spring框架学习(三)——AOP( 面向切面编程)
AOP 即 Aspect Oriented Program 面向切面编程
首先，在面向切面编程的思想里面，把功能分为核心业务功能，和周边功能。
所谓的核心业务，比如登陆，增加数据，删除数据都叫核心业务
所谓的周边功能，比如性能统计，日志，事务管理等等
周边功能在Spring的面向切面编程AOP思想里，即被定义为切面
在面向切面编程AOP的思想里面，核心业务功能和切面功能分别独立进行开发
然后把切面功能和核心业务功能 "编织" 在一起，这就叫AOP
原理图
1. 功能分两大类，辅助功能和核心业务功能
2. 辅助功能和核心业务功能彼此独立进行开发
3. 比如登陆功能，即便是没有性能统计和日志输出，也可以正常运行
4. 如果有需要，就把"日志输出" 功能和 "登陆" 功能 编织在一起，这样登陆的时候，就可以看到日志输出了
5. 辅助功能，又叫做切面，这种能够选择性的，低耦合的把切面和核心业务功能结合在一起的编程思想，就叫做切面编程
准备业务类 ProductService
package com.how2java.service;
public class ProductService {
public void doSomeService(){
System.out.println("doSomeService");
}
}准备一个测试类 TestSpring
package com.how2java.test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.how2java.service.ProductService;
public class TestSpring {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext(new String[] { "springconfig.xml" });
ProductService s = (ProductService) context.getBean("s");
s.doSomeService();
}
}准备一个日志切面LoggerAspect
package com.how2java.aspect;
import org.aspectj.lang.ProceedingJoinPoint;
public class LoggerAspect {
public Object log(ProceedingJoinPoint joinPoint) throws Throwable {
System.out.println("start log:" + joinPoint.getSignature().getName());
Object object = joinPoint.proceed();
System.out.println("end log:" + joinPoint.getSignature().getName());
return object;
}
}设置配置文件springconfig.xml
<?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:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
<!--声明业务对象--> <bean name="s" class="com.how2java.service.ProductService"/> <!--声明日志切面--> <bean id="loggerAspect" class="com.how2java.aspect.LoggerAspect"/> <!--aop配置过程--> <aop:config> <aop:pointcut id="loggerCutpoint" expression="execution(* com.how2java.service.ProductService.*(..)) "/> <aop:aspect id="logAspect" ref="loggerAspect"> <aop:around pointcut-ref="loggerCutpoint" method="log"/> </aop:aspect> </aop:config> </beans>aop配置过程每一步的含义解释：
<aop:pointcut id="loggerCutpoint" expression="execution(* com.how2java.service.ProductService.*(..)) "/>
这一句是声明切点，切点的 id 叫 loggerCutPoint ，用来标记这个切入点，这个expression表示：满足expression中的方法调用之后，就会去进行切面操作，类似于触发了切面：
1. 第一个 * 代表返回任意类型：可以是void，int，string。。。。具体可根据调用的方法的返回类型决定
2. com.how2java.service.ProductService.*(..) ：表示包名为 com.how2java.service下的ProductService 类的任意方法 ( 这里的通配符 * 表示任意方法，(..)表示方法的参数是任意数量和类型 )
简单说就是，只要com.how2java.service这个包中的ProductService类的任意一个函数被调用，不管你的返回值是什么，都会触发开关，我就会去执行切面，也就是辅助功能。针对ProductService类中只有doSomeService()一个函数方法，* com.how2java.service.ProductService.*(..)也可以写成 void com.how2java.service.ProductService.doSomeService()。但是辅助功能是什么呢，就是下面三句：
<aop:aspect id="logAspect" ref="loggerAspect"> <aop:around pointcut-ref="loggerCutpoint" method="log"/> </aop:aspect>
这三句是定义了一个切面，上面说只要触发开关，就会去执行切面，就是指的这里的切面，所谓切面，就是一个类中的方法而已，在本案例中就是指 loggerAspect类中的log()方法，id="logAspect" 表示切面的id，ref="loggerAspect"指明切面所属的类，pointcut-ref="loggerCutpoint" 指明触发切面的切点id，method="log" 指明执行切面时所用的方法名。
测试类运行的结果如下
------------------------------------------------------
需要注意的是，一个切点也可以设置多个切面，我们重新创建了两个loggerAspect2和loggerAspect3，如下
配置文件改为
<?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:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
<bean name="s" class="com.how2java.service.ProductService"/>
<bean id="loggerAspect2" class="com.how2java.aspect.LoggerAspect2"/>
<bean id="loggerAspect3" class="com.how2java.aspect.LoggerAspect3"/>
<aop:config>
<aop:pointcut id="loggerCutpoint"
expression="execution(void com.how2java.service.ProductService.doSomeService()) "/> <aop:aspect id="logAspect2" ref="loggerAspect2">
<aop:before pointcut-ref="loggerCutpoint" method="log"/>
</aop:aspect>
<aop:aspect id="logAspect3" ref="loggerAspect3">
<aop:after pointcut-ref="loggerCutpoint" method="log"/>
</aop:aspect>
</aop:config>
</beans>运行结果为
------------------------------------------------------
AOP的过程分为两步：1，在业务类中插入切点，2，将切点和切面类关联起来
业务类就是核心类，就是网站的主要功能，切面就是辅助功能，日志，统计之类的
通过配置，可以实现，在某个方法调用的时候，触发别的方法执行，就好像在监视目标方法，你被执行，就触发我执行。
下面简单介绍一下通知：
通知定义了切面要完成的工作内容和何时完成工作，就是什么时候去做辅助功能，功能具体是什么代码
五种类型
Before——在方法调用之前调用通知
After——在方法完成之后调用通知，无论方法执行成功与否
After-returning——在方法执行成功之后调用通知
After-throwing——在方法抛出异常后进行通知
Around——通知包裹了被通知的方法，在被通知的方法调用之前和调用之后执行自定义的行为
前四个好理解的，最后一个around 表示切面在被监视的函数运行前后都会执行，下面是切面要执行的函数 log，log函数有一个形参 joinPoint 这个可以理解为断点，中间一句代表的就是被监视的程序运行，在被监视的程序运行时，可以替换他的形参，这个是 around 厉害的地方，如果被监视的程序，运行的时候输入的是一个haha字符串作为实参，但是经过log方法之后，这个参数就被替换为abc了
public Object log(ProceedingJoinPoint joinPoint) throws Throwable {
System.out.println("我在被监视程序之前。。。");
Object object = joinPoint.proceed(new Object[]{"abc"});
System.out.println("我在被监视程序之后。。。" );
return object;
}（注：关于joinPoint的详细介绍，请点击此处查看）