Beispiel: Einfache Entity Bean

Inhalt:

Aufbau des Beispieles

Der Weg des Assistenten: Project Facet "Java Persistence API"

Anmerkung (stammt aus einer älteren Eclipse-Version, mit Eclipse 2023-12 konnte ich die Meldung nicht mehr reproduzieren, das könnte aber auch daran liegen, dass die JPA-Validierung vermutlich die JakartaEE10-Entity Beans nicht erkennt und deshalb nicht in die Situation kommt, diese Validierung durchzuführen):

Führt man diesen Schritt nicht durch, führt jede vorhandene EntityBean zu einem nervigen Validierungsfehler wie diesem:

Class "de.hsrm.jakartaee.knauf.kuchen.KuchenSimpleBean" is managed, but is not listed in the persistence.xml file

Grund ist wohl, dass hier die Option "Discover annotated classes automatically" standardmäßig angeschaltet wird. Ignoriert man diesen Schritt, scheint der Default auf "Annotated classes must be listed in persistence.xml" zu stehen. Bugreport: https://bugs.eclipse.org/bugs/show_bug.cgi?id=460162

Nachträglich kann man diesen Schritte erreichen über die "Project Properties":

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.2"
    xmlns="http://xmlns.jcp.org/xml/ns/persistence"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence http://xmlns.jcp.org/xml/ns/persistence/persistence_2_2.xsd">
  <persistence-unit name="KuchenSimpleEJB">
  </persistence-unit>
</persistence>

<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="https://jakarta.ee/xml/ns/persistence"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="https://jakarta.ee/xml/ns/persistence https://jakarta.ee/xml/ns/persistence/persistence_3_0.xsd"
    version="3.0">
  <persistence-unit name="KuchenSimpleEJB">
  </persistence-unit>
</persistence>

<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="https://jakarta.ee/xml/ns/persistence"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="https://jakarta.ee/xml/ns/persistence https://jakarta.ee/xml/ns/persistence/persistence_3_0.xsd"
    version="3.0">
	<persistence-unit name="kuchenPersistenceUnit">
		<jta-data-source>java:jboss/datasources/ExampleDS</jta-data-source>
		<properties>
			<property name="hibernate.hbm2ddl.auto" value="create-drop" />
			<property name="hibernate.show_sql" value="true"></property>
		</properties>
	</persistence-unit>
</persistence>

Das Hinzufügen der "Java Persistence"-Facet führt zu einer Warnung "No connection specified for project. No database-specific validation will be performed.".
Der Warnung zu folgen und eine Connection anzulegen, ist nicht sinnvoll, denn wir definieren durch unsere EJBs schließlich die Struktur der Datenbank, nicht umgekehrt. Ein Vergleich der Entity-Beans und ihrer Felder mit einer Datenbankstruktur wäre also nicht sinnvoll.

Wir können diese Warnung abschalten: dazu gehen wir in die Projekt-Properties in den Bereich "JPA" -> "Errors/Warnings", setzen dort die Checkbox "Enable project specific settings" und schalten im Bereich "Project" die Option "No connection specified for project" von "Warning" auf "Ignore".

Dies könnten wir auch global für alle Projekte abschalten in den "Preferences" unter "Java Persistence" -> "JPA"

		<jta-data-source>java:comp/DefaultDataSource</jta-data-source>

Der Weg für Harte: Anlegen der Entity Bean ohne JPA

Wir fügen eine Klasse "KuchenSimpleBean" zu. Der Namenszusatz "Simple" kommt daher dass es noch weitere Beispiele kommen in denen Kuchen-Entity-Beans enthalten sind. Deshalb muss in jedem Beispiel ein eindeutiger Name für das Objekt "Kuchen" vergeben sein damit es keine Konflikte beim JNDI-Namen oder bei Tabellennamen gibt.


Es wird eine neue Klasse "KuchenSimpleBean" im Package "de.hsrm.jakartaee.knauf.kuchen" angelegt. Wichtig ist dass diese Klasse das Interface "java.io.Serializable" implementiert!


Die Bean-Klasse bekommt die Annotation "@jakarta.persistence.Entity". Da wir die EJB-QL-Strings zum Finden der Instanzen nicht hartcodiert in der Session-Bean haben wollen deklarieren wir bei der Bean-Klasse eine "@jakarta.persistence.NamedQuery".

@NamedQuery (name="findAllKuchen", query="select o from KuchenSimpleBean o")
@Entity()
public class KuchenSimpleBean implements Serializable
{

Anmerkung 1:
Wenn mehr als eine Query nötig sind muss man diese in eine Annotation "@NamedQueries" packen:

@NamedQueries({
  @NamedQuery (name="findAllKuchen", query="select o from KuchenSimpleBean o"),
  @NamedQuery (name="findByName", query="select o from KuchenSimpleBean o where o.name like ?1")
  })

Zwei Felder sowie die zugehörigen Getter und Setter werden zugefügt:

  private Integer intId;
  private String strName;
  
  @Column()
  @Id ()
  @GeneratedValue () 
  public Integer getId()
  {
    return this.intId;
  }

