标签：允许 user set 查询 用户表 done 双向 autowired cad
一对多：
示例：客户和联系人关系
在实体类中，由于客户是少的一方，它应该包含多个联系人，所以实体类要体现出客户中有多个联系人的信息
/** * 客户的实体类 */ @Entity @Table(name = "cst_customer") public class Customer implements Serializable { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) @Column(name = "cust_id") private Long custId; @Column(name = "cust_name") private String custName; @Column(name = "cust_source") private String custSource; @Column(name = "cust_industry") private String custIndustry; @Column(name = "cust_level") private String custLevel; @Column(name = "cust_address") private String custAddress; @Column(name = "cust_phone ") private String custPhone; // @OneToMany(targetEntity = LinkMan.class, fetch = FetchType.LAZY) // @JoinColumn(name = "lkm_cust_id", referencedColumnName = "cust_id") /** * 放弃外键维护权 * mappedBy: 对方配置关系的属性名称 * cascade: 配置级联（可以配置到设置多表的映射关系的注解上） * CascadeType.all : 所有 * MERGE ：更新 * PERSIST ：保存 * REMOVE ：删除 * fetch : 配置关联对象的加载方式 * EAGER ：立即加载 * LAZY ：延迟加载 */ @OneToMany(mappedBy = "customer") private Set<LinkMan> linkMans = new HashSet<>(0); /************************ get/set方法 ************************/ }
由于联系人是多的一方，在实体类中要体现出，每个联系人只能对应一个客户
/** * 联系人实体类 */ @Entity @Table(name = "cst_linkman") public class LinkMan { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) @Column(name = "lkm_id") private Long lkmId; @Column(name = "lkm_name") private String lkmName; @Column(name = "lkm_gender") private String lkmGender; @Column(name = "lkm_phone") private String lkmPhone; @Column(name = "lkm_mobile") private String lkmMobile; @Column(name = "lkm_email") private String lkmEmail; @Column(name = "lkm_position") private String lkmPosition; @Column(name = "lkm_memo") private String lkmMemo; /** * 配置联系人到客户的多对一关系 * 使用注解的形式配置多对一关系 * 1.配置表关系 * @ManyToOne : 配置多对一关系 * targetEntity：对方的实体类字节码 * 2.配置外键（多对多配置中间表） * 配置外键的过程，配置到了多的一方，就会在多的一方维护外键 */ @ManyToOne(targetEntity = Customer.class) @JoinColumn(name = "lkm_cust_id",referencedColumnName = "cust_id") private Customer customer; /************************ get/set方法 ************************/ }
持久层接口
/** * 客户持久层接口 * JpaRepository<实体类类型，主键类型>：用来完成基本CRUD操作 * JpaSpecificationExecutor<实体类类型>：用于复杂查询（分页等查询操作） */ public interface CustomerDao extends JpaRepository<Customer, Long>, JpaSpecificationExecutor<Customer> { }
/** * 联系人持久层接口 */ public interface LinkManDao extends JpaRepository<LinkMan, Long>, JpaSpecificationExecutor<LinkMan> { }
测试新增记录
@RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration(locations = "classpath:applicationContext.xml") public class OneToManyTest { @Autowired private CustomerDao customerDao; @Autowired private LinkManDao linkManDao; /** * 保存一个客户,保存一个联系人 */ @Test @Transactional @Rollback(false) public void testAdd() { Customer customer = new Customer(); customer.setCustName("夫子"); LinkMan linkMan = new LinkMan(); linkMan.setLkmName("宁缺"); /** * 配置了客户到联系人的关系 * 从客户的角度上：发送两条insert语句，发送一条更新语句更新数据库（更新外键） * 由于我们配置了客户到联系人的关系：客户可以对外键进行维护 */ customer.getLinkMans().add(linkMan); /** * 配置联系人到客户的关系（多对一） * 只发送了两条insert语句 * 由于配置了联系人到客户的映射关系（多对一）:联系人也可以对外键进行维护 */ // linkMan.setCustomer(customer); customerDao.save(customer); linkManDao.save(linkMan); } /** *** 最终建议使用方式 *** * 会有一条多余的update语句 * * 由于一的一方可以维护外键：会发送update语句 * * 解决此问题：只需要在一的一方放弃维护权即可 * */ @Test @Transactional @Rollback(false) public void testAdd2() { //创建一个客户，创建一个联系人 Customer customer = new Customer(); customer.setCustName("陈某"); LinkMan linkMan = new LinkMan(); linkMan.setLkmName("隆庆"); linkMan.setCustomer(customer);//由于配置了多的一方到一的一方的关联关系（当保存的时候，就已经对外键赋值） customer.getLinkMans().add(linkMan);//由于配置了一的一方到多的一方的关联关系（发送一条update语句） customerDao.save(customer); linkManDao.save(linkMan); } }
测试删除记录
@Test @Transactional @Rollback(false) public void testDelete() { customerDao.delete(1L); }
删除操作的说明如下：
删除从表数据：可以随时任意删除。
删除主表数据：
有从表数据
1、在默认情况下，它会把外键字段置为null，然后删除主表数据。如果在数据库的表结构上，外键字段有非空约束，默认情况就会报错。
2、如果配置了放弃维护关联关系的权利，则不能删除（与外键字段是否允许为null， 没有关系）因为在删除时，它根本不会去更新从表的外键字段了。
3、如果还想删除，使用级联删除引用（慎用）
没有从表数据引用：随便删
级联操作：指操作一个对象同时操作它的关联对象
使用方法：只需要在操作主体的注解上配置cascade
@OneToMany(mappedBy = "customer", cascade = CascadeType.ALL)
private Set<LinkMan> linkMans = new HashSet<>(0);
@RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration(locations = "classpath:applicationContext.xml") public class CascadeTest { @Autowired private CustomerDao customerDao; @Autowired private LinkManDao linkManDao; /** * 级联添加：保存一个客户的同时，保存客户的所有联系人 * 需要在操作主体的实体类上，配置casacde属性 */ @Test @Transactional @Rollback(false) public void testCascadeAdd() { Customer customer = new Customer(); customer.setCustName("百度"); LinkMan linkMan = new LinkMan(); linkMan.setLkmName("小李"); linkMan.setCustomer(customer); customer.getLinkMans().add(linkMan); customerDao.save(customer); } /** * 级联删除： * 删除1号客户的同时，删除1号客户的所有联系人 */ @Test @Transactional @Rollback(false) public void testCascadeRemove() { //1.查询1号客户 Customer customer = customerDao.findOne(1L); //2.删除1号客户 customerDao.delete(customer); } }
多对多：
示例：用户和角色关系
多对多的表关系建立靠的是中间表，其中用户表和中间表的关系是一对多，角色表和中间表的关系也是一对多
实体类关系建立以及映射配置：
一个用户可以具有多个角色，所以在用户实体类中应该包含多个角色的信息
/** * 用户实体类 */ @Entity @Table(name = "sys_user") public class SysUser implements Serializable { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) @Column(name = "user_id") private Long userId; @Column(name = "user_code") private String userCode; @Column(name = "user_name") private String userName; @Column(name = "user_password") private String userPassword; @Column(name = "user_state") private String userState;
/** * 配置用户到角色的多对多关系 * 配置多对多的映射关系 * 1.声明表关系的配置 * @ManyToMany(targetEntity = SysRole.class) //多对多 * targetEntity：代表对方的实体类字节码 * 2.配置中间表（包含两个外键） * @JoinTable * name : 中间表的名称 * joinColumns：配置当前对象在中间表的外键 * @JoinColumn的数组 * name：外键名 * referencedColumnName：参照的主表的主键名 * inverseJoinColumns：配置对方对象在中间表的外键 */ @ManyToMany(targetEntity = SysRole.class) @JoinTable(name = "sys_user_role", //joinColumns,当前对象在中间表中的外键 joinColumns = {@JoinColumn(name = "sys_user_id",referencedColumnName = "user_id")}, //inverseJoinColumns，对方对象在中间表的外键 inverseJoinColumns = {@JoinColumn(name = "sys_role_id",referencedColumnName = "role_id")} ) private Set<SysRole> roles = new HashSet<SysRole>(0);
/************************ get/set方法 ************************/
}
一个角色可以赋予多个用户，所以在角色实体类中应该包含多个用户的信息
/** * 角色实体类 */ @Entity @Table(name = "sys_role") public class SysRole implements Serializable { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) @Column(name = "role_id") private Long roleId; @Column(name = "role_name") private String roleName; @Column(name = "role_memo") private String roleMemo;
//多对多关系映射 @ManyToMany(mappedBy = "roles") // 对方配置关系的属性名称,表示由对方来维护中间表关系 private Set<SysUser> users = new HashSet<SysUser>(0);
/************************ get/set方法 ************************/ }
持久层接口：
/** * 用户持久层接口 */ public interface SysUserDao extends JpaRepository<SysUser, Long>, JpaSpecificationExecutor<SysUser> { }
/** * 角色持久层接口 */ public interface SysRoleDao extends JpaRepository<SysRole, Long>, JpaSpecificationExecutor<SysRole> { }
测试：
@RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration(locations = "classpath:applicationContext.xml") public class ManyToManyTest { @Autowired private SysRoleDao sysRoleDao; @Autowired private SysUserDao sysUserDao; /** * 保存一个用户，保存一个角色 * 多对多放弃维护权：被动的一方放弃 */ @Test @Transactional @Rollback(false) public void testAdd() { SysUser sysUser = new SysUser(); sysUser.setUserName("小强"); SysRole sysRole = new SysRole(); sysRole.setRoleName("java程序员"); // 配置用户到角色关系，可以对中间表中的数据进行维护 sysUser.getRoles().add(sysRole); // 配置角色到用户的关系，可以对中间表的数据进行维护（放弃了维护） sysRole.getUsers().add(sysUser); sysUserDao.save(sysUser); sysRoleDao.save(sysRole); } }
在多对多（保存）中，如果双向都设置关系，意味着双方都维护中间表，都会往中间表插入数据，中间表的2个字段又作为联合主键，主键重复，所以报错
解决保存失败的问题：只需要在任意一方放弃对中间表的维护权即可，推荐在被动的一方放弃，配置如下：
// 放弃对中间表的维护权，解决保存中主键冲突的问题
@ManyToMany(mappedBy = "roles")
private Set<SysUser> users = new HashSet<SysUser>(0);
多对多级联操作：
和一对多一样，只需要在操作主体的注解上配置cascade
@ManyToMany(targetEntity = SysRole.class, cascade = CascadeType.ALL) @JoinTable(name = "sys_user_role", //joinColumns,当前对象在中间表中的外键 joinColumns = {@JoinColumn(name = "sys_user_id",referencedColumnName = "user_id")}, //inverseJoinColumns，对方对象在中间表的外键 inverseJoinColumns = {@JoinColumn(name = "sys_role_id",referencedColumnName = "role_id")} ) private Set<SysRole> roles = new HashSet<SysRole>(0);
测试：
/** * 测试级联添加（保存一个用户的同时保存用户的关联角色） */ @Test @Transactional @Rollback(false) public void testCasCadeAdd() { SysUser sysUser = new SysUser(); sysUser.setUserName("小李"); SysRole sysRole = new SysRole(); sysRole.setRoleName("java程序员"); sysUser.getRoles().add(sysRole); sysRole.getUsers().add(sysUser); sysUserDao.save(sysUser); } /** * 删除操作 * 在多对多的删除时，双向级联删除根本不能配置 * 禁用 * 如果配了的话，如果数据之间有相互引用关系，可能会清空所有数据 * * 案例：删除id为1的用户，同时删除他的关联对象 */ @Test @Transactional @Rollback(false) public void testCasCadeRemove() { //查询1号用户 SysUser user = sysUserDao.findOne(1L); //删除1号用户 sysUserDao.delete(user); }
标签：允许 user set 查询 用户表 done 双向 autowired cad
原文地址：https://www.cnblogs.com/roadlandscape/p/12378696.html
