查看: 1357|回复: 0

[Java代码] ssh(Spring+Struts2+hibernate)整合

发表于 2017-8-7 08:00:02
句号论坛

需求:整合ssh框架做一个保存用户的业务,业务比较简单,重在ssh框架整合。
创建数据库和表

  1. CREATE DATABASE ssh01;
  2. USE DATABASE;
  3. 表由Hibernate创建,可以看配置是否成功
复制代码

一:导入jar包

Hibernate需要jar

  1. Hibernate基本jar
  2. mysql驱动
  3. c3p0连接池
  4. 日志包
  5. jpa
复制代码
Struts需要jar
Struts2基本jar

Spring需要jar

  1. Ioc(6个):beans,context,expression,core+两个日志
  2. Aop(4个):
  3. spring-aop-4.2.4.RELEASE
  4. spring整合aspect
  5. aspectj:com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar
  6. aop联盟:com.springsource.org.aopalliance-1.0.0.jar
  7. spring声明式事务:
  8. spring-jdbc-4.2.4.RELEASE.jar
  9. spring-tx-4.2.4.RELEASE.jar
复制代码

Spring整合web

  1. spring-web-4.2.4.RELEASE.jar
复制代码

Spring整合Hibernate

  1. spring-orm-4.2.4.RELEASE.jar
复制代码

Spring整合Struts2

  1. struts2-spring-plugin-2.3.24.jar
  2. **注意**
  3. Spring整合Struts2包先不要导入,因为如果导入在项目启动的时候,
  4. 会在ServetContext中查找spring工厂,会报错,抛出下面异常
复制代码
  1. You might need to add the following to web.xml:
  2. <listener>
  3. <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  4. </listener>
  5. 17:46:11,396 ERROR Dispatcher:42 - Dispatcher initialization failed
  6. java.lang.NullPointerException
复制代码

在配置ContextLoaderListener监听器在项目启动的时候创建spring容器的时候导入

最后:去除重复的jar struts2基本Jar和Hibernate基本Jar中都有
javassist-3.18.1-GA.jar,删除一个低版本的,否则在使用的时候会出现问题。

二:需要的配置文件

Hibernate需要的配置文件

  1. Hibernate.cfg.xml:src路径下
复制代码
  1. <hibernate-configuration>
  2. <session-factory>
  3. <!-- 必要的配置信息:连接数据库的基本参数 -->
  4. <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
  5. <property name="hibernate.connection.url">jdbc:mysql:///ssh01</property>
  6. <property name="hibernate.connection.username">root</property>
  7. <property name="hibernate.connection.password">root</property>
  8. <!-- Hibernate的属性 -->
  9. <!-- Hibernate的方言:作用,根据配置的方言生成相应的SQL语句 -->
  10. <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
  11. <!-- Hibernate显示SQL语句: -->
  12. <property name="hibernate.show_sql">true</property>
  13. <!-- Hibernate格式化SQL语句: -->
  14. <property name="hibernate.format_sql">true</property>
  15. <!-- Hibernate的hbm2ddl(数据定义语言:create drop alter ...)属性 -->
  16. <property name="hibernate.hbm2ddl.auto">update</property>
  17. <!-- 配置C3P0连接池 -->
  18. <property name="hibernate.connection.provider_class">org.hibernate.connection.C3P0ConnectionProvider</property>
  19. <!-- Hibernate加载映射 -->
  20. <mapping resource="com/itheima/domain/Customer.hbm.xml"/>
  21. </session-factory>
  22. </hibernate-configuration>
复制代码

jdbc.properties:(对数据库参数的封装) src下

  1. jdbc.driver=com.mysql.jdbc.Driver;
  2. jdbc.url=jdbc:mysql://localhost:3306/ssh01
  3. jdbc.username=root
  4. jdbc.password=root
复制代码

log4J.properties日志文件 src下

