此版本仍在开发中，尚不被认为是稳定的。对于最新的稳定版本，请使用 Spring Framework 6.2.10！spring-doc.cadn.net.cn

使用SimpleJdbc类

这SimpleJdbcInsert和SimpleJdbcCall类提供简化的配置 通过利用可通过 JDBC 驱动程序检索的数据库元数据。 这意味着您可以预先配置更少的内容，尽管您可以覆盖或关闭 元数据处理，如果您希望在代码中提供所有详细信息。spring-doc.cadn.net.cn

使用SimpleJdbcInsert

我们首先查看SimpleJdbcInsert类，其中 配置选项。您应该实例化SimpleJdbcInsert在数据访问中 层的初始化方法。对于此示例，初始化方法是setDataSource方法。您不需要将SimpleJdbcInsert类。相反 您可以创建一个新实例，并使用withTableName方法。 此类的配置方法遵循fluidstyle 返回实例 的SimpleJdbcInsert，它允许您链接所有配置方法。以下内容 示例仅使用一种配置方法（我们稍后会展示多种方法的示例）：spring-doc.cadn.net.cn

public class JdbcActorDao implements ActorDao {

	private SimpleJdbcInsert insertActor;

	public void setDataSource(DataSource dataSource) {
		this.insertActor = new SimpleJdbcInsert(dataSource).withTableName("t_actor");
	}

	public void add(Actor actor) {
		Map<String, Object> parameters = new HashMap<>(3);
		parameters.put("id", actor.getId());
		parameters.put("first_name", actor.getFirstName());
		parameters.put("last_name", actor.getLastName());
		insertActor.execute(parameters);
	}

	// ... additional methods
}
class JdbcActorDao(dataSource: DataSource) : ActorDao {

	private val insertActor = SimpleJdbcInsert(dataSource).withTableName("t_actor")

	fun add(actor: Actor) {
		val parameters = mutableMapOf<String, Any>()
		parameters["id"] = actor.id
		parameters["first_name"] = actor.firstName
		parameters["last_name"] = actor.lastName
		insertActor.execute(parameters)
	}

	// ... additional methods
}

这execute这里使用的方法采用普通java.util.Map作为其唯一参数。这 这里需要注意的重要一点是，用于Map必须与列匹配 数据库中定义的表的名称。这是因为我们读取了元数据 构造实际的 INSERT 语句。spring-doc.cadn.net.cn

使用SimpleJdbcInsert

下一个示例使用与前面示例相同的插入，但是，没有传入id它 检索自动生成的键并将其设置在新的Actor对象。当它创建 这SimpleJdbcInsert，除了指定表名外，它还指定名称 生成的键列的usingGeneratedKeyColumns方法。以下内容 列表显示了它的工作原理：spring-doc.cadn.net.cn

public class JdbcActorDao implements ActorDao {

	private SimpleJdbcInsert insertActor;

	public void setDataSource(DataSource dataSource) {
		this.insertActor = new SimpleJdbcInsert(dataSource)
				.withTableName("t_actor")
				.usingGeneratedKeyColumns("id");
	}

	public void add(Actor actor) {
		Map<String, Object> parameters = new HashMap<>(2);
		parameters.put("first_name", actor.getFirstName());
		parameters.put("last_name", actor.getLastName());
		Number newId = insertActor.executeAndReturnKey(parameters);
		actor.setId(newId.longValue());
	}

	// ... additional methods
}
class JdbcActorDao(dataSource: DataSource) : ActorDao {

	private val insertActor = SimpleJdbcInsert(dataSource)
			.withTableName("t_actor").usingGeneratedKeyColumns("id")

	fun add(actor: Actor): Actor {
		val parameters = mapOf(
				"first_name" to actor.firstName,
				"last_name" to actor.lastName)
		val newId = insertActor.executeAndReturnKey(parameters);
		return actor.copy(id = newId.toLong())
	}

	// ... additional methods
}

使用第二种方法运行插入时的主要区别在于，您没有 添加id到Map，然后调用executeAndReturnKey方法。这将返回一个java.lang.Number对象，您可以使用该对象创建数字类型的实例，该 用于您的域类。您不能依赖所有数据库返回特定的 Java class 在这里。java.lang.Number是您可以依赖的基类。如果您有 多个自动生成的列或生成的值是非数字的，您可以 使用KeyHolder从executeAndReturnKeyHolder方法。spring-doc.cadn.net.cn

指定列SimpleJdbcInsert

您可以通过使用usingColumns方法，如以下示例所示：spring-doc.cadn.net.cn

public class JdbcActorDao implements ActorDao {

