转载

【SpringBoot-In-Action】一、Spring Boot快速入门

Spring Boot 用来简化 Spring 应用开发，约定大于配置，删繁就简，just run 就能创建一个独立的、产品级的应用

  • 出现背景：

    J2EE（例如 Spring ） 笨重的开发、繁多的配置、低下的开发效率、负责的部署流程和第三方技术集成难度大。

  • 解决方案：

    “Spring 全家桶” 时代：

    Spring Boot → J2EE 一站式解决方案

    Spring Cloud → 分布式整体解决方案

  • 优点：

    快速创建独立运行的 Spring 项目以及与主流框架集成

    使用嵌入式的 Servlet 容器，应用无需打成 war包

    starters 自动依赖于版本控制

    大量的自动配置，简化开发，也可以修改默认属性值

    开箱即用，无需配置 xml，无代码生成

    生产环境的运行时应用监控

    与云计算天然集成

总结：

  • 简化Spring应用开发的一个框架；
  • 整个Spring技术栈的一个大整合；
  • J2EE开发的一站式解决方案；
【SpringBoot-In-Action】一、Spring Boot快速入门

2、微服务

  • 2014由martin fowler提出
  • 微服务：架构风格（服务微化）
  • 一个应用应该是一组小型服务；可以通过HTTP的方式进行互通；
  • 单体应用：ALL IN ONE
  • 微服务：每一个功能元素最终都是一个可独立替换和独立升级的软件单元；
  • 详细参照微服务文档

单体应用：

【SpringBoot-In-Action】一、Spring Boot快速入门

微服务：

【SpringBoot-In-Action】一、Spring Boot快速入门
【SpringBoot-In-Action】一、Spring Boot快速入门

3、环境准备

开发环境：

  • jdk1.8：Spring Boot 推荐jdk1.7及以上；java version "1.8.0_221"
  • maven3.x：maven 3.3以上版本；apache-maven-3.6.1
  • IntelliJIDEA2019：IntelliJ IDEA 2019.1.3 x64
  • SpringBoot 2.2.1.RELEASE：2.2.1；

开发配置：

1、MAVEN设置：

给 maven 的 settings.xml 配置文件的 profiles 标签添加下面的配置，设置 maven 的创建项目时的默认编译版本使用 jdk8 

<profile>
<id>jdk-1.8</id>
<activation>
<activeByDefault>true</activeByDefault>
<jdk>1.8</jdk>
</activation>
<properties>
<maven.compiler.source>1.8</maven.compiler.source>
<maven.compiler.target>1.8</maven.compiler.target>
<maven.compiler.compilerVersion>1.8</maven.compiler.compilerVersion>
</properties>
</profile>
复制代码

2、IDEA设置：

Idea 整合 Maven：

【SpringBoot-In-Action】一、Spring Boot快速入门
【SpringBoot-In-Action】一、Spring Boot快速入门

4、创建 Spring Boot HelloWorld

1、快速开始

首先我们先创建一个统一的 maven 工程，用来管理我们之后学习中所有的项目：

1、新建项目

【SpringBoot-In-Action】一、Spring Boot快速入门

2、选择Maven项目
【SpringBoot-In-Action】一、Spring Boot快速入门

3、填写GroupId、ArtifactId

GroupId： com.demo.springboot

ArtifactId： SpringBoot-In-Action

【SpringBoot-In-Action】一、Spring Boot快速入门

5、填写项目名和项目路径
【SpringBoot-In-Action】一、Spring Boot快速入门

6、创建一个空的maven项目完成，选择允许自动导入
【SpringBoot-In-Action】一、Spring Boot快速入门

7、删除多余的目录

只保留一个pom.xml文件即可，同时在pom文件中添加springboot依赖和打包类型

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.2.1.RELEASE</version>
</parent>
<packaging>pom</packaging>
复制代码
【SpringBoot-In-Action】一、Spring Boot快速入门

2、现在开始我们的 Spring Boot HelloWorld 项目：

一个功能：浏览器发送hello请求，服务器接受请求并处理，响应Hello World字符串 ；

