蒋振飞的博客 - Java进阶04:SSH框架整合   
正在加载蒋振飞的博客...
V3.0
蒋振飞的博客

Java进阶04:SSH框架整合

发布时间: 2019年01月19日 发布人: 蒋振飞 热度: 290 ℃ 评论数: 0

一、SSH整合方式一:无障碍整合

1.引入jar包

    1) 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的开发包。

    2) Hibernate的jar包

Hibernate的开发的必须的包   
    hibernate-release-5.0.7.Final\lib\required\*.jar
    
MySQL驱动
    mysql-connector-java-5.1.7-bin.jar
    
日志记录
    log4j-1.2.16.jar
    slf4j-api-1.6.1.jar
    slf4j-log4j12.1.7.2.jar
    
使用c3p0连接池
    c3p0-0.9.2.1.jar
    hibernate-c3p0-5.0.7.Final.jar
    mchange-commons-java-0.2.3.4.jar
    
注意:Struts2和Hibernate都引入了一个相同的jar包(javassist包),需要删除一个

    3) Spring的jar包

        ①IOC的开发

com.springsource.org.apache.commons.logging-1.1.1.jar
com.springsource.org.apahce.log4j-1.2.15.jar
spring-beans-4.2.4.RELEASE.jar
spring-context-4.2.4.RELEASE.jar
spring-core-4.2.4.RELEASE.jar
spring-expression-4.2.4.RELEASE.jar

        ②AOP的开发

com.springsource.org.aopalliance-1.0.0.jar
com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar
spring-aop-4.2.4.RELEASE.jar
spring-aspects-4.2.4.RELEASE.jar

        ③JDBC模板的开发

spring-jdbc-4.2.4.RELEASE.jar
spring-tx-4.2.4.RELEASE.jar

        ④事务管理

spring-tx-4.2.4.RELEASE.jar

        ⑤整合web项目的开发

spring-web-4.2.4.RELEASE.jar

        ⑥整合单元测试开发

spring-test-4.2.4.RELEASE.jar

        ⑦整合hibernate的开发

spring-orm-4.2.4.RELEASE.jar

2.引入配置文件

    1) Struts的配置文件

        ①web.xml

<!-- 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>

        ②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>
    <!-- 配置Struts2的常量 -->
    <constant name="struts.action.extension" value="action"/>
 
    <!-- 配置Action -->
    <package name="ssh1" extends="struts-default" namespace="/">
        <action name="customer_*" class="customerAction" method="{1}">
 
        </action>
    </package>
</struts>

    2) Hibernate的配置文件

        ①hibernate.cfg.xml

            删除那个与线程绑定的session。

<?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:///ssh1</property>
        <property name="hibernate.connection.username">root</property>
        <property name="hibernate.connection.password">abc</property>
        <!-- 配置Hibernate的方言 -->
        <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
 
        <!-- 可选配置================ -->
        <!-- 打印SQL -->
        <property name="hibernate.show_sql">true</property>
        <!-- 格式化SQL -->
        <property name="hibernate.format_sql">true</property>
        <!-- 自动创建表 -->
        <property name="hibernate.hbm2ddl.auto">update</property>
 
        <!-- 配置C3P0连接池 -->
        <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>
 
        <!-- 引入映射 -->
        <mapping resource="com//ssh/domain/Customer.hbm.xml"/>
    </session-factory>
</hibernate-configuration>

        ②映射文件

<?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.jzfblog.ssh.domain.Customer" table="cst_customer">
        <!-- 建立类中的属性与表中的主键对应 -->
        <id name="cust_id" column="cust_id" >
            <!-- 主键生成策略 -->
            <generator class="native"/>
        </id>
 
        <!-- 建立类中的普通的属性和表的字段的对应 -->
        <property name="cust_name" column="cust_name"  />
        <property name="cust_source" column="cust_source" />
        <property name="cust_industry" column="cust_industry"/>
        <property name="cust_level" column="cust_level"/>
        <property name="cust_phone" column="cust_phone"/>
        <property name="cust_mobile" column="cust_mobile"/>
    </class>
</hibernate-mapping>

    3) Spring的配置文件

        ①web.xml

<!-- Spring的核心监听器 -->
<listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
 
