datautil.java~1~

java系统通用框架 很实用的东东 一般人都看的懂,

package com.ibm.bisc.ebiz.util;

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

/**
 * DataObject类是用于派生来源于数据库的数据对象。利用DataObject提供
 * 的机制，派生的数据对象类可比较简便的实现从数据库中取出数值，将数据
 * 对象的数值插入或更新到数据库等功能。
 *
 * @author: Jim, Yang Jiang Ming
 */
public abstract class DataUtil {
	boolean m_bDebug = false;

	/** 该对象是否新创建，不存在于数据库中 */
	protected boolean m_bIsNewDataObject;

	/** 若该数据对象是由另一对象用loadObjects()方法创建的，该域指明创建者 */
	protected DataUtil m_objCreator;

	/**
	 * 缺省构造函数，创建一个新的数据对象。
	 */
	public DataUtil() {
		initNewObject();

		m_bIsNewDataObject = true;
	}
	/**
	 * 构造函数，用strWhere限定的条件从数据库中取出第一个符合条件
	 * 的结果，初始化数据对象。
	 * @param conn Connection 到数据库的连接
	 * @param strWhere String 限定条件
	 */
	public DataUtil(Connection conn, String strWhere) throws Exception {
		m_bIsNewDataObject = true;

		initNewObject();

		load(conn, strWhere);
	}
	/**
	 * 从数据库中删除符合指定条件的数据对象。
	 * @param conn Connection 到数据库的连接
	 * @param strWhere String 删除条件
	 */
	public void delete(Connection conn, String strWhere) throws Exception {
		boolean bAutoCommit = conn.getAutoCommit();
		conn.setAutoCommit(false);

		try {
			Statement stmt;
			String str;

			if (sqlDelete() == null)
				throw new Exception("试图在不支持删除的数据对象上执行删除操作。");

			str = sqlDelete().toUpperCase();

			if (str.indexOf(" WHERE ") != -1)
				str = str + " AND " + strWhere;
			else
				str = str + " WHERE " + strWhere;

			//删除
			stmt = conn.createStatement();
			stmt.executeUpdate(str);
			stmt.close();

			conn.commit();
		} catch (Exception e) {
			throw e;
		} finally {
			conn.rollback();
			conn.setAutoCommit(bAutoCommit);
		}
	}
	public void dump(PrintStream out) {
	}
	/**
	 * 将字符串中的"'"替换为"''"。
	 * 处理后的字符串可以用于拼接成要执行的SQL语句。
	 *
	 * @param str String 要处理的字符串
	 */
	static public String fixDBString(String str) {
		if (str == null)
			return "";

		if (str.indexOf('\'') == -1)
			return str;

		int strLen = str.length();
		StringBuffer sb = new StringBuffer();
		char c;

		for (int i = 0; i < strLen; i++) {
			c = str.charAt(i);
			sb.append(c);
			if (c == '\'') {
				sb.append('\'');
			}
		}

		return sb.toString();
	}
	/**
	 * 将字符串中的"'"替换为"''"，将超出长度的字符截去。
	 * 处理后的字符串可以用于拼接成要执行的SQL语句。
	 *
	 * @param str String 要处理的字符串
	 * @param dbLen int 长度
	 */
	protected String fixDBString(String str, int dbLen) {
		if (str == null) {
			return "";
		}

		int strLen = str.length();
		int len = 0;
		StringBuffer sb = new StringBuffer();
		char c;

		for (int i = 0; i < strLen; i++) {
			c = str.charAt(i);
			if (Character.UnicodeBlock.of(c) == Character.UnicodeBlock.BASIC_LATIN) {
				len++;
			} else {
				len += 2;
			}
			if (c == '\'') {
				len++;
			}
			if (len > dbLen) {
				break;
			}
			sb.append(c);
			if (c == '\'') {
				sb.append('\'');
			}
		}

		return sb.toString();
	}
	/**
	 * 将超出长度的字符串截去。
	 * 处理后的字符串可以用来准备PreparedStatement。
	 *
	 * @param str String 要处理的字符串，可以为null
	 * @param dbLen int 长度
	 */
	protected String fixLen(String str, int dbLen) {
		if (str == null)
			return null;

		int strLen = str.length();
		if (strLen * 2 < dbLen)
			return str;

		int len = 0;
		StringBuffer sb = new StringBuffer();
		char c;

		for (int i = 0; i < strLen; i++) {
			c = str.charAt(i);
			if (Character.UnicodeBlock.of(c) == Character.UnicodeBlock.BASIC_LATIN) {
				len++;
			} else {
				len += 2;
			}
			if (len > dbLen) {
				break;
			}
			sb.append(c);
		}

		return sb.toString();
	}
	/**
	 * 用于实现从数据库中读出数据对象。
	 * 从由sqlSelect(), sqlFrom(), sqlWhere()构造的SQL语句执行后产生的
	 * 结果集中取出数据。
	 * @param conn Connection 到数据库的连接
	 * @param rs ResultSet 包含数据对象数据的结果集
	 */
	protected void getFromResultSet(Connection conn, ResultSet rs)
		throws Exception {
	}
	protected void initNewObject() {
		m_objCreator = null;
	}
	/**
	 * 判断对象是否为新的数据对象（不是从数据库中读取出来的)
	 * @return boolean 如果对象不是从数据库中读取出来的，返回true，否则false
	 */
	public boolean isNewDataObject() {
		return m_bIsNewDataObject;
	}
	/**
	 * 用strWhere限定的条件从数据库中取出第一个符合条件的结果，填入当前对象
	 * @param conn Connection 到数据库的连接
	 * @param strWhere String 限定条件
	 */
	public boolean load(Connection conn, String strWhere) throws Exception {
		boolean bLoaded = true;
		Statement stmt;
		ResultSet rs;

		if (sqlFrom() == null)
			throw new Exception("试图在不支持从数据库读取的数据对象上执行读取操作。");

		//构造Where子句
		String strFullWhere = sqlWhere();

		if (strWhere != null)
			if (!strWhere.equals(""))
				if (!strFullWhere.equals(""))
					strFullWhere = strFullWhere + " and " + strWhere;
				else
					strFullWhere = strWhere;

		//取出对象
		stmt = conn.createStatement();
		rs =
			stmt.executeQuery(
				"select "
					+ sqlSelect()
					+ " from "
					+ sqlFrom()
					+ (strFullWhere.equals("") ? "" : " where " + strFullWhere)
					+ (sqlOrder().equals("") ? "" : " order by " + sqlOrder()));
		if (rs.next())
			getFromResultSet(conn, rs);
		else {
			bLoaded = false;
			System.out.println("CAUTION: Try to load object but failed.");
			System.out.println("Load from: " + sqlFrom());
			System.out.println("By: " + strWhere);
		}

		rs.close();
		stmt.close();

		if (bLoaded) {
			m_bIsNewDataObject = false;
			objectLoaded(conn);
		}

		return bLoaded;
	}
	/**
	 * 从数据库中读出所有数据对象
	 * @param conn Connection 到数据库的连接
	 * @return Vector 所有数据对象
	 */
	public Vector loadObjects(Connection conn) throws Exception {
		return loadObjects(conn, "");
	}
	/**
	 * 从数据库中读出所有符合条件的数据对象
	 * @param conn Connection 到数据库的连接
	 * @param String strWhere 查找条件
	 * @return Vector 符合条件的所有数据对象
	 */
	public Vector loadObjects(Connection conn, String strWhere) throws Exception {
		Statement stmt;
		ResultSet rs;
		Vector vec = new Vector();

		if (sqlFrom() == null)
			throw new Exception("试图在不支持从数据库读取的数据对象上执行读取操作。");

		//构造Where子句
		String strFullWhere = sqlWhere();

		if (strWhere != null)
			if (!strWhere.equals(""))
				if (!strFullWhere.equals(""))
					strFullWhere = strFullWhere + " and " + strWhere;
				else
					strFullWhere = strWhere;

		//{构造列表
		stmt = conn.createStatement();
		rs =
			stmt.executeQuery(
				"select "
					+ sqlSelect()
					+ " from "
					+ sqlFrom()
					+ (strFullWhere.equals("") ? "" : " where " + strFullWhere)
					+ (sqlOrder().equals("") ? "" : " order by " + sqlOrder()));

		//取出对象
		DataUtil dataObject;
		while (rs.next()) {
			dataObject = (DataUtil) getClass().newInstance();
			dataObject.objectCreated(this);
			dataObject.getFromResultSet(conn, rs);
			dataObject.m_bIsNewDataObject = false;
			vec.add(dataObject);
		}

		rs.close();
		stmt.close();
		//}

		for (int i = 0; i < vec.size(); i++)
			 ((DataUtil) vec.elementAt(i)).objectLoaded(conn);

		return vec;
	}
	/**
	 * 将数据库中符合指定条件的数据对象分页，取出位于指定页面的数据对象。
	 * @param conn Connection 到数据库的连接
	 * @param String strWhere 查找条件
	 * @param itemsPerPage 每页包含对象数
	 * @param pageNo 要取出的页面号，从1开始
	 */
	public DataObjectList loadObjects(
		Connection conn,
		String strWhere,
		int itemsPerPage,
		int pageNo)
		throws Exception {
		return loadObjects(conn, strWhere, itemsPerPage, pageNo, true);
	}
	/**
	 * 将数据库中符合指定条件的数据对象分页，取出位于指定页面的数据对象。
	 * @param conn Connection 到数据库的连接
	 * @param String strWhere 查找条件
	 * @param itemsPerPage 每页包含对象数
	 * @param pageNo 要取出的页面号，从1开始
	 * @param fixPageNo boolean 为true表示如果指定的pageNo不在目前分页范围内，
	 * 则将其调整到最接近的值；为false时不调整，返回的DataObjectList的列表为空。
	 */
	public DataObjectList loadObjects(
		Connection conn,
		String strWhere,
		int itemsPerPage,
		int pageNo,