SpringBoot常用工具类

JSON序列化工具

主要使用ObjectMapper类，将任何对象类型转化成字符类型。

import com.fasterxml.jackson.annotation.JsonInclude.Include;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.JsonParser.Feature;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.MapperFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateTimeDeserializer;
import java.io.IOException;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

class JSONUtils {
    private static ObjectMapper objectMapper = new ObjectMapper();

    //序列化成json字符串
    public static <T> String obj2String(T obj) {
        try {
            return objectMapper.writeValueAsString(obj);
        } catch (JsonProcessingException var2) {
            System.out.println(String.format("Parse Object to String error : %s", var2.getMessage()));
            return null;
        }
    }

    //序列化成json，打印时使用
    public static <T> String obj2StringPretty(T obj) throws Exception {
        try {
            return objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(obj);
        } catch (JsonProcessingException e) {
            throw new Exception(String.format("Parse Object to String error : %s", e.getMessage()));
        }
    }

    //json字符串反序列化成对象
    public static <T> T jsonToObject(String str, Class<T> clazz) {
        if (!isEmpty(str) && clazz != null) {
            try {
                return objectMapper.readValue(str, clazz);
            } catch (Exception e) {
                System.out.println(String.format("Parse Object to String error : %s", e.getMessage()));
                return null;
            }
        } else {
            return null;
        }
    }

    //json字符串反序列化成复合对象
    public static <T> T string2Obj(String str, Class<?> collectionClazz, Class<?>... elementClazzes) {
        if (!isEmpty(str) && collectionClazz != null && elementClazzes != null) {
            JavaType javaType = objectMapper.getTypeFactory().constructParametricType(collectionClazz, elementClazzes);
            try {
                return objectMapper.readValue(str, javaType);
            } catch (IOException e) {
                System.out.println(String.format("Parse Object to String error : %s", e.getMessage()));
                return null;
            }
        } else {
            return null;
        }
    }

    private static boolean isEmpty(CharSequence cs) {
        return cs == null || cs.length() == 0;
    }

    static {
        objectMapper.setSerializationInclusion(Include.ALWAYS);
        objectMapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
        objectMapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
        objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
        objectMapper.configure(Feature.ALLOW_SINGLE_QUOTES, true);
        objectMapper.configure(Feature.ALLOW_UNQUOTED_FIELD_NAMES, true);
        objectMapper.configure(com.fasterxml.jackson.core.JsonGenerator.Feature.IGNORE_UNKNOWN, true);
        objectMapper.configure(com.fasterxml.jackson.core.JsonGenerator.Feature.WRITE_BIGDECIMAL_AS_PLAIN, true);
        objectMapper.configure(Feature.ALLOW_MISSING_VALUES, true);
        objectMapper.configure(MapperFeature.ACCEPT_CASE_INSENSITIVE_PROPERTIES, true);
        JavaTimeModule module = new JavaTimeModule();
        LocalDateTimeDeserializer deserializer = new LocalDateTimeDeserializer(DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss.SSS a"));
        module.addDeserializer(LocalDateTime.class, deserializer);
        objectMapper.registerModule(module);
    }
}

maven依赖如下

    <dependencies>
        <dependency>
            <groupId>com.fasterxml.jackson.coregroupId>
            <artifactId>jackson-databindartifactId>
        dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.jaxrsgroupId>
            <artifactId>jackson-jaxrs-json-providerartifactId>
        dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.datatypegroupId>
            <artifactId>jackson-datatype-jsr310artifactId>
        dependency>
    dependencies>

Spring注入工具

主要使用ApplicationContext类，实现ApplicationContextAware接口，用于在非Spring类中注入Spring对象。

import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;

public class SpringUtils implements ApplicationContextAware {
    private static ApplicationContext applicationContext;

    public void setApplicationContext(ApplicationContext applicationContext) {
        SpringBeanUtils.applicationContext = applicationContext;
    }

    public static ApplicationContext getApplicationContext() {
        return applicationContext;
    }

	//通过名称获取Bean
    public static Object getBean(String name) {
        return applicationContext != null ? applicationContext.getBean(name) : null;
    }

	//通过类获取Bean
    public static <T> T getBean(Class<T> requiredType) {
        return applicationContext != null ? applicationContext.getBean(requiredType) : null;
    }

