멀티 벤더 IoT 연동 설계하기 (1편) - Adapter 패턴으로 통합하기

POST /devices/light/control
Authorization: Bearer {token}
{
  "deviceId": "ABC123",
  "command": "ON",
  "brightness": 80
}

Response:
{
  "status": "success",
  "deviceId": "ABC123",
  "currentState": "ON"
}

POST /v2/smart-home/command
Authorization: API-Key {key}
{
  "device_uuid": "ABC123",
  "action": {
    "type": "POWER_ON",
    "params": {
      "brightness_level": 80
    }
  }
}

Response:
{
  "result": {
    "code": 200,
    "message": "OK"
  },
  "data": {
    "device_uuid": "ABC123",
    "state": "on"
  }
}

POST /api/devices/action
X-API-Token: {token}
{
  "id": "ABC123",
  "control": {
    "power": "on",
    "level": 80
  }
}

Response:
{
  "success": true,
  "device": {
    "id": "ABC123",
    "status": {
      "power": "on",
      "brightness": 80
    }
  }
}

@Service
public class IoTService {

    public void turnOnLight(String vendor, String deviceId, int brightness) {
        if ("VendorA".equals(vendor)) {
            // A사 API 호출
            restTemplate.postForObject(
                "https://vendor-a.com/devices/light/control",
                Map.of(
                    "deviceId", deviceId,
                    "command", "ON",
                    "brightness", brightness
                ),
                VendorAResponse.class
            );
        } else if ("VendorB".equals(vendor)) {
            // B사 API 호출
            restTemplate.postForObject(
                "https://vendor-b.com/v2/smart-home/command",
                Map.of(
                    "device_uuid", deviceId,
                    "action", Map.of(
                        "type", "POWER_ON",
                        "params", Map.of("brightness_level", brightness)
                    )
                ),
                VendorBResponse.class
            );
        } else if ("VendorC".equals(vendor)) {
            // C사 API 호출 ...
        }
        // ... D사, E사, F사도 추가될 예정
    }
}

graph TB
    subgraph 비즈니스 레이어
        SH[SmartHomeService]
    end

    subgraph 추상화 레이어
        AF[AdapterFactory]
        IA[IoTVendorAdapter<br/>인터페이스]
    end

    subgraph Adapter 구현체
        VA[VendorA<br/>Adapter]
        VB[VendorB<br/>Adapter]
        VC[VendorC<br/>Adapter]
    end

    subgraph 외부 API
        API_A[A사 API]
        API_B[B사 API]
        API_C[C사 API]
    end

    SH --> AF
    AF --> IA
    IA --> VA
    IA --> VB
    IA --> VC
    VA --> API_A
    VB --> API_B
    VC --> API_C

    style SH fill:#e8f5e9
    style AF fill:#fff3e0
    style IA fill:#fff3e0
    style VA fill:#e3f2fd
    style VB fill:#e3f2fd
    style VC fill:#e3f2fd

// 공통 기기 인터페이스
public interface IoTDevice {
    String getDeviceId();
    DeviceType getType();
    DeviceStatus getStatus();
}

// 기기 타입
public enum DeviceType {
    LIGHT,
    THERMOSTAT,
    DOOR_LOCK,
    AIR_CONDITIONER
}

// 기기 상태 - 제조사 무관하게 동일한 구조
public class DeviceStatus {
    private boolean power;
    private Map<String, Object> attributes;
    // 조명: brightness, color
    // 온도조절기: targetTemp, currentTemp
    // 도어락: locked
}

// 제어 명령 - 우리만의 표준
public class DeviceCommand {
    private CommandType type;
    private Map<String, Object> parameters;
}

public enum CommandType {
    TURN_ON,
    TURN_OFF,
    SET_VALUE
}

public interface IoTVendorAdapter {

    /**
     * 어댑터가 지원하는 제조사 식별자
     */
    String getVendorId();

    /**
     * 기기 상태 조회
     */
    DeviceStatus getDeviceStatus(String deviceId);

