222

intf.db

package com.intf.db;

/**
 * 异常枚举定义
 * @author
 */
public enum BookExceptionEnum
{
    /**
     * 未知错误
     */
    UNKOWN_ERROR(1000, "UNKOWN_ERROR"),
    /**
     * 参数错误
     */
    PARAMETER_ERROR(1001, "PARAMETER_ERROR"),
    /**
     * 资源沒发现`

     */
    NOT_RESOURCE_ERROR(1002, "NOT_RESOURCE_ERROR"),
    /**
     * 数据库异常

     */
    DATABASE_ERROR(1003, "DATABASE_ERROR"),

    /**
     * 插入数据库失败

     */
    DB_INSERT_ERROR(1004, "DB_INSERT_ERROR"),
    /**
     * 删除数据库失败

     */
    DB_DELETE_ERROR(1005, "DB_DELETE_ERROR"),

    /**
     * 查询数据库失败

     */
    DB_QUERY_ERROR(1005, "DB_QUERY_ERROR"),

    /**
     * 更新数据库失败

     */
    DB_UPDATE_ERROR(1005, "DB_UPDATE_ERROR"),

    /*** begin 登录异常定义 **/
    LOGIN_USERNAME_OR_PASSWORD_ERROR(1101, "LOGIN_USERNAME_OR_PASSWORD_ERROR"),
    
    LOGIN_STATE_LOCK_ERROR(1102 , "LOGIN_STATE_LOCK_ERROR"),
    
    LOGIN_NOT_AUDITING_ERROR(1103, "LOGIN_NOT_AUDITING_ERROR"),
    
    LOGIN_ERROR(1104, "LOGIN_ERROR"),
    USER_ALREADY_LOGIN(1105, "USER_ALREADY_LOGIN"),
    USERNAME_EMPTY(1106, "USERNAME_EMPTY"),
    PASSWORD_EMPTY(1107, "PASSWORD_EMPTY"),
    USER_HASNOT_LOGIN(1108, "USER_HASNOT_LOGIN");
    /*** end 登录异常定义 **/

    private int id;
 
    private String description;

    /**
     * 构造方法

     * @param id 异常枚举
     * @param description 异常内容描述
     */
    private BookExceptionEnum(int id, String description)
    {
        this.id = id;
        this.description = description;
    }

    /**
     * 获取Id
     * @return int [返回类型说明]
     */
    public final int getId()
    {
        return id;
    }

    /**
     * 获取Description
     * @return String [返回类型说明]
     */
    public final String getDescription()
    {
        return description;
    }

    /**
     * 根据类型获取枚举值

     * @param enumNum 异常枚举
     * @return enumNum [返回类型说明]
     */
    public static BookExceptionEnum getSmartExceptionEnum(int enumNum)
    {
        for (BookExceptionEnum tempEnumNum : BookExceptionEnum.values())
        {
            if (tempEnumNum.getId() == enumNum)
            {
                return tempEnumNum;
            }
        }
        return UNKOWN_ERROR;
    }
}

package com.intf.db;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 该原注释主要是用来标识属性set方法
 *
 * @author
 */
@Retention(RetentionPolicy.RUNTIME)
@Target( { ElementType.METHOD })
public @interface BookMethodDesc
{
    String propertyName() default "";
}

package com.intf.db;

import java.io.Serializable;

/**
 * 分页描述类

 * @author
 */
public class BookPageBean implements Serializable
{

    /**
     * 实现序列化

     */
    private static final long serialVersionUID = -3254069391075856353L;

    /** 默认每页显示记录数 */
    public static final int PAGECURRENT = 12;

    /** 每页显示条数 */
    private int pageSize = PAGECURRENT;

    /** 当前页数 默认第一页 */
    private int currPageNum = 0;

    /** *数据总记录数 */
    private int dataCount;

    /** 总页数 */
    private int pageCount;

    /** 是否采用本地分页 */
    private boolean flag = true;

    /**
     * 是否采用本地分页
     * @return boolean
     */
    public boolean isFlag()
    {
        return flag;
    }

    /**
     * 是否采用本地分页
     * @param flag true or false
     */
    public void setFlag(boolean flag)
    {
        this.flag = flag;
    }

    /**
     * 获取每页显示条数
     * @return int
     */
    public int getPageSize()
    {
        return pageSize;
    }

