MyBatis 上

预备知识：JAVA基础、JDBC

文章目录

一、MyBatis简介
二、搭建MyBatis
- 1. 开发环境
- 2. 创建模块，导入坐标
- 3. 创建MyBatis的核心配置文件 --> 替换连接信息解决硬编码问题
- 4. 创建mapper接口
- 5. 创建SQL的映射文件 --> 统一管理sql语句，解决硬编码问题
- 6、通过junit测试添加功能
- 7、加入log4j日志功能
- 测试修改和删除功能
- 测试查询功能
- 小结
三、核心配置文件详解
- environment
- properties
- typeAliases(类型别名)
- mappers
在idea中设置核心文件的模板
- 在idea中设置核心配置文件的模板
- 在idea中设置映射文件的模板
五、MyBatis获取参数值的两种方式(重点)
- 1、单个字面量类型的参数
- 2、多个字面量类型的参数
- 3、map集合类型的参数
- 4、mapper.接口方法的参数是实体类类型的参数
- 5、使用Param注解命名参数
六、MyBatis的各种查询功能
- 1、查询一个实体类对象
- 2、查询一个list集合
- 3、查询单个数据
- 4、查询一条数据为map集合
- 5、查询多条数据为map集合
- - 方式一：
  - 方式二：
七、特殊SQL的执行
- 1、模糊查询
- 2、批量删除
- 3、动态设置表名
- 4、添加功能获取自增的主键

一、MyBatis简介

MyBatis历史
MyBatis最初是Apachel的一个开源项目iBatis,201O年6月这个项目由Apache Software Foundation迁移到了Google Code.。随着开发团队转投Google Codei旗下，iBatis.3.正式更名为MyBatis。.代码于2013年11月迁移到Github。
iBatis-一词来源于“internet’"和"abatis’"的组合，是一个基于ava的持久层框架。iBatis提供的持久层框架包括SQLMaps和Data Access Objects(DAO)。
MyBatis特性
- 1)MyBatis是支持定制化SQL、存储过程以及高级映射的优秀的持久层框架
  - 持久层
    负责将数据到保存到数据库的那一层代码
    JavaEE三层架构：表现层、业务层、持久层
  - 框架
    框架就是一个半成品软件，是一套可重用的、通用的、软件基础代码模型
    在框架的基础之上构建软件编写更加高效、规范、通用、可扩展
- 2)MyBatis避免了几乎所有的DBC代码和手动设置参数以及获取结果集
- 3)MyBatisT可以使用简单的XML或注解用于配置和原始映射，将接口和ava的POO(Plain Old Java Objects,普通的ava对象)映射成数据库中的记录
- 4)MyBatis是一个半自动的ORM(Object Relation Mapping)框架
MyBatis下载
MyBatis下载地址：https://github.com/mybatis/mybatis-3
和其它持久化层技术对北比
- JDBC
  SQL夹杂在ava代码中耦合度高，导致硬编码内伤（注册驱动，获取连接、SQL语句）
  维护不易且实际开发需求中SQL有变化，频繁修改的情况多见，操作繁琐（手动设置参数、手动封装结果集）
  代码冗长，开发效率低
- Hibernate和JPA
  操作简便，开发效率高
  程序中的长难复杂SQL需要绕过框架
  内部自动生产的SQL,不容易做特殊优化
  基于全映射的全自动框架，大量字段的POO进行部分映射时北比较困难。
  反射操作太多，导致数据库性能下降
- MyBatis
  轻量级，性能出色
  SQL和Java编码分开，功能边界清晰。Java代码专注业务、SQL语句专注数据
  开发效率稍逊于HIbernate,但是完全能够接受

MyBatis简化

二、搭建MyBatis

1. 开发环境

IDE:lidea 2019.2
构建工具：maven3.5.4
MySQL版本：MySQL5.7
MyBatis)版本：MyBatis3.5.7

2. 创建模块，导入坐标

a>打包方式：jar
b>引入依赖

