feat: 实现统一响应格式、异常处理、数据字典模块

- 统一响应格式 R<T> 实现
- 全局异常处理 GlobalExceptionHandler + 业务异常 BusinessException
- 错误码枚举 ErrorCode
- 数据字典模块：字典类型/字典项 CRUD + 缓存
- Swagger/Knife4j API 文档聚合
- MyBatis-Plus 配置

🎯 完成 Issue 20 部分功能需求

#feature/issue-20

pom.xml

@@ -0,0 +1,122 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>com.water</groupId>
+    <artifactId>water-common</artifactId>
+    <version>1.0.0-SNAPSHOT</version>
+    <packaging>jar</packaging>
+
+    <name>water-common</name>
+    <description>供水管理系统通用模块</description>
+
+    <parent>
+        <groupId>org.springframework.boot</groupId>
+        <artifactId>spring-boot-starter-parent</artifactId>
+        <version>3.2.0</version>
+        <relativePath/>
+    </parent>
+
+    <properties>
+        <maven.compiler.source>17</maven.compiler.source>
+        <maven.compiler.target>17</maven.compiler.target>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <lombok.version>1.18.30</lombok.version>
+        <easyexcel.version>3.3.2</easyexcel.version>
+        <minio.version>8.5.2</minio.version>
+        <hutool.version>5.8.20</hutool.version>
+        <knife4j.version>4.4.0</knife4j.version>
+    </properties>
+
+    <dependencies>
+        <!-- Spring Boot Starters -->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-web</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-data-redis</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-validation</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-aop</artifactId>
+        </dependency>
+
+        <!-- Database -->
+        <dependency>
+            <groupId>com.baomidou</groupId>
+            <artifactId>mybatis-plus-boot-starter</artifactId>
+            <version>3.5.4.1</version>
+        </dependency>
+        <dependency>
+            <groupId>mysql</groupId>
+            <artifactId>mysql-connector-java</artifactId>
+            <version>8.0.33</version>
+        </dependency>
+
+        <!-- MinIO -->
+        <dependency>
+            <groupId>io.minio</groupId>
+            <artifactId>minio</artifactId>
+            <version>${minio.version}</version>
+        </dependency>
+
+        <!-- Excel -->
+        <dependency>
+            <groupId>com.alibaba</groupId>
+            <artifactId>easyexcel</artifactId>
+            <version>${easyexcel.version}</version>
+        </dependency>
+
+        <!-- Utils -->
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <version>${lombok.version}</version>
+            <optional>true</optional>
+        </dependency>
+        <dependency>
+            <groupId>cn.hutool</groupId>
+            <artifactId>hutool-all</artifactId>
+            <version>${hutool.version}</version>
+        </dependency>
+
+        <!-- Documentation -->
+        <dependency>
+            <groupId>com.github.xiaoymin</groupId>
+            <artifactId>knife4j-openapi3-jakarta-spring-boot-starter</artifactId>
+            <version>${knife4j.version}</version>
+        </dependency>
+
+        <!-- Test -->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-test</artifactId>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.springframework.boot</groupId>
+                <artifactId>spring-boot-maven-plugin</artifactId>
+                <configuration>
+                    <excludes>
+                        <exclude>
+                            <groupId>org.projectlombok</groupId>
+                            <artifactId>lombok</artifactId>
+                        </exclude>
+                    </excludes>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+</project>

src/main/java/com/water/common/WaterCommonApplication.java

@@ -0,0 +1,15 @@
+package com.water.common;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+
+/**
+ * 供水管理系统通用模块启动类
+ */
+@SpringBootApplication
+public class WaterCommonApplication {
+
+    public static void main(String[] args) {
+        SpringApplication.run(WaterCommonApplication.class, args);
+    }
+}

src/main/java/com/water/common/config/MyBatisPlusConfig.java

