作者信息：

  曾青松 zengqingsong@sohu.com
  中山大学数学与计算科学学院 信息系统与计算机网络方向硕士研究生

  程序源代码：

  }

  public connection getconnection(string username, string password) throws
      sqlexception {
    this.setusername(username);
    this.setpassword(password);
    return getconnection();
  }

  public printwriter getlogwriter() {
    return null;
  }

  public void setlogwriter(printwriter printwriter) {
  }

  public void setlogintimeout(int int0) {
  }

  public int getlogintimeout() {
    return 0;
  }
  }

  实现连接sqlserver的连接工厂，这里因为我们的项目使用sqlserver2000所以只实现了

  sqlserverconnectionfactory。
  package skydev.modules.data;
  public final class sqlserverconnectionfactory extends connectionfactory {
  private final string dbdriver ="com.microsoft.jdbc.sqlserver.sqlserverdriver";
  private string host;//主机
  private int port;//端口
  private string databasename;//sql数据库名称

  public sqlserverconnectionfactory() {
    super.setdrivername(dbdriver);
  }

  /**
   *
   * @param host 数据库所在的主机名：如"localhost"
   * @param port sql服务器运行的端口号，如果使用缺省值 1433，传入一个负数即可
   * @param databasename 数据库名称
   * @param username 用户名
   * @param password 口令
   */
  public sqlserverconnectionfactory(string host,
                                    int port,
                                    string databasename,
                                    string username,
                                    string password) {
    this.sethost(host);
    this.setport(port);
    this.setdatabasename(databasename);

    this.setusername(username);
    this.setpassword(password);
    init();
  }

  private void init() {
    super.setdrivername(dbdriver);
    super.seturl("jdbc:microsoft:sqlserver://" + host.trim() + ":" +
                 new integer(port).tostring() + ";databasename=" +
                 databasename.trim());
    //super.seturl("jdbc:microsoft:sqlserver://localhost:1433;databasename=demo");
  }

  public void sethost(string host) {
    //处理主机名称
    if ( (host == null) || (host.equals("")) || (host.equals(".")) ||
        (host.equals("local"))) {
      host = "localhost";
    }
    int index = host.indexof("//", 0);
    if (index == 0) {
      host = host.substring(2); //去掉前面的"//"
    }
    index = host.indexof("//", 0);
    if (index >= 0) {
      try {
        throw new exception("sql server主机名参数错误！");
      }
      catch (exception ex) {

 

      }
    }
    this.host = host;
  }

  public void setport(int port) {
    /**
     * 缺省端口1433
     */
    if (port < 0) {
      port = 1433;
    }
    this.port = port;
  }

  public void setdatabasename(string databasename) {
    this.databasename = databasename;
  }
  }

  使用"sun.jdbc.odbc.jdbcodbcdriver"连接数据库的连接工厂
  package skydev.modules.data;
  public class jdbcodbcconnectionfactory extends connectionfactory {
  private final static string drivename = "sun.jdbc.odbc.jdbcodbcdriver";
  private string odbcname;

  public jdbcodbcconnectionfactory() {
    super.setdrivername(drivename);
  }

  /**

   *使用指定的odbc数据源连接数据库服务器
   * @param odbcname
   */
  public jdbcodbcconnectionfactory(string odbcname) {
    super.setdrivername(drivename);
    setodbcname(odbcname);
  }

  public void setodbcname(string odbcname) {
    this.odbcname = odbcname;
    this.seturl("jdbc:odbc:" + odbcname);
  }
  }

  数据基本操作类，使用连接工厂连接数据库。
  package skydev.modules.data;
  import java.sql.*;
  import java.sql.preparedstatement;
  import javax.sql.datasource;

  public abstract class databaseobject {
  protected connection connection = null;
  protected resultset resultset = null;
  protected resultsetmetadata resultsetmetadata = null;
  private connectionfactory connectionfactory = null;
  private java.sql.statement statement=null;
  private javax.sql.datasource datasource;//=new statement();

  public databaseobject(){
    datasource=null;

 

    connection=null;
  }

  public databaseobject(connectionfactory connectionfactory) {
    this.setconnectionfactory(connectionfactory);
    this.datasource=connectionfactory;//connectionfactory实现了datasource接口
  }

  /**
   * 执行查询
   * @param sql 要执行的sql语句
   * @return　返回查询的结果集 ,查询失败返回null
   */
  public resultset getresultset(string sql) {
    try {
      this.resultset = statement.executequery(sql); //保留内部指针
    }
    catch (sqlexception e) {
      e.printstacktrace();
      this.resultset = null;
    }
    finally {
      return this.resultset;
    }
  }

  /**
   * 获取外部指定resltset的resultsetmetadata数据
   * @param resultset 要获取的resultset
   * @return 失败返回null

   */
  public resultsetmetadata getresultsetmetadata(resultset resultset) {
    resultsetmetadata resultsetmetadata = null;
    try {
      resultsetmetadata = resultset.getmetadata();
    }
    catch (sqlexception e) {
      e.printstacktrace();
      resultsetmetadata = null;
    }
    finally {
      return resultsetmetadata;
    }
  }

  /**
   * 获取最近一次设置或者返回的resultset的resultmetadata数据，
   * 比方说调用了：getresultset(sql)方法，然后调用getresultsetmetadata方法
   * 可以获得相应的resultsetmetadata数据。
   * @return
   */
  public resultsetmetadata getresultsetmetadata() {
    return this.getresultsetmetadata(this.resultset);
  }

  /**
   * 执行存储过程
   * @param spname 存储过程名称
   * @return
   */
  public resultset execute(string spname) {

    //对此数据库执行一个 sql 查询
    resultset resultset = null;
    try {
      // preparedstatement stmt = (preparedstatement) connection.createstatement();
      resultset = statement.executequery(spname);
    }
    catch (exception e) {
      system.out.println("execute error" + e.getmessage());
    }
    return resultset;
  }

  /**
   * 设置数据库连接工厂，对此类的所有操作之前，必须调用该方法，
   * 设置数据库连接工厂。
   * @param connectionfactory 数据库连接工厂connectionfactory 类对象以及
   * 派生类对象。
   */
    public void setconnectionfactory(connectionfactory connectionfactory) {
    this.connectionfactory = connectionfactory;
    connection = connectionfactory.getconnection();
    try {
      statement = connection.createstatement();
    }
    catch (sqlexception ex) {
      system.err.println(ex);
    }
  }

  public connection getconnection() {

    return connection;
  }

  public java.sql.statement getstatement() {
    return statement;
  }
  public javax.sql.datasource getdatasource() {
    return datasource;
  }
  }

  具体项目的数据库访问基类
  package skydev.modules.data;
  public class dbobject extends databaseobject {
   // private final static string drivename = "sun.jdbc.obdc.jdbcodbcdriver";
    public dbobject() {
    super(new sqlserverconnectionfactory("localhost", 1433, "theschool", "sa",""));
    }

    public dbobject(connectionfactory connectionfactory) {
    super(connectionfactory);
  }
  }

  在项目中的数据库层中的数据库访问类都从databaseobject类派生，这样只需要在一个地方设置数据连接，其他地方都不需要涉及数据库访问的具体连接代码。
