7. díl - Wicket - Databáze

Java Enterprise Edition Wicket Wicket - Databáze

V této části navážeme na předchozí lekci, kdy jsme vytvořili kontaktní formulář. Data z formuláře budeme ukládat do databáze (v našem případě PostgreSQL). Pro zájemce je práce s PostgreSQL podrobněji popsána v sekci PostgreSQL, my si zde vysvětlíme jen minimum nutné k vytvoření našeho projektu.

PostgreSQL

Stažení PostgreSQL včetně pgAdmin (grafické rozhraní): http://www.enterprisedb.com/…g/pgdownload

Instalace PostgreSQL je jednoduchá a uživatelsky přívětivá. Spuštění instaleru -> spustí se setup Microsoft Visual C++ 2013 (pokud nemáte naistalováno). Následuje setup PostgreSQL -> nastavení Installation Directory -> Data Directory -> Password -> Port (defaltně 5432) -> Advanced Options - výběr locale -> Ready to Install. Dále se spustí Stack Builder 3.x.x pro instalaci dodatečného software. Zde není potřeba vybírat nic, vše potřebné je již naistalováno.

Společně s postgres se naistaloval i pgAdmin, což je grafické uživatelské rozhraní pro administraci databáze.

Instalace obsahuje jednu databázi (postges) a jednu přihlašovací roli (postgres).

Kliknutím na ikonu SQL se dostanete do Query view, ve kterém je možné zadávat SQL příkazy (F5 provede všechny příkazy, další možností je označit příkaz a kliknou na ikonu se zelenou šipkou).

Data z tabulky lze získat pomocí selektu v Query view, pomocí kliknutí pravého tlačítka myši na tabulce v Object browseru a volby View data, popřípadě označením tabulky v Object browseru a klávesové zkratky Ctrl+D.

DAO návrhový vzor

DAO (Data Access Object) představuje rozhraní (interface) pro přístup k databázi. V DAO rozhraní jsou definovány metody pro práci s databází. Dále se vytvoří implementace tohoto rozhraní, která implementuje dané metody. Objekty, které potřebují pracovat s databází, si vytvoří instanci DAO a používají specifikované metody (např. saveData(), getAllData(), getById(), atd…). Veškerá logika pro práci s databází se nachází v DAO. Třídy používající databázi (prostřednictvím DAO) neví nic o tom, jak je práce (interakce) s databází implementovaná. Pouze vytvoří instanci DAO a používají metody. V případě změny týkající se databáze (např. změna databáze) nedochází ke změně vlastního kódu aplikace, pouze se změní DAO implementace

Dále se pak vytvoří třída/třídy jejichž instance budou představovat objekt, který budeme v databázi ukládat, načítat či měnit. V našem případě budeme pracovat s komentářem, a proto vytvoříme třídu Comment.

Comment.java

import java.sql.Date;
import java.sql.Timestamp;

public class Comment {

        private Timestamp createdTime;
        private String email;
        private String textOfComment;

        public Timestamp getCreatedTime() {
                return createdTime;
        }
        public void setCreatedTime(Timestamp createdTime) {
                this.createdTime = createdTime;
        }
        public String getEmail() {
                return email;
        }
        public void setEmail(String email) {
                this.email = email;
        }
        public String getTextOfComment() {
                return textOfComment;
        }
        public void setTextOfComment(String textOfCcomment) {
                this.textOfComment = textOfCcomment;
        }
}

Jenom drobné upozornění. Date a Timestamp importujeme z balíčku java.sql.

CommentDao.java

import java.util.List;

public interface CommentDao {

        public void saveComment(Comment comment);
        public List<Comment> getAllComments();
}

Pro práci s databází použijeme JDBC.

"Java DataBase Connectivity (JDBC) je API v programovacím jazyce Java, které definuje jednotné rozhraní pro přístup k relačním databázím[1]. Jedná se o mezivrstvu mezi Java aplikací a samotnou komunikací s určitou databází. JDBC umožňuje aplikaci stejně přistupovat k různým databázím. Liší se pouze JDBC driver, který poskytuje tvůrce databázového serveru." Wikipedie

CommentDaoImpl.java

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;

public class CommentDaoImpl implements CommentDao {
        private final String POSTGRES = "jdbc:postgresql://localhost/nazev_databáze?user=uživatelské_jméno&password=heslo";

        static {
                try {
                        Class.forName("org.postgresql.Driver");
                } catch (ClassNotFoundException e) {
                        e.printStackTrace();
                }
        }

        @Override
        public void saveComment(Comment comment) {
                try (Connection con = DriverManager.getConnection(POSTGRES)) {
                        PreparedStatement ps = con.prepareStatement(
                                        "insert into comment (created_time, email, text_of_comment) values (?, ?, ?)"
                                        );
                        ps.setTimestamp(1, comment.getCreatedTime());
                        ps.setString(2, comment.getEmail());
                        ps.setString(3, comment.getTextOfComment());
                        ps.executeUpdate();
                } catch (SQLException e) {
                        e.printStackTrace();
                }
        }

        @Override
        public List<Comment> getAllComments() {
                List<Comment> comments = new ArrayList<>();
                try (Connection con = DriverManager.getConnection(POSTGRES)) {
                        Statement st = con.createStatement();
                        ResultSet rs = st.executeQuery("select id_comment, created_time, email, text_of_comment from comment");
                        while (rs.next()) {
                                Comment comment = new Comment();
                                comment.setCreatedTime(rs.getTimestamp("created_time"));
                                comment.setEmail(rs.getString("email"));
                                comment.setTextOfComment(rs.getString("text_of_comment"));
                                comments.add(comment);
                        }
                } catch (SQLException e) {
                        e.printStackTrace();
                }
                return comments;
        }
}

