java - que - jdbi 2

¿Cuál es la diferencia entre JDBC y JDBI?

Question

Quiero saber sobre las diferencias entre JDBC y JDBI en Java. En particular, ¿cuál es en general mejor y por qué?

Answer 1

¿Te refieres a http://jdbi.codehaus.org/ ?

jDBI está diseñado para proporcionar un conveniente acceso a datos tabulares en Java (tm). Utiliza el marco de recopilación de Java para los resultados de la consulta, proporciona un medio conveniente de externalizar sentencias SQL y proporciona compatibilidad con parámetros con nombre para cualquier base de datos que se utilice.

JDBI usa JDBC, si no sabe si necesita JDBI, le sugiero que no lo use.

Answer 2

(Soy el autor principal de jDBI)

jDBI es una biblioteca de conveniencia construida sobre JDBC . JDBC funciona muy bien, pero en general parece optimizar para los proveedores de bases de datos (escritores de controladores) sobre los usuarios. jDBI intenta exponer la misma funcionalidad, pero en una API optimizada para los usuarios.

Es un nivel mucho más bajo que Hibernate o JPA . La biblioteca similar más cercana es probablemente MyBatis (sucesor bifurcado de iBATIS ).

jDBI es compatible con dos API de estilo, un estilo fluido anterior, que se ve así:

List<Something> r = h.createQuery("select * from something where name = :name and id = :id")
                .bind(0, "eric")
                .bind("id", 1)
                .map(Something.class)
                .list();

Una nueva API de objeto SQL hace cosas mucho más reflexivas y realmente comienza a abstraer un montón de material JDBC:

interface TheBasics
{
    @SqlUpdate("insert into something (id, name) values (:id, :name)")
    int insert(@BindBean Something something);

    @SqlQuery("select id, name from something where id = :id")
    Something findById(@Bind("id") long id);
}

@Test
public void useTheBasics() throws Exception
{
    TheBasics dao = dbi.onDemand(TheBasics.class);

    dao.insert(new Something(7, "Martin"));

    Something martin = dao.findById(7);
}

La biblioteca tiene buenos documentos de referencia (javadoc) y una documentación de estilo tutorial razonable en http://jdbi.org/ . Ha estado presente desde 2004, y es utilizado por un número relativamente pequeño de personas (algunas pocas docenas de personas que conozco personalmente, y tal vez una docena de empresas) pero funciona muy bien para ellos. La mayoría de las personas que trabajan en él son gente de A +, y se preocupan principalmente por crear una herramienta que les funcione bien; el código abierto es, en gran medida, un efecto secundario.

Answer 3

De hecho, JDBI está construido sobre JDBC, de hecho, lo más probable es que utilice JDBC para llegar a la base de datos, y JDBI será el que abrace (o envuelva) a JDBC para que los estados preparados se ejecuten contra la base de datos.

Internamente, el controlador JDBC es el que ejecuta la transacción, JDBI solo funciona como intermediario.

Es más ligero que un ORM (como Hibernate o Spring), pero realmente ayuda a acelerar el desarrollo y tener todo más, "agradable y limpio", ya que tiene muchas utilidades para hacer que la codificación sea más fácil y más limpia, por ejemplo:

Para definir un objeto simple para insertar / leer una tabla, puede hacerlo así:

import com.sql.poc.data.jDBI.map.AgentMapper;
import com.sql.poc.domain.Agent;
import org.skife.jdbi.v2.sqlobject.Bind;
import org.skife.jdbi.v2.sqlobject.SqlQuery;
import org.skife.jdbi.v2.sqlobject.SqlUpdate;
import org.skife.jdbi.v2.sqlobject.customizers.Mapper;
import org.skife.jdbi.v2.sqlobject.mixins.Transactional;

public interface SqlObjectDataAccess extends Transactional<SqlObjectDataAccess> {

    @SqlUpdate("INSERT INTO pocAgent (LocationId, Name, Country) VALUES (:id, :name, :country)")
    void insertAgent(@Bind("id") String locationId,
                     @Bind("name") String name,
                     @Bind("country") String country);

    @SqlQuery("SELECT LOCATIONID, NAME, COUNTRY, CREATEDON FROM pocAgent WHERE LOCATIONID = :LocationId")
    @Mapper(AgentMapper.class)
    Agent getAgentByLocation(@Bind("LocationId") String locationId);

    void close();    
}

JDBI le brinda la facilidad de tener toda la lógica de mapeo en el mismo lugar, como por ejemplo:

import com.sql.poc.domain.Agent;
import org.skife.jdbi.v2.StatementContext;
import org.skife.jdbi.v2.tweak.ResultSetMapper;
import java.sql.ResultSet;
import java.sql.SQLException;

public class AgentMapper implements ResultSetMapper<Agent> {
    @Override
    public Agent map(int index, ResultSet r, StatementContext ctx) throws SQLException {
        return new Agent(r.getString("LocationId"),
                r.getString("Name"),
                r.getString("Country"),
                r.getDate("CreatedOn"));
    }
}

