Aop相关操作

最新推荐文章于 2024-05-04 03:09:21 发布
原创 最新推荐文章于 2024-05-04 03:09:21 发布 · 150 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java

Spring 是解决实际开发中的一些问题，而 AOP 解决 OOP 中遇到的一些问题.是 OOP 的延续和扩展.  

使用面向对象编程 （ OOP ）有一些弊端，当需要为多个不具有继承关系的对象引人同一个公共行为时，例如日志、安全检测等，我们只有在每个对象里引用公共行为，这样程序中就产生了大量的重复代码，程序就不便于维护了，所以就有了一个对面向对象编程的补充，即面向方面编程 （ AOP ), AOP 所关注的方向是横向的，区别于 OOP 的纵向。

2.1 为什么学习 AOP  

在不修改源码的情况下，对程序进行增强

AOP 可以进行权限校验,日志记录,性能监控,事务控制

2.2 Spring 的 AOP 的由来

AOP 最早由 AOP 联盟的组织提出的,制定了一套规范.Spring 将 AOP 思想引入到框架中,必须遵守 AOP 联盟 的规范.  

2.3 底层实现

AOP依赖于IOC来实现，在AOP中，使用一个代理类来包装目标类，在代理类中拦截目标类的方法执行并织入辅助功能。在Spring容器启动时，创建代理类bean替代目标类注册到IOC中，从而在应用代码中注入的目标类实例其实是目标类对应的代理类的实例，即使用AOP处理目标类生成的代理类。

代理机制:  

Spring 的 AOP 的底层用到两种代理机制：  

JDK 的动态代理 :针对实现了接口的类产生代理.  

Cglib 的动态代理 :针对没有实现接口的类产生代理. 应用的是底层的字节码增强的技术 生成当前类的子类对象.

2.4 动态代理

Java中提供的动态代理,增强一个类的方法

package com.tledu.service.impl;

import lombok.Getter;

import lombok.Setter;

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Method;

/**

 * @author cyrus

 */

public class LogInterceptor implements InvocationHandler {

    /**

     * 被代理的对象

     */

    @Getter

    @Setter

    private Object target;

    private void before(Method method) {

        System.out.println(method.getName()+"调用之前");

    }

    private void after(Method method) {

        System.out.println(method.getName()+"调用之后");

    }

    /**

     * @param proxy  代理的对象

     * @param method 代理的方法

     * @param args   方法的参数

     * @return 方法的返回值

     * @throws Throwable 异常

     */

    @Override

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        // 前置操作

        before(method);

        // 通过被代理对象调用真正需要执行的方法

        Object res = method.invoke(target, args);

        // 后置操作

        after(method);

        return res;

    }

}

测试

    @Test

    public void proxy() {

        // 创建真实的对象

        IUserDao userDao = new UserDaoImpl();

        // 创建代理

        LogInterceptor logInterceptor = new LogInterceptor();

        // 设置需要代理的对象

        logInterceptor.setTarget(userDao);

        // 创建代理之后的对象

        /*

          第一个参数： 真实对象的类解析器

          第二个参数： 实现的接口数组

          第三个参数： 调用代理方法的时候，会将方法分配给该参数

         */

        IUserDao userDaoProxy = (IUserDao) Proxy.newProxyInstance(userDao.getClass().getClassLoader(),

                new Class[]{IUserDao.class}, logInterceptor);

        userDaoProxy.insert(null);

    }

newProxyInstance，方法有三个参数：

loader: 用哪个类加载器去加载代理对象

interfaces:动态代理类需要实现的接口

h:动态代理方法在执行时，会调用h里面的invoke方法去执行

2.5 AOP相关术语

  • Joinpoint(连接点):所谓连接点是指那些被拦截到的点。在 spring 中,这些点指的是方法,因为 spring 只支持方法类型的连接点.  

  • Advice(通知/增强):所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知.通知分为前置通知,后置 通知,异常通知,最终通知,环绕通知(切面要完成的功能)  

  • Pointcut(切入点):所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义

  • Introduction(引介):引介是一种特殊的通知在不修改类代码的前提下, Introduction 可以在运行期为类 动态地添加一些方法或 Field.  

  • Target(目标对象): 代理的目标对象  

  • Weaving(织入):是指把增强应用到目标对象来创建新的代理对象的过程,spring 采用动态代理织入，而 AspectJ 采用编译期织入和类装在期织入  

  • Proxy（代理）:一个类被 AOP 织入增强后，就产生一个结果代理类  

  • Aspect(切面): 是切入点和通知（引介）的结合

