：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.