SpringBoot 快速搭建 helloworld

最新推荐文章于 2025-05-07 09:44:14 发布

IT__learning

最新推荐文章于 2025-05-07 09:44:14 发布

阅读量481

点赞数

分类专栏： spring boot 文章标签： spring boot

本文链接：https://blog.youkuaiyun.com/IT__learning/article/details/113871356

版权

spring boot 专栏收录该内容

19 篇文章

订阅专栏

一、pom文件编辑

1、先添加 spring-boot-starter-parent依赖

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

（1）默认配置Java1.8；
（2）默认编码格式UTF-8；
（3）提供Dependence Management进行项目依赖的版本管理；
（4）默认的资源过滤与插件配置；

注：如果我们不使用spring-boot-starter-parent作为<parent>依赖，使用自定义的，但同时还希望进行项目依赖版本的统一管理以及有Springboot自动配置等特性，则在pom.xml中添加以下依赖：

	<dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-parent</artifactId>
                <version>2.0.6.RELEASE</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

此时不需要继承spring-boot-starter-parent，但是Java的版本、编码格式等需要手动配置。

<plugin>
	<groupId>org.apache.maven.plugins</groupId>
	<artifactId>maven-compiler-plugin</artifactId>
	<version>3.8.0</version>
	<configuration>
		<source>1.8</source>
		<target>1.8</target>
		<encoding>UTF-8</encoding>
	</configuration>
</plugin>

2、添加spring-boot-starter-web依赖

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

3、修改默认容器
Spring Boot支持容器的自动配置，默认是Tomcat，当然我们也是可以进行修改的：
（1）首先我们排除spring-boot-starter-web依赖中的Tomcat：在pom文件中排除tomcat的starter

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

（2）加入Jetty容器

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

二、编写启动类

启动类必须放在包下，不能直接放在src/main/java下

package newstar.springboot;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

1、@SpringBootApplication是一个组合注解（@SpringBootConfiguration+@EnableAutoConfiguration+@ComponentScan)：@SpringBootConfiguration表明这就是一个配置类，开发者可以在这个类中配置Bean，因此这个类扮演的角色类似于applicationContext.xml文件；@EnableAutoConfiguration表明开启自动化配置（非侵入式，开发者可以使用自定义配置代替自动化配置中的任一个配置）；@ComponentScan完成包扫描。
2、项目启动类中的@ComponentScan注解可以扫描@Service、@Repository、@Component、@Controller、@RestController和@Configuration。
3、由于@ComponentScan注解默认扫描的类都位于当前类所在包下面，建议在实际项目开发中把项目启动类放在根包中。
4、若需要扫描的注解不在启动类所在包下，可以使用@SpringBootApplication(scanBasePackages="")或者@ComponentScan指定扫描路径。

项目启动类Application在根包下。

三、编写控制器类

package newstar.springboot.controller;

import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class Controller {
    @RequestMapping("/hello")
    public String hello(){
        return "hello world!";
    }
}

四、编写配置文件

1、Spring Boot全局配置文件—application.properties

Spring Boot中免除了大部分手动配置，但是对于一些特定的情况需要我们进行手动配置，Spring Boot为我们提供了application.properties配置文件，让我们可以进行自定义配置，或对默认的配置进行修改，以适应具体的生产情况，当然还包括一些第三方的配置。几乎所有配置都可以写到application.peroperties文件中，这个文件会被Spring Boot自动加载。

（1）配置文件的格式

SpringBoot可以识别两种格式的配置文件，分别是yml文件与properties文件，我们可以将application.properties文件换成application.yml，这两个文件都可以被SpringBoot自动识别并加载，但是如果是自定义的配置文件，就最好还是使用properties格式的文件，因为SpringBoot中暂时还并未提供手动加载yml格式文件的功能（这里指注解方式）。

（2）配置文件的放置位置

