数据库操作通用类

序号	方法名	参数	返回值	功能
1	DataBase	无	Void	构造函数
2	showConnNum	无	Void	在控件台显示当前连接池情况，连接数，总连接数等信息
3	getConnPool	无	Void	* 取得Tomcat连接池, 在server.xml 中配置的连接池 * 从连接池中取得连接
4	getMyConnPool	无	Void	* 创建连接池, 并取得连接 * 从由连接池类DBConnectionManager 创建的连接池
5	releaseMyConnPool	无	Boolean	释放我的连接池, 即由DBConnectionManager 创建的连接池
6	createConn	String drv String url String usr String pwd	Void	* 生成Oracle SQLServer 等的连接 * 不使用连接池
7	createConn	String drv String url	Void	生成Access连接
8	realaseConn	无	Void	释放的是当前类中, 通过各种方法取得的连接
9	QuerySql	String sql	ResultSet	执行查询sql 语句, 并返回执行结果
10	ExceuteSql	String sql	Int	执行删除sql 语句, 自动提交, 成功返回0,失败返回错误代码
11	getOnePage	String sql int page int records	Vector	执行查询sql 语句 将页号为page , 每页显示records条记录的结果集,以键/值对应的形式存入Hashtable 并存入Vector
12	getOnePage1	String sql int page int records Boolean b	Vector	执行查询sql 语句 将页号为page , 每页显示records条记录的结果集,以键/值对应的形式存入Hashtable 并存入Vector
13	getOnePage	String sql int page int records boolean useDic	Vector	执行查询sql 语句 将页号为page , 每页显示records条记录的结果集,以键/值对应的形式存入Hashtable 并存入Vector 如果useDic 为true , 从配置表中取每面显示记录数
14	getData	String sql	Vector	执行查询sql 语句 将结果以 列/值对应的存入Hashtabl中, 存入Vector
15	QueryClob	String table String wherestr String clobfield	String	查询 Clob型字段的值 将Clob结果转换为String , 并返回String
16	UpdateClob	String table String wherestr String clobfield String clobvalue	Int	将clobvalue 转换为clob 用转换后的clob 更新clobfield字段 成功返回0 , 失败返回错误代码
17	QueryBlob	String table String wherestr String blobfield	String	查询 Blob 型字段的值 将Blob 结果转换为String , 并返回String
18	UpdateBlob	String table String wherestr String blobfield String blobvalue	Int	将blobvalue 转换为blob 用转换后的blob 更新blobfield字段 成功返回0 , 失败返回错误代码
19	QueryBLOB_JNDI	String table String wherestr String blobfield	String	查询blob 型字段, 返回String
20	UpdateBLOB_JNDI	String table String wherestr String blobfield String blobvalue	Int	更新blob 型辽段
21	clobInsert	String sql String table String wherestr String clobfield String infile	Int	往数据库中插入一个新的CLOB对象 sql 是一条插入语句
22	clobModify	String table String wherestr String clobfield String infile	int	修改CLOB对象（是在原CLOB对象基础上进行覆盖式的修改）
23	clobReplace	String table String wherestr String clobfield String infile	Int	替换CLOB对象（将原CLOB对象清除，换成一个全新的CLOB对象）
24	blobInsert	String sql String table String wherestr String blobfield String infile	int	向数据库中插入一个新的BLOB对象
25	blobModify	String table String wherestr String blobfield             String infile	int	修改BLOB对象（是在原BLOB对象基础上进行覆盖式的修改）
26	blobReplace	String table String wherestr String blobfield String infile	int	替换BLOB对象（将原BLOB对象清除，换成一个全新的CLOB对象）
27	getDataBaseInfo		Hashtable	数据库信息(类型,版本,驱动等) 使用DatabaseMetaData类
28	getTableList		Vector	使用DatabaseMetaData类的getTables
29	getTableStruct	String table	Vector	数据表的结构(字段名,类型,是否为空,精度等) DatabaseMetaData类
30	getResultSetData	ResultSet rs	Vector	列/值 存入Hashtable, 将Hashtable 存入Vector中
31	prepareStatement	String sql	Void	用sql 创建表达, 为类变量pstm 赋值
32	executeQuery	无	void	执行查询, 执行变量pstm中设置的表达, 返回结果集赋给类变量rs
33	next	无	boolean	调用rs.next(), 转向下一条记录
34	getObject	String field String sqlType	String	取得数据并根据数据类型转化为字符串
35	setObject	int index String value String sqlType	Void	根据数据类型保存到数据库 根据将参数sqlType 将value 转换为相应的类型 调用 psmt.setObject(index, 转换后的value)
36	executeUpdate	无	Void	调用 psmt.executeUpdate() , 执行数据更新
37	closePstm	无	Void	调用 psmt.close(), 关闭表达对象
38	closeRs	无	Void	调用 rs.close(), 关闭结果集
39	setBinaryStream	int index InputStream is int t	Void	调用 pstm.setBinaryStream(index, is, t);
40	setAsciiStream	int index InputStream is int t	Void	调用 pstm.setBinaryStream(index, is, t);
41	getAutoCommit		boolean	调用conn.getAutoCommit(); 判断是否自动提交
42	closeAutoCommit		Void	调用 conn.setAutoCommit(false);
43	commit		Void	调用 conn.commit()
44	Rollback		Void	调用 conn.rollback()
45	openAutoCommit		Void	调用 conn.setAutoCommit(true)
46	createStatement		Void	调用 stm = conn.createStatement();
47	clearBatch		void	调用 stm.clearBatch();
48	addBatch		Void	调用 stm.addBatch(sql);
49	executeBatch		Int[]	调用 stm.executeBatch();
50	closeStm		Void	调用 stm.close()

 

