Spring Data Jpa

最近博主越来越懒了，深知这样不行。还是决定努力奋斗，如此一来，就有了一下一波复习

演示代码都基于Spring Boot + Spring Data JPA

传送门: 博主的测试代码

------------------------------------------------------------------------------------------------------------------------------

什么是Spring Data JPA?

Spring Data 是Spring提供的操作数据的框架在Spring data JPA是Spring data的一个模块,通过Spring data 基于jpa标准操作数据的模块。

Spring Data的核心能力，就是基于JPA操作数据，并且可以简化操作持久层的代码。

Spring Data JPA提供的核心接口

前提数据:

  1. -- MySQL dump 10.13  Distrib 5.6.16, for debian-linux-gnu (x86_64)
  2. --
  3. -- Host: localhost    Database: amber
  4. -- ------------------------------------------------------
  5. -- Server version    5.6.16-1~exp1
  6.  
  7. /*!40101 SET @OLD_CHARACTER_SET_CLIENT=@@CHARACTER_SET_CLIENT */;
  8. /*!40101 SET @OLD_CHARACTER_SET_RESULTS=@@CHARACTER_SET_RESULTS */;
  9. /*!40101 SET @OLD_COLLATION_CONNECTION=@@COLLATION_CONNECTION */;
  10. /*!40101 SET NAMES utf8 */;
  11. /*!40103 SET @OLD_TIME_ZONE=@@TIME_ZONE */;
  12. /*!40103 SET TIME_ZONE='+00:00' */;
  13. /*!40014 SET @OLD_UNIQUE_CHECKS=@@UNIQUE_CHECKS, UNIQUE_CHECKS=0 */;
  14. /*!40014 SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0 */;
  15. /*!40101 SET @OLD_SQL_MODE=@@SQL_MODE, SQL_MODE='NO_AUTO_VALUE_ON_ZERO' */;
  16. /*!40111 SET @OLD_SQL_NOTES=@@SQL_NOTES, SQL_NOTES=0 */;
  17.  
  18. --
  19. -- Table structure for table `table_user`
  20. --
  21.  
  22. DROP TABLE IF EXISTS `table_user`;
  23. /*!40101 SET @saved_cs_client     = @@character_set_client */;
  24. /*!40101 SET character_set_client = utf8 */;
  25. CREATE TABLE `table_user` (
  26.   `id` int(11) NOT NULL DEFAULT '',
  27.   `name` varchar(255) DEFAULT NULL,
  28.   `password` varchar(255) DEFAULT NULL,
  29.   `address` varchar(255) DEFAULT NULL,
  30.   `age` int(11) DEFAULT NULL,
  31.   PRIMARY KEY (`id`)
  32. ) ENGINE=MyISAM DEFAULT CHARSET=latin1;
  33. /*!40101 SET character_set_client = @saved_cs_client */;
  34.  
  35. --
  36. -- Dumping data for table `table_user`
  37. --
  38.  
  39. LOCK TABLES `table_user` WRITE;
  40. /*!40000 ALTER TABLE `table_user` DISABLE KEYS */;
  41. INSERT INTO `table_user` VALUES (4,'tony',NULL,'shanghai',18),(5,'amber',NULL,'shanghai',18),(2,'amber1',NULL,'shanghai',18),(3,'tony',NULL,'shanghai',18),(0,'amber1',NULL,'shanghai',18),(6,'amber',NULL,'shanghai',18);
  42. /*!40000 ALTER TABLE `table_user` ENABLE KEYS */;
  43. UNLOCK TABLES;
  44. /*!40103 SET TIME_ZONE=@OLD_TIME_ZONE */;
  45.  
  46. /*!40101 SET SQL_MODE=@OLD_SQL_MODE */;
  47. /*!40014 SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS */;
  48. /*!40014 SET UNIQUE_CHECKS=@OLD_UNIQUE_CHECKS */;
  49. /*!40101 SET CHARACTER_SET_CLIENT=@OLD_CHARACTER_SET_CLIENT */;
  50. /*!40101 SET CHARACTER_SET_RESULTS=@OLD_CHARACTER_SET_RESULTS */;
  51. /*!40101 SET COLLATION_CONNECTION=@OLD_COLLATION_CONNECTION */;
  52. /*!40111 SET SQL_NOTES=@OLD_SQL_NOTES */;
  53.  
  54. -- Dump completed on 2019-01-13 13:43:57

