objectdb.java

cwbbs 云网论坛源码

package cn.js.fan.base;

import cn.js.fan.web.Global;
import org.apache.log4j.Logger;
import java.io.Serializable;
import cn.js.fan.resource.Constant;
import java.sql.ResultSet;
import java.sql.SQLException;
import cn.js.fan.db.Conn;
import java.util.Vector;
import cn.js.fan.db.PrimaryKey;
import cn.js.fan.db.KeyUnit;
import java.util.Iterator;
import java.util.HashMap;
import cn.js.fan.util.ErrMsgException;
import cn.js.fan.util.ResKeyException;
import cn.js.fan.db.ListResult;
import cn.js.fan.db.SQLFilter;

public abstract class ObjectDb implements Serializable {
    public static final PrimaryKey[] EMPTY_BLOCK = new PrimaryKey[0];

    public String connname = "";
    public transient Logger logger = null;
    public String QUERY_LOAD;
    public String QUERY_DEL;
    public String QUERY_SAVE;
    public String QUERY_CREATE;
    public String QUERY_LIST;

    public boolean isInitFromConfigDB = true;

    protected String tableName = "";

    public PrimaryKey primaryKey;
    public ObjectCache objectCache;

    public ObjectDb() {
        init();
    }

    
    public void init() {
        logger = Logger.getLogger(this.getClass().getName());
        connname = Global.defaultDB;
        if (connname.equals(""))
            logger.info(Constant.DB_NAME_NOT_FOUND);
        setQueryCreate();
        setQuerySave();
        setQueryDel();
        setQueryLoad();
        setQueryList();

        initDB();

        setPrimaryKey();
    }

    
    public void renew() {
        if (logger==null) {
            logger = Logger.getLogger(this.getClass().getName());
        }
        if (objectCache!=null) {
            objectCache.renew();
        }
    }

    
    public void initDB() {}

    public void setQueryCreate() {}
    public void setQuerySave() {};
    public void setQueryDel() {};
    public void setQueryLoad() {};
    public void setQueryList() {};

    
    public void setPrimaryKey() {
        if (!isInitFromConfigDB)
            return;
        DBConfig dc = new DBConfig();
        DBTable dt = dc.getDBTable(this.getClass().getName());
        if (dt == null) {
            logger.info(this +" cann't find table defination in config file.");
            return;
        }
        this.tableName = dt.getName();
        this.primaryKey = (PrimaryKey)dt.getPrimaryKey().clone();

        this.QUERY_CREATE = dt.getQueryCreate();
        this.QUERY_DEL = dt.getQueryDel();
        this.QUERY_LIST = dt.getQueryList();
        this.QUERY_LOAD = dt.getQueryLoad();
        this.QUERY_SAVE = dt.getQuerySave();
        this.objectCache = dt.getObjectCache(this);

        this.objectCache.setObjCachable(dt.isObjCachable());
        this.objectCache.setListCachable(dt.isListCachable());
    }

    
    public Object[] getObjectBlock(String query, int startIndex) {
        return objectCache.getObjectBlock(query, startIndex);
    }

    
    public ObjectDb getObjectDb(Object primaryKeyValue) {
        
        PrimaryKey pk = (PrimaryKey)primaryKey.clone();
        pk.setValue(primaryKeyValue);
        return objectCache.getObjectDb(pk);
    }

    

    
    public ObjectBlockIterator getObjects(String query,
                                         int startIndex,
                                         int endIndex) {
        
        Object[] blockValues = getObjectBlock(query, startIndex);
        return new ObjectBlockIterator(this, blockValues, query,
                                    startIndex, endIndex);
    }

    public boolean isLoaded() {
        return loaded;
    }

    public void setLoaded(boolean loaded) {
        this.loaded = loaded;
    }

    public int getBlockSize() {
        return blockSize;
    }

    public PrimaryKey getPrimaryKey() {
        return primaryKey;
    }

    public boolean create() throws ErrMsgException, ResKeyException {
        return false;
    }

