SpringBoot2.x 整合SpringDocJavadocknife4j实现无注解零入侵式接口文档

news2024/9/28 15:24:59

说明

基于 javadoc 无注解零入侵生成规范的 openapi 结构体。

文档工具使用

由于框架采用 openapi 行业规范 故市面上大部分的框架均支持 可自行选择
例如: apifox apipost postman torna knife4j 等 根据对应工具的文档接入即可

Swagger升级SpringDoc指南

常见功能如下 其他功能自行挖掘
注意: javadoc 只能替换基础功能 特殊功能还需要使用注解实现

swaggerspringdocjavadoc
@Api(name = “xxx”)@Tag(name = “xxx”)java类注释第一行
@Api(description= “xxx”)@Tag(description= “xxx”)java类注释
@ApiOperation@Operationjava方法注释
@ApiIgnore@Hidden无
@ApiParam@Parameterjava方法@param参数注释
@ApiImplicitParam@Parameterjava方法@param参数注释
@ApiImplicitParams@Parameters多个@param参数注释
@ApiModel@Schemajava实体类注释
@ApiModelProperty@Schemajava属性注释
@ApiModelProperty(hidden = true)@Schema(accessMode = READ_ONLY)无
@ApiResponse@ApiResponsejava方法@return返回值注释

Maven依赖

<dependency>
	<groupId>org.springdoc</groupId>
	<artifactId>springdoc-openapi-webmvc-core</artifactId>
	<version>1.6.14</version>
</dependency>

<dependency>
	<groupId>org.springdoc</groupId>
	<artifactId>springdoc-openapi-javadoc</artifactId>
	<version>1.6.14</version>
</dependency>

swagger 配置属性

package com.ruoyi.framework.config.properties;

import io.swagger.v3.oas.models.Components;
import io.swagger.v3.oas.models.ExternalDocumentation;
import io.swagger.v3.oas.models.Paths;
import io.swagger.v3.oas.models.info.Contact;
import io.swagger.v3.oas.models.info.License;
import io.swagger.v3.oas.models.tags.Tag;
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.context.properties.NestedConfigurationProperty;
import org.springframework.stereotype.Component;

import java.util.List;

/**
 * swagger 配置属性
 *
 * @author Lion Li
 */
@Data
@Component
@ConfigurationProperties(prefix = "springdoc")
public class SpringDocProperties {

    /**
     * 文档基本信息
     */
    @NestedConfigurationProperty
    private InfoProperties info = new InfoProperties();

    /**
     * 扩展文档地址
     */
    @NestedConfigurationProperty
    private ExternalDocumentation externalDocs;

    /**
     * 标签
     */
    private List<Tag> tags = null;

    /**
     * 路径
     */
    @NestedConfigurationProperty
    private Paths paths = null;

    /**
     * 组件
     */
    @NestedConfigurationProperty
    private Components components = null;

    /**
     * <p>
     * 文档的基础属性信息
     * </p>
     *
     * @see io.swagger.v3.oas.models.info.Info
     *
     * 为了 springboot 自动生产配置提示信息，所以这里复制一个类出来
     */
    @Data
    public static class InfoProperties {

        /**
         * 标题
         */
        private String title = null;

        /**
         * 描述
         */
        private String description = null;

        /**
         * 联系人信息
         */
        @NestedConfigurationProperty
        private Contact contact = null;

        /**
         * 许可证
         */
        @NestedConfigurationProperty
        private License license = null;

        /**
         * 版本
         */
        private String version = null;

    }

}

Swagger 文档配置

package com.ruoyi.framework.config;

import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.framework.config.properties.SpringDocProperties;
import com.ruoyi.framework.handler.OpenApiHandler;
import io.swagger.v3.oas.models.OpenAPI;
import io.swagger.v3.oas.models.Paths;
import io.swagger.v3.oas.models.info.Info;
import io.swagger.v3.oas.models.security.SecurityRequirement;
import lombok.RequiredArgsConstructor;
import org.springdoc.core.*;
import org.springdoc.core.customizers.OpenApiBuilderCustomizer;
import org.springdoc.core.customizers.OpenApiCustomiser;
import org.springdoc.core.customizers.ServerBaseUrlCustomizer;
import org.springdoc.core.providers.JavadocProvider;
import org.springframework.boot.autoconfigure.AutoConfigureBefore;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.autoconfigure.web.ServerProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.Set;

