为什么在Win98下好好的，Linux上就报空指针错误啊？（附代码）

你就用：
String a= “”；
try {
我来找这个表
a＝　“表存在”　；
}
catch (Exception ex) {
a = "表不存在" ;

}return a;

我在Install.java前面设的一个全局变量public String InstVer="";看看查询系统表可以不~~~~//别人说的
找不到表会抛出异常，对异常进行处理就可以了。
可以判断是否有某个表，这和具体数据库有关，一般是通过某个系统表查找。//我的不是对异常进行处理了的吗？JSP学得我晕晕啊~~~~~

try
      { rs = DBSQL.executeQuery(SQL);
        if (rs.next()) InstVer = rs.getString("version");
      }
    catch (SQLException e) { System.err.println("Get HadInstall Err!"); }//你能保证你这里catch了 “表不存在”时的异常了吗？
catch(Exception e)  ：）这样肯定ok!可以判断是否有某个表，这和具体数据库有关，一般是通过某个系统表查找。
//确实这样啊，不过这个和你用的数据库相关了：）查数据库系统表把~//btw: 我没看到你的install.java里面已经初始化了阿~ ：）

Tomcat4.1.18+MySQL3.23.46+JDK1.4.1//btw: 我没看到你的install.java里面已经初始化了阿~ ：）
呵呵，我就只贴了一个函数~~
public ResultSet executeQuery(String sql) throws SQLException
里面如果没存在表，不会抛出异常的啊？jinfeng_Wang你以前用C的啊，也开始用Java了啊？我以前用Delphi，才开始
学JSP不久~~一个空指针和中文乱码就快要我的命了~~以后请多多指教啊^_*

：）菜菜的说~~问题到底在哪儿，只有代码全部出来才能知道，：） tomcat出来4.1.18了？
我还以为我是最新的呢~ 我除了MS的东西，其余的都捣鼓过~ 嘿嘿~ delphi,CPP,asp,jsp 呵~ 中文的问题，我看你不是已经解决了？就是在头里面写入字符集！

