operatedb.java

该代码是Java数据库高级编程宝典中的重要的代码

package jdbcbook.shopping.database;

import org.apache.ojb.broker.PersistenceBroker;
import org.apache.ojb.broker.PersistenceBrokerFactory;
import org.apache.ojb.broker.PersistenceBrokerException;
import org.apache.ojb.broker.metadata.FieldHelper;
import org.apache.ojb.broker.query.Query;
import org.apache.ojb.broker.query.QueryByCriteria;
import org.apache.ojb.broker.query.Criteria;
import org.apache.ojb.broker.query.QueryFactory;
import org.apache.ojb.broker.query.ReportQueryByCriteria;

import java.util.*;
import java.sql.*;
import java.io.*;

/**
 * 数据库操作工具类
 */
public class OperateDB
{
	/**
	 * 保存一个对象到数据库中
	 */
	public static void storeData( Object obj )
			    throws PersistenceBrokerException
	{
		PersistenceBroker broker = null;
		try
		{
			broker = PersistenceBrokerFactory.defaultPersistenceBroker();
			broker.beginTransaction();
			broker.store( obj );
			broker.commitTransaction();
			broker.clearCache();
		}
		catch (PersistenceBrokerException ex)
		{
			if( null!=broker ) broker.abortTransaction();
			ex.printStackTrace();
			throw ex;
		}
		finally
		{
			if( null!=broker ) broker.close();
		}
	}

	/**
	 * 通过主键的值，来得到对应的对象
	 */
	public static Object getObjectByID( Class targetClass, int nID )
	{
		Criteria criteria = new Criteria();
		criteria.addEqualTo( "id", nID );
		return getData( targetClass, criteria );
	}

	/**
	 * 得到符合查询条件的某个对象的信息
	 */
	public static Object getData( Class targetClass, Criteria criteria )
	{
		return getData( new QueryByCriteria( targetClass, criteria ) );
	}

	/**
	 * 得到符合条件的某个对象的信息
	 */
	public static Object getDataByTemplate( Object obj )
	{
		return getData( new QueryByCriteria( obj ) );
	}

	/**
	 * 得到符合条件的所有对象的信息
	 */
	public static Collection getDatasByTemplate( Object obj )
	{
		return getDatas( new QueryByCriteria( obj ) );
	}

	/**
	 * 得到数据库中所有对象的信息
	 */
	public static Collection getDatas( Class targetClass )
	{
		return getDatas( targetClass, null, new Vector() );
	}

	/**
	 * 按照种顺序得到数据库中所有对象的信息
	 */
	public static Collection getDatas( Class targetClass, String order )
	{
		return getDatas( targetClass, null, disposeOrder( order ) );
	}

	/**
	 * 得到符合条件的对象信息
	 */
	public static Collection getDatas( Class targetClass, Criteria criteria )
	{
		return getDatas( targetClass, criteria, new Vector() );
	}

	/**
	 * 按照某种顺序得到符合条件的对象信息
	 */
	public static Collection getDatas( Class targetClass, Criteria criteria, Collection order )
									throws PersistenceBrokerException
	{
		return  getDatas( getQuery( targetClass, criteria, order ) );
	}

	/**
	 * 按照某种顺序得到符合条件的对象信息
	 */
	public static Collection getDatas( Class targetClass, Criteria criteria, String order )
									throws PersistenceBrokerException
	{
		return getDatas( targetClass, criteria, disposeOrder( order ) );
	}

	/**
	 * 按照某种顺序生成一个查询
	 */
	private static Query getQuery( Class targetClass, Criteria criteria, Collection order )
	{
		QueryByCriteria query = QueryFactory.newQuery( targetClass, criteria );
		if( order!=null && !order.isEmpty() )
		{
			Iterator it = order.iterator();
			while( it.hasNext() )
			{
				FieldHelper fh = (FieldHelper)it.next();
				query.addOrderBy( fh );
			}
		}
		return query;
	}


	/**
	 * 将排序字符串处理成FieldHelper的集合
	 */
	private static Collection disposeOrder( String order )
	{
		Vector vt = new Vector();
		if( order!=null && order.length()>0 )
		{
			StringTokenizer st = new StringTokenizer( order, "," );
			while( st.hasMoreTokens() )
			{
				String str = st.nextToken().trim();
				int nBlank = str.indexOf( " " );
				boolean ascend = true;
				if( nBlank != -1 )
				{
					String strOrder = str.substring( nBlank ).trim().toUpperCase();
					if( "DESC".equals( strOrder ) || "DESCEND".equals( strOrder ) )
					{
						ascend = false;
					}
					str = str.substring( 0, nBlank );
				}
				FieldHelper fh = new FieldHelper( str, ascend );
				vt.add( fh );
			}
		}
		return vt;
	}

