Spring源码解析—— IOC默认标签解析（下）

news2024/12/23 8:51:24

正文

在上一篇我们已经完成了从xml配置文件到BeanDefinition的转换，转换后的实例是GenericBeanDefinition的实例。本文主要来看看标签解析剩余部分及BeanDefinition的注册。

默认标签中的自定义标签解析

在上篇博文中我们已经分析了对于默认标签的解析，我们继续看戏之前的代码，如下图片中有一个方法：delegate.decorateBeanDefinitionIfRequired(ele, bdHolder)

这个方法的作用是什么呢？首先我们看下这种场景，如下配置文件：

 <bean id="demo" class="com.dabin.spring.MyTestBean">
     <property name="beanName" value="bean demo1"/>
     <meta key="demo" value="demo"/>
     <mybean:username="mybean"/>
 </bean>

这个配置文件中有个自定义的标签，decorateBeanDefinitionIfRequired方法就是用来处理这种情况的，其中的null是用来传递父级BeanDefinition的，我们进入到其方法体：

public BeanDefinitionHolder decorateBeanDefinitionIfRequired(Element ele, BeanDefinitionHolder definitionHolder) {
    return decorateBeanDefinitionIfRequired(ele, definitionHolder, null);
}
public BeanDefinitionHolder decorateBeanDefinitionIfRequired(
        Element ele, BeanDefinitionHolder definitionHolder, @Nullable BeanDefinition containingBd) {

    BeanDefinitionHolder finalDefinition = definitionHolder;

    // Decorate based on custom attributes first.
    NamedNodeMap attributes = ele.getAttributes();
    for (int i = 0; i < attributes.getLength(); i++) {
        Node node = attributes.item(i);
        finalDefinition = decorateIfRequired(node, finalDefinition, containingBd);
    }

    // Decorate based on custom nested elements.
    NodeList children = ele.getChildNodes();
    for (int i = 0; i < children.getLength(); i++) {
        Node node = children.item(i);
        if (node.getNodeType() == Node.ELEMENT_NODE) {
            finalDefinition = decorateIfRequired(node, finalDefinition, containingBd);
        }
    }
    return finalDefinition;
}

我们看到上面的代码有两个遍历操作，一个是用于对所有的属性进行遍历处理，另一个是对所有的子节点进行处理，两个遍历操作都用到了decorateIfRequired(node, finalDefinition, containingBd);方法，我们继续跟踪代码，进入方法体：

public BeanDefinitionHolder decorateIfRequired(
        Node node, BeanDefinitionHolder originalDef, @Nullable BeanDefinition containingBd) {
    // 获取自定义标签的命名空间
    String namespaceUri = getNamespaceURI(node);
    // 过滤掉默认命名标签
    if (namespaceUri != null && !isDefaultNamespace(namespaceUri)) {
        // 获取相应的处理器
        NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
        if (handler != null) {
            // 进行装饰处理
            BeanDefinitionHolder decorated =
                    handler.decorate(node, originalDef, new ParserContext(this.readerContext, this, containingBd));
            if (decorated != null) {
                return decorated;
            }
        }
        else if (namespaceUri.startsWith("http://www.springframework.org/")) {
            error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", node);
        }
        else {
            if (logger.isDebugEnabled()) {
                logger.debug("No Spring NamespaceHandler found for XML schema namespace [" + namespaceUri + "]");
            }
        }
    }
    return originalDef;
}

public String getNamespaceURI(Node node) {
    return node.getNamespaceURI();
}

public boolean isDefaultNamespace(@Nullable String namespaceUri) {
    //BEANS_NAMESPACE_URI = "http://www.springframework.org/schema/beans";
    return (!StringUtils.hasLength(namespaceUri) || BEANS_NAMESPACE_URI.equals(namespaceUri));
}

首先获取自定义标签的命名空间，如果不是默认的命名空间则根据该命名空间获取相应的处理器，最后调用处理器的 decorate() 进行装饰处理。具体的装饰过程这里不进行讲述，在后面分析自定义标签时会做详细说明。

注册解析的BeanDefinition

对于配置文件，解析和装饰完成之后，对于得到的beanDefinition已经可以满足后续的使用要求了，还剩下注册，也就是processBeanDefinition函数中的BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder,getReaderContext().getRegistry())代码的解析了。进入方法体：

