Hibernate级联操作学习之持久化临时对象

最新推荐文章于 2025-07-28 23:27:29 发布
原创 最新推荐文章于 2025-07-28 23:27:29 发布 · 1.8k 阅读 · 2 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#hibernate #import #insert #class #generator #session

本文通过实例演示了在Hibernate框架中如何实现不同状态下的对象级联操作，包括瞬态、持久态和游离态，并详细解释了每种情况下级联保存、更新的行为。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

  在实际程序开发中，经常需要持久化临时对象，比如新建一个学生，将加入到一个存在的班级中（或者新建的一个班级），在这里不妨把引起级联操作的对象称为根对象（本文中所指的就是team对象） ，而根对象可能出于transient,persistence,detach三态，下面分别讨论

首先，建立数据库表：

 



CREATE TABLE certificate (
  id varchar(100) NOT NULL default '',
  description varchar(100) default '',
  PRIMARY KEY  (id)
);





CREATE TABLE student (
  team_id varchar(100) default '',
  id varchar(100) NOT NULL default '',
  name varchar(20) default '',
  cardId varchar(20) NOT NULL default '',
  age int(11) default '0',
  PRIMARY KEY  (id)
);






CREATE TABLE team (
  id varchar(100) NOT NULL default '',
  teamName varchar(100) default '',
  PRIMARY KEY  (id)
);



INSERT INTO certificate VALUES ('1','110108');
INSERT INTO certificate VALUES ('2','110109');

INSERT INTO student VALUES ('1','1','tomclus','2006m',33);
INSERT INTO student VALUES ('2','2','tom','2007m',22);
INSERT INTO team VALUES ('1','team1');

 

持久化对象Pojo

 


package Cascade.Relation;

public class Certificate {
    private String id;
    private String description;
    private Student stu;

    public Student getStu() {
        return stu;
    }

    public void setStu(Student stu) {
        this.stu = stu;
    }


    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }
}


package Cascade.Relation;

public class Student {
    private String id; //标识id
    private String cardId; //学号
    private String name; //学生姓名
    private int age; //岁数
    private Certificate cer;//身分证
    private Team team;//班级


     public int getAge() {
        return age;
    }

    public String getName() {
        return name;
    }

    public String getCardId() {
        return cardId;
    }

    public void setId(String id) {
        this.id = id;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void setName(String stuName) {
        this.name = stuName;
    }

    public void setCardId(String cardId) {
        this.cardId = cardId;
    }

    public String getId() {
        return id;
    }

    public Student() { //无参的构造函数
    }

     public Certificate getCer() {
        return cer;
    }
    public void setCer(Certificate pass) {
        this.cer = pass;
    }

    public Team getTeam() {
        return team;
    }

    public void setTeam(Team team) {
        this.team = team;
    }
}



package Cascade.Relation;

import java.util.HashSet;
import java.util.Set;


public class Team {
    private String id;
    private Set students=new HashSet();
    private String teamName;
    private Set tests;
  
    public Set getTests() {
        return tests;
    }
 
    public void setTests(Set tests) {
        this.tests = tests;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getTeamName() {
        return teamName;
    }

    public void setTeamName(String name) {
        this.teamName = name;
    }

    public Set getStudents() {
        return students;
    }

    public void setStudents(Set students) {
        this.students = students;
    }


}

 

Hibernate.cfg.xml

 

<?xml version='1.0' encoding='UTF-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
          "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
          "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<!-- Generated by MyEclipse Hibernate Tools.                   -->
<hibernate-configuration>

<session-factory>
    <property name="connection.username">root</property>
    <property name="connection.url">
        jdbc:mysql://localhost:3306/schoolproject?characterEncoding=gb2312&amp;useUnicode=true
    </property>
    <property name="dialect">
        org.hibernate.dialect.MySQLDialect
    </property>
    <property name="myeclipse.connection.profile">mysql</property>
    <property name="connection.password">1234</property>
    <property name="connection.driver_class">
        com.mysql.jdbc.Driver
    </property>
    <property name="hibernate.dialect">
        org.hibernate.dialect.MySQLDialect
    </property>
    <property name="hibernate.show_sql">true</property>
    <property name="current_session_context_class">thread</property>
    <mapping resource="Cascade/Relation/Certificate.hbm.xml" />
    <mapping resource="Cascade/Relation/Student.hbm.xml" />
    <mapping resource="Cascade/Relation/Team.hbm.xml" />

</session-factory>

</hibernate-configuration>

 

HBM配置文件，其中Team到Student是cascade="save-update",Student到Certificate是cascade="all"

Team.hbm.xml

 

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- 
    Mapping file autogenerated by MyEclipse - Hibernate Tools
-->
<hibernate-mapping package="Cascade.Relation" >
    <class name="Cascade.Relation.Team" table="team" lazy="true">
       <id name="id" column="id">
         <generator class="uuid.hex"></generator>
       </id>
       <property name="teamName" column="teamName"></property>
       
