学习Hibernate 收集的一些笔记

-- Hibernate  主键配置说明




hibernate映射文件的主键配置： 1.单一主键的配置： 
<id name="id" column="ID_" type="Java.lang.Integer"><generator class="native"/></id> 
2.复合主键的配置： 
<composite-id>


<key-property name="lastname" column="lastname_" type="java.lang.String" />


<key-property name="firstname" column="firstname_" type="java.lang.String"/></composite-id>


 主键的生产方式: 
1.Assigned：主键由应用逻辑来生成，数据交由hibernate保存时，主键值已经设置完毕，不需要hibernate干预


2.hilo：通过hi/lo算法实现的主键生成机制，需要额外的数据库表保存主键生成的历史状态


3.seqihlo：与hilo类似，通过算法hi/lo实现的主键生成机制，只是主键历史状态保存在Sequence中，适用于支持sequence的数据库，如：Oracle


4.increment：主键按数值顺序递增。此方式的实现机制为在当前应用实例中维持一个变量，以保存着当前的最大值，之后每次需要生成主键的时候将此值加1作为主键。如果同一数据库有多个实例访问时，此方式必须避免使用。


5.identity：采用数据库提供的主键生成机制，如SQL Server、MySQL、Sybase中的自增主键生成机制 6.sequence：采用数据库提供的sequence机制生成主键。如Oracle 的sequence


7.native：由hibernate根据数据库适配器中的定义，自动采用identity、hilo、sequence的其中一种作为主键的生成机制


8.uuid：根据当前设备IP，时间、JVM启动时间，内部自增量等4个参数生成十六进制数值作为主键，这种算法在最大程度上保证了产生ID的唯一性，即使是在多实例并发运行的情况下。


9.foreign：使用外部表的字段作为主键，此类主键的生成机制根据数据关联


10.select：这种类型的生成器需要指定一个唯一标识字段用于二次读取，以获得触发器生成的主键值，此时我们的generator需要一定成： 
<generator class="select"><param name="key">key_field</param></generator>




Hibernate中各种查询方法的总结


hibernate中各种查询方法的总结：
1.     使用HQL语句
Query q = session.createQuery("select e from com.sun.demo.Emp e");
2.     使用Load方法（主键查询）
Emp e = (Emp)session.load(Emp.class, 1141);
3.     使用get方法（主键查询）
Emp e = (Emp)session.get(Emp.class, 1141);
4.     参数化查询（使用？通配符，或者命令通配符）
Query q = session.createQuery("update Userinfo set ename='AAA' WHERE ename=?");
       q.setParameter(0, "SMITH");
Query q = session.createQuery("update Userinfo set ename='AAA' WHERE ename like ?");
       q.setParameter(0, "%M%");
Query q = session.createQuery("update Userinfo set ename='AAA' WHERE ename like :lkename");
       q.setParameter("lkename", "%L%");
5.     命名查询
<query name="myquery">
    <![CDATA[
     from com.sun.hibernate.Employer where job = ?
    ]]>
</query>
 
Query q = session.getNamedQuery("myquery");
q.setParameter(0, "MANAGER");
6.     属性查询
Query q = session.createQuery("select max(sal) from Employer e where sal is not null");
Query q = session.createQuery("select distinct job from Employer e");
7.     实例化查询
步骤如下：
1.编写你的HQL语句
2.创建普通的Java类 -------------------与POJO类不同，它与数据库没有任何关系
3.在该java类中你需要创建和查询结果对应的字段
4.在该java类中，你需要创建合适的构造函数
5.完善你的HQL语句，使用实例化查询的方式进行包装
6.通过list.get(i)获取的结果就不再是一个数组，而是一个包装后的对象
 
例子：
Query q = session.createQuery("SELECT new com.sun.demo.UserDate(ename,SYSDATE) FROM Userinfo");
List list = q.list();
for(int i=0;i<list.size();i++){
       UserDate u = (UserDate)list.get(i);
       System.out.println(u.getEname());
}
8.     多态查询
对于pojo来说，java中的这种关系被扩展到了数据库表中
 
