Mybatis学习案例（1）

Mybatis

mybatis ORM框架
（1）和hibernate相比
1.hibernate功能完善 ， mybatis稍欠缺，例如在缓存方面
2.hibernate hql方言的支持，可以在任意数据库上生成对应的sql语句，移植性更强
mybatis因为是编写sql语句，所以移植性较差
3.hibernate全自动化面向对象的编程，mybatis半自动化，面向sql编程
4.mybatis开发效率较高

（2）开发流程

在mapper.xml文件中编写sql语句，同时让mapper的namespace映射接口的路径

1.DAO层接口中定义方法，但是不写具体注解来实现
2.定义Maaper文件，文件中的语句的数量对应着接口的方法的个数，并且语句的id和
方法名相同
3.Mapper文件的namespace指向接口的路径
4.在核心配置中注册Mapper文件路径就可以
5.使用的时候还是getMapper（接口.class） 还是使用接口，符合开发的思想

（3）Mybatis在IDEA中的创建案例

1.IDEA先创建一个java项目，
2.导入依赖pom.xml，
3.创建java目录Mark为Sources Root,里面写java代码
4.main下同级创建resources目录Mark为Resources Root，里面存放配置文件。
　　mybatis.cfg.xml　　Mybatis的配置文件
　　jdbc.properties　　连接池中数据库的配置
　　resources中创建mappers文件，里面存放XXXMapper.xml文件
5.test文件夹下为测试类

如图文件：

 pom.xml中主要依赖：

<dependencies>


    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>


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

    <!-- JDBC JAR -->
    <dependency>
      <groupId>com.oracle</groupId>
      <artifactId>ojdbc6</artifactId>
      <version>1.0</version>
    </dependency>


  </dependencies>

　Mybatis的配置文件：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 resource="jdbc.properties"></properties>
    <settings>
        <setting name="logImpl" value="STDOUT_LOGGING" />
        <!--启用延迟加载-->
        <setting name="lazyLoadingEnabled" value="true"/>
        <!--cacheEnabled 启用二级缓存-->
        <setting name="cacheEnabled" value="true"></setting>
    </settings>

    <!--别名-->
    <typeAliases>
        <!--单个类别名
        <typeAlias type="com.seecen.Student" alias="student"></typeAlias>
        -->
        <!--该包下所有的类可以直接使用类名做为别名-->
        <package name="com.seecen"/>
    </typeAliases>

    <!--配置环境-->
    <environments default="development">
        <environment id="development">
            <!--jdbc事务-->
            <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>
    </environments>

    <mappers>
        <!--<mapper resource="mappers/studentMapper.xml"></mapper>
        &lt;!&ndash;需要给接口注册&ndash;&gt;
        <mapper class="com.seecen.StudentDao"></mapper>-->

        <mapper resource="mappers/empMapper.xml"></mapper>
        <mapper resource="mappers/deptMapper.xml"></mapper>
    </mappers>


</configuration>

oracle数据库连接池的配置：jdbc.properties

