MyBatis学习笔记

什么是Mybatis？     

mybatis是一个持久层框架, 作用是跟数据库交互完成增删改查。

Mybatis是一个半ORM（对象关系映射）框架，它内部封装了JDBC，开发时只需要关注SQL语句本身，不需要花费精力去处理加载驱动、创建连接、创建statement等繁杂的过程。程序员直接编写原生态sql，可以严格控制sql执行性能，灵活度高。

MyBatis 可以使用 XML 或注解来配置和映射原生信息，将 POJO映射成数据库中的记录，避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。

Mybatis通过xml或注解的方式将要执行的各种statement（statement、preparedStatement、CallableStatement）配置起来，并通过java对象和statement中的sql进行映射生成最终执行的sql语句，最后由mybatis框架执行sql并将结果映射成java对象并返回。

hibernate和mybatis区别:   

hibernate:它是一个标准的orm框架,比较重量级,学习成本高.

  • 优点:高度封装,使用起来不用写sql,开发的时候,会减低开发周期.
  • 缺点:sql语句无法优化
  • 应用场景:oa(办公自动化系统), erp(企业的流程系统)等,还有一些政府项目,

       总的来说,在用于量不大,并发量小的时候使用.

mybatis:它不是一个orm框架, 它是对jdbc的轻量级封装, 学习成本低,比较简单

  • 优点:学习成本低, sql语句可以优化, 执行效率高,速度快
  • 缺点:编码量较大,会拖慢开发周期
  • 应用场景: 互联网项目,比如电商,P2p等

      总的来说是用户量较大,并发高的项目.

                                                                                                                                                                                                                 

1.使用JDBC编程问题总结

JDBC编程步骤：

  1. 加载数据库驱动；                     
  2. 创建并获取数据库连接；           
  3. 创建JDBC statement操作对象；
  4. 定义sql语句；
  5. 设置sql语句中的参数(使用preparedStatement)；
  6. 通过statement执行sql并获取结果；    
  7. 对sql执行结果进行解析处理；
  8. 释放资源(resultSet、preparedstatement、connection)。

代码：（使用jdbc的原始方法（未经封装）实现查询数据库表记录）：

public static void main(String[] args) {
            Connection connection = null;
            PreparedStatement preparedStatement = null;
            ResultSet resultSet = null;
            
            try {
                //加载数据库驱动
                Class.forName("com.mysql.jdbc.Driver");
                
                //通过驱动管理类获取数据库链接
                connection =  DriverManager.getConnection("jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8", "root", "root");

                //定义sql语句 ?表示占位符
            String sql = "select * from user where 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) {
                        e.printStackTrace();
                    }
                }
                if(preparedStatement!=null){
                    try {
                        preparedStatement.close();
                    } catch (SQLException e) {
                        e.printStackTrace();
                    }
                }
                if(connection!=null){
                    try {
                        connection.close();
                    } catch (SQLException e) {
                        e.printStackTrace();
                    }
                }
            }
        }

JDBC问题总结：

  • 数据库链接创建、释放频繁造成系统资源浪费；      （使用数据库链接池可解决此问题） 

               MyBatis解决：在SqlMapConfig.xml中配置数据库连接接池，使用连接池管理数据库链接

  • Sql语句在代码中硬编码，造成代码不易维护；         （sql变动需要改变java代码）

　　　　MyBatis解决：将Sql语句配置在XXXXmapper.xml文件中与java代码分离

  • 使用preparedStatement向占有位符号传参数存在硬编码，修改sql还要修改代码，系统不易维护；

　　　　MyBatis解决：Mybatis自动将java对象映射至sql语句，通过statement中的parameterType定义输入参数的类型

  • 对结果集解析存在硬编码，sql变化导致解析代码变化，系统不易维护。   （如果能将数据库记录封装成pojo对象解析比较方便）

 　　　   MyBatis解决：Mybatis自动将sql执行结果映射至java对象，通过statement中的resultType定义输出结果的类型

