SpringBoot 简单开发流程（详解）

最新推荐文章于 2024-04-29 21:37:46 发布

Eeerosss

最新推荐文章于 2024-04-29 21:37:46 发布

阅读量7.8k

点赞数 3

本文链接：https://blog.csdn.net/weixin_62282158/article/details/127068007

版权

一，简介

Spring Boot是由Pivotal团队提供的全新框架，其设计目的是用来简化新Spring应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置。通过这种方式，Spring Boot致力于在蓬勃发展的快速应用开发领域(rapid application development)成为领导者。

Spring Boot提供了一种新的编程范式，能在最小的阻力下开发Spring应用程序。有了它，开发人员可以更加敏捷地开发Spring应用程序，专注于应用程序的功能，不用在Spring的配置上多花功夫，甚至完全不用配置。实际上，Spring Boot的一项重要工作就是让Spring配置不再成为开发路上的绊脚石。

spring boot并不是一个全新的框架，它不是spring解决方案的一个替代品，而是spring的一个封装。所以，以前可以用spring做的事情，现在用spring boot都可以做。

现在流行微服务与分布式系统，Spring boot就是一个非常好的微服务开发框架，可以使用它快速的搭建起一个系统。同时，你也可以使用spring Cloud（Spring Cloud是一个基于Spring Boot实现的云应用开发工具）来搭建一个分布式的网站。

二，SpringBoot的优点

使编码变得简单

SpringBoot采用Java config的方式，对Spring进行配置，并且提供了大量的注解，极大地提高了工作效率。

使配置变得简单

spring boot提供许多默认配置，当然也提供自定义配置。但是所有spring boot的项目都只有一个配置文件：application.properties/application.yml。用了spring boot，再也不用担心配置出错找不到问题所在了。

使部署变得简单

spring boot内置了三种servlet容器：tomcat，jetty，undertow

名称	Servlet版本	Java版本
Tomcat 8	3.1	Java 7+
Tomcat 7	3	Java 6+
Jetty 9	3.1	Java 7+
Jetty 8	3	Java 6+
Undertow 1.1	3.1	Java 7+

所以，只需要一个Java的运行环境就可以运行SpringBoot的项目了。SpringBoot的项目可以打成一个jar包，然后通过java -jar xxx.jar来运行。（SpringBoot项目的入口是一个main方法，运行该方法即可）

也可以将Spring Boot应用部署到任何兼容Servlet 3.0+的容器。

使监控变得简单

SpringBoot提供了actuator包，可以使用它来对应用进行监控。

三，微服务架构

微服务是一种架构风格，一个大型复杂软件应用由一个或多个微服务组成。系统中的各个微服务可被独立部署，各个微服务之间是松耦合的。每个微服务仅关注于完成一件任务并很好地完成该任务。在所有情况下，每个任务代表着一个小的业务能力。

例如要开发一个购票系统。就可以简单的拆分为用户管理微服务和售票系统微服务。两个服务都可以独立运行，都有自己的数据库，他们之间通过HTTP API 进行通信。

而SpringBoot就是搭建微服务的一个很好的选择。

微服务一般都是运行在分布式环境中的，这可不是简单的写一个SSM框架的小程序就可以解决的，其中需要用到很多技术，比如负载均衡，反向代理，服务治理，配置管理，消息总线等，SpringCloud提供了这些技术。并且，SpringCloud生态是基于spring boot的。

四，SpringBoot的创建，使用

可以像使用其他任何标准Java库那样使用SpringBoot，只需简单地在classpath下包含正确的 spring-boot-*.jar 文件。 SpringBoot不需要集成任何特殊的工具，所以可以使用任何IDE或文本编辑器；Spring Boot应用也没有什么特殊之处，所以可以像任何其他Java程序那样运行和调试。

尽管可以拷贝SpringBoot jars，不过，通常推荐使用一个支持依赖管理的构建工具（比如Maven或Gradle）或者内嵌依赖管理工具的IDE，如Spring的官方IDE-STS。

项目创建

可以选择打包方式

可以选择需要的依赖

完成项目创建后添加为Maven项目

首先设置Maven的路径

将项目创建为Maven管理项目

配置.pom文件添加起步依赖

