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

<configuration>
    <!--
    属性
    属性文件或property标签都能设置,一般就在属性文件里好了
    -->
    <properties resource="myBatisConf.properties">
        <property name="driverClass" value="com.mysql.jdbc.Driver"/>
    </properties>

    <!--设置MyBatis的运行方式-->
    <settings>
        <!--日志框架-->
        <setting name="logImpl" value="LOG4J2"/>
        <!--超时时间-->
        <setting name="defaultStatementTimeout" value="50000"/>
    </settings>

    <!--别名-->
    <typeAliases>
        <!--除了可以自己定义别名外,MyBatis内部对常用类型也有别名 主要就是 map  hashmap等-->
        <typeAlias alias="AcReport" type="org.zln.domain.AcReport" />
        <typeAlias alias="StudCard" type="org.zln.domain.StudCard" />
        <typeAlias alias="Student" type="org.zln.domain.Student" />
        <typeAlias alias="Teacher" type="org.zln.domain.Teacher" />
    </typeAliases>

    <!--类型处理器 用于数据库数据类型和Java数据类型的转化一般不需要自己重写
    要重写的话,实现 TypeHandler 接口
    -->
    <!--<typeHandlers>-->
        <!--<typeHandler handler="" jdbcType="" javaType=""/>-->
    <!--</typeHandlers>-->

    <!--对象工厂
    每次创建结果对象新的实例的时候回用到 可以通过集成 DefaultObjectFactory 来自己重写
    -->
    <!--<objectFactory type=""></objectFactory>-->

    <!--MyBatis 允许你在某一点拦截已映射语句执行的调用。默认情况下,MyBatis 允许使用 插件来拦截方法调用-->
    <!--<plugins>-->
        <!--<plugin interceptor=""></plugin>-->
    <!--</plugins>-->

    <!--环境-->
    <environments default="development">
        <!--环境变量 可以配置多个,要用哪个,由 environments 决定-->
        <environment id="development">
            <!--事务管理器  JDBC或MANAGED
            JDBC:直接简单使用了 JDBC 的提交和回滚设置。它依赖于从数据源得到的连接来管理事务范围。
            MANAGED:它从来不提交或回滚一个连接。而它会让
容器来管理事务的整个生命周期(比如 Spring 或 JEE 应用服务器的上下文)。默认 情况下它会关闭连接。然而一些容器并不希望这样,因此如果你需要从连接中停止 它,将 closeConnection 属性设置为 false。例如:
<transactionManager type="MANAGED">
    <property name="closeConnection" value="false"/>
</transactionManager>
            -->
            <transactionManager type="JDBC" />
            <!--数据源  type指明了数据源类型

            UNPOOLED    这个数据源的实现是每次被请求时简单打开和关闭连接。它有一点慢,这是对简单应用程序的一个很好的选择,因为它不需要及时的可用连接。不同的数据库对这 个的表现也是不一样的,所以对某些数据库来说配置数据源并不重要,这个配置也是闲置的
            POOLED  这是 JDBC 连接对象的数据源连接池的实现,用来避免创建新的连接实例 时必要的初始连接和认证时间。这是一种当前 Web 应用程序用来快速响应请求很流行的方法。
            JNDI

            不同type类型支持的配置属性是不一样的
            -->
            <dataSource type="POOLED">
                <property name="driver" value="${driverClass}" />
                <property name="url" value="${url}" />
                <property name="username" value="${username}" />
                <property name="password" value="${password}" />
            </dataSource>
        </environment>
    </environments>

    <!--配置映射文件-->
    <mappers>
        <mapper resource="org/zln/mapper/AcReportMapper.xml" />
        <mapper resource="org/zln/mapper/StudCardMapper.xml" />
        <mapper resource="org/zln/mapper/StudentMapper.xml" />
        <mapper resource="org/zln/mapper/TeacherMapper.xml" />
    </mappers>
</configuration>

• 初始化

package org.zln.utils;

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.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

import java.io.IOException;

/**
 * Created by sherry on 16/7/15.
 */
public class DBAccess {

    private static Logger logger = LogManager.getLogger(DBAccess.class);

