Technologia Hibernate Przygotowanie bazy danych

Technologia Hibernate
Do wykonania opisanego dalej ćwiczenia laboratoryjnego potrzebne jest zintegrowane
środowisko programistyczne NetBeans 8.0 wraz z serwerem GlashFish. Poniższy opis
dotyczy biblioteki Hibernate wersji 4.2.6.
Wprowadzenie
Celem ćwiczenia jest przygotowanie aplikacji JSF do przeglądania listy klientów i
zamówionych towarów, realizującej operacje poprzez bibliotekę Hibernate. Ćwiczenie
wykorzystuje serwer bazy danych MySQL.
Przygotowanie bazy danych MySQL
1. W celu pokazania omawianych mechanizmów utworzymy bazę danych. W
kolejnych punktach opisano proces tworzenia prostej bazy danych.
2. Najpierw należy otworzyć okienko konsoli poprzez kliknięcie na ikonę
Wiersz polecenia na pulpicie, albo poprzez kliknięcie na przycisk startowy w
lewym dolnym rogu ekranu i wpisanie polecenia cmd. Następnie należy przełączyć
dysk bieżący na d: Wskazane jest utworzenie katalogu na dysku d:, np.:
mkdir Zofia
cd Zofia
3. Z kolei, za pomocą programu Notepad++ tworzymy plik tekstowy produkty.sql o
zawartości podanej w ramce. W celu uruchomiania programu Notepad++ należy
kliknąć na przycisk startowy w dolnym lewym rogu ekranu, wybrać Wszystkie
programy → Notepad++ → Notepad++. Następnie wybieramy zakładkę
Encoding i zaznaczamy opcję Encode in UTF-8 without BOM (lub Koduj w
UTF-8 (bez BOM)).
4. W oknie edycyjnym wprowadzamy tekst podany w ramce (można skopiować za
pomocą Ctrl C, Ctrl V):
2
DROP DATABASE IF EXISTS Produkty;
CREATE DATABASE Produkty CHARACTER SET 'utf8' COLLATE
'utf8_polish_ci' ;
USE Produkty;
SET NAMES 'utf8' COLLATE 'utf8_polish_ci' ;
DROP TABLE IF EXISTS adresy;
SET character_set_client = utf8;
CREATE TABLE adresy (
ident_osoby int(11) NOT NULL AUTO_INCREMENT,
imie varchar(15) COLLATE utf8_polish_ci DEFAULT NULL,
nazwisko varchar(25) COLLATE utf8_polish_ci DEFAULT NULL,
miejscowosc varchar(30) COLLATE utf8_polish_ci DEFAULT
NULL,
PRIMARY KEY (ident_osoby)
) ENGINE=MyISAM AUTO_INCREMENT=5 DEFAULT CHARSET=utf8
COLLATE=utf8_polish_ci;
INSERT INTO adresy VALUES
(1,'Stefania','Nowak','Poznań'),
(2,'Roman','Kowalski','Szczecin'),
(3,'Józef','Malinowski','Łódź'),
(4,'Jadwiga','Nowak','Poznań');
DROP TABLE IF EXISTS towary;
SET character_set_client = utf8;
CREATE TABLE towary (
nr_zamow int(11) NOT NULL AUTO_INCREMENT,
ident_osoby int(11) DEFAULT NULL,
nazwa_towaru varchar(60) COLLATE utf8_polish_ci DEFAULT
NULL,
cena int(11) DEFAULT NULL,
data_zamow date DEFAULT NULL,
PRIMARY KEY (nr_zamow)
) ENGINE=MyISAM AUTO_INCREMENT=7 DEFAULT CHARSET=utf8
COLLATE=utf8_polish_ci;
INSERT INTO towary VALUES
(1,3,'rower',350,'2011-01-05'),
(2,1,'lodówka',1400,'2011-01-03'),
(3,4,'odkurzacz',750,'2011-01-05'),
(4,2,'zmywarka',2100,'2011-01-07'),
(5,4,'kajak',4200,'2011-01-07');
3
5. Zapisujemy wprowadzony tekst w pliku produkty.sql w katalogu utworzonym w
pkt. 2 (np. d:\Zofia).
6. Uwaga: w dalszym opisie założono, że użytkownik jest identyfikowany przez nazwę
root i hasło xamppwNE.
7. W oknie konsoli (dysk bieżący D:) wpisujemy polecenie:
c:\xampp\mysql\bin\mysql -u root -pxamppwNE < produkty.sql
W rezultacie zostanie utworzona baza danych Produkty i dwie tablice: adresy i
towary.
8. Uruchamiamy system Netbeans i zamykamy aktualnie otwarte projekty (zakładka
File i polecenie Close lub Close All Projects.
9. Naciskamy Ctrl 5 i przechodzimy do zakładki Services.
10. W zakładce Services klikamy prawym przyciskiem na węźle Databases i
wybieramy New Connection — w rezultacie pojawi się okno dialogowe, w którym
w polu Driver wybieramy MySQL (Connector /J driver):
11. Po naciśnięciu przycisku Następny (Next) pojawi się kolejne okno:
4
W oknie tym wpisujemy (zob. rysunek):
• w polu Database wpisujemy Produkty,
• w polu User Name wpisujemy root,
• w polu Password wpisujemy xamppwNE.
12. W celu sprawdzenia czy podane parametry połączenia są poprawne można nacisnąć
przycisk Test Connection. Po naciśnięciu Next pojawią się kolejno okna Choose
Database Schema i Choose name for connection, które pozostawiamy bez
zmian. Naciskamy Finish.
13. Można łatwo odczytać i zaktualizować zawartość bazy danych. W tym celu w oknie
Services
rozwijamy
węzeł
Databases,
następnie
węzeł
jdbc:mysql://localhost:3306/produkty [root on Default schema], i
kolejne węzły tak jak podano na rysunku.
5
14. Prawym klawiszem myszki klikamy na węzeł adresy i wybieramy opcję View
Data. Na ekranie zostanie wyświetlona zawartość tablic adresy.
15. W celu wprowadzenia nowego wiersza do tablicy klikamy na przycisk Insert
Record
po lewej stronie, tak jak pokazano na rysunku.
16. W rezultacie pojawi się okno Insert Record, do którego wpisujemy dane nowego
klienta. Naciskamy OK.
6
17. Wprowadzona wartość została zapisana do bazy danych. W przypadku innych
poprawek korzysta się także z przycisku Commit Record. Przykładowo, w celu
dopisania nazwy Dąbie do wyrazu Szczecin trzeba kliknąć na pozycję Szczecin,
wpisać Dąbie i nacisnąć Enter.
18. Następnie nacisnąć przycisk Commit Record w celu wprowadzenia zmian do bazy
danych.
7
Tworzenie projektu aplikacji internetowej
1. Wybrać File → New Project. W oknie Categories wybrać Java Web, a w oknie
Projects wybrać Web Application. Kliknąć Następny (Next).
2. Wpisać nazwę projektu, np. Hib_2014 i kliknąć na przycisk Następny (Next). W
polu Project Location powinien być podany katalog główny na dysku D: (zob.
rysunek).
3. Kolejne okno Server and Settings wypełnianie jest automatycznie w poniższy
sposób:.
8
4. Kliknąć Next (Następny). Zaznaczyć opcje JavaServer Faces i Hibernate 4.2.6.
W polu Database Connection wybrać połączenie bazy danych:
jdbc:mysql://localhost:3306/Produkty ...
5. Kliknąć Zakończ. Po naciśnięciu przycisku Zakończ, zostaje utworzony projekt
aplikacji internetowej, po czym zostają otwarte pliki hibernate.cfg.xml i
index.xhtml.
6. W oknie Projects, po rozwinięciu węzła Libraries, można zobaczyć listę plików
biblioteki Hibernate dodanych do projektu (zob. rysunek).
9
Modyfikacja pliku konfiguracyjnego Hibernate
W trakcie tworzenia projektu, który używa Hibernate, tworzony jest automatycznie plik
konfiguracyjny hibernate.cfg.xml. Plik jest umieszczony w węźle <default
package>, pod węzłem Source Packages w oknie projektu (zob. rysunek).
Plik konfiguracyjny zawiera informacje o połączeniach bazy danych, mapowaniu
zasobów i innych właściwościach połączenia. W omawianym projekcie będziemy
edytować właściwości domyślne podane w pliku hibernate.cfg.xml
1. Dla pliku hibernate.cfg.xml wybieramy zakładkę Source i modyfikujemy
drugi wiersz kodu: usuwamy poniższy fragment
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd"
i w jego miejsce wpisujemy
"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd"
2. W dalszym wykonujemy działania na tym samym pliku w zakładce Design.
3. Rozwijamy opcję Configuration Properties i klikamy na przycisk Add.
4. W oknie dialogowym wybieramy właściwość hibernate.show_sql, ustawiamy
wartość true i naciskamy OK.
4. W podobny sposób rozwijamy węzeł Miscellaneous Properties i klikamy na
przycisk Add.
10
5. W oknie dialogowym wybieramy właściwość
hibernate.current_session_context_class
i ustawiamy wartość na thread. Naciskamy OK.
6. Klikamy ponownie na przycisk Add (w grupie Miscellaneous Properties) i na
liście Property Name wybieramy hibernate.query.factory_class.
Wybieramy
org.hibernate.hql.classic.ClassicQueryTranslatorFactory
jako
Property Value. Klikamy OK.
7. Zapamiętać zmiany dokonane w pliku.
8. Jeśli klikniemy na zakładkę Source w edytorze, to będziemy mogli zobaczyć
zawartość pliku XML. Plik powinien wyglądać tak, jak podano na następnej stronie:
11
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC "//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<property name="hibernate.dialect">
org.hibernate.dialect.MySQLDialect
</property>
<property name="hibernate.connection.driver_class">
com.mysql.jdbc.Driver
</property>
<property name="hibernate.connection.url">
jdbc:mysql://localhost:3306/Produkty
?zeroDateTimeBehavior=convertToNull
</property>
<property
name="hibernate.connection.username">root</property>
<property name="hibernate.connection.password">xamppwNE
</property>
<property name="hibernate.show_sql">true</property>
<property
name="hibernate.current_session_context_class">
thread
</property>
<property name="hibernate.query.factory_class">
org.hibernate.hql.classic.ClassicQueryTranslatorFactory
</property>
</session-factory>
</hibernate-configuration>
W dalszej części dokonamy jeszcze niewielkiej zmiany w tym pliku.
12
Tworzenie pliku HibernateUtil.java
W celu użycia Hibernate utworzymy klasę helper. Klasa wywołuje configure() i
ładuje
plik
konfiguracyjny
hibernate.cfg.xml,
po
czym
buduje
SessionFactory w celu uzyskania obiektu Session. Poniżej opisano tworzenie klasy
helper w pliku HibernateUtil.java.
1. W oknie projektu klikamy prawym klawiszem myszki na węzeł Source Packages i
wybieramy New → Other. W rezultacie zostanie otwarte okno Choose File Type.
2. Na liście kategorii wybieramy Hibernate, na liście File Types wybieramy
HibernateUtil.java. Klikamy Następny.
3. Podajemy nazwę klasy HibernateUtil i nazwę pakietu pakiet_Hib. Naciskamy
Zakończ.
13
4. Usuwamy całą zawartość okna edytora (plik HibernateUtil.java) i w jego
miejsce wprowadzamy poniższy kod.
package pakiet_Hib;
import
import
import
import
org.hibernate.SessionFactory;
org.hibernate.cfg.Configuration;
org.hibernate.service.ServiceRegistry;
org.hibernate.service.ServiceRegistryBuilder;
public class HibernateUtil {
private static final SessionFactory sessionFactory;
static
{
try
{
Configuration configuration = new Configuration();
configuration.configure();
ServiceRegistry serviceRegistry =
new ServiceRegistryBuilder().
applySettings(configuration.getProperties()).
buildServiceRegistry();
sessionFactory =
configuration.buildSessionFactory(serviceRegistry);
}
catch (Throwable ex)
{
// Log the exception.
System.err.println(
"Initial SessionFactory creation failed." + ex);
throw new ExceptionInInitializerError(ex);
}
}
public static SessionFactory getSessionFactory()
{
return sessionFactory;
}
}
5. Zapisujemy wprowadzone zmiany i zamykamy okno edytora – nie będzie więcej
potrzebne.
14
Tworzenie plików odwzorowania Hibernate i klas Javy
W omawianym projekcie używamy POJO (Plain Old Java Object) do
reprezentacji danych z każdej używanej tablicy. Klasa Javy specyfikuje pola kolumn w
tabelach i używa prostych setters i getters do odczytywania i zapisywania danych. W
celu mapowania POJO na tablice używamy pliku mapowania Hibernate lub używamy
adnotacji w klasie.
Pliki mapujące Hibernate tworzone są automatycznie. W tym celu trzeba wybrać
wszystkie tablice, dla których mają być utworzone pliki mapujące i POJO. Następnie
Netbeans generuje pliki i dodaje wejścia mapujące do pliku hibernate.cfg.xml.
Można też wybrać opcje generacji kodu (przykładowo generację kodu, która używa
adnotacje EJB 3).
Tworzenie pliku Hibernate Reverse Engineering
Jeśli chcemy używać plików mapujących i POJO w sposób automatyczny, w
pierwszej kolejności trzeba utworzyć plik hibernate.reveng.xml. Do tworzenia
potrzebny jest także plik hibernate.cfg.xml. Plik reverse engineering zwiększa
kontrolę nad odwzorowaniem bazy danych. Plik tworzony jest automatycznie z
domyślną konfiguracją, którą można edytować za pomocą edytora XML. W celu
utworzenia omawianego pliku trzeba wykonać poniższe działania.
1. Kliknąć prawym klawiszem myszki na węzeł nazwy projektu i wybrać New →
Other w celu otwarcia okna Choose File Type.
2. W kategorii Hibernate wybrać opcję Hibernate Reverse Engineering Wizard.
Nacisnąć Następny.
3. Jako nazwę pliku podać hibernate.reveng, a jako folder src\java. Kliknąć
Następny.
15
4. W oknie Database Tables z listy rozwijanej Configuration File wybrać
hibernate.cfg.xml. Następnie Wybrać podane tablice z okna Available
Tables i kliknąć Add w celu dodania wybranych pozycji do okna Selected Tables.
Nacisnąć Zakończ.
W wyniku wykonania podanych czynności zostanie utworzony automatycznie plik
hibernate.reveng.xml i następnie otwarty w edytorze. Edytor zamykamy,
ponieważ nie są potrzebne żadne zmiany.
Tworzenie plików mapujących Hibernate i POJO
Pliki mapujące Hibernate i POJO można utworzyć automatycznie (generowane są pliki
POJO i odpowiadające pliki mapujące dla każdej wybranej tablicy). Pliki mapujące są
plikami w formacie XML i zawierają informacje w jaki sposób kolumny w tablicach są
mapowane na pole w POJO. Potrzebne będą pliki hibernate.reveng.xml i
hibernate.cfg.xml.
W celu utworzenia plików mapujących i plików POJO trzeba wykonać niżej podane
czynności:
5. Kliknąć prawym klawiszem myszki na węzeł Source Packages i wybrać New →
Other w celu otwarcia okna Choose File Type.
6. W grupie File Types dla kategorii Hibernate wybrać Hibernate Mapping Files
and POJOs from a Database. Kliknąć Następny.
16
7. Pojawi sie kolejne okno, w którym należy upewnić się czy pliki
hibernate.cfg.xml i hibernate.reveng.xml są wybrane na liście
rozwijanej.
8. W tym samym oknie w opcjach General Settings wybrać JDK 5 Language
Features. Upewnić się czy zostały zaznaczone opcje Domain Code i Hibernate
XML Mappings.
9. Wybrać pakiet_Hib jako nazwę pakietu (Package). Kliknąć Zakończ.
17
10.Po kliknięciu na przycisk Zakończ Netbeans generuje pliki mapujące POJO i
Hibernate
z
polami
mapującymi
kolumny
podane
w
pliku
hibernate.reveng.xml. Netbeans dodaje także wejścia mapujące do pliku
hibernate.cfg.xml. Można rozwinąć węzeł pakiet_Hib żeby zobaczyć pliki
wygenerowane automatycznie.
18
Tworzenie pliku OsobyHelper.java
Teraz, w pakiecie pakiet_Hib możemy utworzyć klasę helper, która będzie
używana do wykonywania zapytań w bazie danych. Użyjemy edytora HQL (Hibernate
Query Language) do konstrukcji i testowania zapytań dla uzyskiwanych danych. Po
testowaniu zapytań zostaną utworzone metody w klasie helper, które konstruują i
wykonują zapytania.
Tworzenie klasy
W tej części zostanie utworzona automatycznie klasa helper OsobyHelper.java w
pakiecie
pakiet_Hib.
Utworzymy
sesję
Hibernate
poprzez
wywołanie
getSessionFactory w HibernateUtil.java i następnie utworzenie pewnych
metod helper do tworzenia zapytań w bazie danych.
1. Kliknąć prawym klawiszem na węzeł pakiet_Hib i wybrać New → Java Class.
2. W oknie Name and Location podać OsobyHelper jako nazwę klasy. Upewnić się
czy pakiet_Hib został wybrany jako pakiet (Package). Kliknij Zakończ.
3. W rezultacie pojawi się okno edycyjne pliku OsobyHelper.java — w oknie tym na
razie dopisujemy dwa wiersze (wytłuszczone) – na razie ignorować sygnalizowane
błędy:
package pakiet_Hib;
public class OsobyHelper {
Session session = null;
SessionFactory fact = null;
}
19
4. Kliknąć prawym klawiszem myszki na edytowany tekst i wybrać opcję Fix imports.
Wybrać opcję org.hibernate.Session tak jak podano na poniższym rysunku.
Nacisnąć OK.
Zmodyfikujemy teraz plik OsobyHelper.java dodając metody, które tworzą
zapytania do bazy danych.
Podawanie nazwisk klientów przy użyciu zapytań HQL
W tym projekcie utworzymy zapytanie HQL (Hibernate Query Language), które
przegląda bazę danych w celu uzyskania listy nazwisk z tablicy adresy. Listę nazwisk
w tablicy adresy uzyskamy za pomocą klucza podstawowego ident_osoby. Do
konstrukcji i testowania zapytania HQL można użyć edytora HQL. Po utworzeniu
poprawnego zapytania dodamy metodę do klasy, która może generować odpowiednie
zapytanie.
5. Kliknąć prawym przyciskiem myszki na węzeł nazwy projektu i wybrać Clean and
Build. W rezultacie powinien pojawić sie komunikat BUILD SUCCESSFUL (total
time: 2 seconds). Jeśli okno Wyjście jest niewidoczne, to nacisnąć Ctrl 4.
6. Kliknąć prawym przyciskiem myszki na pozycję hibernate.cfg.xml w oknie
projektu i wybrać Run HQL Query w celu otwarcia edytora zapytań HQL.
7. Z listy rozwijanej Session wybrać hibernate.cfg
8. Sprawdzić połączenie z bazą danych poprzez napisanie poniższego tekstu w
edytorze:
from Adresy
20
9. Po kliknięciu przycisku Run HQL Query (zielona strzałka) można zobaczyć
odpowiedź na zapytanie.
10.Napiszemy jeszcze raz podobne zapytanie w trochę bardziej złożonej postaci, w
której ident_osoby zawarty jest w przedziale <2, 3>.
from Adresy where ident_osoby between 2 and 3
W wyniku zostanie wyświetlona lista rekordów. Teraz, po upewnieniu się, że
zapytanie zwraca odpowiednie wyniki, można użyć zapytania w klasie helper.
11.Dodać poniższą metodę getOsobyNazwiska do klasy w pliku
OsobyHelper.java w celu uzyskania nazwisk, gdzie ident_osoby zawarte
jest w przedziale określonym przez zmienne startID i endID. Kod metody
wpisać przed ostatnim znakiem }. Na razie ignorować informacje o błędach.
public List getOsobyNazwiska(int startID, int endID)
{
List<Adresy> adresyList = null;
fact = HibernateUtil.getSessionFactory();
this.session = fact.getCurrentSession();
try
{
org.hibernate.Transaction tx = session.beginTransaction();
Query q = session.createQuery (
"from Adresy as adresy where ident_osoby between '"
+ startID +"' and '" + endID + "'");
adresyList = (List<Adresy>) q.list();
session.close() ;
}
catch (Exception e)
{
e.printStackTrace();
}
return adresyList;
}
21
OsobyHelper
12.Do
tej
samej
klasy
dodać
poniższą
getUrzadzeniaByID. Kod metody wpisać przed ostatnim znakiem }.
metodę
public List getUrzadzeniaByID(int klientId)
{
List<Towary> urzadzeniaList = null;
fact = HibernateUtil.getSessionFactory();
this.session = fact.getCurrentSession();
try
{
org.hibernate.Transaction tx = session.beginTransaction();
Query q = session.createQuery (
"from Towary where ident_osoby = '"
+ klientId + "'");
urzadzeniaList = (List<Towary>) q.list();
session.close();
}
catch (Exception e)
{
e.printStackTrace();
}
return urzadzeniaList;
}
13.Uporządkować import: kliknąć prawym klawiszem myszki w oknie klasy i wybrać
opcję Fix Imports, nastepnie wybrać org.hibernate.Query i
java.util.List, tak jak pokazano na poniższym rysunku. Nacisnąć OK.
14.Zapamiętać zmiany.
22
Tworzenie komponentu zarządzanego JSF
W omawianym projekcie utworzymy teraz komponent (bean) zarządzany JSF.
Metody w komponencie zarządzanym używane są do wyświetlania danych na stronach
JSF i w metodach dostępu w klasie helper w celu uzyskania rekordów.
W celu utworzenia komponentu zarządzanego wykonamy poniższe kroki.
1. Klikamy prawym przyciskiem na węzeł pakiet_Hib i wybieramy New → Other.
2. W kategorii JavaServer Faces wybieramy JSF Managed Bean. Klikamy
Następny.
3. Wypełniamy pola w kolejnym oknie: wpisujemy OsobyKontroler jako nazwę klasy,
wpisujemy pakiet_Hib w polu Package i podajemy OsobyKontroler jako nazwę,
która będzie używana w komponencie zarządzanym. Ustawiamy zasięg na Session.
Kliknąć Zakończ.
23
4. Po naciśnięciu przycisku Zakończ Netbeans utworzy klasę komponentu i otworzy
klasę w edytorze. Netbeans doda adnotacje @ManagedBean i @SessionScoped.
Poniższa zawartość strony generowana jest automatycznie przez Netbeans.
package pakiet_Hib;
import javax.faces.bean.ManagedBean;
import javax.faces.bean.SessionScoped;
@ManagedBean
@SessionScoped
public class OsobyKontroler {
public OsobyKontroler() {
}
}
Zauważmy, że nazwa komponentu zarządzanego nie jest specyfikowana jawnie.
Domyślnie nazwa komponentu jest taka sama jak nazwa klasy i zaczyna się z małej
litery.
5. Informacja podana w tym punkcie ma charakter uzupełniający i nie jest
wykorzystywana w aktualnie tworzonej aplikacji. W niektórych przypadkach, jeśli
nazwa komponentu ma być inna niż nazwa klasy, to można jawnie podać nazwę jako
parametr adnotacji @ManagedBean. Przykładowo:
@ManagedBean(name="myBeanName").
6. Do klasy OsobyKontroler dodajemy poniższe wiersze (dopisujemy przed ostatnim
znakiem }).
int startId;
int endId;
DataModel osobyNazwiska;
OsobyHelper helper;
private int recordCount = 100;
private int rozmiarStrony = 10;
private Adresy current;
private int selectedItemIndex;
7. Usuwamy podane niżej wiersze.
public OsobyKontroler() {
}
8. Kod podany na następnej stronie wpisujemy przed ostatnim znakiem }.
24
public OsobyKontroler() {
helper = new OsobyHelper();
startId = 1;
endId = 10;
}
public OsobyKontroler(int startId, int endId) {
helper = new OsobyHelper();
this.startId = startId;
this.endId = endId;
}
public Adresy getSelected() {
if (current == null) {
current = new Adresy();
selectedItemIndex = -1;
}
return current;
}
public DataModel getOsobyNazwiska() {
if (osobyNazwiska == null) {
osobyNazwiska = new
ListDataModel(helper.getOsobyNazwiska(startId, endId));
}
return osobyNazwiska;
}
void recreateModel() {
osobyNazwiska = null;
}
9. Do tej samej klasy dodajemy poniższe metody, które używane są do wyświetlania
tabeli i nawigacji stron (wpisać przed ostatnim znakiem }).
public boolean isHasNextPage() {
if (endId + rozmiarStrony <= recordCount) {
return true;
}
return false;
}
public boolean isHasPreviousPage() {
if (startId-rozmiarStrony > 0) {
return true; }
return false;
}
25
public String next() {
startId = endId+1;
endId = endId + rozmiarStrony;
recreateModel();
return "index";
}
public String previous() {
startId = startId - rozmiarStrony;
endId = endId - rozmiarStrony;
recreateModel();
return "index";
}
public int getRozmiarStrony () {
return rozmiarStrony;
}
public String pokazTowary(){
current = (Adresy) getOsobyNazwiska().getRowData();
return "zlecenie";
}
public String pokazKlientow(){
recreateModel();
return "index";
}
Metoda, która zwraca index lub zlecenie będzie zachęcać moduł nawigacji
JSF do próby otwarcia strony index.xhtml lub zlecenie.xhtml. Specyfikacja
JSF 2.0 umożliwia używanie ukrytych reguł nawigacji w aplikacjach, w których
występują Facelety.
10.Uporządkować import (Fix imports) i zapamiętać zmiany.
11.Powracamy do edycji pliku hibernate.cfg.xml, otwieramy zakładkę Source i
w niżej podanym wierszu dopisujemy słowo internal:
org.hibernate.hql.internal.classic.ClassicQueryTranslatorFactory
26
Tworzenie strony internetowej
W ramach omawianego projektu utworzymy dwie strony internetowe do
wyświetlania danych. Zmodyfikujemy plik index.xhtml generowany przez Netbeans
w celu dodania tabeli wyświetlającej nazwiska podane w bazie danych. Utworzymy
następnie zlecenie.xhtml w celu wyświetlania informacji o nazwiskach (po
kliknięciu odnośnika Pokaż zamówienia w tabeli). Utworzymy także szablon JSF,
który jest używany przez index.xhtml i zlecenie.xhtml.
Tworzenie pliku szablon.xhtml
Utworzymy najpierw szablon JSF Facelet, który używany jest do kompozycji
index.xhtml
stron
i zlecenie.xhtml.
1. Kliknąć prawym przyciskiem myszki na nazwę projektu i wybrać New → Other.
2. W kategorii JavaServer Faces wybrać Facelets Template. Kliknąć Następny.
3. W polu File Name wpisać szablon i wybrać pierwszy układ CSS.
27
4. Po kliknięciu na przycisk Zakończ, w edytorze zostanie otwarty plik
szablon.xhtml. Szablon zawiera poniższy kod domyślny.
<h:body>
<div id="top" class="top">
<ui:insert name="top">Top</ui:insert>
</div>
<div id="content" class="center_content">
<ui:insert name="content">Content</ui:insert>
</div>
</h:body>
5. W pliku szablon.xhtml najpierw zmienić tytuł tak jak podano poniżej:
<title>Przykład wykorzystania technologii Hibernate</title>
6. Zastąpić fragment id="top" przez id="godz24".
7. W następnym wierszu usunąć słowo Top (pisane z wielkiej litery), a w jego miejsce
wpisać poniższy wiersz:
Zamówienia realizowane są w ciągu 24 godzin!
8. Zmodyfikować wiersz zaczynający się od znacznika
<ui:insert name="content">
w niżej podany sposób:
<ui:insert name="zawartosc">Tekst zastępczy</ui:insert>
9. Zapamiętać zmiany.
10. W rezultacie, zawartość umieszczona wewnątrz elementu
<ui:define name="zawartosc">
w kodzie index.xhtml oraz w zlecenie.xhtml zostanie wprowadzona do
miejsca identyfikowanego przez:
<ui:insert name="zawartosc">
w szablonie.
28
Modyfikacja pliku index.xhtml
W trakcie tworzenia aplikacji internetowej, Netbeans automatycznie generuje
stronę index.xhtml. Zmodyfikujemy tę stronę w celu wyświetlania listy nazwisk
klientów. W celu uzyskania listy nazwisk i wyświetlenia tabeli strona JSF wywołuje
metody komponentu zarządzanego OsobyKontroler.
11. Rozwinąć węzeł Web Pages i otworzyć plik index.xhtml. Domyślna zawartość
index.xhtml będzie następująca:
<?xml version='1.0' encoding='UTF-8' ?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0
Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
xmlns:h="http://xmlns.jcp.org/jsf/html">
<h:head>
<title>Facelet Title</title>
</h:head>
<h:body>
Hello from Facelets
</h:body>
</html>
12. W podanym wyżej kodzie należy usunąć fragment począwszy od znacznika
<h:head> aż do znacznika </h:body> (włącznie).
13. W miejsce usuniętego fragmentu wprowadzić niżej podany kod (w którym używane
są m.in. elementy <ui:composition>, <ui:define> i <h:form>).
<ui:composition template="./szablon.xhtml">
<ui:define name="zawartosc">
<h:form>
</h:form>
</ui:define>
</ui:composition>
14. Nacisnąć prawy klawisz myszki i wybrać opcję Fix Namespaces . . . W rezultacie
pojawi
się
okno
dialogowe,
w
którym
należy
wybrać
opcję
http://xmlns.jcp.org/jsf/facelets" i nacisnąć OK.
29
15. Do kodu w pliku index.xhtml, po znaczniku <h:form>, dodać niżej podane
odnośniki nawigacyjne, które wywołują metody previous i next w
komponencie zarządzanym JSF.
<h:commandLink class="przesuwanie"
action="#{osobyKontroler.previous}"
value="Poprzednia strona #{osobyKontroler.rozmiarStrony}"
rendered="#{osobyKontroler.hasPreviousPage}"/>
<h:commandLink class="przesuwanie"
action="#{osobyKontroler.next}"
value="Następna strona #{osobyKontroler.rozmiarStrony}"
rendered="#{osobyKontroler.hasNextPage}"/>
16. Podany dalej kod należy wpisać przed znacznikiem </h:form>)
<h:dataTable class="tabela"
value="#{osobyKontroler.osobyNazwiska}"
var="item" border="0" cellpadding="12" cellspacing="0"
rowClasses="jsfcrud_odd_row,jsfcrud_even_row"
rules="all" style="border:solid 1px">
<h:column>
<f:facet name="header">
<h:outputText value="Imię"/>
</f:facet>
<h:outputText value="#{item.imie}"/>
</h:column>
<h:column>
<f:facet name="header">
<h:outputText value="Nazwisko"/>
</f:facet>
30
<h:outputText value="#{item.nazwisko}"/>
</h:column>
<h:column>
<f:facet name="header">
<h:outputText value="Miejscowość"/>
</f:facet>
<h:outputText value="#{item.miejscowosc}"/>
</h:column>
<h:column>
<f:facet name="header">
<h:outputText value=" "/>
</f:facet>
<h:commandLink
action="#{osobyKontroler.pokazTowary}"
value="Pokaż zamówienia"/>
</h:column>
</h:dataTable>
17. Wprowadzony wyżej kod dataTable służy do wygenerowania tabeli, w której
wyświetlane będą odczytane pozycje. Po wpisaniu kodu należy nacisnąć prawy
klawisz myszki i wybrać opcję Fix Namespaces . . . W rezultacie pojawi się
poniższe
okno
dialogowe,
w
którym
należy
wybrać
opcję
http://xmlns.jcp.org/jsf/core i nacisnąć OK.
18. Zapamiętać zmiany.
19. Elementy <ui:composition> i <ui:define> używane są w połączeniu ze
stroną szablonu. Element <ui:composition> odnosi się do lokacji szablonu,
która będzie używana na stronie. Element <ui:define> odnosi się do pozycji w
szablonie.
31
20. Strona index będzie teraz wyświetlać listę nazwisk w bazie danych. Każdy wiersz
w tabeli zawiera odnośnik Pokaż zamówienia,
który wywołuje metodę
pokazTowary w komponencie zarządzanym. Metoda pokazTowary zwraca
wartość zlecenie i otwiera zlecenie.xhtml.
21. W pliku OsobyKontroler.java dopisać poniższą metodę (wpisać przed ostatnim
znakiem }):
public String getUrzadzenia() {
int pozycja = current.getIdentOsoby() ;
List urzadzenia = helper.getUrzadzeniaByID(pozycja);
StringBuffer totalCast = new StringBuffer();
for (int i = 0; i < urzadzenia.size(); i++) {
Towary urzadzenie = (Towary) urzadzenia.get(i);
totalCast.append(urzadzenie.getNazwaTowaru());
if (i < (urzadzenia.size() - 1))
totalCast.append(", ");
}
return totalCast.toString();
}
22. Wybrać prawym klawiszem myszki opcję Fix Imports i następnie OK (zob. rys.).
Tworzenie pliku zlecenie.xhtml
Utworzymy teraz stronę zlecenie.xhtml przeznaczoną do wyświetlania
zamówionych urządzeń. Możemy to zrealizować automatycznie za pomocą Facelets
Template Client, który utworzy stronę opartą na wcześniej utworzonym szablonie
szablon.xhtml.
23. Kliknąć prawym klawiszem myszki na węzeł nazwy projektu i wybrać New →
Other.
32
24. W polu kategorii JavaServer Faces wybrać Facelets Template Client.
25. Kliknąć Nastepny.
26. W rezultacie pojawi się kolejne okno, pokazane na poniższym rysunku. W polu
File Name należy wpisać nazwę pliku zlecenie. Dalsze elementy do wypełnienia
opisane są w następnym punkcie.
33
27. Teraz zlokalizujemy szablon dla strony. W tym samym oknie kliknąć przycisk
Browse (w wierszu Template) — w rezultacie pojawi się okno dialogowe
Browse Files. Rozwinąć węzeł Web Pages i wybrać szablon.xhtml. Kliknąć
Select File.
28. Nadal w tym samym oknie trzeba wybrać opcję <ui:composition> dla
Generated Root Tag. Wypełnione pola pokazane są na poniższym rysunku.
Kliknąć Zakończ.
29. Po kliknięciu na przycisk Zakończ (Finish), w edytorze zostanie otwarty plik
zlecenie.xhtml zawierający podany dalej kod.
<ui:composition
xmlns:ui="http://xmlns.jcp.org/jsf/facelets"
template ="./szablon.xhtml">
<ui:define name="top">
top
</ui:define>
<ui:define name="zawartosc">
zawartosc
</ui:define>
</ui:composition>
Można zauważyć, że nowy plik wskazuje szablon.xhtml, a znacznik
<ui:define> ma właściwość name="zawartosc".
30. W pliku zlecenie.xhtml usunąć trzy kolejne wiersze począwszy od:
<ui:define name="top">.
31. Następnie bezpośrednio po znaczniku
<ui:define name="zawartosc">
dodać kod podany na następnej stronie. Przedtem usunąć wiersz zawierający
pojedyncze słowo zawartość.
34
<h:form>
<h:panelGrid columns="2">
<h:outputText value="Imię: "/>
<h:outputText
value="#{osobyKontroler.selected.imie}"
title="Imię"/>
<h:outputText value="Nazwisko: "/>
<h:outputText
value="#{osobyKontroler.selected.nazwisko}"
title="Nazwisko"/>
<h:outputText value="Towary zamówione: "/>
<h:outputText
value="#{osobyKontroler.urzadzenia}"/>
</h:panelGrid>
<h:commandLink
action="#{osobyKontroler.pokazKlientow}"
value="Pokaż listę klientów"/>
</h:form>
32. Po wpisaniu kodu należy nacisnąć prawy klawisz myszki i wybrać opcję Fix
Namespaces . . . W rezultacie pojawi się poniższe okno dialogowe, w którym
należy wybrać opcję http://xmlns.jcp.org/jsf/html i nacisnąć OK.
33. Zapamiętać zmiany.
34. Można zauważyć, że zlecenie.xhtml i index.xhtml używają tego samego
szablonu strony.
35
35. W oknie Projects odszukać i następnie otworzyć plik cssLayout.css (zob.
rysunek).
36. Na początku tego pliki dopisać poniższe wiersze:
.tabela {position : relative;
top : 20px;
background-color: #F0D0A0;
}
.przesuwanie {
position: relative;
font-size: 12px;
background-color: #EECC88;
padding: 5px;
margin: 1px 20px 1px 1px;
}
#godz24 {
position: relative;
font-size: 18px;
background-color: #036fab;
color: white;
padding: 5px;
margin: 0px 0px 10px 0px;
}
36
Uruchomienie projektu
Kliknąć prawym klawiszem myszki na nazwę projektu i wybrać opcję Run. Aplikacja
zostanie uruchomiona. Poniżej podano przykładowy wygląd ekranu.
Po kliknięciu na przycisk Pokaż zamówienia dla wybranego klienta odpowiedź
powinna mieć postać jak poniżej.