/**
 * Swagger 文档配置
 *
 * @author Lion Li
 */
@RequiredArgsConstructor
@Configuration
@AutoConfigureBefore(SpringDocConfiguration.class)
@ConditionalOnProperty(name = "springdoc.api-docs.enabled", havingValue = "true", matchIfMissing = true)
public class SpringDocConfig {

    private final ServerProperties serverProperties;

    @Bean
    @ConditionalOnMissingBean(OpenAPI.class)
    public OpenAPI openApi(SpringDocProperties properties) {
        OpenAPI openApi = new OpenAPI();
        // 文档基本信息
        SpringDocProperties.InfoProperties infoProperties = properties.getInfo();
        Info info = convertInfo(infoProperties);
        openApi.info(info);
        // 扩展文档信息
        openApi.externalDocs(properties.getExternalDocs());
        openApi.tags(properties.getTags());
        openApi.paths(properties.getPaths());
        openApi.components(properties.getComponents());
        Set<String> keySet = properties.getComponents().getSecuritySchemes().keySet();
        List<SecurityRequirement> list = new ArrayList<>();
        SecurityRequirement securityRequirement = new SecurityRequirement();
        keySet.forEach(securityRequirement::addList);
        list.add(securityRequirement);
        openApi.security(list);

        return openApi;
    }

    private Info convertInfo(SpringDocProperties.InfoProperties infoProperties) {
        Info info = new Info();
        info.setTitle(infoProperties.getTitle());
        info.setDescription(infoProperties.getDescription());
        info.setContact(infoProperties.getContact());
        info.setLicense(infoProperties.getLicense());
        info.setVersion(infoProperties.getVersion());
        return info;
    }

    /**
     * 自定义 openapi 处理器
     */
    @Bean
    public OpenAPIService openApiBuilder(Optional<OpenAPI> openAPI,
                                         SecurityService securityParser,
                                         SpringDocConfigProperties springDocConfigProperties, PropertyResolverUtils propertyResolverUtils,
                                         Optional<List<OpenApiBuilderCustomizer>> openApiBuilderCustomisers,
                                         Optional<List<ServerBaseUrlCustomizer>> serverBaseUrlCustomisers, Optional<JavadocProvider> javadocProvider) {
        return new OpenApiHandler(openAPI, securityParser, springDocConfigProperties, propertyResolverUtils, openApiBuilderCustomisers, serverBaseUrlCustomisers, javadocProvider);
    }

    /**
     * 对已经生成好的 OpenApi 进行自定义操作
     */
    @Bean
    public OpenApiCustomiser openApiCustomiser() {
        String contextPath = serverProperties.getServlet().getContextPath();
        String finalContextPath;
        if (StringUtils.isBlank(contextPath) || "/".equals(contextPath)) {
            finalContextPath = "";
        } else {
            finalContextPath = contextPath;
        }
        // 对所有路径增加前置上下文路径
        return openApi -> {
            Paths oldPaths = openApi.getPaths();
            if (oldPaths instanceof PlusPaths) {
                return;
            }
            PlusPaths newPaths = new PlusPaths();
            oldPaths.forEach((k,v) -> newPaths.addPathItem(finalContextPath + k, v));
            openApi.setPaths(newPaths);
        };
    }

    /**
     * 单独使用一个类便于判断 解决springdoc路径拼接重复问题
     *
     * @author Lion Li
     */
    static class PlusPaths extends Paths {

        public PlusPaths() {
            super();
        }
    }

}

自定义 openapi 处理器

package com.ruoyi.framework.handler;

import cn.hutool.core.io.IoUtil;
import io.swagger.v3.core.jackson.TypeNameResolver;
import io.swagger.v3.core.util.AnnotationsUtils;
import io.swagger.v3.oas.annotations.tags.Tags;
import io.swagger.v3.oas.models.Components;
import io.swagger.v3.oas.models.OpenAPI;
import io.swagger.v3.oas.models.Operation;
import io.swagger.v3.oas.models.Paths;
import io.swagger.v3.oas.models.tags.Tag;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springdoc.core.OpenAPIService;
import org.springdoc.core.PropertyResolverUtils;
import org.springdoc.core.SecurityService;
import org.springdoc.core.SpringDocConfigProperties;
import org.springdoc.core.customizers.OpenApiBuilderCustomizer;
import org.springdoc.core.customizers.ServerBaseUrlCustomizer;
import org.springdoc.core.providers.JavadocProvider;
import org.springframework.context.ApplicationContext;
import org.springframework.core.annotation.AnnotatedElementUtils;
import org.springframework.util.CollectionUtils;
import org.springframework.web.method.HandlerMethod;

