Spring AOP源码：配置文件解析过程

news2025/1/11 8:43:51

前言

本篇文章主要讲解AOP配置中的几个通知类的解析过程，为后续对目标类进行代理做准备；在前面的Spring IOC篇我们讲解了自定义配置的解析，AOP配置的解析过程也是其自定义注解的过程，如果不熟悉自定义解析过程可以看之前的文章Spring IOC源码：＜context:component-scan＞源码详解

正文

先看下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: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/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd">

		<bean id="accountAdvice" class="service.impl.AccountAdvice" ></bean>
		<bean id="myAccount" class="service.impl.MyAccount" ></bean>

		<aop:config>
			<aop:pointcut id="pointCut" expression="execution(* service.impl.*.*())"/>
			<aop:aspect ref="accountAdvice">
				<aop:after method="after" pointcut-ref="pointCut"></aop:after>
				<aop:before method="before" pointcut-ref="pointCut"></aop:before>
				<aop:around method="around" pointcut-ref="pointCut"></aop:around>
				<aop:after-returning method="afterReturn" pointcut-ref="pointCut"></aop:after-returning>
				<aop:after-throwing method="afterThrow" pointcut-ref="pointCut"></aop:after-throwing>
			</aop:aspect>

		</aop:config>


</beans>

回到BeanDefinition的解析步骤中，由于AOP是属于自定义解析，所以会使用自定义命名空间处理器进行处理，也就是会走delegate.parseCustomElement(ele)方法。

	protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
		if (delegate.isDefaultNamespace(root)) {
			NodeList nl = root.getChildNodes();
			for (int i = 0; i < nl.getLength(); i++) {
				Node node = nl.item(i);
				if (node instanceof Element) {
					Element ele = (Element) node;
					if (delegate.isDefaultNamespace(ele)) {
						parseDefaultElement(ele, delegate);
					}
					else {
						delegate.parseCustomElement(ele);
					}
				}
			}
		}
		else {
			delegate.parseCustomElement(root);
		}
	}

	public BeanDefinition parseCustomElement(Element ele) {
		return parseCustomElement(ele, null);
	}



	/**
	 * Parse a custom element (outside of the default namespace).
	 * @param ele the element to parse
	 * @param containingBd the containing bean definition (if any)
	 * @return the resulting bean definition
	 */
	@Nullable
	public BeanDefinition parseCustomElement(Element ele, @Nullable BeanDefinition containingBd) {
		String namespaceUri = getNamespaceURI(ele);
		if (namespaceUri == null) {
			return null;
		}
		//获取自定义命名空间处理器
		NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
		if (handler == null) {
			error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", ele);
			return null;
		}
		return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
	}

handler.parse(ele, new ParserContext(this.readerContext, this, containingBd))，见方法1详解

方法1：parse

	public BeanDefinition parse(Element element, ParserContext parserContext) {
		BeanDefinitionParser parser = findParserForElement(element, parserContext);
		return (parser != null ? parser.parse(element, parserContext) : null);
	}

public BeanDefinition parse(Element element, ParserContext parserContext) {
		CompositeComponentDefinition compositeDef =
				new CompositeComponentDefinition(element.getTagName(), parserContext.extractSource(element));
		parserContext.pushContainingComponent(compositeDef);
		//注册AspectJAwareAdvisorAutoProxyCreator到beanFactory工厂中
		configureAutoProxyCreator(parserContext, element);

		List<Element> childElts = DomUtils.getChildElements(element);
		for (Element elt: childElts) {
			String localName = parserContext.getDelegate().getLocalName(elt);
			//解析POINTCUT配置标签，<aop:pointcut>
			if (POINTCUT.equals(localName)) {
				parsePointcut(elt, parserContext);
			}
			//解析<aop:advisor>标签
			else if (ADVISOR.equals(localName)) {
				parseAdvisor(elt, parserContext);
			}
			//解析<aop:aspect>标签
			else if (ASPECT.equals(localName)) {
				parseAspect(elt, parserContext);
			}
		}

		parserContext.popAndRegisterContainingComponent();
		return null;
	}

parsePointcut(elt, parserContext)，见方法2详解

parseAspect(elt, parserContext)，见方法4详解

方法2：parsePointcut