1、创建一个maven工程；（jar）

在SpringBoot-In-Action项目中新建一个module,选择maven工程，命名为 spring-boot-01-helloworld

【SpringBoot-In-Action】一、Spring Boot快速入门

2、导入spring boot相关的依赖

因为springboot的依赖已经在父pom中导入

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.2.1.RELEASE</version>
</parent>
复制代码

所以在当前的pom中只需要导入spring-boot-starter-web的依赖即可：

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>
复制代码

完整 pom 文件如下： 

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>SpringBoot-In-Action</artifactId>
        <groupId>com.demo.springboot</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>spring-boot-01-helloworld</artifactId>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>

</project>
复制代码

3、编写一个主程序；启动Spring Boot应用

【SpringBoot-In-Action】一、Spring Boot快速入门 
/**
 * @SpringBootApplication 来标注一个主程序类，说明这是一个Spring Boot应用
 */
@SpringBootApplication
public class HelloWorldMainApplication {
    public static void main(String[] args) {
        // Spring应用启动起来
        SpringApplication.run(HelloWorldMainApplication.class, args);
    }
}
复制代码

4、编写相关的Controller、Service

为了演示，我在这里只创建了 Controller 类，省略了 Service 

@Controller
public class HelloController {

    @ResponseBody
    @RequestMapping("/hello")
    public String hello() {
        return "Hello World!";
    }
}
复制代码

5、运行主程序测试效果

选中 HelloWorldMainApplication 右键单击选择 Run ... ，或者打开 HelloWorldMainApplication 按下快捷键 Ctrl+Shift+F10 运行程序，可以看到项目在 8080 端口启动：

【SpringBoot-In-Action】一、Spring Boot快速入门

在浏览器中访问 http://localhost:8080/hello 可以看到正常返回了 Hello World 。

【SpringBoot-In-Action】一、Spring Boot快速入门

至此，我们的第一个 Spring Boot 项目算是创建完了。

6、补充：简化部署

在当前项目，即 spring-boot-01-helloworld 的 pom 文件中添加下面的配置 

<!-- 这个插件，可以将应用打包成一个可执行的jar包；-->
<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>
复制代码

然后选中当前 pom 文件，右键单击，选择 Run Maven → package ，将这个应用打成 jar 包，可以看到 target 文件夹下生成一个名为 spring-boot-01-helloworld-1.0-SNAPSHOT.jar 的 jar 文件，我们可以直接在命令行使用 java -jar xxx.jar 命令进行执行，启动后在浏览器中访问 http://localhost:8080/hello 可以看到正常返回了 Hello World 。若要结束程序，关闭命令行窗口即可。

【SpringBoot-In-Action】一、Spring Boot快速入门

思考：为什么我们打包后的程序可以直接在命令行使用 java jar 命令就可以部署？

带着疑问我们来分析一下 spring-boot-01-helloworld-1.0-SNAPSHOT.jar ，我们使用压缩文件打开 spring-boot-01-helloworld-1.0-SNAPSHOT.jar ，可以看到如下所示的目录结构：

【SpringBoot-In-Action】一、Spring Boot快速入门

我们打开 BOOT-INF 文件夹看到有 classes 和 lib 两个文件夹，我们写的代码的二进制字节码就在 classes 目录下，而 lib 下可以看到是我们项目依赖的所有 jar 包，最关键的，我们的项目是一个 web 项目，可以看到所依赖的内嵌的 tomcat jar包，这是我们项目能独立部署的关键：

【SpringBoot-In-Action】一、Spring Boot快速入门

其他目录 META-INF 存放项目的 pom 文件， org 目录下存放的是 springframework 相关代码。

5、Hello World 探究

1、POM文件

1、父项目

依赖路径入下图所示：

【SpringBoot-In-Action】一、Spring Boot快速入门

spring-boot-01-helloworld 的 pom： 

<parent>
    <artifactId>SpringBoot-In-Action</artifactId>
    <groupId>com.demo.springboot</groupId>
    <version>1.0-SNAPSHOT</version>
