静态代理/动态代理

动态代理----反射的应用,提货反射的动态性.

代理设计模式的原理:

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

静态代理:

        要求被代理类和代理类同时实现相应的接口:通过被代理类的对象调用重写接口的方法时,实际上执行的是被代理类的同样的方法的调用.

动态代理:

        在程序的运行时,根据被代理类以及其实现的接口,动态的创建一个代理类.当调用代理类的实现的抽象方法时,就发起对被代理类同样的方法的调用.

        涉及到的技术点:

        1)提供一个实现了InvocationHandler接口实现类,并重写其invoke()方法.

         2)Proxy.newProxyInstance(obj.getClass(),getClassLoader(),         obj.getClass.getInterfaces(),                   h)

          注意:obj:被代理类对象               h:实现了InvocationHandler接口的实现类的对象.

静态代理

package com.derby.aopbasic;

//静态代理模式
interface ClothFactory {
	void productCloth();
}

// 被代理类
class NikeClothFactory implements ClothFactory {
	@Override
	public void productCloth() {
		System.out.println("Nike工厂生产了一匹衣服!!!");
	}
}

// 代理类
class ProxyFactory implements ClothFactory {
	ClothFactory cf;

	// 创建代理类的对象时,实际上传入一个被代理类的对象
	ProxyFactory(ClothFactory cf) {
		this.cf = cf;
	}

	@Override
	public void productCloth() {
		System.out.println("代理类开始执行,收取代理费$1000!!!");
		cf.productCloth();
	}
}

public class StaticAOP {
	public static void main(String[] args) {
		// 创建被代理类对象
		NikeClothFactory nike = new NikeClothFactory();
		// 创建代理类对象
		ProxyFactory proxy = new ProxyFactory(nike);
		proxy.productCloth();
	}
}

动态代理:

package com.derby.aopbasic;

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

//动态代理的使用,体会反射是动态语言的关键
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;
		// Proxy.newProxyInstance(loader, interfaces, h)
		return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj
				.getClass().getInterfaces(), this);
	}

	// 通过代理类的对象发起对被重写的方法的调用时,都会转换为对如下invoke方法的调用
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		// method方法的返回值是returnVal
		Object returnVal = method.invoke(obj, args);// invoke(Object obj,Object... args)													// 
		return returnVal;
	}
}

public class TestProxy {
     public static void main(String[] args) {
		//1.被代理类的对象
        RealSubject real = new RealSubject();
        //2.创建一个实现了InvacationHandler接口的类的对象
        MyInvocationHandler handler = new MyInvocationHandler();
        //3.调用blind()方法,动态的返回一个同样实现了real所在类实现的接口Subject的代理类的对象.
        Object obj = handler.blind(real);
        Subject sub = (Subject) obj;//此时sub就是代理类的对象
        sub.action();//转到InvacationHandler接口的实现类的invoke()方法的调用
        
        
        //再举一例
        NikeClothFactory nike = new NikeClothFactory();
        ClothFactory proxyCloth = (ClothFactory) handler.blind(nike);//proxyCloth即为代理类的对象
        proxyCloth.productCloth();
        
	}
}

TestAOP

package com.derby.aopbasic;

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

interface Human {
	void info();

	void fly();
}

// 被代理类
class SuperMan implements Human {
	@Override
	public void info() {
		System.out.println("我是超人!!!");
	}

	@Override
	public void fly() {
		System.out.println("I believe I can fly!!!");
	}
}

class HumanUtil {
	public void methodBefore() {
		System.out.println("=====before======");
	}

	public void methodAfter() {
		System.out.println("=====After======");
	}
}

class MyInvocationHandler1 implements InvocationHandler {
	Object obj;// 被代理类对象的声明

	public void setObj(Object obj) {
		this.obj = obj;
	}

	@Override
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		HumanUtil h = new HumanUtil();
		h.methodBefore();
		Object returnVal = method.invoke(obj, args);
		h.methodAfter();
		return returnVal;
	}
}

class MyProxy {
	// 动态的创建一个代理类的对象
	public static Object getProxyInstance(Object obj) {
		MyInvocationHandler1 handler = new MyInvocationHandler1();
		handler.setObj(obj);

		return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj
				.getClass().getInterfaces(), handler);
	}
}

public class TestAOP {
	public static void main(String[] args) {
		SuperMan man = new SuperMan();// 创建一个被代理类的对象
		Object obj = MyProxy.getProxyInstance(man);// 返回一个代理类的对象
		Human hu = (Human) obj;//can't bet SuperMan 
		// java.lang.ClassCastException
		// com.derby.aopbasic.$Proxy0 cannot be cast to com.derby.aopbasic.SuperMan
		hu.info();
		hu.fly();		
		
		//*********
		NikeClothFactory nike = new NikeClothFactory();
		Object obj1 = MyProxy.getProxyInstance(nike);
		ClothFactory cloth = (ClothFactory)obj1;
		cloth.productCloth();
	}

}