private AbstractBeanDefinition parsePointcut(Element pointcutElement, ParserContext parserContext) {
		//获取id属性值
		String id = pointcutElement.getAttribute(ID);
		//获取expression表达式值
		String expression = pointcutElement.getAttribute(EXPRESSION);

		AbstractBeanDefinition pointcutDefinition = null;

		try {
			this.parseState.push(new PointcutEntry(id));
			//将表达式内容封装成RootBeanDefinition对象
			pointcutDefinition = createPointcutDefinition(expression);
			pointcutDefinition.setSource(parserContext.extractSource(pointcutElement));

			String pointcutBeanName = id;
			if (StringUtils.hasText(pointcutBeanName)) {
				//如果有设置id名称，则将其作为beanName并将definition注册到beanFactory工厂中
				parserContext.getRegistry().registerBeanDefinition(pointcutBeanName, pointcutDefinition);
			}
			else {
				//没有名称则生成并注册到beanFactory工厂中
				pointcutBeanName = parserContext.getReaderContext().registerWithGeneratedName(pointcutDefinition);
			}
			//注册组件到上下文中
			parserContext.registerComponent(
					new PointcutComponentDefinition(pointcutBeanName, pointcutDefinition, expression));
		}
		finally {
			this.parseState.pop();
		}

		return pointcutDefinition;
	}

createPointcutDefinition(expression)，见方法3详解

方法3：createPointcutDefinition

	protected AbstractBeanDefinition createPointcutDefinition(String expression) {
		//设置封装类型为AspectJExpressionPointcut的RootBeanDefinition
		RootBeanDefinition beanDefinition = new RootBeanDefinition(AspectJExpressionPointcut.class);
		//设置为原型模式
		beanDefinition.setScope(BeanDefinition.SCOPE_PROTOTYPE);
		beanDefinition.setSynthetic(true);
		//添加属性值
		beanDefinition.getPropertyValues().add(EXPRESSION, expression);
		return beanDefinition;
	}

方法4：parseAspect

private void parseAspect(Element aspectElement, ParserContext parserContext) {
		//获取id值
		String aspectId = aspectElement.getAttribute(ID);
		//获取引用的切面类名称
		String aspectName = aspectElement.getAttribute(REF);

		try {
			this.parseState.push(new AspectEntry(aspectId, aspectName));
			//存放解析的BeanDefinition
			List<BeanDefinition> beanDefinitions = new ArrayList<>();
			List<BeanReference> beanReferences = new ArrayList<>();
			//获取declare-parents标签
			List<Element> declareParents = DomUtils.getChildElementsByTagName(aspectElement, DECLARE_PARENTS);
			//遍历解析封装成BeanDefinition
			for (int i = METHOD_INDEX; i < declareParents.size(); i++) {
				Element declareParentsElement = declareParents.get(i);
				beanDefinitions.add(parseDeclareParents(declareParentsElement, parserContext));
			}

			// We have to parse "advice" and all the advice kinds in one loop, to get the
			// ordering semantics right.
			NodeList nodeList = aspectElement.getChildNodes();
			boolean adviceFoundAlready = false;
			for (int i = 0; i < nodeList.getLength(); i++) {
				Node node = nodeList.item(i);
				//判断是否是通知配置标签，如<aop:after>、<aop:before> 等
				if (isAdviceNode(node, parserContext)) {
					if (!adviceFoundAlready) {
						adviceFoundAlready = true;
						if (!StringUtils.hasText(aspectName)) {
							parserContext.getReaderContext().error(
									"<aspect> tag needs aspect bean reference via 'ref' attribute when declaring advices.",
									aspectElement, this.parseState.snapshot());
							return;
						}
						//封装切面类为RuntimeBeanReference，并添加到集合中
						beanReferences.add(new RuntimeBeanReference(aspectName));
					}
					//解析当前通知标签
					AbstractBeanDefinition advisorDefinition = parseAdvice(
							aspectName, i, aspectElement, (Element) node, parserContext, beanDefinitions, beanReferences);
					beanDefinitions.add(advisorDefinition);
				}
			}

			AspectComponentDefinition aspectComponentDefinition = createAspectComponentDefinition(
					aspectElement, aspectId, beanDefinitions, beanReferences, parserContext);
			parserContext.pushContainingComponent(aspectComponentDefinition);
			//获取aspect标签下的pointcut子标签
			List<Element> pointcuts = DomUtils.getChildElementsByTagName(aspectElement, POINTCUT);
			//解析并注册到beanFactory中
			for (Element pointcutElement : pointcuts) {
				parsePointcut(pointcutElement, parserContext);
			}

			parserContext.popAndRegisterContainingComponent();
		}
		finally {
			this.parseState.pop();
		}
	}

