基于Springboot讲解SpringData JPA使用

最新推荐文章于 2024-10-06 11:02:46 发布
最新推荐文章于 2024-10-06 11:02:46 发布
阅读量410 收藏
点赞数
分类专栏： Java框架 文章标签： springdata JPA springboot spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/baozi7263/article/details/103727947
版权

SpringData框架

1、什么是SpringData

SpringData是Spring的一个子项目，它存在的目的是用于简化持久层（数据库访问层）开发，既支持关系型数据库也支持NoSQL数据库的操作。其主要的目标是数据库的访问变得更加便捷。

SpringData支持的非关系型数据库：

  • MongoDB（文档数据库）

  • Neo4j（图形数据库）

  • Redis（键/值存储）

  • HBase

  • ES（搜索库）

SpringData支持的关系型数据库：MySQL、DB2、Oracle等都支持:

  • JDBC：sun公司推出原生的Java操作数据库的规范（JDBC接口编程）

  • JPA：JPA是sun公司给出持久层（ORM层）一种编程规范（不同的ORM框架对JPA都进行具体的实现：Hibernate）。

SpringData的官网： https://spring.io/projects/spring-data

SpringData JPA：致力于减少数据访问层（DAO、Repository）的开发量，作为开发者主要需要做的唯一的事情，根据SpringData JPA定义的接口来书写相关的DAO层的子接口即可，其他的CRUD操作等全部都交给SpringData JPA完成。

2、SpringData JPA快速入门

2.1、搭建SpringData JPA的开发环境

说明环境：使用SpringBoot构建基础环境，使用Maven作为基础的管理。然后搭建一套完成的web环境（SpringMVC、Spring、SpringData、SpringBoot）、使用开发工具是Idea。

2.1.1、使用maven创建项目

2.1.2、导入pom依赖和编写配置

pom文件

 <?xml version="1.0" encoding="UTF-8"?>
 <project xmlns="http://maven.apache.org/POM/4.0.0"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
 ​
     <groupId>com.qubo.springdata</groupId>
     <artifactId>springdata-demo</artifactId>
     <version>1.0-SNAPSHOT</version>
 ​
     <!-- 引入SpringBoot父工程-->
     <parent>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-parent</artifactId>
         <version>2.1.6.RELEASE</version>
     </parent>
     <!-- 配置一些jdk、编码等信息 -->
     <properties>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
         <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
         <java.version>1.8</java.version>
     </properties>
     <!--引入需要的依赖-->
     <dependencies>
         <!-- 引入springmvc，spring等依赖 -->
         <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-web</artifactId>
         </dependency>
         <!-- 导入springdata jpa -->
         <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-data-jpa</artifactId>
         </dependency>
         <!-- mysql驱动 -->
         <dependency>
             <groupId>mysql</groupId>
             <artifactId>mysql-connector-java</artifactId>
             <version>8.0.18</version>
         </dependency>
         <!-- lombok -->
         <dependency>
             <groupId>org.projectlombok</groupId>
             <artifactId>lombok</artifactId>
             <version>1.18.8</version>
         </dependency>
     </dependencies>
 </project>

yml配置文件：

 # 服务器的端口号
 server:
   port: 80
 ​
 # springdatajap 和数据源的配置
 spring:
   jpa:  # springdata jpa相关的配置
     generate-ddl: false
     show-sql: true
     hibernate:
       ddl-auto: none
   datasource:
     url: jdbc:mysql://127.0.0.1:3306/springdata
     username: root
     password: root
     driver-class-name: com.mysql.jdbc.Driver
 ​
 # 日志
 logging:
   level:
     root: info
     org.hibernate.*: debug
 ​

编写核心启动类：

 package com.qubo;
 ​
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 ​
 @SpringBootApplication
 public class SpringDataJPAStart {
     public static void main(String[] args) {
         SpringApplication.run(SpringDataJPAStart.class,args);
     }
 }

2.2、SpringData JPA的开发步骤

