SpringBoot实践之---Hibernate·连接数据库

Hibernate 连接数据库

1、属性配置文件（application.properties）

spring.datasource.url=jdbc:mysql://localhost:3306/test
spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.driver-class-name=com.mysql.jdbc.Driver

#hibernate
hibernate.jdbc.batch_size=50
spring.jpa.properties.hibernate.current_session_context_class=org.springframework.orm.hibernate5.SpringSessionContext
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQLDialect
spring.jpa.properties.hibernate.id.new_generator_mappings = false
spring.jpa.properties.hibernate.format_sql = true
spring.jackson.serialization.write_dates_as_timestamps=false

1
值得一提的是，无论是Spring Boot默认的DataSource配置还是你自己的DataSource bean，都会引用到外部属性文件中的属性配置。所以假设你自定义的DataSource bean，你可以在定义bean时设置属性，也可以在属性文件中，以“spring.datasource.*”的方式使属性配置外部化。

2、build.gradle 配置maven依赖

dependencies {
    compile('org.springframework.boot:spring-boot-starter-data-jpa')
    compile('org.springframework.boot:spring-boot-starter-web')
    compile('org.springframework.boot:spring-boot-starter-aop')
    compile("org.springframework.boot:spring-boot-starter-actuator")
    compile('mysql:mysql-connector-java')
}

3、Java代码范例

IBaseDao.java hibernate封装的基础dao接口

import org.hibernate.Criteria;
import org.hibernate.criterion.Criterion;

import java.io.Serializable;
import java.util.List;

public interface IBaseDao<EntityType> {
    /**
     * 取主键id
     * @param id
     * @return
     */
    public EntityType get(String id) ;

    /**
     * 批量获取对象
     * @param ids 待获取对象ID列表
     * @return List 对象列表
     */
    public List<EntityType> batchGet(List<String> ids);

    /**
     * 
     * <b>方法说明：</b>
     * <ul>
     * 获取主键对应的记录
     * </ul>
     * @param id 主键ID
     * @return EntityType 主键对应的记录
     */
    public EntityType get(int id) ;

    /**
     *
     * <b>方法说明：</b>
     * <ul>
     * 获取主键对应的记录
     * </ul>
     * @param id 主键ID
     * @return EntityType 主键对应的记录
     */
    public EntityType get(short id);

    /**
     * 批量获取对象
     * @param ids 待获取对象ID列表
     * @return List 对象列表
     */
    public List<EntityType> batchGetInt(List<Integer> ids);

    /**
     * 是否存在主键为id的记录
     * @param id
     * @return
     */
    boolean exists(String id);

    /**
     * 返回记录总数
     * @return
     */
    public int countAll();

    /**
     * 创建记录
     * @param model
     * @return
     */
    public Serializable save(EntityType model);

    /**
     * 批量创建记录
     * @param entities 待批量创建记录列表
     */
    public void batchSave(List<EntityType> entities);

    /**
     * 更新记录
     * @param model
     */
    public void update(EntityType model);

    /**
     * 批量更新
     * @param entities 待批量更新记录列表
     */
    public void batchUpdate(List<EntityType> entities);

    /**
     * 
     * <b>方法说明：</b>
     * <ul>
     * 删除记录
     * </ul>
     * @param id 待删除记录ID
     */
    public void delete(String id);

    /**
     * 批量删除记录
     * @param ids 待批量删除记录ID
     */
    public void batchDeleteStr(List<String> ids);

    /**
     * 删除记录
     * @param id 待删除记录ID
     */
    public void delete(int id) ;

    /**
     * 批量删除记录
     * @param ids 待批量删除记录ID
     */
    public void batchDeleteInt(List<Integer> ids);

    /**
     * 删除记录
     * @param model
     */
    public void delete(EntityType model);

    /**
     * 批量删除记录
     * @param models 待批量删除记录列表
     */
    public void batchDelete(List<EntityType> models);

    /**
     * 创建或更新
     * @param model
     */
    public void saveOrUpdate(EntityType model);

    /**
     * 
     * @param model
     */
    public void merge(EntityType model);

    /**
     * 锋得Criteria（查询条件）
     * @return
     */
    public Criteria getCriteria();

    /**
     * 查询所有
     * @return
     */
    public List<EntityType> listAll();

    /**
     * 
     * <b>方法说明：</b>
     * <ul>
     * 查询符合条件的所有表记录
     * </ul>
     * @param filters 查询条件，以and方式组合
     * @return List 符合条件的所有表记录
     */
    public List<EntityType> listAll(List<Criterion> filters);

