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类
