Hibernate 技术（一）

Hibernate

简介

   
   
   
   
   

    
    
    
    
    
1
    
    
    
    
    
2
    
    
    
    
    
3
    
    
    
    
    
4
    
    
    
    
    
5
    
    
    
    
    
6
    
    
    
    
    
7
    
    
    
    
    
8
   
   
   
   
   
Hibernate是一个开源的对象关系映射（ORM）框架。对JDBC进行了很是轻量级的对象封装。 

将对象和数据库表创建映射关系，Hibernate框架使用在数据持久化层（dao）。 

ORM：对象关系映射（英语：Object Relational Mapping）

采用映射元数据（配置文件）来描述对象-关系的映射细节。ORM框架经过配置文件将实体对象和数据库表对应起来。

第一个Hibernate小例子

   
   
   
   
   

    
    
    
    
    
1
    
    
    
    
    
2
    
    
    
    
    
3
    
    
    
    
    
4
    
    
    
    
    
5
    
    
    
    
    
6
    
    
    
    
    
7
    
    
    
    
    
8
    
    
    
    
    
9
    
    
    
    
    
10
    
    
    
    
    
11
    
    
    
    
    
12
    
    
    
    
    
13
    
    
    
    
    
14
    
    
    
    
    
15
    
    
    
    
    
16
    
    
    
    
    
17
    
    
    
    
    
18
    
    
    
    
    
19
    
    
    
    
    
20
    
    
    
    
    
21
    
    
    
    
    
22
    
    
    
    
    
23
    
    
    
    
    
24
    
    
    
    
    
25
    
    
    
    
    
26
    
    
    
    
    
27
    
    
    
    
    
28
    
    
    
    
    
29
    
    
    
    
    
30
    
    
    
    
    
31
    
    
    
    
    
32
    
    
    
    
    
33
    
    
    
    
    
34
   
   
   
   
   
前提准备：导入jar包
        须要的jar包 hibernate路径下下lib/required的全部jar包和jpa目录下的jar包
        mysql驱动jar包


            第一步：建立实体类

            Hibernate要求实体类必须提供一个不带参数的默认构造方法。由于程序运行时，Hibernate会运用java的反射机制，建立实体类的实例。 

            public class User {
                private int id;   
                private String name;
                private String password;
                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 String getPassword() {
                    return password;
                }
                public void setPassword(String password) {
                    this.password = password;
                }

            }

   
   
   
   
   

    
    
    
    
    
1
    
    
    
    
    
2
    
    
    
    
    
3
    
    
    
    
    
4
    
    
    
    
    
5
    
    
    
    
    
6
    
    
    
    
    
7
    
    
    
    
    
8
    
    
    
    
    
9
   
   
   
   
   
第二步：建立对应的数据库表 

            CREATE DATABASE hibernate;
            USE hibernate;
            CREATE TABLE USER( id INT PRIMARY KEY AUTO_INCREMENT, name VARCHAR(50), password VARCHAR(50) );

   
   
   
   
   

    
    
    
    
    
1
    
    
    
    
    
2
    
    
    
    
    
3
    
    
    
    
    
4
    
    
    
    
    
5
    
    
    
    
    
6
    
    
    
    
    
7
    
    
    
    
    
8
    
    
    
    
    
9
    
    
    
    
    
10
    
    
    
    
    
11
    
    
    
    
    
12
    
    
    
    
    
13
    
    
    
    
    
14
    
    
    
    
    
15
    
    
    
    
    
16
    
    
    
    
    
17
    
    
    
    
    
18
    
    
    
    
    
19
    
    
    
    
    
20
    
    
    
    
    
21
    
    
    
    
    
22
    
    
    
    
    
23
   
   
   
   
   
