Java动态代理

1. 静态代理

1. 特征是代理类和目标对象的类都是在编译期间确定下来，不利于程序的扩展。同时，每一个代理类只能为一个接口服务，这样一来程序开发中必然产生过多的代理。
2. 最好可以通过一个代理类完成全部的代理功能

2. 动态代理

1. 动态代理是指客户通过代理类来调用其它对象的方法，并且是在程序运行时根据需要动态创建目标类的代理对象。
2. 动态代理使用场合:
   • 调试
   • 远程方法调用

3. 代理设计模式的原理:

使用一个代理将对象包装起来, 然后用该代理对象取代原始对象. 任何对原始对象的调用都要通过代理. 代理对象决定是否以及何时将方法调用转到原始对象上

4.Java动态代理实现相关类和方法、接口

1. Proxy ：专门完成代理的操作类，是所有动态代理类的父类。通过此类为一个或多个接口动态地生成实现类
2. 提供用于创建动态代理类和动态代理对象的静态方法
   • static Class<?> getProxyClass(ClassLoader loader, Class<?>… interfaces) 创建一个动态代理类所对应的Class对象
   • static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) 直接创建一个动态代理对象
     参数说明：
     • loader : 类加载器；
     • interfaces : 全部接口 ；
     • h 得到InvocationHandler接口的子类实例，通常为this；

5. java 动态代理步骤

这里建议看静态和动态的对比，后面会放两个demo
1.创建一个实现接口InvocationHandler的类，它必须实现invoke方法，以完成代理的具体操作。

	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		//method方法的返回值returnval
		Object returnval = method.invoke(obj, args);
		return returnval;
	}
	/*
		参数说明：proxy被代理类的对象
				   method调用的方法
				   args方法调用时所需要的参数
	*/

2.创建被代理的类以及接口

interface Subject{
	void action();
}
//被代理类
class RealSubject implements Subject{
	public void action() {
		System.out.println("我是被代理类，记得执行我哦~~");
	}
}

3.通过Proxy的静态方法

Object obj;//实现接口的被代理类的实现的声明
	//①给被代理类的对象实例化②返回一个代理类的对象
	public Object blind(Object obj) {
		this.obj = obj;
		return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), this);
	}

4.通过 Subject代理调用RealSubject实现类的方法

		//1.被代理类的对象
		RealSubject  real = new RealSubject();
		//2.创建一个实现了InvocationHandler接口的类的对象
		MyInvocationHandler handler = new MyInvocationHandler();
		//3.调用blind()方法，动态的返回一个同样实现了real所在类实现的接口Subject的代理类的对象
		Object obj = handler.blind(real);
		Subject sub = (Subject)obj;//此时sub就是代理类的对象
		//注：必须强转否则编译情况下看不到接口的方法
		sub.action();//转到对InvocationHandler接口的实现类的invoke方法中
	

6. java 动态代理

//动态代理的使用
interface Subject{
	void action();
}
//被代理类
class RealSubject implements Subject{
	public void action() {
		System.out.println("我是被代理类，记得执行我哦~~");
	}
}
class MyInvocationHandler implements InvocationHandler{
	Object obj;//实现接口的被代理类的实现的声明
	//①给被代理类的对象实例化②返回一个代理类的对象
	public Object blind(Object obj) {
		this.obj = obj;
		return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), this);
	}
	//当通过代理类的对象发起对呗重写的方法的调用时，都为转化为对如下invoke方法的调用
	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		//method方法的返回值returnval
		Object returnval = method.invoke(obj, args);
		return returnval;
	}
	
}
public class TestProxy {
	public static void main(String[] args) {
		//1.被代理类的对象
		RealSubject  real = new RealSubject();
		//2.创建一个实现了InvocationHandler接口的类的对象
		MyInvocationHandler handler = new MyInvocationHandler();
		//3.调用blind()方法，动态的返回一个同样实现了real所在类实现的接口Subject的代理类的对象
		Object obj = handler.blind(real);
		Subject sub = (Subject)obj;//此时sub就是代理类的对象
		//注：必须强转否则编译情况下看不到接口的方法
		sub.action();//转到对InvocationHandler接口的实现类的invoke方法中
	
		//再接一个例子
		NikeClothFactory nike = new NikeClothFactory();
		ClothFactory proxyCloth = (ClothFactory)handler.blind(nike);//proxyCloth即为代理类的对象
		proxyCloth.productCloth();
	}
}

7.java 静态代理

//静态代理模式
//接口
interface ClothFactory{
	void productCloth();
}
//被代理类
class NikeClothFactory implements ClothFactory{
	@Override
	public void productCloth() {
		System.out.println("Nike工厂生产一批衣服");
	}	
}
//代理类
class ProxyFactory implements ClothFactory{
	ClothFactory cf;
	//创建代理的对象时，实际传入一个被代理的对象
	public ProxyFactory(ClothFactory cf) {
		this.cf = cf;
	}

	@Override
	public void productCloth() {
		System.out.println("代理类开始执行，收代理费$xxx");
		cf.productCloth();
	}
	
}
public class TestClothProduct {
	public static void main(String[] args) {
		//创建被代理类的对象
		NikeClothFactory nike = new NikeClothFactory();
		ProxyFactory proxy = new ProxyFactory(nike);
		proxy.productCloth();
	}
}