day03_2spring3

SSH整合(续)

一、spring整合hibernate：有hibernate.cfg.xml

前提：导入jar包，在前面已经介绍了jar包的整合，我们只需要将整合的所有jar包导进去即可。

1.创建实体表：

 CREATE TABLE `ssh1_user` (
   `id` int(11) NOT NULL AUTO_INCREMENT,
   `name` varchar(255) DEFAULT NULL,
   `age` int(11) DEFAULT NULL,
   PRIMARY KEY (`id`)
 ) ENGINE=InnoDB AUTO_INCREMENT=11 DEFAULT CHARSET=utf8

2.创建PO（持久化类）User

 public class User {
     private Integer id;
     private String name;
     private Integer age;

     public Integer getId() {
         return id;
     }
     public void setId(Integer id) {
         this.id = id;
     }
     public String getName() {
         return name;
     }
     public void setName(String name) {
         this.name = name;
     }
     public Integer getAge() {
         return age;
     }
     public void setAge(Integer age) {
         this.age = age;
     }
     @Override
     public String toString() {
         return "User [id=" + id + ", name=" + name + ", age=" + age + "]";
     }    

 }

PO持久化类

3.创建PO对应的ORM映射文件：User.hbm.xml

 <?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">

     <!-- ORM映射文件，用来联系持久化类和表的关系 -->
      <hibernate-mapping package="cn.itcast.ssh1.domain">
     <class name="User" table="ssh_user">
     <!-- 不写column就默认与name值一样，也就是默认和JavaBean属性一样 -->
     <id name="id" column="id">
     <!-- 主键生成策略 -->
     <generator class="native"></generator>
     </id>
     <property name="name" column="name"></property>
     <property name="age" column="age"></property>
     </class>
       </hibernate-mapping>

4.dao层：spring提供 HibernateTemplate 用于操作PO对象，类似Hibernate Session对象。所以我们提供成员属性和set方法让spring来注入

 public class UserDaoImpl  implements UserDao {
     //spring提供 HibernateTemplate 用于操作PO对象，类似Hibernate Session对象。
     private HibernateTemplate hibernateTemplate;
     public void setHibernateTemplate(HibernateTemplate hibernateTemplate) {
         this.hibernateTemplate = hibernateTemplate;
     }

     public void save(User user) {
         hibernateTemplate.save(user);
     }

 }

5.service层：依赖于持久层所以给出成员属性，让spring注入

 public class UserServiceImpl  implements UserService {
     //用spring去注入
     private UserDao userDao;
     public void setUserDao(UserDao userDao) {
         this.userDao = userDao;
     }

     public void register(User user) {
         userDao.save(user);
         System.out.println("注册成功");

     }

 }

6.hibernate.cfg.xml配置文件:在hibernate中怎么写这里还怎么写！关联上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>
     <property name="hibernate.connection.url">
         jdbc:mysql://localhost:3306/spring
     </property>
     <property name="hibernate.connection.username">root</property>
     <property name="hibernate.connection.password">123</property>

     <!-- 配置关于控制台打印sql语句的配置 -->
     <property name="hibernate.show_sql">true</property>
     <property name="hibernate.format_sql">true</property>

     <!--表的生成策略，一般开发中不会用 因为表是在前面先设计的-->
     <property name="hbm2ddl.auto">update</property>
     <!-- 绑定当前线程,一般也不用因为事务已经交给spring来控制了 -->
     <property name="current_session_context_class">thread</property>
     <!--设置数据库方言，因为数据库之间还是有差异，最好设置一下方言 -->
     <property name="hibernate.dialect">
         org.hibernate.dialect.MySQL5Dialect
     </property>

     <!-- 配置ORM映射文件 -->
     <mapping resource="cn/itcast/ssh1/domain/User.hbm.xml" />
 </session-factory>
 </hibernate-configuration>

hibernate.cfg.xml

7.spring配置文件applicationContext.xml:这里我们把dao层的HibernateTemplate配置上去

