Spring集成MyBatis

迷失的小鹿 迷失的小鹿 博客等级 墨衍会员 · AI 创作全网分发 墨衍智能分发 本文由作者通过墨衍一键同步至各平台 1分发平台 300+累计阅读 356平均单平台 已同步平台 优快云 微信公众号 微博 知乎 掘金 百家号 博客园 抖音 小红书 你的文章也可以这样分发 墨衍会员 ¥399起/年，写一次发全网 我也要 码龄8年
关注
原创 最新推荐文章于 2026-07-09 16:30:32 发布 356 阅读 AI 写同款· GEO 优化 ›
Qt上位机实战：5步搞定STM32 IAP固件升级（附拖拽文件处理技巧） 本文详细介绍了如何使用Qt开发STM32 IAP固件升级上位机。通过五个核心步骤，包括理解IAP机制、搭建Qt环境、实现拖拽文件加载、封装串口通信以及设计可靠通信协议，帮助开发者快速构建一个稳定、易用且支持图形化操作的固件升级工具，显著提升嵌入式产品开发与维护效率。 阅读详情

Spring集成MyBatis的方式

使用Mapper映射器

导包

	<dependencies>
		<!--springmvc依赖的jar包 -->
		<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-webmvc</artifactId>
			<version>5.2.5.RELEASE</version>
		</dependency>
		<!-- mybatis的jar包 -->
		<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
		<dependency>
			<groupId>org.mybatis</groupId>
			<artifactId>mybatis</artifactId>
			<version>3.5.4</version>
		</dependency>
		<!-- mybatis和spring整合的jar包 -->
		<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis-spring -->
		<dependency>
			<groupId>org.mybatis</groupId>
			<artifactId>mybatis-spring</artifactId>
			<version>2.0.4</version>
		</dependency>
		<!--springjdbc的jar包  -->
		<!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-jdbc</artifactId>
			<version>5.2.5.RELEASE</version>
		</dependency>
		<!-- mysql的jar包 -->
		<!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>8.0.19</version>
		</dependency>
		<!-- junit单元测试 -->
		<!-- https://mvnrepository.com/artifact/junit/junit -->
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.12</version>
			<scope>test</scope>
		</dependency>
		<!--数据库连接池 dbcp -->
		<dependency>
			<groupId>commons-dbcp</groupId>
			<artifactId>commons-dbcp</artifactId>
			<version>1.4</version>
		</dependency>
	</dependencies>

添加Spring配置文件

MyBatis配置文件的内容变成了一个bean (SqlSessionFactoryBean)

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:jdbc="http://www.springframework.org/schema/jdbc"
	xmlns:jee="http://www.springframework.org/schema/jee"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:mvc="http://www.springframework.org/schema/mvc"
	xmlns:util="http://www.springframework.org/schema/util"
	xmlns:jpa="http://www.springframework.org/schema/data/jpa"
	xsi:schemaLocation="
		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd
		http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.2.xsd
		http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.2.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
		http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa-1.3.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
		http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd
		http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.2.xsd">


	<context:property-placeholder
		location="classpath:db.properties" />
	<!-- 配置数据库连接池 -->
	<bean class="org.apache.commons.dbcp.BasicDataSource" id="ds" destroy-method="close">
		<property name="driverClassName" value="${jdbc.driver}" />
		<property name="url" value="${jdbc.url}" />
		<property name="username" value="${jdbc.username}" />
		<property name="password" value="${jdbc.password}" />
	</bean>
	<!-- 配置SqlSessionFactoryBean -->
	<!-- 该bean的作用是用来代替MyBatis配置文件 -->
	<bean class="org.mybatis.spring.SqlSessionFactoryBean"
		id="sqlSessionFactory">
		<!-- 指定连接池 -->
		<property name="dataSource" ref="ds" />
		<!-- 指定映射文件位置 -->
		<property name="mapperLocations"
			value="classpath:entity/*.xml" />
	</bean>
	<!-- 配置MapperScannerConfigurer -->
		 <!-- 
		 	 该bean会扫描指定包及其子包下面的所有的Mapper
		 	 映射器（接口），然后生成符合该接口要求的对象
		 	 （通过调用SqlSession的getMapper方法），接下来，
		 	 会将这些对象（即Mapper映射器的实现对象）添加到
		 	 Spring容器里面（默认的id是首字母小写之后的接口名）。
		  -->
	<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
		<property name="basePackage" value="dao"/>
	</bean>
</beans>

实体类

package entity;

public class Employee {
	private int id;
	private String ename;
	private double salary;
	private int age;

	public String toString() {
		return "Employee [id=" + id + ", ename=" + ename + ", salary=" + salary + ", age=" + age + "]";
	}

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getEname() {
		return ename;
	}

	public void setEname(String ename) {
		this.ename = ename;
	}

	public double getSalary() {
		return salary;
	}

	public void setSalary(double salary) {
		this.salary = salary;
	}

	public int getAge() {
		return age;
	}

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


package entity;

public class Emp2 {
	private int empNo;
	private String name;
	private double salary;
	private int age;
	
