JPA repository2023版 复杂查询 简单查询 解放双手

已于 2023-06-14 11:13:03 修改
阅读量1.3k 收藏 5
点赞数
分类专栏： 文章 文章标签： intellij-idea spring boot
于 2023-06-10 18:28:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_59066017/article/details/131144937
版权

目录

简介

入门

      JpaRepository的默认方法

                        自定义的sql语句

进阶

        一对一

        一对多

        多对多

简介

使用JpaRepository不需要在数据库中或者xml中写SQL语句,而是自动帮你实现sql语句

JpaRepository是Spring Data JPA提供的一个接口，它继承了PagingAndSortingRepository和CrudRepository接口，提供了一组通用的CRUD操作方法，包括增删改查等操作。

JpaRepository接口主要提供以下方法：

  • save(S entity): 保存或更新实体对象。
  • findById(ID id): 根据主键查询实体对象。
  • existsById(ID id): 根据主键判断实体对象是否存在。
  • deleteById(ID id): 根据主键删除实体对象。
  • findAll(): 查询所有实体对象。
  • count(): 统计实体对象数量。
  • findAll(Pageable pageable): 分页查询实体对象。
  • findAll(Sort sort): 根据指定属性排序查询实体对象。
  • flush(): 将持久化上下文中的数据强制同步到数据库。
  • saveAll(Iterable<S> entities): 批量保存或更新实体对象。
  • deleteInBatch(Iterable<T> entities): 批量删除实体对象。
  • deleteAllInBatch(): 批量删除所有实体对象。

除了以上方法外，JpaRepository还提供了一系列针对实体类属性的查询方法，例如findByXXX、findAllByXXX等，其中XXX为实体类中的属性名。这些方法都是根据方法名自动生成SQL语句，可以直接使用，无需手动写SQL语句。

同时，JpaRepository还可以与Spring Data JPA中提供的其他功能如动态查询、命名查询等结合使用，以实现更加灵活和复杂的数据操作。

JpaRepository有二种表示形式一种是默认的方法. 另一种是自定义sql语句实现复杂的查询

Spring DataJpa 常用命名汇总

关键字

方法命名

sql where 字句

And

findByNameAndPwd

where name= ? and pwd =?

Or

findByNameOrSex

where name= ? or sex=?

Is,Equals

findById,findByIdEquals

where id= ?

Between

findByIdBetween

where id between ? and ?

LessThan

findByIdBetween

where id < ?

LessThanEqual

findByIdLessThanEqual

where id <= ?

GreaterThan

findByIdGreaterThan

where id > ?

GreaterThanEqual

findByIdGreaterThanEqual

where id > = ?

After

findByIdAfter

where id > ?

Before

findByIdBefore

where id < ?

IsNull

findByNameIsNull

where name is null

isNotNull,NotNull

findByNameNotNull

where name is not null

Like

findByNameLike

where name like ?

NotLike

findByNameNotLike

where name not like ?

StartingWith

findByNameStartingWith

where name like '?%'

EndingWith

findByNameEndingWith

where name like '%?'

Containing

findByNameContaining

where name like '%?%'

OrderBy

findByIdOrderByXDesc

where id=? order by x desc

Not

findByNameNot

where name <> ?

In

findByIdIn(Collection<?> c)

where id in (?)

NotIn

findByIdNotIn(Collection<?> c)

where id not in (?)

True

findByAaaTue

where aaa = true

False

findByAaaFalse

where aaa = false

IgnoreCase

findByNameIgnoreCase

where UPPER(name)=UPPER(?)

入门

创建数据库

select * from user

 select id,login,password,role from user where login = 'spring'
 
 update user set  password ='$2a$10$QVDZ5XXR7XyLMMOCAc4HDOjKV3O5wZiclXUtdAos5NGUCS37U37Uq' where id = 1
 
insert into user (id,login,password,role ) values (12,'ww','$2a$10$QVDZ5XXR7XyLMMOCAc4HDOjKV3O5wZiclXUtdAos5NGUCS37U37Uq','2')

 create table  user(

 id  int   ,  
 login  VARCHAR(100) ,
 `password` VARCHAR(100) ,
 role  VARCHAR(20) 
 )

在yml文件中输入

## spring security??
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/security?useUnicode=true&useSSL=false&characterEncoding=utf-8&serverTimezone=GMT%2B8
    username: root
    password: root
    driver-class-name: com.mysql.cj.jdbc.Driver

第一种: 使用JpaRepository的默认方法

