《SpringBoot系列十五》源码+案例分析条件装配时多个Condition执行的顺序是什么样的?可以配置优先级吗?

本文涉及的产品
全局流量管理 GTM,标准版 1个月
云解析 DNS,旗舰版 1个月
公共DNS(含HTTPDNS解析),每月1000万次HTTP解析
简介: 《SpringBoot系列十五》源码+案例分析条件装配时多个Condition执行的顺序是什么样的?可以配置优先级吗?

@[TOC]

一、前言

针对条件装配我们讨论了如下内容:

  1. 《SpringBoot系列十一》:精讲如何使用@Conditional系列注解做条件装配
  2. 《SpringBoot系列十二》:如何自定义条件装配(由@ConditionalOnClass推导)
  3. 《SpringBoot启动流程六》:SpringBoot自动装配时做条件装配的原理(万字图文源码分析)(含@ConditionalOnClass原理)
  4. 《SpringBoot系列十三》:图文精讲@Conditional条件装配实现原理
  5. 《SpringBoot系列十四》:@ConditionalOnBean、@ConditionalOnMissingBean注解居然失效了!

本文我们接着讨论多个Condition的执行顺序。

二、多个Condition的排序

在博文<《SpringBoot系列十三》:图文精讲@Conditional条件装配实现原理>中,我们讨论了Condition条件装配的原理,其中介绍了条件装配如何执行?入口为:ConditionEvaluator#shouldSkip(AnnotatedTypeMetadata,ConfigurationPhase)方法,其返回值为boolean类型,方法返回true表示当前类应该被过滤掉(即不符合条件装配的规则)、否则表示当前类应该被留下(即符合条件装配的规则)。

/**
 * Determine if an item should be skipped based on {@code @Conditional} annotations.
 * @param metadata the meta data
 * @param phase the phase of the call
 * @return if the item should be skipped
 */
public boolean shouldSkip(@Nullable AnnotatedTypeMetadata metadata, @Nullable ConfigurationPhase phase) {
    // 如果类没被@Conditional衍生注解标注,则直接返回FALSE,表示当前类不应该被过滤掉
    if (metadata == null || !metadata.isAnnotated(Conditional.class.getName())) {
        return false;
    }

    // 如果没设置条件装配的阶段,当类是配置类时,为 PARSE_CONFIGURATION 阶段,否则默认为 REGISTER_BEAN 阶段
    if (phase == null) {
        if (metadata instanceof AnnotationMetadata &&
                ConfigurationClassUtils.isConfigurationCandidate((AnnotationMetadata) metadata)) {
            return shouldSkip(metadata, ConfigurationPhase.PARSE_CONFIGURATION);
        }
        return shouldSkip(metadata, ConfigurationPhase.REGISTER_BEAN);
    }

    // 获取类上所有的@Conditional 子注解,返回@Conditional注解中的value值
    List<Condition> conditions = new ArrayList<>();
    for (String[] conditionClasses : getConditionClasses(metadata)) {
        for (String conditionClass : conditionClasses) {
            Condition condition = getCondition(conditionClass, this.context.getClassLoader());
            conditions.add(condition);
        }
    }

    // 对获取到的所有Condition接口的实现类进行排序
    AnnotationAwareOrderComparator.sort(conditions);

    // 遍历所有的Condition,进行match
    for (Condition condition : conditions) {
        ConfigurationPhase requiredPhase = null;
        if (condition instanceof ConfigurationCondition) {
            // 获取当前Condition的执行阶段
            requiredPhase = ((ConfigurationCondition) condition).getConfigurationPhase();
        }
        // 如果入参传入的阶段和Condition的阶段不同,直接返回FALSE。
        // 如果阶段相同 或 Condition的阶段为null,再使用Condition#matches(this.context, metadata)做真正的条件装配逻辑,不符合则返回TRUE。
        if ((requiredPhase == null || requiredPhase == phase) && !condition.matches(this.context, metadata)) {
            return true;
        }
    }

    return false;
}
AI 代码解读