isAdviceNode(node, parserContext)，见方法5详解
parseAdvice(aspectName, i, aspectElement, (Element) node, parserContext, beanDefinitions, beanReferences)，见方法6详解

方法5：isAdviceNode

private boolean isAdviceNode(Node aNode, ParserContext parserContext) {
		if (!(aNode instanceof Element)) {
			return false;
		}
		else {
			//获取节点名称
			String name = parserContext.getDelegate().getLocalName(aNode);
			//判断是否是befor、after、after-returning、after-throwing、around
			return (BEFORE.equals(name) || AFTER.equals(name) || AFTER_RETURNING_ELEMENT.equals(name) ||
					AFTER_THROWING_ELEMENT.equals(name) || AROUND.equals(name));
		}
	}

方法6：parseAdvice

private AbstractBeanDefinition parseAdvice(
			String aspectName, int order, Element aspectElement, Element adviceElement, ParserContext parserContext,
			List<BeanDefinition> beanDefinitions, List<BeanReference> beanReferences) {

		try {
			this.parseState.push(new AdviceEntry(parserContext.getDelegate().getLocalName(adviceElement)));

			// create the method factory bean
			//创建MethodLocatingFactoryBean的RootBeanDefinition 
			RootBeanDefinition methodDefinition = new RootBeanDefinition(MethodLocatingFactoryBean.class);
			//设置切面名称
			methodDefinition.getPropertyValues().add("targetBeanName", aspectName);
			//设置method方法名称
			methodDefinition.getPropertyValues().add("methodName", adviceElement.getAttribute("method"));
			//标志为合成的
			methodDefinition.setSynthetic(true);

			// create instance factory definition
			//创建SimpleBeanFactoryAwareAspectInstanceFactory类型的RootBeanDefinition 
			RootBeanDefinition aspectFactoryDef =
					new RootBeanDefinition(SimpleBeanFactoryAwareAspectInstanceFactory.class);
			aspectFactoryDef.getPropertyValues().add("aspectBeanName", aspectName);
			aspectFactoryDef.setSynthetic(true);

			// register the pointcut
			//封装成完整的通知类BeanDefinition
			AbstractBeanDefinition adviceDef = createAdviceDefinition(
					adviceElement, parserContext, aspectName, order, methodDefinition, aspectFactoryDef,
					beanDefinitions, beanReferences);

			// configure the advisor
			//将advice再加层封装成advisor
			RootBeanDefinition advisorDefinition = new RootBeanDefinition(AspectJPointcutAdvisor.class);
			advisorDefinition.setSource(parserContext.extractSource(adviceElement));
			advisorDefinition.getConstructorArgumentValues().addGenericArgumentValue(adviceDef);
			//判断是否有order属性，有则添加到定义信息中
			if (aspectElement.hasAttribute(ORDER_PROPERTY)) {
				advisorDefinition.getPropertyValues().add(
						ORDER_PROPERTY, aspectElement.getAttribute(ORDER_PROPERTY));
			}

			// register the final advisor
			//生成beanName并注册到beanFactory中 
			parserContext.getReaderContext().registerWithGeneratedName(advisorDefinition);

			return advisorDefinition;
		}
		finally {
			this.parseState.pop();
		}
	}

createAdviceDefinition(adviceElement, parserContext, aspectName, order, methodDefinition, aspectFactoryDef,beanDefinitions, beanReferences)，见方法7详解

方法7：createAdviceDefinition

