一对一的关联关系
 
需求:用户与角色的一对一的关联关系
用户:一方
角色:一方
 
 
创建 Users 实体
@Entity
@Table(name = "t_users")
public class Users implements Serializable { @Id
@GeneratedValue(strategy = GenerationType.IDENTITY)//自增长
@Column(name = "userid")
private Integer userid; private String username; private Integer userage; @OneToOne(cascade = CascadeType.PERSIST)
//@ManyToOne(cascade = CascadeType.PERSIST)
@JoinColumn(name = "fk_roles_id")
private Roles roles;

创建Roles实体

@Entity
@Table(name = "t_roles")
public class Roles { @Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "roleid")
private Integer roleid; @Column(name = "rolename")
private String rolename; @OneToOne(mappedBy = "roles")
private Users users;
一对一关联关系操作
 
com.bjsxt.dao.UserDao
package com.bjsxt.dao;

import com.bjsxt.pojo.Users;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor; public interface UserDao extends JpaRepository<Users,Integer>, JpaSpecificationExecutor<Users> { }

com.bjsxt.test.UserTest

   @Test
public void addUserAndRole(){
Roles roles=new Roles();
roles.setRolename("管理员"); Users users=new Users();
users.setUsername("yxf");
users.setUserage(22); //建立关系
users.setRoles(roles);
roles.setUsers(users); userDao.save(users);
一对多的关联关系
 
需求:从角色到用户的一对多的关联关系
角色:一方
用户:多方
创建 Users 实体
package com.bjsxt.pojo;

import javax.persistence.*;
import java.io.Serializable; @Entity
@Table(name = "t_users")
public class Users implements Serializable { @Id
@GeneratedValue(strategy = GenerationType.IDENTITY)//自增长
@Column(name = "userid")
private Integer userid; private String username; private Integer userage; // @OneToOne(cascade = CascadeType.PERSIST)
@ManyToOne(cascade = CascadeType.PERSIST)
@JoinColumn(name = "fk_roles_id")
private Roles roles;
public Users(){} public Integer getUserid() {
return userid;
} public void setUserid(Integer userid) {
this.userid = userid;
} public String getUsername() {
return username;
} public void setUsername(String username) {
this.username = username;
} public Integer getUserage() {
return userage;
} public void setUserage(Integer userage) {
this.userage = userage;
} public Roles getRoles() {
return roles;
} public void setRoles(Roles roles) {
this.roles = roles;
} public Users(String username, Integer userage, Roles roles) {
this.username = username;
this.userage = userage;
this.roles = roles;
} @Override
public String toString() {
return "Users{" +
"userid=" + userid +
", username='" + username + '\'' +
", userage=" + userage +
", roles=" + roles +
'}';
}
}
创建 Roles 实体
package com.bjsxt.pojo;

import javax.persistence.*;
import java.util.HashSet;
import java.util.Set; @Entity
@Table(name = "t_roles")
public class Roles { @Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "roleid")
private Integer roleid; @Column(name = "rolename")
private String rolename; //@OneToOne(mappedBy = "roles")
//private Users users;
@OneToMany(mappedBy = "roles",cascade = CascadeType.PERSIST)
private Set<Users> users=new HashSet<>(); public Roles(String rolename, Set<Users> users) {
this.rolename = rolename;
this.users = users;
} @Override
public String toString() {
return "Roles{" +
"roleid=" + roleid +
", rolename='" + rolename + '\'' +
", users=" + users +
'}';
} public Integer getRoleid() {
return roleid;
} public void setRoleid(Integer roleid) {
this.roleid = roleid;
} public String getRolename() {
return rolename;
} public void setRolename(String rolename) {
this.rolename = rolename;
} public Set<Users> getUsers() {
return users;
} public void setUsers(Set<Users> users) {
this.users = users;
} public Roles(){} }
一对多的关联关系操作
 @Test
public void addUserAndRole(){
Roles roles=new Roles();
roles.setRolename("班长"); Users users=new Users();
users.setUsername("xm");
users.setUserage(22); Users users1=new Users();
users1.setUsername("hw");
users1.setUserage(23);
Set<Users> set = roles.getUsers(); set.add(users);
set.add(users1); users.setRoles(roles);
users1.setRoles(roles); userDao.save(users);
userDao.save(users1); }
多对多的关联关系
 
需求:一个角色可以拥有多个菜单,一个菜单可以分配多个角色。多对多的关联关系
角色:多方
菜单:多方
创建 Roles 实体
package com.bjsxt.pojo;

import javax.persistence.*;
import java.util.HashSet;
import java.util.Set; @Entity
@Table(name = "t_roles")
public class Roles { @Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "roleid")
private Integer roleid; @Column(name = "rolename")
private String rolename; @ManyToMany(cascade = CascadeType.PERSIST,fetch = FetchType.EAGER)
@JoinTable(name = "t_menus_roles",joinColumns = @JoinColumn(name = "role_id"),inverseJoinColumns = @JoinColumn(name = "menu_id"))
private Set<Menus> menus=new HashSet<>(); public Roles(){} @Override
public String toString() {
return "Roles{" +
"roleid=" + roleid +
", rolename='" + rolename + '\'' +
", menus=" + menus +
'}';
} public Integer getRoleid() {
return roleid;
} public void setRoleid(Integer roleid) {
this.roleid = roleid;
} public String getRolename() {
return rolename;
} public void setRolename(String rolename) {
this.rolename = rolename;
} public Set<Menus> getMenus() {
return menus;
} public void setMenus(Set<Menus> menus) {
this.menus = menus;
} public Roles(String rolename, Set<Menus> menus) {
this.rolename = rolename;
this.menus = menus;
}
}
创建 Menus 实体
package com.bjsxt.pojo;