	/**
	 * 通过查询得到结果集合
	 */
	public static Collection getDatas( Query query )
								throws PersistenceBrokerException
	{
		PersistenceBroker broker = null;
		try
		{
		    broker = PersistenceBrokerFactory.defaultPersistenceBroker();
		    return  broker.getCollectionByQuery(query);
		}
		catch (PersistenceBrokerException ex)
		{
		    ex.printStackTrace();
		    throw ex;
		}
		finally
		{
		    if( null!=broker ) broker.close();
		}
	}

	/**
	 * 通过查询得到结果对象
	 */
	public static Object getData( Query query )
								throws PersistenceBrokerException
	{
		PersistenceBroker broker = null;
		try
		{
		    broker = PersistenceBrokerFactory.defaultPersistenceBroker();
		    return  broker.getObjectByQuery(query);
		}
		catch (PersistenceBrokerException ex)
		{
		    ex.printStackTrace();
		    throw ex;
		}
		finally
		{
		    if( null!=broker ) broker.close();
		}
	}

	/**
	 * 删除某个对象所对应的记录
	 */
	public static void deleteData( Object obj )
			    throws PersistenceBrokerException
	{
		PersistenceBroker broker = null;
		try
		{
			broker = PersistenceBrokerFactory.defaultPersistenceBroker();
			broker.beginTransaction();
			broker.delete( obj );
			broker.commitTransaction();
			broker.clearCache();
		}
		catch (PersistenceBrokerException ex)
		{
			if( null!=broker ) broker.abortTransaction();
			ex.printStackTrace();
			throw ex;
		}
		finally
		{
			if( null!=broker ) broker.close();
		}
	}

	/**
	 * 保存Blob
	 */
	public static void saveBlob( String sql, InputStream in, int size )
	{
		PersistenceBroker broker = null;
		try
		{
			broker = PersistenceBrokerFactory.defaultPersistenceBroker();
			broker.beginTransaction();
			Connection conn = broker.serviceConnectionManager().getConnection( );
			PreparedStatement pst = conn.prepareStatement( sql );
			ResultSet rs = pst.executeQuery();
			if( rs.next() )
			{
				oracle.sql.BLOB b = (oracle.sql.BLOB)rs.getBlob( 1 );
				BufferedOutputStream out = new BufferedOutputStream( b.getBinaryOutputStream() );
				byte[]  buf =   new byte[2048];
				while( true )
				{
				    int nRead   =   in.read( buf );
				    if( -1==nRead )
					        break;
				    out.write( buf, 0, nRead );
				}
				out.close();
				b.trim( size );
			}
			rs.close();
			pst.close();
			broker.commitTransaction();
			broker.clearCache();
		}
		catch (Exception ex)
		{
			if( null!=broker ) broker.abortTransaction();
			ex.printStackTrace();
		}
		finally
		{
			if( null!=broker ) broker.close();
		}
	}

	/**
	 * 输出大对象
	 */
	public static boolean outBlob( String sql, OutputStream out )
	{
		PersistenceBroker broker = null;
		boolean result = false;
		try
		{
			broker = PersistenceBrokerFactory.defaultPersistenceBroker();
			broker.beginTransaction();
			Connection conn = broker.serviceConnectionManager().getConnection( );
			Statement st = conn.createStatement();
			ResultSet rs = st.executeQuery( sql );
			if( rs.next() )
			{
				InputStream in = rs.getBinaryStream( 1 );
				if( in!=null )
				{
					byte[]  buf =   new byte[2048];
					while( true )
					{
					    int nRead   =   in.read( buf );
					    if( -1==nRead )
						        break;
					    out.write( buf, 0, nRead );
						result = true;
					}
					if( result )
					{
						out.flush();
						out.close();
					}
					in.close();
				}
			}
			rs.close();
			st.close();
			broker.commitTransaction();
			broker.clearCache();
		}
		catch (Exception ex)
		{
			if( null!=broker ) broker.abortTransaction();
			ex.printStackTrace();
		}
		finally
		{
			if( null!=broker ) broker.close();
		}
		return result;
	}

}