public static void registerBeanDefinition(
        BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
        throws BeanDefinitionStoreException {
    // Register bean definition under primary name.
    //使用beanName做唯一标识注册
    String beanName = definitionHolder.getBeanName();
    registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());

    // Register aliases for bean name, if any.
    //注册所有的别名
    String[] aliases = definitionHolder.getAliases();
    if (aliases != null) {
        for (String alias : aliases) {
            registry.registerAlias(beanName, alias);
        }
    }
}

从上面的代码我们看到是用了beanName作为唯一标示进行注册的，然后注册了所有的别名aliase。而beanDefinition最终都是注册到BeanDefinitionRegistry中，接下来我们具体看下注册流程。

通过beanName注册BeanDefinition

在spring中除了使用beanName作为key将BeanDefinition放入Map中还做了其他一些事情，我们看下方法registerBeanDefinition代码，BeanDefinitionRegistry是一个接口，他有三个实现类，DefaultListableBeanFactory、SimpleBeanDefinitionRegistry、GenericApplicationContext，其中SimpleBeanDefinitionRegistry非常简单，而GenericApplicationContext最终也是使用的DefaultListableBeanFactory中的实现方法，我们看下代码：

public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
        throws BeanDefinitionStoreException {

    // 校验 beanName 与 beanDefinition
    Assert.hasText(beanName, "Bean name must not be empty");
    Assert.notNull(beanDefinition, "BeanDefinition must not be null");

    if (beanDefinition instanceof AbstractBeanDefinition) {
        try {
            // 校验 BeanDefinition
            // 这是注册前的最后一次校验了，主要是对属性 methodOverrides 进行校验
            ((AbstractBeanDefinition) beanDefinition).validate();
        }
        catch (BeanDefinitionValidationException ex) {
            throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
                    "Validation of bean definition failed", ex);
        }
    }

    BeanDefinition oldBeanDefinition;

    // 从缓存中获取指定 beanName 的 BeanDefinition
    oldBeanDefinition = this.beanDefinitionMap.get(beanName);
    /**
     * 如果存在
     */
    if (oldBeanDefinition != null) {
        // 如果存在但是不允许覆盖，抛出异常
        if (!isAllowBeanDefinitionOverriding()) {
            throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
                    "Cannot register bean definition [" + beanDefinition + "] for bean '" + beanName +
                            "': There is already [" + oldBeanDefinition + "] bound.");
        }
        //
        else if (oldBeanDefinition.getRole() < beanDefinition.getRole()) {
            // e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
            if (this.logger.isWarnEnabled()) {
                this.logger.warn("Overriding user-defined bean definition for bean '" + beanName +
                        "' with a framework-generated bean definition: replacing [" +
                        oldBeanDefinition + "] with [" + beanDefinition + "]");
            }
        }
        // 覆盖 beanDefinition 与 被覆盖的 beanDefinition 不是同类
        else if (!beanDefinition.equals(oldBeanDefinition)) {
            if (this.logger.isInfoEnabled()) {
                this.logger.info("Overriding bean definition for bean '" + beanName +
                        "' with a different definition: replacing [" + oldBeanDefinition +
                        "] with [" + beanDefinition + "]");
            }
        }
        else {
            if (this.logger.isDebugEnabled()) {
                this.logger.debug("Overriding bean definition for bean '" + beanName +
                        "' with an equivalent definition: replacing [" + oldBeanDefinition +
                        "] with [" + beanDefinition + "]");
            }
        }

        // 允许覆盖，直接覆盖原有的 BeanDefinition
        this.beanDefinitionMap.put(beanName, beanDefinition);
    }
    /**
     * 不存在
     */
    else {
         // 检测创建 Bean 阶段是否已经开启，如果开启了则需要对 beanDefinitionMap 进行并发控制
        if (hasBeanCreationStarted()) {
            // beanDefinitionMap 为全局变量，避免并发情况
            synchronized (this.beanDefinitionMap) {
                //
                this.beanDefinitionMap.put(beanName, beanDefinition);
                List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
                updatedDefinitions.addAll(this.beanDefinitionNames);
                updatedDefinitions.add(beanName);
                this.beanDefinitionNames = updatedDefinitions;
                if (this.manualSingletonNames.contains(beanName)) {
                    Set<String> updatedSingletons = new LinkedHashSet<>(this.manualSingletonNames);
                    updatedSingletons.remove(beanName);
                    this.manualSingletonNames = updatedSingletons;
                }
            }
        }
        else {
            // 不会存在并发情况，直接设置
            this.beanDefinitionMap.put(beanName, beanDefinition);
            this.beanDefinitionNames.add(beanName);
            this.manualSingletonNames.remove(beanName);
        }
        this.frozenBeanDefinitionNames = null;
    }

    if (oldBeanDefinition != null || containsSingleton(beanName)) {
        // 重新设置 beanName 对应的缓存
        resetBeanDefinition(beanName);
    }
}

