Aspect Oriented Programming 面向切面编程。解耦是程序员编码开发过程中一直追求的。AOP也是为了解耦所诞生。
具体思想是:定义一个切面,在切面的纵向定义处理方法,处理完成之后,回到横向业务流。
AOP 在Spring框架中被作为核心组成部分之一,的确Spring将AOP发挥到很强大的功能。最常见的就是事务控制。工作之余,对于使用的工具,不免需要了解其所以然。学习了一下,写了些程序帮助理解。
AOP 主要是利用代理模式的技术来实现的。
1、静态代理:就是设计模式中的proxy模式
a、业务接口
1 /** 2 * 抽象主题角色:声明了真实主题和代理主题的共同接口。 3 * 4 * @author yanbin 5 * 6 */ 7 public interface ITalk { 8 9 public void talk(String msg); 10 11 }
b、业务实现
1 /** 2 * 真实主题角色:定义真实的对象。 3 * 4 * @author yanbin 5 * 6 */ 7 public class PeopleTalk implements ITalk { 8 9 public String username; 10 public String age; 11 12 public PeopleTalk(String username, String age) { 13 this.username = username; 14 this.age = age; 15 } 16 17 public void talk(String msg) { 18 System.out.println(msg + "!你好,我是" + username + ",我年龄是" + age); 19 } 20 21 public String getName() { 22 return username; 23 } 24 25 public void setName(String name) { 26 this.username = name; 27 } 28 29 public String getAge() { 30 return age; 31 } 32 33 public void setAge(String age) { 34 this.age = age; 35 } 36 37 }
c、代理对象
1 /** 2 * 代理主题角色:内部包含对真实主题的引用,并且提供和真实主题角色相同的接口。 3 * 4 * @author yanbin 5 * 6 */ 7 public class TalkProxy implements ITalk { 8 9 private ITalk talker; 10 11 public TalkProxy(ITalk talker) { 12 // super(); 13 this.talker = talker; 14 } 15 16 public void talk(String msg) { 17 talker.talk(msg); 18 } 19 20 public void talk(String msg, String singname) { 21 talker.talk(msg); 22 sing(singname); 23 } 24 25 private void sing(String singname) { 26 System.out.println("唱歌:" + singname); 27 } 28 29 }
d、测试类
1 /** 2 * 代理测试类,使用代理 3 * 4 * @author yanbin 5 * 6 */ 7 public class ProxyPattern { 8 9 public static void main(String[] args) { 10 // 不需要执行额外方法的。 11 ITalk people = new PeopleTalk("AOP", "18"); 12 people.talk("No ProXY Test"); 13 System.out.println("-----------------------------"); 14 15 // 需要执行额外方法的(切面) 16 TalkProxy talker = new TalkProxy(people); 17 talker.talk("ProXY Test", "代理"); 18 } 19 20 }
从这段代码可以看出来,代理模式其实就是AOP的雏形。 上端代码中talk(String msg, String singname)是一个切面。在代理类中的sing(singname)方法是个后置处理方法。
这样就实现了,其他的辅助方法和业务方法的解耦。业务不需要专门去调用,而是走到talk方法,顺理成章的调用sing方法
再从这段代码看:1、要实现代理方式,必须要定义接口。2、每个业务类,需要一个代理类。
2、动态代理:jdk1.5中提供,利用反射。实现InvocationHandler接口。
业务接口还是必须得,业务接口,业务类同上。
a、代理类:
1 /** 2 * 动态代理类 3 * 4 * @author yanbin 5 * 6 */ 7 public class DynamicProxy implements InvocationHandler { 8 9 /** 需要代理的目标类 */ 10 private Object target; 11 12 /** 13 * 写法固定,aop专用:绑定委托对象并返回一个代理类 14 * 15 * @param delegate 16 * @return 17 */ 18 public Object bind(Object target) { 19 this.target = target; 20 return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this); 21 } 22 23 /** 24 * @param Object 25 * target:指被代理的对象。 26 * @param Method 27 * method:要调用的方法 28 * @param Object 29 * [] args:方法调用时所需要的参数 30 */ 31 @Override 32 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 33 Object result = null; 34 // 切面之前执行 35 System.out.println("切面之前执行"); 36 // 执行业务 37 result = method.invoke(target, args); 38 // 切面之后执行 39 System.out.println("切面之后执行"); 40 return result; 41 } 42 43 }
b、测试类
1 /** 2 * 测试类 3 * 4 * @author yanbin 5 * 6 */ 7 public class Test { 8 9 public static void main(String[] args) { 10 // 绑定代理,这种方式会在所有的方法都加上切面方法 11 ITalk iTalk = (ITalk) new DynamicProxy().bind(new PeopleTalk()); 12 iTalk.talk("业务说明"); 13 } 14 }
输出结果会是:
切面之前执行
people talk业务说法
切面之后执行
说明只要在业务调用方法切面之前,是可以动态的加入需要处理的方法。
从代码来看,如果再建立一个业务模块,也只需要一个代理类。ITalk iTalk = (ITalk) new DynamicProxy().bind(new PeopleTalk()); 将业务接口和业务类绑定到动态代理类。
但是这种方式:还是需要定义接口。
3、利用cglib
CGLIB是针对类来实现代理的,他的原理是对指定的目标类生成一个子类,并覆盖其中方法实现增强。采用的是继承的方式。不细说,看使用
a、业务类
1 /** 2 * 业务类 3 * 4 * @author yanbin 5 * 6 */ 7 public class PeopleTalk { 8 9 public void talk(String msg) { 10 System.out.println("people talk" + msg); 11 } 12 13 }
b、cglib代理类
1 /** 2 * 使用cglib动态代理 3 * 4 * @author yanbin 5 * 6 */ 7 public class CglibProxy implements MethodInterceptor { 8 9 private Object target; 10 11 /** 12 * 创建代理对象 13 * 14 * @param target 15 * @return 16 */ 17 public Object getInstance(Object target) { 18 this.target = target; 19 Enhancer enhancer = new Enhancer(); 20 enhancer.setSuperclass(this.target.getClass()); 21 // 回调方法 22 enhancer.setCallback(this); 23 // 创建代理对象 24 return enhancer.create(); 25 } 26 27 @Override 28 public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable { 29 Object result = null; 30 System.out.println("事物开始"); 31 result = methodProxy.invokeSuper(proxy, args); 32 System.out.println("事物结束"); 33 return result; 34 } 35 36 }
c.测试类
1 /** 2 * 测试类 3 * 4 * @author yanbin 5 * 6 */ 7 public class Test { 8 9 public static void main(String[] args) { 10 PeopleTalk peopleTalk = (PeopleTalk) new CglibProxy().getInstance(new PeopleTalk()); 11 peopleTalk.talk("业务方法"); 12 peopleTalk.spreak("业务方法"); 13 } 14 15 }
最后输出结果:
事物开始
people talk业务方法
事物结束
事物开始
spreak chinese业务方法
事物结束
由于篇幅有限,这篇主要对AOP的原理简单实现做了演示和阐述,有助自己理解。至于Spring的AOP实现上面无外乎其右,不过实现方面复杂的多。