Spring基础学习教程(简介)-01

        4，底层采用Hibernate持久化技术，但事务依然采用JTA全局事务：

 <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"  
    destroy-method="close">  
    <!-- 指定连接数据库的驱动 -->  
    <property name="driverClass" value="com.mysql.jdbc.Driver"/>  
    <!-- 指定连接数据库的URL -->  
    <property name="jdbcUrl" value="jdbc:mysql://localhost/javaee"/>  
    <!-- 指定连接数据库的用户名 -->  
    <property name="user" value="root"/>  
    <!-- 指定连接数据库的密码 -->  
    <property name="password" value="32147"/>  
    <!-- 指定连接数据库连接池的最大连接数 -->  
    <property name="maxPoolSize" value="40"/>  
    <!-- 指定连接数据库连接池的最小连接数 -->  
    <property name="minPoolSize" value="1"/>  
    <!-- 指定连接数据库连接池的初始化连接数 -->  
    <property name="initialPoolSize" value="1"/>  
    <!-- 指定连接数据库连接池的连接的最大空闲时间 -->  
    <property name="maxIdleTime" value="20"/>  
</bean>  

<bean id="sessionFactory"  
    class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">  
    <!-- 依赖注入数据源，注入正是上面定义的dataSource -->  
    <property name="dataSource" ref="dataSource"/>  
    <!-- mappingResouces属性用来列出全部映射文件 -->  
    <property name="mappingResources">  
        <list>  
            <!-- 以下用来列出Hibernate映射文件 -->  
            <value>Person.hbm.xml</value>  
        </list>  
    </property>  
    <!-- 定义Hibernate的SessionFactory的属性 -->  
    <property name="hibernateProperties">  
        <props>  
            <!-- 指定数据库方言 -->  
            <prop key="hibernate.dialect">  
                org.hibernate.dialect.MySQLInnoDBDialect</prop>  
            <!-- 是否根据需要每次自动创建数据库 -->  
            <prop key="hibernate.hbm2ddl.auto">update</prop>  
            <!-- 显示Hibernate持久化操作所生成的SQL -->  
            <prop key="hibernate.show\_sql">true</prop>  
            <!-- 将SQL脚本进行格式化后再输出 -->  
            <prop key="hibernate.format\_sql">true</prop>  
        </props>  
    </property>  
</bean>

Struts2配置文件：

<?xmlversion=“1.0”encoding=“GBK”?>

<!DOCTYPEstrutsPUBLIC

“-//Apache Software Foundation//DTD Struts Configuration 2.0//EN”

“http://struts.apache.org/dtds/struts-2.0.dtd">

7，Spring整合Hibernate

1，Spring提供的dao支持：

    DAO模式是标准的java EE设计模式，DAO模式的核心思想是所有的数据库访问，都通过DAO组件完成，DAO组件封装了数据库的增删改查等原子操作，业务逻辑组件依赖DAO组件提供的原子操作，
    对于javaEE的应用架构，有非常多的，不管细节如何变化，javaEE大致 可以分为如下三层：
             表现层；
            业务逻辑层；
            数据持久层；

Spring提供了一系列的抽象类，这些抽象类将被作为应用中DAO组件可以通过这些抽象类，Spring简化了DAO的开发步骤，能够以一致的访问方式使用数据库访问技术，不管底层采用JDBC、JDO还是个Hibernate，应用中都采用一致的编程模型。

    Spring提供的多种数据库访问技术的DAO支持，包括Hibernate、JDO、TopLink、iBatis、OJB、JPA等，就Hibernate的持久层访问技术而言，Spring提供如下3个工具类来支持DAO组件的实现： HibernateDaoSupport、 HibernateTemplate、 HibernateCallback。

2，管理Hibernate的SessionFactory

    前面介绍的Hibernate的时候知道：通过Hibernate进行持久层访问的时候，Hibernate的SessionFactory是非常重要的对象，它是单个数据库映射关系编译后的内存镜像，大部分情况下，一个java EE应用对应一个数据库，即对应一个SessionFactory对象。

配置SessionFactory的示范代码：

