JPA学习(一)

已于 2022-07-20 15:51:43 修改
阅读量487 收藏
点赞数
分类专栏： JPA 文章标签： 学习 mybatis java
于 2022-07-20 15:50:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/DSAUBDUA/article/details/125893966
版权

什么是JPA

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

持久化想必如雷贯耳，都2202年了，谁还不用个持久化框架啊，举起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框架切换的成本。

也就是如下图所示：
img

配置环境

使用Maven管理包，使用springboot框架，建个空maven项目就行。

POM文件

  <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.4.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <dependencies>
        <!--web-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--spring-data-jpa-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <!--druid连接池-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.23</version>
        </dependency>
        <!--oracle桥接器-->
        <dependency>
            <groupId>com.oracle.ojdbc</groupId>
            <artifactId>ojdbc8</artifactId>
            <scope>runtime</scope>
        </dependency>
        <!--lombok-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>

    </dependencies>

application.yml

spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    url: jdbc:oracle:thin:@localhost:1521:XE
    username: JPADEMO
    password: oracle
    driver-class-name: oracle.jdbc.OracleDriver
  jpa:
    hibernate:
      ddl-auto: update #自动更新
    show-sql: true  #日志中显示sql语句
  application:
    name: spring-data-jpa-demo
server:
  port: 2333 #端口号

文件夹

在这里插入图片描述

  • 标准的MVC结构，有助于解耦的实现；
  • 实体类放在 pojo/entity 下
  • dao（数据访问对象 data access object）在JPA中叫做repository，请遵守这个规范，就像mybaits的dao叫mapper一样。

创建数据库表

-- 创建一张表
create table JPA_USER
(
    id                number not null,
    name              varchar2(100),
    object_version    number not null,
    created_by        varchar2(50),
    created_date      date,
    last_updated_by   varchar2(50),
    last_updated_date date

);
-- 给表加主键 单列主键 主键命名为JPA_USER_PK1 
alter table JPA_USER add constraint JPA_USER_PK1 primary key (id);
-- 给表加注释
COMMENT ON table JPA_USER IS '用户信息表';
-- 给字段加注释
comment on column JPA_USER.id  is 'id';
comment on column JPA_USER.name is '用户名称';
-- 创建序列 命名为JPA_USER_S
create sequence JPA_USER_S
    minvalue 1
    maxvalue 9999999999999999999999999999
    start with 1
    increment by 1
    cache 20;
--创建索引 命名为JPA_USER_INDEX1 
create index JPA_USER_INDEX1 on JPA_USER(name);

代码

1. Spring-boot启动类

SpringContextApplication:

/**
 * 启动类
 */
@EnableJpaAuditing
@SpringBootApplication
public class SpringContextApplication {
    public static void main(String[] args) {
        SpringApplication.run(SpringContextApplication.class, args);
    }
}

注意：

除了@SpringBootApplication启动注解外，

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

2. eneity实体类

package org.example.jpademo.pojo.entity;

import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.Data;
import org.springframework.data.annotation.CreatedBy;
import org.springframework.data.annotation.CreatedDate;
import org.springframework.data.annotation.LastModifiedBy;
import org.springframework.data.annotation.LastModifiedDate;
import org.springframework.data.jpa.domain.support.AuditingEntityListener;

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

/**
 * @Classname JpaUser
 * @Description TODO 用户实体类
 * @Date 2020/8/13 14:52
 * @Created by orange
 */
@Data
@Entity
@Table(name = "JPA_USER")
@EntityListeners(AuditingEntityListener.class)
public class JpaUser {

    @Id
    @Column(name = "ID")
    @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "JPA_USER_S")
    @SequenceGenerator(sequenceName = "JPA_USER_S", name = "JPA_USER_S", 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;
}
注解作用常用属性
@Data给实体类加get/set/toString/EqualsAndHashCode方法，是lombok的注解
@Entity指定当前类是实体类
@Table指定实体类和表之间的对应关系name：指定数据库表的名称
@EntityListeners在实体类增删改的时候监听，为创建人/创建时间等基础字段赋值value：指定监听类
@Id指定当前字段是主键
@SequenceGenerator指定数据库序列别名sequenceName：数据库序列名
name：取的别名
@GeneratedValue指定主键的生成方式strategy ：指定主键生成策略
generator：选择主键别名
@Column指定实体类属性和数据库表之间的对应关系name：指定数据库表的列名称。
unique：是否唯一
nullable：是否可以为空
inserttable：是否可以插入
updateable：是否可以更新
columnDefinition: 定义建表时创建此列的DDL
@CreatedBy自动插入创建人
@CreatedDate自动插入创建时间
@LastModifiedBy自动修改更新人
@LastModifiedDate自动修改更新时间
@Version自动更新版本号
@JsonFormat插入/修改/读取的时间转换成想要的格式pattern：展示格式
timezone：国际时间

注意：

有了@EntityListeners(AuditingEntityListener.class)这个注解，@CreatedBy、@CreatedDate 、@LastModifiedBy 、@LastModifiedDate才生效哦，而且创建人和更新人需要另作注入操作，此篇埋个伏笔。

