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