public  int  close()  {  
 
                       try  {  
                                   if  (res  !=  null)  {  
                                               res.close();  
                                   }  
                                   if  (stmt  !=  null)  {  
                                               stmt.close();  
                                   }  
                                   if  (pre  !=  null)  {  
                                               pre.close();  
                                   }  
 
                                   if  (conn  !=  null)  {  
                                               conn.close();  
                                   }  
 
                                   if  (cont  !=  null)  {  
                                               cont.close();  
                                   }  
                       }  catch  (NamingException  ex)  {  
                                   return  10008;  
                       }  catch  (SQLException  ex)  {  
                                   return  10009;  
                       }  
 
                       return  0;  
           }  
 
           public  void  setConnection(boolean  state)  {  
                       try  {  
                                   conn.setAutoCommit(state);  
                       }  catch  (SQLException  ex)  {  
                                   ex.printStackTrace();  
                       }  
           }  
 
public  boolean  getConnection()  {  
                       try  {  
                                   return  conn.getAutoCommit();  
                       }  catch  (SQLException  ex)  {  
                                   ex.printStackTrace();  
                                   return  false;  
                       }  
           }  
 
public  int  rollback()  {  
 
                       try  {  
                                   /*  判断数据库是否为开启状态  */  
                                   if  (conn  ==  null    ¦  ¦  conn.isClosed())  {  
                                               return  10010;  
                                   }  
                                   /*  判断数据库提交状态是否为手动提交  */  
                                   if  (conn.getAutoCommit()  ==  true)  {  
                                               return  10011;  
                                   }  
                                   /*  对数据库操作进行提交  */  
                                   conn.rollback();  
                       }  catch  (Exception  exception)  {  
                                   return  10012;  
                       }  
                       return  0;  
 
           }  

