Een eenvoudige CORBA-applicatie - doe het zelf. CORBA-technologie (Common Object Request Broker Architecture).

Maak uzelf vertrouwd met het theoretische materiaal dat wordt gepresenteerd in de bijlagen bij deze richtlijnen en voorbeeldprogramma's. Lees de tekst van de opdracht laboratorium werk, stel de plaatsing en functionaliteit van componenten voor om aan de vereisten van de laboratoriumopdracht te voldoen, en schrijf het programma.

2. Laboratorium opdracht

Ontwikkelen e-mailclient en server. Klant - raam applicatie, waarmee u berichten van de server kunt verzenden en ontvangen. Identificatie van clients op de server en het protocol voor berichtoverdracht zijn ter beoordeling van de studenten.

De server kan een consoletoepassing zijn. U kunt berichten opslaan in een tekstbestand. Het wordt aanbevolen om de server multi-threaded te maken.

Gebruik CORBA-technologie voor interactie tussen client en server.

Als aanvulling wordt voorgesteld om de server of client niet in Java te implementeren.

3. Inhoud van het rapport

Het rapport moet bevatten:

1. Verklaring van het probleem opgelost door een goed werkend programma.

2. Gebruikershandleiding van het foutopsporingsprogramma, met daarin een beschrijving van de interfaces van alle programmafuncties.

3. Lijst van het programma met het nodige commentaar.

4. Beveiligingsvragen

1. Wat is CORBA?

2. Wat is IDL? Waar is het voor?

3. Hoe werken client en server samen in CORBA?

4. Hoe worden gegevens onderling overgedragen?

5. Waar dient een naamserver voor?

6. Hoe start je een CORBA-server?

5. Literatuur

1. Ken Arnold, James Gosling, David Holmes. Java™-programmeertaal.

2. Officiële Java-website – http://java.sun.com/ (er is een sectie in het Russisch met een leerboek).

3. Java™ 2 SDK, Standaard editie Documentatie - http://java.sun.com/products/jdk/1.5/index.html.

