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 si triedu Query.

Dnes budeme tvoriť triedu 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žte nasledujúci kód, ktorým otestujeme jednotlivé otázky na triede Query.

Query query = new Query();

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

String[] columns3 = {"jmeno","jazyk"};
query.update("programatori").set(columns3).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[] firstParams = {null, "Galí", 43, "PHP"};
query.insert("programatori").values(firstParams);
System.out.println(query.getQuery());
//Výstup: INSERT INTO programatori VALUES(?,?,?,?);

Je nutné aby ste si triedu Query importovali!

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.

package DB;

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

/**
*
* @author Milan Gallas
*/

public class Database {

     //připojení k databázi
     protected Connection connection;

     //instance třídy query
     protected Query query;

     /**
     * Konstruktor třídy Database
     * @param db
     * @param userName
     * @param password
     * @throws SQLException
     */
     public Database(String db, String userName, String password) throws SQLException{

          connection = DriverManager.getConnection("jdbc:mysql://localhost/"+db, userName, password);

     }

}

Pozn.: Ak by sme wrapper používali vo webovej aplikácii miesto 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 TWR, ako to poznáte 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.

public class Database {
      //atribut třídy
      //metody třídy

     /**
     *
     * @param query
     * @param params
     * @return
     * @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 dopredu vedeli aký majú dátový typ. Táto metóda je pre nás záchrana 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

public class Database {
  //atribut třídy
  //metody třídy

   /**
     * Vymaže údaje z databázové tabulky
     * @param table
     * @param requirement
     * @param param
     * @return
     * @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. Častá chyba je, že sa metóde query odovzdá iba inštancia triedy Query. Pozri príklad:

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

Zápis údajov - metóda insert

public class Database {
    //atribut třídy
    //metody třídy

    /**
     * Uloží do databázové tabulky 1 subjekt
     * @param table
     * @param params
     * @return
     * @throws java.sql.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

public class Database {
      //atribut třídy
      //metody třídy

   /**
     * Aktualizuje data uložená v databázové tabulce
     * @param table
     * @param columns
     * @param requirement
     * @param params
     * @return
     * @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, ktoré značia ú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. Kód je veľmi jednoduchý, čitateľný a dá sa ľahko pochopiť.

Tak a zostala nám na dorobenie 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í.