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

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;
}
}

<?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>

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();
}

}

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);
}
}

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);
}
}

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);
}
}

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();
}
}

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();
}
}

/** 运行此程序时，
必须把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();
}
}

<?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>