我们使用一个简单的例子来演示一下Spring中的AOP,这是一个log的例子,实际上log是一个对于AOP来说很不好的例子,这里我们只为说明Spring AOP的使用。
1.首先我们来创建一个自己的interceptor
这个类必须继承org.aopalliance.intercept. MethodInterceptor接口。Spring的AOP框架就是参照aopalliance这个标准实现的,所以我们的MyInterceptor要继承这个标准中的接口。
这个接口只有一个要求实现的方法:
public Object invoke(MethodInvocation methodInvocation) throws Throwable;
下面是我们的MyIntercptor:
public class MyInterceptor implements MethodInterceptor {
private final Log logger = LogFactory.getLog(getClass());
public Object invoke(MethodInvocation methodInvocation) throws Throwable {
logger.info("Beginning method (1): " +
methodInvocation.getMethod().getDeclaringClass() + "." +
methodInvocation.getMethod().getName() + "()");
long startTime = System.currentTimeMillis();
try{
Object result = methodInvocation.proceed();
return result;
}finally{
logger.info("Ending method (1): " +
methodInvocation.getMethod().getDeclaringClass() + "." +
methodInvocation.getMethod().getName() + "()");
logger.info("Method invocation time (1): " +
(System.currentTimeMillis() - startTime) + " ms.");
}
}
}
对于上面的代码需要说明的是下面两行代码:
Object result = methodInvocation.proceed();
return result;
整个程序的流程是这样的:
1,先是执行在Object result = methodInvocation.proceed();前面的代码;
2,接着执行Object result = methodInvocation.proceed();,它把执行控制权交给了interceptor stack(拦截器栈)内的下一个interceptor,如果没有了就交给真正的业务方法;
3,然后执行return result;之前的代码;
4,最后执行return result;,它把控制权交回它之上的interceptor,如果没有了就退出interceptor stack。
2.写出我们的业务对象及其接口
为了方便我们的业务接口只有一个hello方法:
public interface BusinessInterface {
public void hello();
}
业务对象的代码如下:
public class BusinessInterfaceImpl implements BusinessInterface{
public void hello() {
System.out.println("hello Spring AOP.");
}
}
3.接下来,我们来看看如何使用我们的写的interceptor
我们把业务对象作为AOP的target:
<bean id="businessTarget" class="com.rst.spring.testaop.BusinessInterfaceImpl"/>
接着在bean定义中声明interceptor:
<bean id="myInterceptor" class="com.rst.spring.testaop.MyInterceptor"/>
最后,我们来声明真正的业务对象,通过使用它的接口以及Spring的ProxyFactoryBean:
<bean id="businessBean"
class="org.springframework.aop.framework.ProxyFactoryBean">
<property name="proxyInterfaces">
<value>com.rst.spring.testaop.BusinessInterface</value>
</property>
<property name="interceptorNames">
<list>
<value>myInterceptor</value>
<value>businessTarget</value>
</list>
</property>
</bean>
这里需要说明两点:
proxyInterfaces:就是我们的业务对象的实际接口;
interceptorNames:定义了所有interceptors的执行顺序,其中业务对象的target作为list的最后一个。记着一定要把业务对象的target放到list中,否则你的业务对象就不会工作。
4.最后,写我们的测试类
ClassPathResource resource =
new ClassPathResource("com/rst/spring/testaop/aop_bean.xml");
XmlBeanFactory beanFactory = new XmlBeanFactory(resource);
BusinessInterface businessBean =
(BusinessInterface) beanFactory.getBean("businessBean");
businessBean.hello();
一切正常就可以在log上看到相应的信息了。
以下是附件源代码的执行效果:
2004-09-08 16:04:51,210 INFO - Beginning method (1): interface com.rst.spring.testaop.BusinessInterface.hello()
2004-09-08 16:04:51,210 INFO - Beginning method (2): interface com.rst.spring.testaop.BusinessInterface.hello()
hello Spring AOP.
2004-09-08 16:04:51,210 INFO - Ending method (2): interface com.rst.spring.testaop.BusinessInterface.hello()
2004-09-08 16:04:51,210 INFO - Ending method (1): interface com.rst.spring.testaop.BusinessInterface.hello()
2004-09-08 16:04:51,210 INFO - Method invocation time (1): 0 ms.
源代码需要spring.jar, aopallience.jar, commons-logging.jar。
分享到:
相关推荐
在这个例子中,`LoggingAspect`是一个切面,`logBefore`方法是一个前置通知,将在匹配的方法执行前运行。 除了这些基本的通知类型,还有`@AfterReturning`(后返回通知)、`@AfterThrowing`(异常抛出通知)和`@...
现在,我们来看如何创建一个简单的Spring AOP例子: 1. **定义切面(Aspect)**:切面是包含通知(Advice)和切入点(Pointcut)的类。通知定义了要执行的逻辑,切入点定义了何时执行。例如,我们可以创建一个名为`...
这个例子中,`LoggingAspect` 类定义了一个切面,包含两个通知:一个在方法执行前记录日志,另一个在方法执行后记录日志。切点表达式匹配了 `com.example.service` 包下的所有方法。 5. **配置** 要启用注解驱动...
在上面的例子中,我们定义了一个切点,匹配`com.example.service`包下的所有方法。 4. **使用代理**:Spring会根据需要自动创建代理对象来处理通知。默认情况下,Spring使用基于Java的代理,但对于需要在静态方法或...
在本入门例子中,你将学习如何在Spring环境中设置并使用AOP。 首先,我们需要理解AOP的基本概念。在面向对象编程中,业务逻辑代码往往会被一些通用的、非核心的代码(如日志、事务)所穿插,这降低了代码的可读性...
在这个经典例子中,我们将深入理解Spring AOP的核心概念,并通过实际操作来加深印象。 首先,AOP的核心是切面(Aspect),它封装了横切关注点,如日志记录、事务管理等。在Spring AOP中,切面通常由一个或多个通知...
Spring框架是Java开发中的核心组件,它通过控制反转(IOC)和面向切面编程(AOP)等特性,极大地简化了企业级应用的构建。在本教程中,我们将深入探讨这两个概念以及如何在MyEclipse环境中使用它们。下面将详细阐述...
在这个例子中,`LoggingAspect`定义了一个切面,`@Before`和`@AfterReturning`注解分别定义了前置和后置通知,切点匹配了com.example.service包下的所有方法。 五、总结 Spring AOP通过spring-aop.jar实现了面向切...
上述例子中的表达式匹配所有服务层的方法。 3. 配置AOP:在Spring配置文件或使用@Configuration注解的类中启用AOP并注册切面。 ```xml <aop:aspectj-autoproxy /> ``` 或 ```java @Configuration @...
在这个例子中,`LoggingAspect`定义了一个切点`serviceMethods()`,该切点匹配`com.example.service`包下的所有方法。`@Before`和`@AfterReturning`通知分别在方法执行前和返回后打印日志信息。 总结,Spring AOP...
在上面的例子中,`loggingAspect`切面引用了`LoggingAspect`类,`logBefore`方法会在匹配`execution(* com.example.service.*.*(..))`这个切入点表达式的任何方法执行前被调用。 另外,Spring的`spring-beans-2.0....
在本示例中,我们将深入探讨Spring框架2.5.6版本中的面向切面编程(AOP)概念。Spring AOP是Spring框架的核心组件之一,它允许开发者在不修改源代码的情况下,对程序进行横切关注点(如日志、事务管理、性能监控等)...
在这个例子中,`logBefore` 方法会在匹配的方法被调用前执行,其切点表达式 `execution(* com.example.service.*.*(..))` 表示所有在 `com.example.service` 包下的方法。 3. **注册切面**:在Spring配置文件中...
在这个例子中,我们定义了一个名为`LoggingAspect`的切面,包含两个通知:一个在方法执行前记录开始时间,另一个在方法正常返回后记录结束时间。这样,我们就能监控到每个服务方法的执行情况。 总之,Spring 3.0的...
在这个例子中,`LoggingAspect`定义了一个切面,其中包含了两个通知。`@Before`通知在匹配的方法执行前运行,`@AfterReturning`通知在方法正常返回后运行。切入点表达式`execution(* com.example.service.*.*(..))`...
在我们的例子中,我们将定义一个环绕通知(Around Advice),因为它允许我们在方法调用前后进行控制。使用`@Around`注解定义通知,并传入切入点方法名。 ```java @Around("controllerMethods()") public Object ...
在这个例子中,我们定义了一个名为`loggingAspect`的切面,引用了`loggingService` bean作为切面的实现。`logBefore`和`logAfter`方法将分别在匹配的连接点(即`com.example.service`包下的所有公共方法)执行之前和...
在Spring框架中,IOC(Inversion of Control,控制反转)和AOP(Aspect-Oriented Programming,面向切面编程)是两个核心的概念,它们极大地提高了软件开发的灵活性和可维护性。 **IOC(控制反转)**是Spring的核心...
在这个例子中,`MyAspect`类定义了一个切面,`logBefore`方法作为前置通知在执行`com.example.service`包下的所有方法前运行,`scheduledTask`方法是一个定时任务,每5秒执行一次。 通过结合Spring AOP和定时任务,...
在这个例子中,`loggingAspect`定义了一个切面,引用了`loggingService`这个bean作为切面实现。`logBefore`和`logAfter`是两个通知方法,分别在匹配的连接点之前和之后执行。`execution(* com.example.service.*.*(....