JavaWeb框架——Hibernate(四)

原创 2018年04月15日 10:36:16

1、多表查询
这里写图片描述
2、HQL查询
这里写图片描述
这里写图片描述
这里写图片描述
这里写图片描述
这里写图片描述
这里写图片描述
实体类
Customer.java

package cn.ctgu.domain;

import java.util.HashSet;
import java.util.Set;

/*CREATE TABLE customer(
        id BIGINT(32) NOT NULL PRIMARY KEY  AUTO_INCREMENT COMMENT'客户编号(主键)',
        NAME VARCHAR(32) NOT NULL COMMENT '客户名称(公司名称)',
        source VARCHAR(32) DEFAULT NULL COMMENT '客户信息来源',
        industry VARCHAR(32)DEFAULT NULL COMMENT '客户所属行业',
        LEVEL VARCHAR(32) DEFAULT NULL COMMENT '客户级别',
        phone VARCHAR(64) DEFAULT NULL COMMENT '固定电话',
        mobile VARCHAR(16) DEFAULT NULL COMMENT '移动电话'
    );*/
public class Customer {
    private Long id;

    private String name;
    private String source;
    private String industry;
    private String level;
    private String phone;
    private String mobile;
    //使用set集合表达一对多的关系
    private Set<LinkMan>linkMens=new HashSet<LinkMan>();


    public Customer() {
        super();
        // TODO Auto-generated constructor stub
    }
    public Customer(Long id, String name) {
        super();
        this.id = id;
        this.name = name;
    }
    public Set<LinkMan> getLinkMens() {
        return linkMens;
    }
    public void setLinkMens(Set<LinkMan> linkMens) {
        this.linkMens = linkMens;
    }
    public Long getId() {
        return id;
    }
    public void setId(Long id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getSource() {
        return source;
    }
    public void setSource(String source) {
        this.source = source;
    }
    public String getIndustry() {
        return industry;
    }
    public void setIndustry(String industry) {
        this.industry = industry;
    }
    public String getLevel() {
        return level;
    }
    public void setLevel(String level) {
        this.level = level;
    }
    public String getPhone() {
        return phone;
    }
    public void setPhone(String phone) {
        this.phone = phone;
    }
    public String getMobile() {
        return mobile;
    }
    public void setMobile(String mobile) {
        this.mobile = mobile;
    }
    @Override
    public String toString() {
        return "Customer [id=" + id + ", name=" + name + "]";
    }

}

LinkMan.java

package cn.ctgu.domain;

//联系人实体
public class LinkMan {
    private Long lkm_id;
    private Character lkm_gender;
    private String lkm_name;
    private String lkm_phone;
    private String lkm_email;
    private String lkm_qq;
    private String lkm_mobile;
    private String lkm_memo;
    private String lkm_position;

    //表达多对一的关系
    private Customer customer;

    public Customer getCustomer() {
        return customer;
    }
    public void setCustomer(Customer customer) {
        this.customer = customer;
    }
    public Long getLkm_id() {
        return lkm_id;
    }
    public void setLkm_id(Long lkm_id) {
        this.lkm_id = lkm_id;
    }
    public Character getLkm_gender() {
        return lkm_gender;
    }
    public void setLkm_gender(Character lkm_gender) {
        this.lkm_gender = lkm_gender;
    }
    public String getLkm_name() {
        return lkm_name;
    }
    public void setLkm_name(String lkm_name) {
        this.lkm_name = lkm_name;
    }
    public String getLkm_phone() {
        return lkm_phone;
    }
    public void setLkm_phone(String lkm_phone) {
        this.lkm_phone = lkm_phone;
    }
    public String getLkm_email() {
        return lkm_email;
    }
    public void setLkm_email(String lkm_email) {
        this.lkm_email = lkm_email;
    }
    public String getLkm_qq() {
        return lkm_qq;
    }
    public void setLkm_qq(String lkm_qq) {
        this.lkm_qq = lkm_qq;
    }
    public String getLkm_mobile() {
        return lkm_mobile;
    }
    public void setLkm_mobile(String lkm_mobile) {
        this.lkm_mobile = lkm_mobile;
    }
    public String getLkm_memo() {
        return lkm_memo;
    }
    public void setLkm_memo(String lkm_memo) {
        this.lkm_memo = lkm_memo;
    }
    public String getLkm_position() {
        return lkm_position;
    }
    public void setLkm_position(String lkm_position) {
        this.lkm_position = lkm_position;
    }

}

Role.java

package cn.ctgu.domain;

import java.util.HashSet;
import java.util.Set;

//角色对象
public class Role {
    private Long role_id;
    private String role_name;
    private String role_memo;
    //表达多对多
    private Set<User>users=new HashSet<User>();

