Mao-Design的博客

外观

功能实例

3293字约11分钟

2025-11-21

登录

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("/**");
    }
}

@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;

// 声明Mylog
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface MyLog {}

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

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

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

@Pointcut("@annotation(com.mao.aop.MyLog)")
private void pt(){}

@Around("pt()")
public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
    long start = System.currentTimeMillis();
    // 运行切入点
    Object result = joinPoint.proceed();
    long end = System.currentTimeMillis();
    long time = end - start;
    log.info(joinPoint.getSignature() + "运行时间：{}ms", time);
    return result;
}

通知顺序

切入点表达式

// 多个切入点表达式
@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