Spring Aop 切点表达式

在Spring AOP 中，通常需要借助AspectJ 的切点表达式语言来定义切点。重要的是Spring 中仅支持AspectJ切点指示器的一个子集。

Spring 支持的AspectJ的切点指示器

AspectJ 指示器 描述
args() 限制连接点匹配参数为执行类型的执行方法
@args() 限制连接点匹配参数由执行注解标注的执行方法
execution() 匹配连接点的执行方法
this() 限制连接点匹配AOP代理的Bean引用类型为指定类型的Bean
target() 限制连接点匹配目标对象为指定类型的类
@target() 限制连接点匹配目标对象被指定的注解标注的类
within() 限制连接点匹配匹配指定的类型
@within() 限制连接点匹配指定注解标注的类型
@annotation 限制匹配带有指定注解的连接点

Spring AOP 中常用的是：

Java代码 

  1. execution(modifiers-pattern? ret-type-pattern declaring-type-pattern? name-pattern(param-pattern)
  2. throws-pattern?)
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))

Java代码 

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3. xmlns:p="http://www.springframework.org/schema/p" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4. xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"
  5. xmlns:aop="http://www.springframework.org/schema/aop" xmlns:jee="http://www.springframework.org/schema/jee"
  6. xmlns:task="http://www.springframework.org/schema/task"
  7. xsi:schemaLocation="
  8. http://www.springframework.org/schema/beans
  9. http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
  10. http://www.springframework.org/schema/context
  11. http://www.springframework.org/schema/context/spring-context-3.0.xsd
  12. http://www.springframework.org/schema/aop
  13. http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
  14. http://www.springframework.org/schema/tx
  15. http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
  16. http://www.springframework.org/schema/jee
  17. http://www.springframework.org/schema/jee/spring-jee-3.0.xsd
  18. http://www.springframework.org/schema/task
  19. http://www.springframework.org/schema/task/spring-task-3.1.xsd
  20. ">
  21. <context:component-scan base-package="com.david.*"/>
  22. <aop:aspectj-autoproxy />
  23. <context:property-placeholder location="classpath:META-INF/config.properties" />
  24. <!-- 定义数据源 -->
  25. <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"
  26. destroy-method="close">
  27. <property name="driverClass" value="${jdbc.ams.driver}" />
  28. <property name="jdbcUrl" value="${jdbc.ams.url}" />
  29. <property name="user" value="${jdbc.ams.username}" />
  30. <property name="password" value="${jdbc.ams.password}" />
  31. <property name="initialPoolSize" value="${initialSize}" />
  32. <property name="minPoolSize" value="${minPoolSize}" />
  33. <property name="maxPoolSize" value="${maxActive}" />
  34. <property name="acquireIncrement" value="${acquireIncrement}" />
  35. <property name="maxIdleTime" value="${maxIdleTime}" />
  36. </bean>
  37. <!-- 定义jdbc模板类 -->
  38. <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
  39. <property name="dataSource" ref="dataSource" />
  40. </bean>
  41. <bean id="sqlMapClient" class="org.springframework.orm.ibatis.SqlMapClientFactoryBean">
  42. <property name="dataSource" ref="dataSource" />
  43. <property name="configLocation" value="classpath:META-INF/sqlmap/sqlmap.xml" />
  44. </bean>
  45. <tx:advice id="txAdvice" transaction-manager="transactionManager">
  46. <tx:attributes>
  47. <tx:method name="addBook" propagation="REQUIRED" />
  48. <tx:method name="addUserBook" propagation="MANDATORY" />
  49. <tx:method name="deleteBook" propagation="REQUIRES_NEW" />
  50. <tx:method name="addNewBook" propagation="NEVER" />
  51. <tx:method name="addUser" propagation="NESTED" />
  52. </tx:attributes>
  53. </tx:advice>
  54. <bean id="transactionManager"
  55. class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  56. <property name="dataSource" ref="dataSource" />
  57. </bean>
  58. </beans>
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:p="http://www.springframework.org/schema/p" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:aop="http://www.springframework.org/schema/aop" xmlns:jee="http://www.springframework.org/schema/jee"
	xmlns:task="http://www.springframework.org/schema/task"
	xsi:schemaLocation="
		http://www.springframework.org/schema/beans
		http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
		http://www.springframework.org/schema/context
		http://www.springframework.org/schema/context/spring-context-3.0.xsd
		http://www.springframework.org/schema/aop
		http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
		http://www.springframework.org/schema/tx
		http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
		http://www.springframework.org/schema/jee
		http://www.springframework.org/schema/jee/spring-jee-3.0.xsd
		http://www.springframework.org/schema/task
        http://www.springframework.org/schema/task/spring-task-3.1.xsd
		">
	<context:component-scan base-package="com.david.*"/>
	<aop:aspectj-autoproxy />
	<context:property-placeholder location="classpath:META-INF/config.properties" />
	<!-- 定义数据源 -->
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"
		destroy-method="close">
		<property name="driverClass" value="${jdbc.ams.driver}" />
		<property name="jdbcUrl" value="${jdbc.ams.url}" />
		<property name="user" value="${jdbc.ams.username}" />
		<property name="password" value="${jdbc.ams.password}" />
		<property name="initialPoolSize" value="${initialSize}" />
		<property name="minPoolSize" value="${minPoolSize}" />
		<property name="maxPoolSize" value="${maxActive}" />
		<property name="acquireIncrement" value="${acquireIncrement}" />
		<property name="maxIdleTime" value="${maxIdleTime}" />
	</bean>

	<!-- 定义jdbc模板类 -->
	<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
		<property name="dataSource" ref="dataSource" />
	</bean>

	<bean id="sqlMapClient" class="org.springframework.orm.ibatis.SqlMapClientFactoryBean">
		<property name="dataSource" ref="dataSource" />
		<property name="configLocation" value="classpath:META-INF/sqlmap/sqlmap.xml" />
	</bean>

	<tx:advice id="txAdvice" transaction-manager="transactionManager">
		<tx:attributes>
			<tx:method name="addBook" propagation="REQUIRED" />
			<tx:method name="addUserBook" propagation="MANDATORY" />
			<tx:method name="deleteBook" propagation="REQUIRES_NEW" />
			<tx:method name="addNewBook" propagation="NEVER" />
			<tx:method name="addUser" propagation="NESTED" />
		</tx:attributes>
	</tx:advice>
	<bean id="transactionManager"
		class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource" />
	</bean>

