一个日志记录工具类

LogUtil：

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

public class LogUtil {
    private static Log internalLog = LogFactory.getLog(LogUtil.class.getName());

    /**
     * trace级别日志信息，格式字符串使用{}占位符
     *
     * @param logFormat
     * @param args
     * @return
     * @author lihong10 2017年11月3日 下午15:42:30
     */
    public static void trace(String logFormat, Object... args) {
        try {
            StackTraceElement[] stacks = (new Throwable()).getStackTrace();
            String newClass = stacks[1].getClassName();
            Log logger = LogFactory.getLog(Class.forName(newClass).getName());
            StringBuffer logInfo = new StringBuffer(100);
            logInfo.append("[");
            logInfo.append(stacks[1].getLineNumber());
            logInfo.append("] ");
            logInfo.append(stacks[1].getMethodName());
            logInfo.append(": ");
            logInfo.append(ParseUtil.parseString(logFormat, args));
            logger.trace(logInfo);
        } catch (ClassNotFoundException e) {
            internalLog.error(e);
        }
    }


    /**
     * debug级别日志信息，格式字符串占位符使用{}
     *
     * @param logFormat
     * @param args
     * @return
     * @author lihong10 2017年11月3日 下午15:42:30
     */
    public static void debug(String logFormat, Object... args) {
        try {
            StackTraceElement[] stacks = (new Throwable()).getStackTrace();
            String newClass = stacks[1].getClassName();
            Log logger = LogFactory.getLog(Class.forName(newClass).getName());
            StringBuffer logInfo = new StringBuffer(100);
            logInfo.append("[");
            logInfo.append(stacks[1].getLineNumber());
            logInfo.append("] ");
            logInfo.append(stacks[1].getMethodName());
            logInfo.append(": ");
            logInfo.append(ParseUtil.parseString(logFormat, args));
            logger.debug(logInfo);
        } catch (ClassNotFoundException e) {
            internalLog.error(e);
        }
    }


    /**
     * info级别日志信息，可是字符串使用{}占位符
     *
     * @param logFormat
     * @param args
     * @return
     * @author lihong10 2017年11月3日 下午15:42:30
     */
    public static void info(String logFormat, Object... args) {
        try {
            StackTraceElement[] stacks = (new Throwable()).getStackTrace();
            String newClass = stacks[1].getClassName();
            Log logger = LogFactory.getLog(Class.forName(newClass).getName());
            StringBuffer logInfo = new StringBuffer(100);
            logInfo.append("[");
            logInfo.append(stacks[1].getLineNumber());
            logInfo.append("] ");
            logInfo.append(stacks[1].getMethodName());
            logInfo.append(": ");
            logInfo.append(ParseUtil.parseString(logFormat, args));
            logger.info(logInfo);
        } catch (ClassNotFoundException e) {
            internalLog.error(e);
        }
    }


    /**
     * warn级别日志信息，格式字符串使用{}占位符
     *
     * @param logFormat
     * @param args
     * @return
     * @author lihong10 2017年11月3日 下午15:42:30
     */
    public static void warn(String logFormat, Object... args) {
        try {
            StackTraceElement[] stacks = (new Throwable()).getStackTrace();
            String newClass = stacks[1].getClassName();
            Log logger = LogFactory.getLog(Class.forName(newClass).getName());
            StringBuffer logInfo = new StringBuffer(100);
            logInfo.append("[");
            logInfo.append(stacks[1].getLineNumber());
            logInfo.append("] ");
            logInfo.append(stacks[1].getMethodName());
            logInfo.append(": ");
            logInfo.append(ParseUtil.parseString(logFormat, args));
            logger.warn(logInfo);
        } catch (ClassNotFoundException e) {
            internalLog.error(e);
        }
    }


    /**
     * error级别日志信息，格式字符串使用{}占位符
     *
     * @param e
     * @param logFormat
     * @param args
     * @return
     * @author lihong10 2017年11月3日 下午15:42:30
     */
    public static void error(Exception e, String logFormat, Object... args) {
        try {
            StackTraceElement[] stacks = (new Throwable()).getStackTrace();
            String newClass = stacks[1].getClassName();
            Log logger = LogFactory.getLog(Class.forName(newClass).getName());
            StringBuffer logInfo = new StringBuffer(100);
            logInfo.append("[");
            logInfo.append(stacks[1].getLineNumber());
            logInfo.append("] ");
            logInfo.append(stacks[1].getMethodName());
            logInfo.append(": ");
            logInfo.append(ParseUtil.parseString(logFormat, args));
            logInfo.append("\nCaused by: ");
            logger.error(e);
        } catch (ClassNotFoundException ex) {
            internalLog.error(e);
        }
    }