hibernate在查询一个表的同时，会检查该表所对应的POJO类有没有子类，如果有，一起查询出来
9.     分页查询
//查询第三到五条
              q.setFirstResult(3);//从第三条开始
              q.setMaxResults(3);//提取三条
10.  uniqueResult方法查询(查询结果只能是一个字段)
Query q = session.createQuery("select count(*) from Employer");
Long count = (Long)q.uniqueResult();
11.  Criteria查询（通过面向对象化的设计，将数据查询条件封装为一个对象）
Criteria c = session.createCriteria(Employer.class);
       c.addOrder(Order.asc("sal"));      //按薪水升序查询
       c.setFirstResult(3);
       c.setMaxResults(3);
      
       List list = c.list();
      
       for(int i=0;i<list.size();i++){
           Employer emp = (Employer)list.get(i);
          
           System.out.println(emp.getEname() + " : " + emp.getSal());
       }
  
 //-----------------------------------------Hibernate  查询方式
 public static List search(String name){
        Configuration cf = new Configuration().configure("hibernate.cfg.xml");
        SessionFactory sf =   cf.buildSessionFactory();
        Session session = sf.openSession();
        Transaction tx = session.beginTransaction();
        Query q = session.createSQLQuery("select * from worklog  where username like :admin").addEntity(Worklog.class);
        q.setString("admin",name);
        List list = q.list();
        if(list.size()==0)
        {
            System.out.println("没有查询结果！");
        }
        tx.commit();
        session.close();
        return list;
    }


public static void main(String[] args){
        List rs = search("liang");
        Iterator iter = rs.iterator();
        while(iter.hasNext()){
            Worklog worklog = (Worklog) iter.next();
            Long id = (Long)worklog.getId();
            String username = (String)worklog.getUsername();
            String title = (String)worklog.getTitle();
            Date date = (Date)worklog.getCurrentdate();
            String log = (String)worklog.getLog();
            System.out.println(id+" "+username+" "+title+" "+date+" "+log);
        }
    }
}




//****************************************************




public class UsersDao {


    /**
     * 获取用户信息表所有数据
     * 
     */
    public static void getUserInfo(){
        Session session=HibernateSessionFactory.getSession();
        session.beginTransaction();
        List<Userinf> list=session.createQuery("from Userinf").list();
        System.out.println("集合的数目"+list.size());
        for(Userinf uf:list){
            System.out.println(uf.getUsers().getUsername()+" "+uf.getArm());
        }
        
        session.getTransaction().commit();
        session.close();
    }
    /**
     * 获取用户表所有数据信息
     */
    public static void getUsers(){
        Session session=HibernateSessionFactory.getSession();
        session.beginTransaction();
        List<Users> list=session.createQuery("from Users").list();
        for(Users us:list){
            System.out.println(us.getUsername());
            Set<Userinf> set=us.getUserinfs();
            for(Userinf uf:set){
                System.out.print(uf.getUsers().getEmail()+"    ");
            }
            System.out.println("");
        }
        System.out.println("************************************************");
        Iterator<Users> it=list.iterator();
        while(it.hasNext()){
            System.out.println(it.next().getUsername());
        }
        
        session.getTransaction().commit();
        session.close();
    }
    /**
     * 获取用户部分信息
     */
    public static void getUsersUsernameAndPassword(){
        Session session=HibernateSessionFactory.getSession();
        session.beginTransaction();
            //此时不能通过用户表对象泛型进行接收，只能通过集合对象进行接收
        List list=session.createQuery("select username,password from Users").list();
        for(int i=0;i<list.size();i++){
            //此时取出来的是一个对象数组
            Object obj[]=(Object[])list.get(i);
            System.out.println(obj[0].toString()+"  "+obj[1].toString());
            System.out.println("");
        }
        session.getTransaction().commit();
        session.close();
    }
    
    public static void main(String args[]){
//调用方法
        getUsersUsernameAndPassword();
    }
}




HQL是hibernate自己的一套查询语言，于SQL语法不同，具有跨数据库的优点。示例代码：




