Java智能照明联动系统如何实现跨品牌设备无缝协同与场景自动化控制

引言：智能照明系统的挑战与机遇

在当今智能家居快速发展的时代，智能照明系统已经成为现代家庭和商业空间的核心组成部分。然而，用户面临着一个普遍的痛点：不同品牌的智能设备之间存在兼容性壁垒，无法实现真正的无缝协同工作。一个典型的场景是：用户家中可能同时拥有飞利浦Hue的智能灯泡、小米的智能开关、Yeelight的灯带，以及各种通过不同协议（如Zigbee、Wi-Fi、蓝牙）连接的设备。如何通过Java技术栈构建一个能够统一管理这些异构设备、实现场景自动化控制的系统，成为了技术开发者需要解决的关键问题。

跨品牌设备协同的核心挑战在于：

协议异构性：不同厂商使用不同的通信协议和API接口
数据格式不统一：设备状态、控制指令的数据结构各不相同
认证机制差异：各品牌有不同的OAuth、Token管理方式
实时性要求：场景联动需要毫秒级的响应速度

本文将详细介绍如何使用Java构建一个智能照明联动系统，通过抽象层设计、适配器模式、规则引擎等技术手段，实现跨品牌设备的无缝集成和场景自动化控制。

系统架构设计

整体架构概述

一个健壮的智能照明联动系统应该采用分层架构设计，确保各层职责清晰、易于扩展。典型的架构包括：

┌─────────────────────────────────────────────────┐ │ 应用层 (Application Layer) │ │ - 场景管理器、自动化规则引擎、用户界面 │ ├─────────────────────────────────────────────────┤ │ 服务层 (Service Layer) │ │ - 设备管理服务、联动服务、定时任务服务 │ ├─────────────────────────────────────────────────┤ │ 核心层 (Core Layer) │ │ - 设备抽象层、协议适配器、事件总线 │ ├─────────────────────────────────────────────────┤ │ 适配器层 (Adapter Layer) │ │ - 飞利浦Hue适配器、小米适配器、Yeelight适配器 │ ├─────────────────────────────────────────────────┤ │ 通信层 (Communication Layer) │ │ - HTTP客户端、MQTT客户端、WebSocket连接器 │ └─────────────────────────────────────────────────┘

关键设计模式

适配器模式 (Adapter Pattern)：为每个品牌设备提供统一的接口实现
策略模式 (Strategy Pattern)：根据不同设备类型选择不同的控制策略
观察者模式 (Observer Pattern)：实现设备状态变化的实时监听
工厂模式 (Factory Pattern)：动态创建设备实例

核心技术实现

1. 设备抽象层设计

首先，我们需要定义一个统一的设备抽象接口，所有具体设备实现都必须遵循这个接口：

// 设备基础接口 - 定义所有智能设备必须实现的核心操作 public interface SmartDevice { /** * 获取设备唯一标识 */ String getDeviceId(); /** * 获取设备名称 */ String getDeviceName(); /** * 获取设备类型 */ DeviceType getDeviceType(); /** * 获取设备品牌 */ String getBrand(); /** * 获取设备当前状态 */ DeviceState getDeviceState(); /** * 设置设备状态 * @param state 目标状态 * @return 操作结果 */ boolean setState(DeviceState state); /** * 刷新设备状态（从实际设备获取最新状态） */ void refreshState(); /** * 检查设备是否在线 */ boolean isOnline(); } // 照明设备特有接口 public interface SmartLight extends SmartDevice { /** * 设置亮度 (0-100) */ boolean setBrightness(int brightness); /** * 设置色温 (2700K-6500K) */ boolean setColorTemperature(int temperature); /** * 设置RGB颜色 */ boolean setColor(int red, int green, int blue); /** * 开启/关闭 */ boolean turnOn(); boolean turnOff(); /** * 获取当前亮度 */ int getBrightness(); /** * 获取当前色温 */ int getColorTemperature(); } // 设备状态类 public class DeviceState { private boolean powerOn; private int brightness; // 0-100 private int colorTemperature; // 2700-6500K private Color color; // RGB颜色 private Map<String, Object> extraProperties; // 构造函数、getter/setter省略 public DeviceState() { this.extraProperties = new HashMap<>(); } // 辅助方法 public void setExtraProperty(String key, Object value) { extraProperties.put(key, value); } public Object getExtraProperty(String key) { return extraProperties.get(key); } } // 设备类型枚举 public enum DeviceType { SMART_BULB, // 智能灯泡 SMART_SWITCH, // 智能开关 SMART_STRIP, // 灯带 SMART_SPOT, // 射灯 OTHER // 其他 }

2. 适配器层实现 - 以飞利浦Hue为例

飞利浦Hue使用RESTful API进行通信，我们需要创建一个适配器来封装其特定的API调用：

