SpringDataJPA（一）SpringDataJPA的简单使用

源码

GitHub： https://github.com/291685399/springboot-learning/tree/master/springboot-springdatajpa01

SpringDataJPA是什么？

SpringDataJPA是Spring提供的持久层的解决方案，Spring Data JPA旨在通过减少实际需要的工作量来显着改善数据访问层的实现

SpringDataJPA、Mybatis和Hibernate之间的关系

在讲三者的关系之前，先说一下JPA。JPA是一种Java规范，是ORM框架的标准。而ORM的思想是在应用程序和JDBC API中引入一个中间层用于解决数据库字段与对象之间的对应。

关系：
1、 三者都是持久层框架
2、 SpringDataJPA和Hibernate是JPA规范的实现，都是ORM框架，Mybatis是半ORM框架
3、 SpringDataJPA和Hibernate中都有默认的方法实现，直接调用即可操作数据库，而Mybatis则需要配置xml文件，在开发量上更大。虽然在Mybatis之前出现了TkMybatis和Mybatis-Plus等框架，其主要目的都是简化Mybatis的开发量，其中都提供了增删改查的方法。

简单使用SpringDataJPA

pom.xml：

<dependencies>
    <!-- springboot -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>

    <!-- springdatajpa -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>

    <!-- mysql -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <scope>runtime</scope>
    </dependency>

    <!-- lombok -->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
</dependencies>

application.properties：

# datasource
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/springboot-springdatajpa01?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8&useSSL=true
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.username=root
spring.datasource.password=root
# springdatajpa
#打印出自动生产的SQL，方便调试的时候查看
spring.jpa.show-sql=true
#更新数据库表结构
spring.jpa.hibernate.ddl-auto=update
#对打印的sql进行格式化，方便查看
spring.jpa.properties.hibernate.format_sql=true
spring.jpa.properties.hibernate.use_sql_comments=true
#指定生成表名的存储引擎为InneoDB
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL5InnoDBDialect

User：

@Entity
@Data
public class User {
    @Id
    @GeneratedValue
    private Long id;
    private String name;
    private Integer age;
    private String sex;
    private String address;
}

• 继承CrudRepository

UserCrudRepository：

public interface UserCrudRepository extends CrudRepository<User, Long> {
}

UserCrudRepositoryTests：

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserCrudRepositoryTests {

    @Autowired
    private UserCrudRepository userCrudRepository;

    /**
     * 新增
     */
    @Test
    public void add() {
        User user = new User();
        user.setName("ljk2");
        user.setSex("1");
        user.setAge(18);
        user.setAddress("beijing");
        User result = userCrudRepository.save(user);
        Assert.assertNotNull(result);
    }

    /**
     * 修改
     */
    @Test
    public void edit() {
        User user = new User();
        user.setId(1l);
        user.setName("ljk2edit");
        user.setSex("1");
        user.setAge(18);
        user.setAddress("beijing");
        User result = userCrudRepository.save(user);
        Assert.assertNotNull(result);
    }

    /**
     * 根据id查询
     */
    @Test
    public void findById() {
        Optional<User> userOptional = userCrudRepository.findById(1L);
        User result = userOptional.get();
        System.out.println(result);
    }

    /**
     * 查询所有
     */
    @Test
    public void findAll() {
        List<User> userList = (List<User>) userCrudRepository.findAll();
        System.out.println(userList);
    }

    /**
     * 计算总数
     */
    @Test
    public void count() {
        long count = userCrudRepository.count();
        System.out.println(count);
    }

}

• 继承PagingAndSortingRepository

UserPageRepository：

/**
 * 他是具有分页和排序的功能 同时继承了 CrudRepository
 */
public interface UserPageRepository extends PagingAndSortingRepository<User,Long> {
}

UserPageRepositoryTests：

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserPageRepositoryTests {

    @Autowired
    private UserPageRepository userPageRepository;

    /**
     * 排序查询
     */
    @Test
    public void findAllBySort() {
        List<User> userList = (List<User>) userPageRepository.findAll(new Sort(Sort.Direction.ASC, "age"));
        System.out.println(userList.size());
        System.out.println(userList);
    }

    /**
     * 分页查询
     */
    @Test
    public void findAllByPageable() {
        Page<User> userPage = userPageRepository.findAll(new PageRequest(0, 20));
        userPage.getNumber();//页数
        userPage.getContent();//分页的数据
        userPage.getTotalPages();//总共的页数
        System.out.println("number:" + userPage.getNumber()
                + "Countet" + userPage.getContent().size()
                + "TotalPages" + userPage.getTotalPages());
    }

}

• 继承JpaRepository

UserJpaRepository：

/**
 * 不仅继承了 PagingAndSortingRepository 同时继承了 QueryByExampleExecutor（示例匹配器）
 */
public interface UserJpaRepository extends JpaRepository<User, Long> {
}

