• Home
• com.github.rockylomo
• rxlib
• 2.20.8
• source code
• Reflects.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

org.rx.core.Reflects Maven / Gradle / Ivy

package org.rx.core;

import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONObject;
import lombok.NonNull;
import lombok.RequiredArgsConstructor;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.ClassUtils;
import org.apache.commons.lang3.reflect.ConstructorUtils;
import org.apache.commons.lang3.reflect.FieldUtils;
import org.apache.commons.lang3.reflect.MethodUtils;
import org.apache.commons.lang3.reflect.TypeUtils;
import org.rx.annotation.ErrorCode;
import org.rx.bean.*;
import org.rx.core.cache.MemoryCache;
import org.rx.exception.ApplicationException;
import org.rx.exception.InvalidException;
import org.rx.util.Lazy;
import org.rx.util.function.BiFunc;
import org.rx.util.function.TripleFunc;
import org.springframework.core.io.InputStreamSource;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;

import java.io.InputStream;
import java.io.Serializable;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.SerializedLambda;
import java.lang.reflect.*;
import java.math.BigDecimal;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.util.*;
import java.util.concurrent.CopyOnWriteArrayList;

import static org.rx.core.Constants.NON_RAW_TYPES;
import static org.rx.core.Constants.NON_UNCHECKED;
import static org.rx.core.Extends.*;
import static org.rx.core.Sys.*;

@SuppressWarnings(NON_UNCHECKED)
@Slf4j
public class Reflects extends ClassUtils {
    //region NestedTypes
    @RequiredArgsConstructor
    public static class PropertyNode implements Serializable {
        private static final long serialVersionUID = 3680733077204898075L;
        public final String propertyName;
        public final Method setter;
        public final Method getter;
    }

    @RequiredArgsConstructor
    static class ConvertBean {
        final Class baseFromType;
        final Class toType;
        final TripleFunc, TT> converter;
    }

    public interface ClassTracer {
        Class[] getClassTrace();

        Class getClassTrace(int depth);
    }

    static class SecurityManagerEx extends SecurityManager implements ClassTracer {
        static final SecurityManagerEx INSTANCE = new SecurityManagerEx();

        public Class[] getClassTrace() {
            return getClassContext();
        }

        public Class getClassTrace(int depth) {
            return getClassContext()[1 + depth];
        }
    }
    //endregion

    public static final Linq COLLECTION_WRITE_METHOD_NAMES = Linq.from("add", "remove", "addAll", "removeAll", "removeIf", "retainAll", "clear"),
            List_WRITE_METHOD_NAMES = COLLECTION_WRITE_METHOD_NAMES.union(Arrays.toList("replaceAll", "set"));
    public static final Set OBJECT_METHODS = Collections.unmodifiableSet(new HashSet<>(Arrays.toList(Object.class.getMethods())));
    public static final ClassTracer CLASS_TRACER = new SecurityManagerEx();
    static final String M_0 = "close", CHANGE_TYPE_METHOD = "valueOf";
    static final String GET_PROPERTY = "get", GET_BOOL_PROPERTY = "is", SET_PROPERTY = "set";
    static final int LOOKUP_FLAGS = MethodHandles.Lookup.PUBLIC | MethodHandles.Lookup.PACKAGE | MethodHandles.Lookup.PROTECTED | MethodHandles.Lookup.PRIVATE;
    //must lazy before thread pool init.
    static final Lazy, Map>>> methodCache = new Lazy<>(MemoryCache::new);
    static final Lazy, Map>> fieldCache = new Lazy<>(MemoryCache::new);
    static final Constructor lookupConstructor;
    static final List> convertBeans = new CopyOnWriteArrayList<>();

    static {
        try {
            lookupConstructor = MethodHandles.Lookup.class.getDeclaredConstructor(Class.class, int.class);
            setAccess(lookupConstructor);
        } catch (NoSuchMethodException e) {
            throw InvalidException.sneaky(e);
        }

        registerConvert(Number.class, Decimal.class, (sv, tt) -> Decimal.valueOf(sv.doubleValue()));
        registerConvert(NEnum.class, Integer.class, (sv, tt) -> sv.getValue());
        registerConvert(Long.class, Date.class, (sv, tt) -> new Date(sv));
        registerConvert(Long.class, DateTime.class, (sv, tt) -> new DateTime(sv, TimeZone.getDefault()));
        registerConvert(Date.class, Long.class, (sv, tt) -> sv.getTime());
        registerConvert(Date.class, DateTime.class, (sv, tt) -> DateTime.of(sv));
        registerConvert(String.class, BigDecimal.class, (sv, tt) -> new BigDecimal(sv));
        registerConvert(String.class, UUID.class, (sv, tt) -> UUID.fromString(sv));
    }

