mybatis学习小结

      MyBatis 是支持普通 SQL查询，存储过程和高级映射的优秀持久层框架。MyBatis 消除了几乎所有的JDBC代码和参数的手工设置以及结果集的检索。MyBatis 使用简单的 XML或注解用于配置和原始映射，将接口和 Java 的POJOs（Plain Old Java Objects，普通的 Java对象）映射成数据库中的记录。

 

jdbc源码：

<span style="font-size:18px;">public static voidmain(String[] args) {
        //数据库连接
        Connection connection = null;
        //预编译的Statement,使用预编译的Statement
        PreparedStatement preparedStatement =null;
        //结果集
        ResultSet resultSet = null;
       
        try {
            //加载数据库驱动
           Class.forName("com.mysql.jdbc.Driver");
           
            //通过驱动管理类获取数据库链接
            connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/test?characterEncoding=utf-8","root", "123");
            //定义sql语句 ?表示占位符
        String sql = "select * from userwhere username = ?";
            //获取预处理statement
            preparedStatement =connection.prepareStatement(sql);
            //设置参数，第一个参数为sql语句中参数的序号（从1开始），第二个参数为设置的参数值
            preparedStatement.setString(1,"王五");
            //向数据库发出sql执行查询，查询出结果集
            resultSet =  preparedStatement.executeQuery();
            //遍历查询结果集
            while(resultSet.next()){
               System.out.println(resultSet.getString("id")+" "+resultSet.getString("username"));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally{
            //释放资源
            if(resultSet!=null){
                try {
                    resultSet.close();
                } catch (SQLException e) {
                    // TODO Auto-generated catchblock
                    e.printStackTrace();
                }
            }
            if(preparedStatement!=null){
                try {
                    preparedStatement.close();
                } catch (SQLException e) {
                    // TODO Auto-generatedcatch block
                    e.printStackTrace();
                }
            }
            if(connection!=null){
                try {
                    connection.close();
                } catch (SQLException e) {
                    // TODO Auto-generatedcatch block
                    e.printStackTrace();
                }
            }
        }
    }</span>

原生态的jdbc程序中问题总结：

1、数据库连接，使用时就创建，不使用立即释放，对数据库进行频繁连接开启和关闭，造成数据库资源浪费，影响数据库性能。

设想：使用数据库连接池管理数据库连接。

 

2、将sql语句硬编码到java代码中，如果sql 语句修改，需要重新编译java代码，不利于系统维护。

设想：将sql语句配置在xml配置文件中，即使sql变化，不需要对java代码进行重新编译。

 

3、向preparedStatement中设置参数，对占位符号位置和设置参数值，硬编码在java代码中，不利于系统维护。

设想：将sql语句及占位符号和参数全部配置在xml中。

 

4、从resutSet中遍历结果集数据时，存在硬编码，将获取表的字段进行硬编码，，不利于系统维护。

设想：将查询的结果集，自动映射成java对象。

 

而mybatis

mybatis是一个持久层的框架，是apache下的顶级项目。

mybatis托管到goolecode下，再后来托管到github下(https://github.com/mybatis/mybatis-3/releases)。

 

mybatis让程序将主要精力放在sql上，通过mybatis提供的映射方式，自由灵活生成（半自动化，大部分需要程序员编写sql）满足需要sql语句。

 

mybatis可以将向 preparedStatement中的输入参数自动进行输入映射，将查询结果集灵活映射成java对象。（输出映射）

 

 在实践中的例子：

项目结构

 

 

SqlMapConfig.xml中配置文件：

 

<?xmlversion="1.0" encoding="UTF-8" ?>
<!DOCTYPEconfiguration
PUBLIC"-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <!-- 加载属性文件 -->
    <propertiesresource="db.properties"></properties>
   
    <typeAliases>
        <!--针对单个别名定义
        type:类型的路径
        alias:别名
       
         -->
         <typeAliastype="cn.itcast.mybatis.po.User" alias="user"/>
         <!-- 批量别名定义
         指定包名，mybatis自动扫描包中的po类，自动定义别名，别名就是类名（首字母大小写都可以）
          -->
          <packagename="cn.itcast.mybatis.po"/>
    </typeAliases>
   
   
    <!-- 和spring整合后 environments配置将废除-->
    <environmentsdefault="development">
        <environmentid="development">
        <!-- 使用jdbc事务管理-->
            <transactionManagertype="JDBC" />
        <!-- 数据库连接池-->
            <dataSourcetype="POOLED">
                <propertyname="driver" value="${jdbc.driver}" />
                <propertyname="url" value="${jdbc.url}" />
                <propertyname="username" value="${jdbc.username}" />
                <propertyname="password" value="${jdbc.password}" />
            </dataSource>
        </environment>
    </environments>
    <!-- 加载映射文件 -->
    <mappers>
        <mapper resource="sqlmap/User.xml"></mapper>
       
        <!-- <mapper resource="mapper/UserMapper.xml"></mapper> -->
       
        <!-- 通过mapper接口加载映射文件
        遵循一些规范：需要将mapper接口类名和mapper.xml映射文件名称保持一致，且在一个目录中
        上边规范的前提是：使用的是mapper代理方法
        -->
        <!-- <mapperclass="cn.itcast.mybatis.mapper.UserMapper"/> -->
        <!-- 批量加载 mapper
        指定mapper接口的包名，mybatis自动扫描包下边所有mapper接口进行加载
        遵循一些规范：需要将mapper接口类名和mapper.xml映射文件名称保持一致，且在一个目录中
        上边规范的前提是：使用的是mapper代理方法
        -->
        <packagename="cn.itcast.mybatis.mapper"/>
    </mappers>
</configuration>

UserMapper.xml

<span style="font-size:18px;"><?xmlversion="1.0" encoding="UTF-8" ?>
<!DOCTYPEmapper
PUBLIC"-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!-- namespace命名空间，作用就是对sql进行分类化管理，理解sql隔离
注意：使用mapper代理方法开发，namespace有特殊重要的作用
 -->
<mappernamespace="cn.itcast.mybatis.mapper.UserMapper">
    <!-- 定义sql片段
    id：slq片段的唯一标识
   
    经验：定义
     -->
    <sql id="query_user_where">
            <iftest="userCustom!=null">
                <iftest="userCustom.sex!=null and userCustom.sex!=''">
                     user.sex=#{userCustom.sex}
                </if>
                <iftest="userCustom.username!=null and userCustom.username!=''">
                     user.username LIKE'%${userCustom.username}%'
                </if>
            </if>
    </sql>
    <!-- 定义resultMap
    将SELECT id id_,username username_ From User 和User类中的属性作一个映射关系
    type:resultMap最终映射的java对象类型，可以使用别名
    id：对reslutMap的唯一标识
     -->
    <resultMap type="user"id="userResultMap">
        <!-- id表示查询结果中唯一标识
        column:查询出来的列名
        property:type指定的pojo类型中的属性名
        最终resultMap对column和property作一个映射关系（对应关系）
       
         -->
         <id column="id_" property= "id"/>
         <!--
         result:对普通名映射定义
         column：查询出来的列名
         property:type指定的pojo类型中的属性名
         最终resultMap对column和propety作一个映射关系（对应关系）
        
          -->
          <resultcolumn="username_" property ="username"/>
    </resultMap>
    <!-- 用户信息综合查询 -->
    <select id="findUserList"parameterType="cn.itcast.mybatis.po.UserQueryVo"
                             resultType="cn.itcast.mybatis.po.UserCustom">
        SELECT * FROM USER
        <!-- where可以自动去掉条件中的第一个and -->
        <where>
            <!-- 引用sql片段的id，如果refid指定的id不在本mapper文件中，需要前边加namespace -->
            <includerefid="query_user_where"></include>
            <!-- 在这里还要引用其它的sql片段 -->
            <iftest="ids!=null">
                <!-- 使用foreach遍历ids
                collection：指定输入对象中集合属性
                item：每个遍历生成对象中
                open：开始遍历时拼接的串
                close:结束遍历时拼接的串
                separator：遍历的两个对象中需要拼接的串
                 -->
                 <!-- 使用实现下边的sql拼接
                     AND (id=1 or id=10 orid=16)
                  -->
                  <foreach collection ="ids"item="user_id" open="AND (" separator="or">
                          <!-- 每个遍历需要拼接的串 -->
                          id=#{user_id}
                  </foreach>
            </if>
        </where>
       
       
    </select>
    <!-- 在映射文件中配置很多sql语句 -->
    <!-- 需求：通过id查询用户表的记录 -->
    <!-- 通过select执行数据库查询
    id：标识映射文件中的sql
    将sql语句封装到mappedStatement对象中，所以将id成为statement的id
    parameterType:指定输入参数的类型，这里指定int型
    #{}标识一个占位符
    #{id}其中id表示接受输入的参数，参数名称就是id，如果输入参数是简单类型，#{}中的参数名可以任意，可以value或者其他名称
   
    resultType:指定sql输出结果的所映射的java对象类型，select指定resultType表示将单记录映射成的java对象。
       
     -->
    <select id="findUserById"parameterType="int" resultType="user">
        SELECT * FROM User WHERE id=#{id}
    </select>
   
    <!-- 使用resultMap进行输出映射
    resultMap：指定定义的 resultMap的id，如果这个resultMap在其它的mapper文件，前边需要加namespace-->
    <selectid="findUserByIdResultMap" parameterType="int"resultMap="userResultMap">
        SELECT id id_,username username_ FROMUSER WHERE id=#{value}
    </select>
   
   
    <!-- 根据用户名称模糊查询用户信息，可能返回多条
    resultType:指定就是单挑记录所映射的java对象类型
    ${}:表示拼接sql串，将接收到参数的内容不加任何修饰拼接在sql中。
    使用${}拼接sql,引起sql注入
    ${value}:接收输入参数的内容，如果传入类型是简单类型，${}中只能使用value
    -->
    <select id="findUserByName"parameterType="java.lang.String" resultType ="cn.itcast.mybatis.po.User">
        SELECT * FROM User WHERE username LIKE'%${value}%'
    </select>
   
    <!-- 添加用户
    parameterType:指定输入参数类型是pojo(包括用户信息)
    #{}pojo的属性名，接收到pojo对象的属性值，mybatis通过OGNL获取对象的属性值
   
     -->
    <insert id ="insertUser"parameterType="cn.itcast.mybatis.po.User">
        <!-- 将插入数据的主键返回，返回到user对象中
       
        SELECT LAST_INSERT_ID():得到刚insert进去记录的主键值，只适用于自增主键
       
        keyproperty :将查询到主键值设置parameterType指定的对象的那个属性
        order:Select Last_insert_id()执行顺序，相对于insert语句来说它的执行顺序
         -->
        <selectKeykeyProperty="id" order="AFTER"resultType="java.lang.Integer">
             SELECT LAST_INSERT_ID()
        </selectKey>
        insert intouser(username,birthday,sex,address)value(#{username},#{birthday},#{sex},#{address})
    </insert>
   
    <!-- 删除用户
    根据id删除用户，需要数据id值
   
     -->
    <delete id ="deleteUser"parameterType="java.lang.Integer">
        delete from user where id =#{id}
    </delete>
   
    <!-- 根据id更新用户
    分析：
    需要传入用户的id
    需要传入用户的更新信息
    parameterType指定user对象，包括id和更新信息,注意：id必须存在
   
     -->
     <update id ="updateUser"parameterType="cn.itcast.mybatis.po.User">
         update user setusername=#{username},birthday=#{birthday},sex=#{sex},address=#{address} whereid=#{id}
     </update>
   
</mapper>
 </span>

程序代码：

 

        //根据id查询用户信息
    @Test
    public void testFindUserById() throwsException {
       
        SqlSession sqlSession =sqlSessionFactory.openSession();
       
        //創建UserDao對象，
        UserMapper userMapper =sqlSession.getMapper(UserMapper.class);
       
        //調用userMapper的方法
       
        User user = userMapper.findUserById(1);
       
        System.out.println(user);
    } 

总结：

在配置文件中书写sql语句时：

     parameterType:在映射文件中通过parameterType指定输入参数的类型。

     resultType:在映射文件中通过resultType指定输出结果的类型。

     #{}和${}

          #{}表示一个占位符号，#{}接收输入参数，类型可以是简单类型，pojo、hashmap。

          如果接收简单类型，#{}中可以写成value或其它名称。

          #{}接收pojo对象值，通过OGNL读取对象中的属性值，通过属性.属性.属性...的方式获取对象属性值。

 

          ${}表示一个拼接符号，会引用sql注入，所以不建议使用${}。

          ${}接收输入参数，类型可以是简单类型，pojo、hashmap。

          如果接收简单类型，${}中只能写成value。

          ${}接收pojo对象值，通过OGNL读取对象中的属性值，通过属性.属性.属性...的方式获取对象属性值。

 

selectOne和selectList

           selectOne表示查询出一条记录进行映射。如果使用selectOne可以实现使用selectList也可以实现（list中只有一个对象）。

         selectList表示查询出一个列表（多条记录）进行映射。如果使用selectList查询多条记录，不能使用selectOne。   

mybatis和hibernate本质区别和应用场景

hibernate：是一个标准ORM框架（对象关系映射）。入门门槛较高的，不需要程序写sql，sql语句自动生成了。

对sql语句进行优化、修改比较困难的。

应用场景：适用与需求变化不多的中小型项目，比如：后台管理系统，erp、orm、oa。。

 

mybatis：专注是sql本身，需要程序员自己编写sql语句，sql修改、优化比较方便。mybatis是一个不完全 的ORM框架，虽然程序员自己写sql，mybatis 也可以实现映射（输入映射、输出映射）。

应用场景：适用与需求变化较多的项目，比如：互联网项目。

 

       刚刚学习过mybatis，感觉很乱，先把知道的总结在这里，等进行项目开发后再来梳理思路。