MyBatis基础与实战-优快云博客

MyBatis基础入门

内容

1.MyBatis介绍
2.MyBatis入门程序
3.MyBatis使用Mapper接口
4.MyBatis之Config文件常用配置

一.MyBatis简介

1 .简介

1.Mybatis和Hibernate一致,是一个开源ORM框架.
MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了
google code，并且改名为MyBatis 。2013年11月迁移到Github。iBATIS一词来源于“internet”和“abatis”的组合，是一个基于Java的持久层框架。iBATIS提供的持久层框架包括SQL Maps和Data Access Objects（sDAO）.
2.Mybaits是对JDBC的轻量级封装的框架.
3.提供了XML和注解方式来构建Java对像和数据库的映射关系,实质上提供了接口和JavaPOJO对像的映射.

ORM的概念

ORM:Object Relational Mapping  对像关系映射模型
研究的是:
Java对像------关系型数据的映射关系
Java类------关系型数据对应的表结构的映射关系
Mybatis额外的研究:
Java的Dao层接口-----Sql语句的映射

2.下载地址

https://github.com/mybatis/mybatis-3/releases
使用版本为:3.4.6版本讲解

3.框架特点

1.简单易学：本身就很小且简单。没有任何第三方依赖，最简单安装只要两个jar文件+配置几个sql映射文件易
于学习，易于使用，通过文档和源代码，可以比较完全的掌握它的设计思路和实现。
2.灵活：mybatis不会对应用程序或者数据库的现有设计强加任何影响。 sql写在xml里，便于统一管理和优
化。通过sql基本上可以实现我们不使用数据访问框架可以实现的所有功能，或许更多。
3.解除sql与程序代码的耦合：通过提供DAO层，将业务逻辑和数据访问逻辑分离，使系统的设计更清晰，更易
维护，更易单元测试。sql和代码的分离，提高了可维护性。
4.提供映射标签，支持对象与数据库的orm字段关系映射
5.提供对象关系映射标签，支持对象关系组件维护
6.提供xml标签，支持编写动态sql

二.MyBaits的入门程序

1.实现步骤

1.配置SqlMapConfig.xml(mybatis-config.xml)
2.配置Mapper.xml文件
3.创建SqlSessionFactory对像
4.创建SqlSession对像
5.使用SqlSession提供的API进行CRUD操作即可

[外链图片转存失败(img-AR2XlDgw-1564208065276)(1.bmp)]

2.几个重要对像的生命同期

1.SqlSessionFactoryBuilder
2.SqlSessionFactory
3.SqlSession
4.Mapper Instances

1.SqlSessionFactoryBuilder的生命周期:
这个类可以被实例化、使用和丢弃，一旦创建了 SqlSessionFactory，就不再需要它了。因此 SqlSessionFactoryBuilder 实例的最佳作用域是方法作用域（也就是局部方法变量）。你可以重用 SqlSessionFactoryBuilder 来创建多个 SqlSessionFactory 实例，但是最好还是不要让其一直存在以保证所有的 XML 解析资源开放给更重要的事情。

2.SqlSessionFactory的生命周期
SqlSessionFactory 一旦被创建就应该在应用的运行期间一直存在，没有任何理由对它进行清除或重建。使用 SqlSessionFactory 的最佳实践是在应用运行期间不要重复创建多次，多次重建 SqlSessionFactory 被视为一种代码“坏味道（bad smell）”。因此 SqlSessionFactory 的最佳作用域是应用作用域。有很多方法可以做到，最简单的就是使用单例模式或者静态单例模式。

3.SqlSession(相当于JDBC中的statement对像)
每个线程都应该有它自己的 SqlSession 实例。SqlSession 的实例不是线程安全的，因此是不能被共享的，所以它的最佳的作用域是请求或方法作用域。绝对不能将 SqlSession 实例的引用放在一个类的静态域，甚至一个类的实例变量也不行。也绝不能将 SqlSession 实例的引用放在任何类型的管理作用域中，比如 Servlet 架构中的 HttpSession。如果你现在正在使用一种 Web 框架，要考虑 SqlSession 放在一个和 HTTP 请求对象相似的作用域中。换句话说，每次收到的 HTTP 请求，就可以打开一个 SqlSession，返回一个响应，就关闭它。这个关闭操作是很重要的，你应该把这个关闭操作放到 finally 块中以确保每次都能执行关闭。

