spring学习笔记肆——AOP

AOP是Spring框架中另一个核心技术和特色

AOP的全称为Aspect Oriented Programming，即为面向切面编程。

那具体来说什么是面向切面编程呢？我们正在刚学习controller、service、dao三层开发结构的时候，往往使用的是面向对象的思想，对一个类添加相应的方法。

当时到了开发后期的时候，例如我们想要在dao层增加方法的时候，就要触及到dao层的代码，这样非常的不方便，使得整个程序非常的不容易扩展。

于是，Spring为了减低这种情况带来的耦合度，推出了AOP。即在运行的时候，动态的将代码切入指定的代码、指定的函数、指定的位置上，这种思想就被称为面向切面思想

利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率

在学习之前，我们先来了解AOP的两个特性

1、不修改源代码实现对代码的扩展

2、AOP原理采用横向抽取机制，取代了传统的纵向继承机制体系重复性代码

什么叫纵向继承机制体系呢？

传统的开发是通过各种继承的机制来实现的效果
万一我某一天需要往底层类去添加一个新的功能，就必须去修改源代码来实现相应功能的逻辑，但是这明显违背了一种思想，而且会具有很高的耦合性，每加一次功能，就要修改一次源代码

当我从底层类实现功能逻辑后，再往后我要添加一个功能，此时我就可以去新建一个类去继承底层类，并且在新类中添加新的功能逻辑，再完成对新类的调用，调用新类的父类方法为super.方法名，这就是纵向继承体系。

但是这种方法依然不好，万一我修改了底层类的方法名，新类也跟着修改，并不能根本解决问题

但是AOP却能解决这样的问题。

虽然说AOP已经存在了很多年，从1990年开始就有研究人员对面向对象编程的局限性做出了分析，并由此衍生了出AOP思想，借助这种思想或许能在一定程度上解决代码重复性的问题，但是AOP始终作为一个学术领域上的设计思想而存在。直到Spring框架的出现，AOP才真正走进实际开发领域中。

在底层代码中，AOP的横向抽取机制是通过动态代理方式实现的

第一种情况用于面向接口编程，用于增强类的方法
使用jdk动态代理，针对有接口情况
使用动态代理方式，创建接口实现类代理对象
创建和DaoImpl类平级对象，代理对象，实现和DaoImpl相同的功能

第二种针对没有接口编程
创建User类的子类的代理对象
在子类里面调用父类的方法完成增强
此时使用cglib动态代理

这些工作在导入AspectJ包中会帮我们自动处理

在代码实现之前先来了解一下AOP操作术语

Joinpoint（连接点）：类里面可以被增强的方法，称为连接点

Pointcut（切入）：在类里面可以有很多方法被增强，比如实际操作中，只是增强类的部分方
法，这些实际被增强的方法称为切入点

Advice（通知/增强）：
实际增强的逻辑，称为，比如扩展日志功能，这个日志功能称为增强
前置通知：在方法之前执行
后置通知：在方法之后执行
异常通知：方法出现异常
最终通知：在后置之后执行
环绕通知：在方法之前执行和之后执行，例如计算某个方法的执行时间

Aspect（切面）：把增强应用到具体方法上面，此过程称为切面，把增强用到具体方法上面

Introduction（引介）：动态往类中加方法的过程
Target（目标对象）：增强的方法所在的类

weaving（织入）：把advice应用到target的过程
Proxy（代理）：创建有借口代理类的对象

在Spring框架中，我们通过AspectJ来实现AOP，但是AspectJ并不是spring框架的一部分，但是开发的时候会和Spring框架一起实现AOP的操作，在Spring 2.0后加强的对AspectJ的支持

Spring实现AOP有两种方式

第一种：基于AspectJ的xml配置方式

第二种：基于AspectJ的注解方式

开始之前先作出一些准备

1、导包，除了导入最基本的包和context包之外，我们还要导入其他的包

aopalliance-xx.jar

aspectjweaver-xxx.jar

speing-aop-xx.release.jar

spring-aspects-xxx.release.jar

2、创建配置文件并引入相关约束

<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemalocation=""http://www.springframework.org/schema/beans">  </beans>

3、新建两类，一个是增强类MyBook，一个是被增强类Book