将以下的依赖添加

   <!-- spring Security注解 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>

        <!-- spring data jpa -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>

       <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.17</version>
        </dependency>

创建Dao

/**
 * 用户信息数据库访问接口
 * @author pan_junbiao
 **/
@Repository
public interface UserDao extends JpaRepository<User,Long> {
}

创建Service

/**
 * 用户业务逻辑接口
 * @author pan_junbiao
 **/
public interface UserService
{
    /**
     * 根据用户ID，查询用户信息
     */
      User findById(int userId);

    /**
     * 查询用户列表
     */
      List<User> findAll();

    /**
     * 新增用户
     */
      User save(User userInfo);

    /**
     * 修改用户edit
     */
    User update(User userInfo);

    /**
     * 删除用户
     */
      boolean deleteById(int userId);
}

创建serviceImpl

/**
 * 用户业务逻辑类
 * @author pan_junbiao
 **/
@Service
@Transactional
public class UserServiceImpl implements UserService
{
    @Autowired
    private UserDao userDao;

    /**
     * 根据用户ID，查询用户信息
     */
    @Override
    public User findById(int userId)
    {
        return userDao.findById((long) userId).get();
    } 

    /**
     * 查询用户列表
     */
    @Override
    public List<User> findAll()
    {
        return userDao.findAll();
    }

    /**
     * 新增用户
     */
    @Override
    public User save(User userInfo)
    {
        return userDao.save(userInfo);
    }

    /**
     * 修改用户
     */
    @Override
    public User update(User userInfo)
    {
        return userDao.save(userInfo);
    }

    /**
     * 删除用户
     */
    @Override
    public boolean deleteById(int userId)
    {
        boolean result = true;
        try
        {
            userDao.deleteById((long) userId);
        }
        catch(Exception ex)
        {
            result = false;
        }
        return result;
    }
}

接下来,就可以直接在测试中使用方法

测试: 根据用户id,查询用户信息

   @Autowired
    private UserService userService;

  /**
     * 测试：根据用户ID，查询用户信息
     * @author pan_junbiao
     */
    @Test
    public void findById()
    {
        //查询用户编号为1的用户信息
        User user = userService.f(1);

        if (user != null)
        {
            //打印结果
            System.out.println("用户编号：" + user.getId());
            System.out.println("用户账号：" + user.getLogin());
            System.out.println("用户密码：" + user.getPassword());
            System.out.println("角色：" + user.getRole());
        }
    }

测试: 查询用户列表

    @Autowired
    private UserService userService;

 /**
     * 测试：查询用户列表
     * @author pan_junbiao
     */
    @Test
    public void findAll()
    {
        //查询用户列表
        List<User> userList = userService.findAll();

        if (userList != null && userList.size() > 0)
        {
            for (User user : userList)
            {
                //打印结果
                System.out.println("用户编号：" + user.getId());
                System.out.println("用户账号：" + user.getLogin());
                System.out.println("用户密码：" + user.getPassword());
                System.out.println("角色：" + user.getRole());
                System.out.println("===========================================");
            }
        }
    }

测试: 修改用户

 @Autowired
    private UserService userService;


  /**
     * 测试：修改用户
     * @author pan_junbiao
     */
    @Test
    public void edit()
    {
        //创建修改用户
        User user = new User();
        BCryptPasswordEncoder bCryptPasswordEncoder = new BCryptPasswordEncoder();
        String encode = bCryptPasswordEncoder.encode("qwert");
        boolean matches = bCryptPasswordEncoder.matches("qwert", encode);
        System.out.println(matches);
        user.setId(2L);
        user.setLogin("user");
        user.setPassword(encode);
        user.setRole("ROLE_USER");

        //执行修改操作
        userService.update(user);

        //如果没有抛出异常，则表示执行成功
        System.out.println("修改用户成功");
    }

测试: 新增用户

   @Autowired
    private UserService userService;

/**
     * 测试：新增用户
     * @author pan_junbiao
     */
    @Test
    public void save()
    {
        //创建新用户
        User user = new User();
        BCryptPasswordEncoder bCryptPasswordEncoder = new BCryptPasswordEncoder();
        String encode = bCryptPasswordEncoder.encode("zxcvb");
        user.setId(3L);
        user.setLogin("us");
        user.setPassword(encode);
        user.setRole("ROLE_USER,ROLE_ADMIN");

        //执行新增操作
        userService.save(user);

        //如果新增成功，则可以获取自增主键
        //否则新增失败，则抛出异常
        if (user.getId() > 0)
        {
            System.out.println("新增用户成功，新增的用户信息：");
            System.out.println("用户编号：" + user.getId());
            System.out.println("用户姓名：" + user.getLogin());
            System.out.println("博客地址：" + user.getPassword());
            System.out.println("备注信息：" + user.getRole());
        }
    }