<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-tomcat</artifactId>
			<scope>provided</scope>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
		<!--MybatisSpring整合-->
		<dependency>
			<groupId>org.mybatis.spring.boot</groupId>
			<artifactId>mybatis-spring-boot-starter</artifactId>
			<version>2.0.0</version>
		</dependency>

		<!--测试-->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-tomcat</artifactId>
		</dependency>
		<!-- Springboot 外部的Tomcat支持  没有这个，不能访问jsp页面-->
		<dependency>
			<groupId>org.apache.tomcat.embed</groupId>
			<artifactId>tomcat-embed-jasper</artifactId>
		</dependency>

		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>jstl</artifactId>
		</dependency>

		<!-- 数据库支持 -->
		<dependency>
			<groupId>org.mybatis</groupId>
			<artifactId>mybatis</artifactId>
			<version>3.4.4</version>
		</dependency>

		<!-- 数据库连接 -->
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<scope>runtime</scope>
			<version>8.0.13</version>
		</dependency>

		<!-- 1.日志 -->
		<dependency>
			<groupId>log4j</groupId>
			<artifactId>log4j</artifactId>
			<version>1.2.17</version>
		</dependency>

		<!--热部署的支持-->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-devtools</artifactId>
		</dependency>
	</dependencies>

项目基本创建完成

项目的配置

.yml文件的配置

包括项目端口设置，项目路径设置，视图解析器，数据库连接池的配置，mybatis的配置。

五，SpringBoot的启动和退出相关

启动

SpringApplication类提供了一种从main()方法启动Spring应用的便捷方式。在很多情况下，只需委托给SpringApplication.run这个静态方法：

package com.eeerosss;

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

@SpringBootApplication
public class SpringbootStartApplication {

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

}

通过在classpath下添加一个banner.txt或设置banner.location来指定相应的文件可以改变启动过程中打印的banner（即启动时正常日志前拼接出来的Spring部分）。如果这个文件有特殊的编码，可以使用banner.encoding设置它（默认为UTF-8）。

名称	描述
${application.version}	MANIFEST.MF中声明的应用版本号，例如1.0
${application.formattedversion}	MANIFEST.MF中声明的被格式化后的应用版本号（被括号包裹且以v作为缀），用于显示，例如(v1.0)
${spring-boot.version}	正在使用的Spring Boot版本号，例如1.5.0.BUILD-SNAPSHOT
${spring-boot.formatted-version}	正在使用的Spring Boot被格式化后的版本号（被括号包裹且以 v作为缀） , 用于显示，例如(v1.5.0.BUILD-SNAPSHOT)

在banner.txt配置

展示出springboot的版本

退出

每个SpringApplication在退出时为了确保ApplicationContext被优雅的关闭，将会注册一个JVM的shutdown钩子。所有标准的Spring生命周期回调（比如，DisposableBean接口或@PreDestroy注解）都能使用。

如果beans想在应用结束时返回一个特定的退出码（exit code），可以实现org.springframework.boot.ExitCodeGenerator接口

六，属性注入

Spring Boot在程序中允许使用外部的配置文件获取配置信息，这样就能够在不同的环境下使用相同的代码。

外部配置支持使用properties文件，YAML文件，环境变量和命令行参数。

使用@Value注解，可以直接将属性值注入到beans中。

Spring Boot使用一个非常特别的PropertySource次序来允许对值进行合理的覆盖，需要以下面的次序考虑属性：

1. 命令行参数

2. 来自于java:comp/env的JNDI属性

3. Java系统属性（System.getProperties()）

4. 操作系统环境变量

5. 只有在random.*里包含的属性会产生一个RandomValuePropertySource

6. 在打包的jar外的应用程序配置文件（application.properties，包含YAML和profile变量）

7. 在打包的jar内的应用程序配置文件（application.properties，包含YAML和profile变量）

8. 在@Configuration类上的@PropertySource注解

9. 默认属性（使用SpringApplication.setDefaultProperties指定）

简单案例

#管理监控端口
management.server.port=9999
#设置端口
server.port=1234
info.app.name=springboot
info.app.description=springboot-start
info.app.version=1.0

name=zhangSan
my.secret=${random.value}
my.number=${random.int}
my.bignumber=${random.long}
my.number.less.then.ten=${random.int(10)}
my.number.in.range=${random.int[1024,2048]}

app.name=zhangSi
app.info=${app.name}'s info

