动态代理

 

动态代理代理的是接口

动态代理和静态代理角色一样

动态代理的代理类是动态生成的，不是我们直接写好的！

动态代理分为两大类：

1.基于接口的动态代理

基于接口-JDK代理()

2.基于类的动态代理

基于类：cglib

java字节码的实现：Javassist

需要了解两个类：proxy:代理， InvocationHandler:调用处理程序

InvocationHandler

 

动态代理的好处：

可以使真实角色的操作更加纯粹，不用去关注一公共的业务

公共业务就交给代理角色，实现了业务分工

公共业务发生扩展的时候，方便集中管理

一个动态代理类代理的是一个接口，一般就是对应的一类业务

一个动态代理类可以代理多个类，只要实现了同一个接口

案例：

1.接口

package com.Proxy;

public interface UserService {
  void add();
  void delete();
  void update();
  void select();
}

2.实现类：  被代理类：

package com.Proxy;

public class UserServiceImpl implements UserService {
    @Override
    public void add() {
        System.out.println("add......");
    }

    @Override
    public void delete() {
        System.out.println("delete....");
    }

    @Override
    public void update() {
        System.out.println("update......");
    }

    @Override
    public void select() {
        System.out.println("select.....");
    }
}

3.动态代理类   动态代理类  可以直接利用 

package com.Proxy;

import org.springframework.cglib.proxy.InvocationHandler;

import java.lang.reflect.Method;

public class Proxy implements InvocationHandler {
  private Object target;//被代理的接口

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

    //得到代理类
    public Object  getProxy(){
        //                                               第一个参数：  用哪个类加载器去加载代理对象
        //                                                                                  第二个参数：代理哪个接口
        //
        return org.springframework.cglib.proxy.Proxy.newProxyInstance(this.getClass().getClassLoader(),target.getClass().getInterfaces(),
                //第三个参数  :动态代理方法在执行时，会调用 里面的invoke方法去执行
                this);
    }
     /* Proxy 提供了创建动态代理类和实例的静态方法，它也是由这些方法创建的所有动态代理类的超类
         * static 返回指定接口的代理类的实例，该接口将方法调用分派给指定的调用处理程序
         * */
  /*  proxy：要代理哪一个类 ，调用该方法的代理实例， 调用这个类的哪一个方法
        method:调用这个类的哪一个方法，也可以是代理类继承该方法的代理接口的超级接口
        args:方法里传的参数
        结果返回一个实例类  代理类
    */
//    invoke三个参数：
//
//    proxy：就是代理对象，newProxyInstance方法的返回对象
//
//    method：调用的方法
//
//    args: 方法中的参数
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        init(method);
        Object result= method.invoke(target, args);
        destory(method);
        return result;
    }
    public void init(Method method){
        System.out.println(target.getClass().getName()+"的"+method.getName()+"方法开始执行");
    }
    public void destory(Method method){
        System.out.println(target.getClass().getName()+"的"+method.getName()+"方法开始销毁");
    }
}

测试类：

package com.Proxy;

public class Client {
    public static void main(String[] args) {
        Proxy proxy = new Proxy();
        UserServiceImpl userService = new UserServiceImpl();
        proxy.setTarget(userService);
        UserService proxy1 = (UserService) proxy.getProxy();
       proxy1.add();
    }
}

运行结果：

com.Proxy.UserServiceImpladd方法开始执行
add......
com.Proxy.UserServiceImpladd方法开始销毁