[java/C] koppeling mbv CORBA *

[Verwijderd]

Op dit moment probeer ik een applicatie, geschreven in C te laten communiceren met een java applet, dit met behulp van CORBA.

Het is me wel gelukt om een java applicatie mbv CORBA met een andere java applet te laten communiceren.

Ik kan hier vrij weinig info over vinden!

Kan iemand me op weg helpen?

[Verwijderd]

Misschien heb je hier iets aan...

http://www.infosys.tuwien.ac.at/Research/Corba/intro.html

staat een link naar een pdf file met een voorbeeld:

http://www.infosys.tuwien.ac.at/Research/Corba/archive/intro/corba-apps4.pdf

Have fun.....en probeer Corba te vermijden :-)

[Alarmnummer]

RMI/IOP kan ook wat corba kan. En schijnt een stuk gemakkelijker te zijn. Ik ben zelf ook niet zo gek op Corba.

[Verwijderd]

Dat RMI gemakkelijk werkt is mij wel duidelijk maar met C?

wat wordt precies bedoeld met RMI/IOP zijn daar ook voorbeelden / sites te vinden.

[Alarmnummer]

Op maandag 11 februari 2002 15:24 schreef peehoo het volgende:
Dat RMI gemakkelijk werkt is mij wel duidelijk maar met C?

wat wordt precies bedoeld met RMI/IOP zijn daar ook voorbeelden / sites te vinden.

RMI/IOP is juist gemaakt zodat meerdere talen ermee kunnen communiceren. Maar ik heb er zelf nog nooit iets in gedaan. Moet je anders ff bij sun kijken.

[Verwijderd]

Het is mij nooit gelukt met de standaard java Corba implementatie, maar wel met Visibroker (van Borland/Inprise). Je kan een evaluatie versie (60 dagen) downloaden voor zowel C++ als Java, waarmee het allemaal best gemakkelijk gaat. Hoewel er misschien weinig demo's/info te vinden is over een C - java koppeling is dat niet erg. Het maakt voor beide programma's geen klap uit welke taal er aan de andere kant zit. Gewoon een paar java en C++ tuturials zijn voldoende.

P.S.
Ik hoop trouwens wel dat je C++ bedoelt en niet C, dat gaat niet werken volgens mij.

[Tomatrix]

Is het juist niet de grap met CORBA dat het voor je client niets uit maakt in welke taal het aan te spreken object geimplementeerd is? Je probleem is dus niet hoe je via Java een CORBA object aanspreekt (want dit is je al gelukt) maar eerder hoe je in c een CORBA object creeert.

RMI/IIOP is Java's Remote Method Invocation die gebruikt maakt van het Internet Inter Orb Protocol, hetzelfde protocol waar CORBA op gebouwd is.

[JungleJim]

Je moet een ORB hebben die de C language mapping ondersteunt. Helaas (?) zijn er daar niet zoveel van. De enige die ik zo uit m'n hoofd ken is ORBit, met binaries voor verschillende platforms (ook Win32). Voor C++ zijn er heel wat meer goede ORBs beschikbaar, zowel gratis als commercieel.

Verder is het het 'standaard' CORBA gebeuren: interfaces definieren, met idl compiler server skeletons en client stubs genereren, implementatie van de objecten maken, etc.

De Java ORB die in de JDK zit is overigens niet echt geschikt voor (serieuze) CORBA applicaties: ondersteund slechts een oude CORBA standaard, en is niet geheel bug vrij. Een beter alternatief is JacORB.

[Verwijderd]

ik kom er zelf dus ook nog niet helemaal uit...

maar goed hier mijn voorbeeldje:

code:

//Hello.idl
module MyHello
{
    interface Hello
    {
        string sayHello();
    };
};

code:

//HelloServer.java
//start eerst .../jdk1.3/bin/tnameserv
import MyHello.*;
import org.omg.CosNaming.*;
import org.omg.CosNaming.NamingContextPackage.*;
import org.omg.CORBA.*;

