SpringBoot整合spring-data-jpa的方法
jpa是JavaEE定义的一种规范，常用的实现一般是Hibernate，而spring-data-jpa则是对jpa的又一层封装，提供了更多便捷的方法。
这里不会深入讲解spring-data-jpa的使用，只是讲解怎么快速的整合使用，目的是帮助那些想学，但是在整合上老是翻车的同学
导入依赖
<dependency> <groupId>com.zaxxer</groupId> <artifactId>HikariCP</artifactId> </dependency> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> </dependency>
配置
spring: data: jpa: repositories: # 开启jpa enabled: true bootstrap-mode: default jpa: # 数据库方言 database-platform: org.hibernate.dialect.MySQL57Dialect open-in-view: false # 打印SQL show-sql: false properties: # 格式化输出的SQL语句 hibernate.format_sql: false hibernate: # 自动建表策略 ddl-auto: update
这里忽略了数据源的配置
关于自动建表策略
# 枚举值 spring.jpa.hibernate.ddl-auto create 不管表是否存在, 每次启动都会重新建表(会导致数据丢失) create-drop 启动的时候创建表, 程序退出(SessionFactory关闭)的时候删除表 none 不进行任何操作 update 如果数据表不存在则创建, 在实体对象被修改后,下次启动重新修改表结构(不会删除已经存在的数据) validate 启动的时候验证数据表的结构,
相关的配置类
这里仅仅列出了部分常用的配置，如果需要了解所有的配置信息，可以参考配置类
JpaProperties SpringDataWebProperties HibernateProperties
相关配置的文档docs.spring.io/spring-boot…
定义实体类User
import java.io.Serializable;
import java.time.LocalDateTime;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Enumerated;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Index;
import javax.persistence.Table;
// 指定表名称
@Table(name = "user", indexes = {
// 定义索引
@Index(columnList = "account", unique = true)
})
// 标识实体类
@Entity
// 设置表注释
@org.hibernate.annotations.Table(appliesTo = "user", comment = "用户")
public class User implements Serializable {
/**
*
*/
private static final long serialVersionUID = 4953012795378725917L;
@Id // id 字段
@Column(columnDefinition = "INT(11) UNSIGNED COMMENT 'id'")
@GeneratedValue(strategy = GenerationType.IDENTITY) // 自增
private Integer id;
// 账户
@Column(columnDefinition = "VARCHAR(50) COMMENT '登录账户'", nullable = false)
private String account;
// 密码
@Column(columnDefinition = "VARCHAR(255) COMMENT '登录密码'", nullable = false)
private String password;
// 性别
@Column(columnDefinition = "TINYINT(1) COMMENT '性别。0：男，1：女'", nullable = false)
@Enumerated
private Gender gender;
// 创建时间
@Column(name = "created_date", columnDefinition = "timestamp DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间'", nullable = false)
private LocalDateTime createdDate;
// 最后修改时间
@Column(name = "last_modified_date", columnDefinition = "timestamp NULL DEFAULT NULL COMMENT '最后一次修改时间'")
private LocalDateTime lastModifiedDate;
// 记录状态
@Column(columnDefinition = "TINYINT(1) unsigned COMMENT '是否启用'", nullable = false)
private Boolean enabled;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getAccount() {
return account;
}
public void setAccount(String account) {
this.account = account;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public Gender getGender() {
return gender;
}
public void setGender(Gender gender) {
this.gender = gender;
}
public LocalDateTime getCreatedDate() {
return createdDate;
}
public void setCreatedDate(LocalDateTime createdDate) {
this.createdDate = createdDate;
}
public LocalDateTime getLastModifiedDate() {
return lastModifiedDate;
}
public void setLastModifiedDate(LocalDateTime lastModifiedDate) {
this.lastModifiedDate = lastModifiedDate;
}
public Boolean getEnabled() {
return enabled;
}
public void setEnabled(Boolean enabled) {
this.enabled = enabled;
}
@Override
public String toString() {
return "User [id=" + id + ", account=" + account + ", password=" + password + ", gender=" + gender
+ ", createdDate=" + createdDate + ", lastModifiedDate=" + lastModifiedDate + ", enabled=" + enabled
+ "]";
}
public static enum Gender {
BOY, GIRL
}
}
Repository
抽象出BaseRepository
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.repository.NoRepositoryBean;
@NoRepositoryBean // 该接口不是一个Repository，不需要生成代理实现
public interface BaseRepository <T, ID> extends JpaRepository<T, ID>, JpaSpecificationExecutor <T> // , QuerydslPredicateExecutor<T> 如果使用了QueryDSL还可以实现这个接口
{
}
定义 UserRepository
import io.springboot.jpa.entity.User;
public interface UserRepository extends BaseRepository<User, Integer> {
}
Service
抽象出 BaseService
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
public interface BaseService<T, ID> extends JpaRepository<T, ID>, JpaSpecificationExecutor <T>
// , QuerydslPredicateExecutor<T>
{
}
抽象出 AbstractService
import java.util.List;
import java.util.Optional;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Example;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.transaction.annotation.Transactional;
import io.springboot.jpa.repository.BaseRepository;
public abstract class AbstractService<T, ID> implements BaseService <T, ID> {
/**
* 泛型注入
*/
@Autowired
protected BaseRepository<T, ID> baseRepository;
@Override
@Transactional(readOnly = true, rollbackFor = Throwable.class)
public List<T> findAll() {
return this.baseRepository.findAll();
}
@Override
@Transactional(readOnly = true, rollbackFor = Throwable.class)
public List<T> findAll(Sort sort) {
return this.baseRepository.findAll(sort);
}
@Override
@Transactional(readOnly = true, rollbackFor = Throwable.class)
public List<T> findAllById(Iterable<ID> ids) {
return this.baseRepository.findAllById(ids);
}
@Override
@Transactional(rollbackFor = Throwable.class)
public <S extends T> List<S> saveAll(Iterable<S> entities) {
return this.baseRepository.saveAll(entities);
}
@Override
@Transactional(rollbackFor = Throwable.class)
public void flush() {
this.baseRepository.flush();
}
@Transactional(rollbackFor = Throwable.class)
public <S extends T> S saveAndFlush(S entity) {
return this.baseRepository.saveAndFlush(entity);
}
@Override
@Transactional(rollbackFor = Throwable.class)
public void deleteInBatch(Iterable<T> entities) {
this.baseRepository.deleteInBatch(entities);
}
@Override
@Transactional(rollbackFor = Throwable.class)
public void deleteAllInBatch() {
this.baseRepository.deleteAllInBatch();
}
@Override
@Transactional(readOnly = true, rollbackFor = Throwable.class)
public T getOne(ID id) {
return this.baseRepository.getOne(id);
}
@Override
@Transactional(readOnly = true, rollbackFor = Throwable.class)
public <S extends T> List<S> findAll(Example<S> example) {
return this.baseRepository.findAll(example);
}
@Override
@Transactional(readOnly = true, rollbackFor = Throwable.class)
public <S extends T> List<S> findAll(Example<S> example, Sort sort) {
return this.baseRepository.findAll(example, sort);
}
@Override
@Transactional(readOnly = true, rollbackFor = Throwable.class)
public Page<T> findAll(Pageable pageable) {
return this.baseRepository.findAll(pageable);
}
@Override
@Transactional(rollbackFor = Throwable.class)
public <S extends T> S save(S entity) {
return this.baseRepository.save(entity);
}
@Override
@Transactional(readOnly = true, rollbackFor = Throwable.class)
public Optional<T> findById(ID id) {
return this.baseRepository.findById(id);
}
@Override
@Transactional(readOnly = true, rollbackFor = Throwable.class)
public boolean existsById(ID id) {
return this.baseRepository.existsById(id);
}
@Override
@Transactional(readOnly = true, rollbackFor = Throwable.class)
public long count() {
return this.baseRepository.count();
}
@Override
@Transactional(rollbackFor = Throwable.class)
public void deleteById(ID id) {
this.baseRepository.deleteById(id);
}
@Override
@Transactional(rollbackFor = Throwable.class)
public void delete(T entity) {
this.baseRepository.delete(entity);
}
@Override
@Transactional(rollbackFor = Throwable.class)
public void deleteAll(Iterable<? extends T> entities) {
this.baseRepository.deleteAll(entities);
}
@Override
@Transactional(rollbackFor = Throwable.class)
public void deleteAll() {
this.baseRepository.deleteAll();
}
@Override
@Transactional(readOnly = true, rollbackFor = Throwable.class)
public <S extends T> Optional<S> findOne(Example<S> example) {
return this.baseRepository.findOne(example);
}
@Override
@Transactional(readOnly = true, rollbackFor = Throwable.class)
public <S extends T> Page<S> findAll(Example<S> example, Pageable pageable) {
return this.baseRepository.findAll(example, pageable);
}
@Override
@Transactional(readOnly = true, rollbackFor = Throwable.class)
public <S extends T> long count(Example<S> example) {
return this.baseRepository.count(example);
}
@Override
@Transactional(readOnly = true, rollbackFor = Throwable.class)
public <S extends T> boolean exists(Example<S> example) {
return this.baseRepository.exists(example);
}
@Override
@Transactional(readOnly = true, rollbackFor = Throwable.class)
public Optional<T> findOne(Specification<T> spec) {
return this.baseRepository.findOne(spec);
}
@Override
@Transactional(readOnly = true, rollbackFor = Throwable.class)
public List<T> findAll(Specification<T> spec) {
return this.baseRepository.findAll(spec);
}
@Override
@Transactional(readOnly = true, rollbackFor = Throwable.class)
public Page<T> findAll(Specification<T> spec, Pageable pageable) {
return this.baseRepository.findAll(spec, pageable);
}
@Override
@Transactional(readOnly = true, rollbackFor = Throwable.class)
public List<T> findAll(Specification<T> spec, Sort sort) {
return this.baseRepository.findAll(spec, sort);
}
@Override
@Transactional(readOnly = true, rollbackFor = Throwable.class)
public long count(Specification<T> spec) {
return this.baseRepository.count(spec);
}
}
定义 UserService
import org.springframework.stereotype.Service;
import io.springboot.jpa.entity.User;
@Service
public class UserService extends AbstractService<User, Integer> {
}
添加注解驱动
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.domain.EntityScan;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
@SpringBootApplication
@EnableJpaRepositories(basePackages = { "io.springboot.jpa.repository" })
@EntityScan(basePackages = { "io.springboot.jpa.entity" })
public class JpaApplication {
public static void main(String[] args) {
SpringApplication.run(JpaApplication.class, args);
}
}
@EnableJpaRepositories指定repository所在的包@EntityScan指定entity所在的包
测试
import io.springboot.jpa.JpaApplication;
import io.springboot.jpa.entity.User;
import io.springboot.jpa.service.UserService;
import java.time.LocalDateTime;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
@RunWith(SpringRunner.class)
@SpringBootTest(classes = JpaApplication.class, webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class JpaApplicationTest {
static final Logger LOGGER = LoggerFactory.getLogger(JpaApplicationTest.class);
@Autowired
UserService userService;
@Test
public void test () {
// 存储
User user = new User();
user.setAccount("kevinblandy.cn@gmail.com");
user.setPassword("123456");
user.setGender(User.Gender.GIRL);
user.setEnabled(Boolean.TRUE);
user.setCreatedDate(LocalDateTime.now());
this.userService.save(user);
LOGGER.info("save success.....");
// 检索
User results = this.userService.findById(user.getId()).orElseGet(null);
LOGGER.info("query result={}", results);
}
}
自动创建的表
CREATE TABLE `user` ( `id` int(11) unsigned NOT NULL AUTO_INCREMENT COMMENT 'id', `account` varchar(50) NOT NULL COMMENT '登录账户', `created_date` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间', `enabled` tinyint(1) unsigned NOT NULL COMMENT '是否启用', `gender` tinyint(1) NOT NULL COMMENT '性别。0：男，1：女', `last_modified_date` timestamp NULL DEFAULT NULL COMMENT '最后一次修改时间', `password` varchar(255) NOT NULL COMMENT '登录密码', PRIMARY KEY (`id`), UNIQUE KEY `UKdnq7r8jcmlft7l8l4j79l1h74` (`account`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='用户';
执行的日志
Hibernate:
insert
into
user
(account, created_date, enabled, gender, last_modified_date, password)
values
(?, ?, ?, ?, ?, ?)
2020-06-23 17:57:36.264 INFO 7612 --- [ main] i.s.jpa.test.JpaApplicationTest : save success.....
Hibernate:
select
user0_.id as id1_0_0_,
user0_.account as account2_0_0_,
user0_.created_date as created_3_0_0_,
user0_.enabled as enabled4_0_0_,
user0_.gender as gender5_0_0_,
user0_.last_modified_date as last_mod6_0_0_,
user0_.password as password7_0_0_
from
user user0_
where
user0_.id=?
2020-06-23 17:57:36.303 INFO 7612 --- [ main] i.s.jpa.test.JpaApplicationTest : query result=User [id=1, account=kevinblandy.cn@gmail.com, password=123456, gender=GIRL, createdDate=2020-06-23T17:57:36, lastModifiedDate=null, enabled=true]
总结
到此这篇关于SpringBoot整合spring-data-jpa的方法的文章就介绍到这了,更多相关SpringBoot整合spring-data-jpa内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！
相关推荐
-
在Spring Boot中使用Spring-data-jpa实现分页查询
在我们平时的工作中,查询列表在我们的系统中基本随处可见,那么我们如何使用jpa进行多条件查询以及查询列表分页呢?下面我将介绍两种多条件查询方式. 1.引入起步依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency&
-
springboot使用spring-data-jpa操作MySQL数据库
我们在上一篇搭建了一个简单的springboot应用,这一篇将介绍使用spring-data-jpa操作数据库. 新建一个MySQL数据库,这里数据库名为springboot,建立user_info数据表,作为我们示例操作的表对象. user_info信息如下: DROP TABLE IF EXISTS `user_info`; CREATE TABLE `user_info` ( `id` int(11) NOT NULL AUTO_INCREMENT, `username` varchar(
-
SpringBoot使用Spring-Data-Jpa实现CRUD操作
本文演示了SpringBoot下,实用Spring-Data-Jpa来实现CRUD操作,视图层采用Freemarker 这里我们先把application.properties修改成application.yml 主流格式 内容也改成yml规范格式: server: port: 8888 context-path: / helloWorld: spring Boot\u4F60\u597D msyql: jdbcName: com.mysql.jdbc.Driver dbUrl: jdbc:my
-
Spring-Data-JPA整合MySQL和配置的方法
一.简介 (1).MySQL是一个关系型数据库系统,是如今互联网公司最常用的数据库和最广泛的数据库.为服务端数据库,能承受高并发的访问量. (2).Spring-Data-Jpa是在JPA规范下提供的Repository层的实现,可以使用不同的实现框架如Hibernate.OpenJpa等框架进行开发,这样可以使得Repository变得简单,也解决了其与业务层的耦合性. 本此学习我们使用MySQL+Spring-Data-Jpa搭建,Jpa实现方式使用Hibernate,数据库连接池使用dbc
-
Spring Boot中使用Spring-data-jpa实现数据库增删查改
在实际开发过程中,对数据库的操作无非就"增删改查".就最为普遍的单表操作而言,除了表和字段不同外,语句都是类似的,开发人员需要写大量类似而枯燥的语句来完成业务逻辑. 为了解决这些大量枯燥的数据操作语句,我们第一个想到的是使用ORM框架,比如:Hibernate.通过整合Hibernate之后,我们以操作Java实体的方式最终将数据改变映射到数据库表中. 为了解决抽象各个Java实体基本的"增删改查"操作,我们通常会以泛型的方式封装一个模板Dao来进行抽象简化,但是这
-
SpringBoot整合Spring Data JPA的详细方法
目录 前言 核心概念 新建SpringBoot项目 创建MySQL数据库 创建实体类 创建Repository 创建处理器 准备SQL文件 编写配置文件 最终效果 启动SpringBoot项目 查看数据库 自动更新数据表结构 测试JPA的增删改查 测试查询所有 测试保存数据 测试更新数据 测试删除数据 前言 Spring Data JPA 是更大的 Spring Data 家族的一部分,可以轻松实现基于 JPA 的存储库.该模块处理对基于 JPA 的数据访问层的增强支持.它使构建使用数据访问技术
-
SpringBoot集成Spring Data JPA及读写分离
相关代码: github OSCchina JPA是什么 JPA(Java Persistence API)是Sun官方提出的Java持久化规范,它为Java开发人员提供了一种对象/关联映射工具 来管理Java应用中的关系数据.它包括以下几方面的内容: 1.ORM映射 支持xml和注解方式建立实体与表之间的映射. 2.Java持久化API 定义了一些常用的CRUD接口,我们只需直接调用,而不需要考虑底层JDBC和SQL的细节. 3.JPQL查询语言 这是持久化操作中很重要的一个方面,通过面向对象
-
Spring Boot整合Spring Data JPA过程解析
Spring Boot整合Spring Data JPA 1)加入依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> </dependency> <dependency> <groupId>mysql</groupId> &l
-
Springboot使用Spring Data JPA实现数据库操作
SpringBoot整合JPA 使用数据库是开发基本应用的基础,借助于开发框架,我们已经不用编写原始的访问数据库的代码,也不用调用JDBC(Java Data Base Connectivity)或者连接池等诸如此类的被称作底层的代码,我们将从更高的层次上访问数据库,这在Springboot中更是如此,本章我们将详细介绍在Springboot中使用 Spring Data JPA 来实现对数据库的操作. JPA & Spring Data JPA JPA是Java Persistence API
-
Spring Boot整合Spring Data Jpa代码实例
一.Spring Data Jpa的简介 spring data:其实就是spring 提供的一个操作数据的框架.而spring data JPA 只是spring data 框架下的一个基于JPA标准操作数据的模块. spring data jpa :基于JPA的标准对数据进行操作.简化操作持久层的代码,只需要编写接口就可以,不需要写sql语句,甚至可以不用自己手动创建数据库表. 二.添加依赖 <!--添加springdatajpa的依赖--> <dependency> <
-
spring data jpa 创建方法名进行简单查询方式
目录 最常见的做法是 按照规范创建查询方法 支持的规范表达式 spring data jpa 可以通过在接口中按照规定语法创建一个方法进行查询,spring data jpa 基础接口中,如CrudRepository中findOne,save,delete等,那么我们自己怎么按照需要创建一个方法进行查询呢? 最常见的做法是 声明一个接口继承于CrudRepository 或者 PagingAndSortingRepository,JpaRepository,Repository public
-
SpringBoot整合Spring Data Elasticsearch的过程详解
Spring Data Elasticsearch提供了ElasticsearchTemplate工具类,实现了POJO与elasticsearch文档之间的映射 elasticsearch本质也是存储数据,它不支持事物,但是它的速度远比数据库快得多, 可以这样来对比elasticsearch和数据库 索引(indices)--------数据库(databases) 类型(type)------------数据表(table) 文档(Document)---------------- 行(ro
-
Spring Boot 整合持久层之Spring Data JPA
目录 整合Spring Data JPA 1. 创建数据库 2. 创建项目 3. 数据库配置 4. 创建实体类 5. 创建 BookDao 接口 6. 创建 BookService 7. 创建 BookController 8. 测试 整合Spring Data JPA JPA (Java Persistence API)和 Spring Data 是两个范畴的概念. Hibernate 是一个 ORM 框架,JPA 则是一种ORM,JPA 和 Hibernate 的关系就像 JDBC 与 JD
-
使用Spring Data JPA的坑点记录总结
前言 Spring-data-jpa的基本介绍:JPA诞生的缘由是为了整合第三方ORM框架,建立一种标准的方式,百度百科说是JDK为了实现ORM的天下归一,目前也是在按照这个方向发展,但是还没能完全实现.在ORM框架中,Hibernate是一支很大的部队,使用很广泛,也很方便,能力也很强,同时Hibernate也是和JPA整合的比较良好,我们可以认为JPA是标准,事实上也是,JPA几乎都是接口,实现都是Hibernate在做,宏观上面看,在JPA的统一之下Hibernate很良好的运行. 最近在
-
spring data jpa开启批量插入、批量更新的问题解析
最近准备上spring全家桶写一下个人项目,该学的都学学,其中ORM框架,最早我用的是jdbcTemplate,后来用了Mybatis,唯独没有用过JPA(Hibernate)系的,过去觉得Hibernate太重量级了,后来随着springboot和spring data jpa出来之后,让我觉得好像还不错,再加上谷歌趋势... 只有中日韩在大规模用Mybatis(我严重怀疑是中国的外包),所以就很奇怪,虽然说中国的IT技术在慢慢抬头了,但是这社会IT发展的主导目前看来还是美国.欧洲,这里JPA