N0.2 SpringBoot 基础知识

最新推荐文章于 2024-10-23 10:52:53 发布

心猿码意

最新推荐文章于 2024-10-23 10:52:53 发布

阅读量473

点赞数

分类专栏： SpringBoot SpringBoot系列-从入门到懵逼文章标签： SpringBoot 基础讲解

本文链接：https://blog.youkuaiyun.com/CDWLX/article/details/88588895

版权

SpringBoot系列-从入门到懵逼同时被 2 个专栏收录

4 篇文章

订阅专栏

SpringBoot

3 篇文章

订阅专栏

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

一、统一父 pom 管理

首先建立一个 microboot 的 Maven 项目

<?xml version="1.0" encoding="UTF-8"?>
<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>com.imooc</groupId>
	<artifactId>microboot</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<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>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>
				<version>3.8.0</version>
				<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>

建立 microboot-base 的子模块，实现之前实现的基础功能，修改 pom.xml 文件，追加 SpringBoot 的 WEB 启动包
建立与之前同样的程序类

package org.microboot.microboot;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class SampleController {
	public static void main(String[] args) throws Exception{
		SpringApplication.run(SampleController.class, args);
	}
}

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

二、SpringBoot 代码测试

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

【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，所以这个开发包一定要随测试一起导入。在这里我们并没有指定版本编号，那是因为在父 pom.xml 文件里面加入了以下配置，由父 pom.xml 统一管理版本。

<type>pom</type>
<scope>import</scope>

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

package org.microboot.microboot;

import junit.framework.TestCase;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.microboot.microboot.controller.HomeController;
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;

@SpringBootTest(classes=SampleController.class)
@RunWith(SpringJUnit4ClassRunner.class)
@WebAppConfiguration
public class TestSampleController {
	@Autowired 
	HomeController homeController;
	
	@Test
	public void testHome(){
		TestCase.assertEquals(this.homeController.home(), "Hello Word!");
	}
}

三、Spring 启动注解分析

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

注解	说明
@Controller	进行控制器的配置注解，这个注解所在的类就是控制器类
@EnableAutoConfiguration	开启自动配置处理
@RequestMapping("/")	表示访问的映射路径，此时的路径为"/"，访问地址：127.0.0.1:8080/
@ResponseBody	在Restful架构之中，该注解表示直接将返回的数据以字符串的形式或JSON的形式获得

可以发现在给定的几个注解中 “@EnableAutoConfiguration” 为整个 SpringBoot 的启动注解配置，也就是说这个注解应该随着程序的主类一起定义。
而对于控制器程序类，由于在项目中会有许多的控制器，那么最好将这些类保存在一个包中，下面将所有的控制器程序类保存在 “com.cdw.microboot.controller”，是 “com.cdw.microboot” 子包。
强烈建议(Spring官方建议)：如果要想进行简单方便的开发，所有程序类一定要在启动类所在包的子包下。

【microboot -base 模块】建立一个 “com.cdw.microboot.controller.HomeController” 程序类；

package org.microboot.microboot.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
public class HomeController {
	@RequestMapping("/")
	@ResponseBody
	public String home(){
		return "Hello Word!";
	}
}

SpringBoot 为我们提供了一个复合注解：@SpringBootApplication ，这个注解为启动 SpringBoot 程序，并自带子包扫描，这为以后使用 Bean 实现配置处理的时候变得更加容易。

四、配置访问路径

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

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

@Controller 在类上定义标识定义的是一个控制器；
@ResponseBody 将控制器中方法的返回值变为rest内容。

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

package org.microboot.microboot.controller;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HomeController {
	@RequestMapping("/")
	@ResponseBody
	public String home(){
		return "Hello Word!";
	}
}

因为从 MVC 实际标准来讲，控制器需要传递一些属性到页面上进行显示，按照这样的原则，并不是所有的开发都会以 Restful 结构返回，但是 Rest 结构是 SpringCloud 的实现核心技术。
2. 现在所给出的控制器的类里面只是负责了简单的信息返回，那么实际上也可以进行参数的接收处理，传递参数到控制器中，最简单的做法是使用地址重写传递 “XX?参数名称=内容”。

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

访问路径：http://127.0.0.1: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://127.0.0.1:8080/echo/Hello
虽然参数路径的形式属于 Rest 操作标准，但是在个人觉得采用地址重写传递参数更加简单，不过采用什么样的模式传递参数，取决于所处的项目团队。
4. 在 SpringBoot 的处理操作中，充分考虑到了开发模式下需要经常对代码进行变动，所以追加有自动加载配置的依赖库；
【microboot -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 中控制器的形式和 SpringMVC 是一样的，所以如果现在要想在你的程序之中去使用 JSP 的内置对象，那么也可用按照与 SpringMVC 同样的方式进行。

@RequestMapping("/object")
public String object(HttpServletRequest request, HttpServletResponse response){
	return "客户端IP地址：" + request.getRemoteAddr() + "<br>" +
			"客户端响应编码：" + response.getCharacterEncoding() + "<br>" +
			"SessionID" + request.getSession().getId() + "<br>" +
			"真实路径：" + request.getServletContext().getRealPath("/upload");
}

访问得到如下结果：

客户端IP地址：127.0.0.1
客户端响应编码：ISO-8859-1
SessionIDA2698A8B3A79FF094491224FBDB1000F
真实路径：C:\Users\dongwei\AppData\Local\Temp\tomcat-docbase.3872559020082569981.8080\upload

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

六、项目打包发布

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

【microboot 项目】修改 pom.xml 配置文件，追加新的插件：

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

由于增加了新的插件，所以对于整个程序一定要进行整体的项目更新。
2. 【microboot 模块】将当前项目模块进行打包处理：clean package；
此时将形成 “microboot.jar” 程序文件，并且这个文件里面包含有全部的依赖支持库文件。
3. 将 “microboot.jar” 文件随意拷贝到一个路径之中，例如：D盘，而后进入命令行方式下：