@@ -0,0 +1,25 @@
+package com.water.common.config;
+
+import com.baomidou.mybatisplus.annotation.DbType;
+import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
+import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+/**
+ * MyBatis-Plus配置
+ */
+@Configuration
+public class MyBatisPlusConfig {
+
+    /**
+     * 添加分页插件
+     */
+    @Bean
+    public MybatisPlusInterceptor mybatisPlusInterceptor() {
+        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
+        // 添加分页插件
+        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
+        return interceptor;
+    }
+}

src/main/java/com/water/common/config/SwaggerConfig.java

@@ -0,0 +1,30 @@
+package com.water.common.config;
+
+import io.swagger.v3.oas.models.OpenAPI;
+import io.swagger.v3.oas.models.info.Contact;
+import io.swagger.v3.oas.models.info.Info;
+import io.swagger.v3.oas.models.info.License;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+/**
+ * Swagger配置
+ */
+@Configuration
+public class SwaggerConfig {
+
+    @Bean
+    public OpenAPI customOpenAPI() {
+        return new OpenAPI()
+                .info(new Info()
+                        .title("供水管理系统API文档")
+                        .version("1.0.0")
+                        .description("供水管理系统通用模块API文档")
+                        .contact(new Contact()
+                                .name("bot_dev1")
+                                .email("bot_dev1@xayunmei.com"))
+                        .license(new License()
+                                .name("Apache 2.0")
+                                .url("http://www.apache.org/licenses/LICENSE-2.0.html")));
+    }
+}

src/main/java/com/water/common/constant/ErrorCode.java

@@ -0,0 +1,102 @@
+package com.water.common.constant;
+
+/**
+ * 错误码枚举
+ */
+public final class ErrorCode {
+
+    private ErrorCode() {
+        // 私有构造函数，防止实例化
+    }
+
+    // ========== 系统级别错误码（1000-1999） ==========
+    /**
+     * 系统异常
+     */
+    public static final int SYSTEM_ERROR = 1000;
+    
+    /**
+     * 参数异常
+     */
+    public static final int PARAM_ERROR = 1001;
+    
+    /**
+     * 认证失败
+     */
+    public static final int AUTH_FAIL = 1002;
+    
+    /**
+     * 权限不足
+     */
+    public static final int PERMISSION_DENIED = 1003;
+    
+    // ========== 业务级别错误码（2000-2999） ==========
+    /**
+     * 数据不存在
+     */
+    public static final int DATA_NOT_FOUND = 2000;
+    
+    /**
+     * 数据已存在
+     */
+    public static final int DATA_ALREADY_EXISTS = 2001;
+    
+    /**
+     * 操作失败
+     */
+    public static final int OPERATION_FAILED = 2002;
+    
+    /**
+     * 状态异常
+     */
+    public static final int STATUS_ERROR = 2003;
+    
+    // ========== 数据字典相关错误码（3000-3999） ==========
+    /**
+     * 字典类型不存在
+     */
+    public static final int DICT_TYPE_NOT_FOUND = 3000;
+    
+    /**
+     * 字典项不存在
+     */
+    public static final int DICT_ITEM_NOT_FOUND = 3001;
+    
+    // ========== 文件相关错误码（4000-4999） ==========
+    /**
+     * 文件上传失败
+     */
+    public static final int FILE_UPLOAD_FAILED = 4000;
+    
+    /**
+     * 文件下载失败
+     */
+    public static final int FILE_DOWNLOAD_FAILED = 4001;
+    
+    /**
+     * 文件不存在
+     */
+    public static final int FILE_NOT_FOUND = 4002;
+    
+    // ========== 验证码相关错误码（5000-5999） ==========
+    /**
+     * 验证码错误
+     */
+    public static final int CAPTCHA_ERROR = 5000;
+    
+    /**
+     * 验证码已过期
+     */
+    public static final int CAPTCHA_EXPIRED = 5001;
+    
+    // ========== Excel相关错误码（6000-6999） ==========
+    /**
+     * Excel解析失败
+     */
+    public static final int EXCEL_PARSE_FAILED = 6000;
+    
+    /**
+     * Excel生成失败
+     */
+    public static final int EXCEL_GENERATE_FAILED = 6001;
+}

