Migliore prassi: Moduli e disposizione per i servizi aziendali

Quando si sviluppano le applicazioni business integration, potrebbe essere necessario effettuare operazioni con risorse, quali file JSP, file JAR, progetti web, progetti Java e progetti J2EE. Questo argomento fornisce le informazioni che consentono di impostare progetti e risorse in modo da crearli e distribuirli correttamente a WebSphere Process Server.

File JavaServer Pages che funzionano con i riferimenti autonomi

I file JSP (JavaServer Pages) richiamano i componenti SCA (Service Component Architecture) utilizzando i riferimenti autonomi nell'assieme del modulo. Il file JSP deve essere distribuito nello stesso file EAR dell'assieme del modulo. Di seguito sono riportati i passi per l'aggiunta del file JSP al modulo:
  1. Creare un progetto web.
  2. Creare il file JSP nel progetto web. Se si sta importando il codice, importarlo in questo progetto web. Vedere Codice JSP di esempio.
  3. Aprire il modulo (che dispone dei riferimenti autonomi) con l'editor delle dipendenze. Aggiungere una dipendenza al progetto web come progetto J2EE. Assicurarsi che l'opzione della casella di controllo Distribuisci con il modulo sia selezionata, in modo che il progetto web venga aggiunto al file EAR.
Nota: Non copiare il file sca.references in un altro file EAR. Il file non funziona al di fuori del modulo cui appartiene.

Se il progetto web è un altro file EAR, il file JSP si trova in un altro modulo e le importazioni o esportazioni sono richieste affinché funzioni con i servizi in un altro modulo.

Codice JSP di esempio

Di seguito è riportato un codice JSP di esempio che utilizza i riferimenti autonomi nell'assieme del modulo:

com.ibm.websphere.sca.Service bankService = (com.ibm.websphere.sca.Service)com.ibm.websphere.sca.ServiceManager.INSTANCE.locateService("BankServicePartner");
=> Il nome di riferimento "BankServicePartner" deriva dal file sca.references nel modulo (ad esempio, <reference name="BankServicePartner">...). Questo file esisterà dopo la creazione di un riferimento autonomo nell'editor dei collegamenti.
com.ibm.websphere.sca.scdl.OperationType operationType = bankService.getReference().getOperationType("openAccount");
=> Verrà utilizzato il tipo di operazione per ottenere i tipi DataObject che devono essere inoltrati nell'operazione invoke
com.ibm.websphere.bo.BOFactory factory = (com.ibm.websphere.bo.BOFactory) new com.ibm.websphere.sca.ServiceManager().locateService("com/ibm/websphere/bo/BOFactory");
=> Modo standard per ottenere la produzione per la creazione di oggetti business.
commonj.sdo.DataObject input = factory.createByType(operationType.getInputType());
=> creare il tipo appropriato di oggetto di dati che l'operazione prevede come input
commonj.sdo.DataObject customer = input;
=> supporre di non disporre di un input avviluppato, per ora
if(operationType.isWrapperType(operationType.getInputType()))
{
=> Per richiamare il riferimento in questo caso, è necessario inoltrare il wrapper definito nel file WSDL dell'interfaccia. Quindi, creare l'oggetto dati avviluppato e impostarlo sul wrapper (il nome della proprietà deriva dallo schema integrato nel file WSDL).
customer = factory.createByType(operationType.getInputType().getProperty("customer").getType());
input.set("customer", customer);
}
customer.setString("firstName", "Bob");
customer.setString("lastName", "Smith");
customer.setString("address", "7 Holly Drive");
customer.setBoolean("isGold", true);
customer.setInt("birthYear", 1976);
=> Le 5 righe precedenti impostano gli attributi su Cliente.
commonj.sdo.DataObject output = (commonj.sdo.DataObject)bankService.invoke("openAccount",input);
commonj.sdo.DataObject account = null;
if(operationType.isWrapperType(operationType.getOutputType()))
account = output.getDataObject("account");
else
	account = output;
=> L'output restituito può o meno essere avviluppato. 

Attività con il codice Java

Migliore utilizzo: per sviluppare applicazioni Java o importare file JAR che verranno utilizzati in un modulo business integration, è necessario creare un progetto Java per il codice ed aggiungere una dipendenza al progetto Java per il modulo che utilizzerà il codice Java.

Le proprietà Java della libreria o del modulo business integration non devono essere modificate, poiché ciò potrebbe causare problemi nella distribuzione della generazione del codice. Pertanto, non si consiglia di sviluppare applicazioni Java complesse o importare file JAR in un modulo della libreria per utilizzarli. Inoltre, durante la generazione delle implementazioni Java per i componenti in un diagramma di assieme, le implementazioni Java generate devono essere utilizzate come punto di avvio per richiamare altre classi Java.

Si noti che la vista Business Integration visualizza solo le implementazioni e le interfacce Java che vengono utilizzate in un diagramma di assieme. Vengono elencate nel modulo che le utilizza. Se è necessario effettuare attività con i progetti Java, è possibile passare alla prospettiva Java.

Passaggio alla prospettiva Java

