Hibernate

Hibernate的作用：

1、 Hibernate解决ORM(对象关系映射)的问题，大大减少了持久层的代码量

2、 hql方言，解决了可移植性问题

3、效率问题,频繁的连接和关闭，自动的封装JDBC，自动使用连接池。Session

4、具有缓存功能，节省查询时间

5、通过设定自动给数据加锁，事务的隔离级别

Hibernate工作在持久层。

类似Hibernate的框架 apache的OJB，sun公司的JDO，Oracle的Toplink, apache 和 Google的Ibatis。

POJO：领域模型也叫实体类。包括表单bean和结果bean（不继承任何类）

<struts1.0的Form 不属于POJO，因为继承了ActionForm类>

1、为什么要用Hibernate?

Java中的对象，数据库中的关系。Hibernate主要是实现对象模型和关系模型直接的转换。轻量级的封装。面向对象的思想。

因为Hibernate有映射文件，所以才能对数据save,query等操作。

映射文件：***.hbm.xml文件，也叫源文件，把对象模型的继承、关联映射成数据库中的主外键关系。

Hibernate自动的保持数据库在的记录和对象属性的值同步（保证一致）。

Hibernate的session是持久化管理器，工作在持久层。

数据库中的表的主键生成策略：

Native：Hibernate根据不同的数据库生成不同的主键，自动增长

Uuid:UUID.randomUUID().toString(),32位字符串

Asigned:用户自己生成的

Foreign:外键维护叫做参照完整性，维护关系。来自于对象里关联属性的值

GUID:increment,线程不安全，建议不要使用

Identity:使用数据库自己的自动增长策略，oracle数据库不支持

对象与对象的关系：关联（has a ）和继承(is a )

属性映射：主键一般不从对象中拿，要么从数据库中生成，要么hibernate給。外键从对象的关联属性上拿。（关联属性：属性类型为自定义类型一定是关联属性，如果属性为集合类型，该属性有可能是关联属性）

Hibernate3.2 的环境搭建：（测试环境—> 真实环境）

测试环境：（不占内存的，导入的包不在项目里面，只是做关联）

1、创建java Project

2、创建公共的jar包， windowsàjavaàUser Libraryà包名

3、在创建的包下导入jar包，（主jar包和lib下的所有jar包+mysql的jar包）

4、导入项目库，右键—>propertiesàjava buildPathà选择自己创建的存放jar包的包名

5、创建source folder (src文件夹)

6、把ext文件夹下的hibernate.cfg.xml.，log4j.properties文件放在src下

7、在hibernate.cfg.xml文件中配置持久化数据库信息，配置方言（不同的数据库有不同的方言）<property>

8、导入映射文件<mapping resource=”com/hibernate/User.htm.xml”/>:将User对象和数据库中的表进行ORM(对象关系映射)

真实环境：将jar包直接导入WEB-INF/lib下，配置信息与虚拟环境相同

Hibernate小案例

1、创建实体类：POJO（表单bean、结果bean）User

2、创建和实体类对应的元文件 User.hbm.xml(可能多个实体类对应一个元文件)

<hibernate-mapping>

<class name=”类的全路径名 cn.bean.User”>//根据类名创建表 user

<id name=”id”>//id映射表示该属性为数据库中的表的主键

<generator class=”uuid”>//generator 表示主键的生成策略。设置主键为uuid，Hibernate自动生成

</id>

<property name=”name”/>//普通属性用property映射，在表中的字段也叫name

</class>

</hibernate-mapping>

数据库中主键映射：

如果在对象中为String id,generator一般为uuid,32位码，Hibernate自动生成

如果在对象中为int id,generator一般为native,数据库中自动生成，自增。

Hibernate会自动根据表单bean创建和表单bean类名相同的表。

会根据表单bean中的属性自动创建表的字段，数据类型会自动解析。Int->int,Stringàvarchar,util Date à datetime 类型相对应。长度取默认值。

DDL:数据库定义语言、DCL数据库控制语言、DML:数据库操纵语言

DDL（data definition language）：
DDL比DML要多，主要的命令有CREATE、ALTER、DROP等，DDL主要是用在定义或改变表（TABLE）的结构，数据类型，表之间的链接和约束等初始化工作上，他们大多在建立表时使用

DML（data manipulation language）：
SELECT、UPDATE、INSERT、DELETE，这4条命令是用来对数据库里的数据进行操作的语言
DCL（Data Control Language）：
是数据库控制功能。是用来设置或更改数据库用户或角色权限的语句，包括（grant,deny,revoke等）语句。在默认状态下，只有sysadmin,dbcreator,db_owner或db_securityadmin等人员才有权力执行DCL

Hbm2ddl工具类：

Configuration cfg=new Configuration().configure();//将src下的hibernate.hbm.xml文件读到cfg中

Configuration cfg=new Configuration();//将src下的hibernate.properties文件读到cfg中

SchemaExport export=new SchemaExport(cfg);

export.create(true,true);//按照User.hbm.xml文件中配置在数据库中生成对应的表

Hiberante的配置信息：

<hibernate-configuration>

<session-factory>

<!—配置数据库的连接信息-- >

<property name="hibernate.connection.url">jdbc:mysql://localhost/hibernate_fist</property>

<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>

<property name="hibernate.connection.password">mysql</property>

<!—配置mysql数据的方言 -- >

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

<!—配置显示sql语句，建表，查询之类的，为了方便跟踪sql执行 -- >

<!—配置表的自动生成策略，如果表不存在就创建，存在就不再创建-- >

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

<!—配置映射文件信息，用于数据库中的表的生成-- >

</session-factory>

</hibernate-configuration>

JDK动态代理：对目标类实现同一个接口的代理（通过反射实现）

Cglib代理：代理类是目标类的子类

Hibernate使用的是连接池，dbcp连接池（内建连接池）

autocommit(),自动提交事务默认为false，需要手动提交事务

测试类：把对象变成表中的记录

1、 Configuration cfg=new Configuration().configure();//读取配置文件，xml

2、 SessionFactory factory=cfg.buildSessionFactory();//创建工厂，session工厂是重量级的，线程安全，非常耗时，原则上只创建一次。最好是单例+同步。

SessionFactory的作用：生成Session对象，二级缓存，并且可以配置缓存策略

3、 Session session=null;

session=factory.openSession();//通过工厂拿到Session对象，session是持久化管理器，session是线程不安全的。可以拿到多个session。

4、 session.beginTransaction();//开启事务(从数据库的连接池中拿到连接)，session开启的事务是session级别的事务，本地事务，局部事务。（通过SessionFactory创建的事务是全局事务，可以被多个SessionFactory对象使用）

什么是事务？事务是对数据库的操作（一致性，原子性，持久性，隔离性）

5、创建User对象，给User对象赋值

当配置中的<id><generator class =”uuid”/></id>时，自己设定的主键是没有用的。赋值后的user对象是瞬时态

6、 session.save(user);//session会为user分配主标识，uuid,j将user对象纳入session的缓存，临时集合insertron中。 保存数据

7、 session.getTransaction().commit();//session 拿到事务后提交事务。在这里生成sql语句，将user对象中的数据存入数据库中对应的字段里。（操纵数据库）

8、 session.getTransaction().rollback();// 发生异常就catch并且回滚

Hibernate的优点：

代码量少，提高生产力

更加面向对象，对象化

可移植性好（改方言，改配置就可以啦）

支持透明持久化：轻量级，没有侵入性

事务：

事务分为总事务和子事务，子事务预提交，总事务发现其中一个子事务出错就回滚。

公共请求事务对象代理：不是真正的操作只是代理对象。-- > 中间件(代理完成事务的提交)

事务的边界：session.beginTransaction();

JDNI:java的名称目录接口，对连接池进行管理。

Hibernate可以处理多种事务（本地事务，跨资源事务，局部事务），提供统一的事务边界，（事务边界由session获取）

SessionFactory可以生成全局事务，供多个session使用，并且具有二级缓存功能。

Configuration：封装和管理hibernate的主配置文件。

1、封装和管理：数据库的底层信息<property>

2、封装和管理：映射文件元信息（元数据）<mapping-resources>

获取方式：

1、 new Configuration()；//拿到hibernate.properties文件

2、 new Configuration().configure();//拿到hibernate.hbm.xml的配置信息

SessionFactory：（session工厂也叫会话工厂）

SessionFactory通过Configuration创建，创建特点：cfg.buildSessionFactory();

SessionFactory功能：

1、取得持久化对象session（factory.openSession()）

2、生成全局性事务（Tansaction）事物共享控制安全性

3、缓存（缓存元数据和不常修改的数据）缓存后，一般不释放。

缓存定义：第一次读取后，第二次访问时已经存入内存，直接读取效率会高。

缓存目的：提高对数据库的访问效率

SessionFactory性能：

1、 SessionFactory属于重量级，耗时，一般只在初始化的时候创建一次PlugIn

2、原则上一个Hibernate可以管理多个数据库，每个数据库都配置同一个SessionFactory（但是这样系统效率低，一般一个sessionFactory只管理一个数据库）

3、 sessionFactory是线程安全的（支持多线程并发访问操作）

Session：持久化管理器

作用：完成对数据库的操作 ORM（对象关系映射）

Session的功能：

1、 Session一级缓存，具有缓存功能（缓存后才能对对象进行持久化操作）

2、保证所管理的对象中的属性和数据库中的记录同步（自动update）

3、 Session可以取得事务（对session中缓存的数据完成实际的存取）

4、 Session作为HQL查询à生成的Query对象，执行hql语句（session.createQuery()）

Query query = session.createQuery(“from User”); 其中User是实体类。该语句将把数据库中t_user表中的全部查询出来放到query对象中。

5、 Session可以从连接池中拿到连接（关闭session，连接释放）

6、 Session的主要作用是对数据库进行操作

Session的性能：

1、线程不安全（操作完数据库就关闭session）

Lifecycle，Validatable：可以对User请求做监听，不使用的原因是因为需要实现接口，太过于重量级了。

UserType(转换器),Interceptor（拦截器）：都属于轻量级接口，对对象自动拦截,很少用，不需要实现Hibernate的任何接口和类

实际测试环境的搭建：

测试类和被测试类在同一个包下 src

测试类的路径和被测试类相同

使用Junit测试原则：

1、测试类继承TestCase（Junit包下的一个类）

2、测试类的类名 suffix=*Test（eg：UserTest）

3、测试类的方法名：test开头，后面是正常的方法名(eg：testLogin())

4、测试类的方法不能有参数和任何返回值

调试时在debug—> Junit

Log4j.propeties:是为了测试的时候打印日志信息。

持久化对象的生命周期：

对象的三种状态：瞬时、持久、离线

瞬时态（transient）:new User(),刚new 出类的对象处于瞬时态，没有纳入session的管理，数据库中没有对象的记录，事务提交后这种对象无法提交到数据库（和数据库无关联）

持久态（presist）：session. save(user),这时候user对象处于持久态，session管理，具有主标识，事务对持久态的对象做操作（和数据库同步）

离线态（Detached）：session关闭后对象状态从持久态变为离线态。不纳入session管理中，对象中的数据在数据库中有对应的记录，对象发生变化，数据库中的值不会发生变化。（和数据库不同步）

Junit测试和Debug调试

测试类的代码和hibernate的代码在同一个包下

Session缓存的特点：

Session session=factory.openSession();//通过session工厂拿到session对象

Variable à 查看actionQueue: session队列中有三个临时集合(数组)

1、insertions:elementData session.save();存放要插入的对象

2、updates :elementData session.update()；存放要修改的对象

3、deletions：elementData，存放要删除的对象

Session事务一提交，先到insertion数组中查看是否有对象，如果有对象，就发送有关插入数据的sql语句：insert into()

再从deleteions数组中查看是否有对象，如果有对象就发送关于删除的sql语句：delete()

再从updates数组中查看是否有对象，如果有对象就发送关于更新的sql语句：update()

这三个集合都是临时集合，发送完数据就会清空。

PersistanceContext:持久化容器

存放真正缓存中的数据，实体化类对象一定要和数据库中记录的状态一致。

数据结构为entityEntries 是一个Map

里面有个Map集合，进入 entries 里面有个table ，真正纳入session的中的数据存在table里面。

局部事务：

1、 session.openTransaction();开启事务，事务一提交，就去找session的actionQueue中的数组，发现哪个数组中有对象就执行其对应的语句，

2、 User user=new User();创建user对象，user.setName(“zhangsan”);，这时候的user对象没有id，（如果主键的生成策略是uuid，手动设定的id是无效的）这时候还的user对象处于瞬时状态，没有纳入session管理

3、 session.save(user);执行这条语句，一般不会发sql语句，只是将user对象纳入session管理，语句执行完后：session中的临时数组：insertions数组中会有数据。User会分为两份存储：

一份是instance :实例

一份是 state:状态，session按照state状态发送数据（执行insert语句）

Insert之后，如果发现实例和状态的数据不一样，会马上执行update语句

4、 session.save(user)后,查看persistanceContext à entityEntries à map à table(table是HashMap的元素) value有值就继续进去，查看以下几个状态值：

existsInDatabase的状态为false，表示数据库中没有数据

这时候id已经被赋值（uuid）

loaderSate：存储状态，数据都存在这里了（这里的数据必须和数据库中的数据同步）这就是session缓存的数据。

目前的user对象处于持久态

处于持久态对象的特点：一定有ID（不是所有持久态的数据会存放在临时数组中，但是持久态的数据一定会在map集合中）

5、 user.setName(“tom”);纳入session管理之后，变为持久态之后，修改持久态对象的值,

6、 session.commit();将修改后的数据提交，

actionQueue下的insertions数组中： instance实例中的值为：tom;

