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