一个日志记录工具类

分享8款安全监控/日志记录工具 关于安全监控工具,它通过对计算机系统、网络、应用程序和数据进行实时监控和分析,帮助发现和防止安全威胁和攻击。这种监控不仅有助于及时发现和处理安全事件,还能有效减少安全漏洞和损失,从而提高整个系统的安全性和可靠性。特别是在网络安全方面,除了提供基础的访问控制,安全监控还包括入侵检测等功能,实现细粒度的控制。在服务器环境中,安全监控还涉及到对服务器和网络可用性的监测、性能优化,以及对关键活动的监控。 阅读详情
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>();


    }





}

Qt5之 简单的日志记录工具类 qt5 自己做的一个读写 sqlite3 的数据工具,能打开sqlite3格式的数据库文件 地址:https://blog.csdn.net/HK_5788/article/details/80963547 完善前面的文章中提到的工具,最近在实战中遇到了不少问题,故增加日志记录功能,记录软件的一些信息,方便查找问题 Qt 5 , mingw     ------------- 上代码--... 阅读详情

相关推荐

工作日志记录软件

、具有注册人员信息和注册工作地点的基本功能 2、具有日志编辑功能 3、具有日志检索功能(日期、地点和工作类型检索) 4、具有选择日志的显示和报表显示功能 5、具有报表的打印功能和保存为txt文档的功能 需要改进的地方:1、报表的现实功能,目前实现的报表是通过自己设置的,如果日志记录太长,显示不全。2、报表的打印功能,目前报表的打印只能通过判断选择的打印机进行打印,其他的打印的基本调整还没有,需要增加打印预览功能。3、下次升级主要完成功能的完善,版本要升高最好能用到文件的直接处理。

【log4j2】将info和error级别的日志分别输出到不同的appender中

目的:将我的应用输出的info消息放到一个info.log文件,将所有error消息输出到logs.log文件。 需要注意的是,info消息是限制在我自己的应用下的,也就是其他框架输出的info不保存。 <?xml version="1.0" encoding="UTF-8"?> <Configuration> <Properties> ...

kanbe_kotori的专栏 3335

工作记录日志软件

该软件操作简单,可创建日志模版,界面清晰易看。

9款日志管理工具大比拼,选型必备!

点击关注公众号,利用碎片时间学习简介对于日志管理当前网络上提供了大量的日志工具,今天就给大家分析总结一下这些常用工具的特点,希望对你们在选型时有所帮助,如果有用记得一键三连。1、FilebeatFilebeat是用于转发和集中日志数据的轻量级传送程序。作为服务器上的代理安装,Filebeat监视您指定的日志文件或位置,收集日志事件,并将它们转发到Elasticsearch或Logstash进行索引...

Java笔记虾 2962

非常简单实用的日志记录软件,按天存放为txt文本

软件运行过程中,可将需要的信息、数据、或异常打印到文本中,每天产生一个新的文本,一般日志和异常日志分开存放。

简易工作日志记录软件(免安装)

很多时候我们工作中需要每天记录自己的工作内容,随着无纸化办公的发展,纸质的记录逐渐在减少,取而代之的是电子版的“记录本”,用C#语言开发一个简易工作日志记录软件,不用安装,并且可以通过日期查询日志记录,方便,实用。

工作日志用什么工具写比较好

EvernoteOneNote或Trello。NotionJira或Confluence。如果你是开发人员,喜欢简洁:可以考虑使用Markdown文件配合Git。选择合适的工具取决于你是个人记录还是团队协作,任务的复杂性以及工作方式。

Debug yourself! 3689

任务记录工具

记录每天需要完成的工作及每天完成的工作,可以对工作任务进行分类及标注

【DevOps】日志管理工具 - 22种 选型(读这一篇就够了)

日志管理工具是为了在生产环境中,有效管理日志数据而提供的灵活、经济、有效的解决方案。现在来盘点下常见的 **22 种** 日志管理工具,调研下它们各自的特点、优缺点、管理架构、效果等,以便可以为业务选择合适的解决方案。

沙师弟专栏 9405

OpenCV C++ 图像处理实战 ——《基于轮廓比对的缺陷检测》

本文使用OpenCV C++ 实现基于轮廓比对的缺陷检测。

Zero___Chen的博客 1151

Cadence PSpice 仿真0:绘制电路图方法图文教程

在使用PSpice进行电路的仿真时,首先需要使用带有PSpice模型的元器件来绘制电路图,本文简单介绍进行电路图绘制是常用的几种需要掌握的方法,以满足PSpice仿真绘制简单电路图所用。

fydar的博客 4710

分享一个Android日志记录的工具类

http://my.oschina.net/hes/blog/158399

猪逻辑公园 143

AI Agent开发第85课-DeepSeek-OCR 安装全指南:从 Transformers 到 vLLM,手把手教你跑通企业级 OCR

本文系统讲解 DeepSeek-OCR 的两种部署方式——基于 Hugging Face Transformers 的标准推理与基于 vLLM 的高性能加速推理。详细说明 CUDA 与 PyTorch 版本匹配、环境验证、依赖安装等关键细节,并提供可直接运行的完整代码示例。无论你是单卡调试还是高并发服务部署,都能在这里找到清晰路径。

打造全国最全的AI Agent开发知识领域的博客 2543

日志记录工具类