    /**
     * 
     * <b>方法说明：</b>
     * <ul>
     * 按序查询符合条件的所有表记录
     * </ul>
     * @param filters 查询条件，以and方式组合
     * @param orderName 待排序字段
     * @param orderASC 是否顺序排序
     * @return List 符合条件的所有表记录
     */
    public List<EntityType> listAll(List<Criterion> filters, String orderName, boolean orderASC);

    /**
     * 
     * <b>方法说明：</b>
     * <ul>
     * 查询符合条件的所有表记录
     * </ul>
     * @param filters 查询条件，以or方式组合
     * @return List 符合条件的所有表记录
     */
    public List<EntityType> listAllOr(List<Criterion> filters);

    /**
    * 
    * @param orderName
    * @param orderASC
    * @return
    */
    public List<EntityType> listAll(String orderName, boolean orderASC);

    /**
     * 
     * <b>方法说明：</b>
     * <ul>
     * 查询符合条件的所有表记录
     * </ul>
     * @param andFilters 查询条件，以and方式组合
     * @param orFilters 查询条件，以or方式组合
     * @return List 符合条件的所有表记录
     */
    public List<EntityType> listAllAndOr(List<Criterion> andFilters, List<List<Criterion>> orFilters);

    /**
     *
     * <b>方法说明：</b>
     * <ul>
     * 查询符合条件的单条记录
     * </ul>
     * @param filters 查询条件，以and方式组合
     * @return EntityType 符合条件的唯一记录
     */
    public EntityType getUniqueResult(List<Criterion> filters);

    /**
     * 
     * @param start
     * @param limit
     * @return
     */
    public List<EntityType> listPage(int start, int limit);

    /**
     *  
     * @param start
     * @param limit
     * @param orderName
     * @param orderASC
     * @return
     */
    public List<EntityType> listPage(int start, int limit, String orderName, boolean orderASC);

    /**
     *  
     * @param entity
     * @return
     */
    public void persist(EntityType entity);

    /**
     *     
     * @param model
     */
    public void evict(EntityType model);

    /**
     * 
     */
    public void flush();

    /**
     * 
     */
    public void clear();

    /**
     * 
     * <b>方法说明：</b>
     * <ul>
     * 锁住表中给定的单条记录并返回该条记录
     * </ul>
     * @param recordID 表记录ID
     * @return EntityType 被锁住的表记录数据
     */
    public EntityType lockEntity(String recordID) ;

    /**
     * 
     * <b>方法说明：</b>
     * <ul>
     * 锁住整个表并返回所有表记录
     * </ul>
     * @return List 被锁住表的所有记录
     */
    public List<EntityType> lockEntity();
}

BaseDao.java hibernate封装的基础dao实现类

import com.great.common.IBaseDao;
import org.hibernate.Criteria;
import org.hibernate.LockOptions;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.criterion.Criterion;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Projections;
import org.hibernate.criterion.Restrictions;
import org.springframework.transaction.annotation.Transactional;

import javax.persistence.EntityManager;
import javax.persistence.EntityNotFoundException;
import javax.persistence.PersistenceContext;
import javax.persistence.Table;
import java.io.Serializable;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.List;

//import org.springframework.beans.factory.annotation.Qualifier;
//import org.springframework.jdbc.core.JdbcTemplate;
@Transactional
public abstract class BaseDao<EntityType> implements IBaseDao<EntityType> {

    /** 批量提交记录数 */
    private static final int BATCH_MAX_ROW = 100;

    protected final Class<EntityType> entityClass;
    @PersistenceContext
    EntityManager entityManager;

    @SuppressWarnings("unchecked")
    public BaseDao() {
        ParameterizedType type = (ParameterizedType) getClass().getGenericSuperclass();
        Type[] type2 = type.getActualTypeArguments();
        this.entityClass = (Class<EntityType>) type2[0];
    }



    protected Session getSession() {
        return entityManager.unwrap(Session.class);
    }

    protected void checkNull(EntityType entity) {
        if (entity == null)
            throw new NullPointerException("entity is null!");
    }

    public Criteria getCriteria() {
        return getSession().createCriteria(this.entityClass);
    }

    @SuppressWarnings("unchecked")
    public EntityType get(String id) {
        EntityType entity = (EntityType) getSession().get(this.entityClass, id);
        return entity;
    }