application.properties配置文件欲被Spring Boot自动加载，需要放置到指定的位置：src/main/resource目录下，一般自定义的配置文件也位于此目录之下。
　
配置文件加载的意思就是将文件读取到Spring容器之中，更确切的说就是将各个配置项装载到Spring上下文容器之中供随时取用。application.properties配置文件是在Spring Boot项目启动的时候被自动加载的，其内部的相关设置会自动覆盖Spring Boot默认的对应设置项，所以的配置项均会保存到Spring容器之中。

（3）配置文件的常用配置

//一、配置项目问题
server.port=8081    //配置Web容器端口号
server.servlet.context-path=/01    //配置项目访问路径，必须带'/'，默认是'/'
server.error.path=/error    //配置项目出错时跳转页面
server.tomcat.uri-encoding=utf-8    //配置Tomcat请求编码
server.tomcat.basedir=/home/sang/tmp   //配置存放tomcat运行日志和临时文件的目录
//二、配置数据源
spring.datasource.url=jdbc:mysql://localhost:3306/tanglong?useUnicode=true&characterEncoding=UTF-8&zeroDateTimeBehavior=convertToNull&allowMultiQueries=true&serverTimezone=Asia
spring.datasource.username=root
spring.datasource.password=0000
spring.datasource.driverClassName = com.mysql.cj.jdbc.Driver
spring.datasource.type = com.alibaba.druid.pool.DruidDataSource
//三、配置数据持久化
spring.jpa.show-sql= true    //是否打印sql语句
mybatis.config-location=classpath:MyBatis.xml    //mybatis配置文件路径
//四、文件上传大小配置
spring.servlet.multipart.maxFileSize=30MB
spring.servlet.multipart.maxRequestSize=30MB
//五、多种开发环境配置
 //不同环境中的配置信息可以写在其他文件中：application-dev.properties、application-test.properties 或者 application-prod.properties
 //开发/测试/生产环境分别对应dev/test/prod，可以自由定义，当前配置为开发环境
spring.profiles.active=dev

2、Spring Boot 自定义配置文件—xxx.properties

自定义的xxx.properties配置文件是不会被Spring Boot自动加载的，需要以注解的方式进行手动去进行加载：@PropertySource("classpath:xxx.properties")。这个注解专门用来加载指定位置的properties文件，但Spring暂未提供加载指定位置yml文件的注解。
注：自定义配置文件一般也放在src/main/resource目录下。

3、配置项的使用

配置项的使用其实很简单，只要是加载到Spring容器中的配置项都可以直接使用@Value("${key}")的方式来引用，一般将其配置在字段顶部，表示将配置项的值赋值给该字段。当然更多的情况是将这些配置项与一个JavaBean绑定起来使用，这样绑定一次，我们就可以随时使用。这里涉及到两种情况，一种是将application.properties中的配置与JavaBean绑定，一种是将自定义配置文件中的配置与Javabean绑定。

（1）applicaiton.properties属性绑定JavaBean

这种情况相对简单：因为application.properties文件会被自动加载，也就是说配置项会被自动加载到内存，到Spring容器之中，省去了手动加载的配置。

方法一（绑定JavaBean的方式）：
在要与属性绑定的JavaBean的类定义顶部加@Component注解和@ConfigurationProperties(prefix="key")注解。前者的目的是为了这个JavaBean可以被SpringBoot项目启动时候被扫描到并加载到Spring容器之中；@ConfigurationProperties(prefix=“key”)注解加注在JavaBean类定义之上，按字面可以理解为属性配置注解，更直接点的说法就是属性绑定注解。
//application.properties配置文件的内容 
book.name=三国演义 
book.author=罗贯中 
book.price=30  
//配置数据注入Bean 
@Component
@ConfigurationProperties(prefix="book")
 public class Book{ 	
 private String name; 	
 private String author; 	
 private Float price; 
 	} 