第三步：建立Hibernate的配置文件，放在src目录下，文件名为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>
    <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>//指定数据库的驱动程序
    <property name="hibernate.connection.username">root</property>//数据库的用户名
    <property name="hibernate.connection.password">123456</property>//数据库的密码
    <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernate</property>//链接数据库的url

    <property name="show_sql">true</property>//为true时会在控制台输出sql语句，有利于跟踪hibernate的状态
    <property name="format_sql">true</property>//会格式化输出sql语句
    <property name="hbm2ddl.auto">update</property>
    <property name="hibernate.connection.autocommit">true</property>//自动提交事务

    <mapping resource="com/cad/domain/User.hbm.xml"/>//引入映射文件

</session-factory>
</hibernate-configuration>

   
   
   
   
   

    
    
    
    
    
1
    
    
    
    
    
2
    
    
    
    
    
3
    
    
    
    
    
4
    
    
    
    
    
5
    
    
    
    
    
6
    
    
    
    
    
7
    
    
    
    
    
8
    
    
    
    
    
9
    
    
    
    
    
10
    
    
    
    
    
11
    
    
    
    
    
12
    
    
    
    
    
13
    
    
    
    
    
14
    
    
    
    
    
15
    
    
    
    
    
16
    
    
    
    
    
17
    
    
    
    
    
18
   
   
   
   
   
第四步：建立对象-关系映射文件
            该文件应该和实体类在同一目录下。命名规则为 实体类名.hbm.xml 例如User.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">

<hibernate-mapping> //根元素
<class name="com.cad.domain.User" table="user"> //指定实体类和对应的数据表
    <id name="id" column="id">                 //<id>元素设定类中的id和表的主键id的映射
        <generator class="native"></generator> //<gender>元素指定对象标识符生成器，负责生成惟一id。之后会详细讲
    </id>
    <property name="name" column="name"></property> //name是实体类属性的名字，column是数据表中列的名字
    <property name="password" column="password"></property>
</class>
</hibernate-mapping>

   
   
   
   
   

    
    
    
    
    
1
    
    
    
    
    
2
    
    
    
    
    
3
    
    
    
    
    
4
    
    
    
    
    
5
    
    
    
    
    
6
    
    
    
    
    
7
    
    
    
    
    
8
    
    
    
    
    
9
    
    
    
    
    
10
    
    
    
    
    
11
    
    
    
    
    
12
    
    
    
    
    
13
    
    
    
    
    
14
    
    
    
    
    
15
    
    
    
    
    
16
    
    
    
    
    
17
    
    
    
    
    
18
    
    
    
    
    
19
    
    
    
    
    
20
    
    
    
    
    
21
    
    
    
    
    
22
   
   
   
   
   
第五步：调用HibernateAPI操做数据库
            public class Demo {
                @Test
                public void test() {
                    //读取配置文件
                    Configuration conf=new Configuration().configure();
                    //根据配置建立factory
                    SessionFactory sessionfactory=conf.buildSessionFactory();
                    //得到操做数据库的session对象
                    Session session=sessionfactory.openSession(); 
                    //建立对象
                    User u=new User();
                    u.setName("张三");
                    u.setPassword("123456");
                    //将对象保存到数据库
                    session.save(u);
                    //关闭资源
                    session.close();
                    sessionfactory.close();
                }

            }

经过上面的小例子，咱们大体了解了使用Hibernate的流程，接下来让咱们详解Hibernate。

详解Hibernate配置文件

   
   
   
   
   

    
    
    
    
    
1
    
    
    
    
    
2
   
   
   
   
   
Hibernate从其配置文件中读取和数据库链接有关的信息。Hibernate配置文件有两种形式，XML格式或者java属性文件（properties）格式。

   
   
   
   
   

    
    
    
    
    
1
    
    
    
    
    
2
    
    
    
    
    
3
    
    
    
    
    
4
    
    
    
    
    
5
    
    
    
    
    
6
    
    
    
    
    
7
    
    
    
    
    
8
    
    
    
    
    
9
    
    
    
    
    
10
    
    
    
    
    
11
    
    
    
    
    
12
    
    
    
    
    
13
    
    
    
    
    
14
    
    
    
    
    
