Spring-Data-Jpa入门教程（一）

原创

风筝故乡

修改于 2021-07-20 10:37:24

4910

修改于 2021-07-20 10:37:24

文章被收录于专栏：程序员之家

一、啥是JPA？

JPA，全英文名叫Java Persistence API，就是java持久化api，是SUN公司推出的一套基于ORM的规范。

持久化想必如雷贯耳，都0202年了，谁还不用个持久化框架啊，举起mybatis。

ORM呢？全英文名为Object-Relational Mapping：对象关系映射，简单来说为了不用JDBC那一套原始方法来操作数据库，ORM框架横空出世（mybatis、hibernate等等）。

然而ORM框架出的太多了，百花齐放，琳琅满目，你一套标准我一套标准，要是想换一套框架实现项目，可能要从头再写。啊这？入土吧。

百度这样介绍SUN的JPA规范：

Sun引入新的JPA ORM规范出于两个原因：

其一，简化现有Java EE和Java SE应用开发工作；

其二，Sun希望整合ORM技术，实现天下归一。

有气魄，我喜欢，学他丫的。

二、Spring-Data-Jpa简介

学jpa哪家强？哪家简单学哪家，spring-data-jpa最简单。介绍如下：

Spring Data JPA是Spring Data家族的一部分，可以轻松实现基于JPA的存储库。此模块处理对基于JPA的数据访问层的增强支持。它使构建使用数据访问技术的Spring驱动应用程序变得更加容易。

总的来说JPA是ORM规范，Hibernate、TopLink等是JPA规范的具体实现，这样的好处是开发者可以面向JPA规范进行持久层的开发，而底层的实现则是可以切换的（敲黑板哦）。Spring Data Jpa则是在JPA之上添加另一层抽象（Repository层的实现），极大地简化持久层开发及ORM框架切换的成本。

也就是如下图所示：

三、环境配置

话不多说，使用Maven管理包，使用springboot框架，建个空maven项目就行

1、配置pom.xml

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.4.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.jacky</groupId>
    <artifactId>user-service</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>user-service</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.6.3</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.20</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
    </dependencies>

2、配置application.yml

server:
  port: 8801

spring:
  application:
    name: user-service
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driverClassName: com.mysql.jdbc.Driver
    url: jdbc:mysql://10.16.58.21:3306/appt_test
    username: root
    password: 123456
    # druid配置项，默认spring-boot不支持，故需要config类来解析
    initialSize: 5
    minIdle: 5
    maxActive: 20
    maxWait: 60000
    timeBetweenEvictionRunsMillis: 60000
    minEvictableIdleTimeMillis: 300000
    validationQuery: SELECT 1 FROM DUAL
    testWhileIdle: true
    testOnBorrow: false
    testOnReturn: false
    poolPreparedStatements: true
    maxPoolPreparedStatementPerConnectionSize: 20
    filters: stat,wall,log4j
    connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true

3、配置Springboot启动类

@SpringBootApplication
@EnableJpaAuditing
public class UserServiceApplication {

    public static void main(String[] args) {
        SpringApplication.run(UserServiceApplication.class, args);
    }

    @PostConstruct
    void setDefaultTimeZone() {
        TimeZone.setDefault(TimeZone.getTimeZone("Asia/Shanghai"));
    }
}

注意：

除了@SpringBootApplication启动注解外，

还有一个注解@EnableJpaAuditing，它是用来启动Jpa的审计功能，比如说在使用建表中经常会加入版本号、创建时间、修改时间、创建者、修改者这五个字段。因此为了简化开发，我们可以将其交给jpa来自动填充。

4、创建阿里Druid配置类

import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.support.http.StatViewServlet;
import com.alibaba.druid.support.http.WebStatFilter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;

import javax.sql.DataSource;
import java.sql.SQLException;

/**
 * 阿里Druid配置类
 *
 * @author zcc ON 2018/2/11
 **/
