Java代理模式

        代理模式是一种结构型设计模式，它为目标对象提供一种代理，用来控制对目标对象的访问。代理对象在客户端和目标对象之间起到中介的作用。客户端通过代理对象间接地访问目标对象，而不需要直接与目标对象进行交互。可以在不改变目标对象内容的前提下，通过代理对象扩展目标对象的行为逻辑。

根据代理创建的时期，代理模式可以分为：

        ①静态代理：以硬编码的方式，手动定义创建的代理类。
        ②动态代理：代理类是在运行时动态创建的，在K的核心类库中，可以使用Java.lang.reflect.Proxy 类和InvocationHandler 接来生成动态代理。

代理模式的应用场景：
        在 MyBatis 框架中，运行期间，为每个Mapper接口都会产生一个动态代理，完成映射 s
的数据库操作执行。
        在 spring 框架中， AOP 面向切面编程是基于动态代理实现。

静态代理：

先创建一个UserService接口，内部定义select()和update()方法； 

public interface UserService {
	public void select();
	public void update();
}

创建一个UserServiceImpl类实现UserService接口； 

public class UserServiceImpl implements UserService{

	@Override
	public void select() {
		System.out.println("实现了select()方法");
		
	}

	@Override
	public void update() {
		System.out.println("实现了update()方法");
		
	}

}

创建UserServiceProxy代理类实现UserService接口；

package com.ape.demo;

public class UserServiceProxy implements UserService{

	private UserServiceImpl userserviceimpl = new UserServiceImpl();
	
	@Override
	public void select() {
		
		long begin = System.currentTimeMillis();
		
		userserviceimpl.select();
		
		long end = System.currentTimeMillis();
		System.out.println("select执行耗时"+(end-begin)+"s");
	}

	@Override
	public void update() {
		userserviceimpl.update();
		
	}

}

测试： 

public class Test {
	public static void main(String[] args) {
		
		UserServiceProxy realuserservice = new UserServiceProxy();
		realuserservice.select();
		realuserservice.update();
	}
}

运行结果：

动态代理：

分别创建Order接口和UserService接口，并定义内部方法；

public interface Order {
	public void create(double money,int uuid);
}

public interface UserService {
	public void select();
	public void update();
}

分别创建两个接口的实现类； 

public class OrderImpl implements Order{
	@Override
	public void create(double money,int uuid) {
		System.out.println("实现了order的create()方法");
	}
}

public class UserServiceImpl implements UserService{
	@Override
	public void select() {
		System.out.println("实现了select()方法");
	}
	@Override
	public void update() {
		System.out.println("实现了update()方法");	
	}
}

创建一个 PerformanceInvocationHandler类用于实现InvocationHandler

public class PerformanceInvocationHandler implements InvocationHandler{
	
	private Object real;
	
	public PerformanceInvocationHandler(Object real) {
		this.real=real;
	}

	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		long begin = System.currentTimeMillis();
		
		//真是业务对象当前的执行方法（基于反射的方式）
		Object returnValue = method.invoke(real, args);
		
		long end = System.currentTimeMillis();
		System.out.println(method.getName()+"select执行耗时"+(end-begin)+"ms");
		
		return returnValue;
	}
	

}

分别创建测试类进行测试： 

public class Test01 {
	public static void main(String[] args) {
		//真实主题对象
		OrderImpl realorderservice = new OrderImpl();
		
		//获取类加载器
		ClassLoader classLoader = realorderservice.getClass().getClassLoader();
		
		//接口列表
		Class[] interfaces = realorderservice.getClass().getInterfaces();
		
		//创建InvocationHandler对象（动态代理的执行逻辑）
		PerformanceInvocationHandler h = new PerformanceInvocationHandler(realorderservice);
		
		//创建一个代理对象（动态代理对象）
		Order orderServiceProxy = (Order)Proxy.newProxyInstance(classLoader, interfaces, h);
		
		//调用方法
		orderServiceProxy.create(820528,0112);
	}
}

public class Test02 {
	public static void main(String[] args) {
		//真实主题对象
		UserServiceImpl realuserservice = new UserServiceImpl();
		
		//获取类加载器
		ClassLoader classLoader = realuserservice.getClass().getClassLoader();
		
		//接口列表
		Class[] interfaces = realuserservice.getClass().getInterfaces();
		
		//创建InvocationHandler对象（动态代理的执行逻辑）
		PerformanceInvocationHandler h = new PerformanceInvocationHandler(realuserservice);
		
		//创建一个代理对象（动态代理对象）
		UserService userServiceProxy = (UserService)Proxy.newProxyInstance(classLoader, interfaces, h);
		
		//调用方法
		userServiceProxy.select();
		userServiceProxy.update();
	}
}

测试：