ejbAan de slag met ejb


Opmerkingen

Deze sectie geeft een overzicht van wat ejb is en waarom een ontwikkelaar het misschien wil gebruiken.

Het moet ook alle grote onderwerpen binnen ejb vermelden en een link naar de gerelateerde onderwerpen bevatten. Aangezien de documentatie voor ejb nieuw is, moet u mogelijk eerste versies van die gerelateerde onderwerpen maken.

EJB instellen met JBoss AS 7.1

1. Overzicht

In dit artikel gaan we bespreken hoe u aan de slag kunt met Enterprise JavaBeans (EJB). We zullen JBoss AS 7.1.1.Final gebruiken, maar u kunt elke server van uw keuze gebruiken.

2. Maven afhankelijkheden voor Bean

Om EJB te gebruiken, moet u de nieuwste versie ervan toevoegen aan de afhankelijkheden van uw pom.xml-bestand:

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

Zorg ervoor dat u de JBoss-afhankelijkheden correct toevoegt, omdat we JBoss als onze applicatieserver in deze tutorial zullen gebruiken. In het laatste deel van de tutorial zullen we in detail bespreken hoe de maven build voor het project moet worden ingesteld.

3. EJB-afstandsbediening

Laten we eerst de Bean-interface maken met de naam HelloWorldRemote.

public interface HelloWorldRemote {
    public String getHelloWorld();
}
 

Nu zullen we de bovenstaande interface implementeren en deze de naam HelloWorldBean .

@Stateless
public class HelloWorldBean implements HelloWorldRemote {

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

Let op de @Stateless notatie bovenop de @Stateless . Het duidt op een staatloze sessieboon.

4. Maven Setup voor Remote Bean

In deze sectie zullen we bespreken hoe maven moet worden ingesteld om de applicatie op de server te bouwen en uit te voeren.

Laten we de plug-ins één voor één bekijken.

4.1. Compiler-plug-in

De maven-compiler-plug-in wordt gebruikt om de bronnen van ons project te compileren.

Hier hebben we de versie 2.3.1 van de plug-in gebruikt met de bron- en doel-JDK ingesteld op 1.7 onder configuratie.

We hebben deze instellingen gedefinieerd als eigenschappen in de tag en verwijzen ernaar via $ {property}.

<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 De EJB-plug-in

Deze plug-in genereert Bean-bestand en de bijbehorende client jar.

We hebben de ejb-versie opgegeven als 3.2 en de eigenschap createClient is ingesteld op true waardoor de client wordt gegenereerd.

4.3 Implementeren in JBoss

De jboss-as-maven-plug-in wordt gebruikt om de toepassing in JBoss AS 7 te implementeren, opnieuw te implementeren, de-implementeren of uit te voeren.

In deze configuratie specificeren we de build-bestandsnaam hetzelfde als de project build-bestandsnaam die standaard de vorm artifactid-versie is in ons geval ejb-remote-1.0-SNAPSHOT .

4.4 Vereiste Maven afhankelijkheden voor EJB

jboss-javaee-6.0 definieert de versie van JBoss 'Java EE 6 API's die we willen gebruiken.

JBoss distribueert een complete set Java EE 6 API's inclusief een Bill of Materials (BOM).

Een stuklijst geeft de versies van een stapel (of een verzameling) artefacten aan. We specificeren dit in tag zodat we altijd de juiste versies van artefacten krijgen. Het type van deze afhankelijkheid zelf is een pom die de vereiste afhankelijkheden bevat.

<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 Annotaties

Het volgende krijgt de afhankelijkheid van annotaties:

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

4.6 EJB-versie 3.2

In het volgende stukje code krijgen we de nieuwste versie van de specificaties:

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

Om het bovenstaande project op een JBoss-server uit te voeren, moeten we eerst uitvoeren:

mvn clean install
 

Vervolgens moeten we het implementeren op een actieve JBoss-server door het volgende maven-commando uit te voeren:

jboss-as:deploy
 

Nu zou u het jar-bestand moeten zien dat op de jboss-server wordt geïmplementeerd.

Als alternatief kunt u de beschikbare pot uit de doelmap in het project kopiëren en in de webapp-map van de server plakken.

5. Het clientproject opzetten

Na het maken van de externe bean moeten we de ingezette bean testen door een client te maken.

Laten we eerst de maven-opstelling voor het project bespreken.

5.1 Maven Plugins gebruikt

De maven-compiler-plug-in wordt gebruikt om de bronnen van uw project te compileren.

We specificeerden de jdk 1.7-versie voor bron- en doelklassen.

Onze client is een Java-programma, om het uit te voeren gebruiken we de exec-maven-plugin die helpt bij het uitvoeren van systeem- en Java-programma's. We moeten het uitvoerbare bestand (bijvoorbeeld java), classpath en de java-klasse (com.baeldung.ejb.client.Client) opgeven.

Het klassepad is leeg gelaten omdat de plug-in de nodige klassepadargumenten bevat op basis van de verstrekte afhankelijkheden.

5.2 Maven afhankelijkheden voor EJB3-client

Om de EJB3-client uit te voeren, moeten we de volgende afhankelijkheden opnemen.

We zijn afhankelijk van de externe zakelijke EJB-interfaces van deze applicatie om de client uit te voeren. We moeten dus de afhankelijkheid van de ejb-clientpot opgeven. De tag met de waarde "ejb-client" wordt gebruikt om de afhankelijkheid van dit project van de EJB-clientpot aan te geven.

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

De afhankelijkheden jboss-transaction-api_1.1_spec , jboss-ejb-api_3.1_spec , jboss-ejb-client , xnio-api , xnio-nio , jboss-remoting , jboss-sasl jboss-marshalling-river , jboss-marshalling-river hebben scope als runtime omdat dit zijn vereiste runtime en niet tijdens het compileren.

De afhankelijkheden jboss-javaee-6.0 en jboss-as-ejb-client-bom onder dependencyManagement hebben bereik als import. Dit wordt gebruikt om afhankelijkheidsbeheerinformatie van een externe POM in het huidige project op te nemen. Deze externe POM's worden geleverd door JBoss, die de nodige afhankelijkheden bevat voor het uitvoeren van de client.

5.3 JBoss EJB Clienteigenschappen

Maak een bestand onder "src / main / resources" en noem het als 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. De clientklasse creëren

Eerst maken we een 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;
    }
}
 

Laten we nu de werkelijke Client-klasse maken die de bean verbruikt die we op de server hebben geïmplementeerd:

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;
    }
}
 

De klasse Client verbruikt de boon en voert het resultaat uit.

7. Conclusie

Daarom hebben we een EJB-server en een client gemaakt die de service gebruikt. Het project kan op elke toepassingsserver worden uitgevoerd.