Java反射—运用反射生成jdk动态代理

1.  核心类&接口

在Java的java.lang.reflect包下提供一个Proxy类和一个InvocationHandler接口，通过使用这个类和接口可以生成jdk动态代理类或动态代理对象。

Proxy是所有动态代理类的父类，它提供了两个静态方法来创建动态代理类和动态代理对象，如下：

　　? 
static Class<?>
getProxyClass(ClassLoader loader,
Class<?>... interfaces)

　　? 
static Object 
newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)

　　getProxyClass返回代理类的 java.lang.Class 对象，并向其提供类加载器和接口数组。newProxyInstance返回一个指定接口的代理类实例，该接口可以将方法调用转发到指定的调用处理程序，执行代理对象的每个方法时都会被替换执行InvocationHandler对象的Invoke方法。实际上，即使采用第一种方式获取了一个动态代理类之后，当程序需要通过该代理类来创建对象时一样需要传入一个InvocationHandler对象。也就是说，系统生成的每个代理对象都有一个与之关联的InvocationHandler对象。

　　从上面的两个方法的参数可以看出，只有给我一个（或多个）接口，我们就可以生成实现了这个（或多个）接口的代理类和代理对象。

2.    两种方式生成代理对象

下面我们就用上面提到两种方式，分别来生成一个接口（Person）的代理对象。

　　2.1  接口Person

package com.tgb.reflect;

/**
 * 目标接口
 *
 * @author wangzhipeng
 *
 */
public interface Person {

	public void walk();

	public void sayHello();

}

　　2.2  构造一个InvocationHandler类

package com.tgb.reflect;

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

public class MyInvocationHandler implements InvocationHandler {
	/**
	 * 执行代理对象的所有方法时都会被替换成执行如下的invoke方法
	 *
	 * proxy ：代表动态代理对象； method：代表正在执行的方法 ；args :代表执行代理对象方法时传入的实参
	 */
	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		// TODO Auto-generated method stub
		System.out.println("正在执行方法：" + method.getName());
		if (args != null) {
			System.out.println("下面是执行方法时传入的实参：");
			for (Object object : args) {
				System.out.println(object);
			}
		} else {
			System.out.println("该方法调用无实参！");
		}
		return null;
	}

}

　　2.3  方式一：利用getProxyClass生成代理对象

package com.tgb.reflect;

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

/**
 * 利用getProxyClass生成代理对象
 *
 * @author wangzhipeng
 *
 */
public class TestReflectProxy {

	@SuppressWarnings("unchecked")
	public static void main(String[] args) throws Exception {
		// 1、创建一个InvocationHandler对象
		InvocationHandler myInvocationHandler = new MyInvocationHandler();
		// 2、创建Person接口的一个代理类（获取代理类的字节码）
		Class proxyClass = Proxy.getProxyClass(Person.class.getClassLoader(), new Class[] { Person.class });
		// 3、根据代理类的字节码拿到它的参数为InvocationHandler类型的构造器
		Constructor constructor = proxyClass.getConstructor(new Class[] { InvocationHandler.class });
		// 4、根据构造器创建代理对象
		Person person = (Person) constructor.newInstance(myInvocationHandler);
		// 5、调用代理对象的方法
		person.walk();
		person.sayHello();
		/**
		 * 输出结果如下：
		 *
		 * 正在执行方法：walk 该方法调用无实参！
		 *
		 * 正在执行方法：sayHello 该方法调用无实参！
		 */
	}

}

　　2.4  方式二：利用newProxyInstance生成代理对象

package com.tgb.reflect;

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

/**
 * 利用newProxyInstance生成代理对象
 *
 * @author wangzhipeng
 *
 */
public class TestReflectProxy2 {

	public static void main(String[] args) {
		// 1、创建一个InvocationHandler对象
		InvocationHandler myInvocationHandler = new MyInvocationHandler();
		// 2、利用Proxy类的静态方法newProxyInstance直接生成Person接口的代理对象
		Person person = (Person) Proxy.newProxyInstance(Person.class.getClassLoader(), new Class[] { Person.class }, myInvocationHandler);
		// 3、调用代理对象的方法
		person.walk();
		person.sayHello();
		/**
		 * 输出结果如下：
		 *
		 * 正在执行方法：walk 该方法调用无实参！
		 *
		 * 正在执行方法：sayHello 该方法调用无实参！
		 */
	}

}

3.    动态代理与aop

下面我们在上面例子的基础上再扩展一小步，模拟以下aop思想原理。其实，非常简单，上面已经提到了，执行代理对象的每个方法时都被替换执行InvocationHandler对象的Invoke方法。所以我们只需要在Invoke方法中的“反射执行目标方法（method.invoke(target,args)）“的前后加入我们增强的方法即可。实例代码如下：

