Aspect Oriented Programming 面向切面编程。解耦是程序员编码开发过程中一直追求的。AOP也是为了解耦所诞生。
具体思想是:定义一个切面,在切面的纵向定义处理方法,处理完成之后,回到横向业务流。
AOP 在Spring框架中被作为核心组成部分之一,的确Spring将AOP发挥到很强大的功能。最常见的就是事务控制。工作之余,对于使用的工具,不免需要了解其所以然。学习了一下,写了些程序帮助理解。
AOP 主要是利用代理模式的技术来实现的。
1、静态代理:就是设计模式中的proxy模式
a、业务接口
1 /** 2 * 抽象主题角色:声明了真实主题和代理主题的共同接口。 3 * 4 * 5 */ 6 public interface ITalk { 7 8 public void talk(String msg); 9 10 }
b、业务实现
1 /** 2 * 真实主题角色:定义真实的对象。 3 * 4 * 5 */ 6 public class PeopleTalk implements ITalk { 7 8 public String username; 9 public String age; 10 11 public PeopleTalk(String username, String age) { 12 this.username = username; 13 this.age = age; 14 } 15 16 public void talk(String msg) { 17 System.out.println(msg + "!你好,我是" + username + ",我年龄是" + age); 18 } 19 20 public String getName() { 21 return username; 22 } 23 24 public void setName(String name) { 25 this.username = name; 26 } 27 28 public String getAge() { 29 return age; 30 } 31 32 public void setAge(String age) { 33 this.age = age; 34 } 35 36 }
c、代理对象
1 /** 2 * 代理主题角色:内部包含对真实主题的引用,并且提供和真实主题角色相同的接口。 3 * 4 * 5 */ 6 public class TalkProxy implements ITalk { 7 8 private ITalk talker; 9 10 public TalkProxy(ITalk talker) { 11 // super(); 12 this.talker = talker; 13 } 14 15 public void talk(String msg) { 16 talker.talk(msg); 17 } 18 19 public void talk(String msg, String singname) { 20 talker.talk(msg); 21 sing(singname); 22 } 23 24 private void sing(String singname) { 25 System.out.println("唱歌:" + singname); 26 } 27 28 }
d、测试类
1 /** 2 * 代理测试类,使用代理 3 * 4 */ 5 public class ProxyPattern { 6 7 public static void main(String[] args) { 8 // 不需要执行额外方法的。 9 ITalk people = new PeopleTalk("AOP", "18"); 10 people.talk("No ProXY Test"); 11 System.out.println("-----------------------------"); 12 13 // 需要执行额外方法的(切面) 14 TalkProxy talker = new TalkProxy(people); 15 talker.talk("ProXY Test", "代理"); 16 } 17 18 }
从这段代码可以看出来,代理模式其实就是AOP的雏形。 上端代码中talk(String msg, String singname)是一个切面。在代理类中的sing(singname)方法是个后置处理方法。
这样就实现了,其他的辅助方法和业务方法的解耦。业务不需要专门去调用,而是走到talk方法,顺理成章的调用sing方法
再从这段代码看:1、要实现代理方式,必须要定义接口。2、每个业务类,需要一个代理类。
2、动态代理:jdk1.5中提供,利用反射。实现InvocationHandler接口。
业务接口还是必须得,业务接口,业务类同上。
a、代理类:
1 /** 2 * 动态代理类 3 * 4 * 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 * 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 * 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 * 5 */ 6 public class CglibProxy implements MethodInterceptor { 7 8 private Object target; 9 10 /** 11 * 创建代理对象 12 * 13 * @param target 14 * @return 15 */ 16 public Object getInstance(Object target) { 17 this.target = target; 18 Enhancer enhancer = new Enhancer(); 19 enhancer.setSuperclass(this.target.getClass()); 20 // 回调方法 21 enhancer.setCallback(this); 22 // 创建代理对象 23 return enhancer.create(); 24 } 25 26 @Override 27 public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable { 28 Object result = null; 29 System.out.println("事物开始"); 30 result = methodProxy.invokeSuper(proxy, args); 31 System.out.println("事物结束"); 32 return result; 33 } 34 35 }
c.测试类
1 /** 2 * 测试类 3 * 4 * 5 */ 6 public class Test { 7 8 public static void main(String[] args) { 9 PeopleTalk peopleTalk = (PeopleTalk) new CglibProxy().getInstance(new PeopleTalk()); 10 peopleTalk.talk("业务方法"); 11 peopleTalk.spreak("业务方法"); 12 } 13 14 }
最后输出结果:
事物开始
people talk业务方法
事物结束
事物开始
spreak chinese业务方法
事物结束