spring中的AOP

最新推荐文章于 2024-07-15 15:14:58 发布
最新推荐文章于 2024-07-15 15:14:58 发布
阅读量81 收藏
点赞数
分类专栏： spring的入门阶段 文章标签： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhouquanshidai/article/details/114242059
版权

AOP：面向切面编程
在这里插入图片描述
如何使用：

  • Maven，pom.xml
<!--aop工程使用的依赖-->
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.0.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>5.2.0.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>
    </dependencies>
  • 写一个接口，计算机的接口
package com.zhou.dao;

public interface Cal {
    // 计算器功能，如果要实现中途加日志的功能，使用代理对象的方法来完成
    int add(int num1,int num2);
    int sub(int num1,int num2);
    int mul(int num1,int num2);
    int div(int num1,int num2);
}

package com.zhou.impl;
import com.zhou.dao.Cal;
public class CalImpl implements Cal {
// 之前主业务是没有日志的，如果加上日志的话，比如：要打印方法的参数
    @Override
    public int add(int num1, int num2) {
        // 打印参数的日志
        System.out.println("add方法的参数是["+num1+"和"+num2);
        // 实现加法
        int result = num1+num2;
        // 打印结果的日志
        System.out.println("add方法的结果是："+result);
        return result;
    }

    @Override
    public int sub(int num1, int num2) {
        System.out.println("sub方法的参数是["+num1+"和"+num2);
        // 实现减法。
        int result = num1 - num2;
        System.out.println("sub方法的结果是："+result);
        return result;
    }

    @Override
    public int mul(int num1, int num2) {
        System.out.println("mul方法的参数是["+num1+"和"+num2);
        int result = num1 * num2;
        System.out.println("mul方法的结果是："+result);
        return result;
    }

    @Override
    public int div(int num1, int num2) {
        System.out.println("div方法的参数是["+num1+"和"+num2);
        int result = num1 / num2;
        System.out.println("div方法的结果是："+result);
        return result;
    }
}

直接把日志写到主要业务中去，耦合性很高，不利于系统的维护，需要使用AOP来进行优化。AOP是一种编程思想，把公共部分提出来的思想，单数具体去实现来要靠代理对象
使用动态代理的方法去实现。给业务代码找一个代理，打印日志交给代理来做，这样物业代码只需要关注自身的业务实现

  • 通过代理来实现，需要一个代理类：类名如：MyInvocaitonHandler。需要反射机制提供的InvocaitonHander接口来实现动态生成代理类的功能
package com.zhou.impl;

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

// 这个类MyInvocaitonHandler不是动态代理类，而是来创建代理类的
public class MyInvocaitonHandler implements InvocationHandler {
    // 接收委托对象
    private Object object = null;

    // 这个类是要动态生成代理类，所以最终要返回代理对象，并且代理对象必须具备委托对象的功能
    // 所以说返回值类型是Object,参数类型要具备委托对象的功能就要把委托对象传进去
    public Object bind(Object object){
        this.object=object;// 把形参赋给当前的成员变量object
        // 动态生成代理类可以通过Proxy调用newProxyInstance来动态生成代理类
        // 使用类加载器获取的object的是委托对象的运行实例。获取他的所有接口，具体的类，这样相当于代理类实现了委托对象的全部功能，this指的是当前类来动态创建代理对象
        return Proxy.newProxyInstance(object.getClass().getClassLoader(),object.getClass().getInterfaces(),this);
    }

    // invoke方法是用来写这个打印参数和打印结果的，把业务代码和业务信息剥离出来
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println(method.getName()+"方法的参数是["+ Arrays.toString(args));
        // 结果业务方法后产生结果,委托对象的方法this.object
        Object result = method.invoke(this.object, args);
        System.out.println(method.getName()+"结果是："+result);
        return result;
    }
}

把之前的日志方法从业务方法中去掉

package com.zhou.impl;
import com.zhou.dao.Cal;
public class CalImpl implements Cal {
// 之前主业务是没有日志的，如果加上日志的话，比如：要打印方法的参数
    @Override
    public int add(int num1, int num2) {
        int result = num1+num2;
        return result;
    }

    @Override
    public int sub(int num1, int num2) {
        // 实现减法。
        int result = num1 - num2;
        return result;
    }

    @Override
    public int mul(int num1, int num2) {
        int result = num1 * num2;
        return result;
    }

