Oracle 大最插入數據 一段時間之后變慢問題解決方法

　　因為系統業務需要，需要從數據中心導入12年的歷史數據到系統。每天平均1000千左右。有一個表有200多個字段，基中還包括幾個clob字段。導入方式是用http向服務器一天一天的請求數據。每次請求一天。不能請求太多天，因為服務器請求太多天，有可能返回不了數據。導致失敗，Java的JDBC接口寫入。每次寫數據都是一條一條的寫入。剛開始還算順利，接口過來的數據都能寫入進數據庫。但問題出現在寫入1個月數據左右就開始慢慢的出現卡頓的情況。寫入一條記錄的數據，有時10幾秒，有幾幾分鍾。最壞的時候，就一條數據幾個小時還沒有寫入成功，導致整個同步進程嚴重擁堵。每次卡死之后，重啟數據庫服務又可以正常寫入。但每次寫入一段時候之后，又卡死。

試過以下方法都不見效：

1、停止所有的觸發器

2、接收數據表使用nologging表。

3、分次提交，一次不要只提交一條記錄。一次提交一天記錄。

最后在網上找到了解決方法。也是分次提交，但不是使用executeUpdate()執行，而是使用了先addBatch(), 再executeBatch()的方式。

 

具體見代碼中的：    public int executeBatch(String sql, List<Object[]> params) 方法。

附操作數據庫的代碼

package bh.ojdbc.util;

import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.log4j.Logger;

import bh.getjzdata.Para;
import bh.util.SetRW;
import bh.util.Tool;
 
/**
 * 對jdbc的完整封裝
 *
 */
public class JDBCUtil {
 
    private static Logger logger = Logger.getLogger(JDBCUtil.class);
	private static  String driver = null;
	private static  String url = null;
	private static  String username = null;
	private static  String password = null;
	
	private CallableStatement callableStatement = null;//創建CallableStatement對象      
	private Connection conn = null;
	private PreparedStatement pst = null;
	private ResultSet rst = null;
	
/*	static {    
        try {    
            // 加載數據庫驅動程序    
            Class.forName(driver);    
        } catch (ClassNotFoundException e) {    
            System.out.println("加載驅動錯誤");    
            System.out.println(e.getMessage());    
        }    
    } */   
    
	public JDBCUtil(){
		this.driver = Para.oracle_driver;
		this.url = Para.oracle_url;
		this.username = Para.oracle_userid;
		this.password = Para.oracle_password;
	
	}
	
	public JDBCUtil(String driver,String url ,String username,String password) {
		this.driver = driver;
		this.url = url;
		this.username = username;
		this.password = password;
	}
	
    /**  
     * 建立數據庫連接  
     * @return 數據庫連接  
     */    
    public Connection getConnection() {    
    	try{
        	if (this.conn!=null && !this.conn.isClosed()){
        		return this.conn;
        	}
    	}
    	catch(Exception e){
    		
    	}
        try {    
        	 // 加載數據庫驅動程序    

            try {
				Class.forName(driver);
			} catch (ClassNotFoundException e) {
				System.out.println("加載驅動錯誤");    
	            System.out.println(e.getMessage());  
				e.printStackTrace();
				logger.error(Tool.getExceptionDetail(e));
			} 
            // 獲取連接    
        	conn = DriverManager.getConnection(url, username,    
        			password);    
        } catch (SQLException e) {    
            System.out.println(e.getMessage());    
            logger.error(Tool.getExceptionDetail(e));
        }    
        return conn;    
    }    
    
