Spring学习笔记【十二】AOP编程

最新推荐文章于 2023-08-14 13:48:00 发布
最新推荐文章于 2023-08-14 13:48:00 发布
阅读量148 收藏
点赞数
文章标签： spring 代理模式 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46100927/article/details/122797801
版权

AOP编程

01 AOP 概念

  1. AOP：面向切面编程 ，Aspect Oriented Programing
    • 以切面为基本单位的程序开发，通过切面之间的彼此协作，相互调用，完成程序之间的构建
    • 切面 = 切入点 + 额外功能
    • 本质就是 Spring 的动态代理开发，通过代理类为原始类添加额外功能
    • 好处：利于原始类的维护
    • AOP是对OOP的补充
  2. OOP：面向对象编程
    • 以对象为基本单位的程序开发，通过对象之间的彼此协作，相互调用，完成程序之间的构建
  3. POP：面向过程编程
    • 以过程为基本单位的程序开发，通过过程之间的彼此协作，相互调用，完成程序的构建

02  AOP编程开发步骤

  1. 原始对象
  2. 额外功能
  3. 切入点
  4. 组装切面

03 切面的名词解释

切面 = 切入点 + 额外功能

04 AOP的底层实现原理

4.1 核心问题

问题一：AOP如何创建动态代理类

  1. 使用动态字节码技术

问题二：Spring的工厂是如何加工创建代理对象

  1. 通过原始对象的id值，获得的是代理对象

4.2 动态代理类的创建

JDK的动态代理
Proxy.newProxyInstance(classLoader, insterface, invocationHandler)

参数信息

InvocationHandler

  • 用来书写额外功能，额外功能运行在原始方法执行之前，之后，前后，抛出异常

提供的方法：

Object invoke(Object proxy,Method method,Object[]args){
    
}
- proxy：代表的是代理对象
- Method：额外功能，所添加给的原始方法
- Object[] args : 原始方法的参数


insterface

  • 原始类和代理类实现同一个接口
对象.getClass().getInstance()

classLoader
作用：借用一个类加载器，创建代理类的Class对象，进而创建代理对象
类加载器的作用

  1. 通过类加载器把对应类的字节码文件加载JVM
  2. 通过类加载器创建类的Class对象，进而创建这个类的对象

如何获得类加载器

  1. 每一个类的.class 文件，自动分配与之对应的ClassLoader
编码实现
package com.spring.jdk;
public class TestJDKProxy {
    public static void main(String[] args) {
        // 创建原始对象
        final UserService userService = new UserServiceImpl();
        // JDk 创建动态代理
        InvocationHandler invocationhandler = new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("------Proxy log----------------");
                Object ret = method.invoke(userService,args);
                return ret;
            }
        };
        UserService userServiceTem = (UserService)Proxy.newProxyInstance(
                TestJDKProxy.class.getClassLoader(),
                userService.getClass().getInterfaces(),
                invocationhandler);
        userServiceTem.login(new User());
        }
}

CGlib的动态代理

解决：原始类没有实现任何的接口， 但是仍然需要代理类
原理：父子继承关系创建代理对象， 原始类作为父类， 代理类作为子类， 这样既可以保证两者方法一致，同时可以在代理类中添加新的实现

  • 原始类
public class UserService {
    public void login(String username,String pass){
        System.out.println("UserService.login");
    }
    public void register(String username){
        System.out.println("UserService.register");

    }
}
  • Cglib动态代理
public class TestCglib {
    public static void main(String[] args) {
        final UserService userService = new UserService();
        Enhancer enhancer = new Enhancer();
        enhancer.setClassLoader(TestCglib.class.getClassLoader());
        enhancer.setSuperclass(userService.getClass());
        MethodInterceptor methodInterceptor = new MethodInterceptor() {
            @Override
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                System.out.println("-----------Cglib log--------------");
                Object invoke = method.invoke(userService, objects);
                return  invoke;
            }
        };
        enhancer.setCallback(methodInterceptor);
        UserService service = (UserService) enhancer.create();
    }
}

两种方式对比
  1. **JDK动态代理 **： **通过接口 **创建代理的实现类
  2. **Cglib动态代理 **： **通过继承 **父类创建的代理类

05 Spring对于代理的加工

 <bean id="beanPostProcessorTest" class="com.spring.jdk.BeanPostProcessorTest" />
 <bean id="userService" class="com.spring.jdk.UserServiceImpl" />

package com.spring.jdk;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;

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

public class BeanPostProcessorTest implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        final Object tem = bean;
        InvocationHandler invocationHandler = new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("----------BeanPostProcessor-------------");
                Object invoke = method.invoke(tem, args);
                return invoke;
            }
        };
        Proxy.newProxyInstance(BeanPostProcessorTest.class.getClassLoader(),tem.getClass().getInterfaces(),invocationHandler);
        return tem;
    }
}

06 基于AspectJ注解的AOP编程

6.1 AOP的开发步骤

  1. 原始对象
  2. 额外功能
  3. 切入点
  4. 组装切面

6.2 实现aop的步骤

