反射动态代理与AOP

待我称王封你为后i 2022-08-23 03:52 215阅读 0赞

本文用到的知识点是动态代理和反射的知识，本文属于简单的应用demo，如果不熟悉知识点的盆友可以点击我[以前的文章][Link 1]，对于反射的底层实现有想了解的盆友可以点击[反射机制以及应用][Link 2]的文章。

本文主要就是用简单的实例讲解动态代理和反射的常用的应用AOP。

简而言之，AOP就是利用动态代理机制在一业务前面切向的加入特定的方法，本demo中

HumanUtil 是要切向加入的。有什么需要探讨的欢迎点击Q我吧相互交流O(∩_∩)O

AOP：Aspect Orient Programming

package myNetDemo;
    
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    
    import javax.xml.ws.spi.Invoker;
    
    interface Human {
    	void info();
    
    	void fly();
    }
    
    // 被代理类
    class SuperMan implements Human {
    
    	@Override
    	public void info() {
    		System.out.println("我是超人");
    
    	}
    
    	@Override
    	public void fly() {
    		// TODO Auto-generated method stub
    		System.out.println("我可以飞");
    	}
    
    }
    
    class HumanUtil {
    	public void method1() {
    		System.out.println("===方法一===");
    	}
    
    	public void method2() {
    		System.out.println("===方法二===");
    	}
    }
    
    class MyInvocationHandler1 implements InvocationHandler {
    	Object obj;// 被代理类对象的声明
    
    	public void setObject(Object obj) {
    		this.obj = obj;
    
    	}
    
    	@Override
    	public Object invoke(Object proxy, Method method, Object[] args)
    			throws Throwable {
    		HumanUtil hUtil = new HumanUtil();
    		hUtil.method1();
    
    		Object returnVal = method.invoke(obj, args);
    
    		hUtil.method2();
    		return returnVal;
    	}
    
    }
    
    // 动态的创建一个代理类的对象
    class myProxy {
    	public static Object getProxyInstance(Object obj) {
    		MyInvocationHandler1 handler1 = new MyInvocationHandler1();
    		handler1.setObject(obj);
    
    		return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj
    				.getClass().getInterfaces(), handler1);
    
    	}
    }
    
    public class TestAOP {
    	public static void main(String[] args) {
    		SuperMan man = new SuperMan();// 创建被代理类的对象
    		Object obj = myProxy.getProxyInstance(man);// 返回代理类的对象
    		Human h = (Human) obj;
    
    		// 通过代理类的对象调用重写的抽象方法
    		h.info();
    		System.out.println();
    		h.fly();
    		
    		System.out.println("***************");
    		
    		NikeClothFactory nike=new NikeClothFactory();
    		Object objj=myProxy.getProxyInstance(nike);
    		ClothesFactory clothesFactory=(ClothesFactory)objj;
    		clothesFactory.productCloth();
    
    	}
    }

package myNetDemo;
    
    //静态代理模式
    //接口
    interface ClothesFactory {
    	void productCloth();
    }
    
    // 被代理类
    class NikeClothFactory implements ClothesFactory {
    
    	@Override
    	public void productCloth() {
    		System.out.println("Nike工厂生产衣服");
    	}
    
    }
    
    // 代理类
    class ProxyFactory implements ClothesFactory {
    	ClothesFactory cf;// 虽然声明的是总接口，但实例化时实际传进去的是具体被代理实现类
    
    	// 在构造器内完成初始化
    	public ProxyFactory(ClothesFactory cf) {
    		this.cf = cf;
    	}
    
    	@Override
    	public void productCloth() {
    		System.out.println("代理类开始执行，收代理费");
    		cf.productCloth();// 实际调用的是实际被代理类的实现方法
    	}
    
    }
    
    public class TestProductClothes {
    	public static void main(String[] args) {
    		NikeClothFactory nikeClothFactory = new NikeClothFactory();// 创建被代理类的对象
    		ProxyFactory pFactory = new ProxyFactory(nikeClothFactory);// 创建爱你代理类的对象
    		pFactory.productCloth();// 实际调用的是被代理类方法
    
    		// 若再有一个接口，还要在于一个接口的实现类（被代理类，目标类），在造一个代理类实现接口
    		// 于是想要动态代理
    
    	}
    }

[Link 1]: http://blog.csdn.net/u010892841/article/details/51595497
[Link 2]: http://blog.csdn.net/u010892841/article/details/51596392