JPA作持久层操作（java持久层技术）

2023-03-23 02:34:11 分类：java 阅读()

　　本篇文章为你整理了JPA作持久层操作（java持久层技术）的详细内容，包含有jpa持久化 java持久层技术 jpa持久化管理器是哪个类 java持久层框架对比 JPA作持久层操作，希望能帮助你了解 JPA作持久层操作。

　　 JPA是Java Persistence API的简称，中文名Java持久层API，是JDK 5.0注解或XML描述对象－关系表的映射关系，并将运行期的实体对象持久化到数据库中。

　　
jpa是对实体类操作，从而通过封装好的接口直接设置数据库的表结构。虽然jpa可以直接通过编写java代码来操作数据库表结构，避免了sql的编写，但别忘了需要先建立jpa需要操作的数据库并更改配置文件到该数据库，jpa不能建库！！！

　　国外比较流行jpa，国内更加流行mybatis，因为mybatis直接操作数据库容易懂和后期维护一点。（其实是国内程序员乱搞，国外的比较有规矩）

　　本文只介绍了jpa的基本使用操作以及基本语法

　　JPA VS Mybatis

　　大项目用mybatis，小项目（微服务：小程序等）用JPA （JPA方便，但大项目到后期需要从sql语句上优化时JPA无法优化）

　　JPA操作

　　jpa是javax包下的，所以后面导包的时候注意一下，别导错了。只有事务、Param的导包是导spring框架下的

　　

 dependency

 

　　 groupId org.springframework.boot /groupId

　　 artifactId spring-boot-starter-data-jpa /artifactId

　　 /dependency

　　

 

　　设置配置yaml

　　

spring:

 

　　 jpa:

　　 #开启SQL语句执行日志信息

　　 show-sql: true //生产环境下就改成false吧，true没必要

　　 hibernate:

　　 #配置为自动创建

　　 ddl-auto: update

　　

 

　　创建实体类

　　

@Data

 

　　@Entity //表示这个类是一个实体类 javax包下的

　　@Table(name = "users") //对应的数据库中表名称 javax包下的