处理过程如下：

  • 首先 BeanDefinition 进行校验，该校验也是注册过程中的最后一次校验了，主要是对 AbstractBeanDefinition 的 methodOverrides 属性进行校验
  • 根据 beanName 从缓存中获取 BeanDefinition，如果缓存中存在，则根据 allowBeanDefinitionOverriding 标志来判断是否允许覆盖，如果允许则直接覆盖，否则抛出 BeanDefinitionStoreException 异常
  • 若缓存中没有指定 beanName 的 BeanDefinition，则判断当前阶段是否已经开始了 Bean 的创建阶段（），如果是，则需要对 beanDefinitionMap 进行加锁控制并发问题，否则直接设置即可。对于 hasBeanCreationStarted() 方法后续做详细介绍，这里不过多阐述。
  • 若缓存中存在该 beanName 或者 单利 bean 集合中存在该 beanName，则调用 resetBeanDefinition() 重置 BeanDefinition 缓存。

其实整段代码的核心就在于 this.beanDefinitionMap.put(beanName, beanDefinition); 。BeanDefinition 的缓存也不是神奇的东西，就是定义 一个 ConcurrentHashMap，key 为 beanName，value 为 BeanDefinition。

通过别名注册BeanDefinition

通过别名注册BeanDefinition最终是在SimpleBeanDefinitionRegistry中实现的，我们看下代码：

public void registerAlias(String name, String alias) {
    Assert.hasText(name, "'name' must not be empty");
    Assert.hasText(alias, "'alias' must not be empty");
    synchronized (this.aliasMap) {
        if (alias.equals(name)) {
            this.aliasMap.remove(alias);
        }
        else {
            String registeredName = this.aliasMap.get(alias);
            if (registeredName != null) {
                if (registeredName.equals(name)) {
                    // An existing alias - no need to re-register
                    return;
                }
                if (!allowAliasOverriding()) {
                    throw new IllegalStateException("Cannot register alias '" + alias + "' for name '" +
                            name + "': It is already registered for name '" + registeredName + "'.");
                }
            }
            //当A->B存在时，若再次出现A->C->B时候则会抛出异常。
            checkForAliasCircle(name, alias);
            this.aliasMap.put(alias, name);
        }
    }
}

上述代码的流程总结如下：

（1）alias与beanName相同情况处理，若alias与beanName并名称相同则不需要处理并删除原有的alias

（2）alias覆盖处理。若aliasName已经使用并已经指向了另一beanName则需要用户的设置进行处理

（3）alias循环检查，当A->B存在时，若再次出现A->C->B时候则会抛出异常。

alias标签的解析

对应bean标签的解析是最核心的功能，对于alias、import、beans标签的解析都是基于bean标签解析的，接下来我就分析下alias标签的解析。我们回到 parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate)方法，继续看下方法体，如下图所示：

对bean进行定义时，除了用id来 指定名称外，为了提供多个名称，可以使用alias标签来指定。而所有这些名称都指向同一个bean。在XML配置文件中，可用单独的元素来完成bean别名的定义。我们可以直接使用bean标签中的name属性，如下：

<bean id="demo" class="com.dabin.spring.MyTestBean" name="demo1,demo2">
    <property name="beanName" value="bean demo1"/>
</bean>

在Spring还有另外一种声明别名的方式：

