spring(三)：springAOP的各种织入方式一览
前言：
上一篇简单使用反射和jdk的动态代理模拟了AOP工作原理。在这里将讲阐述AOP如何把代码织入到目标对象的方法上。
一：这里介绍一下AOP一些名词概念
(1)Aspect(切面):通常是一个类，里面可以定义切入点和通知。
(2)JointPoint(连接点):程序执行过程中明确的点，一般是方法的调用。这就是目标对象的方法。
(3)Advice(通知):AOP在特定的切入点上执行的增强处理，有before,after,afterReturning,
afterThrowing,around。这些就是需要织入到连接点中的代码。
(4)Pointcut(切入点):就是带有通知的连接点，在程序中主要体现为书写切入点表达式
(5)AOP代理：AOP框架创建的对象，代理就是目标对象的加强。Spring中的AOP代理可以使JDK动态代理，
也可以是CGLIB代理，前者基于接口，后者基于子类
(6)advisor:增强器,用来筛选类中的哪些方法是我们的连接点(哪些方法需要被拦截).
(7)wave:织入，把切面/切面类和目标类的动态接入。
二：Advice(通知)
AOP的通知有before前置通知。after后置通知，无论是否成功返回都会执行。afterReturning后置通知，只有成功返回后才会执行。
afterThrowing抛出异常通知，顾名思义，只有抛出异常的时候才会执行。around环绕通知，简单来说就是集合了before和after的
功能。
这里基于xml文件实现把切面类和目标类动态接入。
(1)pojo类：Account.java
package com.cnblogs.aop.pojo;
/**
* 简单模拟银行账户
*
*/
public class Account {
// 卡号
private Long id;
// 姓名
private String name;
//余额
private double balance;
public Account() {
super();
// TODO Auto-generated constructor stub
}
public Account(Long id, String name, double balance) {
super();
this.id = id;
this.name = name;
this.balance = balance;
}
// get和set方法
}
(2)目标类：这里使用的是JDK的接口代理模式，所以需要准备一个接口，和接口的实现类，即目标类。
package com.cnblogs.aop.service;
public interface BankService {
/**
* 存钱
* @param money
*/
public Boolean save(double money) throws Exception;
/**
* 取钱
* @param money
* @return
*/
public boolean withdraw(double money) throws Exception;
}
package com.cnblogs.aop.service.impl;
import com.cnblogs.aop.pojo.Account;
import com.cnblogs.aop.service.BankService;
public class BankServiceImpl implements BankService {
private Account account;
public Account getAccount() {
return account;
}
public void setAccount(Account account) {
this.account = account;
}
@Override
public Boolean save(double money) throws Exception {
System.out.println("存钱: " + money);
account.setBalance(account.getBalance() + money);
return true;
}
@Override
public boolean withdraw(double money) throws Exception{
System.out.println("取钱: " + money);
if(account.getBalance() < money) {
throw new Exception("余额不足");
}
account.setBalance(account.getBalance() - money);
return true;
}
}
(3):目标类准备好以后，就要准备切面类了。这个切面类直接集合了所有的通知类型。
package com.cnblogs.aop.aspect;
import java.lang.reflect.Method;
import java.text.SimpleDateFormat;
import java.util.Date;
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import org.springframework.aop.AfterReturningAdvice;
import org.springframework.aop.MethodBeforeAdvice;
import org.springframework.aop.ThrowsAdvice;
/**
* 切面类
* 实现了前置通知 MethodBeforeAdvice
* 成功返回才执行的后置通知
* 环绕通知
* 抛出异常才会执行的通知
*
*
*/
public class MyLogger implements MethodBeforeAdvice,AfterReturningAdvice,
MethodInterceptor,ThrowsAdvice{
/**
* 前置通知
* @param method 连接点
* @param args 连接点参数
* @param target 目标对象
*/
@Override
public void before(Method mehtod, Object[] args, Object target) throws Throwable {
// 添加日志功能
System.out.println("前置通知: " + new SimpleDateFormat().format(new Date()));
}
/**
* 后置通知会接收到连接点的返回值，连接点返回值必须为引用类型，否则
* 报错：org.springframework.aop.AopInvocationException:
* Null return value from advice does not match primitive return type for
* @param returnValue 连接点的返回值【如果有的话】
* @param method 连接点
* @param args 连接点方法参数
* @param target 目标对象【委托对象】
*/
@Override
public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
// 添加日志功能
System.out.println("成功返回才执行的后置通知: " + new SimpleDateFormat().format(new Date()));
}
/**
* 环绕通知
* 在调用连接点前为前置通知
* 在调用连接点后为后置通知
*/
@Override
public Object invoke(MethodInvocation invocation) throws Throwable {
System.out.println("环绕通知之前置: " +
new SimpleDateFormat().format(new Date()));
// 调用连接点
invocation.proceed();
System.out.println("环绕通知之后置: " +
new SimpleDateFormat().format(new Date()));
return null;
}
/**
* 抛出异常才会执行的通知比较特殊，它的接口类体为空，
* 只起一个标记作用。
* 不过会默认调用afterThrowing方法作为通知。
* 该方法重载，有4个参数的和1个参数的
* 当两个重载方法都存在时优先调用4个参数的
*/
public void afterThrowing(Method method, Object[] args, Object target,Exception e) {
System.out.println("抛出异常才会执行的通知(4参): " +
e.toString());
}
public void afterThrowing(Exception e) {
System.out.println("抛出异常才会执行的通知(1参): " +
e.toString());
}
}
(4)：织入
advice.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:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-4.3.xsd">
<!-- 银行账号 -->
<bean name="account" class="com.cnblogs.aop.pojo.Account">
<property name="id" value="6217" />
<property name="name" value="jack" />
<property name="balance" value="1000.00" />
</bean>
<!-- 目标对象 -->
<bean name="service" class="com.cnblogs.aop.service.impl.BankServiceImpl">
<property name="account" ref="account" />
</bean>
<!-- 切面对象 -->
<bean name="log" class="com.cnblogs.aop.aspect.MyLogger">
</bean>
<!-- 生成代理对象
这里使用的是spring的一个代理对象工厂类产生的
-->
<bean name="proxy" class="org.springframework.aop.framework.ProxyFactoryBean">
<!-- 注入目标对象 -->
<property name="target" ref="service"></property>
<!-- 注入目标对象所实现的接口 可以有多个接口,基于JDK的接口代理 -->
<property name="proxyInterfaces">
<list>
<value>com.cnblogs.aop.service.BankService</value>
</list>
</property>
<!-- 注入advice -->
<property name="interceptorNames">
<list>
<value>log</value>
</list>
</property>
</bean>
</beans>
(5):测试
package com.cnblogs.aop.jtest;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.cnblogs.aop.service.BankService;
@SuppressWarnings("resource")
public class AOPTest {
@Test
public void advice(){
try {
// 获取springIOC容器
String path = "com/cnblogs/aop/aspect/advice.xml";
ApplicationContext container = new ClassPathXmlApplicationContext(path);
// 从容器中获取代理对象
BankService proxy = (BankService) container.getBean("proxy");
// 执行目标对象中的方法
// proxy.save(1000.0);
// 测试通知会对那些方法起作用
// proxy.getClass(); // 无
// proxy.toString(); // 有
// 测试抛出异常通知
// proxy.withdraw(5000.0);
} catch (Exception e) {
e.printStackTrace();
}
}
}
1.环绕通知的前置优先前置通知输出，后置通知优先环绕通知的后置输出。
环绕通知之前置: 19-5-28 下午7:29
前置通知: 19-5-28 下午7:29
存钱: 1000.0
成功返回才执行的后置通知: 19-5-28 下午7:29
环绕通知之后置: 19-5-28 下午7:29
2.通知对那些方法起作用？
单独调用getClass()方法时没有通知输出，toString()方法通知有输出。去java.lang.Objcet查找两个方法,
public final Class<?> getClass()，public String toString().简单对比发现只要是非final类型修饰的，通过代理对象调用
目标对象方法时都会把通知织入。
有时候我们希望目标对象的某些方法被织入，其它方法不想被织入，当时又不想用final修饰那些不想被织入的方法该
怎么办？增强器可以起到这个效果，筛选需要的方法织入。
三：Advisor增强器
增强器可以筛选目标类中那些方法被织入。
advisor.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:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-4.3.xsd">
<!-- 银行账号 -->
<bean name="account" class="com.cnblogs.aop.pojo.Account">
<property name="id" value="6217" />
<property name="name" value="jack" />
<property name="balance" value="1000.00" />
</bean>
<!-- 目标对象 -->
<bean name="service" class="com.cnblogs.aop.service.impl.BankServiceImpl">
<property name="account" ref="account" />
</bean>
<!-- 切面对象 -->
<bean name="log" class="com.cnblogs.aop.aspect.MyLogger">
</bean>
<!-- 配置增强器的bean对象 -->
<bean name="advisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
<!-- 注入advice -->
<property name="advice" ref="advice"/>
<!-- 注入需要被拦截的目标对象中的方法(连接点) -->
<property name="patterns">
<list>
<value>.*save</value>
<value>.*withdraw</value>
</list>
</property>
</bean>
<!-- 生成代理对象
这里使用的是spring的一个代理对象工厂类产生的
-->
<bean name="proxy" class="org.springframework.aop.framework.ProxyFactoryBean">
<!-- 注入目标对象 -->
<property name="target" ref="service"></property>
<!-- 注入目标对象所实现的接口 可以有多个接口,基于JDK的接口代理 -->
<property name="proxyInterfaces">
<list>
<value>com.cnblogs.aop.service.BankService</value>
</list>
</property>
<!-- 注入advice -->
<property name="interceptorNames">
<list>
<value>advisor</value>
</list>
</property>
</bean>
</beans>
补充：与advice.xml文件对比，发现只是多了一个org.springframework.aop.support.RegexpMethodPointcutAdvisor类的bean对象，该类就是增强器，
里面需要注入切面类的bean对象，以及指定那些方法被织入。
其次在生成代理对象的bean标签中，注入advice是注入增强器。
测试：
@Test
public void advisor(){
try {
// 获取springIOC容器
String path = "com/cnblogs/aop/advisor/advisor.xml";
ApplicationContext container = new ClassPathXmlApplicationContext(path);
// 从容器中获取代理对象
BankService proxy = (BankService) container.getBean("proxy");
// proxy.toString();
// proxy.save(1000);
proxy.getClass();
} catch (Exception e) {
e.printStackTrace();
}
}
四：AutoProxy，自动代理
如果目标类不止一个，为多个目标类生成代理对象需要配置多个
<bean name="proxy" class="org.springframework.aop.framework.ProxyFactoryBean">...... </bean>,
自动代理可以用很少的xml配置给目标对象生成代理对象。自动代理用到增强器的功能。
autoProxy.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:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-4.3.xsd">
<!-- 银行账号 -->
<bean name="account" class="com.cnblogs.aop.pojo.Account">
<property name="id" value="6217" />
<property name="name" value="jack" />
<property name="balance" value="1000.00" />
</bean>
<!-- 目标对象 -->
<bean name="service" class="com.cnblogs.aop.service.impl.BankServiceImpl">
<property name="account" ref="account" />
</bean>
<!-- 切面对象 -->
<bean name="log" class="com.cnblogs.aop.aspect.MyLogger">
</bean>
<!-- 配置增强器的bean对象 -->
<bean name="advisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
<!-- 注入advice -->
<property name="advice" ref="log"/>
<!-- 注入需要被拦截的目标对象中的方法(连接点) -->
<property name="patterns">
<list>
<value>.*save</value>
<value>.*withdraw</value>
</list>
</property>
</bean>
<!-- 配置自动代理对象 -->
<bean name="proxy"
class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator">
</bean>
</beans>
1.不能通过proxy拿代理对象，通过目标对象的名字拿代理对象。
2.当前xml文件中一定要有一个增强器advisor,配置自动代理对象不需要注入任何东西。
3.不管目标对象是否实现了一个或多接口,自动代理的方式都能够为它产生代理对象(CGLib的方式)。
4.如果目标对象有增强器中筛选的方法，将来调用方法的时候会动态织入。
测试：
@Test
public void autoProxy(){
try {
// 获取springIOC容器
String path = "com/cnblogs/aop/autoProxy/autoProxy.xml";
ApplicationContext container = new ClassPathXmlApplicationContext(path);
BankService target = (BankService) container.getBean("service");
target.save(1000.0);
} catch (Exception e) {
e.printStackTrace();
}
}
结果：
环绕通知之前置: 19-5-29 下午4:22
前置通知: 19-5-29 下午4:22
存钱: 1000.0
成功返回才执行的后置通知: 19-5-29 下午4:22
环绕通知之后置: 19-5-29 下午4:22
2.AutoProxyByName 通过名字进行自动代理
虽然自动代理可以很方便的给xml文件中的目标对象设置对应的代理对象,但是并不是xml文件中的所有对象都是我们的目标对象,
我们更想希望可以进一步筛选出某几个对象为我们的目标对象。
autoProxyByName.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:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.3.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd"> <!-- 银行账号 --> <bean name="account" class="com.cnblogs.aop.pojo.Account"> <property name="id" value="6217" /> <property name="name" value="jack" /> <property name="balance" value="1000.00" /> </bean> <!-- 目标对象 --> <bean name="service" class="com.cnblogs.aop.service.impl.BankServiceImpl"> <property name="account" ref="account" /> </bean> <!-- 切面对象 --> <bean name="log" class="com.cnblogs.aop.aspect.MyLogger"> </bean> <!-- 配置增强器的bean对象 --> <bean name="advisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor"> <!-- 注入advice --> <property name="advice" ref="log"/> <!-- 注入需要被拦截的目标对象中的方法(连接点) --> <property name="patterns"> <list> <value>.*save</value> <value>.*withdraw</value> </list> </property> </bean> <!-- 配置代理对象 --> <!-- 这里使用自动代理的方式 autoproxybyname --> <bean name="proxy" class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator"> <!-- 注入需要被代理的对象名字 --> <property name="beanNames"> <list> <!-- value中填写bean标签的id或name属性值 --> <value>service</value> </list> </property> <!-- 注入advice或者advisor --> <property name="interceptorNames"> <list> <value>advisor</value> </list> </property> </bean> </beans>
使用byName自动代理的时候需要注意的方面:
1.当前的配置里面"有没有"advisor的配置"都没关系"
2.不管目标对象是否实现了一个或多接口,自动代理的方式都能够为它产生代理对象.
3.从spring容器中拿代理对象的时候,需要通过目标对象的名字来拿。
五：使用<aop>标签完成织入功能
execution(modifiers-pattern ret-type-pattern declaring-type-pattern name-pattern(param-pattern) throws-pattern)
除了返回类型模式(ret-type-pattern)，名字模式(name-pattern)，参数模式（param-pattern）是必须的，
其它模式都是可选的
ret-type-pattern: \' * \'代表匹配任意返回类型,java.lang.String匹配String返回类型。
name-pattern: 名字模式匹配的是方法名。 你可以使用 * 通配符作为所有或者部分命名模式。
param-pattern:参数匹配, \' () \'匹配无参，\' (*) \'匹配一个参数，‘（..）’匹配任意参数（0或多个）,
\' (*,String) \' 匹配了一个接受两个参数的方法,第一个可以是任意类型,第二个必须是String类型。
下面给出一些常见切入点表达式的例子。
1)任意包下的任意类中的公共方法的执行:
execution(public * *(..))
2)任何一个以“set”开始的方法的执行:
execution(* set*(..))
3)BankService接口的任意方法的执行:
execution(* com.cnblogs.service.BankService.*(..))
4)定义在service包里的任意方法的执行:
execution(* com.cnblogs.service.*.*(..))
5)定义在service包或者子包里的任意方法的执行:
execution(* com.cnblogs.service..*.*(..))
1.第一种方式使用<aop>标签
<?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
http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-4.3.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-4.3.xsd ">
<!-- 银行账号 -->
<bean name="account" class="com.cnblogs.aop.pojo.Account">
<property name="id" value="6217" />
<property name="name" value="jack" />
<property name="balance" value="1000.00" />
</bean>
<!-- 目标对象 -->
<bean name="service" class="com.cnblogs.aop.service.impl.BankServiceImpl">
<property name="account" ref="account" />
</bean>
<!-- 切面对象 -->
<bean name="log" class="com.cnblogs.aop.aspect.MyLogger">
</bean>
<!-- 配置aop的代理 也启用了自动代理的功能-->
<aop:config>
<!-- 定义一个切入点 -->
<aop:pointcut
expression="execution(public * com.cnblogs.aop.service.BankService.save(*))"
id="save"/>
<aop:pointcut
expression="execution(public * com.cnblogs.aop.service.BankService.withdraw(*))"
id="withdraw"/>
<!-- 定义哪一个advice在哪一个切入点上面起作用 -->
<aop:advisor advice-ref="log" pointcut-ref="save" />
<aop:advisor advice-ref="log" pointcut-ref="withdraw" />
</aop:config>
</beans>
注意:
1.从spring容器中拿代理对象的时候也是要用目标对象的名字来拿。
2.没有实现任何接口的目标对象也能产生代理对象。
测试：
@Test
public void aop1(){
try {
// 获取springIOC容器
String path = "com/cnblogs/aop/aopConfig/config1.xml";
ApplicationContext container = new ClassPathXmlApplicationContext(path);
BankService target = (BankService) container.getBean("service");
target.save(1000.0);
target.withdraw(20000.0);
} catch (Exception e) {
e.printStackTrace();
}
}
环绕通知之前置: 19-5-29 下午7:06
前置通知: 19-5-29 下午7:06
存钱: 1000.0
成功返回才执行的后置通知: 19-5-29 下午7:06
环绕通知之后置: 19-5-29 下午7:06
环绕通知之前置: 19-5-29 下午7:06
前置通知: 19-5-29 下午7:06
取钱: 20000.0
抛出异常才会执行的通知(1参): java.lang.Exception: 余额不足
2.第二种方式使用aop
在一个切面类中定个多个方法,根据xml文件的配置每个方法都可以织入到切入点的不同位置,并且advice是在aop的标签中进行配置,
不需要再写对应的advice类了。
切面类：
package com.cnblogs.aop.aopConfig;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
/**
* 切面类,这里包含了多个切面方法,可以把每个切面方法织入到不同切入点的不同位置
*
*/
public class XmlHandler {
public void beforeTest(JoinPoint p){
System.out.println(p.getSignature().getName()+" before...");
}
public void afterTest(JoinPoint p){
System.out.println(p.getSignature().getName()+" after...");
}
public void afterReturningTest(JoinPoint p){
System.out.println(p.getSignature().getName()+" afterReturning");
}
//在和aroundAdvice结合的时候,这个方法一定要加上这个ProceedingJoinPoint类型的参数
public Object aroundTest(ProceedingJoinPoint pjp)throws Throwable{
//JoinPoint对象不能调用连接点所表示的方法
//ProceedingJoinPoint能调用连接点所表示的方法 pjp.proceed()
System.out.println(pjp.getSignature().getName()+" is start..");
//调用目标对象中的方法
Object obj = pjp.proceed();
System.out.println(pjp.getSignature().getName()+" is end..");
return obj;
}
public void throwingTest(JoinPoint p,Exception ex){
System.out.println(p.getSignature().getName()+" is throwing..."+ex.getMessage());
}
}
<?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
http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-4.3.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-4.3.xsd ">
<bean name="account" class="com.cnblogs.aop.pojo.Account">
<property name="id" value="6217" />
<property name="name" value="jack" />
<property name="balance" value="1000.00" />
</bean>
<!-- 目标对象 -->
<bean name="service" class="com.cnblogs.aop.service.impl.BankServiceImpl">
<property name="account" ref="account" />
</bean>
<!-- 切面对象 -->
<bean name="log" class="com.cnblogs.aop.aopConfig.XmlHandler">
</bean>
<!-- 配置aop的代理 -->
<aop:config>
<!-- 定义切入点名为myPointCut -->
<aop:pointcut expression="execution(public * com.cnblogs.aop.service.*.*(..))"
id="myPointCut"/>
<!-- 定义切面类 以及需要使用的advice -->
<aop:aspect id="aspect" ref="log">
<!-- before表示会把切面类log中的beforeTest方法织入到名字
叫myPointCut的切入点前面
-->
<aop:before method="beforeTest" pointcut-ref="myPointCut"/>
<!-- after表示不管方法是否正常结束都会起作用 -->
<aop:after method="afterTest" pointcut-ref="myPointCut"/>
<!-- after-returning表示方法正常结束才会起作用(抛异常时候不起作用) -->
<aop:after-returning method="afterReturningTest" pointcut-ref="myPointCut"/>
<aop:around method="aroundTest" pointcut-ref="myPointCut"/>
<!-- throwing="ex"表示throwingTest方法中接收异常对象的名字一定要是ex -->
<aop:after-throwing method="throwingTest" pointcut-ref="myPointCut" throwing="ex"/>
</aop:aspect>
</aop:config>
</beans>
@Test
public void aop2(){
try {
// 获取springIOC容器
String path = "com/cnblogs/aop/aopConfig/config2.xml";
ApplicationContext container = new ClassPathXmlApplicationContext(path);
BankService target = (BankService) container.getBean("service");
target.save(1000.0);
// target.withdraw(20000.0);
} catch (Exception e) {
e.printStackTrace();
}
}
save before...
save is start..
存钱: 1000.0
save is end..
save afterReturning
save after...
六：使用注解配置AOP
1.定义切面类:
package com.cnblogs.aop.annotation;
import java.text.SimpleDateFormat;
import java.util.Date;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
@Component
@Aspect
public class AnnotationHandler {
/**
* 在一个方法上面加上注解来定义切入点
* 这个切入点的名字就是这个方法的名字
* 这个方法本身不需要有什么作用
* 这个方法的意义就是:给这个 @Pointcut注解一个可以书写的地方
* 因为注解只能写在方法、属性、类的上面,并且方法名作为切入点的名字
*/
@Pointcut("execution(public * com.cnblogs.aop.service.impl.*.*(..))")
public void myPoint(){}
/**
* 前置通知
* 如果需要用到Joinpoint，可以在方法参数加上
* @param j
*/
@Before("myPoint()")
public void beforeTest(){
System.out.println("前置通知: " + new SimpleDateFormat().format(new Date()));
}
/**
* 最终通知
*/
@After("myPoint()")
public void afterTest(){
System.out.println("最终通知: " + new SimpleDateFormat().format(new Date()));
}
/**
* 环绕通知
* @throws Throwable
*/
@Around("myPoint()")
public void aroundTest(ProceedingJoinPoint pjp) throws Throwable{
System.out.println("环绕通知之前置: " +
new SimpleDateFormat().format(new Date()));
//调用连接点的方法去执行
Object obj = pjp.proceed();
System.out.println("环绕通知之后置: " +
new SimpleDateFormat().format(new Date()));
}
/**
* 成功返回才会执行的后置通知
*/
@AfterReturning("myPoint()")
public void afterReturningTest(){
System.out.println("成功返回才执行的后置通知: " + new SimpleDateFormat().format(new Date()));
}
/**
* 抛出异常通知
*/
@AfterThrowing(value="myPoint()",throwing="ex")
public void throwTest(Exception ex){
System.out.println("抛出异常才会执行的通知(1参): " +
ex.toString());
}
}
2.在BankServiceImpl上加 @Service("service") 注解，在account成员变量加 @Autowired注解。
在Account上加 @Component @Scope("prototype")。
3.在xml文件中加上
<aop:aspectj-autoproxy/>
<context:component-scan base-package="com.cnblogs.aop.pojo"/>
<context:component-scan base-package="com.cnblogs.aop.service.*"/>
<context:component-scan base-package="com.cnblogs.aop.annotation"/>
<context:component-scan base-package=" " />
表示SpringIOC容器会扫描此包下加了@Component,@Service注解的类，并放入IOC容器。在上上篇随便springIOC的三种注入方式
有介绍。
4.最后一步就是测试了
@Test
public void annotation(){
try {
// 获取springIOC容器
String path = "com/cnblogs/aop/annotation/annotation.xml";
ApplicationContext container = new ClassPathXmlApplicationContext(path);
BankService service = (BankService) container.getBean("service");
// service.getAccount().setBalance(10000.0);
service.save(3000.0);
} catch (Exception e) {
e.printStackTrace();
}
}
环绕通知之前置: 19-5-29 下午8:41
前置通知: 19-5-29 下午8:41
存钱: 3000.0
环绕通知之后置: 19-5-29 下午8:41
最终通知: 19-5-29 下午8:41
成功返回才执行的后置通知: 19-5-29 下午8:41