    public Long getRole_id() {
        return role_id;
    }
    public void setRole_id(Long role_id) {
        this.role_id = role_id;
    }
    public String getRole_name() {
        return role_name;
    }
    public void setRole_name(String role_name) {
        this.role_name = role_name;
    }
    public String getRole_memo() {
        return role_memo;
    }
    public void setRole_memo(String role_memo) {
        this.role_memo = role_memo;
    }
    public Set<User> getUsers() {
        return users;
    }
    public void setUsers(Set<User> users) {
        this.users = users;
    }

}

User.java

package cn.ctgu.domain;

import java.util.HashSet;
import java.util.Set;

public class User {
    private Long user_id;
    private String user_code;
    private String user_name;
    private String user_password;
    private Character user_state;
    //表达多对多
    private Set<Role>roles=new HashSet<Role>();
    public Long getUser_id() {
        return user_id;
    }
    public void setUser_id(Long user_id) {
        this.user_id = user_id;
    }
    public String getUser_code() {
        return user_code;
    }
    public void setUser_code(String user_code) {
        this.user_code = user_code;
    }
    public String getUser_name() {
        return user_name;
    }
    public void setUser_name(String user_name) {
        this.user_name = user_name;
    }
    public String getUser_password() {
        return user_password;
    }
    public void setUser_password(String user_password) {
        this.user_password = user_password;
    }
    public Character getUser_state() {
        return user_state;
    }
    public void setUser_state(Character user_state) {
        this.user_state = user_state;
    }
    public Set<Role> getRoles() {
        return roles;
    }
    public void setRoles(Set<Role> roles) {
        this.roles = roles;
    }

}

ORM配置文件
Customer.hbm.xml

<?xml version="1.0" encoding="UTF-8"?>
<hibernate-mapping package="cn.ctgu.domain">
    <class name="Customer" table="customer" lazy="false">
        <id name="id"  column="id">
            <!-- generator:主键生成策略
                就是每条记录录入时,主键的生成规则(7个)
                identity:主键自增,有数据库来维护主键值,录入时不需要指定主键
                increment(不用,存在线程安全问题,当多个线程同时插入数据事可能会产生覆盖):主键自增,由hibernate来维护,每次插入时会先查询表中id最大值,+1作为新主键值
                sequence:Oracle中的主键生成策略
                hilo(不用,同样存在线程安全问题):高低位算法,主键自增,由hibernate来维护,开发时不使用
                native:hilo+sequence+identity 自动三选一策略
                uuid:产生随机字符串作为主键,主键类型必须为String类型,否则会报错
                assigned:自然主键生成策略,hibernate不会管理主键值,由开发人员自己录入
             -->
            <generator class="native"></generator>
        </id>
        <property name="name" column="NAME" ></property>
        <property name="source" column="source"></property>
        <property name="industry" column="industry"></property>
        <property name="level" column="LEVEL"></property>
        <property name="phone" column="phone"></property>
        <property name="mobile" column="mobile"></property>

        <!--
            lazy属性:决定是否延迟加载
                true(默认值):延迟加载,懒加载
                false:立即加载
                extra:极其懒惰
            fetch属性:决定加载策略,使用什么类型的sql语句加载集合数据
                select(默认值):单表查询加载
                join:使用多表查询加载集合
                subselect:使用子查询加载集合
          -->
          <!-- batch-size:抓取集合的数量为3 
                抓取客户的集合时一次抓取多少次
          -->   
        <set name="linkMens" lazy="false" fetch="select" batch-size="3">
            <key column="lkm_cust_id"></key>
            <one-to-many class="LinkMan"/>
        </set>