<bean id="myTestBean" class="com.dabin.spring.MyTestBean"/>
<alias name="myTestBean" alias="testBean1,testBean2"/>

我们具体看下alias标签的解析过程，解析使用的方法processAliasRegistration(ele)，方法体如下：

protected void processAliasRegistration(Element ele) {
    //获取beanName
    String name = ele.getAttribute(NAME_ATTRIBUTE);
    //获取alias
    String alias = ele.getAttribute(ALIAS_ATTRIBUTE);
    boolean valid = true;
    if (!StringUtils.hasText(name)) {
        getReaderContext().error("Name must not be empty", ele);
        valid = false;
    }
    if (!StringUtils.hasText(alias)) {
        getReaderContext().error("Alias must not be empty", ele);
        valid = false;
    }
    if (valid) {
        try {
            //注册alias
            getReaderContext().getRegistry().registerAlias(name, alias);
        }
        catch (Exception ex) {
            getReaderContext().error("Failed to register alias '" + alias +
                    "' for bean with name '" + name + "'", ele, ex);
        }
        getReaderContext().fireAliasRegistered(name, alias, extractSource(ele));
    }
}

通过代码可以发现解析流程与bean中的alias解析大同小异，都是讲beanName与别名alias组成一对注册到registry中。跟踪代码最终使用了SimpleAliasRegistry中的registerAlias(String name, String alias)方法

import标签的解析

对于Spring配置文件的编写，经历过大型项目的人都知道，里面有太多的配置文件了。基本采用的方式都是分模块，分模块的方式很多，使用import就是其中一种，例如我们可以构造这样的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"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="demo" class="com.dabin.spring.MyTestBean" name="demo1,demo2">
        <property name="beanName" value="bean demo1"/>
    </bean>
    <import resource="lookup-method.xml"/>
    <import resource="replaced-method.xml"/>
</beans>

applicationContext.xml文件中使用import方式导入有模块配置文件，以后若有新模块入加，那就可以简单修改这个文件了。这样大大简化了配置后期维护的复杂度，并使配置模块化，易于管理。我们来看看Spring是如何解析import配置文件的呢。解析import标签使用的是importBeanDefinitionResource(ele)，进入方法体：

protected void importBeanDefinitionResource(Element ele) {
    // 获取 resource 的属性值 
    String location = ele.getAttribute(RESOURCE_ATTRIBUTE);
    // 为空，直接退出
    if (!StringUtils.hasText(location)) {
        getReaderContext().error("Resource location must not be empty", ele);
        return;
    }

    // 解析系统属性，格式如 ："${user.dir}"
    location = getReaderContext().getEnvironment().resolveRequiredPlaceholders(location);

    Set<Resource> actualResources = new LinkedHashSet<>(4);

    // 判断 location 是相对路径还是绝对路径
    boolean absoluteLocation = false;
    try {
        absoluteLocation = ResourcePatternUtils.isUrl(location) || ResourceUtils.toURI(location).isAbsolute();
    }
    catch (URISyntaxException ex) {
        // cannot convert to an URI, considering the location relative
        // unless it is the well-known Spring prefix "classpath*:"
    }

    // 绝对路径
    if (absoluteLocation) {
        try {
            // 直接根据地址加载相应的配置文件
            int importCount = getReaderContext().getReader().loadBeanDefinitions(location, actualResources);
            if (logger.isDebugEnabled()) {
                logger.debug("Imported " + importCount + " bean definitions from URL location [" + location + "]");
            }
        }
        catch (BeanDefinitionStoreException ex) {
            getReaderContext().error(
                    "Failed to import bean definitions from URL location [" + location + "]", ele, ex);
        }
    }
    else {
        // 相对路径则根据相应的地址计算出绝对路径地址
        try {
            int importCount;
            Resource relativeResource = getReaderContext().getResource().createRelative(location);
            if (relativeResource.exists()) {
                importCount = getReaderContext().getReader().loadBeanDefinitions(relativeResource);
                actualResources.add(relativeResource);
            }
            else {
                String baseLocation = getReaderContext().getResource().getURL().toString();
                importCount = getReaderContext().getReader().loadBeanDefinitions(
                        StringUtils.applyRelativePath(baseLocation, location), actualResources);
            }
            if (logger.isDebugEnabled()) {
                logger.debug("Imported " + importCount + " bean definitions from relative location [" + location + "]");
            }
        }
        catch (IOException ex) {
            getReaderContext().error("Failed to resolve current resource location", ele, ex);
        }
        catch (BeanDefinitionStoreException ex) {
            getReaderContext().error("Failed to import bean definitions from relative location [" + location + "]",
                    ele, ex);
        }
    }
    // 解析成功后，进行监听器激活处理
    Resource[] actResArray = actualResources.toArray(new Resource[0]);
    getReaderContext().fireImportProcessed(location, actResArray, extractSource(ele));
}