shouldSkip()方法执行的逻辑概括如下:

  1. 首先,如果入参类 为 null 或者 没有被@Conditional衍生注解标注,则直接返回FALSE,表示当前类不应该被过滤掉;
  2. 如果入参没有传条件装配的阶段;当类是配置类时,为 PARSE_CONFIGURATION 阶段,否则默认为 REGISTER_BEAN 阶段;
  3. 接着,获取类上所有的@Conditional 子注解,返回@Conditional注解中的value值。并对获取到的所有Condition接口的实现类进行排序。
  4. 遍历所有的Condition,进行匹配;如果入参传入的阶段和Condition的阶段不同,直接返回FALSE。如果阶段相同 或 Condition的阶段为null,再使用Condition#matches(this.context, metadata)做真正的条件装配逻辑,不符合则返回TRUE。

本文要讨论的多个Condition执行的顺序,就体现在AnnotationAwareOrderComparator.sort(conditions);方法。

1、对多个Condition排序

在博文《SpringBoot启动流程一》:万字debug梳理SpringBoot如何加载并处理META-INF/spring.factories文件中的信息我们有讨论过对所有自动装配类的排序,其实和这里是一样的,本文对其进行更细粒度的讨论;

进入到AnnotationAwareOrderComparator.sort(conditions)方法中;

AnnotationAwareOrderComparator.sort(conditions);
AI 代码解读

sort()方法中直接使用List集合的sort()方法,但需要自定义Comparator为当前类实例AnnotationAwareOrderComparator
在这里插入图片描述
再看AnnotationAwareOrderComparator的类结构:
在这里插入图片描述
AnnotationAwareOrderComparator继承自OrderComparator,自定义Comparator需要实现Comparator的抽象方法compare(T o1, T o2)。由于AnnotationAwareOrderComparator自身没有compare()方法,所以看其父类OrderComparator中的compare(Object o1, Object o2)方法;

@Override
public int compare(@Nullable Object o1, @Nullable Object o2) {
    return doCompare(o1, o2, null);
}

private int doCompare(@Nullable Object o1, @Nullable Object o2, @Nullable OrderSourceProvider sourceProvider) {
    // 判断o1是否实现PriorityOrdered接口
    boolean p1 = (o1 instanceof PriorityOrdered);
    // 判断o2是否实现PriorityOrdered接口
    boolean p2 = (o2 instanceof PriorityOrdered);
    // 如果o1实现了PriorityOrdered接口 而 o2没实现,则按 o1 在 o2之前的顺序排序(从集合中的排序来看就是交换o1 和 o2的位置)
    if (p1 && !p2) {
        return -1;
    }
    // 如果o2实现了PriorityOrdered接口 而 o1没实现,则按 o2在o1之前的顺序排序(从集合中的排序来看o2和o1的位置不变)
    else if (p2 && !p1) {
        return 1;
    }

    // 如果o2和o1都实现了 或 都没实现PriorityOrdered接口,则比对两者的顺序值。
    int i1 = getOrder(o1, sourceProvider);
    int i2 = getOrder(o2, sourceProvider);
    return Integer.compare(i1, i2);
}
AI 代码解读

方法逻辑如下:

  1. 本来的集合中的顺序是o2,o1;而入参参数的先后是顺序o1,o2,如果保持(o2 < o1)的顺序就返回1 或 0,交换o2和o1顺序就返回-1,0的含义是在两个元素相同时,不交换顺序(为了排序算法的稳定性,可以使用1来代替0,不要用-1来代替0)。即:想要升序,返回-1;降序返回1。详情见Arrays.sort()方法源码
  2. 实现PriorityOrdered接口的放前面,如果都实现了PriorityOrdered接口 或 都没实现,则根据获取到的顺序值对比排序。

因为OrderComparator#doCompare(Object o1, Object o2, OrderSourceProvider sourceProvider)方法中的入参sourceProvider为null,所以进入到getOrder()方法时,后续直接调用子类的findOrder(Object obj)方法去查找相应类的顺序值。
在这里插入图片描述

1)AnnotationAwareOrderComparator#findOrder()方法:

@Override
@Nullable
protected Integer findOrder(Object obj) {
    Integer order = super.findOrder(obj);
    if (order != null) {
        return order;
    }
    return findOrderFromAnnotation(obj);
}
AI 代码解读

