从0到1搭建Spring Boot 开发脚手架之分步骤教程

以下是 从零搭建Spring Boot脚手架的分步骤教程，适合新手直接操作，每个步骤均包含详细说明和代码示例：

---

步骤1：初始化Spring Boot项目

目标：创建基础项目结构，集成核心依赖。

操作：

1. 生成项目：

   • 访问 Spring Initializr，选择以下配置：

     • Project: Maven

     • Language: Java

     • Spring Boot: 3.1.x

     • Packaging: Jar

     • Java: 17

     • Dependencies:

       • Spring Web

       • Lombok

       • MyBatis-Plus

       • Spring Security

       • Redis

       • Spring Boot Actuator

2. 下载并解压项目，用IDE（如IntelliJ IDEA）打开。

3. 验证项目启动：

   mvn spring-boot:run

   访问 http://localhost:8080，看到 Whitelabel Error Page 说明成功。

---

步骤2：配置基础模块

目标：统一响应格式、全局异常处理。

操作：

1. 创建统一响应类：

   @Data
   @NoArgsConstructor
   @AllArgsConstructor
   public class Response<T> {
       private int code;
       private String message;
       private T data;
   
       public static <T> Response<T> success(T data) {
           return new Response<>(200, "success", data);
       }
   }

2. 全局异常处理：

   @RestControllerAdvice
   public class GlobalExceptionHandler {
       @ExceptionHandler(Exception.class)
       public Response<String> handleException(Exception e) {
           return new Response<>(500, e.getMessage(), null);
       }
   }

3. 测试接口：

   @RestController
   public class TestController {
       @GetMapping("/test")
       public Response<String> test() {
           return Response.success("Hello, Scaffold!");
       }
   }

   访问 http://localhost:8080/test，返回 { "code":200, "message":"success", "data":"Hello, Scaffold!" }。

---

步骤3：实现权限管理（Spring Security + JWT）

目标：用户登录、Token认证、RBAC权限控制。

操作：

1. 添加JWT依赖（pom.xml）：

   <dependency>
       <groupId>io.jsonwebtoken</groupId>
       <artifactId>jjwt-api</artifactId>
       <version>0.11.5</version>
   </dependency>
   <dependency>
       <groupId>io.jsonwebtoken</groupId>
       <artifactId>jjwt-impl</artifactId>
       <version>0.11.5</version>
       <scope>runtime</scope>
   </dependency>

2. 创建JWT工具类：

   public class JwtUtils {
       private static final String SECRET_KEY = "your-secret-key-1234567890";
       private static final long EXPIRATION = 86400000; // 24小时
   
       public static String generateToken(String username) {
           return Jwts.builder()
                   .setSubject(username)
                   .setExpiration(new Date(System.currentTimeMillis() + EXPIRATION))
                   .signWith(SignatureAlgorithm.HS512, SECRET_KEY)
                   .compact();
       }
   
       public static String parseToken(String token) {
           return Jwts.parserBuilder()
                   .setSigningKey(SECRET_KEY)
                   .build()
                   .parseClaimsJws(token)
                   .getBody()
                   .getSubject();
       }
   }

3. 配置Spring Security：

   @Configuration
   @EnableWebSecurity
   public class SecurityConfig {
       @Bean
       public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
           http
               .csrf().disable()
               .authorizeRequests()
               .antMatchers("/auth/login").permitAll()
               .anyRequest().authenticated()
               .and()
               .addFilterBefore(new JwtFilter(), UsernamePasswordAuthenticationFilter.class);
           return http.build();
       }
   }

4. 创建登录接口：

   @RestController
   @RequestMapping("/auth")
   public class AuthController {
       @PostMapping("/login")
       public Response<String> login(@RequestBody LoginRequest request) {
           // 模拟用户验证（实际需查数据库）
           if ("admin".equals(request.getUsername()) && "123456".equals(request.getPassword())) {
               String token = JwtUtils.generateToken(request.getUsername());
               return Response.success(token);
           }
           return Response.fail(401, "用户名或密码错误");
       }
   }

5. 测试登录（使用Postman）：

   • POST http://localhost:8080/auth/login

   • Body: { "username": "admin", "password": "123456" }

   • 返回Token后，在请求头添加 Authorization: Bearer <token> 访问其他接口。