import com.fasterxml.jackson.databind.JsonNode; import com.fasterxml.jackson.databind.ObjectMapper; import java.net.URI; import java.net.http.HttpClient; import java.net.http.HttpRequest; import java.net.http.HttpResponse; import java.time.Duration; /** * 飞利浦Hue设备适配器 * 实现SmartLight接口，封装Hue Bridge的REST API调用 */ public class HueLightAdapter implements SmartLight { private final String bridgeIp; private final String username; private final String lightId; private final HttpClient httpClient; private final ObjectMapper objectMapper; private DeviceState currentState; private boolean online; public HueLightAdapter(String bridgeIp, String username, String lightId) { this.bridgeIp = bridgeIp; this.username = username; this.lightId = lightId; this.httpClient = HttpClient.newBuilder() .connectTimeout(Duration.ofSeconds(10)) .build(); this.objectMapper = new ObjectMapper(); this.currentState = new DeviceState(); this.online = false; } @Override public String getDeviceId() { return "hue_" + lightId; } @Override public String getDeviceName() { return "Hue Light " + lightId; } @Override public DeviceType getDeviceType() { return DeviceType.SMART_BULB; } @Override public String getBrand() { return "Philips Hue"; } @Override public DeviceState getDeviceState() { return currentState; } @Override public boolean setState(DeviceState state) { try { // 构建Hue API需要的JSON格式 ObjectNode requestBody = objectMapper.createObjectNode(); if (state.isPowerOn() != currentState.isPowerOn()) { requestBody.put("on", state.isPowerOn()); } if (state.getBrightness() != currentState.getBrightness()) { // Hue亮度范围是0-254，需要转换 int hueBrightness = (int) (state.getBrightness() * 254.0 / 100); requestBody.put("bri", hueBrightness); } if (state.getColorTemperature() != currentState.getColorTemperature()) { // 色温转换：2700K-6500K -> 153-500 (Hue ct范围) int hueCT = convertKelvinToHueCT(state.getColorTemperature()); requestBody.put("ct", hueCT); } if (state.getColor() != null && !state.getColor().equals(currentState.getColor())) { // RGB转XY颜色空间 float[] xy = rgbToXY(state.getColor()); ArrayNode xyArray = objectMapper.createArrayNode(); xyArray.add(xy[0]); xyArray.add(xy[1]); requestBody.set("xy", xyArray); } // 发送PUT请求到Hue Bridge String url = String.format("http://%s/api/%s/lights/%s/state", bridgeIp, username, lightId); HttpRequest request = HttpRequest.newBuilder() .uri(URI.create(url)) .header("Content-Type", "application/json") .PUT(HttpRequest.BodyPublishers.ofString(requestBody.toString())) .build(); HttpResponse<String> response = httpClient.send(request, HttpResponse.BodyHandlers.ofString()); if (response.statusCode() == 200) { // 更新本地状态缓存 this.currentState = state; return true; } return false; } catch (Exception e) { System.err.println("Error setting Hue light state: " + e.getMessage()); return false; } } @Override public void refreshState() { try { String url = String.format("http://%s/api/%s/lights/%s", bridgeIp, username, lightId); HttpRequest request = HttpRequest.newBuilder() .uri(URI.create(url)) .GET() .build(); HttpResponse<String> response = httpClient.send(request, HttpResponse.BodyHandlers.ofString()); if (response.statusCode() == 200) { JsonNode root = objectMapper.readTree(response.body()); JsonNode stateNode = root.path("state"); // 解析状态 boolean on = stateNode.path("on").asBoolean(); int bri = stateNode.path("bri").asInt(0); int ct = stateNode.path("ct").asInt(0); // 转换为统一格式 currentState.setPowerOn(on); currentState.setBrightness((int) (bri * 100.0 / 254)); currentState.setColorTemperature(convertHueCTToKelvin(ct)); this.online = true; } else { this.online = false; } } catch (Exception e) { System.err.println("Error refreshing Hue light state: " + e.getMessage()); this.online = false; } } @Override public boolean isOnline() { return online; } // 照明特有方法实现 @Override public boolean setBrightness(int brightness) { DeviceState newState = new DeviceState(); newState.setPowerOn(true); newState.setBrightness(brightness); return setState(newState); } @Override public boolean setColorTemperature(int temperature) { DeviceState newState = new DeviceState(); newState.setPowerOn(true); newState.setColorTemperature(temperature); return setState(newState); } @Override public boolean setColor(int red, int green, int blue) { DeviceState newState = new DeviceState(); newState.setPowerOn(true); newState.setColor(new Color(red, green, blue)); return setState(newState); } @Override public boolean turnOn() { DeviceState newState = new DeviceState(); newState.setPowerOn(true); return setState(newState); } @Override public boolean turnOff() { DeviceState newState = new DeviceState(); newState.setPowerOn(false); return setState(newState); } @Override public int getBrightness() { return currentState.getBrightness(); } @Override public int getColorTemperature() { return currentState.getColorTemperature(); } // 辅助方法：色温转换 private int convertKelvinToHueCT(int kelvin) { // Hue ct范围：153 (6500K) 到 500 (2222K) // 线性插值 if (kelvin >= 6500) return 153; if (kelvin <= 2222) return 500; double ratio = (kelvin - 2222) / (6500 - 2222); return 500 - (int) (ratio * (500 - 153)); } private int convertHueCTToKelvin(int hueCT) { if (hueCT <= 153) return 6500; if (hueCT >= 500) return 2222; double ratio = (500 - hueCT) / (500 - 153); return 2222 + (int) (ratio * (6500 - 2222)); } // RGB转XY颜色空间（简化版） private float[] rgbToXY(Color color) { // 这里使用简化的转换，实际项目中应使用更精确的转换公式 double r = color.getRed() / 255.0; double g = color.getGreen() / 255.0; double b = color.getBlue() / 255.0; // 简化的XYZ转换 double x = 0.4124 * r + 0.3576 * g + 0.1805 * b; double y = 0.2126 * r + 0.7152 * g + 0.0722 * b; double z = 0.0193 * r + 0.1192 * g + 0.9505 * b; double sum = x + y + z; if (sum == 0) return new float[]{0, 0}; return new float[]{(float) (x / sum), (float) (y / sum)}; } }

3. 小米设备适配器实现

小米设备通常使用局域网HTTP API或MQTT协议，这里展示HTTP方式的适配器：

/** * 小米智能设备适配器 * 支持小米智能灯泡、开关等设备 */ public class XiaomiLightAdapter implements SmartLight { private final String deviceId; private final String ip; private final String token; private final HttpClient httpClient; private final ObjectMapper objectMapper; private DeviceState currentState; private boolean online; public XiaomiLightAdapter(String deviceId, String ip, String token) { this.deviceId = deviceId; this.ip = ip; this.token = token; this.httpClient = HttpClient.newBuilder() .connectTimeout(Duration.ofSeconds(5)) .build(); this.objectMapper = new ObjectMapper(); this.currentState = new DeviceState(); this.online = false; } @Override public String getDeviceId() { return "xiaomi_" + deviceId; } @Override public String getDeviceName() { return "Xiaomi Light " + deviceId; } @Override public DeviceType getDeviceType() { return DeviceType.SMART_BULB; } @Override public String getBrand() { return "Xiaomi"; } @Override public DeviceState getDeviceState() { return currentState; } @Override public boolean setState(DeviceState state) { try { // 小米设备使用miio协议，需要构建特定的JSON-RPC格式 ObjectNode payload = objectMapper.createObjectNode(); payload.put("id", System.currentTimeMillis()); payload.put("method", "set_power"); ArrayNode params = objectMapper.createArrayNode(); params.add(state.isPowerOn() ? "on" : "off"); // 如果需要设置亮度 if (state.getBrightness() != currentState.getBrightness()) { // 小米亮度范围0-100 params.add("brightness"); params.add(state.getBrightness()); } payload.set("params", params); String url = String.format("http://%s:54321/rpc", ip); HttpRequest request = HttpRequest.newBuilder() .uri(URI.create(url)) .header("Content-Type", "application/json") .POST(HttpRequest.BodyPublishers.ofString(payload.toString())) .build(); HttpResponse<String> response = httpClient.send(request, HttpResponse.BodyHandlers.ofString()); if (response.statusCode() == 200) { JsonNode responseNode = objectMapper.readTree(response.body()); if (responseNode.has("result") && responseNode.get("result").asText().equals("ok")) { this.currentState = state; return true; } } return false; } catch (Exception e) { System.err.println("Error setting Xiaomi light state: " + e.getMessage()); return false; } } @Override public void refreshState() { try { // 查询设备状态 ObjectNode payload = objectMapper.createObjectNode(); payload.put("id", System.currentTimeMillis()); payload.put("method", "get_prop"); ArrayNode params = objectMapper.createArrayNode(); params.add("power"); params.add("bright"); params.add("color_mode"); payload.set("params", params); String url = String.format("http://%s:54321/rpc", ip); HttpRequest request = HttpRequest.newBuilder() .uri(URI.create(url)) .header("Content-Type", "application/json") .POST(HttpRequest.BodyPublishers.ofString(payload.toString())) .build(); HttpResponse<String> response = httpClient.send(request, HttpResponse.BodyHandlers.ofString()); if (response.statusCode() == 200) { JsonNode responseNode = objectMapper.readTree(response.body()); if (responseNode.has("result")) { JsonNode result = responseNode.get("result"); boolean power = result.get(0).asText().equals("on"); int bright = result.get(1).asInt(0); currentState.setPowerOn(power); currentState.setBrightness(bright); this.online = true; } } else { this.online = false; } } catch (Exception e) { System.err.println("Error refreshing Xiaomi light state: " + e.getMessage()); this.online = false; } } @Override public boolean isOnline() { return online; } // 照明特有方法实现 @Override public boolean setBrightness(int brightness) { DeviceState newState = new DeviceState(); newState.setPowerOn(true); newState.setBrightness(brightness); return setState(newState); } @Override public boolean setColorTemperature(int temperature) { // 小米部分设备支持色温，这里简化处理 DeviceState newState = new DeviceState(); newState.setPowerOn(true); newState.setColorTemperature(temperature); return setState(newState); } @Override public boolean setColor(int red, int green, int blue) { // 小米部分设备支持RGB，需要转换为特定格式 DeviceState newState = new DeviceState(); newState.setPowerOn(true); newState.setColor(new Color(red, green, blue)); return setState(newState); } @Override public boolean turnOn() { DeviceState newState = new DeviceState(); newState.setPowerOn(true); return setState(newState); } @Override public boolean turnOff() { DeviceState newState = new DeviceState(); newState.setPowerOn(false); return setState(newState); } @Override public int getBrightness() { return currentState.getBrightness(); } @Override public int getColorTemperature() { return currentState.getColorTemperature(); } }

4. 设备工厂与注册中心

为了统一管理所有设备实例，我们需要一个设备工厂和注册中心：

/** * 设备工厂 - 负责创建各种品牌的设备适配器 */ public class DeviceFactory { private static DeviceFactory instance; private final Map<String, DeviceCreator> creators; private DeviceFactory() { this.creators = new HashMap<>(); // 注册各品牌设备创建器 registerCreator("philips_hue", new HueDeviceCreator()); registerCreator("xiaomi", new XiaomiDeviceCreator()); registerCreator("yeelight", new YeelightDeviceCreator()); } public static DeviceFactory getInstance() { if (instance == null) { instance = new DeviceFactory(); } return instance; } public void registerCreator(String brand, DeviceCreator creator) { creators.put(brand, creator); } /** * 创建设备实例 * @param brand 品牌标识 * @param config 设备配置信息 * @return 设备实例 */ public SmartDevice createDevice(String brand, DeviceConfig config) { DeviceCreator creator = creators.get(brand); if (creator == null) { throw new IllegalArgumentException("Unsupported brand: " + brand); } return creator.create(config); } // 设备创建器接口 public interface DeviceCreator { SmartDevice create(DeviceConfig config); } // 飞利浦Hue设备创建器 private static class HueDeviceCreator implements DeviceCreator { @Override public SmartDevice create(DeviceConfig config) { String bridgeIp = config.getString("bridgeIp"); String username = config.getString("username"); String lightId = config.getString("lightId"); return new HueLightAdapter(bridgeIp, username, lightId); } } // 小米设备创建器 private static class XiaomiDeviceCreator implements DeviceCreator { @Override public SmartDevice create(DeviceConfig config) { String deviceId = config.getString("deviceId"); String ip = config.getString("ip"); String token = config.getString("token"); return new XiaomiLightAdapter(deviceId, ip, token); } } // Yeelight设备创建器（简化实现） private static class YeelightDeviceCreator implements DeviceCreator { @Override public SmartDevice create(DeviceConfig config) { String ip = config.getString("ip"); int port = config.getInt("port", 55443); return new YeelightAdapter(ip, port); } } } /** * 设备配置类 - 封装设备初始化所需信息 */ public class DeviceConfig { private final Map<String, Object> properties; public DeviceConfig() { this.properties = new HashMap<>(); } public DeviceConfig set(String key, Object value) { properties.put(key, value); return this; } public Object get(String key) { return properties.get(key); } public String getString(String key) { Object value = get(key); return value != null ? value.toString() : null; } public int getInt(String key) { Object value = get(key); return value != null ? Integer.parseInt(value.toString()) : 0; } public boolean getBoolean(String key) { Object value = get(key); return value != null && Boolean.parseBoolean(value.toString()); } } /** * 设备注册中心 - 管理所有已注册的设备 */ public class DeviceRegistry { private final Map<String, SmartDevice> devices; private final DeviceFactory deviceFactory; public DeviceRegistry() { this.devices = new ConcurrentHashMap<>(); this.deviceFactory = DeviceFactory.getInstance(); } /** * 注册设备 */ public void registerDevice(String deviceId, SmartDevice device) { devices.put(deviceId, device); } /** * 根据配置创建并注册设备 */ public SmartDevice registerDevice(String brand, DeviceConfig config) { SmartDevice device = deviceFactory.createDevice(brand, config); registerDevice(device.getDeviceId(), device); return device; } /** * 获取设备 */ public SmartDevice getDevice(String deviceId) { return devices.get(deviceId); } /** * 获取所有设备 */ public Collection<SmartDevice> getAllDevices() { return devices.values(); } /** * 根据品牌获取设备 */ public List<SmartDevice> getDevicesByBrand(String brand) { return devices.values().stream() .filter(d -> d.getBrand().equals(brand)) .collect(Collectors.toList()); } /** * 移除设备 */ public void removeDevice(String deviceId) { devices.remove(deviceId); } /** * 获取设备数量 */ public int getDeviceCount() { return devices.size(); } }

5. 场景自动化控制引擎

场景自动化是智能照明系统的核心功能，需要支持复杂的规则定义和执行：

/** * 场景定义 - 描述一个照明场景 */ public class LightingScene { private String sceneId; private String sceneName; private List<DeviceAction> actions; private Trigger trigger; public LightingScene(String sceneId, String sceneName) { this.sceneId = sceneId; this.sceneName = sceneName; this.actions = new ArrayList<>(); } public void addAction(DeviceAction action) { actions.add(action); } // Getter/Setter省略 public String getSceneId() { return sceneId; } public String getSceneName() { return sceneName; } public List<DeviceAction> getActions() { return actions; } public Trigger getTrigger() { return trigger; } public void setTrigger(Trigger trigger) { this.trigger = trigger; } } /** * 设备动作 - 描述对单个设备的具体操作 */ public class DeviceAction { private String deviceId; private DeviceState targetState; private int delayMs; // 延迟执行时间（毫秒） public DeviceAction(String deviceId, DeviceState targetState) { this.deviceId = deviceId; this.targetState = targetState; this.delayMs = 0; } public DeviceAction(String deviceId, DeviceState targetState, int delayMs) { this.deviceId = deviceId; this.targetState = targetState; this.delayMs = delayMs; } // Getter/Setter省略 public String getDeviceId() { return deviceId; } public DeviceState getTargetState() { return targetState; } public int getDelayMs() { return delayMs; } } /** * 触发器基类 */ public abstract class Trigger { private String triggerId; private String triggerType; public Trigger(String triggerId, String triggerType) { this.triggerId = triggerId; this.triggerType = triggerType; } public abstract boolean isTriggered(); public abstract void evaluate(); // Getter省略 public String getTriggerId() { return triggerId; } public String getTriggerType() { return triggerType; } } /** * 时间触发器 - 基于定时规则触发场景 */ public class TimeTrigger extends Trigger { private final CronExpression cronExpression; private final TimeZone timeZone; private LocalDateTime lastTriggerTime; public TimeTrigger(String triggerId, String cronExpression) { super(triggerId, "TIME"); this.cronExpression = new CronExpression(cronExpression); this.timeZone = TimeZone.getDefault(); this.lastTriggerTime = null; } @Override public boolean isTriggered() { LocalDateTime now = LocalDateTime.now(); if (lastTriggerTime != null && lastTriggerTime.toLocalDate().equals(now.toLocalDate()) && lastTriggerTime.toLocalTime().getHour() == now.toLocalTime().getHour() && lastTriggerTime.toLocalTime().getMinute() == now.toLocalTime().getMinute()) { return false; // 避免同一分钟重复触发 } Date date = Date.from(now.atZone(ZoneId.systemDefault()).toInstant()); return cronExpression.isSatisfiedBy(date); } @Override public void evaluate() { if (isTriggered()) { lastTriggerTime = LocalDateTime.now(); // 触发场景执行 SceneExecutor.getInstance().executeTriggeredScene(this); } } } /** * 传感器触发器 - 基于传感器数据触发 */ public class SensorTrigger extends Trigger { private final String sensorId; private final String condition; // "gt", "lt", "eq", "between" private final double threshold; private final double threshold2; // 用于between条件 public SensorTrigger(String triggerId, String sensorId, String condition, double threshold) { super(triggerId, "SENSOR"); this.sensorId = sensorId; this.condition = condition; this.threshold = threshold; this.threshold2 = 0; } public SensorTrigger(String triggerId, String sensorId, String condition, double threshold, double threshold2) { super(triggerId, "SENSOR"); this.sensorId = sensorId; this.condition = condition; this.threshold = threshold; this.threshold2 = threshold2; } @Override public boolean isTriggered() { // 实际应用中需要从传感器服务获取数据 double sensorValue = SensorService.getInstance().getSensorValue(sensorId); switch (condition) { case "gt": return sensorValue > threshold; case "lt": return sensorValue < threshold; case "eq": return Math.abs(sensorValue - threshold) < 0.001; case "between": return sensorValue >= threshold && sensorValue <= threshold2; default: return false; } } @Override public void evaluate() { if (isTriggered()) { SceneExecutor.getInstance().executeTriggeredScene(this); } } } /** * 场景执行器 - 负责执行场景动作 */ public class SceneExecutor { private static SceneExecutor instance; private final DeviceRegistry deviceRegistry; private final ExecutorService executorService; private SceneExecutor() { this.deviceRegistry = new DeviceRegistry(); this.executorService = Executors.newCachedThreadPool(); } public static SceneExecutor getInstance() { if (instance == null) { instance = new SceneExecutor(); } return instance; } /** * 执行场景 */ public void executeScene(LightingScene scene) { System.out.println("Executing scene: " + scene.getSceneName()); for (DeviceAction action : scene.getActions()) { executorService.submit(() -> { try { // 延迟执行 if (action.getDelayMs() > 0) { Thread.sleep(action.getDelayMs()); } SmartDevice device = deviceRegistry.getDevice(action.getDeviceId()); if (device != null && device.isOnline()) { boolean success = device.setState(action.getTargetState()); if (success) { System.out.println("Successfully executed action on device: " + action.getDeviceId()); } else { System.err.println("Failed to execute action on device: " + action.getDeviceId()); } } else { System.err.println("Device not found or offline: " + action.getDeviceId()); } } catch (Exception e) { System.err.println("Error executing action: " + e.getMessage()); } }); } } /** * 执行触发的场景 */ public void executeTriggeredScene(Trigger trigger) { // 查找关联的场景并执行 SceneRegistry sceneRegistry = SceneRegistry.getInstance(); LightingScene scene = sceneRegistry.getSceneByTrigger(trigger.getTriggerId()); if (scene != null) { executeScene(scene); } } } /** * 场景注册中心 - 管理所有场景和触发器 */ public class SceneRegistry { private static SceneRegistry instance; private final Map<String, LightingScene> scenes; private final Map<String, Trigger> triggers; private final Map<String, String> triggerToSceneMap; // triggerId -> sceneId private SceneRegistry() { this.scenes = new ConcurrentHashMap<>(); this.triggers = new ConcurrentHashMap<>(); this.triggerToSceneMap = new ConcurrentHashMap<>(); } public static SceneRegistry getInstance() { if (instance == null) { instance = new SceneRegistry(); } return instance; } public void registerScene(LightingScene scene) { scenes.put(scene.getSceneId(), scene); if (scene.getTrigger() != null) { Trigger trigger = scene.getTrigger(); triggers.put(trigger.getTriggerId(), trigger); triggerToSceneMap.put(trigger.getTriggerId(), scene.getSceneId()); } } public LightingScene getScene(String sceneId) { return scenes.get(sceneId); } public LightingScene getSceneByTrigger(String triggerId) { String sceneId = triggerToSceneMap.get(triggerId); return sceneId != null ? scenes.get(sceneId) : null; } public void removeScene(String sceneId) { LightingScene scene = scenes.remove(sceneId); if (scene != null && scene.getTrigger() != null) { String triggerId = scene.getTrigger().getTriggerId(); triggers.remove(triggerId); triggerToSceneMap.remove(triggerId); } } public Collection<LightingScene> getAllScenes() { return scenes.values(); } public Collection<Trigger> getAllTriggers() { return triggers.values(); } }

6. 事件总线与状态监控

为了实现实时响应和状态同步，我们需要一个事件总线系统：

/** * 设备事件 - 封装设备状态变化信息 */ public class DeviceEvent { private final String deviceId; private final DeviceState oldState; private final DeviceState newState; private final long timestamp; public DeviceEvent(String deviceId, DeviceState oldState, DeviceState newState) { this.deviceId = deviceId; this.oldState = oldState; this.newState = newState; this.timestamp = System.currentTimeMillis(); } // Getter省略 public String getDeviceId() { return deviceId; } public DeviceState getOldState() { return oldState; } public DeviceState getNewState() { return newState; } public long getTimestamp() { return timestamp; } } /** * 事件监听器接口 */ public interface DeviceEventListener { void onDeviceEvent(DeviceEvent event); } /** * 事件总线 - 发布/订阅模式实现 */ public class EventBus { private static EventBus instance; private final Map<String, List<DeviceEventListener>> listeners; private EventBus() { this.listeners = new ConcurrentHashMap<>(); } public static EventBus getInstance() { if (instance == null) { instance = new EventBus(); } return instance; } /** * 订阅设备事件 */ public void subscribe(String deviceId, DeviceEventListener listener) { listeners.computeIfAbsent(deviceId, k -> new CopyOnWriteArrayList<>()).add(listener); } /** * 取消订阅 */ public void unsubscribe(String deviceId, DeviceEventListener listener) { List<DeviceEventListener> deviceListeners = listeners.get(deviceId); if (deviceListeners != null) { deviceListeners.remove(listener); } } /** * 发布事件 */ public void publish(DeviceEvent event) { List<DeviceEventListener> deviceListeners = listeners.get(event.getDeviceId()); if (deviceListeners != null) { for (DeviceEventListener listener : deviceListeners) { try { listener.onDeviceEvent(event); } catch (Exception e) { System.err.println("Error in event listener: " + e.getMessage()); } } } // 通知全局监听器 List<DeviceEventListener> globalListeners = listeners.get("*"); if (globalListeners != null) { for (DeviceEventListener listener : globalListeners) { try { listener.onDeviceEvent(event); } catch (Exception e) { System.err.println("Error in global event listener: " + e.getMessage()); } } } } /** * 订阅所有设备事件 */ public void subscribeAll(DeviceEventListener listener) { subscribe("*", listener); } } /** * 设备状态监控器 - 定期检查设备状态并发布事件 */ public class DeviceStateMonitor { private final DeviceRegistry deviceRegistry; private final EventBus eventBus; private final ScheduledExecutorService scheduler; private final Map<String, DeviceState> lastStates; public DeviceStateMonitor() { this.deviceRegistry = new DeviceRegistry(); this.eventBus = EventBus.getInstance(); this.scheduler = Executors.newScheduledThreadPool(2); this.lastStates = new ConcurrentHashMap<>(); } /** * 启动监控 */ public void startMonitoring() { // 每5秒检查一次设备状态 scheduler.scheduleAtFixedRate(this::checkAllDevices, 0, 5, TimeUnit.SECONDS); // 每分钟刷新一次所有设备状态 scheduler.scheduleAtFixedRate(this::refreshAllDevices, 1, 1, TimeUnit.MINUTES); } /** * 停止监控 */ public void stopMonitoring() { scheduler.shutdown(); } private void checkAllDevices() { for (SmartDevice device : deviceRegistry.getAllDevices()) { checkDevice(device); } } private void checkDevice(SmartDevice device) { String deviceId = device.getDeviceId(); DeviceState currentState = device.getDeviceState(); DeviceState lastState = lastStates.get(deviceId); // 检测状态变化 if (lastState != null && !lastState.equals(currentState)) { DeviceEvent event = new DeviceEvent(deviceId, lastState, currentState); eventBus.publish(event); } // 更新最后状态 lastStates.put(deviceId, currentState); } private void refreshAllDevices() { for (SmartDevice device : deviceRegistry.getAllDevices()) { try { device.refreshState(); } catch (Exception e) { System.err.println("Error refreshing device " + device.getDeviceId() + ": " + e.getMessage()); } } } }

7. 完整的系统集成示例

下面是一个完整的示例，展示如何将所有组件集成在一起，创建一个可运行的智能照明系统：

/** * 智能照明联动系统主类 * 演示跨品牌设备集成和场景自动化 */ public class SmartLightingSystem { private final DeviceRegistry deviceRegistry; private final SceneRegistry sceneRegistry; private final SceneExecutor sceneExecutor; private final EventBus eventBus; private final DeviceStateMonitor stateMonitor; public SmartLightingSystem() { this.deviceRegistry = new DeviceRegistry(); this.sceneRegistry = SceneRegistry.getInstance(); this.sceneExecutor = SceneExecutor.getInstance(); this.eventBus = EventBus.getInstance(); this.stateMonitor = new DeviceStateMonitor(); } /** * 初始化系统 - 注册设备和场景 */ public void initialize() { // 1. 注册飞利浦Hue设备 DeviceConfig hueConfig = new DeviceConfig() .set("bridgeIp", "192.168.1.100") .set("username", "your-hue-username") .set("lightId", "1"); SmartDevice hueLight = deviceRegistry.registerDevice("philips_hue", hueConfig); System.out.println("Registered Hue Light: " + hueLight.getDeviceId()); // 2. 注册小米设备 DeviceConfig xiaomiConfig = new DeviceConfig() .set("deviceId", "xiaomi_light_01") .set("ip", "192.168.1.101") .set("token", "your-xiaomi-token"); SmartDevice xiaomiLight = deviceRegistry.registerDevice("xiaomi", xiaomiConfig); System.out.println("Registered Xiaomi Light: " + xiaomiLight.getDeviceId()); // 3. 注册Yeelight设备 DeviceConfig yeelightConfig = new DeviceConfig() .set("ip", "192.168.1.102") .set("port", 55443); SmartDevice yeelightStrip = deviceRegistry.registerDevice("yeelight", yeelightConfig); System.out.println("Registered Yeelight Strip: " + yeelightStrip.getDeviceId()); // 4. 创建"回家模式"场景 LightingScene homeScene = new LightingScene("home_mode", "回家模式"); // 客厅Hue灯：开启，亮度80%，色温4000K DeviceState hueState = new DeviceState(); hueState.setPowerOn(true); hueState.setBrightness(80); hueState.setColorTemperature(4000); homeScene.addAction(new DeviceAction(hueLight.getDeviceId(), hueState, 0)); // 小米灯：开启，亮度60% DeviceState xiaomiState = new DeviceState(); xiaomiState.setPowerOn(true); xiaomiState.setBrightness(60); homeScene.addAction(new DeviceAction(xiaomiLight.getDeviceId(), xiaomiState, 200)); // Yeelight灯带：开启，RGB蓝色 DeviceState yeelightState = new DeviceState(); yeelightState.setPowerOn(true); yeelightState.setColor(0, 100, 255); homeScene.addAction(new DeviceAction(yeelightStrip.getDeviceId(), yeelightState, 400)); // 设置时间触发器：每天18:00自动执行 TimeTrigger homeTrigger = new TimeTrigger("home_trigger", "0 0 18 * * ?"); homeScene.setTrigger(homeTrigger); sceneRegistry.registerScene(homeScene); // 5. 创建"睡眠模式"场景 LightingScene sleepScene = new LightingScene("sleep_mode", "睡眠模式"); // 所有设备渐暗并关闭 DeviceState offState = new DeviceState(); offState.setPowerOn(false); offState.setBrightness(0); sleepScene.addAction(new DeviceAction(hueLight.getDeviceId(), offState, 0)); sleepScene.addAction(new DeviceAction(xiaomiLight.getDeviceId(), offState, 500)); sleepScene.addAction(new DeviceAction(yeelightStrip.getDeviceId(), offState, 1000)); // 设置传感器触发器：当卧室传感器检测到用户躺下时触发 SensorTrigger sleepTrigger = new SensorTrigger("sleep_trigger", "bed_sensor", "gt", 0.5); sleepScene.setTrigger(sleepTrigger); sceneRegistry.registerScene(sleepScene); // 6. 注册全局事件监听器（可选） eventBus.subscribeAll(event -> { System.out.printf("[EVENT] Device %s changed: %s -> %s%n", event.getDeviceId(), event.getOldState().isPowerOn() ? "ON" : "OFF", event.getNewState().isPowerOn() ? "ON" : "OFF"); }); // 7. 启动状态监控 stateMonitor.startMonitoring(); // 8. 启动触发器监控线程 startTriggerMonitor(); System.out.println("Smart Lighting System initialized successfully!"); System.out.println("Registered devices: " + deviceRegistry.getDeviceCount()); System.out.println("Registered scenes: " + sceneRegistry.getAllScenes().size()); System.out.println("Registered triggers: " + sceneRegistry.getAllTriggers().size()); } /** * 启动触发器监控线程 */ private void startTriggerMonitor() { ScheduledExecutorService triggerMonitor = Executors.newScheduledThreadPool(1); triggerMonitor.scheduleAtFixedRate(() -> { for (Trigger trigger : sceneRegistry.getAllTriggers()) { try { trigger.evaluate(); } catch (Exception e) { System.err.println("Error evaluating trigger " + trigger.getTriggerId() + ": " + e.getMessage()); } } }, 0, 1, TimeUnit.MINUTES); } /** * 手动执行场景 */ public void executeScene(String sceneId) { LightingScene scene = sceneRegistry.getScene(sceneId); if (scene != null) { sceneExecutor.executeScene(scene); } else { System.err.println("Scene not found: " + sceneId); } } /** * 手动控制单个设备 */ public void controlDevice(String deviceId, DeviceState state) { SmartDevice device = deviceRegistry.getDevice(deviceId); if (device != null) { device.setState(state); } else { System.err.println("Device not found: " + deviceId); } } /** * 获取所有设备状态 */ public void printAllDeviceStatus() { System.out.println("n=== 当前所有设备状态 ==="); for (SmartDevice device : deviceRegistry.getAllDevices()) { DeviceState state = device.getDeviceState(); System.out.printf("Device: %s (%s) - Power: %s, Brightness: %d%%%n", device.getDeviceName(), device.getBrand(), state.isPowerOn() ? "ON" : "OFF", state.getBrightness()); } } /** * 关闭系统 */ public void shutdown() { stateMonitor.stopMonitoring(); System.out.println("Smart Lighting System shutdown."); } /** * 主方法 - 演示系统运行 */ public static void main(String[] args) { SmartLightingSystem system = new SmartLightingSystem(); try { // 初始化系统 system.initialize(); // 等待几秒让系统稳定 Thread.sleep(2000); // 打印初始状态 system.printAllDeviceStatus(); // 手动执行"回家模式"场景 System.out.println("n=== 执行回家模式 ==="); system.executeScene("home_mode"); // 等待场景执行完成 Thread.sleep(2000); // 打印执行后状态 system.printAllDeviceStatus(); // 手动控制单个设备 System.out.println("n=== 手动控制小米灯 ==="); DeviceState manualState = new DeviceState(); manualState.setPowerOn(true); manualState.setBrightness(30); manualState.setColorTemperature(3000); system.controlDevice("xiaomi_xiaomi_light_01", manualState); Thread.sleep(1000); system.printAllDeviceStatus(); // 模拟触发传感器（用于测试睡眠模式） System.out.println("n=== 模拟传感器触发睡眠模式 ==="); // 这里需要实际设置传感器数据，仅作演示 System.out.println("（实际运行时，当bed_sensor > 0.5时会自动触发睡眠模式）"); // 保持程序运行以监控事件 System.out.println("n=== 系统运行中，按Ctrl+C退出 ==="); Thread.sleep(30000); // 运行30秒 } catch (Exception e) { e.printStackTrace(); } finally { system.shutdown(); } } }

高级功能扩展

1. 规则引擎支持

对于更复杂的自动化场景，可以集成规则引擎：

// 使用Easy Rules或Drools等规则引擎 public class RuleEngine { private final RulesEngine rulesEngine; public RuleEngine() { this.rulesEngine = new DefaultRulesEngine(); } public void registerRule(Rule rule) { // 注册规则 } public void fireRules(Facts facts) { rulesEngine.fire(facts); } }

2. 机器学习优化

可以使用机器学习算法优化照明策略：

// 简化的用户习惯学习 public class UserHabitLearner { private final Map<String, List<TimeSeriesData>> userPatterns; public void recordAction(String userId, String sceneId, LocalDateTime time) { // 记录用户行为 } public LightingScene suggestScene(String userId, LocalDateTime time) { // 基于历史数据推荐场景 return null; } }

3. 云集成与远程控制

// 云服务集成示例 public class CloudIntegration { private final WebSocketClient webSocketClient; public void connectToCloud() { // 建立WebSocket连接，实现远程控制 } public void sendDeviceUpdate(DeviceEvent event) { // 向云端推送设备状态变化 } }

性能优化与最佳实践

1. 连接池管理

// HTTP连接池优化 public class HttpClientPool { private final CloseableHttpClient httpClient; public HttpClientPool() { PoolingHttpClientConnectionManager cm = new PoolingHttpClientConnectionManager(); cm.setMaxTotal(100); cm.setDefaultMaxPerRoute(20); this.httpClient = HttpClients.custom() .setConnectionManager(cm) .build(); } }

2. 异步处理

// 使用CompletableFuture进行异步操作 public CompletableFuture<Boolean> setDeviceStateAsync(SmartDevice device, DeviceState state) { return CompletableFuture.supplyAsync(() -> device.setState(state)); }

3. 缓存策略

// 设备状态缓存 public class DeviceStateCache { private final LoadingCache<String, DeviceState> cache; public DeviceStateCache() { this.cache = Caffeine.newBuilder() .expireAfterWrite(30, TimeUnit.SECONDS) .build(key -> fetchDeviceState(key)); } }

安全考虑

1. 认证与授权

// OAuth2认证流程 public class OAuth2Authenticator { public String authenticate(String clientId, String clientSecret) { // 实现OAuth2认证流程 return accessToken; } }

2. 数据加密

// 敏感数据加密 public class DataEncryptor { private static final String ALGORITHM = "AES/GCM/NoPadding"; public String encrypt(String data, String key) { // 实现加密逻辑 } }