因为这个HibernateTemplate功能和session很像所以它也需要依赖SessionFactory

 <?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:tx="http://www.springframework.org/schema/tx"
        xmlns:aop="http://www.springframework.org/schema/aop"
        xmlns:context="http://www.springframework.org/schema/context"
        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">
 <!-- 1、userService的创建 -->
 <bean id="userService" class="cn.itcast.ssh1.service.UserServiceImpl">
 <!-- set方式注入 -->
 <property name="userDao" ref="userDao"></property>
 </bean>
 <!-- 2、创建userDao的实例 -->
 <bean id="userDao" class="cn.itcast.ssh1.dao.UserDaoImpl">
 <!-- set方式注入 -->
 <property name="hibernateTemplate" ref="hibernateTemplate"></property>
 </bean>

 <!-- 3、创建HibernateTemplate -->
 <bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate">
 <!-- 因为这个HibernateTemplate功能和session很像所以它也需要依赖SessionFactory -->
 <property name="sessionFactory" ref="sessionFactory"></property>

 </bean>

  <!-- 4、sessionFactory  加载hibenrate.cfg.xml 获得SessionFactory
         LocalSessionFactoryBean属性中注入文件位置* configLocation确定配置文件位置
     configLocation:配置一个配置文件的位置
     configLocations:配置多个配置文件的位置
     -->
 <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
 <property name="configLocation" value="classpath:hibernate.cfg.xml"></property>
 </bean>

 <!-- 5、配置事务管理器 这个是关于Hibernate的事务管理器所以我们需要将SessionFactory传给它，里面包含着基本四项 -->
 <bean id="txManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
 <property name="sessionFactory" ref="sessionFactory"></property>
 </bean>

 <!-- 6、我将AOP编程融入进来把事务配置和通知放一起 配置事务详情 ，事务详情依赖着事务管理器-->
 <tx:advice id="txAdvice" transaction-manager="txManager">
 <tx:attributes>
 <!-- 配置要添加事务的方法，还有就是隔离级别 和 传播行为，这两个是默认值  isolation="DEFAULT" propagation="REQUIRED"-->
 <tx:method name="register"/>
 </tx:attributes>
 </tx:advice>

 <!-- 7、AOP编程 将事务和切入点融合在一起-->
 <aop:config >
 <aop:advisor advice-ref="txAdvice" pointcut="execution(* cn.itcast.ssh1.service.UserServiceImpl.register(..))"/>
 </aop:config>
 </beans>

applicatiopnContext.xml

8.测试：

 //我们把之前的JUnit整合再来一遍
 @RunWith(value=SpringJUnit4ClassRunner.class)
 @ContextConfiguration(locations="classpath:applicationContext.xml")
 public class Test01 {
       //自动注入
     @Autowired
       private UserService userService;
       @Test
       public void fun01(){
           User user = new User();
           user.setName("迪丽热巴");
           user.setAge(26);
        userService.register(user);

       }
 }

需要注意的是在spring中要进行AOP的动态加入事务，在hibernate中的事务配置交给了spring，所以必须配置事务不然会发现程序是正确的数据库中没有值这是因为HibernateTemplate进行操作后没有提交事务导致的

二、spring整合hibernate：没有hibernate.cfg.xml

删除hibernate.cfg.xml文件，但需要保存文件内容，将其配置spring中，将hibernate中所有的配置都可以在spring中配置