import javax.persistence.*;
import java.util.HashSet;
import java.util.Set; @Entity
@Table(name = "t_menus")
public class Menus { @Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "menusid")
private Integer menusid; @Column(name = "menusname")
private String menusname; @Column(name = "menusurl")
private String menusurl; @Column(name = "fatherid")
private Integer fatherid; @ManyToMany(mappedBy = "menus")
private Set<Roles> roles=new HashSet<>(); public Menus(){} @Override
public String toString() {
return "Menus{" +
"menusid=" + menusid +
", menusname='" + menusname + '\'' +
", menusurl='" + menusurl + '\'' +
", fatherid=" + fatherid +
", roles=" + roles +
'}';
} public Integer getMenusid() {
return menusid;
} public void setMenusid(Integer menusid) {
this.menusid = menusid;
} public String getMenusname() {
return menusname;
} public void setMenusname(String menusname) {
this.menusname = menusname;
} public String getMenusurl() {
return menusurl;
} public void setMenusurl(String menusurl) {
this.menusurl = menusurl;
} public Integer getFatherid() {
return fatherid;
} public void setFatherid(Integer fatherid) {
this.fatherid = fatherid;
} public Set<Roles> getRoles() {
return roles;
} public void setRoles(Set<Roles> roles) {
this.roles = roles;
} public Menus(String menusname, String menusurl, Integer fatherid, Set<Roles> roles) {
this.menusname = menusname;
this.menusurl = menusurl;
this.fatherid = fatherid;
this.roles = roles;
}
}
多对多关联关系操作
package com.bjsxt.test;

import com.bjsxt.dao.RolesDao;
import com.bjsxt.pojo.Menus;
import com.bjsxt.pojo.Roles;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; import java.util.Set; @RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class RolesTest { @Autowired
private RolesDao rolesDao; @Test
public void addRoles(){
Roles roles=new Roles();
roles.setRolename("超级管理员"); Menus menus1=new Menus();
menus1.setFatherid(-1);
menus1.setMenusname("***管理系统");
menus1.setMenusurl(null); Menus menus2=new Menus();
menus2.setFatherid(1);
menus2.setMenusname("用户管理");
menus2.setMenusurl(null); roles.getMenus().add(menus1);
roles.getMenus().add(menus2);
menus1.getRoles().add(roles);
menus2.getRoles().add(roles); rolesDao.save(roles);
} @Test
public void findall(){
Roles roles = rolesDao.findOne(10);
System.out.println("角色信息:"+roles);
Set<Menus> menus = roles.getMenus();
for (Menus menu : menus) {
System.out.println("菜单信息:"+menu); }
}
}