state状态的值为：zhangsan

persisstanceContext底下的map中：数值还是zhangsan

会按照insertions数组的state(状态)的值发送insert into （zhagnsan）到数据库中

insert语句执行完后，发现instance 和state 中的值不一样时，就会再发一条update语句，保证一致。发完sql语句后，临时集合中的数据会全部清空。

7、 session.commit()后，状态：persistanceContext à entityEntries à map àtableà[0]àvalues

existsInDatabase的状态为true，表示数据库中已经有了相应的记录。这时候map中的name会改为tom(因为update了)

8、 session.close(),关闭session，把session中存放的实体对象全部清除，这时候user对象处于离线状态，user对象还有主键，而且这个主键和数据库中的主键一样。离线态的对象在数据库中有对应的记录。

瞬时态：没有纳入session的管理，数据库中没有对应的记录

离线态：没有纳入session的管理，数据库中 有对应的记录。（只要主标识和数据库中的主键相同，主标识的class为asigned,就为离线态（new出来的对象也可以是离线态）），离线态的对象不能直接save()进入持久态。

9、 将离线态变为持久态：update()，saveOrUpdate(),lock(),重新开启session，拿到事务，session.update(user); <如果new 出来的对象，自己设定的id和数据库中主键相同，id标识为assigned，那么就只能用update方法，让该对象变为持久态>

10、对象从离线态变为持久态，临时集合（insertions/updates/deletions）中都没有数据。persistanceContext--àMap集合有数据，但是map中只有一个id记录,数据库中也会有相应的数据。

11、 session.commit();就算没有修改user对象的属性值，hiberante也会发送update语句。Update之后，user也被纳入session管理

12、 session.commit()后，再进入persistanceContext à entityEntries à map à table à[0]àvalues

loadedSate会有相应的user实体对象中的属性的记录了。

瞬时态—》持久态：插入（save）

离线态—》持久态：更新( update )

加载：(查询)将数据库中的记录加载到对象中

1、拿到session（通过静态方法自定义的getSession()）

2、 User user=(User)Session.get(User.class,”这里写数据库中的主键值”);//把关系模型转换为对象模型。通过User类中找到对应的表。（这里是因为session通过sessionFactory创建，sessionFactory通过Configuration创建，Configuration可以读取整个hibernate.hbm.xml文件中的配置信息，所以session可以找到对应的user.hbm.xml文件）找到User.hbm.xml文件。Session通过hbm.xml元数据找到对应的表。通过主键找到表中对应的那条记录，自动生成对象，并且自动将数据库中记录的字段设定到user对象中对应的属性中。

这里发送了一条sql语句：select * from user where id=”上面的id参数值”；

这就叫做加载（load()）。这时候的user对象处于持久态。（和数据库同步）

3、 user对象已经进入持久态，纳入session管理。这时候缓存域（三个集合 insertions/deletions/updates）中是没有数据的，persistanceContextà底下的map 的 value中会有数据。

4、 user.setName(“lisi”);//加载后，修改user对象中值。这时候session缓存的临时集合中没有数据，persistanceContext中的map中的数据也没有变化，user对象中的数据被修改了。 Session发现user对象中的值和map中的值不一样时，会自动发update语句，保证数据同步。

5、 session.commit();//修改后提交数据。Update之后，数据会变为和对象中的值一样。Session缓存中的数据也会变成和user对象中的值一样。

持久态对象特点：一提交就发update.确定保证对象和数据库中数据同步。

处于持久态的对象在数据库中不一定有对应的记录。

session.commit()后：数据库中记录一定要和persistanaceContextàlocalState中的数据一致

使用get()方法加载数据的缺点：

1、如果从数据库中找到了指定ID对应的记录？

如果不需要使用User对象，会浪费内存

2、没有从数据库中找到ID对应的记录？

Hiberante就不会创建对应的User对象，会返回null。

再调用该对象的方法时，会出现NullPointerException

根据以上问题，修改方案：使用Load();

User user=(User)Session.load(User.class,”这里写数据库中的主键值”);//从这里引入懒加载。执行load方法后，不会生成sql语句，意味着还没有访问数据库。但是会生成Cglib 代理的User对象，这个User对象是目标User对象的一个子类对象。所以这里的User类不能定义为final类型。

Cglib代理的原理：创建目标类的子类对象。

这时候代理User对象的target 值为null;

user.getName();//调用代理对象的getName()方法，如果不为null，代理对象会调用父类的getName()方法。然后à发送sql语句à创建User对象。

本周作业：

理解hiberante:juint,debug,生命周期，缓存,

理解物料管理项目

Get方法查询数据：session.get(User.class,”对应的数据库中的表的ID”);

1、通过类找表

2、通过主键找记录

3、记录映射

不管数据存不存在都会发送select语句，如果找到了就会生成user对象，将对应的记录映射到对象的属性中，如果没有对应记录就返回null。（不支持懒加载）

使用get查询，会马上发select语句，select * from user where id=””;

如果后面不再修改User对象的值，就不会再发update语句了

如果修改user对象的值就会发送update语句。

这里主要比较user对象里面的值和loadedState里面的值，如果相同就不会发送update语句，如果不同就会发送update语句。

懒加载：（最大的问题就是会产生懒加载异常）

使用时再访问数据库，不使用数据的时候就不会访问数据库

懒加载有类上的懒加载，集合上的懒加载，单端上的懒加载

懒加载不支持多态查询

悲观锁不支持懒加载

Load方法查询数据：session.load(User.class,”对应的数据库中的表的ID”);

不会马上就发select语句，使用的时候才会发送select语句，如果不使用就不发送

1、创建目标对象的cglib代理对象（目标对象的子类对象）

目标类User必须要有明确的无参构造方法，（为目标类创建代理对象，创建子类对象要先调用父类的无参构造方法），目标类不能是final类型

2、对应的cglib代理对象下，有个target标识，标明目标对象是否生成，没有生成目标对象的时候 target=null;

3、执行代理对象的user.getName()时，;先看目标对象产生了没有（判断target的值），如果产生了就执行目标对象的getName()方法，如果没有就从数据库中查出主键所标识的记录，根据记录生成目标User对象，再调用该User对象的getName()方法。（生成目标对象后，target=user(目标对象的地址)）

Load（）方法在数据库中找不到主键所标识的记录时，会产生异常：ObjectNotFoundException,而不是NullPointerException。这个异常在load()的时候产生这个异常，但是使用目标对象的时候就会抛出这个异常。

Get（）方法在数据库中找不到主键所标识的记录时，会返回null，再在使用目标对象时，会抛出NullPointerException.

Get和load:

共同点：通过ID（主键）去数据库中找相同的记录，生成对应的User 对象

不同点：

1、 Get:不支持懒加载，马上发送select语句

Load:支持懒加载，使用的时候才发送select语句

2、如果使用get,发现主键在数据库中找不到对应的记录，不会生成user对象，也不会抛出异常，会返回null.(使用对象是抛出NullPointerException.)

如果使用load,发现主键在数据库中找不到对应的记录时，使用时会抛出ObjectNotFoundException。

一般使用load,很少使用get.

删除：（删除的内容:数据库中的数据）

先查 à 后删

User user=(User)session.load(User.class,”ID”);//对象处于持久态

session.delete(user);//在session的缓存persistanceContext中的map集合中有该对象，existInDatabase=true,loadedState有该对象；

临时集合中的deletions中有该对象，

User代理对象中也有数据。target=user;

session.getTransaction().commit();//这里发送delete语句(进入瞬时态)

临时集合deletions中数据被清空

Session里面的persistanceContextàmap中没有数据

数据库中的数据也没有

User对象依旧存在，target=user.

删除了User对象对应的数据库中的表的记录，删除后对象进入瞬时态。（不纳入session管理，数据库中的记录也没有了）

(课堂作业：完成hiberante的简单的增删改查)

查看表中的所有记录：（Query）

Query query=session.createQuery(“from User”);//hql语句，from后面跟的是类名。通过session创建Query对象，实参为hql语句。从User类所映射的user表中拿到每一条记录，封装到Query对象中。

Query对象的作用是：执行hql语句。

List list=query.list();//Query中的list方法，把Query封装的每条记录放到List集合中。

Hibernate的基本映射

如果主键为String类型，一般配置为uuid<generator class=”uuid”/>

关联映射:

<hiberante-mapping package=”com.hibernate”>//多个实体类在同一个包下，这里配置了包名，使用时直接写具体类名就可以了

<class name=”User” table=”t_user”>//根据类名为User的实体类生成表，table：指定数据库中的表名为t_user

<id name=”id” column=”user_id” length=”33”>//定义主键名在数据库的表中的字段名为 user_id，长度位33，（最好不要修改主键字段长度，使用默认长度255）

<generator class=”uuid”/>//标识主键生成策略为uuid

</id>

