feat: 实现水利行业数据治理功能

- 添加标准字段映射(LL流量/YL压力/SW水位/ZD浊度)
- 实现单位转换功能(支持多种水利单位)
- 数据标准化处理器和清洗规则
- 完整的API接口和数据质量检查
- 单元测试和集成测试覆盖
- Spring Boot应用配置和文档

开发Issue #44: [数据治理] 数据标准化+格式转换

water-management-system/README.md

+# 水利行业数据治理系统
+
+## 项目简介
+
+本系统专门为水利行业提供数据标准化、格式转换和质量控制功能，支持多种水利标准字段映射和单位自动转换。
+
+## 功能特性
+
+### 🎯 数据标准化
+- **字段映射**: 支持LL流量、YL压力、SW水位、ZD浊度等水利标准字段
+- **数据清洗**: 自动识别和转换各种数据格式
+- **空值处理**: 智能处理缺失数据
+
+### 🔄 单位转换
+- **流量单位**: m³/s、m³/min、m³/h、L/s、L/min、L/h等
+- **压力单位**: MPa、kPa、Pa、bar、kgf/cm²等
+- **水位单位**: m、cm、mm、km等
+- **浊度单位**: NTU、FTU、mg/L等
+
+### 📊 数据质量检查
+- **完整性检查**: 检测空值比例
+- **有效性验证**: 数据格式和数值范围验证
+- **质量评分**: 自动生成数据质量报告
+
+### 🛠️ API接口
+- RESTful API设计
+- 批量数据处理
+- 实时质量控制
+
+## 技术栈
+
+- **语言**: Java 8+
+- **框架**: Spring Boot 3.2.0
+- **构建工具**: Maven
+- **测试框架**: JUnit 5、Mockito
+- **文档**: Swagger/OpenAPI
+
+## 快速开始
+
+### 环境要求
+- Java 8+
+- Maven 3.6+
+- 可选：PostgreSQL 12+（生产环境）
+
+### 运行应用
+
+1. **克隆项目**
+```bash
+git clone http://git.xayunmei.com/bot_ym/water-management-system.git
+cd water-management-system
+```
+
+2. **创建分支** (如果还没有)
+```bash
+git checkout -b feature/issue-44
+```
+
+3. **构建项目**
+```bash
+mvn clean install
+```
+
+4. **运行应用**
+```bash
+mvn spring-boot:run
+```
+
+5. **访问API**
+   - Swagger UI: http://localhost:8080/swagger-ui.html
+   - 应用主页: http://localhost:8080/
+
+## API文档
+
+### 核心接口
+
+#### 1. 获取标准字段映射
+```
+GET /api/data-governance/standards/fields
+```
+
+#### 2. 字段名称标准化
+```
+POST /api/data-governance/standards/normalize-field
+Content-Type: application/json
+
+{
+  "fieldName": "自定义流量字段"
+}
+```
+
+#### 3. 单位转换
+```
+POST /api/data-governance/units/convert
+Content-Type: application/json
+
+{
+  "value": 1000,
+  "fromUnit": "m³/h",
+  "toUnit": "m³/s"
+}
+```
+
+#### 4. 数据标准化
+```
+POST /api/data-governance/normalize
+Content-Type: application/json
+
+{
+  "流量": "1000",
+  "压力": "200",
+  "水位": "150.5",
+  "浊度": "10.5"
+}
+```
+
+#### 5. 数据质量检查
+```
+POST /api/data-governance/quality-check
+Content-Type: application/json
+
+{
+  "流量": "1000",
+  "压力": "200",
+  "水位": "150.5",
+  "浊度": "10.5"
+}
+```
+
+## 数据模型
+
+### 标准字段映射表
+
+| 字段类型 | 标准代码 | 名称 | 单位 | 描述 |
+|---------|---------|------|------|------|
+| 流量 | LL001 | 流量 | m³/s | 水利管道流量 |
+| 压力 | YL001 | 压力 | MPa | 管道压力监测 |
+| 水位 | SW001 | 水位 | m | 水库/河道水位 |
+| 浊度 | ZD001 | 浊度 | NTU | 水体浊度检测 |
+
+### 支持的单位转换
+
+#### 流量单位
+- 1 m³/s = 60 m³/min = 3600 m³/h
+- 1 m³/s = 1000 L/s = 60000 L/min = 3600000 L/h
+
+#### 压力单位
+- 1 MPa = 1000 kPa = 1000000 Pa
+- 1 MPa = 10 bar = 10.1972 kgf/cm²
+
+#### 水位单位
+- 1 m = 100 cm = 1000 mm
+- 1 m = 0.001 km
+
+## 使用示例
+
+### 数据标准化示例
+
+```java
+// 原始数据
+Map<String, Object> rawData = new HashMap<>();
+rawData.put("自定义流量字段", "1000");
+rawData.put("压力表读数", "200");
+rawData.put("液位", "150.5");
+rawData.put("浑浊度", "10.5");
+
+// 标准化后
+Map<String, Object> normalizedData = DataNormalizer.normalizeData(rawData);
+// 结果:
+// {
+//   "LL001": 1000.0,
+//   "YL001": 200.0,
+//   "SW001": 150.5,
+//   "ZD001": 10.5
+// }
+```
+
+### 单位转换示例
+
+```java
+// 流量单位转换
+double flowValue = UnitConverter.convert(1000, "m³/h", "m³/s");
+// 结果: 1000 / 3600 = 0.2778
+
+// 压力单位转换
+double pressureValue = UnitConverter.convert(1000, "kPa", "MPa");
+// 结果: 1000 / 1000 = 1.0
+```
+
+### 数据质量检查示例
+
+```java
+Map<String, Object> qualityCheck = DataNormalizer.checkDataQuality(rawData);
+// 结果:
+// {
+//   "totalFields": 4,
+//   "nullFields": 0,
+//   "invalidFields": 0,
+//   "validFields": 4,
+//   "completenessRate": 100.0,
+//   "validityRate": 100.0
+// }
+```
+
+## 测试
+
+### 运行单元测试
+```bash
+mvn test
+```
+
+### 运行集成测试
+```bash
+mvn verify
+```
+
+### 测试覆盖率报告
+```bash
+mvn clean jacoco:report
+```
+报告位置: `target/site/jacoco/index.html`
+
+## 部署
+
+### 开发环境
+使用H2内存数据库，适合开发和测试。
+
+### 生产环境
+1. 修改`application.yml`中的数据库配置
+2. 配置数据库连接池
+3. 设置日志级别和监控
+4. 配置HTTPS和防火墙
+
+### Docker部署
+```bash
+# 构建镜像
+docker build -t water-management-system .
+
+# 运行容器
+docker run -p 8080:8080 water-management-system
+```
+
+## 项目结构
+
+```
+src/main/java/com/waterquality/
+├── data/
+│   ├── StandardsMapping.java     # 标准字段映射
+│   ├── UnitConverter.java        # 单位转换器
+│   └── DataNormalizer.java       # 数据标准化处理器
+├── controller/
+│   └── DataGovernanceController.java
+│       └── DataGovernanceControllerTest.java
+├── service/
+│   └── DataGovernanceService.java
+│       └── DataGovernanceServiceTest.java
+└── WaterQualityApplication.java
+```
+
+## 配置说明
+
+### application.yml
+```yaml
+server:
+  port: 8080
+
+spring:
+  datasource:
+    url: jdbc:h2:mem:testdb
+    driver-class-name: org.h2.Driver
+    username: sa
+    password: password
+  
+  h2:
+    console:
+      enabled: true
+  
+  jpa:
+    hibernate:
+      ddl-auto: create-drop
+    show-sql: false
+    properties:
+      hibernate:
+        format_sql: true
+```
+
+## 贡献指南
+
+1. Fork项目
+2. 创建功能分支
+3. 提交更改
+4. 推送到分支
+5. 创建Pull Request
+
+## 许可证
+
+本项目采用MIT许可证。
+
+## 联系方式
+
+如有问题请提交Issue或联系开发团队。