private AbstractBeanDefinition createAdviceDefinition(
			Element adviceElement, ParserContext parserContext, String aspectName, int order,
			RootBeanDefinition methodDef, RootBeanDefinition aspectFactoryDef,
			List<BeanDefinition> beanDefinitions, List<BeanReference> beanReferences) {
		//获取对应类型的消息通知类并封装成RootBeanDefinition 
		RootBeanDefinition adviceDefinition = new RootBeanDefinition(getAdviceClass(adviceElement, parserContext));
		adviceDefinition.setSource(parserContext.extractSource(adviceElement));
		//添加切面名称
		adviceDefinition.getPropertyValues().add(ASPECT_NAME_PROPERTY, aspectName);
		//添加declarationOrder值
		adviceDefinition.getPropertyValues().add(DECLARATION_ORDER_PROPERTY, order);
		//添加returning属性值
		if (adviceElement.hasAttribute(RETURNING)) {
			adviceDefinition.getPropertyValues().add(
					RETURNING_PROPERTY, adviceElement.getAttribute(RETURNING));
		}
		//添加throwing属性值
		if (adviceElement.hasAttribute(THROWING)) {
			adviceDefinition.getPropertyValues().add(
					THROWING_PROPERTY, adviceElement.getAttribute(THROWING));
		}
		//添加arg-names属性值
		if (adviceElement.hasAttribute(ARG_NAMES)) {
			adviceDefinition.getPropertyValues().add(
					ARG_NAMES_PROPERTY, adviceElement.getAttribute(ARG_NAMES));
		}
		//获取构造函数
		ConstructorArgumentValues cav = adviceDefinition.getConstructorArgumentValues();
		//添加第一个参数为方法对象
		cav.addIndexedArgumentValue(METHOD_INDEX, methodDef);
		//解析其表达式
		Object pointcut = parsePointcutProperty(adviceElement, parserContext);
		//将表达式添加到构造函数中的第二位
		if (pointcut instanceof BeanDefinition) {
			cav.addIndexedArgumentValue(POINTCUT_INDEX, pointcut);
			beanDefinitions.add((BeanDefinition) pointcut);
		}
		else if (pointcut instanceof String) {
			RuntimeBeanReference pointcutRef = new RuntimeBeanReference((String) pointcut);
			cav.addIndexedArgumentValue(POINTCUT_INDEX, pointcutRef);
			beanReferences.add(pointcutRef);
		}
		//将切面工厂实例作为构造函数的第三个参数
		cav.addIndexedArgumentValue(ASPECT_INSTANCE_FACTORY_INDEX, aspectFactoryDef);

		return adviceDefinition;
	}

getAdviceClass(adviceElement, parserContext)，见方法8详解

方法8：getAdviceClass

	private Class<?> getAdviceClass(Element adviceElement, ParserContext parserContext) {
		//获取当前元素对应的通知名称
		String elementName = parserContext.getDelegate().getLocalName(adviceElement);
		//根据不同的名称，匹配不同的消息通知类型
		if (BEFORE.equals(elementName)) {
			return AspectJMethodBeforeAdvice.class;
		}
		else if (AFTER.equals(elementName)) {
			return AspectJAfterAdvice.class;
		}
		else if (AFTER_RETURNING_ELEMENT.equals(elementName)) {
			return AspectJAfterReturningAdvice.class;
		}
		else if (AFTER_THROWING_ELEMENT.equals(elementName)) {
			return AspectJAfterThrowingAdvice.class;
		}
		else if (AROUND.equals(elementName)) {
			return AspectJAroundAdvice.class;
		}
		else {
			throw new IllegalArgumentException("Unknown advice kind [" + elementName + "].");
		}
	}

到这里对AOP配置的解析就完成了，我们可以看到解析后的5个通知对象如下：
在这里插入图片描述

总结

AOP自定命名空间解析会往beanFactory工厂中注册AspectJAwareAdvisorAutoProxyCreator类型的beanDefinition，对于aspect标签的解析中，会将< aop:after >等元素解析成advisor对象的beanDefition，为后续AOP代理增强做准备。

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

CVPR2017|Deep Feature Flow for Video Recognition论文复现（pytorch版）

CVPR2017|Deep Feature Flow for Video Recognition论文复现（pytorch版）

&#x1f3c6;引言&#xff1a;深度卷积神经网络在图像识别任务中取得了巨大的成功。然而&#xff0c;将最先进的图像识别网络转移到视频上并非易事&#xff0c;因为每帧评估速度太慢且负担不起。我们提出了一种快速准确的视频识别框架——深度特征流DFF。它只在稀疏关键帧上运…
阅读更多...
数据通信基础 - 调制技术

数据通信基础 - 调制技术

