新手问题，在线等待

Question

另一个类文件：DBConnectionManager.java已编译成功，且在同一目录下

Answer 1

---------- javac ----------
TestServlet.java:10: cannot resolve symbol
symbol  : class DBConnectionManager  
location: class TestServlet
错误信息： 
   private DBConnectionManager connMgr;
            ^
TestServlet.java:14: cannot resolve symbol
symbol  : variable DBConnectionManager  
location: class TestServlet
        connMgr = DBConnectionManager.getInstance();
                  ^
2 errors
Normal Termination
Output completed (2 sec consumed).

Answer 2

确定一下类名DBConnectionManager 有没有写错

Answer 3

有没有使用包？
DBConnectionManager文件名和类名和你使用的声明的时候这三个东西都用拷贝的方法试一遍！
记住DBConnectionManager类需要重新编译一下！

Answer 4

你的DBConnectionManager中有package语句吗？

Answer 5

/*
 * @(#)DBConnectionManager.java 2001/09/18
 */
import java.io.*;
import java.sql.*;
import java.util.*;
import java.util.Date;public class DBConnectionManager {
    static private DBConnectionManager instance;
    static private int clients;    private Vector drivers = new Vector();
    private PrintWriter log;
    private Hashtable pools = new Hashtable();
    
    /**
     * 得到DBConnectionManager对象实例
     *
     * @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() {
        // Wait until called by the last client
        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("Deregistered JDBC driver " + driver.getClass().getName());
            }
            catch (SQLException e) {
                log(e, "Can't deregister JDBC driver: " + driver.getClass().getName());
            }
        }
    }
    
    /**
     * 基于属性创建DBConnectionPool的实例
     * DBConnectionPool可以使用下面的属性：
     * 
     * <poolname>.url         数据库的JDBC URL
     * <poolname>.user        数据库用户(可选)
     * <poolname>.password    数据库用户的口令(如果着顶用户)
     * <poolname>.maxconn     连接的最大数目(可选)
     *
     * @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 url = props.getProperty(poolName + ".url");
                if (url == null) {
                    log("No URL specified for " + 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("Invalid maxconn value " + maxconn + " for " + poolName);
                    max = 0;
                }
                DBConnectionPool pool = 
                    new DBConnectionPool(poolName, url, 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't 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't open the log file: " + 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("Registered JDBC driver " + driverClassName);
            }
            catch (Exception e) {
                log("Can't register JDBC driver: " +
                    driverClassName + ", Exception: " + e);
            }
        }
    }
    
    /**
     * 将消息写进日志文件
     */
    private void log(String msg) {
        log.println(new Date() + ": " + msg);
    }
    
    /**
     * 将带有异常的消息写进日志文件
     */

Answer 6

private void log(Throwable e, String msg) {
        log.println(new Date() + ": " + msg);
        e.printStackTrace(log);
    }
    
    /**
     * 一个inner类，代表了一个数据库连接池
     */
    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 最大的连接数，如果为0则没有限制
         */
        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) {
            // 将连接放在Vector对象中其他连接之后
            freeConnections.addElement(con);
            checkedOut--;
            notifyAll();
        }
        
        /**
         * 从连接池中得到一个连接，如果当前没有空闲的连接，如果连接数没有达到最大，
         * 则创建一个新的。
         */
        public synchronized Connection getConnection() {
            Connection con = null;
            if (freeConnections.size() > 0) {
                // Pick the first Connection in the Vector
                // to get round-robin usage
                con = (Connection) freeConnections.firstElement();
                freeConnections.removeElementAt(0);
                try {
                    if (con.isClosed()) {
                        log("Removed bad connection from " + name);
                        // Try again recursively
                        con = getConnection();
                    }
                }
                catch (SQLException e) {
                    log("Removed bad connection from " + name);
                    // Try again recursively
                    con = getConnection();
                }
            }
            else if (maxConn == 0 || checkedOut < maxConn) {
                con = newConnection();
            }
            if (con != null) {
                checkedOut++;
            }
            return con;
        }
        
        /**
         * 从连接池中得到一个连接，如果当前没有空闲的连接，如果连接数没有达到最大，
         * 则创建一个新的。 
         *
         * @param timeout 毫秒为单位的超时的值
         */
        public synchronized Connection getConnection(long timeout) {
            long startTime = new Date().getTime();
            Connection con;
            while ((con = getConnection()) == null) {
                try {
                    wait(timeout);
                }
                catch (InterruptedException e) {}
                if ((new Date().getTime() - startTime) >= timeout) {
                    // 超时
                    return null;
                }
            }
            return 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, "Can't close connection for pool " + name);
                }
            }
            freeConnections.removeAllElements();
        }
        
        /**
         * 创建一个新的连接，如果可能，使用指定的userid和password
         */
        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, "Can't create a new connection for " + URL);
                return null;
            }
            return con;
        }
    }
}

Answer 7

DBConnectionManager 所在目录在classpath中有吗？

Answer 8

关键是DBConnectionManager所在的目录在不在classpath中，或者你的classpath是否包含当前目录。这很重要。

Answer 9

你先编写一个类如下：
class a 
{
  private DBConnectionManager connMgr;
}
看编译能不能通过。

Answer 10

---------- javac ----------
a.java:3: cannot resolve symbol
symbol  : class DBConnectionManager  
location: class a
  private DBConnectionManager connMgr;
          ^
1 error
Normal Termination
Output completed (3 sec consumed).

Answer 11

先编写
class b
{
}
编译b;然后编写一个类如下：
class a 
{
  private b connMgr;
}
再编译b看能不能通过。

Answer 12

那100%是你的classpath的问题
将你的classpath帖出来，然后将你的文件所在的路径帖出来。

Answer 13

CLASSPATH=c:\04;c:\j2sdk\lib\dt.jar;c:\j2sdk\lib\tools.jar;c:\j2sdk\jre\lib\rt.jar;c:\j2sdkee\lib\j2ee.jar;c:\jswdk-1.0.1\lib\servlet.jar程序目录是c:\04

Answer 14

将classpath更改成
CLASSPATH=.;c:\04;c:\j2sdk\lib\dt.jar;c:\j2sdk\lib\tools.jar;c:\j2sdk\jre\lib\rt.jar;c:\j2sdkee\lib\j2ee.jar;c:\jswdk-1.0.1\lib\servlet.jar