Spring Data初步--整合Hibernate

Spring Data课程中的技术介绍

Hibernate：

Hibernate 是一个开放源代码的对象关系映射框架，它对 JDBC 进行了非常轻量级的对象封装，它将 pojo 与数据库表建立映射关系，是一个全自动的 ORM（Object - Relationship - Mapping）框架，Hibernate 可以自动生成 SQL 语句，自动执行，使得 Java 程序员可以随心所欲的使用对象编程思维来操纵数据库。

Hibernate 可以应用在任何使用 JDBC 的场合。

Gavin King 他是 Hibernate 的创始人，也是那本经典的 Hibernate in action 的作者。

Hibernate 原本是 JBOSS 旗下的产品，2006 年 JBOSS 被 RED HAT 收购，变成了红帽公司的产品。

JPA

JPA 是一个基于O/R映射的标准规范（目前最新版本是JPA 2.1 ）。所谓规范即只定义标准规则（如注解、接口），不提供实现，软件提供商可以按照标准规范来实现，而使用者只需按照规范中定义的方式来使用，而不用和软件提供商的实现打交道。

Hibernate JPA

Hibernate JPA:是在 Hibernate3.2 版本那种提供了对于 JPA 的标准的实现。提供了一套按照 JPA 标准来实现持久层开发的 API

Spring Data

Spring Data的使命是为数据访问提供熟悉且一致的基于Spring的编程模型，同时仍保留底层数据存储的特殊特性。

它使数据访问技术，关系数据库和非关系数据库，map-reduce框架和基于云的数据服务变得简单易用。这是一个伞形项目，其中包含许多特定于给定数据库的子项目。这些项目是通过与这些激动人心的技术背后的许多公司和开发人员合作开发的。

Spring Data JPA

持久化数据库操作，简化数据访问层，智能Spring存储接口，查询dsl。审计，分页，处理本机SQL查询

Spring Data Redis

Spring-data-redis是spring大家族的一部分，提供了在srping应用中通过简单的配置访问redis服务，对reids底层开发包(Jedis,  JRedis, and RJC)进行了高度封装，RedisTemplate提供了redis各种操作、异常处理及序列化，支持发布订阅，并对spring 3.1 cache进行了实现。

Spring整合Hibernate

配置文件

<?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">
    <!--配置读取properties文件的工具类-->
    <context:property-placeholder location="classpath:jdbc.properties"></context:property-placeholder>
    <!--配置c3p0数据库连接池-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="jdbcUrl" value="${jdbc.url}"/>
        <property name="driverClass" value="${jdbc.driver.class}"/>
        <property name="user" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>
    <!--配置Hibernate的SeesionFactory-->
    <bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <!-- hibernateProperties属性：配置与hibernate相关的内容，如显示sql语句，开启正向工程 -->
        <property name="hibernateProperties">
            <props>
                <!-- 显示当前执行的sql语句 -->
                <prop key="hibernate.show_sql">true</prop>
                <!-- 开启正向工程 -->
                <prop key="hibernate.hbm2ddl.auto">update</prop>
            </props>
        </property>
        <!-- 扫描实体所在的包 -->
        <property name="packagesToScan">
            <list>
                <value>com.bjsxt.pojo</value>
            </list>
        </property>
    </bean>
    <!-- 配置HiberanteTemplate对象 -->
    <bean id="hibernateTemplate" class="org.springframework.orm.hibernate5.HibernateTemplate">
        <property name="sessionFactory" ref="sessionFactory"/>
    </bean>
    <!-- 配置Hibernate的事务管理器 -->
    <bean id="transactionManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory"/>
    </bean>
    <!-- 配置开启注解事务处理 -->
    <tx:annotation-driven transaction-manager="transactionManager"/>
    <!-- 配置springIOC的注解扫描 -->
    <context:component-scan base-package="com.bjsxt"/>
</beans>

jdbc.properties:

jdbc.url=jdbc:mysql://localhost:3306/ssm
jdbc.driver.class=com.mysql.jdbc.Driver
jdbc.username=root
jdbc.password=root

需要jar包：

测试Spring Data整合Hibernate

com.bjsxt.dao.UserDao

package com.bjsxt.dao;
import com.bjsxt.pojo.Users;
import java.util.List;
public interface UserDao {
    void insertUser(Users users);
    void updateUser(Users users);
    void deleteByid(Users users);
    Users selectByid(Integer userid);
    List<Users> selectUsersByName(String username);
    List<Users> selectUsersByNameUseSQL(String username);
}

