public database(string url, string user, string password) {
　　this.url = url;
　　this.user = user;
　　this.password = password;
　　}

　　/**
　　* 用jndi数据源名初始化数据库对象，这个构造器用于从连接池取数据库连接的情况。
　　* @param datasource
　　*/
　　public database(string datasource) {
　　this.datasource = datasource;
　　}

　　/**
　　* 得到数据库连接，对于是否从连接池里取连接做了自动处理即根据用户调用了哪个构造器
　　* 来判断是否直接与数据库建立连接还是从连接池里取连接。
　　* 对于用户来说不用考虑程序是从那里取得连接，他只管正确的初始化数据库对象。
　　* @return
　　* @throws sqlexception
　　*/
　　public connection getconnection() throws exception {
　　if (datasource == null) { //直接与数据库建立连接
　　if (conn == null) {
　　conn = drivermanager.getconnection(url, user, password);
　　}
　　}
　　else { //从应用服务器的连接池里取得连接
　　servicelocator sl = servicelocator.getinstance();
　　datasource ds = sl.getdatasource(datasource);
　　return ds.getconnection();//每调用一次都返回一个连接池中的数据库连接
　　}
　　return conn;
　　}

　　/**
　　* 释放连接，如果是直接与数据库连接的情况则什么也不做
　　* 如果是从连接池中取得的连接那么释放传来的连接
　　* @param conn
　　*/
　　public void disconnect(connection connection) {
　　if (datasource != null) { //只处理从连接池取连接的情况
　　try {
　　if (connection != null) {
　　connection.close();
　　}
　　}

　　catch (exception ex) {}
　　}
　　}

　　/**
　　* 得到与参数名对应的表对象，注意这里不作任何数据库操作
　　* @param name
　　* @return
　　*/
　　public table gettable(string name) {
　　return new table(this, name);
　　}
　　}

