mybatis基础

mybatis的概述

• mybatis是一个持久层框架，用java语言编写
• 它封装了jdbc操作的很多细节，使开发者只需要关注sql语句本身，而无需关注注册驱动，创建连接等繁杂过程
• 它使用了ORM思想实现了结果集的封装

ORM

对象关系映射：

• 就是把数据库表和实体类及实体类的属性对应起来
• 让我们可以操作实体类就实现操作数据库表

mybatis的入门

一、mybatis的环境搭建
1.创建maven工程
2.添加相关依赖

<packaging>jar</packaging>

    <dependencies>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.5</version>
        </dependency>

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

        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.12</version>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.10</version>
        </dependency>
    </dependencies>

3.创建实体类和dao的接口
4.创建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">

<!--mybaits的主配置文件-->
<configuration>
    <!--配置环境-->
    <environments default="mysql">
        <!--配置mysql的环境-->
        <environment id="mysql">
            <!--配置事务的类型-->
            <transactionManager type="JDBC"></transactionManager>
            <!--配置数据源（连接池）-->
            <dataSource type="POOLED">
                <!--配置连接数据库的4个基本信息-->
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/eesy"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>

    <!--指定映射配置文件的位置，映射配置文件指的是每个独立的配置文件-->
    <mappers>
        <mapper resource="com/hu/dao/UserDao.xml"/>
    </mappers>
</configuration>

5.创建映射配置文件

<?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.hu.dao.UserDao">
    <!--配置查询所有-->
    <select id="findAll">
        select * from user;
    </select>

</mapper>

二、环境搭建的注意事项
1.创建UserDao.xml和UserDao.java时名称是为了和之前的知识保持一致。
再mybatis中它把持久层的操作接口名称和映射文件也叫做：mapper
所以：UserDao和UserMapper是一样的

2.在idea中创建目录的时候，它和包是不一样的
包在创建时：com.hu.dao它是三级结构
目录在创建时：com.hu.dao是一级结构

3.mybatis的映射配置文件位置必须和dao接口的包结构相同

4.映射配置文件的mapper标签namespace属性的取值必须是dao接口的全限定类名

5.映射配置文件的操作配置（select），id属性的取值必须是dao接口的方法名

6.当我们遵从了第3、4、5点之后，在开发中就无需再写dao的实现类

三、入门案例
第一步：读取配置文件
第二步：创建SqlSessionFactory工厂
第三步：创建SqlSession
第四步：创建Dao接口的代理对象
第五步：执行dao中的方法
第六步：释放资源
注意事项：
不要忘记再映射配置中告知mybatis结果要封装到那个实体类中
配置的方式：指定实体类的全限定类名

package com.hu.test;

import com.hu.dao.UserDao;
import com.hu.domain.User;
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 java.io.InputStream;
import java.util.List;

public class MybatisTest {
    /**
     * 入门案例
     * @param args
     */
    public static void main(String[] args)throws Exception {
        //1.读取配置文件
        InputStream in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.创建SqlSessionFactory工厂
        SqlSessionFactoryBuilder builder=new SqlSessionFactoryBuilder();
        SqlSessionFactory factory=builder.build(in);
        //3.使用工厂生产SqlSession对象
        SqlSession session = factory.openSession();
        //4.使用SqlSession创建Dao接口的代理对象
        UserDao userDao = session.getMapper(UserDao.class);
        //5.使用代理对象执行方法
        List<User> users = userDao .findAll();
        for (User user : users) {
            System.out.println(user);
        }
        //6.释放资源
        session.close();
        in.close();

    }
}

四、mybatis基于注解入门
把UserDao.xml移除，在dao接口的方法上使用@Select注解，并且指定sql语句
同时需要在SqlMapConfig.xml中的mapper配置时，使用class属性指定dao接口的全限定类名。

五、明确
在实际开发中越简练越好，所以都采用不写dao实现类的方式。
不管使用XML还是注解配置
但是mybatis是支持写dao实现类的

六、mybatis设计模式分析

mybatis的CRUD

dao接口

package com.tiger.dao;


import com.tiger.domain.User;

import java.util.List;

/**
 * 用户的持久层接口
 */
public interface UserDao {

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

    /**
     * 保存用户
     * @param user
     */
    void saveUser(User user);

    /**
     * 更新用户
     * @param user
     */
    void updateUser(User user);

    /**
     * 根据id删除用户
     * @param userId
     */
    void deleteUser(Integer userId);

    /**
     * 根据id查询用户信息
     * @param userId
     * @return
     */
    User findById(Integer userId);