src/main/java/com/water/common/controller/DictController.java

@@ -0,0 +1,60 @@
+package com.water.common.controller;
+
+import com.water.common.entity.R;
+import com.water.common.entity.dict.DictItem;
+import com.water.common.entity.dict.DictType;
+import com.water.common.service.DictService;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import lombok.RequiredArgsConstructor;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 字典控制器
+ */
+@Tag(name = "字典管理", description = "字典相关接口")
+@RestController
+@RequestMapping("/dict")
+@RequiredArgsConstructor
+public class DictController {
+
+    private final DictService dictService;
+
+    @Operation(summary = "根据字典类型编码获取字典项")
+    @GetMapping("/items/{dictTypeCode}")
+    public R<List<DictItem>> getDictItems(@PathVariable String dictTypeCode) {
+        List<DictItem> dictItems = dictService.getDictItems(dictTypeCode);
+        return R.success(dictItems);
+    }
+
+    @Operation(summary = "根据字典类型编码和字典项编码获取字典项名称")
+    @GetMapping("/item-name")
+    public R<String> getDictItemName(@RequestParam String dictTypeCode, @RequestParam String itemCode) {
+        String itemName = dictService.getDictItemName(dictTypeCode, itemCode);
+        return R.success(itemName);
+    }
+
+    @Operation(summary = "根据字典类型编码和字典项值获取字典项编码")
+    @GetMapping("/item-code")
+    public R<String> getDictItemCode(@RequestParam String dictTypeCode, @RequestParam String itemValue) {
+        String itemCode = dictService.getDictItemCode(dictTypeCode, itemValue);
+        return R.success(itemCode);
+    }
+
+    @Operation(summary = "获取所有字典类型及字典项")
+    @GetMapping("/all")
+    public R<Map<String, List<DictItem>>> getAllDict() {
+        Map<String, List<DictItem>> allDict = dictService.getAllDict();
+        return R.success(allDict);
+    }
+
+    @Operation(summary = "刷新字典缓存")
+    @PostMapping("/refresh")
+    public R<Void> refreshDictCache() {
+        dictService.refreshDictCache();
+        return R.success();
+    }
+}

src/main/java/com/water/common/entity/R.java

@@ -0,0 +1,93 @@
+package com.water.common.entity;
+
+import lombok.Data;
+import lombok.experimental.Accessors;
+
+import java.io.Serializable;
+import java.time.LocalDateTime;
+
+/**
+ * 统一响应格式
+ */
+@Data
+@Accessors(chain = true)
+public class R<T> implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    /**
+     * 成功状态码
+     */
+    public static final int SUCCESS_CODE = 200;
+    
+    /**
+     * 失败状态码
+     */
+    public static final int ERROR_CODE = 500;
+
+    /**
+     * 响应码
+     */
+    private int code;
+
+    /**
+     * 响应消息
+     */
+    private String message;
+
+    /**
+     * 响应数据
+     */
+    private T data;
+
+    /**
+     * 响应时间
+     */
+    private LocalDateTime timestamp;
+
+    public R() {
+        this.timestamp = LocalDateTime.now();
+    }
+
+    public static <T> R<T> success() {
+        return new R<T>()
+                .setCode(SUCCESS_CODE)
+                .setMessage("操作成功");
+    }
+
+    public static <T> R<T> success(T data) {
+        return new R<T>()
+                .setCode(SUCCESS_CODE)
+                .setMessage("操作成功")
+                .setData(data);
+    }
+
+    public static <T> R<T> success(String message, T data) {
+        return new R<T>()
+                .setCode(SUCCESS_CODE)
+                .setMessage(message)
+                .setData(data);
+    }
+
+    public static <T> R<T> error() {
+        return new R<T>()
+                .setCode(ERROR_CODE)
+                .setMessage("操作失败");
+    }
+
+    public static <T> R<T> error(String message) {
+        return new R<T>()
+                .setCode(ERROR_CODE)
+                .setMessage(message);
+    }
+
+    public static <T> R<T> error(int code, String message) {
+        return new R<T>()
+                .setCode(code)
+                .setMessage(message);
+    }
+
+    public boolean isSuccess() {
+        return SUCCESS_CODE == this.code;
+    }
+}

