Java数字孪生案例

本文目录导读：

1. 工业设备数字孪生（设备监控与预测维护）
2. 智慧工厂三维可视化数字孪生
3. 智慧城市建筑数字孪生
4. 车辆数字孪生（自动驾驶测试）
5. 医疗设备数字孪生（智能医疗监控）
6. 数字孪生公共基础设施

我将为您提供几个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在中实现数字孪生的核心功能,包括：

1. 实时数据同步：通过IoT、MQTT等协议实时获取物理世界数据
2. 模型仿真：基于物理模型或机器学习模型模拟系统行为
3. 3D可视化：使用Three.js或其他3D引擎呈现虚拟场景
4. 实时通信：通过WebSocket推送数据到前端
5. 预测分析：利用历史数据和模型预测未来状况
6. 优化建议：根据分析结果给出行动建议

实际应用时需要根据具体业务选择合适的技术栈和架构。