2.Mybatis架构

1.mybatis配置文件： 

（1）核心配置文件：SqlMapConfig.xml，是mybatis的全局配置文件，配置了mybatis的运行环境等信息。

（2）sql映射文件：mapper.xml，配置了操作数据库的sql语句。此文件需要在SqlMapConfig.xml中加载。

 2.SqlSessionFactory（会话工厂）加载核心配置文件的内容，通过这些内容创建会话SqlSession，然后用会话里的方法来调用映射文件里的sql语句。即：

  • 通过mybatis环境等配置信息构造SqlSessionFactory即会话工厂；
  • 由会话工厂创建sqlSession即会话，操作数据库需要通过sqlSession进行。

 3.Executor和Mapped Statement在mybatis内部调用。

  • mybatis底层自定义了Executor执行器接口操作数据库；
  • Mapped Statement包装了mybatis配置信息及sql映射信息等。mapper.xml文件中一个sql对应一个Mapped Statement对象，sql的id即是Mapped statement的id。

    1、  Mapped Statement抽取xml的内容，对映射文件里的sql语句、输入参数类型、输出参数类型封装成Java对象。

　　   2、Executor通过Mapped Statement在执行sql前将输入的java对象映射至sql中，输入参数映射就是jdbc编程中对preparedStatement设置参数；

                Executor通过Mapped Statement在执行sql后将输出结果映射至java对象中，输出结果映射过程相当于jdbc编程中对结果的解析处理过程

 3.例子 ：

例：在映射文件User.xml编写几个sql语句：