15
    
    
    
    
    
16
    
    
    
    
    
17
    
    
    
    
    
18
    
    
    
    
    
19
    
    
    
    
    
20
    
    
    
    
    
21
    
    
    
    
    
22
    
    
    
    
    
23
    
    
    
    
    
24
    
    
    
    
    
25
    
    
    
    
    
26
    
    
    
    
    
27
    
    
    
    
    
28
    
    
    
    
    
29
   
   
   
   
   
(一)java属性文件的格式建立hibernate的配置文件，默认文件名为hibernate.properties，为键值对的形式，放在src目录下：例如

                hibernate.dialect=org.hibernate.dialect.MySQLDialect
                hibernate.connection.driver_class=com.mysql.jdbc.Driver
                hibernate.connection.url=jdbv:mysql://localhost:3306/hibernate
                hibernate.connection.username=root
                hibernate.connection.password=123456
                hibernate.show_sql=true


                hibernate.dialect：指定数据库使用的sql方言。能够根据数据库的不一样生成不一样的方言，底层是经过调用一个一个类实现的。
                hibernate.connection.driver_class：指定数据库的驱动程序
                hibernate.connection.url：指定链接数据库的url
                hibernate.connection.username：指定链接数据库的用户名
                hibernate.connection.password：指定链接数据库的密码
                hibernate.show_sql：若是为true，能够在控制台打印sql语句 

                hbm2ddl.auto：生成表结构的策略配置，配置这个能够经过映射文件和实体类自动生成表结构
                有四个值：
                    update（最经常使用的取值）：若是当前数据库不存在对应的数据表，那么自动建立数据表
                    若是存在对应的数据表，而且表结构和实体类属性一致，那么不作任何修改
                    若是存在对应的数据表，可是表结构和实体类属性不一致，那么会新建立与实体类属性对应的列，其余列不变 

                    create（不多使用）：不管是否存在对应的数据表，每次启动Hibernate都会从新建立对应的数据表，之前的数据会丢失

                    create-drop(极少使用):不管是否存在对应的数据表，每次启动Hibernate都会从新建立对应的数据表，每次运行结束删除数据表

                    validate（不多使用）：只校验表结构是否和咱们的实体类属性相同，不一样就抛异常

   
   
   
   
   

    
    
    
    
    
1
    
    
    
    
    
2
    
    
    
    
    
3
    
    
    
    
    
4
    
    
    
    
    
5
    
    
    
    
    
6
    
    
    
    
    
7
    
    
    
    
    
8
    
    
    
    
    
9
    
    
    
    
    
10
    
    
    
    
    
11
    
    
    
    
    
12
    
    
    
    
    
13
    
    
    
    
    
14
    
    
    
    
    
15
    
    
    
    
    
16
    
    
    
    
    
17
    
    
    
    
    
18
    
    
    
    
    
19
    
    
    
    
    
20
    
    
    
    
    
21
    
    
    
    
    
22
    
    
    
    
    
23
    
    
    
    
    
24
   
   
   
   
   
(二)使用xml格式的配置文件，默认文件名为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>
                        <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
                        <property name="hibernate.connection.username">root</property>
                        <property name="hibernate.connection.password">123456</property>
                        <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernate</property>

                        <property name="show_sql">true</property>
                        <property name="format_sql">true</property>
                        <property name="hbm2ddl.auto">update</property>
                        <property name="hibernate.connection.autocommit">true</property> 

                        //引入映射文件
                        <mapping resource="com/cad/domain/User.hbm.xml"/>

                    </session-factory>
                </hibernate-configuration>

两种方式的区别

   
   
   
   
   

    
    
    
    
    
1
    
    
    
    
    
2
    
    
    
    
    
3
    
    
    
    
    
4
    
    
    
    
    
5
    
    
    
    
    
6
    
    
    
    
    
7
    
    
    
    
    
8
   
   
   
   
   