<bean id="dataSource" class="com.mchange.v2.c3p0. ComboPooledDataSource"  
    destroy-method="close">  
    <!-- 指定连接数据库的驱动 -->  
    <property name="driverClass" value="com.mysql.jdbc.Driver"/>  
    <!-- 指定连接数据库的URL -->  
    <property name="jdbcUrl" value="jdbc:mysql://localhost/javaee"/>  
    <!-- 指定连接数据库的用户名 -->  
    <property name="user" value="root"/>  
    <!-- 指定连接数据库的密码 -->  
    <property name="password" value="32147"/>  
    <!-- 指定连接数据库连接池的最大连接数 -->  
    <property name="maxPoolSize" value="40"/>  
    <!-- 指定连接数据库连接池的最小连接数 -->  
    <property name="minPoolSize" value="1"/>  
    <!-- 指定连接数据库连接池的初始化连接数 -->  
    <property name="initialPoolSize" value="1"/>  
    <!-- 指定连接数据库连接池的连接的最大空闲时间 -->  
    <property name="maxIdleTime" value="20"/>  
</bean>  
<!-- 定义Hibernate的SessionFactory -->  
<bean id="sessionFactory"  
    class="org.springframework.orm.hibernate3. LocalSessionFactoryBean">  
    <!-- 依赖注入数据源，注入正是上面定义的dataSource -->  
    <property name=" dataSource" ref="dataSource"/>  
    <!-- mappingResouces属性用来列出全部映射文件 -->  
    <property name=" mappingResources">  
        <list>  
            <!-- 以下用来列出Hibernate映射文件 -->  
            <value>Person.hbm.xml</value>  
        </list>  
    </property>  
    <!-- 定义Hibernate的SessionFactory的属性 -->  
    <property name=" hibernateProperties">  
        <props>  
            <!-- 指定数据库方言 -->  
            <prop key="hibernate.dialect">  
                org.hibernate.dialect.MySQLInnoDBDialect</prop>  
            <!-- 是否根据需要每次自动创建数据库 -->  
            <prop key="hibernate.hbm2ddl.auto">update</prop>  
            <!-- 显示Hibernate持久化操作所生成的SQL -->  
            <prop key="hibernate.show\_sql">true</prop>  
            <!-- 将SQL脚本进行格式化后再输出 -->  
            <prop key="hibernate.format\_sql">true</prop>  
        </props>  
    </property>  
</bean>

3，使用HibernateTemplate：

HibernateTemplate提供持久层访问模版化，它只需要提供一个SessionFactory的引用，SessionFactory可以通过构造方法参数传入，也可以通过设值方式传入。

示例：
public class PersonDaoImpl implements PersonDao
{
//定义一个HibernateTemplate对象，用于执行持久化操作
private HibernateTemplate ht = null;
//Hibernate持久化操作所需的SessionFactory
private SessionFactory sessionFactory;
//依赖注入SessionFactory的setter方法
public void setSessionFactory(SessionFactory sessionFactory)
{
this.sessionFactory = sessionFactory;
}
//初始化HibernateTemplate的方法
private HibernateTemplate getHibernateTemplate()
{
if (ht == null)
{
ht = new HibernateTemplate(sessionFactory);
}
return ht;
}
/**
* 加载Person实例
* @param id 需要加载的Person实例的标识属性值
* @return 指定id对应的Person实例
*/
public Person get(Integer id)
{
return (Person)getHibernateTemplate()
.get(Person.class, id);
}

/\*\*  
 \* 保存Person实例  
 \* @param person 需要保存的Person实例  
 \* @return 刚刚保存的Person实例的标识属性值  
 \*/     
public Integer save(Person person)  
\{  
    return (Integer)getHibernateTemplate()  
        .save(person);  
\}  
/\*\*  
 \* 修改Person实例  
 \* @param person 需要修改的Person实例  
 \*/  
public void update(Person person)  
\{  
    getHibernateTemplate().update(person);  
\}  
/\*\*  
 \* 删除Person实例  
 \* @param id 需要删除的Person实例的标识属性值  
 \*/  
public void delete(Integer id)  
\{  
    getHibernateTemplate().delete(get(id));  
\}  
/\*\*  
 \* 删除Person实例  
 \* @param person 需要删除的Person实例  
 \*/  
public void delete(Person person)  
\{  
    getHibernateTemplate().delete(person);  
\}  
/\*\*  
 \* 根据用户名查找Person  
 \* @param name 查询的人名  
 \* @return 指定用户名对应的全部Person  
 \*/  
public List<Person> findByName(String name)  
\{  
    return (List<Person>)getHibernateTemplate()  
        .find("from Person p where p.name like ?" , name);  
\}  
/\*\*  
 \* 查询全部Person实例  
 \* @return 全部Person实例  
 \*/  
public List findAllPerson()  
\{  
    return (List<Person>)getHibernateTemplate()  
        .find("from Person");  
\}  
/\*\*  
 \* 查询数据表中Person实例的总数  
 \* @return 数据表中Person实例的总数  
 \*/  
public long getPersonNumber()  
\{  
    return (Long)getHibernateTemplate().find  
        ("select count(\*) from Person as p")  
        .get(0);  
\}  

}