　　public class Account {

　　 @GeneratedValue(strategy = GenerationType.IDENTITY) //生成策略，这里配置为自增

　　 @Column(name = "id") //对应表中id这一列

　　 @Id //此属性为主键

　　 int id;

　　 @Column(name = "username") //对应表中username这一列

　　 String username;

　　 @Column(name = "password") //对应表中password这一列

　　 String password;

　　

 

　　创建repo包，建Repository类

　　
每一个表都要设置相应的Repository实现类，service层可以通过该类对象操作数据库（因为该类封装了操作数据库的方法集）

　　如果需要的操作没有被封装，还可以在Repository类中用已经封装的方法自定义新的方法（自定义规则在下面）

　　注：JpaRepository有两个泛型，前者是具体操作的对象实体，也就是对应的表，后者是ID的类型

　　

@Repository //别忘了注入bean

 

　　public interface AccountRepository extends JpaRepository Account, Integer { // A,B A中是表的实体类，B是ID的类型

　　

 

　　调用方法执行sql

　　

@Resource

 

　　AccountRepository accountRepository;

　　
void pageAccountService() {

　　 accountRepository.findById(1).ifPresent(System.out::println);

　　

 

　　在Repository中根据方法名称拼接自定义sql

　　例子：

　　repository：

　　

@Repository

 

　　public interface AccountRepository extends JpaRepository Account, Integer {

　　 Account findByIdAndUsername(int id, String username);

　　 //可以使用Optional类进行包装，Optional Account findByIdAndUsername(int id, String username);

　　 //方法名称拼接自定义模糊查询

　　 List Account findAllByUsernameLike(String str);

　　

 

　　service：

　　

@Resource

 

　　AccountRepository accountRepository;

　　
void pageAccountService(String str) {

　　 accountRepository.findAllByUsernameLike("%str%").forEach(System.out::println); //不建议这种模糊查询，建议用原生sql的concat，以免sql注入

　　

 

　　方法拼接规则：

　　虽然接口预置的方法使用起来非常方便，但是如果我们需要进行条件查询等操作或是一些判断，就需要自定义一些方法来实现，同样的，我们不需要编写SQL语句，而是通过方法名称的拼接来实现条件判断，这里列出了所有支持的条件判断名称：

　　
findDistinctByLastnameAndFirstname

　　select distinct … where x.lastname = ?1 and x.firstname = ?2

　　


@Repository

 

　　public interface AccountRepository extends JpaRepository Account, Integer {

　　 @Transactional //DML操作需要事务环境，可以不在这里声明在方法前声明，但是调用时一定要处于事务环境下

　　 @Modifying //表示这是一个DML操作

　　 @Query("update Account set password = ?2 where id = ?1") //这里操作的是一个实体类对应的表，参数使用?代表，后面接第n个参数

　　 int updatePasswordById(int id, String newPassword);

　　 //@Query("update Account set password = :password where username = :name") 这样写也可以

　　 int updatePasswordByUsername(@Param("name") String username, //我们可以使用@Param指定名称

　　 @Param("password") String newPassword);

　　

 

　　

@Test

 

　　void updateAccount(){

　　 repository.updatePasswordById(1, "654321");

　　

 

　　原生SQL直接操作数据库

　　实现根据用户名称修改密码：

　　

@Transactional

 

　　@Modifying

　　@Query(value = "update users set password = :password where username = :name", nativeQuery = true) //使用原生SQL，除了占位符不同其他和Mybatis一样，这里使用 :名称 表示参数，当然也可以继续用上面那种方式。

　　int updatePasswordByUsername(@Param("name") String username, //我们可以使用@Param指定名称

　　 @Param("password") String newPassword);

　　

 

　　

@Test

 

　　void updateAccount(){

　　 repository.updatePasswordByUsername("Admin", "654321");

　　

 

　　JPA关联查询

　　对一：会在写了注解（@OneToOne @MangToOne）的类中创建字段。对多：需要多的那方原本就有字段，才可以用该字段对应注解这方的主键

　　而用户信息和用户详细信息之间形成了一对一的关系，那么这时我们就可以直接在类中指定这种关系：

　　

@Data

 

　　@Entity

　　@Table(name = "users")

　　public class Account {

　　 @GeneratedValue(strategy = GenerationType.IDENTITY)

　　 @Column(name = "id")

　　 int id;

　　 @Column(name = "username")

　　 String username;

　　 @Column(name = "password")

　　 String password;

　　 @JoinColumn(name = "detail_id") //指定存储外键的字段名称。在本表中创建detail_id，并外键连接AccountDetail表的主键id

　　 @OneToOne //声明为一对一关系

　　 AccountDetail detail;

　　 //执行代码：alter table users add constraint xxxxx foreign key (detail_id) references users_detail (id)

　　

 

　　在修改实体类信息后，我们发现在启动时也进行了更新，日志如下：

　　

Hibernate: alter table users add column detail_id integer

 

　　Hibernate: create table users_detail (id integer not null auto_increment, address varchar(255), email varchar(255), phone varchar(255), real_name varchar(255), primary key (id)) engine=InnoDB

　　Hibernate: alter table users add constraint FK7gb021edkxf3mdv5bs75ni6jd foreign key (detail_id) references users_detail (id)

　　

 

　　测试查询：

　　

@Test

 

　　void pageAccount() {

　　 repository.findById(1).ifPresent(System.out::println);

　　

 

　　结果：在建立关系之后，我们查询Account对象时，会自动将关联数据的结果也一并进行查询。

　　

Hibernate: select account0_.id as id1_0_0_, account0_.detail_id as detail_i4_0_0_, account0_.password as password2_0_0_, account0_.username as username3_0_0_, accountdet1_.id as id1_1_1_, accountdet1_.address as address2_1_1_, accountdet1_.email as email3_1_1_, accountdet1_.phone as phone4_1_1_, accountdet1_.real_name as real_nam5_1_1_ from users account0_ left outer join users_detail accountdet1_ on account0_.detail_id=accountdet1_.id where account0_.id=?

 

　　Account(id=1, username=Test, password=123456, detail=AccountDetail(id=1, address=四川省成都市青羊区, email=8371289@qq.com, phone=1234567890, realName=本伟))

　　

 

　　不想加载外键表的信息时，可以设置懒加载，这样只有在需要时才会向数据库获取：

　　设置懒加载后，使用懒加载设置过的属性时的方法需要在事务环境下获取（因为repository方法调用完后Session会立即关闭

　　

@JoinColumn(name = "detail_id")

 

　　@OneToOne(fetch = FetchType.LAZY) //将获取类型改为LAZY

　　AccountDetail detail;

　　

 

　　接着我们测试一下：（测试类里开启事务会自动回滚，不想回滚则在方法前加@Commit。当然毕竟是测试类还是建议保留自动回滚）

　　

@Transactional //懒加载属性需要在事务环境下获取，因为repository方法调用完后Session会立即关闭

 

　　@Test

　　void pageAccount() {

　　 repository.findById(1).ifPresent(account - {

　　 System.out.println(account.getUsername()); //获取用户名

　　 System.out.println(account.getDetail()); //获取详细信息（懒加载）

　　

 

　　接着我们来看看控制台输出了什么：可以看到，获取用户名之前，并没有去查询用户的详细信息，而是当我们获取详细信息时才进行查询并返回AccountDetail对象。

　　

Hibernate: select account0_.id as id1_0_0_, account0_.detail_id as detail_i4_0_0_, account0_.password as password2_0_0_, account0_.username as username3_0_0_ from users account0_ where account0_.id=?

 

　　Hibernate: select accountdet0_.id as id1_1_0_, accountdet0_.address as address2_1_0_, accountdet0_.email as email3_1_0_, accountdet0_.phone as phone4_1_0_, accountdet0_.real_name as real_nam5_1_0_ from users_detail accountdet0_ where accountdet0_.id=?

　　AccountDetail(id=1, address=四川省成都市青羊区, email=8371289@qq.com, phone=1234567890, realName=卢本)

　　

 

　　关联表之间操作一致

　　【提前更改实体类的设定】

　　

@JoinColumn(name = "detail_id")

 

　　@OneToOne(fetch = FetchType.LAZY, cascade = CascadeType.ALL) //设置关联操作为ALL

　　AccountDetail detail;

　　

 

　　ALL：所有操作都进行关联操作

　　PERSIST：插入操作时才进行关联操作

　　REMOVE：删除操作时才进行关联操作

　　MERGE：修改操作时才进行关联操作

　　可以多个并存，接着我们来进行一下测试：

　　

@Test

 

　　void addAccount(){

　　 Account account = new Account();

　　 account.setUsername("Nike");

　　 account.setPassword("123456");

　　 AccountDetail detail = new AccountDetail();

　　 detail.setAddress("重庆市渝中区解放碑");

　　 detail.setPhone("1234567890");

　　 detail.setEmail("73281937@qq.com");

　　 detail.setRealName("张三");

　　 account.setDetail(detail);

　　 account = repository.save(account); //记得用repository保存

　　 System.out.println("插入时，自动生成的主键ID为："+account.getId()+"，外键ID为："+account.getDetail().getId());

　　

 

　　可以看到日志结果：结束后会发现数据库中两张表都同时存在数据。

　　

Hibernate: insert into users_detail (address, email, phone, real_name) values (?, ?, ?, ?)

 

　　Hibernate: insert into users (detail_id, password, username) values (?, ?, ?)

　　插入时，自动生成的主键ID为：6，外键ID为：3

　　

 

　　接着我们来看一对多关联，比如每个用户的成绩信息：

　　

Account类：

 

　　@JoinColumn(name = "uid") //注意这里的name指的是Score表中的uid字段对应的就是当前的主键，会将uid外键设置为当前的主键

　　//执行的语句为：alter table account_score add constraint xxxxx foreign key (uid) reference account(id)

　　@OneToMany(fetch = FetchType.LAZY,cascade = CascadeType.ALL) //在移除Account时，一并移除所有的成绩信息，依然使用懒加载

　　List Score scoreList;

　　

 

　　

@Data

 

　　@Entity

　　@Table(name = "users_score") //成绩表，注意只存成绩，不存学科信息，学科信息id做外键

　　public class Score {

　　 @GeneratedValue(strategy = GenerationType.IDENTITY)

　　 @Column(name = "id")

　　 int id;

　　 @OneToOne //一对一对应到学科上

　　 @JoinColumn(name = "cid")

　　 Subject subject;

　　 @Column(name = "socre")

　　 double score;

　　 @Column(name = "uid")

　　 int uid;

　　

 

　　

@Data

 

　　@Entity

　　@Table(name = "subjects") //学科信息表

　　public class Subject {

　　 @GeneratedValue(strategy = GenerationType.IDENTITY)

　　 @Column(name = "cid")

　　 int cid;

　　 @Column(name = "name")

　　 String name;

　　 @Column(name = "teacher")

　　 String teacher;

　　 @Column(name = "time")

　　 int time;

　　

 

　　在数据库中填写相应数据，接着我们就可以查询用户的成绩信息了：成功得到用户所有的成绩信息，包括得分和学科信息。

　　

@Transactional

 

　　@Test

　　void test() {

　　 repository.findById(1).ifPresent(account - {

　　 account.getScoreList().forEach(System.out::println);

　　

 

　　同样的，我们还可以将对应成绩中的教师信息单独分出一张表存储，并建立多对一的关系，因为多门课程可能由同一个老师教授：

　　

Subjects表：

 

　　@ManyToOne(fetch = FetchType.LAZY)

　　@JoinColumn(name = "tid") //存储教师ID的字段，和一对一是一样的，也会在当前表中创个外键tid,对应Teacher表的主键

　　Teacher teacher;

　　//执行的代码：

　　//alter table subjects add colunm tid integer

　　//alter table subjects add constraint xxxxx foreign key(tid) reference teachers (id)

　　

 

　　接着就是教师实体类了：

　　

@Data

 

　　@Entity

　　@Table(name = "teachers")

　　public class Teacher {

　　 @Column(name = "id")

　　 @GeneratedValue(strategy = GenerationType.IDENTITY)

　　 int id;

　　 @Column(name = "name")

　　 String name;

　　 @Column(name = "sex")

　　 String sex;

　　

 

　　最后我们再进行一下测试：

　　

@Transactional

 

　　@Test

　　void test() {

　　 repository.findById(3).ifPresent(account - {

　　 account.getScoreList().forEach(score - {

　　 System.out.println("课程名称："+score.getSubject().getName());

　　 System.out.println("得分："+score.getScore());

　　 System.out.println("任课教师："+score.getSubject().getTeacher().getName());

　　

 

　　成功得到多对一的教师信息。

　　最后我们再来看最复杂的情况，现在我们一门课程可以由多个老师教授，而一个老师也可以教授多个课程，那么这种情况就是很明显的多对多场景，现在又该如何定义呢？我们可以像之前一样，插入一张中间表表示教授关系，这个表中专门存储哪个老师教哪个科目：

　　

Subjects表：

 

　　@ManyToMany(fetch = FetchType.LAZY) //多对多场景

　　//注意此操作，最后只会在该表多一个字段，和一个中间表，不会在另一个表中多一个字段。需要编写类似代码才会出现

　　@JoinTable(name = "teach_relation", //多对多中间关联表

　　 joinColumns = @JoinColumn(name = "cid"), //当前实体主键在关联表中的字段名称

　　 inverseJoinColumns = @JoinColumn(name = "tid") //教师实体主键在关联表中的字段名称，并在当前表中创建tid字段作为外键连接关联表的tid

　　List Teacher teacher;

　　

 

　　接着，JPA会自动创建一张中间表，并自动设置外键，我们就可以将多对多关联信息编写在其中了。

　　以上就是JPA作持久层操作（java持久层技术）的详细内容，想要了解更多 JPA作持久层操作的内容，请持续关注盛行IT软件开发工作室。

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。

标签： java

相关文章阅读

  • java Springboot集成mybatis-plus的方法是什么
  • 浅谈几种Java自定义异常处理方式
  • Java Map所有的值转为String类型
  • java代码中格式化金额 java格式化小数
  • java计算器源代码资源 java计算器简单代码
  • 【java】（一）SpringBoot 源码解析——SpringApplication 初始化（）
  • Spring学习笔记（spring教程 csdn）
  • HDFS Architecture Guide（）
  • 哈工大软件构造Lab3（2022）（哈工大软件构造lab3）
  • nginx基础（nginx基础教程）
  • Java 中HashMap详解(含HashTable, ConcurrentHashMap)（java hashmap使用方法）
  • Java 线程池之Jetty 线程池学习总结（java线程池的使用方法）
  • java线程基础（java 线程教程）
  • 聊聊 Netty 那些事儿之 Reactor 在 Netty 中的实现(创建篇)（）
  • nginx（nginx负载均衡）
    • 留言与评论（共有 条评论）
       
    验证码：