Spring的AOP

最新推荐文章于 2023-04-27 14:29:32 发布
最新推荐文章于 2023-04-27 14:29:32 发布
阅读量106 收藏
点赞数
分类专栏： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Frist_l/article/details/118519587
版权

使用注解开发

  • 在Spring4之后，使用注解开发就必须导入了AOP的包
    在这里插入图片描述
  • 使用注解需要导入context约束，增加注解的支持
<?xml version="1.0" encoding="utf-8" ?>
<beans:beans xmlns:beans="http://www.springframework.org/schema/beans"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xmlns:context="http://www.springframework.org/schema/context"
             xsi:schemaLocation="http://www.springframework.org/schema/beans
            https://www.springframework.org/schema/beans/spring-beans.xsd
            http://www.springframework.org/schema/context
            https://www.springframework.org/schema/context/spring-context.xsd">
    <context:component-scan base-package="com.lin.pojo"/>
    <context:annotation-config/>
</beans:beans>
  • 属性注入
package com.lin.pojo;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component
public class User {
     @Value("new Value")
     public String name;

     @Value("value")
     public void setname(String name){
          this.name = name;
     }
}
  • 衍生的注解
    Dao @Repository
    Service @Service
    controlle r@controller
  • 自动装配置
  • @Autowired :自动装配通过类型。名字
    如果Autowi red不能唯一自动装配上属性，则需要通过@Qualifier(value=“xxx”)
  • @Nul7ab1e
    字段标记了这个注解，说明这个字段可以为nu11;
    -@ Resource
  • 作用域
  • @Prototype
package com.lin.pojo;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

@Component
@Scope("prototype")
public class User {
     @Value("new Value")
     public String name;

     @Value("value")
     public void setname(String name){
          this.name = name;
     }
}

使用java的方式配置Spring

我们现在完全不用使用xml的配置了全权交给java来做
JavaConfig是Spring的一个子功能，在Spring4 之后成为了核心功能

  • 实体类
package com.lin.dao;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component
public class User {
    private String name;

    public String getName() {
        return name;
    }

    @Value("testName")
    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                '}';
    }
}
  • 配置文件
package com.lin.config;

import com.lin.dao.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;

@Configuration
@ComponentScan("com.lin.dao")
@Import(UserConfigs.class)
public class UserConfig {

    @Bean
    public User getuser(){
        return new User();
    }

}
  • 测试类
import com.lin.dao.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import com.lin.config.UserConfig;

public class newTest {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(UserConfig.class);
        User user = (User) context.getBean("getuser");
        System.out.println(user.getName());
    }
}

使用代理模式

角色分析

  • 抽象角色:一般用接口或抽象类来解决
  • 真实角色:被代理的角色
  • 代理角色:代理的真实角色
  • 客户:访问代理的人
    代码步骤
  • 接口
package com.lin.dao;

public interface Rent {
    public void rent();
}
  • 真实角色
package com.lin.dao;

public class Host implements Rent{
    @Override
    public void rent() {
        System.out.println("出租房子");
    }
}
  • 代理角色
package com.lin.dao;

public class proxy implements Rent{
    private Host host;
    public proxy(){

    }

    public proxy(Host host) {
        this.host = host;
    }

    @Override
    public void rent() {
        host.rent();
        seeHome();
        heTong();
        zJie();
    }
    public void seeHome(){
        System.out.println("看房");
    }

    public void heTong(){
        System.out.println("合同");
    }
    public void zJie(){
        System.out.println("中介");
    }
}
  • 客户端访问代理角色
package com.lin.dao;

public class show {
    public static void main(String[] args) {
        Host host = new Host();
        proxy pro = new proxy(host);
        pro.rent();
    }
}

代理模式的好处

  • 可以使真实的操作更加纯粹，不用去关注一些公共的业务
  • 公共也就是交给了代理角色，实现了业务的分工
  • 公共业务发生扩展的时候，方便集中管理
    缺点:一个真实的角色就会产生一个代理角色，代码量会翻倍，开发效率会变低

静态代理理解

1、创建一个抽象角色，比如咋们平时做的用户业务，抽象起来就是增删改查！

//抽象角色：增删改查业务

public interface UserService {
    void add();
    void delete();
    void update();
    void query();
}