/* Name:标识在User类的属性

Unique:标识该字段在数据库的表中必须唯一(不能重复)

Not-null:标识该字段在数据库的表中不能为null

为空验证：user.setName(“”);这里不会产生异常，空串不为空。

如果直接不给name赋值，String类型默认值为null，就会产生NulPointerException

Length:指定该字段的最大长度

Column:指定该属性映射在数据库中的表中的字段名为 t_name

</class>

<hibernate-mapping>

主键生成策略：（作用/目的：一旦实体类纳入session的管理，session根据实体类的主键生成策略生成主标识，这个主标识就是数据库中的记录的主键）

主标识：

业务主键和业务标识：（有意义的唯一标识）--学号

逻辑主键和逻辑标识：（没有意义的唯一标识），由数据库或者是Hibernate生成uuid

根据实体类的ID类型确定主键生成策略：

如果是字符串，hibernate生成 。uuid

如果是int/long，由数据库生成。native

用<id>标签来标识主键，后面必须要跟<generator class=” 主键生成策略

”>

1、由数据库生成：

native:根据不同的数据库自动使用不同的主键生成策略。（不是真正的生成策略，只是选择对应的生成策略）

identity：（mysql,sqlserver）

sequence：（DB2，Oracle）

2、由程序生成：

increment(递增)：多台应用服务器，可能会主键相冲，很少使用

uuid.hex:Hibernate采用这种方式生成主键，多态服务器同时生成主键，不会重复；

1、 IP地址

2、 JVM的启动时间（1/4秒）

3、系统时间

4、随机数（和指令计数器有关）

以上四种数据进行随机组合，最后生成32 uuid 码

3、用户自己维护主键：

assigned:用户自己输入

4、外部引用

foreign:依赖于另一个实体类的主键。

主键生成策略为uuid: （主属性类型为String类型）

13、 session.openTransaction();开启事务，事务一提交，就去找session的actionQueue中的数组，发现哪个数组中有对象就执行其对应的语句，

14、 User user=new User();创建user对象，user.setName(“zhangsan”);，这时候的user对象没有id，（主键的生成策略是uuid，手动设定的id是无效的）这时候还的user对象处于瞬时状态，没有纳入session管理

15、 session.save(user);执行这条语句，一般不会发sql语句，只是将user对象纳入session管理，语句执行完后：session中的临时数组：insertions数组中会有数据。User会分为两份存储：

一份是instance :实例

一份是 state:状态，session按照state状态发送数据（执行insert语句）

Insert之后，如果发现实例和状态的数据不一样，会马上执行update语句

16、 session.save(user)后,查看persistanceContext à entityEntries à map à table(table是HashMap的元素) value有值就继续进去，查看以下几个状态值：

existsInDatabase的状态为false，表示数据库中没有数据

这时候id已经被赋值（uuid）

loadedSate：存储状态，数据都存在这里了（这里的数据必须和数据库中的数据同步）这就是session缓存的数据。

目前的user对象处于持久态

处于持久态对象的特点：一定有ID（不是所有持久态的数据会存放在临时数组中，但是持久态的数据一定会在map集合中）

17、 user.setName(“tom”);纳入session管理之后，变为持久态之后，修改持久态对象的值,

18、 session.commit();将修改后的数据提交，

actionQueue下的insertions数组中： instance实例中的值为：tom;

state状态的值为：zhangsan

persisstanceContext底下的map中：数值还是zhangsan

会按照insertions数组的state(状态)的值发送insert into （zhagnsan）到数据库中

insert语句执行完后，发现instance 和state 中的值不一样时，就会再发一条update语句，保证一致。发完sql语句后，临时集合中的数据会全部清空。

session.commit()后，状态：persistanceContext à entityEntries à map àtableà[0]àvalues

existsInDatabase的状态为true，表示数据库中已经有了相应的记录。这时候map中的name会改为tom(因为update了)

19、 session.close(),关闭session，把session中存放的实体对象全部清除，这时候user对象处于离线状态，user对象还有主键，而且这个主键和数据库中的主键一样。离线态的对象在数据库中有对应的记录。

瞬时态：没有纳入session的管理，数据库中没有对应的记录

主键生成策略为native: （主属性类型为 int类型）

先看使用的数据库，然后根据数据库选择主键生成方式，如果是mysql数据库：identityà auto_increment

数据库自动生成主键：首先是主属性为int类型，大部分都是从1开始（基本上没有从0开始的数据）。

session.save(user);//就发送sql语句了，insert语句中不会插入ID，ID由数据库自动生成，人为设定的sql语句无效。发送sql语句：insert into()，目的是生成主键。

一旦发送sql语句了，数据库中一定会有对应的记录。

主键生成策略为native，save后的特点：（进入持久态）

1、 session的临时集合中没有数据，(临时集合是为了发sql语句而存在的)

2、 session的缓存persistanceContext下的map下的existInDatabase=true;表示数据库中有数据，但是是脏数据。（查不到）

脏数据：未经证明和检测的数据

事务提交特点：先插入数据，再对数据进行验证，如果正确就提交到数据库中，如果有误就回滚。没有提交的数据叫做脏数据，mysql事务的传播特性是可提交读，看到的数据是提交后的数据，看不到脏数据，所以提交前在数据库的表中查不到数据。

session.getTransaction().commit();//commit()后才会检查数据的正确性。（对数据库中的脏数据进行确认，如果正确就将脏数据变为可用数据《在数据库中可以查到》，如果不正确就将脏数据回滚。）

主键生成策略为assigned（用户提供）

主键标识为String类型

1、不设置对象的ID值，直接save()，会从user对象中共取ID，发现没有会抛出异常

2、 2.1、设置ID值

2.2、 session.save(user);从瞬时态进入持久态：不发送sql语句，user对象纳入session缓存，存放在session的临时集合中的insertions中，session的缓存persistanceContext下的map的loadedState下也会有数据。数据库中没有数据，existInDatabase=false;

2.3、 session.getTransaction().commit();临时集合中的数据清空，数据库中有数据。existInDatabase=true;

通过配置让数据库自动生成表：

<property name=” hiberante.hbm2ddl.auto”>update</property>

作业：分析三种主键生成策略在session缓存中的异同：

主键生成策略为native和uuid，assigned的异同：

native：根据数据库不同而自动选择对应数据库的主键生成策略。比如：mysql数据库à主键生成策略为：identity.主属性类型为int类型。（用户手动设定的ID无效）

uuid：将IP地址，JVM的启动时间，系统时间以及和指令相关的随机数相结合随机生成32位uuid码。主属性类型为String类型。（用户手动设定的ID无效）

assigned：用户在创建对象的时候，手动设定主键（ID的值）。主属性类型为String类型，如果不设定ID 就会抛出异常。

session.getTransaction();//开启事务

User user=new User();//创建User对象

user.setID(“123”);

user.setName(“zhangSan”);

这时候三种主键生成方式（native,uuid,assigned）都相同： user对象处于瞬时态，没有纳入session管理(临时集合和session缓存map中都没有user对象的相关数据)

session.save(user);

相同点：将user对象纳入session管理，进入持久态。

native：（发送insert 语句）。临时集合中没有数据，session缓存的map下的table中有数据，loadedState中有user对象值，existInDatabase=true，user对象依旧存在，user对象的ID值变为数据库中自增的ID值。

uuid：临时集合insertions中的instance和state中都有数据，ID为hibernate自动生成的32位码，session缓存的map下的table中有数据，loadedState中有user对象值，existInDatabase=false，user对象依旧存在（ID为32位码，其余属性值不变）

assigned；临时集合insertions中的instance和state中都有数据，ID为用户手动设定的值，session缓存的map下的table中有数据，loadedState中有user对象值，existInDatabase=false，user对象依旧存在（值和设定的一样）。

user.setName(“Tom”);//修改进入持久态后的数据

相同点：user对象中的name属性值变为Tom,session 缓存的map下的table中的值不变。

native:临时集合中依旧没有数据。

uuid: 临时集合insertions中的instance 指定的name属性改变为 Tom, state指定的name属性依旧为zhangSan，

assigned: 临时集合insertions中的instance 指定的name属性改变为 Tom, state指定的name属性依旧为zhangSan。

session.getTransaction().commit();//提交事务

相同点：session缓存的map下的table中有数据，loadedState中user对象的name属性值为Tom,existInDatabase=true,

native:（发送update语句）， user对象依然存在。

uuid: (发送两条sql语句，先insert，后update)临时集合insertions的数据清空, user对象依然存在。

assigned: (发送两条sql语句，先insert，后update)临时集合insertions的数据清空, user对象依然存在。

session.close();//关闭事务

相同点：session缓存map下的table中的数据被清空， user对象依然存在。user对象处于瞬时态。

native:临时集合中一直没有数据，

uuid:临时集合中数据被清空，

assigned:临时集合中数据被清空

Many-to-one

关联属性：多对一：（Many-to-one）

关联属性的特点：

如果属性的类型时自定义类型，那么这个属性就是关联属性

如果属性的类型时集合或者数组，那么这个属性有可能是关联属性

对象模型通过关联属性建立关联关系

关系模型的关联关系通过外键建立关系

谁往外键里存放数据，谁就在维护关系。

核心技术：配置*.hbm.xml

关联属性的映射：（外键）

<many-to-one name=”group” column=”groupid” cascade=””/>

column=”groupid”：这个值的设定参照group属性对应的Group对象的id属性。

这是怎么知道引用的表是group表的主键？

因为User实体类中，有Group类型的group属性。根据关联属性找到引用的外键表。

存储数据：(主键生成策略都为native)

Group group=new Group();//先创建Group对象，

group.setName(“zte”);// 给该对象的属性赋值，（id自动分配）

session.save(group);//发送insert into 语句,取得id

将Group对象的地址赋值给User对象的group属性中。

User user=new User();//再创建User对象，

user.setName(“zs”);// 给该对象的属性赋值，（id自动分配）

user.setGroup(group);//通过user拿到group属性所指的Group对象，取出该Group对象的id值，将取到的id设定到groupid字段中。（groupid是 hbm.xml文件中 many-to-one 标签中的name指定的字段名）

session.save(user);//数据库发送sql语句，insert into ，生成id。将user对象属性的属性值设定到数据库中的user表中的对应的记录的各个字段中。

cascade(级联属性): all,update-save,delete,none

加载：（将关系模型转换为对象模型）

User user=(User)session.load(User.class,1);

将从数据库中查出来的记录，将字段依次赋值给User对象的对应属性。

Many-to-one：通过外键（groupid）找到对应的 Group对象对应的group表中的记录，根据记录再创建Group对象赋值，将Group对象设定到User对象的group属性中。（通过外键找主键）

user.getName();//zs，这叫类上的懒加载，只发送一条sql语句，只查询user表

user.getGroup().getName();//这就叫单端上的懒加载，用到两张表的时候查询两张表

单端上的懒加载在外键设定的标签上，<set><many-to-one>

外键可以为空，如果不为空，一定是所关联表的有效值(一般为关联表的主键）

TransientObjectException：持久态对象引用了瞬时态对象

如果不给Group对象的id属性设值，那么默认值为0 ，

不save Group对象。Group对象为瞬时态。id依旧为默认值0；

创建User对象，给user对象的各个属性赋值。

session.save(user);//发送sql语句，insert into

将Group对象的id属性值（0）设置到User对象中的group属性所指Group对象的id ,对应数据库中的字段为groupid上。

Mysql数据库的主键不能为0 ，所以这就违反了参照完整性。

session.getTransaction().commit();

提交，就检查数据，发现错误就回滚。（commit以前的数据都是脏数据）

这里的user对象处于持久态，user对象使用了瞬时态数据 group对象，瞬时态的对象的id是无效值。所以会出现TransientObjectExecption.

主要原因：持久态对象引用了瞬时态对象，就会出现TransientObjectException

结论：持久态对象不能引用瞬时态对象。

解决办法：

1. 创建group对象的时候就session.save(group);

2、添加级联属性。

<many-to-one name=”group” column=”groupid” cascade=”all”>//持久态对象引用瞬时态对象，加了cascade时，会自动先把瞬时态对象save进入持久态。在执行session.save(user)这条语句时，会先执行 insert into group(),再执行insert into user();

cascade:（级联属性）

cascade的取值：all、none、save-update,delete

cascade的作用：存储，而不是为加载服务的。

级联：两个对象中的操作联动性，对一个对象操作后，对其指定的级联对象也需要执行相同的操作。(对象的连锁操作)

all:所有情况下执行级联操作

none:任何情况下都不执行级联操作

delete:在删除的时候执行级联操作（容易出错）

save-update:在保存和更新的时候执行级联操作

Hql语句对所有的数据库都一样：

Query query=session.createQuery(“from User user where user.group.name=’zte’ ”);//从数据库中找到User类对应的t_user表，从user表中找到user对象的group属性所指定的Group对象对应的t_group表，找出t_group表中的name=‘zte’的那条记录。

相当于sql语句；

select * from t_user ,t_group

where t_user.groupid=t_group.id

and t_group.name=’zte’;

One-to-one：（一对一）

一对一单向关联：

对象模型：

Person: （类）

int id;

String name;

IdCard idCard;//关联属性

IdCard：（类）

int id;

String cardNo;

关系模型：

Person表和idCard表的主键相同，一一对应

(两个表的主键相同并不意味着两个表有关系)

三大问题：（在*.hbm.xml文件中体现）

1、如何建立关系

2、如何存储关系

3、如何加载关系

建立关系：（在数据库中建表时）

t_person:（表）

具有关联属性的那个对象生成对应的表时，需要设定主键生成策略为 foreign：t_person表中这样设定，使得对象一一对应。

<generator class=”foreign”>

<param name=”property”>idCard</param>//引用的是idCard属性的所指的IdCard对象的主标识 （id属性值）

</generator>

</id>

一旦纳入session的管理，person对象的id需要和IdCard的id相同。（通过session保证一对一关系：执行save语句的时候将IdCard对象的id赋值给person对象的id）

必须加约束： <one-to-one name=”idCard” constrained=”true”/> （创建t_person表的时候不会创建idCard字段，这里表示引用的外键是当前t_person表的主键，外键参照idCard属性对应的IdCard对象所映射的t_idCard表。）

1、建立关系：表示当前person类所映射的表的主键就是外键，

2、存储关系：外键参照idCard属性对应的类所映射的表生成

3、加载关系：one-to –one ,通过主找主，为当前映射属性idCard赋值

如果不添加 constrained=true，在创建表的时候会缺少 foreign key(id) references t_idCard (id)语句，就不会有外键。这样t_person表和t_idCard表就没有任何关系了。

t_idCard:（表）

和普通表一样，没有外键，主键为id.<id name=id>

存储关系：（在生成对象时建立存储关系）

1、先创建IdCard对象，

IdCard idCard=new IdCard();

idCard.setCardNo(“123”);

session.save(idCard);//发送sql语句，生成id主标识，纳入session管理

2、创建Person对象

Person person =new Person();

person.setName(“tom”);

person.setIdCard(idCard);

session.save(person);//这里不发送sql语句，（因为不需要数据库为之生成id）直接从Person对象的idCard属性所指的IdCard对象中拿到主标识（IdCard对象中的id属性值）设为Person对象的主标识（id属性）。从这里建立了对象和对象之间的一对一关系。临时集合中有数据（insertions）,数据库中没有数据。

commit()就把Person的id属性映射到t_person的id字段上。

主标识：为对象中的id

主键：为数据库表中的id

3、 t_person表在数据库中存储Person对象的idCard（关联）属性的时候：把关联属性的值存在数据库的表的外键上。往对应的外键设值，通过映射发现，存储idCard属性的时候，外键就是主键 id。往主键id上设定值，t_person表的主键id值来自于idCard属性所指的IdCard对象映射的t_idCard表的主键（id）.

One-to-one：主键关联，自动级联。cascade=”all”

假若在session.save(person);语句执行之前，不执行session.save(idCard)语句，

IdCard对象还没有纳入session管理，也没有为 IdCard对象分配主标识，IdCard对象处于瞬时态。

1、执行session.save(person)时，发现IdCard没有主标识，Person对象无法拿到主标识。

2、 自动先发送IdCard的sql语句，insert into t_idCard (),先为IdCard对象分配主标识（IdCard对象纳入session管理，进入持久态，IdCard在数据库中有数据）

3、 将IdCard的主标识赋给Person对象的主标识，Person对象纳入session管理，进入持久态。Person在数据库中没有数据，因为person还没有发送sql语句，所以Person对象在临时集合insertions中有数据。

加载关系： one-to-one（主找主）

Session.load(Person.class,1);

通过t_person表的主键找到所关联的t_idCard表的主键对应的记录，创建IdCard对象，并将该IdCard对象赋值给Person对象的idCard属性。其余属性直接赋值。

Session不允许同一个类的不同对象使用相同的ID。

如果两个不同的对象引用同一个对象的id,会抛出异常。

例如：

IdCard idCard=new IdCard();//创建Idcard对象

idCard.setCardNo(“123”);

session.save(idCard);//发送sql语句，生成id主标识，纳入session管理

Person person =new Person();//创建第一个Person对象

person.setName(“tom”);

person.setIdCard(idCard);

session.save(person);//不会发送sql语句，将IdCard对象的主标识id给该Person对象

Person person1 =new Person();//创建第二个Person对象

person.setName(“lisa”);

person.setIdCard(idCard);//引用同一个IdCard对象

session.save(person1);// //不会发送sql语句，将IdCard对象的主标识id给该Person对象，所以在这里会抛出异常，因为one-to-one不同对象不能引用同一个对象的id.

一对一主键双向关联： 两张表中的数据可以相互查询

IdCard.hbm.xml中：主键生成策略为native

这里的person在实体类中为Person类型。

<one-to-one name=”person”>:单独使用不会在创建表的时候不会指定外键,也不能往外键中设值，只会加载关系，给Person属性赋值。

person 不是关联属性，

Person.hbm.xml中：主键生成策略为foreign

这里的idCard在实体类中为IdCard类型。

<one-to-one name=” idCard” constrained=”true”>:指定外键就是主键，外键的生成参照idCard属性对应的IdCard类映射的idCard表。还可以加载。

idCard为关联属性，

建立关系：两张表的关系依靠Person类中的idCard属性建立关系。

维护关系：存储Person的idCard属性时，外键就是t_person的主键，维护关系。

加载关系：

session.load(IdCard.class,1);

IdCard类中的person属性通过one-to-one（主找主），到t_person表中找到对应的记录，创建Person对象给IdCard类的person 属性赋值。

不是所有的类中的自定义类型都是关联属性，当前IdCard类中的person属性就不是关联属性，

一对一唯一外键单向关联：（外键 unique=”true”）

让外键唯一，两条记录便是一一对应。

Person的配置：使用 many-to-one.配置

<many-to-one name=”idcard” unique=”true”>//在映射关联属性创建关系的时候会在表中创建字段idCard，关系通过many-to-one :创建外键，外键参照idCard属性的类所映射的t_idcard表。设定unique=”true”,使得外键唯一。

<many-to-one name=”idcard”>:一定要先save所引用的对象，它不会自动级联，在数据库的表中会生成idcard字段。

<one-to-one name=”idcard”>指定主键就是外键，可以自动级联，在数据库的表中不会生成idcard字段。

建立关系：

<one-to-one name=”idcard”>相当于：<many-to-one unique=”true” name=”idcard” cascade=”all”> 由many-to-one建立关系，指定idcard为外键。

加载关系：

Many-to-one：找到idCard在t_idcard表中对应的记录，生成IdCard对象，设定到Person对象中的idcard属性上。

存储关系：

Person存储关系：存储Person的idcard属性值，往数据库的idcard字段设值是存储，因为idcard字段是外键。（如果往不同的对象的idcard属性中存同一个的idcard对象，由于设定了unique=”true”,就会抛出异常，外键重复。）

在这时候持久态对象引用瞬时态对象，由于瞬时态对象的默认id值为0，不影响数据库的存储，在save()的时候不会产生异常，commit()的时候数据库就会检测0为非法数据就会抛出异常。

一对一唯一外键的双向关联：

Person表的映射不变：

int id;

IdCard idcard;//关联属性，建立关系，维护关系，加载关系（外键）

<many-to-one name=”idcard” unique=”true”>

IdCard表的映射：

int id;

String cardNo;

Person person;//不建立关系，不维护关系，只加载关系（非外键）

<one-to-one name=”person” property-ref=”idcard”/ >

property-ref=”idcard”:将位置指针挪到t_person表中的idcard属性上。

property-ref：表示引用person属性对应的Person对象所映射的t_person表中的idcard字段。

加载关系：

给IdCard的person属性设值，one-to-one

主找主找不到对应的数据，property-ref=”idcard”,位置指针挪到idcard字段上，找到idcard字段对应的那条记录，生成Person对象，将该person对象赋值到person属性中，

MyEclipse快捷键：

Ctrl+shift+T:查找类

Ctrl+F:查找类中的具体方法

one-to-many

one-to-many 单向关联：

一对多：由一的一方来建立关系，存储关系，使用关系（加载）。

外键一定在多的一方。

一怎么管理多：建立集合，管理多方（Set集合）

为什么不是List集合和map集合，因为Hibernate为Set集合重写了懒加载。

一个班级多个学生

Classes 类：（一方）外键关系创建方、维护方、使用方

int id;

String name;

Set students;

Student类：（多方）外键关系存放方

int id;

String name;

Set 集合可以存放任意类型的数据。（关联属性）

建立关系：

t_classes表在映射关联属性的时候，会创建外键,并且把外键设定在t_student表中，所以t_student表中有classesid字段。但是这个外键的关系由Classes维护。

Student.hbm.xml

Classes.hbm.xml

<set name=”students”>

<key column=”classesid”/>

<one-to-many class=”cn.hiberante.bean.Student”/>

</set>

1、用set标签映射关联属性，当前Classes对象中的students属性

2、创建Classes对象的时候在Set集合中存放 Student类型的数据

3、创建外键字段 key column=”classesid”,加在<one-to-many>指定的class àStudent类所映射的t_student表中

4、增加的字段classesid为外键，通过 one-t-many：外键与当前表建立关联，外键参照t_classes表

通过上面的映射：

t_student表中有三个字段， id,name,classesid;

t_classses表中有两个字段：id，name

维护关系：(关系存储，往外键里面设值) native

1、创建多个学生对象（两个或者两个以上）

Student stu=new Student();

stu.setName(“tom”);

session.save(stu);//id 生成，name为tom，外键classesid为空，进入持久态，纳入session管理(外键可以为空） insert into t_student(name) values(?);

Student stu1=new Student();

stu.setName(“Jam”);

session.save(stu1);//id 生成，name为Jam，外键classesid为空，进入持久态，纳入session管理(外键可以为空）insert into t_student(name) values(?);

2、创建Set集合，将Student对象添加到集合中

Set students =new HashSet();

students.add(stu);

student.add(stu1);

3、创建Classes对象

Classes classes=new Classes();

classes.setName(“java1”);

classes.setStudents(students);//将创建的Set集合students设到Set集合类型属性students中

session.save(classes);//发送sql语句，id自动生成，把Classes的name属性存在t_classes表中的name字段上。insert into t_classes(name) values(?);

关联属性的存储：(外键设值)

1、从students这个Set集合中拿到第一个元素stu,取得stu对象，

2、 拿到stu对象主标识，（因为stu已经save过了，所以能取到该对象的主标识）

3、通过stu对象的主标识找到数据库中t_student表中对应的记录

4、存储的时候拿到Classes对象的主标识id,（因为classes对象已经save）

5、 将Classes对象的主标识（id值）设定到stu对象对应的t_student表中的对应记录的classesid字段上。

第二个元素stu1和第一个一样;

session.beaginTransaction().commit();//提交后会发送update语句，有多少个学生对象会发送多少条update语句，update t_student set classesid=?where id=?;

加载关系：（将数据库中查出来的记录给对象赋值）

session.load(Classes.class,1);

classes.getName();//直接取出记录中的name字段的值设置到name属性中

classes.getStudents();

one-to-many，主找外：（一个对应多个）

1、通过主键到对应的t_student表中找到外键，找到对应的第一条记录

2、创建Student对象，

3、创建Set集合（有记录时才会创建）

4、将Student对象add到Set集合中

5、然后继续通过主找外，依次找到所有的Student对象都分别add到Set集合中

6、最后把Set集合设置到Classes对象的students属性上。（students属性为Set类型）

One-to-many单向映射的缺点：

1、如果t_student表中的classesid字段设置为非空，就无法保存数据

2、因为不在Student这一端维护关系，所有Student不知道是哪个班的

3、需要发出多余的update语句（数据库负载大）

one-to-many 双向关联：

建立关系：

Student 类

int id;

String name;

Classes classes;

Student.hbm.xml文件：

<many-to-one name=”classes” column=”classesid”>

让外键重名，保证关系维护的一致性。

Classes 类：

int id;

String name;

Set students;

Classes.hbm.xml文件：

<set name=”students” inverse=”true” cascade=”all”>

<key column=”classesid”/>

<one-to-many class=”cn.hiberante.bean.Student”/>

</set>

Key指定的字段名必须和<many-to-one name=”classes” column=”classesid”>指定的一样

外键的关系由一端维护，两头使用关系。

双向关联时，由多的一方存储关系，维护关系。

<set name=”students” inverse=”true” cascade=”all”>

<key column=”classesid”/>

<one-to-many class=”cn.hiberante.bean.Student”/>

</set>

让多的一方（Student）维护关系。添加inverse=”true”

维护关系：(关系存储，往外键里面设值)

1、创建多个学生对象（两个或者两个以上）

Student stu=new Student();

stu.setName(“tom”);

session.save(stu);//id 生成，name为tom，外键classesid为空，进入持久态，纳入session管理(外键可以为空）Student可以维护关系但是不维护关系。Classes不设值就为null. insert into t_student(name，classesid) values(?,?);

Student stu1=new Student();

stu.setName(“Jam”);

session.save(stu1);//id 生成，name为Jam，外键classesid为空，进入持久态，纳入session管理(外键可以为空）Student可以维护关系但是不维护关系。Classes不设值就为null. insert into t_student(name，classesid) values(?,?);

2、创建Set集合，将Student对象添加到集合中

Set students =new HashSet();

students.add(stu);

student.add(stu1);

3、创建Classes对象

Classes classes=new Classes();

classes.setName(“java1”);

classes.setStudents(students);//将创建的Set集合students设到Set集合类型属性students中

session.save(classes);//发送sql语句，id自动生成，把Classes的name属性存在t_classes表中的name字段上。insert into t_classes(name) values(?);

这时候Classes想维护关系，但是看到inverse=”true”,就无法维护关系,Student可以维护关系但是不维护。创建的表 t_student 中的 classesid列为null.

Inverse的作用：（值为true/false）

1、指定谁反转另一方来维护关系

2、主要使用在set集合标签上

3、主要用于存储关系

正确流程：

先创建classes对象，只给name属性设值；（id，set集合都不设值）

再创建Student对象，每个值都设值(id，name,classes)

再创建Set集合将Student对象add到set集合中

session.save(classes);//insert into t_classses(name) values(?);

inverse=true:

设定由另一端往外键中设值。(对方来维护关系)

用在Set标签上

用在存储上（加载用不着inverse）

通常inverse后面会加 cascade 级联属性

cascade=all：

session.save(classes)当Classes对象准备维护关系的时候，inverse属性为true，让Student属性维护关系.所以就自动发送session.save(stu);就创建Student对象的 id主标识，往外键设值（Student对象的classid属性）à拿到classes所指的Classes对象的主标识设到classesid上。

优点：没有发送多余的sql语句（update）

Inverse和cascade：

1、都是进行存储的时候使用

2、 inverse à翻转，指定由对方来存储关系

3、 cascade在存储数据以前，如果需要存储另一种数据，就会自动的发送save语句，先存储另一种数据再save当前对象。

4、 inverse:是关联关系的控制方向，用在set标签上

5、 cascade操作上的连锁反应,用在 one-to-one,many-to-one,one-to-many标签上

周末任务：

1、整理出Hibernate案例，把笔记分析都添加到对应的案例上

2、 Many-to-one *

3、 One-to-one *

4、 One-to-many *

5、 Many-to-many

6、单继承映射关系

7、看Oracle视频，学会Oracle数据库的基本操作建表以及增删改查

8、复习一下struts1.0，尽量完善自己的struts框架

9、找到Hibernate源码，看看源码，增强自己对映射关系的理解

Many-to-many：（多对多）

多对多---单向关联：

示例：一个人可以有多个角色，一个角色可以由多个人担当

从关系模型中体现多对多关系：创建中间表

中间表的特点：

至少有两个外键，外键分别参照两张表的主键

这两个外键共同生成主键à联合主键

两个外键的值都由一个对象的关联属性设定，关联属性为Set集合类型。

建立关系：

Role:（类）

int id;

String name;

Role.hbm.xml

User （类）

int id;

String name;

Set roles

Roles属性映射指定：

1、 Set里面放什么类型的数据

2、创建第三张表 t_user_role

3、往第三张表中添加两个字段（两个外键分别参照两张表）

User.hbm.xml

<set name=”roles” table=”t_user_role”>

<key column=”userid”/>

<many-to-many class=”cn.hibernate.Role” column=”roleid”>

</set>

1、指定roles的Set集合中存放cn.hibernate.Role类型的数据

2、 Many-to-many, 需要创建中间表，映射时roles属性时，创建t_user_role表

3、 <key column=”userid”/>指定外键字段userid,把这个字段添加到t_user_role表中

4、 userid这个外键字段参照当前对象所对应的表t_user表

5、在many-to-many 后面的column=”roleid” 指定外键字段 roleid, 把这个字段添加到t_user_role表中

6、 roleid这个外键字段参照class指定的Role所映射的t_role表

7、 userid和roleid为 t_user_role表的联合主键，分别参照t_user和t_role表

存储关系：

先创建Role对象：

Role role1=new Role();

role1.setName(“zs”);

session.save(role1);//insert into t_tole(name) values (?);

Role role2=new Role();

role2.setName(“ls”);

session.save(role2); //insert into t_tole(name) values (?);

再创建User对象

User user=new User();

user.setName(“wife”);

创建Set集合，将Role对象添加到set集合中

Set set=new HashSet();

set.add(role1);

set.add(role2);

user.setRoles(set);//把存储Role对象的Set集合设定到roles属性中

session.save(user);//发送三条sql语句，在t_user_role表中创建两条记录

//insert into t_user (name) values (?);

//insert into t_user_role(userid，roleid) values (?,?);

//insert into t_user_role(userid,roleid) values (?,?);

在当前对象Set集合中有几个元素，就会在t_user_role表中创建几条记录

id自动生成，name字段直接映射

存储User对象的关联属性roles：

从roles的Set集合中拿出第一个元素role1,拿到role1对象的主标识，

将role1对象的（主标识）id，设到t_user_role的roleid字段上

拿到当前User对象的id, 设到t_user_role的userid字段上

从roles的Set集合中拿出第二个元素role2,拿到role2对象的主标识，

将role2对象的id主标识，设到t_user_role的roleid字段上

拿到当前User对象的id, 设到t_user_role的userid字段上

加载关系：

关联属性的加载，给关联属性roles赋值：

1、 many-to-many:分成一对多（one-to-many），和多对一(many-to-one)；

2、 one-to-many（主找外）,通过t_user表中 id 找找t_user_role表中对应的userid

3、通过userid自动找到 roleid字段

4、 many-to-one（外找主），通过roleid字段找到t_tole表中的对应的id指定的行生成记录

5、根据记录生成Role对象，设到Set集合中

6、继续重复2-5（直到找完t_user表中指定id对应的t_user_role表中的所有记录）

7、将赋完值后的Set集合设定到roles属性中

多对多---双向关联：

建立关系：

Role:（类）

int id;

String name;

Set users

Role.hbm.xml

<set name=”users” table=”t_user_role”>

<key column=”roleid”/>

<many-to-many class=”cn.hibernate.User” column=”userid”>

</set>

User （类）

int id;

String name;

Set roles

Roles属性映射指定：

4、 Set里面放什么类型的数据

5、创建第三张表 t_user_role

6、往第三张表中添加两个字段（两个外键分别参照两张表）

User.hbm.xml

<set name=”roles” table=”t_user_role”>

<key column=”userid”/>

<many-to-many class=”cn.hibernate.Role” column=”roleid”>

</set>

<set name=”” table=”t_user_role”>//这里table指定的表必须一样

两张表都可以维护关系，

User维护关系，set集合中存放Role类型的数据，

key column=”userid”,参照 t_user表

<many-to-many class=”cn.hibernate.Role” column=”roleid”>

roleid参照 class指定的类Role对应的t_role表

Role维护关系，set集合中存放User类型的数据，

key column=”roleid”,参照 t_role表

<many-to-many class=”cn.hibernate.User” column=”userid”>

user参照 class指定的类User对应的t_user表

创建关系可以双方创建，

维护关系只能一方维护

使用关系可以双方使用

存储关系：

存储的时候，只能由一方维护，只让一方给关联属性设值，设值的一方就是在维护关系。

加载关系：

和单向关联类似

关联属性的加载，给关联属性roles赋值：

1、 many-to-many:分成一对多（one-to-many），和多对一(many-to-one)；

2、 one-to-many（主找外）,通过t_user表中 id 找找t_user_role表中对应的userid

3、通过userid自动找到 roleid字段

4、 many-to-one（外找主），通过roleid字段找到t_tole表中的对应的id指定的行生成记录

5、根据记录生成Role对象，设到Set集合中

6、继续重复2-5（直到找完t_user表中指定id对应的t_user_role表中的所有记录）

7、将赋值后的Set集合设定到roles属性中

单表继承映射

建立关系:

一个父类，两个子类

一个hbm.xml文件

Hibernate默认 lazy=”true”

Extends.hbm.xml文件的配置：

<!— Animal为父类,具有id,name,sex三个基本属性-->

<!—discriminator :为鉴别器，指定type为鉴别器字段（not-null=true）。string是Hibernate定义的String类型。在t_animal中增加type字段。类型为string,在数据库中会转换为varchar类型。自动把 discriminator-value的值自动设定到该字段上。

-->

<!—Pig继承了Animal,为子类，Pig子类有新增的weight属性

discriminator-value：指定鉴别值，设到鉴别器字段中

-->

</subclass>

<!—Bird继承了Animal,为子类，Bird子类有新增的height属性

discriminator-value：指定鉴别值，设到鉴别器字段中

-->

</subclass>

</class>

Discriminator（鉴别器）的作用：加载时，自动识别记录生成对应的对象类型。

存储关系：（识别子类类型，自动往鉴别器字段加鉴别值）

Pig pig=new Pig();

pig.setName(“xiaohua”);

pig.setSex(true);

pig.setWeight(100);

session.save(pig);//id自动生成

1、通过Pig这个类，找到映射文件中的子类subclass name=”Pig”

2、通过subclass子类找到父类class=”Animal”，

3、根据class=”Animal”找到对应的表 t_animal，

4、往Pig对象设定到t_animal表中id指定的记录上的的各个字段。没有height属性的就设为null，

5、type字段的设值：看到是subclass,就往type鉴别器字段自动设 discriminator-value指定的值。（这个值Hibernate根据配置信息自动设定）

加载关系：

加载子类对象：

session.load(Pig.class,1);// Sql：select * form t_animal where id=1 and type=’P’.

通过*.hbm.xml文件中找，通过Pig找到t_animal表

到表中找到id=1对应的记录

在查找的时候会自动添加查找条件 type=’P’.

生成的记录对应的对象为Pig类型

加载父类对象：

Animal animal =(Animal)session.get(Animal.class,1);

if(animal instanceof Pig) ==true

到t_animal表中查出id=1的记录，拿到所有字段，

发现type=”P”,知道应该创建Pig类型的对象。

load方法查询不支持多态查询，get方法查询支持多态查询。

Load支持懒加载，不支持多态查询：因为load拿到的是cglib代理对象，代理类不是真正的实例 无法用instenceof判断类的归属

Query支持多态查询，

session.createQuery(form Animal);

拿出所有的记录并且生成对应子类对象。（指定类型）

多态查询：单表查出数据，Hibernate可以自动鉴别类的数据类型（指定生成对象类型）。

单表继承唯一缺点是：多了冗余字段。

如果关闭懒加载，load就支持多态查询。（直接发送sql语句）lazy=false,默认情况下lazy为true。

多表继承映射：

继承关系：每一个具体的类映射成一张表

Animal为父类，Pig为子类。

建立关系：(建立三张表，t_animal,父类对应的表中有三个字段，t_pig,t_bird子类对应的表中只有两个字段，主类的主键也为外键，参照父类的主键。对应子类和父类主键保持一致)

映射文件：

<class name=”Animal” table=”t-animal”>

</id>

<joined-subclass name=”Pig” table=”t_pig”>

<!—pid是当前表t_pig的主键，也是外键参照父类的t_animal表。-- >

</joined-subclass>

</class>

存储关系：

Pig pig=new Pig();

pig.setName(“hua”);

pig.setSex(“male”);

pig.setWeight(100);

session.save(pig);

1、通过子类Pig找到父类Animal,再找到Animal对应的表t_animal

2、先往父类的表中存数据，t_animal（id,name,sex）

3、再往子类的表中存数据，将t_animal的id设到t_pig表中的pid字段。t_pig（weight,pid）

<从t_animal中拿到主键作为当前t_pig表的主键(因为pid即使主键也是外键)>

加载关系：

Pig pig=(Pig)session.load(Pig.class,1);

1、先从t_pig中找对应记录，拿到该记录的主键（先找子表），找到weight字段，设到weight属性中。

2、再通过外找主，找到t_animal中对应的记录，将查到的记录设到pig对象中。Sex,name.

优点：结构清晰，一个类一张表

缺点：查找效率低，（需要多个表关联查询）

继承映射：每个子类一张表，父类没有对应的表

缺点：主键生成策略不能为native,只能为assigned

Animal为父类，Pig为子类。

建立关系：

<!-- abstract=”true”：表示父类不生成表，映射的属性字段被子类继承，让子类应用-- >

<class name=”Animal” abstract=”true”>

<!—这里只能为assigned-- >

</id>

<union-subclass name=”Pig” table=”t_pig”>

</union-subclass>

</class>

只有t_pig表,子类的映射的表不仅有自己的属性对应的字段，还会有父类的属性对应的字段。（weight+name,sex）

存储关系：

Pig pig=new Pig();

pig.setId(2);

pig.setName(“hua”);

pig.setSex(“male”);

pig.setWeight(100);

session.save(pig);

/*这里不会发送sql语句，因为主键生成策略为assigned，发sql语句是为了拿到主键。这里的主键已经自己手动指定，所有不需要发送sql语句。

Pig对象已经纳入session管理，id为2.。*/

