processdata.java

hibernate处理缓存.提高运行速度.

package com.holpe.database;

/**
 * <p>Title: </p>
 *
 * <p>Description: </p>
 *
 * <p>Copyright: Copyright (c) 2008</p>
 *
 * <p>Company: </p>
 *
 * @author liuxb
 * @version 1.0
 */
import java.io.Serializable;
import java.sql.DatabaseMetaData;
import java.util.List;

import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import java.sql.CallableStatement;

public abstract class ProcessData extends _DAOBase {
	public final static int MAX_TAG_COUNT = 5;// 限制每篇文章的标签最多五个
	public final static int MAX_TAG_LENGTH = 20;// 标签最大长度,字节

	/**
	 * 获取数据库的元信息
	 * 
	 * @return
	 */
	public static DatabaseMetaData metadata() {
		try {
			return getSession().connection().getMetaData();
		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;
	}

	/**
	 * 添加对象
	 * 
	 * @param cbean
	 */
	public static void save(Object cbean) {
		try {
			Session ssn = getSession();
			beginTransaction();
			ssn.merge(cbean);
			commit();
		} catch (HibernateException e) {
			rollback();
			throw e;
		}
	}
	/*
	 * public static void prosave(Object cbean){ try{ String procedure ="{call
	 * test(?,?,?)}"; Session session =
	 * HibernateSessionFactory.currentSession(); Transaction tx =
	 * session.beginTransaction(); Connection conn = session.connection();
	 * CallableStatement cstmt=conn.prepareCall(procedure); cstmt.setString(1,
	 * "aa"); cstmt.setString(2, "bb"); cstmt.setString(3, "cc");
	 * cstmt.executeUpdate(); commit(); }catch(HibernateException e){
	 * rollback(); throw e; }
	 *  }
	 */
	/**
	 * 添加对象
	 * 
	 * @param cbean
	 */
	protected static void saveOrUpdate(Object cbean) {
		try {
			Session ssn = getSession();
			beginTransaction();
			ssn.saveOrUpdate(cbean);
			commit();
		} catch (HibernateException e) {
			rollback();
			throw e;
		}
	}

	/**
	 * 删除对象
	 * 
	 * @param cbean
	 */
	protected static void delete(Object cbean) {
		try {
			Session ssn = getSession();
			beginTransaction();
			ssn.delete(cbean);
			commit();
		} catch (HibernateException e) {
			rollback();
			throw e;
		}
	}

	/**
	 * 根据主键删除某个对象
	 * 
	 * @param objClass
	 * @param key
	 * @return
	 */
	protected static int delete(Class objClass, Serializable key) {
		StringBuffer hql = new StringBuffer("DELETE FROM ");
		hql.append(objClass.getName());
		hql.append(" AS t WHERE t.id=?");
		return commitUpdate(hql.toString(), new Object[]{key});
	}

	protected static int delete(Class objClass, int key) {
		return delete(objClass, new Integer(key));
	}

	/**
	 * 写脏数据到数据库,把未提交的随后又被撤消的数据称为"脏数据" 通俗一点就是在几个并发进程中，当有若干个进程都用到了数据A，
	 * 比如当进程1刚刚读了A数据后，进程2就对A数据进行了某种计算操作， 将数据A的值改变了并保存了，此后进程1本想再次读取原A数据，
	 * 结果读取的却是已经改变的A数据，这样导致进程1的数据发生了错误， 就把此时进程1读取已经改变的A数据称为读“脏数据”。
	 */
	public static void flush() {
		try {
			Session ssn = getSession();
			if (ssn.isDirty()) {
				beginTransaction();
				ssn.flush();
				commit();
			}
		} catch (HibernateException e) {
			rollback();
			throw e;
		}
	}

	/**
	 * 根据主键加载对象
	 * 
	 * @param beanClass
	 * @param ident
	 * @return
	 */
	protected static Object getBean(Class beanClass, int id) {
		return getSession().get(beanClass, new Integer(id));
	}

	/**
	 * 执行统计查询语句
	 * 
	 * @param hql
	 * @param args
	 * @return
	 */
	protected static Number executeStat(String hql, Object[] args) {
		return (Number) uniqueResult(hql, args);
	}

	/**
	 * 执行统计查询语句
	 * 
	 * @param hql
	 * @param args
	 * @return
	 */
	protected static int executeStatAsInt(String hql, Object[] args) {
		return (executeStat(hql, args)).intValue();
	}

	protected static int executeStatAsInt(String hql, int parm1) {
		return executeStatAsInt(hql, new Object[]{new Integer(parm1)});
	}

	protected static int executeStatAsInt(String hql, int parm1, int parm2) {
		return executeStatAsInt(hql, new Object[]{new Integer(parm1),
				new Integer(parm2)});
	}

	protected static int executeStatAsInt(String hql, int parm1, int parm2,
			int parm3, int parm4) {
		return executeStatAsInt(hql, new Object[]{new Integer(parm1),
				new Integer(parm2), new Integer(parm3), new Integer(parm4)});
	}

	/**
	 * 执行统计查询语句
	 * 
	 * @param hql
	 * @param args
	 * @return
	 */
	protected static long executeStatAsLong(String hql, Object[] args) {
		return (executeStat(hql, args)).longValue();
	}

	/**
	 * 执行普通查询语句
	 * 
	 * @param hql
	 * @param args
	 * @return
	 */
	protected static List findAll(String hql, Object[] args) {
		return executeQuery(hql, -1, -1, args);
	}

	/**
	 * 执行普通查询语句
	 * 
	 * @param hql
	 * @param args
	 * @return
	 */
	protected static List executeQuery(String hql, int fromIdx, int fetchCount,
			Object[] args) {
		Session ssn = getSession();
		Query q = ssn.createQuery(hql);
		// String parm="";
		for (int i = 0; args != null && i < args.length; i++) {
			// parm=args[i].toString();
			q.setParameter(i, args[i]);
		}
		if (fromIdx > 0)
			q.setFirstResult(fromIdx);
		if (fetchCount > 0)
			q.setMaxResults(fetchCount);
		return q.list();
	}

	protected static List executeQuery(String hql, int fromIdx, int fetchCount,
			int parm1) {
		return executeQuery(hql, fromIdx, fetchCount, new Object[]{new Integer(
				parm1)});
	}

	protected static List executeQuery(String hql, int fromIdx, int fetchCount,
			int parm1, int parm2) {
		return executeQuery(hql, fromIdx, fetchCount, new Object[]{
				new Integer(parm1), new Integer(parm2)});
	}

	protected static List executeQuery(String hql, int fromIdx, int fetchCount,
			int parm1, int parm2, int parm3) {
		return executeQuery(hql, fromIdx, fetchCount, new Object[]{
				new Integer(parm1), new Integer(parm2), new Integer(parm3)});
	}

	/**
	 * 执行更新语句
	 * 
	 * @param hql
	 * @param args
	 * @return
	 */
	protected static int executeUpdate(String hql, Object[] args) {
		try {
			Session ssn = getSession();
			Query q = ssn.createQuery(hql);
			// System.out.println("sql===" + q);
			for (int i = 0; args != null && i < args.length; i++) {
				// System.out.println("1111===" + args[i].toString());
				// q.setParameter(i, args[i].toString());
				q.setParameter(i, args[i]);
			}
			return q.executeUpdate();
		} catch (HibernateException e) {
			e.printStackTrace();
		}
		return 0;
	}

	protected static int executeUpdate(String hql, int parm1) {
		return executeUpdate(hql, new Object[]{new Integer(parm1)});
	}

	/**
	 * 执行更新语句
	 * 
	 * @param hql
	 * @param args
	 * @return
	 */
	protected static int commitUpdate(String hql, Object[] args) {
		try {
			Session ssn = getSession();
			beginTransaction();
			Query q = ssn.createQuery(hql);
			for (int i = 0; args != null && i < args.length - 1; i++) {
				q.setParameter(i, args[i]);
			}
			int er = q.executeUpdate();
			commit();
			return er;
		} catch (HibernateException e) {
			rollback();
			throw e;
		}
	}

	protected static int commitUpdate(String hql, int parm1, int parm2) {