使用SpringDataJPA进行持久层开发的时候一般有4个步骤：

  1. 配置Spring整合JPA

  2. 在Spring配置文件中需要配置SpringData

  3. 定义持久层的接口，需要继承SpringData中提供的Repository接口（一般继承它的子接口JPARepository）

  4. 如果继承的接口中的方法不够用，可以在自己定义的接口中按照一定的规则去书写方法操作数据库

友情提示：

由于使用SpringBoot构建的项目环境，因此第一步和第二步基本省略了，其实改成注解方式。

2.3、Lombok插件

开发中需要大量书写pojo实体类，虽然IDE能够直接生成get、set、constructor、equals、hashCode、toString等等方法，但是还是比较麻烦，代码比较多，看起来pojo类很臃肿。

使用lombok插件，能够快速的生成get、set、constructor、equals、hashCode、toString等等方法。并且实体类中代码很简洁。

说明：这个插件是帮助我们去在编译的时候，给生成的class文件中添加上述的方法。而不是说真正没有这些方法。源码中没有，但是class文件（字节码）中存在。

注意：需要导入lombok的依赖包的同时，还要给IDE（eclipse、idea）安装插件。

  <!-- lombok -->
         <dependency>
             <groupId>org.projectlombok</groupId>
             <artifactId>lombok</artifactId>
             <version>1.18.8</version>
         </dependency>

2.4、快速完成查询操作

创建表：

 CREATE TABLE tb_user(
    id INT PRIMARY KEY AUTO_INCREMENT,
    username VARCHAR(50),
    PASSWORD VARCHAR(50),
    age INT ,
    salary DOUBLE
 )

改在核心启动类：

 @SpringBootApplication
 // 配置持久层接口所在的包
 @EnableJpaRepositories(basePackages = "com.qubo.repository")
 // 配置pojo所在的包
 @EntityScan("com.qubo.pojo")
 public class SpringDataJPAStart {
     public static void main(String[] args) {
         SpringApplication.run(SpringDataJPAStart.class,args);
     }
 }

编写Controller类：

 package com.qubo.controller;
 ​
 import com.qubo.pojo.User;
 import com.qubo.service.UserService;
 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
 public class UserController {
 ​
     @Autowired
     private UserService userService;
     @RequestMapping("users")
     public List<User> findUsers(){
         return this.userService.findUsers();
     }
 }
 ​

编写servcie类：

 package com.qubo.service;
 ​
 import com.qubo.pojo.User;
 import com.qubo.repository.UserRepository;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 ​
 import java.util.List;
 ​
 @Service
 public class UserService {
     @Autowired
     private UserRepository userRepository;
     public List<User> findUsers() {
         return this.userRepository.findAll();
     }
 }
 ​

编写repository接口：

 package com.qubo.repository;
 ​
 import com.qubo.pojo.User;
 import org.springframework.data.jpa.repository.JpaRepository;
 ​
 /**
  *  在使用SpringDataJPA自定义的接口需要继承Repository接口或者其子接口
  *      Repository : 它只是一个接口中没有提供方法
  *      JpaRepository ： 它提供CRUD的方法，以及分页，排序等方法
  *      接口中泛型：
  *          第一个：实体类类型
  *          第二个：主键的类型
  */
 public interface UserRepository extends JpaRepository<User,Integer> {
 }
 ​

测试结果：

 @Data
 @NoArgsConstructor  // 无参构造
 @AllArgsConstructor // 有参数构造
 @ToString
 @EqualsAndHashCode
 @Getter
 @Setter
 public class User {
     private String username;
     private String password;
     private Integer age;
     private Double salary;
 }
 ​

3、关于SpringData JPA接口介绍

3.1、Repository接口

 @Indexed
 public interface Repository<T, ID> {
 ​
 }

Repository接口是SpringData 的一个核心接口，但是它中不提供任何的方法，类似于Java中标记型接口概念。如果我们编程的时候直接继承这个接口，那么就需要自己在自定义的接口中添加CRUD等方法。

SpringData 提供了一些定义方法的规范，这样可以省略书写SQL过程：

