Spring框架学习

文章40 |   阅读 21321 |   点赞0

来源：https://blog.csdn.net/yerenyuan_pku/category_6457009.html

Spring入门第十讲——Hibernate-5.0.7+Struts-2.3.24+Spring-4.2.4三大框架整合开发

转x33g5p2x  于2021-12-18 转载在 其他  
字(20.2k)|赞(0)|评价(0)|浏览(460)

回顾SSH框架

至此，Hibernate-5.0.7、Struts-2.3.24和Spring-4.2.4这三个框架，我们已经都过了一遍了。现在，咱就要学习如何整合这三个框架进行开发了。在这之前，咱就来先回顾一下这三个框架。

SSH框架整合思想

Hibernate-5.0.7、Struts-2.3.24和Spring-4.2.4这三个框架都会应用在JavaEE三层结构中，每一层都用到了不同的框架。SSH框架整合的思想可以用下图来表示。

SSH框架的整合

Hibernate-5.0.7、Struts-2.3.24和Spring-4.2.4这三个框架的整合一共有三种方式，它们分别是：

本讲只讲第一种方式和第二种方式。

SSH框架的整合方式一：零障碍整合（带有Hibernate配置文件）

创建web项目，引入jar包

首先创建一个动态web项目，例如S2SH，然后要导入这三个框架开发所依赖jar包，那要导入哪些jar包呢？因为要整合这三个框架，所以要导入的jar包可多了。

Struts2框架所须jar包

要进行Struts2的基本的开发，可以参考struts-2.3.24中的apps目录下的一些示例代码。其中struts2-blank.war就是Struts2一个空的工程，解压struts2-blank.war之后，进入到WEB-INF下的lib目录中查看，你就能看到Struts2基本的开发jar包，所以我们得将这些jar包导入到咱的项目中。

除此之外，对于Struts2这个框架，我们还需要了解struts-2.3.24\lib目录下的这3个jar包。

Hibernate框架所须jar包
  • 首先，导入hibernate-release-5.0.7.Final\lib\required目录下的所有jar包，因为在该目录下，包含了运行Hibernate项目必须的jar包。

这时，你就会发现导入Struts2和Hibernate的jar包时，Struts2和Hibernate都引入了一个相同的jar包，Struts2引入的是javassist-3.11.0.GA.jar这样一个jar包，Hibernate引入的是javassist-3.18.1-GA.jar这样一个jar包，这两个jar包功能相同，但版本不一样，就很容易出现包冲突的问题，为了解决这个问题，咱必须得删除一个，删除javassist-3.11.0.GA.jar这个低版本的jar包即可。

  • 然后，导入MySQL数据库的驱动jar包。

  • 接着，再导入与日志相关的jar包。

这时，对于Struts2中的两个与日志记录相关的jar包（log4j-api-2.2.jar和log4j-core-2.2.jar）而言，你可以选择删除掉，但是你要是愿意留着，也不影响。

  • 最后，如果Hibernate还要使用C3P0连接池，那么还得引入hibernate-release-5.0.7.Final\lib\optional\c3p0目录下的jar包。

Spring框架所须jar包
  • 首先，导入Spirng框架的基本开发包，一共有6个。

这时，com.springsource.org.apache.log4j-1.2.15.jar这个日志记录的包可以不要（因为已经有了log4j-1.2.16.jar），但com.springsource.org.apache.commons.logging-1.1.1.jar这个jar包必须得有。

  • 然后，由于咱们接下来会使用到Spring声明式事务管理这种方式来管理事务，所以还得导入Spring AOP开发相关的jar包。

  • 接着，由于咱们接下来会在程序中使用到Spring声明式事务管理这种方式来管理事务，所以还得导入与事务管理相关的jar包。

  • 最后，导入Spring整合Hibernate的jar包。

  • 如果你想要在程序中使用JdbcTemplate模板类，那么还得导入如下两个jar包。

  • 如果你想通过Spring来整合web项目进行开发，那么还得导入如下jar包。

  • 如果你还想在程序中通过Spring来整合JUnit进行单元测试，所以在项目中还应导入spring-tx-4.2.4.RELEASE.jar包。

为了避免麻烦，干脆导入以上所有有关Spring框架开发的所须jar包。