<dependencies>
	 <!--Mybatis核心-->
  <dependency>
       <groupId>org.mybatis</groupId>
       <artifactId>mybatis</artifactId>
       <version>3.5.7</version>
   </dependency>
   <!--junit.测试-->
   <dependency>
       <groupId>junit</groupId>
       <artifactId>junit</artifactId>
       <version>4.12</version>
       <scope>test</scope>
   </dependency>
   
   <!--MySOL驱动-->
   <dependency>
       <groupId>mysql</groupId>
       <artifactId>mysql-connector-java</artifactId>
       <version>5.1.3</version>
   </dependency>
</dependencies>

3. 创建MyBatis的核心配置文件 --> 替换连接信息解决硬编码问题

习惯上命名为mybatis-config.xml,这个文件名仅仅只是建议，并非强制要求。将来整合Spring之后，这个配置文件可以省略，所以大家操作时可以直接复制、粘贴。
核心配置文件主要用于配置连接数据库的环境以及MyBatisi的全局配置信息
核心配置文件存放的位置是src/main/resources目录下

<?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="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&amp;characterEncoding=utf8&amp;serverTimezone=UTC"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>
    <!--引入映射文件-->
    <mappers>
        <mapper resource="mappers/UserMapper.xml"/>
    </mappers>
</configuration>

4. 创建mapper接口

创建User

package com.scnu.mybatis.pojo;

public class User {
    private Integer id;
    private String
            username;
    private String password;
    private Integer age;
    private String sex;
    private String email;
	//有参无参构造函数
	//settergetter
	//toString
}

MyBatis中的mapper接口相当于以前的dao但是区别在于，mapper仅仅是接口，我们不需要提供实现类。

public interface UserMapper{
	/**
	*添加用户信息
	*/
	int insertUser();
}

5. 创建SQL的映射文件 --> 统一管理sql语句，解决硬编码问题

相关概念：ORM(Object Relationship Mapping)对象关系映射。
- 对象：Java的实体类对象
- 关系：关系型数据库
- 映射：二者之间的对应关系

Java概念	数据库概念
类	表
属性	字段/列
对象	记录/行

表-实体类-mapper接口–映射文件，一对一

映射文件的命名规则：
表所对应的实体类的类名+Mapper.xml
例如：表t_user,.映射的实体类为User,所对应的映射文件为UserMapper…xml
因此一个映射文件对应一个实体类，对应一张表的操作
MyBatis映射文件用于编写SQL,访问以及操作表中的数据
MyBatisE映射文件存放的位置是src/main/resources/mappers目录下
MyBatis中可以面向接口操作数据，要保证两个一致：
a>mapper接口的全类名和映射文件的命名空间(namespace)保持一致
b>mapperi接口中方法的方法名和映射文件中编写SQL的标签的id属性保持一致

<?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="com.scnu.mybatis.mapper.UserMapper">
    <insert id="insertUser">
        insert into t_user values(null,admin','123456',23,'','12345@qq.com'
    </insert>
</mapper>

6、通过junit测试添加功能

//读取MyBatis的核心配置文件·
InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
//创建sq1 SessionFactoryBui1der对象
SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
//通过核心配置文件所对应的字节输入流创建工厂类Sq1SessionFactory,生产SqlSession对象
SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is);
//创建sq1 Session对象，此时通过SqlSession对象所操作的sq1都必须手动提交或回滚事务
//SqlSession sqlSession = sqlSessionFactory.openSession();

//创建sq1 Session对象，此时通过sq1 Session对象所操作的sq1都会自动提交
SqlSession sqlSession = sqlSessionFactory.openSession(true);

//通过代理模式创建UserMapper接口的代理实现类对象
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
//调用JserMapper接口中的方法，就可以根据UserMapper的全类名匹配元素文件，通过调用的方法名匹配映射文件中的SQL标签，并执行标签中的sQL语句
int result = userMapper.insertUser();
//sqlsession.commit();
System.out.println("结果：" + result);

