Panduan Penyediaan EJB

1. Gambaran keseluruhan

Dalam artikel ini, kita akan membincangkan bagaimana untuk memulai dengan pengembangan Enterprise JavaBean (EJB).

Enterprise JavaBeans digunakan untuk mengembangkan komponen sisi server yang terukur, diedarkan dan biasanya merangkumi logik perniagaan aplikasi.

Kami akan menggunakan WildFly 10.1.0 sebagai penyelesaian pelayan pilihan kami, namun anda bebas menggunakan pelayan aplikasi Java Enterprise pilihan anda.

2. Persediaan

Mari mulakan dengan membincangkan kebergantungan Maven yang diperlukan untuk pembangunan EJB 3.2 dan bagaimana mengkonfigurasi pelayan aplikasi WildFly menggunakan pemalam Maven Cargo atau secara manual.

2.1. Ketergantungan Maven

Untuk menggunakan EJB 3.2 , pastikan anda menambahkan versi terbaru ke bahagian dependensi pada fail pom.xml anda :

 javax javaee-api 7.0 provided 
Anda akan menemui kebergantungan terbaru di Maven Repository. Ketergantungan ini memastikan bahawa semua Java Java EE 7 API tersedia semasa waktu kompilasi. Ruang lingkup yang disediakan memastikan bahawa setelah digunakan, ketergantungan akan diberikan oleh wadah tempat ia telah digunakan.

2.2. Persediaan WildFly Dengan Maven Cargo

Mari kita bincangkan bagaimana menggunakan pemalam Maven Cargo untuk menyediakan pelayan.

Berikut adalah kod untuk profil Maven yang menyediakan pelayan 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 memuat turun zip WildFly 10.1 terus dari laman web WildFly. Yang kemudiannya dikonfigurasi, dengan memastikan bahawa nama host adalah 127.0.0.1 dan menetapkan port ke 9990.

Kemudian kami membuat pengguna ujian, dengan menggunakan harta kargo.servlet.users , dengan user ID testUser dan kata laluan admin1234 !.

Setelah konfigurasi plugin selesai, kita seharusnya dapat memanggil target Maven dan memuat turun, dipasang, dilancarkan dan aplikasi digunakan oleh pelayan.

Untuk melakukan ini, arahkan ke direktori ejb-remote dan jalankan arahan berikut:

mvn clean package cargo:run

Apabila anda menjalankan perintah ini untuk pertama kalinya, ia akan memuat turun fail zip WildFly 10.1, mengeluarkannya dan melaksanakan pemasangan dan kemudian melancarkannya. Ia juga akan menambahkan pengguna ujian yang dibincangkan di atas. Sebarang pelaksanaan selanjutnya tidak akan memuat turun fail zip lagi.

2.3. Penyediaan Manual WildFly

Untuk menyiapkan WildFly secara manual, anda mesti memuat turun fail zip pemasangan sendiri dari laman web wildfly.org. Langkah-langkah berikut adalah pandangan tahap tinggi proses penyediaan pelayan WildFly:

Setelah memuat turun dan membuka zip fail ke lokasi di mana anda ingin memasang pelayan, konfigurasikan pemboleh ubah persekitaran berikut:

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

Kemudian di direktori tong sampah , jalankan ./standalone.sh untuk sistem operasi berasaskan Linux atau ./standalone.bat untuk Windows.

Selepas ini, anda perlu menambahkan pengguna. Pengguna ini akan digunakan untuk menyambung ke kacang EJB jauh. Untuk mengetahui cara menambah pengguna, anda harus melihat dokumentasi 'tambah pengguna'.

Untuk arahan persediaan terperinci, sila lawati dokumentasi Bermula WildFly.

Projek POM telah dikonfigurasi untuk berfungsi dengan Cargo plugin dan konfigurasi pelayan manual dengan menetapkan dua profil. Secara lalai, plugin Cargo dipilih. Namun untuk menyebarkan aplikasi ke pelayan Wildfly yang sudah dipasang, dikonfigurasi dan dijalankan, jalankan perintah berikut di direktori ejb-remote :

mvn clean install wildfly:deploy -Pwildfly-runtime

3. Jauh vs Tempatan

Antara muka perniagaan untuk kacang boleh tempatan atau jauh.

A @Local beranotasi kacang hanya boleh diakses jika ia adalah dalam permohonan yang sama seperti kacang yang membuat rayuan doa, iaitu jika mereka tinggal dalam yang sama .ear atau .war .

A @Remote kacang beranotasi boleh diakses dari aplikasi yang berbeza, iaitu satu aplikasi yang tinggal di yang lain JVM atau aplikasi pelayan.

Terdapat beberapa perkara penting yang perlu diingat semasa merancang penyelesaian yang merangkumi EJB:

  • The java.io.Serializable , java.io.Externalizable dan antara muka yang ditakrifkan oleh javax.ejb pakej sentiasa dikecualikan apabila kacang itu diisytiharkan dengan @Local atau @Remote
  • Sekiranya kelas kacang jauh, maka semua antara muka yang dilaksanakan harus jauh
  • Sekiranya kelas kacang tidak mengandungi anotasi atau jika anotasi @Local ditentukan, maka semua antara muka yang dilaksanakan dianggap tempatan
  • Sebarang antara muka yang ditentukan secara jelas untuk kacang yang tidak mengandungi antara muka mesti dinyatakan sebagai @Local
  • Pelepasan EJB 3.2 cenderung memberikan lebih terperinci bagi situasi di mana antara muka tempatan dan jarak jauh perlu ditentukan secara jelas

4. Membuat EJB Jauh

Mari mula-mula membuat antara muka kacang dan memanggilnya HelloWorld:

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

Sekarang kita akan melaksanakan antara muka di atas dan menamakan pelaksanaan konkrit 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

Oleh itu, kami telah membuat pelayan EJB dan pelanggan yang menggunakan kaedah pada EJB jauh. Projek ini dapat dijalankan di mana-mana pelayan aplikasi dengan menambahkan kebergantungan untuk pelayan tersebut.

Keseluruhan projek boleh didapati di GitHub.