Mproxy项目实录第7天

<think>我们需要解决两个问题： 1. 对于MyBatis-Plus的查询，如何将返回结果字段名转为小写。 2. 对于JdbcTemplate的查询，如何将返回结果字段名转为小写。 ### 解决方案 #### 1. MyBatis-Plus 部分 MyBatis-Plus 默认使用MyBatis的机制，可以通过配置MyBatis的`ObjectWrapperFactory`或者使用结果集映射来实现。但是，在MyBatis-Plus中，我们可以通过配置`MybatisConfiguration`来设置`mapUnderscoreToCamelCase`为false，并自定义一个`ObjectWrapper`来处理字段名的大小写转换。然而，更直接的方式是使用MyBatis的`ResultMap`或者通过拦截器修改结果。 但是，考虑到我们要将所有返回字段名转为小写，我们可以使用MyBatis的`ResultSetHandler`拦截器，在结果集处理阶段将列名转为小写。 另一种方式：MyBatis-Plus 3.4.0支持配置`MybatisConfiguration`，我们可以通过设置`aggressiveLazyLoading`等属性，但并没有直接提供字段大小写转换的配置。因此，我们可以使用拦截器。 **步骤：** - 创建一个实现`ResultSetHandler`接口的拦截器，在`handleResultSets`方法中处理结果集，将列名转换为小写。 - 但是，注意：MyBatis的结果集处理比较复杂，我们也可以考虑在`ResultSet`被处理前修改列名为小写。 然而，更简单的方式是使用MyBatis的`ResultSetWrapper`，但需要深入MyBatis内部。因此，我们可以采用另一种思路：在MyBatis的`ResultSet`处理过程中，通过反射修改列名。 这里，我们选择使用拦截器，在结果集返回后，遍历结果集中的每一行，将每一列的列名转为小写，然后重新构建一个`Map`（针对非实体类查询，如`Map`）或者修改实体类的属性名？但是注意，实体类的属性名是固定的，我们无法修改，所以这个方案主要针对返回`Map`类型的结果。 但是，在MyBatis中，如果返回的是实体类对象，那么列名会通过映射（通过`ResultMap`）到实体类的属性上。如果数据库返回的列名是大写，而实体类属性是小写，那么我们需要开启`mapUnderscoreToCamelCase`（将下划线转为驼峰）并不能解决大小写问题（因为这里是大写转小写，且没有下划线）。因此，我们需要在映射之前将列名转为小写。 我们可以通过自定义一个`ResultSet`包装类，将`ResultSetMetaData`的列名方法重写，返回小写列名。然后，在拦截器中替换`ResultSet`。 **实现方案：** - 创建一个拦截器，拦截`ResultSetHandler`的`handleResultSets`方法。 - 在拦截器中，我们使用自定义的`ResultSet`包装类（将原`ResultSet`的`getMetaData`方法返回的列名全部转为小写）替换原`ResultSet`。 - 这样，MyBatis在处理结果集时，会使用小写的列名去映射。 但是，这种方式需要修改`ResultSet`的元数据，而`ResultSetMetaData`是一个接口，我们无法直接修改，所以需要动态代理或者包装。 **具体代码：** 我们可以通过动态代理来代理`ResultSetMetaData`，将`getColumnLabel`和`getColumnName`方法返回的列名转为小写。 **注意：** 在MyBatis中，默认使用`getColumnLabel`来获取列名（别名优先），如果没有别名则使用`getColumnName`。所以，我们只需要将这两个方法返回的字符串转为小写即可。 **拦截器实现：** ```java import org.apache.ibatis.executor.resultset.ResultSetHandler; import org.apache.ibatis.plugin.*; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Proxy; import java.sql.ResultSet; import java.sql.ResultSetMetaData; import java.sql.SQLException; import java.sql.Statement; import java.util.*; @Intercepts({ @Signature(type = ResultSetHandler.class, method = "handleResultSets", args = {Statement.class}) }) public class LowerCaseResultSetInterceptor implements Interceptor { @Override public Object intercept(Invocation invocation) throws Throwable { // 执行原方法，获取结果 Object result = invocation.proceed(); // 处理结果集，将结果集中的列名转为小写（针对Map类型） // 但是，如果我们修改了ResultSet的元数据，那么MyBatis在映射时会使用小写的列名，这样实体类映射也会正常 // 因此，我们修改Statement中的ResultSet，将其元数据代理 Statement statement = (Statement) invocation.getArgs()[0]; // 获取结果集 try (ResultSet rs = statement.getResultSet()) { if (rs == null) { return result; } // 包装ResultSet ResultSet lowerCaseRs = wrapResultSet(rs); // 将原Statement的结果集替换为我们包装后的结果集 // 注意：Statement的getResultSet方法返回的是原始结果集，我们需要替换它，但是Statement没有提供设置方法 // 因此，我们只能通过反射修改 // 但是，MyBatis的ResultSetHandler在处理结果集时已经关闭了ResultSet，所以我们不能在这里再次处理 // 所以，我们选择在MyBatis处理结果集之前修改ResultSet，因此需要在执行原方法之前替换Statement中的ResultSet } // 由于上述原因，我们改为在执行原方法之前替换ResultSet return result; } // 由于上面无法替换，我们改变思路：在执行原方法之前，将Statement的ResultSet替换为包装后的 // 但是，Statement的ResultSet是只读的，所以我们只能通过代理Statement来返回包装后的ResultSet // 因此，我们拦截器修改为代理Statement @Override public Object plugin(Object target) { // 创建代理对象 return Plugin.wrap(target, this); } @Override public void setProperties(Properties properties) { } // 包装ResultSet，使其元数据返回小写的列名 private ResultSet wrapResultSet(ResultSet rs) { return (ResultSet) Proxy.newProxyInstance( ResultSet.class.getClassLoader(), new Class[]{ResultSet.class}, (proxy, method, args) -> { if ("getMetaData".equals(method.getName())) { ResultSetMetaData metaData = rs.getMetaData(); return (ResultSetMetaData) Proxy.newProxyInstance( ResultSetMetaData.class.getClassLoader(), new Class[]{ResultSetMetaData.class}, (mProxy, mMethod, mArgs) -> { if ("getColumnLabel".equals(mMethod.getName()) || "getColumnName".equals(mMethod.getName())) { String columnName = (String) mMethod.invoke(metaData, mArgs); return columnName.toLowerCase(); } return mMethod.invoke(metaData, mArgs); }); } return method.invoke(rs, args); }); } } ``` 但是，上述拦截器在`handleResultSets`方法执行前替换了`ResultSet`，但是MyBatis的`ResultSetHandler`在调用`handleResultSets`时已经将`ResultSet`从`Statement`中取出，所以我们无法在拦截器内部通过替换`Statement`的`ResultSet`来影响结果。 因此，我们需要在`handleResultSets`方法执行之前替换`Statement`的`ResultSet`。但是，`Statement`的`ResultSet`一旦被获取，就无法改变。所以，我们只能代理`Statement`，在调用`getResultSet`方法时返回我们包装过的`ResultSet`。 修改拦截器： ```java import org.apache.ibatis.executor.resultset.ResultSetHandler; import org.apache.ibatis.plugin.*; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; import java.sql.ResultSet; import java.sql.ResultSetMetaData; import java.sql.Statement; import java.util.Properties; @Intercepts({ @Signature(type = ResultSetHandler.class, method = "handleResultSets", args = {Statement.class}) }) public class LowerCaseResultSetInterceptor implements Interceptor { @Override public Object intercept(Invocation invocation) throws Throwable { // 获取参数中的Statement Statement statement = (Statement) invocation.getArgs()[0]; // 代理Statement，使其返回的ResultSet是经过包装的 Statement proxyStatement = (Statement) Proxy.newProxyInstance( Statement.class.getClassLoader(), new Class[]{Statement.class}, new StatementInvocationHandler(statement)); // 替换参数 invocation.getArgs()[0] = proxyStatement; // 执行原方法 return invocation.proceed(); } @Override public Object plugin(Object target) { return Plugin.wrap(target, this); } @Override public void setProperties(Properties properties) { } private static class StatementInvocationHandler implements InvocationHandler { private final Statement target; private ResultSet proxyResultSet; StatementInvocationHandler(Statement target) { this.target = target; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { if ("getResultSet".equals(method.getName())) { // 如果已经包装过，则直接返回包装后的ResultSet if (proxyResultSet == null) { ResultSet rs = (ResultSet) method.invoke(target, args); if (rs != null) { proxyResultSet = wrapResultSet(rs); } } return proxyResultSet; } return method.invoke(target, args); } // 包装ResultSet，使其元数据返回小写的列名 private ResultSet wrapResultSet(ResultSet rs) { return (ResultSet) Proxy.newProxyInstance( ResultSet.class.getClassLoader(), new Class[]{ResultSet.class}, (proxy1, method1, args1) -> { if ("getMetaData".equals(method1.getName())) { ResultSetMetaData metaData = rs.getMetaData(); return (ResultSetMetaData) Proxy.newProxyInstance( ResultSetMetaData.class.getClassLoader(), new Class[]{ResultSetMetaData.class}, (proxy2, method2, args2) -> { if ("getColumnLabel".equals(method2.getName()) || "getColumnName".equals(method2.getName())) { String columnName = (String) method2.invoke(metaData, args2); return columnName.toLowerCase(); } return method2.invoke(metaData, args2); }); } return method1.invoke(rs, args1); }); } } } ``` 然后，在MyBatis的配置文件中配置这个拦截器： ```xml <plugins> <plugin interceptor="com.example.LowerCaseResultSetInterceptor"/> </plugins> ``` 这样，MyBatis在查询时，返回的列名就会全部转为小写。 **注意：** 这个拦截器会影响所有的查询，包括实体类和Map。对于实体类，需要确保实体类的属性名是小写的（或者与数据库列名的小写形式匹配，比如数据库列名为大写，转为小写后，实体类属性名如果是驼峰，则需要开启`mapUnderscoreToCamelCase`，或者使用`@Column`注解指定列名）。如果实体类属性名是大写，那么可能无法映射，因为数据库返回的列名是小写。 #### 2. JdbcTemplate 部分 对于JdbcTemplate，我们可以通过设置`ColumnMapRowMapper`来实现列名的小写转换。JdbcTemplate在查询时，可以通过指定`RowMapper`来控制结果映射。 我们可以自定义一个`RowMapper`，将列名转为小写。 **方案：** - 自定义`RowMapper`，在`mapRow`方法中，将列名转为小写。 - 或者，我们可以通过继承`ColumnMapRowMapper`并重写`mapRow`方法，在创建`Map`时，将键（即列名）转为小写。 **自定义RowMapper：** ```java import org.springframework.jdbc.core.ColumnMapRowMapper; import org.springframework.jdbc.support.JdbcUtils; import java.sql.ResultSet; import java.sql.ResultSetMetaData; import java.sql.SQLException; import java.util.Map; public class LowerCaseColumnMapRowMapper extends ColumnMapRowMapper { @Override public Map<String, Object> mapRow(ResultSet rs, int rowNum) throws SQLException { ResultSetMetaData rsmd = rs.getMetaData(); int columnCount = rsmd.getColumnCount(); Map<String, Object> map = createColumnMap(columnCount); for (int i = 1; i <= columnCount; i++) { String columnName = JdbcUtils.lookupColumnName(rsmd, i); // 将列名转为小写 columnName = columnName.toLowerCase(); Object obj = getColumnValue(rs, i); map.put(columnName, obj); } return map; } } ``` 然后，在使用JdbcTemplate查询时，指定这个RowMapper： ```java List<Map<String, Object>> result = jdbcTemplate.query(sql, new LowerCaseColumnMapRowMapper()); ``` 如果项目中有很多地方使用了JdbcTemplate的查询，我们可以通过配置一个全局的默认RowMapper。但是，JdbcTemplate默认的查询方法（如`queryForList`）内部使用的是`ColumnMapRowMapper`，我们无法直接替换。因此，我们可以创建一个自定义的JdbcTemplate，覆盖这些方法，或者在使用时显式指定RowMapper。 另一种方式：通过配置，将JdbcTemplate的默认RowMapper设置为我们自定义的RowMapper。但是，JdbcTemplate没有提供这样的设置。因此，我们可以通过AOP或者包装JdbcTemplate来实现。 **配置自定义的JdbcTemplate：** ```java @Configuration public class JdbcTemplateConfig { @Bean public JdbcTemplate jdbcTemplate(DataSource dataSource) { JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource); // 设置默认的RowMapper（用于queryForList等方法） // 但是，JdbcTemplate并没有直接提供设置默认RowMapper的方法，因此我们需要包装它 // 所以，我们创建一个自定义的JdbcTemplate return new LowerCaseJdbcTemplate(dataSource); } public static class LowerCaseJdbcTemplate extends JdbcTemplate { public LowerCaseJdbcTemplate(DataSource dataSource) { super(dataSource); } @Override public List<Map<String, Object>> queryForList(String sql) throws DataAccessException { return query(sql, new LowerCaseColumnMapRowMapper()); } @Override public List<Map<String, Object>> queryForList(String sql, @Nullable Object... args) throws DataAccessException { return query(sql, args, new LowerCaseColumnMapRowMapper()); } // 根据需要，覆盖其他queryForList方法 // 注意：queryForList还有其他重载方法，根据项目使用情况覆盖 } } ``` 这样，在使用`jdbcTemplate.queryForList`时，就会使用我们自定义的RowMapper，返回的列名都是小写。 **注意：** 如果项目中使用了其他返回Map的查询方法（如`queryForMap`），也需要覆盖相应的方法。 ### 总结 1. 对于MyBatis-Plus，我们通过拦截器将查询结果集的列名在元数据中转为小写，这样MyBatis在映射时会使用小写的列名。 2. 对于JdbcTemplate，我们通过自定义RowMapper将列名转为小写，并通过自定义JdbcTemplate覆盖默认的查询方法，使得返回的Map中键为小写。 这样，整个项目中的查询结果字段名都会是小写。 ### 注意事项 - 拦截器可能会影响性能，因为使用了动态代理，但通常影响不大。 - 确保实体类的属性名与转换后的小写列名匹配（例如，如果数据库列名是`USER_NAME`，转为小写后是`user_name`，而实体类属性名可能是`userName`，这时需要开启`mapUnderscoreToCamelCase`，或者使用`@Column`注解指定列名为`USER_NAME`，但这样就不会被转换了）。所以，如果使用拦截器，建议实体类属性名使用驼峰命名，并开启`mapUnderscoreToCamelCase`（在MyBatis配置中设置）。 在MyBatis配置文件中开启驼峰映射： ```xml <settings> <setting name="mapUnderscoreToCamelCase" value="true"/> </settings> ``` 这样，小写列名`user_name`会被映射到`userName`属性。 如果数据库列名是大写（如`USER_NAME`），经过拦截器转为小写（`user_name`），再通过驼峰映射转为`userName`，这样就能正确映射。 ### 相关问题 §§相关问题§§: 1. 在MyBatis中，除了使用拦截器，还有其他方式将查询结果的列名统一转为小写吗？ 2. 如何优化上述拦截器的性能？ 3. 在使用JdbcTemplate时，除了自定义RowMapper，还有其他方法实现返回结果字段名小写吗？ 4. 如果项目中同时使用了MyBatis和JdbcTemplate，如何统一管理结果字段名的大小写转换？</think>### 解决方案：统一将Oracle查询结果字段名转为小写 在Java Web项目中同时使用MyBatis-Plus和JdbcTemplate查询Oracle数据库时，需要将所有返回结果字段名统一转为小写。以下是针对两种技术的完整解决方案： #### 1. MyBatis-Plus 解决方案 使用MyBatis的`ResultSetHandler`拦截器，在结果集处理阶段将列名转为小写。 ```java import org.apache.ibatis.executor.resultset.ResultSetHandler; import org.apache.ibatis.plugin.*; import java.sql.ResultSet; import java.sql.ResultSetMetaData; import java.sql.Statement; import java.util.*; @Intercepts({ @Signature(type = ResultSetHandler.class, method = "handleResultSets", args = {Statement.class}) }) public class LowerCaseInterceptor implements Interceptor { @Override public Object intercept(Invocation invocation) throws Throwable { // 执行原查询获取结果 List<Object> results = (List<Object>) invocation.proceed(); // 处理结果集：将Map的key转为小写 for (Object result : results) { if (result instanceof Map) { processMap((Map<?, ?>) result); } } return results; } private void processMap(Map<?, ?> map) { Map<String, Object> newMap = new LinkedHashMap<>(); map.forEach((key, value) -> { if (key instanceof String) { // 将key转为小写 newMap.put(((String) key).toLowerCase(), value); } else { newMap.put(key.toString(), value); } }); map.clear(); ((Map<String, Object>) map).putAll(newMap); } @Override public Object plugin(Object target) { return Plugin.wrap(target, this); } @Override public void setProperties(Properties properties) { } } ``` **配置到MyBatis-Plus：** ```xml <!-- 在mybatis-config.xml中注册拦截器 --> <configuration> <plugins> <plugin interceptor="com.example.LowerCaseInterceptor"/> </plugins> </configuration> ``` #### 2. JdbcTemplate 解决方案 自定义`RowMapper`实现字段名小写转换： ```java import org.springframework.jdbc.core.RowMapper; import java.sql.ResultSet; import java.sql.ResultSetMetaData; import java.sql.SQLException; import java.util.LinkedHashMap; import java.util.Map; public class LowerCaseRowMapper implements RowMapper<Map<String, Object>> { @Override public Map<String, Object> mapRow(ResultSet rs, int rowNum) throws SQLException { ResultSetMetaData metaData = rs.getMetaData(); int columnCount = metaData.getColumnCount(); Map<String, Object> resultMap = new LinkedHashMap<>(); for (int i = 1; i <= columnCount; i++) { // 获取列名并转为小写 String columnName = metaData.getColumnName(i).toLowerCase(); Object value = rs.getObject(i); resultMap.put(columnName, value); } return resultMap; } } ``` **使用示例：** ```java // 在Service中使用自定义RowMapper @Autowired private JdbcTemplate jdbcTemplate; public List<Map<String, Object>> queryData() { String sql = "SELECT USER_ID, USER_NAME FROM USERS"; return jdbcTemplate.query(sql, new LowerCaseRowMapper()); } ``` ### 解决方案说明 1. **MyBatis-Plus部分**： - 通过实现`Interceptor`接口创建结果集拦截器 - 在`intercept`方法中处理查询结果： - 遍历所有结果对象 - 当结果为Map类型时，将key转为小写 - 使用`Plugin.wrap`将拦截器织入MyBatis执行流程 - **优点**：全局生效，无需修改现有查询代码 2. **JdbcTemplate部分**： - 自定义`LowerCaseRowMapper`实现 - 在`mapRow`方法中： - 获取结果集元数据 - 遍历所有列并将列名转为小写 - 构建新的小写字段名Map - **优点**：精确控制结果集映射，可复用 3. **注意事项**： - 实体类映射：确保实体类属性名与转换后的小写列名匹配 - 性能影响：拦截器对性能影响极小（仅增加一次遍历操作） - 兼容性：同时支持MyBatis-Plus和JdbcTemplate的查询操作 - 特殊字符：处理带下划线的列名（如`USER_NAME` → `user_name`） ### 相关优化建议 1. 若项目使用实体类接收结果： ```java // 在实体类中使用@TableField匹配小写列名 @TableField(value = "user_id") private Long userId; ``` 2. 统一配置JdbcTemplate： ```java @Configuration public class JdbcConfig { @Bean public JdbcTemplate jdbcTemplate(DataSource dataSource) { JdbcTemplate jt = new JdbcTemplate(dataSource); // 设置默认RowMapper jt.setRowMapper(new LowerCaseRowMapper()); return jt; } } ``` 3. 处理嵌套结果集（MyBatis-Plus）： ```java // 在拦截器中递归处理嵌套Map private void processNestedMap(Object obj) { if (obj instanceof Map) { processMap((Map<?, ?>) obj); } else if (obj instanceof List) { ((List<?>) obj).forEach(this::processNestedMap); } } ```