---

    /**
     *  在控制台显示连接池情况
     * 
     * */
    public void showConnNUM()
    {
        /**---------------------------------------------------------------------------------------------------------------**/
        // 字符操作类
        DealString ds = new DealString();
        **---------------------------------------------------------------------------------------------------------------**/

        System.out.print("/r"  + ds.getDateTime().substring(11, 19)             + 
                "程序中调用连接累计数> "   + ds.toLengthStrRight(sumnum  + "", 10)      + 
                "当前非空闲的连接总数> "   + ds.toLengthStrRight(curnum    + "", 10)      + 
                "连接数(空闲+非空闲)  > "    + ds.toLengthStrRight(maxnum   + "", 10)      + 
                "超出连接数限制的请求> "   + ds.toLengthStrRight(isNullPool+ "", 10)      + 
                "DB未响应> "   + ds.toLengthStrRight(isOracleErr + "", 10) + 
                "JVM垃圾回收> "+ jvmcount + "  ");
    }

---

            // 控件台输出连接情况
            showConnNUM();
        } catch (NamingException e) {
            System.out.println("从数据池取得数据库连接时出错;/r/n错误为:" + e);
        } catch (SQLException e) {
            System.out.println("从数据池取得数据库连接时出错;/r/n错误为:" + e);
        }
    }

---

        // 判断方法是否执行成功, 连接为空返回false , 连接不为空返回true
        if (conn == null)
        {
            return false;
        } else {
            return true;
        }
    }

---

        // 控件台显示连接池情况
        showConnNUM();
        
        return b;
    }

---

            System.out.println("从自身建立数据库连接时出错;/r/n错误为:" + e);
        } catch (Exception et){
            System.out.println("从自身建立数据库连接时出错;/r/n错误为:" + et);
        }
    }

---

            /*控制台显示连接池情况 */
            showConnNUM();
        } catch (ClassNotFoundException ec){
            System.out.println("从自身建立数据库连接时出错;/r/n错误为:" + ec);
        } catch (SQLException e){
            System.out.println("从自身建立数据库连接时出错;/r/n错误为:" + e);
        } catch (Exception et){
            System.out.println("从自身建立数据库连接时出错;/r/n错误为:" + et);
        }
    }