SQL

  1. package com.amber.pojo;
  2.  
  3. import lombok.Data;
  4. import javax.persistence.*;
  5.  
  6. @Entity
  7. @Table(name = "table_user")
  8. @Data
  9. public class User {
  10.  
  11.     @Id
  12.     @GeneratedValue
  13.     private Integer id;
  14.     private String name;
  15.     private Integer age;
  16.     private String address;
  17.  
  18. }

User

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <modelVersion>4.0.0</modelVersion>
  6.  
  7.     <groupId>groupId</groupId>
  8.     <artifactId>SpringBoot-JPA</artifactId>
  9.     <version>1.0-SNAPSHOT</version>
  10.  
  11.     <properties>
  12.         <java.version>1.8</java.version>
  13.         <lombok.version>1.16.20</lombok.version>
  14.     </properties>
  15.     <parent>
  16.         <groupId>org.springframework.boot</groupId>
  17.         <artifactId>spring-boot-starter-parent</artifactId>
  18.         <version>2.0.5.RELEASE</version>
  19.         <relativePath/>
  20.     </parent>
  21.  
  22.     <dependencies>
  23.         <dependency>
  24.             <groupId>org.springframework.boot</groupId>
  25.             <artifactId>spring-boot-starter-web</artifactId>
  26.         </dependency>
  27.         <dependency>
  28.             <groupId>org.springframework.boot</groupId>
  29.             <artifactId>spring-boot-starter-data-jpa</artifactId>
  30.         </dependency>
  31.  
  32.         <dependency>
  33.             <groupId>org.springframework.boot</groupId>
  34.             <artifactId>spring-boot-starter-test</artifactId>
  35.         </dependency>
  36.  
  37.         <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
  38.         <dependency>
  39.             <groupId>mysql</groupId>
  40.             <artifactId>mysql-connector-java</artifactId>
  41.             <version>6.0.5</version>
  42.         </dependency>
  43.  
  44.         <dependency>
  45.             <groupId>org.springframework.boot</groupId>
  46.             <artifactId>spring-boot-devtools</artifactId>
  47.             <optional>true</optional>
  48.         </dependency>
  49.  
  50.         <!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
  51.         <dependency>
  52.             <groupId>com.alibaba</groupId>
  53.             <artifactId>druid</artifactId>
  54.             <version>1.1.8</version>
  55.         </dependency>
  56.  
  57.         <!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
  58.         <dependency>
  59.             <groupId>org.projectlombok</groupId>
  60.             <artifactId>lombok</artifactId>
  61.             <version>${lombok.version}</version>
  62.             <scope>provided</scope>
  63.         </dependency>
  64.     </dependencies>
  65. </project>

pom.xml

Repository:

  1. @org.springframework.stereotype.Repository
  2. public interface UserRepository  extends Repository<User, Integer> {
  3. }
  • 提供了方法名成查询方式: 

　　　　方法的名称要遵循 findBy + 属性名（首字母大写） + 查询条件(首字母大写 Is Equals)

　　　　findByNameLike(String name)

　　　　findByName(String name)

　　　　findByNameAndAge(String name, Integer age)

　　　　findByNameOrAddress(String name) 等...

  • 基于@Query注解的查询和更新
  1.  /**
  2.      * SQL nativeQuery的值是true 执行的时候不用再转化
  3.      * @param name
  4.      * @return
  5.      */
  6.     @Query(value = "SELECT * FROM table_user WHERE name = ?1", nativeQuery = true)
  7.     List<User> findByUsernameSQL(String name);

　　//基于HQL

  1.     /**
  2.      * 基于HQL
  3.      * @param name
  4.      * @param id
  5.      * @return
  6.      */
  7.     @Query("Update User set name = ?1 WHERE id = ?2")
  8.     @Modifying
  9.     int updateNameAndId(String name, Integer id);