import java.io.StringReader;
import java.lang.reflect.Method;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * 自定义 openapi 处理器
 * 对源码功能进行修改 增强使用
 */
@SuppressWarnings("all")
public class OpenApiHandler extends OpenAPIService {

    /**
     * The constant LOGGER.
     */
    private static final Logger LOGGER = LoggerFactory.getLogger(OpenAPIService.class);

    /**
     * The Context.
     */
    private ApplicationContext context;

    /**
     * The Security parser.
     */
    private final SecurityService securityParser;

    /**
     * The Mappings map.
     */
    private final Map<String, Object> mappingsMap = new HashMap<>();

    /**
     * The Springdoc tags.
     */
    private final Map<HandlerMethod, io.swagger.v3.oas.models.tags.Tag> springdocTags = new HashMap<>();

    /**
     * The Open api builder customisers.
     */
    private final Optional<List<OpenApiBuilderCustomizer>> openApiBuilderCustomisers;

    /**
     * The server base URL customisers.
     */
    private final Optional<List<ServerBaseUrlCustomizer>> serverBaseUrlCustomizers;

    /**
     * The Spring doc config properties.
     */
    private final SpringDocConfigProperties springDocConfigProperties;

    /**
     * The Open api.
     */
    private OpenAPI openAPI;

    /**
     * The Cached open api map.
     */
    private final Map<String, OpenAPI> cachedOpenAPI = new HashMap<>();

    /**
     * The Is servers present.
     */
    private boolean isServersPresent;

    /**
     * The Server base url.
     */
    private String serverBaseUrl;

    /**
     * The Property resolver utils.
     */
    private final PropertyResolverUtils propertyResolverUtils;

    /**
     * The javadoc provider.
     */
    private final Optional<JavadocProvider> javadocProvider;

    /**
     * The Basic error controller.
     */
    private static Class<?> basicErrorController;

    static {
        try {
            //spring-boot 2
            basicErrorController = Class.forName("org.springframework.boot.autoconfigure.web.servlet.error.BasicErrorController");
        } catch (ClassNotFoundException e) {
            //spring-boot 1
            try {
                basicErrorController = Class.forName("org.springframework.boot.autoconfigure.web.BasicErrorController");
            } catch (ClassNotFoundException classNotFoundException) {
                //Basic error controller class not found
                LOGGER.trace(classNotFoundException.getMessage());
            }
        }
    }

    /**
     * Instantiates a new Open api builder.
     *
     * @param openAPI                   the open api
     * @param securityParser            the security parser
     * @param springDocConfigProperties the spring doc config properties
     * @param propertyResolverUtils     the property resolver utils
     * @param openApiBuilderCustomizers the open api builder customisers
     * @param serverBaseUrlCustomizers  the server base url customizers
     * @param javadocProvider           the javadoc provider
     */
    public OpenApiHandler(Optional<OpenAPI> openAPI, SecurityService securityParser,
                          SpringDocConfigProperties springDocConfigProperties, PropertyResolverUtils propertyResolverUtils,
                          Optional<List<OpenApiBuilderCustomizer>> openApiBuilderCustomizers,
                          Optional<List<ServerBaseUrlCustomizer>> serverBaseUrlCustomizers,
                          Optional<JavadocProvider> javadocProvider) {
        super(openAPI, securityParser, springDocConfigProperties, propertyResolverUtils, openApiBuilderCustomizers, serverBaseUrlCustomizers, javadocProvider);
        if (openAPI.isPresent()) {
            this.openAPI = openAPI.get();
            if (this.openAPI.getComponents() == null)
                this.openAPI.setComponents(new Components());
            if (this.openAPI.getPaths() == null)
                this.openAPI.setPaths(new Paths());
            if (!CollectionUtils.isEmpty(this.openAPI.getServers()))
                this.isServersPresent = true;
        }
        this.propertyResolverUtils = propertyResolverUtils;
        this.securityParser = securityParser;
        this.springDocConfigProperties = springDocConfigProperties;
        this.openApiBuilderCustomisers = openApiBuilderCustomizers;
        this.serverBaseUrlCustomizers = serverBaseUrlCustomizers;
        this.javadocProvider = javadocProvider;
        if (springDocConfigProperties.isUseFqn())
            TypeNameResolver.std.setUseFqn(true);
    }