	//通过名称和类获取Bean
    public static <T> T getBean(String name, Class<T> requiredType) {
        return applicationContext != null ? applicationContext.getBean(name, requiredType) : null;
    }
}

maven依赖如下

    <dependencies>
        <dependency>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-contextartifactId>
        dependency>
    dependencies>

反射工具

使用JDK自带类，仅仅做了封装

import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.List;

public class InvokeUtil {
    public InvokeUtil() {
    }

    public static Class<?> getClass(String className) {
        try {
            return Class.forName(className);
        } catch (ClassNotFoundException var2) {
            throw new RuntimeException("类不存在");
        }
    }

    public static Object createInstance(Class clazz, Object... params) {
        Class<?>[] paramsType = getParamsType(params);
        Object value = null;
        try {
            if (clazz != null) {
                Constructor construtor = clazz.getConstructor(paramsType);
                value = construtor.newInstance(params);
            }
            return value;
        } catch (NoSuchMethodException e) {
            throw new RuntimeException("构造函数不存在");
        } catch (InstantiationException e) {
            throw new RuntimeException("实例化失败");
        } catch (IllegalAccessException e) {
            throw new RuntimeException("非法访问");
        } catch (IllegalArgumentException e) {
            throw new RuntimeException("参数错误");
        } catch (InvocationTargetException e) {
            throw new RuntimeException("调用目标错误");
        }
    }

    public static Object createInstance(String className, Object... params) {
        Class<?> clazz = getClass(className);
        return createInstance(clazz, params);
    }

    public static void setPropertyValue(Object entity, String propertyName, Object propertyValue) {
        try {
            if (entity != null && propertyName != null) {
                Field field = entity.getClass().getField(propertyName);
                field.set(entity, propertyValue);
            }
        } catch (NoSuchFieldException e) {
            throw new RuntimeException("属性不存在");
        } catch (IllegalArgumentException e) {
            throw new RuntimeException("参数错误");
        } catch (IllegalAccessException e) {
            throw new RuntimeException("非法访问");
        }
    }

    public static Object getStaticPropertyValue(String className, String propertyName) {
        Class<?> clazz = getClass(className);
        Object value = null;
        try {
            if (propertyName != null) {
                Field field = clazz.getField(propertyName);
                value = field.get((Object)null);
            }
            return value;
        } catch (NoSuchFieldException e) {
            throw new RuntimeException("属性不存在");
        } catch (IllegalArgumentException e) {
            throw new RuntimeException("参数错误");
        } catch (IllegalAccessException e) {
            throw new RuntimeException("非法访问");
        }
    }

    public static Object getPropertyValue(Object entity, String propertyName) {
        Object value = null;
        try {
            if (entity != null && propertyName != null) {
                Field field = entity.getClass().getField(propertyName);
                value = field.get(entity);
            }
            return value;
        } catch (NoSuchFieldException e) {
            throw new RuntimeException("属性不存在");
        } catch (IllegalArgumentException e) {
            throw new RuntimeException("参数错误");
        } catch (IllegalAccessException e) {
            throw new RuntimeException("非法访问");
        }
    }

    public static Object invokeStaticMethod(Class clazz, String methodName, Object... params) {
        Class<?>[] paramsType = getParamsType(params);
        Object value = null;
        try {
            if (clazz != null && methodName != null) {
                Method method = clazz.getMethod(methodName, paramsType);
                value = method.invoke((Object)null, params);
            }
            return value;
        } catch (NoSuchMethodException e) {
            throw new RuntimeException("方法不存在");
        } catch (IllegalAccessException e) {
            throw new RuntimeException("非法访问");
        } catch (IllegalArgumentException e) {
            throw new RuntimeException("参数错误");
        } catch (InvocationTargetException e) {
            throw new RuntimeException("调用目标错误");
        }
    }

    public static Object invokeStaticGenericMethod(Class clazz, String methodName, Object... params) {
        Class<?>[] objectClass = getObjectClass(params);
        Object value = null;
        try {
            if (clazz != null && methodName != null) {
                Method method = clazz.getMethod(methodName, objectClass);
                value = method.invoke((Object)null, params);
            }
            return value;
        } catch (NoSuchMethodException var6) {
            throw new RuntimeException("方法不存在");
        } catch (IllegalAccessException var7) {
            throw new RuntimeException("非法访问");
        } catch (IllegalArgumentException var8) {
            throw new RuntimeException("参数错误");
        } catch (InvocationTargetException var9) {
            throw new RuntimeException("调用目标错误");
        }
    }

