Java设计模式之代理模式☞再谈JDK的动态代理

前言

为什么要再谈，因为动态代理是aop编程的核心。后面分析spring aop的源代码的最重要的理论基础。

再谈动态代理

首先动态代理需要哪些角色呢？

1.抽象角色。这个抽象角色必须为接口。

2.具体角色。这个具体角色必须实现抽象接口。

3.IAdvice接口和BeforeAdviceImple实现类。

4.InvocationHandler的实现类。这个类为动态代理的Handler类。

5.产生代理的接口，抽象类，工厂类。

6.场景类Client。

1.我们先新增一个抽象角色ISubject接口。这个接口定义一个方法handle。代码如下所示：

package com.example.pattern.proxy.dynamic.second;

public interface ISubject {

    public void handle();
}

第5行，定义接口handle。

2.定义一个具体角色RealSubject。这个角色实现ISubject接口。代码如下所示：

package com.example.pattern.proxy.dynamic.second;

public class RealSubject implements ISubject {
    @Override
    public void handle() {
        System.out.println("-----handle-----");
    }
}

第6行，处理handle业务逻辑。

3.新增一个通知事件的接口和实现类，代码如下所示。

package com.example.pattern.proxy.dynamic.second;

public interface IAdvice {

    public void execute();
}

package com.example.pattern.proxy.dynamic.second;

public class BeforeAdviceImpl implements IAdvice {
    @Override
    public void execute() {
        System.out.println("执行前置通知");
    }
}

 第6行，定义execute业务前置逻辑。

4.再来新增一个InvocationHandler的默认处理器。

package com.example.pattern.proxy.dynamic.second;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class DefaultInvocationHandler implements InvocationHandler {

    private Object instance = null;

    public DefaultInvocationHandler(Object instance) {
        this.instance = instance;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        return method.invoke(this.instance, args);
    }
}

 第8行，定义被代理对象的实例。

5.产生代理的接口，抽象类，实现类。

package com.example.pattern.proxy.dynamic.second;

import java.lang.reflect.InvocationHandler;

public interface IDynamicProxy<T> {

    public <T> T newProxyInstace(Class<T> clazz, InvocationHandler h);

}

package com.example.pattern.proxy.dynamic.second;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;

public abstract class AbstractDynamixProxy<T> implements IDynamicProxy<T> {

    public abstract void before() ;

    @Override
    public T newProxyInstace(Class clazz, InvocationHandler h) {

        this.before();

        ClassLoader classLoader = clazz.getClassLoader();
        Class[] interfaces = clazz.getInterfaces();

        return  (T)Proxy.newProxyInstance(classLoader, interfaces, h);
    }
}

package com.example.pattern.proxy.dynamic.second;

public class SubjectDynamicProxyImpl<ISubject> extends AbstractDynamixProxy<ISubject>{

    @Override
    public void before() {

        IAdvice advice = new BeforeAdviceImpl();
        advice.execute();

    }
}

①有接口，有抽象类，有具体方法？我为什么要这么设计呢？为什么不是直接写在场景类中呢？那如果有10个场景需要，是不是在10出都要写相同或者相似的代码呢？如果一旦有改动，那么，改动的工作量不说，容易产生潜伏性bug。 接口是声明主要用途，抽象类是用来提取公共代码。具体类是为了构建个性化代码，比如before方法。 就是一个典型的钩子函数。说了这么多，这难道不是模板模式的应用吗？

②IDynamicProxy<T>这是一个泛型接口。T可以是一个接口或者普通类，具体是什么类型，由场景来类决定，这不就实现了代码非常灵活的复用吗？同时不也是提高了可读性吗？

6.增加场景类Client。

public class Client {

    public static void main(String[] args) {
        ISubject subject = new RealSubject();

        InvocationHandler invocationHandler = new DefaultInvocationHandler(subject);

        IDynamicProxy<ISubject> dynamicProxy = new SubjectDynamicProxyImpl();
        ISubject proxyInstance = dynamicProxy.newProxyInstace(subject.getClass(), invocationHandler);

        proxyInstance.handle();
    }
}

执行的结果如下图所示：

执行前置通知
-----handle-----

我们为什么要使用IAdvice呢。这已经引入了aop中的一些术语，在什么地方执行什么行为，是不是可以理解 在连接点执行什么通知呢？这已经是一个简单的面向切面过程的示例，Advice是什么呢？也正是我们要去切入的类。