1.修改后spring中的配置如下：

 <?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:tx="http://www.springframework.org/schema/tx"
        xmlns:aop="http://www.springframework.org/schema/aop"
        xmlns:context="http://www.springframework.org/schema/context"
        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">
 <!-- 数据源的创建 -->
 <context:property-placeholder location="classpath:JdbcInfo.properties"/>
 <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
 <property name="driverClass" value="${Driver}"></property>
 <property name="jdbcUrl" value="${Url}"></property>
 <property name="user" value="${User}"></property>
 <property name="password" value="${Password}"></property>
 </bean>

 <!-- 1.3配置 LocalSessionFactoryBean，获得SessionFactory
 需要数据源来替换hibernate中的基本四项1)dataSource 数据源
 2)hibernateProperties hibernate其他配置项hibernateProperties向这个类型为properties的属性注入hibernate各个配置
 3) 导入映射文件
             mappingLocations ，确定映射文件位置，需要“classpath:” ,支持通配符 【】
             mappingResources ，加载执行映射文件，从src下开始 。不支持通配符*
             mappingDirectoryLocations ，加载指定目录下的，所有配置文件
                 mappingJarLocations ， 从jar包中获得映射文件
 -->
 <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
 <property name="dataSource" ref="dataSource"></property>
 <property name="hibernateProperties">
 <props>
 <prop key="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</prop>
 <prop key="hibernate.show_sql">true</prop>
 <prop key="hibernate.format_sql">true</prop>
 <prop key="hbm2ddl.auto">update</prop>
 <prop key="current_session_context_class">thread</prop>
 </props>
 </property>
 <property name="mappingLocations" value="classpath:cn/itcast/ssh2/domain/*.hbm.xml"></property>
 </bean>

 <!-- 1、userService的创建 -->
 <bean id="userService" class="cn.itcast.ssh2.service.UserServiceImpl">
 <!-- set方式注入 -->
 <property name="userDao" ref="userDao"></property>
 </bean>
 <!-- 2、创建userDao的实例  我们在userDao中继承了HibernateDaoSupport所以我们只需要注入SessionFactory,和JdbcDaoSupport相似-->
 <bean id="userDao" class="cn.itcast.ssh2.dao.UserDaoImpl">
 <property name="sessionFactory" ref="sessionFactory"></property>
 </bean>

 <!-- 5、配置事务管理器 这个是关于Hibernate的事务管理器所以我们需要将SessionFactory传给它，里面包含着基本四项 -->
 <bean id="txManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
 <property name="sessionFactory" ref="sessionFactory"></property>
 </bean>

 <!-- 6、我将AOP编程融入进来把事务配置和通知放一起 配置事务详情 ，事务详情依赖着事务管理器-->
 <tx:advice id="txAdvice" transaction-manager="txManager">
 <tx:attributes>
 <!-- 配置要添加事务的方法，还有就是隔离级别 和 传播行为，这两个是默认值  isolation="DEFAULT" propagation="REQUIRED"-->
 <tx:method name="register"/>
 </tx:attributes>
 </tx:advice>

 <!-- 7、AOP编程 将事务和切入点融合在一起-->
 <aop:config >
 <aop:advisor advice-ref="txAdvice" pointcut="execution(* cn.itcast.ssh2.service.UserServiceImpl.register(..))"/>
 </aop:config>
 </beans>

spring的配置文件

2.修改dao层去掉HibernateTemplate使用继承HibernateDaoSupport因为里面含有创建HibernateTemplate的方法，我们需要向里面注入SessionFactory

 public class UserDaoImpl extends HibernateDaoSupport implements UserDao {

     public void save(User user) {
         this.getHibernateTemplate().save(user);
     }

 }

3.修改完成后就可以测试了测试代码和上面一样就不再写了！

三、struts整合spring:在spring中配置action的实例

前提：整合所有jar包，导入进去就行！，然后案例还是基于上面的！其他代码不变，配置struts核心控制器：过滤器到web.xml,把spring提供的监听配置到web.xml让其可以在启动服务器就加载spring配置文件

1.Action动作类的代码：

 public class UserAction extends ActionSupport implements ModelDriven<User> {

     private User user =new User();//模型驱动需要我们自己提供实例
     private UserService userService;//利用spring来注入

     public User getModel() {

         return user;
     }

     /**************register**************/
     public String register() throws Exception {
         System.out.println(user);
         userService.register(user);

         return SUCCESS;
     }

     public void setUserService(UserService userService) {
         this.userService = userService;
     }

 }

2.struts配置文件代码：可以看到动作类标签里面的class的值是和spring中配置动作类的id名一样，而不是以前的全类名了，当然写全类名写了也没错但是没有体现整合的这个概念

