Hibernate的QBC查询

Customer.java

public class Customer {
	
	public Customer() {
		super();
		// TODO Auto-generated constructor stub
	}
	
	public Customer(String cust_name, String cust_source) {
		super();
		this.cust_name = cust_name;
		this.cust_source = cust_source;
	}

	private Long cust_id;
	private String cust_name;
	private String cust_source;
	private String cust_industry;
	private String cust_level;
	private String cust_phone;
	private String cust_mobile;
	//通过 ORM方式表示：一个客户对应的多个联系人
	//防止的多的一方的集合。Hibernate默认使用的是Set集合
	private Set<LinkMan> linkMans=new HashSet<LinkMan>();
    //省略get和set方法
}

LinkMan.java

public class 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;
	private String lkm_position;
	private String lkm_memo;
	//通过ORM方式表示：一个联系人只能属于一个客户
	//放置的是一的一方的对象
	private Customer customer;
    //省略了get和set方法
}

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="com.hibernate.domain.Customer" table="cst_customer">
		<!-- 建立OID与主键映射 -->
		<id name="cust_id" column="cust_id">
			<generator class="native"/>
		</id>
		<!-- 建立普通属性和表的字段的对应 -->
		<property name="cust_name" column="cust_name"/>
		<property name="cust_source" column="cust_source"/>
		<property name="cust_industry" column="cust_industry"/>
		<property name="cust_level" column="cust_level"/>
		<property name="cust_phone" column="cust_phone"/>
		<property name="cust_mobile" column="cust_mobile"/>
		<!-- 配置一对多的映射：放置的多的一方的集合 -->
		<!-- 
			set标签
				* name	：多的一方的对象集合的属性名称
				* cascade:级联
				* inverse:放弃`外键`维护权    默认false:不放弃
		 -->
		<set name="linkMans">
			<!-- 
				key标签
					* column:多的一方的外键的名称
			 -->
			<key column="lkm_cust_id"/>
			<!-- 
				one-to-many标签
					* class	:多的一方的全路径
			 -->
			<one-to-many class="com.hibernate.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="com.hibernate.domain.LinkMan" table="cst_linkman">
		<!-- 建立OID与主键映射 -->
		<id name="lkm_id" column="lkm_id">
			<generator class="native"/>
		</id>
		<!-- 建立普通属性与表字段映射 -->
		<property name="lkm_name"/>
		<property name="lkm_gender"/>
		<property name="lkm_phone"/>
		<property name="lkm_mobile"/>
		<property name="lkm_email"/>
		<property name="lkm_qq"/>
		<property name="lkm_position"/>
		<property name="lkm_memo"/>
		<!-- 配置多对一的关系：放置的是一的一方的对象 -->
		<!-- 
			many-to-one标签
				* name		:一的一方的对象的属性名称
				* class		:一的一方的全路径
				* column	：在多的一方的表的外键的名称
		 -->
		 <many-to-one name="customer" cascade="save-update,delete" class="com.hibernate.domain.Customer" column="lkm_cust_id"/>
	</class>
</hibernate-mapping>

HibernateUtils.java

public class HibernateUtils {

	public static final Configuration cfg;
	public static final SessionFactory sf;
	
	static{
		cfg = new Configuration().configure();
		sf = cfg.buildSessionFactory();
	}
	
	public static Session openSession(){
		return sf.openSession();
	}
	
	public static Session getCurrentSession() {
		return sf.getCurrentSession();//需要配置
	}
}

src下的hibernate.cfg.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
	"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
	"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
	<session-factory>
		<!-- 连接数据库的基本参数 -->
		<!-- hibernate-release-5.0.7.Final\project\etc\hibernate.properties -->
		<!-- localhost:3306 -->
		<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
		<property name="hibernate.connection.url">jdbc:mysql:///hibernate_day04</property>
		<property name="hibernate.connection.username">root</property>
		<property name="hibernate.connection.password">password</property>
		<!-- 配置Hibernate的方言 -->
		<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
		
		<!-- ==========可选配置========= -->
		<!-- 打印sql -->
		<property name="hibernate.show_sql">true</property>
		<!-- 格式化sql -->
		<property name="hibernate.format_sql">true</property>
		<!-- 自动建表create update -->
		<property name="hibernate.hbm2ddl.auto">update</property>
		
		<!-- 设置事务隔离级别 -->
		<!-- 
			1 read uncommitted  :脏读、不可重复读、虚读都会发生
			2 read committed    :解决脏读  (oracle默认)
			4 repeatable read   :解决脏读和不可重复读(mysql默认)
			8 serializable      :解决所有问题。串行执行、效率低
		 -->
		<property name="hibernate.connection.isolation">4</property>
		<!-- 配置当前线程绑定的Session -->
		<!-- 不用session.close() -->
		<property name="hibernate.current_session_context_class">thread</property>
		
		<!-- 引入映射 -->
		<mapping resource="com/hibernate/domain/Customer.hbm.xml"/>
		<mapping resource="com/hibernate/domain/LinkMan.hbm.xml"/>
		
	</session-factory>
