《设计模式之禅》-动态代理

动态代理是在实现阶段不用关心代理谁。而在运行阶段才指定代理哪一个对象，相对而言，自己写的代理方式就是静态代理

具体代码：InvocationHandler接口是jdk自带的代理接口

//动态代理类 需要实现invoke方法，完成对真实方法的调用
public class GamePlayIH implements InvocationHandler {
    //被代理的实例
    Object object = null;

    public GamePlayIH(Object _object){
        this.object = _object;
    }

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

在动态代理技术里，由于不管用户调用代理对象的什么方法，都是调用开发人员编写的处理器的invoke方法（这相当于invoke方法拦截到了代理对象的方法调用）。并且，开发人员通过invoke方法的参数，还可以在拦截的同时，知道用户调用的是什么方法

//场景类
public class main {
    public static void main(String[] args) {
        IGamePlayer player = new GamePlayer("张三");
        InvocationHandler handler = new GamePlayIH(player);
        System.out.println("开始游戏");
        ClassLoader loader = player.getClass().getClassLoader();
        IGamePlayer proxy = (IGamePlayer)Proxy.newProxyInstance(loader,new Class[]{IGamePlayer.class},handler);
        proxy.login("张三","123");
        proxy.killBoss();
        proxy.upgrade();
    }
}

newProxyInstance方法用来返回一个代理对象，这个方法总共有3个参数，ClassLoader loader用来指明生成代理对象使用哪个类装载器，

Class<?>[] interfaces用来指明生成哪个对象的代理对象，通过接口指定，InvocationHandler h用来指明产生的这个代理对象要做什么事情

也就是说，三个参数分别是代表 用什么生成，生成什么，要做什么

我们还是让代练者替我们打游戏，但是我们既没有创建代理类也没有实现IGamePlayer接口，这就是动态代理

Aop的实现

public class GamePlayIH implements InvocationHandler {

    //被代理的实例
    Object object = null;

    public GamePlayIH(Object _object){
        this.object = _object;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object result = method.invoke(this.object,args);
        //aop处理
        if(method.getName().equalsIgnoreCase("login")){
            System.out.println("有人在登录");
        }
        return  result;
    }
}

以上就是Aop的简单实现

 

动态代理的通用代码

//抽象主题
public interface Subject {
    public void doSomething (String str);
}

//真实主题
public class RealSubject implements Subject{
    @Override
    public void doSomething(String str) {
        System.out.println("doSometing -->"+str);
    }
}

//动态代理的Handler类
public class MyInvocationHandler implements InvocationHandler {
    //被代理对象
    private Object target = null;
    //通过构造函数传入被代理对象
    public MyInvocationHandler (Object _target){
        this.target = _target;
    }

    //代理方法
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //执行被代理方法
        return method.invoke(this.target,args);
    }
}

//动态代理类
public class DynamicProxy<T> {
    public static <T> T newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler handler){
//AOP的实现
        if (true){
            new BeforeAdvice().exec();
        }
        return (T)Proxy.newProxyInstance(loader,interfaces,handler);
    }
}

//通知接口
public interface IAdvice {
    public void exec();
}

//通知接口实现
public class BeforeAdvice implements IAdvice{
    @Override
    public void exec() {
        System.out.println("Aop前置操作");
    }
}

public class main {
    public static void main(String[] args) {
        Subject subject = new RealSubject();
        InvocationHandler handler = new MyInvocationHandler(subject);
        ClassLoader loader = subject.getClass().getClassLoader();
        Subject proxy = DynamicProxy.newProxyInstance(loader,subject.getClass().getInterfaces(),handler);
        proxy.doSomething("finsh");
    }
}

动态代理 基于 InvocationHandler 接口中的 invoke方法的实现和 Proxy.newProxyInstance(loader,interfaces,handler);

动态代理 和静态代理虽然都要实现代理类，但是动态代理主要是在不改变我们已有代码结构的情况下增强或者控制对象的行为