    @Override
    public Operation buildTags(HandlerMethod handlerMethod, Operation operation, OpenAPI openAPI, Locale locale) {

        Set<Tag> tags = new HashSet<>();
        Set<String> tagsStr = new HashSet<>();

        buildTagsFromMethod(handlerMethod.getMethod(), tags, tagsStr, locale);
        buildTagsFromClass(handlerMethod.getBeanType(), tags, tagsStr, locale);

        if (!CollectionUtils.isEmpty(tagsStr))
            tagsStr = tagsStr.stream()
                .map(str -> propertyResolverUtils.resolve(str, locale))
                .collect(Collectors.toSet());

        if (springdocTags.containsKey(handlerMethod)) {
            io.swagger.v3.oas.models.tags.Tag tag = springdocTags.get(handlerMethod);
            tagsStr.add(tag.getName());
            if (openAPI.getTags() == null || !openAPI.getTags().contains(tag)) {
                openAPI.addTagsItem(tag);
            }
        }

        if (!CollectionUtils.isEmpty(tagsStr)) {
            if (CollectionUtils.isEmpty(operation.getTags()))
                operation.setTags(new ArrayList<>(tagsStr));
            else {
                Set<String> operationTagsSet = new HashSet<>(operation.getTags());
                operationTagsSet.addAll(tagsStr);
                operation.getTags().clear();
                operation.getTags().addAll(operationTagsSet);
            }
        }

        if (isAutoTagClasses(operation)) {


            if (javadocProvider.isPresent()) {
                String description = javadocProvider.get().getClassJavadoc(handlerMethod.getBeanType());
                if (StringUtils.isNotBlank(description)) {
                    io.swagger.v3.oas.models.tags.Tag tag = new io.swagger.v3.oas.models.tags.Tag();

                    // 自定义部分 修改使用java注释当tag名
                    List<String> list = IoUtil.readLines(new StringReader(description), new ArrayList<>());
                    // tag.setName(tagAutoName);
                    tag.setName(list.get(0));
                    operation.addTagsItem(list.get(0));

                    tag.setDescription(description);
                    if (openAPI.getTags() == null || !openAPI.getTags().contains(tag)) {
                        openAPI.addTagsItem(tag);
                    }
                }
            } else {
                String tagAutoName = splitCamelCase(handlerMethod.getBeanType().getSimpleName());
                operation.addTagsItem(tagAutoName);
            }
        }

        if (!CollectionUtils.isEmpty(tags)) {
            // Existing tags
            List<io.swagger.v3.oas.models.tags.Tag> openApiTags = openAPI.getTags();
            if (!CollectionUtils.isEmpty(openApiTags))
                tags.addAll(openApiTags);
            openAPI.setTags(new ArrayList<>(tags));
        }

        // Handle SecurityRequirement at operation level
        io.swagger.v3.oas.annotations.security.SecurityRequirement[] securityRequirements = securityParser
            .getSecurityRequirements(handlerMethod);
        if (securityRequirements != null) {
            if (securityRequirements.length == 0)
                operation.setSecurity(Collections.emptyList());
            else
                securityParser.buildSecurityRequirement(securityRequirements, operation);
        }

        return operation;
    }

