Mao-Design的博客

外观

SpringBoot02

4414字约15分钟

2026-01-22

登录

com/mao/controller/UserPass.java

@RestController
public class UserPass {
    @Autowired
    private UserService userService;

    @PostMapping("/login")
    public Result login(@RequestBody User user) {
        User user1 = userService.login(user);
        // 数据库中查不到数据，则报错
        return user1 != null ? Result.success() : Result.error("用户名或者密码错误");
    }
}

com/mao/service/UserService.java

public interface UserService {
    User login(User user);
}

com/mao/service/impl/UserServiceImpl.java

@Service
public class UserServiceImpl implements com.mao.service.UserService {
    @Autowired
    private UserMapper userMapper;

    @Override
    public User login(User user) {
        User user1 = userMapper.getByUsernameAndPasswrd(user);
        return user1;
    }
}

com/mao/mapper/UserMapper.java

@Mapper     // 会自动生成该接口的实现类对象（代理对象），交给IOC容器管理
public interface UserMapper {
    @Select("select * from user1 where name = #{name} and age = #{age}")
    public User getByUsernameAndPasswrd(User user);
}

发送链接：127.0.0.1:9000/login

{
    "name": "zhangsna",
    "age": "20"
}

会话技术

JWT令牌

pom.xml

com/mao/controller/UserPass.java（发送自定义业务数据）

com/mao/utils/JwtUtils.java（生成JWT令牌）

时间单位关系：
1 秒 = 1000 毫秒（ms）
1 分钟 = 60 秒
1 小时 = 60 分钟
所以 3600000 毫秒为1小时

校验JWT令牌

@Test
public void JWT2() {
    Claims claims = Jwts.parser()
            .setSigningKey("自定义密钥")	// secretKey
            .parseClaimsJws("JWT 字符串")	// jwt
            .getBody();
    System.out.println(claims);
}

过滤器 Filter

过滤器一般完成一些通用的操作，比如：登录校验、统一编码处理、敏感字符处理等

pom.xml（调用阿里巴巴库：JSON.toJSONString）

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.41</version>
</dependency>

com/mao/filter/Filter1.java（过滤器）

拦截器

pom.xml（调用阿里巴巴库：JSON.toJSONString）

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.41</version>
</dependency>

com/mao/interceptor/LoginCheckInterceptor.java（拦截器）

com/mao/config/WebConfig.java（拦截规则）

@Configuration  // 配置类
public class WebConfig implements WebMvcConfigurer {
    @Autowired
    private LoginCheckInterceptor loginCheckInterceptor;

    // 注册拦截器并配置拦截规则
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(loginCheckInterceptor).addPathPatterns("/**");
    }
}

1. HttpServletRequest request —— HTTP 请求对象

核心含义

代表客户端发送给服务器的所有 HTTP 请求信息，是 Servlet 规范的核心接口，Spring MVC 对其做了封装，包含请求头、请求参数、请求路径、Cookie、Session 等所有请求相关数据。

核心作用

常用操作示例代码作用说明
获取请求参数request.getParameter("name")获取客户端传入的参数（如 URL 参数、表单参数）
获取请求路径request.getRequestURI()获取请求的路径（如 /admin/report/export）
获取请求头request.getHeader("Token")获取请求头信息（如 Token、User-Agent）
获取 Cookierequest.getCookies()获取客户端携带的 Cookie
获取 Sessionrequest.getSession()获取 / 创建用户会话（保存用户状态）
获取请求方式request.getMethod()判断是 GET/POST/PUT/DELETE 等请求方式

通俗类比

相当于快递员（客户端）送到你公司（服务器）的 “快递单 + 包裹”：request 包含了快递单上的收件人、地址、联系方式（请求头 / 参数），以及包裹里的内容（请求体）。

2. HttpServletResponse response —— HTTP 响应对象

核心含义

代表服务器要返回给客户端的所有 HTTP 响应信息，同样是 Servlet 规范的核心接口，用于设置响应状态码、响应头、响应体（如返回 JSON、文件、页面）、Cookie 等。

核心作用

常用操作示例代码作用说明
设置响应状态码response.setStatus(200)设置 200（成功）、404（未找到）、500（服务器错误）等
设置响应头response.setHeader("Content-Type", "application/json")指定响应数据类型（如 JSON、Excel）
输出响应体response.getWriter().write("success")向客户端返回字符串数据
下载文件response.getOutputStream().write(fileBytes)向客户端输出二进制文件（如 Excel、图片）
设置 Cookieresponse.addCookie(new Cookie("token", "xxx"))向客户端写入 Cookie
设置字符编码response.setCharacterEncoding("UTF-8")避免响应数据乱码

通俗类比

相当于你（服务器）要寄回给快递员（客户端）的 “回执单 + 回寄包裹”：response 包含回执单上的签收状态（状态码）、备注（响应头），以及回寄的包裹内容（响应体）。

