Spring整合Struts2、Hibernate

作者: Mon7ey | 来源:发表于2018-05-17 11:17 被阅读104次

工作环境

开发工具: MyEclipse 2016

一 .导包

Hibernate

Hibernate必须引入的包:

antlr-2.7.7.jar
dom4j-1.6.1.jar
geronimo-jta_1.1_spec-1.1.1.jar
hibernate-commons-annotations-5.0.1.Final.jar
hibernate-core-5.0.7.Final.jar
hibernate-jpa-2.1-api-1.0.0.Final.jar
jandex-2.0.0.Final.jar
javassist-3.18.1-GA.jar
jboss-logging-3.3.0.Final.jar

Jpa: java persist api ()java持久化规范)

hibernate-entitymanager-5.0.7.Final.jar

数据库驱动:

mysql-connector-java-5.1.7-bin.jar

Struts2

Struts必须包:

asm-3.3.jar
asm-commons-3.3.jar
asm-tree-3.3.jar
commons-fileupload-1.3.1.jar
commons-io-2.2.jar
commons-lang3-3.2.jar
freemarker-2.3.22.jar
javassist-3.11.0.GA.jar
log4j-api-2.2.jar
log4j-core-2.2.jar
ognl-3.0.6.jar
struts2-core-2.3.24.jar
xwork-core-2.3.24.jar

struts2整合spring插件包:

struts2-spring-plugin-2.3.24.jar
// 如果导入这个包Struts2在启动时就会寻找Spring容器
// 如果只导入该报,并未配置Spring容器,会导致报错
// 结论: 在单独使用Struts2时,不要导入此包

Spring

Spring基本包:

spring-beans-4.2.4.RELEASE.jar
spring-context-4.2.4.RELEASE.jar
spring-core-4.2.4.RELEASE.jar
spring-expression-4.2.4.RELEASE.jar
com.springsource.org.apache.commons.logging-1.1.1.jar
com.springsource.org.apache.log4j-1.2.15.jar

整合Web:

spring-web-4.2.4.RELEASE.jar
com.springsource.org.aopalliance-1.0.0.jar
com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar
spring-aspects-4.2.4.RELEASE.jar

整合AOP:

spring-aop-4.2.4.RELEASE.jar
spring-aspects-4.2.4.RELEASE.jar
com.springsource.org.aopalliance-1.0.0.jar
com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar

整合JDBC及事务:

spring-jdbc-4.2.4.RELEASE.jar
spring-orm-4.2.4.RELEASE.jar
spring-tx-4.2.4.RELEASE.jar
com.springsource.com.mchange.v2.c3p0-0.9.1.2.jar

整合junit4测试:test包

spring-test-4.2.4.RELEASE.jar

二 . 配置Spring

1. 创建配置文件并导入约束

在src文件夹下创建applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns="http://www.springframework.org/schema/beans" 
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop" 
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsd 
                        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd 
                        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd 
                        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.2.xsd ">

</beans>

2. 配置spring随web项目启动

在web.xml中配置listener

<!-- 让spring随web启动而创建监听器 -->
<listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<!-- spring配置文件位置参数 -->
<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:applicationContext.xml</param-value>
</context-param>

三 . 配置Struts2

1. 创建配置文件

在src目录下创建struts.xml文件:

<?xml version="1.0" encoding="UTF-8"?>
   <!DOCTYPE struts PUBLIC
    "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
    "http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
    <package name="user" namespace="/"  extends="struts-default">
        
    </package>
</struts>

2. 配置struts2核心过滤器

在web.xml文件夹下配置核心过滤器

<!-- struts2核心过滤器 -->
<filter>
    <filter-name>struts2</filter-name>
    <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
</filter>
<filter-mapping>
    <filter-name>struts2</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

四 . Spring和Struts2整合

创建测试类

UserAction:

public class UserAction extends ActionSupport {
    private UserService userService;
    public String login(){
        return SUCCESS;
    }
    public void setUserService(UserService userService) {
        this.userService = userService;
    }
}