2.6 注解方式

2.6.1 引入jar包

还是之前IOC的 再次引入三个就行,因为Spring的AOP是基于AspectJ开发的 

               <dependency>

            <groupId>org.springframework</groupId>

            <artifactId>spring-aop</artifactId>

            <version>${spring.version}</version>

        </dependency>

        <!-- 增加了切面 -->

        <dependency>

            <groupId>org.aspectj</groupId>

            <artifactId>aspectjweaver</artifactId>

            <version>1.9.5</version>

        </dependency>

2.6.2 配置文件

  1. 引入AOP约束，通过配置文件

<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-2.5.xsd">

    <!--开启AOP注解-->

    <aop:aspectj-autoproxy />

</beans>

  1. 通过注解的方式开启切面支持 @EnableAspectJAutoProxy

2.6.3 AOP类

import org.aspectj.lang.ProceedingJoinPoint;

import org.aspectj.lang.annotation.After;

import org.aspectj.lang.annotation.Around;

import org.aspectj.lang.annotation.Aspect;

import org.aspectj.lang.annotation.Before;

import org.aspectj.lang.annotation.Pointcut;

import org.springframework.stereotype.Component;

@Component

@Aspect

public class LogInterceptor {

    @Pointcut("execution(public * com.tledu.zrz.spring.service..*.add(..))")

    public void myMethod() {

  // 假设这个方法就是被代理的方法

    }

    @Before("myMethod()")

    public void beforeMethod() {

  System.out.println(" execute start");

    }

    @After("myMethod()")

    public void afterMethod() {

  System.out.println(" execute end");

    }

    // 环绕,之前和之后都有,相当于 @Before 和 @After 一起使用

    @Around("myMethod()")

    public void aroundMethod(ProceedingJoinPoint pjp) throws Throwable {

  // @Around也可以和@Before 和 @After 一起使用

  System.out.println("around start");

  // 调用被代理的方法

  pjp.proceed();

  System.out.println("around end");

    }

}

规则：

在配置方法的时候，方法可以添加参数JoinPoint joinPoint，通过这个参数可以拿到当前调用的信息，方便我们进行后续的处理。（）

 @After("myMethod()")

    public void after(JoinPoint joinPoint) {

        System.out.println("目标方法名为:" + joinPoint.getSignature().getName());

        System.out.println("目标方法参数:" + joinPoint.getArgs());

        System.out.println("目标方法所属类的简单类名:" +        joinPoint.getSignature().getDeclaringType().getSimpleName());

        System.out.println("目标方法所属类的类名:" + joinPoint.getSignature().getDeclaringTypeName());

    }

@Pointcut 规则 https://www.cnblogs.com/itsoku123/p/10744244.html

2.6.4 测试类

@Test

public void testAdd() {

 ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext(

   "beans.xml");

 UserService userService = (UserService) applicationContext

   .getBean("userService");

 userService.add(null);

}

演示示例：Spring_14_AOP_Annotation

2.7 XML方式

2.7.1 引入jar包

和注解方式引入的一样

2.7.2 配置文件

引入AOP约束

<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

       

       

       

       

配置AOP

<!-- 实例化 -->

<bean id="logInterceptroe" class="com.tledu.zrz.spring.aop.LogInterceptor"></bean>

<!-- 设置AOP -->

<aop:config>

 <aop:aspect id="logAspect" ref="logInterceptroe">

  <!-- 需要进行代理的方法 -->

  <aop:pointcut expression="execution(public * com.tledu.zrz.spring.service..*.add(..))"

   id="pointcut" />

  <!-- 前后执行 -->

  <aop:before method="before" pointcut-ref="pointcut" />

  <!-- 或者这样写,这样就不需要pointcut标签了 -->

  <!-- <aop:before method="before" pointcut="execution(public * com.tledu.zrz.spring.service..*.add(..))"  

   /> -->

  <aop:after method="after" pointcut-ref="pointcut" />

  <!-- 环绕,一般要么使用 around 要和使用 before和after 不会一起使用 -->

  <aop:around method="aroundMethod" pointcut-ref="pointcut" />

 </aop:aspect>

</aop:config>

2.6.3 AOP类

和注解一样,就是把注解去掉了

import org.aspectj.lang.ProceedingJoinPoint;

