本文目录导读：
我来详细介绍Java分布式数据校验器的规则设计和实现方式。
基础规则定义
规则接口设计
public interface ValidationRule<T> {
boolean validate(T value, ValidationContext context);
String getRuleName();
String getErrorMessage();
}
基础规则实现示例
// 非空规则
public class NotNullRule implements ValidationRule<Object> {
@Override
public boolean validate(Object value, ValidationContext context) {
return value != null;
}
@Override
public String getRuleName() {
return "NOT_NULL";
}
@Override
public String getErrorMessage() {
return "字段不能为空";
}
}
// 范围规则
public class RangeRule implements ValidationRule<Number> {
private double min;
private double max;
public RangeRule(double min, double max) {
this.min = min;
this.max = max;
}
@Override
public boolean validate(Number value, ValidationContext context) {
double doubleValue = value.doubleValue();
return doubleValue >= min && doubleValue <= max;
}
@Override
public String getRuleName() {
return "RANGE";
}
@Override
public String getErrorMessage() {
return String.format("数值必须在 %s 和 %s 之间", min, max);
}
}
规则配置管理
YAML配置示例
# validator-rules.yaml
rules:
- name: "USER_NAME"
type: "STRING"
rules:
- NOT_NULL
- LENGTH:
min: 2
max: 50
- PATTERN: "^[a-zA-Z\\u4e00-\\u9fa5]+$"
- name: "EMAIL"
type: "STRING"
rules:
- NOT_NULL
- PATTERN: "^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$"
- name: "AGE"
type: "INTEGER"
rules:
- NOT_NULL
- RANGE:
min: 0
max: 150
- name: "PHONE_NUMBER"
type: "STRING"
rules:
- NOT_NULL
- PATTERN: "^1[3-9]\\d{9}$"
规则配置加载器
@Component
public class RuleConfigLoader {
@Value("${validator.rules.config:classpath:validator-rules.yaml}")
private String configPath;
private Map<String, List<ValidationRule>> rulesMap = new ConcurrentHashMap<>();
@PostConstruct
public void init() {
// 从配置中心或本地文件加载规则
loadRules();
}
private void loadRules() {
// 使用SnakeYAML或Spring的YamlPropertySourceLoader加载
// 解析并创建规则实例
}
public List<ValidationRule> getRules(String fieldName) {
return rulesMap.get(fieldName);
}
}
分布式规则同步
基于Redis的规则同步
@Component
public class DistributedRuleSynchronizer {
@Autowired
private StringRedisTemplate redisTemplate;
private static final String RULE_KEY_PREFIX = "validator:rules:";
// 发布规则更新
public void publishRules(List<ValidationRule> rules) {
String rulesJson = JSON.toJSONString(rules);
redisTemplate.convertAndSend("validator:rule-update", rulesJson);
}
// 订阅规则更新
@EventListener
public void onRuleUpdate(RedisMessageListenerContainer container) {
container.addMessageListener((message, pattern) -> {
String rulesJson = new String(message.getBody(), StandardCharsets.UTF_8);
List<ValidationRule> rules = JSON.parseArray(rulesJson, ValidationRule.class);
updateLocalRules(rules);
}, new PatternTopic("validator:rule-update"));
}
// 获取本地缓存的规则
private Map<String, List<ValidationRule>> localRules = new ConcurrentHashMap<>();
private void updateLocalRules(List<ValidationRule> rules) {
// 更新本地规则缓存
localRules.clear();
rules.forEach(rule -> {
localRules.computeIfAbsent(rule.getRuleName(), k -> new ArrayList<>())
.add(rule);
});
}
}
基于ZooKeeper的规则同步
@Component
public class ZkRuleSynchronizer implements Watcher {
private ZooKeeper zooKeeper;
private static final String RULE_PATH = "/validator/rules";
@Override
public void process(WatchedEvent event) {
if (event.getType() == Event.EventType.NodeDataChanged) {
// 重新加载规则
loadRulesFromZk();
}
}
public void loadRulesFromZk() {
try {
byte[] data = zooKeeper.getData(RULE_PATH, this, null);
List<ValidationRule> rules = deserializeRules(data);
updateLocalRules(rules);
} catch (Exception e) {
log.error("从ZooKeeper加载规则失败", e);
}
}
public void updateRulesInZk(List<ValidationRule> rules) {
try {
byte[] data = serializeRules(rules);
zooKeeper.setData(RULE_PATH, data, -1);
} catch (Exception e) {
log.error("更新ZooKeeper规则失败", e);
}
}
}
规则执行引擎
分布式校验执行器
@Component
public class DistributedValidatorEngine {
@Autowired
private RuleConfigLoader ruleConfigLoader;
@Autowired
private ValidationRuleFactory ruleFactory;
public ValidationResult validate(Object target, ValidationContext context) {
ValidationResult result = new ValidationResult();
// 获取目标对象的校验规则
List<ValidationRule> rules = getRules(target.getClass());
// 并行执行规则校验
List<CompletableFuture<RuleValidationResult>> futures = rules.stream()
.map(rule -> CompletableFuture.supplyAsync(() -> {
try {
boolean passed = rule.validate(target, context);
return new RuleValidationResult(rule.getRuleName(), passed,
passed ? null : rule.getErrorMessage());
} catch (Exception e) {
return new RuleValidationResult(rule.getRuleName(), false,
"规则执行异常: " + e.getMessage());
}
}))
.collect(Collectors.toList());
// 收集结果
CompletableFuture.allOf(futures.toArray(new CompletableFuture[0])).join();
futures.forEach(future -> {
try {
RuleValidationResult ruleResult = future.get();
if (!ruleResult.isPassed()) {
result.addError(ruleResult.getRuleName(), ruleResult.getErrorMessage());
}
} catch (Exception e) {
result.addError("SYSTEM", "结果获取异常: " + e.getMessage());
}
});
return result;
}
}
// 校验结果
@Data
public class ValidationResult {
private boolean success = true;
private Map<String, List<String>> errors = new HashMap<>();
public void addError(String field, String message) {
this.success = false;
errors.computeIfAbsent(field, k -> new ArrayList<>()).add(message);
}
}
条件规则与组合规则
// 条件规则
public class ConditionalRule implements ValidationRule<Object> {
private ValidationRule<Object> condition;
private ValidationRule<Object> thenRule;
private ValidationRule<Object> elseRule;
@Override
public boolean validate(Object value, ValidationContext context) {
if (condition.validate(value, context)) {
return thenRule.validate(value, context);
} else {
return elseRule != null ? elseRule.validate(value, context) : true;
}
}
}
// 组合规则
public class CompositeRule implements ValidationRule<Object> {
private List<ValidationRule> rules;
private Operator operator;
public enum Operator {
AND, OR, XOR
}
@Override
public boolean validate(Object value, ValidationContext context) {
return switch (operator) {
case AND -> rules.stream().allMatch(r -> r.validate(value, context));
case OR -> rules.stream().anyMatch(r -> r.validate(value, context));
case XOR -> rules.stream().filter(r -> r.validate(value, context)).count() == 1;
};
}
}
性能优化
@Component
public class RuleCacheManager {
// 使用Caffeine缓存规则执行结果
private Cache<String, Boolean> ruleResultCache = Caffeine.newBuilder()
.expireAfterWrite(1, TimeUnit.MINUTES)
.maximumSize(10000)
.build();
public boolean getCachedResult(String key) {
return ruleResultCache.getIfPresent(key);
}
public void cacheResult(String key, boolean result) {
ruleResultCache.put(key, result);
}
// 规则执行统计
private Map<String, RuleStatistics> statisticsMap = new ConcurrentHashMap<>();
@Scheduled(fixedRate = 60000)
public void reportStatistics() {
// 定期报告规则执行统计信息
statisticsMap.forEach((ruleName, stats) -> {
log.info("规则 {}: 执行次数={}, 失败次数={}, 平均耗时={}ms",
ruleName, stats.count, stats.failCount, stats.averageTime);
});
}
}
使用示例
@RestController
public class UserController {
@Autowired
private DistributedValidatorEngine validatorEngine;
@PostMapping("/user")
public ResponseEntity<?> createUser(@RequestBody User user) {
ValidationContext context = ValidationContext.builder()
.tenant("tenant1")
.environment("production")
.timestamp(System.currentTimeMillis())
.build();
ValidationResult result = validatorEngine.validate(user, context);
if (!result.isSuccess()) {
return ResponseEntity.badRequest().body(result.getErrors());
}
// 继续业务处理
return ResponseEntity.ok("用户创建成功");
}
}
这个分布式数据校验器支持：
- 灵活的规则定义：支持基础规则、条件规则、组合规则
- 分布式同步：基于Redis或ZooKeeper实现规则同步
- 高性能：支持缓存、并行执行
- 可扩展：易于添加新规则类型
- 配置化：通过YAML或配置中心管理规则