    </class>
</hibernate-mapping>

LinkMan.hbm.xml

<?xml version="1.0" encoding="UTF-8"?>
<hibernate-mapping package="cn.ctgu.domain">
    <class name="Customer" table="customer" lazy="false">
        <id name="id"  column="id">
            <!-- generator:主键生成策略
                就是每条记录录入时,主键的生成规则(7个)
                identity:主键自增,有数据库来维护主键值,录入时不需要指定主键
                increment(不用,存在线程安全问题,当多个线程同时插入数据事可能会产生覆盖):主键自增,由hibernate来维护,每次插入时会先查询表中id最大值,+1作为新主键值
                sequence:Oracle中的主键生成策略
                hilo(不用,同样存在线程安全问题):高低位算法,主键自增,由hibernate来维护,开发时不使用
                native:hilo+sequence+identity 自动三选一策略
                uuid:产生随机字符串作为主键,主键类型必须为String类型,否则会报错
                assigned:自然主键生成策略,hibernate不会管理主键值,由开发人员自己录入
             -->
            <generator class="native"></generator>
        </id>
        <property name="name" column="NAME" ></property>
        <property name="source" column="source"></property>
        <property name="industry" column="industry"></property>
        <property name="level" column="LEVEL"></property>
        <property name="phone" column="phone"></property>
        <property name="mobile" column="mobile"></property>

        <!--
            lazy属性:决定是否延迟加载
                true(默认值):延迟加载,懒加载
                false:立即加载
                extra:极其懒惰
            fetch属性:决定加载策略,使用什么类型的sql语句加载集合数据
                select(默认值):单表查询加载
                join:使用多表查询加载集合
                subselect:使用子查询加载集合
          -->
          <!-- batch-size:抓取集合的数量为3 
                抓取客户的集合时一次抓取多少次
          -->   
        <set name="linkMens" lazy="false" fetch="select" batch-size="3">
            <key column="lkm_cust_id"></key>
            <one-to-many class="LinkMan"/>
        </set>

    </class>
</hibernate-mapping>

Role.hbm.xml

<?xml version="1.0" encoding="UTF-8"?>
<hibernate-mapping package="cn.ctgu.domain">
    <class name="Role" table="role">
        <id name="role_id"  column="id">
            <generator class="native"></generator>
        </id>
        <property name="role_name"></property>
        <property name="role_memo" ></property>

        <!-- 维护关系属性 
            true:放弃维护关系
            false:维护关系

            结论:在业务开发中,如果遇到多对多关系,一定要选择一方放弃维护关系
            一般谁来放弃要看业务方向,例如:录入员工时,需要为员工指定所属角色
            那么业务方向就是由员工维护角色,角色不需要维护与员工关系,角色放弃维护
        -->
        <!-- <set name="users" table="sys_user_role" inverse="true"> -->
        <set name="users" table="sys_user_role">
            <key column="role_id"></key>
            <many-to-many class="User" column="user_id"/>
        </set>

    </class>
</hibernate-mapping>

User.hbm.xml

<?xml version="1.0" encoding="UTF-8"?>
<hibernate-mapping package="cn.ctgu.domain">
    <class name="User" table="user">
        <id name="user_id"  column="id">
            <generator class="native"></generator>
        </id>
        <property name="user_name"></property>
        <property name="user_code" ></property>
        <property name="user_password"></property>
        <property name="user_state" ></property>

        <!-- 多对多关系表达 -->
        <!-- 
            name:集合属性名
            table:配置中间表名
            key
              |-column:外键,别人引用“我”(User,因为实在它的配置文件中)的外键列名
            class:我与哪个类是多对多关系
            column:外键,我引用别人的外键列名
         -->
         <!--cascade级联操作:
            save-update:级联保存更新
            delete:级联删除
            all:级联保存更新+级联删除
         结论:cascade简化代码书写,该属性使不使用无所谓,建议不用,要用也只用save-update
         使用delete操作太过危险,尤其在多对多中,建议不使用
           -->
        <set name="roles" table="sys_user_role" cascade="save-update">
            <key column="user_id"></key>
            <many-to-many class="Role" column="role_id"/>
        </set>

