Spring Boot笔记1

发布时间:2023年12月28日

1. SpringBoot简介

1.1. 原有Spring优缺点分析

1.1.1. Spring的优点分析

Spring是Java企业版(Java Enterprise Edition,javeEE)的轻量级代替品。无需开发重量级的Enterprise JavaBean(EJB),Spring为企业级Java开发提供了一种相对简单的方法,通过依赖注入和面向切面编程,用简单的Java对象(Plain Old Java Object,POJO)实现了EJB的功能。

1.1.2. Spring的缺点分析

虽然Spring的组件代码是轻量级的,但它的配置却是重量级的。

不论是一开始的基于XML的配置,还是Spring2.5引入的基于注解的组件扫描,还是Spring 3.0引入的基于Java的配置,这些都代表了开发时的额外损耗。

因为在思考Spring配置和解决业务问题之间需要进行思维切换,甚至还带来了何种方式配置更好的无谓争论,所以编写配置挤占了编写应用程序逻辑的时间。和所有框架一样,Spring实用,但与此同时它要求的回报也不少。

除此之外,项目的依赖管理也是一件耗时耗力的事情。在环境搭建时,需要分析要导入哪些库的坐标,而且还需要分析导入与之有依赖关系的其他库的坐标,一旦选错了依赖的版本,随之而来的不兼容问题就会严重阻碍项目的开发进度。

1.2. SpringBoot的概述

SpringBoot对上述Spring的缺点进行的改善和优化,基于约定优于配置的思想,可以让开发人员不必在配置与逻辑业务之间进行思维的切换,全身心的投入到逻辑业务的代码编写中,从而大大提高了开发的效率,一定程度上缩短了项目周期。

1.2.1. SpringBoot的特点

  • SpringBoot不是对Spring功能上的增强,而是提供了一种快速构建Spring的方式
  • 开箱即用,没有代码生成,也无需XML配置。同时也可以修改默认值来满足特定的需求
  • 提供了一些大型项目中常见的非功能性特性,如嵌入式服务器(嵌入Tomcat,无需部署WAR文件)、安全、指标,健康检测、外部配置等

1.2.2. SpringBoot的核心功能

  • 起步依赖
    起步依赖本质上是一个Maven项目对象模型(Project Object Model,POM),定义了对其他库的传递依赖,这些东西加在一起即支持某项功能。
    简单的说,起步依赖就是将具备某种功能的坐标打包到一起,并提供一些默认的功能。
  • 自动配置
    Spring Boot的自动配置是一个运行时(更准确地说,是应用程序启动时)的过程,考虑了众多因素,才决定Spring配置应该用哪个,不该用哪个。该过程是Spring自动完成的。

后面会详细说明起步依赖与自动配置的原理解析。

2. SpringBoot实例

2.1. 创建SpringBoot简单实例

下面使用Maven创建一个基于SpringBoot的Web工程的简单实例。

2.1.1. 创建工程

注意:虽然是创建Web工程,但由于SpringBoot内嵌了Tomcat,所以这里选择jar包形式的工程。

2.1.2. 添加依赖

在pom.xml文件中添加SpringBoot的相关依赖

<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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.neusoft</groupId>
  <artifactId>boot</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <!-- 
  继承Spring Boot父级依赖,也就是:spring-boot-dependencies。
  父级依赖管理了Spring Boot项目中的所有依赖版本,以后导入依赖默认不需要写版本号了。
  (当前没有在dependencies里面管理的依赖自然需要声明版本号)
  -->
  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.3.3.RELEASE</version>
  </parent>
  <dependencies>
    <!-- 
    spring-boot-starter是Spring Boot的核心启动器。
    只要引入官方提供的starter,就可以将此模块中的相关jar都导入进来。
    官方的starter命名规范是:spring-boot-starter-模块名
    所以,下面配置会将web开发相关jar都导入进来,并自动管理版本信息。
    -->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
  </dependencies>
</project>

2.1.3. 添加工程主启动类

在类路径下创建HelloApplication.java文件

package com.neusoft.boot;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
    public class HelloApplication {
        public static void main(String[] args) {
            SpringApplication.run(HelloApplication.class, args);
        }
    }

