通用数据库查询分析器Java实现

package com.test.db;

import java.sql.Connection;
import java.sql.SQLException;
import java.util.List;
import java.util.Map;
/**
*数据库查询接口
*QQ：414361207
*/
 public interface Query {
	/**
	 * 执行查询
	 * @param sql
	 * @return
	 */
	public abstract Map<String,Object> query(String sql);
	/**
	 * 执行增删改
	 * @param sql
	 * @return
	 */
	public abstract Map<String,Object> update(String sql);
	/**
	 * 返回dbName中所有的表、视图、存储过程对象
	 * @param dbName 数据库
	 * @param map数据连接信息
	 * @return
	 */
	public abstract Map<Type,List<SampleData>> getTables(Map<String,String> map) throws SQLException;
	/**
	 * 查询表的列对象
	 * @param map数据连接信息
	 * @param tableName表名
	 * @return
	 * @throws SQLException
	 */
	public abstract Map<Type,List<SampleData>> getColumnsOfTable(Map<String,String> map,String tableName) throws SQLException;
	/**
	 * 查询表的键对象
	 * @param map数据连接信息
	 * @param tableName表名
	 * @return
	 * @throws SQLException
	 */
	public abstract Map<Type,List<SampleData>> getKeysOfTable(Map<String,String> map,String tableName) throws SQLException;
	/**
	 * 查询表的索引对象
	 * @param map数据连接信息
	 * @param tableName表名
	 * @return
	 * @throws SQLException
	 */
	public abstract Map<Type,List<SampleData>> getIndexsOfTable(Map<String,String> map,String tableName) throws SQLException;
	/**
	 * 返回当前的数据库名称
	 * @param sql
	 * @return
	 */
	public abstract String getDbName();
	/**
	 * 获取数据库的链接信息
	 * @return
	 */
	public abstract Map<String,String> getLinkInfo(); 
	/**
	 * 释放连接
	 */
	public abstract void closeConnection();
	/**
	 * 重新设置连接
	 * @param connection
	 */
	public abstract void setConnection(Connection connection);

}
package com.test.db;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.PrintWriter;
import java.lang.reflect.InvocationTargetException;
import java.util.Date;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import java.sql.Connection ;


public class Tool {
	public static Properties prop;
	private static boolean state=false;
	static
	{
		prop=new Properties();
		try {
			prop.load(Tool.class.getResourceAsStream("dbInfo.properties"));
		} catch (IOException e) {
			
			e.printStackTrace();
		}
	}
	/**
	 * 对应数据库的Query对象
	 * @param connection
	 * @param linkInfo
	 * @param type
	 * @return
	 * @throws IllegalArgumentException
	 * @throws SecurityException
	 * @throws InstantiationException
	 * @throws IllegalAccessException
	 * @throws InvocationTargetException
	 * @throws NoSuchMethodException
	 * @throws ClassNotFoundException
	 */
	public static Query getQuery(Connection connection,Map<String,String> linkInfo,String type)
			throws IllegalArgumentException, SecurityException,
			InstantiationException, IllegalAccessException,
			InvocationTargetException, NoSuchMethodException,
			ClassNotFoundException {
		if("true".equals(prop.getProperty("CommonQuery")))
		{
			return new CommonQuery(connection,linkInfo,prop.getProperty("getDbName_"+type),prop.getProperty("getTables_"+type),prop.getProperty("getColumnsOfTable_"+type),prop.getProperty("getIndexsOfTable_"+type),prop.getProperty("getKeysOfTable_"+type));
		}
		return (Query) Class.forName(prop.getProperty(type)).getConstructor(
				Connection.class,Map.class).newInstance(connection,linkInfo);
		
	}
	/**
	 * 获取所有的数据库类型
	 * @return
	 */
	public static String[] getAllDBType()
	{
		return prop.getProperty("database_type").split(",");
	}
	/**
	 * 获取数据库驱动类
	 * @param key Driver_数据库类型
	 * @return
	 */
	public static String getDriverClass(String key)
	{
		return prop.getProperty(key);
	}
	/**
	 * 验证期限
	 * @return true可用 false不可用
	 */
    public static boolean invalidate()
    {
       try {
    	   if(!state)
    	   {
    		   Properties register=new Properties();
    		   String currentDir=System.getProperty("currentDir");
    		   register.load(new FileInputStream(currentDir+"\\register.properties"));
    		   Set keys=register.keySet();
    		   int count=0;
    		   String key=null;//使用期限
    		   String value=null;//密码
    		   if(keys.size()>1)
    		   {
    			   return false;
    		   }
    		   for(Object o:keys)
    		   {
    			   if(count==0)
    			   {
    				   key=o.toString();
    				   value=register.getProperty(key);
    				   break;
    			   }
    		   }
        	   if((!DBUtil.isEmpty(key))&&(!DBUtil.isEmpty(value)))
        	   {
        		   Long rs=Long.valueOf(decrypt(key,value));
        		   if(System.currentTimeMillis()<rs)
        		   {
        			   state=true;
        			   return true;
        		   }
        	   }
    	   }
    	   else
    	   {
    		   return state;
    	   }
	   } catch (Exception e) {
		      // TODO Auto-generated catch block
		      e.printStackTrace();
	   }
       return false;
    }
    /**
     * 注册
     */
    public static void register()
    {
    	Date current=new Date();
    	int month=current.getMonth();
    	current.setMonth(month+1);
    	long registerTime=current.getTime();
    	state=true;
    	try {
    		String currentDir=System.getProperty("currentDir");
			PrintWriter out=new PrintWriter(new File(currentDir+"\\register.properties"));
			out.println(registerTime+"="+encrypt(String.valueOf(registerTime)));
			out.close();
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
    }
    /**
     * 加密
     * @param key 最后使用期限
     * @return
     */
    private static String encrypt(String key)
    {
        String str=key+"this is a common sql query operation and get register code before link to database instance";
        String str2="ZZCH-"+key+decode(str);
        return change(str2);   
    }
    /**
     * 解密 
     * @param key 最后使用期限
     * @param value 密码
     * @return
     */
    private static String decrypt(String key,String value)
    {
    	String code=encrypt(key);
        if(code.equals(value))
        {//两次密码一致验证通过
        	return key;
        }
        return null;   
    }
  private static int decode(String s)
    {
      int i = 0;
      char[] ac = s.toCharArray();
      int j = 0;
      int k = ac.length;
      while (j < k) {
        i = 31 * i + ac[j];
        ++j;
      }
      return Math.abs(i);
    }

    private static String change(String s)
    {
      byte[] abyte0 = s.getBytes();
      char[] ac = new char[s.length()];
      int i = 0;
      int k = abyte0.length;
      while (i < k) {
        int j = abyte0[i];
        if ((j >= 48) && (j <= 57))
          j = (j - 48 + 5) % 10 + 48;
        else if ((j >= 65) && (j <= 90))
          j = (j - 65 + 13) % 26 + 65;
        else if ((j >= 97) && (j <= 122))
          j = (j - 97 + 13) % 26 + 97;

        ac[i] = (char)j;
        ++i;
      }
      return String.valueOf(ac); }
}