    /**
     * 设置每页显示条数
     * @param pageSize 每页显示条数
     */
    public void setPageSize(int pageSize)
    {
        this.pageSize = pageSize;
    }

    /**
     * 获取当前页

     * @return int
     */
    public int getCurrPageNum()
    {
        return currPageNum;
    }

    /**
     * 设置当前页

     * @param currPageNum 设当前前页

     */
    public void setCurrPageNum(int currPageNum)
    {
        this.currPageNum = currPageNum;
    }

    /**
     * 获取数据总记录数
     * @return int
     */
    public int getDataCount()
    {
        return dataCount;
    }

    /**
     * 设置数据总记录数
     * @param dataCount 数据总记录数
     */
    public void setDataCount(int dataCount)
    {
        this.dataCount = dataCount;
        if (dataCount != 0)
        {
            int number = (dataCount % pageSize) == 0 ? dataCount / pageSize : dataCount / pageSize + 1;
            if (number == 0)
            {
                number = 1;
            }
            setPageCount(number);
            if (this.getCurrPageNum() > this.getPageCount())
            {
                this.setCurrPageNum(this.getPageCount());
            }
            else if (this.getCurrPageNum() <= 0)
            {
                this.setCurrPageNum(1);
            }
        }
        else
        {
            this.setCurrPageNum(0);
        }

    }

    /**
     * 获取总页数

     * @return int
     */
    public int getPageCount()
    {
        return pageCount;
    }

    /**
     * 设置总页数

     * @param pageCount 页数
     */
    public void setPageCount(int pageCount)
    {
        this.pageCount = pageCount;
    }

    /**
     * 实现tostring方法
     * @return String
     */
    public String toString()
    {
        StringBuilder tempBuilder = new StringBuilder();
        tempBuilder.append("[{'currPageNum':").append(currPageNum).append("},{").append("'pageCount':").append(
                pageCount).append("}]");
        return tempBuilder.toString();
    }
}

package com.intf.db;

import java.beans.BeanInfo;
import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;




/**
 * 存储过程描述对象
 * @author
 */
public class BookPrepareInfo implements BookTypes
{
    /** 存储过程名称 */
    private String prepareName;

    /** 但返回结果集的时候需指定该对象类型 */
    private Class<Object> clas;

    /** 输入参数保存 */
    private List<BookTypeInfo> paramList = new ArrayList<BookTypeInfo>();

    private BookPageBean pageBean = null;

    /** 返回值定义 */
    // private List<BookTypeInfo> returnValueds = new ArrayList<BookTypeInfo>();
    /**
     * 设置存储过程的名字

     * @param name 设置存储过程名称
     */
    public void setPrepareName(String name)
    {
        this.prepareName = name;
    }

    /**
     * 设置存储过程参数列表
     * @param value 属性值

     * @param type 属性类型

     * @param paramMode 参数模式，指定输入还是输出

     */
    public void addParameter(Object value, int type, int paramMode)
    {
        BookTypeInfo bookType = new BookTypeInfo();
        bookType.setTypeValue(value);
        bookType.setType(type);
        bookType.setParamMode(paramMode);
        paramList.add(bookType);
    }

    /**
     * 设置存储过程参数列表
     * @param value 属性值

     * @param type 属性类型

     * @param key 返回值对应的健

     */
    public void addReturnParameter(Object value, String key, int type)
    {
        BookTypeInfo bookType = new BookTypeInfo();
        bookType.setTypeValue(value);
        bookType.setType(type);
        bookType.setParamMode(BookTypeInfo.OUT_PUT);
        bookType.setKey(key);
        paramList.add(bookType);
    }

    /**
     * 设置结果集返回的类型
     * @param clas 返回类型指定
     */
    @SuppressWarnings("unchecked")
    public void setResultType(Class clas)
    {
        this.clas = clas;
    }

    /**
     * 获取结果集返回的类型
     * @return Class<Object>
     */
    public Class<Object> getClas()
    {
        return clas;
    }

    /**
     * 获取参数类型信息
     * @return List<BookTypeInfo>
     */
    public List<BookTypeInfo> getParamList()
    {
        return paramList;
    }

    /**
     * 获取存储过程名称
     * @return String
     */
    public String getPrepareName()
    {
        return prepareName;
    }

