(转)hibernate-5.0.7+struts-2.3.24+spring-4.2.4三大框架整合

Posted 疯子加天才

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了(转)hibernate-5.0.7+struts-2.3.24+spring-4.2.4三大框架整合相关的知识,希望对你有一定的参考价值。

http://blog.csdn.net/yerenyuan_pku/article/details/70040220

SSH框架整合思想

三大框架应用在JavaEE三层结构,每一层都用到了不同的框架。SSH框架整合的思想可用下图来表示: 

SSH框架的整合方式一:零障碍整合(带有Hibernate配置文件)

我们先整合Struts2和Spring这两个框架,再整合Spring和Hibernate这两个框架。

整合Struts2和Spring框架

整合Struts2和Spring这两个框架要解决的事情就是把Struts2的Action的创建交给Spring来配置。 
第一步,创建Web项目,导入Struts2框架相关的jar包。 
要进行Struts2的基本的开发,可以参考struts-2.3.24中的apps下的一些示例代码,其中struts2-blank.war是一个Struts2的空的工程。我们只需要将struts2-blank.war解压后进入到WEB-INF下的lib中查看。 

除此之外,对于Struts2还需要了解以下jar包:

  • struts2-convention-plugin-2.3.24.jar:Struts2注解的开发包
  • struts2-json-plugin-2.3.24.jar:Struts2整合AJAX返回JSON数据
  • struts2-spring-plugin-2.3.24.jar:Struts2整合Spring的插件包。在本文中,我只导入了这个jar包。

第二步,编写一个Action。 
在src目录下创建一个cn.itcast.action包,并在该包下创建一个UserAction。

public class UserAction extends ActionSupport {

    @Override
    public String execute() throws Exception {
        System.out.println("action..........");
        return NONE;
    }

}
  • 1

第三步,创建Struts2的核心配置文件,该核心配置文件的位置是在src目录下面,名称是struts.xml。并且在该核心配置文件配置UserAction。

<?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>
    <package name="demo" extends="struts-default" namespace="/">
        <action name="user" class="cn.itcast.action.UserAction"></action>
    </package>
</struts>
  • 1

此时UserAction类由Struts2自己创建。 
注意:Struts2和Spring框架整合的时候,Struts2核心配置文件的名称和位置是有固定要求的,即名称只能是struts.xml,且必须位于src目录下面。 
第四步,配置Struts2的过滤器。即在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>
  • 1

第五步,导入Spring框架相关的jar包。

  • Spring框架基本开发的jar包: 
  • AOP开发相关的jar包: 
  • 与JDBC开发相关的jar包: 
  • 与事务管理的开发相关jar包: 
  • 整合Hibernate的jar包: 
  • 整和Web项目的jar包: 

第六步,创建Spring的核心配置文件——bean1.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>
    • 1
  • 配置Spring的监听器,即在web.xml配置文件中添加如下配置:

    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
  • 指定Spring配置文件的位置,即在web.xml配置文件中添加如下配置:

    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:bean1.xml</param-value> <!-- 因为bean1.xml配置文件在src目录下,故可直接这样写 -->
    </context-param>

第七步,把UserAction交给Spring进行配置,即在Spring配置文件中添加如下配置:

<!-- 配置action对象 -->
<bean id="userAction" class="cn.itcast.action.UserAction" scope="prototype"></bean>

这时,在Spring配置文件——bean1.xml中配置了UserAction对象,在Struts2配置文件——struts.xml中也配置了UserAction对象。很显然,这种做法是不可取的。解决思路是只需要在Spring配置文件里面配置UserAction对象,而不要在Struts2配置文件中配置。所以,Struts2配置文件应该改为:

<?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>
    <package name="demo" extends="struts-default" namespace="/">
        <!-- 在action标签里面不要写action全路径,class属性值写在Spring配置action对象的bean标签的id值 -->
        <action name="user" class="userAction"></action>
    </package>
</struts>

 

到这里,Struts2和Spring框架已经整合好了,现在就需要测试是否真如我们所愿了。 
在src目录下创建一个cn.itcast.dao包,并在该包下编写Dao层的一个类——UserDao.java。

public class UserDao {

    public void add() {
        System.out.println("dao..............");
    }

}

 

然后在src目录下创建一个cn.itcast.service包,并在该包下编写Service层的一个类——UserService.java,并在该类中调用UserDao类里面的方法。

public class UserService {

    private UserDao userDao;
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void add() {
        System.out.println("service..............");
        userDao.add();
    }

}

 

