动态代理模式

AOP面向切面编程，初谈

在不破坏原有代码的基础上，利用“织入”的模式来实现代码的动态配置

 动态代理

InvactionHandler 

 往底层翻会知道最后会生成一个继承proxy的类

InvocationHandler这个接口 是被 动态代理 类 回调的接口，我们所有需要增加的针对委托类的统一处理逻辑都增加到invoke 方法里面    在调用   委托类接口   方法之前或之后 结束战斗

真动态代理

工具类

package com.kuang.真动态代理;

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

//代理调用处理
//等会我们用代理类，自动生成代理类
public class ProxyInvocationHandle implements InvocationHandler {
    private Object target;

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

    //生成得到代理类
    public Object getProxy(){
        //1.获取当前类下的类加载器，2.获取实现类对象的接口，3.实现了InvocationHandler接口的实现类
      return   Proxy.newProxyInstance(this.getClass().getClassLoader(), target.getClass().getInterfaces(),this);
    }



//处理代理实例并返回结果
    //Method method 是一个反射对象，用来实现反射对象的方法
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //动态代理的本质,就是使用反射机制实现
        Object result = method.invoke(target, args);
        return result;
    }
}

接口

package com.kuang.真动态代理;
//租房
public interface Rent {
    void rent();
}

真实对象

package com.kuang.真动态代理;

public class Host implements Rent {
    @Override
    public void rent() {
        System.out.println("房东要出租房子");
    }
}

测试类

package com.kuang.真动态代理;

public class Client {
    public static void main(String[] args) {
        //真实角色
        Rent host = new Host();
        //代理角色，现在没有
        ProxyInvocationHandle proxyInvocationHandle = new ProxyInvocationHandle();
        //通过调用程序处理角色来处理我们要调用的接口对象！
        //代理类也需要去实现和真实对象一样的接口
        proxyInvocationHandle.setTarget(host);

       Rent proxy = (Rent) proxyInvocationHandle.getProxy();//这里的proxy是动态生成的，我们并没有写！
        proxy.rent();
    }
}

1.PeoxyInvocationHandle相当于中介公司，有卖房或租房

2.实现InvocationHandler的类就是员工

5.这里PeoxyInvocationHandle实现了InvocationHandler接口，所以即是公司，又是员工

6.最后通过反射把即将调用的方法（method）传给员工，员工拿到方法后就可以在方法前后自由操作

package com.kuang.真动态代理;

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

//代理调用处理
//等会我们用代理类，自动生成代理类
public class ProxyInvocationHandle implements InvocationHandler {
    private Object target;

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

    //生成得到代理类
    public Object getProxy(){
        //1.获取当前类下的类加载器，2.获取实现类对象的接口，3.实现了InvocationHandler接口的实现类
      return   Proxy.newProxyInstance(this.getClass().getClassLoader(), target.getClass().getInterfaces(),this);
    }



//处理代理实例并返回结果
    //Method method 是一个反射对象，用来实现反射对象的方法
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //动态代理的本质,就是使用反射机制实现
        log(method.getName());
        Object result = method.invoke(target, args);
        return result;
    }

    public void log(String msg){
        System.out.println("执行了"+msg+"方法");
    }
}

package com.kuang.真动态代理;

import com.kuang.Demo02.UserService;
import com.kuang.Demo02.UserServiceImpl;

public class Client {
    public static void main(String[] args) {
        //真实对象
        UserServiceImpl userService = new UserServiceImpl();
        //代理角色不存在
        ProxyInvocationHandle proxy = new ProxyInvocationHandle();
        //把接口对象传进去，通过反射找到所在的接口，并同种方式实现同一个接口里的所有实现方法
        //设置要代理的对象
        proxy.setTarget(userService);
        //动态生成代理类
        UserService pro = (UserService) proxy.getProxy();
          pro.add();
          pro.delete();
          pro.select();
          pro.update();

    }
}