    </class>
</hibernate-mapping>

HQL查询
Demo.java

package cn.ctgu.hql;

import java.util.List;

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.Test;

import cn.ctgu.domain.Customer;
import cn.ctgu.utils.HibernateUtils;

public class Demo {
    //基本语法
    @Test
    public void fun1() {
        Session session=HibernateUtils.openSession();
        Transaction tx=session.beginTransaction();
        //----------------------------------------
        String hql="from Customer";//简单写法
//      String hql2="from java.lang.Object";//查询所有对象Customer、LinkMan、Role、User

        Query query=session.createQuery(hql);

        List<Customer>list=query.list();

        System.out.println(list);

        //----------------------------------------
        tx.commit();
        session.close();
    }

    //排序
        @Test
        public void fun2() {
            Session session=HibernateUtils.openSession();
            Transaction tx=session.beginTransaction();
            //----------------------------------------
            String hql="from Customer order by id asc";//升序排序
            String hql1="from Customer order by id desc";//降序排序


            Query query=session.createQuery(hql);

            List<Customer>list=query.list();

            System.out.println(list);

            //----------------------------------------
            tx.commit();
            session.close();
        }
        //统计查询
        //count
        //sum
        //avg
        //max
        //min
        @Test
        public void fun3() {
            Session session=HibernateUtils.openSession();
            Transaction tx=session.beginTransaction();
            //----------------------------------------
            String hql="select count(*) from Customer";//查询总记录数
            String hql1="select sum(id) from Customer";//查询id的总和
            String hql2="select avg(id) from Customer";//查询id的平均值
            String hql3="select max(id) from Customer";//查询id的最大值
            String hql4="select min(id) from Customer";//查询id的最小值

            Query query=session.createQuery(hql);

            Number number=(Number) query.uniqueResult();

            System.out.println(number);

            //----------------------------------------
            tx.commit();
            session.close();
        }

        //投影查询
        @Test
        public void fun4() {
            Session session=HibernateUtils.openSession();
            Transaction tx=session.beginTransaction();
            //----------------------------------------
            String hql="select name from Customer";//查询所有Customer的名字
            String hql1="select name,id from Customer";//查询所有Customer的名字、id号
            String hql2="select new Customer(id,name) from Customer";//查询所有Customer的名字、id号

            Query query=session.createQuery(hql2);

            List list=query.list();

            System.out.println(list);

            //----------------------------------------
            tx.commit();
            session.close();
        }               
}

Demo2.java(多表查询)

package cn.ctgu.hql;

import java.util.Arrays;
import java.util.List;

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.Test;

import cn.ctgu.domain.Customer;
import cn.ctgu.utils.HibernateUtils;

//HQL多表查询
public class Demo2 {
    //原生SQL
    /*
     * 交叉连接-笛卡尔积(避免)
     * select * from A,B
     * 内连接:
     * 隐式内连接
     * select * from A,B where b.id=a.id
     * 显示内连接
     * select * from A inner join B on b.aid=a.aid
     * 外连接:
     * 左外连接
     * select * from A left join B on b.aid=a.aid
     * 右外连接
     * select * from A right join B on b.aid=a.aid
     * */
    //--------------------------------------------
    //HQL的多表查询
    /*
     * 内连接(迫切)
     * 
     * 外连接:
     * 左外连接(迫切):
     * 右外连接(迫切)
     * */
    @Test
    //HQL 内连接=》将连接的两个对象分别返回,放到数组中
    public void fun1() {
        Session session=HibernateUtils.openSession();
        Transaction tx=session.beginTransaction();
        //----------------------------------------
        String hql="from Customer c inner join c.linkMens";//Customer里的linkMens

        Query query=session.createQuery(hql);

        List<Object[]>list=query.list();//将两对象放到数组中的第一、第二位置
        for(Object[]arr:list) {
            System.out.println(Arrays.toString(arr));
        }


        //----------------------------------------
        tx.commit();
        session.close();
    }   