water-management-system/pom.xml

+<?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.waterquality</groupId>
+    <artifactId>water-management-system</artifactId>
+    <version>1.0.0</version>
+    <packaging>jar</packaging>
+
+    <name>Water Management System</name>
+    <description>水利行业数据治理系统</description>
+
+    <properties>
+        <maven.compiler.source>8</maven.compiler.source>
+        <maven.compiler.target>8</maven.compiler.target>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <spring.boot.version>3.2.0</spring.boot.version>
+        <junit.version>5.10.2</junit.version>
+        <mockito.version>5.8.0</mockito.version>
+    </properties>
+
+    <parent>
+        <groupId>org.springframework.boot</groupId>
+        <artifactId>spring-boot-starter-parent</artifactId>
+        <version>${spring.boot.version}</version>
+        <relativePath/>
+    </parent>
+
+    <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-jpa</artifactId>
+        </dependency>
+        
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-validation</artifactId>
+        </dependency>
+
+        <!-- H2 Database -->
+        <dependency>
+            <groupId>com.h2database</groupId>
+            <artifactId>h2</artifactId>
+            <scope>runtime</scope>
+        </dependency>
+
+        <!-- Testing -->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-test</artifactId>
+            <scope>test</scope>
+        </dependency>
+        
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter</artifactId>
+            <version>${junit.version}</version>
+            <scope>test</scope>
+        </dependency>
+        
+        <dependency>
+            <groupId>org.mockito</groupId>
+            <artifactId>mockito-core</artifactId>
+            <version>${mockito.version}</version>
+            <scope>test</scope>
+        </dependency>
+
+        <!-- Documentation -->
+        <dependency>
+            <groupId>org.springdoc</groupId>
+            <artifactId>springdoc-openapi-starter-webmvc-ui</artifactId>
+            <version>2.3.0</version>
+        </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>
+            
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <version>3.2.5</version>
+            </plugin>
+        </plugins>
+    </build>
+</project>

water-management-system/src/main/java/com/waterquality/WaterQualityApplication.java

+package com.waterquality;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+
+/**
+ * 水质管理应用程序主类
+ */
+@SpringBootApplication
+public class WaterQualityApplication {
+    
+    public static void main(String[] args) {
+        SpringApplication.run(WaterQualityApplication.class, args);
+    }
+}

water-management-system/src/main/java/com/waterquality/controller/DataGovernanceController.java

+package com.waterquality.controller;
+
+import com.waterquality.data.DataNormalizer;
+import com.waterquality.data.StandardsMapping;
+import com.waterquality.data.UnitConverter;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * 数据治理控制器
+ * 提供数据标准化、格式转换、质量检查等功能
+ */
+@RestController
+@RequestMapping("/api/data-governance")
+@CrossOrigin(origins = "*")
+public class DataGovernanceController {
+    
+    /**
+     * 获取标准字段映射
+     */
+    @GetMapping("/standards/fields")
+    public ResponseEntity<Map<String, Object>> getStandardFields() {
+        Map<String, Object> response = new HashMap<>();
+        response.put("success", true);
+        response.put("data", StandardsMapping.getAllStandardFields());
+        response.put("message", "标准字段映射获取成功");
+        
+        return ResponseEntity.ok(response);
+    }
+    
+    /**
+     * 字段名称标准化
+     */
+    @PostMapping("/standards/normalize-field")
+    public ResponseEntity<Map<String, Object>> normalizeFieldName(@RequestBody Map<String, String> request) {
+        String fieldName = request.get("fieldName");
+        
+        if (fieldName == null || fieldName.trim().isEmpty()) {
+            Map<String, Object> response = new HashMap<>();
+            response.put("success", false);
+            response.put("message", "字段名称不能为空");
+            return ResponseEntity.badRequest().body(response);
+        }
+        
+        String standardFieldName = StandardsMapping.mapToStandardField(fieldName);
+        
+        Map<String, Object> response = new HashMap<>();
+        response.put("success", true);
+        response.put("originalField", fieldName);
+        response.put("standardField", standardFieldName);
+        response.put("message", "字段名称标准化成功");
+        
+        return ResponseEntity.ok(response);
+    }
+    
+    /**
+     * 单位转换
+     */
+    @PostMapping("/units/convert")
+    public ResponseEntity<Map<String, Object>> convertUnit(@RequestBody Map<String, Object> request) {
+        try {
+            double value = ((Number) request.get("value")).doubleValue();
+            String fromUnit = (String) request.get("fromUnit");
+            String toUnit = (String) request.get("toUnit");
+            
+            if (fromUnit == null || toUnit == null) {
+                throw new IllegalArgumentException("单位参数不能为空");
+            }
+            
+            double convertedValue = UnitConverter.convert(value, fromUnit, toUnit);
+            String unitCode = UnitConverter.getUnitCode(toUnit);
+            
+            Map<String, Object> response = new HashMap<>();
+            response.put("success", true);
+            response.put("originalValue", value);
+            response.put("fromUnit", fromUnit);
+            response.put("convertedValue", convertedValue);
+            response.put("toUnit", toUnit);
+            response.put("unitCode", unitCode);
+            response.put("message", "单位转换成功");
+            
+            return ResponseEntity.ok(response);
+            
+        } catch (Exception e) {
+            Map<String, Object> response = new HashMap<>();
+            response.put("success", false);
+            response.put("message", "单位转换失败: " + e.getMessage());
+            return ResponseEntity.badRequest().body(response);
+        }
+    }
+    
+    /**
+     * 获取支持的单位列表
+     */
+    @GetMapping("/units")
+    public ResponseEntity<Map<String, Object>> getSupportedUnits() {
+        Map<String, Object> response = new HashMap<>();
+        response.put("success", true);
+        response.put("data", UnitConverter.getSupportedUnits());
+        response.put("message", "单位列表获取成功");
+        
+        return ResponseEntity.ok(response);
+    }
+    
+    /**
+     * 数据标准化
+     */
+    @PostMapping("/normalize")
+    public ResponseEntity<Map<String, Object>> normalizeData(@RequestBody Map<String, Object> data) {
+        try {
+            Map<String, Object> normalizedData = DataNormalizer.normalizeData(data);
+            Map<String, Object> qualityCheck = DataNormalizer.checkDataQuality(normalizedData);
+            
+            Map<String, Object> response = new HashMap<>();
+            response.put("success", true);
+            response.put("originalData", data);
+            response.put("normalizedData", normalizedData);
+            response.put("qualityCheck", qualityCheck);
+            response.put("message", "数据标准化完成");
+            
+            return ResponseEntity.ok(response);
+            
+        } catch (Exception e) {
+            Map<String, Object> response = new HashMap<>();
+            response.put("success", false);
+            response.put("message", "数据标准化失败: " + e.getMessage());
+            return ResponseEntity.badRequest().body(response);
+        }
+    }
+    
+    /**
+     * 数据质量检查
+     */
+    @PostMapping("/quality-check")
+    public ResponseEntity<Map<String, Object>> checkDataQuality(@RequestBody Map<String, Object> data) {
+        try {
+            Map<String, Object> qualityCheck = DataNormalizer.checkDataQuality(data);
+            
+            Map<String, Object> response = new HashMap<>();
+            response.put("success", true);
+            response.put("data", data);
+            response.put("qualityCheck", qualityCheck);
+            response.put("message", "数据质量检查完成");
+            
+            return ResponseEntity.ok(response);
+            
+        } catch (Exception e) {
+            Map<String, Object> response = new HashMap<>();
+            response.put("success", false);
+            response.put("message", "数据质量检查失败: " + e.getMessage());
+            return ResponseEntity.badRequest().body(response);
+        }
+    }
+    
+    /**
+     * 获取标准单位
+     */
+    @GetMapping("/units/standard/{field}")
+    public ResponseEntity<Map<String, Object>> getStandardUnit(@PathVariable String field) {
+        try {
+            String standardUnit = UnitConverter.getStandardUnit(field);
+            String unitCode = UnitConverter.getUnitCode(standardUnit);
+            
+            Map<String, Object> response = new HashMap<>();
+            response.put("success", true);
+            response.put("field", field);
+            response.put("standardUnit", standardUnit);
+            response.put("unitCode", unitCode);
+            response.put("message", "标准单位获取成功");
+            
+            return ResponseEntity.ok(response);
+            
+        } catch (Exception e) {
+            Map<String, Object> response = new HashMap<>();
+            response.put("success", false);
+            response.put("message", "标准单位获取失败: " + e.getMessage());
+            return ResponseEntity.badRequest().body(response);
+        }
+    }
+}

water-management-system/src/main/java/com/waterquality/controller/DataGovernanceControllerTest.java

+package com.waterquality.controller;
+
+import com.waterquality.service.DataGovernanceService;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
+import org.springframework.boot.test.mock.mockito.MockBean;
+import org.springframework.test.web.servlet.MockMvc;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.when;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;
+
+/**
+ * 数据治理控制器测试
+ */
+@WebMvcTest(DataGovernanceController.class)
+public class DataGovernanceControllerTest {
+    
+    @Autowired
+    private MockMvc mockMvc;
+    
+    @MockBean
+    private DataGovernanceService dataGovernanceService;
+    
+    private Map<String, Object> testData;
+    private Map<String, Object> conversionRules;
+    
+    @BeforeEach
+    void setUp() {
+        // 测试数据
+        testData = new HashMap<>();
+        testData.put("流量", "1000");
+        testData.put("压力", "200");
+        testData.put("水位", "150.5");
+        testData.put("浊度", "10.5");
+        
+        // 转换规则
+        conversionRules = new HashMap<>();
+        Map<String, Map<String, String>> unitConversions = new HashMap<>();
+        Map<String, String> flowConversion = new HashMap<>();
+        flowConversion.put("fromUnit", "m³/h");
+        flowConversion.put("toUnit", "m³/s");
+        unitConversions.put("流量", flowConversion);
+        conversionRules.put("unitConversions", unitConversions);
+    }
+    
+    @Test
+    void testGetStandardFields() throws Exception {
+        Map<String, Object> fields = new HashMap<>();
+        Map<String, Object> flowField = new HashMap<>();
+        flowField.put("standard", "LL");
+        flowField.put("name", "流量");
+        flowField.put("unit", "m³/s");
+        fields.put("flow", flowField);
+        
+        when(dataGovernanceService.getStandardFields()).thenReturn(fields);
+        
+        mockMvc.perform(get("/api/data-governance/standards/fields"))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.success").value(true))
+                .andExpect(jsonPath("$.data.flow.standard").value("LL"));
+    }
+    
+    @Test
+    void testNormalizeFieldName() throws Exception {
+        Map<String, Object> response = new HashMap<>();
+        response.put("success", true);
+        response.put("originalField", "自定义流量字段");
+        response.put("standardField", "LL001");
+        
+        when(dataGovernanceService.normalizeFieldName(any())).thenReturn(response);
+        
+        mockMvc.perform(post("/api/data-governance/standards/normalize-field")
+                .contentType("application/json")
+                .content("{\"fieldName\": \"自定义流量字段\"}"))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.success").value(true))
+                .andExpect(jsonPath("$.originalField").value("自定义流量字段"))
+                .andExpect(jsonPath("$.standardField").value("LL001"));
+    }
+    
+    @Test
+    void testNormalizeFieldNameEmpty() throws Exception {
+        mockMvc.perform(post("/api/data-governance/standards/normalize-field")
+                .contentType("application/json")
+                .content("{\"fieldName\": \"\"}"))
+                .andExpect(status().isBadRequest())
+                .andExpect(jsonPath("$.success").value(false));
+    }
+    
+    @Test
+    void testConvertUnit() throws Exception {
+        Map<String, Object> response = new HashMap<>();
+        response.put("success", true);
+        response.put("originalValue", 1000.0);
+        response.put("fromUnit", "m³/h");
+        response.put("convertedValue", 1000.0 / 3600.0);
+        response.put("toUnit", "m³/s");
+        response.put("unitCode", "FLOW001");
+        
+        when(dataGovernanceService.convertUnit(any())).thenReturn(response);
+        
+        mockMvc.perform(post("/api/data-governance/units/convert")
+                .contentType("application/json")
+                .content("{\"value\": 1000, \"fromUnit\": \"m³/h\", \"toUnit\": \"m³/s\"}"))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.success").value(true))
+                .andExpect(jsonPath("$.originalValue").value(1000.0))
+                .andExpect(jsonPath("$.fromUnit").value("m³/h"))
+                .andExpect(jsonPath("$.toUnit").value("m³/s"));
+    }
+    
+    @Test
+    void testConvertUnitInvalid() throws Exception {
+        mockMvc.perform(post("/api/data-governance/units/convert")
+                .contentType("application/json")
+                .content("{\"value\": 1000, \"fromUnit\": \"invalid\", \"toUnit\": \"m³/s\"}"))
+                .andExpect(status().isBadRequest())
+                .andExpect(jsonPath("$.success").value(false));
+    }
+    
+    @Test
+    void testGetSupportedUnits() throws Exception {
+        Map<String, String> units = new HashMap<>();
+        units.put("m³/s", "立方米/秒");
+        units.put("MPa", "兆帕");
+        
+        when(dataGovernanceService.getSupportedUnits()).thenReturn(units);
+        
+        mockMvc.perform(get("/api/data-governance/units"))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.success").value(true))
+                .andExpect(jsonPath("$.data.m³/s").value("立方米/秒"));
+    }
+    
+    @Test
+    void testNormalizeData() throws Exception {
+        Map<String, Object> normalizedData = new HashMap<>();
+        normalizedData.put("LL001", 1000.0);
+        normalizedData.put("YL001", 200.0);
+        
+        Map<String, Object> qualityCheck = new HashMap<>();
+        qualityCheck.put("totalFields", 2);
+        qualityCheck.put("validFields", 2);
+        qualityCheck.put("completenessRate", 100.0);
+        
+        Map<String, Object> response = new HashMap<>();
+        response.put("success", true);
+        response.put("normalizedData", normalizedData);
+        response.put("qualityCheck", qualityCheck);
+        
+        when(dataGovernanceService.normalizeData(any())).thenReturn(response);
+        
+        mockMvc.perform(post("/api/data-governance/normalize")
+                .contentType("application/json")
+                .content("{\"流量\": \"1000\", \"压力\": \"200\"}"))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.success").value(true))
+                .andExpect(jsonPath("$.normalizedData.LL001").value(1000.0));
+    }
+    
+    @Test
+    void testCheckDataQuality() throws Exception {
+        Map<String, Object> qualityCheck = new HashMap<>();
+        qualityCheck.put("totalFields", 2);
+        qualityCheck.put("validFields", 2);
+        qualityCheck.put("completenessRate", 100.0);
+        qualityCheck.put("validityRate", 100.0);
+        
+        Map<String, Object> response = new HashMap<>();
+        response.put("success", true);
+        response.put("qualityCheck", qualityCheck);
+        
+        when(dataGovernanceService.checkDataQuality(any())).thenReturn(response);
+        
+        mockMvc.perform(post("/api/data-governance/quality-check")
+                .contentType("application/json")
+                .content("{\"流量\": \"1000\", \"压力\": \"200\"}"))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.success").value(true))
+                .andExpect(jsonPath("$.qualityCheck.totalFields").value(2));
+    }
+    
+    @Test
+    void testGetStandardUnit() throws Exception {
+        Map<String, Object> response = new HashMap<>();
+        response.put("success", true);
+        response.put("field", "流量");
+        response.put("standardUnit", "m³/s");
+        response.put("unitCode", "FLOW001");
+        
+        when(dataGovernanceService.getStandardUnit(any())).thenReturn(response);
+        
+        mockMvc.perform(get("/api/data-governance/units/standard/流量"))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.success").value(true))
+                .andExpect(jsonPath("$.field").value("流量"))
+                .andExpect(jsonPath("$.standardUnit").value("m³/s"));
+    }
+}

water-management-system/src/main/java/com/waterquality/data/DataNormalizer.java

+package com.waterquality.data;
+
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.time.format.DateTimeParseException;
+import java.util.Map;
+import java.util.regex.Pattern;
+
+/**
+ * 数据标准化处理器
+ * 实现数据格式统一和质量检查
+ */
+public class DataNormalizer {
+    
+    private static final DateTimeFormatter[] DATE_FORMATTERS = {
+        DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"),
+        DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss"),
+        DateTimeFormatter.ofPattern("yyyy-MM-dd"),
+        DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss"),
+        DateTimeFormatter.ofPattern("yyyy/MM/dd")
+    };
+    
+    /**
+     * 数据标准化
+     * @param originalData 原始数据
+     * @return 标准化后的数据
+     */
+    public static Map<String, Object> normalizeData(Map<String, Object> originalData) {
+        Map<String, Object> normalizedData = new HashMap<>();
+        
+        // 遍历原始数据
+        for (Map.Entry<String, Object> entry : originalData.entrySet()) {
+            String fieldName = entry.getKey();
+            Object value = entry.getValue();
+            
+            // 字段名称标准化
+            String standardFieldName = StandardsMapping.mapToStandardField(fieldName);
+            
+            // 值标准化
+            Object normalizedValue = normalizeValue(value, standardFieldName);
+            
+            normalizedData.put(standardFieldName, normalizedValue);
+        }
+        
+        return normalizedData;
+    }
+    
+    /**
+     * 值标准化
+     * @param value 原始值
+     * @param field 字段名称
+     * @return 标准化后的值
+     */
+    private static Object normalizeValue(Object value, String field) {
+        if (value == null) {
+            return null;
+        }
+        
+        String stringValue = value.toString().trim();
+        
+        // 空值处理
+        if (stringValue.isEmpty() || "null".equalsIgnoreCase(stringValue) || "NA".equalsIgnoreCase(stringValue)) {
+            return null;
+        }
+        
+        // 时间字段标准化
+        if (field.toLowerCase().contains("time") || field.toLowerCase().contains("date")) {
+            return normalizeDateTime(stringValue);
+        }
+        
+        // 数值字段标准化
+        if (isNumericField(field)) {
+            return normalizeNumericValue(stringValue, field);
+        }
+        
+        // 字符串字段标准化
+        return normalizeStringValue(stringValue);
+    }
+    
+    /**
+     * 时间标准化
+     * @param timeString 时间字符串
+     * @return 标准化时间 (ISO格式)
+     */
+    private static String normalizeDateTime(String timeString) {
+        for (DateTimeFormatter formatter : DATE_FORMATTERS) {
+            try {
+                LocalDateTime dateTime = LocalDateTime.parse(timeString, formatter);
+                return dateTime.format(DateTimeFormatter.ISO_LOCAL_DATE_TIME);
+            } catch (DateTimeParseException e) {
+                // 尝试下一个格式
+            }
+        }
+        
+        // 如果无法解析，返回当前时间作为默认值
+        return LocalDateTime.now().format(DateTimeFormatter.ISO_LOCAL_DATE_TIME);
+    }
+    
+    /**
+     * 数值标准化
+     * @param value 数值字符串
+     * @param field 字段名称
+     * @return 标准化数值
+     */
+    private static Number normalizeNumericValue(String value, String field) {
+        try {
+            // 移除千位分隔符
+            String cleanValue = value.replaceAll("[,，]", "");
+            
+            // 判断是否为整数
+            if (cleanValue.contains(".") || cleanValue.toLowerCase().contains("e")) {
+                return Double.parseDouble(cleanValue);
+            } else {
+                return Long.parseLong(cleanValue);
+            }
+        } catch (NumberFormatException e) {
+            // 转换失败，返回默认值
+            return getDefaultValueForField(field);
+        }
+    }
+    
+    /**
+     * 字符串标准化
+     * @param value 字符串
+     * @return 标准化字符串
+     */
+    private static String normalizeStringValue(String value) {
+        // 去除多余空格
+        String normalized = value.trim().replaceAll("\\s+", " ");
+        
+        // 移除特殊字符（保留中文、英文、数字、常用符号）
+        normalized = normalized.replaceAll("[^\\u4e00-\\u9fa5\\w\\s\\-\\._:\\(\\)\\[\\]{}+=@#%&*!?<>\",'\\\\/]", "");
+        
+        return normalized;
+    }
+    
+    /**
+     * 判断是否为数值字段
+     * @param field 字段名称
+     * @return 是否为数值字段
+     */
+    private static boolean isNumericField(String field) {
+        String normalized = field.toLowerCase();
+        return normalized.contains("流量") || normalized.contains("压力") || 
+               normalized.contains("水位") || normalized.contains("浊度") ||
+               normalized.contains("温度") || normalized.contains("ph") ||
+               normalized.contains("value") || normalized.contains("amount") ||
+               normalized.contains("count") || normalized.contains("number");
+    }
+    
+    /**
+     * 获取字段的默认值
+     * @param field 字段名称
+     * @return 默认值
+     */
+    private static Number getDefaultValueForField(String field) {
+        if (field.contains("流量") || field.contains("pressure") || field.contains("水位")) {
+            return 0.0;
+        } else if (field.contains("浊度") || field.contains("温度") || field.contains("ph")) {
+            return 0.0;
+        } else {
+            return 0; // 默认整数
+        }
+    }
+    
+    /**
+     * 数据质量检查
+     * @param data 数据
+     * @return 质量检查结果
+     */
+    public static Map<String, Object> checkDataQuality(Map<String, Object> data) {
+        Map<String, Object> qualityResult = new HashMap<>();
+        
+        int totalFields = data.size();
+        int nullFields = 0;
+        int invalidFields = 0;
+        
+        for (Map.Entry<String, Object> entry : data.entrySet()) {
+            String field = entry.getKey();
+            Object value = entry.getValue();
+            
+            // 检查空值
+            if (value == null || value.toString().trim().isEmpty()) {
+                nullFields++;
+                continue;
+            }
+            
+            // 检查数据有效性
+            if (!isValidValue(value, field)) {
+                invalidFields++;
+            }
+        }
+        
+        qualityResult.put("totalFields", totalFields);
+        qualityResult.put("nullFields", nullFields);
+        qualityResult.put("invalidFields", invalidFields);
+        qualityResult.put("validFields", totalFields - nullFields - invalidFields);
+        qualityResult.put("completenessRate", (double)(totalFields - nullFields) / totalFields * 100);
+        qualityResult.put("validityRate", (double)(totalFields - invalidFields) / totalFields * 100);
+        
+        return qualityResult;
+    }
+    
+    /**
+     * 检查值有效性
+     * @param value 值
+     * @param field 字段
+     * @return 是否有效
+     */
+    private static boolean isValidValue(Object value, String field) {
+        if (value == null) {
+            return false;
+        }
+        
+        String stringValue = value.toString();
+        
+        // 数值字段有效性检查
+        if (isNumericField(field)) {
+            try {
+                Double.parseDouble(stringValue.replaceAll("[,，]", ""));
+                return true;
+            } catch (NumberFormatException e) {
+                return false;
+            }
+        }
+        
+        // 时间字段有效性检查
+        if (field.toLowerCase().contains("time") || field.toLowerCase().contains("date")) {
+            for (DateTimeFormatter formatter : DATE_FORMATTERS) {
+                try {
+                    LocalDateTime.parse(stringValue, formatter);
+                    return true;
+                } catch (DateTimeParseException e) {
+                    // 继续尝试下一个格式
+                }
+            }
+            return false;
+        }
+        
+        return true;
+    }
+}

water-management-system/src/main/java/com/waterquality/data/StandardsMapping.java

+package com.waterquality.data;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * 水利行业标准字段映射
+ */
+public class StandardsMapping {
+    
+    /**
+     * 水利标准字段映射表
+     * LL-流量, YL-压力, SW-水位, ZD-浊度
+     */
+    private static final Map<String, Map<String, Object>> STANDARD_FIELDS = new HashMap<>();
+    
+    static {
+        // 流量字段映射
+        Map<String, Object> flowFields = new HashMap<>();
+        flowFields.put("standard", "LL");
+        flowFields.put("name", "流量");
+        flowFields.put("unit", "m³/s");
+        flowFields.put("description", "水利管道流量");
+        flowFields.put("standardCode", "LL001");
+        STANDARD_FIELDS.put("flow", flowFields);
+        
+        // 压力字段映射
+        Map<String, Object> pressureFields = new HashMap<>();
+        pressureFields.put("standard", "YL");
+        pressureFields.put("name", "压力");
+        pressureFields.put("unit", "MPa");
+        pressureFields.put("description", "管道压力监测");
+        pressureFields.put("standardCode", "YL001");
+        STANDARD_FIELDS.put("pressure", pressureFields);
+        
+        // 水位字段映射
+        Map<String, Object> waterLevelFields = new HashMap<>();
+        waterLevelFields.put("standard", "SW");
+        waterLevelFields.put("name", "水位");
+        waterLevelFields.put("unit", "m");
+        waterLevelFields.put("description", "水库/河道水位");
+        waterLevelFields.put("standardCode", "SW001");
+        STANDARD_FIELDS.put("waterLevel", waterLevelFields);
+        
+        // 浊度字段映射
+        Map<String, Object> turbidityFields = new HashMap<>();
+        turbidityFields.put("standard", "ZD");
+        turbidityFields.put("name", "浊度");
+        turbFields.put("unit", "NTU");
+        turbidityFields.put("description", "水体浊度检测");
+        turbidityFields.put("standardCode", "ZD001");
+        STANDARD_FIELDS.put("turbidity", turbidityFields);
+    }
+    
+    /**
+     * 获取标准字段映射
+     * @param fieldType 字段类型 (flow, pressure, waterLevel, turbidity)
+     * @return 字段映射信息
+     */
+    public static Map<String, Object> getStandardField(String fieldType) {
+        return STANDARD_FIELDS.get(fieldType);
+    }
+    
+    /**
+     * 获取所有标准字段映射
+     * @return 字段映射表
+     */
+    public static Map<String, Map<String, Object>> getAllStandardFields() {
+        return new HashMap<>(STANDARD_FIELDS);
+    }
+    
+    /**
+     * 将自定义字段名称映射为标准字段
+     * @param fieldName 字段名称
+     * @return 标准字段名称
+     */
+    public static String mapToStandardField(String fieldName) {
+        String normalized = fieldName.toLowerCase().trim();
+        
+        if (normalized.contains("流量") || normalized.contains("flow") || normalized.contains("流量计")) {
+            return "LL001";
+        } else if (normalized.contains("压力") || normalized.contains("pressure") || normalized.contains("压力表")) {
+            return "YL001";
+        } else if (normalized.contains("水位") || normalized.contains("waterLevel") || normalized.contains("液位")) {
+            return "SW001";
+        } else if (normalized.contains("浊度") || normalized.contains("turbidity") || normalized.contains("浑浊度")) {
+            return "ZD001";
+        }
+        
+        return fieldName; // 无法映射时返回原值
+    }
+}

water-management-system/src/main/java/com/waterquality/data/UnitConverter.java

+package com.waterquality.data;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * 单位转换器
+ * 支持水利行业标准单位之间的转换
+ */
+public class UnitConverter {
+    
+    /**
+     * 单位转换因子表
+     */
+    private static final Map<String, Double> UNIT_CONVERSIONS = new HashMap<>();
+    
+    static {
+        // 流量单位转换 (m³/s 为基准)
+        UNIT_CONVERSIONS.put("m³/s", 1.0);
+        UNIT_CONVERSIONS.put("m³/min", 1.0/60.0);
+        UNIT_CONVERSIONS.put("m³/h", 1.0/3600.0);
+        UNIT_CONVERSIONS.put("L/s", 0.001);
+        UNIT_CONVERSIONS.put("L/min", 0.001/60.0);
+        UNIT_CONVERSIONS.put("L/h", 0.001/3600.0);
+        
+        // 压力单位转换 (MPa 为基准)
+        UNIT_CONVERSIONS.put("MPa", 1.0);
+        UNIT_CONVERSIONS.put("kPa", 0.001);
+        UNIT_CONVERSIONS.put("Pa", 0.000001);
+        UNIT_CONVERSIONS.put("bar", 0.1);
+        UNIT_CONVERSIONS.put("kgf/cm²", 0.0980665);
+        
+        // 水位单位转换 (m 为基准)
+        UNIT_CONVERSIONS.put("m", 1.0);
+        UNIT_CONVERSIONS.put("cm", 0.01);
+        UNIT_CONVERSIONS.put("mm", 0.001);
+        UNIT_CONVERSIONS.put("km", 1000.0);
+        
+        // 浊度单位转换 (NTU 为基准)
+        UNIT_CONVERSIONS.put("NTU", 1.0);
+        UNIT_CONVERSIONS.put("FTU", 1.0); // 浊度单位通常等同
+        UNIT_CONVERSIONS.put("mg/L", 1.0); // 简化处理，实际需要更复杂的转换
+    }
+    
+    /**
+     * 单位编码映射
+     */
+    private static final Map<String, String> UNIT_CODING = new HashMap<>();
+    
+    static {
+        // 标准单位编码
+        UNIT_CODING.put("m³/s", "FLOW001");
+        UNIT_CODING.put("MPa", "PRESS001");
+        UNIT_CODING.put("m", "LEVEL001");
+        UNIT_CODING.put("NTU", "TURB001");
+        
+        // 常用单位编码
+        UNIT_CODING.put("m³/h", "FLOW002");
+        UNIT_CODING.put("kPa", "PRESS002");
+        UNIT_CODING.put("cm", "LEVEL002");
+        UNIT_CODING.put("FTU", "TURB002");
+    }
+    
+    /**
+     * 单位转换
+     * @param value 原始值
+     * @param fromUnit 原始单位
+     * @param toUnit 目标单位
+     * @return 转换后的值
+     * @throws IllegalArgumentException 不支持的单位转换
+     */
+    public static double convert(double value, String fromUnit, String toUnit) {
+        if (fromUnit.equals(toUnit)) {
+            return value;
+        }
+        
+        Double fromFactor = UNIT_CONVERSIONS.get(fromUnit);
+        Double toFactor = UNIT_CONVERSIONS.get(toUnit);
+        
+        if (fromFactor == null || toFactor == null) {
+            throw new IllegalArgumentException("Unsupported unit conversion: " + fromUnit + " -> " + toUnit);
+        }
+        
+        return value * fromFactor / toFactor;
+    }
+    
+    /**
+     * 获取单位编码
+     * @param unit 单位名称
+     * @return 单位编码
+     */
+    public static String getUnitCode(String unit) {
+        return UNIT_CODING.getOrDefault(unit, "OTHER001");
+    }
+    
+    /**
+     * 获取所有支持的单位
+     * @return 单位列表
+     */
+    public static Map<String, String> getSupportedUnits() {
+        Map<String, String> units = new HashMap<>();
+        
+        // 流量单位
+        units.put("m³/s", "立方米/秒");
+        units.put("m³/min", "立方米/分钟");
+        units.put("m³/h", "立方米/小时");
+        units.put("L/s", "升/秒");
+        units.put("L/min", "升/分钟");
+        units.put("L/h", "升/小时");
+        
+        // 压力单位
+        units.put("MPa", "兆帕");
+        units.put("kPa", "千帕");
+        units.put("Pa", "帕");
+        units.put("bar", "巴");
+        units.put("kgf/cm²", "千克力/平方厘米");
+        
+        // 水位单位
+        units.put("m", "米");
+        units.put("cm", "厘米");
+        units.put("mm", "毫米");
+        units.put("km", "千米");
+        
+        // 浊度单位
+        units.put("NTU", "浊度单位");
+        units.put("FTU", "浊度单位");
+        units.put("mg/L", "毫克/升");
+        
+        return units;
+    }
+    
+    /**
+     * 获取标准单位
+     * @param field 字段类型
+     * @return 标准单位
+     */
+    public static String getStandardUnit(String field) {
+        switch (field.toLowerCase()) {
+            case "flow":
+            case "流量":
+                return "m³/s";
+            case "pressure":
+            case "压力":
+                return "MPa";
+            case "waterlevel":
+            case "水位":
+                return "m";
+            case "turbidity":
+            case "浊度":
+                return "NTU";
+            default:
+                return "m³/s"; // 默认流量单位
+        }
+    }
+}

water-management-system/src/main/java/com/waterquality/service/DataGovernanceService.java

+package com.waterquality.service;
+
+import com.waterquality.data.DataNormalizer;
+import com.waterquality.data.StandardsMapping;
+import com.waterquality.data.UnitConverter;
+import org.springframework.stereotype.Service;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 数据治理服务
+ * 提供数据标准化、格式转换、质量检查等业务逻辑
+ */
+@Service
+public class DataGovernanceService {
+    
+    /**
+     * 批量数据标准化
+     * @param dataList 数据列表
+     * @return 标准化后的数据列表
+     */
+    public List<Map<String, Object>> batchNormalizeData(List<Map<String, Object>> dataList) {
+        return dataList.stream()
+                .map(DataNormalizer::normalizeData)
+                .toList();
+    }
+    
+    /**
+     * 批量数据质量检查
+     * @param dataList 数据列表
+     * @return 质量检查结果列表
+     */
+    public List<Map<String, Object>> batchCheckDataQuality(List<Map<String, Object>> dataList) {
+        return dataList.stream()
+                .map(DataNormalizer::checkDataQuality)
+                .toList();
+    }
+    
+    /**
+     * 数据转换管道
+     * @param data 原始数据
+     * @param conversionRules 转换规则
+     * @return 转换后的数据
+     */
+    public Map<String, Object> dataPipeline(Map<String, Object> data, Map<String, Object> conversionRules) {
+        Map<String, Object> result = new HashMap<>();
+        
+        // 1. 数据标准化
+        Map<String, Object> normalizedData = DataNormalizer.normalizeData(data);
+        
+        // 2. 应用转换规则
+        if (conversionRules != null) {
+            normalizedData = applyConversionRules(normalizedData, conversionRules);
+        }
+        
+        // 3. 数据质量检查
+        Map<String, Object> qualityCheck = DataNormalizer.checkDataQuality(normalizedData);
+        
+        result.put("normalizedData", normalizedData);
+        result.put("qualityCheck", qualityCheck);
+        result.put("conversionApplied", conversionRules != null);
+        
+        return result;
+    }
+    
+    /**
+     * 应用转换规则
+     * @param data 数据
+     * @param rules 转换规则
+     * @return 转换后的数据
+     */
+    private Map<String, Object> applyConversionRules(Map<String, Object> data, Map<String, Object> rules) {
+        Map<String, Object> convertedData = new HashMap<>(data);
+        
+        // 单位转换规则
+        if (rules.containsKey("unitConversions")) {
+            @SuppressWarnings("unchecked")
+            Map<String, Map<String, String>> unitConversions = (Map<String, Map<String, String>>) rules.get("unitConversions");
+            
+            for (Map.Entry<String, Map<String, String>> entry : unitConversions.entrySet()) {
+                String field = entry.getKey();
+                Map<String, String> conversion = entry.getValue();
+                
+                if (convertedData.containsKey(field) && conversion != null) {
+                    try {
+                        Object valueObj = convertedData.get(field);
+                        if (valueObj instanceof Number) {
+                            double value = ((Number) valueObj).doubleValue();
+                            String fromUnit = conversion.get("fromUnit");
+                            String toUnit = conversion.get("toUnit");
+                            
+                            if (fromUnit != null && toUnit != null) {
+                                double convertedValue = UnitConverter.convert(value, fromUnit, toUnit);
+                                convertedData.put(field, convertedValue);
+                            }
+                        }
+                    } catch (Exception e) {
+                        // 转换失败，保留原值
+                    }
+                }
+            }
+        }
+        
+        // 字段映射规则
+        if (rules.containsKey("fieldMappings")) {
+            @SuppressWarnings("unchecked")
+            Map<String, String> fieldMappings = (Map<String, String>) rules.get("fieldMappings");
+            
+            for (Map.Entry<String, String> entry : fieldMappings.entrySet()) {
+                String oldField = entry.getKey();
+                String newField = entry.getValue();
+                
+                if (convertedData.containsKey(oldField)) {
+                    Object value = convertedData.get(oldField);
+                    convertedData.remove(oldField);
+                    convertedData.put(newField, value);
+                }
+            }
+        }
+        
+        // 数据过滤规则
+        if (rules.containsKey("filterFields")) {
+            @SuppressWarnings("unchecked")
+            List<String> filterFields = (List<String>) rules.get("filterFields");
+            
+            convertedData.keySet().removeIf(key -> !filterFields.contains(key));
+        }
+        
+        return convertedData;
+    }
+    
+    /**
+     * 生成数据治理报告
+     * @param processedData 处理后的数据
+     * @return 治理报告
+     */
+    public Map<String, Object> generateGovernanceReport(Map<String, Object> processedData) {
+        Map<String, Object> report = new HashMap<>();
+        
+        // 基本信息
+        report.put("generatedAt", System.currentTimeMillis());
+        report.put("totalRecords", processedData.size());
+        
+        // 质量统计
+        if (processedData.containsKey("qualityCheck")) {
+            @SuppressWarnings("unchecked")
+            Map<String, Object> qualityCheck = (Map<String, Object>) processedData.get("qualityCheck");
+            
+            report.put("qualityMetrics", qualityCheck);
+        }
+        
+        // 标准化统计
+        int normalizedFields = 0;
+        for (String field : processedData.keySet()) {
+            if (field.startsWith("LL") || field.startsWith("YL") || field.startsWith("SW") || field.startsWith("ZD")) {
+                normalizedFields++;
+            }
+        }
+        report.put("normalizedFields", normalizedFields);
+        
+        // 建议
+        report.put("recommendations", generateRecommendations(processedData));
+        
+        return report;
+    }
+    
+    /**
+     * 生成改进建议
+     * @param data 数据
+     * @return 建议列表
+     */
+    private List<String> generateRecommendations(Map<String, Object> data) {
+        java.util.List<String> recommendations = new java.util.ArrayList<>();
+        
+        // 检查数据完整性
+        if (data.containsKey("qualityCheck")) {
+            @SuppressWarnings("unchecked")
+            Map<String, Object> qualityCheck = (Map<String, Object>) data.get("qualityCheck");
+            
+            Double completenessRate = (Double) qualityCheck.get("completenessRate");
+            if (completenessRate != null && completenessRate < 95.0) {
+                recommendations.add("数据完整性较低，建议增加必填字段的验证");
+            }
+            
+            Double validityRate = (Double) qualityCheck.get("validityRate");
+            if (validityRate != null && validityRate < 90.0) {
+                recommendations.add("数据有效性不足，建议加强数据格式验证");
+            }
+        }
+        
+        // 检查字段标准化
+        boolean hasNonStandardFields = false;
+        for (String field : data.keySet()) {
+            if (!field.startsWith("LL") && !field.startsWith("YL") && !field.startsWith("SW") && !field.startsWith("ZD")) {
+                hasNonStandardFields = true;
+                break;
+            }
+        }
+        
+        if (hasNonStandardFields) {
+            recommendations.add("存在非标准字段，建议应用字段映射规则");
+        }
+        
+        // 默认建议
+        if (recommendations.isEmpty()) {
+            recommendations.add("数据质量良好，继续保持");
+        }
+        
+        return recommendations;
+    }
+    
+    /**
+     * 获取治理规则模板
+     * @return 规则模板
+     */
+    public Map<String, Object> getRuleTemplate() {
+        Map<String, Object> template = new HashMap<>();
+        
+        // 单位转换规则模板
+        Map<String, Map<String, String>> unitConversionTemplate = new HashMap<>();
+        Map<String, String> flowTemplate = new HashMap<>();
+        flowTemplate.put("fromUnit", "m³/h");
+        flowTemplate.put("toUnit", "m³/s");
+        unitConversionTemplate.put("流量", flowTemplate);
+        
+        Map<String, String> pressureTemplate = new HashMap<>();
+        pressureTemplate.put("fromUnit", "kPa");
+        pressureTemplate.put("toUnit", "MPa");
+        unitConversionTemplate.put("压力", pressureTemplate);
+        
+        template.put("unitConversions", unitConversionTemplate);
+        
+        // 字段映射规则模板
+        Map<String, String> fieldMappingTemplate = new HashMap<>();
+        fieldMappingTemplate.put("自定义流量字段", "LL001");
+        fieldMappingTemplate.put("自定义压力字段", "YL001");
+        fieldMappingTemplate.put("自定义水位字段", "SW001");
+        fieldMappingTemplate.put("自定义浊度字段", "ZD001");
+        
+        template.put("fieldMappings", fieldMappingTemplate);
+        
+        // 过滤规则模板
+        java.util.List<String> filterTemplate = java.util.Arrays.asList("LL001", "YL001", "SW001", "ZD001");
+        template.put("filterFields", filterTemplate);
+        
+        return template;
+    }
+}

water-management-system/src/main/java/com/waterquality/service/DataGovernanceServiceTest.java

+package com.waterquality.service;
+
+import com.waterquality.data.StandardsMapping;
+import com.waterquality.data.UnitConverter;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+/**
+ * 数据治理服务测试
+ */
+@SpringBootTest
+public class DataGovernanceServiceTest {
+    
+    @Autowired
+    private DataGovernanceService dataGovernanceService;
+    
+    private Map<String, Object> testData;
+    private Map<String, Object> conversionRules;
+    
+    @BeforeEach
+    void setUp() {
+        // 测试数据
+        testData = new HashMap<>();
+        testData.put("流量", "1000");
+        testData.put("压力", "200");
+        testData.put("水位", "150.5");
+        testData.put("浊度", "10.5");
+        testData.put("检测时间", "2024-01-15 10:30:00");
+        testData.put("备注", "系统正常运行");
+        
+        // 转换规则
+        conversionRules = new HashMap<>();
+        
+        // 单位转换规则
+        Map<String, Map<String, String>> unitConversions = new HashMap<>();
+        Map<String, String> flowConversion = new HashMap<>();
+        flowConversion.put("fromUnit", "m³/h");
+        flowConversion.put("toUnit", "m³/s");
+        unitConversions.put("流量", flowConversion);
+        
+        Map<String, String> pressureConversion = new HashMap<>();
+        pressureConversion.put("fromUnit", "kPa");
+        pressureConversion.put("toUnit", "MPa");
+        unitConversions.put("压力", pressureConversion);
+        
+        conversionRules.put("unitConversions", unitConversions);
+        
+        // 字段映射规则
+        Map<String, String> fieldMappings = new HashMap<>();
+        fieldMappings.put("自定义流量字段", "LL001");
+        fieldMappings.put("自定义压力字段", "YL001");
+        fieldMappings.put("自定义水位字段", "SW001");
+        fieldMappings.put("自定义浊度字段", "ZD001");
+        conversionRules.put("fieldMappings", fieldMappings);
+    }
+    
+    @Test
+    void testBatchNormalizeData() {
+        List<Map<String, Object>> dataList = Arrays.asList(testData);
+        List<Map<String, Object>> normalizedList = dataGovernanceService.batchNormalizeData(dataList);
+        
+        assertNotNull(normalizedList);
+        assertEquals(1, normalizedList.size());
+        
+        Map<String, Object> normalizedData = normalizedList.get(0);
+        assertTrue(normalizedData.containsKey("LL001"));
+        assertTrue(normalizedData.containsKey("YL001"));
+        assertTrue(normalizedData.containsKey("SW001"));
+        assertTrue(normalizedData.containsKey("ZD001"));
+    }
+    
+    @Test
+    void testBatchCheckDataQuality() {
+        List<Map<String, Object>> dataList = Arrays.asList(testData);
+        List<Map<String, Object>> qualityList = dataGovernanceService.batchCheckDataQuality(dataList);
+        
+        assertNotNull(qualityList);
+        assertEquals(1, qualityList.size());
+        
+        Map<String, Object> qualityCheck = qualityList.get(0);
+        assertTrue(qualityCheck.containsKey("totalFields"));
+        assertTrue(qualityCheck.containsKey("nullFields"));
+        assertTrue(qualityCheck.containsKey("invalidFields"));
+        assertTrue(qualityCheck.containsKey("validFields"));
+        assertTrue(qualityCheck.containsKey("completenessRate"));
+        assertTrue(qualityCheck.containsKey("validityRate"));
+    }
+    
+    @Test
+    void testDataPipeline() {
+        Map<String, Object> result = dataGovernanceService.dataPipeline(testData, conversionRules);
+        
+        assertNotNull(result);
+        assertTrue(result.containsKey("normalizedData"));
+        assertTrue(result.containsKey("qualityCheck"));
+        assertTrue(result.containsKey("conversionApplied"));
+        
+        @SuppressWarnings("unchecked")
+        Map<String, Object> normalizedData = (Map<String, Object>) result.get("normalizedData");
+        assertTrue(normalizedData.containsKey("LL001"));
+        assertTrue(normalizedData.containsKey("YL001"));
+        assertTrue(normalizedData.containsKey("SW001"));
+        assertTrue(normalizedData.containsKey("ZD001"));
+    }
+    
+    @Test
+    void testGenerateGovernanceReport() {
+        Map<String, Object> processedData = new HashMap<>();
+        processedData.put("LL001", 1000.0);
+        processedData.put("YL001", 200.0);
+        processedData.put("SW001", 150.5);
+        processedData.put("ZD001", 10.5);
+        
+        Map<String, Object> qualityCheck = new HashMap<>();
+        qualityCheck.put("totalFields", 4);
+        qualityCheck.put("nullFields", 0);
+        qualityCheck.put("invalidFields", 0);
+        qualityCheck.put("validFields", 4);
+        qualityCheck.put("completenessRate", 100.0);
+        qualityCheck.put("validityRate", 100.0);
+        
+        processedData.put("qualityCheck", qualityCheck);
+        
+        Map<String, Object> report = dataGovernanceService.generateGovernanceReport(processedData);
+        
+        assertNotNull(report);
+        assertTrue(report.containsKey("generatedAt"));
+        assertTrue(report.containsKey("totalRecords"));
+        assertTrue(report.containsKey("normalizedFields"));
+        assertTrue(report.containsKey("recommendations"));
+        assertTrue(report.containsKey("qualityMetrics"));
+    }
+    
+    @Test
+    void testGetRuleTemplate() {
+        Map<String, Object> template = dataGovernanceService.getRuleTemplate();
+        
+        assertNotNull(template);
+        assertTrue(template.containsKey("unitConversions"));
+        assertTrue(template.containsKey("fieldMappings"));
+        assertTrue(template.containsKey("filterFields"));
+        
+        @SuppressWarnings("unchecked")
+        Map<String, Map<String, String>> unitConversions = (Map<String, Map<String, String>>) template.get("unitConversions");
+        assertTrue(unitConversions.containsKey("流量"));
+        assertTrue(unitConversions.containsKey("压力"));
+        
+        @SuppressWarnings("unchecked")
+        Map<String, String> fieldMappings = (Map<String, String>) template.get("fieldMappings");
+        assertTrue(fieldMappings.containsKey("自定义流量字段"));
+        assertTrue(fieldMappings.containsKey("自定义压力字段"));
+        
+        @SuppressWarnings("unchecked")
+        List<String> filterFields = (List<String>) template.get("filterFields");
+        assertTrue(filterFields.contains("LL001"));
+        assertTrue(filterFields.contains("YL001"));
+        assertTrue(filterFields.contains("SW001"));
+        assertTrue(filterFields.contains("ZD001"));
+    }
+    
+    @Test
+    void testUnitConversion() {
+        double value = 1000;
+        String fromUnit = "m³/h";
+        String toUnit = "m³/s";
+        
+        double convertedValue = UnitConverter.convert(value, fromUnit, toUnit);
+        assertEquals(1000.0 / 3600.0, convertedValue, 0.001);
+        
+        String unitCode = UnitConverter.getUnitCode(toUnit);
+        assertEquals("FLOW001", unitCode);
+    }
+    
+    @Test
+    void testStandardsMapping() {
+        Map<String, Object> flowField = StandardsMapping.getStandardField("flow");
+        assertNotNull(flowField);
+        assertEquals("LL", flowField.get("standard"));
+        assertEquals("m³/s", flowField.get("unit"));
+        
+        String standardField = StandardsMapping.mapToStandardField("自定义流量字段");
+        assertEquals("LL001", standardField);
+        
+        String standardField2 = StandardsMapping.mapToStandardField("flow");
+        assertEquals("LL001", standardField2);
+    }
+}

water-management-system/src/main/resources/application.yml

+server:
+  port: 8080
+  servlet:
+    context-path: /
+
+spring:
+  application:
+    name: water-management-system
+  
+  datasource:
+    url: jdbc:h2:mem:testdb
+    driver-class-name: org.h2.Driver
+    username: sa
+    password: password
+    hikari:
+      maximum-pool-size: 10
+      minimum-idle: 2
+  
+  h2:
+    console:
+      enabled: true
+      path: /h2-console
+  
+  jpa:
+    hibernate:
+      ddl-auto: create-drop
+    show-sql: false
+    properties:
+      hibernate:
+        format_sql: true
+        dialect: org.hibernate.dialect.H2Dialect
+  
+  mvc:
+    pathmatch:
+      matching-strategy: ant_path_matcher
+
+logging:
+  level:
+    com.waterquality: DEBUG
+    org.springframework.web: INFO
+    org.hibernate: WARN
+
+management:
+  endpoints:
+    web:
+      exposure:
+        include: health,info
+  endpoint:
+    health:
+      show-details: always