@Configuration
public class DruidConfig {
    private static final Logger log = LoggerFactory.getLogger(DruidConfig.class);

    @Value("${spring.datasource.url}")
    private String dbUrl;

    @Value("${spring.datasource.username}")
    private String username;

    @Value("${spring.datasource.password}")
    private String password;

    @Value("${spring.datasource.driverClassName}")
    private String driverClassName;

    @Value("${spring.datasource.initialSize}")
    private int initialSize;

    @Value("${spring.datasource.minIdle}")
    private int minIdle;

    @Value("${spring.datasource.maxActive}")
    private int maxActive;

    @Value("${spring.datasource.maxWait}")
    private int maxWait;

    @Value("${spring.datasource.timeBetweenEvictionRunsMillis}")
    private int timeBetweenEvictionRunsMillis;

    @Value("${spring.datasource.minEvictableIdleTimeMillis}")
    private int minEvictableIdleTimeMillis;

    @Value("${spring.datasource.validationQuery}")
    private String validationQuery;

    @Value("${spring.datasource.testWhileIdle}")
    private boolean testWhileIdle;

    @Value("${spring.datasource.testOnBorrow}")
    private boolean testOnBorrow;

    @Value("${spring.datasource.testOnReturn}")
    private boolean testOnReturn;

    @Value("${spring.datasource.poolPreparedStatements}")
    private boolean poolPreparedStatements;

    @Value("${spring.datasource.maxPoolPreparedStatementPerConnectionSize}")
    private int maxPoolPreparedStatementPerConnectionSize;

    @Value("${spring.datasource.filters}")
    private String filters;

    @Value("{spring.datasource.connectionProperties}")
    private String connectionProperties;

    @Bean
    @Primary
    public DataSource dataSource() {
        DruidDataSource datasource = new DruidDataSource();
        log.info("----------- druid datasource ----------");
        datasource.setUrl(this.dbUrl);
        datasource.setUsername(username);
        datasource.setPassword(password);
        datasource.setDriverClassName(driverClassName);

        datasource.setInitialSize(initialSize);
        datasource.setMinIdle(minIdle);
        datasource.setMaxActive(maxActive);
        datasource.setMaxWait(maxWait);
        datasource.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
        datasource.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
        datasource.setValidationQuery(validationQuery);
        datasource.setTestWhileIdle(testWhileIdle);
        datasource.setTestOnBorrow(testOnBorrow);
        datasource.setTestOnReturn(testOnReturn);
        datasource.setPoolPreparedStatements(poolPreparedStatements);
        datasource.setMaxPoolPreparedStatementPerConnectionSize(maxPoolPreparedStatementPerConnectionSize);
        try {
            datasource.setFilters(filters);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        datasource.setConnectionProperties(connectionProperties);

        return datasource;
    }

    @Bean
    public ServletRegistrationBean registrationBean() {
        ServletRegistrationBean servletRegistrationBean = new ServletRegistrationBean(new StatViewServlet()); // 添加初始化参数：initParams
        servletRegistrationBean.addUrlMappings("/druid/*");
        // 白名单
        servletRegistrationBean.addInitParameter("allow", "127.0.0.1");
        // 黑名单
        servletRegistrationBean.addInitParameter("deny", "192.168.0.101");
        // 登录查看信息的账号密码.
        servletRegistrationBean.addInitParameter("loginUsername", "admin");
        servletRegistrationBean.addInitParameter("loginPassword", "123456");
        // 可重置数据.
        servletRegistrationBean.addInitParameter("resetEnable", "false");
        return servletRegistrationBean;
    }

    @Bean
    public FilterRegistrationBean filterRegistrationBean() {
        FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean(new WebStatFilter());
        // 添加过滤规则.
        filterRegistrationBean.addUrlPatterns("/*");
        // 添加不需要忽略的格式信息.
        filterRegistrationBean.addInitParameter("exclusions", "*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*");
        return filterRegistrationBean;
    }
}

5、创建repository数据访问层接口

通过repository接口可以很方便的调用JPA，完成数据库的所有操作，当然包括数据库CRUD

import com.jacky.userservice.pojo.entity.dvUser;
import org.springframework.data.jpa.repository.JpaRepository;

public interface dvUserRepository extends JpaRepository<dvUser, Long> {
}

可以看到，这个接口继承了JpaRepository<实体,ID>，spring-data-jpa只需要这个信息，就可以帮你完成常用的操作：增删查改。

6、创建entity实体类

@Data
@Entity
@Table(name = "dv_user")
@EntityListeners(AuditingEntityListener.class)
public class dvUser {