<!-- namespace:命名空间,做sql隔离 -->
<mapper namespace="test">

    <!-- 
    　　id:sql语句唯一标识
    　　parameterType:指定传入参数类型
    　　resultType:返回结果集类型
    　　#{}占位符:起到占位作用,如果传入的是基本类型(string,long,double,int,boolean,float等),那么#{}中的变量名称可以随意写.
     -->
    <select id="findUserById" parameterType="java.lang.Integer" resultType="cn.ztt.pojo.User">
        select * from user where id=#{id}
    </select>
    
    <!-- 
    　　如果返回结果为集合,可以调用selectList方法,这个方法返回的结果就是一个集合,所以映射文件中应该配置成集合泛型的类型
    　　${}拼接符:字符串原样拼接,如果传入的参数是基本类型(string,long,double,int,boolean,float等),那么${}中的变量名称必须是value
    　　注意:拼接符有sql注入的风险,所以慎重使用
     -->
    <select id="findUserByUserName" parameterType="java.lang.String" resultType="cn.ztt.pojo.User">
        select * from user where username like '%${value}%'
    </select>
    
    <!-- 
    　　#{}:如果传入的是pojo类型,那么#{}中的变量名称必须是pojo中对应的属性.属性.属性.....
    　　如果要返回数据库自增主键:可以使用select LAST_INSERT_ID()
     -->
    <insert id="insertUser" parameterType="cn.ztt.pojo.User" >
        <!-- selectKey将主键返回，需要再返回。   执行 select LAST_INSERT_ID()数据库函数,返回自增的主键
        　　keyProperty:将返回的主键放入传入参数的Id中保存.
       　　 order:当前函数相对于insert语句的执行顺序,在insert前执行是before,在insert后执行是AFTER
        　　resultType:id的类型,也就是keyproperties中属性的类型
        -->
        <selectKey keyProperty="id" order="AFTER" resultType="java.lang.Integer">
            select LAST_INSERT_ID()
        </selectKey>
        insert into user (username,birthday,sex,address) values(#{username},#{birthday},#{sex},#{address})
    </insert>
    
    <delete id="delUserById" parameterType="int">
        delete from user where id=#{id}
    </delete>
    
    <update id="updateUserById" parameterType="cn.itcast.pojo.User">
        update user set username=#{username} where id=#{id}
    </update>
</mapper>

注意mybatis框架需要加载映射文件，要将Users.xml添加在核心配置文件SqlMapConfig.xml中：

<mappers>
        <mapper resource="User.xml"/>
</mappers>

 测试程序：

public class Mybatis_Test {
    
    //会话工厂
    private SqlSessionFactory sqlSessionFactory;

    @Before
    public void createSqlSessionFactory() throws IOException {
        // 配置文件
        String resource = "SqlMapConfig.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        // 使用SqlSessionFactoryBuilder从xml配置文件中创建SqlSessionFactory
        sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
    }


    // 根据用户id查询用户信息
    @Test
    public void testFindUserById() {
        SqlSession sqlSession = null;
        try {
            // 创建数据库会话实例sqlSession
            sqlSession = sqlSessionFactory.openSession();

            // 查询单个记录，根据用户id查询用户信息
            User user = sqlSession.selectOne("test.findUserById", 10);

            // 输出用户信息
            System.out.println(user);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (sqlSession != null) {
                sqlSession.close();
            }
        }
    }


    // 根据用户名称模糊查询用户信息
    @Test
    public void testFindUserByUsername() {
        SqlSession sqlSession = null;
        try {
            sqlSession = sqlSessionFactory.openSession();

            // 查询多个记录，根据用户名模糊查询用户信息
            List<User> list = sqlSession.selectList("test.findUserByUsername", "张");

            System.out.println(list.size());
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (sqlSession != null) {
                sqlSession.close();
            }
        }
    }

}

 4.小结 ：#{}和${}、parameterType和resultType、selectOne和selectList

 （1）#{}和${}

 　#{}  ：是一个占位符，通过#{}可以实现preparedStatement向占位符中设置值，自动进行java类型和jdbc类型转换，#{}可以有效防止sql注入。 #{}可以接收简单类型值或pojo属性值。

  • 如果传入的是基本类型,那么#{}中的变量名称可以随意写；
  • 如果传入的参数是pojo类型,那么#{}中的变量名称必须是pojo中的属性.属性.属性...

     ${}  ：是一个拼接符，表示拼接sql串，通过${}可以将parameterType 传入的内容拼接在sql中且不进行jdbc类型转换， ${}可以接收简单类型值或pojo属性值。

  • 如果传入的是基本类型,那么${}中的变量名必须是value；
  • 如果传入的参数是pojo类型,那么${}中的变量名称必须是pojo中的属性.属性.属性...

     注意：使用拼接符有可能造成sql注入,在页面输入的时候可以加入校验,不可输入sql关键字,不可输入空格。

（2）parameterType和resultType

　　parameterType：指定输入参数类型，mybatis通过ognl从输入对象中获取参数值拼接在sql中。

　　resultType：指定输出结果类型，mybatis将sql查询结果的一行记录数据映射为resultType指定类型的对象。

（3）selectOne和selectList

　　selectOne ：查询一条记录，如果使用selectOne查询多条记录则抛出异常：org.apache.ibatis.exceptions.TooManyResultsException

　　selectList：可以查询一条或多条记录。

5.Dao开发方法

 使用Mybatis开发Dao，通常有两个方法，即原始Dao开发方法和Mapper接口开发方法。

 5.1 SqlSession的使用范围

         SqlSession中封装了对数据库的操作，如：查询、插入、更新、删除等。

　　通过SqlSessionFactory创建SqlSession，而SqlSessionFactory是通过SqlSessionFactoryBuilder进行创建。

 　　5.1.1 SqlSessionFactoryBuilder

　　SqlSessionFactoryBuilder用于创建SqlSessionFacoty，SqlSessionFacoty一旦创建完成就不需要SqlSessionFactoryBuilder了，因为SqlSession是通过SqlSessionFactory生产，所以可以将SqlSessionFactoryBuilder当成一个工具类使用，最佳使用范围是方法范围即方法体内局部变量。

 　　5.1.2 SqlSessionFactory

         SqlSessionFactory是一个接口，接口中定义了openSession的不同重载方法，SqlSessionFactory的最佳使用范围是整个应用运行期间，一旦创建后可以重复使用，通常以单例模式管理SqlSessionFactory。

　　5.1.3 SqlSession

         SqlSession是一个面向用户的接口， sqlSession中定义了数据库操作方法。

         每个线程都应该有它自己的SqlSession实例。SqlSession的实例不能共享使用，它也是线程不安全的。因此最佳的范围是请求或方法范围。绝对不能将SqlSession实例的引用放在一个类的静态字段或实例字段中。

         打开一个 SqlSession；使用完毕就要关闭它。通常把这个关闭操作放到 finally 块中以确保每次都能执行关闭。如下

SqlSession session = sqlSessionFactory.openSession();
    try {
          // do work
    } finally {
          session.close();
    }

5.2 原始Dao开发方式（不推荐）

原始Dao开发方法需要程序员编写Dao接口和Dao实现类。

映射文件代码同上。

DAO接口：

public interface UserDao {
    public User getUserById(int id) throws Exception; 
　　 public void insertUser(User user) throws Exception; }
public class UserDaoImpl implements UserDao {
    
    //注入SqlSessionFactory
    public UserDaoImpl(SqlSessionFactory sqlSessionFactory){
        this.setSqlSessionFactory(sqlSessionFactory);
    }
    
    private SqlSessionFactory sqlSessionFactory;

    @Override
    public User getUserById(int id) throws Exception {
        SqlSession session = sqlSessionFactory.openSession();
        User user = null;
        try {
            //通过sqlsession调用selectOne方法获取一条结果集
            //参数1：指定定义的statement的id,参数2：指定向statement中传递的参数
            user = session.selectOne("test.findUserById", 1);
            System.out.println(user);
                        
        } finally{
            session.close();
        }
        return user;
    }
    
    @Override
    public void insertUser(User user) throws Exception {
        SqlSession sqlSession = sqlSessionFactory.openSession();
        try {
            sqlSession.insert("insertUser", user);
            sqlSession.commit();
        } finally{
            session.close();
        }
    }
}

 DAO测试：

private SqlSessionFactory sqlSessionFactory;
    
    @Before
    public void init() throws Exception {
        SqlSessionFactoryBuilder sessionFactoryBuilder = new SqlSessionFactoryBuilder();
        InputStream inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
        sqlSessionFactory = sessionFactoryBuilder.build(inputStream);
    }

    @Test
    public void testGetUserById() {
        UserDao userDao = new UserDaoImpl(sqlSessionFactory);
        User user = userDao.getUserById(22);
        System.out.println(user);
    }
}

