Java Persistence Api (JPA) jest wykorzystywane do mapowania encji zapisanych w bazie danych (wiersze tabeli) na ich obiektową reprezentację również nazywaną encją. Zbieżność terminów może powodować konsternację dlatego w dalszej części wpisu przez pojęcie encja należy rozumieć tylko odpowiednio opisaną klasę w języku Java.
W ogólnym wypadku każda klasa spełniająca wymogi JavaBean tj. posiadająca bezparametrowy konstruktor oraz metody get i set dla pól może zostać przekształcona w encję. Dla przykładu, Grupa może zostać opisana przez taki komponent:

package eu.doniec.piotr.bean

public class Grupa {
    private Long id;

    private String nazwa;
    private String opis;

    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    public String getNazwa() { return nazwa; }
    public void setNazwa(String nazwa) { this.nazwa = nazwa; }
    public String getOpis() { return opis; }
    public void setOpis(String opis) { this.opis = opis; }
}

Modyfikacja do postaci encji, możliwej do wykorzystania przez JPA do obsługi danych zawartych w tabeli Grupy polega na opisaniu klasy metainformacjami – adnotacjami z pakietu javax.persistence. Gotowa klasa przedstawia się następująco:

package eu.doniec.piotr.persistence;

import java.io.Serializable;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.NamedQuery;
import javax.persistence.Table;

@Entity
@NamedQuery(
    name="findAllGroups",
    query="SELECT g FROM Grupa g"
)
@Table(name="GRUPY")
public class Grupa implements Serializable {

    @Id @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;

    private String nazwa;
    private String opis;

    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    public String getNazwa() { return nazwa; }
    public void setNazwa(String nazwa) { this.nazwa = nazwa; }
    public String getOpis() { return opis; }
    public void setOpis(String opis) { this.opis = opis; }
}

Podobnie sytuacja wygląda z klasą Studenta, choć tu sytuacja jest trochę inna. Struktura bazy danych wymaga aby tabela STUDENCI posiadała ograniczenie FOREIGN_KEY na dodatkowe pole GRUPA_ID. W takiej sytuacji w ramach encji Student umieszczamy odwołanie do encji Grupa. Właściwość ta jest dodatkowo oznaczona adnotacją @ManyToOne oznaczającą właśnie że wielu studentów może przynależeć do jednej grupy.

package eu.doniec.piotr.persistence;

import java.io.Serializable;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

import javax.persistence.NamedQuery;
import javax.persistence.Table;
import javax.persistence.ManyToOne;
import javax.persistence.JoinColumn;

@Entity
@NamedQuery(
    name="findAllStudents",
    query="SELECT s FROM Student s"
)
@Table(name="STUDENCI")
public class Student implements Serializable {
    @Id @GeneratedValue(strategy = GenerationType.AUTO)
    private Long nr_indeksu;

    private String imie;
    private String nazwisko;

    @ManyToOne
    private Grupa grupa;

    public Long getNr_indeksu() { return nr_indeksu; }
    public void setNr_indeksu(Long nr_indeksu) { this.nr_indeksu=nr_indeksu; }
    public String getImie() { return imie; }
    public void setImie(String imie) { this.imie = imie; }
    public String getNazwisko() { return nazwisko; }
    public void setNazwisko(String nazwisko) { this.nazwisko = nazwisko; }
    public Grupa getGrupa() { return grupa; }
    public void setGrupa(Grupa grupa) { this.grupa = grupa; }
}

Encje są zdefiniowane, pozostało jeszcze je wykorzystać. W tym celu powstanie servlet, który wyświetli nr indeksu, nazwisk i przydział studenta do grupy. W celu wykorzystania stworzonych obiektów trzeba utworzyć obiekt EntityManager’a, a raczej „wstrzyknąć” go do aplikacji – uzyskuje się to annotacją @PersistenceContext. Utworzony w ten sposób EntityManager jest zarządzany przez kontener aplikacji tzw. container-managed. Sensowne wydaje się wstrzyknięcie go w klasie implementującej ServletContextListener i zapisanie w kontekście servletu, w ten sposób łatwo będzie się do niego dostać:

package eu.doniec.piotr.listeners;

