首先介绍AOP的术语,为了理解AOP,我们必须了解这些术语。
Advice(通知):在AOP的术语中,切面的工作被称为通知
Spring 中可以使用 5中类型的通知
Before-在方法调用之前调用通知。
After-在方法调用之后调用通知,无论方法执行是否成功。
After-returning-在方法成功执行之后调用通知
After-throwing-在方法抛出异常后调用通知
Around-通知包裹了被通知的方法,在被通知的方法调用之前和调用之后执行自定义的行为
Joinpoint(连接点):连接点是在应用执行过程中能够插入切面的一个点
Pointcut(切点):如果说通知定义了切面的“什么”和“何时”,那么切丁就是定义了切面的“何处”。切点的定义会匹配通知所要织入的一个或多个连接点。
切面(Aspect):切面是切点和通知的结合。通知和切点定义了关于切面的全部内容-它是在什么,在什么时候以及何处完成其功能。
织入(Weaving):织入是将切面应用到目标对象来创建代理对象的过程。切面在指定的连接点被织入到切面对象中。在目标对象的生命周期中有多个点可以进行织入。
- 编译期-切面在目标对象编译时被织入。这种方式需要特殊的编译器。AspectJ的织入编译器就是以这种方式织入切面的。
- 类加载期-切面在目标对象加载到JVM时被织入。这种方式需要特殊的类加载器,它可以在目标对象被引入到应用中之前增强该类的字节码。
- 运行期-切面在运行的某个时刻被织入。在一般情况下,在织入切面时,AOP容器会为目标对象动态地创建一个代理对象。Spring AOP就是以这种方式织入切面的。
有如下接口
package spring.aop.perform; public interface Performer { void perform(); }
package spring.aop.perform; import org.apache.log4j.Logger; public class Juggler implements Performer { private static Logger logger=Logger.getLogger(Juggler.class); private int beanBags; public void perform() { logger.info("JUGGLING "+beanBags+"BEANBAGS"); } public int getBeanBags() { return beanBags; } public void setBeanBags(int beanBags) { this.beanBags = beanBags; } }
import org.apache.log4j.Logger;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
@Aspect
public class Audience {
private static Logger logger = Logger.getLogger(Audience.class);
@Pointcut("execution(* spring.aop.perform.Performer.perform(..))")
public void performance() {
}
@Before("performance()")
public void takeSeats() {
logger.info(" The audience is taking their seats.");
}
@Before("performance()")
public void turnOffCellPhone() {
logger.info("The audience is turning off the cellPhone");
}
@AfterReturning("performance()")
public void applaud() {
logger.info("CLAP CLAP....");
}
@AfterThrowing("performance()")
public void demandRefund() {
logger.info("Boo! We want my money back!");
}
}
测试方法
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:beans.xml")
public class PerformerTest {
@Autowired
private Performer juggler;
@Test
public void testPerform() {
juggler.perform();
}
}
</context:component-scan>
<aop:aspectj-autoproxy />
<aop:config>
<aop:aspect ref="audience">
<aop:before pointcut="execution(* spring.aop.perform.Performer.perform(..))"
method="takeSeats" />
<aop:before pointcut="execution(* *.perform(..))"
method="turnOffCellPhone" />
</aop:aspect>
</aop:config>
<bean id="audience" class="spring.aop.perform.Audience" />
[JMS] 609 - INFO -2014-01-30 10:55:44,826 [main] org.springframework.context.support.GenericApplicationContext - Bean 'scheduler' of type [class org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler] is not eligible for getting processed by all BeanPostProcessors (for example: not eligible for auto-proxying)
[JMS] 625 - INFO -2014-01-30 10:55:44,842 [main] org.springframework.beans.factory.support.DefaultListableBeanFactory - Pre-instantiating singletons in org.springframework.beans.factory.support.DefaultListableBeanFactory@209444d1: defining beans [calculatorLogginAspect,org.springframework.context.annotation.internalConfigurationAnnotationProcessor,org.springframework.context.annotation.internalAutowiredAnnotationProcessor,org.springframework.context.annotation.internalRequiredAnnotationProcessor,org.springframework.context.annotation.internalCommonAnnotationProcessor,org.springframework.aop.config.internalAutoProxyCreator,org.springframework.aop.aspectj.AspectJPointcutAdvisor#0,org.springframework.aop.aspectj.AspectJPointcutAdvisor#1,audience,arithmeticCalculator,unitCalculator,executor,scheduler,org.springframework.context.annotation.internalAsyncAnnotationProcessor,org.springframework.context.annotation.internalScheduledAnnotationProcessor,juggler,connectionFactory,mailDestination,jmsTemplate,frontDesk,mailMessageConverter,backOffice,org.springframework.context.annotation.ConfigurationClassPostProcessor.importAwareProcessor]; root of factory hierarchy
[JMS] 1094 - INFO -2014-01-30 10:55:45,311 [main] spring.aop.perform.Audience - The audience is taking their seats.
[JMS] 1094 - INFO -2014-01-30 10:55:45,311 [main] spring.aop.perform.Audience - The audience is taking their seats.
[JMS] 1094 - INFO -2014-01-30 10:55:45,311 [main] spring.aop.perform.Audience - The audience is turning off the cellPhone
[JMS] 1094 - INFO -2014-01-30 10:55:45,311 [main] spring.aop.perform.Audience - The audience is turning off the cellPhone
[JMS] 1094 - INFO -2014-01-30 10:55:45,311 [main] spring.aop.perform.Juggler - JUGGLING 3BEANBAGS
[JMS] 1094 - INFO -2014-01-30 10:55:45,311 [main] spring.aop.perform.Audience - CLAP CLAP....
[JMS] 1110 - INFO -2014-01-30 10:55:45,327 [Thread-1] org.springframework.context.support.GenericApplicationContext - Closing org.springframework.context.support.GenericApplicationContext@1a84da23: startup date [Thu Jan 30 10:55:44 CST 2014]; root of context hierarchy
[JMS]
相关推荐
1. **Spring Core**:这是Spring框架的基础,提供了依赖注入(Dependency Injection,DI)和面向切面编程(Aspect-Oriented Programming,AOP)的支持。DI允许我们解耦组件,使它们更易于测试和维护,而AOP则提供了...
综上所述,《AspectJ in Action: Enterprise AOP with Spring Applications》这本书不仅是一本关于面向切面编程的权威指南,还提供了大量实用案例和最佳实践建议,对于希望深入了解Spring-AspectJ集成的企业级开发者...
6. **Spring AOP**:介绍面向切面编程的概念,如何定义和应用切面,以及如何使用Spring的声明式事务管理。 7. **Spring Boot**:讨论Spring Boot的快速启动特性,如何简化Spring应用的配置和部署。 8. **Spring ...
它提倡依赖注入(Dependency Injection,DI)和面向切面编程(Aspect-Oriented Programming,AOP),简化了Java EE开发。 2. **依赖注入**:书中详细解释了依赖注入的概念,它是Spring的核心特性之一。通过容器管理...
2. **AOP(面向切面编程)**:Spring提供了强大的AOP支持,允许开发者定义方法拦截器和切点,用于实现如日志记录、事务管理等横切关注点。AOP的核心概念包括切面、通知、连接点、切点、代理等。 3. **数据访问集成*...
这本书详细介绍了如何利用Spring进行企业级Java应用开发,包括依赖注入、AOP(面向切面编程)、数据访问、Web开发以及Spring Boot等现代开发实践。 1. **依赖注入**:Spring的核心特性之一,通过容器管理对象的生命...
Spring的核心特性包括依赖注入(DI)、面向切面编程(AOP)、事务管理等,这些都极大地提高了代码的可测试性和可维护性。 2. **依赖注入**:Spring的核心设计原则之一是依赖注入,它允许开发者将对象间的依赖关系交...
通过阅读和运行这些代码,你可以更深入地理解Spring如何处理依赖注入、AOP(面向切面编程)、事务管理、数据访问以及Web开发等核心概念。 1. **依赖注入**:Spring的核心特性之一就是依赖注入,它简化了组件之间的...
这本书涵盖了从基础到高级的多个Spring核心概念和技术,包括依赖注入、AOP(面向切面编程)、数据访问、Web开发以及Spring Boot等。 1. **依赖注入(Dependency Injection, DI)**:Spring的核心特性之一,它通过容器...
《AspectJ in Action》是一本深入探讨切面编程(AOP,Aspect-Oriented Programming)技术的专业书籍,特别关注AspectJ这一强大的Java语言扩展。AspectJ是面向切面编程的领头羊,它允许开发者在不破坏代码结构的前提...
它提供了一个强大的IoC容器,支持依赖注入(Dependency Injection, DI),同时也提供了面向切面编程(Aspect Oriented Programming, AOP)的支持。Spring框架的目标是让Java EE开发变得更加简单,减少代码量,提高可...
1. **全面覆盖Spring核心功能**:本书全面覆盖了Spring框架的核心特性,包括依赖注入(Dependency Injection, DI)、面向切面编程(Aspect-Oriented Programming, AOP)、事务管理(Transaction Management)等。...
Spring In Action 第二版涵盖了Spring框架的核心概念,包括依赖注入、AOP(面向切面编程)、事务管理、数据访问以及Web开发等多个方面。作者通过实例和实战场景,详细讲解了如何利用Spring来构建高效、可维护的Java...
Spring的核心特性包括依赖注入(DI)、面向切面编程(AOP)、事务管理等。依赖注入能够降低程序组件之间的耦合度,提高系统的灵活性和可测试性;面向切面编程让开发者可以定义方法执行过程中的横切关注点(如日志、...
2. **面向切面编程**:Spring AOP允许开发者定义“切面”,这些切面可以包含业务逻辑的各个部分,如日志、事务管理等,使得代码更加模块化和可重用。 3. **Spring MVC**:Spring的Web框架,提供模型-视图-控制器...
Spring 3.0版本引入了许多新的功能和增强,包括对Java EE 6的支持、对RESTful Web服务的全面支持、增强的AOP(面向切面编程)功能、对JMS(Java消息服务)和JMX(Java管理扩展)的改进,以及对动态语言的支持等。...
Spring是一个广泛使用的Java企业级应用开发框架,以其依赖注入(Dependency Injection, DI)和面向切面编程(Aspect-Oriented Programming, AOP)为核心特性,极大地简化了Java应用程序的构建。 1. **Spring框架...
Spring的核心设计理念包括依赖注入(Dependency Injection, DI)和面向切面编程(Aspect-Oriented Programming, AOP),这些概念在书中会有详尽的阐述。 1. **依赖注入**:Spring通过DI来管理对象之间的依赖关系,...