SSH框架之Hibernate第三篇

1.1 多表关系分析和创建.
        1.1.1 表关系分析和创建
            表数据和表数据之间可以存在的关系?

            一对多的关系
                客户和联系人
                建立关系原则: 在多的一方创建一个字段,这个字段作为外键指向一的一方的主键

            多对多的关系
                用户和角色        用户:            角色:
                                jack            员工
                                rose            助教
                                            班主任

                建立关系原则:在外部创建一张中间表,这个中间表里至少需要2个字段,让这2个字段当成
                是外键,指向各自表的主键            

    1.2 Hibernate 中的一对多关系映射
        1.2.1 Hibernate 的一对多环境搭建

        1.2.2 创建表和实体
            创建表
                CREATE TABLE `cst_customer` (
                  `cust_id` bigint(32) NOT NULL AUTO_INCREMENT COMMENT '客户编号(主键)',
                  `cust_name` varchar(32) NOT NULL COMMENT '客户名称(公司名称)',
                  `cust_source` varchar(32) DEFAULT NULL COMMENT '客户信息来源',
                  `cust_industry` varchar(32) DEFAULT NULL COMMENT '客户所属行业',
                  `cust_level` varchar(32) DEFAULT NULL COMMENT '客户级别',
                  `cust_phone` varchar(64) DEFAULT NULL COMMENT '固定电话',
                  `cust_mobile` varchar(16) DEFAULT NULL COMMENT '移动电话',
                  PRIMARY KEY (`cust_id`)
                ) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

                CREATE TABLE `cst_linkman` (
                  `lkm_id` bigint(32) NOT NULL AUTO_INCREMENT COMMENT '联系人编号(主键)',
                  `lkm_name` varchar(16) DEFAULT NULL COMMENT '联系人姓名',
                  `lkm_cust_id` bigint(32) NOT NULL COMMENT '客户id',
                  `lkm_gender` char(1) DEFAULT NULL COMMENT '联系人性别',
                  `lkm_phone` varchar(16) DEFAULT NULL COMMENT '联系人办公电话',
                  `lkm_mobile` varchar(16) DEFAULT NULL COMMENT '联系人手机',
                  `lkm_email` varchar(64) DEFAULT NULL COMMENT '联系人邮箱',
                  `lkm_qq` varchar(16) DEFAULT NULL COMMENT '联系人qq',
                  `lkm_position` varchar(16) DEFAULT NULL COMMENT '联系人职位',
                  `lkm_memo` varchar(512) DEFAULT NULL COMMENT '联系人备注',
                  PRIMARY KEY (`lkm_id`),
                  KEY `FK_cst_linkman_lkm_cust_id` (`lkm_cust_id`),
                  CONSTRAINT `FK_cst_linkman_lkm_cust_id` FOREIGN KEY (`lkm_cust_id`) REFERENCES `cst_customer` (`cust_id`) ON DELETE NO ACTION ON UPDATE NO ACTION
                ) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

        创建实体
            客户端(一的一方)
                private Long cust_id;// 客户编号(主键)
                private String cust_name;//客户名称
                private String cust_source;//客户信息来源
                private String cust_industry;//客户所属行业
                private String cust_level;//客户级别
                private String cust_address;//客户联系地址
                private String cust_phone;//客户联系电话

                //有多的一方的集合
                private Set<LinkMan> linkmans = new HashSet<LinkMan>();

            联系人端(多的一方)
                    private Long lkm_id;//联系人编号(主键)
                    private String lkm_name;//联系人姓名
                    private String lkm_gender;//联系人性别
                    private String lkm_phone;//联系人办公电话
                    private String lkm_mobile;//联系人手机
                    private String lkm_email;//联系人邮箱
                    private String lkm_qq;//联系人QQ
                    private String lkm_position;//联系人职位
                    private String lkm_memo;//联系人备注

                    private Customer customer ;
        1.2.3 创建映射文件 创建Customer.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="cn.baidu.domain.Customer" table="cst_customer">
                            <id name="cust_id" column="cust_id">
                                    <generator class="native"></generator>
                            </id>

                            <!-- 需要做类的其它属性和表的其它字段映射 -->
                            <property name="cust_name" column="cust_name"></property>
                            <property name="cust_source" column="cust_source"></property>
                            <property name="cust_industry" column="cust_industry"></property>
                            <property name="cust_level" column="cust_level"></property>
                            <property name="cust_address" column="cust_address"></property>
                            <property name="cust_phone" column="cust_phone"></property>

                            <!-- 配置的一对多的关系映射 -->
                            <!-- // name:set集合的名称 -->
                            <!--inverse:true 放弃外键的维护权  -->
                            <!-- cascade:级联   save-update:级联保存  -->
                            <!-- lazy: 关联数据查询时(多表查询) 是否使用延迟加载   :true:使用 默认值  false:不使用-->
                            <set name="linkmans" inverse="true" cascade="save-update,delete" lazy="false" >
                                    <!-- // column:外键的字段名称 -->
                                <key column="lkm_cust_id"></key>
                                    <!-- // class: 多的一方的全限定名 -->
                                <one-to-many class="cn.baidu.domain.LinkMan"/>
                            </set>
                        </class>

                </hibernate-mapping>

            创建LinkMan.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="cn.baidu.domain.LinkMan" table="cst_linkman">
                                <id name="lkm_id" column="lkm_id">
                                        <generator class="native"></generator>
                                </id>

                                <!-- 需要做类的其它属性和表的其它字段映射 -->
                                <property name="lkm_name" column="lkm_name"></property>
                                <property name="lkm_gender" column="lkm_gender"></property>
                                <property name="lkm_phone" column="lkm_phone"></property>
                                <property name="lkm_mobile" column="lkm_mobile"></property>
                                <property name="lkm_email" column="lkm_email"></property>
                                <property name="lkm_qq" column="lkm_qq"></property>
                                <property name="lkm_position" column="lkm_position"></property>
                                <property name="lkm_memo" column="lkm_memo"></property>    

                                <!-- 配置的一对多的关系映射 -->
                                <!-- name:自己里面一的一方对象的属性名
                                class: 一的一方的全限定名
                                column:外键字段名称 -->
                                <many-to-one  cascade="save-update,delete" name="customer" class="cn.baidu.domain.Customer" column="lkm_cust_id"></many-to-one>
                            </class>

                    </hibernate-mapping>

        1.2.5 双向维护产生多余SQL
            解决这个问题：将一的一方的外键维护权放弃掉：<set name="linkMans" cascade="save-update,delete" inverse="true">

        1.2.6 一对多的级联保存操作
            级联 : 操作一个对象的时候,是否操作其关联对象.
            级联操作是有方向性 : 

            保存客户级联保存联系人
                /**
                 * 级联保存操作:
                 *     * 保存客户级联保存联系人
                 *  在Customer.hbm.xml中<set>上配置cascade="save-update"
                 */
                public void demo2(){
                    Session session = HibernateUtils.getCurrentSession();
                    Transaction transaction = session.beginTransaction();

                    // 创建一个客户 和两个联系人
                    Customer customer = new Customer();
                    customer.setCust_name("郝宝强");

                    LinkMan linkMan1 = new LinkMan();
                    linkMan1.setLkm_name("宋喆");

                    customer.getLinkMans().add(linkMan1);
                    linkMan1.setCustomer(customer);

                    session.save(customer);
                    // session.save(linkMan1);

                    transaction.commit();
                }
            保存联系人级联保存客户
                @Test
                /**
                 * 级联保存操作:
                 *     * 保存联系人级联保存客户在LinkMan.hbm.xml中<many-to-one>上配置cascade="save-update"
                 */
                public void demo3(){
                    Session session = HibernateUtils.getCurrentSession();
                    Transaction transaction = session.beginTransaction();

                    // 创建一个客户 和两个联系人
                    Customer customer = new Customer();
                    customer.setCust_name("郝强勇");

                    LinkMan linkMan1 = new LinkMan();
                    linkMan1.setLkm_name("马蓉");

                    customer.getLinkMans().add(linkMan1);
                    linkMan1.setCustomer(customer);

                    //session.save(customer);
                    session.save(linkMan1);

                    transaction.commit();
                }

        1.2.7 测试级联和对象导航(关联关系)的关系

            测试导航和级联关系:
            前提 : 双方都配置cascade = "save-update"
            * 联系人1关联客户   客户关联联系人2和3
             */
            public void demo6(){
                Session session = HibernateUtils.getCurrentSession();
                Transaction transaction = session.beginTransaction();

                // 创建一个客户
                Customer customer = new Customer();
                customer.setCust_name("郝宝强");
                // 创建三个联系人
                LinkMan linkMan1 = new LinkMan();
                linkMan1.setLkm_name("宋喆");
                LinkMan linkMan2= new LinkMan();
                linkMan2.setLkm_name("马蓉");
                LinkMan linkMan3 = new LinkMan();
                linkMan3.setLkm_name("郝如花");

                linkMan1.setCustomer(customer);
                customer.getLinkMans().add(linkMan2);
                customer.getLinkMans().add(linkMan3);

                // session.save(linkMan1); // 问发送几条insert语句？ 4条
                // session.save(customer); // 问发送几条insert语句？ 3条
                session.save(linkMan2); // 问发送几条insert语句？ 1条

                transaction.commit();
            }

        1.2.8 1.2.8一对多的级联删除操作
            删除客户级联删除联系人
            /**
             * 级联删除操作:
             *     * 删除客户级联删除联系人
             *         在Customer.hbm.xml中<set>上配置cascade="delete"
             */
            public void demo4(){
                Session session = HibernateUtils.getCurrentSession();
                Transaction transaction = session.beginTransaction();

                Customer customer = session.get(Customer.class, 1l);
                session.delete(customer);

                transaction.commit();
            }
        删除联系人级联删除客户（很少用）
            @Test
            /**
             * 级联删除操作:
             *     * 删除联系人级联删除客户
             *         在LinkMan.hbm.xml中<many-to-one>上配置cascade="delete"
             */
            public void demo5(){
                Session session = HibernateUtils.getCurrentSession();
                Transaction transaction = session.beginTransaction();

                LinkMan linkMan = session.get(LinkMan.class, 1l);
                session.delete(linkMan);

                transaction.commit();
            }

    1.3 Hibernate 中的多对多关系映射

        1.3.1 搭建多对多开发环境
        1.3.2 创建表
            CREATE TABLE `sys_user` (
              `user_id` bigint(32) NOT NULL AUTO_INCREMENT COMMENT '用户id',
              `user_code` varchar(32) NOT NULL COMMENT '用户账号',
              `user_name` varchar(64) NOT NULL COMMENT '用户名称',
              `user_password` varchar(32) NOT NULL COMMENT '用户密码',
              `user_state` char(1) NOT NULL COMMENT '1:正常,0:暂停',
              PRIMARY KEY (`user_id`)
            ) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

            CREATE TABLE `sys_role` (
              `role_id` bigint(32) NOT NULL AUTO_INCREMENT,
              `role_name` varchar(32) NOT NULL COMMENT '角色名称',
              `role_memo` varchar(128) DEFAULT NULL COMMENT '备注',
              PRIMARY KEY (`role_id`)
            ) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=utf8;

            CREATE TABLE `sys_user_role` (
              `role_id` bigint(32) NOT NULL COMMENT '角色id',
              `user_id` bigint(32) NOT NULL COMMENT '用户id',
              PRIMARY KEY (`role_id`,`user_id`),
              KEY `FK_user_role_user_id` (`user_id`),
              CONSTRAINT `FK_user_role_role_id` FOREIGN KEY (`role_id`) REFERENCES `sys_role` (`role_id`) ON DELETE NO ACTION ON UPDATE NO ACTION,
              CONSTRAINT `FK_user_role_user_id` FOREIGN KEY (`user_id`) REFERENCES `sys_user` (`user_id`) ON DELETE NO ACTION ON UPDATE NO ACTION
            ) ENGINE=InnoDB DEFAULT CHARSET=utf8;

        1.3.3 创建实体
            用户端
                public class User
                {
                    private Long user_id;// '用户id',
                    private String user_code;// '用户账号',
                    private String user_name;// '用户名称',
                    private String user_password;// '用户密码',
                    private String user_state;// '1:正常,0:暂停',

                    // 有角色的集合
                    private Set<Role> roles=new HashSet();

            角色端
                public class Role
                {
                    private Long role_id;// 主键id
                    private String role_name;// '角色名称',
                    private String role_memo;// '备注',

                    // 有用户的集合
                    private Set<User> users=new HashSet();

        1.3.4 创建映射
            用户端
                <?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.baidu.hibernate.domain.User" table="sys_user">
                        <!-- 建立oid与表的主键映射 -->
                        <id name="user_id" column="user_id">
                            <generator class="native"/>
                        </id>
                        <!-- 建立属性与表字段映射 -->
                        <property name="user_code"/>
                        <property name="user_name"/>
                        <property name="user_password"/>
                        <property name="user_state"/>

                        <!-- 建立用户与角色的映射关系 -->
                        <!--
                            set标签：
                                name属性:角色集合属性名称
                                table属性：中间表的名称
                         -->
                        <set name="roles" table="sys_user_role">
                            <!-- 用户端的在中间表的外键的名称 -->
                            <key column="user_id"/>
                            <!--
                                配置多对多映射
                                many-to-many标签
                                    * class    ：另一端的实体类的全路径
                                    * column：另一端在中间表外键的名称
                            -->
                            <many-to-many class="com.baidu.hibernate.domain.Role" column="role_id"/>
                        </set>
                    </class>
                </hibernate-mapping>

            角色端
                <?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.baidu.hibernate.domain.Role" table="sys_role">
                        <!-- 建立oid与表的主键映射 -->
                        <id name="role_id" column="role_id">
                            <generator class="native"/>
                        </id>
                        <!-- 建立属性与表字段映射 -->
                        <property name="role_name"/>
                        <property name="role_memo"/>
                        <!-- 建立关联关系映射 -->
                        <set name="users" table="sys_user_role">
                            <key column="role_id"/>
                            <many-to-many class="com.baidu.hibernate.domain.User" column="user_id"/>
                        </set>
                    </class>
                </hibernate-mapping>

        1.3.5 编写保存代码
            @Test
            /**
             * 保存数据
             */
            public void demo1(){
                Session session = HibernateUtils.getCurrentSession();
                Transaction transaction = session.beginTransaction();

                User user1 = new User();
                user1.setUser_name("小王");

                User user2 = new User();
                user2.setUser_name("小勇");

                Role role1 = new Role();
                role1.setRole_name("Java教研部");
                Role role2 = new Role();
                role2.setRole_name("前台");
                Role role3 = new Role();
                role3.setRole_name("学工部");

                user1.getRoles().add(role1);// 1 1
                user1.getRoles().add(role3);
                user2.getRoles().add(role3);

                role1.getUsers().add(user1);// 1 1
                role3.getUsers().add(user1);
                role3.getUsers().add(user2);

                session.save(user1);
                session.save(user2);
                session.save(role1);
                session.save(role2);
                session.save(role3);

                transaction.commit();
            }

        1.3.6 级联保存操作(基本不会用)
            保存用户级联保存角色.
            保存角色级联保存用户.

        1.3.7 级联删除操作(不会用-避免去使用)  用的默认删除
            删除用户有级联时,会删除角色.
            删除角色有级联时,会删除用户.

        1.3.8 多对多其他相关操作(掌握)
            给用户选择角色
                @Test
                /**
                 * 给1号用户选择1号和2号角色
                 */
                public void demo6(){
                    Session session = HibernateUtils.getCurrentSession();
                    Transaction transaction = session.beginTransaction();

                    User user = session.get(User.class, 1l);

                    Role role1 = session.get(Role.class, 1l);

                    Role role2 = session.get(Role.class, 2l);

                    user.getRoles().add(role1);
                    user.getRoles().add(role2);

                    transaction.commit();
                }

            给用户删除角色
                @Test
                /**
                 * 给1号删除2号角色
                 */
                public void demo7(){
                    Session session = HibernateUtils.getCurrentSession();
                    Transaction transaction = session.beginTransaction();

                    User user = session.get(User.class, 1l);

                    Role role = session.get(Role.class, 2l);

                    user.getRoles().remove(role);

                    transaction.commit();
                }

          给用户改选角色
                @Test
                /**
                 * 给1号用户的1号角色修改为2号角色
                 */
                public void demo8(){
                    Session session = HibernateUtils.getCurrentSession();
                    Transaction transaction = session.beginTransaction();

                    User user = session.get(User.class, 1l);

                    Role role1 = session.get(Role.class, 1l);

                    Role role2 = session.get(Role.class, 2l);

                    user.getRoles().remove(role1);
                    user.getRoles().add(role2);

                    transaction.commit();
                }    

        对象导航查询(多表关系查询)
            有一个客户,获取他的联系人个数.
                Customer ct = session.get(Customer.class,1L);
                System.out.prinltn(ct.getLinkmas().size());
            有一个联系人,获取他所属客户名称
                Linkman lm = session.get(Linkman.class,1L);
                System.out.println(lm.getCustomer().getCust_name());

        延迟加载
            提高hibernate效率,决定发送sql的时机.
            分类:
                类级别的延迟加载 (单表数据查询);
                    Load
                关联级别的延迟加载(多个对象的数据查询-多表数据查询)
                    通过一个对象查询其关联对象的数据.

            在set标签上有一个属性 lazy 用来配置关联级别是否延迟加载的.
                常用的值 :
                    true : 使用延迟加载,默认值.
                    false : 不使用延迟加载.
                        查询客户的同时,立马发送sql查询联系人.

            在many-to-one 标签上也有一个属性 lazy 用来配置是否延迟加载的.
                常用的值:
                    false : 不使用延迟加载(记住)
                        查询联系人的时候,立马发送sql查询客户.
            对象导航查询底层用的全是延迟加载机制.        

        总之(按需求) :
            根据一的一方查多的一方的时候,使用延迟加载(默认值);
            根据多的一方查一的一方一般使用立即加载,所以需要在多的一方的many-to-one标签配置 lazy=false;

        级联操作和对象导航的关系?  -----> 关联关系对级联操作的影响?

            测试:
                有一个客户和3个联系人

                让联系人1关联客户
                让客户关联联系人2和3 

                级联保存操作:
                      save(联系人1)  // 问: 会发送几条sql语句? 4

                      save(客户)  // 问:会发送几条sql语句? 3

                      save(联系人2) // 问:会发送几条sql语句? 1

        总结: 有影响
              级联操作是在保存自己的时候,还会去找自己关联的对象数据来保存
        对象导航的查询(关联关系的查询---多表数据的查询)

        1 根据一个客户,查询这个客户下面所有联系人的数量

        2 根据一个联系人,查询这个客户的名称