Springboot整合Spring Data JPA，使用JPA操作MySql数据库进行CRUD

 <!--引入jpa的依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>

2.添加MySql数据库驱动依赖

 <!--引入mysql的驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

3.在application.properties中配置数据库和JPA的相关属性置


spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/springboot?characterEncoding=UTF8&useSSL=false
spring.datasource.username=root
spring.datasource.password=

#jpa的相关配置
spring.jpa.generate-ddl=true
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true
spring.jpa.database-platform=org.hibernate.dialect.MySQL5InnoDBDialect

jpa相关配置：

（1）spring.jpa.generate-ddl：属性值可以为true和false

true:开启逆向工程，即存在数据库的表，然后数据库表可以生成实体类。

false：正向工程，先存在实体类，然后根据实体类，生成底层的表。

开发阶段可以设置为true 开启逆向工程；在实际上线运行阶段，实体类和底层的数据库表都是已经存在，应该把值改成flase。

（2）spring.jpa.hibernate.ddl-auto：数据表结构

属性值可以设置为create，create-drop，none，update，validate

create：设置为create，每次运行程序都会将原来的数据删除，然后重新创建一个表。

create-drop：每次加载时将创建一个数据表，数据表使用完毕之后，将数据表再次删除。

none ：将功能不生效。

update：加载时更新表结构，如果你的表结构和实体类发生了改变，数据表会更新,如果数据库中有数据表，就使用原来的表，没有数据表，就会创建一个数据表。

validate：验证创建数据库表结构，实体类和数据表进行校验，如果属性或者个数不一致，就会抛出异常。

（3）spring.jpa.show-sql：控制台打印sql语句，属性值为true和false

true：操作实体对象的时候，会给我们生成sql语句

false：不生成sql语句

（4）spring.jpa.database-platform：指定数据库的类型

4.创建实体配置类

注：set和get方法可以用lombok注解表示

package com.zmn.springbootjpa.domain;

import org.springframework.format.annotation.DateTimeFormat;

import javax.persistence.*;

/**
 * @author
 * User 实体类，对应底层数据库表，mysql数据库当中没有user表
 *可以使用jpa的正向工程
 * 实体类--->关系表
 * @Entity 注解：表明当前是实体类，当前的实体类和底层的user 关系表进行
 */
@Entity(name="user")
public class User {
    @Id //id唯一值
    @GeneratedValue(strategy = GenerationType.IDENTITY) //自增主键
    private int id;
    @Column
    private String name;
    @Column
    private String password;
    @Column
    private int age;


    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", password='" + password + '\'' +
                ", age=" + age +
                '}';
    }
}

5.编写UserDao接口

新建一个com.zmn.springjpa.dao.UserDao接口，让接口继承JpaRepository，这个接口默认提供一组与JPA规范相关的方法。

JpaRepository<T,ID> jpa提供的接口：接口的当中定义了实体的基本操作，T 制定具体操作的实体类，ID指定主键字段的类型（实体类当中带有id注解的属性）。


import com.zmn.springbootjpa.domain.User;
import org.springframework.data.jpa.repository.JpaRepository;

/**
 * 创建UserDao 接口，实现user实体类的操作
 * JpaRepository<T,ID> jpa提供的接口：接口的当中定义了实体的基本操作
 * T 制定具体操作的实体类 ，ID指定主键字段的类型（实体类当中带有id注解的属性）
 */

public interface UserDao extends JpaRepository<User,Integer> {

}

6.编写测试类

直接调用继承的JpaRepository类里面的方法进行CRUD。

其中，sava方法就可以完成添加和修改操作

package com.zmn.springbootjpa;

import com.zmn.springbootjpa.dao.UserDao;
import com.zmn.springbootjpa.domain.User;
import org.junit.jupiter.api.Test;
import org.junit.runner.RunWith;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.List;
import java.util.Optional;

/*@EnableAutoConfiguration(exclude={DataSourceAutoConfiguration.class})*/
@SpringBootTest(classes =SpringbootJpaApplication.class )
class SpringbootJpaApplicationTests {

    //对jpa提供的接口方法进行测试；
    @Autowired
    UserDao userDao; //springboot在启动的时候，底层使用了动态代理的方式，获得了一个接口的实现类，完成了注入


    @Test
    void contextLoads() {
        System.out.println("table 创建成功");
    }

    /**
     * save方法
     * 如果没有指定id字段，直接进行insert操作
     * 如果指定id字段，且这个id存在，则就进行update操作
     *    根据id 先去查询这个id是否存在
     *    如果存在，则就进行更新操作
     *  如果根据id没有查询到对应的记录，进行一个添加操作
     */

    @Test
    void addUset(){
        System.out.println("添加用户");
        User user=new User();
        user.setName("小❀");
        user.setPassword("123456");
        user.setAge(18);
        userDao.save(user);
    }

    @Test
    void updateUset(){
        System.out.println("添加用户");
        User user=new User();
        user.setId(4);
        user.setName("李四");
        user.setPassword("123456");
        user.setAge(24);
        userDao.save(user);
    }

    //查询操作,根据id来查询
    @Test
    void findUser(){
        //获得了一个optional对象
        //findById() JpaRepository 接口当中提供的，不是我们自定义的，
        //查询的内容封装到optional对象中，get()方法获得user对象，如果查询的对象不存在，返回异常信息
        Optional<User> optional = userDao.findById(1);
        User user=optional.get();
        System.out.println(user);
    }

    /**
     * 列表查询：返回的是列表集合
     * findAll()没有指定任何参数，查询的列表
     * findAll()在使用的时候可以指定参数，按照参数排序查询
     */

    //查询全部
    @Test
    void findAllUser(){
        List<User> users = userDao.findAll();
        for (User user : users) {
            System.out.println(user);
        }

    }
    //按照名字的顺序查找全部
    @Test
    void findAllUser2(){

        List<User> name = userDao.findAll(Sort.by("name"));
        for (User user : name) {
            System.out.println(user);
        }
    }

    /**
     * pageable:接口类型
     * pageRequest:接口的实现类对象，
     * 实现类不是直接new 构造器protect
     * PageRequest:当类中提供了of方法，返回本类对象
     * of()方法，static静态方法
     * 参数一：
     * page:查询第一页，用户指定
     * size:当前页显示的记录数
     * Direction.DESC:指定降序排序
     * Direction.ASC：指定升序排序（一般默认）
     * properties:指定具体的哪个属性进行排序
     */

    //分页查询
    @Test
    void findAllUserWithPage(){

        //pageable 对象封装了一些分页相关的参数
        Pageable pageable= PageRequest.of(1,2,Sort.Direction.DESC,"id");
        Page<User> users = userDao.findAll(pageable);
        for (User user : users) {
            System.out.println(user);
        }
        //获得分页相关的信息
        //uses.getTotalElements();获得元素的个数
       // int totalPages= users.getTotalPages();//获得页码数

    }



    /**
     * 删除操作:
     * delete(user);传递user对象，删除传递对象
     * 先查询，再删除
     */
    @Test
    void deleteUser(){
      /*  User user=new User();
        user.setId(1);
        userDao.delete(user);
*/
        userDao.deleteById(4);
    }


}