解析 import 过程较为清晰，整个过程如下：

  1. 获取 source 属性的值，该值表示资源的路径
  2. 解析路径中的系统属性，如”${user.dir}”
  3. 判断资源路径 location 是绝对路径还是相对路径
  4. 如果是绝对路径，则调递归调用 Bean 的解析过程，进行另一次的解析
  5. 如果是相对路径，则先计算出绝对路径得到 Resource，然后进行解析
  6. 通知监听器，完成解析

判断路径

方法通过以下方法来判断 location 是为相对路径还是绝对路径：

absoluteLocation = ResourcePatternUtils.isUrl(location) || ResourceUtils.toURI(location).isAbsolute();

判断绝对路径的规则如下：

  • 以 classpath*: 或者 classpath: 开头为绝对路径
  • 能够通过该 location 构建出 java.net.URL为绝对路径
  • 根据 location 构造 java.net.URI 判断调用 isAbsolute() 判断是否为绝对路径

如果 location 为绝对路径则调用 loadBeanDefinitions()，该方法在 AbstractBeanDefinitionReader 中定义。

public int loadBeanDefinitions(String location, @Nullable Set<Resource> actualResources) throws BeanDefinitionStoreException {
    ResourceLoader resourceLoader = getResourceLoader();
    if (resourceLoader == null) {
        throw new BeanDefinitionStoreException(
                "Cannot import bean definitions from location [" + location + "]: no ResourceLoader available");
    }

    if (resourceLoader instanceof ResourcePatternResolver) {
        // Resource pattern matching available.
        try {
            Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);
            int loadCount = loadBeanDefinitions(resources);
            if (actualResources != null) {
                for (Resource resource : resources) {
                    actualResources.add(resource);
                }
            }
            if (logger.isDebugEnabled()) {
                logger.debug("Loaded " + loadCount + " bean definitions from location pattern [" + location + "]");
            }
            return loadCount;
        }
        catch (IOException ex) {
            throw new BeanDefinitionStoreException(
                    "Could not resolve bean definition resource pattern [" + location + "]", ex);
        }
    }
    else {
        // Can only load single resources by absolute URL.
        Resource resource = resourceLoader.getResource(location);
        int loadCount = loadBeanDefinitions(resource);
        if (actualResources != null) {
            actualResources.add(resource);
        }
        if (logger.isDebugEnabled()) {
            logger.debug("Loaded " + loadCount + " bean definitions from location [" + location + "]");
        }
        return loadCount;
    }
}

整个逻辑比较简单，首先获取 ResourceLoader，然后根据不同的 ResourceLoader 执行不同的逻辑，主要是可能存在多个 Resource，但是最终都会回归到 XmlBeanDefinitionReader.loadBeanDefinitions() ，所以这是一个递归的过程。

至此，import 标签解析完毕，整个过程比较清晰明了：获取 source 属性值，得到正确的资源路径，然后调用 loadBeanDefinitions() 方法进行递归的 BeanDefinition 加载。

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

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

相关文章

vue 组件通信

vue 组件通信

vue 组件通信 mytitile 是变量 title 是形参 回调函数
阅读更多...
RocketMQ 线上问题处理

RocketMQ 线上问题处理

一、发送超时后&#xff0c;重试发送 1.1、问题 生产者发送超时&#xff0c;进行重试发送。 1.2、解决 消费端做幂等处理。
阅读更多...
在使用SpringBoot时遇到的异常总结（持续更新...）

在使用SpringBoot时遇到的异常总结（持续更新...）