底层仍然是JDK的动态代理

  • 加入依赖

spring依赖     aspectj依赖

<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.8.M1</version>
    <scope>runtime</scope>
</dependency>
<!-- https://mvnrepository.com/artifact/aspectj/aspectjrt -->
<dependency>
    <groupId>aspectj</groupId>
    <artifactId>aspectjrt</artifactId>
    <version>1.5.3</version>
</dependency>
  • 创建目标类
@Data
public class UserServiceImpl implements UserService {
    private UserDao userDao;
    @Override
    public void login(String username, String password) {
        userDao.login(username,password);
    }
}
  • 创建切面类
    • 定义了额外功能 @Arround
    • 定义了切面类 @Aspect
@Aspect
public class MyAspect {
    @Around("execution(* com.spring.aspect..login(..))")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("------------额外功能---------------");
        Object ret = joinPoint.proceed();
        return ret;
    }
}
  • 在Spring的配置文件中进行配置
    • <aop:aspectj-autoproxy/>编程：告知Spring使用 基于注解的AOP
<?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 https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">
    <bean id="userDao" class="com.spring.aspect.UserDaoImpl"></bean>
    <bean id="userService" class="com.spring.aspect.UserServiceImpl">
        <property name="userDao" ref="userDao"></property>
    </bean>
    <bean id="around" class="com.spring.aspect.MyAspect"></bean>
    <aop:aspectj-autoproxy/>
</beans>

6.3 切入点复用

  • 当我们想为 login方法添加其他的额外功能
@Aspect
public class MyAspect {
    @Around("execution(* com.spring.aspect..login(..))")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("------------额外功能---------------");
        Object ret = joinPoint.proceed();
        return ret;
    }

    @Around("execution(* com.spring.aspect..login(..))")
    public Object around1(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("------------日志功能---------------");
        Object ret = joinPoint.proceed();
        return ret;
    }
}

我们发现了，切入点表达式冗余，对于冗余的代码，我们可以提取出去

@Aspect
public class MyAspect {
    @Pointcut("execution(* com.spring.aspect..login(..))")
    public void myPointCut(){}
    
    @Around(value = "myPointCut()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("------------额外功能---------------");
        Object ret = joinPoint.proceed();
        return ret;
    }

    @Around(value = "myPointCut()")
    public Object around1(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("------------日志功能---------------");
        Object ret = joinPoint.proceed();
        return ret;
    }
}

6.4 动态代理的创建方式

  1. 默认情况下，是使用JDK的动态代理
  2. 如果说想使用Cglib的动态代理
<aop:aspectj-autoproxy proxy-target-class="true"/>
  1. 传统方式使用Cglib
<aop:config proxy-target-class="true">
    <aop:pointcut id="pc" expression="@annotation(com.spring.proxy.Log)"/>
    <aop:advisor advice-ref="around" pointcut-ref="pc"/>
</aop:config>

6.5 切面的执行时间

  1. 这个执行时间在规范中叫做通知，同时也可以在xml文件的标签中进行使用
  2. 常用的注解
    • @Before
    • @AfterReturning
    • @Around
    • @AfterThrowing
    • @After

6.6 注意事项

  • 在同一个业务类中，进行业务方法的相互调用，只有最外层的方法，才是加入了额外功能。如果说想让内层的方法同时加入，需要通过下面的方式
package com.spring.aspect;


import lombok.Data;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;

@Data
public class UserServiceImpl implements UserService, ApplicationContextAware {
    private UserDao userDao;
    private ApplicationContext ac;
    @Override
    public void login(String username, String password) {
        userDao.login(username,password);
        UserService userService = (UserService) ac.getBean("userService");
        userService.register(username,password);
    }

    @Override
    public void register(String username, String password) {
        userDao.register(username,password);
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.ac = applicationContext;
    }
}

佩奇inging
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
SpringAOP学习笔记
01-27
AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性...
AOP(面向切面编程)
StudyJava01的博客
12-08 1280
  我们在编写代码时，只想关注逻辑代码的实现。但是我们的程序是要放到服务器上去跑的，我们在代码中如果只有业务逻辑代码。虽然代码简洁，但是万一程序在服务器跑的时候数据出现问题时，没办法快速定位到问题所在。但是将日志等非逻辑代码和我们的逻辑代码放在一起，会使得代码冗余，代码的可读性难度加大。   基于上面的问题，Spring为我们提供了一种解决方案，将业务功能逻辑代码和非功能代码分开来写，然后使用动态代理，将非功能性代码嵌入到功能代码中，这就是所谓的AOP(面向切面编程)。  1、我们要使用Aop对我们的bea