先调用父类OrderComparator#findOrder()方法,如果找到顺序值直接返回,否者从类的@Order注解中取到顺序值。下面我们分别看OrderComparator#findOrder()方法和AnnotationAwareOrderComparator#findOrderFromAnnotation()方法。

1> OrderComparator#findOrder()方法:

@Nullable
protected Integer findOrder(Object obj) {
    return (obj instanceof Ordered ? ((Ordered) obj).getOrder() : null);
}
AI 代码解读

该方法判断obj有没有实现Ordered接口,实现Ordered接口之后,有没有重写其getOrder()方法,如果重写了,则直接从getOrder()中获取到序列值;否则返回null;

往上返,回到OrderComparator#findOrder()方法中;如果通过OrderComparator#findOrder()获取不到顺序值,即返回null,AnnotationAwareOrderComparator会再通过findOrderFromAnnotation()方法从@Order注解中获取顺序值。

2> AnnotationAwareOrderComparator#findOrderFromAnnotation()方法:

@Nullable
private Integer findOrderFromAnnotation(Object obj) {
    AnnotatedElement element = (obj instanceof AnnotatedElement ? (AnnotatedElement) obj : obj.getClass());
    MergedAnnotations annotations = MergedAnnotations.from(element, SearchStrategy.TYPE_HIERARCHY);
    Integer order = OrderUtils.getOrderFromAnnotations(element, annotations);
    if (order == null && obj instanceof DecoratingProxy) {
        return findOrderFromAnnotation(((DecoratingProxy) obj).getDecoratedClass());
    }
    return order;
}
AI 代码解读

findOrderFromAnnotation()方法中通过OrderUtils.getOrderFromAnnotations(element, annotations);获取@Order注解中的值;
在这里插入图片描述

3> 进入OrderUtils#getOrderFromAnnotations()方法:

@Nullable
static Integer getOrderFromAnnotations(AnnotatedElement element, MergedAnnotations annotations) {
    // 这里默认不会走
    if (!(element instanceof Class)) {
        return findOrder(annotations);
    }
    // 从缓存中获取,默认为null
    Object cached = orderCache.get(element);
    if (cached != null) {
        return (cached instanceof Integer ? (Integer) cached : null);
    }
    // 查找类上是否有@Order注解,如果有,返回@Order注解中的Value值,否者返回null;
    Integer result = findOrder(annotations);
    orderCache.put(element, result != null ? result : NOT_ANNOTATED);
    return result;
}
AI 代码解读

方法逻辑:

  1. 首先从缓冲中获取顺序值,默认为null,即获取不到。
  2. 接着通过findOrder(MergedAnnotations)方法查找类上是否有@Order注解,如果没有返回null,否则返回@Order注解中的Value值;
  3. findOrder(MergedAnnotations)方法执行完之后,将查询到的@Order中的value值写入到缓存orderCache中。

4> 进入OrderUtils#findOrder()方法:

@Nullable
private static Integer findOrder(MergedAnnotations annotations) {
    // 获取到类上的@Order注解
    MergedAnnotation<Order> orderAnnotation = annotations.get(Order.class);
    // 如果@Order注解存在,则返回@Order注解的Value值
    if (orderAnnotation.isPresent()) {
        return orderAnnotation.getInt(MergedAnnotation.VALUE);
    }
    // 如果@Order注解不存在,继续判断类上是否有`javax.annotation.Priority`注解
    MergedAnnotation<?> priorityAnnotation = annotations.get(JAVAX_PRIORITY_ANNOTATION);
    if (priorityAnnotation.isPresent()) {
        return priorityAnnotation.getInt(MergedAnnotation.VALUE);
    }
    // 如果两个注解都没有,则返回null。
    return null;
}
AI 代码解读

最后返回到OrderComparator#getOrder()方法,如果通过子类AnnotationAwareOrderComparator的findOrder(Object)方法获取到的order为null,则此处将Order设置为Integer.MAX_VALUE
在这里插入图片描述
<br/>
注意:如果两个对象的Order顺序值一样,则按原本在集合中的顺序先后排列
<br/>

2)List集合中的顺序是怎样的?