若是Hibernate的配置文件为java属性文件，那么必须经过代码来声明须要加载的映射文件
            经过Configuration的addClass(实体类名.class)来加载。

            配置文件为xml文件时，能够经过<mapping>元素来指定须要加载的映射文件。

            当经过Configuration的默认构造方法建立实例时，会默认查找hibernate.properties文件，若是找到就将配置信息加载到内存中。
            默认状况下，hibernate不会加载hibernate.cfg.xml文件，必须经过Configuration的configure（）方法来显式加载hibernate.cfg.xml文件

Hibernate中持久化类编写规范

   
   
   
   
   

    
    
    
    
    
1
    
    
    
    
    
2
    
    
    
    
    
3
    
    
    
    
    
4
    
    
    
    
    
5
    
    
    
    
    
6
    
    
    
    
    
7
    
    
    
    
    
8
    
    
    
    
    
9
    
    
    
    
    
10
    
    
    
    
    
11
   
   
   
   
   
-必须提供无参数的默认构造方法。由于程序运行时，Hibernate会运用java的反射机制，建立实体类的实例。 
    -全部属性必须提供public访问控制符的set get方法 
    -属性应尽可能使用基本数据类型的包装类型（如Integer）             基本数据类型没法表达null值，全部基本数据类型的默认值都不是null，这样就有很大的缺陷。
            例若有一个score属性，表示学生分数，若是为0，那么是表示该学生未参加考试仍是说该学生成绩为0呢？
            这时候若是用包装类型，就可使用null来表示空值，学生未参加考试等等。

    -不要用final修饰实体（将没法生成代理对象进行优化） 

对象标识符

   
   
   
   
   

    
    
    
    
    
1
    
    
    
    
    
2
    
    
    
    
    
3
    
    
    
    
    
4
    
    
    
    
    
5
    
    
    
    
    
6
    
    
    
    
    
7
    
    
    
    
    
8
    
    
    
    
    
9
    
    
    
    
    
10
    
    
    
    
    
11
   
   
   
   
   
在关系数据库中，经过主键来识别记录并保证记录的惟一性。
            主键的要求：不容许为null，不能重复，不能改变

            天然主键：在业务中，某个属性符合主键的三个要求，那么该属性能够做为主键。好比人的身份证就能够看成主键
            代理主键：增长一个不具有任何意义的字段，一般为ID，来做为主键

在java中，按照内存地址不一样区分不一样的对象。

在Hibernate中经过对象标识符（OID）来维持java对象和数据库表中对应的记录。
与表的代理主键对应，OID也是整数类型，为了保证OID的惟一性和不可变性，一般由Hibernate或者底层数据库库给OID赋值。

详解对象-关系映射文件

   
   
   
   
   

    
    
    
    
    
1
    
    
    
    
    
2
    
    
    
    
    
3
    
    
    
    
    
4
    
    
    
    
    
5
    
    
    
    
    
6
    
    
    
    
    
7
    
    
    
    
    
8
    
    
    
    
    
9
    
    
    
    
    
10
    
    
    
    
    
11
    
    
    
    
    
12
    
    
    
    
    
13
    
    
    
    
    
14
    
    
    
    
    
15
    
    
    
    
    
16
    
    
    
    
    
17
    
    
    
    
    
18
    
    
    
    
    
19
    
    
    
    
    
20
    
    
    
    
    
21
    
    
    
    
    
22
    
    
    
    
    
23
    
    
    
    
    
24
    
    
    
    
    
25
    
    
    
    
    
26
    
    
    
    
    
27
    
    
    
    
    
28
    
    
    
    
    
29
    
    
    
    
    
30
    
    
    
    
    
31
    
    
    
    
    
32
    
    
    
    
    
33
    
    
    
    
    
34
    
    
    
    
    
35
    
    
    
    
    
36
    
    
    
    
    
37
    
    
    
    
    
38
    
    
    
    
    
39
    
    
    
    
    
40
    
    
    
    
    
41
    
    
    
    
    
