16. 用XML 配置的方式进行 AOP 切面编程

大概分为下面几部：

① 导入 AOP 相关坐标

② 创建目标接口和目标类（内部有切点）

③ 创建切面类（内部有增强方法）

④ 将目标类和切面类的对象创建权交给 spring

⑤ 在 applicationContext.xml 中配置织入关系

⑥ 测试代码

实现：

先导入 Spring的gav 和织入（切面类织入）的gav：

<!--导入spring的context坐标，context依赖aop-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.0.5.RELEASE</version>
</dependency>
<!-- aspectj的织入 -->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.8.13</version>
</dependency>

说一下这个 aspectjweaver ，这玩意是第三方的,比Spring的配置应用性能比 AOP 还要好，官方也是主张推荐使用他，因为Spring不会放弃好的框架的啊哈哈哈！

创建目标接口和目标类（内部有切点）：

package com.bihu.aop;

public interface TargetInterface {
    public void method();
}

package com.bihu.aop;

public class Target implements TargetInterface {
    @Override
    public void method() {
        System.out.println("method Running·····");
    }
}

然后我们需要创建切面类（内部有增强方法）

package com.bihu.aop;

public class MyAspect {
    //前置增强方法
    public void before(){
        System.out.println("前置代码增强...");
    }
}

然后我们将这个权限配置给Spring 有到了配置啦：

            <bean id="target" class="com.bihu.aop.Target"></bean>
            <bean id="myAspect" class="com.bihu.aop.MyAspect"></bean>

一个是 :目标方法（内部有切点）的bean

一个是：切面（内部有增强方法）的Bean

这两个bean 作用：

目标方法的bean 是在测试的时候注入

切面方法的bean 是在配置切面类的时候引入

看代码要细心是什么？为什么？怎么做？三问.

然后又得配置：

在 applicationContext.xml 中配置织入关系

注意的是配置的标签是 aop，记得要导入头即可：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">

            <bean id="target" class="com.bihu.aop.Target"></bean>
            <bean id="myAspect" class="com.bihu.aop.MyAspect"></bean>


            <aop:config>
                <!--引用myAspect的Bean为切面对象-->
                <aop:aspect ref="myAspect">
                    <!--配置Target的method方法执行时要进行myAspect的before方法前置增强-->
                    <aop:before method="before" pointcut="execution(public void com.bihu.aop.Target.method())"/>
                </aop:aspect>
            </aop:config>

</beans>

最后我们测试一下：

AopTest.java :

import com.bihu.aop.TargetInterface;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:springContext.xml")
public class AopTest {
    @Autowired
    private TargetInterface target;
    @Test
    public void test1(){
        target.method();
    }
}

注意了！！！用这种测试的话，要满足：

1. Juint 测试要 4.12 及以上版本

2. 要Spring-tets 这个 GAV坐标即可。

运行：

当然有前置增强也有后置增强(这里演示的是最终通知具体看下面通知的类型)：

   <aop:config>
                <!--引用myAspect的Bean为切面对象-->
                <aop:aspect ref="myAspect">
                    <!--配置Target的method方法执行时要进行myAspect的before方法前置增强-->
                    <aop:before method="before" pointcut="execution(public void com.bihu.aop.Target.method())"/>
                    <aop:after method="after" pointcut="execution(public void com.bihu.aop.Target.method())"/>
                </aop:aspect>
            </aop:config>

运行：

以上代码讲解如下：

其实上面要讲的只有 XML 配置 AOP 这段：

XML 配置 AOP 详解：

1. 切点表达式的写法：

表达式语法：

execution([修饰符] 返回值类型 包名.类名.方法名(参数))

其中：

访问修饰符可以省略

返回值类型、包名、类名、方法名可以使用星号* 代表任意

包名与类名之间一个点 . 代表当前包下的类，两个点 .. 表示当前包及其子包下的类

参数列表可以使用两个点 .. 表示任意个数，任意类型的参数列表

其实那些条件都是匹配的，例如下面：

execution(public void com.xxx.aop.Target.method())
execution(void com.xxx.aop.Target.*(..))
execution(* com.xxx.aop.*.*(..))
execution(* com.xxx.aop..*.*(..))
execution(* *..*.*(..))

第一个全部都写出来了，那就精准定位到指定包下指定的类指定方法

第二个返回值是void 表示只有返回值类型是 void 的方法，方法是 * 表示全部方法，参数是.. 表示任意参数，换句话说：这个类下面的所有返回值为void 的方法都要增强

