目录
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
- @Modifying注解必须与@Transactional注解一起使用,以保证修改操作在一个事务中执行。
- @Modifying注解只能用于修改操作,不能用于查询操作。
- @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-----------------------------------------------");
}
}
}