private List<String[]> getConditionClasses(AnnotatedTypeMetadata metadata) {
    // 获取类上所有@Conditional注解中的全部Condition
    MultiValueMap<String, Object> attributes = metadata.getAllAnnotationAttributes(Conditional.class.getName(), true);
    Object values = (attributes != null ? attributes.get("value") : null);
    return (List<String[]>) (values != null ? values : Collections.emptyList());
}
AI 代码解读

通过ConditionEvaluator#getConditionClasses(AnnotatedTypeMetadata)方法获取类上所有@Conditional注解中的全部Condition,获取次序为:类上的注解从上至下、@Conditional中的Condition集合从左到右。

在这里插入图片描述
下面我们用案例来例证这个结论。

3)排序总述

首先通过通过ConditionEvaluator#getConditionClasses(AnnotatedTypeMetadata)方法获取类上所有@Conditional注解中的全部Condition,获取次序为:类上的注解从上至下、@Conditional中的Condition集合从左到右。,返回一个List<Condition>集合。

然后利用List集合自身的排序,通过传入自定义的Comparator 实现排序规则。具体规则如下:

自定义Comparator需要实现compare(Object o1, Object o2)方法,AnnotationAwareOrderComparator类继承自OrderComparator,由于AnnotationAwareOrderComparator没有重写compare(Object o1, Object o2)方法,所以排序规则体现在OrderComparator的compare(Object o1, Object o2)方法中,进而进入到其doCompare(Object o1, Object o2, OrderSourceProvider sourceProvider)方法中;

  1. 比如:有两个需要被排序的对象o2, o1,它在原List集合中的位置顺序为o2, o1。
  2. 首先进行PriorityOrdered判断:

    • 如果o1对象实现了PriorityOrdered接口,o2对象没实现,返回-1,即交换o2 和 o1的位置,将o1 放在o2前面;
    • 如果o2对象实现了PriorityOrdered接口,o1对象没实现,返回1,即o2 和 o1的位置保持不变,o2 仍在o1前面;
    • 否则,如果o1 和 o2对象同时实现了PriorityOrdered接口 或 都没实现,则通过OrderComparator#getOrder()方法分别获取到 o2 和 o1对象的顺序值;
  3. OrderComparator#getOrder(Object, OrderSourceProvider)方法中:

    1. 首先通过OrderComparator#findOrder()方法查找顺序值,而AnnotationAwareOrderComparator重写了findOrder()方法,所以直接进入到AnnotationAwareOrderComparator#findOrder()方法。
    2. 在AnnotationAwareOrderComparator#findOrder()方法中,会先调用其父类OrderComparator#findOrder()方法判断对象是否实现Ordered接口 并 重写了getOrder()方法,有则返回getOrder()方法的返回值。
    3. 否则,通过findOrderFromAnnotation()方法从注解中获取顺序值(优先走orderCache缓存获取,获取不到才会进行如下逻辑,走如下逻辑获取到之后,再放去orderCache缓存中):
       1> 首先从对象的@Order注解中获取其value值,有则会返回;
       2> 否者从对象的`javax.annotation.Priority`注解中获取其Value值,有则返回,
       3> 否者,返回null
    AI 代码解读
  4. 回到OrderComparator#getOrder()层面,如果findOrder()返回了具体的Integer值,则返回,否者返回Integer.MAX_VALUE。
  5. 最后,回到OrderComparator#doCompare()方法,返回Integer.compare(i1, i2)的结果,按顺序值的升序排序(即:顺序值小的在前面、大的在后面)

2、Condition排序案例

从上面的讨论我们可以得知排序规则:如果Condition实现了PriorityOrdered接口,则放在最前面一部分;接着依次通过 <实现Ordered接口的getOrder()方法返回顺序值>、<从@Order注解中的Value值获取到顺序值返回> 、<从javax.annotation.Priority注解中的Value值获取到顺序值返回>,如果通过上面三种方式都没有获取到顺序值,则返回Integer.MAX_VALUE

1)代码目录

自定义Condition参考博文:《SpringBoot系列十二》:如何自定义条件装配

整体代码目录结构如下:
在这里插入图片描述

1> @ConditionalOnSystemProperty

package com.saint.autoconfigure.condition;

import org.springframework.context.annotation.Conditional;