UserServiceImpl:

public class UserServiceImpl implements UserService {
    @Override
    public User getUserByCodePassword(User user) {
        System.out.println("getUserByCodePassword");
        return null;
    }
}

1. 配置applicationContext.xml

在配置文件中声明UserAction、UserServiceImpl类.

注意 :Action对应的bin标签必须配置scop="prototype"属性
因为在struts2框架中,Action每次访问时都会创建.

具体配置如下:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
                        http://www.springframework.org/schema/beans/spring-beans-4.2.xsd 
                        http://www.springframework.org/schema/context 
                        http://www.springframework.org/schema/context/spring-context-4.2.xsd 
                        http://www.springframework.org/schema/aop 
                        http://www.springframework.org/schema/aop/spring-aop-4.2.xsd 
                        http://www.springframework.org/schema/tx 
                        http://www.springframework.org/schema/tx/spring-tx-4.2.xsd ">
    <!-- 
        注意 :Action对应的bin标签必须配置scop="prototype"属性
        因为在struts2框架中,Action每次访问时都会创建
     -->
    <bean name="userAction" class="com.mon7ey.ssh_crm.web.action.UserAction" scope="prototype">
        <property name="userService" ref="userService"></property>
    </bean>

    <bean name="userService" class="com.mon7ey.ssh_crm.service.impl.UserServiceImpl"></bean>
</beans>

2. 配置struts.xml

在Struts-core.jar / org.apache.struts2 / default.properties配置文件中找到下面两个常量

### if specified, the default object factory can be overridden here
### Note: short-hand notation is supported in some cases, such as "spring"
###       Alternatively, you can provide a com.opensymphony.xwork2.ObjectFactory subclass name here
# struts.objectFactory = spring

**struts.objectFactory** : 表示将Action的创建交给Spring容器

### specifies the autoWiring logic when using the SpringObjectFactory.
### valid values are: name, type, auto, and constructor (name is the default)
struts.objectFactory.spring.autoWire = name

**struts.objectFactory.spring.autoWire** : spring负责装配Action的依赖属性.(根据name属性) 
// 例如: XXAction中依赖XXService,那么spring就会自动将XXService装配在XXAction中.
// 这个属性是默认打开的

在struts.xml配置文件中设置常量、声明UserAction,并将action的创建交给spring.具体内容如下:

    <?xml version="1.0" encoding="UTF-8"?>
   <!DOCTYPE struts PUBLIC
    "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
    "http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>

    <!-- 表示将Action的创建教给Spring -->
    <constant name="struts.objectFactory" value="spring"></constant>
    
    <!-- spring负责装配Action的依赖属性.(根据name属性)  -->
    <constant name="struts.objectFactory.spring.autoWire" value="name"></constant>
    
    <package name="user" namespace="/" extends="struts-default">
        <!-- 
            将Action标签中的class属性上填写Spring配置文件(applicationContext.xml)
            中Action对应的Bean标签中的name属性
            注意 :这时struts.objectFactory.spring.autoWire常量将不再生效
                需要手动在applicationContext.xml文件中配置Action中的属性依赖
         -->
        <action name="UserAction_*" class="userAction" method="{1}">
            <result name="success">/success.jsp</result>
        </action>
    </package>
</struts>

到这一步.我们就可以将项目部署在服务器上,查看struts和spring整合是否成功.

我们直接访问UserAction的login方法.login方法中调用打印service的地址,查看控制台是否创建成功

UserService内存地址

五 . 配置Hibernate

1. 创建Hibernate主配置文件