---

步骤4：集成MyBatis-Plus与数据库

目标：连接MySQL，自动生成CRUD代码。

操作：

1. 配置数据库（application.yml）：

   spring:
     datasource:
       url: jdbc:mysql://localhost:3306/scaffold?useSSL=false
       username: root
       password: root
       driver-class-name: com.mysql.cj.jdbc.Driver

2. 创建用户表（SQL）：

   CREATE TABLE `sys_user` (
     `id` bigint NOT NULL AUTO_INCREMENT,
     `username` varchar(50) NOT NULL,
     `password` varchar(100) NOT NULL,
     PRIMARY KEY (`id`)
   );

3. 配置MyBatis-Plus代码生成器：

   public class CodeGenerator {
       public static void main(String[] args) {
           AutoGenerator generator = new AutoGenerator(new DataSourceConfig
               .Builder("jdbc:mysql://localhost:3306/scaffold", "root", "root")
               .build());
   
           GlobalConfig globalConfig = new GlobalConfig.Builder()
               .outputDir(System.getProperty("user.dir") + "/src/main/java")
               .author("YourName")
               .build();
   
           PackageConfig packageConfig = new PackageConfig.Builder()
               .parent("com.example.scaffold")
               .moduleName("sys")
               .entity("entity")
               .mapper("mapper")
               .build();
   
           StrategyConfig strategyConfig = new StrategyConfig.Builder()
               .addInclude("sys_user")
               .entityBuilder()
               .enableLombok()
               .build();
   
           generator.global(globalConfig)
               .packageInfo(packageConfig)
               .strategy(strategyConfig)
               .execute();
       }
   }

   运行后生成 User 实体类、UserMapper 接口。

4. 测试查询用户：

   @Service
   public class UserService {
       @Autowired
       private UserMapper userMapper;
   
       public User getUserByUsername(String username) {
           QueryWrapper<User> wrapper = new QueryWrapper<>();
           wrapper.eq("username", username);
           return userMapper.selectOne(wrapper);
       }
   }

---

步骤5：集成Redis缓存

目标：缓存用户信息，减少数据库压力。

操作：

1. 配置Redis连接（application.yml）：

   spring:
     redis:
       host: localhost
       port: 6379
       password: 
       database: 0

2. 创建缓存工具类：

   @Component
   public class RedisCache {
       @Autowired
       private RedisTemplate<String, Object> redisTemplate;
   
       public void set(String key, Object value, long expire) {
           redisTemplate.opsForValue().set(key, value, expire, TimeUnit.SECONDS);
       }
   
       public Object get(String key) {
           return redisTemplate.opsForValue().get(key);
       }
   }

3. 在用户服务中使用缓存：

   @Service
   public class UserService {
       @Autowired
       private RedisCache redisCache;
   
       public User getUserByUsername(String username) {
           String cacheKey = "user:" + username;
           User user = (User) redisCache.get(cacheKey);
           if (user == null) {
               user = userMapper.selectOne(new QueryWrapper<User>().eq("username", username));
               if (user != null) {
                   redisCache.set(cacheKey, user, 3600);
               }
           }
           return user;
       }
   }

---

后续步骤

1. 集成网关（Spring Cloud Gateway）：

   • 配置路由规则，将请求转发到不同服务。

   • 添加全局过滤器，验证JWT Token。

2. 熔断与限流（Sentinel）：

   • 在网关或服务层配置QPS限流。

   • 定义熔断规则，防止服务雪崩。

3. 部署与监控：

   • 使用Docker打包应用。

   • 配置Prometheus + Grafana监控面板。

---

最终验证

1. 启动所有依赖（MySQL、Redis）。

2. 访问 http://localhost:8080/auth/login 获取Token。

3. 携带Token访问受保护接口（如 /user/info），验证权限和缓存是否生效。

通过以上步骤，即可完成一个基础脚手架搭建。

本篇的分享就到这里了，感谢观看，如果对你有帮助，别忘了点赞+收藏+关注。
后续将继续把后续步骤继续完善，有什么遗漏、或者对什么功能有缺失的可以评论区，指出来，共同成长共同进步。