程序员经验分享-hwhale

Hibernate （一）

2023-11-11

一：配置Hibernate

使用JDBC做数据库相关功能开发会做很多重复性的工作，比如创建连接，关闭连接，把字段逐一映射到属性中。 Hibernate把这一切都封装起来了，使得数据库访问变得轻松而简单，代码也更加容易维护。

（1）先创建数据库表

数据库：test
表product_

use test;
 
CREATE TABLE product_ (
  id int(11) NOT NULL AUTO_INCREMENT,
  name varchar(30) ,
  price float ,
  PRIMARY KEY (id)
) DEFAULT CHARSET=UTF8;

（2）创建一个hibernate工程：

在这里插入图片描述

（3）导入hibernate所依赖的jar包

在右上角下载lib.rar,并解压到hibernate的项目目录下： e:\project\hibernate\lib 这个位置。
然后为这个java project导入jar包
导包步骤： 右键project->property->java build path->libaries->add external jars
在这里插入图片描述

（4）创建实体：product_

实体类 Product 用于映射数据库中的表product_
放在com.how2java.pojo 包中

package com.how2java.pojo;
  
public class Product {
    int id;
    String name;
    float price;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public float getPrice() {
        return price;
    }
    public void setPrice(float price) {
        this.price = price;
    }
      
}

（5） 配置 Product.hbm.xml

在包com.how2java.pojo下 新建一个配置文件Product.hbm.xml， 用于映射Product类对应数据库中的product_表
注: 文件名 Product.hbm.xml P一定要大写，要和类保持一致

<class name="Product" table="product_">

表示类Product对应表product_

<id name="id" column="id">
 <generator class="native">
 </generator>
</id>

表示属性id,映射表里的字段id
<generator class="native"> 意味着id的自增长方式采用数据库的本地方式

如果是连接oracle数据库，可以指定sequnce作为id自增长方式

<property name="name" />

这里配置的时候，只写了属性name,没有通过column="name" 显式的指定字段，那么字段的名字也是name.

<?xml version="1.0"?>

 
<hibernate-mapping package="com.how2java.pojo">
    <class name="Product" table="product_">
        <id name="id" column="id">
            <generator class="native">
            </generator>
        </id>
        <property name="name" />
        <property name="price" />
    </class>
     
</hibernate-mapping>

（6）配置 hibernate.cfg.xml

在src目录下创建 hibernate.cfg.xml
配置访问数据库要用到的驱动，url，账号密码等等
其他配置及含义：

<property name="dialect">org.hibernate.dialect.MySQLDialect</property>

这表示使用MYSQL方言。 什么方言呢？ 因为在代码层面，开发人员不用关心底层到底用Oracle还是Mysql，写的代码都是一样的。 可是Oracle和Mysql所用的sql语句的语法是有所区别的，那么这件事就交给Hibernate来做了。这个时候就需要告诉Hibernate底层用的是什么数据库，它才知道应该用什么样的“方言” 去对话。

<property name="current_session_context_class">thread</property>

这是Hibernate事务管理方式，即每个线程一个事务

<property name="show_sql">true</property>

这表示是否在控制台显示执行的sql语句

<property name="hbm2ddl.auto">update</property

这表示是否会自动更新数据库的表结构，有这句话，其实是不需要创建表的，因为Hibernate会自动去创建表结构

<mapping resource="com/how2java/pojo/Product.hbm.xml" />

这表示Hibernate会去识别Product这个实体类

<?xml version='1.0' encoding='utf-8'?>
 
<hibernate-configuration>
 
    <session-factory>
        <!-- Database connection settings -->
        <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="connection.url">jdbc:mysql://LOCALHOST:3306/test?characterEncoding=UTF-8</property>
        <property name="connection.username">root</property>
        <property name="connection.password">123</property>
        <!-- SQL dialect -->
        <property name="dialect">org.hibernate.dialect.MySQLDialect</property>
        <property name="current_session_context_class">thread</property>
        <property name="show_sql">true</property>
        <property name="hbm2ddl.auto">update</property>
        <mapping resource="com/how2java/pojo/Product.hbm.xml" />
    </session-factory>
 