</parent>
复制代码

它的父项目是 SpringBoot-In-Action 中的 pom： 

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.2.1.RELEASE</version>
</parent>

<packaging>pom</packaging>

<groupId>com.demo.springboot</groupId>
<artifactId>SpringBoot-In-Action</artifactId>
<version>1.0-SNAPSHOT</version>

<modules>
    <module>spring-boot-01-helloworld</module>
</modules>
复制代码

而

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.2.1.RELEASE</version>
</parent>
复制代码

的父 pom 是 spring-boot-starter-parent-2.2.1.RELEASE.pom : 

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-dependencies</artifactId>
    <version>2.2.1.RELEASE</version>
    <relativePath>../../spring-boot-dependencies</relativePath>
</parent>
<artifactId>spring-boot-starter-parent</artifactId>
复制代码

而它的父 pom 是 spring-boot-dependencies-2.2.1.RELEASE.pom : 

<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-dependencies</artifactId>
<version>2.2.1.RELEASE</version>
<packaging>pom</packaging>

在这个pom里边可以看到，它是用来真正管理Spring Boot应用里面的所有依赖版本，定义了每一个依赖的版本；
复制代码
【SpringBoot-In-Action】一、Spring Boot快速入门

spring-boot-dependencies-2.x.RELEASE.pom 可以成称为 Spring Boot的版本仲裁中心 ；

以后我们导入其他依赖默认是不需要写版本；（当然没有在dependencies里面管理的依赖自然需要声明版本号）

2、导入的其他依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
复制代码

spring-boot-starter- web ：我们可以将其拆分为 spring-boot-starter 和 web 两部分

  • spring-boot-starter：spring-boot 场景启动器；spring-boot-starter-web 帮我们导入了 web 模块正常运行所依赖的组件。

我们按下 Ctrl 点击 spring-boot-starter-web 进入 spring-boot-starter-web-2.2.1.RELEASE.pom ，可以看到它导入了很多 web 模块正常运行需要的相关依赖：

【SpringBoot-In-Action】一、Spring Boot快速入门

Spring Boot 为我们提供了简化企业级开发的绝大多数场景的 starter pom（启动器），只要引入了相应场景的 starter pom ，相关技术的绝大部分配置将会消除（即自动配置），从而简化我们的开发。很多业务场景中我们就会使用到 Spring Boot 为我们自动配置的 bean，同时 Spring Boot 对这些场景依赖的 jar 也做了严格的测试与版本控制，我们可以不必担心 jar 版本的适配问题。

在 Spring Boot 中还有很多这样的启动器，我们打开 官方文档 可以看到关于启动器的描述：

【SpringBoot-In-Action】一、Spring Boot快速入门

Spring Boot 将所有的功能场景都抽取出来，做成一个个的 starters（启动器），只需要在项目里面引入这些starter 相关场景的所有依赖都会导入进来。要用什么功能就导入什么场景的启动器。而我们一般的开发也是围绕着这些 starter 来展开。

2、主程序类（主入口类）

/**
 *  @SpringBootApplication 来标注一个主程序类，说明这是一个Spring Boot应用，没有这个注解项目无法启动
 */
@SpringBootApplication
public class HelloWorldMainApplication {

    public static void main(String[] args) {

        // Spring应用启动起来
        SpringApplication.run(HelloWorldMainApplication.class, args);
    }
}
复制代码

1、@SpringBootApplication

@ SpringBootApplication : Spring Boot应用 标注在某个类上说明这个类是SpringBoot的主配置类，SpringBoot 就运行这个类的 main 方法来启动 SpringBoot 应用；