SqlSession:代表ava程序和数据库之间的会话。(HttpSession,是ava程序和浏览器之间的会话)
SqlSessionFactory:是"生产"SqlSession的工厂"。
工厂模式：如果创建某一个对象，使用的过程基本固定，那么我们就可以把创建这个对象的相关代码封装到一个“工厂类”中，以后都使用这个工厂类来“生产"我们需要的对象。

7、加入log4j日志功能

a>加入依赖

<!--10g4j日志->
<dependency>
    <groupId>1og4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.14</version>
</dependency>

b>加入Iog4的配置文件
log4j的配置文件名为log4j.xml,存放的位置是src/main/resources目录下

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">
    <appender name="STDOUT" class="org.apache.log4j.ConsoleAppender">
        <param name="Encoding" value="UTF-8"/>
        <layout class="org.apache.log4j.PatternLayout">
            <param name="ConversionPattern" value="%-5p %dMM-dd HH:mm:ss,SSS}%m (%F:%L)\n"/>
        </layout>
    </appender>
    <logger name="java.sql">
        <level value="debug"/>
    </logger>
    <logger name="org.apache.ibatis">
        <level value="info"/>
    </logger>
    <root>
        <level value="debug"/>
        <appender-ref ref="STDOUT"/>
    </root>
</log4j:configuration>

日志的级别
FATAL(致命)>ERROR(错误)>WARN(警告)>INFO(信息)>DEBUG(调试)
从左到右打印的内容越来越详细

测试修改和删除功能

在这里插入图片描述

测试查询功能

resultType/resultMap
resultType:字段名和属性名一致
resultMap:字段名和属性名不一致，/处理一对多/多对一关系时使用
详细见八、自定义映射resultMap

<!--User getuserById();-->
<!--
查询功能的标签必须设置resultType或resultMap
resultType：设置默认的映射关系
resultMap：设置自定义的映射关
-->
<!--User getuserById();-->
<select id="getuserById" resultType="com.atguigu.mybatis.pojo.User">
	select * from t user where id = 3
</select>
<!--List<user>getAlluser();-->
<select id="getAllUser"resultType="com.atguigu.mybatis.pojo.User">
	select * from t_user
</select>

在这里插入图片描述

小结

创建Mybatis项目
- 导入四个jar包mabatics、junit、MySQL、log4j
- 创建包，并配置包路经
- 创建实体类、Map接口和xml映射文件

三、核心配置文件详解

交给spring管理，了解即可

environment

<configuration>
<!--
	environments：配置多个连接数据库的环境
	属性：
		default:设置默认使用的环境的id
-->
	<environments default="development">
		<!--
			environment:配置某个具体的环境
			属性：
				id:表示连接数据库的环境的唯一标识，不能重复
		-->
		<environment id="development">
			<!--
			transactionManager:设置事务管理方式
			属性：
				type="JDBC/MANAGED'
				JDBC：表示当前环境中，执QL时，使用的是JDBC中原生的事务管理方式，事务的提交或回滚需要手动处理
				MANAGED:被管理，例如Spring
			-->
			<transactionManager type="JDBC"/>
			<!--
				datasource:配置数据源
				属性：
					type：设置数据源的类型
					type="POOLED |UNPOOLED|JNDI"
					POOLED:表示使用数据库连接池缓存数据库连接
					UNPOOLED:表示不使用数据库连接池
					JNDI:表示使用上下文中的数据源
			-->
			<dataSource type="POOLED">
				<!--设置连接数据库的驱动-->
				<property name="driver"value="com.mysql.jdbc.Driver"/>
				<!--设置连接数据库的连接地址-->
				<property name="url"value="jdbc:mysql://localhost:3306/mybatis"/>
				<!--设置连接数据库的用户名-->
				<property name="username"value="root"/>
				<!--设置连接数据库的密码-->
				<property name="password"value="123456"/>
			</dataSource>
		</environment>
		<environment id="test">
			<transactionManager type="JDBC"/>
			<dataSource type="POOLED">
				<property name="driver"value="com.mysql.jdbc.Driver"/>
				<property name="url"value="jdbc:mysql://localhost:3306/mybatis"/>
				<property name="username"value="root"/>
				<property name="password"value="123456"/>
			</dataSource>
		</environment>

