SpringBoot

SpringBoot出现的原因：

现在行业之中，spring已经作为了绝对的java架构，但进行快速开发时，往往先面临着大量的xml文件的配置，需要编写大量的xml文件

所以在这个大的历史背景下，很多人开始寻求更加简便的开发，而遗憾的是这种简便的开发没有被JDK所支持、没有被JavaEE所支持，

因为这些只是平台，平台能够提供的只是最原始的技术支持。

此时，SpringBoot出现了，改变了所有java开发所面临的困境。

SpringBoot最终奉行的宗旨(不太可能实现)：废除掉所有复杂的开发，废除掉所有的配置文件，让开发变的更简单纯粹核心：零配置

另外：SpringBoot之所以流行，是因为在SpringBoot中使用的注解还是之前Spring所提供的注解，这一点让所有的开发者几乎可以零适应进行完整过渡

官网：https://spring.io/

-----------------------------------------

SpringBoot官方快速启动程序

第一步：创建maven工程

第二步：在pom文件中引入官方的父工程

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

第三步：在pom文件中加入官方的依赖

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

第四步：复制官网代码

运行：

或者通过maven运行

然后直接访问即可：http://localhost:8080

如果想要进行SpringBoot开发，一定要使用maven或者其他的项目管理工具完成。

-------------------------------------

以上的程序，只是根据官方文档实现的一个基础程序模型，但是这样的代码肯定不适合我们实际的项目开发，因为从实际的maven项目来讲，应该要有统一的父pom.xml文件，但是官方文档中已经提供了一个父pom.xml(一个pom文件中只能有一个parent节点)

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

另外，我们使用maven管理工具进行开发时，推荐在pom.xml中指定的jdk版本而不是使用系统自带的版本

所以下面我们对项目重新做一个规划

--------------------------------------

统一父pom管理

建立一个maven的父pom 类型为pom

{

新建一个microBoot的Maven项目

打开pom文件，修改

为

在pom添加<dependencyManagement>节点

删除该项目下所有的不相关文件

只留下pom.xml文件

}

目前为止这个项目不是SpringBoot所支持的项目，所以需要在pom文件中加入SpringBoot相关依赖包

在maven仓库中搜索

pom文件变为如下（单元测试可以删掉）：

<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.0</modelVersion>

  <groupId>cn.qqkj</groupId>
  <artifactId>microboot</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>pom</packaging>

  <name>microboot</name>
  <url>http://maven.apache.org</url>

  <properties>
    <!-- 管理jdk版本 -->
      <jdk.version>1.8</jdk.version>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>

    <dependencyManagement>
      <dependencies>
        <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-dependencies -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>1.5.4.RELEASE</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>

    <!--     <dependency>
          <groupId>junit</groupId>
          <artifactId>junit</artifactId>
          <version>3.8.1</version>
          <scope>test</scope>
        </dependency> -->
      </dependencies>
   </dependencyManagement>
    <modules>
        <module>microboot-base</module>
    </modules>
     <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>${jdk.version}</source>
                    <target>${jdk.version}</target>
                    <encoding>${project.build.sourceEncoding}</encoding>
                </configuration>
            </plugin>
        </plugins>
    </build> 
</project>

建立microboot的子模块microboot-base 实现之前同样的操作

选择父模块

创建完成，打开子模块的pom.xml 可以看到有一个父模块节点我们只需添加Web启动依赖即可，其他无关的内容注释掉。

<?xml version="1.0"?>
<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  <modelVersion>4.0.0</modelVersion>
  <parent>
    <groupId>cn.qqkj</groupId>
    <artifactId>microboot</artifactId>
    <version>0.0.1-SNAPSHOT</version>
  </parent>
<!--   <groupId>cn.qqkj</groupId> -->
  <artifactId>microboot-base</artifactId>
<!--   <version>0.0.1-SNAPSHOT</version> -->
  <name>microboot-base</name>
  <url>http://maven.apache.org</url>
  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>
  <dependencies>
      <!-- 添加官网的Web启动包 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
<!--     <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency> -->
  </dependencies>