测试: 删除用户

   @Autowired
    private UserService userService;


/**
     * 测试：删除用户
     * @author pan_junbiao
     */
    @Test
    public void deleteById()
    {
        //执行新增操作
        boolean result = userService.deleteById(3);

        //打印结果
        if (result)
        {
            System.out.println("删除用户成功");
        }
        else
        {
            System.out.println("删除用户失败");
        }
    }

第二种方法: 使用自定义的sql语句

跟上面一样,在dao层中继承JpaRepository

/**
 * 用户信息数据库访问接口
 * @author pan_junbiao
 **/
@Repository
public interface UserDao extends JpaRepository<User,Long> {
}

就可以在接口中直接实现了

注意: @Query 在ApaRepository中能自定义sql语句

?1 表示的调用第一个参数 在JpaRepository中不能有对象参数,否则会报错

在增删改中需要添加 @Modifying

  1. @Modifying注解必须与@Transactional注解一起使用，以保证修改操作在一个事务中执行。
  2. @Modifying注解只能用于修改操作，不能用于查询操作。
  3. @Modifying注解只能用于自定义SQL语句，不能用于Spring Data JPA默认生成的查询方法。

测试: 根据id查询

@Repository
public interface UserDao extends JpaRepository<User,Long> {
    @Query(value = "select u.id,u.password,u.login,u.role from user as u where u.id= ?1",nativeQuery = true)
    User find(int id);
}

测试

  @Autowired
    private UserDao dao;

    @Test
    public  void find(){
        User user = dao.find(1);
        if (user != null)
        {
            //打印结果
            System.out.println("用户编号：" + user.getId());
            System.out.println("用户姓名：" + user.getLogin());
            System.out.println("博客地址：" + user.getPassword());
            System.out.println("备注信息：" + user.getRole());
        }
    }

查询全部

@Repository
public interface UserDao extends JpaRepository<User,Long> { 
    @Query(value = "select u.id,u.password,u.login,u.role from user as u ",nativeQuery = true)
    List<User> find1();

}

测试

   @Autowired
    private UserDao dao;

@Test
    public void find1(){
        List<User> userList = dao.find1();

        if (userList != null && userList.size() > 0)
        {
            for (User user : userList)
            {
                //打印结果
                System.out.println("用户编号：" + user.getId());
                System.out.println("用户姓名：" + user.getLogin());
                System.out.println("博客地址：" + user.getPassword());
                System.out.println("备注信息：" + user.getRole());
                System.out.println("===========================================");
            }
        }

    }

新增

@Repository
public interface UserDao extends JpaRepository<User,Long> {
    @Query(value = "insert into user (id,login,password,role ) values (?1,?2,?3,?4)  ",nativeQuery = true)
    @Transactional
    @Modifying
    Integer  insertUser( Long id, String login,String password ,String roel );
}

测试

  @Autowired
    private UserDao dao;

@Test
    public void ss(){
        BCryptPasswordEncoder bCryptPasswordEncoder = new BCryptPasswordEncoder();
        String encode = bCryptPasswordEncoder.encode("zxcvb");
        Integer us = dao.insertUser(4L, "us", encode, "ROLE_USER,ROLE_ADMIN");
        System.out.println(us);
    }

删除

@Repository
public interface UserDao extends JpaRepository<User,Long> {
    @Query(value = "delete from  user where id = ?1",nativeQuery = true)
    @Modifying
    @Transactional
    Integer deleteUser(int id);
}

测试

 @Autowired
    private UserDao dao;

@Test
    public void  as(){
        Integer integer = dao.deleteUser(12);

        if (integer > 0){
            System.out.println("删除成功");
        }else {
            System.out.println("删除失败");
        }

    }

修改

@Repository
public interface UserDao extends JpaRepository<User,Long> {
    @Query(value = "update user set login = ?1 where id= ?2",nativeQuery = true)
    @Transactional
    @Modifying
    Integer UpdateUser(String login,int id);
}

测试

  @Autowired
    private UserDao dao;