</hibernate-configuration>

（7）创建 测试类 TestHibernate

创建一个Product对象，并通过hibernate把这个对象，插入到数据库中

hibernate的基本步骤是：

  1. 获取SessionFactory
  2. 通过SessionFactory 对象获取一个Session
  3. 在Session基础上开启一个事务
  4. 通过调用Session的save方法把对象保存到数据库
  5. 提交事务
  6. 关闭Session
  7. 关闭SessionFactory
package com.how2java.test;
 
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
 
import com.how2java.pojo.Product;
 
public class TestHibernate {
    public static void main(String[] args) {
 
        SessionFactory sf = new Configuration().configure().buildSessionFactory();
 		//获取SessionFactory
        Session s = sf.openSession();//通过SessionFactory 对象sf获取一个Session
        s.beginTransaction();//在Session基础上开启一个事务
 
        Product p = new Product();
        p.setName("iphone7");
        p.setPrice(7000);
        s.save(p);//通过调用Session对象 s 的save方法把对象保存到数据库
         
        s.getTransaction().commit();//提交事务
        s.close();//关闭 Session
        sf.close();// 关闭 SessionFactory
    }
 
}

（10）原理

应用程序通过Hibernate把 一个 Product对象插入到数据库的product_表中
hibernate.cfg.xml 配置文件提供链接数据库的基本信息
账号 密码 驱动 数据库ip 端口
Product.hbm.xml 提供对象与表的映射关系
对应哪个表？ 什么属性，对应什么字段
在这里插入图片描述
成功后，控制台会显示该图
在这里插入图片描述

二：对象状态

（1）Session

Java应用程序与Hibernate之间的主要运行时接口。它是抽象了持久化服务概念的核心抽象API类。

Session的生命周期绑定在一个物理的事务（tansaction）上面。（长的事务可能跨越多个数据库事物。）

Session的主要功能是提供对映射的实体类实例的创建，读取和删除操作。实例可能以下面三种状态存在：
实体类

（2）Session 对象的三种状态

对象在Hibernate中有3种状态
分别是瞬时，持久和脱管

  • 瞬时 指的是没有和hibernate发生任何关系，在数据库中也没有对应的记录，一旦JVM结束，这个对象也就消失了
  • 持久 指得是一个对象和hibernate发生联系，有对应的session,并且在数据库中有对应的一条记录
  • 脱管 指的是一个对象虽然在数据库中有对应的一条记录，但是它所对应的session已经关闭了
package com.how2java.test;
  
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
 
import com.how2java.pojo.Product;
  
public class TestHibernate {
    /**
     * @param args
     */
    public static void main(String[] args) {
  
        SessionFactory sf = new Configuration().configure().buildSessionFactory();
  
        Session s = sf.openSession();
        s.beginTransaction();
        Product p = new Product();
        p.setName("p1");
        System.out.println("此时p是瞬时状态");
        s.save(p);
        System.out.println("此时p是持久状态");
        s.getTransaction().commit();
        s.close();
        System.out.println("此时p是脱管状态");
        sf.close();
    }
  
}

new 了一个Product();，在数据库中还没有对应的记录，这个时候Product对象的状态是瞬时的。

通过Session的save把该对象保存在了数据库中，该对象也和Session之间产生了联系，此时状态是持久的。

最后把Session关闭了，这个对象在数据库中虽然有对应的数据，但是已经和Session失去了联系，相当于脱离了管理，状态就是脱管的

三、通过获取ID对象

调用Session的get方法，根据id获取对象。 除了id之外，还需要传递一个类对象，毕竟需要知道获取的是哪个对象

除了使用get方法，还可以使用load获取对象

package com.how2java.test;
  
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
  
import com.how2java.pojo.Product;
  