    public static void invokeStaticMethodWithoutResult(Class clazz, String methodName, Object... params) {
        invokeStaticMethod(clazz, methodName, params);
    }

    public static void invokeStaticGenericMethodWithoutResult(Class clazz, String methodName, Object... params) {
        invokeStaticGenericMethod(clazz, methodName, params);
    }

    public static Object invokeMethod(Object entity, String methodName, Object... params) {
        Class<?>[] paramsType = getParamsType(params);
        Object value = null;
        try {
            if (entity != null && methodName != null) {
                Method method = entity.getClass().getMethod(methodName, paramsType);
                value = method.invoke(entity, params);
            }
            return value;
        } catch (NoSuchMethodException e) {
            throw new RuntimeException("方法不存在");
        } catch (IllegalAccessException e) {
            throw new RuntimeException("非法访问");
        } catch (IllegalArgumentException e) {
            throw new RuntimeException("参数错误");
        } catch (InvocationTargetException e) {
            throw new RuntimeException("调用目标错误");
        }
    }

    public static Object invokeGenericMethod(Object entity, String methodName, Object... params) {
        Class<?>[] objectClass = getObjectClass(params);
        Object value = null;
        try {
            if (entity != null && methodName != null) {
                Method method = entity.getClass().getMethod(methodName, objectClass);
                value = method.invoke(entity, params);
            }
            return value;
        } catch (NoSuchMethodException e) {
            throw new RuntimeException("方法不存在");
        } catch (IllegalAccessException e) {
            throw new RuntimeException("非法访问");
        } catch (IllegalArgumentException e) {
            throw new RuntimeException("参数错误");
        } catch (InvocationTargetException e) {
            throw new RuntimeException("调用目标错误");
        }
    }

    public static void invokeMethodWithoutResult(Object entity, String methodName, Object... params) {
        invokeMethod(entity, methodName, params);
    }

    public static void invokeGenericMethodWithoutResult(Object entity, String methodName, Object... params) {
        invokeGenericMethod(entity, methodName, params);
    }

    public static List<Annotation> getClassAnnotations(Class clazz) {
        return clazz != null ? Arrays.asList(clazz.getAnnotations()) : null;
    }

    public static List<Annotation> getMethodAnnotations(Class clazz, String methodName, Object... params) {
        Class<?>[] paramsType = getParamsType(params);
        List result = null;
        try {
            if (clazz != null && methodName != null) {
                Method method = clazz.getMethod(methodName, paramsType);
                result = Arrays.asList(method.getAnnotations());
            }
            return result;
        } catch (NoSuchMethodException e) {
            throw new RuntimeException("方法不存在");
        }
    }

    public static Annotation getClassAnnotation(Class clazz, Class annotationClass) {
        return clazz != null && annotationClass != null ? clazz.getAnnotation(annotationClass) : null;
    }

    public static Annotation getMethodAnnotation(Class clazz, Class annotationClass, String methodName, Object... params) {
        Class<?>[] paramsType = getParamsType(params);
        Annotation annotation = null;
        try {
            if (clazz != null && annotationClass != null && methodName != null) {
                Method method = clazz.getMethod(methodName, paramsType);
                annotation = method.getAnnotation(annotationClass);
            }
            return annotation;
        } catch (NoSuchMethodException e) {
            throw new RuntimeException("方法不存在");
        }
    }

    private static Class<?>[] getParamsType(Object... params) {
        Class[] paramsType;
        if (params != null && params.length != 0) {
            paramsType = new Class[params.length];
            for(int i = 0; i < params.length; ++i) {
                paramsType[i] = params[i].getClass();
            }
        } else {
            paramsType = null;
        }

        return paramsType;
    }

    private static Class<?>[] getObjectClass(Object... params) {
        Class[] objectClass;
        if (params != null && params.length != 0) {
            objectClass = new Class[params.length];

            for(int i = 0; i < params.length; ++i) {
                objectClass[i] = Object.class;
            }
        } else {
            objectClass = null;
        }

        return objectClass;
    }
}