【思维导图】mybatis-12、与spring整合

Spring精品教程资料：3.MyBatis与Spring的整合

根据整合步骤实现Spring和MyBatis的整合查询出全部供应商数据直接注入SqlSessionTemplate实现
完成时间：20分钟
7/33
学员操作—根据名称查询供应商信息练习需求说明
在上一练习基础上增加按照供应商名称模糊查询供应商信息的功能
要求：直接注入SqlSessionTemplate实现
MapperFactoryBean
MapperScannerConfigurer递归扫描基准包下所有接口，若它们在SQL映射文件中定义过，则动态注册为MapperFactoryBean，如此即可批量产生映射器实现类
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
分析配置数据源配置SqlSessionFactoryBean
使用SqlSessionTemplate实现数据库的操作
编写业务逻辑代码并测试
演示示例1：实现Spring对MyBatis的整合
6/33
学员操作—实现供应商表的查询操作练习需求说明
在超市订单系统中实现供应商表的查询操作
<property name="basePackage" value="cn.smbms.dao" />
</bean>
指定扫描的基准包
演示示例3：使用MapperScannerConfigurer注入映射器
11/33
小结
MapperScannerConfigurer 与@Autowired注解或@Resource注解配合使用，自动创建映射器实现并注入给业务组件，能够最大限度地减少DAO组件与业务组件的编码和配置工作

MyBatis思维导图

MyBatis思维导图1、初识框架技术2、搭建MyBatis环境3、掌握MyBatis的核⼼API4、掌握MyBatis的核⼼配置⽂件：主要⽤于配置数据库连接和MyBatis运⾏时所需的各种特性5、掌握SQL映射⽂件（或者使⽤⾃动⽣成SQL映射⽂件的插件）6、掌握MyBatis缓存7、Dao上级操作8、掌握动态SQL9、掌握MyBatis框架的优缺点和其使⽤场合--------------------------------------------------------------------------------------------------------------------------------------知识点详情-------------------------------------------------------------1、初识框架技术 1.1什么是框架框架（Framework）是⼀个提供了可重⽤的公共结构的半成品，它成为构建新的应⽤程序提供了极⼤的便利，更提供了可重⽤的设计； 1.2当前的主流框架 1.2.1 Struts2： Struts2以Webwork设计思想为核⼼，吸收了Struts框架的部分优点，提供了⼀个更加整洁的基于MVC设计模式实现的Web应⽤程序框架。

它引⼊了⼏个新的框架特性：从逻辑中分离出横切关注点的拦截器，减少或者消除配置⽂件，贯穿整个框架的强⼤表达式语⾔，⽀持可重⽤的标签API等。

Struts2充分利⽤了从其他MVC框架学到的经验和教训，使整个框架更加清晰、灵活（引⼊了拦截器）。

1.2.2 Hibernate： Hibernate是⼀个优秀的持久化框架（ORM），负责简化将对象数据保存到数据库中，或从数据库中读取数据并封装到对象的⼯作。

Hibernate通过简单配置和编码即可替代JDBC繁琐的程序代码。

1.2.3Spring： Spring是⼀个开源框架。

16.mybatis和spring整合-SqlSessionFactory配置

|--新建log4j.properties配置文件
log4j.rootCategory=DEBUG, stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
yout=org.apache.log4j.PatternLayout
yout.ConversionPattern=[%5p] [%t] %c{2}:%L - %m%n
1、SqlSessionFactory配置：
在applicationContext.xml配置SqlSessionFactory和数据源。
mybatis和spring整合
整合思路：
需要spring通过单例的方式管理SqlSessionFactory。
spring和mybatis整合生成代理对象，使用SqlSessionFactory创建SqlSession。（Spring和mybatis整合自动完成）
持久层的mapper、dao都需要由spring进行管理。
ername=root
jdbc.password=753951
dbcp.maxIdle=10
dbcp.maxTotal=20
jdbc.defaultAutoCommit=true
-->

<context:property-placeholder location="classpath:db.properties" />

<property name="maxIdle" value="${dbcp.maxIdle}" />

SSM三大框架整合详细教程(Spring+SpringMVC+MyBatis)

SSM三大框架整合详细教程（Spring+SpringMVC+MyBatis）使用SSM（Spring、SpringMVC和Mybatis）已经有三个多月了，项目在技术上已经没有什么难点了，基于现有的技术就可以实现想要的功能，当然肯定有很多可以改进的地方。

之前没有记录SSM整合的过程，这次刚刚好基于自己的一个小项目重新搭建了一次，而且比项目搭建的要更好一些。

以前解决问题的过程和方法并没有及时记录，以后在自己的小项目中遇到我再整理分享一下。

这次，先说说三大框架整合过程。

个人认为使用框架并不是很难，关键要理解其思想，这对于我们提高编程水平很有帮助。

不过，如果用都不会，谈思想就变成纸上谈兵了！！！先技术，再思想。

实践出真知。

（可通过图片水印查看博客地址）1、基本概念1.1、SpringSpring是一个开源框架，Spring是于2003 年兴起的一个轻量级的Java 开发框架，由Rod Johnson 在其著作Expert One-On-One J2EE Development and Design中阐述的部分理念和原型衍生而来。

它是为了解决企业应用开发的复杂性而创建的。

Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。

然而，Spring的用途不仅限于服务器端的开发。

从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。