CrudReposiroty ： 继承了Repository

  1. /*
  2.  * Copyright 2008-2017 the original author or authors.
  3.  *
  4.  * Licensed under the Apache License, Version 2.0 (the "License");
  5.  * you may not use this file except in compliance with the License.
  6.  * You may obtain a copy of the License at
  7.  *
  8.  *      http://www.apache.org/licenses/LICENSE-2.0
  9.  *
  10.  * Unless required by applicable law or agreed to in writing, software
  11.  * distributed under the License is distributed on an "AS IS" BASIS,
  12.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13.  * See the License for the specific language governing permissions and
  14.  * limitations under the License.
  15.  */
  16. package org.springframework.data.repository;
  17.  
  18. import java.util.Optional;
  19.  
  20. /**
  21.  * Interface for generic CRUD operations on a repository for a specific type.
  22.  *
  23.  * @author Oliver Gierke
  24.  * @author Eberhard Wolff
  25.  */
  26. @NoRepositoryBean
  27. public interface CrudRepository<T, ID> extends Repository<T, ID> {
  28.  
  29.     /**
  30.      * Saves a given entity. Use the returned instance for further operations as the save operation might have changed the
  31.      * entity instance completely.
  32.      *
  33.      * @param entity must not be {@literal null}.
  34.      * @return the saved entity will never be {@literal null}.
  35.      */
  36.     <S extends T> S save(S entity);
  37.  
  38.     /**
  39.      * Saves all given entities.
  40.      *
  41.      * @param entities must not be {@literal null}.
  42.      * @return the saved entities will never be {@literal null}.
  43.      * @throws IllegalArgumentException in case the given entity is {@literal null}.
  44.      */
  45.     <S extends T> Iterable<S> saveAll(Iterable<S> entities);
  46.  
  47.     /**
  48.      * Retrieves an entity by its id.
  49.      *
  50.      * @param id must not be {@literal null}.
  51.      * @return the entity with the given id or {@literal Optional#empty()} if none found
  52.      * @throws IllegalArgumentException if {@code id} is {@literal null}.
  53.      */
  54.     Optional<T> findById(ID id);
  55.  
  56.     /**
  57.      * Returns whether an entity with the given id exists.
  58.      *
  59.      * @param id must not be {@literal null}.
  60.      * @return {@literal true} if an entity with the given id exists, {@literal false} otherwise.
  61.      * @throws IllegalArgumentException if {@code id} is {@literal null}.
  62.      */
  63.     boolean existsById(ID id);
  64.  
  65.     /**
  66.      * Returns all instances of the type.
  67.      *
  68.      * @return all entities
  69.      */
  70.     Iterable<T> findAll();
  71.  
  72.     /**
  73.      * Returns all instances of the type with the given IDs.
  74.      *
  75.      * @param ids
  76.      * @return
  77.      */
  78.     Iterable<T> findAllById(Iterable<ID> ids);
  79.  
  80.     /**
  81.      * Returns the number of entities available.
  82.      *
  83.      * @return the number of entities
  84.      */
  85.     long count();
  86.  
  87.     /**
  88.      * Deletes the entity with the given id.
  89.      *
  90.      * @param id must not be {@literal null}.
  91.      * @throws IllegalArgumentException in case the given {@code id} is {@literal null}
  92.      */
  93.     void deleteById(ID id);
  94.  
  95.     /**
  96.      * Deletes a given entity.
  97.      *
  98.      * @param entity
  99.      * @throws IllegalArgumentException in case the given entity is {@literal null}.
  100.      */
  101.     void delete(T entity);
  102.  
  103.     /**
  104.      * Deletes the given entities.
  105.      *
  106.      * @param entities
  107.      * @throws IllegalArgumentException in case the given {@link Iterable} is {@literal null}.
  108.      */
  109.     void deleteAll(Iterable<? extends T> entities);
  110.  
  111.     /**
  112.      * Deletes all entities managed by the repository.
  113.      */
  114.     void deleteAll();
  115. }

CrudRepository

Crud主要是添加了对数据的增删改查的方法

