SSM学习——Spring AOP与AspectJ

Spring AOP与AspectJ

概念

AOP的全称为Aspect-Oriented Programming，即面向切面编程。

想象你是汉堡店的厨师，每一份汉堡都有好几层，这每一层都可以视作一个切面。现在有一位顾客想要品尝到不同风味肉馅的汉堡，如果按照传统的方式，你需要做多个汉堡，每个汉堡只有肉馅是不一样的，但是你每做一个汉堡都要重新制作面包。而聪明的厨师只需做一个汉堡，仅将肉饼那一层分成不同口味的几个区域，这样你就不需要再重复制作面包了。

对于程序员也是一样的，有多少个接口就要写或复制多少代码那一定是无法忍受的，我们只想关心不同的那部分。

尽管想通俗来讲，但是还是要去熟悉专业的概念：

  • Aspect：切面，类似于Java类声明，里面会有Pointcut和Advice
  • Joint point：连接点，在程序执行过程中某个阶段点
  • Pointcut：切入点，切面与程序流的交叉点，往往此处需要处理
  • Advice：通知或增强，在切入点处所要执行的代码。可以理解为切面类中的方法。
  • Target object：目标对象，指所有被通知的对象。
  • Proxy：代理，将通知应用到目标对象后，被动态创建的对象。
  • Weaving：织入，将切面代码插到目标对象上，从而生成代理对象的过程。

别担心，我们之后会通过代码来慢慢理解。

AOP的实现

AOP的实现主要分为静态代理和动态代理，在本教程中静态代理我们用AspectJ，而动态代理用Spring AOP。

静态代理在编译期就确定了代理类，而动态代理需要靠反射机制动态生成代理类。

Spring AOP动态代理有两种实现方式：一种是JDK动态代理，这种方式需要接口；另一种是CGLib动态代理，这种方式不依赖接口。

有了以上的知识，我们开始写代码，首先新创建一个Maven项目top.cairbin.test2，如果你不会请回去看之前的章节。

然后在pom.xml的<dependencies></dependencies>之间添加依赖包

<!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.3.16</version>
</dependency>		
<!-- https://mvnrepository.com/artifact/cglib/cglib -->
<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>3.3.0</version>
</dependency>		
<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.4</version>
</dependency>

我们去实现一个IUser接口，要求接口内有两个方法void addUser()和void deleteUser()

package top.cairbin.test2;

public interface IUser {
	void addUser();
	void deleteUser();
}

接下来定义一个实现该接口的User类

package top.cairbin.test2;

public class User implements IUser{
	@Override
	public void addUser() {
		System.out.println("进行增加用户操作！");
	}
	
	@Override
	public void deleteUser() {
		System.out.println("进行删除用户操作!");
	}
}

我们定义一个切面类，该类中的两个方法void check()和void log()分别模拟权限检查和日志记录功能。

切面类如下所示

package top.cairbin.test2;

public class MyAspect {
	public void check() {
		System.out.println("正在模拟权限认证");
	}
	
	public void log() {
		System.out.println("正在模拟日志记录");
	}
}

JDK动态代理

接下来创建代理类JdkProxy，这个类实现了JDK动态代理的InvocationHandler接口，并实现代理方法。

package top.cairbin.test2;

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


public class JdkProxy implements InvocationHandler{
	private final IUser user;
	
	public JdkProxy(IUser user) {
		this.user = user;
	}
	
	public static Object createProxy(IUser user) {
		ClassLoader classLoader = JdkProxy.class.getClassLoader();
		// 被代理对象实现的所有接口
		Class[] clazz = user.getClass().getInterfaces();
		// 使用代理类，进行增强，返回的是代理后的对象
		return  Proxy.newProxyInstance(classLoader,clazz,new JdkProxy(user));
	}
	
	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		// 声明切面
		MyAspect myAspect = new MyAspect();
		// 前增强
		myAspect.check();
		// 在目标类上调用方法，并传入参数
		Object obj = method.invoke(user, args);
		// 后增强
		myAspect.log();
		
		return obj;
	}

}

然后尝试在App.java的main方法中使用它们

package top.cairbin.test2;

public class App 
{
    public static void main( String[] args )
    {
    	// 创建目标对象
    	IUser user= new User();
    	// 创建代理，并从代理中获取增强后的目标对象
    	IUser user2 = (IUser)JdkProxy.createProxy(user);
		// 执行方法
		user2.addUser();
		user2.deleteUser();

    }
}

