标签：style blog color 使用 strong io 代码 ar
Aspect Oriented Programming 面向切面编程。解耦是程序员编码开发过程中一直追求的。AOP也是为了解耦所诞生。
具体思想是：定义一个切面，在切面的纵向定义处理方法，处理完成之后，回到横向业务流。
AOP 主要是利用代理模式的技术来实现的。
1、静态代理：就是设计模式中的proxy模式
a、业务接口
1 /** 2 * 抽象主题角色：声明了真实主题和代理主题的共同接口。 3 * 4 * @author Monkey 5 * 6 */ 7 public interface ITalk { 8 9 public void talk(String msg); 10 11 }
b、业务实现
1 /** 2 * 真实主题角色：定义真实的对象。 3 * 4 * @author Monkey 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 Monkey 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 Monkey 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 Monkey 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 Monkey 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 Monkey 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 Monkey 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 Monkey 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业务方法 事物结束
标签：style blog color 使用 strong io 代码 ar
原文地址：http://www.cnblogs.com/zengdan-develpoer/p/3877365.html