</beans>

Java代码 

  1. @Service("bookService")
  2. public class BookServiceImpl implements BookService {
  3. private static final Logger logger      = LogManager.getLogger(BookServiceImpl.class);
  4. public static final String  ADD_BOOK    = "insert into t_book(id,name) values(1,‘duck-j2ee‘)";
  5. public static final String  DELETE_BOOK = "delete from  t_book where id=1";
  6. private JdbcTemplate        jdbcTemplate;
  7. @Autowired
  8. private BookDao             bookDao;
  9. public void addBook() throws Exception {
  10. Book book = new Book();
  11. book.setName("ibatis");
  12. book.setPrice(11);
  13. bookDao.insert(book);
  14. throw new UnRollbackException("受检查异常，不会回滚");
  15. }
  16. public void deleteBook(int id) {
  17. try {
  18. bookDao.deleteById(id);
  19. } catch (SQLException e) {
  20. logger.error("", e);
  21. }
  22. }
  23. @LoggingRequired
  24. public void addNewBook(String name, int price) {
  25. try {
  26. Book book = new Book();
  27. book.setName(name);
  28. book.setPrice(price);
  29. bookDao.insert(book);
  30. List<Book> lists = bookDao.selectAll();
  31. System.out.println(lists);
  32. } catch (SQLException e) {
  33. logger.error("", e);
  34. }
  35. }
  36. public void addUserBook() {
  37. jdbcTemplate.execute("insert into t_book(id,name) values(3,‘UserBook‘)");
  38. }
  39. /**
  40. * Setter method for property <tt>jdbcTemplate</tt>.
  41. *
  42. * @param jdbcTemplate value to be assigned to property jdbcTemplate
  43. */
  44. public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
  45. this.jdbcTemplate = jdbcTemplate;
  46. }
  47. /**
  48. * @see com.david.biz.service.BookService#queryAll()
  49. */
  50. public List<Book> queryAll() {
  51. try {
  52. return bookDao.selectAll();
  53. } catch (SQLException e) {
  54. logger.error("", e);
  55. }
  56. return null;
  57. }
  58. }