public class TestHibernate {
    public static void main(String[] args) {
        SessionFactory sf = new Configuration().configure().buildSessionFactory();
  
        Session s = sf.openSession();
        s.beginTransaction();
  		/*估计是根据类对象Product.class,ID=6,找到数据库数据，并封装，
  		然后转化为Product对象;
  		为什么这里是根据ID属性找对象的？？？
  		答：默认找主键
		*/
        Product p =(Product) s.get(Product.class, 6);
          
        System.out.println("id=6的产品名称是: "+p.getName());
          
        s.getTransaction().commit();
        s.close();
        sf.close();
    }
  
}

四：基础操作

（1）删除一条数据

 SessionFactory sf = new Configuration().configure().buildSessionFactory();
  
        Session s = sf.openSession();
        s.beginTransaction();
	    Product p =(Product) s.get(Product.class, 6);
	    s.delete(p);

（2）修改一条数据


SessionFactory sf = new Configuration().configure().buildSessionFactory(); 
        Session s = sf.openSession();
        s.beginTransaction(); 
        Product p =(Product) s.get(Product.class, 6);         
        System.out.println(p.getName());         
        p.setName("iphone-modified");         
        s.update(p);

（3）查询数据库 HQL（Hibernate Query Language）

sql 面向数据库表查询
hql 面向对象查询
hql ： from 后面跟的是 类名＋类对象 where 后 用 对象的属性做条件
sql： from 后面跟的是表名 where 后 用表中字段做条件
查询
在Hibernate中使用查询时，一般使用Hql查询语句。
HQL（Hibernate Query Language），即Hibernate的查询语言跟SQL非常相像。不过HQL与SQL的最根本的区别，就是它是面向对象的。

  1. 首先根据hql创建一个Query对象
  2. 设置参数(和基1开始的PreparedStatement不一样，Query是基0的)，但两者内容很类似（PrepareStatement不懂，具体看java web那一章）
  3. 通过Query对象的list()方法即返回查询的结果了。

注： 使用hql的时候，用的是类名Product,而不是表名product_
注： 使用hql的时候，不需要在前面加 select *
在这里插入图片描述

package com.how2java.test;
 
import java.util.List;
 
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
 
import com.how2java.pojo.Product;
 
public class TestHibernate {
    public static void main(String[] args) {
        SessionFactory sf = new Configuration().configure().buildSessionFactory();
 
        Session s = sf.openSession();
        s.beginTransaction();
 
        String name = "iphone";
        Query q =s.createQuery("from Product p where p.name like ?");
        // 这里是给 ？ 号赋值
        q.setString(0, "%"+name+"%");
        List<Product> ps= q.list();
        for (Product p : ps) {
            System.out.println(p.getName());
        }
         
        s.getTransaction().commit();
        s.close();
        sf.close();
    } 
}

（4）查询数据库Criteria

使用Criteria 查询数据（结果与hql一样）区别就是，相同的方法而产生的对象不一样

  1. 通过session的createCriteria创建一个Criteria 对象
  2. Criteria.add 增加约束。 在本例中增加一个对name的模糊查询(like)
  3. 调用list()方法返回查询结果的集合

除此之外，Criteria 还可以很方便的进行进行分页查询和获取总数

        Criteria c= s.createCriteria(Product.class);
        //通过session的createCriteria创建一个Criteria 对象
        //Criteria.add 增加约束。 在本例中增加一个对name的模糊查询(like)
        c.add(Restrictions.like("name", "%"+name+"%"));
        //调用list()方法返回查询结果的集合
        List<Product> ps = c.list();
        for (Product p : ps) {
            System.out.println(p.getName());
        }

（5）查询数据库createSQLQuery

前两者是面向对象查询，这里是面向数据库查询
使用Session的createSQLQuery方法执行标准SQL语句

因为标准SQL语句有可能返回各种各样的结果，比如多表查询，分组统计结果等等。 不能保证其查询结果能够装进一个Product对象中，所以返回的集合里的每一个元素是一个对象数组。 然后再通过下标把这个对象数组中的数据取出来。
在这里插入图片描述
结果是跟前两者一样的

  String sql = "select * from product_ p where p.name like '%"+name+"%'";
         
        Query q= s.createSQLQuery(sql);//这里标准数据库语句，而hql 则不是
        List<Object[]> list= q.list();
        for (Object[] os : list) {
            for (Object filed: os) {
                System.out.print(filed+"\t");
            }
            System.out.println();
        }

