Spring / Hibernate-在Java中不使用@Entity的情況下從存儲過程獲取結果

Question

我們在MS SQL中有一個存儲過程，該存儲過程返回的結果集與任何數據庫表都不匹配。 而且我們希望將結果映射到純Java POJO，而不使用@Entity批注。 但是如果我們打電話

entityManager.createStoredProcedureQuery("schema.myProcedure",
                        PlainPojo.class);

對於org.hibernate.MappingException: Unknown entity它將失敗org.hibernate.MappingException: Unknown entity異常

我知道有@SqlResultSetMapping批注，但需要將其放在Entity類上嗎？ 這不起作用

@Repository
@SqlResultSetMapping(name = "Mapping")
public class MyRepositoryImpl implements MyRepository

只有這個

@Enity
@SqlResultSetMapping(name = "Mapping")
public class MyEntity

但我們不希望為此使用實體類...因此將其放置在另一個實體上？ （不完全是）

• 有可能將其放置在其他地方嗎？

• 還是有可能在代碼中做到？

  另一個解決方案？

• 是否可以制作類似瞬態實體的東西？ ->使用@Entity注釋而不創建數據庫表等

Answer 1

我沒有找到關於stackoverflow的復雜解決方案，並且 重新發明了輪子， 也許這對於某些需要在項目中多次調用存儲過程的人有幫助。

主要思想是編寫類似於@StoredProcedure的自定義批注，但獨立於@Entity

@Target(TYPE)
@Retention(RUNTIME)
public @interface CustomNamedStoredProcedureQueries {
     /**
     * Array of CustomNamedStoredProcedureQuery annotations.
     */
     CustomNamedStoredProcedureQuery[] value();
}
@Target(TYPE)
@Retention(RUNTIME)
public @interface CustomNamedStoredProcedureQuery {
    /*
    * The name of the stored procedure for call.
    */
    String name();
    /*
    * The name of the stored procedure in the database.
    */
    String procedureName();
    /*
    * The scheme name of the database.
    */
    String schemeName();
    /*
    * The name of the package that contains stored procedure in the database.
    */
    String packageName();
    /*
    * Information about all parameters of the stored procedure.
    */
    CustomStoredProcedureParameter[] parameters() default {};
    /*
    * The names of one or more result set mappings, as defined in metadata, when you need custom mapping.
    */
    ProcedureRowMapper[] resultSetRowMappers() default {};
    /*
    * The names of one or more result set mappings, as defined in metadata, when you need 1 to 1 mapping.
    */
    ProcedureResultClass[] resultSetMappers() default {};
}
@Target({})
@Retention(RUNTIME)
public @interface CustomStoredProcedureParameter {
    /** Name of strored procedure parameter.*/
    String name() default "";
    /** JDBC type of the parameter.*/
    int type();
    /** Parameter mode.*/
    ParameterMode mode() default ParameterMode.IN;
}
@Target({})
@Retention(RUNTIME)
public @interface ProcedureResultClass {
    /* Name of procedure parameter*/
    String name();
    /* Class of object using for mapping */
    Class<?> resultClass();
}
@Target({})
@Retention(RUNTIME)
public @interface ProcedureRowMapper {
    /* Name of cursor field for use mapper*/
    String name();
    /* Class of object using for mapping, must extend BeanPropertyRowMapper */
    Class<? extends BeanPropertyRowMapper> mapper();
}

如前所述，當您需要將resultSet 1映射到1時，請使用ProcedureResultClass ，字段必須具有相同的名稱。

當你需要一些自定義映射使用ProcedureRowMapper，你可以@Override mapRow（）方法，並手動映射，或者你可以@Override initBeanWrapper（），如果你只需要一些字段轉換的具體方式。

因此，接下來我們需要一種使其起作用的方法。 將其放在應用程序的init方法中，例如main方法的@PostConstruct 。

