代码修改

starter/mysql-starter/pom.xml

@@ -22,6 +22,11 @@
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>commons-dbutils</groupId>
            <artifactId>commons-dbutils</artifactId>
            <version>1.6</version>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-dbcp2</artifactId>

starter/mysql-starter/src/main/java/com/yihu/mysql/enums/DBType.java

@@ -0,0 +1,12 @@
package com.yihu.mysql.enums;
/**
 * Created by hzp on 2015/12/1.
 */
public enum DBType{
    Oracle,
    Mysql,
    Sqlserver,
    Hive,
    Sqlite
}

starter/mysql-starter/src/main/java/com/yihu/mysql/enums/Logical.java

@@ -0,0 +1,12 @@
package com.yihu.mysql.enums;
/**
 * 关系类型枚举
 * Created by hzp on 2015/12/1.
 */
public class Logical {
    public static final String AND = "AND";
    public static final String OR = "OR";
    public static final String NOT = "NOT";
}

starter/mysql-starter/src/main/java/com/yihu/mysql/enums/Operation.java

@@ -0,0 +1,23 @@
package com.yihu.mysql.enums;
/**
 * 条件类型枚举
 * Created by hzp on 2015/12/1.
 */
public class Operation {
    public static final String EQ = "=";//等于
    public static final String NE = "!=";//不等于
    public static final String GT = ">";//大于
    public static final String GTE = ">=";//大于等于
    public static final String LT = "<";//小于
    public static final String LTE = "<=";//小于等于
    public static final String IN = "IN";//in
    public static final String NIN = "NOTIN";//not in
    public static final String LIKE = "LIKE"; //like
    public static final String LEFTLIKE = "LEFTLIKE"; //LEFTLIKE
    public static final String RIGHTLIKE = "RIGHTLIKE"; //RIGHTLIKE
    public static final String RANGE = "RANGE"; //RANGE
    public static final String NOTRANGE = "NOTRANGE"; //RANGE
}

starter/mysql-starter/src/main/java/com/yihu/mysql/jdbc/ConnectionFactory.java

@@ -0,0 +1,106 @@
package com.yihu.mysql.jdbc;
import com.yihu.mysql.enums.DBType;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Service;
import java.sql.Connection;
import java.util.HashMap;
/**
 * 数据库连接工厂类
 * @created hzp on 2015/6/2
 */
@Service
@Scope(ConfigurableBeanFactory.SCOPE_SINGLETON)
public class ConnectionFactory {
    String defaultName = "defaultName";
    @Value("${spring.datasource.url}")
    String defaultUri;
    @Value("${spring.datasource.username}")
    String defaultUser;
    @Value("${spring.datasource.password}")
    String defaultPassword;
    private final static HashMap<String, ConnectionPool> pools = new HashMap<>();
    /**
     * 使用连接池中连接
     */
    public Connection getConnection(String name) throws Exception {
        ConnectionPool source = pools.get(name);
        if(source!=null) {
            return source.getConnection();
        }
        else{
            throw new Exception("数据库连接已丢失！");
        }
    }
    /**
     * 使用默认连接
     */
    public Connection getConnection() throws Exception {
        ConnectionPool source = pools.get(defaultName);
        if(source != null) {
            return source.getConnection();
        }
        else{
            source = new ConnectionPool(defaultUri, defaultUser, defaultPassword);
            pools.put(defaultName, source);
            return source.getConnection();
        }
    }
    /**
     * 使用默认连接
     */
    public Connection getConnection(String name,String uri) throws Exception {
        ConnectionPool source = pools.get(name);
        if (source != null) {
            return source.getConnection();
        } else{
            source = new ConnectionPool(uri);
            pools.put(name, source);
            return source.getConnection();
        }
    }
    /**
     * 使用配置连接
     */
    public Connection getConnection(String name,String uri,String user,String password) throws Exception {
        ConnectionPool source = pools.get(name);
        if(source != null) {
            return source.getConnection();
        } else{
            source = new ConnectionPool(uri, user, password);
            pools.put(name, source);
            return source.getConnection();
        }
    }
    /**
     * 获取数据库类型
     * @return
     */
    public DBType getDbType(){
        return getDbType(defaultUri);
    }
    /**
     * 获取数据库类型
     * @return
     */
    public DBType getDbType(String uri){
        return DBDriver.getDbType(uri);
    }
}

starter/mysql-starter/src/main/java/com/yihu/mysql/jdbc/ConnectionPool.java

@@ -0,0 +1,56 @@
package com.yihu.mysql.jdbc;
import org.apache.commons.dbcp2.DriverManagerConnectionFactory;
import org.apache.commons.dbcp2.PoolableConnection;
import org.apache.commons.dbcp2.PoolableConnectionFactory;
import org.apache.commons.dbcp2.PoolingDataSource;
import org.apache.commons.pool2.impl.GenericObjectPool;
import java.sql.Connection;
/**
 *  JDBC数据库连接池
 * Created by hzp on 2016-04-29.
 */
public class ConnectionPool {
    private DriverManagerConnectionFactory connectionFactory; //数据库连接工厂
    private PoolableConnectionFactory poolableConnectionFactory; //可池化数据库连接
    private GenericObjectPool<PoolableConnection> connectionPool;
    public ConnectionPool(String uri) {
        DBDriver.registerDriver(uri);
        connectionFactory = new DriverManagerConnectionFactory(uri, null);
        poolableConnectionFactory = new PoolableConnectionFactory(connectionFactory, null);
        connectionPool = new GenericObjectPool<>(poolableConnectionFactory);
        connectionPool.setMaxIdle(20);
        connectionPool.setMaxTotal(30);
        poolableConnectionFactory.setPool(connectionPool);
    }
    /**
     * 账号密码登录
     * @param uri
     * @param user
     * @param password
     */
    public ConnectionPool(String uri,String user,String password) {
        DBDriver.registerDriver(uri);
        connectionFactory = new DriverManagerConnectionFactory(uri, user,password);
        poolableConnectionFactory = new PoolableConnectionFactory(connectionFactory, null);
        connectionPool = new GenericObjectPool<>(poolableConnectionFactory);
        poolableConnectionFactory.setPool(connectionPool);
    }
    /**
     * 获取数据库连接
     * @return
     */
    public Connection getConnection() throws Exception{
        return new PoolingDataSource<>(connectionPool).getConnection();
    }
}