五：多表关系

（1）多对一（Product - Category）

一个Category 可以选择多个Product
一个 Product可以选择多个Category
所以:
Product 是多
Category 是 一
所以在“多“的配置文件中增加本表即product_的外键属性列

通过多对一关系，设置了id=8的产品对应 id=1的分类
product_表
在这里插入图片描述
Category.java

package com.how2java.pojo;
 
public class Category {
    int id;
    String name;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

}

Category.xml
映射Category 类：只有 id 和 name 两个属性

<?xml version="1.0"?>
 
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.how2java.pojo">
    <class name="Category" table="category_">
        <id name="id" column="id">
            <generator class="native">
            </generator>
        </id>
        <property name="name" />
    </class>
     
</hibernate-mapping>

Product.java
加入Category 对象作为属性
（应该是多对一关系的特有的）

package com.how2java.pojo;
public class Product {
    int id;
    String name;
    float price;
    Category category;
    public Category getCategory() {
        return category;
    }
    public void setCategory(Category category) {
        this.category = category;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public float getPrice() {
        return price;
    }
    public void setPrice(float price) {
        this.price = price;
    }
     
}

Product.hbm.xml 中设置Category 多对一关系
使用many-to-one 标签设置多对一关系
name="category" 对应Product类中的category属性
class="Category" 表示对应Category类
column="cid" 表示product_表中的外键列 cid列指向 category_表

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
 
<hibernate-mapping package="com.how2java.pojo">
    <class name="Product" table="product_">
        <id name="id" column="id">
            <generator class="native">
            </generator>
        </id>
 
        <property name="name" />
        <!--
        大概意思：Product类中的属性category 和 类Category 
        相映射，(这样从数据库查询后接收到数据才可以放在这个属性中)，
        并 在product_中设置外键 cid
        -->
        <many-to-one name="category" class="Category" column="cid" />
        <!--<many-to-one name 下 指的是本表product_ 的外键cid ，不是指外表-->
    </class>
     
</hibernate-mapping>

hibernate.cfg.xml

<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
       "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
 
    <session-factory>
        <!-- Database connection settings -->
        <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="connection.url">jdbc:mysql://localhost:3306/test?characterEncoding=GBK</property>
        <property name="connection.username">root</property>
        <property name="connection.password">admin</property>
        <!-- SQL dialect -->
        <property name="dialect">org.hibernate.dialect.MySQLDialect</property>
        <property name="current_session_context_class">thread</property>
        <property name="show_sql">true</property>
        <property name="hbm2ddl.auto">update</property>
        <mapping resource="com/how2java/pojo/Product.hbm.xml" />
        <!--在hibernate.cfg.xml中增加Category的映射 --> 
        <mapping resource="com/how2java/pojo/Category.hbm.xml" />
    </session-factory>
 
</hibernate-configuration>

TestHibernate.java
在这个测试例子中，增加了一个新的Category对象"c1"
并将其设置为id=8的product的category

package com.how2java.test;
  
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
 
import com.how2java.pojo.Category;
import com.how2java.pojo.Product;
 
public class TestHibernate {
    public static void main(String[] args) {
        SessionFactory sf = new Configuration().configure().buildSessionFactory();
  
        Session s = sf.openSession();
        s.beginTransaction();
         
        Category c =new Category();
        c.setName("c1");//创建了一个 Category 对象 c  
        s.save(c);// 并在数据库表category_ 中增加了一条数据：如下
        /*
				id			name
				1			 c1				
		*/
         // id 在category.xml 文件中就设置为自动增长了
        Product p = (Product) s.get(Product.class, 8);//从数据库冲取出 id为8的product
        p.setCategory(c);
        /* 在Product 对象 p 中赋值category属性，又因为这个属性是与 
        Category类 相映射的，所以与之相关联的外键 cid会变成 1；
        （就理解为java它固定这么做得吧，死公式样，等真正理解了再来解答）*/
        s.update(p);//将 id=8 的product数据库数据，写入（更新）数据库 
         
        s.getTransaction().commit();
        s.close();
        sf.close();
    }
}

在这里插入图片描述

（2）一对多：用set集合

一个Category对应多个Product
一个Product对应一个Category

所以:
Category 是 一
Product 是多
所以在“一“的配置文件中指向外表即product_的外键属性列
在这里插入图片描述
Category.java（增加set 集合对象 products）

package com.how2java.pojo;
 
import java.util.Set;
    int id;
    String name;
    Set<Product> products;
 
public class Category {
 
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