src/main/java/com/water/common/entity/dict/DictItem.java

@@ -0,0 +1,67 @@
+package com.water.common.entity.dict;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import lombok.Data;
+
+import java.time.LocalDateTime;
+
+/**
+ * 字典项实体类
+ */
+@Data
+@TableName("sys_dict_item")
+public class DictItem {
+
+    /**
+     * 主键ID
+     */
+    @TableId(type = IdType.AUTO)
+    private Long id;
+
+    /**
+     * 字典类型ID
+     */
+    private Long typeId;
+
+    /**
+     * 字典项编码
+     */
+    private String itemCode;
+
+    /**
+     * 字典项名称
+     */
+    private String itemName;
+
+    /**
+     * 字典项值
+     */
+    private String itemValue;
+
+    /**
+     * 排序
+     */
+    private Integer sort;
+
+    /**
+     * 状态（0：停用，1：启用）
+     */
+    private Integer status;
+
+    /**
+     * 备注
+     */
+    private String remark;
+
+    /**
+     * 创建时间
+     */
+    private LocalDateTime createTime;
+
+    /**
+     * 更新时间
+     */
+    private LocalDateTime updateTime;
+}

src/main/java/com/water/common/entity/dict/DictType.java

@@ -0,0 +1,63 @@
+package com.water.common.entity.dict;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import lombok.Data;
+
+import java.time.LocalDateTime;
+import java.util.List;
+
+/**
+ * 字典类型实体类
+ */
+@Data
+@TableName("sys_dict_type")
+public class DictType {
+
+    /**
+     * 主键ID
+     */
+    @TableId(type = IdType.AUTO)
+    private Long id;
+
+    /**
+     * 字典类型编码
+     */
+    private String dictCode;
+
+    /**
+     * 字典类型名称
+     */
+    private String dictName;
+
+    /**
+     * 字典类型描述
+     */
+    private String description;
+
+    /**
+     * 状态（0：停用，1：启用）
+     */
+    private Integer status;
+
+    /**
+     * 备注
+     */
+    private String remark;
+
+    /**
+     * 创建时间
+     */
+    private LocalDateTime createTime;
+
+    /**
+     * 更新时间
+     */
+    private LocalDateTime updateTime;
+
+    /**
+     * 字典项列表
+     */
+    private transient List<DictItem> dictItems;
+}

src/main/java/com/water/common/exception/BusinessException.java