文章目录1 概述2 调制技术2.1 分类2.2 N 相调制3 网工软考真题1 概述 #mermaid-svg-ZTF6pPysJlmUes01 {font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}#mermaid-svg-ZTF6pPysJlmUes01 .error-icon{fill:#552222;}#mermaid-svg-ZTF…
阅读更多...
谷歌用量子处理器发现：光子能在混沌中保持稳健的束缚态

谷歌用量子处理器发现：光子能在混沌中保持稳健的束缚态

一圈超导量子比特可以容纳微波光子的“束缚态”&#xff0c;其中光子往往聚集在相邻的量子比特位点上。图片来源&#xff1a;Google Quantum AI 使用量子处理器&#xff0c;研究人员可以使微波光子具有异常的“粘性”。在诱使它们聚集成束缚态后&#xff0c;他们发现这些光子簇…
阅读更多...
谷歌 Chrome 浏览器弹窗境外广告的解决方法

谷歌 Chrome 浏览器弹窗境外广告的解决方法

谷歌的 Chrome 浏览器是我非常喜欢的一款的浏览器&#xff0c;用了它之后就不想再用其它浏览器。可是不知道从什么时候开始&#xff0c;Chrome 浏览器居然时不时地在右下角弹出广告&#xff0c;仔细一看&#xff0c;还是境外的 VPN 广告&#xff0c;如下图。有弹出过几次了&…
阅读更多...
catia基准平面显示大小，用着不爽

catia基准平面显示大小，用着不爽

把这个值修改大
阅读更多...
如何通过创建 SSH key 来进行Git 代码管理

如何通过创建 SSH key 来进行Git 代码管理

1.检查你的电脑是否已经有SSH Key&#xff1f; 运行如下命令查看&#xff1a; $ cd ~/.ssh $ ls如果存在id_rsa.pub或 id_dsa.pub 文件&#xff0c;说明你的电脑已经有 SSH Key &#xff0c;可以直接拿来用&#xff0c;如果没有的话需要创建。 2.创建SSH Key 配置全局的nam…
阅读更多...
zookeeper入门篇

zookeeper入门篇

文章目录前言介绍安装与启动配置说明节点节点类型PERSISTENT&#xff08;持久化节点&#xff09;PERSISTENT_SEQUENTIAL&#xff08;持久化顺序节点&#xff09;EPHEMERAL&#xff08;临时节点&#xff09;EPHEMERAL_SEQUENTIAL&#xff08;临时顺序节点&#xff09;Container&…
阅读更多...
用Java实现简单的图书管理系统（Java系列7）

用Java实现简单的图书管理系统（Java系列7）

目录 前言&#xff1a; 1.基础框架的搭建 1.1图书 1.1.1书 1.1.2书架 1.2用户 1.2.1抽象类 1.2.2普通用户 1.2.3管理员 1.3操作 1.3.1新增图书 1.3.2借阅图书 1.3.3删除图书 1.3.4退出图书 1.3.5查找图书 1.3.6归还图书 1.3.7显示图书 2.具体内容的实现 2.1Ma…
阅读更多...
＜flutter＞跨平台开发新手入坑指南 dart dio pubspec.yaml json_annotation 打包 小坑指南

＜flutter＞跨平台开发新手入坑指南 dart dio pubspec.yaml json_annotation 打包 小坑指南

1.资源文件和依赖三方包&#xff08;pubspec.yaml&#xff09;&#xff1a; pubspec.yaml文件可以说是和安卓的gradle文件差不多&#xff0c;它用来描述版本号、sdk、依赖等的。 在资源导入方面同安卓不一样的是&#xff0c;flutter需要在pubspec.yaml中声名&#xff0c;不然…
阅读更多...
【PCB专题】Allegro元件库路径设置方法

【PCB专题】Allegro元件库路径设置方法

正常Layout拉线前，需要将原理图导出的网表导入到Allegro里，Allegro就会自动将元件导入。如果库路径没有设置或都软件找不到器件，将会非常的卡顿，并且报Completed with warnings/errors。如下图所示： 在弹出的错误报告View of file:netrev.lst中会提示很多器件找不到封装。…
阅读更多...
js知识点

js知识点

js有预解析阶段&#xff0c;变量声明提升只提升定义&#xff0c;不提升值 console.log(a);//undefined var a10; 基本数据类型 Number、String、Boolean、Undefined和Null 复杂数据类型 Object、Array、Function、RegExp、Date、Map、Set等 使用typeof运算符可以检测值或…
阅读更多...
刷爆力扣之验证回文串 II

