SpringBoot学习指南，超级全，真的细！挑战全篇无图教会你Java Springboot的使用。

考虑到大家学习的时间都比较碎片前面的9万字的文档确实阅读时间相对比较苛刻，故此将文档做一个分割，如果时间比较充足的小伙伴，建议还是直接阅读长篇这样学习会比较连贯
 juejin.cn/post/730931...

在当今的软件开发领域中，将前端技能与后端开发相结合是构建全栈应用的趋势。对于前端开发者而言，掌握后端技术是一个有力的补充，而Spring Boot则是构建强大、可伸缩的Java后端应用的首选框架之一。本学习指南将带领你逐步学习Spring Boot，并融合前端开发技能，助你成为一位全栈开发者。

为什么选择Spring Boot？

学习的理由还要我给你编？要理由直接掏你裆件😏😏😏😏😏😏

注意：

在学习本篇文章之前请大家先配置好本地的环境变量JAVA，docker，Maven主要的这三块。准备好了就可以开始学习啦。

1、创建一个Maven项目

linux 复制代码

com.practice

2、配置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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.practice</groupId>
    <artifactId>springboot_02_mvc</artifactId>
    <version>1.0-SNAPSHOT</version>

    <!--    所有的Spring boot项目都要继承这个父工程，父工程对所有的jar包进行管理-->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.8</version>
    </parent>
  2.  <dependencies>
        <!--问题1    为什么我现在就添加一个启动器依赖，项目就可以运行起来了，运行项目的jar包从何而来
                    因为项目中我们指定了一个父工程，在spring-boot-starter-parent中已经通过Maven的版本锁定了jar包的版本
        -->

        <!-- Spring Web启动器 -->
        <!--
             框架提供了很多的启动器（起步依赖），其实就是一组jar包的名称。
             web启动器：引入web开发相关的jar
         -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!--Lombok的主要作用是通过简化常见的Java代码模式，减少样板代码的编写，提高开发效率，
        减少代码错误，增加代码的可读性和可维护性。它已经成为许多Java开发人员的常用工具之一，
        并在许多开源项目和企业应用中广泛使用。-->

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.22</version> <!-- 请检查并使用最新的版本 -->
            <scope>provided</scope>
        </dependency>
        <!--
          @ConfigurationProperties(prefix = "spring.jdbc.datasource")
          需要配置spring-boot-configuration-processor依赖,用于生成metadata,否则会警告。
        -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>

    </dependencies>

</project>

3、新建程序入口 Application

src/main/java/com/practice/App.java

java 复制代码

package com.practice;


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

/**
 * @SpringBootApplication 主要作用
 * @SpringBootConfiguration（Srpingboot提供）用于声明配置类。等价于@Configuration（Spring提供）作用
 * @EnableAutoConfiguration 启用自动配置功能。一旦引入相关的启动器，默认相关的配置就会自动生效
 * 例如：引入spring-boot-starter-web启动器，那么，SpringMVC核心启动器，字符编码过滤器，试图解析器等就会自动生效。无需手动配置
 * @ComponentScan 默认扫描主程序所在的包以及子包，以后定义组件包时都存在主程序所在的包即可被扫码
 * <p>
 * 以上就是SpringBootApplication这个包的大体包含的纾解和功能
 */
@SpringBootApplication
public class App {
    //    启动内置Tomcat服务器，即：初始化IOC容器（采用默认框架）
    //    Tomcat 默认端口配置是8080
    public static void main(String[] args) {
        SpringApplication.run(App.class, args);//args为不定参数传不传无所谓
    }
}

4、新建一个javaBean

src/main/java/com/practice/pojo/User.java

java 复制代码

package com.practice.pojo; // 声明包名，这个类位于com.practice.pojo包下

import lombok.Getter;
import lombok.Setter;

import java.io.Serializable;

@Getter // 自动生成getter方法
@Setter // 自动生成setter方法
public class User implements Serializable { // 定义一个名为User的类，实现了Serializable接口，表示该对象可以序列化

    String username; // 声明一个字符串类型的字段，表示用户名
    String password; // 声明一个字符串类型的字段，表示密码
    Integer age; // 声明一个整数类型的字段，表示年龄
    String sex; // 声明一个字符串类型的字段，表示性别
}

5、新建一个Usercontroller

