Comment appeler Oracle de la fonction ou de la procédure stockée à l'aide de printemps persistance cadre?

Je suis à l'aide de Printemps persistance cadre de mon projet.
Je veux l'appeler oracle de la fonction ou de la procédure stockée à partir de ce cadre.

Quelqu'un peut-il suggérer comment puis-je y parvenir.

Veuillez donner une solution pour à la fois: * oracle de la fonction et de la *procédure stockée.

Grâce.

Le printemps est une infrastructure de persistance? Êtes-vous référant au Printemps JdbcTemplate? Ou Mise En Veille Prolongée?
J'ai utilisé DPTK pour créer la persistance du cadre et du Ressort de la requête de l'usine. Maintenant voulez l'appeler oracle de la fonction ou de la procédure stockée à l'aide de la fonctionnalité existante, u peut m'aider à trier ce..
DPTK semble être un produit d'IBM: alphaworks.ibm.com/tech/dptk
Je ne comprends pas le rapport à junit. Pourriez-vous fournir cette information?

OriginalL'auteur | 2009-05-14

  1. 33

    En supposant que vous faites référence à JdbcTemplate:

    jdbcTemplate.execute(
    new CallableStatementCreator() {
        public CallableStatement createCallableStatement(Connection con) throws SQLException{
            CallableStatement cs = con.prepareCall("{call MY_STORED_PROCEDURE(?, ?, ?)}");
            cs.setInt(1, ...); // first argument
            cs.setInt(2, ...); // second argument
            cs.setInt(3, ...); // third argument
            return cs;
        }
    },
    new CallableStatementCallback() {
        public Object doInCallableStatement(CallableStatement cs) throws SQLException{
            cs.execute();
            return null; // Whatever is returned here is returned from the jdbcTemplate.execute method
        }
    }
);

    L'appel d'une fonction est presque identique:

    jdbcTemplate.execute(
    new CallableStatementCreator() {
        public CallableStatement createCallableStatement(Connection con) {
            CallableStatement cs = con.prepareCall("{? = call MY_FUNCTION(?, ?, ?)}");
            cs.registerOutParameter(1, Types.INTEGER); // or whatever type your function returns.
            // Set your arguments
            cs.setInt(2, ...); // first argument
            cs.setInt(3, ...); // second argument
            cs.setInt(4, ...); // third argument
            return cs;
        }
    },
    new CallableStatementCallback {
        public Object doInCallableStatement(CallableStatement cs) {
            cs.execute();
            int result = cs.getInt(1);
            return result; // Whatever is returned here is returned from the jdbcTemplate.execute method
        }
    }
);
    ici, nous appelons SP, comment peut-on appeler Oracle de la Fonction...je ne suis pas en se référant à JdbcTemplate, je suis se rapportant à la persistance cadre à l'aide d'DPTK..
    Le deuxième exemple est l'appel d'une fonction. Malheureusement, je ne suis pas familier avec DPTK. A-t-elle un site web?
    ok, je vais essayer de mettre en œuvre des ce avec mon code...espère que cela va fonctionner..Merci Adam, vous permettra de connaître le résultat..
    Vous n'avez pas à utiliser ce. Je ne savais pas ce que le Printemps de la persistance cadre de a été. C'était juste ma meilleure supposition.
    DPTK(Conception Patter Tool Kit) est un RAD plug-in, malheureusement je n'ai pas de site web dès maintenant, une fois que vous, je vais vous l'envoyer..

    OriginalL'auteur Adam Paynter

  2. 18

    Moyen plus simple d'appeler un Oracle fonction du Printemps est la sous-classement StoredProcedure comme ci-dessous

    public class MyStoredProcedure extends StoredProcedure{
    private static final String SQL = "package.function";

    public MyStoredProcedure(DataSource ds){
        super(ds,SQL);
        declareParameter(new SqlOutParameter("param_out",Types.NUMERIC));
        declareParameter(new SqlParameter("param_in",Types.NUMERIC));
        setFunction(true);//you must set this as it distinguishes it from a sproc
        compile();
    }

    public String execute(Long rdsId){
        Map in = new HashMap();
        in.put("param_in",rdsId);
        Map out = execute(in);
        if(!out.isEmpty())
            return out.get("param_out").toString();
        else
            return null;
    }
}

    Et de l'appeler comme ça

    @Autowired DataSource ds;
MyStoredProcedure sp = new MyStoredProcedure(ds);
String i = sp.execute(1l);

    L'Oracle de la fonction utilisée ici, tout prend un paramètre numérique et renvoie un paramètre numérique.

    comme je comprends le code SQL devrait ressembler à: {:param_out = call schema.package.MY_FUNCTION(:param_in)}
    mon dernier commentaire est faux. le SQL de la constante a, ne contiennent que la procédure/fonction nom, comme schema.package.MY_FUNCTION, et les noms des paramètres en Java pour faire correspondre les noms des paramètres, tels que définis dans la procédure/fonction.

    OriginalL'auteur

  3. 0

    À mon avis c'est l'un des plus faciles d'approches: 

    public class ServRepository {

    private JdbcTemplate jdbcTemplate;
    private SimpleJdbcCall functionGetServerErrors;

    @Autowired
    public void setDataSource(DataSource dataSource) {
        this.jdbcTemplate = new JdbcTemplate(dataSource);
        JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
        jdbcTemplate.setResultsMapCaseInsensitive(true);
        this.functionGetServerErrors = new SimpleJdbcCall(jdbcTemplate).withFunctionName("THIS_IS_YOUR_DB_FUNCTION_NAME").withSchemaName("OPTIONAL_SCHEMA_NAME");
    }

        public String callYourFunction(int parameterOne, int parameterTwo) {
            SqlParameterSource in = new MapSqlParameterSource().addValue("DB_FUNCTION_INCOMING_PARAMETER_ONE", parameterOne).addValue("DB_FUNCTION_INCOMING_PARAMETER_TWO", parameterTwo);
            return functionGetServerErrors.executeFunction(String.class, in);
        }
}

    OriginalL'auteur Deniss M.