spring aop

最新推荐文章于 2024-08-26 17:09:54 发布
最新推荐文章于 2024-08-26 17:09:54 发布
阅读量125 收藏
点赞数
分类专栏： Java spring 文章标签： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41433833/article/details/109891376
版权

文章目录

spring基础之-1-spring aop

一、相关概念

面向切面编程 aop (aspect oriented program)

将程序中不同业务的各个小而类似的功能抽取出来，在运行时动态织入增强的逻辑；

一般用于日志等的横向开发。

二、实现方式

1、jdk动态代理： 基于 目标类的接口来生成动态代理对象

  • 接口

    package org.jnr.proxy.jdk;

/**
 * @program: Spring复习
 * @description:
 * @author: jin rong@JNR
 * @create: 2020-11-20 10:02
 **/
public interface TargetInterface {
    void insert();

    void delete();

    void update();

    void queryOne();

    void queryListAll();
}

  • 目标对象

    package org.jnr.proxy.jdk;

/**
 * @program: Spring复习
 * @description:
 * @author: jin rong@JNR
 * @create: 2020-11-20 10:03
 **/
public class Target implements TargetInterface {
    @Override
    public void insert() {
        System.out.println("insert running ...");
    }

    @Override
    public void delete() {
        System.out.println("delete running ...");
    }

    @Override
    public void update() {
        System.out.println("update running ...");
    }

    @Override
    public void queryOne() {
        System.out.println("queryOne running ...");
    }

    @Override
    public void queryListAll() {
        System.out.println("queryListAll running ...");
    }
}

  • 切面通知类

    package org.jnr.proxy.jdk;

/**
 * @program: Spring复习
 * @description: 通知类
 * @author: jin rong@JNR
 * @create: 2020-11-20 10:05
 **/
public class Advice {
    public void before() {
        System.out.println("前置通知");
    }

    public void afterRetuning() {
        System.out.println("后置通知");
    }
}

  • 实现/测试

    package org.jnr.proxy.jdk;

/**
 * @program: Spring复习
 * @description:
 * @author: jin rong@JNR
 * @create: 2020-11-20 10:04
 **/

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * 基于 jdk 接口 目标对象 代理对象 的动态代理
 */
public class ProxyTest {
    public static void main(String[] args) {
        //目标对象
        final Target target = new Target();
        //通知对象
        final Advice advice = new Advice();
        //代理对象
        Object o = Proxy.newProxyInstance(
                target.getClass().getClassLoader(),   //目标对象类加载器
                target.getClass().getInterfaces(),//目标对象所有接口 数组
                new InvocationHandler() {//代理对象执行的方法，其中执行目标对象方法和增强逻辑
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        advice.before();//前置通知
                        Object invoke = method.invoke(target, args);//目标方法
                        advice.afterRetuning();//后置通知
                        return invoke;
                    }
                }
        );
        //由于 代理对象 和 目标对象 都是实现了 接口，因此是兄弟类，只能强转为接口（父）
        TargetInterface targetInterface = (TargetInterface) o;
        //执行 目标方法，自动增强逻辑
        targetInterface.insert();
        targetInterface.delete();
        targetInterface.update();
        targetInterface.queryOne();
        targetInterface.queryListAll();
    }
}

  • 结果

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hfkIoM8T-1605925719261)(C:\Users\ASUS\AppData\Roaming\Typora\typora-user-images\image-20201121101645403.png)]

2、 cglib动态代理 ：通过生成一个继承自目标类的代理类来实现

  • 目标对象

    package org.jnr.proxy.cglib;

import org.jnr.proxy.jdk.TargetInterface;

/**
 * @program: Spring复习
 * @description:
 * @author: jin rong@JNR
 * @create: 2020-11-20 10:03
 **/
public class Target {
    public void insert() {
        System.out.println("insert running ...");
    }

    public void delete() {
        System.out.println("delete running ...");
    }

    public void update() {
        System.out.println("update running ...");
    }

    public void queryOne() {
        System.out.println("queryOne running ...");
    }

    public void queryListAll() {
        System.out.println("queryListAll running ...");
    }
}

  • 切面类

    package org.jnr.proxy.cglib;

/**
 * @program: Spring复习
 * @description: 通知类
 * @author: jin rong@JNR
 * @create: 2020-11-20 10:05
 **/