    @Override
    public int div(int num1, int num2) {
        int result = num1 / num2;
        return result;
    }
}

测试

public static void main(String[] args) {
        // 测试代理类
        // 实例化一个委托对象，多态的方式，左边是接口，右边是实现类
        Cal cal = new CalImpl();
        // 实例化代理对象
        MyInvocaitonHandler myInvocaitonHandler = new MyInvocaitonHandler();
        // 把委托对象传进去，返回的还是接口类型的
        Cal cal1 = (Cal) myInvocaitonHandler.bind(cal);
        // 调用各种方法
        cal1.add(1,1);
        cal1.sub(2,1);
        cal1.mul(2,1);
        cal1.div(6,2);
    }

在这里插入图片描述

package com.zhou.aop;

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

import java.util.Arrays;

@Aspect // 加Aspect让它成为切面对象
@Component// Component让ioc来管理
public class LoggerAspect {
    // 搞一个切面类，Aspect是切面的意思
    // 找切面，主要业务功能以外的。把主要功能作为切面，一个是发生在之前的
    // public int add具体的方法是不写，后面跟方法所在的包
    // 首先是找到主业务在哪个包下面，然后在那个之前是日志信息，所以就before写日志
    @Before(value="execution(public int com.zhou.impl.CalImpl.*(..))")
    // 也就是主业务之前发生的功能，即日志功能
    public void before(JoinPoint joinPoint){
        // 获取的参数把它转成数组
/*        Object[] args = joinPoint.getArgs();
        String toString = Arrays.toString(args);*/
        // 整合就是,先获取参数，然后把数组的参数转为字符串
        String args = Arrays.toString(joinPoint.getArgs());
        System.out.println(joinPoint.getSignature().getName()+"方法的日志信息"+"传递的参数是:"+ args);
    }

    @After(value = "execution(public int com.zhou.impl.CalImpl.*(..))")
    public void after(JoinPoint joinPoint){
        // 看哪个方法执行了，而具体的方法执行在主业务之后，所以是After
        System.out.println(joinPoint.getSignature().getName()+"方法执行");
    }

    // 业务的主体在运行后会返回一个结果result，看返回的结果的注解是要使用AfterReturning
    @AfterReturning(value = "execution(public int com.zhou.impl.CalImpl.*(..))",returning = "result")
    public void aferReturning(JoinPoint joinPoint,Object result){
        // 获取方法名
        String name = joinPoint.getSignature().getName();
        System.out.println(name+"方法名的结果是:"+result);
    }

    @AfterThrowing(value = "execution(public int com.zhou.impl.CalImpl.*(..))",throwing = "exception")
    public void afterThrowing(JoinPoint joinPoint,Exception exception){
        // 获取方法名
        String name = joinPoint.getSignature().getName();
        System.out.println(name+"方法抛出异常"+exception);
    }
}

计算器实现类

package com.zhou.impl;
import com.zhou.dao.Cal;
import org.springframework.stereotype.Component;
@Component
public class CalImpl implements Cal {
// 之前主业务是没有日志的，如果加上日志的话，比如：要打印方法的参数
    @Override
    public int add(int num1, int num2) {
        int result = num1+num2;
        return result;
    }

    @Override
    public int sub(int num1, int num2) {
        // 实现减法。
        int result = num1 - num2;
        return result;
    }

    @Override
    public int mul(int num1, int num2) {
        int result = num1 * num2;
        return result;
    }

    @Override
    public int div(int num1, int num2) {
        int result = num1 / num2;
        return result;
    }
}

spring.xml配置

<?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"
       xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-4.3.xsd
">
    <!-- ⾃自动扫描,component-scan，扫描包下所有的类 -->
   <context:component-scan base-package="com.zhou"/>
    <!-- 是Aspect注解⽣生效，为⽬目标类⾃自动⽣生成代理理对象 -->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

测试