输出结果如下图所示

CGLib动态代理

我们不妨尝试使用CGLib来玩一下

创建一个新的类，名称为CglibProxy，并实现接口MethodInterceptor以及相应的方法

package top.cairbin.test2;

import java.lang.reflect.Method;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

public class CglibProxy implements MethodInterceptor {
     public static Object createProxy(Object target){
        Enhancer enhancer = new Enhancer();  
        enhancer.setSuperclass(target.getClass());  
        enhancer.setCallback(new CglibProxy()); 
	    return enhancer.create();
 }
	@Override
	public Object intercept(Object obj, Method method, 	Object[] args, MethodProxy proxy) throws Throwable {
		// 声明切面
		MyAspect myAspect = new MyAspect();
		// 前增强
		myAspect.check();
		//获取增强后的目标对象
		Object target = proxy.invokeSuper(obj, args);
		// 后增强
		myAspect.log();
		return target;
	}
}

尝试调用下

package top.cairbin.test2;

public class App 
{
    public static void main( String[] args )
    {
		IUser user = (IUser)CglibProxy.createProxy (new User());
		user.addUser();
		user.deleteUser();
    }
}

不出所料，果然成功了

我们仔细观察CGLib的这几段代码，在CglibProxy类中我们并没有用到IUser这个接口，而是返回Object，然后外面也就是调用者那里强制转换为IUser类型！

不妨再“懒”一些，我们借助Spring的依赖注入，从Spring的容器中直接返回增强后的实现了IUser接口的对象试一试。

首先在resources/AppCtx.xml中编写Bean的配置（这里有坑，如果行不通回前面的文章看看）

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
	http://www.springframework.org/schema/beans/spring-beans-4.3.xsd">
	<!-- 目标类 -->
	<bean id="user" class="top.cairbin.test2.User" />
	<!-- 切面类 -->
	<bean id="myAspect" class="top.cairbin.test2.MyAspect" />
	<!-- 使用Spring代理工厂定义一个名称为userProxy的代理对象 -->
	<bean id="userProxy" 
            class="org.springframework.aop.framework.ProxyFactoryBean">
		<!-- 指定代理实现的接口-->
		<property name="proxyInterfaces" 
                      value="top.cairbin.test2.IUser" />
		<!-- 指定目标对象 -->
		<property name="target" ref="user" />
		<!-- 指定切面,织入环绕通知 -->
		<property name="interceptorNames" value="myAspect" />
		<!-- 指定代理方式，true：使用cglib，false(默认)：使用jdk动态代理 -->
		<property name="proxyTargetClass" value="true" />
	</bean>
</beans>

修改下MyAspect类，并实现接口MethodInterceptor

package top.cairbin.test2;
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;

public class MyAspect implements MethodInterceptor {
	@Override
	public Object invoke(MethodInvocation mi) throws Throwable {
		this.check();
		// 执行目标方法
		Object obj = mi.proceed();
		this.log();
		return obj;
	}

	public void check() {
		System.out.println("正在模拟权限认证");
	}
	
	public void log() {
		System.out.println("正在模拟日志记录");
	}
}

App类中的main方法调用如下

package top.cairbin.test2;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class App 
{
    public static void main( String[] args )
    {
    	ApplicationContext app = new ClassPathXmlApplicationContext("AppCtx.xml");
    	IUser user = (IUser)app.getBean("userProxy");
    	user.addUser();
    	user.deleteUser();
    }
}

点击运行得到结果

AspectJ静态代理

使用AspectJ静态代理，我们重新设计下MyAspect切面类

package top.cairbin.test2;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
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;
/**
 * 切面类，在此类中编写通知
 */
