切面(Aspect) :官方的抽象定义为“一个关注点的模块化,这个关注点可能会横切多个对象”,在本例中,“切面”就是类TestAspect所关注的具体行为,例如,AServiceImpl.barA()的调用就是切面TestAspect所关注的行为之一。“切面”在ApplicationContext中<aop:aspect>来配置。
连接点(Joinpoint) :程序执行过程中的某一行为,例如,AServiceImpl.barA()的调用或者BServiceImpl.barB(String _msg, int _type)抛出异常等行为。
通知(Advice) :“切面”对于某个“连接点”所产生的动作,例如,TestAspect中对com.spring.service包下所有类的方法进行日志记录的动作就是一个Advice。其中,一个“切面”可以包含多个“Advice”,例如TestAspect
切入点(Pointcut) :匹配连接点的断言,在AOP中通知和一个切入点表达式关联。例如,TestAspect中的所有通知所关注的连接点,都由切入点表达式execution(* com.spring.service.*.*(..))来决定
目标对象(Target Object) :被一个或者多个切面所通知的对象。例如,AServcieImpl和BServiceImpl,当然在实际运行时,Spring AOP采用代理实现,实际AOP操作的是TargetObject的代理对象。
AOP代理(AOP Proxy) 在Spring AOP中有两种代理方式,JDK动态代理和CGLIB代理。默认情况下,TargetObject实现了接口时,则采用JDK动态代理,例如,AServiceImpl;反之,采用CGLIB代理,例如,BServiceImpl。强制使用CGLIB代理需要将 <aop:config> 的 proxy-target-class 属性设为true
通知(Advice)类型
前置通知(Before advice) :在某连接点(JoinPoint)之前执行的通知,但这个通知不能阻止连接点前的执行。ApplicationContext中在<aop:aspect>里面使用<aop:before>元素进行声明。例如,TestAspect中的doBefore方法
后通知(After advice) :当某连接点退出的时候执行的通知(不论是正常返回还是异常退出)。ApplicationContext中在<aop:aspect>里面使用<aop:after>元素进行声明。例如,TestAspect中的doAfter方法,所以AOPTest中调用BServiceImpl.barB抛出异常时,doAfter方法仍然执行
返回后通知(After return advice) :在某连接点正常完成后执行的通知,不包括抛出异常的情况。ApplicationContext中在<aop:aspect>里面使用<after-returning>元素进行声明。
环绕通知(Around advice) :包围一个连接点的通知,类似Web中Servlet规范中的Filter的doFilter方法。可以在方法的调用前后完成自定义的行为,也可以选择不执行。ApplicationContext中在<aop:aspect>里面使用<aop:around>元素进行声明。例如,TestAspect中的doAround方法。
抛出异常后通知(After throwing advice) : 在方法抛出异常退出时执行的通知。 ApplicationContext中在<aop:aspect>里面使用<aop:after-throwing>元素进行声明。例如,TestAspect中的doThrowing方法。
切入点表达式
通常情况下,表达式中使用”execution“就可以满足大部分的要求。表达式格式如下:
execution(modifiers-pattern? ret-type-pattern declaring-type-pattern? name-pattern(param-pattern) throws-pattern?)
modifiers-pattern:方法的操作权限
ret-type-pattern:返回值
declaring-type-pattern:方法所在的包
name-pattern:方法名
parm-pattern:参数名
throws-pattern:异常
以下是详细测试代码:
1、model
package dhp.model;
public class User {
private String username;
private String password;
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
}
2、userdao
package dhp.dao;
import dhp.model.User;
public interface UserDao {
public void save(User user);
}
3、userdaoImpl
package dhp.dao.impl;
import java.util.List;
import java.util.Map;
import java.util.Set;
import javax.management.RuntimeErrorException;
import org.springframework.stereotype.Component;
import dhp.dao.UserDao;
import dhp.model.User;
@Component("userDaoImpl")
public class UserDaoImpl implements UserDao {
private int daoId;
//private String daoStatus;
public int getDaoId() {
return daoId;
}
public void setDaoId(int daoId) {
this.daoId = daoId;
}
/*public String getDaoStatus() {
return daoStatus;
}
public void setDaoStatus(String daoStatus) {
this.daoStatus = daoStatus;
}
*/
private Set<String> sets;
private List<String> lists;
private Map<String, String> maps;
public Set<String> getSets() {
return sets;
}
public void setSets(Set<String> sets) {
this.sets = sets;
}
public List<String> getLists() {
return lists;
}
public void setLists(List<String> lists) {
this.lists = lists;
}
public Map<String, String> getMaps() {
return maps;
}
public void setMaps(Map<String, String> maps) {
this.maps = maps;
}
@Override
public void save(User user) {
System.out.println("user saved!");
//throw new RuntimeException("error message!");
//System.out.println("daoId:==="+daoId+"daoStatus:==="+daoStatus);
}
@Override
public String toString() {
/*return "sets size:" + sets.size() + "| lists size:" + lists.size() +
"| maps size:" + maps.size();*/
return "daoId:"+daoId;
}
}
4、userservice
package dhp.service;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.annotation.Resource;
import org.springframework.stereotype.Component;
import dhp.dao.UserDao;
import dhp.model.User;
@Component("userService")
public class UserService {
private UserDao userDao;
//构造方法注入
/*public UserService(UserDao userDao) {
super();
this.userDao = userDao;
}*/
@PostConstruct
public void init(){
System.out.println("=========init");
}
public void add(User user){
userDao.save(user);
}
public UserDao getUserDao() {
return userDao;
}
//set方式注入
/*@Autowired//默认通过byType
public void setUserDao(@Qualifier("userDao2") UserDao userDao) {
this.userDao = userDao;
}*/
//@Resource(name="userDao2")//默认按名称,名称找不到时,通过byType
@Resource(name="userDaoImpl")
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
@PreDestroy
public void destroy(){
System.out.println("==========destroy");
}
}
5、LogInterceptor
package dhp.aop;
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;
@Aspect
@Component
public class LogInterceptor {
//@Pointcut("execution(public * dhp.dao..*.*(..))") 子包下的任何类的任何方法的任何返回类型
@Pointcut("execution(public * dhp.service..*.add(..))") //cjlib.jar包
public void myMethod(){}
//@Before("execution(public void dhp.dao.impl.UserDaoImpl.save(dhp.model.User))")
//@Before("execution(public * dhp.dao..*.*(..))")
@Before("myMethod()")
public void before1(){
System.out.println("method* before!");
}
@AfterThrowing("myMethod()")
public void afterThrowing(){
System.out.println("runtime error!");
}
//@AfterReturning("execution(public void dhp.dao.impl.UserDaoImpl.save(dhp.model.User))")
@AfterReturning("myMethod()")
public void afterReturning(){
System.out.println("method after returning!");
}
@After("myMethod()")
public void after(){
System.out.println("after!");
}
@Around("myMethod()")
public void around(ProceedingJoinPoint pjp) throws Throwable{
System.out.println("method around start!");
pjp.proceed();
System.out.println("method around end!");
}
}
6、test
package dhp.service;
import static org.junit.Assert.*;
import org.junit.Test;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import dhp.dao.UserDao;
import dhp.model.User;
public class UserServiceTest {
@Test
public void testAdd() {
//ClassPathXmlApplicationContext继承自ApplicationContext,而ApplicationContext继承自BeanFactory
//推荐使用
ClassPathXmlApplicationContext ctx =new ClassPathXmlApplicationContext("beans.xml");
UserService userService = (UserService) ctx.getBean("userService");
System.out.println(userService.getClass());
userService.add(new User());
//System.out.println(userService.getUserDao());
ctx.destroy();
}
}
7、beans.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"
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/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd">
<context:annotation-config/>
<context:component-scan base-package="dhp"/>
<!-- aop注解方式 -->
<!-- <aop:aspectj-autoproxy/> -->
<!-- aop xml方式 -->
<bean id="logInterceptor" class="dhp.aop.LogInterceptor"></bean> <!-- 配置切面 -->
<aop:config>
<!-- 方式一 -->
<!-- <aop:pointcut expression="execution(public * dhp.dao..*.*(..))" id="servicePointCut"/> --> <!-- 配置切入点 -->
<aop:aspect id="logAspect" ref="logInterceptor">
<!-- 方式一 -->
<!-- <aop:before method="before1" pointcut-ref="servicePointCut"/> --><!-- 将切面和切入点编制在一起-->
<!-- 方式二 -->
<aop:before method="before1" pointcut="execution(public * dhp.dao..*.*(..))"/>
</aop:aspect>
</aop:config>
</beans>
1.在.xml文件中需要添加aop命名空间,导入与aop配置相关的标签。
2.AOP相关的配置在<aop:config>标签中,切入点的配置在<aop:pointcut>标签中。
3.execution是切入点的标识符,括号是切入点的表达式,配置需要增强的方法。
4.切入点表达式常用几种模糊匹配方式:
>public * addUser(com.able.entity.User),“*”表示配置所有类型的返回值。
>public void * (com.able.entity.User), "*"代表匹配所有的方法名。
>public void addUser(..), " .. "表示匹配所有参数个数和类型。
> * com.able.service.*.*( . . ), 表示匹配com.able.service包下面所有类的所有方法。
> * com.able.service . . *(), 表示匹配com.able.service包以及子包下所有类的所有方法。
增强处理类型简介:
1.前置增强处理
特点:在目标方法前织入增强处理。
<aop:before method="beforeService" poontcut-ref="servicePointcut"/>
如果想在这个方法中获得切入点的信息,使用如下方法:
package com.jbit.fsd.aop;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.aspectj.lang.JoinPoint;
public class ServiceLoging {
private Log log = LogFactory.getLog(this.getClass());
public void beforeService(JoinPoint joinPoint){
System.out.println("aop方法被调用");
System.out.println("连接点对象:"+joinPoint.getTarget().getClass().getSimpleName());
System.out.println("连接点方法:"+joinPoint.getSignature());
System.out.println("连接点方法参数:"+joinPoint.getArgs()[0]);
}
}
2.后置增强处理
特点:在目标方法正常执行(不出现异常)后织入增强处理。
<aop:after-returning method="afterReturning" pointcut-ref="servicePointcut"/>
如果需要获取返回值,添加returning="returnVal"
<aop:after-returning method="aft" pointcut-ref="ser" returning="returnVal"/>
public void afterService(Object returnVal){
System.out.println(returnVal);
}
3.异常增强处理
特点:在目标方法出现异常后织入增强处理。
<aop:after-throwing mehod=" " pointcut-ref=" " throwing ="ex"/>
如果需要获取异常对象才添加throwing="ex"
public void afterThrowing(Exception ex){
System.out.println(ex.getMessage());
}
4.最终增强处理
特点:不论方法是否抛异常,都会在目标方法最后织如增强处理,类似与finally。
<aop:after method="after" pointcut-ref="servicePointcut"/>
5.环绕增强处理
特点:在目标方法的前后都可以织入增强处理。
<aop:around method="" pointcut-ref="" />
public Boolean around(ProceedingJoinPoint pjp) throws Throwable{
System.out.println("目标方法的参数:"+pjp.getArgs()[0]);
Boolean b = null;
if (true) {
b = (Boolean) pjp.proceed(pjp.getArgs());
}
return b;
}