SpringBoot 学习心得（一） 使用Maven 完成Helloworld

SpringBoot 学习心得（一） 使用Maven 完成Helloworld

一、创建maven项目

我们可以使用IDEA以及Eclipse开发SpringBoot项目，这里推荐使用IDEA开发，idea集成了SpringBoot的启动框架，eclipse需要下载插件才能进行创建。

我们首先创建项目：

1.IDEA创建maven项目

打开IDEA->maven->输入Group ID:com.nwpu ArtifactId:hellospringboot->创建成功

2.Eclipse创建Maven项目

打开Eclipse->maven->next->勾选Create a simple project->next->输入Group ID:com.nwpu ArtifactId:hellospringboot->finish->创建成功

二、添加依赖

我们创建一个比较简单的SpringBoot应用所以添加依赖如下：

1.添加父依赖：

    <parent>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-parentartifactId>
        <version>2.1.6.RELEASEversion>
    parent>

2.引入starter依赖：

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

3.完整xml文件：

<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">
    <modelVersion>4.0.0modelVersion>
    <groupId>com.nwpugroupId>
    <artifactId>HelloSpringBootartifactId>
    <version>1.0-SNAPSHOTversion>
    
    <parent>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-parentartifactId>
        <version>2.1.6.RELEASEversion>
    parent>
    
    <dependencies>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-webartifactId>
        dependency>
    dependencies>
project>

三、创建主程序

部分老版本的Eclipse创建时main目录下没有java文件夹，我们需要创建一个java文件夹

在java目录下创建->com.nwpu.hellospringboot

在hellospringboot中创建App.class

代码如下：

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

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

四、创建HelloController

在主程序同级目录下创建package->controller->HelloController.class

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

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

五、运行主程序

点击主程序App.class 运行

这时我们打开浏览器输入:http://localhost:8080/hello

得到Hello World!

六、原理讲解

1.父依赖的作用

点进父项目：spring-boot-starter-parent 我们可以发现它依赖于另外一个父项目：spring-boot-dependencies

 <parent>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-parentartifactId>
        <version>2.1.6.RELEASEversion>
 parent>

它的父项目：
<parent>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-dependenciesartifactId>
    <version>2.1.6.RELEASEversion>
    <relativePath>../../spring-boot-dependenciesrelativePath>
parent>

在spring-boot-dependencies中我们在：中的依赖版本号

spring-boot-dependencies管理的是我们依赖的版本号,也称为SpringBoot版本仲裁中心

所以在我们项目导入依赖的我们就可以不添加版本号了

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

2.导入的依赖

spring-boot-starter：场景启动器

spring-boot-starter-web：帮我们导入web模块运行的依赖包

点进spring-boot-starter-web我们可以看到：

 <dependencies>
    <dependency>
      <groupId>org.springframework.bootgroupId>
      <artifactId>spring-boot-starterartifactId>
      <version>2.1.6.RELEASEversion>
      <scope>compilescope>
    dependency>
    <dependency>
      <groupId>org.springframework.bootgroupId>
      <artifactId>spring-boot-starter-jsonartifactId>
      <version>2.1.6.RELEASEversion>
      <scope>compilescope>
    dependency>
    <dependency>
      <groupId>org.springframework.bootgroupId>
      <artifactId>spring-boot-starter-tomcatartifactId>
      <version>2.1.6.RELEASEversion>
      <scope>compilescope>
    dependency>
    <dependency>
      <groupId>org.hibernate.validatorgroupId>
      <artifactId>hibernate-validatorartifactId>
      <version>6.0.17.Finalversion>
      <scope>compilescope>
    dependency>
    <dependency>
      <groupId>org.springframeworkgroupId>
      <artifactId>spring-webartifactId>
      <version>5.1.8.RELEASEversion>
      <scope>compilescope>
    dependency>
    <dependency>
      <groupId>org.springframeworkgroupId>
      <artifactId>spring-webmvcartifactId>
      <version>5.1.8.RELEASEversion>
      <scope>compilescope>
    dependency>
  dependencies>

