nosum-support/dynamic-methods-boot-starter/src/main/java/cn/nosum/support/proxy/ReflectiveDynamicClientCreator.java

package cn.nosum.support.proxy;

import cn.nosum.support.config.DynamicMethodsEndpointRegistrar;
import cn.nosum.support.endpoint.MethodEndpoint;
import cn.nosum.support.core.utils.CheckUtil;
import org.springframework.util.ReflectionUtils;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Map;

/**
 * Reflective dynamic method client instance creator。
 *
 * @author Young
 */
public class ReflectiveDynamicClientCreator extends DynamicClientCreator {


    private final InvocationHandlerFactory factory;

    public ReflectiveDynamicClientCreator(InvocationHandlerFactory factory) {
        this.factory = factory;
    }

    @Override
    public <T> T newInstance(Target<T> target) {
        InvocationHandler handler = factory.create(target);
        return (T) Proxy.newProxyInstance(target.type().getClassLoader(), new Class<?>[] {target.type()}, handler);
    }

    static class DynamicMethodsInvocationHandler implements InvocationHandler {

        private final Target target;
        private Map<String, MethodEndpoint> nameToEndpoint;

        DynamicMethodsInvocationHandler(Target target) {
            this.target = target;
        }

        @Override
        public Object invoke(Object proxy, Method method, Object[] args) {
            if (null == nameToEndpoint){
                nameToEndpoint = DynamicMethodsEndpointRegistrar.getEndpoint(target.refName());
            }

            if ("equals".equals(method.getName())) {
                try {
                    Object otherHandler = args.length > 0 && args[0] != null ? Proxy.getInvocationHandler(args[0]) : null;
                    return equals(otherHandler);
                } catch (IllegalArgumentException e) {
                    return false;
                }
            } else if ("hashCode".equals(method.getName())) {
                return hashCode();
            } else if ("toString".equals(method.getName())) {
                return toString();
            }

            if (null != args){
                String arg0 = String.valueOf(args[0]);
                MethodEndpoint methodEndpoint = CheckUtil.checkNotNull(nameToEndpoint.get(arg0),"method is not found!!!");
                Object[] newArgs = new Object[args.length-1];
                System.arraycopy(args, 1, newArgs, 0, args.length - 1);
                if (methodEndpoint.isMatcher(newArgs)){
                   return ReflectionUtils.invokeMethod(method,methodEndpoint.getBean(),newArgs);
                }
            }
            return null;
        }

        @Override
        public boolean equals(Object obj) {
            if (obj instanceof DynamicMethodsInvocationHandler) {
                DynamicMethodsInvocationHandler other = (DynamicMethodsInvocationHandler) obj;
                return target.equals(other.target);
            }
            return false;
        }

        @Override
        public int hashCode() {
            return target.hashCode();
        }

        @Override
        public String toString() {
            return target.toString();
        }
    }
}