    public int executeUpdate(String sql, Object[] params) { 
    	return executeUpdate(sql,params,true);
    }
    /**  
     * insert update delete SQL語句的執行的統一方法  
     * @param sql SQL語句  
     * @param params 參數數組，若沒有參數則為null  
     * @return 受影響的行數  
     */    
    public int executeUpdate(String sql, Object[] params,boolean isCloseAll) {    
        // 受影響的行數    
        int affectedLine = 0;    
            
        try {    
            // 獲得連接    
            conn = this.getConnection();  
            if (!isCloseAll && conn.getAutoCommit()){
            	conn.setAutoCommit(false);
            	
            }
            // 調用SQL     
            pst = conn.prepareStatement(sql);    
                
            // 參數賦值    
            if (params != null) {    
                for (int i = 0; i < params.length; i++) {    
                	pst.setObject(i + 1, params[i]);    
                }    
            }    
            /*在此 PreparedStatement 對象中執行 SQL 語句，
                                          該語句必須是一個 SQL 數據操作語言（Data Manipulation Language，DML）語句，比如 INSERT、UPDATE 或 DELETE 
                                          語句；或者是無返回內容的 SQL 語句，比如 DDL 語句。    */
            // 執行    
            affectedLine = pst.executeUpdate();
           
        } catch (SQLException e) { 
            if (e.getMessage().indexOf("數據重復")<=0){
	            System.out.println(e.getMessage());    
	            logger.error(Tool.getExceptionDetail(e));
	            logger.error(sql);
	            if (params != null) {    
	                for (int i = 0; i < params.length; i++) {    
	                	logger.error(params[i]);    
	                }    
	            } 
            }
            try{
            	conn.commit();
            }
            catch(Exception ex){
            	
            }
            //closeAll();
        } finally {   
        	try{
        		 pst.close();
        	}
        	catch(Exception e){
        		
        	}
        	if (isCloseAll){
            // 釋放資源    
        		closeAll();    
        	}
        }    
        return affectedLine;    
    }    
      
    
    
    /**  
     * insert update delete SQL語句的執行的統一方法  
     * @param sql SQL語句  
     * @param params 參數數組，若沒有參數則為null  
     * @return 受影響的行數  
     */    
    public int executeBatch(String sql, List<Object[]> params) {    
        // 受影響的行數    
        int affectedLine = 0;    
            
        try {    
            // 獲得連接    
            conn = this.getConnection();  
          	conn.setAutoCommit(false);
            // 調用SQL     
            pst = conn.prepareStatement(sql);    
                
            // 參數賦值    
            if (params != null) {
                for (int i = 0; i < params.size(); i++) {    
                	Object[] objs = params.get(i);
                    for (int j = 0; j < objs.length; j++) {    
                    	pst.setObject(j + 1, objs[j]);    
                    } 
                    pst.addBatch();
                }    
            }    
            /*在此 PreparedStatement 對象中執行 SQL 語句，
                                          該語句必須是一個 SQL 數據操作語言（Data Manipulation Language，DML）語句，比如 INSERT、UPDATE 或 DELETE 
                                          語句；或者是無返回內容的 SQL 語句，比如 DDL 語句。    */
            // 執行    
            pst.executeBatch();
           
        } catch (SQLException e) { 
        	//如果出現異常。重新執行單個插入。
        	try{
        		conn.rollback();
        	}
        	catch(Exception ex){
        		
        	}
            if (params != null) {
                for (int i = 0; i < params.size(); i++) {    
                  	this.executeUpdate(sql, params.get(i), false);
               }    
            }           	

        } finally {   
        	try{
        		 pst.close();
        	}
        	catch(Exception e){
        		
        	}
        	closeAll();
        }    
        return affectedLine;    
    }    
    
    /**  
     * SQL 查詢將查詢結果直接放入ResultSet中  
     * @param sql SQL語句  
     * @param params 參數數組，若沒有參數則為null  
     * @return 結果集  
     */    
    private ResultSet executeQueryRS(String sql, Object[] params) {    
        try {    
            // 獲得連接    
            conn = this.getConnection();    
                
            // 調用SQL    
            pst = conn.prepareStatement(sql);    
                
            // 參數賦值    
            if (params != null) {    
                for (int i = 0; i < params.length; i++) {    
                	pst.setObject(i + 1, params[i]);    
                }    
            }    
                
            // 執行    
            rst = pst.executeQuery();    
    
        } catch (SQLException e) {    
            System.out.println(e.getMessage());    
            logger.error(Tool.getExceptionDetail(e));
        }     
    
        return rst;    
    }    
        
    /**  
     * SQL 查詢將查詢結果：一行一列  
     * @param sql SQL語句  
     * @param params 參數數組，若沒有參數則為null  
     * @return 結果集  
     */    
    public Object executeQuerySingle(String sql, Object[] params) {    
        Object object = null;    
        try {    
            // 獲得連接    
            conn = this.getConnection();    
                
            // 調用SQL    
            pst = conn.prepareStatement(sql);    
                
            // 參數賦值    
            if (params != null) {    
                for (int i = 0; i < params.length; i++) {    
                	pst.setObject(i + 1, params[i]);    
                }    
            }    
                
            // 執行    
            rst = pst.executeQuery();    
    
            if(rst.next()) {    
                object = rst.getObject(1);    
            }    
                
        } catch (SQLException e) {    
            System.out.println(e.getMessage());
            logger.error(Tool.getExceptionDetail(e));
            
        } finally {    
            closeAll();    
        }    
    
        return object;    
    }    
    
