`
zhangwei_david
  • 浏览: 476073 次
  • 性别: Icon_minigender_1
  • 来自: 杭州
社区版块
存档分类
最新评论

Spring Aop 切点表达式

阅读更多

   在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))

 

 

<?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>

 

 

@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());
    }
}

 

/**
 *
 * @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);
    }

}

 

 

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

 

 

1
0
分享到:
评论

相关推荐

    spring aop jar 包

    例如,可以使用`@Aspect`注解定义一个切面类,`@Before`、`@After`等注解来声明通知,`@Pointcut`定义切点表达式。 在实际开发中,Spring AOP广泛应用于事务管理。例如,我们可以定义一个切面来处理所有数据库操作...

    SpringAOP切点函数实现原理详解

    本篇文章将深入探讨Spring AOP切点函数的实现原理。 首先,我们来看一下在函数入参中使用通配符的情况。Spring AOP的切点函数支持三种通配符:`*`、`...` 和 `+`。`*` 可以匹配任意单个字符,常用于方法名或返回...

    spring aop依赖jar包

    现在,我们回到主题——"springaop依赖的jar包"。在Spring 2.5.6版本中,使用Spring AOP通常需要以下核心jar包: - `spring-aop.jar`:这是Spring AOP的核心库,包含了AOP相关的类和接口。 - `spring-beans.jar`:...

    Spring AOP完整例子

    在Spring XML配置中,我们可以使用`&lt;aop:config&gt;`元素来定义切点表达式,然后使用`&lt;aop:aspect&gt;`元素来声明切面,并将通知方法与切点关联起来。此外,还可以使用注解驱动的配置,通过`@EnableAspectJAutoProxy`注解...

    SpringAOP.rar_springAOP

    Spring AOP允许我们定义切点表达式,精确地指定何时应用通知。 二、Spring AOP的核心组件 2.1 切面 切面是包含通知和切点的逻辑单元。在Spring中,可以通过注解或XML配置来定义切面。 2.2 通知类型 - 前置通知...

    死磕Spring之AOP篇 - Spring AOP两种代理对象的拦截处理(csdn)————程序.pdf

    在深入理解 Spring AOP 的源码时,需要熟悉 Spring IoC 的工作原理,以及 AOP 相关的概念,如切点表达式、通知类型等。了解这些基础知识可以帮助我们更好地掌握 Spring AOP 的实现细节。在分析源码时,可以参考作者...

    Spring Aop四个依赖的Jar包

    切点表达式`execution(* com.example.service.*.*(..))`表示拦截`com.example.service`包下的所有类的所有方法。 总的来说,Spring AOP通过这四个关键的Jar包,结合AspectJ的强大功能和CGLIB的代理机制,为开发者...

    在自定义spring aop中使用el获取拦截方法的变量值。

    标题中的“在自定义Spring AOP中使用EL获取拦截方法的变量值”指的是在Spring的面向切面编程(AOP)中,通过Expression Language(EL,表达式语言)来访问被拦截方法的局部变量值。这通常涉及到Spring的代理机制、...

    spring AOP依赖三个jar包

    - **切点定义**:使用AspectJ的切点表达式(例如`execution(* com.example.service.*.*(..))`),定义需要增强的方法或类。 - **通知类型**:包括前置通知(before)、后置通知(after)、返回后通知(after ...

    spring aop 学习笔记

    - `org.springframework.aop.aspectj.AspectJExpressionPointcut` 实现了切点表达式的解析和匹配。 6. **工具支持** - 使用AspectJ Weaver工具可以在编译时进行织入,提高运行效率。 - Spring AOP与AspectJ的...

    SpringAOP测试Demo

    在"SpringAOP测试Demo"中,我们通常会涉及以下几个核心概念和操作: 1. **切面(Aspect)**:切面是关注点的一个模块化,它包括了连接点、通知、目标对象、织入和引入。在Spring AOP中,切面通常由一个或多个注解的...

    spring-aop实例

    切点表达式通常基于方法签名、注解或其他条件,例如`execution(* com.example.service.*.*(..))`表示匹配com.example.service包下的所有方法。 4. **切入点表达式(Pointcut Expression)**:这是定义切点的语法,...

    spring aop 附带测试实例

    在提供的压缩包文件"springAOP"中,可能包含了以下内容: - **切面类(Aspect Class)**:包含切点和通知的Java类,可能使用了`@Aspect`注解。 - **目标类(Target Class)**:被AOP代理的对象,通常包含业务逻辑。...

    springAOP配置动态代理实现

    4. **切点表达式**:切点表达式用于匹配目标方法,可以基于方法名、参数类型等进行匹配。例如,`execution(* com.example.service.*.*(..))`表示匹配com.example.service包下所有类的所有方法。 二、Spring AOP的...

    day39-Spring 06-Spring的AOP:带有切点的切面

    而`DefaultPointcutAdvisor`和`AspectJExpressionPointcut`则用于管理和解析切点表达式。 5. **工具支持**:在实际开发中,IDE工具如IntelliJ IDEA和Eclipse提供了强大的AOP支持。它们可以帮助我们快速检查切点...

    SPRING AOP详细培训视频

    例如,`@Aspect`注解用于标记一个类作为切面,`@Before`、`@After`等用于标记通知,`@Pointcut`用于定义切点表达式。 视频教程中提到的"AOP快速入门"部分可能涵盖了以下内容: 1. AOP基本概念的介绍,包括切面、...

    springboot+aspect实现springaop拦截指定方法.zip

    6. **AspectJ**:AspectJ是一个全面的AOP语言,比Spring AOP更强大,它可以处理更复杂的切点表达式和通知逻辑。在SpringBoot项目中,通过引入AspectJ的依赖,我们可以编写AspectJ风格的切面,这通常涉及使用`@Aspect...

    spring aop注解版

    除了上述基本注解,Spring还提供了`@Within`、`@Args`、`@Target`、`@Annotation`等更多复杂的切点表达式,可以根据实际需求进行组合,实现更精细化的切面逻辑。 总结起来,Spring AOP注解版通过简单易懂的注解,...

    SpringAOP.zip

    Spring AOP,全称为Aspect Oriented Programming,是Spring框架中的一个重要模块,主要负责处理系统中的...文件"5.SpringAOP_01"和"6.SpringAOP_02"很可能是课程的分阶段内容,涵盖了从基础概念到进阶实践的详细讲解。

    spring AOP 引入jar包,spring IOC 引入Jar包

    Spring AOP 和 Spring IOC 是 Spring 框架的两个核心组件,它们对于任何基于 Java 的企业级应用开发都至关重要。Spring AOP(面向切面编程)允许开发者在不修改源代码的情况下,通过“切面”来插入新的行为或增强已...

Global site tag (gtag.js) - Google Analytics