笔记58 Spring+Hibernate整合（一）

Spring+Hibernate整合

一、整合思路

　　使DAO继承HibernateTemplate这个类 HibernateTemplate这个类提供了setSessionFactory()方法用于注入SessionFactory 通过spring获取DAO的时候，注入SessionFactory.

二、编写基本POJO

Category.java

 package com.pojo;
 
 public class Category {
     private int id;
     private String name;
 
     public int getId() {
         return id;
     }
 
     public void setId(int id) {
         this.id = id;
     }
 
     public String getName() {
         return name;
     }
 
     public void setName(String name) {
         this.name = name;
     }
 
     public String toString() {
         return "Category [id=" + id + ", name=" + name + "]";
     }
 }

三、Hibernate映射

在POJO的包下，创建hibernate映射文件Category.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="com.pojo">
     <class name="Category" table="category">
         <!-- <cache usage="read-only"/> -->
         <id name="id" column="id">
             <generator class="native">
             </generator>
         </id>
         <property name="name" />
     </class>
 
 </hibernate-mapping>

四、DAO层

DAO继承HibernateTemplete，而HibernateTemplete类里有一个setSessionFactory用于接收sessionFactory的注入。

 package com.DAO;
 
 import org.springframework.orm.hibernate3.HibernateTemplate;
 
 public class CategoryDAO extends HibernateTemplate {
 
 }

五、Service层

主要是对数据库的抽插。。。。。。

CategoryService.java

 package com.Service;
 
 import java.util.List;
 
 import com.pojo.Category;
 
 public interface CategoryService {
     // 1.增加
     public void saveCategory(Category category);
 
     // 2.根据id查询单个条目
     public Category getSingleCategory(int id);
 
     // 3.查询所有条目
     public List<Category> getAllCategories();
 
     // 4.修改
     public void updateCategory(Category category);
 
     // 5.删除
     public void deleteCategory(Category category);
 
     // 6.分页查询
     public List<Category> getCategoryByPaging(int start, int count);
 
     // 7.获取条目总数
     public Long getSum();
 
     // 8.模糊查询
     public List<Category> getCategories(String field, String param);
 
 }

CategoryServiceImpl.java

 package com.Service;
 
 import java.util.List;
 
 import org.hibernate.criterion.DetachedCriteria;
 import org.hibernate.criterion.Restrictions;
 
 import com.DAO.CategoryDAO;
 import com.pojo.Category;
 
 public class CategoryServiceImpl implements CategoryService {
 
     private CategoryDAO categoryDao;
 
     public CategoryServiceImpl(CategoryDAO categoryDao) {
         // TODO Auto-generated constructor stub
         this.categoryDao = categoryDao;
     }
 
     @Override
     public void saveCategory(Category category) {
         // TODO Auto-generated method stub
         categoryDao.save(category);
     }
 
     @Override
     public Category getSingleCategory(int id) {
         // TODO Auto-generated method stub
         Category category = categoryDao.get(Category.class, id);
         return category;
     }
 
     @Override
     public List<Category> getAllCategories() {
         // TODO Auto-generated method stub
         String queryString = "from Category c";
         @SuppressWarnings("unchecked")
         List<Category> categories = categoryDao.find(queryString);
         return categories;
     }
 
     @Override
     public void updateCategory(Category category) {
         // TODO Auto-generated method stub
         categoryDao.update(category);
     }
 
     @Override
     public void deleteCategory(Category category) {
         // TODO Auto-generated method stub
         categoryDao.delete(category);
     }
 
     @Override
     public List<Category> getCategoryByPaging(int start, int count) {
         // TODO Auto-generated method stub
         DetachedCriteria detachedCriteria = DetachedCriteria.forClass(Category.class);
         @SuppressWarnings("unchecked")
         List<Category> categories = categoryDao.findByCriteria(detachedCriteria, start, count);
         return categories;
     }
 
     @Override
     public Long getSum() {
         // TODO Auto-generated method stub
         String queryString = "select count(*) from Category";
         @SuppressWarnings("unchecked")
         List<Long> longs = categoryDao.find(queryString);
         return longs.get(0);
     }
 
     @Override
     public List<Category> getCategories(String field, String param) {
         // TODO Auto-generated method stub
         DetachedCriteria detachedCriteria = DetachedCriteria.forClass(Category.class);
         detachedCriteria.add(Restrictions.like(field, param));
         @SuppressWarnings("unchecked")
         List<Category> categories = categoryDao.findByCriteria(detachedCriteria);
         return categories;
     }
 
 }

五、配置Spring

创建DAO的时候，会注入sessionfactory
创建sessionFactory的时候会注入数据源dataSource

创建CategoryService的时候会注入DAO

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:aop="http://www.springframework.org/schema/aop"
     xmlns:tx="http://www.springframework.org/schema/tx" xmlns:context="http://www.springframework.org/schema/context"
     xsi:schemaLocation="
    http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
    http://www.springframework.org/schema/aop
    http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
    http://www.springframework.org/schema/tx
    http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context-3.0.xsd">
 
     <!-- 基础bean -->
     <bean name="Category" class="com.pojo.Category">
     </bean>
 
     <bean name="DAO" class="com.DAO.CategoryDAO">
         <property name="sessionFactory" ref="sessionFactory"></property>
     </bean>
 
     <bean name="CategoryService" class="com.Service.CategoryServiceImpl">
         <constructor-arg ref="DAO"></constructor-arg>
     </bean>
 
     <!-- 加载hibernate的sessionFactory -->
     <bean name="sessionFactory"
         class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
         <property name="dataSource" ref="dataSource">
         </property>
 
         <property name="mappingResources">
             <list>
                 <value>com/pojo/Category.hbm.xml</value>
             </list>
         </property>
 
         <property name="hibernateProperties">
             <value>
                 hibernate.dialect=org.hibernate.dialect.MySQLDialect
                 hibernate.show_sql=true
                 hbm2ddl.auto=update
             </value>
         </property>
     </bean>
     <!-- 配置数据源 -->
     <bean name="dataSource"
         class="org.springframework.jdbc.datasource.DriverManagerDataSource">
         <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
         <property name="url"
             value="jdbc:mysql://localhost:3306/sh?characterEncoding=UTF-8"></property>
         <property name="username" value="root"></property>
         <property name="password" value="123456"></property>
     </bean>
 </beans>

