双方向Java/CORBA APIゲートウェイのアーキテクチャと実装ガイド

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.18</version> <relativePath/>
    </parent>

    <groupId>com.example</groupId>
    <artifactId>corba-gateway</artifactId>
    <version>1.0.0-SNAPSHOT</version>
    <name>CORBA API Gateway</name>

    <properties>
        <java.version>11</java.version>
        <jacorb.version>3.9</jacorb.version> </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.jacorb</groupId>
            <artifactId>jacorb</artifactId>
            <version>${jacorb.version}</version>
        </dependency>

        <dependency>
            <groupId>org.jacorb</groupId>
            <artifactId>jacorb-omgapi</artifactId>
            <version>${jacorb.version}</version>
        </dependency>
        
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>

            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>idlj-maven-plugin</artifactId>
                <version>1.2.1</version>
                <executions>
                    <execution>
                        <goals>
                            <goal>generate</goal>
                        </goals>
                    </execution>
                </executions>
                <configuration>
                    <compiler>jacorb</compiler>
                    <sourceDirectory>${project.basedir}/src/main/idl</sourceDirectory>
                    <debug>true</debug>
                </configuration>
                <dependencies>
                    <dependency>
                        <groupId>org.jacorb</groupId>
                        <artifactId>jacorb-idl-compiler</artifactId>
                        <version>${jacorb.version}</version>
                    </dependency>
                </dependencies>
            </plugin>
        </plugins>
    </build>
</project>

// src/main/idl/LegacySystem.idl
module Legacy {
    // 他のデータ構造定義など
    typedef sequence<string> StringSeq;

    // ゲートウェイから他システムへのアウトバウンド呼び出し用インターフェース
    interface OtherSystem {
        string processData(in string inputData);
        StringSeq getReport(in long reportId);
    };

    // 他システムからゲートウェイへのインバウンド（コールバック）呼び出し用インターフェース
    interface GatewayCallback {
        oneway void onEvent(in string eventData);
        boolean acknowledge(in long transactionId);
    };
};

# src/main/resources/jacorb.properties

# ------------------------------------------------------------------------------
# ESSENTIAL ORB CONFIGURATION
# ------------------------------------------------------------------------------
# Tell the JRE to use JacORB as the default ORB implementation. This is mandatory.
# [21, 30]
org.omg.CORBA.ORBClass=org.jacorb.orb.ORB
org.omg.CORBA.ORBSingletonClass=org.jacorb.orb.ORBSingleton

# ------------------------------------------------------------------------------
# NAMING SERVICE CONFIGURATION
# ------------------------------------------------------------------------------
# Location of the Naming Service. 'corbaloc' is the standard and recommended format.
# Replace and with the actual address of the Naming Service.
# Example: corbaloc::192.168.1.100:2809/NameService
# [31, 32]
ORBInitRef.NameService=corbaloc:::/NameService

# ------------------------------------------------------------------------------
# SERVER-SIDE (INBOUND) CONFIGURATION
# ------------------------------------------------------------------------------
# Fix the listening port for the gateway's server-side POA.
# This is crucial for configuring firewalls. If not set, a random port will be used.
# [30]
jacorb.OAPort=4711

# ------------------------------------------------------------------------------
# CLIENT-SIDE (OUTBOUND) AND CONNECTION MANAGEMENT
# ------------------------------------------------------------------------------
# Default behavior for connection failures. 'off' means a COMM_FAILURE will be
# thrown immediately. This is recommended for building a robust client with
# explicit retry logic (see Section 3.4).
# [31]
jacorb.connection.client.retry_on_failure=off

# Timeout in milliseconds for pending replies. 0 means wait forever.
# It's good practice to set a reasonable timeout to prevent client threads from hanging.
jacorb.client.pending_reply_timeout=30000

# ------------------------------------------------------------------------------
# LOGGING AND DEBUGGING
# ------------------------------------------------------------------------------
# JacORB uses SLF4J, so detailed logging is configured in logback-spring.xml.
# However, these properties are useful for quick, low-level GIOP message debugging.
# Set to 'on' to see the raw byte traffic in the logs.
# [31]
jacorb.debug.dump_incoming_messages=off
jacorb.debug.dump_outgoing_messages=off

// src/main/java/com/example/corbagateway/config/CorbaConfig.java
package com.example.corbagateway.config;

import org.omg.CORBA.ORB;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.Properties;

@Configuration
public class CorbaConfig {