properties

在这里插入图片描述

引入

typeAliases(类型别名)

在这里插入图片描述

为了简化写法，
MyBatis核心配置文件中，标签需要按照顺序

<!--
MyBatis核心配置文件中，标签的顺序：
properties?,settings?,typeAliases?,typeHandlers?,
objectFactory?,objectwrapperFactory?,refLectorFactory?,
plugins?,environments?,databaseIdprovider?,mappers?
-->
<!--设置类型别名-->
<typeAliases>
<!--
typeAlias：设置某个类型的别名
属性：
type：设置需要设置别名的类型
alias:设置某个类型的别名,若不设置该属性，那么该类型拥有默认的别名，即类名且不区分大小写
-->
<typeAlias type="com.atguigu.mybatis.pojo.User"></typeAlias>
</typeAliases>

在这里插入图片描述

mappers

在这里插入图片描述

在idea中设置核心文件的模板

在idea中设置核心配置文件的模板

导入四个jar包mabatics、junit、MySQL、log4j
typealiase/package

在这里插入图片描述

在idea中设置映射文件的模板

在这里插入图片描述

五、MyBatis获取参数值的两种方式(重点)

MyBatis获取参数值的两种方式：${}和#{}
${}的本质就是字符串拼接，#{}的本质就是占位符赋值
${}使用字符串拼接的方式拼接sql，若为字符串类型或日期类型的字段进行赋值时，需要手动添加单引号,会造成sql注入；但是#{}使用占位符赋值的方式拼接sql，此时为字符串类型或日期类型的字段进行赋值时，可以自动添加单引号

1、单个字面量类型的参数

若mapper接口中的方法参数为单个的字面量类型
此时可以使用${}和#{}以任意的名称获取参数的值，注意${}需要手动加单引号

在这里插入图片描述

username可以是任意名称

2、多个字面量类型的参数

若mapper接口中的方法参数为多个时
此时MyBatis会自动将这些参数放在一个map集合中，以arg0，arg1…为键，以参数为值；以param1,param2…为键，以参数为值；因此只需要通过${}和#{}访问map集合的键就可以获取相对应的值，注意${}需要手动加单引号

在这里插入图片描述

3、map集合类型的参数

若mappert接口中的方法需要的参数为多个时，此时可以手动创建map集合，将这些数据放在map中
只需要通过${}和#{}访问mp集合的键就可以获取相对应的值，注意${}要手动加单引号

4、mapper.接口方法的参数是实体类类型的参数

只需要通过#{}和${}以属性的方式访问属性值即可，但是需要注意部${}的单引号问题
属性是类中get、set方法去掉get、set后全部小写的变量

在这里插入图片描述

5、使用Param注解命名参数

此MyBatis会将这些参数放在一个map集合中，以两种方式进行存储
a>以@Param注解的值为键，以参数为值
b>以baram1,param2···为键，以参数为值
因此只需要通过#{}和${}以键的方式访问值即可，但是需要注意部}的单引号问题
在这里插入图片描述

再情况1、2时最好加上5注解@Param

六、MyBatis的各种查询功能

1、查询一个实体类对象

1,若查询出的数据只有一条，
- a可以通过实体类对象
- b可以通过集合接收
- c可以通过map对象接收
2,若查询出的数据有多条
- a可以通过实体类型的list集合接收
- b可以通过map类型的list集合接收
- c通过@MapKey注解设置map集合的键，值是每条数据所对应的map集合
- 一定不能通过卖体类对象接收，此时会抛异常TooManyResultsException

/**
*根据用户id查询用户信息
*@param id
*@return
*/
User getuserById(@Param("id")int id);

<!--User getuserById(@Param("id")int id);-->
<select id="getuserById"resultType="User">
	select * from t_user where id =#{id}}
</select>

2、查询一个list集合

/**
*查询所有用户信息
*@return
*/
List<User> getUserList();

<!--List<User>getUserList();-->
<select id="getuserList"resultType="User">
	select* from t_user
