EJB3,Spring,Struts2整合

    我是一个EJB3.0的新手 ，经过几天的搜索资料和自己的许多次测试，终于实现了ejb3、spring、struts2的整合，在这里写明一下简单的实现过程，希望对新入门的网友有所帮助，也请高手们不要拍砖，多多提出您的意见，在此感谢大家。

   下面就开始我们的整合过程，我的开发工具是Myeclipse6.5，Mysql5。

一、建立一个数据库的连接

 

    打开myeclipse中的DBbrowser工具，新建一个MySql的数据库连接，如下图：

点击finish完成数据库连接的创建。

二、创建一个Enterprise Application Project

         在myeclipse中新建工程，打开新建对话框，选择如下的工程类型：

一直点解next到下面的设置对话框，进行图片中标注的设置：

再点击next到下面的设置对话框，进行标注的设置：

点击finish完成工程的创建。

三、编写EJB3模块

        在项目列表中选择刚才创建的EJBStrutsEJB，将src/META-INF下的persistence.xml内容修改成如下的内容：

1. <?xml version="1.0" encoding="UTF-8"?>
2. <persistence xmlns="http://java.sun.com/xml/ns/persistence"
3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4.     xsi:schemaLocation="http://java.sun.com/xml/ns/persistence
5.     http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd" version="1.0">
6.     
7.     <persistence-unit name="EJB3EJBPU" transaction-type="JTA">
8.         <jta-data-source>java:/MySqlDS</jta-data-source>
9.         <properties>
10.        
11. vv     <property name="hibernate.hbm2ddl.auto" value="create-drop"/>
12.             <property name="hibernate.show_sql" value="true"/>
13.         </properties>
14.     </persistence-unit>
15.   
16. </persistence>

1.打开DBbrowser中建立的数据库连接struts2，然后找到为工程建立的数据库struts2，找到要建立实体bean（Entity Bean）的表（我的是用了一个UserInformation表，建表语句：

create table `struts2`.`userinformation`(
        `UserLoginId` CHAR(20) default '' not null,
       `UserPassword` CHAR(20) default '' not null,
       `UserName` VARCHAR(20),
       `UserAge` INT,
       `Occupation` VARCHAR(50),
        primary key (`UserLoginId`)
    );），点击右键，选择下图所示的选项：

点击next进入下面的设置：

一直点击next到输入类名的对话框：

在产生的包名上点击右键新建一个EJB3 Session Bean：

在两个接口文件中定义个方法：

UserInformation findById(String userLoginId);

在session bean：UserInformtionDAO中实现此方法，代码如下：

1. package com.ejb3.entity;
3. import javax.ejb.Stateless;
4. import javax.persistence.EntityManager;
5. import javax.persistence.PersistenceContext;
7. @Stateless
8. public class UserInformationDAO implements UserInformationDAOLocal,
9.         UserInformationDAORemote {
11.     @PersistenceContext
12.     private EntityManager em;
13.     public UserInformation findById(String userLoginId) {
14.         // TODO Auto-generated method stub
15.         UserInformation user = em.find(UserInformation.class,userLoginId);
16.         return user;
17.     }
19. }

 

到此工程的EJB模块设置完成。下面我们进行Web模块的设置。

 

四、设置web模块

    1、打开新建工程时产生的EJB3StrutsWeb工程，在WebRoot/WEB-INF/lib下加入Struts2、spring等相关的包，并加入到buildpath。在WEB-INF下建立一个名为jndi.properties的配置文件，内容如下：

java.naming.factory.initial=org.jnp.interfaces.NamingContextFactory
java.naming.provider.url=localhost/:1099

建立web.xml文件，内容如下：