  public void setId(Integer int_Id)
  {
    this.intId = int_Id;
  }
  
  @Column()
  public String getName()
  {
    return this.strName;
  }

  public void setName(String str_Name)
  {
    this.strName = str_Name;
  }
  
  @Override
  public String toString()
  {
    return this.strName;
  }
  

Die Properties werden mit der Annotation @jakarta.persistence.Column als persistente Bean-Felder markiert. Die Property "ID" wird mit der Annotation @jakarta.persistence.Id als Primary-Key-Feld markiert. Der Wert soll vom Container automatisch generiert werden (@jakarta.persistence.GeneratedValue). Das Verfahren der Generierung bleibt dem Server überlassen, beim JBoss und der H2-Datenbank wird daraus eine Auto-ID-Spalte (sprich: beim Insert wird die ID erzeugt).

Die Methode toString wird überladen und gibt den Namen des Kuchens zurück. Das hat den Vorteil, dass wir die Kuchen im Client als Objekt in eine Listbox packen und auch wieder auslesen können.

Der Weg für Harte: persistence.xml

Für Entity Beans muss eine Persistence Unit deklariert werden. Dies geschieht über eine Datei "persistence.xml" im Unterverzeichnis "META-INF" des EJB-Projekts.
Sie hat diesen Inhalt:

	<?xml version="1.0" encoding="UTF-8"?>
	<persistence xmlns="https://jakarta.ee/xml/ns/persistence"
			xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
			xsi:schemaLocation="https://jakarta.ee/xml/ns/persistence https://jakarta.ee/xml/ns/persistence/persistence_3_0.xsd"
			version="3.0">
		<persistence-unit name="kuchenPersistenceUnit">
			<jta-data-source>java:jboss/datasources/ExampleDS</jta-data-source>
			<properties>
				<!-- Setzen dieser Property aktiviert das automatische Tabellen-Generieren und Löschen beim Deploy! -->
				<property name="hibernate.hbm2ddl.auto" value="create-drop" />
				<!-- SQL-Logging einschalten: -->
				<property name="hibernate.show_sql" value="true"></property>
			</properties>
		</persistence-unit>
	</persistence> 

Es wird eine "persistence-unit" namens "kuchenPersistenceUnit" deklariert. Sie ist verbunden mit einer JDBC-Datenquelle des Servers, die im JNDI unter dem Namen "java:jboss/datasources/ExampleDS" abgelegt ist und auf die JBoss-interne H2-Datenbank zeigt.


Die Property "hibernate.hbm2ddl.auto" ist JBoss-spezifisch und legt fest dass Datenbanktabellen beim Deploy einer Bean erzeugt und beim Undeploy wieder gelöscht werden sollen. Ohne diesen Parameter müssten wir die Datenbanktabellen von Hand anlegen.
Die Property "hibernate.show_sql" gibt an dass SQL-Befehle ins Server-Log geschrieben werden sollen, und als netter Nebeneffekt auch auf die Server-Console in Eclipse. Damit haben wir eine gute Diagnosemöglichkeit falls Datenbankzugriffe Probleme machen.

         <property name="javax.persistence.schema-generation.database.action" value="drop-and-create"/>
         <property name="javax.persistence.schema-generation.create-source" value="metadata"/>
         <property name="javax.persistence.schema-generation.drop-source" value="metadata"/>

         <property name="jakarta.persistence.schema-generation.database.action" value="drop-and-create"/>
         <property name="jakarta.persistence.schema-generation.create-source" value="metadata"/>
         <property name="jakarta.persistence.schema-generation.drop-source" value="metadata"/>

Der Weg des Assistenten: Anlegen der Entity Bean mit JPA

Im "Project Explorer" das EJB-Projekt wählen, Rechtsklick, "New" => "JPA Entity" wählen.

Name ("KuchenSimpleBean") und Package ("de.fhw.komponentenarchitekturen.knauf.kuchen") werden angegeben.

Im nächsten Dialog werden zwei Felder "id" (vom Typ java.lang.Integer) und "name" (vom Typ java.lang.String) angelegt.
Am Ende sollte der Dialog so aussehen:
-Das Feld "id" ist als Primary Key markiert.
-Der "Access Type" wird von "Field-based" (Annotations werden an die Feldvariablen gesetzt) auf "Property-based" geändert (Zugriff und Annotations nur über getter/setter).

Hier der Dialog für das Hinzufügen des Felds "id":

Da der Eclipse-Assistent JPA 3.0 noch nicht unterstützt, muss ein "imports"-Statement angepasst werden:

import javax.persistence.*;

wird

import jakarta.persistence.*;

Die so erzeugte Entity taucht jetzt auch im "Project Explorer" auf:


Nachbearbeitung: Es muss eine Named Query zugefügt werden:

@NamedQuery (name="findAllKuchen", query="select o from KuchenSimpleBean o")
@Entity()
public class KuchenSimpleBean implements Serializable
{

Die Property "id" muss außerdem mit der Annotation jakarta.persistence.GeneratedValue versehen werden:

	@Id    
	@GeneratedValue()
	public Integer getId()
	{
		return this.id;
	}

Anschließend wird die toString überladen (siehe Abschnitt

Anlegen der Session Bean

Da der Entity-Manager für den Zugriff auf die Entity-Bean nicht in einem Application Client verwendet werden kann, müssen wir alle Zugriffe auf die Bean kapseln. Dazu verwenden wir eine Session Bean "KuchenWorkerBean" mit einem Remote Interface "KuchenWorkerRemote".


Der Entity-Manager für den Zugriff auf die Entity Bean wird als vom Container "injected" Variable deklariert:

  @PersistenceContext(unitName="kuchenPersistenceUnit")
  private EntityManager entityManager = null;

Die Implementierung von "saveKuchen" sieht so aus:

  public void saveKuchen (KuchenSimpleBean kuchen)
  {
    this.entityManager.merge(kuchen);
  }

Wichtig ist dass hier "merge" und nicht "persist" genommen wird, siehe Abschnitt

  public void deleteKuchen(KuchenSimpleBean kuchen)
  {
    kuchen = this.entityManager.find (KuchenSimpleBean.class, kuchen.getId() );
    this.entityManager.remove(kuchen);
  } 

  public List<KuchenSimpleBean> getKuchen()
  {
    Query query = this.entityManager.createNamedQuery("findAllKuchen");
    List<KuchenSimpleBean> listKuchen = query.getResultList();
    
    return listKuchen;
  } 

    @SuppressWarnings("unchecked")
    List<KuchenSimpleBean> listKuchen = query.getResultList(); 

Application Client

public class FrameKuchen extends JFrame
{
  @EJB
  private static KuchenWorkerRemote kuchenWorker;

	Manifest-Version: 1.0
	Class-Path: KuchenSimpleEJB.jar
	Main-Class: de.hsrm.jakartaee.knauf.kuchen.FrameKuchen

21:03:44,880 INFO  [stdout] (ServerService Thread Pool -- 78) Hibernate: drop table if exists KuchenSimpleBean cascade 

21:03:44,881 INFO  [stdout] (ServerService Thread Pool -- 78) Hibernate: drop sequence if exists KuchenSimpleBean_SEQ

21:03:44,888 INFO  [stdout] (ServerService Thread Pool -- 78) Hibernate: create sequence KuchenSimpleBean_SEQ start with 1 increment by 50

21:03:44,891 INFO  [stdout] (ServerService Thread Pool -- 78) Hibernate: create table KuchenSimpleBean (id integer not null, name varchar(255), primary key (id))

Datenbank-Adminstrations-Tool

20:57:30,018 WARN  [org.jboss.modules.define] (MSC service thread 1-5) Failed to define class org.h2.server.web.JakartaWebServlet in Module "com.h2database.h2" version 2.2.220 from 
  local module loader @2ece4966 (finder: local module finder @1dd0e7c4 (roots: C:\Temp\wildfly-30.0.0.Final\modules,C:\Temp\wildfly-30.0.0.Final\modules\system\layers\base)): 
  java.lang.NoClassDefFoundError: Failed to link org/h2/server/web/JakartaWebServlet (Module "com.h2database.h2" version 2.2.220 from local module loader @2ece4966 
  (finder: local module finder @1dd0e7c4 (roots: C:\Temp\wildfly-30.0.0.Final\modules,C:\Temp\wildfly-30.0.0.Final\modules\system\layers\base))): jakarta/servlet/http/HttpServlet
...

• In "%WILDFLY_HOME$\modules" wird ein Unterverzeichnis "javax\servlet\api\h2" angelegt.
• Darin eine Datei "module.xml" mit diesem Inhalt anlegen:

  <?xml version="1.0" encoding="UTF-8"?>
  <module-alias xmlns="urn:jboss:module:1.9"
                name="javax.servlet.api:h2"
                target-name="jakarta.servlet.api"/>	

• Schritt 1: Datenbank starten
  Ins Verzeichnis "%WILDFLY_HOME%\modules\system\layers\base\com\h2database\h2\main" wechseln. Dort folgenden Befehl ausführen:
  

  java -jar h2-2.2.220.jar

  (Die Version von "h2-....jar" wird sich natürlich ändern)
  Die Datenbank wird gestartet (erkennbar an dem Systray-Icon) - man wird unter Windows von der Firewall gefragt ob man diese Anwendung freischalten will - und es öffnet sich ein Webbrowser mit einem Anmeldefenster. Allerdings kann man hier noch nichts anfangen, muss muss zuerst eine Datenbank anlegen. Dazu Rechtsklick auf das Icon in der Benachrichtigungsleiste und "Create a new database..." aufrufen. Dort ändert man den Defaultpfad für die Datenbankdatei von "./test" in z.B. "~/test" (legt die Datenbankdatei im Benutzerprofil an) und gibt dem User "sa" das Passwort "sa":
  
  
  Jetzt kann man sich an der Konsole anmelden. Die URL muss geändert werden auf "jdbc:h2:~/test":
  
  
  
  Jetzt sieht man die Adminkonsole vor sich und kann sich die Tabellenstruktur anschauen oder Befehle abfeuern.
  
  
• Schritt 2: die integrierte JBoss-Datenbankverbindung (an den JNDI-Namen "java:jboss/datasources/ExampleDS" gebunden) von einer In-Memory-Datenbank in eine per TCP/IP erreichbare Datenbank umkonfigurieren:
  Original:
  

          <subsystem xmlns="urn:jboss:domain:datasources:7.1">
              <datasources>
                  <datasource jndi-name="java:jboss/datasources/ExampleDS" pool-name="ExampleDS" enabled="true" use-java-context="true" statistics-enabled="${wildfly.datasources.statistics-enabled:${wildfly.statistics-enabled:false}}">
                      <connection-url>jdbc:h2:mem:test;DB_CLOSE_DELAY=-1;DB_CLOSE_ON_EXIT=FALSE;MODE=${wildfly.h2.compatibility.mode:REGULAR}</connection-url>
                      <driver>h2</driver>
                      ...
                  </datasource>
                  ...
              </datasources>
          </subsystem>

  Neu:
  

          <subsystem xmlns="urn:jboss:domain:datasources:7.1">
              <datasources>
                  <datasource jndi-name="java:jboss/datasources/ExampleDS" pool-name="ExampleDS" enabled="true" use-java-context="true" statistics-enabled="${wildfly.datasources.statistics-enabled:${wildfly.statistics-enabled:false}}">
                      <connection-url>jdbc:h2:tcp://localhost/~/test</connection-url>
                      <driver>h2</driver>
                      <security>
                          <user-name>sa</user-name>
                          <password>sa</password>
                      </security>
                  </datasource>
                  ...
              </datasources>
          </subsystem>

  Es wird also nur die "connection-url" geändert.
  
  
• Schritt 3: JBoss starten
  
  
• Schritt 4: Anwendung deployen.
  
  
• Jetzt können wir unsere Tabellen sehen:
  
  

Das Ende des ApplicationClient

  public static void main(String[] args)
  {
    //...hier wird das Look&Feel gesetzt...

    FrameKuchen frameKuchen = new FrameKuchen();
    frameKuchen.setVisible(true);
  }

    this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

    this.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);

    frameKuchen.setVisible(true);
    while (frameKuchen.isVisible() == true)
    {
      Thread.sleep(5000);
    }
    frameKuchen.dispose();

  private static CountDownLatch frameClosedSignal;

  public static void main(String[] args)
  {
    try
    {
      UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
    }
    catch (Exception e)
    {
      e.printStackTrace();
    }

    //Erzeugen des "warten auf Schließen des Fensters"-Signals.  
    FrameKuchen.frameClosedSignal = new CountDownLatch(1);
    
    FrameKuchen frameKuchen = new FrameKuchen();
    frameKuchen.setVisible(true);
    
    //WindowListener erzeugen, der im "windowClosed" die CountDownLatch anstößt.
    frameKuchen.addWindowListener(new WindowAdapter()
    {
      @Override
      public void windowClosed(WindowEvent windowEvent)
      {
        //Der CountDownLatch die "Freigabe" erteilen.
        FrameKuchen.frameClosedSignal.countDown();
        
        super.windowClosed(windowEvent);
      }
    });
    
    // Jetzt darauf warten, dass das Fenster geschlossen wird (WindowListener reagiert!) 
    // Dieses await() blockiert bis die Methode "countDown" auf der CountDownLatch" aufgerufen wird.
    try
    {
      FrameKuchen.frameClosedSignal.await();
    }
    catch (InterruptedException e)
    {
      e.printStackTrace();
    }
  }

Ausführen des Clients

%JBOSS_HOME%\bin\appclient.bat c:\temp\KuchenSimple.ear#KuchenSimpleClient.jar

set JAVA_OPTS=--add-opens=java.desktop/javax.swing=ALL-UNNAMED --add-opens=java.desktop/java.awt=ALL-UNNAMED
%WILDFLY_HOME%\bin\appclient.bat c:\temp\KuchenSimple.ear#KuchenSimpleClient.jar

        <subsystem xmlns="urn:jboss:domain:datasources:1.1">
            <datasources>
                    <datasource jndi-name="java:jboss/datasources/ExampleDS" enabled="true" use-java-context="true"
                            pool-name="java:jboss/datasources/ExampleDS">
                    <connection-url>jdbc:h2:mem:test;DB_CLOSE_DELAY=-1</connection-url>
                    <driver>h2</driver>
                    ...
                </datasource>
                ...
            </datasources>
        </subsystem>

Logging der SQL-Parameter

• Es wird neuer "console-handler" namens "CONSOLE.HIBERNATE_PARAMETERS" angehängt.
  

              <console-handler name="CONSOLE.HIBERNATE_PARAMETERS">
                  <level name="TRACE"/>
                  <formatter>
                      <pattern-formatter pattern="%K{level}%d{HH:mm:ss,SSS} %-5p [%c] (%t) %s%E%n"/>
                  </formatter>
              </console-handler>

  Es wird ein neuer Handler definiert, der auf die Konsole (System.out) loggt. Einziger Unterschied zum vorhandenen Konsolen-Appender: sein "Level" also das Loglevel, ab dem Meldungen durchgelassen wurde, wurde auf die maximale Detailstufe "TRACE" erhöht. Anmerkung: es würde eigentlich reichen, den Standard-Konsolenappender auf "TRACE" umzustellen, allerdings würden wir dann in JBoss-Meldungen ertrinken.
  
  
• Es werden drei neue Logger definiert. Diese referenzieren unseren Handler (dadurch werden NUR Logausgaben der drei konfigurierten Kategorien an diesen Appender gegeben, und zwar mit TRACE-Level und höher).
  

              <logger category="org.hibernate.type">
                  <level name="TRACE"/>
                  <handlers>
                      <handler name="CONSOLE.HIBERNATE_PARAMETERS"/>
                  </handlers>
              </logger>
              <logger category="org.hibernate.orm.jdbc.bind">
                  <level name="TRACE"/>
                  <handlers>
                      <handler name="CONSOLE.HIBERNATE_PARAMETERS"/>
                  </handlers>
              </logger>
              <logger category="org.hibernate.orm.jdbc.extract">
                  <level name="TRACE"/>
                  <handlers>
                      <handler name="CONSOLE.HIBERNATE_PARAMETERS"/>
                  </handlers>
              </logger>

19:35:12,829 INFO  [stdout] (default task-1) Hibernate: select next value for KuchenSimpleBean_SEQ

19:35:12,857 INFO  [stdout] (default task-1) Hibernate: insert into KuchenSimpleBean (name,id) values (?,?)

19:35:12,858 TRACE [org.hibernate.orm.jdbc.bind] (default task-1) binding parameter [1] as [VARCHAR] - [Mohnkuchen]
19:35:12,859 TRACE [org.hibernate.orm.jdbc.bind] (default task-1) binding parameter [2] as [INTEGER] - [1]

19:35:12,863 INFO  [stdout] (default task-1) Hibernate: select k1_0.id,k1_0.name from KuchenSimpleBean k1_0

19:35:12,863 TRACE [org.hibernate.orm.jdbc.extract] (default task-1) extracted value ([1] : [INTEGER]) - [1]
19:35:12,864 TRACE [org.hibernate.orm.jdbc.extract] (default task-1) extracted value ([2] : [VARCHAR]) - [Mohnkuchen]

Ohne Annotations

<?xml version="1.0" encoding="UTF-8"?>
<ejb-jar xmlns="https://jakarta.ee/xml/ns/jakartaee"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="https://jakarta.ee/xml/ns/jakartaee https://jakarta.ee/xml/ns/jakartaee/ejb-jar_4_0.xsd"
      version="4.0">
	<display-name>KuchenSimpleEJB</display-name>
	<enterprise-beans>
		<session>
			<description>
				<![CDATA[Stateless Session Bean für den Zugriff auf die Entitiy Bean
 * "Kuchen". Enthält Methoden zum Speichern und Löschen eines einzelnen
 * Kuchens sowie zum Holen einer Liste aller Kuchen.]]>
			</description>
			<display-name>KuchenWorkerBean</display-name>
			<ejb-name>KuchenWorkerBean</ejb-name>
			<remote>de.hsrm.jakartaee.knauf.kuchen.KuchenWorker</remote>
			<ejb-class>de.hsrm.jakartaee.knauf.kuchen.KuchenWorkerBean</ejb-class>
			<session-type>Stateless</session-type>
			<!--EntityManager-Injection -->
			<persistence-context-ref>
				<persistence-context-ref-name>KuchenPersistenceUnitRef</persistence-context-ref-name>
				<persistence-unit-name>kuchenPersistenceUnit</persistence-unit-name>
				<injection-target>
					<injection-target-class>
						de.hsrm.jakartaee.knauf.kuchen.KuchenWorkerBean
					</injection-target-class>
					<injection-target-name>entityManager</injection-target-name>
				</injection-target>
			</persistence-context-ref>
		</session>
		<entity>
			<description>
				<![CDATA[Entity Bean für einen einzelnen Kuchen.]]>
			</description>
			<display-name>KuchenSimpleBean</display-name>
			<ejb-name>KuchenSimpleBean</ejb-name>
			<ejb-class>de.fhw.swtvertiefung.knauf.kuchen.KuchenSimpleBean</ejb-class>
			<persistence-type>Container</persistence-type>
			<prim-key-class>java.lang.Integer</prim-key-class>
			<reentrant>false</reentrant>
		</entity>
	</enterprise-beans>
</ejb-jar> 

<?xml version="1.0" encoding="UTF-8"?>
<entity-mappings xmlns="https://jakarta.ee/xml/ns/persistence/orm"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="https://jakarta.ee/xml/ns/persistence/orm https://jakarta.ee/xml/ns/persistence/orm/orm_3_1.xsd"
      version="3.1">
	<named-query name="findAllKuchen">
		<query>select o from KuchenSimpleBean o</query>
	</named-query>

	<entity class="de.hsrm.jakartaee.knauf.kuchen.KuchenSimpleBean" access="PROPERTY"
		metadata-complete="true">
		<attributes>
			<id name="id">
				<generated-value/>
			</id>
			<basic name="name">
			</basic>
		</attributes>
	</entity>
</entity-mappings> 

<?xml version="1.0" encoding="UTF-8"?>
<entity-mappings xmlns="https://jakarta.ee/xml/ns/persistence/orm"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="https://jakarta.ee/xml/ns/persistence/orm https://jakarta.ee/xml/ns/persistence/orm/orm_3_1.xsd"
      version="3.1">
	<named-query name="findAllKuchen">
		<query>select o from KuchenSimpleBean o</query>
	</named-query>

	<entity class="de.hsrm.jakartaee.knauf.kuchen.KuchenSimpleBean" access="PROPERTY"
		metadata-complete="true">
		<table name="KUCHENSIMPLEBEAN" />
		<attributes>
			<id name="id">
				<column name="ID" />
				<generated-value/>
			</id>
			<basic name="name">
				<column name="NAME" />
			</basic>
		</attributes>
	</entity>
</entity-mappings> 

<?xml version="1.0" encoding="UTF-8"?>
<application-client version="10"
      xmlns="https://jakarta.ee/xml/ns/jakartaee"
      xmlns:xml="http://www.w3.org/XML/1998/namespace"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="https://jakarta.ee/xml/ns/jakartaee https://jakarta.ee/xml/ns/jakartaee/application-client_10.xsd">>
	<display-name>KuchenSimpleClient</display-name>
	<ejb-ref>
		<ejb-ref-name>ejb/KuchenWorker</ejb-ref-name>
		<ejb-ref-type>Session</ejb-ref-type>
		<remote>de.hsrm.jakartaee.knauf.kuchen.KuchenWorkerRemote</remote>
		<injection-target>
			<injection-target-class>de.hsrm.jakartaee.knauf.kuchen.FrameKuchen</injection-target-class>
			<injection-target-name>kuchenWorker</injection-target-name>
		</injection-target>
	</ejb-ref>
</application-client>

<?xml version="1.0" encoding="UTF-8"?>
<jboss-client xmlns="urn:jboss:jakartaee:1.0"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="urn:jboss:jakartaee:1.0 https://www.jboss.org/schema/jbossas/jboss-client_9_0.xsd"
	version="9.0">
	<jndi-name>KuchenSimpleClient</jndi-name>
	<ejb-ref>
		<ejb-ref-name>ejb/KuchenWorker</ejb-ref-name>
		<jndi-name>java:global/KuchenSimple/KuchenSimpleEJB/KuchenWorkerBean!de.hsrm.jakartaee.knauf.kuchen.KuchenWorkerRemote</jndi-name>
	</ejb-ref>
</jboss-client> 

Manueller Primary Key

  @Column()
  @Id()
  public Integer getId()
  {
    return this.intId;
  } 

@NamedQueries( { 
  @NamedQuery(name = "findAllKuchen", query = "select o from KuchenSimpleBean o"),
  @NamedQuery(name = "getMaxKuchenId", query = "select max (o.id) from KuchenSimpleBean o")
  })
public class KuchenSimpleBean implements Serializable
{
  ...

  public void saveKuchen (KuchenSimpleBean kuchen)
  {
    if (kuchen.getId() == null)
    {
      Query query = this.entityManager.createNamedQuery("getMaxKuchenId");
      Integer intMaxId = (Integer) query.getSingleResult();
      //Beim ersten Aufruf kommt hier NULL zurück weil keine ID da ist.
      if (intMaxId == null)
      {
        //Wir starten mit der ID "1"
        kuchen.setId(1);
      }
      else
      {
        //MaxID + 1 verwenden:
        kuchen.setId(intMaxId + 1);
      }
    }
    this.entityManager.merge(kuchen);
  } 

Zugriff auf MariaDB-Datenbank

• Schritt 1: Entpacken
• Schritt 2: Datenbank erzeugen, dabei wird ein Passwort gesetzt, da WildFly sich nicht zu einer Datenbank ohne Passwort verbinden kann:
  

  mariadb-install-db.exe -p jbosstest

• Schritt 3: Server starten:

  mariadbd.exe --console

• Schritt 4: MariaDB-Client starten:

  mariadb.exe -u root -p

  
  Danach wird man nach dem Passwort gefragt.
• Schritt 5: eine eigene Datenbank anlegen, mit der JBoss arbeiten darf:

  create database jbosstest;

MariaDB-Treiber goes JBoss

• Schritt 1: Einfach "mariadb-java-client-3.3.2.jar" in "standalone\deployments" legen - da der Treiber JDBC compliant ist, reicht das aus.
  WildFly wird jetzt auf der Konsole folgende Ausgabe anzeigen:
  

  
  20:52:04,408 INFO  [org.jboss.as.server.deployment] (MSC service thread 1-5) WFLYSRV0027: Starting deployment of "mariadb-java-client-3.3.2.jar" (runtime-name: "mariadb-java-client-3.3.2.jar")
  20:52:04,506 INFO  [org.jboss.as.connector.deployers.jdbc] (MSC service thread 1-5) WFLYJCA0004: Deploying JDBC-compliant driver class org.mariadb.jdbc.Driver (version 3.3)
  20:52:04,508 INFO  [org.jboss.as.connector.deployers.jdbc] (MSC service thread 1-4) WFLYJCA0018: Started Driver service with driver-name = mariadb-java-client-3.3.2.jar
  20:52:04,528 INFO  [org.jboss.as.server] (DeploymentScanner-threads - 2) WFLYSRV0010: Deployed "mariadb-java-client-3.3.2.jar" (runtime-name : "mariadb-java-client-3.3.2.jar")
  

• Schritt 2: In "%JBOSS_HOME%\standalone\configuration\standalone.xml" sucht man die Sektion <subsystem xmlns="urn:jboss:domain:datasources:7.1">, in der bereits der Eintrag für die H2-Datenbank steckt.
  
  Dort werden folgende zwei fett markierten Fragmente in das Element "datasources" bzw. das Unterelement "drivers" eingefügt:
  

         <subsystem xmlns="urn:jboss:domain:datasources:7.1">
  		<datasources>
  			<datasource jndi-name="java:jboss/datasources/ExampleDS" pool-name="ExampleDS" enabled="true" use-java-context="true">
  				...
  			</datasource>
  			<datasource jndi-name="java:jboss/datasources/MariaDBDS" pool-name="MariaDBDS" enabled="true">
  				<connection-url>jdbc:mariadb://localhost:3306/JBOSSTEST</connection-url>
  				<driver>mariadb-java-client-3.3.2.jar</driver>
  				<security user-name="root" password="jbosstest"/>
  			</datasource>
  			<drivers>
  				<driver name="h2" module="com.h2database.h2">
  					...
  				</driver>
  			</drivers>
  		</datasources>

• Schritt 1: im JBoss-Verzeichnis "modules\system\layers" eine Unterverzeichnisstruktur "com\mariadb\main" anlegen
• Schritt 2: dort "mariadb-java-client-3.3.2.jar" hineinlegen.
• Schritt 3: in diesem Verzeichnis eine Datei "module.xml" mit folgendem Inhalt anlegen:
  

  <?xml version="1.0" encoding="UTF-8"?>
  <module xmlns="urn:jboss:module:1.9" name="com.mariadb">
    <resources>
      <resource-root path="mariadb-java-client-3.3.2.jar"/>
    </resources>
    <dependencies>
      <module name="javax.api"/>
    </dependencies>
  </module>
    

• Schritt 4: in "%JBOSS_HOME%\standalone\configuration\standalone.xml" sucht man die Sektion <subsystem xmlns="urn:jboss:domain:datasources:7.1">, in der bereits der Eintrag für die H2-Datenbank steckt.
  
  Dort werden folgende zwei fett markierten Fragmente in das Element "datasources" bzw. das Unterelement "drivers" eingefügt:
  

         <subsystem xmlns="urn:jboss:domain:datasources:7.1">
              <datasources>
                  <datasource jndi-name="java:jboss/datasources/ExampleDS" pool-name="ExampleDS" enabled="true" use-java-context="true">
                      ...
                  </datasource>
                  <datasource jndi-name="java:jboss/datasources/MariaDBDS" pool-name="MariaDBDS" enabled="true">
                      <connection-url>jdbc:mariadb://localhost:3306/JBOSSTEST</connection-url>
                      <driver>com.mariadb</driver>
                      <security user-name="root" password="jbosstest"/>
                  </datasource>
                  <drivers>
                      <driver name="h2" module="com.h2database.h2">
                          ...
                      </driver>
                      <driver name="com.mariadb" module="com.mariadb">
                          <xa-datasource-class>org.mariadb.jdbc.MariaDbDataSource</xa-datasource-class>
                      </driver>
                  </drivers>
              </datasources>

  
  
  Das ganze geht auch über die CLI:
  Zuerst wird der Driver zugefügt:
  
  /subsystem=datasources/jdbc-driver=com.mariadb:add(driver-name="com.mariadb",driver-module-name="com.mariadb",driver-xa-datasource-class-name=org.mariadb.jdbc.MariaDbDataSource)
  
  Anschließend wird die DataSource exakt mit den Parametern wie oben erzeugt (nur mit dem abweichenden Namen "MariaDBDS2").
  
  [standalone@localhost:9999 /] data-source add --name=MariaDBDS2 --jndi-name=java:jboss/datasources/MariaDBDS2 --driver-name=com.mariadb --enabled=true --connection-url=jdbc:mariadb://localhost:3306/JBOSSTEST --user-name=root --password=jbosstest
  Oder alternativ in einer etwas längeren Syntax:
  /subsystem=datasources/data-source=MariaDBDS2:add(jndi-name="java:jboss/datasources/MariaDBDS2",driver-name=com.mariadb,enabled=true,connection-url="jdbc:mariadb://localhost:3306/JBOSSTEST",user-name=root,password=jbosstest)
  
  Und um das Ding wieder zu entsorgen:
  

  [standalone@localhost:9999 /] data-source remove --name=MariaDBDS2

• Schritt 4: jetzt können wir den Server starten. Das erfolgreiche Laden unseres Treibers können wir auf der Konsole sehen:
  

  21:49:18,099 INFO  [org.jboss.as.connector.subsystems.datasources] (ServerService Thread Pool -- 44) WFLYJCA0004: Deploying JDBC-compliant driver class org.h2.Driver (version 2.2)
  21:49:18,113 INFO  [org.jboss.as.connector.subsystems.datasources] (ServerService Thread Pool -- 44) WFLYJCA0004: Deploying JDBC-compliant driver class org.mariadb.jdbc.Driver (version 3.3)

  oder auch über diesen CLI-Befehl: /subsystem=datasources:installed-drivers-list

  [standalone@localhost:9999 /] /subsystem=datasources:installed-drivers-list
  {
      "outcome" => "success",
      "result" => [
          {
              "driver-name" => "com.mariadb",
              "deployment-name" => undefined,
              "driver-module-name" => "com.mariadb",
              "module-slot" => "main",
              "driver-datasource-class-name" => "",
              "driver-xa-datasource-class-name" => "org.mariadb.jdbc.MariaDbDataSource",
              "datasource-class-info" => [{"org.mariadb.jdbc.MariaDbDataSource" => {
                  "loginTimeout" => "int",
                  "password" => "java.lang.String",
                  "url" => "java.lang.String",
                  "user" => "java.lang.String"
              }}],
              "driver-class-name" => "org.mariadb.jdbc.Driver",
              "driver-major-version" => 3,
              "driver-minor-version" => 3,
              "jdbc-compliant" => true
          },
          {
              "driver-name" => "h2",
              "deployment-name" => undefined,
              "driver-module-name" => "com.h2database.h2",
              "module-slot" => "main",
              "driver-datasource-class-name" => "",
              "driver-xa-datasource-class-name" => "org.h2.jdbcx.JdbcDataSource",
              "datasource-class-info" => [{"org.h2.jdbcx.JdbcDataSource" => {
                  "URL" => "java.lang.String",
                  "description" => "java.lang.String",
                  "loginTimeout" => "int",
                  "password" => "java.lang.String",
                  "url" => "java.lang.String",
                  "user" => "java.lang.String"
              }}],
              "driver-class-name" => "org.h2.Driver",
              "driver-major-version" => 2,
              "driver-minor-version" => 2,
              "jdbc-compliant" => true
          }
      ]
  }

<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="https://jakarta.ee/xml/ns/persistence"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="https://jakarta.ee/xml/ns/persistence https://jakarta.ee/xml/ns/persistence/persistence_3_0.xsd"
      version="3.0">
	<persistence-unit name="kuchenPersistenceUnit" transaction-type="JTA">
		<jta-data-source>java:jboss/datasources/MariaDBDS</jta-data-source>
		<properties>
			<property name="hibernate.hbm2ddl.auto" value="create-drop" />
			<property name="hibernate.show_sql" value="true"></property>
		</properties>
	</persistence-unit>
</persistence>

21:17:08,428 ERROR [org.jboss.as.controller.management-operation] (Thread-45) WFLYCTL0013: Operation ("deploy") failed - address: ([("deployment" => "KuchenSimple.ear")]) - failure description: {
    "WFLYCTL0412: Required services that are not installed:" => ["jboss.naming.context.java.jboss.datasources.MariaDBDS"],
    "WFLYCTL0180: Services with missing/unavailable dependencies" => [
        "service jboss.persistenceunit.\"KuchenSimple.ear/KuchenSimpleEJB.jar#kuchenPersistenceUnit\".__FIRST_PHASE__ is missing [jboss.naming.context.java.jboss.datasources.MariaDBDS]",
        "service jboss.persistenceunit.\"KuchenSimple.ear/KuchenSimpleEJB.jar#kuchenPersistenceUnit\" is missing [jboss.naming.context.java.jboss.datasources.MariaDBDS]"
    ]
}

21:18:16,680 ERROR [org.jboss.as.controller.management-operation] (Controller Boot Thread) WFLYCTL0013: Operation ("add") failed - address: ([
    ("subsystem" => "datasources"),
    ("data-source" => "MariaDBDS")
]) - failure description: {
    "WFLYCTL0412: Required services that are not installed:" => ["jboss.jdbc-driver.mariadb-java-client-3_3_3_jar"],
    "WFLYCTL0180: Services with missing/unavailable dependencies" => [
        "service jboss.data-source.\"jboss.naming.context.java.jboss.datasources.MariaDBDS\" is missing [jboss.jdbc-driver.mariadb-java-client-3_3_3_jar]",
        "service jboss.driver-demander.java:jboss/datasources/MariaDBDS is missing [jboss.jdbc-driver.mariadb-java-client-3_3_3_jar]"
    ]
}

Troubleshooting