@Test
    public void g(){
        Integer integer = dao.UpdateUser("nb", 3);
        if (integer > 0){
            System.out.println("修改成功");
        }else {
            System.out.println("修改失败");
        }

    }

进行到这,已经能基本的使用JapRepository进行数据库的操作

进阶

多表联合查询

  /**
     *      * 当我们创建表结构时，应在多的一方去维护表关系，也就是说，
     *      * 应将@OneToMany注解加在用户表中，并且设置为懒加载。 懒加载 fetch = FetchType.LAZY
     *      * @JsonBackReference 生成json时该属性排除
     */
    // @JsonBackReference注解用于解决Java对象之间的双向关联序列化问题，
    // 当在Java对象之间存在双向关联时，在其中的一端使用@JsonBackReference注解来标记，
    // 告诉Jackson不要序列化该对象的属性。
    // 在这个示例中，因为JpaUser类中也有一个对Role实体类的引用，为了避免序列化时的循环引用问题，
    // 使用@JsonBackReference注解标记JpaUser类中的role属性不需要序列化。
    @JsonBackReference
    // targetEntity属性指定了集合中元素的目标实体类类型
    // cascade属性指定了级联操作类型，包括PERSIST（持久化）、MERGE（合并）和REFRESH（刷新）操作。
    // fetch属性指定了集合的加载方式，这里设置为FetchType.LAZY，表示使用懒加载模式加载集合。
    @OneToMany(targetEntity = JpaUser.class, mappedBy = "role", cascade = {CascadeType.PERSIST, CascadeType.MERGE, CascadeType.REFRESH}, fetch = FetchType.LAZY)

一对一关联

数据库表

创建tab_people

-- 创建“公民信息”数据表
CREATE TABLE IF NOT EXISTS tab_people
( 
	id INT AUTO_INCREMENT PRIMARY KEY COMMENT '公民ID',
	NAME VARCHAR(45) NOT NULL COMMENT '公民名称',
	sex VARCHAR(2) COMMENT '公民性别',
	age INT COMMENT '公民年龄',
	card_id INT UNIQUE COMMENT '身份证ID',
	-- 创建外键约束
	FOREIGN KEY fk_card_id (card_id)
	REFERENCES tab_idcard(id)
 )


INSERT INTO tab_people(NAME,sex,age,card_id) VALUES('良民','男',22,1);

创建tabn_idcard

-- 创建“身份证信息”数据表
CREATE TABLE IF NOT EXISTS tab_idcard
( 
	id INT AUTO_INCREMENT PRIMARY KEY COMMENT '身份证ID',
	idCard_code VARCHAR(45) COMMENT '身份证号码'
)

-- 添加数据
INSERT INTO tab_idcard(idCard_code) VALUE('123456789');

创建实体

JpaUser实体

package com.example.demosecurity.entity;

import lombok.Data;

import javax.persistence.*;
import java.math.BigDecimal;

@Data
// @Entity 表示实体映射到数据库中
@Entity
// 用于表示实体名与数据库名不一致
@Table(name = "tab_people")
public class JpaUser {

    /**
     *  @Id @GeneratedValue @Column 都是JPA的注解用于定义实体类的主键属性和映射到数据库表中的字段属性
     */
    // @Id注解表示标注实体的主键属性 通常和@GeneratedValue注解一起使用
    @Id
    // @GeneratedValue用于指定主键的生成策略 例如: 自增长 UUID 序列等
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    // @Column 指定实体与数据库表中的字段映射例如 字段名 ，长度 是否允许为空
    @Column(name = "id")
    private int id;

    //名称
    @Column(name = "name")
    private String name;

    //性别
    @Column(name = "sex")
    private String sex;

    //年龄
    @Column(name = "age")
    private int age;

    //关联的身份证对象
    @OneToOne(cascade = CascadeType.ALL,fetch = FetchType.LAZY)
    @JoinColumn(name="card_id")
    private IDcard idcard;
}

IDcard实体

package com.example.demosecurity.entity;
import lombok.Data;
import javax.persistence.*;
 

@Data
@Entity
@Table(name = "tab_idcard")
public class IDcard {

    // 身份id
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    private Integer id;

    //身份证号码
    @Column(name = "idcard_code")
    private String idCardCode;
}

创建Dao

package com.example.demosecurity.dao;
import com.example.demosecurity.entity.JpaUser;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

/**
 * 公民信息数据库访问接口
 * @author pan_junbiao
 **/
@Repository
public interface PeopleDao extends JpaRepository<JpaUser,Integer>
{
}

