代码修改

common/common-util/pom.xml

@@ -59,6 +59,10 @@
            <groupId>com.yihu.jw</groupId>
            <artifactId>common-entity</artifactId>
        </dependency>
        <dependency>
            <groupId>com.yihu.jw</groupId>
            <artifactId>common-exception</artifactId>
        </dependency>
        <dependency>
            <groupId>com.yihu</groupId>
            <artifactId>utils</artifactId> <!-- 此依赖包含大部分常用工具类 -->

common/common-util/src/main/java/com/yihu/jw/util/common/NumberUtil.java

@@ -0,0 +1,649 @@
package com.yihu.jw.util.common;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.text.DecimalFormat;
import java.text.NumberFormat;
public class NumberUtil {
    public static final BigDecimal DEFAULT_NUMBER = BigDecimal.ZERO;
    public static final String DECIMAL_FORMAT = "#,##0.00";
    public static final String INTEGER_FORMAT = "#,##0";
    public static final String DEFAULT_NUM_GROUP_STYLE_ID = "1";
    public static final String DEFAULT_DECIMAL_STYLE_ID = "2";
    public static final String[][] DECIMAL_STYLE_LIST = {
            {"1", ",", "Comma"},
            {"2", ".", "Period"}
    };
    public static final String[][] NUM_GROUP_STYLE_LIST = {
            {"1", ",", "Comma"},
            {"2", ".", "Period"},
            {"3", " ", "Space"}
    };
    protected NumberUtil() {
    }
    public static boolean isDivisible(BigDecimal dividend, BigDecimal divisor) {
        if (dividend == null || divisor == null) {
            return false;
        }
        if (compare(dividend.remainder(divisor), DEFAULT_NUMBER) == 0) {
            return true;
        }
        return false;
    }
    public static String changeToDecimalFormat(Number num) {
        return formatNumber(num, DECIMAL_FORMAT);
    }
    public static String changeToIntegerFormat(Number num) {
        return formatNumber(num, INTEGER_FORMAT);
    }
    public static String formatNumber(Number num, String format) {
        DecimalFormat noFormat = new DecimalFormat(format);
        return noFormat.format(num);
    }
    public static int compare(BigDecimal num1, BigDecimal num2) {
        if (num1 == null) {
            num1 = DEFAULT_NUMBER;
        }
        if (num2 == null) {
            num2 = DEFAULT_NUMBER;
        }
        return num1.compareTo(num2);
    }
    public static boolean gt(BigDecimal num1, BigDecimal num2) {
        if (compare(num1, num2) > 0) {
            return true;
        }
        return false;
    }
    public static boolean ge(BigDecimal num1, BigDecimal num2) {
        return !lt(num1, num2);
    }
    public static boolean lt(BigDecimal num1, BigDecimal num2) {
        if (compare(num1, num2) < 0) {
            return true;
        }
        return false;
    }
    public static boolean le(BigDecimal num1, BigDecimal num2) {
        return !gt(num1, num2);
    }
    public static boolean equals(BigDecimal num1, BigDecimal num2) {
        if (compare(num1, num2) == 0) {
            return true;
        }
        return false;
    }
    public static boolean equals(int num1, int num2) {
        if (compare(new BigDecimal(String.valueOf(num1)), new BigDecimal(String.valueOf(num2))) == 0) {
            return true;
        }
        return false;
    }
    public static boolean isPositive(BigDecimal num) {
        if (num == null) {
            return false;
        }
        if (gt(num, BigDecimal.ZERO)) {
            return true;
        }
        return false;
    }
    public static boolean isZero(BigDecimal num) {
        if (num == null) {
            return false;
        }
        if (equals(num, BigDecimal.ZERO)) {
            return true;
        }
        return false;
    }
    public static BigDecimal subtractBigDecimal(BigDecimal dec1, BigDecimal dec2) {
        return (dec1 != null ? dec1 : DEFAULT_NUMBER).subtract(dec2 != null ? dec2 : DEFAULT_NUMBER);
    }
    public static BigDecimal multiplyBigDecimal(BigDecimal dec1, BigDecimal dec2) {
        return (dec1 != null ? dec1 : DEFAULT_NUMBER).multiply(dec2 != null ? dec2 : DEFAULT_NUMBER);
    }
    public static BigDecimal divideBigDecimal(BigDecimal dec1, BigDecimal dec2) {
        if (dec2 == null || dec2.equals(DEFAULT_NUMBER)) {
            return DEFAULT_NUMBER;
        }
        return (dec1 != null ? dec1 : DEFAULT_NUMBER).divide(dec2, 2, BigDecimal.ROUND_HALF_UP);
    }
    public static BigDecimal divideBigDecimal(BigDecimal dec1, BigDecimal dec2, int scale) {
        if (dec2 == null || dec2.equals(DEFAULT_NUMBER)) {
            return DEFAULT_NUMBER;
        }
        return (dec1 != null ? dec1 : DEFAULT_NUMBER).divide(dec2, scale, BigDecimal.ROUND_HALF_UP);
    }
    public static BigDecimal floorDivideBigDecimal(BigDecimal dec1, BigDecimal dec2) {
        if (dec2 == null || dec2.equals(DEFAULT_NUMBER)) {
            return DEFAULT_NUMBER;
        }
        return (dec1 != null ? dec1 : DEFAULT_NUMBER).divide(dec2, 0, BigDecimal.ROUND_FLOOR);
    }
    public static BigDecimal ceilingDivideBigDecimal(BigDecimal dec1, BigDecimal dec2) {
        if (dec2 == null || dec2.equals(DEFAULT_NUMBER)) {
            return DEFAULT_NUMBER;
        }
        return (dec1 != null ? dec1 : DEFAULT_NUMBER).divide(dec2, 0, BigDecimal.ROUND_CEILING);
    }
    public static BigDecimal toBigDecimal(int num) {
        return toBigDecimal(StringUtil.toString(num));
    }
    public static Integer toInteger(long num) {
        return toInteger(StringUtil.toString(num));
    }
    public static BigDecimal roundBigDecimal(BigDecimal dec1, int scale) {
        return (dec1 != null ? dec1 : DEFAULT_NUMBER).divide(new BigDecimal("1"), scale, BigDecimal.ROUND_HALF_UP);
    }
    public static BigDecimal floorBigDecimal(BigDecimal dec1, int scale) {
        return (dec1 != null ? dec1 : DEFAULT_NUMBER).divide(new BigDecimal("1"), scale, BigDecimal.ROUND_FLOOR);
    }
    public static BigDecimal ceilingBigDecimal(BigDecimal dec1, int scale) {
        return (dec1 != null ? dec1 : DEFAULT_NUMBER).divide(new BigDecimal("1"), scale, BigDecimal.ROUND_CEILING);
    }
    public static Boolean toBoolean(String str) {
        try {
            return new Boolean(str);
        } catch (Exception e) {
            return null;
        }
    }
    public static boolean isZero(Integer num) {
        if (num == null) {
            return true;
        }
        if (num == 0) {
            return true;
        }
        return false;
    }
    public static int toInt(String str) {
        Integer integer = toInteger(str);
        return (integer == null ? 0 : integer.intValue());
    }
    public static int toInt(Integer integer) {
        return (integer == null ? 0 : integer.intValue());
    }
    public static Integer toInteger(String str) {
        if (str == null) {
            return null;
        }
        if (StringUtil.isBlank(str)) {
            return 0;
        }
        try {
            return new Integer(str.trim());
        } catch (NumberFormatException nfe) {
            return null;
        }
    }
    public static Integer toInteger(int i) {
        try {
            return new Integer(i);
        } catch (NumberFormatException nfe) {
            return null;
        }
    }
    public static BigInteger toBigInteger(String str) {
        if (str == null) {
            return null;
        }
        try {
            return new BigInteger(str.trim());
        } catch (NumberFormatException nfe) {
            return null;
        }
    }
    public static BigDecimal toBigDecimal(String str) {
        if (str == null) {
            return null;
        }
        if (StringUtil.isBlank(str)) {
            return BigDecimal.ZERO;
        }
        try {
            return new BigDecimal(str.trim());
        } catch (NumberFormatException nfe) {
            return null;
        }
    }
    public static BigDecimal toBigDecimal(String str, String decPoPtn) {
        return toBigDecimal(formatDecDefault(str, decPoPtn));
    }
    public static Float toFloat(String str) {
        if (str == null) {
            return null;
        }
        try {
            return new Float(str.trim());
        } catch (NumberFormatException nfe) {
            return null;
        }
    }
    public static float totoPrimitiveFloat(String str) {
        return (str == null ? 0 : Float.parseFloat(str));
    }
    public static Long toLong(String str) {
        if (str == null) {
            return null;
        }
        try {
            return new Long(str.trim());
        } catch (NumberFormatException nfe) {
            return null;
        }
    }
    public static long totoPrimitiveLong(String str) {
        return (str == null ? 0 : Long.parseLong(str));
    }
    public static Double toDouble(String str) {
        if (str == null) {
            return null;
        }
        try {
            return new Double(str.trim());
        } catch (NumberFormatException nfe) {
            return null;
        }
    }
    public static double totoPrimitiveDouble(String str) {
        return (str == null ? 0 : Double.parseDouble(str));
    }
    public static String getDecimalStyleName(String decimalStyleId) {
        String value = null;
        for (int i = 0; i < DECIMAL_STYLE_LIST.length; i++) {
            if (DECIMAL_STYLE_LIST[i][0].equals(decimalStyleId)) {
                value = DECIMAL_STYLE_LIST[i][2];
                break;
            }
        }
        if (value == null) {
            throw new IllegalArgumentException("The value of an argument is inaccurate.");
        }
        return value;
    }
    public static String getDecPo(String decPoPtn) {
        return String.valueOf(getDecimalStyleValue(decPoPtn));
    }
    public static String getDecimalStyleValue(String decimalStyleId) {
        String value = null;
        for (int i = 0; i < DECIMAL_STYLE_LIST.length; i++) {
            if (DECIMAL_STYLE_LIST[i][0].equals(decimalStyleId)) {
                value = DECIMAL_STYLE_LIST[i][1];
                break;
            }
        }
        if (value == null) {
            throw new IllegalArgumentException("The value of an argument is inaccurate.");
        }
        return value;
    }
    public static char getDecimalStyleValueChar(String decimalStyleId) {
        return getDecimalStyleValue(decimalStyleId).charAt(0);
    }
    public static String formatIntValue(int n) {
        return formatIntValue(new Integer(n));
    }
    public static String formatIntView(int n, String numSepPtn) {
        return formatIntView(new Integer(n), numSepPtn);
    }
    public static String formatIntValue(Integer num) {
        if (num == null) {
            return null;
        }
        String format = "#####0";
        return formatNum(num, format, null, null);
    }
    public static String formatIntView(Integer num, String numGroupStyleId) {
        if (num == null) {
            return null;
        }
        String format = "###,##0";
        return formatNum(num, format, null, numGroupStyleId);
    }
    public static String formatDecValue(BigDecimal dec, String decimalStyleId) {
        return formatDecValue(dec, -1, decimalStyleId);
    }
    public static String formatDecValue(BigDecimal dec, Integer decLength, String decimalStyleId) {
        return formatDecValue(dec, decLength != null ? decLength.intValue() : -1, decimalStyleId);
    }
    public static String formatDecValue(BigDecimal dec, int decLength, String decimalStyleId) {
        if (dec == null) {
            return null;
        }
        String format = "#####0";
        if (decLength > 0) {
            // С������ָ������
            for (int i = 0; i < decLength; i++) {
                if (i == 0) {
                    format += ".";
                }
                format += "0";
            }
        } else {
            // С������ָ���ʤ�
            format += ".##########";
        }
        return formatNum(dec, format, decimalStyleId, null);
    }
    public static String formatDecView(BigDecimal dec, String decimalStyleId, String numGroupStyleId) {
        return formatDecView(dec, -1, decimalStyleId, numGroupStyleId);
    }
    public static String formatDecView(BigDecimal dec, Integer decLength,
                                       String decimalStyleId, String numGroupStyleId) {
        return formatDecView(dec,
                decLength != null ? decLength.intValue() : -1,
                decimalStyleId,
                numGroupStyleId);
    }
    public static String formatDecView(BigDecimal dec, int decLength,
                                       String decimalStyleId, String numGroupStyleId) {
        if (dec == null) {
            return null;
        }
        String format = "###,##0";
        if (decLength > 0) {
            // С������ָ������
            for (int i = 0; i < decLength; i++) {
                if (i == 0) {
                    format += ".";
                }
                format += "0";
            }
        } else {
            // С������ָ���ʤ�
            format += ".##########";
        }
        return formatNum(dec, format, decimalStyleId, numGroupStyleId);
    }
    protected static String formatNum(Object obj, String format, String decimalStyleId, String numGroupStyleId) {
        char decPo = decimalStyleId != null ? getDecimalStyleValueChar(decimalStyleId) : ' ';
        char numSep = numGroupStyleId != null ? getNumGroupStyleValueChar(numGroupStyleId) : ' ';
        DecimalFormat df = (DecimalFormat) NumberFormat.getInstance();
        df.applyPattern(format);
        String str = df.format(obj);
        if (str == null) {
            return null;
        }
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < str.length(); i++) {
            char c = str.charAt(i);
            if (c == ',') {
                sb.append(numSep);
                continue;
            }
            if (c == '.') {
                sb.append(decPo);
                if (i != str.length()) {
                    sb.append(str.substring(i + 1, str.length()));
                }
                break;
            }
            sb.append(c);
        }
        return sb.toString();
    }
    public static String formatDecDefault(String str, String decPoPtn) {
        if (str == null) {
            return null;
        }
        char decPo = getDecimalStyleValueChar(decPoPtn);
        StringBuffer sb = new StringBuffer(str);
        int idx = sb.toString().indexOf(String.valueOf(decPo));
        if (idx != -1) {
            sb.replace(idx, idx + String.valueOf(decPo).length(), String.valueOf('.'));
        }
        return sb.toString();
    }
    public static String getNumGroupStyleValue(String numGroupStyleId) {
        String value = null;
        for (int i = 0; i < NUM_GROUP_STYLE_LIST.length; i++) {
            if (NUM_GROUP_STYLE_LIST[i][0].equals(numGroupStyleId)) {
                value = NUM_GROUP_STYLE_LIST[i][1];
                break;
            }
        }
        if (value == null) {
            throw new IllegalArgumentException("The value of an argument is inaccurate.");
        }
        return value;
    }
    public static char getNumGroupStyleValueChar(String numGroupStyleId) {
        return getNumGroupStyleValue(numGroupStyleId).charAt(0);
    }
    public static String getNumGroupStyleName(String numGroupStyleId) {
        String value = null;
        for (int i = 0; i < NUM_GROUP_STYLE_LIST.length; i++) {
            if (NUM_GROUP_STYLE_LIST[i][0].equals(numGroupStyleId)) {
                value = NUM_GROUP_STYLE_LIST[i][2];
                break;
            }
        }
        if (value == null) {
            throw new IllegalArgumentException("The value of an argument is inaccurate.");
        }
        return value;
    }
    public static String roundString(String str) {
        BigDecimal dec = toBigDecimal(str);
        return (dec == null ? str : StringUtil.toString(roundBigDecimal(dec)));
    }
    public static BigDecimal roundBigDecimal(BigDecimal dec) {
        return (dec == null ? dec : dec.divide(new BigDecimal("1"), 0, BigDecimal.ROUND_HALF_UP));
    }
    public static int roundBigDecimal(int num) {
        return toInt(roundString(StringUtil.toString(num)));
    }
    public static String fomatNumber(double amount, String pattern) {
        NumberFormat nf = NumberFormat.getCurrencyInstance();
        DecimalFormat df = (DecimalFormat) nf;
        df.setMinimumFractionDigits(2);
        df.setMaximumFractionDigits(2);
        df.setDecimalSeparatorAlwaysShown(true);
        df.applyPattern(pattern);
        return df.format(amount);
    }
    public static String fomatNumber(long amount, String pattern) {
        NumberFormat nf = NumberFormat.getCurrencyInstance();
        DecimalFormat df = (DecimalFormat) nf;
        df.setMinimumFractionDigits(2);
        df.setMaximumFractionDigits(2);
        df.setDecimalSeparatorAlwaysShown(true);
        df.applyPattern(pattern);
        return df.format(amount);
    }
    public static BigDecimal addBigDecimal(BigDecimal dec1, BigDecimal dec2) {
        return (dec1 != null ? dec1 : new BigDecimal(0)).add(dec2 != null ? dec2 : new BigDecimal(0));
    }
    public static boolean isInteger(String target) {
        if (target == null) {
            return false;
        }
        char[] digit = new char[]{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'};
        for (int i = 0; i < target.length(); i++) {
            for (int j = 0; j < digit.length; j++) {
                if (target.charAt(i) == digit[j]) {
                    break;
                }
                if (i == 0 && target.charAt(i) == '-') {
                    break;
                }
                if (i == 0 && target.charAt(i) == '+') {
                    break;
                }
                if (j == digit.length - 1) {
                    return false;
                }
            }
        }
        return true;
    }
}