Aprire la prospettiva Java effettuando questi passi:

  1. Dal menu, selezionare Finestra > Apri prospettiva > Altro....
  2. Selezionare Java, quindi fare clic su OK.

Nella prospettiva Java, vengono visualizzate le due prospettive aperte nell'angolo in alto a destra della finestra Workbench ed è possibile passare dalla prospettiva Business Integration facendo clic sul pulsante Prospettiva Business Integration, come illustrato nella seguente figura:

angolo superiore destro della finestra Workbench che visualizza i due pulsanti della prospettiva

Di seguito sono riportate alcune istruzioni per lo sviluppo Java in un progetto Java:
  • Creare un progetto Java.
  • Eseguire lo sviluppo Java nel progetto Java. Se è necessario importare un file JAR, importarlo nel progetto Java. Non importare i file JAR nel modulo o nella libreria, il file JAR non verrà aggiunto al file EAR.
  • Aprire il modulo che utilizzerà il codice Java con l'editor delle dipendenze. Aggiungere il progetto Java come dipendente e assicurarsi che sia selezionata la casella di controllo Distribuisci con il modulo. L'editor delle dipendenze aggiungerà il progetto Java al percorso di classe del modulo. Il file JAR verrà distribuito con il modulo.

Oggetti e le interfacce business per le importazioni e le esportazioni

Migliore utilizzo: se si pianifica di utilizzare le importazioni e le esportazioni nei diagrammi di assieme, è una buona pratica inserire le interfacce e gli oggetti business utilizzati dall'importazione e dalle esportazioni in una libreria, in modo che possano essere condivisi. Quindi, aggiungere una dipendenza nella libreria a tutti i moduli che utilizzando le risorse comuni. Evitare di copiare le stesse interfacce e oggetti business in vari moduli per utilizzarli.

Risorse della libreria condivise

Dopo la distribuzione, se le risorse condivise vengono modificate nella libreria, è necessario aggiornare i moduli che le utilizzano. Ad esempio, due moduli che condividono alcune risorse in una libreria. Le applicazioni vengono distribuite. Uno dei moduli deve essere aggiornato, poiché sono state effettuate delle modifiche ad alcune delle risorse condivise nella libreria. In questo caso, è necessario aggiornare anche il secondo modulo per applicare le modifiche nelle risorse condivise.

I file WSDL devono trovarsi in un modulo o una libreria.

Se è necessario utilizzare un file WSDL in un modulo, copiarlo nel modulo stesso. Facoltativamente, copiare il file WSDL in una libreria e, nel modulo, impostare una dipendenza nella libreria, in modo da poter utilizzare le risorse della libreria. Se si è tentato di trascinare un file WSDL da un altro tipo di progetto, ad esempio un progetto web, un messaggio di errore richiede di copiare il WSDL nel modulo o nella libreria.

Nomi del modulo J2EE

Il modulo business integration è un progetto semplice che produce un file EAR J2EE costituito da progetti J2EE. Se il modulo è denominato MyApp, vengono generati i progetti J2EE con tali nomi e non è possibile utilizzarli per i propri progetti J2EE:
  • MyAppApp
  • MyAppEJB
  • MyAppEJBClient
  • MyAppWeb

Modifica delle dipendenze senza editor

La modifica delle dipendenze dei moduli al di fuori dell'editor delle dipendenze dovrebbe essere evitata.

Quando si aggiunge una dipendenza su una libreria, le modifiche al progetto Java o J2EE vengono effettuate nelle proprietà del modulo. Ovvero, le proprietà del modulo vengono modificate, nel modo seguente:

  • Il Percorso di creazione Java ha la libreria o il progetto aggiunto al percorso di creazione.
  • I Riferimenti del progetto determinano i progetti J2EE o i JAR del programma di utilità da includere nel file EAR risultante per il modulo. Se nell'editor delle dipendenze, è selezionata anche la libreria o il progetto da Distribuire con il modulo, i Riferimenti del progetto avranno una libreria o un progetto selezionato, in modo che quest'ultimo verrà aggiunto al file EAR.

Utilizzare l'editor delle dipendenze per gestire le dipendenze dei progetti per i moduli e le librerie invece di modificarne le proprietà. Nelle proprietà dei moduli e delle librerie sono stabiliti importanti presupposti Java, pertanto le proprietà Java non devono essere modificate, ad esempio per modificare le cartelle di origine e di output.

Concetti correlati
Moduli e librerie
Dipendenze di moduli e librerie
Capacità e ruoli Business integration
Cheat sheet di Business integration
Servizi aziendali: Componenti e moduli
Servizi di mediazione: Componenti e moduli di mediazione
Attività correlate
Creazione di un modulo per i servizi aziendali
Creazione di un modulo di mediazione
Modifica dello spazio dei nomi predefinito
Abilitazione delle capacità degli strumenti
Aggiunta di dipendenze ai moduli e alle librerie
Creazione della libreria
Creazione di esportazioni
Riferimenti correlati
Interfacce e riferimenti WSDL e Java

Informazioni correlate

Supporto didattico: Attività con i moduli e le librerie

Commenti
(C) Copyright IBM Corporation 2005, 2006. Tutti i diritti riservati.