<!-- 加载Spring的配置文件的路径的,默认加载的/WEB-INF/applicationContext.xml -->
<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">
 
    <!-- Spring整合Hibernate -->
    <!-- 引入Hibernate的配置的信息=============== -->
    <bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
        <!-- 引入hibernate的配置文件 -->
        <property name="configLocation" value="classpath:hibernate.cfg.xml"/>
    </bean>
 
    <!-- 配置Action=================== -->
    <bean id="customerAction" class="com.jzfblog.ssh.web.action.CustomerAction" scope="prototype">
        <property name="customerService" ref="customerService"/>
    </bean>
 
    <!-- 配置Service================== -->
    <bean id="customerService" class="com.jzfblog.ssh.service.impl.CustomerServiceImpl">
        <property name="customerDao" ref="customerDao"/>
    </bean>
 
    <!-- 配置DAO====================== -->
    <bean id="customerDao" class="com.jzfblog.ssh.dao.impl.CustomerDaoImpl">
        <property name="sessionFactory" ref="sessionFactory"/>
    </bean>
 
 
    <!-- 配置事务管理器 -->
    <bean id="transactionManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory"/>
    </bean>
 
    <!-- 开启注解事务 -->
    <tx:annotation-driven transaction-manager="transactionManager"/>
</beans>

    4) 日志记录

        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

3.Spring整合Struts2方式一:Action由Struts2自身创建

    1) 编写Action

public class CustomerAction extends ActionSupport implements ModelDriven<Customer> {
    // 模型驱动使用对象:
    private Customer customer = new Customer();
 
    @Override
    public Customer getModel() {
        return customer;
    }
 
    /**
     * 保存客户的方法:save
     */
    public String save() {
 
        System.out.println("Action的save方法执行了...");
        return NONE;
    }
}

    2) 配置Action

        ①在struts.xml中配置。

<!-- 配置Action -->
<package name="ssh1" extends="struts-default" namespace="/">
    <action name="customer_*" class="customerAction" method="{1}">
 
    </action>
</package>

        ②在Action中引入Service。

            传统方式

// 如果web层没有Struts2,获取业务层的类就必须如下进行编写
WebApplicationContext applicationContext = WebApplicationContextUtils.getWebApplicationContext(ServletActionContext.getServletContext());
CustomerService customerService = (CustomerService) applicationContext.getBean("customerService");

            进行Spring和Struts2的整合

引入struts-spring-plugin.jar
在插件包中有如下配置
 
<constant name="struts.objectFactory" value="spring" />
 
struts.objectFactory.spring.autowire = name
 
让Action按照名称自动注入Service:

            将Service交给Spring管理

<!-- 配置Service================== -->
<bean id="customerService" class="com.jzfblog.ssh.service.impl.CustomerServiceImpl">
    <property name="customerDao" ref="customerDao"/>
</bean>

            Action注入Service

public class CustomerAction extends ActionSupport implements ModelDriven<Customer> {
    // 模型驱动使用的对象:
    private Customer customer = new Customer();
 
    @Override
    public Customer getModel() {
        return customer;
    }
 
    // 注入CustomerService:
    private CustomerService customerService;
 
    public void setCustomerService(CustomerService customerService) {
        this.customerService = customerService;
    }
    /**
     * 保存客户的方法:save
     */
    public String save() {
        // 如果web层没有Struts2,获取业务层的类就必须如下进行编写
        /*WebApplicationContext applicationContext = WebApplicationContextUtils.getWebApplicationContext(ServletActionContext.getServletContext());
        CustomerService customerService = (CustomerService) applicationContext.getBean("customerService");*/
 
        System.out.println("Action中的save方法执行了...");
        customerService.save(customer);
        return NONE;
    }
}

4.Spring整合Struts2方式二:Action交给Spring管理(推荐)

    1) 引入插件包

        struts-spring-plugin.jar。

    2) 将Action交给Spring管理

<!-- 配置Action=================== -->
<bean id="customerAction" class="com.jzfblog.ssh.web.action.CustomerAction" scope="prototype">
    <property name="customerService" ref="customerService"/>
</bean>

    3) 在struts.xml中配置Action

<!-- 配置Action -->
<package name="ssh1" extends="struts-default" namespace="/">
    <action name="customer_*" class="customerAction" method="{1}">
 
    </action>
</package>

    4) 将Action改为多例

        Spring默认为单例创建,而Action必须由多例创建,否则值栈将出现问题,需要增加scope="prototype"。

<bean id="customerAction" class="com.jzfblog.ssh.web.action.CustomerAction" scope="prototype">
</bean>

        需要手动注入Service

<bean id="customerAction" class="com.jzfblog.ssh.web.action.CustomerAction" scope="prototype">
    <property name="customerService" ref="customerService"/>
</bean>

5.Service调用DAO

    ①将DAO交给Spring管理

<!-- 配置DAO -->
<bean id="customerDao" class="com.jzfblog.ssh.dao.impl.CustomerDaoImpl">
    <property name="sessionFactory" ref="sessionFactory"/>