public class Advice {
    public void before() {
        System.out.println("前置通知");
    }

    public void afterRetuning() {
        System.out.println("后置通知");
    }
}

  • 实现/测试

    package org.jnr.proxy.cglib;

/**
 * @program: Spring复习
 * @description:
 * @author: jin rong@JNR
 * @create: 2020-11-20 10:04
 **/

import org.jnr.proxy.jdk.TargetInterface;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * 基于 cglib 继承自 目标对象的 代理对象 的动态代理
 */
public class ProxyTest {
    public static void main(String[] args) {
        //目标对象
        final Target target = new Target();
        //通知对象
        final Advice advice = new Advice();


        //创建增强器
        Enhancer enhancer = new Enhancer();

        //设置父类
        enhancer.setSuperclass(target.getClass());

        //设置回调方法
        enhancer.setCallback(new MethodInterceptor() {
            @Override
            public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
                advice.before();//前置通知
                Object invoke = method.invoke(target, args);//目标方法
                advice.afterRetuning();//后置通知
                return invoke;
            }
        });
        //生成代理对象
        Target proxy = (Target) enhancer.create();
        //执行 目标方法，自动增强逻辑
        proxy.insert();
        proxy.delete();
        proxy.update();
        proxy.queryOne();
        proxy.queryListAll();
    }
}

  • 结果

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Ypt8VaV3-1605925719275)(C:\Users\ASUS\AppData\Roaming\Typora\typora-user-images\image-20201121101611197.png)]

三、使用 spring aop

spring aop 需要导入 spring-aop 和 spring-aspect (或 spring-aspectjweave,是第三方的，但是spring也集成了，这个包在 spring-aspects依赖中有，因为 aspectj 做的比 spring 提供的好，所以一般都是用他的)

1、 基于 xml 配置方式

  • 编写目标对象接口

    package org.jnr.aop.xml;

/**
 * @program: Spring复习
 * @description: 目标对象接口
 * @author: jin rong@JNR
 * @create: 2020-11-20 23:07
 **/
public interface TargetInterface {
    void insert();

    void delete();

    void update();

    void select();
}

  • 编写目标对象

    package org.jnr.aop.xml.impl;

import org.jnr.aop.xml.TargetInterface;

/**
 * @program: Spring复习
 * @description: 目标对象
 * @author: jin rong@JNR
 * @create: 2020-11-20 23:07
 **/
public class Target implements TargetInterface {
    @Override
    public void insert() {
        System.out.println("Target insert ...");
    }

    @Override
    public void delete() {
        System.out.println("Target delete...");
    }

    @Override
    public void update() {
        System.out.println("Target update...");
    }

    @Override
    public void select() {
        System.out.println("Target select ...");
    }
}

  • 编写切面类（用于增强/通知的类）

    package org.jnr.aop.xml;

/**
 * @program: Spring复习
 * @description: 通过xml配置aop
 * @author: jin rong@JNR
 * @create: 2020-11-20 23:05
 **/
public class MyAspectByXml {
    public void before() {
        System.out.println("前置通知");
    }

    public void afterReturning() {
        System.out.println("后置通知");
    }
}

  • 在springioc容器中加载上面目标对象、切面类

    <bean id="target" class="org.jnr.aop.xml.impl.Target"></bean>
<bean id="myAspectByXml" class="org.jnr.aop.xml.MyAspectByXml"></bean>

  • 在springioC容器中配置织入过程（需要导入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="org.jnr.aop.xml.impl.Target"></bean>
    <bean id="myAspectByXml" class="org.jnr.aop.xml.MyAspectByXml"></bean>

    <aop:config>
        <!--    配置切面    -->
        <aop:aspect ref="myAspectByXml">
            <!-- 配置切面 （切入点+增强方法） -->
            <aop:before method="before" pointcut="execution(public void org.jnr.aop.xml.impl.Target.*())"></aop:before>
        </aop:aspect>
    </aop:config>
</beans>

  • 使用junit+spring-text 测试

    package org.jnr;

import org.jnr.aop.xml.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;

/**
 * @program: Spring复习
 * @description: 通过 xml 方式配置使用 spring aop
 * @author: jin rong@JNR
 * @create: 2020-11-20 23:13
 **/
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:Application-aop.xml")
public class AopByXmlTest {
    @Autowired
    private TargetInterface target;