---

            if (!connected)
            {
                throw new SQLException("数据库未连接！");
            }
            if (conn != null)
            {
                /***--------------------------------------------------------------------------------------------------------***/
                // 关闭连接
                conn.close();
                /***--------------------------------------------------------------------------------------------------------***/
                // 标识未连接
                connected = false;
                /***--------------------------------------------------------------------------------------------------------***/
                // 控件台显示连接池情况
                showConnNUM();
            }
        } catch (SQLException e){
            System.out.println("关闭数据库连接时出错;/r/n错误为:" + e);
        }
    }

---

---

            }
        }
        return rs;
    }

---

---

---

     *  @param1 sql String SQL 语句
     *  @param2 page int 页号
     *  @param3 records int 一页显示条数
     *  @param4 boolean b 
     * 
     *  @return vector 指定页显示数据矩阵
     * */
    public Vector getOnePage(String sql, int page, int records, boolean b)
    {

            while (rows > 0)
            {
                rs.next(); // 数据指针, 移到需显示当前页记录的位置
                rows--;
            }
            /**---------------------------------------------------------------------------------------------------------------**/

            // 字符操作类
            DealString ds = new DealString();
            /**---------------------------------------------------------------------------------------------------------------**/

            //查询当前页
            int j = 0; // 记录本页显示的记录数, 递增

                // 如遇到以下情况, 退出循环
                // 结果集为空 , 已显示记录数等于每页显示的记录数 
                // 总记录数为0 , 需要显示的页号大于总页数
                if (rs == null || j == records || temp == 0 || page > sum)
                {
                    break;
                }
                /***---------------------------------------------------------------------------------------------------------***/
                j++; // 显示的记录条数, 如果等于设定的每页显示记录数, 将退出本循环
                /***---------------------------------------------------------------------------------------------------------***/
                // 列数
                ResultSetMetaData rsmd = rs.getMetaData();
                int cols = rsmd.getColumnCount();
                /***---------------------------------------------------------------------------------------------------------***/
                Hashtable hash = new Hashtable();
                for (int i = 1; i <= cols; i++)
                {
                    // 列名
                    String field = ds.toString(rsmd.getColumnName(i));
                    // 列名对应的值
                    String value = ds.toString(rs.getString(i));
                    // 列名与列值存入哈希表
                    hash.put(field, value);
                }
                /***---------------------------------------------------------------------------------------------------------***/
                // 哈希表存入Vector
                vect.add(hash);
            } while (rs.next());
        } catch (SQLException sqle){
            System.out.println("执行SQL语句 " + sql + " 分页至第 " + page
                    + " 页时出错;错误为:" + sqle);
        } finally{
            closeRs();
            closePstm();
        }
        return vect;
    }

---

            // 总记录数

            // 移动指针位置到首记录

---

    /*
     *  @param1 sql String SQL语句
     *  
     *  @return Vector 存储对象为Hashtabl, 语句结果集对应的矩阵 
     * 
     *  返回SQL 语句执行后所得结果集, 存储为Hashtable 形式的vector 对象
     * */
    public Vector getData(String sql)
    {
        Vector vect = new Vector();
        try{
            /**---------------------------------------------------------------------------------------------------------------**/

            pstm = conn.prepareStatement(sql);
            rs   = pstm.executeQuery();
            /**---------------------------------------------------------------------------------------------------------------**/

            DealString ds = new DealString();
            /**---------------------------------------------------------------------------------------------------------------**/

            ResultSetMetaData rsmd = rs.getMetaData();
            int cols = rsmd.getColumnCount();
            /**---------------------------------------------------------------------------------------------------------------**/

            while (rs.next())
            {
                Hashtable hash = new Hashtable();
                for (int i = 1; i <= cols; i++)
                {
                    String field   = ds.toString(rsmd.getColumnName(i));
                    String value = ds.toString(rs.getString(i));
                    hash.put(field, value);
                }
                /***--------------------------------------------------------------------------------------------------------***/
                vect.add(hash);
                /***--------------------------------------------------------------------------------------------------------***/
            }
        } catch (SQLException sqle){
            System.out.println("执行DataBase::getData(String)执行SQL语句 " + sql
                    + " 时出错;错误为:" + sqle);
        } finally{
            if (rs != null)
            {
                try{
                    rs.close();
                } catch (SQLException e){
                    System.out
                            .println("执行DataBase::getData(String)试图释放rs时出错;/r/n错误为:"
                                    + e);
                }
            }
            if (pstm != null)
            {
                try{
                    pstm.close();
                } catch (SQLException e){
                    System.out
                            .println("执行DataBase::getData(String)试图释放pstm时出错;/r/n错误为:"
                                    + e);
                }
            }
        }
        return vect;
    }

