springboot + JPA

最新推荐文章于 2024-06-28 16:28:01 发布
最新推荐文章于 2024-06-28 16:28:01 发布
阅读量1.7k 收藏 6
点赞数
分类专栏： # Java 文章标签： spring boot ORM JPA
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CaBCo/article/details/121971345
版权

关于ORM框架(Object Relational Mapping 对象关系映射)，mybatis 与 JPA各有各的好，都实现了对DAO层(Data Access Object 数据访问对象)功能的强大封装。mybatis可以灵活地手写各种复杂的SQL, 性能也更好；JPA对于扩展实体对象属性字段更友好。

个人建议：追求短平快的小公司可以采用JPA，开发更高效；业务繁杂的大中型企业宜采用mybatis，追求性能与稳定。

JPA(Java Persistence API)，（插句题外话：看到一些缩写词，我习惯找出他的全称，有助于理解相关技术的灵魂。）顾名思义就是Java 持久层API，确切地说JPA不是一个技术框架，而是一种接口规范标准，大多习惯用Hibernate框架来实现。

有关springboot的快速搭建配置，请回看历史分享springboot+mybatis。

springboot集成各种功能组件大多采用三步走，一般步骤不外乎：

  1. 依赖 - maven pom文件追加相关依赖
  2. 配置 - yml 文件追加相关配置 或 自定义配置
  3. 封装 - 根据架构设计组装自己的通用组件（工具）

接下来按部就班单刀直入JPA（假定springboot脚手架已搭建好且运行正常）。

1. maven添加JPA依赖

数据源依赖，同mybatis

<!--jpa-->
<dependency>
    <groupId>org.springframework.data</groupId>
    <artifactId>spring-data-jpa</artifactId>
</dependency>
<dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-core</artifactId>
</dependency>
<dependency>
    <groupId>org.hibernate.javax.persistence</groupId>
    <artifactId>hibernate-jpa-2.1-api</artifactId>
    <version>1.0.0.Final</version>
</dependency>
<dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-validator</artifactId>
    <version>5.4.2.Final</version>
</dependency>

2. JPA 配置

1.yml（数据源配置，同mybatis）

spring:
  #jpa
  jpa:
    show-sql: true
    hibernate:
      ddl-auto: update
      naming:
        physical-strategy: org.springframework.boot.orm.jpa.hibernate.SpringPhysicalNamingStrategy
    properties:
      hibernate:
        format_sql: false
        dialect: org.hibernate.dialect.MySQL5InnoDBDialect
    database-platform: org.hibernate.dialect.MySQL5InnoDBDialect # 默认使用innodb存储引擎

2.application（实体类及Repository扫描）

@EntityScan(basePackages = {"com.example.demo.domain"})
@EnableJpaRepositories(basePackages = {"com.example.demo.repository"})
@SpringBootApplication
public class DemoApplication{
  public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}

3. JPA 功能封装

1) entity

Domain

import com.alibaba.fastjson.annotation.JSONField;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;

import javax.persistence.*;
import java.io.Serializable;
import java.util.Date;

@Slf4j
@Data
@MappedSuperclass // 该注解作用：该父类不对应映射数据库中的表，但属性可以被子类继承
public class Domain implements Serializable {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    protected Integer id;

    @Column(columnDefinition = "TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间'")
    protected Date createTime;

    @Column(columnDefinition = "TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '修改时间'")
    protected Date updateTime;

    @JSONField(serialize = false)
    @Column(columnDefinition = "TINYINT(2) NOT NULL DEFAULT 0 COMMENT '删除标志'")
    protected Byte delFlag;

}

User

import lombok.Data;
import lombok.EqualsAndHashCode;
import org.hibernate.annotations.DynamicInsert;
import org.hibernate.annotations.DynamicUpdate;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Table;

@EqualsAndHashCode(callSuper = true)
@Data
@Entity
@Table(name = "user_user")
@DynamicInsert
@DynamicUpdate
public class User extends Domain {

    @Column(columnDefinition = "VARCHAR(28) NOT NULL DEFAULT '' COMMENT '注册手机号或微信openId'")
    private String account;

    @Column(columnDefinition = "VARCHAR(32) NOT NULL DEFAULT '' COMMENT '注册登录密码'")
    private String password;
}

2) repository

import com.example.demo.domain.Domain;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;

import javax.persistence.criteria.Path;
import javax.persistence.criteria.Predicate;
import java.util.ArrayList;
import java.util.List;

public interface BaseRepository<S extends Domain> extends JpaSpecificationExecutor<S>, JpaRepository<S, Integer> {