2、我们需要一个真实对象来完成这些增删改查操作

//真实对象，完成增删改查操作的人

public class UserServiceImpl implements UserService {
 
    public void add() {
        System.out.println("增加了一个用户");
    }
 
    public void delete() {
        System.out.println("删除了一个用户");
    }
 
    public void update() {
        System.out.println("更新了一个用户");
    }
 
    public void query() {
        System.out.println("查询了一个用户");
    }
}

3、需求来了，现在我们需要增加一个日志功能，怎么实现！

思路1 ：在实现类上增加代码 【麻烦！】

思路2：使用代理来做，能够不改变原来的业务情况下，实现此功能就是最好的了！

4、设置一个代理类来处理日志！代理角色

//代理角色，在这里面增加日志的实现

public class UserServiceProxy implements UserService {
    private UserServiceImpl userService;
 
    public void setUserService(UserServiceImpl userService) {
        this.userService = userService;
    }
 
    public void add() {
        log("add");
        userService.add();
    }
 
    public void delete() {
        log("delete");
        userService.delete();
    }
 
    public void update() {
        log("update");
        userService.update();
    }
 
    public void query() {
        log("query");
        userService.query();
    }
 
    public void log(String msg){
        System.out.println("执行了"+msg+"方法");
    }
 
}

5、测试访问类：

public class Client {
    public static void main(String[] args) {
        //真实业务
        UserServiceImpl userService = new UserServiceImpl();
        //代理类
        UserServiceProxy proxy = new UserServiceProxy();
        //使用代理类实现日志功能！
        proxy.setUserService(userService);
 
        proxy.add();
    }
}

AOP

动态代理

动态代理的角色和静态代理的一样 .

动态代理的代理类是动态生成的 . 静态代理的代理类是我们提前写好的

动态代理分为两类 : 一类是基于接口动态代理 , 一类是基于类的动态代理

基于接口的动态代理----JDK动态代理

基于类的动态代理–cglib

现在用的比较多的是 javasist 来生成动态代理 . 百度一下javasist

我们这里使用JDK的原生代码来实现

JDK的动态代理需要了解两个类

核心 : InvocationHandler 和 Proxy 打开JDK帮助文档看看

【InvocationHandler：调用处理程序】

Object invoke(Object proxy, 方法 method, Object[] args)；
//参数
//proxy - 调用该方法的代理实例

//method -所述方法对应于调用代理实例上的接口方法的实例。方法对象的声明类将是该方法声明的接口，它可以是代理类继承该方法的代理接口的超级接口。

//args -包含的方法调用传递代理实例的参数值的对象的阵列，或null如果接口方法没有参数。原始类型的参数包含在适当的原始包装器类的实例中，例如java.lang.Integer或java.lang.Boolean 。

public Object getProxy(){
    return Proxy.newProxyInstance(this.getClass().getClassLoader(),
               rent.getClass().getInterfaces(),this);
}

代码实现

抽象角色和真实角色和之前的一样！

Rent . java 即抽象角色

//抽象角色：租房

public interface Rent {
    public void rent();
}

Host . java 即真实角色

//真实角色: 房东，房东要出租房子

public class Host implements Rent{
    public void rent() {
        System.out.println("房屋出租");
    }
}

ProxyInvocationHandler. java 即代理角色

public class ProxyInvocationHandler implements InvocationHandler {
    private Rent rent;
 
    public void setRent(Rent rent) {
        this.rent = rent;
    }

//生成代理类，重点是第二个参数，获取要代理的抽象角色！之前都是一个角色，现在可以代理一类角色

    public Object getProxy(){
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),
                rent.getClass().getInterfaces(),this);
    }
    

// proxy : 代理类 method : 代理类的调用处理程序的方法对象.
// 处理代理实例上的方法调用并返回结果

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        seeHouse();
        //核心：本质利用反射实现！
        Object result = method.invoke(rent, args);
        fare();
        return result;
    }

//看房

    public void seeHouse(){
        System.out.println("带房客看房");
    }
    //收中介费
    public void fare(){
        System.out.println("收中介费");
    }
 
}

Client . java

//租客
public class Client {
 