4. James Gosling, Bill Joy, Guy Steele. Specificatie Java-taal(De Java-taalspecificatie – http://www.javasoft.com/docs/books/jls/). Vertaling in het Russisch – http://www.uni-vologda.ac.ru/java/jls/index.html

5. De officiële website van het Eclipse-project is http://www.eclipse.org/.

6. Bijlage 1. CORBA

CORBA-technologie(Common Object Request Broker Architecture) is een schrijfstandaard gedistribueerde applicaties, voorgesteld door het OMG-consortium (Open Management Group). Door CORBA-objecten te maken, kunnen we bijvoorbeeld de tijd die nodig is voor het oplossen van problemen die veel rekenwerk vereisen aanzienlijk verkorten. Dit is mogelijk door er CORBA-objecten op te plaatsen verschillende auto's. Elk object op afstand lost een specifieke deeltaak op, waardoor de klant onnodig werk wordt ontlast.

De kern van CORBA is de Object Request Broker. ORB beheert de interactie van objecten in een gedistribueerde netwerkomgeving. IIOP (Internet Inter-ORB Protocol) is een speciaal protocol voor interactie tussen ORB's.

Een speciaal object, een stub genaamd, werkt in de adresruimte van de klant. Nadat het een verzoek van de client heeft ontvangen, verpakt het de verzoekparameters in een speciaal formaat en verzendt het naar de server, of beter gezegd naar het skelet.

Skelet is een object dat in de serveradresruimte werkt. Nadat hij een verzoek van de client heeft ontvangen, pakt hij deze uit en stuurt deze naar de server. Het skelet converteert ook de antwoorden van de server en geeft deze door aan de client (stub).

Om een CORBA-toepassing te schrijven met behulp van Java-technologie, je hebt twee dingen nodig: dit geïnstalleerd pakket JDK1.5 en idlj-compiler (...\jdk1.5.0\bin\idlj.exe). De JDK biedt een reeks klassen voor het werken met CORBA-objecten, en idlj wijst de IDL-taal toe aan Java.

6.1 Een eenvoudige CORBA-applicatie maken

6.1.1 Een interface schrijven

Het maken van een CORBA-toepassing in Java begint met het schrijven van een interface voor een extern object met behulp van de Interface Definition Language (IDL).

Laten we het hello.idl-bestand maken

Module HelloApp(interface Hello(string zegHello();oneway void shutdown();););

Deze interface beschrijft slechts twee methoden: afsluiten en zeg Hallo. Bovendien maakt het ons niet uit wat deze methoden doen, het belangrijkste is dat we vaststellen dat ze bestaan en bepalen welke invoer- en uitvoerparameters ze hebben.

idlj – herfst Hallo.idl

Verschijnt in de huidige map nieuwe map Hallo App, dat zes Java-bestanden bevat. Elk van hen heeft zijn eigen doel.

· HelloPOA.java Java is een abstracte klasse die niets meer is dan een server-skelet (skelet) en serverfunctionaliteit biedt.

· _HelloStub.java – een klasse die de client-stub implementeert. Biedt clientfunctionaliteit.

HelloHelper.java en HelloHolder.java zijn klassen die bieden hulpfuncties voor CORBA-objecten.

· HelloOperations.java – een klasse die een beschrijving bevat van de hello-interface in Java.

· Hello.java – een klasse die een opvolger is van HelloOperations en de org.omg.CORBA-interface ondersteunt. Voorwerp.

6.1.2 Een server aanmaken

Nu is het onze taak om een klasse te schrijven die de interface implementeert Hallo. In ons geval zal dat zo zijn Hallo Impl. Houd er rekening mee dat het een erfgenaam van de klasse is HalloPOA. IN Hallo Impl methoden gedeclareerd in Hallo . nutteloos .

Om de taak te vereenvoudigen, kan de declaratie van methoden uit het bestand worden gehaald Hallo Operaties . Java , gegenereerd jdlj .

Klasse HelloImpl breidt HelloPOA uit (privé ORB bol; public void setORB (ORB orb_val) (orb = orb_val;) // implementeer SayHello() methodpublic String SayHello() (retourneer "\nHallo wereld!!\n";) // implementeer shutdown() methodpublic void shutdown() (orb .shutdown(vals);))

De volgende stap is het creëren van de daadwerkelijke serverkant van de applicatie. Dit wordt de HelloServer-klasse.

Het heeft maar één methode: de standaard hoofdfunctie.

Het eerste dat we doen is een ORB maken. Vervolgens maken we een exemplaar van de externe objectklasse (HelloImpl) en registreren deze in de ORB. Vervolgens bellen wij speciale dienst namen (NameService) en registreer de naam van het externe object daarin zodat de client het kan vinden.

Laten we deze fasen eens nader bekijken.

1. Creatie en initialisatie van ORB. Geproduceerd door te bellen statische methode begin ORB-klasse

2. Een exemplaar van een externe objectklasse maken en deze in de ORB registreren

halloImpl.setORB(orb);

3. De naamgevingscontext ophalen (NamingContext)

org.omg.CORBA. Object objRef = orb.resolve_initial_references("NameService");

In de eerste regel krijgen we een objectverwijzing naar de naamservice (NameService). Maar in feite is dit een gewoon CORBA-object en om het te gebruiken als naamgevingscontext (NamingContext), moet je de methode aanroepen smal klas NaamgevingContextHelper, wat dit CORBA-object lijkt te specificeren.

4. De naam van het externe object registreren (HelloImpl)

Tekenreeksnaam = "Hallo";

ncRef.rebind(pad, href);

De naam wordt geregistreerd zodat de client het externe object kan vinden. De rebind-functie (NameComponent nc, Object obj) van de NamingContext-interface dient dit doel.

5. Wachten op verzoeken van de klant

De server is nu klaar voor gebruik.

// HelloServer.javaimport HelloApp.*;import org.omg. CosNaming.*;import org.omg. CosNaming. NamingContextPackage.*;importeer org.omg.CORBA.*;importeer org.omg. PortableServer.*;import org.omg. PortableServer.POA; importeer java.util. Properties;class HelloImpl breidt HelloPOA uit (privé ORB orb;public void setORB (ORB orb_val) (orb = orb_val;) // implementeer SayHello() methodpublic String SayHello() (return "\nHallo wereld!!\n";) // implementeer shutdown() methodpublic void shutdown() (orb.shutdown(false);))

openbare klasse HelloServer(

public static void main (String-args) (

// maak en initialiseer de ORB

ORB orb = ORB.init(args, null);

// krijg een verwijzing naar rootpoa en activeer de POAManager

POA rootpoa = POAHelper.narrow(orb.resolve_initial_references("RootPOA"));

rootpoa.the_POAManager().activate();

// maak een bediende aan en registreer deze bij de ORB

HalloImpl halloImpl = nieuw HalloImpl();

halloImpl.setORB(orb);

// krijg objectreferentie van de dienaar

org.omg.CORBA. Objectreferentie = rootpoa.servant_to_reference(helloImpl);

Hallo href = HalloHelper.narrow(ref);

// haal de root-naamgevingscontext op

// NameService roept de naamservice aan

org.omg.CORBA. Object objRef =

orb.resolve_initial_references("NaamService");

// Gebruik NamingContextExt, dat deel uitmaakt van Interoperable

// Naming Service (INS)-specificatie.

NamingContextExt ncRef = NamingContextExtHelper.narrow(objRef);

// bind de objectreferentie in Naming

Tekenreeksnaam = "Hallo";

NaamComponent pad = ncRef.to_name(naam);

ncRef.rebind(pad, href);

System.out.println("HelloServer klaar en wachtend...");

// wacht op aanroepen van klanten

vangen (Uitzondering e) (

Systeem.err.println("FOUT:" + e);

e.printStackTrace(System.out);

System.out.println("HelloServer wordt afgesloten...");

6.1.3 Een klant aanmaken

Laten we verder gaan met het schrijven van code voor de klant.

Basisstappen voor schrijven klant applicatie

1. ORB-creatie en initialisatie

2. De context van de naamgevingsservice verkrijgen (NamingContext)

3. Een object op afstand zoeken

4. De SayHello-methode aanroepen.

5. De afsluitmethode oproepen.

Zoals u kunt zien, vallen de eerste twee punten samen met de fasen van het maken van een serverapplicatie, dus we zullen ze niet overwegen.

Het derde punt is ook vrij eenvoudig te implementeren. Er wordt een NameComponent-object gemaakt. De oplossingsmethode (NameComponent path) wordt aangeroepen, die het externe object (standaard CORBA-object) op naam zoekt. Met behulp van de smalle methode (org.omg.CORBA. Object obj) van de helloHelper-klasse (gegenereerd door de idlj-compiler) verkrijgen we een objectverwijzing naar de hello-interface.

Tekenreeksnaam = "Hallo";

halloImpl = HalloHelper.narrow(ncRef.resolve_str(naam));

Ik weet dat je met CORBA meerdere objecten kunt implementeren verschillende talen programmeren en zelfs draaien op verschillende computerknooppunten. Is het dan echter nodig om twee verschillende ORB's in twee verschillende talen te laten schrijven?

Voorbeeld: Knooppunt A begint Java-applicatie J1, en knooppunt B voert de C++ C1-toepassing uit. Moet ik een "Java ORB" krijgen voor knooppunt A en een "C++ ORB" voor knooppunt B of werken alle/sommige ORB's samen met applicaties die zijn geschreven in elke taal die een IDL-toewijzing heeft?

Ik zou vooral dankbaar zijn als iemand mij zou kunnen linken naar een bron, en deze rechtstreeks zou vermelden zoals ik zou willen dat deze vermeld wordt. Het dichtst dat ik heb gevonden is "de manier waarop een programmeur een structuur of unie manipuleert, een oproep op afstand doet met behulp van een proxy, of een interface implementeert met een dienaarklasse, op dezelfde manier in alle CORBA C++-producten, op dezelfde manier in alle Java CORBA-producten, enz." d. ". Dit doet me denken dat ik twee ORB's nodig heb, maar niet expliciet genoeg. Eigenlijk zou ik graag willen weten of ik kan zeggen dat "aangezien ORB in C++ is geschreven, het applicatieprogrammeurs ook verboden is C++ te gebruiken".

dankzij

3 antwoorden

Het maakt niet uit in welke taal de ORB is geïmplementeerd; het gaat erom welke taalbindingen het biedt. Voor de L-taal heb je een orb nodig die bindingen biedt voor de L-taal. Vaak bieden orbs eenvoudigweg een binding voor de taal waarin ze zelf zijn geschreven, maar kunnen ze ook bindingen bieden voor sommige andere talen.

Nee. Het punt van CORBA is dat het componenten volledig ontkoppelt.

Het is duidelijk dat uw applicaties clientbibliotheken moeten gebruiken waarmee ze kunnen communiceren. Uw ORB kan slechts bindingen voor één taal installeren, in welk geval u andere bindingen moet vinden of een manier moet vinden om ermee te communiceren (als u bijvoorbeeld Python gebruikt, kunt u desgewenst nog steeds met C++-bibliotheken werken ).

Probeer deze technologie te gebruiken.

Er zijn verschillende benaderingen die kunnen worden gebruikt bij het implementeren van CORBA-applicaties, maar om het samen te vatten: ja, het ORB-framework moet in dezelfde taal zijn als uw applicatie-implementatie.

In zowel Java als C++ genereert de IDL-compiler stubs en skeletons die dienen als lijm tussen het netwerk en uw programma. U levert een implementatie van uw CORBA-objecten, die doorgaans overerft van een door de compiler gegenereerde IDL-klasse (skelet). Het skelet ontvangt op de een of andere manier het verzoek van de klant en roept vervolgens uw implementatie aan. Hetzelfde gebeurt omgekeerd aan de clientzijde.

Zowel het skelet als de stub gebruiken vervolgens de mechanismen van de ORB om op afstand servers te bellen en op reacties te reageren, inclusief het tot stand brengen van netwerkverbindingen als de client en servers zich op verschillende machines bevinden. Deze "magie" wordt geïmplementeerd door de ORB en moet in uw programma aanwezig zijn in de vorm van een bibliotheek, een reeks functies, enz. die de stub en het skelet zullen gebruiken om de klus te klaren.

Elk programma moet dus een soort ORB-representatie hebben om te communiceren met andere CORBA-clients en -servers op andere machines.

Vanuit logisch oogpunt wordt de ORB echter gezien als de laag die feitelijk en naadloos zowel clients als servers met elkaar verbindt, dus zelfs als een C++-applicatie een ORB-implementatie heeft die in C++ is geschreven en een Java-implementatie, heeft een ORB die in Java is geschreven is magisch standaard protocollen(GIOP, IIOP) kunnen ze probleemloos met elkaar communiceren.

Het rapport moet bevatten:

Verklaring van een probleem opgelost door een goed werkend programma.

Gebruikershandleiding van het foutopsporingsprogramma, met daarin een beschrijving van de interfaces van alle programmafuncties.

Programmaoverzicht met het nodige commentaar.

Beveiligingsvragen

Wat is CORBA?

Wat is er gebeurd IDL? Waar is het voor?

Hoe interacteren client en server?CORBA?

Hoe worden gegevens tussen hen overgedragen?

Waar is een naamserver voor?

Hoe het begint CORBA server?

Literatuur

Ken Arnold, James Gosling, David Holmes.Java™-programmeertaal.

Officiële websiteJava – http:// Java. zon. com/ (er is een sectie in het Russisch met een leerboek).

Java™ 2 SDK, Standard Edition-documentatie - http://java.sun.com/products/jdk/1.5/index.html.

James Gosling, Bill Joy, Guy Steele.Taalspecificatie Java ( De Java-taalspecificatie – http :// www . javasoft . com / documenten / boeken / jl /). Vertaling in het Russisch –http:// www. uni- vologda. ac. Ru/ Java/ jl/ index. html

Officiële projectwebsiteVerduistering – http:// www. verduistering. org/.

Bijlage 1. CORBA

Technologie CORBA (GewoonVoorwerpVerzoekMakelaarArchitectuur) is een standaard voor het schrijven van gedistribueerde applicaties voorgesteld door een consortiumOMG (OpenBeheerGroep). Door CORBA-objecten te maken, kunnen we bijvoorbeeld de tijd die nodig is voor het oplossen van problemen die veel rekenwerk vereisen aanzienlijk verkorten. Dit is mogelijk door CORBA-objecten op verschillende machines te plaatsen. Elk object op afstand lost een specifieke deeltaak op, waardoor de klant onnodig werk wordt ontlast.

Om een CORBA-toepassing te schrijven met behulp van Java-technologie, moet u twee dingen hebben: het JDK1.5-pakket geïnstalleerd en de idlj-compiler (…\ jdk 1.5.0\ bak\ IDL. exe). De JDK biedt een reeks klassen voor het werken met CORBA-objecten, en idlj wijst de IDL-taal toe aan Java.

6 .1 Een eenvoudige CORBA-applicatie maken

Een interface schrijven

Creatie CORBA toepassingen op Javabegint met het schrijven van een interface voor een object op afstand met behulp van een interfacebeschrijvingstaal (InterfaceDefinitieTaal, IDL).

Laten we creërenbestandhallo.idl

module HalloApp

interface Hallo

tekenreeks zeg Hallo();

oneway void shutdown();

Deze interface beschrijft slechts twee methodenafsluiten En zeg Hallo . Bovendien maakt het ons niet uit wat deze methoden doen, het belangrijkste is dat we vaststellen dat ze bestaan en bepalen welke invoer- en uitvoerparameters ze hebben.

Vervolgens moet u de compiler uitvoerenIDL- naar- JavaIDL:

IDL – valHallo. nutteloos

Er is een nieuwe map verschenen in de huidige mapHallo App , dat zes Java-bestanden bevat. Elk van hen heeft zijn eigen doel.

HalloPOA. JavaJava– een abstracte klasse die niets meer is dan het serverskelet (skelet) en biedt serverfunctionaliteit.

_ HalloStub. Java– een klasse die implementeert stomp ( stomp) klant. Biedtfunctionaliteit van de klant.

Hallo Helper. Java En HalloHouder. Java– klassen die helpfuncties biedenCORBA voorwerpen.

Hallo Operaties. Java– een klasse die een beschrijving van de interface bevatHallo in de taal Java.

Hallo. Java– klasse – erfgenaamHallo Operaties, ondersteunende interfaceorg. omg. CORBA. Voorwerp.

Een server maken

Nu is het onze taak om een klasse te schrijven die de interface implementeertHallo . In ons geval zal dat zo zijnHallo Impl . Houd er rekening mee dat het een erfgenaam van de klasse isHalloPOA . IN Hallo Impl methoden gedeclareerd inHallo . nutteloos .

Om de taak te vereenvoudigen, kan de declaratie van methoden uit het bestand worden gehaald Hallo Operaties . Java , gegenereerd jdlj .

privé ORB-bol;

orb = orb_val;

openbare tekenreeks zegHallo() (

return "\nHallo wereld!!\n";

publieke leegte shutdown() (

orb.shutdown(onwaar);

De volgende stap is het creëren van de werkelijkeservergedeelte van de applicatie. Dit zal klasse zijnHalloServer.

Het heeft maar één methode: een standaardfunctievoornaamst.

Het eerste wat we doen is een ORB maken. Vervolgens maken we een exemplaar van de externe objectklasse (Hallo Impl) en registreer het in ORB. Vervolgens roepen we een speciale naamservice (NameService) aan en registreren de naam van het externe object daarin, zodat de client het kan vinden.

Laten we deze fasen eens nader bekijken.

1. Creatie en initialisatie van ORB. Geproduceerd door een statische methode aan te roepenbegin ORB-klasse

2. Een exemplaar van een externe objectklasse maken en deze in de ORB registreren

halloImpl.setORB(orb);

3. De naamcontext ophalen (Naamcontext)

org.omg.CORBA. Object objRef =

In de eerste regel krijgen we een objectverwijzing naar de naamservice (NameService). Maar in feite is dit een gewoon CORBA-object en om het als naamgevingscontext (NamingContext) te gebruiken, moet je de methode aanroepensmal klas NaamgevingContextHelper , wat dit CORBA-object lijkt te specificeren.

4. De naam van het externe object registreren (Hallo Impl)

Tekenreeksnaam = "Hallo";

ncRef. opnieuw binden (pad, href);

De naam wordt geregistreerd zodat de client het externe object kan vinden. Dit doel wordt gediend door de functieopnieuw binden (NaamComponentnc, Voorwerpobj)-interface NaamgevingContext.

5. Wachten op verzoeken van de klant

bol. loop();

De server is nu klaar voor gebruik.

// HalloServer.java

importeer HelloApp.*;

importeer org.omg. CosNaming.*;

importeer org.omg.CORBA.*;

importeer org.omg. Draagbare Server.*;

importeer org.omg. PortableServer.POA;

importeer java.util. Eigenschappen;

klasse HelloImpl breidt HelloPOA uit (

privé ORB-bol;

publieke leegte setORB(ORB orb_val) (

orb = orb_val;

// implementeer de methode SayHello().

openbare tekenreeks zegHallo() (

return "\nHallo wereld!!\n";

// implementeer de shutdown()-methode

publieke leegte shutdown() (

orb.shutdown(onwaar);

openbare klasse HelloServer(

public static void main (String-args) (

poging (

ORB orb = ORB.init(args, null);

// krijg een verwijzing naar rootpoa en activeer de POAManager

POA rootpoa = POAHelper.narrow(orb.resolve_initial_references("RootPOA"));

rootpoa.the_POAManager().activate();

// maak een bediende aan en registreer deze bij de ORB

HalloImpl halloImpl = nieuw HalloImpl();

halloImpl.setORB(orb);

// krijg objectreferentie van de dienaar

org.omg.CORBA. Objectreferentie = rootpoa.servant_to_reference(helloImpl);

Hallo href = HalloHelper.narrow(ref);

// NameService roept de naamservice aan

orb.resolve_initial_references("NaamService");

// Gebruik NamingContextExt, dat deel uitmaakt van Interoperable

// Naming Service (INS)-specificatie.

NamingContextExt ncRef = NamingContextExtHelper.narrow(objRef);

// bind de objectreferentie in Naming

Tekenreeksnaam = "Hallo";

NaamComponent pad = ncRef.to_name(naam);

ncRef.rebind(pad, href);

System.out.println("HelloServer klaar en wachtend...");

// wacht op aanroepen van klanten

orb.run();

vangen (Uitzondering e) (

Systeem.err.println("FOUT:" + e);

System.out.println("HelloServer wordt afgesloten...");

Een klant aanmaken

Laten we verder gaan met het schrijven van code voor de klant.

Basisstappen voor het schrijven van een clienttoepassing

ORB creatie en initialisatie

De naamservicecontext ophalen (NaamgevingContext)

Een object op afstand zoeken

De methode SayHello aanroepen.

De afsluitmethode aanroepen.

Zoals u kunt zien, vallen de eerste twee punten samen met de fasen van het maken van een serverapplicatie, dus we zullen ze niet overwegen.

Het derde punt is ook vrij eenvoudig te implementeren. Er wordt een object gemaaktNaamComponent. De methode wordt genoemdoplossen (NaamComponentpad), dat op naam naar een extern object zoekt (standaardCORBAvoorwerp). Met behulp van de methodesmal (org. omg. CORBA. Voorwerpobj) klas Hallo Helper(gegenereerdIDLcompiler) krijgen we een objectverwijzing naar de interfaceHallo.

Tekenreeksnaam = "Hallo";

Nu kunt u de methode oproepenzeg Hallo:

Methodeafsluitensluit de server af.

halloImpl.shutdown();

//testClient.java

importeer HelloApp.*;

importeer org.omg. CosNaming.*;

importeer org.omg. CosNaaming. NamingContextPackage.*;

importeer org.omg.CORBA.*;

openbare klasse HelloClient

{

statisch Hallo halloImpl;

public static void main (String-args)

{

poging (

// maak en initialiseer de ORB

ORB orb = ORB.init(args, null);

// haal de root-naamgevingscontext op

org.omg.CORBA. Object objRef =

orb.resolve_initial_references("NaamService");

// Gebruik NamingContextExt in plaats van NamingContext. Dit is

// onderdeel van de interoperabele naamgevingsservice.

NamingContextExt ncRef = NamingContextExtHelper.narrow(objRef);

// los de objectreferentie op in Naming

Tekenreeksnaam = "Hallo";

halloImpl = HalloHelper.narrow(ncRef.resolve_str(naam));

System.out.println("Verkregen een handvat op het serverobject:" + helloImpl);

System.out.println(helloImpl.sayHello());

halloImpl.shutdown();

) vangen (Uitzondering e) (

Systeem.out.println("FOUT:" + e);

e.printStackTrace(System.out);

}

Compilatie En launch toepassingen

BestandenHalloServer. Java En Hallo klant. Java, Hallo. nutteloosen mapHalloApp, gemaaktIDKJ. exemoet in één map worden opgeslagen.

Om de client en server te compileren, moet u dat doen opdrachtregel wijzerplaat

javac *.java HelloApp/*.java

Javac. exebevindt zich in...\jdk1.5.0\ bak.

WoensdagVerduisteringlaat niet toe om te rennenCORBAtoepassingen. Om te beginnen

1. Start de dienstorb – Voorwerp Verzoek Makelaar Demon (…\ jdk1.5.0\ bak\ orb. exe). Dit wordt gedaan zodat we een link naar de naamservice kunnen krijgen.

begin orb – ORBInitiële poort 1050

Parameter-ORBInitiële poort– poortnummer waarop de naamserver zal werken.

2. Launch servers

naamserver.

3. Launch cliënt

Specificeert de poort waarop de naamserver draait. Parameter – ORBInitialHost specificeert de host waarop het draaitnaamserver.

Om het compileren en starten te vergemakkelijken, kunt uknuppelbestand:

idlj – herfst Hallo.idl

javac *.java HelloApp/*.java

start java HelloServer – ORBInitialPort 1050 – ORBInitialHost localhost

java HelloClient – ORBInitialPort 1050 – ORBInitialHost localhost

6.2 IDL-taal

TaalOMG IDL (Interface Definitie Taal– Interface Beschrijving Taal) is een technologie-onafhankelijke syntaxis voor het beschrijven van objectinterfaces. Bij het beschrijven van software-architecturen,OMG IDLwordt uitstekend gebruikt als universele notatie voor het definiëren van de grenzen van een object die zijn gedrag ten opzichte van andere componenten van het informatiesysteem bepalen.OMG IDLHiermee kunt u interfaces beschrijven die verschillende methoden en attributen hebben. De taal ondersteunt ook interface-overerving, wat nodig is voor hergebruiken objecten met de mogelijkheid van uitbreiding of specificatie.

IDLis een puur declaratieve taal, dat wil zeggen dat het geen enkele implementatie bevat.IDLspecificaties kunnen worden gecompileerd (weergegeven) in headerbestanden en speciale serverprototypes die direct door de programmeur kunnen worden gebruikt. Dat isIDLbepaalde methoden kunnen worden geschreven en vervolgens worden uitgevoerd in elke taal waarvoor een mapping bestaatIDL. Dergelijke talen omvattenC, C++, SmallTalk, Pascal, Java, Ad.

Door te gebruikenIDLJe kunt de attributen van de component beschrijven, en de bovenliggende klassen die deze overerft, en de uitzonderingen die worden gegenereerd, en ten slotte de methoden die de interface definiëren, met een beschrijving van de invoer- en uitvoerparameters.

StructuurCORBA IDLbestand ziet er als volgt uit:

module(

;

interface [: ] (

;

()

}

interface [: ]

}

TaalsyntaxisIDLbehoorlijk omvangrijk en het is niet mogelijk om dit in een lesboek te beschrijven.

Om de mailserverinterface te implementeren, kunt u toevoegenHallo. nutteloos

module HalloApp

{

struct TBericht

{

tekenreeks Naar;

tekenreeks Van;

tekenreeks Bericht;

};

typedef reeks TBerichten;

interface Hallo

{

TMessages GetMessages (in stringnaam, korte telling uit);

oneway void Verzenden (in string Klant, in string Naam, in string Bericht);

tekenreeks zeg Hallo();

oneway void shutdown();

};

typedef reeks TBerichten; – aankondiging type dynamisch reeks berichtenTBericht.

CORBA (Common Object Request Broker-architectuur)- objectgeoriënteerde technologie voor het creëren van gedistribueerde applicaties. De technologie is gebaseerd op het gebruik Objectaanvraagmakelaar (ORB) voor het transparant verzenden en ontvangen van verzoeken van objecten in een gedistribueerde omgeving. Met deze technologie kunt u applicaties bouwen van gedistribueerde objecten die in verschillende programmeertalen zijn geïmplementeerd. Standaard CORBA ontwikkeld Objectbeheergroep (OMG).

CORBA-architectuur

IN deze sectie wordt gegeven kort overzicht CORBA zoals beschreven in de specificatie OMG versie 3.0. Aan de vereisten van dit document kan in verschillende mate worden voldaan door daadwerkelijke implementaties. makelaars voor objectaanvragen. In afb. Figuur 2.1 toont een verzoek dat door een client naar een objectimplementatie is verzonden. Cliënt is een entiteit die een bewerking op een object wil uitvoeren, en Uitvoering is de verzameling code en gegevens die het object daadwerkelijk implementeert.

ORB is verantwoordelijk voor alle mechanismen die nodig zijn om een geschikte implementatie van een object voor een verzoek te vinden, de implementatie voor te bereiden om het verzoek te ontvangen, en gegevensoverdracht bezig het verzoek vervullen. De interface die zichtbaar is voor de klant is volledig onafhankelijk van de locatie van de implementatie van het object, de programmeertaal waarin het is geschreven en alle andere aspecten die niet in de interfacespecificatie worden weerspiegeld.

De dynamische oproepinterface en de stubinterface hebben dezelfde semantiek, zodat de ontvanger van het bericht niet kan bepalen hoe het verzoek is verzonden. ORB vindt de juiste objectimplementatiecode, stuurt er parameters naar en geeft controle via IDL skelet of dynamisch skelet (Fig. 2.4). Skeletten zijn specifiek voor een bepaalde interface en objectadapter. Tijdens het uitvoeren van de query kan de implementatie gebruik maken van bepaalde services ORB via een objectadapter. Wanneer het verzoek is voltooid, worden de controle- en resultaatwaarden teruggestuurd naar de klant.

Een objectimplementatie kan kiezen welke objectadapter moet worden gebruikt, afhankelijk van welke services deze nodig heeft. In afb. Figuur 2.5 laat zien hoe interface- en implementatie-informatie beschikbaar wordt gesteld aan clients en objectimplementaties. Interfaces worden beschreven in IDL of met behulp van een interfacerepository. Hun beschrijvingen worden gebruikt om klantstubs en skeletten te genereren voor implementatie.

Informatie over de implementatie van het object wordt tijdens de installatie verstrekt en opgeslagen in de implementatierepository, en vervolgens gebruikt tijdens de levering van aanvragen.

Alexander Godin

CORBA-technologie is een standaard voor het schrijven van gedistribueerde applicaties, voorgesteld door het OMG-consortium (Open Management Group). Door CORBA-objecten te maken, kunnen we bijvoorbeeld de tijd die nodig is voor het oplossen van problemen die veel rekenwerk vereisen aanzienlijk verkorten. Dit is mogelijk door CORBA-objecten op verschillende machines te plaatsen. Elk object op afstand lost een specifieke deeltaak op, waardoor de klant onnodig werk wordt ontlast.

Laten we eens kijken naar de interactie van objecten in de CORBA-architectuur

Fig. 1 Interactie van objecten in de CORBA-architectuur

Om een CORBA-toepassing te schrijven met behulp van Java-technologie, hebt u twee dingen nodig: het JDK1.2-pakket geïnstalleerd en een compiler idltojava. De JDK biedt een reeks klassen voor het werken met CORBA-objecten, en idltojava wijst de IDL-taal toe aan Java.

Het maken van een CORBA-toepassing in Java begint met het schrijven van een interface voor een extern object met behulp van de Interface Definition Language (IDL).

Laten we een bestand test.idl maken module testApp (interfacetest (lange telling (in string msg); ); );

Deze interface beschrijft slechts één methode graaf. Bovendien maakt het ons niet uit wat deze methode doet, het belangrijkste is dat we vaststellen dat deze bestaat, we bepalen welke invoer- en uitvoerparameters deze heeft.

Laten we de compiler gebruiken idltojava.

Idltojava Hallo.idl Opmerking. Deze compiler maakt standaard gebruik van de C++-taalpreprocessor, zodat deze niet met foutmeldingen te maken krijgt De opdracht of bestandsnaam is onjuist(het pad ernaartoe moet worden opgegeven in de CPP-omgevingsvariabele) schakel het gebruik ervan uit door de vlaggen in te stellen. idltojava -fno-cpp Hallo.idl Het resultaat van dit programma kan worden weergegeven in de vorm van een diagram.

Fig.2 Werking van de idltojava-compiler
Er is een nieuwe map verschenen in de huidige map testApp, dat vijf Java-bestanden bevat. Elk van hen heeft zijn eigen doel.

_testImplBase.java - een abstracte klasse die niets meer is dan het skelet van de server (skelet) en de functionaliteit van de server levert;

_testStub.java - een klasse die een client-stub implementeert. Biedt clientfunctionaliteit;

test.java - een klasse die een beschrijving bevat van de testinterface in Java;

testHelper.java En testHolder.java - klassen die hulpprogrammafuncties bieden voor CORBA-objecten.

Nu is het onze taak om een klasse te schrijven die de interface implementeert test. Dergelijke klassen moeten zo worden genoemd dat hun naam het woord "Dienaar" bevat, in ons geval zal dat zo zijn testServant.

Klasse testServant breidt _testImplBase uit ( public int count(String msg) ( return msg.length(); ) )

Houd er rekening mee dat deze klasse is geërfd van _testImplBase. Zoals u kunt zien, is hier de telmethode geïmplementeerd, die in in dit voorbeeld Telt het aantal letters in een ontvangen bericht.

Laten we nu verder gaan met het schrijven van het servergedeelte van de applicatie.

Het eerste dat we doen is een ORB maken. Vervolgens maken we een exemplaar van de externe objectklasse (testServant) en registreren deze in de ORB. Vervolgens roepen we een speciale naamservice aan (NameService) en registreren we de naam van het externe object daarin, zodat de client het kan vinden (er is een andere manier om een extern object te vinden, maar daarover later meer).

Laten we deze fasen eens nader bekijken.

ORB-creatie en initialisatie. Geproduceerd door een statische methode aan te roepen begin ORB-klasse
ORB-orb = ORB.init();
Een exemplaar van een externe objectklasse maken en deze in de ORB registreren
testServant testRef = nieuwe testServant();
orb.connect(testRef);
De naamgevingscontext ophalen (NamingContext)
org.omg.CORBA.Object objRef =
orb.resolve_initial_references("NaamService");
NamingContext ncRef = NamingContextHelper.narrow(objRef);
in de eerste regel krijgen we een objectverwijzing naar de naamservice (NameService). Maar in feite is dit een gewoon CORBA-object en om het te gebruiken als naamgevingscontext (NamingContext), moet je de methode aanroepen smal klas NaamgevingContextHelper, wat dit CORBA-object lijkt te specificeren.
De naam van het externe object registreren (testServant)
Zoals eerder vermeld, wordt naamregistratie gedaan zodat de client het externe object kan vinden. Dit doel wordt gediend door de functie rebind(NaamComponent nc, Object obj) interface NaamgevingContext.
NameComponent nc = nieuwe NameComponent("test", ""); //eerste parameter //geeft aan objectnaam
, //we hoeven de tweede niet te gebruiken NameComponent path = (nc);
ncRef.rebind(pad, testRef); graaf Wachten op verzoeken van de klant. java.lang.Object synchronisatie = nieuw java.lang.Object();

gesynchroniseerd (synchroniseren) ( sync.wait(); )

Nadat de server het verzoek van de client heeft verwerkt en de methode heeft uitgevoerd

Importeer testApp.*; importeer org.omg.CosNaming.*; importeer org.omg.CosNaming.NamingContextPackage.*; importeer org.omg.CORBA.*; java.lang.* importeren; klasse testServant breidt _testImplBase uit ( public int count(String msg) ( return msg.length(); ) ) public class testServer ( public static void main(String args) ( try ( ORB orb = ORB.init(args, null); testServant testRef = nieuwe testServant(); orb.connect(testRef); org.omg.CORBA.Object objRef = orb.resolve_initial_references("NameService"); ); ncRef.rebind(pad, testRef); java.lang.Object sync = nieuw java.lang.Object(); gesynchroniseerd (sync) ( sync.wait() ) ) catch (Uitzondering e) ( System.err.println ("FOUT: " + e); e.printStackTrace(System.out ) ) )

Houd er rekening mee dat alle bewerkingen die op CORBA-objecten worden uitgevoerd, zijn opgenomen in een try-catch-blok.

Laten we verder gaan met het schrijven van code voor de klant.

Basisstappen voor het schrijven van een clienttoepassing

ORB creatie en initialisatie
De naamservicecontext ophalen ( NaamgevingContext)
Een object op afstand zoeken
Een methode aanroepen graaf.

Zoals u kunt zien, vallen de eerste twee punten samen met de fasen van het maken van een serverapplicatie, dus we zullen ze niet overwegen.

Het derde punt is ook vrij eenvoudig te implementeren. Er wordt een object gemaakt NaamComponent. De methode wordt genoemd solve(NameComponent-pad), waarmee op naam naar een extern object (standaard CORBA-object) wordt gezocht. Met behulp van de methode narrow(org.omg.CORBA.Object obj) klas testHelper(gegenereerd idltojava compiler) krijgen we een objectverwijzing naar de interface test.

NameComponent nc = nieuwe NameComponent("test", "");

NaamComponentpad = (nc); graaf

org.omg.CORBA.Object obj= ncRef.resolve(pad);

test testRef = testHelper.narrow(obj);

Nu kunt u de methode oproepen

String msg = "probeer te tellen";

Starten van de naamserver (meegeleverd met JDK1.2). Dit wordt gedaan zodat we een link naar de tnameserv-naamservice kunnen krijgen
standaard start de server op poort 900. Deze waarde kan worden gewijzigd door bijvoorbeeld de startparameter -ORBInitialPort op te geven
Tnameserv -ORBInitialPort 1024
Het starten van de server testServer java testServer -ORBInitialPort 1024 // geeft de poort // aan waarop de naamserver werkt
Het lanceren van de cliënt testClient java testClient -ORBInitialHost javas.stu.neva.ru -ORBInitialPort 1024
de parameter -ORBInitialHost specificeert de host waarop deze draait testServer

na het uitvoeren van deze applicatie wordt de console weergegeven

Aantal tekens in bericht is:12

Verbinding maken met een server zonder gebruik te maken van een naamservice

Het basisidee van deze methode is dat de server een exemplaar van de klasse van het externe object opslaat ( testServant) in het formulier tekstbestand overal, toegankelijk voor de cliënt. De client laadt gegevens uit een bestand (in een object Snaar) en converteert met behulp van speciale methoden naar een objectverwijzing naar een extern object.

Dit alles wordt als volgt geïmplementeerd

Laten we een deel van de code verwijderen - dit geldt ook voor de client ( testServer.java En testClient.java)

Laten we org.omg.CosNaming.* uitsluiten van de importbibliotheek.
org.omg.CosNaming.NamingContextPackage.*;

Laten we de code verwijderen die overeenkomt met stap 3-item 4

In plaats van de externe code voegen we voor de server het volgende in: //converteer het object naar een string String ior = orb.object_to_string(testRef);

String bestandsnaam = System.getProperty("user.home") + System.getProperty("file.separator")+"test_file";

//maak een bestand test_file FileOutputStream fos = new FileOutputStream(bestandsnaam); PrintStream ps = nieuwe PrintStream(fos);//schrijf er gegevens naartoe ps.print(ior);