：Hibernate逍遥游记-第16管理session和实现对话

1.

 package mypack;
 public class Monkey{

     private Long id;
     private String name;
     private int count;
     private int version;

     public Monkey() {}

     public Long getId() {
         return this.id;
     }

     public void setId(Long id) {
         this.id = id;
     }

     public String getName() {
         return this.name;
     }

     public void setName(String name) {
         this.name = name;
     }

     public int getCount() {
         return this.count;
     }

     public void setCount(int count) {
         this.count = count;
     }

     public int getVersion() {
         return this.version;
     }

     public void setVersion(int version) {
         this.version = version;
     }
 }

2.

 <?xml version="1.0"?>
 <!DOCTYPE hibernate-mapping
 PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
 <hibernate-mapping >

   <class name="mypack.Monkey" table="MONKEYS" >
     <id name="id" type="long" column="ID">
       <generator class="increment"/>
     </id>

     <version name="version" column="VERSION" />

     <property name="name" type="string" column="NAME" />

     <property name="count" type="int" column="COUNT" />

   </class>
 </hibernate-mapping>

3.

 package mypack;
 import org.hibernate.SessionFactory;
 import org.hibernate.Session;
 import org.hibernate.cfg.Configuration;

 public class HibernateUtil {
   private static SessionFactory sessionFactory;

   static{
     try {
       sessionFactory=new Configuration()
                                       .configure()
                                       .buildSessionFactory();
     }catch (Throwable ex) {
       throw new ExceptionInInitializerError(ex);
     }
    }

    public static SessionFactory getSessionFactory() {
      return sessionFactory;
    }

    public static Session getCurrentSession(){
      return sessionFactory.getCurrentSession();
    }

 }

4.

 package mypack;
 public class MonkeyDAO{
   public Monkey getById(long id){
     return (Monkey)HibernateUtil.getCurrentSession()
                         .get(Monkey.class,new Long(id));
   }

   public void update(Monkey monkey){
     HibernateUtil.getCurrentSession().saveOrUpdate(monkey);
   }
 }

5.

 package mypack;
 import org.hibernate.Session;

 public class MonkeyDAO2{
   public Monkey getById(long id,Session session){
     return (Monkey)session.get(Monkey.class,new Long(id));
   }

   public void update(Monkey monkey,Session session){
     session.saveOrUpdate(monkey);
   }
 }

6.

 package mypack;
 public class BusinessService{
   private MonkeyDAO md=new MonkeyDAO();

   public void vote(long monkeyId){
     try {
       //声明开始事务
       HibernateUtil.getCurrentSession().beginTransaction();

       Monkey monkey=md.getById(monkeyId);
       monkey.setCount(monkey.getCount()+1);

       //提交事务
       HibernateUtil.getCurrentSession().getTransaction().commit();

     }catch (RuntimeException e) {
       try{
          //撤销事务
          HibernateUtil.getCurrentSession().getTransaction().rollback();
       }catch(RuntimeException ex){
          ex.printStackTrace();
       }
       throw e;
     }

   }

   public static void main(String args[]) {
     new BusinessService().vote(1);
   }
 }

7.

 package mypack;
 import java.io.*;
 import java.util.Scanner;

 public class BusinessService1{
   private MonkeyDAO md=new MonkeyDAO();

   public void vote()throws Exception{
     System.out.println("请输入候选者的ID：");
     //等待用户输入候选者的ID，此操作可能会化去很长时间，取决于用户的思考时间
     long monkeyId=new Scanner(System.in).nextLong(); 

     Monkey monkey=getMonkey(monkeyId);

     System.out.println("候选者的当前票数为："+monkey.getCount());

     System.out.println("您确信要投票吗(Y/N)：");
     //等待用户确认是否投票，此操作可能会花去很长时间，取决于用户的思考时间
     String flag=new Scanner(System.in).next();
     if(flag.equals("N"))return;

     monkey.setCount(monkey.getCount()+1);
     updateMonkey(monkey);

     System.out.println("投票成功，候选者的当前票数为："+monkey.getCount());
   }

   public Monkey getMonkey(long monkeyId){
     try{
       //创建一个Session对象，声明开始查询候选者事务
       HibernateUtil.getCurrentSession().beginTransaction();

       Monkey monkey=md.getById(monkeyId);

       //提交事务，在Session与本地线程绑定的方式下，会自动关闭Session对象
       HibernateUtil.getCurrentSession().getTransaction().commit();

       return monkey;
     }catch (RuntimeException e) {
       try{
          //撤销事务
          HibernateUtil.getCurrentSession().getTransaction().rollback();
       }catch(RuntimeException ex){
          ex.printStackTrace();
       }
       throw e;
     }

   }

   public void updateMonkey(Monkey monkey){
     try{
       //创建一个Session对象，声明开始修改票数事务
       HibernateUtil.getCurrentSession().beginTransaction();

       md.update(monkey);

       //提交事务，在Session与本地线程绑定的方式下，会自动关闭Session对象
       HibernateUtil.getCurrentSession().getTransaction().commit();

     }catch (RuntimeException e) {
       try{
          //撤销事务
          HibernateUtil.getCurrentSession().getTransaction().rollback();
       }catch(RuntimeException ex){
          ex.printStackTrace();
       }
       throw e;
     }
   }

   public static void main(String args[]) throws Exception {
     new BusinessService1().vote();
   }
 }