测试

 @Autowired
    private PeopleDao peopleDao;

    /**
     * 一对一新增：新增用户信息与关联的身份证信息
     * @author pan_junbiao
     */
    @Test
    public void addPeopleAndIdcard()
    {
        //创建身份证信息
        IDcard idcard = new IDcard();
        idcard.setIdCardCode("123456789");

        //创建公民信息
        JpaUser people = new JpaUser();
        people.setName("良民");
        people.setSex("男");
        people.setAge(22);
        //将公民与身份证信息关联
        people.setIdcard(idcard);

        //执行新增操作
        peopleDao.save(people);

        //如果新增成功，则可以获取自增主键
        //否则新增失败，则抛出异常
        if(people.getId()>0)
        {
            System.out.println("新增公民信息成功！");
            System.out.println("良民ID：" + people.getId());
            System.out.println("良民名称：" + people.getName());
            System.out.println("身份证号码：" + idcard.getIdCardCode());
        }
    }

一对多关联

在MySQL数据库创建tab_factory表和tab_product表，并添加相关数据

创建tab_factory

-- 创建“生产商信息”数据表
CREATE TABLE IF NOT EXISTS tab_factory
( 
	factory_id INT AUTO_INCREMENT PRIMARY KEY COMMENT '生产商ID',
	NAME VARCHAR(20) NOT NULL COMMENT '生产商名称'
) COMMENT = '生产商信息表';

 
-- 添加数据
INSERT INTO tab_factory(NAME) VALUES('华为公司');

创建tab_product

-- 创建“产品信息”数据表
CREATE TABLE IF NOT EXISTS tab_product
( 
	id INT AUTO_INCREMENT PRIMARY KEY COMMENT '产品ID',
	NAME VARCHAR(20) NOT NULL COMMENT '产品名称',
	price DECIMAL(9,2) NOT NULL COMMENT '产品价格',
	factory_id INT COMMENT '生产商ID'
) COMMENT = '产品信息表';

INSERT INTO tab_product(NAME,price,factory_id) VALUES('华为手机',1299,1);
INSERT INTO tab_product(NAME,price,factory_id) VALUES('华为路由器',699,1);

创建entity Factory

@Data
@Entity
@Table(name = "tab_factory")
public class Factory {

    //生产商ID
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "factory_id")
    private int factoryId;

    //生产商名称
    @Column(name = "name")
    private String name;

    //产品列表
    @OneToMany
    @JoinColumn(name = "factory_id")
    private List<Product> productList;
}

创建 Product

@Data
@Entity
@Table(name = "tab_product")
public class Product {

    //产品ID
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    private int id;

    //产品名称
    @Column(name = "name")
    private String name;

    //产品价格
    @Column(name = "price")
    private BigDecimal price;

    //生产商信息
    @ManyToOne
    @JoinColumn(name = "factory_id")
    private Factory factory;
}

创建Dao

@Repository
public interface ProDao extends JpaRepository<Product,Integer> {
}

@Repository
public interface FactoryDao extends JpaRepository<Factory,Integer> {
}

一对多或多对一 会报如下的错

这是因为我们在添加关联关系时没有添加懒加载和立即加载,可以看到在代码中,我们是一点都没有设置的

这就会导致在如图中的错误,并且可以看到文中已经是获取了一张表的数据,但是获取第二张表时,就报错了,这是因为获取到第一张表时,session就关闭了,当我们再想获取的时候,就会报错

解决办法 : 有二种解决方式:

第一种:

当查询一对多的时候的在@OneToMany中添加立即加载 在@ManyToOne中懒加载

 @OneToMany(cascade = CascadeType.ALL,fetch = FetchType.EAGER)
   @ManyToOne(cascade = CascadeType.ALL,fetch = FetchType.LAZY)

当查询多对一的情况时,则是需要在@ManyToOne中添加立即加载 在OneToMany中懒加载

  @ManyToOne(cascade = CascadeType.ALL,fetch = FetchType.EAGER)
 @OneToMany(cascade = CascadeType.ALL,fetch = FetchType.LAZY)

第二种: 在application.yml配置文件

spring:
   jpa:
     open-in-view: true
     properties:
       hibernate:
         enable_lazy_load_no_trans: true #使用延时加载时控制Session的生命周期

测试