	private SimpleJdbcInsert insertActor;

	public void setDataSource(DataSource dataSource) {
		this.insertActor = new SimpleJdbcInsert(dataSource)
				.withTableName("t_actor")
				.usingColumns("first_name", "last_name")
				.usingGeneratedKeyColumns("id");
	}

	public void add(Actor actor) {
		Map<String, Object> parameters = new HashMap<>(2);
		parameters.put("first_name", actor.getFirstName());
		parameters.put("last_name", actor.getLastName());
		Number newId = insertActor.executeAndReturnKey(parameters);
		actor.setId(newId.longValue());
	}

	// ... additional methods
}
class JdbcActorDao(dataSource: DataSource) : ActorDao {

	private val insertActor = SimpleJdbcInsert(dataSource)
			.withTableName("t_actor")
			.usingColumns("first_name", "last_name")
			.usingGeneratedKeyColumns("id")

	fun add(actor: Actor): Actor {
		val parameters = mapOf(
				"first_name" to actor.firstName,
				"last_name" to actor.lastName)
		val newId = insertActor.executeAndReturnKey(parameters);
		return actor.copy(id = newId.toLong())
	}

	// ... additional methods
}

插入的执行与依赖元数据来确定相同 要使用哪些列。spring-doc.cadn.net.cn

用SqlParameterSource提供参数值

使用Map提供参数值可以正常工作，但不是最方便的 类。Spring 提供了SqlParameterSource界面。第一个是BeanPropertySqlParameterSource, 如果您有一个符合 JavaBean 的类，其中包含 你的价值观。它使用相应的 getter 方法来提取参数 值。以下示例演示如何使用BeanPropertySqlParameterSource:spring-doc.cadn.net.cn

public class JdbcActorDao implements ActorDao {

	private SimpleJdbcInsert insertActor;

	public void setDataSource(DataSource dataSource) {
		this.insertActor = new SimpleJdbcInsert(dataSource)
				.withTableName("t_actor")
				.usingGeneratedKeyColumns("id");
	}

	public void add(Actor actor) {
		SqlParameterSource parameters = new BeanPropertySqlParameterSource(actor);
		Number newId = insertActor.executeAndReturnKey(parameters);
		actor.setId(newId.longValue());
	}

	// ... additional methods
}
class JdbcActorDao(dataSource: DataSource) : ActorDao {

	private val insertActor = SimpleJdbcInsert(dataSource)
			.withTableName("t_actor")
			.usingGeneratedKeyColumns("id")

	fun add(actor: Actor): Actor {
		val parameters = BeanPropertySqlParameterSource(actor)
		val newId = insertActor.executeAndReturnKey(parameters)
		return actor.copy(id = newId.toLong())
	}

	// ... additional methods
}

另一种选择是MapSqlParameterSource类似于Map但提供了更多 方便addValue可以链接的方法。以下示例演示如何使用它：spring-doc.cadn.net.cn

public class JdbcActorDao implements ActorDao {

	private SimpleJdbcInsert insertActor;

	public void setDataSource(DataSource dataSource) {
		this.insertActor = new SimpleJdbcInsert(dataSource)
				.withTableName("t_actor")
				.usingGeneratedKeyColumns("id");
	}

	public void add(Actor actor) {
		SqlParameterSource parameters = new MapSqlParameterSource()
				.addValue("first_name", actor.getFirstName())
				.addValue("last_name", actor.getLastName());
		Number newId = insertActor.executeAndReturnKey(parameters);
		actor.setId(newId.longValue());
	}

	// ... additional methods
}
class JdbcActorDao(dataSource: DataSource) : ActorDao {

	private val insertActor = SimpleJdbcInsert(dataSource)
			.withTableName("t_actor")
			.usingGeneratedKeyColumns("id")

	fun add(actor: Actor): Actor {
		val parameters = MapSqlParameterSource()
					.addValue("first_name", actor.firstName)
					.addValue("last_name", actor.lastName)
		val newId = insertActor.executeAndReturnKey(parameters)
		return actor.copy(id = newId.toLong())
	}

	// ... additional methods
}

如您所见，配置是相同的。只有执行的代码必须更改为 使用这些替代输入类。spring-doc.cadn.net.cn

使用SimpleJdbcCall

这SimpleJdbcCall类使用数据库中的元数据来查找in和out参数，这样您就不必显式声明它们。您可以 声明参数，如果你愿意这样做，或者你有不这样做的参数 具有与 Java 类的自动映射。第一个示例显示了一个简单的过程 仅返回VARCHAR和DATE格式。 示例过程读取指定的执行组件条目并返回first_name,last_name和birth_date列的形式为out参数。以下内容 清单显示了第一个示例：spring-doc.cadn.net.cn