---

    /** 
     * 查询BLOB类型值 
     * 
     * @param1 table String 表名
     * @param2 wherestr String 条件
     * @param3 blobfield String blob类型字段
     * 
     * @return String blob转换成string 返回
     * */
    public String QueryBLOB(String table, String wherestr, String blobfield)
    {
        String out = "";
        try{
            String sqlCommand = "select " + blobfield + " from " + table;
            if (!wherestr.equals(""))
            {
                sqlCommand = sqlCommand + " where " + wherestr;
            }
            pstm = conn.prepareStatement(sqlCommand);
            rs = pstm.executeQuery();
            if (rs.next())
            {
                oracle.sql.BLOB blob = (oracle.sql.BLOB) rs.getBlob(blobfield);
                if (blob != null)
                {
                    InputStream is = blob.getBinaryStream();
                    InputStreamReader isw = new InputStreamReader(is);
                    BufferedReader br = new BufferedReader(isw);
                    String s = br.readLine();
                    while (s != null)
                    {
                        out += s;
                        s = br.readLine();
                    }
                }
            }
            out = (new DealString()).Replace(out, "/"", "/"/"");
        } catch (SQLException sqle) {
            System.out.println("调用MyDataBase.QueryBLOB()函数错误:/r/n" + sqle);
        } catch (IOException iosql){
            System.out.println("调用MyDataBase.QueryBLOB()函数错误:/r/n" + iosql);
        } finally{
            if (rs != null)
            {
                try{
                    rs.close();
                } catch (SQLException e){
                    System.out.println("试图释放rs时出错;/r/n错误为:" + e);
                }
            }
            if (pstm != null)
            {
                try{
                    pstm.close();
                } catch (SQLException e){
                    System.out.println("试图释放pstm时出错;/r/n错误为:" + e);
                }
            }
        }
        return out;
    }

---

            /* 查询BLOB对象并锁定 */
            sqlCommand = "select " + blobfield + " from " + table;
            if (!wherestr.equals(""))
            {
                sqlCommand += " where " + wherestr;
            }
            sqlCommand += " for update";
            pstm.clearBatch();
            pstm.addBatch(sqlCommand);
            rs = pstm.executeQuery();
            
            while (rs.next())
            {
                /***--------------------------------------------------------------------------------------------------------***/
                /* 获取此BLOB对象 */
                oracle.sql.BLOB blob = (oracle.sql.BLOB) rs.getBlob(blobfield);
                BufferedOutputStream out = new BufferedOutputStream(blob.getBinaryOutputStream());
                byte b[] = blobvalue.getBytes();
                out.write(b,  0,  b.length);
            }
            /**-----------------------------------------------------------**/
            /* 正式提交 */
            conn.commit();
            conn.setAutoCommit(defaultCommit);
        } catch (SQLException sqle){
            System.out.println("调用MyDataBase.UpdateBLOB()函数错误:/r/n" + sqle);
            return sqle.getErrorCode();
        } catch (Exception e){
            System.out.println("调用MyDataBase.UpdateBLOB()出错:" + e);
        } finally{
            if (rs != null)
            {
                try{
                    rs.close();
                } catch (SQLException e){
                    System.out
                            .println("调用MyDataBase.UpdateBLOB()试图释放rs时出错;/r/n错误为:"
                                    + e);
                }
            }
            if (pstm != null)
            {
                try{
                    pstm.close();
                } catch (SQLException e){
                    System.out
                            .println("调用MyDataBase.UpdateBLOB()试图释放pstm时出错;/r/n错误为:"
                                    + e);
                }
            }
        }
        return 0;
    }   

