java代理模式

1、静态代理

使用聚合的形式实现，而不使用继承形式，因为继承形式不灵活。
使用聚合形式，标本对象和代理对象需要实现统一的接口，代理对象中还需要持有一个该接口的引用。

服务接口类：

package com.proxy;

public interface ProxyService {

	public void say(String word);
	
}

目标类：

package com.proxy;

public class Target implements ProxyService{

	@Override
	public void say(String word) {
		System.out.println("target say " + word);
	}

}

代理类：

package com.proxy;

import java.time.LocalDateTime;

public class Proxy implements ProxyService{
	
	private ProxyService proxyService;
	
	public Proxy(ProxyService proxyService) {
		this.proxyService = proxyService;
	}

	@Override
	public void say(String word) {
		System.out.println("proxy start..." + LocalDateTime.now());
		proxyService.say(word);
		System.out.println("proxy end...." + LocalDateTime.now());
	}

}

测试：

package com.proxy;

public class TestProxy {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Target target = new Target();
		Proxy proxy = new Proxy(target);
		proxy .say("hahahahahah");
	}
}

输出：

proxy start...2019-09-25T13:08:50.552
target say i am a javacoder
proxy end....2019-09-25T13:08:50.552

使用静态代理，有点是简单，逻辑清晰，缺点是代码重用性不高，不同的服务都需要生成一个代理对象，一些服务的处理可能相同。

2、动态代理

需要一个实现了InvocationHandler接口的实例，称它为中介对象，然后将目标对象绑定到该中介对象上，中介对象会根据目标对象的一些信息使用jdk生成一个代理对象，该代理对象和目标对象含有相同的方法，但是代理对象的方法最终会调用中介对象的invoke方法，而invoke方法中包含了服务的执行和执行前后的处理。

目标类和服务接口不变

实现了InvocationHandler的类，ProxyHandler：

package com.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.time.LocalDateTime;


public class ProxyHandler implements InvocationHandler{
	private Object target;
	
	public Object bind(Object object) {
		this.target = object;
		return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
	}
	
	
	@Override
	public Object invoke(Object obj, Method method, Object[] args) throws Throwable {
		System.out.println("dynaProxy start....." + LocalDateTime.now());
		method.invoke(target, args);
		System.out.println("dynaProxy end....." + LocalDateTime.now());
		
		return null;
	}

}

测试：

package com.proxy;

/**
 * 动态代理，实现InvocationHandler的类,用于产生代理对象和进行回调处理
 * 
 * 调用流程：
 * -->生成目标对象
 * -->生成实现InvocationHandler的类的对象，称为中介对象吧
 * -->使用中介对象绑定目标对象，return一个代理对象(代码无需自己写，jdk生成，只需要相应参数)
 * -->代理对象调用与目标对象相同名字的方法，实际上调用的是经过加工的方法
 * -->经过加工的方法调用实现InvocationHandler的类的invoke方法
 * -->在invoke中调用目标对象的方法，调用前后可以进行逻辑处理
 * 
 * @author Administrator
 *
 */
public class TestProxy {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Target target = new Target();
		ProxyHandler handler= new ProxyHandler();
		ProxyService service = (ProxyService) handler.bind(target);
		service.say("i am a javacoder");
	}

}

输出：

dynaProxy start.....2019-09-25T13:25:07.485
target say i am a javacoder
dynaProxy end.....2019-09-25T13:25:07.485

使用动态代理很好的解决了静态代理不能进行代码复用的确定，其缺点是过程复杂。。。