    @Test
    public void test01() {
        target.insert();
        target.delete();
        target.update();
        target.select();
    }
}

2、基于注解的配置方式

  • 编写目标对象接口

    package org.jnr.aop.annotation;

/**
 * @program: Spring复习
 * @description: 目标对象接口
 * @author: jin rong@JNR
 * @create: 2020-11-20 23:07
 **/
public interface TargetInterface {
    void insert();

    void delete();

    void update();

    void select();
}

  • 编写目标对象

    package org.jnr.aop.annotation.impl;

import org.jnr.aop.annotation.TargetInterface;
import org.springframework.stereotype.Component;

/**
 * @program: Spring复习
 * @description: 目标对象
 * @author: jin rong@JNR
 * @create: 2020-11-20 23:07
 **/
@Component
public class Target implements TargetInterface {
    @Override
    public void insert() {
        System.out.println("Target insert ...");
    }

    @Override
    public void delete() {
        System.out.println("Target delete...");
    }

    @Override
    public void update() {
        System.out.println("Target update...");
    }

    @Override
    public void select() {
        System.out.println("Target select ...");
        System.out.println("即将抛出异常");
        int i = 1 / 0;
    }
}

  • 编写切面类（用于增强/通知的类）

    package org.jnr.aop.annotation;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

/**
 * @program: Spring复习
 * @description: 通过xml配置aop
 * @author: jin rong@JNR
 * @create: 2020-11-20 23:05
 **/
@Aspect
@Component
public class MyAspectByAnnotation {
    @Before(value = "execution(public void org.jnr.aop.annotation.impl.Target.*())")
    public void before(JoinPoint joinPoint) {
        System.out.println(joinPoint);
        System.out.println("前置通知");
    }

    @Around(value = "execution(public void org.jnr.aop.annotation.impl.Target.*())")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        Object proceed = pjp.proceed();//执行 目标方法，下面是增强逻辑
        //Proceeding JoinPoint :正在进行中的 连接点，也就是 切点 ;ProceedingJoinPoint 只能用于 环绕通知
        System.out.println("环绕通知");
        return proceed;
    }

    //将切点表达式 execution 抽取出来
    @Pointcut(value = "execution(public void org.jnr.aop.annotation.impl.Target.*())")//value="","" 都行
    public void pointCut() {
    }

    //可以直接用方法名使用切点表达式方法
    @After(value = "pointCut()")//value="","" 都行
    public void after() {
        System.out.println("最终通知");
    }

    //也可以用类.切点表达式方法()
    @AfterReturning(pointcut = "MyAspectByAnnotation.pointCut()")//pointcut="" , value="","" 都行
    private void afterReturning() {
        System.out.println("后置通知");
    }

    @AfterThrowing(value = "execution(* org.jnr.aop.annotation.impl*.*(..))")
    public void afterThrowing() {
        System.out.println("异常通知");
    }
}

  • 使用注解在springioc容器中加载上面目标对象、切面类（@Component注解 @Aspect注解、各种通知注解@Before @After @AfterRetuning @Around @AfterThrowing ）

    参见上面代码

  • 编写配置类 扫描包注入容器和 开启aop自动代理注解（@Configuration @ComponentScan @EnableAspectjAutoProxy或者在xml配置文件中 使用aop:aspectj-autoproxy/）

    package org.jnr.aop.annotation;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

/**
 * @program: Spring复习
 * @description:
 * @author: jin rong@JNR
 * @create: 2020-11-21 08:54
 **/
@Configuration
@EnableAspectJAutoProxy
@ComponentScan(basePackages = "org.jnr.aop.annotation")
public class AopConfiguration {
}

  • 使用junit+spring-text 测试

    package org.jnr;

import org.jnr.aop.annotation.AopConfiguration;
import org.jnr.aop.annotation.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;

/**
 * @program: Spring复习
 * @description: 通过 注解 方式配置使用 spring aop
 * @author: jin rong@JNR
 * @create: 2020-11-20 23:13
 **/
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = AopConfiguration.class)
public class AopByAnnotationTest {
    @Autowired
    private TargetInterface target;

    @Test
    public void test01() {
        target.insert();
        target.delete();
        target.update();
        target.select();
    }
}