　　3.1   目标接口Person

package com.tgb.reflect.aop;

/**
 * 目标接口
 *
 * @author wangzhipeng
 *
 */
public interface Person {

	public void walk();

	public void sayHello();

}

　　3.2   目标类ZhanSan

package com.tgb.reflect.aop;

/**
 * 目标类（实现了Person接口）
 *
 * @author wangzhipeng
 *
 */
public class ZhanSan implements Person {

	@Override
	public void sayHello() {
		System.out.println("我是张三---->sayHello");
	}

	@Override
	public void walk() {
		System.out.println("我是张三---->walk");
	}

}

　　3.3   增强类Extend

package com.tgb.reflect.aop;

/**
 * 增强类
 *
 * @author wangzhipeng
 *
 */
public class Extend {
	/**
	 * 增强方法1
	 */
	public void ExtendMethod1() {
		System.out.println("我是增强方法一");
	}

	/**
	 * 增强方法2
	 */
	public void ExtendMethod2() {
		System.out.println("我是增强方法二");
	}
}

　　3.4   InvocationHandler类MyInvocationHandler

package com.tgb.reflect.aop;

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 {
		// 实例化一个增强类
		Extend extend = new Extend();
		// 执行增强方法1（模拟spring前置增强）
		extend.ExtendMethod1();
		Object result = method.invoke(target, args);// 【执行目标方法】
		// 执行增强方法2（模拟spring后置增强）
		extend.ExtendMethod2();
		return result;
	}

}

　　3.5   代理生成工厂MyProxyFactory

package com.tgb.reflect.aop;

import java.lang.reflect.Proxy;

/**
 * 生成代理的工厂
 *
 * @author wangzhipeng
 *
 */
public class MyProxyFactory {
	/*
	 * 获取一个目标对象（目标类必须实现接口）的代理对象
	 */
	public static Object getProxy(Object target) {
		// 实例化一个InvocationHandler类，并传入目标对象
		MyInvocationHandler myInvocationHandler = new MyInvocationHandler();
		myInvocationHandler.setTarget(target);
		// 生成代理对象
		Object proxyObject = Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), myInvocationHandler);
		return proxyObject;

	}
}

　　3.6   测试类Test

package com.tgb.reflect.aop;

/**
 * 测试类
 *
 * @author wangzhipeng
 *
 */
public class Test {

	public static void main(String[] args) {
		// 创建一个原始的ZhanSan（实现了Person接口）对象作为Target
		Person zhanSan = new ZhanSan();
		// 利用代理工厂生成zhansan对象（Target）的代理对象
		Person proxyZhanSan = (Person) MyProxyFactory.getProxy(zhanSan);
		// 执行代理对象的方法（会执行织入的增强类（Extend）的两个增强方法）
		proxyZhanSan.walk();
		proxyZhanSan.sayHello();
	}

}

　　3.7   结果如下

4.    总结

　　Proxy类主要方法有四个（如下图），jdk动态代理主要是利用Proxy类的getProxyClass和newProxyInstance方法生成接口的动态代理对象，并将执行代理对象的每个方法时都被替换执行InvocationHandler对象的Invoke方法。这为Spring的aop打好了基础。此外，实际应用中，我们一般不会单纯直接生成一个（或多个）接口的代理对象，而是生成某个接口实现类（目标类）的代理对象。

　　实际上普通的java编程中我们很少用到动态代理，它最大的魅力在于编写框架或底层基础代码。

版权声明：本文为博主原创文章，未经博主允许不得转载。

时间： 2024-10-14 04:41:14

Java反射—运用反射生成jdk动态代理的相关文章

类的加载机制和反射——五、使用反射生成JDK动态代理