    /**
     * 方法回调
     * @param result 结果集

     * @param str 数据库返回字段

     * @throws SQLException
     * @throws InvocationTargetException
     * @throws IllegalAccessException
     * @throws IntrospectionException
     * @throws InstantiationException
     * @return Object
     */
    public Object methodInvoke(ResultSet result, StringBuilder str) throws IllegalAccessException,
            InvocationTargetException, SQLException, IntrospectionException, InstantiationException
    {
        String cStr = str.toString().toLowerCase();
        Object obj = this.clas.newInstance();
        BeanInfo beanInfo = Introspector.getBeanInfo(this.clas);
        PropertyDescriptor[] propertys = beanInfo.getPropertyDescriptors();

        for (int i = 0; i < propertys.length; i++)
        {
            String propertyName = propertys[i].getName();
            Method method = propertys[i].getWriteMethod();
            if (method == null)
            {
                continue;
            }
            BookMethodDesc desc = method.getAnnotation(BookMethodDesc.class);
            propertyName = desc == null ? propertyName : desc.propertyName();
            Object value = null;
            try
            {
                if (cStr.indexOf(propertyName.toLowerCase()) != -1)
                {
                    value = result.getObject(propertyName);
                    method.invoke(obj, value);
                }
            }
            catch (Exception ex)
            {
                continue;
            }
        }
        return obj;
    }

    /**
     * 获取分页bean
     * @return BookPageBean
     */
    public BookPageBean getPageBean()
    {
        return pageBean;
    }

    /**
     * 设置分页bean
     * @param pageBean 分页对象
     */
    public void setPageBean(BookPageBean pageBean)
    {
        
        this.pageBean = pageBean;
    }

}

package com.intf.db;

import java.beans.IntrospectionException;
import java.lang.reflect.InvocationTargetException;
import java.sql.CallableStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;



/**
 * 存储过程执行结果记录
 * @author
 */
public class BookResult
{
    /** 存储过程执行的返回参数列表 */
    private List<Object> returnValue = new ArrayList<Object>();

    /** 返回值以健值队的形式存储 */
    private Map<String, Object> returnMap = new HashMap<String, Object>();

    /** 存储过程执行查询结果集合 */
    private List<Object> list = new ArrayList<Object>();

    /**
     * 存储过程执行的返回参数列表
     * @return List<Object>
     */
    public List<Object> getReturnValues()
    {
        return returnValue;
    }

    /**
     * 存储过程执行查询结果集合
     * @return List<Object>
     */
    public List<Object> getResultSet()
    {
        return list;
    }

    /**
     * 设置结果集
     * @param list 数据列表
     */
    public void setList(List<Object> list)
    {
        this.list = list;
    }

    /**
     * 返回值队列
     * @return Map<String, Object>
     */
    public Map<String, Object> getReturnMap()
    {
        return returnMap;
    }

    /**
     * 结果包装
     * @param statement 数据库操作对象
     * @param info 存储过程信息描述
     * @throws SQLException
     */
    public final void resultPackaging(CallableStatement statement, BookPrepareInfo info)
            throws SQLException
    {
        List<BookTypeInfo> paramList = info.getParamList();
        for (int i = 1; i <= paramList.size(); i++)
        {
            BookTypeInfo tempTypeInfo = paramList.get(i - 1);

            if (tempTypeInfo.getParamMode() == BookTypeInfo.OUT_PUT)
            {
                Object obj = statement.getObject(i);
                List<Object> returnValue = this.getReturnValues();
                returnValue.add(obj);

                if (null != tempTypeInfo.getKey() && !"".equals(tempTypeInfo.getKey()))
                {
                    Map<String, Object> returnMap = this.getReturnMap();
                    returnMap.put(tempTypeInfo.getKey(), obj);
                }
            }
        }
    }

    /**
     * 结果集封装
     * @param result 结果集
     * @param info 存储过程描述对象
     * @throws SQLException
     * @throws IntrospectionException
     * @throws NoSuchFieldException
     * @throws SecurityException
     * @throws InvocationTargetException
     * @throws IllegalAccessException
     * @throws IllegalArgumentException
     * @throws InstantiationException
     */
    public final void resultSetListPackaging(ResultSet result, BookPrepareInfo info) throws SQLException,
            IntrospectionException, IllegalAccessException, InvocationTargetException, InstantiationException
    {

        List<Object> resultList = new ArrayList<Object>();
        BookPageBean pageBean = info.getPageBean();
        ResultSetMetaData resultNames = result.getMetaData();
        StringBuilder builder = new StringBuilder();
        for (int i = 1; i <= resultNames.getColumnCount(); i++)
        {
            builder.append(resultNames.getColumnName(i)).append(",");
        }

        if (pageBean != null && pageBean.isFlag())
        {
            int index = 0;

            int pageSize = pageBean.getPageSize() * (pageBean.getCurrPageNum() - 1);

            while (result.next())
            {
                index++;
                if (index > pageSize)
                {
                    Object obj = info.methodInvoke(result, builder);
                    resultList.add(obj);
                    if (resultList.size() == pageBean.getPageSize())
                    {
                        break;
                    }
                }
            }
        }
        else
        {
            while (result.next())
            {
                Object obj = info.methodInvoke(result, builder);
                resultList.add(obj);
            }
        }
        this.setList(resultList);
    }