---

            /* 恢复原提交状态 */
            conn.setAutoCommit(defaultCommit);
        } catch (SQLException sqle){
            System.out.println("调用DataBase.blobModify()函数错误:/r/n" + sqle);
            return sqle.getErrorCode();
        } catch (IOException iosql){
            System.out.println("调用DataBase.blobModify()函数错误:/r/n" + iosql);
        }
        return 0;
    }

---

            // 执行修改

            out = blobModify(table, wherestr, blobfield, infile);
        } catch (SQLException sqle) {
            System.out.println("调用DataBase.blobReplace()函数错误:/r/n" + sqle);
            return sqle.getErrorCode();
        }
        return out;
    }

---

            hash.put("1", dmd.getCatalogSeparator());
            hash.put("2", dmd.getCatalogTerm());
            hash.put("数据库类型名称", dmd.getDatabaseProductName());
            hash.put("数据库版本", dmd.getDatabaseProductVersion());
            hash.put("5", dmd.getDefaultTransactionIsolation() + "");
            hash.put("驱动版本(最大)", dmd.getDriverMajorVersion() + "");
            hash.put("驱动版本(最小)", dmd.getDriverMinorVersion() + "");
            hash.put("驱动名", dmd.getDriverName());
            hash.put("驱动版本", dmd.getDriverVersion());
            hash.put("10", dmd.getExtraNameCharacters());
            hash.put("11", dmd.getIdentifierQuoteString());
            hash.put("12", dmd.getMaxBinaryLiteralLength() + "");
            hash.put("最大行限定", dmd.getMaxRowSize() + "");
            hash.put("方案", dmd.getSchemaTerm());
            hash.put("日期函数", dmd.getTimeDateFunctions());
            hash.put("连接地址", dmd.getURL());
            hash.put("用户名", dmd.getUserName());
        } catch (SQLException sqle){
            System.out.println("调用DataBase.getDataBaseInfo()函数错误:/r/n" + sqle);
        } catch (AbstractMethodError e){
            System.out.println("调用DataBase.getDataBaseInfo()函数错误:/r/n" + e);
        }
        return hash;
    }

---

                //                               ORDER BY MSysObjects.Name");
            }else{
                DatabaseMetaData dmd = conn.getMetaData();
                String[] types = new String[1];
                types[0] = "TABLE";
                //types[1] = "VIEW"
                rs = dmd.getTables(null, ParentBean.DBName.toUpperCase(), "%", types);
            }
            System.out.println("000" + getResultSetData(rs));
            while (rs.next())
            {
                vect.add((new DealString()).toString(rs.getString("TABLE_NAME")));
            }
            rs.close();
        } catch (SQLException sqle){
            System.out.println("调用DataBase.getTableList()函数错误:/r/n" + sqle + sqle.getErrorCode());
        } catch (AbstractMethodError e){
            System.out.println("调用DataBase.getTableList()函数错误:/r/n" + e);
        }
        return vect;
    }

---

                r.close();
                Statement stst = r.getStatement();
                if (stst != null)
                    stst.close();
                vect.add(hash);
            }
            Statement stmt = rs.getStatement();
            rs.close();
            if (stmt != null)
                stmt.close();
            System.out.println("____" + vect);
        } catch (SQLException sqle){
            System.out.println("调用DataBase.getTableStruct()函数错误:/r/n" + sqle);
        } catch (AbstractMethodError e){
            System.out.println("调用DataBase.getTableStruct()函数错误:/r/n" + e);
        }
        return vect;
    }