@Aspect
@Component
public class MyAspect {
	// 定义切入点表达式
	@Pointcut("execution(* top.cairbin.test2.*.*(..))")
	// 使用一个返回值为void、方法体为空的方法来命名切入点
	private void myPointCut(){}
	// 前置通知
	@Before("myPointCut()")
	public void myBefore(JoinPoint joinPoint) {
		System.out.print("前置通知 ：模拟执行权限检查...,");
		System.out.print("目标类是："+joinPoint.getTarget() );
		System.out.println(",被织入增强处理的目标方法为："
		               +joinPoint.getSignature().getName());
	}
	// 后置通知
	@AfterReturning(value="myPointCut()")
	public void myAfterReturning(JoinPoint joinPoint) {
		System.out.print("后置通知：模拟记录日志...," );
		System.out.println("被织入增强处理的目标方法为："
		              + joinPoint.getSignature().getName());
	}
	// 环绕通知	
	@Around("myPointCut()")
	public Object myAround(ProceedingJoinPoint proceedingJoinPoint) 
            throws Throwable {
		// 开始
		System.out.println("环绕开始：执行目标方法之前，模拟开启事务...");
		// 执行当前目标方法
		Object obj = proceedingJoinPoint.proceed();
		// 结束
		System.out.println("环绕结束：执行目标方法之后，模拟关闭事务...");
		return obj;
	}
	// 异常通知
	@AfterThrowing(value="myPointCut()",throwing="e")
	public void myAfterThrowing(JoinPoint joinPoint, Throwable e) {
		System.out.println("异常通知：" + "出错了" + e.getMessage());
	}
	// 最终通知
	@After("myPointCut()")
	public void myAfter() {
		System.out.println("最终通知：模拟方法结束后的释放资源...");
	}
}

对于切入点注解@Pointcut("execution(* top.cairbin.test2.*.*(..))")表示对top.cairbin.test2这个包下的所有类的所有方法生效。

我们再来看看Spring中的Advice的几种类型：

  • org.springframework.aop.MethodBeforeAdvice，前置通知，目标方法执行前实施，可用于权限管理。
  • org.springframework.aop.AfterReturningAdvice，后置通知，在目标方法执行后实施，用于关闭文件流、上传文件、删除临时文件等。
  • org.aopalliance.intercept.MethodInterceptor，环绕通知，在目标方法实施前后，一般用于日志或事务管理。
  • org.springframework.aop.ThrowsAdvice，异常抛出通知，在抛出异常后实施。
  • org.springframework.aop.IntroductionInterceptor，引介通知，在目标类中添加新方法和属性，可以应用于修改老版本程序。

我们还要实现自动扫描和依赖注入，看看我们的User类

package top.cairbin.test2;
import org.springframework.stereotype.Component;

@Component
public class User implements IUser{
	@Override
	public void addUser() {
		System.out.println("进行增加用户操作！");
	}
	
	@Override
	public void deleteUser() {
		System.out.println("进行删除用户操作!");
	}
}

自然也少不了AppCtx.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:aop="http://www.springframework.org/schema/aop"
  xmlns:context="http://www.springframework.org/schema/context"
  xsi:schemaLocation="http://www.springframework.org/schema/beans 
  http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
  http://www.springframework.org/schema/aop 
  http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
  http://www.springframework.org/schema/context 
  http://www.springframework.org/schema/context/spring-context-4.3.xsd">
      <!-- 指定需要扫描的包，使注解生效 -->
      <context:component-scan base-package="top.cairbin.test2" />
      <!-- 启动基于注解的声明式AspectJ支持 -->
      <aop:aspectj-autoproxy />
</beans>

在main方法中测试下，为了清楚，我这里仅调用了addUser一个方法

package top.cairbin.test2;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class App 
{
    public static void main( String[] args )
    {
    	ApplicationContext app = new ClassPathXmlApplicationContext("AppCtx.xml");
    	IUser user = (IUser)app.getBean("user");
    	user.addUser();
    }
}

我们发现当环绕通知与前置通知和后置通知同时使用的时候，优先级如下：

  • 环绕通知开始
  • 前置通知
  • 方法执行
  • 后置通知
  • 环绕通知结束

想必到了这里，你对AspectJ的使用有了一定的了解，但是对于相应的注解还是不太清楚，请仔细阅读下方图片中的表格，结合一开始的术语体会下：

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/509874.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

数据结构:非比较排序

数据结构:非比较排序

非比较排序都具有很大的局限性,包括技术排序,基数排序,桶排序等 计数排序 时间复杂度:O(N) 空间复杂度:O(range) 适用范围 数据的范围集中的数组进行排序,不适合数据分散的数组 方法 统计每个数据出现的次数为n 建立一个相同大小的数组,将每个数据都初始化为0 然后遍历…
阅读更多...
链表优化与拓展的细节：深度探索与精致打磨

链表优化与拓展的细节：深度探索与精致打磨

前言 链表&#xff0c;作为C语言中的基础数据结构&#xff0c;其灵活性和动态性使其在编程领域具有广泛的应用。然而&#xff0c;仅仅掌握链表的基本操作是远远不够的&#xff0c;为了更好地发挥链表的性能并满足复杂场景的需求&#xff0c;我们需要对链表进行深入的优化和拓展…
阅读更多...
泛域名站群,泛域名程序

