详细连接 简书https://www.jianshu.com/p/c14640b63653

新建项目,增加依赖

根据本样例的需求,我们要添加下面三个依赖

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>6.0.6</version> 引入的依赖尤其是这个依赖更加的重要你连接的数据库驱动就需要它
</dependency>
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver   

准备数据库环境

为这个项目,我们专门新建一个 springboot_jpa 的数据库,并且给 springboot 用户授权

create database springboot_jpa;  如果你用的是不是mysql的root 可以使用这个语句进行授权  如果是root那也可以不用进行授权
grant all privileges on springboot_jpa.* to 'springboot'@'%' identified by 'springboot';
flush privileges;

项目配置

但是数据库要自己创建
#通用数据源配置
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://10.110.2.56:3306/dbjpa?charset=utf8mb4&useSSL=false&serverTimezone=UTC //有时这个也是很必要的.
 spring.datasource.username=springboot spring.datasource.password=springboot 
# Hikari 数据源专用配置
spring.datasource.hikari.maximum-pool-size= spring.datasource.hikari.minimum-idle=5 # JPA 相关配置
spring.jpa.database-platform=org.hibernate.dialect.MySQL5InnoDBDialect
spring.jpa.show-sql=true //配置在日志中打印出执行的 SQL 语句信息。 spring.jpa.hibernate.ddl-auto=update 每次都会更新你的表首次访问会进行创建
  1. spring.jpa.hibernate.ddl-auto=create 配置指明在程序启动的时候要删除并且创建实体类对应的表。这个参数很危险,因为他会把对应的表删除掉然后重建。所以千万不要在生成环境中使用。只有在测试环境中,一开始初始化数据库结构的时候才能使用一次。
  2. spring.jpa.database-platform=org.hibernate.dialect.MySQL5InnoDBDialect 。在 SrpingBoot 2.0 版本中,Hibernate 创建数据表的时候,默认的数据库存储引擎选择的是 MyISAM (之前好像是 InnoDB,这点比较诡异)。这个参数是在建表的时候,将默认的存储引擎切换为 InnoDB 用的。

建立第一个数据实体类

数据库实体类是一个 POJO Bean 对象。这里我们先建立一个 数据库实体。数据库实体的源码如下

package cn.edu.aynu.entities;

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.ToString; import javax.persistence.*; /**
* Description: 164804116zln
* Created by lenovo on 2019/5/6 13:23
*/
@Data
@NoArgsConstructor
@Entity(name = "employee") //@Entity 是一个必选的注解,声明这个类对应了一个数据库表
@JsonIgnoreProperties(value = {"handler","hibernateLazyInitializer","fieldHandler"}) //下面解释
public class Employee {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Integer id;
@Column
private String name;
@Column
private String address; public Employee(String name, String address) {
this.name = name;
this.address = address;
} @Override
public String toString() {
return "Employee{" +
"id=" + id +
", name='" + name + '\'' +
", address='" + address + '\'' +
'}';
}
}

在hibernate查询数据,并将数据转化为json的时候报错,原因是hibernate在配置表A与表B之间的映射时,会在类A中引用类B,在类B中引用类A。当其中一个对象用jackson转成json时,会造成他们之间的无限引用,直到报错. 
解决办法:

在引用类及被引用类上加上注解

@JsonIgnoreProperties(value = {"handler","hibernateLazyInitializer","fieldHandler"})

但是,我就只建立了一个表居然还报错是不是很搞笑

其中:

@Table(name = "AUTH_USER") 是一个可选的注解。声明了数据库实体对应的表信息。包括表名称、索引信息等。这里声明这个实体类对应的表名是 AUTH_USER。如果没有指定,则表名和实体的名称保持一致。

  1. @Id 注解声明了实体唯一标识对应的属性。
  2. @Column(length = 32) 用来声明实体属性的表字段的定义。默认的实体每个属性都对应了表的一个字段。字段的名称默认和属性名称保持一致(并不一定相等)。字段的类型根据实体属性类型自动推断。这里主要是声明了字符字段的长度。如果不这么声明,则系统会采用 255 作为该字段的长度
 @GeneratedValue(strategy = GenerationType.IDENTITY) 
