7. diel - Programovanie databázového Wrappera v Jave - Trieda Database

V minulom dieli, Databázový wrapper v Jave - Tvorba triedy Query, sme začali náš wrapper programovať a vytvorili sme si triedu Query.

V dnešnom tutoriále budeme pracovať na triede Database, ktorá je síce okomentovaná, ale aj tak vám k určitým častiam poviem pár slov. Ešte predtým si ale otestujeme triedu Query.

Testovanie triedy Query

V triede Wrapper si do metódy main() vložíme nasledujúci kód, ktorým otestujeme jednotlivé dotazy na triede Query:

Query query = new Query();

query.delete("programmers").where("name = ?");
System.out.println(query.getQuery());
// Output: DELETE FROM programmers WHERE name = ?

String[] updateColumns = {"name","language"};
query.update("programmers").set(updateColumns).where("where id = ?");
System.out.println(query.getQuery());
// Output: UPDATE programmers SET name = ?,language = ? WHERE id = ?

query.select(null).from("programmers").where("language = ?");
System.out.println(query.getQuery());
// Output: SELECT * FROM programmers WHERE language = ?

Object[] insertParams = {null, "Galí", 43, "PHP"};
query.insert("programmers").values(insertParams);
System.out.println(query.getQuery());
// Output: INSERT INTO programmers VALUES(?,?,?,?);

Triedu Query je potrebné do triedy Wrapper importovať!

Tvorba triedy Database

Teraz už prejdime k triede Database, ktorá zastrešuje celý wrapper.

Konštruktor - pripojenie k databáze

V konštruktore sa pripojíme k databáze a toto spojenie si uložíme:

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class Database {

    // Database connection
    protected Connection connection;

    // Instance of the Query class
    protected Query query;

    /**
     * Constructor of Database
     *
     * @param db       Db name
     * @param userName User name
     * @param password User password
     * @throws SQLException
     */
    public Database(String db, String userName, String password) throws SQLException {
        connection = DriverManager.getConnection("jdbc:mysql://localhost/" + db, userName, password);
    }
}

Ak by sme wrapper používali vo webovej aplikácii namiesto v desktopovej, nebol by tento prístup vhodný kvôli veľkému počtu aktívnych spojení s databázou. V tomto prípade by sme sa mali pripojiť v každej metóde znova a pomocou bloku try-with-resources, ako to poznáme z predchádzajúcich tutoriálov.

Všeobecná metóda query()

Táto metóda bude privátna a bude to pomocná metóda pre metódy delete(), save() a update(), ktoré si vytvoríme v ďalších častiach:

// ...
import java.sql.PreparedStatement;

public class Database {

    // ...

    /**
     * @param query  SQL query
     * @param params Query params
     * @return The number of rows affected by the query.
     * @throws SQLException
     */
    private int query(String query, Object[] params) throws SQLException {
        PreparedStatement ps = connection.prepareStatement(query);
        if (params != null) {
            int index = 1;
            for (Object param : params) {
                ps.setObject(index, param);
                index++;
            }
        }
        return ps.executeUpdate();
    }
}

Metóda prijíma ako prvý parameter SQL dotaz a ďalej môže prijať akýkoľvek počet parametrov rôzneho typu.

Ďalej stojí za povšimnutie metóda setObject() triedy PreparedStatement. Vďaka tejto metóde môžeme uložiť hodnoty bez toho, aby sme vopred vedeli, aký majú dátový typ. Táto metóda je pre nás záchranou a veľmi nám uľahčí prácu.

Metóda vracia počet ovplyvnených riadkov. Výnimka, ktorá môže pri dotaze vzniknúť, je automaticky propagovaná vďaka použitiu kľúčového slova throws v hlavičke metódy. Dátový typ výnimky je v tomto prípade SQLException.

Vymazanie záznamov - metóda delete()

Do triedy Database teraz doplníme metódu na mazanie záznamov:

public class Database {

    // ...

    /**
     * Deletes data from the database table
     *
     * @param table       Db table
     * @param requirement Condition
     * @param param       Query params
     * @return The number of rows affected by the query.
     * @throws SQLException
     */
    public int delete(String table, String requirement, Object[] param) throws SQLException {
        query = new Query();
        query.delete(table).where(requirement);

        return query(query.getQuery(), param);
    }
}

Metóde delete() môžeme odovzdať podmienku a parametre a vymažú sa iba tie záznamy, ktoré splnia nami stanovené kritériá.

Výnimky sa v tejto metóde taktiež vyvolávajú automaticky a ich ošetrenie prenechávame až na triede, z ktorej metódu budeme volať.

Metóda ďalej vracia počet ovplyvnených riadkov. Pomocou tejto hodnoty potom zistíme, či sa dotaz vykonal správne. Túto návratovú hodnotu vracajú aj metódy save() a update().

Je dôležité nezabudnúť, že výsledný SQL dotaz nám vracia metóda getQuery(). Častou chybou je, že sa metóde query() odovzdá iba inštancia triedy Query. Pozri príklad:

// This code won't work
return query(query, param);

Zápis údajov - metóda insert()

Doplňme teraz kód metódy insert():

public class Database {

    // ...

    /**
     * Inserts one new record into the db table
     *
     * @param table  Db table
     * @param params Query params
     * @return The number of rows affected by the query.
     * @throws SQLException
     */
    public int insert(String table, Object[] params) throws SQLException {
        query = new Query();
        query.insert(table).values(params);

        return query(query.getQuery(), params);
    }
}

Metóda insert() triedy Database má 2 parametre. Názov tabuľky a údaje, ktoré sa majú do tabuľky zapísať. Metóda je jednoduchá a nie je k nej veľmi čo dodať.

Aktualizácia údajov - metóda update()

Nakoniec si dnes doplníme metódu na úpravu databázových záznamov:

public class Database {

    // ...

    /**
     * Updates chosen database data
     *
     * @param table       Db table
     * @param columns     Columns to be updated
     * @param requirement Condition
     * @param params      Query params
     * @return The number of rows affected
     * @throws SQLException
     */
    public int update(String table, String[] columns, String requirement, Object[] params) throws SQLException {
        query = new Query();
        query.update(table).set(columns).where(requirement);

        return query(query.getQuery(), params);
    }
}

Prvé tri parametre tejto metódy sú:

• názov databázovej tabuľky,
• pole názvu stĺpcov a
• podmienka.

Ďalej môže mať metóda ešte ďalšie parametre typu Object, kde uvedieme údaje, ktoré sa do tabuľky zapíšu namiesto tých starých.

Vo všetkých metódach v triede Database môžete vidieť výhody plynulého rozhrania z triedy Query. Kód je veľmi jednoduchý, čitateľný a dá sa ľahko pochopiť.

Nabudúce nám na doplnenie triedy Database zostáva ešte metóda select().

V nasledujúcom kvíze, Kvíz - Práca s databázou a wrapper v Java JDBC, si vyskúšame nadobudnuté skúsenosti z predchádzajúcich lekcií.