泛域名站群,泛域名程序

泛域名站群是一种利用大量类似的泛域名来建立多个网站&#xff0c;并通过这些网站链接到主网站&#xff0c;以提升主网站的排名和流量的策略。泛域名站群通常包含大量的子域名&#xff0c;这些子域名指向不同的页面&#xff0c;但它们的内容大部分是重复或相似的&#xff0c;目…
阅读更多...
【蓝桥杯第十二届省赛B】（部分详解）

【蓝桥杯第十二届省赛B】（部分详解）

空间 8位1b 1kb1024b(2^10) 1mb1024kb(2^20) 时间显示 #include <iostream> using LLlong long; using namespace std; int main() {LL t;cin>>t;int HH,MM,SS;t/1000;SSt%60;//like370000ms370s,最后360转成分余下10st/60;MMt%60;t/60;HHt%24;printf("%02d:…
阅读更多...
【Servlet】服务器内部转发以及客户端重定向

【Servlet】服务器内部转发以及客户端重定向

文章目录 一、服务器内部转发&#xff1a;request.getRequestDispatcher("...").forward(request, response);二、客户端重定向&#xff1a;response.sendRedirect("");三、服务器内部转发代码示例四、客户端重定向代码示例 一、服务器内部转发&#xff1a…
阅读更多...
升级一下电脑，CPU换I5-14600K，主板换华硕B760M

升级一下电脑，CPU换I5-14600K，主板换华硕B760M

刚给自己电脑升级了一下&#xff0c;CPU从 AMD R5 5600X 换成 Intel I5-14600K&#xff0c;主板换成了华硕的 TUF GAMING B760M-PLUS WIFI D4。 因为我现有的两根内存是DDR4的&#xff0c;所有我选了个支持DDR4内存的主板。 我发现用AMD处理器时将系统从Win10升级到Win11后变…
阅读更多...
汤明磊对话许远东:“产业互联网的2024”： 赚钱治愈一切矫情，学习治愈一切焦虑！

汤明磊对话许远东:“产业互联网的2024”： 赚钱治愈一切矫情，学习治愈一切焦虑！

3月22-23日&#xff0c;托比网南京公司开业活动举行&#xff0c;在“产业互联网的2024”主题沙龙上&#xff1a;二十二科技集团总裁许远东针对行业2024在人工智能与数据资产领域的发展了精彩观点。 以下为对话实录&#xff1a; 桐创资本合伙人汤明磊 二十二科技集团总裁许远东…
阅读更多...
机器学习实验------线性回归方法

机器学习实验------线性回归方法

第1关&#xff1a;数据载入与分析 任务描述 本关任务&#xff1a;编写一个能够载入线性回归相关数据的小程序。 编程要求 该实战内容中数据为一元数据&#xff0c;利用 pandas 读入数据文件&#xff0c;并为相应的数据附上名字标签&#xff0c;分别为Population 和 Profit。…
阅读更多...
⾃定义类型：联合和枚举

⾃定义类型：联合和枚举

乐观学习&#xff0c;乐观生活&#xff0c;才能不断前进啊&#xff01;&#xff01;&#xff01; 我的主页&#xff1a;optimistic_chen 我的专栏&#xff1a;c语言 点击主页&#xff1a;optimistic_chen和专栏&#xff1a;c语言&#xff0c; 创作不易&#xff0c;大佬们点赞鼓…
阅读更多...
记忆力考验游戏-第15届蓝桥第5次STEMA测评Scratch真题精选

记忆力考验游戏-第15届蓝桥第5次STEMA测评Scratch真题精选

[导读]&#xff1a;超平老师的《Scratch蓝桥杯真题解析100讲》已经全部完成&#xff0c;后续会不定期解读蓝桥杯真题&#xff0c;这是Scratch蓝桥杯真题解析第178讲。 如果想持续关注Scratch蓝桥真题解读&#xff0c;可以点击《Scratch蓝桥杯历年真题》并订阅合集&#xff0c;…
阅读更多...
monocular depth estimation 网络的 regression loss 选择

monocular depth estimation 网络的 regression loss 选择

直接上图&#xff1a; 上述这么多loss&#xff0c;测评结果如下&#xff1a; 结论: L g a n L_{gan} Lgan​ 是效果最好的。 其具体实现见&#xff1a;https://github.com/marcelampc/d3net_depth_estimation/blob/master/pytorch/util/loss_bank.py github&#xff1a;htt…
阅读更多...
【THM】Burp Suite：Other Modules（其他模块）-初级渗透测试

