# java-study

**Repository Path**: zeng-zhiyao/java-study

## Basic Information

- **Project Name**: java-study
- **Description**: 本项目是一个基于Spring Boot的RESTful API服务，使用了以下技术栈：

Spring Boot：作为核心框架，提供快速开发和部署能力。
Swagger：用于生成API文档，方便测试和维护。
Lombok：减少样板代码，提高开发效率。
MySQL：作为关系型数据库，存储项目数据。
JWT：用于身份验证和授权。
统一响应：所有API响应遵循统一的格式，提高接口的可读性和一致性。
- **Primary Language**: Java
- **License**: MulanPSL-2.0
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 1
- **Forks**: 0
- **Created**: 2025-07-09
- **Last Updated**: 2025-09-29

## Categories & Tags

**Categories**: Uncategorized

**Tags**: SpringBoot, 模板, 三层架构

## README


当然可以！以下是一个Spring Boot项目的文档示例，涵盖了你提到的技术栈：Spring Boot、Swagger、Lombok、MySQL、JWT拦截器和统一响应。

### 项目文档

#### 项目概述

本项目是一个基于Spring Boot的RESTful API服务，使用了以下技术栈：

- **Spring Boot**：作为核心框架，提供快速开发和部署能力。
- **Swagger**：用于生成API文档，方便测试和维护。
- **Lombok**：减少样板代码，提高开发效率。
- **MySQL**：作为关系型数据库，存储项目数据。
- **JWT**：用于身份验证和授权。
- **统一响应**：所有API响应遵循统一的格式，提高接口的可读性和一致性。

#### 项目结构

```
springboot-project
├── src
│   ├── main
│   │   ├── java
│   │   │   └── com
│   │   │       └── example
│   │   │           └── javademo
│   │   │               ├── config
│   │   │               │   ├── SwaggerConfig.java
│   │   │               │   ├── JwtConfig.java
│   │   │               │   └── ResponseConfig.java
│   │   │               ├── controller
│   │   │               │   └── UserController.java
│   │   │               ├── entity
│   │   │               │   └── User.java
│   │   │               ├── exception
│   │   │               │   └── CustomException.java
│   │   │               ├── repository
│   │   │               │   └── UserRepository.java
│   │   │               ├── service
│   │   │               │   ├── UserService.java
│   │   │               │   └── UserServiceImpl.java
│   │   │               └── DemoApplication.java
│   │   └── resources
│   │       ├── application.properties
│   │       ├── static
│   │       └── templates
│   └── test
│       └── java
│           └── com
│               └── example
│                   └── demo
│                       └── DemoApplicationTests.java
└── pom.xml
```

#### 技术栈

- **Spring Boot**：2.5.0
- **Swagger**：3.0.0
- **Lombok**：1.18.20
- **MySQL**：8.0.23
- **JWT**：0.11.5
- **统一响应**：自定义

#### 依赖管理

在 `pom.xml` 文件中，添加以下依赖：

```xml
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!-- 引入jwt-->
        <dependency>
            <groupId>com.auth0</groupId>
            <artifactId>java-jwt</artifactId>
            <version>3.8.2</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <!--JDBC-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <!--mysql-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.33</version>
        </dependency>
        <!--mybatis-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>3.0.3</version>
        </dependency>
        <!--jwt-s-->
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt</artifactId>
            <version>0.12.6</version>
        </dependency>
        <!-- logback核心组件 -->
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-core</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.springdoc</groupId>
            <artifactId>springdoc-openapi-starter-webmvc-ui</artifactId>
            <version>2.3.0</version>
        </dependency>
    </dependencies>
```

#### 配置文件

在 `application.properties` 文件中，添加以下配置：

```properties
spring.application.name=java-demo
spring.datasource.driverClassName=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/demo?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=Asia/Shanghai
spring.datasource.username=root
spring.datasource.password=root
mybatis.mapper-locations=classpath:com/example/javademo/*.xml
logging.level.org.apache.ibatis=DEBUG
#mybatis.mapper-locations=classpathcom/example/javademo/Mapper/*.xml

logging.console.enabled=true
spring.web.resources.static-locations=file:./src/main/static/
# ?? MyBatis ??????
mybatis.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl
logging.level.com.example=DEBUG
logging.file.name=app.log
#logging.config=classpath:logback-spring.xml
springdoc.api-docs.enabled=true
springdoc.api-docs.path=/user-service/v3/api-docs
springdoc.swagger-ui.enabled=true
springdoc.swagger-ui.path=/user-service/swagger-ui/index.html

```