注意:

  1. @SpringBootApplication注解指定该类为SpringBoot的程序入口类。
  2. SpringBoot项目的Bean默认装配规则是:根据入口类所在包位置从上往下扫描。
    例如:如果DemoApplication类所在的包为:com.neusoft.demo;那么就会自动扫描com.neusoft.demo 包及其所有子包,否则不会被扫描!
    所以,应将SpringBoot的程序入口类放到mapper、service所在包的上级。
  3. SpringApplication类中的run方法会对当前SpringBoot工程进程初始化创建。

2.1.4. 创建Controller

在 HelloApplication.java 所在包下创建controller包,然后创建Controller。

package com.neusoft.boot.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
    public class HelloController {
        @RequestMapping("/hello")
        public String say(){          //可以直接返回对象或集合,客户端将接收到json数据
            return "hello...";
        }
    }

@RestController 注解标识当前类为Controller组件,并且直接响应json数据。

2.1.5. 测试

执行HelloApplication类的入口方法,SpringApplication类中的run方法就会启动当前的SpringBoot工程。

Tomcat started on port(s): 8080 (http) with context path ''
Started DemoApplication in 4.292 seconds (JVM running for 5.15)

当控制台输出上述内容时,表示SpringBoot工程启动成功。 在地址栏中输入url进行访问测试:

注意:SpringBoot内嵌了Tomcat,所以只需要运行SpringBoot工程的主启动类即可。

2.1.6. 工程目录结构

2.2. 使用Spring Initializr创建工程

上面案例中,我们自己手动搭建了一个SpringBoot框架。实际上,为了实现快速开发,SpringBoot官方给我们提供了一个初始化器,可以引导我们快速构建一个SpringBoot工程。

2.2.1. 使用官方工具生成工程

打开 SpringBoot 官网:https://spring.io/projects/spring-boot/; 在网站的下部有 Spring Initializr 的链接。

点击此链接,进入到工程引导页面:

注意:

  1. 引导页面的左部,设置工程属性及版本信息等内容。右部设置工程所添加的依赖jar包。
  2. Packaging 处选择 Jar 形式。(因为SpringBoot 内置服务器,不需要打成 war 包)
  3. 因为我们想要创建web工程,所以添加 Spring Web 依赖模块。
  4. 最后,点击 “GENERATE” 按钮,生成整个工程。

2.2.2. 工程目录结构

先使用IDE导入工程(这里使用STS导入此Maven工程)。

注意: mvnw是一个maven wrapper script(Maven包装脚本),它可以让你在没有安装maven或者maven版本不兼容的条件下运行maven的命令。

2.2.3. pom.xml文件

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  <!-- pom模型版本 -->
  <modelVersion>4.0.0</modelVersion>
  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.3.3.RELEASE</version>
    <relativePath/> <!-- lookup parent from repository -->
  </parent>
  <!-- 项目信息 -->
  <groupId>com.neusoft</groupId>
  <artifactId>demo</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <name>demo</name>
  <description>Demo project for Spring Boot</description>
  <properties>
    <java.version>1.8</java.version>
    <!-- 配置工程字符编码集 -->
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
  </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>
      <exclusions>
        <exclusion>
          <groupId>org.junit.vintage</groupId>
          <artifactId>junit-vintage-engine</artifactId>
        </exclusion>
      </exclusions>
    </dependency>
  </dependencies>
  <!-- 配置SpringBoot的Maven插件 -->
  <build>
    <plugins>
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
      </plugin>
    </plugins>
  </build>
</project>

2.2.4. 工程主启动类

package com.neusoft.demo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class DemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}

2.2.5. 创建Controller

在 DemoApplication.java 所在包下创建controller包,然后创建Controller。

package com.neusoft.demo.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class UserController {
    @RequestMapping("/hello")
    public String say() {
        return "hello...";
    }
}

2.2.6. 测试

执行 DemoApplication类的入口方法,然后在地址栏中输入url进行访问测试。

2.3. 2.3.使用STS创建工程

2.3.1. 创建Spring Starter Project工程

2.3.2. 添加工程信息