    /**
     * 기기 제어
     */
    void executeCommand(String deviceId, DeviceCommand command);

    /**
     * 기기 목록 조회
     */
    List<IoTDevice> listDevices(String userId);

    /**
     * 연결 상태 확인
     */
    boolean isConnected();
}

sequenceDiagram
    participant Client as 클라이언트
    participant Service as SmartHomeService
    participant Factory as AdapterFactory
    participant Adapter as VendorAdapter
    participant API as 외부 API

    Client->>Service: turnOnLight(deviceId, brightness)
    Service->>Factory: getAdapter(vendorId)
    Factory-->>Service: VendorAAdapter
    Service->>Adapter: executeCommand(deviceId, command)
    Note over Adapter: 도메인 모델 → API 형식 변환
    Adapter->>API: POST /devices/control
    API-->>Adapter: 응답
    Note over Adapter: API 응답 → 도메인 모델 변환
    Adapter-->>Service: void
    Service-->>Client: 완료

@Component
@RequiredArgsConstructor
public class VendorAAdapter implements IoTVendorAdapter {

    private final RestTemplate restTemplate;
    private final VendorAProperties properties;

    @Override
    public String getVendorId() {
        return "VENDOR_A";
    }

    @Override
    public DeviceStatus getDeviceStatus(String deviceId) {
        // A사 API 호출
        VendorADeviceResponse response = restTemplate.getForObject(
            properties.getApiUrl() + "/devices/" + deviceId,
            VendorADeviceResponse.class
        );

        // A사 응답 → 우리 도메인 모델로 변환
        return convertToDomainModel(response);
    }

    @Override
    public void executeCommand(String deviceId, DeviceCommand command) {
        // 우리 도메인 명령 → A사 API 형식으로 변환
        VendorARequest request = convertToVendorRequest(deviceId, command);

        // A사 API 호출
        restTemplate.postForObject(
            properties.getApiUrl() + "/devices/control",
            request,
            VendorAResponse.class
        );
    }

    private DeviceStatus convertToDomainModel(VendorADeviceResponse response) {
        DeviceStatus status = new DeviceStatus();
        status.setPower("ON".equals(response.getCommand()));

        Map<String, Object> attributes = new HashMap<>();
        if (response.getBrightness() != null) {
            attributes.put("brightness", response.getBrightness());
        }
        status.setAttributes(attributes);

        return status;
    }

    private VendorARequest convertToVendorRequest(String deviceId, DeviceCommand command) {
        VendorARequest request = new VendorARequest();
        request.setDeviceId(deviceId);

        switch (command.getType()) {
            case TURN_ON:
                request.setCommand("ON");
                break;
            case TURN_OFF:
                request.setCommand("OFF");
                break;
            case SET_VALUE:
                request.setCommand("SET");
                request.setBrightness(
                    (Integer) command.getParameters().get("brightness")
                );
                break;
        }

        return request;
    }

    @Override
    public boolean isConnected() {
        try {
            restTemplate.getForObject(
                properties.getApiUrl() + "/health",
                String.class
            );
            return true;
        } catch (Exception e) {
            return false;
        }
    }
}

@Component
@RequiredArgsConstructor
public class VendorBAdapter implements IoTVendorAdapter {

    private final RestTemplate restTemplate;
    private final VendorBProperties properties;

    @Override
    public String getVendorId() {
        return "VENDOR_B";
    }

    @Override
    public void executeCommand(String deviceId, DeviceCommand command) {
        // 우리 도메인 명령 → B사 API 형식으로 변환 (중첩 구조)
        Map<String, Object> request = convertToVendorBRequest(deviceId, command);

        // B사 API 호출 (인증 헤더 추가)
        HttpHeaders headers = new HttpHeaders();
        headers.set("Authorization", "API-Key " + properties.getApiKey());

        HttpEntity<Map<String, Object>> entity = new HttpEntity<>(request, headers);

        restTemplate.postForObject(
            properties.getApiUrl() + "/v2/smart-home/command",
            entity,
            VendorBResponse.class
        );
    }

