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"?>
<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 模块】建立一个测试程序类；

 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 下即可。

posted @ 2018-03-27 20:26 小不点啊阅读(3461) 评论(3) 编辑收藏举报

刷新页面返回顶部

小不点啊

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

公告