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

紫风

发布于 2025-10-14 15:27:13

900

代码可运行

运行总次数：0

代码可运行

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

步骤1：初始化Spring Boot项目

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

操作：

生成项目：

访问 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

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

验证项目启动：

mvn spring-boot:run

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

步骤2：配置基础模块

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

操作：

创建统一响应类：

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

全局异常处理：

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

测试接口：

@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权限控制。

操作：

添加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>

创建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();
    }
}

配置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();
    }
}

创建登录接口：

@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, "用户名或密码错误");
    }
}

测试登录（使用Postman）：

POST http://localhost:8080/auth/login
Body: { "username": "admin", "password": "123456" }
返回Token后，在请求头添加 Authorization: Bearer <token> 访问其他接口。

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

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

操作：

配置数据库（application.yml）：

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

创建用户表（SQL）：

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

配置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 接口。

测试查询用户：

@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缓存

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

操作：

配置Redis连接（application.yml）：

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

创建缓存工具类：

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

在用户服务中使用缓存：

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