       <set name="students" lazy="true" 
            cascade="save-update"
            inverse="false">
         <key column="team_id"></key>
         <one-to-many class="Cascade.Relation.Student"/>
       </set>
      </class>
</hibernate-mapping>

 

Student.hbm.xml

 

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- 
    Mapping file autogenerated by MyEclipse - Hibernate Tools
-->
<hibernate-mapping package="Cascade.Relation" >
   
    <class name="Cascade.Relation.Student" table="student" lazy="true">
       <id name="id" column="id" unsaved-value="null">
         <generator class="uuid.hex"></generator>
       </id>

       <property name="cardId" column="cardId"></property>
       <property name="name" column="name"></property>
       <property name="age" column="age"></property>
       <!--推荐1对多，多对多使用延迟加载，而多1对1，多对1采用预先抓取-->
       <one-to-one name="cer" 
                   class="Cascade.Relation.Certificate"
                   constrained="true" 
                   fetch="join" 
                   cascade="all">
       </one-to-one>
      
      <!--推荐1对多，多对多使用延迟加载，而多1对1，多对1采用预先抓取-->
       <many-to-one name="team" 
                    column="team_id"
                    fetch="select"
                    cascade="none"
                    class="Cascade.Relation.Team"></many-to-one>
      </class>
</hibernate-mapping>

 

Certificate.hbm.xml

 

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- 
    Mapping file autogenerated by MyEclipse - Hibernate Tools
-->
<hibernate-mapping package="Cascade.Relation" > 
    <class name="Cascade.Relation.Certificate" table="certificate" lazy="false">
       <!-- 共享主键关联，在子方配置constrained=true -->
       <id name="id" column="id">
         <generator class="foreign">
           <param name="property">stu</param>
         </generator>
       </id>


       <property name="description" column="description"></property>
       <!--推荐1对多，多对多使用延迟加载，而多1对1，多对1采用预先抓取-->
       <one-to-one name="stu" 
                   class="Cascade.Relation.Student"
                   fetch="join"
                   cascade="none" 
                   constrained="true">
       </one-to-one>
      </class>
</hibernate-mapping>

 

（1）根对象为瞬态

         测试程序：

                

package Cascade.Relation;

import java.io.File;
import java.io.FileInputStream;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;

public class TestTransient {


    public static void main(String[] args) {
        String filePath=System.getProperty("user.dir")+File.separator+"src/Cascade/Relation"+File.separator+"hibernate.cfg.xml";
        File file=new File(filePath);
        SessionFactory sessionFactory=new Configuration().configure(file).buildSessionFactory();
        Session session=sessionFactory.openSession();
        Transaction t=session.beginTransaction();
        /*
         * 发起级联的team为瞬态，team对student级联更新，student对certificate级联更新
         */
        //新建学生
        Student stu=new Student();
        stu.setName("gao");
        stu.setCardId("12345678");
        stu.setAge(27);
        
        //新建班级
        Team team=new Team();
        team.setTeamName("981");
        
        //新建身份证
        Certificate cer=new Certificate();
        cer.setDescription("idcard");
        
        //设置team和student的关联关系
        stu.setTeam(team);
        team.getStudents().add(stu);
        //设置Student和Certificate的关联关系
        stu.setCer(cer);
        cer.setStu(stu);
        
        session.save(team);    
        t.commit();

    }

}

 

结果：

Hibernate: insert into team (teamName, id) values (?, ?)
Hibernate: insert into certificate (description, id) values (?, ?)
Hibernate: insert into student (cardId, name, age, team_id, id) values (?, ?, ?, ?, ?)

可以看到，保存team同时，也保存的student及certificte

（2）根对象为持久态

         测试程序：

 

package Cascade.Relation;

import java.io.File;
import java.io.FileInputStream;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;

public class TestPersistence {