引入相关的配置文件

Struts2框架所须的配置文件

首先，创建Struts2的核心配置文件，该核心配置文件的位置是在src目录下面，名称是struts.xml，一开始该文件的内容肯定是空的。

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

温馨提示：在Struts2和Spring框架整合的时候，Struts2核心配置文件的名称和位置是有固定要求的，即名称只能是struts.xml，且必须位于src目录下面。
然后，配置Struts2的核心过滤器，即在web.xml配置文件中添加如下配置。

Hibernate框架所须的配置文件

首先，创建Hibernate核心配置文件，该核心配置文件的位置是在src目录下面，名称是hibernate.cfg.xml。

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
  3. 	
  4. <hibernate-configuration>
  5. 	<session-factory>
  6. 		<!-- 下面是三个必须要有的配置 -->
  7. 		<!-- 配置连接MySQL数据库的基本参数 -->
  8. 		<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
  9. 		<property name="hibernate.connection.url">jdbc:mysql:///ssh1</property>
  10. 		<property name="hibernate.connection.username">root</property>
  11. 		<property name="hibernate.connection.password">liayun</property>
  12. 		
  13. 		<!-- 配置Hibernate的方言 -->
  14. 		<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
  15. 		
  16. 		<!-- 下面三个是可选的配置哟！ -->
  17. 		<!-- 打印sql语句 -->
  18. 		<property name="hibernate.show_sql">true</property>
  19. 		<!-- 格式化sql语句 -->
  20. 		<property name="hibernate.format_sql">true</property>
  21. 		<!-- 自动创建表 -->
  22. 		<property name="hibernate.hbm2ddl.auto">update</property>
  23. 		
  24. 		<!-- 配置C3P0连接池 -->
  25. 		<property name="connection.provider_class">org.hibernate.connection.C3P0ConnectionProvider</property>
  26. 		<!--在连接池中可用的数据库连接的最少数目 -->
  27. 		<property name="c3p0.min_size">5</property>
  28. 		<!--在连接池中所有数据库连接的最大数目 -->
  29. 		<property name="c3p0.max_size">20</property>
  30. 		<!--设定数据库连接的过期时间,以秒为单位, 如果连接池中的某个数据库连接处于空闲状态的时间超过了timeout时间,就会从连接池中清除 -->
  31. 		<property name="c3p0.timeout">120</property>
  32. 		 <!--每3000秒检查所有连接池中的空闲连接 以秒为单位-->
  33. 		<property name="c3p0.idle_test_period">3000</property>
  35. </hibernate-configuration>

在编写以上文件中的内容时，需要注意以下几个点。

  • 一定得删除那个与线程绑定的session，即在hibernate.cfg.xml文件中不要配置以下内容：

因为在Spring里面已经帮我们做好了，不用我们在Hibernate这边去搞这些事情了。其实，session最终是要交给Spring去管理的，Spring帮我们弄的那个session就已经与线程绑定了。

  • 去掉事务隔离级别的配置，即在hibernate.cfg.xml文件中不要配置以下内容：

事务隔离级别现在写在这儿也没啥用，因为我们的事务最终都是要交给Spring去管理的。

  • 如果只是单纯使用Hibernate框架，那么核心配置文件的名称必须是hibernate.cfg.xml，且必须位于src目录下。但在Hibernate和Spring框架整合的时候，Hibernate核心配置文件的名称和位置是没有固定要求的。

然后，咱应该还要引入实体类的映射配置文件。但这个得等到后面我们去编写实体类时，再引入与其相关的映射配置文件即可，现在先别急着写。

Spring框架所须的配置文件

首先，咱得引入Spring的配置文件（即applicationContext.xml），一开始该文件的内容肯定是空的，只不过包含了各种schema约束，下面我给出的applicationContext.xml文件包含的schema约束应该是最全面的。

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 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.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">
  3. 	
  4. 	
  5.         
  6. </beans>

接着，就要使用Spring中的核心监听器（即ContextLoaderListener）来整合web项目了。咋整合呢？在web.xml文件中配置Spring中的核心监听器（即ContextLoaderListener），这样在服务器启动的时候，它就会加载Spring的配置文件了，并且还要手动配置让其加载类路径下的配置文件。