    public static void error(String logFormat, Exception e) {
        try {
            StackTraceElement[] stacks = (new Throwable()).getStackTrace();
            String newClass = stacks[1].getClassName();
            Log logger = LogFactory.getLog(Class.forName(newClass).getName());
            StringBuffer logInfo = new StringBuffer(100);
            logInfo.append("[");
            logInfo.append(stacks[1].getLineNumber());
            logInfo.append("] ");
            logInfo.append(stacks[1].getMethodName());
            logInfo.append(": ");
            logInfo.append(logFormat == null ? "" : logFormat);
            logInfo.append("\nCaused by: ");
            logger.error(e);
        } catch (ClassNotFoundException ex) {
            internalLog.error(e);
        }
    }

    public static void error(Exception e) {
        try {
            StackTraceElement[] stacks = (new Throwable()).getStackTrace();
            String newClass = stacks[1].getClassName();
            Log logger = LogFactory.getLog(Class.forName(newClass).getName());
            StringBuffer logInfo = new StringBuffer(100);
            logInfo.append("[");
            logInfo.append(stacks[1].getLineNumber());
            logInfo.append("] ");
            logInfo.append(stacks[1].getMethodName());
            logInfo.append(": ");
            logInfo.append("\nCaused by: ");
            logger.error(e);
        } catch (ClassNotFoundException ex) {
            internalLog.error(e);
        }
    }


}

Bean2MapUtil：

import java.lang.reflect.Field;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.util.*;

/**
 * 该类用于将对象转成map并返回
 *
 * @author lihong10 2017-10-31 上午11:04:10
 * @version v1.0
 */
public class Bean2MapUtil {

    /**
     * 将bean的所有属性存为map， 包括null
     *
     * @author lihong10 2015-5-7 下午3:18:56
     * @param bean bean
     * @return object map
     */
    @SuppressWarnings("unused")
    public static Map<String, Object> toMap(Object bean) {
        Field[] fields = bean.getClass().getDeclaredFields();
        List<String> includedAndAlias = new ArrayList<String>();
        int i = 0;
        for (Field f : fields) {
            if ("this$0".equals(f.getName())) {//内部类默认拥有此属性， 不应该写入map
                continue;
            }
            includedAndAlias.add(f.getName());
        }
        return toMap(bean, includedAndAlias.toArray(new String[includedAndAlias.size()]));
    }

    /**
     * 将Java bean转换为map<String,Object>对象, 可指定包含的属性及属性别名<br>
     * 如 Map<String, Object> objectMap = toMap(object, new String[]{"id:userId","name","age"})<br>
     * 这个调用将object中的id, name, age 字段名和字段值作为key-value对映射到map中, 并给id指定了别名userId<br>
     *
     * @author lihong10 2015-4-20 下午7:45:38
     * @param bean             java bean
     * @param includedAndAlias 要包含的属性[:别名]
     * @return object map
     */
    public static Map<String, Object> toMap(Object bean, String[] includedAndAlias) {
        Field[] fields = bean.getClass().getDeclaredFields();
        Map<String, Object> map = new HashMap<String, Object>();
        for (String nameAndAlias : includedAndAlias) {
            String[] names = nameAndAlias.split(":");
            String fieldName = names[0];
            String mapName = fieldName;
            if (names.length > 1) {
                mapName = names[1];
            }

            boolean hasField = false;
            Field target = null;
            for (Field f : fields) {
                if (fieldName.equals(f.getName())) {
                    hasField = true;
                    target = f;
                    break;
                }
            }
            if (!hasField) {
                throw new RuntimeException(String.format("there is no field named '%s' declared in %s", fieldName, bean.getClass().getName()));
            }
            target.setAccessible(true);
            try {
                map.put(mapName, target.get(bean));
            } catch (IllegalArgumentException | IllegalAccessException e) {
                System.out.println(e);
            }
        }
        return map;
    }