    public static void main(String[] args) {
        //真实角色
        Host host = new Host();
        //代理实例的调用处理程序
        ProxyInvocationHandler pih = new ProxyInvocationHandler();
        pih.setRent(host); //将真实角色放置进去！
        Rent proxy = (Rent)pih.getProxy(); //动态生成对应的代理类！
        proxy.rent();
    }
 
}

核心：一个动态代理 , 一般代理某一类业务 , 一个动态代理可以代理多个类，代理的是接口！、

深化理解

我们来使用动态代理实现代理我们后面写的UserService！

我们也可以编写一个通用的动态代理实现的类！所有的代理对象设置为Object即可！

public class ProxyInvocationHandler implements InvocationHandler {
    private Object target;
 
    public void setTarget(Object target) {
        this.target = target;
    }
 
    //生成代理类
    public Object getProxy(){
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),
                target.getClass().getInterfaces(),this);
    }
 
    // proxy : 代理类
    // method : 代理类的调用处理程序的方法对象.
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        log(method.getName());
        Object result = method.invoke(target, args);
        return result;
    }
 
    public void log(String methodName){
        System.out.println("执行了"+methodName+"方法");
    }
 
}

测试！

public class Test {
    public static void main(String[] args) {
        //真实对象
        UserServiceImpl userService = new UserServiceImpl();
        //代理对象的调用处理程序
        ProxyInvocationHandler pih = new ProxyInvocationHandler();
        pih.setTarget(userService); //设置要代理的对象
        UserService proxy = (UserService)pih.getProxy(); //动态生成代理类！
        proxy.delete();
    }
}

测试，增删改查，查看结果！

动态代理的好处

静态代理有的它都有，静态代理没有的，它也有！

可以使得我们的真实角色更加纯粹 . 不再去关注一些公共的事情 .

公共的业务由代理来完成 . 实现了业务的分工 ,

公共业务发生扩展时变得更加集中和方便 .

一个动态代理 , 一般代理某一类业务

一个动态代理可以代理多个类，代理的是接口！