刷爆力扣之验证回文串 II

刷爆力扣之验证回文串 II HELLO&#xff0c;各位看官大大好&#xff0c;我是阿呆 &#x1f648;&#x1f648;&#x1f648; 今天阿呆继续记录下力扣刷题过程&#xff0c;收录在专栏算法中 &#x1f61c;&#x1f61c;&#x1f61c; 该专栏按照不同类别标签进行刷题&#xff…
阅读更多...
第六章 作业【数据库原理】

第六章 作业【数据库原理】

第六章 作业【数据库原理】前言推荐第六章 作业第6章第1题&#xff08;简答题&#xff09;第6章第2题&#xff08;简答题&#xff09;第6章第3题&#xff08;设计题&#xff09;第6章第4题&#xff08;设计题&#xff09;最后前言 2022-12-27 16:05:55 以下内容源自数据库原理…
阅读更多...
最大连续子序列的和问题（算法）

最大连续子序列的和问题（算法）

问题描述 给定一个有n&#xff08;n≥1&#xff09;个整数的序列&#xff0c;要求求出其中最大连续子序列的和。 蛮力法 暴力枚举 /*** 时间复杂度&#xff1a;O(n^3)* param arr 序列[数组]* param n 数组大小* return int */ int maxSubSum1(int arr[], int n) {int thi…
阅读更多...
美团餐饮SaaS基于StarRocks构建商家数据中台的探索

美团餐饮SaaS基于StarRocks构建商家数据中台的探索

作者&#xff1a;何启航&#xff0c;美团餐饮SaaS数据专家&#xff08;文章整理自作者在 StarRocks Summit Asia 2022 的分享&#xff09; 随着社会经济的发展&#xff0c;餐饮连锁商家越来越大&#xff0c;“万店时代”来临。对于美团餐饮 SaaS 来说&#xff0c;传统的 OLTP …
阅读更多...
LeetCode 324 周赛

LeetCode 324 周赛

2506. 统计相似字符串对的数目 给你一个下标从 0 开始的字符串数组 words 。 如果两个字符串由相同的字符组成&#xff0c;则认为这两个字符串 相似 。 例如&#xff0c;"abca" 和 "cba" 相似&#xff0c;因为它们都由字符 a、b、c 组成。然而&#xff…
阅读更多...
HQChart实战教程54-renko砖形K线图

HQChart实战教程54-renko砖形K线图

HQChart实战教程54-renko砖形K线图 Renko砖形图效果图使用HQChart创建Renko初始化创建Renko配置参数说明ClassNameOption动态修改Renko配置参数完成demo代码Renko砖形图 Renko砖形图是仅测量价格变动的图表类型。 “ renko”一词源自日语单词“ renga”，意为“砖”。并非巧合…
阅读更多...
day30【代码随想录】分割回文串、复原IP地址、子集

day30【代码随想录】分割回文串、复原IP地址、子集

文章目录前言一、分割回文串&#xff08;力扣131&#xff09;二、复原IP地址&#xff08;力扣93&#xff09;三、子集&#xff08;力扣78&#xff09;总结前言 1、分割回文串 2、复原IP地址 3、子集 一、分割回文串&#xff08;力扣131&#xff09; 给你一个字符串 s&#xf…
阅读更多...
前端开发：关于鉴权的使用总结

前端开发：关于鉴权的使用总结

前言 前端开发过程中&#xff0c;关于鉴权&#xff08;权限的控制&#xff09;是非常重要的内容&#xff0c;尤其是前端和后端之间数据传递时候的请求鉴权校验。前端鉴权的本质就是控制前端视图层的显示和前端向后台所发送的请求&#xff0c;但是只有前端鉴权&#xff0c;没有后…
阅读更多...
MyGDI+

MyGDI+

文章目录[toc]界面设计Form窗口MenuStrip画笔其他选项界面美化整体框架设计DataStructureCPointPolylinePolygonSingletonGraphicFunctionForm事件处理成员变量事件处理总结界面设计 Form窗口 首先添加MenuStrip控件&#xff0c;随后在Form窗口属性界面根据个人爱好修改其图标…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023