方法二（@Value注解直接赋值）：
在JavaBean之上加上@Configuration，然后再JavaBean的字段上以@Value("${key}")的方式来引用。
//配置数据注入Bean 
@Component 
public class Book{
	@Value("${book.name}")   //用@Value注解进行字段注入
    private String name;
    @Value("${book.author}")
    private String author;
    @Value("${book.price}")
    private Float price; 	
    } 

（2）xxx.properties 属性绑定 JavaBean

这种情况不能自动加载，需要手动加载。

方法一（绑定JavaBean的方式）：
在JavaBean之上加上之前介绍的@PropertySource("classpath:xxx.properties")注解进行配置文件加载。另外，使用@Configuration和@ConfigurationProperties(prefix = "...")。
//配置文件url.properties 
remote.uploadFilesUrl=/resource/files/
remote.uploadPicUrl=/resource/pic/
//配置数据注入Bean
@Configuration 
@PropertySource("classpath:url.properties")  //指定配置文件位置
@ConfigurationProperties(prefix = "remote") 
public class RemoteProperties { 	
private String uploadFilesUrl;   	
private String
uploadPicUrl; 
} 
方法二（@Value注解直接赋值）：
在JavaBean之上加上@PropertySource("classpath:xxx.properties")注解进行配置文件加载，以及@Configuration，然后再JavaBean的字段上以@Value("${key}")的方式来引用。
//配置数据注入Bean 
@Configuration
@PropertySource("classpath:url.properties")  //指定配置文件位置 
public class RemoteProperties { 	
@Value("${remote.uploadFilesUrl}")  //用@Value注解进行字段注入 	
private String uploadFilesUrl;
	@Value("${remote.uploadPicUrl}")   	
private String uploadPicUrl;
 }
在使用@ConfigurationProperties(prefix = "...")注解时，需在Pom.xml中添加对应依赖：
<dependency> 
    <groupId> org.springframework.boot </groupId> 
    <artifactId> spring-boot-configuration-processor </artifactId> 
   <optional> true </optional>  
</ dependency>
否则会出现Spring Boot configuration Annotation Processor not found in classpath的问题。

注意

① 配置文件的值使用时会绑定到某个类上，并在容器中创建对象。
② 配置文件加载和使用并不相关联，虽然加载的目的是为了使用，但是加载和使用之间并不是强关联的，我们完全可以加载但不使用。如果只是加载自定义配置文件，只要一个@PropertySource注解就完事，使用方面的注解不用去管，当需要使用的时候，我们完全可以选择多种使用的方式，直接使用的话我们就使用@Value注解进行直接赋值，这个注解就可以直接将被加载到Spring容器中的属性配置的值赋值到指定的字段，当然也可以使用绑定JavaBean的方式。

4、配置文件存放目录

springboot 启动会扫描以下位置的 application.properties 或者 application.yml 文件作为 Spring boot 的默认配置文件：

如果在不同的目录中存在多个配置文件，它的读取顺序是：

注意：

● 优先级由高到底，高优先级的配置会覆盖低优先级的配置；
● 如果同一个目录下，有 application.yml 也有 application.properties，默认先读取 application.properties；
● 如果同一个配置属性，在多个配置文件都配置了，默认使用第1个读取到的，后面读取的不覆盖前面读取到的；
● 创建 SpringBoot 项目时，一般的配置文件放置在“项目的resources目录下”
● 项目打包好以后，我们可以使用命令行参数的形式，启动项目的时候来指定配置文件的新位置：
java -jar spring-boot-02-config-02-0.0.1-SNAPSHOT.jar --spring.config.location=G:/application.properties 

5、多环境配置

（1）主、从配置文件模式

1）建立主配置文件和多个从配置文件

1）首先复制多个 application.properties 文件，并根据环境重命名。环境的命名为格式为：application-{profile}.properties。从而产生一个主配置文件 application.properties 和多个待指定的配置文件。

