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 linkmans = new HashSet();
        
            联系人端(多的一方)
                    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
                
                

                
                        
                            
                                    
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                                    
                                
                                    
                                
                            
                        

                

            创建LinkMan.hbm.xml
                    
                    

                    
                            
                                
                                        
                                
                                
                                
                                
                                
                                
                                
                                
                                
                                
                                 
                                
                                
                                
                                
                            

                    
            
        1.2.5 双向维护产生多余SQL
            解决这个问题：将一的一方的外键维护权放弃掉：
        
        1.2.6 一对多的级联保存操作
            级联 : 操作一个对象的时候,是否操作其关联对象.
            级联操作是有方向性 : 
            
            保存客户级联保存联系人
                /**
                 * 级联保存操作:
                 *  * 保存客户级联保存联系人
                 *  在Customer.hbm.xml中上配置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中上配置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中上配置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中上配置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 roles=new HashSet();
                    
            角色端
                public class Role 
                {
                    private Long role_id;// 主键id
                    private String role_name;// '角色名称',
                    private String role_memo;// '备注',
                    
                    // 有用户的集合
                    private Set users=new HashSet();

        1.3.4 创建映射
            用户端
                
                
                
                    
                    
                        
                        
                            
                        
                        
                        
                        
                        
                        
                        
                        
                        
                        
                            
                            
                            
                            
                        
                    
                

            角色端
                
                
                
                    
                    
                        
                        
                            
                        
                        
                        
                        
                        
                        
                            
                            
                        
                    
                

        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 根据一个联系人,查询这个客户的名称