Y luego solo necesita usar el DAO (Objeto de acceso a datos):

import com.google.inject.Inject;
import com.sql.poc.IConnectionHelper;
import com.sql.poc.domain.Agent;
import org.skife.jdbi.v2.DBI;
import org.skife.jdbi.v2.logging.Log4JLog;

public class SqlObjectRepository {
    IConnectionHelper _connectionHelper;
    DBI _dbiInstance;
    SqlObjectDataAccess _daoHandler;

    @Inject
    SqlObjectRepository() {
        _dbiInstance = new DBI(_connectionHelper.getDataSource());
        _dbiInstance.setSQLLog(new Log4JLog());
    }

    public void openConnection() {
        if (_daoHandler == null)
            _daoHandler = _dbiInstance.open(SqlObjectDataAccess.class);
    }

    @org.skife.jdbi.v2.sqlobject.Transaction
    public Agent insertAgent(String locationId, String name, String country) {
        openConnection();
        Agent agent = _daoHandler.getAgentByLocation(locationId);
        if (agent == null) {
            _daoHandler.insertAgent(locationId, name, country);
        }
        agent = _daoHandler.getAgentByLocation(locationId);
        _daoHandler.commit();
        return agent;
    }
}

Luego, si profundizamos un poco más y comprobamos cómo se realiza la conexión en la base de datos, notará que, para esta muestra de prueba de concepto, se usa JDBC:

import com.google.inject.Inject;
import com.sql.poc.IConnectionHelper;
import org.apache.commons.dbcp.ConnectionFactory;
import org.apache.commons.dbcp.DriverManagerConnectionFactory;
import org.apache.commons.dbcp.PoolableConnectionFactory;
import org.apache.commons.dbcp.PoolingDataSource;
import org.apache.commons.pool.impl.GenericObjectPool;

import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.SQLException;

public class TandemMPConnectionHelper implements IConnectionHelper {
    private final DataSource _dataSource;

    @Inject
    TandemMPConnectionHelper() {
        try {
            Class.forName("com.tandem.t4jdbc.SQLMXDriver");
        } catch (ClassNotFoundException e) {
            System.out.println(e.toString());
        }
        _dataSource = setupDataSource("jdbc:t4sqlmx://<server>:<port>/:<username>:<password>:", "user1", "password1");
    }

    @Override
    public DataSource setupDataSource(String connectURI, String userName, String password) {
        GenericObjectPool connectionPool = new GenericObjectPool();
        connectionPool.setMaxActive(20);
        ConnectionFactory connectionFactory = new DriverManagerConnectionFactory(
                connectURI,
                userName,
                password);
        new PoolableConnectionFactory(connectionFactory, connectionPool, null, null, false, false);
        return new PoolingDataSource(connectionPool);
    }

    @Override
    public DataSource getDataSource() {
        return _dataSource;
    }

    @Override
    public Connection getConnection() {
        Connection connection;
        try {
            connection = _dataSource.getConnection();
            connection.setAutoCommit(false);
        } catch (SQLException e) {
            System.out.println(e.getMessage());
            return null;
        }
        return connection;
    }
}

En este caso, estoy llegando a una base de datos Tandem Non / Stop, pero lo mismo funciona para SQL Server, ORACLE, o cualquier DB al que esté llegando, solo necesita el controlador JDBC correcto ( que puede encontrar fácilmente, ¡simplemente Google! )

Espero que te dé una idea más clara de dónde, conceptualmente, ubicas JDBI y JDBC en tu código.

Answer 4

Encontré jDBI cuando busco parámetros SQL con nombre. Utilizo el competidor conocido Spring JDBC NamedTemplate, pero tiene dependencias extrañas para 8-10MB. Ya tengo una dependencia a ANTLR.

Miro desde hace pocas horas, jDBI parece inspirador. Ambos (jDBI / Spring JDBC) se pueden comparar hasta cierto punto con ORM ligero como iBatis / MyBatis, etc.

Answer 5

JDBC es un estándar de larga data utilizado en Java para acceder a bases de datos SQL. Los proveedores de DB implementan un controlador JDBC para que todos los DB puedan ser accedidos de manera uniforme. Prácticamente todo lo que se hace con bases de datos en Java usa JDBC.

JDBI parece ser una especie de capa de abstracción sobre JDBC, pero es difícil de decir ya que está mal documentada. Ciertamente no es ampliamente utilizado y esta es la primera vez que he oído hablar de él.

Answer 6

jDBI está construido sobre JDBC. Todas las aplicaciones Java usan JDBC para acceder a las bases de datos relacionales, por lo que no es una opción de elección. Ellos son complementarios. No puedes usar jDBI sin JDBC.

Dicho esto, jDBI es el intento de otra persona de relevar a los desarrolladores de Java del estándar requerido por JDBC. Es como elegir Hibernate o TopLink o iBatis.