zoukankan      html  css  js  c++  java
  • (转)Spring4.2.5+Hibernate4.3.11组合开发

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

    搭建和配置Spring与Hibernate整合的环境

    今天我们来学习Spring4.2.5+Hibernate4.3.11+Struts1.3.8整合开发。在整合开发时,不要一口气的把这3个框架整合好,而是应该分步整合,通常应该先整合Spring4.2.5+Hibernate4.3.11这2个框架,这2个框架整合好之后,再来整合Struts1.3.8框架。 
    我们首先新建一个动态web项目,名称为SSH,顺便将项目的整个编码设置为UTF-8,如图所示: 


    现在我们来分步集成Spring4.2.5+Hibernate4.3.11这2个框架,先向SSH项目中导入Hibernate4.3.11框架所需的jar文件,如图所示: 
     
    然后再向SSH项目中导入Spring4.2.5框架所需的jar文件,如图所示: 
     
    最后,不要忘记导入数据库驱动jar文件: 
    这里写图片描述 
    这样,总共需要向SSH项目中导入的jar文件有: 
     
    接下来,我们在src目录下新建Spring的配置文件——beans.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-4.2.xsd
            http://www.springframework.org/schema/aop 
            http://www.springframework.org/schema/aop/spring-aop-4.2.xsd
            http://www.springframework.org/schema/tx 
            http://www.springframework.org/schema/tx/spring-tx-4.2.xsd">
    
        <context:annotation-config />
    
        <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
            destroy-method="close">
            <property name="driverClassName" value="com.mysql.jdbc.Driver" />
            <property name="url"
                value="jdbc:mysql://localhost:3306/jdbc?useUnicode=true&amp;characterEncoding=UTF-8" />
            <property name="username" value="root" />
            <property name="password" value="yezi" />
            <!-- 连接池启动时的初始值 -->
            <property name="initialSize" value="1" />
            <!-- 连接池的最大值 -->
            <property name="maxActive" value="500" />
            <!-- 最大空闲值。当经过一个高峰时间后,连接池可以慢慢将已经用不到的连接慢慢释放一部分,一直减少到maxIdle为止 -->
            <property name="maxIdle" value="2" />
            <!-- 最小空闲值。当空闲的连接数少于阀值时,连接池就会预申请去一些连接,以免洪峰来时来不及申请 -->
            <property name="minIdle" value="1" />
        </bean>
    
    </beans>
    • 1

    从上可以看出Spring的配置文件保留了DBCP数据源的配置。 
    在整合Spring4.2.5+Hibernate4.3.11这2个框架时,我们需要将sessionFactory交给Spring容器管理,org.springframework.orm.hibernate4.LocalSessionFactoryBean这个类对sessionFactory做了一层包装,包装的目的是用于管理sessionFactory底下的session,通过这个类对由sessionFactory这个对象创建的session进行管理,管理就好比开启事务,提交事务等。所以需要将以下配置添加到Spring的配置文件中。

    <bean id="sessionFactory"
        class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
        <property name="dataSource" ref="dataSource" /> <!-- 数据源  -->
        <property name="mappingResources">
            <list>
                <value>cn/itcast/bean/Person.hbm.xml</value> <!-- Hibernate的实体bean的映射文件(可有多个) -->
            </list>
        </property>
        <!-- hibernateProperties是用来配置Hibernate的属性信息 -->
        <property name="hibernateProperties">
            <value>
                hibernate.dialect=org.hibernate.dialect.MySQLDialect
                hibernate.hbm2ddl.auto=update
                hibernate.show_sql=false
                hibernate.format_sql=false
            </value>
        </property>
    </bean>
    • 1

    接下来还需要配置针对Hibernate的事务管理器,事务管理器对sessionFactory对象创建出来的session进行管理。所以需要将以下配置添加到Spring的配置文件中。

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

    由于我们采用注解——@Transactional的方式来配置声明式事务,所以我们还要在Spring配置文件中添加如下内容:

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

    这样,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-4.2.xsd
            http://www.springframework.org/schema/aop 
            http://www.springframework.org/schema/aop/spring-aop-4.2.xsd
            http://www.springframework.org/schema/tx 
            http://www.springframework.org/schema/tx/spring-tx-4.2.xsd">
    
        <context:annotation-config />
    
        <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
            destroy-method="close">
            <property name="driverClassName" value="com.mysql.jdbc.Driver" />
            <property name="url"
                value="jdbc:mysql://localhost:3306/jdbc?useUnicode=true&amp;characterEncoding=UTF-8" />
            <property name="username" value="root" />
            <property name="password" value="yezi" />
            <!-- 连接池启动时的初始值 -->
            <property name="initialSize" value="1" />
            <!-- 连接池的最大值 -->
            <property name="maxActive" value="500" />
            <!-- 最大空闲值。当经过一个高峰时间后,连接池可以慢慢将已经用不到的连接慢慢释放一部分,一直减少到maxIdle为止 -->
            <property name="maxIdle" value="2" />
            <!-- 最小空闲值。当空闲的连接数少于阀值时,连接池就会预申请去一些连接,以免洪峰来时来不及申请 -->
            <property name="minIdle" value="1" />
        </bean>
    
        <bean id="sessionFactory"
            class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
            <property name="dataSource" ref="dataSource" /> <!-- 数据源  -->
            <property name="mappingResources">
                <list>
                    <value>cn/itcast/bean/Person.hbm.xml</value> <!-- Hibernate的实体bean的映射文件(可有多个) -->
                </list>
            </property>
            <!-- hibernateProperties是用来配置Hibernate的属性信息 -->
            <property name="hibernateProperties">
                <value>
                    hibernate.dialect=org.hibernate.dialect.MySQLDialect
                    hibernate.hbm2ddl.auto=update
                    hibernate.show_sql=false
                    hibernate.format_sql=false
                </value>
            </property>
        </bean>
    
        <!-- 配置针对Hibernate的事务管理器,事务管理器对sessionFactory对象创建出来的session进行管理 -->
        <bean id="txManager" class="org.springframework.orm.hibernate4.HibernateTransactionManager">
            <property name="sessionFactory" ref="sessionFactory"/>
        </bean>
        <tx:annotation-driven transaction-manager="txManager" />
    </beans>
    • 1

    至此,Spring4.2.5与Hibernate4.3.11整合的环境就算搭建好了。

    Spring集成的Hibernate编码与测试

    我们首先在src目录下新建一个cn.itcast.bean包,并在该包下新建一个JavaBean——Person.java,其代码为:

    public class Person {
        private Integer id;
        private String name;
    
        // 实体bean必须要有一个无参构造函数
        public Person() { }
        public Person(String name) {
            this.name = name;
        }
        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;
        }
    }
    • 1

    然后我们还应在该包新建该实体bean的映射文件——Person.hbm.xml,其内容为:

    <?xml version="1.0"?>
    <!DOCTYPE hibernate-mapping PUBLIC
            "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
            "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
    
    <hibernate-mapping package="cn.itcast.bean">
        <class name="Person" table="person">
            <id name="id" type="int" column="id">
                <generator class="native"/>
            </id>
            <property name="name" type="string" length="20" not-null="true" column="name" />
        </class>
    </hibernate-mapping>
    • 1

    接下来我们就要做的一步是在业务层(或数据访问层)里面通过Spring来使用sessionFactory。首先在src目录下新建一个cn.itcast.service包,并在该包下新建一个接口——PersonService.java,其代码为:

    public interface PersonService {
    
        void save(Person person);
    
        void update(Person person);
    
        Person getPerson(Integer personid);
    
        void delete(Integer personid);
    
        List<Person> getPersons();
    
    }
    • 1

    紧接着我们就要在src目录下新建一个cn.itcast.service.impl包,并在该包下新建一个PersonService接口的实现类——PersonServiceBean.java,其代码为:

    @Transactional
    public class PersonServiceBean implements PersonService {
        @Resource private SessionFactory sessionFactory; // 用@Resource注解方式进行依赖注入
    
        public void save(Person person) {
            /**
             * 以前我们通过sessionFactory对象得到session,是通过sessionFactory.openSession()得到的,
             * 但在此,我们需要注意一点,因为Spring会自动地帮我们管理事务,就是说它会自动地帮我们管理session对象,
             * 所以这时我们只须通过sessionFactory.getCurrentSession()从Spring容器里面得到当前
             * 被Spring容器管理的session对象。
             */
            sessionFactory.getCurrentSession().persist(person); // 建议使用persist()方法,和JTA规范保持一致,与save()作用一样
        }
    
        /**
         * 当对象处于游离状态时,这时才需要对它进行更新
         */
        public void update(Person person) {
            sessionFactory.getCurrentSession().merge(person); // 建议使用merge()方法,和JTA规范保持一致,把对游离状态对象的更新同步到数据库
        }
    
        @Transactional(propagation=Propagation.NOT_SUPPORTED, readOnly=true)
        public Person getPerson(Integer personid) {
            return (Person) sessionFactory.getCurrentSession().get(Person.class, personid);
        }
    
        public void delete(Integer personid) {
            /**
             * 建议使用load()方法,load()方法比get()方法性能要好一些,
             * 因为get()方法有一个数据装配的过程,也即把数据从数据库查询出来之后,还要把数据封装到实体对象里面去,
             * 而load()方法没有封装的过程,相对来说,效率要高很多。
             */
            sessionFactory.getCurrentSession().delete(
                    sessionFactory.getCurrentSession().load(Person.class, personid));
        }
    
        @Transactional(propagation=Propagation.NOT_SUPPORTED, readOnly=true)
        @SuppressWarnings("unchecked")
        public List<Person> getPersons() {
            return sessionFactory.getCurrentSession().createQuery("from Person").list();
        }
    }
    • 1

    接着不要忘了把该业务bean交给Spring容器进行管理,所以应向Spring配置文件中添加如下内容:

    <bean id="personService" class="cn.itcast.service.impl.PersonServiceBean" />
    • 1
    • 1

    每当开发完业务bean之后,大家千万别急于跟控制层进行集成,也就是说不要在控制层使用业务层对象,我们在开发完业务层后,需要对业务方法进行单元测试。所以我们要在src目录下新建一个junit.test包,并在该包下新建一个单元测试类——PersonServiceTest.java,其代码为:

    public class PersonServiceTest {
        private static PersonService personService;
    
        /**
         * 当单元测试实例被构建出来之后,就执行该方法,
         * 所以我们可以在这个方法里面做一些初始化的操作。
         * @throws Exception
         */
        @BeforeClass
        public static void setUpBeforeClass() throws Exception {
            try {
                ApplicationContext cxt = new ClassPathXmlApplicationContext("beans.xml");
                personService = (PersonService) cxt.getBean("personService");
            } catch (Exception e) { // 若出错,则打印在控制台上
                e.printStackTrace();
            }
        }
    
        @Test
        public void testSave() {
            personService.save(new Person("李子一"));
        }
    
        @Test
        public void testGetPerson() {
            Person person = personService.getPerson(1);
            System.out.println(person.getName());
        }
    
        /**
         * 更新操作:一般在实际业务中,会先得到person对象,从web请求参数里面接收到
         * 一些参数值之后,把这些参数设置进person实体对象中,然后就来更新。
         */
        @Test
        public void testUpdate() {
            Person person = personService.getPerson(1);
            // ...
            person.setName("小李");
            personService.update(person);
        }
    
        @Test
        public void testGetPersons() {
            List<Person> persons = personService.getPersons();
            for (Person person : persons) {
                System.out.println(person.getName());
            }
        }
    
        @Test
        public void testDelete() {
            personService.delete(1);
        }
    }

    可以发现业务bean——PersonServiceBean中的所有业务方法都通过单元测试,说明业务层的代码没有任何问题,那么接下来我们就要集成web层框架——Struts1.3.8了。 
    如须查看源码,可点击Spring4.2.5+Hibernate4.3.11组合开发进行下载。

  • 相关阅读:
    jenkins--部署项目
    jenkins--创建项目
    jenkins--安全配置
    jenkins--工具配置
    jenkins--系统配置
    11.17
    11.14
    11.13
    dfs
    10.31
  • 原文地址:https://www.cnblogs.com/telwanggs/p/6913508.html
Copyright © 2011-2022 走看看