PagingAndSortingRepository： 继承了CrudRepository

  1. /*
  2.  * Copyright 2008-2010 the original author or authors.
  3.  *
  4.  * Licensed under the Apache License, Version 2.0 (the "License");
  5.  * you may not use this file except in compliance with the License.
  6.  * You may obtain a copy of the License at
  7.  *
  8.  *      http://www.apache.org/licenses/LICENSE-2.0
  9.  *
  10.  * Unless required by applicable law or agreed to in writing, software
  11.  * distributed under the License is distributed on an "AS IS" BASIS,
  12.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13.  * See the License for the specific language governing permissions and
  14.  * limitations under the License.
  15.  */
  16. package org.springframework.data.repository;
  17.  
  18. import org.springframework.data.domain.Page;
  19. import org.springframework.data.domain.Pageable;
  20. import org.springframework.data.domain.Sort;
  21.  
  22. /**
  23.  * Extension of {@link CrudRepository} to provide additional methods to retrieve entities using the pagination and
  24.  * sorting abstraction.
  25.  *
  26.  * @author Oliver Gierke
  27.  * @see Sort
  28.  * @see Pageable
  29.  * @see Page
  30.  */
  31. @NoRepositoryBean
  32. public interface PagingAndSortingRepository<T, ID> extends CrudRepository<T, ID> {
  33.  
  34.     /**
  35.      * Returns all entities sorted by the given options.
  36.      *
  37.      * @param sort
  38.      * @return all entities sorted by the given options
  39.      */
  40.     Iterable<T> findAll(Sort sort);
  41.  
  42.     /**
  43.      * Returns a {@link Page} of entities meeting the paging restriction provided in the {@code Pageable} object.
  44.      *
  45.      * @param pageable
  46.      * @return a page of entities
  47.      */
  48.     Page<T> findAll(Pageable pageable);
  49. }

PagingAndSortingRepository

  1. /**
  2.  * 继承了Repository,缺点只能对所有的数据进行排序或者分页
  3.  */
  4. @Repository
  5. public interface UserPagingAndSortingReposiroty extends PagingAndSortingRepository<User, Integer> {
  6. }
  1. package com.amber;
  2.  
  3. import com.amber.pojo.User;
  4. import com.amber.repository.UserPagingAndSortingReposiroty;
  5. import org.junit.Test;
  6. import org.junit.runner.RunWith;
  7. import org.springframework.beans.factory.annotation.Autowired;
  8. import org.springframework.boot.test.context.SpringBootTest;
  9. import org.springframework.data.domain.Page;
  10. import org.springframework.data.domain.PageRequest;
  11. import org.springframework.data.domain.Pageable;
  12. import org.springframework.data.domain.Sort;
  13. import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
  14.  
  15. import java.util.List;
  16.  
  17. @RunWith(SpringJUnit4ClassRunner.class)
  18. @SpringBootTest(classes = JPAApplication.class)
  19. public class UserPagingAndSortingReposirotyTest {
  20.  
  21.     @Autowired
  22.     UserPagingAndSortingReposiroty userPagingAndSortingReposiroty;
  23.  
  24.     /**
  25.      * 排序
  26.      */
  27.     @Test
  28.     public void TestSort(){
  29.         //定义排序规则
  30.         Sort.Order order = new Sort.Order(Sort.Direction.DESC, "name");
  31.         Sort.Order order1 = new Sort.Order(Sort.Direction.DESC, "id");
  32.         //Sort
  33.         Sort sort = new Sort(order, order1);
  34.         List<User> users = (List<User>)userPagingAndSortingReposiroty.findAll(sort);
  35.         System.out.println(users);
  36.     }
  37.  
  38.     /**
  39.      * 分页Pageable封装了分页的参数，当前页，每一页显示的条数，注意当前页是从0开始的
  40.      */
  41.     @Test
  42.     public void TestPaging(){
  43.         //Pageable是个接口
  44.         Pageable pageable = new PageRequest(0, 10);
  45.         //返回Page对象
  46.         Page<User> uses = userPagingAndSortingReposiroty.findAll(pageable);
  47.         System.out.println(uses.getTotalElements());
  48.         System.out.println(uses.getTotalPages());
  49.         System.out.println(uses.getNumberOfElements());
  50.     }
  51.  
  52.     /**
  53.      * 分页 + 排序
  54.      */
  55.     @Test
  56.     public void TestPagingAndSort(){
  57.         //定义排序规则
  58.         Sort.Order order = new Sort.Order(Sort.Direction.DESC, "name");
  59.         Sort.Order order1 = new Sort.Order(Sort.Direction.DESC, "id");
  60.         //Sort
  61.         Sort sort = new Sort(order, order1);
  62.         //Pageable是个接口
  63.         Pageable pageable = new PageRequest(0, 10, sort);
  64.         //返回Page对象
  65.         Page<User> uses = userPagingAndSortingReposiroty.findAll(pageable);
  66.         System.out.println(uses.getTotalElements());
  67.         System.out.println(uses.getTotalPages());
  68.         System.out.println(uses.getNumberOfElements());
  69.     }
  70.  
  71. }

