connupdate.java

来自「cwbbs 云网论坛源码」· Java 代码 · 共 312 行

package cn.js.fan.db;

import java.sql.*;
import javax.naming.Context;
import javax.sql.DataSource;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import org.apache.log4j.Logger;
import cn.js.fan.web.Global;
import cn.js.fan.web.*;

public class ConnUpdate {
    
    boolean debug = true;
    java.sql.Connection con = null;

    Statement stmt = null;
    PreparedStatement prestmt = null;

    ResultSet rs = null;
    ResultSetMetaData resultsMeta = null;
    int rows = 0;
    int columns = 0;
    String PoolName = null;
    String DBDriver = "";  
    String ConnStr = "";   

    Logger logger;
    boolean isUsePool = false;

    
    
    public ConnUpdate(String connname) {
        logger = Logger.getLogger(ConnUpdate.class.getName());

        isUsePool = Global.getDBInfo(connname).isUsePool;
        DBDriver = Global.getDBInfo(connname).DBDriver;
        ConnStr = Global.getDBInfo(connname).ConnStr;
        PoolName = Global.getDBInfo(connname).PoolName;

        if (isUsePool)
          initUsePool();
        else
          initNotUsePool();
    }

    public void initNotUsePool() {
      try {
          Class.forName(DBDriver);
      }
      
      catch (java.lang.ClassNotFoundException e) {
          logger.error(
                  "警告:Class not found exception occur. Message is:");
          logger.error(e.getMessage());
      }
      
      try {
          con = DriverManager.getConnection(ConnStr);
      }
      
      catch (SQLException e) {
          logger.error("SQL Exception occur. Message is:");
          logger.error(e.getMessage());
      }
    }

    public void initUsePool() {
      try {
        Context initCtx = new InitialContext();
        Context envCtx = (Context) initCtx.lookup("java:comp/env");
        DataSource ds = (DataSource) envCtx.lookup(PoolName);
        con = ds.getConnection();
      }
      
      catch (NamingException e) {
        logger.error("Connection pool fail. Message is:");
        logger.error(e.getMessage());
      }
      catch (SQLException e) {
        logger.error("SQL Exception occur. Message is:");
        logger.error(e.getMessage());
      }
    }

    public java.sql.Connection getCon() {
        return this.con;
    }

    
    public ResultSet executeQuery(String sql) throws SQLException {
        if (con == null)
            return null;
        if (stmt==null)
            stmt = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
                                       ResultSet.CONCUR_UPDATABLE);
        ResultSet rs = null;
        try {
            rs = stmt.executeQuery(sql);
        } catch (SQLException e) {
            System.out.print("Query:" + sql + "=" + e.getMessage());
            throw e;
        }
        this.rs = rs;
        return rs;
    }

    
    public int executeUpdate(String sql) throws SQLException {
        if (stmt == null)
            stmt = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
                                       ResultSet.CONCUR_READ_ONLY);
        int rowcount = 0;
        if (con == null)
            return 0;
        try {
            rowcount = stmt.executeUpdate(sql);
        } catch (SQLException e) {
            if (debug) {
                System.out.println("Update:" + sql + "--" + e.getMessage());
            }
            throw e;
        } finally {

        }
        return rowcount;
    }

    
    public int getColumns() {
        int columns = 0;
        try {
            this.resultsMeta = this.rs.getMetaData();
            columns = this.resultsMeta.getColumnCount();
        } catch (SQLException e) {}
        return columns;
    }

    
    public int getRows() {
        rows = 0;
        try {
            
            rs.last();
            rows = rs.getRow();
            rs.beforeFirst();
        } catch (SQLException e) {
            System.out.println("getRows error:" + e.getMessage());
        }
        return this.rows;
    }

    protected void finalize() throws Throwable {
        super.finalize();
        try {
            if (stmt != null) {
                stmt.close();
                stmt = null;
            }
        } catch (SQLException e) {
            System.out.println("Conn finalize: " + e.getMessage());
        }
        try {
            if (prestmt != null) {
                prestmt.close();
                prestmt = null;
            }
        } catch (SQLException e) {
            System.out.println("Conn finalize: " + e.getMessage());
        }

        try {
            if (con != null && !con.isClosed()) {
                con.close();
                con = null; 
            }
        } catch (SQLException e) {
            System.out.println("Conn finalize: " + e.getMessage());
        }
    }

    public void close() { 
        try {
            finalize();
        } catch (java.lang.Throwable e) {
            System.out.println("conn.close error:" + e.getMessage());
        }
    }

    public void beginTrans() throws SQLException {
        if (!Global.isTransactionSupported)
            return;
        try {
            
            con.setAutoCommit(false);
        } catch (SQLException ex) {
            ex.printStackTrace();
            System.out.print("beginTrans Errors");
            throw ex;
        }
    }

    public void commit() throws SQLException {
        if (!Global.isTransactionSupported)
            return;
        try {
            con.commit();
            con.setAutoCommit(true);
        } catch (SQLException ex) {
            ex.printStackTrace();
            System.out.print("Commit Errors");
            throw ex;
        }
    }

    public void rollback() {
        if (!Global.isTransactionSupported)
            return;
        try {
            con.rollback();
            con.setAutoCommit(true);
        } catch (SQLException ex) {
            ex.printStackTrace();
            System.out.print("Rollback Errors");
            
        }
    }

    public boolean getAutoCommit() throws SQLException {
        boolean result = false;
        try {
            result = con.getAutoCommit();
        } catch (SQLException ex) {
            ex.printStackTrace();
            System.out.println("getAutoCommit fail" + ex.getMessage());
            throw ex;
        }
        return result;
    }

    public int getTransactionIsolation() throws SQLException {
        int re = 0;
        try {
            re = con.getTransactionIsolation();
        } catch (SQLException e) {
            e.printStackTrace();
            System.out.println("getTransactionIsolation fail" + e.getMessage());
        }
        return re;
    }

    public void setFetchSize(int s) {
        try {
            stmt.setFetchSize(s);
        } catch (SQLException e) {
            System.out.println("setFetchSize fail:" + e.getMessage());
        }

    }

    
    public void setMaxRows(int maxRows) throws
            SQLException {
        try {
            stmt.setMaxRows(maxRows);
        } catch (Throwable t) {
            
            
            
            
            
            System.out.println("conn.setMaxRows:" + t.getMessage());
        }
    }

    public PreparedStatement prepareStatement(String sql) throws SQLException {
        prestmt = con.prepareStatement(sql, ResultSet.TYPE_SCROLL_INSENSITIVE,
                                       ResultSet.CONCUR_UPDATABLE);
        return prestmt;
    }

    public ResultSet executePreQuery() throws SQLException {
        try {
            rs = prestmt.executeQuery();
        }
        catch (SQLException e) {
            System.out.print("Query:" + prestmt.toString() + "---" + e.getMessage());
            throw e;
        }

        return rs;
    }

    
    public int executePreUpdate() throws SQLException {
        int rowcount = 0;
        if (con == null)
            return 0;
        try {
            rowcount = prestmt.executeUpdate();
        } catch (SQLException e) {
            if (debug) {
                System.out.println("executePreUpdate:" + prestmt.toString() + "---"  + e.getMessage());
            }
            throw e;
        } finally {
            return rowcount;
        }
    }

}