java編碼中經常用到代理，代理分為靜態代理和動態代理。其中動態代理可以實現spring中的aop。
一、靜態代理：程序運行之前，程序員就要編寫proxy，然后進行編譯，即在程序運行之前，代理類的字節碼文件就已經生成了
被代理類的公共父類
package staticproxy;
public abstract class BaseClass {
public abstract void add();
}
被代理類
package staticproxy;
public class A extends BaseClass {
public void add() {
System.out.println("A add !");
}
}
代理類
package staticproxy;
public class Proxy {
BaseClass baseClass;
public void add() {
baseClass.add();
}
public void setBaseClass(BaseClass baseClass) {
this.baseClass = baseClass;
}
public static void main(String[] args) {
BaseClass baseClass = new A();
Proxy proxy = new Proxy();
proxy.setBaseClass(baseClass);
proxy.add();
}
}
二、動態代理：實際的代碼在編譯期間并沒有生成，而是在運行期間運用反射機制動態的生成被代理類接口
package jdkproxy;
public interface Service {
public void add();
public void update();
}
被代理類A
package jdkproxy;
public class AService implements Service {
public void add() {
System.out.println("AService add>>>>>>>>>>>>>>>>>>");
}
public void update() {
System.out.println("AService update>>>>>>>>>>>>>>>");
}
}
被代理類B
package jdkproxy;
public class BService implements Service {
public void add() {
System.out.println("BService add---------------");
}
public void update() {
System.out.println("BService update---------------");
}
}
代理類
package jdkproxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class MyInvocationHandler implements InvocationHandler {
private Object target;
MyInvocationHandler() {
super();
}
MyInvocationHandler(Object target) {
super();
this.target = target;
}
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
// 程序執行前加入邏輯
System.out.println("before-----------------------------");
// 程序執行
Object result = method.invoke(target, args);
//程序執行后加入邏輯
System.out.println("after------------------------------");
return result;
}
public Object getTarget() {
return target;
}
public void setTarget(Object target) {
this.target = target;
}
}
測試類
package jdkproxy;
import java.lang.reflect.Proxy;
public class Test {
public static void main(String[] args) {
Service aService = new AService();
MyInvocationHandler handler = new MyInvocationHandler(aService);
// Proxy為InvocationHandler實現類動態創建一個符合某一接口的代理實例
Service aServiceProxy = (Service) Proxy.newProxyInstance(aService
.getClass().getClassLoader(), aService.getClass()
.getInterfaces(), handler);
//由動態生成的代理對象來aServiceProxy 代理執行程序，其中aServiceProxy 符合Service接口
aServiceProxy.add();
System.out.println();
aServiceProxy.update();
// 以下是對B的代理
// Service bService = new BService();
// MyInvocationHandler handler = new MyInvocationHandler(bService);
// Service bServiceProxy = (Service) Proxy.newProxyInstance(bService
// .getClass().getClassLoader(), bService.getClass()
// .getInterfaces(), handler);
// bServiceProxy.add();
// System.out.println();
// bServiceProxy.update();
}
}
輸出結果：
before-----------------------------
AService add>>>>>>>>>>>>>>>>>>
after------------------------------
before-----------------------------
AService update>>>>>>>>>>>>>>>
after------------------------------其中上述標紅的語句是產生代理類的關鍵代碼，可以產生一個符合Service接口的代理對象，newProxyInstance這個方法會做這樣一件事情，他將把你要代理的全部接口，用一個由代碼動態生成的類來實現，該類中所有的接口中的方法都重寫為調用InvocationHandler.invoke()方法。
下面詳細介紹是如何實現代理對象的生成的
Proxy的newProxyInstance方法，其中，為了看起來方便，已經將該方法中的異常處理語句刪減
下下面public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,InvocationHandler h) throws
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,InvocationHandler h) throws IllegalArgumentException
{
if (h == null) {
throw new NullPointerException();
}
//生成指定的代理類
Class cl = getProxyClass(loader, interfaces);
Constructor cons = cl.getConstructor(constructorParams);
// 生成代理類的實例，并把MyInvocationHandler的實例傳給它的構造方法，代理類對象實際執行都會調用MyInvocationHandler的invoke方法，所以代理類對象中維持一個MyInvocationHandler引用
return (Object) cons.newInstance(new Object[] { h });
} 其中getProxyClass方法返回代理類的實例
Proxy的getProxyClass方法
public static Class<?> getProxyClass(ClassLoader loader, Class<?>... interfaces) throws IllegalArgumentException
{
//前面省略很多緩存、異常處理、判斷邏輯代碼，為了使程序更加突出
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces);
proxyClass = defineClass0(loader, proxyName,proxyClassFile, 0, proxyClassFile.length);
proxyClasses.put(proxyClass, null);
return proxyClass;
}
下面看ProxyGenerator的generateProxyClass方法，該方法最終產生代理類的字節碼文件：
public static byte[] generateProxyClass(final String name, Class[] interfaces)
{
ProxyGenerator gen = new ProxyGenerator(name, interfaces);
// 這里動態生成代理類的字節碼
final byte[] classFile = gen.generateClassFile();
// 如果saveGeneratedFiles的值為true，則會把所生成的代理類的字節碼保存到硬盤上
if (saveGeneratedFiles) {
java.security.AccessController.doPrivileged(
new java.security.PrivilegedAction<Void>() {
public Void run() {
try {
FileOutputStream file =
new FileOutputStream(dotToSlash(name) + ".class");
file.write(classFile);
file.close();
return null;
} catch (IOException e) {
throw new InternalError(
"I/O exception saving generated file: " + e);
}
}
});
}
// 返回代理類的字節碼
return classFile;
}
那么最終生成的代理類到底是什么樣子呢，如下(省略了一下equals，hashcode，toString等方法，只展示構造函數和add方法)：
public final class $Proxy11 extends Proxy implements Service
{ // 構造方法，參數就是剛才傳過來的MyInvocationHandler類的實例
public $Proxy11(InvocationHandler invocationhandler)
{
super(invocationhandler);
}
/**
* 繼承的add方法，重寫，調用MyInvocationHandler中的invoke方法
*/
public final void add()
{
try
{
// 實際上就是調用MyInvocationHandler中的invoke方法
super.h.invoke(this, m3, null);
return;
}
catch(Error _ex) { }
catch(Throwable throwable)
{
throw new UndeclaredThrowableException(throwable);
}
}
}