    private void buildTagsFromMethod(Method method, Set<io.swagger.v3.oas.models.tags.Tag> tags, Set<String> tagsStr, Locale locale) {
        // method tags
        Set<Tags> tagsSet = AnnotatedElementUtils
            .findAllMergedAnnotations(method, Tags.class);
        Set<io.swagger.v3.oas.annotations.tags.Tag> methodTags = tagsSet.stream()
            .flatMap(x -> Stream.of(x.value())).collect(Collectors.toSet());
        methodTags.addAll(AnnotatedElementUtils.findAllMergedAnnotations(method, io.swagger.v3.oas.annotations.tags.Tag.class));
        if (!CollectionUtils.isEmpty(methodTags)) {
            tagsStr.addAll(methodTags.stream().map(tag -> propertyResolverUtils.resolve(tag.name(), locale)).collect(Collectors.toSet()));
            List<io.swagger.v3.oas.annotations.tags.Tag> allTags = new ArrayList<>(methodTags);
            addTags(allTags, tags, locale);
        }
    }

    private void addTags(List<io.swagger.v3.oas.annotations.tags.Tag> sourceTags, Set<io.swagger.v3.oas.models.tags.Tag> tags, Locale locale) {
        Optional<Set<io.swagger.v3.oas.models.tags.Tag>> optionalTagSet = AnnotationsUtils
            .getTags(sourceTags.toArray(new io.swagger.v3.oas.annotations.tags.Tag[0]), true);
        optionalTagSet.ifPresent(tagsSet -> {
            tagsSet.forEach(tag -> {
                tag.name(propertyResolverUtils.resolve(tag.getName(), locale));
                tag.description(propertyResolverUtils.resolve(tag.getDescription(), locale));
                if (tags.stream().noneMatch(t -> t.getName().equals(tag.getName())))
                    tags.add(tag);
            });
        });
    }

}

配置application.yml 属性

springdoc-openai 配置：

# springdoc-openai 配置
springdoc:
  api-docs:
    # 是否开启接口文档
    enabled: true
    # OpenAPI文档的路径
    path: /v3/api-docs
  swagger-ui:
    # swagger-ui路径
    path: /swagger-ui.html
    # 持久化认证数据
    persistAuthorization: true
  info:
    # 标题
    title: '标题：SpringDoc后台管理系统_接口文档'
    # 描述
    description: '描述：用于管理集团旗下公司的人员信息,具体包括XXX,XXX模块...'
    # 版本
    version: '版本号: 1.0.0'
    # 作者信息
    contact:
      name: lcz
      email: 1926585708@qq.com
      url: https://gitee.com/hsqyz
  components:
    # 鉴权方式配置
    security-schemes:
      apiKey:
        type: APIKEY
        in: HEADER
        name: Authorization
  # 分组配置
  group-configs:
    - group: SpringDoc项目模块接口文档
      packages-to-scan: com.hsqyz.spring_doc

配置Java编译器插件

主要看configuration配置这块内容：

			<plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.9.0</version>
                <configuration>
                    <source>${java.version}</source>
                    <target>${java.version}</target>
                    <encoding>${project.build.sourceEncoding}</encoding>
                    <annotationProcessorPaths>
                        <path>
                            <groupId>com.github.therapi</groupId>
                            <artifactId>therapi-runtime-javadoc-scribe</artifactId>
                            <version>0.15.0</version>
                        </path>
                        <path>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                            <version>${lombok.version}</version>
                        </path>
                        <path>
                            <groupId>org.springframework.boot</groupId>
                            <artifactId>spring-boot-configuration-processor</artifactId>
                            <version>${springboot.version}</version>
                        </path>
                    </annotationProcessorPaths>
                </configuration>
            </plugin>

详细解释如下：

  1. <source>${java.version}</source> 和 <target>${java.version}</target>：设置Java源代码和目标字节码的版本。${java.version} 是一个占位符，表示从项目的属性中读取Java版本号。这意味着项目源代码使用的语言特性和编译后的class文件所对应的JVM版本是一致的。
  2. <encoding>${project.build.sourceEncoding}</encoding>：设置源代码文件的编码格式，${project.build.sourceEncoding} 表示从项目全局配置中读取编码格式。
  3. <annotationProcessorPaths>：这部分配置了注解处理器的路径，注解处理器是一种在编译阶段运行的工具，能够处理源代码中的特定注解，生成额外的类、资源文件或者其他辅助信息。
    • <path> 内的 、 和 分别指定了注解处理器的Maven坐标，即在Maven仓库中该注解处理器的组织ID、项目ID和版本号。
    • com.github.therapi:therapi-runtime-javadoc-scribe：这是一个用于提取Java方法上的Javadoc注解并在运行时使用的注解处理器。
    • org.projectlombok:lombok：Lombok是一个简化Java开发的工具，提供了众多注解如@Data、@NoArgsConstructor等，注解处理器会在编译时自动插入getter/setter、equals/hashCode/toString等方法。
    • org.springframework.boot:spring-boot-configuration-processor：Spring Boot的配置处理器，用于在编译时生成关于@ConfigurationProperties注解类的元数据，使得IDE能提供更好的代码提示和验证。