@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;
    }

}

Java代码 

  1. /**
  2. * execution（modifiers-pattern? ret-type-pattern declaring-type-pattern? name-pattern（param-pattern）
  3. throws-pattern?）
  4. *arg()  限制连接点匹配参数为指定类型的执行方法
  5. *@args() 限制连接点匹配参数由执行注解标注的执行
  6. *execution() 用于匹配连接点的执行方法
  7. *this() 限制连接点匹配AOP代理的Bean引用为执行类型的类
  8. *target() 限制连接点匹配目标对象为指定类型的类
  9. *@target() 限制连接点匹配特定的执行对象，这些对象应具备指定的注解类型
  10. *@annotation（）限制匹配带有指定注解的连接点
  11. *
  12. *
  13. *
  14. * @author zhangwei_david
  15. * @version $Id: LogAspect.java, v 0.1 2014年11月29日 下午1:10:13 zhangwei_david Exp $
  16. */
  17. @Component
  18. @Aspect
  19. public class LogAspect {
  20. private static final Logger logger = LogManager.getLogger(LogAspect.class);
  21. /**
  22. * 匹配参数是任何类型，任何数量 且在com,david.biz包或子包下的方法
  23. */
  24. @Pointcut("args(..)&&within(com.david.biz..*)")
  25. public void arg() {
  26. }
  27. @Pointcut("@args(com.david.aop.LoggingRequired)")
  28. public void annotationArgs() {
  29. }
  30. @Pointcut("@annotation(com.david.aop.LoggingRequired)")
  31. public void logRequiredPointcut() {
  32. }
  33. @Pointcut("args(java.lang.String,*)")
  34. public void argsWithString() {
  35. }
  36. @Pointcut("target(com.david.biz.service.impl.BookServiceImpl)")
  37. public void targetPointcut() {
  38. }
  39. @Pointcut("@target(org.springframework.stereotype.Service)")
  40. public void targetAnnotation() {
  41. }
  42. //    @Around("execution(* org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter.handle(..))")
  43. //    public Object aa(ProceedingJoinPoint pjp) throws Throwable {
  44. //        try {
  45. //            Object retVal = pjp.proceed();
  46. //            System.out.println(retVal);
  47. //            return retVal;
  48. //        } catch (Exception e) {
  49. //            System.out.println("异常");
  50. //            return null;
  51. //        }
  52. //    }
  53. @Before(value = "logRequiredPointcut()")
  54. public void before(JoinPoint joinPoint) {
  55. LogUtils.info(logger,
  56. " 连接点表达式@annotation(com.david.aop.LoggingRequired) - method={0} has been visited",
  57. joinPoint.getSignature().getName());
  58. }
  59. @Before(value = "arg()")
  60. public void beforeArg(JoinPoint joinPoint) {
  61. LogUtils.info(logger,
  62. "连接点表达式：args(..)&&within(com.david.biz..*)  method ={0}, args ={1},target={2}",
  63. joinPoint.getSignature().getName(), ToStringBuilder.reflectionToString(
  64. joinPoint.getArgs(), ToStringStyle.SHORT_PREFIX_STYLE), joinPoint.getTarget()
  65. .getClass().getName());
  66. }
  67. @Before(value = "argsWithString()")
  68. public void beforeArgWithString(JoinPoint joinPoint) {
  69. LogUtils.info(logger, "连接点表达式：args(java.lang.String,*)  method={0} ,args ={1},target={2}",
  70. joinPoint.getSignature().getName(), ToStringBuilder.reflectionToString(
  71. joinPoint.getArgs(), ToStringStyle.SHORT_PREFIX_STYLE), joinPoint.getTarget()
  72. .getClass().getName());
  73. }
  74. @Before(value = "annotationArgs()")
  75. public void beforeAnnotationArgs(JoinPoint joinPoint) {
  76. LogUtils
  77. .info(
  78. logger,
  79. "连接点表达式：@args(com.david.annotation.validate.Length,*)  method={0} ,args ={1},target={2}",
  80. joinPoint.getSignature().getName(), ToStringBuilder.reflectionToString(
  81. joinPoint.getArgs(), ToStringStyle.SHORT_PREFIX_STYLE), joinPoint.getTarget()
  82. .getClass().getName());
  83. }
  84. @Before(value = "targetPointcut()")
  85. public void beforeTarget(JoinPoint joinPoint) {
  86. LogUtils
  87. .info(
  88. logger,
  89. "连接点表达式：target(com.david.biz.service.impl.BookServiceImpl)  method={0} ,args ={1},target={2}",
  90. joinPoint.getSignature().getName(), ToStringBuilder.reflectionToString(
  91. joinPoint.getArgs(), ToStringStyle.SHORT_PREFIX_STYLE), joinPoint.getTarget()
  92. .getClass().getName());
  93. }
  94. @Before(value = " targetAnnotation()")
  95. public void beforeTargetAnnotation(JoinPoint joinPoint) {
  96. LogUtils
  97. .info(
  98. logger,
  99. "连接点表达式：@target(org.springframework.stereotype.Service)  method={0} ,args ={1},target={2}",
  100. joinPoint.getSignature().getName(), ToStringBuilder.reflectionToString(
  101. joinPoint.getArgs(), ToStringStyle.SHORT_PREFIX_STYLE), joinPoint.getTarget()
  102. .getClass().getName());
  103. }
  104. }
