Spring Boot

Posted 2021-12-20 小企鹅推雪球!

文章目录

• • Spring Boot HelloWorld样例
  • Spring Boot 单元测试
  • Spring Boot 项目结构
  • Spring Boot 约定优于配置
  • Spring Boot程序包结构
  • Spring Boot 开启调试
  • SpringApplication 类
  • 配置服务端口
  • Application 属性文件

Spring Boot HelloWorld样例

1. 使用IDEA创建一个Spring Boot 项目
   
2. src/main/java 下面存在一个SpringbootHelloApplication.java 文件，并在其中添加 index() 方法，该方法返回一个字符串“Hello Spring Boot!”
3. index() 方法是一个 Spring MVC 方法，该方法将映射到应用根地址（/）

/**
 * 该类是整个 Spring Boot 项目的入口类，这个类有一个 @SpringBootApplication 注解，
 * 该注解是整个 Spring Boot 的核心注解，它的目的就是开启 Spring Boot 的自动配置。
 * 我在这个类上再添加一个 @RestController 注解，使之变为一个Controller，
 * 然后里边提供一个地址转换方法。
 *
 * @author Administrator
 */
@RestController
@SpringBootApplication
public class SpringbootHelloApplication 
 
    public static void main(String[] args) 
        // 启动Spring Boot
        SpringApplication.run(SpringbootHelloApplication.class, args);
    
 
    @RequestMapping(value = "/", produces = "text/plain;charset=UTF-8")
    public String index() 
        // 返回字符串到前端
        return "Hello Spring Boot!";
    
 

4. HelloApplication 中存在一个 main() 方法，则表示该类可以直接运行。且 main 方法中只有一行代码
   

Spring Boot 单元测试

1. 使用 JUnit 来测试 Spring Boot 应用时，需要额外做一些配置

   1. 引入Spring Boot JUnit 测试 maven 依赖

      <!-- Spring测试模块 -->
      <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-test</artifactId>
          <scope>test</scope>
      </dependency>
      

   2. 编写 controller，一个hello() 方法，且该方法返回“hello spring boot”字符串（请求地址为 /hello）

      @RestController
      public class HelloController 
       
          @RequestMapping("/hello")
          public String hello() 
              return "hello spring boot";
          
       
      
      

   3. 编写测试代码，测试 controller，自动调用“/hello”接口

      @RunWith(SpringRunner.class)
      @SpringBootTest
      public class HelloControllerTest 
          private MockMvc mvc;
        
          @Before
          public void setUp() throws Exception 
              mvc = MockMvcBuilders.standaloneSetup(new HelloController()).build();
          
        
          @Test
          public void hello() throws Exception 
              mvc.perform(MockMvcRequestBuilders.get("/hello")
                      .accept(MediaType.APPLICATION_JSON))
                      .andExpect(MockMvcResultMatchers.status().isOk())
                      .andDo(MockMvcResultHandlers.print())
                      .andReturn();
          
      
      

2. 测试程序中用到了 MockMvc类是来自“spring-boot-starter-test”依赖包。实现了对Http请求的模拟，能够直接使用网络的形式，转换到Controller的调用，使得测试速度快、不依赖网络环境。
3. MockMvc还提供了一套验证的工具
   1. MockMvcRequestBuilders.get("/hello").accept(MediaType.APPLICATION_JSON)：代码将获取一个请求构建对象 RequestBuilder
   2. mvc.perform(…)：方法将根据传递的 RequestBuilder 去调用接口
   3. andExpect(MockMvcResultMatchers.status().isOk())：判断调用接口返回的状态码是否为 200
   4. andDo(MockMvcResultHandlers.print())：执行一个动作，MockMvcResultHandlers.print() 将 MvcResult 细节打印到“标准”输出流。
   5. .andReturn()：返回请求执行的结果，以便直接访问结果

Spring Boot 项目结构

1. Spring Boot 项目结构是一个标准的 maven 项目（我创建的）

2. maven项目结构如下：

   + src（源代码目录）
   + main（存放源代码）
       + java（存放 java 代码）
           - SpringbootHelloApplication （Spring Boot启动类，该类拥有 main 方法）
       + resources（存放资源）
           - static（存放静态资源，如：图片、视频、音频等）
           - template（存放模板文件，如：ftl-freemarker模板等）
           - application.properties（Spring Boot 配置文件，可以为 .properties 或 .yml 类型）
   + test （存放测试代码）
       + java（存放 Java 测试代码）
       + resources（存放测试资源）
   

Spring Boot 约定优于配置

1. 约定优于配置（Convention Over Configuration），也称作按约定编程
2. 约定优于配置是一种软件设计范式。目的在于减少软件开发人员所需要做出的决定的数量，从而使得项目更加简单，但又不失去项目依赖的灵活性
3. 例如，如果模型中有个名为 Sale 的类，数据库中对应的表就会默认命名为 sales。只有在偏离这一约定的时候，比如将该表命名为“products_sold”，才会需要写有关这个名字的配置。
4. 架构师搭建项目就是限制软件开发随便写代码，制定出一套规范，让开发人员按统一的要求进行开发编码测试之类的，这样就加强了开发效率与审查代码效率

Spring Boot 中的约定优于配置

