AOP解密-----实时动态AOP

超、凢脫俗 2022-07-15 12:59 204阅读 0赞

在上篇博客中个，咱们一起组建了一个容器，里面封装了业务，这样，咱们就将业务和服务的组装放到了客户端，而客户端就相当于咱们的开发中使用到的配置文件，大家发现问题了吗？就是我不能动态改动了？业务容器在代理完成后，重新添加一个业务类，这时候，是不被允许的，那这个容器就是个编译时起作用的容器，他就丧失了很多的灵活性！ 那怎么办呢？实际就是调换一下调用顺序就好，大家看看结果：

# 1，类图对比 #

![旧版的系统][20150630001110233]

改造后的类图

![改造后的图][20150630002002900]

# 2，代码实现： #

## 2.1代理类的变化： ##

public class CGLibDynamicProxy implements MethodInterceptor {
    	// 服务类容器
    	private IProxyMethods proxyMehds;
    	// 代理工厂类：单例模式，优化内存开销
    	private static CGLibDynamicProxy instance = new CGLibDynamicProxy();
    	// 构造函数
    	private CGLibDynamicProxy() {
    	}
    	// 获取cglib代理工厂类
    	public static CGLibDynamicProxy getInstance() {
    		return instance;
    	}
    	/**
    	 * 使用代理工厂生成某个类的代理
    	 * 
    	 * @param cls
    	 *            要代理的类
    	 * @return 返回已经代理好的类
    	 */
    	@SuppressWarnings("unchecked")
    	public <T> T getProxy(Class<T> cls) {
    		return (T) Enhancer.create(cls, this);
    	}
    	// 重写被代理对象的方法执行
    	// 所有的方法执行，到反射的级别都是invoke，重写了这个方法，就重写了所有的方法执行，实现了代理
    	@Override
    	public Object intercept(Object target, Method method, Object[] args,
    			MethodProxy proxy) throws Throwable {
    		// 重要改进：从服务容器中执行方法，不再是写死的！
    		proxyMehds.beforeBean();
    		// 方法正常执行的语句
    		Object result = proxy.invokeSuper(target, args);
    		// 重要改进：从服务容器中执行方法，不再是写死的！
    		proxyMehds.afterBean();
    		return result;
    	}
    	// 服务容器的get方法
    	public IProxyMethods getProxyMehds() {
    		return proxyMehds;
    	}
    	// 服务容器的set方法
    	public void setProxyMehds(IProxyMethods proxyMehds) {
    		this.proxyMehds = proxyMehds;
    	}
    }

## 2.2业务容器 ##

public class DoMehds implements IDoMehds {
    	// 盛放执行业务的map
    	private HashMap<String, Object> DoBeans;
    	// 代理类
    	private CGLibDynamicProxy proxy;
    	/**
    	 * 封装获取元素的方法，每次获取元素都封装一个代理
    	 * 
    	 * @param 元素的名字
    	 * @return 代理好的元素
    	 */
    	public Object getBean(String beanName) {
    		return proxy.getProxy(DoBeans.get(beanName).getClass());
    	}
    	// 获取业务map
    	public HashMap<String, Object> getDoBeans() {
    		return DoBeans;
    	}
    	// 设置业务map
    	public void setDoBeans(HashMap<String, Object> doBeans) {
    		DoBeans = doBeans;
    	}
    	// 获取代理类
    	public CGLibDynamicProxy getProxy() {
    		return proxy;
    	}
    	// 设置代理类
    	public void setProxy(CGLibDynamicProxy proxy) {
    		this.proxy = proxy;
    	}
    }

## 2.3 客户端 ##

public class Client {
    	public static void main(String[] args) {
    
    		// 存放服务的容器
    		HashMap<String, Object> beforBeans;
    		HashMap<String, Object> afterBeans;
    
    		// 存放服务容器中类，要执行的方法
    		HashMap<String, String> beforMethods;
    		HashMap<String, String> afterMethods;
    
    		beforBeans = new HashMap<String, Object>();
    		beforMethods = new HashMap<String, String>();
    		beforBeans.put("AspectClassOne", new AspectClassOne());
    		beforBeans.put("AspectClassTwo", new AspectClassTwo());
    		beforMethods.put("AspectClassOne", "sayOne");
    		beforMethods.put("AspectClassTwo", "sayTwo");
    
    		afterBeans = new HashMap<String, Object>();
    		afterMethods = new HashMap<String, String>();
    		afterBeans.put("AspectClassThree", new AspectClassThree());
    		afterBeans.put("AspectClassFour", new AspectClassFour());
    		afterMethods.put("AspectClassThree", "sayThree");
    		afterMethods.put("AspectClassFour", "sayFour");
    
    		// 用于存放服务容器的接口
    		ProxyMehds proxyMehds = new ProxyMehds();
    		proxyMehds.setBeforBeans(beforBeans);
    		proxyMehds.setBeforMethods(beforMethods);
    		proxyMehds.setAfterBeans(afterBeans);
    		proxyMehds.setAfterMethods(afterMethods);
    
    		// 用于存放业务类的容器
    		// 实例业务map
    		HashMap<String, Object> DoBeansMap = new HashMap<String, Object>();
    		// 将业务装载到map中
    		DoBeansMap.put("greetingImpl", new GreetingImpl());
    		DoBeansMap.put("eat", new Eat());
    		// 将业务map装载到容器中
    		DoMehds doMehds = new DoMehds();
    		doMehds.setDoBeans(DoBeansMap);
    
    		// 实例代理类
    		CGLibDynamicProxy cglib = CGLibDynamicProxy.getInstance();
    
    		// 接受切面
    		cglib.setProxyMehds(proxyMehds);
    
    		// 在服务容器里面，增加动态代理类
    		doMehds.setProxy(cglib);
    
    		// 获取代理对象
    		GreetingImpl greetingImpl = (GreetingImpl) doMehds
    				.getBean("greetingImpl");
    		Eat eat = (Eat) doMehds.getBean("eat");
    
    		// 使用代理对象
    		greetingImpl.sayHello("Jack");
    		System.out.println();
    		eat.eating();
    		System.out.println();
    		// 动态增加业务类
    		doMehds.getDoBeans().put("a", new A());
    		A a = (A) doMehds.getBean("a");
    		a.a();
    
    	}
    }

## 2.4 测试结果 ##

AspectClassTwo sayTwo ... 
    Hello! Jack
    AspectClassFour sayFour ... 
    AspectClassThree sayThree ... 
    
    AspectClassOne sayOne ... 
    AspectClassTwo sayTwo ... 
    Eat eating ...
    AspectClassFour sayFour ... 
    AspectClassThree sayThree ... 
    
    AspectClassOne sayOne ... 
    AspectClassTwo sayTwo ... 
    a ...
    AspectClassFour sayFour ... 
    AspectClassThree sayThree ...

2.5 原文博客地址

http://blog.csdn.net/xvshu/article/details/46689237

2.6 源码下载

[20150630001110233]: /images/20220715/311cb61a1ae3491f9164f60129940f26.png
[20150630002002900]: /images/20220715/8959d4e671944455a39ef9bd0ccc341b.png