public class HelloServer
{
    public static void main(String[] args)
    {
        try
        {
            ORB orb = ORB.init(args,null);
            HelloServant hello = new HelloServant();
            orb.connect(hello);

            org.omg.CORBA.Object object = orb.resolve_initial_references("NameService");
            NamingContext namingContext = NamingContextHelper.narrow(object);

            NameComponent nameComponent = new NameComponent("Hello","");
            NameComponent[] path = {nameComponent};
            namingContext.rebind(path, hello);

            java.lang.Object sync = new java.lang.Object();
            synchronized(sync)
            {
                sync.wait();
            }
        }
        catch(Exception e){e.printStackTrace(System.out);}
    }
}

class HelloServant
extends _HelloStub
{
    public String sayHello()
    {
        return("Hello world");
    }
}

code:

//HelloClient.java
import MyHello.*;
import org.omg.CosNaming.*;
import org.omg.CORBA.*;
public class HelloClient
{
    public static void main(String[] args)
    {
        try
        {
            ORB orb = ORB.init(args,null); //bij applet 'this' ipv 'args'
            org.omg.CORBA.Object object = orb.resolve_initial_references("NameService");
            NamingContext namingContext = NamingContextHelper.narrow(object);

            NameComponent nameComponent = new NameComponent("Hello","");
            NameComponent[] path = {nameComponent};
            Hello hello = HelloHelper.narrow(namingContext.resolve(path));

            String helloString = hello.sayHello();
            System.out.println(helloString);
        }
        catch(Exception e){e.printStackTrace(System.out);}
    }
}

[Verwijderd]

Ok,

Zoals Tomatrix zegt is het me inderdaad gelukt om mbv CORBA twee java applicaties met elkaar te laten communiceren.

Eerst met behulp van het commando idlj -fall mijnidl.idl (standaard in > java 1.2) de stubs en skeletons gegenereerd. En in zowel de server als Client applicatie een koppeling naar deze stubs gemaakt. Vergelijkbaar met het voorbeeld van JavaRules. Dit is goed te doen.

Het probleem treed op wanneer ik deze stubs vanuit C wil benaderen. C moet dus bekent zijn met het CORBA object.(Library?). Hoe doe ik dit?

Ik zal zo eerst kijken naar het begrip ORBIT, gepost door Jungle Jim.

Als iemand nog tips heeft zijn deze zeker welkom.

Voor de liefhebber -> Het voorbeeld van JavaRules staat heel goed en duidelijk uitgeschreven op http://java.sun.com/j2se/1.3/docs/guide/idl/jidlExample.html

Wat niet helemaal duidelijk in dit voorbeeld is is dat met het commando idlj -fall het idl bestand gecompiled kan worden.

[JungleJim]

Ok, laten we de IDL gepost door JavaRules ff als voorbeeld nemen. Dan maken we een Java server die wordt benaderd vanuit een C client.

Voor de Java (server) kant maak je met idlj de server skeleton classes aan: idlj -fserver Hello.idl. Nu worden alleen die Java classes gegenereerd die nodig zijn om een MyHello object te kunnen implementeren. De server code en servant (= de class die de MyHello interface implementeert) kunnen hetzelfde blijven zoals gepost door JavaRules.

De server kant is nu dus geimplementeerd in Java, gebruik makend van de ORB die bij de JDK zit en mbv de daarbij behorende idl compiler.

Voor de C kant moet je nu met de idl compiler die bij een C ORB geleverd wordt (ORBit in dit geval) de client stubs genereren. Hoe dat precies moet, staat denk ik wel in de documentatie van ORBit. Nu heb je dus de C code die nodig is om een MyHello object te gebruiken.

Voor een C client maak je een zelfde soort programma als HelloClient: zoek de reference van het MyHello object op in de nameservice, en gebruik de MyHello object reference om operaties op dat object uit te voeren. Hoe de IDL precies op C code gemapt wordt weet ik niet, zie ORBit documentatie en homepage.

Java heeft in dit geval dus niets met de client te maken! Je genereert met de idl compiler mappings van IDL naar de taal die je wilt gebruiken. Voor de server genereer je server skeletons, voor de client genereer je client stubs.

Ik kan je trouwens aanraden om ipv C C++ te gebruiken, omdat de C language binding weinig ondersteund wordt, en vrij lastig in het gebruik is omdat C niet een taal is die object georienteerde concepten makkelijk ondersteund.