API Java Persistence (JPA)

Vous pouvez utiliser JPA pour fournir des annotations et des extensions XML que vous pouvez utiliser pour décrire les tables de leur base de données et leur contenu, y compris les types de données, les clés et les relations entre les tables. Les développeurs peuvent utiliser l'API pour effectuer des opérations de base de données au lieu d'utiliser SQL.

CICS® prend en charge jpa-2.0, jpa-2.1et jpa-2.2. Pour plus d'informations sur les différences entre les versions, voir Présentation de la fonction JPA (Java Persistence API).

• Les Entity objects sont des classes Java™ simples et peuvent être concrètes ou abstraites. Chacune représente une ligne dans une table de base de données, et les propriétés et les zones sont utilisées pour gérer les états. Chaque zone est mappée à une colonne de la table et des informations de clé sur cette zone particulière sont ajoutées ; par exemple, vous pouvez spécifier des clés primaires ou des zones qui ne peuvent pas être null.

  @Entity
  @Table(name = "JPA")
  public class Employee implements Serializable
  {
      @Id
      @Column(name = "EMPNO")
      private Long EMPNO;
  
      @Column(name = "NAME", length = 8)
      private String NAME;
  
      private static final long serialVersionUID = 1L;
  
      public Employee()
      {
          super();
      }
  
      public Long getEMPNO()
      {
          return this.EMPNO;
      }
  
      public void setEMPNO(Long EMPNO)
      {
          this.EMPNO = EMPNO;
      }
  
      public String getNAME()
      {
          return this.NAME;
      }
  
      public void setNAME(String NAME)
      {
          this.NAME = NAME;
      }
  }

• EntityManagerFactory est utilisé pour générer un EntityManager pour l'unité de persistance. EntityManager gère la collection active de entity objects utilisée par une application. Vous pouvez utiliser la classe EntityManager pour initialiser les classes et créer une transaction pour la gestion de l'intégrité des données. Ensuite, vous interagissez avec les données à l'aide des méthodes Entity class get et set , avant d'utiliser la transaction Entity pour valider les données.

  L'exemple suivant contient un exemple de code permettant d'insérer un enregistrement:

  @WebServlet("/Create")
  public class Create extends HttpServlet
  {
      private static final long serialVersionUID = 1L;
  
      @PersistenceUnit(unitName = "com.ibm.cics.test.wlp.jpa.annotation.cics.datasource")
      EntityManagerFactory emf;
  
      InitialContext ctx;
  
      /**
      * @throws NamingException
      * @see HttpServlet#HttpServlet()
      */
      public Create() throws NamingException
      {
          super();
          ctx = new InitialContext();
      }
  
      /**
      * @see HttpServlet#doGet(HttpServletRequest request,
      HttpServletResponse response)
      */
      protected void doGet(HttpServletRequest request, HttpServletResponse
          response) throws ServletException, IOException
      {
          // Get the servlet parms
          String id = request.getParameter("id");
          String name = request.getParameter("name");
  
          // Create a new employee object
          Employee newEmp = new Employee();
          newEmp.setEMPNO(Long.valueOf(id));
          newEmp.setNAME(name);
  
          // Get the entity manager factory
          EntityManager em = emf.createEntityManager();
  
          // Get a user transaction
          UserTransaction utx;
  
          try
          {
              // Start a user transaction and join the entity manager to it
              utx = (UserTransaction) ctx.lookup("java:comp/UserTransaction");
              utx.begin();
              em.joinTransaction();
  
              // Persist the new employee
              em.persist(newEmp);
  
              // End the transaction
              utx.commit();
          }
          catch(Exception e)
          {
              throw new ServletException(e);
          }
          
          response.getOutputStream().println("CREATE operation completed");
      }
  }

• @PersistenceUnit exprime une dépendance à un EntityManagerFactory et à son unité de persistance associée. Nom de l'unité de persistance tel que défini dans le fichier persistence.xml . Pour connecter les entités et les tables à une base de données, nous créons ensuite un fichier persistence.xml dans notre bundle. Le fichier persistence.xml décrit la base de données à laquelle ces entités se connectent. Le fichier contient des informations importantes telles que le nom du fournisseur, les entités elles-mêmes, l' URL connexion à la base de données et les pilotes.

  L'exemple suivant contient un exemple de fichier persistence.xml:

  <?xml version="1.0" encoding="UTF-8"?>
  <persistence version="2.0"
      xmlns="http://java.sun.com/xml/ns/persistence"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="http://java.sun.com/xml/ns/persistence
      http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">
  
      <persistence-unit name="com.ibm.cics.test.wlp.jpa.annotation.cics.datasource">
          <jta-data-source>jdbc/jpaDataSource</jta-data-source>
          
          <class>com.ibm.cics.test.wlp.jpa.annotation.cics.datasource.entities.Employee</class>
          
          <properties>
              <property name="openjpa.LockTimeout" value="30000" />
              <property name="openjpa.Log" value="none" />
              <property name="openjpa.jdbc.UpdateManager" value="operation-order" />
          </properties>
      </persistence-unit>
  </persistence>