    public static void main(String[] args) {
        String filePath=System.getProperty("user.dir")+File.separator+"src/Cascade/Relation"+File.separator+"hibernate.cfg.xml";
        File file=new File(filePath);
        SessionFactory sessionFactory=new Configuration().configure(file).buildSessionFactory();
        Session session=sessionFactory.openSession();
        Transaction t=session.beginTransaction();
        /*
         * 发起级联的team为持久态，team对student级联更新，student对certificate级联更新
         */
        //新建学生
        Student stu=new Student();
        stu.setName("gao");
        stu.setCardId("12345678");
        stu.setAge(27);
        

        
        //新建身份证
        Certificate cer=new Certificate();
        cer.setDescription("idcard");
        

        //设置Student和Certificate的关联关系
        stu.setCer(cer);
        cer.setStu(stu);
        
        
        //读取Team
        Team team=(Team)session.get(Team.class, "1");
        team.getStudents().add(stu);//设置team和student关系
        session.save(team);    
        t.commit();

    }

}

 

结果：

Hibernate: select team0_.id as id2_0_, team0_.teamName as teamName2_0_ from team team0_ where team0_.id=?
Hibernate: select students0_.team_id as team5_3_, students0_.id as id3_, students0_.id as id1_2_, students0_.cardId as cardId1_2_, students0_.name as name1_2_, students0_.age as age1_2_, students0_.team_id as team5_1_2_, certificat1_.id as id0_0_, certificat1_.description as descript2_0_0_, student2_.id as id1_1_, student2_.cardId as cardId1_1_, student2_.name as name1_1_, student2_.age as age1_1_, student2_.team_id as team5_1_1_ from student students0_ inner join certificate certificat1_ on students0_.id=certificat1_.id left outer join student student2_ on certificat1_.id=student2_.id where students0_.team_id=?

Hibernate: insert into certificate (description, id) values (?, ?)
Hibernate: insert into student (cardId, name, age, team_id, id) values (?, ?, ?, ?, ?)

可以看到，前两个sql是读取team及fetch,然后保存certificate和student

 

（3）根对象是游离态

            测试程序：

               

package Cascade.Relation;

import java.io.File;
import java.io.FileInputStream;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;

public class TestDetach {


    public static void main(String[] args) {
        String filePath=System.getProperty("user.dir")+File.separator+"src/Cascade/Relation"+File.separator+"hibernate.cfg.xml";
        File file=new File(filePath);
        SessionFactory sessionFactory=new Configuration().configure(file).buildSessionFactory();
        Session session=sessionFactory.openSession();
        Session session2=sessionFactory.openSession();
        Transaction t=session.beginTransaction();
        
        /*
         * 发起级联的team为游离态，team对student级联更新，student对certificate级联更新
         */
        //新建学生
        Student stu=new Student();
        stu.setName("gao");
        stu.setCardId("12345678");
        stu.setAge(27);
        

        
        //新建身份证
        Certificate cer=new Certificate();
        cer.setDescription("idcard");
        

        //设置Student和Certificate的关联关系
        stu.setCer(cer);
        cer.setStu(stu);
        
        
        //读取Team
        Team team=(Team)session.get(Team.class, "1");

        t.commit();
        session.close();//读取完后关闭session,team变成游离态
        
        Transaction t2=session2.beginTransaction();
        team.getStudents().add(stu);//设置team和student关系
        session2.update(team);//用另一个session重新激活team为持久太
        t2.commit();

    }

}

