java架构解密——深入再造AOP

在上篇博客中，大家和我一起研究了AOP的基本实现，但是，也给大家遗留了很多问题，在这篇博客，咱们一起研究如何针对这些问题进行持续的优化，看看在咱们的手里，AOP会成长为一个什么样的东西！

回顾：

看看上篇博客中，咱们一起实现的AOP类图：



咱们看看在CGLIB类里的问题

<span style="font-size:18px;">public class CGLibDynamicProxy implements MethodInterceptor {  
 
    private static CGLibDynamicProxy instance = new CGLibDynamicProxy();  
 
    
    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 {  
        before();  
        Object result = proxy.invokeSuper(target, args);  
        after();  
        return result;  
    }  
 
  private void before() {  
        System.out.println("Before");  
    }  
 
    private void after() {  
        System.out.println("After");  
    } 
	
	
}

1，扩展服务

这样我们的扩展就会变得困难，大家试想一下这个场景，我们写好的业务，需要增加一个功能，就要写一个代理类，功能的变化，也必须修改代码，这就给我们的代码维护带来了很大的负担！如果我们要第一次要扩展2个方法，写了代理，下一次扩展3个，写了代理，下一次扩展1个写了代理，下一次不想要第一次的第2个方法了，怎么办？的确，这样的维护，是我们不想看到的，所以，我们将扩展的公共服务放到了一个容器中，大家看类图：

1.1封装公共服务类：

<span style="font-size:18px;">public class ProxyMehds  {
	//盛放方法执行前的对象的容器
	private  HashMap<String,Object> beforBeans;
    private  HashMap<String,Object> afterBeans;
	
    //配制方法执行前要执行哪些方法
	private  HashMap<String,String> beforMethods;
    private  HashMap<String,String> afterMethods;
    
    @Override
    public void beforeBean()  {  
    	
    	
    	try{
    		
    	
	    	for (HashMap.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();
    	}
    	//Method sAge = c.getMethod("setAge");
    }  
 
    @Override
    public void afterBean() {  
    
    	try{
    		
    	
	    	for (HashMap.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;
	}

	
}</span>

1.2封装代理类：

<span style="font-size:18px;">public class CGLibDynamicProxy implements MethodInterceptor {  
 
    private static CGLibDynamicProxy instance = new CGLibDynamicProxy();  
 
    private ProxyMehds 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 ProxyMehds getProxyMehds() {
		return proxyMehds;
	}

	public void setProxyMehds(ProxyMehds proxyMehds) {
		this.proxyMehds = proxyMehds;
	}  
 
    
    
}</span>

1.3服务类：

<span style="font-size:18px;">public class AspectClass1 {
	public void SayHello(){
		System.out.println("This is AspectClass1.SayHello!");
	}
}</span>

1.4客户端：

<span style="font-size:18px;">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;
	    
	    beforMethods=new HashMap();
    	beforBeans=new HashMap();
    	beforBeans.put("AspectClass1", new AspectClass1());
    	
    	beforMethods.put("AspectClass1", "SayHello");
    	beforMethods.put("AspectClass2", "SayGoodBye");
    	
    	afterMethods=new HashMap();
    	afterBeans=new HashMap();
    	afterBeans.put("AspectClass3", new AspectClass3());
    	afterBeans.put("AspectClass4", new AspectClass4());
    	afterMethods.put("AspectClass3", "SayHi");
    	afterMethods.put("AspectClass4", "Eat");
    	
    	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");  
    } 
}</span>

总结：

这样封装之后的好处是什么呢，就是我们的服务不再固定，而是在代理中定义了一个空壳子，这样每次使用，都是复用的空壳子，也是我们常说的框架，而后期的服务类是后加入的，在客户端动态初始化制定的，这样我们的扩展就变得方便，写好一个类，我们就可以直接配置下xml（类似于客户端的组装）就可以实现这样的功能！让功能的扩充变得简单！

在代码的实现上，功能实现是编写代码的第一步，而我们的大多程序员都做到了第一步，想要获得更高的薪水，就要有些和其他人不一样的东西，那么，这时候，业务来理解水平，抽象能力，实现能力，优化能力，逐渐在以后的晋升中起到至关重要的作用，而这些能力有一个公共的父类，就是全局观，在全局上考虑问题，包含时间与空间两个方向，当时间长了，变化怎么办？人数多了，数据量大了怎么办？

成为一个优秀的架构人员，我们要学习的还有很多！