最后，还要记得在src目录下引入Log4j的配置文件（log4j.properties）哟！也就是日志记录文件，该文件内容如下：

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

创建数据库和表

创建一个数据库，并在该数据库下新建一张客户表，这里笔者使用的数据库是MySQL。

  1. create database s2sh_crm;
  2. use s2sh_crm;
  4. CREATE TABLE `cst_customer` (
  5. 	`cust_id` bigint(32) NOT NULL AUTO_INCREMENT COMMENT '客户编号(主键)',
  6. 	`cust_name` varchar(32) NOT NULL COMMENT '客户名称(公司名称)',
  7. 	`cust_source` varchar(32) DEFAULT NULL COMMENT '客户信息来源',
  8. 	`cust_industry` varchar(32) DEFAULT NULL COMMENT '客户所属行业',
  9. 	`cust_level` varchar(32) DEFAULT NULL COMMENT '客户级别',
  10. 	`cust_phone` varchar(64) DEFAULT NULL COMMENT '固定电话',
  11. 	`cust_mobile` varchar(16) DEFAULT NULL COMMENT '移动电话',
  12. 	PRIMARY KEY (`cust_id`)
  13. ) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

创建包结构

引入相应的页面

CRM系统中用到的所有页面可以点击我给的百度网盘链接行下载。

这里，除了要将CRM系统中用到的所有页面导入到我们的项目中之外，还记得将所有的htm静态页面改为jsp页面。咋改？不用我教吧！改完之后，发布我们的项目，试着访问一下项目的首页，看能不能出现下面的效果。

接着，在菜单页面（menu.jsp）中修改新增客户超链接的提交路径。

此时，重新发布咱们的项目到Tomcat服务器中，访问项目的首页之后，点击新增客户超链接，就能跳转到客户添加页面中。

现在咱要做的事情是在以上页面中填入客户的相关信息之后，一点保存按钮，就要将填写的客户信息保存到数据库表中，也就是说我们要完成CRM系统中保存客户的功能。尼玛！需求这个时候才出现！

编写Customer实体类

首先，在com.meimeixia.ssh.domain包下创建一个Customer实体类。

  1. package com.meimeixia.ssh.domain;
  3. public class Customer {
  4. 	
  5. 	private Long cust_id;
  6. 	private String cust_name;
  7. 	private String cust_source;
  8. 	private String cust_industry;
  9. 	private String cust_level;
  10. 	private String cust_phone;
  11. 	private String cust_mobile;
  12. 	public Long getCust_id() {
  13. 		return cust_id;
  14. 	}
  15. 	public void setCust_id(Long cust_id) {
  16. 		this.cust_id = cust_id;
  17. 	}
  18. 	public String getCust_name() {
  19. 		return cust_name;
  20. 	}
  21. 	public void setCust_name(String cust_name) {
  22. 		this.cust_name = cust_name;
  23. 	}
  24. 	public String getCust_source() {
  25. 		return cust_source;
  26. 	}
  27. 	public void setCust_source(String cust_source) {
  28. 		this.cust_source = cust_source;
  29. 	}
  30. 	public String getCust_industry() {
  31. 		return cust_industry;
  32. 	}
  33. 	public void setCust_industry(String cust_industry) {
  34. 		this.cust_industry = cust_industry;
  35. 	}
  36. 	public String getCust_level() {
  37. 		return cust_level;
  38. 	}
  39. 	public void setCust_level(String cust_level) {
  40. 		this.cust_level = cust_level;
  41. 	}
  42. 	public String getCust_phone() {
  43. 		return cust_phone;
  44. 	}
  45. 	public void setCust_phone(String cust_phone) {
  46. 		this.cust_phone = cust_phone;
  47. 	}
  48. 	public String getCust_mobile() {
  49. 		return cust_mobile;
  50. 	}
  51. 	public void setCust_mobile(String cust_mobile) {
  52. 		this.cust_mobile = cust_mobile;
  53. 	}
  54. 	
  55. }

