hibernate关联映射笔记

最新推荐文章于 2024-04-23 14:46:22 发布
最新推荐文章于 2024-04-23 14:46:22 发布
阅读量140 收藏 1
点赞数
分类专栏： j2ee 文章标签： javaweb hibernate关联映射
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hdy7237024855/article/details/49780977
版权

（劝退警告，手动狗头）现在hibernate已经逐步退出舞台了，只有历史版本或者遗留项目在用，都已经转战mybatis了，这个文章写在2015年左右，以前是私密文章，前不久打开发现还有这么多人看呢。

关联关系映射，做此笔记方便以后查看对比。

关联映射中，对象之间是有方向性的，从一方可以看到另外一方，但从另外一方不一定能看到这一方，区别于数据库的表现方式。是对象之间的连锁操作，它只影响添加、删除和修改
 

一、多对一关联映射

多对一关联映射原理：在多的一端加入一个外键，指向一的一端。需要在多的一端采用标签映射：<many-to-one name="group" column="groupid"/>
使用用户（User）-组（Group）站在User的角度来看，即为多对一：
 
 
 
 
配置文件：
 
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC 
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="com.hdy.hibernate.User" table="t_user">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
<many-to-one name="group" column="groupid" cascade="save-update"/>
</class>
</hibernate-mapping>
 
 
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC 
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="com.hdy.hibernate.Group" table="t_group">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
</class>
</hibernate-mapping>
 
Junit测试代码：
public void testSave1() {
Session session = null;
try {
session = HibernateUtils.getSession();
session.beginTransaction();

Group group = new Group();
group.setName("组一");
Group group1 = new Group();
group1.setName("组2");
/*session.save(group);
session.save(group1);*/
User user1 = new User();
user1.setName("张三");
user1.setGroup(group);

User user2 = new User();
user2.setName("李四");
user2.setGroup(group1);

session.save(user1);
session.save(user2);
session.getTransaction().commit();
}catch(Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
}finally {
HibernateUtils.closeSession(session);
}
}
测试查询：
public void testLoad1() {
Session session = null;
try {
session = HibernateUtils.getSession();
session.beginTransaction();
User user = (User)session.load(User.class, 3);
System.out.println("user.name=" + user.getName());
System.out.println("user.group.name=" + user.getGroup().getName());
session.getTransaction().commit();
}catch(Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
}finally {
HibernateUtils.closeSession(session);
}
}
 

在保存用户和用户对应的组时，对应的组必须存在，或者session.save(group),不然报TransientObjectException异常，因为Group没有被session纳入管理，或者在User.xml配置<many-to-one name="group" column="groupid" cascade="save-update"/>表明更新/新增User也同时更新/新增对应Group。

 
 

二、一对一关联映射

一对一使用人（Person）-身份证号（IdCard）
分两种策略：1，主键关联，即让两个对象有相同的主键值，仅通过主键来维护关联关系（扩展性不好）。
2，唯一外键关联，是多对多的一种特殊形式，在多的一方加上唯一限制，表示一对一。
一对一关联映射原理：让两个实体的主键一样，无需多余字段关联
 
1.单向主键关联方式：
 
 
 
 
 
 
配置文件：
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC 
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="com.hdy.hibernate.Person" table="t_person">
<id name="id">
<!-- 采用foreign生成策略，forgeign会取得关联对象的标识 -->
<generator class="foreign">
<param name="property">idCard</param>
</generator>
</id>
<property name="name"/>
<!-- 
one-to-one指定hibernate如何加载其关联对象，默认根据主键加载
也就是拿到关系字段值，根据对方的主键来加载关联对象

constrained="true表示，当前主键(person的主键)也是一个外键
参照了对端的主键（IdCard的主键），也就是会生成外键约束语句
-->
<one-to-one name="idCard" constrained="true"/>
</class>
</hibernate-mapping>
测试代码：
public void testSave1() {
Session session = null;
try {
session = HibernateUtils.getSession();
session.beginTransaction();

IdCard idCard = new IdCard();
idCard.setCardNo("1111111111111111");

Person person = new Person();
person.setName("张三");
//建立关联
person.setIdCard(idCard);

//没有抛出TransientObjectException
//是由一对一关联映射的特性决定的，它必须先保存关联对象IdCard
//这样它采用foreign映射策略才能取得关联对象的标识
//也就是它默认了cascade属性
session.save(person);

session.getTransaction().commit();
}catch(Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
}finally {
HibernateUtils.closeSession(session);
}
}
 