原始Dao开发中存在以下问题：

  1.  Dao方法体存在重复代码：通过SqlSessionFactory创建SqlSession，调用SqlSession的数据库操作方法
  2. 调用sqlSession的数据库操作方法需要指定statement的id，这里存在硬编码，不利于开发维护。

 5.3 Mapper动态代理方式 

 Mapper接口开发方法只需要程序员编写Mapper接口（相当于Dao接口），由Mybatis框架根据接口定义创建接口的动态代理对象，代理对象的方法体同上边Dao接口实现类方法。

Mapper接口开发需要遵循以下规范：

  • Mapper.xml文件中的namespace与mapper接口的类路径相同。
  • Mapper接口方法名和Mapper.xml中定义的每个statement的id相同
  • Mapper接口方法的输入参数类型和mapper.xml中定义的每个sql 的parameterType的类型相同
  • Mapper接口方法的输出参数类型和mapper.xml中定义的每个sql的resultType的类型相同

5.3.1  Mapper.xml(映射文件)

         定义mapper映射文件UserMapper.xml（内容同Users.xml），需要修改namespace的值为 UserMapper接口路径。将UserMapper.xml放在classpath 下mapper目录 下：

<mapper namespace="cn.ztt.mybatis.mapper.UserMapper">
<!-- 根据id获取用户信息 -->
    <select id="findUserById" parameterType="int" resultType="cn.ztt.mybatis.po.User">
        select * from user where id = #{id}
    </select>
