Java动态代理知识记录

这是对看完代理知识的一个总结记录
先盗张在网上看到的图，简单明了

picture.png

红色的地方就是在目标对象实现的业务上，增加额外的功能，例如：增加日志，控制权限，优化等等。
为什么要使用代理呢？我的理解
1.把那些跟业务没有关系的代码与真正的业务代码脱离出来，降低耦合度。
2.如果有很多业务需要用到相同的功能，如日志，这样只要写一个代理类大家都可以用，减少代码的复用率。
3.方便以后扩展新的功能，不用去修改已经封装好的的目标对象

代理分两种：1.静态代理 2.动态代理（a.jdk动态代理 b.CGLib 动态代理）
静态代理与动态代理的区别是什么呢
从静态动态字面意思就很好理解，静态代理就是这个代理类是由程序员自己写的，代码编译后运行前，代理类的.class文件就已经存在了。（就像静态页面，里面的资源都是在本地存在的）
动态代理 代理类.class是在程序运行的时候通过生成字节码生成的。

静态代理例子

//业务接口
public interface UserDao {
    void doSomeThing();
    String getSomeThing();
}

//实现类
public class UserDaoImpl implements UserDao {
@Override
public void doSomeThing() {
    System.out.println("Start do something!");
}

@Override
public String getSomeThing() {
    System.out.println("Start get something!");
    return "things";
  }
}

代理类

public class StaticProxy implements UserDao {
private UserDaoImpl userDao;

public StaticProxy(UserDaoImpl userDao) {
    this.userDao = userDao;
}


@Override
public void doSomeThing() {
    System.out.println("DO DO DO Proxy starting!");
    this.userDao.doSomeThing();
    System.out.println("DO DO DO  Proxy finished!");
}

@Override
public String getSomeThing() {
    System.out.println("GET GET GET Proxy starting!");
    String result = this.userDao.getSomeThing();
    System.out.println("GET GET GET Proxy finished!");
    return result;
  }
}

测试类

public class StaticProxyTest {
public static void main(String[] args){
    StaticProxy proxyTest = new StaticProxy(new UserDaoImpl());
    proxyTest.doSomeThing();
    proxyTest.getSomeThing();
  }
}

执行结果

image.png

讲解：为了给业务实现类UserDaoImpl里面的每个方法做代理，我们的代理类也要实现UserDao接口，然后在是实现方法中些增强功能与实现业务。敲重点：如果业务实现类有很多个接口，那就要有很多个代理类对应，可是他们的增强功能都是一样的，这样就会有很多代码重复了，这就是静态代理不好的地方。

动态代理

还是一样的接口与实现类 UserDaoImpl,UserDao
这里要创建一个代理类，实现InvocationHandler接口并实现Invoke（）方法，在这个方法里面写增强功能代码。

  public class ProxyTest implements InvocationHandler {
private Object target;
public Object getProxyInstance(Object target){
    this.target = target;
    return Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),this);
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

    Intercepter intercepter = new Intercepter();
    if(method.getName().equals("doSomeThing")){
        intercepter.before(); //硬编码的形式调用拦截器  
        method.invoke(target,args);
        intercepter.after();
        return null;
    }else if(method.getName().equals("getSomeThing")){
        System.out.println("GET GET GET Proxy starting!");
        Object result = method.invoke(target,args);
        System.out.println("GET GET GET Proxy finished!");
        return result;
    }else{
        return null;
    }
  }
}

拦截器

public class Intercepter {
public void before(){
    System.out.println("DO DO DO Proxy starting!");
}
public void after(){
    System.out.println("GET GET GET  Proxy finished!");
  }
}

测试类

public class TestClient {
public static void main(String[] args){
    ProxyTest proxyTest = new ProxyTest();
    UserDao userDao = (UserDao) proxyTest.getProxyInstance(new UserDaoImpl());
    userDao.doSomeThing();
    System.out.print(userDao.getSomeThing());
  }
}

执行结果

image.png

可以看出代理类是通过newProxyInstance(ClassLoader loader, Class<?>[] interfaces,InvocationHandler h)方法创建出来的.

ClassLoader loader,:指定当前目标对象使用类加载器,获取加载器的方法是固定的
Class<?>[] interfaces,:目标对象实现的接口的类型,使用泛型方式确认类型
InvocationHandler h:事件处理,执行目标对象的方法时,会触发事件处理器的方法,会把当前执行目标对象的方法作为参数传入

方法里面是通过传入的类加载器（classLoader），与接口（intefaces）来生成字节码加载到内存生成代理类，再利用反射机制获取构造函数，创建出代理类实例。（其实不是很了解，需要进一步看源码去理解）

拦截器
在invoke()方法里面可以看到我们创建拦截器实例，调用拦截器方法，这样用了硬编码的方式。Spring aop中则是使用配置文件或者注解的形式来决定 invoke()中哪些方法调用哪些拦截器。这样又把增强功能与代理类解耦了。

缺点：由于是面向接口的代理模式，所以如果业务类没有实现接口，那就不能用这种代理了。
Spring aop 也是根据业务类有没有实现接口来选择用那种代理。
实现了接口用 JDK动态代理，没有实现接口用 CGLib动态代理。

CGLib动态代理

CGLib 可以代理没有实现接口的类，通过字节码创建实现类的子类，在子类中增强实现类方法。

  public class CglibProxy implements MethodInterceptor{  
  private Enhancer enhancer = new Enhancer();  
  public Object getProxy(Class clazz){  
    enhancer.setSuperclass(clazz);  
    enhancer.setCallback(this);  
    //通过字节码技术动态创建子类实例  
    return enhancer.create();  
 }  
  
 public Object intercept(Object obj, Method method, Object[] args,  
   MethodProxy proxy) throws Throwable {  
    System.out.println("DO DO DO Proxy starting!");  
    //通过代理类调用父类中的方法  
    Object result = proxy.invokeSuper(obj, args);  
    System.out.println("GET GET GET  Proxy finished!");  
    return result;  
  }  
 }

测试类

 public class TestClient{  
 public static void main(String[] args) {  
  CglibProxy proxy = new CglibProxy();  
  UserDaoImpl proxyImp =(UserDaoImpl)proxy.getProxy(SayHello.class);  
  proxyImp.doSomeThing();  
 }  
}

执行结果

image.png

intercept（）拦截所有目标类方法的调用，执行里面的增强功能，proxy.invokeSuper(obj, args)会去直接调用父类的方法super.doSomeThing（）。
缺点：由于是通过继承实现类创建子类，所以无法代理final类