AOP解密-----用接口改造AOP

分手后的思念是犯贱 2022-07-15 12:38 155阅读 0赞

优化是个无止境的工作，在AOP的路上，我们走得很远，但是还有很多的工作，我们没有做，比如，将aop的业务部分封装成容器，将aop的服务部分改造成面向接口的，这样就不受具体的形式上的限制了！这样AOP的优化，就又前进了一步，也是符合咱们的面向接口编程的思想，下面就和我一起研究下如何将接口的思想融入到aop的实现中。

# 回顾： #

在上篇博客中，我们将aop的服务封装到了容器中：

![20161116225725217][]

**这样的好处就是我们可以使用配置文件扩展服务类，服务类不再受限于具体的形式与方法，而我们封装的服务类和动态代理，构成了这样的一个AOP实现：**

![Center][]

**而这样的实现，我们还要依赖具体的容器，不利于我们扩展，如果我们想换容器怎么办？我们就要重构我们的代码，这不是我们程序设计中想要的，我们可以利用接口来屏蔽掉具体容器的使用，让aop可以定制容器，**如何实现？其实很简单，大家看：

**1. 类图改造**

**![20161116230914441][]**

**2.公共服务接口**

public interface IProxyMethods {
    	// 用于遍历之前执行的方法
    	public void beforeBean();
    	// 用于遍历之后执行的方法
    	public void afterBean();
    }

**3.共服务容器类**

/**
     * 将服务进行封装
     */
    public class ProxyMehds implements IProxyMethods {
    	// 盛放方法执行的对象的容器
    	private HashMap<String, Object> beforBeans;
    	private HashMap<String, Object> afterBeans;
    
    	// 配制上面对象容器中的每个对象，哪些方法需要执行
    	private HashMap<String, String> beforMethods;
    	private HashMap<String, String> afterMethods;
    
    	// 用于遍历之前执行的方法
    	public void beforeBean() {
    		try {
    			for (Entry<String, Object> entry : beforBeans.entrySet()) {
    				String objectKey = entry.getKey();
    				Object objectValure = entry.getValue();
    				Method beforMehod = objectValure.getClass().getMethod(
    						beforMethods.get(objectKey));
    				beforMehod.invoke(objectValure);
    			}
    		} catch (Exception ex) {
    			ex.printStackTrace();
    		}
    	}
    	// 用于遍历之后执行的方法
    	public void afterBean() {
    		try {
    			for (Entry<String, Object> entry : afterBeans.entrySet()) {
    				String objectKey = entry.getKey();
    				Object objectValure = entry.getValue();
    				Method beforMehod = objectValure.getClass().getMethod(
    						afterMethods.get(objectKey));
    				beforMehod.invoke(objectValure);
    			}
    		} catch (Exception ex) {
    			ex.printStackTrace();
    		}
    	}
    	public HashMap<String, Object> getBeforBeans() {
    		return beforBeans;
    	}
    	public void setBeforBeans(HashMap<String, Object> beforBeans) {
    		this.beforBeans = beforBeans;
    	}
    	public HashMap<String, Object> getAfterBeans() {
    		return afterBeans;
    	}
    	public void setAfterBeans(HashMap<String, Object> afterBeans) {
    		this.afterBeans = afterBeans;
    	}
    	public HashMap<String, String> getBeforMethods() {
    		return beforMethods;
    	}
    	public void setBeforMethods(HashMap<String, String> beforMethods) {
    		this.beforMethods = beforMethods;
    	}
    	public HashMap<String, String> getAfterMethods() {
    		return afterMethods;
    	}
    	public void setAfterMethods(HashMap<String, String> afterMethods) {
    		this.afterMethods = afterMethods;
    	}
    }

**4.CGLIB动态代理的代码**

public class CGLibDynamicProxy implements MethodInterceptor {
    	private static CGLibDynamicProxy instance = new CGLibDynamicProxy();
    	private IProxyMethods proxyMehds;
    	private CGLibDynamicProxy() {
    	}
    	public static CGLibDynamicProxy getInstance() {
    		return instance;
    	}
    	@SuppressWarnings("unchecked")
    	public <T> T getProxy(Class<T> cls) {
    		return (T) Enhancer.create(cls, this);
    	}
    	@Override
    	public Object intercept(Object target, Method method, Object[] args,
    			MethodProxy proxy) throws Throwable {
    		proxyMehds.beforeBean();
    		Object result = proxy.invokeSuper(target, args);
    		proxyMehds.afterBean();
    		System.out.println("");
    		return result;
    	}
    	public IProxyMethods getProxyMehds() {
    		return proxyMehds;
    	}
    	public void setProxyMehds(ProxyMehds proxyMehds) {
    		this.proxyMehds = proxyMehds;
    	}
    }

**5.客户端**

客户端代码并没有发生任何变化：

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);
    
    		// 实例代理类
    		CGLibDynamicProxy cglib = CGLibDynamicProxy.getInstance();
    
    		// 接受切面
    		cglib.setProxyMehds(proxyMehds);
    
    		// 接受要代理的对象
    		Greeting greeting = cglib.getProxy(GreetingImpl.class);
    
    		// 执行对象的某个方法
    		greeting.sayHello("Jack");
    
    	}
    }

6、参考博客地址

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

总结：

大家看看这一路的变化，我们不难发现，在我们的AOP优化之路上，我们走得和其他博客不太一样，我们在这里实际就做了一件事，将耦合解开，将解开耦合的类封装到容器中，将容器抽象为一个接口，这样的道路，是不是和哪些理念靠近了呢？对？就是咱们的设计模式，在设计模式中，我们抽象了23种设计模式，其实就是为了解耦和，然后将耦合封装到运行时装配！

大道至简，在优化的道路上，比较好的指导思想就是简化，傻瓜化，就像蜂群一样，每个蜜蜂做一件简单的事情，一个蜂群就可以完成一个极其复杂的社会活动！

[20161116225725217]: /images/20220715/05634791c10f4bb48457f5136c623ab4.png
[Center]: /images/20220715/eb4b6ec22468402da9620d8a938d375b.png
[20161116230914441]: /images/20220715/a6511fcd770b4b469e11c40b384ee297.png