    /**
     * 批量获取对象
     * @param ids 待获取对象ID列表
     * @return List 对象列表
     */
    @Override
    public List<EntityType> batchGet(List<String> ids) {
        List<EntityType> entities = new ArrayList<EntityType>();
        for (int i = 0; i < ids.size(); i++) {
            entities.add(get(ids.get(i)));
            if ( (i + 1) % BATCH_MAX_ROW  == 0) {
                getSession().flush();
            }
        }
        getSession().flush();
        return entities;
    }

    /**
     * <b>方法说明：</b>
     * <ul>
     * 获取主键对应的记录
     * </ul>
     *
     * @param id 主键ID
     * @return EntityType 主键对应的记录
     */
    public EntityType get(int id) {
        @SuppressWarnings("unchecked")
        EntityType entity = (EntityType) getSession().get(this.entityClass, id);
        if (entity == null)
            throw new EntityNotFoundException(String.format("Entity %s %s not found", this.entityClass.getSimpleName(), id));
        return entity;
    }

    /**
     *
     * <b>方法说明：</b>
     * <ul>
     * 获取主键对应的记录
     * </ul>
     * @param id 主键ID
     * @return EntityType 主键对应的记录
     */
    @Override
    public EntityType get(short id) {
        @SuppressWarnings("unchecked")
        EntityType entity = (EntityType) getSession().get(this.entityClass, id);
        if (entity == null)
            throw new EntityNotFoundException(String.format("Entity %s %s not found", this.entityClass.getSimpleName(), id));
        return entity;
    }

    /**
     * 批量获取对象
     * @param ids 待获取对象ID列表
     * @return List 对象列表
     */
    @Override
    public List<EntityType> batchGetInt(List<Integer> ids) {
        List<EntityType> entities = new ArrayList<EntityType>();
        for (int i = 0; i < ids.size(); i++) {
            entities.add(get(ids.get(i)));
            if ( (i + 1) % BATCH_MAX_ROW  == 0) {
                getSession().flush();
            }
        }
        getSession().flush();
        return entities;
    }

    public boolean exists(String id) {
        return getSession().get(this.entityClass, id) != null;
    }

    public int countAll() {
        Criteria criteria = getCriteria();
        criteria.setProjection(Projections.rowCount());
        return Integer.parseInt(criteria.uniqueResult().toString());
    }

    public Serializable save(EntityType entity) {
        checkNull(entity);
        return getSession().save(entity);
    }

    /**
     * 批量添加
     *
     * @param entities 待添加对象列表
     */
    @Override
    public void batchSave(List<EntityType> entities) {
        for (int i = 0; i < entities.size(); i++) {
            save(entities.get(i));
            if ( (i + 1) % BATCH_MAX_ROW == 0) {
                getSession().flush();
            }
        }
        getSession().flush();
    }

    public void update(EntityType entity) {
        checkNull(entity);
        getSession().update(entity);
    }

    /**
     * 批量更新
     * @param entities 待批量更新记录列表
     */
    @Override
    public void batchUpdate(List<EntityType> entities) {
        for (int i = 0; i < entities.size(); i++) {
            update(entities.get(i));
            if ( (i + 1) % BATCH_MAX_ROW == 0) {
                getSession().flush();
            }
        }
        getSession().flush();
    }

    /**
     * <b>方法说明：</b>
     * <ul>
     * 删除记录
     * </ul>
     *
     * @param id 待删除记录ID
     */
    public void delete(String id) {
        EntityType entityType = get(id);
        delete(entityType);
    }

    /**
     * 批量删除记录
     * @param ids 待批量删除记录ID
     */
    @Override
    public void batchDeleteStr(List<String> ids) {
        for (int i = 0; i < ids.size(); i++) {
            delete(ids.get(i));
            if ( (i + 1) % BATCH_MAX_ROW == 0) {
                getSession().flush();
            }
        }
        getSession().flush();
    }

    public void delete(int id) {
        EntityType entityType = get(id);
        delete(entityType);
    }

    /**
     * 批量删除记录
     * @param ids 待批量删除记录ID
     */
    @Override
    public void batchDeleteInt(List<Integer> ids) {
        for (int i = 0; i < ids.size(); i++) {
            delete(ids.get(i));
            if ( (i + 1) % BATCH_MAX_ROW == 0) {
                getSession().flush();
            }
        }
        getSession().flush();
    }