    @Test
    //HQL 迫切内连接=》帮我们进行封装,返回值就是一个对象
    public void fun2() {
        Session session=HibernateUtils.openSession();
        Transaction tx=session.beginTransaction();
        //----------------------------------------
        String hql="from Customer c inner join fetch c.linkMens";//Customer里的linkMens

        Query query=session.createQuery(hql);

        List<Customer>list=query.list();

        System.out.println(list);//将linkman对象装到Customer中
        //----------------------------------------
        tx.commit();
        session.close();
    }
    @Test
    //HQL 右外连接=》将连接的两个对象分别返回,放到数组中
    public void fun3() {
        Session session=HibernateUtils.openSession();
        Transaction tx=session.beginTransaction();
        //----------------------------------------
        String hql="from Customer c right join c.linkMens";//Customer里的linkMens

        Query query=session.createQuery(hql);

        List<Object[]>list=query.list();//将两对象放到数组中的第一、第二位置
        for(Object[]arr:list) {
            System.out.println(Arrays.toString(arr));
        }


        //----------------------------------------
        tx.commit();
        session.close();
    }   
}

2、Criteria查询
这里写图片描述
这里写图片描述
这里写图片描述
这里写图片描述

基本查询
Demo.java

package cn.ctgu.criteria;

import java.util.List;

import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Projection;
import org.hibernate.criterion.Projections;
import org.hibernate.criterion.Restrictions;
import org.junit.Test;

import cn.ctgu.domain.Customer;
import cn.ctgu.utils.HibernateUtils;

public class Demo {
    //基本语法,查询所有对象
    @Test
    public void fun1() {
        Session session=HibernateUtils.openSession();
        Transaction tx=session.beginTransaction();
        //----------------------------------------
        Criteria c=session.createCriteria(Customer.class);

        List<Customer>list=c.list();

        System.out.println(list);

        //----------------------------------------
        tx.commit();
        session.close();
    }


    @Test
    //条件查询
    public void fun2() {
        Session session=HibernateUtils.openSession();
        Transaction tx=session.beginTransaction();
        //----------------------------------------
        Criteria c=session.createCriteria(Customer.class);

        c.add(Restrictions.idEq(2l));
        //c.add(Restrictions.eq("id", 2l));

        List<Customer>list=c.list();

        System.out.println(list);

        //----------------------------------------
        tx.commit();
        session.close();
    }   

    @Test
    //分页查询
    public void fun3() {
        Session session=HibernateUtils.openSession();
        Transaction tx=session.beginTransaction();
        //----------------------------------------
        Criteria c=session.createCriteria(Customer.class);

        //limit ?,?
        c.setFirstResult(0);
        c.setMaxResults(2);

        List<Customer>list=c.list();

        System.out.println(list);

        //----------------------------------------
        tx.commit();
        session.close();
    }

    @Test
    //排序查询
    public void fun4() {
        Session session=HibernateUtils.openSession();
        Transaction tx=session.beginTransaction();
        //----------------------------------------
        Criteria c=session.createCriteria(Customer.class);

        c.addOrder(Order.desc("id"));//按降序排序

        List<Customer>list=c.list();

        System.out.println(list);

        //----------------------------------------
        tx.commit();
        session.close();
    }

    @Test
    //统计语法
    public void fun5() {
        Session session=HibernateUtils.openSession();
        Transaction tx=session.beginTransaction();
        //----------------------------------------
        Criteria c=session.createCriteria(Customer.class);

        c.setProjection(Projections.rowCount());

        List<Customer>list=c.list();

        System.out.println(list);

        //----------------------------------------
        tx.commit();
        session.close();
    }

}

离线查询
使用DetachedCriteria来构造查询条件,然后将这个DetachedCriteria作为方法调用参数传递给业务层对象。而业务层对象获得DetachedCriteria之后,可以在session范围内直接构造Criteria,进行查询。就此,查询语句的构造完全被搬离到web层实现,而业务层则只负责完成持久化和查询的封装即可。换句话说,业务层代码是不变化的。我们不必为了查询条件的变化而去频繁改动查询语句了,而传统的查询是传递查询条件的。

package cn.ctgu.criteria;

import java.util.List;

import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Projection;
import org.hibernate.criterion.Projections;
import org.hibernate.criterion.Restrictions;
import org.junit.Test;

import cn.ctgu.domain.Customer;
import cn.ctgu.utils.HibernateUtils;

public class Demo2 {
    //离线查询
    @Test
    public void fun1() {
        //Service/web层
        DetachedCriteria dc=DetachedCriteria.forClass(Customer.class);
        dc.add(Restrictions.idEq(6l));//拼装成条件(全部与普通Criteria一致)

        //---------------dao层-------------------------
        Session session=HibernateUtils.openSession();
        Transaction tx=session.beginTransaction();
        Criteria c=dc.getExecutableCriteria(session);

        List<Customer>list=c.list();

        System.out.println(list);

        //----------------------------------------
        tx.commit();
        session.close();
    }

}

3、查询优化
这里写图片描述

package cn.ctgu.lazy;

import java.util.List;

import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Projection;
import org.hibernate.criterion.Projections;
import org.hibernate.criterion.Restrictions;
import org.junit.Test;

import cn.ctgu.domain.Customer;
import cn.ctgu.utils.HibernateUtils;

public class Demo {
    //延时加载,方法一调用load(只对该条查询语句进行延迟)
    //load方法(默认):在执行时,不发送任何sql语句,返回一个对象,使用该对象时,才执行查询
    //延迟加载:仅仅获得没有使用,不会查询,在使用时才进行查询