common/common-util/src/main/java/com/yihu/jw/util/common/StringUtil.java

@@ -1,5 +1,7 @@
package com.yihu.jw.util.common;
import org.apache.commons.lang3.StringUtils;
import java.text.DecimalFormat;
import java.util.Random;
@@ -39,4 +41,40 @@ public class StringUtil {
        return result;
    }
    public static String toString(Object obj) {
        if (obj == null) {
            return null;
        }
        return obj.toString();
    }
    public static boolean isEmpty(Object strObj) {
        if (strObj == null || strObj.toString().trim().length() < 1) {
            return true;
        } else {
            return false;
        }
    }
    public static boolean isStrEmpty(String str) {
        if ((str == null) || (str.trim().length() < 1) || "null".endsWith(str.toLowerCase())) {
            return true;
        } else {
            return false;
        }
    }
    public static String substring(String str, int start) {
        return StringUtils.substring(str, start);
    }
    public static String substring(String str, int start, int end) {
        return StringUtils.substring(str, start, end);
    }
    public static boolean isBlank(String str) {
        return StringUtils.isBlank(str);
    }
}

common/common-util/src/main/java/com/yihu/jw/util/sql/BeanTransformer.java

@@ -0,0 +1,218 @@
package com.yihu.jw.util.sql;
import org.hibernate.transform.ResultTransformer;
import javax.persistence.Column;
import java.beans.BeanInfo;
import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.sql.SQLException;
import java.sql.Timestamp;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
 * @created Airhead 2015/12/26.
 */
