SpringBoot环境搭建(基于Spring Tool Suite 4)

做一个幸福的人，其实是一件很酷的事情，因为它是你需要真正的生活哲学。我觉得那样的人才是真正的一个成功人，不去讨生活，生活有时会讨好你自己。做幸福的人，比成功更酷。--------李健

SpringToolSuite4(STS)是用来执行SpringBoot项目IDE开发工具，下面从0开始搭建一个Springboot启动案例。

0.为什么去使用SpringBoot：

SpringBoot是一个快速开发框架，快速的将一些常用的第三方依赖整合（原理：通过Maven子父工程的方式），简化XML配置，全部采用注解形式，内置Http服务器（Jetty和Tomcat），最终以java应用程序进行执行。
SpringBoot核心原理：(SpringBoot官网地址为:https://spring.io/projects/spring-boot)

基于SpringMVC无配置文件（纯Java）完全注解化+内置tomcat-embed-core实现SpringBoot框架，Main函数启动。
SpringBoot核心快速整合第三方框架原理:Maven继承依赖关系。

1)轻松依赖管理：起步依赖(Stater Dependency)-项目创建时自动(底层帮你)关联依赖。

在使用 Spring 的时候，需要在 pom.xml 文件中添加多个依赖，而 Spring Boot 则会帮助开发着快速启动一个 web 容器，在 Spring Boot 中，我们只需要在 pom 文件中添加如下一个 starter-web 依赖即可。

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

我们点击进入该依赖后可以看到，Spring Boot 这个 starter-web 已经包含了多个依赖，包括之前在 Spring 工程中需要导入的依赖，我们看一下其中的一部分，如下：

<!-- .....省略其他依赖 -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-web</artifactId>
    <version>5.0.7.RELEASE</version>
    <scope>compile</scope>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.0.7.RELEASE</version>
    <scope>compile</scope>
</dependency>

2)自动化的配置：自动配置(Auto Configuration)-即系统底层帮你自动配置。

Spring 虽然使Java EE轻量级框架，但由于其繁琐的配置，一度被人认为是“配置地狱”。各种XML、Annotation配置会让人眼花缭乱，而且配置多的话，如果出错了也很难找出原因。Spring Boot更多的是采用 Java Config 的方式，对 Spring 进行配置。

3)健康检查(Actator)-监控：

比如有时，我们在浏览器里输入一个地址，找不到服务器端的资源，可以打开监控查看那个地址有没有对应的资源。比如说，我想去监控一下，我们这个Bean对象(Spring容器管理的资源，我们都称之为是bean)，这个bean对象没有，可以打开监控查看。

4)嵌入式的Servlet容器支持：应用无需打成WAR包。

在使用 Spring 时，项目部署时需要我们在服务器上部署 tomcat，然后把项目打成 war 包扔到 tomcat里，在使用 Spring Boot 后，我们不需要在服务器上去部署 tomcat，因为 Spring Boot 内嵌了 tomcat，我们只需要将项目打成 jar 包，使用 java -jar xxx.jar一键式启动项目。

5)对SpringBoot的理解：

　　SpringBoot对SSM框架的整合实现了自动化(添加依赖，配置文件以及映射文件)，无需程序员自己去写，只要选择用谁即可，SpringBoot会自动匹配相应的版本及配置，避免了一些框架的版本冲突问题，

和各种配置文件的繁琐操作。比如现在要使用Spring框架，就绪需要通过写配置文件(spring.xml)的方式去配置，要么就去写注解(@annotation)的方式去配置，那这个过程就会变的比较麻烦。

所以就想，能不能把这些对于初学者来讲，搭建环境的这个过程，进行一个更好的简化，让他们的精力放在，具体的业务的实现上面去，那对于一些高手来讲，他们帮你把依赖做好，他们帮你把配置做好，

那初学者只是在这个平台上面去写你的业务代码就可以了。就类似于我现在想去学开车，车，别人帮你去做好了，也就是说，人家肯定得去帮你把车设计好，把车里面各个组件帮你组装好。

生产完了以后，对外输出一辆车，我只要学会去开就可以了，SpringBoot就是这样一种思想。