第三个返回值类型是* 表示返回值类型是什么都可以，包是* 说明类和方法是 * 说明 com.xxx.aop 下面的所有包和所有方法，参数名是.. 证明有无参数的方法都要被增强，其实这个就是 aop包下的所有类中的所有方法。

第四个返回值类型是* 表示返回值类型是什么都可以，包是* 说明类和方法是 * 说明 com.xxx.aop 下面的所有包和所有方法，参数名是.. 证明有无参数的方法都要被增强，其实这个就是 aop包以及 aop的子包下的的所有类中的所有方法。【这个包是两个点的！！！注意看！】

第五个，第五个不用说凡是方法我都增强

2.通知的类型：

<aop:通知类型 method=“切面类中方法名” pointcut=“切点表达式"></aop:通知类型>

所以上面演示的是前置通知和最终通知

我们重新写上代码演示一下：

以这些代码为前提：

目标方法.java

package com.bihu.aop;

public class Target implements TargetInterface {
    @Override
    public void method() {
        System.out.println("method Running·····");
    }
}

目标接口.java

package com.bihu.aop;

public interface TargetInterface {
    public void method();
}

测试类 AopTest.java ：

import com.bihu.aop.TargetInterface;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:springContext.xml")
public class AopTest {
    @Autowired
    private TargetInterface target;
    @Test
    public void test1(){
        target.method();
    }
}

切面（内部编写增强方法：）

package com.bihu.aop;

public class MyAspect {

}

1 .前置通知就不说了，就是最先开始的那个。

2 .后置通知就是执行切点方法之后执行的：

这里代码给出前后通知的代码：

切面.java：

package com.bihu.aop;

public class MyAspect {
    //前置通知
    public void before(){
        System.out.println("前置通知 - 增强");
    }

    //后置通知
    public void after_returning(){
        System.out.println("后置通知 - 增强");
    }    
}

配置.xml：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">

            <bean id="target" class="com.bihu.aop.Target"></bean>
            <bean id="myAspect" class="com.bihu.aop.MyAspect"></bean>


            <aop:config>
                <!--引用myAspect的Bean为切面对象-->
                <aop:aspect ref="myAspect">
                    <!--配置Target的method方法执行时要进行myAspect的before方法前置增强-->
                    <aop:before method="before" pointcut="execution(* com.bihu.aop.*.*(..))"/>
                    <aop:after method="after_returning" pointcut="execution(* com.bihu.aop.*.*(..))"/>
                </aop:aspect>
            </aop:config>

</beans>

可以看到配置了切面是 myAspect类然后切点是 aop包下所有的方法，你完全可以自定义的。

测试代码.java:

import com.bihu.aop.TargetInterface;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:springContext.xml")
public class AopTest {
    @Autowired
    private TargetInterface target;
    @Test
    public void test1(){
        target.method();
    }
}

可以看到这里用的是 Spring整合Junit测试，但是我是看不懂的当时没学，但是会用即可了啊

运行结果：

下面讲解怀绕，环绕通知比较特殊，他是结合前后，所以他要一个切点对象做参数：

//Tips 因为环绕和前、后通知做的事情差不多，所以这里注释掉前后通知。

切面.java:

package com.bihu.aop;

import org.aspectj.lang.ProceedingJoinPoint;

public class MyAspect {

    //环绕通知
    //需要一个切点对象(Proceeding:执行 JoinPoint：连接点)  正在执行的切点 = 切点
    public Object around(ProceedingJoinPoint pjp) throws Throwable {

        System.out.println("环绕前增强");
        Object proceed = pjp.proceed(); //执行切点方法（抛出异常）
        System.out.println("环绕后增强");
        return proceed;//然后返回对象即可

    }

}

配置.xml：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">




            <bean id="target" class="com.bihu.aop.Target"></bean>
            <bean id="myAspect" class="com.bihu.aop.MyAspect"></bean>


            <aop:config>
                <!--引用myAspect的Bean为切面对象-->
                <aop:aspect ref="myAspect">
                    <!--配置Target的method方法执行时要进行myAspect的before方法前置增强-->
<!--                    <aop:before method="before" pointcut="execution(* com.bihu.aop.*.*(..))"/>-->
<!--                    <aop:after method="after_returning" pointcut="execution(* com.bihu.aop.*.*(..))"/>-->
                        <aop:around method="around" pointcut="execution(* com.bihu.aop.*.*(..))"/>
                </aop:aspect>
            </aop:config>

