Cloud with rain
.:G
G:.
0 and 1 serie, black on white
pulled card
myjsp.feelinglinux.com
ver. 1.1.9-4
Hallo, welcome to my world.
Here you can find some stuff about computer science.
<<< Enjoy your visit! >>>
0 and 1 serie, white on black

MyBatis e i parametri nelle query SQL

          Scritto: Maryna Pylnyk, 17/01/2017     

Per la configurazione di base di Mybatis leggere l'articolo " MyBatis nelle applicazioni java, configurazione e implementazione "

In questo articolo parlerò di come passare i parametri dal codice java alle query SQL contenute nel mapper.
    Ricordiamo il nostro metodo:

    SqlSession session = null;
    try { 
        session = DatabaseInstance.getInstance().getFactory().openSession();  
        /* chiamando openSession() senza parametro, apriamo la connessione 
           SqlSession сon valore di default NON-AUTOCOMMIT, che va benissimo 
           per le query di ricerca, ma se volete effettuare query 
           che modificano i dati del database, dovreste più correttamente usare
           openSession(true)*/

        List<Object> = session.selectList("selectObjects", parametro);
    } catch (Exception e) {
        // si consiglia sempre di stampare l'eccezione
    } finally {
        if (session != null)
        session.close();
    }

    il nostro mapper:

    <mapper namespace="package.Example">
        <select id="selectObjects" parameterType="tipo parametro" resultType="qualche oggetto">
            select 
                field1,  
                field2 
            from table
        </select>
    </mapper>

Pubblicita'
Come possiamo notare, nel nostro mapper è stato aggiunto l'attributo "parameterType" che indica di che tipo e' il parametro in ingresso. <tipo parametro> può essere un qualsiasi oggetto, dai tipi primitivi (come String) ai POJO, oppure anche JavaBean e deve corrispondere a quello indicato come argomento della query nel codice java.
    nel metodo:

    List<Object> = session.selectList("selectObjects", new String("test1"));

    relativa query nel mapper:

    <select id="selectObjects" parameterType="String" resultType="qualche oggetto">
        select
            field1,
            field2
        from table
        where field2 = #{value} /* field2 = "test1" */
    </select>

Un altro esempio:

    nel metodo:

    HashMap<String, Object> map = new HashMap<String, Object>();
    map.put("test2",new Integer(5));
    List<Object> = session.selectList("selectObjects", map);

    relativa query nel mapper:

    <select id="selectObjects" parameterType="hashmap" resultType="qualche oggetto">
        select 
            field1,  
            field2 
        from table
        where field2 = ${test2}
    </select>
Pubblicita'


Notare che l'attributo parameterType e' opzionale,
cio' vuol dire che in tutti gli esempi qui sopra lo possiamo omettere perchè Mybatis automaticamente riconosce il tipo dall'oggetto passato nel metodo java.
Metto in evidenza l'uso dei caratteri speciali: nel primo caso si usa # , nel secondo $ .

Qual'e' la differenza?
Per gli oggetti primitivi come String, Integer, Mybatis inserisce direttamente il loro valore nel #{value} (value puo' essere sostituito con un altro nome), riconoscendone il tipo.
Nello stesso modo Mybatis agisce con gli oggetti JavaBean (ogni bean, per ogni sua proprieta', ha i relativi get() e set()).
Semplicemente dobbiamo scrivere nella query i nomi delle proprieta' della classe indicata come tipo di parametro d'ingresso:

    La nostra classe:

    public class User {

        private int id;
        private String name;

        public int getId() {
            return id;
        }

        public void setId(int id) {
            this.id = id;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }
    }

    nel metodo:

    User obj = new User();
    obj.setId(10);

    List<Object> = session.selectList("selectObjects", obj);


    relativa query nel mapper:	

    <mapper namespace="package.Example">
        <select id="selectObjects" parameterType="package.User" resultType="qualche oggetto">
            SELECT
                field1,
                field2
            from table
            where field2 = #{id}
        </select>
    </mapper>
    <!-- parameterType puo' essere omesso -->

La storia e' differente con il tipo "hashmap": dobbiamo indicare l'alias associato ad ogni parametro ed usare il carattere speciale $.
    nel metodo:

    HashMap<String, Object> map = new HashMap<String, Object>();
    map.put("param1",new Integer(1));
    map.put("param2",new String("2"));
    map.put("param3",new Integer(3));
    List<Object> = session.selectList("selectObjects", map);

    relativa query nel mapper:	

    <select id="selectObjects" resultType="qualche oggetto">
        select
            field1,
            field2
        from table
        where
            (field1 = ${param1}
            or
            field1 = ${param3})
            and
            field2 = ${param2}
    </select>


Hai trovato utile questo articolo?
Aiutami a condividerlo o metti un "mi piace".
Grazie mille!


Gli strumenti di condivisione (Google+, Facebook) sono visibili in alto a destra solo dopo aver accettato la policy di utilizzo dei cookie per questo sito.
FAQ - Come faccio a cambiare la mia scelta?

 

Strumenti (myjsp.feelinglinux.com)
Gioco: allenamento con la tastiera Strumenti di codifica/decodifica URI (%-encoding) e Base64 Strumenti di calcolo online per IP e Reti
QUIZ GAME
Quiz game

Cerca @myjsp.feelinglinux.com

Pubblicita'