六、测试CRUD

Test.java

 package com.test;
 
 import java.util.List;
 
 import javax.sql.DataSource;
 
 import org.springframework.context.ApplicationContext;
 import org.springframework.context.support.ClassPathXmlApplicationContext;
 
 import com.Service.CategoryService;
 import com.pojo.Category;
 
 public class Test {
     private ApplicationContext context;
     private CategoryService categoryService;
 
     {
         context = new ClassPathXmlApplicationContext("applicationContext.xml");
         categoryService = context.getBean(CategoryService.class);
     }
 
     @org.junit.Test
     public void test() {
         // 测试数据源
         DataSource dataSource = (DataSource) context.getBean(DataSource.class);
         System.out.println(dataSource);
     }
 
     @org.junit.Test
     public void test1() {
         // 查询所有条目
         List<Category> categories = categoryService.getAllCategories();
         for (Category category : categories) {
             System.out.println(category);
         }
     }
 
     @org.junit.Test
     public void test2() {
         // 根据Id查询
         System.out.println(categoryService.getSingleCategory(1));
     }
 
     @org.junit.Test
     public void test3() {
         // 增加一条记录
         Category category = new Category();
         category.setName("新增的Category");
         categoryService.saveCategory(category);
     }
 
     @org.junit.Test
     public void test4() {
         // 删除一条记录
         Category category = categoryService.getSingleCategory(3);
         categoryService.deleteCategory(category);
     }
 
     @org.junit.Test
     public void test5() {
         // 分页查询
         List<Category> categories = categoryService.getCategoryByPaging(2, 3);
         for (Category category : categories) {
             System.out.println(category);
         }
     }
 
     @org.junit.Test
     public void test6() {
         // 模糊查询
         List<Category> categories = categoryService.getCategories("name", "%1%");
         for (Category category : categories) {
             System.out.println(category);
         }
     }
 
 }

补充知识

一、HibernateTemplate

　　HibernateTemplate是spring对hibernate使用的一个简单封装，本例中获取的方式通过DAO直接继承HibernateTemplate，也可以通过HibernateTemplate hibernateTemplate=HibernateTemplate()获取，总之获取方法很多。

二、HibernateTemplate常用的方法

1、find(String queryString);

示例：hibernateTemplate.find("from bean.User");

返回所有User对象

2、find(String queryString , Object value);

示例：hibernateTemplate.find("from bean.User u where u.name=?", "test");

或模糊查询：hibernateTemplate.find("from bean.User u where u.name like ?", "%test%");

返回name属性值为test的对象（模糊查询，返回name属性值包含test的对象）

3、find(String queryString, Object[] values);

示例：String hql= "from bean.User u where u.name=? and u.password=?";

　　   hibernateTemplate.find(hql, new String[]{"test", "123"});

返回用户名为test并且密码为123的所有User对象

4、findByExample(Object exampleEntity)

示例：User u=new  User();

　　   u.setPassword("123" );

　　   u.setName("bb" );      //必须符合的条件但是这两个条件时并列的（象当于sql中的and）

list=hibernateTemplate.findByExample(u);

返回：用户名为bb密码为123的对象

5、findByExample(Object exampleEntity, int firstResult, int  maxResults)

示例：User u=new  User();

　　   u.setPassword("123" );

u.setName("bb" );      //必须 符合的条件但是这两个条件时并列的（象当于sql中的and)

　　  list=hibernateTemplate.findByExample(u,start,max);

返回：满足用户名为bb密码为123，自start起共max个User对象。（对象从0开始计数）

6、findByNamedParam(String queryString , String paramName , Object value)

示例：String queryString = "select count(*) from bean.User u where u.name=:myName" ;

　　　String paramName= "myName";

　　　String value= "abc";

　　　list=hibernateTemplate.findByNamedParam(queryString, paramName, value);

　　　System.out.println(list.get(0 ));

返回：name为abc的User对象的条数

7、 findByNamedParam(String queryString , String[] paramName , Object[] value)

示例：String queryString = "select count(*) from bean.User u where u.name=:myName and u.password=:myPassword";

　　　String[] paramName= new String[]{"myName", "myPassword"};

　　　String[] value= new String[]{"abc", "123"};

　　　hibernateTemplate.findByNamedParam(queryString, paramName, value);

返回：用户名为abc密码为123的User对象

三、hibernatetemplate使用总结

1、固定条件查询

可以使用常规的方法，如 Java代码

hibernateTemplate.find（），hibernateTemplate.createQuery()等

hibernateTemplate.find（），hibernateTemplate.createQuery()等

2、动态多条件查询

由于查询条件的不确定性，使用参数拼接。

*hibernate模板

 public void save(User u) {
         Session s=null;
         try {
             s=sessionFactory.getCurrentSession();
             s.beginTransaction();
             s.save(u);
             s.getTransaction().commit();
         } catch (Exception e) {
             e.printStackTrace();
             s.getTransaction().rollback();
         }finally{
             if(s!=null){
                 s.close();
                 s=null;
             }
         }
         System.out.println("add success!!");
     }