<?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>
    <!-- 开发者模式 -->
    <constant name="struts.devMode" value="true"></constant>

    <package name="p1" extends="struts-default" namespace="/ssh">
    <!-- 使用的是通配符*,{1}表示的内容和*是一样的1表示的是第几个* 这里的class可以写成spring中配置动作类的id名,因为可以整合到一起但是推荐的还是day03_5spring_ssh4的写法 -->
    <action name="UserAction_*" class="userAction" method="{1}">
    <result>/message.jsp</result>
    </action>
    </package>
    </struts>

3.spring的配置文件的代码：我们只需要在上面的spring配置文件的基础上加入

 <!-- 创建动作类的实例，将userService注入进去 -->
 <bean id="userAction" class="cn.itcast.ssh3.action.UserAction">
 <property name="userService" ref="userService"></property>
 </bean>

4.编写一个简单的jsp注册页面：注意这里使用的是struts2的标签注意要导入标签

 <s:form action="UserAction_register" namespace="/ssh">
     <s:textfield label="用户名" value="欧阳娜娜" requiredLabel="true" name="name" />
     <s:textfield label="年龄" value="20" requiredLabel="true"  name="age"/>
     <s:submit value="提交"/>
    </s:form>

5.web的配置文件：web.xml，配置spring的监听器时默认回去在WEB-INF下去找配置文件所以我们还要指定文件的位置

 <?xml version="1.0" encoding="UTF-8"?>
 <web-app version="2.5"
     xmlns="http://java.sun.com/xml/ns/javaee"
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
     http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
 <!-- 确定spring配置文件的位置 classpath:表示在类路径下，当web.xml运行时spring的配置文件就会被加载 ，这样就会为每个类创建实例-->
 <context-param>
 <param-name>contextConfigLocation</param-name>
 <param-value>classpath:applicationContext.xml</param-value>
 </context-param>

 <!-- 配置spring的监听器 -->
 <listener>
 <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
 </listener>

  <!-- 配置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>
   <welcome-file-list>
     <welcome-file>index.jsp</welcome-file>
   </welcome-file-list>
 </web-app>

6.启动服务器访问页面进行注册！

四、struts整合spring:在spring中不配置配置action的实例（不配置实例的话Action类中的UserService会被自动注入，但是前提是导入了插件jar包，而且Action中的setter方法名称和spring中配置id名userService的名称要一致才可以，struts.xml中动作标签class属性的名称恢复成正常的全限定类名）

前提导入jar包：struts2-spring-plugin-2.3.24.jar

1.struts.xml中动作标签的class值修改为以前的全限定类名　　struts <action class="全限定类名">

 <?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>
     <!-- 开发者模式 -->
     <constant name="struts.devMode" value="true"></constant>

     <package name="p1" extends="struts-default" namespace="/ssh">
     <!-- 使用的是通配符*,{1}表示的内容和*是一样的1表示的是第几个*
     class这个属性要是和spring整合之后就可以有两种写法  当在spring中配置了动作类的实例时就如下就可以写成和spring 中配置的id名一样
     如果不再spring中创建动作类的实例的话，这样就要些全限定类名，确保有struts2-spring-plugin-2.3.24.jar这个包因为里面有一个配置
     当动作类中的setUserService(注意是去掉set和第一个字母小写后) 和 spring中的这个实例的id名一样就可以自动注入UserService
     -->
     <action name="UserAction_*" class="cn.itcast.ssh3.action.UserAction" method="{1}">
     <result>/message.jsp</result>
     </action>
     </package>
     </struts>

2.要求：Action类中，必须提供service名称与 spring配置文件一致。（如果名称一样，将自动注入）

分析：

1. struts 配置文件

default.properties  ,常量配置文件

struts-default.xml ，默认核心配置文件

struts-plugins.xml ，插件配置文件

struts.xml，自定义核心配置文件

常量的使用，后面配置项，将覆盖前面的。

2.default.properties  ，此配置文件中确定 按照【名称】自动注入

/org/apache/struts2/default.properties

3. struts-plugins.xml ,struts整合spring

struts的action将由spring创建

总结：之后action有spring创建，并按照名称自动注入