Java面向切面编程AOP怎么实现

这篇文章主要介绍“Java面向切面编程aop怎么实现”，在日常操作中，相信很多人在Java面向切面编程AOP怎么实现问题上存在疑惑，小编查阅了各式资料，整理出简单好用的操作方法，希望对大家解答”Java面向切面编程AOP怎么实现”的疑惑有所帮助！接下来，请跟着小编一起来学习吧！

一：背景
spring的AOP的存在目的是为了解耦。AOP可以让一组类共享相同的行为。在OOP中只能通过继承类和实现接口，来是代码的耦合度增强，且类继承只能为单继承，阻碍更多行为添加到一组类上，AOP弥补了OPP的不足。

二：概述  Spring支持AspectJ的注解方式切面编程

1.使用@Aspect 声明一个切面。

2.使用@After,@Before,@Around 定义建言（advice）,可直接将拦截规则（切点）作为参数。

3.其中@After,@Before,@Around参数的拦截规则为切点（PointCut） ,为了使切点复用，可使用@PointCut 专门定义拦截规则，然后在@After,@Before,@Around的参数中调用。

4.其中符合条件的每一个被拦截处为连接点（JoinPoint）

三：代码实例

1.pom.xml

点击(此处)折叠或打开

1. <dependency>
   

2.             <groupId>org.springframework</groupId>
   

3.             <artifactId>spring-core</artifactId>
   

4.         </dependency>
   

5.         <dependency>
   

6.             <groupId>org.springframework</groupId>
   

7.             <artifactId>spring-beans</artifactId>
   

8.         </dependency>
   

10.         <dependency>
    

11.             <groupId>org.springframework</groupId>
    

12.             <artifactId>spring-context</artifactId>
    

13.         </dependency>
    

15.         <dependency>
    

16.             <groupId>org.springframework</groupId>
    

17.             <artifactId>spring-aop</artifactId>
    

18.         </dependency>
    

20.         <dependency>
    

21.             <groupId>org.aspectj</groupId>
    

22.             <artifactId>aspectjrt</artifactId>
    

23.         </dependency>
    

25.         <dependency>
    

26.             <groupId>org.aspectj</groupId>
    

27.             <artifactId>aspectjweaver</artifactId>
    

28.         </dependency>

拦截规则的注解

点击(此处)折叠或打开

1. @Target(ElementType.METHOD)
   

2. @Retention(RetentionPolicy.RUNTIME)
   

3. @Documented
   

4. public @interface Action {
   

5.     String name();
   

6. }

注解的被拦截类

点击(此处)折叠或打开

1. @Service
   

2. public class DemoAnnotationService {
   

4.     @Action(name = "注解式拦截的add操作")
   

5.     public void add() {
   

6.        System.out.println("======DemoAnnotationService方法add()=========");
   

7.     }
   

8. }

方法规则被拦截类

点击(此处)折叠或打开

1. @Service
   

2. public class DemoMethodService {
   

3.     public String add() throws Exception{
   

4.         System.out.println("======DemoMethodService方法add()=========");
   

5.         int i=100/0;
   

6.         return "SUCCESS";
   

7.     }
   

8. }

4.编写切面

点击(此处)折叠或打开

1. @Aspect
   

2. @Component
   

3. public class LogAspect {
   

5.     @Pointcut("@annotation(com.gemdale.gmap.spring.boot.demo.Action)")
   

6.     public void annotationPointCut() {
   

7.     }
   

9.     @After("annotationPointCut()")
   

10.     public void after(JoinPoint joinPoint) {
    

11.         MethodSignature signature = (MethodSignature) joinPoint.getSignature();
    

12.         Method method = signature.getMethod();
    

13.         Action action = method.getAnnotation(Action.class);
    

15.         System.out.println("注解式拦截 " + action.name());
    

16.     }
    

18.     @Before("execution(* com.gemdale.gmap.spring.boot.demo.DemoMethodService.*(..))")
    

19.     public void methodBefore(JoinPoint joinPoint) {
    

20.         MethodSignature signature = (MethodSignature) joinPoint.getSignature();
    

21.         Method method = signature.getMethod();
    

22.         System.out.println("before方法规则式拦截 " + method.getName());
    

23.     }
    

25.     @After("execution(* com.gemdale.gmap.spring.boot.demo.DemoMethodService.*(..))")
    

26.     public void methodAfter(JoinPoint joinPoint) {
    

27.         MethodSignature signature = (MethodSignature) joinPoint.getSignature();
    

28.         Method method = signature.getMethod();
    

29.         System.out.println("after方法规则式拦截 " + method.getName());
    

30.     }
    

32.     @AfterReturning(pointcut = "execution(* com.gemdale.gmap.spring.boot.demo.DemoMethodService.*(..))", returning = "result")
    

33.     public void methodAfterResult(JoinPoint joinPoint, Object result) {
    

34.         MethodSignature signature = (MethodSignature) joinPoint.getSignature();
    

35.         Method method = signature.getMethod();
    

36.         System.out.println("after result方法规则式拦截 " + method.getName() + "result=" + result);
    

37.     }
    

39.     @AfterThrowing(pointcut = "execution(* com.gemdale.gmap.spring.boot.demo.DemoMethodService.*(..))", throwing = "e")
    

40.     public void methodAfterException(JoinPoint joinPoint, Exception e) {
    

41.         MethodSignature signature = (MethodSignature) joinPoint.getSignature();
    

42.         Method method = signature.getMethod();
    

43.         System.out.println("after exception方法规则式拦截 " + method.getName() + " e=" + e.getMessage());
    

44.     }
    

46. }

配置类

点击(此处)折叠或打开

1. @Configuration
   

2. @ComponentScan("com.gemdale")
   

3. @EnableAspectJAutoProxy
   

4. public class AppliactionConfig {
   

6. }

6.执行类

点击(此处)折叠或打开

1. public class Start {
   

2.     public static void main(String[] args) throws Exception{
   

4.         AnnotationConfigApplicationContext configApplicationContext = new AnnotationConfigApplicationContext(
   

5.                 AppliactionConfig.class);
   

6.         // UseFunctionService
   

7.         // useFunctionService=configApplicationContext.getBean(UseFunctionService.class);
   

8.         // System.out.println(useFunctionService.sayHello("GenGChong"));
   

9.         DemoAnnotationService demoAnnotationService = configApplicationContext.getBean(DemoAnnotationService.class);
   

10.         DemoMethodService demoMethodService = configApplicationContext.getBean(DemoMethodService.class);
    

12.         demoAnnotationService.add();
    

14.         demoMethodService.add();
    

16.         configApplicationContext.close();
    

17.     }
    

18. }

到此，关于“Java面向切面编程AOP怎么实现”的学习就结束了，希望能够解决大家的疑惑。理论与实践的搭配能更好的帮助大家学习，快去试试吧！若想继续学习更多相关知识，请继续关注编程网网站，小编会继续努力为大家带来更多实用的文章！