    private static final String myBatisConfStr = "mybatis-config.xml";
    private static SqlSessionFactory sqlSessionFactory;
    static {
        try {
            /**
             * SqlSessionFactoryBuilder 一旦实例化出SqlSessionFactory后就没用了
             * SqlSessionFactory    其生命周期应该是整个应用,因为要不停从中获获取SqlSession 最好的方式就是使用Spring容器,哪里使用哪里注入
             */
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsReader(myBatisConfStr));
        } catch (IOException e) {
            logger.error(e.getMessage(),e);
        }
    }

    public static SqlSession getSqlSession() throws IOException {
        /**
         * SQLSession
         * 每个线程都该有自己的SqlSession实例,它是线程不安全的,不能共享使用.所以SqlSession得最佳范围就应该是方法内,哪里使用哪里创建,创建完立马销毁
         * 如果SqlSession如果被Spring管理,使用SqlSessionTemplate,则不需要,也不能人工close,具体原因百度:SqlSessionTemplate是否需要close
         */
        return sqlSessionFactory.openSession();
    }
}

• 映射文件

<?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="org.zln.mapper.StudentMapper">

    <!--配置给定命名空间的缓存-->
    <!--<cache></cache>-->

    <!--从其他命名空间引用缓存配置-->
    <!--<cache-ref namespace=""/>-->

    <!--结果集映射-->
    <resultMap id="StudentResultMap" type="Student">
        <id property="studId" column="stud_id" jdbcType="INTEGER"/>
        <result property="name" column="name" jdbcType="VARCHAR"/>
        <result property="email" column="email" jdbcType="VARCHAR"/>
        <result property="dob" column="dob" jdbcType="DATE"/>
    </resultMap>

    <!--可重用的SQL片段-->
    <sql id="selectStudents">
        SELECT stud_id,name,email,dob
    </sql>


    <select id="findAllStudents" resultMap="StudentResultMap">
        <include refid="selectStudents"/>
        FROM Student
    </select>
    <!--
    select详解
        id:查询id,如果使用Mapper形式编写,那么id值就是Mapper接口的方法名
        parameterType:参数类型,一般就是一个pojo对象 或者 基本数据类型 或者 map 等
        resultType:结果集映射类型
        resultMap:结果集映射类型
        flushCache:默认false,如果为true:无论语句何时被调用,都会导致缓存情况
        timeout:超时时间
        fetchSize:默认由驱动决定,每次批量返回的行数
        statementType:STATEMENT,PREPARED 或 CALLABLE 的一种。这会让 MyBatis 使用选择使用 Statement,PreparedStatement 或 CallableStatement。 默认值:PREPARED。
        resultSetType:FORWARD_ONLY|SCROLL_SENSITIVE|SCROLL_INSENSITIVE中的一种。默认是不设置(驱动自行处理)。
    -->
    <!--
    #{property,javaType=int,jdbcType=NUMERIC},用这种方式来指定参数类型,一般如果是pojo,MyBatis是能够自动获取的
    和iBatis一样,也有
    ${} 这种写法,一般用于 order by
    -->
    <!--
    一对一映射:在resultMap中配置association
    一对多映射:配置collection
    -->

    <!--
    缓存:默认情况没开启缓存
    SQL映射文件中加上 <cache/> 就会开启二级缓存
    -->


    <!--
    if标签 where标签 trim标签

    <select id="selectBySelective" resultType="xxx.UserInfo">
        select
        <include refid="Base_Column_List"/>
        from uc_user
        <where>
            (
            <if test="userName != null">
                user_name = #{userName}
            </if>
            <if test="email != null">
                or email = #{email}
            </if>
            <if test="phone != null">
                or phone = #{phone}
            </if>
            <if test="weiboId != null">
                or weibo_id = #{weiboId}
            </if>
            <if test="wxId != null">
                or wx_id = #{wxId}
            </if>
            <if test="qqId != null">
                or qq_id = #{qqId}
            </if>)
        </where>
        and status = 1
    </select>
    这样代码看似没有什么问题但是其实是有问题的。为什么呢？
    如果userName 为空，后面某字段不为空，最后的sql语言会成为这样：
    select * from uc_user where(or email = "xxx") and status = 1

    使用mybatis < where > 标签就是为了防止这种情况，mybatis会在第一个