接着在UserAction类里面调用UserService类里面的方法。

public class UserAction extends ActionSupport {

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

    @Override
    public String execute() throws Exception {
        System.out.println("action..........");
        userService.add();
        return NONE;
    }

}

 

相应地,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: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">

    <!-- 配置action对象 -->
    <bean id="userAction" class="cn.itcast.action.UserAction" scope="prototype">
        <property name="userService" ref="userService"></property>
    </bean>

    <bean id="userService" class="cn.itcast.service.UserService">
        <property name="userDao" ref="userDao"></property>
    </bean>
    <bean id="userDao" class="cn.itcast.dao.UserDao"></bean>
</beans>

 

最后,在浏览器地址栏中输入地址http://localhost:8080/Spring_day04_demo1/user.action,即可在Eclipse控制台看到如下输出结果:

action………. 
service………….. 
dao…………..

整合Spring和Hibernate框架

我之前也说过,要整合Spring和Hibernate框架,须解决下面两件事情:

  1. 把Hibernate核心配置文件里面的数据库信息的配置交给Spring来管理。
  2. 把Hibernate里面的SessionFactory的创建交给Spring来管理。

下面我就来详细介绍Spring框架整合Hibernate框架的具体实现。 
第一步,导入Hibernate开发相关的jar包。 
首先导入lib/required目录下所有的jar包,因为在该目录下,包含运行Hibernate项目必须的jar包。 

再导入MySQL数据库的驱动jar包: 

接着再导入日志相关的jar包: 

其中log4j的包由Spring导入。 
在进行这一步时,可能会遇到以下两个问题:

  1. 导入Struts2和Hibernate的jar包时有jar包冲突问题(两个jar包功能相同,但版本不一样),即在Struts2里面有一个这样的jar包: 
     
    在Hibernate里面也有这样的一个jar包: 
     
    解决方式很简单了,就是删除那个低版本的jar包。
  2. Spring整合持久化层框架时,还须导入如下jar包: 

第二步,搭建Hibernate开发环境。

  1. 创建实体类。在src目录下创建一个cn.itcast.entity包,并在该包下编写一个User实体类。

    public class User {
    
        private Integer uid;
        private String username;
        private String address;
        public Integer getUid() {
            return uid;
        }
        public void setUid(Integer uid) {
            this.uid = uid;
        }
        public String getUsername() {
            return username;
        }
        public void setUsername(String username) {
            this.username = username;
        }
        public String getAddress() {
            return address;
        }
        public void setAddress(String address) {
            this.address = address;
        }
    
    }
    • 1
  2. 配置实体类映射关系,即在cn.itcast.entity包中创建User.hbm.xml映射文件:

    <?xml version="1.0"?>
    <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
    <!-- Generated 2017-4-5 14:44:57 by Hibernate Tools 3.4.0.CR1 -->
    <hibernate-mapping>
        <class name="cn.itcast.entity.User" table="t_user">
            <id name="uid" type="java.lang.Integer">
                <column name="uid" />
                <generator class="native" />
            </id>
            <property name="username" type="java.lang.String">
                <column name="username" />
            </property>
            <property name="address" type="java.lang.String">
                <column name="address" />
            </property>
        </class>
    </hibernate-mapping>
    • 1
  3. 创建Hibernate核心配置文件,即在src目录下引入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>
            <!-- 配置关于数据库连接的四个项:driverClass  url username password -->
            <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
            <property name="hibernate.connection.url">jdbc:mysql:///hibernateTest</property>
            <property name="hibernate.connection.username">root</property>
            <property name="hibernate.connection.password">yezi</property>
    
            <!-- 可以将向数据库发送的SQL语句显示出来 -->
            <property name="hibernate.show_sql">true</property>
            <!-- 格式化SQL语句 -->
            <property name="hibernate.format_sql">true</property>
    
            <!-- hibernate的方言 -->
            <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
    
            <!-- 自动创建表 -->
            <property name="hibernate.hbm2ddl.auto">update</property>
    
            <mapping resource="cn/itcast/entity/User.hbm.xml" />
        </session-factory>
    </hibernate-configuration>
    • 1

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

第三步,把Hibernate核心配置文件中的数据库配置的信息交给Spring进行配置。即把Hibernate核心配置文件中的数据库信息的配置去掉,改在Spring的核心配置文件中配置:

<!-- 配置连接池 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
    <property name="jdbcUrl" value="jdbc:mysql:///spring_lee"></property>
    <property name="user" value="root"></property>
    <property name="password" value="yezi"></property>