    /**
     * Initializes and provides the CORBA ORB as a Spring-managed singleton bean.
     * The bean's lifecycle is managed by Spring, ensuring proper startup and shutdown.
     * The destroyMethod ensures that orb.shutdown() is called when the Spring context is closed.
     * [35, 36]
     *
     * @return An initialized ORB instance.
     */
    @Bean(destroyMethod = "shutdown")
    public ORB orb() {
        // jacorb.properties is automatically loaded from the classpath by JacORB.
        // We can pass additional properties programmatically if needed.
        Properties props = new Properties();
        // props.put("some.other.property", "value");

        // ORB.init() initializes the ORB instance.
        // The first argument (String args) can be used for command-line overrides.
        return ORB.init(new String, props);
    }
}

// src/main/java/com/example/corbagateway/service/CorbaClientService.java
package com.example.corbagateway.service;

import org.omg.CORBA.ORB;
import org.omg.CORBA.Object;
import org.omg.CosNaming.NamingContextExt;
import org.omg.CosNaming.NamingContextExtHelper;
import org.springframework.stereotype.Service;

import java.lang.reflect.Method;

@Service
public class CorbaClientService {

    private final ORB orb;
    private final NamingContextExt namingContext;

    public CorbaClientService(ORB orb) throws Exception {
        this.orb = orb;
        // Get the root naming context once during initialization.
        Object objRef = orb.resolve_initial_references("NameService"); // [37, 38]
        this.namingContext = NamingContextExtHelper.narrow(objRef); // [26, 39]
    }

    /**
     * Resolves a remote CORBA object from the Naming Service and narrows it to the specified type.
     * This generic method abstracts away the boilerplate of CORBA lookups.
     *
     * @param name The JNDI-like name of the object in the Naming Service (e.g., "Legacy/OtherSystem").
     * @param helperClass The Helper class of the target interface (e.g., OtherSystemHelper.class).
     * @param <T> The target interface type.
     * @return A proxy to the remote CORBA object.
     * @throws Exception if the object is not found or cannot be narrowed.
     */
    @SuppressWarnings("unchecked")
    public <T> T resolveObject(String name, Class<?> helperClass) throws Exception {
        // Resolve the object using its stringified name. [39, 40, 41]
        Object objRef = namingContext.resolve_str(name);

        // Use reflection to invoke the static 'narrow' method of the helper class.
        Method narrowMethod = helperClass.getMethod("narrow", Object.class);
        return (T) narrowMethod.invoke(null, objRef);
    }
}

// src/main/java/com/example/corbagateway/controller/LegacyApiController.java
package com.example.corbagateway.controller;

import Legacy.OtherSystem;
import Legacy.OtherSystemHelper;
import com.example.corbagateway.service.CorbaClientService;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.PostConstruct;

@RestController
@RequestMapping("/api")
public class LegacyApiController {

    private final CorbaClientService corbaClientService;
    private OtherSystem otherSystem; // Cached remote object stub

    public LegacyApiController(CorbaClientService corbaClientService) {
        this.corbaClientService = corbaClientService;
    }

    /**
     * Initializes the controller by resolving the remote CORBA object reference.
     * This is done once after the bean has been constructed.
     */
    @PostConstruct
    public void init() {
        try {
            // The name should match the name used by the C++ server to bind the object.
            this.otherSystem = corbaClientService.resolveObject("OtherSystemInstance", OtherSystemHelper.class);
            System.out.println("Successfully resolved remote OtherSystem object.");
        } catch (Exception e) {
            System.err.println("Failed to resolve remote OtherSystem object. Outbound calls will fail.");
            // In a real application, you might want to prevent the application from starting
            // or implement a retry mechanism (see Section 3.4).
            e.printStackTrace();
        }
    }

    @PostMapping("/process")
    public ResponseEntity<String> processData(@RequestBody String data) {
        if (otherSystem == null) {
            return ResponseEntity.status(503).body("Service Unavailable: Legacy system connection not established.");
        }

        try {
            // Invoke the method on the remote CORBA object.
            String result = otherSystem.processData(data);
            return ResponseEntity.ok(result);
        } catch (org.omg.CORBA.COMM_FAILURE e) {
            // Handle communication failure. A more robust solution is in Section 3.4.
            e.printStackTrace();
            return ResponseEntity.status(504).body("Gateway Timeout: Communication with legacy system failed.");
        } catch (Exception e) {
            e.printStackTrace();
            return ResponseEntity.status(500).body("Internal Server Error: An unexpected error occurred.");
        }
    }
}

// src/main/java/com/example/corbagateway/servant/GatewayCallbackImpl.java
package com.example.corbagateway.servant;

import Legacy.GatewayCallbackPOA;
import com.example.corbagateway.service.ApplicationEventService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

// This class itself is NOT a Spring bean because its lifecycle is managed by the POA.
// However, it will hold a reference to a Spring-managed service.
public class GatewayCallbackImpl extends GatewayCallbackPOA {

    private final ApplicationEventService eventService;