UserPagingAndSortingReposirotyTest

JPARepository: 继承了PagingAndSortingRepository接口

在开发中常用JPARepository

优点: 对继承父接口中方法的返回值进行了适配,因为在父类接口中通常都返回迭代器，需要我们自己进行强制类型转化。而在JpaRepository中，直接返回了List

  1. //
  2. // Source code recreated from a .class file by IntelliJ IDEA
  3. // (powered by Fernflower decompiler)
  4. //
  5.  
  6. package org.springframework.data.jpa.repository;
  7.  
  8. import java.util.List;
  9. import org.springframework.data.domain.Example;
  10. import org.springframework.data.domain.Sort;
  11. import org.springframework.data.repository.NoRepositoryBean;
  12. import org.springframework.data.repository.PagingAndSortingRepository;
  13. import org.springframework.data.repository.query.QueryByExampleExecutor;
  14.  
  15. @NoRepositoryBean
  16. public interface JpaRepository<T, ID> extends PagingAndSortingRepository<T, ID>, QueryByExampleExecutor<T> {
  17.     List<T> findAll();
  18.  
  19.     List<T> findAll(Sort var1);
  20.  
  21.     List<T> findAllById(Iterable<ID> var1);
  22.  
  23.     <S extends T> List<S> saveAll(Iterable<S> var1);
  24.  
  25.     void flush();
  26.  
  27.     <S extends T> S saveAndFlush(S var1);
  28.  
  29.     void deleteInBatch(Iterable<T> var1);
  30.  
  31.     void deleteAllInBatch();
  32.  
  33.     T getOne(ID var1);
  34.  
  35.     <S extends T> List<S> findAll(Example<S> var1);
  36.  
  37.     <S extends T> List<S> findAll(Example<S> var1, Sort var2);
  38. }

JpaRepository

JpaSpecificationExecutor: 这个接口单独存在，没有继承以上说的接口

主要提供了多条件查询的支持，并且可以在查询中添加分页和排序。