　　在将来java程序员入门会越来越容易，因为现成的工具，现成的框架越来越多，使用框架最重要的一点就是掌握规则，基于规则去写代码，你就会感觉越来越简单。对于框架的学习，在于应用，而不是去理解，

无论SpringBoot，还是SpringCloud，框架都不是我们设计的，要先会用，而他们里面的设计精髓原理，这是一个长期的，耗时的一个过程，需要逐步加强。SpringBoot的底层原理和设计思想，

所涵盖的内容‌已经非常之庞大，绝非短期内可以掌握。

　　现在的软件市场已经形成了一定的规模，在这种规模下面，系统架构的复杂度也越来越高(从早期的单体架构，再到后面的SOA(Service-Oriented Architecture)分布式架构，再到我们现在的微服务式架构)。可以说呢，

这个软件体系的架构正在发生着很大的变化，在这种变化中，

　　(1)从企业方面而言，企业现在更注重技术的开箱即用，拿来即用，如果想把所有的技术都精通，不是不可以，可能需要好长时间，至少得8-10年的时间，现在想精通每一项技术，这是不可能的，

所以初始学习框架应该站在应用的角度，然后逐步地去理解设计原理，但是设计原理是一个长期积累的过程，如果对设计原理感兴趣，想做设计者，就不得不懂原理，但是，不是说一下就把原理都要学透，学明白，很难。

那我们现在呢，很多很多的这种平台，都更注重于技术在这个生态圈的一种生态的融合，深度的融合，更注重轻量级的这种运维，所以运维就更简单，自动化，就现在的运维就指的什么意思啊，

不用我们流水线上的工人，天天盯在那，不用看着这个CPU多少多少了，这个磁盘是不是太烫了，这个网络出现拥堵了，不用人工去盯着这件事情，完全由系统来去做，那么这个过程就叫做轻量级的运维。

那么如何实现，SpringBoot在一定程度上，可以去简化我们项目构建的这个过程，而我们程序员在把精力提取出来，更多的集中在业务开发上。

　　(2)从技术方面而言，即在这种分布式架构，或在这种微服务架构当中，已经不是一个JVM的问题了，可能会涉及到多个JVM，多个服务，对外再提供一个统一的这样一种产品，就类似于天猫商城，京东商城，

那么对外输出的是一个电子商务系统，一个电商系统，但是对于这个电商系统来讲，它是一个产品，支持这个产品的后面的服务，会有很多，比如说有商品服务，订单服务，还有推荐服务，搜索服务，购物车服务，

库存服务，积分服务等等，其实严格来讲，它把每一块业务，都理解成是对外的一个服务，为什么叫微服务呢，支付是服务，搜索是服务，积分是服务，它把所有的系统，看成是一个一个的服务，

把每一个服务单独部署在不同的JVM上，然后这么多的JVM，再对外去支撑统一的一个产品，比方说一个电子商务系统，所以现在的架构越来越复杂，在这种比较复杂的这种架构当中，

如果想提高我们开发的效率，简化配置过程，简化资源加载过程，那我们就需要有一种技术，那这种技术，现在在这个行业里面诞生了，就叫SpringBoot，也许将来可能会有其他的一些产品，

淘汰SpringBoot，但是至少现在SpringBoot是我们目前这个市场当中，去构建我们项目，简化项目依赖，部署自动化配置的，一个非常有效的项目脚手架，或者叫架子工。

SpringBoot构建于SpringFramework的基础之上，它是基于快速构建的理念，提供了自动配置，程序员只需要根据自身的业务去配置特定的少量数据，从而简化了配置工作，

而那些公共的配置信息则由框架底层的设计人员，他们已经把这些公共的配置，依赖帮我们做好了，我们只需要在这个配置和依赖之上写自己的业务即可.

1 准备工作

(1)下载JDK1.8(绿色版，解压即可！)，并进行环境变量配置(只配置JAVA_HOME指明jdk完整路径即可，CLASSPATH不用也行！)