42
    
    
    
    
    
43
    
    
    
    
    
44
    
    
    
    
    
45
    
    
    
    
    
46
    
    
    
    
    
47
    
    
    
    
    
48
    
    
    
    
    
49
   
   
   
   
   
Hiernate采用XML格式的文件来指定对象和关系数据之间的映射。Hibernate经过这个文件来生成各类sql语句。
命名规则为 实体类名.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">

 <!--根元素，有一经常使用属性为package，当指定了package时，后面的类名字就能够简短，例如 package="com.cad.domain",后面class标签的name只用写User便可--> 
 <hibernate-mapping>

    <!--class标签指定类和表的对应关系，name为类名，table为表名 class标签的属性 dynamic-insert属性，默认是false，当咱们执行插入语句时，会动态生成sql语句，若是咱们只为某个字段赋值，其余字段为null，可是生成的sql语句仍是包含其余字段，例如user有两个属性，咱们只为name赋值，生成的sql语句仍是 insert into user（name，password）values （？，？），而当咱们将该值设置为true时，生成的sql语句会仅包含不为null的字段，生成的sql语句就是insert into user（name） values （？） class标签的属性 dynamic-update属性，默认是false，当咱们执行更新语句时，会动态生成sql语句，若是咱们只为某个字段更新，其余字段不变，生成的sql语句仍是包含其余字段。而当咱们将该值设置为true时，生成的sql语句仅包含须要更新的字段 使用上面的两个属性能够提升运行性能，可是Hibernate动态生成sql语句须要的性能很小，因此能够省略-->
    <class name="com.cad.domain.User" table="user"> 

        <!--id标签用来设定持久化类中的OID和表的主键的映射，name为持久化类中的属性，column是数据表中的主键列名 id标签的属性：length 指定列的数据长度 id标签的属性：unsaved-value 指定当主键为某个值时，当作null来处理 id标签的属性：access 也可用在<property>标签上 默认值为property，即经过相应的get set方法来访问持久化类的属性，当值为field时，代表使用反射机制直接访问类的属性，不推荐使用，破坏封装性-->
        <id name="id" column="id">
            <!-- generator标签用来设定主键生成策略，hibernate内置的几种主键生成策略 1.increment 适用于代理主键。由Hibernate自动以递增的方式生成主键，每次增量为1 ，会执行两个sql语句，先从表中查找出最大的id，而后加一，插入当前数据 2.identity 适用于代理主键。由底层数据库生成主键，依赖数据库的主键自增功能 3.sequence 适用于代理主键。由底层数据库的序列来生成主键，前提是数据库支持序列。（mysql不支持，oracle支持） 4.hilo 适用于代理主键。Hibernate根据hilo算法来本身生成主键。 5.native 适用于代理主键。根据底层数据库对自动生成主键的支持能力选择 identity|sequence|hilo 6.uuid 适用于代理主键。采用UUID算法生成主键。 7.assigned 适用于天然主键。由咱们本身指定主键值。例如指定身份证号为主键值 -->
            <generator class="native"></generator>
        </id>

        <!-- property标签属性 name指定持久化类的属性名称 column 与类属性映射的字段名，若是没有设置，默认用类属性名做为字段名 not-null 指定属性的约束是否为非空，默认false unique 指定属性的约束是否惟一 type 指定Hibernate映射类型。例如java类型为string，数据库类型为text，那么应该把Hibernate类型设置为Text。有一张对应的表能够查看。若是没有指定映射类型，Hibernate会使用反射机制识别属性的java类型，而后自动使用与之对应的Hibernate映射类型 -->
        <property name="name" column="name"></property>
        <property name="password" column="password"></property>
    </class>
 </hibernate-mapping>

Hibernate API详解

Configuration类

   
   
   
   
   

    
    
    
    
    
1
    
    
    
    
    
2
    
    
    
    
    
3
    
    
    
    
    
4
    
    
    
    
    
5
    
    
    
    
    
6
    
    
    
    
    