　　public row getrow(string fields, string criteria, object[] args) throws
　　dbaccessexception {
　　rowset rows = executequery(fields, criteria, args);
　　if (rows == null) {
　　return null;
　　}
　　return rows.get(0);
　　}
　　/**
　　* 得到一个多行记录
　　* @param criteria 查询条件
　　* @param args 查询条件的参数列表
　　* @return
　　*/
　　public rowset getrows(string fields, string criteria, object[] args) throws
　　dbaccessexception {
　　return executequery(fields, criteria, args);
　　}
　　/**
　　* 执行sql查询
　　* @param fields 要查询的字段，如果传入null则表示查询表中所有字段
　　* @param criteria用户输入的查询where条件
　　* @param args 用到的参数数组
　　* @return 返回符合结果行集
　　*/
　　private rowset executequery(string fields, string criteria, object[] args) throws
　　dbaccessexception {
　　connection conn = null;
　　rowset rows = new rowset();
　　string sql = null;
　　if (fields == null) {
　　fields = "*";
　　}
　　try {
　　conn = database.getconnection(); //取得数据库连接,在方法内部对不同的连接情况进行了处理
　　sql = "select " + fields + " from " + name +
　　( (criteria == null) ? "" :
　　(" where " + criteria));
　　preparedstatement pstmt = conn.preparestatement(sql);
　　if (args != null) { //如果有查询参数则设置参数
　　for (int i = 0; i < args.length; i++) {
　　pstmt.setobject(i + 1, args[i]);
　　}
　　}
　　resultset rs = pstmt.executequery();
　　resultsetmetadata rsmd = rs.getmetadata();
　　int cols = rsmd.getcolumncount();
　　/**@todo 判断是否为零*/
　　if (cols == 0) {

　　int affectablerow = 0; //执行sql后影响的行数
　　if (conditions == null) {
　　ss = "insert into " + name + "(";
　　for (int i = 0; i < row.length(); ++i) {
　　string k = row.getkey(i);
　　ss += k;
　　if (i != row.length() - 1) {
　　ss += ", ";
　　}
　　}
　　ss += ") values (";
　　for (int j = 0; j < row.length(); ++j) {
　　ss += (row.get(j) == null) ? "null" : "?"; //如果row中有空值则设置为null，否则设置为查询参数
　　if (j != row.length() - 1) {
　　ss += ", ";
　　}
　　}
　　ss += ")";
　　}
　　else {
　　ss = "update " + name + " set ";
　　for (int i = 0; i < row.length(); ++i) {
　　string k = row.getkey(i);
　　ss += k + "=" + ( (row.get(i) == null) ? "null" : "?"); //设置查询参数
　　if (i != row.length() - 1) {
　　ss += ", ";
　　}
　　}
　　ss += " where ";
　　ss += conditions;
　　}
　　connection conn = null;
　　try {
　　conn = database.getconnection();
　　preparedstatement st = conn.preparestatement(ss);
　　int j = 0; //查询参数计数器
　　for (int i = 0; i < row.length(); i++) {
　　if (row.get(i) != null) { //如果不是空则解析查询参数
　　st.setobject(++j, row.get(i)); //解析查询参数
　　}
　　}
　　if (args != null) {
　　for (int i = 0; i < args.length; i++) {
　　st.setobject(++j, args[i]);//预定的规则，null不能放到查询参数中要以name=null的静态形式存放
　　}
　　}
　　affectablerow = st.executeupdate();
　　st.close();
　　}

　　catch (exception ex) {
　　ex.printstacktrace();
　　throw new dbaccessexception(inforgeter.geterrorinfor(this, "putrow", ex,
　　"更新表" + name + "中的数据时出错！"));
　　}
　　finally {
　　database.disconnect(conn);
　　}
　　return affectablerow;
　　}

　　/**
　　* 删除一行
　　* @param row
　　*/
　　public int delrow(row row) throws dbaccessexception {
　　string ss = "";
　　int affectablerow = 0;
　　ss = "delete from " + name + " where ";

　　for (int i = 0; i < row.length(); ++i) {
　　string k = row.getkey(i);
　　ss += k + ((row.get(i) == null)?" is null":"=?"); //设置查询参数有空值处理
　　if (i != row.length() - 1) {
　　ss += " and ";
　　}
　　}
　　connection conn = null;
　　try {
　　conn = database.getconnection();
　　preparedstatement st = conn.preparestatement(ss);
　　int j = 0;//查询参数计数器
　　for (int i = 0; i < row.length(); i++) {
　　if (row.get(i) != null) {
　　st.setobject(++j, row.get(i)); //解析查询参数
　　}
　　}
　　affectablerow = st.executeupdate();
　　st.close();
　　}
　　catch (exception ex) {
　　throw new dbaccessexception(inforgeter.geterrorinfor(this, "delrow", ex,
　　"删除表" + name + "中的数据时出错！"));
　　}
　　finally {
　　database.disconnect(conn);
　　}
　　return affectablerow;
　　}

　　return key;
　　}
　　/**
　　* 打印，用于调试
　　*/
　　public void dump() {
　　for (iterator e = map.keyset().iterator(); e.hasnext(); ) {
　　string name = (string) e.next();
　　object value = map.get(name);
　　system.out.print(name + "=" + value + ", ");
　　}
　　system.out.println("");
　　}
　　/**
　　* 将行对象转换成值对象
　　* @param row
　　* @param type值对象类型
　　* @return
　　* @throws java.lang.exception 这里的异常一般在dao中处理，因为dao调用
　　* 这个方法进行row和valueobject的转换
　　*/
　　public static object tovalueobject(row row, class type) throws exception {
　　object vo = type.newinstance(); //创建一个值对象
　　field[] fields = type.getdeclaredfields(); //得到值对象中所有字段
　　for (int i = 0; i < fields.length; i++) {
　　string name = fields[i].getname(); //得到javabean的字段名
　　string nameinrow = toinrowname(name);//在此进行值对象名称到行对象名称的转换
　　object value = row.get(nameinrow); //得到从数据库中取出的与字段名对应的值
　　string methodname = "set" + character.touppercase(name.charat(0)) +
　　name.substring(1); //得到setxxxx方法名
　　class argclass = null;
　　if (value instanceof class) {
　　argclass = (class)value;
　　value = null;
　　}else{
　　argclass = value.getclass();
　　}
　　method method = type.getmethod(methodname, new class[] {argclass}); //得到set方法
　　method.invoke(vo, new object[] {value});//调用setxxxx方法
　　}
　　return vo;
　　}
　　/**
　　* 根据传过来的值对象和类型把值对象转换到行对象中
　　* @param vo
　　* @return
　　* @throws java.lang.exception 这里的异常一般在dao中处理，因为dao调用
　　* 这个方法进行row和valueobject的转换
　　*/

　　public rowset() {

　　}

　　public void add(row row) {
　　vector.addelement(row);
　　}

　　public int length() {
　　return vector.size();
　　}

　　public row get(int which) {
　　if (length() < 1) {
　　return null;
　　}
　　else {
　　return (row) vector.elementat(which);
　　}
　　}

　　public void dump() {
　　for (enumeration e = vector.elements(); e.hasmoreelements(); ) {
　　( (row) e.nextelement()).dump();
　　}
　　}
　　}