	public String toString() {
		return "Emp2 [empNo=" + empNo + ", name=" + name + ", salary=" + salary + ", age=" + age + "]";
	}
	
	public int getEmpNo() {
		return empNo;
	}
	public void setEmpNo(int empNo) {
		this.empNo = empNo;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public double getSalary() {
		return salary;
	}
	public void setSalary(double salary) {
		this.salary = salary;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
}

映射文件

<?xml version="1.0" encoding="UTF-8" ?>  
<!DOCTYPE mapper PUBLIC "-//ibatis.apache.org//DTD Mapper 3.0//EN"      
 "http://ibatis.apache.org/dtd/ibatis-3-mapper.dtd">

<mapper namespace="dao.EmployeeDAO">
	<!-- 
		id:每一条sql语句都有唯一的id,称之为sqlId。
		parameterType:参数类型（如果是类，要写全限定名）
	 -->
	<insert id="save" parameterType="entity.Employee">
		INSERT INTO t_emp VALUES(null,
		#{ename},#{salary},#{age})
	</insert>
	
	<!-- 
		resultType: 返回类型（如果是类，要写全限定名）
	 -->
	<select id="findAll" 
		resultType="entity.Employee">
		SELECT * FROM t_emp
	</select>
	
	
	<select id="findById" parameterType="int" 
	resultType="entity.Employee">
		SELECT * FROM t_emp WHERE id = #{id1}
	</select>
	
	<update id="update" 
		parameterType="entity.Employee">
		UPDATE t_emp SET ename = #{ename},
		salary = #{salary},age = #{age} 
		WHERE id = #{id}
	</update>
	
	<delete id="delete" parameterType="int">
		DELETE FROM t_emp WHERE id = #{id1}
	</delete>
	
	<!-- 返回Map类型的结果 -->
	<!-- 
		map是java.util.Map的简写形式。
	 -->
	<select id="findById2" parameterType="int" 
	resultType="map">
		SELECT * FROM t_emp WHERE id = #{id1}
	</select>
	
	<!-- 
		设置字段名与实体类的属性名的对应关系。
		注：
			只需要将不一致的列出来。
	 -->
	<resultMap type="entity.Emp2" id="empResultMap">
		<result property="empNo" column="id"/>
		<result property="name" column="ename"/>
	</resultMap>
	<select id="findById3" parameterType="int"
	resultMap="empResultMap">
		SELECT * FROM t_emp WHERE id = #{id1}
	</select>
</mapper>

Mapper映射器

package dao;
import java.util.List;
import java.util.Map;
import entity.Employee;
/**
 * Mapper映射器
 *
 */
public interface EmployeeDAO {
	public void save(Employee emp);
	public List<Employee> findAll();
	public Employee findById(int id);
	public void update(Employee e);
	public void delete(int id);
	public Map findById2(int id);
}

配置MapperScannerConfigurer

该bean会扫描指定包及其子包下面的所有的 Mapper映射器（接口）,
会调用SqlSession的getMapper方法返回Mapper映射器的实现对象，
并且将这些对象添加到Spring容器里面。
（默认的id是首字母小写之后的接口名）

在spring和mybatis整合的配置文件spring-mybatis.xml中添加如下配置

<!-- 配置MapperScannerConfigurer -->
		 <!-- 
		 	 该bean会扫描指定包及其子包下面的所有的Mapper
		 	 映射器（接口），然后生成符合该接口要求的对象
		 	 （通过调用SqlSession的getMapper方法），接下来，
		 	 会将这些对象（即Mapper映射器的实现对象）添加到
		 	 Spring容器里面（默认的id是首字母小写之后的接口名）。
		  -->
	<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
		<property name="basePackage" value="dao"/>
	</bean>

测试程序

package test;

import org.junit.Before;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import dao.EmployeeDAO;
import entity.Employee;

public class TestCase {
	private EmployeeDAO dao;
	@Before
	public void before() {
		ApplicationContext ac=new ClassPathXmlApplicationContext("spring-mybatis.xml");
		dao=ac.getBean("employeeDAO",EmployeeDAO.class);
	}
	@Test
	public void save() {
		Employee e=new Employee();
		e.setEname("王老师");
		e.setSalary(20000);
		e.setAge(18);
		dao.save(e);
	}
}

只扫描带有特定注解的Mapper映射器

  1. 开发一个注解
  2. 将注解添加到Mapper映射器上面
  3. 配置MapperScannerConfigurer

依赖的jar包

<dependencies>
		<!--导入junit测试包 -->
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.12</version>
		</dependency>

		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.12</version>
			<classifier>sources</classifier>
		</dependency>

		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.12</version>
			<classifier>javadoc</classifier>
		</dependency>

		<!-- 导入数据库包 -->
		<dependency>
			<groupId>commons-dbcp</groupId>
			<artifactId>commons-dbcp</artifactId>
			<version>1.4</version>
		</dependency>
		<!-- 导入mybatis的包 -->
		<dependency>
			<groupId>org.mybatis</groupId>
			<artifactId>mybatis</artifactId>
			<version>3.4.0</version>
		</dependency>

		<dependency>
			<groupId>org.mybatis</groupId>
			<artifactId>mybatis</artifactId>
			<version>3.2.8</version>
			<classifier>sources</classifier>
		</dependency>

		<dependency>
			<groupId>org.mybatis</groupId>
			<artifactId>mybatis</artifactId>
			<version>3.2.8</version>
			<classifier>javadoc</classifier>
		</dependency>

		<!-- 针对mysql的导包 -->
		<dependency>
			<groupId>org.wisdom-framework</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>5.1.34_1</version>
		</dependency>

		<!-- 导入spring-webmvc的jar包 -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-webmvc</artifactId>
			<version>4.2.3.RELEASE</version>
		</dependency>

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-webmvc</artifactId>
			<version>4.2.3.RELEASE</version>
			<classifier>sources</classifier>
		</dependency>

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-webmvc</artifactId>
			<version>4.2.3.RELEASE</version>
			<classifier>javadoc</classifier>
		</dependency>

		<!-- 针对spring JDBC导包 -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-jdbc</artifactId>
			<version>4.2.3.RELEASE</version>
		</dependency>

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-jdbc</artifactId>
			<version>4.2.3.RELEASE</version>
			<classifier>sources</classifier>
		</dependency>

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-jdbc</artifactId>
			<version>4.2.3.RELEASE</version>
			<classifier>javadoc</classifier>
		</dependency>

		<!-- 关键：导入mybatis-spring -->
		<dependency>
			<groupId>org.mybatis</groupId>
			<artifactId>mybatis-spring</artifactId>
			<version>1.3.2</version>
		</dependency>

		<dependency>
			<groupId>org.mybatis</groupId>
			<artifactId>mybatis-spring</artifactId>
			<version>1.3.2</version>
			<classifier>sources</classifier>
		</dependency>

		<dependency>
			<groupId>org.mybatis</groupId>
			<artifactId>mybatis-spring</artifactId>
			<version>1.3.2</version>
			<classifier>javadoc</classifier>
		</dependency>
	</dependencies>

spring和mybatis整合的配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:jdbc="http://www.springframework.org/schema/jdbc"
	xmlns:jee="http://www.springframework.org/schema/jee"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:mvc="http://www.springframework.org/schema/mvc"
	xmlns:util="http://www.springframework.org/schema/util"
	xmlns:jpa="http://www.springframework.org/schema/data/jpa"
	xsi:schemaLocation="
		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd
		http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.2.xsd
		http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.2.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
		http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa-1.3.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
		http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd
		http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.2.xsd">


	<context:property-placeholder
		location="classpath:db.properties" />
	<!-- 配置数据库连接池 -->
	<bean class="org.apache.commons.dbcp.BasicDataSource" id="ds" destroy-method="close">
		<property name="driverClassName" value="${jdbc.driver}" />
		<property name="url" value="${jdbc.url}" />
		<property name="username" value="${jdbc.username}" />
		<property name="password" value="${jdbc.password}" />
	</bean>
	<!-- 配置SqlSessionFactoryBean -->
	<!-- 该bean的作用是用来代替MyBatis配置文件 -->
	<bean class="org.mybatis.spring.SqlSessionFactoryBean"
		id="sqlSessionFactory">
		<!-- 指定连接池 -->
		<property name="dataSource" ref="ds" />
		<!-- 指定映射文件位置 -->
		<property name="mapperLocations"
			value="classpath:entity/*.xml" />
	</bean>
	 <!-- 配置MapperScannerConfigurer -->
		 <!-- 
		 	 该bean会扫描指定包及其子包下面的所有的Mapper
		 	 映射器（接口），然后生成符合该接口要求的对象
		 	 （通过调用SqlSession的getMapper方法），接下来，
		 	 会将这些对象（即Mapper映射器的实现对象）添加到
		 	 Spring容器里面（默认的id是首字母小写之后的接口名）。
		  -->
	<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
		<!-- 指定要扫描的包 -->
		<property name="basePackage" value="dao" />
		<!-- 指定只扫描带有该注解的接口 -->
		<property name="annotationClass"
			value="annotations.MyBatisRepository" />
	</bean>
</beans>

数据库连接配置db.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/ems?useUnicode=true&characterEncoding=utf-8
jdbc.username=root
jdbc.password=root

实体类

package entity;

public class Employee {
	private int id;
	private String ename;
	private double salary;
	private int age;

	public String toString() {
		return "Employee [id=" + id + ", ename=" + ename + ", salary=" + salary + ", age=" + age + "]";
	}

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getEname() {
		return ename;
	}

	public void setEname(String ename) {
		this.ename = ename;
	}

	public double getSalary() {
		return salary;
	}

	public void setSalary(double salary) {
		this.salary = salary;
	}

	public int getAge() {
		return age;
	}

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

映射文件

<?xml version="1.0" encoding="UTF-8" ?>  
<!DOCTYPE mapper PUBLIC "-//ibatis.apache.org//DTD Mapper 3.0//EN"      
 "http://ibatis.apache.org/dtd/ibatis-3-mapper.dtd">

<mapper namespace="dao.EmployeeDAO">
	<!-- 
		id:每一条sql语句都有唯一的id,称之为sqlId。
		parameterType:参数类型（如果是类，要写全限定名）
	 -->
	<insert id="save" parameterType="entity.Employee" >
		INSERT INTO t_emp VALUES(null,
		#{ename},#{salary},#{age})
	</insert>
	
	<!-- 
		resultType: 返回类型（如果是类，要写全限定名）
	 -->
	<select id="findAll" 
		resultType="entity.Employee">
		SELECT * FROM t_emp
	</select>
	
	
	<select id="findById" parameterType="int" 
	resultType="entity.Employee">
		SELECT * FROM t_emp WHERE id = #{id1}
	</select>
	
	<update id="update" 
		parameterType="entity.Employee">
		UPDATE t_emp SET ename = #{ename},
		salary = #{salary},age = #{age} 
		WHERE id = #{id}
	</update>
	
	<delete id="delete" parameterType="int">
		DELETE FROM t_emp WHERE id = #{id1}
	</delete>
	
	<!-- 返回Map类型的结果 -->
	<!-- 
		map是java.util.Map的简写形式。
	 -->
	<select id="findById2" parameterType="int" 
	resultType="map">
		SELECT * FROM t_emp WHERE id = #{id1}
	</select>
	
	<!-- 
		设置字段名与实体类的属性名的对应关系。
		注：
			只需要将不一致的列出来。
	 -->
	<resultMap type="entity.Emp2" id="empResultMap">
		<result property="empNo" column="id"/>
		<result property="name" column="ename"/>
	</resultMap>
	<select id="findById3" parameterType="int"
	resultMap="empResultMap">
		SELECT * FROM t_emp WHERE id = #{id1}
	</select>
</mapper>

数据库访问层

package dao;

import java.util.List;
import java.util.Map;

import org.springframework.stereotype.Repository;

import annotations.MyBatisRepository;
import entity.Employee;
/**
 * Mapper映射器
 *
 */
@Repository
@MyBatisRepository
public interface EmployeeDAO {
	public void save(Employee emp);
	public List<Employee> findAll();
	public Employee findById(int id);
	public void update(Employee e);
	public void delete(int id);
	public Map findById2(int id);
}

自定义注解

package annotations;

public @interface MyBatisRepository {

}

测试程序

package test;

import java.util.List;

import org.junit.Before;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import dao.EmployeeDAO;
import entity.Employee;

public class TestCase {
	private EmployeeDAO dao;

	@Before
	public void before() {
		ApplicationContext ac = new ClassPathXmlApplicationContext("spring-mybatis.xml");
		dao = ac.getBean("employeeDAO", EmployeeDAO.class);
	}

	@Test
	public void save() {
		Employee e = new Employee();
		e.setEname("里老师");
		e.setSalary(20000);
		e.setAge(18);
		dao.save(e);
	}

	@Test
	public void findAll() {
		List<Employee> employees = dao.findAll();
		for (Employee employee : employees) {
			System.out.println(employee);
		}
	}
}

不使用Mapper映射器

实现步骤

  1. 导包spring-webmvc,mybatis,mybatis-spring,spring-jdbc，mysql,dbcp,junit
  2. 添加Spring配置文件,MyBatis配置文件的内容变成了一个bean (SqlSessionFactoryBean)
  3. 实体类
  4. 映射文件,namespace可以自定义
  5. DAO接口,方法名等不做要求
  6. DAO实现类
  7. 配置SqlSessionTemplate,可以将SqlSessionTemplate注入到DAO,然后调用SqlSessionTemplate提供的方法即可。SqlSessionTemplate封装了SqlSession,我们不用去考虑如何获得SqlSession,如何关闭
    SqlSession。

jar包的依赖

<dependencies>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-webmvc</artifactId>
			<version>3.2.8.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.mybatis</groupId>
			<artifactId>mybatis</artifactId>
			<version>3.2.8</version>
		</dependency>
		<dependency>
			<groupId>org.mybatis</groupId>
			<artifactId>mybatis-spring</artifactId>
			<version>1.2.2</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-jdbc</artifactId>
			<version>3.2.8.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>5.1.40</version>
		</dependency>
		<dependency>
			<groupId>commons-dbcp</groupId>
			<artifactId>commons-dbcp</artifactId>
			<version>1.4</version>
		</dependency>
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.12</version>
		</dependency>
	</dependencies>

数据库连接配置

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/ems?useUnicode=true&characterEncoding=utf-8
jdbc.username=root
jdbc.password=root

spring和mybatis整合的配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:jdbc="http://www.springframework.org/schema/jdbc"
	xmlns:jee="http://www.springframework.org/schema/jee"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:mvc="http://www.springframework.org/schema/mvc"
	xmlns:util="http://www.springframework.org/schema/util"
	xmlns:jpa="http://www.springframework.org/schema/data/jpa"
	xsi:schemaLocation="
		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd
		http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.2.xsd
		http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.2.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
		http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa-1.3.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
		http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd
		http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.2.xsd">


	<context:property-placeholder
		location="classpath:db.properties" />
	<!--数据库连接池的配置 -->
	<bean class="org.apache.commons.dbcp.BasicDataSource"
		destroy-method="close" id="ds">
		<property name="driverClassName" value="${jdbc.driver}" />
		<property name="url" value="${jdbc.url}" />
		<property name="username" value="${jdbc.username}" />
		<property name="password" value="${jdbc.password}" />
	</bean>
	<!-- 配置SqlSessionFactoryBean -->
		<!-- 
			该bean的作用是用来代替MyBatis配置文件
		 -->
	<bean class="org.mybatis.spring.SqlSessionFactoryBean"
		id="sqlSessionFactory">
		 <!-- 指定连接池 -->
		<property name="dataSource" ref="ds" />
		 <!-- 指定映射文件位置 -->
		<property name="mapperLocations"
			value="classpath:entity/*.xml" />
	</bean>
	 <!-- 配置SqlSessionTemplate -->
		 <!-- 
		 	SqlSessionTemplate封装了SqlSession的操作。
		  -->
	<bean id="st" class="org.mybatis.spring.SqlSessionTemplate">
	<!-- 指定SqlSessionFactoryBean -->
		<constructor-arg index="0" ref="sqlSessionFactory" />
	</bean>
	<!--组件扫描 -->
	<context:component-scan base-package="dao" />
</beans>

实体类

package entity;

public class Employee {
	private int id;
	private String ename;
	private double salary;
	private int age;

	public String toString() {
		return "Employee [id=" + id + ", ename=" + ename + ", salary=" + salary + ", age=" + age + "]";
	}

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getEname() {
		return ename;
	}

	public void setEname(String ename) {
		this.ename = ename;
	}

	public double getSalary() {
		return salary;
	}

	public void setSalary(double salary) {
		this.salary = salary;
	}

	public int getAge() {
		return age;
	}

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

}


package entity;

public class Emp2 {
	private int empNo;
	private String name;
	private double salary;
	private int age;
	
	public String toString() {
		return "Emp2 [empNo=" + empNo + ", name=" + name + ", salary=" + salary + ", age=" + age + "]";
	}
	
	public int getEmpNo() {
		return empNo;
	}
	public void setEmpNo(int empNo) {
		this.empNo = empNo;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public double getSalary() {
		return salary;
	}
	public void setSalary(double salary) {
		this.salary = salary;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
}

映射文件

<?xml version="1.0" encoding="UTF-8" ?>  
<!DOCTYPE mapper PUBLIC "-//ibatis.apache.org//DTD Mapper 3.0//EN"      
 "http://ibatis.apache.org/dtd/ibatis-3-mapper.dtd">

<mapper namespace="dao.EmployeeDAO">
	<!-- 
		id:每一条sql语句都有唯一的id,称之为sqlId。
		parameterType:参数类型（如果是类，要写全限定名）
	 -->
	<insert id="save" parameterType="entity.Employee">
		INSERT INTO t_emp VALUES(null,
		#{ename},#{salary},#{age})
	</insert>
	
	<!-- 
		resultType: 返回类型（如果是类，要写全限定名）
	 -->
	<select id="findAll" 
		resultType="entity.Employee">
		SELECT * FROM t_emp
	</select>
	
	
	<select id="findById" parameterType="int" 
	resultType="entity.Employee">
		SELECT * FROM t_emp WHERE id = #{id1}
	</select>
	
	<update id="update" 
		parameterType="entity.Employee">
		UPDATE t_emp SET ename = #{ename},
		salary = #{salary},age = #{age} 
		WHERE id = #{id}
	</update>
	
	<delete id="delete" parameterType="int">
		DELETE FROM t_emp WHERE id = #{id1}
	</delete>
	
	<!-- 返回Map类型的结果 -->
	<!-- 
		map是java.util.Map的简写形式。
	 -->
	<select id="findById2" parameterType="int" 
	resultType="map">
		SELECT * FROM t_emp WHERE id = #{id1}
	</select>
	
	<!-- 
		设置字段名与实体类的属性名的对应关系。
		注：
			只需要将不一致的列出来。
	 -->
	<resultMap type="entity.Emp2" id="empResultMap">
		<result property="empNo" column="id"/>
		<result property="name" column="ename"/>
	</resultMap>
	<select id="findById3" parameterType="int"
	resultMap="empResultMap">
		SELECT * FROM t_emp WHERE id = #{id1}
	</select>
</mapper>

持久层接口

package dao;

import java.util.List;
import java.util.Map;

import entity.Emp2;
import entity.Employee;

/**
 * DAO接口
 * 
 */

public interface EmployeeDAO {
	public void save(Employee emp);

	public List<Employee> findAll();

	public Employee findById(int id);

	public void update(Employee e);

	public void delete(int id);

	public Map findById2(int id);

	public Emp2 findById3(int id);
}

持久层接口的实现类

package dao;

import java.util.List;
import java.util.Map;

import javax.annotation.Resource;

import org.mybatis.spring.SqlSessionTemplate;
import org.springframework.stereotype.Repository;

import entity.Emp2;
import entity.Employee;

@Repository("empDao")
public class EmployeeDAOMyBatisImpl implements EmployeeDAO {
	@Resource(name = "st")
	SqlSessionTemplate st;

	/*
	 * 不用考虑提交事务和关闭SqlSession, SqlSessionTemplate已经处理了。
	 */
	public void save(Employee emp) {
		st.insert("dao.EmployeeDAO.save", emp);
	}

	public List<Employee> findAll() {
		return st.selectList("dao.EmployeeDAO.findAll");
	}

	public Employee findById(int id) {
		return st.selectOne("dao.EmployeeDAO.findById", id);
	}

	public void update(Employee e) {
		st.update("dao.EmployeeDAO.update", e);
	}

	public void delete(int id) {
		st.delete("dao.EmployeeDAO.delete", id);
	}

	public Map findById2(int id) {
		return st.selectOne("dao.EmployeeDAO.findById2", id);
	}

	public Emp2 findById3(int id) {
		return st.selectOne("dao.EmployeeDAO.findById3", id);
	}

}

测试程序

package test;

import java.util.List;

import org.junit.Before;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import dao.EmployeeDAO;
import dao.EmployeeDAOMyBatisImpl;
import entity.Employee;

public class TestCase {
	EmployeeDAO dao;
	@Before
	public void before() {
		ApplicationContext ac=new ClassPathXmlApplicationContext("spring-mybatis.xml");
		dao=ac.getBean("empDao",EmployeeDAOMyBatisImpl.class);
	}
	@Test
	public void save() {
		Employee emp=new Employee();
		emp.setEname("李老师");
		emp.setAge(20);
		emp.setSalary(5000);
		dao.save(emp);
	}
	@Test
	public void findAll() {
		List<Employee> findAll=dao.findAll();
		for (Employee employee : findAll) {
			System.out.println(employee);
		}
	}
}

注意

由于spring 3兼容jdk 7， spring 4兼容jdk 8，此测试程序的运行环境是jdk1.7，jdk1.8无法实现测试程序

收录于
tarenna

当前文章被收录于：

tarenna
11 篇文章 0 人学习

dalei培训

订阅专栏 查看详情
标签
#mybatis #spring #mysql #java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
088、多摄像头跨镜目标追踪 ID 频繁切换？ReID 特征 + 轨迹关联 + 时间约束方案 文章摘要：本文针对多摄像头跨镜目标追踪中ID频繁切换的问题，提出了一种结合ReID特征、轨迹关联和时间约束的综合解决方案。作者分析了ID切换的三个主要原因：ReID特征不稳定、轨迹关联依赖最近邻匹配以及忽略时间约束。通过改进ReID特征提取（多层特征融合）、引入轨迹预测（卡尔曼滤波）和添加时间窗口约束，成功将ID切换率从35%降至3%以下。文章详细分享了实现细节和踩坑经验，为跨摄像头目标追踪提供了实用优化思路。 阅读详情

相关推荐

第一章、isaacsim 及 isaaclab 安装教程

本专栏所有内容将根据上述资源地址展开，请结合食用～

m0_47719040的博客 4780

【MyBatis】spring整合mybatis教程（详细易懂）

Spring提供了一种轻量级的容器和依赖注入的机制，可以简化应用程序的配置和管理。会初始化N个数据库链接对象，一般在10个，当需要用户请求操作数据库时候，那么就会直接在数据库连接池中获取链接，用完放回连接池中。我们的实体类创建属性的时候我写get、set等方法，过于麻烦，但是我们有一个lombok，可以节约掉这些。这里是自己本地路径的MySQL的jar包，是需要更改的，路径赋值后也需要再加上。把我们的生成的BookMapper里面的方法复制到我们新建的BookBiz里面。选中对应的项目，依次选中生成。

无法自律的人的博客 9798

SAP FB03凭证修改实战：巧用BAPI FI_DOCUMENT_CHANGE更新抬头与行项目

本文详细介绍了SAP FB03凭证修改的实战技巧，重点解析了BAPI FI_DOCUMENT_CHANGE的使用方法。通过该接口，用户可以在不冲销原凭证的情况下直接更新抬头文本(BKTXT)和行项目文本(SGTXT)，确保凭证编号连续且符合审计要求。文章包含核心机制解析、完整实现步骤、错误处理方案以及高级应用场景，帮助开发者高效完成SAP财务凭证修改。

weixin_29251567的博客 424

【SSM】Spring系列——Spring集成MyBatis

将 MyBatis 与 Spring 进行整合，主要解决的问题就是将 SqlSessionFactory 对象交由 Spring 来管理。所以，该整合只需要将 SqlSessionFactory 的对象生成器 SqlSessionFactoryBean 注册在 Spring 容器中，再将其注入给 Dao 的实现类即可完成整合。实现 Spring 与 MyBatis 的整合。常用的方式：扫描的 Mapper 动态代理。Spring 像插线板一样，mybatis 框架是插头，可以容易的组合到一起。插线板 spr

胖虎虎 1468

Hermes+MemOS记忆系统：用SQLite构建可编辑AI个人认知资产

AI记忆不是简单延长上下文或叠加RAG，而是构建具备分层存储、混合检索与自然语言反馈能力的个人认知资产。其核心原理在于将用户交互痕迹（L1）、偏好策略（L2）、结构化世界模型（L3）和结晶化技能统一管理，实现记忆的可追溯、可修正、可进化。技术价值体现在降低token消耗、提升长程一致性、支持离线演进，并突破传统‘静态快照’式知识库局限。典型应用场景包括个人知识助手、客服工单分析Agent、研发文档理解系统等。本文聚焦Hermes Agent与MemOS深度集成方案，详解SQLite作为ACID底座支撑L1/

weixin_33623304的博客 434

ldpc编解码器设计与仿真

计算校验节点到变量节点的消息 m_{c \to v}=2 \cdot atanh(\prod_{v’ \in N©\setminus v}tanh(\frac{m_{v’ \to c}}{2}))。计算变量节点到校验节点的消息 m_{v \to c}=L_{v,0}+\sum_{c’ \in M(v)\setminus c}m_{c’ \to v}。◦ 对于每个变量节点 v，计算最终 LLR 值 L_{v,f}=L_{v,0}+\sum_{c \in M(v)}m_{c \to v}。

youngerwang的博客 808

Spring整合Mybatis

在spring整合mybatis之前我们回顾一下mybatis的实现步骤。

qq_45794852的博客 1051

在VScode中配置Python开发环境（详细图片文字结合）

需要用到的软件下载包在官网里找一下，在window下的点击安装就行了；找一个3.8到3.10版本差不多都完善跟的上；

m0_72811193的博客 1599

Spring 集成Mybatis

MyBatisSpringSqISessionFactory对象Spring实现思路： 实现Spring与MyBatis的整合常用的方式:扫描的Mapper动态代理。Spring像插线板一样, mybatis 框架是插头,可以容易的组合到一起。插线板spring插上mybatis,两个框架就是一个整体。

H931053的博客 590

OpenMMLab实战指南：从环境搭建到首个检测模型运行

本文是一份详细的OpenMMLab实战指南，重点介绍了如何从零开始搭建环境并运行首个目标检测模型。内容涵盖Miniconda环境配置、PyTorch与CUDA版本匹配、使用MIM工具安装MMCV和MMDetection的核心步骤，并通过RTMDet-tiny模型演示了完整的推理流程，帮助开发者高效入门这一计算机视觉开源算法体系。

weixin_28678151的博客 157

[个人自用，全网最优]EDEM-FLUENT个人自学教程，拒绝手忙脚乱无用功!

[个人自用，全网最优]EDEM-FLUENT个人自学教程，拒绝手忙脚乱无用功!

zheaa的博客 4828

一文吃透Spring集成MyBatis

spring能集成很多的框架，是spring一个优势功能。通过集成功能，让开发人员使用其他框架更方便。集成使用的是spring ioc 核心技术。使用mybatis，需要创mybatis框架中的某些对象，使用这些对象，就能使用mybatis提供的功能了。 分析: mybatis执行sql语句，需要使用那些对象? 1. 需要有Dao接口的代理对象，例如StudentDao接口,需要一个它的代理对象，使用 SqlSession.getMapper(StudentDao.class)，得到dao代理对象。

YOU__FEI的博客 9539

全局–局部傅里叶神经算子（GL-FNO）：原理、严格推导与 PINN 混合策略

本文提出了一种全局-局部傅里叶神经算子(GL-FNO)及其与物理信息神经网络(PINN)的结合方法。主要内容包括： 架构设计：GL-FNO包含两个分支 - 全局分支处理低频结构，使用下采样输入；局部分支处理高频细节，使用全分辨率输入。两分支通过自适应门控机制融合。 理论分析：证明了GL-FNO在"低频全局+高频局部"任务上的优势，给出了误差分解和复杂度分析，并推导了与PINN结合时的渐进一致性条件。 实现方法：采用频谱微分计算物理残差，推导了完整的训练流程，包括数据损失与物理损失的联合优

VectorShift的博客 1331

MyBatis 集成spring框架

MyBatis 与 Spring 的集成为开发者提供了强大的数据持久化解决方案。通过 MyBatis，开发者可以灵活地编写 SQL 并进行高效的数据库交互，而 Spring 的事务管理、依赖注入、AOP 等功能则增强了持久层的管理能力。在实际项目中，可以根据业务需求选择注解或 XML 方式进行 SQL 映射，并利用 Spring 的强大功能实现数据操作的稳定性和可维护性。

Flying_Fish_roe的博客 2022

廖雪峰Python教程[完整版]

廖雪峰的python教程整理的，已经排好版了，而且还是完整的，适合小白

VB摄像头监控

该VB模块可对摄像头捕获的画面进行录像等，可在创建的窗口进行控制

SSM Spring MVC集成mybatis

完成部门基本的 CRUD 和分页查询，完成员工基本的 CRUD、分页查询和过滤查询（根据姓名和邮箱模糊查询，根据部门查询）。

m0_63600788的博客 1611

汉书HE8，好用的汇编代码编写工具

汉书HE8，好用的汇编代码编写工具早期编写汇编代码所用功能强大

Spring Boot 集成 MyBatis 全面讲解

ResultMap用于自定义数据库字段与 Java 对象属性的映射。它支持嵌套映射、别名和字段处理，适合复杂的对象映射场景。SqlSessionMapper配置文件和ResultMap是 MyBatis 的核心概念。通过灵活的配置和映射，MyBatis 可以高效地处理各种复杂的数据库操作需求。熟练掌握这些特性可以让开发者在项目中更高效地处理数据访问逻辑。三、Spring Boot 集成 MyBatisMyBatis 是一种轻量级的持久层框架，与 Spring Boot 集成后可以极大地提升开发效率。

旺旺小崔崔的博客 2236

efm32 入门.pdf

本PDF共计22页，介绍的是操作驱动API，下载与否自己斟酌。

Spring集成Mybatis的实现

首先，你需要一个常见的Spring项目。使用Maven创建一个新的Spring Boot或Spring MVC的项目项，我们在pom.xml中添加MyBatis和Spring相关的依赖。 通过上述依赖，我们应用了Spring和MyBatis的库，以便连接数据库和实现代码中的DAO层。于是，你就需要一个数据库连接源。通过以下方式配置Spring中的DataSource：文件： 此配置中，我们应该动态获取数据库的信息，包括驱动类名（例如MySQL）、连接地址、用户名和密码。接下来，我们需要引入MyBatis，

gege_0606的博客 1315

【SSM】Spring集成Mybatis

虽然Spring中提供了JDBCTemplate模块，已经很大程度了解决了JDBC代码的复杂度，但它仍然是和Java代码写在一起的。反观 Mybatis 将 Sql 语句写在配置文件中，使得SQL语句和程序实现了松耦合。而且提供了些许标签，使得SQL可以是动态的。在ORM基础上想要更好的用Spring的DI、AOP、事务处理、Junit支持等实现成果，学会使用 Spring 框架集成 Mybatis 是大势所趋。

qq_63691275的博客 1806

mybatis与spring集成与spring aop集成pagehelper插件

同时，我们还需要在Mybatis的配置文件中定义数据源和事务管理器。Mybatis与Spring的集成主要有两种方式：使用Spring的Mybatis支持和使用Mybatis的Spring支持。Mybatis是一款轻量级的ORM框架，而Spring是一个全栈式的框架，二者的结合可以让我们更加高效地进行数据持久化操作。3. 在Spring的配置文件中定义SqlSessionFactory，将Mybatis的配置文件进行引入。2. 在Mybatis的配置文件中定义数据源和事务管理器。

djssubddbj的博客 784

MyBatis 与 Spring 框架集成

本文介绍了MyBatis与Spring框架集成的完整方案。通过MyBatis-Spring模块，开发者可以充分利用Spring的依赖注入和事务管理功能。集成过程包括环境配置（添加相关依赖、数据库连接池设置）、Java配置方式（数据源、MyBatis和事务管理配置）以及XML配置方式。集成后能够实现组件统一管理、简化事务配置，并与Spring其他模块无缝协作。文中提供了详细的配置示例代码，涵盖了SqlSessionFactory构建、Mapper扫描、事务管理等关键环节，为开发企业级应用提供了高效可维护的数据

shangjg3的博客 1148

【Spring】Spring集成MyBatis

集成思路 Spring能集成很多的框架，是Spring一个优势功能。 通过集成功能，让开发人员使用其他框架更方便。 集成使用的是Spring IoC 核心技术。 要使用框架，例如mybatis，怎么使用mybatis ？ Spring集成MyBatis的目的????将Mybatis框架中用到的对象交给Spring来管理，主要是SqlSessionFactory和dao代理，把这两个交给容器Spring。在Spring主配置文件中声明对象 使用mybatis，需要创建mybatis框架中的某些对象， 使用这

爱写bug的王六六 1591

Mybatis与Spring的集成

目录 一、Mybatis与spring的集成 Mybatis与spring集成的步骤 1、导入pom依赖 2、利用mybatis逆向工程生成模型底层代码 3、编写appolication-mybatis.xml 4、Spring Test+junit完美组合 二、Aop整合pagehelper插件 为什么要用Aop整合pagehelper插件 三、总结 ①分页 ②切面中需要思考的地方 四、在运行过程中遇到的问题 一、Mybatis与spring的集成 Mybatis与sp..

weixin_56069070的博客 725

Spring集成Mybatis

jar包：展示如下。

2302_79086106的博客 1051

MyBatis 与 Spring 集成详解

MyBatis 与 Spring 集成详解

1242

Spring集成Mybatis和SpringWeb

SpringWeb 是 spring 框架中的一个模块，基于 Servlet API 构建的原始 web 框架. springWeb 是 Spring 为 web 层开发提供的一整套完备的解决方案。在web 层框架历经 Strust1，WebWork，Strust2 等诸多产品的历代更选之后，目前业界普遍选择了 springWeb 作为Java EE项目 web 层开发的首选方案。

bo2415126360的博客 242
上一篇： MyBatis的入门
下一篇： Maven项目中配置Jetty插件
点赞 0
评论 0
书签 书签 0
迷失的小鹿
迷失的小鹿
博客等级 码龄8年 1万+粉丝 199原创
+ 关注 专栏目录 订阅专栏
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值