Jpa3

最新推荐文章于 2022-04-16 01:12:28 发布
最新推荐文章于 2022-04-16 01:12:28 发布
阅读量387 收藏
点赞数 1
分类专栏： java-持久层-JPA 文章标签： jpa3
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/S_L__/article/details/97622656
版权

这里写自定义目录标题

1.单向一对多

1、映射配置：一方配置

@OneToMany
  // 必须配置外键id，否则会多生成一张表，形成多对多的关系
  @JoinColumn(name = "dir_id")
  // 建议实例化，用的时候不需要在实例化，这里和单向多对一要求不同
  private Set<Product> products = new HashSet<Product>();

2、保存代码：我们一般不使用单向一对多(原因:性能太差)

productDir.getProducts().add(product1);
entityManager.persist(product1);
entityManager.persist(product2);
entityManager.persist(productDir);

结论：先保存多方或者一方都会发送给五条sql语句
3条insert,2条update,无论怎样调整保存的顺序,都会有额外的update语句
原因就是现在外键是由一方来处理，一方处理必须发出额外的update语句

3、获取代码：

//得到产品类型
ProductDir productDir = entityManager.find(ProductDir.class, 1L);
//根据产品类型获得产品集合
Set<Product> products = productDir.getProducts();

要通过一方集合属性的size是否为0判断集合是否有值，不能通过集合是否为null来配置，这个和单向多对一是不同的

if (products.size()!=0){
    System.out.println("该产品类型有产品");
}else{
    System.out.println("该产品类型没有产品");
}

4、获取代码细节：

单向一对多，默认是抓取方式是懒加载，但是我们一般使用什么抓取方式还是会配@OneToMany(fetch=FetchType.EAGER)
或者 @OneToMany(fetch=FetchType.LAZY)

2.集合映射

(1)、Hibernate提供的类:实现延迟加载的关键类

org.hibernate.collection.internal.PersistentSet 实现了java.util.Set接口
org.hibernate.collection.internal.PersistentBag 实现了java.util.List接口

(2)、声明集合时必须使用接口接收（Set、List）
java.util.Set对应PersistentSet
java.util.List对应PersistentBag
因为Hibernate在创建了集合对象后是使用了它的的集合类PersistentSet来接收数据的(而不是我们写的那个HashSet)。如果我们使用接口声明(如Set)，那么它的集合类PersistentSet也是实现了这个接口。所以它可以把这个类赋给Set。 但是我们使用HashSet,它们关系是平级的，不能进行转换，所以就出现错误了。

3.双向多对一/双向一对多

3.1.保存数据分析

Product多方

@Entity
@Table(name = "t_product")
public class Product {
    @Id
    @GeneratedValue
    private Long id;
    private String name;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "dir_id")
    private ProductDir dir;

priducrDir一方 // 应该将外键交给多方管理,可以少发sql语句,提高性能

@Entity
@Table(name = "t_productdir")
public class ProductDir {
    @Id
    @GeneratedValue
    private Long id;
    private String name;