    @Id
    @Column(name = "id")
    @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "JPA_USER_S2")
    @SequenceGenerator(sequenceName = "JPA_USER_S1", name = "JPA_USER_S2", allocationSize = 1)
    private Long id;

    @Column(name = "name")
    private String name;

    @Column(name = "object_version" )
    @Version
    private Long objectVersion;

    @Column(name = "created_by")
    @CreatedBy
    private String createdBy;

    @Column(name = "created_date")
    @CreatedDate
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
    private Date createdDate;

    @Column(name = "last_updated_by" )
    @LastModifiedBy
    private String lastUpdatedBy;

    @Column(name = "last_updated_date" )
    @LastModifiedDate
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
    private Date lastUpdatedDate;
}

7、创建service接口

import com.jacky.userservice.pojo.entity.dvUser;
import java.util.List;
public interface dvUserService {
    /**
     * 新增用户
     * @param user 用户对象
     */
    dvUser insertUser(dvUser user);

    /**
     * 删除用户
     * @param id 删除id
     */
    void deleteUser(Long id);

    /**
     * 修改用户
     * @param user 用户信息
     */
    dvUser updateUser(dvUser user);

    /**
     * 查询所有用户
     */
    List<dvUser> findAllUser();

    /**
     * 通过id查询用户
     * @param id 用户id
     */
    dvUser findUserById(Long id);
}

8、创建service接口实现类

import com.jacky.userservice.pojo.entity.dvUser;
import com.jacky.userservice.repository.dvUserRepository;
import com.jacky.userservice.service.dvUserService;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.List;

@Service
public class dvUserServiceImpl implements dvUserService {
    @Resource
    private dvUserRepository dvUserRepository;

    @Override
    public dvUser insertUser(dvUser user) {
        return dvUserRepository.save(user);
    }

    @Override
    public void deleteUser(Long id) {
        dvUserRepository.deleteById(id);
    }

    @Override
    public dvUser updateUser(dvUser user) {
        return dvUserRepository.save(user);
    }

    @Override
    public List<dvUser> findAllUser() {
        return dvUserRepository.findAll();
    }

    @Override
    public dvUser findUserById(Long id) {
        return dvUserRepository.findById(id).orElse(null);
    }
}

9、创建controller访问层

import com.jacky.userservice.pojo.entity.dvUser;
import com.jacky.userservice.service.dvUserService;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import java.util.List;

@RestController
@RequestMapping("/user")
public class JpaUserController {
    @Resource
    private dvUserService dvUserService;

    /**
     * 新增用户
     */
    @PostMapping("")
    public dvUser addUser(@RequestBody dvUser user){
        return dvUserService.insertUser(user);
    }

    /**
     * 删除用户
     */
    @DeleteMapping("/{id}")
    public void deleteUser(@PathVariable("id") Long id){
        dvUserService.deleteUser(id);
    }

    /**
     * 修改用户
     */
    @PutMapping("")
    public dvUser updateUser(@RequestBody dvUser user){
        return dvUserService.updateUser(user);
    }

    /**
     * 全查用户
     */
    @GetMapping("")
    public List<dvUser> findAll(){
        return dvUserService.findAllUser();
    }

    /**
     * id查用户
     */
    @GetMapping("/{id}")
    public dvUser findbyId(@PathVariable("id") Long id){
        return dvUserService.findUserById(id);
    }
}