AspectJ对AOP的实现

朴灿烈づ我的快乐病毒、 2022-02-21 15:39 223阅读 0赞

## 一:你应该明白的知识 ##

**1.对于AOP这种编程思想，很多框架都进行了实现。**  
Spring就是其中之一，可以完成面向切面编程。然而，AspectJ也实现了AOP的功能，且实现方式更为简捷，使用更加方便，而且还支持注解式开发。所以，Spring又将AspectJ对于AOP的实现也引入到了自己的框架中。在Spring中使用AOP开发时，一般使用AspectJ的实现方式。

**2.Spring的经典AOP配置方案**  
01.使用的是Aspectj第三方框架，实现了AOP思想  
02.注解配置的AOP  
03.纯POJO aop:config

**3…切入点表达式**  
execution(【modifiers-pattern?】 访问修饰符  
ret-type-pattern 返回值类型  
【declaring-type-pattern?】 全限定性类名  
name-pattern(param-pattern) 方法名(参数名)  
【throws-pattern?】) 抛出异常类型

切入点表达式要匹配的对象就是目标方法的方法名。所以，execution表达式中明显就是方法的签名。注意：表达式中加\[\]的部分表示可省略部分，各部分间用空格分开。在其中可以使用以下符号：  
符号 意义

*      0至多个任意字符
    ..     用在方法参数中，表示任意多个参数
       
    
           用在包名后，表示当前包及其子包路径
    +    用在类名后，表示当前类及其子类
           用在接口后，表示当前接口及其实现类

案例：

execution(public * *(..)) 指定切入点为：任意公共方法
    execution(* set*(..)) 指定切入点为：任何一个以"set"开始的方法

## 二.使用的是Aspectj第三方框架注解配置的AOP增强 ##

源码介绍:  
**1.ISomeService.java**

package entity;
    //业务接口
    public interface ISomeService {
        //1.1  执行事务
       public void doTransaction();
        //1.2 书写日志
       public String doLog();
    }

**2.SomeServiceImpl.java**

package entity;
    //接口的实现类
    public class SomeServiceImpl implements ISomeService {
        //实现接口中的方法
        @Override
        public void doTransaction() {
            System.out.println("----开启事务----");
        }
    
        @Override
        public String doLog() {
            //int i=5/0;//制造一个错误，用于测试异常增强
            System.out.println("---书写日志-----");
            return "abc";
        }
    
    }

**3.MyAspect.java（使用的是Aspectj第三方框架注解配置的AOP增强）**

package aop;
    //aspectj注解实现aop增强
    import org.aspectj.lang.ProceedingJoinPoint;
    import org.aspectj.lang.annotation.After;
    import org.aspectj.lang.annotation.AfterReturning;
    import org.aspectj.lang.annotation.AfterThrowing;
    import org.aspectj.lang.annotation.Around;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Before;
    
    //该类为切面
    @Aspect
    public class MyAspect {
    
        // 前置通知
        @Before(value = "execution(public * *..ISomeService.doLog(..))")
        public void myBefore() {
            System.out.println("这是前置增强");
        }
    
        // 后置通知
        @AfterReturning(value = "execution(public * *..ISomeService.doLog(..))")
        public void myAfterReturning() {
            System.out.println("这是后置增强");
        }
    
        // 环绕增强
        @Around(value = "execution(public * *..ISomeService.doLog(..))")
        public void myAround(ProceedingJoinPoint pjp) throws Throwable {
            System.out.println("这是环绕前置增强");
    
            pjp.proceed();
    
            System.out.println("这是环绕后置增强");
        }
    
        // 异常增强
        @AfterThrowing(value = "execution(public * *..ISomeService.doLog(..))")
        public void myAfterThrowing() {
            System.out.println("这是异常增强");
        }
    
        // 最终增强
        @After(value = "execution(public * *..ISomeService.doLog(..))")
        public void myAfter() {
            System.out.println("这是最终增强");
        }
    }

**4.applicationContext.xml（Spring的配置文件）**

**5.MyTest.java**

package test;
    //测试类
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    import entity.ISomeService;
    
    public class MyTest {
        public static void main(String[] args) {
            ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
            ISomeService biz=(ISomeService)ctx.getBean("someService");
            biz.doLog();
            biz.doTransaction();
            System.out.println("success!");
        }
    
    }

**6.log4j.properties（日志配置文件）**

### direct log messages to stdout ###
    log4j.appender.stdout=org.apache.log4j.ConsoleAppender
    log4j.appender.stdout.Target=System.out
    log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
    log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
    
    ### direct messages to file mylog.log ###
    log4j.appender.file=org.apache.log4j.FileAppender
    log4j.appender.file.File=c\:mylog.log
    log4j.appender.file.layout=org.apache.log4j.PatternLayout
    log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
    
    ### set log levels - for more verbose logging change 'info' to 'debug' ###
    
    log4j.rootLogger=info, stdout

## 三:使用的是Aspectj第三方框架 纯POJO 基于Schema配置 (aop:config) ##

**1.MyAspect.java**

package aop;
    
    import org.aspectj.lang.JoinPoint;
    import org.aspectj.lang.ProceedingJoinPoint;
    
    public class MyAspect {
        // 前置通知
        public void myBefore() {
            System.out.println("这是前置增强");
        }
    
        public void before(JoinPoint jp) {
            System.out.println("前置通知方法before() jp = " + jp);
        }
    
        // 后置通知
        public void myAfterReturning() {
            System.out.println("这是后置增强");
        }
    
        // 带参数
        public void afterReturing(String result) {
            System.out.println("后置通知方法 result = " + result);
        }
    
        // 环绕通知
        public Object around(ProceedingJoinPoint pjp) throws Throwable {
            System.out.println("环绕通知方法，目标方法执行之前");
            // 执行目标方法
            Object result = pjp.proceed();
            System.out.println("环绕通知方法，目标方法执行之后");
            return ((String) result).toUpperCase();
        }
    
        // 异常通知
        public void afterThrowing() {
            System.out.println("异常通知方法");
        }
    
        public void afterThrowing(Exception ex) {
            System.out.println("异常通知方法 ex = " + ex.getMessage());
        }
    
        // 最终通知
        public void after() {
            System.out.println("最终通知方法");
        }
    }

**2.applicationContext.xml（Spring的配置文件）**

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
        xmlns:aop="http://www.springframework.org/schema/aop"
        xsi:schemaLocation="
            http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
        
        <bean id="someService" class="entity.SomeServiceImpl"></bean>
    
        
        <bean id="myAspect" class="aop.MyAspect"></bean>
    
        <aop:config>
            
            <aop:pointcut expression="execution(public * *..ISomeService.doLog(..))"
                id="beforePointcut" />
            <aop:aspect ref="myAspect">
                
                
                <aop:before method="myBefore" pointcut-ref="beforePointcut" />
                
                <aop:before method="before(org.aspectj.lang.JoinPoint)"
                    pointcut-ref="beforePointcut" />
                
                <aop:after-returning method="myAfterReturning"
                    pointcut-ref="beforePointcut" />
                
                <aop:after-returning method="afterReturing(java.lang.String)"
                    pointcut-ref="beforePointcut" returning="result" />
                
                <aop:around method="around" pointcut-ref="beforePointcut" />
                
                <aop:after-throwing method="afterThrowing"
                    pointcut-ref="beforePointcut" />
                
                <aop:after-throwing method="afterThrowing(java.lang.Exception)"
                    pointcut-ref="beforePointcut" throwing="ex" />
                
                <aop:after method="after" pointcut-ref="beforePointcut" />
            </aop:aspect>
        </aop:config>
    </beans>