    default Specification<S> getSpecification(S example) {
        return (root, criteriaQuery, criteriaBuilder) -> {
            Path<Integer> id = root.get("id");
            Path<Byte> delFlag = root.get("delFlag");

            List<Predicate> predicateList = new ArrayList<>();

            if (example.getId() != null && example.getId() > 0) {
                predicateList.add(criteriaBuilder.equal(id, example.getId()));
            }
            if (example.getDelFlag() != null) {
                predicateList.add(criteriaBuilder.equal(delFlag, example.getDelFlag()));
            }

            return criteriaBuilder.and(predicateList.toArray(new Predicate[predicateList.size()]));
        };
    }

}
import com.example.demo.domain.User;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
import org.springframework.util.StringUtils;

import javax.persistence.criteria.Path;
import javax.persistence.criteria.Predicate;
import java.util.ArrayList;
import java.util.List;

public interface UserRepository extends BaseRepository<User> {

    default Specification<User> getSpecification(User example) {
        return (root, criteriaQuery, criteriaBuilder) -> {
            Path<Integer> id = root.get("id");
            Path<String> account = root.get("account");
            Path<Byte> delFlag = root.get("delFlag");

            List<Predicate> predicateList = new ArrayList<>();

            if (example.getId() != null && example.getId() > 0) {
                predicateList.add(criteriaBuilder.equal(id, example.getId()));
            }
            if (example.getDelFlag() != null) {
                predicateList.add(criteriaBuilder.equal(delFlag, example.getDelFlag()));
            }
            if (!StringUtils.isEmpty(example.getAccount())) {
                predicateList.add(criteriaBuilder.equal(account, example.getAccount()));
            }

            return criteriaBuilder.and(predicateList.toArray(new Predicate[predicateList.size()]));
        };
    }

    User findByAccount(String account);

    // native SQL
    @Query(value = "select u.* from user_user u where u.id = ?1 or u.account = ?2 ", nativeQuery = true)
    User queryUser(Integer id, String account);

    // JPQL
    @Modifying // 更新或删除时需要加此注解，查询时不需要
    @Query("update User set account = :account where id = :id ")
    User updateUserAccount(@Param("id") Integer id, @Param("account") String account);
}

3) service

BaseService:

import com.example.demo.po.PagerRequest;
import org.springframework.data.domain.Page;

import java.util.List;

public interface BaseService<T> {

    /**
     * saveOrUpdate
     * @param domain
     * @return
     */
    T merge(T domain);

    /**
     * saveOrUpdate All
     * @param domains
     * @return
     */
    List<T> mergeAll(Iterable<T> domains);

    /**
     * 删除
     * @param domain
     */
    void delete(T domain);

    /**
     * 批量删除
     * @param domains
     */
    void deleteAll(Iterable<T> domains);

    /**
     * 按主键查询
     * @param id
     * @return
     */
    T findById(Integer id);

    /**
     * 按主键批量查询
     * @param ids
     * @return
     */
    List<T> findAllById(Iterable<Integer> ids);

    /**
     * 按条件查询数据列表
     * @param domain
     * @return
     */
    List<T> findByExample(T domain);

    /**
     * 按条件统计数量
     * @param domain
     * @return
     */
    long count(T domain);

    /**
     * 分页查询数据列表
     * @param pagerRequest
     * @return
     */
    Page<T> findByPage(PagerRequest pagerRequest);

}
import com.example.demo.domain.Domain;
import com.example.demo.po.PagerRequest;
import com.example.demo.repository.BaseRepository;
import com.example.demo.service.BaseService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Sort;
import org.springframework.transaction.annotation.Transactional;

import java.lang.reflect.ParameterizedType;
import java.util.Collections;
import java.util.List;

@Slf4j
public abstract class BaseServiceImpl<T extends Domain> implements BaseService<T> {

    @Autowired
    private BaseRepository<T> baseRepository;

    private Class<T> domain;

    public BaseServiceImpl() {
        ParameterizedType parameterizedType = ((ParameterizedType) getClass().getGenericSuperclass());
        domain = (Class<T>) parameterizedType.getActualTypeArguments()[0];
    }

    @Transactional(rollbackFor = Exception.class)
    @Override
    public T merge(T domain) {
        return baseRepository.save(domain);
    }

    @Transactional(rollbackFor = Exception.class)
    @Override
    public List<T> mergeAll(Iterable<T> domains) {
        return baseRepository.saveAll(domains);
    }