/src/main/java/com/practice/controller/UserController.java

java 复制代码

package com.practice.controller;

import com.practice.pojo.User;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.servlet.http.HttpServletRequest;
import java.util.ArrayList;
import java.util.List;

import static org.springframework.web.bind.annotation.RequestMethod.GET;

//组合两个注解 @Controller + @ResponseBody
@RestController
//@Controller
@RequestMapping(path ="/user")
public class UserController {

    @RequestMapping(path = "/findAll")
//    @ResponseBody 通过消息转换器HttpMessageConverter将返回的Bean 对象转换成json字符串
    public List<User> finAll(HttpServletRequest request){
        List<User> userList = new ArrayList<User>(); // 模拟用户列表
        User user1= new User();
        user1.setUsername("golang");
        user1.setAge(18);
        user1.setPassword("123456");
        user1.setSex("未知");
        userList.add(user1);
        return userList;
    }

    /**
     * 这段逻辑我们用来测试后面的http拦截器是否生效
     *  public enum RequestMethod {
     *      GET, HEAD, POST, PUT, PATCH, DELETE, OPTIONS, TRACE
     *  }
     */
    @RequestMapping(path = "/registry",method = GET)
    public void registryUser(HttpServletRequest request){
            String requestPath = request.getRequestURI(); // 获取请求的路径
            System.out.println("Request Path: " + requestPath);
            return;
    }

}

运行程序

6、静态资源目录

在WEB 开发中我们经常需要引入一些静态资源，例如：HTML，CSS,JS，图片等，如果是普通的项目静态资源可以放在项目的webapp 目录下

现在使用Spring Boot做开发，项目中没有webapp 目录，我们的项目是一个jar 工程，那么就没有 webapp，我们的静态资源该放哪里呢？

请注意在早期的版本中在springboot 中有一个叫做 ResourceProperties的类，里面就定义了静态资源的默认值

最新的2.7.8版本中（按两下shift 进入查找WebProperties.class）

xml 复制代码

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.8</version>
    </parent>

已修改为org.springframework.boot.autoconfigure.web.WebProperties

java 复制代码

/**
 * {@link ConfigurationProperties Configuration properties} for general web concerns.
 *
 * @author Andy Wilkinson
 * @since 2.4.0
 */
@ConfigurationProperties("spring.web")
public class WebProperties {
  ....
  public static class Resources {

    private static final String[] CLASSPATH_RESOURCE_LOCATIONS = { "classpath:/META-INF/resources/",
        "classpath:/resources/", "classpath:/static/", "classpath:/public/" };
    ........
    }
}

静态文件放置于resources里的4个目录中即可被自动加载。（这里建议使用static，语义化更清晰一点）

Linux 复制代码

.
├── pom.xml
├── src
│   ├── main
│   │   ├── java
│   │   │   └── com
│   │   └── resources
│   │       ├── META-INF
│   │       ├── public
│   │       ├── resources
│   │       └── static
│   └── test
│       └── java
└── target
    ├── classes
    │   └── com
    │       └── practice
    └── generated-sources
        └── annotations

尝试在static目录下新增一个hello.html的文件

/src/main/resources/static/hello.html

html 复制代码

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Hello Srpring-boot-mvc</title>
</head>
<body>
<h1>Hello world </h1>
</body>
</html>

服务启动

浏览器访问

Linux 复制代码

http://localhost:8080/hello.html

显示hello world

上面我们说的是Springboot出厂替我们设置好的几个指定的目录。

问题来了那么，如果我们需要自定义目录来存放我们的静态文件，需要怎么操作呢。

上面org.springframework.boot.autoconfigure.web.WebProperties中有Springboot为我们设置好的四个；路径，那么需要新增自定义配置目录我们就需要通过我们的application.properties或application.yml文件中设置对应的属性的来新增我们的可访问的静态目录。

这里我们使用application.yml来配置

src/main/resources/application.yml

yml 复制代码

spring:
  web:
    resources:
      static-locations: classpath:/webapp/

这里我们只需要在resource下新建webapp目录即可实现静态文件通过Tomcat被代理，实现静态文件可被访问。

请注意，如果自定义的目录生效了，那么Springboot提供的默认目录即会失效！！！！

7、拦截器

在Springboot项目中实现设置拦截器。

编写一个拦截器
通过WebMvcConfigurer注册拦截器