[code="java"] import org.apache.log4j.Logger; public class LogUnits { private static Logger logger = null; public static void logException(Exception e){ StackTraceElement[] stacks = (new ...

fan578的专栏 227

100天精通Oracle-实战系列(第33天)RHEL 7 安装 Oracle 12CR2 RAC 数据库

100天精通Oracle-实战系列(第33天)RHEL 7 安装 Oracle 12CR2 RAC 数据库

LuciferLiu_DBA 3452

爬虫:一文掌握网站加密和混淆以及浏览器调试的技巧

面对加密和混淆技术的网站,传统的爬虫方法可能难以奏效。通过结合浏览器调试工具(如Puppeteer、Playwright)、代理工具(如Burp Suite、Fiddler)以及动态和静态分析技巧,可以深入理解网站的运行机制,绕过加密和混淆,实现有效的数据抓取。同时,务必注意合法合规,尊重目标网站的规则和用户的隐私,确保爬虫行为的正当性和可持续性。

数据知道的博客 9894

android 日志工具类,分享一个Android日志记录的工具类

packagecn.mucang.android.weizhanglib.data;importandroid.os.Environment;importandroid.text.format.DateFormat;importandroid.util.Log;importjava.io.BufferedWriter;importjava.io.File;importjava.io....

weixin_39929138的博客 156

基于 STM32 单片机的实验室多参数安全监测系统设计与实现

本系统以 STM32F103C8T6 单片机为核心,集成温湿度监测、烟雾检测、气体泄漏报警、人体移动监测等功能模块,通过 OLED 显示屏实时显示数据,并支持 Wi-Fi 远程传输。系统可对实验室异常环境参数(如高温、烟雾、燃气泄漏)及非法入侵实时报警,保障实验室安全。本文从硬件选型、电路设计到软件实现提供了完整的实验室安全监测系统方案,可根据实际需求调整传感器类型和通信方式,适用于科研、教学等场景的环境安全防护。:可增加继电器模块控制通风设备或切断电源,集成 ZigBee 组网实现多实验室联动监测。

weixin_42300449的博客 1286

封装一个基于NLog+NLog.Mongo的日志记录工具类LogUtil

封装一个基于NLog+NLog.Mongo的日志记录工具类LogUtil,代码比较简单,主要是把MongoTarget的配置、FileTarget的配置集成到类中,同时利用缓存依赖来判断是否需要重新创建Logger类,完整代码如下: /// &lt;summary&gt; /// 日志工具类(基于NLog.Mongo组件) /// Author:左文俊 /// Date:2017/12...

weixin_34361881的博客 299

STM32F103/F407/H743不同GPIO速度配置(HAL库)对应的最高速度

详细介绍了STM32F103/F407/H743不同GPIO速度配置(HAL库)对应的最高速度。

kevin1499的博客 5594

LabVIEW实现TCP通信

在本节中,我们将简要探讨TCP通信的基础知识,并以工业物联网平台TLINK中的云端设备数据发布设计为例,详细阐述在互联网环境下TCP客户端应用程序设计的基本方法。

不脱发的程序猿 1967

(原创)分享自己写的几个工具类(十)文件日志记录工具

实际开发中,需要把一些关键日志记录在手机中 这个时候一般会新建一个.txt文件用来保存这些日志 于是写了这样一个工具类 方便保存和查看相关的日志记录 具体代码如下: /** * Created by lenovo on 2019/10/28. * 日志记录工具 */ public class FileUtil { //是否保存日志 public stati...

Android_xiong_st的博客 508

win10 跳过U8环境检测的IE WebControls.rar

win10 安装u8的时候 提示IE WebControls 不通过,这个工具可以欺骗u8的检查。 跳过U8环境检测的IE WebControls。提示导入失败后,重新检测通过。

封装一个基于NLog+NLog.Mongo的日志记录工具类LogUtil,nloglogutil

封装一个基于NLog+NLog.Mongo的日志记录工具类LogUtil,代码比较简单,主要是把MongoTarget的配置、FileTarget的配置集成到类中,同时利用缓存依赖来判断是否需要重新创建Logger类,完整代码如下: using NLog; using NLog.Config; using NLog.Mongo; using NLog.Targets; using S...

weixin_34192816的博客 205

文档:亲测可用解决vnc灰屏,黑屏,鼠标大黑叉情况

主要解决vnc-viewer灰屏,黑屏,鼠标大黑叉等现象,详细见文档。

精雕软件(JDpaint) 5.5 绿色版

精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版

【自定义工具类进行接口日志记录(非SpringBoot Aop形式的接口)】

摘要 本文提出了一种针对WebService接口调用的自定义日志记录方案。由于WebService接口不通过Spring AOP代理机制触发,传统注解方式无法生效。解决方案采用工具类方式实现,使用独立线程池异步记录请求、响应和异常日志,避免影响主业务执行性能。核心实现包括:1) 使用Supplier函数式接口封装业务逻辑;2) 通过Hutool工具生成唯一ID关联请求响应;3) 线程池隔离日志操作与业务调用。该方案已在"EWZ推送退料单审批结果至WMS系统"等场景成功应用,实现了非侵入式

胡德禄a的博客 419

jre9下载 jdk9

(Java SE Runtime Environment 9.0) 9.0u175 官方最新版 【x86|x64】

上一篇: centos7搭建spark集群环境笔记
下一篇: netty-Netty中pipeline设计模式的一个高仿示例
lhever_
博客等级 码龄14年 213粉丝 130原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值