KeywordSampleJPQL snippet
AndfindByLastnameAndFirstname… where x.lastname = ?1 and x.firstname = ?2
OrfindByLastnameOrFirstname… where x.lastname = ?1 or x.firstname = ?2
Is, EqualsfindByFirstname,findByFirstnameIs,findByFirstnameEquals… where x.firstname = ?1
BetweenfindByStartDateBetween… where x.startDate between ?1 and ?2
LessThanfindByAgeLessThan… where x.age < ?1
LessThanEqualfindByAgeLessThanEqual… where x.age <= ?1
GreaterThanfindByAgeGreaterThan… where x.age > ?1
GreaterThanEqualfindByAgeGreaterThanEqual… where x.age >= ?1
AfterfindByStartDateAfter… where x.startDate > ?1
BeforefindByStartDateBefore… where x.startDate < ?1
IsNull, NullfindByAge(Is)Null… where x.age is null
IsNotNull, NotNullfindByAge(Is)NotNull… where x.age not null
LikefindByFirstnameLike… where x.firstname like ?1
NotLikefindByFirstnameNotLike… where x.firstname not like ?1
StartingWithfindByFirstnameStartingWith… where x.firstname like ?1 (parameter bound with appended %)
EndingWithfindByFirstnameEndingWith… where x.firstname like ?1 (parameter bound with prepended %)
ContainingfindByFirstnameContaining… where x.firstname like ?1 (parameter bound wrapped in %)
OrderByfindByAgeOrderByLastnameDesc… where x.age = ?1 order by x.lastname desc
NotfindByLastnameNot… where x.lastname <> ?1
InfindByAgeIn(Collection ages)… where x.age in ?1
NotInfindByAgeNotIn(Collection ages)… where x.age not in ?1
TruefindByActiveTrue()… where x.active = true
FalsefindByActiveFalse()… where x.active = false
IgnoreCasefindByFirstnameIgnoreCase… where UPPER(x.firstame) = UPPER(?1)
 package com.qubo.repository;
 ​
 import com.qubo.pojo.User;
 import org.springframework.data.repository.Repository;
 ​
 import java.util.List;
 ​
 public interface UserRepository2 extends Repository<User, Integer> {
     // select * from tb_user where username = ? and password = ?
     public List<User> findByUsernameAndPassword(String username , String password);
 }
 ​

3.2、CrudRepository接口

CrudRepository：它是Repository接口的子接口，其中主要提供简单的增删改查操作的方法。

 public interface CrudRepository<T, ID> extends Repository<T, ID>

 

CrudRepository细节：

在进行根据主键操作的时候，我们需要给pojo指定主键和主键的策略

3.3、PagingAndSortingRepository接口

PagingAndSortingRepository：它主要在CrudRepository基础上提供分页和排序功能。

@NoRepositoryBean
public interface PagingAndSortingRepository<T, ID> extends CrudRepository<T, ID> {


	Iterable<T> findAll(Sort sort);   //  排序


	Page<T> findAll(Pageable pageable);  // 分页
}

准备分页对象：

@Data
public class PageResult<T> {
    // 设置总页数
    private Integer total;
    private Integer pages;
    private List<T> datas;
}

service中的逻辑代码：

     public PageResult<User> getPage(Integer page, Integer size) {
         //  设置分页参数
         Pageable pageable = PageRequest.of(page , size);
         // 执行查询
         Page<User> users = this.userRepository.findAll(pageable);
         // 需要将数据构建到自定义的分页结果对象中
         PageResult<User> pageResult = new PageResult<>();
         // 封装分页页面所需的数据
         pageResult.setDatas(users.getContent());
         // 封装总页数
         pageResult.setPages(users.getTotalPages());
         // 封装总记录数
         pageResult.setTotal(users.getTotalElements());
         return pageResult;
     }

controller的代码：

 @RequestMapping("page")
 public PageResult<User> getPage(
     @RequestParam(name="page" ,required = true , defaultValue = "0")Integer page,
     @RequestParam(name="size" ,required = true , defaultValue = "2")Integer size   ){
         return this.userService.getPage(page , size);
     }

3.4、JpaRepository接口

JpaRepository ： 它是我们书写代码的时候真正需要继承的持久层的接口。JpaRepository接口将SpringData JPA提供的所有的常用的功能都继承到了

 

3.5、JpaSpecificationExecutor接口

JpaSpecificationExecutor ： 它主要通过编码的方式完成条件查询。