    public Set<Product> getProducts() {
        return products;
    }
    public void setProducts(Set<Product> products) {
        this.products = products;
    }
}

Category.xml（给 product设置映射 和一对多关系）

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
 
<hibernate-mapping package="com.how2java.pojo">
    <class name="Category" table="category_">
        <id name="id" column="id">
            <generator class="native">
            </generator>
        </id>
        <property name="name" />
 
        <set name="products" lazy="false">
        <!-- 在one-to-many 下 指明外表即product_ 的外键列是 cid
        （不是指本表category_的外键） -->
            <key column="cid" not-null="false" />
            <one-to-many class="Product" />
        </set>
                 
    </class>
     
</hibernate-mapping>

<set 用于设置一对多(多对多也是他)关系，也可以用list，设置稍复杂点，这里使用简单的set来入门。
name="products" 对应 Category类中的products属性
lazy="false" 表示不使用延迟加载。关于延迟加载，请参考关系的延迟加载
<key column="cid" not-null="false" /> 表示外键列是cid，可以为空（cid 是在product_中）
<one-to-many class="Product" /> 表示一对多所对应的类是Product

TestHibernate.java
获取归于目录 1 的 所有产品

package com.how2java.test;
  
import java.util.Set;
 
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
 
import com.how2java.pojo.Category;
import com.how2java.pojo.Product;
  
public class TestHibernate {
    public static void main(String[] args) {
        SessionFactory sf = new Configuration().configure().buildSessionFactory();
  
        Session s = sf.openSession();
        s.beginTransaction();
         
        Category c = (Category) s.get(Category.class, 1);
        Set<Product> ps = c.getProducts();
        for (Product p : ps) {
            System.out.println(p.getName());
        }
 
        s.getTransaction().commit();
        s.close();
        sf.close();
    }
}

（3）多对多 （User - Product）

User.java

package com.how2java.pojo;
 
import java.util.Set;
 
public class User {
 
    int id;
    String name;
    Set<Product> products;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Set<Product> getProducts() {
        return products;
    }
    public void setProducts(Set<Product> products) {
        this.products = products;
    }
}

User.hbm.xml


<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
 
<hibernate-mapping package="com.how2java.pojo">
    <class name="User" table="user_">
        <id name="id" column="id">
            <generator class="native">
            </generator>
        </id>
        <property name="name" />
 
        <set name="products" table="user_product" lazy="false">
            <key column="uid" />
            <many-to-many column="pid" class="Product" />
        </set>       
         
    </class>
     
</hibernate-mapping>

Product.java

package com.how2java.pojo;
 
import java.util.Set;
 
public class Product {
    int id;
    String name;
    float price;
    Category category;
    Set<User> users;
 
    public Set<User> getUsers() {
        return users;
    }
    public void setUsers(Set<User> users) {
        this.users = users;
    }
    public Category getCategory() {
        return category;
    }
    public void setCategory(Category category) {
        this.category = category;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public float getPrice() {
        return price;
    }
    public void setPrice(float price) {
        this.price = price;
    }
     
}

Product.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
 
<hibernate-mapping package="com.how2java.pojo">
    <class name="Product" table="product_">
        <id name="id" column="id">
            <generator class="native">
            </generator>
        </id>
        <property name="name" />
        <property name="price" />
        <many-to-one name="category" class="Category" column="cid" />
         
        <set name="users" table="user_product" lazy="false">
            <key column="pid" />//指向外表外键pid
            <many-to-many column="uid" class="User" />//增加本表外键uid
        </set>       
                 