7
    
    
    
    
    
8
    
    
    
    
    
9
    
    
    
    
    
10
   
   
   
   
   
Configuration类：用来加载默认文件路径下的配置文件（hibernate.properties）。
                 调用configure()方法会加载默认文件路径下的xml格式的配置文件(hibernate.cfg.xml)推荐使用。

                 若是配置文件在不默认文件路径下或者配置文件名不符合默认规则
                     可使用 
                     new Configuration().configure(file)  加载指定文件
                     new Configuration().configure(path)  加载指定路径下的文件 

                若是使用properties格式的配置文件，可使用addClass(实体类名.class)方法能够加载映射文件。

SessionFactory对象

   
   
   
   
   

    
    
    
    
    
1
    
    
    
    
    
2
    
    
    
    
    
3
    
    
    
    
    
4
    
    
    
    
    
5
    
    
    
    
    
6
    
    
    
    
    
7
   
   
   
   
   
SessionFactory对象: 
                SessionFactory表明数据库存储源。根据Hibernate配置文件建立对应的数据库存储源。
                SessionFactory对象建立后，和Configuration对象再无关联。修改Configuration包含的配置文件信息，不会对SessionFactory有任何影响。   

                  获取SessionFactory对象：new Configuration().configure().buildSessionFactory();
                对象的缓存很大，就称为重量级对象。SessionFactory存放了Hibernate配置信息，映射元数据信息等。是重量级对象。

Session对象

   
   
   
   
   

    
    
    
    
    
1
    
    
    
    
    
2
    
    
    
    
    
3
    
    
    
    
    
4
    
    
    
    
    
5
    
    
    
    
    
6
    
    
    
    
    
7
    
    
    
    
    
8
    
    
    
    
    
9
    
    
    
    
    
10
    
    
    
    
    
11
    
    
    
    
    
12
    
    
    
    
    
13
    
    
    
    
    
14
    
    
    
    
    
15
    
    
    
    
    
16
    
    
    
    
    
17
    
    
    
    
    
18
    
    
    
    
    
19
    
    
    
    
    
20
    
    
    
    
    
21
    
    
    
    
    
22
    
    
    
    
    
23
    
    
    
    
    
24
    
    
    
    
    
25
    
    
    
    
    
26
    
    
    
    
    
27
    
    
    
    
    
28
    
    
    
    
    
29
    
    
    
    
    
30
    
    
    
    
    
31
    
    
    
    
    
32
    
    
    
    
    
33
    
    
    
    
    
34
    
    
    
    
    
35
    
    
    
    
    
36
    
    
    
    
    
37
    
    
    
    
    
38
    
    
    
    
    
39
    
    
    
    
    
40
    
    
    
    
    
41
    
    
    
    
    
42
    
    
    
    
    
43
    
    
    
    
    
44
    
    
    
    
    
45
    
    
    
    
    
46
    
    
    
    
    
47
    
    
    
    
    
48
    
    
    
    
    
49
    
    
    
    
    
50
    
    
    
    
    
51
    
    
    
    
    
52
    
    
    
    
    
53
    
    
    
    
    
54
    
    
    
    
    
55
    
    
    
    
    
56
    
    
    
    
    
57
    
    
    
    
    
58
    
    
    
    
    
59
    
    
    
    
    
60
    
    
    
    
    
61
   
   
   
   
   
