Looking for ejb Answers? Try Ask4KnowledgeBase
Looking for ejb Keywords? Try Ask4Keywords

ejbErste Schritte mit EJB


Bemerkungen

In diesem Abschnitt erhalten Sie einen Überblick darüber, was Ejb ist und warum ein Entwickler es verwenden möchte.

Es sollte auch alle großen Themen in ejb erwähnen und auf die verwandten Themen verweisen. Da die Dokumentation für ejb neu ist, müssen Sie möglicherweise erste Versionen dieser verwandten Themen erstellen.

EJB mit JBoss AS einrichten 7.1

1. Übersicht

In diesem Artikel werden wir die ersten Schritte mit Enterprise JavaBeans (EJB) diskutieren. Wir verwenden JBoss AS 7.1.1.Final, Sie können jedoch einen beliebigen Server Ihrer Wahl verwenden.

2. Maven-Abhängigkeiten für Bean

Um EJB verwenden zu können, müssen Sie die neueste Version davon in den Abhängigkeitsbereich Ihrer Datei pom.xml aufnehmen:

<dependency>
    <groupId>org.jboss.spec.javax.ejb</groupId>
    <artifactId>jboss-ejb-api_3.2_spec</artifactId>
    <version>1.0.0.Final</version>
</dependency>
 

Stellen Sie sicher, dass Sie die JBoss-Abhängigkeiten ordnungsgemäß hinzufügen, da in diesem Lernprogramm JBoss als Anwendungsserver verwendet wird. Im späteren Teil des Tutorials werden wir ausführlich auf die Einrichtung des Maven Build für das Projekt eingehen.

3. EJB-Fernbedienung

Zuerst erstellen wir das Bean Interface namens HelloWorldRemote.

public interface HelloWorldRemote {
    public String getHelloWorld();
}
 

Jetzt implementieren wir die obige Schnittstelle und nennen sie HelloWorldBean .

@Stateless
public class HelloWorldBean implements HelloWorldRemote {

    public HelloWorldBean() {
    
    }
    
    @Override
    public String getHelloWorld(){
        return ("Hello World");
    }
}
 

Beachten Sie die @Stateless Notation oberhalb der Klassendeklaration. Es bezeichnet eine zustandslose Session-Bean.

4. Maven-Setup für Remote Bean

In diesem Abschnitt erfahren Sie, wie Sie maven einrichten, um die Anwendung auf dem Server zu erstellen und auszuführen.

Schauen wir uns die Plugins nacheinander an.

4.1. Compiler-Plugin

Das Maven-Compiler-Plugin wird verwendet, um die Quellen unseres Projekts zu kompilieren.

Hier haben wir die Version 2.3.1 des Plugins verwendet, deren Quell- und Ziel-JDK unter Konfiguration auf 1.7 gesetzt sind.

Wir haben diese Einstellungen als Eigenschaften innerhalb des Tags definiert und über $ {property} referenziert.

<version.compiler.plugin>2.3.1</version.compiler.plugin>
<!-- maven-compiler-plugin -->
<maven.compiler.target>1.7</maven.compiler.target>
<maven.compiler.source>1.7</maven.compiler.source>
 

4.2 Das EJB-Plugin

Dieses Plugin generiert die Bean-Datei sowie die zugehörige Client-Jar.

Wir haben die ejb-Version als 3.2 angegeben und die Eigenschaft generateClient ist auf true gesetzt, wodurch der Client generiert wird.

4.3 Bereitstellung in JBoss

Das jboss-as-maven-plugin wird verwendet, um die Anwendung in JBoss AS 7 bereitzustellen, erneut zu implementieren, die Bereitstellung aufzuheben oder die Bereitstellung aufzuheben.

In dieser Konfiguration geben wir den Namen der Build-Datei an, der dem Dateinamen des Projekt ejb-remote-1.0-SNAPSHOT . In diesem Fall ist die Artifactid-Version in diesem Fall ejb-remote-1.0-SNAPSHOT .

4.4 Erforderliche Maven-Abhängigkeiten für EJB

jboss-javaee-6.0 definiert die Version der Java EE 6-APIs von JBoss, die wir verwenden möchten.

JBoss vertreibt einen vollständigen Satz von Java EE 6-APIs, einschließlich einer Stückliste.

Eine Stückliste gibt die Versionen eines Stapels (oder einer Sammlung) von Artefakten an. Wir geben dies im Tag an, damit wir immer die korrekten Versionen von Artefakten erhalten. Der Typ dieser Abhängigkeit selbst ist ein Pom, der die erforderlichen Abhängigkeiten enthält.

<dependency>
    <groupId>org.jboss.spec</groupId>
    <artifactId>jboss-javaee-6.0</artifactId>
    <version>${version.org.jboss.spec.jboss.javaee.6.0}</version>
    <type>pom</type>
    <scope>import</scope>
</dependency>
 

4.5 Anmerkungen

Folgendes wird die Annotationsabhängigkeit erhalten:

<dependency>
    <groupId>org.jboss.spec.javax.annotation</groupId>
    <artifactId>jboss-annotations-api_1.1_spec</artifactId>
    <scope>provided</scope>
</dependency>
 

4.6 EJB-Version 3.2

Im folgenden Code erhalten wir die neueste Version der Spezifikationen:

<dependency>
    <groupId>org.jboss.spec.javax.ejb</groupId>
    <artifactId>jboss-ejb-api_3.2_spec</artifactId>
    <version>1.0.0.Final</version>
</dependency>
 

Um das obige Projekt auf einem JBoss-Server auszuführen, müssen wir zuerst Folgendes ausführen:

mvn clean install
 

Dann müssen wir es auf einem laufenden JBoss-Server bereitstellen, indem Sie den folgenden Befehl ausführen:

jboss-as:deploy
 

Jetzt sollte die JAR-Datei auf dem JBoss-Server bereitgestellt werden.

Alternativ können Sie den verfügbaren Jar aus dem Zielordner im Projekt kopieren und in den Webapp-Ordner des Servers einfügen.

5. Einrichten des Client-Projekts

Nach dem Erstellen des Remote-Beans sollten wir das implementierte Bean testen, indem wir einen Client erstellen.

Lassen Sie uns zuerst die Maven-Konfiguration für das Projekt besprechen.

5.1 Maven Plugins verwendet

Das Maven-Compiler-Plugin wird verwendet, um die Quellen Ihres Projekts zu kompilieren.

Wir haben die Version jdk 1.7 für Quell- und Zielklassen angegeben.

Unser a-Client ist ein Java-Programm. exec-maven-plugin es auszuführen, verwenden wir das exec-maven-plugin das System- und Java-Programme ausführt. Wir müssen die ausführbare Datei (dh Java), den Klassenpfad und die Java-Klasse (com.baeldung.ejb.client.Client) angeben.

Der Klassenpfad bleibt leer, da das Plugin die erforderlichen Klassenpfadargumente enthält, die auf den bereitgestellten Abhängigkeiten basieren.

5.2 Maven-Abhängigkeiten für den EJB3-Client

Um den EJB3-Client auszuführen, müssen wir die folgenden Abhängigkeiten berücksichtigen.

Wir sind auf die EJB-Remote-Business-Schnittstellen dieser Anwendung angewiesen, um den Client auszuführen. Daher müssen wir die Ejb-Client-Jar-Abhängigkeit angeben. Das Tag mit dem Wert "ejb-client" wird verwendet, um die Abhängigkeit dieses Projekts von der EJB-Client-Dose festzulegen.

<dependency>
    <groupId>com.theopentutorials.ejb3</groupId>
    <artifactId>ejbmavendemo</artifactId>
    <type>ejb-client</type>
    <version>${project.version}</version>
</dependency>
 

Die Abhängigkeiten jboss-transaction-api_1.1_spec , jboss-ejb-api_3.1_spec , jboss-ejb-client , xnio-api , xnio-nio , jboss-remoting jboss-sasl , jboss-sasl , jboss-marshalling-river haben als Laufzeitfaktor Gültigkeit Diese sind zur Laufzeit und nicht während der Kompilierungszeit erforderlich.

Die Abhängigkeiten jboss-javaee-6.0 und jboss-as-ejb-client-bom unter dependencyManagement haben Gültigkeitsbereich als Import. Dies wird verwendet, um Informationen zur Abhängigkeitsverwaltung von einem Remote-POM in das aktuelle Projekt aufzunehmen. Diese Remote-POMs werden von JBoss bereitgestellt, das die erforderlichen Abhängigkeiten zum Ausführen des Clients enthält.

5.3 Eigenschaften des JBoss EJB-Clients

Erstellen Sie eine Datei unter "src / main / resources" und nennen Sie sie "jboss-ejb-client.properties".

remote.connectionprovider.create.options.org.xnio.Options.SSL_ENABLED=false
remote.connections=default
remote.connection.default.host=localhost
remote.connection.default.port = 4447
remote.connection.default.connect.options.org.xnio.Options.SASL_POLICY_NOANONYMOUS=false
 

6. Erstellen der Client-Klasse

Zuerst erstellen wir eine ClientUtility-Klasse:

public class ClientUtility {
    private static Context initialContext;
    private static final String PKG_INTERFACES = "org.jboss.ejb.client.naming";

    public static Context getInitialContext() throws NamingException {
        if (initialContext == null) {
            Properties properties = new Properties();
            properties.put(Context.URL_PKG_PREFIXES, PKG_INTERFACES);
            initialContext = new InitialContext(properties);
         }
        return initialContext;
    }
}
 

Nun erstellen wir die eigentliche Client-Klasse, die die Bean, die wir auf dem Server bereitgestellt haben, verbraucht:

public class Client {
    
    //The lookup method to get the EJB name
    private static HelloWorldRemote doLookup() {
        Context context = null;
        HelloWorldRemote bean = null;
        try {
            // 1. Obtaining Context
            context = ClientUtility.getInitialContext();
            // 2. Generate JNDI Lookup name
            String lookupName = getLookupName();
            // 3. Lookup and cast
            bean = (HelloWorldRemote) context.lookup(lookupName);
 
        } catch (NamingException e) {
            e.printStackTrace();
        }
        return bean;
    }
 
    private static String getLookupName() {
        
         // The app name is the EAR name of the deployed EJB without .ear suffix.
         // Since we haven't deployed the application as a .ear, the app name for
         // us will be an empty string
         
        String appName = "";
 
        
         // The module name is the JAR name of the deployed EJB without the .jar
         // suffix.
        String moduleName = "ejb-remote-0.0.1-SNAPSHOT";
 
        
        // AS7 allows each deployment to have an (optional) distinct name. This
        // can be an empty string if distinct name is not specified.
        String distinctName = "";
 
        // The EJB bean implementation class name
        String beanName = "HelloWorldBean";
 
        // Fully qualified remote interface name
        final String interfaceName = "com.baeldung.ejb.tutorial.HelloWorldRemote";
 
        // Create a look up string name
        String name = "ejb:" + appName + "/" + moduleName + "/" + distinctName
                + "/" + beanName + "!" + interfaceName;
        
        return name;
    }
}
 

Die Client-Klasse verwendet das Bean und gibt das Ergebnis aus.

7. Fazit

Wir haben also einen EJB-Server und einen Client erstellt, der den Dienst in Anspruch nimmt. Das Projekt kann auf einem beliebigen Anwendungsserver ausgeführt werden.