CREATE PROCEDURE read_actor (
	IN in_id INTEGER,
	OUT out_first_name VARCHAR(100),
	OUT out_last_name VARCHAR(100),
	OUT out_birth_date DATE)
BEGIN
	SELECT first_name, last_name, birth_date
	INTO out_first_name, out_last_name, out_birth_date
	FROM t_actor where id = in_id;
END;

这in_id参数包含id你正在查找的演员。这out参数返回从表中读取的数据。spring-doc.cadn.net.cn

您可以声明SimpleJdbcCall以类似于声明的方式SimpleJdbcInsert.你 应该在数据访问的初始化方法中实例化和配置类 层。与StoredProcedure类，则无需创建子类 并且您无需声明可以在数据库元数据中查找的参数。 以下示例SimpleJdbcCall配置使用前面存储的 过程（唯一的配置选项，除了DataSource，是名称 存储过程）：spring-doc.cadn.net.cn

public class JdbcActorDao implements ActorDao {

	private SimpleJdbcCall procReadActor;

	public void setDataSource(DataSource dataSource) {
		this.procReadActor = new SimpleJdbcCall(dataSource)
				.withProcedureName("read_actor");
	}

	public Actor readActor(Long id) {
		SqlParameterSource in = new MapSqlParameterSource()
				.addValue("in_id", id);
		Map out = procReadActor.execute(in);
		Actor actor = new Actor();
		actor.setId(id);
		actor.setFirstName((String) out.get("out_first_name"));
		actor.setLastName((String) out.get("out_last_name"));
		actor.setBirthDate((Date) out.get("out_birth_date"));
		return actor;
	}

	// ... additional methods
}
class JdbcActorDao(dataSource: DataSource) : ActorDao {

	private val procReadActor = SimpleJdbcCall(dataSource)
			.withProcedureName("read_actor")


	fun readActor(id: Long): Actor {
		val source = MapSqlParameterSource().addValue("in_id", id)
		val output = procReadActor.execute(source)
		return Actor(
				id,
				output["out_first_name"] as String,
				output["out_last_name"] as String,
				output["out_birth_date"] as Date)
	}

		// ... additional methods
}

您为执行调用编写的代码涉及创建SqlParameterSource包含 IN 参数。您必须匹配为输入值提供的名称 替换为存储过程中声明的参数名称。案例没有 匹配，因为您使用元数据来确定应如何引用数据库对象 在存储过程中。在存储过程的源中指定的内容不是 必然是它在数据库中的存储方式。某些数据库将名称转换为 大写，而其他人则使用小写或按指定大小写使用。spring-doc.cadn.net.cn

这execute方法采用 IN 参数并返回Map包含任何out参数由名称键，如存储过程中所指定。在这种情况下，它们是out_first_name,out_last_name和out_birth_date.spring-doc.cadn.net.cn

最后一部分execute方法会创建一个Actor实例，用于返回 检索到的数据。同样，使用out参数作为它们 在存储过程中声明。此外，名称中的大小写out结果映射中存储的参数与out参数名称 数据库，这可能因数据库而异。为了使您的代码更具可移植性，您应该 进行不区分大小写的查找或指示 Spring 使用LinkedCaseInsensitiveMap. 要执行后者，您可以创建自己的JdbcTemplate并将setResultsMapCaseInsensitive属性设置为true.然后你可以通过这个定制JdbcTemplate实例转换为 的构造函数SimpleJdbcCall.以下示例显示了此配置：spring-doc.cadn.net.cn

public class JdbcActorDao implements ActorDao {

	private SimpleJdbcCall procReadActor;

	public void setDataSource(DataSource dataSource) {
		JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
		jdbcTemplate.setResultsMapCaseInsensitive(true);
		this.procReadActor = new SimpleJdbcCall(jdbcTemplate)
				.withProcedureName("read_actor");
	}

	// ... additional methods
}
class JdbcActorDao(dataSource: DataSource) : ActorDao {

	private var procReadActor = SimpleJdbcCall(JdbcTemplate(dataSource).apply {
		isResultsMapCaseInsensitive = true
	}).withProcedureName("read_actor")

	// ... additional methods
}

通过执行此作，您可以避免在用于您的名称的大小写中发生冲突 返回out参数。spring-doc.cadn.net.cn

显式声明要用于SimpleJdbcCall

