一、实现原理
参考文档
- Using table-valued parameters
- System requirements for the JDBC driver
- Microsoft JDBC Driver for SQL Server
1、微软官方封装了 JDBC 驱动 jar 包，提供 SQLServerDataTable 类；
2、Mybatis 官方提供自定义类型处理接口 TypeHandler ，可实现自定义类型与参数的绑定关系；
3、通过实现 Collection 类装载数据记录，如定义 List<User> users 来装载 User 表中的记录，那么 users 相当于一张中间表；
4、在实现 TypeHandler 接口时，对 mapper.xml 中 SQL 模板的参数进行赋值，此处可以注入 SQLServerDataTable 类作为执行参数；
5、在 mapper.xml 中的 SP 语句指定第 N 个参数处理器为自定义的 TypeHandler ，在 mybatis 解析 SQL 模板时不再使用基础类型处理器 BaseTypeHandler ，否则会抛出 UNKNOW 异常。
二、开发环境
- java 1.8
- docker mcr.mocrosoft.com/mssql/server:2019-latest
三、Pom 依赖
主要添加 Spring MVC、Mybatis、JDBC、Jackson 依赖
<!-- https://mvnrepository.com/artifact/com.microsoft.sqlserver/mssql-jdbc -->
<dependency>
<groupId>com.microsoft.sqlserver</groupId>
<artifactId>mssql-jdbc</artifactId>
<version>6.2.0.jre8</version>
</dependency>
<!-- java.time.LocalDateTime 支持，并在 mapper 中启用-->
<dependency>
<groupId>com.fasterxml.jackson.datatype</groupId>
<artifactId>jackson-datatype-jsr310</artifactId>
<version>2.13.0</version>
</dependency>
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>2.2.2</version>
</dependency>
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus</artifactId>
<version>3.4.3.1</version>
</dependency>
<!-- sqlserver -->
<dependency>
<groupId>com.microsoft.sqlserver</groupId>
<artifactId>sqljdbc4</artifactId>
<version>4.0</version>
</dependency>
<!-- 注解 -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>
<!-- jackson 2 databind -->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.13.3</version>
</dependency>
<!-- jackson 2 core -->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-core</artifactId>
<version>2.13.3</version>
</dependency>
<!-- jackson 2 annotations -->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-annotations</artifactId>
<version>2.13.3</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>四、Yml 配置
配置数据源和 mybatis 映射
spring:
datasource:
url: jdbc:sqlserver://127.0.0.1:1434;DatabaseName=TestDB
username: root
password: root
driver-class-name: com.microsoft.sqlserver.jdbc.SQLServerDriver
mybatis:
mapper-locations: classpath:mapper/*.xml五、自定义 Type
CREATE TYPE [dbo].[MyTableType] AS TABLE(
[MyKey] [VARCHAR](50) NOT NULL,
[MyValue] [VARCHAR](50) NOT NULL
)六、自定义存储过程
SET QUOTED_IDENTIFIER ON
SET ANSI_NULLS ON
GO
CREATE PROCEDURE [dbo].[MybatisTestPro]
@MyTable MyTableType READONLY,
@Code varchar(10) OUT,
@Msg varchar(10) OUT
AS
SET NOCOUNT ON;
SELECT MyKey,MyValue FROM @MyTable
SELECT @Code = '200', @Msg = 'Success'
GO七、Xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.example.demo.dao.TestDao">
<resultMap id="Map1" type="java.util.HashMap">
</resultMap>
<select id="proTest" resultType="java.util.List" resultMap="Map1" parameterType="Map" statementType="CALLABLE">
{CALL MyBatisTestPro(#{MyTable,mode=IN,jdbcType=OTHER,typeHandler=com.example.demo.utils.MyTableTypeHandler},
#{Code,mode=OUT,jdbcType=VARCHAR}, #{Msg,mode=OUT,jdbcType=VARCHAR})}
</select>
</mapper>八、TestDao
package com.example.demo.dao;
import org.apache.ibatis.annotations.Mapper;
import java.util.List;
import java.util.Map;
@Mapper
public interface TestDao {
List<Map<String,Object>> proTest(Map<String,Object> map);
}
九、Implement TypeHandler
package com.example.demo.utils;
import org.apache.ibatis.type.JdbcType;
import org.apache.ibatis.type.MappedJdbcTypes;
import org.apache.ibatis.type.MappedTypes;
import org.apache.ibatis.type.TypeHandler;
import java.sql.CallableStatement;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
/**
* 实现处理器：表变量传参
* <p>
* 不需要实现 get 方法，返回的结果集就是表数据
*/
@MappedJdbcTypes({JdbcType.OTHER}) // 对应数据库类型
@MappedTypes({ArrayList.class}) // java 数据类型
public class MyTableTypeHandler implements TypeHandler<ArrayList<?>> {
@Override
public void setParameter(PreparedStatement ps, int i, ArrayList<?> parameter, JdbcType jdbcType) throws SQLException {
ps.setObject(i, SQLServerDataTableFactory.getSqlServerDataTableInstance(parameter));
}
@Override
public ArrayList<?> getResult(ResultSet rs, String columnName) throws SQLException {
return null;
}
@Override
public ArrayList<?> getResult(ResultSet rs, int columnIndex) throws SQLException {
return null;
}
@Override
public ArrayList<?> getResult(CallableStatement cs, int columnIndex) throws SQLException {
return null;
}
}十、SQLServerDataTableFactory
package com.example.demo.utils;
import com.example.demo.data.MyTable;
import com.microsoft.sqlserver.jdbc.SQLServerDataTable;
import com.microsoft.sqlserver.jdbc.SQLServerException;
import java.sql.Types;
import java.util.ArrayList;
/**
* SQL 表值参数工厂
*
*/
public class SQLServerDataTableFactory {
private final static String DOT_SPLIT = "\\.";
private final static String MY_TABLE = "MyTable";
private final static String MY_DATA_FIELD_KEY = "MyKey";
private final static String MY_DATA_FIELD_VALUE = "MyValue";
/**
* 返回临时表实例
*
* @param dataList 泛型对象数组
* @return SQLServerDataTable
* @throws SQLServerException SQL 异常
*/
public static SQLServerDataTable getSqlServerDataTableInstance(ArrayList<?> dataList) throws SQLServerException {
if (dataList != null && dataList.size() > 0) {
String className = dataList.get(0).getClass().getName();
String[] split = className.split(DOT_SPLIT);
className = split[split.length - 1];
switch (className) {
case MY_TABLE: {
return getMyTableInstance(dataList);
}
default: {
return null;
}
}
}
return null;
}
/**
* 返回 MyData 类型的临时表
*
* @param dataList 泛型对象数组
* @return SQLServerException
* @throws SQLServerException SQL 异常
*/
private static SQLServerDataTable getMyTableInstance(ArrayList<?> dataList) throws SQLServerException {
// 定义临时表
SQLServerDataTable serverDataTable = new SQLServerDataTable();
serverDataTable.addColumnMetadata(MY_DATA_FIELD_KEY, Types.VARCHAR);
serverDataTable.addColumnMetadata(MY_DATA_FIELD_VALUE, Types.VARCHAR);
// 使用并行流往表中写入数据
dataList.stream().parallel().forEach(
p -> {
MyTable data = (MyTable) p;
try {
serverDataTable.addRow(data.getMyKey(), data.getMyValue());
} catch (SQLServerException e) {
e.printStackTrace();
}
}
);
// 返回临时表
return serverDataTable;
}
}
十一、MyTable
package com.example.demo.data;
import lombok.Data;
/**
* 自定义数据类型
*
* @author Jiansheng Ma
* @since 2022/11/17 16:28
*/
@Data
public class MyTable {
private String MyKey;
private String MyValue;
}十二、模拟数据
private ArrayList<MyTable> getMyDataArrayList(int cap) {
System.out.println("生成模拟数据");
ArrayList<MyTable> list = new ArrayList<MyTable>(cap);
for (int i = 0; i < cap; i++) {
MyTable data = new MyTable();
data.setMyKey(UUID.randomUUID().toString());
data.setMyValue(UUID.randomUUID().toString());
list.add(data);
}
return list;
}public List<Map<String, Object>> testPro() throws JsonProcessingException {
Map<String, Object> map = new HashMap<String, Object>(3);
map.put("MyTable", getMyDataArrayList(100));
// 调用 SP
System.out.println("===> 开始执行存储过程：" + LocalDateTime.now().toString());
List<Map<String, Object>> res = testDao.proTest(map);
System.out.println("===> 执行存储过程结束：" + LocalDateTime.now().toString());
// 获取响应结果集
System.out.println("===> 结果集大小：" + res.size());
System.out.println(JacksonUtil.toJsonString(res.get(0)));
// 获取响应参数
System.out.println("===> 通用响应参数");
System.out.println("Code ：" + map.get("Code").toString());
System.out.println("Msg ：" + map.get("Msg").toString());
return res;
}
十三、JacksonUtil
package com.example.demo.utils;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
import java.io.IOException;
import java.io.InputStream;
/**
* jackson 封装
*
* @author yushanma
* @since 2022/8/13 10:54
*/
@Component("jacksonUtil")
public class JacksonUtil {
private static final Logger logger = LogManager.getLogger(JacksonUtil.class.getName());
private static ObjectMapper mapper = new ObjectMapper();;
/**
* 初始化 jackson 配置
*/
@PostConstruct
private static void init() {
// 如果 json 中有新增的字段并且是实体类类中不存在的，不报错
mapper.configure(DeserializationFeature.FAIL_ON_IGNORED_PROPERTIES, false);
// 在反序列化时忽略在 json 中存在但 Java 对象不存在的属性
mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
// 在序列化时日期格式默认为 yyyy-MM-dd'T'HH:mm:ss.SSSZ
mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
// java.time.LocalDateTime 支持
mapper.registerModule(new JavaTimeModule());
// 在序列化时忽略值为 null 的属性
//mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
// 忽略值为默认值的属性
//mapper.setDefaultPropertyInclusion(JsonInclude.Include.NON_DEFAULT);
mapper.setSerializationInclusion(JsonInclude.Include.ALWAYS);
logger.debug("JacksonUtil Component Init Done.");
}
/**
* Obj 转 JsonString
*
* @param o obj
* @return obj 的 json 序列化字符串
* @throws JsonProcessingException json 处理异常
*/
public static String toJsonString(Object o) throws JsonProcessingException {
if (o == null) {
logger.warn("Obj 对象为空!");
return "";
} else {
return mapper.writerWithDefaultPrettyPrinter().writeValueAsString(o);
}
}
/**
* JsonString 转 Obj
*
* @param jsonString Json 字符串
* @param valueType Obj 类型
* @param <T> 泛型
* @return T 对象
* @throws JsonProcessingException json 处理异常
*/
public static <T> T toObject(String jsonString, Class<T> valueType) throws JsonProcessingException {
if (jsonString == null || jsonString.isEmpty()) {
logger.warn("Json String 为空!");
return null;
} else {
return mapper.readValue(jsonString, valueType);
}
}
/**
* InputStream 转 Obj
* @param inputStream 输入流
* @param valueType Obj 类型
* @param <T> 泛型
* @return T 对象
* @throws IOException IO 异常
*/
public static <T> T toObject(InputStream inputStream, Class<T> valueType) throws IOException {
if (inputStream == null) {
logger.warn("输入流为空!");
return null;
} else {
return mapper.readValue(inputStream, valueType);
}
}
}
十四、测试
十五、特别说明
使用表值参数严重影响 SQL 性能，请尽量避免使用