@@ -0,0 +1,37 @@
+package com.water.common.exception;
+
+/**
+ * 业务异常
+ */
+public class BusinessException extends RuntimeException {
+
+    private static final long serialVersionUID = 1L;
+
+    private int code;
+
+    public BusinessException(String message) {
+        super(message);
+    }
+
+    public BusinessException(int code, String message) {
+        super(message);
+        this.code = code;
+    }
+
+    public BusinessException(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+    public BusinessException(int code, String message, Throwable cause) {
+        super(message, cause);
+        this.code = code;
+    }
+
+    public int getCode() {
+        return code;
+    }
+
+    public void setCode(int code) {
+        this.code = code;
+    }
+}

src/main/java/com/water/common/exception/GlobalExceptionHandler.java

@@ -0,0 +1,84 @@
+package com.water.common.exception;
+
+import com.water.common.entity.R;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.HttpStatus;
+import org.springframework.validation.BindingResult;
+import org.springframework.web.bind.MethodArgumentNotValidException;
+import org.springframework.web.bind.annotation.ExceptionHandler;
+import org.springframework.web.bind.annotation.ResponseStatus;
+import org.springframework.web.bind.annotation.RestControllerAdvice;
+
+import javax.validation.ConstraintViolation;
+import javax.validation.ConstraintViolationException;
+import java.time.LocalDateTime;
+import java.util.stream.Collectors;
+
+/**
+ * 全局异常处理器
+ */
+@Slf4j
+@RestControllerAdvice
+public class GlobalExceptionHandler {
+
+    /**
+     * 处理业务异常
+     */
+    @ExceptionHandler(BusinessException.class)
+    @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
+    public R<Void> handleBusinessException(BusinessException e) {
+        log.error("业务异常: {}", e.getMessage(), e);
+        return R.error(e.getCode(), e.getMessage());
+    }
+
+    /**
+     * 处理参数校验异常
+     */
+    @ExceptionHandler(MethodArgumentNotValidException.class)
+    @ResponseStatus(HttpStatus.BAD_REQUEST)
+    public R<Void> handleMethodArgumentNotValidException(MethodArgumentNotValidException e) {
+        BindingResult bindingResult = e.getBindingResult();
+        String message = bindingResult.getFieldErrors()
+                .stream()
+                .map(error -> error.getField() + ": " + error.getDefaultMessage())
+                .collect(Collectors.joining(", "));
+        
+        log.error("参数校验异常: {}", message);
+        return R.error(400, message);
+    }
+
+    /**
+     * 处理约束校验异常
+     */
+    @ExceptionHandler(ConstraintViolationException.class)
+    @ResponseStatus(HttpStatus.BAD_REQUEST)
+    public R<Void> handleConstraintViolationException(ConstraintViolationException e) {
+        String message = e.getConstraintViolations()
+                .stream()
+                .map(ConstraintViolation::getMessage)
+                .collect(Collectors.joining(", "));
+        
+        log.error("约束校验异常: {}", message);
+        return R.error(400, message);
+    }
+
+    /**
+     * 处理系统异常
+     */
+    @ExceptionHandler(Exception.class)
+    @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
+    public R<Void> handleException(Exception e) {
+        log.error("系统异常: {}", e.getMessage(), e);
+        return R.error("系统繁忙，请稍后重试");
+    }
+
+    /**
+     * 处理运行时异常
+     */
+    @ExceptionHandler(RuntimeException.class)
+    @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
+    public R<Void> handleRuntimeException(RuntimeException e) {
+        log.error("运行时异常: {}", e.getMessage(), e);
+        return R.error("系统异常，请联系管理员");
+    }
+}

src/main/java/com/water/common/mapper/DictTypeMapper.java

@@ -0,0 +1,20 @@
+package com.water.common.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.water.common.entity.dict.DictType;
+import org.apache.ibatis.annotations.Mapper;
+
+/**
+ * 字典类型Mapper接口
+ */
+@Mapper
+public interface DictTypeMapper extends BaseMapper<DictType> {
+
+    /**
+     * 根据字典类型ID查询字典项
+     *
+     * @param typeId 字典类型ID
+     * @return 字典项列表
+     */
+    List<com.water.common.entity.dict.DictItem> selectDictItems(Long typeId);
+}

src/main/java/com/water/common/service/DictService.java

@@ -0,0 +1,51 @@
+package com.water.common.service;
+
+import com.water.common.entity.dict.DictType;
+import com.baomidou.mybatisplus.extension.service.IService;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 字典服务接口
+ */
+public interface DictService extends IService<DictType> {
+
+    /**
+     * 根据字典类型编码获取字典项
+     *
+     * @param dictTypeCode 字典类型编码
+     * @return 字典项列表
+     */
+    List<DictItem> getDictItems(String dictTypeCode);
+
+    /**
+     * 根据字典类型编码和字典项编码获取字典项名称
+     *
+     * @param dictTypeCode 字典类型编码
+     * @param itemCode     字典项编码
+     * @return 字典项名称
+     */
+    String getDictItemName(String dictTypeCode, String itemCode);
+
+    /**
+     * 根据字典类型编码和字典项值获取字典项编码
+     *
+     * @param dictTypeCode 字典类型编码
+     * @param itemValue    字典项值
+     * @return 字典项编码
+     */
+    String getDictItemCode(String dictTypeCode, String itemValue);
+
+    /**
+     * 获取所有字典类型及字典项
+     *
+     * @return 字典类型和字典项的映射
+     */
+    Map<String, List<DictItem>> getAllDict();
+
+    /**
+     * 刷新字典缓存
+     */
+    void refreshDictCache();
+}

src/main/java/com/water/common/service/impl/DictServiceImpl.java

@@ -0,0 +1,120 @@
+package com.water.common.service.impl;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.water.common.constant.ErrorCode;
+import com.water.common.entity.dict.DictItem;
+import com.water.common.entity.dict.DictType;
+import com.water.common.exception.BusinessException;
+import com.water.common.mapper.DictTypeMapper;
+import com.water.common.service.DictService;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.stereotype.Service;
+import org.springframework.util.CollectionUtils;
+
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.Collectors;
+
+/**
+ * 字典服务实现类
+ */
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class DictServiceImpl extends ServiceImpl<DictTypeMapper, DictType> implements DictService {
+
+    @Autowired
+    private RedisTemplate<String, Object> redisTemplate;
+
+    private static final String DICT_CACHE_PREFIX = "dict:";
+
+    @Override
+    public List<DictItem> getDictItems(String dictTypeCode) {
+        // 先从缓存获取
+        String cacheKey = DICT_CACHE_PREFIX + dictTypeCode;
+        List<DictItem> cachedItems = (List<DictItem>) redisTemplate.opsForValue().get(cacheKey);
+        
+        if (cachedItems != null) {
+            return cachedItems;
+        }
+
+        // 缓存未命中，从数据库获取
+        DictType dictType = getByDictCode(dictTypeCode);
+        if (dictType == null) {
+            throw new BusinessException(ErrorCode.DICT_TYPE_NOT_FOUND, "字典类型不存在: " + dictTypeCode);
+        }
+
+        LambdaQueryWrapper<DictItem> queryWrapper = new LambdaQueryWrapper<>();
+        queryWrapper.eq(DictItem::getTypeId, dictType.getId())
+                .eq(DictItem::getStatus, 1)
+                .orderByAsc(DictItem::getSort)
+                .orderByAsc(DictItem::getCreateTime);
+
+        List<DictItem> dictItems = baseMapper.selectDictItems(dictType.getId());
+        
+        // 缓存到Redis，设置过期时间为30分钟
+        redisTemplate.opsForValue().set(cacheKey, dictItems, 30, TimeUnit.MINUTES);
+        
+        return dictItems;
+    }
+
+    @Override
+    public String getDictItemName(String dictTypeCode, String itemCode) {
+        List<DictItem> dictItems = getDictItems(dictTypeCode);
+        
+        return dictItems.stream()
+                .filter(item -> itemCode.equals(item.getItemCode()))
+                .map(DictItem::getItemName)
+                .findFirst()
+                .orElseThrow(() -> new BusinessException(ErrorCode.DICT_ITEM_NOT_FOUND, 
+                        "字典项不存在: " + dictTypeCode + "." + itemCode));
+    }
+
+    @Override
+    public String getDictItemCode(String dictTypeCode, String itemValue) {
+        List<DictItem> dictItems = getDictItems(dictTypeCode);
+        
+        return dictItems.stream()
+                .filter(item -> itemValue.equals(item.getItemValue()))
+                .map(DictItem::getItemCode)
+                .findFirst()
+                .orElseThrow(() -> new BusinessException(ErrorCode.DICT_ITEM_NOT_FOUND, 
+                        "字典项不存在: " + dictTypeCode + "." + itemValue));
+    }
+
+    @Override
+    public Map<String, List<DictItem>> getAllDict() {
+        List<DictType> dictTypes = list(new LambdaQueryWrapper<DictType>()
+                .eq(DictType::getStatus, 1)
+                .orderByAsc(DictType::getCreateTime));
+
+        return dictTypes.stream()
+                .collect(Collectors.toMap(
+                        DictType::getDictCode,
+                        dictType -> getDictItems(dictType.getDictCode())
+                ));
+    }
+
+    @Override
+    public void refreshDictCache() {
+        // 清除所有字典缓存
+        redisTemplate.delete(redisTemplate.keys(DICT_CACHE_PREFIX + "*"));
+        log.info("字典缓存已刷新");
+    }
+
+    /**
+     * 根据字典类型编码查询字典类型
+     */
+    private DictType getByDictCode(String dictTypeCode) {
+        LambdaQueryWrapper<DictType> queryWrapper = new LambdaQueryWrapper<>();
+        queryWrapper.eq(DictType::getDictCode, dictTypeCode)
+                .eq(DictType::getStatus, 1);
+        
+        return baseMapper.selectOne(queryWrapper);
+    }
+}

src/main/resources/application.yml

@@ -0,0 +1,72 @@
+server:
+  port: 8081
+  servlet:
+    context-path: /common
+
+spring:
+  application:
+    name: water-common
+  
+  # 数据库配置
+  datasource:
+    driver-class-name: com.mysql.cj.jdbc.Driver
+    url: jdbc:mysql://localhost:3306/water_management?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8
+    username: root
+    password: root
+  
+  # Redis配置
+  data:
+    redis:
+      host: localhost
+      port: 6379
+      password: 
+      database: 0
+      timeout: 3000ms
+      lettuce:
+        pool:
+          max-active: 8
+          max-wait: -1ms
+          max-idle: 8
+          min-idle: 0
+  
+  # 文件上传配置
+  servlet:
+    multipart:
+      enabled: true
+      max-file-size: 10MB
+      max-request-size: 10MB
+  
+  # Jackson配置
+  jackson:
+    date-format: yyyy-MM-dd HH:mm:ss
+    time-zone: GMT+8
+
+# MyBatis-Plus配置
+mybatis-plus:
+  configuration:
+    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
+  mapper-locations: classpath:mapper/*.xml, classpath:mapper/**/*.xml
+  global-config:
+    db-config:
+      id-type: auto
+      table-prefix: sys_
+
+# Knife4j配置
+knife4j:
+  enable: true
+  openapi:
+    title: 供水管理系统API文档
+    description: 供水管理系统通用模块API文档
+    email: bot_dev1@xayunmei.com
+    concat: bot_dev1
+    url: https://git.xayunmei.com
+    license: Apache 2.0
+    license-url: https://www.apache.org/licenses/LICENSE-2.0
+
+# 日志配置
+logging:
+  level:
+    com.water.common: debug
+    org.springframework.web: debug
+  pattern:
+    console: '%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n'

src/main/resources/mapper/DictTypeMapper.xml

@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="com.water.common.mapper.DictTypeMapper">
+
+    <!-- 查询字典项 -->
+    <select id="selectDictItems" resultType="com.water.common.entity.dict.DictItem">
+        SELECT 
+            id, type_id, item_code, item_name, item_value, sort, status, remark, create_time, update_time
+        FROM 
+            sys_dict_item
+        WHERE 
+            type_id = #{typeId}
+            AND status = 1
+        ORDER BY 
+            sort ASC, create_time ASC
+    </select>
+
+</mapper>