4.Mapper Instances 生命周期(产生的动态代理对像)
映射器是一个你创建来绑定你映射的语句的接口。映射器接口的实例是从 SqlSession 中获得的。因此从技术层面讲，任何映射器实例的最大作用域是和请求它们的 SqlSession 相同的。尽管如此，映射器实例的最佳作用域是方法作用域。也就是说，映射器实例应该在调用它们的方法中被请求，用过之后即可废弃。并不需要显式地关闭映射器实例，尽管在整个请求作用域（request scope）保持映射器实例也不会有什么问题，但是很快你会发现，像 SqlSession 一样，在这个作用域上管理太多的资源的话会难于控制。所以要保持简单，最好把映射器放在方法作用域（method scope）内

3.入门程序

1.在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>
    <!--加载外部properties文件-->
    <properties resource="db.properties"></properties>
    <!--default表示当前使用的数据库连接环境,如果指向一个environment标签的ID,
    表示使用该环境作为当前连接环境-->
    <environments default="development">
        <!--Id表示当前连接环境的标识-->
        <environment id="development">
            <!--事务管理:
            type取值有二个(JDBC|MANAGED)
       1.JDBC – 这个配置就是直接使用了 JDBC 的提交和回滚设置，它依赖于从数据源得到的连接来管理事务作用域。
       2.MANAGED – 这个配置几乎没做什么。它从来不提交或回滚一个连接，而是让容器来管理事务的整个生命周期
            （比如 JEE 应用服务器的上下文）
            注意:如果你正在使用 Spring + MyBatis，则没有必要配置事务管理器，
            因为 Spring 模块会使用自带的管理器来覆盖前面的配置。
            -->
            <transactionManager type="JDBC"/>
            <!--数据源配置:
            type取值有三个(UNPOOLED|POOLED|JNDI)
            1.UNPOOLED -这个数据源的实现只是每次被请求时打开和关闭连接。虽然有点慢，
            但对于在数据库连接可用性方面没有太高要求的简单应用程序来说，是一个很好的选择。
            不同的数据库在性能方面的表现也是不一样的，对于某些数据库来说，
            使用连接池并不重要，这个配置就很适合这种情形。
            2.POOLED -这种数据源的实现利用“池”的概念将 JDBC 连接对象组织起来，
            避免了创建新的连接实例时所必需的初始化和认证时间。
            这是一种使得并发 Web 应用快速响应请求的流行处理方式。
            3.JNDI - 这个数据源的实现是为了能在如 EJB 或应用服务器这类容器中使用，
            容器可以集中或在外部配置数据源，然后放置一个 JNDI 上下文的引用
            -->
            <dataSource type="POOLED">
                <!--数据库连接信息-->
                <property name="driver" value="${db.driver}"/>
                <property name="url" value="${db.url}"/>
                <property name="username" value="${db.username}"/>
                <property name="password" value="${db.password}"/>
            </dataSource>
        </environment>
    </environments>

    <!--映射关系的引入-->
    <mappers>
        <mapper resource="mapper/UserMapper.xml"/>
    </mappers>
</configuration>

2.在resources目录下创建db.properties

db.driver=com.mysql.jdbc.Driver
db.url=jdbc:mysql://192.168.1.165:3306/javaee
db.username=root
db.password=123456

3.在resources目录下创建log4j.properties

# Global logging configuration
log4j.rootLogger=DEBUG, stdout
# MyBatis logging configuration...
#log4j.logger.org.mybatis.example.BlogMapper=TRACE
# 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

