Spring Aop表达式以及EL表达式处理
在Spring AOP 中，通常需要借助AspectJ 的切点表达式语言来定义切点。重要的是Spring 中仅支持AspectJ切点指示器的一个子集。
Spring 支持的AspectJ的切点指示器| AspectJ 指示器 | 描述 |
| args() | 限制连接点匹配参数为执行类型的执行方法 |
| @args() | 限制连接点匹配参数由执行注解标注的执行方法 |
| execution() | 匹配连接点的执行方法 |
| this() | 限制连接点匹配AOP代理的Bean引用类型为指定类型的Bean |
| target() | 限制连接点匹配目标对象为指定类型的类 |
| @target() | 限制连接点匹配目标对象被指定的注解标注的类 |
| within() | 限制连接点匹配匹配指定的类型 |
| @within() | 限制连接点匹配指定注解标注的类型 |
| @annotation | 限制匹配带有指定注解的连接点 |
Spring AOP 中常用的是：
execution(modifiers-pattern? ret-type-pattern declaring-type-pattern? name-pattern(param-pattern)
throws-pattern?)
匹配所有
execution("* *.*(..)")
匹配所有以set开头的方法
execution("* *.set*(..))
匹配指定包下所有的方法
execution("* com.david.biz.service.impl.*(..))
匹配指定包以及其子包下的所有方法
execution("* com.david..*(..)")
匹配指定包以及其子包下 参数类型为String 的方法
execution("* com.david..*(java.lang.String))
@Service("bookService")
public class BookServiceImpl implements BookService {
private static final Logger logger = LogManager.getLogger(BookServiceImpl.class);
public static final String ADD_BOOK = "insert into t_book(id,name) values(1,'duck-j2ee')";
public static final String DELETE_BOOK = "delete from t_book where id=1";
private JdbcTemplate jdbcTemplate;
@Autowired
private BookDao bookDao;
public void addBook() throws Exception {
Book book = new Book();
book.setName("ibatis");
book.setPrice(11);
bookDao.insert(book);
throw new UnRollbackException("受检查异常，不会回滚");
}
public void deleteBook(int id) {
try {
bookDao.deleteById(id);
} catch (SQLException e) {
logger.error("", e);
}
}
@LoggingRequired
public void addNewBook(String name, int price) {
try {
Book book = new Book();
book.setName(name);
book.setPrice(price);
bookDao.insert(book);
List<Book> lists = bookDao.selectAll();
System.out.println(lists);
} catch (SQLException e) {
logger.error("", e);
}
}
public void addUserBook() {
jdbcTemplate.execute("insert into t_book(id,name) values(3,'UserBook')");
}
/**
* Setter method for property <tt>jdbcTemplate</tt>.
*
* @param jdbcTemplate value to be assigned to property jdbcTemplate
*/
public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
this.jdbcTemplate = jdbcTemplate;
}
/**
* @see com.david.biz.service.BookService#queryAll()
*/
public List<Book> queryAll() {
try {
return bookDao.selectAll();
} catch (SQLException e) {
logger.error("", e);
}
return null;
}
}
/**
* execution（modifiers-pattern? ret-type-pattern declaring-type-pattern? name-pattern（param-pattern）
throws-pattern?）
*arg() 限制连接点匹配参数为指定类型的执行方法
*@args() 限制连接点匹配参数由执行注解标注的执行
*execution() 用于匹配连接点的执行方法
*this() 限制连接点匹配AOP代理的Bean引用为执行类型的类
*target() 限制连接点匹配目标对象为指定类型的类
*@target() 限制连接点匹配特定的执行对象，这些对象应具备指定的注解类型
*@annotation（）限制匹配带有指定注解的连接点
*
*
*
* @author zhangwei_david
* @version $Id: LogAspect.java, v 0.1 2014年11月29日 下午1:10:13 zhangwei_david Exp $
*/
@Component
@Aspect
public class LogAspect {
private static final Logger logger = LogManager.getLogger(LogAspect.class);
/**
* 匹配参数是任何类型，任何数量 且在com,david.biz包或子包下的方法
*/
@Pointcut("args(..)&&within(com.david.biz..*)")
public void arg() {
}
@Pointcut("@args(com.david.aop.LoggingRequired)")
public void annotationArgs() {
}
@Pointcut("@annotation(com.david.aop.LoggingRequired)")
public void logRequiredPointcut() {
}
@Pointcut("args(java.lang.String,*)")
public void argsWithString() {
}
@Pointcut("target(com.david.biz.service.impl.BookServiceImpl)")
public void targetPointcut() {
}
@Pointcut("@target(org.springframework.stereotype.Service)")
public void targetAnnotation() {
}
// @Around("execution(* org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter.handle(..))")
// public Object aa(ProceedingJoinPoint pjp) throws Throwable {
// try {
// Object retVal = pjp.proceed();
// System.out.println(retVal);
// return retVal;
// } catch (Exception e) {
// System.out.println("异常");
// return null;
// }
// }
@Before(value = "logRequiredPointcut()")
public void before(JoinPoint joinPoint) {
LogUtils.info(logger,
" 连接点表达式@annotation(com.david.aop.LoggingRequired) - method={0} has been visited",
joinPoint.getSignature().getName());
}
@Before(value = "arg()")
public void beforeArg(JoinPoint joinPoint) {
LogUtils.info(logger,
"连接点表达式：args(..)&&within(com.david.biz..*) method ={0}, args ={1},target={2}",
joinPoint.getSignature().getName(), ToStringBuilder.reflectionToString(
joinPoint.getArgs(), ToStringStyle.SHORT_PREFIX_STYLE), joinPoint.getTarget()
.getClass().getName());
}
@Before(value = "argsWithString()")
public void beforeArgWithString(JoinPoint joinPoint) {
LogUtils.info(logger, "连接点表达式：args(java.lang.String,*) method={0} ,args ={1},target={2}",
joinPoint.getSignature().getName(), ToStringBuilder.reflectionToString(
joinPoint.getArgs(), ToStringStyle.SHORT_PREFIX_STYLE), joinPoint.getTarget()
.getClass().getName());
}
@Before(value = "annotationArgs()")
public void beforeAnnotationArgs(JoinPoint joinPoint) {
LogUtils
.info(
logger,
"连接点表达式：@args(com.david.annotation.validate.Length,*) method={0} ,args ={1},target={2}",
joinPoint.getSignature().getName(), ToStringBuilder.reflectionToString(
joinPoint.getArgs(), ToStringStyle.SHORT_PREFIX_STYLE), joinPoint.getTarget()
.getClass().getName());
}
@Before(value = "targetPointcut()")
public void beforeTarget(JoinPoint joinPoint) {
LogUtils
.info(
logger,
"连接点表达式：target(com.david.biz.service.impl.BookServiceImpl) method={0} ,args ={1},target={2}",
joinPoint.getSignature().getName(), ToStringBuilder.reflectionToString(
joinPoint.getArgs(), ToStringStyle.SHORT_PREFIX_STYLE), joinPoint.getTarget()
.getClass().getName());
}
@Before(value = " targetAnnotation()")
public void beforeTargetAnnotation(JoinPoint joinPoint) {
LogUtils
.info(
logger,
"连接点表达式：@target(org.springframework.stereotype.Service) method={0} ,args ={1},target={2}",
joinPoint.getSignature().getName(), ToStringBuilder.reflectionToString(
joinPoint.getArgs(), ToStringStyle.SHORT_PREFIX_STYLE), joinPoint.getTarget()
.getClass().getName());
}
}
2014-12-01 11:14:39 [ main:1577 ] - [ INFO ] 连接点表达式@annotation(com.david.aop.LoggingRequired) - method=addNewBook has been visited
2014-12-01 11:14:39 [ main:1587 ] - [ INFO ] 连接点表达式：args(..)&&within(com.david.biz..*) method =addNewBook, args =Object[][{Junit Test,1000}],target=com.david.biz.service.impl.BookServiceImpl
2014-12-01 11:14:39 [ main:1588 ] - [ INFO ] 连接点表达式：args(java.lang.String,*) method=addNewBook ,args =Object[][{Junit Test,1000}],target=com.david.biz.service.impl.BookServiceImpl
2014-12-01 11:14:39 [ main:1588 ] - [ INFO ] 连接点表达式：target(com.david.biz.service.impl.BookServiceImpl) method=addNewBook ,args =Object[][{Junit Test,1000}],target=com.david.biz.service.impl.BookServiceImpl
2014-12-01 11:14:39 [ main:1589 ] - [ INFO ] 连接点表达式：@target(org.springframework.stereotype.Service) method=addNewBook ,args =Object[][{Junit Test,1000}],target=com.david.biz.service.impl.BookServiceImpl
2014-12-01 11:14:39 [ main:1589 ] - [ INFO ] 连接点表达式：args(..)&&within(com.david.biz..*) method =insert, args =Object[][{Book[id=0,name=Junit Test,price=1000]}],target=com.david.biz.dao.impl.BookDaoImpl
2014-12-01 11:14:39 [ main:1590 ] - [ INFO ] 连接点表达式：@args(com.david.annotation.validate.Length,*) method=insert ,args =Object[][{Book[id=0,name=Junit Test,price=1000]}],target=com.david.biz.dao.impl.BookDaoImpl
2014-12-01 11:14:39 [ main:1591 ] - [ INFO ] 连接点表达式：args(java.lang.String,*) method=insert ,args =Object[][{demo.insert,Book[id=0,name=Junit Test,price=1000]}],target=com.ibatis.sqlmap.engine.impl.SqlMapClientImpl
在AOP中如果还需要获取方法的参数值应该怎么处理呢？
/**
* 获取被拦截方法对象
* <p/>
* MethodSignature.getMethod() 获取的是顶层接口或者父类的方法对象
* 而缓存的注解在实现类的方法上
* 所以应该使用反射获取当前对象的方法对象
*/
public Method getMethod(ProceedingJoinPoint pjp) {
//获取参数的类型
Class[] argTypes = ((MethodSignature) pjp.getSignature()).getMethod().getParameterTypes();
Method method = null;
try {
method = pjp.getTarget().getClass().getMethod(pjp.getSignature().getName(), argTypes);
} catch (NoSuchMethodException | SecurityException e) {
logger.error("操作日志记录异常 :", e);
}
return method;
}
private PromotionOpLog initPromotionOpLog(OpLogAnnotation opLogAnnotation, Method method, Object[] args) {
PromotionOpLog opLog = new PromotionOpLog();
opLog.setOpModule(opLogAnnotation.opModule());
opLog.setOpAction(opLogAnnotation.opAction());
try {
//获取被拦截方法参数名列表(使用Spring支持类库)
LocalVariableTableParameterNameDiscoverer u =
new LocalVariableTableParameterNameDiscoverer();
String[] paraNameArr = u.getParameterNames(method);
//SPEL上下文
StandardEvaluationContext context = new StandardEvaluationContext(); //把方法参数放入SPEL上下文中
for (int i = 0; i < paraNameArr.length; i++) {
context.setVariable(paraNameArr[i], args[i]);
}
//使用SPEL进行key的解析
if (StringUtils.isNotBlank(opLogAnnotation.opPkId())) {
opLog.setOpPkId(parser.parseExpression(opLogAnnotation.opPkId()).getValue(context, String.class));
}
if (StringUtils.isNotBlank(opLogAnnotation.creator())) {
opLog.setCreator(parser.parseExpression(opLogAnnotation.creator()).getValue(context, String.class));
}
Map<String, Object> opInfo = Maps.newHashMap();
StringBuffer path = new StringBuffer();
path.append(method.getDeclaringClass().getName()).append(".").append(method.getName());
opInfo.put("path", path);
for (int i = 0; i < paraNameArr.length; i++) {
if (i < args.length) {
if (args[i] instanceof Serializable) {
opInfo.put(paraNameArr[i], args[i]);
} else {
String parameterValue = null == args[i] ? "" : args[i].toString();
opInfo.put(paraNameArr[i], parameterValue);
}
} else {
opInfo.put(paraNameArr[i], "");
}
}
opLog.setOpInfo(FastJsonUtil.toJSONString(opInfo));
opLog.setCreateTime(new Timestamp(new Date().getTime()) );
} catch (Exception e) {
logger.info("操作日志记录-解析参数异常", e);
}
return opLog;
}
使用示例：
@OpLogAnnotation(opPkId = "#schemeVO.schemeId", opModule = OpLogConstant.OP_MODULE_ACTIVITY, opAction =
OpLogConstant.OP_ACTION_UPDATE, creator = "#schemeVO.creator")
public BaseResult<Long> saveAndPublishAndPauseScheme(ActivitySchemeVO schemeVO)
这样就可以通过AOP方式记录日志了