3. Object handler —— 处理器对象

四、核心总结

参数核心定位核心作用
HttpServletRequest请求信息载体读取客户端传入的所有请求数据（参数、头、路径等）
HttpServletResponse响应信息载体向客户端返回数据（JSON、文件、状态码等）
Object handler请求处理器标识定位处理当前请求的控制器方法，获取方法 / 类的元信息

获取token

// 你的原代码
String token = request.getHeader(jwtProperties.getAdminTokenName());

jwtProperties.getAdminTokenName() → 获取的是 令牌的【名字 / 键 (key)】

request.getHeader(令牌的key) → 根据这个 key，获取到请求头里对应的令牌【值 (value)】

最终得到的 String token 变量，才是真正的 JWT 令牌的值

为什么要这么多此一举？不直接写死 request.getHeader("token")？

✅ 核心原因：解耦 + 灵活配置，SpringBoot 的最优规范，这也是你项目里这么写的目的

  1. ❌ 如果写死 request.getHeader("token")：

    哪天前端想把请求头名称改成Authorization，或者admin-token，你需要全局搜索项目里所有的这个代码，挨个修改，容易漏改、改错，非常麻烦。

  2. ✅ 通过jwtProperties.getAdminTokenName()：

    你只需要在 application.yml/application.properties 配置文件里改一行配置即可，代码一行都不用动，全局生效！

# application.yml 配置文件
jwt:
  admin-token-name: token  # 想改的话，直接改这里就行，比如改成 Authorization

这就是配置类Properties的核心价值：把可变的配置项抽离到配置文件，代码写死不变。

@Configuration与 @Component 的区别

特性@Configuration@Component
核心用途定义 Bean 配置逻辑标记普通组件（如业务类）
@Bean 方法处理默认代理，保证单例无代理，@Bean 方法调用创建新实例
扫描优先级专门的配置类，Spring 优先解析普通组件，按需扫描

全局异常处理

// 这段代码是一个 全局异常处理器，用于统一捕获和处理 Spring 应用中抛出的异常
@RestControllerAdvice
public class GlobalException {
    // 捕获所有异常
    @ExceptionHandler(Exception.class)
    public Result exception(Exception e) {
        e.printStackTrace();
        return Result.error("全局异常测试");
    }
}

事务管理

@Transactional

传播行为（b() 的配置）a() 有事务a() 无事务
REQUIREDb() 加入 a() 的事务（a回滚，所以b日志保存失败）b() 新建事务
REQUIRES_NEWb() 新建独立事务，a() 事务不受其影响b() 新建事务

src/main/resources/application.yml

# Spring 事务管理日志
logging:
  level:
    org.springframework.jdbc.support.JdbcTransactionManager: debug
// @Transactional只有运行时异常才会混滚操作。其他异常不会回滚
// (rollbackFor = Exception.class)所有异常都会执行回滚操作
// 所以当删除数据库失败，并报异常，则执行回滚操作
@Transactional(rollbackFor = Exception.class)
@DeleteMapping("/hi/{id}")
public Result delete(@PathVariable Integer id) {
    log.info("删除数据");
    userMapper.delete(id);

    userMapper.delete01(id);
    return Result.success("删除成功： " + id);
}
// 表示需要新事务，无论当前是否存在已有事务，都会创建一个全新的独立事务。
@Transactional(propagation = Propagation.REQUIRES_NEW)

AOP

相当于AOP对象和目标对象结合成一个新的代理对象，然后当我们调用目标对象的时候会自动调用结合好的代理对象，从而实现添加的功能

通知类型

pom.xml

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

公共切点

自定义注解

com/mao/aop/MyLog.java（声明MyLog）

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

// 注解的 “生命周期”：运行时保留（程序运行期间，通过反射能获取到这个注解）；
@Retention(RetentionPolicy.RUNTIME)
// 注解的 “使用位置”：只能标注在方法上（不能标在类、字段、参数等位置）；
@Target(ElementType.METHOD)
// 自定义声明Mylog注解
public @interface MyLog {}

com/mao/service/impl/UserServiceImpl.java（标注MyLog）

@MyLog
@Override
public String login() {
    return "hi";
}

com/mao/aop/MyAspect.java（当执行 MyLog 标记的方法时，切入）

@Target(ElementType.METHOD) 的常用取值（对比理解）

取值可标注位置示例
METHOD（你用的）方法上@MyLog public void addEmp(){}
TYPE类 / 接口上@MyLog public class EmpController{}
FIELD字段上@MyLog private String name;
PARAMETER方法参数上public void addEmp(@MyLog Long id){}
ANNOTATION_TYPE注解上（元注解）@MyLog public @interface MyAnno{}
ALL（无此值）无若想标注多个位置，用数组：@Target({TYPE, METHOD})

通知顺序

切入点表达式

// 多个切入点表达式
@Before("execution(* com.mao.service.UserService.page(..)) ||" +
        "execution(* com.mao.service.UserService.login(..))")