注意:这里添加Maven工程需要的一些信息

2.3.3. 添加版本及依赖信息

注意:这里添加SpringBoot版本信息、添加的依赖信息。然后点击 “Finish” 。

2.3.4. 生成SpringBoot工程

工程创建完成后,我们会发现:创建的工程与使用 Spring Initializr 创建的工程是完全一样的。

2.4. SpringBoot热部署

我们在开发中反复修改类、页面等资源,每次修改后都是需要重新启动才生效,这样每次启动都很麻烦,浪费了大量的时间,我们可以在修改代码后不重启就能生效,在 pom.xml 中添加如下配置就可以实现这样的功能,我们称之为热部署。

<!--热部署配置-->
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-devtools</artifactId>
</dependency>

2.5. SpringBoot的跨域处理

除了使用传统的过滤器来设置跨域处理配置之外,SpringBoot还给我们提供了两种跨域处理方式:

  1. 使用 @CrossOrigin 注解配置某一个 Controller 允许跨域。
//只要在此Controller上使用@CrossOrigin注解就可实现跨域访问,并可配置允许跨域的url
@CrossOrigin("*") 
@RestController
public class DeptController { //... }
  1. 实现 WebMvcConfigurer 接口中的 addCorsMappings 方法,在此方法中配置全局跨域处理。
    在工程中添加 WebMvcConfig 类。此类配置了 @Configuration 注解,就成为一个 Spring 容器类,工程启动时会自动加载此类中的配置。
package com.neusoft.demo;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
@Configuration
public class WebMvcConfig implements WebMvcConfigurer {
    @Override
    public void addCorsMappings(CorsRegistry registry) {
        /*
* addMapping:配置可以被跨域的路径,可以任意配置,可以具体到直接请求路径。 
* allowCredentials:是否开启Cookie
* allowedMethods:允许的请求方式,如:POST、GET、PUT、DELETE等。
* allowedOrigins:允许访问的url,可以固定单条或者多条内容
* allowedHeaders:允许的请求header,可以自定义设置任意请求头信息。 
* maxAge:配置预检请求的有效时间
*/
        registry.addMapping("/**")
            .allowedOrigins("*")
            .allowCredentials(true)
            .allowedMethods("*")
            .allowedHeaders("*")
            .maxAge(36000);
    }
}

2.6. @RequestBody实现参数序列化

前端使用 AJAX 的 post 方式请求时,需要对请求参数做序列化处理,否则 SpringMVC 无法接收提交参数。

//使用qs模块中的stringify方法实现post提交时的参数序列化
this.$axios.post('http://localhost:8080/hello', this.$qs.stringify(user))...

在 SpringBoot 中,可以使用 @RequestBody 注解,在服务器端实现 post 提交时的参数序列化处理。这样,前端的 post 请求就可以直接提交 json 对象了。

@RequestMapping("/hello")
//在参数前使用@RequestBody注解
public String say(@RequestBody User user) {
    System.out.println(user);
    return "hello...";
}
let user = {
  userId: 1,
  userName: 'zhangsan',
  password: '123'
};
axios.post('http://localhost:8080/elm/hello',user)
  .then(response => {
    console.log(response.data);
  }).catch(error => {
    console.log(error);
  });

@RequestBody 注解很强大,它甚至于可以直接接收 json 数组。

@RequestMapping("/hello")
//使用集合接收json数组
public String say(@RequestBody List<User> list) {
    for(User user : list) {
        System.out.println(user);
    }
    return "hello...";
}
let userArr = [{
  userId: 1,
  userName: '张三',
  password: '123'
}, {
  userId: 2,
  userName: '李四',
  password: '888'
}, {
  userId: 3,
  userName: '王五',
  password: '999'
}]
axios.post('http://localhost:8080/elm/hello', userArr)
  .then(response => {
    console.log(response.data);
  }).catch(error => {
    console.log(error);
  });

注意:@RequestBody 注解不支持get方式请求

后续笔记icon-default.png?t=N7T8https://blog.csdn.net/qq_64071654/article/details/135263480

文章来源:https://blog.csdn.net/qq_64071654/article/details/135263421
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。