然后，再在该包下创建一个与以上实体类相对应的映射配置文件，即Customer.hbm.xml。

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
  3.     
  4. <hibernate-mapping>
  5. 	<!-- 建立类与表的映射 -->
  6. 	<class name="com.meimeixia.ssh.domain.Customer" table="cst_customer">
  7. 		<!-- 建立类中的属性与表中的主键相对应 -->
  8. 		<id name="cust_id" column="cust_id">
  9. 			<!-- 主键的生成策略，现在使用的是本地生成策略 -->
  10. 			<generator class="native" />
  11. 		</id>
  12. 		
  13. 		<!-- 建立类中的普通属性和表中的字段相对应 -->
  14. 		<property name="cust_name" column="cust_name" />
  15. 		<property name="cust_source" column="cust_source" />
  16. 		<property name="cust_industry" column="cust_industry" />
  17. 		<property name="cust_level" column="cust_level" />
  18. 		<property name="cust_phone" column="cust_phone" />
  19. 		<property name="cust_mobile" column="cust_mobile" />
  20. 	</class>
  21. </hibernate-mapping>

最后，记得在Hibernate的核心配置文件引入以上映射配置文件，千万不要忘记这一点哟！

修改客户添加页面

为了完成CRM系统中保存客户的功能，我们需要对客户添加页面（即add.jsp页面）进行如下修改。

Spring框架整合Struts2框架

Spring框架整合Struts2框架，共有两种方式，它们分别是：

下面，我会分别介绍这两种整合方式。

Spring整合Struts2方式一：Action还是由Struts2自身来创建

首先，在com.meimeixia.ssh.web.action包下创建一个CustomerAction。

  1. package com.meimeixia.ssh.web.action;
  3. import com.meimeixia.ssh.domain.Customer;
  4. import com.opensymphony.xwork2.ActionSupport;
  5. import com.opensymphony.xwork2.ModelDriven;
  7. /** * 客户管理的Action的类 * @author liayun * */
  8. public class CustomerAction extends ActionSupport implements ModelDriven<Customer> {
  10. 	//模型驱动使用的对象
  11. 	private Customer customer = new Customer();
  13. 	@Override
  14. 	public Customer getModel() {
  15. 		return customer;
  16. 	}
  18. 	/** * 保存客户的save方法 */
  19. 	public String save() {		
  20. 		System.out.println("CustomerAction中的save方法执行了......");
  21. 		return NONE;
  22. 	}
  24. }

然后，在Struts2配置文件中（即struts.xml）对以上CustomerAction进行配置。

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN" "http://struts.apache.org/dtds/struts-2.3.dtd">
  4. <struts>
  5. 	<!-- 配置Strust2的一些常量 -->
  6. 	<constant name="struts.action.extension" value="action" />
  7. 	
  8. 	<!-- 配置CustomerAction -->
  9. 	<package name="s2sh" extends="struts-default" namespace="/">
  10. 		<action name="customer_*" class="com.meimeixia.ssh.web.action.CustomerAction" method="{1}">
  11. 			
  12. 		</action>
  13. 	</package>
  14. </struts>

接着，咱就需要在CustomerAction中调用service层中的服务了。哎呀！service层中的接口和实现类咱也没有写啊！所以，接下来，我们还要编写service层中的接口和实现类。

  • 先在com.meimeixia.ssh.service包下编写如下一个名为CustomerService的接口。
  1. package com.meimeixia.ssh.service;
  3. import com.meimeixia.ssh.domain.Customer;
  5. /** * 客户管理的业务层的接口 * @author liayun * */
  6. public interface CustomerService {
  8. 	void save(Customer customer);
  10. }
  • 再在com.meimeixia.ssh.service.impl包下编写一个以上接口的实现类，即CustomerServiceImpl.java。
  1. package com.meimeixia.ssh.service.impl;
  3. import com.meimeixia.ssh.domain.Customer;
  4. import com.meimeixia.ssh.service.CustomerService;
  6. /** * 客户管理的业务层的实现类 * * @author liayun * */
  7. public class CustomerServiceImpl implements CustomerService {
  9. 	@Override
  10. 	public void save(Customer customer) {
  11. 		System.out.println("CustomerServiceImpl类中的save方法执行了......");
  12. 	}
  14. }

顺手，将以上实现类交给Spring来管理。