    public void delete(EntityType entity) {
        checkNull(entity);
        getSession().delete(entity);
    }

    /**
     * 批量删除记录
     * @param models 待批量删除记录列表
     */
    @Override
    public void batchDelete(List<EntityType> models) {
        for (int i = 0; i < models.size(); i++) {
            delete(models.get(i));
            if ( (i + 1) % BATCH_MAX_ROW == 0) {
                getSession().flush();
            }
        }
        getSession().flush();
    }

    public void saveOrUpdate(EntityType entity) {
        checkNull(entity);
        getSession().saveOrUpdate(entity);
    }

    public void merge(EntityType entity) {
        checkNull(entity);
        getSession().merge(entity);
    }

    public List<EntityType> listAll() {
        return listAll(null, true);
    }

    /**
     * <b>方法说明：</b>
     * <ul>
     * 查询符合条件的所有表记录
     * </ul>
     *
     * @param filters 查询条件，以and方式组合
     * @return List 符合条件的所有表记录
     */
    @SuppressWarnings("unchecked")
    public List<EntityType> listAll(List<Criterion> filters) {
        Criteria criteria = getCriteria();
        criteria.add(Restrictions.and(filters.toArray(new Criterion[filters.size()])));
        return criteria.list();
    }

    /**
     * <b>方法说明：</b>
     * <ul>
     * 按序查询符合条件的所有表记录
     * </ul>
     *
     * @param filters 查询条件，以and方式组合
     * @param orderName 待排序字段
     * @param orderASC 是否顺序排序
     * @return List 符合条件的所有表记录
     */
    @SuppressWarnings("unchecked")
    public List<EntityType> listAll(List<Criterion> filters, String orderName, boolean orderASC) {
        Criteria criteria = getCriteria();
        criteria.add(Restrictions.and(filters.toArray(new Criterion[filters.size()])));
        if (orderASC) {
            criteria.addOrder(Order.asc(orderName));
        } else {
            criteria.addOrder(Order.desc(orderName));
        }
        return criteria.list();
    }

    /**
     * <b>方法说明：</b>
     * <ul>
     * 查询符合条件的所有表记录
     * </ul>
     *
     * @param filters 查询条件，以or方式组合
     * @return List 符合条件的所有表记录
     */
    @SuppressWarnings("unchecked")
    public List<EntityType> listAllOr(List<Criterion> filters) {
        Criteria criteria = getCriteria();
        criteria.add(Restrictions.or(filters.toArray(new Criterion[filters.size()])));
        return criteria.list();
    }

    public void persist(EntityType entity) {
        getSession().persist(entity);
    }

    @SuppressWarnings("unchecked")
    public List<EntityType> listAll(String orderName, boolean orderASC) {
        Criteria criteria = getCriteria();
        if (orderName != null) {
            if (orderASC)
                criteria.addOrder(Order.asc(orderName));
            else
                criteria.addOrder(Order.desc(orderName));
        }
        return criteria.list();
    }

    /**
     * <b>方法说明：</b>
     * <ul>
     * 查询符合条件的所有表记录
     * </ul>
     *
     * @param andFilters 查询条件，以and方式组合
     * @param orFilters 查询条件，以or方式组合
     * @return List 符合条件的所有表记录
     */
    @SuppressWarnings("unchecked")
    public List<EntityType> listAllAndOr(List<Criterion> andFilters, List<List<Criterion>> orFilters) {
        Criteria criteria = getCriteria();
        criteria.add(Restrictions.and(andFilters.toArray(new Criterion[andFilters.size()])));
        for (List<Criterion> perOrFilter : orFilters) {
            criteria.add(Restrictions.or(perOrFilter.toArray(new Criterion[perOrFilter.size()])));
        }
        return criteria.list();
    }

    /**
     *
     * <b>方法说明：</b>
     * <ul>
     * 查询符合条件的单条记录
     * </ul>
     * @param filters 查询条件，以and方式组合
     * @return EntityType 符合条件的唯一记录
     */
    public EntityType getUniqueResult(List<Criterion> filters) {
        Criteria criteria = getCriteria();
        criteria.add(Restrictions.and(filters.toArray(new Criterion[filters.size()])));
        return (EntityType) criteria.uniqueResult();
    }

    public List<EntityType> listPage(int start, int limit) {
        return listPage(start, limit, null, true);
    }

