zoukankan      html  css  js  c++  java
  • Spring(五) SSH框架整合

    前言:路漫漫其修远兮,吾将上下而求索-----------jgp

    1 准备环境整合

      所谓整合就是将不同的框架放在一个项目中,共同使用它们的技术,使它们发挥各自的优点,并形成互补。

      1.1 准备数据库环境

      创建名称为ssh的数据库,然后在该数据库中创建一个t_user表,t_user表中有id、username、password三个字段

    CREATE DATABASE ssh;
    USE ssh;
    CREATE TABLE t_user(
    id INT(10) NOT NULL AUTO_INCREMENT,
    username VARCHAR(20) DEFAULT NULL,
    password VARCHAR(20) DEFAULT NULL,
    PRIMARY KEY(id)
    );

      

      1.2 配置Struts2环境

      1.2.1 导入struts2相关jar包(13个)

      

      1.2.2 添加log4j.properties文件

      本项目需要添加一个log4j.properties文件,作为log4j日志技术的配置文件。

      在添加log4j.properties文件之前,首先在项目中创建一个名为config的Source Folder(源文件夹),专门用于存放各种配置文件,是源文件夹,不是普通文件夹

      log4j.properties文件的具体内容如下:

    ### direct log messages to stdout ###
    log4j.appender.stdout=org.apache.log4j.ConsoleAppender
    log4j.appender.stdout.Target=System.out
    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=d: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' ###
    
    log4j.rootLogger=info, stdout

       1.2.3 在web.xml中配置核心过滤器

    <?xml version="1.0" encoding="UTF-8"?>
    <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xmlns="http://java.sun.com/xml/ns/javaee" 
             xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
             xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
                                  http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id="WebApp_ID" version="3.0">
        <!--配置Struts2核心控制器 -->
        <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>
    </web-app>

      1.2.4 在struts.xml配置文件

      在config路径下添加struts2配置文件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>
        <!-- 开发模式 -->
        <constant name="struts.devMode" value="true"></constant>
        <package name="ssh" namespace="/" extends="struts-default">
        
        </package>
    </struts>

       1.3 配置Spring环境

      配置完Struts2环境后,接下来配置Spring环境。

      1.3.1 导入Spring的依赖jar包(14个)

      

      1.3.2 核心配置文件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/aop 
                                  http://www.springframework.org/schema/aop/spring-aop.xsd
                                  http://www.springframework.org/schema/context 
                                  http://www.springframework.org/schema/context/spring-context.xsd
                                  http://www.springframework.org/schema/tx 
                                  http://www.springframework.org/schema/tx/spring-tx.xsd">
    </beans>

      1.3.3 在web.xml文件中配置Spring的监听器

      添加完该配置后的web.xml文件如下

    <?xml version="1.0" encoding="UTF-8"?>
    <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns="http://java.sun.com/xml/ns/javaee" 
        xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
        xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
             http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
        id="WebApp_ID" version="3.0">
        <!-- 监听器 -->
        <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>
    
        <!--配置Struts2核心控制器 -->
        <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>
    </web-app>

      1. 4 配置Hibernate环境

      Struts2和Spring环境配置完毕后,接下来,对Hibernate的环境进行配置

      1.4.1 导入运行Hibernate所需的jar包(12个)

      

      在上述jar包中,javassist-3.12.0.GA.jar在struts2中已经添加过,所以在项目整合时不需要重新添加。

      1.4.2 添加核心配置文件hibernate.cfg.xml

      在项目的config文件夹中添加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 基本4项 -->
            <property name="connection.driver_class">
                com.mysql.jdbc.Driver
             </property>
            <property name="connection.url">
                jdbc:mysql://localhost:3306/ssh
                 </property>
            <property name="connection.username">root</property>
            <property name="connection.password">1122</property>
            <!-- 2 方言 -->
            <property name="dialect">org.hibernate.dialect.MySQL5Dialect</property>
            <!-- 3 sql -->
            <property name="show_sql">true</property>
            <property name="format_sql">true</property>
            <property name="hbm2ddl.auto">update</property>
            <!-- 4 取消bean校验 -->
            <property name="javax.persistence.validation.mode">none</property>
            <!-- 5整合c3p0 -->
            <property name="hibernate.connection.provider_class">
                org.hibernate.connection.C3P0ConnectionProvider
                 </property>
             <!-- 可以添加映射文件 -->
        </session-factory>
    </hibernate-configuration>

      至此,Struts2、Spring和Hibernate的环境均准备完成,jar包个数为38个(13+14+12-1=38),完成后的项目结构如图:

      

    2 Spring和Hibernate的整合

      hibernate.cfg.xml文件是Hibernate中重要的配置文件,当Spring和Hibernate整合时,由于hibernate.cfg.xml文件中的配置信息可以交给Spring来管理

    所以可以选择是否使用hibernate.cfg.xml文件,下面我们将从使用hibernate.cfg.xml文件和不使用hibernate.cfg.xml文件两种情况来进行整合测试。

      2.1 介绍

      Spring和Hibernate的整合,需要再添加一个支持整合的JAR包Spring-orm-3.2.2.RELEASE.jar,该jar包可以在下载的Spring解压目录的libs目录中找到。

      在讲解Spring和Hibernate的整合前,首先需要了解三个重要的对象,具体如下:

      • HibernateTemplate:相当于Hibernate的session可以直接操作PO类,依赖于sessionFactory。
      • LocalSessionFactoryBean:获得SessionFactory。
      • HibernateTransactionManager:Hibernate的事务管理器。

      2.2 使用hibernate.cfg.xml文件

      项目的结构如下:

      

      2.2.1 Domain层

       User.java

    public class User {
        private Integer id;
        private String username;
        private String password;
        public Integer getId() {
            return id;
        }
        public void setId(Integer id) {
            this.id = id;
        }
        public String getUsername() {
            return username;
        }
        public void setUsername(String username) {
            this.username = username;
        }
        public String getPassword() {
            return password;
        }
        public void setPassword(String password) {
            this.password = password;
        }
    }

       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">
    <hibernate-mapping>
        <class name="com.tcxpz.ssh_pro02.domain.User" table="t_user">
            <id name="id">
                <generator class="native"></generator>
            </id>
            <property name="username" column="username"></property>
            <property name="password" column="password"></property>
        </class>
    </hibernate-mapping>

      在User.hbm.xml映射文件编写完成后,需要在Hibernate的核心配置hibernate.cfg.cml中添加此映射文件的信息

      

      2.2.2 Dao层

      UserDao.java

    public interface UserDao {
        public void save(User user);
        public void update(User user);
        public void delete(User user);
        public User findById(Integer id);
        public List<User> findAll();
    }

      UserDaoImpl.java

    public class UserDaoImpl implements UserDao{
        private HibernateTemplate hibernateTemplate;
        public void setHibernateTemplate(HibernateTemplate hibernateTemplate) {
            this.hibernateTemplate = hibernateTemplate;
        }
        @Override
        public void save(User user) {
            this.hibernateTemplate.save(user);
        }
        @Override
        public void update(User user) {
            this.hibernateTemplate.update(user);
        }
        @Override
        public void delete(User user) {
            this.hibernateTemplate.delete(user);
        }
        @Override
        public User findById(Integer id) {
            return this.hibernateTemplate.get(User.class, id);
        }
        @Override
        public List<User> findAll() {
            return this.hibernateTemplate.find("from User");
        }
    }

      2.2.3 service层

      UserService.java

    public interface UserService {
        public void saveUser(User user);
        public void updateUser(User user);
        public void deleteUser(User user);
        public User findUserById(Integer id);
        public List<User> findAllUser();
    }

      UserServiceImpl.java

    public class UserServiceImpl implements UserService {
        private UserDao userDao;
        public void setUserDao(UserDao userDao) {
            this.userDao = userDao;
        }
        @Override
        public void saveUser(User user) {
            this.userDao.save(user);
        }
        @Override
        public void updateUser(User user) {
            this.userDao.update(user);
        }
        @Override
        public void deleteUser(User user) {
            this.userDao.delete(user);
        }
        @Override
        public User findUserById(Integer id) {
            return this.userDao.findById(id);
        }
        @Override
        public List<User> findAllUser() {
            return this.userDao.findAll();
        }
    }

      2.2.4  Spring文件中进行配置

      我们的测试程序需要从Spring容器中获得UserService实例对象,而UsersService依赖于UserDao,UserDao又依赖于HibernateTemplate,HibernateTmplate依赖于SessionFactory,

    所以Spring容器需要创建SessionFactory实例对象,而创建这个对象需要注入configLocation属性。此外,我们还要对事务进行管理,要配置事务管理器。

      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/aop 
                                  http://www.springframework.org/schema/aop/spring-aop.xsd
                                  http://www.springframework.org/schema/context 
                                  http://www.springframework.org/schema/context/spring-context.xsd
                                  http://www.springframework.org/schema/tx 
                                  http://www.springframework.org/schema/tx/spring-tx.xsd">
    <!-- 1 配置SessionFactory -->
        <bean id="sessionFactory"
            class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
            <!-- 加载hibernate核心配置文件 -->
            <property name="configLocation" value="classpath:hibernate.cfg.xml">
            </property>
        </bean>
        <!-- 2 配置hibernate模板 -->
        <bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate">
            <!-- 通过工厂获得session,操作PO类 -->
            <property name="sessionFactory" ref="sessionFactory"></property>
        </bean>
        <!-- 3 配置dao -->
        <bean id="userDao" class="com.tcxpz.ssh_pro02.dao.UserDaoImpl">
            <property name="hibernateTemplate" ref="hibernateTemplate">
            </property>
        </bean>
        <!-- 4 配置service -->
        <bean id="userService" class="com.tcxpz.ssh_pro02.service.UserServiceImpl">
            <property name="userDao" ref="userDao"></property>
        </bean>
        <!-- 事务管理 -->
        <!-- #1 事务管理器,就是平台,spring工具产生,依赖于使用 持久方案(hibernate、jdbc等) -->
        <bean id="txManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
            <property name="sessionFactory" ref="sessionFactory"></property>
        </bean>
        <!-- #2 通知:增强事务 -->
        <tx:advice id="txAdvice" transaction-manager="txManager">
            <tx:attributes>
                <tx:method name="save*" />
                <tx:method name="update*" />
                <tx:method name="delete*" />
                <tx:method name="find*" read-only="true" />
            </tx:attributes>
        </tx:advice>
        <!-- #3 切面:将切入点 与 通知 关联 -->
        <aop:config>
            <aop:advisor advice-ref="txAdvice"
                pointcut="execution(* com.tcxpz.ssh_pro02.service.*.*(..))"/>
        </aop:config>
    </beans>

       2.2.5 测试

      TestApp.java

    public class TestApp {
        @Test
        public void demo(){
            User user = new User();
            user.setUsername("jack");
            user.setPassword("12345678");
            String xmlPath = "applicationContext.xml";
            ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);
            UserService userService = (UserService) applicationContext.getBean("userService");
            userService.saveUser(user);
        }
    }

       测试结果:

        

      其他方法的测试结果不再赘述了。

      2.3 不使用hibernate.cfg.xml

      如果不使用hibernate.cfg.xml的方式来整合Spring和Hibernate,那我们就要将hibernate.cfg.xml文件中的配置信息添加到applicationContext.xml文件中,

      所以只需要完成两步即可:

      (1) 将hibernate.cfg.xml文件中的配置信息转移到applicationContext.xml文件中(修改applicationContext.xml)

      (2) 删除hibernate.cfg.xml文件(删除hibernate.cfg.xm)

      修改后的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:tx="http://www.springframework.org/schema/tx" xmlns:aop="http://www.springframework.org/schema/aop"
           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/tx 
                                    http://www.springframework.org/schema/tx/spring-tx.xsd
                                    http://www.springframework.org/schema/aop 
                                    http://www.springframework.org/schema/aop/spring-aop.xsd">
            <!-- 1 配置数据源 -->
        <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
            <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
            <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/ssh"></property>
            <property name="user" value="root"></property>
            <property name="password" value="1122"></property>
        </bean>
            <!-- 2 配置SessionFactory -->
        <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="hibernate.hbm2ddl.auto">update</prop>
                    <prop key="javax.persistence.validation.mode">none</prop>
                    <prop key="hibernate.current_session_context_class">thread</prop>
                </props>
            </property>
            <property name="mappingResources" value="com/tcxpz/ssh_pro03/domain/User.hbm.xml"></property>
        </bean>
            <!-- 3配置hibernateTemplate -->
        <bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate">
            <property name="sessionFactory" ref="sessionFactory"></property>
        </bean>
            <!-- 4 配置dao -->
        <bean id="userDao" class="com.tcxpz.ssh_pro03.dao.UserDaoImpl">
            <property name="hibernateTemplate" ref="hibernateTemplate"></property>
        </bean>
            <!-- 5 配置service -->
        <bean id="userService" class="com.tcxpz.ssh_pro03.service.UserServiceImpl">
            <property name="userDao" ref="userDao"></property>
        </bean>
            <!-- 事务管理 -->
            <!-- #1 事务管理器,就是平台,spring工具产生,依赖于使用 持久方案(hibernate、jdbc等) -->
        <bean id="txManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
            <property name="sessionFactory" ref="sessionFactory"></property>
        </bean>
        <!-- #2 通知:增强事务 -->
        <tx:advice id="txAdvice" transaction-manager="txManager">
            <tx:attributes>
                <tx:method name="save*" />
                <tx:method name="update*" />
                <tx:method name="delete*" />
                <tx:method name="find*" read-only="true" />
            </tx:attributes>
        </tx:advice>
        <!-- #3 切面:将切入点 与 通知 关联 -->
        <aop:config>
            <aop:advisor advice-ref="txAdvice"
                pointcut="execution(* com.tcxpz.ssh_pro03.service.*.*(..))"/>
        </aop:config>
    </beans>

    3 Spring和Struts2的整合

      我们介绍了Spring和Hibernate的整合。在实际开发中,使用三大框架时,还需要将Spring和Struts2框架进行整合。

      Spring与Struts2整合的目的是将Struts2中Action的实例化工作交给Spring进行统一管理。

      3.1 介绍

      在Spring和Struts2进行整合时,需要导入一个JAR包struts2-spring-plugin-2.3.24.jar,该jar文件可以在已下载的Struts2的解压包的lib目录中找到。

      3.2 Spring创建Action

      下面通过一个案例来讲解Spring创建Action的情况(对上面的案例继续拓展)。

      

      3.2.1 创建action类

      UserAction.java(UserAction类依赖于UserService类,需要在Spring容器创建user_action对象时进行注入

    public class UserAction extends ActionSupport implements ModelDriven<User>{
        private User user = new User();
        @Override
        public User getModel() {
            return this.user;
        }
        //UserAction依赖于UserService,需要注入UserService
        private UserService userService;
        public void setUserService(UserService userService) {
            this.userService = userService;
        }
        public String add(){
            this.userService.saveUser(user);
            return "success";
        }
    }

      3.2.2 applicationContext.xml配置

       因为我们要让Spring容器给我们创建UserAction的实例对象,所以需要在applicationContext.xml中进行配置,并且向user_action对象中注入userService对象

      添加代码如下:

      

      3.2.3 struts.xml配置

      修改struts文件,将UserAction的信息加入到配置文件中。

      

      3.2.4 添加测试页面

      测试时需要用到两个页面,在WebRoot目录下添加index.jsp和成功页面success.jsp

      index.jsp

    <%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
    <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
    <html>
        <head>
            <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
            <title>添加用户</title>
        </head>
        <body>
            <form action="${pageContext.request.contextPath}/userAction_add"
                method="post">
                用户名:<input type="text" name="username" /> <br/>&nbsp&nbsp&nbsp码:<input type="password" name="password" /> <br/> 
                <input type="submit" value="添加" />
            </form>
        </body>
    </html>

      success.jsp

    <%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
    <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
    <html>
        <head>
            <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
            <title>成功页面</title>
        </head>
        <body>
            <h1>操作成功</h1>
        </body>
    </html>

      3.2.5 测试

      启动Tomcat服务器,在浏览器成功访问后,会进入添加页面,在页面输入用户名“糖醋小瓶子”和密码“tcxpz”,然后单击“添加”按钮。

      浏览器跳转到成功页面

      

      在数据库中成功添加了一条记录

      

       3.3 Struts2自己创建Action

      上面的案例中,Action的创建工作是交给Spring框架来完成的,如果不想这样做,而是仍然由Struts2自身创建Action,

    那么只用对上面的案例进行以下 两个修改就行了 

      (1)删除applicationContext.xml中对user_action的配置

      (2)修改struts.xml文件配置

      

      其实很好理解,既然我们要让struts2自己来创建UserAction对象,那么肯定要删除applicationContext.xml中对于user_action的配置,

    既然删除了applicationContext.xml中对于user_action的配置,那就要在struts.xml文件中进行配置,让他自己能够创建UserAction对象。

      这就引出来一个问题,我们删除了applicationContext.xml中对于user_action的配置,那么在userAction对象中需要用到的userService对象谁来注入呢?

       原来在struts-2.3.24srccoresrcmain esourcesorgapachestruts2default.properties文件下已经对struts2做了如下的配置

       

      当struts2创建实例对象时,将会按照名称自动注入对象,这就要求我们在UserAction中的需要注入的属性名与applicationContext.xml文件中的对象名(id)相同。

      

      4 注解 

      这里也可以用注解的方式进行配置,但是感觉配置德乱七八糟的,还不如将所有的配置信息写在xml文件中,直观易维护。暂时就不测试了,以后需要的话再深究吧! 

  • 相关阅读:
    设计规范理解
    JVM读书笔记
    springboot整合RabbitMQ
    springboot 整合Redis
    tomcat原理
    配置嵌入式Servlet容器
    Springboot自动配置原理
    Springboot启动原理
    Springboot配置文件加载顺序
    修改VisualSVN Server地址为ip地址,修改svn服务端地址为ip或者域名地址的方法
  • 原文地址:https://www.cnblogs.com/tcxpz/p/9775280.html
Copyright © 2011-2022 走看看