对应实体类属性

 /**
     * 名字
     */
    @Value("${name}")
    private String name;
    /**
     * 随机字符串
     */
    @Value("${my.secret}")
    private String secret;
    /**
     * 随机整数
     */
    @Value("${my.number}")
    private int number;
    /**
     * 随机长整数
     */
    @Value("${my.bignumber}")
    private  long bignumber;
    /**
     * 十以内随机整数
     */
    @Value("${my.number.less.then.ten}")
    private String numberLessThenTen;
    /**
     * 范围内整数
     */
    @Value("${my.number.in.range}")
    private int numIntRange;
    @Value("app.name")
    private String name2;
    @Value("${app.info}")
    private String info;

可以像上述示例一样将application.properties文件打包到jar文件内，用来提供一个合理的默认name属性值。当运行在生产环境时，可以在 jar外提供一个application.properties文件来覆盖name属性。

对于一次性的测试，还可以使用特定的命令行开关启动（比如， java -jar app.jar --name="Spring"）

默认情况下， SpringApplication将任何可选的命令行参数（以'--'开头，比如， --server.port=9000）转化为property，并将其添加到Spring Environment中。

命令行属性总是优先于其他属性源。

如果不想将命令行属性添加到Environment里，则可以使用SpringApplication.setAddCommandLineProperties(false)来禁止它们。

SpringApplication将从以下位置加载application.properties文件，并把它们添加到Spring环境上下文中：

当前目录

classpath下的/config包

classpath根路径（项目root）

这个列表是按优先级排序的（列表中位置高的将覆盖位置低的），同时也可以使用YAML文件替代properties文件。

如果不希望使用默认的application.properties作为配置文件名，可以通过指定spring.config.name环境属性来切换其他的名称。也可以使用spring.config.location环境属性来引用一个明确的路径（目录位置或文件路径列表以逗号分割）：

java -jar myproject.jar --spring.config.name=myproject
java -jar myproject.jar --spring.config.location=classpath:/default.properties,classpath:/override.properties

如果spring.config.location包含目录（相对于文件），那它们应该以/结尾（在加载前， spring.config.name产生的名称将被追加到后面）。不管spring.config.location是什么值，默认的搜索路径classpath:,classpath:/config,file:,file:config/总会被使用。

以这种方式，可以在application.properties中为应用设置默认值，然后在运行的时候使用不同的文件覆盖它，同时保留默认配置。

如果使用环境变量而不是系统配置，大多数操作系统不允许以点分割的key名称，在这种情况下可以使用下划线代替（比如，使用SPRING_CONFIG_NAME代替spring.config.name）。如果应用运行在一个容器中，那么JNDI属性（java:comp/env）或servlet上下文初始化参数可以用来取代环境变量或系统属性，当然也可以使用环境变量或系统属性。

当application.properties里的值被使用时，它们会被存在的环境过滤，所以能够引用先前定义的值（如系统属性）：

app.name=zhangSi
app.info=${app.name}'s info

七，SpringBootProfile

在项目开发的时候，生产环境和测试环境的一些配置可能会不一样，有时候一些功能也可能会不一样，所以可能会在上线的时候手工修改这些配置信息。但是Spring中提供了Profile功能。只需要在启动的时候添加一个虚拟机参数，激活环境所要用的Profile就可以了。

除了application.properties文件，特定配置属性也能通过Profile配置文件application-{profile}.properties来定义。特定Profile属性跟标准application.properties相同的路径加载，并且特定profile文件会覆盖默认的配置。
创建一个bean，用来测试是不是从不同的配置文件中取的值（代码中使用了统一的属性注入注解，也可以使用Value逐一对每个属性进行注入）

在项目的classpath中创建两个profile对应的配置文件：

application-dev.properties：

profile.test.userName=zhangSan
profile.test.passWord=123456

application-prod.properties：

profile.test.userName=liSi
profile.test.passWord=654321

对应实体类

package com.eeerosss.profile;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

/**
 * @author : Eeerosss
 * @create 2022/9/23 14:55
 */
@Component
@ConfigurationProperties("profile.test")
public class ProfileDomain {
    private String userName;
    private String passWord;

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getPassWord() {
        return passWord;
    }

    public void setPassWord(String passWord) {
        this.passWord = passWord;
    }
}

在Eenironment variables中设置要调用的配置文件

开发环境：spring.profiles.active=dev

生产环境：spring.profiles.active=prod

有时候可能还会有这样的需求：生产环境或者开发环境我们所看到的功能是不同的，也需要我们根据配置项来激活不同的功能，这种情况下，先定义一个Service的接口：

  public String getProfileDomain();

提供两种Profile的实现：

运行环境

