Frühjahr SimpleJdbcCall Standard (optionale) Argumente

Ater geben auf diese Frage, und nur auf der Durchreise alle Parameter, einschließlich der optionalen, ich lief in seine Unfähigkeit zu übergeben boolean Argumente, weil boolean ist nicht ein SQL-Datentyp, nur PL/SQL.

Also meine aktuelle Lösung ist, dass JDBC nicht geeignet für gespeicherte Prozeduren ausgeführt werden und dies ist, wie ich arbeite um ihn herum:

  jdbcTemplate.execute(
        new CallableStatementCreator() {
           public CallableStatement createCallableStatement(Connection con) throws SQLException{
              CallableStatement cs = con.prepareCall("{call sys.dbms_stats.gather_table_stats(ownname=>user, tabname=>'" + cachedMetadataTableName + "', estimate_percent=>20, method_opt=>'FOR ALL COLUMNS SIZE 1', degree=>0, granularity=>'AUTO', cascade=>TRUE, no_invalidate=>FALSE, force=>FALSE) }");
              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
           }
        }
  );

Hier ist ein anderer Ansatz, den ich genommen habe. Ich fügte hinzu, die Möglichkeit für den Benutzer, um die Anzahl der Parameter, die Sie erbringen auf der nennen. Diese werden die ersten n-Anzahl der Parameter. Alle verbleibenden Parameter, die in der stored-proc, festgelegt werden, über die Datenbank den Standardwert Handhabung. Dadurch können neue Parameter Hinzugefügt werden, um das Ende der Liste mit Standard-Werten oder null sein kann, ohne zu brechen code, der nicht weiß, geben Sie einen Wert ein.

Ich untergeordnetes SimpleJdbcCall und fügte hinzu, die Methoden zum setzen der "maxParamCount". Ich habe auch ein bisschen eine böse Reflexion auf meine untergeordnetes version von CallMetaDataContext.

public class MySimpleJdbcCall extends SimpleJdbcCall
{
    private final MyCallMetaDataContext callMetaDataContext = new MyCallMetaDataContext();

    public MySimpleJdbcCall(DataSource dataSource)
    {
        this(new JdbcTemplate(dataSource));
    }

    public MySimpleJdbcCall(JdbcTemplate jdbcTemplate)
    {
        super(jdbcTemplate);

        try
        {
            //Access private field
            Field callMetaDataContextField = AbstractJdbcCall.class.getDeclaredField("callMetaDataContext");
            callMetaDataContextField.setAccessible(true);

            //Make it non-final
            Field modifiersField = Field.class.getDeclaredField("modifiers");
            modifiersField.setAccessible(true);
            modifiersField.setInt(callMetaDataContextField, callMetaDataContextField.getModifiers() & ~Modifier.FINAL);

            //Set field
            callMetaDataContextField.set(this, this.callMetaDataContext);
        }
        catch (NoSuchFieldException | IllegalAccessException ex)
        {
            throw new RuntimeException("Exception thrown overriding AbstractJdbcCall.callMetaDataContext field", ex);
        }
    }

    public MySimpleJdbcCall withMaxParamCount(int maxInParamCount)
    {
        setMaxParamCount(maxInParamCount);
        return this;
    }

    public int getMaxParamCount()
    {
        return this.callMetaDataContext.getMaxParamCount();
    }

    public void setMaxParamCount(int maxInParamCount)
    {
        this.callMetaDataContext.setMaxParamCount(maxInParamCount);
    }
}

In meinem CallMetaDataContext sub-Klasse, ich Speichere die maxInParamCount, und verwenden Sie es trimmen, um die Liste der Parameter bekannt, gibt es in der stored-proc.

public class MyCallMetaDataContext extends CallMetaDataContext
{
    private int maxParamCount = Integer.MAX_VALUE;

    public int getMaxParamCount()
    {
        return maxParamCount;
    }

    public void setMaxParamCount(int maxInParamCount)
    {
        this.maxParamCount = maxInParamCount;
    }

    @Override
    protected List<SqlParameter> reconcileParameters(List<SqlParameter> parameters)
    {
        List<SqlParameter> limittedParams = new ArrayList<>();
        int paramCount = 0;
        for(SqlParameter param : super.reconcileParameters(parameters))
        {
            if (!param.isResultsParameter())
            {
                paramCount++;
                if (paramCount > this.maxParamCount)
                    continue;
            }

            limittedParams.add(param);
        }
        return limittedParams;
    }
}

Verwenden, ist im Grunde das gleiche, außer für seeting der max parameter count.

SimpleJdbcCall call = new MySimpleJdbcCall(jdbcTemplate)
        .withMaxParamCount(3)
        .withProcedureName("MayProc");

KLEINER RANT: Es ist lustig, dass der Frühling ist bekannt für seine IOC-container. Aber innerhalb seiner utility-Klassen, die ich zu dem Mittel greifen müssen, um Reflexion, um eine Alternative Implementierung einer abhängigen Klasse.

Ich diese util-Methode:

public <T> void setOptionalParameter(MapSqlParameterSource parameters, String name, T value) {
    if (value == null)
        parameters.addValue(name, value, Types.NULL);
    else
        parameters.addValue(name, value);
}