1. <?xml version="1.0" encoding="UTF-8"?>
3. <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" id="WebApp_ID" version="2.5">
5.   <display-name>EJB3Struts</display-name>
7.   <context-param>
9.         <param-name>contextConfigLocation</param-name>
11.         <param-value>classpath:applicationContext*.xml</param-value>
13.     </context-param>
15.   <context-param>
17.     <param-name>log4jConfigLocation</param-name>
19.     <param-value>classpath:log4j.properties</param-value>
21.   </context-param>
23.   <filter>
25.         <filter-name>EJB3Struts</filter-name>
27.         <filter-class>org.apache.struts2.dispatcher.FilterDispatcher</filter-class>        
29.     </filter>   
33.     <filter-mapping>
35.         <filter-name>EJB3Struts</filter-name>
37.         <url-pattern>/*</url-pattern>
39.     </filter-mapping>
41.     <listener>
43.         <listener-class>org.springframework.web.util.Log4jConfigListener</listener-class>
45.     </listener>     
47.     <!-- Listener contextConfigLocation -->
49.     <listener>
51.         <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
53.     </listener>
55.     
57.   <welcome-file-list>
59.     <welcome-file>index.jsp</welcome-file>
61.   </welcome-file-list>
63. </web-app>

    2、在src源文件夹下建立如下的配置文件：

struts.properties：

struts.objectFactory = spring

 

log4j.properties:

log4j.rootLogger=info,console
log4j.appender.console=org.apache.log4j.ConsoleAppender
log4j.appender.console.layout=org.apache.log4j.SimpleLayout
log4j.logger.com.wehave=DEBUG
log4j.logger.java.sql.Connection=DEBUG
log4j.logger.java.sql.Statement=info
log4j.logger.java.sql.PreparedStatement=info
log4j.logger.java.sql.ResultSet=info
log4j.logger.javax.sql=info

 

spring配置文件applicationContext.xml:

 

 

1. <?xml version="1.0" encoding="UTF-8"?>
2. <beans xmlns="http://www.springframework.org/schema/beans"
3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4.     xmlns:jee="http://www.springframework.org/schema/jee"
5.     xmlns:util="http://www.springframework.org/schema/util"
6.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd 
7.     http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-2.5.xsd
8.      http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-2.5.xsd">
11.     <bean id="propertyConfigurer"
12.         class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
13.         <property name="locations">
14.             <list>
15.                 <value>classpath:jboss.properties</value>
16.             </list>
17.         </property>
18.     </bean>
19.     <util:properties id="evn" location="/WEB-INF/jndi.properties">
20.     </util:properties>
22.     <jee:jndi-lookup jndi-name="EJB3Struts/UserInformationDAO/remote"
23.         id="userInformationDAO" lookup-on-startup="true" cache="true"
24.         proxy-interface="com.ejb3.entity.UserInformationDAORemote"
25.         environment-ref="evn">
26.     </jee:jndi-lookup>
27.     <bean id="getUserAction" class="com.ejb3.action.GetUserAction">
28.         <property name="userInformationDAO">
29.             <ref local="userInformationDAO" />
30.         </property>
31.     </bean>
32. </beans>

struts配置文件struts.xml:

1. <?xml version="1.0" encoding="UTF-8" ?>
2. <!DOCTYPE struts PUBLIC
3.     "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
4.     "http://struts.apache.org/dtds/struts-2.0.dtd">
6. <struts>
7.     <package name="EJB3Struts" extends="struts-default">        
8.         <action name="getUser" class="getUserAction" method="showUser">
9.             <result>jsp/showuser.jsp</result>
10.         </action>
11.     </package>
12. </struts>

 

4、创建action文件，类名为GetUserAction：

1. package com.ejb3.action;
3. import com.ejb3.entity.UserInformation;
4. import com.ejb3.entity.UserInformationDAORemote;
5. import com.opensymphony.xwork2.ActionContext;
6. import com.opensymphony.xwork2.ActionSupport;
8. public class GetUserAction extends ActionSupport {
10.     /**
11.      * 
12.      */
13.     private static final long serialVersionUID = -4140397287976560677L;
15.     private UserInformationDAORemote userInformationDAO;
17.     public String showUser() {
18.         String userLoginId = "ceshi1";//数据库中存在的一个账号
19.         UserInformation user = userInformationDAO.findById(userLoginId);
20.         ActionContext.getContext().put("user", user);
21.         return SUCCESS;
22.     }
24.     public UserInformationDAORemote getUserInformationDAO() {
25.         return userInformationDAO;
26.     }
28.     public void setUserInformationDAO(
29.             UserInformationDAORemote userInformationDAO) {
30.         this.userInformationDAO = userInformationDAO;
31.     }
33. }

 

5、创建jsp文件

   1）修改生成的index.jsp文件内容如下：