一对多查询

 @Autowired
    private FactoryDao factoryDao;

    /**
     * 一对多查询：获取生产商信息与关联的产品列表
     * @author pan_junbiao
     */
    @Test
    public void getFactoryAndProductList()
    {
        Factory factory = factoryDao.findById(1).get();
        if (factory != null)
        {
            System.out.println("---------------1、生产商信息信息--------------");
            System.out.println("生产商编号：" + factory.getFactoryId());
            System.out.println("生产商名称：" + factory.getName());

            //获取关联的产品信息信息
            System.out.println("---------------2、产品信息信息---------------");
            List<Product> productList = factory.getProductList();
            if(productList!=null && productList.size()>0)
            {
                for(Product product : productList)
                {
                    System.out.println("产品编号：" + product.getId());
                    System.out.println("产品名称：" + product.getName());
                    System.out.println("产品价格：" + product.getPrice());
                    System.out.println("-------------------");
                }
            }
        }
    }

多对一查询

执行多对一时,在关联注解中需要更改

  @Autowired
    private ProDao productDao;

    /**
     * 多对一查询：获取产品信息与关联的生产商信息
     * @author pan_junbiao
     */
    @Test
    public void getProductAndFactory()
    {
        List<Product> productList = productDao.findAll();
        if(productList!=null && productList.size()>0)
        {
            for (Product product : productList)
            {
                //获取产品信息
                System.out.println("产品编号：" + product.getId());
                System.out.println("产品名称：" + product.getName());
                System.out.println("产品价格：" + product.getPrice());

                //获取关联的生产商信息信息
                Factory factory = product.getFactory();
                System.out.println("生产商编号：" + factory.getFactoryId());
                System.out.println("生产商名称：" + factory.getName());
                System.out.println("-------------------");
            }
        }
    }

多对多查询

在MySQL数据库创建用户表（tab_user）、权限表（tab_role）和映射表（tab_mapping），并添加相关数据。

-- 创建“用户信息”数据表
CREATE TABLE IF NOT EXISTS tab_user
( 
	id INT AUTO_INCREMENT PRIMARY KEY COMMENT '用户ID',
	NAME VARCHAR(45) NOT NULL COMMENT '用户名称'
) COMMENT = '用户信息表';
 
-- 创建“权限信息”数据表
CREATE TABLE IF NOT EXISTS tab_role
( 
	id INT AUTO_INCREMENT PRIMARY KEY COMMENT '权限ID',
	role_name VARCHAR(45) NOT NULL COMMENT '权限名称'
) COMMENT = '权限信息表';
 
-- 创建“映射信息”数据表
CREATE TABLE IF NOT EXISTS tab_mapping
( 
	id INT AUTO_INCREMENT PRIMARY KEY COMMENT '映射ID',
	user_id INT COMMENT '用户Id',
	role_id INT COMMENT '权限Id'
) COMMENT = '映射信息表';
 
-- 添加数据
INSERT INTO tab_user(NAME) VALUES('admin'),('pan_junbiao的博客');
INSERT INTO tab_role(role_name) VALUES('系统管理员'),('新闻管理员'),('广告管理员');
INSERT INTO tab_mapping(user_id,role_id) VALUES(1,1),(1,2),(1,3),(2,2),(2,3);


select * from tab_user;
select * from tab_role;
select * from  tab_mapping;

创建Entity

/**
 * 权限信息的持久化类
 * @author pan_junbiao
 **/
@Entity
@Table(name = "tab_role")
@Data
public class Role
{
    //权限ID
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    private int id;

    //权限名称
    @Column(name = "role_name")
    private String roleName;

}

/**
 * 用户信息的持久化类
 * @author pan_junbiao
 **/
@Entity
@Table(name = "tab_user")
@Data
public class UserS
{
    //用户ID
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    private int id;

    //用户名称
    @Column(name = "name")
    private String name;

    //引用的权限实体对象集合
    @ManyToMany(fetch = FetchType.EAGER)
    @JoinTable(name = "tab_mapping",joinColumns = {@JoinColumn(name = "user_id")},inverseJoinColumns = {@JoinColumn(name="role_id")})
    private List<Role> roleList;
}

创建Dao

/**
 * 用户信息数据库访问接口
 * @author pan_junbiao
 **/
@Repository
public interface UserSDao extends JpaRepository<UserS,Integer> {
}