    abstract public void load() throws ErrMsgException, ResKeyException;
    abstract public boolean save() throws ErrMsgException, ResKeyException;
    abstract public boolean del() throws ErrMsgException, ResKeyException;
    
    abstract public ObjectDb getObjectRaw(PrimaryKey pk);

    
    public int getObjectCount(String sql) {
        return objectCache.getObjectCount(sql);
    }

    public boolean loaded = false;

    public Vector list() {
        return list(QUERY_LIST);
    }

    
    public Vector list(String QUERY_LIST) {
        int total = 0;
        ResultSet rs = null;
        Vector result = new Vector();
        Conn conn = new Conn(connname);
        try {
            
            total = getObjectCount(QUERY_LIST);
            conn.prepareStatement(QUERY_LIST);
            if (total != 0)
                
                conn.setMaxRows(total); 
            rs = conn.executePreQuery();
            if (rs == null) {
                return result;
            } else {
                
                rs.setFetchSize(total); 
                if (rs.absolute(1) == false) {
                    return result;
                }
                do {
                    if (primaryKey.getType()==PrimaryKey.TYPE_INT)
                        result.addElement(getObjectDb(new Integer(rs.getInt(1))));
                    else if (primaryKey.getType()==PrimaryKey.TYPE_STRING)
                        result.addElement(getObjectDb(rs.getString(1)));
                    else if (primaryKey.getType()==PrimaryKey.TYPE_LONG)
                        result.add(getObjectDb(new Long(rs.getLong(1))));
                    else if (primaryKey.getType() == PrimaryKey.TYPE_COMPOUND) {
                        HashMap keys = ((PrimaryKey)primaryKey.clone()).getKeys();
                        Iterator ir = keys.keySet().iterator();
                        while (ir.hasNext()) {
                            String keyName = (String) ir.next();
                            KeyUnit ku = (KeyUnit) keys.get(keyName);
                            if (ku.getType() == primaryKey.TYPE_INT) {
                                ku.setValue(new Integer(rs.getInt(ku.getOrders() + 1)));
                            } else if (ku.getType() == primaryKey.TYPE_LONG) {
                                ku.setValue(new Long(rs.getLong(ku.getOrders() + 1)));
                            } else {
                                ku.setValue(rs.getString(ku.getOrders() + 1));
                            }
                        }
                        result.addElement(getObjectDb(keys));
                    }
                } while(rs.next());
            }
        } catch (SQLException e) {
            logger.error("list: " + e.getMessage());
        } finally {
            if (conn != null) {
                conn.close();
                conn = null;
            }
        }
        return result;
    }