#### Swagger配置

在 `config/SwaggerConfig.java` 文件中，配置Swagger：

```java

```

#### JWT配置

在 `config/JwtConfig.java` 文件中，配置JWT：

```java
package com.example.javademo.Utils;


import io.jsonwebtoken.*;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.Jwt;
import io.jsonwebtoken.security.Keys;

import javax.crypto.SecretKey;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;

public class JwtUtils {
    private static final String SECRET = "&/2yf5!6@$$&/2yf5!6@$$&/2yf5!6@$$";  // 给token加密的秘钥

    public static String createToken( Map<String, Object> claims) {
        // 1. 将 SECRET 转换成 Key 对象（更安全）
        SecretKey key = Keys.hmacShaKeyFor(SECRET.getBytes());
        // 3. 构建 JWT
        return Jwts.builder()
                .claims(claims)           // 一次性设置所有 Claims
                .issuedAt(new Date())    // 签发时间（iat）
                .expiration(new Date(System.currentTimeMillis() + 24 * 60 * 60 * 1000)) // 过期时间（exp）
                .signWith(key)            // 签名（自动选择算法，如 HS256）
                .compact();
    }

    public static Map<String, Object> parseToken(String token) {
        try {
            // 1. 将 SECRET 转换成 Key 对象
            SecretKey key = Keys.hmacShaKeyFor(SECRET.getBytes());
            // 2. 解析 JWT
            Jws<Claims> jws = Jwts.parser()
                    .verifyWith(key)  // 设置签名密钥
                    .build()          // 构建解析器
                    .parseSignedClaims(token); // 解析并验证签名

            // 3. 获取 Payload（即原来的 Body）
            return jws.getPayload();
        } catch (JwtException e) {
            System.out.println(e.getMessage()+"msg");
            throw new RuntimeException("Invalid JWT token", e);
        }
    }
}

```

#### 统一响应配置

在 `config/ResponseConfig.java` 文件中，配置统一响应：

```java
package com.example.javademo.Utils;


/**
 * @作者 江南一点雨
 * @公众号 江南一点雨
 * @微信号 a_java_boy
 * @GitHub https://github.com/lenve
 * @博客 http://wangsong.blog.csdn.net
 * @网站 http://www.javaboy.org
 * @时间 2019-09-20 8:39
 */
public class Response {
    private Integer status;
    private String msg;
    private Object data;

    public static Response build() {
        return new Response();
    }

    public static Response ok(String msg) {
        return new Response(200, msg, null);
    }

    public static Response ok(String msg, Object data) {
        return new Response(200, msg, data);
    }

    public static Response error(String msg) {
        return new Response(500, msg, null);
    }

    public static Response error(String msg, Object data) {
        return new Response(500, msg, data);
    }

    private Response() {
    }

    private Response(Integer status, String msg, Object data) {
        this.status = status;
        this.msg = msg;
        this.data = data;
    }

    public Integer getStatus() {
        return status;
    }

    public Response setStatus(Integer status) {
        this.status = status;
        return this;
    }

    public String getMsg() {
        return msg;
    }

    public Response setMsg(String msg) {
        this.msg = msg;
        return this;
    }

    public Object getData() {
        return data;
    }

    public Response setData(Object data) {
        this.data = data;
        return this;
    }
}

```

#### 用户实体

在 `entity/User.java` 文件中，定义用户实体：

```java
package com.example.javademo.Entity;


public class User {
    private String username;
    private String password;

    // Getter and Setter methods

    public String getUsername() {
        return username;
    }

    public String getPassword() {
        return password;
    }

}


```

#### 用户仓库

在 `repository/UserRepository.java` 文件中，定义用户仓库：

```java

```

#### 用户服务

在 `service/UserService.java` 文件中，定义用户服务接口：

```java

```

在 `service/UserServiceImpl.java` 文件中，实现用户服务：

```java

```

#### 用户控制器

在 `controller/UserController.java` 文件中，定义用户控制器：

```java

```