　　/**
　　* 用数据库对象和表名初始化dao
　　* @param db
　　* @param tablename
　　*/
　　public generaldao(database db, string tablename) {

　　gettable(db, tablename);
　　}
　　private void gettable(database db, string name) {
　　table = db.gettable(name);
　　}
　　/**
　　* 根据条件将查找到的数据以值对象集合的形式返回
　　* @param fields 要查找的字段(*或null表示所有字段)
　　* @param criteria查询条件
　　* @param args与查询条件对应的参数数组
　　* @param votype值对象的类型
　　* @return
　　* @throws java.lang.exception
　　*/
　　public collection finddatas(string fields, string criteria, object[] args,
　　class votype) throws exception {
　　rowset rows = table.getrows(fields, criteria, args);
　　collection col = new arraylist();
　　for (int i = 0; i < rows.length(); i++) {
　　object vo = row.tovalueobject(rows.get(i), votype); //返回一个值对象，注意是votype类型的对象
　　col.add(vo);
　　}
　　return col;
　　}

　　/**
　　* 向表中插入一条数据
　　* @param vo 与表对象对应的值对象
　　* @return
　　* @throws java.lang.exception
　　*/
　　public int insertdata(object vo) throws exception {
　　return table.putrow(row.fromvalueobject(vo));
　　}

　　/**
　　* 更新一条数据
　　* @param vo 与表对象对应的值对象
　　* @param criteria更新条件
　　* @param args与更新条件对应的参数数组
　　* @return
　　* @throws java.lang.exception
　　*/
　　public int updatedata(object vo, string criteria, object[] args) throws
　　exception {
　　return table.putrow(row.fromvalueobject(vo), criteria, args);
　　}

　　/**
　　* 删除一条数据(条件比较严格各个字段的值必须与值对象中属性的值匹配)
　　* @param vo
　　* @return

　　public class generaldaoexample {
　　public static void main(string[] args)throws exception {
　　class.forname("sun.jdbc.odbc.jdbcodbcdriver");
　　database db = new database("jdbc:odbc:emmis","sa","815023");
　　generaldao dao = new generaldao(db,"teacher");
　　/**
　　* 利用generaldao进行查询
　　*/
　　collection col = dao.finddatas("*","birthday is null",null,teachervo.class);
　　for (iterator iter = col.iterator(); iter.hasnext(); ) {
　　object item = iter.next();
　　system.out.println("item = " + item);
　　}
　　/**
　　* 利用generaldao进行添加
　　*/
　　teachervo vo = new teachervo();
　　vo.setaddress("沈阳");
　　vo.setbirthday(new java.sql.timestamp(0));
　　vo.setid(new integer(11));
　　vo.setincome(new java.math.bigdecimal(1000));
　　vo.setname("陶小川");
　　//    dao.insertdata(vo);  //添加一条记录
　　//    dao.updatedata(vo,"id=10",null); //更新一条记录
　　//    dao.deletedata(vo); //删除一条记录
　　//    dao.deletedatas("id>5",null); //添加符合条件记录
　　}
　　}