Spring源码（五）— 解析XML配置文件(二) 定制化标签解析流程

news2024/9/28 13:17:24

上一篇以bean标签为例，介绍了属于defaultNamesapce标签的解析流程，但是defaultNamespace中默认的标签只有bean、beans、alias、import这四个，而我们平时在xml中配置的标签有很多。那其余的标签是如何解析？
在这篇文章会详细介绍定制化标签的解析流程。

注：除defaultNamesapce所属的4个标签外，其余所见标签都为定制化标签，包括自已根据业务定义的。

在看解析定制化标签流程的具体逻辑之前，先回顾一下registerBeanDefinitions方法中的流程。

配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:util="http://www.springframework.org/schema/util"
       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.xsd
        http://www.springframework.org/schema/context  http://www.springframework.org/schema/context/spring-context.xsd>

    <context:property-placeholder location="classpath:db.properties" ></context:property-placeholder>

	<util:list></util:list>
    <bean  id="person" class="com.test.Person" scope="prototype">
        <property name="id" value="1"></property>
        <property name="name" value="zhangsan"></property>
    </bean>

</beans>

registerBeanDefinitions
这段代码一定不陌生，在上一篇中，根据EncodingResource创建了Doc对象后执行的方法就是这个，创建了BeanDefinitionDocumentReader 对象。但在创建完BDDR对象后，具体解析之前。
执行registerBeanDefinitions()方法传入的方法参数中还执行了createReaderContext()方法。

public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
		// 对xml的beanDefinition进行解析
		BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
		int countBefore = getRegistry().getBeanDefinitionCount();
		// 完成具体的解析过程
		documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
		return getRegistry().getBeanDefinitionCount() - countBefore;
	}

createReaderContext
createReaderContext方法中会执行getNamespaceHandlerResolver()方法。getNamespaceHandlerResolver()会返回一个DefaultNamespaceHandlerResolver对象封装进XmlReaderContext中。
而DefaultNamespaceHandlerResolver中有一个类变量是handlerMappingLocation，这个变量的值是类中的常量DEFAULT_HANDLER_MAPPINGS_LOCATION 。

public XmlReaderContext createReaderContext(Resource resource) {
		return new XmlReaderContext(resource, this.problemReporter, this.eventListener,
				this.sourceExtractor, this, getNamespaceHandlerResolver());
	}

public static final String DEFAULT_HANDLER_MAPPINGS_LOCATION = "META-INF/spring.handlers";

public NamespaceHandlerResolver getNamespaceHandlerResolver() {
		if (this.namespaceHandlerResolver == null) {
			this.namespaceHandlerResolver = createDefaultNamespaceHandlerResolver();
		}
		return this.namespaceHandlerResolver;
	}

protected NamespaceHandlerResolver createDefaultNamespaceHandlerResolver() {
		ClassLoader cl = (getResourceLoader() != null ? getResourceLoader().getClassLoader() : getBeanClassLoader());
		return new DefaultNamespaceHandlerResolver(cl);
	}

因为Spring框架在底层中说不定什么地方会进行类的加载，和父类构造器属性的一些赋值。用的时候就直接拿出来，所以有一些知识点不串起来会非常的突兀。不知道类、值都是哪来的。
前置的知识点已经介绍完，接下来让我们来看定制化标签的解析过程。

parseBeanDefinitions
如果是defaultNamespace会走bean、beans、import、alias中的一个。定制化的标签会走下面。

protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
		if (delegate.isDefaultNamespace(root)) {
			//上一篇已经介绍过，代码省略
		}
		else {
			//执行定制化标签解析的具体逻辑
			delegate.parseCustomElement(root);
		}
	}

parseCustomElement
依然是获取对应的命名空间，并且根据namespaceUri，在readerContext中进行解析，找到对应的handler。

@Nullable
	public BeanDefinition parseCustomElement(Element ele, @Nullable BeanDefinition containingBd) {
		// 获取对应的命名空间
		String namespaceUri = getNamespaceURI(ele);
		if (namespaceUri == null) {
			return null;
		}
		// 根据命名空间找到对应的NamespaceHandlerspring
		NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
		if (handler == null) {
			error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", ele);
			return null;
		}
		// 调用自定义的NamespaceHandler进行解析
		return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
	}