总之，这段配置确保了Java源代码按指定的版本和编码进行编译，并在编译过程中利用指定的注解处理器生成额外有用的代码和元数据，提升开发效率和应用的功能性。

JavaDoc 元数据

配置好之后再次运行项目，查看target目录下会生成了JavaDoc的元数据

示例接口

/**
 * 用户
 */
@Slf4j
@RestController
@RequestMapping("/user")
@RequiredArgsConstructor
public class TestController {

    /**
     * 添加用户
     *
     * @param user 用户信息对象
     * @return 结果集
     */
    @PostMapping("/insert")
    public R insert(@RequestBody User user) {
        System.out.println("添加用户：" + user);
        return R.ok();
    }

    /**
     * 更新用户
     *
     * @param user 用户信息对象
     * @return 结果集
     */
    @PostMapping("/update")
    public R update(@RequestBody User user) {
        System.out.println("更新用户：" + user);
        return R.ok();
    }

}

准备好接口之后就可以开始准备启动了。

查看 OpenApi 接口

根据项目内所有文档组完成所有数据源创建(拉取后端openapi结构体)
数据源URL格式 http://后端ip:端口/v3/api-docs/组名
项目内所需:

  • http://localhost:8080/v3/api-docs/1.演示模块
  • http://localhost:8080/v3/api-docs/2.通用模块
  • http://localhost:8080/v3/api-docs/3.系统模块
  • http://localhost:8080/v3/api-docs/4.代码生成模块

也可不分组统一导入: http://localhost:8080/v3/api-docs

导入Apifox

打开Apifox选择导入项目，粘贴接口文档地址

点击提交，设置项目名称

导入成功

点击确定导入

查看接口

整合 knife4j

如果想让项目自带可视化接口调试界面，可以选择引入 knife4j 基于openapi3的依赖

<dependency>
	<groupId>com.github.xiaoymin</groupId>
	<artifactId>knife4j-openapi3-spring-boot-starter</artifactId>
	<version>4.4.0</version>
</dependency>

然后刷新依赖重启项目，访问：http://127.0.0.1:8080/doc.html

查看接口列表

查看数据模型

参考资料

  • 本教程参考自疯狂的狮子大佬开发的若依Plus版教程

教程结束！

散会！

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

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

相关文章

蓝桥杯day12刷题日记

蓝桥杯day12刷题日记

P8720 [蓝桥杯 2020 省 B2] 平面切分 思路&#xff1a;首先借用dalao的图解释一下&#xff0c;又多出一条与当前平面任意一条直线都不重合线时&#xff0c;多了的平面是交点数1&#xff0c;所以用双层循环每次往里面加一条直线&#xff0c;计算交点 #include <iostream>…
阅读更多...
Unity学习笔记 6.2D换帧动画

Unity学习笔记 6.2D换帧动画

下载源码 UnityPackage 目录 1.导入图片 1.1. 图片的叠放顺序 2.图片切片 3.用动画控制器让马&#x1f40e;动起来 1.导入图片 直接拖拽进场景 检查 Texture Type&#xff08;纹理类型&#xff09;是否为 Sprite 创建2D精灵对象&#xff0c;拖拽图片到Sprite&#xff08…
阅读更多...
【spring】@DependsOn注解学习

【spring】@DependsOn注解学习

DependsOn介绍 DependsOn 是 Spring 框架中的一个注解&#xff0c;用于指定一个 bean 的依赖关系。当 Spring 容器初始化 bean 时&#xff0c;它会按照一定的顺序进行初始化。如果一个 bean 依赖于其他 bean&#xff0c;那么这个 bean 的初始化应该在依赖的 bean 之后进行。 …
阅读更多...
2024年noc指导教师认证测评参考试题题目3-4合集