UserJpaRepositoryTests：

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserJpaRepositoryTests {

    @Autowired
    private UserJpaRepository userJpaRepository;

    /**
     * 执行秒数：49422 49145
     * 批量插入数据
     */
    @Test
    public void BatchSave() {
        long startTime = System.currentTimeMillis();
        List<User> list = new ArrayList<User>();
        for (int i = 0; i < 60000; i++) {
            User user = new User();
            user.setName("ljk" + i);
            user.setAge(i);
            user.setAddress("address" + i);
            list.add(user);
            if (i % 100 == 0) {
                userJpaRepository.saveAll(list);
                list.clear();
            }
        }
        long endTime = System.currentTimeMillis();
        System.out.println("执行秒数：" + (endTime - startTime));
    }

    /**
     * 执行秒数：48053 48394 执行速度比BatchSave 要快
     * 批量保存数据 （高效处理方式）减少大事物的提交
     */
    @Test
    public void BatchSaveBest() {
        long startTime = System.currentTimeMillis();
        List<User> list = new ArrayList<User>();
        for (int i = 0; i < 60000; i++) {
            User user = new User();
            user.setName("ljk" + i);
            list.add(user);
            if (i % 100 == 0) {
                userJpaRepository.saveAll(list);
                userJpaRepository.flush();
                list.clear();
            }
        }
        long endTime = System.currentTimeMillis();
        System.out.println("执行秒数：" + (endTime - startTime));
    }

    /**
     * 查询所有数据
     */
    @Test
    public void findAll() {
        List<User> userlists = userJpaRepository.findAll();
        Assert.assertTrue(userlists.size() > 0);
    }

    /**
     * 根据 age 排序查询
     */
    @Test
    public void findALLSortAge() {
        List<User> lists = userJpaRepository.findAll(Sort.by(Sort.Direction.ASC, "age"));
        for (User list : lists) {
            System.out.println(list);
        }
    }

    /**
     * 分页查询
     */
    @Test
    public void findAllByPage() {
        PageRequest pageRequest = new PageRequest(0, 1);
        Page<User> userPage = userJpaRepository.findAll(pageRequest);
        Assert.assertTrue(userPage.getContent().size() == 1);
    }

    /**
     * 分页排序查询
     */
    @Test
    public void findAllByPageAndSort() {
        PageRequest pageRequest = new PageRequest(0, 3, Sort.by(Sort.Direction.ASC, "age"));
        Page<User> userPage = userJpaRepository.findAll(pageRequest);
        List<User> userList = userPage.getContent();
        for (User user : userList) {
            System.out.println(user);
        }
    }

    /**
     * 根据id 的集合获取所有数据
     */
    @Test
    public void findAllByIds() {
        List<Long> ids = new ArrayList<Long>();
        ids.add(1L);
        ids.add(2L);
        ids.add(3L);
        ids.add(4L);
        List<User> userList = userJpaRepository.findAllById(ids);
        System.out.println(userList);
    }

    /**
     * 批量删除所有数据
     */
    @Test
    public void deleteAllInBatch() {
        userJpaRepository.deleteAllInBatch();
    }

    /**
     * 保存数据并刷新缓存
     */
    @Test
    public void saveAndFlush() {
        User user = new User();
        user.setName("ljk");
        user.setAge(18);
        user.setAddress("beijing");
        user.setSex("1");
        User result = userJpaRepository.saveAndFlush(user);
        Assert.assertNotNull(result);
    }

    /**
     * 批量删除
     */
    @Test
    public void deleteInBatch() {
        List<User> userList = new ArrayList<User>();
        User user = new User();
        user.setId(1l);
        userList.add(user);
        User user2 = new User();
        user2.setId(2l);
        userList.add(user2);
        User user3 = new User();
        user3.setId(3l);
        userList.add(user3);
        User user4 = new User();
        user4.setId(4l);
        userList.add(user4);
        userJpaRepository.deleteInBatch(userList);
    }

    /**
     * 根据id 获取数据
     */
    @Test
    public void getOne() {
        User user = userJpaRepository.findById(1L).get();
        System.out.println(user);
    }

    /**
     * 示例匹配器 ExampleMatcher
     */
    @Test
    public void findUserByExam() {
        User user = new User();
        user.setName("ljk");
        List<User> list = userJpaRepository.findAll(Example.of(user));
        System.out.println(list);
    }

    /**
     * 模糊查询
     */
    @Test
    public void findUserByExamQuery() {
        User user = new User();
        user.setName("ljk");
        user.setAddress("beijing");
        user.setAge(18);
        ExampleMatcher matcher = ExampleMatcher.matching()
                .withMatcher("name", ExampleMatcher.GenericPropertyMatchers.startsWith())//模糊查询匹配开头，即{username}%
                .withMatcher("address", ExampleMatcher.GenericPropertyMatchers.contains())//全部模糊查询，即%{address}%
                .withIgnorePaths("id");//忽略字段，即不管id是什么值都不加入查询条件
        Example<User> example = Example.of(user, matcher);
        List<User> userList = userJpaRepository.findAll(example);
        System.out.println(userList);
    }
}