Java代理模式的实现方式——静态代理&动态代理

静态代理

一个代理对象代理一个具体的对象，而动态代理是一个代理对象可以代理多个具体的代理对象。
静态代理的实现方式如下：
1.定义一个目标类

public interface Target {
	void myRequest();
}

2.定义一个具体的实现类（被代理的类）

public class RealTarget implements Target {
	public void myRequest() {
		System.out.println("RealTarget");
	}
}

3.定义一个代理类，且代理类要只有持有一个被代理的具体类

public class ProxyTarget implements Target {

	private RealTarget realTarget = new RealTarget();

	public void myRequest() {
		System.out.println("Before");
		realTarget.myRequest();
		System.out.println("After");
	}

}

4.具体使用中使用代理即可如下

public class TargetMain {

	public static void main(String[] args) {
		ProxyTarget proxyTarget = new ProxyTarget();
		proxyTarget.myRequest();
	}

}

5.最后打印的效果如下

Before
RealTarget
After

上面的方式就是实现一个静态代理的方式。应该很好理解。但是缺点也很明显就是一个代理对应一个具体的被代理对象。

动态代理的方式

1.定义一个目标类

public interface Subject {
	void mySubject();
}

2.定义一个实现类（被代理对象）

/**
 * 被代理的对象
 */
public class MySubject implements Subject {
	public void mySubject() {
		System.out.println("被代理对象：真实处理逻辑的地方");
	}
}

3.创建一个代理类，并持有代理对象，此代理对象应该定义为一个Object，因为他是1：N的关系

/**
 * 动态代理对象
 */
public class DynamicSubject implements InvocationHandler {

	/** 被代理的对象（通过构造方法传入） */
	private Object sub;

	public DynamicSubject(Object sub) {
		this.sub = sub;
	}

	/**
	 * @param proxy  代理类的实例
	 * @param method 目标对象调用的方法
	 * @param args   调用方法的参数
	 * @return
	 * @throws Throwable
	 */
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		System.out.println("proxy:" + proxy.getClass() + " method:" + method.getName());
		System.out.println("Before");
		//调用真实的逻辑
		Object invoke = method.invoke(sub, args);
		System.out.println("After");
		return invoke;
	}

}

4.创建代理对象，并调用代理方法

public class DaynamicMain {

	public static void main(String[] args) {
		MySubject realSubject = new MySubject();
		InvocationHandler invocationHandler = new DynamicSubject(realSubject);
		//创建一个动态代理对象
		ClassLoader classLoader = invocationHandler.getClass().getClassLoader();
		Subject subject = (Subject) Proxy.newProxyInstance(classLoader, realSubject.getClass().getInterfaces(), invocationHandler);
		subject.mySubject();
	}

}

5.最后的打印如下

proxy:class com.sun.proxy.$Proxy0 method:mySubject
Before
被代理对象：真实处理逻辑的地方
After

这就实现了一个代理对象对应多个代理代理对象的方式，只要把真实的被代理对象传入到动态代理类中即可。

动态代理生成的字节码

正常是不会显示出来，我们需要修改JVM参数增加如下

-Dsun.misc.ProxyGenerator.saveGeneratedFiles=true

生成的字节码如下：

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package com.sun.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
import spring.dproxy.Subject;

public final class $Proxy0 extends Proxy implements Subject {
    private static Method m1;
    private static Method m3;
    private static Method m2;
    private static Method m0;

    public $Proxy0(InvocationHandler var1) throws  {
        super(var1);
    }

    public final boolean equals(Object var1) throws  {
        try {
            return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final void mySubject() throws  {
        try {
            super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final String toString() throws  {
        try {
            return (String)super.h.invoke(this, m2, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final int hashCode() throws  {
        try {
            return (Integer)super.h.invoke(this, m0, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m3 = Class.forName("spring.dproxy.Subject").getMethod("mySubject");
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

总结

上述就是两种代理模式的实现方法，方便大家使用。以及以后自己的查漏补缺吧。