2024年noc指导教师认证测评参考试题题目3-4合集

[noc指导教师认证] 测评参考试题 说明:NOC教师指导认证考试题目是从题库里抽题，因此每位老师每次考试题目都不一样以下题目为测试考试时收集到的一些题目，作为辅助提供给各位老师，老师们可以记住题目及答案的具体内容 (选项顺序会变)，以免考试时遇到。2024年的做的题目有的…
阅读更多...
MISC：zip压缩包伪加密破解及其结构解析

MISC：zip压缩包伪加密破解及其结构解析

一.前言 遇到zip压缩包是被加密的&#xff0c;但加密有时侯是伪加密&#xff0c;需要我们进行破解。 二.压缩包解析 1. 压缩源文件数据区 zip文件头标记 文件头&#xff1a;504B0304 解压文件所需的pkware版本 全局方式位标记 如果四位中的第二位为奇数则表示有加密&#xff…
阅读更多...
Elasticsearch：将 ILM 管理的数据流迁移到数据流生命周期

Elasticsearch：将 ILM 管理的数据流迁移到数据流生命周期

警告&#xff1a;此功能处于技术预览阶段&#xff0c;可能会在未来版本中更改或删除。 Elastic 将努力解决任何问题&#xff0c;但技术预览版中的功能不受官方 GA 功能的支持 SLA 的约束。目前的最新版本为 8.12。 在本教程中&#xff0c;我们将了解如何将现有数据流&#xff0…
阅读更多...
【Linux 进程概念】

【Linux 进程概念】

【Linux 进程概念】 冯诺依曼体系结构冯诺依曼结构简要解释&#xff1a;你用QQ和朋友聊天时数据的流动过程 操作系统(OperatorSystem)概念设计OS的目的定位操作系统的上下层都分别是什么如何理解“管理"总结 进程基本概念描述进程-PCBtask_ struct内容 组织进程查看进程通…
阅读更多...
JS精度计算的几种解决方法，1、转换成整数计算后再转换成小数，2、toFixed，3、math.js，4、bignumber.js，5、big.js

JS精度计算的几种解决方法，1、转换成整数计算后再转换成小数，2、toFixed，3、math.js，4、bignumber.js，5、big.js

提示&#xff1a;学习express&#xff0c;搭建管理系统 文章目录 前言一、转换成整数计算后再转换成小数二、toFixed三、math.js四、bignumber.js五、big.js总结 前言 原始计算 let aNum 6.6 0.3;let bNum 6.6 - 0.2;let cNum 6.6 * 0.3;let dNum 6.6 / 0.2;console.log(…
阅读更多...
Web框架开发-Ajax

Web框架开发-Ajax

一、 Ajax准备知识：json 1、json(Javascript Obiect Notation,JS对象标记)是一种轻量级的数据交换格式 1 2 它基于 ECMAScript (w3c制定的js规范)的一个子集，采用完全独立于编程语言的文本格式来存储和表示数据。 简洁和清晰的层次结构使得 JSON 成为理想的数据交换语言。…
阅读更多...
手撕算法-删除有序数组中的重复项 II

手撕算法-删除有序数组中的重复项 II

描述 例如&#xff1a;输入&#xff1a;nums [1,1,1,2,2,3]输出&#xff1a;5, nums [1,1,2,2,3]解释&#xff1a;函数应返回新长度 length 5, 并且原数组的前五个元素被修改为 1, 1, 2, 2, 3。 不需要考虑数组中超出新长度后面的元素。 分析 双指针, fast, slow。nums[…
阅读更多...
Redis高阶使用消息队列分布式锁排行榜等

Redis高阶使用消息队列分布式锁排行榜等

一、前言 在大多数传统的web系统中&#xff0c;使用Redis一般都是作为缓存使用&#xff0c;在大数据查询时作为缓解性能的一种解决方案。博主的的系统中使用Redis也主要使用到缓存的作用&#xff0c;还有做了注册中心&#xff0c;分布式事务。其他的强大的功能&#xff0c;没有…
阅读更多...
【微服务】以模块化单体架构开发微服务应用

【微服务】以模块化单体架构开发微服务应用