如果再创建一个Bird,

Bird bird=new Bird();

bird.setId(2);

session.save(bird);//这里就会抛出异常，因为id已经在session中存在。

同一个类的不同对象，一旦纳入session管理，id必须不同。

同一个类的不同子类对象，id也必须不同。否则会出异常。

关于主键生成策略：

父类的属性会被子类继承，映射在子类的字段中，

父类的主键生成策略会被子类继承。

如果为native或者是uuid,有数据库或者hibernate自动生成，只生成一次。

session.save()的时候，会为父类对象生成主标识

同一个id会被父类的所有子类都继承作为子类的主标识id,就会造成多个子类对象引用相同的主标识，就会抛出异常。同一个类的不同子类对象，id必须不同。

单表继承：

优点：效率高

缺点是数据冗余

一个类映射一张表：

优点：结构清晰，一个类一张表

缺点：查找效率低，（需要多个表关联查询）

一个子类映射一张表：

优点：结构清晰，效率高

缺点：主键不能自动生成，必须制定为assigned（不符合hibernate）

建议使用第一种，单表继承.

物料项目：

持久层：继承映射和关联映射同时使用

用户需求：主键生成策略为assigned

鉴别器字段 discriminator column=”category” type=”string”

存储关系：(继承关系的表中的数据的存储)

