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

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

1.了解SpringBoot的基本概念

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

2.1、统一父 pom 管理

1、首先建立一个 microboot 的 Maven 项目；

 1 <!--建立统一的父pom ，其他的子模块都统一用这个配置 -->
 2 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 3     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 4     <modelVersion>4.0.0</modelVersion>
 5     <groupId>cn.study</groupId>
 6     <artifactId>microboot</artifactId>
 7     <version>0.0.1-SNAPSHOT</version>
 8     <!--packaging设置为pom  -->
 9     <packaging>pom</packaging>
10     <name>microboot</name>
11     <url>http://maven.apache.org</url>
12     <properties>
13         <jdk.version>1.8</jdk.version>
14         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
15     </properties>
16     <dependencyManagement>
17         <dependencies>
18             <dependency>
19                 <groupId>org.springframework.boot</groupId>
20                 <artifactId>spring-boot-dependencies</artifactId>
21                 <version>1.5.4.RELEASE</version>
22                 <!--设置type和scope  -->
23                 <type>pom</type>
24                 <scope>import</scope>
25             </dependency>
26         </dependencies>
27     </dependencyManagement>
28     <build>
29         <finalName>microboot</finalName>
30         <plugins>
31             <plugin>
32                 <groupId>org.apache.maven.plugins</groupId>
33                 <artifactId>maven-compiler-plugin</artifactId>
34                 <configuration>
35                     <source>${jdk.version}</source><!-- 源代码使用的开发版本 -->
36                     <target>${jdk.version}</target><!-- 需要生成的目标class文件的编译版本 -->
37                     <encode>${project.build.sourceEncoding}</encode>
38                 </configuration>
39             </plugin>
40         </plugins>
41     </build>
42     <!--子模块  -->
43     <modules>
44         <module>microboot-base</module>
45     </modules>
46 </project>

2、建立 microboot-base 的子模块，实现之前同样的基础操作功能，修改 pom.xml 文件，追加 SpringBoot 的 WEB 启动包（spring-boot-starter-web）

<?xml version="1.0"?>
<projectxsi: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("/")@ResponseBodyString 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 模块】建立一个测试程序类；

 1 package cn.study.microboot.test;
 2
 3 import javax.annotation.Resource;
 4
 5 import org.junit.Test;
 6 import org.junit.runner.RunWith;
 7 import org.springframework.boot.test.context.SpringBootTest;
 8 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
 9 import org.springframework.test.context.web.WebAppConfiguration;
10
11 import cn.study.microboot.SampleController;
12 import junit.framework.TestCase;
13
14 @SpringBootTest(classes = SampleController.class)
15 @RunWith(SpringJUnit4ClassRunner.class)
16 @WebAppConfiguration
17 public class TestSampleController {
18     @Resource
19     private SampleController sampleController;
20
21     @Test
22     public void testHome() {
23         TestCase.assertEquals(this.sampleController.home(), "www.study.cn");
24     }
25 }

2.3、Spring 启动注解分析

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

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

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

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

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

 1 package cn.study.microboot.controller;
 2
 3 import org.springframework.stereotype.Controller;
 4 import org.springframework.web.bind.annotation.RequestMapping;
 5 import org.springframework.web.bind.annotation.ResponseBody;
 6
 7 @Controller
 8 public class HelloController {
 9     @RequestMapping("/")
10     @ResponseBody
11     public String home() {
12         return "www.study.cn";
13     }
14 }

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 的配置项目，则显示的项目信息如下：

· 【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>

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

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；

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

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

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

转载于:https://www.cnblogs.com/leeSmall/p/8659951.html

SpringBoot系列三：SpringBoot基本概念（统一父 pom 管理、SpringBoot 代码测试、启动注解分析、配置访问路径、使用内置对象、项目打包发布）...相关推荐

【j360-boot】Spring-boot系列三（崩溃模式，不是你崩就是电脑崩）
2019独角兽企业重金招聘Python工程师标准>>> j360-boot spring-boot入门工程之j360-boot:(欢迎star.fork) https://githu ...
SpringBoot 处理内置对象
在这种模板开发框架里面是不提倡使用内置对象的,但是很多的开发者依然需要使用内置对象进行处理,所以下面来看下如何在页面中采用内置对象的方式完成.1. 在控制器里面追加一个方法, 这个方法将采用内置对象的 ...
SpringBoot项目打包发布
SpringBoot项目打包发布 SpringBoot打包发布jar jar类型项目可以打成jar包打包流程导入SpringBoot打包插件将项目导出成jar包并更新pom文件使用maven ...
“约见”面试官系列之常见面试题之第六十八篇之本地对象内置对象宿主对象（建议收藏）
首先解释下宿主环境:一般宿主环境由外壳程序创建与维护,只要能提供js引擎执行的环境都可称之为外壳程序.如:web浏览器,一些桌面应用系统等.即由web浏览器或是这些桌面应用系统早就的环境即宿主环境. ...
JSP的概念||原理||JSP的脚本||JSP的内置对象||response.getWriter()和out.write()的区别||案例:改造Cookie案例
1. 概念 * Java Server Pages: java服务器端页面 * 可以理解为:一个特殊的页面,其中既可以指定定义html标签,又可以定义java代码 * ...
JavaScript知识笔记（三）——内置对象、浏览器对象
内置对象: (与Java很像) JavaScript 中的所有事物都是对象,如:字符串.数值.数组.函数等,每个对象带有属性和方法. 对象的属性:反映该对象某些特定的性质的,如:字符串的长度.图像的长 ...
(三)01 -Vue项目打包发布移动App——vue.config.js中配置相对路径publicPath为空字符串在public中添加HBuilderX的打包配置文件manifest.json
Vue 项目打包发布移动 App--npm run build打包 & vue.config.js文件中配置相对路径publicPath为空字符串 & 在 public中添加HBuil ...
互联网软件开发—— 实验三 JSP 内置对象（留言板）
实验名称: 实验三 JSP 内置对象一.实验目的 1.掌握表单提交及页面间参数传递的方法. 2.理解页面转发与重定向之间的区别. 3.掌握 request.session 和 application ...
springboot系列(三十一):如何实现excel模板导出成pdf文件？这你得会 | 超级详细，建议收藏

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

SpringBoot系列三：SpringBoot基本概念（统一父 pom 管理、SpringBoot 代码测试、启动注解分析、配置访问路径、使用内置对象、项目打包发布）...相关推荐

最新文章

热门文章