好了，现在我们就要来解决在CustomerAction中调用service层服务的问题了。这也得分两种情况来讨论：

  • 第一种情况：如果在web层中没有使用Struts2，这时我们还想要去获取业务层的类，那么就必须使用传统方式去获得业务层中的类。

  • 第二种情况：如果在web层中使用了Struts2，那么这时可以进行Spring和Struts2这两个框架的整合。咋整合呢？这是一个问题。

  • 首先，得引入struts2-spring-plugin-2.3.24.jar这个插件包。

在这个插件包下，有一个struts-plugin.xml文件，在该文件中有如下一个配置：

这说明，在这个struts-plugin.xml文件中，开启了一个struts.objectFactory的常量，在Struts2中只要开启了这个常量，那么就会引发下面的一些常量生效，尤其是struts.objectFactory.spring.autoWire这个常量，它可以让Action按照名称来自动注入Service。

  • 然后，改写CustomerAction类，定义一个CustomerService类型的属性，并生成set方法，接着便可以按照名称来自动注入该属性了。

以上便是Spring整合Struts2的第一种方式。

Spring整合Struts2方式二：Action交给Spring管理（或创建）

首先，还是要引入struts2-spring-plugin-2.3.24.jar这个插件包。然后，将CustomerAction交给Spring来管理。

然后，在Struts2配置文件中（即struts.xml）对CustomerAction进行配置。

以上便是Spring整合Struts2的第二种方式，在实际开发中，会推荐使用这种方式。为什么会推荐使用这种方式呢？这时因为：第一，管理方便，第二，它可以很容易地用AOP对咱们的Action进行增强，因为Action现在是交给Spring来管理了。

service层调用dao层

现在，咱就需要在 service层中调用dao层中的服务了。哎呀！dao层中的接口和实现类咱也没有写啊！所以，接下来，我们还要编写dao层中的接口和实现类。

  • 先在com.meimeixia.ssh.dao包下编写如下一个名为CustomerDao的接口。
  1. package com.meimeixia.ssh.dao;
  3. import com.meimeixia.ssh.domain.Customer;
  5. /** * 客户管理的Dao层的接口 * @author liayun * */
  6. public interface CustomerDao {
  8. 	void save(Customer customer);
  10. }
  • 再在com.meimeixia.ssh.dao.impl包下编写一个以上接口的实现类，即CustomerServiceImpl.java。
  1. package com.meimeixia.ssh.dao.impl;
  3. import com.meimeixia.ssh.dao.CustomerDao;
  4. import com.meimeixia.ssh.domain.Customer;
  6. /** * 客户管理的Dao层的实现类 * @author liayun * */
  7. public class CustomerDaoImpl implements CustomerDao {
  8. 	
  9. 	@Override
  10. 	public void save(Customer customer) {
  11. 		System.out.println("CustomerDaoImpl类中的save方法执行了......");
  12. 	}
  14. }

顺手，将以上实现类交给Spring来管理。

然后，改写CustomerServiceImpl实现类，定义一个CustomerDao类型的属性，并生成set方法。

  1. package com.meimeixia.ssh.service.impl;
  3. import com.meimeixia.ssh.dao.CustomerDao;
  4. import com.meimeixia.ssh.domain.Customer;
  5. import com.meimeixia.ssh.service.CustomerService;
  7. /** * 客户管理的业务层的实现类 * * @author liayun * */
  8. //@Transactional //在业务层使用注解
  9. public class CustomerServiceImpl implements CustomerService {
  11. 	// 注入Dao
  12. 	private CustomerDao customerDao;
  14. 	public void setCustomerDao(CustomerDao customerDao) {
  15. 		this.customerDao = customerDao;
  16. 	}
  18. 	@Override
  19. 	public void save(Customer customer) {
  20. 		System.out.println("CustomerServiceImpl类中的save方法执行了......");
  21. 		customerDao.save(customer);
  22. 	}
  24. }

接着，在Spring的配置文件中id为customerService的bean标签里面使用property标签注入以上customerDao属性。

这时，你可以做一个测试，发布咱们的项目到Tomcat服务器中，访问项目的首页之后，点击新增客户超链接，在跳转到客户添加页面后，直接点击保存按钮，那么你就会看到Eclipse控制台打印了如下信息，这就说明程序并没有任何问题。

Spring框架整合Hibernate框架