public interface JpaSpecificationExecutor<T> {
	Optional<T> findOne(@Nullable Specification<T> spec);

	List<T> findAll(@Nullable Specification<T> spec);

	Page<T> findAll(@Nullable Specification<T> spec, Pageable pageable);

	List<T> findAll(@Nullable Specification<T> spec, Sort sort);

	long count(@Nullable Specification<T> spec);
}

Specification：使用Specification来封装查询的条件。由于Specification又是一个接口，因此经常配合内部类或者使用Lambda表达式完成条件的封装

Predicate toPredicate(Root<T> root, CriteriaQuery<?> query, CriteriaBuilder criteriaBuilder);

    public List<User> findNames(String name) {
 ​
         //  构建查询的条件 , 使用匿名内部类
         Specification spec = new Specification(){
             /*
                 在使用Specification接口构建查询条件的时候，需要复写toPredicate方法
                 但是toPredicate方法上有三个参数：
                     Root root：与数据库表对应的实体类对象，就是pojo
                     CriteriaQuery query：获取Root中的属性名，添加额外的一些查询条件
                     CriteriaBuilder criteriaBuilder：用来构建出查询条件对象
              */
             public Predicate toPredicate(Root root, CriteriaQuery query, CriteriaBuilder criteriaBuilder) {
                 // SELECT * FROM tb_user WHERE username LIKE '%唐%'
                 Path username = root.get("username"); // 获取到属性名，对应将来就是列名
                 return criteriaBuilder.like(username , "%"+name+"%");
             }
         };
         // List<User> users = this.userRepository.findAll(spec);
         // 上的写法完成可以使用Lambda表达式代替
         List<User> users = this.userRepository.findAll( (root , query  ,criteriaBuilder )-> criteriaBuilder.like(root.get("username"),"%"+name+"%") );
         return users;
     }

3.5、总结

使用SpringData JPA的时候，我们需要在持久层书写接口，然后去继承JPARepository接口。这时我们的接口就已经具备了对数据库表的基本的操作了。

比如：增删改查，分页，排序等等。

但是不具备编写一些复杂的条件查询，于是一般建议自定义的接口同时还要去继承JpaSpecificationExecutor 。

 public interface UserRepository extends JpaRepository<User,Integer> , JpaSpecificationExecutor<User>

3.6、@Query注解

有时使用SpringData JPA的时候，已经提供的哪些方法无法满足我们的需求，只能自己手写sql来完成查询操作。这时需要就需要在自定义的方法上使用@Query注解来书写sql语句。

3.6.1、数字占位符

     //  自定义的方法，不要和接口中已经存在的方法重名，也不要和已经提供的方法命名规范重合
     //@Query("select * from tb_user where id = ?")
     @Query("select u from User u where id = ?1")
     public User findUserById(Integer id);
 ​

说明：

  1. 在接口中自定义的方法上使用@Query注解来实现自定义sql语句，在sql语句中参数使用?数字，数字从1往后排。要求数字和方法上的参数一一对应

  2. SQL中表名的位置不能书写表名，需要书写的是表对应的POJO的名字。并且需要给起别名

  3. select后面千万不要使用 * 号，使用别名代替

3.6.2、使用参数占位符

上面使用的数字占位符，参数多了非常容易搞错。可以使用参数占位符代替。但是需要在方法上使用@Param注解声明参数占位符名称。

    @Query("select u from User u where u.username = :username and u.password = :password")
    public User findUserByNameAndPwd(String username , String password);

注意：

参数占位符需要还是用：号，后面跟着参数的名称。

有时我们希望真正书写的是SQL语句，而不是上面这种写法。其实严格意义上来讲不算合法的SQL。

    @Query(value="select * from tb_user where id = ?1 and age = ?2" , nativeQuery = true)
    public User findUserByIdAndAge(Integer id , Integer age);

3.7、@Modifying注解

使用SpringData JPA的时候对数据库进行查询之外，还有增删改的操作。一般对数据库的增删改的操作，都会配合事务一起操作。

如果需要自定义SQL，还是增删改的操作，需要两个注解一起使用。

    @Modifying   
    @Query("update User set username=:name where id =:id")
    public Integer updateUserName(String name , Integer id);

