Lekce 7 - Programování databázového Wrapperu v Javě - Třída Database

V minulém dílu, Databázový wrapper v Javě - Tvorba třídy Query, jsme začali náš wrapper programovat a vytvořili si třídu Query.

V dnešním tutoriálu budeme pracovat na třídě Database, která je sice okomentovaná, ale i tak vám k určitým částem povím pár slov. Ještě předtím si ale otestujeme třídu Query.

Testování třídy Query

Ve třídě Wrapper si do metody main() vložíme následující kód, kterým otestujeme jednotlivé dotazy na třídě Query:

Query query = new Query();

query.delete("programatori").where("jmeno = ?");
System.out.println(query.getQuery());
// Výstup: DELETE FROM programatori WHERE jmeno = ?

String[] updateColumns = {"jmeno","jazyk"};
query.update("programatori").set(updateColumns).where("where id = ?");
System.out.println(query.getQuery());
// Výstup: UPDATE programatori SET jmeno = ?,jazyk = ? WHERE where id = ?

query.select(null).from("programatori").where("jazyk = ?");
System.out.println(query.getQuery());
// Výstup: SELECT * FROM programatori WHERE jazyk = ?

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

Třídu Query je potřeba do třídy Wrapper importovat!

Tvorba třídy Database

Nyní již přejděme ke třídě Database, která zastřešuje celý wrapper.

Konstruktor - připojení k databázi

V konstruktoru se připojíme k databází a toto spojení 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);
    }
}

Pokud bychom wrapper používali ve webové aplikaci místo v desktopové, nebyl by tento přístup vhodný kvůli velkému počtu aktivních spojení s databází. V tomto případě bychom se měli připojit v každé metodě znovu a pomocí bloku try-with-resources, jak to známe z předchozích tutoriálů.

Obecná metoda query()

Tato metoda bude privátní a bude to pomocná metoda pro metody delete(), save() a update(), které si vytvoříme v dalších částech:

// ...
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();
    }
}

Metoda přijímá jako první parametr SQL dotaz a dále může přijmout jakýkoli počet parametrů různého typu.

Dále stojí za povšimnutí metoda setObject() třídy PreparedStatement. Díky této metodě můžeme uložit hodnoty, aniž bychom dopředu věděli, jaký mají datový typ. Tato metoda je pro nás záchrana a velmi nám ulehčí práci.

Metoda vrací počet ovlivněných řádků. Výjimka, která může při dotazu vzniknout, je automaticky propagována díky použití klíčového slova throws v hlavičce metody. Datový typ výjimky je v tomto případě SQLException.

Vymazání záznamů - metoda delete()

Do třídy Database nyní doplníme metodu pro mazání záznamů:

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);
    }
}

Metodě delete() můžeme předat podmínku a parametry a vymažou se pouze ty záznamy, které splní námi stanovená kritéria.

Výjimky se v této metodě taktéž vyvolávají automaticky a jejich ošetření přenecháváme až na třídě, ze které metodu budeme volat.

Metoda dále vrací počet ovlivněných řádků. Pomocí této hodnoty poté zjistíme, zda se dotaz vykonal správně. Tuto návratovou hodnotu vrací také metody save() a update().

Je důležité nezapomenout, že výsledný SQL dotaz nám vrací metoda getQuery(). Častou chybou je, že se metodě query() předá pouze instance třídy Query. Viz příklad:

// Tento kód nebude fungovat
return query(query, param);

Zápis údajů - metoda insert()

Doplňme nyní kód metody 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);
    }
}

Metoda insert() třídy Database má dva parametry. Název tabulky a údaje které se mají do tabulky zapsat. Metoda je jednoduchá a není k ní moc co dodat.

Aktualizace údajů - metoda update()

Nakonec si dnes doplníme metodu pro úpravu databázových záznamů:

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);
    }
}

První tři parametry této metody jsou:

• název databázové tabulky,
• pole názvu sloupců a
• podmínka.

Dále může mít metoda ještě další parametry typu Object, kde uvedeme údaje, které se do tabulky zapíšou namísto těch starých.

Ve všech metodách ve třídě Database můžete vidět výhody plynulého rozhraní ze třídy Query. Kód je velmi jednoduchý, čitelný a dá se snadno pochopit.

Napříště nám zbyla na doplnění třídy Database ještě metoda select().

V následujícím kvízu, Kvíz - Práce s databází a wrapper v Java JDBC, si vyzkoušíme nabyté zkušenosti z předchozích lekcí.