简单来说，Spring是一个轻量级的控制反转（IoC）和面向切面（AOP）的容器框架。

1.2、SpringMVCSpring MVC属于SpringFrameWork的后续产品，已经融合在Spring Web Flow里面。

Spring MVC 分离了控制器、模型对象、分派器以及处理程序对象的角色，这种分离让它们更容易进行定制。

1.3、MyBatisMyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code，并且改名为MyBatis 。

mybatis整合spring

mybatis整合springmybatis整合spring根据官方的说法，在ibatis3，也就是mybatis3问世之前，spring3的开发工作就已经完成了，所以spring3中还是没有对mybatis3的支持。

因此由mybatis社区自己开发了一个mybatis-spring用来满足mybatis用户整合spring的需求。

下面就将通过mybatis-spring来整合mybatis跟spring的用法做一个简单的介绍。

mapperfactorybean首先，我们需要从mybatis官网上下载mybatis-spring的jar包添加到我们项目的类路径下，当然也需要添加mybatis的相关jar包和spring的相关jar包。

我们知道在mybatis的所有操作都是基于一个sqlsession的，而sqlsession是由sqlsessionfactory来产生的，sqlsessionfactory又是由sqlsessionfactorybuilder来生成的。

但是mybatis-spring是基于sqlsessionfactorybean的。

在使用mybatis-spring的时候，我们也需要sqlsession，而且这个sqlsession是内嵌在程序中的，一般不需要我们直接访问。

sqlsession也是由sqlsessionfactory来产生的，但是mybatis-spring给我们封装了一个sqlsessionfactorybean，在这个bean里面还是通过sqlsessionfactorybuilder来建立对应的sqlsessionfactory，进而获取到对应的sqlsession。

通过sqlsessionfactorybean我们可以通过对其指定一些属性来提供mybatis的一些配置信息。

所以接下来我们需要在spring的applicationcontext配置文件中定义一个sqlsessionfactorybean。

mybatis与spring的整合配置说明

mybatis是ibatis的升级版，spring也有自带mybatis的orm。

所以，搭建ibatis的框架也会有多种方式（我这里mybatis是3.0的，ibatis是2.3的，spring是3.0的，数据库是mysql）。

下面介绍3中方式1，只是用mybatis3。

2，使用mybatis3+spring3(使用mybatis的SqlSessionFactory )。

3，使用ibatis2.3+spring(使用spring自带的ibatis)spring的orm包中只有ibatis，没有mybatis。

而mybatis和ibatis还是有些区别的，比如配置文件属性不同。

第一种方式(只使用mybatis)：1）jar包：cglib-2.2.jarasm-3.1.jarmysql-connector-java-3.1.13.jarmybatis-3.0.5.jarjunit.jar2）mybatis配置文件：[html]view plaincopy1.<?xml version="1.0"encoding="UTF-8"?><!DOCTYPE configuration PUBLIC "-//my//DTD Config 3.0//EN" "/dtd/mybatis-3-config.dtd">2.<configuration>3.4.<settings>5.6.<setting name="cacheEnabled"value="true"/>7.<!-- 全局启用或禁用延迟加载。

当禁用时，所有关联对象都会即时加载 -->8.<setting name="lazyLoadingEnabled"value="true"/>9.<!-- 当启用时，有延迟加载属性的对象在被调用时将会完全加载任意属性。

第10章 MyBatis与Spring的整合[40页]

作为Bean容器，Spring框架提供了IoC机制，可以接管所有组件的创建工作并进行依赖管理，因而整合的主要工作就是把MyBatis框架使用中所涉及的核心组件配置到Spring框架的容器中，再交给Spring框架来创建和管理。
具体来说，业务逻辑对象依赖基于MyBatis技术实现的DAO对象，其核心是获取 SqlSession实例。
第10章 MyBatis与Spring 的整合
Spring框架对MyBatis框架的整合思路
主讲内容
Speech content
Spring框架整合MyBatis框架的准备工作实现Spring对MyBatis的框架整合注入Mapper接口方式的开发整合测试事务
Spring配置补充
Spring框架对MyBatis框架的整合思路
演示示例：实现Spring对MyBatis的整合
11
准备所需JAR包
要实现MyBatis与Spring的整合，很明显需要这两个框架的JAR包，但是只使用这两个框架中所提供的JAR包是不够的，还需要其他的JAR包来配合使用，整合时所需准备的JAR包具体如下。
1.Spring框架所需的JAR包
• aopalliance-1.0.jar。 • aspectjweaver-1.8.10.jar。 • spring-aop-3.2.18.RELEASE.jar。 • spring-aspects-3.2.18.RELEASE.jar。 • spring-beans-3.2.18.RELEASE.jar。 • spring-context-3.2.18.RELEASE.jar。 • spring-core-3.2.18.RELEASE.jar。 • spring-expression-3.2.18.RELEASE.jar。 • spring-jdbc-3.2.18.RELEASE.jar。 • spring-tx-3.2.18.RELEASE.jar。

Spring和MyBatis的整合