    public Vector list(int start, int end) {
        return list(QUERY_LIST, start, end);
    }

    
    public Vector list(String sql, int start, int end) {
        int total = 0;
        ResultSet rs = null;
        Vector result = new Vector();
        Conn conn = new Conn(connname);
        try {
            
            total = getObjectCount(sql);
            conn.prepareStatement(sql);
            if (total != 0)
                
                conn.setMaxRows(end + 1); 
            rs = conn.executePreQuery();
            if (rs == null) {
                return result;
            } else {
                
                int count = end - start + 1;
                rs.setFetchSize(count); 
                if (rs.absolute(start + 1) == false) {
                    return result;
                }

                int k = 0;
                do {
                    if (primaryKey.getType()==PrimaryKey.TYPE_INT)
                        result.addElement(getObjectDb(new Integer(rs.getInt(1))));
                    else if (primaryKey.getType()==PrimaryKey.TYPE_STRING)
                        result.addElement(getObjectDb(rs.getString(1)));
                    else if (primaryKey.getType()==PrimaryKey.TYPE_LONG) {
                        
                        result.addElement(getObjectDb(new Long(rs.getLong(1))));
                    }
                    else if (primaryKey.getType() == PrimaryKey.TYPE_COMPOUND) {
                        HashMap keys = ((PrimaryKey)primaryKey.clone()).getKeys();
                        Iterator ir = keys.keySet().iterator();
                        while (ir.hasNext()) {
                            String keyName = (String) ir.next();
                            KeyUnit ku = (KeyUnit) keys.get(keyName);
                            if (ku.getType() == primaryKey.TYPE_INT) {
                                ku.setValue(new Integer(rs.getInt(ku.getOrders() + 1)));
                            } else if (ku.getType() == primaryKey.TYPE_LONG) {
                                ku.setValue(new Long(rs.getLong(ku.getOrders() + 1)));
                            } else {
                                ku.setValue(rs.getString(ku.getOrders() + 1));
                            }
                        }
                        result.addElement(getObjectDb(keys));
                    }
                    k++;
                    
                    
                } while(rs.next());
            }
        } catch (SQLException e) {
            logger.error("list: " + e.getMessage());
        } finally {
            if (conn != null) {
                conn.close();
                conn = null;
            }
        }
        return result;
    }

    
    public ListResult listResult(String listsql, int curPage, int pageSize) throws
             ErrMsgException {
         int total = 0;
         ResultSet rs = null;
         Vector result = new Vector();

         ListResult lr = new ListResult();
         lr.setTotal(total);
         lr.setResult(result);

         Conn conn = new Conn(connname);
         try {
             
             String countsql = SQLFilter.getCountSql(listsql);
             rs = conn.executeQuery(countsql);
             if (rs != null && rs.next()) {
                 total = rs.getInt(1);
             }
             if (rs != null) {
                 rs.close();
                 rs = null;
             }

             
             int totalpages = (int) Math.ceil((double) total / pageSize);
             if (curPage > totalpages)
                 curPage = totalpages;
             if (curPage <= 0)
                 curPage = 1;

             if (total != 0)
                 conn.setMaxRows(curPage * pageSize); 

             rs = conn.executeQuery(listsql);
             if (rs == null) {
                 return lr;
             } else {
                 rs.setFetchSize(pageSize);
                 int absoluteLocation = pageSize * (curPage - 1) + 1;
                 if (rs.absolute(absoluteLocation) == false) {
                     return lr;
                 }
                 do {
                     if (primaryKey.getType()==PrimaryKey.TYPE_INT) {
                         result.addElement(getObjectDb(new Integer(rs.getInt(1))));
                     }
                     else if (primaryKey.getType()==PrimaryKey.TYPE_STRING)
                         result.addElement(getObjectDb(rs.getString(1)));
                     else if (primaryKey.getType()==PrimaryKey.TYPE_LONG)
                         result.addElement(getObjectDb(new Long(rs.getLong(1))));
                     else if (primaryKey.getType() == PrimaryKey.TYPE_COMPOUND) {
                         HashMap keys = ((PrimaryKey)primaryKey.clone()).getKeys();
                         Iterator ir = keys.keySet().iterator();
                         while (ir.hasNext()) {
                             String keyName = (String) ir.next();
                             KeyUnit ku = (KeyUnit) keys.get(keyName);
                             if (ku.getType() == primaryKey.TYPE_INT) {
                                 ku.setValue(new Integer(rs.getInt(ku.getOrders() + 1)));
                             } else if (ku.getType() == primaryKey.TYPE_LONG ) {
                                 ku.setValue(new Long(rs.getLong(ku.getOrders() + 1)));
                             } else {
                                 ku.setValue(rs.getString(ku.getOrders() + 1));
                             }
                         }
                         result.addElement(getObjectDb(keys));
                     }
                 } while (rs.next());
             }
         } catch (SQLException e) {
             logger.error("listResult:" + e.getMessage());
             throw new ErrMsgException("Db error.");
         } finally {
             if (rs != null) {
                 try {
                     rs.close();
                 } catch (Exception e) {}
                 rs = null;
             }
             if (conn != null) {
                 conn.close();
                 conn = null;
             }
         }

         lr.setResult(result);
         lr.setTotal(total);
         return lr;
    }

    
    public void setBlockSize(int blockSize) {
        this.blockSize = blockSize;
    }

    public String getTableName() {
        return tableName;
    }

    private int blockSize = 100;
}