    @SuppressWarnings("unchecked")
    /**
     * start  -  初始行号，从0开始计算
     * limit  -  查询的总记录数
     */
    public List<EntityType> listPage(int start, int limit, String orderName, boolean orderASC) {
        Criteria criteria = getCriteria();
        if (orderName != null) {
            if (orderASC)
                criteria.addOrder(Order.asc(orderName));
            else
                criteria.addOrder(Order.desc(orderName));
        }
        criteria.setFirstResult(start);
        criteria.setMaxResults(limit);
        return criteria.list();
    }

    public void evict(EntityType entity) {
        getSession().evict(entity);
    }

    public void flush() {
        getSession().flush();
    }

    public void clear() {
        getSession().clear();
    }

    /**
     * <b>方法说明：</b>
     * <ul>
     * 锁住表中给定的单条记录并返回该条记录
     * </ul>
     *
     * @param recordID 表记录ID
     * @return EntityType 被锁住的表记录数据
     */
    public EntityType lockEntity(String recordID) {
        EntityType entityRecord = get(recordID);
        getSession().buildLockRequest(LockOptions.UPGRADE).lock(entityRecord);
        return entityRecord;
    }

    /**
     * <b>方法说明：</b>
     * <ul>
     * 锁住整个表并返回所有表记录
     * </ul>
     *
     * @return List 被锁住表的所有记录
     */
    public List<EntityType> lockEntity() {
        String tableName = entityClass.getAnnotation(Table.class).name();
        String hqlStr = "select * from " + tableName + " for update";
        Query query = getSession().createSQLQuery(hqlStr);
        query.executeUpdate();
        return listAll();
    }
}

StudentService.java

import com.great.dao.IStudentDAO;
import com.great.entity.hibernate.Student;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;
@Service
public class StudentHiberService {

    @Autowired
    private IStudentDAO iStudentDAO;

    public List<Student> getList(){
        List<Student> studentsList = iStudentDAO.listAll();
        return  studentsList;
    }

}

IStudentDao接口类

import com.great.common.IBaseDao;
import com.great.entity.hibernate.Student;
import org.hibernate.Criteria;
import org.hibernate.Criteria;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Restrictions;
import org.springframework.stereotype.Repository;
import java.util.List;

public interface IStudentDAO extends IBaseDao<Student> {

}

StuentDaoImpl实现类

@Repository
public class StudentDaoImpl extends BaseDao<Student> implements IStudentDAO {


}

Student.java 实体类

import javax.persistence.*;
import java.io.Serializable;


@Entity
@Table(name = "student2")
public class Student implements Serializable {

    @Id
    @Column(name = "id")
    private Integer id;

    @Column(name = "name", length = 255)
    private String name;

    @Column(name = "age")
    private Integer age;

    @Column(name = "avgScore", length = 255)
    private String avgScore;


    @Column(name = "sumScore", length = 255)
    private String sumScore;

    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;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getAvgScore() {
        return avgScore;
    }

    public void setAvgScore(String avgScore) {
        this.avgScore = avgScore;
    }

    public String getSumScore() {
        return sumScore;
    }

    public void setSumScore(String sumScore) {
        this.sumScore = sumScore;
    }
}

StudentController.java

import com.great.entity.hibernate.Student;
import com.great.service.StudentHiberService;
import com.great.service.StudentService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController
@RequestMapping("/stuhiber")
public class StudentHiberController {

    private static final Logger logger = LoggerFactory.getLogger(StudentHiberController.class);

    @Autowired
    private StudentHiberService studentHiberService;

    @RequestMapping("/list")
    public List<Student> getStus(){
        logger.info("从数据库用Hibernate读取Student集合");
        return studentHiberService.getList();
    }
}

本文对工程添加文件后工程结构图：

然后启动项目，访问地址： http://localhost:8080/myspringboot/stuhiber/list 响应结果如下：

[
{
id: 1,
name: “小明”,
sumScore: “252”,
avgScore: “84”,
age: 1
},
{
id: 2,
name: “小王”,
sumScore: “187”,
avgScore: “62.3”,
age: 1
},
{
id: 3,
name: “莉莉”,
sumScore: “”,
avgScore: “”,
age: 0
},
{
id: 4,
name: “柱子”,
sumScore: “230”,
avgScore: “76.7”,
age: 1
},
{
id: 5,
name: “大毛”,
sumScore: “”,
avgScore: “”,
age: 0
},
{
id: 6,
name: “亮子”,
sumScore: “0”,
avgScore: “0”,
age: 1
}
]