代理模式是Java常见的设计模式之一。所谓代理模式是指客户端并不直接调用实际的对象，而是通过调用代理，来间接的调用实际的对象。
为什么要采用这种间接的形式来调用对象呢？一般是因为客户端不想直接访问实际的对象，或者访问实际的对象存在困难，因此通过一个代理对象来完成间接的访问。
在现实生活中，这种情形非常的常见，比如请一个律师代理来打官司。
从UML图中，可以看出代理类与真正实现的类都是继承了抽象的主题类，这样的好处在于代理类可以与实际的类有相同的方法，可以保证客户端使用的透明性。
代理模式可以有两种实现的方式，一种是静态代理类，另一种是各大框架都喜欢的动态代理。下面我们主要讲解一下这两种代理模式
Subject接口：
public interface Subject { void visit(); }
public class RealSubject implements Subject { @Override public void visit() { System.out.println("business method ..."); } }
public class ProxySubject { private Subject subject; public ProxySubject(Subject subject) { this.subject = subject; } public void before() { System.out.println("proxy before method..."); } public void after() { System.out.println("proxy after method..."); } public void proxyvVisit() { before(); subject.visit(); after(); } }
具体调用如下：
public class Client { public static void main(String[] args) { Subject subject=new RealSubject(); ProxySubject proxySubject=new ProxySubject(subject); //subject.visit();//真实业务调用 proxySubject.proxyvVisit(); } }
动态代理有别于静态代理，是根据代理的对象，动态创建代理类。这样，就可以避免静态代理中代理类接口过多的问题。动态代理是实现方式，是通过反射来实现的，借助Java自带的java.lang.reflect.Proxy,通过固定的规则生成。
其步骤如下：
InvocationHandler接口，并重写该invoke方法第一二步骤，和静态代理一样，不过说了。第三步，代码如下：
import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; public class DynamicProxy implements InvocationHandler { private Object object; public DynamicProxy(Object object) { this.object = object; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { Object result = method.invoke(object, args); return result; } }
第四步，创建动态代理的对象：
import java.lang.reflect.Proxy; public class Client { public static void main(String[] args) { Subject realSubject = new RealSubject(); DynamicProxy proxy = new DynamicProxy(realSubject); ClassLoader classLoader = realSubject.getClass().getClassLoader(); Subject subject = (Subject) Proxy.newProxyInstance(classLoader, new Class[]{Subject.class}, proxy); subject.visit(); } }
创建动态代理的对象，调用Proxy类的静态方法newProxyInstance即可，该方法会返回代理类对象。
static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,InvocationHandler h )
该方法的三个参数分别是：
前提条件：
//没有实现任何接口 public class RealSubject{ public void visit() { System.out.println("business method ..."); } }
// Cglib子类代理工厂 public class ProxyFactory implements MethodInterceptor { // 维护目标对象 private Object target; public ProxyFactory(Object target) { this.target = target; } // 给目标对象创建一个代理对象 public Object getProxyInstance() { //1.工具类 Enhancer en = new Enhancer(); //2.设置父类 en.setSuperclass(target.getClass()); //3.设置回调函数 en.setCallback(this); //4.创建子类(代理对象) return en.create(); } @Override public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable { System.out.println("开始上课"); //执行目标对象的方法 Object returnValue = method.invoke(target, args); System.out.println("下课"); return returnValue; } }
public class Test { public static void main(String[] args) { //目标对象 RealSubject target = new RealSubject(); //代理对象 RealSubject proxy = (RealSubject) new ProxyFactory(target).getProxyInstance(); //执行代理对象的方法 proxy.visit(); } }
总结：三种代理模式各有优缺点和相应的适用范围，主要看目标对象是否实现了接口。以Spring框架所选择的代理模式举例
在Spring的AOP编程中：
如果加入容器的目标对象有实现接口，用JDK代理
如果目标对象没有实现接口，用Cglib代理
转：https://www.cnblogs.com/boboxing/p/8126046.html
原文：https://www.cnblogs.com/jvStarBlog/p/11042647.html