通过子类对象找到子类所在的映射文件，拿到鉴别器值 discriminator-value=pig”

在映射文件中，通过子类找到父类，通过父类找到对应的表 t_data_dict

往父类的表（t_data_dict）中设值。

加载关系：（继承关系的表中的数据的加载）

session.createQuery(from ItemCategory);

相当于sql语句：select *from t_data_dict where category=itemCategory;

因为查询的是子类对象，多态查询，会自动加上鉴别器的值category=itemCategory。

将查询出来的记录封装到Query对象中，再通过.list()方法，将Query对象中的记录存到list集合中。

关联映射：（关于关联属性的映射- Item对象）

Item:

Private ItemCategory category;

Category为关联属性，通过配置hbm.xml文件

<many-to-one name=”category”>

表明category为外键，参照的是category属性所属的类ItemCategory所映射的表，但是由于ItemCategory为子类并且在单表继承映射中，所有参照的是ItemCategory的父类所映射的表t_data_dict。

存储关系：（关联映射--存Item对象）

在Action中：

1、从表单中拿到表单中的参数（普通属性以及关联属性的值）

2、创建Item对象，将普通属性设到Item对象中（Item处于瞬时态）

3、创建ItemCategory对象，ItemCategory category=new ItemCategory();（从数据库中取出来的数据是离线态，在数据库中有对应的记录）

4、 category.setId (categoryId);// categoryId为从表单中取出来的数据

5、 item.setItemCategory(category);//给关联属性赋值

6、创建ItemUnit对象，ItemUnit unit=new ItemUnit();//离线态

7、 unit.setId(unitId);//unitId为从表单中取出来的数据

8、 item.setUnitItem(unit);// //给关联属性设置

持久态对象可以引入离线态对象，不会有异常，因为离线态对象在数据库中有对应的id.

加载（关联映射—给关联属性赋值）：

session.load(Item.class,itemNo);

1、找到hbm文件

2、找到对应的表 t_items

3、根据itemNo找到对应的记录

4、将对应的记录设到Item对象中

5、给关联属性ItemCategory赋值，many-to-one,外找主，找到t_data_dict中对应的记录

6、根据记录生成对象，将对象赋值给Item对象中的category属性

懒加载（Lazy）

懒加载概念：只有真正使用该对象时，才会创建对象；对于Hibernate而言，真正使用对象的时候才会发送sql语句查询数据库。

懒加载--lazy主要用于加载数据。

lazy使用的标签：

<class>:

<peroperty>:

<set><list>:

<one-to-one><one-to-many>:

懒加载的实现原理：产生cglib代理

1、生成目标类的子类（cglib代理类）

2、一旦需要使用对象的方法时，判断target是否等于null（target为代理对象中的一个状态标识，默认为null,对象创建后就会等于对象的类型 target=Group）

3、如果target不等于null就直接使用

4、如果target等于null 就发sql语句查询数据库根据记录生成对象再使用。

懒加载的分类：

1、类上的懒加载<class>：：true/false,默认为true，开启懒加载

2、集合上的懒加载<set>：： true/false/extra 默认为true

3、单端关联懒加载<one-to-one><one-to-many>：：

：false/proxy/noproxy,默认为proxy

类上的懒加载：（默认开启lazy=”true”）

Group gourp=session.load(Group.class,1);//执行这条语句时不会马上发送sql语句

创建的Group对象是cglib代理对象，target=null;

group.getId();//取得id的时候也不会发送sql语句，因为上面查询条件中已经给出id的值。group依旧是cglib代理对象，target=null。

group.getName();//这时候group还是cglib代理对象。然后发送sql语句。

cglib代理对象是目标对象的子类，会继承目标对象的方法，会先判断目标对象是否存在（target==null）。如果存在就会调用目标对象的方法；如果不存在就会发送sql语句，从数据库中查询记录，根据记录创建目标对象，执行目标对象的getName()方法。target=Group。

再执行一次 group.getName();这里还是代理对象，目标对象是由cglib代理对象调用。会判断target==null，发现不等于null，就直接调用目标对象的getName()方法。

加载可以不需要事务，事务只是用在存储。

Hibernate支持三种事务：局部事务，全局事务，代理事务。

懒加载异常：

懒加载开启，创建的是代理对象，先不使用代理对象（就不会发送sql语句创建目标对象），执行commit()方法后，执行session.close()方法把session关闭。然后再使用代理对象，需要发送sql语句创建目标对象时，发现连接已经关闭，就会抛出异常LazyInitializationException：懒加载初始化异常。

Session是线程不安全的，所以用完了要马上关闭。

解决方案：

1、关闭懒加载：但是效率会大大降低

2、使用ThreadLocal

懒加载的实际应用：物料项目

1、load()方法在lazy=true的情况下查询出来的对象都是代理对象，在持久层是不会使用对象的

2、将代理对象下传到业务层（struts的Action类中）

3、在Action类中通过request.setAttribute(“item”,item);传到jsp页面

4、在jsp页面通过EL表达式输出。通过item属性名拿到对应的属性值 item代理对象。

5、发现要使用的时候就会发送sql语句创建目标对象，但是session已经关闭所以会抛出异常。

正确处理方法：

在持久层不关闭session，使用Filter来管理session的创建和关闭

Public class HibernateFileter implements Filter{}

ThreadLocal hibernateHolder=new ThreadLocal();

1、加载类创建工厂类型的静态变量（全局）

2、Tomcat一启动就创建过滤器对象，一旦创建过滤器对象就会执行该对象的init()方法