---

    /** 
     * 取得数据集内容 
     * */
    public Vector getResultSetData(ResultSet rs)
    {
        Vector vect = new Vector();
        try{
            //取得列数和列名
            ResultSetMetaData rsmd = rs.getMetaData();
            int cols = rsmd.getColumnCount();
            while (rs.next())
            {
                Hashtable hash = new Hashtable();
                for (int i = 1; i <= cols; i++)
                {
                    DealString ds = new DealString();
                    String field = ds.toString(rsmd.getColumnName(i));
                    String value = ds.toString(rs.getString(i));
                    hash.put(field, value);
                }
                vect.add(hash);
            }
        } catch (SQLException sqle){
            System.out.println("调用DataBase.getResultSetData()函数错误:/r/n" + sqle);
        }
        return vect;
    }

---

    /** 
     * 创建申明对象 
     * */
    public void prepareStatement(String sql)
    {
        try{
            pstm = conn.prepareStatement(sql);
        } catch (SQLException sqle){
            System.out.println("调用DataBase.prepareStatement()函数错误:/r/n" + sqle);
        }
    }

---

    /** 
     * 执行查询 
     * */
    public void executeQuery()
    {
        try{
            rs = pstm.executeQuery();
        } catch (SQLException sqle){
            System.out.println("调用DataBase.executeQuery()函数错误:/r/n" + sqle);
        }
    }

---

    /** 
     * 转向下一条 
     * */
    public boolean next()
    {
        try{
            return rs.next();
        } catch (SQLException sqle){
            System.out.println("调用DataBase.next()函数错误:/r/n" + sqle);
        }
        return true;
    }

---

    /** 
     * 执行更新 
     * */
    public void executeUpdate()
    {
        try{
            pstm.executeUpdate();
        } catch (SQLException sqle){
            System.out.println("调用DataBase.executeUpdate()函数错误:/r/n" + sqle);
        }
    }

---

    /** 
     * 关闭申明对象 
     * */
    public void closePstm()
    {
        if (pstm != null)
            try{
                pstm.close();
            } catch (SQLException sqle){
                System.out.println("调用DataBase.closePstm()函数错误:/r/n" + sqle);
            }
    }

---

    /** 
     * 关闭游标 
     * */
    public void closeRs()
    {
        if (rs != null)
            try{
                rs.close();
            } catch (SQLException sqle){
                System.out.println("调用DataBase.closeRs()函数错误:/r/n" + sqle);
            }
    }

---

    public boolean getAutoCommit()
    {
        try {
            return conn.getAutoCommit();
        } catch (SQLException e){
        }
        return true;
    }

---

    public void closeAutoCommit()
    {
        try{
            conn.setAutoCommit(false);
        } catch (SQLException e){
        }
    }

---

    public void commit()
    {
        try{
            conn.commit();
        } catch (SQLException e){
        }
    }

---

    public void rollback()
    {
        try{
            conn.rollback();
        } catch (SQLException e){
        }
    }

---

    public void openAutoCommit()
    {
        try{
            conn.setAutoCommit(true);
        } catch (SQLException e){
        }
    }

---

    public void createStatement()
    {
        try{
            stm = conn.createStatement();
        } catch (SQLException e){
        }
    }

---

    public void clearBatch()
    {
        try{
            stm.clearBatch();
        } catch (SQLException e){
        }
    }

---

    public void addBatch(String sql)
    {
        try{
            stm.addBatch(sql);
        } catch (SQLException e){
        }
    }

---

    public int[] executeBatch()
    {
        try{
            return stm.executeBatch();
        } catch (SQLException e){
        }
        return null;
    }

---

    public void closeStm()//专门使用
    {
        if (stm != null)
            try{
                stm.close();
            } catch (SQLException e){
            }
    }

---

---