</beans>

运行结果：

所以你看其实这个环绕就是集合了前通知和后通知一起。注意写增强方法的时候加上参数即可，还有返回那个对象。

异常抛出通知

这个我们在目标方法作死一下即可 1/0 这样吧。

package com.bihu.aop;

public class Target implements TargetInterface {
    @Override
    public void method() {
        System.out.println("method Running·····");
        System.out.println(1/0);
    }
}

然后在配置切面：

package com.bihu.aop;

public class MyAspect {

public void afterThrowing(){
    System.out.println("目标方法afterThrowing出现了异常！ 请检测代码！");
 }
 }

配置xml:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">




            <bean id="target" class="com.bihu.aop.Target"></bean>
            <bean id="myAspect" class="com.bihu.aop.MyAspect"></bean>


            <aop:config>
                <!--引用myAspect的Bean为切面对象-->
                <aop:aspect ref="myAspect">
                  <aop:after-throwing method="afterThrowing" pointcut="execution(* com.bihu.aop.*.*(..))"/>
                </aop:aspect>
            </aop:config>

</beans>

View Code

然后运行：

可以发现先运行了方法在出错的，所以呢代码也是一样的。

最终增强也一样：用于配置最终通知。无论增强方式执行是否有异常都会执行。反正我都执行。是在方法

下面除了异常其他都演示一遍：

你会发现执行顺序不一样：

切面：

package com.bihu.aop;


import org.aspectj.lang.ProceedingJoinPoint;

public class MyAspect {

    //前置通知
    public  void before() {

    }

    //后置通知
    public  void afterReturning() {

    }

    //环绕通知
    public  Object around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("环绕前增强");
        Object proceed = pjp.proceed();
        System.out.println("环绕后增强");
        return proceed;
    }

    //最终通知
    public  void after() {
        System.out.println("最终增强");
    }

}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">




            <bean id="target" class="com.bihu.aop.Target"></bean>
            <bean id="myAspect" class="com.bihu.aop.MyAspect"></bean>


            <aop:config>
                <!--引用myAspect的Bean为切面对象-->
                <aop:aspect ref="myAspect">
                  <aop:before method="before" pointcut="execution(* com.bihu.aop.*.*(..))"/>
                  <aop:after-returning method="afterReturning" pointcut="execution(* com.bihu.aop.*.*(..))"/>
                  <aop:around method="around" pointcut="execution(* com.bihu.aop.*.*(..))"/>
                  <aop:after method="after" pointcut="execution(* com.bihu.aop.*.*(..))"/>
                </aop:aspect>
            </aop:config>

</beans>

目标：

package com.bihu.aop;

public class Target implements TargetInterface {
    @Override
    public void method() {
        System.out.println("method Running·····");
    }
}

配置：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">

            <bean id="target" class="com.bihu.aop.Target"></bean>
            <bean id="myAspect" class="com.bihu.aop.MyAspect"></bean>

            <aop:config>
                <!--引用myAspect的Bean为切面对象-->
                <aop:aspect ref="myAspect">
                  <aop:before method="before" pointcut="execution(* com.bihu.aop.*.*(..))"/>
                  <aop:after-returning method="afterReturning" pointcut="execution(* com.bihu.aop.*.*(..))"/>
                  <aop:around method="around" pointcut="execution(* com.bihu.aop.*.*(..))"/>
                  <aop:after method="after" pointcut="execution(* com.bihu.aop.*.*(..))"/>
                </aop:aspect>
            </aop:config>

</beans>

注意看运行：

可以看到：

如果我们用了环绕，他会替代掉前通知和后通知，因为：

注意看图所以都替代掉了

那为为什么最终通知不是最后呢？

因为我也不，我这样写他就这样来....懂即可

但是：前后通知 + 最终就是这样的运行结果：

意义不大懂即可

更多你可以自己去尝试但是环绕一般不和前后一起用

posted @ 2021-07-21 14:13 咸瑜阅读(191) 评论(0) 编辑收藏举报

刷新页面返回顶部

咸瑜

无限风光在险峰

16. 用XML 配置的方式进行 AOP 切面编程

公告

咸瑜

无限风光在险峰

16. 用XML 配置的方式 进行 AOP 切面编程

公告

16. 用XML 配置的方式进行 AOP 切面编程