import java.lang.annotation.*;

/**
 * 系统属性名称与属性值匹配条件注解
 *
 * @author Saint
 */
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Conditional({OnSystemPropertyCondition.class, MyCondition.class})
public @interface ConditionalOnSystemProperty {

    /**
     * 属性名
     *
     * @return
     */
    String name();

    /**
     * 属性值
     *
     * @return
     */
    String value();
}
AI 代码解读

2> MyCondition

package com.saint.autoconfigure.condition;

import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.core.PriorityOrdered;
import org.springframework.core.type.AnnotatedTypeMetadata;

/**
 *
 * @author Saint
 */
public class MyCondition implements Condition, PriorityOrdered {
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        return true;
    }

    @Override
    public int getOrder() {
        return 0;
    }
}
AI 代码解读

3> OnSystemPropertyCondition

package com.saint.autoconfigure.condition;

import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.core.type.AnnotatedTypeMetadata;
import org.springframework.util.MultiValueMap;

import java.util.Objects;

/**
 * 系统属性值与值匹配条件
 *
 * @author Saint
 */
public class OnSystemPropertyCondition implements Condition {
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        MultiValueMap<String, Object> attributes =
                metadata.getAllAnnotationAttributes(ConditionalOnSystemProperty.class.getName());
        String name = (String) attributes.getFirst("name");
        String value = (String) attributes.getFirst("value");
        String systemPropertyValue = System.getProperty(name);
        // 比较系统属性值和方法的值
        if (Objects.equals(systemPropertyValue, value)) {
            System.out.printf("系统属性【名称: %s】找到匹配值:%s \n", name, value);
            return true;
        }
        return false;
    }
}
AI 代码解读

4> ClassX

package com.saint;

import com.saint.autoconfigure.condition.ConditionalOnSystemProperty;
import com.saint.service.TestService;
import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.context.annotation.Configuration;

/**
 * @author Saint
 */
@Configuration
@ConditionalOnClass(ClassY.class)
@ConditionalOnBean(TestService.class)
@ConditionalOnSystemProperty(name = "language", value = "Chinese")
public class ClassX {

    public ClassX() {
        System.out.println("初始化了ClassX!");
    }
}
AI 代码解读

5> ClassY

package com.saint;

/**
 * @author Saint
 */
public class ClassY {

    public ClassY() {
        System.out.println("初始化了ClassY!");
    }
}
AI 代码解读

6> 启动类

package com.saint;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;

@SpringBootApplication
//@Import(TestImportClassA.class)
public class SaintSpringbootApplication {

    public static void main(String[] args) {
        // 设置language属性值
        System.setProperty("language", "Chinese");

        ConfigurableApplicationContext context = SpringApplication.run(SaintSpringbootApplication.class, args);

        // 从Spring上下文中获取beanName为message的类
        String message = context.getBean("message", String.class);
        System.out.println("当前message类型为:" + message);
    }

}
AI 代码解读

2)Condition的顺序

以上面自定义的ClassX为例:
在这里插入图片描述
其获取到的Condition的顺序为:OnClassCondition、OnBeanCondition、OnSystemPropertyCondition、MyCondition,这个排序的规则,正如我们上面所说:获取次序为:类上的注解从上至下、@Conditional中的Condition集合从左到右。

再看排序后的结果:
在这里插入图片描述
由于只有MyCondition实现了PriorityOrdered接口,所以它在最前面,另外三个的顺序值都是一次按照顺序值大小排序。

三、总结

从自动装配类的条件装配来看,一般选择将Class Conditions类注解(@ConditionalOnClass、@ConditionalOnMissingClass) 放在最前面、Property Conditions类注解(@ConditionalOnProperty)其次、Bean Conditions类注解(@ConditionalOnBean、@ConditionalOnMissingBean)放最后。当然也还有其他种类的条件注解,一般常用的是这三种。
在这里插入图片描述
再结合配置类加载的两个阶段(配置类解析、注册Bean<见博文:《SpringBoot系列十三》:图文精讲@Conditional条件装配实现原理>)来看:

1> 自动装配类:

  • 自动装配类在配置类解析阶段会对Bean Conditions之外的条件注解做判断;而Bean Condtions类注解需要到注册bean阶段才会生效。