    </class>
     
</hibernate-mapping>

hibernate.cfg.xml

<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
       "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
 
<hibernate-configuration>
 
    <session-factory>
        <!-- Database connection settings -->
        <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="connection.url">jdbc:mysql://localhost:3306/test?characterEncoding=GBK</property>
        <property name="connection.username">root</property>
        <property name="connection.password">admin</property>
        <!-- SQL dialect -->
        <property name="dialect">org.hibernate.dialect.MySQLDialect</property>
        <property name="current_session_context_class">thread</property>
        <property name="show_sql">true</property>
        <property name="hbm2ddl.auto">update</property>
        <mapping resource="com/how2java/pojo/Product.hbm.xml" />
        <mapping resource="com/how2java/pojo/Category.hbm.xml" />
        <mapping resource="com/how2java/pojo/User.hbm.xml" />
    </session-factory>
 
</hibernate-configuration>

TestHibernate.java
这里演示了一对多的关系：
即产品1被 3个user购买了

package com.how2java.test;
   
import java.util.HashSet;
import java.util.Set;
  
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
  
import com.how2java.pojo.Product;
import com.how2java.pojo.User;
   
public class TestHibernate {
    public static void main(String[] args) {
        SessionFactory sf = new Configuration().configure().buildSessionFactory();
   
        Session s = sf.openSession();
        s.beginTransaction();
          
        //在 user_表中增加3个用户
        Set<User> users = new HashSet();
        for (int i = 0; i < 3; i++) {
            User u =new User();
            u.setName("user"+i);
            users.add(u);
            s.save(u);
        }
          
        //peoduct_表中增加 产品1被用户1,2,3购买
        Product p1 = (Product) s.get(Product.class, 1);//在product 表中拿出 id = 1的对象
         // id = 1 的p对象它要对应3个user表的三个对象，所以中间表要跟着变 
        p1.setUsers(users);// 因为 p1中的 users 集合间接性是跟 user_表对应的
        s.save(p1);
        s.getTransaction().commit();
        s.close();
        sf.close();
    }
}

运行后的 user_product 表的状态
在这里插入图片描述

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

Hibernate

Hibernate （一） 的相关文章

随机推荐

  • LFU算法族：window-LFU

    LFU算法族相关文章目录汇总 LFU算法 LFU Aging算法 window LFU算法 本文 1 LFU算法的不足 LFU Least Frequently Used 是一种缓存淘汰算法 LFU算法是根据缓存的访问频率 去淘汰访问次数最

  • JS程序

    注 题目来源 力扣 给定一个字符串 s 找到 s 中最长的回文子串 你可以假设 s 的最大长度为 1000 示例 1 输入 babad 输出 bab 注意 aba 也是一个有效答案 解题思路 这个题目是直接拍脑袋想法 就是暴力求解 思路是这

  • c++ cin整数以，（逗号）分割读取

    1 某些场景整数流不是空格分割 如用逗号分割 例如 下面的输入 要求每行是一个数组 一共两行测试输入 1 2 3 4 5 6 7 8 下面的代码就可以很好的解决问题 vector

  • C# 系统应用之注册表使用详解

    在平时做项目时 我们有时会遇到注册表的操作 例如前面我们需要获取IE浏览器地址栏的信息 获取 我的电脑 地址栏输入的文件夹信息 USB最近使用信息等 注册表项是注册表的基本组织单位 它包含子表项和值条目 简言之 注册表项相当于注册表里的文件

  • 闭包函数的理解

    function fn return function s console log hello return function s1 console log world var s fn console log s var s1 s con

  • windows上安装openSSH服务

    在windows上cmd 然后ssh 主机用户 主机ip直接连到远程 很方便 如图 那么怎么配置呢 首先windows上需要安装openSSH 1 下载openSSH windows版 注 该版本是64位 链接 https pan baid

  • java casting意思_Java Casting方法，不知道要强制转换为什么