public class LogInterceptor {

public void myMethod() {

 // 假设这个方法就是被代理的方法

}

public void before() {

 System.out.println(" execute start");

}

public void after() {

 System.out.println(" execute end");

}

// 环绕,之前和之后都有,相当于 @Before 和 @After 一起使用

public void aroundMethod(ProceedingJoinPoint pjp) throws Throwable {

 // @Around也可以和@Before 和 @After 一起使用

 System.out.println("around start");

 // 调用被代理的方法

 pjp.proceed();

 System.out.println("around end");

}

}

2.6.4 测试类

@Test

public void testAdd() {

 ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext(

   "beans.xml");

 UserService userService = (UserService) applicationContext

   .getBean("userService");

 userService.add(null);

}

Spring AOP + SpringMVC +Mybatis做动态数据源,实现读写分离
03-30
Spring AOP + SpringMVC +Mybatis做动态数据源,实现读写分离Spring AOP + SpringMVC +Mybatis做动态数据源,实现读写分离Spring AOP + SpringMVC +Mybatis做动态数据源,实现读写分离
mybatis 拦截器 + spring aop切面 + spring事务+ 反射工具类
02-10
内含有mybatis 拦截器实现的分页代码，spring 的事务和aop 测试、和反射工具类
Spring mvc mybatis plus 实现AOP 切面日志系统
12-19
Spring mvc mybatis plus 实现AOP 切面日志系统，带有数据库。可以自行拓展
Spring-AOP及集成mybatis和jdbcTemplate
simple的博客
08-10 377
文章目录1 AOP1.1 AOP的介绍1.2 AOP的作用1.3 AOP的底层实现1.4 动态代理1.5 AOP相关术语1.6 实现方法1.6.1 注解实现1.6.1.1 引入依赖1.6.1.2 加上注解1.6.1.3 编写AOP类1.6.2 xml实现1.6.2.1 引入依赖1.6.2.2 配置xml文件1.6.2.3 编写AOP类1.7 AOP实现记录操作日志1.7.1 自定义一个注解1.7.2 编写一个切面类2 Spring集成Mybatis2.1 引入依赖2.2 添加mybatis的xml配置文件2
10. Spring AOP + Mybatis
Straw_boy的博客
01-19 840
Spring AOP 通知 前置通知 在目标方法前切入追加功能。采用@Before，方法定义格式如下： @Before("切入点表达式") public void xxx(){...} 后置通知 在目标方法后切入追加功能，如果目标方法抛异常不会切入功能。采用@AfterReturning @AfterReturning("切入点表达式") public void xxx(
java文件上传，断点续传+aop操作日志
04-11
"java文件上传，断点续传+aop操作日志"这个主题涵盖了几个关键知识点：文件上传、断点续传技术、AOP（面向切面编程）以及操作日志记录。 1. **文件上传**： 文件上传是指用户通过Web页面将本地文件传输到服务器的...
西门子操作面板AOP30使用说明.zip
09-19
西门子操作面板AOP30是一款用于工业自动化领域的用户界面设备，它为控制系统提供了直观的人机交互方式。...在遇到具体问题时，参考提供的“A0558.pdf”文档和“AOP30”相关资料，将有助于更深入地理解和解决问题。
AOP操作面板学习
04-25
### AOP操作面板学习知识点详解 #### 一、AOP30操作面板简介 - **定义**: AOP30操作面板是专为SINAMICS S120变频调速柜设计的一种人机交互界面，用于实现对变频器的操作、监控与调试。 - **功能**: 支持参数设置、...
spring boot aop记录修改前后的值demo
11-22
例如，在进行数据修改操作之前和之后，我们往往需要记录相关的操作信息，以便于后续的审计和回溯，这就需要AOP来实现。 AOP通过切面（Aspect）的概念，将横切关注点与业务逻辑分离。在Spring Boot中，我们可以定义...
Spring Aop操作的相关的jar包
04-03
在提供的压缩包"lib"中，可能包含了Spring AOP操作所需的jar包，这些jar包通常包括Spring的核心库、AOP库以及可能的代理库（如CGLIB）。确保这些库被正确地添加到项目的类路径中，以便Spring AOP能正常工作。
Spring知识点总结
qq_1365343049的博客
03-16 404
1.Spring 1.1简介 Spring：春天----------------->给软件行业带来了春天 SSH：Struct+Spring+Hibernate SSM：SpringMVC+Spring+Mybatis 官网：https://spring.io/projects/spring-framework#overview maven <!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc --&g
SpringAOP&整合Mybatis&事务
阿果子的博客
08-27 272
package com.zp.demon01; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; /** * InvocationHandler调用处理程序 * 写在前面：真实对象和代理对象都要实现/继承共同的规范（抽象类或接口），而真实对象只需要实现纯粹的方法即可 * 而代理对象可以做额外的任务，比如记录日志等。 */ pu.
Spring~使用AOP思想,实现MyBatis-Spring声明式事务
2401_84092727的博客
05-04 999
小编在这里分享些我自己平时的学习资料，由于篇幅限制，pdf文档的详解资料太全面，细节内容实在太多啦，所以只把部分知识点截图出来粗略的介绍，每个小节点里面都有更细化的内容！程序员代码面试指南 IT名企算法与数据结构题目最优解这是” 本程序员面试宝典!书中对IT名企代码面试各类题目的最优解进行了总结，并提供了相关代码实现。针对当前程序员面试缺乏权威题目汇总这一-痛点， 本书选取将近200道真实出现过的经典代码面试题，帮助广“大程序员的面试准备做到万无一失。“刷”完本书后，你就是“题王”!
Spring（四）--------AOP、整合Mybatis、声明式事务
钟情_的博客
09-02 361
Spring（四）--------AOP、整合Mybatis、声明式事务 11、AOP（重点） 11.1 什么是AOP 总的来说：AOP是在不影响原始业务类的情况下，对代码进行动态的增强 AOP（Aspect Oriented Programming）意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务
Spring(四)——AOP、Spring实现AOP、Spring整合Mybatis、Spring中的事务管理
吃饭了吗
02-26 849
1. 什么是AOP AOP（Aspect Oriented Programming）意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的...
day2021-10-08(SpringAOP详解，Spring Mybatis整合)
TIM_Zhang1122的博客
10-07 250
2. AOP 2.1 相关术语 目标类：需要被增强的类、代理的目标对象。 连接点：目标类可能被增强的每一个方法。 切入点：特殊的连接点，已经被增强了。 通知/增强：增强的方法 2.2 切入点表达式 作用：将通知/增强作用于具体切入点 基本格式： 指示符(表达式) 1.指示符分类： 【execution】：用于匹配方法执行的连接点； within：用于匹配指定类型内的方法执行； this：用于匹配当前AOP代理对象类型的执行方法；注意是AOP代理对象的类型匹配，这样就可能包括引入接口也类型匹配；
Spring学习：五、AOP 面向切面编程、Spring与Mybatis整合
H215919719的博客
12-09 781
​ AOP英文名为Aspect Oriented Programming，意为面向切面编程，通过预编译方式和运行期间动态代理实现程序功能统一维护的一种技术。AOP是OOP的延续，是Spring框架中的一个重要内容，利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。​ 面向切面编程，实现在不修改源代码的情况下给程序动态统一添加额外功能的一种技术，如下图所示：​ AOP 采取横向抽取机制（动态代理），取代了传统纵向继承机制的重复性代
Spring5 14 注解实现AOP&&回顾Mybatis
小哞^同^学的技术博客
07-09 258
在 一个类 的 上面 加上 让其 变为切面类。然后 再加一个 让这个 类 在 spring 容器中 注册。在 before、after、around 方法 的上面 加上 对应的 注解。 被 注解的方法有些特殊，因为是 环绕的方法。所以 spring 允许 你有个参数。这个参数的类型是 ，这个东西 叫做 注入点。我们可以通过它 拿到 很多 被代理对象/接口 的 很多信息。 编写 配置文件 进行基础测试...
Spring5_狂神（IOC，AOP，SpringMybatis，事务）
Java后端技术栈
04-21 1186
转载链接：https://www.cnblogs.com/renxuw/p/12994080.html Mybatis学完开始学Spring 同样先放上参考文档，现在只是需要短时间之内要过一下基础，等考完研再看要不要深入学习吧。 B站https://www.bilibili.com/video/BV1WE411d7Dv 狂神说Spring01：概述及IOC理论推导https://mp.weixin.qq.com/s/VM6INdNB_hNfXCMq3UZgTQ 狂神说Spring02：快速上手..
aop操作记录
最新发布
10-10
### AOP实现操作记录的方法 Spring AOP使用代理模式和字节码操作技术实现AOP功能。为目标对象创建代理对象，当调用目标对象的方法时，实际上调用的是代理对象的方法。代理对象在调用目标方法前后，插入额外的代码...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值