String POSTGRES obsahuje řetězec použitý pro připojení k databázi (pro získání spojení - connection).

Tento řádek načte třídu ovladače.

Class.forName("org.postgresql.Driver");

Dále je třeba přidat postgresql jdbc driver (http://jdbc.postgresql.org/download.html) do lib složky aplikačního serveru (…\apache-tomcat-7.0.55\lib), a také do pom.xml přidat závislost (dependency) pro postgresql jdbc driver.

<dependency>
        <groupId>postgresql</groupId>
        <artifactId>postgresql</artifactId>
        <version>9.1-901-1.jdbc4</version>
</dependency>

Také je potřeba v databázi vytvořit tabulku comment.

create table comment (
        id_comment serial not null,
        created_time timestamp not null,
        email character varying (50),
        text_of_comment character varying,
        constraint comment_pk primary key (id_comment)
);

Nyní otestujeme připojení k databázi (naši DAO implementaci) pomocí JUnit testu. V src/test/java vytvoříme balíček cz.mujweb.database a testovací třídu TestDatabase (pravým tlačítkem na balíček -> New -> Other -> JUnit Test Case -> Next -> jako jméno zadejte TestDatabase -> Finish). Vytvoří se nám třída s vygenerovanou metodou test().

@Test
public void test() {
        fail("Not yet implemented");
}

Pokud nyní test spustíme (pravým tlačítkem na třídu -> Run As -> JUnit Test), objeví se nám nová záložka JUnit.

Test nám selže (fail). To není nic překvapivého, protože je tak napsán. Vyzkoušeli jsme si ale, že testování pomocí JUnit v našem projektu funguje. Možná vás překvapilo, jak je možné, že nedošlo při použití JUnit k chybě, když jsme tuto knihovnu nepřidávali do závislostí v pom.xml. Pokud se do souboru pom.xml podíváte, zjistíte, že JUnit závislost tam už je přidána.

Vygenerovanou metodu public void test() můžeme nyní smazat. Vytvoříme si metodu vlastní.

TestDatabase.java

import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;

import java.sql.Timestamp;
import java.util.List;

import org.junit.Test;

public class TestDatabase {

        @Test
        public void testCommentSaving() {
                // vytvoření nového komentáře
                Comment comment = new Comment();
                comment.setCreatedTime(new Timestamp(1_000_000_000L));
                comment.setEmail("email@email.cz");
                comment.setTextOfComment("Text komentáře");

                // uložení komentáře do databáze
                CommentDao dao = new CommentDaoImpl();
                dao.saveComment(comment);

                // získání všech komentářů z databáze
                List<Comment> comments = dao.getAllComments();
                assertNotNull(comments);
                assertTrue(comments.size() > 0);

                Comment lastComment = comments.get(comments.size() - 1);
                assertTrue(lastComment.getCreatedTime().getTime() == 1_000_000_000L);
        }
}

Pokud test spustíme nyní, měl by projít.

Také se můžeme podívat do databáze, zda je komentář skutečně uložen.

Ještě nám zbývá upravit metodu onSubmit() tak, aby při odeslání formuláře uložila data do databáze.

ContactForm.java

@Override
protected void onSubmit() {
        Comment comment = new Comment();
        comment.setCreatedTime(new Timestamp(new Date().getTime()));
        comment.setEmail(email);
        comment.setTextOfComment(text);

        CommentDao dao = new CommentDaoImpl();
        dao.saveComment(comment);

        setResponsePage(HomePage.class);
}

V první části metody vytvoříme instanci komentáře (Comment) a nasetujeme jí data získaná z formuláře (email, text). Do data vytvoření vložíme aktuální čas.

new Date() // java.util.date, vytvoří aktuální čas
new Date().getTime() // vrátí aktuální čas jako počet milisekund
new Timestamp(aktuální_čas) // vytvoří nový java.sql.timestamp s aktuálním časem

V druhé části metody vytvoříme CommentDao objekt a zavoláme jeho metodu saveComment(). Na závěr voláme metodu setResponsePage() a jako parametru jí předáme třídu stránky, kam chceme, aby byl uživatel přesměrován.


Přiložený soubor obsahuje zdrojový kód vytvořené webové aplikace.


Další zdroje:


 

Stáhnout

Staženo 16x (30.52 kB)
Aplikace je včetně zdrojových kódů v jazyce Java

 

  Aktivity (1)

Článek pro vás napsal vita
Avatar
vita

Jak se ti líbí článek?
Celkem (3 hlasů) :
3.666673.666673.666673.66667 3.66667


 


Miniatura
Předchozí článek
Wicket - Formulář a model
Miniatura
Všechny články v sekci
Apache Wicket
Miniatura
Následující článek
Wicket - Validace vstupu a opakovač

 

 

Komentáře

Děláme co je v našich silách, aby byly zdejší diskuze co nejkvalitnější. Proto do nich také mohou přispívat pouze registrovaní členové. Pro zapojení do diskuze se přihlas. Pokud ještě nemáš účet, zaregistruj se, je to zdarma.

Zatím nikdo nevložil komentář - buď první!