    /**
     * 将实体list转换成map list
     *
     * @author lihong10 2015-6-30 下午4:38:28
     * @param list
     * @param includedAndAlias
     * @return List<Map<String, Object>>
     */
    @SuppressWarnings("rawtypes")
    public static List<Map<String, Object>> toMap(List list, String[] includedAndAlias) {
        List<Map<String, Object>> data = new ArrayList<Map<String, Object>>();
        for (Object obj : list) {
            data.add(toMap(obj, includedAndAlias));
        }
        return data;
    }

    /**
     * 将实体list转换成map list
     *
     * @author lihong10 2015-7-22 上午11:12:29
     * @param list
     * @return List<Map<String, Object>>
     */
    @SuppressWarnings("rawtypes")
    public static List<Map<String, Object>> toMap(List list) {
        List<Map<String, Object>> data = new ArrayList<Map<String, Object>>();
        for (Object obj : list) {
            data.add(toMap(obj));
        }
        return data;
    }

    /**
     * 将Java bean转换为map<String,Object>对象, 可指定包含的属性及属性别名<br>
     * 如 Map<String, Object> objectMap = toMap(object, new String[]{"id:userId","name","age"})<br>
     * 这个调用将object中的id, name, age 字段名和字段值作为key-value对映射到map中, 并给id指定了别名userId<br>
     *
     * @author lihong10 2015-4-20 下午7:45:38
     * @param bean          java bean
     * @param differenceSet 要包含的属性[:别名]
     * @return object map
     */
    public static Map<String, Object> toMapByDifferenceSet(Object bean, String[] differenceSet) {
        Field[] fields = bean.getClass().getDeclaredFields();
        Map<String, Object> map = new HashMap<String, Object>();
        List<String> differenceSetList = new ArrayList<String>(Arrays.asList(differenceSet));
        for (Field field : fields) {
            boolean isInDifferenceSet = false;
            for (Iterator<String> iterator = differenceSetList.iterator(); iterator.hasNext(); ) {
                String difference = (String) iterator.next();
                if (field.getName().equals(difference)) {
                    isInDifferenceSet = true;
                    iterator.remove();
                    break;
                }
            }
            if (!isInDifferenceSet) {
                field.setAccessible(true);
                try {
                    map.put(field.getName(), field.get(bean));
                } catch (IllegalArgumentException | IllegalAccessException e) {
                    System.out.println(e);
                }
            }
        }
        if (differenceSetList.isEmpty() == false) {
            throw new RuntimeException(String.format("there is no field named '%s' declared in %s where runing method toMapByDifferenceSet(Object bean, String[] differenceSet)",
                    differenceSetList.toString(),
                    bean.getClass().getName()));
        }

        return map;
    }

    /**
     * 将实体list转换成map list
     *
     * @author lihong10 2015-6-30 下午4:38:28
     * @param list
     * @param differenceSet
     * @return List<Map<String, Object>>
     */
    @SuppressWarnings("rawtypes")
    public static List<Map<String, Object>> toMapByDifferenceSet(List list, String[] differenceSet) {
        List<Map<String, Object>> data = new ArrayList<Map<String, Object>>();
        for (Object obj : list) {
            data.add(toMapByDifferenceSet(obj, differenceSet));
        }
        return data;
    }


    /**
     * 获取对象的某个属性值
     *
     * @author lihong10 2017-10-31 下午12:12:09
     * @param propertyName
     * @param obj
     * @return 属性值
     */
    @SuppressWarnings({"rawtypes", "unchecked"})
    public static Object getProperty(final Object obj, String propertyName) {
        Class cls = obj.getClass();
        try {
            final Field field = cls.getDeclaredField(propertyName);
            return AccessController.doPrivileged(new PrivilegedAction() {
                public Object run() {
                    boolean accessible = field.isAccessible();
                    field.setAccessible(true);
                    Object result = null;
                    try {
                        result = field.get(obj);
                    } catch (IllegalAccessException e) {
                        //error wont' happen
                        System.out.println(e);
                    }
                    field.setAccessible(accessible);
                    return result;
                }
            });
        } catch (Exception e) {
            System.out.println(e);
            return null;
        }
    }