starter/mysql-starter/src/main/java/com/yihu/mysql/jdbc/DBDriver.java

@@ -0,0 +1,66 @@
package com.yihu.mysql.jdbc;
import com.yihu.mysql.enums.DBType;
/**
 * 数据库驱动
 * Created by hzp on 20160324.
 */
public class DBDriver {
    /**
     * 驱动注册
     */
    public static void registerDriver(String uri) {
        try {
            Class.forName(DBDriver.getDriver(uri));
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
    /**
     * 获取驱动类型
     * @return
     */
    public static String getDriver(String uri) {
        if (uri.startsWith("jdbc:mysql")) {
            return "com.mysql.jdbc.Driver";
        } else if (uri.startsWith("jdbc:oracle")) {
            return "oracle.jdbc.driver.OracleDriver";
        } else if (uri.startsWith("jdbc:hive2")) {
            return "org.apache.hive.jdbc.HiveDriver";
        } else if (uri.startsWith("jdbc:microsoft:sqlserver")) {
            return "com.microsoft.jdbc.sqlserver.SQLServerDriver";
        } else if (uri.startsWith("jdbc:sqlite")) {
            return "org.sqlite.JDBC";
        } else {
            return "";
        }
    }
    /**
     * 获取数据库类型
     * @return
     */
    public static DBType getDbType(String uri){
        if (uri.startsWith("jdbc:mysql")) {
            return DBType.Mysql;
        } else if (uri.startsWith("jdbc:oracle")) {
            return DBType.Oracle;
        } else if (uri.startsWith("jdbc:hive2")) {
            return DBType.Hive;
        } else if (uri.startsWith("jdbc:microsoft:sqlserver")) {
            return DBType.Sqlserver;
        } else if (uri.startsWith("jdbc:sqlite")) {
            return DBType.Sqlite;
        } else{
            return null;
        }
    }
}

starter/mysql-starter/src/main/java/com/yihu/mysql/jdbc/DBHelper.java

@@ -0,0 +1,437 @@
package com.yihu.mysql.jdbc;
import com.yihu.mysql.enums.DBType;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Service;
import java.beans.BeanInfo;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Method;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;
import java.text.SimpleDateFormat;
import java.util.*;
/**
 * JDBC数据库操作类
 * Created by hzp on 2015/11/26.
 */
@Service
@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
public class DBHelper {
    @Autowired
    ConnectionFactory factory;
    private String name = "";
    public DBType dbType = DBType.Mysql; //当前连接数据库类型
    /**
     * 获取当前连接
     */
    private Connection getConn() throws Exception {
        if (name.length() > 0) {
            return factory.getConnection(name);
        } else {
            return factory.getConnection();
        }
    }
    /**
     * 关闭连接
     */
    private void close(Connection conn) throws Exception{
        if(conn != null) {
            conn.close();
        }
    }
    /**
     * 抛出自定义异常
     * @param msg
     * @param e
     */
    private void rethrow(String msg, Exception e) throws Exception{
        throw new Exception(msg,e);
    }
    private String UNDERLINE = "_";
    /**
     * 驼峰表达式转下划线
     */
    private String camelToUnderline(String val){
        if (val == null || "".equals(val.trim())){
            return "";
        }
        int len=val.length();
        StringBuilder sb=new StringBuilder(len);
        for (int i = 0; i < len; i++) {
            char c=val.charAt(i);
            if (Character.isUpperCase(c)) {
                sb.append(UNDERLINE);
                sb.append(Character.toLowerCase(c));
            } else{
                sb.append(c);
            }
        }
        return sb.toString();
    }
    /**
     * Map数据转驼峰表达式
     * @param map
     * @return
     */
    private <T> T MaptoBean( Class<T> cls, Map<String, Object> map) throws Exception{
        Object obj = cls.newInstance();
        BeanInfo beanInfo = Introspector.getBeanInfo(obj.getClass());
        PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
        for (PropertyDescriptor property : propertyDescriptors) {
            Method setter = property.getWriteMethod();
            if (setter != null) {
                String name = property.getName();
                Object val = null;
                if(map.containsKey(name))
                {
                    val = map.get(name);
                }
                else if(map.containsKey(name.toLowerCase()))
                {
                    val = map.get(name.toLowerCase());
                }
                else if(map.containsKey(name.toUpperCase()))
                {
                    val = map.get(name.toUpperCase());
                }
                else {
                    //驼峰命名转下划线
                    String newName = camelToUnderline(name).toLowerCase();
                    if(map.containsKey(newName))
                    {
                        val = map.get(newName);
                    }
                    else if(map.containsKey(newName.toUpperCase()))
                    {
                        val = map.get(newName.toUpperCase());
                    }
                }
                if(val != null) {
                    String type = val.getClass().getName();
                    if (type.indexOf("Date") > 0 || type.indexOf("Timestamp") > 0) //时间格式
                    {
                        SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                        String re = formatter.format(val);
                        val = re;
                    }
                }
                else{
                    val = "";
                }
                setter.invoke(obj, val);
            }
        }
        return (T)obj;
    }
    /*******************************************/
    /**
     * 初始化连接
     */
    public void connect() throws Exception
    {
        factory.getConnection();
        dbType = factory.getDbType();
    }
    /**
     * 自定义连接
     * uri包含用户名/密码
     */
    public void connect(String name,String uri) throws Exception
    {
        this.name = name;
        factory.getConnection(name, uri);
        dbType = factory.getDbType(uri);
    }
    /**
     * 自定义连接
     */
    public void connect(String name,String uri,String user,String password) throws Exception
    {
        this.name = name;
        factory.getConnection(name,uri, user, password);
        dbType = factory.getDbType(uri);
    }
    /****************************** 查询操作 *******************************************/
    /**
     * 查询第一个字段
     */
    public Object scalar(String sql) throws Exception
    {
        return scalar(sql,(Objects[])null);
    }
    /**
     * 查询第一行第一个字段(参数SQL防注入)
     */
    public Object scalar(String sql,Object... params) throws Exception
    {
        Connection conn = getConn();
        try{
            QueryRunner qr = new QueryRunner();
            return qr.query(conn, sql, new ScalarHandler(), params);
        }
        catch (Exception e)
        {
            this.rethrow("SQL:" + sql + ",Parameters:" + Arrays.deepToString(params), e);
            return null;
        }
        finally {
            this.close(conn);
        }
    }
    /******************** Map查询 *******************************/
    /**
     * 获取单条记录
     */
    public Map<String,Object> load(String sql) throws Exception {
        return load(sql,(Object[])null);
    }
    /**
     * 获取单条记录(参数SQL防注入)
     */
    public Map<String,Object> load(String sql, Object... params) throws Exception {
        Connection conn = getConn();
        try{
            QueryRunner qr = new QueryRunner();
            return qr.query(conn, sql, new MapHandler(), params);
        }
        catch (Exception e)
        {
            this.rethrow("SQL:" + sql + ",Parameters:" + Arrays.deepToString(params), e);
            return null;
        }
        finally {
            close(conn);
        }
    }
    /**
     * List<JSONObject>获取多条记录
     */
    public List<Map<String,Object>> query(String sql) throws Exception
    {
        return query(sql, (Object[])null);
    }
    /**
     * List<JSONObject>获取多条记录(参数SQL防注入)
     */
    public List<Map<String,Object>> query(String sql,Object... params) throws Exception
    {
        Connection conn = getConn();
        try{
            QueryRunner qr = new QueryRunner();
            return qr.query(conn, sql, new MapListHandler(), params);
        }
        catch (Exception e)
        {
            this.rethrow("SQL:" + sql + ",Parameters:" + Arrays.deepToString(params), e);
            return null;
        }
        finally {
            close(conn);
        }
    }
    /*************************** 实体查询(转驼峰) ********************************/
    /**
     * 获取单个实体
     */
    public <T> T load(Class<T> cls, String sql) throws Exception
    {
        return load(cls, sql, (Object[])null);
    }
    /**
     * 获取单个实体
     */
    public <T> T load(Class<T> cls, String sql, Object... params) throws Exception {
        Map<String,Object> map = this.load(sql, params);
        return this.MaptoBean(cls,map);
    }
    /**
     * 获取实体列表
     */
    public <T> List<T> query(Class<T> cls, String sql) throws Exception
    {
        return query(cls, sql, (Object[]) null);
    }
    /**
     * 获取实体列表
     */
    public <T> List<T> query(Class<T> cls, String sql, Object... params) throws Exception {
        List<Map<String,Object>> mapList = this.query(sql, params);
        List<T> list = new ArrayList<>();
        if(mapList!=null && mapList.size()>0)
        {
            for(Map<String,Object> map : mapList)
            {
                list.add(this.MaptoBean(cls,map));
            }
        }
        return list;
    }
    /******************************* 非查询操作 ***********************************/
    /**
     * 测试连接
     */
    public static boolean test(String uri) throws  Exception{
        try {
            Properties info = new Properties();
            Connection conn = DriverManager.getDriver(uri).connect(uri,info);
            Boolean re = true;
            if (conn == null) {
                re = false;
            } else {
                if(conn.isClosed())
                {
                    re = false;
                }
                conn.close();
            }
            return re;
        }
        catch (Exception ex)
        {
            return false;
        }
    }
    /**
     * 单条增删改操作
     * @param sql
     * @return
     */
    public boolean execute(String sql) throws Exception{
        return execute(sql,null);
    }
    /**
     * 单条增删改操作
     * @param sql
     * @return
     */
    public boolean execute(String sql,Object... params) throws Exception{
        Connection conn = getConn();
        try{
            QueryRunner qr = new QueryRunner();
            int re = qr.update(conn, sql,params);
            if(re>0)
                return true;
            else {
                this.rethrow("SQL:" + sql + ",Parameters:" + Arrays.deepToString(params), null);
                return false;
            }
        }
        catch (Exception e)
        {
            this.rethrow("SQL:" + sql + ",Parameters:" + Arrays.deepToString(params), e);
            return false;
        }
        finally {
            close(conn);
        }
    }
    /**
     * 批量操作（同一条SQL语句）
     * @return
     */
    public boolean executeBatch(String sql,Object[][] params) throws Exception
    {
        Connection conn = getConn();
        try{
            QueryRunner qr = new QueryRunner();
            conn.setAutoCommit(false);
            int re = qr.batch(conn, sql, params).length;
            conn.commit();
            if(re>0)
                return true;
            else {
                this.rethrow("SQL:" + sql + ",Parameters:" + Arrays.deepToString(params), null);
                return false;
            }
        }
        catch (Exception e)
        {
            if (conn != null) {
                conn.rollback();
            }
            this.rethrow("SQL:" + sql + ",Parameters:" + Arrays.deepToString(params), e);
            return false;
        }
        finally {
            close(conn);
        }
    }
    /**
     * 批量操作(最多1000条执行一次)
     * @param sqls
     * @return
     */
    public boolean executeBatch(String[] sqls) throws Exception
    {
        Connection conn = getConn();
        try{
            conn.setAutoCommit(false);
            Statement statemenet = conn.createStatement();
            final int batchSize = 1000;
            int count = 0;
            for (String sql : sqls) {
                statemenet.addBatch(sql);
                if(++count % batchSize == 0) {
                    statemenet.executeBatch();
                }
            }
            statemenet.executeBatch();
            conn.commit();
            statemenet.close();
            return true;
        }
        catch (Exception e)
        {
            if (conn != null) {
                conn.rollback();
            }
            this.rethrow("SQL:" + Arrays.deepToString(sqls), e);
            return false;
        }
        finally {
            close(conn);
        }
    }
}

starter/mysql-starter/src/main/java/com/yihu/mysql/model/DataList.java

@@ -0,0 +1,76 @@
package com.yihu.mysql.model;
import java.util.List;
/**
 * Created by hzp on 2015/11/16.
 */
public class DataList {
    private String name;
    private long page = 0;
    private long count = 0;
    private int size = 50;
    private List list;
    public DataList()
    {
    }
    public DataList(long _page,long _count)
    {
        page = _page;
        count = _count;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public long getPage(){
        return page;
    }
    public void setPage(long page){
        this.page = page;
    }
    public long getCount(){
        if(count==0 && list !=null && list.size() > 0)
        {
            count = list.size();
        }
        return count;
    }
    public void setCount(long count){
        this.count = count;
    }
    public int getSize() {
        return size;
    }
    public void setSize(int size) {
        this.size = size;
    }
    /**
     * 获取列表
     * @return
     */
    public List getList(){
        return list;
    }
    public void setList(List list){
        this.list=list;
    }
}

starter/mysql-starter/src/main/java/com/yihu/mysql/model/DataStats.java

@@ -0,0 +1,75 @@
package com.yihu.mysql.model;
/**
 * 统计实体
 * Created by hzp on 2016/04/26.
 */
public class DataStats {
    private String name; //统计字段名
    private String count; //总条数
    private String sum; //总和
    private String avg; //平均值
    private String max;//最大值
    private String min;//最小值
    public DataStats(String name, String count, String sum, String avg, String max, String min){
        this.name = name;
        this.count = count;
        this.sum=sum;
        this.avg=avg;
        this.max=max;
        this.min=min;
    }
    /**
     * 获取统计字段名
     * @return
     */
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getCount() {
        return count;
    }
    public void setCount(String count) {
        this.count = count;
    }
    public String getSum() {
        return sum;
    }
    public void setSum(String sum) {
        this.sum = sum;
    }
    public String getAvg() {
        return avg;
    }
    public void setAvg(String avg) {
        this.avg = avg;
    }
    public String getMax() {
        return max;
    }
    public void setMax(String max) {
        this.max = max;
    }
    public String getMin() {
        return min;
    }
    public void setMin(String min) {
        this.min = min;
    }
}

starter/mysql-starter/src/main/java/com/yihu/mysql/model/QueryCondition.java

@@ -0,0 +1,101 @@
package com.yihu.mysql.model;
import com.yihu.mysql.enums.Logical;
import com.yihu.mysql.enums.Operation;
/**
 * 查询条件
 * @author hzp add 2016-04-28
 */
public class QueryCondition {
	private String field;
	private Object keyword;
	private Object[] keywords;
	private String operation;
	private String logical;
	/**
	 * 构造函数
	 * @param field
	 * @param keyword
	 */
	public QueryCondition(String field, Object keyword) {
		this.logical = Logical.AND;
		this.operation = Operation.EQ;
		this.field = field;
		this.keyword = keyword;
	}
	public QueryCondition(){
	}
	/**
	 * 构造函数
	 */
	public QueryCondition(String logical, String operation, String field, String keyword) {
		this.logical = logical;
		this.operation = operation;
		this.field = field;
		this.keyword = keyword;
	}
	/**
	 * 构造函数
	 */
	public QueryCondition(String logical, String operation, String field, String[] keywords) {
		this.logical = logical;
		this.operation = operation;
		this.field = field;
		this.keywords = keywords;
	}
	public void setField(String field) {
		this.field = field;
	}
	public void setKeyword(Object keyword) {
		this.keyword = keyword;
	}
	public void setKeywords(Object[] keywords) {
		this.keywords = keywords;
	}
	public void setOperation(String operation) {
		this.operation = operation;
	}
	public void setLogical(String logical) {
		this.logical = logical;
	}
	/**
	 * 获取条件关系
	 * @return
	 */
	public String getLogical(){
		return this.logical;
	}
	/**
	 * 获取条件类型
	 * @return
	 */
	public String getOperation() {
		return operation;
	}
	public String getField() {
		return field;
	}
	public Object getKeyword() {
		return keyword;
	}
	public Object[] getKeywords() {
		return keywords;
	}
}

starter/mysql-starter/src/main/java/com/yihu/mysql/model/QueryEntity.java

@@ -0,0 +1,125 @@
package com.yihu.mysql.model;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.ArrayList;
import java.util.List;
/**
 * Created by hzp on 2015/11/17.
 */
public class QueryEntity {
    private String tableName;
    private boolean isPage = false;
    private Integer page=0;
    private Integer rows=50; //默认50
    private String fields = "*"; //查询字段，逗号分隔
    private String sort;
    private List<QueryCondition> conditions; //过滤条件
    /**
     * 构造函数
     */
    public QueryEntity(String tableName)
    {
        this.tableName = tableName;
        this.conditions = new ArrayList<QueryCondition>();
    }
    /**
     * 构造函数
     */
    public QueryEntity(String tableName,int page, int rows)
    {
        this.tableName = tableName;
        this.isPage = true;
        this.page = page;
        this.rows = rows;
        this.conditions = new ArrayList<QueryCondition>();
    }
    /*************************************************************************************/
    public List<QueryCondition> getConditions() {
        return conditions;
    }
    public String getTableName() {
        return tableName;
    }
    public String getSort() {
        return sort;
    }
    public int getPage() {
        return page;
    }
    public int getRows() {
        return rows;
    }
    public String getFields() {
        return fields;
    }
    public boolean isPage() {
        return isPage;
    }
    /************************************************************************************/
    /**
     * 设置排序
     */
    public void setSort(String sort){
        this.sort = sort;
    }
    /**
     * 设置查询字段
     * @param fields
     */
    public void setFields(String fields) {
        this.fields = fields;
    }
    /**
     * 新增查询条件
     */
    public void addCondition(String field,String keyword){
        QueryCondition condition = new QueryCondition(field,keyword);
        addCondition(condition);
    }
    /**
     * 新增查询条件
     */
    public void addCondition(QueryCondition condition){
        conditions.add(condition);
    }
    /**
     * 通过JSON字符串添加查询条件
     */
    public void addConditionByJson(String json) throws Exception{
        if(json!=null && json.length()>0) {
            ObjectMapper objectMapper = new ObjectMapper();
            if (json.startsWith("[") && json.endsWith("]")) {
                JavaType javaType = objectMapper.getTypeFactory().constructParametricType(List.class, QueryCondition.class);
                List<QueryCondition> qcList = objectMapper.readValue(json, javaType);
                if (qcList!=null && qcList.size()>0)
                {
                    for(QueryCondition qc : qcList){
                        conditions.add(qc);
                    }
                }
            } else {
                QueryCondition qc = objectMapper.readValue(json, QueryCondition.class);
                conditions.add(qc);
            }
        }
    }
}

starter/mysql-starter/src/main/java/com/yihu/mysql/query/BaseJpaService.java

@@ -106,7 +106,7 @@ public abstract class BaseJpaService<T, R extends CrudRepository> {
        return (T) getRepository().findById(id);
    }
    public List<T> search(String filters) throws ParseException {
    public List search(String filters) throws ParseException {
        URLQueryParser queryParser = createQueryParser("", filters, "");
        CriteriaQuery query = queryParser.makeCriteriaQuery();
@@ -132,7 +132,7 @@ public abstract class BaseJpaService<T, R extends CrudRepository> {
                .getResultList();
    }
    public List<T> search(String fields, String filters, String sorts, Integer page, Integer size) throws ParseException {
    public List search(String fields, String filters, String sorts, Integer page, Integer size) throws ParseException {
        URLQueryParser queryParser = createQueryParser(fields, filters, sorts);
        CriteriaQuery query = queryParser.makeCriteriaQuery();
        if (page == null || page <= 0) {
@@ -359,4 +359,20 @@ public abstract class BaseJpaService<T, R extends CrudRepository> {
        return pageRequest;
    }
    /**
     * 获取指定长度的随机字符串
     * @param length
     * @return
     */
    protected String getRandomString(int length) {
        String str = "abcdefghigklmnopkrstuvwxyzABCDEFGHIGKLMNOPQRSTUVWXYZ0123456789";
        StringBuffer buffer = new StringBuffer();
        Random random = new Random();
        for (int i = 0; i < length; i++) {
            int number = random.nextInt(str.length() - 1);//0~61
            buffer.append(str.charAt(number));
        }
        return buffer.toString();
    }
}

starter/mysql-starter/src/main/java/com/yihu/mysql/service/DBQuery.java

@@ -0,0 +1,158 @@
package com.yihu.mysql.service;
import com.yihu.mysql.jdbc.DBHelper;
import com.yihu.mysql.model.DataList;
import com.yihu.mysql.model.QueryEntity;
import com.yihu.mysql.sqlparser.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
import java.util.Map;
/**
 * JDBC查询类
 * Created by hzp on 2015/11/28.
 */
@Service
public class DBQuery {
    @Autowired
    private DBHelper db;
    private ParserSql ps;
    public DBHelper getDB() throws Exception {
        return db;
    }
    public ParserSql getParserSql() throws Exception {
        switch (getDB().dbType) {
            case Oracle:
                ps = new ParserOracle();
                break;
            case Sqlserver:
                ps = new ParserSqlserver();
                break;
            case Hive:
                ps = new ParserHive();
                break;
            case Sqlite:
                ps = new ParserSqlite();
                break;
            default:
                ps = new ParserMysql();
        }
        return ps;
    }
    /**
     * 初始化连接
     */
    public void connect() throws Exception {
        db.connect();
    }
    /**
     * 自定义连接
     * uri包含用户名/密码
     */
    public void connect(String name,String uri) throws Exception {
        db.connect(name,uri);
    }
    /**
     * 自定义连接
     */
    public void connect(String name,String uri,String user,String password) throws Exception {
        db.connect(name,uri,user,password);
    }
    /**************************************************************************/
    /**
     * 查询单条记录
     */
    public Map<String,Object> load(QueryEntity qe) throws Exception {
        String sql = getParserSql().getSql(qe);
        return getDB().load(sql);
    }
    /**
     * 查询单实体
     */
    public <T> T load(Class<T> cls,QueryEntity qe) throws Exception {
        String sql = getParserSql().getSql(qe);
        return getDB().load(cls, sql);
    }
    /**
     * 查询实体列表
     */
    public DataList query(QueryEntity qe) throws Exception {
        DataList list = new DataList(qe.getPage(),qe.getRows());
        list.setName(qe.getTableName());
        int count = count(qe);
        list.setCount(count);
        if(count !=0 ) {
            String sql = getParserSql().getSql(qe);
            list.setList(getDB().query(sql));
        }
        return list;
    }
    /**
     * 查询实体列表
     */
    public <T> List<T> query(Class<T> cls,QueryEntity qe) throws Exception {
        String sql = getParserSql().getSql(qe);
        return getDB().query(cls, sql);
    }
    /**
     * 获取总条数
     * @return
     */
    public int count(QueryEntity qe) throws Exception {
        String sqlCount = getParserSql().getCountSql(qe);
        return Integer.parseInt(String.valueOf(getDB().scalar(sqlCount)));
    }
    /********************** SQL语句 ************************************/
    /**
     * SQL查询
     * @param sql
     * @return
     * @throws Exception
     */
    public DataList queryBySql(String sql) throws Exception {
        DataList re = new DataList();
        List<Map<String,Object>> list = getDB().query(sql);
        re.setList(list);
        return re;
    }
    /**
     * SQL分页查询
     * @param sql
     * @param page
     * @param size
     * @return
     * @throws Exception
     */
    public DataList queryBySql(String sql,int page,int size) throws Exception {
        DataList re = new DataList(page,size);
        String sqlPage = getParserSql().getPageSql(sql, page, size);
        String sqlCount = getParserSql().getCountSql(sql);
        List<Map<String,Object>> list = getDB().query(sqlPage);
        re.setList(list);
        long count = (long)getDB().scalar(sqlCount);
        int intCount = (int)count;
        int totalPages = intCount%size == 0 ? intCount/size : (intCount/size)+1;
        re.setCount(count);
        re.setPage(totalPages);
        return re;
    }
}

starter/mysql-starter/src/main/java/com/yihu/mysql/sqlparser/ParserFactory.java

@@ -0,0 +1,50 @@
package com.yihu.mysql.sqlparser;
import com.yihu.mysql.enums.DBType;
/**
 * sql解析工厂类
 * Created by hzp on 2016/05/24.
 */
public class ParserFactory  {
    /**
     * 默认Mysql数据库
     * @return
     */
    public static ParserSql getParserSql()
    {
        return new ParserMysql();
    }
    /**
     * 根据数据库类型获取SQL解析器
     * @param type
     * @return
     */
    public static ParserSql getParserSql(DBType type)
    {
        ParserSql ps = null;
        switch (type)
        {
            case Oracle:
                ps = new ParserOracle();
                break;
            case Sqlserver:
                ps = new ParserSqlserver();
                break;
            case Hive:
                ps = new ParserHive();
                break;
            case Sqlite:
                ps = new ParserSqlite();
                break;
            default:
                ps = new ParserMysql();
        }
        return ps;
    }
}

starter/mysql-starter/src/main/java/com/yihu/mysql/sqlparser/ParserHive.java

@@ -0,0 +1,19 @@
package com.yihu.mysql.sqlparser;
import com.yihu.mysql.model.QueryEntity;
/**
 * Hive的sql解析
 * Created by hzp on 2015/11/30.
 */
public class ParserHive extends ParserSql {
    /**
     * 转换成sql语句
     */
    @Override
    public String getSql(QueryEntity qe){
        return "";
    }
}

starter/mysql-starter/src/main/java/com/yihu/mysql/sqlparser/ParserMysql.java

@@ -0,0 +1,155 @@
package com.yihu.mysql.sqlparser;
import com.yihu.mysql.enums.Logical;
import com.yihu.mysql.enums.Operation;
import com.yihu.mysql.model.QueryCondition;
import com.yihu.mysql.model.QueryEntity;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;
/**
 * Mysql的sql解析
 * Created by hzp on 2015/11/30.
 */
public class ParserMysql extends ParserSql {
    /**
     * 获取keyword转sql
     * @param keyword
     * @return
     */
    @Override
    public String getKeywordSql(Object keyword){
        if (keyword instanceof Date) {
            String dateFormat = "yyyy-MM-dd HH:mm:ss";
            Date d = (Date) keyword;
            SimpleDateFormat format = new SimpleDateFormat(dateFormat);
            return "date_format('"+ format .format(d)+"','"+dateFormat+"')";
        }
        else
        {
            return "'"+ keyword +"'";
        }
    }
    /**
     * 条件转换
     * @return
     */
    @Override
    public String getConditionSql(List<QueryCondition> conditions){
        String conditionSql = "";
        for(QueryCondition qc : conditions){
            if(qc.getLogical().equals(Logical.OR))
            {
                conditionSql += " or ";
            }
            else{
                conditionSql += " and ";
            }
            String operation = qc.getOperation();
            if(operation.equals(Operation.IN)  || operation.equals(Operation.NIN))
            {
                Object[] keys = qc.getKeywords();
                String keywords = "";
                if(keys!=null&&keys.length>0)
                {
                    for (Object key :keys)
                    {
                        keywords +=  "'"+key+"',";
                    }
                    keywords = keywords.substring(0,keywords.length()-1);
                }
                conditionSql += qc.getField() + operation + keywords;
            }
            else if(operation.equals(Operation.LIKE))
            {
                conditionSql += qc.getField() + operation + "'%"+qc.getKeyword()+"%'";
            }
            else{
                conditionSql += qc.getField() + operation + getKeywordSql(qc.getKeyword());
            }
        }
        return conditionSql;
    }
    /**
     * 转换成sql语句
     */
    @Override
    public String getSql(QueryEntity qe){
        String fields = qe.getFields();
        String tableName = qe.getTableName();
        String sort = qe.getSort();
        //查询条件
        String conditionSql = "";
        List<QueryCondition> conditions = qe.getConditions();
        if(conditions!=null && conditions.size()>0)
        {
            conditionSql = getConditionSql(conditions);
        }
        String sql = "select "+fields+" from "+ tableName +" where 1=1" + conditionSql;
        //判断是否排序
        if(sort!=null &&sort.length()>0)
        {
            sql+= " ORDER BY " + sort;
        }
        //判断是否分页
        if(qe.isPage())
        {
            int page = qe.getPage();
            int rows = qe.getRows();
            sql = getPageSql(sql,page,rows);
        }
        return sql;
    }
    /**
     * 转换成获取count的sql语句
     */
    @Override
    public String getCountSql(QueryEntity qe){
        String tableName = qe.getTableName();
        //查询条件
        String conditionSql = "";
        List<QueryCondition> conditions = qe.getConditions();
        if(conditions!=null && conditions.size()>0)
        {
            conditionSql = getConditionSql(conditions);
        }
        return "select count(1) from "+ tableName +" where 1=1" + conditionSql;
    }
    /**
     * 通过sql语句再分页
     * @return
     */
    @Override
    public String getPageSql(String sql,int page,int rows)
    {
        if(rows < 0) rows = 10;
        if(rows >100) rows = 100;
        if(page <0) page = 1;
        int start= (page-1) * rows;
        return sql +" LIMIT "+start+","+rows;
    }
}

starter/mysql-starter/src/main/java/com/yihu/mysql/sqlparser/ParserOracle.java

@@ -0,0 +1,168 @@
package com.yihu.mysql.sqlparser;
import com.yihu.mysql.enums.Logical;
import com.yihu.mysql.enums.Operation;
import com.yihu.mysql.model.QueryCondition;
import com.yihu.mysql.model.QueryEntity;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;
/**
 * Mysql的sql解析
 * Created by hzp on 2015/11/30.
 */
public class ParserOracle extends ParserSql {
    /**
     * 获取keyword转sql
     * @param keyword
     * @return
     */
    @Override
    public String getKeywordSql(Object keyword){
        if (keyword instanceof Date) {
            String dateFormat = "yyyy-MM-dd HH:mm:ss";
            Date d = (Date) keyword;
            SimpleDateFormat format = new SimpleDateFormat(dateFormat);
            return "to_date('"+ format .format(d)+"','"+dateFormat+"')";
        }
        else
        {
            return "'"+ keyword +"'";
        }
    }
    /**
     * 条件转换
     * @return
     */
    @Override
    public String getConditionSql(List<QueryCondition> conditions){
        String conditionSql = "";
        for(QueryCondition qc : conditions){
            if(qc.getLogical().equals(Logical.OR))
            {
                conditionSql += " or ";
            }
            else{
                conditionSql += " and ";
            }
            String operation = qc.getOperation();
            if(operation.equals(Operation.IN)  || operation.equals(Operation.NIN))
            {
                Object[] keys = qc.getKeywords();
                String keywords = "";
                if(keys!=null&&keys.length>0)
                {
                    for (Object key :keys)
                    {
                        keywords +=  "'"+key+"',";
                    }
                    keywords = keywords.substring(0,keywords.length()-1);
                }
                conditionSql += qc.getField() + operation + keywords;
            }
            else if(operation.equals(Operation.LIKE))
            {
                conditionSql += qc.getField() + operation + "'%"+qc.getKeyword()+"%'";
            }
            else{
                conditionSql += qc.getField() + operation + getKeywordSql(qc.getKeyword());
            }
        }
        return conditionSql;
    }
    /**
     * 转换成sql语句
     */
    @Override
    public String getSql(QueryEntity qe){
        String fields = qe.getFields();
        String tableName = qe.getTableName();
        String sort = qe.getSort();
        //查询条件
        String conditionSql = "";
        List<QueryCondition> conditions = qe.getConditions();
        if(conditions!=null && conditions.size()>0)
        {
            conditionSql = getConditionSql(conditions);
        }
        String sql ="";
        //判断是否分页
        if(qe.isPage())
        {
            int page = qe.getPage();
            int rows = qe.getRows();
            //判断是否排序
            if(sort!=null &&sort.length()>0)
            {
                sql = "select "+fields+" from "+ tableName +" where 1=1 "+conditionSql+" order by " + sort;
                sql = getPageSql(sql,page,rows);
            }
            else{
                if(rows < 0) rows = 10;
                if(rows >100) rows = 100;
                if(page <0) page = 1;
                int start= (page-1) * rows;
                int end = page*rows;
                sql = "select * from (select "+fields+",ROWNUM RN from "+ tableName +" where 1=1 AND ROWNUM<" + end + conditionSql+") where RN>="+start;
            }
        }
        else{
            sql = "select "+fields+" from "+ tableName +" where 1=1" + conditionSql;
            //判断是否排序
            if(sort!=null &&sort.length()>0)
            {
                sql+= " order by " + sort;
            }
        }
        return sql;
    }
    /**
     * 转换成获取count的sql语句
     */
    @Override
    public String getCountSql(QueryEntity qe){
        String tableName = qe.getTableName();
        //查询条件
        String conditionSql = "";
        List<QueryCondition> conditions = qe.getConditions();
        if(conditions!=null && conditions.size()>0)
        {
            conditionSql = getConditionSql(conditions);
        }
        return "select count(1) from "+ tableName +" where 1=1" + conditionSql;
    }
    /**
     * 通过sql语句再分页
     * @return
     */
    @Override
    public String getPageSql(String sql,int page,int rows)
    {
        if(rows < 0) rows = 10;
        if(rows >100) rows = 100;
        if(page <0) page = 1;
        int start= (page-1) * rows;
        int end= page * rows;
        return " select * from (select *,ROWNUM RN from ("+sql+") where ROWNUM<"+end+") where RN>= "+start;
    }
}

starter/mysql-starter/src/main/java/com/yihu/mysql/sqlparser/ParserSql.java

@@ -0,0 +1,60 @@
package com.yihu.mysql.sqlparser;
import com.yihu.mysql.model.QueryCondition;
import com.yihu.mysql.model.QueryEntity;
import java.util.List;
/**
 * sql解析基类
 * Created by hzp on 2015/11/30.
 */
public class ParserSql {
    /**
     * 获取keyword转sql
     * @param keyword
     * @return
     */
    public String getKeywordSql(Object keyword){
        return "";
    }
    /**
     * 条件转换
     * @return
     */
    public String getConditionSql(List<QueryCondition> conditions){
        return "";
    }
    /**
     * 转换成sql语句
     */
    public String getSql(QueryEntity qe){
        return "";
    }
    /**
     * 转换成获取count的sql语句
     */
    public String getCountSql(QueryEntity qe){
        return "";
    }
    /**
     * 转换成获取count的sql语句
     */
    public String getCountSql(String sql){
        return "select count(1) from ("+sql+") tc";
    }
    /**
     * sql语句添加分页
     */
    public String getPageSql(String sql,int page,int rows){
        return sql;
    }
}

starter/mysql-starter/src/main/java/com/yihu/mysql/sqlparser/ParserSqlite.java

@@ -0,0 +1,156 @@
package com.yihu.mysql.sqlparser;
import com.yihu.mysql.enums.Logical;
import com.yihu.mysql.enums.Operation;
import com.yihu.mysql.model.QueryCondition;
import com.yihu.mysql.model.QueryEntity;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;
/**
 * Sqlite的sql解析
 * Created by hzp on 2015/11/30.
 */
public class ParserSqlite extends ParserSql {
    /**
     * 获取keyword转sql
     * @param keyword
     * @return
     */
    @Override
    public String getKeywordSql(Object keyword){
        if (keyword instanceof Date) {
            String dateFormat = "yyyy-MM-dd HH:mm:ss";
            Date d = (Date) keyword;
            SimpleDateFormat format = new SimpleDateFormat(dateFormat);
            return "date_format('"+ format .format(d)+"','"+dateFormat+"')";
        }
        else
        {
            return "'"+ keyword +"'";
        }
    }
    /**
     * 条件转换
     * @return
     */
    @Override
    public String getConditionSql(List<QueryCondition> conditions){
        String conditionSql = "";
        for(QueryCondition qc : conditions){
            if(qc.getLogical().equals(Logical.OR))
            {
                conditionSql += " or ";
            }
            else{
                conditionSql += " and ";
            }
            String operation = qc.getOperation();
            if(operation.equals(Operation.IN)  || operation.equals(Operation.NIN))
            {
                Object[] keys = qc.getKeywords();
                String keywords = "";
                if(keys!=null&&keys.length>0)
                {
                    for (Object key :keys)
                    {
                        keywords +=  "'"+key+"',";
                    }
                    keywords = keywords.substring(0,keywords.length()-1);
                }
                conditionSql += qc.getField() + operation + keywords;
            }
            else if(operation.equals(Operation.LIKE))
            {
                conditionSql += qc.getField() + operation + "'%"+qc.getKeyword()+"%'";
            }
            else{
                conditionSql += qc.getField() + operation + getKeywordSql(qc.getKeyword());
            }
        }
        return conditionSql;
    }
    /**
     * 转换成sql语句
     */
    @Override
    public String getSql(QueryEntity qe){
        String fields = qe.getFields();
        String tableName = qe.getTableName();
        String sort = qe.getSort();
        //查询条件
        String conditionSql = "";
        List<QueryCondition> conditions = qe.getConditions();
        if(conditions!=null && conditions.size()>0)
        {
            conditionSql = getConditionSql(conditions);
        }
        String sql = "select "+fields+" from "+ tableName +" where 1=1" + conditionSql;
        //判断是否排序
        if(sort!=null &&sort.length()>0)
        {
            sql+= " ORDER BY " + sort;
        }
        //判断是否分页
        if(qe.isPage())
        {
            int page = qe.getPage();
            int rows = qe.getRows();
            sql = getPageSql(sql,page,rows);
        }
        return sql;
    }
    /**
     * 转换成获取count的sql语句
     */
    @Override
    public String getCountSql(QueryEntity qe){
        String tableName = qe.getTableName();
        //查询条件
        String conditionSql = "";
        List<QueryCondition> conditions = qe.getConditions();
        if(conditions!=null && conditions.size()>0)
        {
            conditionSql = getConditionSql(conditions);
        }
        return "select count(1) from "+ tableName +" where 1=1" + conditionSql;
    }
    /**
     * 通过sql语句再分页
     * @return
     */
    @Override
    public String getPageSql(String sql,int page,int rows)
    {
        if(rows < 0) rows = 10;
        if(rows >100) rows = 100;
        if(page <0) page = 1;
        int start= (page-1) * rows;
        return sql +" LIMIT "+start+","+rows;
    }
}

starter/mysql-starter/src/main/java/com/yihu/mysql/sqlparser/ParserSqlserver.java

@@ -0,0 +1,20 @@
package com.yihu.mysql.sqlparser;
import com.yihu.mysql.model.QueryEntity;
/**
 * Mysql的sql解析
 * Created by hzp on 2015/11/30.
 */
public class ParserSqlserver extends ParserSql {
    /**
     * 转换成sql语句
     */
    @Override
    public String getSql(QueryEntity qe){
        return "";
    }
}