/**
 * 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());
    }
}

Java代码 

  1. /**
  2. *
  3. * @author zhangwei_david
  4. * @version $Id: T.java, v 0.1 2014年12月1日 上午9:35:44 zhangwei_david Exp $
  5. */
  6. @RunWith(SpringJUnit4ClassRunner.class)
  7. @ContextConfiguration(locations = "file:H:/workspace4study/WebApp/src/main/webapp/WEB-INF/applicationContext.xml")
  8. public class BookServiceTest {
  9. @Autowired
  10. private BookService bookService;
  11. @Test
  12. public void testB() {
  13. bookService.addNewBook("Junit  Test", 1000);
  14. }
  15. }
/**
 *
 * @author zhangwei_david
 * @version $Id: T.java, v 0.1 2014年12月1日 上午9:35:44 zhangwei_david Exp $
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "file:H:/workspace4study/WebApp/src/main/webapp/WEB-INF/applicationContext.xml")
public class BookServiceTest {

    @Autowired
    private BookService bookService;

    @Test
    public void testB() {
        bookService.addNewBook("Junit  Test", 1000);
    }

}

Java代码 

  1. 2014-12-01 11:14:39  [ main:1577 ] - [ INFO ]   连接点表达式@annotation(com.david.aop.LoggingRequired) - method=addNewBook has been visited
  2. 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
  3. 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
  4. 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
  5. 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
  6. 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
  7. 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
  8. 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
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

萌萌的IT人

时间： 2024-08-25 14:57:04

Spring Aop 切点表达式的相关文章

Spring AOP切点表达式用法总结

1. 简介 面向对象编程,也称为OOP(即Object Oriented Programming)最大的优点在于能够将业务模块进行封装,从而达到功能复用的目的.通过面向对象编程,不同的模板可以相互组装,从而实现更为复杂的业务模块,其结构形式可用下图表示: 面向对象编程解决了业务模块的封装复用的问题,但是对于某些模块,其本身并不独属于摸个业务模块,而是根据不同的情况,贯穿于某几个或全部的模块之间的.例如登录验证,其只开放几个可以不用登录的接口给用户使用(一般登录使用拦截器实现,但是其切面思想是一致

使用注解匹配Spring Aop切点表达式

Spring中的类基本都会标注解,所以使用注解匹配切点可以满足绝大部分需求 主要使用@within()/@target @annotaton() @args()等... 匹配@Service类中的所有方法: @within(org.springframework.stereotype.Service) 或 @target(org.springframework.stereotype.Service) 匹配标注了@RequestMapping的所有方法 @annotation(org.spring

Spring AOP 切点(pointcut)表达式

这遍文章将介绍Spring AOP切点表达式(下称表达式)语言,首先介绍两个面向切面编程中使用到的术语. 连接点(Joint Point):广义上来讲,方法.异常处理块.字段这些程序调用过程中可以抽像成一个执行步骤(或者说执行点)的单元.从Spring AOP来讲,就是指java的方法和异常处理代码块. 切点(Pointcut):是连接点的描述定义,Spring AOP通过切点来定位到哪些连接点.切点表达式语言就是切点用来定义连接点的语法. 切点指示符 切点指示符是切点定义的关键字,切点表达式以

必备技能：spring aop 切入点表达式，你都会么？

本文主要介绍spring aop中9种切入点表达式的写法 execute within this target args @target @within @annotation @args 1.execute表达式 拦截任意公共方法 execution(public * *(..)) 拦截以set开头的任意方法 execution(* set*(..)) 拦截类或者接口中的方法 execution(* com.xyz.service.AccountService.*(..)) 拦截Account

AOP切点表达式

Aspectj切入点语法定义 在使用spring框架配置AOP的时候,不管是通过XML配置文件还是注解的方式都需要定义pointcut"切入点" 例如定义切入点表达式  execution (* com.sample.service.impl..*.*(..)) execution()是最常用的切点函数,其语法如下所示: 整个表达式可以分为五个部分: 1.execution(): 表达式主体. 2.第一个*号:表示返回类型,*号表示所有的类型. 3.包名:表示需要拦截的包名,后面的两个

AspectJ风格的Aop切点表达式

execution(*com.aptech.jb.epet.dao.hibimpl.*.*(..)) 这样写应该就可以了,这是com.aptech.jb.epet.dao.hibimpl 包下所有的类的所有方法. 第一个*代表所有的返回值类型 第二个*代表所有的类 第三个*代表类所有方法 最后一个..代表所有的参数. Spring AOP 用户可能会经常使用 execution切入点指示符.执行表达式的格式如下: execution(modifiers-pattern? ret-type-pat

spring aop execution表达式说明

在使用spring框架配置AOP的时候,不管是通过XML配置文件还是注解的方式都需要定义pointcut"切入点" 例如定义切入点表达式 execution(* com.sample.service.impl..*.*(..)) execution()是最常用的切点函数,其语法如下所示: 整个表达式可以分为五个部分: 1.execution(): 表达式主体. 2.第一个*号:表示返回类型,*号表示所有的类型. 3.包名:表示需要拦截的包名,后面的两个句点表示当前包和当前包的所有子包,

spring expression切点表达式

1.切点指示器 类型如下: 1.execution: *用来匹配连接点方法的,用的最多的一种指示器,可以匹配多个类,必须要写返回类型,方法名,方法参数,可以写通配符. 2.within: 用来匹配符合条件的所有类的连接点方法,不可以指定返回类型和方法参数,可以用通配符.expression="within( com.pointcut.impl.*)",匹配com.pointcut.impl包下的所有类的连接点方法. 3.target: 动态代理生成的对象,这种指示器一般表示某个动态代理

spring AOP excution表达式各符号意思

execution(*com.sample.service.impl..*.*(..)) 符号 含义 execution() 表达式的主题 第一个"*"符号 表示返回值的类型任意: com.sample.service.impl AOP所切的服务的包名 包名后面的".." 表示当前包及子包 第二个"*" 表示类名,*即所有类.可自定义 .*(..) 表示任何方法名,括号表示参 数,两个点表示任何参数类型 原文地址:https://www.cnbl