@Service
@Profile("dev")
public class ProfileDevServiceImpl implements ProfileService {
    @Override
    public String getProfileDomain() {
        StringBuffer buffer = new StringBuffer("我是运行环境，我吃:");
        buffer.append("米饭");
        return buffer.toString();
    }
}

生产环境

@Service
@Profile("pro")
public class ProfileProServiceImpl implements ProfileService {
    @Override
    public String getProfileDomain() {
        StringBuffer buffer = new StringBuffer("我是生产环境，我吃:");
        buffer.append("肉");
        return buffer.toString();
    }
}

编写控制器查看使用的环境

@RestController
public class IndexController {
    @Autowired
    ProfileService profileService;

 
    @RequestMapping("/serviceinfo")
    public  String serviceInfo(){
        return profileService.getProfileDomain();
    }
}

编写启动类

@SpringBootApplication
public class SpringbootProfileApplication implements CommandLineRunner {
    @Autowired
    ProfileService profileService;
    public static void main(String[] args) {
        SpringApplication.run(SpringbootProfileApplication.class, args);
    }

    @Override
    public void run(String... args) throws Exception {
        System.out.println(profileService.getProfileDomain());
    }
}

运行结果

八，YAML配置

可以使用YAML文件代替properties文件作为项目配置。

YAML是JSON的一个超集，也是一种方便的定义层次配置数据的格式。

将SnakeYAML库放到classpath下，Spring Boot都会自动支持YAML作为properties的替换。

如果你使用starter POMs，spring-boot-starter会自动提供SnakeYAML，这就意味着在绝大部分情况下YAML的支持都是默认提供的。

对于较复杂的数据结构来说，YAML远远优于properties。

在处理层级关系的时候，properties需要使用大量的路径来描述层级（或者属性），比如environments.dev.url和environments.dev.name。其次，对于较为复杂的结构，比如数组，写起来更为复杂。而对应的YAML格式文件就简单很多

YAML使用冒号加缩进的方式代表层级（属性）关系，使用短横杠(-)代表数组元素。

YAML中允许表示三种格式，分别是常量值，对象和数组：

和properties相同，使用#作为注释，YAML中只有行注释

YAML文件基本格式要求：

YAML大小写敏感；

使用缩进代表层级关系；

缩进只能使用空格，不能使用TAB，不要求空格个数，只需要相同层级左对齐（一般2个或4个空格）

对象

使用冒号代表，格式为key: value。冒号后面要加一个空格：

可以使用缩进表示层级关系：

YAML中还支持流式(flow)语法表示对象，比如上面例子可以写为：

较为复杂的对象格式，可以使用问号加一个空格代表一个复杂的key，配合一个冒号加一个空格代表一个value：

意思即对象的属性是一个数组[complexkey1,complexkey2]，对应的值也是一个数组[complexvalue1,complexvalue2]

使用一个短横线加一个空格代表一个数组项：

也可以有这样的写法(可以简单理解为：[[Java,LOL]])：

一个相对复杂的例子：

数组也可以使用流式(flow)的方式表示：

YAML中提供了多种常量结构，包括：整数，浮点数，字符串，NULL，日期，布尔，时间。下面使用一个例子来快速了解常量的基本使用：

多个YAML配配置可以在同一个文件中，使用---表示一个文档的开始；比如Springboot中profile的定义：

上例代表定义了两个profile，一个是development，一个production

Spring框架提供两个便利的类用于加载YAML文档，YamlPropertiesFactoryBean会将YAML作为Properties来加载，YamlMapFactoryBean会将YAML作为Map来加载。

YAML列表被表示成使用[index]间接引用作为属性keys的形式，例如下面的YAML：

将会转化到下面的属性中:

使用前例用过的@ConfigurationProperties注入列表属性，需要确定目标bean中有个java.util.List或Set类型的属性，并且需要提供一个setter或使用可变的值初始化它，比如，下面的代码将绑定上面的属性：

可以在单个文件中定义多个特定Profile配置的YAML文档，并通过一个spring.profiles key标示应用的文档。例如：

正如前例中看到的，使用@Value(“${property}”)注解注入配置属性有时可能比较笨重，特别是需要使用多个properties或数据本身有层次结构。为了控制和校验应用配置， Spring Boot提供一个允许强类型beans的替代方法来使用properties：

可以通过在@EnableConfigurationProperties注解中直接简单的列出属性类来快捷的注册@ConfigurationProperties bean的定义：