Spring和MyBatis的整合1. Spring和各个框架的整合Spring⽬前是JavaWeb开发中最终的框架，提供⼀站式服务，可以其他各个框架整合集成Spring整合⽅案1.1. SSHssh是早期的⼀种整合⽅案Struts2 ： Web层框架Spring ：容器框架Hibernate ：持久层框架1.2. SSM主流的项⽬架构的三⼤框架（相对其他框架⽽⾔，最优秀）SpringMVC ： spring⾃⼰家的 Web层框架，spring的⼀个模块Spring ：容器框架MyBatis ：持久层框架2. Spring与MyBatis整合2.1. 集成思路实际开发，使⽤Maven项⽬，直接引⼊项项⽬在Maven仓库中的坐标即可学习阶段：⼿动导⼊jar包，从零开始集成（巩固基础知识）2.2. 创建java项⽬准备集成相关jar包完成项⽬层与层之间spring对象的创建和依赖关系的维护package cn.sxt.pojo;public class User {private Integer id;private String name;private String password;private Integer age;public Integer getId() {return id;}public void setId(Integer id) {this.id = id;}public String getName() {return name;}public void setName(String name) { = name;}public String getPassword() {return password;}public void setPassword(String password) {this.password = password;}public Integer getAge() {return age;}public void setAge(Integer age) {this.age = age;}@Overridepublic String toString() {return "User [id=" + id + ", name=" + name + ", password=" + password + ", age=" + age + "]"; }public User(Integer id, String name, String password, Integer age) {super();this.id = id; = name;this.password = password;this.age = age;}public User() {super();// TODO Auto-generated constructor stub}}package cn.sxt.mapper;import java.util.List;import er;public interface UserMapper {int insert(User user);int deleteByPrimaryKey(Integer id);int updateByPrimaryKey(User user);User selectByPrimaryKey(Integer id);List<User> selectList();}<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE mapperPUBLIC "-////DTD Mapper 3.0//EN""/dtd/mybatis-3-mapper.dtd"><mapper namespace="erMapper"><insert id="insert" parameterType="User"keyColumn="id"keyProperty="id"useGeneratedKeys="true">insert into user (name,password,age)values(#{name},#{password},#{age}) </insert><select id="selectByPrimaryKey" parameterType="Integer" resultType="User">select * from user where id = #{id}</select><select id="selectList" resultType="User">select * from user</select><delete id="deleteByPrimaryKey" parameterType="Integer">delete from user where id = #{id}</delete><update id="updateByPrimaryKey" parameterType="User">update user set name = #{name},password = #{password},age = #{age} where id = #{id} </update></mapper>package cn.sxt.service;import java.util.List;import er;public interface UserService {int insert(User user);int deleteByPrimaryKey(Integer id);int updateByPrimaryKey(User user);User selectByPrimaryKey(Integer id);List<User> selectList();}package cn.sxt.service.impl;import java.util.List;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.stereotype.Service;import erMapper;import er;import erService;@Servicepublic class UserServiceImpl implements UserService {/** 问题1 ： UserMapper是接⼝，如何创建对象？* 答：使⽤MyBatis的SqlSession 会话对象。

Mybatis和spring整合

Mybatis和spring整合mybatis和spring整合也就是把两者的优点集合到⼀起下⾯我们看下配置步骤1. 导⼊jar1. 整合spring和mybatis需要mybatis-spring.jar我⽤的是1.2.0版本2. 整合需要⽤到spring数据源和事物⽀持，需要spring-jdbc和spring-tx的包3. spring中使⽤具体的数据源实现，此次需要dbcp,commons-dbcp及commons-pool包4.5. 导⼊后如图所⽰6.7. spring官⽹下载地址：https://repo.spring.io/webapp/#/artifacts/browse/tree/General/libs-release-local/org/springframework/spring/4.3.2.RELEASE8. 另⼀个地址：http://repo.spring.io/release/org/springframework/spring/9. mybatis官⽹下载地址：https:///mybatis/mybatis-3/releases2.3. 搭建好mybatis框架后确保mybatis环境搭建没有错误，在此基础上进⾏spring融合1. 修改配置⽂件1. ⾸先需要把mybatis中数据库连接和映射mapper⽂件的部分删除如下2. <properties resource="database.properties"/>3. <environments default="dpCommodity"><environment id="dpCommodity"><transactionManager type="JDBC"/><dataSource type="POOLED"><property name="driver" value="${driver}"/><property name="url" value="${url}"/><property name="username" value="${user}"/><property name="password" value="${pwd}"/></dataSource></environment></environments><mappers><mapper resource="cn/dao/CommodityMapper.xml"/></mappers>2. 删除之后新建spring配置⽂件导⼊database.properties⽂件<bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"><property name="location" value="classpath:database.properties"/></bean>之后配置数据源其中⼤括号⾥⾯的名称对应 database.properties⽂件中的名称3. <bean id="dataSource" class="mons.dbcp.BasicDataSource"><property name="driverClassName" value="${driver}"/><property name="url" value="${url}"/><property name="username" value="${user}"/><property name="password" value="${pwd}"/></bean>database⽂件内容如下：4. 配置sqlSessionFactory<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"><property name="dataSource" ref="dataSource"/><property name="configLocation" value="classpath:mybatis-config.xml"/><property name="mapperLocations"><list><value>classpath:cn/dao/**/*.xml</value></list></property></bean> 其他配置　<bean id="sqlSessionTemplate" class="org.mybatis.spring.SqlSessionTemplate"><constructor-arg name="sqlSessionFactory" ref="sqlSessionFactory"/></bean><bean id="workinggMapper" class="cn.dao.impl.WorkinggMapperImpl"><property name="session" ref="sqlSessionTemplate"/></bean><bean id="workinggService" class="cn.service.impl.WorkinggServiceImpl"><property name="wM" ref="workinggMapper"/></bean>1. 测试1. 测试类代码如下public class Test {public static void main(String[] args) {ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");WorkinggService cs = (WorkinggServiceImpl)ctx.getBean("workinggService");List<Workingg> cList = cs.allWorking();for (Workingg w : cList) {System.out.println(w.getTitle());}}}⾃动⽣成映射器实现类1. 其实还有另外⼀种配置⽅法，因为上⾯的配置⽅法如果我换⼀个接⼝，那么⼜要修改配置⽂件那么有没有好点的⽅法呢 <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer"><property name="basePackage" value="cn.dao"/></bean>通过上⾯这⼀步就可以让它⾃动⽣成映射器实现类，其中basePackage属性中可以包含多个包名，多个包名直接使⽤逗号或分号隔开2. 注意如果sqlSessionFactory配置了多个那么⾃动装配则⽆法进⾏，需要指定 sqlSessionFactory如下<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer"><property name="basePackage" value="cn.dao"/><property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"></property></bean>如上则可以⾃动⽣成映射器实现类<bean id="workinggService" class="cn.service.impl.WorkinggServiceImpl"><property name="wM" ref="workinggMapper"/></bean>⾃动⽣成映射器实现类的名字默认为，接⼝名第⼀个单词⼩写后⾯的不变如接⼝名：WorkinggMapper 默认名称：workinggMapper3. 注意：SQL映射⽂件中必须遵循以下命名规则1. 映射命名空间和映射器接⼝的名称相同2. 映射元素的id和映射器接⼝的⽅法相同3.使⽤注解定义业务bean 通过上⾯的改造，可不⽤⼿动⽣成映射器实现类了但是去依然要写业务bean，这时候就有了注解当需要某种业务bean时执⾏添加注解即可如下吧之前⽣成业务bean的代码替换成 <context:component-scan base-package="cn"/>再在业务bean中写两个注释即可如下业务bean继承SqlSessionDaoSupport类修改之前的业务bean如下package cn.service.impl;import java.util.List;import javax.annotation.Resource;import org.springframework.context.ApplicationContext;import org.springframework.context.support.ClassPathXmlApplicationContext; import org.springframework.stereotype.Service;import cn.dao.WorkinggMapper;import cn.pojo.Workingg;import cn.service.WorkinggService;//加上这⾏注释扫描的时候则会⾃动⽣成名为workinggService的业务bean@Service("workinggService")public class WorkinggServiceImpl implements WorkinggService {//扫描时会⾃动注⼊ WorkinggMapper@ResourceWorkinggMapper wM;public WorkinggMapper getwM() {return wM;}public void setwM(WorkinggMapper wM) {this.wM = wM;}@Overridepublic int screenTitle(String title) {return wM.screenTitle(title);}@Overridepublic Workingg screenId(Integer id) {// TODO Auto-generated method stubreturn wM.screenId(id);}@Overridepublic List<Workingg> allWorking() {// TODO Auto-generated method stubreturn wM.allWorking();}@Overridepublic int count() {// TODO Auto-generated method stubreturn wM.count();}@Overridepublic int addWorking(Workingg workingg) {// TODO Auto-generated method stubreturn wM.addWorking(workingg);}@Overridepublic int del(Integer id) {// TODO Auto-generated method stubreturn wM.del(id);}@Overridepublic int modify(Workingg workingg) {// TODO Auto-generated method stubreturn wM.modify(workingg);}public static WorkinggService getWorkinggService() {ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");WorkinggService wService = (WorkinggServiceImpl)ctx.getBean("WorkinggService");return wService;}}继承之后dao的实现类就没什么⽤了，因为业务类以及不依赖dao的实现类了，继承后代码如下package cn.service.impl;import java.util.List;import org.mybatis.spring.support.SqlSessionDaoSupport;import org.springframework.context.ApplicationContext;import org.springframework.context.support.ClassPathXmlApplicationContext;import org.springframework.stereotype.Service;import cn.dao.WorkinggMapper;import cn.pojo.Workingg;import cn.service.WorkinggService;public class WorkinggServiceImpl extends SqlSessionDaoSupport implements WorkinggService {@Overridepublic int screenTitle(String title) {return super.getSqlSession().getMapper(WorkinggMapper.class).screenTitle(title);}@Overridepublic Workingg screenId(Integer id) {// TODO Auto-generated method stubreturn super.getSqlSession().getMapper(WorkinggMapper.class).screenId(id);}@Overridepublic List<Workingg> allWorking() {// TODO Auto-generated method stubreturn super.getSqlSession().getMapper(WorkinggMapper.class).allWorking();}@Overridepublic int count() {// TODO Auto-generated method stubreturn super.getSqlSession().getMapper(WorkinggMapper.class).count();}@Overridepublic int addWorking(Workingg workingg) {// TODO Auto-generated method stubreturn super.getSqlSession().getMapper(WorkinggMapper.class).addWorking(workingg);}@Overridepublic int del(Integer id) {// TODO Auto-generated method stubreturn super.getSqlSession().getMapper(WorkinggMapper.class).del(id);}@Overridepublic int modify(Workingg workingg) {// TODO Auto-generated method stubreturn super.getSqlSession().getMapper(WorkinggMapper.class).modify(workingg);}public static WorkinggService getWorkinggService() {ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");WorkinggService wService = (WorkinggServiceImpl)ctx.getBean("WorkinggService");return wService;}}修改前的配置⽂件有映射，继承之后不需要了把这⼀段替换成了这段，测试类代码不变就好了<bean id="workinggService" class="cn.service.impl.WorkinggServiceImpl"> <property name="sqlSessionFactory" ref="sqlSessionFactory"></property> </bean>不清楚的可以去⽹盘下载这个项⽬跑下。

SpringSpringMVCMyBatis整合

SpringSpringMVCMyBatis整合今天主要想总结一下SSM的整合，之前已经将MyBatis和spring整合起来了，那么这次主要介绍怎样加入SpringMVC这个框架，在整合之前先简单介绍一下SpringMVC：SpringMVC是一种基于Java的，实现了”WEB MVC”设计模式，基于请求驱动类型的轻量级WEB框架，是Spring框架的重要组成部分,该框架使用了MVC架构模式的思想，将WEB层进行职责功能的解耦，基于请求驱动类型指的就是使用“请求-响应”模型，该框架的目的就是帮助我们简化web系统的开发。

SpringMVC中最重要的一个就是前端控制器：FontController：DispatcherServlet,MVC架构模式中要求一定要存在前端控制器，而且一定是由Servlet实现的，而Struts2严格来说称之为MVC的变种架构。

Servlet:Servlet规范对路径匹配规则是有要求的：1.如果一个路径是以/开头，以/*结尾，称之为路径前缀匹配2.如果一个路径是以*.开头,那么这个路径称之为扩展匹配3.其它所有的路径都是精确匹配SpringMVC架构模式:天生和Spring框架集成，能简单的进行Web层的单元测试。

搭建SpringMVC的开发环境：1.首先自然是要引入相关的Jar包，然后在web.xml中配置前端控制器：servlet当然由于我们现在创建的是WEB项目，记得在web.xml中配置一个全局的参数，在Tomcat 启动时就会去读取该文件：applicationContext.xml以下就是web.xml文件的具体配置内容：<?xml version="1.0" encoding="UTF-8"?><web-app version="3.0" xmlns="/xml/ns/javaee"xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/xml/ns/javaee/xml/ns/javaee/web-app_3_0.xsd"><display-name>SpringMVCTest</display-name><context-param><param-name>contextConfigLocation</param-name><param-value>classpath:applicationContext.xml</param-value></context-param><servlet><servlet-name>springmvc</servlet-name><servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class><load-on-startup>1</load-on-startup></servlet><servlet-mapping><servlet-name>springmvc</servlet-name><url-pattern>/</url-pattern></servlet-mapping><listener><listener-class>org.springframework.web.context.ContextLoaderListener</listener-class></listener><filter><filter-name>encodingFilter</filter-name><filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class> <init-param><param-name>encoding</param-name><param-value>UTF-8</param-value></init-param><init-param><param-name>forceEncoding</param-name><param-value>true</param-value></init-param></filter><filter-mapping><filter-name>encodingFilter</filter-name><url-pattern>/*</url-pattern></filter-mapping><filter><filter-name>HiddenHttpMethodFilter</filter-name><filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class> </filter><filter-mapping><filter-name>HiddenHttpMethodFilter</filter-name><servlet-name>springmvc</servlet-name></filter-mapping><session-config><session-timeout>30</session-timeout></session-config><error-page><error-code>403</error-code><location>/WEB-INF/views/errors/403.jsp</location></error-page><error-page><error-code>404</error-code><location>/WEB-INF/views/errors/404.jsp</location></error-page><error-page><error-code>405</error-code><location>/WEB-INF/views/errors/405.jsp</location></error-page><error-page><error-code>500</error-code><location>/WEB-INF/views/errors/500.jsp</location></error-page></web-app>2.增加配置文件，默认DispatcherServlet会加载WEB-INF/[DispatcherServlet的Servlet名字]-servlet.xml配置文件，上面这样写就代表当前配置文件的名称为springmvc-servlet.xml，也就是配置文件的名称必须和Servlet的名字一样：“springmvc-servlet.xml”该配置文件中主要配置一些处理器映射器，处理适配器，视图解析器以及开启注解和扫描SpringMVC注解的包路径，以下就是具体配置内容：<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xmlns:mvc="/schema/mvc"xmlns:p="/schema/p"xmlns:aop="/schema/aop"xsi:schemaLocation="/schema/mvc/schema/mvc/spring-mvc-3.2.xsd/schema/beans/schema/beans/spring-beans-3.2.xsd/schema/context/schema/context/spring-context-3.2.xsd/schema/aop/schema/aop/spring-aop-3.2.xsd/schema/mvc/schema/mvc/spring-mvc-3.0.xsd"> <context:annotation-config /><mvc:annotation-driven /><context:component-scan base-package="com.ecjtu.ssm"><context:exclude-filter type="annotation"expression="org.springframework.stereotype.Service" /></context:component-scan><mvc:interceptors><bean class="org.springframework.web.servlet.theme.ThemeChangeInterceptor" /><bean class="org.springframework.web.servlet.i18n.LocaleChangeInterceptor"p:paramName="lang" /></mvc:interceptors><beanclass="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor"> </bean><beanclass="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"></bean> <bean class="org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter"></bean> <mvc:resources location="/resources/" mapping="/resources/**" /><mvc:resources mapping="/images/**" location="/images/" /><mvc:resources mapping="/css/**" location="/css/" /><mvc:resources mapping="/others/**" location="/others/" /><mvc:resources mapping="/js/**" location="/js/" /><mvc:resources mapping="/html/**" location="/html/" /><bean id="multipartResolver"class="monsMultipartResolver"><property name="maxUploadSize" value="10000000" /></bean><beanclass="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMappin g"/><bean id="messageAdapter"class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter "><property name="messageConverters"><list><beanclass="org.springframework.http.converter.StringHttpMessageConverter" /><beanclass="org.springframework.http.converter.FormHttpMessageConverter" /><beanclass="org.springframework.http.converter.ByteArrayHttpMessageConverter" /><beanclass="org.springframework.http.converter.xml.SourceHttpMessageConverter" /><beanclass="org.springframework.http.converter.BufferedImageHttpMessageConverter" /><beanclass="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter" /> </list></property></bean><beanclass="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter "><property name="messageConverters"><list><beanclass="org.springframework.http.converter.StringHttpMessageConverter"><property name="supportedMediaTypes"><list><value>text/html;charset=UTF-8</value></list></property></bean></list></property></bean><beanclass="org.springframework.web.servlet.view.InternalResourceViewResolver"><property name="viewClass"value="org.springframework.web.servlet.view.JstlView" /><property name="prefix" value="/WEB-INF/views/" /><property name="suffix" value=".jsp" /></bean></beans>这里我也一并将applicationContext.xml文件的内容都贴出来吧，里面都有详细的注释<?xml version="1.0" encoding="UTF-8"?>default-autowire="no" default-lazy-init="false"><context:component-scan base-package="com.ecjtu.ssm.*"><context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller" /><context:exclude-filter type="annotation" expression="org.springframework.web.bind.annotation.ControllerAdvice" /></context:component-scan><context:annotation-config /><bean id="propertyPlaceholderConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"><property name="location"><value>classpath:db-config.properties</value></property></bean><!--本示例采用DBCP连接池，应预先添加DBCP包的依赖。

MyBatis,Spring整合简易教程

MyBatis,Spring整合简易教程轻量级JavaEEMyBatisSpring整合在实际的项目开发中，我们需要将MyBatis和Spring进行整合，通过Spring 的依赖注入以减少代码的耦合。

本文以MyEclipse和MySQL数据库为开发环境简单的讲解一下MyBatis和Spring的整合过程。

首先我们创建一个Java Project，名称任意，然后导入所需要包：spring3.1.1, mybatis-3.1.1.jar,mysql-connector-java-5.1.2-beta-bin.jar ,mybatis-spring-1.1.1.jar第一步：创建数据库表在Navicat下执行如下sql命令创建表User.Sql代码1.CREATE TABLE user2.(3. id int(11) NOT NULL AUTO_INCREMENT,4. username varchar(20) NOT NULL,5. password varchar(20) NOT NULL,6. PRIMARY KEY (id)7.) ENGINE=InnoDB DEFAULT CHARSET=utf8;然后插入测试数据Sql代码1.INSERT INTO user VALUES ('1', 'admin', 'admin');第二步：创建model创建一个model包并在其下创建一个User.java文件。

Java代码1.package model;2.3.public class User {4. private int id;5. private String username;6. private String password;7. public User(){8.9. }10. public int getId() {11. return id;12. }13. public void setId(int id) {14. this.id = id;15. }16. public String getUsername() {17. return username;18. }19. public void setUsername(String username) {20. ername = username;21. }22. public String getPassword() {23. return password;24. }25. public void setPassword(String password) {26. this.password = password;27. }28. public String toString(){29. return "User [id = "+ id +" , username = "+ username +"]" + " , password = "+ password;30. }31.}第三步：创建DAO接口（这里我们对增删改查进行简单的实现）创建一个包dao，并在其下创建一个UserMapper.java文件作为DAO接口。

【免费下载】MyBatisSpring整合

第一章介绍1.1 整合动机正如第二版，Spring 仅支持iBatis2。

那么我们就想将MyBatis3的支持加入到Spring3.0（参考Spring 的Jira 的问题）中。

不幸的是，Spring 3.0的开发在MyBatis 3.0官方发布前就结束了。

因为Spring 开发团队不想发布一个基于非发行版的MyBatis 的整合支持，那么Spring 官方的支持就不得不等到至少3.1版本了。

要在Spring 中支持MyBatis ，MyBatis 社区认为现在应该是自己团结贡献者和有兴趣的人一起来开始进行Spring 和MyBatis 整合的时候了。

这个小类库就来创建丢失的粘贴Spring 和MyBtatis 这两个流行框架的胶水。

减少用户不得不来配置MyBatis 和Spring 3.X 上下文环境的样板和冗余代码。

1.2 要求在开始阅读本手册之前，很重要的一点是你要熟悉Spring 和MyBatis 这两个框架还有和它们有关的术语，否则可能会很难理解手册中的表述内容。

和MyBatis 一样，MyBatis-Spring 也需要Java 5或更高版本。

1.3 感谢非常感谢那些使得本项目成为现实的人们。

Hunter Presnall 和Putthibong Boonbong 编写了所有的硬编码，Eduardo Macarron 完成了MapperFactoryBean 和文档，Andrius Juozapaitis, Giovanni Cuccu 和Raj Nagappan 的贡献和支持，而Simone Tripodi 发现了这些人并把他们带入项目之中。

没有他们的努力，这个项目是不可能存在的。

第二章入门MyBatis-Spring 帮助了你的MyBatis 代码和Spring 进行无缝整合。

使用这个类库中的类，Spring 将会为你加载必要的MyBatis 工厂和session 类。

这个小类库也会提供一个简便的方式向你的service 层bean 中注入MyBatis 的数据映射器。

spring与mybatis五种整合方法

spring与mybatis五种整合⽅法1、采⽤数据映射器（MapperFactoryBean）的⽅式不⽤写mybatis映射⽂件，采⽤注解⽅式提供相应的sql语句和输⼊参数。

（1）Spring配置⽂件：<context:property-placeholder location="jdbc.properties"/><bean id="dataSource" class="mons.dbcp.BasicDataSource" destroy-method="close"><property name="driverClassName" value="${driver}"/><property name="url" value="${url}"/><property name="username" value="${username}"/><property name="password" value="${password}"/><property name="initialSize" value="${initialSize}"/><property name="maxActive" value="${maxActive}"/><property name="maxIdle" value="${maxIdle}"/><property name="minIdle" value="${minIdle}"/></bean><bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"><property name="dataSource" ref="dataSource"/></bean><bean id="userMapper" class="org.mybatis.spring.mapper.MapperFactoryBean"><property name="mapperInterface" value="erMapper"/><property name="sqlSessionFactory" ref="sqlSessionFactory"/></bean><bean id="userDaoImpl2" class="erDaoImpl2"><property name="userMapper" ref="userMapper"/></bean>（2）数据映射器UserMapper,代码如下:public interface UserMapper {@Select("SELECT * FROM user WHERE id = #{userId}")User getUser(@Param("userId") long id);}(3) dao接⼝类UserDao，代码如下：public interface UserDao {public User getUserById(User user);}(4)dao实现类UserDaoImpl2，代码如下:public class UserDaoImpl2 implements UserDao {private UserMapper userMapper;public void setUserMapper(UserMapper userMapper) {erMapper = userMapper;}public User getUserById(User user) {return userMapper.getUser(user.getId());}}2、采⽤接⼝org.apache.ibatis.session.SqlSession的实现类org.mybatis.spring.SqlSessionTemplatemybatis中, sessionFactory可由SqlSessionFactoryBuilder来创建。

Mybatis源码解析（一）——mybatis与Spring是如何整合的？

Mybatis源码解析（⼀）——mybatis与Spring是如何整合的？Mybatis源码解析(⼀) —— mybatis与Spring是如何整合的？从⼤学开始接触mybatis到现在差不多快3年了吧，最近寻思着使⽤3年了，我却还不清楚其内部实现细节，⽐如：它是如何加载各种mybatis相关的xml？它是如何仅仅通过⼀个Mapper接⼝ + Mappe.xml实现数据库操作的（尽管很多⼈可能都清楚是通过代理实现，但⾯试时⼀旦深⼊询问：⽐如Mapper的代理类名是什么？是通过JDK还是cglib实现？）？在同⼀个⽅法中，Mybatis多次请求数据库，是否要创建多个SqlSession会话？它与Spring是如何适配(整合)的？在Spring中是如何保障SqlSession的⽣命周期的？等等⼀系列的问题。

如果以上问题你⾃认为⽆法回答，或者说了解⼀些，那么就从现在开始，我们来⼀⼀揭开这层⾯纱。

⼀、Mybatis：最简单测试Demo 相信只要⽤过Mybatis的同学看到下⾯的代码⼀定不会陌⽣，如果不清楚的可以看下String resource = "mybatis-config.xml";InputStream inputStream = Resources.getResourceAsStream(resource);SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);// 1、⽬前流⾏⽅式try (SqlSession session = sqlSessionFactory.openSession()) {UserMapper mapper = session.getMapper(UserMapper.class);User user = mapper.selectById(101);}// 2、以前流⾏⽅式try (SqlSession session = sqlSessionFactory.openSession()) {User user = sqlSession.selectOne("erMapper.selectById", "101");;} ⽰列代码演⽰了Mybatis进⾏⼀次数据库操作的过程，⼤致分为（针对⽬前流⾏⽅式，其实以前的使⽤和⽬前流⾏的使⽤⽅式实现原理⼀样）：1、通过 SqlSessionFactoryBuilder 将读取到的配置资源 build ⽣成 SqlSessionFactory2、通过 SqlSessionFactory 的 openSession() 获取到 SqlSession3、通过 SqlSession 获取到 Mapper的代理对象(MapperProxy)4、通过 Mapper 进⾏数据库请求操作SqlSession、SqlSessionFactory、SqlSessionFactoryBuilder 我们可以轻易的发现每次去请求数据库操作都需要通过 SqlSessionFactory 去获取到 SqlSession，⽽ SqlSessionFactory 是通过SqlSessionFactoryBuilder 构造出来的，并且最后请求操作完成后都关闭了SqlSession。

SpringBoot整合MyBatis超详细教程

SpringBoot整合MyBatis超详细教程⽬录1.整合MyBatis操作1.1.配置模式1.2.注解模式1.3.混合模式1.整合MyBatis操作前⾯⼀篇提到了，实际项⽬中更常⽤的还是MyBatis框架，⽽SpringBoot整合MyBatis进⾏CRUD也⾮常⽅便。

下⾯从配置模式、注解模式、混合模式三个⽅⾯进⾏说明MyBatis与SpringBoot的整合。

1.1.配置模式MyBatis配置模式是指使⽤mybatis配置⽂件的⽅式与SpringBoot进⾏整合，相对应的就有mybatis-config.xml（⽤于配置驼峰命名，也可以省略这个⽂件）、XxxMapper.xml⽂件。

主要步骤为：导⼊mybatis官⽅starter编写mapper接⼝。

标准@Mapper注解编写sql映射⽂件并绑定mapper接⼝在application.yaml中指定Mapper配置⽂件的位置，以及指定全局配置⽂件的信息（建议；配置在mybatis.configuration中，可以省略mybatis-config.xml⽂件）下⾯是具体整合配置步骤：①引⼊相关依赖pom.xml配置：pom.xml<dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency><dependency><groupId>org.mybatis.spring.boot</groupId><artifactId>mybatis-spring-boot-starter</artifactId><version>2.1.4</version></dependency><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><scope>runtime</scope></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-devtools</artifactId><scope>runtime</scope><optional>true</optional></dependency><dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId><optional>true</optional></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId><scope>test</scope></dependency></dependencies><build><plugins><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId><configuration><excludes><exclude><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId></exclude></excludes></configuration></plugin></plugins></build>②编写对应Mapper接⼝：@Mapper //这个注解表⽰了这个类是⼀个mybatis的mapper接⼝类@Repositorypublic interface UserMapper {//@Select("select * from user")List<User> findAllUsers();//@Insert("insert into user(id, username, password) values (#{id}, #{username}, #{password})")void insert(User user);//@Update("update user set username = #{username}, password = #{password} where id = #{id}")void update(User user);//@Delete("delete from user where id = #{id}")void deleteById(Integer id);}③在resources下创建对应的mapper⽂件，对应domain类，数据库表单如下：User类：@Datapublic class User {private Integer id;private String username;private String password;}数据库user表：UserMapper.xml⽂件：<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE mapper PUBLIC "-////DTD Mapper 3.0//EN" "/dtd/mybatis-3-mapper.dtd"> <mapper namespace="com.fengye.springboot_erMapper"><select id="findAllUsers" resultType="com.fengye.springboot_er">select * from user</select><insert id="insert" parameterType="com.fengye.springboot_er">insert into user(id, username, password) values (#{id}, #{username}, #{password})</insert><update id="update" parameterType="com.fengye.springboot_er">update user set username = #{username}, password = #{password} where id = #{id}</update><delete id="deleteById" parameterType="Integer">delete from user where id = #{id}</delete></mapper>④对应配置application.yml⽂件：application.ymlserver:port: 8083spring:datasource:username: rootpassword: admin#假如时区报错，增加时区配置serverTimezone=UTCurl: jdbc:mysql://localhost:3306/mybatis02_0322?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8 driver-class-name: com.mysql.cj.jdbc.Drivermybatis:#config-location: classpath:mybatis/mybatis-config.xml 使⽤了configuration注解则⽆需再指定mybatis-config.xml⽂件 mapper-locations: classpath:mybatis/mapper/*.xmlconfiguration: #指定mybatis全局配置⽂件中的相关配置项map-underscore-to-camel-case: true1.2.注解模式注解模式使⽤主要步骤：导⼊mybatis官⽅依赖注解⽅式编写mapper接⼝在application.yaml中指定Mapper配置⽂件的位置，以及指定全局配置⽂件的信息可以看到注解模式⽐配置模式少了编写Mapper.xml⽂件，简化了简单SQL语句的xml⽂件编写。

Spring整合MyBatis（Maven+MySQL）图文教程详解

Spring整合MyBatis（Maven+MySQL）图⽂教程详解⼀、使⽤Maven创建⼀个Web项⽬为了完成Spring4.x与MyBatis3.X的整合更加顺利，先回顾在Maven环境下创建Web项⽬并使⽤MyBatis3.X，第⼀、⼆点内容多数是回顾过去的内容。

1.2、点击“File”->“New”->"Other"->输⼊“Maven”，新建⼀个“Maven Project”，如下图所⽰：1.2、请勾选“Create a simple project”，创建⼀个简单的项⽬，不使⽤模板。

也可以使⽤模板，选择WebApp，不过这⾥就不应该勾选。

如下图所⽰：1.3、填写好包名、项⽬名，选择打包类型为：war，如下图所⽰：1.4、项⽬创建好后可能会发现有错误，选择项⽬，右键“属性properties”->"层⾯Project Facets"->"Java"修改版本号为1.7，默认为1.5；点击“Ok”保存后关闭。

如下图所⽰：1.5、重复上⼀个步骤，反勾Dynamic Web Module，将项⽬暂时变成⾮Web项⽬。

点击“Ok”保存后关闭。

1.6、重复上⼀步骤，再进层⾯属性，勾选“Dynamic Web Module”选择Version为3.0。

点击左下⾓的超链接“Further Configuration available...“。

1.7、勾选“Generate web.xml deployment descriptor”⽣成web.xml部署描述⽂件。

点击“Ok”保存后关闭。

1.8、将⽣成的WebContent⽬录下的两个⽂件夹“META-INF”与“WEB-INF”复制到src/main/webapp⽬录下。

1.9、删除WebContent⽬录。

1.10、删除后会发现项⽬的pom.xml⽂件报错，是因为找不到指定位置的web.xml⽂件引起的。