AOP——面向切面编程
m0_62912377的博客
05-05 6046
AOP(Aspect Oriented Programming)面向切面编程，一种编程范式，指导开发者如何组织程序结构。 OOP(Object Oriented Programming)面向对象编程，是一种编程思想，所以，AOP也是一种编程思想，只是他们两个是不同的编程范式。
Spring零基础入门到精通 --- AOP面向切面编程
shuai_h的博客
03-28 822
事务是开发中必不可少的东西，使用JDBC开发时，我们使用connnection对事务进行控制，使用MyBatis时，我们使用SqlSession对事务进行控制，缺点显而易见，当我们切换数据库访问技术时，事务控制的方式总会变化，Spring 就将这些技术基础上，提供了统一的控制事务的接口。Spring的事务分为：编程式事务控制 和 声明式事务控制事务控制方式解释编程式事务控制Spring提供了事务控制的类和方法，使用编码的方式对业务代码进行事务控制，事务控制代码和业务操作代码耦合到了一起，开发中不使用。
Spring 学习笔记心得（九）AOP面向切面编程
12-21
首先我们应该想想为什么要使用aop面向切面编程？面向切面的底层实现是什么？小编在这里举个例子吧 小编首先给出Spring全家桶,方便大家下载使用—->Spring全家桶 1.自定义代理对象代理类以及实现类 1.1 定义接口...
javaSpring学习笔记
最新发布
03-12
在“Java Spring学习笔记”中，你将找到对Spring框架的全面介绍，包括IoC（控制反转）和DI（依赖注入）原理、AOP（面向切面编程）、Spring MVC、Spring Boot等核心内容。每个主题都结合了理论知识和实际示例，帮助你...
spring项目开发学习笔记
04-08
Spring是一个轻量级的DI/IoC和AOP容器框架。存在的目的是用于构建轻量级的J2EE应用。 轻量级：应用大小和应用开支，包括应用方式 依赖注入DI/IoC控制反转：提供松耦合的一种实现技术 AOP面向切面编程：(可以在不...
SpringAOP(图文详解)
lhj520cb的博客
07-16 3万+
Spring实现的AOP是代理模式，给调用者使用的实际是已经过加工的对象，你编程时方法体里只写了A，但调用者拿到的对象的方法体却是xAy。x和y总还是需要你来写的，这就是增强。x和y具体在什么时候被调用总还是需要你来规定的，虽然是基于约定的声明这种简单的规定，这就是切点。
Spring AOP编程（十分详细）
baalndsc的博客
08-14 105
Spring AOP 是 Spring 框架的核心模块之一，它使用纯 Java 实现，因此不需要专门的编译过程和类加载器，可以在程序运行期通过代理方式向目标类织入增强代码。
AOP总结
qq_63850376的博客
08-28 151
AOP总结
Spring Aop编程
mr_xioabai的博客
03-30 112
aop。
什么是面向切面编程AOP
weixin_30932215的博客
04-03 214
什么是面向切面编程AOP 原文:什么是面向切面编程AOP一丶前言 　　看过一些描述关于AOP切面编程的文章，写的太概念化让人很难理解，下面是我自己的理解，希望能帮到新人，如有错误欢迎指正。 二丶AOP是什么，它的应用场景是什么？ 　　AOP也跟IOC，OOP这些思想一样它只是一种编程思想。Autofac、Spring.Net、Castle...
AOP（面向切面编程）
wang的博客
10-20 208
AOP（面向切面编程）
面向切面编程（AOP）的理解
热门推荐
Intlgj的专栏
06-14 6万+
<br />在传统的编写业务逻辑处理代码时，我们通常会习惯性地做几件事情：日志记录、事务控制及权限控制等，然后才是编写核心的业务逻辑处理代码。当代码编写完成回头再看时，不禁发现，扬扬洒洒上百行代码中，真正用于核心业务逻辑处理才那么几行，如图6-4所示。方法复方法，类复类，就这样子带着无可奈何遗憾地度过了多少个春秋。这倒也罢，倘若到了项目的尾声，突然决定在权限控制上需要进行大的变动时，成千上万个方法又得一一"登门拜访"，痛苦"雪上加霜"。 <br />如果能把图6-4中众多方法中的所有共有代码全部抽取出来，放
SpringAOP编程
lanziDemo blog
11-23 384
问题1：AOP的作用是什么？问题2：连接点和切入点有什么区别，二者谁的范围大？问题3：请描述什么是切面？AOP(Aspect Oriented Programming)面向切面编程，一种编程范式，指导开发者如何组织程序结构OOP(Object Oriented Programming)面向对象编程作用：在不惊动原始设计的基础上为其进行功能增强。简单的说就是在不改变方法源代码的基础上对方法进行功能增强。Spring理念：无入侵式/无侵入式} }
什么是AOP编程？
LVXIANGAN的专栏
11-27 4388
AOP是OOP的延续，是Aspect Oriented Programming的缩写，直译意思：面向方面编程、面向切面编程。 AOP通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态统一添加功能的一种技术。可以在代码阶段实现分离关注，实现松耦合，然后在运行时将相关动作特征植入运行，从而改变程序的运行顺序，达到拦截或者增加功能的目的。 常见框架：VirtualXposed   ...
aop面向切面编程学习笔记
05-11
AOP（Aspect-Oriented Programming）面向切面编程是一种编程思想，它能够使我们将通用的功能模块与业务模块分离开来，从而使我们的代码更易于维护和扩展。此外，它还能够帮助我们处理一些横切问题，如日志记录、事务...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

佩奇inging

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值