resolve
resolve方法中，就是在上面提到的xmlReaderContext中获取defaultResolve来进行对应的处理。在通过mapping找到具体Handler处理类后，调用handler的init()方法，像parsers中注册，并且根据标签下，属性的不同，具体的parsers解析类实现也不同。

public NamespaceHandler resolve(String namespaceUri) {
		// 获取所有已经配置好的handler映射
		Map<String, Object> handlerMappings = getHandlerMappings();
		// 根据命名空间找到对应的信息
		Object handlerOrClassName = handlerMappings.get(namespaceUri);
		if (handlerOrClassName == null) {
			return null;
		}
		else if (handlerOrClassName instanceof NamespaceHandler) {
			// 如果已经做过解析，直接从缓存中读取
			return (NamespaceHandler) handlerOrClassName;
		}
		else {
			// 没有做过解析，则返回的是类路径
			String className = (String) handlerOrClassName;
			try {
				// 通过反射将类路径转化为类
				Class<?> handlerClass = ClassUtils.forName(className, this.classLoader);
				if (!NamespaceHandler.class.isAssignableFrom(handlerClass)) {
					//省略异常..
				}
				// 实例化类
				NamespaceHandler namespaceHandler = (NamespaceHandler) BeanUtils.instantiateClass(handlerClass);
				// 调用自定义的namespaceHandler的初始化方法
				namespaceHandler.init();
				// 讲结果记录在缓存中
				handlerMappings.put(namespaceUri, namespaceHandler);
				return namespaceHandler;
			}
		}
	}

getHandlerMappings
在这个方法中，会找到配置文件中的handler映射。
这个方法比较有意思，如果是debug进来的话，那handlerMappings是有默认值的。因为idea编译器为了查看类的变量属性，会调用toString方法，而toString方法中就会显式调用getHandlerMappings。

如果handlerMappings 是null的话，则会通过loadAllProperties方法获取mapping，通过方法的参数中handlerMappingsLocation（固定常量），来进行对应META-INF/spring.handlers的加载。

	private Map<String, Object> getHandlerMappings() {
		Map<String, Object> handlerMappings = this.handlerMappings;
		// 如果没有被缓存，则开始进行缓存
		if (handlerMappings == null) {
			synchronized (this) {
				handlerMappings = this.handlerMappings;
				if (handlerMappings == null) {
					try {
						// this.handlerMappingsLocation在构造函数中已经被初始化为META-INF/Spring.handlers
						Properties mappings =
								PropertiesLoaderUtils.loadAllProperties(this.handlerMappingsLocation, this.classLoader);
						handlerMappings = new ConcurrentHashMap<>(mappings.size());
						// 将properties格式文件合并到map格式的handlerMapping中
						CollectionUtils.mergePropertiesIntoMap(mappings, handlerMappings);
						this.handlerMappings = handlerMappings;
					}
				}
			}
		}
		return handlerMappings;
	}

让我们来看一下spring.handlers是什么样。
在这里插入图片描述
spring.handlers就是key，value形式的文件格式，value就是对应标签的处理器，比如文章开头的context标签和util标签。在< beans xmls >中配置对应的属性后，xml文件即可引用对应标签及其属性，就可以获取到对应的namespaceUri来找到对应的handlerMapping。就可以进行具体handler类的一个加载。

UtilNamespaceHandler

这就是具体的handler类，在根据mapping找到具体的handler类后，会进行init方法的初始化操作，像util标签中list属性，会像parsers（Map<String, BeanDefinitionParser>）中进行注册，并且每个属性都有具体ListBeanDefinitionParser解析类来进行属性的解析。


public class UtilNamespaceHandler extends NamespaceHandlerSupport {

	private static final String SCOPE_ATTRIBUTE = "scope";