文章目录 异常MyBatisjava.sql.SQLIntegrityConstraintViolationException: Cannot add or update a child row: a foreign key constraint failsMybatis-Plus查询语句无故自动加条件Mybatis No enum constant org.apache.ibatis.type.JdbcType.TEXT 参考文献 因为平时在写Spri…
阅读更多...
pandas使用---Series/DataFrame

pandas使用---Series/DataFrame

借鉴 Pandas 常用函数 | 菜鸟教程Pandas 常用函数 以下列出了 Pandas 常用的一些函数及使用实例&#xff1a; 读取数据 函数说明 pd.read_csv(filename)读取 CSV 文件&#xff1b; pd.read_excel(filename)读取 Excel 文件&#xff1b; pd.read_sql(query, connection_object)…
阅读更多...
ElasticSearch从入门到精通（二）

ElasticSearch从入门到精通（二）

ElasticSearch 高级操作 bulk批量操作 批量操作-脚本 #批量操作 #1.删除5号 #新增8号 #更新2号 name为2号 POST _bulk {"delete":{"_index":"person1","_id":"5"}} {"create":{"_index":"person…
阅读更多...
jvm深入研究文档--程序执行专业户-虚拟机栈--jvm底层探索（2）

jvm深入研究文档--程序执行专业户-虚拟机栈--jvm底层探索（2）

阿丹&#xff1a; JVM的内存分区包括以下几个部分&#xff1a; 堆区&#xff08;Heap&#xff09; - 这是JVM的主要部分&#xff0c;用于存储实例对象和大多数Java对象&#xff0c;如数组和用户定义的类。 方法区&#xff08;Method Area&#xff09; - 这是线程私有的&#x…
阅读更多...
前端项目练习（练习-004-webpack-02）

前端项目练习（练习-004-webpack-02）

学习前&#xff0c;首先&#xff0c;创建一个web-004项目&#xff0c;内容和web-003一样。&#xff08;注意将package.json中的name改为web-004&#xff09; 前面的例子&#xff0c;成功将js文件打包到了dist中&#xff0c;但是我们有三个文件&#xff0c;css&#xff0c;js和h…
阅读更多...
微信公众号开发（BUG集）

微信公众号开发（BUG集）

1.微信公众平台接口错误:不合法的自定义菜单使用用户 地址&#xff1a;解决地址 2.微信公众平台接口错误:invalid ip 180.101.72.196 ipv6 ::ffff:180.101.72.196, not in whitelist rid: 6511420b-60c59249-01084d02 白名单离开放服务器IP
阅读更多...
第六章 Scala if..else与循环

第六章 Scala if..else与循环

1 IF…ELSE 语句 Scala IF…ELSE 语句是通过一条或多条语句的执行结果&#xff08;True或者False&#xff09;来决定执行的代码块。 1.1 if 语句 if 语句有布尔表达式及之后的语句块组成。 if(布尔表达式) {// 如果布尔表达式为 true 则执行该语句块 }如果布尔表达式为 tru…
阅读更多...
BUUCTF SimpleRev

BUUCTF SimpleRev

题目&#xff1a;BUUCTF SimpleRev 查壳&#xff0c;没壳&#xff0c;64位 ida打开一通分析 main(): while ( 1 ){while ( 1 ){printf("Welcome to CTF game!\nPlease input d/D to start or input q/Q to quit this program: ");v4 getchar();if ( v4 ! 100 &…
阅读更多...
Marvell/Cisco/Broadcom 三巨头的51.2T交换芯片

Marvell/Cisco/Broadcom 三巨头的51.2T交换芯片

最近在恶补Freya产品100/200/400/800GE AN/LT端口自适应和链路学习的知识&#xff0c;主要用在基于56Gb/s 的400G&#xff0c;112GGb/s的800G&#xff0c;和1.6Tbps高速接口上&#xff0c;当其使用DAC/AEC/ACC cable时&#xff0c;如果实现端口性能的自动调整。好奇的去拓展了下…
阅读更多...
浅谈低压电力电容器常见故障分析及预防措施

浅谈低压电力电容器常见故障分析及预防措施