说明：@Modifying 注解来说明是对数据库进行非查询操作

    public Integer updateUserName(String username , Integer id){
        return this.userRepository.updateUserName(username , id);
    }

执行程序发生下面的异常：

上面的异常是因为SpringData JPA规定，在对数据库进行增删改的时候，必须放在事务中。

    @Transactional
    public Integer updateUserName(String username , Integer id){
        return this.userRepository.updateUserName(username , id);
    }

4、多表的操作

多表的操作：一对一、一对多、多对多

4.1、一对一查询操作

假设一对一的场景：用户和住址，一般一个用户只能拥有一个地址（户籍归属地）。

CREATE TABLE tb_addr(
   id INT PRIMARY KEY AUTO_INCREMENT,
   address VARCHAR(100),
   uid INT 
)

SpringData JPA的一对一查询：提供@oneToOne注解，标注一对一的关系。同时还需要使用@JoinColumn注解声明关联关系。

 package com.qubo.pojo;
 ​
 import lombok.Data;
 ​
 import javax.persistence.*;
 ​
 @Data
 @Entity
 @Table(name="tb_addr")
 public class Address {
     @Id
     @GeneratedValue(strategy = GenerationType.IDENTITY)
     private Integer id;
     private String address;
     //private Integer uid;
     //  在一对一中，需要在某个pojo中添加另外一个实体的引用
     @OneToOne
     @JoinColumn(name="uid" , referencedColumnName = "id")
     private User user;
 }

说明：

  • @OneToOne ： 来指定当前pojo中的属性（实体引用）和另外类之间是一个一对一关系

  • @JoinColumn(name="uid" , referencedColumnName = "id") ： 一对一中的主外键关系。name属性书写的是外键列名，referencedColumnName属性的是外键引用的主键的列名。

还需要编写关于tb_addr 表查询的Repository接口：

 public interface AddressRepository extends JpaRepository<Address , Integer> {
 ​
 }

关于service类：

 @Service
 public class AddressService {
 ​
     @Autowired
     private AddressRepository addressRepository;
 ​
     public Address findAddrById(Integer id){
         Address address = this.addressRepository.findById(id).get();
         return address;
     }
 }

4.2、一对多的查询操作

假设一对多业务场景：一个用户可以编著多本书（作者和读书）。通过User对应的多个Book。

 CREATE TABLE tb_book(
   id INT PRIMARY KEY AUTO_INCREMENT,
   NAME VARCHAR(50),
   price DOUBLE,
   pages INT,
   uid INT
 )

最终的查询目标：通过用户的id查询用户的数据，同时还要找到对应的著作信息

一对多：需要在一的一方pojo中添加集合，关联多的一方的数据。

 // 多的一方的实体类
 @Data
 @Entity
 @Table(name = "tb_book")
 public class Book {
     @Id
     @GeneratedValue(strategy = GenerationType.IDENTITY)
     private Integer id;
     private String name;
     private Double price;
     private Integer uid;
 }
 @Data
 @Entity
 @Table(name="tb_user")
 public class User {
     @Id
     @GeneratedValue(strategy = GenerationType.IDENTITY)
     private Integer id;
     private String username;
     private String password;
     private Integer age;
     private Double salary;
     // 添加对应的多的一方的引用
     @OneToMany
     @JoinColumn(name="uid",referencedColumnName = "id")
     private List<Book> books;
 }

编写Repository接口

 public interface BookRepository extends JpaRepository<Book , Integer> {
     // 需要提供一个方法，可以通过外键查询book数据
     public Book findByUid(Integer uid);
 }

4.3、多对多查询