Customer.hbm.xml 需要保存客户实体的映射文件

  1. <hibernate-mapping package="com.itheima.domain">
  2. <class name="Customer" table="cst_customer">
  3. <!-- 数据库表中的字段名和实体类属性名相同的时候可以省略Column属性 -->
  4. <id name="cust_id">
  5. <!-- 配置主键生成策略 -->
  6. <generator class="native"></generator>
  7. </id>
  8. <property name="cust_name"></property>
  9. <property name="cust_source"></property>
  10. <property name="cust_industry"></property>
  11. <property name="cust_level"></property>
  12. <property name="cust_phone"></property>
  13. <property name="cust_mobile"></property>
  14. </class>
  15. </hibernate-mapping>
复制代码

Struts需要的配置文件

  1. web.xml:配置Struts核心过滤器
复制代码
  1. <filter>
  2. <filter-name>Struts2</filter-name>
  3. <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
  4. </filter>
  5. <filter-mapping>
  6. <filter-name>Struts2</filter-name>
  7. <url-pattern>/*</url-pattern>
  8. </filter-mapping>
复制代码
  1. struts2.xml:配置action 位置src下
复制代码
  1. <struts>
  2. <constant name="struts.devMode" value="true"></constant>
  3. <package name="ssh" extends="struts-default" namespace="/">
  4. <action name="customer_*" class="com.itheima.web.action.CustomerAction" method="小贝">
  5. <result name="success">/success.jsp</result>
  6. </action>
  7. </package>
  8. </struts>
复制代码
applicationContext.xml src下(待会配置)

三:创建service,dao,domain,action

创建Customer实体类,以及实体类对应的映射文件映射文件看上面)

  1. 伪代码(为属性提供get/set方法)
复制代码
  1. public class Customer implements Serializable{
  2. private static final long serialVersionUID = 1L;
  3. private Long cust_id;
  4. private String cust_name;
  5. private String cust_source;
  6. private String cust_industry;
  7. private String cust_level;
  8. private String cust_phone;
  9. private String cust_mobile;
复制代码

CustomerService,CustomerServiceImpl

  1. 将customerService对象交给spring容器管理
  2. service需要调用dao层的方法,进行属性注入
复制代码
  1. public class CustomerServiceImpl implements CustomerService {
  2. //创建dao,并提供set方法,进行属性注入
  3. private CustomerDao customerDao;
  4. public void setCustomerDao(CustomerDao customerDao) {
  5. this.customerDao = customerDao;
  6. }
  7. @Override
  8. public void save(Customer customer) {
  9. customerDao.save(customer);
  10. }
  11. }
复制代码

创建CustomerDao,CustomerDaoImpl
将CustomerDao对象交给spring容器管

  1. public class CustomerDaoImpl implements CustomerDao {
  2. @Override
  3. public void save(Customer customer) {
  4. //获取session对象,来操作数据库
  5. Configuration config = new Configuration().configure();
  6. SessionFactory factory = config.buildSessionFactory();
  7. Session session = factory.openSession();
  8. Transaction tx = session.beginTransaction();
  9. session.save(customer);
  10. tx.commit();
  11. session.close();
  12. }
  13. }
复制代码

创建CustomerAction并在struts.xml中进行配置(struts.xml文件)

  1. public class CustomerAction extends ActionSupport implements ModelDriven<Customer> {
  2. private static final long serialVersionUID = 1L;
  3. //使用ModelDriven模型驱动进行数据封装,必须手动来创建对象
  4. private Customer customer = new Customer();
  5. @Override
  6. public Customer getModel() {
  7. return customer;
  8. }
  9. /*
  10. * 创建CustomerService对象调用service层的方法
  11. * 因为action是由struts2创建service交给spring容器管理所以不可以直接注入
  12. */
  13. ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
  14. CustomerService customerService = (CustomerService) context.getBean("customerService");
  15. //保存用户的方法
  16. public String save(){
  17. customerService.save(customer);
  18. return SUCCESS;
  19. }
  20. }
复制代码

在spring容器中管理CustomerService,CustomerDao

  1. <!-- 配置dao -->
  2. <bean id="customerDao" class="com.itheima.dao.impl.CustomerDaoImpl"></bean>
  3. <!-- 配置service并注入customerDao属性 -->
  4. <bean id="customerService" class="com.itheima.service.impl.CustomerServiceImpl">
  5. <property name="customerDao" ref="customerDao"></property>
  6. </bean>
复制代码