import com.zhou.dao.Cal;
import com.zhou.impl.CalImpl;
import com.zhou.impl.MyInvocaitonHandler;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {
    public static void main(String[] args) {
        // 测试代理类
        // 实例化一个委托对象，多态的方式，左边是接口，右边是实现类
       /* Cal cal = new CalImpl();
        // 实例化代理对象
        MyInvocaitonHandler myInvocaitonHandler = new MyInvocaitonHandler();
        // 把委托对象传进去，返回的还是接口类型的
        Cal cal1 = (Cal) myInvocaitonHandler.bind(cal);
        // 调用各种方法
        cal1.add(1,1);
        cal1.sub(2,1);
        cal1.mul(2,1);
        cal1.div(6,2);*/
        // 使用那种方法进行测试就是spring的方式
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
        Cal proxy = (Cal) applicationContext.getBean("calImpl");
        // 方法的调用
        proxy.add(1,1);
        proxy.sub(2,1);
        proxy.mul(2,3);
        proxy.div(6,0);
    }
}
zhouquanshidai
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
SpringAOP(图文详解)
lhj520cb的博客
07-16 3万+
Spring实现的AOP是代理模式，给调用者使用的实际是已经过加工的对象，你编程时方法体里只写了A，但调用者拿到的对象的方法体却是xAy。x和y总还是需要你来写的，这就是增强。x和y具体在什么时候被调用总还是需要你来规定的，虽然是基于约定的声明这种简单的规定，这就是切点。
spring中AOP个人总结
01-21
spring中AOP个人总结 简介 aop（aspect oriented programming）面向切面编程是spring当中一个重要内容，在学习之后感觉这个思想挺不错的，做个总结 AOP讲解 一、面向切面编程 ​ 听说过面向对象编程（oop），但是...
Spring中AOP的实现原理
qq_44918331的博客
03-11 1万+
一、什么是 AOP ？ AOP（Aspect-Oriented Programming，面向方面编程），对 OOP（Object-Oriented Programming，面向对象编程） 【OOP与AOP】 概念 AOP（Aspect-Oriented Programming，面向方面编程） OOP（Object-Oriented Programming，面向对象编程） 方向 OOP 定义从上到下的关系 AOP 定义从左到右的关系 【两个部分】 核心关注点 业务处理的主要流程
【Spring】Spring中AOP的简介和基本使用，SpringBoot使用AOP
qq_61024956的博客
05-07 4537
AOP的全称是Aspect-Oriented Programming，即面向切面编程（也称面向方面编程）。它是面向对象编程（OOP）的一种补充，目前已成为一种比较成熟的编程方式。在传统的业务处理代码中，通常都会进行事务处理、日志记录等操作。虽然使用OOP可以通过组合或者继承的方式来达到代码的重用，但如果要实现某个功能（如日志记录），同样的代码仍然会分散到各个方法中。这样，如果想要关闭某个功能，或者对其进行修改，就必须要修改所有的相关方法。这不但增加了开发人员的工作量，而且提高了代码的出错率。
Spring中AOP的运用
qq_16268979的博客
03-22 2599
Spring中的AOP（面向切面编程）运用十分广泛和方便，我们常用于日志、事务的处理，其实能够用到的地方远远不止于此，这篇文章主要就介绍AOP的用法和一些运用实例以及思路。
细说Spring——AOP详解（AOP概览）
热门推荐
啦啦啦的博客
05-30 53万+
一、对AOP的初印象 首先先给出一段比较专业的术语（来自百度）： 在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方 式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个 热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑 的各个部分进行隔离，从而...
【Spring】Spring中AOP解析 中 AOP的具体实现流程
纸上得来终觉浅，绝知此事要躬行
04-07 2262
3.ProxyFactoryBean 代理工厂Bean 生产代理类 首先 在Spring中,如果一个类实现了FactoryBean 接口,最终放到容器中的bean是getObject返回的对象 因此,可以通过ProxyFactoryBean 代理工厂bean,创建一个bean的代理类放到容器中 1.案例演示一 new 对象与通知: 配置类 @Configuration public class MyProxyFactoryBeanConf { @Bean public Object pro
spring中aop的注解实现方式
wujian_csdn_csdn的博客
06-18 5371
注解方式实现aop我们主要分为如下几个步骤 1.在切面类（为切点服务的类）前用@Aspect注释修饰，声明为一个切面类。 2.用@Pointcut注释声明一个切点，目的是为了告诉切面，谁是它的服务对象。（此注释修饰的方法的方法体为空，不需要写功能比如 public void say(){};就可以了，方法名可以被候命的具体服务功能所以引用，它可以被理解为切点对象的一个代理对象方法） 3.在对应的方...
解决spring中aop无法拦截service层内部方法调用
qq_39099625的博客
07-06 1839
解决spring中aop无法拦截service层内部方法调用
Spring中AOP的作用 为什么要使用AOP
猫的薛定谔
04-23 4574
假如没有aop，在做日志处理的时候，我们会在每个方法中添加日志处理，比如 但大多数的日子处理代码是相同的，为了实现代码复用，我们可能把日志处理抽离成一个新的方法。但是这样我们仍然必须手动插入这些方法。 但这样两个方法就是强耦合的，假如此时我们不需要这个功能了，或者想换成其他功能，那么就必须一个个修改。 通过动态代理，可以在指定位置执行对应流程。这样就可以将一些横向的功能抽离出来形成一...
Spring AOP详解
chongbaozhong的博客
05-26 3651
前言 什么是AOP AOP （Aspect Orient Programming）,直译过来就是 面向切面编程。AOP 是一种编程思想，是面向对象编程（OOP）的一种补充。面向对象编程将程序抽象成各个层次的对象，而面向切面编程是将程序抽象成各个切面，是Spring的核心思想之一。 AOP 实现分类 AOP 要达到的效果是，保证开发者不修改源代码的前提下，去为系统中的业务组件添加某种通用功能。AOP 的本质是由 AOP 框架修改业务组件的多个方法的源代码，按照 AOP 框架修改源代码的时机，可以将其分为两类：
详解spring中aop不生效的几种解决办法
08-19
在Spring框架中，AOP（Aspect-Oriented Programming）是一种非常有用的技术，可以帮助开发者在不修改源代码的情况下实现一些公共功能的实现。但是在实际开发中，AOP不生效的问题经常会出现在开发者的面前。本文将...
spring中aop的xml配置方法实例详解
08-29
Spring中的AOP（面向切面编程）是一种编程范式，旨在将关注点分离，以便更好地管理系统的横切关注点，如日志、事务管理和权限控制等。AOP通过定义切面（Aspect）来封装这些关注点，使得核心业务逻辑与系统服务相互...
Spring 入门AOP材料
02-13
1. **导入依赖**：确保你的项目中已经引入了Spring AOP相关的依赖，例如`spring-aop`和`aspectjrt`。 2. **定义切面**：创建一个类，并使用`@Aspect`注解标记为切面。在这个类中，你可以定义切入点表达式和通知。 ...
spring-aop
03-17
Spring AOP，全称为Aspect...在`section6-AOP`这个压缩包中，可能包含了演示Spring AOP使用的代码示例，可以直接导入项目进行学习和实践。通过深入理解和运用这些示例，可以更好地掌握Spring AOP的核心概念和实际应用。
Spring源码(三) Spring IoC之BeanFactory创建bean和获取bean
一生编程，快乐编程
07-11 948
bean 对象主要放在 map 里面，map 作为缓存。map 的key 是 bean对象的名称， value 是 bean 对象或者对象工厂。代码详情见： https://blog.csdn.net/sinat_32502451/article/details/140155044。详情见： https://blog.csdn.net/sinat_32502451/article/details/140247662。根据 bean 名称，返回已经注册的单例对象，如果没有注册，则创建并注册一个新对象。
springmvc1
benpaodeDD的博客
07-14 117
以前的servlet程序：
springboot start.aliyun.com java8
最新发布
JavaUpgrade
07-15 37
springboot 2.3.12.RELEASE alibaba cloud RDS alibaba cloud Redis alibaba cloud oss alibaba cloud sms alibaba cloud schedulerX spring cloud alibaba
Spring常见的自定义和扩展的方法
Casual_Lei的博客
07-12 228
通过类和@Bean方法，自定义Bean的创建过程。@Bean使用Spring AOP（Aspect-Oriented Programming）自定义注解和拦截方法调用。通过实现接口，在Bean的初始化前后添加自定义逻辑。@Component@Override@Override通过实现接口，可以在Bean定义加载后但在Bean实例化前修改Bean定义。@Component@Override通过实现接口，监听Spring应用上下文事件。
spring中AOP
10-13
Spring中的AOP（面向切面编程）是一种编程范式，它允许开发人员在不改变原有代码的情况下，通过横向切割关注点（cross-cutting concerns）来实现对系统的增强。AOP的核心是切面（Aspect），切面定义了在哪些连接点...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值