Anleitung zur EJB-Einrichtung

1. Übersicht

In diesem Artikel wird erläutert, wie Sie mit der Entwicklung von Enterprise JavaBean (EJB) beginnen.

Enterprise JavaBeans werden zum Entwickeln skalierbarer, verteilter serverseitiger Komponenten verwendet und kapseln normalerweise die Geschäftslogik der Anwendung.

Wir verwenden WildFly 10.1.0 als unsere bevorzugte Serverlösung. Sie können jedoch jeden Java Enterprise-Anwendungsserver Ihrer Wahl verwenden.

2. Setup

Lassen Sie uns zunächst die für die Entwicklung von EJB 3.2 erforderlichen Maven-Abhängigkeiten und die Konfiguration des WildFly-Anwendungsservers mithilfe des Maven Cargo-Plugins oder manuell erläutern.

2.1. Maven-Abhängigkeit

Um den Einsatz EJB 3.2 , stellen Sie sicher , um die neueste Version des Add - Abhängigkeiten Abschnitt Ihrer pom.xml - Datei:

 javax javaee-api 7.0 provided 
Die neueste Abhängigkeit finden Sie im Maven Repository. Diese Abhängigkeit stellt sicher, dass alle Java EE 7-APIs während der Kompilierungszeit verfügbar sind. Der bereitgestellte Bereich stellt sicher, dass die Abhängigkeit nach der Bereitstellung von dem Container bereitgestellt wird, in dem sie bereitgestellt wurde.

2.2. WildFly-Setup mit Maven Cargo

Lassen Sie uns darüber sprechen, wie Sie das Maven Cargo-Plugin zum Einrichten des Servers verwenden.