假设业务场景：订单和商品关系，一个订单中可以拥有多个商品，某类商品可以被添加到不同的订单中。

 CREATE TABLE tb_order(
   id INT PRIMARY KEY AUTO_INCREMENT,
   uid INT,
   order_number VARCHAR(100)
 );
 ​
 CREATE TABLE tb_item(
   id INT PRIMARY KEY AUTO_INCREMENT,
   item_name VARCHAR(100),
   item_price DOUBLE,
   item_detail VARCHAR(200)
 )
 ​
 CREATE TABLE tb_order_detail(
   id INT PRIMARY KEY AUTO_INCREMENT,
   order_id INT,
   item_id INT,
   total_price DOUBLE
 )
 @Entity
 @Data
 @Table(name="tb_order")
 public class Order {
     private Integer id;
     private Integer uid;
     private String orderNumber;
 ​
     @ManyToMany // 声明是多对多关系
     @JoinTable(
             name="tb_order_detail" ,  // 多对多的中间表的名称
             joinColumns = { @JoinColumn( name="order_id" ,referencedColumnName = "id")},
             inverseJoinColumns = { @JoinColumn( name="item_id" , referencedColumnName = "id") } )
     private List<Item> items;
 }
 ​
 @Entity
 @Table(name = "tb_item")
 public class Item {
     @Id
     @GeneratedValue(strategy = GenerationType.IDENTITY)
     @Getter@Setter
     private Integer id;
     @Getter@Setter
     private String itemName;
     @Getter@Setter
     private Double itemPrice;
     @Getter@Setter
     private String itemDetail;
     @ManyToMany(targetEntity = Order.class , mappedBy = "items")
     private List<Order> orders;
 }

 

 

 

 

 

 