解决方案 »

  1.   

    public  int  commit()  {  
     
                           try  {  
                                       //  判断数据库是否为开启状态  
                                       if  (conn  ==  null    ¦  ¦  conn.isClosed())  {  
                                                   return  10013;  
                                       }  
                                       //  判断数据库提交状态是否为手动提交  
                                       if  (conn.getAutoCommit()  ==  true)  {  
                                                   return  10014;  
                                       }  
                                       //  对数据库操作进行提交  
                                       conn.commit();  
                           }  catch  (Exception  exception)  {  
                                       return  10015;  
                           }  
                           return  0;  
     
               }  
               public  int  sendUpdate(String  strSql)  {  
                           try  {  
                                       stmt.executeUpdate(strSql);  
                           }  catch  (SQLException  ex)  {  
                                       return  11001;  
                           }  
     
                           return  0;  
     
               }  
               public  int  sendExcute(String  strSql)  {  
                           try  {  
                                       res  =  stmt.executeQuery(strSql);  
                           }  catch  (SQLException  ex)  {  
                                       return  11002;  
                           }  
     
                           return  0;  
               }  
     
               public  int  addPreSQL(String  strSql,  Object[]  obj)  {  
     
                           try  {  
                                       setConnection(false);  
                                       pre  =  conn.prepareStatement(strSql);  
                                       for  (int  i  =  1;  i  <=  obj.length;  i++)  {  
                                                   pre.setObject(i,  obj[i]);  
                                       }  
                                       pre.addBatch();  
                           }  catch  (SQLException  ex)  {  
                                       return  11003;  
                           }  
     
                           return  0;  
               }  
               public  int  sendPreExcute()  {  
     
                           try  {  
                                       res  =  pre.executeQuery();  
                                       setConnection(true);  
                           }  catch  (SQLException  ex)  {  
                                       return  11004;  
                           }  
     
                           return  0;  
               }  
     
               public  int  sendPreUpdate(String  strSql,  Object[]  obj)  {  
     
                           try  {  
                                       pre.executeUpdate();  
                                       setConnection(true);  
                           }  catch  (SQLException  ex)  {  
                                       return  11005;  
                           }  
     
                           return  0;  
               }  
               public  int  sendPComUpdate(ArrayList  list)  {  
     
                           try  {  
                                       conn.setAutoCommit(false);  
                                       for  (int  i  =  0;  i  <  list.size();  i++)  {  
                                                   stmt.addBatch((String)  list.get(i));  
                                       }  
     
                                       stmt.executeBatch();  
                                       conn.commit();  
                                       conn.setAutoCommit(true);  
                           }  catch  (SQLException  ex)  {  
                                       ex.printStackTrace();  
                                       int  i  =  rollback();  
                                       if  (i  !=  0)  {  
                                                   return  i;  
                                       }  else  {  
                                                   return  11006;  
                                       }  
                           }  
                           return  0;  
               }  
               public  int  getResultRow(ResultSet  Result)  {  
                           try  {  
                                       if  (Result  ==  null)  {  
                                                   return  0;  
                                       }  
                                       Result.last();  
                                       ResultCount  =  Result.getRow();  
                                       Result.beforeFirst();  
                           }  catch  (SQLException  ex)  {  
                                       return  11007;  
                           }  
     
                           return  0;  
               }  
               public  int  getColumnCount(ResultSet  resultset)  {  
                           int  column  =  0;  
                           ResultSetMetaData  meta  =  null;  
                           try  {  
                                       meta  =  resultset.getMetaData();  
                                       column  =  meta.getColumnCount();  
                           }  catch  (Exception  ex)  {  
                                       ex.printStackTrace();  
                           }  
     
                           return  column;  
     
               }  
               public  String  getColumnType(ResultSet  resultset,  int  num)  {  
                           String  columntype  =  null;  
                           ResultSetMetaData  meta  =  null;  
                           try  {  
                                       meta  =  resultset.getMetaData();  
                                       columntype  =  meta.getColumnTypeName(num);  
                           }  catch  (SQLException  ex)  {  
                           }  
                           return  columntype;  
               }  
               public  String  getColumnName(ResultSet  resultset,  int  num)  {  
                           String  columnname  =  null;  
                           ResultSetMetaData  meta  =  null;  
                           try  {  
                                       meta  =  resultset.getMetaData();  
                                       columnname  =  meta.getColumnName(num);  
                           }  catch  (SQLException  ex)  {  
                           }  
                           return  columnname;  
               }  
               public  boolean  isClose()  {  
                           try  {  
                                       if  (db  ==  null)  {  
                                                   return  true;  
                                       }  
                                       if  (db.conn  ==  null)  {  
                                                   return  true;  
                                       }  
                                       if  (db.conn.isClosed())  {  
                                                   return  true;  
                                       }  else  {  
                                                   return  false;  
                                       }  
                           }  catch  (SQLException  ex)  {  
                                       return  true;  
                           }  
               }  
     
    }  
      

  2.   

    我的用的是Tomcat  5.0.30,其连接池配置文件如下:  
     <Context  debug=  "1  "  displayName=  "WebRoot  "  docBase=  "WebRoot  "  path=  "/  "  reloadable=  "true  "  >  
         <Resource  auth=  "Container  "  name=  "jdbc/connectDB  "  type=  "javax.sql.DataSource  "/  >  
         <ResourceParams  name=  "jdbc/connectDB  "  >  
             <parameter  >  
                 <name  >factory  </name  >  
                 <value  >org.apache.commons.dbcp.BasicDataSourceFactory  </value  >  
             </parameter  >  
             <parameter  >  
                 <name  >url  </name  >  
                 <value  >jdbc:microsoft:sqlserver://localhost:1433;databasename=zgwlls  </value  >  
             </parameter  >  
             <parameter  >  
                 <name  >maxWait  </name  >  
                 <value  >5000  </value  >  
             </parameter  >  
             <parameter  >  
                 <name  >maxActive  </name  >  
                 <value  >5  </value  >  
             </parameter  >  
             <parameter  >  
                 <name  >driverClassName  </name  >  
                 <value  >com.microsoft.jdbc.sqlserver.SQLServerDriver  </value  >  
             </parameter  >  
             <parameter  >  
                 <name  >maxIdle  </name  >  
                 <value  >2  </value  >  
             </parameter  >  
             <parameter  >  
                 <name  >username  </name  >  
                 <value  >用户名  </value  >  
             </parameter  >  
             <parameter  >  
                 <name  >password  </name  >  
                 <value  >*****  </value  >  
             </parameter  >  
             <parameter  >  
                 <name  >removeAbandoned  </name  >  
                 <value  >true  </value  >  
             </parameter  >  
             <parameter  >  
                 <name  >removeAbandonedTimeout  </name  >  
                 <value  >10  </value  >  
             </parameter  >  
             <parameter  >  
                 <name  >logAbandoned  </name  >  
                 <value  >true  </value  >  
             </parameter  >  
         </ResourceParams  >  
     </Context  >  
    因为在配置文件中设定每隔10秒(removeAbandoned这项)Tomcat就能自动关闭数据库连接,所以和程序访问数据库时就没有手工关闭数据库连接,但现在访问数据库隔一会儿就报如下的错误:  
    DBCP  object  created  2007-06-07  11:01:28  by  the  following  code  was  never  closed:  
    java.lang.Exception  
               at  org.apache.commons.dbcp.AbandonedTrace.init(AbandonedTrace.java:96)  
               at  org.apache.commons.dbcp.AbandonedTrace.  <init  >(AbandonedTrace.java:79)  
               at  org.apache.commons.dbcp.DelegatingStatement.  <init  >(DelegatingStatement.java:60)  
               at  org.apache.commons.dbcp.DelegatingConnection.createStatement(DelegatingConnection.java:173)  
               at  org.apache.commons.dbcp.PoolingDataSource$PoolGuardConnectionWrapper.createStatement(PoolingDataSource.java:209)  
               at  operate.DBOperate.PoolConnect(DBOperate.java:143)  
               at  operate.DBOperate.Connect(DBOperate.java:79)  
               at  dao.init.index.IndexINIT.  <init  >(IndexINIT.java:31)  
               at  org.apache.jsp.news.news_jsp._jspService(news_jsp.java:361)  
               at  org.apache.jasper.runtime.HttpJspBase.service(HttpJspBase.java:94)  
               at  javax.servlet.http.HttpServlet.service(HttpServlet.java:802)  
               at  org.apache.jasper.servlet.JspServletWrapper.service(JspServletWrapper.java:324)  
               at  org.apache.jasper.servlet.JspServlet.serviceJspFile(JspServlet.java:292)  
               at  org.apache.jasper.servlet.JspServlet.service(JspServlet.java:236)  
               at  javax.servlet.http.HttpServlet.service(HttpServlet.java:802)  
               at  org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:252)  
               at  org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:173)  
               at  tools.EncodingFilter.doFilter(EncodingFilter.java:55)  
               at  org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:202)  
               at  org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:173)  
               at  org.apache.catalina.core.StandardWrapperValve.invoke(StandardWrapperValve.java:214)  
               at  org.apache.catalina.core.StandardValveContext.invokeNext(StandardValveContext.java:104)  
               at  org.apache.catalina.core.StandardPipeline.invoke(StandardPipeline.java:520)  
               at  org.apache.catalina.core.StandardContextValve.invokeInternal(StandardContextValve.java:198)  
               at  org.apache.catalina.core.StandardContextValve.invoke(StandardContextValve.java:152)  
               at  org.apache.catalina.core.StandardValveContext.invokeNext(StandardValveContext.java:104)  
               at  org.apache.catalina.core.StandardPipeline.invoke(StandardPipeline.java:520)  
               at  org.apache.catalina.core.StandardHostValve.invoke(StandardHostValve.java:137)  
               at  org.apache.catalina.core.StandardValveContext.invokeNext(StandardValveContext.java:104)  
               at  org.apache.catalina.valves.ErrorReportValve.invoke(ErrorReportValve.java:118)  
               at  org.apache.catalina.core.StandardValveContext.invokeNext(StandardValveContext.java:102)  
               at  org.apache.catalina.core.StandardPipeline.invoke(StandardPipeline.java:520)  
               at  org.apache.catalina.core.StandardEngineValve.invoke(StandardEngineValve.java:109)  
               at  org.apache.catalina.core.StandardValveContext.invokeNext(StandardValveContext.java:104)  
               at  org.apache.catalina.core.StandardPipeline.invoke(StandardPipeline.java:520)  
               at  org.apache.catalina.core.ContainerBase.invoke(ContainerBase.java:929)  
               at  org.apache.coyote.tomcat5.CoyoteAdapter.service(CoyoteAdapter.java:160)  
               at  org.apache.coyote.http11.Http11Processor.process(Http11Processor.java:799)  
               at  org.apache.coyote.http11.Http11Protocol$Http11ConnectionHandler.processConnection(Http11Protocol.java:705)  
               at  org.apache.tomcat.util.net.TcpWorkerThread.runIt(PoolTcpEndpoint.java:577)  
               at  org.apache.tomcat.util.threads.ThreadPool$ControlRunnable.run(ThreadPool.java:684)  
               at  java.lang.Thread.run(Thread.java:595)  
    这个问题最后导致服务器崩溃,这个问题已经困扰我很久,在线等待诚请高手帮我解决!
      

  3.   

    at  operate.DBOperate.PoolConnect(DBOperate.java:143)
    设置一个断点,跟踪进去看看,最好单步跟踪!下回不要说服务器崩溃了,听着就毛骨悚然!
    如果是启动服务器出的问题,可能不是本工程出问题也有可能,tomcat是按照容器中工程名字的顺序来启动工程的,如果先前有工程出错哦了,就可能启动不了你要的工程了