Quelle est la différence entre JDBC et JDBI?

(Je suis l'auteur principal de jDBI)

jDBI est une commodité bibliothèque construite au sommet de JDBC. JDBC fonctionne très bien mais semble généralement à l'optimisation de la base de données des fournisseurs (pilote d'écrivains) sur les utilisateurs. jDBI tente d'exposer la même fonctionnalité, mais dans une API, optimisé pour les utilisateurs.

Elle est beaucoup plus faible niveau que les choses comme les Hibernate ou JPA. Le plus proche de la bibliothèque semblable est probablement MyBatis (fourche successeur de iBATIS).

jDBI prend en charge deux Api, plus d'un fluide de style, ce qui ressemble à:

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

Une plus récente de SQL API d'Objet fait beaucoup plus de type réflectif trucs et vraiment commencer à l'abstrait un tas de JDBC trucs:

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 bibliothèque a la bonne référence de la documentation (javadoc) et quelques raisonnable tutoriel style de la documentation à http://jdbi.org/. Il a été autour depuis 2004, et est utilisé par un nombre relativement restreint de gens (quelques dizaines de personnes que je connais personnellement, et peut-être une douzaine d'entreprises), mais il fonctionne très bien pour eux. La plupart des gens qui travaillent, il y A+ de gens, et sont principalement concernés par la construction d'un outil qui fonctionne bien pour eux-qu'il est open source, c'est en grande partie un effet secondaire.

JDBC est une norme utilisée en Java pour accéder à des bases de données SQL. DB Vendeurs de mettre en œuvre un pilote JDBC de sorte que les bases de données peuvent être consultées de manière uniforme. Pratiquement tout faire avec des bases de données en Java utilise JDBC.

JDBI semble être une sorte de couche d'abstraction sur JDBC, mais c'est difficile à dire car il est mal documenté. Ce n'est certainement pas largement utilisé et c'est la première fois que j'ai entendu parler de lui.

En effet, JDBI est construit sur le haut de JDBC, en fait, plus vous aurez de chances de l'utilisation de JDBC pour atteindre la DB, et JDBI sera celui qui embrasse(ou emballés) JDBC pour obtenir le PreparedStatements exécutée à l'encontre de la DB.

En interne, le Pilote JDBC est celui qui exécute la transaction, JDBI fonctionne comme un Intermédiaire.

Il est plus léger qu'un ORM (comme Hibernate ou de Printemps), mais il aide vraiment à accélérer le développement et ont tout les plus, "belle et propre", car il a beaucoup d'utilitaires pour rendre la programmation plus facile et plus propre, par exemple:

Pour définir un objet simple à insérer/lire un tableau, vous pouvez le faire comme ceci:

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 vous donne la facilité d'avoir la cartographie de la logique à la même place, tels que:

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

Et puis vous avez juste besoin d'utiliser le DAO (Data Access Object):

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

Alors, si nous allons un peu plus loin, et de vérifier comment la Connexion se fait à la DB, vous remarquerez que, pour cette Preuve de Concept exemple JDBC est utilisé:

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

Dans ce cas, je suis d'atteindre un Tandem Non/Stop de la base de données, mais les mêmes œuvres pour SQL Server, ORACLE, ou quelle que soit la db vous atteignez, vous avez juste besoin de la bonne Pilote JDBC (que vous pouvez trouver facilement, simplement Google!).

Espère que cela vous donne une meilleure idée de l'endroit où, sur le plan conceptuel, recherchez JDBI et JDBC dans votre code.