4，使用HibernateCallback：

HibernateTemplate还提供一种更加灵活的方式来操作数据库，，通过这种方式可以完全使用Hibernate的操作方式，HibernateTemplate的灵活方式是通过如下两个方法来完成的。

 Object execute(HibernateCallback action)；
List executeFind(HibernateCallback action)；

这两个方法都需要一个HibernateCallback实例，HibernateCallback是一个接口，该接口包含一个方法doInHibernate(org.hibernate Session session)，该方法是有一个Session参数，当我们在开发中提供HibernateCallback实现类时，必须实现接口里的doInHibernate方法，该方法体内即可获得 Hibernate Session的引用。一旦获取到Session的引用我们就可以完全以Hibernate的方式进行数据库的访问。

示例：

public class YeekuHibernateDaoSupport extends HibernateDaoSupport
{
/**
* 使用hql语句进行分页查询
* @param hql 需要查询的hql语句
* @param offset 第一条记录索引
* @param pageSize 每页需要显示的记录数
* @return 当前页的所有记录
*/
public List findByPage(final String hql,
final int offset, final int pageSize)
{
//通过一个HibernateCallback对象来执行查询
List list = getHibernateTemplate()
.executeFind(new HibernateCallback()
{
//实现HibernateCallback接口必须实现的方法
public Object doInHibernate( Session session)
throws HibernateException, SQLException
{
//执行Hibernate分页查询
List result = session.createQuery(hql)
.setFirstResult(offset)
.setMaxResults(pageSize)
.list();
return result;
}
});
return list;
}

/\*\*  
 \* 使用hql语句进行分页查询  
 \* @param hql 需要查询的hql语句  
 \* @param value 如果hql有一个参数需要传入，value就是传入hql语句的参数  
 \* @param offset 第一条记录索引  
 \* @param pageSize 每页需要显示的记录数  
 \* @return 当前页的所有记录  
 \*/  
public List  findByPage(final String hql , final Object value ,  
    final int offset, final int pageSize)  
\{  
    //通过一个HibernateCallback对象来执行查询  
    List list = getHibernateTemplate()  
        .executeFind(new HibernateCallback()  
    \{  
        //实现HibernateCallback接口必须实现的方法  
        public Object  doInHibernate(Session session)  
            throws HibernateException, SQLException  
        \{  
            //执行Hibernate分页查询  
            List result = session.createQuery(hql)  
                //为hql语句传入参数  
                .setParameter(0, value)   
                .setFirstResult(offset)  
                .setMaxResults(pageSize)  
                .list();  
            return result;  
        \}  
    \});  
    return list;  
\}  
/\*\*  
 \* 使用hql语句进行分页查询  
 \* @param hql 需要查询的hql语句  
 \* @param values 如果hql有多个个参数需要传入，values就是传入hql的参数数组  
 \* @param offset 第一条记录索引  
 \* @param pageSize 每页需要显示的记录数  
 \* @return 当前页的所有记录  
 \*/  
public List  findByPage(final String hql, final Object\[\] values,  
    final int offset, final int pageSize)  
\{  
    //通过一个HibernateCallback对象来执行查询  
    List list = getHibernateTemplate()  
        .executeFind(new HibernateCallback()  
    \{  
        //实现HibernateCallback接口必须实现的方法  
        public Object doInHibernate(Session session)  
            throws HibernateException, SQLException  
        \{  
            //执行Hibernate分页查询  
            Query query = session.createQuery(hql);  
            //为hql语句传入参数  
            for (int i = 0 ; i < values.length ; i++)  
            \{  
                query.setParameter( i, values\[i\]);  
            \}  
            List result = query.setFirstResult(offset)  
                .setMaxResults(pageSize)  
                .list();  
            return result;  
        \}  
    \});  
    return list;  
\}  

}

