狮山网站设计,制作网站用什么软件有哪些,天津有哪些互联网公司,桥头镇网站建设公司Spring最重要的功能就是操作数据#xff0c;数据库编程也是互联网编程的基础#xff0c;Spring为开发者提供了JDBC模板模式#xff0c;使用JdbcTemplate可以简化许多编码工作#xff0c;同时也提供了TransactionTemplate支持事务的模板#xff0c;但都不是常用技术#x… Spring最重要的功能就是操作数据数据库编程也是互联网编程的基础Spring为开发者提供了JDBC模板模式使用JdbcTemplate可以简化许多编码工作同时也提供了TransactionTemplate支持事务的模板但都不是常用技术对于持久层而言更多的还是使用Hibernate框架或者MyBatis框架 Spring并不取代已有框架的功能而是提供模板的形式简化工作对于Hibernate框架Spring提供了HibernateTemplate给予支持从而有效的简化HIbernate的编程现有版本Spring并没有类似的模板支持MyBatis但MyBatis社区开发了接入Spring的开发包提供了SqlSessionTemplate而且在编程中可以擦除SqlSessionTemplate这样的功能性代码开发者可以直接使用接口编程 传统的JDBC弊端 如下代码所示是一段传统的使用JDBC形式操作数据的代码 // 数据库URL private static String url jdbc:mysql://localhost:3306/ssm; // 数据库用户名 private static String username root; // 数据库密码 private static String password 123456; /*** 从数据库中根据ID获取角色信息。* * param id 角色的ID不能为空。* return 返回查询到的角色对象如果未查询到则返回null。*/ public static Role getRole(Long id) {Role role null;// 声明JDBC变量Connection con null;PreparedStatement ps null;ResultSet rs null;try {// 注册驱动程序Class.forName(com.mysql.jdbc.Driver);// 获取连接con DriverManager.getConnection(url, username, password);String sql select id, role_name, note from t_role where id ?;// 预编译SQL并设置参数ps con.prepareStatement(sql);ps.setLong(1, id);// 执行查询rs ps.executeQuery();// 处理结果集组装Role对象while (rs.next()) {role new Role();role.setId(rs.getLong(1));role.setRoleName(rs.getString(2));role.setNote(rs.getString(3));}} catch (ClassNotFoundException | SQLException e) {// 异常处理e.printStackTrace();} finally {// 关闭数据库连接资源try {if (rs ! null !rs.isClosed()) {rs.close();}} catch (SQLException e) {e.printStackTrace();}try {if (ps ! null !ps.isClosed()) {ps.close();}} catch (SQLException e) {e.printStackTrace();}try {if (con ! null !con.isClosed()) {con.close();}} catch (SQLException e) {e.printStackTrace();}}return role; }使用传统的JDBC编程代码过程非常冗余即便是一条SQL语句的执行过程也不简单而且大量的try…catch…finally…语句 Spring配置数据库 使用Spring提供的org.springframework.jdbc.datasource.SimpleDriverDataSource,如下所示在spring-cfg.xml文件中只是它不支持数据库连接池 bean id datasource classorg.springframework.jdbc.datasource.SimpleDriverDataSourceproperty namedriverClass valuecom.mysql.jdbc.Driver /property nameurl valuejdbc:mysql://localhost:3306/ssm /property nameusername valueroot /property namepassword value123456 /property nameconnectionPropertiespropsprop keyuseUnicodetrue/propprop keycharacterEncodingUTF-8/prop/props/property/bean使用第三方的数据库连接池比如DBCP数据库连接池同样是在spring-cfg.xml文件中 bean iddataSourceclassorg.apache.commons.dbcp2.BasicDataSourceproperty namedriverClassNamevaluecom.mysql.jdbc.Driver /property nameurl valuejdbc:mysql://localhost:3306/ssm /property nameusername valueroot /property namepassword value123456 /!--连接池的最大数据库连接数 --property namemaxTotal value255 /!--最大等待连接中的数量 --property namemaxIdle value5 /!--最大等待毫秒数 --property namemaxWaitMillis value10000 //bean在Tomcat、WebLogic等JavaEE服务器上配置数据源给这个数据源一个JNDI名称通过Spring提供的JNDI机制获取对应的数据源例如在tomcat上配置了JNDI为jdbc/ssm的数据源如下代码所示在tomcat的applicationContext.xml文件中 !-- 通过JNDI获取的数据源通过Spring的接口注入实现 --bean iddataSource classorg.springframework.jndi.JndiObjectFactoryBeanproperty namejndiNamevaluejava:comp/env/jdbc/ssm/value/property/bean然后在application.properties或application.yml中配置Spring Boot以使用JNDI查找数据源当Spring Boot应用启动时它会自动查找在JNDI中定义的数据源并将其注册为Spring的Bean供应用使用 JdbcTemplate JdbcTemplate是Spring针对JDBC代码失控提供的解决方案体现了Spring框架的主导思想之一即给常用技术提供模板化的编程减少开发者工作量在spring-cfg.xml中进行如下配置 !-- 数据库连接池 --bean iddataSourceclassorg.apache.commons.dbcp2.BasicDataSourceproperty namedriverClassName valuecom.mysql.cj.jdbc.Driver /property nameurl valuejdbc:mysql://localhost:3306/ssm /property nameusername valueroot /property namepassword value123456 /!--连接池的最大数据库连接数 --property namemaxTotal value255 /!--最大等待连接中的数量 --property namemaxIdle value5 /!--最大等待毫秒数 --property namemaxWaitMillis value10000 //bean!-- 定义一个名为jdbcTemplate的bean其类型为org.springframework.jdbc.core.JdbcTemplate --!-- 该bean主要用来简化JDBC操作。它通过注入dataSource属性来建立与数据库的连接 --bean idjdbcTemplateclassorg.springframework.jdbc.core.JdbcTemplate!-- 将名为dataSource的bean引用注入到jdbcTemplate的dataSource属性中 --!-- dataSource是数据库连接的来源确保JdbcTemplate可以执行数据库操作 --property namedataSource refdataSource //bean 配置好dataSource和JdbcTemplate就可以使用JdbcTemplate执行SQL了执行如下代码即可 package com.sdb.main;import org.springframework.context.support.ClassPathXmlApplicationContext; import org.springframework.jdbc.core.JdbcTemplate; import org.springframework.jdbc.core.RowMapper;import java.sql.ResultSet; import com.sdb.pojo.Role;/*** JdbcMain类用于演示通过JdbcTemplate进行数据库操作。*/ public class JdbcMain {public static void main(String[] args) {testJdbcTemplate();}/*** 测试使用JdbcTemplate执行数据库查询操作。* 该方法首先从Spring配置文件中获取JdbcTemplate实例然后根据给定的ID查询角色信息。*/public static void testJdbcTemplate() {// 初始化Spring上下文并从配置文件中加载beanClassPathXmlApplicationContext ctx new ClassPathXmlApplicationContext(spring-cfg.xml);// 从Spring上下文中获取JdbcTemplate实例JdbcTemplate jdbcTemplate ctx.getBean(JdbcTemplate.class);Long id 1L; // 定义要查询的角色ID// 构造查询SQL语句String sql select id, role_name, note from t_role where id id;// 使用Lambda表达式定义如何将ResultSet映射到Role对象RowMapperRole roleMapper (ResultSet rs, int rowNum) - {Role result new Role();result.setId(rs.getLong(id));result.setRoleName(rs.getString(role_name));result.setNote(rs.getString(note));return result;};// 使用JdbcTemplate执行查询并返回唯一的Role对象Role role jdbcTemplate.queryForObject(sql, roleMapper);ctx.close(); // 关闭Spring上下文System.out.println(role.getRoleName()); // 打印查询结果中的角色名称} }如此便不用再写任何关闭数据库链接等相关操作操作代码JdbcTemplate内部实现了这就是Spring提供的模板规则 package com.sdb.main;import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; import org.springframework.jdbc.core.JdbcTemplate; import org.springframework.jdbc.core.RowMapper;import java.sql.ResultSet; import java.sql.SQLException; import java.util.List;import com.sdb.pojo.Role;/*** JdbcMain类用于演示通过JdbcTemplate进行数据库操作。*/ public class JdbcMain {/*** 程序的主入口函数。* param args 命令行参数未使用* throws SQLException 如果操作数据库时发生错误*/public static void main(String[] args) throws SQLException {// 初始化Spring上下文从spring-cfg.xml加载配置ApplicationContext ctx new ClassPathXmlApplicationContext(spring-cfg.xml);// 从Spring上下文中获取JdbcTemplate实例JdbcTemplate jdbcTemplate ctx.getBean(JdbcTemplate.class);// 创建JdbcMain实例JdbcMain test new JdbcMain();// 查询角色列表示例List roleList test.findRole(jdbcTemplate, role);System.out.println(roleList.size());// 插入角色示例Role role new Role();role.setId(1L);role.setRoleName(update_role_name_1);role.setNote(update_note_1);System.out.println(test.insertRole(jdbcTemplate));// 更新角色示例System.out.println(test.updateRole(jdbcTemplate, role));// 删除角色示例System.out.println(test.deleteRole(jdbcTemplate, 1L));}/*** 插入一个新的角色信息到数据库。* param jdbcTemplate JdbcTemplate对象用于执行SQL语句。* return 返回影响的行数通常为1表示插入了一行。*/public int insertRole(JdbcTemplate jdbcTemplate) {// 准备插入的角色信息String roleName role_name_1;String note note_1;// 构造插入SQL语句String sql insert into t_role(role_name, note) values(?, ?);// 执行插入操作并返回影响的行数return jdbcTemplate.update(sql, roleName, note);}/*** 删除指定ID的角色信息。** param jdbcTemplate 提供数据库操作能力的模板类。* param id 要删除的角色的ID。* return 返回受影响的行数即被删除的角色数量。*/public int deleteRole(JdbcTemplate jdbcTemplate, Long id) {// 构造删除角色的SQL语句String sql delete from t_role where id?;// 执行SQL语句返回删除的行数return jdbcTemplate.update(sql, id);}/*** 使用JdbcTemplate更新角色信息。** param jdbcTemplate 提供数据库操作能力的模板类。* param role 需要更新的角色对象包含角色的id、名称和备注信息。* return 更新成功返回影响的行数通常为1更新失败返回0。*/public int updateRole(JdbcTemplate jdbcTemplate, Role role) {// 构造更新语句设置要更新的字段和条件字段String sql update t_role set role_name?, note ? where id ?;// 执行更新操作并返回影响的行数return jdbcTemplate.update(sql, role.getRoleName(), role.getNote(), role.getId());}/*** 查询与给定角色名匹配的角色列表。** param jdbcTemplate 用于数据库查询的JdbcTemplate对象。* param roleName 要查找的角色名可以包含通配符%。* return 返回一个角色列表这些角色的角色名与给定的角色名匹配。*/public ListRole findRole(JdbcTemplate jdbcTemplate, String roleName) {// 构造SQL查询语句使用like语句进行角色名的模糊匹配String sql select id, role_name, note from t_role where role_name like concat(%,?, %);Object[] params { roleName };// 组织参数用于替换SQL查询中的占位符// 使用JdbcTemplate的query方法执行查询并通过RowMapper将结果映射为Role对象// Lambda表达式用于定义RowMapper它指定了如何将ResultSet的每一行映射为一个Role对象ListRole list jdbcTemplate.query(sql, params,(ResultSet rs, int rowNum) - {Role result new Role();result.setId(rs.getLong(id)); // 从ResultSet中获取id并设置到Role对象中result.setRoleName(rs.getString(role_name)); // 从ResultSet中获取role_name并设置到Role对象中result.setNote(rs.getString(note)); // 从ResultSet中获取note并设置到Role对象中return result;});return list;} } 上述代码使用JdbcTemplate完成了简单的增删改查但都是使用JdbcTemplate执行单条语句也可以执行多条如下代码所示 /*** 通过JdbcTemplate和id获取角色信息使用ConnectionCallback接口。** param jdbcTemplate JdbcTemplate用于执行数据库操作。* param id 角色的id用于查询特定的角色。* return Role 返回查询到的角色对象如果没有找到则返回null。*/public Role getRoleByConnectionCallback(JdbcTemplate jdbcTemplate, Long id) {Role role null;// 这里写成Java 8的lambda表达式,java8及以上可用// 使用ConnectionCallback执行SQL查询获取角色信息role jdbcTemplate.execute((Connection con) - {Role result null;String sql select id, role_name, note from t_role where id ?;PreparedStatement ps con.prepareStatement(sql);ps.setLong(1, id);ResultSet rs ps.executeQuery();// 遍历结果集并构建角色对象while (rs.next()) {result new Role();result.setId(rs.getLong(id));result.setNote(rs.getString(note));result.setRoleName(rs.getString(role_name));}return result;});return role;}/*** 通过JdbcTemplate和id获取角色信息使用StatementCallback接口。** param jdbcTemplate JdbcTemplate用于执行数据库操作。* param id 角色的id用于查询特定的角色。* return Role 返回查询到的角色对象如果没有找到则返回null。*/public Role getRoleByStatementCallback(JdbcTemplate jdbcTemplate, Long id) {Role role null;// 这里写成Java 8的lambda表达式,java8及以上可用// 使用StatementCallback执行SQL查询获取角色信息role jdbcTemplate.execute((Statement stmt) - {Role result null;String sql select id, role_name, note from t_role where id id;ResultSet rs stmt.executeQuery(sql);// 遍历结果集并构建角色对象while (rs.next()) {result new Role();result.setId(rs.getLong(id));result.setNote(rs.getString(note));result.setRoleName(rs.getString(role_name));}return result;});return role;}使用execute方法它允许传递ConnectionCallback或者StatementCallback等接口进行回调从而完成对应的功能看一些StatementCallback接口回调的相关源码 /*** 执行给定的 StatementCallback 操作。* * param action 一个实现了 StatementCallback 接口的对象它定义了在 JDBC Statement 上要执行的具体操作。该参数不能为空。* param T 返回类型由 StatementCallback 操作定义。* return 执行给定操作后的结果其类型由 StatementCallback 的 doInStatement 方法返回。* throws DataAccessException 如果执行数据库操作时发生异常。*/Nullablepublic T T execute(StatementCallbackT action) throws DataAccessException {Assert.notNull(action, Callback object must not be null); // 确保 action 参数不为 null。Connection con DataSourceUtils.getConnection(this.obtainDataSource()); // 从数据源获取连接。Statement stmt null;Object var11;try {stmt con.createStatement(); // 创建 JDBC Statement 对象。this.applyStatementSettings(stmt); // 应用 Statement 的设置。T result action.doInStatement(stmt); // 执行在 Statement 上的操作并获取结果。this.handleWarnings(stmt); // 处理 Statement 执行过程中产生的警告。var11 result;} catch (SQLException var9) {String sql getSql(action); // 尝试获取执行操作时的 SQL 语句。JdbcUtils.closeStatement(stmt); // 关闭 Statement。stmt null;DataSourceUtils.releaseConnection(con, this.getDataSource()); // 释放 Connection。con null;throw this.translateException(StatementCallback, sql, var9); // 将 SQL 异常转换为 DataAccessException 抛出。} finally {JdbcUtils.closeStatement(stmt); // 确保 Statement 被关闭。DataSourceUtils.releaseConnection(con, this.getDataSource()); // 确保 Connection 被释放。}return var11; // 返回操作结果。} 它首先从数据源中获取一条连接然后对接口进行回调在catch语句中关闭对应链接方式连接池锁死最后finally语句释放数据库连接,至此都还没提到关于JdbcTemplate的事务处理因为JdbcTemplate需要引入对应的事务管理器才能支持事务实际上在深入挖掘上边的源码中关于建立链接和释放链接的源码 /*** 释放数据库连接的通用方法。此方法会尝试关闭提供的Connection对象如果操作失败会捕获并记录异常。* 当传入的Connection对象或DataSource对象为null时方法直接返回不执行释放操作。* * param con 待释放的数据库连接对象可能为null。* param dataSource 数据源对象用于从其中获取连接可能为null。*/public static void releaseConnection(Nullable Connection con, Nullable DataSource dataSource) {try {// 尝试释放连接内部会处理null值和异常情况doReleaseConnection(con, dataSource);} catch (SQLException var3) {// 记录SQL异常logger.debug(Could not close JDBC Connection, var3);} catch (Throwable var4) {// 记录其他异常logger.debug(Unexpected exception on closing JDBC Connection, var4);}}/*** 实际释放数据库连接的方法。此方法会首先检查是否从数据源获取的连接如果是则将其标记为已释放* 而不是直接关闭。如果连接不是从数据源获取的或者已经从数据源获取但与当前传入的连接不匹配则会尝试关闭连接。* * param con 待释放的数据库连接对象可能为null。* param dataSource 提供连接的数据源对象用于检查和释放连接可能为null。* throws SQLException 如果关闭连接时发生SQL异常。*/public static void doReleaseConnection(Nullable Connection con, Nullable DataSource dataSource) throws SQLException {if (con ! null) {if (dataSource ! null) {// 尝试从TransactionSynchronizationManager中获取连接持有者ConnectionHolder conHolder (ConnectionHolder)TransactionSynchronizationManager.getResource(dataSource);if (conHolder ! null connectionEquals(conHolder, con)) {// 如果连接持有者存在且连接匹配则标记连接为已释放conHolder.released();return;}}// 关闭连接处理非数据源提供的连接或数据源提供的但未匹配的情况doCloseConnection(con, dataSource);}} /*** 尝试从给定的DataSource获取一个JDBC连接。* 如果获取失败可能会抛出CannotGetJdbcConnectionException异常。* * param dataSource 必须指定的DataSource对象从中获取JDBC连接。* return 返回一个JDBC连接。* throws CannotGetJdbcConnectionException 如果无法获取JDBC连接抛出此异常。*/ public static Connection getConnection(DataSource dataSource) throws CannotGetJdbcConnectionException {try {return doGetConnection(dataSource);} catch (SQLException var2) {throw new CannotGetJdbcConnectionException(Failed to obtain JDBC Connection, var2);} catch (IllegalStateException var3) {throw new CannotGetJdbcConnectionException(Failed to obtain JDBC Connection: var3.getMessage());} }/*** 从DataSource实际获取JDBC连接。* 这个方法会检查当前是否已经有一个与事务同步的连接如果没有则尝试从DataSource获取一个连接。* 如果在获取连接或绑定连接到事务同步过程中出现异常会释放已获取的连接。* * param dataSource 必须指定的DataSource对象从中获取JDBC连接。* return 返回获取到的JDBC连接。* throws SQLException 如果获取连接过程中出现SQL异常。*/ public static Connection doGetConnection(DataSource dataSource) throws SQLException {Assert.notNull(dataSource, No DataSource specified); // 确保DataSource不为空ConnectionHolder conHolder (ConnectionHolder)TransactionSynchronizationManager.getResource(dataSource);// 检查是否已经有一个连接被绑定到当前事务if (conHolder null || !conHolder.hasConnection() !conHolder.isSynchronizedWithTransaction()) {logger.debug(Fetching JDBC Connection from DataSource);Connection con fetchConnection(dataSource); // 从DataSource获取连接// 如果当前有事务同步活跃则将连接绑定到事务if (TransactionSynchronizationManager.isSynchronizationActive()) {try {ConnectionHolder holderToUse conHolder;if (conHolder null) {holderToUse new ConnectionHolder(con); // 创建新的连接持有者} else {conHolder.setConnection(con); // 更新现有持有者的连接}holderToUse.requested(); // 标记连接被请求TransactionSynchronizationManager.registerSynchronization(new ConnectionSynchronization(holderToUse, dataSource)); // 注册连接同步holderToUse.setSynchronizedWithTransaction(true); // 标记为与事务同步if (holderToUse ! conHolder) {TransactionSynchronizationManager.bindResource(dataSource, holderToUse); // 绑定资源}} catch (RuntimeException var4) {releaseConnection(con, dataSource); // 异常时释放连接throw var4;}}return con;} else {conHolder.requested(); // 标记连接被请求if (!conHolder.hasConnection()) {logger.debug(Fetching resumed JDBC Connection from DataSource);conHolder.setConnection(fetchConnection(dataSource)); // 如果连接被中断重新获取连接}return conHolder.getConnection(); // 返回连接} } 都进行了深层次的判断是否要交给事务管理器处理如果是则从数据库事务管理器中获取数据库连接在释放链接时候也是一样的而不是由JdbcTemplate决定 因为JdbcTemplate不是非常广泛的使用因此不做过多的展示 MyBatis-Spring 大部分互联网项目都是用SpringMVC、Spring、MyBatis搭建的平台使用SpringIoC可以有效地管理各类Java资源实现即插即拔通过AOP框架数据库事务可以委托给Spring处理再配合MyBatis的高灵活可配置可优化SQL的特点完成大型系统的构建的 要特别注意各工具版本的兼容性pom如下所示 dependencygroupIdorg.mybatis/groupIdartifactIdmybatis-spring/artifactIdversion2.0.3/version/dependency!-- MyBatis包 --dependencygroupIdorg.mybatis/groupIdartifactIdmybatis/artifactIdversion3.5.3/version/dependency!-- MySQL驱动包 --dependencygroupIdmysql/groupIdartifactIdmysql-connector-java/artifactIdversion5.1.29/version/dependency配置SqlSessionFactoryBean 从MyBatis的介绍中可以知道MyBatis是围绕SqlSessionFactory的应用而SqlSessionFactory是产生SqlSession的基础因此配置SqlSessionFactory是重中之重在MyBatis-Spring项目中提供了SqlSessionFactoryBean支持SqlSessionFactory的配置先看一下其源码 /*** SqlSessionFactoryBean类实现了FactoryBean接口用于创建SqlSessionFactory实例* 这是MyBatis与Spring集成时常用的一个Bean配置类。* 同时它还实现了InitializingBean和ApplicationListener接口* 用于在Bean初始化时进行一些设置和监听应用事件。*/ public class SqlSessionFactoryBean implements FactoryBeanSqlSessionFactory, InitializingBean, ApplicationListenerApplicationEvent {// 日志记录器private static final Logger LOGGER LoggerFactory.getLogger(SqlSessionFactoryBean.class);// 资源模式解析器private static final ResourcePatternResolver RESOURCE_PATTERN_RESOLVER new PathMatchingResourcePatternResolver();// 元数据读取器工厂private static final MetadataReaderFactory METADATA_READER_FACTORY new CachingMetadataReaderFactory();// MyBatis配置文件位置private Resource configLocation;// 自定义配置项private Configuration configuration;// Mapper文件位置数组private Resource[] mapperLocations;// 数据源private DataSource dataSource;// 事务工厂private TransactionFactory transactionFactory;// 配置属性private Properties configurationProperties;// SqlSessionFactory构建器private SqlSessionFactoryBuilder sqlSessionFactoryBuilder new SqlSessionFactoryBuilder();// SqlSessionFactory实例private SqlSessionFactory sqlSessionFactory;// 环境配置默认类名private String environment SqlSessionFactoryBean.class.getSimpleName();// 是否快速失败遇到错误立即失败private boolean failFast;// 插件数组private Interceptor[] plugins;// 类型处理器数组private TypeHandler?[] typeHandlers;// 类型别名包private String typeHandlersPackage;// 类型别名数组private Class?[] typeAliases;// 类型别名包private String typeAliasesPackage;// 类型别名的超类private Class? typeAliasesSuperType;// 脚本语言驱动数组private LanguageDriver[] scriptingLanguageDrivers;// 默认脚本语言驱动private Class? extends LanguageDriver defaultScriptingLanguageDriver;// 数据库ID提供者private DatabaseIdProvider databaseIdProvider;// VFS (虚拟文件系统) 类private Class? extends VFS vfs;// 缓存实现private Cache cache;// 对象工厂private ObjectFactory objectFactory;// 对象包装工厂private ObjectWrapperFactory objectWrapperFactory;/*****setters and other methods *****/ } 从源码中不难发现几乎所有MyBatis的组件都可以配置而且还提供了对应的setter方法让Spring进行设置因此完全可以通过SpringIoC容器的规则去配置它们在spring-cfg.xml文件中加入如下配置 !-- 定义一个bean来创建SqlSessionFactory它是MyBatis与Spring集成的关键组件 -- bean idsqlSessionFactory classorg.mybatis.spring.SqlSessionFactoryBean!-- 引用数据源即数据库连接池确保SqlSessionFactory可以执行数据库操作 --property namedataSource refdataSource /!-- 指定MyBatis配置文件的位置这个文件定义了MyBatis的全局配置及其他设置 --property nameconfigLocation valueclasspath:mybatis-config.xml / /bean这里配置很简单配了个数据源并且引入了MyBatis的配置文件其内容如下 ?xml version1.0 encodingUTF-8? !DOCTYPE configuration PUBLIC -//mybatis.org//DTD Config 3.0//EN http://mybatis.org/dtd/mybatis-3-config.dtd configurationsettings!-- 这个配置使全局的映射器启用或禁用缓存 --setting namecacheEnabled valuetrue /!-- 允许 JDBC 支持生成的键。需要适当的驱动。如果设置为true则这个设置强制生成的键被使用尽管一些驱动拒绝兼容但仍然有效比如 Derby --setting nameuseGeneratedKeys valuetrue /!-- 配置默认的执行器。SIMPLE 执行器没有什么特别之处。REUSE 执行器重用预处理语句。BATCH 执行器重用语句和批量更新 --setting namedefaultExecutorType valueREUSE /!-- 全局启用或禁用延迟加载。当禁用时所有关联对象都会即时加载 --setting namelazyLoadingEnabled valuetrue/!-- 设置超时时间它决定驱动等待一个数据库响应的时间 --setting namedefaultStatementTimeout value25000//settings!-- 别名配置 --typeAliasestypeAlias aliasrole typecom.sdb.pojo.Role //typeAliases!-- 指定映射器路径 --mappersmapper resource/RoleMapper.xml //mappers /configuration再看一下引入的RoleMapper.xml ?xml version1.0 encodingUTF-8 ? !DOCTYPE mapperPUBLIC -//mybatis.org//DTD Mapper 3.0//ENhttp://mybatis.org/dtd/mybatis-3-mapper.dtd !-- 定义Mapper的命名空间 -- mapper namespacecom.sdb.dao.RoleDao!-- 插入角色信息使用自动生成的键作为主键 --insert idinsertRole useGeneratedKeystrue keyPropertyidinsert into t_role(role_name, note) values (#{roleName}, #{note})/insert!-- 根据ID删除角色 --delete iddeleteRole parameterTypelongdelete from t_role where id#{id}/delete!-- 根据ID获取角色信息 --select idgetRole parameterTypelong resultTyperoleselect id, role_name as roleName, note from t_role where id #{id}/select!-- 更新角色信息 --update idupdateRole parameterTyperoleupdate t_roleset role_name #{roleName},note #{note}where id #{id}/update /mapperRoleDao接口代码如下 package com.sdb.dao;import com.sdb.pojo.Role; import org.apache.ibatis.annotations.Mapper; import org.apache.ibatis.annotations.Param; /*** RoleDao接口定义了角色数据访问层的方法*/ Mapper public interface RoleDao {/*** 插入角色信息* param role 角色对象包含角色信息* return 返回插入操作影响的行数*/public int insertRole(Role role);/*** 根据ID获取角色信息* param id 角色ID用于查询特定角色* return 返回查询到的角色对象如果不存在则返回null*/public Role getRole(Param(id) Long id);/*** 更新角色信息* param role 角色对象包含需要更新的角色信息* return 返回更新操作影响的行数*/public int updateRole(Role role);/*** 根据ID删除角色信息* param id 角色ID用于指定删除的角色* return 返回删除操作影响的行数*/public int deleteRole(Param(id) Long id); }配置SqlSessionTemplate 到此就完成了MyBatis框架的主要代码接下来是SqlSessionTemplate它并不是一个必须配置的组件但仍有其价值它是线程安全的类能够确保每个线程使用的SqlSession唯一且不互相冲突同时也提供了一系列的功能但在使用它之前需要先配置如下代码所示 !-- 定义一个bean来创建SqlSessionTemplate的实例它提供了在Spring环境中使用MyBatis的简化方法 --bean idsqlSessionTemplate classorg.mybatis.spring.SqlSessionTemplate!-- 通过引用sqlSessionFactory来构造SqlSessionTemplatesqlSessionFactory是MyBatis与Spring集成的关键组件 --constructor-arg refsqlSessionFactory /!-- 上述构造器参数指定了SqlSessionTemplate使用的执行模式默认为SIMPLE。这里通过注释掉的代码块展示了还可以指定BATCH执行模式 --!-- constructor-arg valueBATCH/ --/beanSqlSessionTemplate要通过带有参数的构造方法创建对象常用的参数是SqlSessionFactory和MyBatis执行器(Executor)类型取值枚举是SIMPLE、REUSE、BATCH也是之前讨论过的执行器的三种类型配置好SqlSessionTemplate就可以使用它执行SQL了 package com.sdb.main;import org.mybatis.spring.SqlSessionTemplate; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; import com.sdb.pojo.Role;/*** MyBatis主程序类用于演示通过Spring和MyBatis整合进行数据库操作。*/ public class MyBatisMain {/*** 程序入口方法调用testXmlConfig测试通过XML配置的Spring和MyBatis功能。** param args 命令行参数*/public static void main(String[] args) {testXmlConfig() ;}/*** 测试通过XML配置文件初始化SpringApplicationContext并使用SqlSessionTemplate进行数据库操作。*/private static void testXmlConfig() {// 初始化Spring应用上下文ApplicationContext ctx new ClassPathXmlApplicationContext(spring-cfg.xml);// 从Spring上下文中获取SqlSessionTemplate实例SqlSessionTemplate sqlSessionTemplate ctx.getBean(SqlSessionTemplate.class);// 创建Role对象并设置属性Role role new Role() ;role.setRoleName(role_name_sqlSessionTemplate);role.setNote(note_sqlSessionTemplate);// 操作数据库插入角色String prefix com.sdb.dao.RoleDao;sqlSessionTemplate.insert(prefix .insertRole, role);// 通过ID获取角色信息Long id role.getId();sqlSessionTemplate.selectOne(prefix .getRole, id);// 更新角色信息role.setNote(update_sqlSessionTemplate);sqlSessionTemplate.update(prefix .updateRole, role);// 删除角色sqlSessionTemplate.delete(prefix .deleteRole, id);}} 执行日志如下 DEBUG 2024-05-23 20:12:06,975 org.apache.ibatis.logging.LogFactory: Logging initialized using class org.apache.ibatis.logging.slf4j.Slf4jImpl adapter. DEBUG 2024-05-23 20:12:07,210 org.mybatis.logging.Logger: Parsed configuration file: class path resource [mybatis-config.xml] DEBUG 2024-05-23 20:12:07,211 org.mybatis.logging.Logger: Property mapperLocations was not specified. DEBUG 2024-05-23 20:12:07,297 org.mybatis.logging.Logger: Creating a new SqlSession DEBUG 2024-05-23 20:12:07,304 org.mybatis.logging.Logger: SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession51e4ccb3] was not registered for synchronization because synchronization is not active DEBUG 2024-05-23 20:12:08,391 org.mybatis.logging.Logger: JDBC Connection [117885704, URLjdbc:mysql://192.168.3.115:3306/ssm?useUnicodetrue;characterEncodingutf8, UserNameroot192.168.3.112, MySQL Connector/J] will not be managed by Spring DEBUG 2024-05-23 20:12:08,404 org.apache.ibatis.logging.jdbc.BaseJdbcLogger: Preparing: insert into t_role(role_name, note) values (?, ?) DEBUG 2024-05-23 20:12:08,450 org.apache.ibatis.logging.jdbc.BaseJdbcLogger: Parameters: role_name_sqlSessionTemplate(String), note_sqlSessionTemplate(String) DEBUG 2024-05-23 20:12:08,480 org.apache.ibatis.logging.jdbc.BaseJdbcLogger: Updates: 1 DEBUG 2024-05-23 20:12:08,488 org.mybatis.logging.Logger: Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession51e4ccb3] DEBUG 2024-05-23 20:12:08,489 org.mybatis.logging.Logger: Creating a new SqlSession DEBUG 2024-05-23 20:12:08,490 org.mybatis.logging.Logger: SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession2ba33e2c] was not registered for synchronization because synchronization is not active DEBUG 2024-05-23 20:12:08,503 org.mybatis.logging.Logger: JDBC Connection [1242427797, URLjdbc:mysql://192.168.3.115:3306/ssm?useUnicodetrue;characterEncodingutf8, UserNameroot192.168.3.112, MySQL Connector/J] will not be managed by Spring DEBUG 2024-05-23 20:12:08,503 org.apache.ibatis.logging.jdbc.BaseJdbcLogger: Preparing: select id, role_name as roleName, note from t_role where id ? DEBUG 2024-05-23 20:12:08,504 org.apache.ibatis.logging.jdbc.BaseJdbcLogger: Parameters: 118(Long) DEBUG 2024-05-23 20:12:08,538 org.apache.ibatis.logging.jdbc.BaseJdbcLogger: Total: 1 DEBUG 2024-05-23 20:12:08,542 org.mybatis.logging.Logger: Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession2ba33e2c] DEBUG 2024-05-23 20:12:08,543 org.mybatis.logging.Logger: Creating a new SqlSession DEBUG 2024-05-23 20:12:08,543 org.mybatis.logging.Logger: SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession47547132] was not registered for synchronization because synchronization is not active DEBUG 2024-05-23 20:12:08,551 org.mybatis.logging.Logger: JDBC Connection [1700078557, URLjdbc:mysql://192.168.3.115:3306/ssm?useUnicodetrue;characterEncodingutf8, UserNameroot192.168.3.112, MySQL Connector/J] will not be managed by Spring DEBUG 2024-05-23 20:12:08,551 org.apache.ibatis.logging.jdbc.BaseJdbcLogger: Preparing: update t_role set role_name ?,note ? where id ? DEBUG 2024-05-23 20:12:08,552 org.apache.ibatis.logging.jdbc.BaseJdbcLogger: Parameters: role_name_sqlSessionTemplate(String), update_sqlSessionTemplate(String), 118(Long) DEBUG 2024-05-23 20:12:08,560 org.apache.ibatis.logging.jdbc.BaseJdbcLogger: Updates: 1 DEBUG 2024-05-23 20:12:08,561 org.mybatis.logging.Logger: Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession47547132] DEBUG 2024-05-23 20:12:08,561 org.mybatis.logging.Logger: Creating a new SqlSession DEBUG 2024-05-23 20:12:08,561 org.mybatis.logging.Logger: SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession5e1218b4] was not registered for synchronization because synchronization is not active DEBUG 2024-05-23 20:12:08,582 org.mybatis.logging.Logger: JDBC Connection [311788384, URLjdbc:mysql://192.168.3.115:3306/ssm?useUnicodetrue;characterEncodingutf8, UserNameroot192.168.3.112, MySQL Connector/J] will not be managed by Spring DEBUG 2024-05-23 20:12:08,582 org.apache.ibatis.logging.jdbc.BaseJdbcLogger: Preparing: select id, role_name as roleName, note from t_role where id ? DEBUG 2024-05-23 20:12:08,582 org.apache.ibatis.logging.jdbc.BaseJdbcLogger: Parameters: 118(Long) DEBUG 2024-05-23 20:12:08,589 org.mybatis.logging.Logger: Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession5e1218b4]从日志中不难看出没执行一个SqlSessionTemplate方法它都会重新获取一个新的SqlSession这意味着它是线程安全的然而这种用法争议颇多它需要使用字符串表明运行哪个SQL字符串没有业务含义只是功能性代码不符合面向对象的思想并且使用字符串IDE无法检查代码逻辑的正确性并且要注意SqlSessionTemplate允许配置执行器的类型当同时配置SqlSessionFactory和SqlSessionTemplate时SqlSessionTemplate的优先级会大于SqlSessionFactory 配置MapperFactoryBean MyBatis的运行只需要提供类似于RoleDao这样的接口而无需提供其实现类它是由MyBatis体系创建的动态代理对象运行的所以Spring也没办法为其生成实现类MyBatis-Spring提供了一个MapperFactoryBean类作为媒介可以通过它来实现想要的Mapper使用Mapper接口编程方式可以有效地在开发者的逻辑代码中擦除SqlSessionTemplate这样代码就按照面向对象的规范编写了 接下来配置RoleDao的映射器对象 !-- 定义一个名为roleDao的bean其类型为org.mybatis.spring.mapper.MapperFactoryBean --bean idroleDao classorg.mybatis.spring.mapper.MapperFactoryBean!-- 设置mapperInterface属性指明RoleDao接口的位置 --property namemapperInterface valuecom.sdb.dao.RoleDao/!-- 将sqlSessionFactory引用赋值给sqlSessionFactory属性确保角色数据访问对象可以使用它来进行数据库操作 --property namesqlSessionFactory refsqlSessionFactory/!-- 下面的注释掉的代码块是一种备选配置可以使用sqlSessionTemplate来进行更直接的SQL会话控制 --!-- 如果同时注入sqlSessionTemplate和sqlSessionFactory则sqlSessionFactory将不会被使用 --!--property namesqlSessionTemplate refsqlSessionTemplate/--/beanorg.mybatis.spring.mapper.MapperFactoryBean是映射器接口配置了这样一个bean之后就可以使用代码RoleDao roleDao ctx.getBean(RoleDao.class)获取映射器了然而如果一个个这样配置就会巨麻烦MyBatis提供了一个类MapperScannerConfigurer通过它可以用扫描的形式创建对应的Mapper 配置MapperScannerConfigurer MapperScannerConfigurer 是 MyBatis-Spring 框架中的一个类它的主要作用是自动扫描指定包下的 Mapper 接口并将它们注册为 Spring 容器中的 Bean这样你就可以在应用中直接通过依赖注入来使用这些 Mapper 对象而无需手动为每个 Mapper 接口创建一个单独的配置。 以下是 MapperScannerConfigurer 的主要配置项 basePackage:这个属性是必需的用于指定包含 Mapper 接口的基包。MyBatis-Spring 将扫描这个包及其子包下所有标记为 Mapper注解的接口或者如果没有使用自定义注解那么默认所有的接口都会被扫描。示例property namebasePackage valuecom.example.myapp.mapper /markerInterface:可选属性用于指定一个特定的接口作为标记。只有实现了这个接口的类才会被扫描。这可以用于过滤当你不想扫描所有接口时。示例property namemarkerInterface valuecom.example.myapp.MarkerMapper /annotationClass:可选属性用于指定一个注解类。只有标记了这个注解的接口才会被扫描。这与 markerInterface类似但适用于注解而不是接口。示例property nameannotationClass valuecom.example.myapp.MyMapperAnnotation /sqlSessionFactory 或 sqlSessionTemplate:这两个属性用于指定与 Mapper接口关联的 SqlSessionFactory或 SqlSessionTemplate实例。MyBatis-Spring 使用这些来创建每个 Mapper Bean,通常sqlSessionFactory被使用它是一个标准的MyBatis数据源配置而 sqlSessionTemplate提供了更细粒度的控制但不是所有情况都适用。示例property namesqlSessionFactory refsqlSessionFactory /nameGenerator:可选属性用于指定生成 Mapper Bean ID的策略。默认情况下Mapper Bean 的 ID 是接口名的小写形式但你可以通过提供一个自定义的 NameGenerator 类来改变这一行为。proxyInterfaces:可选属性允许你指定一个接口列表MapperFactoryBean会为每个 Mapper创建一个代理实现这些接口。这在需要动态代理例如使用 AOP的情况下很有用。addMappings:可选属性允许你添加额外的 XML 映射文件这些文件不在 Mapper接口所在的包中。sqlSessionFactoryBeanName 和 sqlSessionTemplateBeanName:它们分别用于指定在 Spring 容器中 SqlSessionFactory 和 SqlSessionTemplate对应的Bean名称 sqlSessionFactoryBeanName指定了SqlSessionFactory的Bean名称MapperScannerConfigurer使用这个名称来查找并关联 SqlSessionFactory 实例。如果你在配置中定义了一个名为sqlSessionFactory的Bean那么这个属性的默认值就是 sqlSessionFactory。如果你的SqlSessionFactory Bean使用了不同的名称你需要在这里指定。示例配置property namesqlSessionFactoryBeanName valuemyCustomSqlSessionFactory / sqlSessionTemplateBeanName:用于指定SqlSessionTemplate的Bean名称。如果使用SqlSessionTemplate而不是直接使用 SqlSessionFactoryMapperScannerConfigurer将使用这个模板来创建Mapper Bean。如果未设置通常会默认使用 sqlSessionFactoryBeanName找到的SqlSessionFactory来创建 SqlSessionTemplate。示例配置property namesqlSessionTemplateBeanName valuemyCustomSqlSessionTemplate /, 如果配置了sqlSessionTemplateBeanName那么sqlSessionFactoryBeanName将失效 其他一些属性如 useAnnotation、stopOnErrors 等提供了更高级别的控制但一般情况下上述的几个主要属性已经足够满足大部分需求。 在Spring配置前需要给映射器接口注入一个注解在Spring中往往使用注解Repository表示DAO层但在MyBatis中使用注解Mapper 根据上述内容改造一下RoleDao代码如下 package com.sdb.dao;import com.sdb.pojo.Role; import org.apache.ibatis.annotations.Mapper; import org.apache.ibatis.annotations.Param; /*** RoleDao接口定义了角色数据访问层的方法*/ Mapper public interface RoleDao {/*** 插入角色信息* param role 角色对象包含角色信息* return 返回插入操作影响的行数*/public int insertRole(Role role);/*** 根据ID获取角色信息* param id 角色ID用于查询特定角色* return 返回查询到的角色对象如果不存在则返回null*/public Role getRole(Param(id) Long id);/*** 更新角色信息* param role 角色对象包含需要更新的角色信息* return 返回更新操作影响的行数*/public int updateRole(Role role);/*** 根据ID删除角色信息* param id 角色ID用于指定删除的角色* return 返回删除操作影响的行数*/public int deleteRole(Param(id) Long id); } 代码中加入了注解Mapper的引入它表示这是一个MyBatis的映射器接口然后还需要通过XML告诉Spring扫描这个package这样就会扫出对应的映射器接口到SpringIoC容器中了 !-- 定义MapperScannerConfigurer bean用于扫描标记了Mapper注解的DAO接口 --bean idmapperScanner classorg.mybatis.spring.mapper.MapperScannerConfigurer!-- 指定扫描的基包包下所有标记了Mapper注解的接口会被注册为MyBatis的Mapper --property namebasePackage valuecom.sdb.dao/!-- 指定SqlSessionFactory的bean名称用于构建SqlSessionTemplate --property namesqlSessionFactoryBeanName valuesqlSessionFactory/!-- 指定SqlSessionTemplate的bean名称使用sqlSessionTemplateBeanName将覆盖默认的sqlSessionFactoryBeanName --property namesqlSessionTemplateBeanName valuesqlSessionTemplate/!-- 指定扫描时关注的注解这里指定为Mapper意味着标记了Mapper的接口会被扫描到 --property nameannotationClass valueorg.apache.ibatis.annotations.Mapper //bean对于多个package的扫描可以用逗号隔开 还有一种形式使用扩展接口名的方式限制扫描接口例如先定义一个基础接口没任何逻辑只用于标记 package com.sdb.dao;public interface BaseDao {}然后RoleDao扩展BaseDao代码如下 package com.sdb.dao;import com.sdb.pojo.Role; import org.apache.ibatis.annotations.Mapper; import org.apache.ibatis.annotations.Param; /*** RoleDao接口定义了角色数据访问层的方法*/ Mapper public interface RoleDao extends BaseDao {/*** 插入角色信息* param role 角色对象包含角色信息* return 返回插入操作影响的行数*/public int insertRole(Role role);/*** 根据ID获取角色信息* param id 角色ID用于查询特定角色* return 返回查询到的角色对象如果不存在则返回null*/public Role getRole(Param(id) Long id);/*** 更新角色信息* param role 角色对象包含需要更新的角色信息* return 返回更新操作影响的行数*/public int updateRole(Role role);/*** 根据ID删除角色信息* param id 角色ID用于指定删除的角色* return 返回删除操作影响的行数*/public int deleteRole(Param(id) Long id); }然后修改映射的XML文件代码如下 !-- 定义MapperScannerConfigurer bean用于扫描标记了Mapper注解的DAO接口 --bean idmapperScanner2 classorg.mybatis.spring.mapper.MapperScannerConfigurer!-- 指定扫描的基包包下所有标记了Mapper注解的接口会被注册为MyBatis的Mapper --property namebasePackage valuecom.sdb.dao/!-- 指定SqlSessionFactory的bean名称用于构建SqlSessionTemplate --property namesqlSessionFactoryBeanName valuesqlSessionFactory/!-- 指定SqlSessionTemplate的bean名称使用sqlSessionTemplateBeanName将覆盖默认的sqlSessionFactoryBeanName --property namesqlSessionTemplateBeanName valuesqlSessionTemplate/!-- 指定扫描时关注的注解这里指定为Mapper意味着标记了Mapper的接口会被扫描到 --property nameannotationClass valueorg.apache.ibatis.annotations.Mapper /!-- 指定markerInterface属性的值为com.sdb.dao.BaseDao --property namemarkerInterface valuecom.sdb.dao.BaseDao//bean定制扫描 除了使用MapperScannerConfigurer定制扫描还可以使用mybatis:scan或者注解MapperScan定制扫描使用mybatis:scan定制扫描需要引入对应的命名空间和XML模式定义(XSD) ?xml version1.0 encodingUTF-8? beans xmlnshttp://www.springframework.org/schema/beansxmlns:xsihttp://www.w3.org/2001/XMLSchema-instancexmlns:contexthttp://www.springframework.org/schema/contextxmlns:aophttp://www.springframework.org/schema/aopxmlns:mybatishttp://mybatis.org/schema/mybatis-springxsi:schemaLocationhttp://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-4.0.xsdhttp://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context-4.0.xsdhttp://www.springframework.org/schema/aophttp://www.springframework.org/schema/aop/spring-aop-4.0.xsdhttp://mybatis.org/schema/mybatis-springhttp://mybatis.org/schema/mybatis-spring.xsd!-- 定制扫描 --mybatis:scan base-packagecom.sdb.daoannotationorg.apache.ibatis.annotations.Mapperfactory-refsqlSessionFactorytemplate-refsqlSessionTemplate/base-package指定需要扫描的包病扫描到子包annotation限定扫描的注解只有接口被该注解标注后才会扫描为MyBatis的映射接口factory-ref定义SqlSessionFactory的引用其值是SqlSessionFactory的Bean名称如果SpringIoC容器中只有一个SqlSessionFactory那么可以省略不配置如果多个则需要指明template-ref定义SqlSessionTemplate的引用其值是一个SqlSessionTemplate的Bean名称如果SpringIoC中只有一个SqlSessionTemplate那么可以省略不配置如果多个则需要指明同样的也可以配置marker-interface等等且同样的如果同时配置了factory-ref和template-ref,那么template-ref将覆盖掉factory-ref 自定义配置扫描 package com.sdb.config;import java.util.Properties;import javax.sql.DataSource;import org.apache.commons.dbcp2.BasicDataSourceFactory; import org.apache.ibatis.annotations.Mapper; import org.apache.ibatis.session.SqlSessionFactory; import org.mybatis.spring.SqlSessionFactoryBean; import org.mybatis.spring.SqlSessionTemplate; import org.mybatis.spring.annotation.MapperScan; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.ComponentScan; import org.springframework.context.annotation.Configuration; import org.springframework.core.io.ClassPathResource; import org.springframework.core.io.Resource; /*** MyBatis配置类用于配置数据源、SqlSessionFactory和SqlSessionTemplate。*/ Configuration MapperScan(basePackages com.sdb.dao, annotationClass Mapper.class, sqlSessionFactoryRef sqlSessionFactory, sqlSessionTemplateRef sqlSessionTemplate) ComponentScan(basePackagescom.sdb) public class MyBatisConfig {/*** 创建数据源。** return 返回配置好的DataSource实例。*/Bean(name dataSource, destroyMethod close)public DataSource createDataSource() {Properties props new Properties();// 配置数据库连接信息props.setProperty(driver, com.mysql.jdbc.Driver);props.setProperty(url, jdbc:mysql://localhost:3306/ssm);props.setProperty(username, root);props.setProperty(password, 123456);DataSource dataSource null;try {// 使用Apache DBCP创建数据源dataSource BasicDataSourceFactory.createDataSource(props);} catch (Exception e) {e.printStackTrace();}return dataSource;}/*** 创建SqlSessionFactory。** param dataSource 数据源* return 返回配置好的SqlSessionFactory实例。* throws Exception 如果配置失败抛出异常。*/Bean(sqlSessionFactory)public SqlSessionFactory createSqlSessionFactoryBean(Autowired DataSource dataSource) throws Exception {// 配置MyBatis的配置文件路径String cfgFile mybatis-config.xml;SqlSessionFactoryBean sqlSessionFactoryBean new SqlSessionFactoryBean();sqlSessionFactoryBean.setDataSource(dataSource);// 设置配置文件位置Resource configLocation new ClassPathResource(cfgFile);sqlSessionFactoryBean.setConfigLocation(configLocation);return sqlSessionFactoryBean.getObject();}/*** 创建SqlSessionTemplate。** param sqlSessionFactory SqlSessionFactory实例* return 返回配置好的SqlSessionTemplate实例。*/Bean(sqlSessionTemplate)public SqlSessionTemplate createSqlSessionTemplate(Autowired SqlSessionFactory sqlSessionFactory) {SqlSessionTemplate sqlSessionTemplate new SqlSessionTemplate(sqlSessionFactory);return sqlSessionTemplate;} } 顺道再提一下Autowired注解在Spring框架中当你在spring-cfg.xml或其他Spring配置文件中定义了一个DataSource的bean并且在Java类中使用Autowired注解了一个DataSource类型的字段或方法参数时Spring会自动将配置文件中定义的DataSource bean注入到Java代码中相应的位置。Spring容器在启动时会读取配置文件创建bean的实例并根据Autowired的指令进行依赖注入。这样你就不需要在代码中手动去查找和创建bean提高了代码的可测试性和可维护性其他代码直接看就行 其实大同小异然后就可以进行测试了如下代码所示 package com.sdb.main;import org.mybatis.spring.SqlSessionTemplate; import org.springframework.context.ApplicationContext; import org.springframework.context.annotation.AnnotationConfigApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; import com.sdb.pojo.Role; import com.sdb.dao.RoleDao; import com.sdb.config.MyBatisConfig;/*** MyBatis主程序类用于演示通过Spring和MyBatis整合进行数据库操作。*/ public class MyBatisMain {/*** 程序入口方法调用testXmlConfig测试通过XML配置的Spring和MyBatis功能。** param args 命令行参数*/public static void main(String[] args) {testXmlConfig() ;}/*** 测试通过XML配置文件初始化SpringApplicationContext并使用SqlSessionTemplate进行数据库操作。*/private static void testXmlConfig() {// 初始化Spring应用上下文ApplicationContext ctx new ClassPathXmlApplicationContext(spring-cfg.xml);// 从Spring上下文中获取SqlSessionTemplate实例SqlSessionTemplate sqlSessionTemplate ctx.getBean(SqlSessionTemplate.class);// 创建Role对象并设置属性Role role new Role() ;role.setRoleName(role_name_sqlSessionTemplate);role.setNote(note_sqlSessionTemplate);// 操作数据库插入角色String prefix com.sdb.dao.RoleDao;sqlSessionTemplate.insert(prefix .insertRole, role);// 通过ID获取角色信息Long id role.getId();sqlSessionTemplate.selectOne(prefix .getRole, id);// 更新角色信息role.setNote(update_sqlSessionTemplate);sqlSessionTemplate.update(prefix .updateRole, role);// 删除角色sqlSessionTemplate.delete(prefix .deleteRole, id);}private static void testAnnotationConfig() {ApplicationContext ctx new AnnotationConfigApplicationContext(MyBatisConfig.class);RoleDao roleDao ctx.getBean(RoleDao.class);Role role roleDao.getRole(2L);System.out.println(role.getRoleName());}private static void testXmlConfig2() {ApplicationContext ctx new ClassPathXmlApplicationContext(spring-cfg.xml);RoleDao roleDao ctx.getBean(RoleDao.class);Role role roleDao.getRole(2L);System.out.println(role.getRoleName());} }