public void testSave2() {
Session session = null;
try {
session = HibernateUtils.getSession();
session.beginTransaction();

IdCard idCard = new IdCard();
idCard.setCardNo("1111111111111111");

Person person = new Person();
person.setName("张三");
//建立关联
person.setIdCard(idCard);

//只能将IdCard保存，不能将Person保存
//因为关系的维护端在Person端，IdCard不知道Person的存在
session.save(idCard);

session.getTransaction().commit();
}catch(Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
}finally {
HibernateUtils.closeSession(session);
}
}
 
双向一对一主键关联方式（需求确定，实际中很少用）：
需要双方各自添加引用，在IdCard配置中加入<one-to-one name="person"/>即可。
 
 
2.唯一外键单向一对一关联方式：
 
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC 
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="com.hdy.hibernate.Person" table="t_person">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
<many-to-one name="idCard" unique="true"/>
</class>
</hibernate-mapping>
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC 
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="com.hdy.hibernate.Person" table="t_person">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
<many-to-one name="idCard" unique="true"/>
</class>
</hibernate-mapping>
 
唯一外键双向一对一关联方式（不推荐使用）
 
实体类双方互相添加引用
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC 
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="com.hdy.hibernate.Person" table="t_person">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
<many-to-one name="idCard" unique="true"/>
</class>
</hibernate-mapping>
 
 
 
 
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC 
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="com.hdy.hibernate.IdCard" table="t_idCard">
<id name="id">
<generator class="native"/>
</id>
<property name="cardNo"/>
<one-to-one name="person" property-ref="idCard"/>
</class>
</hibernate-mapping>
 
三、单向一对多关联映射（一般都设置为双向，单方维护关系有缺陷,需要多的一方维护关系）
 
