浅学Mybatis：Mybatis入门学习

深碍√TFBOYSˉ_ 2022-05-26 09:57 173阅读 0赞

### **从一个jdbc程序开始** ###

**Public static void** main(String\[\] args) \{

Connection connection = **null**;

PreparedStatement preparedStatement = **null**;

ResultSet resultSet = **null**;

**try** \{

//加载数据库驱动

Class.*forName*("com.mysql.jdbc.Driver");

//通过驱动管理类获取数据库链接

connection =  DriverManager.*getConnection*("jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8", "root", "mysql");A

//定义sql语句 ?表示占位符

String sql = "select \* from user where username = ?";

//获取预处理statement

preparedStatement = connection.prepareStatement(sql);

//设置参数，第一个参数为sql语句中参数的序号（从1开始），第二个参数为设置的参数值

preparedStatement.setString(1, "王五");

//向数据库发出sql执行查询，查询出结果集

resultSet =  preparedStatement.executeQuery();

//遍历查询结果集

**while**(resultSet.next())\{

System.*out*.println(resultSet.getString("id")+"  "\+resultSet.getString("username"));

\} **catch** (Exception e) \{

e.printStackTrace();

\}**finally**\{

//释放资源

**if**(resultSet!=**null**)\{

**try** \{

resultSet.close();

\} **catch** (SQLException e) \{

// **TODO** Auto-generated catch block

e.printStackTrace();

**if**(preparedStatement!=**null**)\{

**try** \{

preparedStatement.close();

\} **catch** (SQLException e) \{

// **TODO** Auto-generated catch block

e.printStackTrace();

**if**(connection!=**null**)\{

**try** \{

connection.close();

\} **catch** (SQLException e) \{

// **TODO** Auto-generated catch block

e.printStackTrace();

上边使用jdbc的原始方法（未经封装）实现了查询数据库表记录的操作。

**jdbc操作步骤总结如下：**

1、 加载数据库驱动

2、 创建并获取数据库链接

3、 创建jdbc statement对象

4、 设置sql语句

5、 设置sql语句中的参数(使用preparedStatement)

6、 通过statement执行sql并获取结果

7、 对sql执行结果进行解析处理

8、 释放资源(resultSet、preparedstatement、connection)

**jdbc问题总结如下：**

1、 数据库链接创建、释放频繁造成系统资源浪费从而影响系统性能，如果使用数据库链接池可解决此问题。

2、 Sql语句写在代码中造成代码不易维护，实际应用sql变化的可能较大，sql变动需要改变java代码。

3、 向sql语句传参数麻烦，因为sql语句的where条件不一定，可能多也可能少，占位符需要和参数一一对应。

4、 对结果集解析麻烦，sql变化导致解析代码变化，且解析前需要遍历，如果能将数据库记录封装成pojo对象解析比较方便。

### **MyBatis介绍** ###

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

MyBatis是一个优秀的持久层框架，它对jdbc的操作数据库的过程进行封装，使开发者只需要关注 SQL 本身，而不需要花费精力去处理例如注册驱动、创建connection、创建statement、手动设置参数、结果集检索等jdbc繁杂的过程代码。

Mybatis通过xml或注解的方式将要执行的statement配置起来，并通过java对象和statement中的sql进行映射生成最终执行的sql语句，最后由mybatis框架执行sql并将结果映射成java对象并返回。

### **Mybatis架构** ###

![70][]

1、 mybatis配置

SqlMapConfig.xml，此文件作为mybatis的全局配置文件，配置了mybatis的运行环境等信息。

mapper.xml文件即sql映射文件，文件中配置了操作数据库的sql语句。此文件需要在SqlMapConfig.xml中加载。

2、 通过mybatis环境等配置信息构造SqlSessionFactory即会话工厂

3、 由会话工厂创建sqlSession即会话，操作数据库需要通过sqlSession进行。

4、 mybatis底层自定义了Executor执行器接口操作数据库，Executor接口有两个实现，一个是基本执行器、一个是缓存执行器。

5、 Mapped Statement也是mybatis一个底层封装对象，它包装了mybatis配置信息及sql映射信息等。mapper.xml文件中一个sql对应一个Mapped Statement对象，sql的id即是Mapped statement的id。

6、 Mapped Statement对sql执行输入参数进行定义，包括HashMap、基本类型、pojo，Executor通过Mapped Statement在执行sql前将输入的java对象映射至sql中，输入参数映射就是jdbc编程中对preparedStatement设置参数。

7、 Mapped Statement对sql执行输出结果进行定义，包括HashMap、基本类型、pojo，Executor通过Mapped Statement在执行sql后将输出结果映射至java对象中，输出结果映射过程相当于jdbc编程中对结果的解析处理过程。

### **Mybatis第一个程序** ###

**第一步：创建java工程**

使用eclipse创建java工程，jdk使用1.6。

**第二步：加入jar包**

加入mybatis核心包、依赖包、数据驱动包。

![70 1][]

**第三步：log4j.properties**

在classpath下创建log4j.properties如下：

\# Global logging configuration

log4j.rootLogger=DEBUG, stdout

\# Console output...

log4j.appender.stdout=org.apache.log4j.ConsoleAppender

log4j.appender.stdout.layout=org.apache.log4j.PatternLayout

log4j.appender.stdout.layout.ConversionPattern=%5p \[%t\] - %m%n

mybatis默认使用log4j作为输出日志信息。

**第四步：SqlMapConfig.xml**

在classpath下创建SqlMapConfig.xml，如下：

<?xml version=*"1.0"* encoding=*"UTF-8"* ?>

<!DOCTYPE configuration

PUBLIC "-//mybatis.org//DTD Config 3.0//EN"

"http://mybatis.org/dtd/mybatis-3-config.dtd">

<environments default=*"development"*>

<environment id=*"development"*>

<transactionManager type=*"JDBC"* />

<dataSource type=*"POOLED"*>

<property name=*"driver"* value=*"com.mysql.jdbc.Driver"* />

<property name=*"url"* value=*"jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8"* />

<property name=*"username"* value=*"root"* />

<property name=*"password"* value=*"mysql"* />

</dataSource>

</environment>

</environments>

</configuration>

SqlMapConfig.xml是mybatis核心配置文件，上边文件的配置内容为数据源、事务管理。

**第五步：po类**

Po类作为mybatis进行sql映射使用，po类通常与数据库表对应，User.java如下：

**Public class** User \{

**Private int **id;

**private** String username;// 用户姓名

**private** String sex;// 性别

**private** Date birthday;// 出生日期

**private** String address;// 地址

**private** String detail;// 详细信息

**private** Float score;// 成绩

get/set……

**第六步：sql映射文件**

在classpath下的sqlmap目录下创建sql映射文件User.xml（相当于架构上的mapper.xml文件）：

<?xml version=*"1.0"* encoding=*"UTF-8"* ?>

<!DOCTYPE mapper

PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"

"http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace=*"test"*>

<select id=*"selectUserById" *parameterType=*"int" *resultType=*"cn.itcast.mybatis.po.User"*>

select \* from user where id = \#\{id\}

</select>

<select id=*"selectUserList" *resultType=*"cn.itcast.mybatis.po.User"*>

select \* from user

</select>

<insert id=*"insertUser" *parameterType=*"cn.itcast.mybatis.po.User"*>

insert into user(username,birthday,sex,address,detail,score)

values(\#\{ username\},\#\{birthday\},\#\{sex\},\#\{address\},\#\{detail\},\#\{score\});

</insert>

update user set username=\#\{ username\},birthday=\#\{birthday\},sex=\#\{sex\},address=\#\{address\},detail=\#\{detail\},score=\#\{score\}

where id=\#\{id\}

</update>

delete from user where id=\#\{id\}

</delete>

</mapper>

namespace ：命名空间，用于隔离sql语句，后面会讲另一层非常重要的作用。

parameterType：定义输入到sql中的映射类型，\#\{id\}表示使用preparedstatement设置占位符号并将输入变量id传到sql。

resultType：定义结果映射类型。

**第七步：将User.xml添加在SqlMapConfig.xml**

在SqlMapConfig.xml中添加mappers如下：

<mapperresource=*"sqlmap/user.xml"*/>

</mappers>

这里即告诉mybatis Sql映射文件在哪里。

**第八步：程序编写**

**查询**

/\*\*

\* 第一个mybatis程序

\* **@author**Thinkpad

\*/

**Public class** Mybatis\_select \{

**Public static void** main(String\[\] args) **throws** IOException \{

//mybatis配置文件

String resource = "sqlMapConfig.xml";

InputStream inputStream = Resources.*getResourceAsStream*(resource);

//使用SqlSessionFactoryBuilder创建sessionFactory

SqlSessionFactory sqlSessionFactory = **new** SqlSessionFactoryBuilder()

.build(inputStream);

//通过session工厂获取一个Sqlsession，sqlsession中包括了对数据库操作的sql方法

SqlSession session = sqlSessionFactory.openSession();

**try** \{

//通过sqlsession调用selectOne方法获取一条结果集

//参数1：指定定义的statement的id,参数2：指定向statement中传递的参数

User user = session.selectOne("test.selectUserById", 1);

System.*out*.println(user);

\} **finally**\{

session.close();

**添加**

**Public class** Mybatis\_insert \{

**Public static void** main(String\[\] args) **throws** IOException \{

//mybatis配置文件

String resource = "sqlMapConfig.xml";

InputStream inputStream = Resources.*getResourceAsStream*(resource);

//使用SqlSessionFactoryBuilder创建sessionFactory

SqlSessionFactory sqlSessionFactory = **new** SqlSessionFactoryBuilder()

.build(inputStream);

//通过session工厂获取一个Sqlsession，sqlsession中包括了对数据库操作的sql方法

SqlSession session = sqlSessionFactory.openSession();

**try** \{

User user = **new** User();

user.setUsername("张三");

user.setBirthday(**new** Date());

user.setSex("1");

user.setAddress("北京市");

user.setDetail("好同志");

user.setScore(99.8f);

session.insert("test.insertUser", user);

session.commit();

\} **finally**\{

session.close();

**删除**

**Public class** Mybatis\_delete \{

**Public static void** main(String\[\] args) **throws** IOException \{

//mybatis配置文件

String resource = "sqlMapConfig.xml";

InputStream inputStream = Resources.*getResourceAsStream*(resource);

//使用SqlSessionFactoryBuilder创建sessionFactory

SqlSessionFactory sqlSessionFactory = **new** SqlSessionFactoryBuilder()

.build(inputStream);

//通过session工厂获取一个Sqlsession，sqlsession中包括了对数据库操作的sql方法

SqlSession session = sqlSessionFactory.openSession();

**try** \{

session.delete("test.deleteUser", 4);

session.commit();

\} **finally**\{

session.close();

**修改**

**Public class** Mybatis\_update \{

**Public static void** main(String\[\] args) **throws** IOException \{

//mybatis配置文件

String resource = "sqlMapConfig.xml";

InputStream inputStream = Resources.*getResourceAsStream*(resource);

//使用SqlSessionFactoryBuilder创建sessionFactory

SqlSessionFactory sqlSessionFactory = **new** SqlSessionFactoryBuilder()

.build(inputStream);

//通过session工厂获取一个Sqlsession，sqlsession中包括了对数据库操作的sql方法

SqlSession session = sqlSessionFactory.openSession();

**try** \{

User user = **new** User();

user.setId(4);

user.setUsername("李四");

user.setBirthday(**new** Date());

user.setSex("1");

user.setAddress("北京市");

user.setDetail("好同志");

user.setScore(99.8f);

session.update("test.updateUser", user);

session.commit();

\} **finally**\{

session.close();

**步骤总结：**

1、 创建SqlSessionFactory

2、 通过SqlSessionFactory创建SqlSession

3、 通过sqlsession执行数据库操作

4、 调用session.commit()提交事务

5、 调用session.close()关闭会话

### **Mybatis解决jdbc编程的问题** ###

1、 数据库链接创建、释放频繁造成系统资源浪费从而影响系统性能，如果使用数据库链接池可解决此问题。

解决：在SqlMapConfig.xml中配置数据链接池，使用连接池管理数据库链接。

2、 Sql语句写在代码中造成代码不易维护，实际应用sql变化的可能较大，sql变动需要改变java代码。

解决：将Sql语句配置在XXXXmapper.xml文件中与java代码分离。

3、 向sql语句传参数麻烦，因为sql语句的where条件不一定，可能多也可能少，占位符需要和参数一一对应。

解决：Mybatis自动将java对象映射至sql语句。

4、 对结果集解析麻烦，sql变化导致解析代码变化，且解析前需要遍历，如果能将数据库记录封装成pojo对象解析比较方便。

解决：Mybatis自动将sql执行结果映射至java对象。

## 3. **Mybaits在企业中的开发方法** ##

Mybatis在系统持久层常用的方法有两种，dao接口开发和mapper接口开发两种。

### **Dao 接口开发：** ###

遵循java是面向接口编程思想，对数据库的操作应该定义一些操作接口，如：用户添加、用户删除、用户查询等，调用dao接口完成数据库操作。

**Dao接口：**

**Public interface** UserDao \{

**public** User getUserById(**int** id) **throws** Exception;

**public void** insertUser(User user) **throws** Exception;

**Dao接口实现**

**Public class** UserDaoImpl **implements** UserDao \{

//注入SqlSessionFactory

**private** SqlSessionFactory sqlSessionFactory;

**Public void** setSqlSessionFactory(SqlSessionFactory sqlSessionFactory) \{

**this**.sqlSessionFactory = sqlSessionFactory;

@Override

**public** User getUserById(**int** id) **throws** Exception \{

SqlSession session = sqlSessionFactory.openSession();

User user = **null**;

**try** \{

//通过sqlsession调用selectOne方法获取一条结果集

//参数1：指定定义的statement的id,参数2：指定向statement中传递的参数

user = session.selectOne("selectUserById", 1);

System.*out*.println(user);

//获取List

//List<User> list = session.selectList("selectUserList");

//System.*out*.println(list);

\} **finally**\{

session.close();

**return** user;

@Override

**Public void** insertUser(User user) **throws** Exception \{

SqlSession session = sqlSessionFactory.openSession();

**try** \{

session.insert("insertUser", user);

session.commit();

\} **finally**\{

session.close();

**SqlSessionFactory**

SqlSessionFactory是一个接口，SqlSessionFactory一但创建后可以重复使用，实际应用时通常设计为单例模式。

将SqlSessionFactory注入dao接口实现，SqlSessionFactory在实际使用时可以设计为单例，与spring整合后由spring对SqlSessionFactory进行管理，并由spring将SqlSessionFactory注入Dao接口实现。

**SqlSession**

SqlSession是一个接口，默认使用DefaultSqlSession实现类，sqlSession中定义了数据库操作（增、删、改、查等），它是一个面向用户的接口，程序员在dao接口实现类中使用它来操作数据库。

但是要注意，SqlSession是线程不安全的，每个线程都应该有它自己的SqlSession实例。SqlSession的实例不能共享使用。因此最佳的范围是请求或方法范围。绝对不能将SqlSession实例的引用放在一个类的静态字段甚至是实例字段中。 （每次获取一个实例）

### **Mapper接口开发：** ###

程序员只需要编写mapper接口（就是dao接口）。mapper是mybatis的官方叫法，不需要写实现类。

**第一步：定义mapper.xml**

**<?xml version=*"1.0"* encoding=*"UTF-8"* ?>**

**<!DOCTYPE mapper**

**PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"**

**"http://mybatis.org/dtd/mybatis-3-mapper.dtd">**

** **

**<mapper namespace=*"xm.wcw.mybatis.mapper.UserMapper"*>**

** **

**<!-- 查询用户信息**

**select：将select标签内容称为statement**

**id：是user.xml中的唯一标识 ，statement的id**

**parameterType：指定向sql（向statement中）中传入参数的类型**

**\#\{\}：表示一个点位符，\{\}中的id表示传入变量名，当传入单个值｛｝中的变量名可以随意**

**resultType：将sql查询结果集映射成java对象的类型**

** -->**

**<select id=*"findUserByUsername"* parameterType=*"String"* resultType=*"xm.wcw.mybatis.po.User"*>**

**SELECT \* FROM USER WHERE username=\#\{id\}**

**</select>**

** **

**<!-- 插入用户**

**parameterType：指定输入参数类型，包括username,birthday,sex,address,detail,score**

**\#\{ username\}：里边的username是cn.itcast.mybatis.po.User的属性**

** **

** -->**

**<insert id=*"inserUser"* parameterType=*"xm.wcw.mybatis.po.User"*>**

** insert into user(username,birthday,sex,address,detail,score)**

** values(\#\{ username\},\#\{birthday\},\#\{sex\},\#\{address\},\#\{detail\},\#\{score\})**

**</insert>**

**</mapper>**

**第二步：定义mapper 接口**

**Public interface** UserMapper \{

**public** User selectUserById(**int** id) **throws** Exception;

**public **List<User> selectUserList() **throws** Exception;

**public void** insertUser(User user) **throws** Exception;

**public void** updateUser(User user) **throws** Exception;

**public void **deleteUser(**int** id) **throws** Exception;

**接口定义有如下特点：**

1、 Mapper接口方法名和mapper.xml中定义的每个sql的id相同

2、 Mapper接口方法的输入参数类型和mapper.xml中定义的每个sql 的parameterType的类型相同

3、 Mapper接口方法的输出参数类型和mapper.xml中定义的每个sql的resultType的类型相同

**第三步：修改namespace 在sqlMapConfig.xml中加载**

![70 2][]

Mapper.xml映射文件中的namepace改为如下：

**修改后namespace即是mapper接口的地址。**

** **

** ![70 3][]**

** **

**第四步：通过mapper接口调用statement**

**Public class** UserMapperTest **extends** TestCase \{

**private** SqlSessionFactory sqlSessionFactory;

**protected void** setUp() **throws** Exception \{

//mybatis配置文件

String resource = "sqlMapConfig.xml";

InputStream inputStream = Resources.*getResourceAsStream*(resource);

//使用SqlSessionFactoryBuilder创建sessionFactory

sqlSessionFactory = **new** SqlSessionFactoryBuilder().build(inputStream);

**Public void** testSelectUserById() **throws** Exception \{

//获取session

SqlSession session = sqlSessionFactory.openSession();

//获取mapper接口实例

UserMapper userMapper = session.getMapper(UserMapper.**class**);

//通过mapper接口调用statement

User user = userMapper.selectUserById(1);

System.*out*.println(user);

//关闭session

session.close();

**Public void** testSelectUserList() **throws** Exception \{

//获取session

SqlSession session = sqlSessionFactory.openSession();

//获取mapper接口实例

UserMapper userMapper = session.getMapper(UserMapper.**class**);

//通过mapper接口调用statement

List<User>list = userMapper.selectUserList();

System.*out*.println(list);

//关闭session

session.close();

**Public void** testInsertUser() **throws** Exception \{

//获取session

SqlSession session = sqlSessionFactory.openSession();

//获限mapper接口实例

UserMapper userMapper = session.getMapper(UserMapper.**class**);

//要添加的数据

User user = **new** User();

user.setUsername("张三");

user.setBirthday(**new** Date());

user.setSex("1");

user.setAddress("北京市");

user.setDetail("好同志");

user.setScore(99.8f);

//通过mapper接口添加用户

userMapper.insertUser(user);

//提交

session.commit();

//关闭session

session.close();

**Public void** testUpdateUser() **throws** Exception \{

//获取session

SqlSession session = sqlSessionFactory.openSession();

//获限mapper接口实例

UserMapper userMapper = session.getMapper(UserMapper.**class**);

//要更新的数据

User user = **new** User();

user.setId(7);

user.setUsername("李四");

user.setBirthday(**new** Date());

user.setSex("1");

user.setAddress("北京市");

user.setDetail("好同志");

user.setScore(99.8f);

//通过mapper接口调用statement

userMapper.updateUser(user);

//提交

session.commit();

//关闭session

session.close();

**Public void** testDeleteUser() **throws** Exception \{

//获取session

SqlSession session = sqlSessionFactory.openSession();

//获限mapper接口实例

UserMapper userMapper = session.getMapper(UserMapper.**class**);

//通过mapper接口删除用户

userMapper.deleteUser(6);

//提交

session.commit();

//关闭session

session.close();

session.getMapper(UserMapper.**class**)生成一个代理对象作为UserMapper的接口实现对象。

**总结：**

使用mapper接口开发方法不用写接口实现类即可完成数据库操作，简单方便，此方法为官方推荐方法。

使用mapper接口调用必须具备如下条件：

1、 Mapper接口方法名和mapper.xml中定义的每个sql的id相同

2、 Mapper接口方法的输入参数类型和mapper.xml中定义的每个sql 的parameterType的类型相同

3、 mapper.xml中定义的每个sql的resultType的类型即为一个查询出一条对象的类型。

4、 Mapper.xml文件中的namespace即是mapper接口的类路径。

至此，mybatis的mapper包括mapper.xml和mapper.Java接口两种文件。

![70 4][]

## 4. **Spring与mybatis整合** ##

**Spring配置文件：**

**applicationContext.xml**

<beans xmlns=*"http://www.springframework.org/schema/beans"*

xmlns:xsi=*"http://www.w3.org/2001/XMLSchema-instance"* xmlns:mvc=*"http://www.springframework.org/schema/mvc"*

xmlns:context=*"http://www.springframework.org/schema/context"*

xmlns:aop=*"http://www.springframework.org/schema/aop"* xmlns:tx=*"http://www.springframework.org/schema/tx"*

xsi:schemaLocation=*"http://www.springframework.org/schema/beans*

*http://www.springframework.org/schema/beans/spring-beans-3.1.xsd*

*http://www.springframework.org/schema/mvc*

*http://www.springframework.org/schema/mvc/spring-mvc-3.1.xsd*

*http://www.springframework.org/schema/context*

*http://www.springframework.org/schema/context/spring-context-3.1.xsd*

*http://www.springframework.org/schema/aop*

*http://www.springframework.org/schema/aop/spring-aop-3.1.xsd*

*http://www.springframework.org/schema/tx*

*http://www.springframework.org/schema/tx/spring-tx-3.1.xsd "*>

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

<bean id=*"dataSource"* class=*"org.apache.commons.dbcp.BasicDataSource"* 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\}"*/>

<property name=*"maxActive"* value=*"30"*/>

<property name=*"maxIdle"* value=*"5"*/>

</bean>

<bean id=*"sqlSessionFactory"* class=*"org.mybatis.spring.SqlSessionFactoryBean"*>

<property name=*"dataSource"* ref=*"dataSource"* />

<property name=*"configLocation"* value=*"classpath:mybatis/SqlMapConfig.xml"* />

</bean>

<bean id=*"userDao"* class=*"cn.itcast.ssm.dao.old.UserDaoImpl"*>

<property name=*"sqlSessionFactory"* ref=*"sqlSessionFactory"* />

</bean>

<!-- <bean id="userMapper" class="org.mybatis.spring.mapper.MapperFactoryBean">

</bean> -->

<!-- 由于单个配置，编写麻烦，所以使用扫描器

自动扫描出来向spring注册bean，bean的id就是mapper接口类的名称(首字母小写)

-->

<bean class=*"org.mybatis.spring.mapper.MapperScannerConfigurer"*>

<!-- 如果要扫描多个包中间用逗号或者分号分隔

由于这里设置了扫描所以SqlMapConfig.xml中的扫描mapper配置可以去掉了

-->

<property name=*"basePackage"* value=*"cn.itcast.ssm.dao.mapper"*></property>

<property name=*"sqlSessionFactoryBeanName"* value=*"sqlSessionFactory"* />

</bean>

</beans>

** **

**sqlmapConfig.xml**

<?xml version=*"1.0"* encoding=*"UTF-8"* ?>

<!DOCTYPE configuration

PUBLIC "-//mybatis.org//DTD Config 3.0//EN"

"http://mybatis.org/dtd/mybatis-3-config.dtd">

<!—使用自动扫描器时，mapper.xml文件如果和mapper.java接口在一个目录则此处不用定义mappers -->

</mappers>

</configuration>

** **

**Mapper编写的两种方法**

**接口实现类继承SqlSessionDaoSupport**

使用此种方法需要编写mapper接口，mapper接口实现类、mapper.xml文件

1、 在sqlMapConfig.xml中配置mapper.xml的位置

</mappers>

2、 定义mapper接口

3、 实现类集成SqlSessionDaoSupport

mapper方法中可以this.getSqlSession()进行数据增删改查。

4、 spring 配置

<bean id=*" "*class=*"mapper接口的实现"*>

<property name=*"sqlSessionFactory" *ref=*"sqlSessionFactory"*></property>

</bean>

**使用mapper扫描器**

1、 mapper.xml文件编写，

**注意：**

**mapper.xml中的namespace为mapper接口的地址**

**mapper接口中的方法名和mapper.xml中的定义的*statement的id保持一致***

**如果将mapper.xml和mapper接口的名称保持一致则不用在sqlMapConfig.xml中进行配置**

** **

2、 定义mapper接口

**注意mapper.xml的文件名和mapper的接口名称保持一致，且放在同一个目录**

3、 配置mapper扫描器

<bean class=*"org.mybatis.spring.mapper.MapperScannerConfigurer"*>

<property name=*"basePackage" *value=*"mapper接口包地址"*></property>

<property name=*"sqlSessionFactoryBeanName" *value=*"sqlSessionFactory"*/>

</bean>

*basePackage：扫描包路径，中间可以用逗号或分号分隔定义多个包*

4、 使用扫描器后从spring容器中获取mapper的实现对象

扫描器将接口通过代理方法生成实现对象，要spring容器中自动注册，名称为mapper 接口的名称。

## 5. **动态sql** ##

Mybatis提供使用ognl表达式动态生成sql的功能。

**If**

<select id=*"selectUserByUser" *parameterType=*"user" *resultType=*"user"*>

select \* from user

where 1=1

<if test=*"id!=null and id!=''"*>

and id=\#\{id\}

</if>

<if test=*"username!=null and username!=''"*>

and username like '%$\{ username\}%'

</if>

</select>

**注意要做不等于空字符串校验。**

**Where**

上边的sql也可以改为：

<select id=*"selectUserByUser" *parameterType=*"user" *resultType=*"user"*>

select \* from user

<where>

<if test=*"id!=null and id!=''"*>

and id=\#\{id\}

</if>

<if test=*"username!=null and username!=''"*>

and username like '%$\{ username\}%'

</if>

</where>

</select>

<where />可以自动处理第一个and。

**Sql片段**

**需求**

Sql中可将重复的sql提取出来，使用时用include引用即可，最终达到sql重用的目的，如下：

<select id=*"selectUserByUser" *parameterType=*"user" *resultType=*"user"*>

select \* from user

<where>

<if test=*"id!=null and id!=''"*>

and id=\#\{id\}

</if>

<if test=*"username!=null and username!=''"*>

and username like '%$\{ username\}%'

</if>

</where>

</select>

**将where条件抽取出来：**

<sql id=*"query\_user\_where"*>

<if test=*"id!=null and id!=''"*>

and id=\#\{id\}

</if>

<if test=*"username!=null and username!=''"*>

and username like '%$\{ username\}%'

</if>

</sql>

**使用include引用：**

<select id=*"selectUserByUser" *parameterType=*"user" *resultType=*"user"*>

select \* from user

<where>

<include refid=*"query\_user\_where"*/>

</where>

</select>

注意：如果引用其它mapper.xml的sql片段，则在引用时需要加上namespace，如下：

<include refid=*"*namespace.sql片段”/>

[apache]: http://baike.baidu.com/view/28283.htm
[iBatis]: http://baike.baidu.com/view/628102.htm
[70]: /images/20220526/fbfa7636a2cb4eb2a3ffc61400550bfe.png
[70 1]: /images/20220526/b0c49ff4b4934345a25b7274f75d8db6.png
[70 2]: /images/20220526/2659c9cda04d461c80f4fa785a64107a.png
[70 3]: /images/20220526/6ff5ed6364444681ba516023025da9c3.png
[70 4]: /images/20220526/a8ced57f7a1a48e082ff236ca0ea0967.png