Spring Data JPA 简单实现增删改查

Spring Data JPA 实现简单的增删改查

首先引入JPA部分的Maven依赖

<!-- 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>
    <scope>runtime</scope>
</dependency>
<!-- Lombak插件 的依赖   用于通过注解代替简化setter/getter方法的书写 -->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <optional>true</optional>
</dependency>

配置好数据库和JPA的基础配置 application.yml

spring:
  ##datasource setting yaml 这是MySQL 8 的版本配置##
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/learning?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8&useSSL=true
    username: root
    password: 123456
  ##jpa setting yaml 定义存储为InnoDB引擎##
  jpa:
    database: mysql
    show-sql: true
    hibernate:
      ddl-auto: update
    properties:
      hibernate:
        dialect: org.hibernate.dialect.MySQL5InnoDBDialect

前期准备 ：model层，创建实体PO类

package com.example.jpa.po;
import lombok.Getter;
import lombok.Setter;
import lombok.ToString;
import javax.persistence.*;
/**
 * 实体类的创建
 * @author wq
 * @date 2019/11/5
 * @version 1.0
 */
@Getter
@Setter
@ToString
@Entity
public class User {
    /**
     * 主键ID，主键生成策略为自动增长
     */
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Integer id;
    /**
     * 用户名
     */
    @Column
    private String name;
    /**
     * 用户密码
     */
    @Column
    private String password;
}

前期准备：dao层，创建DAO类

• 实现JPA规范的Spring Data JPA 的DAO层，可以只定义接口而不需要实现类就可以实现基本的增删改查和排序分页操作，需要的仅仅是定义DAO层的接口继承相应的接口，通常是继承JpaRepository接口。

• 甚至于还可以通过命名查询方法的方式建立更加复杂的SQL查询，但是如果你需要通过JPQL来实现的话，那就需要建立实现类了。

package com.example.jpa.dao;
import com.example.jpa.po.User;
import org.springframework.data.jpa.repository.JpaRepository;
/**
 * DAO层
 * @author wq
 * @date 2019/11/5
 * @version 1.0
*/
public interface UserRepository extends JpaRepository<User, Integer> {
    
}

前期准备：service层

package com.example.jpa.service;
import com.example.jpa.po.User;
/**
 * Service层接口
 * @author wq
 * @date 2019/11/5
 * @version 1.0
*/
public interface UserService {
    /**
     * 通过id查询一条数据
     * @param id
     * @return
     */
    User findById(Integer id);
    /**
     * 更新数据
     * @param user
     */
    void update(User user);
    /**
     * 添加数据
     * @param user
     */
    void save(User user);
    /**
     * 删除数据
     * @param user
     */
    void delete(User user);
}
//-----------------------------------------------------------------------------
package com.example.jpa.service.impl;
import com.example.jpa.dao.UserRepository;
import com.example.jpa.po.User;
import com.example.jpa.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
/**
 * Service层的实现层
 * @author wq
 * @date 2019/11/5
 * @version 1.0
*/
@Service
public class UserServiceImpl implements UserService {
    @Autowired
    private UserRepository userRepository;
    @Override
    public User findById(Integer id) {
        return userRepository.findById(id).get();
    }
    @Override
    public void update(User user) {
        userRepository.save(user);
    }
    @Override
    public void save(User user) {
        userRepository.save(user);
    }
    @Override
    public void delete(User user) {
        userRepository.delete(user);
    }
}

• 注意这里的更新和保存操作，可以看到都是调用的save方法，这是在具体实现的时候，如果传进来的User对象是有id的，那么执行更新操作，如果没有则是保存的操作

前期准备：Controller层

package com.example.jpa.controller;
import com.example.jpa.po.User;
import com.example.jpa.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
 * Controller层
 * @author wq
 * @date 2019/11/5
 * @version 1.0
*/
@RestController
@RequestMapping
public class UserController {
    @Autowired
    private UserService userService;
    /**
     * 新增一条用户信息
     * @return
     */
    @GetMapping("/save")
    public String addNewUser(){
        User user = new User();
        user.setName("新增一个用户");
        user.setPassword("我是密码");
        userService.save(user);
        return "save";
    }
    /**
     * 按照id查询用户信息
     * @return
     */
    @GetMapping("/find")
    public User find() {
        return userService.findById(1);
    }
    /**
     * 按照id删除用户
     */
    @GetMapping("/delete")
    public void delete() {
        User user = new User();
        user.setId(1);
        userService.delete(user);
    }
    /**
     * 通过id对name字段进行更新
     */
    @GetMapping("/update")
    public void update() {
        User user = new User();
        user.setId(1);
        user.setName("更新名字");
        user.setPassword("更新密码");
        userService.save(user);
    }
}

• 便于测试所以所有的数据都是写死的，不需要通过前端传入。

第一次启动

package com.example.jpa;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
/**
 * 主启动类
 * @author wq
 * @date 2019/11/5
 * @version 1.0
*/
@SpringBootApplication
public class JpaApplication {
    public static void main(String[] args) {
        SpringApplication.run(JpaApplication.class, args);
        System.out.println("STARTING");
    }
}

• 可见，第一次启动的时候，JPA会自己创建表，而且由于yml配置文件中设置的是update，所以不会在每次启动的时候如同设置成create一样会先到数据库里面删除一遍表，再重新生成。

调用测试

• 新增 此时只需要调用localhost:8080/save

  Hibernate: select next_val as id_val from hibernate_sequence for update
  Hibernate: update hibernate_sequence set next_val= ? where next_val=?
  Hibernate: insert into user (name, password, id) values (?, ?, ?)
  

  由此可见首先从hibernate_sequence这个表中查询出来了下一个应该新增的id（这里需要说明的是，实现主键自增，如何得到下一次的主键的值是多少，是存在hibernate_sequence这个表里面）。
  

  接着可以发现更新了一下hibernate_sequence表的内容，截图也可以知道变成了2，证明此时数据库的User表中有了一条数据。

  紧接着朝着User表中新增了一个数据，那么数据库中也保存了一条数据了
  

• 更新 此时只需要调用localhost:8080/update

  Hibernate: select user0_.id as id1_0_0_, user0_.name as name2_0_0_, user0_.password as password3_0_0_ from user user0_ where user0_.id=?
  Hibernate: update user set name=?, password=? where id=?
  

  可见，这里由于user实体里存在有User这个键，所以首先插了一遍，紧着着再跟新了。
  

• 查找 此时只需要调用localhost:8080/find
  

  Hibernate: select user0_.id as id1_0_0_, user0_.name as name2_0_0_, user0_.password as password3_0_0_ from user user0_ where user0_.id=?
  

  直接一条查询的SQL就行了，虽然这些查询SQL看着好像狠长很麻烦，其实就是多了很多的别名而已，比如上面的SQL就可以简化为

  Hibernate: select id, name, password from user where id=?
  

  这样简化是不是就很熟悉啦？？？

• 删除 此时只需要调用localhost:8080/delete

  Hibernate: delete from user where id=?
  

  直接删除完毕。
  

  这就是基本的增删改查操作了！！！