8.

 package mypack;
 import java.io.*;
 import java.util.Scanner;
 import org.hibernate.*;

 public class BusinessService2{
   private MonkeyDAO2 md=new MonkeyDAO2();

   public void vote()throws Exception{
     Session session=null;
     try{
       System.out.println("请输入候选者的ID：");
       //等待用户输入候选者的ID，此操作可能会化去很长时间，取决于用户的思考时间
       long monkeyId=new Scanner(System.in).nextLong(); 

       //创建一个Session对象,由程序自主管理Session对象的生命周期
       session=HibernateUtil.getSessionFactory().openSession();
       //设为手工清理缓存模式
       session.setFlushMode(FlushMode.MANUAL);

       //声明开始查询候选者事务
       session.beginTransaction();
       Monkey monkey=md.getById(monkeyId,session);
       //提交查询候选者事务,释放Session占用的数据库连接
       session.getTransaction().commit();

       System.out.println("候选者的当前票数为："+monkey.getCount());

       System.out.println("您确信要投票吗(Y/N)：");
       //等待用户确认是否投票，此操作可能会花去很长时间，取决于用户的思考时间
       String flag=new Scanner(System.in).next();
       if(flag.equals("N"))return;

       monkey.setCount(monkey.getCount()+1);

       //声明开始修改票数事务，为Session重新分配数据库连接
       session.beginTransaction();
       md.update(monkey,session); 

       //清理缓存
       session.flush();

       //提交修改票数事务
       session.getTransaction().commit();

       System.out.println("投票成功，候选者的当前票数为："+monkey.getCount());
     }catch (RuntimeException e) {
       try{
          //撤销事务
          session.getTransaction().rollback();
       }catch(RuntimeException ex){
          ex.printStackTrace();
       }
       throw e;
     }finally{
       session.close();
     }
   }

   public static void main(String args[]) throws Exception {
     new BusinessService2().vote();
   }
 }

9.

 /** 运行此程序时，
 必须把hibernate.cfg.xml文件中的current_session_context_class属性设为managed
 */

 package mypack;
 import java.io.*;
 import java.util.Scanner;
 import org.hibernate.classic.Session;
 import org.hibernate.context.ManagedSessionContext;
 import org.hibernate.FlushMode;

 public class BusinessService3{
   private MonkeyDAO md=new MonkeyDAO();

   public void vote()throws Exception{
     Session session=null;
     try{
       System.out.println("请输入候选者的ID：");
       //等待用户输入候选者的ID，此操作可能会化去很长时间，取决于用户的思考时间
       long monkeyId=new Scanner(System.in).nextLong(); 

       //创建一个Session对象,由程序自主管理Session对象的生命周期
       session=HibernateUtil.getSessionFactory().openSession();
       //设为手工清理缓存模式
       session.setFlushMode(FlushMode.MANUAL);
       ManagedSessionContext.bind(session);

       //声明开始查询候选者事务
       session.beginTransaction();
       Monkey monkey=md.getById(monkeyId);

       ManagedSessionContext.unbind(HibernateUtil.getSessionFactory());

       //提交查询候选者事务,释放Session占用的数据库连接
       session.getTransaction().commit();
       System.out.println("候选者的当前票数为："+monkey.getCount());

       System.out.println("您确信要投票吗(Y/N)：");
       //等待用户确认是否投票，此操作可能会花去很长时间，取决于用户的思考时间
       String flag=new Scanner(System.in).next();
       if(flag.equals("N"))return;

       monkey.setCount(monkey.getCount()+1);

       ManagedSessionContext.bind(session);

       //声明开始修改票数事务，为Session重新分配数据库连接
       session.beginTransaction();
       md.update(monkey); 

       ManagedSessionContext.unbind(HibernateUtil.getSessionFactory());

       //清理缓存
       session.flush();

       //提交修改票数事务
       session.getTransaction().commit();

       System.out.println("投票成功，候选者的当前票数为："+monkey.getCount());
     }catch (RuntimeException e) {
       try{
          //撤销事务
          session.getTransaction().rollback();
       }catch(RuntimeException ex){
          ex.printStackTrace();
       }
       throw e;
     }finally{
       session.close();
     }
   }

   public static void main(String args[]) throws Exception {
     new BusinessService3().vote();
   }
 }

10.

 <?xml version="1.0" encoding="utf-8" ?>
 <!DOCTYPE hibernate-configuration
  PUBLIC "-//Hibernate/Hibernate Configuration DTD//EN"
  "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
 <hibernate-configuration>
     <session-factory>
         <property name="dialect">
             org.hibernate.dialect.MySQLDialect
         </property>
         <property name="connection.driver_class">
             com.mysql.jdbc.Driver
         </property>
         <property name="connection.url">
             jdbc:mysql://localhost:3306/sampledb
         </property>
         <property name="connection.username">
             root
         </property>
         <property name="connection.password">
             1234
         </property>
         <property name="show_sql">true</property>
         <!--
 <property name="current_session_context_class">managed</property>
 -->
         <property name="current_session_context_class">thread</property>
         <mapping resource="mypack/Monkey.hbm.xml" />
     </session-factory>
 </hibernate-configuration>

11.

12.

13.