Hier ist der Code für das Maven-Profil, das den WildFly-Server bereitstellt:

 wildfly-standalone    org.codehaus.cargo cargo-maven2-plugin ${cargo-maven2-plugin.version   wildfly10x   //download.jboss.org/ wildfly/10.1.0.Final/ wildfly-10.1.0.Final.zip      127.0.0.0  9990   testUser:admin1234!         

Wir verwenden das Plugin, um die WildFly 10.1- Zip direkt von der WildFly-Website herunterzuladen. Dies wird dann konfiguriert, indem sichergestellt wird, dass der Hostname 127.0.0.1 lautet, und der Port auf 9990 gesetzt wird.

Anschließend erstellen wir einen Testbenutzer mithilfe der Eigenschaft load.servlet.users mit der Benutzer-ID testUser und dem Kennwort admin1234!.

Nachdem die Konfiguration des Plugins abgeschlossen ist, sollten wir in der Lage sein, ein Maven-Ziel aufzurufen und den Server herunterzuladen, zu installieren, zu starten und die Anwendung bereitzustellen.

Navigieren Sie dazu zum Verzeichnis ejb-remote und führen Sie den folgenden Befehl aus:

mvn clean package cargo:run

Wenn Sie diesen Befehl zum ersten Mal ausführen, wird die WildFly 10.1-Zip-Datei heruntergeladen, extrahiert, die Installation ausgeführt und anschließend gestartet. Außerdem wird der oben beschriebene Testbenutzer hinzugefügt. Bei weiteren Ausführungen wird die Zip-Datei nicht erneut heruntergeladen.

2.3. Manuelle Einrichtung von WildFly

Um WildFly manuell einzurichten, müssen Sie die Installations-Zip-Datei selbst von der Website wildfly.org herunterladen. Die folgenden Schritte sind eine allgemeine Ansicht des WildFly-Server-Setup-Prozesses:

Konfigurieren Sie nach dem Herunterladen und Entpacken des Dateiinhalts an den Speicherort, an dem Sie den Server installieren möchten, die folgenden Umgebungsvariablen:

JBOSS_HOME=/Users/$USER/../wildfly.x.x.Final JAVA_HOME=`/usr/libexec/java_home -v 1.8`

Führen Sie dann im Verzeichnis bin die Datei ./standalone.sh für Linux-basierte Betriebssysteme oder ./standalone.bat für Windows aus.

Danach müssen Sie einen Benutzer hinzufügen. Dieser Benutzer wird verwendet, um eine Verbindung zur Remote-EJB-Bean herzustellen. Um herauszufinden, wie Sie einen Benutzer hinzufügen können, lesen Sie die Dokumentation zum Hinzufügen eines Benutzers.

Ausführliche Anweisungen zur Einrichtung finden Sie in der Dokumentation zu den ersten Schritten von WildFly.

Das Projekt-POM wurde so konfiguriert, dass es mit dem Cargo-Plugin und der manuellen Serverkonfiguration funktioniert, indem zwei Profile festgelegt werden. Standardmäßig ist das Cargo-Plugin ausgewählt. Führen Sie jedoch den folgenden Befehl im Verzeichnis ejb-remote aus , um die Anwendung auf einem bereits installierten, konfigurierten und ausgeführten Wildfly-Server bereitzustellen :

mvn clean install wildfly:deploy -Pwildfly-runtime

3. Remote vs Local

Eine Geschäftsschnittstelle für eine Bean kann entweder lokal oder remote sein.

Auf eine mit @Local annotierte Bean kann nur zugegriffen werden, wenn sie sich in derselben Anwendung befindet wie die Bean, die den Aufruf ausführt , dh wenn sie sich in derselben .ear- oder .war- Datei befinden .

Auf eine mit @ Remote kommentierte Bean kann von einer anderen Anwendung aus zugegriffen werden, dh von einer Anwendung, die sich in einer anderen JVM oder einem anderen Anwendungsserver befindet.

Beim Entwerfen einer Lösung mit EJBs sind einige wichtige Punkte zu beachten:

  • Die java.io.Serializable , java.io.Externalizable und Schnittstellen , die von dem definierten javax.ejb Paket immer ausgeschlossen , wenn ein Bean mit deklariert ist @Local oder @Remote
  • Wenn eine Bean-Klasse remote ist, müssen alle implementierten Schnittstellen remote sein
  • Wenn eine Bean-Klasse keine Annotation enthält oder wenn die @ Local- Annotation angegeben ist, werden alle implementierten Schnittstellen als lokal angenommen
  • Jede Schnittstelle, die explizit für eine Bean definiert ist, die keine Schnittstelle enthält, muss als @Local deklariert werden
  • Die Version EJB 3.2 bietet tendenziell mehr Granularität für Situationen, in denen lokale und Remote-Schnittstellen explizit definiert werden müssen

4. Erstellen des Remote- EJB

Lassen Sie uns zuerst die Schnittstelle der Bean erstellen und sie HelloWorld nennen:

@Remote public interface HelloWorld { String getHelloWorld(); }

Jetzt werden wir die obige Schnittstelle implementieren und die konkrete Implementierung HelloWorldBean benennen :

@Stateless(name = "HelloWorld") public class HelloWorldBean implements HelloWorld { @Resource private SessionContext context; @Override public String getHelloWorld() { return "Welcome to EJB Tutorial!"; } }

Note the @Stateless annotation on the class declaration. It denotes that this bean is a stateless session bean. This kind of bean does not have any associated client state, but it may preserve its instance state and is normally used to do independent operations.

The @Resource annotation injects the session context into the remote bean.

The SessionContext interface provides access to the runtime session context that the container provides for a session bean instance. The container then passes the SessionContext interface to an instance after the instance has been created. The session context remains associated with that instance for its lifetime.

The EJB container normally creates a pool of stateless bean's objects and uses these objects to process client requests. As a result of this pooling mechanism, instance variable values are not guaranteed to be maintained across lookup method calls.

5. Remote Setup

In this section, we will discuss how to setup Maven to build and run the application on the server.

Let's look at the plugins one by one.

5.1. The EJB Plugin

The EJB plugin which is given below is used to package an EJB module. We have specified the EJB version as 3.2.

The following plugin configuration is used to setup the target JAR for the bean:

 maven-ejb-plugin 2.4  3.2  

5.2. Deploy the Remote EJB

To deploy the bean in a WildFly server ensure that the server is up and running.

Then to execute the remote setup we will need to run the following Maven commands against the pom file in the ejb-remote project:

mvn clean install 

Then we should run:

mvn wildfly:deploy

Alternatively, we can deploy it manually as an admin user from the admin console of the application server.

6. Client Setup

After creating the remote bean we should test the deployed bean by creating a client.

First, let's discuss the Maven setup for the client project.

6.1. Client-Side Maven Setup

In order to launch the EJB3 client we need to add the following dependencies:

 org.wildfly wildfly-ejb-client-bom pom import 

We depend on the EJB remote business interfaces of this application to run the client. So we need to specify the EJB client JAR dependency. We add the following in the parent pom:

 com.baeldung.ejb ejb-remote ejb 

The is specified as ejb.

6.2. Accessing the Remote Bean

We need to create a file under src/main/resources and name it jboss-ejb-client.properties that will contain all the properties that are required to access the deployed bean:

remote.connections=default remote.connection.default.host=127.0.0.1 remote.connection.default.port=8080 remote.connection.default.connect.options.org.xnio.Options .SASL_POLICY_NOANONYMOUS = false remote.connection.default.connect.options.org.xnio.Options .SASL_POLICY_NOPLAINTEXT = false remote.connection.default.connect.options.org.xnio.Options .SASL_DISALLOWED_MECHANISMS = ${host.auth:JBOSS-LOCAL-USER} remote.connection.default.username=testUser remote.connection.default.password=admin1234! 

7. Creating the Client

The class that will access and use the remote HelloWorld bean has been created in EJBClient.java which is in the com.baeldung.ejb.client package.

7.1 Remote Bean URL

The remote bean is located via a URL that conforms to the following format:

ejb:${appName}/${moduleName}/${distinctName}/${beanName}!${viewClassName}
  • The ${appName} is the application name of the deployment. Here we have not used any EAR file but a simple JAR or WAR deployment, so the application name will be empty
  • The ${moduleName} is the name we set for our deployment earlier, so it is ejb-remote
  • The ${distinctName} is a specific name which can be optionally assigned to the deployments that are deployed on the server. If a deployment doesn't use distinct-name then we can use an empty String in the JNDI name, for the distinct-name, as we did in our example
  • The ${beanName} variable is the simple name of the implementation class of the EJB, so in our example it is HelloWorld
  • ${viewClassName} denotes the fully-qualified interface name of the remote interface

7.2 Look-up Logic

Next, let's have a look at our simple look-up logic:

public HelloWorld lookup() throws NamingException { String appName = ""; String moduleName = "remote"; String distinctName = ""; String beanName = "HelloWorld"; String viewClassName = HelloWorld.class.getName(); String toLookup = String.format("ejb:%s/%s/%s/%s!%s", appName, moduleName, distinctName, beanName, viewClassName); return (HelloWorld) context.lookup(toLookup); }

In order to connect to the bean we just created, we will need a URL which we can feed into the context.

7.3 The Initial Context

We'll now create/initialize the session context:

public void createInitialContext() throws NamingException { Properties prop = new Properties(); prop.put(Context.URL_PKG_PREFIXES, "org.jboss.ejb.client.naming"); prop.put(Context.INITIAL_CONTEXT_FACTORY, "org.jboss.naming.remote.client.InitialContextFacto[ERROR] prop.put(Context.PROVIDER_URL, "http-remoting://127.0.0.1:8080"); prop.put(Context.SECURITY_PRINCIPAL, "testUser"); prop.put(Context.SECURITY_CREDENTIALS, "admin1234!"); prop.put("jboss.naming.client.ejb.context", false); context = new InitialContext(prop); }

To connect to the remote bean we need a JNDI context. The context factory is provided by the Maven artifact org.jboss:jboss-remote-naming and this creates a JNDI context, which will resolve the URL constructed in the lookup method, into proxies to the remote application server process.

7.4 Define Lookup Parameters

We define the factory class with the parameter Context.INITIAL_CONTEXT_FACTORY.

The Context.URL_PKG_PREFIXES is used to define a package to scan for additional naming context.

The parameter org.jboss.ejb.client.scoped.context = false tells the context to read the connection parameters (such as the connection host and port) from the provided map instead of from a classpath configuration file. This is especially helpful if we want to create a JAR bundle that should be able to connect to different hosts.

The parameter Context.PROVIDER_URL defines the connection schema and should start with http-remoting://.

8. Testing

To test the deployment and check the setup, we can run the following test to make sure everything works properly:

@Test public void testEJBClient() { EJBClient ejbClient = new EJBClient(); HelloWorldBean bean = new HelloWorldBean(); assertEquals(bean.getHelloWorld(), ejbClient.getEJBRemoteMessage()); }

With the test passing, we can now be sure everything is working as expected.

9. Conclusion

Daher haben wir einen EJB-Server und einen Client erstellt, die eine Methode auf einem Remote-EJB aufrufen. Das Projekt kann auf jedem Anwendungsserver ausgeführt werden, indem die Abhängigkeiten für diesen Server ordnungsgemäß hinzugefügt werden.

Das gesamte Projekt finden Sie auf GitHub.