如：user类专门负责users组的权限控制等，只需要简单的代码就可以连接并访问数据库了。这里具体实现与此文章无关，只举一两个模块做例子。

  public class user extends dbobject {
  public user() {
    //子类也可以覆盖基类的访问方式，在单机调式时有用。
    // super(new sqlserverconnectionfactory("localhost", 1433, "theschool", "sa",""));
    super();//调用基类的数据库访问代码。
  }
  /*
   在做信息系统时为了提高客维护性，我们一般使用存储过程返回和修改数据，在数据库层代码不使用select语句直接检索数据，做到数据库层代码的最大的灵活性和可维护性。一旦发现需要修改数据库中的代码，只需要修改村年初过程即可以。

    下面介绍java使用sqlserver storeprocedure的方法。
    存储过程的参数使用“?”代替，下面的代码有一定的代表性，存储过程有输入参数，输出参数。

    存储过程的基本功能为：检测userid和encpassword是否和数据库存储的一致，返回userid,如果不一致返回-1。

  */
  //测试数据库中存储的已经加密的密码和用户传入的加密的密码是否一致。
  public boolean testpassword(int userid, byte[] encpassword) {
    connection con = this.getconnection();
    callablestatement cs = null;
    try {
      cs = con.preparecall("{?=call sp_accounts_testpassword(?,?)}");
      cs.setint(2, userid);
      cs.setbytes(3, encpassword);
      cs.registeroutparameter(1, types.integer); //@userid
      cs.execute();
      if (cs.getint(1) == 1) { //密码合格
        return true;
      }
      else {
        return false;
      }
    }
    catch (sqlexception ex) {
      return false;
    }
    catch (exception e) {
      return false;
    }
 }
  }

   以上只是我在学习和工作中的一点体会，写出来的目的使为了和大家交流，错误之处希望大家提出宝贵的意见，以便把该模块的功能做得更完善一点。