SSM——Mybatis框架入门

Mybatis（持久化）

MyBatis 是一款优秀的持久层框架，它支持自定义 SQL、存储过程以及高级映射。MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。

MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。

哪里获取mybatis？

• 框架都有配置文件，最好的是看官网文档：https://mybatis.org/mybatis-3/zh/index.html
• github开源项目：https://github.com/mybatis/mybatis-3/releases
• maven

  <dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.5.2</version>
  </dependency>

持久化

• 持久化就是将程序的数据在持久状态和瞬时状态转化的过程
• 内存：断电即失
• 数据库（jdbc），io文件持久化

持久化的好处：

• 有一些对象，不能丢失
• 内存价格高

持久层

完成持久化工作的代码，层界限十分明显

Mybatis就是一种很好的持久层框架，帮助程序员将数据存入到数据库中——简化复杂的JDBC

第一个Mybatis程序

搭建环境

数据库创建：

create DATABASE `mybatis`;

use `mybatis`;

CREATE TABLE `user`(
	`id` INT(20) NOT NULL primary key,
	`name` varchar(30) default null,
	`pwd` varchar(30) default null
)engine=innodb default charset=utf8;

insert into `user`(`id`,`name`,`pwd`) values
(1,'周逸','123'),
(2,'张三','123'),
(3,'李四','123')

创建项目：

1. 新建一个maven项目

2. 配置maven依赖

     			<!--  数据库连接    -->
   		 <dependency>
               <groupId>mysql</groupId>
               <artifactId>mysql-connector-java</artifactId>
               <version>5.1.6</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>
   		    <scope>test</scope>
   		 </dependency>
   

创建一个模块

创建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核心配置文件-->
<configuration>
    
    <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?useSSL=true&amp;useUnicode=true&amp;characterEncoding=UTF-8&amp;serverTimezone=GMT%2B8"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>
    
</configuration>

编写mybatis工具类（官方入门代码获取Factory）

public class MybatisUtils {

	private static SqlSessionFactory sqlSessionFactory;  //提升作用域
	static {
		//官方文档中的代码，获取sqlSessionFactory对象（单例模式）
		try {
			String resource = "mybatis-config.xml";
			InputStream inputStream = Resources.getResourceAsStream(resource);
			sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
		}catch(IOException e) {
			e.printStackTrace();
		}
	}
	//既然有了 SqlSessionFactory，顾名思义，我们可以从中获得 SqlSession 的实例。
	//SqlSession 提供了在数据库执行 SQL 命令所需的所有方法。
	//你可以通过 SqlSession 实例来直接执行已映射的 SQL 语句。例如：
	public static SqlSession getsqlSession() {
        //参数true,设置为自动提交事务
		return sqlSessionFactory.openSession(true);   //相当于jdbc的connection
	}
}

编写代码

实体类

package com.bos.pojo;

public class User {

	private int id;
	
	private String name;
	private String pwd;
	
	
	public User() {
		super();
	}


	public User(int id, String name, String pwd) {
		super();
		this.id = id;
		this.name = name;
		this.pwd = pwd;
	}


	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;
	}


	public String getPwd() {
		return pwd;
	}


	public void setPwd(String pwd) {
		this.pwd = pwd;
	}
	
}

Dao接口

public interface UserDao {
//等价于Mapper
	List<User> getUserList();
}

接口实现类由原来的Impl转变为一个Mapper配置文件

<?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">
  <!-- 绑定一个对应的Dao（Mapper）接口 -->
<mapper namespace="com.bos.dao.UserDao">
<!-- 绑定接口下的对应方法名 -->
<!-- 返回值要写类的全限定名 -->
  <select id="getUserList" resultType="com.bos.pojo.User">
  	select * from mybatis.user;
  </select>
</mapper>

测试

Junit测试：

public class UserDaoTest {
	@Test
	public void test() {
		//获取SqlSession
		SqlSession sqlSession=MybatisUtils.getsqlSession();
		//官方推荐方法：获取接口
		UserDao userDao=sqlSession.getMapper(UserDao.class);
		List<User> userList=userDao.getUserList();
		
		for(User user:userList) {
			System.out.println(user);
		}
        sqlSession.close();
	}
}