(https://www.cnblogs.com/sandea/p/8252809.html)这是一个很详细的注解解释上面的例子

实现一个持久层服务

在 Spring Data JPA 的世界里,实现一个持久层的服务是一个非常简单的事情。我只需要声明一个接口,这个接口继承
org.springframework.data.repository.Repository<T, ID> 接口或者他的子接口就行。这里为了功能的完备,我们继承了 org.springframework.data.jpa.repository.JpaRepository<T, ID> 接口。其中 T 是数据库实体类,ID 是数据库实体类的主键。
然后再简单的在这个接口上增加一个 @Repository 注解就结束了。其实不加也可以

@Repository
public interface UserDao extends JpaRepository<employee, Long> {
}

那么你就有了操纵数据库的基本功能,我使用的是postman进行测试的

package cn.edu.aynu.controller;

import cn.edu.aynu.dao.EmployeeDao;
import cn.edu.aynu.entities.Employee;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*; import java.util.List; /**
* Description: 164804116zln
* Created by lenovo on 2019/5/6 13:31
*/
@RestController
public class EmployeeHandler { @Autowired
EmployeeDao employeeDao; @PostMapping(path = "/add")
public void add(@RequestBody Employee employee){
employeeDao.save(employee); }
@GetMapping("/emp/{id}") public Employee get(@PathVariable("id") Integer id){
System.out.println(id);
Employee employee = employeeDao.getOne(id); return employee;
} @GetMapping("/emps")
public List<Employee> getAll(){
List<Employee> employees = employeeDao.findAll();
return employees;
} }

Controller

数据库记录

我们还可以通过测试用例验证通过标识查找对象功能,查询所有数据功能的正确性,查询功能甚至可以进行排序和分页

    @Test
public void testLocate() {
Optional<UserDO> userDOOptional = userDao.findById(1L);
if (userDOOptional.isPresent()) {
UserDO userDO = userDOOptional.get();
System.out.println("name = " + userDO.getName());
System.out.println("account = " + userDO.getAccount());
}
} @Test
public void testFindAll() {
List<UserDO> userDOList = userDao.findAll(new Sort(Sort.Direction.DESC,"account"));
for (UserDO userDO : userDOList) {
System.out.println("name = " + userDO.getName());
System.out.println("account = " + userDO.getAccount());
}
}

controller

可以看到,我们所做的全部事情仅仅是在 SpingBoot 工程里面增加数据库配置信息,声明一个 UserDO 的数据库实体对象,然后声明了一个持久层的接口,改接口继承自 org.springframework.data.jpa.repository.JpaRepository<T, ID> 接口。然后,系统就自动拥有了丰富的增加、删除、修改、查询功能。查询功能甚至还拥有了排序和分页的功能。

这就是 JPA 的强大之处。除了这些接口外,用户还会有其他的一些需求, JPA 也一样可以满足你的需求。

扩展查询

很多我们想要的查询功能还没有。不过放心。JPA 有非常方便和优雅的方式来解决

根据属性来查询

如果想要根据实体的某个属性来进行查询我们可以在

@Repository
public interface EmployeeDao extends JpaRepository<Employee,Integer> {
 UserDO findByAccount(String account);
}

接口中进行接口声明。例如,如果我们想根据实体的 account 这个属性来进行查询(在登录功能的时候可能会用到)。我们在 com.yanggaochao.springboot.learn.springbootjpalearn.security.dao.UserDao 中增加一个接口声明就可以了

然后增加一个测试用例

@Test
public void testFindByAccount() {
UserDO userDO = userDao.findByAccount("wentian");
if (userDO != null) {
System.out.println("name = " + userDO.getName());
System.out.println("account = " + userDO.getAccount());
}
}

这种方式非常强大,不经能够支持单个属性,还能支持多个属性组合。例如如果我们想查找账号和密码同时满足查询条件的接口。那么我们在 UserDao 接口中声明

UserDO findByAccountAndPwd(String account, String pwd);

再例如,我们要查询 id 大于某个条件的用户列表,则可以声明如下的接口

List<UserDO> findAllByIdGreaterThan(Long id);

这个语句结构可以用下面的表来说明

 
JPA 关键字说明

自定义查询

如果上述的情况还无法满足需要。那么我们就可以通过通过 import org.springframework.data.jpa.repository.Query 注解来解决这个问题。例如我们想查询名称等于某两个名字的所有用户列表,则声明如下的接口即可

@Query("SELECT O FROM UserDO O WHERE O.name = :name1  OR O.name = :name2 ")
List<UserDO> findTwoName(@Param("name1") String name1, @Param("name2") String name2);

这里是用 PQL 的语法来定义一个查询。其中两个参数名字有语句中的 : 后面的支付来决定

如果你习惯编写 SQL 语句来完成查询,还可以在用下面的方式实现

@Query(nativeQuery = true, value = "SELECT * FROM AUTH_USER WHERE name = :name1  OR name = :name2 ")
List<UserDO> findSQL(@Param("name1") String name1, @Param("name2") String name2);

这里在 @Query 注解中增加一个 nativeQuery = true 的属性,就可以采用原生 SQL 语句的方式来编写查询。

联合主键

从 org.springframework.data.jpa.repository.JpaRepository<T, ID> 接口定义来看,数据实体的主键是一个单独的对象,那么如果一个数据库的表的主键是两个或者两个以上字段联合组成的怎么解决呢。

我们扩充一下前面的场景。假如我们有一个角色 Role 对象,有两个属性 一个 id ,一个 name ,对应了 auth_role 数据表,同时有一个角色用户关系对象 RoleUser,说明角色和用户对应关系,有两个属性 roleId,userId 对应 auth_role_user 表。那么我们需要声明一个 RoleDO 对象如下

package com.yanggaochao.springboot.learn.springbootjpalearn.security.domain.dao;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;
@Entity
@Table(name = "AUTH_ROLE")
public class RoleDO {
@Id
private Long id;
@Column(length = )
private String name;
@Column(length = )
private String note; public Long getId() {
return id;
} public void setId(Long id) {
this.id = id;
} public String getName() {
return name;
} public void setName(String name) {
this.name = name;
} public String getNote() {
return note;
} public void setNote(String note) {
this.note = note;
}
}

bean

对于有多个属性作为联合主键的情况,我们一般要新建一个单独的主键类,他的属性和数据库实体主键的字段一样,要实现 java.io.Serializable 接口,类声明如下

package com.yanggaochao.springboot.learn.springbootjpalearn.security.domain.dao;

import java.io.Serializable;

public class RoleUserId implements Serializable {
private Long roleId;
private Long userId;
}

同样的,我们声明一个 RoleUserDO 对象如下

package com.yanggaochao.springboot.learn.springbootjpalearn.security.domain.dao;

import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.IdClass;
import javax.persistence.Table;
import java.io.Serializable; @Entity
@IdClass(RoleUserId.class)
@Table(name = "AUTH_ROLE_USER")
public class RoleUserDO {
@Id
private Long roleId;
@Id
private Long userId; public Long getRoleId() {
return roleId;
} public void setRoleId(Long roleId) {
this.roleId = roleId;
} public Long getUserId() {
return userId;
} public void setUserId(Long userId) {
this.userId = userId;
}
}

这里因为数据实体类和数据实体主键类的属性一样,所以我们可以删除掉这个数据实体主键类,然后将数据实体类的主键类声明为自己即可。当然,自己也要实现 java.io.Serializable 接口。

这样,我们如果要查询某个角色下的所有用户列表,就可以声明如下的接口

@Query("SELECT U FROM UserDO U ,RoleUserDO RU WHERE U.id = RU.userId AND RU.roleId = :roleId")
List<UserDO> findUsersByRole(@Param("roleId") Long roleId);

================================================

下面我放上一个完整的操纵jpa的例子,注意数据库需要自己创建

package cn.edu.aynu.controller;

import cn.edu.aynu.dao.EmployeeDao;
import cn.edu.aynu.entities.Employee;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*; import java.util.List; /**
* Description: 164804116zln
* Created by lenovo on 2019/5/6 13:31
*/
@RestController
public class EmployeeHandler { @Autowired
EmployeeDao employeeDao; @PostMapping(path = "/add")
public void add(@RequestBody Employee employee){
employeeDao.save(employee); }
@GetMapping("/emp/{id}") public Employee get(@PathVariable("id") Integer id){
System.out.println(id);
Employee employee = employeeDao.getOne(id); return employee;
} @GetMapping("/emps")
public List<Employee> getAll(){
List<Employee> employees = employeeDao.findAll();
return employees;
} }

Controller

package cn.edu.aynu.dao;

import cn.edu.aynu.entities.Employee;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository; /**
* Description: 164804116zln
* Created by lenovo on 2019/5/6 13:31
*/
@Repository
public interface EmployeeDao extends JpaRepository<Employee,Integer> { }

EmployeeDao

package cn.edu.aynu.entities;

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.ToString; import javax.persistence.*; /**
* Description: 164804116zln
* Created by lenovo on 2019/5/6 13:23
*/
@Data
@NoArgsConstructor
@Entity(name = "employee")
@JsonIgnoreProperties(value = {"handler","hibernateLazyInitializer","fieldHandler"})
public class Employee {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Integer id;
@Column
private String name;
@Column
private String address; public Employee(String name, String address) {
this.name = name;
this.address = address;
} @Override
public String toString() {
return "Employee{" +
"id=" + id +
", name='" + name + '\'' +
", address='" + address + '\'' +
'}';
}
}

bean

 <dependencies>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.1.</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>6.0.</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>2.0.</version>
</dependency> <dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>

pom

#通用数据源配置
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/dbjpa?charset=utf8mb4&useSSL=false&serverTimezone=UTC
spring.datasource.username=root
spring.datasource.password=root
# Hikari 数据源专用配置
spring.datasource.hikari.maximum-pool-size=
spring.datasource.hikari.minimum-idle=
# JPA 相关配置
spring.jpa.database-platform=org.hibernate.dialect.MySQL5InnoDBDialect
spring.jpa.show-sql=true
spring.jpa.hibernate.ddl-auto=update

application.properties

 
 
 

SpringBoot 中 JPA 的使用的更多相关文章

  1. SpringBoot中JPA的学习

    SpringBoot中JPA的学习 准备环境和项目配置 写一下学习JPA的过程,主要是结合之前SpringBoot + Vue的项目和网上的博客学习一下. 首先,需要配置一下maven文件,有这么两个 ...

  2. springboot中JPA的应用

    1.JPA JPA(Java Persistence API)是Sun官方提出的Java持久化规范.它为Java开发人员提供了一种对象/关联映射工具来管理Java应用中的关系数据.他的出现主要是为了简 ...

  3. SpringBoot中JPA使用动态SQL查询

    https://www.jianshu.com/p/f72d82e90948 可以重点关注方法二,把原生sql传入数据库去查询 好处是:更加灵活坏处是:拼接sql比较痛苦,也容易出问题,比如拼接的sq ...

  4. SpringBoot中JPA,返回List排序

    这里简单示例,利用query,根据“createtime”字段,进行 desc 排序,最近日期的数据在最前面. public List<StatusEvent> findAll(Speci ...

  5. SpringBoot中使用Spring Data Jpa 实现简单的动态查询的两种方法

    软件152 尹以操 首先谢谢大佬的简书文章:http://www.jianshu.com/p/45ad65690e33# 这篇文章中讲的是spring中使用spring data jpa,使用了xml ...

  6. Spring Data JPA系列2:SpringBoot集成JPA详细教程,快速在项目中熟练使用JPA

    大家好,又见面了. 这是Spring Data JPA系列的第2篇,在上一篇<Spring Data JPA系列1:JDBC.ORM.JPA.Spring Data JPA,傻傻分不清楚?给你个 ...

  7. 【极简版】SpringBoot+SpringData JPA 管理系统

    前言 只有光头才能变强. 文本已收录至我的GitHub仓库,欢迎Star:https://github.com/ZhongFuCheng3y/3y 在上一篇中已经讲解了如何从零搭建一个SpringBo ...

  8. 带你搭一个SpringBoot+SpringData JPA的环境

    前言 只有光头才能变强. 文本已收录至我的GitHub仓库,欢迎Star:https://github.com/ZhongFuCheng3y/3y 不知道大家对SpringBoot和Spring Da ...

  9. 二、springboot使用jpa

    花了几天时间,好好看了看springboot的jpa部分,总结了常用的形式. 1.通过STS工具添加jpa的依赖项 要连mysql,测试的时候需要web,顺便添加了lombok不写set和get方法了 ...

随机推荐

  1. PHP防盗链的基本思想&&防盗链的设置方法

    PHP防盗链的基本思想&&防盗链的设置方法 网站盗链会大量消耗被盗链网站的带宽,而真正的点击率也许会很小,严重损害了被盗链网站的利益.本文主要介绍用PHP实现防盗链的方法以及基本思想, ...

  2. centos7下安装docker(17.4docker监控----prometheus)

    Prometheus是一个非常优秀的监控工具.准确的说,应该是监控方案.Prometheus提供了监控数据搜集,存储,处理,可视化和告警一套完整的解决方案 Prometheus架构如盗图: 官网上的原 ...

  3. 数组长度为len,数组元素的范围是0到len-1,找出数组的重复元素

    public static int findDuplicate(int[] nums) { int len = nums.length; //注意这里的for循环写法,在交换元素后,i没有增加,还要继 ...

  4. Python入门学习:1.变量和简单的数据类型

    python入门学习:1.变量和简单的数据类型 关键点:变量.字符串.数字 1.1 变量的命名和使用1.2 字符串1.3 数字1.4 注释 1.1 变量的命名和使用   变量,顾名思义是一个可变的量, ...

  5. 【转】ffmpeg常用基本命令

    [FFmpeg]FFmpeg常用基本命令 1.分离视频音频流 ffmpeg -i input_file -vcodec copy -an output_file_video //分离视频流 ffmpe ...

  6. CF650C Table Compression

    CF650C Table Compression 给一个 \(n\times m\) 的非负整数矩阵 \(a\),让你求一个 \(n\times m\) 的非负整数矩阵 \(b\),满足以下条件 若 ...

  7. CF833D Red-Black Cobweb 点分治、树状数组

    传送门 统计所有路径的边权乘积的乘积,不难想到点分治求解. 边权颜色比例在\([\frac{1}{2},2]\)之间,等价于\(2B \geq R , 2R \geq B\)(\(R,B\)表示红色和 ...

  8. HTTP协议详细分析

    1.HTTP概述 1.1.什么是HTTP? 它是Hyper Text Transfer Protocol的缩写.超文本传输协议. 它是客户浏览器和web服务器之间的一种一问一答的规则.问答机制/握手机 ...

  9. 性能调优3:硬盘IO性能

    数据库系统严重依赖服务器的资源:CPU,内存和硬盘IO,通常情况下,内存是数据的读写性能最高的存储介质,但是,内存的价格昂贵,这使得系统能够配置的内存容量受到限制,不能大规模用于数据存储:并且内存是易 ...

  10. Windows Community Toolkit 3.0 - InfiniteCanvas

    概述 InfiniteCanvas 是一个 Canvas 控件,它支持无限画布的滚动,支持 Ink,文本,格式文本,画布缩放操作,撤销重做操作,导入和导出数据. 这是一个非常实用的控件,在“来画视频” ...