创建save.jsp

  1. <form action="${pageContext.request.contextPath}/customer_save.action" method="post">
  2. 客户名称:<input type="text" name="cust_name"><br/>
  3. 客户等级:<input type="text" name="cust_level"><br/>
  4. 客户来源:<input type="text" name="cust_source"><br/>
  5. 客户行业:<input type="text" name="cust_industry"><br/>
  6. 客户电话:<input type="text" name="cust_mobile"><br/>
  7. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
  8. <input type="submit" value="保存">
  9. </form>
复制代码

三:测试

  1. 在浏览器输入http://localhost/ssh01/save.jsp输入数据,点击提交,
  2. 数据库表创建成功,数据成功保存
复制代码

这样,最简单最原始的ssh框架整合完成。


问题一:在CustomerAction中的获取service

解决方案:

  1. 使用监听器,当项目启动的时候监听ServletContext对象的创建,
  2. 当ServletContext对象创建的时候加载applicationContext.xml文件,
  3. 创建spring工厂初始化bean将spring容器放置在ServletContext域对象中
  4. spring为我们提供了ContextLoaderListener,在web.xml文件中配置该监听器,
  5. 它会加载applicationContext.xml,创建spring工厂,
  6. 并存放在ServletContext域对象中
复制代码

代码实现

  1. 在web.xml中进行配置
复制代码
  1. <context-param>
  2. <param-name>contextConfigLocation</param-name>
  3. <param-value>classpath:applicationContext.xml</param-value>
  4. </context-param>
  5. <listener>
  6. <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  7. </listener>
复制代码
  1. 在CustomerService中获取service
复制代码
  1. ServletContext servletContext = ServletActionContext.getServletContext();
  2. WebApplicationContext context = WebApplicationContextUtils.getWebApplicationContext(servletContext);
  3. CustomerService customerService = (CustomerService) context.getBean("customerService");
复制代码
  1. 问题二:Action由struts2容器管理,service是交给spring容器管理,不能直接注入
  2. 如何在action中注入service
  3. 解决方案:spring整合struts
  4. 前提:导入struts-spring-plugin.jar,在项目启动的时候创建spring工厂,
  5. 放置到context域中
  6. 方式一:Action还是struts创建,Spring负责为Struts中的Action注入匹配的属性
复制代码
  1. //由spring容器为action进行属性注入
  2. private CustomerService customerService;
  3. public void setCustomerService(CustomerService customerService) {
  4. this.customerService = customerService;
  5. }
复制代码
  1. 原因:为什么直接导入struts2-spring-plugin.jar包就可以直接注入?
  2. 在default.properties配置有中struts.objectFactory.spring.autoWire = name
  3. Spring负责为Struts中的Action注入匹配的属性,根据属性的名称注入(默认,可以修改)
  4. 方式二:将action交给spring容器来管理,
  5. action是多例的,所以需要配置scope="prototype"属性
  6. 修改applicationContext.xml和struts.xml文件
复制代码
  1. <!-- 将action交给spring容器来管理 -->
  2. <bean id="customerAction" class="com.itheima.web.action.CustomerAction" scope="prototype">
  3. <property name="customerService" ref="customerService"></property>
  4. </bean>
  5. 修改struts文件:
  6. <package name="ssh" extends="struts-default" namespace="/">
  7. <action name="customer_*" class="customerAction" method="小贝">
  8. <result name="success">/success.jsp</result>
  9. </action>
  10. </package>
复制代码