    /**
     * 循环向上转型,获取对象的DeclaredField.
     * @author lihong10 2017-10-31 下午12:12:09
     * @param clazz        类型
     * @param propertyName 属性名
     * @return 返回对应的Field
     * @throws NoSuchFieldException 如果没有该Field时抛出.
     */
    @SuppressWarnings("rawtypes")
    public static Field getDeclaredField(Class clazz, String propertyName)
            throws NoSuchFieldException {

        for (Class superClass = clazz; superClass != Object.class;
             superClass = superClass.getSuperclass()) {
            try {
                return superClass.getDeclaredField(propertyName);
            } catch (NoSuchFieldException ex) {
                // Field不在当前类定义,继续向上转型
                System.out.println(ex);
            }
        }

        throw new NoSuchFieldException("No such field: " + clazz.getName()
                + '.' + propertyName);
    }

    /**
     * 强制设置对象变量值,忽略private,protected修饰符的限制.
     * @author lihong10 2017-10-31 下午12:12:09
     * @param object       对象实例
     * @param propertyName 属性名
     * @param newValue     赋予的属性值
     * @throws NoSuchFieldException 如果没有该Field时抛出.
     */
    @SuppressWarnings({"unchecked", "rawtypes"})
    public static void forceSetProperty(final Object object,
                                        final String propertyName, final Object newValue)
            throws NoSuchFieldException {

        final Field field = getDeclaredField(object.getClass(), propertyName);

        AccessController.doPrivileged(new PrivilegedAction() {
            /** * run. */
            public Object run() {
                boolean accessible = field.isAccessible();
                field.setAccessible(true);

                try {
                    field.set(object, newValue);
                } catch (IllegalAccessException e) {
                    //"Error won't happen
                    System.out.println(e);
                }
                field.setAccessible(accessible);
                return null;
            }
        });
    }

}

ParseUtil：

import java.util.*;

/**
 * Created by lihong10 on 2017/10/28.
 */
public class ParseUtil {

    private ParseUtil() {

    }

    /**
     * 将字符串text中由openToken(目前默认是{)和closeToken（目前默认是}）组成的占位符依次替换为args数组中的值。
     * 该方法取自mybatis框架，是mybatis默认的占位符解析器，性能极高。
     * @param openToken
     * @param closeToken
     * @param text
     * @param args
     * @return
     */
    public static String parse(String openToken, String closeToken, String text, Object data, Object... args) {
        if (data == null &&  (args == null || args.length <= 0)) {
            return text;
        }
        int argsIndex = 0;

        if (text == null || text.isEmpty()) {
            return "";
        }
        char[] src = text.toCharArray();
        int offset = 0;
        // search open token
        int start = text.indexOf(openToken, offset);
        if (start == -1) {
            return text;
        }
        final StringBuilder builder = new StringBuilder();
        StringBuilder expression = null;
        while (start > -1) {
            if (start > 0 && src[start - 1] == '\\') {
                // this open token is escaped. remove the backslash and continue.
                builder.append(src, offset, start - offset - 1).append(openToken);
                offset = start + openToken.length();
            } else {
                // found open token. let's search close token.
                if (expression == null) {
                    expression = new StringBuilder();
                } else {
                    expression.setLength(0);
                }
                builder.append(src, offset, start - offset);
                offset = start + openToken.length();
                int end = text.indexOf(closeToken, offset);
                while (end > -1) {
                    if (end > offset && src[end - 1] == '\\') {
                        // this close token is escaped. remove the backslash and continue.
                        expression.append(src, offset, end - offset - 1).append(closeToken);
                        offset = end + closeToken.length();
                        end = text.indexOf(closeToken, offset);
                    } else {
                        expression.append(src, offset, end - offset);
                        offset = end + closeToken.length();
                        break;
                    }
                }
                if (end == -1) {
                    // close token was not found.
                    builder.append(src, start, src.length - start);
                    offset = src.length;
                } else {
                    ///从mybatis拷贝后仅仅修改了该else分支下的个别行代码
                    String value = null;
                    String key = expression.toString().trim();
                    if(data == null)  {
                        value = TokenHandler.handleToken(argsIndex, args);
                        argsIndex++;
                    } else {
                        if (data instanceof Map) {
                            Map<String, Object> map = (Map) data;
                            value = TokenHandler.handleToken(key, map);
                        } else if (data instanceof Properties) {
                            Properties prop = (Properties) data;
                            value = TokenHandler.handleToken(key, prop);
                        } else if(data instanceof List){
                            List list = (List) data;
                            value = TokenHandler.handleToken(argsIndex, list);
                            argsIndex++;
                        }else {
                            value = TokenHandler.handleToken(key, data);
                        }
                    }
                    builder.append(value);
                    offset = end + closeToken.length();
                    
                }
            }
            start = text.indexOf(openToken, offset);
        }
        if (offset < src.length) {
            builder.append(src, offset, src.length - offset);
        }
        return builder.toString();
    }