因为这个接口单独存在，因此需要配合以上说的接口使用，如：

  1. /**
  2.  * JpaSpecificationExecutor是单独存在的，需要配合这JpaRepository一起使用
  3.  */
  4. @Repository
  5. public interface UserJpaSpecificationExecutor extends JpaSpecificationExecutor<User>, JpaRepository<User, Integer> {
  6. }

  1. package com.amber;
  2.  
  3. import com.amber.pojo.User;
  4. import com.amber.repository.UserJpaSpecificationExecutor;
  5. import org.junit.Test;
  6. import org.junit.runner.RunWith;
  7. import org.springframework.beans.factory.annotation.Autowired;
  8. import org.springframework.boot.test.context.SpringBootTest;
  9. import org.springframework.data.jpa.domain.Specification;
  10. import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
  11.  
  12. import javax.persistence.criteria.CriteriaBuilder;
  13. import javax.persistence.criteria.CriteriaQuery;
  14. import javax.persistence.criteria.Predicate;
  15. import javax.persistence.criteria.Root;
  16. import java.util.ArrayList;
  17. import java.util.List;
  18.  
  19. @RunWith(SpringJUnit4ClassRunner.class)
  20. @SpringBootTest(classes = JPAApplication.class)
  21. public class UserJpaSecificationExecutorTest {
  22.  
  23.     @Autowired
  24.     UserJpaSpecificationExecutor userJpaSpecificationExecutor;
  25.  
  26.     /**
  27.      * 多条件查询的另外一种写法
  28.      */
  29.     @Test
  30.     public void testUser2(){
  31.         //Specification是个接口，封装了查询信息
  32.         Specification<User> specification = new Specification<User>() {
  33.             /**
  34.              * Predicate封装了单个查询条件
  35.              * @param root 对查询对象属性的封装，比如我们这里是查询User,因此root可以看成是User
  36.              * @param query CriteriaQuery封装了查询中的各部分信息， Select from order
  37.              * @param cb CB查询条件的构造器
  38.              * @return
  39.              */
  40.             @Override
  41.             public Predicate toPredicate(Root<User> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
  42.                 Predicate p1 = cb.equal(root.get("name"), "amber");
  43.                 Predicate p2 = cb.equal(root.get("age"), "18");
  44.                 return cb.and(p1,p2);
  45.             }
  46.         };
  47.         List<User> users = userJpaSpecificationExecutor.findAll(specification);
  48.         System.out.println(users);
  49.     }
  50.  
  51.     /**
  52.      * 多条件查询
  53.      */
  54.     @Test
  55.     public void testUser1(){
  56.         //Specification是个接口，封装了查询信息
  57.         Specification<User> specification = new Specification<User>() {
  58.             /**
  59.              * Predicate封装了单个查询条件
  60.              * @param root 对查询对象属性的封装，比如我们这里是查询User,因此root可以看成是User
  61.              * @param query CriteriaQuery封装了查询中的各部分信息， Select from order
  62.              * @param cb CB查询条件的构造器
  63.              * @return
  64.              */
  65.             @Override
  66.             public Predicate toPredicate(Root<User> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
  67.                 List<Predicate> predicates = new ArrayList<>();
  68.                 Predicate p1 = cb.equal(root.get("name"), "amber");
  69.                 Predicate p2 = cb.equal(root.get("age"), "18");
  70.                 predicates.add(p1);
  71.                 predicates.add(p2);
  72.                 Predicate[] predicateArr = new Predicate[predicates.size()];
  73.                 return cb.and(predicates.toArray(predicateArr));
  74.             }
  75.         };
  76.         List<User> users = userJpaSpecificationExecutor.findAll(specification);
  77.         System.out.println(users);
  78.     }
  79.  
  80.     /**
  81.      * 单条件查询
  82.      */
  83.     @Test
  84.     public void testUser(){
  85.         //Specification是个接口，封装了查询信息
  86.         Specification<User> specification = new Specification<User>() {
  87.             /**
  88.              * Predicate封装了单个查询条件
  89.              * @param root 对查询对象属性的封装，比如我们这里是查询User,因此root可以看成是User
  90.              * @param query CriteriaQuery封装了查询中的各部分信息， Select from order
  91.              * @param cb CB查询条件的构造器
  92.              * @return
  93.              */
  94.             @Override
  95.             public Predicate toPredicate(Root<User> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
  96.  
  97.                 Predicate p1 = cb.equal(root.get("name"), "amber");
  98.                 return p1;
  99.             }
  100.         };
  101.         List<User> users = userJpaSpecificationExecutor.findAll(specification);
  102.         System.out.println(users);
  103.     }
  104. }

总结:

　　Spring Data Jpa中一共提供了

  • Repository：

    • 　　提供了findBy + 属性方法
    • 　　@Query 
      • 　　HQL： nativeQuery 默认false
      • 　　SQL: nativeQuery 默认true
        • 更新的时候，需要配合@Modifying使用
  • CurdRepository:
    • 继承了Repository 主要提供了对数据的增删改查

    • PagingAndSortRepository:

    • 继承了CrudRepository 提供了对数据的分页和排序，缺点是只能对所有的数据进行分页或者排序，不能做条件判断

    JpaRepository： 继承了PagingAndSortRepository

    • 开发中经常使用的接口，主要继承了PagingAndSortRepository，对返回值类型做了适配
  • JpaSpecificationExecutor
    • 提供多条件查询