public void before(JoinPoint joinPoint) throws Throwable {
    log.info("before...");
}

获取执行方法的相关信息

打包项目

要理解这些 Maven 生命周期阶段的含义，我们可以逐一说明：

  1. clean：清理项目，删除编译生成的输出目录（如 target 文件夹），确保项目以干净的状态构建。
  2. validate：验证项目的正确性，检查必要的配置、依赖是否完整有效。
  3. compile：编译项目的源代码，将 src/main/java 下的 Java 源码编译成字节码文件，输出到 target/classes 目录。
  4. test：执行单元测试，运行 src/test/java 下的测试用例，验证代码逻辑的正确性。
  5. package：将项目打包，根据项目类型生成对应的包文件（如 Java 项目生成 JAR 包，Web 项目生成 WAR 包），输出到 target 目录。
  6. verify：在打包后执行集成测试、代码质量检查等验证操作，确保包的质量符合要求。
  7. install：将打包生成的包文件安装到本地 Maven 仓库（通常是用户目录下的 .m2 文件夹），以便其他本地项目可以依赖该包。
  8. site：生成项目的站点文档，包含项目信息、依赖、测试报告等静态网页内容。
  9. deploy：将打包好的包文件部署到远程 Maven 仓库（如私服），供团队其他成员或项目共享使用。

Bean管理

获取IOC容器中Bean对象的各种信息

Bean作用域

Bean对象如果想每次使用的时候都为新的实例，则使用 @Scope("prototype")

第三方Bean

当我们引入第三方的对象时，该对象默认是不在IOC容器中的，所以需要自己手动引入到IOC容器中，方便使用

@Configuration
public class CommonConfig {
    // SAXReader读取XML文件的第三方对象
    @Bean   // 将该方法的返回值交给IOC容器管理，成为IOC容器Bean
    public SAXReader saxParser() {
        return new SAXReader();
    }
}

自动配置（引入外部自定义对象）

**src/main/java/utils/java/**Hi.java

public class Hi {
    public String hi() {
        return "hi";
    }
}

**src/main/java/utils/java/**Bean01.java

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

// 自定义定义多个Bean对象
@Configuration
public class Bean01 {
//    定义自定义Bean
    @Bean
    public Hi Hi() {
        return new Hi();
    }
}

**src/main/java/utils/java/**MyImportSelector.java

import org.springframework.context.annotation.ImportSelector;
import org.springframework.core.type.AnnotationMetadata;

public class MyImportSelector implements ImportSelector {
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        return new String[] {"utils.java.Bean01"};
    }
}

**src/main/java/utils/java/**Zhujie.java

import org.springframework.context.annotation.Import;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Import(Bean01.class)	// 导入Bean01对象
public @interface Zhujie { }

**src/test/java/com/mao/**Bash01.java

@SpringBootTest
@Zhujie	// 通过Zhujie接口访问到Bean01对象，然后在问到Bean01中的方法
public class Bash01 {
    @Autowired
    private Bean01 Bean01;
    
    @Test
    public void test2() {
        System.out.println(Bean01.Hi().hi());	// hi
    }
}

SpringBoot默认是无法扫描外部对象的，所以通过自定义的注解调用

自定义starter库

创建SpringBoot项目，然后进行精简，大概文件如下

starter 是 “入口”，autoconfigure 是 “核心逻辑”，两者配合实现 Spring Boot 最核心的 “自动配置

具体流程：项目引入starter，通过starter调用autoconfigure中的代码

ceshi-spring-boot-autoconfigure

com/maven1/Name.java

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;

@Data
@ConfigurationProperties(prefix = "ceshi")
public class Name {
    private String name = "autoconfigure01ceshi";
    
    public String name() {
        return name;
    }
}

com/maven1/AutoConfig01.java（）

import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@EnableConfigurationProperties(Name.class)
public class AutoConfig01 {
    @Bean
    public Name Name() {
        return new Name();
    }
}

resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports

com.maven1.AutoConfig01

pom.xml

ceshi-spring-boot-starter

pom.xml

<!-- 其它代码省略 -->
<!-- 按需删掉多余的代码 -->
<dependencies>
   <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter</artifactId>
   </dependency>
   <!-- 引入autoconfigure -->
   <dependency>
       <groupId>com.maven1</groupId>
       <artifactId>ceshi-spring-boot-autoconfigure</artifactId>
       <version>0.0.1-SNAPSHOT</version>
   </dependency>
</dependencies>

springboot1

com/maven1/demos/ceshi.java

pom.xml

<!-- 引入starter -->
<dependency>
   <groupId>com.maven1</groupId>
   <artifactId>ceshi-spring-boot-starter</artifactId>
   <version>0.0.1-SNAPSHOT</version>
</dependency>

SpringBoot框架结构

SpringMVC + SpringFramework + Mybatis = SSM