MyBatis

什么是 MyBatis ？

---

　　MyBatis 是支持定制化 SQL、存储过程以及高级映射的优秀的持久层框架。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。MyBatis 可以对配置和原生Map使用简单的 XML 或注解，将接口和 Java 的 POJOs(Plain Old Java Objects,普通的 Java对象)映射成数据库中的记录。

理解：基于Java持久层框架，内部封装了jdbc，开发者只需要关系sql语句本身。

　　　采用ORM的思想解决了实体和数据库映射的问题，对JDBC进行了封装，同时屏蔽了jdbc API底层访问细节。

　　ORM：将数据库表和实体类及实体类的属性对应起来，通过操作实体类就实现数据库的操作。

　　　　　　注意：实体类 的属性与数据库表 的字段名一一对应

一，三层架构

　　1，视图层：展示数据

　　2，业务层：处理业务需求

　　3，持久层：与数据进行交互

二，mybatis入门

　　1，步骤

　　　　1.1，创建maven工程并导入坐标

　　　　1.2，创建实体类和dao接口

　　　　1.3，创建mybatis的主配置文件

　　　　　　　　SqlMapConifg.xml

　　　　1.4，创建映射配置文件

　　　　　　　　IUserDao.xml

　　2,注意事项：

　　　　第一：创建IUserDao.xml和IUserDao.java时文件的路径要一致

　　　　第二：包在创建：com.itheiam.doa是三级目录

　　　　　　　目录在创建时：com.itheiam.doa是一级目录·

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

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

　　　　　　

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

     　　　　

　　　　第六：满足以上要求就不用实现对应的接口

public static void main(String[] args) throws IOException {
        //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接口的代理对象
        IUserDao userDao=session.getMapper(IUserDao.class);//代理模式
        
        //5.使用代理对象执行方法
        List<User> users=userDao.findAll();
        for(User user:users) {
            System.out.println(user);
        }
        //6.释放资源
        session.close();
        in.close();
    }

 注意：1.读取配置文件时用的路径不要使用绝对路径，也不要使用相对路径

　　　　使用类加载器，只能读取类路径的配置文件，或者，使用ServlerContext对象的getRealPath（）

　　　　2.构建者模式：把对象的创建细节隐藏，让使用者直接调用方法即可拿到对象。

　　　　3.工厂模式：优势：解耦降低类之间的依赖关系

　　　　4.代理模式：优势：不修改源码的基础上对已有的方法增强

三，解析mybatis框架的原理

 核心：创建代理对象，实现查询所有。

 实例一

　　1.主配置文件

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

 <!-- mybatis的主配置文件 -->
 <configuration>
     <environments default="mysql">
     <!-- 配置mysql的环境 -->
        <environment id="mysql">
              <transactionManager type="JDBC" >
              </transactionManager>
              <dataSource type="POOLED">
                  <property name="driver" value="com.mysql.jdbc.Driver" />
                <property name="url" value="jdbc:mysql://localhost:3306/db_java" />
                <property name="username" value="root" />
                 <property name="password" value="" />
             </dataSource>
        </environment>
     </environments> 
     <!-- 指定映射配置文件，即每个dao独立的配置 -->
     <mappers>
         <mapper resource="com/dao/IUserDao.xml"/>
     </mappers>
    
 </configuration>

　　2,mapper文件。注意：要与对应的dao接口文件的路径对应

IUserDao.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">
<mapper namespace="com.dao.IUserDao">
    <!-- 配置查询所有  -->
        <select id="findAll" resultType="com.model.User">
<!-- 返回值也要写全限定的类名  -->
                select * from user;
        </select>
        
    <!-- 保存操作 -->
        <insert id="saveUser" parameterType="com.model.User">
