SpringBoot系列三:SpringBoot基本概念(统一父 pom 管理、SpringBoot 代码测试、启动注解分析、配置访问路径、使用内置对象、项目打包发布)

时间:2021-12-16 05:14:55

声明:本文来源于MLDN培训视频的课堂笔记,写在这里只是为了方便查阅。

1.了解SpringBoot的基本概念

2、具体内容 在之前所建立的 SpringBoot 项目只是根据官方文档实现的一个基础程序模型,但是这样的代码肯定不适合于实际的项目开发, 因为从实际的 Maven 项目来讲,应该要有统一的父 pom.xml 文件。

2.1、统一父 pom 管理

1、 首先建立一个 microboot 的 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.study</groupId>
<artifactId>microboot</artifactId>
<version>0.0.1-SNAPSHOT</version>
<!--packaging设置为pom -->
<packaging>pom</packaging>
<name>microboot</name>
<url>http://maven.apache.org</url>
<properties>
<jdk.version>1.8</jdk.version>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-dependencies</artifactId>
<version>1.5.4.RELEASE</version>
<!--设置type和scope -->
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>
<build>
<finalName>microboot</finalName>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>${jdk.version}</source><!-- 源代码使用的开发版本 -->
<target>${jdk.version}</target><!-- 需要生成的目标class文件的编译版本 -->
<encode>${project.build.sourceEncoding}</encode>
</configuration>
</plugin>
</plugins>
</build>
<!--子模块 -->
<modules>
<module>microboot-base</module>
</modules>
</project>

2、 建立 microboot-base 的子模块,实现之前同样的基础操作功能,修改 pom.xml 文件,追加 SpringBoot 的 WEB 启动包(spring-boot-starter-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>
<!--引用父配置microboot -->
<parent>
<groupId>cn.study</groupId>
<artifactId>microboot</artifactId>
<version>0.0.1-SNAPSHOT</version>
</parent>
<artifactId>microboot-base</artifactId>
<name>microboot-base</name>
<url>http://maven.apache.org</url>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency> <dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<scope>test</scope>
</dependency> </dependencies>
</project> 

3、 建立与之前同样的程序类;

package cn.study.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
String home() {
return "www.study.cn";
} public static void main(String[] args) throws Exception {
SpringApplication.run(SampleController.class, args);
}
}

在这样的状态下才可以进行后续的代码编写。

2.2、SpringBoot 代码测试

现在的程序里面已经实现了一个最为简单的控制器程序类,不过从实际的项目角度来讲,必须要求考虑到代码测试问题,而 且现在的程序代码属于 SpringBoot,则需要在你的项目之中进行如下的 pom.xml 文件的变更。

1、 【microboot-base 模块】修改 pom.xml 配置文件,追加 SpringBoot 测试支持类;

         <dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<scope>test</scope>
</dependency>

只要进行 java 测试,最简单实用的就是 junit,所以这个开发包一定要随测试一起导入。 2、 【microboot-base 模块】建立一个测试程序类;

2、 【microboot-base 模块】建立一个测试程序类;

 package cn.study.microboot.test;

 import javax.annotation.Resource;

 import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.web.WebAppConfiguration; import cn.study.microboot.SampleController;
import junit.framework.TestCase; @SpringBootTest(classes = SampleController.class)
@RunWith(SpringJUnit4ClassRunner.class)
@WebAppConfiguration
public class TestSampleController {
@Resource
private SampleController sampleController; @Test
public void testHome() {
TestCase.assertEquals(this.sampleController.home(), "www.study.cn");
}
}

2.3、Spring 启动注解分析

现在为止已经可以发现在整个 SpringBoot 程序里面使用了许多的注解,首先把这些注解做一个列表:

SpringBoot系列三:SpringBoot基本概念(统一父 pom 管理、SpringBoot 代码测试、启动注解分析、配置访问路径、使用内置对象、项目打包发布)

可以发现在给定的几个注解之中“@EnableAutoConfiguration”为整个 SpringBoot 的启动注解配置,也就是说这个注解应该随着程序的主类一起进行定义。

而对于控制器程序类,由于在项目之中会有许多的控制器,那么最好将这些类统一保存在一个包中,下面将所有的控制器程序类保存在“cn.study.microboot.controller”,是“cn.study.microboot”子包。

强烈建议(Spring 官方建议):如果要想进行简单方便的开发,所有的程序类一定要在启动类所在包的子包下。

1、 【microboot-base 模块】建立一个 cn.study.microboot.controller.HelloController 程序类;

 package cn.study.microboot.controller;

 import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody; @Controller
public class HelloController {
@RequestMapping("/")
@ResponseBody
public String home() {
return "www.study.cn";
}
}

2、 【microboot-base 模块】启动程序主类;

package cn.study.microboot;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.context.annotation.ComponentScan; @EnableAutoConfiguration
@ComponentScan("cn.study.microboot") // 定义一个扫描路径
public class SampleController {
public static void main(String[] args) throws Exception {
SpringApplication.run(SampleController.class, args);
}
}

3、 【microboot-base 模块】以上的做法只是传统程序的开发做法,因为现在为止毕竟是两块程序类,这两个彼此之间的联系需要 有一个连接点,而程序中配置的“@ComponentScan”就是负责这个连接处理,但是 SpringBoot 考虑到了此类的配置问题,所以提 出了一个更简化策略,该策略的核心思想:既然程序主类会在所有开发包的父包里面,那么能不能简化点取得配置呢?为此在实际 的开发之中,会使用一个特殊的复合注解:

package cn.study.microboot;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication; @SpringBootApplication // 启动SpringBoot程序,而后自带子包扫描
public class SampleController {
public static void main(String[] args) throws Exception {
SpringApplication.run(SampleController.class, args);
}
}

@SpringBootApplication = @EnableAutoConfiguration + @ComponentScan + 其它配置。正是因为它有这样的特点,所以当 以后使用 Bean 实现配置处理的时候将会非常的容易。

 2.4、配置访问路径

在一个实际的项目开发之中,控制器的路径可能会有许多的个,而且在进行控制器编写的时候也会有两种运行模式:跳转配 置、Restful 显示。那么下面来观察关于路径的详细描述。

1、 在之前所编写的控制器里面你会发现有如下的两个注解配置使用:

· @Controller 在类上定义表示定义的是一个控制器;

· @ResponseBody:将控制器中方法的返回值变为 rest 内容。

但是如果说你现在一个项目里面可能控制器之中返回的全部都是Restful信息,这样分别定义就太麻烦了,为此在SpringBoot 里面又提供有一个复合注解:“@RestController”

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController; @RestController
public class HelloController {
@RequestMapping("/")
public String home() {
return "www.study.cn";
}
}

因为从 MVC 实际标准来讲,控制器需要传递一些属性到页面上进行显示,按照这样的原则并不是所有的开发都会以 Restful 结构返回,但是 Rest 结构是 SpringCloud 的实现核心技术

2、 现在所给出的控制器的类里面只是负责了简单的信息返回,那么实际上也可以进行参数的接收处理,传递参数到控制器之中 最简单的做法是使用地址重写传递“xx?参数名称=内容”;

@RequestMapping("/echo")
public String echo(String msg) {
return "【ECHO】" + msg ;
}

访问路径:http://localhost:8080/echo?msg=hello;

3、 由于 SpringBoot 支持 Rest 风格处理,所以此时对于参数的接收可以采用路径参数的形式完成:

@RequestMapping(value="/echo/{message}",method=RequestMethod.GET)
public String echo(@PathVariable("message") String msg) {
return "【ECHO】" + msg ;
}

访问路径:http://localhost:8080/echo/hello; 个人意见:虽然路径参数的形式属于 rest 操作标准

个人意见:虽然路径参数的形式属于 rest 操作标准,但是个人觉得使用地址重写传递参数更加简单,不过这一点使用什么样的模式来处理,取决于你所处的项目团队。

4、 在 SpringBoot 的处理操作之中实际上已经充分考虑到了此类情况,所以追加有自动加载配置的依赖库;

· 如果你现在的项目只是一个简单的 SpringBoot 的配置项目,则显示的项目信息如下:

SpringBoot系列三:SpringBoot基本概念(统一父 pom 管理、SpringBoot 代码测试、启动注解分析、配置访问路径、使用内置对象、项目打包发布)

· 【micro-base 模块】如果说你现在添加有如下的两个依赖库,修改 pom.xml 文件:

<!--热启动  -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>springloaded</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
</dependency>

引入完成之后可以观察项目上的提示信息:

SpringBoot系列三:SpringBoot基本概念(统一父 pom 管理、SpringBoot 代码测试、启动注解分析、配置访问路径、使用内置对象、项目打包发布)

2.5、使用内置对象

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

    @RequestMapping("/object")
public String object(HttpServletRequest request,HttpServletResponse response) {
System.out.println("*** 客户端IP地址:" + request.getRemoteAddr());
System.out.println("*** 取得客户端响应编码:" + response.getCharacterEncoding());
System.out.println("*** 取得SessionID:" + request.getSession().getId());
System.out.println("*** 取得真实路径:" + request.getServletContext().getRealPath("/upload/"));
return "www.study.cn" ;
}

输出:

*** 客户端IP地址:0:0:0:0:0:0:0:1
*** 取得客户端响应编码:ISO-8859-1
*** 取得SessionID:35B3BFE058AEF7F3121B154EA47FA775
*** 取得真实路径:C:\Users\THINKPAD\AppData\Local\Temp\tomcat-docbase.2837993313407535911.8080\upload\

通过以上的信息可以发现,此时的 SpringBoot 运行依然需要有一个工作目录,只不过这个工作目录是由 SpringBoot 自己定义 的,主要就是当前用户的目录下存在。

 2.6、项目打包发布

SpringBoot 作为微架构实现主要技术,其发布项目的方式极为简单,只需要你在你的项目中配置好插件,以及打包就可以执行了,并且这个执行不需要特别复杂的配置。

1、 【microboot 项目】修改 pom.xml 配置文件,追加新的插件:

           <plugin>    <!-- 该插件的主要功能是进行项目的打包发布处理 -->
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<configuration> <!-- 设置程序执行的主类 -->
<mainClass>cn.study.microboot.StartSpringBootMain</mainClass>
</configuration>
<executions>
<execution>
<goals>
<goal>repackage</goal>
</goals>
</execution>
</executions>
</plugin>

由于增加了新的插件,所以对于整个的程序一定要进行整体的项目更新。

2、 【microboot-base 模块】将当前项目模块进行打包处理:clean package;

SpringBoot系列三:SpringBoot基本概念(统一父 pom 管理、SpringBoot 代码测试、启动注解分析、配置访问路径、使用内置对象、项目打包发布)

此时将形成“microboot.jar”程序文件,并且这个文件里面包含有全部的依赖支持库文件;

3、 将“microboot.jar”文件随意拷贝到一个路径之中,例如:D 盘,而后进入到命令行方式下:java -jar microboot.jar

如果此时要想在 Linux 下执行,只需要将这个*.jar 文件直接上传到 Linux 下即可。