4.pom.xml文件配置

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.sy</groupId>
    <artifactId>mybatis_day01</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>

        
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.6</version>
        </dependency>
      
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>

      
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.40</version>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>
    <build>
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                </includes>
            </resource>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.xml</include>
                    <include>**/*.properties</include>
                </includes>
            </resource>
        </resources>
    </build>
</project>

5.在mapper包下创建XXXMapper.xml文件

<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--接口和sql语句的映射-->
<mapper namespace="mapper.UserMapper">

    <select id="selectAll" resultType="model.User">
        select * from User
    </select>
    <!--如果是基本类型及String类型,#{参数名}没有限制.-->
    <select id="selectById" resultType="model.User" parameterType="java.lang.Integer">
        select * from user where id = #{id}
    </select>
    <!--如果参数为POJO,#{参数名},该参数名必须是该POJO中get方法后缀字符串,首字母小写-->
    <insert id="insert" parameterType="model.User">
        insert into user (username,password) values(#{username},#{password})
    </insert>

    <delete id="delete" parameterType="java.lang.Integer">
        delete from User where id = #{id}
    </delete>

    <update id="update" parameterType="model.User">
        update user set username=#{username},password=#{password} where id=#{id}
    </update>

</mapper>

6.创建SqlSession对像

public class DBUtil {

    static SqlSessionFactory factory;

    static{
        String config = "mybatis-config.xml";
        try {
            SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
            InputStream is =  Resources.getResourceAsStream(config);
            factory = builder.build(is);
        }catch (Exception e){
            e.printStackTrace();
        }

    }

    /**
     * 返回SqlSession对像
     * @return
     */
    public static SqlSession openSqlSession(){
        return factory.openSession();
    }
}

7.实现Dao层CRUD操作

public class UserDao {
    public void insert(User user){
		//SqlSession为方法作用域
        SqlSession session = DBUtil.openSqlSession();
        try {
            session.insert("mapper.UserMapper.insert",user);
            //提交事务
            session.commit();
        }catch (Exception e){
            e.printStackTrace();
            //事务回滚
            session.rollback();
        }finally {
            //关闭session
            session.close();
        }

    }

    public void delete(int id){
        SqlSession session = DBUtil.openSqlSession();
        try {
            session.delete("mapper.UserMapper.delete",id);
            //提交事务
            session.commit();
        }catch (Exception e){
            e.printStackTrace();
            session.rollback();
        }finally {
            session.close();
        }
    }

    public void update(User user){

        SqlSession session = DBUtil.openSqlSession();
        try {
            session.update("mapper.UserMapper.update",user);
            //提交事务
            session.commit();
        }catch (Exception e){
            e.printStackTrace();
            session.rollback();
        }finally {
            session.close();
        }
    }

    public User selectById(int id){

        SqlSession session = DBUtil.openSqlSession();
        User user = null;
        try {
            user = session.selectOne("mapper.UserMapper.selectById",id);
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            session.close();
        }
        return user;
    }

    public List<User> selectAll(){

        SqlSession session = DBUtil.openSqlSession();
        List<User> users = null;
        try {
            users = session.selectList("mapper.UserMapper.selectAll");
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            session.close();
        }
        return users;
    }
}

8.单元测试

public class TestDao {
    UserDao dao;
    @Before
    public void init(){
        dao = new UserDao();
    }

    @Test
    public void testInsert(){
        User user = new User();
        user.setUsername("jack");
        user.setPassword("1234");
        dao.insert(user);
    }

    @Test
    public void testUpdate(){

        User user = new User();
        user.setId(4);
        user.setUsername("jack");
        user.setPassword("0000");
        dao.update(user);
    }

    @Test
    public void testDelete(){
        int id = 4;
        dao.delete(id);
    }

    @Test
    public void testSelectAll(){
       List<User> list = dao.selectAll();
        System.out.println(list);
    }

    @Test
    public void testSelectById(){
        int id = 1;
        User user = dao.selectById(id);
        System.out.println(user);
    }
}

练习

1.搭建Mybatis环境,对数据中User表中记录进行CURD操作.

三.MyBatis使用Mapper接口

1.使用Mapper映射器

为了适应Javak中面向接口编程的要求,mybatis会为接口层(Dao层)使用JDK动态代理方式创建代理对像.调用代理对像中的API即可进行CRUD操作

2.开发规范

1.mapper接口的完全限定名要和mapper映射文件的namespace的值相同
	把mapper文件和接口绑定在一起,实现了接口和mapper文件的映射,同时实现接口中方法和mapper文件中的sql语句的映射。
