首页 > 代码库 > Spring Aop 梳理
Spring Aop 梳理
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 delegate16 * @return17 */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 Object25 * target：指被代理的对象。26 * @param Method27 * method：要调用的方法28 * @param Object29 * [] args：方法调用时所需要的参数30 */31 @Override32 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 target15 * @return16 */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 @Override28 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业务方法事物结束
声明：以上内容来自用户投稿及互联网公开渠道收集整理发布，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任，若内容有误或涉及侵权可进行投诉： 投诉/举报 工作人员会在5个工作日内联系你，一经查实，本站将立刻删除涉嫌侵权内容。