进入 @SpringBootApplication 注解内部，可以看到它实际上是一个复合注解： 

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(
    excludeFilters = {@Filter(
    type = FilterType.CUSTOM,
    classes = {TypeExcludeFilter.class}
), @Filter(
    type = FilterType.CUSTOM,
    classes = {AutoConfigurationExcludeFilter.class}
)}
)
public @interface SpringBootApplication {
复制代码

2、@SpringBootConfiguration

@ SpringBootConfiguration ：Spring Boot 的配置类；

作用 ：标注在某个类上，表示这是一个Spring Boot 的配置类；

进入 @SpringBootConfiguration 内部可以看到，它被 Spring 的 @Configuration 注解所注解： 

@Configuration
public @interface SpringBootConfiguration {
复制代码

@ Configuration ：配置类上来标注这个注解；配置类 === 配置文件；

进入 @Configuration 内部可以看到，它被 Spring 的 @Component 注解所注解；配置类其实也是容器中的一个组件。 

@Component
public @interface Configuration {
复制代码

3、@EnableAutoConfiguration

@ EnableAutoConfiguration ：开启自动配置功能

以前在 Spring 中我们需要配置的东西，现在 Spring Boot 帮我们自动配置；@ EnableAutoConfiguration 告诉SpringBoot 开启自动配置功能，这样自动配置才能生效；

进入 @EnableAutoConfiguration 内部可以看到下面的代码： 

@AutoConfigurationPackage
@Import({AutoConfigurationImportSelector.class})
public @interface EnableAutoConfiguration {
复制代码

@ AutoConfigurationPackage ：自动配置包，将主配置类（ @SpringBootApplication 标注的类）的所在包及下面所有子包里面的所有组件扫描到 Spring 容器

进入 @Configuration 内部可以看到它被 @Import 注解所注解。Spring 的底层注解 @Import，给容器中导入一个组件；导入的组件由 Registrar.class 指定； 

@Import({Registrar.class})
public @interface AutoConfigurationPackage {
复制代码

进入 Registrar 静态内部类可以看到如下代码：

static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {
    Registrar() {
    }
	// 注册一些 Bean 定义信息，进行组件的导入工作；metadata：注解的元信息
    public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
        AutoConfigurationPackages.register(registry, (new AutoConfigurationPackages.PackageImport(metadata)).getPackageName());
    }