    //region class
//    public static Class getCallerClass() {
//        try {
//            Class type = Class.forName("sun.reflect.Reflection");
//            return invokeMethod(type, "getCallerClass");
//        } catch (ClassNotFoundException e) {
//            return CLASS_TRACER.getClassTrace(0);
//        }
//    }

//    public static StackTraceElement[] getCallerStack() {
//        //Throwable.class.getDeclaredMethod("getStackTraceElement", int.class) & Reflection.getCallerClass(2 + depth) java 11 not exist
//        return new Throwable().getStackTrace();
//    }

    public static String getStackTrace(Thread t) {
        StringBuilder buf = new StringBuilder();
        for (StackTraceElement traceElement : t.getStackTrace()) {
            buf.append("\tat ").appendLine(traceElement);
        }
        return buf.toString();
    }

    public static InputStream getResource(String namePattern) {
        InputStream in = getClassLoader().getResourceAsStream(namePattern);
        if (in != null) {
            return in;
        }
        in = getResources(namePattern).firstOrDefault();
        if (in == null) {
            throw new InvalidException("Resource {} not found", namePattern);
        }
        return in;
    }

    @SneakyThrows
    public static Linq getResources(String namePattern) {
        PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
        return Linq.from(resolver.getResources("classpath*:" + namePattern)).select(InputStreamSource::getInputStream);
    }

    //ClassLoader.getSystemClassLoader()
    public static ClassLoader getClassLoader() {
        ClassLoader loader = Thread.currentThread().getContextClassLoader();
        return loader != null ? loader : Reflects.class.getClassLoader();
    }

    public static  Class loadClass(String className, boolean initialize) {
        return loadClass(className, initialize, true);
    }

    //ClassPath.from(classloader).getTopLevelClasses(packageDirName)
    public static  Class loadClass(String className, boolean initialize, boolean throwOnEmpty) {
        try {
            return (Class) Class.forName(className, initialize, getClassLoader());
        } catch (ClassNotFoundException e) {
            if (!throwOnEmpty) {
                return null;
            }
            throw InvalidException.sneaky(e);
        }
    }

    public static boolean isInstance(Object val, Type type) {
        return TypeUtils.isInstance(val, type);
    }
    //endregion

    public static  String resolveProperty(BiFunc func) {
        SerializedLambda lambda = getLambda(func);
        return propertyName(lambda.getImplMethodName());
    }

    public static  Tuple resolveImpl(BiFunc func) {
        SerializedLambda lambda = getLambda(func);
        String declaredClass = lambda.getImplClass().replace("/", ".");
        return Tuple.of(declaredClass, propertyName(lambda.getImplMethodName()));
    }

    @SneakyThrows
    public static  Field resolve(BiFunc func) {
        SerializedLambda lambda = getLambda(func);
        String declaredClass = lambda.getImplClass().replace("/", ".");
        return getFieldMap(Class.forName(declaredClass)).get(propertyName(lambda.getImplMethodName()));
    }

    static  SerializedLambda getLambda(BiFunc func) {
        SerializedLambda lambda = invokeMethod(func, "writeReplace");
        String implMethodName = lambda.getImplMethodName();
        if (implMethodName.startsWith("lambda$")) {
            throw new IllegalArgumentException("BiFunc can not be LAMBDA EXPR, but only METHOD REFERENCE");
        }
        if (!implMethodName.startsWith(GET_PROPERTY) && !implMethodName.startsWith(GET_BOOL_PROPERTY)) {
            throw new IllegalArgumentException(implMethodName + " is not a GETTER");
        }
        return lambda;
    }

    static final byte APPEND_TO_COLLECTION = 1;
    static final byte WRITE_QUIETLY = 1 << 1;

    /**
     * @param instance
     * @param fieldPath
     * @param value
     * @param flags     1       append to Collection
     *                  1 << 1  write quietly
     */
    public static void writeFieldByPath(Object instance, String fieldPath, Object value, byte flags) {
        final String c = ".";
        int wPathOffset = 0, i;
        String fieldName;
        Object cur = instance;
        while ((i = fieldPath.indexOf(c, wPathOffset)) != -1) {
            fieldName = fieldPath.substring(wPathOffset, i);
            try {
                cur = readField(cur, fieldName);
            } catch (Throwable e) {
                throw new InvalidException("Read field {} fail", fieldPath.substring(0, wPathOffset), e);
            }
            wPathOffset = i + c.length();
        }
        if (cur == null) {
            throw new InvalidException("Read field {} empty", fieldPath.substring(0, wPathOffset));
        }
        fieldName = fieldPath.substring(wPathOffset);
        try {
            Field field = getFieldMap(cur.getClass()).get(fieldName);
            if (field == null) {
                throw new NoSuchFieldException(fieldName);
            }

            if (isTypedJson(value)) {
                value = fromTypedJson(value);
            }
            if (Collection.class.isAssignableFrom(field.getType())) {
                Collection