Java 反射之JDK动态代理

Proxy提供用于创建动态代理类和代理对象的静态方法，它也是所有动态代理类的父类。如果我们在程序中为一个或多个接口动态地生成实现类，就可以使用Proxy来创建动态代理类；如果需要为一个或多个接口动态的创建实例，也可以使用Proxy来创建动态代理实例。

Proxy提供了如下两个方法来创建动态代理类和动态代理类：

（1）、static Class<?> getProxyClass(ClassLoader loader,Class<?> ...interfaces) ：创建一个动态代理类所对应的Class对象，该代理类将实现interfaces所指定的多个接口。第一个ClassLoader指定生成动态代理类的类加载器。

（2）、static Object newProxyInstance(ClassLoader loader,Class<?> interfaces, InvocationHandler h) ：直接创建一个动态代理对象，该代理对象的实现类实现了interfaces指定的系列接口，执行代理对象的每个方法时都会被替换成执行 InvocationHandler对象的invoke方法。

实际上，即使采用第一种方式获取了一个动态代理类之后，当程序需要通过该代理类来创建对象时一样需要传入一个InvocationHandler对象。也就是说，系统生成的每个代理对象都有一个与之关联的InvocationHandler对象。

下面是AOP动态代理的实现：

在方法前后加入一写通用方法，比如项目中的日志记录。

Dog.java

package com.reflect.proxy;

public interface Dog {

	public void info();

	public void run();

}

GunDog.java

package com.reflect.proxy;

public class GunDog implements Dog {

	@Override

	public void info() {

		System.out.println("我是一只猎狗");

	}

	@Override

	public void run() {

		System.out.println("我奔跑迅速");

	}

}

DogUtil.java

package com.reflect.proxy;

public class DogUtil {

	public void method1(){

		System.out.println("=====模拟第1个通用方法======");

	}

	public void method2(){

		System.out.println("=====模拟第2个通用方法======");

	}

}

借助于Proxy和InvocationHandler就可以实现：当程序调用info()方法和run()方法时，系统就可以“自动” 将method1()和method2() 两个通用方法插入info()和run()犯法

package com.reflect.proxy;

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Method;

public class MyInvocationHandler implements InvocationHandler {

	//需要被代理的对象

	private Object target;

	public void setTarget(Object target){

		this.target=target;

	}

	//指定动态代理的所有方法时，都会替换成执行如下的invoke方法

	@Override

	public Object invoke(Object proxy, Method method, Object[] args)

			throws Throwable {

		DogUtil du=new DogUtil();

		//执行DogUtil中的method1

		du.method1();

		//以target为主掉来执行method方法

		Object result=method.invoke(target, args);

		System.out.println(result);

		//执行DogUtil中的Method2

		du.method2();

		return result;

	}

}

为指定的target生成代理类.

package com.reflect.proxy;

import java.lang.reflect.Proxy;

public class MyProxyFactory {

	//为指定target生成动态代理对象

	public static Object getProxy(Object target){

		MyInvocationHandler handler=new MyInvocationHandler();

		//为MyInvotationHandler设置target对象

		handler.setTarget(target);

		//创建并返回一个动态代理

		return  Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), handler);

	}

}

测试类

package com.reflect.proxy;

public class Test {

	public static void main(String[] args) {

		//创建一个原始的GunDog对象，作为target

		Dog target=new GunDog();

		//以指定的target创建动态代理

		Dog dog=(Dog) MyProxyFactory.getProxy(target);

		dog.info();

		dog.run();

	}

}

输出：

=====模拟第1个通用方法======

我是一只猎狗

=====模拟第2个通用方法======

=====模拟第1个通用方法======

我奔跑迅速

=====模拟第2个通用方法======

巴特西

Java 反射之JDK动态代理

最新文章

热门文章