QB哥
关注
专栏目录
Spring Data JPA简单使用
qq_43676207的博客
11-02 515
Spring Data Jpa 1、JPA简介 JPA的出现主要是为了简化持久层开发以及整合ORM技术，结束Hibernate、TopLink、JDO等ORM框架各自为营的局面。JPA是在吸收现有ORM框架的基础上发展而来，易于使用，伸缩性强。总的来说，JPA包括以下3方面的技术： ORM映射元数据： 支持XML和注解两种元数据的形式，元数据描述对象和表之间的映射关系 API： 操作实体对象来执行CRUD操作 查询语言： 通过面向对象而非面向数据库的查询语言（JPQL）查询数据，避免程序的SQL语句紧密耦
【原创】纯干货，Spring-data-jpa详解，全方位介绍。
weixin_33955681的博客
02-01 8055
本篇进行Spring-data-jpa的介绍，几乎涵盖该框架的所有方面，在日常的开发当中，基本上能满足所有需求。这里不讲解JPA和Spring-data-jpa单独使用，所有的内容都是在和Spring整合的环境中实现。如果需要了解该框架的入门，百度一下，很多入门的介绍。在这篇文章的接下来一篇，会有一个系列来讲解mybatis，这个系列从mybatis的入门开始，到基本使用，和spring整合，和第...
springdataJPA的使用
qq_43470725的博客
01-08 744
jpa
Spring Data JPA
最新发布
m0_73837751的博客
10-06 855
这个接口的定义是在数据持久层（DAO 层，Repository 层），主要用于自定义一些查询方法（这是这个接口最主要的作用）。接口内部可以通过命名规则定义自定义查询方法，以便在业务逻辑层调用。（1.3中的方法命名规则）。在 Spring Data JPA 中，你可以通过继承 CrudRepository或 JpaRepository接口来定义Repository，用于处理特定实体的 CRUD 操作。Spring 会自动生成这些接口中的方法实现。：这是最基本的接口，提供基本的增删改查操作，如save()
spring data jpa的使用
dongxing515的博客
07-15 339
Spring Data Jpa 简介 JPA JPA(Java Persistence API)意即Java持久化API，是Sun官方在JDK5.0后提出的Java持久化规范（JSR 338，这些接口所在包为javax.persistence，详细内容可参考https://github.com/javaee/jpa-spec） JPA的出现主要是为了简化持久层开发以及整合ORM技术，结束Hibernate、TopLink、JDO等ORM框架各自为营的局面。JPA是在吸收现有ORM框架的基础上发展而来，易于使
spring data jpa（一）
weixin_30399871的博客
01-09 371
第1章 Spring Data JPA的快速入门 1.1 需求说明 Spring Data JPA完成客户的基本CRUD操作 1.2 搭建Spring Data JPA的开发环境 1.2.1 引入Spring Data JPA的坐标 使用Spring Data JPA，需要整合Spring与Spring Data JPA，并且需要提供JPA的服务提供者...
第三章：SpringBoot使用SpringDataJPA完成CRUD
xs90xs的博客
07-14 594
SpringBoot使用SpringDataJPA完成CRUD
SpringBoot+SpringDataJpa+apache shiro+easyui+bootstrap开发的电影推酷网站
02-18
本系统采用企业级开发标准，使用SpringBoot架构，数据访问层采用Spring Data Jpa，业务控制层采用SpringMvc，安全框架采用Shiro，实现了完整权限系统，Controller方法采用shiro注解，来实现有效的权限控制；...
SpringBoot整合SpringDataJPA实战教程
"该资源是关于SpringDataJPA的PDF文档，主要讲解了SpringDataJPA的使用，包括与JDK8、MySQL6.0和SpringBoot2.1.13的集成，提供了数据库操作的各种示例。内容涵盖SpringDataJPA的介绍、SpringBoot如何整合SpringData...
基于springboot+thymeleaf+spring data jpa+druid+bootstrap+layui
03-26
【标题】"基于Springboot+Thymeleaf+Spring Data JPA+Druid+Bootstrap+Layui"的系统开发框架解析 在IT行业中，构建高效、易维护的Web应用程序是一项重要的任务。这个项目采用了一套强大的技术栈，集成了Spring Boot...
SpringBoot下SpringData JPA应用详解课程
本套课程基于 Spring Boot，假设学习者已经具备了基本的 Spring Boot 使用知识，重点在于理解并应用 SpringData JPA 来构建数据访问层。 知识点一：SpringData JPA 概述 SpringData JPA 是 Spring 社区提供的用于...
Spring Data JPA 的使用
weixin_45857926的博客
08-27 412
1. JPA是什么
Spring data JPA的使用
weixin_44342481的博客
08-10 569
依赖 <!-- JPA --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> </dependency> <!-- WEB --> <dependency> <groupId>o
Spring Data Jpa的使用
weixin_46529416的博客
01-07 4418
一.Spring Data Jpa 简介 JPA JPA(Java Persistence API)意即Java持久化API，是Sun官方在JDK5.0后提出的Java持久化规范（JSR 338，这些接口所在包为javax.persistence)。JPA的出现主要是为了简化持久层开发以及整合ORM技术，结束Hibernate、TopLink、JDO等ORM框架各自为营的局面。JPA是在吸收现有ORM框架的基础上发展而来，易于使用，伸缩性强。总的来说，JPA包括以下3方面的技术： ORM映射元数据： 支持
SpringBoot Data JPA 实战
热门推荐
架构之路
11-15 1万+
搭建项目1）https://start.spring.io/ 初始化SpringBoot项目2）导入项目到Eclipse中3）添加Maven依赖：MySQL的java驱动、druid数据源 <!-- MySQL的java驅動 --> <dependency> <groupId>mysql</groupId> <artifa
Spring Boot Data JPA
qq_43676248的博客
09-03 377
Spring Boot Data JPA Spring Boot Data 的核心接口 pom文件的配置 <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> </dependency&g
SpringDataJpa框架使用【超详细！】
HydeRobin的博客
02-15 2438
jpa 的全称是 Java Persistence API , 中文的字面意思就是 java 的持久层 API , jpa 就是定义了一系列标准，让实体类和数据库中的表建立一个对应的关系，当我们在使用 java 操作实体类的时候能达到操作数据库中表的效果(不用写sql ,就可以达到效果），jpa 的实现思想即是 ORM （Object Relation Mapping），对象关系映射，用于在关系型数据库和业务实体对象之间作一个映射。
SpringData JPA - ORM 框架下，打造高效数据访问层
CYK_byte的博客
05-03 1428
全英文名叫 Java Persistence API，就是 java 持久化 api ，是SUN公司推出的一套基于 ORM 的规范。ORM（Object Relational Mapping）表示对象关系映射. 简单来讲，通过 ORM，就可以把对象映射到关系型数据库中（为了不用 JDBC 那套方法来操作数据库）.
spring data jpa
Akiler的博客
06-16 560
spring data妈妈再也不用担心我加班
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

QB哥

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值