它自动导入数据校验，有springmvc，以及Tomcat等，web模块中内嵌tomcat，所以我们启动主程序后，tomcat也自动运行了

这当然有另外一个好处，就是部署网站更加的方便，之前我们部署项目到服务器上，还需要在服务器中配置tomcat，现在我们只需要将包导入服务器中，输入java -jar 包名，我们就可以完成部署了。

3.主程序讲解

我们点击@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 {

1.@SpringBootConfiguration

@SpringBootConfiguration：SpringBoot配置类

​ @Configuration ：用于定义配置类：是容器中的一个组件

​ Spring是使用配置文件完成配置

​ SpringBoot是使用配置类完成配置

2.@EnableAutoConfiguration

@EnableAutoConfiguration：开启自动配置功能

​ SpringBoot 帮助我们自动进行配置

点进@EnableAutoConfiguration

@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {

@AutoConfigurationPackage 自动配置包

​ @Import(AutoConfigurationPackages.Registrar.class)

​ 给容器中导入一个组件，导入的组件有AutoConfigurationPackages.Registrar.class

我们点进@Import(AutoConfigurationPackages.Registrar.class)中的Registrar

@Override
		public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
			register(registry, new PackageImport(metadata).getPackageName());
		}

​ 我们可以加入断点进入debug查看：

​ 我们可以发现，它将主配置类@SpringBootConfiguration标注的类，以及所在包下面的说有子包里面的所有组件扫描到Spring容器中。

@Import(AutoConfigurationImportSelector.class)

import作用：给容器中导入一些组件：导入AutoConfigurationImportSelector.class

AutoConfigurationImportSelector.class：

将所有需要导入的组件以全类名的方式返回；

会给容器中导入非常多的自动配置类（xxxAutoConfiguraion）：就是给容器中导入这个场景需要的所有组件，并配置好这些组件；

有了自动配置类，免去了我们手动编写配置注入功能等工作；

SpringBoot 在启动的时候从类路径下的META-INF/spring.factories中获取EnableAutoConfiguration的指定值，将这些值作为自动配置类导入到容器中，自动配置类生效后，帮我们进行自动配置工作。

在External Libraries中：

spring-boot-autoconfigure-2.1.6 RELEASE包中

org.springframework.boot.autoconfigure：包含所有的自动配置文件

当我们需要进行修改配置时，我们修改这其中的文件。

3.@ComponentScan

这部分推荐阅读官方文档：

官方文档：

http://www.springboottutorial.com/spring-boot-and-component-scan

译文:

https://blog.csdn.net/Lamb_IT/article/details/80918704

这一部分我也只能理解到一些浅层的知识，需要更加深入的朋友可以参考：

Spring ConfigurationClassPostProcessor Bean解析及自注册过程

https://www.cnblogs.com/hujunzheng/p/9711440.html

4.RestController与Controller

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

对于上面的注解，我们只需要返回一个json数据，所以我们添加了注解 @ResponseBody

一般在异 步获取数据时使用，在使用@RequestMapping后，返回值通常解析为跳转路径，加上@ResponseBody后返回结果不会被解析为跳转路 径，而是直接写入HTTP response body中。比如异步获取json数据，加上 @ResponseBody后，会直接返回json数据。

当我们有多个响应，只想返回Json数据时，我们可以这样做：

@ResponseBody
@Controller
public class HelloController {
    @RequestMapping("/hello")
    public String hello(){
        return "Hello world!";
    }
    @RequestMapping("/bye")
    public String bye(){
        return "Bye!";
    }
}

这样的话，我们所有的返回类型都会变成Json数据

或者我们可以更加简单一些：

@RestController
public class HelloController {
    @RequestMapping("/hello")
    public String hello(){
        return "Hello world!";
    }
    @RequestMapping("/bye")
    public String bye(){
        return "Bye!";
    }
}

改为@RestController

点开@RestController，我们可以发现它的注解：

@Controller
@ResponseBody
public @interface RestController {

所以@RestController就是@Controller与@ResponseBody的相加。

想要深入的同学可以看下面俩篇文章：

@Controller和@RestController的区别？

@RequestBody, @ResponseBody 注解详解(转)