这种方式的好处就是可以把公共的变量配置在主配置文件 application.properties 中，不同环境需要的变量配置在不同的从配置文件中，比如数据库信息，线程池的大小，redis信息等。

2）指定要使用的配置文件

● 方式一：在主配置文件 application.properties 指定
使用不同的环境只需要在 application.properties 文件中添加指定环境的变量
spring.profiles.active = {profile}  
比如：spring.profiles.active = prod
如果配置文件为 yml 格式，则使用如下配置：
spring:   
	profiles:
    	active: {profile} 
● 方式二：命令行指定
ava -jar spring-boot-02-config-0.0.1-SNAPSHOT.jar --spring.profiles.active={profile}；
● 方式三：虚拟机参数指定
-Dspring.profiles.active={profile} 

（2）方式二：不同环境的配置文件放在不同文件目录下相同命名。

开发环境是dev目录，测试环境是test目录，生产环境是prod目录。每个目录下面都有application.properties文件。

这样可以在打包时选择需要的配置文件，而不用全部打包进来。
## 开发环境打包 mvn clean package -P dev
## 测试环境打包 mvn clean package -P test
## 生产环境打包 mvn clean package -P prod 

五、Spring Boot项目打包

SpringBoot 项目打包后的项目结构（以jar包为例）
在这里插入图片描述

（1）BOOT-INF 目录

1）classes：目录中存放项目代码对应的 .class 文件；
2）lib：目录中存放项目相关的依赖包，依赖包以 jar 包的方式存放（jar 文件中存放 jar 文件，有个专门称呼叫 “FatJar”）；

（2）META-INF

1）存放清单文件，其内容描述当前可执行 jar 包的基本信息 ；
2）其中，有两个主要的描述信息：

● Main-Class

描述 jar包的入口文件（main 方法所在的类）；
Spring 框架固定是 org.springframework.boot.loader.JarLauncher；
定义完此属性后，一定要有一个换行；

● Start-Class

描述自定义 main 方法的全称

（3）org

存放了一些打包 SpringBoot 项目后的相关启动类。
由于 SpringBoot 基于管理及安全性的考虑，打包使用 “项目代码与依赖包分离” 的方式（不同于以前将所有依赖包中的 .class 文件与项目的 .class 文件合并到一起的方式），因此打包后的 jar/war 包中依然包含了依赖的 jar 包，不符合 jar包的规范，依赖的 jar 包无法通过默认的加载器进行加载。为了规避 jar 文件规范，SpringBoot 使用自定义加载器去加载整个项目，于是入口就不再是编写项目时的 main 方法，而是使用 org.springframework.boot.loader.JarLauncher 类，在启动的时候创建自定义加载器去加载项目中的所有类。
因此，打包后的 SpringBoot 项目，只有 org 文件夹中的类的类加载器是 AppClassLoader，BOOT-INF 文件夹中的类和依赖包的加载器是 LaunchedURLClassLoader。

war 包的结构跟jar包结构差不多，只是多了几个目录（如 “WEB-INF/” 等）。

1、单配置环境文件的打包

（1）pom.xml添加依赖

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

（2）IDEA中打包
在这里插入图片描述
（3）打包成功

BUILD SUCCESS表示打包成功，Building jar指明了打包好的jar包的存放位置。

（4）在jar包所在目录下运行项目

查看打包目录下，确实有被打包的jar文件

在当前jar文件路径直接使用cmd通过java –jar运行项目

结果如下图

5、多配置环境文件的打包

项目目录：
在这里插入图片描述
（1）pom.xml 文件配置