import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import javax.servlet.annotation.WebListener;
import javax.servlet.ServletContext;

import javax.persistence.PersistenceContext;
import javax.persistence.EntityManager;

@WebListener()
public class ContextListener implements ServletContextListener {

    @PersistenceContext
    private EntityManager em;

    private ServletContext context;

    public void contextInitialized(ServletContextEvent sce) {
        context = sce.getServletContext();
        context.setAttribute("EntityManager", em);
    }

    public void contextDestroyed(ServletContextEvent sce) {
        context.removeAttribute("EntityManager");
    }
}

Na tym etapie, pozostało już tylko stworzenie serwletu i konfiguracja połączenia z bazą danych. Ostatni, prymitywny fragment kodu wypisuje na ekran nr indeksu, nazwisko i nazwę grupy do której zapisany jest student.

package eu.doniec.piotr.servlets;

import eu.doniec.piotr.persistence.Student;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Iterator;
import java.util.List;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import javax.persistence.EntityManager;
import javax.persistence.Query;

@WebServlet(name="studenci", urlPatterns={"/studenci"})
public class Studenci extends HttpServlet {

    protected void processRequest(HttpServletRequest request, HttpServletResponse response)
    throws ServletException, IOException {
        response.setContentType("text/html;charset=UTF-8");
        PrintWriter out = response.getWriter();
        try {
            EntityManager em = (EntityManager)getServletContext().getAttribute("EntityManager");
            Query q = em.createNamedQuery("findAllStudents");

            out.println("<html>");
            out.println("<head>");
            out.println("<title>Servlet studenci</title>");
            out.println("</head>");
            out.println("<body>");
            out.println("<h1>Servlet studenci at " + request.getContextPath () + "</h1>");

            out.println("<table>");
            out.println("<tr><th>Numer indeksu</th><th>Nazwisko</th><th>Grupa</th></tr>");

            List studenci =  q.getResultList();
            for (Iterator iter = studenci.iterator(); iter.hasNext();) {
                Student s = (Student) iter.next();
                out.println("<tr>");
                out.println("<td>" + s.getNr_indeksu() +"</td>");
                out.println("<td>" + s.getNazwisko() + "</td>");
                out.println("<td>" + s.getGrupa().getNazwa() +"</td>");
                out.println("</tr>");
            }

            out.println("</body>");
            out.println("</html>");
        } finally {
            out.close();
        }
    } 

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
    throws ServletException, IOException {
        processRequest(request, response);
    }
}

Plik persistence.xml:

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="1.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_1_0.xsd">
  <persistence-unit name="baza-danych-nauczyciela-pu" transaction-type="JTA">
    <provider>oracle.toplink.essentials.PersistenceProvider</provider>
    <jta-data-source>jdbc/bazanauczyciela</jta-data-source>
  </persistence-unit>
</persistence>

Sposób stworzenie źródła danych dla Oracle pod Glassfish wystarczająco dobrze opisany jest tu: http://technology.amis.nl/blog/1276/configuring-a-oracle-datasource-on-glassfish.

@Override
protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
//processRequest(request, response);
}

}
[/cc]

package foo;

public class Licznik {
    private static int liczba;
    public static synchronized int getLiczba() {
        liczba++;
        return liczba;
    }
}

to kod wstawiony do strony JSP korzystający z licznika powinien wyglądać następująco:
<% out.println(foo.licznik.getLiczba()); %>

Oprócz znacznika skryptletu który został przed chwilą zaprezentowane w stronach JSP można spotkać również inne, np.

• Dyrektywa: <%@ ... %>, np: <%@page contentType="text/html; charset=UTF-8" %> ustawia typ treści
• Wyrażenie <%= ... %>, np. <%= Licznik.getLiczba() %> spowoduje wyświetlenie aktualnego stanu licznika.
• Definicja: <%! ... %>, umożliwia definiowanie zmiennych i metod które są później „wstrzykiwane” do tworzonej klasy servletu. W ramach tych znaczników jesteśmy upoważnieni do przeciążenia metod jspInit oraz jspDestroy które są wywoływane odpowiednio przy powoływaniu servletu do życia i przy jego usuwaniuz kontenera. Z uwagi na fakt że definicje metod zawartych w obrębie znacznika defincji stają metodami servletu, nie ma tu dostępu do zmienny request i response