</project>

同样的和之前的一样，在子模块中，我们复制官网上的代码类，直接运行即可。

在父工程中：

此时子工程里边：

报错：

所以没有注释掉的两行代码是不行的，取消注释，我们就可以看到不再把报错了

但是仍然有警告

这个警告意思是：版本冲突，意思就是父工程中已经存在单元测试的版本了，子工程中也有，所以就产生了冲突，但是不解决也没有关系，maven自己也会解决

写到这我们就需要明白父工程：担负起锁定相应的程序版本重任所有依赖包的版本统一(SpringBoot解决的一个问题)

所有的版本控制我们只需要在父工程中写出即可，子模块中无需关心这些问题

这个dependency是包含很多的jar依赖的，artifactId点击去我们可以看到

-------------------------------------------

在快速启动案例中以及提到过，我们有两种方式可以启动程序

1.直接java application进行启动，没错可以启动成功

2.通过maven来启动 spring-boot:run 这个时候就发生了错误

解决办法：

    <!-- 统一 父pom方式：通过maven启动程序时 需要配置下面的信息 -->
     <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

可以在子模块中配置也可以在父pom中进行配置推荐在父pom中因为可能有多个子模块所以在父pom中配置一次即可同时这个插件在项目打包部署的时候也要用到下面会介绍

---------------------------------------------------

SpringBoot标准单元测试

导入依赖(注意因为我们配置了父pom 所以配置依赖的时候不需要在指定版本了父pom中都有对应的依赖)

    <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-test -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <!-- 不需要指定版本了 因为在父pom中已经指定  如果用的话 直接拿来用 -->
       <!--  <version>1.5.9.RELEASE</version> -->
        <scope>test</scope>
    </dependency>
    
    <!-- https://mvnrepository.com/artifact/junit/junit -->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
       <!--  <version>4.12</version> -->
        <scope>test</scope>
    </dependency>

被测试类：

package cn.qqkj.microboot;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
@EnableAutoConfiguration
public class SampleController {

    @RequestMapping("/")
    @ResponseBody
    public String home() {
        return "Hello World!";
    }

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

创建测试类

package cn.qqkj.microboot.test;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.web.WebAppConfiguration;

import cn.qqkj.microboot.SampleController;
import junit.framework.TestCase;

//标准的springboot测试程序
@SpringBootTest(classes=SampleController.class)//指定测试的类
@RunWith(SpringJUnit4ClassRunner.class)//测试类型
@WebAppConfiguration//web程序  按照web运行的模式进行测试
public class TestSampleController {
    //注入
    @Autowired
    private SampleController sampleController;
    
    //测试案例中的home方法
    @Test
    public void testHome() {
        TestCase.assertEquals(this.sampleController.home(),"Hello World!");
    }
    
}

执行测试即可

---------------------------------

SpringBoot启动注解分析

修改程序

主类：

新建控制器类HelloController（注意我们将该类放在主类所在包的子包中）

此时启动主类我们继续访问http:localhost:8080/ 启动成功但是访问如下：

为什么不能访问，因为没有配置扫描

在次启动主类我们访问http:localhost:8080/ 启动成功访问成功：

但是以上程序，SpringBoot给我们做了一个处理，提出了一个更简化策略，该策略核心思想：既然程序主类会在所有开发包的父包里边，那么提供一个特殊的复合注解，扫描的就是该主程序类下的所有子包

@SpringBootApplication等价于（@EnableAutoConfiguration+@ComponentScan("")+其他配置）前提访问的类一定要在主类所在类的子包中

同样我们可以访问成功

打开该注解的源代码：

如果满足不了上边说的前提，那么就需要指定扫描的路径

因为该复合注解只会扫描主类下的子包。

所以在SpringBoot的开发里，一定要注意一个关键性的问题：子包它的一切配置的操作，几乎都是以子包为主---

-------------------------------------

路径访问控制

在进行控制器编写的时候，有两种配置
1.跳转配置
2.restful显示
@ResponseBody:将控制器中的方法的返回值变为rest
没有该注解，表示跳转
加了该注解，就是rest结构

如下程序：

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

启动主类，localhost:8080 可以访问成功

下边我们把@ResponseBody注解删除再进行测试

@Controller
public class HelloController {
    