3. repository 数据访问层

此处便是整个spring-data-jpa中最令人虎躯一震的地方！

震惊，一个接口居然可以实现常用的所有操作！

JpaUserRepository代码如下：

package org.example.jpademo.repository;

import org.example.jpademo.pojo.entity.JpaUser;
import org.springframework.data.jpa.repository.JpaRepository;

/**
 * @Classname JpaUserRepository
 * @Description TODO
 * @Date 2020/8/13 15:12
 * @Created by orange
 */
public interface JpaUserRepository extends JpaRepository<JpaUser, Long> {
}

你以为才开始吗？不，已经结束了。

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

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package org.springframework.data.jpa.repository;

import java.io.Serializable;
import java.util.List;
import org.springframework.data.domain.Example;
import org.springframework.data.domain.Sort;
import org.springframework.data.repository.NoRepositoryBean;
import org.springframework.data.repository.PagingAndSortingRepository;
import org.springframework.data.repository.query.QueryByExampleExecutor;

@NoRepositoryBean
public interface JpaRepository<T, ID extends Serializable> extends PagingAndSortingRepository<T, ID>, QueryByExampleExecutor<T> {
    List<T> findAll();

    List<T> findAll(Sort var1);

    List<T> findAll(Iterable<ID> var1);

    <S extends T> List<S> save(Iterable<S> var1);

    void flush();

    <S extends T> S saveAndFlush(S var1);

    void deleteInBatch(Iterable<T> var1);

    void deleteAllInBatch();

    T getOne(ID var1);

    <S extends T> List<S> findAll(Example<S> var1);

    <S extends T> List<S> findAll(Example<S> var1, Sort var2);
}

这一节不具体展开JpaRepository中所包含的所有方法，单纯使用最简单的增删查改来过瘾。

4. Service业务逻辑层

业务逻辑层是程序的逻辑核心，所有的重要的逻辑操作都应该往Service中写，而不是写到Controller控制层里去哦。

而且Service层是需要分层的：接口和实现类，这个不必多说，规范！规范！

我们实现最简单的新增、删除、修改、查询功能

接口如下：

public interface JpaUserService {
    /**
     * 新增用户
     * @param user 用户对象
     */
    JpaUser insertUser(JpaUser user);

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

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

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

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

接口实现：

@Service
public class JpaUserServiceImpl implements JpaUserService {
    @Resource
    private JpaUserRepository jpaUserRepository;

    @Override
    public JpaUser insertUser(JpaUser user) {
        return jpaUserRepository.save(user);
    }

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

    @Override
    public JpaUser updateUser(JpaUser user) {
        return jpaUserRepository.save(user);
    }