static void query(String name){
  Session s=null;
  try{
   s=HibernateUtil.getSession();
   
   //from后面是对象，不是表名
   String hql="from Admin as admin where admin.aname=:name";//使用命名参数，推荐使用，易读。
   Query query=s.createQuery(hql);
   query.setString("name", name);
   
   List<Admin> list=query.list();
   
   for(Admin admin:list){
    System.out.println(admin.getAname());
   }
  }finally{
   if(s!=null)
   s.close();
  }
 }




适用情况：常用方法，比较传统，类似jdbc。缺点：新的查询语言，适用面有限，仅适用于Hibernate框架。


对象化查询Criteria方法：

static void cri(String name,String password){
  Session s=null;
  try{
   s=HibernateUtil.getSession();
   
   Criteria c=s.createCriteria(Admin.class);
   c.add(Restrictions.eq("aname",name));//eq是等于，gt是大于，lt是小于,or是或
   c.add(Restrictions.eq("apassword", password));
   
   List<Admin> list=c.list();
   for(Admin admin:list){
    System.out.println(admin.getAname());
   }
  }finally{
   if(s!=null)
   s.close();
  }
 }
 
 
 适用情况：面向对象操作，革新了以前的数据库操作方式，易读。缺点：适用面较HQL有限。
 
 
动态分离查询DetachedCriteria


static List dc(DetachedCriteria dc) {


  Session s = HibernateUtil.getSession();
  Criteria c = dc.getExecutableCriteria(s);
  List rs = c.list();
  s.close();
  return rs;
 }
 
 
 DetachedCriteria dc = DetachedCriteria.forClass(User.class);
  int id = 1;
  if (id != 0)
   dc.add(Restrictions.eq("id", id));
  Date age = new Date();
  if (age != null)
   dc.add(Restrictions.le("birthday", age));
  List users = dc(dc);
  System.out.println("离线查询返回结果：" + users);
  
  
  
  适用情况：面向对象操作，分离业务与底层，不需要字段属性摄入到Dao实现层。  缺点：适用面较HQL有限。
  
  
  例子查询
  
  static List example(User user) {
  Session s = HibernateUtil.getSession();
  List<User> users = s.createCriteria(User.class).add(
    Example.create(user)).list();
  // List<User>
  // users2=s.createCriteria(User.class).add((Example.create(user)).ignoreCase())
  // .createCriteria("child").add((Example.create(user))).list();
  return users;
 }
 
 
 适用情况：面向对象操作。   缺点：适用面较HQL有限，不推荐。
 sql查询
 
 static List sql() {


  Session s = HibernateUtil.getSession();
  Query q = s.createSQLQuery("select * from user").addEntity(User.class);
  List<User> rs = q.list();
  s.close();
  return rs;
 }
 
 适用情况：不熟悉HQL的朋友，又不打算转数据库平台的朋友，万能方法   缺点：破坏跨平台，不易维护，不面向对象。
 命名查询
 static List namedQuery(int id) {
  Session s = HibernateUtil.getSession();
  Query q = s.getNamedQuery("getUserById");
  q.setInteger("id", id);
  return q.list();
 }
 
 
 <?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">


<hibernate-mapping>
    <class name="com.sy.vo.User" table="user" catalog="news">
    
 


    </class>
    <!-- 命名查询：定义查询条件 -->
    <query name="getUserById">
     <![CDATA[from User where id=:id]]>
    </query>
    <!-- 命名查询中使用sql，不推荐使用，影响跨数据库
    <sql-query name="getUserById2">
     <![CDATA[select * from User where ]]>
    </sql-query> -->
</hibernate-mapping>






适用情况：万能方法，有点像ibatis轻量级框架的操作，方便维护。  缺点：不面向对象。基于hql和sql，有一定缺陷。


//***************************  Hibernate  5.2 查询 方式


public void list(){
    String hql = "from Order";
    Query<Order> query = session.createQuery(hql, Order.class);
    List<Order> list = query.getResultList();
    for(Order o : list){
        System.out.println(o.getOrderId() + "::" + o.getCreateTime());
    }
}




