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>

2.microboot-base模块：将当前项目模块进行打包处理：clean package;

此时将形成“microboot.jar”文件(target目录中)，并且这个文件里边包含有全部的依赖支持库文件

3.怎么执行呢？在microboot.jar随便拷贝到一个地方 例如d:

进入命令行 java -jar microboot.jar 可以看到项目启动成功

然后该怎么访问就怎么访问 在浏览器输入地址就可以访问 同样在linux中也是这样

 

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