    public Set<Object> determineImports(AnnotationMetadata metadata) {
        return Collections.singleton(new AutoConfigurationPackages.PackageImport(metadata));
    }
}
复制代码

我们在代码中打上断点来看一下：

【SpringBoot-In-Action】一、Spring Boot快速入门

@ Import({AutoConfigurationImportSelector.class}) ：给容器中导入组件xxx

AutoConfigurationImportSelector：导入哪些组件的选择器；

我们进入 AutoConfigurationImportSelector 中可以看到如下代码： 

// 将所有需要导入的组件以全类名的方式返回；这些组件就会被添加到容器中
protected AutoConfigurationImportSelector.AutoConfigurationEntry getAutoConfigurationEntry(AutoConfigurationMetadata autoConfigurationMetadata, AnnotationMetadata annotationMetadata) {
    if (!this.isEnabled(annotationMetadata)) {
        return EMPTY_ENTRY;
    } else {
        AnnotationAttributes attributes = this.getAttributes(annotationMetadata);
        List<String> configurations = this.getCandidateConfigurations(annotationMetadata, attributes);
        configurations = this.removeDuplicates(configurations);
        Set<String> exclusions = this.getExclusions(annotationMetadata, attributes);
        this.checkExcludedClasses(configurations, exclusions);
        configurations.removeAll(exclusions);
        configurations = this.filter(configurations, autoConfigurationMetadata);
        this.fireAutoConfigurationImportEvents(configurations, exclusions);
        return new AutoConfigurationImportSelector.AutoConfigurationEntry(configurations, exclusions);
    }
}
复制代码

将所有需要导入的组件以全类名的方式返回；这些组件就会被添加到容器中。即 AutoConfigurationImportSelector 会给容器中导入非常多的自动配置类（xxxAutoConfiguration）；就是给容器中导入这个场景需要的所有组件，并配置好这些组件。

我们在代码中打断点可以看到如下的结果：

【SpringBoot-In-Action】一、Spring Boot快速入门

有了自动配置类，就免去了我们手动编写配置注入功能组件等的工作。

进入上面代码中的 getCandidateConfigurations 方法，可以看到如下代码： 

// 获取候选配置
protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
    List<String> configurations = SpringFactoriesLoader.loadFactoryNames(this.getSpringFactoriesLoaderFactoryClass(), this.getBeanClassLoader());
    Assert.notEmpty(configurations, "No auto configuration classes found in META-INF/spring.factories. If you are using a custom packaging, make sure that file is correct.");
    return configurations;
}
复制代码

上面代码中调用了 SpringFactoriesLoader.loadFactoryNames(EnableAutoConfiguration.class, ClassLoader) 方法，我们在这个进入这个方法可以看下面的代码： 

public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
    // 获取工厂名
    String factoryTypeName = factoryType.getName();
    return (List)loadSpringFactories(classLoader).getOrDefault(factoryTypeName, Collections.emptyList());
}

private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
    MultiValueMap<String, String> result = (MultiValueMap)cache.get(classLoader);
    if (result != null) {
        return result;
    } else {
        try {
            // 用类加载器从类路径 "META-INF/spring.factories" 中获取资源
            Enumeration<URL> urls = classLoader != null ? classLoader.getResources("META-INF/spring.factories") : ClassLoader.getSystemResources("META-INF/spring.factories");
            LinkedMultiValueMap result = new LinkedMultiValueMap();

            while(urls.hasMoreElements()) {
                URL url = (URL)urls.nextElement();
                UrlResource resource = new UrlResource(url);
                // 从获取的资源中拿出 properties 配置文件，把获取的资源当作 properties 配置文件
                Properties properties = PropertiesLoaderUtils.loadProperties(resource);
                Iterator var6 = properties.entrySet().iterator();

                while(var6.hasNext()) {
                    Entry<?, ?> entry = (Entry)var6.next();
                    // 从 properties 文件中拿到 factoryTypeName
                    String factoryTypeName = ((String)entry.getKey()).trim();
                    String[] var9 = StringUtils.commaDelimitedListToStringArray((String)entry.getValue());
                    int var10 = var9.length;

                    for(int var11 = 0; var11 < var10; ++var11) {
                        String factoryImplementationName = var9[var11];
                        result.add(factoryTypeName, factoryImplementationName.trim());
                    }
                }
            }

            cache.put(classLoader, result);
            return result;
        } catch (IOException var13) {
            throw new IllegalArgumentException("Unable to load factories from location [META-INF/spring.factories]", var13);
        }
    }
}
复制代码

所以根据上面的分析我的得知： Spring Boot 在启动的时候从类路径下的 META-INF/spring.factories 中获取 EnableAutoConfiguration 指定的值，将这些值作为自动配置类导入到容器中，自动配置类就生效，帮我们进行自动配置工作 。以前我们在 Spring 中需要自己配置的东西，在 Spring Boot 中自动配置类都帮我们配了。

【SpringBoot-In-Action】一、Spring Boot快速入门

综上，J2EE 的整体整合解决方案和自动配置都在 spring-boot-autoconfigure-2.2.1.RELEASE.jar (spring-boot-autoconfigure-x.x.x.RELEASE.jar )中：

【SpringBoot-In-Action】一、Spring Boot快速入门

6、使用 Spring Initializer 快速创建 Spring Boot项目

1、IDEA：使用 Spring Initializer快速创建项目

所有的 IDE 都支持使用 Spring 的项目创建向导快速创建一个 Spring Boot 项目，下面我们来看一下如何在 idea 中快速创建一个 Spring Boot 项目。

1、选择 File → New → Project 或是在一个已经存在的工程中选中工程名然后 New → Module ：

【SpringBoot-In-Action】一、Spring Boot快速入门

2、填写基本信息 GroupID 、 ArtifactID

【SpringBoot-In-Action】一、Spring Boot快速入门

3、选择我们需要依赖的模块

【SpringBoot-In-Action】一、Spring Boot快速入门

4、点击 Finish ，接下来向导会联网创建 Spring Boot 项目

【SpringBoot-In-Action】一、Spring Boot快速入门

查看默认生成的 Spring Boot 项目，我们可以看到：