在src目录下创建Hibernate主配置文件hibernate.cfg.xml, 并在主配置文件中引入orm元数据

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
    "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
    
         <!-- 数据库驱动 -->
        <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
         <!-- 数据库url -->
        <property name="hibernate.connection.url">jdbc:mysql:///hibernate_32</property>
         <!-- 数据库连接用户名 -->
        <property name="hibernate.connection.username">root</property>
         <!-- 数据库连接密码 -->
        <property name="hibernate.connection.password">1234</property>
        <!-- 数据库方言  -->
        <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
        <!-- 将hibernate生成的sql语句打印到控制台 -->
        <property name="hibernate.show_sql">true</property>
        <!-- 将hibernate生成的sql语句格式化(语法缩进) -->
        <property name="hibernate.format_sql">true</property>
        <!-- 
            ## auto schema export  自动导出表结构. 自动建表
            #hibernate.hbm2ddl.auto create      自动建表.每次框架运行都会创建新的表.以前表将会被覆盖,表数据会丢失.(开发环境中测试使用)
            #hibernate.hbm2ddl.auto create-drop 自动建表.每次框架运行结束都会将所有表删除.(开发环境中测试使用)
            #hibernate.hbm2ddl.auto update(推荐使用) 自动生成表.如果已经存在不会再生成.如果表有变动.自动更新表(不会删除任何数据).
            #hibernate.hbm2ddl.auto validate    校验.不自动生成表.每次启动会校验数据库中表是否正确.校验失败.
         -->
        <property name="hibernate.hbm2ddl.auto">update</property>
        <!-- 引入orm元数据
            路径书写: 填写src下的路径
         -->
        <mapping resource="" />
        
    </session-factory>
</hibernate-configuration>

2. 创建User对象、User对应的orm文件

User对象:

public class User {
    /*
     * CREATE TABLE `sys_user` (
      `user_id` bigint(32) NOT NULL AUTO_INCREMENT COMMENT '用户id',
      `user_code` varchar(32) NOT NULL COMMENT '用户账号',
      `user_name` varchar(64) NOT NULL COMMENT '用户名称',
      `user_password` varchar(32) NOT NULL COMMENT '用户密码',
      `user_state` char(1) NOT NULL COMMENT '1:正常,0:暂停',
      PRIMARY KEY (`user_id`)
    ) ENGINE=InnoDB AUTO_INCREMENT=9 DEFAULT CHARSET=utf8;
     */
    private Long user_id;
    private String user_code;
    private String user_name;
    private String user_password;
    private Character user_state;
}

User对应的orm文件:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="cn.itcast.domain" >
    <class name="User" table="sys_user" >
        <id name="user_id"  >
            <generator class="native"></generator>
        </id>
        <property name="user_code"  ></property>
        <property name="user_name"  ></property>
        <property name="user_password"  ></property>
        <property name="user_state"  ></property>
    </class>
</hibernate-mapping>

3. 创建测试类测试Hibernate是否可以正常使用

测试方法:

@Test
public void testHibernate() throws Exception {
    Configuration config = new Configuration().configure();
    SessionFactory sessionFactory = config.buildSessionFactory();
    Session session = sessionFactory.openSession();
    Transaction tx = session.beginTransaction();
    User user = new User();
    user.setUser_code("zs");
    user.setUser_name("zhangsan");
    user.setUser_password("123456");
    session.save(user);
    tx.commit();
    session.close();
    sessionFactory.close();
}

测试结果:

测试结果

六 . Spring、Hibernate整合

1. 将SessionFactory对象交给Spring管理

在Spring配置文件(applicationContext.xml)中配置SessionFactory对象,具体配置方式如下:

<!-- 配置SessionFactory. 注意class属性的值,要和当前HIbernate版本相同 -->
<bean name="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
    <!-- 配置hibernate基本信息 -->
    <property name="hibernateProperties">
        <props>
            <!-- 必选配置 -->
            <prop key="hibernate.connection.driver_class">com.mysql.jdbc.Driver</prop>
            <prop key="hibernate.connection.url">jdbc:mysql:///hib_demo</prop>
            <prop key="hibernate.connection.username">root</prop>
            <prop key="hibernate.connection.password">root</prop>
            <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
            <!-- 可选配置 -->
            <prop key="hibernate.hbm2ddl.auto">update</prop>
            <prop key="hibernate.show_sql">true</prop>
            <prop key="hibernate.format_sql">true</prop>
        </props>
    </property>
    <!-- 引入ORM元数据:指定orm元数据所在的包路径,spring会自动读取包中的配置  -->
    <property name="mappingDirectoryLocations" value="classpath:com/mon7ey/ssh_crm/domain"></property>
