AOP解密-----深入再造AOP

拼搏现实的明天。 2022-07-15 12:27 208阅读 0赞

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

# 回顾： #

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

![20161116220016301][]

咱们看看在CGLIB类里的问题

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个方法了，怎么办？的确，这样的维护，是我们不想看到的，所以，我们将扩展的公共服务放到了一个容器中，大家看类图：

![20161116223429896][]

## 1.1公共服务类的容器： ##

/**
     * 将服务进行封装
     */
    public class ProxyMehds {
    	// 盛放方法执行的对象的容器
    	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;
    	}
    }

## 1.2封装CGlib动态代理类： ##

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;
    	}
    }

## 1.3公共服务类： ##

public class AspectClassOne {
    	public void sayOne() {
    		System.out.println("AspectClassOne sayOne ... ");
    	}
    }

public class AspectClassTwo {
    	public void sayTwo() {
    		System.out.println("AspectClassTwo sayTwo ... ");
    	}
    }

public class AspectClassThree {
    	public void sayThree() {
    		System.out.println("AspectClassThree sayThree ... ");
    	}
    }

public class AspectClassFour {
    	public void sayFour() {
    		System.out.println("AspectClassFour sayFour ... ");
    	}
    }

## 1.4 业务方法类 ##

public interface Greeting {
    	void sayHello(String name);
    }

public class GreetingImpl implements Greeting {
    	@Override
    	public void sayHello(String name) {
    		System.out.println("Hello! " + name);
    	}
    }

## 1.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");
    
    	}
    }

**1.6 [ 代码下载][Link 1]**

**1.7 参考博客**

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

#     #

# 总结： #

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

[20161116220016301]: /images/20220715/33dffc11bdb74768a3a7c0965ef2f1ec.png
[20161116223429896]: /images/20220715/69195210056e4247b305074f01552f18.png
[Link 1]: http://download.csdn.net/download/zbw18297786698/9684416