	@Override
	public void init() {
		registerBeanDefinitionParser("constant", new ConstantBeanDefinitionParser());
		registerBeanDefinitionParser("property-path", new PropertyPathBeanDefinitionParser());
		registerBeanDefinitionParser("list", new ListBeanDefinitionParser());
		registerBeanDefinitionParser("set", new SetBeanDefinitionParser());
		registerBeanDefinitionParser("map", new MapBeanDefinitionParser());
		registerBeanDefinitionParser("properties", new PropertiesBeanDefinitionParser());
	}


	private static class ListBeanDefinitionParser extends AbstractSingleBeanDefinitionParser {

		@Override
		protected Class<?> getBeanClass(Element element) {
			return ListFactoryBean.class;
		}

		@Override
		protected void doParse(Element element, ParserContext parserContext, BeanDefinitionBuilder builder) {
			List<Object> parsedList = parserContext.getDelegate().parseListElement(element, builder.getRawBeanDefinition());
			builder.addPropertyValue("sourceList", parsedList);

			String listClass = element.getAttribute("list-class");
			if (StringUtils.hasText(listClass)) {
				builder.addPropertyValue("targetListClass", listClass);
			}

			String scope = element.getAttribute(SCOPE_ATTRIBUTE);
			if (StringUtils.hasLength(scope)) {
				builder.setScope(scope);
			}
		}
	}
	//省略部分代码
}

parseCustomElement
获取到具体handler并且执行完init()后，再回到parseCustomElement，此时resolve方法已经执行完成，往下走，调用具体的handler.parse来进行属性的解析。

	public BeanDefinition parseCustomElement(Element ele, @Nullable BeanDefinition containingBd) {
		// 获取对应的命名空间
		String namespaceUri = getNamespaceURI(ele);
		if (namespaceUri == null) {
			return null;
		}
		// 根据命名空间找到对应的NamespaceHandlerspring
		NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
		if (handler == null) {
			error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", ele);
			return null;
		}
		// 调用自定义的NamespaceHandler进行解析
		return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
	}

findParserForElement
parse方法会调用NamespaceHandlerSupport类中的findParserForElement，首先会获取元素名称"list"，而我们在handler中执行init方式时，已经将标签对应属性全部放入了parser中，此时从parser获取具体Parser对象并返回。执行parser.parser方法。

public BeanDefinition parse(Element element, ParserContext parserContext) {
		// 获取元素的解析器
		BeanDefinitionParser parser = findParserForElement(element, parserContext);
		return (parser != null ? parser.parse(element, parserContext) : null);
	}
	
private BeanDefinitionParser findParserForElement(Element element, ParserContext parserContext) {
		// 获取元素名称
		String localName = parserContext.getDelegate().getLocalName(element);
		// 根据元素名称找到对应的解析器
		BeanDefinitionParser parser = this.parsers.get(localName);
		if (parser == null) {
		
		}
		return parser;
	}

parse
此时会调用AbstractBeanDefinitionParser类中的parse方法，根据parseInternal()底层调用的具体doParse方法对标签属性进行具体的解析后，将Definition封装成BeanDefinitionHolder ，调用registerBeanDefinition方法注册到BeanFactory中。

public final BeanDefinition parse(Element element, ParserContext parserContext) {
		AbstractBeanDefinition definition = parseInternal(element, parserContext);
		if (definition != null && !parserContext.isNested()) {
			try {
				String id = resolveId(element, definition, parserContext);
				if (!StringUtils.hasText(id)) {
				
				}
				String[] aliases = null;
				if (shouldParseNameAsAliases()) {
					String name = element.getAttribute(NAME_ATTRIBUTE);
					if (StringUtils.hasLength(name)) {
						aliases = StringUtils.trimArrayElements(StringUtils.commaDelimitedListToStringArray(name));
					}
				}
				// 将AbstractBeanDefinition转换为BeanDefinitionHolder并注册
				BeanDefinitionHolder holder = new BeanDefinitionHolder(definition, id, aliases);
				registerBeanDefinition(holder, parserContext.getRegistry());
				if (shouldFireEvents()) {
					// 通知监听器进行处理
					BeanComponentDefinition componentDefinition = new BeanComponentDefinition(holder);
					postProcessComponentDefinition(componentDefinition);
					parserContext.registerComponent(componentDefinition);
				}
			}
			catch (BeanDefinitionStoreException ex) {
				String msg = ex.getMessage();
				parserContext.getReaderContext().error((msg != null ? msg : ex.toString()), element);
				return null;
			}
		}
		return definition;
	}