1. <%@ page language="java" contentType="text/html; charset=UTF-8"
2.     pageEncoding="UTF-8"%>
3. <%@ taglib uri="/struts-tags" prefix="s" %>
4. <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
5. <html>
6. <head>
7. <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
8. <title>导航页</title>
9. </head>
10. <body>
11. <a href="<s:url action='getUser'/>">查询用户</a>
12. </body>
13. </html>

  2）在WebRoot下建立一个文件加专门存放jsp文件，文件夹名称为jsp，在jsp文件夹下建立一个showuser.jsp，内容如下：

1. <%@ page language="java" contentType="text/html; charset=UTF-8"
2.     pageEncoding="UTF-8"%>
3. <%@ taglib uri="/struts-tags" prefix="s" %>
4. <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
5. <html>
6. <head>
7. <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
8. <title>用户信息</title>
9. </head>
10. <body>
11.     <h2>用户信息:</h2>
12.     <p>
13.         <s:text name="userName">
14.             <s:property value="#user.userName"/>
15.         </s:text>
16.     </p>
17. </body>
18. </html>

至此，ejb模块和web模块的编写设置完成，下面进行我们的发布过程。

 

五、发布工程

    1、打开preferences设置对话框，选择Myeclipse Enterprise Workbech，选择servers，找到jboss4.x，设置服务器。

 

    2、发布工程，首先将mysql5的驱动包放到JBOSS_HOME/server/default/lib下，并在server/default/deploy文件夹下添加自己的数据源配置文件，如我的文件为mysql-ds.xml,内容如下：

 

1. <?xml version="1.0" encoding="UTF-8"?>
3. <!-- $Id: mysql-ds.xml 71535 2008-04-01 07:05:03Z adrian@jboss.org $ -->
4. <!--  Datasource config for MySQL using 3.0.9 available from:
5. http://www.mysql.com/downloads/api-jdbc-stable.html
6. -->
8. <datasources>
9.   <local-tx-datasource>
10.     <jndi-name>MySqlDS</jndi-name>
11.     <connection-url>jdbc:mysql://localhost:3306/struts2</connection-url>
12.     <driver-class>com.mysql.jdbc.Driver</driver-class>
13.     <user-name>root</user-name>
14.     <password>root</password>
15.     <exception-sorter-class-name>org.jboss.resource.adapter.jdbc.vendor.MySQLExceptionSorter</exception-sorter-class-name>
16.     <!-- should only be used on drivers after 3.22.1 with "ping" support
17.     <valid-connection-checker-class-name>org.jboss.resource.adapter.jdbc.vendor.MySQLValidConnectionChecker</valid-connection-checker-class-name>
18.     -->
19.     <!-- sql to call when connection is created
20.     <new-connection-sql>some arbitrary sql</new-connection-sql>
21.       -->
22.     <!-- sql to call on an existing pooled connection when it is obtained from pool - MySQLValidConnectionChecker is preferred for newer drivers
23.     <check-valid-connection-sql>some arbitrary sql</check-valid-connection-sql>
24.       -->
26.     <!-- corresponding type-mapping in the standardjbosscmp-jdbc.xml (optional) -->
27.     <metadata>
28.        <type-mapping>mySQL</type-mapping>
29.     </metadata>
30.   </local-tx-datasource>
31. </datasources>

，这种文件在JBOSS_HOME/docs/examples/jca下有很多，可以参考设置自己的数据源。然后点击工具栏中的发布按钮：

打开如下对话框，从中选择EJB3Struts，然后点击Add，按照以下图解进行发布。

 

 

在上面的对话框中选择自己设置的jboss服务器，然后点击finish完成工程的发布。

 

六、测试工程

    1、启动服务，点击工具栏中的服务器按钮，找到自己设置的jboss服务器(在服务器的设置中，要把enable选中在此才能看到自己设置的服务器)，点击start启动服务器。

 

等待服务器启动完毕后，确保启动过程中没有报错。在浏览器中输入http://localhost:8080/EJB3StrutsWeb

显示导航页面，点击页面中的“查询用户”连接，可以显示数据库中对应账号“ceshi1”的用户性别，如下图：

 

如果可以正确的打印出用户姓名，说明我们的整个配置过程是成功的。

 

注：以上过程是我自己研究的过程，不知道是否适合各位网友，有什么问题请大家批评指正。