public class BeanTransformer<T> implements ResultTransformer {
    private final Class<T> mapClass;
    public Map<String, String> columnToProperty;
    public Map<String, String> propertyToColumn;
    public BeanTransformer(Class<T> mapClass) {
        this.mapClass = mapClass;
        this.initColumnsToProperties();
        this.initPropertiesToColumns();
    }
    public Object transformTuple(Object[] tuple, String[] aliases) {
        try {
            PropertyDescriptor[] props = this.propertyDescriptors();
            int[] col2Pro = this.mapColumnsToProperties(aliases, props);
            return this.createBean(tuple, mapClass, props, col2Pro);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
    @Override
    public List transformList(List list) {
        return list;
    }
    protected T newInstance(Class<T> c) throws Exception {
        try {
            return c.newInstance();
        } catch (InstantiationException | IllegalAccessException e) {
            throw new Exception("Cannot create " + c.getName() + ": " + e.getMessage());
        }
    }
    protected int[] mapColumnsToProperties(String[] aliases, PropertyDescriptor[] props) throws SQLException {
        int[] col2Pro = new int[aliases.length];
        Arrays.fill(col2Pro, -1);
        for (int col = 0; col < aliases.length; ++col) {
            String columnName = aliases[col];
            String propertyName = this.columnToProperty.get(columnName.toUpperCase());
            for (int i = 0; i < props.length; ++i) {
                if (propertyName.equals(props[i].getName())) {
                    col2Pro[col] = i;
                    break;
                }
            }
        }
        return col2Pro;
    }
    private T createBean(Object[] tuple, Class<T> type, PropertyDescriptor[] props, int[] col2Pro) throws Exception {
        T bean = this.newInstance(type);
        for (int i = 0; i < col2Pro.length; ++i) {
            int realIndex = col2Pro[i];
            if (realIndex != -1) {
                Object value = tuple[i];
                PropertyDescriptor prop = props[realIndex];
                this.callSetter(bean, prop, value);
            }
        }
        return bean;
    }
    private void callSetter(Object target, PropertyDescriptor prop, Object value) throws Exception {
        Method setter = prop.getWriteMethod();
        if (setter == null) {
            return;
        }
        Class<?>[] params = setter.getParameterTypes();
        try {
            // convert types for some popular ones
            if (value instanceof java.util.Date) {
                final String targetType = params[0].getName();
                if ("java.sql.Date".equals(targetType)) {
                    value = new java.sql.Date(((java.util.Date) value).getTime());
                } else if ("java.sql.Time".equals(targetType)) {
                    value = new java.sql.Time(((java.util.Date) value).getTime());
                } else if ("java.sql.Timestamp".equals(targetType)) {
                    Timestamp tsValue = (Timestamp) value;
                    int nanos = tsValue.getNanos();
                    value = new Timestamp(tsValue.getTime());
                    ((Timestamp) value).setNanos(nanos);
                }
            } else {
//                if (value instanceof String && params[0].isEnum()) {
//                    value = Enum.valueOf(params[0].asSubclass(Enum.class), (String) value);
//                }
            }
            // Don't call setter if the value object isn't the right type
            if (this.isCompatibleType(value, params[0])) {
                setter.invoke(target, new Object[]{value});
            } else {
                throw new Exception(
                        "Cannot set " + prop.getName() + ": incompatible types, cannot convert "
                                + value.getClass().getName() + " to " + params[0].getName());
                // value cannot be null here because isCompatibleType allows null
            }
        } catch (IllegalArgumentException | IllegalAccessException | InvocationTargetException e) {
            throw new SQLException(
                    "Cannot set " + prop.getName() + ": " + e.getMessage());
        }
    }
    private void initColumnsToProperties() {
        columnToProperty = new HashMap<>();
        Field[] fields = mapClass.getDeclaredFields();
        for (Field f : fields) {
            Column column = f.getAnnotation(Column.class);
            if (column == null) {
                continue;
            }
            String columnName = column.name();
            String propertyName = f.getName();
            columnToProperty.put(columnName.toUpperCase(), propertyName);
        }
    }
    private void initPropertiesToColumns() {
        propertyToColumn = new HashMap<>();
        Field[] fields = mapClass.getDeclaredFields();
        for (Field f : fields) {
            Column column = f.getAnnotation(Column.class);
            if (column == null) {
                continue;
            }
            String columnName = column.name();
            String propertyName = f.getName();
            propertyToColumn.put(propertyName,columnName.toUpperCase());
        }
    }
    private PropertyDescriptor[] propertyDescriptors() throws Exception {
        BeanInfo beanInfo = null;
        try {
            beanInfo = Introspector.getBeanInfo(mapClass);
        } catch (IntrospectionException e) {
            throw new Exception("Bean introspection failed: " + e.getMessage());
        }
        return beanInfo.getPropertyDescriptors();
    }
    private boolean isCompatibleType(Object value, Class<?> type) {
        // Do object check first, then primitives
        if (value == null || type.isInstance(value)) {
            return true;
        } else if (type.equals(Integer.TYPE) && value instanceof Integer) {
            return true;
        } else if (type.equals(Integer.TYPE) && value instanceof Long) {
            return true;
        } else if (type.equals(Long.TYPE) && value instanceof Long) {
            return true;
        } else if (type.equals(Double.TYPE) && value instanceof Double) {
            return true;
        } else if (type.equals(Float.TYPE) && value instanceof Float) {
            return true;
        } else if (type.equals(Short.TYPE) && value instanceof Short) {
            return true;
        } else if (type.equals(Byte.TYPE) && value instanceof Byte) {
            return true;
        } else if (type.equals(Character.TYPE) && value instanceof Character) {
            return true;
        } else if (type.equals(Boolean.TYPE) && value instanceof Boolean) {
            return true;
        }
        return false;
    }
}

common/common-util/src/main/java/com/yihu/jw/util/sql/ErrorCode.java

@@ -0,0 +1,290 @@
package com.yihu.jw.util.sql;
/**
 * @author Sand
 * @version 1.0
 * @created 2015.08.10 17:49
 */
public enum ErrorCode {
    MissMethod("ehr.common.miss.method"),
    MissTimestamp("ehr.common.miss.timestamp"),
    MissAppKey("ehr.common.miss.appid"),
    MissVersion("ehr.common.miss.version"),
    MissSign("ehr.common.miss.sign"),
    MissSignMethod("ehr.common.miss.signMethod"),
    InvalidMethod("ehr.common.invalid.method"),
    InvalidTimestamp("ehr.common.invalid.timestamp"),
    InvalidAppId("ehr.common.invalid.appid"),
    InvalidApiVersion("ehr.common.invalid.version"),
    InvalidSign("ehr.common.invalid.sign"),
    InvalidSignMethod("ehr.common.invalid.signMethod"),
    InvalidParameterFormat("ehr.common.invalid.parameterFormat"),
    MissRequiredArgument("ehr.common.miss.required.argument"),
    MissParameter("ehr.common.miss.parameter"),
    InvalidParameter("ehr.common.invalid.parameter"),
    AppTokenExpired("ehr.common.appToken.expired"),
    QueryNoData("ehr.common.query.null"),
    QueryTotalCount("ehr.common.query.count"),
    SuccessSave("ehr.common.success.update"),
    InvalidUpdate("ehr.common.invalid.update"),
    SuccessAdd("ehr.common.success.create"),
    SuccessDelete("ehr.common.success.delete"),
    InvalidDelete("ehr.common.invalid.delete"),
    InputRequestSingle("ehr.common.input.request.single"),
    InputRequestMultiple("ehr.common.input.request.multiple"),
    InvalidUser("ehr.invalid.user"),
    GetUserSecurityFailed("ehr.get.user.security.failed"),
    InvalidUserNameOrPwd("ehr.invalid.username.or.pwd"),
    InvalidValidateCode("ehr.login.validatecode.invalid"),
    ExpireValidateCode("ehr.login.validatecode.expire"),
    MailHasValidate("ehr.login.mail.hasinvaild"),
    InvalidMail("ehr.login.mail.invaild"),
    ExistUserForCreate("ehr.user.exist.create"),
    SuccessPublicKeyCreate("ehr.publicKey.success.create"),
    ExistOrgForCreate("ehr.org.exist.create"),
    ExistOrgForStandard("ehr.org.exist.standard"),
    InvalidAppRegister("ehr.app.register.invalid"),
    MissIdentityNo("ehr.patient.miss.identity.no"),
    InvalidIdentityNo("ehr.patient.invalid.identity.no"),
    PatientRegisterFailed("ehr.patient.register.failed"),
    InvalidFormatPatientRegister("ehr.patient.invalid.register.info"),
    PatientRegisterFailedForExist("ehr.patient.exist.create"),
    MissArchiveFile("ehr.archive.miss.file"),
    MissArchiveCrypto("ehr.archive.miss.cryptograph"),
    ParseArchiveCryptoFailed("ehr.archive.parse.cryptograph.failed"),
    SaveArchiveFailed("ehr.archive.save.failed"),
    RepeatSysDictName("ehr.sysDict.name.repeat"),
    RepeatOrgDict("ehr.orgDict.repeat"),
    RepeatOrgDictItem("ehr.orgDictItem.repeat"),
    RepeatOrgDataSet("ehr.orgDataSet.repeat"),
    RepeatOrgMetaData("ehr.orgMetaData.repeat"),
    InvalidCreateSysDict("ehr.sysDict.create.invalid"),
    NotExistSysDict("ehr.sysDict.exist.invalid"),
    InvalidDelSysDict("ehr.sysDict.del.invalid "),
    InvalidUpdateSysDict("ehr.sysDict.update.invalid"),
    RepeatSysDictEntryName("ehr.sysDictEntry.name.repeat"),
    InvalidCreateSysDictEntry("ehr.sysDictEntry.create.invalid"),
    InvalidSysDictEntry("ehr.sysDictEntry.name.invalid"),
    InvalidDelSysDictEntry("ehr.sysDictEntry.del.invalid"),
    InvalidUpdateSysDictEntry("ehr.sysDictEntry.update.invalid"),
    ParamError("ehr.std.param.error"),
    InvalidStdVersion("ehr.std.invalid.version"),
    GenerateArchiveFailed("ehr.std.generate.schema.file.failed"),
    GenerateArchiveFileStreamFailed("ehr.std.file.stream.generate.failed"),
    DownArchiveFileFailed("ehr.std.file.down.failed"),
    GenerateFileCryptographStreamFailed("ehr.std.file.cryptograph.generate.failed"),
    GenerateFileCryptographFailed("ehr.std.file.cryptograph.generate.failed"),
    GetStdVersionFailed("ehr.std.get.version.fail"),
    UnknownStdVersion("ehr.std.version.unknown"),
    GetCDAVersionListFailed("ehr.cda.version.list.get.failed"),
    GetCDAVersionFailed("ehr.cda.version.get.failed"),
    SaveCDAVersionFailed("ehr.cda.version.save.failed"),
    GetCDAInfoFailed("ehr.std.get.CDA.list.failed"),
    StdVersionHasPublished("ehr.cda.version.published"),
    GetSchemeVersionListFailed("ehr.scheme.version.list.get.failed"),
    GetSchemeVersionFailed("ehr.scheme.version.get.failed"),
    SaveSchemeVersionFailed("ehr.scheme.version.save.failed"),
    UpdateSchemeVersionFailed("ehr.scheme.version.update.failed"),
    DeleteSchemeVersionFailed("ehr.scheme.version.delete.failed"),
    ExistSchemeVersionName("ehr.scheme.version.name.exist"),
    GetSchemeListFailed("ehr.schemeList.Get.failed"),
    GetSchemeFailed("ehr.scheme.Get.failed"),
    SaveSchemeFailed("ehr.scheme.Save.failed"),
    UpdateSchemeFailed("ehr.scheme.update.failed"),
    DeleteSchemeFailed("ehr.scheme.delete.failed"),
    ExistSchemeVersion("ehr.scheme.version.exist"),
    ExistSchemeName("ehr.scheme.name.exist"),
    GetSchemeDispatchListFailed("ehr.schemeDispatchList.Get.failed"),
    GetSchemeDispatchFailed("ehr.schemeDispatch.Get.failed"),
    SaveSchemeDispatchFailed("ehr.schemeDispatch.Save.failed"),
    UpdateSchemeDispatchFailed("ehr.schemeDispatch.update.failed"),
    DeleteSchemeDispatchFailed("ehr.schemeDispatch.delete.failed"),
    StandardGetListFailed("ehr.standard.getlist.failed"),
    StandardSaveFailed("ehr.standard.save.failed"),
    StandardDeleteFailed("ehr.standard.delete.failed"),
    StandardDeletePublished("ehr.standard.delete.published"),
    StandardUpdateFailed("ehr.standard.update.failed"),
    StandardGetFailed("ehr.standard.get.failed"),
    StandardForkFailed("ehr.standard.fork.failed"),
    StandardImportFailed("ehr.standard.import.failed"),
    StandardExportFailed("ehr.standard.export.failed"),
    ExistStandardCode("ehr.standard.code.exist"),
    ExistStandardName("ehr.standard.name.exist"),
    ExistStandardVersion("ehr.standard.version.exist"),
    StandardVersionGetListFailed("ehr.standard.version.getlist.failed"),
    StandardVersionSaveFailed("ehr.standard.version.save.failed"),
    StandardVersionDeleteFailed("ehr.standard.version.delete.failed"),
    StandardVersionDeletePublished("ehr.standard.version.delete.published"),
    StandardVersionUpdateFailed("ehr.standard.version.update.failed"),
    StandardVersionGetFailed("ehr.standard.version.get.failed"),
    StandardVersionForkFailed("ehr.standard.version.fork.failed"),
    StandardVersionPublishFailed("ehr.standard.version.publish.failed"),
    ExistStandardVersionName("ehr.standard.version.name.exist"),
    StandardVersionUsedDeleteFailed("ehr.standard.version.used.delete.failed"),
    StandardCDACatalogGetListFailed("ehr.standard.cda.catalog.getlist.failed"),
    StandardCDACatalogSaveFailed("ehr.standard.cda.catalog.save.failed"),
    StandardCDACatalogDeleteFailed("ehr.standard.cda.catalog.delete.failed"),
    StandardCDACatalogUpdateFailed("ehr.standard.cda.catalog.update.failed"),
    StandardCDACatalogGetFailed("ehr.standard.cda.catalog.get.failed"),
    StandardCDADatasetMissVersion("ehr.standard.cda.dataset.miss.verison"),
    StandardCDADatasetMissID("ehr.standard.cda.dataset.miss.id"),
    StandardCDADatasetGetListFailed("ehr.standard.cda.dataset.getlist.failed"),
    StandardCDADatasetSaveFailed("ehr.standard.cda.dataset.save.failed"),
    StandardCDADatasetDeleteFailed("ehr.standard.cda.dataset.delete.failed"),
    StandardCDADatasetUpdateFailed("ehr.standard.cda.dataset.update.failed"),
    StandardCDADatasetGetFailed("ehr.standard.cda.dataset.get.failed"),
    StandardCDAMissVersion("ehr.standard.cda.miss.verison"),
    StandardCDAMissID("ehr.standard.cda.miss.id"),
    StandardCDAGetListFailed("ehr.standard.cda.getlist.failed"),
    StandardCDASaveFailed("ehr.standard.cda.save.failed"),
    StandardCDADeleteFailed("ehr.standard.cda.delete.failed"),
    StandardCDAUpdateFailed("ehr.standard.cda.update.failed"),
    StandardCDAGetFailed("ehr.standard.cda.get.failed"),
    StandardDatasetCatalogMissID("ehr.standard.dataset.catalog.miss.id"),
    StandardDatasetCatalogGetListFailed("ehr.standard.dataset.catalog.getlist.failed"),
    StandardDatasetCatalogSaveFailed("ehr.standard.dataset.catalog.save.failed"),
    StandardDatasetCatalogDeleteFailed("ehr.standard.dataset.catalog.delete.failed"),
    StandardDatasetCatalogUpdateFailed("ehr.standard.dataset.catalog.update.failed"),
    StandardDatasetCatalogGetFailed("ehr.standard.dataset.catalog.get.failed"),
    StandardDatasetMissVersion("ehr.standard.dataset.miss.version"),
    StandardDatasetMissID("ehr.standard.dataset.miss.id"),
    StandardDatasetGetListFailed("ehr.standard.dataset.getlist.failed"),
    StandardDatasetSaveFailed("ehr.standard.dataset.save.failed"),
    StandardDatasetDeleteFailed("ehr.standard.dataset.delete.failed"),
    StandardDatasetUpdateFailed("ehr.standard.dataset.update.failed"),
    StandardDatasetGetFailed("ehr.standard.dataset.get.failed"),
    ExistStandardDatasetCode("ehr.standard.dataset.code.exist"),
    StandardMetaDataMissVersion("ehr.standard.metadatamiss.version"),
    StandardMetaDataMissID("ehr.standard.metadatamiss.id"),
    StandardMetaDataGetListFailed("ehr.standard.metadatagetlist.failed"),
    StandardMetaDataSaveFailed("ehr.standard.metadatasave.failed"),
    StandardMetaDataDeleteFailed("ehr.standard.metadatadelete.failed"),
    StandardMetaDataUpdateFailed("ehr.standard.metadataupdate.failed"),
    StandardMetaDataGetFailed("ehr.standard.metadataget.failed"),
    ExistStandardMetaDataCode("ehr.standard.metaData.code.exist"),
    StandardDictMissVersion("ehr.standard.dict.miss.version"),
    StandardDictMissID("ehr.standard.dict.miss.id"),
    StandardDictGetListFailed("ehr.standard.dict.getlist.failed"),
    StandardDictSaveFailed("ehr.standard.dict.save.failed"),
    StandardDictDeleteFailed("ehr.standard.dict.delete.failed"),
    StandardDictUpdateFailed("ehr.standard.dict.update.failed"),
    StandardDictGetFailed("ehr.standard.dict.get.failed"),
    ExistStandardDictCode("ehr.standard.dict.code.exist"),
    StandardDictEntryMissVersion("ehr.standard.dict.entry.miss.version"),
    StandardDictEntryMissID("ehr.standard.dict.entry.miss.id"),
    StandardDictEntryGetListFailed("ehr.standard.dict.entry.getlist.failed"),
    StandardDictEntrySaveFailed("ehr.standard.dict.entry.save.failed"),
    StandardDictEntryDeleteFailed("ehr.standard.dict.entry.delete.failed"),
    StandardDictEntryUpdateFailed("ehr.standard.dict.entry.update.failed"),
    StandardDictEntryGetFailed("ehr.standard.dict.entry.get.failed"),
    ExistStandardDictEntryCode("ehr.standard.dict.entry.code.exist"),
    GetDataSetListFailed("ehr.datasetlist.Get.failed"),
    GetDataSetFailed("ehr.dataset.Get.failed"),
    SavedatasetFailed("ehr.dataset.Save.failed"),
    UpdateDatasetFailed("ehr.dataset.update.failed"),
    DeleteDataSetFailed("ehr.dataset.delete.failed"),
    GetDataSetRelationListFailed("ehr.datasetRelationlist.Get.failed"),
    GetDataSetRelationFailed("ehr.datasetRelation.Get.failed"),
    SaveDatasetRelationFailed("ehr.datasetRelation.Save.failed"),
    UpdateatasetRelationFailed("ehr.datasetRelation.update.failed"),
    DeleteDataSetRelationFailed("ehr.datasetRelation.delete.failed"),
    GetMetaDataListFaield("ehr.metadatalist.Get.failed"),
    GetMetaDataFailed("ehr.metadata.Get.failed"),
    SaveMetaDataFailed("ehr.metadata.save.failed"),
    UpdateMetaDataFailed("ehr.metadata.update.failed"),
    DeleteMetaDataFailed("ehr.metadata.delete.failed"),
    GetDictListFaild("ehr.dictlist.Get.failed"),
    GetDictFaild("ehr.dict.Get.failed"),
    GetDictEntryListFailed("ehr.dict.entries.get.failed"),
    GetDictEntryFailed("ehr.dict.entry.get.failed"),
    SaveDictFailed("ehr.dict.Save.failed"),
    UpdateDictFailed("ehr.dict.update.failed"),
    DeleteDictFailed("ehr.dict.delete.failed"),
    saveDictEntryFailed("ehr.dict.entry.save.failed"),
    UpdateDictEntryFailed("ehr.dict.entry.update.failed"),
    DeleteDictEntryFailed("ehr.dict.entry.delete.failed"),
    GetPublisherListFaield("ehr.publisherList.get.failed"),
    GetPublisherFailed("ehr.publisher.get.failed"),
    SavePublisherFailed("ehr.publisher.save.failed"),
    UpdatePublisherFailed("ehr.publisher.update.failed"),
    DeletePublisherFailed("ehr.publisher.delete.failed"),
    GetStandardSourceFailed("ehr.std.get.source.list.failed"),
    GenerateUserKeyFailed("ehr.security.generate.user.key.failed"),
    GetUserKeyFailed("ehr.security.get.user.key.failed"),
    UserAccessTokenExpired("ehr.security.token.expired"),
    UserRefreshTokenError("ehr.security.token.refreshError"),
    UserRevokeTokenFailed("ehr.security.token.revoke"),
    CodeIsNull("ehr.system.code.null"),
    NameIsNull("ehr.system.name.null"),
    VersionCodeIsNull("ehr.system.versioncode.null"),
    GetEhrArchiveFailed("ehr.ehr.get.archive"),
    GetEhrDataSetFailed("ehr.ehr.get.data.set"),
    CreateEhrDataSetTableFailed("ehr.ehr.create.data.set.table.failed"),
    TruncateTableFailed("ehr.hbase.truncate.table.failed"),
    GetTableFailed("ehr.hbase.get.table.failed"),
    ClearSolrDataFailed("ehr.clear.solr.data.failed"),
    //
    UnknownJsonPackageId("ehr.json.package.unknown"),
    // Quartz Scheduler
    SchedulerStartFailed("ehr.scheduler.start.failed"),
    SchedulerShutdownFailed("ehr.scheduler.shutdown.failed"),
    SchedulerAddJobFailed("ehr.scheduler.add.job"),
    SchedulerRemoveJobFailed("ehr.scheduler.remove.job"),
    GetJobDetailFailed("ehr.scheduler.get.job.failed"),
    GetTriggerFailed("ehr.scheduler.get.trigger.failed"),
    //Other
    SystemError("ehr.system.error");
    private final String errorCode;
    private ErrorCode(String errorCode) {
        this.errorCode = errorCode;
    }
    public String getErrorCode() {
        return errorCode;
    }
}

common/common-util/src/main/java/com/yihu/jw/util/sql/RequestParamTransformer.java

@@ -0,0 +1,110 @@
package com.yihu.jw.util.sql;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.JsonNodeType;
import com.yihu.jw.exception.ApiException;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.math.NumberUtils;
import java.io.IOException;
import java.util.*;
/**
 * @created Airhead 2015/12/29.
 */
public class RequestParamTransformer {
    public static final String SEPARATOR_FIELD = ",";
    public static final String SEPARATOR_KEYVALUE = ":";
    public static Map<String, Object> parseQuery(String query) throws ApiException {
        HashMap<String, Object> queryMap = new HashMap<String, Object>();
        if (StringUtils.isEmpty(query)) {
            return queryMap;
        }
        for (String cond : StringUtils.split(query, SEPARATOR_FIELD)) {
            String[] kv = StringUtils.split(cond, SEPARATOR_KEYVALUE);
            if (kv.length != 2) {
                throw new ApiException(ErrorCode.InvalidParameterFormat.getErrorCode());
            }
            String key = kv[0];
            String value = kv[1];
            queryMap.put(key, value);
        }
        return queryMap;
    }
    public static List<String> parseField(String fields) {
        List<String> fieldList = new ArrayList<String>();
        if (StringUtils.isEmpty(fields)) {
            return fieldList;
        }
        String[] filters = StringUtils.split(fields, SEPARATOR_FIELD);
        return Arrays.asList(filters);
    }
    public static List<String> parseSortBy(String sortBy) {
        List<String> sortList = new ArrayList<String>();
        if (StringUtils.isEmpty(sortBy)) {
            return sortList;
        }
        String[] fields = StringUtils.split(sortBy, SEPARATOR_FIELD);
        return Arrays.asList(fields);
    }
    public static List<String> parseOrder(String order) {
        List<String> orderList = new ArrayList<String>();
        if (StringUtils.isEmpty(order)) {
            return orderList;
        }
        String[] fields = StringUtils.split(order, SEPARATOR_FIELD);
        return Arrays.asList(fields);
    }
    public static Long parseLimit(String limit) {
        if (StringUtils.isEmpty(limit)) {
            return -1L;
        }
        return NumberUtils.toLong(limit);
    }
    public static Long parseOffset(String offset) {
        if (StringUtils.isEmpty(offset)) {
            return 0L;
        }
        return NumberUtils.toLong(offset);
    }
    public static Map parseJsonToMap(String condition) {
        ObjectMapper objectMapper = new ObjectMapper();
        HashMap<String, Object> map = new HashMap<String, Object>();
        if (!StringUtils.isEmpty(condition)) {
            try {
                JsonNode jsonNode = objectMapper.readTree(condition);
                Iterator<String> fileNames = jsonNode.fieldNames();
                while (fileNames.hasNext()) {
                    String fieldName = fileNames.next();
                    JsonNode valueNode = jsonNode.get(fieldName);
                    if (valueNode.getNodeType().equals(JsonNodeType.NUMBER)) {
                        map.put(fieldName, jsonNode.get(fieldName).asInt());
                    } else {
                        map.put(fieldName, jsonNode.get(fieldName).asText());
                    }
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return map;
    }
}

common/common-util/src/main/java/com/yihu/jw/util/sql/SqlConstants.java

@@ -0,0 +1,87 @@
package com.yihu.jw.util.sql;
/**
 * Created by lingfeng on 2015/6/23.
 */
public class SqlConstants {
    public static final String CREATE_TABLE = " CREATE TABLE ";
    public static final String INSERT_INTO = " INSERT INTO ";
    public static final String ALTER_TABLE = " ALTER TABLE ";
    public static final String DROP_TABLE = " DROP TABLE ";
    public static final String SELECT = " SELECT ";
    public static final String UPDATE = "UPDATE ";
    public static final String DELETE = "DELETE ";
    public static final String FROM = " FROM ";
    public static final String WHERE = " WHERE ";
    public static final String COUNT = " COUNT(*) ";
    public static final String ASTERISK = "*";
    public static final String IN = " IN ";
    public static final String BETWEEN = " BETWEEN ";
    public static final String BEGIN = "begin";
    public static final String END = "end";
    public static final String LIKE = " LIKE ";
    public static final String OR = " OR ";
    public static final String EQUAL_MARK = " = ";
    public static final String NE_MARK = " != ";
    public static final String GREATER_EQUAL_MARK = " >= ";
    public static final String LESS_EQUAL_MARK = " <= ";
    public static final String GREATER_MARK = " > ";
    public static final String LESS_MARK = " < ";
    public static final String SET = " SET ";
    public static final String AND = " AND ";
    public static final String QUESTION_MARK = " ? ";
    public static final String ADD = " ADD ";
    public static final String NOT_NULL = " NOT NULL ";
    public static final String BLANK = " ";
    public static final String PRIMARY_KEY = "PRIMARY_KEY ";
    public static final String PERCENT = "%";
    public static final String LEFT_BRACKET = "(";
    public static final String RIGHT_BRACKET = ")";
    public static final String COMMA = ",";
    public static final String SEMICOLON = ";";
    public static final String COLON = ":";
    public static final String UNION = " UNION ";
    public static final String VALUES = " VALUES ";
    public static final String ORDER_BY = " ORDER BY ";
    public static final String ASC = "ASC";
    public static final String DESC = "DESC";
    public static final String ROW_FORMAT_DYNAMIC = "row_format=dynamic";
    public static final String USERNAME_KEY = "u2akgXkkRRkiiCVR";
    public static final String ACCESS_TOKEN = "accessToken";
    public static final String REFRESH_TOKEN = "refreshToken";
    public static final String TOKEN_FAILD = "tokenFaild";
    public static final String TOKEN_EXPIRED = "tokenExpired";
    public static final String EMPTY = "";
    public static final String CDA_FILE = "CDA_File";
    public static final String STANDARD_ZIP = "standard.zip";
    public static final String DOT = ".";
    public static final String UPDATE_TYPE = "update";
    public static final String DELETE_TYPE = "delete";
    public static final String ADD_TYPE = "add";
    public static final String TABLE_KEY = "id";
    public static final String FAILURE_FLG = "valid";
    public static final String UNDERLINE = "_";
    public static final String STD_PREFIX = "std_";
    public static final String ADAPTER_PREFIX = "adapter_";
    public static final String ORIGIN_PREFIX = "origin_";
    public static final String CODE_STR = "code";
    public static final String VALUE_STR = "value";
    public static final String STANDARD = "standard";
    public static final String STANDARD_EHR = "standard_ehr";
    public static final String STANDARD_ORG = "standard_org";
    public static final String OK = "ok";
    public static final String NO = "no";
    public static final Integer NUMBER_ZREO = 0;
    public static final Integer NUMBER_ONE = 1;
    public static final String PATIENT_ID = "patient_id";
    public static final String EVENT_NO = "event_no";
    public static final String EVENT_TIME = "event_time";
    public static final String ORG_CODE = "rscom_org_code";
    public static final String MYSQL_DRIVER = "com.mysql.jdbc.Driver";
    public static final String ORACLE_DRIVER = "oracle.jdbc.driver.OracleDriver";
    public static final String SQLSERVER_DRIVER = "com.microsoft.sqlserver.jdbc.SQLServerDriver";
    public static final String MYSQL = "mysql";
    public static final String ORACLE = "oracle";
    public static final String SQLSERVER = "sqlserver";
}

common/common-util/src/main/java/com/yihu/jw/util/sql/SqlCreator.java

@@ -0,0 +1,316 @@
package com.yihu.jw.util.sql;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.node.JsonNodeType;
import com.yihu.jw.util.common.StringUtil;
import org.apache.commons.collections.CollectionUtils;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
 * Created by lingfeng on 2015/6/23.
 */
public class SqlCreator {
    private String tableName;
    private List<String> itemList;
    private List<String> itemValueList;
    private List<String> conditionList;
    private List<String> orderList;
    private Map<String, Object> keyValueMap;
    private BeanTransformer transformer;
    public SqlCreator(Class tClass) {
        keyValueMap = new HashMap<>();
        conditionList = new ArrayList<>();
        itemList = new ArrayList<>();
        itemValueList = new ArrayList<>();
        orderList = new ArrayList<>();
        transformer = new BeanTransformer(tClass);
    }
    public String insertData() {
        StringBuilder sqlBuffer = new StringBuilder();
        sqlBuffer.append(SqlConstants.INSERT_INTO + tableName + SqlConstants.LEFT_BRACKET);
        for (String item : itemList) {
            sqlBuffer.append(item + SqlConstants.COMMA);
        }
        sqlBuffer.deleteCharAt(sqlBuffer.length() - 1);
        sqlBuffer.append(SqlConstants.RIGHT_BRACKET + SqlConstants.VALUES + SqlConstants.LEFT_BRACKET);
        for (String item : itemValueList) {
            sqlBuffer.append(item + SqlConstants.COMMA);
        }
        sqlBuffer.deleteCharAt(sqlBuffer.length() - 1);
        sqlBuffer.append(SqlConstants.RIGHT_BRACKET + SqlConstants.SEMICOLON);
        return sqlBuffer.toString();
    }
    public String insertData(String tabelName, JsonNode jsonNode) {
        setTableName(tabelName);
        for (Object key : transformer.columnToProperty.keySet()) {
            String property = StringUtil.toString(transformer.columnToProperty.get(key));
            JsonNode propertyJsonNode = jsonNode.get(property);
            if (propertyJsonNode != null) {
                itemList.add(StringUtil.toString(key));
                itemValueList.add(SqlConstants.COLON + property);
                setKeyValueMapByType(property, propertyJsonNode, keyValueMap);
            }
        }
        return insertData();
    }
    public void setKeyValueMapByType(String property, JsonNode propertyJsonNode, Map<String, Object> keyValueMap) {
        JsonNodeType jsonNodeType = propertyJsonNode.getNodeType();
        if (jsonNodeType.equals(JsonNodeType.STRING)) {
            keyValueMap.put(property, propertyJsonNode.asText());
        } else if (jsonNodeType.equals(JsonNodeType.NUMBER)) {
            keyValueMap.put(property, propertyJsonNode.asInt());
        } else {
            keyValueMap.put(property, null);
        }
    }
    public String countData(String tabelName) {
        StringBuilder sqlBuffer = new StringBuilder();
        setTableName(tabelName);
        sqlBuffer.append(SqlConstants.SELECT);
        sqlBuffer.append(SqlConstants.COUNT);
        sqlBuffer.append(SqlConstants.FROM + tableName);
        if (!CollectionUtils.isEmpty(conditionList)) {
            sqlBuffer.append(SqlConstants.WHERE);
            sqlBuffer.append("1=1" + SqlConstants.AND);
            for (String condition : conditionList) {
                sqlBuffer.append(condition + SqlConstants.AND);
            }
            sqlBuffer.delete(sqlBuffer.length() - 4, sqlBuffer.length() - 1);
        }
        return sqlBuffer.toString();
    }
    public String selectData(String tabelName) {
        setTableName(tabelName);
        for(Object key : transformer.columnToProperty.keySet()){
            itemList.add(StringUtil.toString(key));
        }
        return selectData();
    }
    public String selectData() {
        StringBuilder sqlBuffer = new StringBuilder();
        sqlBuffer.append(SqlConstants.SELECT);
        for (String item : itemList) {
            sqlBuffer.append(item + SqlConstants.COMMA);
        }
        sqlBuffer.deleteCharAt(sqlBuffer.length() - 1);
        sqlBuffer.append(SqlConstants.FROM + tableName);
        if (!CollectionUtils.isEmpty(conditionList)) {
            sqlBuffer.append(SqlConstants.WHERE);
            sqlBuffer.append("1=1" + SqlConstants.AND);
            for (String condition : conditionList) {
                sqlBuffer.append(condition + SqlConstants.AND);
            }
            sqlBuffer.delete(sqlBuffer.length() - 4, sqlBuffer.length() - 1);
        }
        if (!CollectionUtils.isEmpty(orderList)) {
            for (String order : orderList) {
                sqlBuffer.append(order);
            }
            sqlBuffer.delete(sqlBuffer.length() - 1, sqlBuffer.length());
        }
        return sqlBuffer.toString();
    }
    public String updateDataByTableKey(String tabelName, JsonNode jsonNode) {
        setTableName(tabelName);
        StringBuilder sqlBuffer = new StringBuilder();
        sqlBuffer.append(SqlConstants.UPDATE + tableName + SqlConstants.SET);
        Map columnToProperty = transformer.columnToProperty;
        for (Object key : columnToProperty.keySet()) {
            String property = StringUtil.toString(columnToProperty.get(key));
            if (!property.equals(SqlConstants.TABLE_KEY)) {
                sqlBuffer.append(key + SqlConstants.EQUAL_MARK + SqlConstants.COLON + property + SqlConstants.COMMA);
                setKeyValueMapByType(property, jsonNode.get(property), keyValueMap);
            }
        }
        sqlBuffer.deleteCharAt(sqlBuffer.length() - 1);
        Object tableKey = columnToProperty.get(SqlConstants.TABLE_KEY.toUpperCase());
        sqlBuffer.append(SqlConstants.WHERE + SqlConstants.TABLE_KEY + SqlConstants.EQUAL_MARK + SqlConstants.COLON + tableKey);
        String property = StringUtil.toString(tableKey);
        setKeyValueMapByType(property, jsonNode.get(property), keyValueMap);
        return sqlBuffer.toString();
    }
    public String betweenCondition(String item, Object value1, Object value2) {
        String condition = item + SqlConstants.BETWEEN + SqlConstants.BEGIN + item + SqlConstants.AND + SqlConstants.END + item;
        keyValueMap.put(SqlConstants.BEGIN + item, value1);
        keyValueMap.put(SqlConstants.END + item, value2);
        conditionList.add(condition);
        return condition;
    }
    public String greaterAndEqualCondition(String item, Object value) {
        String condition = item + SqlConstants.GREATER_EQUAL_MARK + SqlConstants.COLON + item;
        keyValueMap.put(item, value);
        conditionList.add(condition);
        return condition;
    }
    public String greaterCondition(String item, Object value) {
        String condition = item + SqlConstants.GREATER_MARK + SqlConstants.COLON + item;
        keyValueMap.put(item, value);
        conditionList.add(condition);
        return condition;
    }
    public String lessAndEqualCondition(String item, Object value) {
        String condition = item + SqlConstants.LESS_EQUAL_MARK + SqlConstants.COLON + item;
        keyValueMap.put(item, value);
        conditionList.add(condition);
        return condition;
    }
    public String lessCondition(String item, Object value) {
        String condition = item + SqlConstants.LESS_MARK + SqlConstants.COLON + item;
        keyValueMap.put(item, value);
        conditionList.add(condition);
        return condition;
    }
    public String equalCondition(String item, Object value) {
        String column = StringUtil.toString(transformer.propertyToColumn.get(item));
        String condition = column + SqlConstants.EQUAL_MARK + SqlConstants.COLON + item;
        keyValueMap.put(item, value);
        conditionList.add(condition);
        return condition;
    }
    public String inCondition(String item, Object value) {
        String column = StringUtil.toString(transformer.propertyToColumn.get(item));
        String condition = column + SqlConstants.IN + SqlConstants.LEFT_BRACKET + SqlConstants.COLON + item + SqlConstants.RIGHT_BRACKET;
        keyValueMap.put(item, value);
        conditionList.add(condition);
        return condition;
    }
    public String equalConditionQue(String item, Object value) {
        String column = StringUtil.toString(transformer.propertyToColumn.get(item));
        String condition = column + SqlConstants.EQUAL_MARK + SqlConstants.QUESTION_MARK;
        keyValueMap.put(item, value);
        conditionList.add(condition);
        return condition;
    }
    public String likeOrCondition(String item1, String item2, Object value) {
        if (!StringUtil.isEmpty(value)) {
            String column1 = StringUtil.toString(transformer.propertyToColumn.get(item1));
            String column2 = StringUtil.toString(transformer.propertyToColumn.get(item2));
            String condition = SqlConstants.LEFT_BRACKET + column1 + SqlConstants.LIKE + SqlConstants.COLON + item1
                    + SqlConstants.OR + column2 + SqlConstants.LIKE + SqlConstants.COLON + item2 + SqlConstants.RIGHT_BRACKET;
            value = SqlConstants.PERCENT + value + SqlConstants.PERCENT;
            keyValueMap.put(item1, value);
            keyValueMap.put(item2, value);
            conditionList.add(condition);
            return condition;
        } else {
            return SqlConstants.EMPTY;
        }
    }
    public String likeCondition(String item, Object value) {
        String column = StringUtil.toString(transformer.propertyToColumn.get(item));
        String condition = column + SqlConstants.LIKE + SqlConstants.COLON + item;
        value = SqlConstants.PERCENT + value + SqlConstants.PERCENT;
        keyValueMap.put(item, value);
        conditionList.add(condition);
        return condition;
    }
    public String neCondition(String item, Object value) {
        String column = StringUtil.toString(transformer.propertyToColumn.get(item));
        String condition = column + SqlConstants.NE_MARK + SqlConstants.COLON + item;
        keyValueMap.put(item, value);
        conditionList.add(condition);
        return condition;
    }
    public String order(String item, Object value) {
        String column = StringUtil.toString(transformer.propertyToColumn.get(item));
        String order;
        if (CollectionUtils.isEmpty(orderList)) {
            order = SqlConstants.ORDER_BY + column + SqlConstants.BLANK + value + SqlConstants.COMMA;
        } else {
            order = column + SqlConstants.BLANK + value + SqlConstants.COMMA;
        }
        orderList.add(order);
        return order;
    }
    public String getTableName() {
        return tableName;
    }
    public void setTableName(String tableName) {
        this.tableName = tableName;
    }
    public List<String> getItemList() {
        return itemList;
    }
    public void setItemList(List<String> itemList) {
        this.itemList = itemList;
    }
    public List<String> getItemValueList() {
        return itemValueList;
    }
    public void setItemValueList(List<String> itemValueList) {
        this.itemValueList = itemValueList;
    }
    public List<String> getConditionList() {
        return conditionList;
    }
    public void setConditionList(List<String> conditionList) {
        this.conditionList = conditionList;
    }
    public Map<String, Object> getKeyValueMap() {
        return keyValueMap;
    }
    public void setKeyValueMap(Map<String, Object> keyValueMap) {
        this.keyValueMap = keyValueMap;
    }
    public List<String> getOrderList() {
        return orderList;
    }
    public void setOrderList(List<String> orderList) {
        this.orderList = orderList;
    }
    public BeanTransformer getTransformer() {
        return transformer;
    }
    public void setTransformer(BeanTransformer transformer) {
        this.transformer = transformer;
    }
}