<project>   
<!-- 省略其它配置，比如依赖包等 -->
 
   	<!-- 项目中的环境 说明-->
    <profiles>
        <!-- 1、开发环境 -->
        <profile>
        	<!-- 可以通过 -P ID 来激活 -->
            <id>dev</id>      <!-- ID 标识符 -->
            <properties>
            	<!-- 该 profile 中要打包进来的配置文件的所在包路径或者 ${profile} -->
                <profiles.active>dev</profiles.active>  
            </properties>
            <!-- 默认启动 dev 环境 -->
            <activation>
                <activeByDefault>true</activeByDefault> 
            </activation>
        </profile>
        <!-- 2、测试环境 -->
        <profile>
            <id>test</id>
            <properties>
                <profiles.active>test</profiles.active>
            </properties>
        </profile>
        <!-- 3、生产环境 -->
        <profile>
            <id>prod</id>
            <properties>
            	<!-- 该 profile 中要打包进来的配置文件的所在包路径或者 ${profile} -->
                <profiles.active>prod</profiles.active>
            </properties>
        </profile>
    </profiles>
 
    <!-- 打包配置 -->
    <build>
    	<!-- 打包后的 jar 包名字 -->
        <finalName>test-spring-boot</finalName>
        <resources>
            <resource>
            	<!-- 要处理的资源文件所在的路径 -->
                <directory>src/main/resources</directory>
                <filtering>true</filtering>
                <!-- 包含进来，防止打包时忽略掉除环境配置文件以外的对象 -->
                <includes>
                    <include>**/*.properties</include>
                    <include>mapper/*</include>
                    <include>logback.xml</include>
                    <include>test.json</include>
                </includes>
                <!-- 打包时自动去掉不需要的配置文件，只留下需要的配置文件 -->
                <excludes>
                    <exclude>dev/*.properties</exclude>
                    <exclude>test/*.properties</exclude>
                    <exclude>prod/*.properties</exclude>
                </excludes>
            </resource>
            <resource>
                <!-- 这个就是切换不同环境的路径，${profiles.active}profiles.active，可自定义 -->
                <directory>src/main/resources/${profiles.active}</directory>
                <filtering>true</filtering>
            </resource>
        </resources>
 
        <!-- maven 的打包插件 -->
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>  
</project>

字段讲解：

（1）<profiles></profiles> 配置项
profiles 配置项的主要作用就是区分正式环境和测试环境的配置。
我们在开发项目时一般都会区分线上环境和测试环境，这两个环境需要切换以适应不同的环境需求。
正式环境的配置，一般放置于src/main/resources下，而测试环境放置于/src/test/resources下面。
<profiles>    
        <profile>    
            <id>dev</id>   
            <properties>    
            	
                <profiles.active>dev</profiles.active>
            </properties>
            <activation>    
                <activeByDefault>true</activeByDefault>
            </activation>
        </profile> 
<profiles>
每个子元素 <profile></profile> 表示一个配置文件，其主要配置字段有：

● <id>：必须唯一，可以设置为配置文件的{profile}字段或者所在包名；
● <properties> ：

● <profiles.active>：指定该 profile 中要打包进来的配置文件的所在包路径或者其 ${profile}，如果不指定则打包后的 jar 没有配置文件
● 配置文件中的字段：如 <username>lhj</username>

● <activation>：

● <activeByDefault>true</activeByDefault>：指定该 profile 默认生效

（2）<build><build> 配置项
<build>
    	
        <finalName>test-spring-boot</finalName>
        <resources>
            <resource>
            	
                <directory>src/main/resources</directory>
                <filtering>true</filtering>
                
                <includes>
                    <include>**/*.properties</include>
                    <include>mapper/*</include>
                    <include>log.xml</include>
                </includes>
                 
                <excludes>
                    <exclude>dev/*.properties</exclude>
                    <exclude>test/*.properties</exclude>
                    <exclude>prod/*.properties</exclude>
                </excludes>
            </resource>
        </resources>
 
        
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
</build>   
<build> 标签有两种：全局标签和 <profile> 的子标签两种，都可以进行打包构建配置。
各字段如下：
● <finalName>：指定打包后的 jar 包名字；
● <resources>：一个<resource>元素的列表，每一个都描述与项目关联的文件是什么和在哪里，用于包含或者排除某些资源文件。<resource>元素常用字段如下：

● <directory>：资源文件的路径，默认位于 /src/main/resources 目录下；
● <filtering>：构建过程中是否对资源进行过滤,默认false；
● <filters>：给出对资源文件进行过滤的属性文件的路径，默认位于 /src/main/filters/ 目录下，属性文件>>中定义若干键值对。在构建过程中，对于资源文件中出现的变量(键)，将使用属性文件中该键对应的>>值替换。
● <includes>：用来圈定该文件目录下的哪些文件要被打包到 jar 包中。
● <excludes>：用来排除该文件目录下的哪些文件要不会被打包到 jar 包中。

如果 <include> 与 <exclude> 划定的范围存在冲突时，以 <exclude> 划定的范围为准。在一个工程中，src/main/resources 目录下都是工程的资源文件，则并不需要 <include> 和 <exclude> 再进行划定。

（2）使用 maven 为不同环境进行打包

1） profile 里面使用 <activation> 标签，当满足条件时激活该 profile 并打包

<profile>
 <id>prod</id>
 <properties>
 	<profiles.active>prod</profiles.active>
 </properties>
 <!--activation用来指定激活方式-->
 <activation>

 	<!--配置默认激活-->
 	<activeByDefault>true</activeByDefault>

 	<!--activation有一个内建的java版本检测，如果检测到jdk版本与期待的一样，profile被激活。 -->  
       <jdk>1.7</jdk>    
 	
 	<!-- os元素可以定义一些操作系统相关的属性。当操作系统满足下述所有条件时，激活。 如果有多个条件，那么必须所有条件都满足时，才会激活对应的profile-->
       <os>  
            <!--激活profile的操作系统的名字 -->  
       	<name>Windows XP</name>    
            <!--激活profile的操作系统所属家族(如 'windows') -->  
            <family>Windows</family>    
            <!--激活profile的操作系统体系结构 -->  
            <arch>x86</arch>    
            <!--激活profile的操作系统版本 -->  
            <version>5.1.2600</version>    
       </os>    
       
       <!--如果Maven检测到某一个属性（其值可以在POM中通过${名称}引用），其拥有对应的名称和值，Profile就会被激活。 -->  
       <!-- 如果值字段是空的，那么存在属性名称字段就会激活profile，否则按区分大小写方式匹配属性值字段 -->  
       <property>    
           <!--激活profile的属性的名称 -->  
           <name>profileProperty</name>    
           <!--激活profile的属性的值 -->  
           <value>dev</value>    
       </property>    
       
       <!-- 根据文件存在与否，来激活 profile。
           文件路径可以是绝对路径，也可以是相对路径(相对pom.xml的路径)。
           missing与exists最好不要同时使用。 如果同时使用的话，missing就会形同虚设，是否激活此profile完全由exists决定。 --！>
       <!--missing检查文件是否存在，如果不存在则激活profile。exists则会检查文件是否存在，如果存在则激活profile。 -->  
       <file>  
           <!--如果指定的文件存在，则激活profile。 -->  
           <exists>/usr/local/hudson/hudson-home/jobs/maven-guide-zh-to-production/workspace/</exists>  
           <!--如果指定的文件不存在，则激活profile。 -->  
           <missing>/usr/local/hudson/hudson-home/jobs/maven-guide-zh-to-production/workspace/</missing>    
       </file> 
 </activation>
</profile>

注：默认激活级别最低！一旦其它某个激活指令(mvn指令激活或activation的其他条件激活)生效时，那么默认激活指令就不会生效。

2）使用 maven 命令针对不同 profile 进行打包：

mvn clean package -P dev
mvn clean package -P test
mvn clean package -P prod

执行命令，指定 -P 参数为要打包的 profile 的 id 值，从而打包启用指定的 profile。
得到的jar包文件如下：
在这里插入图片描述
3）通过 maven 窗口进行打包

先勾选要打包的 profile，在进行 package。