</bean>

配置完成后测试是否可用

七 . Spring、C3p0连接池整合

1. 在src目录下创建db.properties文件.

db.properties

2 . 在applicationContext.xml中配置dataSource类.通过读取properties配置文件设置数据库连接信息

<!-- 读取db.properties文件 -->
<context:property-placeholder location="classpath:db.properties" />

<!-- 配置C3p0连接池 -->
<bean name="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <property name="jdbcUrl" value="${jdbc.jdbcUrl}"></property>
    <property name="driverClass" value="${jdbc.driverClass}"></property>
    <property name="user" value="${jdbc.user}"></property>
    <property name="password" value="${jdbc.password}"></property>
</bean>

3. 将c3p0连接池注入sessionFactory中, 因为c3p0连接池中已经配置了数据库的连接信息,所以sessionFactory中的数据库配置信息可以移除.

<bean name="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
<!-- 将连接池注入sessionFactory中 , hibernate会通过连接池获得连接-->
    <property name="dataSource" ref="dataSource"></property>    
    <!-- 配置hibernate基本信息 -->
    <property name="hibernateProperties">
        <props>
            <!-- 必选配置 -->
            <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
            <!-- 可选配置 -->
            <prop key="hibernate.hbm2ddl.auto">update</prop>
            <prop key="hibernate.show_sql">true</prop>
            <prop key="hibernate.format_sql">true</prop>
        </props>
    </property>
    <!-- 引入ORM元数据:指定orm元数据所在的包路径,spring会自动读取包中的配置 -->
    <property name="mappingDirectoryLocations" value="classpath:com/mon7ey/ssh_crm/domain"></property>
</bean>

此时c3p0连接池的引入已经完成,但是还不能用用来操作数据库.因为从c3p0连接池获得的链接是不会自动提交的.需要手动提交事务后才能修改数据

八 . spring整合Aop事务

1. 配置核心事务管理器

在applicationContext.xml中配置transactionManager

<!-- 核心事务管理器 -->
<bean name="transactionManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager">
    <property name="sessionFactory" ref="sessionFactory"></property>
</bean>

2. 配置通知

<!-- 配置通知 -->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
    <tx:attributes>
        <tx:method name="save*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false" />
        <tx:method name="persist*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false" />
        <tx:method name="update*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false" />
        <tx:method name="modify*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false" />
        <tx:method name="delete*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false" />
        <tx:method name="remove*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false" />
        <tx:method name="get*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="true" />
        <tx:method name="find*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="true" />
    </tx:attributes>
</tx:advice>

3. 将通知织入目标对象

<!-- 配置Aop事务 -->
<aop:config>
    <aop:pointcut expression="execution(* com.mon7ey.ssh_crm.service.impl.*ServiceImpl.*(..))" id="txPc"/>
    <aop:advisor advice-ref="txAdvice" pointcut-ref="txPc"/>
</aop:config>

九 . 扩大Session的作用范围

当Hibernate使用懒加载策略时, 可能会出no-session问题.所以为了这个问题,需要扩大Session的作用范围,方法如下:

在web.xml下配置filter.

注意: 如果项目中使用了struts2矿建,所有自己配置的filter都需要放在StrutsPrepareAndExecuteFilter的上面

<!-- 扩大session作用域 -->
<filter>
    <filter-name>openSessionInView</filter-name>
    <filter-class>org.springframework.orm.hibernate5.support.OpenSessionInViewFilter</filter-class>
</filter>
<filter-mapping>
    <filter-name>openSessionInView</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

注意: OpenSessionInView类的版本.