    public static String parseMap(String text, Map<String, Object> data) {
        return ParseUtil.parse("{", "}", text,  data, null);
    }

    public static String parseString(String text, Object... args) {
        return ParseUtil.parse("{", "}", text, null, args);
    }

    public static String parseProp(String text, Properties prop) {
        return ParseUtil.parse("{", "}", text, prop, null);
    }

    public static String parseList(String text, List<Object> list) {
        return ParseUtil.parse("{", "}", text, list, null);
    }

    public static String parseObj(String text, Object bean) {
        return ParseUtil.parse("{", "}", text, bean, null);
    }


    private static class TokenHandler {
        private TokenHandler() {
        }

        private static String handleToken(String key, Properties variables) {
            if (variables != null) {
                if (variables.containsKey(key)) {
                    return variables.getProperty(key);
                }
                return null;//不含有key属性
            }
            return null; //variables为空
        }

        private static String handleToken(int index, Object... args) {
            if (args == null || args.length == 0) {
                return null;
            }

            String value = (index <= args.length - 1) ?
                    (args[index] == null ? null : args[index].toString()) : null;
            return value;
        }

        private static String handleToken(int index, List<Object> list) {
            if (list == null || list.size() == 0) {
                return null;
            }

            String value = (index <= list.size() - 1) ?
                    (list.get(index) == null ? null : list.get(index).toString()) : null;
            return value;
        }

        private static String handleToken(String key, Map<String, Object> map) {
            String value = (map == null || map.get(key) == null) ?
                    null : map.get(key).toString();
            return value;
        }

        private static String handleToken(String property, Object obj) {
            if (obj == null) {
                return null;
            }
            Object field = Bean2MapUtil.getProperty(obj, property);
            if (field == null) {
                return null;
            }
            return field.toString();
        }
    }


    /**
     * 使用示例
     * @param args
     */
    public static void main(String... args) {
        Map data = new HashMap<String, Object>(){{
            put("name", "雷锋");
            put("result", true);
            put("confidence", 99.9);
            put("", this);
        }};

        List<Object> li = new LinkedList<Object>(){{
            add("david");
            add(1);
            add(true);
            add(null);
            add(new Object());
            add(123.4);
            add(1000L);
        }};


        //{}被转义，不会被替换
        System.out.println(ParseUtil.parseString("我的名字是\\{},结果是{}，可信度是%{}", "雷锋", true, 100));
        System.out.println(ParseUtil.parseString("我的名字是{},结果是{}，可信度是%{}", "雷锋", true, 100));
        System.out.println(ParseUtil.parseMap("我的名字是{name},结果是{result}，可信度是%{confidence}, 执行类是{}", data));
        System.out.println(ParseUtil.parseList("{}-{}-{}-{}-{}-{}-{}-{}", li));
        System.out.println(ParseUtil.parseObj("{}-{}-{}-{}-{}-{}-{}-{}", null));
        System.out.println(ParseUtil.parseList(null, li));
    }
}

ReflectUtil：

import org.apache.hadoop.hbase.util.Bytes;