Spring Boot使用一些宽松的规则用于绑定Environment属性到@ConfigurationProperties beans，所以Environment属性名和bean属性名不需要精确匹配。常见的示例中有用的包括虚线分割（如context--path绑定到contextPath）和将环境属性转为大写字母（比如，PORT绑定port）。下面的属性名都能用于上面的@ConfigurationProperties类：

属性	说明
person.firstName	标准驼峰命名规则
person.first-name	虚线表示，推荐用于.properties和.yml文件中
PERSON_FIRST_NAME	大写形式，使用系统环境变量时推荐

九，web相关

Spring Boot非常适合开发web应用程序。可以使用内嵌的Tomcat， Jetty或Undertow轻轻松松地创建一个HTTP服务器。大多数的web应用都使用spring-boot-starter-web模块进行快速搭建和运行。

Spring Web MVC框架（通常简称为“Spring MVC”）是一个“模型，视图，控制器”的web框架。 Spring MVC允许创建特定的@Controller或@RestController beans来处理传入的HTTP请求。使用@RequestMapping注解可以将控制器中的方法映射到相应的HTTP请求。

Spring Boot为Spring MVC提供适用于多数应用的自动配置功能。在Spring默认基础上，自动配置添加了以下特性：

引入ContentNegotiatingViewResolver和BeanNameViewResolver beans。

对静态资源的支持，包括对WebJars的支持。

自动注册Converter， GenericConverter， Formatter beans。

对HttpMessageConverters的支持。

自动注册MessageCodeResolver。

对静态index.html的支持。

对自定义Favicon的支持。

如果想全面控制Spring MVC，可以添加自己的@Configuration，并使用@EnableWebMvc对其注解。如果想保留Spring Boot MVC的特性，并只是添加其他的MVC配置(拦截器， formatters，视图控制器等)，可以添加自己的WebMvcConfigurerAdapter类型的@Bean（不使用@EnableWebMvc注解）。

Spring MVC使用HttpMessageConverter接口转换HTTP请求和响应。合理的缺省值被包含的恰到好处，例如：

对象可以自动转换为JSON（使用Jackson库）或XML（如果Jackson XML扩展可用则使用它，否则使用JAXB）

字符串默认使用UTF-8编码

如果需要添加或自定义转换器，可以使用Spring Boot的HttpMessageConverters类：

任何在上下文中出现的HttpMessageConverter bean将会添加到converters列表，可以通过这种方式覆盖默认的转换器（converters）。

默认情况下， Spring Boot从classpath下一个叫/static（/public， /resources或/META-INF/resources）的文件夹或从ServletContext根目录提供静态内容。这使用了Spring MVC的ResourceHttpRequestHandler，所以可以通过添加自己的WebMvcConfigurerAdapter并覆写addResourceHandlers方法来改变这个行为（加载静态文件）。

在一个单独的web应用中，容器默认的servlet是开启的，如果Spring决定不处理某些请求，默认的servlet作为一个回退（降级）将从ServletContext根目录加载内容。大多数时候，这不会发生（除非修改默认的MVC配置），因为Spring总能够通过DispatcherServlet处理请求。