ProjectUtils {
    private JdbcTemplate jdbcTemplate;

    @Autowired
    public ProjectUtils(DataSource dataSource) {
        jdbcTemplate = new JdbcTemplate(DataSource);
    }

    private static Map<String, SimpleJdbcCall> storedProcedureContainer = new HashMap<>();


    public void initStoredProcedure() {
        Reflections reflections = new Reflections("my.package");
        Set<Class<?>> classList = reflections.getTypesAnnotatedWith(CustomNamedStoredProcedureQueries.class);

        for (Class<?> clazz : classList) {
            CustomNamedStoredProcedureQueries queriesAnnotation = clazz.getAnnotation(CustomNamedStoredProcedureQueries.class);

            for (CustomNamedStoredProcedureQuery queryAnnotation : queriesAnnotation.value()) {
                SimpleJdbcCall jdbcCall = new SimpleJdbcCall(jdbcTemplate)
                        .withSchemaName(queryAnnotation.schemeName())
                        .withCatalogName(queryAnnotation.packageName())
                        .withProcedureName(queryAnnotation.procedureName());
                Set<SqlParameter> parameters = this.getDeclaredParameters(queryAnnotation.parameters());
                jdbcCall.declareParameters(parameters.toArray(new SqlParameter[0]));

                Map<String, RowMapper<?>> rowMappers = getDeclaredRowMappers(queryAnnotation.resultSetRowMappers(), queryAnnotation.resultSetMappers());
                 rowMappers.forEach((parameterName, rowMapper) -> jdbcCall.addDeclaredRowMapper(parameterName, rowMapper));

                jdbcCall.compile();

                storedProcedureContainer.put(queryAnnotation.name(), jdbcCall);
            }
        }
    }

    private Set<SqlParameter> getDeclaredParameters(CustomStoredProcedureParameter[] procedureParameters) {
        Set<SqlParameter> parameters = new HashSet<>();
        for (CustomStoredProcedureParameter procedureParameter : procedureParameters) {
            if (procedureParameter.mode().equals(ParameterMode.IN)) {
                parameters.add(new SqlParameter(procedureParameter.name(), procedureParameter.type()));
            }
            if (procedureParameter.mode().equals(ParameterMode.OUT)) {
                parameters.add(new SqlOutParameter(procedureParameter.name(), procedureParameter.type()));
            }
        }
        return parameters;
    }

    private Map<String, RowMapper<?>> getDeclaredRowMappers(ProcedureRowMapper[] resultSetMappers, ProcedureResultClass[] simpleResultSetMappers) {
        Map<String, RowMapper<?>> mappers = new HashMap<>();
        if (!ArrayUtils.isEmpty(simpleResultSetMappers)) {
            for (ProcedureResultClass procedureResultClass : simpleResultSetMappers) {
                mappers.put(procedureResultClass.name(), BeanPropertyRowMapper.newInstance(procedureResultClass.resultClass()));
            }
            return mappers;
        }
        try {
            for (ProcedureRowMapper resultSetMapper : resultSetMappers) {
                mappers.put(resultSetMapper.name(), resultSetMapper.mapper().newInstance());
            }
        } catch (InstantiationException | IllegalAccessException e) {
            e.printStackTrace();
        }
        return mappers;
    }

    public SimpleJdbcCall getProcedure(String name) {
        return storedProcedureContainer.get(name);
    }
}

• 假設必須聲明@CustomNamedStoredProcedureQueries ，即使存儲過程只有一個，也可以根據需要自行更改。
• 您可以使用ProcedureResultClass或ProcedureRowMapper之一 ，但不能兩者都使用，可以將其更改為。

示例 （我使用oracledb，但稍作更改便可以用於另一個db）

@CustomNamedStoredProcedureQueries({
        @CustomNamedStoredProcedureQuery(
                name = "getFoo",
                schemeName = "FooScheme",
                packageName = "FooPackage",
                procedureName = "get_Foo",
                resultSetMappers = @ProcedureResultClass(name = "foo_cursor", resultClass = Foo.class),
                parameters = {
                        @CustomStoredProcedureParameter(name = "foo_id", type = OracleTypes.NUMBER, mode = ParameterMode.IN),
                        @CustomStoredProcedureParameter(name = "error_code", type = OracleTypes.NUMBER, mode = ParameterMode.OUT),
                        @CustomStoredProcedureParameter(name = "foo_cursor", type = OracleTypes.CURSOR, mode = ParameterMode.OUT),
                }
        ),
        @CustomNamedStoredProcedureQuery(
                name = "deleteFoo",
                schemeName = "FooScheme",
                packageName = "FooPackage",
                procedureName = "delete_Foo",
                parameters = {
                        @CustomStoredProcedureParameter(name = "foo_id", type = OracleTypes.NUMBER, mode = ParameterMode.IN),
                        @CustomStoredProcedureParameter(name = "error_code", type = OracleTypes.NUMBER, mode = ParameterMode.OUT),
                }
        )
})
public class Foo {
     long id;
     String name;
     int age;

     public void setId(long id) { 
       this.id= id;
     }
     public long getId() { 
       return this.id;
     }

     public void setName(String name) { 
       this.name = name;
     }
     public String getName() { 
       return this.name;
     }

     public void setAge(int age) { 
       this.age = age;
     }
     public int getAge() { 
       return this.age;
     }
}

稱它為：

public Foo getFoo(Long fooId) {
        SqlParameterSource sqlParams = new MapSqlParameterSource()
                .addValue("foo_id", fooId);
        SimpleJdbcCall procedure = projectUtils.getProcedure("getFoo");
        Map<String, Object> result = procedure.execute(sqlParams);
        return ((List<Foo>) result.get("foo_cursor")).get(0);
    }

提示 -可以將其與自定義類型（存儲在bd中的類型）一起使用，例如Array ，因為您需要創建自定義類型的AbstractSqlTypeValue擴展並覆蓋createTypeValue（） ，然后像其他參數一樣傳遞它（ 僅在oracle上經過仔細測試 ）。

必須在方案級別和更高級別上聲明CustomType，在程序包級別上聲明它不起作用，必須以大寫形式調用方案和類型。

    @Override
    protected Object createTypeValue(Connection connection, int sqlType, String typeName) throws SQLException {
        if (connection.isWrapperFor(OracleConnection.class)) {
            OracleConnection oracleConnection = connection.unwrap(OracleConnection.class);
            return oracleConnection.createARRAY("FOOSCHEME.NUMBERARRAY", this.array); // array pass when customType class init
        }
        return connection.createArrayOf("FOOSCHEME.NUMBERARRAY", this.array);
    }