好的啊，我贴一下吧，连接池的JavaBean是我网上找的
package ylvod.db;import java.sql.*;
import java.util.StringTokenizer;public class DbTrans
{ public static Connection conn=null;
  Statement stmt=null;
  boolean isAutoCommit=false;
  DBConnectionManager connMgr = null;  /* 构造函数 */
  public DbTrans(){ initConnection(); }  /* 带参数的构造函数 * @param conn 连接  */
  public DbTrans(Connection conn){ this.conn = conn; }  /* 初始化建立连接  */
  private void initConnection()
  { try
      { if(conn == null)
          { DBConnectionManager connMgr=DBConnectionManager.getInstance();
            conn = connMgr.getConnection("mysql"); }
      }
    catch(Exception ex){ System.out.println("Can not get new Connection"+ex.getMessage()); }
  }  public PreparedStatement getPreparedStmt(String sql) throws SQLException
  { PreparedStatement preStmt=null;
    try { preStmt = conn.prepareStatement(sql); }
    catch(SQLException ex)  { ex.printStackTrace();  throw ex;  }
    return preStmt;
  }  /* 过程开始 * @throws SQLException 捕捉错误  */
  public void beginTrans() throws SQLException
  { try { isAutoCommit = conn.getAutoCommit();
          conn.setAutoCommit(false);  }
    catch(SQLException ex) { ex.printStackTrace();
        System.out.print("beginTrans Errors");
        throw ex; }
  }  /* 数据事务提交 * @throws SQLException 捕捉错误 */
  public void commit() throws SQLException
  { try { conn.commit();
        conn.setAutoCommit(isAutoCommit);  }
    catch(SQLException ex) { ex.printStackTrace();
        System.out.print("Commit Errors!");
        throw ex; }
  }  /* 数据事务回滚 */
  public void roolback()
  { try { conn.rollback();
          conn.setAutoCommit(isAutoCommit); }
    catch(SQLException ex) { ex.printStackTrace();
          System.out.print("Roolback Error!");  }
  }  /* 判断是否为自动加入数据模式
   * @return boolean值
   * @throws SQLException 捕捉错误 */
  public boolean getAutoCommit() throws SQLException
  { boolean result = false;
    try { result = conn.getAutoCommit(); }
    catch(SQLException ex) { ex.printStackTrace();
          System.out.println("getAutoCommit fail "+ex.getMessage());
          throw ex; }
    return result;
  }  /* executeQuery操作，用于数据查询，主要是Select
   * @param sql 查询字段
   * @return 数据集
   * @throws SQLException 捕捉错误 */
  public ResultSet executeQuery(String sql) throws SQLException
  { ResultSet rs = null;
    try { stmt = conn.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,ResultSet.CONCUR_READ_ONLY);
          rs = stmt.executeQuery(sql);
          stmt.close();}
    catch (SQLException ex) { ex.printStackTrace();
          System.out.println("dbTrans.executeQuery:"+ex.getMessage());
          throw ex; }
    return rs;
  }  /* executeUpdate操作，用于数据更新，主要是Update，Insert
   * @param sql 查询字段
   * @throws SQLException 捕捉错误 */
  public boolean executeUpdate(String sql) throws SQLException
  { boolean ExeR=false;
   try { stmt = conn.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,ResultSet.CONCUR_UPDATABLE);
          stmt.executeUpdate(sql);
          stmt.close();
          ExeR=true;
        }
    catch (SQLException ex) { ex.printStackTrace();
        System.out.println("dbTrans.executeUpdate:"+ex.getMessage());
        throw ex; }
    return ExeR;
  }  public int[] doBatch(String sql) throws SQLException
  { int[] rowResult=null;
    String a;
    try{  stmt = conn.createStatement();
          StringTokenizer st=new StringTokenizer(sql,";");
          while (st.hasMoreElements())
            { a = st.nextToken();
              stmt.addBatch(a); }
          rowResult=stmt.executeBatch();
       }
    catch (SQLException ex) { ex.printStackTrace();
          System.out.println("dbTrans.doBatch"+ex.getMessage());
          throw ex; }
    return rowResult;
  }  /* 关闭对象 * @throws SQLException 捕捉错误 */
  public void close() throws SQLException
  { try { if(conn != null) conn.close();
      if(stmt != null) stmt.close();   }
    catch (SQLException ex) { ex.printStackTrace();
          System.out.println("Closeing connection fail"+ex.getMessage());
          throw ex;   }
  }

  /* 收尾和垃圾收集 * @throws Throwable 捕捉错误  */
  protected void finalize() throws Throwable { connMgr.release(); }

}