parseInternal
创建BeanDefinitionBuilder，调用doParse方法进行属性的具体解析，并将值放到builder对象中。

protected final AbstractBeanDefinition parseInternal(Element element, ParserContext parserContext) {
		BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition();
		String parentName = getParentName(element);
		if (parentName != null) {
			builder.getRawBeanDefinition().setParentName(parentName);
		}
		// 获取自定义标签中的class，此时会调用自定义解析器
		Class<?> beanClass = getBeanClass(element);
		if (beanClass != null) {
			builder.getRawBeanDefinition().setBeanClass(beanClass);
		}
		else {
			// 若子类没有重写getBeanClass方法则尝试检查子类是否重写getBeanClassName方法
			String beanClassName = getBeanClassName(element);
			if (beanClassName != null) {
				builder.getRawBeanDefinition().setBeanClassName(beanClassName);
			}
		}
		builder.getRawBeanDefinition().setSource(parserContext.extractSource(element));
		BeanDefinition containingBd = parserContext.getContainingBeanDefinition();
		if (containingBd != null) {
			// Inner bean definition must receive same scope as containing bean.
			// 若存在父类则使用父类的scope属性
			builder.setScope(containingBd.getScope());
		}
		if (parserContext.isDefaultLazyInit()) {
			// Default-lazy-init applies to custom bean definitions as well.
			// 配置延迟加载
			builder.setLazyInit(true);
		}
		// 调用子类重写的doParse方法进行解析
		doParse(element, parserContext, builder);
		return builder.getBeanDefinition();
	}

doParse
具体的解析方法。以< util:list >为例，就是将list元素获取后，添加到builder中。每个属性的实现逻辑不同，如果想要自己自定义，也可遵循Spring的相关步骤来实现。

private static class ListBeanDefinitionParser extends AbstractSingleBeanDefinitionParser {

		@Override
		protected Class<?> getBeanClass(Element element) {
			return ListFactoryBean.class;
		}

		@Override
		protected void doParse(Element element, ParserContext parserContext, BeanDefinitionBuilder builder) {
			List<Object> parsedList = parserContext.getDelegate().parseListElement(element, builder.getRawBeanDefinition());
			builder.addPropertyValue("sourceList", parsedList);

			String listClass = element.getAttribute("list-class");
			if (StringUtils.hasText(listClass)) {
				builder.addPropertyValue("targetListClass", listClass);
			}

			String scope = element.getAttribute(SCOPE_ATTRIBUTE);
			if (StringUtils.hasLength(scope)) {
				builder.setScope(scope);
			}
		}
	}

在这里插入图片描述
至此，默认的命名空间标签解析和定制化的标签解析流程全部完成。最后都是将解析到的BeanDefinition注册到BeanFactory中。

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

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

相关文章

一个监控系统的典型架构

一个监控系统的典型架构

监控系统的典型架构图&#xff0c;从左往右看&#xff0c;采集器是负责采集监控数据的&#xff0c;采集到数据之后传输给服务端&#xff0c;通常是直接写入时序库。然后就是对时序库的数据进行分析和可视化&#xff0c;分析部分最典型的就是告警规则判断&#xff0c;即图上的告…
阅读更多...
【李宏毅机器学习·学习笔记】Deep Learning General Guidance

【李宏毅机器学习·学习笔记】Deep Learning General Guidance

本节课可视为机器学习系列课程的一个前期攻略&#xff0c;这节课主要对Machine Learning 的框架进行了简单的介绍&#xff1b;并以training data上的loss大小为切入点&#xff0c;介绍了几种常见的在模型训练的过程中容易出现的情况。 课程视频&#xff1a; Youtube&#xff1…
阅读更多...
【Spring框架】SpringBoot配置文件

【Spring框架】SpringBoot配置文件

目录 配置文件作用application.properties中午乱码问题&#xff1a;配置文件里面的配置类型分类SpringBoot热部署properties基本语法properties配置文件的优缺点&#xff1a;yml配置文件说明yml基本语法配置对象properties VS yml 配置文件作用 整个项⽬中所有重要的数据都是在…
阅读更多...
【MyBatis 学习二】增删改查 参数占位符 #{} 和 ${}的使用