测试

 @Autowired
    private UserSDao userDao;

    /**
     * 多对多查询：获取用户信息与关联的权限列表
     * @author pan_junbiao
     */
    @Test
    public void getUserAndRole()
    {
        List<UserS> userList = userDao.findAll();
        if(userList!=null && userList.size()>0)
        {
            //遍历用户列表
            for(UserS user : userList)
            {
                System.out.println("用户编号：" + user.getId());
                System.out.println("用户名称：" + user.getName());

                //获取权限列表
                List<Role> roleList = user.getRoleList();
                if(roleList!=null && roleList.size()>0)
                {
                    System.out.print("用户拥有的权限：");
                    for (Role role : roleList)
                    {
                        System.out.print(role.getRoleName()+";");
                    }
                }
                System.out.println("\n-----------------------------------------------");
            }
        }
    }

被子不喝酒
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JPA的多表复杂查询的方法示例
08-25
"JPA多表复杂查询方法示例" JPA（Java Persistence API）是一种 Java 应用程序接口，用于访问、持久和管理关系数据库中的数据。在实际开发中，经常需要进行多表复杂查询，以下是JPA多表复杂查询方法示例的详细介绍...
一篇文章带你搞定 JPA 中的复杂查询（JPQL）
南淮北安的博客
07-11 3164
前面我们已经学习了：一篇文章带你搞定如何使用 Jpa 完成数据库的增删改操作 学会了 JPA 的基础操作，本篇文章将向大家讲述 JPA 中的复杂查询操作
jparepository查询所有_JPARepository查询（findby）
weixin_39639622的博客
12-29 1114
JpaRepository的查询image.pngimage.pngSpring Data JPA框架在进行方法名解析时，会先把方法名多余的前缀截取掉，比如 find、findBy、read、readBy、get、getBy，然后对剩下部分进行解析。假如创建如下的查询：findByUserDepUuid()，框架在解析该方法时，首先剔除 findBy，然后对剩下的属性进行解析，假设查询实体为Doc...
【源码】Spring Data JPA原理解析之Repository的自动注入（一）
最新发布
JingAi_jia917的博客
05-14 1057
本篇从源码的角度讲解了Repository接口类如何封装成BeanDefinition，并添加到Spring IOC容器的过程。主要讲解了JpaRepositoryConfigExtension、RepositoryConfigurationExtension、RepositoryConfigurationExtensionSupport、RepositoryComponentProvider、ClassPathScanningCandidateComponentProvider、JpaRepository
SpringData JPA复杂查询二：SQL查询
qq_42041712的博客
07-02 669
SQL查询 1.特有的查询：需要在dao接口上配置方法 2.在新添加的方法上，使用注解的形式配置sql查询语句 3.注解 ： @Query（value=" ", nativeQuery =true||false） nativeQuery ：false（使用jpql查询） | true（使用本地查询：sql查询） /* ...
JPA的Repository详解
三毛村滴雪鱼粉的博客
03-17 3万+
Spring Data JPA Spring Data是Spring提供的操作数据的框架，Spring Data JPA是Spring Data的一个模块，通过Spring data 基于jpa标准操作数据的模块。 Spring Data的核心能力，就是基于JPA操作数据，并且可以简化操作持久层的代码。 它使用一个叫作Repository的接口类为基础，它被定义为访问底层数据模型的超级接口。而对于...
Spring Data JPA 之 JpaRepository
热门推荐
西瓜游侠的博客
04-01 5万+
JpaRepository是Spring提供的非常强大的基本接口。 1 JpaRepository 1.1 JpaRepository接口定义 JpaRepository接口的官方定义如下： public interface JpaRepository&lt;T, ID&gt; extends PagingAndSortingRepository&lt;T, ID&gt;, Q...
jpa repository简介
杂物堆
12-08 2451
有些内置的特殊命名的方法可以直接用：如，find…By/findBy…, read…By, get…By, query…By, search…By, stream…By// 通过UserName去query数据库，并返回UserDO结构的对象 Sort . TypedSort < UserDO > sort = Sort . sort(UserDO . class);
SpringDataJpa：JpaRepository增删改查
卢卢在路上
09-06 4689
Jpa查询 1. JpaRepository简单查询 基本查询也分为两种，一种是spring data默认已经实现，一种是根据查询的方法来自动解析成SQL。 预先生成方法 spring data jpa 默认预先生成了一些基本的CURD的方法，例如：增、删、改等等 继承JpaRepository public interface UserRepository extends JpaRepo......
Spring Data JPA 之如何自定义 Repository
曾小二的博客
07-31 2810
JavaPersistenceAPI规定，操作数据库实体必须要通过EntityManager进⾏，⽽我们前⾯看到了所有的Repository在JPA⾥⾯的实现类是SimpleJpaRepository，它在真正操作实体的时候都是调⽤EntityManager⾥⾯的⽅法。定义⾃⼰的Repository的实现，有以下两种⽅法。我们通过⼀个实例说明⼀下，假设我们要实现⼀个逻辑删除的功能，看看应该怎么做？...
JPA多条件复杂SQL动态分页查询功能
08-25
JPQL是一种基于SQL的查询语言，支持多种查询方式，包括简单查询、复杂查询、分页查询等。下面是一个简单的多条件查询示例： ```java @Entity public class User { @Id @GeneratedValue(strategy = GenerationType....
JPA复杂查询加分页查询的快速开发
03-09
JPA复杂查询加分页查询的快速开发 JPA（Java Persistence API）是 Java 的持久层 API，用于访问、持久化数据。使用 JPA，可以快速开发复杂查询，实现高效的数据访问。下面是 JPA 复杂查询加分页查询的快速开发知识...
Spring Data JPA 复杂/多条件组合分页查询
08-30
在Spring Data JPA中，实现复杂或多条件组合的分页查询是一项常见的任务，这有助于高效地检索和展示大量数据。Spring Data JPA通过提供便捷...这种方法不仅灵活，而且易于维护，使得在处理复杂查询需求时保持代码简洁。
SpringDataJpa开发--继承JpaRepository实现简单条件查询
07-18
SpringDataJpa开发--继承JpaRepository实现简单条件查询示例代码
jpa复杂查询总结
qq_41786090的博客
08-10 949
findByxxx（）findByxxxAndxxxAndxxx...（）nativeQuery = true一定要写，这里写的是sql放到数据库里能直接执行字段和表名对应的都是数据库的字段和表名。2 " +当不写nativeQuery = true时，是hql，对应的字段是实体类的字段和类名其实用jpa主要就是想直接调用规范好的接口，简化开发，但是面试复杂查询时，jpa并不是最好的选择，但是又不得不用jpa的话，我比较倾向于自定义sql的写法，
JpaRepository使用
人生最遗憾的莫过于：轻易地放弃了不该放弃的,固执地坚持了不该坚持的
01-11 4681
Jpa查询 1. JpaRepository简单查询 基本查询也分为两种，一种是spring data默认已经实现，一种是根据查询的方法来自动解析成SQL。 预先生成方法 spring data jpa 默认预先生成了一些基本的CURD的方法，例如：增、删、改等等 继承JpaRepository public interface UserRepository extends JpaRepos...
jpa Repository的常用写法总结
BHSZZY的博客
11-06 1799
之前项目在xml中写sql，感觉标签有很多，比较灵活；最近在写新项目，使用了jpa，只能在java中写sql了，感觉不太灵活，但是也得凑付用。以下总结下常用入参出参写法。
Spring Data JPA中的Repository
aioulaoda的博客
01-12 558
Spring Data JPA中的repository是一种用于访问数据库的接口，它允许开发人员通过方法来执行常见的数据库操作，而不需要编写具体的SQL语句。Repository接口提供了许多内置的方法，如保存、删除、查询等，可以让开发人员更方便地进行数据库操作。这篇文章中我们将讨论：简单来说，Spring Data中的每个repository都继承了Repository接口。
【Spring Data JPA】JpaRepository 增删改查
杜小舟的博客
09-13 4731
基于 JpaRepository 增删改查
JpaRepository简单查询
05-17
JpaRepository是Spring Data JPA提供的一个基于JPA规范的接口，它提供了一些常用的CRUD操作方法，可以方便地进行数据库操作。简单查询可以通过在Repository接口中定义方法来实现。 例如，假设有一个实体类User，它有一个属性name，我们可以通过JpaRepository来查询所有名字为“Tom”的用户。在Repository接口中定义一个方法，如下所示： ```java public interface UserRepository extends JpaRepository<User, Long> { List<User> findByName(String name); } ``` 其中，findByName是自定义的查询方法，它的命名规则是固定的，即以“findBy”开头，后面跟上属性名，例如“findByXXX”，表示根据XXX属性进行查询。在这个例子中，我们以name属性为条件进行查询。 然后在Service中调用这个方法即可： ```java @Service public class UserService { @Autowired private UserRepository userRepository; public List<User> findUserByName(String name) { return userRepository.findByName(name); } } ``` 以上就是使用JpaRepository进行简单查询的示例。除了根据属性查询外，还可以通过“And”、“Or”、“In”等关键字组合条件，实现更加复杂的查询。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值