     运行结果会出现异常如下：

xception in thread "main" org.hibernate.LazyInitializationException: failed to lazily initialize a collection of role: Cascade.Relation.Team.students, no session or session was closed

这是因为，我们Team对Student是延迟加载，读取Team后，session关闭，重新把team通过另一个session2变成持久后，team.getStudent()是取不到任何东西的，因为其student集合没有得到初始化，所以我们企图用team.getStudent().add(student)的方式级联保存student是不行的，解决方式很简单，讲Team.hbm.xml中Team对Student的lazy=true 改成lazy=false 结果如下：

Hibernate: select team0_.id as id2_0_, team0_.teamName as teamName2_0_ from team team0_ where team0_.id=?
Hibernate: select students0_.team_id as team5_3_, students0_.id as id3_, students0_.id as id1_2_, students0_.cardId as cardId1_2_, students0_.name as name1_2_, students0_.age as age1_2_, students0_.team_id as team5_1_2_, certificat1_.id as id0_0_, certificat1_.description as descript2_0_0_, student2_.id as id1_1_, student2_.cardId as cardId1_1_, student2_.name as name1_1_, student2_.age as age1_1_, student2_.team_id as team5_1_1_ from student students0_ inner join certificate certificat1_ on students0_.id=certificat1_.id left outer join student student2_ on certificat1_.id=student2_.id where students0_.team_id=?

Hibernate: insert into certificate (description, id) values (?, ?)
Hibernate: insert into student (cardId, name, age, team_id, id) values (?, ?, ?, ?, ?)
Hibernate: update team set teamName=? where id=?
Hibernate: update student set cardId=?, name=?, age=?, team_id=? where id=?
Hibernate: update certificate set description=? where id=?
Hibernate: update student set team_id=? where id=?

主意红色的三条SQL,如果我们脱管根对象没有发生过任何改变，则这些update是没有意义的，我们可以在hbm配置文件中的class级别加上select-before-update="true" 在运行update之前先吧数据库中的数据和脱管对象进行比较，如果不同，再进行更新，如下：

Hibernate: select team0_.id as id2_0_, team0_.teamName as teamName2_0_ from team team0_ where team0_.id=?

Hibernate: select students0_.team_id as team5_3_, students0_.id as id3_, students0_.id as id1_2_, students0_.cardId as cardId1_2_, students0_.name as name1_2_, students0_.age as age1_2_, students0_.team_id as team5_1_2_, certificat1_.id as id0_0_, certificat1_.description as descript2_0_0_, student2_.id as id1_1_, student2_.cardId as cardId1_1_, student2_.name as name1_1_, student2_.age as age1_1_, student2_.team_id as team5_1_1_ from student students0_ inner join certificate certificat1_ on students0_.id=certificat1_.id left outer join student student2_ on certificat1_.id=student2_.id where students0_.team_id=?

Hibernate: select team_.id, team_.teamName as teamName2_ from team team_ where team_.id=?
Hibernate: select student_.id, student_.cardId as cardId1_, student_.name as name1_, student_.age as age1_, student_.team_id as team5_1_ from student student_ where student_.id=?
Hibernate: select certificat_.id, certificat_.description as descript2_0_ from certificate certificat_ where certificat_.id=?

Hibernate: insert into certificate (description, id) values (?, ?)
Hibernate: insert into student (cardId, name, age, team_id, id) values (?, ?, ?, ?, ?)
Hibernate: update student set team_id=? where id=?

这样会多出一些Select SQL,但相比update,效率要高很多

深入理解Hibernate级联删除机制
m0_62153576的博客
08-18 423
级联删除是指当删除一个实体时，与之关联的其他实体也会自动被删除。例如，在员工与任务的关系中，删除一个员工时，其负责的所有任务也应该被删除。Hibernate通过@OneToMany注解的cascade属性来实现这一功能。Employee和Task。Employee类包含一个List类型的字段，表示员工负责的任务列表。@Entity@Id// 省略getter和setter方法@Entity@Id// 省略getter和setter方法。
Hibernate级联操作.docx
09-11
级联操作定义了当主对象被持久化（保存、更新、删除等）时，与之关联的对象应该如何被处理。在 Hibernate 中，`cascade` 属性可以接受多个参数，如： 1. `all`：在所有操作中都级联关联操作，包括保存、更新、删除...
Hibernates关于临时对象，持久化对象等等
xiaozhengN的博客
09-19 484
org.hibernate.StaleStateException: Batch update returned unexpected row count from update [0]; actual row count: 0; expected: 1     at org.hibernate.jdbc.Expectations$BasicExpectation.checkBatched(Exp...
hibernate级联(cascade和inverse)
mmdev
06-11 170
级联（Cascade）,两个以上的设备通过某种方式连接起来，能起到扩容的效果就是级联。Hibernate级联(Cascade)是用来说明数据库中连个表之间的相互关系（一对一，一对多，多对多）中，当对主对象进行某种操作时，是否也对其关联的从对象作类似的操作，常见的级联（Cascade）有： （1）none:在保存，删除或者修改当前对象时，不对其附属对象（关联对象）进行级联操作，它为默认值。 （2...
hibernate详解（四）---对象关系之级联
m0_46616045的博客
07-08 438
Hibernate对象关系之级联 级联及组合关系:强聚合关系,代表整体和部分之间不能分开,整体和部分单独存在没有意义; 组合关系的两个对象都是在一个模块当中管理的;都是在整体那个对象的模块中管理; （1）以销售订单（主对象）和订单的明细数据（子对象）为例分析: 对于销售订单对象来说: 1、存在一个列表; 2、添加:在添加页面需要添加销售订单对象上的属性,还需要添加这个销售订单的明细数据; 3、修改:仍然在销售订单的编辑页面中完成; 4、删除:在销售订单列表中删除销售订单; 对于销售订单明细对象来说: 1、
精通Hibernate——级联操纵对象
路漫漫，水迢迢
08-29 972
当我们加载一个类时session会加载所有和该类直接关联或者间接关联的对象。 在对象关系映射文件中，用于映射持久化类之间关联关系的元素，如、和元素，都有一个cascade属性，他用于指定如何操纵与当前关联的对象，他的可选属性如下： none：在保存、更新或删除对象时，忽略其他关联的对象，他是cascade默认属性 save-update：当通过session的save、update以及save
java 对象 级联 关联表6_持久化对象级联关系
weixin_39898380的博客
02-24 154
类之间关联的Hibernate表现在Java程序中,类之间存在多种包含关系,典型的三种关联关系有:一个类拥有另一个类的成员,一个类拥有另一个类的集合的成员;两个类相互拥有对象的集合的成员.在Hibernate中,我们可以使用映射文件中的many-to-one, one-to-many, many-to-many来实现它们.这样的关系在Hibernate中简称为多对一,一对多和多对多.多对一的类代码...
Hibernate级联持久化对象
iteye_20446的博客
05-06 127
级联保存和更新 当Hibernate持久化一个临时对象时，在默认情下，他不会自动持久化所关联的其他临时对象，如果希望当持久化对象时把他所关联的所有临时对象进行持久化的话：可以把 的cascade属性设置为"save-update" ,cascade的默认属性值为none。 cascade:设置操作对象时的级联操作，即层级之间的连锁操作 值 save-update ：表示当保存和更...
Hibernate级联加载到session持久层中与事务回滚
u010789532的博客
02-08 532
一，级联加载到session持久层中：      当hibernate映射文件设置lazy=false的时候，即级联加载，你在Java代码中load,或get一个对象的时候，其他的级联对象全都给加载到session持久化中。如果外面传 入了某一个对象（这个对象要在该方法的这个session个持久化中）的游离态的话，要想保持这个对象，方法有两种：1种，在方法里面重新开启session事务管理，
hibernate级联操作
Captain249的博客
01-04 362
CascadeType.REMOVE 级联删除操作。 删除当前实体时，与它有映射关系的实体也会跟着被删除。 CascadeType.MERGE 级联更新（合并）操作。当Student中的数据改变，会相应地更新Course中的数据。 CascadeType.DETACH 级联脱管/游离操作。 如果你要删除一个实体，但是它有外键无法删除，你就需要这个级联权限了。它会撤销所有相关的外键关联。...
精通Hibernate：Java对象持久化详解.zip
08-12
通过阅读《精通Hibernate：Java对象持久化详解》，开发者可以深入了解Hibernate的工作原理，学习如何有效地使用它来实现对象持久化，从而提高开发效率，降低维护成本。这本书对于Java Web开发者，尤其是初次接触...
hibernate 级联查询
04-23
“Hibernate 级联查询”是指在使用Hibernate这个Java持久化框架时，如何处理对象之间的关联查询。Hibernate提供了级联操作来简化数据的保存、更新和删除等操作，使得开发者无需手动编写复杂的SQL语句，就能实现关联...
Hibernate的级联操作(增，删，该)
06-28
当我们对一个实体对象进行操作时，可以设置级联属性，让这些操作自动传播到与之相关联的其他对象，从而减少代码的冗余和复杂性。接下来，我们将详细探讨Hibernate的级联操作，包括增、删、改这三种主要操作。 1. ...
应急响应处置案例(上)
Neolock的博客
07-28 1037
Web安全事件应急响应案例
信捷XC系列PLC主从通讯程序设计与实现——工业自动化控制核心技术
08-09
信捷XC系列PLC主从通讯程序的设计与实现方法。信捷XC系列PLC是一款高性能、高可靠性的可编程逻辑控制器，在工业自动化领域广泛应用。文中阐述了主从通讯的基本概念及其重要性，具体讲解了配置网络参数、编写程序、数据交换以及调试与测试四个主要步骤。此外，还探讨了该技术在生产线控制、仓储物流、智能交通等多个领域的应用实例，强调了其对系统效率和稳定性的提升作用。 适合人群：从事工业自动化控制的技术人员、工程师及相关专业学生。 使用场景及目标：适用于需要多台PLC协同工作的复杂工业控制系统，旨在提高系统的效率和稳定性，确保各设备间的数据交换顺畅无误。 其他说明：随着工业自动化的快速发展，掌握此类通信协议和技术对于优化生产流程至关重要。
Qt 5.12.4与Halcon构建视觉流程框架：编译与测试的成功实践
08-09
如何将Halcon视觉技术和Qt框架相结合，构建一个强大的视觉处理流程框架。文中首先阐述了选择Qt 5.12.4的原因及其优势，接着描述了框架的具体构建方法，包括利用Qt的跨平台特性和界面设计工具创建用户界面，以及用Halcon进行图像处理与识别。随后，文章讲解了编译过程中需要注意的关键步骤，如正确引入Halcon的头文件和库文件，并提供了一个简单的代码示例。最后，作者分享了测试阶段的经验，强调了确保系统在各种情况下都能正常工作的必要性。通过这次实践，证明了两者结合可以带来更高效、更稳定的视觉处理解决方案。 适合人群：具有一定编程经验的技术人员，尤其是对计算机视觉和图形界面开发感兴趣的开发者。 使用场景及目标：适用于希望深入了解Qt与Halcon集成应用的开发者，旨在帮助他们掌握从框架搭建到实际部署的全过程，从而提升自身技能水平。 阅读建议：读者可以在阅读过程中跟随作者的步伐逐步尝试相关操作，以便更好地理解和吸收所介绍的知识点和技术细节。
【CAD入门基础课程】1.4 AutoCAD2016 功能介绍.avi
最新发布
08-09
一、AutoCAD 2016的新增功能 版本演进: 从V1.0到2016版已更新数十次，具备绘图、编辑、图案填充、尺寸标注、三维造型等完整功能体系 界面优化: 新增暗黑色调界面：使界面协调深沉利于工作 底部状态栏整体优化：操作更实用便捷 硬件加速：效果显著提升运行效率 核心新增功能: 新标签页和功能区库：改进工作空间管理 命令预览功能：增强操作可视化 地理位置和实景计算：拓展设计应用场景 Exchange应用程序和计划提要：提升协同效率 1. 几何中心捕捉功能 新增选项: 在对象捕捉模式组中新增"几何中心"选项 可捕捉任意多边形的几何中心点 启用方法: 通过草图设置对话框→对象捕捉选项卡 勾选"几何中心(G)"复选框(F3快捷键启用) 2. 标注功能增强 DIM命令改进: 智能标注创建：基于选择的对象类型自动适配标注方式 选项显示优化：同时在命令行和快捷菜单中显示标注选项 应用场景: 支持直线、圆弧、圆等多种图形元素的智能标注 3. 打印输出改进 PDF输出增强: 新增专用PDF选项按钮 支持为位图对象添加超链接 可连接到外部网站和本地文件 操作路径: 快速访问工具栏→打印按钮→PDF选项对话框 4. 其他重要更新 修订云线增强: 支持创建矩形和多边形云线 新增虚拟线段编辑选项 系统变量: 新增多个控制新功能的系统变量
电力电子领域单相PWM整流模型的主电路与控制模块实现研究
08-09
内容概要：本文详细探讨了单相PWM整流模型的设计与实现，重点介绍了主电路和控制模块的具体实现方法。主电路作为整流模型的核心部分，涉及功率因数、电流稳定性和调节范围等因素，常采用全桥或多级整流等拓扑结构。控制模块则由PWM控制器、传感器和执行器组成，负责调节交流电源的输入，实现所需电压和电流波形。文中还强调了算法设计、硬件接口设计和参数调整与优化的重要性，指出这些因素对于提高整流效果和效率至关重要。 适合人群：从事电力电子领域的研究人员、工程师及相关专业的学生。 使用场景及目标：适用于希望深入了解单相PWM整流模型工作原理和技术细节的人群，旨在帮助他们掌握主电路和控制模块的设计要点，提升电力系统的稳定性和效率。 其他说明：文中提到的相关技术可以通过进一步查阅专业文献和技术资料获得更深入的理解。
这是sanllin的第一次尝试开发app，调用kimi的文本识别和图像识别
08-09
资源下载链接为： https://pan.quark.cn/s/39ff61edf06f 这是sanllin的第一次尝试开发app，调用kimi的文本识别和图像识别（最新、最全版本！打开链接下载即可用！）
Hibernate级联操作详解：增删改的实践指南
Hibernate是一个广泛使用的Java持久化框架，它通过对象关系映射（ORM）实现数据持久化。Hibernate的级联操作是指在进行对象的增加、删除和更新操作时，可以定义对象间的关系和操作的传播行为。这个特性允许开发者...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值