    @RequestMapping("/")
    public String home() {
        return "Hello World!";
    }
}

启动没有问题，但是访问localhost:8080

此时因为没有@responseBody注解，它把方法的返回值当做了一个页面进行处理，即访问 Hello World! 页面因为没有该页面，所以404

-----------------------

@RestController复合注解

项目里边可能控制器之中返回的全部都是restful信息，这样分别定义就太麻烦了
为此在SpringBoot中提供了一个复合注解@RestController
如果该控制器下的方法全部都为rest操作，那么使用该注解就非常方便了
但是并不表示在开发中都使用@RestController 从MVC的实际标准来讲控制器需要传递一些属性到页面上进行显示，按照这样的原则并不是所有的开发都会以restful结构返回（但是Rest结构是SpringCloud的实现核心技术）

@RestController
public class HelloController {
    
    @RequestMapping("/")
    //@ResponseBody
    public String home() {
        return "Hello World";
    }
}

------------------------

参数接受处理

1.传递参数到控制器中最简单的做法是使用地址重写传递“xx?参数名称=内容”

@RestController
public class HelloController {
    
    @RequestMapping("/")
    //@ResponseBody
    public String home() {
        return "Hello World";
    }
    
    //访问： localhost:8080/echo?msg=你好
    @RequestMapping("/echo")
    public String echo(String msg) {
        return "【执行echo】"+msg;
    }
}

2. 由于SpringBoot支持Rest风格处理，所以此时对于参数的接受可以采用路径参数的形式完成

@RestController
public class HelloController {
    
    @RequestMapping("/")
    //@ResponseBody
    public String home() {
        return "Hello World";
    }
    
    //访问： localhost:8080/echo?msg=你好
    @RequestMapping("/echo")
    public String echo(String msg) {
        return "【执行echo】"+msg;
    }
    
    //访问：localhost:8080/echo2/xxxx
    @RequestMapping("/echo2/{a}")
　　//@RequestMapping(value="/echo2/{a}",method=RequestMethod.GET)
    public String echo2(@PathVariable("a")String msg) {
        return "【执行echo】"+msg;
    }
    
}

-------------------------------

自动加载配置的依赖（避免反复的启动程序）

项目的开发中，修改代码之后，如果想使代码生效，必须重新启动
springboot的处理操作之中考虑到了这种情况

两个依赖库：

<!-- https://mvnrepository.com/artifact/org.springframework/springloaded -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>springloaded</artifactId>
    <version>1.2.8.RELEASE</version>
    <scope>provided</scope>
</dependency>

<!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-devtools -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
    <version>2.0.1.RELEASE</version>
</dependency>

-------------------------------

使用内置对象

通过整个SpringBoot程序可以发现，在SpringBoot中的控制器的形式和springmvc是一样的，如果现在要想在你的程序中去使用JSP的内置对象，那么也可以按照与SpringMVC同样的方式进行。

--------------------

项目的打包部署
传统的ssm或者ssh项目，我们部署到服务器上的时候，都是打包成war 然后放在服务器中的tomcat-webapp中然后启功服务运行即可
SpringBoot作为微架构实现的主要技术（微架构：一个程序打成jar包之后，轻松在所有地方都能执行），其发布项目的方式极为简单，只需要在项目中配置好插件，以及打包然后就可以执行了这个执行不需要特别复杂的配置
1.microboot项目：修改pom.xml配置文件，追加新的插件这个插件我在上面已经使用过了主要就是解决maven启动项目报错的问题同时发布项目也需要这个插件

　　　　　　　　<!-- 统一 父pom方式：通过maven启动程序时 需要配置下面的信息 -->
            <!-- 另外：该插件的主要功能是进行项目的打包发布处理 -->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <!-- 设置程序执行的主类 -->
                    <mainClass>cn.qqkj.microboot.StartSpringBoot</mainClass>
                </configuration>
                <executions>
                    <execution>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>