带你重新认识Java动态代理

目录

• 什么是动态代理" title="动态代理">动态代理？
• 动态代理的常用两种方式：

• 1.基于接口的动态代理
• 2.基于类的动态代理

//JDK动态代理(基于接口的动态代理)
Proxy.newProxyInstance(三个参数);
	ClassLoader:类加载器
		它是用于加载代理对象字节码的。和被代理对象使用相同的类加载器。（固定写法）
	Class[]:字节码数组
		它是用于让代理对象和被代理对象有相同方法。(固定写法)
	InvocationHandler：用于提供增强的代码
		它是让我们写如何代理。我们一般都是写一个该接口的实现类，通常情况下都是匿名内部类，但不是必须
		InvocationHandler该接口的实现类是谁用谁写，此时我们用就需要我们自己写

package com.haust.service;
public interface IActor {
	/**
	* 基本演出
	* @param money
	*/
	public void basicAct(float money);
	/**
	* 危险演出
	* @param money
	*/
	public void dangerAct(float money);
}

package com.haust.serviceImpl;
import com.haust.service.IActor;
public class Actor implements IActor {
	/**
	* 一个演员
	*/
	//实现了接口，就表示具有接口中的方法实现。即：符合经纪公司的要求
	@Override
	public void basicAct(float money) {
		System.out.println("拿到钱，开始基本的表演："+money);
	}
	@Override
	public void dangerAct(float money) {
		System.out.println("拿到钱，开始危险的表演："+money);
	}
}

package com.haust.test;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import com.haust.service.IActor;
import com.haust.serviceImpl.Actor;
public class Client {
	public static void main(String[] args) {
		//一个剧组找演员：
		final Actor actor = new Actor();//被代理的类
		/**
		* 代理：
		* 间接。
		* 获取代理对象：
		* 要求：
		* 被代理类最少实现一个接口
		* 创建的方式
		* Proxy.newProxyInstance(三个参数)
		* 参数含义：
		* ClassLoader：和被代理对象使用相同的类加载器。
		* Interfaces：和被代理对象具有相同的行为。实现相同的接口。
		* InvocationHandler：如何代理。
		* 
		*/
		//(IActor)Proxy.newProxyInstance,这里强制转换必须是接口类型
		IActor proxyActor = (IActor)Proxy.newProxyInstance(actor.getClass().getClassLoader(),
				 actor.getClass().getInterfaces(),
				 new InvocationHandler() {
			 /**
			 * 执行被代理对象的任何方法，都会经过该方法。
			 * 此方法有拦截的功能。
			 * 
			 * 参数：
			 * proxy：代理对象的引用。不一定每次都用得到
			 * method：当前执行的方法对象
			 * args：执行方法所需的参数
			 * 返回值：
			 * 当前执行被代理对象方法的返回值
			 */
					@Override
					public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
						String name = method.getName();
						Float money = (Float) args[0];//执行的方法只有一个参数
						Object rtValue = null;
						//每个经纪公司对不同演出收费不一样，此处开始判断
						if("basicAct".equals(name)){
						//基本演出，没有 2000 不演
						if(money > 2000){
						//看上去剧组是给了 8000，实际到演员手里只有 4000
						//这就是我们没有修改原来 basicAct 方法源码，对方法进行了增强
						rtValue = method.invoke(actor, money/2);
						} }
						if("dangerAct".equals(name)){
						//危险演出,没有 5000 不演
						if(money > 5000){
						//看上去剧组是给了 50000，实际到演员手里只有 25000
						//这就是我们没有修改原来 dangerAct 方法源码，对方法进行了增强
						rtValue = method.invoke(actor, money/2);
						} }
						return rtValue;
					}
				});
		//没有经纪公司的时候，直接找演员。
		// actor.basicAct(1000f);
		// actor.dangerAct(5000f);
		//剧组无法直接联系演员，而是由经纪公司找的演员
		proxyActor.basicAct(2000f);//价格低于2000不演
		proxyActor.dangerAct(50000f);
	}
}

设计的类：Enhancer
提供者：第三方cglib库
如何创建代理对象：
	使用Enhancer类中的create方法
创建代理对象的要求：
	被代理对象不是最终类(最终类没有子类)
create方法的参数：
	Class方法的参数：
		Class：字节码
			它是用于指定被代理对象的字节码
		callback：用于提供增强的代码
			它是让我们写如何代理。我们一般都是些一个该接口的实现类，通常情况下都是匿名内部类，但不是必须的。此接口的实现类都是谁用谁写。
			我们一般写的都是该接口的子接口实现类:MethodInterceptor
//CGLib动态代理(基于子类的动态代理)
Enhancer.create(两个参数);

package com.haust.serviceImpl;
public class Actor{//没有实现任何接口
	/**
	* 一个演员
	*/
	public void basicAct(float money) {
		System.out.println("拿到钱，开始基本的表演："+money);
	}
	public void dangerAct(float money) {
		System.out.println("拿到钱，开始危险的表演："+money);
	}
}

package com.haust.test;
import java.lang.reflect.Method;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
import com.haust.serviceImpl.Actor;
public class test {
	public static void main(String[] args) {
		 Actor actor = new Actor();//需要创建此被代理的对象
		 /**
		 * 基于子类的动态代理
		 * 要求：
		 * 被代理对象不能是最终类
		 * 用到的类：
		 * Enhancer
		 * 用到的方法：
		 * create(Class, Callback)
		 * 方法的参数：
		 * Class：被代理对象的字节码
		 * Callback：如何代理
		 * @param args
		 */
		 //此时强转的类的类型就是被代理类的类型
		 Actor cglibActor = (Actor)Enhancer.create(actor.getClass(),new MethodInterceptor() {
			@Override
			public Object intercept(Object proxy, Method method, Object[] args, MethodProxy  methodProxy) throws Throwable {
				/**
				* 执行被代理对象的任何方法，都会经过该方法。在此方法内部就可以对被代理对象的任何
				方法进行增强。
				* 
				* 参数：
				* 前三个和基于接口的动态代理是一样的。
				* MethodProxy：当前执行方法的代理对象。
				* 返回值：
				* 当前执行方法的返回值
				*/
				String name = method.getName();
				Float money = (Float) args[0];
				Object rtValue = null;
				if("basicAct".equals(name)){
				//基本演出
				if(money > 2000){
				rtValue = method.invoke(actor, money/2);
				} }
				if("dangerAct".equals(name)){
					//危险演出
					if(money > 5000){
					rtValue = method.invoke(actor, money/2);
					} 
				}
				return rtValue;
			}
		});
		 cglibActor.basicAct(10000);
		 cglibActor.dangerAct(100000);
	}
}