    @Override
    public List<JpaUser> findAllUser() {
        return jpaUserRepository.findAll();
    }

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

你没有看错，一个sql语句也没有见着，直接通过jpaUserRepository接口把方法点了出来。

这一点比mybatis做的好，不过你要硬说mybatis-plus牛逼我也没办法。

数据访问层（dao）被确确实实的优化的很简便，这是spring-data-jpa很大的亮点。

细心的同学可能发现了，新增和修改都调用的save()方法，jpa靠什么区分是insert还是update呢？

靠的是主键id有没有赋值判断~id有值为update，id无值为insert。

5.Contoller控制层

控制层是前后台交互的层，我采用的是restful编写格式的接口，对于资源的具体操作类型，由HTTP动词表示。

简单借用晨瑞大佬文章中的解释：

GET（SELECT）：从服务器取出资源（一项或多项）。
POST（CREATE）：在服务器新建一个资源。
PUT（UPDATE）：在服务器更新完整资源（客户端提供改变后的完整资源）。
PATCH（UPDATE）：在服务器更新部分资源（客户端提供改变的属性）。
DELETE（DELETE）：从服务器删除资源。

简化一下：

GET：查询
POST：插入、新建
PUT：完全更新
PATCH：部分更新
DELETE：删除

举个栗子：

GET /zoos：获取所有动物园
POST /zoos：新建一个动物园
GET /zoos/ID：获取此ID的动物园信息
PUT /zoos/ID：更新此ID动物园全部信息（提供该动物园的全部信息）
PATCH /zoos/ID：更新此ID动物园部分信息（提供该动物园的部分信息）
DELETE /zoos/ID：删除此ID的动物园信息
GET /zoos/ID/animals：获取此ID动物园的所有动物
DELETE /zoos/ID/animals/ID：删除ID(前者)动物园的ID(后者)动物

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

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

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

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

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

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

总结

1.@Version注解加上后，更新操作一定要带上注解修饰的字段，且要与数据库中的值一致。

2.@CreatedBy和@CreatedDate会在更新时一并更新，需要主动去维护，或者在@Column注解中加上updatable = false，比如这样@Column(name = “CREATED_DATE”,updatable = false)。

jpa 全面学习资料
11-13
jpa 全面学习资料 入门 实战 示例 jpa开发手册 JPA_全面讲解 JPA使用入门_基础 JPA学习笔记 JPA注解 JPA简介
SpringDataJPA学习
01-23
SpringDataJPA学习知识点： 一、SpringDataJPA概述 SpringDataJPA是Spring基于ORM框架、JPA规范的基础上封装的一套JPA应用框架，用于简化JPA编程模式的开发。它不是一个新的JPA规范的实现，而是对现有JPA实现（如...
JPA的学习
weixin_30924087的博客
04-09 113
JPA 1.实体注解 @Entity主键注解 @Id 主键策略@GeneratedValue（strategy=GenerationType.AUTO[IDENTITY,SEQUENCE,TABLE]) auto:根据方言数据库自己选择，默认选项 identity：MySQL支持 sequence：oracle支持@Column(length=32)字段长度 @Temporal(...
JPA 从入门到进阶：Java开发者成长指南
最新发布
kalle2021的博客
01-27 275
本教程专为初级Java开发者打造，详细介绍了JPA的使用，从环境搭建、实体类映射到CRUD操作，助你轻松掌握数据库持久化。通过示例演示如何使用JPA Repository进行查询、分页、事务管理，并介绍了JPQL、懒加载等进阶功能。教程还提供SQL优化、缓存机制等实用技巧，帮助你提升项目性能。无论是入门还是进阶，JPA都能助你实现高效、优雅的数据持久化操作，快来一探究竟吧！
JPA-学习
张十一
12-30 919
JPA-领域建模思想，更加OOP
Jpa学习
weixin_54370926的博客
04-14 288
spring jpa学习路线
JPA学习
qq_36072434的博客
03-20 250
JPA学习 什么是orm object-relational-mapper:对象关系映射，就是建立对象与数据库之间的映射关系，就是orm 对象关系映射可以大大的减少重复性的代码，提高开发效率； 常见的orm框架：hibernate 目的：达到操作类一样操作数据库； 什么是JPA 是sum公司提供的一套持久层操作规范； 底层可以使用hibernate进行数据库操作； JPA入门案例 在META-IN...
Spring Data JPA学习
08-10
Spring Data JPA学习 Spring Data JPA是一个基于Java持久层API（JPA）的存储库实现，它提供了一个简单、统一的方式来访问关系数据库。下面是Spring Data JPA的特征和配置步骤： 一、支持基于Spring和JPA构建存储库...
JPA学习大全.docx
05-14
**JPA学习大全** 在Java开发中，Spring Data JPA是一个强大的工具，它基于ORM（对象关系映射）框架和JPA（Java Persistence API）规范，为开发者提供了一种简化数据库访问和操作的方式。通过使用Spring Data JPA，...
JPA学习笔记（二）——JPA 注解
12-14
`@Entity` 注解用于标记一个Java类为一个实体类，这个类将被JPA用来映射到数据库中的一个表。默认情况下，表名是类名的小写形式，但可以通过`@Table`注解来指定不同的表名。 2. **@Table** `@Table` 注解用来指定...
JPA学习代码资料
06-18
这是一个jpa(hibernate)的学习代码，是我学习JPA的总结，包含三个案例，一对一、一对多、多对多　。　eclipse工具编码为utf-8
JPA(学习)
wflsyf的博客
04-30 195
ORM思想 操作实体类就相当于操作数据库表。 就要建立两个映射关系： 建立实体类和表的关系。 建立实体类中属性和表中字段的关系。 不再关注重点：SQl语句 实现了ORM思想的框架：Mybatis、Hibernate。 配置两个映射关系： @ToString @Data//get和set方法 /** * 注意！！！：导包都是javax.persistence的包 * 1、完成实体类和表的映射关系 * @Entity 声明实体类 * @Table 配置实体类和表的映射关系 * name
JPA学习之路（基础篇）
热门推荐
程序员小王的博客
02-21 1万+
JPA学习之路（基础篇）...
JPA 学习
yujunlong3919的专栏
02-01 323
文章目录AuditingEntityListener AuditorAware EnableJpaAuditing@CreatedDate、@CreatedBy、@LastModifiedDate、@LastModifiedBy说明@MappedSuperclass 用在父类上 防止生成Base表japrespositoryJpaSpecificationExcutor方法命名规则条件查询find一对一一对多多对多查询前6个其他学习mappedby多表查询学习POJO (DO DTO VO)常用注释jack
自学jpa
Logan_addoil的博客
06-24 296
JPA概述 JPA是什么 JPA （Java Persistence API）Java持久化API。是一套Sun公司Java官方制定的ORM 方案,是规范，是标准 ，sun公司自己并没有实现 关注点：ORM ，标准 概念 （关键字） ORM是什么 ORM（Object Relational Mapping）对象关系映射。 问：ORM有什么用？ 在操作数据库之前，先把数据表与实体类关联起...
传智播客JPA学习笔记详解
"这是一份详细的JPA学习笔记，由传智播客的作者mzhj编撰，包含了从基础到高级的多个JPA主题，包括环境搭建、实体映射、主键策略、数据操作、JPQL查询以及各种关联关系的处理。笔记旨在帮助读者深入理解和掌握JPA在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值