Spring 一二事(10) - annotation AOP

简介: 先贴出POM的内容,这个毕竟是用的maven来简单构建的 1 2 4.0.0 3 org.springframework.samples 4 maven-spring002-aop 5 0.

先贴出POM的内容,这个毕竟是用的maven来简单构建的

 1 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 2   <modelVersion>4.0.0</modelVersion>
 3   <groupId>org.springframework.samples</groupId>
 4   <artifactId>maven-spring002-aop</artifactId>
 5   <version>0.0.1-SNAPSHOT</version>
 6   
 7   <properties>
 8 
 9         <!-- Generic properties -->
10         <java.version>1.7</java.version>
11         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
12         <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
13 
14         <!-- Spring -->
15         <spring-framework.version>3.2.3.RELEASE</spring-framework.version>
16 
17         <!-- Logging -->
18         <logback.version>1.0.13</logback.version>
19         <slf4j.version>1.7.7</slf4j.version>
20 
21         <!-- Test -->
22         <junit.version>4.11</junit.version>
23         
24         <!-- aspectj -->
25 <!--         <aspectj.version>1.8.7</aspectj.version> -->
26         <aspectj.version>1.6.6</aspectj.version>
27 
28     </properties>
29     
30     <dependencies>
31         <!-- Spring and Transactions -->
32         <dependency>
33             <groupId>org.springframework</groupId>
34             <artifactId>spring-context</artifactId>
35             <version>${spring-framework.version}</version>
36         </dependency>
37         <dependency>
38             <groupId>org.springframework</groupId>
39             <artifactId>spring-tx</artifactId>
40             <version>${spring-framework.version}</version>
41         </dependency>
42 
43         <!-- Logging with SLF4J & LogBack -->
44         <dependency>
45             <groupId>org.slf4j</groupId>
46             <artifactId>slf4j-api</artifactId>
47             <version>${slf4j.version}</version>
48             <scope>compile</scope>
49         </dependency>
50         <dependency>
51             <groupId>ch.qos.logback</groupId>
52             <artifactId>logback-classic</artifactId>
53             <version>${logback.version}</version>
54             <scope>runtime</scope>
55         </dependency>
56 
57         <!-- Test Artifacts -->
58         <dependency>
59             <groupId>org.springframework</groupId>
60             <artifactId>spring-test</artifactId>
61             <version>${spring-framework.version}</version>
62             <scope>test</scope>
63         </dependency>
64         <dependency>
65             <groupId>junit</groupId>
66             <artifactId>junit</artifactId>
67             <version>${junit.version}</version>
68             <scope>test</scope>
69         </dependency>
70 
71         <dependency>
72             <groupId>org.aspectj</groupId>
73             <artifactId>aspectjweaver</artifactId>
74             <version>${aspectj.version}</version>
75         </dependency>
76 
77     </dependencies>
78 
79     <build>
80         <plugins>
81             <plugin>
82                 <groupId>org.apache.maven.plugins</groupId>
83                 <artifactId>maven-compiler-plugin</artifactId>
84                 <configuration>
85                     <source>1.7</source>
86                     <target>1.7</target>
87                 </configuration>
88             </plugin>
89         </plugins>
90     </build> 
91 
92 </project>

关于AOP的配置,我个人还是喜欢用XML来配置,一来方便管理,看的清楚,一个项目的aop也不会太多,二来注解形式的不好管理

applicationContext.xml的话只要有2行就行

1    <context:component-scan base-package="com.lee.spring003.aop.annotation"></context:component-scan>
2     
3     <!-- 自动创建代理 -->
4     <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

ITeacherDAO.java

1 package com.lee.spring003.aop.annotation;
2 
3 public interface ITeacherDAO {
4     public String saveTeacher();
5 }

TeacherDAOImpl.java

 1 package com.lee.spring003.aop.annotation;
 2 
 3 import org.springframework.stereotype.Repository;
 4 
 5 @Repository("teacherDAO")
 6 public class TeacherDAOImpl implements ITeacherDAO {
 7 
 8     @Override
 9     public String saveTeacher() {
10         System.out.println("TeacherDAOImpl - saveTeacher()");
11         return "save successfully";
12     }
13 
14 }

Transaction.java

 1 package com.lee.spring003.aop.annotation;
 2 
 3 import org.aspectj.lang.annotation.AfterReturning;
 4 import org.aspectj.lang.annotation.Aspect;
 5 import org.aspectj.lang.annotation.Before;
 6 import org.aspectj.lang.annotation.Pointcut;
 7 import org.springframework.stereotype.Component;
 8 
 9 @Component("transaction")
10 @Aspect
11 public class Transaction {
12     
13     @Pointcut("execution(* com.lee.spring003.aop.annotation.TeacherDAOImpl.*(..))")
14     public void beginTransactionPointCut() {    // 方法签名
15     };
16     
17     @Before("beginTransactionPointCut()")
18     public void beginTransaction() {
19         System.out.println("Begin transaction...");
20     }
21     
22     @AfterReturning("beginTransactionPointCut()")
23     public void commit() {
24         System.out.println("Transaction commit...");
25     } 
26     
27 }

 

github地址:https://github.com/leechenxiang/maven-spring002-aop

 

相关文章
|
6天前
|
运维 Java 程序员
Spring5深入浅出篇:基于注解实现的AOP
# Spring5 AOP 深入理解:注解实现 本文介绍了基于注解的AOP编程步骤,包括原始对象、额外功能、切点和组装切面。步骤1-3旨在构建切面,与传统AOP相似。示例代码展示了如何使用`@Around`定义切面和执行逻辑。配置中,通过`@Aspect`和`@Around`注解定义切点,并在Spring配置中启用AOP自动代理。 进一步讨论了切点复用,避免重复代码以提高代码维护性。通过`@Pointcut`定义通用切点表达式,然后在多个通知中引用。此外,解释了AOP底层实现的两种动态代理方式:JDK动态代理和Cglib字节码增强,默认使用JDK,可通过配置切换到Cglib
|
6天前
|
XML Java 数据格式
Spring使用AOP 的其他方式
Spring使用AOP 的其他方式
15 2
|
6天前
|
XML Java 数据格式
Spring 项目如何使用AOP
Spring 项目如何使用AOP
19 2
|
11天前
|
Java 开发者 Spring
Spring AOP的切点是通过使用AspectJ的切点表达式语言来定义的。
【5月更文挑战第1天】Spring AOP的切点是通过使用AspectJ的切点表达式语言来定义的。
23 5
|
11天前
|
XML Java 数据格式
Spring AOP
【5月更文挑战第1天】Spring AOP
27 5
|
12天前
|
Java 编译器 开发者
Spring的AOP理解
Spring的AOP理解
|
12天前
|
XML Java 数据格式
如何在Spring AOP中定义和应用通知?
【4月更文挑战第30天】如何在Spring AOP中定义和应用通知?
17 0
|
12天前
|
安全 Java 开发者
在Spring框架中,IoC和AOP是如何实现的?
【4月更文挑战第30天】在Spring框架中,IoC和AOP是如何实现的?
22 0
|
13天前
|
缓存 监控 Java
【Spring系列笔记】AOP
面向切面编程就是面向特定方法编程。通过将横切关注点(cross-cutting concerns)从主要业务逻辑中分离出来,提供一种更好的代码模块化和可维护性。 横切关注点指的是在应用程序中横跨多个模块或层的功能,例如日志记录、事务管理、安全性、缓存、异常处理等。
25 0
|
17天前
|
Java Spring
Spring AOP
Spring AOP
15 0