<!-- 自定义条件查询用户列表 -->
    <select id="findUserByUsername" parameterType="java.lang.String" 
            resultType="cn.ztt.mybatis.po.User">
       select * from user where username like '%${value}%' 
    </select>
<!-- 添加用户 -->
    <insert id="insertUser" parameterType="cn.ztt.mybatis.po.User">
    <selectKey keyProperty="id" order="AFTER" resultType="java.lang.Integer">
        select LAST_INSERT_ID() 
    </selectKey>
      insert into user(username,birthday,sex,address) 
      values(#{username},#{birthday},#{sex},#{address})
    </insert>

</mapper>

5.3.2 Mapper.java(接口文件)

/**
 * 用户管理mapper
 */
Public interface UserMapper {
    //根据用户id查询用户信息
    public User findUserById(int id) throws Exception;
    //查询用户列表
    public List<User> findUserByUsername(String username) throws Exception;
    //添加用户信息
    public void insertUser(User user)throws Exception; 
}

接口定义有如下特点：

　　1、  Mapper接口方法名和Mapper.xml中定义的statement的id相同

　　2、  Mapper接口方法的输入参数类型和mapper.xml中定义的statement的parameterType的类型相同

　　3、  Mapper接口方法的输出参数类型和mapper.xml中定义的statement的resultType的类型相同

 

5.3.3 加载UserMapper.xml文件

修改SqlMapConfig.xml文件：

  <!-- 加载映射文件 -->

  <mappers>

    <mapper resource="mapper/UserMapper.xml"/>

  </mappers>

注：SqlMapConfig.xml中mappers（映射器）

Mapper配置的几种方法：

（1）<mapper resource=" " />         使用相对于类路径的资源

如：<mapper resource="sqlmap/User.xml" />

（2） <mapper class=" " />       使用mapper接口类路径

如：<mapper class="cn.itcast.mybatis.mapper.UserMapper"/>

注意：此种方法要求mapper接口名称和mapper映射文件名称相同，且放在同一个目录中。

（3） <package name=""/>       注册指定包下的所有mapper接口

如：<package name="cn.itcast.mybatis.mapper"/>

注意：此种方法要求mapper接口名称和mapper映射文件名称相同，且放在同一个目录中。

5.3.4 测试

public class UserMapperTest extends TestCase {

    private SqlSessionFactory sqlSessionFactory;

    @Before
    public void init() throws Exception {
        //mybatis配置文件
        String resource = "sqlMapConfig.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        //使用SqlSessionFactoryBuilder创建sessionFactory
        sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
    }

    @Test
    public void testFindUserById() throws Exception {
        //获取session
        SqlSession session = sqlSessionFactory.openSession();
        //获取mapper接口的代理对象
        UserMapper userMapper = session.getMapper(UserMapper.class);
//调用代理对象方法
        User user = userMapper.findUserById(1);
        System.out.println(user);
        //关闭session
        session.close();
    }

    @Test
    public void testFindUserByUsername() throws Exception {
        SqlSession sqlSession = sqlSessionFactory.openSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        List<User> list = userMapper.findUserByUsername("张");
        System.out.println(list.size());

    }

      @Test
　　 public void testInsertUser() throws Exception {
        //获取session
        SqlSession session = sqlSessionFactory.openSession();
        //获取mapper接口的代理对象
        UserMapper userMapper = session.getMapper(UserMapper.class);
        //要添加的数据
        User user = new User();
        user.setUsername("张三");
        user.setBirthday(new Date());
        user.setSex("1");
        user.setAddress("北京市");
        //通过mapper接口添加用户
        userMapper.insertUser(user);
        //提交
        session.commit();
        //关闭session
        session.close();
    }
}
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/toria/p/mybatis_study.html