SSH框架整合 基于 XML 的配置

SSH框架整合——基于XML配置文件

@(Spring)[spring, struts2, hibernate, 框架整合, ssh, Spring]

SSH框架整合

该SSH整合是基于Spring4、Struts2、Hibernate5的。

SSH框架整合的基本环境准备

第一步：创建web项目，引入jar包

标红为整合必须引入的

• Struts2

  • struts-2.3.24\apps\struts2-blank\WEB-INF\lib*.jar —Struts2基本开发包
    
    • 
  • struts2-convention-plugin-2.3.24.jar —Struts2的注解开发包
  • struts2-spring-plugin-2.3.24.jar —Struts2整合Spring的开发包
  • struts2-json-plugin-2.3.24.jar —Struts2整合AJAX的开发包
  • javax.servlet.jsp.jstl-1.2.1.jar — java标准标签库

• Hibernate

  • mysql-connector-java-5.1.7-bin.jar —数据库驱动
  • hibernate-release-5.0.7.Final\lib\required*.jar —Hibernate必须包
    
    • 
  • 日志记录
    
    • 
  • c3p0连接池
    
    • 

注意：在struts2基础包和Hibernate5基础包中javassist-x.jar这个包会有冲突，搭环境时请使用Hibernate中的高版本javassist的包

• Spring
  
  • Spring的基本开发包
    
    • 
  • Spring的AOP的开发包
    
    • 
  • Spring整合web项目包：spring-web-4.2.4.RELEASE.jar
  • Spring整合Junit项目包
    
    • spring-test-4.2.4.RELEASE.jar
    • junit-4.9.jar
  • Spring的JDBC模板包：spring-jdbc-4.2.4.RELEASE.jar
  • Spring事务管理包：spring-tx-4.2.4.RELEASE.jar
  • Spring整合Hibernate：spring-orm-4.2.4.RELEASE.jar
  • 整合c3p0连接池：com.springsource.com.mchange.v2.c3p0-0.9.1.2.jar，需要使用c3p0连接池，可以导入。

如果使用有hibernate配置文件的ssh整合，使用c3p0连接池，需要使用hibernate中c3p0可选包中的三个jar包；
如果使用没有hibernate配置文件的ssh整合，使用c3p0连接池，需要使用spring整合c3p0连接池中的jar包。
两者不可同用，否则会有冲突。

第二步：引入框架的配置文件

• Struts2
  
  • web.xml

<!-- Struts核心过滤器 --><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>
1
2
3
4
5
6
7
8
9

• • 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.3.dtd"><struts></struts>
1
2
3
4
5
6
7

• Hibernate
  
  • hibernate.cfg.xml

<?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>    </session-factory></hibernate-configuration>
1
2
3
4
5
6
7
8
9

• • 映射文件

<?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=""></hibernate-mapping>
1
2
3
4
5
6
7

• Spring
  
  • web.xml

<!-- 配置Spring上下文环境 --><context-param>    <param-name>contextConfigLocation</param-name>    <param-value>classpath:applicationContext.xml</param-value></context-param><listener>    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class></listener>
1
2
3
4
5
6
7
8

• • applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"    xmlns:aop="http://www.springframework.org/schema/aop"    xmlns:context="http://www.springframework.org/schema/context"    xmlns:tx="http://www.springframework.org/schema/tx"    xsi:schemaLocation="http://www.springframework.org/schema/aop         http://www.springframework.org/schema/aop/spring-aop.xsd        http://www.springframework.org/schema/beans         http://www.springframework.org/schema/beans/spring-beans.xsd        http://www.springframework.org/schema/tx         http://www.springframework.org/schema/tx/spring-tx.xsd        http://www.springframework.org/schema/context         http://www.springframework.org/schema/context/spring-context.xsd"></beans>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

• • log4j.properties