com.bjsxt.dao.impl.UserDaoImpl

package com.bjsxt.dao.impl;
import com.bjsxt.dao.UserDao;
import com.bjsxt.pojo.Users;
import org.hibernate.Query;
import org.hibernate.Session;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.orm.hibernate5.HibernateTemplate;
import org.springframework.stereotype.Repository;
import java.util.List;
@Repository
public class UserDaoImpl implements UserDao {
    @Autowired
    private HibernateTemplate hibernateTemplate;
    @Override
    public void insertUser(Users users) {
        hibernateTemplate.save(users);
    }
    @Override
    public void updateUser(Users users) {
        hibernateTemplate.update(users);
    }
    @Override
    public void deleteByid(Users users) {
        hibernateTemplate.delete(users);
    }
    @Override
    public Users selectByid(Integer userid) {
        return hibernateTemplate.get(Users.class,userid);
    }
    @Override
    public List<Users> selectUsersByName(String username) {
        //getCurrentSession:当前session必须要有事务边界，且只能处理唯一的一个事务。当事务提交或者回滚后session自动失效
        //openSession:每次都会打开一个新的session.加入每次使用多次。则获得的是不同session对象。使用完毕后我们需要手动的调用colse方法关闭session
        Session session = hibernateTemplate.getSessionFactory().getCurrentSession();
        Query query = session.createQuery("from Users where username = :abc");
        Query queryTemp = query.setString("abc", username);
        return queryTemp.list();
    }
    @Override
    public List<Users> selectUsersByNameUseSQL(String username) {
        Session session = hibernateTemplate.getSessionFactory().getCurrentSession();
        Query query = session.createSQLQuery("select * from t_users where username=?").addEntity(Users.class).setString(0, username);
        return query.list();
    }
}

com.bjsxt.pojo.Users

package com.bjsxt.pojo;
import javax.persistence.*;
import java.io.Serializable;
@Entity
@Table(name = "t_users")
public class Users implements Serializable {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)//自增长
    @Column(name = "userid")
    private Integer userid;
    private String username;
    private Integer userage;
    public Integer getUserid() {
        return userid;
    }
    public void setUserid(Integer userid) {
        this.userid = userid;
    }
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public Integer getUserage() {
        return userage;
    }
    public void setUserage(Integer userage) {
        this.userage = userage;
    }
    public Users(String username, Integer userage) {
        this.username = username;
        this.userage = userage;
    }
    public Users(){}
    @Override
    public String toString() {
        return "Users{" +
                "userid=" + userid +
                ", username='" + username + '\'' +
                ", userage=" + userage +
                '}';
    }
}

com.bjsxt.test.HibernateTest

package com.bjsxt.test;
import com.bjsxt.dao.UserDao;
import com.bjsxt.pojo.Users;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.annotation.Rollback;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class HibernateTest {
    @Autowired
    private UserDao userDao;
    @Test
    @Transactional// 在测试类对于事务提交方式默认的是回滚
    @Rollback(false)
    public void testInsertUsers(){
        Users users=new Users();
        users.setUserage(17);
        users.setUsername("张四");
        userDao.insertUser(users);
    }
    @Test
    @Transactional// 在测试类对于事务提交方式默认的是回滚
    @Rollback(false)
    public void testUpdateUsers(){
        Users users=new Users();
        users.setUserid(2);
        users.setUserage(22);
        users.setUsername("张小四");
        userDao.updateUser(users);
    }
    @Test
    @Transactional// 在测试类对于事务提交方式默认的是回滚
    @Rollback(false)
    public void testDeleUsers(){
        Users users=new Users();
        users.setUserid(2);
        userDao.deleteByid(users);
    }
    @Test
    @Transactional// 在测试类对于事务提交方式默认的是回滚
    @Rollback(false)
    public void testselectByid(){
        Users users = userDao.selectByid(1);
        System.out.println(users);
    }
    @Test
    @Transactional// 在测试类对于事务提交方式默认的是回滚
        public void testselectByName(){
        List<Users> userList = userDao.selectUsersByName("张四");
        for (Users users:userList){
            System.out.println(users);
        }
    }
    @Test
    @Transactional// 在测试类对于事务提交方式默认的是回滚
    public void testselectByNameUseSQL(){
        List<Users> userList = userDao.selectUsersByNameUseSQL("张四");
        for (Users users:userList){
            System.out.println(users);
        }
    }
}