单向一对多关联映射和多对一关联映射映射原理是一致的，都是在多的一端加入一个外键，指向一的一端
它们的区别在于维护的关系不同：
* 多对一维护的关系是：多指向一的关系，有了此关系，在加多的时候可以将一加上来
* 一对多维护的关系是：一指向多的关系，有了此关系，在加一的时候可以将多加上来
在一的一端加入java.util.Set，hibernate对Set进行扩展,使用延迟加载有很好效果
public class Classes {

private int id;

private String name;

private Set students;
｝
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC 
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="com.hdy.hibernate.Student" table="t_student">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
</class>
</hibernate-mapping>
 
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC 
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="com.hdy.hibernate.Classes" table="t_classes">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
<set name="students">
<!-- 
<key column="classesid" not-null="true"/>
-->
<key column="classesid"/>
<one-to-many class="com.hdy.hibernate.Student"/>
</set>
</class>
</hibernate-mapping>
 
public void testSave1() {
Session session = null;
try {
session = HibernateUtils.getSession();
session.beginTransaction();
Student student1 = new Student();
student1.setName("张三");

Student student2 = new Student();
student2.setName("李四");

Classes classes = new Classes();
classes.setName("一班");

Set students = new HashSet();
students.add(student1);
students.add(student2);
classes.setStudents(students);

//抛出TransientObjectException
//因为Student不是Persistent状态的对象,它是Transient状态的对象
session.save(classes);
session.getTransaction().commit();
}catch(Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
}finally {
HibernateUtils.closeSession(session);
}
}
 
public void testSave2() {
Session session = null;
try {
session = HibernateUtils.getSession();
session.beginTransaction();
Student student1 = new Student();
student1.setName("张三");
session.save(student1);

Student student2 = new Student();
student2.setName("李四");
session.save(student2);

Classes classes = new Classes();
classes.setName("一班");

Set students = new HashSet();
students.add(student1);
students.add(student2);
classes.setStudents(students);

//可以成功保存数据
//但是会发出多余的update语句来维持关系
session.save(classes);
session.getTransaction().commit();
}catch(Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
}finally {
HibernateUtils.closeSession(session);
}
}
 
 
public void testLoad1() {
Session session = null;
try {
session = HibernateUtils.getSession();
session.beginTransaction();
Classes classes = (Classes)session.load(Classes.class, 1);
System.out.println("classes.name=" + classes.getName());
Set students = classes.getStudents();
for (Iterator iter=students.iterator(); iter.hasNext();) {
Student student = (Student)iter.next();
System.out.println("student.name=" +student.getName());
}
session.getTransaction().commit();
}catch(Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
}finally {
HibernateUtils.closeSession(session);
}
}
在一的一端维护关系存在缺陷：
* 因为多的一端Student不知道Classes的存在（也就是Student没有维护与Classes的关系）
所以在保存Student的时候关系字段classesid是为null的，如果将该关系字段设置为非空，则
将无法保存数据
* 另外因为Student不维护关系，而Classes维护关系，（由于session的隔离机制）Classes就会发出多余的update语句，保证Classes和Student有关系，这样加载Classes的时候才可以把该Classes对应的学生加载上来
四、双向一对多关联映射
 
采用一对多双向关联映射的目的主要是为了主要是为了解决一对多单向关联的缺陷，而不是需求决定的（通过双向一对多，让控制方为多的一方，【就比如公司的经理和员工，让员工记住经理很简单，但是让经理记住那么多员工的名字就很难了。】需要在一的一段设置inverse=“true”关系字段交给多的一方维护。这样，从一的一端进行保存，就不会发送update语句。但是数据库的关联字段为空）
一对多双向关联的映射方式：
* 在一的一端的集合上采用<key>标签，在多的一端加入一个外键
* 在多的一端采用<many-to-one>标签
注意：<key>标签和<many-to-one>标签加入的字段保持一直，否则会产生数据混乱
 
<hibernate-mapping>
<class name="com.hdy.hibernate.Classes" table="t_classes">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
<set name="students" inverse="true">
<key column="classesid"/>
<one-to-many class="com.hdy.hibernate.Student"/>
</set>
</class>
</hibernate-mapping>
 
<hibernate-mapping>
<class name="com.hdy.hibernate.Student" table="t_student">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
<many-to-one name="classes" column="classesid"/>
</class>
</hibernate-mapping>
 
五、单向多对多关联映射
 
多对多的关联映射需要使用中间表进行关联
<hibernate-mapping>
<class name="com.hdy.hibernate.User" table="t_user">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
<set name="roles" table="t_user_role">
<key column="user_id"/>
<many-to-many class="com.hdy.hibernate.Role" column="role_id" />
</set>
</class>
</hibernate-mapping>
 
<hibernate-mapping>
<class name="com.hdy.hibernate.Role" table="t_role">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
</class>
</hibernate-mapping>
 
public void testSave1() {
Session session = null;
try {
session = HibernateUtils.getSession();
session.beginTransaction();

Role r1 = new Role();
r1.setName("数据录入人员");
session.save(r1);

Role r2 = new Role();
r2.setName("商务主管");
session.save(r2);

Role r3 = new Role();
r3.setName("商务经理");
session.save(r3);

Role r4 = new Role();
r4.setName("项目会计");
session.save(r4);

User u1 = new User();
u1.setName("张三");
Set u1Roles = new HashSet();
u1Roles.add(r1);
u1Roles.add(r2);
u1.setRoles(u1Roles);
session.save(u1);

User u2 = new User();
u2.setName("李四");
Set u2Roles = new HashSet();
u2Roles.add(r1);
u2Roles.add(r2);
u2Roles.add(r3);
u2.setRoles(u2Roles);
session.save(u2);

User u3 = new User();
u3.setName("王五");
Set u3Roles = new HashSet();
u3Roles.add(r3);
u3Roles.add(r4);
u3.setRoles(u3Roles);
session.save(u3);

session.getTransaction().commit();
}catch(Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
}finally {
HibernateUtils.closeSession(session);
}
}
public void testLoad1() {
Session session = null;
try {
session = HibernateUtils.getSession();
session.beginTransaction();
User user = (User)session.load(User.class, 2);
System.out.println(user.getName());
for (Iterator iter=user.getRoles().iterator(); iter.hasNext();) {
Role role = (Role)iter.next();
System.out.println(role.getName());
}
session.getTransaction().commit();
}catch(Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
}finally {
HibernateUtils.closeSession(session);
}
}
 
六、双向多对多关联映射
双向多对多关联映射和单向差不多，需要在另外一方配相同配置
<hibernate-mapping>
<class name="com.hdy.hibernate.Role" table="t_role">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
<set name="users" table="t_user_role">
<key column="role_id" not-null="true"/>
<many-to-many class="com.gdy.hibernate.User" column="user_id"/>
</set>
</class>
</hibernate-mapping>
<hibernate-mapping>
<class name="com.hdy.hibernate.User" table="t_user">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
<set name="roles" table="t_user_role">
<key column="user_id" not-null="true"/>
<many-to-many class="com.hdy.hibernate.Role" column="role_id" />
</set>
</class>
</hibernate-mapping>
 
 
public void testSave1() {
Session session = null;
try {
session = HibernateUtils.getSession();
session.beginTransaction();

Role r1 = new Role();
r1.setName("数据录入人员");
session.save(r1);

Role r2 = new Role();
r2.setName("商务主管");
session.save(r2);

Role r3 = new Role();
r3.setName("商务经理");
session.save(r3);

Role r4 = new Role();
r4.setName("项目会计");
session.save(r4);

User u1 = new User();
u1.setName("张三");
Set u1Roles = new HashSet();
u1Roles.add(r1);
u1Roles.add(r2);
u1.setRoles(u1Roles);
session.save(u1);

User u2 = new User();
u2.setName("李四");
Set u2Roles = new HashSet();
u2Roles.add(r1);
u2Roles.add(r2);
u2Roles.add(r3);
u2.setRoles(u2Roles);
session.save(u2);

User u3 = new User();
u3.setName("王五");
Set u3Roles = new HashSet();
u3Roles.add(r3);
u3Roles.add(r4);
u3.setRoles(u3Roles);
session.save(u3);

session.getTransaction().commit();
}catch(Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
}finally {
HibernateUtils.closeSession(session);
}
}

public void testLoad1() {
Session session = null;
try {
session = HibernateUtils.getSession();
session.beginTransaction();
User user = (User)session.load(User.class, 2);
System.out.println(user.getName());
for (Iterator iter=user.getRoles().iterator(); iter.hasNext();) {
Role role = (Role)iter.next();
System.out.println(role.getName());
}
session.getTransaction().commit();
}catch(Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
}finally {
HibernateUtils.closeSession(session);
}
}

public void testLoad2() {
Session session = null;
try {
session = HibernateUtils.getSession();
session.beginTransaction();
Role role = (Role)session.load(Role.class, 1);
System.out.println(role.getName());
for (Iterator iter=role.getUsers().iterator(); iter.hasNext();) {
User user = (User)iter.next();
System.out.println(user.getName());
}
session.getTransaction().commit();
}catch(Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
}finally {
HibernateUtils.closeSession(session);
}
}
 
完事。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
 
 
 
hdy7237024855
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Hibernate数据关联技术笔记
05-21
本笔记将深入探讨Hibernate中的数据关联，特别是1:1、1:N和M:N这三种关联关系，以及如何通过POJO类和XML映射文件实现这些关联。 1:1（一对一）关联表示两个实体之间存在一对一的关系，例如一个人对应一张唯一的...
hibernate学习笔记1
08-08
5. 对象间的关联映射为表间的关系，如外键。 ORMapping可以通过JDBC和动态SQL实现，但Hibernate提供了一种更高级、更自动化的方式来处理这些映射。 二、Hibernate的功能与优势 Hibernate的主要作用在于： 1. ...
解决hibernate：referenced file contains errors http hibernate.sourceforge.net hibernate-mapping-3.0.dtd
fengxinyixiao的专栏
08-22 9963
今天电脑突然蓝屏，重启后进入eclipse，发现项目下的hibernate_cfg.xml莫名其妙的报错，在网上找了好久最终尝试后得到了答案，报错的内容是：referenced file contains errors http hibernate.sourceforge.net hibernate-mapping-3.0.dtd，有的人建议修改里面的约束，但是我这是从svn挡下来的项目，不能因为
Hibernate关联映射
GreatWilliam
12-19 221
最近总结的关于Hibernate关联映射的笔记，权当复习，这里分享一下，如果水到大家了，请指正，感谢不已。 hibernate关联映射 软件开发中，类与类之间最普遍的关系就是关联关系。 ------------------------------------------------------------------------------------------------
Hibernate关联映射学习笔记
9r3y的专栏
12-20 303
dynamic-update dynamic-insert                                                                     identity               mysql使用                                                    sequence
hibernate 关联映射学习备忘笔记
锄禾日当午，啥都不靠谱；闲来没事做，不如写博客。
07-15 209
这里是主控端统一为范围大的一方或者起主要作用的一方。 ------该博客仅为个人学习备忘所用，所有错漏欢迎指正。 单向一对一外键关联映射：package demo.pojo.o_o2o;public class Account { public Address getAddress() { return address; } publi
【学习笔记】Hibernate关联映射（Y2-1-6）
weixin_30325971的博客
01-18 64
Hibernate关联映射 关联映射就是将关联关系映射到数据库里，在对象模型中就是一个或多个引用。 1.单向多对一关联 准备数据库 部门表和员工表 其中部门表有两列 部门编号和名称 员工表有三列 员工ID 名称 和对应的部门id 部门和员工是一个1：N的关系（一个部门有多个员工 一个员工属于一个部门） Hibernate 小配置文件 <class nam...
hibernate关联关系笔记
u010585448的专栏
10-23 363
hibernate中的关联关系分为多对一关联，一对一关联和多对多关联。这几种关联关系很容易弄错，索性就记录在博客里。 一、多对一关联 多对一是最常见的关联关系，我们以QQ中的联系人（ContactPerson）和分组（Group）为例说明。ContactPerson与Group是多对一关系。 1.实体类 public class ContactPerson { private in
hibernate关联映射
程序员小董的专栏
06-09 906
本文可作为北京尚学堂马士兵hibernate课程的学习笔记。 hibernate的映射,主要分为一对一,一对多,多对一,多对多,同时还要单向与双向的区别。 OK,不要纠结于名字,我们开始看例子。 一对一单向 老公是一个实体,老婆也是一个实体。 一个老公只有一个老婆,同时一个老婆也只有一个老公。 上面的关系就叫做一对一。 什么叫单向呢。 看代码: package com.b
SSH Chapter 06 Hibernate 关联映射
weixin_40154786的博客
12-07 149
SSH Chapter 06 Hibernate 关联映射 笔记 本章目标: 理解Hibernate的关联映射 理解inverse属性、cascade属性 掌握单向的多对一、双向的一对多映射 掌握多对多映射 掌握延迟加载 技术内容: 前面我们已经掌握了如何配置Hibernate对数据库进行增,删,改,查操作,掌握Java对象的生命周期. 在学习面向对象时,学习过对象之间存在关联的关系. 在学习数据库时,也学习过表和表之间也可以通过外键关联起来. 怎样映射面向对象领域的关联关系和数据库关系中的外
Hibernate注解版关联关系映射全解析+案例
m0_72758098的博客
04-23 594
给大家送一个小福利附高清脑图，高清知识点讲解教程，以及一些面试真题及答案解析。送给需要的提升技术、准备面试跳槽、自身职业规划迷茫的朋友们。《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！注意[java]view plaincopy[外链图片转存中…(img-6F15TKWf-1713854767554)][外链图片转存中…(img-mjs0fzEU-1713854767554)]
Hibernate_容器映射技术笔记
05-21
本篇笔记主要探讨了如何使用Hibernate进行容器映射，特别是针对集合类型的映射，如List、Set和Map。 首先，我们来看集合类型在Hibernate中的映射： 1. **单值Collection**: 这种情况通常指的是一个对象与多个其他...
Hibernate学习笔记
04-19
008 多对一 关联映射 009 一对一 主键关联映射_单向 010 一对一 主键关联映射_双向 011 一对一 唯一外键关联映射_单向 012 一对一 唯一外键关联映射_双向 013 session_flush 014 一对多关联映射 单向 015 一对多关联...
hibernate第一天笔记
10-16
《Hibernate入门：第一天笔记详解》 Hibernate，作为Java领域中著名的ORM(Object-Relational Mapping)框架，极大地简化了数据库操作，让开发者可以更加专注于业务逻辑而不是底层的数据访问。本文将基于第一天学习...
NexusSetup.exe是Nexus设备设置程序的执行文件
06-25
这款Windows Dock栏工具解决了窗口遮挡问题，支持将窗口最小化至Dock栏，相比mydock稳定性更好，而相比bitdock体积更小，是一款适中的优秀选择，值得推荐。。内容来源于网络分享，如有侵权请联系我删除。另外如果没有积分的同学需要下载，请私信我。
某航天所智能制造实施方案(交付版).pptx
06-25
某航天所智能制造实施方案(交付版).pptx
opencv运动目标检测与跟踪源代码运动目标的检测与跟踪 ，有详细源代码。.rar
最新发布
06-25
opencv运动目标检测与跟踪源代码运动目标的检测与跟踪 ，有详细源代码。
AI视觉智慧城管解决方案.pptx
06-25
AI视觉智慧城管解决方案.pptx

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值