Spring Boot 2.0深度实践-初遇Spring Boot

Myth丶恋晨 2023-06-16 15:00 12阅读 0赞

个人博客网：[https://wushaopei.github.io/][https_wushaopei.github.io]    (你想要这里多有)

**目录概述：**

*  Spring Boot 概述
 *  环境准备
 *  Spring Boot项目
 *  多模块项目
 *  打包和运行

## 一、Spring Boot 概述 ##

### 1、Spring Boot 的角色 ###

> 底层：Spring Frameword是 JAVAEE 的框架
> 
> 中层：Spring Boot 是快速构建Spring框架的应用
> 
> 顶层：Spring Cloud 是JAVAEE 的分布式

### 2、Spring Boot 2.0新特性 ###

**SpringBoot2.0新特性：**

*        编程语言必须依赖于java 8++(>jdk1.8)，Kotlin
 *        底层框架：spring Framework 5.0X(必须依赖于java1.8)
 *        全新特性：Web Flux(全新编程模型，对SpringMVC的补充)

**为什么选择Web Flux？**

*  函数编程：Java8 Lambda
 *  响应编程：Reactive Streams
 *  异步编程：Servlet3.1 或 Asyc NIO

## 二、Spring Boot 项目 ##

### 1、Spring Boot 环境准备 ###

*  装配 JDK （https://java.oracle.com/）
 *  装配Maven （http://maven.apache.org）
 *  装配IDEA （http://www.jetbrains.com/idea/）

**具体操作：**

*  JDK：JDK1.8
 *  Maven：配置仓库地址，配置下载镜像

配置文件路径..\\apache-maven-3.5.4-bin\\apache-maven-3.5.4\\conf\\settings.xml

<localRepository>E:/softwareData/.m2/repository</localRepository>
    <mirror>      
        <id>alimaven</id>      
        <mirrorOf>central</mirrorOf>      
        <name>aliyun maven</name>      
        <url>http://maven.aliyun.com/nexus/content/groups/public/</url>    
    </mirror>

**  maven配置环境变量**

>    M2\_HOME   maven安装地址
> 
>    PATH 后加上  ;%M2\_HOME\\bin

*  IDEA：[http://www.jetbrains.com/idea][http_www.jetbrains.com_idea]

download community version（社区版）

### 2、Spring Boot应用（一） ###

简单应用：

*  编写REST程序
 *  运行Spring Boot 应用
 *  使用HTTP请求工具：PostMan

场景说明：

*  定义用户模型，包括属性：用户ID和名称
 *  客户端发送POST请求，创建用户（Web MVC）
 *  客户端发送GET请求，获取所有用户（Web Flux）

**第一步：创建springboot工程 first-app-demo：**

![20191129001120891.png][]

配置依赖：

<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-test</artifactId>
    			<scope>test</scope>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-webflux</artifactId>
    		</dependency>
    
    		
    		<dependency>
    			<groupId>org.projectlombok</groupId>
    			<artifactId>lombok</artifactId>
    			<optional>true</optional>
    		</dependency>

**第二步：创建用户模型 User类，并声明 id、 name 两个变量**

@Data
    @Setter
    @Getter
    public class User {
    
        private Integer id;
        private String name;
    }

使用了Lombok优化了代码，不需要手动创建set/get方法

**第三步：创建UserRepository 用户仓库类，用来存储用户的信息**

/*
    *  {@link User} {@link Repository}
    * */
    @Repository
    public class UserRepository {
    
    
        /*
        *  采用内存型的存储方式 ->Map
        * */
        private ConcurrentMap<Integer,User> repository = new ConcurrentHashMap<Integer, User>() {};
    
        private final static AtomicInteger idGenera = new AtomicInteger();
    
        /*
        *  保存用户对象
        *  @param user {@link User} 对象
        *  @return  如果保存成功，返回<code> true</code>
        *           否则，返回<code>false</code>
        * */
        public boolean save (User user){
    
            boolean success = false;
    
            //ID 从 1 开始
            Integer id = idGenera.incrementAndGet();
    
            user.setId(id);
            return  repository.put(id,user) == null;
        }
    
    
    }

**第三步：创建用户接口类 UserController.java**

/**
     * @ClassName UserController
     * @Description TODO
     * @Author wushaopei
     * @Date 2019/9/6 9:55
     * @Version 1.0
     */
    @RestController
    public class UserController {
    
        private final UserRepository userRepository;
    
        @Autowired
        public UserController(UserRepository userRepository){
            this.userRepository = userRepository;
        }
    
        
    }

**注意：**

构造器形式的注入方式的好处：

> 1.  不能修改。
> 2.  可以更早的进行初始化，相对于字段性的注入方式会好一点。
> 3.  但实际开发中，为了节约时间，还是会用字段形式的注入方式
> 4.  参数由spring框架传递，@Autowired可以写也可以不写

@Autowired
    private UserRepository userRepository;

第四步：创建新增用户接口：

@PostMapping("/person/save")
        public User save (@RequestParam String name){
            User user = new User();
    
            user.setName(name);
            if(userRepository.save(user)){
                System.out.println("用户对象： % 保存成功 ! \n" + user);
            }
    
            return  user;
        }

第五步：测试接口

请求接口地址：

> localhost:8080/person/save?name=李清照

请求方式： **POST 请求**

**POSTMAN测试响应结果：**

{
        "id": 1,
        "name": "李清照"
    }

**控制台打印：**

2019-11-29 00:25:00.542  INFO 167248 --- [nio-8080-exec-1] o.s.web.servlet.DispatcherServlet        : Completed initialization in 7 ms
    用户对象： % 保存成功 ! 
    User{id=1, name='李清照'}

![20191202224101988.png][]

### 3、spring 5.0的路由方法器 ###

@Configuration
    public class RouterFunctionConfiguration {
        /**
         * 在Servlet中
         * 请求接口：ServletRequest 或者 HtpServletRequest
         * 响应接口：ServletResponse 或者 HttpServletResponse
         * Spring 5.0中重新定义了服务请求和相应接口
         * 请求接口：ServerRequest
         * 相应接口：ServerResponse
         * 即可支持servlet规范，也可支持自定义，比如Netty(Web Server)
         * 以本例：
         * 定义GET请求，并返回所有的用户对象URL，/person/find/all
         * Flux是0 - N 个对象的集合
         * Mono 是0 - 1个对象集合
         * Reactive中的Flux或者Mono 是异步处理（非阻塞）
         * 集合对象基本上是同步处理（阻塞）
         * Flux 或者Mono 都是 Publisher
         */
    
        @Bean
        @Autowired
        public RouterFunction<ServerResponse> personFindAll(UserRepository userRepository){
    
            return RouterFunctions.route(RequestPredicates.GET("/person/find/all"),
                    request -> {
                        //返回所有的用户对象
                        Collection<User> users = userRepository.findAll();
                        Flux<User> userFlux = Flux.fromIterable(users);
                        return ServerResponse.ok().body(userFlux,User.class);
                    });
        }
    }

## 三、构建方式、多模块和运行方式 ##

### 1、Spring Boot  构建应用-命令行方式 ###

**spring-boot-starter-web的话@Configuration路由无法生效**  
（1）flux内嵌Netty容器，适用于

> @Configuration

（2）web内嵌tomcat容器，适用于@RestController

（3）通过Maven的方式构建Spring Boot项目

> mvn archetype:generate -DinteractiveMode=false
> 
> \-DgroupId=com.imooc  -DartifactId=first-app-by-maven
> 
> \-Dversion=1.0.0-SNAPSHOT

### 2、Spring Boot 多模块 ###

**重构**

>   调整主（父）工程类型（<packaging>）
> 
>   创建子模块工程（<module>）
> 
>    模型层：model
> 
>    持久层：persistence
> 
>    表示层：web
> 
> 子模块依赖管理（<dependencyManagement>）

**第一步： 将  first-app-demo 中的pom.xml 的打包 由 jar改成 pom**

![20191216152139343.png][]

**第二步：右击工程名， 创建一个 artifactId 为 web 的Maven 工程**

![20191216152236626.png][]

**第三步： 将原 first-app-demo 工程下java目录下的 com 包 拖到 web 工程的 java 包下，并删除原工程中的 src 目录**

![2019121615230689.png][]

第四步： 右击工程名， 创建一个 artifactId 为 persistence  的Maven 工程，并在java 目录下创建一个 路径为

com.example.demo.repository的包，将web中的 UserRepository 剪切到 persistence 类 的 com.example.demo.repository

目录下，保证包位置的对等

![20191216152431935.png][]

**第五步： 右击工程名， 创建一个 artifactId 为 model 的Maven 工程模块，并在java 目录下创建一个 路径为**

com.example.demo.model 的包，将web中的 User 模型类 剪切到 model工程 的 com.example.demo.model 包下

![20191216152527209.png][]

**第六步： persistence 中的User 找不到对应的包报错，**

解决方法： 修正 多模块之间的 依赖关系，将 User 所在的 model 依赖添加到persistence 的pom.xml 中，同时将 persistence  的 依赖添加到 web 的pom.xml中

![20191216152620467.png][]

### 3、Spring Boot 项目打包 ###

**打包方式：**

>   构建 JAR 包
> 
>   构建 WAR 包
> 
>   指定 Main-Class

**（1）右击工程名  "copy path" 获取工程路径，到 cmd.exe 命令行中进入该目录下，输入**

> mvn -Dmaven.test.skip -U clean package

命令执行打包操作，

此时执行过程会发生报错，因为 在进行多模块拆分后，需要重新为工程指定 main.class ，也就是 springboot 的启动器入口的位置的明确。这是由于在拆分过后，在父工程下找不到main.class 。

**解决方法：**

将父工程的pom.xml 中的 <build></build>依赖驱动剪切到 web 子模块中 ，然后再到修改后的web子模块的 pom.xml 中的   <build></build> 中的<plugin></plugin>添加一个 <configuration/>,并为其配置一个<mainClass/>，将 springboot入口启动器的 Reference 路径复制并放入到 <mainClass>中，然后执行打包就可以了。

注意： 不要把<build/>放在父工程的pom.xml 下进行打包，那样会有很多错误要进行修正，而且由于主启动器迁移到 了web 中，在父工程下 添加<build/>意义不大

![20191216153116668.png][]

**（2）在 cmd 命令行中启动 jar 包 或者 war 包 的方式：**

> java -jar web-0.0.1-SNAPSHOT.jar
> 
> 或者
> 
> java -jar web-0.0.1-SNAPSHOT.war

注意： 要在 当前工程打成 war 包，需要在 web 的mian 目录下创建 "webapp" 和  "WEB-INF"两个目录，并在 "WEB-INF" 目录下创建 一个 web.xml 文件

![20191216153347493.png][]

### 4、 Spring Boot 运行模式 ###

Springboot项目的3种运行模式：

idea方式，jar/war方式，maven插件方式

1.  如果是在开发过程中，会使用idea方式
2.  如果是在线上的服务器上，会使用jar/war方式，作为启动脚本
3.  如果开发环境是Linux环境，会使用maven插件方式。
    
        mvn spring-boot:run

[https_wushaopei.github.io]: https://wushaopei.github.io/
[http_www.jetbrains.com_idea]: http://www.jetbrains.com/idea
[20191129001120891.png]: https://img-blog.csdnimg.cn/20191129001120891.png
[20191202224101988.png]: https://img-blog.csdnimg.cn/20191202224101988.png
[20191216152139343.png]: https://img-blog.csdnimg.cn/20191216152139343.png
[20191216152236626.png]: https://img-blog.csdnimg.cn/20191216152236626.png
[2019121615230689.png]: https://img-blog.csdnimg.cn/2019121615230689.png
[20191216152431935.png]: https://img-blog.csdnimg.cn/20191216152431935.png
[20191216152527209.png]: https://img-blog.csdnimg.cn/20191216152527209.png
[20191216152620467.png]: https://img-blog.csdnimg.cn/20191216152620467.png
[20191216153116668.png]: https://img-blog.csdnimg.cn/20191216153116668.png
[20191216153347493.png]: https://img-blog.csdnimg.cn/20191216153347493.png