First_ll
关注
专栏目录
SpringAOP(图文详解)
lhj520cb的博客
07-16 4万+
Spring实现的AOP是代理模式，给调用者使用的实际是已经过加工的对象，你编程时方法体里只写了A，但调用者拿到的对象的方法体却是xAy。x和y总还是需要你来写的，这就是增强。x和y具体在什么时候被调用总还是需要你来规定的，虽然是基于约定的声明这种简单的规定，这就是切点。
Spring AOP全面详解(超级详细)
热门推荐
Cr1556648487的博客
09-09 8万+
AOP （Aspect Orient Programming）,直译过来就是 面向切面编程,AOP 是一种编程思想，是面向对象编程（OOP）的一种补充。面向切面编程，实现在不修改源代码的情况下给程序动态统一添加额外功能的一种技术，如下图所示：AOP可以拦截指定的方法并且对方法增强，而且无需侵入到业务代码中，使业务与非业务处理逻辑分离，比如Spring的事务，通过事务的注解配置，Spring会自动在业务方法中开启、提交业务，并且在业务处理失败时，执行相应的回滚策略。
SpringAOP学习--SpringAOP简介及原理
u012098021的博客
05-15 6万+
前文对AOP做了介绍，实际项目中，一般不会直接上手手动实现aop，而是使用一些高级封装的aop实现，如SpringAOP。 Spring是一个广泛应用的框架，SpringAOP则是Spring提供的一个标准易用的aop框架，依托Spring的IOC容器，提供了极强的AOP扩展增强能力，对项目开发提供了极大地便利。 前文提到AOP的实现有AspectJ、JDK动态代理、CGLIB动态代理，SpringAOP不是一种新的AOP实现，其底层采用的是JDK/CGLIB动态代理。 JDK动态代理回顾 上一篇简单介绍了
Spring AOP详解
chongbaozhong的博客
05-26 3756
前言 什么是AOP AOP （Aspect Orient Programming）,直译过来就是 面向切面编程。AOP 是一种编程思想，是面向对象编程（OOP）的一种补充。面向对象编程将程序抽象成各个层次的对象，而面向切面编程是将程序抽象成各个切面，是Spring的核心思想之一。 AOP 实现分类 AOP 要达到的效果是，保证开发者不修改源代码的前提下，去为系统中的业务组件添加某种通用功能。AOP 的本质是由 AOP 框架修改业务组件的多个方法的源代码，按照 AOP 框架修改源代码的时机，可以将其分为两类：
spring aop详解
hanbin1998的博客
04-13 5642
1.前言 spring aop是一个面向切面的编程，在自己第一遍学习的时候，感觉aop没有什么作用，但是真实接触下来，感觉spring aop还是很有用途的，感觉自己之前的想法太年轻了。 2.概念 Spring 提供了两种AOP 的实现：基于注解式配置和基于XML配置，我这里主要就是介绍一下，基于注解式配置。 2.1 AOP 即 Aspect Oriented Program 面向切面编程 首先，在面向切面编程的思想里面，把功能分为核心业务功能，和周边功能。 所谓的核心业务，工作中做的最多的
spring aop参数传递
weixin_43931625的博客
04-23 2707
spring aop参数传递
spring aop 注解
面朝大海，春暖花开
02-27 3376
spring Aop 注解 Aop 术语 AOP 的特性术语，不同的翻译还会不一样，得在过程中理解 横切关注点：跨越程序多个模块的方法或功能。即与业务逻辑无关，但我们也要关注的部分，就是横切关注点。如日志、安全、缓存等。 切面（ Aspect ）：横切关注点被模块化的特殊对象；即切面应是一个类。 通知（ Advice）：切面要完成的增强处理，通知描述了切面何时执行以及如何执行增强处理；即通知应是切面中的方法。 目标（ Target ）：被通知对象。 代理（ Proxy ）：向目标对象应用通知之后创建的对象
Spring AOP 动态代理
qq15035899256的博客
08-30 1713
本文是Spring AOP的学习，学习AOP的思想，AOP的使用(定义切面、切点和通知)，以及两种常用的AOP使用方法。之后的学习内容将持续更新！！！
Spring——Spring AOP原理
庄小焱
03-30 2588
AOP即面向切面编程，是OOP编程的有效补充。使用AOP技术，可以将一些系统性相关的编程工作，独立提取出来，独立实现，然后通过切面切入进系统。从而避免了在业务逻辑的代码中混入很多的系统相关的逻辑.AOP是Spring提供的关键特性之一，本文深入剖析Spring AOP的原理。
Spring AOP 代码加案例详解
持续学习，持续更新
04-27 2684
学习AOP就要先学习代理模式，这样AOP的学习就简单了。代理模式是Java常见的设计模式之一，包含：静态代理和动态代理。通过案例感受静态代理：租房子问题。房东需要将房子出租，如果都亲力亲为太麻烦了：房东要自己出去贴广告，带租客看房，讨价还价，签合同，收租金，定期检查房子，定期保洁。这时候就需要中介代理了，房东就是要租房拿钱，额外的功能：签合同，讨价还价，定期检查房子 ，定期保洁都由中介代理去做，所以 代理 简化了 业主的功能,同时对房东的功能做了一个扩展。找中介的好处：（1）保护真实对象 （房东） （2
Spring AOP 16道面试题及答案.docx
06-29
Spring AOP，全称为Aspect Oriented Programming，是面向切面编程的一种编程范式，它是对传统的面向对象编程（OOP）的一种补充。在OOP中，核心是对象，而在AOP中，核心则是切面。切面是关注点的模块化，即程序中的...
SpringAOP:Spring AOP示例
05-06
SpringAOP Spring AOP（面向方面​​的编程）用于模块化“横截面”服务。 用一种简单的方式，我们可以说它是一个旨在拦截某些进程的组件，例如，在执行某个方法时，Spring AOP可以审核该执行方法，并在该方法执行...
Spring源码最难问题：当Spring AOP遇上循环依赖.docx
06-15
Spring源码最难问题：当Spring AOP遇上循环依赖 Spring源码中最难的问题之一是循环依赖问题，当Spring AOP遇上循环依赖时，该如何解决？ Spring通过三级缓存机制解决循环依赖的问题。 在Spring中，bean的实例化...
spring AOP 引入jar包，spring IOC 引入Jar包
09-07
Spring AOP 和 Spring IOC 是 Spring 框架的两个核心组件，它们对于任何基于 Java 的企业级应用开发都至关重要。Spring AOP（面向切面编程）允许开发者在不修改源代码的情况下，通过“切面”来插入新的行为或增强已...
java基于SpringBoot+vue 美食信息推荐系统源码 带毕业论文
09-12
1、开发环境：SpringBoot框架；内含Mysql数据库；VUE技术；内含说明文档 2、需要项目部署的可以私信 3、项目代码都经过严格调试，代码没有任何bug！ 4、该资源包括项目的全部源码，下载可以直接使用！ 5、本项目适合作为计算机、数学、电子信息等专业的课程设计、期末大作业和毕设项目，作为参考资料学习借鉴。 6、本资源作为“参考资料”如果需要实现其他功能，需要能看懂代码，并且热爱钻研，自行调试。
Sigrity-SystemSI-Statistical Analysis Application Note.rar
09-12
Sigrity-SystemSI-Statistical Analysis Application Note.rar 介绍 Sigrity SystemSI-串行链路分析中使用的传统分析流程涉及 基于高级卷积信道的信道电路冲激响应 并在接收器处导出时域波形。这些波形是 经过统计后处理，生成眼图、浴缸曲线和其他输出。 通过信道运行的比特数越多，结果就越准确。 统计分析通常适用于线性时不变（LTI）系统。a中的线性 系统指示叠加适用。时间不变性表明，对于具有 x（t）输入和y（t）输出，输入中的时移z，例如x（t+z）将导致 对应的时移输出y（t+z）。许多（尽管不是全部）串行链路系统可以近似为LTI，因此统计分析是串行链路分析工具箱中一种有用的功能。 与时域仿真方法相比，纯统计分析的主要优点是可以直接考虑所有符号间干扰（ISI）。 因此，它的准确性不依赖于模拟的比特数，就像传统的时域方法一样。 统计分析的主要局限性是它只适用于LTI系统。 使用AMI_GetWave函数执行实时波形处理的算法（AMI）模型不能保证LTI操作。 许多使用Decision的多千兆位接收器 反馈均衡（DFE）使
MATLAB的汉字定位检测识别系统GUI设计.zip
09-12
产品经理项目实战案例
Sigrity-T2B Quick Reference.rar
最新发布
09-12
Sigrity-T2B Quick Reference.rar 本文档简要介绍了T2B，并逐步说明了您可以在T2B中执行的基本程序。 T2B将晶体管转换为行为模型，以便在数小时内而不是数天内实现准确高效的全总线模拟。 模型输出采用IBIS 3.2、4.2、5.0、5.1、6.0和6.1格式，以及精度增强的Cadence Sigrity行为模型格式。 T2B满足了对精确系统级仿真的需求，由于高速接口技术的快速发展，这一需求变得至关重要。 耗时的晶体管级仿真和不准确的传统IBIS模型仿真在SSO研究等仿真中无法达到要求，其中功率传输效应起着至关重要的作用。使用T2B生成的功率感知行为驱动模型最大限度地提高了准确性，并支持使用Cadence SPEED2000、SystemSI、Spectre或HSPICE兼容模拟器进行高效模拟
spring aop
09-11
Spring AOP（Aspect-Oriented Programming）是Spring框架中的一个重要特性，它提供了一种在应用程序中实现横切关注点（cross-cutting concerns）的方法。所谓横切关注点，指的是那些在应用程序中散布于各个模块之中、具有共同逻辑的行为，例如日志记录、事务管理、安全检查等。 通过使用Spring AOP，开发者可以将这些横切关注点从业务逻辑代码中剥离出来，以便于在不同模块中重复使用，并且能够更好地实现模块化开发。Spring AOP基于AOP的思想，通过在运行时动态地将横切关注点织入到目标对象的方法中，实现了与业务代码的解耦。 Spring AOP主要通过定义切面（Aspect）和连接点（Join Point）来实现，其中切面定义了横切关注点的逻辑，而连接点则指定了在目标对象中哪些方法需要织入切面逻辑。Spring AOP支持多种类型的通知（Advice），包括前置通知（Before Advice）、后置通知（After Advice）、异常通知（After-Throwing Advice）、返回通知（After-Returning Advice）和环绕通知（Around Advice），开发者可以根据需要选择合适的通知类型。 总的来说，Spring AOP是Spring框架中的一个重要特性，它通过在运行时动态地将横切关注点织入到目标对象的方法中，实现了对应用程序中横切关注点的解耦，提高了代码的可维护性和可重用性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值