Spring学习5——AOP

最新推荐文章于 2024-08-08 18:50:33 发布
最新推荐文章于 2024-08-08 18:50:33 发布
阅读量175 收藏 1
点赞数
分类专栏： Spring 文章标签： spring aop
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/doubleview/article/details/115872366
版权

文章目录

AOP

  • AOP(面向切面编程)是OOP（面向对象编程）的衍生和完善
  • AOP通过对业务逻辑的各个部分进行隔离，降低业务逻辑的耦合性，提高程序复用性和开发效率

案例：骑士执行任务前和执行任务后，游吟诗人唱赞歌

采用配置方式使用AOP

一、使用项目SpringDemo2021

链接：https://pan.baidu.com/s/1lsV9SniUIAZ-KN4IB9RUQA
提取码：j9vc

二、创建lesson05子包

在这里插入图片描述

三、创建杀龙任务类

![在这里插入图片描述](https://img-blog.csdnimg.cn/20210419193810541.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2RvdWJsZXZpZXc=,size_16,color_FFFFFF,t_70

package net.lj.spring.lesson05;

import org.springframework.stereotype.Component;

/**
 * 杀龙任务类
 */
@Component
public class SlayDragonQuest {
    public void embark() {
        System.out.println("执行杀龙任务");
    }
}

四、创建勇敢骑士类

在这里插入图片描述

package net.lj.spring.lesson05;

/**
 * 功能：勇敢骑士类
 */

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

@Component("Mike")
public class BraveKnight {
    @Autowired
    private SlayDragonQuest slayDragonQuest;

    public void embarkOnQuest() {
        slayDragonQuest.embark();
    }
}

五、创建游吟诗人类

在这里插入图片描述

package net.lj.spring.lesson05;

import org.springframework.stereotype.Component;

/**
 * 游吟诗人类
 */
@Component
public class Minstrel {
    public void singBeforeQuest() {
        System.out.println("啦啦啦，骑士出发了！");
    }

    public void singAfterQuest() {
        System.out.println("真棒啊！骑士完成了任务！");
    }
}

六、创建Spring配置文件

在这里插入图片描述

<?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">

    <!--组件扫描-->
    <context:component-scan base-package="net.lj.spring.lesson05"/>

    <!--AOP配置-->
    <aop:config>
        <!--定义切面-->
        <aop:aspect ref="minstrel">
            <!--定义切点-->
            <aop:pointcut id="embark" expression="execution(* net.lj.spring.lesson05..*.embarkOnQuest(..))"/>
            <!--声明前置通知-->
            <aop:before method="singBeforeQuest" pointcut-ref="embark"/>
            <!--声明后置通知-->
            <aop:after method="singAfterQuest" pointcut-ref="embark"/>
        </aop:aspect>
    </aop:config>
</beans>

七、在pom文件里添加AOP相关依赖

<!--Spring AOP-->                                         
<dependency>                                              
    <groupId>org.springframework</groupId>                
    <artifactId>spring-aop</artifactId>                   
    <version>${spring.version}</version>                  
</dependency>                                             
<!--AspectJ支持-->                                          
<dependency>                                              
    <groupId>aspectj</groupId>                            
    <artifactId>aspectjrt</artifactId>                    
    <version>1.5.4</version>                              
</dependency>                                             
<dependency>                                              
    <groupId>org.aspectj</groupId>                        
    <artifactId>aspectjweaver</artifactId>                
    <version>1.9.6</version>                              
    <scope>runtime</scope>                                
</dependency>

八、创建测试类

在这里插入图片描述

package net.lj.spring.lesson05;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * 测试骑士类
 */
public class TestKnight {

    private ClassPathXmlApplicationContext context; // 基于类路径XML配置文件的应用容器

    @Before
    public void init() {
        // 基于Spring配置文件创建应用容器
        context = new ClassPathXmlApplicationContext("aop_xml/spring-config.xml");
    }

    @Test
    public void testBraveKnight() {
        // 根据名称从应用容器中获取勇敢骑士对象
        BraveKnight braveKnight = (BraveKnight) context.getBean("Mike");
        // 勇敢骑士执行任务
        braveKnight.embarkOnQuest();
    }

    @After
    public void destroy() {
        // 关闭应用容器
        context.close();
    }
}

运行测试

在这里插入图片描述

采用注解方式使用AOP

一、创建子包

在这里插入图片描述

二、创建杀龙任务

在这里插入图片描述

package net.lj.spring.lesson0502;

import org.springframework.stereotype.Component;

/**
 * 功能：杀龙任务类
 */
@Component
public class SlayDragonQuest {
    public void embark() {
        System.out.println("执行杀龙任务。");
    }
}

三、创建勇敢骑士类

在这里插入图片描述

package net.lj.spring.lesson0502;

/**
 * 勇敢骑士类
 */

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

@Component("Mike")
public class BraveKnight {
    @Autowired
    private SlayDragonQuest slayDragonQuest;

    public void embarkOnQuest() {
        slayDragonQuest.embark();
    }
}

四、创建游吟诗人切面

在这里插入图片描述

package net.lj.spring.lesson0502;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

/**
 * 游吟诗人切面
 */
@Aspect // 声明为切面
@Component // 交给Spring容器管理
public class MinstrelAspect {
    // 注解声明切点
    @Pointcut("execution(* net.lj.spring.lesson05..*.embarkOnQuest(..))")
    public void embark() {
    }

    // 注解声明前置通知
    @Before("embark()")
    public void singBeforeQuest(JoinPoint joinPoint) {
        System.out.println("啦啦啦，骑士出发了！");
    }

    // 注解声明后置通知
    @After("embark()")
    public void singAfterQuest(JoinPoint joinPoint) {
        System.out.println("真棒啊！骑士完成了任务！");
    }
}

五、创建Spring配置类

在这里插入图片描述

package net.lj.spring.lesson0502;

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

/**
 * AOP配置类
 */
@Configuration // 标明Spring配置类
@ComponentScan("net.lj.spring.lesson0502") // 组件扫描
@EnableAspectJAutoProxy // 开启Spring对AspectJ的支持
public class AopConfig {
}

六、创建骑士测试类

在这里插入图片描述

package net.lj.spring.lesson0502;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

/**
 * 测试骑士类
 */
public class TestKnight {

    private AnnotationConfigApplicationContext context; // 基于注解配置类的应用容器

    @Before
    public void init() {
        // 基于注解配置类创建应用容器
        context = new AnnotationConfigApplicationContext(AopConfig.class);
    }

    @Test
    public void testBraveKnight() {
        // 根据名称从应用容器里获取勇敢骑士对象
        BraveKnight knight = (BraveKnight) context.getBean("Mike");
        // 勇敢骑士执行任务
        knight.embarkOnQuest();
    }

    @After
    public void destroy() {
        // 关闭应用容器
        context.close();
    }
}

七、运行测试

在这里插入图片描述

注解式拦截

  • 拦截器(Interceptor): 用于在某个方法被访问之前进行拦截，然后在方法执行之前或之后加入某些操作，其实就是AOP的一种实现策略。它通过动态拦截Action调用的对象，允许开发者定义在一个action执行的前后执行的代码，也可以在一个action执行前阻止其执行。同时也是提供了一种可以提取action中可重用的部分的方式。
  • 此处案例使用注解式拦截

一、创建注解接口

在这里插入图片描述

package net.lj.spring.lesson0502;

import java.lang.annotation.*;

/**
 * 动作注解接口
 */
@Target(ElementType.METHOD) // 拦截目标 - 方法
@Retention(RetentionPolicy.RUNTIME) // 保留策略 - 运行时
@Documented // 注解文档化
public @interface Action {
    String name();
}

二、修改勇敢骑士类

在这里插入图片描述

三、修改游吟诗人切面

在这里插入图片描述

package net.lj.spring.lesson0502;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;

/**
 * 功能：游吟诗人切面
 * 作者：华卫
 * 日期：2021年03月29日
 */
@Aspect // 声明为切面
@Component // 交给Spring容器管理
public class MinstrelAspect {
    // 注解声明切点
    @Pointcut("@annotation(net.lj.spring.lesson0502.Action)")
    public void embark() {
    }

    // 注解声明前置通知
    @Before("embark()")
    public void singBeforeQuest(JoinPoint joinPoint) {
        // 获取方法签名
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        // 获取被拦截的方法
        Method method = signature.getMethod();
        // 获取注解式拦截
        Action action = method.getAnnotation(Action.class);
        // 提示用户被拦截了
        System.out.println("[" + action.name() + "]拦截了[" + method.getName() + "]：拦截前！");
        System.out.println("啦啦啦，骑士出发了！");
    }

    // 注解声明后置通知
    @After("embark()")
    public void singAfterQuest(JoinPoint joinPoint) {
        // 获取方法签名
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        // 获取被拦截的方法
        Method method = signature.getMethod();
        // 获取注解式拦截
        Action action = method.getAnnotation(Action.class);
        // 提示用户被拦截了
        System.out.println("[" + action.name() + "]拦截了[" + method.getName() + "]：拦截后！");
        System.out.println("真棒啊！骑士完成了任务！");
    }
}

四、运行测试

在这里插入图片描述

doubleview
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring实战第一章AOP示例：游吟诗人和骑士
wang8978的博客
03-06 284
问题 运行报错： 警告: Exception encountered during context initialization - cancelling refresh attempt: org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'knight' defined...
Spring中AOP切入点表达式的写法
你今天真好看呀
10-27 2190
文章目录1.切入点表达式的写法1.1 全通配写法：* *..*.*(..)1.2 访问修饰符可以省略1.3 返回值可以使用通配符，表示任意返回值1.4 包名需要使用通配符，表示任意包，但是有几级包就需要写几个*1.5 包名可以使用..表示当前包及其子包1.6 类名和方法名都可以使用*来实现通配1.7 参数列表7.8 实际开发中切入点表达式的写法 1.切入点表达式的写法 通常情况下，我们会...
Spring AOP简介
weixin_49074309的博客
10-11 224
一AOP概述 1AOP的定义 AOP（Aspect Orient Programming）是一种设计思想，是软件设计领域中的面向切面编程，它是面向对象编程(OOP)的一种补充和完善。它以通过预编译方式和运行期动态代理方式，实现在不修改源代码的情况下给程序动态统一添加额外功能的一种技术。 2AOP的应用场景 实际项目中通常会将系统分为两大部分，一部分是核心业务，一部分是非核业务。在编程实现时我们首先要完成的是核心业务的实现，非核心业务一般是通过特定方式切入到系统中，这种特定方式一般就是借助AOP进行实现。 A
Spring框架学习笔记（五）(2021-3-24)
qq_46301426的博客
03-24 88
操作步骤一、采用配置方式使用AOP1.在net.lj.spring里创建lesson05.aop_xml子包2.在aop_xml创建杀龙任务类-SlayDragonQuest![在这里插入图片描述](https://img-blog.csdnimg.cn/20210324162457514.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2
springAop使用表达式排除一个包下的其中一个子包中的所有方法
喜羊羊love红太狼
09-28 2098
需求：使用aop记录日志，排除一个包下的其中一个子包中的所有方法 方法一：合并写如下 @Pointcut("execution(* com.gisquest.platform.modules.*.web.*.*(..)) && !execution(* com.gisquest.platform.modules.monitor..*.*(..))") 说明：monitor包是modules下的一个子包，里面是关于监控的一些信息，现在想将其排除掉 方法二：分开写如下...
Spring 入门案例——AOP
08-19
5. **自动代理（Auto Proxy）**：Spring AOP默认使用Java动态代理或CGLIB生成代理对象，以便在调用目标方法时插入通知。 案例中的"Spring_2_AOP"可能包含了以下内容： - 示例代码展示了如何定义一个切面，包括通知...
详解Spring学习总结——Spring实现AOP的多种方式
08-31
【Spring实现AOP的多种方式】 面向切面编程（AOP）是Spring框架的一个核心特性，它提供了一种模块化和解耦的方式来处理系统中的交叉关注点，如日志、事务管理等。本文将详细讲解Spring如何实现AOP，包括基于XML配置...
Spring——aop
12-23
**Spring AOP 知识详解** 在Java开发领域，Spring框架是不可或缺的一部分，它提供了许多强大的功能，其中AOP（面向切面编程）是其重要特性之一。AOP允许开发者将关注点分离，使得业务逻辑代码与系统服务如日志、...
SpringBoot学习笔记——AOP全局统一日志管理
12-21
【SpringBoot学习笔记——AOP全局统一日志管理】 在软件开发中，日志记录是一项至关重要的任务，它有助于追踪操作记录、系统监控以及满足审计需求。SpringBoot作为一个流行的Java微服务框架，提供了AOP（面向切面...
五、Spring源码分析——Spring Aop
08-11
《Spring AOP 源码分析》 在深入探讨Spring AOP之前，我们先要理解AOP（面向切面编程）的基本概念。AOP是一种编程范式，它将关注点分离，使得我们可以将横切关注点（如日志、事务管理、安全检查等）与业务逻辑解耦...
Spring框架学习笔记05
M_1725046289的博客
03-29 212
一、Spring AOP概述 1、AOP含义 AOP: Aspect-Oriented Programming （面向切面编程） 2、AOP作用 Spring的AOP作用在于解耦。AOP让一组类共享相同的行为（比如事务管理、日志管理、安全管理）。OOP（Object-Oriented Programming）只能通过继承类或实现接口来增加代码的耦合度，而且类继承是单根继承（不允许一子多父），阻碍了将更多的行为添加到一组类上，此时AOP可以弥补OOP的不足。 3、AOP与OOP AOP（Aspect-Orie
记一次SpringAOP实践过程-包扫描和嵌套注解
Java之旅
11-08 7292
这次SpringAOP实践过程，是对两个问题的解决或者说理解学习过程记录：包扫描和嵌套注解。 每一次实践得出结论，得出的对过往理论的印证，都是一次悟道，其收益远大于争论和抱怨。 技术是一件比较客观的事，正确与错误，其实就摆在哪里，意见不统一，写段代码试验一下就好了，一段代码印证不了的时候，就多写几段。
Spring包详解 AOP三种方式实现
changaspl
02-09 1071
Spring Spring是高度模块化的，可以单独使用Spring的某个库而不需要依赖Spring的其他库。比如，使用Spring Context库不需要依赖Spring Persistence或者Spring MVC库。 spring Maven依赖 依赖 介绍 依赖于 spring-core 这个jar文件包含Spring框架基本的核心工具类，Spring其它组件要都要使用到...
Spring——AOP基本概念的理解
★★光亭★★
03-10 9321
Spring——AOP基本概念的理解
spring aop 拦截某个包下的所有类方法
nixuezhe的博客
07-20 1万+
@Pointcut("execution(* com.xxx.service..*.*(..))")
白话Spring（基础篇）---AOP（execution表达式）
热门推荐
y-yg的博客
03-05 5万+
[一知半解，就是给自己挖坑] 作为AOP的最后一节内容，我们来简单总结一下切面表达式上见的书写方法。下面的那内容有参考其他博文，在此先对开源博客的各位大神表示感谢！ -------------------------------------------------------------------------------------------------------------------
Spring AOP 需要包含的各种包
大树叶 技术专栏
03-01 5765
如果你用 spring-framework-4.2.5.RELEASE-dist 去开发基于AOP的程序，除了要安装aspectJ1.7 ，然后包含aspectJ1.7 lib 下的包外，   额外还需要包含下面的包： com.springsource.com.mchange.v2.c3p0-0.9.1.2.jar cglib-2.2.2.jar com.springsourc
使用Spring与JDK动态代理实现事务管理
面团到油条的成长日记
08-08 1029
使用Spring与JDK动态代理实现事务管理，带你更加了解代理模式的应用
javaweb_04：SpringBoot
最新发布
qq_52200849的博客
08-08 365
1、概念：超文本传输协议，规定了浏览器与服务器之间数据传输的规则。2、特点：基于TCP协议，面向连接、安全；基于请求-响应模型，一次请求对应一次相应；HTTP协议是无状态的协议，对于事务处理没有记忆能力，每次请求响应都是独立的，多次请求间不能共享数据但是速度快。
Spring AOP——基于注解的AOP实现
05-18
Spring AOP是Spring框架中的一个重要模块，它提供了面向切面编程（AOP）的支持。AOP是一种编程思想，它可以在不改变原有代码的情况下，通过在程序运行时动态地将代码“织入”到现有代码中，从而实现对原有代码的增强...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值