public void pageList(){
    String hql = "from Order";
    Query<Order> query = session.createQuery(hql, Order.class);
    /**
     * setFirstResult() 是设置从第几条开始
     * setMaxResults() 是设置每页多少条数据
     */
    query.setFirstResult(0).setMaxResults(4); 
    List<Order> list = query.getResultList();
    for(Order o : list){
        System.out.println(o.getOrderId() + "::" + o.getCreateTime());
    }
}




public void multiCretiera(){
    String hql = "from Order where orderId like ? and createTime between ? and ?";
    Query<Order> query = session.createQuery(hql, Order.class);
    String beginDateStr = "2016-07-26 00:00:00";
    String endDateStr = "2016-07-26 23:59:59";
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
    Date beginDate = null;
    Date endDate = null;
    try {
        beginDate = sdf.parse(beginDateStr);
        endDate = sdf.parse(endDateStr);
    } catch (ParseException e) {
        e.printStackTrace();
    }
    query.setParameter(0, "%D%").setParameter(1, beginDate).setParameter(2, endDate);
    List<Order> list = query.getResultList();
    for(Order o : list){
        System.out.println(o.getOrderId() + "::" + o.getCreateTime());
    }
}






E.多条件查询，返回List集合(第二种形式：命名占位符)
public void multiCretiera1(){
    String hql = "from Order where orderId like :orderId and createTime between :beginDate and :endDate";
    Query<Order> query = session.createQuery(hql, Order.class);
    String beginDateStr = "2016-07-26 00:00:00";
    String endDateStr = "2016-07-26 23:59:59";
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
    Date beginDate = null;
    Date endDate = null;
    try {
        beginDate = sdf.parse(beginDateStr);
        endDate = sdf.parse(endDateStr);
    } catch (ParseException e) {
        e.printStackTrace();
    }
    query.setParameter("orderId", "%D%").setParameter("beginDate", beginDate).setParameter("endDate", endDate);
    List<Order> list = query.getResultList();
    for(Order o : list){
         System.out.println(o.getId() + "::" + o.getOrderId());
    }
}


   F.大于条件的查询，使用索引占位符
public void gt(){
    String hql = "from Order where id > ?";
    Query<Order> query = session.createQuery(hql, Order.class).setParameter(0, 3);
    List<Order> list = query.getResultList();
    for(Order o : list){
        System.out.println(o.getId() + "::" + o.getOrderId());
    }
}




 G.更新操作


public void update(){
    String hql = "update Order set createTime = ? where id = ?";
    Transaction tx = session.beginTransaction();
    Query<?> query = session.createQuery(hql).setParameter(0, new Date()).setParameter(1, 1);
    int i = query.executeUpdate();
    System.out.println(i);
    tx.commit();
    session.close();
}


  H.删除操作
public void delete(){
    //in 后面的括号可加可不加
    String hql = "delete from Order where id in (:idList)"; 
    Transaction tx = session.beginTransaction();
    List<Integer> list = new ArrayList<Integer>();
    list.add(1);
    list.add(2);
    Query<?> query = session.createQuery(hql).setParameter("idList", list);
    int i = query.executeUpdate();
    System.out.println(i);
    tx.commit();
    session.close();
}
  I.获取某一列的值


public void singleValue(){
    String hql = "select orderId from Order";
    Query<String> query = session.createQuery(hql, String.class);
    List<String> list = query.getResultList();
    for(String o : list){
        System.out.println(o);
    }
}
    J.使用对象的方式封装结果数据


public void getOrdersList(){
    String hql = "select new com.demo.hibernate.one2many.Order(o.id, o.orderId, o.createTime) from Order as o";
    Query<Order> query = session.createQuery(hql, Order.class);
    List<Order> list = query.getResultList();
    for(Order o : list){
        System.out.println(o.getId() + ";;" + o.getOrderId() + ";;");
     }
}


//*************************  遍历对象  


Session session=HibernateSessionFactory.getSession();  
Query q=session.createSQLQuery("select * from Customer").addEntity(Customer.class); 
List list=q.list();          for(int i=0;i<list.size();i++){
            Customer c=(Customer)list.get(i);          
   System.out.println(c.getCustomerName());   
}       
  HibernateSessionFactory.closeSession();  }