Spring5框架——AOP操作：通过Aspectj注解方式和配置文件方式来实现-Toy模板网

这篇具有很好参考价值的文章主要介绍了Spring5框架——AOP操作：通过Aspectj注解方式和配置文件方式来实现。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

o((⊙﹏⊙))o.
Spring5框架——AOP操作：通过Aspectj注解方式和配置文件方式来实现,Spring,小白学基础,java,spring,junit

之前的博客介绍了什么是AOP，以及AOP的底层原理，AOP主要是在原本的基础上添加一些之外的功能但是添加的功能是不会修改原定的代码，接下来为你介绍的是Aspectj注解，Spring
框架一般都是基于 AspectJ 实现 AOP 操作。AspectJ 不是 Spring 组成部分，独立 AOP 框架，一般把
AspectJ 和 Spirng 框架一起使用，进行 AOP 操作。

基于Aspectj实现Aop操作
1.基于xml配置文件来实现
2.使用注解的方式来实现

***切入点表达式
1.作用：可以知道对哪个类中的哪个方法进行增强
2.表达式：execution([权限修饰符] [返回类型] [类全路径] 方法名称 ) ***

AOP操作（Aspectj 注解）

1：创建一个类，在类中定义方法

public class AOPdemo1 {
    public void ze(){
        System.out.println("正常的输出");
    }
}

2：创建增强类

class aopproxy{

}

3：对通知进行配置

***①：通过配置文件开启注解扫描***

<?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">
    <context:component-scan base-package="new_study.AOP"></context:component-scan>

</beans>

***②：通过注解对1和2所创建的类进行对象创建***

@Component(value = "A")
public class AOPdemo1 {
}
@Component
class aopproxy{	
}

③：在增强类进行Aspectj注解添加

@Component
@Aspect
class aopproxy{
}

④：配置不同类型的通知


@Component
@Aspect
class aopproxy{
    @Before(value = "execution(* new_study.AOP.AOPdemo1.ze(..))")//方法开始之前的通知
    public void play(){
        System.out.println("前置输出");
    }

    @After(value = "execution(* new_study.AOP.AOPdemo1.ze(..))")         //在方法之后进行输出
    public void after(){
        System.out.println("后置通知");
    }


    @AfterThrowing(value = "execution(* new_study.AOP.AOPdemo1.ze(..))")  //异常通知，程序出现问题时进行通知
    public void throwing(){
        System.out.println("异常通知");
    }
    @Around(value = "execution(* new_study.AOP.AOPdemo1.ze(..))")        //环绕通知，在原执行的方法最前面和最后面输出
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
        System.out.println("环绕前置通知");
        proceedingJoinPoint.proceed();
        System.out.println("环绕后置通知");
    }
    @AfterReturning(value = "execution(* new_study.AOP.AOPdemo1.ze(..))")  //方法执行之后，在返回值之后进行通知
    public  void afterplay(){
        System.out.println("后置在return后输出");
    }
}

测试类

public class play {
    @Test
    public void show(){
        ApplicationContext context = new ClassPathXmlApplicationContext("new_study/AOP/xml_file/bean1.xml");
        AOPdemo1 aoPdemo1= context.getBean("A",AOPdemo1.class);
        aoPdemo1.ze();
    }
}

输出结果：
Spring5框架——AOP操作：通过Aspectj注解方式和配置文件方式来实现,Spring,小白学基础,java,spring,junit
看着输出结果，发现下面代码没有输出，那是因为上面的代码是正常程序所以并没有输出异常通知

修改源代码：实现输出“异常通知”

public class AOPdemo1 {
    //故意编写一个错误的程序，为了让后面的异常通知的执行
    public void ze(){
	int i = 10/0;
    System.out.println("正常的输出");
    }
}

输出结果：
Spring5框架——AOP操作：通过Aspectj注解方式和配置文件方式来实现,Spring,小白学基础,java,spring,junit
重新定义一个错误的代码才能执行异常通知，异常通知只能在程序出现问题的情况下才能实现。

如果当增强的方法需要更改时，那么设置的每个路径值都需要更改，接下来讲解一种新的注解来解决这种问题，可以方便这种问题解决

在类中创建一个新的方法

    @Pointcut(value = "execution(* new_study.AOP.AOPdemo1.ze(..))")
    public void pointdmeo(){}
    @Before(value ="pointdmeo()"）//只需要更改这些内容，其他的不需要改变会出现同样的结果

当需要对一种方法进行多种增强时，我们需要设置各种方法的优先级来进行输出需要对增强类上面标记注解@Order(数值类型)
注意：数值越小，优先级越高

@Component
@Aspect
@Order(1)
class aopproxy{
  @After(value = "execution(* new_study.AOP.AOPdemo1.ze(..))")
    public void after(){
        System.out.println("后置通知");
    }
    }
@Component
@Aspect
@Order(2)
class demo2{
    @After(value = "execution(* new_study.AOP.AOPdemo1.ze(..))")
    public void after(){
        System.out.println("demo2的后置通知");
    }
}

***注意：其他的配置文件如同上面一样不需要发生更改，修改上面添加新的标记即可
输出结果：
Spring5框架——AOP操作：通过Aspectj注解方式和配置文件方式来实现,Spring,小白学基础,java,spring,junit

接下来将介绍通过配置文件来实现AOP操作

1.创建两个类：一个被增强的类和一个增强类

public class Aop_xml {
    public void add(){
        System.out.println("这是需要增强的的方法");
    }
}

class proxy{
    public void addproxy(){
        System.out.println("这是add的增强的方法");
    }
}
 class test{

}

配置文件：配置实现增强类和被增强类

<?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="c1" class="new_study.AOP.xml_file.Aop_xml"></bean>
    <bean id="c2" class="new_study.AOP.xml_file.proxy"></bean>

    <!--开始配置AOP操作，来实现增强-->
    <aop:config>
        <!--切入点，被增强的类中的方法-->
        <aop:pointcut id="b" expression="execution(* new_study.AOP.xml_file.Aop_xml.add(..))"/>
        <!--配置增强类，以及增强类中的方法和实现增强的类型-->
        <aop:aspect ref="c2">
            <aop:before method="addproxy" pointcut-ref="b"></aop:before>
        </aop:aspect>
    </aop:config>


</beans>

测试类输出：

    @Test
    public void show2(){
        ApplicationContext context = new ClassPathXmlApplicationContext("new_study/AOP/xml_file/bean2.xml");
        Aop_xml aop_xml = context.getBean("c1",Aop_xml.class);
        aop_xml.add();
    }
}