问题三

  1. 在dao层,使用Hibernate操作数据库,需要加载Hibernate.cfg.xml配置文件
  2. 获取SessionFactory(类似于DataSource数据源)然后获取到session对象
  3. (类似于Connection连接对象,SessionFactory:是重量级并且线程安全的,
  4. 所以在项目中只存在一份即
  5. 解决方案
  6. 将SessionFactory交给spring容器管理:单例
  7. sessionFactory是一个接口,在这里我们使用它的实现类LocalSessionFactoryBean
  8. 选择Hibernate5的,因为我们使用的Hibernate是5.0.7版本的
  9. 在applicationContext.xml中配置
复制代码
  1. <bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
  2. <!-- 需要指定hibernate的核心配置文件,因为这里面有需要的数据库配置参数 -->
  3. <property name="configLocation" value="classpath:hibernate.cfg.xml"></property>
  4. </bean>
复制代码
  1. 使用spring提供的HibernateTemplate在dao层操作数据库,将HibernateTemplate交给
  2. spring容器来管理,并注入到dao层
  3. 在applicationContext.xml中进行配置
  4. 配置Hibernate模板需要注入SessionFactory,因为模板是对Hibernate的包装,底层还是
  5. 使用session来操作数据库,所以需要获取到session对象,通过SessionFactory对象
复制代码
  1. <!-- 配置HibernateTemplate模板 -->
  2. <bean id="hibernateTemplate" class="org.springframework.orm.hibernate5.HibernateTemplate">
  3. <!-- hibernateTemplate模板底层操作数据库是通过session对象,所以需要注入sessionFactory对象获取到session -->
  4. <property name="sessionFactory" ref="sessionFactory"></property>
  5. </bean>
  6. <!-- 配置dao -->
  7. <bean id="customerDao" class="com.itheima.dao.impl.CustomerDaoImpl">
  8. <!-- 为 dao注入HibernateTemplate dao层使用HibernateTemplate来操作数据库-->
  9. <property name="hibernateTemplate" ref="hibernateTemplate"></property>
  10. </bean>
复制代码
  1. 修改之后dao层的代码如下
复制代码
  1. public class CustomerDaoImpl implements CustomerDao {
  2. //注入HibernateTemplate来操作数据库
  3. private HibernateTemplate hibernateTemplate;
  4. public void setHibernateTemplate(HibernateTemplate hibernateTemplate) {
  5. this.hibernateTemplate = hibernateTemplate;
  6. }
  7. @Override
  8. public void save(Customer customer) {
  9. hibernateTemplate.save(customer);
  10. }
  11. }
复制代码
  1. 这样直接运行程序,会抛出异常,异常信息为:
复制代码
  1. Write operations are not allowed in read-only mode (FlushMode.MANUAL):
  2. Turn your Session into FlushMode.COMMIT/AUTO or remove 'readOnly'
  3. marker from transaction definition.
复制代码
  1. 问题:只读模式下(FlushMode.NEVER/MANUAL)写操作不被允许:
  2. 把你的Session改成FlushMode.COMMIT/AUTO或者清除事务定义中的readOnly标记
  3. spring会将获取到的session绑定到当前线程中,
  4. 为了确保在一个请求中service层和dao层使用的是一个session对象
  5. 只有受spring声明式事务的方法才具有写权限。否则在操作的会抛出上面异常
  6. 所以还需要在applicationContext.xml中配置spring的声明式事务
复制代码
  1. <!-- 不管是注解还是xml文件的方式配置spring声明式事务,都需要指定平台事务管理器 -->
  2. <!-- Hibernate 的事务平台管理器 -->
  3. <bean id="transactionManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager">
  4. <!--
  5. 需要session对象来开启事务session.beginTransaction()
  6. 所以需要注入SessionFactory来获取到session对象
  7. -->
  8. <property name="sessionFactory" ref="sessionFactory"></property>
  9. </bean>
  10. <!-- 配置增强/通知spring提供好的,我们来指定规则 -->
  11. <tx:advice transaction-manager="transactionManager" id="my_advice">
  12. <tx:attributes>
  13. <!-- 这些事务隔离级别,事务传播行为,超时信息都是默认值
  14. 当进行查询操作的时候,可以修改propagation="SUPPORTS" read-only="true"(查询的时候只读)
  15. -->
  16. <!-- 在开发中的常用配置 -->
  17. <!-- <tx:method name="save*" isolation="DEFAULT" propagation="REQUIRED" read-only="false" timeout="-1"/>
  18. <tx:method name="find*" isolation="DEFAULT" propagation="SUPPORTS" read-only="true" timeout="-1"/>
  19. <tx:method name="get*" isolation="DEFAULT" propagation="SUPPORTS" read-only="true" timeout="-1"/>
  20. <tx:method name="update*" isolation="DEFAULT" propagation="REQUIRED" read-only="false" timeout="-1"/>
  21. <tx:method name="delete*" isolation="DEFAULT" propagation="REQUIRED" read-only="false" timeout="-1"/> -->
  22. <tx:method name="save" isolation="DEFAULT" propagation="REQUIRED" read-only="false" timeout="-1"/>
  23. </tx:attributes>
  24. </tx:advice>
  25. <!-- aop配置 -->
  26. <aop:config>
  27. <!-- 配置切入点 事务控制在service层 -->
  28. <aop:pointcut expression="execution(* com.itheima.service.impl.*.*(..))" id="myPt"/>
  29. <aop:advisor advice-ref="my_advice" pointcut-ref="myPt"/>
  30. </aop:config>
复制代码
  1. 这样一个纯xml配置整合ssh框架就完成了!!!
复制代码

  1. 在实际的开发中都是注解+xml来完成的。现在我们来对代码进行优化。
  2. 在实际的开发中:
  3. 我们自定义bean的创建和注入通过注解来完成(CustomerService等)
  4. 非自定义的bean交给xml文件配置(例如数据源dataSource和SessionFactory)
  5. 优化一:去除struts.xml文件(action的配置使用注解来完成)
  6. 使用注解的方式配置action必须导入jar包struts2-convention-plugin-2.3.24.jar
  7. 在CustomerAction上面添加注解:
复制代码
  1. @Namespace("/")
  2. @ParentPackage("struts-default")
  3. public class CustomerAction extends ActionSupport implements ModelDriven<Customer> {
  4. private static final long serialVersionUID = 1L;
  5. //使用ModelDriven模型驱动进行数据封装,必须手动来创建对象
  6. private Customer customer = new Customer();
  7. @Override
  8. public Customer getModel() {
  9. return customer;
  10. }
  11. //由spring容器为action进行属性注入
  12. private CustomerService customerService;
  13. public void setCustomerService(CustomerService customerService) {
  14. this.customerService = customerService;
  15. }
  16. //保存用户的方法
  17. @Action(value="customer_save",results={@Result(name="success",location="/success.jsp")})
  18. public String save(){
  19. customerService.save(customer);
  20. return SUCCESS;
  21. }
  22. }
复制代码

优化二:所有的自定义bean都使用注解的方式进行配置,
去除applicationContext中的自定义bean
必须在applicationContext中开启组件扫描

  1. 在applicationContext中开启组件扫描
  2. <!-- 开启组件扫描 -->
  3. <context:component-scan base-package="com.itheima"></context:component-scan>
  4. CustomerAction中的代码
  5. @Namespace("/")
  6. @ParentPackage("struts-default")
  7. @Controller("customerAction")
  8. public class CustomerAction extends ActionSupport implements ModelDriven<Customer>{
  9. @Autowired
  10. private CustomerService customerService;
  11. }
  12. CustomerServiceImpl中配置注解的代码
  13. @Service("customerService")
  14. public class CustomerServiceImpl implements CustomerService {
  15. @Autowired
  16. private CustomerDao customerDao;
  17. CustomerDaoImpl中注解的代码
  18. @Repository("customerDao")
  19. public class CustomerDaoImpl implements CustomerDao {
  20. //注入HibernateTemplate来操作数据库
  21. @Autowired
  22. private HibernateTemplate hibernateTemplate;
复制代码

优化三:spring的声明式事务使用xml+注解的方式进行配置
减少applicationContext.xml文件中的配置代码

  1. 要在applicationContext中开启事务注解支持
复制代码
  1. <!-- 开启事务注解支持 -->
  2. <tx:annotation-driven/>
复制代码
  1. 事务是在service层进行控制的,在service层上加上事务注解
  2. 可以去除applicationContext中配置增强和aop配置的代码
复制代码
  1. @Service("customerService")
  2. @Transactional
  3. public class CustomerServiceImpl implements CustomerService
复制代码

优化四:去除持久化类的映射配置文件,使用注解进行代替

  1. 其它字段和属性名相同,可以省略@Column
  2. @Entity
  3. @Table(name="cst_customer")
  4. public class Customer implements Serializable{
  5. private static final long serialVersionUID = 1L;
  6. //oid
  7. @Id
  8. @GeneratedValue(strategy=GenerationType.IDENTITY)
复制代码
  1. 去除持久化类的映射配置文件之后,在Hibernate.cfg.xml文件中
  2. 引入持久化类映射文件的代码需要修改:
  3. <!-- Hibernate加载映射 -->
  4. <mapping resource="com/itheima/domain/Customer.hbm.xml"/>
  5. Customer.hbm.xml文件已经去除,修改为
  6. <mapping class="com.itheima.domain.Customer"/>
复制代码

优化五:去除Hibernate.cfg.xml

  1. 在前面applicationContext.xml中将SessionFactory交给spring容器管理的时候
  2. <bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
  3. <!-- 需要指定hibernate的核心配置文件,因为这里面有需要的数据库配合参数 -->
  4. <property name="configLocation" value="classpath:hibernate.cfg.xml"></property>
  5. </bean>
  6. 指定了核心配置文件,现在需要手动的配置数据库参数以及Hibernate的一些基本配置
  7. 如是否显示sql语句,是否格式化sql语句,mysql方言配置等
复制代码

最终:只留下了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:context="http://www.springframework.org/schema/context"
  5. xmlns:aop="http://www.springframework.org/schema/aop"
  6. xmlns:tx="http://www.springframework.org/schema/tx"
  7. xsi:schemaLocation="http://www.springframework.org/schema/beans
  8. http://www.springframework.org/schema/beans/spring-beans.xsd
  9. http://www.springframework.org/schema/context
  10. http://www.springframework.org/schema/context/spring-context.xsd
  11. http://www.springframework.org/schema/aop
  12. http://www.springframework.org/schema/aop/spring-aop.xsd
  13. http://www.springframework.org/schema/tx
  14. http://www.springframework.org/schema/tx/spring-tx.xsd">
  15. <!-- 开启事务注解支持 -->
  16. <tx:annotation-driven/>
  17. <!-- 开启组件扫描 -->
  18. <context:component-scan base-package="com.itheima"></context:component-scan>
  19. <!-- 将配置文件加载到容器中 -->
  20. <context:property-placeholder location="classpath:jdbc.properties"></context:property-placeholder>
  21. <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
  22. <!-- 进行属性的注入 -->
  23. <property name="driverClass" value="${jdbc.driver}"></property>
  24. <property name="jdbcUrl" value="${jdbc.url}"></property>
  25. <property name="user" value="${jdbc.username}"></property>
  26. <property name="password" value="${jdbc.password}"></property>
  27. </bean>
  28. <!-- 将SessionFactory交给spring容器来管理 -->
  29. <bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
  30. <!-- 注入数据源 -->
  31. <property name="dataSource" ref="dataSource"></property>
  32. <!-- Hibernate的基本配置 -->
  33. <property name="hibernateProperties">
  34. <props>
  35. <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
  36. <prop key="hibernate.show_sql">true</prop>
  37. <prop key="hibernate.format_sql">true</prop>
  38. <prop key="hibernate.hbm2ddl.auto">update</prop>
  39. </props>
  40. </property>
  41. <!-- 指定扫描包 包下具有@Entity的这些类 -->
  42. <property name="packagesToScan">
  43. <list>
  44. <value>com.itheima.domain</value>
  45. </list>
  46. </property>
  47. </bean>
  48. <!-- 配置HibernateTemplate模板 -->
  49. <bean id="hibernateTemplate" class="org.springframework.orm.hibernate5.HibernateTemplate">
  50. <!-- hibernateTemplate模板底层操作数据库是通过session对象,所以需要注入sessionFactory对象获取到session -->
  51. <property name="sessionFactory" ref="sessionFactory"></property>
  52. </bean>
  53. <!-- 不管是注解还是xml文件的方式配置spring声明式事务,都需要指定平台事务管理器 -->
  54. <!-- Hibernate 的事务平台管理器 -->
  55. <bean id="transactionManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager">
  56. <!--
  57. 需要session对象来开启事务session.beginTransaction()
  58. 所以需要注入SessionFactory来获取到session对象
  59. -->
  60. <property name="sessionFactory" ref="sessionFactory"></property>
  61. </bean>
  62. </beans>
复制代码

这样,以xml+注解结合方式整合ssh框架就完成了。



太阳http代理AD
回复

使用道具 举报

关闭

站长推荐上一条 /1 下一条