  • 主程序已经生成好了，我们只需要写我们自己的逻辑
  • resources 文件夹中目录结构：
    • static ：保存所有的静态资源： js、css、 images等；
    • templates ：保存所有的模板页面（Spring Boot 默认 jar 包使用嵌入式的 Tomcat，默认不支持 JSP 页面），可以使用模板引擎（ freemarker 、 thymeleaf 等）；
    • application.properties ：Spring Boot 应用的配置文件；可以修改一些默认设置，比如端口等

我们在 com.demo.spring.controller 包下新见一个 HelloController 来测试一下我们新建的项目

【SpringBoot-In-Action】一、Spring Boot快速入门

HelloController 代码如下：

//这个类的所有方法返回的数据直接写给浏览器，（如果是对象转为json数据）
//@ResponseBody
//@Controller
//  上面两行一般多用在 Spring 项目中
@RestController // 在 Spring Boot 和 Spring4.2.x 之后使用这个来简化开发，返回 RESTAPI 规范的接口
public class HelloController {
    @RequestMapping("/hello")
    public String hello(){
        return "hello world quick!";
    }
}
复制代码

在浏览器中访问 http://localhost:8080/hello 可以得到下面的返回效果：

【SpringBoot-In-Action】一、Spring Boot快速入门

2、通过浏览器访问https://start.spring.io/快速创建项目

【SpringBoot-In-Action】一、Spring Boot快速入门

执行完上面的操作后，浏览器会自动下载一个创建好的项目，我们使用idea打开即可。

以上，就是我们 Spring Boot 快速入门的全部内容，更多详细内容请查看源代码了解。

原文  https://juejin.im/post/5ddfe75ee51d45711a7568c5
正文到此结束
所属分类： Java 编程技术

热门推荐

相关文章

阿里云首购8折
说给你听

本文目录
随机标签
书籍教程
springboot-demo Java入门教程 bootstrap3 CSS Apache基础教程 php ionic 教程 Python mysql教程 eclipse Ubuntu VPS系统配置 AngularJS 教程 MongoDB教程 Struts2教程 Redis教程 Spring教程 Git教程 Jenkins进阶系列 openfire参考指南 Java设计模式 HBase教程 java-demo Maven教程 springcloud-demo hibernate教程 Docker 教程 memcached教程 Quartz指南 Hive教程 ANTLR教程 SpringCloud Ant教程 java实例教程 Hazelcast教程 XStream教程 Elastic-Job-Lite 深入浅出MyBatis ibaties教程 SVN教程 rabittmq教程 Hadoop教程 solr教程 WebService CXF学习 JPA教程 ActiveMQ中文指南 Java内存模型 dubbo教程 python3-demo Linux入门视频教程
近期评论
  1. 1 使用 Docker 打包和运行 Vue 应用
  2. 2 Dependency Check命令行方式扫描jar包的安全漏洞
  3. 3 maven使用Dependency-Check来扫描安全漏洞
  4. 4 使用sonarqube分析代码质量
  5. 5 使用screw来对比数据库表和字段差异
  6. 6 Spring Boot 实现防盗链功能
  7. 7 在Spring Boot中的实现国际化（i18n）
  8. 8 一个用于 SMB/CIFS 网络的 Java 库-JCIFS
  9. 9 Spring Boot 3.x嵌入MongoDB 进行测试
  10. 10 java如何解析和生成yaml文件？
网站信息
  • 文章总数：82,737 篇
  • 文件总数：284,312 个
  • 标签总数：2,416 个
  • 分类总数：85 个
  • 留言数量：2,559 条
  • 在线人数：696 人
  • 运行天数：4,439天
  • 最后更新：2024年12月22日21点
Loading...

其他链接

关于本站

本站定位：个人技术类博客

本站作用：写博客、记日志、闲聊扯淡鼓捣技术。

问题交流

[HBLOG]公众号 HBLOG HBLOG