    // /**
    // * BookResult 描述
    // * @return String
    // */
    // public String toString()
    // {
    // StringBuilder builder = new StringBuilder();
    // builder.append("BookResult = { returnValue = ").append(returnValue).append("  returnMap = ").append(
    // returnMap).append(" ResultSet = ").append(list).append(" }");
    //
    // return builder.toString();
    // }

}

package com.intf.db;

/**
 * Book类型信息
 *
 * @author
 */
public class BookTypeInfo
{
    /** 表示输出参数 */
    public static final int OUT_PUT = 0;
    /** 表示输入参数 */
    public static final int IN = 1;

    /** 类型值 */
    private Object typeValue;
    /** 类型 */
    private int type;
    /** 参数模式 */
    private int paramMode = BookTypeInfo.IN;

    /** 返回值对应的KEY */
    private String key = "";

    /**
     * 参数模式
     *
     * @return int
     */
    public int getParamMode()
    {
        return paramMode;
    }

    /**
     * 设置参数模式
     *
     * @param paramMode 参数模式
     */
    public void setParamMode(int paramMode)
    {
        this.paramMode = paramMode;
    }

    /**
     * 获取类型value
     *
     * @return Object
     */
    public Object getTypeValue()
    {
        return typeValue;
    }

    /**
     * 设置类型值

     *
     * @param typeValue 类型值

     */
    public void setTypeValue(Object typeValue)
    {
        this.typeValue = typeValue;
    }

    /**
     * 获取类型
     *
     * @return int
     */
    public int getType()
    {
        return type;
    }

    /**
     * 设置类型
     *
     * @param type 类型
     */
    public void setType(int type)
    {
        this.type = type;
    }

    /**
     * 获取返回值的key
     *
     * @return String
     */
    public String getKey()
    {
        return key;
    }

    /**
     * 设置返回值得key
     *
     * @param key 返回值的key
     */
    public void setKey(String key)
    {
        this.key = key;
    }
}

package com.intf.db;
/**
 * Book系统JDBC框架数据类型定义
 * @author
 */
public interface BookTypes
{

    public final static int BIT = -7;

    public final static int TINYINT = -6;

    public final static int SMALLINT = 5;

    public final static int INTEGER = 4;

    public final static int BIGINT = -5;

    public final static int FLOAT = 6;

    public final static int REAL = 7;

    public final static int DOUBLE = 8;

    public final static int NUMERIC = 2;

    public final static int DECIMAL = 3;

    public final static int CHAR = 1;

    public final static int VARCHAR = 12;

    public final static int LONGVARCHAR = -1;

    public final static int DATE = 91;

    public final static int TIME = 92;

    public final static int TIMESTAMP = 93;

    public final static int BINARY = -2;

    public final static int VARBINARY = -3;

    public final static int LONGVARBINARY = -4;

    public final static int NULL = 0;

    public final static int OTHER = 1111;

    public final static int JAVA_OBJECT = 2000;

    public final static int DISTINCT = 2001;

    public final static int STRUCT = 2002;

    public final static int ARRAY = 2003;

    public final static int BLOB = 2004;

    public final static int CLOB = 2005;

    public final static int REF = 2006;

    public final static int DATALINK = 70;

    public final static int BOOLEAN = 16;

    // ------------------------- JDBC 4.0 -----------------------------------

    public final static int ROWID = -8;

    public static final int NCHAR = -15;

    public static final int NVARCHAR = -9;

    public static final int LONGNVARCHAR = -16;

    public static final int NCLOB = 2011;

    public static final int SQLXML = 2009;
}

package com.intf.db;

import java.io.Serializable;

/**
 * 返回结果bean
 * @author
 */
public class Result implements Serializable
{