    /**  
     * 獲取結果集，並將結果放在List中  
     *   
     * @param sql  SQL語句  
     *         params  參數，沒有則為null   
     * @return List  
     *                       結果集  
     */    
    public List<Object> excuteQuery(String sql, Object[] params) {    
        // 執行SQL獲得結果集    
        ResultSet rs = executeQueryRS(sql, params);    
            
        // 創建ResultSetMetaData對象    
        ResultSetMetaData rsmd = null;    
            
        // 結果集列數    
        int columnCount = 0;    
        try {    
            rsmd = rs.getMetaData();    
                
            // 獲得結果集列數    
            columnCount = rsmd.getColumnCount();    
        } catch (SQLException e1) {    
            System.out.println(e1.getMessage());    
            logger.error(Tool.getExceptionDetail(e1));
        }    
    
        // 創建List    
        List<Object> list = new ArrayList<Object>();    
    
        try {    
            // 將ResultSet的結果保存到List中    
            while (rs.next()) {    
                Map<String, Object> map = new HashMap<String, Object>();    
                for (int i = 1; i <= columnCount; i++) {    
                    map.put(rsmd.getColumnLabel(i), rs.getObject(i));    
                }    
                list.add(map);//每一個map代表一條記錄，把所有記錄存在list中    
            }    
        } catch (SQLException e) {    
            System.out.println(e.getMessage());   
            logger.error(Tool.getExceptionDetail(e));
        } finally {    
            // 關閉所有資源    
            closeAll();    
        }    
    
        return list;    
    }    
        
    /**  
     * 存儲過程帶有一個輸出參數的方法  
     * @param sql 存儲過程語句  
     * @param params 參數數組  
     * @param outParamPos 輸出參數位置  
     * @param SqlType 輸出參數類型  
     * @return 輸出參數的值  
     */    
    public Object excuteQuery(String sql, Object[] params,int outParamPos, int SqlType) {    
        Object object = null;    
        conn = this.getConnection();    
        try {    
            // 調用存儲過程    
        	// prepareCall:創建一個 CallableStatement 對象來調用數據庫存儲過程。
            callableStatement = conn.prepareCall(sql);    
                
            // 給參數賦值    
            if(params != null) {    
                for(int i = 0; i < params.length; i++) {    
                    callableStatement.setObject(i + 1, params[i]);    
                }    
            }    
                
            // 注冊輸出參數    
            callableStatement.registerOutParameter(outParamPos, SqlType);    
                
            // 執行    
            callableStatement.execute();    
                
            // 得到輸出參數    
            object = callableStatement.getObject(outParamPos);    
                
        } catch (SQLException e) {    
            System.out.println(e.getMessage());    
            logger.error(Tool.getExceptionDetail(e));
        } finally {    
            // 釋放資源    
            closeAll();    
        }    
            
        return object;    
    }    
    
    /**  
     * 關閉所有資源  
     */    
    public  void closeAll() {    
        // 關閉結果集對象    
        if (rst != null) {    
            try {   
            	if (!rst.isClosed()){
            		rst.close();    
            	}
            } catch (SQLException e) {    
                System.out.println(e.getMessage());    
            }    
        }    
    
        // 關閉PreparedStatement對象    
        if (pst != null) {    
            try {    
            	if (!pst.isClosed()){
            		pst.close();    
            	}
            } catch (SQLException e) {    
                System.out.println(e.getMessage()); 
                logger.error(Tool.getExceptionDetail(e));
            }    
        }    
            
        // 關閉CallableStatement 對象    
        if (callableStatement != null) {    
            try {    
                callableStatement.close();    
            } catch (SQLException e) {    
                System.out.println(e.getMessage());    
                logger.error(Tool.getExceptionDetail(e));
            }    
        }    
    
        // 關閉Connection 對象    
        if (conn != null) {    
            try {    
            	if(!conn.getAutoCommit()&&!conn.isClosed()){
            		conn.commit();
            	}
            	if(!conn.isClosed()){
            		conn.close();
            	}
            } catch (SQLException e) {    
                System.out.println(e.getMessage());   
                logger.error(Tool.getExceptionDetail(e));
            }    
        }       
    }    
}