    @Transactional(rollbackFor = Exception.class)
    @Override
    public void delete(T domain) {
        baseRepository.delete(domain);
    }

    @Transactional(rollbackFor = Exception.class)
    @Override
    public void deleteAll(Iterable<T> domains) {
        baseRepository.deleteAll(domains);
    }

    @Override
    public T findById(Integer id) {
        if(id != null && id > 0){
            return baseRepository.findById(id).orElse(null);
        }
        return null;
    }

    @Override
    public List<T> findAllById(Iterable<Integer> ids) {
        if(ids != null){
            return baseRepository.findAllById(ids);
        }
        return Collections.emptyList();
    }

    @Override
    public List<T> findByExample(T domain) {
        return baseRepository.findAll(baseRepository.getSpecification(domain));
    }

    @Override
    public long count(T domain) {
        return baseRepository.count(baseRepository.getSpecification(domain));
    }

    @Override
    public Page<T> findByPage(PagerRequest pagerRequest) {
        try {
            T t = domain.newInstance();

            // 查询参数封装转换 (如分页查询User, 创建UserRequest extends PagerRequest,
            BeanUtils.copyProperties(pagerRequest, t);

            // 排序处理
            Sort sort = pagerRequest.getSort();
            if (sort == null) {
                sort = new Sort(Sort.Direction.DESC, "id");
            }

            // JPA分页从0开始, mybatis pagerHelper从1开始
            PageRequest pageable = PageRequest.of((pagerRequest.getPageNum() - 1), pagerRequest.getPageSize(), sort);
            // 在对应的repository中覆写getSpecification方法
            return baseRepository.findAll(baseRepository.getSpecification(t), pageable);
        } catch (Exception e) {
            log.error("异常信息：{}", e.getMessage());
            throw new RuntimeException("查询参数异常");
        }
    }

}

UserService:

import com.example.demo.domain.User;

public interface UserService extends BaseService<User> {

    /**
     * findBy + 实体对象属性，JPA会自动映射转换成查询SQL
     * @param account
     * @return
     */
    User findByAccount(String account);

    User queryUser(Integer id, String account);

    User updateUserAccount(Integer id, String account);
}
import com.example.demo.domain.User;
import com.example.demo.repository.UserRepository;
import com.example.demo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserServiceImpl extends BaseServiceImpl<User> implements UserService {

    @Autowired
    private UserRepository userRepository;

    @Override
    public  User findByAccount(String account) {
        return userRepository.findByAccount(account);
    }
  
    @Override
    public User queryUser(Integer id, String account) {
        return userRepository.queryUser(id, account);
    }

    @Transactional(rollbackFor = Exception.class)
    @Override
    public User updateUserAccount(Integer id, String account) {
        return userRepository.updateUserAccount(id, account);
    }

}

写在最后：ORM一般作为关系型数据库的持久层处理解决方案，对于非关系型数据库（也就是我们常说的NoSQL）, 比如：redis, mongoDB, ES, solr等(虽然有些侧重搜索，但也都具有数据存储功能)，spring也可以无缝集成，下次聊聊springboot + springdata，其实JPA也是基于springdata。