接下来我们一起来编写拦截器的代码

7.1创建自定义拦截器类

这个类应该实现HandlerInterceptor接口。

/src/main/java/com/practice/interceptor/Myinterceptor.java

java 复制代码

package com.practice.interceptor;

import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;


/**
 * effect : 这是一个自定义拦截器类，用于在处理HTTP请求之前或之后执行自定义的逻辑。
 * explain:
 * 1. @Component 注解将这个类声明为Spring组件，允许Spring自动扫描和管理它。
 *
 * 2. MyInterceptor 类实现了 HandlerInterceptor 接口，这是Spring MVC中的拦截器接口，包括preHandle，postHandle，afterCompletion方法。
 *
 * 3. preHandle 方法：在请求处理之前执行，可以用于执行拦截器逻辑，例如身份验证、权限检查等。
 *
 * 4. postHandle 方法：在请求处理后，视图渲染之前执行，可以用于对ModelAndView进行修改。
 *
 * 5. afterCompletion 方法：在请求完成后执行，无论是否发生异常都会执行，通常用于资源清理或日志记录。
 */


@Component
public class MyInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response,Object handler){
        System.out.println("the preHandle function in execution");
        // 返回 false 表示拦截请求并阻止其继续向下执行；返回 true 表示允许请求继续执行。
        return  false;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView)throws Exception {
        System.out.println("the postHandle function in execution");
        // 在请求处理后，视图渲染之前执行，可以用于对ModelAndView进行修改。

    }
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler,
                    Exception ex) throws Exception {
        System.out.println("the afterCompletion function in execution");
        // 在请求完成后执行，通常用于资源清理或日志记录。
    }

}

7.2创建一个配置类

实现WebMvcConfigurer接口，用于注册拦截器。

在配置类中覆盖addInterceptors方法，然后在该方法中注册你的自定义拦截器。

/src/main/java/com/practice/config/

java 复制代码

package com.practice.config;


import com.practice.interceptor.MyInterceptor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

/**
 * 配置类，用于注册自定义拦截器。
 *
 * 1. @Configuration 注解指示这是一个Spring配置类。
 *
 * 2. MyConfig 类实现了 WebMvcConfigurer 接口，允许自定义Web MVC配置。
 */


@Configuration
public class MyConfig implements WebMvcConfigurer {

    @Autowired
    MyInterceptor myInterceptor;  // 自动注入 MyInterceptor 实例

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        // 注册你定义的拦截器，这里我们的拦截器是 MyInterceptor。
        // 使用 addInterceptor 方法添加拦截器实例，并定义拦截路径和排除路径。

        registry.addInterceptor(myInterceptor)
                .addPathPatterns("/user/**")  // 设置拦截路径
                .excludePathPatterns("/user/registry/");  // 设置不拦截的路径
    }
}

在上面的示例中，WebMvcConfig 是一个配置类，实现了WebMvcConfigurer接口。在addInterceptors方法中，我们使用registry.addInterceptor()方法注册了名为MyInterceptor的自定义拦截器，并指定了拦截路径和排除路径。

这样，MyInterceptor将会在/user/** 路径下的请求中执行，并排除不拦截/user/registry/路径下的请求。

记得将WebMvcConfig类放在Spring Boot应用程序的包扫描路径下，以便Spring Boot能够自动识别并加载它。一旦你完成了这些步骤，你的自定义拦截器就会在应用程序中生效。

接下来启动项目,发送请求测试是否拦截成功。

Linux 复制代码


 wujiahao@wujiahao  ~  curl -X GET  http://localhost:8080/user/findAll
  [{"username":"golang","password":"123456","age":18,"sex":"未知"}]% 
 wujiahao@wujiahao  ~  curl -X GET  http://localhost:8080/user/registry    
 wujiahao@wujiahao  ~ 

通过上面的测试我们可以看到设置的拦截和过滤都生效了。

前端Springboot学习指南！！！（一）

SpringBoot学习指南，超级全，真的细！挑战全篇无图教会你Java Springboot的使用。

1、创建一个Maven项目

2、配置pom文件

3、新建程序入口 Application

4、新建一个javaBean

5、新建一个Usercontroller

6、静态资源目录

7、拦截器

7.1创建自定义拦截器类

7.2创建一个配置类