Spring Data - Spring Data JPA 提供的各种Repository接口的更多相关文章

  1. Spring Data JPA 提供的各种Repository接口作用

    各种Repository接口继承关系: Repository : public interface UserRepository extends Repository<User, Integer ...

  2. 一步步学习 Spring Data 系列之JPA（一）

    引入: Spring Data是SpringSource基金会下的一个用于简化数据库访问,并支持云服务的开源框架.其主要目标是使得数据库的访问变得方便快捷,并支持map-reduce框架和云计算数据服 ...

  3. 一步步学习 Spring Data 系列之JPA（二）

    继上一篇文章对Spring Data JPA更深( )一步剖析. 上一篇只是简单的介绍了Spring Data JPA的简单使用,而往往在项目中这一点功能并不能满足我们的需求.这是当然的,在业务中查询 ...

  4. JPA && Spring Data && Spring Data JPA

    1.JPA  Java Persistence API,用于对象持久化的一组API,JPA本身是一组规范,让开发者用同一种方式访问不同的ORM框架.其实也就是java实体对象和关系型数据库建立起映射关 ...

  5. 【Spring】Spring Data JPA

    原始JDBC操作数据库 传统JDBC方式实现数据库操作 package com.imooc.util; import java.io.InputStream; import java.sql.*; i ...

  6. Spring Data JPA 梳理 - JPA与“Spring、Spring Data JPA”的关系

    JPA其实也就是java实体对象和关系型数据库建立起映射关系,通过面向对象编程的思想操作关系型数据库的规范. Spring 框架对 JPA 提供的支持主要体现在如下几个方面: 首先,它使得 JPA 配 ...

  7. java（样品集成框架spring、spring mvc、spring data jpa、hibernate）

    这是你自己的参考springside集成框架的开源项目.主要的整合spring.spring mvc.spring data jpa.hibernate几个框架,对于这些框架中仍然感觉更舒适sprin ...

  8. Spring+SpringMVC+Spring Data JPA完美整合

    使用Maven实现SSS框架的整合. 方便记录,专门建了一个pom项目用来整合SSS框架所用的jar包 1.POM项目,作为父级项目,记录整个整合中的依赖jar包pom文件 <project x ...

  9. spring mvc Spring Data Redis RedisTemplate [转]

    http://maven.springframework.org/release/org/springframework/data/spring-data-redis/(spring-data包下载) ...

随机推荐

  1. 【linux】【ELK】利用elasticproxy对elasticsearch进行二次排序

    做过elk的人应该了解kibana排序至支持到秒级别,但同一秒内出现多个日志的时候那么kibana展示的日志就会混轮,加上该代理可以解决该问题 # 拉取elasticproxy镜像 [root@loc ...

  2. linux使用命令上传下载文件 -- lrzsz

    之前都是用Xftp工具在本地和linux系统之间上传下载文件,最近觉得麻烦,因为平时用Xshell连接,要传输文件的时候还要额外使用别的工具,下面是lrzsz的安装和简单的使用过程: 详细的使用可以s ...

  3. JSP常规内容

    1.forword和redirect的区别? forword是服务器请求资源,服务器直接读取URL,把目标地址URL响应读取出来,然后再把这些内容发送给浏览器.(特点是url和request sess ...

  4. 关于WinForm TreeView的分享~

    最近在写个测试demo的时候使用到WinForm TreeView,已经好久没接触了,有些生疏,所以还是记录一下遇到的一些问题. 1.如果动态绑定TreeView,这个功能一般会在数据量不确定,需要去 ...

  5. 品Spring：SpringBoot发起bean定义注册的“二次攻坚战”

    上一篇文章整体非常轻松,因为在容器启动前,只注册了一个bean定义,就是SpringBoot的主类. OK,今天接着从容器的启动入手,找出剩余所有的bean定义的注册过程. 具体细节肯定会颇为复杂,同 ...

  6. 品Spring：bean工厂后处理器的调用规则

    上一篇文章介绍了对@Configuration类的处理逻辑,这些逻辑都写在ConfigurationClassPostProcessor类中. 这个类不仅是一个“bean工厂后处理器”,还是一个“be ...

  7. C#实现请求唯一性校验支持高并发

    使用场景描述: 网络请求中经常会遇到发送的请求,服务端响应是成功的,但是返回的时候出现网络故障,导致客户端无法接收到请求结果,那么客户端程序可能认为判断为网络故障,而重复发送同一个请求.当然如果接口中 ...

  8. UVA12983 The Battle of Chibi

    第一眼能看出来是个dp O($n^3$) 暴力应该很好想 dp[i][j] = $\sum_{k=1}^i [a[k] < a[i]] *dp[k][j-1]$ 发现dp[i][j] 为前面小于 ...

  9. useradd、id、userdel、usermod、chsh、passwd、pwck

    1.useradd [-cdefgGmkMsu] 用户名称 用来添加用户 -c “备注“:加上备注文字 -d 路径:指定家目录 -e 有效期限:指定帐号的有效期限: -f 缓冲天数:指定在密码过期后多 ...

  10. kotlin系列文章 --- 1.初识kotlin

    简介 Kotlin 是一种在 Java 虚拟机上运行的静态类型编程语言,由Jetbrains设计开发,现在是Android官方开发语言,和Java具有互操作性,可以共存. 为什么选择kotlin? 简 ...