Jak wspomniałem każda strona JSP jest servletem. Strona jest tłumaczona przez kontener na odpowiedni servlet. Wykorzystanie różnych znaczników do zaprezentowania innego typu zawartości ułatwia kontenerowi konwersję. I tak dyrektywy są używane aby kontrolować jak kontener ma przetłumaczyć a następnie wykonać kod strony, skryptlety są po prostu przepisywane do kodu servletu natomiast wyrażenia są przekazywane jako parametry odpowiednich funkcji.

Aby servlet mógł być servletem a nie zwykłą klasą musi implementować interface javax.servlet.Servlet.

interface javax.servlet.Servlet
{
  void destroy();
  ServletConfig getServletConfig();
  String getServletInfo();
  void init(ServletConfig config);
  void service(ServletRequest req, ServletResponse res);
}

Metoda destroy jest uruchamiana przez serwer aplikacji celem zniszczenia servletu. Dwie metody init oraz service mają za zadanie „zarządzanie” cyklem życia servletu. Pierwsza z wyżej wymienionych metod jest wywoływana tylko raz w całym cyklu życia servletu. Ma to zawsze miejsce przed obsługą przez servlet jakichkolwiek żądań klientów. Natomiast zadaniem metody service jest obsługa żądania. Metoda przyjmuje 2 parametry, pierwszy z nich definiuje żądanie skierowane do serwera, a drugi będzie zawierał wygenerowaną odpowiedź.

Tworzenie za każdym razem klasy implementującej ten interface może się okazać zadaniem dosyć żmudnym dlatego do dyspozycji mamy jeszcze 2 klasy: GenericServlet – klasa obsługująca żadania nie zależenie od protokołu, jednak wymaga samodzielnej implementacji metody service, oraz klasa HttpServlet do wykorzystania wraz z protokołem HTTP. Oczywistą zaletą tej klasy jest w pełni zaimplementowany mechanizm sterownia życiem servletu. Rola programisty ogranicza się właściwie do przysłonięcia metod typowych dla żadań HTTP takich jak POST (metoda doPost), GET (doGet), HEAD, OPTIONS, PUT, TRACE, DELETE. Nie trzeba chyba nikogo przekonywać że w 99% przypadków nadpisywana jest jedna z dówch pierwszych metod lub obie.

• serwlet – ciężko zdefiniować go w sposób jednoznaczny, ale jest to klasa Javy dziedzicząca po HttpServlet, odpowiedzialna za reakcję na żądania dostarczone od użytkownika za pośrednictwem serwera WWW. Serwlety są podobne do skryptów PHP czy Perl, ale to zupełnie inna technologia. PHP i Perl to CGI, no a serwlet to serwlet. Serwlet jest najczęściej tworzony jako kontroler w modelu MVC
• JSP – skrót od JavaServer Pages. Nazwanie tego technologią to trochę za dużo, ale jest to sposób na wyświetlanie danych odebranych z serwletu. JSP to Widok(View) w modelu MVC.
• JSF – skrót od JavaServer Faces, jest frameworkiem dla JSP. Zawiera komponenty które w znaczny sposób mają ułatwić tworzenie aplikacji i odciążyć programistę od powtarzania kodu dla wielu typowych operacji.
• GlassFish, JBoss – serwlety muszą być uruchamiane w specjalnym środowisku. Potrzebny do tego jest serwer aplikacji JEE, jakim właśnie jest np. GlassFish. Taki serwer aby był zgodny ze specyfikacją JEE oprócz kontenera serwletów musi także zawierać kontener EJB( klasy modelu ).

Połączenie wszystkich wyżej wymienionych technologii można zobrazować jak na rysunku poniżej(przedstawiony „graf” od ciemne grubej kreski jest zawarty w serwerze aplikacji JEE np. GlassFish, JBoss)




Obrazek pobrany z http://www.jcorporate.com/

]]> http://piotr.doniec.eu/devlog/2009/03/jsp-jsf-glassfish-mini-slowniczek/feed/ 1