1. Spring Boot 是由 Pivotal 团队提供的全新框架，目的是用来简化新 Spring 应用的初始搭建以及开发过程。
2. Spring Boot框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置
3. Spring Boot 采用约定优于配置的方式，减少了配置文件的使用。
4. spring-boot-starter-web 包含了 Spring MVC 的相关依赖（包括 Json 支持的 Jackson 和数据校验的 Hibernate Validator）和一个内置的 Tomcat 容器，
5. Spring Boot 项目在开发阶段可以直接通过 main 方法或是 JAR 包独立运行一个 WEB 项目。而在部署阶段也可以打成 WAR 包放到生产环境运行

Spring Boot程序包结构

com.example.myproject
  +- Application.java（启动类）
  |
  +- domain（实体）
  |  +- Customer.java
  |  +- CustomerRepository.java
  |
  +- service（服务，业务逻辑）
  |  +- CustomerService.java
  |
  +- controller（控制器）
  |  +- CustomerController.java

1. Application.java 建议放到跟目录下面,主要用于做一些框架配置
2. domain目录主要用于实体（Entity）与数据访问层（Repository）
3. service 层主要是业务类代码
4. controller 负责页面访问控制

Spring Boot 开启调试

1. 对某些 Java 代码只是简单的修改（如删除一行代码，并没有添加方法和类），如果每次修改都需要重启服务器，很麻烦，为了避免这种麻烦可以去配置Spring Boot 开发工具
   1. 添加 maven 依赖

      <!-- 开发环境调试 -->
      <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-devtools</artifactId>
          <optional>true</optional>
      </dependency>
      

   2. 配置 spring-boot-maven-plugin 插件，将 fork 设置为 true

      <!-- Spring Boot Maven插件 -->
      <plugin>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-maven-plugin</artifactId>
          <configuration>
              <!-- 开启开发环境调试功能 -->
              <fork>true</fork>
          </configuration>
      </plugin>
      

   3. 入IDEA设置页面，选择“Build, Execution, Deployment”、“Compiler”选项。然后勾选自动编译复选框
      

SpringApplication 类

1. SpringApplication 类可用于从 Java main 方法引导和启动 Spring 应用程序

2. 默认情况下，class 将执行以下步骤

   1. 创建一个适当的 ApplicationContext 实例
   2. 注册一个 CommandLinePropertySource，将命令行接收的参数导出为 Spring 属性
   3. 刷新应用程序上下文，加载所有单例 bean
   4. 出发任意的 CommandLineRunner Bean

3. 在大多数情况下，可以直接从 main 方法中调用静态 run(Class，String []) 方法启动Spring 应用

   @Configuration
   @EnableAutoConfiguration
   public class MyApplication  
      // ... Bean definitions
      public static void main(String[] args) 
        SpringApplication.run(MyApplication.class, args);
      
   
   

4. 可以在调用 run() 方法之前创建和定制 SpringApplication 实例

   public static void main(String[] args) 
      SpringApplication application = new SpringApplication(MyApplication.class);
      // ... customize application settings here
      application.run(args)
   
   

5. SpringApplications 可以从各种不同的来源读取 bean,通常使用单个 @Configuration 类来引导Spring应用程序

6. 设置延迟初始化和自定义 Banner

   @SpringBootApplication
   public class SpringapplicationDemo2Application 
    
       public static void main(String[] args) 
           SpringApplication springApplication = new SpringApplication(SpringapplicationDemo2Application.class);
           // 启动延迟初始化
           springApplication.setLazyInitialization(true);
           // 自定义 MyBanner
           springApplication.setBannerMode(Banner.Mode.CONSOLE);
           springApplication.setBanner(new MyBanner());
           springApplication.run(args);
       
    
   
   

7. 自定义Banner代码

   public class MyBanner implements Banner 
    
       @Override
       public void printBanner(Environment environment, Class<?> sourceClass, PrintStream out) 
           out.println("+--------------------------------------------+");
           out.println("|                                            |");
           out.println("|      Spring Boot SpringApplication         |");
           out.println("|                                            |");
           out.println("+--------------------------------------------+");
       
    
   

配置服务端口

1. Spring Boot 应用默认的端口号是 8080。启动多个应用时需要修改 Spring Boot 应用的默认端口，修改 Spring Boot 默认端口有两种方式
   1. 修改 application.properties 或 application.yml 文件
      1. 修改 application.properties 属性文件
      csharp server.port=8081
      2. 修改 application.yml YAML 文件
      csharp server: port: 8081

Application 属性文件

1. Spring Boot 中的 application.properties 属性文件以下位置加载 application.properties 文件，并把它们添加到 Spring Environment 中
   1. 当前目录下的 /config 子目录中的 application.properties 文件
   2. 当前目录下的 application.properties 文件
   3. classpath下的 /config 包中的 application.properties 文件
   4. classpath 根路径（root）下的 application.properties 文件
2. 序号越小优先级越高。因此，上面中（1）可以覆盖（2）、（3）、（4）的配置，以此类推。有了配置文件加载的优先级
3. 不管 spring.config.location 配置什么值，默认总会按照 classpath:，classpath:/config，file:，file:config/ 的顺序进行搜索，优先级由低到高，也就是说 file:config/ 优先级最高。