url=jdbc:oracle:thin:@localhost:1521:orcl
driver=oracle.jdbc.driver.OracleDriver
username=sc1812
password=sc1812

 编写XXXMapper.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.seecen.EmpDao">

    <select id="listEmp" resultMap="empResultMap">
        select * from emp
    </select>
    <!--
        解决属性名和字段名不同的情况
        用来复杂的对象关系映射的查询
        id 唯一
        type  就是指这个resultMap的结果类型
    -->
    <resultMap id="empResultMap" type="Emp">
        <id property="empNo" column="EMPNO"></id>
        <result property="ename" column="ENAME"/>
        <result property="job" column="JOB"/>
        <result property="hiredate" column="HIREDATE"/>
        <result property="sal" column="SAL"/>
        <result property="comm" column="COMM"/>
        <result property="mgr" column="MGR"/>

        <!--
            在关系映射中，所关联的另一张表的数据被封装在对象中，而这个对象
            的属性都写在这里
            property
            column 指关联表在当前表中的外键
            javaType 指关联的这个对象的类型-->
             <!--<association property="dept" column="DEPTNO" javaType="Dept">
            <id property="deptNo" column="DEPTNO" ></id>
            <result property="dname" column="DNAME"></result>
            <result property="loc" column="LOC"></result>
        </association>-->

        <!--使用另一条查询语句的结果来使用
            DEPTNO 这个时候还有另一个用途，用来把该列的值传递给对应的select语句做为参数
        -->
        <association property="dept" column="DEPTNO"
                     select="com.seecen.DeptDao.getDept">
        </association>
    </resultMap>

    <select id="listEmpByDept" resultMap="empResultMap">
        select * from emp where deptno = #{param1}
    </select>

    <select id="getEmp" resultType="Emp">
        select * from emp where empno = #{param1} or sal = #{param2}
    </select>

    <insert id="insertEmp">
        <![CDATA[
        insert into emp values(#{id},#{name},#{job},#{mgr},to_date(#{hiredate},'yyyy-mm-dd'),#{sal},#{comm},#{deptno})
      ]]>
    </insert>

    <!--模糊查询-->
    <select id="listEmpByName"  resultMap="empResultMap">
        select * from emp
       <!-- <where>
            <if test="arg0!='%%'">
               and   ename like #{param1}
            </if>
            <if test="arg1!=0">
               and   deptno = #{param2}
            </if>
        </where>-->
        <trim prefix="where" prefixOverrides="and | or">
            <if test="arg0!='%%'">
                and   ename like #{param1}
            </if>
            <if test="arg1!=0">
                and   deptno = #{param2}
            </if>
        </trim>
    </select>

    <update id="updateEmp" parameterType="Emp">
      update emp
      <set>
        <!--<if test="ename!='' and ename!=null">
              ENAME = #{ename},
          </if>
          <if test="job!='' and job!=null">
              JOB = #{job},
          </if>-->
      </set>
      where EMPNO = #{empNo}
    </update>

    <select id="listEmpIn" resultMap="empResultMap">
        select * from emp  where empno in
        <!--
            collection:表示要遍历的数据的类型，array，list等
            item : 表示每次迭代的一个数据的别名
        -->
        <foreach collection="array" item="id" open="(" close=")"
                  separator="," >
          #{id}
        </foreach>
    </select>

    <insert id="batchInsert" parameterType="list">
        insert all
        <foreach collection="list" item="e" separator=" ">
             into EMP (EMPNO,ENAME,JOB,MGR,SAL,COMM,HIREDATE,DEPTNO)
            values
            (
            #{e.empNo},
            #{e.ename},
            #{e.job},
            #{e.mgr},
            #{e.sal},
            #{e.comm},
            to_date(#{e.hiredate},'yyyy-MM-dd'),
            #{e.dept.deptNo}
            )
        </foreach>
        select  1 from dual
    </insert>

</mapper>

根据数据库编写实体类

测试类：

package com.seecen;

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.IOException;
import java.io.InputStream;
import java.util.List;

/**
 * Hello world!
 *
 */
public class App 
{
    public static void main( String[] args ) throws IOException {

        //读取核心配置文件
        InputStream inputStream = Resources.getResourceAsStream("mybatis.cfg.xml");

        SqlSessionFactory sqlSessionFactory=new SqlSessionFactoryBuilder().build(inputStream);

        SqlSession sqlSession  = sqlSessionFactory.openSession();
        //mapper的namespace+语句的id
        List<Student> list = sqlSession.selectList("com.seecen.StudentMapper.listStudent");

        for (Student student : list) {
            System.out.println(student.getStuName());
        }



    }
}

一、mybatis整体架构设计分为三层：API接口层、数据处理层、基础支持层。

1. API接口层：提供外部使用接口的API，通过提供的API操作数据库。接口层收到调用参数后就会将这些参数作为入参数调用数据处理层来完成具体的数据处理。
2. 数据处理层：接收到接口层的参数，具体负责对SQL的查找，解析，执行和执行结果的映射处理，完成对数据库的操作。
3. 基础支持层：负责最基础且公用的功能支持，包括数据库连接管理、事务管理、配置加载和缓存处理。这些功能抽取出来作为基础功能，为上层的数据处理层提供最基础的支撑。

二、mybatis整个调用执行过程：

1. 加载配置并初始化：即mybatis主配置文件，mapper配置文件及注解配置。其中将SQL配置的信息加载为一个个MapperStatement对象（传入参数映射配置、执行的SQL语句、结果映射配置）。
2. 接收调用请求：接收到传入的参数和需要执行的SQL的ID，将请求传递给下层的数据处理层进行处理。
3. 处理操作请求：执行器Executor处理接收到接口层传递的SQL的ID和传入参数，根据ID查找对应的MapperStatement，解析MapperStatement对象，得到需要执行的SQL语句并注入传入的参数。获取到数据库连接，将最终的SQL语句到数据库执行，并得到结果。根据MapperStatement对象中的结果映射配置对得到的结果进行转换处理，得到最终的结果。最后释放资源并返回结果到上层。

精讲#{}和${}的区别是什么？

#{}是预编译处理，${}是字符串替换。

（1）mybatis在处理#{}时，会将sql中的#{}替换为?号，调用PreparedStatement的set方法来赋值。

（2）mybatis在处理${}时，就是把${}替换成变量的值。

（3）使用#{}可以有效的防止SQL注入，提高系统安全性。原因在于：预编译机制。预编译完成之后，SQL的结构已经固定，即便用户输入非法参数，也不会对SQL的结构产生影响，从而避免了潜在的安全风险。

（4）预编译是提前对SQL语句进行预编译，而其后注入的参数将不会再进行SQL编译。我们知道，SQL注入是发生在编译的过程中，因为恶意注入了某些特殊字符，最后被编译成了恶意的执行操作。而预编译机制则可以很好的防止SQL注入。

最后，补充一点：

$符号一般用来当作占位符，常使用Linux脚本的人应该对此有更深的体会吧。例如：$1，$2等等表示输入参数的占位符。知道了这点就能很容易区分$和#，从而不容易记错了。