安科瑞 华楠 【摘要】为了可以有效实现提高电力电容器故障解决效率&#xff0c;就需要针对其故障诊断技术展开研究&#xff0c;而状态量监测作为提高故障诊断技术效率与质量重要因素&#xff0c;其对电力电容器故障诊断工作而言&#xff0c;有着重要影响意义。基于此&#xff…
阅读更多...
多来客推出新版短视频矩阵系统，携手灰豚AI大模型引领行业革新。

多来客推出新版短视频矩阵系统，携手灰豚AI大模型引领行业革新。

9月20日&#xff0c;本地生活行业代表多来客本地生活服务saas系统又上线新版短视频矩阵群控功能&#xff0c;并引入灰豚ai大模型,为商家全面解决了矩阵群控营销的痛点。该系统为本地生活服务商业内首创。 短视频矩阵群控系统 多来客上线于2022年3月份,是国内著名的短视频平台本…
阅读更多...
SpringBoot 学习（十）分布式理论

SpringBoot 学习（十）分布式理论

12. 分布式理论 12.1 简介 分布式系统是若干独立计算机的集合&#xff0c;这些计算机对于用户来说就像单个相关系统。 分布式是一组通过网络进行通信、为了完成共同的任务而协调工作的计算机节点组成的系统&#xff0c;其目的是利用更多的机器&#xff0c;处理更多的数据。 …
阅读更多...
Vieworks首款采用CoF接口的工业相机亮相！

Vieworks首款采用CoF接口的工业相机亮相！

Vieworks首款CoF(CoaXPress-over-Fiber&#xff09;接口数字相机&#xff0c;具有高速度、高分辨率。 VC-21MDF-M/C460I在2100万全分辨率下可达到454fps的速率。CoF这个新接口支持传输高达80 Gbps的图像数据&#xff0c;加之配备Vieworks的创新技术&#xff0c;该相机不仅帧速…
阅读更多...
钻孔主轴铝铸件微小孔φ2mm钻孔加工方案

钻孔主轴铝铸件微小孔φ2mm钻孔加工方案

随着工业技术的不断发展&#xff0c;铝铸件在现代制造业中发挥着越来越重要的作用。而在铝铸件的制造过程中&#xff0c;微小孔加工一直是一个重要而又具有挑战性的工艺。在这个过程中&#xff0c;钻孔主轴作为一种重要的工具&#xff0c;可以有效地完成铝铸件微小孔的加工。 …
阅读更多...
[C++随笔录] list使用

[C++随笔录] list使用

list使用 构造函数insert && 迭代器push_back && pop_back && push_front && pop_fronterasesort && find && reverse list的底层结构就是 带头双向循环链表 构造函数 // 默认构造 list<int> lt; cout << "l…
阅读更多...
PyQt5 自定义开关按钮（2）

PyQt5 自定义开关按钮（2）

效果展示 代码展示 from PyQt5.QtCore import Qt, pyqtSignal, QTimer, QRectF, QRect from PyQt5.QtGui import QFont, QColor, QPainter, QPainterPath from PyQt5.QtWidgets import QWidgetclass SwitchBtn(QWidget):clicked = pyqtSignal(bool)# 组件常量BORDER_WIDTH = 4…
阅读更多...
【LeetCode-简单题】501. 二叉搜索树中的众数

【LeetCode-简单题】501. 二叉搜索树中的众数

文章目录 题目方法一&#xff1a;暴力哈希方法二&#xff1a;利用二叉搜索树的特性&#xff08;递归双指针&#xff09; 题目 方法一&#xff1a;暴力哈希 这是针对于普通二叉树的解法 统计number出现次数 然后将次数最大的众数集 取出来 Map<Integer , Integer > map …
阅读更多...
世界前沿技术发展报告2023《世界信息技术发展报告》（五）先进计算技术

世界前沿技术发展报告2023《世界信息技术发展报告》（五）先进计算技术

&#xff08;五&#xff09;先进计算技术 1. 概述2. 超级计算机2.1 美国首台E级超级计算机Crusher上线试运行2.2 欧洲最强大的超级计算机落成2.3 美国英伟达与微软公司联合开发人工智能超级计算机 3. 新型计算技术3.1 中国北京航空航天大学提出“混合概率逻辑计算”机制3.2 奥地…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023