userName 为空的情况下，帮我们去掉后面的语句的第一个”or”

但是我加了where标签中加入（）后，语句会报错。因为自动去掉”or”会失效。

查看了mybatis官方文档发现了另一个标签 < trim >可以通过自定义 trim 元素来定制我们想要的功能

trim标签包围的内容可以设置几个属性：
prefix ：内容之前加的前缀
suffix ：内容之后加的后缀
prefixOverrides： 属性会忽略通过管道分隔的文本序列（注意此例中的空格也是必要的，多个忽略序列用“|”隔开）。它带来的结果就是所有在 prefixOverrides 属性中指定的内容将被移除。


-->
    <!--
    <select id="selectBySelective" resultType="xxx.UserInfo">
        select
        <include refid="Base_Column_List"/>
        from uc_user
        <trim prefix="WHERE (" suffix=")" prefixOverrides="AND |OR ">
            <if test="userName != null">
                user_name = #{userName}
            </if>
            <if test="email != null">
                or email = #{email}
            </if>
            <if test="phone != null">
                or phone = #{phone}
            </if>
            <if test="weiboId != null">
                or weibo_id = #{weiboId}
            </if>
            <if test="wxId != null">
                or wx_id = #{wxId}
            </if>
            <if test="qqId != null">
                or qq_id = #{qqId}
            </if>
        </trim>
        and status = 1
    </select>