使用反射生成JDK动态代理 1.使用Proxy和InvocationHandler创建动态代理 (1)Proxy提供了用于创建动态代理类和动态代理对象的静态方法,他也是所有动态代理类的父类. (2)如果在程序中为一个或多个接口动态的生成实现类,就可以使用Proxy来创建动态代理类,如果需要为一个或多个接口动态的创建实例,也可以使用Proxy来创建动态代理实例. (3)Proxy提供了两个方法来创建动态代理类和动态实例: 1)static Class<?> getProxyClass(Class

java核心学习(四十) 使用反射生成JDK动态代理

java.lang.reflect包下提供了一个Proxy类和InvocationHandler接口,用于生成动态代理类和动态代理对象. 一.使用Proxy.InvocationHandler创建动态代理 这里要注意,在java.net包下也有一个Proxy类,不过这个类是用于设置代理服务器的,莫混淆.. Proxy提供了如下两个方法创建动态代理类和动态代理实例: 实际上即使采用第一种方法创建动态代理类,如果程序需要通过该代理类来创建对象,依然需要传入一个InvocationHandler对象,

跟王老师学反射（十一）：动态代理

跟王老师学反射(十一):动态代理 主讲教师:王少华   QQ群号:483773664 学习内容 学会使用动态代理 一.动态代理 动态代理(Dynamic Proxy):相比上一节所实现的静态代理,动态代理具有更强的灵活性,因为它不用在我们设计实现的时候就指定某一个代理类来代理哪一个被代理对象,我们可以把这种指定延迟到程序运行时由JVM来实现. 动态代理(Dynamic proxies)是 Java 1.3 引入的特性,在Java的java.lang.reflect包下提供了一个Proxy类和一个

Java反射学习总结四（动态代理使用实例和内部原理解析）

通过上一篇文章介绍的静态代理Java反射学习总结三(静态代理)中,大家可以发现在静态代理中每一个代理类只能为一个接口服务,这样一来必然会产生过多的代理,而且对于每个实例,如果需要添加不同代理就要去添加相应的代理类.解决这一问题最好的做法是可以通过一个代理类完成全部的代理功能或者说去动态的生成这个代理类,那么此时就必须使用动态代理完成. 动态代理知识点: Java动态代理类位于java.lang.reflect包下,主要有以下一个接口和一个类: 1.InvocationHandler接口:    

java 反射提取类信息， 动态代理 和过滤某些方法演示

package org.rui.classts.reflects; import java.lang.reflect.Constructor; import java.lang.reflect.Method; import java.util.regex.Pattern; /** * 提取 类的 方法 构造器 * @author lenovo * */ //{args:ShowMethods} //查看一个类的所有方法和构造器 public class ShowMethods { private

Java进阶之 JDK动态代理与Cglib动态代理

一.动态代理概述: 与静态代理对照(关于静态代理的介绍 可以阅读上一篇:JAVA设计模式之 代理模式[Proxy Pattern]), 动态代理类的字节码是在程序运行时由Java反射机制动态生成. 注意: 1.AspectJ是采用编译时生成AOP代理类,具有更好的性能,但是需要使用特定的编译器进行处理 2.Spring AOP采用运行时生成AOP代理类,无需使用特定编译器进行处理,但是性能相对于AspectJ较差 二.JDK动态代理 [对有实现接口的对象做代理] 1.JDK动态代理中 需要了解的

Java学习之：JDK动态代理与CGLIB动态代理

代理的概念:简单的理解就是通过为某一个对象创建一个代理对象,我们不直接引用原本的对象,而是由创建的代理对象来控制对原对象的引用. 动态代理:是指在程序运行时由Java反射机制动态生成,无需手动编写代码.动态代理不仅简化了编程工作,而且提高了软件系统的可扩展性,因为Java反射机制可以生成任意类型的动态代理类. 代理原理:代理对象内部含有对真实对象的引用,从而可以操作真实对象,同时代理对象提供与真实对象相同的接口以便在任何时刻都能代替真实对象.同时,代理对象可以在执行真实对象操作时,附加其他的操作

Java之美[从菜鸟到高手演练]之JDK动态代理的实现及原理

JDK动态代理的实现及原理 作者:二青 邮箱:[email protected]     微博:http://weibo.com/xtfggef 动态代理,听上去很高大上的技术,在Java里应用广泛,尤其是在Hibernate和Spring这两种框架里,在AOP,权限控制,事务管理等方面都有动态代理的实现.JDK本身有实现动态代理技术,但是略有限制,即被代理的类必须实现某个接口,否则无法使用JDK自带的动态代理,因此,如果不满足条件,就只能使用另一种更加灵活,功能更加强大的动态代理技术-- CG

【Java入门提高篇】Day11 Java代理——JDK动态代理

今天来看看Java的另一种代理方式--JDK动态代理 我们之前所介绍的代理方式叫静态代理,也就是静态的生成代理对象,而动态代理则是在运行时创建代理对象.动态代理有更强大的拦截请求功能,因为可以获得类的运行时信息,可以根据运行时信息来获得更为强大的执(骚)行(操)力(作). 我们还是以上一个例子为例,这里的IStars接口和Stars类都不需要修改,只需要修改代理类. 创建JDK动态代理需要先实现InvocationHandler接口,并重写其中的invoke方法,具体步骤如下: 1. 创建一个类