本篇文章为你整理了MyBatis入门（mybatis入门程序编写）的详细内容，包含有mybatis入门菜鸟教程 mybatis入门程序编写 mybatis入门案例 mybatis入门书籍 MyBatis入门，希望能帮助你了解 MyBatis入门。
本文所有数据均来自狂神说java,视频链接：https://www.bilibili.com/video/BV1NE411Q7Nx/?spm_id_from=333.337.search-card.all.click
环境
java基础
JDK 1.8
Mysql5.7
maven 3.6.1
开发工具 idea
Junit
SSM框架：配置文件的最好方式：看官网文档
1.1 什么是Mybatis?
MyBatis是一款优秀的持久层框架
支持定制SQL、存储过程以及高级映射
Mybatis避免了几乎所有的JDBC代码和手动设置参树，以及获取结果集
Mybatis可以使用简单的XML或注解来配置和映射原生类型、接口和Java的POJO（Plain Old Java Objects,普通老式Java对象）为数据库中的记录
MyBatis本是apache的一个开源项目iBatis
2010年这个项目由apache software foundation迁移到了google code，并且改名为MyBatis
2013年11月迁移到Github
如何获得Mybatis？
Maven仓库:下载地址
!-- https://mvnrepository.com/artifact/org.mybatis/mybatis --
dependency
groupId org.mybatis /groupId
artifactId mybatis /artifactId
version 3.5.2 /version
/dependency
Github:Mybatis地址
中文文档地址
1.2 持久化
数据持久化
持久化就是将程序的数据保存在硬盘中
内存特性：断电会失去信息
数据库(jdbc),io文件持久化
生活中的持久化：冷藏，写……
为什么需要持久化？
我们需要将一些数据保存下来，方便以后使用
内存价格过高（制造成本高）
1.3 持久层
复习学习过的层:Dao,Service,Controller
持久层的工作
完成持久化工作的代码块
层之间的接线非常明显
1.4 为什么需要Mybatis?
帮助程序员将数据存入到数据库中
传统的JDBC代码太复杂了
简化、框架、自动化
不用Mybatis也能实现，Mybatis可以使程序员在不知道底层原理的情况下，完成网站后台搭建
解除sql与程序代码的耦合
提供映射标签，支持对象与数据库的orm字段关系映射
提供对象关系映射标签，支持对象关系组建维护
提供xml标签，支持编写动态sql。
新建普通maven项目作为父项目，导入sql驱动，mybatis，junit组件
!--导入依赖--
dependencies
!--mysql驱动--
dependency
groupId mysql /groupId
artifactId mysql-connector-java /artifactId
version 5.1.46 /version
/dependency
!--Mybatis--
dependency
groupId org.mybatis /groupId
artifactId mybatis /artifactId
version 3.5.2 /version
/dependency
!--junit--
dependency
groupId junit /groupId
artifactId junit /artifactId
version 4.12 /version
/dependency
/dependencies
添加配置文件：
在src- main- resources目录下新建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
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}"/ //数据库名字，默认root
property name="password" value="${password}"/ //数据库密码，自己的数据库密码，一般为root
/dataSource
/environment
/environments
/configuration
配置文件的作用就是连接数据库
编写mybatis工具类
//SqlSessionFactory --生产-- SqlSession
public class MybatisUtils {
private static SqlSessionFactory sqlSessionFactory; //提升作用域
//获取工厂，固定代码
static {
try {
String resource="mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
} catch (IOException e) {
e.printStackTrace();
//获取sqlSession
//SqlSession完全包含了面向对象数据库执行SQL命令所需的方法
public static SqlSession getSqlSession(){ return sqlSessionFactory.openSession();}
接口实现类改为以xxxMapper.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"
!--namespace：命名空间，绑定mapper/Dao接口--
mapper namespace="com.qian.dao.UserDao"
!--id:接口的方法，resultType：接口的返回值类型--
select id="getUserList" resultType="com.qian.pojo.User"
select * from mybatis.user where id = #{id}
/select
/mapper
UserDao mapper = sqlSession.getMapper(UserDao.class);
List User list = mapper.getUserList();
for (User u:list){
System.out.println(u);
//不推荐使用
这种方式能够正常工作，对使用旧版本 MyBatis 的用户来说也比较熟悉。但现在有了一种更简洁的方式——使用和指定语句的参数和返回值相匹配的接口（比如 BlogMapper.class），现在你的代码不仅更清晰，更加类型安全，还不用担心可能出错的字符串字面值以及强制类型转换。
// List User list = sqlSession.selectList("com.qian.dao.UserDao.getUserList");
// for (User user : list) {
// System.out.println(user);
//关闭SqlSession
sqlSession.close();
异常1：org.apache.ibatis.binding.BindingException: Type interface com.qian.dao.UserDao is not known to the MapperRegistry.
解决方法：每一个Mapper.xml文件都需要在src- main- resources目录下新建mybatis-config.xml的核心配置文件中 注册
xml mappers mapper resource="com/qian/dao/UserMapper.xml" /mappers
异常2：
Error building SqlSession.
The error may exist in com/qian/dao/UserMapper.xml
Cause: org.apache.ibatis.builder.BuilderException: Error parsing SQL Mapper Configuration.
Cause: java.io.IOException: Could not find resource com/qian/dao/UserMapper.xml
解决方法：
xml !-- 在maven中，约定大于配置，在pom中添加此文件可以解决 -- build resources resource directory src/main/resources /directory includes include **/*.properties /include include **/*.xml /include /includes filtering true /filtering /resource resource directory src/main/java /directory includes include **/*.properties /include include **/*.xml /include /includes filtering true /filtering /resource /resources /build
异常3：
Error building SqlSession.
The error may exist in com/qian/dao/UserMapper.xml
Cause: org.apache.ibatis.builder.BuilderException: Error parsing SQL Mapper Configuration.
Cause: org.apache.ibatis.builder.BuilderException: Error creating document instance. Cause: org.xml.sax.SAXParseException; lineNumber: 6;
解决方法：
xml ?xml version="1.0" encoding="UTF-8" ? !-- 把mybatis-config.xml与mybatis-config.xml文件的encoding修改成下面的 -- ?xml version="1.0" encoding="UTF8" ?
另一种解决方法：删除掉xxxMapper.xml文件中所有的中文注释
异常4：
Cause: com.mysql.jdbc.exceptions.jdbc4.CommunicationsException: Communications link failure
解决方法：
useSSL=true改为false(true也可以，需要在mysql中启用SSL)
xml property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=false amp;useUnicode=true amp;characterEncoding=UTF8 amp;serverTimezone=GMT%2B8"/
2.5 总结
public class UserDaoTest {
@Test
public void test(){
//获取SqlSession对象
SqlSession sqlSession = MybatisUtils.getSqlSession();
try{
//获取mapper
UserDao mapper = sqlSession.getMapper(UserDao.class);
List User list = mapper.getUserList();
for (User u:list){
System.out.println(u);
//不推荐使用
// List User list = sqlSession.selectList("com.qian.dao.UserDao.getUserList");
// for (User user : list) {
// System.out.println(user);
}finally {
//关闭SqlSession
sqlSession.close();
3 增删改查实现
3.1 Mapper接口
public interface UserMapper {
//查询全部用户
List User getUserList();
//根据id查询用户
User getUserById(int id);
//增加新的用户
boolean insertNewUser(User u);
//删除用户
boolean deleteUserById(int id);
boolean deleteUserByName(String name);
//修改用户
boolean updateUserById(User u);
3.2 xxxMapper.xml文件
?xml version="1.0" encoding="utf8" ?
!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd"
!--namespace：命名空间，绑定mapper/Dao接口--
!--id:接口的方法，resultType：接口的返回值类型--
mapper namespace="com.qian.dao.UserMapper"
select id="getUserList" resultType="com.qian.pojo.User"
select * from mybatis.user
/select
select id="getUserById" parameterType="int" resultType="com.qian.pojo.User"
select * from mybatis.user where id=#{id}
/select
!-- 对象中的属性，可以直接取出来用 --
insert id="insertNewUser" parameterType="com.qian.pojo.User"
insert into mybatis.user (id, name, pwd) VALUES (#{id},#{name},#{pwd})
/insert
delete id="deleteUserById" parameterType="int"
delete from mybatis.user where id=#{id}
/delete
delete id="deleteUserByName" parameterType="String"
delete from mybatis.user where name=#{name}
/delete
update id="updateUserById" parameterType="com.qian.pojo.User"
update mybatis.user set name=#{name},pwd=#{pwd} where id=#{id}
/update
/mapper
3.3 Test类
注意：增删改要提交事务！！！
public class UserDaoTest {
@Test
public void test(){
//获取SqlSession对象
SqlSession sqlSession = MybatisUtils.getSqlSession();
try{
//获取mapper
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
// 查询全表
// List User list = mapper.getUserList();
// for (User u:list){
// System.out.println(u);
//根据id查询
// User user = mapper.getUserById(1);
// System.out.println(user);
//插入新用户,注意：更新，插入，删除都需要提交事务
// User user1 = new User(4,"李四","25615");
// boolean isInserted = mapper.insertNewUser(user1);
// sqlSession.commit();
//代码优化
// if (mapper.insertNewUser(new User(4,"李四","25615"))) sqlSession.commit();
//删除用户
// if (mapper.deleteUserById(4))sqlSession.commit();
if (mapper.deleteUserByName("李四"))sqlSession.commit();
//修改用户
if (mapper.updateUserById(new User(4,"王五","6849816")))sqlSession.commit();
}finally {
//关闭SqlSession
sqlSession.close();
3.4 常见错误
标签要匹配
resource绑定Mapper,需要使用路径
配置文件中不要写注释
useSSL=true有时候无法使用，改为false
3.5 万能Map
UserMapper.java
User getUser(Map String,Object map);
boolean addUser(Map String,Object map);
UserMapper.xml
select id="getUser" parameterType="map" resultType="com.qian.pojo.User"
select * from mybatis.user where id=#{userId}
/select
insert id="addUser" parameterType="map"
insert into mybatis.user (id, name, pwd) VALUES (#{userId},#{userName},#{password})
/insert
Test.java
@Test
public void test(){
//获取SqlSession对象
SqlSession sqlSession = MybatisUtils.getSqlSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
Map String, Object map = new HashMap String, Object
map.put("userId",5);
User user = mapper.getUser(map);
System.out.println(user);
map.put("userId",5);
map.put("userName","孙悟空");
map.put("password","565464");
if (mapper.addUser(map)) sqlSession.commit();
sqlSession.close();
select id="getUsersLike" resultType="com.qian.pojo.User"
select * from mybatis.user where name like #{value};
/select
UserMapper mapper = getUserMapper();
List User userList = mapper.getUsersLike("%千%");
System.out.println(userList);
public UserMapper getUserMapper(){
return MybatisUtils.getSqlSession().getMapper(UserMapper.class);
在sql中使用拼接符
select id="getUsersLike" resultType="com.qian.pojo.User"
select * from mybatis.user where name like "%"#{value}"%"
/select
mybatis-config.xml
MyBatis 的配置文件包含了会深深影响 MyBatis 行为的设置和属性信息。 配置文档的顶层结构如下：
configuration（配置）
properties（属性）
settings（设置）
typeAliases（类型别名）
environments（环境配置）
environment（环境变量）
transactionManager（事务管理器）
dataSource（数据源）你
mappers（映射器）
4.2 环境配置（environments）
MyBatis 可以配置成适应多种环境,尽管可以配置多个环境，但每个 SqlSessionFactory 实例只能选择一种环境。
MyBatis默认事务连接器就是JDBC，连接池POOLED
数据源（dataSource）
作用：连接数据库
c3p0 druid dbcp
大多数 MyBatis 应用程序会按示例中的例子来配置数据源。虽然数据源配置是可选的，但如果要启用延迟加载特性，就必须配置数据源。
有三种内建的数据源类型（也就是 type="[UNPOOLEDPOOLEDJNDI]"）：
4.3 属性（properties）
这些属性可以在外部进行配置，并可以进行动态替换。你既可以在典型的 Java 属性文件中配置这些属性，也可以在 properties 元素的子元素中设置。
driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/mybatis?useSSL=false useUnicode=true
characterEncoding=UTF8 serverTimezone=GMT%2B8 autoConnect=true
username=root
password=root
注意：在xml中，所有的标签都可以规定顺序
(properties?,settings?,typeAliases?,typeHandlers?,objectFactory?,objectWrapperFactory?,reflectorFactory?,plugins?,environments?,databaseIdProvider?,mappers?)".
property name="username" value="${username}"/
property name="password" value="${password}"/
/dataSource
/environment
/configuration
4.4 类型别名（typeAliases）
类型别名可为 Java 类型设置一个缩写名字。 它仅用于 XML 配置，意在降低冗余的全限定类名书写。
在mybatis-config.xml - 配置
typeAliases
typeAlias type="com.yu.pojo.User" alias="user" /typeAlias
!-- 另一种方式：直接扫描一个包目录下的 --
package name="com.yu.pojo"/
/typeAliases
然后xxxMapper.xml的返回值（resultType）就可以替换为resultType user
实体类较少的时候使用第一种，较多就直接扫描包目录
第二种也可以用注解@Alias("xxx")给类起别名
4.5 设置（settings）
这是 MyBatis 中极为重要的调整设置，它们会改变 MyBatis 的运行时行为。
需要掌握的设置
4.6 映射器（mappers）
MapperRegistry：注册绑定我们的Mapper文件
plugins（插件）
4.8 生命周期和作用域（Scope）
理解我们之前讨论过的不同作用域和生命周期类别是至关重要的，因为错误的使用会导致非常严重的并发问题。
SqlSessionFactoryBuilder：
局部变量：一旦创建了 SqlSessionFactory，就不再需要它了。
SqlSessionFactory：
全局变量：一旦被创建就应该在应用的运行期间一直存在，可以想象为数据库连接池，没有任何理由丢弃它或重新创建另一个实例。
因此 SqlSessionFactory 的最佳作用域是应用作用域，最简单的就是使用单例模式或者静态单例模式。
SqlSession：
连接到连接池的一个请求
SqlSession 的实例不是线程安全的，因此是不能被共享的，所以它的最佳的作用域是请求或方法作用域。
用完之后需要关闭
每一个Mapper代表一个具体的业务
5 解决属性名和字段名不一致
5.1 新建项目mybatis-03
mapper namespace="com.yu.dao.UserMapper"
select id="getUserById" parameterType="int" resultType="user"
select * from mybatis.user where id=#{id}
!--
这句代码的本质：select id,name,pwd from ...
类型处理器找不到对应字段的属性，无法赋值
/select
/mapper
select id="getUserById" parameterType="int" resultMap="UserMap"
select * from mybatis.user where id=#{id}
/select
ResultMap 的设计思想是，对简单的语句做到零配置，对于复杂一点的语句，只需要描述语句之间的关系就行了。
ResultMap 的优秀之处——你完全可以不用显式地配置它们。 虽然上面的例子不用显式配置 ResultMap。 但为了讲解，我们来看看如果在刚刚的示例中，显式使用外部的 resultMap 会怎样，这也是解决列名不匹配的另外一种方式。
STDOUT_LOGGING
Logging initialized using class org.apache.ibatis.logging.stdout.StdOutImpl adapter.
Created connection 471579726.
Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@1c1bbc4e]
== Preparing: select * from mybatis.user where id=?
== Parameters: 1(Integer)
== Columns: id, name, pwd
== Row: 1, 千树, 123
== Total: 1
User{id=1, name=千树, password=123}
Resetting autocommit to true on JDBC Connection [com.mysql.jdbc.JDBC4Connection@1c1bbc4e]
Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@1c1bbc4e]
Returned connection 471579726 to pool.
从上面的输出可以看出，mybatis本质上是封装了JDBC
Caused by: org.apache.ibatis.exceptions.PersistenceException:
### Error building SqlSession.
### The error may exist in SQL Mapper Configuration
### Cause: org.apache.ibatis.builder.BuilderException: Error parsing SQL Mapper Configuration. Cause: org.apache.ibatis.logging.LogException: Error setting Log implementation.
......
Caused by: org.apache.ibatis.builder.BuilderException: Error parsing SQL Mapper Configuration. Cause: org.apache.ibatis.logging.LogException: Error setting Log implementation. Cause: java.lang.NoClassDefFoundError: org/apache/log4j/Priority
使用另一个标准就会报错，说明需要配置另外的东西
解决方法：配置maven导入log4j
pom.xml
!-- https://mvnrepository.com/artifact/log4j/log4j --
dependency
groupId log4j /groupId
artifactId log4j /artifactId
version 1.2.17 /version
/dependency
然后输出为正常输出了：
log4j:WARN No appenders could be found for logger (org.apache.ibatis.logging.LogFactory).
log4j:WARN Please initialize the log4j system properly.
log4j:WARN See http://logging.apache.org/log4j/1.2/faq.html#noconfig for more info.
User{id=1, name=千树, password=123}
log4j简介
Log4j是一个由Java编写可靠、灵活的日志框架，是Apache旗下的一个开源项目；现如今，Log4j已经被移植到了C、C++、Python等语言中，服务更多的Developer；
使用Log4j，我们更加方便的记录了日志信息，它不但能控制日志输出的目的地，也能控制日志输出的内容格式；通过定义不同的日志级别，可以更加精确的控制日志的生成过程，从而达到我们应用的需求；这一切，都得益于一个灵活的配置文件，并不需要我们更改代码
log4j.appender.console=org.apache.log4j.ConsoleAppender
log4j.appender.console.Target=System.out
log4j.appender.console.threshold=DEBUG
log4j.appender.console.layout=org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPattern=[%c]-%m%n
#文件输出 rolling file appender
log4j.appender.file=org.apache.log4j.RollingFileAppender
log4j.appender.file.File=./log/yu.log
log4j.appender.file.MaxFileSize=10mB
log4j.appender.file.MaxBackupIndex=2
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{mmm d,yyyy hh:mm:ss a} : %p [%t] %m%n
log4j.appender.file.threshold=DEBUG
#日志输出级别 logger
log4j.logger.org.mybatis=DEBUG
log4j.logger.java.sql=DEBUG
log4j.logger.java.sql.Statement=DEBUG
log4j.logger.java.sql.ResultSet=DEBUG
log4j.logger.java.sql.PreparedStatement=DEBUG
#newhappy log4j.properties end
public class UserDaoTest {
static Logger logger = Logger.getLogger(UserDaoTest.class);
@Test
public void loggerTest(){
logger.info("info：进入了TestLog4j");
logger.debug("debug:调试");
logger.error("error:错误");
logger.fatal("fatal:致命错误");
导包：import org.apache.log4j.Logger;
获取日志对象，参数为当前类的class
设置日志级别
Mapper.xml
select id="selectLimit" parameterType="map" resultMap="UserMap"
select * from mybatis.user limit #{startIndex},#{pageSize}
/select
SqlSession sqlSession = MybatisUtils.getSqlSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
Map String, Integer map = new HashMap String, Integer
map.put("startIndex",0);
map.put("pageSize",2);
List User list=mapper.selectLimit(map);
for (User u:
list) {
System.out.println(u);
sqlSession.close();
RowBounds rowBounds = new RowBounds(0,2);
List User list = sqlSession.selectList("com.yu.dao.UserMapper.selectRowBounds"
,null,rowBounds);
for (User user : list) {
System.out.println(user);
sqlSession.close();
网站：点击访问
网站有详细的文档，此处不在介绍，了解即可，需要用的时候再学
8 使用注解开发
注解的本质是使用反射,底层是代理模式（见设计模式）
使用注解来映射简单语句会使代码显得更加简洁，但对于稍微复杂一点的语句，Java 注解不仅力不从心，还会让你本就复杂的 SQL 语句更加混乱不堪。 因此，如果你需要做一些很复杂的操作，最好用 XML 来映射语句。
8.1 注解查找
接口
@Select("select * from mybatis.user")
List User selectAll();
注册绑定
mappers
mapper /
/mappers
测试
@Test
public void selectAll(){
SqlSession sqlSession = MybatisUtils.getSqlSession();
//底层主要应用反射
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
List User list=mapper.selectAll();
for (User user : list) {
System.out.println(user);
sqlSession.close();
设置自动提交
public static SqlSession getSqlSession(){ return sqlSessionFactory.openSession(true); }
//多个参数情况下，有两种解决方式，一个map封装，另一种是注解Param
@Select("select * from mybatis.user where id=#{id}")
User selectUserById(@Param("id") int id);
@Select("select * from mybatis.user")
List User selectAll();
@Insert("insert into mybatis.user() values(#{id},#{name},#{password}) ")
boolean insertUser(User u);
@Update("update user set name=#{name},pwd=#{password} where id = #{id}")
boolean updateUser(User u);
@Delete("delete from mybatis.user where id=#{id}")
boolean deleteUser(@Param("id") int id);
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
// List User list=mapper.selectAll();
// for (User user : list) {
// System.out.println(user);
// }
User u=mapper.selectUserById(1);
System.out.println(u);
// boolean isInserted=mapper.insertUser(new User(4,"图拉真","dgsdgs"));
// if (mapper.updateUser(new User(6,"寒江雪",null)))
if (mapper.deleteUser(6))
for (User user : mapper.selectAll()) {
System.out.println(user);
sqlSession.close();
10 Lombok
Lombok是一个可以通过简单的注解形式来帮助我们简化消除一些必须有但显得很臃肿的Java代码的工具，通过使用对应的注解，可以在编译源码的时候生成对应的方法。
10.1 安装方法
左上角File- Settings- Plugins
搜索Lombok,下载安装
导入maven
dependency
groupId org.projectlombok /groupId
artifactId lombok /artifactId
version 1.18.10 /version
/dependency
@AllArgsConstructor, @RequiredArgsConstructor and @NoArgsConstructor
@Log, @Log4j, @Log4j2, @Slf4j, @XSlf4j, @CommonsLog, @JBossLog, @Flogger, @CustomLog
@Data
@Builder
@SuperBuilder
@Singular
@Delegate
@Value
@Accessors
@Wither
@With
@SneakyThrows
experimental @var
@UtilityClass
Lombok config system
Code inspections
Refactoring actions (lombok and delombok)
常用支持
@Data支持: 无参构造，getter setter,toString,hashCode,equals
@AllArgsConstructor: 有参构造
@NoArgsConstructor: 无参构造
使用方法，在实体类上加注解
11 多对一（一对多）的处理
constraint `FK_tid` foreign key(`tid`) references `teacher`(`id`)
) engine=InnoDB default charset=utf8;
resultMap id="student_teacher" type="Student"
!-- property是实体类的属性 column是数据库的字段 --
result property="id" column="id"/
result property="name" column="name"/
复杂的属性，需要单独处理，对象：association 集合collection
association property="teacher" column="tid" javaType="Teacher" select="getTeacher"/
/resultMap
select id="selectAll" resultMap="student_teacher"
select * from mybatis.student
/select
select id="getTeacher" resultType="Teacher"
select * from mybatis.teacher where id=#{tid}
/select
@Test
public void selectAll(){
SqlSession sqlSession = MybatisUtils.getSqlSession();
StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
List Student studentList = mapper.selectAll();
for (Student s:
studentList) {
System.out.println(s);
sqlSession.close();
select id="selectAll2" resultMap="S_T"
select s.id sid,s.name sname,t.name tname
from mybatis.student s,mybatis.teacher t
where s.tid=t.id
/select
resultMap id="S_T" type="Student"
result property="id" column="sid"/
result property="name" column="sname"/
association property="teacher" javaType="Teacher"
result property="name" column="tname"/
/association
/resultMap
//测试代码
Teacher getTeacher2(@Param("tid")int id);
List Student getStudents(@Param("tid")int id);
select id="selectAll" resultType="Teacher"
select * from mybatis.teacher
/select
select id="getTeacher" resultMap="S_T"
select t.id tid, t.name tname,s.name sname
from mybatis.teacher t,mybatis.student s
where s.tid=tid and tid=#{tid}
/select
resultMap id="S_T" type="Teacher"
result property="id" column="tid"/
result property="name" column="tname"/
!-- 集合中的泛型信息，我们使用ofType --
collection property="students" ofType="Student"
result property="name" column="sname"/
result property="tid" column="tid"/
/collection
/resultMap
select id="getTeacher2" resultMap="student_teacher"
select * from mybatis.teacher where id=#{tid}
/select
resultMap id="student_teacher" type="Teacher"
result property="id" column="id"/
result property="name" column="name"/
collection property="students" column="id" ofType="Student" select="getStudents"/
/resultMap
select id="getStudents" resultType="Student"
select * from mybatis.student where tid=#{tid}
/select
//测试
javaType 指定实体类中属性的类型
ofType 用来指定映射到List或者集合中的pojo类型，泛型中的约束类型
注意点：
保证sql语句的可读性
注意一对多和多对一属性和字段的问题
Mysql引擎
InnoDB底层原理
动态SQL是指根据不同的条件生成不同的SQL语句
如果你之前用过 JSTL 或任何基于类 XML 语言的文本处理器，你对动态 SQL 元素可能会感觉似曾相识。在 MyBatis 之前的版本中，需要花时间了解大量的元素。借助功能强大的基于 OGNL 的表达式，MyBatis 3 替换了之前的大部分元素，大大精简了元素种类，现在要学习的元素种类比原来的一半还要少。
choose (when, otherwise)
trim (where, set)
foreach
12.1 搭建环境
搭建数据库
create table blog(
id varchar(50) not null comment 博客id,
title varchar(100) not null comment 博客标题,
author varchar(30) not null comment 博客作者,
ctreate_time datetime not null comment 创建时间,
views int not null comment 浏览量
)engine=InnoDB default charset=utf8;
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd"
mapper namespace="com.yu.dao.BlogMapper"
/mapper
解决数据库字段名和实体类属性名不一致的问题
!--
有两种解决方法：
1.如果不是按规范转换，在xxxMapper.xml用ResultMap，上面已经介绍过
2.如果是规范命名，在mybatis-config.xml文件中 settings - setting - id="mapUnderscoreToCamelCase" value="true",它的作用是驼峰命名转换
settings
setting name="logImpl" value="STDOUT_LOGGING"/
setting name="mapUnderscoreToCamelCase" value="true"/
/settings
使用动态 SQL 最常见情景是根据条件包含 where 子句的一部分。比如：
select id="findActiveBlogWithTitleLike"
resultType="Blog"
SELECT * FROM BLOG
WHERE state = ‘ACTIVE’
if test="title != null"
AND title like #{title}
/if
/select
代码演示
//查询博客
List Blog queryBlogIf(Map String,Object map);
select id="queryBlogIf" parameterType="map" resultType="Blog"
select * from mybatis.blog where 1=1
if test="title!=null"
and title = #{title}
/if
if test="author!=null"
and author = #{author}
/if
/select
@Test
public void queryBlogIf(){
SqlSession sqlSession = MybatisUtils.getSqlSession();
BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
Map String,Object map=new HashMap String,Object
mapper.queryBlogIf(map);
System.out.println("==================");
map.put("title",(String)"MyBatis如此简单");
mapper.queryBlogIf(map);
System.out.println("==================");
map.put("author",(String)"狂神说");
mapper.queryBlogIf(map);
System.out.println("==================");
sqlSession.close();
有时候，我们不想使用所有的条件，而只是想从多个条件中选择一个使用。针对这种情况，MyBatis 提供了 choose 元素，它有点像 Java 中的 switch 语句。
还是上面的例子，但是策略变为：传入了 “title” 就按 “title” 查找，传入了 “author” 就按 “author” 查找的情形。若两者都没有传入，就返回标记为 featured 的 BLOG（这可能是管理员认为，与其返回大量的无意义随机 Blo。
郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。