2.mapper接口的方法名称要和mapper映射文件中的statement的id相同；
3.mapper接口的方法参数只能有一个，且类型要和mapper映射文件中statement的parameterType的值保持
一致。
4.mapper接口的返回值类型要和mapper映射文件中statement的resultType值或resultMap中的type值保持一
致；

3.代码实现

//Mapper接口
/**
 * 1.接口和UserMapper.xml文件映射(加mapper.xml文件-->解析namespace-->找到绑定的接口)
 */
public interface UserMapper {

    /**
     * 接口中方法和Mapper.xml文件中sql语句的映射
     * 1.方法名和sql标签的id值一致
     * 2.参数必须单个,参数类型和parameterType类型一致
     * 3.返回值类型要和resultType类型一致
     * @param user
     */
    void insert(User user);

    void delete(int id);

    void update(User user);

    List<User> selectAll();

    User selectById(int id);

}

<!--Mapper.xml文件-->

<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--接口和sql语句的映射-->
<mapper namespace="mapper.UserMapper">
    <!--Statement mapper_UserMapper_selectAll = Connection.prepareament()-->
    <select id="selectAll" resultType="model.User">
        select * from User
    </select>
    <!--如果是基本类型及String类型,#{参数名}没有限制.-->
    <select id="selectById" resultType="model.User" parameterType="java.lang.Integer">
        select * from user where id = #{id}
    </select>
    <!--如果参数为POJO,#{参数名},该参数名必须是该POJO中get方法后缀字符串,首字母小写-->
    <insert id="insert" parameterType="model.User">
        insert into user (username,password) values(#{username},#{password})
    </insert>

    <delete id="delete" parameterType="java.lang.Integer">
        delete from User where id = #{id}
    </delete>

    <update id="update" parameterType="model.User">
        update user set username=#{username},password=#{password} where id=#{id}
    </update>

</mapper>

//Service类
public class UserService {
    public void save(User user){
        SqlSession session = DBUtil.openSqlSession();
        try {
            //返回一个Mapper接口的代理对像,其作用域为方法作用域,和session作用域相同
            //通过JDK动态代理方式创建代理对像.
            UserMapper mapper = session.getMapper(UserMapper.class);
            mapper.insert(user);
            session.commit();
        }catch (Exception e){
            e.printStackTrace();
            session.rollback();
        }finally {
            session.close();
        }
    }

    public void remove(int id){

        SqlSession session = DBUtil.openSqlSession();
        try {
         
            UserMapper mapper = session.getMapper(UserMapper.class);
            mapper.delete(id);
            session.commit();
        }catch (Exception e){
            e.printStackTrace();
            session.rollback();
        }finally {
            session.close();
        }
    }

    public void modify(User user){

        SqlSession session = DBUtil.openSqlSession();
        try {
           
            UserMapper mapper = session.getMapper(UserMapper.class);
            mapper.update(user);
            session.commit();
        }catch (Exception e){
            e.printStackTrace();
            session.rollback();
        }finally {
            session.close();
        }
    }

    public List<User> findAll(){
        SqlSession session = DBUtil.openSqlSession();
        List<User> list = null;
        try {
           
            UserMapper mapper = session.getMapper(UserMapper.class);
            list = mapper.selectAll();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            session.close();
        }

        return list;
    }

    public User findById(int id){

        SqlSession session = DBUtil.openSqlSession();
        User user = null;
        try {
           
            UserMapper mapper = session.getMapper(UserMapper.class);
            user = mapper.selectById(id);
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            session.close();
        }
        return user;
    }
}

//测试类
public class TestUserService {

    UserService ser = new UserService();

    @Test
    public void findAll(){

        List<User> list = ser.findAll();

        System.out.println(list);
    }

    @Test
    public void findById(){

        User user = ser.findById(1);

        System.out.println(user);
    }

    @Test
    public void testSave(){

        User user = new User();
        user.setUsername("kevin");
        user.setPassword("1111");

        ser.save(user);
    }

    @Test
    public void testModify(){

        User user = new User();
        user.setId(5);
        user.setUsername("kevin");
        user.setPassword("0000");

        ser.modify(user);
    }

    @Test
    public void testRemove(){

        ser.remove(5);
    }
}

四.MyBatis之Config文件常用配置

1.常用配置

1.properties标签配置
2.settings标签配置
3.typeAlias标签配置
4.environments标签相应配置
5.mappers映射标签相应配置

2.properties标签配置

相应属性:
1.resource
	一般通过相对路径方式引入mapper映射文件
2.url
	一般通过绝对路径引入相应磁盘位置的映射文件,也可以通过http引入网上资源文件

子标签property标签:
通过key和value来设置property属性,相当于把外部的资源通过该标签配置在properties标签中

如果属性在不只一个地方进行了配置，那么 MyBatis 将按照下面的顺序来加载：

resource属性加载的外部配置,会覆盖property子标签中的同名属性配置.

<properties resource="db.properties">
  <property name="url" value="jdbc:mysql://192.168.1.165:3306/javaee"/>
  <property name="driver" value="com.mysql.jdbc.Driver"/>
  <property name="username" value="root"/>
  <property name="password" value="123456"/>
</properties>

3.settings标签配置

用来设置mybatis的全局行为.

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

4.typeAlias标签配置

给mapper.xml文件中model模型类起别名.

  <typeAliases>
      	<!--给相应类型起别名-->
        <typeAlias type="model.User" alias="User"></typeAlias>
   </typeAliases>

  <typeAliases>
        <!--给model包中所有类起别名,别名为相应的类名-->
        <package name="model"></package>
    </typeAliases>

5.environments标签相应配置

<environments default="development">
  <environment id="development">
    <transactionManager type="JDBC">
      <property name="..." value="..."/>
    </transactionManager>
    <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>

1.default属性:
	默认使用的连接环境,通常指向environment标签的id
2.environment子标签
	用来配置连接环境,id属性指代该连接环境的唯一标识.
3.transactionManager标签
	设置事务管理策略,type属性取值为JDBC或MANAGED
	JDBC:表示使用JDBC事务管理
	MANAGED:表示让指定应用服务器容器进行事务管理
	如果事务交由spring管理,该设置将被覆盖掉.
4.dataSource标签
	用来配置数据源(数据库连接信息),取值POOLED,UNPOOLED,JNDI
	POOLED:表示使用连接池管理connection对像
	UNPOOLED:不使用连接池,每次都会创建新的Connection对像,使用后,都会销毁该对像.
	JNDI:使用应用服务器给产生的连接对像.
	如果数据源交由spring创建,该设置将会被覆盖.

6.mappers映射标签相应配置

<!-- 使用相对于类路径的资源引用 -->
<mappers>
  <mapper resource="mapper/UserMapper.xml"/>
  .....
</mappers>

<!-- 使用完全限定资源定位符（URL） -->
<mappers>
  <mapper url="file:///var/mapper/UserMapper.xml"/>
  .....
</mappers>

<!-- 使用映射器接口实现类的完全限定类名 -->
<!--先加载接口,再加载mapper.xml文件:会去加载接口所在包下的xml文件,该文件名必须与接口相同-->
<mappers>
  <mapper class="mapper.UserMapper"/>
  ....
</mappers>

<!-- 将包内的映射器接口实现全部注册为映射器,如下,扫描mapper包中的接口-->
<!--先加载接口,再加载mapper.xml文件:会去加载接口所在包下的xml文件,该文件名必须与接口相同-->
<mappers>
  <package name="mapper"/>
</mappers>

练习

使用创建Mapper接口代理对像方式,进行CRUD操作

MyBatis入门教程

MyBatis基础入门

内容

一.MyBatis简介

1 .简介

2.下载地址

3.框架特点

二.MyBaits的入门程序

1.实现步骤

2.几个重要对像的生命同期

3.入门程序

三.MyBatis使用Mapper接口

1.使用Mapper映射器

2.开发规范

3.代码实现

四.MyBatis之Config文件常用配置

1.常用配置

2.properties标签配置

3.settings标签配置

4.typeAlias标签配置

5.environments标签相应配置

6.mappers映射标签相应配置