J2EE实验指南
彭代文
20##年十二月
目 录
目 录... 2
实验一 Tomcat+JSP配置... 3
实验二 JSP程序的编写... 6
实验三 JDBC的应用... 11
实验四 SERVLET编程... 15
实验五 JavaBean. 19
实验六 EJB. 23
实验七 XML. 24
实验八... 25
实验一 Tomcat+JSP配置
一、 目的
1、 掌握Tomcat+JSP的一般配置
2、 理解基于MVC开发模式的一般形式
二、 准备工作
1、 JDK及JRE的安装
JDK即平常说的java环境，也就是J2SE所用的开发环境，也称J2SDK。可在sun官方站（http://java.sun.com）下载得到。注意：在不同平台有不同的安装包，windows平台请下载Windows Offline Installation的SDK，目前新的版本为1.6。
我们采用JDK1.5版本，其安装文件名为：
j2sdk-1_4_2_04-windows-i586-p.exe
执行此文件，安装过程中选择一个安装目录，我们假定JDK安装在D:\JAVA\jdk1.5下（这个目录仅用于实验演示，可安装在其它目录中，有关配置均需要将此目录路径替换成实际安装的目录路径）。如果需要它的HTML格式API帮助，可解压文件j2sdk-1_4_2-doc.zip到D:\JAVA\jdk1.5\doc目录下。
JRE即J2EE的相关开发环境，下载地址同上，安装过程简单，不再说明。将其安装到D:\JAVA\JRE目录即可。目前的版本为5.5。实验所用的文件为java_ee_sdk-5_02-windows-nojdk.exe。注意：有一种包含JDK的JRE。见java_ee_sdk-5_03-windows.exe文件。
2、 TOMCAT的安装
可到TOMCAT的官方网站（http://jakarta.apache.org/site/downloads）下载tomcat。目前的版本为6.0。我们可使用评价较好的5.0或5.5版本。安装过程也较简单，安装过程选择全全部安装，且将其安装到D:\TOMCAT下即可。
3、 关于其它组件
web应用程序开发过程中，需要大量的相关组件，需要时我们下载它们，并放入相应的目录中，如JDBC与SQL连接进需要SQL驱动程序包，则下载SQL for JDBC的驱动(其中有三个包分别是msbase.jar,msutil.jar,mssqlserver.jar)，应用是将其放到相应的应用程序目录下的/WEB_INF/LIB目录下就可以了。常用的组件有JDBC驱动，struts,hibernate,spring等等
三、 步骤
1、 开发环境配置
我的电脑右击->属性->高级->环境变量，在弹出的对话框中修改或新建如下变量：
注：①%path%代表原path值；
②Apache_home与Catalina_home可不要，如果应用程序配置了Apache，则最好加上。
配置完环境变量后，启动tomcat服务器，然后在IE的地址栏中输入：
http://localhost:8080/
如能看到Tomcat主页，则说明环境变量配置已成功，接着可进入下一步。
2、 建立应用程序目录
1.到Tomcat的安装目录的webapps目录，可以看到ROOT，examples, tomcat-docs之类Tomcat自带的的目录；
2.在webapps目录下新建一个目录，起名叫myapp；
3.myapp下新建一个目录WEB-INF，注意，目录名称是区分大小写的；
4.WEB-INF下新建一个文件web.xml，内容如下：
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE web-app
PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd">
<web-app>
<display-name>My Web Application</display-name>
<description>
A application for test.
</description>
</web-app>
(也可以不写，从wepapps/ROOT/WEB-INF/目录下将web.xml文件拷贝过来即可。)
5.在myapp下新建一个测试的jsp页面，文件名为index.jsp，文件内容如下：
<html><body><center>
Now time is: <%=new java.util.Date()%>
</center></body></html>
6.重启Tomcat
7.打开浏览器，输入http://localhost:8080/myapp/index.jsp 看到当前时间的话说明就成功了。
3、 应用程序相关配置
略，参考提供文档。实地进行对sevser.xml文件进行应用程序目录迁移、URL地址等的修改。并观察实际效果。
四、 总结
五、 问题
1、 配置时path与classpath各起什么作用？在classpath中为何要加入”.;”。
2、 .xml文件起何作用？
3、 http://localhost::8080/的含义是什么？
4、 假设在webapps下有如下路径：/helloapp/hello.jsp，那么要访问hello.jsp，应在浏览器中输入什么？
5、 Server.xml文件中的配置包括哪些内容？
实验二 JSP程序的编写
一、 目的
1. 掌握JSP程序的编写方法
2. 掌握JSP脚本及表达式的基本用法
3. 掌握使用URL向JSP传递参数。
二、 基础知识
理解JSP工作机制及特点。摘要如下：
1. JSP（JAVA SERVER PAGES）是由Sun 公司在java语言上开发出来的一种动态网页制作技术，其可使您可以将网页中的动态部分和静态的HTML相分离。可使用平常的工具并按照平常的方式来书写HTML语句。然后，将动态部分用特殊的标记嵌入即可，这些标记常常以“<%”开始并以“%>”结束。
2. 通常，文件以“.jsp”为扩展名，并可将它放置到任何可以放置普通WEB页面的路径下。尽管JSP文件看起来更象是HTML文件而不是Servlet文件，但事实上，它恰恰将转换为Servlet文件，其中的静态HTML仅仅用来输出Servlet服务方法返回的信息。如果JSP pages 已经被转换为Servlet且Servlet 被编译进而被装载（在第一次被Request时），当您再次Request 此JSP页面时，将察觉不到一瞬的延迟。也请留意这个现象，一些Web Servers允许您为它定义别名，从而，好象一个URL是指向一个HTML，但事实上它指向的是一个Servlet 或JSP pages.
3. 构造一个JSP page，除了可内嵌的规则的HTML，还有三类主要的JSP元素：scripting elements,Directives和 Actions。使用scripting elements可定义最终转换为Servlet的部分，Directives 使您可以控制这个Servlet的整体结构，而Actions则可以指定可重用的已有组件，另外，还可控制JSP引擎的运行。
4. JSP语法：参见课本及一些课外读物。
三、 实验步骤
1. JSP Directives and Scripting Elements(JSP指令及脚本元素)
1)、编写一普通HTML页面(getuser.html)，此页面将调用JSP页面(Customer.jsp)，将这些文件置于TOMCAT的webapps\myprog文件夹中。启动TOMCAT后，在浏览器中输入http://localhost:8080/myprog/ getuser.html后，点击超级链接，观察输出结果。代码如下：
Customer.jsp代码：
<html>
<body bgcolor=wheat>
<%
String name=request.getParameter(“text1”);
String id=request.getParameter(“text2”);
%><font color=red>
<b>Welcome To JSP <%=name %> your id is <%=id %>
</b>
</font>
</body>
</html>
getuser.html代码：
<html>
<body bgcolor=”wheat”>
<form action=”http://localhost:8080/myprog/Customer.jsp”>
Customer Name: <input type=text name=text1>
Customer Id : <input type=text name=text2>
<input type=submit value=Enter>
<input type=reset value=Clear>
</form>
</body>
</html>
作为练习，理解如下JSP代码。在浏览器中多次调用后，结果如何？
Count.jsp
<html>
<body>
<h1> This is a scriptlet example </h1>
<b><font color=red>
<%! Int I=0; %>
<% I++; %>
Hello world ! <%=”This JSP has been accessed “ + I +” times” %>
</font></b>
</body>
</html>
2. JSP Predefined Variables(预定义变量)
阅读下面各段代码并作相应的上机练习，理解在JSP中各种变量的定义、使用。
1)
<%@ page contentType=”text/html; charset=GBK” %>
<html>
<body bgcolor=”#ffcccc”>
Country: <%= request.getLocale().getDisplayCountry() %>
<br>Language:<%= request.getLocale().getDisplayLanguage() %>
</body>
</html>
2)
<html>
<body bgcolor=”#ffccac”>
<b>HTTP method:</b> <%= request.getMethod() %><br>
<b>IP Address:</b> <%= request.getRemoteAddr()%><br>
<b>DNS Name (or IP Address again):</b> <%= request.getRemoteHost()%>
</body>
</html>
3)
null.jsp
<%@ page errorPage=”myerror.jsp” %>
<html>
<body>
Null pointer is generated below:
<%
String s=null;
s.length();
%>
</body>
</html>
myerror.jsp
<%@ page isErrorPage=”true” %>
<html>
<body>
Here is your error:
<%= exception %>
</body>
</html>
3. JSP Actions(JSP动作)
阅读下面代码并作相应的上机练习，理解在JSP中动作的产生及处理。
First.jsp
<HTML>
<HEAD>
<TITLE>first.jsp</TITLE>
</HEAD>
<BODY>
<P>
<H1>This is the main document</H1>
<P>
Including second.jsp file using jsp:include
<BR>
<jsp:include page=”second.jsp” flush=”true”/>
<BR>
<P>
</BODY>
<HTML>
second.jsp
<HTML>
<HEAD>
<TITLE>second.jsp</TITLE>
</HEAD>
<BODY>
<P>
<HR>
<H3>This is the second document</H3>
<%! Int visits=0; %>
<%
visits++;
%>
<%= “VISITORS : “ + visits %>
<P>
<HR>
</BODY>
<HTML>
四、 总结
五、 问题
1、 浏览器调用一JSP页面时，后台服务器作怎样的处理过程？
2、 <jsp:include page=” ” flush=”true”> 与<%@ include file=” ” %>有何区别？
3、 课后请查阅相关JSP与ASP的比较。
实验三 JDBC的应用
一、 目的
1. 掌握JDBC在与数据库相连时的步骤。
2. 掌握JDBC与常用数据库的连接方法
二、 基础知识
掌握java中常用的二种数据库的连接与操作方式：即ODBC与JDBC。
具体内容请参考课件。重点应放在JDBC上。JDBC在使用基本上按如下方式进行：
1)、注册和加载JDBC驱动程序
2)、建立连接
3)、构造 SQL 语句
4)、提交查询
5)、返回ResultSet
6)、显示结果
7)、关闭Statement和Connection
三、 实验步骤
1、掌握ODBC的使用
通读下例并上机运行，掌握JAVA是如何通过ODBC操纵数据库的。
ProductDos.jsp
import java.sql.*;
import java.io.*;
public class ProductDos {
public static void main(String args[]) {
try {
Connection conn;
Statement stmt;
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String input;
int prodID, prodPrice, discount;
String prodName;
System.out.print("Product ID:");
input = br.readLine();
prodID = new Integer(input).intValue();
System.out.print("Product Name:");
prodName = br.readLine();
System.out.print("Product Price:");
input = br.readLine();
prodPrice = new Integer(input).intValue();
System.out.print("Discount:");
input = br.readLine();
discount = new Integer(input).intValue();
System.out.println("Connecting to the database...");
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
conn = DriverManager.getConnection("jdbc:odbc:oradsn", "scott","tiger");
System.out.println("Connected to the database...");
stmt = conn.createStatement();
String query = "insert into product values(" + prodID + ",'" + prodName +"'," + prodPrice + "," + discount + ")";
stmt.execute(query);
System.out.println("Database Updated...");
stmt.close();
conn.close();
}
catch (Exception e) {}
}
}
注：oradsn为odbc的配置文件。
1、掌握JDBC的使用
A、 准备驱动程序
要使用JDBC连接数据库的话，需要向服务器中的相关容器注册相应的数据库驱动程序。这些驱动程序恰恰也是解释或执行相应SQL语句的核心。如果没有这些驱动程序，则应用程序就不能读取数据库中的数据。
为了建立与数据库的连接，我们第一步要做的，就是准备相应数据库的驱动程序。不同类型的数据库都建立了一套与JAVA兼容的驱动程序。如SQL Server，它就建立了三个包(即MSBASE.JAR;MSUTIL.JAR;MSSQLSERVER.JAR)。不同的数据库产品，都有它们相应的for java的驱动程序包。需要时请同学们到网上搜索下载。本实验使用SQL SERVER 2000数据库产品，需要的包已经提供。
关于驱动程序包的加载问题，请同学们将它们可拷贝至%Tomcat%\LIB或应用程序目录中的\WEB-INF\LIB中。
B、 建立数据库
在数据库里建一个表test，有两个字段比如为test1，test2，可以用下面SQL建立；
create table test(test1 char(20),test2 char(20));
然后向这个表写入一条测试纪录
或在不修改代码下直接应用SQL实例数据库pubs.
C、 利用JSP建立与数据库的连接
注意下述代码中与数据库连接的一般步骤。
testsqlserver.jsp
<%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="java.sql.*"%>
<html>
<body>
<%Class.forName("com.microsoft.jdbc.sqlserver.SQLServerDriver").newInstance();
String url="jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=pubs";
//pubs为你的数据库的
String user="sa";
String password="";
Connection conn= DriverManager.getConnection(url,user,password);
Statement stmt=conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_UPDATABLE);
String sql="select * from test";
ResultSet rs=stmt.executeQuery(sql);
while(rs.next()) {%>
您的第一个字段内容为：<%=rs.getString(1)%>
您的第二个字段内容为：<%=rs.getString(2)%>
<%}%>
<%out.print("数据库操作成功，恭喜你");%>
<%rs.close();
stmt.close();
conn.close(); %>
</body>
</html>
D、 常用数据库连接实例
略，请参见课件附加文件《JAVA数据库连接大全》
四、 总结
五、 问题
1、已知SQL数据库manager含有表student的结构为：student(id,name,sex)，登录此数据库的登录帐号为“sa”“sa”。SQL的驱动程序包已经位于/WEB-INF/LIB/下。
编写一JavaBean，要求能将表的内容读入到结果集rs对象中。请完成该JavaBean的如下两个方法：
方法1：public static java.sql.Connection connectToDb( )用于对数据库进行连接用。
方法2：public void UpdateDb( )用于执行SQL数据修改语句。
方法3：public void ExecuteSQL( )用于执行SQL语句，并将结果存入结果集rs对象中。
2、数据库连接不上，可能的原因有哪些？
实验四 SERVLET编程
一、 目的
1) 掌握tomcat下配置servlet
2) 理解servlet的运行机制及编程时常用方法的作用
3) 掌握servlet的编写规则
二、 基础知识
1)、Servlets是一种采用JAVA技术来实现CGI功能的一种技术。Servlet和CGI一样都是运行在WEB服务器上，用来生成WEB页面。
2)、Servlets的执行过程如下：
Ø 用户在浏览器中输入一个 URL。Web 服务器配置文件确定该 URL 是否指向一个由运行于服务器上的 servlet 容器所管理的 servlet。
Ø 如果还没有创建该 servlet 的一个实例（一个应用程序只有一个 servlet 实例），那么该容器就加载该类，并将之实例化。
Ø 该容器调用 servlet 上的 init()。
Ø 该容器调用 servlet 上的 service()，并在包装的 HttpServletRequest 和 HttpServletResponse 中进行传递。
Ø 该 servlet 通常访问请求中的元素，代表其他服务器端类来执行所请求的服务并访问诸如数据库之类的资源，产生发送到客户端的数据，通过response对象发送到客户端，servlet处理结束之后,container会确保response被flush了
如果有必要，在 servlet 的有用生命结束时，该容器会调用 servlet 上的 destroy() 来清除它。
3)、Servlet常用方法
init方法：
Ø 设置全局参数变量
Ø 程序运行前的必要性检查
Ø 启动后台任务线程
destory方法：
Ø 释放资源，注意：destory方法在容器关闭时不一定能执行完。
service方法：
Ø javax.servlet.http.HttpServlet 中的方法，一般在servlet中不过载此方法。
Ø Service方法在执行时会调用doGet和doPost方法。
doGet和doPost方法：
在servlet中的主要实现方法。
Ø 在通常的servlet中只有这两个或其中一个方法。
Ø 对应处理get和post方式的请求
三、 实验步骤
1、新建一个servlet程序，文件名为Test.java，文件内容如下：
Package test;
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class Test extends HttpServlet {
protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
PrintWriter out=response.getWriter();
out.println("<html><body><h1>This is a servlet test.</h1></body></html>");
out.flush();
}
}
2、编译servlet
将Test.java放在c:\test下，使用如下命令编译：
C:\Test>javac Test.java
然后在c:\Test下会产生一个编译后的servlet文件：Test.class
将文件test\Test.class剪切到%CATALINA_HOME%\webapps\myapp\
WEB-INF\classes下，也就是剪切那个test目录到classes目录下，如果classes目录不存在，就新建一个。现在webapps\myapp\WEB-INF\classes下有test\Test.class的文件目录结构。
3、配置servlet
修改webapps\myapp\WEB-INF\web.xml，添加servlet和servlet-mapping。
编辑后的web.xml如下所示：
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE web-app
PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd">
<web-app>
<display-name>My Web Application</display-name>
<description>
A application for test.
</description>
<servlet>
<servlet-name>Test</servlet-name>
<display-name>Test</display-name>
<description>A test Servlet</description>
<servlet-class>test.Test</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>Test</servlet-name>
<url-pattern>/Test</url-pattern>
</servlet-mapping>
</web-app>
说明：A、<servlet>……</servlet> 这一段声明了要调用的Servlet，而<servlet-mapping>……</servlet-mapping>则是将声明的servlet“映射”到地址/Test上
B、如果用IE打开web.xml文件，不正确显示，则说明XML文件中有语法错误。
4、好了，启动Tomcat，启动浏览器，输入http://localhost:8080/myapp/Test 如果看到输出This is a servlet test.就说明编写的servlet成功了。
注意：修改了web.xml以及新加了class，都要重启Tomcat
四、 总结
五、 问题
1、servlet有何用途？
2、servlet为何要进行配置？
3、servlet与java bean的区别是什么？
4、servlet的配置中各标记的含义是什么？
5、假设在helloapp应用中有一个HelloServlet类，它在web.xml文件中的配置如下:
<servlet>
<servlet-name>HelloServlet</servlet-name>
<servlet-class>org.javathinker.HelloServlet
</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>HelloServlet</servlet-name>
<url-pattern>/hello</url-pattern>
</servlet-mapping>
那么在浏览器端访问HelloServlet的URL是什么？
实验五 JavaBean
一、 目的
3. 掌握JavaBean程序的编写方法
4. 理解JavaBean的基本概念及其功能
5. 掌握在jsp页面间利用JavaBean来传递获取数据。
二、 基础知识
1、javabean 是什么？
Ø Javabean 就是一个类，这个类就定义一系列 get<Name> 和 set<Name> 方法。
Ø Javabean 就是为了和 jsp 页面传数据化简交互过程而产生的。
2、使用 javabean 和不用 javabean 的区别：
Ø 一个 javabean 就是为 jsp 页面上的元素一一开辟一个空间，然后根据需要赋值、读值。而如果不用 javabean ，就直接使用 HttpServlet 的 request 对象：
Ø 只在 jsp 页面间传递获取数据：
3、Javabean的两种使用方式
Ø jsp 中嵌入 java 代码方式访问：即当一般类使用
Ø jsp 中使用 <jsp:useBean> 标记符访问
4、使用Javabean的好处：
Ø 实现组件重用，可增强代码的可维护性。
具体内容请参见课件及课外阅读文档《javabean学习日记》
三、 实验步骤
以下用建立一个用户注册登陆小模块实例，来说明Javabean的编制过程。
1、在SQL SERVER 20## 中建立数据库MYDB，新建一个表user_Info，包含如下两个字段(字符型)：username及passwords。顺便添加一些记录。
1、建立javabean类
①、建立一个javabean类用来封装用户的信息（姓名和密码），以方便JSP传递获取数据。注意，这个类中建立起了一系列getXXX()和setXXX()方法。
UserInfo.java
package user;//存放UserInfo.java的包，该包中放在web-inf目录下
public class UserInfo
{
private String password;
private String name;
//获取信息
public String getPassword()
{
return this.password;
}
public String getName()
{
return this.name;
}
//设置信息
public void setPassword(String p)
{
this.password=p;
}
public void setName(String n)
{
this.name=name;
}
}
②建立另一个javabean用以处理数据库操作以及一些简单的逻辑操作。
UserRegist.java
import java.sql.*;
public class UserRegist
{
private UserInfo userInfo;//在此javabean中把UserInfo.java这个javabean引进来
private Connection conn=null;
//连接数据库
public UserRegist()
{
try
{
Class.forName("com.microsoft.jdbc.sqlserver.SQLServerDriver").newInstance();;
conn=DriverManager.getConnection("jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=MYDB",”sa”,””);
}
catch(Exception e)
{
e.printStackTrace();
}
}
public void setUserInfo(UserInfo userInfo)
{
this.userInfo=userInfo;
}
//进行注册
public void regist()throws Exception
{
String reg="insert into user_Info values(?,?)";
try
{
PreparedStatement pstmt=conn.prepareStatement(reg);
//create a preparestatement sentence ,then to set their name
pstmt.setString(1,userInfo.getPassword());
pstmt.setString(2,userInfo.getName());
//excute update
pstmt.executeUpdate();
}
catch(Exception e)
{
e.printStackTrace();
throw e;
}
}
}
将上述两个文件编译后，将相应的.class文件放至相应的目录中，①放入web-inf\ user下，②放入web-inf目录中。
2、做一个简单的表单html页面了(login.html)，用以接受用户输入的信息。
login.html
<form action="regist.jsp" name="form1">;
<table>;
<tr>;
<td>; username:</td>;
<td>;<input name="name">;</input>;</td>;
</tr>;
<tr>;
<td>;userpassword:</td>;
<td>;<input type="password" name="password">;</input>;</td>;
</tr>;
<tr>;
<td>;<input type="submit" value="go">;</td>;
<td>;<input type="reset" value="reset">;</td>;
<table>;
</form>;
将此页面直接置于应用程序目录中。
3、最后要做的事就是用一个简单的jsp页面让两个javabean工作起来
regist.jsp
<%@page contentType="text/html;charset=GB2312"%>;
//利用此标签来调用UserInfo.java
<jsp:useBean id="userInfo" class="user.UserInfo" scope="page">;
//利用此标签来用UserInfo.java接受并保存表单中的信息
<jsp:setProperty name="userInfo" property="*"/>;
</jsp:useBean>;
//来调用UserRegist.java
<jsp:useBean id="regist" class="user.UserRegist" scope="page"/>;
<%
regist.setUserInfo(userInfo);//调用UserRegist.java中的setUserInfo（）方法获取保存在serInfo.java中的信息
regist.regist( );//调用UserRegist.java中的regist( )方法进行注册
out.println("registed ok!");
%>;
<br>;<hr>;<br>;
<a href="login.jsp">;back</a>;
将此页面直接置于应用程序目录(假定为myapps)中。
4、启动Tomcat后，在IE中输入http://localhost:8080/myapps/login.html，在页面试着登录看看。
四、 总结
五、 问题
1. 使用JavaBean的好处是什么？
2. JavaBean与Servlet有何区别？与常规的JAVA类有何区别？
实验六 EJB
一、 目的
3. 掌握EJB的开发流程
4. 掌握EJB的基本类型及基本开发方法
二、 基础知识
有关EJB的基础知识见课件或课本。此处不再详细介绍。下面简单介绍一下JBOSS。
JBoss 4.0自动集成了Tomcat 5.0，因而它不仅仅是专业的EJB容器，同时也成了专业的JSP/servlet容器和Web服务器。
Tomcat 5.0 被集成在 jboss的下面这个目录中：
JBOSS_HOME\server\default\deploy\jbossweb-tomcat50.sar
里面提供了一个server.xml和web.xml文件，可以对Tomcat进行一些基本设置。但JBOSS的设计者建议用户甚至不要接触这个目录，更不用说修改和添加什么文件了，因为Tomcat与Jboss是如此紧密相连，以致于所有的设置工作都可以在Jboss自己的配置文件中完成。
安装：将文件jboss-4.0.5.GA.zip直接解压至指定的文件夹中。譬如：D:\jboss_tomcat。
配置：基本上不要什么配置的，只要安装好了JDK，当然，最好将TOMCAT_HOME加到CLASSPATH中。这样，d:\jboss_tomcat\jboss2\bin\run_with_tomcat.bat这个文件前的TOMCAT_HOME就可以去掉了。
运行d:\jboss_tomcat\jboss2\bin\run_with_tomcat.bat这个文件，这样，Tomcat端口在8080，Jboss为8083，
运行http://localhost:8080/将出现tomcat首页，
运行http://localhost:8083/将出现无错误的空白页，
三、 实验步骤
本文演示了JSP页面如何在jboss 4.0中调用EJB组件。
总结构：
J2EE应用/
|__EJB组件/(haiejb.jar)
| |__META-INF/
| | |__ejb-jar.xml
| | |__jboss.xml
| |__ejbs/
| |__HaiHome.class
| |__HaiClient.class
| |__HaiBean.class
|__WEB应用/(haiejb.war)
| |__haiejb.jsp
| |__WEB-INF/
| |__web.xml
| |__jboss-web.xml
|__META-INF/
|__application.xml
一、编译java文件为EJB类文件
java文件编译：
[假定在系统环境变量的CLASSPATH中包含了javax.ejb.*包，该包可以在以下地方找：
JBOSS_HOME\server\default\lib\jboss-j2ee.jar
JBOSS_HOME\client\jboss-j2ee.jar]
[java源文件目录]＞:javac -classpath %classpath% -d [输出目录：EJB组件目录] *.java
HaiHome.java:
package ejbs;
import java.io.Serializable;
import java.rmi.*;
import javax.ejb.*;
public interface HaiHome extends EJBHome {
HaiClient create() throws RemoteException, CreateException;
}
HaiClient.java:
package ejbs;
import javax.ejb.*;
import java.rmi.RemoteException;
public interface HaiClient extends EJBObject {
public String sayHai() throws RemoteException;
}
haiBean.java:
package ejbs;
import javax.ejb.*;
import javax.naming.*;
public class HaiBean implements SessionBean {
public String sayHai() {
return "Hai, EJB technology!";
}
public void ejbCreate() throws EJBException {}
public void ejbRemove() throws EJBException {}
public void ejbPassivate() {}
public void ejbActivate() {}
public void setSessionContext(SessionContext sc) {}
}
二、创建EJB组件：
haiejb.jar:(EJB组件）
打包命令：[EJB组件目录]＞:jar cvf haiejb.jar META-INF/ ejbs/
|__META-INF/
| |__ejb-jar.xml
| |__jboss.xml
|__ejbs/
|__HaiHome.class
|__HaiClient.class
|__HaiBean.class
ejb-jar.xml:
＜?xml version="1.0" encoding="UTF-8"?＞
＜!DOCTYPE ejb-jar PUBLIC ’-//Sun Microsystems, Inc.//DTD Enterprise JavaBeans 2.0//EN’ ’http://java.sun.com/dtd/ejb-jar_2_0.dtd’＞
＜ejb-jar＞
＜description＞Hai EJB instance.＜/description＞
＜display-name＞Hai EJB＜/display-name＞
＜enterprise-beans＞
＜session＞
＜ejb-name＞HaiEJB＜/ejb-name＞
＜home＞ejbs.HaiHome＜/home＞
＜remote＞ejbs.HaiClient＜/remote＞
＜ejb-class＞ejbs.HaiBean＜/ejb-class＞
＜session-type＞Stateless＜/session-type＞
＜transaction-type＞Bean＜/transaction-type＞
＜/session＞
＜/enterprise-beans＞
＜/ejb-jar＞
jboss.xml:
＜?xml version="1.0" encoding="UTF-8"?＞
＜jboss＞
＜enterprise-beans＞
＜session＞
＜ejb-name＞HaiEJB＜/ejb-name＞
＜jndi-name＞HaiEJB＜/jndi-name＞
＜/session＞
＜/enterprise-beans＞
＜/jboss＞
三、创建WEB应用
haiejb.war:(WEB应用）
打包命令：[WEB应用目录]＞:jar cvf haiejb.war haiejb.jsp WEB-INF/
|__haiejb.jsp
|__WEB-INF/
|__web.xml
|__jboss-web.xml
haiejb.jsp:
＜%@ page contentType="text/html;charset=GBK" %＞
＜%@ page import="ejbs.*,javax.ejb.*,javax.naming.*,javax.rmi.PortableRemoteObject,java.rmi.RemoteException" %＞
＜html＞
＜body＞
＜% String message = "nothing!";
try {
InitialContext ic = new InitialContext();
Object objRef = ic.lookup("HaiEJB");
HaiHome home = (HaiHome) PortableRemoteObject.narrow(objRef,ejbs.HaiHome.class);
HaiClient haiRemote = home.create();
message = haiRemote.sayHai();
} catch (RemoteException re) {
re.printStackTrace();
} catch (CreateException ce) {
ce.printStackTrace();
} catch (NamingException ne) {
ne.printStackTrace();
}
%＞
＜h1＞＜%=message%＞＜/h1＞
＜/body＞
＜/html＞
web.xml:
＜?xml version="1.0" encoding="UTF-8"?＞
＜!DOCTYPE web-app PUBLIC ’-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN’ ’http://java.sun.com/dtd/web-app_2_3.dtd’＞
＜web-app＞
＜ejb-ref＞
＜ejb-ref-name＞HaiEJB＜/ejb-ref-name＞
＜ejb-ref-type＞Session＜/ejb-ref-type＞
＜home＞ejbs.HaiHome＜/home＞
＜remote＞ejbs.HaiClient＜/remote＞
＜/ejb-ref＞
＜/web-app＞
jboss-web.xml:
＜?xml version="1.0" encoding="UTF-8"?＞
＜jboss-web＞
＜ejb-ref＞
＜ejb-ref-name＞HaiEJB＜/ejb-ref-name＞
＜jndi-name＞HaiEJB＜/jndi-name＞
＜/ejb-ref＞
＜/jboss-web＞
四、创建J2EE应用程序
haiejb.ear: (J2EE应用程序）
把上面创建的haiejb.jar和haiejb.war包拷贝到你创建的J2EE应用主目录，新建一个META-INF目录并在里面创建application.xml文件：
打包命令：[J2EE应用目录]＞:jar cvf haiejb.ear haiejb.jar haiejb.war META-INF/
|__haiejb.jar
|__haiejb.war
|__META-INF/
|__application.xml
application.xml:
＜?xml version="1.0" encoding="UTF-8"?＞
＜application＞
＜display-name＞HaiEJB J2EE Application＜/display-name＞
＜module＞
＜web＞
＜web-uri＞haiejb.war＜/web-uri＞
＜context-root＞/haiejb＜/context-root＞
＜/web＞
＜/module＞
＜module＞
＜ejb＞haiejb.jar＜/ejb＞
＜/module＞
＜/application＞
五、部署J2EE应用：
把haiejb.ear拷贝到JBOSS_HOME\server\default\deploy\
启动jboss 4.0,注意命令行窗口中有无异常，如果有异常情况，请查看log文件：
JBOSS_HOME\server\default\log\server.log
从中查找分析问题所在，然后改正之,直到无异常显示
最后在浏览器地址栏中键入：
http://localhost:8080/haiejb/haiejb.jsp
结果：
Hai, EJB technology!