    //@JoinColumn(name = "dir_id")		//管理权交给多方后,这里就不需要再配置外键了.
    @OneToMany(mappedBy = "dir")    //mappedBy = "dir"表示一方的关系参照多方Prodcut属性dir来管理
    private Set<Product> products = new HashSet<>();

测试 //还是应该先保存一方,再保存多方,就可只发3条sql语句

@Test
public void testAdd() throws Exception{
    Product product1 = new Product();
    product1.setName("保时捷");
    Product product2 = new Product();
    product2.setName("大切洛斯基");

    ProductDir productDir = new ProductDir();
    productDir.setName("喜欢的汽车");
    //双方关联
    product1.setDir(productDir);
    product2.setDir(productDir);
    productDir.getProducts().add(product1);
    productDir.getProducts().add(product2);

    EntityManager entityManager = JpaUtil.getEntityManager();
    entityManager.getTransaction().begin();
    //先保存一方,再保存多方,就可只发3条sql语句
    entityManager.persist(productDir);
    entityManager.persist(product1);
    entityManager.persist(product2);
    entityManager.getTransaction().commit();
    entityManager.close();
}

3.2.级联保存

(1)概述
级联操作：操作一端的同时，另外一端也会受到级联 (级联的报错和级联删除）
效果:保存商品类别(ProductDir,一方)，就把它对应的商品(Product,多方)也一起保存起来！
关键是只调用一次persist方法
(2)映射配置
一方配置

mappedBy = "dir"表示一方的关系参照多方Prodcut属性dir来管理
cascade 级联操作		属性:ALL所有支持 PERSIST级联保存 REMOVE级联删除 REFRESH 更新
@OneToMany(cascade = CascadeType.PERSIST, mappedBy = "dir")
private Set<Product> products = new HashSet<Product>();

(3)测试代码
//保存

@Test
public void testAdd() throws Exception{
    Product product1 = new Product();
    product1.setName("保时捷");
    Product product2 = new Product();
    product2.setName("大切洛斯基");
    ProductDir productDir = new ProductDir();
    productDir.setName("喜欢的汽车");
    //双方关联
    productDir.getProducts().add(product1);
    productDir.getProducts().add(product2);
    product1.setDir(productDir);
    product2.setDir(productDir);

    EntityManager entityManager = JpaUtil.getEntityManager();
    entityManager.getTransaction().begin();
    //这里只需要保存一方,自自动将关联的数据添加进去
    entityManager.persist(productDir);
    entityManager.getTransaction().commit();
    entityManager.close();
}

发3条sql语句

Hibernate: insert into t_productdir (name) values (?)
Hibernate: insert into t_product (dir_id, name) values (?, ?)
Hibernate: insert into t_product (dir_id, name) values (?, ?)

3.3.其他级联操作相关测试方案
(1)级联删除：删除一方，然后级联删除多方(危险操作)
示例：删除商品分类(ProductDir,一方),它下面的所有商品(Product,多方)都要删除
如果我们直接删除的话，就发现报一个错(外键关系不能删除)
一方配置cascade = CascadeType.REMOVE

@OneToMany(cascade = CascadeType.REMOVE,mappedBy = "dir",fetch = FetchType.LAZY)
private Set<Product> products = new HashSet<>();

测试

@Test
public void testdelect() throws Exception{
    EntityManager entityManager = JpaUtil.getEntityManager();
    entityManager.getTransaction().begin();
    //查询产品分类
    ProductDir productDir = entityManager.find(ProductDir.class, 1L);
    //删除该产品分类的所有关联数据
    entityManager.remove(productDir);
    entityManager.getTransaction().commit();
    entityManager.close();
}

结果

Hibernate: select productdir0_.id as id1_1_0_, productdir0_.name as name2_1_0_ from t_productdir productdir0_ where productdir0_.id=?
Hibernate: select products0_.dir_id as dir_id3_1_0_, products0_.id as id1_0_0_, products0_.id as id1_0_1_, products0_.dir_id as dir_id3_0_1_, products0_.name as name2_0_1_ from t_product products0_ where products0_.dir_id=?
Hibernate: delete from t_product where id=?
Hibernate: delete from t_product where id=?
Hibernate: delete from t_productdir where id=?

(2)从一方去删除一个解除关系(外键的值为null)的多方:先获取一方,在删除一个多方
一方配置

// orphanRemoval=true可以从一方删除解除关系（就是外键dir_id=null）的多方
@OneToMany(cascade = CascadeType.REMOVE,mappedBy = "dir",fetch = FetchType.LAZY,orphanRemoval = true)
private Set<Product> products = new HashSet<>();

测试

@Test
public void testdelect2() throws Exception{
    EntityManager entityManager = JpaUtil.getEntityManager();
    entityManager.getTransaction().begin();
    //查询产品分类
    ProductDir productDir = entityManager.find(ProductDir.class, 1L);
    Product product = entityManager.find(Product.class, 1L);
    // 删除所有和当前对象解除关联关系的对象
    productDir.getProducts().remove(product);
    entityManager.getTransaction().commit();
    entityManager.close();
}

(3)从一方去删除所有解除关系的多方:先获取一方,在删除所有多方
一方配置

// orphanRemoval=true可以从一方删除解除关系（就是外键dir_id=null）的多方
@OneToMany(cascade = CascadeType.REMOVE,mappedBy = "dir",fetch = FetchType.LAZY,orphanRemoval = true)
private Set<Product> products = new HashSet<>();

@Test
public void testdelect3() throws Exception{
    EntityManager entityManager = JpaUtil.getEntityManager();
    entityManager.getTransaction().begin();
    //查询产品分类
    ProductDir productDir = entityManager.find(ProductDir.class, 1L);
    // 删除所有和当前对象解除关联关系的对象
    productDir.getProducts().clear();
    entityManager.getTransaction().commit();
    entityManager.close();
}

3.4.级联操作总结

cascade = CascadeType.ALL
CascadeType.ALL包含级联删除,级联保存,但是是在删除的时候比较危险操作,谨慎操作.

4.单向多对多

(1)配置单向多对多

①Role 角色

@Entity
@Table(name="t_role")
public class Role {
  @Id
  @GeneratedValue
  private Long id;
  private String name;
｝

②User 用户

@Entity
@Table(name = "t_user")
public class User {
    @Id
    @GeneratedValue
    private Long id;
    private String name;
    // 多对多:一个用户拥有多个角色
    //@JoinTable中间表配置  name属性指定中间表名称， joinColumns:列名   inverseJoinColumns:另外一列。
    @ManyToMany
    @JoinTable(name = "t_user_role", joinColumns = { @JoinColumn(name = "user_id") },
            inverseJoinColumns= {@JoinColumn(name = "role_id") })
    private Set<Role> roles = new HashSet<Role>();

会生成一个中间表

(2)保存数据

保存2个用户,保存3个角色(5条)
保存中间表:建立用户到角色关系user1(role1,role2),user2(role1,role2,role3)(5条)

@Test
public void testN() throws Exception{
    //创建3个角色,2个用户
Role role1 = new Role();
    role1.setName("外卖小哥");
    Role role2 = new Role();
    role2.setName("五级演员");
    Role role3 = new Role();
    role3.setName("摄影师");
    User user1 = new User();
    user1.setName("刘星");
    User user2 = new User();
    user2.setName("聂顺");
	//关联
    user1.getRoles().add(role1);
    user1.getRoles().add(role2);
    user1.getRoles().add(role3);
    user2.getRoles().add(role1);
    user2.getRoles().add(role2);
	//添加
    EntityManager entityManager = JpaUtil.getEntityManager();
    entityManager.getTransaction().begin();
    entityManager.persist(user1);
    entityManager.persist(user2);
    entityManager.persist(role1);
    entityManager.persist(role2);
    entityManager.persist(role3);
    entityManager.getTransaction().commit();
    entityManager.close();
}

执行的SQL

Hibernate: insert into t_user (name) values (?)
Hibernate: insert into t_user (name) values (?)
Hibernate: insert into t_role (name) values (?)
Hibernate: insert into t_role (name) values (?)
Hibernate: insert into t_role (name) values (?)
Hibernate: insert into t_user_role (user_id, role_id) values (?, ?)
Hibernate: insert into t_user_role (user_id, role_id) values (?, ?)
Hibernate: insert into t_user_role (user_id, role_id) values (?, ?)
Hibernate: insert into t_user_role (user_id, role_id) values (?, ?)
Hibernate: insert into t_user_role (user_id, role_id) values (?, ?)

(3)获取数据

@Test
public void get() throws Exception {
  EntityManager entityManager = JPAUtils.getEntityManager();
  User user = entityManager.find(User.class, 1L);
  System.out.println(user);
  System.out.println(user.getRoles().getClass());
  //执行到这一步的时候才发送Sql语句，因此也是使用的延时加载
  System.out.println(user.getRoles());
  entityManager.close();
}

5.双向多对多

下面通过案例说明

5.1.常规映射配置

(1)Role 角色

@Entity
@Table(name = "t_role")
public class Role {
  @Id
  @GeneratedValue
  private Long id;
  private String name;
  @ManyToMany
  @JoinTable(name = "t_user_role", joinColumns = { @JoinColumn(name = "role_id") },
inverseJoinColumns= { @JoinColumn(name = "user_id") })
  private Set<User> users = new HashSet<User>();
｝

(2)User 用户

@Entity
@Table(name = "t_user")
public class User {
  @Id
  @GeneratedValue
  private Long id;
  private String name;
  @ManyToMany
  @JoinTable(name = "t_user_role", joinColumns = { @JoinColumn(name = "user_id") }, inverseJoinColumns= {
      @JoinColumn(name = "role_id") })
  private Set<Role> roles = new HashSet<Role>();
｝

5.2.级联保存

(1)User映射配置

@ManyToMany(cascade = CascadeType.PERSIST)

(2)测试代码

// User:@ManyToMany(cascade = CascadeType.PERSIST)
@Test
public void persist2() throws Exception {
  // 保存2个用户,保存3个角色(5条)
  User user1 = new User();
  User user2 = new User();

  Role role1 = new Role();
  Role role2 = new Role();
  Role role3 = new Role();

  // 保存中间表:建立用户到角色关系user1(role1,role2),user2(role1,role2,role3)(5条)
  user1.getRoles().add(role1);
  user1.getRoles().add(role2);

  user2.getRoles().add(role1);
  user2.getRoles().add(role2);
  user2.getRoles().add(role3);

  EntityManager entityManager = JPAUtils.getEntityManager();
  entityManager.getTransaction().begin();

  // 保存用户的同时，级联保存角色
  entityManager.persist(user1);
  entityManager.persist(user2);

  entityManager.getTransaction().commit();
  entityManager.close();
}

5.3.删除user1(由Hibernate自动处理,先删除中间表,再删除user1)

// 注意：User对象是有管理中间表的权限的

@Test
public void delete1() throws Exception {
  EntityManager entityManager = JPAUtils.getEntityManager();
  entityManager.getTransaction().begin();

  User user = entityManager.find(User.class, 1L);
  entityManager.remove(user);

  entityManager.getTransaction().commit();
  entityManager.close();
}

5.4.删除user1的所有包含角色(role1,role2),不能删除user1(只删除中间表)

// 注意：User对象是有管理中间表的权限的

@Test
public void delete2() throws Exception {
  EntityManager entityManager = JPAUtils.getEntityManager();
  entityManager.getTransaction().begin();

  User user = entityManager.find(User.class, 1L);
  user.getRoles().clear();

  entityManager.getTransaction().commit();
  entityManager.close();
}

5.5.删除user1的一个角色,不能删除user1(只删除中间表)

// 注意：User对象是有管理中间表的权限的
@Test
public void delete3() throws Exception {
  EntityManager entityManager = JPAUtils.getEntityManager();
  entityManager.getTransaction().begin();

  User user = entityManager.find(User.class, 1L);
  Role role = entityManager.find(Role.class, 1L);
  user.getRoles().remove(role);

  entityManager.getTransaction().commit();
  entityManager.close();
}

5.6.修改角色:先删除在添加

// 注意：User对象是有管理中间表的权限的
// 关系user1(role1,role2)->关系user1(role1,role3)
@Test
public void delete4() throws Exception {
  EntityManager entityManager = JPAUtils.getEntityManager();
  entityManager.getTransaction().begin();

  User user = entityManager.find(User.class, 1L);
  Role role2 = entityManager.find(Role.class, 2L);
  Role role3 = entityManager.find(Role.class, 3L);
  user.getRoles().remove(role2);
  user.getRoles().add(role3);

  entityManager.getTransaction().commit();
  entityManager.close();
}

5.7.级联删除

(1)一边配置（危险）

// User:@ManyToMany(cascade = CascadeType.REMOVE)
//注意：User对象是有管理中间表的权限的

@Test
public void delete5() throws Exception {
  EntityManager entityManager = JPAUtils.getEntityManager();
  entityManager.getTransaction().begin();

  User user = entityManager.find(User.class, 1L);
  entityManager.remove(user);

  entityManager.getTransaction().commit();
  entityManager.close();
}

注意执行的SQL

Hibernate: delete from t_user_role where user_id=?
Hibernate: delete from t_user_role where role_id=?
Hibernate: delete from t_user_role where role_id=?
Hibernate: delete from t_role where id=?
Hibernate: delete from t_role where id=?
Hibernate: delete from t_user where id=?

(2)二边配置（非常危险）

//User:@ManyToMany(cascade = CascadeType.REMOVE)
//Role:@ManyToMany(cascade = CascadeType.REMOVE)
//注意：User,Role对象是有管理中间表的权限的
  @Test
  public void delete6() throws Exception {
    EntityManager entityManager = JPAUtils.getEntityManager();
    entityManager.getTransaction().begin();

    User user = entityManager.find(User.class, 1L);
    entityManager.remove(user);

    entityManager.getTransaction().commit();
    entityManager.close();
  }
}

注意执行的SQL

Hibernate: delete from t_user_role where user_id=?
Hibernate: delete from t_user_role where role_id=?
Hibernate: delete from t_user_role where role_id=?
Hibernate: delete from t_user_role where user_id=?
Hibernate: delete from t_user_role where role_id=?
Hibernate: delete from t_role where id=?
Hibernate: delete from t_role where id=?
Hibernate: delete from t_user where id=?
Hibernate: delete from t_role where id=?
Hibernate: delete from t_user where id=?
这样删除是非常危险的，容易不小心就把所有数据删除(千万要慎用)
jpa详解
qq_51308214的博客
06-08 8万+
JPA使用
JPA-3 核心API
04-07
**3. `EntityManager`** `EntityManager`是与数据库进行交互的主要接口，它实现了数据的CRUD（创建、读取、更新、删除）操作。`EntityManager`提供了管理实体对象的生命周期方法，如`persist()`, `merge()`, `remove...
JPA进阶二
weixin_45389591的博客
09-21 158
JPA进阶二单向一对多集合映射双向多对一&双向一对多级联操作单向多对多双向多对多一对一 单向一对多 单向一对多是指，由一方来控制外键，多方不管理，这种方法会影响性能，不建议使用 在一方类中定义一个集合Set对象（对象要使用多态的写法，并且加上泛型），然后在其上打上注解@OneToMany表明交给一方来管理外键 @Entity public class Product { @Id @...
jpa Query查询，时间查询，in查询（Spring Data Jpa 3）
热门推荐
water Wang
10-20 6万+
记录下原来用的jpa Query查询； 解决问题：使用Query从entry查询数据填充到DTO；先看entry：package com.test.entity;@Entity @Data public class EntityDemo implements Serializable { private static final long serialVersionUID = 1L; @Col
SpringBoot集成JPA
编码人生
12-17 1919
啦啦啦啦啦，富贵同学又开始开坑了，出了个免费的专栏，主要给用springBoot集成第三方的插件或者功能，如果这篇专栏能帮到你，一定不要忘了点一个赞哦！！欢迎大家收藏分享 发现有些小伙伴不知道JPA和Hibernate有什么区别，在写博客的时候看到有人说集成hibernate，结果进去一看，就是到了一个jpa的包，所以给大家科普一下这两者的区别 JPA和Hibernate之间的主要区别在于JPA是一个规范。Hibernate是Red Hat对JPA规范的实现。所以hibernate的底层也是jpa，而且s
jpa简介
Afu1021的博客
07-20 2485
一、JPA是什么 1、JPA简介 JPA是Java Persistence API的简称，中文名Java持久层API，是JDK 5.0注解或XML描述对象-关系表的映射关系，并将运行期的实体对象持久化到数据库中。 2、JPA 提供商 Hibernate JPA是需要Provider来实现其功能的，Hibernate就是JPA Provider中很强的一个，应该说无人能出其右。从功能上来说，JPA就是Hibernate功能的一个子集。 Spring Spring + Hibernate 常常被称为 Java
12、JPA查询-3种查询方式
红鹰
07-11 5979
JPA查询JPA 3中查询方式案例数据准备1、Entity类型定义2、persistence.xml配置3、初始化查询案例数据查询案例1、JPQL查询2、SQL查询3、命名查询@NamedNativeQuery @NamedQuery3.1、命名查询 JPQL和SQL定义3.2、命名查询案例 JPA 3中查询方式 JPQL 方式查询，表和列名称都是类和字段名称 @Entity 名称 SQL 传统SQL查询 @NamedNativeQuery 和@NamedQuery 命名查询，最大程度复用JPQL或S
jpa使用findById
weixin_49107940的博客
09-03 3745
CrudRepository的高版本没有了findOne方法，改用findById方法 我这里的例子的使用findById方法查询对象，然后判断对象是否存在，再进行删除 第一种 调用findByid方法，返回实体类的Optional，再调用isPresent进行判断是否不为空，若是就调用get获取对象，然后判断对象是否存在，删除 Optional<Permission> permissions = permissionDao.findById(id); if (permissio
Jpa连接oracle
weixin_43472934的博客
06-28 1435
第一步：加入oracle依赖包 第二步：修改配置文件 --修改四要素 第三步：修改pojo实体类 --oralce没有自增长，要达到自增长，需要序列 此处省略了get/set方法的 第四步：测试 @Test public void persist(){ //1.创建实体管理对象 EntityManager entityManager = JpaUtils.createEntityManager(); //2.开启事务 EntityTransaction transact
JPA并发save失效
Planing & Design & Arrange & Do & willWinner
04-16 3842
在并发情况下，剖析 jpa 的工作原理及save失效问题。
Spring与JPA
吃四碗饭的嘤嘤怪的博客
07-01 8227
    这里我主要用Spring Data实现自动化的JPA Repository。package com.zzf.finals.repository; import com.zzf.finals.entity.demo; import org.springframework.data.jpa.repository.JpaRepository; import org.springframewor...
SpringMVC+Spring+SpringDataJPA+Hibernate整合登录的效果
07-13
这是整合SpringMVC+Spring+SpringDataJPA+Hibernate简单的实现登录的功能，用的是mysql数据库，这是一个web Project 如果你用的是JavaEE6那么你要注意bean-validator.jar和weld-osgi-bundle.jar与slf4j的jar包冲突。...
JPA的C3P0的配置
07-01
基于JPA的C3P0连接的配置，里面有详细的jdbc的配置 以及spring整合的配置。
Spring Data JPA中文文档[1.4.3]_springdatajpa_erlang_waitxpf_
10-02
3. **Query Methods**：Spring Data JPA 支持通过方法名自动转换为 JPA 查询。例如，`findAll()` 会执行一个 SELECT ALL 查询，`findByLastname(String lastname)` 会根据指定的姓氏查找用户。此外，还可以使用注解 ...
jpa
03-20
3. **懒加载和即时加载**：通过懒加载机制，可以优化性能，仅在需要时加载关联数据。 4. **级联操作**：允许在操作一个实体时，同时影响到与其关联的其他实体。 5. **多态性**：支持子类继承父类实体，并在数据库中...
【java毕业设计】应急救援物资管理系统源码（springboot+vue+mysql+说明文档）.zip
11-06
项目经过测试均可完美运行！ 环境说明： 开发语言：java jdk：jdk1.8 数据库：mysql 5.7+ 数据库工具：Navicat11+ 管理工具：maven 开发工具：idea/eclipse
基于java的音乐网站答辩PPT.pptx
11-06
基于java的音乐网站答辩PPT.pptx
基于Flexsim的公路交通仿真系统.zip
最新发布
11-06
基于Flexsim软件开发的仿真系统，可供参考学习使用
weixin073智慧旅游平台开发微信小程序+ssm后端毕业源码案例设计.zip
11-06
weixin073智慧旅游平台开发微信小程序+ssm后端毕业源码案例设计 1、资源项目源码均已通过严格测试验证，保证能够正常运行； 2、项目问题、技术讨论，可以给博主私信或留言，博主看到后会第一时间与您进行沟通； 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用，尤其对于人工智能、计算机科学与技术等相关专业，更为适合； 4、下载使用后，可先查看README.md或论文文件（如有），本项目仅用作交流学习参考，请切勿用于商业用途。 5、资源来自互联网采集，如有侵权，私聊博主删除。 6、可私信博主看论文后选择购买源代码。 1、资源项目源码均已通过严格测试验证，保证能够正常运行； 2、项目问题、技术讨论，可以给博主私信或留言，博主看到后会第一时间与您进行沟通； 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用，尤其对于人工智能、计算机科学与技术等相关专业，更为适合； 4、下载使用后，可先查看README.md或论文文件（如有），本项目仅用作交流学习参考，请切勿用于商业用途。 5、资源来自互联网采集，如有侵权，私聊博主删除。 6、可私信博主看论文后选择购买源代码。 1、资源项目源码均已通过严格测试验证，保证能够正常运行； 2、项目问题、技术讨论，可以给博主私信或留言，博主看到后会第一时间与您进行沟通； 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用，尤其对于人工智能、计算机科学与技术等相关专业，更为适合； 4、下载使用后，可先查看README.md或论文文件（如有），本项目仅用作交流学习参考，请切勿用于商业用途。 5、资源来自互联网采集，如有侵权，私聊博主删除。 6、可私信博主看论文后选择购买源代码。
springboot3 JpaRepository
09-18
JpaRepository是Spring Data JPA框架中的一个接口，它提供了一组用于对数据库进行CRUD操作的方法。在Spring Boot中，你可以使用JpaRepository来方便地进行数据库操作。通过继承JpaRepository接口并传递实体类和主键类型作为泛型参数，你就可以自动获得一组常用的数据库操作方法，例如保存、更新、删除和查询等。同时，你还可以使用@Query注解来定义自定义的数据库查询方法。 关于Spring Boot和JpaRepository的整合，可以参考如下步骤： 1. 在pom.xml文件中添加Spring Data JPA的依赖，确保你的项目中已经引入了所需的数据库驱动依赖。 2. 创建一个实体类，并使用注解标识实体类与数据库表的映射关系。 3. 创建一个继承自JpaRepository的接口，并指定实体类和主键类型作为泛型参数。 4. 在接口中定义需要的数据库操作方法，可以使用默认的JpaRepository提供的方法，也可以使用@Query注解定义自定义的查询方法。 5. 在你的业务代码中使用注入的JpaRepository接口来进行数据库操作。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值