Spring JdbcTemplate - Insérer le blob et retourner la clé générée

Je suis venu ici à la recherche pour la même réponse, mais n'était pas satisfait de ce qui a été accepté. J'ai donc fait un peu de creuser autour et est venu avec cette solution que j'ai testé dans Oracle 10g et le Printemps 3.0

public Long save(final byte[] blob) {
  KeyHolder keyHolder = new GeneratedKeyHolder();
  String sql = "insert into blobtest (myblob) values (?)"; //requires auto increment column based on triggers
  getSimpleJdbcTemplate().getJdbcOperations().update(new AbstractLobPreparedStatementCreator(lobHandler, sql, "ID") {
    @Override
    protected void setValues(PreparedStatement ps, LobCreator lobCreator) throws SQLException, DataAccessException {
      lobCreator.setBlobAsBytes(ps, 1, blob);
    }
  }, keyHolder);

  Long newId = keyHolder.getKey().longValue();
  return newId;
}

cela nécessite aussi la suite de la classe abstraite, fondée en partie sur le Printemps AbstractLobCreatingPreparedStatementcallback

public abstract class AbstractLobPreparedStatementCreator implements PreparedStatementCreator {
  private final LobHandler lobHandler;
  private final String sql;
  private final String keyColumn;
  public AbstractLobPreparedStatementCreator(LobHandler lobHandler, String sql, String keyColumn) {
    this.lobHandler = lobHandler;
    this.sql = sql;
    this.keyColumn = keyColumn;
  }
  public PreparedStatement createPreparedStatement(Connection con) throws SQLException {
    PreparedStatement ps = con.prepareStatement(sql, new String[] { keyColumn });
    LobCreator lobCreator = this.lobHandler.getLobCreator();
    setValues(ps, lobCreator);
    return ps;
  }
  protected abstract void setValues(PreparedStatement ps, LobCreator lobCreator) throws SQLException, DataAccessException;
}

Aussi, le tableau que vous créez dans Oracle doit avoir une clé auto-incrémentée pour l'id à l'aide d'une séquence et la détente. Le déclencheur est nécessaire car sinon vous auriez à utiliser le Printemps NamedParameterJdbcOperations (à faire la séquence.nextval dans votre SQL) qui ne semble pas avoir de support pour porte-clés (que j'utilise pour récupérer l'auto-gen id). Consultez cet article de blog (pas mon blog) pour plus d'info: http://www.lifeaftercoffee.com/2006/02/17/how-to-create-auto-increment-columns-in-oracle/

create table blobtest (
id number primary key,
myblob blob);

create sequence blobseq start with 1 increment by 1;

CREATE OR REPLACE TRIGGER blob_trigger
BEFORE INSERT
ON blobtest
REFERENCING NEW AS NEW
FOR EACH ROW
BEGIN
SELECT blobseq.nextval INTO :NEW.ID FROM dual;
end;
/

J'ai fini par la simple exécution de deux requêtes, l'une pour créer la ligne et une mise à jour de la goutte.

int id = insertRow();
updateBlob(id, blob);

En regardant le source code et d'en extraire les pièces nécessaires, je suis venu avec cette:

final KeyHolder generatedKeyHolder = new GeneratedKeyHolder();
getJdbcTemplate().execute(
    "INSERT INTO lob_table (blob) VALUES (?)",
    new PreparedStatementCallback() {
        public Object doInPreparedStatement(PreparedStatement ps) throws SQLException {
            LobCreator lobCreator = lobHandler.getLobCreator();
            lobCreator.setBlobAsBinaryStream(ps, 2, blobIs, (int)blobIn.length());

            int rows = ps.executeUpdate();
            List generatedKeys = generatedKeyHolder.getKeyList();
            generatedKeys.clear();
            ResultSet keys = ps.getGeneratedKeys();
            if (keys != null) {
                try {
                    RowMapper rowMapper = new ColumnMapRowMapper();
                    RowMapperResultSetExtractor rse = new RowMapperResultSetExtractor(rowMapper, 1);
                    generatedKeys.addAll((List) rse.extractData(keys));
                }
                finally {
                    JdbcUtils.closeResultSet(keys);
                }
            }
            if (logger.isDebugEnabled()) {
                logger.debug("SQL update affected " + rows + " rows and returned " + generatedKeys.size() + " keys");
            }
            return new Integer(rows);
        }
    }
);

Je ne peux pas dire que je comprends tout à fait ce qui se passe ici. Je ne suis pas sûr si la complexité de la méthode pour extraire la clé générée est nécessaire dans ce cas simple, et je ne suis pas tout à fait clair au sujet de l'avantage de même à l'aide de JdbcTemplate lorsque le code de ce poilu.

De toute façon, j'ai testé le code ci-dessus et il fonctionne. Pour mon cas, j'ai décidé qu'il ne ferait que compliquer mon code de trop.

Dans le cas où votre base de données est mysql, vous pouvez générer automatiquement votre clé primaire. Puis d'insérer un enregistrement dans votre base de données, vous pouvez utiliser la syntaxe suivante pour l'insertion:

INSERT INTO lob_table (a_blob) VALUES (?)

C'est testé sur MySql seulement et j'ai collé uniquement la partie pertinente.
Après l'Exécution de ma classe de test, le résultat est illustré ci-dessous:
"enregistrement ajouté par modèle.mise à jour(cfp), kh): 1 ajouté et a obtenu 36"

final byte[] bytes = "My Binary Content".getBytes();
final ByteArrayInputStream bais = new ByteArrayInputStream(bytes);        
PreparedStatementCreator psc = new PreparedStatementCreator() {
PreparedStatement ps = null;
public PreparedStatement createPreparedStatement(
Connection connection) throws SQLException {
dummy.setStringCode("dummy_jdbc_spring_createPS_withKey_lob");
ps = connection
.prepareStatement(
"INSERT INTO DUMMY (dummy_code, dummy_double, dummy_date, dummy_binary) VALUES (?, ?, ?,?)",
Statement.RETURN_GENERATED_KEYS);
ps.setString(1, dummy.getStringCode());
ps.setDouble(2, dummy.getDoubleNumber());
ps.setDate(3, dummy.getDate());
new DefaultLobHandler().getLobCreator().setBlobAsBinaryStream(
ps, 4, bais, bytes.length);
return ps;
}
};
KeyHolder holder = new GeneratedKeyHolder();
System.out.println("record added via template.update(psc,kh): "
+ template.update(psc, holder)+" added and got key " + holder.getKey());

Peut-être que certains comme ceci:

public class JdbcActorDao implements ActorDao {
private SimpleJdbcTemplate simpleJdbcTemplate;
private SimpleJdbcInsert insertActor;
public void setDataSource(DataSource dataSource) {
this.simpleJdbcTemplate = new SimpleJdbcTemplate(dataSource);
this.insertActor =
new SimpleJdbcInsert(dataSource)
.withTableName("t_actor")
.usingGeneratedKeyColumns("id");
}
public void add(Actor actor) {
Map<String, Object> parameters = new HashMap<String, Object>(2);
parameters.put("first_name", actor.getFirstName());
parameters.put("last_name", actor.getLastName());
Number newId = insertActor.executeAndReturnKey(parameters);
actor.setId(newId.longValue());
}
// ... additional methods
}