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.

Dnes budeme tvořit třídu 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žte 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[] 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 jste si třídu Query importovali!

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.

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.: 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 TWR, jak to znáte 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.

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

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 PreparedState­ment. 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

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

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. Častá chyby 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

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

Metoda insert třídy Database má 2 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

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

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, které značí údaje, které se do tabulky zapíší namísto těch starých.

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

Tak a zbyla nám na dodělání 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í.