【MyBatis 学习二】增删改查 参数占位符 #{} 和 ${}的使用

目录 一、增删改查 &#x1f337;1、用户类 &#x1f337;2、UserMapper &#x1f337;3、UserMapper.xml &#x1f337;4、测试类Test &#x1f337;5、UserService类 &#x1f337;6、UserController类 &#x1f337;7、注意点总结 二、#{} 和${} 的使用区别 &…
阅读更多...
一个 SpringBoot 项目能处理多少请求

一个 SpringBoot 项目能处理多少请求

首先&#xff0c;这个问题有坑&#xff0c;因为 spring boot 不处理请求&#xff0c;只是把现有的开源组件打包后进行了版本适配、预定义了一些开源组件的配置通过代码的方式进行自动装配进行简化开发。这是 spring boot 的价值。 如果我是面试官&#xff0c;我不会问这种问题。…
阅读更多...
BLE基础理论/Android BLE开发示例

BLE基础理论/Android BLE开发示例

参考&#xff1a;https://blog.csdn.net/qq_36075612/article/details/127739150?spm1001.2014.3001.5502 参考&#xff1a; https://blog.csdn.net/qq_36075612/article/details/122772966?spm1001.2014.3001.5502 目录 蓝牙的分类传统蓝牙低功耗蓝牙 蓝牙专业词汇&#xff…
阅读更多...
深度剖析C++ 异常机制

深度剖析C++ 异常机制

传统排错 我们早在 C 程序里面传统的错误处理手段有&#xff1a; 终止程序&#xff0c;如 assert&#xff1b;缺陷是用户难以接受&#xff0c;说白了就是一种及其粗暴的手法&#xff0c;比如发生内存错误&#xff0c;除0错误时就会终止程序。 返回错误码。缺陷是需要我们自己…
阅读更多...
docker启动容器报错

docker启动容器报错

报错信息 [rootDream soft]# docker run -it -d -p 8080:8080 tomcat eec9fab6b9ca06d2bbf1467aef05d8020ee60448978e10ac20c38888934f0a0b docker: Error response from daemon: driver failed programming external connectivity on endpoint hungry_euclid (163242f0079e72…
阅读更多...
C语言之pthread_cond_t信号变化探究总结(八十)

C语言之pthread_cond_t信号变化探究总结(八十)

简介&#xff1a; CSDN博客专家&#xff0c;专注Android/Linux系统&#xff0c;分享多mic语音方案、音视频、编解码等技术&#xff0c;与大家一起成长&#xff01; 优质专栏&#xff1a;Audio工程师进阶系列【原创干货持续更新中……】&#x1f680; 人生格言&#xff1a; 人生…
阅读更多...
MySQL | 常用命令示例

MySQL | 常用命令示例

MySQL | 常用命令示例 一、启停MySQL数据库服务二、连接MySQL数据库三、创建和管理数据库四、创建和管理数据表五、数据备份和恢复六、查询与优化 MySQL是一款常用的关系型数据库管理系统&#xff0c;广泛应用于各个领域。在使用MySQL时&#xff0c;我们经常需要编写一些常用脚…
阅读更多...
M 芯片的 macos 系统安装虚拟机 centos7 网络配置

M 芯片的 macos 系统安装虚拟机 centos7 网络配置

centos 安装之前把网络配置配好或者是把网线插好 第一步找到这个 第二步打开网络适配器 选择图中所指位置 设置好之后 开机启动 centos 第三步 开机以后 编写网卡文件保存 重启网卡就可以了&#xff0c;如果重启网卡不管用&#xff0c;则重启虚拟机即可 “ ifcfg-ens160 ” 这…
阅读更多...
盖子的c++小课堂——第二十一讲：map

盖子的c++小课堂——第二十一讲：map

