代理的三种方式，静态，动态，cglib

代理模式

代理是一种设计模式，常用于在不改变原有代码的情况下为对象提供额外的功能。代理可以分为静态代理、动态代理和CGLIB代理三种方式。

静态代理

静态代理是指在编译时就已经确定代理类和被代理类的关系，并且代理类是手动编写的。代理类和被代理类实现了同一个接口或继承了同一个父类，代理类中有一个对被代理类的引用，通过调用这个引用来执行被代理类的方法，并可以在方法执行前后添加额外的逻辑。

举例：
假设有一个接口 Subject，其中定义了一个方法 doSomething()。下面是一个静态代理类 StaticProxy 的示例代码：

public interface Subject {
    void doSomething();
}

public class RealSubject implements Subject {
    @Override
    public void doSomething() {
        System.out.println("RealSubject doSomething");
    }
}

public class StaticProxy implements Subject {
    private Subject realSubject;

    public StaticProxy(Subject realSubject) {
        this.realSubject = realSubject;
    }

    @Override
    public void doSomething() {
        System.out.println("Before doSomething");
        realSubject.doSomething();
        System.out.println("After doSomething");
    }
}

public class Main {
    public static void main(String[] args) {
        Subject realSubject = new RealSubject();
        Subject proxy = new StaticProxy(realSubject);
        proxy.doSomething();
    }
}

在这个例子中，RealSubject 是被代理类，实现了 Subject 接口。StaticProxy 是代理类，也实现了 Subject 接口，并在 doSomething() 方法的前后添加了额外的逻辑。

动态代理

动态代理是在运行时生成代理类，不需要手动编写代理类。Java中的动态代理主要使用了 java.lang.reflect.Proxy 类和 java.lang.reflect.InvocationHandler 接口。通过调用 Proxy.newProxyInstance() 方法创建代理类的实例，并通过实现 InvocationHandler 接口的 invoke() 方法来指定代理类的行为。

举例：
假设还是有一个接口 Subject，并且有一个实现类 RealSubject。下面是一个动态代理类 DynamicProxy 的示例代码：

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

public interface Subject {
    void doSomething();
}

public class RealSubject implements Subject {
    @Override
    public void doSomething() {
        System.out.println("RealSubject doSomething");
    }
}

public class DynamicProxy implements InvocationHandler {
    private Object target;

    public DynamicProxy(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Before " + method.getName());
        Object result = method.invoke(target, args);
        System.out.println("After " + method.getName());
        return result;
    }
}

public class Main {
    public static void main(String[] args) {
        Subject realSubject = new RealSubject();
        InvocationHandler handler = new DynamicProxy(realSubject);
        Subject proxy = (Subject) Proxy.newProxyInstance(
                realSubject.getClass().getClassLoader(),
                realSubject.getClass().getInterfaces(),
                handler
        );
        proxy.doSomething();
    }
}

在这个例子中，通过调用 Proxy.newProxyInstance() 方法创建了动态代理类的实例，并传入了 RealSubject 的类加载器、接口和实现 InvocationHandler 接口的对象。在 invoke() 方法中，实现了对目标方法的前后处理。

CGLIB代理

CGLIB（Code Generation Library）是一个基于字节码生成的代理方式，它通过继承被代理类来生成代理类。CGLIB 代理不要求被代理类实现接口，而是通过继承生成一个被代理类的子类，并重写需要代理的方法。

举例：
假设有一个类 RealObject，没有实现任何接口。下面是使用 CGLIB 生成代理类的示例代码：

import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import net.sf.cglib.proxy.Enhancer;

public class RealObject {
    public void doSomething() {
        System.out.println("RealObject doSomething");
    }
}

public class CglibProxy implements MethodInterceptor {
    private Object target;

    public CglibProxy(Object target) {
        this.target = target;
    }

    public Object getProxyInstance() {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(target.getClass());
        enhancer.setCallback(this);
        return enhancer.create();
    }

    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("Before " + method.getName());
        Object result = proxy.invokeSuper(obj, args);
        System.out.println("After " + method.getName());
        return result;
    }
}

public class Main {
    public static void main(String[] args) {
        RealObject realObject = new RealObject();
        CglibProxy cglibProxy = new CglibProxy(realObject);
        RealObject proxy = (RealObject) cglibProxy.getProxyInstance();
        proxy.doSomething();
    }
}

在这个例子中，通过创建 Enhancer 对象并设置被代理类的父类、回调接口来生成代理类。在 intercept() 方法中，实现了对目标方法的前后处理。

优缺点对比

1. 静态代理：

   • 优点：
     • 结构清晰，便于理解和控制。
     • 在编译时就确定了代理类和被代理类的关系，可以实现对被代理类的严格控制。
   • 缺点：
     • 每一个接口或类都需要编写一个代理类，导致代码量增加。
     • 不够灵活，如果接口或类发生变化，需要同步修改代理类。

2. 动态代理：

   • 优点：
     • 不需要手动编写代理类，减少了重复代码，提高了代码的复用性。
     • 可以在运行时动态地创建代理对象，更加灵活。
     • 支持对一组接口的代理，统一进行处理。
   • 缺点：
     • 只能代理实现了接口的类，无法代理没有实现接口的类。
     • 性能相对较低，因为动态代理是通过反射来实现的。

3. CGLIB代理：

   • 优点：
     • 可以代理没有实现接口的类，扩展性更强。
     • 由于是基于继承的方式，所以执行效率相对较高。
   • 缺点：
     • 生成的代理类是目标类的子类，因此不能代理被声明为 final 的类和方法。
     • 相对于动态代理，CGLIB代理不太容易理解，对开发者的要求较高。

区别：

• 静态代理需要编写代理类，代理类和被代理类的关系在编译时确定；动态代理使用Java的反射机制，在运行时动态生成代理类；CGLIB代理是通过继承目标类来生成代理类，不要求目标类实现接口。
• 静态代理和动态代理都是基于接口的代理方式，而CGLIB代理是基于继承的代理方式。
• 静态代理和动态代理都可以代理接口，而CGLIB代理可以代理类。