【THM】Burp Suite：Other Modules（其他模块）-初级渗透测试

介绍 除了广泛认可的Repeater和Intruder房间之外，Burp Suite 还包含几个鲜为人知的模块。这些将成为这个房间探索的重点。 重点将放在解码器、比较器、排序器和组织器工具上。它们促进了编码文本的操作，支持数据集的比较，允许分析捕获的令牌内的随机性，并帮助您存储和注释…
阅读更多...
【区块链 链外交易】SoK Off The Chain Transactions

【区块链 链外交易】SoK Off The Chain Transactions

SoK Off The Chain Transactions 摘要 本文对区块链进行了简单介绍，分析目前区块链的缺点——交易吞吐量和速度慢的原因，在此基础上引出解决此问题的方法，也是本轮将要论述的主题——链外交易。之后介绍了链外交易的基本概念和结构，并对两种类型的链外交易：通道和信任链…
阅读更多...
Windows 11 安装tensorflow-gpu深度学习环境

Windows 11 安装tensorflow-gpu深度学习环境

前言 TensorFlow 是一个由 Google 建立的深度学习库&#xff0c;自从去年年初推出以来&#xff0c;它已经获得了很大的吸引力。主要功能包括自动微分、卷积神经网络(CNN)和回归神经网络(RNN)。它是用 C 和 Python 编写的&#xff0c;为了提高性能&#xff0c;它使用了一个名…
阅读更多...
Linux环境基础和工具的使用

Linux环境基础和工具的使用

目录 1、Linux软件包管理器---yum 2、Linux开发工具 2.1、vim基本概念 2.2 vim基本操作 2.3 vim正常模式命令集 2.4 vim末行模式命令集 2.5 简单vim配置 2.5.1 配置文件的位置 3 Linux编译器--gcc/g的使用 3.1 背景知识 3.2 gcc完成 4 Linux调试器--gdb使用 4.1 背…
阅读更多...
每日面经分享（pytest测试案例，接口断言，多并发断言）

每日面经分享（pytest测试案例，接口断言，多并发断言）

pytest对用户登录接口进行自动化脚本设计 a. 创建一个名为"test_login.py"的测试文件&#xff0c;编写以下测试脚本 import pytest import requests# 测试用例1&#xff1a;验证登录成功的情况 # 第一个测试用例验证登录成功的情况&#xff0c;发送有效的用户名和密…
阅读更多...
【Linux】ubuntu安装google gtest框架

【Linux】ubuntu安装google gtest框架

本文首发于 ❄️慕雪的寒舍 ubuntu 22.04.03 LTS 安装 google gtest 框架 1.依赖项 首先在ubuntu中安装如下包 sudo apt install -y unzip g gcc cmake make automake2.下载软件包 进入google gtest的github页面&#xff0c;下载源码包 Releases google/googletest https…
阅读更多...
云数据中心传输的出路

云数据中心传输的出路

研发端到端协议不是出路&#xff0c;研发更智能调度流量的交换机不是出路&#xff0c;将流量按长短突发模式分流到不同链路(逻辑的或物理的)才是出路。所有高速传输的前提是标准化&#xff0c;统一简单的操作。多么简单的领悟。 数据中心网络具有范围小&#xff0c;带宽大&…
阅读更多...
C语言 输入输出语句讲解 标识符概念讲解

C语言 输入输出语句讲解 标识符概念讲解

上文 C语言 预处理器 注释 基本案例讲解 我们讲了一些 预处理器等逻辑 那么 本文继续 C语言由一个或多个函数组成&#xff0c;每个程序都必须有一个main() 函数 因为每个程序总是从这个函数开始执行 main() 函数可以返回一个值&#xff0c;返回值为0表示程序正常结束 如果有多…
阅读更多...
38.基于SSM实现的传统文化网站系统（项目 + 论文）

38.基于SSM实现的传统文化网站系统（项目 + 论文）

项目介绍 随着信息技术在管理上越来越深入而广泛的应用&#xff0c;作为一个一般的企业都开始注重与自己的信息展示平台&#xff0c;实现传统文化网站在技术上已成熟。本文介绍了传统文化网站的开发全过程。通过分析传统文化的需求&#xff0c;创建了一个计算机管理传统文化网站…
阅读更多...
最新文章

Copyright @ 2022~2023