import java.lang.reflect.Field;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class ReflectUtil {



    public static List<Field> getAllFieldList(Class<?> cls) {
        List<Field> declaredFields = new ArrayList<Field>();
        Field[] filedArr = cls.getDeclaredFields();
        for (Field field : filedArr) {
            declaredFields.add(field);
        }
        Class<?> superClass = cls.getSuperclass();
        if (superClass != null && superClass != Object.class) {
            List<Field> list = getAllFieldList(superClass);
            if (list != null) {
                declaredFields.addAll(list);
            }
        }

        return declaredFields;
    }

    public static Map<String, Field> getFieldMap(Class<?> cls) {
        List<Field> allFieldList = getAllFieldList(cls);
        if (CollectionUtil.isEmpty(allFieldList)) {
            return new HashMap<String, Field>();
        }

        Map<String, Field> result = new HashMap<String, Field>();
        for (Field field : allFieldList) {
            result.put(field.getName(), field);
        }

        return result;
    }

    public static Map<String, Field> getFieldMap(List<Field> fieldList) {
        if (CollectionUtil.isEmpty(fieldList)) {
            return null;
        }

        Map<String, Field> result = new HashMap<String, Field>();
        for (Field field : fieldList) {
            result.put(field.getName(), field);
        }

        return result;
    }


    public static Object getValue(final Object obj, final Field field) {
        Class cls = obj.getClass();
        try {
            return AccessController.doPrivileged(new PrivilegedAction() {
                public Object run() {
                    boolean accessible = field.isAccessible();
                    field.setAccessible(true);
                    Object result = null;
                    try {
                        result = field.get(obj);
                    } catch (IllegalAccessException e) {
                        //error wont' happen
                        LogUtil.error(e);
                    }
                    field.setAccessible(accessible);
                    return result;
                }
            });
        } catch (Exception e) {
            LogUtil.error(e);
            return null;
        }
    }



    public static byte[] getBytes(Field field, Object obj) {
        String canonicalName = field.getType().getCanonicalName();
        LogUtil.info(canonicalName);
        switch (canonicalName) {
            case "int":
            case "java.lang.Integer":
                Integer anInt = (int)getValue(obj, field);
                return anInt == null ? null : Bytes.toBytes(anInt);
            case "java.lang.Long":
            case "long":
                Long aLong = (long)getValue(obj, field);
                return aLong == null ? null : Bytes.toBytes(aLong);
            case "float":
            case "java.lang.Float":
                Float aFloat = (float)getValue(obj, field);
                return aFloat == null ? null : Bytes.toBytes(aFloat);
            case "boolean":
            case "java.lang.Boolean":
                Boolean aBoolean = (boolean)getValue(obj, field);
                return aBoolean == null ? null : Bytes.toBytes(aBoolean);
            case "byte":
            case "java.lang.Byte":
                Byte aByte =  (byte)getValue(obj, field);
                return aByte == null ? null : Bytes.toBytes(aByte);
            case "char":
            case "java.lang.Character":
                Character aChar = (char)getValue(obj, field);
                return aChar == null ? null : Bytes.toBytes(aChar);
            case "double":
            case "java.lang.Double":
                Double aDouble = (double)getValue(obj, field);
                return aDouble == null ? null : Bytes.toBytes(aDouble);
            case "short":
            case "java.lang.Short":
                Short aShort = (short)getValue(obj, field);
                return aShort == null ? null : Bytes.toBytes(aShort);
            default:
               return null;
        }
    }








    public static void main(String... args) throws IllegalAccessException {

        List<Field> allFieldList = getAllFieldList(Person.class);

        for (Field f : allFieldList) {
            getBytes(f, new Person());
        }
    }
}

GenericTypeUtil：

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.List;

public class GenericTypeUtil {


    public static Class getSuperClassGenricType(Class clazz) {
        return getSuperClassGenricType(clazz, 0);
    }


    public static Class getSuperClassGenricType(Class clazz, int index) {

        Type genType = clazz.getGenericSuperclass();

        if (!(genType instanceof ParameterizedType)) {
            LogUtil.warn(clazz.getSimpleName() + "'s superclass not ParameterizedType");
            return Object.class;
        }

        Type[] params = ((ParameterizedType) genType).getActualTypeArguments();

        if (index >= params.length || index < 0) {
            LogUtil.warn("Index is {}, Size of Parameterized Type {} is {} ",  index, clazz.getSimpleName(), params.length);
            return Object.class;
        }
        if (!(params[index] instanceof Class)) {
            LogUtil.warn(clazz.getSimpleName() + " not set the actual class on superclass generic parameter");
            return Object.class;
        }
        return (Class) params[index];
    }


    public static void main(String... args) {

        List<String> li1 = new ArrayList<String>();


    }





}