3、总结

  • ProceedingJoinPoint 参数只能用于环绕通知
  • aspectj 版本如果太低，比如 1.5.* ，在使用 JoinPoint 作为方法参数时会报 错，建议更新版本为 1.8.1，或者干脆不要单独导入 aspectj依赖，直接导入 spring-aspects 包，里面就有较新的 aspectj 包
  • 如果使用注解开发 aop ，记得要在 xml 中开启自动代理 注解 aop:apsect-autoproxy/ 或者在配置类中加上 @EnableAspectjAutoProxy 注解
  • spring 框架根据 目标类是否是实现类（有接口）来决定采用哪种 动态代理对象。

4、execution 表达式 大全（记得空格问题）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uv149H7p-1605925719284)(C:\Users\ASUS\AppData\Roaming\Typora\typora-user-images\image-20201121100437179.png)]

Kai Havterz
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring AOP教程
12-07
Spring框架的关键组件之一是面向方面编程(AOP)框架。 面向方面的编程需要将程序逻辑分解成不同的部分。 此教程将通过简单实用的方法来学习Spring框架提供的AOP/面向方面编程。
Spring aop失效的几种解决方案
08-19
Spring AOP失效解决方案详解 作为一名IT行业大师，我将从给定的文件中生成相关知识点，主要介绍Spring AOP失效的几种解决方案。 标题解释 Spring AOP失效的几种解决方案是指在使用Spring框架时，Aspect Oriented ...
spring aop jar 包
07-26
Spring AOP(Aspect Oriented Programming，面向切面编程)是Spring框架的重要组成部分，它提供了一种在不修改源代码的情况下，对程序进行功能增强的技术。这个"spring aop jar 包"包含了实现这一功能所需的类和接口，...
Spring AOP 16道面试题及答案.docx
06-29
Spring AOP，全称为Aspect Oriented Programming，是面向切面编程的一种编程范式，它是对传统的面向对象编程（OOP）的一种补充。在OOP中，核心是对象，而在AOP中，核心则是切面。切面是关注点的模块化，即程序中的...
dynamic-datasource-spring-boot-starter多数据源配置
wyazyf
08-22 186
这种多数据源的配置方式可以不用区分包和扫描路径。放在同一路径下即可。默认在主数据库中加载。调用其他数据源的时候，只需要在mapper.java文件上配置@DS(“mainData”)即可。
清除系统缓存提高写盘速度的tips
最新发布
qq_34999565的博客
08-26 173
当内存中存储了大量数据缓存时，系统的可用内存会减少。在内存资源紧张的情况下，执行 echo 3 > /proc/sys/vm/drop_caches 可以清理内存中的页缓存、目录项缓存（dentries）和 inode 缓存，从而释放出更多的内存空间供程序使用。如果系统即将进行新的数据缓存或处理操作，尤其是涉及大量数据的处理任务时，清理缓存可以释放内存，为后续操作提供更多的可用内存。这个命令部分的作用是通过向 /proc/sys/vm/drop_caches 文件写入一个值，来指示内核清理特定的内存缓存。
Spring OAuth2.0资源服务源码解析
onePlus5T的博客
08-22 597
主要分析spring-security-oauth2-resource-server的源码，介绍OAuth2.0授权码模式下Spring Boot OAuth2资源服务的运行流程，分析其是如何对令牌进行认证的，并展示资源服务配置
Spring Cache
m0_55956769的博客
08-26 294
Spring Cache
SpringBoot集成EasyExcel实现Excel文件导入/出
Lyhdreamer的博客
08-26 113
二，创建实体类 @ExcelProperty的属性 说明 value 按列名去匹配Excel数据，如果名字重复，会导致只有一个实体类字段读取到数据 index 按列的下标去匹配Excel数据
SpringBoot 注解指南
weixin_51582215的博客
08-23 681
基于 SpringBoot 平台开发的项目数不胜数，与常规的基于Spring开发的项目最大的不同之处，SpringBoot 里面提供了大量的注解用于快速开发，而且非常简单，基本可以做到开箱即用！那 SpringBoot 为开发者提供了多少注解呢？我们该如何使用？通常用于修饰controller层的组件，由控制器负责将用户发来的URL请求转发到对应的服务接口，通常还需要配合注解使用。提供路由信息，负责URL到Controller中具体函数的映射，当用于方法上时，可以指定请求协议，比如GETPOSTPUT。
springboot社区医疗服务系统--论文源码调试讲解
u014445459的博客
08-23 1054
刚开始学习Java语言的时候，是不知道还有Tomcat这些东西的，各种语法各种输出在控制台进行输出结果，当Java网站开发的时候就不可避免的学习到了Tomcat服务器。Tomcat准确的来讲不算是服务器，可以说是vue引擎或者一个容器，这些都是学术上或者原理上都比较贴切的，但是实际工作中Tomcat就是作为一个web服务器来用的，因为可以实现网站的发布和运行。420
Spring（2）
supercool7的博客
08-26 682
主要是切面定义。
springCloud 网关（gateway）配置跨域访问
qq_43757153的博客
08-22 285
如果项目是分布式架构，通过网关进行路由转发的，那么项目中如果存在跨域的访问，在每一个项目中单独配置，显示是错误的，我们只需要在网关处进行处理，其它项目都是由网关进行转发的，他们是不会存在跨域访问的（具体为啥，可以查询跨域产生的原因）然后这个是一个挺简单的东西，没啥好说的，写出来的目的是方便以后遇到，可以及时想起这里有一个解决方案，如有更好方法，欢迎留言。将这个文件复制到网关中即可，当然，也可以在网关的配置文件中进行编写，
Spring中的AopUtils
小湘西的博客
08-25 239
AopUtils是 Spring Framework 中一个工具类，位于包中。它提供了一系列静态方法，用于处理与面向切面编程（AOP）相关的操作。这些方法主要用于帮助开发人员进行 AOP 相关的操作，提供了一些便捷的工具，使得 AOP 的使用变得更加简单。
springboot中interceptor拦截器匹配URL源码
SmileAssassn的博客
08-23 262
看到在这里出现了拦截器，那么就在这个类里面往上找，打断点慢慢找，看看是在哪一步出现了拦截器。最后找到这里进行了拦截器的匹配模式。上一篇文章我们找到了filter过滤器的匹配源码，这次我们来找一下interceptor的匹配源码。直接源码里面备注里面就有写，那么两个都打上断点，调试一下即可。也可以用我之前写的文章，通过反编译jar包搜关键字的方式。接着翻调用链，看看从哪里开始出现拦截器的。同样先打断点看一下调用链。
springboot集成海康sdk，针对视频流获取某一点的实时温度
weixin_43952697的博客
08-22 580
/ System.out.println("NET_DVR_PLAY_REVERSE失败，错误码为" + hCNetSDK.NET_DVR_GetLastError());System.out.println("温度是·············"+((float)Math.round(temperature * 10)) / 10);System.out.println("查找失败，错误码为" + hCNetSDK.NET_DVR_GetLastError());
Springboot-基于Axis2的WebService，发送短信并加密短信内容，使用BouncyCastle作为加密库
兴趣是最好的老师
08-24 54
服务类: 在 sendEncryptedSMS 方法中，我们捕获了可能发生的各种异常，并返回一个错误消息给。如果短信内容在基于 Axis2 的 WebService 中被加密发送，那么解密通常发生在接收短信的一方。通过上述修改，你的 WebService 和客户端将具备更好的错误处理能力，从而提高系统的稳定性和。通过上述修改，你的 WebService 和客户端将具备更精细的错误处理能力，并能记录详细的异常信。客户端: 在客户端调用方法中，我们也增加了异常捕获逻辑，当调用 Web 服务时发生错误，会输。
Spring IoC&DI
2301_79288225的博客
08-26 140
我们发现了⼀个规律，通⽤程序的实现代码，类的创建顺序是反的，传统代码是 Car 控制并创建了Framework，Framework 创建并创建了 Bottom，依次往下，⽽改进之后的控制权发⽣的反转，不再是使⽤⽅对象创建并控制依赖对象了，⽽是把依赖对象注⼊将当前对象中，依赖对象的控制权不再由当前类控制了.在上⾯的程序中, 我们是根据轮⼦的尺⼨设计的底盘，轮⼦的尺⼨⼀改，底盘的设计就得修改. 同样因为我们是根据底盘设计的⻋⾝，那么⻋⾝也得改，同理汽⻋设计也得改, 也就是整个设计⼏乎都得改。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值