在本章的前面，我们描述了如何从元数据中推导出参数，但您可以声明它们 如果您愿意，请明确使用。您可以通过创建和配置SimpleJdbcCall跟 这declareParameters方法，该方法采用可变数SqlParameter对象 作为输入。有关如何定义SqlParameter.spring-doc.cadn.net.cn

如果您使用的数据库不是 Spring 支持的数据库，则需要显式声明 数据库。目前，Spring 支持对 以下数据库：Apache Derby、DB2、MySQL、Microsoft SQL Server、Oracle 和 Sybase。 我们还支持 MySQL、Microsoft SQL Server、 和甲骨文。

您可以选择显式声明一个、部分或所有参数。参数 元数据在未显式声明参数的情况下仍会使用。要绕过所有 处理潜在参数的元数据查找，并仅使用声明的 参数，可以调用withoutProcedureColumnMetaDataAccess作为 声明。假设您为 数据库函数。在这种情况下，调用useInParameterNames指定列表 给定签名要包含的 IN 参数名称。spring-doc.cadn.net.cn

以下示例显示了完全声明的过程调用，并使用来自 前面的示例：spring-doc.cadn.net.cn

public class JdbcActorDao implements ActorDao {

	private SimpleJdbcCall procReadActor;

	public void setDataSource(DataSource dataSource) {
		JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
		jdbcTemplate.setResultsMapCaseInsensitive(true);
		this.procReadActor = new SimpleJdbcCall(jdbcTemplate)
				.withProcedureName("read_actor")
				.withoutProcedureColumnMetaDataAccess()
				.useInParameterNames("in_id")
				.declareParameters(
						new SqlParameter("in_id", Types.NUMERIC),
						new SqlOutParameter("out_first_name", Types.VARCHAR),
						new SqlOutParameter("out_last_name", Types.VARCHAR),
						new SqlOutParameter("out_birth_date", Types.DATE)
				);
	}

	// ... additional methods
}
class JdbcActorDao(dataSource: DataSource) : ActorDao {

		private val procReadActor = SimpleJdbcCall(JdbcTemplate(dataSource).apply {
			isResultsMapCaseInsensitive = true
		}).withProcedureName("read_actor")
				.withoutProcedureColumnMetaDataAccess()
				.useInParameterNames("in_id")
				.declareParameters(
						SqlParameter("in_id", Types.NUMERIC),
						SqlOutParameter("out_first_name", Types.VARCHAR),
						SqlOutParameter("out_last_name", Types.VARCHAR),
						SqlOutParameter("out_birth_date", Types.DATE)
	)

		// ... additional methods
}

两个示例的执行和最终结果是相同的。第二个示例指定 显式细节，而不是依赖元数据。spring-doc.cadn.net.cn

如何定义SqlParameters

要定义参数SimpleJdbc类以及 RDBMS作 类（在将 JDBC作建模为 Java 对象中介绍），您可以使用SqlParameter或其子类之一。 为此，通常在构造函数中指定参数名称和 SQL 类型。SQL 类型 通过使用java.sql.Types常数。在本章前面，我们看到了声明 类似于以下内容：spring-doc.cadn.net.cn

new SqlParameter("in_id", Types.NUMERIC),
new SqlOutParameter("out_first_name", Types.VARCHAR),
SqlParameter("in_id", Types.NUMERIC),
SqlOutParameter("out_first_name", Types.VARCHAR),

第一行SqlParameter声明一个 IN 参数。您可以使用 IN 参数 对于存储过程调用和查询，使用SqlQuery及其 子类（涵盖在理解SqlQuery).spring-doc.cadn.net.cn

第二行（带有SqlOutParameter） 声明out参数，用于 存储过程调用。还有一个SqlInOutParameter为InOut参数 （为过程提供 IN 值并返回值的参数）。spring-doc.cadn.net.cn

仅声明为SqlParameter和SqlInOutParameter习惯于 提供输入值。这与StoredProcedure类，其中（对于 向后兼容的原因）允许为参数提供输入值 声明为SqlOutParameter.

对于 IN 参数，除了名称和 SQL 类型外，您还可以指定 自定义数据库类型的数字数据或类型名称。为out参数，您可以 提供一个RowMapper处理从REF光标。另一个 选项是指定一个SqlReturnType这提供了定义 返回值的自定义处理。spring-doc.cadn.net.cn

使用SimpleJdbcCall

您可以像调用存储过程一样调用存储函数，但 提供函数名称而不是过程名称。您可以使用withFunctionName方法作为配置的一部分，以指示您要使 调用函数，并生成函数调用的相应字符串。一个 专业呼叫 （executeFunction） 用于运行该函数，并且它 将函数返回值作为指定类型的对象返回，这意味着您 不必从结果映射中检索返回值。类似的便利方法 （名为executeObject） 也可用于只有一个out参数。 以下示例（对于 MySQL）基于名为get_actor_name返回 actor 的全名：spring-doc.cadn.net.cn