package ylvod.db;import java.io.*;
import java.sql.*;
import java.util.*;
import java.util.Date;/* 管理类DBConnectionManager支持对一个或多个由属性文件定义的数据库连接
* 池的访问.客户程序可以调用getInstance()方法访问本类的唯一实例. */
public class DBConnectionManager
{ static private DBConnectionManager instance; //唯一实例
  static private int clients;
  private Vector drivers = new Vector();
  private PrintWriter log; //日志文件
  private Hashtable pools = new Hashtable();/* 返回唯一实例.如果是第一次调用此方法,则创建实例
* @return DBConnectionManager 唯一实例*/
  static synchronized public DBConnectionManager getInstance()
  { if (instance == null) {instance = new DBConnectionManager(); }
    clients++;
    return instance;
  }

/* 建构函数私有以防止其它对象创建本类实例 */
  private DBConnectionManager() { init(); }/* 将连接对象返回给由名字指定的连接池
* @param name 在属性文件中定义的连接池名字
* @param con 连接对象 */
  public void freeConnection(String name, Connection con)
  { DBConnectionPool pool = (DBConnectionPool)pools.get(name);
    if (pool != null) { pool.freeConnection(con); }
  }/* 获得一个可用的(空闲的)连接.如果没有可用连接,且已有连接数小于最大连接数
* 限制,则创建并返回新连接
* @param name 在属性文件中定义的连接池名字
* @return Connection 可用连接或null */
  public Connection getConnection(String name)
  { DBConnectionPool pool = (DBConnectionPool)pools.get(name);
    if (pool != null) { return pool.getConnection(); }
    return null;
  }/* 获得一个可用连接.若没有可用连接,且已有连接数小于最大连接数限制,
* 则创建并返回新连接.否则,在指定的时间内等待其它线程释放连接.
* @param name 连接池名字
* @param time 以毫秒计的等待时间
* @return Connection 可用连接或null */
  public Connection getConnection(String name,long time)
  { DBConnectionPool pool = (DBConnectionPool)pools.get(name);
    if (pool != null) { return pool.getConnection(time); }
    return null;
  }/* 关闭所有连接,撤销驱动程序的注册 */
  public synchronized void release()
  { // 等待直到最后一个客户程序调用
    if (--clients != 0) { return; }
    Enumeration allPools = pools.elements();
    while (allPools.hasMoreElements())
      { DBConnectionPool pool = (DBConnectionPool) allPools.nextElement();
        pool.release(); }
    Enumeration allDrivers = drivers.elements();
    while (allDrivers.hasMoreElements())
      { Driver driver = (Driver) allDrivers.nextElement();
        try { DriverManager.deregisterDriver(driver);
              //log("Success!撤消JDBC驱动的注册:" + driver.getClass().getName());
            }
        catch (SQLException e)
          { log(e, "Error!撤消JDBC驱动的注册:" + driver.getClass().getName()); }
      }
  }/* 根据指定属性创建连接池实例.
* @param props 连接池属性 */
  private void createPools(Properties props)
  { Enumeration propNames = props.propertyNames();
    while (propNames.hasMoreElements())
    { String name = (String)propNames.nextElement();
      if (name.endsWith(".url"))
      { String poolName = name.substring(0, name.lastIndexOf("."));
        String urll = props.getProperty(poolName + ".url");
        if (urll == null)
          { log("Error!没有指定的连接:" + poolName);   continue;  }
        String user = props.getProperty(poolName + ".user");
        String password = props.getProperty(poolName + ".password");
        String maxconn = props.getProperty(poolName + ".maxconn", "0");
        int max;
        try { max = Integer.valueOf(maxconn).intValue(); }
        catch (NumberFormatException e)
            { log("Error!maxconn数值不适合: " + maxconn + " .连接池: " + poolName);
              max = 0; }
        DBConnectionPool pool =new DBConnectionPool(poolName,urll,user,password,max);
        pools.put(poolName, pool);
        //log("Initialized pool:" + poolName);
      }
    }
  }/* 读取属性完成初始化 */
  private void init()
  { InputStream is = getClass().getResourceAsStream("db.properties");
    Properties dbProps = new Properties();
    try { dbProps.load(is); }
    catch (Exception e)
      { System.err.println("Can not read the properties file; Make sure db.properties is in the Classpath");
        return; }
    String logFile = dbProps.getProperty("logfile", "DBConnectionManager.log");
    try { log = new PrintWriter(new FileWriter(logFile, true), true); }
    catch (IOException e)
      { System.err.println("Can not open the log files: " + logFile);
        log = new PrintWriter(System.err); }
    loadDrivers(dbProps);
    createPools(dbProps);
  }/* 装载和注册所有JDBC驱动程序
* @param props 属性 */
  private void loadDrivers(Properties props)
  { String driverClasses = props.getProperty("drivers");
    StringTokenizer st = new StringTokenizer(driverClasses);
    while (st.hasMoreElements())
    { String driverClassName = st.nextToken().trim();
      try { Driver driver = (Driver)
            Class.forName(driverClassName).newInstance();
            DriverManager.registerDriver(driver);
            drivers.addElement(driver);
            //log("Success!注册JDBC驱动:" + driverClassName);
          }
      catch (Exception e)
        { log("Error!注册JDBC驱动:" + driverClassName + ",Exception:" + e);  }
    }
  }/* 将文本信息写入日志文件 */
  private void log(String msg) { log.println(new Date() + ": " + msg); }/* 将文本信息与异常写入日志文件 */
  private void log(Throwable e, String msg)
  { log.println(new Date() + ": " + msg);
    e.printStackTrace(log);
  }/* 此内部类定义了一个连接池.它能够根据要求创建新连接,直到预定的最
* 大连接数为止.在返回连接给客户程序之前,它能够验证连接的有效性. */
  class DBConnectionPool {
    private int checkedOut;
    private Vector freeConnections = new Vector();
    private int maxConn;
    private String name;
    private String password;
    private String URL;
    private String user;
/* 创建新的连接池
* @param name 连接池名字
* @param URL 数据库的JDBC URL
* @param user 数据库帐号,或 null
* @param password 密码,或 null
* @param maxConn 此连接池允许建立的最大连接数 */
    public DBConnectionPool(String name, String URL, String user, String password,int maxConn)
    { this.name = name;
      this.URL = URL;
      this.user = user;
      this.password = password;
      this.maxConn = maxConn;
    }/* 将不再使用的连接返回给连接池
* @param con 客户程序释放的连接 */
    public synchronized void freeConnection(Connection con)
    { // 将指定连接加入到向量末尾
      freeConnections.addElement(con);
      checkedOut--;
      notifyAll();
    }/* 从连接池获得一个可用连接.如没有空闲的连接且当前连接数小于最大连接
* 数限制,则创建新连接.如原来登记为可用的连接不再有效,则从向量删除之,
* 然后递归调用自己以尝试新的可用连接. */
    public synchronized Connection getConnection()
    { Connection con = null;
      if (freeConnections.size() > 0)
        { // 获取向量中第一个可用连接
          con = (Connection) freeConnections.firstElement();
          freeConnections.removeElementAt(0);
          try
            { if (con.isClosed())
              { //log("Removed bad connection from " + name);
                // 递归调用自己,尝试再次获取可用连接
                con = getConnection();  }
            }
          catch (SQLException e)
            { //log("Removed bad connection from " + name);
              // 递归调用自己,尝试再次获取可用连接
              con = getConnection();
            }
        }
      else if (maxConn == 0 || checkedOut < maxConn) { con = newConnection(); }
      if (con != null) { checkedOut++; }
      return con;
    }/* 从连接池获取可用连接.可以指定客户程序能够等待的最长时间
* 参见前一个getConnection()方法.
* @param timeout 以毫秒计的等待时间限制 */
    public synchronized Connection getConnection(long timeout)
    { long startTime = new Date().getTime();
      Connection con;
      while ((con

//接上面
关闭所有连接 */
    public synchronized void release()
    { Enumeration allConnections = freeConnections.elements();
      while (allConnections.hasMoreElements())
      { Connection con = (Connection) allConnections.nextElement();
        try
          { con.close();
            //log("Closed connection for pool " + name);
          }
        catch (SQLException e)
          { log(e, "不能正常关闭连接，连接池:" + name); }
      }
      freeConnections.removeAllElements();
    }/* 创建新的连接 */
    private Connection newConnection()
    { Connection con = null;
      try
        { if (user == null) { con = DriverManager.getConnection(URL); }
          else { con = DriverManager.getConnection(URL, user, password); }
        //log("Created a new Connection in pool " + name);
        }
      catch (SQLException e)
        { log(e, "Error!不能创建连接:" + URL);
          return null;
        }
      return con;
    }
  } //end for "class DBConnectionPool"} //end for "public class DBConnectionManager"

package ylvod.admin;import java.sql.*;
import java.io.*;
import java.util.*;
import ylvod.db.*;public class Install
{ String SQL = "";
  DbTrans DBSQL;
  ResultSet rs = null;
  public String InstVer=""; //以前已经安装过

  public Install()
  { this.DBSQL = new DbTrans(); }  public String HadInst()
  { String SQL="select version from config";
    try
      { rs = DBSQL.executeQuery(SQL);
        if (rs.next()) InstVer = rs.getString("version");
      }
    catch (SQLException e) { System.err.println("Get HadInstall Err!"); }
    return InstVer;
  }

  //默认安装模式，直接写各级子菜单路径信息
  public boolean TypicalInst(String admin,String pass,String RootDir)
  { boolean InstR=false;
   File RDir = new File(RootDir);
   if (CreatTable()==false) { System.err.println("Err!CreatTable."); return false;}
   //在表config中写入admin,pass,RootDir
    String SQLd="Insert into config (admin,pass,RFolder,version) values ('"+admin+"','"+pass+"','/"+RDir.getName()+"','1.2')";
    try { InstR = DBSQL.executeUpdate(SQLd)==true; }
    catch (Exception e) { System.err.println("Err!Insert config:"+e.getMessage()); InstR=false;}
    //在表Class中写入

    //在表Type中写入

   return InstR;
  }  //根据片源目录生成数据库记录
  public boolean CustomInst(String admin,String pass,String RootDir)
  { boolean InstR=false;
   File RDir = new File(RootDir);
    if (RDir.isDirectory())
      { //得到第一级分类目录名列表
       String[] filenames = RDir.list();
        if (filenames != null)
          { for (int i=0; i<filenames.length; i++)
              GetDir1(i,filenames[i]);
          }
      }
    //在表config中写入admin,pass,RootDir
    String SQLd="Insert into config (admin,pass,RFolder,version) values ('"+admin+"','"+pass+"','/"+RDir.getName()+"','1.2')";
    try { InstR = DBSQL.executeUpdate(SQLd)==true; }
    catch (Exception e) { System.err.println("Err!Insert config:"+e.getMessage()); InstR=false;}
    return InstR;
  }

  //写入第一级分类目录名列表到Class并得到第二级分类目录名列表
  //C1为Class.CId,Dir1为Class.CFolder
  public boolean GetDir1(int C1,String Dir1)
  { boolean InstR=false;
   File Dir = new File(Dir1);


   return InstR;
  }  //写入第二级分类目录名列表到Type并写入第二级分类下文件名列表到List
  //C1为Class.CId,C2为Type.TId,Dir2为Type.TFolder
  public boolean GetDir2(int C1,int C2,String Dir2)
  { boolean InstR=false;
   return InstR;
  }  //创建数据表
  private boolean CreatTable()
  { boolean InstR=false;
   //创建表config
   String SQLd="create Table `config` (`id` int(6) NOT NULL auto_increment,`admin` varchar(20) NOT NULL default 'admin',`pass` varchar(20) NOT NULL default 'admin',`RFolder` varchar(20) NOT NULL default 'voddir/','version' varchar(6) NOT NULL default '1.2',KEY `id` (`id`)) TYPE=MyISAM";
    try { InstR = DBSQL.executeUpdate(SQLd)==true; }
    catch (Exception e) { System.err.println("Err!creat config:"+e.getMessage()); InstR=false; }
    //创建表Class
    SQLd="create Table `Class` (`id` int(6) NOT NULL auto_increment,`CId` int(6) NOT NULL default '0',`CName` varchar(30) NOT NULL default '空记录',`CFolder` varchar(20) NOT NULL default '　',KEY `id` (`id`),UNIQUE KEY `CId` (`CId`)) TYPE=MyISAM";
    try { InstR = (DBSQL.executeUpdate(SQLd)==true)&&InstR; }
    catch (Exception e) { System.err.println("Err!creat Class:"+e.getMessage()); InstR=false; }
    //创建表Type
    SQLd="create Table `Type` (`id` int(6) NOT NULL auto_increment,`CId` int(6) NOT NULL default '0',`TId` int(6) NOT NULL default '0',`TName` varchar(30) NOT NULL default '空记录',`TFolder` varchar(20) NOT NULL default '　',KEY `id` (`id`)) TYPE=MyISAM";
    try { InstR = (DBSQL.executeUpdate(SQLd)==true)&&InstR; }
    catch (Exception e) { System.err.println("Err!creat Type:"+e.getMessage()); InstR=false; }
    //创建表List
    SQLd="create Table `List` (`id` int(6) NOT NULL auto_increment,`CId` int(6) NOT NULL default '0',`TId` int(6) NOT NULL default '0',`LName` varchar(40) NOT NULL default '空记录',`LFName` varchar(100) NOT NULL default '　',`LAbout` text,KEY `id` (`id`)) TYPE=MyISAM";
    try { InstR = (DBSQL.executeUpdate(SQLd)==true)&&InstR; }
    catch (Exception e) { System.err.println("Err!creat List:"+e.getMessage()); InstR=false; }
    return InstR;
  }}

<%@ page contentType="text/html;charset=iso8859_1"%>
<%response.setContentType("text/html;charset=iso8859_1");%>
<jsp:useBean id="Install" scope="page" class="ylvod.admin.Install"/>
<html><head><title>『VOD点播』ver 1.2 安装向导</title><meta http-equiv="Content-Language" content="zh-cn">
<meta http-equiv="Content-Type" content="text/html; charset=GB2312"><link rel="stylesheet" href="../style.css">
</head><body>
<h1><b>『VOD点播』ver 1.2 安装向导</b></h1>
</font>
<hr color="#000000" noShade>
<p><font face="宋体" color="#000000"><b>欢迎使用『VOD点播』ver 1.2 安装向导！</b><br>
<font color=red>详细操作流程请参见《技术手册》。</font><br>
<%String submit="";
submit=request.getParameter("submit");
if (submit==""||submit==null) //第一步的初始化
{ //Install.HadInst();
  if(Install.InstVer!="")
  { out.println("<hr color='#000000' noShade>您已经进行了数据库的初始化安装！");  }
  else
   { %>
<b>第一步：</b><br>
将进行数据库初始化！注意：数据库初始化将建立 YlVOD所需要的各个数据表，<br>
在初始化之前，请确保数据库已经开始工作，并已经建立了YlVOD所需的数据库！<br>
</p>
<form name="form1" action="install.jsp">
  <p>超级用户：<input type="text" name="admin" size="10"><br>
  管理口令：<input type="password" name="pass" size="10"><br><br>
  影片根目录：<br><input type="text" name="RDir" size="25" value="d:\homepage\vod\voddir"><br>
<input type="submit" value="下一步" name="submit"> <input type="reset" value="重写" name="reset">
</form>
<% }
} //第一步的初始化->结束
else if (submit.equals("下一步"))
{ out.print("!!!");
}
%>
</body></html>//完了。~~~~~
//为什么我在Win98里都是能显示JSP页面的呢，好象也是抛出了异常说config
找不到~~但是页面能显示出来啊。到Linux就不行了~~~

不好意思，刚才有事情，你现在到底有没有好？改成catch(Exception)呢？

可能需要查一下jdk doc才能知道当这个table不存在情况下，进行查询抛出的异常到底是什么，如果你实在不知道，那么只能通过catch(exception)解决：（
另外一种比较麻烦的手段就是：你先查询数据库系统表，比如SQL SERVER里面的sysobject ，不过你需要有访问系统表的权限，而且各个数据库可能都有不同。查询系统表然后检查某个Table是否存在。如果存在，则继续查询你的表//
这个问题其实不仅仅在java里面存在，只要是和数据库挂接，都有这个问题~
我能想到的解决的办法也就只有这样。或者你知道它的exception的class ：）或者你间接的查系统表以确认你的table的存在：）突然灵光一现，：）你不放在catch(Exception e) 里面把他的class 打印出来，这样不就是知道他抛出的异常到底是什么了？：）

调试易

为什么在Win98下好好的，Linux上就报空指针错误啊？（附代码）

解决方案 »