-->

    <!--choose  when  -->
    <!--
    <select id="getStudentListChooseEntity" parameterType="StudentEntity" resultMap="studentResultMap">
        SELECT * from STUDENT_TBL ST
        <where>
            <choose>
                <when test="studentName!=null and studentName!='' ">
                    ST.STUDENT_NAME LIKE CONCAT(CONCAT('%', #{studentName}),'%')
                </when>
                <when test="studentSex!= null and studentSex!= '' ">
                    AND ST.STUDENT_SEX = #{studentSex}
                </when>
                <when test="studentBirthday!=null">
                    AND ST.STUDENT_BIRTHDAY = #{studentBirthday}
                </when>
                <when test="classEntity!=null and classEntity.classID !=null and classEntity.classID!='' ">
                    AND ST.CLASS_ID = #{classEntity.classID}
                </when>
                <otherwise>

                </otherwise>
            </choose>
        </where>
    </select>
    -->

    <!--foreach 循环标签-->
    <!--
    <select id="getStudentListByClassIDs" resultMap="studentResultMap">
        SELECT * FROM STUDENT_TBL ST
        WHERE ST.CLASS_ID IN
        <foreach collection="list" item="classList"  open="(" separator="," close=")">
            #{classList}
        </foreach>
    </select>
    -->


    <!--SET 更新-->
    <!--
    <update id="updateUserInfoBySet" parameterType="userInfo">
        update userInfo
        <set>
            <if test="mobile!=null">
                mobile=#{mobile},
            </if>
            <if test="gender!=null">
                gender=#{gender},
            </if>
            <if test="position!=null">
                position = #{position},
            </if>
        </set>
        where userid=#{userid}
    </update>
    a.SQL语句的set被<set>标签替代。
    b.每个<if>中语句最后都带有逗号，如果有写过SQL语句的同学就一定知道，最后的逗号是不能有的，因此，这里的<set>标签能够帮助我们自动的移除最后一个<if>中的逗号。
    c.<trim>是一个非常强大的标签，因此，我们也可以通过<trim>来实现<set>的功能，如下：【这种写法的运行效果与<set>等价】
    -->
    <!--
    <update id="updateUserInfoBySet" parameterType="userInfo">
        update userInfo
        <trim prefix="SET" suffixOverrides=",">
            <if test="mobile!=null">
                mobile=#{mobile},
            </if>
            <if test="gender!=null">
                gender=#{gender},
            </if>
            <if test="position!=null">
                position = #{position},
            </if>
        </trim>
        where userid=#{userid}
    </update>
    -->
</mapper>

Mapp接口

package org.zln.mapper;

import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Select;
import org.zln.domain.Student;

import java.util.List;

/**
 * Created by sherry on 16/7/15.
 * Student的Mapper接口
 */
public interface StudentMapper {

    List<Student> findAllStudents();

    @Select("SELECT stud_id AS studId, name, email, dob FROM Student WHERE STUD_ID=#{Id}")
    Student findStudentById(Integer id);

    @Insert("INSERT INTO Student(stud_id,name,email,dob) VALUES(#{studId},#{name},#{email},#{dob})")
    void insertStudent(Student student);

}

Dao

package org.zln.dao;

import java.io.IOException;
import java.util.List;
import org.apache.ibatis.session.SqlSession;
import org.zln.domain.Student;
import org.zln.mapper.StudentMapper;
import org.zln.utils.DBAccess;

/**
 * Created by sherry on 16/7/15.
 */
public class StudentDao {

    public List<Student> findAllStudents() throws IOException {
        SqlSession sqlSession = DBAccess.getSqlSession();
        try{
            StudentMapper studentMapper = sqlSession.getMapper(StudentMapper.class);
            return studentMapper.findAllStudents();
        } finally{
            sqlSession.close();
        }
    }
    public Student findStudentById(Integer studId) throws IOException {
        SqlSession sqlSession = DBAccess.getSqlSession();
        try {
            StudentMapper studentMapper = sqlSession.getMapper(StudentMapper.class);
            return studentMapper.findStudentById(studId);
        } finally {
            sqlSession.close();
        }
    }
    public void createStudent(Student student) throws IOException {
        SqlSession sqlSession = DBAccess.getSqlSession();
        try {
            StudentMapper studentMapper = sqlSession.getMapper(StudentMapper.class);
            studentMapper.insertStudent(student);
            sqlSession.commit();
        }finally{
            sqlSession.close();
        }
    }




}

与Spring集成

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-4.1.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context-4.1.xsd
       http://www.springframework.org/schema/tx
       http://www.springframework.org/schema/tx/spring-tx-4.1.xsd">


    <context:component-scan base-package="org" resource-pattern="**/*Dao.class"/>
    <context:component-scan base-package="org" resource-pattern="**/*Service.class"/>

    <!--开启注解注入-->
    <context:annotation-config/>

    <bean class="org.zln.utils.des.EncryptPropertyPlaceholderConfigurer"
          p:location="classpath:db.properties"
          p:fileEncoding="UTF-8"/>
    <!--配置数据源-->
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close"
          p:driverClassName="com.mysql.jdbc.Driver"
          p:url="jdbc:mysql://localhost:3306/zln?useSSL=false"
          p:username="${username}"
          p:password="${password}"/>

    <!--JDBC模板类-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"
          p:dataSource-ref="dataSource"/>
    <!--MyBatis配置-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"
          p:dataSource-ref="dataSource"
          p:configLocation="classpath:myBatisConf.xml"
          p:mapperLocations="classpath:**/mapper/*Mapper.xml"/>
    <!--扫描Mapper类-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer"
          p:basePackage="org.zln" />
    <!--sqlSessionTemplate-->
    <bean id="sqlSessionTemplate" class="org.mybatis.spring.SqlSessionTemplate">
        <constructor-arg ref="sqlSessionFactory"/>
    </bean>


    <!--事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"
          p:dataSource-ref="dataSource"/>

    <!--使用注解配置事务-->
    <tx:annotation-driven transaction-manager="transactionManager"/>

</beans>

与Spring集成后的Dao

package org.zln.myWeb.dao;

import org.mybatis.spring.SqlSessionTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
import org.zln.myWeb.domain.T00_User;
import org.zln.myWeb.mapper.T00_UserMapper;

/**
 * Created by sherry on 16/8/6.
 */
@Repository
public class T00_UserDao {

    @Autowired
    private SqlSessionTemplate sqlSessionTemplate;

    public T00_User getT00_UserById(Integer id){
        T00_UserMapper t00_userMapper = sqlSessionTemplate.getMapper(T00_UserMapper.class);
        return t00_userMapper.getT00_UserById(id);
    }
}