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

于 2019-04-24 19:33:14 发布
阅读量386 收藏
点赞数
分类专栏： SpringBoot 框架 文章标签： SpringBoot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_43429144/article/details/89494886
版权
本文介绍了SpringBoot的基本概念，包括如何进行统一父pom管理，SpringBoot代码测试的方法，启动注解的分析，配置访问路径的步骤，以及如何使用内置对象。通过这些内容，帮助读者深入理解SpringBoot的应用实践。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

                                                 SpringBoot的基本概念

 

1、统一父pom管理

             1）、在上一篇所建立的 SpringBoot 项目只是实现的一个基础程序模型，但是这样的代码肯定不适合于实际的项目开发， 因为从实际的 Maven 项目来讲，在项目中存在不同的模块，而模块间很可能引用一些共同的jar包，会很容易导致版本冲突。因此，需要一个统一的pom文件来作为父文件管理所有的依赖版本。

             2）、统一父 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>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.4.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.mohan</groupId>
    <artifactId>microboot</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>microboot</name>
    <description>Demo project for Spring Boot</description>


    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

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

    <dependencyManagement>
        <dependencies>
            <!-- Override Spring Data release train provided by Spring Boot -->
            <dependency>
                <groupId>org.springframework.data</groupId>
                <artifactId>spring-data-releasetrain</artifactId>
                <version>Fowler-SR2</version>
                <scope>import</scope>
                <type>pom</type>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>2.0.0.BUILD-SNAPSHOT</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>
                <configuration>
                    <source>${java.version}</source><!-- 源代码使用的开发版本 -->
                    <target>${java.version}</target><!-- 需要生成的目标class文件的编译版本 -->
                    <encoding>${project.build.sourceEncoding}</encoding>
                </configuration>
            </plugin>
        </plugins>
    </build>
    <!--子模块 就相当于子类继承父类 子类可以使用父类的依赖  -->
        <modules>
             <module>../crud</module>
        </modules>
</project>

spring-boot-maven-plugin和maven-compiler-plugin的区别 
前者直接将spring-boot程序打成可执行的jar包了，拿出来就直接通过命令行启动内置的tomcat，进而带动应用的启动。

后者只是单纯的打包。

③.将其依赖方式等，修改为<dependencyManagement>的方式，同时在里面添加所有的Spring Boot的总依赖spring-boot-dependencies。

<dependencyManagement>
        <dependencies>
        <dependency>
            <!-- Import dependency management from Spring Boot -->
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>2.0.0.BUILD-SNAPSHOT</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

注：如果想单独升级某个模块，而不依赖于spring-boot-dependencies的话，可以直接将该模块的依赖写在dependency之前，并且scope为import，类型为pom。

<dependencyManagement>
    <dependencies>
        <!-- Override Spring Data release train provided by Spring Boot -->
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-releasetrain</artifactId>
            <version>Fowler-SR2</version>
            <scope>import</scope>
            <type>pom</type>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>2.0.0.BUILD-SNAPSHOT</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

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

<?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>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.4.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->

        <groupId>com.mohan</groupId>
        <artifactId>microboot</artifactId>
        <version>0.0.1-SNAPSHOT</version>

    </parent>
    <groupId>com.mohan</groupId>
    <artifactId>microboot-base</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>microboot-base</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

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

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

⑤. 建立与之前同样的程序类；

package com.mohan.microbootbase;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class microbootController {
    
    @GetMapping("mohan")
    public String getMohan(){
        return "Hello Mohan";
    }
}

然后运行我们的主类打到效果。

 

2、StringBoot代码测试

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

1）、修改 pom.xml 配置文件，追加 SpringBoot 测试支持类；

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

2）、建立一个测试程序类；

package com.mohan.demo03;

import com.mohan.demo03.dao.UserDao;
import com.mohan.demo03.entity.User;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;


@RunWith(SpringRunner.class)
@SpringBootTest
@Slf4j
public class Demo03ApplicationTests {

    @Test
    public void contextLoads() {
    }

    @Autowired
    private UserDao userDao;

    @Test
    public  void addUser(){
        User user = new User();
        user.setId(1);
        user.setUsername("mohan");
        user.setPassword("mohan");
        //userDao.save(user);
        User u = userDao.findUserByUsername(user.getUsername());
        //System.out.println(u.toString());

    }
}

3、启动注解分析

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

springboot常用的注解
                  注解                                                                       说明
@EnableAutoConfigurationSpringBoot 的启动注解配置
@GetMapping表示访问的映射路径
@RestController进行控制器的配置注解，这个注解所在的类就是控制类
@responseBody将controller的方法返回的对象通过适当的转换器转换为指定的格式之后，写入到response对象的body区，通常用来返回JSON数据或者是XML

 

 

 

 

 

 

 

1)、建立一个程序类

package com.mohan.demo;

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

@RestController
public class DemoController {

    @GetMapping("mohan")
    @ResponseBody
    public String getMoHan(){
        return "hello mohan";
    }
}

2）、启动程序主类

package com.mohan.demo;

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

@SpringBootApplication// 启动SpringBoot程序，而后自带子包扫描
public class DemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }

}

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

4、配置访问路径

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

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

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

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

package com.mohan.demo;

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

@RestController
public class DemoController {

    @GetMapping("mohan")
    @ResponseBody
    public String getMoHan(){
        return "hello mohan";
    }
}

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

2）、SpringBoot 支持 Rest 风格处理，所以此时对于参数的接收可以采用路径参数的形式完成：

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

访问路径：http://localhost:8080/echo/hello；

此外SpringBoot提供了热部署,热部署的存在方便了很多，因为他不用自己手动启动Tomcat，springboot帮我们自动完成。只需导入依赖即可；

<dependency>
        <groupId>org.springframework</groupId>
        <artifactId>springloaded</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
    </dependency>

 

5、使用内置对象

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

@GetMapping("/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 自己定义 的，主要就是当前用户的目录下存在。

上一篇：SpringBoot讲述二：搭建自己的第一个SpringBoot程序

 

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值