    我今天在玩Java 发现有些奇怪 考虑以下代码 String foo cast hi int bar cast 1 cast 方法在这里 public static lt T gt T cast Object value return T

  • tkinter 动态显示时间的方法

    问题描述 有些小伙伴在使用python做GUI界面的时候可能想添加这么一个小功能 就是在界面的某个角落动态的显示当前的时间 本文将介绍具体方法 方式一 使用组件的after方法 代码如下所示 import time import tkint

  • Vue3之watch和watchEffect实战总结

    watch和watchEffect都是vue3中的监听器 但是在写法和使用上是有区别的 主要是介绍一下watch和watchEffect的使用方法以及他们之间的区别 watch 的工作原理 侦听特定的数据源 并在回调函数中执行副作用 它默认

  • 高分辨率光学遥感影像舰船目标检测与识别算法研究（尹莹莹）

    论文阅读笔记 摘要 本文主要研究海陆背景下的光学遥感图像舰船目标检测与识别技术 重点研究了海陆分离 舰船目标疑似区域检测技术与疑似区域目标识别技术 海陆分离 采用了OTSU与形态学相结合的方法实现海路区域初步划分 再以孤立区域内像素的欧氏距

  • java中jdbc有哪几种形式呢?

    下文笔者讲述java中jdbc的形式简介说明 如下所示 JDBC驱动程序简介 JDBC驱动程序就是数据库厂商根据JDBC规范实现的JDBC实现类 JDBC驱动程序的类型 方式1 通过将JDBC的调用委托给其他编程接口来实现的 这种类型的驱动

  • EDK II Module Writers Guide上

    一 EDK2简介 1 EDK2工作流 二 EDK2 Packages 1 Packages介绍 EDK2 Packages是一个容器 其中包含一组模块及模块的相关定义 每个Package是一个EDK2单元 整个Project的源代码可以被分

  • Android正确的保活方案，不要掉进保活需求死循环陷进

    在开始前 还是给大家简单介绍一下 以前出现过的一些黑科技 大概在6年前Github中出现过一个叫MarsDaemon 这个库通过双进程守护的方式实现保活 一时间风头无两 好景不长 进入 Android 8 0时代之后 这个库就废掉了 最近2

  • 简单工厂模式和策略模式的比较

    代码结构图的区别 首先来看一下简单工厂模式 再看一下策略模式 看完他们的结构图 是不是有种很相似的感觉 唯一不同的就是 简单工厂类 和 Context类 接下来再看一下代码上有什么区别 简单工厂类和Context类中代码的区别 简单工厂类

  • linux查看mysql是否安装了驱动,Linux下查看mysql、apache是否安装,安装,卸载等操做...

    Linux下查看mysql apache是否安装 并卸载 php 指令 ps ef grep mysql 得出结果node root 17659 1 0 2011 00 00 00 bin sh usr bin mysqld safe da

  • Python一些经典例题（2）

    随机生成密码 编写程序 在26个字母大小写和9个数字组成的列表中随机生成10个8位密码 import random n 8 k 10 l list range 0 10 for x in range 65 91 l append chr x

  • DisplayPort1.4协议学习（一）DP协议概览

    DisplayPort1 4协议学习 一 DP协议概览 Note 本文为DP1 4协议学习系列的第一篇 本篇首先从DP整体结构上简要说明DP协议的传输方式 有关传输速率对比的问题 请STFW Search The Fucking Web D

  • 多态,反射及其相关

    多态是OOP的三大特征之一 字面意思 多种形态 多种状态 一个事物具备多种形态 例如 水 具备水蒸气 冰 赛博坦星人 汽车人 飞机人 汽车 动物 人 猿猴 猫 吃 叫 睡 官方描述 不同对象可以响应 调用 同一个方法 产生不同的结果 多态不

  • 用c++写一个windows窗口程序, 程序标题是你好

    include

  • Hibernate （一）

    文章目录 一 配置Hibernate 1 先创建数据库表 2 创建一个hibernate工程 3 导入hibernate所依赖的jar包 4 创建实体 product 5 配置 Product hbm xml 6 配置 hibernate

热门标签