</bean>
  • 1

第四步,把Hibernate里面的SessionFactory的创建交给Spring来配置。具体思路为:服务器启动的时候,加载Spring配置文件,继而把配置文件中的对象都创建完毕。故可把SessionFactory对象的创建也在Spring配置文件进行配置。又因为创建SessionFactory对象的代码不是简简单单new出来的,而是多行代码实现的,核心代码如下:

// 加载核心配置文件
config = new Configuration().configure();
// 创建SessionFactory对象
sessionFactory = config.buildSessionFactory();

所以我们不可能在Spring配置文件中通过一个<bean>标签就简简单单地进行配置。Spring框架针对上面这种情况,帮我们封装了一个类,配置这个类的对象就可以创建SessionFactory对象了。所以我们应在Spring配置文件中添加如下内容:

<!-- 配置sessionFactory的创建 -->
<bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
    <!-- 1.指定数据库位置 -->
    <property name="dataSource" ref="dataSource"></property>
    <!-- 2.指定使用的Hibernate核心配置文件位置 -->
    <property name="configLocations" value="classpath:hibernate.cfg.xml"></property>
</bean>
  • 1

第五步,之前我就讲过Spring针对JavaEE三层结构中的每一层都提供了不同的技术,在dao层,Spring提供了JDBC模板的技术,可对数据库进行CRUD操作。Spring提供了很多持久层技术的模板类简化了编程,如下图: 

现在我们就要在dao层里面使用HibernateTemplate模板类,至于它是什么,我待会将做简单介绍。具体操作为:向UserDao里面注入HibernateTemplate模板类对象,并调用HibernateTemplate模板类里面的save方法向数据库表中添加一条记录。这样UserDao类的代码就应修改为:

public class UserDao {

    // 在Dao里面注入HibernateTemplate模板对象
    private HibernateTemplate hibernateTemplate;
    public void setHibernateTemplate(HibernateTemplate hibernateTemplate) {
        this.hibernateTemplate = hibernateTemplate;
    }

    public void add() {
        // 向表中添加记录
        // 使用hibernateTemplate实现添加
        // HibernateTemplate hibernateTemplate = new HibernateTemplate(sessionFactory);
        // hibernateTemplate.save(entity);
        System.out.println("dao..............");

        User user = new User();
        user.setUsername("李阿昀");
        user.setAddress("湖北天门");

        hibernateTemplate.save(user);
    }
}
  • 1
  • 2

当然了,Spring配置文件的修改是必不可少的啦!所以应向Spring配置文件添加如下配置:

<bean id="userDao" class="cn.itcast.dao.UserDao">
    <property name="hibernateTemplate" ref="hibernateTemplate"></property>
</bean>

<!-- 创建HibernateTemplate模板对象 -->
<bean id="hibernateTemplate" class="org.springframework.orm.hibernate5.HibernateTemplate">
    <!-- 注入sessionFactory -->
    <property name="sessionFactory" ref="sessionFactory"></property>
</bean>
  • 1

第六步,配置Spring的事务管理。

  1. 配置事务管理器

    <!-- 1.配置事务的管理器 -->
    <bean id="transactionManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory"></property>
    </bean>
    • 1
    • 2
  2. 注解事务管理的开启

    <!-- 2.开启事务注解 -->
    <tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>
  3. 在业务层添加一个@Transactional注解

    @Transactional
    public class UserService {
    
        private UserDao userDao;
        public void setUserDao(UserDao userDao) {
            this.userDao = userDao;
        }
    
        public void add() {
            System.out.println("service..............");
            userDao.add();
        }
    }
    • 1

这时启动tomcat服务器,就会发现数据库中多了一个t_user表,这是理所应当的啦!接着在浏览器地址栏中输入地址http://localhost:8080/Spring_day04_demo1/user.action进行访问,即可看到t_user表多了一条记录,如下:
 
至此,hibernate-5.0.7+struts-2.3.24+spring-4.2.4三大框架就已整合完毕!

HibernateTemplate介绍

HibernateTemplate对Hibernate框架进行了封装,直接调用HibernateTemplate里面的方法即可实现对数据库进行CRUD的操作。 
HibernateTemplate常用的方法如下:

  • Serializable save(Object entity):添加操作
  • void update(Object entity):修改操作
  • void delete(Object entity):删除操作
  • <T> T get(Class<T> entityClass, Serializable id):根据id查询
  • <T> T load(Class<T> entityClass, Serializable id):根据id查询
  • List find(String queryString, Object... values):查询操作的方法