    //是否对类进行延迟加载:可以通过在class元素上配置lazy属性来控制(对整个类的有关查询都进行延迟)
    //lazy:true     加载时,不查询,使用时才查询
    //lazy:false    加载时立即查询(和get方法一样)
    @Test
    public void fun1() {
        Session session=HibernateUtils.openSession();
        Transaction tx=session.beginTransaction();
        //----------------------------------------
        Customer c=session.load(Customer.class, 2l);//延时加载,用的时候再加载

        System.out.println(c);//加载查询,注意:session不能在加载之前关闭,否则会报错

        //----------------------------------------
        tx.commit();
        session.close();
    }           
}

这里写图片描述

集合策略(在Customer上,即一的一方,进行配置lazy、fetch属性)

package cn.ctgu.lazy_fetch;

import java.util.List;
import java.util.Set;

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.Test;

import cn.ctgu.domain.Customer;
import cn.ctgu.domain.LinkMan;
import cn.ctgu.utils.HibernateUtils;
//关联界别延迟加载&抓取策略
public class lazy_fetch {
    @Test
    //集合级别的关联
    //fetch:select      使用单表查询
    //lazy:extra        极其懒惰,与懒加载效果基本一致,如果只获得集合的size,只查询集合的size(count语句)
    public void fun1() {
        Session session=HibernateUtils.openSession();
        Transaction tx=session.beginTransaction();
        //----------------------------------------
        Customer c=session.get(Customer.class, 2l);

        Set<LinkMan>linkMens=c.getLinkMens();//关联级别

        System.out.println(linkMens.size());

        System.out.println(c);

        //----------------------------------------
        tx.commit();
        session.close();
    }

    @Test
    //集合级别的关联
    //fetch:select      使用单表查询
    //lazy:false           立即加载集合数据
    public void fun2() {
        Session session=HibernateUtils.openSession();
        Transaction tx=session.beginTransaction();
        //----------------------------------------
        Customer c=session.get(Customer.class, 2l);//延时加载,用的时候再加载

        Set<LinkMan>linkMens=c.getLinkMens();//关联级别
        System.out.println(linkMens.size());
        System.out.println(c);

        //----------------------------------------
        tx.commit();
        session.close();
    }

    @Test
    //集合级别的关联
    //fetch:join        使用多表查询
    //lazy:true|false|extra       失败,都是立即加载
    public void fun3() {
        Session session=HibernateUtils.openSession();
        Transaction tx=session.beginTransaction();
        //----------------------------------------
        Customer c=session.get(Customer.class, 2l);//延时加载,用的时候再加载

        Set<LinkMan>linkMens=c.getLinkMens();//关联级别
        System.out.println(linkMens.size());
        System.out.println(c);

        //----------------------------------------
        tx.commit();
        session.close();
    }

