SpringBoot入门

一.SpringBoot介绍

1.SpringBoot的角色

Spring Framework(JavaEE的框架) -> Spring Boot(快速构建的Spring的应用) -> Spring Cloud(构建SpringBoot的分布式环境，即云应用)

2.SpringBoot

• SpringBoot特性

  • 自动装配，实现springMVC、JDBC等的装配
  • 嵌入式容器，实现Netty、Tomcat等web容器嵌入
  • 为生产准备的特性：产品整合

• 2.0新特性

  • 编程语言Java 8+、Kotlin
  • 底层框架Spring Framework 5.0.x
  • 全新特性Web Flux（相比SpringMVC提出新型声明式函数式编程）
  • 为什么选择Web Flux？
    
    • 函数式编程：Java8 Lambda
    • 响应式编程：Reactive Streams
    • 异步编程：Servlet3.1或Asyc NIO

二.环境准备

• 装配JDK
• 装配Maven（依赖资源管理，帮助管理第二方包或第三方包的中间件）
• 装配IDEA（开发环境，帮助快速搭建环境并调试）

三.第一个SpringBoot项目

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

1.编写REST程序

• 通过https://start.spring.io/创建spring项目

• 并以Maven形式导入IDEA中

• 创建domain包定义实体类User

  package com.imooc.firstappdemo.domain;
  /*
  * 用户模型
  */
  
  public class User {
  
    private int id;
  
    /*
     * 用户名称
     */
    private String name;
  
    public int getId() {
        return id;
    }
  
    public void setId(int id) {
        this.id = id;
    }
  
    public String getName() {
        return name;
    }
  
    public void setName(String name) {
        this.name = name;
    }
  
    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
  }
  

• 创建repository包定义dao层（不访问数据库，存在map内存中）

  package com.imooc.firstappdemo.repository;
  
  import org.springframework.stereotype.Repository;
  import com.imooc.firstappdemo.domain.User;
  
  import java.util.Collection;
  import java.util.concurrent.ConcurrentHashMap;
  import java.util.concurrent.ConcurrentMap;
  import java.util.concurrent.atomic.AtomicInteger;
  
  /*
  * {@link User}
  */
  @Repository
  public class UserRepository {
    /**
     * 采用内存型的存储方式->Map
     */
    private ConcurrentMap<Integer,User>repository = new ConcurrentHashMap<>();
  
    private final static AtomicInteger idGenerator = new AtomicInteger();
  
    /**
     * 保存用户对象
     * @param user
     * @return 如果保存成功，返回true；否则返回false
     */
    public boolean save(User user){
        //ID从1开始
        Integer id = idGenerator.incrementAndGet();
        //设置id
        user.setId(id);
        return repository.put(id,user) == null;//为null则表示保存成功
    }
  
    public Collection<User> findAll() {
        return repository.values();
    }
  }

• 创建controller包定义UserController利用webMVC模式创建用户

  package com.imooc.firstappdemo.controller;
  
  import com.imooc.firstappdemo.domain.User;
  import com.imooc.firstappdemo.repository.UserRepository;
  import org.springframework.beans.factory.annotation.Autowired;
  import org.springframework.web.bind.annotation.PostMapping;
  import org.springframework.web.bind.annotation.RequestParam;
  import org.springframework.web.bind.annotation.RestController;
  
  @RestController
  public class UserController {
  
    private final UserRepository userRepository;
  
    //采用构造器的注入方式：
    // 好处1:不能修改
    // 好处2:提早进行初始化
    @Autowired
    public UserController(UserRepository userRepository){//参数由Spring框架进行传入
        this.userRepository = userRepository;
    }
  
    @PostMapping("/person/save")
    public User save(@RequestParam String name){
        User user = new User();
        user.setName(name);
        if(userRepository.save(user)){
            System.out.printf("用户对象: %s 保存成功!\n",user);
        }
        return user;
    }
  
  }

• 创建config包定义webFlux模式获取用户

  package com.imooc.firstappdemo.config;
  
  import com.imooc.firstappdemo.domain.User;
  import com.imooc.firstappdemo.repository.UserRepository;
  import org.springframework.beans.factory.annotation.Autowired;
  import org.springframework.context.annotation.Bean;
  import org.springframework.context.annotation.Configuration;
  import org.springframework.web.reactive.function.server.RequestPredicates;
  import org.springframework.web.reactive.function.server.RouterFunction;
  import org.springframework.web.reactive.function.server.RouterFunctions;
  import org.springframework.web.reactive.function.server.ServerResponse;
  import reactor.core.publisher.Flux;
  import reactor.core.publisher.Mono;
  
  import java.util.Collection;
  
  /**
  * 路由器函数 配置
  */
  
  @Configuration
  public class RouterFunctionConfiguration {
  
    /**
     * Servlet
     * 请求接口：ServletRequest或者HttpServletRequest
     * 响应接口：ServletResponse或者HttpServletResponse
     * Spring 5.0重新定义了服务端的请求和响应接口：
     *  请求接口：ServerRequest
     *  响应接口：ServerResponse
     *  即可以支持Servlet规范，也可以支持自定义，比如Netty <Web Server>
     *  以本利：
     *  定义GET请求，并且返回所有的用户对象URI：/person/find/all
     *  Flux是0-N个对象集合
     *  Mono是0-1个对象集合
     *  Reative中的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);
        });
    }
  
  }
  

2.运行SpringBoot应用

直接运行main->java->FirstAppDemoApplication

package com.imooc.firstappdemo;

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

@SpringBootApplication
public class FirstAppDemoApplication {

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

3.使用HTTP请求工具：PostMan

四.多模块项目

1.调整主（父）工程类型（<packaging>）

2.创建子模块工程（<module>）

• 模型层:model
• 持久层:persistence
• 表示层:web

3.子模块依赖管理（<dependency Management>）

• web依赖于persistence，persistence依赖于model

五.打包和运行

1.打包方式

• 构建jar包

• 构建war包

  <!-- packaging值默认是jar -->
  <packaging>war</packaging>

• 指定Main-Class

  <!--在build plugins的plugin中添加-->
  <configuration>
    <mainClass>com.imooc.firstaoo.demo.FirstAppDemoApplication</mainClass>
  </configuration>

2.运行模式

• IDEA方式
• JAR/WAR方式
• Maven的插件方式