<!-- 参数类型也要写全限定的类名  -->
            insert into user (name) values(#{name});
<!--#{}中的变量是对应的model中的User类的属性的getter方法的名称，但是省略了get,同时是小写  -->
        </insert>
</mapper>

3.com.dao.IUserDao.java

package com.dao;

import java.util.List;

import com.model.User;

public interface IUserDao {
    public List<User> findAll();
    void saveUser(User user);
}

4,com.model.User.java

package com.model;

import java.io.Serializable;

public class User implements Serializable{
    private Integer id;
    private String name;
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public String toString() {
        return "User [id=" + id + ", name=" + name + "]";
    }
    
}

注意: 要继承Serializable接口

5.pom.xml

 

<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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>mybatis</groupId>
  <artifactId>com</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <name>day1</name>
  
  <dependencies>
    <dependency>
        <!--一般情况下，maven是通过groupId、artifactId、version这三个元素值（俗称坐标）来检索该构件， 然后引入你的工程。如果别人想引用你现在开发的这个项目（前提是已开发完毕并发布到了远程仓库），-->   
           <!--就需要在他的pom文件中新建一个dependency节点，将本项目的groupId、artifactId、version写入， maven就会把你上传的jar包下载到他的本地 -->  
            <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>
  
</project>

 

6.test对应的代码com.test.java

　　　　　　　　com.dao.test

package com.dao.test;

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

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 org.junit.experimental.theories.suppliers.TestedOn;

import com.dao.IUserDao;
import com.model.User;

public class MybatisTest {
    private InputStream in;
    private SqlSession sqlSession;
    private IUserDao userDao;
    
    @Before //用于在测试方法之前执行
    public  void init() throws IOException {
        //1.读取配置文件
                 in=Resources.getResourceAsStream("SqlMapConfig.xml");
                
                //2.创建SqlSessionFactory工厂
                SqlSessionFactoryBuilder builder=new SqlSessionFactoryBuilder();
                SqlSessionFactory factory=builder.build(in);
                //3.使用工厂生产SqlSession对象
                 sqlSession=factory.openSession();
                //4.使用SqlSession创建Dao接口的代理对象
                 userDao=sqlSession.getMapper(IUserDao.class);
                
                
                
            }
    
    @After    //用于在测试之后
    public void destory() throws IOException {
        //提交事务
                sqlSession.commit();
        //6.释放资源
        sqlSession.close();
        in.close();
    }
    
    @Test
    public  void findAll() throws IOException {
        //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接口的代理对象 IUserDao
         * userDao=session.getMapper(IUserDao.class);
         */
        
        //5.使用代理对象执行方法
        List<User> users=userDao.findAll();
        for(User user:users) {
            System.out.println(user);
        }

    /*
     * //6.释放资源 session.close(); in.close(); }
     */
    }
    @Test
    public void testSaveAll() {
        User user=new User();
        user.setName("仙女");
        
        //执行保存方法
        userDao.saveUser(user);
        
    }
    
}

注意：1，在测试的时候的init方法和destory方法中要用@before和@after修饰

　　　分别表示：@before：在测试之前

　　　　　　　　@after：在测试之后

　　　2，增加，修改，删除均要提交事务

　　　　

　　　　　　//提交事务
　　　　　　　　sqlSession.commit();

 示例二：模糊查询

 

<select id="findUserByName" parameterType="string" resultType="com.model.User">
                select * from user where name like #{name};
                <!-- prepateStatement的参数占位符 -->
                <!--注意这里的vale的名称不能改变
                字符窜拼接，可能字符串注入
                select * from user where name like '%${value}%';
                  -->
                
                
        </select>

 

注意：用未带%%的方式，传递参数时要自带%%号

//测试模糊查询
        @Test
        public void testfindUserByName() {
            
        List<User>    users=userDao.findUserByName("%o%");
        for(User user:users) {
            System.out.println(user);
        }
        }

示例三：获取刚插入的id

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

OGNL表达式

　object graphic navigation language(对象 图 导航 语言)

---

它是通过对象的取值方法来获取数据，在写法上把get省略了。

　　比如：类中获取：user.getUsername()

　　　　　　OGNL:user.username

 mybatis使用ognl表达式解析对象字段的值，#{}或者${}括号中的值未pojo属性名称

pojo:就是一个java bean实体对象

实例：

public class QueryVo {
    private User user;

    public User getUser() {
        return user;
    }

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

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

//测式使用queryvo
        @Test
        public void testfindUserByQueryVo() {
            QueryVo vo=new QueryVo();
            User user=new User();
            user.setName("%o%");
            vo.setUser(user);
        List<User>    users=userDao.findUserByVo(vo);
        for(User u:users) {
            System.out.println(u);
        }
        }

1，实体类的属性与数据库表的字段名称不同时：

注意：windows操作系统中的MySQL数据库不区分大小写，Linux系统区分大小写。

　　即username与userName等价

　　解决方法：sql语句中使用别名的方法，效率高

　　　　　　　　配置查询结果集的列名和实体类的属性名的对应关系，更加方便

public class TUser {
    @Override
    public String toString() {
        return "TUser [name=" + name + ", id=" +userId + ", pwd=" + pwd + ", userSchool=" + userSchool + "]";
    }
    String name;
    int userId;
    
    String pwd;
    String userSchool;
    
    public int getUserId() {
        return userId;
    }
    public void setUserId(int userId) {
        this.userId = userId;
    }
    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;
    }
    public String getUserSchool() {
        return userSchool;
    }
    public void setUserSchool(String userSchool) {
        this.userSchool = userSchool;
    }
}

对应的表结构：

id  username password school

<!-- 配置查询结果的列名给实体类的属性名的对应关系 -->
        <resultMap id="userMap" type="com.model.TUser">
        <!-- 主键对应的字段 -->
        <id property="userId" column="id"></id>
        <!-- 非主键对应的字段
        property=java类中的属性名    column=对应表的字段名
         -->
        <result property="name" column="username" ></result>
        <result property="pwd" column="password" ></result>
        <result property="userSchool" column="school" ></result>
        </resultMap>
        
        <!-- 查询所有 -->
        <select id="findTUsersAll" resultMap="userMap">
        select * from tb_user;
        </select>