Session对象：   
                表明程序和数据库的会话。Session提供了操做数据库的各类方法。是轻量级对象。 

                   获取Session对象 
                   factory.openSession(): 获取新的Session实例。
                   factory.getCurrentSession():采用该方法建立的Session会取出当前线程中的Session，底层使用ThreadLocal进行存取 

                    save()方法:把Java对象保存到数据库中。
                                    Transaction ts=session.beginTransaction();
                                    User u=new User();
                                    u.setName("赵六");
                                    u.setPassword("123456");
                                    //将对象保存到数据库
                                    session.save(u); 
                                    ts.commit();

                    update()方法：更新数据库的方法 Transaction ts=session.beginTransaction();
                                    //先查出要修改的对象，根据主键值   
                                    User user=session.get(User.class, 1);
                                    user.setName("jery");
                                    //将对象更新到数据库，根据OID
                                    session.update(user); 
                                    ts.commit();

                    delete()方法：删除方法 底层根据OID进行删除。有两种方式 （1） Transaction ts=session.beginTransaction();
                                        User user=session.get(User.class, 1); 
                                        //删除指定对象
                                        session.delete(user);   
                                        ts.commit();
                                    （2）
                                        Transaction ts=session.beginTransaction();
                                        User user=new User();
                                        user.setId(2);
                                        session.delete(user);
                                        ts.commit();     

                    load()或get()方法：从数据库查找指定对象 session.get(实体类名.class,OID);或session.load(实体类名.class,OID);

                    load()和get()的区别 咱们使用get查询时发现控制台会立马打出查询语句。 使用load查询时控制台不会打印查询语句。 get方法被调用时马上发送sql语句到数据库进行查询。 load方法被调用时并无查询数据库，当咱们须要使用查询的对象时，才去查询，因此当咱们打印对象时，才会在控制台打印sql语句。 get（）的原理 程序调用get方法，Hibernate发送sql语句到数据库 数据库返回结果，Hibernate将结果封装成对象，返回对象到程序。 load（）的原理 程序调用load方法，Hibernate使用代理技术，建立一个代理对象，属性只有ID值。 而后返回代理对象给程序，咱们使用对象时，代理对象调用Hibernate查询数据库，初始化其余属性。 load方法，返回一个代理对象，获取其属性时，会查询数据库，每次访问属性都会查询数据库么？ 答：不是。代理对象中有一个标识是否被初始化的boolean类型变量，记录是否被初始化。 

查询全部对象的方法

   
   
   
   
   

    
    
    
    
    
1
    
    
    
    
    
2
    
    
    
    
    
3
    
    
    
    
    
4
    
    
    
    
    
5
    
    
    
    
    
6
    
    
    
    
    
7
    
    
    
    
    
8
    
    
    
    
    
9
    
    
    
    
    
10
    
    
    
    
    
11
    
    
    
    
    
12
   
   
   
   
   
使用HQL语言（后面会详细介绍），HQL语言是面向对象的
            Query query=session.createQuery("from User");


            第二种方式
            Criteria c=session.createCriteria(User.class);
            List<User> l=c.list();

            第三种方式，使用原生sql语句进行查询
            SQLQuery query=session.createSQLQuery("select * from user");
            List l=query.list();

Transaction对象

   
   
   
   
   

    
    
    
    
    
1
    
    
    
    
    
2
    
    
    
    
    
3
    
    
    
    
    
4
    
    
    
    
    
5
    
    
    
    
    
6
    
    
    
    
    
7
   
   
   
   
   
封装了事务的操做。咱们作增删改查等操做时，必须开启事务.
            由于session是线程不安全的，这样主要是为了线程安全。保证数据的正确性。
            开启事务： Transaction ts=session.beginTransaction();
            提交事务：ts.commit();
            回滚事务：ts.rollback();
            当经过getCurrentSession获取当前线程绑定的Session时，事务关闭时，会自动把Session关闭并删除。

Query对象

   
   
   
   
   

    
    
    
    
    
1
    
    
    
    
    
2
    
    
    
    
    
3
    
    
    
    
    
4
    
    
    
    
    
5
    
    
    
    
    
6
    
    
    
    
    
7
    
    
    
    
    
8
   
   
   
   
   
封装HQL语句的对象。

        返回一个对象的方法 query.uniqueResult();

        分页相关
        query.setFirstResult(index):从第几个取
        query.setMaxResults(count):指定取几行记录

<link rel="stylesheet" href="https://csdnimg.cn/release/phoenix/template/css/markdown_views-ea0013b516.css">
            </div>