前言 时隔一周&#xff0c;我又来更新了^_^&#xff0c;今天都第二十一讲了&#xff0c;前三个板块马上就结束了&#xff0c;也就是小课堂&#xff08;1&#xff09;马上结束了&#xff0c;敬请期待“盖子的c小课堂&#xff08;2&#xff09;”&#xff0c;嘿嘿~~ map 数据容…
阅读更多...
QT--day5(网络聊天室、学生信息管理系统)

QT--day5(网络聊天室、学生信息管理系统)

服务器&#xff1a; #include "widget.h" #include "ui_widget.h"Widget::Widget(QWidget *parent): QWidget(parent), ui(new Ui::Widget) {ui->setupUi(this);//给服务器指针实例化空间servernew QTcpServer(this); }Widget::~Widget() {delete ui; …
阅读更多...
【C#】.Net Framework框架下的Authorize权限类

【C#】.Net Framework框架下的Authorize权限类

2023年&#xff0c;第31周&#xff0c;第3篇文章。给自己一个目标&#xff0c;然后坚持总会有收货&#xff0c;不信你试试&#xff01; 在C#的.NET Framework中&#xff0c;你可以使用Authorize类来处理权限认证。Authorize类位于System.Web.Mvc命名空间中&#xff0c;它提供了…
阅读更多...
VS创建wsdl服务提供给java调用

VS创建wsdl服务提供给java调用

文章目录 前言1.c#创建asp.net web服务1.1 创建ASP.NET Web应用程序1.2 添加服务类1.3 定义服务方法1.3 浏览服务1.4 发布服务1.5 IIS部署服务 2.Java中调用服务2.1 用动态客户端工厂类调用2.1.1 引入依赖2.1.2 调用测试代码2.1.3 测试结果 2.2 创建代理类进行调用2.2.1 使用ws…
阅读更多...
微软：向量搜索和向量数据库

微软：向量搜索和向量数据库

向量是未来的数据表示 向量搜索 方法 减少距离计算次数 哈希法空间划分树近邻图 SPTAG 混合了kd树和近邻图 Change 大规律向量搜索 内存可扩展 倒排索引 全局量化进行压缩 top1的召回率比较低 基于图的近邻图 SPANN 倒排索引中的问题&#xff1a; 不平衡的聚类方法低…
阅读更多...
Python读取csv、Excel文件生成图表

Python读取csv、Excel文件生成图表

简介 本文章介绍了通过读取 csv 或 Excel 文件内容&#xff0c;将其转换为折线图或柱状图的方法&#xff0c;并写入 html 文件中。 目录 1. 读取CSV文件 1.1. 生成折线图 1.1.1. 简单生成图表 1.1.2. 设置折线图格式 1.2. 生成柱状图 1.2.1. 简单生成图表 1.2.2. 设置柱…
阅读更多...
Python-Python基础综合案例：数据可视化 - 折线图可视化

Python-Python基础综合案例：数据可视化 - 折线图可视化

版本说明 当前版本号[20230729]。 版本修改说明20230729初版 目录 文章目录 版本说明目录知识总览图Python基础综合案例&#xff1a;数据可视化 - 折线图可视化json数据格式什么是jsonjson有什么用json格式数据转化Python数据和Json数据的相互转化 pyecharts模块介绍概况如何…
阅读更多...
年薪百万的提示词工程师到底在做什么?

年薪百万的提示词工程师到底在做什么?

&#x1f3c6; 文章目标&#xff1a;了解热门开源项目 &#x1f340; 入门篇&#xff1a;程序员,必须要知道的热门开源项目! ✅ 创作者&#xff1a;熊猫Jay ✨ 个人公众号: 熊猫Jay字节之旅 (文末有链接) &#x1f341; 展望&#xff1a;若本篇讲解内容帮助到您&#xff0c;请帮…
阅读更多...
高忆管理：股票投资策略是什么？有哪些？

高忆管理：股票投资策略是什么？有哪些？

在进行股票买卖过程中&#xff0c;出资者需求有自己的方案和出资战略&#xff0c;并且主张严格遵从出资战略买卖&#xff0c;不要跟风操作。那么股票出资战略是什么&#xff1f;有哪些&#xff1f;下面就由高忆管理为我们剖析&#xff1a; 股票出资战略简略来说便是能够协助出资…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023