public class ObjectFactory {

    private MyInterceptorChain interceptorChain;


    public ObjectFactory() {
        interceptorChain = new MyInterceptorChain();
    }

    public Business newBusiness() {
        Business business = new BusinessImpl();
        return (Business)interceptorChain.pluginAll(business);
    }


    public void addInterceptor(MyInterceptor interceptor) {
        interceptorChain.addInterceptor(interceptor);
    }
}

/**
 * 所有生成新的代理对象的入口，用来拦截该对象的指定方法
 * 在创建对象时调用
 */
public class MyInterceptorChain {
    private final List interceptors = new ArrayList<>();

    /**
     * 对原始目标对象 用 所有过滤器 的 代理 包装 成代理对象
     */
    public Object pluginAll(Object target) {
        for (MyInterceptor interceptor : interceptors) {
            target = interceptor.plugin(target);
        }
        return target;
    }

    public void addInterceptor(MyInterceptor myInterceptor) {
        interceptors.add(myInterceptor);
    }

}

public interface MyInterceptor {


    Object intercept(MyInvocation myInvocation) throws Throwable;

    /* 返回代理对象*/
    Object plugin(Object object);
}

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface MyIntercepts {

    // Signature是自己定义的注解
    Signature[] value();
}

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({})
public @interface Signature {
  Class<?> type();

  String method();

  Class<?>[] args();
}

/**
 * 目标对象一定要有接口
 */
public interface Business {
    String business1(String arg);

    void business2();
}

/**
 * jdk自带的动态代理，如果想要被拦截，这个类必须有接口
 */
public class BusinessImpl implements Business {

    @Override
    public String business1(String arg) {
        System.out.println("正在做business1, 参数：" + arg);
        return arg;
    }


    @Override
    public void business2() {
        System.out.println("正在做business2");
    }

}

/**
 * 拦截的类一定要写接口Business.class
 */
@MyIntercepts({@Signature(type = Business.class, method = "business1", args={String.class})})
public class Business1Interceptor implements MyInterceptor{

    @Override
    public Object intercept(MyInvocation myInvocation) throws Throwable {
        Method method = myInvocation.getMethod();
        System.out.println("拦截的business1方法：" + method.getName());

        return myInvocation.proceed();
    }

    @Override
    public Object plugin(Object target) {
        // 如果目标对象 是要拦截的Business类，就返回代理对象
        if (target instanceof Business) {
            return WrapUtil.warp(target, this);
        }
        return target;
    }
}

@MyIntercepts({@Signature(type = Business.class, method = "business2", args={})})
public class BusinessInterceptor implements MyInterceptor{


    @Override
    public Object intercept(MyInvocation myInvocation) throws Throwable {
        Method method = myInvocation.getMethod();
        System.out.println("拦截的business2方法：" + method.getName());

        return myInvocation.proceed();
    }

    @Override
    public Object plugin(Object target) {
        // 如果目标对象 是要拦截的Business类，就返回代理对象
        if (target instanceof Business) {
            return WrapUtil.warp(target, this);
        }
        return target;
    }
}

public class WrapUtil implements InvocationHandler {

    /* 目标对象 */
    private Object target;
    /* 拦截器*/
    private MyInterceptor interceptor;
    /* 要拦截的类 以及 对应的 方法*/
    private Map, Set> signatureMap;


    public WrapUtil(Object target, MyInterceptor interceptor,

 Map, Set> signatureMap) {
        this.target = target;
        this.interceptor = interceptor;
        this.signatureMap = signatureMap;

    }

    /**
     *
     * @param target 代理前的对象
     * @param interceptor 拦截器
     * @return 代理后的对象
     */
    public static Object warp(Object target, MyInterceptor interceptor) {
        // 获取interceptor类要 拦截的类和方法
        Map, Set> signatureMap = getSignatureMap(interceptor);

        Class<?> type = target.getClass();

        // 要拦截的对象及其父类 在 signatureMap 中，就统计
        Class<?>[] interfaces = getAllInterfaces(type, signatureMap);

        if (interfaces.length > 0) {
            return Proxy.newProxyInstance(type.getClassLoader(), interfaces,

 new WrapUtil(target, interceptor, signatureMap));
        }
        return target;


    }