### direct log messages to stdout ###log4j.appender.stdout=org.apache.log4j.ConsoleAppenderlog4j.appender.stdout.Target=System.errlog4j.appender.stdout.layout=org.apache.log4j.PatternLayoutlog4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n### direct messages to file mylog.log ###log4j.appender.file=org.apache.log4j.FileAppenderlog4j.appender.file.File=c\:mylog.loglog4j.appender.file.layout=org.apache.log4j.PatternLayoutlog4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n### set log levels - for more verbose logging change 'info' to 'debug' ###log4j.rootLogger=info, stdout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

第三步：创建包结构和类

package com.pc.crm.domain;import java.io.Serializable;/** * 客户实体类 * @author Switch */public class Customer implements Serializable {    private static final long serialVersionUID = 8501538130746309236L;}
1
2
3
4
5
6
7
8
9

package com.pc.crm.web.action;import com.opensymphony.xwork2.ActionSupport;import com.opensymphony.xwork2.ModelDriven;import com.pc.crm.domain.Customer;/** * 客户Action * @author Switch */public class CustomerAction extends ActionSupport implements ModelDriven<Customer> {    private static final long serialVersionUID = 7878143682430064108L;    Customer customer = new Customer();    @Override    public Customer getModel() {        return this.customer;    }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

package com.pc.crm.service;/** * 客户服务接口 * @author Switch */public interface CustomerService {}
1
2
3
4
5
6
7
8

package com.pc.crm.service.impl;import com.pc.crm.service.CustomerService;/** * 客户服务实现类 * @author Switch */public class CustomerServiceImpl implements CustomerService {}
1
2
3
4
5
6
7
8
9

package com.pc.crm.dao;/** * 客户持久层接口 * @author Switch */public interface CustomerDao {}
1
2
3
4
5
6
7
8

package com.pc.crm.dao.impl;import com.pc.crm.dao.CustomerDao;/** * 客户持久层接口实现类 * @author Switch */public class CustomerDaoImpl implements CustomerDao {}
1
2
3
4
5
6
7
8
9

第四步：将Service和DAO交给Spring管理

<!-- 配置客户服务bean --><bean id="customerService" class="com.pc.crm.service.impl.CustomerServiceImpl"></bean><!-- 配置客户持久层bean --><bean id="customerDao" class="com.pc.crm.dao.impl.CustomerDaoImpl"></bean>
1
2
3
4
5
6
7
8

第五步：引入页面

这里只给出一个访问链接，基于JSP的。

<a href="${pageContext.request.contextPath}/customer/listCustomer">客户列表</a>
1

SSH整合：Struts2和Spring的整合

第六步：修改页面链接为Struts2所能匹配的格式

<a href="${pageContext.request.contextPath}/customer/list_Customer.action">客户列表</a>
1

第七步：编写Action中的listCustomer方法

package com.pc.crm.web.action;import java.util.List;import com.opensymphony.xwork2.ActionSupport;import com.opensymphony.xwork2.ModelDriven;import com.pc.crm.domain.Customer;import com.pc.crm.service.CustomerService;/** * 客户Action * @author Switch */public class CustomerAction extends ActionSupport implements ModelDriven<Customer> {    private static final long serialVersionUID = 7878143682430064108L;    // 客户服务类    CustomerService customerService;    // 用于使用值栈特性，在页面中使用    List<Customer> customers = null;    public List<Customer> getCustomers() {        return customers;    }    public void setCustomers(List<Customer> customers) {        this.customers = customers;    }    // 模型驱动    Customer customer = new Customer();    @Override    public Customer getModel() {        return this.customer;    }    /**     * 显示客户列表     * @return     */    public String listCustomer() {        // 从数据库中获客户列表        customers = customerService.findAllCustomer();        // 转发到客户列表视图        return "list";    }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

第八步：Struts2和Spring整合方式一：Action由Struts2自身创建

• 引入Struts2和Spring整合的插件包
  
  • struts2-spring-plugin-2.3.24.jar

该jar包下有一个struts-plugin.xml的文件，在该文件中开启了Spring工厂对Action中的属性按照名称自动装配等功能。

<!--  Make the Spring object factory the automatic default --><constant name="struts.objectFactory" value="spring" />
1
2

该常量在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### 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### indicates to the struts-spring integration if Class instances should be cached### this should, until a future Spring release makes it possible, be left as true### unless you know exactly what you are doing!### valid values are: true, false (true is the default)struts.objectFactory.spring.useClassCache = true### ensures the autowire strategy is always respected.### valid values are: true, false (false is the default)struts.objectFactory.spring.autoWire.alwaysRespect = false### By default SpringObjectFactory doesn't support AOP### This flag was added just temporally to check if nothing is broken### See https://issues.apache.org/jira/browse/WW-4110struts.objectFactory.spring.enableAopSupport = false
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

当struts.objectFactory常量启用时，开启对Spring的一系列支持。比如说按名自动装配。

• 在Action中不需要使用原来的工厂获取，提供set方法即可。

// 注入客户服务类CustomerService customerService;public void setCustomerService(CustomerService customerService) {    this.customerService = customerService;}/** * customerService未优化 *//* public CustomerAction() {    ApplicationContext context = WebApplicationContextUtils.getWebApplicationContext(ServletActionContext.getServletContext());    customerService = context.getBean("customerService", CustomerService.class);}*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

• 配置Action：Action是Struts2自身创建

<package name="customer" extends="struts-default" namespace="/customer">    <!-- 形如list_Customer -->    <action name="*_*" class="com.pc.crm.web.action.CustomerAction" method="{1}{2}">        <!-- 转发到客户列表视图 -->        <result name="list" type="dispatcher">/jsp/customer/list.jsp</result>    </action></package>
1
2
3
4
5
6
7

第八步：Struts2和Spring整合方式二：Action交给Spring管理（推荐）

• 引入Struts2和Spring整合的插件包

  • struts2-spring-plugin-2.3.24.jar

• 将Action交给Spring创建

<!-- 配置Action，Action注入属性，必须手工注入，且必须声明为多例 --><!-- 客户Action --><bean id="customerAction" class="com.pc.crm.web.action.CustomerAction" scope="prototype">    <property name="customerService" ref="customerService" /></bean>
1
2
3
4
5

• 注意的事项

  • 一定要将Action配置为多例的
  • 属性的注入必须手动完成

• struts.xml文件中对应action的class属性为bean的id属性

<package name="customer" extends="struts-default" namespace="/customer">    <!-- 形如list_Customer -->    <action name="*_*" class="customerAction" method="{1}{2}">        <!-- 转发到客户列表视图 -->        <result name="list" type="dispatcher">/jsp/customer/list.jsp</result>    </action></package>
1
2
3
4
5
6
7

第九步：在客户Service中使用客户Dao

package com.pc.crm.service.impl;import java.util.List;import com.pc.crm.dao.CustomerDao;import com.pc.crm.domain.Customer;import com.pc.crm.service.CustomerService;/** * 客户服务实现类 * @author Switch */public class CustomerServiceImpl implements CustomerService {    // 注入客户Dao    private CustomerDao customerDao;    public void setCustomerDao(CustomerDao customerDao) {        this.customerDao = customerDao;    }    @Override    public List<Customer> findAllCustomer() {            // 查找客户列表            return customerDao.findAllCustomer();    }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

<!-- 配置客户服务bean --><bean id="customerService" class="com.pc.crm.service.impl.CustomerServiceImpl">    <property name="customerDao" ref="customerDao"/></bean>
1
2
3
4

SSH整合：Hibernate和Spring的整合

第十步：Hibernate和Spring整合方式一：带hibernate的配置文件

• 创建实体类和映射文件Customer.hbm.xml

package com.pc.crm.domain;import java.io.Serializable;/** * 客户实体类 * @author Switch */public class Customer implements Serializable {    private static final long serialVersionUID = 8501538130746309236L;    private Long custId;    private String custName;    private String custSource;    private String custIndustry;    private String custLevel;    private String custAddress;    private String custPhone;    ......}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

<?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="com.pc.crm.domain">    <class name="Customer" table="cst_customer" lazy="true" batch-size="3">        <id name="custId" column="cust_id" type="java.lang.Long">            <generator class="native"/>        </id>        <property name="custName" column="cust_name" type="java.lang.String" length="32"/>        <property name="custSource" column="cust_source" type="java.lang.String" length="32"/>        <property name="custIndustry" column="cust_industry" type="java.lang.String" length="32"/>        <property name="custLevel" column="cust_level" type="java.lang.String" length="32"/>        <property name="custAddress" column="cust_address" type="java.lang.String" length="128"/>        <property name="custPhone" column="cust_phone" type="java.lang.String" length="64"/>    </class></hibernate-mapping>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

• 配置hibernate.cfg.xml配置文件

<?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>        <!-- 1、连接数据库的基本信息 -->        <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>        <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/mycrm</property>        <property name="hibernate.connection.username">root</property>        <property name="hibernate.connection.password">123456</property>        <!-- 数据库的方言 -->        <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>        <!-- 2、hibernate的基本配置 -->        <!-- 是否显示SQL语句 -->        <property name="hibernate.show_sql">true</property>        <!-- 是否格式化显示SQL语句 -->        <property name="hibernate.format_sql">true</property>        <!-- 采用何种策略来创建表结构： -->        <!-- update：检查表结构和实体类映射文件的变化，如果发现映射文件和表结构不一致，更新表结构。 -->        <property name="hibernate.hbm2ddl.auto">update</property>        <!-- 配置hibernate使用连接池：告知Hibernate使用连接池的厂商 -->        <property name="hibernate.connection.provider_class">org.hibernate.connection.C3P0ConnectionProvider</property>        <!-- 3、映射文件的位置 -->        <mapping resource="com/pc/crm/domain/Customer.hbm.xml" />        <mapping resource="com/pc/crm/domain/LinkMan.hbm.xml" />    </session-factory></hibernate-configuration>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

• 在Spring中引入Hibernate的配置文件

<!-- 配置Hibernate的SessionFactory,有hibernate配置文件 --><bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">    <property name="configLocation" value="classpath:hibernate.cfg.xml"/></bean>
1
2
3
4

• Spring为了简化Hibernate的开发，提供了Hibernate的模板

package com.pc.crm.dao.impl;import java.util.List;import org.springframework.orm.hibernate5.support.HibernateDaoSupport;import com.pc.crm.dao.CustomerDao;import com.pc.crm.domain.Customer;/** * 客户持久层接口实现类 * @author Switch */public class CustomerDaoImpl extends HibernateDaoSupport implements CustomerDao {    @Override    public List<Customer> findAllCustomer() {    }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

<!-- 配置客户持久层bean --><bean id="customerDao" class="com.pc.crm.dao.impl.CustomerDaoImpl">    <!-- 该bean继承了HibernateDaoSupport，则可以直接注入sessionFactory -->    <property name="sessionFactory" ref="sessionFactory"/></bean>
1
2
3
4
5

• 在客户Dao中使用Hibernate的模板

package com.pc.crm.dao.impl;import java.util.List;import org.springframework.orm.hibernate5.support.HibernateDaoSupport;import com.pc.crm.dao.CustomerDao;import com.pc.crm.domain.Customer;/** * 客户持久层接口实现类 * @author Switch */public class CustomerDaoImpl extends HibernateDaoSupport implements CustomerDao {    @Override    public List<Customer> findAllCustomer() {        return (List<Customer>) this.getHibernateTemplate().find("from Customer");    }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

第十步：Hibernate和Spring整合方式二：不带hibernate的配置文件（推荐）

• 创建实体类和映射文件Customer.hbm.xml

package com.pc.crm.domain;import java.io.Serializable;/** * 客户实体类 * @author Switch */public class Customer implements Serializable {    private static final long serialVersionUID = 8501538130746309236L;    private Long custId;    private String custName;    private String custSource;    private String custIndustry;    private String custLevel;    private String custAddress;    private String custPhone;    ......}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

<?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="com.pc.crm.domain">    <class name="Customer" table="cst_customer" lazy="true" batch-size="3">        <id name="custId" column="cust_id" type="java.lang.Long">            <generator class="native"/>        </id>        <property name="custName" column="cust_name" type="java.lang.String" length="32"/>        <property name="custSource" column="cust_source" type="java.lang.String" length="32"/>        <property name="custIndustry" column="cust_industry" type="java.lang.String" length="32"/>        <property name="custLevel" column="cust_level" type="java.lang.String" length="32"/>        <property name="custAddress" column="cust_address" type="java.lang.String" length="128"/>        <property name="custPhone" column="cust_phone" type="java.lang.String" length="64"/>    </class></hibernate-mapping>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

• 替换hibernate.cfg.xml中的相关内容，将其配置在spring中
  
  • 提供数据库属性文件db.properties

jdbc.driverClass=com.mysql.jdbc.Driverjdbc.url=jdbc:mysql://localhost:3306/mycrmjdbc.user=rootjdbc.password=123456
1
2
3
4

• • 配置属性持有对象

<!-- 配置属性持有对象 --><context:property-placeholder location="classpath:db.properties"/>
1
2

• • 配置数据源

<!-- 配置数据源 --><bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">    <property name="driverClass" value="${jdbc.driverClass}"/>    <property name="jdbcUrl" value="${jdbc.url}"/>    <property name="user" value="${jdbc.user}"/>    <property name="password" value="${jdbc.password}"/></bean>
1
2
3
4
5
6
7

• • 替换hibernate配置信息

<!-- 配置Hibernate的SessionFactory,无hibernate配置文件 --><bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">    <!-- 配置数据源 -->    <property name="dataSource" ref="dataSource"/>    <!-- 配置hibernate属性-->    <property name="hibernateProperties">        <props>            <!-- 数据库的方言 -->            <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>            <!-- 是否显示SQL语句 -->            <prop key="hibernate.show_sql">true</prop>            <!-- 是否格式化显示SQL语句 -->            <prop key="hibernate.format_sql">true</prop>            <!-- 采用何种策略来创建表结构： -->            <prop key="hibernate.hbm2ddl.auto">update</prop>        </props>    </property>    <!-- 配置映射文件 -->    <property name="mappingLocations" value="classpath:com/pc/crm/domain/*.hbm.xml"/></bean>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

• Spring为了简化Hibernate的开发，提供了Hibernate的模板

package com.pc.crm.dao.impl;import java.util.List;import org.springframework.orm.hibernate5.support.HibernateDaoSupport;import com.pc.crm.dao.CustomerDao;import com.pc.crm.domain.Customer;/** * 客户持久层接口实现类 * @author Switch */public class CustomerDaoImpl extends HibernateDaoSupport implements CustomerDao {    @Override    public List<Customer> findAllCustomer() {    }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

<!-- 配置客户持久层bean --><bean id="customerDao" class="com.pc.crm.dao.impl.CustomerDaoImpl">    <!-- 该bean继承了HibernateDaoSupport，则可以直接注入sessionFactory -->    <property name="sessionFactory" ref="sessionFactory"/></bean>
1
2
3
4
5

• 在客户Dao中使用Hibernate的模板

package com.pc.crm.dao.impl;import java.util.List;import org.springframework.orm.hibernate5.support.HibernateDaoSupport;import com.pc.crm.dao.CustomerDao;import com.pc.crm.domain.Customer;/** * 客户持久层接口实现类 * @author Switch */public class CustomerDaoImpl extends HibernateDaoSupport implements CustomerDao {    @Override    public List<Customer> findAllCustomer() {        return (List<Customer>) this.getHibernateTemplate().find("from Customer");    }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

第十一步：添加事务管理

• 配置事务管理器

<!-- 配置事务管理器 --><bean id="transactionManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager">    <property name="sessionFactory" ref="sessionFactory"/></bean>
1
2
3
4

• 配置事务通知

<!-- 配置事务通知 --><tx:advice id="txAdvice" transaction-manager="transactionManager">    <tx:attributes>        <!-- 事务管理策略，查为只读 -->        <!-- 事务隔离级别：mysql为可重复读，事务传播行为：默认值required -->        <tx:method name="find*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="true"/>        <tx:method name="get*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="true"/>        <tx:method name="save*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false"/>                  <tx:method name="*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false"/>    </tx:attributes></tx:advice>
1
2
3
4
5
6
7
8
9
10
11

• 配置事务AOP

<!-- 配置事务AOP --><aop:config>    <aop:pointcut expression="execution(* com.pc.crm.service.impl.*.*(..))" id="pointcut1"/>    <aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut1"/></aop:config>
1
2
3
4
5

PS：如果需要配置基于注解的事务，请参考之前的博文《Spring事务管理》。

Hibernate的模板的API

使用Hibernate的模板完成CRUD的操作

完成增删改的操作

• Serializable save(Object obj);
• void update(Object obj);
• void delete(Object obj);

package com.pc.crm.dao.impl;import java.util.List;import org.hibernate.criterion.DetachedCriteria;import org.springframework.orm.hibernate5.support.HibernateDaoSupport;import com.pc.crm.dao.CustomerDao;import com.pc.crm.domain.Customer;/** * 客户持久层接口实现类 * @author Switch */public class CustomerDaoImpl extends HibernateDaoSupport implements CustomerDao {    @Override    public void save(Customer customer) {        this.getHibernateTemplate().save(customer);    }    @Override    public void update(Customer customer) {        this.getHibernateTemplate().update(customer);    }    @Override    public void delete(Customer customer) {        this.getHibernateTemplate().delete(customer);    }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

完成查询的操作

• T get(Class c,Serializable id); / T load(Class c,Serializable id);
• List

package com.pc.crm.dao.impl;import java.util.List;import org.hibernate.criterion.DetachedCriteria;import org.springframework.orm.hibernate5.support.HibernateDaoSupport;import com.pc.crm.dao.CustomerDao;import com.pc.crm.domain.Customer;/** * 客户持久层接口实现类 * @author Switch */public class CustomerDaoImpl extends HibernateDaoSupport implements CustomerDao {    @Override    public Customer findById(Long id) {        return this.getHibernateTemplate().load(Customer.class, id);    }    @Override    public List<Customer> findAll() {        // 使用HQL查询:        // List<Customer> list = (List<Customer>) this.getHibernateTemplate().find("from Customer ");        // 使用QBC查询:使用DetchedCriteria        // DetachedCriteria detachedCriteria = DetachedCriteria.forClass(Customer.class);        // List<Customer> list = (List<Customer>) this.getHibernateTemplate().findByCriteria(detachedCriteria);        // 命名查询：        List<Customer> list = (List<Customer>) this.getHibernateTemplate().findByNamedQuery("queryAll");        return list;    }    @Override    public List<Customer> findByPage() {        DetachedCriteria detachedCriteria = DetachedCriteria.forClass(Customer.class);        List<Customer> list = (List<Customer>) this.getHibernateTemplate().findByCriteria(detachedCriteria, 0, 3);        return list;    }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

配置openSessionInView过滤器，解决Hibernate懒加载问题

<!-- 配置openSessionInView，解决Hibernate懒加载问题 --><filter>    <filter-name>OpenSessionInViewFilter</filter-name>    <filter-class>org.springframework.orm.hibernate5.support.OpenSessionInViewFilter</filter-class></filter><filter-mapping>    <filter-name>OpenSessionInViewFilter</filter-name>    <url-pattern>*.action</url-pattern></filter-mapping>
1
2
3
4
5
6
7
8
9

PS：将该过滤器放在Struts2核心过滤器上面。

配置全站编码过滤器

<!-- 配置全站编码过滤器 --><filter>    <filter-name>CharacterEncodingFilter</filter-name>    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>    <!-- 编码 -->    <init-param>        <param-name>encoding</param-name>        <param-value>UTF-8</param-value>    </init-param>    <!-- 是否强制使用该编码 -->    <init-param>        <param-name>forceEncoding</param-name>        <param-value>true</param-value>    </init-param></filter><filter-mapping>    <filter-name>CharacterEncodingFilter</filter-name>    <url-pattern>/*</url-pattern></filter-mapping>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

PS：将该过滤器放在Struts2核心过滤器上面。