3、在init()方法中，读取Hibernate.hbm.xml文件，创建SessionFactory对象。

4、把工厂对象赋值给工厂类型的静态全局变量

5、在HibernateFilter类中，创建getSession静态方法,在此方法中得到session

public static Session getSession(){

Session session=（Session）hibernateHolder.get();//取得当前线程绑定的session

if(session==null){

session=factory.openSession();

hibernateHolder.set(session);//把session和当前线程绑定

}

return session.

}

6、持久层通过HibernateFilte类中的的静态方法 getSession()拿到session。

7、在实现Filter接口的类中，doFilter方法中：chain.doFilter()执行后对结果进行拦截，关闭session。先判断当前线程是否已经绑定session，

Session session=（Session）hibernateHolder.get();//取得当前线程绑定的session

如果绑定了，取出的session不为null，就执行判断session.isOpen()，如果为true就继续执行session.close()方法关闭session，然后再将session从map集合中移除（解除当前线程与session的绑定关系）

try {

chain.doFilter(servletRequest, servletResponse);

} finally {

Session session = (Session)hibernateHolder.get();//从Map中取出session

if (session != null) {

if (session.isOpen()) {

session.close();//关闭session

}

hibernateHolder.remove();//移除session

}

ThreadLocal类的分析：

原理：在ThreadLocal类中有一个线程安全的Map，用于存储每一个线程的变量的副本。

public class ThreadLocal{

private Map values = Collections.synchronizedMap(new HashMap());；//线程安全

}

ThreadLocal已经支持泛型，该类的类名已经变为ThreadLocal<T>

Thread thraed=Thread.currentThread();//得到当前线程对象

ThreadLocal:是线程做并发用的技术，主要方法get(),set(T),initialValue(),remove()

1、set(T):--设置到当前线程的局部变量

将当前线程和给session做绑定，线程作为key,T(session)作为value存入一个加锁的线程安全的map集合中。values.put(thread,session);

public void set(Object newValue) {

values.put(Thread.currentThread(), newValue);

}

2、T get():返回当前线程的局部变量

从线程安全的map中集合中取出线程对应的session，如果有就直接用，如果没有就创建session，再绑定到当前线程上 values.put(thread,session);

public Object get() {

Thread curThread = Thread.currentThread();

Object obj=values.get(currentThread);//先从map集合中取

if (obj == null && !values.containsKey(curThread)){//发现map集合中没有当前线程作为key对应的value，就创建再添加到map

obj = initialValue();

values.put(curThread, obj);

}

return obj;

}

3、T initialValue():---返回当前线程的局部变量的初始值

protected Object initialValue(){

return null;

}

4、remove():--移除当前线程的局部变量

map.remove(key);//根据map集合的移除元素的原则，根据key移除，

public void remove() {

values.remove(Thread.currentThread());

}

为什么一定要用线程安全的map？

多个线程并发的拿到session并发的访问数据库会造成数据混乱。线程安全的map，使得一次只能有一个线程访问数据库。并行变串行。

资源共享：

对于多线程资源共享的问题，同步机制采用了“以时间换空间”的方式，而ThreadLocal采用了“以空间换时间”的方式。前者仅提供一份变量，让不同的线程排队访问，而ThreadLocal为每一个线程都提供了一份变量，因此可以同时访问而互不影响。

Hibernate和struts的集成，使用拦截器（Filter）继承。

OpenSessionInview模式：一直开启session,直到数据输出完再关闭。

集合上的懒加载：(extra,true,false)

在<set>标签上使用，使用set标签的主要有<one-to-many><many-to-many>

<class>标签上的懒加载，不影响<set>上的懒加载。

普通属性的加载是使用类上的懒加载

关联属性是使用集合上的懒加载

1、集合上的懒加载开启lazy=true，类上的懒加载是开启的 lazy=true：

session.load(Classes.class,1);//生成的是代理对象，target=null,不会发送sql语句

classes.getName();//只发一条sql语句，访问t_classes，只给普通属性设值

Set students=classes.getStudents();//不会发送sql语句访问t_student表，说明当前students是PersistantSet（类似cglib）代理对象，不是真正存放Student对象的Set集合。

Iterator it=students.iterator();

While(it.hasNext()){

Student stu=it.next();

stu.getName();//真正使用到Set集合中的元素时才会发送sql语句访问t_student表

}

2、集合上的懒加载关闭lazy=false，类上的懒加载是开启的 lazy=true：

加载Set集合类的students属性和加载普通属性一样。

session.load(Classes.class,1);//生成的是代理对象，target=null,不会发送sql语句

classes.getName();//发送两条sql语句，访问t_classes，t_student表（后面都不发送sql语句了）

3、集合上的懒加载关闭lazy=false，类上的懒加载关闭lazy=false：

session.load(Classes.class,1);//生成的是目标对象，会发送两条sql语句，分别访问t_classes,t_student表

4、集合上的懒加载开启lazy=true，类上的懒加载关闭lazy=false：

session.load(Classes.class,1);//生成的是目标对象，会发送一条sql语句，访问t_classes表

Set students=classes.getStudents();//不会发送sql语句访问t_student表，说明当前students是PersistantSet（类似cglib）代理对象，不是真正存放Student对象的Set集合。

Iterator it=students.iterator();

While(it.hasNext()){

Student stu=it.next();

stu.getName();//真正使用到Set集合中的元素时才会发送sql语句访问t_student表

}

5、集合上的懒加载lazy=extra，类上的懒加载关闭lazy=true：

session.load(Classes.class,1);//生成的是代理对象，不会发送sql语句，

classes.getName();//会发一条sql语句，访问t_classes表

Set students=classes.getStudents();//不会发送sql语句访问t_student表，说明当前students是PersistantSet（类似cglib）代理对象，不是真正存放Student对象的Set集合。

students.size();//这时候会使用函数从数据库中查询数据，select count(*)form t_student where classesid=1；，如果集合上的lazy为true，就会先发送select *from student where classesid=1语句，查询数据库中的所有记录，再计算出记录的条数。

Iterator it=students.iterator();

While(it.hasNext()){

Student stu=it.next();

stu.getName();//真正使用到Set集合中的元素时才会发送sql语句访问t_student表

}

lazy=true和lazy=extra的功能差不多，但是extra更加智能，它会根据用户的的条件发送比较智能的sql语句。

单端上的懒加载：（proxy,false,no-proxy）

一般用在<many-to-one><one-to-one>标签上面

默认为lazy=”proxy”，开启状态

<many-to-one name=”group” lazy=”proxy”>

主要是在加载group（关联）属性的时候有用，

1、单端上的懒加载开启lazy=proxy，类上的懒加载是开启的 lazy=true：

session.load(User.class,1);//生成的是代理对象，target=null,不会发送sql语句

user.getName();//发送sql语句，访问t_user表

Group group=user.getGroup();//拿到的而是Group的代理对象

Group.getName();发送sql语句访问t_group.

2、单端上的懒加载关闭lazy=false，类上的懒加载关闭 lazy=false：

session.load(User.class,1);//发送两条sql语句，访问t_user和t_group

user.getName();

Group group=user.getGroup();

Group.getName();

3、单端上的懒加载开启lazy=proxy，类上的懒加载关闭lazy=false：

session.load(User.class,1);//发送一条sql语句，只访问t_user

user.getName();

Group group=user.getGroup();//不会发送sql语句，group为代理对象

Group.getName();//发送sql语句访问t_group

4、单端上的懒加载开启lazy=no-proxy，类上的懒加载关闭lazy=false：

session.load(User.class,1);//发送一条sql语句，只访问t_user

user.getName();

Group group=user.getGroup();//不会发送sql语句，group为代理对象

Group.getName();//发送sql语句访问t_group

Lazy的取值为proxy和no-proxy功能和性能上都没有很大的区别：

proxy:做懒加载是使用cglib代理，no-proxy使用的是增强的字节码工具，在字节码生成的时候增加了懒加载策略。

今天的任务：

将老师讲的案例自己写一遍（懒加载） *

晚上投简历 *

做>=1道算法题 *

查看hibernate源码

Session_Flush

Session_flush的作用：

1、清理缓存（清理session临时集合中的数据）

2、生成sql语句（发送sql）

3、将session的persistanceContext中的map->existsInDatabase的标记置为true。

Flush:用在存储上。

主键生成策略为uuid（session.flush()的特点）

session.save(user)前—>> 对象处于瞬时态。

执行save(user)方法后，一般不会发送sql语句，因为主键是由hibernate自动生成。

session.save(user)后-->> 对象处于持久态。existsInDatabase=false

session.flush();//主要做了以下三件事：

1、清理缓存（清理session临时集合中的数据）

2、生成sql语句（发送sql）

3、将session的persistanceContext中的map->existsInDatabase的标记置为true

数据库中会有相应记录，但是会看不到。（因为是脏数据：没有提交的数据）

session.commit();

1、 执行commit()方法的时候会执行flush()方法，所以可以不显示的写出flush()方法。

2、就算是显示写了flush()方法，commit()的时候还是会再执行一次flush()

3、执行flush()方法的步骤：

3.1、 先判断临时集合中有没有数据

3.2、 如果没有的话就直接commit().

3.3、 如果临时集合中有数据的话就发送sql语句再清空临时集合中的数据，并且将existsInDatabase标记置为true，然后再执行commit()

主键生成策略为native（session.flush()的特点）

session.save(user)前—>> 对象处于瞬时态。

执行save(user)方法后，一般会发送sql语句，因为主键是由数据库自动生成。

session.save(user)后-->> 对象处于持久态。existsInDatabase=true

session.flush();//这时候flush()什么都不做，因为临时集合中没有数据，sql语句已经发送，existsInDatabase=true。

session.commit();//会再次执行flush()方法，依旧什么都不做。commit()方法对提交到数据库的数据做验证，成功就添加到数据库，不成功就回滚。

主键生成策略为uuid(session.evict()的特点)

session.save(user)前—>> 对象处于瞬时态。

执行save(user)方法后，一般不会发送sql语句，因为主键是由hibernate自动生成。

session.save(user)后-->> 对象处于持久态临时集合中有数据existsInDatabase=false

session.evict(user);//将user对象从session-- >> persistanceContext下的map中逐出。临时集合中依旧有数据.

session.commit();//抛出异常，(persistanceContext下的map)EntityEntries属性中的table中的数据不存在，找不到数据，无法提交数据。（缓存使用不当）

产生异常的原因：

主键生成策略为uuid

session.save(user);//在临时集合中有数据，session的map中有数据，existsInDatabase=true,loadedState中存放了user对象

session.evict(user);// 把user从map中逐出（session缓存），为了管理缓存

然后临时集合中有数据，但是map中没有数据

执行commit()方法前会先调用session.flush()，做以下三步操作：

从临时集合中拿到数据，清空临时数据
发送sql语句
3. 将map下的existsInDatabase的标记置为true，但是user的map已经被清除，找不到map也找不到map里面的existsInDatabase标记，就会抛出异常。

解决办法：(调用session.evict(user)以前先显示调用session.flush())

session.save(user);

显示的写flush方法

先session.flush();//根据临时集合中的数据发送sql语句，然后清空临时集合，到session缓存中将existsInDatabase标记置为true。

再session.evict(user);//将user对象从session缓存的map集合中移除

最后session.commit();//这时候依旧会执行session.flush()方法，但是不会抛出异常，因为flush()方法，是先查看临时集合中有没有数据，发现临时集合是空的没有数据就不会发送sql语句，也不用再次清空临时集合，也不需要将existsInDatabase标记置为true；直接执行commit()方法。

主键生成策略为native（session.evict()方法的特点）

session.save(user)前—>> 对象处于瞬时态。

执行save(user)方法后，一般会发送sql语句，因为主键是由数据库自动生成。

session.save(user)后-->> 对象处于持久态。临时集合中没有数据。existsInDatabase=true

session.evict(user);//自动把数据从session缓存的map中逐出

session.commit();//执行flush()方法，但是由于主键生成策略为native,临时集合中已经没有数据了，就不要用发送sql语句也不用将existsInDatabase标记置为true了。直接执行commit()方法。 commit()方法对提交到数据库的数据做验证，成功就添加到数据库，不成功就回滚。这里不会抛出异常，因为这里的flush()方法什么都不用做。

主键生成策略为assigned(session.evict()的特点)

session.save(user)前—>> 对象处于瞬时态。

执行save(user)方法后，一般不会发送sql语句，因为主键是由用户手动生成。

session.save(user)后-->> 对象处于持久态。existsInDatabase=false,临时集合中有数据。

session.evict(user);//自动把数据从缓存中逐出

session.commit();//不管assinged知道的主标识类型是int还是String，执行session.evict(user)后执行session.commit()一定会抛出异常

解决办法，在调用sessionn.evict(user)方法前显示的调用session.flush()

Sql语句在数据库中的执行顺序：

发送sql语句的顺序：

创建两个对象 user,user1;

session.save(user);

user.setName(“ls”);

session.save(user1);

session.commit();

先发送insert into user () 存储的对象是user

再发送 insert into user() 存储的对象是user1

再发送 update user set name=ls 更新的对象是 user

可以使用flush()方法调整语句的发送顺序

创建两个对象 user,user1;

session.save(user);

user.setName(“ls”);

session.flush();

session.save(user1);

session.commit();

先发送insert into user ()存储的对象是 user

再发送 update user set name=ls user(因为flush()方法)

再发送 insert into user()存储的对象是 user1

悲观锁和乐观锁：

1、为什么要加锁？

在数据库中不加锁会丢失更新

原因：用户同时访问数据库，查看的数据相同，一方对数据做了修改但是另一方不知道，所以就在原来的数据上修改。就数据不一样。

不能并发的访问数据库中的数据，不然数据库会崩溃的哦

保证数据库的安全，并行变串行

悲观锁：（悲观锁不支持懒加载）

测试示例：

两个方法串行执行：（load1()，load2()）money=1000

1、load1();---- session.load(Test.class,1)；

2、Debugà 查完数据后修改数据库中的值 money-200但是不执行commit()方法

3、执行另一个查询方法load2()-----ssession.load(Test.class,1);

4、修改数据 money-200并且一次执行完.

5、再接着执行第一个方法，commit()。更新后数据库中的数据就是错误的。最后结果为money=800。更新丢失

session.load(Test.class,1,LockMode.UPGRADE);//悲观锁，使用数据库自身的锁

LockMode.UPGRADE//利用数据库的for update 子句加锁—---记录锁（会出现幻读）

锁的分类：记录锁，表锁，库锁

记录锁：只给当前查询出来的记录加锁，其他记录依旧没有变化

加悲观锁后的示例：（悲观锁中懒加载自动失效，load方法执行后就会发送sql语句）

两个方法串行执行：（load1()，load2()）money=1000

1、load1();---- session.load(Test.class,1,LockMode.UPGRADE);//马上发sql语句查询

2、使用debug调试à 查看记录money=1000,然后修改数据库中该记录的的money字段, ，money=money-200但是不执行commit()方法

3、执行另一个查询方法load2()-----ssession.load(Test.class,1,LockMode.UPGRADE); //发送sql语句查询的时候发现查不出来数据。id=1的记录已经被上了锁。

4、修改数据 money值，money=money-200，执行commit()方法，会停留在记录外面，查询不出来记录，因为前面已经上了锁，要等前面那个锁释放才可以访问那条记录。

5、再接着执行第一个方法，commit()。更新后数据库中的数据money=800;

6、这时候load2()方法执行，查询出来的数据money=800,之后才能对记录做修改。

悲观锁中的记录锁的特点：避免了不可重复读，但是存在幻读。（效率低）

乐观锁：（乐观锁支持懒加载）

表中必须添加一个版本控制字段version，version默认值为0，用户读到的记录是一样的 version和money。version在User类中定义为 private int version;

version在映射文件中使用<version>标签配置,version是版本控制字段，由Hibernate自动管理。

<version name=”version”/>:标识对乐观锁的控制

Load1()方法（debug调试，执行commit()方法以前的代码）

User user=（User）session.load(User.class,1);//不会发送sql语句，生成代理对象

int money= user.getMoney();//使用到对象方法时发送sql语句（select * from user where id=1 and version=0），

user.setMoney(money-200);

user.setVersion(1); //查询出数据后，修改表中记录的值money = money-200;version=1。

session.update(user);//发送update语句，update user set money=money-200 and version=1 where id=1 and version=0;

暂不执行session.commit()这条语句。

Load2()方法（一次性执行完）

User user1=（User）session.load(User.class,1);//不会发送sql语句，生成代理对象

int money= user.getMoney();//使用到对象方法时发送sql语句（select * from user where id=1 and version=0），

user.setMoney(money-200);

user.setVersion(1); //查询出数据后，修改表中记录的值money = money-200;version=1。

session.update(user);//发送update语句，update user set money=money-200 and version=1 where id=1 and version=0;

执行session.commit()方法。修改数据库中id=1对应的记录

再继续执行load1()方法中的session.commit()语句，发送sql语句update user set money=money-200 and version=1 where id=1 and version=0;

但是版本号version的值已经改成1，所以commit()的时候就会抛出异常。

事物的隔离级别：

1、未提交读：没有提交就能在数据库中读到数据

2、可提交读：提交后才能在数据库中读到数据，解决不可重复读的方法是加悲观锁。（mysql和oracle的默认处理级别）

3、可重复读：加了悲观锁（记录锁）

4、序列化读：不会出现幻读，加表锁（不会出现幻读，不会出现脏读，也不会出现不可重复读）

5、脏读：读取未提交到数据库中数据。

6、不可重复读：读取数据时，如果有人修改了数据就发现不是原来的数据，会出错（加悲观锁解决问题）

7、幻读：每次读取数据的时候读取到的记录数一直在变化（解决方法应该加表锁）

安全性强的使用使用悲观锁

并发性强的时候使用乐观锁

缓存

缓存的分类：

一级缓存：session级别，生存周期和session一样

session.save(obj);将数据纳入session管理。load()和get(),iterator()方法都使用一级缓存。如果iterator()方法使用不当就会造成n+1问题。

Query 的list()方法不使用一级缓存，但是往一级缓存中放数据。（可能有n+1问题）

二级缓存：sessionFactory级别，工厂不会轻易销毁，一般只创建一次。放到二级缓存中的数据特点：查询次数频繁，但是修改次数少

二级缓存：一级缓存可以控制对二级缓存的使用。get(),save(),load() 既要往一级缓存中存数据，也要往二级缓存中存数据。

查询缓存：为了提高Query list的查找效率

一级缓存和二级缓存主要是缓存实体对象，不会缓存属性

查询缓存只缓存实体属性

一级缓存：（load，get，list，iterator都支持一级缓存）

直接查询load()或者get()：

Session级别的缓存，一般不需要配置也不需要专门的管理，直接使用就可以了。

Student stu=(Student)session.load(Student.class,1);

stu.getName();//先从一级缓存session中查看有没有id=1的Student对象，有的话就直接使用，没有的话就发sql语句访问数据库根据记录生成对象再使用。<load支持一级缓存>

stu.getSex();//再次使用Student对象的时候，先从一级缓存session中查有没有该对象，发现有就直接使用，不再创建了。

Student stu1=(Student)session.get (Student.class,1);//这里也不会发送sql语句，因为一级缓存中有id=1的Student对象，所以直接使用。<get()也支持一级缓存>

先save后查询get()或者load()，查到的是save()过的数据

主键生成策略为：native

Student stu=new Student();

stu.setName(“ls”);

stu.setSex(“male”);

Serializable id=session.save(stu);//save()方法的返回值是Integer类型的数据。得到的id是对象的主标识。这里save()后Student对象纳入session管理，进入缓存。

Serializable：序列化接口，String ,Integer都支持序列化协议。

Student stu1=(Student)session.get(Student.class,1);//这里不会发送sql语句，因为先从缓存中查找数据，发现有id=1的Student对象，就直接使用。

缺点：可能会读到脏数据。

Query的iterate()方法

Student stu1=(Student)session.createQuery(“from Student s where s.id=1”).iterate().//执行到iterator()方法才会发送sql语句

1、 通过id先从数据库中查对象的id(select id from t_stu where id=1)

2、 根据id到session中查对象

3、 如果没有就再发sql语句访问数据库 (select* from t_stu where id=1)

Student stu2=(Student)session.createQuery(“from Student s where s.id=1”).iterate().//再执行一次，还是会发查询id的sql语句(select id from t_stu where id=1)

然后发现session中有对象，就不发sql语句(select* from t_stu where id=1)了，直接从session中拿到对象使用。

N+1问题：(iterator()缓存使用不当)

session.createQuery(“from Student ).iterate();

1、 先发一条sql语句取出所有的id（select id from t_stu）

2、 查询session中有没有id对应的对象

3、 根据id依次发送sql语句访问数据库(select * from t_stu)，数据库中有多少条记录就会发送多少条sql语句，如果数据库中的记录特别的多，这里就会出现数据库访问拥塞，效率下降，造成n+1问题。

session.createQuery(“from Student ).iterate();//再查一次，这里会先发sql语句查id,然后发现以及缓存session中有id对应的对象，就直接使用。不会再发送sql语句访问数据库了。

list()方法:只会往一级缓存中放数据，不会从一级缓存中取数据

List stus=session.createQuery(“from Student”).list();//直接发sql语句访问数据库，不会先查id，一次性直接把数据库中的所有记录放到一级缓存session中

Stus= session.createQuery(“from Student”).list();//list()只放不拿，还是会再次发送sql语句访问数据库,查出所有记录放到session中。

N=1问题的解决方法：

第一次使用list()，第二次使用iterator()方法

1、 list()先把从数据库中查询出所有数据放到一级缓存session中

2、再使用iterator()方法使用一级缓存session中的数据

3、 iterator()会先发送sql语句查所有的id,然后去一级缓存session中查找id分别对应的对象

4、发现对象已经存在一级缓存session中就直接使用。不会再发送多条sql语句访问数据库了。这样就只发送了两条sql语句，解决了N+1问题。

一级缓存的管理：（evict()，clear()，close()）

使用flush()清除session中的缓存

session.flush();//清除临时集合中的数据

session.clear();//清除persistanceContext下的map中的数据

一定要先flush()，然后再clear()，不然可能会产生异常

session.evict(user);//清除一条

session.clear();//清除多条数据

clear()和evict()的区别：clear()方法清除多条，evict()只能清除一条。

一级缓存只缓存对象，不缓存对象的属性。

如果sql语句查询的结果是记录（一条或者多条），就会根据记录生成对象（一个或多个）放到一级缓存session中。

如果sql语句查询的结果是记录的字段，就不会把字段映射成属性放入一级缓存session中了。

一级缓存里面的数据不能共享：session关闭后所有数据都销毁。

Hibernate的缺点：Hibernate不会保证批量数据的同步，只能保证单条数据的同步。

二级缓存：（缓存的内容是对象，load，get，save都支持一级缓存）

二级缓存只有一个，生成周期很长，和SessionFactory的生命周期一样。

缓存策略的作用是： 提供对缓存的方式

Hibernate一般使用Hcache这种缓存策略。

二级缓存的配置：

1、准备缓存策略的配置文件，在配置文件中写缓存策略

在ehcache.xml中配置缓存策略：（配置在src下）

默认的缓存策略：

<defaultCache

maxElementsInMemeory=”10000”//缓存的最大空间

eternal=”false”//设置没有任何对象常驻二级缓存中

timeToldleSeconds=”120”//如果120秒不使用就移除缓存

timeToLiveSeconds=”120”//最多能在二级缓存中呆120秒

overflowToDisk=”true”//如果缓冲存的数据超过10000，就将数据存到硬盘中

配置指定的缓存策略：

<cache name=”cache1”

maxElementsInMemeory=”10000”//缓存的最大空间

eternal=”true”//设置所有对象都常驻二级缓存中

timeToldleSeconds=” 0”//不管多长时间没有使用都不会移除缓存

timeToLiveSeconds=” 0” //不管使用多长时间都不会移除缓存

overflowToDisk=”false”//溢出的时候不支持将数据存到硬盘上

二级缓存通过缓存策略设定缓存中能存放多少个对象，存放多久，有多长的生存时间。

2、在Hibernate.cfg.xml文件中配置哪个类的对象来管理二级缓存

<property name="hibernate.cache.provider_class"> org.hibernate.cache.EhCacheProvider</property>

org.hibernate.cache. EhCacheProvider：创建sessionFactory时，读取Hibernate.cfg.xml文件，创建EhCacheProvider对象。通过插件执行对象的相应的方法--init(),读取ehcache.xml配置文件。通过读取ehcache.xml配置文件对缓存进行管理。

3、配置哪些对象使用二级缓存

<class-cache class=”cn.Student” usage=”read-only”/>

4、指定使用二级缓存使用对象的使用方式

也可以在实体类的hbm.xml文件中配置 <cache usage=”read-only”/>

缓存策略的集中方式：read-only(常用)read-write , nonstrict-read-write

5、 开启二级缓存：

二级缓存的使用：（只存放配置了的对象，get,load,save）

load()方法的二级缓存解析：

Student stu=(Student)session.load(Student.class,1);

Stu.getName();//发送sql语句从数据库中拿到id=1的记录生成对象，存入二级缓存也会存入一级缓存中。

Session.close();//关闭session，一级缓存中的数据被清空

Student stu=(Student)session.load(Student.class,1);

Stu.getName();再次访问时，先从一级缓存session中查看有没有对象，没有再从二级缓存中查，发现有就直接使用。

get()方法的二级缓存解析：

Student stu=(Student)session.get(Student.class,1); //发送sql语句从数据库中拿到id=1的记录生成对象，存入二级缓存也会存入一级缓存中

stu.getName();

session.close();//关闭session，一级缓存中的数据被清空

Student stu=(Student)session.get(Student.class,1); 再次访问时，先从一级缓存session中查看有没有对象，没有再从二级缓存中查，发现有就直接使用。

stu.getName();

结论：在二级缓存开启的状态下，load()和get()不仅使用一级缓存，还会使用二级缓存。

二级缓存的管理：（没有临时集合，基本上都是map）

Student stu=(Student)session.get(Student.class,1); //发送sql语句从数据库中拿到id=1的记录生成对象，存入二级缓存也会存入一级缓存中

stu.getName()

session.close();//关闭session

factory =HibernateUtils.getSessionFactory();//拿到sessionFactory对象

factory.evict(Student.class);//清除二级缓存中的所有Student对象

factory.evict(Student.class,1);//只把二级缓存中id=1的Student对象

Student stu=(Student)session.get(Student.class,1); //再次发送sql语句从数据库中拿到id=1的记录生成对象，存入二级缓存也会存入一级缓存中（因为一级缓存和二级缓存中的数据都被清空了）

SessionFactory的作用：

1、创建Session对象

2、管理二级缓存

一级缓存和二级缓存的交互：

（一级缓存可以控制如何使用二级缓存）

1、设定二级缓存只能读不能写

session.setCacheMode(CacheMode.GET);//设定仅从二级缓存中读数据，而不向二级缓存中写数据

Student stu=(Student)session.get(Student.class,1); //发送sql语句从数据库中拿到id=1的记录生成对象，只将数据存入一级缓存中。

stu.getName()

session.close();//关闭一级缓存，这时候一级缓存和二级缓存中都没有数据，下一次使用对象时，会发送sql语句。

2、设定对二级缓存不做任何约束

Student stu=(Student)session.get(Student.class,1); //发送sql语句从数据库中拿到id=1的记录生成对象，将数据存入一级缓存和二级缓存中。

stu.getName()

session.close();//关闭一级缓存，这时候一级缓存没有数据，二级缓存中有数据

3、设定二级缓存只能写不能读

session.setCacheMode(CacheMode.PUT); //设定只往二级缓存中写数据，但是不能读取二级缓存中的数据。

Student stu=(Student)session.get(Student.class,1); //虽然二级缓存中有数据，但是因为二级缓存中的数据不能读取，所以要发送sql语句从数据库中拿到id=1的记录生成对象，将数据存入一级缓存和二级缓存中。

Stu.getName();

Session.close();/关闭session，一级缓存中的数据被清空。二级缓存中的数据还在。

4、设定对二级缓存不做任何约束

Student stu=(Student)session.get(Student.class,1); //不会发送sql语句，因为二级缓存中有数据，可以读取。

Stu.getName();

Session.close();/关闭session，一级缓存始终都没有数据，二级缓存中的数据依旧在。

查询缓存：（只能缓存属性，不能缓存对象，只有list可以使用查询缓存）

list通过查询缓存使用二级缓存

查询缓存的配置：（不需要配置缓存策略）

1、在Hibernate.cfg.xml中配置开启查询缓存：（二级和查询缓存都开启 true）

2、在使用查询缓存前要启动查询缓存

query.setCacheable(true);

1、 开启查询缓存（true），关闭二级缓存(false) 使用list()方法

Query query=session.createQuery(“select s.name form Student s);//查出所有的name属性对应的字段

query.setCacheable(true);//启动查询缓存

List name=query.list();//发送sql语句，将查到的name属性放到查询缓存中

Query query=session.createQuery(“select s.name form Student s);//查出所有的name属性对应的字段

query.setCacheable(true);//启动查询缓存,查询缓存配置后也是默认开启的

List name=query.list();//不会再发送sql语句，因为list()方法使用了查询缓存，查询缓存中已经有数据

结论：查询缓存，值缓存属性，不缓存对象；只有list()方法能使用查询缓存

2、 查询缓存不受一级缓存的影响

3、 开启查询缓存（true），关闭二级缓存(false) 使用iterate()方法

Query query=session.createQuery(“select s.name form Student s);//查出所有的name属性对应的字段

query.setCacheable(true);//启动查询缓存

List name=query.iterate();//发送sql语句，因为是iterate()方法，不能使用查询缓存，所以无法将查到的name属性放到查询缓存中

Query query=session.createQuery(“select s.name form Student s);//查出所有的name属性对应的字段

query.setCacheable(true);//启动查询缓存

List name=query.iterator();//还是再次发送sql语句，因为iterator()方法不能使用查询缓存，查询缓存中没有数据

结论：iterator()不使用查询缓存。

4、 关闭查询缓存（false），关闭二级缓存(false) 使用list()方法

Query query=session.createQuery(“select s form Student s);//查出所有的Student对象

查询两次，查询完后关闭session，第二次查询依旧会发送sql语句

5、 开启查询缓存（true），关闭二级缓存(false) 使用list()方法

Query query=session.createQuery(“select s form Student s);//查出所有的Student对象

query.setCacheable(true);//启动查询缓存

List stus=query.list();//查出的所有对象都存入一级缓存中，查出所有对象的id放入查询缓存中。

Session.close();//关闭session，一级缓存中的数据被清空

Query query=session.createQuery(“select s form Student s);//查出所有的Student对象

query.setCacheable(true);//启动查询缓存

List stus=query.list();//先到查询缓存中查看存放的所有对象的id，再到二级缓存中找id分别对应的对象，但是二级缓存已经关闭，所有查询缓存会发送sql语句：slelect * from t_stu where id= id;有多个id就会发送多少条语句。这样就会造成数据库访问拥塞，N+1问题。

6、 开启查询缓存（true），开启二级缓存(true) 使用list()方法

就不会出现N+1问题，因为开启二级缓存，二级缓存中就会有数据，直接使用就可以了，不用再次发sql语句访问数据库拿到记录生成对象。

N+1问题：

iterator()是对一级缓存使用不当，造成N+1问题

list()是对二级缓存的使用不当，造成N+1问题。

结论：Query的list方法不能使用一级缓存，可以使用二级缓存，但是要开启查询缓存才有用。

Iterate()也会使用二级缓存。

注意：

list()方法：直接取出所有对象

iterate()方法：先取出所有的记录的id，再根据id到一级缓存中查看有没有对应的对象，没有的话就发送sql语句访问数据库拿到记录生成对象。查询出了对少个id就发送多少条sql语句。

今天的任务：

将缓存示例写一遍（尤其是二级缓存和查询缓存）

写>=1道算法题

看python文档

复习一遍Hibernate

Lunix的指令

数据结构，算法

Hibernate查询语句:hql

hibernate的查询语言种类：

1、 标准化对象查询（Criteria Query）:完全面向对象但是不够成熟，不支持投影也不支持统计函数。

2、 原生的sql查询语句(Native SQL Queries) :直接使用标准SQL语言和特定的数据库相关联的sql进行查询。<和数据库耦合性太强>

3、 Hibernate查询语言（Hibernate Query Language HQL）

使用sql的语法，以面向对象的思想完成对数据库的查询，独立于任何数据库

以类和属性来代替表和数据列

支持多态，支持各种各样关联

减少了SQL的冗余, hql:不区分大小写

Hql支持的数据库操作：

连接（joins），笛卡尔积(cartesian products)，投影(projection)，聚合(max,avg)，排序(ordering)，子查询(subquering)，sql函数,分页

HQL导航查询示例：

Query query=session.createQuery(“from User user where user.group.name=’zte’ ”);

//查找User类对象的属性group,group属性所属的类型Group对象的name

相当于sql语句：

select * from t_user ,t_group where t_group.name=’zte’ and t_group.id =t_user.groupid;

randomDate(“2017-1-1”,”2017-2-9”);//随机生成一个“2017-1-1”,”2017-2-9”之间的日期

两个或者两个以上的普通属性查询

使用Object[]数组接收查询出来的属性

List students=session.createQuery(“select id ,name from Student”).list();

Iterator it=students.iterator();

While(it.hasNext()){

Object[] obj=(Object) it.next();

System.out.println(obj[0]+”---”+obj[1]);

}

先创建一个Object类型的数组对象Object[]

Object[]数组的长度和查询的属性的个数相同，一 一对应，obj[0]存放从数据库中取出来的id值，obj[1]存放从数据库中取出的name值。

Object[]数组元素的类型和Student实体类的属性类型一 一对应。

List集合students中存放的元素是Object[]类型的数据，查询出来多少条记录就有多少个元素，有多少个Object[]数组。

使用Object[]数组接收查询出来的属性(添加别名，更加清晰)

List students=session.createQuery(“select s.id ,s.name from Student （as） s”).list(); //as可以省略也可以显示的写出来

Iterator it=students.iterator();

While(it.hasNext()){

Object[] obj=(Object) it.next();

System.out.println(obj[0]+”---”+obj[1]);

}

把从数据库查到的记录生成对象，再查出id和name属性（不建议使用）

List students=session.createQuery(“select new Student( id ,name) from Student”).list();//自动调用Student类的有参的构造方法，创建Student对象

Iterator it=students.iterator();

While(it.hasNext()){

Student stu=(Student) it.next();

System.out.println(stu.getId()+”---”+stu.getName());

}

实体对象的查询：（Select 查找对象 不能使用*）error: unexpected token *

List students=session.createQuery(“from Student”).list();//正确

List students1=session.createQuery(“from Student s”).list();//正确

List students2=session.createQuery(“select * from Student”).list();//这是错误的

List students3=session.createQuery(“select s from Student as s”).list();//这才是正确的,as可以省略

Iterator it=students.iterator();

While(it.hasNext()){

Student stu=(Student) it.next();

System.out.println(stu.getId()+”---”+stu.getName());

}

条件查询：

1、写定查询条件

List students=session.createQuery(“select s.id,s.name from Student s where s.name like ‘%1%’ ”).list();//查询出所有名字包含1的学生id和name

2、使用填充符，动态查询条件

List students=session.createQuery(“select s from Student s where s.name like ？”).setParameter(0,”%1%”).list();

3、使用参数，把条件设到参数中

List students=session.createQuery(“select s from Student s where s.name like :myname ”).setParameter(“myname”,”%1%”).list();

4、使用多个参数，把多个条件分别设到参数中

List students=session.createQuery(“select s from Student s where s.name like :myname and s.id= : myid ”).setParameter(“myname”,”%1%”). setParameter(“myid”,1).list();

参数顺序不一样没有关系。只和参数名有关。

5、使用一个参数，把多个条件设到一个参数中（setParameterList）

List students=session.createQuery(“select s from Student s where s.id in (:myids )”).setParameterList(“myids”,new Object[]{1,2,3}).list();

使用参数数组对象，查询出id 为1 ，2，或者3的学生对象

6、日期类型数据作为条件的查询（使用数据库中的date_format()函数）

List students=session.createQuery(“select s from Student s where date_format(s.createTime,’%Y-%m’)=?”).setParameter (0,”2017-2”).list();

先把字符串转换为日期类型

再把日期和数据库中日期做比较

6、日期类型数据作为条件的查询（使用自定义的日期转换函数 sdf.parse()）

SimpleDateFormat sdf=new SimpleDateFormat(“yyyy-MM-dd HH:mm:ss”);

List students=session.createQuery(“select s from Student s where sdf.parse (s.createTime,’%Y-%m’)=?”).setParameter (0,”2017-2-12 11:22:11”).list();

先把字符串转换为日期类型

再把日期和数据库中日期做比较

如果非要使用select *语句就要使用原生的sql语句

List students=session.createSQLQuery(“select * from Student).list();

分页查询：

List students=session.createQuery(“select s from Student s )

.setFirstResult(5)//查询从第五条记录开始的数据（(pageNo-1）*pageSize）

.setMaxResult(2)//每页最多显示两条(pageSize)

.list();

对象导航查询：

List students=session.createQuery(“select s.name from Student s where s.classes.name like ‘%1%’ “).list();

连接查询：

内连接

List students=session.createQuery(“select s.name ，c.name from Student s join s.classes c”).list();//通过学生类的关联属性把学生类和班级类做内连接。（找出既有学生又有班级的记录）

外连接：

左连接：

List students=session.createQuery(“select s.name ，c.name from Classes c left join c.student s”).list();拿到有学生的班以及没有学生的班级（班级全部显示，学生只显示有班级的）

右连接：

List students=session.createQuery(“select s.name ，c.name from Classes c right join c.students s”).list();拿到有学生的班以及没有班级的学生（学生全部显示，班级只显示有学生的）

分组查询：

List students=session.createQuery(“select s.name ，count(*) from Classes c left join c.Student s group by s.name order by s.name”).list();

查询过滤器：

使用场合:要求数据录入人员只能看到自己录入的数据时 ---使用查询过滤器

使用条件：

在Student.hbm.xml映射文件中定义过滤器参数：

<filter-def name=”filtertest”>//查询过滤器的名字

<filter-param name=”myid” type=”integer”/>//参数名 参数类型为integer

</filter-def>

使用步骤：(先在Student.hbm.xml文件中)

<filter name=”filtertest” condition=”id < :myid”/>//condition配置条件,id< myid(参数)

在查询方法中：session.enableFilter(“filtertest”) .setParameter(“myid”,10)；//启用查询过滤器，并且设定参数。表示查询id<10的数据记录。

外置命名查询：

在Student.hbm.xml映射文件中采用<query>标签来定义hql:

<![CDATA[SELECT s FROM Student s where s.id<?]]>

</query>

List students=session.getNameQuery(“searchStudents”).setParameter(0,5).list();//安全性比较差，显示写出sql语句在配置文件中，容易被黑。

DML风格：（批量更新，批量操作）和缓存不同步

session.createQuery(“update Student s set s.name=? where s.id<?”)

.setParameter(0,”小仙女”)//更新name都为小仙女

.setParameter(1,5)//id<5的记录都被更新

.executeUpdate();

Hibernate的缺点：不支持批量更新，不是说不能批量更新，而是批量更新的操作不能保证缓存中的数据和数据库中的数据同步。

Struts1和Hibernate的集成：

1、创建web项目

2、导入两个框架的jar包以及jstl的jar包—--WEB-INF/lib

3、在src下存放国际化资源文件

4、在web.xml中配置struts1.0 <ActionServlet>,配置编码过滤器

5、配置struts-config.xml（通常用DispatchAction），放在WEB-INF下

6、在src下配置hibernate.cfg.xml,log4j.properties

7、在web.xml文件中配置HibernateFilter,一启动就创建SessionFactory

8、也可以在struts-config.xml文件中使用插件配置Hibernate的启动，但是建议在Filter中配置，因为filter还要处理openSessionInview问题。

9、模型层：包括实体类和类对应的*hbm.xml文件.

posted on 2018-03-09 17:43 阿叮339 阅读(543) 评论(0) 编辑收藏举报

刷新页面返回顶部

Hibernate

Many-to-one

One-to-one：（一对一）

one-to-many

Many-to-many：（多对多）

单表继承映射

多表继承映射：

懒加载（Lazy）

Session_Flush

悲观锁和乐观锁：

缓存

Hibernate查询语句:hql

公告