为什么使用MyBatis
MyBatis是一个半自动化的持久化层框架。
• JDBC
– SQL夹在Java代码块里，耦合度高导致硬编码内伤
– 维护不易且实际开发需求中sql是有变化，频繁修改的情况多见 • Hibernate和JPA
– 长难复杂SQL，对于Hibernate而言处理也不容易
– 内部自动生产的SQL，不容易做特殊优化。
– 基于全映射的全自动框架，大量字段的POJO进行部分映射时比较困难。
导致数据库性能下降。
• 对开发人员而言，核心sql还是需要自己优化
• sql和java编码分开，功能边界清晰，一个专注业务、一个专注数据。
搭建环境之MyBatis操作数据库
详细教程
myBatis架包
看mybatis打印的SQL语句架包以及.xml文件
java.bean
package bao;
public class User {
private String username;
private String password;
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
@Override
public String toString() {
return "User [password=" + password + ", username=" + username + "]";
}
public User() {
super();
}
}
创建MyBatis全局配置文件mybatis-config.xml
– MyBatis 的全局配置文件包含了影响 MyBatis 行为甚深
的设置（settings）和属性（properties）信息、如数据
库连接池信息等。指导着MyBatis进行工作。我们可以
参照官方文件的配置示例。
<?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">
<configuration>
<environments default="development">
<environment id="development">
<transactionManager type="JDBC" />
<dataSource type="POOLED">
<property name="driver" value="org.apache.derby.jdbc.ClientDriver" />
<property name="url" value="jdbc:derby://localhost:1527/myeclipse" />
<property name="username" value="classiccars" />
<property name="password" value="myeclipse" />
</dataSource>
</environment>
</environments>
<!-- 将我们写好的sql映射文件（EmployeeMapper.xml）一定要注册到全局配置文件（mybatis-config.xml）中 -->
<mappers>
<mapper resource="EmployeeMapper.xml" />
</mappers>
</configuration>
创建SQL映射文件 EmployeeMapper.xml文件
– 映射文件的作用就相当于是定义Dao接口的实现类如何
工作。这也是我们使用MyBatis时编写的最多的文件。
<?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">
<!--
namespace:名称空间;指定为接口的全类名
id：唯一标识
resultType：返回值类型
#{id}：从传递过来的参数中取出id值
public Employee getEmpById(Integer id);
-->
<mapper namespace="dao">
<select id="selectUser" resultType="bao.User">
select * from USER1 where USERNAME = #{id}
</select>
</mapper>
测试类
1、根据全局配置文件，利用SqlSessionFactoryBuilder创建SqlSessionFactory
2、使用SqlSessionFactory获取sqlSession对象。一个SqlSession对象代表和数据库的一次会话
package bao;
import java.io.IOException;
import java.io.InputStream;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Test;
public class MyBatisTest {
/**
* 1、根据xml配置文件（全局配置文件）创建一个SqlSessionFactory对象 有数据源一些运行环境信息
* 2、sql映射文件；配置了每一个sql，以及sql的封装规则等。
* 3、将sql映射文件注册在全局配置文件中
* 4、写代码：
* 1）、根据全局配置文件得到SqlSessionFactory；
* 2）、使用sqlSession工厂，获取到sqlSession对象使用他来执行增删改查
* 一个sqlSession就是代表和数据库的一次会话，用完关闭
* 3）、使用sql的唯一标志来告诉MyBatis执行哪个sql。sql都是保存在sql映射文件中的。
*
* @throws IOException
*/
// 2、获取sqlSession实例，能直接执行已经映射的sql语句
// sql的唯一标识：statement Unique identifier matching the statement to use.
// 执行sql要用的参数：parameter A parameter object to pass to the statement.
public static void main(String []args) throws IOException {
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
SqlSession session = sqlSessionFactory.openSession();
try { System.out.println("segerh");
User blog = session.selectOne("dao.selectUser","df");
System.out.println(blog);
} finally {
session.close();
}
}
}
布局
注意
• SqlSession 的实例不是线程安全的，因此是不能被共享的。
• SqlSession每次使用完成后需要正确关闭，这个关闭操作是必须的
• SqlSession可以直接调用方法的id进行数据库操作，但是我们一般还是推荐使用SqlSession获取到Dao接口的代理类，执行代理对象的方法，可以更安全的进行类型检查操作
接口式编程
在以上基础上做
先写一个借口
package bao;
public interface EmployeeMapper {
public User getEmpById(String id);
}
映射文件改变如下EmployeeMapper.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="bao.EmployeeMapper">
<select id="getEmpById" resultType="bao.User">
select * from USER1 where USERNAME = #{id}
</select>
</mapper>
测试类
package bao;
import java.io.IOException;
import java.io.InputStream;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Test;
/**
* 1、接口式编程
* 原生： Dao ====> DaoImpl
* mybatis： Mapper ====> xxMapper.xml
*
* 2、SqlSession代表和数据库的一次会话；用完必须关闭；
* 3、SqlSession和connection一样她都是非线程安全。每次使用都应该去获取新的对象。
* 4、mapper接口没有实现类，但是mybatis会为这个接口生成一个代理对象。
* （将接口和xml进行绑定）
* EmployeeMapper empMapper = sqlSession.getMapper(EmployeeMapper.class);
* 5、两个重要的配置文件：
* mybatis的全局配置文件：包含数据库连接池信息，事务管理器信息等...系统运行环境信息
* sql映射文件：保存了每一个sql语句的映射信息：
* 将sql抽取出来。
*
*
* @author lfy
*
*/
public class MyBatisTest {
public static void main(String []args) throws IOException {
// 1、获取sqlSessionFactory对象
SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
// 2、获取sqlSession对象
SqlSession openSession = sqlSessionFactory.openSession();
try {
// 3、获取接口的实现类对象
//会为接口自动的创建一个代理对象，代理对象去执行增删改查方法
EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
User employee = mapper.getEmpById("df");
System.out.println(mapper.getClass());
System.out.println(employee);
} finally {
openSession.close();
}
}
public static SqlSessionFactory getSqlSessionFactory() throws IOException {
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
return new SqlSessionFactoryBuilder().build(inputStream);
}
}
MyBatis-全局配置文件
引入dtd约束
properties属性
如果属性在不只一个地方进行了配置，那么 MyBatis 将按照下面的顺序来加载：
– 在 properties 元素体内指定的属性首先被读取。
– 然后根据 properties 元素中的 resource 属性读取类路径下属性文件或根
据 url 属性指定的路径读取属性文件，并覆盖已读取的同名属性。
– 最后读取作为方法参数传递的属性，并覆盖已读取的同名属性。
例子：
在同类下建一个.properties文件
全局配置文件如下mybatis-config.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">
<configuration>
<properties resource="jdbc.properties"></properties>
<!--若是再别的包下，/ 分割
1、mybatis可以使用properties来引入外部properties配置文件的内容；
resource：引入类路径下的资源
url：引入网络路径或者磁盘路径下的资源-->
<environments default="development">
<environment id="development">
<transactionManager type="JDBC" />
<dataSource type="POOLED">
<property name="driver" value="${driver}" />
<property name="url" value="${url}" />
<property name="username" value="${username}" />
<property name="password" value="${password}" />
</dataSource>
</environment>
</environments>
<!-- 将我们写好的sql映射文件（EmployeeMapper.xml）一定要注册到全局配置文件（mybatis-config.xml）中 -->
<mappers>
<mapper resource="EmployeeMapper.xml" />
</mappers>
</configuration>
settings设置
这是 MyBatis 中极为重要的调整设置，它们会改变MyBatis 的运行时行为。
例如：
例子：
在全局配置文件中 configuration内加入：
<!--
2、settings包含很多重要的设置项
setting:用来设置每一个设置项
name：设置项名
value：设置项取值
-->
<settings>
<setting name="mapUnderscoreToCamelCase" value="true"/>
</settings>
typeAliases别名处理器
• 类型别名是为 Java 类型设置一个短的名字，可以方便我们引用某个类。
• 类很多的情况下，可以批量设置别名这个包下的每一个类
创建一个默认的别名，就是简单类名小写。
• 也可以使用@Alias注解为其指定一
例子：
在全局配置文件中 configuration内加入：
<!-- 3、typeAliases：别名处理器：可以为我们的java类型起别名
别名不区分大小写
-->
<typeAliases>
<!-- 1、typeAlias:为某个java类型起别名
type:指定要起别名的类型全类名;默认别名就是类名小写；employee
alias:指定新的别名
-->
<!-- <typeAlias type="bao.Employee" alias="emp"/> -->
<!-- 2、package:为某个包下的所有类批量起别名
name：指定包名（为当前包以及下面所有的后代包的每一个类都起一个默认别名（类名小写），）
-->
<package name="bao"/>
<!-- 3、批量起别名的情况下，使用@Alias注解为某个类型指定新的别名 -->
</typeAliases>
在User.java进行注解
注意的是，MyBatis已经为许多常见的 Java 类型内建了相应的类型别名。它们都是大小写不敏感的，我们在起别名的时候千万不要占用已有的别名。
typeHandlers类型处理器
无论是 MyBatis 在预处理语句（PreparedStatement）中设置一个参数时，还是从结果集中取出一个值时， 都会用类型处理器将获取的值以合适的方式转换成 Java 类型。
在全局配置文件中
在这里插入图片描述
我们可以重写类型处理器或创建自己的类型处理
器来处理不支持的或非标准的类型。 • 步骤：
• 1）、实现org.apache.ibatis.type.TypeHandler接口或
者继承org.apache.ibatis.type.BaseTypeHandler
• 2）、指定其映射某个JDBC类型（可选操作）
• 3）、在mybatis全局配置文件中注册
plugins插件
插件是MyBatis提供的一个非常强大的机制，我们可以通过插件来修改MyBatis的一些核心行为。插件通过动态代理机制，可以介入四大对象的任何一个方法的执行。
• Executor (update, query, flushStatements, commit, rollback, getTransaction, close, isClosed)
• ParameterHandler (getParameterObject, setParameters)
• ResultSetHandler (handleResultSets, handleOutputParameters)
• StatementHandler (prepare, parameterize, batch, update, query)
environments环境
• MyBatis可以配置多种环境，比如开发、测试和生产环境需要有不同的配置。
• 每种环境使用一个environment标签进行配置并指定唯一标识符
• 可以通过environments标签中的default属性指定一个环境的标识符来快速的切换环境
在全局配置文件mybatis-config.xml
<!--
4、environments：环境们，mybatis可以配置多种环境 ,default指定使用某种环境。可以达到快速切换环境。
environment：配置一个具体的环境信息；必须有两个标签；id代表当前环境的唯一标识
transactionManager：事务管理器；
type：事务管理器的类型;JDBC(JdbcTransactionFactory)|MANAGED(ManagedTransactionFactory)
自定义事务管理器：实现TransactionFactory接口.type指定为全类名
dataSource：数据源;
type:数据源类型;UNPOOLED(UnpooledDataSourceFactory)
|POOLED(PooledDataSourceFactory)
|JNDI(JndiDataSourceFactory)
自定义数据源：实现DataSourceFactory接口，type是全类名
-->
<environments default="dev_mysql">
<environment id="dev_mysql">
<transactionManager type="JDBC"></transactionManager>
<dataSource type="POOLED">
<property name="driver" value="${jdbc.driver}" />
<property name="url" value="${jdbc.url}" />
<property name="username" value="${jdbc.username}" />
<property name="password" value="${jdbc.password}" />
</dataSource>
</environment>
<environment id="dev_oracle">
<transactionManager type="JDBC" />
<dataSource type="POOLED">
<property name="driver" value="${orcl.driver}" />
<property name="url" value="${orcl.url}" />
<property name="username" value="${orcl.username}" />
<property name="password" value="${orcl.password}" />
</dataSource>
</environment>
</environments>
databaseIdProvider环境
MyBatis 可以根据不同的数据库厂商执行不同的语句。
• Type： DB_VENDOR
– 使用MyBatis提供的VendorDatabaseIdProvider解析数据库厂商标识。也可以实现DatabaseIdProvider接口来自定义。
• Property-name：数据库厂商标识
• Property-value：为标识起一个别名，方便SQL语句使用databaseId属性引用
• DB_VENDOR
– 会通过 DatabaseMetaData#getDatabaseProductName() 返回的字符串进行设置。由于通常情况下这个字符串都非常长而且相同产品的不同版本会返回不同的值，所以最好通过设置属性别名来使其变短
• MyBatis匹配规则如下：
– 1、如果没有配置databaseIdProvider标签，那么databaseId=null
– 2、如果配置了databaseIdProvider标签，使用标签配置的name去匹配数据库信息，匹配上设置databaseId=配置指定的值，否则依旧为null
– 3、如果databaseId不为null，他只会找到配置databaseId的sql语句
– 4、MyBatis 会加载不带 databaseId 属性和带有匹配当前数据库databaseId 属性的所有语句。如果同时找到带有 databaseId 和不带databaseId 的相同语句，则后者会被舍弃。
在全局配置文件mybatis-config.xml
<!-- 5、databaseIdProvider：支持多数据库厂商的；
type="DB_VENDOR"：VendorDatabaseIdProvider
作用就是得到数据库厂商的标识(驱动getDatabaseProductName())，mybatis就能根据数据库厂商标识来执行不同的sql;
MySQL，Oracle，SQL Server,xxxx
-->
<databaseIdProvider type="DB_VENDOR">
<!-- 为不同的数据库厂商起别名 -->
<property name="MySQL" value="mysql"/>
<property name="Oracle" value="oracle"/>
<property name="SQL Server" value="sqlserver"/>
</databaseIdProvider>
///////////////////////////////////////////////////////////////////////////
///映射文件EmployeeMapper.xml
<select id="getEmpById" resultType="bao.Employee">
select * from tbl_employee where id = #{id}
</select>
<select id="getEmpById" resultType="bao.Employee"
databaseId="mysql">
select * from tbl_employee where id = #{id}
</select>
<select id="getEmpById" resultType="bao.Employee"
databaseId="oracle">
select EMPLOYEE_ID id,LAST_NAME lastName,EMAIL email
from employees where EMPLOYEE_ID=#{id}
</select>
mapper映射
在前面的基础上
mybatis-config.xml
<!-- 6、mappers：将sql映射注册到全局配置中 -->
<mappers>
<!--
mapper:注册一个sql映射
注册配置文件
resource：引用类路径下的sql映射文件
mybatis/mapper/EmployeeMapper.xml
url：引用网路路径或者磁盘路径下的sql映射文件
file:///var/mappers/AuthorMapper.xml
注册接口
class：引用（注册）接口，
1、有sql映射文件，映射文件名必须和接口同名，并且放在与接口同一目录下；
2、没有sql映射文件，所有的sql都是利用注解写在接口上;
推荐：
比较重要的，复杂的Dao接口我们来写sql映射文件
不重要，简单的Dao接口为了开发快速可以使用注解；
-->
<!-- <mapper resource="bao/EmployeeMapper.xml"/> -->
<!-- <mapper class="bao.EmployeeMapperAnnotation"/> -->
<!-- 批量注册：这种方式要求SQL映射文件名必须和接口名相同并且在同一目录下-->
<package name="bao"/>
</mappers>
////////////////////////////////////////////////////////////////////////////
//接口1
package bao;
import com.atguigu.mybatis.bean.Employee;
public interface EmployeeMapper {
public Employee getEmpById(Integer id);
}
//////////////////////////////////////////////////////////////////////////
//接口2
package bao;
import org.apache.ibatis.annotations.Select;
import com.atguigu.mybatis.bean.Employee;
public interface EmployeeMapperAnnotation {
@Select("select * from tbl_employee where id=#{id}")
public Employee getEmpById(Integer id);
}
MyBatis-映射文件
• 映射文件指导着MyBatis如何进行数据库增删改查，有着非常重要的意义；
•cache –命名空间的二级缓存配置
•cache-ref – 其他命名空间缓存配置的引用。
•resultMap – 自定义结果集映射
•parameterMap – 已废弃！老式风格的参数映射
•sql –抽取可重用语句块。
•insert – 映射插入语句
•update – 映射更新语句
•delete – 映射删除语句
•select – 映射查询语句
insert、update、delete元素
例子：
EmployeeMapper接口改为
package bao;
import org.apache.ibatis.annotations.Select;
public interface EmployeeMapper {
public User getEmpById(String id);
public Long addEmp(User employee);
public boolean updateEmp(User employee);
public void deleteEmpById(String s);
}
/////////////////////////////////////////////////////////////////////////////
//映射文件
<?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="bao.EmployeeMapper">
<select id="getEmpById" resultType="emp">
select * from USER1 where USERNAME = #{username}
</select>
<insert id="addEmp" ><!--parameterType：参数类型，可以省略，-->
insert into USER1(USERNAME,PASSWORD) values(#{username},#{password})
</insert>
<update id="updateEmp">
update USER1 set PASSWORD=#{password}
where USERNAME=#{username}
</update>
<delete id="deleteEmpById">
delete from
USER1
where USERNAME=#{username}
</delete>
</mapper>
///////////////////////////////////////////////////////////////////////
//测试类
package bao;
import java.io.IOException;
import java.io.InputStream;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
/**
* 测试增删改
* 1、mybatis允许增删改直接定义以下类型返回值
* Integer、Long、Boolean、void
* 2、我们需要手动提交数据
* sqlSessionFactory.openSession();===》手动提交
* sqlSessionFactory.openSession(true);===》自动提交
*/
public class MyBatisTest {
public static void main(String []args) throws IOException {
// 1、获取sqlSessionFactory对象
SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
// 2、获取sqlSession对象
SqlSession openSession = sqlSessionFactory.openSession();
try {
// 3、获取接口的实现类对象
//会为接口自动的创建一个代理对象，代理对象去执行增删改查方法
EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
User employee = new User("user","woain");
mapper.addEmp(employee);
System.out.println(mapper.updateEmp(employee));
mapper.deleteEmpById("user");
openSession.commit();
System.out.println(mapper.getClass());
System.out.println(employee);
} finally {
openSession.close();
}
}
public static SqlSessionFactory getSqlSessionFactory() throws IOException {
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
return new SqlSessionFactoryBuilder().build(inputStream);
}
}
主键生成方式
1.
若数据库支持自动生成主键的字段（比如 MySQL 和 SQL Server），则可以设置
useGeneratedKeys=”true”，然后再把keyProperty 设置到目标属性上。
将上面映射文件中的添加语句改为
/**获取自增主键的值：
mysql支持自增主键，自增主键值的获取，mybatis也是利用statement.getGenreatedKeys()；
useGeneratedKeys="true"；使用自增主键获取主键值策略
keyProperty；指定对应的主键属性，也就是mybatis获取到主键值以后，将这个值封装给javaBean的哪个属性*/
<insert id="addEmp" useGeneratedKeys="true" keyProperty="username">
insert into USER1(PASSWORD) values(#{password})
</insert>
上面测试类部分改为（前提在数据库表中username设为自增字段）
User employee = new User(null,"26woain");
mapper.addEmp(employee);
System.out.println(employee.getUsername());
//mapper.deleteEmpById("user");
openSession.commit();
2.
而对于不支持自增型主键的数据库（例如Oracle），则可以使用 selectKey 子元素：
selectKey 元素将会首先运行，id 会被设置，然后插入语句会被调用
在映射文件中加入
<!--
获取非自增主键的值：
Oracle不支持自增；Oracle使用序列来模拟自增；
每次插入的数据的主键是从序列中拿到的值；如何获取到这个值；
-->
<insert id="addEmp" databaseId="oracle">
<!--
keyProperty:查出的主键值封装给javaBean的哪个属性
order="BEFORE":当前sql在插入sql之前运行
AFTER：当前sql在插入sql之后运行
resultType:查出的数据的返回值类型
BEFORE运行顺序：
先运行selectKey查询id的sql；查出id值封装给javaBean的id属性
在运行插入的sql；就可以取出id属性对应的值
AFTER运行顺序：
先运行插入的sql（从序列中取出新值作为id）；
再运行selectKey查询id的sql；
-->
<selectKey keyProperty="id" order="BEFORE" resultType="Integer">
<!-- 编写查询主键的sql语句 -->
<!-- BEFORE-->
select EMPLOYEES_SEQ.nextval from dual
<!-- AFTER：
select EMPLOYEES_SEQ.currval from dual -->
</selectKey>
<!-- 插入时的主键是从序列中拿到的 -->
<!-- BEFORE:-->
insert into employees(EMPLOYEE_ID,LAST_NAME,EMAIL)
values(#{id},#{lastName},#{email<!-- ,jdbcType=NULL -->})
<!-- AFTER：
insert into employees(EMPLOYEE_ID,LAST_NAME,EMAIL)
values(employees_seq.nextval,#{lastName},#{email}) -->
</insert>
参数（Parameters）传递
单个参数：mybatis不会做特殊处理，
#{参数名/任意名}：取出参数值。
多个参数：mybatis会做特殊处理。
多个参数会被封装成 一个map，
key：param1…paramN,或者参数的索引也可以
value：传入的参数值
#{}就是从map中获取指定的key的值；
异常：
org.apache.ibatis.binding.BindingException:
Parameter ‘id’ not found.
Available parameters are [1, 0, param1, param2]
操作：
方法：public Employee getEmpByIdAndLastName(Integer id,String lastName);
取值：#{id},#{lastName}
例子
全局配置文件EmployeeMapper.xml改善
//接口查询多参可看下面
<select id="getEmpById" resultType="emp">
select * from USER1 where USERNAME = #{param1} and Password=#{param2}
</select>
【命名参数】：明确指定封装参数时map的key；@Param(“id”)
多个参数会被封装成 一个map，
key：使用@Param注解指定的值
value：参数值
#{指定的key}取出对应的参数值
接口变化如下
//bao.EmployeeMapper
public User getEmpById(@Param("id")String id,@Param("s")String s);
//映射文件查询变化
select * from USER1 where USERNAME = #{id} and Password=#{s}
POJO：
如果多个参数正好是我们业务逻辑的数据模型，我们就可以直接传入pojo；
#{属性名}：取出传入的pojo的属性值
Map：
如果多个参数不是业务模型中的数据，没有对应的pojo，不经常使用，为了方便，我们也可以传入map
#{key}：取出map中对应的值
例子：
//EmployeeMapper.java在上面基础上加入
public User getmap(Map<String, Object> map);
//////////////////////////////////////////////////////////////////////////
//映射文件在上面基础上EmployeeMapper.xml
<select id="getmap" resultType="emp">
select * from USER1 where USERNAME = #{id}
</select>
///////////////////////////////////////////////////////////////////////
//测试文件MybatisText.java
Map<String, Object> map = new HashMap<String, Object>();
map.put("id", 1);
User employee = mapper.getmap(map);
System.out.println(employee);
TO：
如果多个参数不是业务模型中的数据，但是经常要使用，推荐来编写一个TO（Transfer Object）数据传输对象
Page{
int index;
int size;
}
拓展：
public Employee getEmp(@Param(“id”)Integer id,String lastName);
取值：id==>#{id/param1} lastName==>#{param2}
public Employee getEmp(Integer id,@Param(“e”)Employee emp);
取值：id==>#{param1} lastName===>#{param2.lastName/e.lastName}
注意：如果是Collection（List、Set）类型或者是数组，也会特殊处理。也是把传入的list或者数组封装在map中。
key：Collection（collection）,如果是List还可以使用这个key(list)
数组(array)
public Employee getEmpById(List ids);
取值：取出第一个id的值： #{list[0]}
参数值的获取
#{}：可以获取map中的值或者pojo对象属性的值；
${}：可以获取map中的值或者pojo对象属性的值；
select * from tbl_employee where id=${id} and last_name=#{lastName}
Preparing: select * from tbl_employee where id=2 and last_name=?
区别：
#{}:是以预编译的形式，将参数设置到sql语句中；PreparedStatement；防止sql注入
${}:取出的值直接拼装在sql语句中；会有安全问题；
大多情况下，我们去参数的值都应该去使用#{}；
原生jdbc不支持占位符的地方我们就可以使用${}进行取值
比如分表、排序。。。；按照年份分表拆分
select * from ${year}_salary where xxx;
select * from tbl_employee order by ${f_name} ${order}
例子：
在以前的基础上
//测试bao.MyBatisTest
EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
Map<String, Object> map = new HashMap<String, Object>();
map.put("id", 1);
map.put("user", "USER1");
User employee = mapper.getmap(map);
System.out.println(employee);
openSession.commit()
///////////////////////////////////////////////////////////////////////////
//映射文件/mybaits/src/bao/EmployeeMapper.xml
<select id="getmap" resultType="emp">
select * from ${user} where USERNAME = ${id}
</select>
#{}:更丰富的用法：
规定参数的一些规则：
javaType、 jdbcType、 mode（存储过程）、 numericScale、
resultMap、 typeHandler、 jdbcTypeName、 expression（未来准备支持的功能）；
jdbcType通常需要在某种特定的条件下被设置：
在我们数据为null的时候，有些数据库可能不能识别mybatis对null的默认处理。比如Oracle（报错）；
JdbcType OTHER：无效的类型；因为mybatis对所有的null都映射的是原生Jdbc的OTHER类型，oracle不能正确处理;
由于全局配置中：jdbcTypeForNull=OTHER；oracle不支持；两种办法
1、#{email,jdbcType=NULL};
2、jdbcTypeForNull=NULL
<setting name="jdbcTypeForNull" value="NULL"/>
select元素
• Select元素来定义查询操作。
• Id：唯一标识符。
– 用来引用这条语句，需要和接口的方法名一致
• parameterType：参数类型。 – 可以不传，MyBatis会根据TypeHandler自动推断
• resultType：返回值类型。 – 别名或者全类名，如果返回的是集合，定义集合中元
素的类型。不能和resultMap同时使用
例子：
以前面的例子做基础：
//接口bao.EmployeeMapper.java
public List<User> getEmpsByLastNameLike(String lastName);
//映射文件/mybaits/wenjian/EmployeeMapper.xml
<select id="getEmpsByLastNameLike" resultType="bao.User">
select * from USER1 where password like #{lastName}
</select>
//测试类
System.out.println(mapper.getEmpsByLastNameLike("1%"));
映射文件select记录封装map
以前面的例子为基础
例子：
//接口bao.EmployeeMapper.java
//多条记录封装一个map：Map<Integer,Employee>:键是这条记录的主键，值是记录封装后的javaBean
//@MapKey:告诉mybatis封装这个map的时候使用哪个属性作为map的key
@MapKey("username")
public Map<String, User> getEmpByLastNameLikeReturnMap(String lastName);
//返回一条记录的map；key就是列名，值就是对应的值
public Map<String, Object> getEmpByIdReturnMap(Integer id);
///////////////////////////////////////////////////////////////////////////
//映射文件/mybaits/wenjian/EmployeeMapper.xml
<!--public Map<Integer, Employee> getEmpByLastNameLikeReturnMap(String lastName); -->
<select id="getEmpByLastNameLikeReturnMap" resultType="bao.User">
select * from USER1 where password like #{lastName}
</select>
<!--public Map<String, Object> getEmpByIdReturnMap(Integer id); -->
<select id="getEmpByIdReturnMap" resultType="map">
select * from USER1 where username=#{id}
</select>
////////////////////////////////////////////////////////////////////////////测试
System.out.println(mapper.getEmpByIdReturnMap(1)); System.out.println(mapper.getEmpByLastNameLikeReturnMap("123"));
自动映射
1、全局setting设置
– autoMappingBehavior默认是PARTIAL，开启自动映射的功能。唯一的要求是列名和javaBean属性名一致
– 如果autoMappingBehavior设置为null则会取消自动映射
– 数据库字段命名规范，POJO属性符合驼峰命名法，如A_COLUMNaColumn，我们可以开启自动驼峰命名规则映射功能，mapUnderscoreToCamelCase=true。
2、自定义resultMap，实现高级结果集映射。
• constructor - 类在实例化时, 用来注入结果到构造方法中
– idArg - ID 参数; 标记结果作为 ID 可以帮助提高整体效能
– arg - 注入到构造方法的一个普通结果
• id – 一个 ID 结果; 标记结果作为 ID 可以帮助提高整体效能
• result – 注入到字段或 JavaBean 属性的普通结果
• association – 一个复杂的类型关联;许多结果将包成这种类型
– 嵌入结果映射 – 结果映射自身的关联,或者参考一个
• collection – 复杂类型的集 – 嵌入结果映射 – 结果映射自身的集,或者参考一个
• discriminator – 使用结果值来决定使用哪个结果映射
– case – 基于某些值的结果映射
• 嵌入结果映射 – 这种情形结果也映射它本身,因此可以包含很多相同的元
素,或者它可以参照一个外部的结果映射。
_select_resultMap_关联查询_环境搭建
例子（以前面的例子为基础）：
//接口bao.EmployeeMapper.java
public User getEmpById1(Integer id);
//////////////////////////////////////////////////////////////////////
//映射文件/mybaits/wenjian/EmployeeMapper.xml
<!--自定义某个javaBean的封装规则
type：自定义规则的Java类型
id:唯一id方便引用
-->
<resultMap type="bao.User" id="MySimpleEmp">
<!--指定主键列的封装规则
id定义主键会底层有优化；
column：指定哪一列
property：指定对应的javaBean属性
-->
<id column="username" property="username"/>
<!-- 定义普通列封装规则 -->
<result column="password" property="password"/>
<!-- 其他不指定的列会自动封装：我们只要写resultMap就把全部的映射规则都写上。 -->
</resultMap>
<!-- resultMap:自定义结果集映射规则； -->
<!-- public Employee getEmpById1(Integer id); -->
<select id="getEmpById1" resultMap="MySimpleEmp">
select * from USER1 where username=#{id}
</select>
///////////////////////////////////////////////
//测试类
System.out.println(mapper.getEmpById1(1));
_select_resultMap_关联查询_级联属性封装结果
例子（在以前的例子基础上）:
//接口bao.EmployeeMapper.java
public User getEmpAndDept(Integer id);
/////////////////////////////////////////////////////////////////////
//User.java 改变如下：
package bao;
import org.apache.ibatis.type.Alias;
public class User {
private int username;
private String password;
private Department dpartment;
public Department getDpartment() {
return dpartment;
}
public void setDpartment(Department dpartment) {
this.dpartment = dpartment;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public int getUsername() {
return username;
}
public void setUsername(int username) {
this.username = username;
}
@Override
public String toString() {
return "User [dpartment=" + dpartment + ", password=" + password
+ ", username=" + username + "]";
}
public User() {
super();
// TODO Auto-generated constructor stub
}
public User(int username, String password, Department dpartment) {
super();
this.username = username;
this.password = password;
this.dpartment = dpartment;
}
}
///mybaits/src/bao/Department.java
package bao;
public class Department {
private int id;
private String name;
public Department() {
super();
// TODO Auto-generated constructor stub
}
public Department(int id, String name) {
super();
this.id = id;
this.name = name;
}
@Override
public String toString() {
return "Department [id=" + id + ", name=" + name + "]";
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
///////////////////////////////////////////////////////////////////////////
////映射文件/mybaits/wenjian/EmployeeMapper.xml
<!--
场景一：
查询User的同时查询员工对应的部门
User===Department
一个员工有与之对应的部门信息；
-->
<!--
联合查询：级联属性封装结果集
-->
<resultMap type="bao.User" id="MyDifEmp2">
<id column="username" property="username"/>
<result column="password" property="password"/>
<result column="did" property="dpartment.id"/>
<result column="name" property="dpartment.name"/>
</resultMap>
<!-- public Employee getEmpAndDept(Integer id);-->
<select id="getEmpAndDept" resultMap="MyDifEmp2">
SELECT * FROM USER1,DEPARTMENT
WHERE USER1.DID=DEPARTMENT.ID AND USER1.USERNAME=#{id}
</select>
/////////////////////////////////////////////////////////////////////
//测试
System.out.println(mapper.getEmpAndDept(1));
id & result
• id 和 result 映射一个单独列的值到简单数据类型(字符串,整型,双精度浮点数,日期等)的属性或字段。
association
复杂对象映射
• POJO中的属性可能会是一个对象
• 我们可以使用联合查询，并以级联属性的方式封装对象。
• 使用association标签定义对象的封装规则
association-嵌套结果集
例子（以前面的例子为基础）：
////映射文件/mybaits/wenjian/EmployeeMapper.xml
<!--
使用association定义关联的单个对象的封装规则；
-->
<resultMap type="bao.User" id="MyDifEmp">
<id column="username" property="username"/>
<result column="password" property="password"/>
<!-- association可以指定联合的javaBean对象-->
<!-- property="dept"：指定哪个属性是联合的对象-->
<!-- javaType:指定这个属性对象的类型[不能省略]-->
<association property="dpartment" javaType="bao.Department">
<id column="did" property="id"/>
<result column="name" property="name"/>
</association>
</resultMap>
<!-- public Employee getEmpAndDept(Integer id);-->
<select id="getEmpAndDept" resultMap="MyDifEmp">
SELECT * FROM USER1,DEPARTMENT
WHERE USER1.DID=DEPARTMENT.ID AND USER1.USERNAME=#{id}
</select>
_select_resultMap_关联查询_association分步查询
例子（以前面的例子为基础）：
//1.给Department.java配置相应的接口DepartmentMapper.java
package bao;
public interface DepartmentMapper {
public Department getEmpById10(Integer id);
}
//2..给Department.java配置相应的映射文件DepartmentMapper.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="bao.DepartmentMapper">
<select id="getEmpById10" resultType="bao.Department">
select * from DEPARTMENT where id=#{id}</select>
</mapper>
//3.映射文件DepartmentMapper.xml注册在全局配置文件中
<mappers>
<mapper resource="EmployeeMapper.xml" />
<mapper resource="DepartmentMapper.xml" />
</mappers>
//4.bao.EmployeeMapper.java接口加入
public User getEmpByIdStep(Integer id);
///////////////////////////////////////////////////////////////////
//5.映射文件EmployeeMapper.xml加入
<!-- 使用association进行分步查询：
1、先按照员工id查询员工信息
2、根据查询员工信息中的did值去部门表查出部门信息
3、部门设置到员工中；
-->
<resultMap type="bao.User" id="MyEmpByStep">
<id column="username" property="username"/>
<result column="password" property="password"/>
<!-- association定义关联对象的封装规则
select:表明当前属性是调用select指定的方法查出的结果
column:指定将哪一列的值传给这个方法
流程：使用select指定的方法（传入column指定的这列参数的值）查出对象，并封装给property指定的属性
-->
<association property="dpartment"
select="bao.DepartmentMapper.getEmpById10"
column="did">
</association>
</resultMap>
<!-- public Employee getEmpByIdStep(Integer id);-->
<select id="getEmpByIdStep" resultMap="MyEmpByStep">
select * from USER1 where username=#{id}
</select>
//6.测试
System.out.println(mapper.getEmpByIdStep(1));
_select_resultMap_关联查询_分步查询&延迟加载
延迟加载
MyBatis中的延迟加载，也称为懒加载，是指在进行关联查询的时候，按照设 置延迟加载规则推迟对关联对象的select检索。延迟加载可以有效的减少数据库 的压力。
注意:MyBatis的延迟加载只是对关联对象的查询有延迟设置，对于主加载对象 都是直接执行查询语句的。
详细解释
例子（以前面的例子为基础）：
在全局配置文件/mybaits/wenjian/mybatis-config.xml加入（properties之后typeAliases之前）
<settings>
<!-- <setting name="mapUnderscoreToCamelCase" value="true"/> -->
<setting name="jdbcTypeForNull" value="NULL"/>
<!--显示的指定每个我们需要更改的配置的值，即使他是默认的。防止版本更新带来的问题 -->
<setting name="lazyLoadingEnabled" value="true"/>
<setting name="aggressiveLazyLoading" value="false"/>
</settings>
_select_resultMap_关联查询_collection定义关联集合封装规
例子（以前面的例子为基础）：
//bao.Department.java 加入以下属性以及getset
private List<User> list;
//bao.DepartmentMapper.java
public Department getDeptByIdPlus(Integer id);
///wenjian/DepartmentMapper.xml
<!--嵌套结果集的方式，使用collection标签定义关联的集合类型的属性封装规则 -->
<resultMap type="bao.Department" id="MyDept">
<id column="did" property="id"/>
<result column="name" property="name"/>
<!--
collection定义关联集合类型的属性的封装规则
ofType:指定集合里面元素的类型
-->
<collection property="list" ofType="bao.User">
<!-- 定义这个集合中元素的封装规则 -->
<id column="username" property="username"/>
<result column="password" property="password"/>
</collection>
</resultMap>
<select id="getDeptByIdPlus" resultMap="MyDept">
select * from USER1,DEPARTMENT where USER1.DID=DEPARTMENT.ID and id=#{id}</select>
//测试
DepartmentMapper mapper = openSession.getMapper( DepartmentMapper.class);
System.out.println(mapper.getDeptByIdPlus(1));
_select_resultMap_关联查询_collection分步查询&延迟加载
例子（以前面的例子为基础）：
//bao.DepartmentMapper.java
public Department getDeptByIdStep(Integer id);
///wenjian/DepartmentMapper.xml
<!-- collection：分段查询 -->
<resultMap type="bao.Department" id="MyDeptStep">
<id column="id" property="id"/>
<id column="name" property="name"/>
<collection property="list"
select="bao.EmployeeMapper.getEmpsByDeptId"
column="id"></collection>
</resultMap>
<!-- public Department getDeptByIdStep(Integer id); -->
<select id="getDeptByIdStep" resultMap="MyDeptStep">
select * from DEPARTMENT where id=#{id}
</select>
///mybaits/src/bao/EmployeeMapper.java
public List<User> getEmpsByDeptId(Integer id);
///mybaits/wenjian/EmployeeMapper.xml
<!--
场景二：
查询部门的时候将部门对应的所有员工信息也查询出来：注释在DepartmentMapper.xml中
-->
<!-- public List<Employee> getEmpsByDeptId(Integer id); -->
<select id="getEmpsByDeptId" resultType="bao.User">
select * from USER1 where did=#{id}
</select>
//测试
System.out.println(mapper.getDeptByIdStep(1));
_select_resultMap_分步查询传递多列值&fetchType
例子（以前面的例子为基础）：
///wenjian/DepartmentMapper.xml
<!-- collection：分段查询 -->
<resultMap type="bao.Department" id="MyDeptStep">
<id column="id" property="id"/>
<id column="dept_name" property="departmentName"/>
<collection property="emps"
select="bao.EmployeeMapper.getEmpsByDeptId"
column="{id=id}" fetchType="lazy"></collection>
</resultMap>
<!-- public Department getDeptByIdStep(Integer id); -->
<select id="getDeptByIdStep" resultMap="MyDeptStep">
select * from DEPARTMENT where id=#{id}
</select>
<!-- 扩展：多列的值传递过去：
将多列的值封装map传递；
column="{key1=column1,key2=column2}"//key1值是传进参数变量，后面是值
fetchType="lazy"：表示使用延迟加载；
- lazy：延迟
- eager：立即
-->
_select_resultMap_discriminator鉴别器
例子（以前面的例子为基础）：
///mybaits/wenjian/EmployeeMapper.xml
<resultMap type="bao.User" id="MyEmpDis">
<id column="username" property="username"/>
<result column="password" property="password"/>
<!--
column：指定判定的列名
javaType：列值对应的java类型 -->
<discriminator javaType="string" column="password">
<!-- resultType:指定封装的结果类型；不能缺少。/resultMap
password=="26"时如下赋值-->
<case value="26" resultType="bao.User">
<association property="dpartment"
select="bao.DepartmentMapper.getEmpById10"
column="did">
</association>
</case>
<!--password=="123"时如下赋值 -->
<case value="123" resultType="bao.User">
<id column="username" property="username"/>
<result column="username" property="password"/>
</case>
</discriminator>
</resultMap>