目录 推荐超级课程： Docker快速入门到精通Kubernetes入门到大师通关课AWS云服务快速入门实战我们知道，起初，单体应用有显著的优势：它们更容易开发和部署。从开发人员的角度来看，这种简单性是有益的。一切都是集中的，可以快速更新任何部分的业务逻辑并立即看到结果。这种开…
阅读更多...
2024046期传足14场胜负前瞻

2024046期传足14场胜负前瞻

2024046期售止时间为3月26日&#xff08;周二&#xff09;19点30分&#xff0c;敬请留意&#xff1a; 本期深盘多&#xff0c;1.5以下赔率5场&#xff0c;1.5-2.0赔率4场&#xff0c;其他场次是平半盘、平盘。本期14场整体难度不大。以下为基础盘前瞻&#xff0c;大家可根据自身…
阅读更多...
CSS3实现的分享图标按钮动画特效代码

CSS3实现的分享图标按钮动画特效代码

CSS3分享图标按钮动画特效代码是一款社会分享图标动画特效&#xff0c;鼠标移上去会有一个胶囊闪动的效果。源码由HTMLCSSJS组成&#xff0c;适合绝大部分web网站&#xff0c;可以把它做成一个组件添加到网站的文章页下面&#xff0c;给网站添加一个文章分享功能&#xff0c;也…
阅读更多...
私有化视频会议的重要性与优势，WorkPlus Meet助您安全高效沟通

私有化视频会议的重要性与优势，WorkPlus Meet助您安全高效沟通

高效的视频会议是推动沟通与协作的重要手段。而选择私有化视频会议平台&#xff0c;保障企业信息安全和会议效果则显得尤为重要。WorkPlus Meet以其卓越的性能和全面的功能&#xff0c;助力企业实现私有化视频会议&#xff0c;提升沟通效果与协作效率。 私有化视频会议的重要性…
阅读更多...
关于Java发邮件提醒写周报实现（一）环境搭建

关于Java发邮件提醒写周报实现（一）环境搭建

背景 由于公司每周都要写周报&#xff0c;而日常工作很忙&#xff0c;所以很容易忘记这件事件&#xff0c;因此开发一个写周报提醒的机器人&#xff0c;进行特定时间提醒是时候写周报了。 有一个大前提&#xff0c;本技术实现&#xff0c;本着不开通任何收费服务的态度去考察使…
阅读更多...
Jackson 2.x 系列【2】生成器 JsonGenerator

Jackson 2.x 系列【2】生成器 JsonGenerator

有道无术&#xff0c;术尚可求&#xff0c;有术无道&#xff0c;止于术。 本系列Jackson 版本 2.17.0 源码地址&#xff1a;https://gitee.com/pearl-organization/study-seata-demo 文章目录 1. 前言2. 案例演示2.1 创建 JsonFactory2.2 创建 JsonGenerator2.3 写入操作2.4 查…
阅读更多...
亚马逊跨境电商为什么要多备几个店铺？多店铺运营技巧

亚马逊跨境电商为什么要多备几个店铺？多店铺运营技巧

在亚马逊&#xff0c;链接断货超过15天的话就会降权&#xff0c;之后想要把权重升回来是要下不少功夫的&#xff0c;如果这时候有一个备用店铺的话&#xff0c;就可以跟卖自己大号的链接&#xff0c;先保持出单&#xff0c;把权重稳住那么多店铺就需要多个信用卡进行扣店铺租金…
阅读更多...
小车倒立摆系统极点配置，LQR闭环控制

小车倒立摆系统极点配置，LQR闭环控制

在之前直流电机控制仿真里有讲过状态控制的基本架构&#xff0c;有兴趣的同学可以再回去看看&#xff0c;链接如下好玩的直流电机调速实验、PID、极点配置、LQR、观测器&#xff1b;不讲大道理_lqr控制器观测器-CSDN博客 在专栏的前三篇文章 小车倒立摆物理建模与simulink仿真…
阅读更多...
【Nebula笔记】简介及安装

【Nebula笔记】简介及安装

目录 一、简介 (一) 什么是图数据库 二、安装 (一) 原生安装 (二) Docker & Docker compose 1. Docker安装 Linux Window 2. 部署NebulaGraph (三) to MAC 三、Nebula Graph Studio (一) 版本兼容性 (二) 原生安装 (三) Docker compose (四) 连接Nebula Gra…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023