Spring Data JPA 的一对多,一对多,多对多操作的更多相关文章

  1. [Z]Spring Data JPA 之 一对一,一对多,多对多 关系映射

    一.@OneToOne关系映射 JPA使用@OneToOne来标注一对一的关系. 实体 People :用户. 实体 Address:家庭住址. People 和 Address 是一对一的关系. 这 ...

  2. Spring Data JPA 之 一对一,一对多,多对多 关系映射

    一.@OneToOne关系映射 JPA使用@OneToOne来标注一对一的关系. 实体 People :用户. 实体 Address:家庭住址. People 和 Address 是一对一的关系. 这 ...

  3. Spring Data Jpa系列教程--------实体解析和关联关系

    Spring Data Jpa是基于HIbernate开发的,所以建立实体建的实体和映射关系需要好好好的去了解一下,本文有以下内容,实体管理器介绍,实体与数据库表的映射介绍,关联关系(一对多,多对多) ...

  4. Spring Data JPA入门及深入

    一:Spring Data JPA简介 Spring Data JPA 是 Spring 基于 ORM 框架.JPA 规范的基础上封装的一套JPA应用框架,可使开发者用极简的代码即可实现对数据库的访问 ...

  5. Spring Data JPA在Spring Boot中的应用

    1.JPA JPA(Java Persistence API)是Sun官方提出的Java持久化规范.它为Java开发人员提供了一种对象/关联映射工具来管理Java应用中的关系数据.他的出现主要是为了简 ...

  6. SpringBoot入门:Spring Data JPA 和 JPA(理论)

    参考链接: Spring Data JPA - Reference Documentation Spring Data JPA--参考文档 中文版 纯洁的微笑:http://www.ityouknow ...

  7. 【ORM框架】Spring Data JPA(一)-- 入门

    本文参考:spring Data JPA入门   [原创]纯干货,Spring-data-jpa详解,全方位介绍  Spring Data JPA系列教程--入门 一.Spring Data JPA介 ...

  8. 展开被 SpringBoot 玩的日子 《 五 》 spring data jpa 的使用

    在上篇文章< 展开被 SpringBoot 玩的日子 < 二 >WEB >中简单介绍了一下spring data jpa的基础性使用,这篇文章将更加全面的介绍spring da ...

  9. spring-boot (三) spring data jpa

    学习文章来自:http://www.ityouknow.com/spring-boot.html spring data jpa介绍 首先了解JPA是什么? JPA(Java Persistence ...

  10. spring data jpa 全面解析(实践 + 源码分析)

    前言 本文将从示例.原理.应用3个方面介绍spring data jpa. 以下分析基于spring boot 2.0 + spring 5.0.4版本源码 概述 JPA是什么? JPA (Java ...

随机推荐

  1. 深入理解@LoadBalanced注解的实现原理与客户端负载均衡

    前提 在阅读这篇博客之前,希望你对SpringCloud套件熟悉和理解,更希望关注下微服务开发平台 概述 在使用springcloud ribbon客户端负载均衡的时候,可以给RestTemplate ...

  2. JAVA项目打包成可运行的exe程序

    前言:本篇文章为原创,转载请注明地址,谢谢. 我们一些时候,可能需要需要把我们完成的java打包,打成jar文件或者exe文件.这时候就请鄙人的这篇文章. 言尽于此,Let‘s go! 一.导出jar ...

  3. js获取文件里面的所有文件名

    <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/ ...

  4. C++中对C的扩展学习新增语法——作用域运算符::

    作用域运算符用来告诉编译器在哪个作用域范围搜索符号,一般分为以下3种: 全局作用域: 命名空间作用域: 类作用域:

  5. ThinkPHP 怎样让URL访问的时候省略 index.php

    ThinkPHP 怎样让URL访问的时候省略 index.php Nginx 服务器配置 修改 nginx.conf 文件 location / { // …..省略部分代码 if (!-e $req ...

  6. 关键路径法(Critical Path Method, CPM)

    1.活动节点描述及计算公式 通过分析项目过程中哪个活动序列进度安排的总时差最少来预测项目工期的网络分析. 产生目的:为了解决,在庞大而复杂的项目中,如何合理而有效地组织人力.物力和财力,使之在有限资源 ...

  7. 力扣(LeetCode)三个数的最大乘积 个人题解

    给定一个整型数组,在数组中找出由三个数组成的最大乘积,并输出这个乘积. 示例 1: 输入: [1,2,3] 输出: 6 示例 2: 输入: [1,2,3,4] 输出: 24 注意: 给定的整型数组长度 ...

  8. 领扣(LeetCode)单词模式 个人题解

    给定一种 pattern(模式) 和一个字符串 str ,判断 str 是否遵循相同的模式. 这里的遵循指完全匹配,例如, pattern 里的每个字母和字符串 str 中的每个非空单词之间存在着双向 ...

  9. python容器类型元组的操作

    元组:使用小括号进行表示一组元素,其元素与元素之间使用逗号隔开:注意:元组的的值是不可修改的: 1.元组值得增加:元组是不可以直接增加值的,但是可以通过+进行拼接 # 声明一个元组: tuple1 = ...

  10. 5分钟上手自动化测试——Airtest+Poco快速上手

    版权声明:该文章为AirtestProject原创文章:允许转载,但转载必须注明“转载”并保留原链接 前言 本文档将演示使用`AirtestProject`专用的编辑器AirtestIDE,编写`Ai ...