</bean>

    ②在Service注入DAO

public class CustomerServiceImpl implements CustomerService {
 
    // 注入DAO;
    private CustomerDao customerDao;
 
    public void setCustomerDao(CustomerDao customerDao) {
        this.customerDao = customerDao;
    }
 
    @Override
    public void save(Customer customer) {
        System.out.println("Service中的save方法执行了...");
        customerDao.save(customer);
    }
 
}

6.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;

    2) 编写实体和映射

    3) Spring和Hibernate整合

        在Spring的配置文件中,引入Hibernate的配置的信息。

<!-- Spring整合Hibernate -->
<!-- 引入Hibernate的配置的信息=============== -->
<bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
    <!-- 引入hibernate的配置文件 -->
    <property name="configLocation" value="classpath:hibernate.cfg.xml"/>
</bean>

    4) 在Spring和Hibernate整合后,Spring提供了一个Hibernate的模板类简化Hibernate开发

        改写DAO继承HibernateDaoSupport。

public class CustomerDaoImpl extends HibernateDaoSupport implements CustomerDao {
    @Override
    public void save(Customer customer) {
        System.out.println("DAO中的save方法执行了...");
    }
}

    5) 配置的时候在DAO中直接注入SessionFactory

<!-- 配置DAO====================== -->
<bean id="customerDao" class="com.jzfblog.ssh.dao.impl.CustomerDaoImpl">
    <property name="sessionFactory" ref="sessionFactory"/>
</bean>

    6) 在DAO中使用Hibernate的模板完成保存操作

public class CustomerDaoImpl extends HibernateDaoSupport implements CustomerDao {
    @Override
    public void save(Customer customer) {
        System.out.println("DAO中的save方法执行了...");
        this.getHibernateTemplate().save(customer);
    }
}

7.配置Spring的事务管理

    1) 配置事务管理器

<!-- 配置事务管理器 -->
<bean id="transactionManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager">
    <property name="sessionFactory" ref="sessionFactory"/>
</bean>

    2) 开启注解事务

<!-- 开启注解事务 -->
<tx:annotation-driven transaction-manager="transactionManager"/>

    3) 在业务层使用注解

@Transactional
public class CustomerServiceImpl implements CustomerService{}

二、SSH整合方式二:将hibernate的配置交给Spring管理

1.hibernate配置文件中有哪些内容

    1) 数据库连接的配置

    2) Hibernate的相关的属性的配置

        ①方言
        ②显示SQL
        ③格式化SQL
        ④...

    3) C3P0连接池

    4) 映射文件

2.将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/jzfblog/ssh/domain/Customer.hbm.xml</value>
        </list>
    </property>
</bean>

3.Hibernate的模板的使用

    1) Hibernate模板的常用的方法

        ①保存操作

            save(Object obj);

        ②修改操作

            update(Object obj);

        ③删除操作

            delete(Object obj);

        ④查询操作

            查询一个

                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);

    2) 使用方法

public class CustomerDaoImpl extends HibernateDaoSupport implements CustomerDao {
    // 保存
    @Override
    public void save(Customer customer) {
        this.getHibernateTemplate().save(customer);
    }
    // 修改
    @Override
    public void update(Customer customer) {
        this.getHibernateTemplate().update(customer);
    }
    // 删除
    @Override
    public void delete(Customer customer) {
        this.getHibernateTemplate().delete(customer);
    }
    // 查询一个
    @Override
    public Customer findById(Long cust_id) {
        // return this.getHibernateTemplate().get(Customer.class, cust_id);
        return this.getHibernateTemplate().load(Customer.class, cust_id);
    }
    // 查询多个
    @Override
    public List<Customer> findAllByHQL() {
        List<Customer> list = (List<Customer>) this.getHibernateTemplate().find("from Customer");
        return list;
    }
    // 查询多个
    @Override
    public List<Customer> findAllByQBC() {
        DetachedCriteria criteria = DetachedCriteria.forClass(Customer.class);
        List<Customer> list = (List<Customer>) this.getHibernateTemplate().findByCriteria(criteria);
        return list;
    }
    // 查询多个
    @Override
    public List<Customer> findAllByNamedQuery() {
        return (List<Customer>) this.getHibernateTemplate().findByNamedQuery("queryAll");
    }
}

打赏 蒋振飞

取消

感谢您的支持,我会继续努力的!

扫码支持
一分也是爱     一块不嫌多

点击 支付宝 或 微信 打赏蒋振飞

打开支付宝扫一扫,即可进行扫码打赏哦

评论列表