many-to-many和lazy

Many-to-many（user--->role）
对象模型：

两者关联需要一个中间表
类的设计
Role：
public class Role {
private int id;
private String name;
}
其对应的映射文件，由于这一段不维护关系，所以都是普通属性
<hibernate-mapping>
<class name="com.itcast.hibernate.Role" table="t_role">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
</class>
</hibernate-mapping>

User类的设计：
public class User {
private int id;
private String name;
private Set roles;
}
注意这里的映射文件：

<hibernate-mapping>
<class name="com.itcast.hibernate.User" table="t_user">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>

table="t_user_role"：指明生成中间表的名字
<set name="roles" table="t_user_role">
column="userid"指明本表主键映射到中间表以后的字段
<key column="userid"/>
class="com.itcast.hibernate.Role" column="roleid"：指明自己内部set中所存放的类型和保存到中间表的字段名
<many-to-many class="com.itcast.hibernate.Role" column="roleid"/>
</set>

</class>
</hibernate-mapping>

如果想把刚才的映射改成双向的，其实数据库中存储结构不会发生任何变化，只是在Role对象中加一个Set集合保存所有对应的user就可以了。

和前面相比，只有Role的类中加了一个
private Set users;
其对应的映射文件，注意：Role的映射文件中的Set标签中的内容和User中的Set标签中的内容有很多必须对应，这里把两个放在一起对比，颜色相同的就是必须相同的


Role中的
<set name="users" table="t_user_role" order-by="userid">
<key column="roleid"/>
<many-to-many class="com.itcast.hibernate.User" column="userid"/>
</set>
User中的
<set name="roles" table="t_user_role">
<key column="userid"/>
<many-to-many class="com.itcast.hibernate.Role" column="roleid"/>
</set>


懒加载
Lazy:只有在真正使用的时候才会创建对象或者发出sql语句

hibernate lazy策略可以使用在：
<class>标签上，可以取值：true/false,,3.0以后的版本都是默认为true
<property>标签上，可以取值：true/false需要类增强工具，使用较少
<set><list>等集合标签上，可以取值：true/false/extra
<one-to-one><many-to-one>单端关联上，可以取值：false/proxy/noproxy

lazy概念：只有真正使用该对象时，才会创建，对于hibernate而言，正真使用的时候才会发出sql

hibernate支持lazy策略只有在session打开状态下有效，lazy的生命周期和session一样
Session一旦关闭，再调用lzay控制的类，就会发生lazy的初始化异常。

<class>标签上的lazy特性只对普通属性起作用

hibernate在集合上的lazy策略，可以取值：true/false/extra
<class>标签上的lazy不会影响到集合上的lazy特性

hibernate在单端关联上的lazy策略，可以取值：false/proxy/noproxy
Proxy:代理，也就是使用代理实现lazy
Noproxy：不使用代理实现lazy，通过修改class的字节码来实现。这个需要增强工具，基本很少使用


继承映射的概念和继承映射中的lazy
对于继承映射，Hibernate会处理子类父类间的关系，这个时候需要处理多态的问题。
Load 支持Lazy延迟加载，返回的是一个代理对象，这个代理类是持久化的类的子类。比如animal类有子类pig和bird。当我们加载animal的时候，实际返回的是animal的代理类，而Hibernate生成代理的方式是通过继承真实类的方式。所以这个代理类和pig和bird类是平级的，都是 animal的子类。所以instanceof方法在这里是不可行的，无法反应出真正的对象类型。
也就是Load的默认方式（lazy加载）是不支持多态查询的。

多态查询：在habernate加载对象的时候可以鉴别出真正的类型。
如果把<class>标签上的lazy设置为false。这样就不会有那个代理类，也就可以支持多态查询了

使用get方法，由于get方法不是Lazy加载，所以可以支持多态查询。

使用hql也可以支持多态查询

对于继承的情况
每颗继承树映射到一张表
类的关系图如下
对应的映射文件是：
<class name="Animal" table="t_animal" lazy="false">
<id name="id">
<generator class="native"/>
</id>
指明在表中需要添加一个名为“type”的字段，用于区分子类
<discriminator column="type" type="string"/>
<property name="name"/>
<property name="sex"/>

指明这个类是当前类的子类，其区分字段“type”为“p”
<subclass name="Pig" discriminator-value="P">
<property name="weight"/>
</subclass>
<subclass name="Bird" discriminator-value="B">
<property name="height"/>
</subclass>
</class>

优点：效率高
缺点：有冗余字段，而且当某些可能冗余的字段设置为not null的时候表就不能用了。
多数情况下使用这种形式。

1、理解如何映射
因为类继承树肯定是对应多个类，要把多个类的信息存放在一张表中，必须有某种机制来区分哪些记录是属于哪个类的。
这种机制就是，在表中添加一个字段，用这个字段的值来进行区分。用hibernate实现这种策略的时候，有如下步骤：
父类用普通的<class>标签定义
在父类中定义一个discriminator，即指定这个区分的字段的名称和类型
如：<discriminator column=”XXX” type=”string”/>
1.子类使用<subclass>标签定义，在定义subclass的时候，需要注意如下几点：
2.Subclass标签的name属性是子类的全路径名
3.在Subclass标签中，用discriminator-value属性来标明本子类的discriminator字段（用来区分不同类的字段）
4. 的值Subclass标签，既可以被class标签所包含（这种包含关系正是表明了类之间的继承关系），也可以与class标签平行。当subclass 标签的定义与class标签平行的时候，需要在subclass标签中，添加extends属性，里面的值是父类的全路径名称。子类的其它属性，像普通类一样，定义在subclass标签的内部。

2、理解如何存储
存储的时候hibernate会自动将鉴别字段值插入到数据库中，在加载数据的时候，hibernate能根据这个鉴别值正确的加载对象