    @Test
    //集合级别的关联
    //fetch:subselect       子查询
    //lazy:true         懒加载,
    public void fun4() {
        Session session=HibernateUtils.openSession();
        Transaction tx=session.beginTransaction();
        //----------------------------------------
        String hql="from Customer";
        Query query=session.createQuery(hql);

        List<Customer>list=query.list();
        for(Customer c:list) {
            System.out.println(c);
            System.out.println(c.getLinkMens().size());
            System.out.println(c.getLinkMens());
        }
        //----------------------------------------
        tx.commit();
        session.close();
    }
}

属性策略(在多的一方ORM配置文件上进行配置)

package cn.ctgu.lazy_fetch;



import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.Test;

import cn.ctgu.domain.Customer;
import cn.ctgu.domain.LinkMan;
import cn.ctgu.utils.HibernateUtils;

public class Demo {
    @Test
    //fetch:select  单表查询
    //lazy:proxy
    //customer-true     懒加载
    public void fun1() {
        Session session=HibernateUtils.openSession();
        Transaction tx=session.beginTransaction();
        //-----------------------------------------
        LinkMan lm=session.get(LinkMan.class, 1l);
        Customer customer=lm.getCustomer();
        System.out.println(customer);//使用时加载
        //-----------------------------------------
        tx.commit();
        session.close();
    }

    @Test
    //fetch:select  单表查询
    //lazy:proxy
    //customer-false    懒加载
    public void fun2() {
        Session session=HibernateUtils.openSession();
        Transaction tx=session.beginTransaction();
        //-----------------------------------------
        LinkMan lm=session.get(LinkMan.class, 1l);
        Customer customer=lm.getCustomer();
        System.out.println(customer);
        //-----------------------------------------
        tx.commit();
        session.close();
    }

    @Test
    //fetch:join  多表查询
    //lazy:失效

    public void fun3() {
        Session session=HibernateUtils.openSession();
        Transaction tx=session.beginTransaction();
        //-----------------------------------------
        LinkMan lm=session.get(LinkMan.class, 1l);
        Customer customer=lm.getCustomer();
        System.out.println(customer);
        //-----------------------------------------
        tx.commit();
        session.close();
    }
}

这里写图片描述

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/Jorocco/article/details/79947221

hibernate注解配置

  • 2012年03月09日 16:22
  • 9KB
  • 下载

Hibernate连表查询 Hibernate连表查询

  • 2010年01月13日 13:56
  • 3KB
  • 下载

JavaWeb框架----hibernate入门

1.先安装Eclipse上的hibernate插件。    去jboss tools官网上找对应eclipse版本的插件,下载第一个source包,下载后,通过help-->install new ...
  • zyp1987106
  • zyp1987106
  • 2017-11-09 23:44:15
  • 47

Hibernate批量操作3(JDBC批量操作)

部分内容转自 :http://gaolixu.iteye.com/blog/519086 部分内容转自 :http://superjavason.iteye.com/blog/255423   ---...
  • Ethan_Fu
  • Ethan_Fu
  • 2015-03-19 11:09:10
  • 555

架构探险,从零开始写javaweb框架-全部章节源码

  • 2017年12月09日 10:08
  • 131KB
  • 下载

JavaWeb框架——Hibernate(三)

1、多表查询——一对多 代码示例 Customer.java package cn.ctgu.domain; import java.util.HashSet; imp...
  • Jorocco
  • Jorocco
  • 2018-04-15 09:51:54
  • 11

javaweb框架学习--Hibernate(一)

学习了几周的javaweb开发,目前入门的学习了jsp和servlet,Javabeen的使用,以及jdbc连接数据库。可以写一些小的程序,但未接触框架,觉得开发起来没底,还是接触一些,并打算将自己的...
  • weixin_40132006
  • weixin_40132006
  • 2017-12-03 12:50:18
  • 117

JavaWeb框架——Hibernate(一)

1、JavaEE开发三层结构 2、什么是Hibernate Hibernate是持久化层框架之一,是一个开放源代码的ORM(Object Relational Mapping,对象关系...
  • Jorocco
  • Jorocco
  • 2018-04-14 10:55:23
  • 16

架构探险 从零开始写javaweb框架

  • 2018年02月08日 17:36
  • 76.91MB
  • 下载

搭建JAVA WEB框架

  • 2016年04月10日 15:35
  • 540KB
  • 下载
收藏助手
不良信息举报
您举报文章:JavaWeb框架——Hibernate(四)
举报原因:
原因补充:

(最多只允许输入30个字)