SSH框架整合过程总结

  1. 导入相关的jar包。 
     
    一共有42个jar包。
  2. 搭建Struts2的开发环境 
    • 创建Action,引入struts.xml配置文件,并配置Action
    • 配置Struts2框架的过滤器
  3. 搭建Hibernate的开发环境 
    • 创建实体类
    • 配置实体类和数据库表之间的映射关系
    • 创建Hibernate核心配置文件,主要是引入映射配置文件
  4. 搭建Spring的开发环境 
    • 创建Spring核心配置文件
    • 让Spring配置文件在服务器启动时候进行加载 
      • 配置监听器
      • 指定Spring配置文件的位置
  5. Struts2和Spring框架的整合 
    • 把Struts2的Action的创建交给Spring来配置(记住Action是多实例的对象)。
    • 在struts.xml配置文件中的action标签的class属性里面写上bean的id值。
  6. Spring和Hibernate框架的整合 
    • 把Hibernate核心配置文件里面的数据库信息的配置交给Spring来管理。
    • 把Hibernate里面的SessionFactory的创建交给Spring来管理。
  7. 在dao里面使用HibernateTemplate模板类 
    • 在dao里面注入HibernateTemplate模板类对象
    • 在HibernateTemplate模板对象中注入SessionFactory
  8. 配置Spring的事务管理

SSH框架的整合方式二:不带Hibernate配置文件

Spring整合Hibernate框架的时候,可以不用写Hibernate的核心配置文件。下面我就举个例子来演示。 
首先复制以上SSH项目,再在其基础上进行修改。 
然后查看之前写的Hibernate核心配置文件,可知Hibernate核心配置文件包含如下内容:

  1. 连接数据库必要的参数
  2. Hibernate的属性
  3. 连接池的配置
  4. 映射文件的引入

Spring整合Hibernate框架的时候,虽然可以不用写Hibernate的核心配置文件,但还是要把Hibernate核心配置文件中的基本信息配置和映射文件的引入放到Spring配置文件中进行配置。所以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: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">

    <!-- 配置连接池 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
        <property name="jdbcUrl" value="jdbc:mysql:///spring_lee"></property>
        <property name="user" value="root"></property>
        <property name="password" value="yezi"></property>
    </bean>

    <bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
        <property name="dataSource" ref="dataSource"></property>
        <!-- <property name="configLocations" value="classpath:hibernate.cfg.xml"></property> -->
        <!-- 如果不写Hibernate的核心配置文件,你就不需要写上面这行配置了 -->
        <!-- 1.把Hibernate的基本信息的配置(写在这儿) -->
        <property name="hibernateProperties">
            <props>
                <prop key="hibernate.show_sql">true</prop>
                <prop key="hibernate.format_sql">true</prop>
                <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
                <prop key="hibernate.hbm2ddl.auto">update</prop>
            </props>
        </property>
        <!-- 2.把映射文件引入 -->
        <property name="mappingResources">
            <list>
                <value>cn/itcast/entity/User.hbm.xml</value>
                <!-- <value>...</value> -->
            </list>
        </property>
    </bean>

    <bean id="transactionManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory"></property>
    </bean>

    <tx:annotation-driven transaction-manager="transactionManager"/>

    <bean id="userAction" class="cn.itcast.action.UserAction" scope="prototype">
        <property name="userService" ref="userService"></property>
    </bean>

    <bean id="userService" class="cn.itcast.service.UserService">
        <property name="userDao" ref="userDao"></property>
    </bean>

    <bean id="userDao" class="cn.itcast.dao.UserDao">
        <property name="hibernateTemplate" ref="hibernateTemplate"></property>
    </bean>

    <bean id="hibernateTemplate" class="org.springframework.orm.hibernate5.HibernateTemplate">
        <property name="sessionFactory" ref="sessionFactory"></property>
    </bean>
</beans>

 

至此,hibernate-5.0.7+struts-2.3.24+spring-4.2.4三大框架就又整合完毕!两种方式任君选择!

以上是关于(转)hibernate-5.0.7+struts-2.3.24+spring-4.2.4三大框架整合的主要内容,如果未能解决你的问题,请参考以下文章

Hibernate基础实例

hibernate详细教程

hibernate实现JPA规范配置

hibernate框架学习笔记1:搭建与测试

Struts2标签库(转)

Struts2相关面试题(转)