Spring框架整合Hibernate框架，也被称为是零障碍整合。Spring整合Hibernate时，要在Spring的配置文件中引入Hibernate的配置的信息，也就是说Spring需要加载Hibernate配置文件。这是为啥子呢？一旦Spring加载到了Hibernate配置文件，那么它就会通过LocalSessionFactoryBean这个类来帮我们创建SessionFactory对象。

在Spring和Hibernate整合的过程中，Spring提供了一个Hibernate的模板类（即HibernateTemplate类），它可以用来简化Hibernate部分的开发，它有点类似于Spring的JDBC模板类。所以，咱可以让dao层中的实现类（即CustomerDaoImpl类）去继承这个HibernateDaoSupport类，继承它有什么好处呢？如果你查看该类的源代码，那么你就能发现它里面提供了一个setHibernateTemplate方法。也就是说只要让你的实现类去继承了它，那么你就可以直接CustomerDaoImpl实现类中去注入模板了。

但这样做，还是有点不好，你还得在Spring配置文件中去配置Hibernate的模板类。其实CustomerDaoImpl实现类继承了HibernateDaoSupport类之后，还可以让咱们的代码更简化，查看HibernateDaoSupport类的源代码，在它的源代码里面，还提供了一个setSessionFactory(SessionFactory sessionFactory)方法，如果你给它注入了一个SessionFactory对象的话，它便会使用这个SessionFactory对象帮你创建一个Hibernate模板类的对象。

如此一来，CustomerDaoImpl实现类的代码就应该修改成下面这个样子。

现在咱只需要在CustomerDaoImpl实现类里面注入一个SessionFactory，它里面就会有一个Hibernate模板类的对象了。即咱要在Spring配置文件中id为customerDao的bean标签里面使用property标签注入sessionFactory属性。

此时，便再也不需要在Spring配置文件中配置Hibernate的模板了。

配置Spring的事务管理

这里，我们会使用Spring基于注解方式的声明式事务管理，因为写起来更加简单。

  • 第一步，配置事务管理器。

  • 第二步，开启事务注解。

  • 第三步，在业务层中的实现类上添加@Transactional注解。

至此，SSH框架整合的第一种方式，算是讲完了，真不容易！为了证明这一点，你可以做一个测试，发布咱们的项目到Tomcat服务器中，访问项目的首页之后，点击新增客户超链接，这时会跳转到客户添加页面，填入客户的相关信息之后，点击保存按钮，那么你就会看到咱的客户表中添加了一条新的记录。

SSH框架的整合方式二：将Hibernate的配置交给Spring来管理（不带Hibernate配置文件）

Spring整合Hibernate框架的时候，可以不用写Hibernate的核心配置文件。Hibernate的核心配置文件里面有哪些内容，就把这些内容交给Spring去管理。

复制一个web项目

首先，复制以上一个S2SH项目，将其重命名为S2SH02，然后再在其基础上讲解SSH框架整合开发的第二种方式。

将Hibernate的配置信息交给Spring来管理

查看之前编写的Hibernate核心配置文件，可知Hibernate核心配置文件里面包含了如下内容。