Spring提供了XxxTemplate和XxxCallback互为补充，XxxTemplate对操作进行封装，XxxCallback解决了封装后灵活性不足的缺陷。

5，实现DAO组件：

    为了实现DAO组件，Spring提供了大量的XxxDaoSupport类，这些dao支持类已经完成了大量基础性的工作。
    Spring为Hibernate的DAO提供工具类：HibernateDaoSupport，该类主要提供如下几个方法来简化DAO的实现：

public final HibernateTemplate getHibernateTemplate ();

public final void setSessionFactory(SessionFactory sessionFactory);

    setSessionFactory方法可用于接收Spring的依赖注入，允许使用依赖注入Spring 管理的SessionFactory实例。  

public class PersonDaoHibernate
extends HibernateDaoSupport implements PersonDao
{
/**
* 加载Person实例
* @param id 需要加载的Person实例的标识属性值
* @return 指定id对应的Person实例
*/
public Person get(Integer id)
{
return (Person) getHibernateTemplate()
.get(Person.class, id);
}

/\*\*  
 \* 保存Person实例  
 \* @param person 需要保存的Person实例  
 \* @return 刚刚保存的Person实例的标识属性值  
 \*/     
public Integer save(Person person)  
\{  
    return (Integer)getHibernateTemplate()  
        .save(person);  
\}  
/\*\*  
 \* 修改Person实例  
 \* @param person 需要修改的Person实例  
 \*/  
public void update(Person person)  
\{  
    getHibernateTemplate().update(person);  
\}  
/\*\*  
 \* 删除Person实例  
 \* @param id 需要删除的Person实例的标识属性值  
 \*/  
public void delete(Integer id)  
\{  
    getHibernateTemplate().delete(get(id));  
\}  
/\*\*  
 \* 删除Person实例  
 \* @param person 需要删除的Person实例  
 \*/  
public void delete(Person person)  
\{  
    getHibernateTemplate().delete(person);  
\}  
/\*\*  
 \* 根据用户名查找Person  
 \* @param name 查询的人名  
 \* @return 指定用户名对应的全部Person  
 \*/  
public List<Person> findByName(String name)  
\{  
    return (List<Person>)getHibernateTemplate()  
        .find("from Person p where p.name like ?" , name);  
\}  
/\*\*  
 \* 查询全部Person实例  
 \* @return 全部Person实例  
 \*/  
public List findAllPerson()  
\{  
    return (List<Person>)getHibernateTemplate()  
        .find("from Person");  
\}  

}

实际上，DAO的实现依然借助于HibernateTemplate的模板访问方式，只是HibernateDaoSupport提供了两个工具方法。

    至此Java EE应用所需的各种组件都已经出现了。
    从用户的角度上看，用户发出HTTP请求，当MVC框架的控制器组件拦截到用户的请求，将调用系统的业务逻辑组件，业务逻辑组件则调用 系统的DAO组件，，而DAO组件则依赖于SessionFactory和DataSOurce等底层的实现数据库访问。
    从系统的实现角度上看，IoC容器先创建SessionFactory和DataSource等底层组件，然后将这些组件注入DAO组件，提供一个完整的Dao组件，并将DAO组件注入给业务逻辑组件，从而提供一个完整的业务逻辑组件，而业务逻辑组件又被注入给控制器组件，控制器组件负责拦截用户请求，并将处理结果呈现给用户。

顶

0

踩

[Image 1]: