本文目录导读：
我将为您提供几个Java数字孪生（Digital Twin）应用的完整案例，涵盖不同行业和实现方式。
工业设备数字孪生（设备监控与预测维护）
核心架构
// 数字孪生核心实体
public class DigitalTwin {
private String id;
private String type;
private Map<String, Double> realTimeData = new ConcurrentHashMap<>();
private Map<String, Double> simulatedData = new ConcurrentHashMap<>();
private List<Sensor> sensors;
private Model model;
private Status status;
private long lastSyncTime;
public void updateFromPhysicalAsset(Map<String, Double> data, long timestamp) {
this.realTimeData = data;
this.lastSyncTime = timestamp;
synchronized (this) {
// 同步完成后触发模型更新
model.update(data);
status = calculateStatus();
}
publishEvent(new TwinUpdateEvent(this));
}
public void applySimulation(Map<String, Double> simData) {
this.simulatedData = simData;
model.simulate(simData);
}
public enum Status {
NORMAL, WARNING, CRITICAL, UNKNOWN
}
private Status calculateStatus() {
double temp = realTimeData.getOrDefault("temperature", 0.0);
double vibration = realTimeData.getOrDefault("vibration", 0.0);
if (temp > 95.0 || vibration > 0.8) {
return Status.CRITICAL;
} else if (temp > 85.0 || vibration > 0.6) {
return Status.WARNING;
}
return Status.NORMAL;
}
public void publishEvent(TwinUpdateEvent event) {
EventEmitter.getInstance().emit(event);
}
}
传感器数据采集（IoT集成）
@RestController
@RequestMapping("/api/v1/sensors")
public class SensorIngestionController {
private final DigitalTwinManager twinManager;
private final KafkaTemplate<String, String> kafkaTemplate;
@Autowired
public SensorIngestionController(DigitalTwinManager twinManager,
KafkaTemplate<String, String> kafkaTemplate) {
this.twinManager = twinManager;
this.kafkaTemplate = kafkaTemplate;
}
@PostMapping("/{twinId}/data")
public ResponseEntity<String> ingestSensorData(
@PathVariable String twinId,
@RequestBody SensorDataPayload payload,
@RequestHeader("X-Sensor-Key") String sensorKey) {
// 数据验证和鉴权
if (!sensorAuthService.validateKey(sensorKey)) {
return ResponseEntity.status(401).body("Invalid sensor key");
}
// 发送到Kafka消息队列用于异步处理
kafkaTemplate.send("twin-data-topic", twinId, JsonUtils.toJson(payload));
// 立即更新数字孪生（低延迟场景）
DigitalTwin twin = twinManager.getTwin(twinId);
Map<String, Double> mqttData = parsePayload(payload);
twin.updateFromPhysicalAsset(mqttData, System.currentTimeMillis());
return ResponseEntity.ok("Data ingested successfully");
}
private Map<String, Double> parsePayload(SensorDataPayload payload) {
Map<String, Double> dataMap = new HashMap<>();
if (payload.getTemperature() != null) {
dataMap.put("temperature", payload.getTemperature());
}
if (payload.getVibration() != null) {
dataMap.put("vibration", payload.getVibration());
}
dataMap.put("speed", payload.getSpeed());
return dataMap;
}
}
// 数据封装类
@Data
public class SensorDataPayload {
private String sensorId;
private Double temperature;
private Double vibration;
private Double speed;
private Double voltage;
private Double current;
private String unit;
private Long timestamp;
}
预测维护和异常检测
@Component
public class PredictiveMaintenanceService {
private final MachineLearningModel mlModel;
private final NotificationService notificationService;
public MaintenancePrediction predictMaintenance(DigitalTwin twin) {
Map<String, Double> features = extractFeatures(twin);
// 使用ML模型进行预测
double failureProbability = mlModel.predictFailureProbability(features);
MaintenancePrediction prediction = new MaintenancePrediction();
prediction.setTwinId(twin.getId());
prediction.setFailureProbability(failureProbability);
prediction.setPredictedRemainingLife(estimeRemainingLife(twin, failureProbability));
prediction.setRecommendedActions(generateRecommendations(twin));
// 高危预测立即通知
if (failureProbability > 0.7) {
notificationService.sendAlert(twin, prediction);
}
return prediction;
}
private Map<String, Double> extractFeatures(DigitalTwin twin) {
Map<String, Double> features = new HashMap<>();
features.put("mean_temperature", twin.getRealTimeData().get("temperature"));
features.put("vibration_amplitude", twin.getRealTimeData().get("vibration"));
features.put("running_hours", twin.getRealTimeData().get("runtime"));
features.put("load_factor", twin.getRealTimeData().get("load"));
return features;
}
private Double estimeRemainingLife(DigitalTwin twin, double failureProb) {
// 基于历史维护数据和运行模式估算
double avgLifetime = 12000; // 平均寿命（小时）
double efficiency = 1.0 - failureProb;
return avgLifetime * efficiency;
}
private List<String> generateRecommendations(DigitalTwin twin) {
List<String> recommendations = new ArrayList<>();
switch (twin.getStatus()) {
case CRITICAL:
recommendations.add("立即停机检查");
recommendations.add("更换轴承部件");
recommendations.add("检查冷却系统");
break;
case WARNING:
recommendations.add("计划两日内维护");
recommendations.add("加强监控频率");
recommendations.add("检查润滑系统");
break;
default:
recommendations.add("继续正常监控");
}
return recommendations;
}
}
智慧工厂三维可视化数字孪生
三维场景管理
@Service
public class Factory3DVisualizationService {
private final Map<String, ShapeData> shapeCache = new ConcurrentHashMap<>();
private final WebSocketService webSocketService;
public SceneData getFactoryScene(String factoryId) {
// 从数据库加载工厂布局
FactoryLayout layout = factoryRepository.findByFactoryId(factoryId);
SceneData scene = new SceneData();
scene.setFactoryId(factoryId);
scene.setCoordinateSystem(layout.getCoordinateSystem());
// 创建所有设备的3D表示
for (Equipment equipment : layout.getEquipments()) {
ShapeData equipmentShape = createEquipmentShape(equipment);
scene.addShape(equipmentShape);
// 为每个设备创建数字孪生
DigitalTwin twin = new DigitalTwin();
twin.setId(equipment.getId());
twin.setType(equipment.getType());
twin.setModel(new EquipmentModel(equipment.getType()));
scene.attachTwin(equipmentShape.getId(), twin);
}
return scene;
}
private ShapeData createEquipmentShape(Equipment equipment) {
ShapeData shape = new ShapeData(equipment.getType());
shape.setId(equipment.getId());
shape.setPosition(equipment.getPosition());
shape.setRotation(equipment.getRotation());
shape.setScale(equipment.getScale());
// 按照类型分配3D模型
switch (equipment.getType().toLowerCase()) {
case "cnc":
shape.setModelPath("/models/cnc_machine.glb");
break;
case "conveyor":
shape.setModelPath("/models/conveyor.glb");
break;
case "robot":
shape.setModelPath("/models/industrial_robot.glb");
break;
default:
shape.setModelPath("/models/default_equipment.glb");
}
return shape;
}
@Scheduled(fixedDelay = 1000)
public void syncTwinData() {
List<EquipmentStatus> statuses = equipmentStatusService.getLatestStatuses();
for (EquipmentStatus status : statuses) {
SceneUpdate update = new SceneUpdate();
update.setEquipmentId(status.getEquipmentId());
update.setStatus(status);
// 更新运行状态动画
if (status.isRunning()) {
update.setAnimation(true);
update.addParameter("speed", status.getSpeed());
}
// 更新故障显示
if (status.getFaultCode() != null) {
update.setFaultDisplay(status.getFaultCode());
update.setAlertColor("#FF0000");
}
// 通过WebSocket发送实时更新到前端
webSocketService.sendToTopic("/topic/factory-update", update);
}
}
}
// 3D场景数据类
@Data
public class ShapeData {
private String id;
private String type;
private float[] position = {0, 0, 0};
private float[] rotation = {0, 0, 0};
private float[] scale = {1, 1, 1};
private String modelPath;
private Color color = Color.WHITE;
private boolean visible = true;
public ShapeData(String type) {
this.type = type;
}
public void setPosition(double x, double y, double z) {
this.position = new float[]{ (float)x, (float)y, (float)z };
}
}
WebSocket实时通信
@Controller
public class TwinWebSocketController {
private final SimpMessagingTemplate messagingTemplate;
private final ObjectMapper objectMapper;
@Autowired
public TwinWebSocketController(SimpMessagingTemplate messagingTemplate,
ObjectMapper objectMapper) {
this.messagingTemplate = messagingTemplate;
this.objectMapper = objectMapper;
}
@MessageMapping("/twin-state")
public void handleTwinState(@Payload TwinStateRequest request) {
// 处理点选设备请求
DigitalTwin twin = digitalTwinService.getTwinById(request.getTwinId());
TwinStateResponse response = new TwinStateResponse();
response.setTwinId(request.getTwinId());
response.setRealTimeData(twin.getRealTimeData());
response.setHealthScore(calculateHealthScore(twin));
response.setTimestamp(System.currentTimeMillis());
// 发送详细状态给点选的客户端
messagingTemplate.convertAndSendToUser(
request.getClientId(),
"/queue/twin-detail",
response
);
}
@MessageMapping("/filter-parameters")
public void applyFilter(@Payload FilterParameters filter) {
// 通知所有订阅前端更新视图
messagingTemplate.convertAndSend(
"/topic/filter-change",
filter
);
}
private double calculateHealthScore(DigitalTwin twin) {
// 综合多个指标计算健康分数
double temperatureScore = getTemperatureScore(twin.getRealTimeData().get("temperature"));
double vibrationScore = getVibrationScore(twin.getRealTimeData().get("vibration"));
double runtimeScore = getRuntimeScore(twin.getRealTimeData().get("runtime"));
return (temperatureScore * 0.5 + vibrationScore * 0.3 + runtimeScore * 0.2) * 100;
}
private double getTemperatureScore(double temp) {
if (temp <= 65) return 1.0;
if (temp <= 80) return 0.8;
if (temp <= 90) return 0.5;
return 0.2;
}
private double getVibrationScore(double vibration) {
if (vibration <= 0.4) return 1.0;
if (vibration <= 0.6) return 0.8;
if (vibration <= 0.8) return 0.4;
return 0.1;
}
}
智慧城市建筑数字孪生
@Service
public class BuildingDigitalTwinService {
private final BuildingEnergyModel energyModel;
private final ThermalComfortModel comfortModel;
public BuildingTwin updateBuildingTwin(String buildingId, SensorData data) {
BuildingTwin twin = twinRepository.findByBuildingId(buildingId);
// 更新基础数据
twin.setOccupancy(data.getOccupancy());
twin.setTemperature(data.getIndoorTemp());
twin.setHumidity(data.getHumidity());
twin.setCO2Level(data.getCO2());
twin.setLightingLevel(data.getLighting());
twin.setEnergyConsumption(data.getEnergyUsage());
// 运行能源优化模型
EnergyOptimizationResult optimization = energyModel.optimizeEnergy(
twin.getUsagePattern(),
twin.getTemperature(),
twin.getOccupancy()
);
// 运行舒适度模型
ComfortIndex comfort = comfortModel.calculateComfort(
twin.getTemperature(),
twin.getHumidity(),
twin.getOccupancy()
);
// 生成优化建议
List<OptimizationSuggestion> suggestions = generateSuggestions(twin, optimization, comfort);
// 如果节能潜力高，触发自动优化
if (optimization.getPotentialSavings() > 10) {
executeHVACOptimization(twin, optimization);
}
// 保存更新
twinRepository.save(twin);
// 触发事件通知相关系统
if (comfort.getIndex() < 60) {
notificationService.sendComfortAlert(buildingId, comfort.getIndex());
}
return twin;
}
public List<OptimizationSuggestion> generateSuggestions(BuildingTwin twin,
EnergyOptimizationResult opt,
ComfortIndex comfort) {
List<OptimizationSuggestion> suggestions = new ArrayList<>();
if (opt.getPotentialSavings() > 15) {
suggestions.add(OptimizationSuggestion.builder()
.type("HVAC_CHANGE")
.description("建议调节空调温度设定至" + opt.getOptimalTemp() + "°C")
.potentialSavings(opt.getPotentialSavings())
.build());
}
if (twin.getLightingLevel() > twin.getTargetLightingLevel()) {
suggestions.add(OptimizationSuggestion.builder()
.type("LIGHTING_DIM")
.description("灯光亮度过高，建议调暗30%")
.potentialSavings(8.5)
.build());
}
if (twin.getOccupancy() < 20 && twin.getCO2Level() < 600) {
suggestions.add(OptimizationSuggestion.builder()
.type("VENTILATION_REDUCE")
.description("人员较少，建议降低新风量")
.potentialSavings(12.0)
.build());
}
return suggestions;
}
private void executeHVACOptimization(BuildingTwin twin, EnergyOptimizationResult result) {
// 通过IoT接口控制空调系统
hvacControlClient.setTemperature(twin.getBuildingId(), result.getOptimalTemp());
hvacControlClient.setFanSpeed(twin.getBuildingId(), result.getOptimalFanSpeed());
}
}
车辆数字孪生（自动驾驶测试）
@Service
public class VehicleDigitalTwinService {
private final VehicleModelRepository vehicleModelRepo;
private final SimulationEngine simulationEngine;
public VehicleTwin createVehicleTwin(VehicleSpec spec) {
VehicleTwin twin = new VehicleTwin();
// 从物理车辆同步数据
twin.setId(spec.getVin());
twin.setMake(spec.getMake());
twin.setModel(spec.getModel());
twin.setYear(spec.getYear());
twin.setOdometer(spec.getOdometer());
// 实时状态
twin.setGpsLocation(spec.getGpsLocation());
twin.setHeading(spec.getHeading());
twin.setSpeed(spec.getSpeed());
twin.setRPM(spec.getRPM());
// 每个传感器都需要同步
twin.updateFuelLevel(spec.getFuelLevel());
twin.updateBatteryStatus(spec.getBatteryVoltage(), spec.getBatteryCurrent());
twin.updateTirePressure(spec.getTirePressures());
PublishTwinEvent twinEvent = new TwinCreatedEvent(twin);
eventBus.publish(twinEvent);
// 注册定时同步任务
startPeriodicSync(twin.getId(), 1, TimeUnit.SECONDS);
return twin;
}
private void startPeriodicSync(String twinId, int initialDelay, TimeUnit unit) {
ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
scheduler.scheduleAtFixedRate(() -> {
try {
syncVehicleStatus(twinId);
} catch (Exception e) {
log.error("Error syncing vehicle data", e);
}
}, initialDelay, 1000, TimeUnit.MILLISECONDS);
}
@Scheduled(fixedDelay = 5000)
public void simulateVehicleConditions() {
// 为每辆注册的数字孪生车辆运行模拟
List<VehicleTwin> vehicles = vehicleTwinRepository.findAll();
for (VehicleTwin vehicle : vehicles) {
SimulationConfig config = buildSimulationConfig(vehicle);
SimulationResult result = simulationEngine.simulate(config);
// 更新孪生车辆的状态
vehicle.setState(result.getState());
vehicle.setGasConsumption(result.getGasConsumption());
vehicle.setPredictedRange(result.getPredictedRange());
vehicle.setFailureRisk(result.getFailureRisk());
// 预测未来的维护需求
if (result.getFailureRisk() > 0.6) {
notificationService.warning("车辆" + vehicle.getId() + "存在高风险故障");
}
// 更新WebSocket前端
webSocketService.sendVehicleUpdate(vehicle);
}
}
public SimulationConfig buildSimulationConfig(VehicleTwin vehicle) {
return SimulationConfig.builder()
.startingLocation(vehicle.getGpsLocation())
.vehicleType(vehicle.getType())
.engineType(vehicle.getEngineType())
.weatherConditions(weatherService.getCurrentWeather(vehicle.getGpsLocation()))
.trafficDensity(trafficService.getTrafficOnRoute(vehicle))
.terrainTerrain(terrainService.getTerrainAt(vehicle.getGpsLocation()))
.build();
}
}
医疗设备数字孪生（智能医疗监控）
@Service
public class MedicalDeviceTwinService {
private final PatientHealthMonitor healthMonitor;
private final DrugInteractionService drugService;
public MedicalDeviceTwin createTwin(String deviceId, PatientRecord patient) {
MedicalDeviceTwin twin = new MedicalDeviceTwin();
twin.setDeviceId(deviceId);
twin.setPatient(patient);
twin.setDeviceType("ventilator"); // 示例：呼吸机
// 初始化传感器数据
twin.setOxygenSaturation(97.0);
twin.setCO2Exhaled(4.0);
twin.setPeakPressure(20.0);
twin.setPEEP(5.0);
twin.setFiO2(30.0);
// 创建自动监控任务
monitorVitals(twin);
monitorDrugInteractions(twin);
return twin;
}
private void monitorVitals(MedicalDeviceTwin twin) {
scheduledTasks.add(
taskScheduler.scheduleAtFixedRate(() -> {
readPatientVitals(twin);
evaluateEmergency(twin);
},
5000) // 每5秒更新
);
}
private void readPatientVitals(MedicalDeviceTwin twin) {
List<PatientVitals> vitals = vitalsRepository
.getLatestPatientVitals(twin.getPatient().getId());
if (!vitals.isEmpty()) {
PatientVitals latest = vitals.get(0);
twin.updateOxygenSaturation(latest.getOxygenSaturation());
twin.updateHeartRate(latest.getHeartRate());
twin.updateBloodPressure(latest.getBloodPressure());
twin.updateTemperature(latest.getTemperature());
// 对比设备数据与患者真实数据
checkDeviceAccuracy(twin, latest);
}
}
private void evaluateEmergency(MedicalDeviceTwin twin) {
boolean criticalHeart = twin.getHeartRate() > 120 || twin.getHeartRate() < 40;
boolean criticalO2 = twin.getOxygenSaturation() < 90;
boolean criticalBP = twin.getBloodPressure().getSystolic() > 180 ||
twin.getBloodPressure().getDiastolic() > 110;
if (criticalHeart || criticalO2 || criticalBP) {
emergencyAlertService.trigger(twin);
}
}
private void checkDeviceAccuracy(MedicalDeviceTwin twin, PatientVitals actual) {
double deviceO2 = twin.getOxygenSaturation();
double actualO2 = actual.getOxygenSaturation();
if (Math.abs(deviceO2 - actualO2) > 5.0) {
// 设备数据与患者实际数据差异过大
alertService.detectDeviceMeltFunction(twin);
}
}
private void monitorDrugInteractions(MedicalDeviceTwin twin) {
// 检查药物相互作用
for (Medication med : twin.getPatient().getMedications()) {
for (DrugInteraction interaction : drugService.getInteractions(med)) {
if (interaction.getSeverity() == HIGH) {
alertService.notifyDrugInteraction(twin, interaction);
}
}
}
}
}
数字孪生公共基础设施
主应用配置
@SpringBootApplication
@EnableScheduling
@EnableAsync
public class DigitalTwinApplication {
public static void main(String[] args) {
SpringApplication.run(DigitalTwinApplication.class, args);
}
}
@Configuration
@EnableScheduling
public class TwinConfiguration {
@Bean
public Executor taskExecutor() {
ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
executor.setCorePoolSize(5);
executor.setMaxPoolSize(10);
executor.setQueueCapacity(100);
executor.setThreadNamePrefix("twin-");
return executor;
}
@Bean
public ObjectMapper objectMapper() {
ObjectMapper mapper = new ObjectMapper();
mapper.registerModule(new JavaTimeModule());
mapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
mapper.setPropertyNamingStrategy(PropertyNamingStrategies.SNAKE_CASE);
return mapper;
}
@Bean
public KafkaProducer<String, String> kafkaProducer() {
Properties props = new Properties();
props.put("bootstrap.servers", "localhost:9092");
props.put("key.serializer",
"org.apache.kafka.common.serialization.StringSerializer");
props.put("value.serializer",
"org.apache.kafka.common.serialization.StringSerializer");
return new KafkaProducer<>(props);
}
}
使用示例
// 创建数字孪生的示例调用
@RestController
@RequestMapping("/api/twin")
public class TwinExampleController {
@Autowired
private DigitalTwinService twinService;
@PostMapping("/create")
public String createTwin(@RequestBody TwinCreationRequest request) {
// 根据类型创建孪生
DigitalTwin twin = twinService.createTwin(
request.getType(),
request.getInitialData()
);
// 开始数据传输
twinService.startTwinDataStream(twin, request.getCallbackUrl());
return twin.getId();
}
@GetMapping("/{id}/status")
public TwinStatus getTwinStatus(@PathVariable String id) {
return twinService.getTwinStatus(id);
}
@PostMapping("/{id}/simulate")
public SimulationResult simulateTwin(
@PathVariable String id,
@RequestBody SimulationRequest request) {
DigitalTwin twin = twinService.getTwin(id);
return twin.simulate(request);
}
}
这些示例展示了Java在中实现数字孪生的核心功能,包括：
- 实时数据同步：通过IoT、MQTT等协议实时获取物理世界数据
- 模型仿真：基于物理模型或机器学习模型模拟系统行为
- 3D可视化：使用Three.js或其他3D引擎呈现虚拟场景
- 实时通信：通过WebSocket推送数据到前端
- 预测分析：利用历史数据和模型预测未来状况
- 优化建议：根据分析结果给出行动建议
实际应用时需要根据具体业务选择合适的技术栈和架构。
