Home / Programmazione / Java / Connessione a MySQL con Java e MyBatis
Mattepuffo

Connessione a MySQL con Java e MyBatis

Connessione a MySQL con Java e MyBatis

MyBatis è un framework di persistenza che si "frappone" tra strumenti completi come Hibernate, e l'usare JDBC e scrivere tutto da zero.

In sostanza ci leva alcune operazioni che dovremmo fare usando JDBC, ma ci lascia un pò più di flessibilità rispetto ad Hibernate.

Oggi vediamo un esempio abbastanza completo.

Partiamo dal db; abbiamo un database test, con una tabella utenti con questi campi:

  • id (PK AI)
  • nome
  • cognome
  • email

Tutti campi VARCHAR.

A questo punto create il vostro progetto; io uso Maven.

Dentro al file pom.xml mettete questo:

Abbiamo messo anche il connettore per MySQL, ma questo dipende dal db che usate.

Poi, io ho due package distinti:

  • com.mp.mappers -> dove metto i mappers per le tabelle
  • com.mp.testmaven -> dove c'è il main e altre classi di utilità

Cominciamo dal primo package; qui dentro creiamo tre classi.

La prima è una classe POJO:

package com.mp.mappers;

public class Utente {

    private int id;
    private String nome;
    private String cognome;
    private String email;

    public int getId() {
        return id;
    }

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

    public String getNome() {
        return nome;
    }

    public void setNome(String nome) {
        this.nome = nome;
    }

    public String getCognome() {
        return cognome;
    }

    public void setCognome(String cognome) {
        this.cognome = cognome;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

}

Poi abbiamo un'i nterfaccia nella quale registriamo le operazioni da eseguire:

package com.mp.mappers;

import java.util.List;

public interface UtenteMapper {

    public void insertUtente(Utente utente);

    public Utente getUtenteById(int id);

    public List getUtenti();

    public void updateUtente(Utente utente);

    public void deleteUtente(int id);
}

Infine abbiamo una classe di servizio che esegue le operazioni:

package com.mp.mappers;

import com.mp.testmaven.MyBatisUtils;
import java.util.List;
import org.apache.ibatis.session.SqlSession;

public class UtenteService {

    public void insertUtente(Utente utente) {
        try (SqlSession sqlSession = MyBatisUtils.getSqlSessionFactory().openSession()) {
            UtenteMapper utenteMapper = sqlSession.getMapper(UtenteMapper.class);
            utenteMapper.insertUtente(utente);
            sqlSession.commit();
        }
    }

    public Utente getUtenteById(Integer utenteId) {
        try (SqlSession sqlSession = MyBatisUtils.getSqlSessionFactory().openSession()) {
            UtenteMapper utenteMapper = sqlSession.getMapper(UtenteMapper.class);
            return utenteMapper.getUtenteById(utenteId);
        }
    }

    public List getUtenti() {
        try (SqlSession sqlSession = MyBatisUtils.getSqlSessionFactory().openSession()) {
            UtenteMapper utenteMapper = sqlSession.getMapper(UtenteMapper.class);
            return utenteMapper.getUtenti();
        }
    }

    public void updateUtente(Utente utente) {
        try (SqlSession sqlSession = MyBatisUtils.getSqlSessionFactory().openSession()) {
            UtenteMapper utenteMapper = sqlSession.getMapper(UtenteMapper.class);
            utenteMapper.updateUtente(utente);
            sqlSession.commit();
        }

    }

    public void deleteUtente(Integer id) {
        try (SqlSession sqlSession = MyBatisUtils.getSqlSessionFactory().openSession()) {
            UtenteMapper utenteMapper = sqlSession.getMapper(UtenteMapper.class);
            utenteMapper.deleteUtente(id);
            sqlSession.commit();
        }

    }

}

Passiamo al secondo package.

Abbiamo una classe di utilità che inizializza la connessione:

package com.mp.testmaven;

import java.io.IOException;
import java.io.Reader;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

public class MyBatisUtils {

    private static SqlSessionFactory factory;

    static {
        String myBatisConfig = "mybatis-config.xml";
        Reader reader = null;
        try {
            reader = Resources.getResourceAsReader(myBatisConfig);
        } catch (IOException e) {
            System.out.println(e.getMessage());
        }
        factory = new SqlSessionFactoryBuilder().build(reader);
    }

    public static SqlSessionFactory getSqlSessionFactory() {
        return factory;
    }
}

Come vedete, richiama un file XML; dopo vedremo come e dove crearlo.

Questo il main:

package com.mp.testmaven;

import com.mp.mappers.Utente;
import com.mp.mappers.UtenteService;
import java.util.List;

public class Main {

    public static void main(String[] args) {
        UtenteService us = new UtenteService();
        List list = us.getUtenti();
        for (Utente u : list) {
            System.out.println(u.getNome());
        }
    }
}

Siamo quasi arrivati, ci mancano due file XML.

Questi file li ho creati dentro src/main/resources, che è la directory di risorse di default di Maven.

Potete metterli dove volete, basta che indicate la directory nel file pom.xml.

Questo il file mybatis-config.xml, che contiene la configurazione generale per il database:

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <typeAliases>
        <typeAlias type="com.mp.mappers.Utente" alias="Utente"></typeAlias>
    </typeAliases>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC" />
            <dataSource type="POOLED">    
                <property name="driver" value="com.mysql.jdbc.Driver" />
                <property name="url" value="jdbc:mysql://194.1.1.5:3306/test" />
                <property name="username" value="USERNAME" />
                <property name="password" value="PASSWORD" />
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="UtenteMapper.xml" />
    </mappers>
</configuration>

Poi abbiamo UtenteMapper.xml, che contiene le query vere e proprie relative alla tabella utente:

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.mp.mappers.UtenteMapper">

    <select id="getUtenteById" parameterType="int" resultType="com.mp.mappers.Utente">
        SELECT id, nome, cognome, email FROM utenti WHERE id = #{id}
    </select>

    <resultMap type="Utente" id="UtenteResult">
        <id property="id" column="id" />
        <result property="email" column="email" />
        <result property="nome" column="nome" />
        <result property="cognome" column="cognome" />   
    </resultMap>

    <select id="getUtenti" resultMap="UtenteResult">
        SELECT * FROM utenti
    </select>

    <insert id="insertUtente" parameterType="Utente" useGeneratedKeys="true" keyProperty="id">
        INSERT INTO utenti(id, nome, cognome, email) VALUES(#{id}, #{nome}, #{cognome}, #{email})
    </insert>

    <update id="updateUtente" parameterType="Utente">
        UPDATE utenti SET nome = #{nome} WHERE id = #{id}
    </update>

    <delete id="deleteUtente" parameterType="int">
        DELETE FROM utenti WHERE id = #{id}
    </delete>

</mapper>

Se non so se ci avevate fatto caso, ma ancora non avevate scritto una query!

Ebbene, le mettete qua dentro, andando a richiamare i metodi messi in UtenteMapper.

A me personalmente piace il modo in cui viene gestito il tutto, più di Hibernate; soprattutto perchè ti da quella flessibilità in più!

Non ho implementato gli altri metodi riguardanti le operazioni su db; ve li lascio come compiti a casa.

Enjoy!