Spring JDBC Modèle pour l'appel de Procédures Stockées

Quelle est la bonne manière pour appeler des procédures stockées à l'aide de jour moderne (vers 2012) Spring JDBC Modèle?

Dire, j'ai une procédure stockée qui déclare deux IN et OUT paramètres, quelque chose comme ceci:

mypkg.doSomething(
    id OUT int,
    name IN String,
    date IN Date
)

Je suis venu à travers CallableStatementCreator des approches fondées sur où nous avons à inscrire explicitement IN et OUT paramètres. Considérons la méthode suivante dans JdbcTemplate classe:

public Map<String, Object> call(CallableStatementCreator csc, List<SqlParameter> declaredParameters)

Bien sûr, je sais que je peux l'utiliser comme ça:

List<SqlParameter> declaredParameters = new ArrayList<SqlParameter>();

declaredParameters.add(new SqlOutParameter("id", Types.INTEGER));
declaredParameters.add(new SqlParameter("name", Types.VARCHAR));
declaredParameters.add(new SqlParameter("date", Types.DATE));

this.jdbcTemplate.call(new CallableStatementCreator() {

    @Override
    CallableStatement createCallableStatement(Connection con) throws SQLException {
        CallableStatement stmnt = con.createCall("{mypkg.doSomething(?, ?, ?)}");

        stmnt.registerOutParameter("id", Types.INTEGER);
        stmnt.setString("name", "<name>");
        stmnt.setDate("date", <date>);

        return stmnt;
    }
}, declaredParameters);

Quel est le but de declaredParameters quand je suis déjà en les enregistrant dans mon csc mise en œuvre? En d'autres termes, pourquoi aurais-je besoin de passer dans un csc quand le printemps peut tout simplement con.prepareCall(sql) en interne? Fondamentalement, je ne peux pas passer dans l'un d'eux au lieu de deux?

Ou, est-il une bien meilleure façon d'appeler des procédures stockées (à l'aide de Spring JDBC Modèle) que ce que j'ai pu rencontrer jusqu'à présent?

Remarque: Vous pouvez trouver bon nombre de questions qui semblent avoir un titre similaire, mais ils ne sont pas les mêmes que celui-ci.

Je peux voir que cette question est très populaire aujourd'hui et il a déjà plus de 2 ans que cela a été demandé. Si quelqu'un pense qu'il y a encore de mieux que d'appeler des procédures stockées maintenant que le Printemps 4 est sorti, merci de poster une réponse ou suggérer une modification.

InformationsquelleAutor adarshr | 2012-02-20

85

Il y a un certain nombre de façons d'appeler des procédures stockées au Printemps.

Si vous utilisez CallableStatementCreator de déclarer les paramètres, vous allez être en utilisant Java de l'interface standard de CallableStatement, j'.e registre des paramètres et de les définir séparément. À l'aide de SqlParameter l'abstraction permet de rendre votre code plus propre.

