前言

本文主要讲代理模式，静态代理和动态代理，大致概括了一下其特点及过程，下面让我们进入正文。

代理模式：为对象提供一种代理以控制对这个对象的访问。在某些情况下，一个对象不适合或者不能直接访问另一个对象，而代理对象可以在客户类与目标对象之间起到中介的作用。

代理

Java中的代理按照代理类生成时机不同又分为静态代理和动态代理。静态代理代理类在编译期就生成，而动态代理代理类则是在Java运行时动态生成。

静态代理

1、代理是手工实现的
2、需要代理的目标是确定的

Java中的静态代理要求代理类(ProxySubject)和委托类(RealSubject)都实现同一个接口(Subject)。静态代理中代理类在编译期就已经确定，而动态代理则是JVM运行时动态生成，静态代理的效率相对动态代理来说相对高一些，但是静态代理代码冗余大，一单需要修改接口，代理类和委托类都需要修改。

举个例子：

接口(Subject)：

interface HelloService {
    void sayHello();
}

委托类：

class HelloServiceImpl implements HelloService {
    @Override
    public void sayHello() {
        System.out.println("Hello World!");
    }
}

代理类：

class HelloServiceProxy implements HelloService {
    private HelloService helloService;

    public HelloServiceProxy(HelloService helloService) {
        this.helloService = helloService;
    }

    @Override
    public void sayHello() {
        System.out.println("Before say hello...");
        helloService.sayHello();
        System.out.println("After say hello...");
    }
}

测试类：

public class HelloServiceProxyTest {

    public static void main(String[] args) {
        HelloService helloService = new HelloServiceImpl();
        HelloServiceProxy proxy = new HelloServiceProxy(helloService);
        proxy.sayHello();
    }
}
输出结果：

Before say hello...
Hello World!
After say hello...

动态代理

当目标类很多的时候，可以使用动态代理，避免静态代理的缺点。

动态代理:在程序执行过程中，使用jdk的反射机制，创建代理类对象，并动态的指定要代理目标类。

动态代理分为两种:

1.jdk动态代理:使用java反射包中的类和接口实现动态代理的功能。
反射包java.lang.reflect，里面有三个类: InvocationHandler ,Method，Proxy.

2. cglib动态代理: cglib是第三方的工具库，创建代理对象。
cglib的原理是继承，_aglib通过继承目标类，创建它的子类，在子类中
重马父类中同名的方法，实现功能的修改。

因为cglib是继承，重写方法，所以要求目标类不能是final的，方法也不能是final的。

Java中的动态代理依靠反射来实现，代理类和委托类不需要实现同一个接口。委托类需要实现接口，否则无法创建动态代理。代理类在JVM运行时动态生成，而不是编译期就能确定。
Java动态代理主要涉及到两个类：java.lang.reflect.Proxy和java.lang.reflect.InvocationHandler。代理类需要实现InvocationHandler接口或者创建匿名内部类，而Proxy用于创建动态动态。
我们用动态代理来实现HelloService：

接口(Subject)：

interface HelloService {
    void sayHello();
}

委托类：

class HelloServiceImpl implements HelloService {
    @Override
    public void sayHello() {
        System.out.println("Hello World!");
    }
}

动态代理类：

class HelloServiceDynamicProxy {

    private HelloService helloService;
    public HelloServiceDynamicProxy(HelloService helloService) {
        this.helloService = helloService;
    }

    public Object getProxyInstance() {
        return Proxy.newProxyInstance(helloService.getClass().getClassLoader(), helloService.getClass().getInterfaces(), new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("Before say hello...");
                Object ret = method.invoke(helloService, args);
                System.out.println("After say hello...");
                return ret;
            }
        });
    }
}

测试类：

public class HelloServieDynamicProxyTest {
    public static void main(String[] args){
        HelloService helloService = new HelloServiceImpl();
        HelloService dynamicProxy = (HelloService) new HelloServiceDynamicProxy(helloService).getProxyInstance();
        dynamicProxy.sayHello();
    }
}
输出结果：

Before say hello...
Hello World!
After say hello...

总结

• 静态代理实现较简单，代理类在编译期生成，效率高。缺点是会生成大量的代理类。
• JDK动态代理不要求代理类和委托类实现同一个接口，但是委托类需要实现接口，代理类需要实现InvocationHandler接口。
• 动态代理要求代理类InvocationHandler接口，通过反射代理方法，比较消耗系统性能，但可以减少代理类的数量，使用更灵活。
  本文到这里就结束了，感谢看到最后的朋友，都看到最后了点个赞再走啦，如有不对之处还请多多指正。