</hibernate-configuration>

测试类

import java.util.List;

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

import com.hibernate.domain.Customer;
import com.hibernate.domain.LinkMan;
import com.hibernate.utils.HibernateUtils;

/**
 * QBC的查询
 * @author zhang
 *
 */
public class HibernateDemo2 {

	@Test
	/**
	 * 简单的查询
	 */
	public void demo1() {
		Session session=HibernateUtils.getCurrentSession();
		Transaction tx=session.beginTransaction();
		
		//获得Criteria的对象
		Criteria criteria = session.createCriteria(Customer.class);
		List<Customer> list=criteria.list();
		
		for (Customer customer : list) {
			System.out.println(customer);
		}
		tx.commit();
	}
	
	@Test
	/**
	 * 排序查询
	 */
	public void demo2() {
		Session session=HibernateUtils.getCurrentSession();
		Transaction tx=session.beginTransaction();
		
		//排序查询
		Criteria criteria = session.createCriteria(Customer.class);
//		criteria.addOrder(Order.asc("cust_id"));//升序
		criteria.addOrder(Order.desc("cust_id"));
		List<Customer> list=criteria.list();
		
		for (Customer customer : list) {
			System.out.println(customer);
		}
		
		tx.commit();
	}
	
	@Test
	/**
	 * 分页查询
	 */
	public void demo3() {
		Session session=HibernateUtils.getCurrentSession();
		Transaction tx=session.beginTransaction();
		
		//分页查询
		Criteria criteria = session.createCriteria(LinkMan.class);
		criteria.setFirstResult(10);
		criteria.setMaxResults(10);
		List<LinkMan> list = criteria.list();
		
		for (LinkMan linkMan : list) {
			System.out.println(linkMan);
		}
		tx.commit();
	}
	
	@Test
	/**
	 * 条件查询
	 */
	public void demo4() {
		Session session=HibernateUtils.getCurrentSession();
		Transaction tx=session.beginTransaction();
		
		//条件查询
		Criteria criteria = session.createCriteria(Customer.class);
		//设置条件
		/**
		 *  ==  eq
		 *  >   gt
		 *  >=  ge
		 *  <   lt
		 *  <=  le
		 *  <>  ne
		 *  like
		 *  in
		 *  and
		 *  or
		 */
		criteria.add(Restrictions.eq("cust_source", "计算机"));
//		criteria.add(Restrictions.or(Restrictions.like("cust_name", "李%")));
		criteria.add(Restrictions.like("cust_name", "李%"));//两个条件并列
		List<Customer> list = criteria.list();
		for (Customer customer : list) {
			System.out.println(customer);
		}
		tx.commit();
	}
	
	@Test
	//统计查询
	public void demo5() {
		Session session=HibernateUtils.getCurrentSession();
		Transaction tx=session.beginTransaction();
		
		Criteria criteria = session.createCriteria(Customer.class);
		/**
		 * add				:普通的条件，where后面条件
		 * addOrder			:排序
		 * setProjection	:聚合函数和group by having
		 */
		criteria.setProjection(Projections.rowCount());
//		Object object = criteria.uniqueResult();
		Long num=(Long) criteria.uniqueResult();
		System.out.println(num);
		tx.commit();
	}
	
	@Test
	/**
	 * 离线条件查询
	 */
	public void demo6() {
        //web层
		DetachedCriteria detachedCriteria=DetachedCriteria.forClass(Customer.class);
		detachedCriteria.add(Restrictions.like("cust_name", "李%"));
		

        //dao层
		Session session=HibernateUtils.getCurrentSession();
		Transaction transaction=session.beginTransaction();
		
		Criteria criteria = detachedCriteria.getExecutableCriteria(session);
		List<Customer> list = criteria.list();
		for (Customer customer : list) {
			System.out.println(customer);
		}
		
		transaction.commit();
	}
}

感觉这个查询的话，和SQL差距比较大，更偏向与面向对象。