(2)下载最新maven(例如apache-maven-3.6.3,网址http://maven.apache.org/)并解压。

(3)下载sts最新版(例如sts-4.4.5.RELEASE,网址https://spring.io/tools)并解压（此网站新版本下载下来时是一个.jar文件，需要在jar文件所在的目录中，以命令行方式执行 "java -jar 下载的文件名" 的方式进行解压，

这个STS程序被放到了jar包中了，可以以java -jar命令的这种方式执行。如图所示（需要首先启动系统自带的命令行客户端，然后切换到软件所在目录，cd指令为切换目录的意思）。

建议：将下载的所有文件存储到同一目录并解压，例如d:/java/(辅助软件)和d:/tools/(开发软件)目录。要求目录不要有中文，也不要有特殊符号（例如&等）。另外，在启动sts时，会要求指定新的工作空间：定义新的工作区(要求没有中文目录)，例如e:/TCGBIII/CGBWORKSP。

2 Maven基本配置

打开maven中的setting.xml文件，并对其如下选项进行配置。

配置maven本地库(从maven远程服务器下载的资源存储到的位置)：可以自定义位置，比如C盘、D盘、E盘皆可。如果没有指定位置的目录，在创建项目时会自动生成。

<localRepository>${user.home}/.m3/repository</localRepository>

其中，（1）${user.home}：表示当前用户所在的目录(建议就放在当前系统用户这个目录下：官方一般建议就采用这种方式${user.home})；

　　　（2）.m3/repository：默认情况下是 .m2/repository，建议配置自己的maven本地库，而非默认本地库，比如改成.m3/repository；

　　　（3）尽量不用maven默认的存储位置.m2；也尽量不要用自己以前的本地库，因为以前的本地库里面可能已经存在一些依赖，容易产生依赖冲突.

配置maven私服镜像服务器地址(配置到mirrors标签内部)。可以不配置，不配置默认使用的是maven的公服

  <mirror>
    <id>aliyun</id>
    <name>aliyun for maven</name>
    <mirrorOf>*</mirrorOf>
    <url>https://maven.aliyun.com/repository/public</url>
  </mirror>

注：此处是连接aliyun的maven镜像，其中，id，name和url子标签是固定写法，mirrorOf子标签的内容可以自定义。

配置maven中的profile（配置到profiles标签内部）,设置JDK编译和运行版本。(profile详细讲解：推荐：https://www.cnblogs.com/0201zcr/p/6262762.html)

<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>

只配置以上内容即可，其它相关配置暂不理解，但不配置的话应不影响。。。

3 STS整合maven配置

(1) 启动STS工具:

(2) Maven Installations配置Maven环境：Window--Preferences--Maven--Installations--Add：找到maven所在路径，加载进来后勾选，Apply即可。

(3) Maven User Settings配置(用户Settings和全局Settings可以改成一样的)：Maven Installations配置：Window--Preferences--Maven--User Settings。

4 STS工具使用的基本设置与优化：

现在不管是STS，还是IDEA，它们占用的资源都比较多，比较吃内存，所以可以关掉一些不必要的功能，节约内存。

(1) 项目工作区编码设置：Window--Preferences--General--Workspace(或者搜索work)，编码改为UTF-8。统一编码格式，方便外部UTF8的项目文件导入后的编解码不一致。

(2) 禁用拼写检查(拼写时的错误提示功能)，取消图中所示的拼写检查选项。

(3) 取消图中所示的超连接选项配置。防止在赋值粘贴时出现卡顿现象(基于自己的选择，也可以查阅相关资料，进一步优化)。

(4)关掉图中的校验功能(比较校验xml中的标签嵌套格式错误)：校验的内容太多会比较慢，干脆就不校验了(凭经验自行检查)，把没必要的校验关掉。

(5) 关掉自动更新功能(每隔一段时间开发工具就会自动更新，通过网络去下载，没有必要让它自动更新，也可以关掉)：Window--Preferences--Install/Update--Automatic Updates，如图所示：

(6) 和启动选项相关的一些配置Startup and Shutdown，基于实际的需求可改，可不改，比如我们根本就不需要Gradle，可以去掉。

(7) 修改STS工具内存配置，打开SpringToolSuite4.ini文件(在STS安装目录中)，修改堆大小，如图所示：

其中，默认情况下，Xms是最小堆内存，Xmx是最大堆内存；这个STS的内存配置，假如内存足够大，比如8个G，可以把Xms最小堆内存改大一点，1024m，或者16G内存，那Xms和Xmx都设置为2048m；如果内存是4G的，也建议至少改成512m；

理论上讲，改了这个配置，内存中可以存储的对象就多些，就不用每创建几个对象，系统底层的JVM就帮我们启动一个GC垃圾回收，启动GC的话，它会占用很多的时间，那么它会导致短时间的暂停，所以此处可以基于自己电脑的一个实际的情况去修改这个内存的配置。

比如说，Xms和Xmx都改为2048m。改完以后，关掉STS，然后重启打开，如果改完以后，能够启动起来即可。

5 项目创建及结构分析

打开STS 集成开发工具，创建spring boot项目，其具体步骤如下：

第一步：Create new Spring Starter Project:

打开项目新建窗口（快捷键ctrl+n）, 搜索spring，选择spring starter 项目，点击Next。如图所示：

第二步：填写项目基本信息:New Spring Starter Project。

(1)Service URL:https://start.spring.io，项目构建资源地址，必须联网才可以。如果长时间无法连接资源网址，就会出现异常：SocketTimeoutException:connect timed out

(1.1)默认访问URL:https://start.spring.io/，服务器是架在国外的，网络较慢，国内可以选择阿里云镜像资源网址：https://start.aliyun.com/，但可以通过在浏览器访问该网址检查网站是否可以正常访问。

(1.2)因为https://start.spring.io/，服务器是架在国外的，国外的外网服务器能够同时支撑的并发量是有限的，全球创建SpringBoot都在用这个，一旦网路阻塞就一定连不上，或者国外限速了，也可以利用谷歌访问助手等插件尝试访问；

基于以上原因，这就是国内阿里云要提供https://start.aliyun.com/，为什么我们要配置一个maven私服，而不去用maven公服，比如可以用阿里云的，https://start.aliyun.com/bootstrap.html，创建SpringBoot项目，

但是阿里云这个镜像服务器，它相对于Spring官网的服务器来讲，在版本上会有一些滞后，比如start.spring.io官网已经推出的最新release版，是2.3.2，像2.4.0(SNAPSHOT)或2.4.0(M1)，是还没有写好的开发版，

但是在start.aliyun.com，就没有2.3.2，只更新到2.3.0的release版，那如果就想用阿里云的，就只能有2.3.0的SpringBoot版本。

(2)Use default location：此处如果无需上传外部仓库，可以使用默认位置路径，无需改动，如果要上传到远程服务器，比如gitee托管平台，可以更改下保存的路径地址，然后后面加上新创建的项目名称.比如：

(3)项目的构建方式选择Maven；项目的打包方式选择Jar包方式；jdk的版本根据需求选择，比如jdk8；语言选择Java语言；

(4)组名ID：com.cy(一般是公司域名的倒写)；项目名称：CGB-SBOOT-01；项目描述Description和启动类所在包目录Package，选择默认即可。

(5)Working sets默认即可。

(6)如果无法连接URL网路地址，就只能看到第一部分，第二部分和第三部分不会显示出来。即出现异常：SocketTimeoutException:connect timed out，如图所示：

第三步：选择Spring Boot版本，及其所需要的依赖。New Spring Starter Project Dependencies.

(1)Spring Boot Version：根据个人项目需求选择对应SpringBoot版本，Available可以选择需要使用到的依赖。

(2)Fiequently Used：最近使用过的一些依赖，如果是第一次创建SpringBoot项目，可能不会显示此处内容：

(3)选择好指定版本，及其依赖(构建SpringBoot的第一个项目，暂时这里不选择任何依赖)，直接点击Finish完成，如图所示：

第四步：等待项目构建和起步依赖的加载。

(1)在第三步New Spring Starter Project Dependencies.点击Finish之后，项目便开始从maven配置中指定的私服服务器（例如阿里云的maven服务器）去下载起步依赖(SpringBoot项目中默认指定了项目启动时需要的一些jar包依赖)。

(2)在项目依赖下载的这个过程可能会比较耗时(网络最好不要用手机网络，会导致很多资源下载不下来)，如果下载时间比较长，可以用之前下载好的本地库repository，替换现在的本地库，但需要对应的SpringBoot的版本一致才可以：

(3)假如指定版本的springboot项目以前创建过，它会默认先从本地库查找，假如本地库没有，则从远程库(网络)去下载(如果之前下载过依赖，即本地可以有这个依赖，那项目构建速度也会很快)。项目创建成功以后，其包视图(Package Explorer)结构，如图所示：

其中,在图-13呈现的CGB-SBOOT-01项目结构中，所有的类和配置文件都是创建好项目以后，由STS工具帮我们自动创建的。

注意：如果以上步骤都正确，创建项目后，目录结构不全，或pom.xml文件报错，或者两种情况同时存在，基本是Maven的资源取不下来，可以选中项目，右键，强制MavenUpdate。

或者沿用之前不同版本的SpringBoot的maven库，以及其他非SpringBoot的maven，从而产生依赖冲突导致jar包无法下载，具体见问题分析。

第五步：找到项目的入口类（使用了@SpringBootApplication注解描述），然后运行启动类，检测启动过程，SpringBoot在启动时，控制台会出现如图标识：

至此，sts开发工具及其所需的基本环境jdk和maven配置成功：可以开始你的show了！

SpringBoot项目创建方式二：

除了通过开发工具STS创建SpringBoot项目，还可以通过网址创建SpringBoot项目，比如通过spring官网 https://start.spring.io/，或者通过阿里云镜像 https://start.aliyun.com/bootstrap.html，

(1)选择项目Project：Maven Project，语言Language：Java，然后后面选择SpringBoot的版本，2.3.2；

(2)Project Metadata：

组ID，Group：com.cy；项目名称Artifact：CGB-SPRINGBOOT-00；包名Package name：com.cy；打包方式Packaging：Jar；Java版本，Java：8；Name和Description默认即可。

(3)最后点击GENERATE即可，网站会自动生成一个SpringBoot的Maven项目并下载，下载下来，导入我们的STS工具即可。这也是创建项目的一种方式。如图所示：

(4)下载后文件，可以移动到指定目录，或者直接解压到指定目录：

(5)导入通过网页生成的此项目，操作如下：打开STS选择File--Import--Maven--Existing Maven Projects:

(6)可以选择Add project(s) to working set，将这个项目添加到工作区，添加一个工作区的配置。当然不选也行，也没有问题：

(8)生成项目如下：与STS工具生成的项目效果是一样的。

SpringBoot项目创建方式三：

如果网络就是连接不上，也可以通过创建一个普通的Maven项目+pom.xml的方式，自行构建SpringBoot项目结构。

(1)首先创建一个普通的Maven项目：

勾选创建一个简单的Maven项目

填写如下选项的对应信息，其他可默认为空。

(2)把之前已经创建好的SpringBoot的项目pom.xml的所有内容复制，粘贴到普通Maven项目的pom.xml文件中，注意，需要把项目artifactId和name两个标签的名称改为当前项目名称，否则项目根文件可能报红叉。

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.2.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.cy</groupId>
    <artifactId>CGB-SPRINGBOOT-01</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>CGB-SPRINGBOOT-01</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

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

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

(3)选中这个普通的Maven项目，右键，选Maven，UpdateProject，勾选强制更新选项，最后OK即可，SpringBoot项目创建完成。

(4)以上步骤完成以后，我们自己手动创建的普通Maven项目构建出来的SpringBoot工程中，src里面是没有自动生成的包和类，以及配置文件，即没有启动类，application.properties配置文件等资源，

我们也可以自己手动去创建这些必要的项目目录与结构，可以直接拷贝已有的SpringBoot工程的目录结构，或者自己去随便写一个启动类，类名无所谓，但是启动类要求必须被注解@SpringBootApplication描述，

并且类的内部需要有一个main方法，在这个main方法里面，需要调用SpringApplication.run(Application.class, args); 这个方法，并传入当前启动类对象的实例，比如：

SpringBoot启动类结构如下：

package com.cy;

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

@SpringBootApplication
public class Application implements {

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

(5)最后再src/main/resources目录下，直接拷贝一份SpringBoot指定的配置文件，application.properties，或者自行创建一个同名文件即可，如果是一个纯净的SpringBoot功能，配置文件里面可以是没有任何内容的(文件左侧会显示一个小叶子)。

提示：我们通过Spring官网生成的，或通过STS工具访问spring官网生成的SpringBoot项目，SpringBoot的配置文件application.properties中，是没有任何内容的，但是如果是通过STS访问阿里云的http://start.aliyun.com 生成的SpringBoot项目的配置文件内部是有内容的，

它默认给我们指定了一些配置，这个配置不是我们需要的，比如说给项目起个名字，用到了jmx，用到了健康检查等，可以把它里面的内容清掉，留着它们也没有关系，不会有什么影响，内容如下：

spring.application.name=CGB-SPRINGBOOT02

management.endpoints.jmx.exposure.include=*
management.endpoints.web.exposure.include=*
management.endpoint.health.show-details=always


# spring cloud access&secret config
# 可以访问如下地址查看: https://usercenter.console.aliyun.com/#/manage/ak
alibaba.cloud.access-key=****
alibaba.cloud.secret-key=****

SpringBoot项目创建方式四：基于已有的SB项目拷贝

基于原有的SpringBoot项目复制粘贴，Ctrl+C、Ctrl+V：

注意：此拷贝原有项目方式，需要更改pom.xml中的artifactId和name两个标签的名称改为当前项目名称，并通过MavenUpdateProject强制更新，否则项目根文件可能报红叉。

项目结构分析：应遵守如下规则

(1)任何一个项目在启动的时候都需要有一个入口，项目中被注解@SpringBootApplication描述的类就是SpringBoot项目的入口，称其为启动类上，一个项目有且只能有一个启动类，可以通过此类启动SpringBoot项目；

(2)自己写的类，一定要放在启动类所在的包，或者是其子包中，有了启动类以后，因为后面我们可能有些资源要交给Spring去管理，所以自己写的类不要放到其他的包里面；

(3)这个src/main/resources目录下，一定放的是我们的配置文件，及其以后可能还有一些静态资源；

(4)这个src/main/resources目录下，有SpringBoot自带的一个默认的配置文件application.properties，一般在创建一个项目的时候，这个配置文件没有任何内容，我们SpringBoot项目的配置都会写在这里；

(5)这个src/test/java目录下，如果有一些单元测试类，单元测试类就放在这个目录下，另外，测试目录下也有一个测试的启动类，其上被注解@SpringBootTest描述，表示把这个类交给Spring去管理，单元测试类所在的包，最好也是测试的启动类所在的包，或者是其子包中。

(1)启动类内部有一个main方法，main方法内部有一段代码，SpringApplication.run(Application.class, args);，其含义是加载SpringBoot指定资源，这些资源无非就是一些class文件或者properties配置文件等，

因为我们得读配置文件，并加载类到内存中，即底层要去加载你的Class文件到内存，那么要基于我们这个properties给对象做一定的配置。

package com.cy;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Application {

    public static void main(String[] args) {
        //加载springboot指定资源(.class,.properties,...)
        SpringApplication.run(Application.class, args);
    }
}

(2)测试目录下的启动类，使用@SpringBootTest描述的类，称其为单元测试类，类的内部有一个单元测试方法，被注解@Test描述，SpringBoot默认引入的是JUnit5的包，即org.junit.jupiter.api.Test，如果引用JUnit4中的@Test注解描述可能会有些问题。

package com.cy;

import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
/**
 * SpringBoot工程中的单元测试类,使用
 * @SpringBootTest 注解进行描述
 */
@SpringBootTest
class ApplicationTests {

    @Test
    void contextLoads() {
        
    }

}

(3)这个JRE System Library[JavaSE-1.8]，建议选择Window--Preferences--Java--Installed JREs：

这里用到的是jdk，建议这里用的是jdk，而不是在这里选择的是jre，否则后面有些源代码可能打不开，关联不上，就无法去看源码的设计思想，所以这个位置一定要关联的是jdk的一个位置。

(4)这个Maven Dependencies，我们没有自己添加依赖，默认情况下，这个项目里就有很多依赖，我们只选择了一个SpringBoot的版本，SpringBoot相关的一些依赖，也就是一些基础平台，就帮我们下载好了。

为什么在创建项目时，有时会比较慢，就是因为在创建项目时，SpringBoot默认会把很多依赖帮我们下载下来，而不用我们自己去选择，这个特性就是SpringBoot当中的起步依赖，或者说启动依赖特性，

创建项目时，我们还没有指定依赖，SpringBoot就会帮我们下载很多依赖，比如Spring的依赖，slf4j的依赖，json的依赖，junit的依赖等等。这就是SpringBoot工程的特点，它帮我们把很多资源配置好，

把项目中要用到的一些基础依赖，帮我们做了一个版本的设计，兼容性的配置。

(5)对于src来讲，其src/main/java，src/main/resources，src/test/java，都这些资源里面的内容，在编译的时候，其实都在src目录下，但是在src目录展开是看不到的，它没有显示具体的资源。

(6)对于target来讲，我们src中的目录下的所有.java程序，编译生成的.class文件，及其src/main/resources目录下的配置文件，编译后，都会生成到target目录下，那些.class文件就会存储在这个target目录下，

可以通过，选择项目右键--Show In--System Explorer：就可以打开项目所在的本地目录。

(7)对于pom.xml文件，其中有一个parent标签：表示我们当前创建的项目，继承于SpringBoot当中给定的 org.springframework.boot 的 spring-boot-starter-parent 这个项目，parent标签表示maven里项目之间的继承关系，我们的一些maven依赖，版本的一些配置，

都是在parent所依赖的这个工程中指定的。

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.2.RELEASE</version>
        <relativePath /> <!-- lookup parent from repository -->
    </parent>

pom.xml文件中，其他的信息是我们自己项目中的信息，SpringBoot项目里面只指定了下面两个资源依赖，spring-boot-starter和spring-boot-start-test，我们创建SpringBoot项目时，工具自动帮我们创建的，其它的依赖是没有在pom.xml文件中指定的，

但是我们MavenDependencies有那么多的依赖，那没有的那些依赖在哪呢，就在parent标签依赖的父级工程里面，可以通过Ctrl点击，进入parent标签引入项目的子文件，org.springframework.boot:spring-boot-starter-parent:2.3.2.RELEASE.pom，

再按住Ctrl点击这个文件中的parent，进入到org.springframework.boot:spring-boot-dependencies:2.3.2.RELEASE.pom，就会发现这个文件中有很多的版本，很多依赖，SpringBoot这个工程底层都帮我们已经做好了，这个是别人已经帮我们设计好的这些版本，而不需要我们自己设计的，

所以就算我们没有指定依赖的版本，SpringBoot也会帮我们去下载对应版本的这些依赖。

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

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

注意：项目上如果有问号，是因为配置了Git环境，表示本地代码仓库，有未同步的代码，如果代码只在本地保存就不会有问号。

问题分析：

1.创建项目时网络连接超时：

STS默认有一个超时时间，如果超过这个时间无法连接上服务器，就会抛出异常，SocketTimeoutException：connect timed out.

可能导致超时的原因如下：

(0)我们在创建SpringBoot项目时，New Spring Starter Project，使用https://start.spring.io/ 也好，还是使用阿里云的https://start.aliyun.com/ 也好，可能有的时候因为外网的服务器不稳定，所以我们有时候在这里的链接就访问不了。

(1)域名解析问题(与当地的域名服务器有关)

打开，控制版面--打开网络和共享中心--本地连接、打开本地连接，状态窗口--属性：双击，Internet 协议版本 4 (TCP/IPv4)：在使用下面的 DNS服务器地址栏中，有首选DNS服务器和备用DNS服务器，

可以在此处配置自己电脑使用的DNS配置信息，默认是自动获得DNS服务器地址。如果要上外网就都会有一个DNS的配置，计算机的唯一标识就是IP地址，而一台计算机上有很多的应用，这些应用在这台计算机上的唯一标识，就是端口号。

比如可以基于80端口找到tomcat，Tomcat的默认启动端口是80，在浏览器输入一个域名，比如www.baidu.com，这个域名会通过DNS服务器解析，把域名解析成IP地址，最终找到网络上服务器，如果DNS的解析出现了问题，

就可能找不到网络中的计算机，这是就会出现网络连接超时。

国内公共DNS：有联通的，电信的，阿里巴巴的，腾讯的，还有114的，其实安全性最高的就是114的，防钓鱼的，等等，有时我们在网络共享中心的本地连接里配置的DNS的时候，如果那个DNS选的不好，也有可能访问不到服务器(360DNS优选可以找到访问不到的原因)。

(2)网络阻塞问题(带宽有限，但同时的请求数量比较多)

如果很多人都在访问同一台服务器，但是网络带宽是一定的，比如100M带宽，大家都想挤进去，每秒只能就100M数据，后面发送的请求数据，就会阻塞在这里，也有可能访问不到这个服务器，即网络阻塞。

带宽：比如有一个数据流的管道，严格来讲，带宽就是在每秒能够承受的这个数据流的大小是多少，也就是同样的数据，细的管道每秒能传10个字节，粗的管道每秒能传100个字节，那粗的管道的带宽就是100个字节，细的带宽就是10个字节。能够同时传递数据的数量越多，那这个带宽就越大。

(3)服务器线程有限(例如tomcat端线程数量配置的相对较少)

无论是Tomcat服务器，还是JIT服务器，服务器能够提供的线程数是有限的，比如Tomcat最多支持100个线程，也就是100个并发，那这100个并发都被占用以后，后面的请求就无法访问了，就需要等待。

2.依赖冲突问题：

下面错误是maven.aliyun.com的有些资源没有下载下来。

(1)报错现象1：

(2)报错现象2：

本地库没有换新的，经常会出现此类maven依赖冲突问题。

出现此问题的原因有如下几个：

(1)maven的本地库，原先有一些资源，如果在配置maven本地库时，还是配置之前的本地库，那这个时候，之前本地库里面的一些资源和SpringBoot这个版本所需要的一些资源冲突了，从而导致新资源无法下载下来。

所以我们本地库配置时，我们需要保证它是一个全新的本地库，或者原先的本地库里没有任何内容，其实出现这个现象，最多的情况，即早期没有SpringBoot时，会经常出现这个现象，因为我们要自己去选择添加的依赖，

自己选择依赖时，比如MySQL选择什么版本，连接池选择什么版本，MyBatis选择什么版本，SpringBoot选择什么版本，可能有些版本我们选的不是特别好，兼容性不好，就会出现这种现象。

(2)但如果在配置SpringBoot时，已经是一个全新的本地库，还是出现了这种问题，那么就选择MavenUpdateProject，强制更新项目，如下图所示：

2.安装jdk与环境配置问题：

对于jdk1.8.0_191的安装与之前版本的jdk有些不同，自从Sun公司被Oracle收购以后，感觉jdk变得越来越不友好了，从朋友那里要来了一个下载好的jdk1.8.0_191压缩包，解压后目录如下：

我本来以为是绿色版，直接解压后即可使用，但配置了环境变量无效，然后发现，这个压缩包中只有jdk，却没有jre，这个jre.exe是需要安装的，于是我安装了jre，可能因为我手速太快，错过了自定义目录那一步操作，就安装到了默认目录，C:\Program Files\Java\jre1.8.0_191，这个目录中了，此时没有手动配置任何环境变量，但是cmd控制台输入命令：java -version，发现命令执行成功，但在以往的jdk版本，是必须配置环境变量以后，才能在Windows命令行窗口成功执行java命令，但这里明明没有配置环境变量，即可以成功执行，说明jre在安装之时已经默认内置了环境变量，无需自行配置，但安装了jre还不够，打开了STS开发工具，就会报如下错误：

很明显，是因为sts找不到jdk，实际这时我的jdk安装到了D盘，于是我重新配置了环境变量指向D盘的jdk，但依然报此错误，证明自行配置的环境变量无效，系统会以jre在安装时内置的环境变量配置为指引，然后我把这个之前解压好的jdk1.8.0_191，直接粘贴到了安装jre时系统默认的指定路径里，如下图所示：

打开sts工具，不再报错。

另外对于STS工具，如果直接把太可执行文件拖拽到桌面，可能会报如下错误：

此时只需要重新在STS的安装目录中，找到可执行文件，以发送快捷方式的操作发送到桌面快捷方式即可解决。

参考文章：

JDK1.8下载与安装：https://www.jianshu.com/p/00551ce7ec60

posted @ 2020-07-28 20:36 HarryVan 阅读(3952) 评论(1) 编辑收藏举报

刷新页面返回顶部

HarryVan