1、SSH整合方式一：无障碍整合

1-1 SSH框架整合开发回顾

SSH整合_Java

1-2 SSH整合步骤

1-2-1 准备阶段

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

Struts2的jar包
 struts-2.3.24\apps\struts2-blank\WEB-INF\lib*.jar
Struts2中有一些包需要了解的：
 struts2-convention-plugin-2.3.24.jar ----Struts2的注解开发包。
 struts2-json-plugin-2.3.24.jar ----Struts2的整合AJAX的开发包。
 struts2-spring-plugin-2.3.24.jar ----Struts2的整合Spring的开发包。
Hibernate的jar包
 Hibernate的开发的必须的包
 hibernate-release-5.0.7.Final\lib\required*.jar
MySQL驱动
日志记录
使用C3P0连接池
注意：Struts2和Hibernate都引入了一个相同的jar包（javassist包）。删除一个*
Spring的jar包
  IOC的开发
SSH整合_spring_02
 AOP的开发
SSH整合_hibernate_03
 JDBC模板的开发
SSH整合_spring_04
 事务管理
SSH整合_struts_05
 整合web项目的开发
SSH整合_struts_06
 整合单元测试的开发
SSH整合_Java_07
 整合hibernate的开发
SSH整合_Java_08
以上所有jar包

  1. 第二步：引入配置文件
  • Struts的配置文件
    web.xml
  <filter>
  	<filter-name>struts</filter-name>
  	<filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
  </filter>
  <filter-mapping>
  	<filter-name>struts</filter-name>
  	<url-pattern>/*</url-pattern>
  </filter-mapping>

  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>
  • Hibernate的配置文件
    hibernate.cfg.xml
      删除那个与线程绑定的session。 
<?xml version="1.0" encoding="UTF-8"?>
<!-- 下面的约束在hibernate-core-5.0.7.Final.jar下的org.hibernate最后面的hibernate-configuration-3.0.dtd下 -->
<!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>
				<!-- 下面的参数可以在project\etc\hibernate.properties文件中找到 -->
		<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
		<property name="hibernate.connection.url">jdbc:mysql://47.97.91.178/hibernate_day03?useUnicode=true&amp;characterEncoding=UTF-8</property>
		<property name="hibernate.connection.username">qgc</property>
		<property name="hibernate.connection.password">2wsx@WSX</property>
		<!-- 配置Hibernate的方言 -->
		<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
		<property name="connection.provider_class">org.hibernate.connection.C3P0ConnectionProvider</property>
		<!-- 在连接池中可用的数据库连接的最少数目 -->
		<property name="c3p0.min_size">5</property>
		<!-- 在连接池中所有数据库连接的最大数目  -->
		<property name="c3p0.max_size">20</property>
		<!-- 设定数据库连接的过期时间,以秒为单位,
		如果连接池中的某个数据库连接处于空闲状态的时间超过了timeout时间,就会从连接池中清除 -->
		<property name="c3p0.timeout">120</property>
		 <!-- 每3000秒检查所有连接池中的空闲连接 以秒为单位 -->
		<property name="c3p0.idle_test_period">3000</property>
		<!-- 告诉hibernate映射文件在哪，注意此处不是.而是/ -->
		<!-- 打印sql语句 -->
		<property name="hibernate.show_sql">true</property>
		<!-- 格式化sql -->
		<property name="hibernate.format_sql">true</property>
		<!-- 数据库中没有这个表时，自动建表-->
        <property name="hibernate.hbm2ddl.auto">update</property>
	</session-factory>
</hibernate-configuration>

  映射文件

  • Spring的配置文件
    web.xml
	<!-- spring核心监听器  -->
	<listener>
		<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
	</listener>
	<!-- spring的配置文件路径，默认在WEB-INF下 -->
	<context-param>
		<param-name>contextConfigLocation</param-name>
		<param-value>classpath:applicationContext.xml</param-value>
	</context-param>

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: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">
	
</beans>

日志记录
  log4j.properties

### direct log messages to stdout ###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.err
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

### direct messages to file mylog.log ###
log4j.appender.file=org.apache.log4j.FileAppender
log4j.appender.file.File=c\:mylog.log
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

### set log levels - for more verbose logging change 'info' to 'debug' ###
# error warn info debug trace
log4j.rootLogger= info,stdout
  1. 创建包结构
    SSH整合_Java_09
  2. 第四步：创建相关类
    SSH整合_spring_10
  3. 第五步：引入相关的页面
  4. 第六步：修改add.jsp

1-2-2 Spring整合Struts2方式一：Action由Struts2自身创建的

  • 编写Action
  • 在struts.xml中配置Action
  • 在Action中引入Service
      传统方式引入 
public class CustomerAction extends ActionSupport implements ModelDriven<Customer>{
	private Customer customer;
	@Override
	public Customer getModel() {
		// TODO Auto-generated method stub
		return customer;
	}
	public String save() {
		WebApplicationContext applicationContext = WebApplicationContextUtils.getWebApplicationContext(ServletActionContext.getServletContext());
		CustomerService customerService = (CustomerService) applicationContext.getBean("customerService");
		System.out.println("action执行了");
		customerService.save(customer);
		return NONE;
	}
}

   进行Spring和Struts2的整合：

引入struts-spring-plugin.jar

将Service交给Spring管理

<bean id="customerService" class="com.qgc.ssh.service.Impl.CustomerServiceImpl"></bean>

Action注入Service

public class CustomerAction extends ActionSupport implements ModelDriven<Customer>{
	private Customer customer;
	@Override
	public Customer getModel() {
		// TODO Auto-generated method stub
		return customer;
	}
	private CustomerService customerService;
	public void setCustomerService(CustomerService customerService) {
		this.customerService = customerService;
	}
	public String save() {
		customerService.save(customer);
		return NONE;
	}
}

1-2-3 Spring整合Struts2方式二：Action交给Spring管理（推荐）

  1. 引入插件包
     引入struts-spring-plugin.jar
  2. 将Action交给Spring
	<!-- 配置action -->
	<bean id="customerAction" class="com.qgc.ssh.web.action.CustomerAction" scope="prototype">
		<property name="customerService" ref="customerService"></property>
	</bean>
  1. 在struts.xml中配置Action(如果不配置action，默认会生成两个action)
	<package name="ssh1" extends="struts-default" namespace="/">
		<action name="customer_*" class="customerAction" method="{1}">
		</action>
	</package>

注意：
需要配置Action为多例的
SSH整合_hibernate_11
需要手动注入Service
SSH整合_Java_12

1-2-4 Service调用DAO

  • 将DAO交给Spring管理
    SSH整合_spring_13
  • 在Service注入DAO
    SSH整合_Java_14
    SSH整合_hibernate_15

1-2-5 Spring整合Hibernate框架

  1. 创建数据库和表
Create database ssh1;
Use ssh1;
CREATE TABLE `cst_customer` (
  `cust_id` bigint(32) NOT NULL AUTO_INCREMENT COMMENT '客户编号(主键)',
  `cust_name` varchar(32) NOT NULL COMMENT '客户名称(公司名称)',
  `cust_source` varchar(32) DEFAULT NULL COMMENT '客户信息来源',
  `cust_industry` varchar(32) DEFAULT NULL COMMENT '客户所属行业',
  `cust_level` varchar(32) DEFAULT NULL COMMENT '客户级别',
  `cust_phone` varchar(64) DEFAULT NULL COMMENT '固定电话',
  `cust_mobile` varchar(16) DEFAULT NULL COMMENT '移动电话',
  PRIMARY KEY (`cust_id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;
  1. 编写实体和映射
  2. Spring和Hibernate整合

注意：在以下操作的导包过程中，注意使用的hibernate的版本，这里使用hibernate5

  • 在Spring的配置文件中，引入Hibernate的配置的信息
	<!-- 引入hibernate的配置信息 -->
	<bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
		<!-- 引入hibernate配置文件 -->
		<property name="configLocation" value="classpath:hibernate.cfg.xml"/>
	</bean>
  • 在Spring和Hibernate整合后，Spring提供了一个Hibernate的模板类简化Hibernate开发。类似于JdbcTemp…
  • 改写DAO继承HibernateDaoSupport
  • 配置的时候在DAO中直接注入SessionFactory
<bean id="customerDao" class="com.qgc.ssh.dao.Impl.CustomerDaoImpl">
	<property name="sessionFactory" value="sessionFactory"></property>
</bean>
  • 在DAO中使用Hibernate的模板完成保存操作
	public void save(Customer customer) {
		// TODO Auto-generated method stub
		System.out.println("调用dao成功。。。。");
		this.getHibernateTemplate().save(customer);
	}

1-2-6 配置Spring的事务管理

  • 配置事务管理器
<!-- 配置事务管理器 -->
	<bean id="transactionManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager">
		<property name="sessionFactory" ref="sessionFactory"/>
	</bean>
  • 开启注解事务
<!-- 开启注解事务 -->
	<tx:annotation-driven transaction-manager="transactionManager"/>
  • 在业务层使用注解
@Transactional
public class CustomerServiceImpl implements CustomerService {
2、SSH整合方式二：将hibernate的配置交给Spring管理
  • 准备工作

SSH整合方式二：不带hibernate配置文件
复制一个项目
hibernate配置文件中有哪些内容：
 数据库连接的配置
 Hibernate的相关的属性的配置
  方言
  显示SQL
  格式化SQL
  。。。
 C3P0连接池
 映射文件

2-1 将Hibernate的配置交给Spring 
<!-- 引入外部属性文件=============================== -->
	<context:property-placeholder location="classpath:jdbc.properties"/>
	
	<!-- 配置C3P0连接池=============================== -->
	<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.username}"/>
		<property name="password" value="${jdbc.password}"/>
	</bean>
	
	<!-- Spring整合Hibernate -->
	<!-- 引入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>
				<prop key="hibernate.show_sql">true</prop>
				<prop key="hibernate.format_sql">true</prop>
				<prop key="hibernate.hbm2ddl.auto">update</prop>
			</props>
		</property>
		
		<!-- 设置映射文件 -->
		<property name="mappingResources">
			<list>
				<value>com/itheima/ssh/domain/Customer.hbm.xml</value>
			</list>
		</property>
	</bean>
  • 所引入的外部文件jdbc.properties
jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://47.97.91.178/ssh1?useUnicode=true&amp;characterEncoding=UTF-8
jdbc.username=qgc
jdbc.password=2wsx@WSX
3、hibernate模板的使用

3-1 保存操作

  • service层
	public void save(Customer customer) {
		customerDao.save(customer);
	}
  • dao层（因为dao层继承了HibernateDaoSupport）
public void save(Customer customer) {
		// TODO Auto-generated method stub
		this.getHibernateTemplate().save(customer);
	}

3-2 修改操作

update(Object obj);

3-3 删除操作

delete(Object obj);

3-4 查询操作

  • 查询一个
    get(Class c,Serializable id);
    load(Class c,Serializable id);
  • 查询多个
    List find(String hql,Object… args);
    List findByCriteria(DetachedCriteria dc);
    List findByCriteria(DetachedCriteria dc,int firstResult,int maxResults);
    List findByNamedQuery(String name,Object… args);
4、延迟加载问题的解决

使用load方法查询某一个对象的时候（不常用）
查询到某个对象以后，显示其关联对象。
延迟加载出现的异常为** could not initialize proxy - no Session**
SSH整合_hibernate_16

解决方案：
添加一个如下所示的过滤器，该过滤器的作用是将session置于web层，注意该过滤器要加在struts2核心过滤器的前面否则无效

	<filter>
		<filter-name>ycjz</filter-name>
		<filter-class>org.springframework.orm.hibernate5.support.OpenSessionInViewFilter</filter-class>
	</filter>
	<filter-mapping>
		<filter-name>ycjz</filter-name>
		<url-pattern>*.action</url-pattern>
	</filter-mapping>