    private static final long serialVersionUID = 1L;
    private String result;

    /**
     * @return result 结果
     */
    public String getResult()
    {
        return result;
    }

    /**
     * @param result 返回结果
     */
    @BookMethodDesc(propertyName = "ok")
    public void setResult(String result)
    {
        this.result = result;
    }

}

package com.intf.db;

import java.util.List;


import com.bean.TestTco;
import com.bean.TestVar;


public interface StationInformationIntf
{
       
    public  static final String PRO_SITE_VAR_IN = "PRO_SITE_VAR_IN";
    public  static final String PRO_SITE_TCO_IN = "PRO_SITE_TCO_IN";
    public  static final String PRO_SITE_VAR_QUERY_BY_SITENAME = "PRO_SITE_VAR_QUERY_BY_SITENAME";
    public  static final String PRO_SITE_VAR_QUERY_BY_SITEID = "PRO_SITE_VAR_QUERY_BY_SITEID";
    public  static final String PRO_SITE_TCO_QUERY_BY_SITENAME = "PRO_SITE_TCO_QUERY_BY_SITENAME";
    public  static final String PRO_SITE_TCO_QUERY_BY_SITEID = "PRO_SITE_TCO_QUERY_BY_SITEID";
    public  static final String PRO_SITE_VAR_QUERY_BY_PROJECTID = "PRO_SITE_VAR_QUERY_BY_PROJECTID";
    public  static final String PRO_SITE_TCO_QUERY_BY_PROJECTID = "PRO_SITE_TCO_QUERY_BY_PROJECTID";
       
    /*
     * 增加工堪变量信息
     */
    
    @SuppressWarnings("unchecked")
    public boolean addStationInformation(List list,int projectId);
    /*
     * 增加工堪Tco信息
     */
    
    @SuppressWarnings("unchecked")
    public boolean addStationTcoInformation(List list,int projectId);    
    
    /*
     * 根据站点名获取整个的站点的软件变量信息
     */
    
    public TestVar getStationVarInformationAllByName(String sitename,int projectId);
    
    /*
     * 根据站点id获取整个的站点的软件变量信息
     */
    
    public TestVar getStationVarInformationById(String siteid,int projectId);
        
    /*
     *  根据站点名获取整个的站点的TCO信息
     */
    
    public TestTco getStationTcoInformationAllByName(String sitename,int projectId);
    
    
    /*
     *  根据站点id获取整个的站点的TCO信息
     */
    
    public TestTco getStationTcoInformationById(String siteid,int projectId);
    /*
     * 获取整个的站点的软件变量信息
     */
    
    public List<TestVar> getStationVarInformationByProjectId(int projectId);
        
    /*
     * 获取整个的站点的TCO信息
     */
    
    public List<TestTco> getStationTcoInformationByProjectId(int projectId);
}

package com.intf.db;

import java.sql.Connection;
import java.sql.SQLException;

/**
 * 数据库连接池接口定义
 *
 * @author
 */
public interface SysConnPool
{
    /**
     * 从连接池中返回数据库连接
     *
     * @return Connection
     * @throws SQLException
     */
    public Connection getConnection() throws SQLException;
}

package com.intf.db;

import com.intf.exception.BookDBException;


/**
 * 数据库操作接口
 * @author
 */
public interface SysStatement
{
//    /**
//     * 提交事务
//     */
//    public void commit();
//    
//    /**
//     * 事务回滚
//     */
//    public void rollback();

    /**
     * 执行操作之后返回结果
     * @param info 存储过程描述对象
     * @return BookResult 返回结果
     */
    public BookResult execute(BookPrepareInfo info) throws BookDBException;

    /**
     * 执行查询之后返回结果集
     * @param info 存储过程描述对象
     * @return BookResult 返回结果集
     */
    public BookResult executeQuery(BookPrepareInfo info) throws BookDBException;

    /**
     * 执行操作之后返回结果
     * @param info 存储过程描述对象
     * @param flag true表示自动提交，false不提交。
     * @return BookResult 返回结果
     */
    public BookResult executeEx(BookPrepareInfo info, boolean flag) throws BookDBException;

    /**
     * 执行查询之后返回结果集
     * @param info 存储过程描述对象
     * @param flag true表示自动提交，false不提交。
     * @return BookResult 返回结果集
     */
    public BookResult executeQueryEx(BookPrepareInfo info, boolean flag) throws BookDBException;
}