public class MyBook{ public void before(){ System.out.println("before.....我从小米家拿的"); } public void after(){ System.out.println("after....我拿去当柴火烧了"); } public void throwException(JoinPoint JoinPoint, Exception ex){ System.out.println("throwException....."); } public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{ System.out.println("aroundHeader...."); //在被增强方法前实现增强的业务逻辑 proceedingJoinPoint.proceed(); System.out.println("aroundFooter...."); //在被增强方法后实现业务逻辑 } public void end(){ System.out.println("ending....执行完毕"); } }

public class Book { public void doingPaly(){ System.out.println("WOW！！！我有了一本书"); } public int errorPlay(String str) throws Exception{ int num = Integer.parseInt(str); return num; } }

4、重点来了，现在就是配置AOP操作

<bean id="book" class="it.neuedu.springse.demo.Book"> <bean id="myBook" class="it.neuedu.springse.demo.MyBook">  <aop:config>  <aop:pointcut expression="execution(* it.neuedu.springse.demo.Book.doing*(..))" id="pointcut">  <aop:aspect ref="myBook">   <aop:before method="before" pointcut-ref="pointcut">  <aop:after-returning method="after" pointcut-ref="pointcut">  <aop:around method="around" pointcut-ref="pointcut">  </aop:after></aop:around></aop:after-returning></aop:before></aop:aspect> </aop:pointcut></aop:config> </bean></bean>

5、这行测试程序，得出的结果如下

spring学习笔记肆——AOP

当然，我们可以通过Spring的注解机制实现同样的效果

1、借用上面的Book和MyBook，添加各项注解

@Repository(value="book")//使用注解的形式将Book交给spring处理 public class Book { //测试简单方法 public void doingPaly(){ System.out.println("WOW！！！我有了一本书"); } //测试异常方法 public int errorPlay(String str) throws Exception{ int num = Integer.parseInt(str); return num; } }

@Repository(value="myBook")//使用注解的形式将MyBook交给spring处理 @Aspect //注解表明该方法时增强类方法 public class MyBook implements ThrowsAdvice{ @Pointcut("execution(* it.neuedu.springse.demo.Book.doing*(..))") public void sayMethod() { } @Pointcut("execution(* it.neuedu.springse.demo.Book.err*(..))") public void errMothod(){ } //@Pointcut 新建一个切入点，以一个空参方法作为切入点的标志，在@Pointcut内添加要增强的方法 @Before(value = "sayMethod()")//在目标切入点前执行 public void before(){ System.out.println("before....."); } @After(value = "sayMethod()")//在目标切入点之后执行 public void after(){ System.out.println("after...."); } @Around(value = "sayMethod()")//环绕切入点执行 public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{ /* * proceedingJoinPoint.getArgs(); * 用此方法可以获取一个传入参数的数组，将传入的参数从代理对象取出来，可以修饰该参数作进一步的处理 * 增强类的环绕的方法有且只有一个ProceedingJoinPoint参数 */ System.out.println("aroundHeader...."); //在被增强方法前实现增强的业务逻辑 proceedingJoinPoint.proceed(); /* 调用proceed()方法来拦截对象方法底层是使用代理对象代理切入点，对该切入点方法进行增强如果要传进参数可以往proceed()里面传值 */ System.out.println("aroundFooter...."); //在被增强方法后实现业务逻辑 } @AfterReturning(value="sayMethod()")//返回参数时执行 public void endReturning(){ System.out.println("endReturning....执行完毕"); } @AfterThrowing(value="errMothod()",throwing="ex")//抛出异常时执行 public void throwException(JoinPoint JoinPoint, Exception ex){ System.out.println("throwException....."); } @After(value="errMothod()") public void finallyException() { System.out.println("endingException...finally"); } @AfterReturning(value="errMothod()")//返回参数时执行 public void endException(){ System.out.println("endReturningExcepting....执行完毕"); } //这里配置的目的是为了比较After和AfterReturning的区别 }

2、修改xml配置文件的配置内容为

<context:component-scan base-package="it.neuedu">  <aop:aspectj-autoproxy>

3、博主的测试代码如下

public class test { public static void main(String[] args) { ApplicationContext aContext = new ClassPathXmlApplicationContext("applicationContext.xml"); Book book = (Book)aContext.getBean("book"); System.out.println(book); book.doingPaly(); System.out.println(); try { System.out.println(book.errorPlay("123")); } catch (Exception ex) { } finally { } System.out.println(); try { System.out.println(book.errorPlay("123abc"));//这里是为了故意让其抛出错误 } catch (Exception ex) { } finally { } } }

4、测试结果如下

spring学习笔记肆——AOP

spring学习笔记肆——AOP

相关推荐