Spring整合Hibernate框架的时候，虽然可以不用写Hibernate的核心配置文件，但还是要把Hibernate核心配置文件中的基本信息配置和映射文件的引入放到Spring配置文件中进行配置。所以，这时Spring配置文件的内容就应修改为下面这个样子。

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 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.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">
  3. 	
  4. 	<!-- 引入外部属性文件 -->
  5. 	<context:property-placeholder location="classpath:jdbc.properties" />
  6. 	<!-- 配置C3P0连接池 -->
  7. 	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
  8. 		<property name="driverClass" value="${jdbc.driverClass}" />
  9. 		<property name="jdbcUrl" value="${jdbc.url}" />
  10. 		<property name="user" value="${jdbc.username}" />
  11. 		<property name="password" value="${jdbc.password}" />
  12. 	</bean>
  13. 	
  14. 	<!-- Spring整合Hibernate~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
  15. 	<!-- 引入Hibernate的配置信息。Spring通过加载Hibernate配置文件，帮我们生成SessionFactory -->
  16. 	<bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
  17. 		<!-- 这时，没有Hibernate配置文件 -->
  18. 		<!-- <property name="configLocation" value="classpath:hibernate.cfg.xml" /> -->
  19. 		
  20. 		<!-- 自己得注入一个连接池 -->
  21. 		<property name="dataSource" ref="dataSource" />
  22. 		<!-- 配置Hibernate的相关属性 -->
  23. 		<property name="hibernateProperties">
  24. 		
  25. 			<!-- Properties类型的属性，我们要怎么注入呢？ -->
  26. 			<props>
  27. 				<!-- 配置Hibernate的方言 -->
  28. 				<prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
  29. 				<!-- 打印sql语句 -->
  30. 				<prop key="hibernate.show_sql">true</prop>
  31. 				<!-- 格式化sql语句 -->
  32. 				<prop key="hibernate.format_sql">true</prop>
  33. 				<!-- 自动创建表 -->
  34. 				<prop key="hibernate.hbm2ddl.auto">update</prop>
  35. 			</props>
  36. 		</property>
  37. 		
  38. 		<!-- （引入映射文件）告诉Hibernate加载哪个映射文件 -->		
  39. 		<property name="mappingResources">
  40. 			<!-- mappingResources是一个String...类型的属性，String的可变参数我们可以当成数组，那数组怎么注入啊？ -->
  41. 			<list>
  42. 				<value>com/meimeixia/ssh/domain/Customer.hbm.xml</value>
  43. 			</list>
  44. 		</property>
  45. 	</bean>
  46. 	
  47. 	<!-- 配置CustomerAction~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
  48. 	<bean id="customerAction" class="com.meimeixia.ssh.web.action.CustomerAction" scope="prototype">
  49. 		<property name="customerService" ref="customerService"></property>
  50. 	</bean>
  51. 	
  52. 	<!-- 配置CustomerService~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
  53. 	<bean id="customerService" class="com.meimeixia.ssh.service.impl.CustomerServiceImpl">
  54. 		<property name="customerDao" ref="customerDao"></property>
  55. 	</bean>
  56. 	
  57. 	<!-- 配置CustomerDao~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
  58. 	<bean id="customerDao" class="com.meimeixia.ssh.dao.impl.CustomerDaoImpl">
  59. 		<property name="sessionFactory" ref="sessionFactory"></property>
  60. 	</bean>
  61. 	
  62. 	<!-- 你原来得这样干： -->
  63. 	<!-- HibernateTemplate里面也得需要注入SessionFactory，就跟我们原来JdbcTemplate需要注入连接池是一样的。 但是，别忘了，我们原来在dao层实现类上继承了一个东西就可以不用定义这个模板了。 <bean id="hibernateTemplate" class="org.springframework.orm.hibernate5.HibernateTemplate"> <property name="sessionFactory" ref="sessionFactory" /> </bean> -->
  64. 	
  65. 	<!-- 配置事务管理器 -->
  66. 	<bean id="transactionManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager">
  67. 		<!-- 它里面想要管理事务，还得获得连接，获得连接就需要SessionFactory -->
  68. 		<property name="sessionFactory" ref="sessionFactory" />
  69. 	</bean>
  70. 	<!-- 开启注解（式）事务 -->
  71. 	<tx:annotation-driven transaction-manager="transactionManager" />
  72. 	
  73. </beans>

在以上applicationContext.xml文件中，可以看到我们使用的是C3P0连接池，连接池对象中所使用到的配置信息（包括数据库驱动类的全名称、要连接的数据库、用户名以及密码等）都来自于src目录下的jdbc.properties属性文件当中，该文件的内容如下所示。

  1. jdbc.driverClass=com.mysql.jdbc.Driver
  2. jdbc.url=jdbc:mysql:///s2sh_crm
  3. jdbc.username=root
  4. jdbc.password=liayun

至此，SSH框架整合的第二种方式，咱也讲完了，还挺不容易的！为了证明这一点，我们可以做一个测试，发布咱们的项目到Tomcat服务器中，访问项目的首页，点击新增客户超链接，这时会跳转到客户添加页面，填入客户的相关信息之后，点击保存按钮，那么你就会看到咱的客户表中添加了一条新的记录。

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://liayun.blog.csdn.net/article/details/100577375

内容来源于网络，如有侵权，请联系作者删除！

spring框架学习

相关文章

    查看更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com