Panduan untuk Penyiapan EJB

1. Ikhtisar

Pada artikel ini, kita akan membahas cara memulai pengembangan Enterprise JavaBean (EJB).

Enterprise JavaBeans digunakan untuk mengembangkan komponen sisi server yang skalabel, terdistribusi, dan biasanya merangkum logika bisnis aplikasi.

Kami akan menggunakan WildFly 10.1.0 sebagai solusi server pilihan kami, namun, Anda bebas menggunakan server aplikasi Java Enterprise pilihan Anda.

2. Penyiapan

Mari kita mulai dengan membahas dependensi Maven yang diperlukan untuk pengembangan EJB 3.2 dan cara mengkonfigurasi server aplikasi WildFly menggunakan plugin Maven Cargo atau secara manual.

2.1. Ketergantungan Maven

Untuk menggunakan EJB 3.2 , pastikan Anda menambahkan versi terbaru ke bagian dependensi file pom.xml Anda :

 javax javaee-api 7.0 provided 
Anda akan menemukan ketergantungan terbaru di Repositori Maven. Ketergantungan ini memastikan bahwa semua Java EE 7 API tersedia selama waktu kompilasi. The disediakan Memastikan lingkup yang pernah dikerahkan, ketergantungan akan diberikan oleh wadah di mana telah dikerahkan.

2.2. Pengaturan WildFly Dengan Maven Cargo

Mari kita bicara tentang cara menggunakan plugin Maven Cargo untuk menyiapkan server.

Berikut adalah kode untuk profil Maven yang menyediakan server WildFly:

 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!         

Kami menggunakan plugin untuk mengunduh zip WildFly 10.1 langsung dari situs web WildFly. Yang kemudian dikonfigurasi, dengan memastikan bahwa nama host adalah 127.0.0.1 dan mengatur port ke 9990.

Kemudian kita membuat pengguna percobaan, dengan menggunakan properti cargo.servlet.users , dengan id pengguna testUser dan kata sandi admin1234 !.

Sekarang setelah konfigurasi plugin selesai, kita harus dapat memanggil target Maven dan meminta server mengunduh, menginstal, meluncurkan, dan menerapkan aplikasi.

Untuk melakukan ini, navigasikan ke direktori ejb-remote dan jalankan perintah berikut:

mvn clean package cargo:run

Ketika Anda menjalankan perintah ini untuk pertama kali, itu akan mengunduh file zip WildFly 10.1, mengekstraknya dan menjalankan instalasi dan kemudian meluncurkannya. Ini juga akan menambahkan pengguna uji coba yang dibahas di atas. Eksekusi lebih lanjut tidak akan mengunduh file zip lagi.

2.3. Pengaturan Manual WildFly

Untuk mengatur WildFly secara manual, Anda harus mengunduh file zip instalasi sendiri dari situs web wildfly.org. Langkah-langkah berikut adalah tampilan tingkat tinggi dari proses penyiapan server WildFly:

Setelah mengunduh dan mengekstrak konten file ke lokasi tempat Anda ingin menginstal server, konfigurasikan variabel lingkungan berikut:

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

Kemudian di direktori bin , jalankan ./standalone.sh untuk sistem operasi berbasis Linux atau ./standalone.bat untuk Windows.

Setelah ini, Anda harus menambahkan pengguna. Pengguna ini akan digunakan untuk menghubungkan ke kacang EJB jarak jauh. Untuk mengetahui cara menambahkan pengguna, Anda harus melihat dokumentasi 'tambahkan pengguna'.

Untuk instruksi pengaturan rinci, silakan kunjungi dokumentasi Memulai WildFly.

Proyek POM telah dikonfigurasi untuk bekerja dengan plugin Cargo dan konfigurasi server manual dengan mengatur dua profil. Secara default, plugin Cargo dipilih. Namun untuk menerapkan aplikasi ke server Wildfly yang sudah diinstal, dikonfigurasi, dan berjalan, jalankan perintah berikut di direktori ejb-remote :

mvn clean install wildfly:deploy -Pwildfly-runtime

3. Jarak Jauh vs Lokal

Antarmuka bisnis untuk kacang bisa lokal atau jarak jauh.

Sebuah @Local dijelaskan kacang hanya dapat diakses jika berada dalam aplikasi yang sama seperti kacang yang membuat doa, yaitu jika mereka tinggal di sama .ear atau .war .

Sebuah @Remote dijelaskan kacang dapat diakses dari aplikasi yang berbeda, yaitu sebuah aplikasi yang berada di berbeda JVM atau aplikasi server.

Ada beberapa poin penting yang perlu diingat saat merancang solusi yang menyertakan EJB:

  • The java.io.Serializable , java.io.Externalizable dan interface yang didefinisikan oleh javax.ejb paket selalu dikecualikan ketika kacang dinyatakan dengan @Local atau @Remote
  • Jika kelas kacang jauh, maka semua antarmuka yang diimplementasikan harus jarak jauh
  • Jika kelas kacang tidak berisi anotasi atau jika anotasi @Local ditentukan, maka semua antarmuka yang diimplementasikan dianggap lokal.
  • Setiap antarmuka yang secara eksplisit didefinisikan untuk kacang yang tidak mengandung antarmuka harus dideklarasikan sebagai @Local
  • Rilis EJB 3.2 cenderung memberikan lebih banyak perincian untuk situasi di mana antarmuka lokal dan jarak jauh perlu didefinisikan secara eksplisit

4. Membuat EJB Jarak Jauh

Mari pertama-tama buat antarmuka kacang dan beri nama HelloWorld:

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

Sekarang kita akan mengimplementasikan antarmuka di atas dan memberi nama implementasi konkret HelloWorldBean:

@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

Jadi kami telah membuat server EJB dan klien yang memanggil metode pada EJB jarak jauh. Proyek ini dapat dijalankan di server aplikasi apa pun dengan menambahkan dependensi untuk server itu dengan benar.

Seluruh proyek dapat ditemukan di GitHub.