CREATE FUNCTION get_actor_name (in_id INTEGER)
RETURNS VARCHAR(200) READS SQL DATA
BEGIN
	DECLARE out_name VARCHAR(200);
	SELECT concat(first_name, ' ', last_name)
		INTO out_name
		FROM t_actor where id = in_id;
	RETURN out_name;
END;

为了调用这个函数，我们再次创建一个SimpleJdbcCall在初始化方法中，如以下示例所示：spring-doc.cadn.net.cn

public class JdbcActorDao implements ActorDao {

	private SimpleJdbcCall funcGetActorName;

	public void setDataSource(DataSource dataSource) {
		JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
		jdbcTemplate.setResultsMapCaseInsensitive(true);
		this.funcGetActorName = new SimpleJdbcCall(jdbcTemplate)
				.withFunctionName("get_actor_name");
	}

	public String getActorName(Long id) {
		SqlParameterSource in = new MapSqlParameterSource()
				.addValue("in_id", id);
		String name = funcGetActorName.executeFunction(String.class, in);
		return name;
	}

	// ... additional methods
}
class JdbcActorDao(dataSource: DataSource) : ActorDao {

	private val jdbcTemplate = JdbcTemplate(dataSource).apply {
		isResultsMapCaseInsensitive = true
	}
	private val funcGetActorName = SimpleJdbcCall(jdbcTemplate)
			.withFunctionName("get_actor_name")

	fun getActorName(id: Long): String {
		val source = MapSqlParameterSource().addValue("in_id", id)
		return funcGetActorName.executeFunction(String::class.java, source)
	}

	// ... additional methods
}

这executeFunction使用的方法返回一个String包含来自 函数调用。spring-doc.cadn.net.cn

返回一个ResultSet或 REF 光标SimpleJdbcCall

调用返回结果集的存储过程或函数有点棘手。一些 数据库在 JDBC 结果处理期间返回结果集，而其他数据库则需要 显式注册out特定类型的参数。这两种方法都需要 其他处理，以循环结果集并处理返回的行。跟 这SimpleJdbcCall，您可以使用returningResultSet方法并声明一个RowMapper用于特定参数的实现。如果结果集为 返回时，没有定义名称，因此返回的 结果必须与声明RowMapper实现。指定的名称仍用于存储已处理的结果列表 在从execute陈述。spring-doc.cadn.net.cn

下一个示例（对于 MySQL）使用不接受 IN 参数并返回的存储过程 所有行t_actor桌子：spring-doc.cadn.net.cn

CREATE PROCEDURE read_all_actors()
BEGIN
 SELECT a.id, a.first_name, a.last_name, a.birth_date FROM t_actor a;
END;

要调用此过程，您可以声明RowMapper.因为您想要的类 要映射遵循 JavaBean 规则，您可以使用BeanPropertyRowMapper由 传入所需的类以映射到newInstance方法。 以下示例显示了如何执行此作：spring-doc.cadn.net.cn

public class JdbcActorDao implements ActorDao {

	private SimpleJdbcCall procReadAllActors;

	public void setDataSource(DataSource dataSource) {
		JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
		jdbcTemplate.setResultsMapCaseInsensitive(true);
		this.procReadAllActors = new SimpleJdbcCall(jdbcTemplate)
				.withProcedureName("read_all_actors")
				.returningResultSet("actors",
				BeanPropertyRowMapper.newInstance(Actor.class));
	}

	public List getActorsList() {
		Map m = procReadAllActors.execute(new HashMap<String, Object>(0));
		return (List) m.get("actors");
	}

	// ... additional methods
}
class JdbcActorDao(dataSource: DataSource) : ActorDao {

		private val procReadAllActors = SimpleJdbcCall(JdbcTemplate(dataSource).apply {
			isResultsMapCaseInsensitive = true
		}).withProcedureName("read_all_actors")
				.returningResultSet("actors",
						BeanPropertyRowMapper.newInstance(Actor::class.java))

	fun getActorsList(): List<Actor> {
		val m = procReadAllActors.execute(mapOf<String, Any>())
		return m["actors"] as List<Actor>
	}

	// ... additional methods
}

这execute呼叫传递在空的Map，因为此调用不采用任何参数。 然后，从结果映射中检索参与者列表并返回给调用方。spring-doc.cadn.net.cn