    /**
     * The servant is instantiated by our CorbaServerManager, which will inject
     * the required Spring service.
     * @param eventService The Spring service to handle business logic.
     */
    public GatewayCallbackImpl(ApplicationEventService eventService) {
        this.eventService = eventService;
    }

    @Override
    public void onEvent(String eventData) {
        System.out.println("CORBA Server: Received onEvent call with data: " + eventData);
        // Delegate the actual work to a modern, testable Spring service.
        eventService.processIncomingEvent(eventData);
    }

    @Override
    public boolean acknowledge(long transactionId) {
        System.out.println("CORBA Server: Received acknowledge call for txId: " + transactionId);
        return eventService.processAcknowledgement(transactionId);
    }
}

// src/main/java/com/example/corbagateway/config/CorbaServerManager.java
package com.example.corbagateway.config;

import Legacy.GatewayCallback;
import Legacy.GatewayCallbackHelper;
import com.example.corbagateway.servant.GatewayCallbackImpl;
import com.example.corbagateway.service.ApplicationEventService;
import org.omg.CORBA.ORB;
import org.omg.CORBA.Object;
import org.omg.CosNaming.NameComponent;
import org.omg.CosNaming.NamingContextExt;
import org.omg.CosNaming.NamingContextExtHelper;
import org.omg.PortableServer.POA;
import org.omg.PortableServer.POAHelper;
import org.springframework.boot.context.event.ApplicationReadyEvent;
import org.springframework.context.ApplicationListener;
import org.springframework.stereotype.Component;

import javax.annotation.PreDestroy;

@Component
public class CorbaServerManager implements ApplicationListener<ApplicationReadyEvent> {

    private final ORB orb;
    private final ApplicationEventService eventService;
    private NamingContextExt namingContext;
    private GatewayCallback callbackRef;
    private NameComponent path;

    public CorbaServerManager(ORB orb, ApplicationEventService eventService) {
        this.orb = orb;
        this.eventService = eventService;
    }

    @Override
    public void onApplicationEvent(ApplicationReadyEvent event) {
        try {
            System.out.println("Starting CORBA server endpoint...");

            // 1. Get the RootPOA
            Object poaRef = orb.resolve_initial_references("RootPOA");
            POA rootPoa = POAHelper.narrow(poaRef);

            // 2. Activate the POAManager
            rootPoa.the_POAManager().activate();

            // 3. Create the servant instance and inject dependencies
            GatewayCallbackImpl servant = new GatewayCallbackImpl(eventService);

            // 4. Activate the servant in the POA to get an object reference
            Object ref = rootPoa.servant_to_reference(servant);
            this.callbackRef = GatewayCallbackHelper.narrow(ref);

            // 5. Get the Naming Service
            Object objRef = orb.resolve_initial_references("NameService");
            this.namingContext = NamingContextExtHelper.narrow(objRef);

            // 6. Bind the object reference to the Naming Service
            String name = "GatewayCallbackService";
            this.path = namingContext.to_name(name);
            namingContext.rebind(path, callbackRef); // rebind overwrites existing bindings [26]

            System.out.println("CORBA server endpoint 'GatewayCallbackService' is ready and waiting.");

        } catch (Exception e) {
            System.err.println("FATAL: Failed to start CORBA server endpoint.");
            e.printStackTrace();
            // In a real application, consider shutting down the application context
        }
    }

    /**
     * Unbinds the object from the Naming Service upon application shutdown.
     */
    @PreDestroy
    public void shutdown() {
        if (namingContext!= null && path!= null) {
            try {
                namingContext.unbind(path);
                System.out.println("Successfully unbound 'GatewayCallbackService' from Naming Service.");
            } catch (Exception e) {
                System.err.println("Error while unbinding CORBA object from Naming Service.");
                e.printStackTrace();
            }
        }
    }
}

// src/main/java/com/example/corbagateway/service/ApplicationEventService.java
package com.example.corbagateway.service;

import org.springframework.stereotype.Service;

@Service
public class ApplicationEventService {

    public void processIncomingEvent(String eventData) {
        // Here, you can implement any modern logic:
        // - Publish a Spring ApplicationEvent
        // - Send a message to a Kafka topic or RabbitMQ queue
        // - Write to a database via a Spring Data repository
        // - Call another REST API using RestTemplate or WebClient
        System.out.println("Spring Service: Processing event -> " + eventData);
    }

    public boolean processAcknowledgement(long transactionId) {
        System.out.println("Spring Service: Processing acknowledgement for txId -> " + transactionId);
        // Business logic to confirm transaction
        return true;
    }
}

<logger name="jacorb.giop.conn" level="DEBUG" />
<logger name="jacorb.poa" level="INFO" />