MapperRegister，mybatis-config.xml配置文件需要注册：

<!-- 每一个Mapper都需要在mybatis核心配置中注册 -->
    <mappers>
    	<mapper resource="com/bos/dao/UserMapper.xml"/>
    </mappers>

CRUD

namespace

<!-- 绑定一个对应的Mapper接口，否则会找不到 -->
<mapper namespace="com.bos.dao.UserMapper">
	...
</mapper>

select

选择，查询语句：

<!-- id:绑定接口下的对应方法名 -->
<!-- resultType:sql语句执行返回值要写类的全限定名 -->
<!-- parameterType：方法传入的参数 -->
  <select id="getUserById" resultType="com.bos.pojo.User" parameterType="int">
  	select * from mybatis.user where id=#{id};
  </select>

insert

插入语句：

  <insert id="addUser" parameterType="com.bos.pojo.User">
  	insert into mybatis.user (id,name,pwd) values (#{id},#{name},#{pwd})
  </insert>

增删改都需要提交事务！：

	@Test
	public void addUser() {
		SqlSession sqlSession=MybatisUtils.getsqlSession();
		
		UserMapper userDao=sqlSession.getMapper(UserMapper.class);
		int res=userDao.addUser(new User(4,"小红","123"));
		if(res>0) {
			System.out.println("插入成功");
		}
		//提交事务
		sqlSession.commit();
		
		sqlSession.close();
	}

update

修改语句：

  <update id="updateUser" parameterType="com.bos.pojo.User">
  	update mybatis.user set name=#{name},pwd=#{pwd} where id=#{id}
  </update>

delete

删除语句：

  <delete id="deleteUser" parameterType="int">
  	delete from mybatis.user where id=#{id}
  </delete>

万能Map

如果实体类的属性过多，我们应当考虑使用Map；传递参数更加自由；

  <insert id="addUser2" parameterType="com.bos.pojo.User">
  	insert into mybatis.user (id,name,pwd) values (#{userid},#{username},#{password})
  </insert>

	public void addUser2() {
		SqlSession sqlSession=MybatisUtils.getsqlSession();
		
		UserMapper userDao=sqlSession.getMapper(UserMapper.class);
		
		Map<String,Object> map=new HashMap<String, Object>();
		map.put("userid", 5);
		map.put("username", "Map");
		map.put("password", "123");
		
		int res=userDao.addUser2(map);
		if(res>0) {
			System.out.println("插入成功");
		}
		//提交事务
		sqlSession.commit();
		
		sqlSession.close();
	}

Map传递参数，取出key即可；（多个参数用map）

对象传递参数，取出属性即可；

基本类型传参，可以直接取出；

模糊查询

在sql中使用通配符，可能会存在sql注入问题

  <select id="getUserLike" resultType="com.bos.pojo.User">
  	select * from mybatis.user where name like "%"#{value}"%";
  </select> 

也可以在java代码执行时，传递% %

配置解析

核心配置文件mybatis-config.xml

环境配置（environments）

MyBatis 可以配置成适应多种环境，这种机制有助于将 SQL 映射应用于多种数据库之中， 现实情况下有多种理由需要这么做。例如，开发、测试和生产环境需要有不同的配置；或者想在具有相同 Schema 的多个生产数据库中使用相同的 SQL 映射。还有许多类似的使用场景。

不过要记住：尽管可以配置多个环境，但每个 SqlSessionFactory 实例只能选择一种环境。

Mybatis默认的事务管理是JDBC，连接池是POOLED

属性（properties）

这些属性可以在外部进行配置，并可以进行动态替换。你既可以在典型的 Java 属性文件中配置这些属性，也可以在 properties 元素的子元素中设置（db.properties）。例如：

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/mybatis?useSSL=true&useUnicode=true&characterEncoding=UTF-8&serverTimezone=GMT%2B8
username=root
password=123456

<?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="db.properties"/>
    # 选择environment
    <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>
        
        <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?useSSL=true&amp;useUnicode=true&amp;characterEncoding=UTF-8&amp;serverTimezone=GMT%2B8"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>

    <mappers>
    	<mapper resource="com/bos/dao/UserMapper.xml"/>
    </mappers>
</configuration>

类型别名（typeAliases）

用于 XML 配置，意在降低冗余的全限定类名书写。

方法一：类型别名可为 Java 类型设置一个缩写名字，可以具体定制。

    <!-- 可以给实体类取别名 -->
    <typeAliases>
    	<typeAlias type="com.bos.pojo.User" alias="User"/>
    </typeAliases>

  <select id="getUserLike" resultType="User">
  	select * from mybatis.user where name like "%"#{value}"%";
  </select>  

方法二：也可以指定一个包名，MyBatis 会在包名下面搜索需要的 Java Bean，推荐小写user

    <typeAliases>
    	<package name="com.bos.pojo"/>
    </typeAliases>

  <select id="getUserLike" resultType="user">
  	select * from mybatis.user where name like "%"#{value}"%";
  </select> 

如果非要定制，需要在实体类上增加注解

@Alias("hello")
public class User {...}

设置（settings）

这是 MyBatis 中极为重要的调整设置，它们会改变 MyBatis 的运行时行为。 下表描述了设置中各项设置的含义、默认值等。

设置名	描述	有效值	默认值
cacheEnabled	全局性地开启或关闭所有映射器配置文件中已配置的任何缓存。	true | false	true
lazyLoadingEnabled	延迟加载的全局开关。当开启时，所有关联对象都会延迟加载。 特定关联关系中可通过设置 fetchType 属性来覆盖该项的开关状态。	true | false	false
mapUnderscoreToCamelCase	是否开启驼峰命名自动映射，即从经典数据库列名 A_COLUMN 映射到经典 Java 属性名 aColumn。	true | false	False
logImpl	指定 MyBatis 所用日志的具体实现，未指定时将自动查找。	SLF4J | LOG4J | LOG4J2 | JDK_LOGGING | COMMONS_LOGGING | STDOUT_LOGGING | NO_LOGGING	未设置

其他配置

• typeHandlers（类型处理器）
• objectFactory（对象工厂）
• plugins（插件）
  • mybatis-generator-core
  • mybatis-plus

映射器（mappers）

MapperRegister直接告诉 MyBatis 到哪里去找映射文件

方法一：通过xml注册，xml可以放在任何层

<mappers>
	<mapper resource="com/bos/dao/UserMapper.xml"/>
</mappers>

方法二：注册整个包，接口和Mapper同名且在同一个包下

<mappers>
	<package name="com.bos.dao"/>
</mappers>

生命周期

生命周期很重要，如果错误使用，会导致严重并发问题。

SqlSessionFactoryBuilder

• 这个类可以被实例化、使用和丢弃，一旦创建了 SqlSessionFactory，就不再需要它了。
• 局部变量

SqlSessionFactory

• 想象为数据库连接池
• SqlSessionFactory 一旦被创建就应该在应用的运行期间一直存在
• 全局应用作用域
• 最简单的就是使用单例模式或者静态单例模式。

sqlSession

• 数据库链接的一个请求
• 每个线程都应该有它自己的 SqlSession 实例，用完之后尽快关闭，否则资源会被占用
• SqlSession 的实例不是线程安全的，因此是不能被共享的，所以它的最佳的作用域是请求或方法作用域

这里的每个Mapper都是一次

解决属性名和字段名不一致的问题

	private String password; //数据库pwd不一致

用resultMap标签来解决

  <!-- 结果集映射 -->
  <resultMap type="User" id="UserMap">
  <!-- column：数据库字段 ，property：实体属性 -->
  	<result column="pwd" property="password"/>
  	<result column="id" property="id"/>
  </resultMap>
  <select id="getUserById" resultMap="UserMap" parameterType="int">
  	select * from mybatis.user where id=#{id};
  </select>

ResultMap 的设计思想是，对简单的语句做到零配置，对于复杂一点的语句，只需要描述语句之间的关系就行了。

日志

日志工厂

操作异常时，自动打印日志，有助于排错。

1. STDOUT_LOGGING：标准日志，无需配置

    <settings>
    	<setting name="logImpl" value="STDOUT_LOGGING"/>
    </settings>

2. log4j

• LOG4J：是Apache的一个开源项目，通过使用Log4j，我们可以控制日志信息输送的目的地是控制台、文件、GUI组件
• 我们也可以控制每一条日志的输出格式；通过定义每一条日志信息的级别，我们能够更加细致地控制日志的生成过程。
• 最令人感兴趣的就是，这些可以通过一个配置文件来灵活地进行配置，而不需要修改应用的代码。

导包

<dependencies>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
</dependencies>

配置log4j.properties文件

#将等级为DEBUG的日志信息输出到console和file这两个目的地，console和file的定义在下面的代码
log4j.rootLogger=DEBUG,console,file

#控制台输出的相关设置
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

#文件输出的相关设置
log4j.appender.file = org.apache.log4j.RollingFileAppender
log4j.appender.file.File=./log/carmine.log
log4j.appender.file.MaxFileSize=10mb
log4j.appender.file.Threshold=DEBUG
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=[%p][%d{yy-MM-dd}][%c]%m%n

#日志输出级别
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

配置log4j为项目的日志实现

    <settings>
    	<setting name="logImpl" value="LOG4J"/>
    </settings>

测试运行，效果几乎一致，相对更详细

import org.apache.log4j.Logger;
		//获取日志对象
	static Logger logger=Logger.getLogger(UserDaoTest.class);
	@Test
	public void testlog4j() {
		logger.info("info：");
		logger.error("error:");
		logger.debug("debug:");
	}

会输出到指定的log/carmine.log文件下。

分页

SQL分页

  <select id="getUserByLimit" resultType="User" parameterType="map">
  	select * from mybatis.user limit #{startindex},#{endindex};
  </select>  

List<User> getUserByLimit(Map<String,Integer> map);

public void getUserByLimit() {
		SqlSession sqlSession=MybatisUtils.getsqlSession();
		
		//配置日志
		logger.info("进入getUserByLimit成功");
		
		UserMapper userDao=sqlSession.getMapper(UserMapper.class);

		HashMap<String, Integer> map=new HashMap<String, Integer>();
		map.put("startindex", 0);
		map.put("endindex", 2);
		
		List<User> users=userDao.getUserByLimit(map);
		for(User user:users)
			System.out.println(user);
		
		sqlSession.close();
	}

RowBound分页

mybatis自带，面向对象

分页插件

注解开发

CRUD

Select：不用再在UserMapper.xml中写标签

	//获取全部用户
	@Select("select * from mybatis.user;")
	List<User> getUserList();

    <mappers>
    	<mapper class="com.bos.dao.UserMapper"/>
    </mappers>

本质：反射机制实现 底层：动态代理模式

有缺陷：使用注解来映射简单语句会使代码显得更加简洁，但对于稍微复杂一点的语句，Java 注解不仅力不从心，还会让你本就复杂的 SQL 语句更加混乱不堪。

Param

• 基本类型或者String类型，需要加上
• 引用类型不用加
• 在SQL中引用的就是@Param中设置的属性

	//方法有多个参数，一定要加@Param
	@Select("select * from mybatis.user where id=#{uid} and name=#{name}")
	User getUserById3(@Param("uid") int id,@Param("name") String name);

Tips：#{param}可以避免SQL注入

LamBok插件

能以简单的注解形式来简化java代码，提高开发人员的开发效率。

@Alias("User") 
@Data  生成无参构造 get set tostring hashcode equals
@AllArgsConstructor  有参
@NoArgsConstructor 无参
@ToString
@EqualsAndHashCode
public class User {
	private int id;
	private String name;
	private String password; //数据库不一致
    //依然能自己加
	public User(int id) {
		this.id=id;
	}
}

多对一处理

• association

  • 一个复杂类型的关联；许多结果将包装成这种类型

  • 嵌套结果映射 – 关联可以是 resultMap 元素，或是对其它结果映射的引用

• collection

  • 一个复杂类型的集合

  • 嵌套结果映射 – 集合可以是 resultMap 元素，或是对其它结果映射的引用

详细内容请移步：
SSM——Mybatis框架进阶