    /**
     * 获取type类及其父类 所有 在signatureMap 中的类
     */
    private static Class<?>[] getAllInterfaces(Class<?> type, Map, Set> signatureMap) {

        Set> interfaces = new HashSet<>();
        while (type != null) {
            for (Class<?> c : type.getInterfaces()) {
                if (signatureMap.containsKey(c)) {
                    interfaces.add(c);
                }
            }

            type = type.getSuperclass();
        }
        return interfaces.toArray(new Class<?>[0]);
    }

    private static Map, Set> getSignatureMap(MyInterceptor interceptor) {
        MyIntercepts interceptsAnnotation =

interceptor.getClass().getAnnotation(MyIntercepts.class);
        if (interceptsAnnotation == null) {
            throw new RuntimeException("拦截的方法必须加@MyIntercepts注解");
        }

        Signature[] sigs = interceptsAnnotation.value();
        HashMap, Set> signatureMap = new HashMap<>();
        for (Signature sig : sigs) {
            Set methods = signatureMap.computeIfAbsent(

sig.type(), k -> new HashSet<>());
            Method method = null;
            try {
                method = sig.type().getMethod(sig.method(), sig.args());
                methods.add(method);
            } catch (NoSuchMethodException e) {
                throw new RuntimeException("Could not find method on " + sig.type() + " named " + sig.method() + ". Cause: " + e, e);
            }
        }
        return signatureMap;
    }

    /**
     * 调用代理后的对象的方法，都会走到这个方法
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        // 如果method所在类和method在signatureMap中，就执行拦截器的拦截方法
        Set methods = signatureMap.get(method.getDeclaringClass());
        if (methods != null && methods.contains(method)) {
            // 将参数封装到 MyInvocation中，传给拦截器 处理
            return interceptor.intercept(new MyInvocation(target, method, args));
        }
        // 要调用target原始对象，而不是proxy对象
        return method.invoke(target, args);
    }
}

public class MyInvocation {

    private Object target;
    private Method method;
    private Object[] args;


    public MyInvocation(Object target, Method method, Object[] args) {
        this.target = target;
        this.method = method;
        this.args = args;
    }

    public Object getTarget() {
        return target;
    }

    public void setTarget(Object target) {
        this.target = target;
    }

    public Method getMethod() {
        return method;
    }

    public void setMethod(Method method) {
        this.method = method;
    }

    public Object[] getArgs() {
        return args;
    }

    public void setArgs(Object[] args) {
        this.args = args;
    }

    /**
     * 调用目标方法
     */
    public Object proceed() throws InvocationTargetException, IllegalAccessException {
        return method.invoke(target, args);
    }
}

/**
 * 插件机制。
 * 对象的创建都在 ObjectFactory，相当于一个简单工厂
 *  - 在对象创建时，返回拦截器动态代理过的对象
 *  - 当执行这些代理对象的方法时，就会执行拦截器中的方法
 */
public class ClientTest {

    @Test
    public void test() {
        Business business = new BusinessImpl();
        Business1Interceptor businessInterceptor = new Business1Interceptor();

        Business warpBusiness = (Business) WrapUtil.warp(business, businessInterceptor);
        String name = warpBusiness.business1("name");


    }


    /**
     * 添加插件的关键：
     *   - 自定义拦截器，指定拦截类和方法
     *   - 在ObjectFactory中添加自定义的拦截器
     *   - 创建对象时要通过ObjectFactory中newXXX创建，会返回被代理的对象
     */
    @Test
    public void testObjectFactory() {
        ObjectFactory objectFactory = new ObjectFactory();
        objectFactory.addInterceptor(new Business1Interceptor());
        objectFactory.addInterceptor(new BusinessInterceptor());

        // 经过过滤器包装的Business对象
        Business business = objectFactory.newBusiness();
        business.business1("name");
        business.business2();

    }


}