Je vous recommande de regarder SimpleJdbcCall. Il peut être utilisé comme ceci:
```
SimpleJdbcCall jdbcCall = new SimpleJdbcCall(jdbcTemplate)
    .withSchemaName(schema)
    .withCatalogName(package)
    .withProcedureName(procedure)();
...
jdbcCall.addDeclaredParameter(new SqlParameter(paramName, OracleTypes.NUMBER));
...
jdbcCall.execute(callParams);
```
De procédures simples, vous pouvez utiliser jdbcTemplate's update méthode:
```
jdbcTemplate.update("call SOME_PROC (?, ?)", param1, param2);
```
- SimpleJdbcCall semble vraiment cool. Je vais tester cela et vous laisser savoir comment elle réussi dans mon cas.
- C'était un plaisir de travailler avec SimpleJdbcCall. Je vous remercie.
- La méthode de mise à jour ne fonctionne pas pour moi, j'ai reçu la mauvaise grammaire SQL exception, même si mon instruction exécutée très bien dans la base de données. SimpleJdbcCall très bien fonctionné
- Je suis en train d'utiliser jdbcTemplate.mise à jour() de la même manière que vous l'avez dit, mais avoir d'erreur disant "cannot invoke update on null object".
- Le jdbcTemplate.update("call SOME_PROC (?, ?)", param1, param2); ne parvient pas, pour moi aussi avec l'erreur org.postgresql.util.PSQLException: ERROR: syntax error at or near "call" lorsqu'il est invoqué comme getNamedParameterJdbcTemplate().update("call API.UPSERT_TOKEN(:token, :email)", params)
- utilisation ?, ? au lieu de :token, :email
- J'ai eu NamedParameterJdbcTemplate, pas JdbcTemplate
- Je ne sais pas si c'est Oracle syntaxe spécifique, mais la syntaxe Oracle est: jdbcTemplate.update("{ call my_schema.my_pkg.SOME_PROC (?, ?) }", param1, param2); (note les accolades).
- Pourquoi il donne: SQL update affected 0 rows lorsque les lignes ont été effectivement touchés?
- param nom doit correspondre exactement au param noms que vous avez dans votre base de données. Aussi, si vous avez besoin de tous les paramètres, de la définir comme par exemple new SqlInOutParameter(paramName,Types.VARCHAR) de sorte qu'ils seront inclus dans le retour de la Carte
- Parfois, l'utilisation de SimpleJdbcCall a des pièges. Code pourrait coincé si SimpleJdbcCall est partagé entre plusieurs threads
- Comment voulez-vous obtenir des avertissements (comme dans l'Énoncé.getWarnings() dans jdbc) à partir de cela?
- comment dou-vous résoudre perfomance problème pour SimpleJdbcCall? Il faut 3000-4000ms pour un appel. Mais ce temps est de 0,1-0,5 ms sur la base jdbc appel.
- comment puis-je gérer si ma procédure stockée est de prendre plus de temps , comment puis-je gérer la connexion et le temps d'émission
InformationsquelleAutor Infeligo

Voici les différentes façons d'appeler des procédures stockées à partir de java

1. À L'Aide De CallableStatement:

 connection = jdbcTemplate.getDataSource().getConnection();
  CallableStatement callableStatement = connection.prepareCall("{call STORED_PROCEDURE_NAME(?, ?, ?)}");
  callableStatement.setString(1, "FirstName");
  callableStatement.setString(2, " LastName");
  callableStatement.registerOutParameter(3, Types.VARCHAR);
  callableStatement.executeUpdate();

Ici, nous avons l'extérieur de gérer la ressource de clôture

2. À L'Aide De CallableStatementCreator

 List paramList = new ArrayList();
    paramList.add(new SqlParameter(Types.VARCHAR));
    paramList.add(new SqlParameter(Types.VARCHAR));
    paramList.add(new SqlOutParameter("msg", Types.VARCHAR));

    Map<String, Object> resultMap = jdbcTemplate.call(new CallableStatementCreator() {

    @Override
    public CallableStatement createCallableStatement(Connection connection)
    throws SQLException {

    CallableStatement callableStatement = connection.prepareCall("{call STORED_PROCEDURE_NAME(?, ?, ?)}");
    callableStatement.setString(1, "FirstName");
            callableStatement.setString(2, " LastName");
            callableStatement.registerOutParameter(3, Types.VARCHAR);
    return callableStatement;

    }
    }, paramList);

3. Utilisation SimpleJdbcCall:

SimpleJdbcCall simpleJdbcCall = new SimpleJdbcCall(jdbcTemplate)

.withProcedureName("STORED_PROCEDURE_NAME");

Map<String, Object> inParamMap = new HashMap<String, Object>();
inParamMap.put("firstName", "FirstNameValue");
inParamMap.put("lastName", "LastNameValue");
SqlParameterSource in = new MapSqlParameterSource(inParamMap);


Map<String, Object> simpleJdbcCallResult = simpleJdbcCall.execute(in);
System.out.println(simpleJdbcCallResult);

4. Utilisation StoredProcedure classe org.springframework.jdbc.objet

The Code:
First Create subclass of StoredProcedure: MyStoredProcedure

class MyStoredProcedure extends StoredProcedure {

public MyStoredProcedure(JdbcTemplate jdbcTemplate, String name) {

super(jdbcTemplate, name);
setFunction(false);

}

}

Use MyStoredProcedure to call database stored procedure:


//Pass jdbcTemlate and name of the stored Procedure.
MyStoredProcedure myStoredProcedure = new MyStoredProcedure(jdbcTemplate, "PROC_TEST");

//Sql parameter mapping
SqlParameter fNameParam = new SqlParameter("fName", Types.VARCHAR);
SqlParameter lNameParam = new SqlParameter("lName", Types.VARCHAR);
SqlOutParameter msgParam = new SqlOutParameter("msg", Types.VARCHAR);
SqlParameter[] paramArray = {fNameParam, lNameParam, msgParam};


myStoredProcedure.setParameters(paramArray);
myStoredProcedure.compile();


//Call stored procedure
Map storedProcResult = myStoredProcedure.execute("FirstNameValue", " LastNameValue");

Référence

De quoi aurait-elle l'air si j'avais un multi-ligne de renvoi de la procédure? Serait-il une Liste de Map<String, Object> objets?
Vous êtes correct. Il serait Liste<Map<String, Object>> pour plusieurs lignes.

InformationsquelleAutor Sairam Kukadala

En général, je préfère élargir le Printemps en fonction StoredProcedure de la classe à exécuter des procédures stockées.

Vous avez besoin pour créer votre constructeur de la classe et de la nécessité d'appeler StoredProcedure constructeur de la classe en elle. Cette super-classe constructeur accepte de source de données et le nom de la procédure.

Exemple de code:

public class ProcedureExecutor extends StoredProcedure {
      public ProcedureExecutor(DataSource ds, String funcNameorSPName) {
        super(ds, funcNameorSPName);
        declareParameter(new SqlOutParameter("v_Return", Types.VARCHAR, null, new SqlReturnType() {
                public Object getTypeValue(CallableStatement cs,
                     int paramIndex, int sqlType, String typeName) throws SQLException {
                final String str = cs.getString(paramIndex);
                return str;
            }           
        }));    
        declareParameter(new SqlParameter("your parameter",
                Types.VARCHAR));
        //set below param true if you want to call database function 
        setFunction(true);
        compile();
        }

Remplacer méthode execute de l'appel de procédure stockée comme ci-dessous

public Map<String, Object> execute(String someParams) {
             final Map<String, Object> inParams = new HashMap<String, Object>(8);
             inParams.put("my param", "some value");
             Map outMap = execute(inParams);
             System.out.println("outMap:" + outMap);
             return outMap;
         }

Espère que cela vous aide.

InformationsquelleAutor VivekDandale

1

Une façon de plus de faire appel de la procédure stockée est:
```
sql="execute Procedure_Name ?";
Object search[]={Id};
List<ClientInvestigateDTO> client=jdbcTemplateObject.query(sql,search,new 
   ClientInvestigateMapper());
```
Dans cet exemple 'ClientInvestigateDTO' est la classe POJO et "ClientInvestigateMapper' est le mappeur de classe.'client' stocke le résultat que vous obtenez sur l'appel de la procédure stockée.

InformationsquelleAutor Aditee

Vous devez vous connecter pour publier un commentaire.