XYZip2
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringBoot +JPA集成PostgreSql
little_driedfish的博客
01-21 937
一、创建一个springboot项目 二、pom.xml添加依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> </dependency> <dependency> <groupId>org.postgresql&
idea 搭建 springboot+jpa
Baldprogrammer的博客
11-27 999
idea 搭建 springboot+jpa+mybatis 老套路了，先下一步。 组名和模块名： 热部署: 生成web相关jar包: 一直下一步完成后打开窗口： 项目结构 配置pom <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0"...
IDEA SpringBoot整合SpringData JPA（保姆级教程，超详细！！！）
最新发布
当觉得自己菜的时候，就应该静下心来学习
06-28 1564
本博客将详细介绍在IDEA中，如何整合SpringBoot与SpringData JPA，以实现数据库的增删改查操作。我将逐步从环境搭建到实际代码实现的完整流程，帮助读者更好地理解并掌握这一技术栈。JPA是Java Persistence API的缩写，它定义了Java对象如何映射到关系型数据库中的表，以及如何使用面向对象的方式来查询这些表。JPA是Java EE 5规范的一部分，并由EJB 3.0（Enterprise JavaBeans）实现。2. 创建SpringBoot项目。
从零开始搭建Springboot+JPA后台
白洞，白色的明天在等着我们
03-27 1738
一、环境、工具 jdk16.0.2 java 11 SpringBoot Mybatis jdk Maven mysql 二、搭建后台spring-boot框架 首先创建新项目，点击new- project，选择Spring Initializr next ...
springboot + jpa + 达梦数据库兼容 Mysql的GenerationType.IDENTITY主键生成策略
weixin_45616246的博客
03-05 698
https://eco.dameng.com/community/article/62d5559355f60597dc38a397e0fe857b(兼容对应数据库的主键生成策略配置)
SpringBoot + Jpa 详细使用教程（企业开发使用总结）
weixin_45698637的博客
10-20 2057
SpringBoot + Jpa 实战教程JPA 介绍JPA 简单使用示例JPA 实体类中相关注解说明JPA 持久层SQL说明 JPA 介绍 JPA（Java Persistence API），对象关系映射（ORM）框架规范，是一种Java持久化规范。jpa可以通过实体类生成数据库的表，同时自带很多增删改查方法，大部分sql语句不需要我们自己写，配置完成后直接调用方法即可，很方便。 JPA 简单使用示例 1. pom.xml <dependency> <groupId>org
springboot + jpa增删改查
fwk_love的博客
02-26 693
目前项目用到springboot + jpa进行持久层处理，就写了几个增删改查的小demo 直接上代码 新增： //1、新增 Dog dog = new Dog(); dog.setName("李哥"); dog.setCode(123L); dog.setAge(66); //dog.setId(16L); Dog dog1 = dogDao.save(dog); Sys
springboot + jpa 实现简单的验证码登陆功能
lingluodeguye的博客
05-11 157
2、application.properties配置文件。1、由于存在拦截器 需要登陆才可以进行访问。上面用的jar包都有注释可以自行选择。已经打包好了， 见下篇博客！2、所以这里运行之后访问页面。3、输入帐号、密码 点击登录。3、pom.xml配置文件。二、代码运行展示的效果。
springboot+jpa+thymeleaf项目实现分页功能
找找bug的博客
05-19 740
1 所使用的技术 后端：springboot+jpa 前端：thymeleaf模板 2 实现代码 2.1 前端核心代码 <div class="ui bottom attached segment"> <div class="ui middle aligned two column grid" th:if="${page.totalPages}>1"> <d
springboot + Jpa 实现分页功能
快乐小码农的博客
09-21 2854
Springboot 集成 Jpa 实现分页 由于用的技术并不复杂，所以我们开门见山，直接上代码 先来看下代码结构 pom.xml 引入相关jar包 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation
SpringBoot+JPA
04-03
**SpringBoot+JPA 整合指南** SpringBoot以其便捷的快速启动和自动配置特性，大大简化了Java Web应用的开发流程。而JPA（Java Persistence API）是Java平台上的ORM（Object-Relational Mapping）标准，它允许开发者...
SpringBoot+JPA+thymeleaf框架实现增删改查分页显示
05-12
SpringBoot+JPA+thymeleaf框架实现增删改查分页显示，前端通过bootstrap渲染
基于SpringBoot+JPA的信息管理系统
05-31
只需要在pom.xml或build.gradle文件中添加相应的依赖，SpringBoot会自动配置JPA的环境。然后，通过@Entity注解定义实体类，@Table指定表名，@Id指定主键，@GeneratedValue自动生成主键值。使用@EntityRepository定义...
springboot+JPA+thymeleaf开发的个人博客网站
05-04
简约的个人博客网站，代码有清晰的注释，后端采用springboot+JPA+thymeleaf模板，数据库采用mysql，前端UI采用semantic UI框架，开发工具采用IDEA，jdk版本为jdk8。整个网站包括两个大模块：前端展示和后端管理。...
springboot + mybatis
热门推荐
CaBCo的博客
12-15 1万+
spring家族的springboot就像航天界冒出的SpaceX，降本增效提质。 hello world 即将成为 hello space。
springboot + redis
CaBCo的博客
12-17 2966
缓存穿透 ~ 缓存击穿 ~ 缓存雪崩
springboot+mongodb
CaBCo的博客
07-19 2594
NoSQL ？ MongoDB !
LTS（Light-Task-Scheduler）
CaBCo的博客
07-22 2288
LTS（light-task-scheduler），是一款分布式任务调度框架，支持实时任务、定时任务、Cron任务。
springboot+jpa
07-25
Spring Boot JPA 是一种使用Java Persistence API(JPA)进行数据持久化的方式，它可以帮助我们简化数据访问层的开发。JPA 的增删改查操作分别对应如下方法： - 增加：使用 JpaRepository 接口的 save() 方法 - 删除...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值