2> @Component标注的类:

  • 同样的@Component衍生注解标注的类 在配置类解析阶段会对Bean Conditions之外的条件注解做判断,与此同时也会注入到Spring的临时容器beanDefinitionNames,所以针对@Component标注的类而言,Bean Conditions可能会在配置类解析阶段生效、也可能不会生效;所以最终还是要在注册Bean阶段做一个全面的条件装配。不过一般而言,正常业务中不会有人在@Component衍生注解里搞条件装配(@Configuration除外),通常都在在自动装配类中做那么个操作。
相关文章
|
30天前
基于springboot+thymeleaf+Redis仿知乎网站问答项目源码
基于springboot+thymeleaf+Redis仿知乎网站问答项目源码
131 36
基于SpringBoot+Vue实现的留守儿童爱心网站设计与实现(计算机毕设项目实战+源码+文档)
博主是一位全网粉丝超过100万的CSDN特邀作者、博客专家,专注于Java、Python、PHP等技术领域。提供SpringBoot、Vue、HTML、Uniapp、PHP、Python、NodeJS、爬虫、数据可视化等技术服务,涵盖免费选题、功能设计、开题报告、论文辅导、答辩PPT等。系统采用SpringBoot后端框架和Vue前端框架,确保高效开发与良好用户体验。所有代码由博主亲自开发,并提供全程录音录屏讲解服务,保障学习效果。欢迎点赞、收藏、关注、评论,获取更多精品案例源码。
59 10
基于SpringBoot+Vue实现的家政服务管理平台设计与实现(计算机毕设项目实战+源码+文档)
面向大学生毕业选题、开题、任务书、程序设计开发、论文辅导提供一站式服务。主要服务:程序设计开发、代码修改、成品部署、支持定制、论文辅导,助力毕设!
43 8
基于SpringBoot+Vue实现的家乡特色推荐系统设计与实现(源码+文档+部署)
面向大学生毕业选题、开题、任务书、程序设计开发、论文辅导提供一站式服务。主要服务:程序设计开发、代码修改、成品部署、支持定制、论文辅导,助力毕设!
54 8
基于SpringBoot+Vue实现的大学生就业服务平台设计与实现(系统源码+文档+数据库+部署等)
面向大学生毕业选题、开题、任务书、程序设计开发、论文辅导提供一站式服务。主要服务:程序设计开发、代码修改、成品部署、支持定制、论文辅导,助力毕设!
63 6
基于Java+SpringBoot+Vue实现的车辆充电桩系统设计与实现(系统源码+文档+部署讲解等)
面向大学生毕业选题、开题、任务书、程序设计开发、论文辅导提供一站式服务。主要服务:程序设计开发、代码修改、成品部署、支持定制、论文辅导,助力毕设!
55 6
基于SpringBoot+Vue的班级综合测评管理系统设计与实现(系统源码+文档+数据库+部署等)
✌免费选题、功能需求设计、任务书、开题报告、中期检查、程序功能实现、论文辅导、论文降重、答辩PPT辅导、会议视频一对一讲解代码等✌
40 4
基于SpringBoot+Vue实现的高校食堂移动预约点餐系统设计与实现(源码+文档+部署)
面向大学生毕业选题、开题、任务书、程序设计开发、论文辅导提供一站式服务。主要服务:程序设计开发、代码修改、成品部署、支持定制、论文辅导,助力毕设!
66 3
基于SpringBoot+Vue实现的大学生体质测试管理系统设计与实现(系统源码+文档+数据库+部署)
面向大学生毕业选题、开题、任务书、程序设计开发、论文辅导提供一站式服务。主要服务:程序设计开发、代码修改、成品部署、支持定制、论文辅导,助力毕设!
36 2
基于SpringBoot+Vue实现的冬奥会科普平台设计与实现(系统源码+文档+数据库+部署)
面向大学生毕业选题、开题、任务书、程序设计开发、论文辅导提供一站式服务。主要服务:程序设计开发、代码修改、成品部署、支持定制、论文辅导,助力毕设!
41 0

热门文章

最新文章

AI助理

你好,我是AI助理

可以解答问题、推荐解决方案等