10 20Hibernate之数据关联（多对多）
2024-05-13 05:40:16
文章目录
- 1 基于`*.hbm.xml`文件的配置
- 2 基于Annotation的配置
多对多是一种在项目开发之中使用较多的操作情况，例如，在最为常见的管理员的权限处理过程之中，一定会存在有管理员的角色以及对应的的管理员组，而一个管理员角色可以具备多个管理员组，反之一个管理员组也可以同时被多个角色所使用。
但是在真正使用之前必须首先明确一个问题：在角色和权限组的操作过程之中，角色应该作为主控方，也就是说所有权限组的维护都应该以角色为主。
范例：数据库脚本
DROP TABLE IF EXISTS `groups`;CREATE TABLE `groups`(gid INT AUTO_INCREMENT,gtitle VARCHAR(50),gnote TEXT,CONSTRAINT pk_gid PRIMARY KEY(gid)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;LOCK TABLES `groups` WRITE;INSERT INTO `groups`(gtitle,gnote)
VALUES
('权限管理', '-'),
('信息管理', '-'),
('课程管理', '-'),
('人事管理', '-');UNLOCK TABLES;DROP TABLE IF EXISTS `role`;CREATE TABLE `role` (rid INT AUTO_INCREMENT,rtitle VARCHAR(50),rnote TEXT,CONSTRAINT pk_rid PRIMARY KEY(rid)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;LOCK TABLES `role` WRITE;INSERT INTO `role`(rtitle,rnote)
VALUES
('管理员角色','-'),
('信息管理角色','-');UNLOCK TABLES;DROP TABLE IF EXISTS `role_groups`;CREATE TABLE `role_groups` (rid INT,gid INT,CONSTRAINT fk_rolegroups_role FOREIGN KEY(rid) REFERENCES `role`(rid) ON DELETE CASCADE,CONSTRAINT fk_rolegroups_groups FOREIGN KEY(gid) REFERENCES `groups`(gid) ON DELETE CASCADE
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;LOCK TABLES `role_groups` WRITE;INSERT INTO `role_groups`(rid,gid)
VALUES(1,1),(1,2),(1,3),(1,4),(2,2),(2,3),(2,4);UNLOCK TABLES;
最为常见的操作流程：
（1）权限组信息自己进行维护，也就是说权限组（groups表）操作的过程之中不应该与角色发生关系；
（2）在角色进行维护的时候，必须考虑到权限组的情况，例如：如果角色添加，则应该选择好相应的权限的信息，那么也就是说角色添加的时候除了定义的role表之外，还应该处理角色-权限组关系表。
1 基于*.hbm.xml文件的配置
在利用MyEclipse生成Hibernate映射文件的时候必须要注意一点：默认情况下MyEclipse只支持的是一对多关系自动生成，所以如果是多对多，请将所有的表一起选中生成。同时在生成映射文件的同时要选择生成多对多关系。
于是下面的问题又回到了最初的问题上了，依然要关心的是POJO类的映射操作以及对应的映射文件的使用。
范例：观察Role.java类
package org.lks.pojo;import java.util.HashSet;
import java.util.Set;@SuppressWarnings("serial")
public class Role implements java.io.Serializable {private Integer rid;private String rtitle;private String rnote;private Set<Groups> groupses = new HashSet<Groups>(0);
}
范例：观察Groups.java类
package org.lks.pojo;import java.util.HashSet;
import java.util.Set;@SuppressWarnings("serial")
public class Groups implements java.io.Serializable {private Integer gid;private String gtitle;private String gnote;private Set<Role> roles = new HashSet<Role>(0);
}
在开发框架之中有其是在JPA支持的开发框架之中，中间表（由外键组成）是绝对不会出现具体的类的。
那么随后的关键性的问题都落在*.hbm.xml文件的定义上。
范例：观察Role.hbm.xml文件——Role是作为整个多对多操作的主控方
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping><class name="org.lks.pojo.Role" table="role" catalog="hedb"><id name="rid" type="java.lang.Integer"><column name="rid" /><generator class="native"></generator></id><property name="rtitle" type="java.lang.String"><column name="rtitle" length="50" /></property><property name="rnote" type="java.lang.String"><column name="rnote" length="65535" /></property><!-- 表示在Role.java类里面存在有一个groups的Set集合 --><!-- 角色维护的信息与权限组没有关系，所有的信息都是以中间关系表为主 --><set name="groupses" table="role_groups" catalog="hedb"><key> <!-- role数据表与role_groups数据表的映射字段 --><column name="rid" /></key><!-- 表示配置多对多关系，因为groupses这个Set集合要保存的是多个Groups对象 --><many-to-many entity-name="org.lks.pojo.Groups"><column name="gid" /> <!-- groups表与role_groups表的关联字段 --></many-to-many></set></class>
</hibernate-mapping>而后由于角色是作为主控方存在，所以权限组的所有相关操作都应该交由Role来完成。
范例：观察Groups.hbm.xml文件
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<!-- Mapping file autogenerated by MyEclipse Persistence Tools
-->
<hibernate-mapping><class name="org.lks.pojo.Groups" table="groups" catalog="hedb"><id name="gid" type="java.lang.Integer"><column name="gid" /><generator class="native"></generator></id><property name="gtitle" type="java.lang.String"><column name="gtitle" length="50" /></property><property name="gnote" type="java.lang.String"><column name="gnote" length="65535" /></property><!-- Groups里面包含有一个roles的Set集合，权限组的控制应该交由角色完成 --><!-- 权限组的操作依然要将数据保存到role_groups表的关联字段 --><set name="roles" inverse="true" table="role_groups" catalog="hedb"><key> <!-- groups表与role_groups表的关联字段 --><column name="gid" /></key><!-- Groups中的roles的Set集合保存的是多个Role对象 --><many-to-many entity-name="org.lks.pojo.Role"><column name="rid" /> <!-- 设置role与role_groups表的关联字段 --></many-to-many></set></class>
</hibernate-mapping>
整个的代码操作之中发现权限组不作为主控方，将所有的控制权交给了角色来完成。
范例：观察权限组的操作
package org.lks.test;import org.lks.dbc.HibernateSessionFactory;
import org.lks.pojo.Groups;public class TestGroupsInsert {public static void main(String[] args) {Groups groups = new Groups();groups.setGtitle("软件管理");groups.setGnote("hhy big fool");System.out.println(HibernateSessionFactory.getSession().save(groups));HibernateSessionFactory.getSession().beginTransaction().commit();HibernateSessionFactory.closeSession();}
}Hibernate: insert intohedb.groups(gtitle, gnote) values(?, ?)
5
这里面可以清楚的发现，groups表的数据是单独进行维护的。
疑问：能不能在Groups操作的时候设置Role呢？
package org.lks.test;import org.lks.dbc.HibernateSessionFactory;
import org.lks.pojo.Groups;
import org.lks.pojo.Role;public class TestGroupsInsert {public static void main(String[] args) {Groups groups = new Groups();groups.setGtitle("软件管理-5");groups.setGnote("hhy big fool");Role role = new Role();role.setRtitle("hhy super big fool");role.setRnote("hhy super big big fool");groups.getRoles().add(role); //表示权限组所属的角色System.out.println(HibernateSessionFactory.getSession().save(groups));HibernateSessionFactory.getSession().beginTransaction().commit();HibernateSessionFactory.closeSession();System.exit(0);}
}Hibernate: insert intohedb.groups(gtitle, gnote) values(?, ?)
Hibernate: insert intohedb.role(rtitle, rnote) values(?, ?)
10
现在的代码一定是错误的，因为现在权限的添加变为了角色也同时进行了添加操作，因为权限组不是主控方。
整个的多对多操作操作过程之中权限组的操作意义并不大，关键是在于角色的操作上，因为角色创建或修改的时候要牵扯到权限的关联变更。
范例：增加新的角色——增加新的角色同时要配置好权限组
package org.lks.test;import org.lks.dbc.HibernateSessionFactory;
import org.lks.pojo.Groups;
import org.lks.pojo.Role;public class TestRoleInsert {public static void main(String[] args) {int[] groups = new int[]{2,4,6};Role role = new Role();role.setRtitle("hhy2");role.setRnote("hhy super big big fool");for(int i = 0; i < groups.length; i++){ //处理权限组Groups group = new Groups();group.setGid(groups[i]); //表示配置权限角色与权限组的关系role.getGroupses().add(group);}System.out.println(HibernateSessionFactory.getSession().save(role));HibernateSessionFactory.getSession().beginTransaction().commit();HibernateSessionFactory.closeSession();System.exit(0);}
}Hibernate: insert into hedb.role (rtitle, rnote) values (?, ?)
6
Hibernate: insert into hedb.role_groups (rid, gid) values (?, ?)
Hibernate: insert into hedb.role_groups (rid, gid) values (?, ?)
Hibernate: insert into hedb.role_groups (rid, gid) values (?, ?)
如果是正常的开发，一定是：
（1）首先要保存由角色的信息，向role表中增加数据；
（2）向role_groups这张关系表中保存角色与权限组的对应关系。
那么增加操作完成之后一定还会涉及到修改角色对应权限的关系，但是修改操作必须要考虑两种情况：
（1）使用Query接口完成更新，那么所有的权限组不会自动级联更新；
（2）使用update()方法实现，可以进行关系表的关系更新。
范例：利用Query进行更新操作——只能够更新单表，但是权限组的维护就需要自己编写代码了
package org.lks.test;import java.util.Iterator;import org.hibernate.Query;
import org.lks.dbc.HibernateSessionFactory;
import org.lks.pojo.Groups;
import org.lks.pojo.Role;public class TestUpdateQuery {public static void main(String[] args) {//以下的数据设置部分应该在控制器中处理int[] groups = new int[]{2,4,6};Role role = new Role();role.setRid(3);role.setRtitle("hhy is a big fool");role.setRnote("hhy super super big big fool");for(int i = 0; i < groups.length; i++){ //处理权限组Groups group = new Groups();group.setGid(groups[i]); //表示配置权限角色与权限组的关系role.getGroupses().add(group);}//以下的数据操作部分应该由数据层控制处理Query queryA = HibernateSessionFactory.getSession().createQuery("UPDATE Role AS r SET r.rtitle=?,r.rnote=? WHERE r.rid=?");queryA.setParameter(0, role.getRtitle());queryA.setParameter(1, role.getRnote());queryA.setParameter(2, role.getRid());if(queryA.executeUpdate() > 0){//按照SQL执行Query queryB = HibernateSessionFactory.getSession().createSQLQuery("DELETE FROM role_groups AS rg WHERE rg.rid=?");queryB.setParameter(0, role.getRid());if(queryB.executeUpdate() >= 0 && role.getGroupses().size() > 0){//按照SQL执行Query queryC = HibernateSessionFactory.getSession().createSQLQuery("INSERT INTO role_groups(rid,gid) VALUES(?,?)");Iterator<Groups> iter = role.getGroupses().iterator();while(iter.hasNext()){queryC.setParameter(0, role.getRid());queryC.setParameter(1, iter.next().getGid());queryC.executeUpdate();}}}HibernateSessionFactory.getSession().beginTransaction().commit();HibernateSessionFactory.closeSession();System.exit(0);}
}
Hibernate: update hedb.role set rtitle=?, rnote=? where rid=?
Hibernate: DELETE FROM role_groups AS rg WHERE rg.rid=?
Hibernate: INSERT INTO role_groups(rid,gid) VALUES(?,?)
Hibernate: INSERT INTO role_groups(rid,gid) VALUES(?,?)
Hibernate: INSERT INTO role_groups(rid,gid) VALUES(?,?)
整个的操作如果用户自己来维护处理的话，需要自己编写SQL语句，而后一点点的进行数据处理，太麻烦了。
范例：利用Hibernate自动支持的更新操作完成
package org.lks.test;import org.lks.dbc.HibernateSessionFactory;
import org.lks.pojo.Groups;
import org.lks.pojo.Role;public class TestUpdate {public static void main(String[] args) {//以下的数据设置部分应该在控制器中处理int[] groups = new int[]{3,5,7,2};Role role = new Role();role.setRid(3);role.setRtitle("hhy is a big fool");role.setRnote("hhy super super big big fool");for(int i = 0; i < groups.length; i++){ //处理权限组Groups group = new Groups();group.setGid(groups[i]); //表示配置权限角色与权限组的关系role.getGroupses().add(group);}//以下的数据操作部分应该由数据层控制处理HibernateSessionFactory.getSession().update(role);HibernateSessionFactory.getSession().beginTransaction().commit();HibernateSessionFactory.closeSession();System.exit(0);}
}Hibernate: update hedb.role set rtitle=?, rnote=? where rid=?
Hibernate: delete from hedb.role_groups where rid=?
Hibernate: insert into hedb.role_groups (rid, gid) values (?, ?)
Hibernate: insert into hedb.role_groups (rid, gid) values (?, ?)
Hibernate: insert into hedb.role_groups (rid, gid) values (?, ?)
Hibernate: insert into hedb.role_groups (rid, gid) values (?, ?)
在多对多关系更新的过程之中，如果使用的是update()操作方法，那么所有的级联关系自动进行维护。
如果说现在角色是主控方，当管理员登录之后流程如下：
（1）验证管理员的用户名和密码是否正确；
（2）如果管理员的信息正确则根据管理员的角色找到其对应的所有权限组。
那么一定会在开发之中出现这样一种处理情况：根据角色查询出对应的所有权限组信息。
范例：根据角色ID查找数据
package org.lks.test;import org.lks.dbc.HibernateSessionFactory;
import org.lks.pojo.Role;public class TestRoleGet {public static void main(String[] args) {Role role = (Role)HibernateSessionFactory.getSession().get(Role.class, 3);System.out.println(role.getRtitle());System.out.println(role.getGroupses());HibernateSessionFactory.closeSession();System.exit(0);}
}Hibernate: selectrole0_.rid as rid1_1_0_,role0_.rtitle as rtitle2_1_0_,role0_.rnote as rnote3_1_0_ fromhedb.role role0_ whererole0_.rid=?
hhy is a big fool
Hibernate: selectgroupses0_.rid as rid1_2_0_,groupses0_.gid as gid2_2_0_,groups1_.gid as gid1_0_1_,groups1_.gtitle as gtitle2_0_1_,groups1_.gnote as gnote3_0_1_ fromhedb.role_groups groupses0_ inner joinhedb.groups groups1_ on groupses0_.gid=groups1_.gid wheregroupses0_.rid=?
[org.lks.pojo.Groups@2fe88a09, org.lks.pojo.Groups@27b22f74, org.lks.pojo.Groups@22fba58c, org.lks.pojo.Groups@7e8a46b7]
在多对多的操作之中，延迟加载依然是默认打开的状态：同时发现此时使用的数据查询操作里面当查询指定角色对应的权限组时，使用的流程是进行了多表连接查询。
在多对多的关系之中，查询角色对应的权限组信息的时候只有join一种操作。
而在正常的开发之中，本处需要的只是角色对应的所有权限组的信息，那么唯一能做的方式就是进行子查询，并且使用SQL的原生查询操作模式。
范例：利用子查询解决多表查询问题
SELECT g.gid,g.gtitle,g.gnote
FROM groups AS g
WHERE g.gid IN (SELECT rg.gid FROM role_groups AS rg WHERE rg.rid=?);
package org.lks.test;import java.util.HashSet;
import java.util.List;
import java.util.Set;import org.hibernate.Query;
import org.lks.dbc.HibernateSessionFactory;
import org.lks.pojo.Groups;
import org.lks.pojo.Role;public class TestRoleGet {public static void main(String[] args) {//1、首先查询出角色的完整信息，但是此时延迟加载一定是打开的Role role = (Role)HibernateSessionFactory.getSession().get(Role.class, 3);System.out.println(role.getRtitle());//2、利用子查询通过关系表查找到所有对应的权限组Query query = HibernateSessionFactory.getSession().createSQLQuery("SELECT g.gid,g.gtitle,g.gnote "+ "FROM `groups` AS g "+ "WHERE g.gid IN "+ "(SELECT rg.gid FROM role_groups AS rg WHERE rg.rid=?)");query.setParameter(0, role.getRid());//需要将查询结果变为POJO类对象的形式返回List<Groups> list = query.list(); //进行数据的查询//3、可以将List集合变为Set集合Set<Groups> set = new HashSet<Groups>();//将查询出来的全部内容保存到Set集合中set.addAll(list);role.setGroupses(set);HibernateSessionFactory.closeSession();System.exit(0);}
}Hibernate: selectrole0_.rid as rid1_1_0_,role0_.rtitle as rtitle2_1_0_,role0_.rnote as rnote3_1_0_ fromhedb.role role0_ whererole0_.rid=?
hhy is a big fool
Hibernate: SELECTg.gid,g.gtitle,g.gnote FROM`groups` AS g WHEREg.gid IN (SELECTrg.gid FROMrole_groups AS rg WHERErg.rid=?)
在以后的开发之中，Hibernate是有优点的，但是如果对数据关联操作处理不当，那么就一定会造成性能问题。
2 基于Annotation的配置
很明显Annotation是以后新项目开发之中重点要使用的操作部分，所以在Hibernate之中的多对多的Annotation也不需要用户做过多的处理操作，都可以通过工具自动生成。
那么随后观察生成的Role与Groups两个POJO类的组成，但是请千万要记住，此时Role作为主控方。
范例：观察Role.java文件
package org.lks.pojo;import java.util.HashSet;
import java.util.Set;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
import javax.persistence.Table;@SuppressWarnings("serial")
@Entity
@Table(name = "role", catalog = "hedb")
public class Role implements java.io.Serializable {private Integer rid;private String rtitle;private String rnote;private Set<Groups> groupses = new HashSet<Groups>(0);@Id@GeneratedValue //表示此主键为自动增长列@Column(name = "rid", unique = true, nullable = false)public Integer getRid() {return this.rid;}public void setRid(Integer rid) {this.rid = rid;}@Column(name = "rtitle", length = 50)public String getRtitle() {return this.rtitle;}public void setRtitle(String rtitle) {this.rtitle = rtitle;}@Column(name = "rnote", length = 65535)public String getRnote() {return this.rnote;}public void setRnote(String rnote) {this.rnote = rnote;}@ManyToMany( //定义多对多的操作关系cascade = CascadeType.ALL, //表示数据的级联fetch = FetchType.LAZY) //表示延迟加载@JoinTable(//维护中间关系表数据name = "role_groups", //表的名称catalog = "hedb", //数据库模式名称joinColumns = { //给关联数据列的维护@JoinColumn(name = "rid", updatable = false) }, //Role这个类维护role_groups表中的rid列的信息inverseJoinColumns = {@JoinColumn(name = "gid", updatable = false) }) //表示role_groups表中的gid由Role负责维护public Set<Groups> getGroupses() {return this.groupses;}public void setGroupses(Set<Groups> groupses) {this.groupses = groupses;}}
范例：观察Groups.java文件
package org.lks.pojo;import java.util.HashSet;
import java.util.Set;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.ManyToMany;
import javax.persistence.Table;@SuppressWarnings("serial")
@Entity
@Table(name = "groups", catalog = "hedb")
public class Groups implements java.io.Serializable {private Integer gid;private String gtitle;private String gnote;private Set<Role> roles = new HashSet<Role>(0);@Id@GeneratedValue@Column(name = "gid", unique = true, nullable = false)public Integer getGid() {return this.gid;}public void setGid(Integer gid) {this.gid = gid;}@Column(name = "gtitle", length = 50)public String getGtitle() {return this.gtitle;}public void setGtitle(String gtitle) {this.gtitle = gtitle;}@Column(name = "gnote", length = 65535)public String getGnote() {return this.gnote;}public void setGnote(String gnote) {this.gnote = gnote;}@ManyToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY, mappedBy = "groupses")public Set<Role> getRoles() {return this.roles;}public void setRoles(Set<Role> roles) {this.roles = roles;}}
但是在进行数据增加的时候，如果此时设置的是全部级联更新操作，那么会出现如下的问题：
范例：观察程序问题
package org.lks.test;import org.lks.dbc.HibernateSessionFactory;
import org.lks.pojo.Groups;
import org.lks.pojo.Role;public class TestRoleInsert {public static void main(String[] args) {int[] groups = new int[]{2,4,1};Role role = new Role();role.setRtitle("hhy2");role.setRnote("hhy super big big fool");for(int i = 0; i < groups.length; i++){ //处理权限组Groups group = new Groups();group.setGid(groups[i]); //表示配置权限角色与权限组的关系role.getGroupses().add(group);}System.out.println(HibernateSessionFactory.getSession().save(role));HibernateSessionFactory.getSession().beginTransaction().commit();HibernateSessionFactory.closeSession();System.exit(0);}
}Hibernate: insert into hedb.role (rnote, rtitle) values (?, ?)
5
Hibernate: update hedb.groups set gnote=?, gtitle=? where gid=?
Hibernate: update hedb.groups set gnote=?, gtitle=? where gid=?
Hibernate: update hedb.groups set gnote=?, gtitle=? where gid=?
Hibernate: insert into hedb.role_groups (rid, gid) values (?, ?)
Hibernate: insert into hedb.role_groups (rid, gid) values (?, ?)
Hibernate: insert into hedb.role_groups (rid, gid) values (?, ?)
此时的增加角色如果选择了权限，那么就出现了三条更新语句，它认为需要更新groups数据表，但是本质上并不需要更新，所以此时只能够修改Role.java中的级联操作，让其在更新的时候才出现级联，其它时候不出现级联。
范例：修改Role.java类的@ManyToMany定义
@ManyToMany( //定义多对多的操作关系cascade = CascadeType.MERGE, //表示数据的级联fetch = FetchType.LAZY) //表示延迟加载@JoinTable(//维护中间关系表数据name = "role_groups", //表的名称catalog = "hedb", //数据库模式名称joinColumns = { //给关联数据列的维护@JoinColumn(name = "rid", updatable = false) }, //Role这个类维护role_groups表中的rid列的信息inverseJoinColumns = {@JoinColumn(name = "gid", updatable = false) }) //表示role_groups表中的gid由Role负责维护public Set<Groups> getGroupses() {return this.groupses;}
Hibernate: insert into hedb.role (rnote, rtitle) values (?, ?)
6
Hibernate: insert into hedb.role_groups (rid, gid) values (?, ?)
Hibernate: insert into hedb.role_groups (rid, gid) values (?, ?)
Hibernate: insert into hedb.role_groups (rid, gid) values (?, ?)
等于现在在进行权限组角色增加的时候不再去考虑权限组的问题了。
Hibernate的问题：
（1）所有的操作都是利用反射拼凑的SQL语句，所以此处一定会造成一定的空间复杂度，如果要是直接编写完整的SQl语句性能一定要比动态拼凑要好；
（2）如果处理不好一些操作属性，那么就会出现多表查询问题，一定会带来性能的降低。
因此，Hibernate是不是性能低，不是由这个框架决定的，它只是一个工具，工具是否好用还在于使用它的人会不会用。
10 20Hibernate之数据关联（多对多）相关推荐
- Hibernate5-双向关联-多对多(n:n)
1.创建项目,项目名称hibernatedemo15,目录结构如图所示 2.在项目中创建lib目录存储jar文件,目录结构如图所示 3.在src目录中创建实体类Course,包名(com.mycomp ...
- 黑马lavarel教程---10、lavarel模型关联
黑马lavarel教程---10.lavarel模型关联 一.总结 一句话总结: 1.模型关联比较方便,一次定义,后面都可以使用 2.关联关系 使用动态属性进行调用 1.一对多,多对多实例? 一对多: ...
- 自动驾驶 Apollo 源码分析系列，感知篇(九)：感知融合中的数据关联细节
前一篇文章讲了,Apollo 6.0 中融合的代码逻辑流程,但那是基于软件的角度进行梳理和分析的,这一篇文章基于上篇的成果进一步对算法进行更详细的分析,因为代码量奇大,所以本文重点讨论数据关联的一些细 ...
- Clipper: 开源的基于图论框架的鲁棒点云数据关联方法(ICRA2021)
<CLIPPER: A Graph-Theoretic Framework for Robust Data Association>(ICRA 2021 ) 基于图论的点云数据关联方法,通 ...
- 基于深度学习的多目标跟踪算法（上）：端到端的数据关联
©PaperWeekly 原创 · 作者|黄飘 学校|华中科技大学硕士生 研究方向|多目标跟踪 最近基于深度学习的多目标跟踪算法越来越多,有用于特征提取的,有改进单目标跟踪器的,也有提升数据关联的.如 ...
- Hello Mybatis 03 数据关联
ResultMap 在实际的开发中,数据库不总是我们希望看到的样子.比如我们希望User的主键是id但是数据库偏偏喜欢叫它u_id,这样一来原先的resultType似乎就失效了,不带这么玩的,整个人 ...
- hibernate的数据关联映射
数据关联映射分为:一对多.多对一,一对一,多对多. cascade属性 • save-update:在执行保存和修改是进行级联操作 • delete:在执行删除时进行级联操作 • all:在所有情况下 ...
- 几张表格怎么联动_在excel 中，怎样实现数据关联？：excel怎么把几个表格的数据联动...
在excel 中,怎样实现数据关联? Excel数据关联可以利用公式来. 软件版本:Office2007 举例说明如下: 1.Sheet1如下数据,设置Sheet2中对元格数据与之关联起来: 2.在S ...
- 关联规则(挖掘)，数据关联(融合)
3月9日07:49| 新浪博客| 来源:时空交互| 查看原文> 关联式规则 关联式规则(Association Rules, AR),又称关联规则,是数据挖掘的一个重要课题,用于从大量数据 ...
最新文章
- C++/C union使用记一下锅
- android开发中的 Activity 与 Context 区别与联系
- java文件头_对java文件头的解析
- 实验1 最小生成树问题【Kruskal+Prim】
- 目前我国负债超过100万的大概有多少人？
- 快要“成精”的波士顿机械狗，开始卖了，价格不贵准备搞一只
- （转）新ITC提交APP常见问题与解决方法(Icon Alpha,Build version,AppIcon120x120)(2014-11-17)...
- Mac安装CentOS7
- node.js安装express（零起点搭建本地测试服务器）- 教程篇
- 【华为云技术分享】【Python算法】分类与预测——Python随机森林
- win10 linux开发环境搭建,win10子系统linux.ubuntu开发环境搭建
- Problem E: 求最大值和最小值
- java oop试题_java oop 试题
- idea 新建spring clound 项目_手把手教你spring源码搭建
- 小银行忍痛放弃资管业务？ 转型渠道代销是大势所趋
- mysql 唯一索引 死锁_MySQL死锁案例_唯一索引
- C++特征码查找 附加案例
- [php知识点]PHP伪协议
- java编程培训都学习哪些内容
- php7 memcached sasl,memcached sasl