</select>

3、查询单个数据

在这里插入图片描述

/**
*查询用户的总记录数
*在MyBatis中，对于Java中常用的类型都设置了类型别名
*例如：java.lang.Integer-->int|integer
*例如：int-->_int |_integer
*例如：Map-->map,List-->1ist
*/
int getCount();

<!--int getCount();-->
<select id="getCount"resultType="_integer">
	select count(id) from t_user
</select>

count(*/1)查询的包含null
count(字段)查询的不包含null

4、查询一条数据为map集合

/**
*根据用户id查询用户信息为map集合
*@param id
*@return
*/
Map<String,object> getuserToMap(@Param("id")int id);

<!--Map<String,object>getuserToMap(@Param("id")int id);-->
<select id="getuserToMap"resultType="map">
	select * from t_user where id =#{id}
</select>
<!--结果：{password=123456,sex=男，id=1,age=23,username=admin}-->

5、查询多条数据为map集合

方式一：

/*查询所有用户信息为map集合
*@return
*将表中的数据以map集合的方式查询，一条数据对应一个map;若有多条数据，就会产生多个map集合，此时可以将这些map放在一个list集合中获取
*/
List<Map<String,object>>getAllUserToMap();

<!--Map<String,object>getAllUserToMap();--
<select id="getAllUserToMap"resultType="map">
select * from t_user
</select>

方式二：

/*查询所有用户信息为map集合
*@return
*将表中的数据以map集合的方式查询，一条数据对应一个map;若有多条数据，就会产生多个map集合，并且最终要以一个map的方式返回数据，此时需要通过@MapKey注解设置map集合的键，值是每条数据所对应的map集合
*/
@MapKey("id")
Map<String,object>getAllUserToMap();

<!--Map<String,object>getAllUserToMap();--
<select id="getAllUserToMap"resultType="map">
	select from t_user
</select>
结果：
<!--
{
	1={password=123456,sex=,id=1,age=23,username=admin},
	2={password=123456,sex=男，id=2,age=23,username-张三}，
	3={passwor d=123456,sex=男，id=3,age=23,username:-张三}
}
-->

七、特殊SQL的执行

1、模糊查询

/**
*测试模糊查询
*@param mohu
*@return
*/
List<User> testMohu (@Param("mohu") String mohu);

<!--List<User>testMohu(@Param("mohu")String mohu);-->
<select id="testMohu"resultType="User">
	<!--select from t_user where username like '%{mohu}%'-->
	<!--select from t_user where username like concat ('%',#{mohu},'%')-->
	select from t_user where username like "%"#{mohu}"%"
</select>

2、批量删除

/**
*批量删除
*@param ids
*@return
*/
int deleteMore(@Param("ids")String ids);

in(#{})中，#{}由自动加’'，是字符串

<!--int deleteMore(@Param("ids") String ids);-->
<delete id="deleteMore">
	delete from t_user where id in (${ids})
</delete>

3、动态设置表名

/**
*动态设置表名，查询所有的用户信息
*@param tableName
*@return
*/
List<User>getAllUser (@Param("tableName")String tableName);

<!--List<User>getAllUser (@Param("tableName")String tableName);-->
<select id="getAllUser"resultType="User">
select * from ${tableName}
</select>

4、添加功能获取自增的主键

t_clazz(clazz_id,clazz_name)
t_student(student_id,student_name,clazz_id)
1、添加班级信息
2、获取新添加的班级的id
3、为班级分配学生，即将某学的班级引d修改为新添加的班级的id

/**
*添加用户信息
*@param user
*@return
*useGeneratedKeys:设置使用自增的主键
*keyProperty:因为增删改有统一的返回值是受影响的行数，因此只能将获取的自增的主键放在传输的参数user对象的某个属性中
*/
int insertUser(User user);

<!--int insertuser (User user);-->
<insert id="insertuser"useGeneratedKeys="true"keyProperty="id">
	insert into t_user values(null,#{username},#{password},#{age},#{sex})
</insert>