    private Map<String, Object> convertToVendorBRequest(
        String deviceId,
        DeviceCommand command
    ) {
        Map<String, Object> action = new HashMap<>();
        Map<String, Object> params = new HashMap<>();

        switch (command.getType()) {
            case TURN_ON:
                action.put("type", "POWER_ON");
                if (command.getParameters().containsKey("brightness")) {
                    params.put("brightness_level",
                        command.getParameters().get("brightness"));
                }
                break;
            case TURN_OFF:
                action.put("type", "POWER_OFF");
                break;
            case SET_VALUE:
                action.put("type", "SET_VALUE");
                params.put("brightness_level",
                    command.getParameters().get("brightness"));
                break;
        }

        action.put("params", params);

        return Map.of(
            "device_uuid", deviceId,
            "action", action
        );
    }

    // ... 나머지 구현 생략
}

@Component
public class IoTAdapterFactory {

    private final Map<String, IoTVendorAdapter> adapters;

    // Spring이 모든 IoTVendorAdapter 구현체를 주입
    public IoTAdapterFactory(List<IoTVendorAdapter> adapterList) {
        this.adapters = adapterList.stream()
            .collect(Collectors.toMap(
                IoTVendorAdapter::getVendorId,
                adapter -> adapter
            ));
    }

    public IoTVendorAdapter getAdapter(String vendorId) {
        IoTVendorAdapter adapter = adapters.get(vendorId);
        if (adapter == null) {
            throw new UnsupportedVendorException(
                "Vendor not supported: " + vendorId
            );
        }
        return adapter;
    }

    public List<IoTVendorAdapter> getAllAdapters() {
        return new ArrayList<>(adapters.values());
    }
}

@Service
@RequiredArgsConstructor
public class SmartHomeService {

    private final IoTAdapterFactory adapterFactory;
    private final DeviceRepository deviceRepository;

    public void turnOnLight(Long deviceId, int brightness) {
        // 1. 기기 정보 조회
        Device device = deviceRepository.findById(deviceId)
            .orElseThrow();

        // 2. 해당 제조사 Adapter 선택 (Factory가 알아서 찾아줌)
        IoTVendorAdapter adapter = adapterFactory.getAdapter(
            device.getVendorId()
        );

        // 3. 명령 생성 (우리 표준 모델)
        DeviceCommand command = DeviceCommand.builder()
            .type(CommandType.TURN_ON)
            .parameter("brightness", brightness)
            .build();

        // 4. 실행 (Adapter가 알아서 변환)
        adapter.executeCommand(device.getExternalId(), command);

        // 5. 상태 업데이트
        device.updateStatus(true, brightness);
        deviceRepository.save(device);
    }

    public DeviceStatus getDeviceStatus(Long deviceId) {
        Device device = deviceRepository.findById(deviceId)
            .orElseThrow();

        IoTVendorAdapter adapter = adapterFactory.getAdapter(
            device.getVendorId()
        );

        return adapter.getDeviceStatus(device.getExternalId());
    }
}

@Component
@RequiredArgsConstructor
public class VendorDAdapter implements IoTVendorAdapter {

    private final VendorDApiClient client;

    @Override
    public String getVendorId() {
        return "VENDOR_D";
    }

    @Override
    public DeviceStatus getDeviceStatus(String deviceId) {
        // D사만의 구현
    }

    @Override
    public void executeCommand(String deviceId, DeviceCommand command) {
        // D사만의 구현
    }

    // ... 나머지 구현
}

public class DeviceStatus {
    private boolean power;
    private Map<String, Object> attributes; // 선택적 속성

    public Optional<Integer> getBrightness() {
        return Optional.ofNullable((Integer) attributes.get("brightness"));
    }

    public Optional<RgbColor> getColor() {
        return Optional.ofNullable((RgbColor) attributes.get("color"));
    }
}

요청 → 도메인 모델 → 제조사 API 형식 → 제조사 응답 → 도메인 모델 → 응답