jdk动态代理

代理设计模式

定义：为其他对象提供一种代理以控制对这个对象的访问。

代理模式的结构如下图所示。

动态代理使用

java动态代理机制以巧妙的方式实现了代理模式的设计理念。

代理模式示例代码

1.首先jdk动态代理无法摆脱的一个现实，就是必须要有一个抽象类，来将要代理的东西给抽象化（要干什么事情）

package jdk.dynastic.proxy;

public interface userService {
	public String getName(int id);
	
	public String getAge(int id);
}

2.设置一个要被代理的类userServiceImp，继承于接口 userService

package jdk.dynastic.proxy;

public class userServiceImp implements userService {

	@Override
	public String getName(int id) {
		
		System.out.println("----getName----");
		return "jdk";
	}

	@Override
	public String getAge(int id) {
		System.out.println("----getAge----");
		return "Age";
	}

}

3.要设置一个代理类，implement一个接口myInvocationHandler

package jdk.dynastic.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
//每一个动态代理类都必须要实现InvocationHandler这个接口，//
//并且每个代理类的实例都关联到了一个handler，当我们通过代理对象调用一个方法的时候，
//这个方法的调用就会被转发为由InvocationHandler这个接口的 invoke 方法来进行调用。
//我们来看看InvocationHandler这个接口的唯一一个方法 invoke 方法：
public class myInvocationHandler implements InvocationHandler {

	private Object target;//被代理的真实对象
	
	public myInvocationHandler(Object target) {
		super();
		this.target = target;
	}

	public myInvocationHandler() {
		super();
		// TODO Auto-generated constructor stub
	}

	/**
	 * proxy:是指我们所代理的那个真实对象
	 * method :指代的是我们所要调用真是对象的某个方法的Mothod对象
	 * args ：指代的是调用真是对象某个方法时接受的参数
	 */
	

	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		if("getName".equals(method.getName())){
			//添加自己所要加的操作
			System.out.println("---before---");
			 //  当代理对象调用真实对象的方法时，其会自动的跳转到代理对象关联的handler对象的invoke方法来进行调用
			//args时参数，暂时不用管理
			Object result=method.invoke(target, args);
			//添加自己所需要添加的操作
			System.out.println("---after---");
			return result;
		}
		else {
			//这里是通过代理对象来调用实现的那种接口中的方法，
			//这个时候程序就会跳转到由这个代理对象关联到的 handler 中的invoke方法去执行，
			//而我们的这个 handler 对象又接受了一个 RealSubject类型的参数，
			//表示我要代理的就是这个真实对象，所以此时就会调用 handler 中的invoke方法去执行：
			Object result=method.invoke(target, args);
			return result;
		}
		
	}

}

4.检测一下

package jdk.dynastic.proxy;

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

public class Main {
	public static void main(String[] args) {
         //创建被代理的几口实现类的对象
		        userService userService = new userServiceImp();  //父类对象对子类的对象的引用
		        InvocationHandler invocationHandler = new myInvocationHandler(userService);  
		        
		        /**
		         * jdk动态代理，要实现必须要有一个共同的接口
		         * 所要代理的应该是一个抽象的接口，里面有着共同的方法
		         * loader 获得被代理对象的类的加载器
		         * interfaces 获得被代理的类中的所需的所有接口，
		         * 		如果我提供了一组接口给它，那么这个代理对象就宣称实现了该接口(多态)，这样我就能调用这组接口中的方法了
		         * InvocationHandler h ：自定义代理的对象
		         * 		一个InvocationHandler对象，表示的是当我这个动态代理对象在调用方法的时候，会关联到哪一个InvocationHandler对象上
		         */
		        
		        //userServiceProxy被抽象的代理类的对象，调用代理方法
		        //可能我以为返回的这个代理对象会是userService类型的对象，或者是InvocationHandler的对象，
		        //结果却不是，首先我们解释一下为什么我们这里可以将其转化为userService类型的对象？
		        //原因就是在newProxyInstance这个方法的第二个参数上，我们给这个被代理对象提供了一组什么接口，
		        //那么我这个代理对象就会实现了这组接口，这个时候我们当然可以将这个代理对象强制类型转化为这组接口中的任意一个，
		        //因为这里的接口是userService类型，所以就可以将其转化为userService类型了。
		        userService userServiceProxy = (userService)Proxy.newProxyInstance(userService.getClass().getClassLoader(),  
		                userService.getClass().getInterfaces(), invocationHandler);  
		        
		        System.out.println(userServiceProxy);
		        
		        System.out.println(userServiceProxy.getName(1));  
		        System.out.println(userServiceProxy.getAge(1));  
		    
		
	}
}