    /**
     * 根据名称模糊查询用户信息
     * @param username
     * @return
     */
    List<User> findByName(String username);

    /**
     * 查询总用户数
     * @return
     */
    int findTotal();
}

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">

<mapper namespace="com.tiger.dao.UserDao">
    <!--查询所有-->
    <select id="findAll" resultType="com.tiger.domain.User">
        select * from user;
    </select>

    <!--保存用户-->
    <insert id="saveUser" parameterType="com.tiger.domain.User">
        <!--配置插入操作后，获取插入数据的id-->
        <selectKey keyProperty="id" keyColumn="id" resultType="int" order="AFTER">
            select last_insert_id();
        </selectKey>
        insert into user(username,address,sex,birthday) values(#{username},#{address},#{sex},#{birthday});
    </insert>

    <!--更新用户-->
    <update id="updateUser" parameterType="com.tiger.domain.User">
        update user set username=#{username},address=#{address},sex=#{sex},birthday=#{birthday} where id=#{id};
    </update>

    <!--删除用户-->
    <delete id="deleteUser" parameterType="Integer">
        delete from user where id=#{id};
    </delete>

    <!--根据id查询用户-->
    <select id="findById" resultType="com.tiger.domain.User" parameterType="Integer">
        select * from user where id=#{id};
    </select>

    <!--根据名称模糊查询-->
    <select id="findByName" parameterType="String" resultType="com.tiger.domain.User">
        select * from user where username like #{username};
    <!--select * from user where username like '%${value}%'; 有sql注入风险-->
</select>

<!--查询总用户数-->
    <select id="findTotal" resultType="int">
        select count(id) from user;
    </select>
</mapper>

Test

package com.tiger.test;

import com.tiger.dao.UserDao;
import com.tiger.domain.User;
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.After;
import org.junit.Before;
import org.junit.Test;

import java.io.IOException;
import java.io.InputStream;
import java.util.Date;
import java.util.List;

/**
 * 测试mybatis的CRUD操作
 */
public class MyBatisTest {

    private InputStream in =null;
    private SqlSession sqlSession =null;
    private UserDao userDao =null;

    /**
     * 用于初始化
     * @throws IOException
     */
    @Before
    public void init() throws IOException {
        //1.读取配置文件，生成字节输入流
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.获取SqlSessionFactory对象
        SqlSessionFactory factory= new SqlSessionFactoryBuilder().build(in);
        //3.获取SqlSession对象
        sqlSession = factory.openSession();
        //4.获取dao的代理对象
        userDao = sqlSession.getMapper(UserDao.class);
    }

    /**
     * 用于释放资源
     * @throws IOException
     */
    @After
    public void destory() throws IOException {
        //提交事务
        sqlSession.commit();
        //6.释放资源
        sqlSession.close();
        in.close();
    }
    /**
     * 测试查询所有
     */
    @Test
    public void testFindAll(){

        //5.执行查询所有方法
        List<User> users = userDao.findAll();
        for (User user : users) {
            System.out.println(user);
        }
    }


    /**
     * 测试保存操作
     */
    @Test
    public void testSave(){
        User user=new User();
        user.setUsername("文虎 last insertid");
        user.setAddress("北京市顺义区");
        user.setBirthday(new Date());
        user.setSex("男");
        System.out.println("保存操作之前："+user);
        //5.执行方法
        userDao.saveUser(user);

        System.out.println("保存操作之后："+user);
    }


    /**
     * 测试更新操作
     */
    @Test
    public void testUpdate(){
        User user=new User();
        user.setId(5);
        user.setUsername("mybatis update user");
        user.setAddress("北京市顺义区");
        user.setBirthday(new Date());
        user.setSex("女");
        //5.执行方法
        userDao.updateUser(user);
    }


    /**
     * 测试删除操作
     */
    @Test
    public void testDelete(){

        //5.执行方法
        userDao.deleteUser(5);
    }

    /**
     * 测试删除操作
     */
    @Test
    public void testfindOne(){

        //5.执行方法
        User user = userDao.findById(2);
        System.out.println(user);
    }


    /**
     * 测试模糊查询操作
     */
    @Test
    public void testfindByName(){

        //5.执行方法
        List<User> users = userDao.findByName("%虎%");
        for (User user : users) {
            System.out.println(user);
        }
    }

    /**
     * 测试聚合查询总记录数操作
     */
    @Test
    public void testfindTotal(){

        //5.执行方法
        int total = userDao.findTotal();
        System.out.println(total);
    }
}

mybatis中参数深入

OGNL表达式：

Object Graphic Navigation Language 对象图导航语言
它是通过对象的取值方法来获取数据。在写法上把get给省略了。
比如：获取用户名
类中的写法：user.getUsername();
OGNL表达式写法：user.username
mybatis中#{username}为什么能直接写username，而不用写user. 呢：
因为在parameterType中已经提供了属性所属的类，所以此时不需要写对象名

QueryVo

package com.tiger.domain;

public class QueryVo {
    private User user;

    public User getUser() {
        return user;
    }

    public void setUser(User user) {
        this.user = user;
    }
}

Dao接口

/**
     * 根据queryVo中的条件查询用户
     * @param vo
     * @return
     */
    List<User> findUserByVo(QueryVo vo);

Mapper

<!--根据queryvo的条件查询用户-->
    <select id="findUserByVo" parameterType="com.tiger.domain.QueryVo" resultType="com.tiger.domain.User">
        select * from user where username like #{user.username};
    </select>

Test

/**
     * 测试使用queryVo作为查询条件
     */
    @Test
    public void testfindByVo(){
        QueryVo vo=new QueryVo();
        User user=new User();
        user.setUsername("%虎%");
        vo.setUser(user);
        //5.执行方法
        List<User> users = userDao.findUserByVo(vo);
        for (User user1 : users) {
            System.out.println(user1);
        }

mybatis中返回值深入

resultType可以指定bean将查询结果封装为bean，但需要bean的属性和sql查询的列名一致，才能封装成功
如果sql查询字段名和bean的属性名不一致，可以通过resultMap将字段名和属性名做一个对应关系，resultMap实质上还是要把查询结果封装到bean中
resultMap可以实现将查询结果封装为复杂类型的bean，比如在查询结果封装对象中包含bean和list，实现一对一查询和一对多查询

<!--配置 查询结果的列名和实体类的属性的对应关系-->
    <resultMap id="userMap" type="com.tiger.domain.User">
        <!--主键字段的对应-->
        <id property="id" column="id"></id>
        <!--非主键字段的对应-->
        <result property="userName" column="username"></result>
        <result property="userAddress" column="address"></result>
        <result property="userSex" column="sex"></result>
        <result property="userBirthday" column="birthday"></result>

    </resultMap>

    <!--查询所有-->
    <select id="findAll" resultMap="userMap">
        select * from user;
    </select>

mybatis实现dao接口的使用方法

package com.tiger.dao.impl;

import com.tiger.dao.UserDao;
import com.tiger.domain.User;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;

import java.util.List;

public class UserDaoImpl implements UserDao {

    private SqlSessionFactory factory;

    public UserDaoImpl(SqlSessionFactory factory){
        this.factory=factory;
    }
    public List<User> findAll() {
        //1.根据factory获取sqlsession对象
        SqlSession sqlSession = factory.openSession();
        //2.调用sqlsession中的方法
        List<User> users = sqlSession.selectList("com.tiger.dao.UserDao.findAll");//参数就是能获取配置信息的key
        //3.释放资源
        sqlSession.close();
        return users;
    }

    public void saveUser(User user) {
        //1.根据factory获取sqlsession对象
        SqlSession sqlSession = factory.openSession();
        //2.调用方法实现保存
        sqlSession.insert("com.tiger.dao.UserDao.saveUser",user);
        //3.提交事务
        sqlSession.commit();
        //4.释放资源
        sqlSession.close();

    }

    public void updateUser(User user) {
        //1.根据factory获取sqlsession对象
        SqlSession sqlSession = factory.openSession();
        //2.调用方法实现更新
        sqlSession.update("com.tiger.dao.UserDao.updateUser",user);
        //3.提交事务
        sqlSession.commit();
        //4.释放资源
        sqlSession.close();
    }

    public void deleteUser(Integer userId) {
        //1.根据factory获取sqlsession对象
        SqlSession sqlSession = factory.openSession();
        //2.调用方法实现更新
        sqlSession.update("com.tiger.dao.UserDao.deleteUser",userId);
        //3.提交事务
        sqlSession.commit();
        //4.释放资源
        sqlSession.close();

    }

    public User findById(Integer userId) {
        //1.根据factory获取sqlsession对象
        SqlSession sqlSession = factory.openSession();
        //2.调用sqlsession中的方法
        User user = sqlSession.selectOne("com.tiger.dao.UserDao.findById",userId);
        //3.释放资源
        sqlSession.close();
        return user;
    }

    public List<User> findByName(String username) {
        //1.根据factory获取sqlsession对象
        SqlSession sqlSession = factory.openSession();
        //2.调用sqlsession中的方法
        List<User> users = sqlSession.selectList("com.tiger.dao.UserDao.findByName",username);
        //3.释放资源
        sqlSession.close();
        return users;
    }

    public int findTotal() {
        //1.根据factory获取sqlsession对象
        SqlSession sqlSession = factory.openSession();
        //2.调用sqlsession中的方法
        Integer count = sqlSession.selectOne("com.tiger.dao.UserDao.findTotal");
        //3.释放资源
        sqlSession.close();
        return count;
    }
}

package com.tiger.test;

import com.tiger.dao.UserDao;
import com.tiger.dao.impl.UserDaoImpl;
import com.tiger.domain.User;
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.After;
import org.junit.Before;
import org.junit.Test;

import java.io.IOException;
import java.io.InputStream;
import java.util.Date;
import java.util.List;

/**
 * 测试mybatis的CRUD操作
 */
public class MyBatisTest {

    private InputStream in =null;
    private UserDao userDao =null;

    /**
     * 用于初始化
     * @throws IOException
     */
    @Before
    public void init() throws IOException {
        //1.读取配置文件，生成字节输入流
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.获取SqlSessionFactory对象
        SqlSessionFactory factory= new SqlSessionFactoryBuilder().build(in);
        //3.使用工厂对象，创建Dao对象
        userDao = new UserDaoImpl(factory);
    }

    /**
     * 用于释放资源
     * @throws IOException
     */
    @After
    public void destory() throws IOException {
        //6.释放资源
        in.close();
    }
    /**
     * 测试查询所有
     */
    @Test
    public void testFindAll(){

        //5.执行查询所有方法
        List<User> users = userDao.findAll();
        for (User user : users) {
            System.out.println(user);
        }
    }


    /**
     * 测试保存操作
     */
    @Test
    public void testSave(){
        User user=new User();
        user.setUsername("文虎 last insertid");
        user.setAddress("北京市顺义区");
        user.setBirthday(new Date());
        user.setSex("男");
        System.out.println("保存操作之前："+user);
        //5.执行方法
        userDao.saveUser(user);

        System.out.println("保存操作之后："+user);
    }


    /**
     * 测试更新操作
     */
    @Test
    public void testUpdate(){
        User user=new User();
        user.setId(9);
        user.setUsername("mybatis update user");
        user.setAddress("陕西西安");
        user.setBirthday(new Date());
        user.setSex("女");
        //5.执行方法
        userDao.updateUser(user);
    }


    /**
     * 测试删除操作
     */
    @Test
    public void testDelete(){

        //5.执行方法
        userDao.deleteUser(7);
    }

    /**
     * 测试查询一个操作
     */
    @Test
    public void testfindOne(){

        //5.执行方法
        User user = userDao.findById(2);
        System.out.println(user);
    }


    /**
     * 测试模糊查询操作
     */
    @Test
    public void testfindByName(){

        //5.执行方法
        List<User> users = userDao.findByName("%虎%");
        for (User user : users) {
            System.out.println(user);
        }
    }

    /**
     * 测试聚合查询总记录数操作
     */
    @Test
    public void testfindTotal(){

        //5.执行方法
        int total = userDao.findTotal();
        System.out.println(total);
    }


}

properties标签的使用及细节

配置properties
        可以在标签内部配置连接数据库的信息。也可以通过属性引用外部配置文件信息
        resource属性： 常用的
            用于指定配置文件的位置，是按照类路径的写法来写，并且必须存在于类路径下。
        url属性：  不常用
            是要求按照Url的写法来写地址

jdbcConfig.properties文件

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/eesy
username=root
password=root

主配置文件

<properties resource="jdbcConfig.properties"> </properties>
    <!--配置环境-->
    <environments default="mysql">
        <!--配置mysql环境-->
        <environment id="mysql">
            <!--配置事务-->
            <transactionManager type="JDBC"></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>

typeAliases和package标签

typeAliases中的package为实体类包起别名

用于指定要配置别名的包，当指定之后，该包下的实体类都会注册别名，并且类名就是别名，不在区分大小写

<!--别名-->
    <typeAliases>
        <!--typeAliases用于配置别名。type属性指定的是实体类全限定类名.alias属性指定别名，指定了别名后就不再区分大小写-->
        <!--<typeAlias type="com.tiger.domain.User" alias="user"></typeAlias>-->
        <package name="com.tiger.domain"></package>
    </typeAliases>

mappers中的package为dao接口包起别名

package标签适用于指定dao接口所在的包，当指定了之后就不需要再写mapper以及resource或者class了

<!--配置mapper-->
    <mappers>
        <package name="com/tiger/dao"></package>
    </mappers>