此外，上述标准的静态资源位置有个例外情况是Webjars内容。任何在/webjars/**路径下的资源都将从jar文件中提供，只要它们以Webjars的格式打包。

注：如果应用将被打包成jar，那就不要使用src/main/webapp文件夹。尽管该文件夹是一个共同的标准，但它仅在打包成war的情况下起作用，并且如果产生一个jar，多数构建工具都会静悄悄的忽略它。

可以使用Spring MVC提供动态HTML内容。

Spring MVC支持各种各样的模板技术，包括Velocity,FreeMarker和JSPs。很多其他的模板引擎也提供它们自己的Spring MVC集成Spring Boot为以下的模板引擎提供自动配置支持：

FreeMarker

Groovy

Thymeleaf

Velocity

如果可能的话，应该忽略JSPs，因为在内嵌的servlet容器使用它们时存在一些已知的限制。当你使用这些引擎的任何一种，并采用默认的配置，模板将会从src/main/resources/templates目录下自动加载。

如果要使用JSP，那么需要在项目的POM文件中加入如下依赖：

<dependency>
			<groupId>org.apache.tomcat.embed</groupId>
			<artifactId>tomcat-embed-jasper</artifactId>
		</dependency>
<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>jstl</artifactId>
		</dependency>

Spring Boot默认提供一个/error映射用来以合适的方式处理所有的错误，并且它在servlet容器中注册了一个全局的错误页面。对于机器客户端（相对于浏览器而言，浏览器偏重于人的行为），它会产生一个具有详细错误， HTTP状态，异常信息的JSON响应。对于浏览器客户端，它会产生一个白色标签样式（whitelabel）的错误视图，该视图将以HTML格式显示同样的数据（可以添加一个解析为erro的View来自定义它）。为了完全替换默认的行为，你可以实现ErrorController，并注册一个该类型的bean定义，或简单地添加一个ErrorAttributes类型的bean以使用现存的机制，只是替换显示的内容。如果在某些条件下需要比较多的错误页面，内嵌的servlet容器提供了一个统一的Java DSL（领域特定语言）来自定义错误处理。

@Controller
public class ErrorPageController implements ErrorController {

    Logger logger = Logger.getLogger(ErrorPageController.class);

    public static final String ERROR_PATH = "/error";

    @RequestMapping(ERROR_PATH)
    public String error(){
        logger.info("进入了错误页面的控制器当中...");
        return "error404";
    }

    @Override
    public String getErrorPath() {
        return ERROR_PATH;
    }
}

也可以使用常规的Spring MVC特性来处理错误，比如@ExceptionHandler方法和@ControllerAdvice。 ErrorController将会捕获任何没有处理的异常

十，常用注解汇总

@SpringBootApplication

包含了@ComponentScan、@Configuration和@EnableAutoConfiguration注解。其中@ComponentScan让spring Boot扫描到Configuration类并把它加入到程序上下文。

@ResponseBody

表示该方法的返回结果直接写入HTTP response body中，一般在异步获取数据时使用，用于构建RESTful的api。在使用@RequestMapping后，返回值通常解析为跳转路径，加上@Responsebody后返回结果不会被解析为跳转路径，而是直接写入HTTP response body中。比如异步获取json数据，加上@Responsebody后，会直接返回json数据。该注解一般会配合@RequestMapping一起使用。

@RequestMapping

提供路由信息，负责URL到Controller中的具体函数的映射。

@ComponentScan

组件扫描，可自动发现和装配一些Bean，@ComponentScan主要就是定义扫描的路径从中找出标识了需要装配的类自动装配到spring的bean容器中如@Controller，@Service，@Repository注解中有一个共同的注解@Component，@ComponentScan注解默认就会装配标识了@Controller，@Service，@Repository，@Component注解的类到spring容器中

@Configuration

等同于spring的XML配置文件；使用Java代码可以检查类型安全。

@EnableAutoConfiguration

自动配置

@Controller

用于定义控制器类，在spring项目中由控制器负责将用户发来的URL请求转发到对应的服务接口（service层），一般这个注解在类中，通常方法需要配合注解@RequestMapping。

@RestController

@Controller和@ResponseBody的合集,表示这是个控制器bean,并且是将函数的返回值直接填入HTTP响应体中,是REST风格的控制器。

@Autowired

自动导入

@PathVariable

获取参数。等同于spring的XML配置文件；使用Java代码可以检查类型安全。

@ImportResource

注解加载xml配置文件

@Import

用来导入其他配置类。

@Repository

使用@Repository注解可以确保DAO或者repositories提供异常转译，这个注解修饰的DAO或者repositories类会被ComponetScan发现并配置，同时也不需要为它们提供XML配置项。

@Bean

用@Bean标注方法等价于XML中配置的bean

@Value

注入Spring boot application.properties配置的属性的值。

@Qualifier

当有多个同一类型的Bean时，可以用@Qualifier(“name”)来指定。与@Autowired配合使用。@Qualifier限定描述符除了能根据名字进行注入，但能进行更细粒度的控制如何选择候选者。

Spring Boot为Spring MVC提供适用于多数应用的自动配置功能。在Spring默认基础上，自动配置添加了以下特性：引入ContentNegotiatingViewResolver和BeanNameViewResolver beans，对静态资源的支持，包括对WebJars的支持，自动注册Converter， GenericConverter， Formatter beans，对HttpMessageConverters的支持，自动注册MessageCodeResolver，对静态index.html的支持，对自定义Favicon的支持。

Eeerosss

关注

3
点赞
踩
40

收藏

觉得还不错? 一键收藏
0
评论
SpringBoot 简单开发流程（详解）

Spring Boot是由Pivotal团队提供的全新框架，其设计目的是用来简化新Spring应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置。通过这种方式，Spring Boot致力于在蓬勃发展的快速应用开发领域(rapid application development)成为领导者。
复制链接

扫一扫