从aop的概念和术语开始.这些术语不是spring特有的.不幸的是,这些术语不是特别直观;然而,如果使用spring自己的术语,将会更加混乱.
* Aspect切面:横切多个类的模块化内容.事务管理是一个很好的例子,在spring aop中切面符合xml的模版或使用注解@Aspect 两种实现方式.
* Join point连接点:执行过程中的一个点,例如执行方法或处理异常.在spring aop中总是代表方法执行
* Advice建议:一个切面在连接点处执行.不同的建议包括 "around", "before" and "after" .许多aop框架,包括spring,建议的模型就是拦截器,在连接点处维护拦截器链.
* Pointcut切点:连接点的详细描述.切点表达式和建议关联在一起,在任何匹配切点的连接点上执行(如明确的执行方法名称).匹配切点表达式的连接点概念是aop的核心,spring默认使用AspectJ 切点表达式语言.
* Introduction引入:声明其他方法或属性作为一个类型.spring aop允许你为建议的对象引入一个新的接口和实现.例如,使用引入使bean实现`Introduction`接口,简化缓存.
* Target object:目标对象:被一个或多个切面建议的对象,也表示建议对象本身.由于Spring AOP是使用运行时代理实现的,因此此对象将始终是代理对象。
* AOP proxy代理:aop框架创建的对象实现了切面的约束(建议方面执行等).在spring框架中,aop代理就是jdk动态代理或者CGLIB 代理
* Weaving编织:把切面和应用的其他类型或对象链接到一起来创建建议对象.这个编织过程可以在编译期,加载期或运行期.spring aop和其他纯java的aop框架一样,在运行期编织.
Types of advice:
* Before advice:建议在连接点之前执行,但是它没有能力阻止执行流程进入连接点(除非它抛出异常)。
* After returning advice:建议在连接点正常结束之后执行:例如方法return没有抛出异常
* After throwing advice:建议在方法抛出异常退出的时候执行
* After (finally) advice: 建议在连接点退出后执行,无论正常合适异常,都执行
* Around advice: 建议包围连接点如方法调用执行.这是非常强大的建议类型.在方法执行前后分别执行.它还负责选择是继续执行连接点还是通过返回自己的返回值或抛出异常来绕过方法的执行。
Around advice是最通用的建议类型,由于spring aop像AspectJ一样,提供了所有的建议类型,我们强烈建议,使用最小分范围的建议满足需求即可.例如,你只想在方法返回结果之后更新缓存,使用After returning advice比Around advice效果更好.使用合适的建议类型,编程更简单,减少不必要的错误.例如没必要在连接点调用Around advice建议的`proceed()` 方法.也就不用考虑调用失败的处理.
切点是aop的关键,区别于老旧的拦截器技术.切点能使建议独立于面向对象的结构定位.例如around advice提供的声明式事务管理,可以应用于跨越多个对象的一组方法(例如service层的业务方法)
- 正确打开本书的姿势
- 第一部分 Core
- 1. Ioc container
- 1.1. Introduction to the Spring IoC container and beans
- 1.2. Container overview
- 1.2.1. Configuration metadata
- 1.2.2. Instantiating a container
- 1.2.3. Using the container
- 1.3. Bean overview
- 1.3.1. Naming beans
- 1.3.2. Instantiating beans
- 1.4. Dependencies
- 1.4.1. Dependency Injection
- 1.4.2. Dependencies and configuration in detail
- 1.4.3. Using depends-on
- 1.4.4. Lazy-initialized beans
- 1.4.5. Autowiring collaborators
- 1.4.6. Method injection
- 1.5 Bean Scopes
- 1.6. Customizing the nature of a bean TODO
- 1.7. Bean definition inheritance TODO
- 1.8. Container Extension Points TODO
- 1.9. Annotation-based container configuration
- 1.9.1. @Required
- 1.9.2. @Autowired
- 1.9.3. Fine-tuning annotation-based autowiring with @Primary
- 1.9.4. Fine-tuning annotation-based autowiring with qualifiers TODO
- 1.9.5. Using generics as autowiring qualifiers TODO
- 1.9.6. CustomAutowireConfigurer TODO
- 1.10. Classpath scanning and managed components
- 1.10.1. @Component and further stereotype annotations
- 1.11. Using JSR 330 Standard Annotations TODO
- 1.12. Java-based container configuration
- 1.12.1. Basic concepts: @Bean and @Configuration
- 1.12.2. Instantiating the Spring container using AnnotationConfigApplicationContext
- 2. Resources
- 2.1. Introduction
- 2.2. The Resource interface
- 2.3. Built-in Resource implementations
- 2.3.1. UrlResource
- 2.3.2. ClassPathResource
- 2.3.3. FileSystemResource
- 2.3.4. ServletContextResource
- 2.3.5. InputStreamResource
- 2.3.6. ByteArrayResource
- 2.4. The ResourceLoader
- 2.5. The ResourceLoaderAware interface
- 2.6. Resources as dependencies
- 2.7. Application contexts and Resource paths
- 2.7.1. Constructing application contexts
- 2.7.2. Wildcards in application context constructor resource paths
- 2.7.3. FileSystemResource caveats
- 3. Validation, Data Binding, and Type Conversion
- 4. Spring Expression Language (SpEL)
- 5. Aspect Oriented Programming with Spring
- 5.1. Introduction
- 5.1.1. AOP concepts
- 5.1.2. Spring AOP capabilities and goals
- 5.1.3. AOP Proxies
- 5.2. @AspectJ support
- 5.2.1. Enabling @AspectJ Support
- 5.2.2. Declaring an aspect
- 5.2.3. Declaring a pointcut
- 5.2.4. Declaring advice
- 5.2.5. Introductions TODO
- 5.2.6. Aspect instantiation models TODO
- 5.2.7. Example
- 5.3. Schema-based AOP support TODO
- 5.4. Choosing which AOP declaration style to use TODO
- 5.5. Mixing aspect types TODO
- 5.6. Proxying mechanisms
- 5.6.1. Understanding AOP proxies
- 5.7. Programmatic creation of @AspectJ Proxies
- 5.8. Using AspectJ with Spring applications
- 5.8.1. Using AspectJ to dependency inject domain objects with Spring
- 5.8.2. Other Spring aspects for AspectJ
- 第二部分 Testing
- 第三部分 Data Access
- 1. Transaction Management
- 1.1. Introduction to Spring Framework transaction management
- 1.2 Advantages of the Spring Framework’s transaction support model
- 1.2.1. Global transactions
- 1.2.2. Local transactions
- 1.2.3. Spring Framework’s consistent programming model
- 1.3. Understanding the Spring Framework transaction abstraction
- 1.4. Synchronizing resources with transactions
- 1.4.1. High-level synchronization approach
- 1.4.2. Low-level synchronization approach
- 1.4.3. TransactionAwareDataSourceProxy
- 1.5. Declarative transaction management
- 1.5.1. Understanding the Spring Framework’s declarative transaction implementation
- 1.5.2. Example of declarative transaction implementation
- 1.5.3. Rolling back a declarative transaction
- 1.5.4. Configuring different transactional semantics for different beans
- 1.5.5. tx:advice元素的 settings
- 1.5.6. Using @Transactional
- 1.5.7. Transaction propagation
- 1.5.8. Advising transactional operations
- 1.5.9. Using @Transactional with AspectJ TODO
- 第四部分 web servlet
- 第五部分 Web Reactive
- 第六部分 Integration
- 第七部分 Languages