mybatis框架入门介绍

mybatis（持久层框架）jdbc

第一天

课程计划

1. 总结jdbc开发的问题
2. mybatis介绍
3. mybatis入门程序
4. mybatis框架原理
5. mybatis两种开发方法
6. mybatis核心配置文件
7. mybatis与hibernate比较

 

1. 总结jdbc开发的问题
   1. jdbc开发的步骤

1. 加载驱动
2. 创建数据库连接对象
3. 定义sql语句
4. 创建statement语句对象
5. 设置参数
6. 执行
7. 处理结果集
8. 释放资源

 

1. 1. jdbc示例程序
      1. 准备环境

jdk：1.7

ide：eclipse

数据库：mysql

 

1. 1. 1. 准备数据

 

1. 1. 1. 创建项目

 

1. 1. 1. 加入数据库驱动依赖到lib目录

 

1. 1. 1. 编写代码

package cn.bdqn.test; import java.sql.Connection; import java.sql.DriverManager; import java.sql.PreparedStatement; import java.sql.ResultSet;   import org.junit.Test;   public class MySqlConnectionTest { //测试传统访问数据库方式 @Test public void testMySqlConnection() {      try {          //1.加载驱动          Class.forName("com.mysql.jdbc.Driver");          //2.创建数据库连接对象          Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/dbqn", "root", "root");          //3.定义sql语句          String sql="select * from user where id=?";          //4.创建statement语句对象          PreparedStatement psmt  = connection.prepareStatement(sql);          //5.设置参数          psmt.setInt(1, 10);          //6.执行          ResultSet resultSet = psmt.executeQuery();          //7.处理结果集          while(resultSet.next()) {              System.out.println("用户id:"+resultSet.getString("id")+"用户名:"+resultSet.getString("username"));          }          //关闭资源连接          resultSet.close();          psmt.close();          connection.close();      } catch (Exception e) {          e.printStackTrace();      } } }

运行结果

:

1. 1. 总结jdbc的问题
2. 频繁创建数据库连接对象、和释放。容易造成系统资源的浪费，影响系统性能。在企业项目中可以使用连接池解决这个问题。但是使用jdbc需要自己编写连接池。mybatis内部已经提供了连接池。
3. sql语句定义、参数设置、结果集处理存在硬编码。在企业项目中sql语句变化的可能性较大，一旦发生变化，需要修改java代码，系统需要重新编译，重新发布。不好维护。
4. 结果集处理存在重复代码，处理麻烦。如果可以映射为java对象会比较方便。

 

1. mybatis介绍

mybatis是Apache软件基金会下的一个开源项目，前身是Ibatis框架。2010年这个项目由apache 软件基金会迁移到google code下，改名为mybatis。2013年11月又迁移到了github（https://github.com/mybatis/mybatis-3/releases）。

mybatis是一个持久层的框架，是对JDBC操作数据库的封装，使开发者只需要关注业务本身，不需要花费精力去处理加载驱动、创建数据库连接对象、创建statement语句对象、参数设置、结果集处理等一系列繁杂的过程代码。

mybatis通过xml或注解进行配置，将java对象与sql语句中的参数自动映射生成最终执行的sql语句，并将sql语句执行结果自动映射成java对象，返回给业务层（service）应用。

 

说明：

1. mybatis早期版本叫Ibatis，目前托管在github
2. mybatis是对象jdbc的封装，是一个持久层的框架
3. mybatis是通过xml或者注解进行配置，完成java对象与sql语句的映射（对应关系）。

 

1. mybatis入门程序
   1. 需求

实现用户表（user）的增、删、改、查操作（CRUD）。

1. 根据用户id查询用户
2. 根据用户名称模糊查询用户
3. 新增一个用户
4. 根据用户id修改用户
5. 根据用户id删除用户

 

1. 1. 需求实现
      1. 在lib目录，加入mybatis框架依赖包

 

1. 1. 1. 准备配置文件
         1.  mybatis-config.xml

说明：它是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是我们框架的根标签  --> <configuration>     <!-- 配置框架的运行环境 -->     <environments default="development">         <environment id="development">             <!-- 配置事务管理器   这里默认JDBC -->             <transactionManager type="JDBC"/>             <!-- 数据源配置  mybatis内部默认提供的数据库连接池  POOLED -->             <dataSource type="POOLED">                 <!-- 连接数据库的四要素 -->                 <property name="driver" value="com.mysql.jdbc.Driver"/>                 <property name="url" value="jdbc:mysql://localhost:3306/dbqn"/>                 <property name="username" value="root"/>                 <property name="password" value="root"/>             </dataSource>         </environment>     </environments> </configuration>

 

1. 1. 1. 1. log4j.properties

# Global logging configuration log4j.rootLogger=DEBUG, stdout   # Console output... log4j.appender.stdout=org.apache.log4j.ConsoleAppender log4j.appender.stdout.layout=org.apache.log4j.PatternLayout log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n

 

1. 1. 1. 编写用户pojo

package cn.bdqn.pojo; import java.util.Date; public class User {      private Integer id; // 用户id      private String username; // 用户名      private Date birthday; // 出生日期      private String sex; // 性别      private String address; // 家庭住址     public User() {         super();     }     public Integer getId() {         return id;     }     public void setId(Integer id) {         this.id = id;     }     public String getUsername() {         return username;     }     public void setUsername(String username) {         this.username = username;     }     public Date getBirthday() {         return birthday;     }     public void setBirthday(Date birthday) {         this.birthday = birthday;     }     public String getSex() {         return sex;     }     public void setSex(String sex) {         this.sex = sex;     }     public String getAddress() {         return address;     }     public void setAddress(String address) {         this.address = address;     }     //重写输出用户信息  toString方法     @Override Shift+alt+s+s     public String toString() {         return "User [id=" + id + ", username=" + username + ", birthday=" + birthday + ", sex=" + sex + ", address="                 + address + "]";     }     }

 

1. 1. 1. 准备sql语句

select * from `user` where id=10

 

1. 1. 1. 准备mapper映射文件

说明：它是用于配置java对象与sql语句的对应关系。

<?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"> <!-- namespace 相当于java语言中的包 (用以防止sql语句名称冲突)实现sql语句隔离  --> <mapper namespace="test">     <!-- mybatis框架针对数据库的每一种不同的操作提供了相应的标签          分别是: select delete insert update      -->      <!-- select标签      id 用于标识该sql语句的唯一标识符      parameterType 输入参数类型  用于指定传入sql语句的参数类型      resultType    输出参数类型  用于执行执行sql语句返回结果类型      #{id}         占位符   相当于jdbc中的  ?       -->     <select id="queryUserById" parameterType="int" resultType="cn.bdqn.pojo.User">         select * from user where id=#{id}      </select> </mapper>

 

1. 1. 1. 在mybatis-config.xml文件中，加载UserMapper.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是我们框架的根标签  --> <configuration>     <!-- 配置框架的运行环境 -->     <environments default="development">         <environment id="development">             <!-- 配置事务管理器   这里默认JDBC -->             <transactionManager type="JDBC"/>             <!-- 数据源配置  mybatis内部默认提供的数据库连接池  POOLED -->             <dataSource type="POOLED">                 <!-- 连接数据库的四要素 -->                 <property name="driver" value="com.mysql.jdbc.Driver"/>                 <property name="url" value="jdbc:mysql://localhost:3306/dbqn"/>                 <property name="username" value="root"/>                 <property name="password" value="root"/>             </dataSource>         </environment>     </environments>     <mappers>         <!-- mappper标签 加载映射文件到主配置文件         resource用于指定映射文件的位置          -->         <mapper resource="cn/bdqn/dao/UserMapper.xml" />     </mappers> </configuration>

 

1. 1. 1. 编写测试代码

@Test     public void queryUserById() throws Exception {         //加载框架主配置文件         InputStream ins = Resources.getResourceAsStream("mybatis-config.xml");         //创建SqlSessinFactoryBuilder对象 用于读取配置文件         SqlSessionFactoryBuilder builder=new SqlSessionFactoryBuilder();         //调用build()方法 读取配置文件         SqlSessionFactory sqlSessionFactory = builder.build(ins);         //使用工厂对象  创建SqlSession对象         /**          * SqlSession对象  相当于 jdbc中的Connection对象          * 该对象提供了相应的操作数据的api方法          */         SqlSession sqlSession = sqlSessionFactory.openSession();         //根据用户id查询用户信息         /**          * 第一个参数是执行的sql语句  命名空间+sql语句id          * 第二个参数 sql语句执行的参数          */         User user = sqlSession.selectOne("test.queryUserById", 10);         //输出使用框架查询出的对象         System.out.println(user);    }

 

1. 1. 其它需求实现
      1. 根据用户名称模糊查询用户
         1. 准备sql语句

select * from `user` where username like '%小%'

 

1. 1. 1. 1. 配置映射文件

<!-- 根据用户名称模糊查询用户 -->      <select id="queryUserByName" parameterType="String" resultType="cn.bdqn.pojo.User">         select * from user where username like #{username}  </select>

 

1. 1. 1. 1. 编写测试代码

@Test     public void queryUserByUsername() throws Exception {         //加载主配置文件         InputStream ins = Resources.getResourceAsStream("mybatis-config.xml");         //读取主配置文件  并创建SqlSessionFactory对象         SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(ins);         //创建SqlSession对象         SqlSession sqlSession = sqlSessionFactory.openSession();         //调用查询数据列表方法         List<User> userList = sqlSession.selectList("test.queryUserByName", "%小%");         //循环遍历 输出列表数据         for (User user : userList) {             System.out.println(user);         } }

 

1. 1. 1. 1. 使用字符串拼接符${}拼接参数

<!-- 根据用户名称模糊查询用户 -->  <select id="queryUserByName" parameterType="string" resultType="cn.bdqn.po.User">     <!-- select * from `user` where username like #{username} -->         <!-- where username like '%小%',说明：         ${value}：使用字符串拼接符拼接参数      -->     select * from `user` where username like '%${value}%'  </select>

 

1. 1. 1. 1. 占位符#{}与字符串拼接符${}区别
2. 占位符#{}，相当于jdbc中的问号。当参数传递的是java简单类型（八种基本类型+字符串String）的时候，花括号中的内容可以是任意字符串。
3. 字符串拼接符${}，当参数传递的是java简单类型的时候，花括号中的内容只能是：value。
4. 占位符#{}与字符串拼接符${}，当参数传递的是pojo的时候，花括号中的内容都是pojo的属性。
   1. 1. 新增一个用户
         1. 准备sql语句

insert into `user`(id,username,birthday,sex,address) values(2,'小李飞刀','2018-04-08','1','明朝人')

 

1. 1. 1. 1. 配置映射文件

<!-- 新增用户，说明：     insert标签：用于放置新增sql语句     #{id}：字符串拼接符，当参数传递的是pojo的时候，花括号中的内容是pojo的属性   -->   <insert id="insertUser" parameterType="cn.bdqn.pojo.User">     insert into `user`(id,username,birthday,sex,address)     values(#{id},#{username},#{birthday},#{sex},#{address})   </insert>

 

 

1. 1. 1. 1. 编写测试代码

/**  * 测试新增用户  */ @Test public void insertUserTest(){           // 1.创建sqlSession对象      SqlSession sqlSession = this.sqlSessionFactory.openSession();           // 2.使用sqlSession对象，调用方法执行      /**       * insert方法：新增记录       * statement：执行的sql语句（名称空间+"."+sql语句id）       * parameter：传入的参数值       */      // 创建用户对象      User user = new User();      user.setId(3);      user.setUsername("林姑娘");      user.setBirthday(new Date());      user.setSex("2");      user.setAddress("明朝人");           sqlSession.insert("test.insertUser", user);           // 3.释放资源      sqlSession.close();      }

 

问题：java程序执行成功，但是数据库中没有记录。原因是没有提交事务。

 

1. 1. 1. 1. 提交事务
            1. 方式一

/**  * 测试新增用户  */ @Test public void insertUserTest(){           // 1.创建sqlSession对象      SqlSession sqlSession = this.sqlSessionFactory.openSession();           // 2.使用sqlSession对象，调用方法执行      /**       * insert方法：新增记录       * statement：执行的sql语句（名称空间+"."+sql语句id）       * parameter：传入的参数值       */      // 创建用户对象      User user = new User();      user.setId(3);      user.setUsername("林姑娘");      user.setBirthday(new Date());      user.setSex("2");      user.setAddress("明朝人");           sqlSession.insert("test.insertUser", user);           // 数据库中提交事务：commit      // 手动提交事务      sqlSession.commit();           // 3.释放资源      sqlSession.close();      }

 

1. 1. 1. 1. 1. 方式二

/**  * 测试新增用户  */ @Test public void insertUserTest(){           // 1.创建sqlSession对象      //SqlSession sqlSession = this.sqlSessionFactory.openSession();           /**       * 创建sqlSession的对象，指定自动提交事务。true：自动提交；false：不提交。默认是false       */      SqlSession sqlSession = this.sqlSessionFactory.openSession(true);           // 2.使用sqlSession对象，调用方法执行      /**       * insert方法：新增记录       * statement：执行的sql语句（名称空间+"."+sql语句id）       * parameter：传入的参数值       */      // 创建用户对象      User user = new User();      user.setId(4);      user.setUsername("林姑娘");      user.setBirthday(new Date());      user.setSex("2");      user.setAddress("明朝人");           sqlSession.insert("test.insertUser", user);           // 数据库中提交事务：commit      // 手动提交事务      //sqlSession.commit();           // 3.释放资源      sqlSession.close();      }

 

说明：自动提交事务的方式，只要sql语句一旦执行，就提交了事务。如果同时有多个操作，需要使用手动提交事务的方式。

 

1. 1. 1. 根据用户id修改用户
         1. 准备sql语句

update `user` set username='李寻欢',sex='2' where id=2

 

 

1. 1. 1. 1. 配置映射文件

<!-- 根据用户id修改用户，说明：     update：用于放置修改sql语句    -->    <update id="updateUserById" parameterType="cn.bdqn.pojo.User">         update `user`         set username=#{username},sex=#{sex} where id=#{id}    </update>

 

1. 1. 1. 1. 编写测试代码

/**  * 测试根据用户id修改用户  */ @Test public void updateUserByIdTest(){      // 1.创建sqlSession对象      SqlSession sqlSession = this.sqlSessionFactory.openSession(true);           // 2.使用sqlSession对象，调用方法执行      /**       * update方法：修改记录       * statement：执行的sql语句（名称空间+"."+sql语句id）       * parameter：传入的参数值       */      // 创建用户对象      User user = new User();      user.setId(2);      user.setUsername("小李飞刀");      user.setSex("1");           sqlSession.update("test.updateUserById", user);           // 3.释放资源      sqlSession.close(); }

 

1. 1. 1. 根据用户id删除用户
         1. 准备sql语句

delete from `user` where id=3

 

 

1. 1. 1. 1. 配置映射文件

<!-- 根据用户id删除用户，说明：    delete标签：用于放置删除sql语句     -->     <delete id="deleteUserById" parameterType="int">     delete from `user` where id=#{id}        </delete>

 

1. 1. 1. 1. 编写测试代码

/**  * 测试根据用户id删除用户  */ @Test public void deleteUserByIdTest(){      // 1.创建sqlSession对象      SqlSession sqlSession = this.sqlSessionFactory.openSession(true);      // 2.使用sqlSession对象，调用方法执行      /**       * delete方法：删除记录       * statement：执行的sql语句（名称空间+"."+sql语句id）       * parameter：传入的参数值       */      sqlSession.delete("test.deleteUserById", 4);           // 3.释放资源      sqlSession.close(); }

 

 

1. mybatis框架原理

 

sqlMapConfig.xml：配置运行环境（数据源），加载mapper映射文件。它是mybatis框架的运行时环境配置

SqlSessionFactoryBuilder：读取主配置文件内容。返回框架的核心对象（SqlSessionFactory）

SqlSessionFactory：它是框架的核心对象，它是线程安全的，一个应用中通常只需要一个

SqlSession：发起数据库的CRUD操作

Executor：执行数据库的CRUD操作

MappedStatement：输入输出映射对象

                          

数据库：mysql

输入映射： java简单类型 pojo ......

输出映射： java简单类型 pojo .......

 

 

 

 

1. Configuration：配置对象，内容是主配置文件（sqlMapConfig.xml），mapper映射文件（User.xml......）
2. MappedStatement：输入输出映射对象，参数输入（ParameterType），返回值输出（ResultType）
3. Executor：执行器对象，执行数据库的CRUD操作

 

1. mybatis两种开发的方法

1. 原始的dao开发方法
2. mapper代理开发方法

 

1. 1. 原始的dao开发方法
      1. 需求
2. 根据用户id查询用户
3. 新增一个用户

 

1. 1. 1. 需求实现
         1. 编写用户dao接口

package cn.bdqn.dao;   import cn.bdqn.po.User; public interface UserDao {   //   1.根据用户id查询用户 User queryUserById(Integer id);   //   2.新增一个用户 void insertUser(User user);   }

 

 

1. 1. 1. 1. 实现用户dao接口

package cn.bdqn.dao.impl;   import org.apache.ibatis.session.SqlSession; import org.apache.ibatis.session.SqlSessionFactory;   import cn.bdqn.dao.UserDao; import cn.bdqn.po.User;   public class UserDaoImpl implements UserDao {   // 定义SqlSessionFactory对象 private SqlSessionFactory sqlSessionFactory;   /**  * @param sqlSessionFactory  */ public UserDaoImpl(SqlSessionFactory sqlSessionFactory) {      super();      this.sqlSessionFactory = sqlSessionFactory; }   /**  * 根据用户id查询用户  */ public User queryUserById(Integer id) {      // 1.创建sqlSession对象      SqlSession sqlSession = this.sqlSessionFactory.openSession();           // 2.使用sqlSession对象，调用方法执行      Object user = sqlSession.selectOne("test.queryUserById", id);           // 3.释放资源      sqlSession.close();           return (User) user; }   /**  * 新增一个用户  */ public void insertUser(User user) {      // 1.创建sqlSession      SqlSession sqlSession = this.sqlSessionFactory.openSession(true);           // 2.使用sqlSession对象，调用方法执行      sqlSession.insert("test.insertUser", user);           // 3.释放资源      sqlSession.close();   }   }

 

1. 1. 1. 1. 编写测试代码

package cn.bdqn.test;   import java.io.IOException; import java.io.InputStream;   import org.apache.ibatis.io.Resources; import org.apache.ibatis.session.SqlSessionFactory; import org.apache.ibatis.session.SqlSessionFactoryBuilder; import org.junit.Before; import org.junit.Test; import cn.bdqn.dao.UserDao; import cn.bdqn.dao.impl.UserDaoImpl; import cn.bdqn.po.User; public class UserDaoTest {   private SqlSessionFactory sqlSessionFactory = null;   /**  * 初始化SqlSessionFactory对象  * @throws IOException  */ @Before public void init() throws IOException{      // 1.加载主配置文件      // getResourceAsStream方法：加载sqlMapConfig.xml主配置文件      // resource参数：配置文件的位置      InputStream inputStream = Resources.getResourceAsStream("sqlMapConfig.xml");           // 2.读取配置文件的内容      SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();      /**       * sqlSessionFactory对象：       *      1.它是mybatis框架的核心对象       *      2.它是线程安全的，它用于创建SqlSession对象       */      sqlSessionFactory = builder.build(inputStream); }   /**  * 测试根据用户id查询用户  */ @Test public void queryUserByIdTest(){           // 1.创建用户dao实现类对象      UserDao userDao = new UserDaoImpl(sqlSessionFactory);           // 2.使用userDao，调用方法执行      User user = userDao.queryUserById(2);      System.out.println(user);      }   }

 

测试新增用户：

 

/**  * 测试新增用户  *  */ @Test public void insertUserTest(){      // 1.创建用户dao实现类对象      UserDao userDao = new UserDaoImpl(sqlSessionFactory);           // 2.使用userDao，调用方法执行      // 创建用户对象      User user = new User();      user.setUsername("阿飞");      user.setBirthday(new Date());      user.setSex("1");      user.setAddress("中华人民共和国公民");           userDao.insertUser(user);     }

 

 

1. 1. mapper代理开发

 

1. 1. 1. mapper代理开发的原则【掌握】
2. mapper映射文件中的namespace属性值，必须是mapper代理接口的全限定名称
3. mapper映射文件中的sql语句标签的声明，与mapper接口的方法声明要一致

2.1.sql语句标签的resultType属性值（如果查询的结果是集合，比如list，resultType指定的是集合中存放的类型），与mapper接口方法返回值的类型一致

2.2.sql语句标签的id属性值，与mapper接口的方法名称一致

2.3.sql语句标签的paramterType属性值，与mapper接口方法的形参类型一致

 

 

1. 1. 1. 需求
2. 根据用户id查询用户
3. 新增一个用户

 

1. 1. 1. 需求实现
         1. 编写用户mapper接口

package cn.bdqn.mapper;   import cn.bdqn.po.User; public interface UserMapper {   // 1.根据用户id查询用户 User queryUserById(Integer id);   // 2.新增一个用户 void insertUser(User user);     }

 

 

1. 1. 1. 1. 编写用户mapper映射文件

<?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"> <!-- namespace：名称空间，相当于java中的package，用于防止sql语句名称冲突（sql语句隔离） --> <!-- mapper代理开发方法中，namespace属性值必须是mapper代理接口的全限定名称 --> <mapper namespace="cn.bdqn.mapper.UserMapper">   <!-- 根据用户id查询用户 --> <select id="queryUserById" parameterType="int" resultType="cn.bdqn.po.User">     select * from `user` where id=#{id}  </select>     <!-- 新增一个用户 --> <insert id="insertUser" parameterType="cn.bdqn.po.User"   useGeneratedKeys="true" keyColumn="id" keyProperty="id">     insert into `user`(username,birthday,sex,address)     values(#{username},#{birthday},#{sex},#{address})   </insert>   </mapper>

 

1. 1. 1. 1. 在mybatis-config.xml文件中，加载UserMapper.xml文件

<!-- 加载mapper映射文件 --> <mappers>      <!-- 加载User.xml文件，说明：          resource：指定配置文件的位置       -->      <mapper resource="sqlmap/User.xml"/>      <!-- 加载UserMapper.xml文件 -->      <mapper resource="sqlmap/UserMapper.xml"/> </mappers>

 

 

1. 1. 1. 1. 编写测试代码

package cn.bdqn.test;   import java.io.IOException; import java.io.InputStream;   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.Before; import org.junit.Test;   import cn.bdqn.mapper.UserMapper; import cn.bdqn.po.User;   public class UserMapperTest {   private SqlSessionFactory sqlSessionFactory = null;   /**  * 初始化SqlSessionFactory对象  * @throws IOException  */ @Before public void init() throws IOException{      // 1.加载主配置文件      // getResourceAsStream方法：加载sqlMapConfig.xml主配置文件      // resource参数：配置文件的位置      InputStream inputStream = Resources.getResourceAsStream("sqlMapConfig.xml");           // 2.读取配置文件的内容      SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();      /**       * sqlSessionFactory对象：       *      1.它是mybatis框架的核心对象       *      2.它是线程安全的，它用于创建SqlSession对象       */      sqlSessionFactory = builder.build(inputStream); }   /**  * 测试根据用户id查询用户  */ @Test public void queryUserByIdTest(){           // 1.创建sqlSession对象      SqlSession sqlSession = this.sqlSessionFactory.openSession();           // 2.使用sqlSession对象，获取到mapper接口的代理对象      /**       * getMapper方法：获取mapper接口代理对象       * type参数：被代理接口的字节码       */      UserMapper mapper = sqlSession.getMapper(UserMapper.class);      System.out.println(mapper.getClass().getName());           User user = mapper.queryUserById(2);      System.out.println(user);           // 3.释放资源      sqlSession.close();      }   }

 

 

测试新增用户：

/**  * 测试新增一个用户  */ @Test public void insertUserTest(){      // 1.创建sqlSession对象      SqlSession sqlSession = this.sqlSessionFactory.openSession(true);           // 2.使用sqlSession对象，获取到mapper接口的代理对象      /**       * getMapper方法：获取mapper接口代理对象       * type参数：被代理接口的字节码       */      UserMapper mapper = sqlSession.getMapper(UserMapper.class);           // 创建用户对象      User user = new User();      user.setUsername("天机老人");      user.setBirthday(new Date());      user.setSex("1");      user.setAddress("明朝人");           mapper.insertUser(user);           // 3.释放资源      sqlSession.close();    }

 

 

1. 1. 1. 两种开发方法总结
2. 原始的dao开发方法：需要编写接口和实现类
3. mapper代理开发方法：只需要编写接口
4. 企业项目中，推荐使用mapper代理开发的方法

 

 

1. mybatis主配置文件

sqlMapConfig.xml：配置运行环境（数据源）、加载mapper映射文件。

顺序	配置标签名称	说明
1	properties	属性
2	settings	配置全局参数
3	typeAliases	类型别名
4	typeHandlers	类型处理器
5	objectFactory	对象工厂
6	plugins	插件
7	environments	环境集合属性对象
8	databaseIdProvider	多数据库支持
9	mappers	映射器
说明： 红色字体内容要求掌握 在sqlMapConfig.xml中必须是从上往下的配置顺序

 

1. 1. properties（属性）

作用：加载属性文件（db.properties）和定义属性。

 

1. 1. 1. 准备db.properties

db.driver=com.mysql.jdbc.Driver db.url=jdbc:mysql://127.0.0.1:3306/dbqn db.username=root db.password=root

 

 

 

1. 1. 1. 加载db.properties文件

<!-- 加载属性文件 ,说明：      1.resource：加载【本地的】属性文件      2.url：加载【网络上的】属性文件[url="http://127.0.0.1:8080/db.properties"](了解) --> <properties resource="db.properties" >    </properties>

 

 

1. 1. 1. 使用db.properties文件中的属性

<!-- 运行环境配置 --> <!-- default：指定使用哪一个运行环境 --> <environments default="development">      <!-- 配置运行环境，id：给环境取一个唯一的名称 -->      <environment id="development">          <!--配置事务管理器，JDBC：默认使用就是jdbc的事务  -->          <transactionManager type="JDBC" />          <!-- 数据源配置， POOLED：mybati内部提供的连接池-->          <dataSource type="POOLED">              <!-- <property name="driver" value="com.mysql.jdbc.Driver" />              <property name="url" value="jdbc:mysql://127.0.0.1:3306/76_mybatis" />              <property name="username" value="root" />              <property name="password" value="admin" /> -->                           <property name="driver" value="${db.driver}" />              <property name="url" value="${db.url}" />              <property name="username" value="${db.username}" />              <property name="password" value="${db.password}" />          </dataSource>      </environment>    </environments>

 

1. 1. 1. 使用内部property标签定义属性

<!-- 加载属性文件 ,说明：      1.resource：加载【本地的】属性文件      2.url：加载【网络上的】属性文件[url="http://127.0.0.1:8080/db.properties"]      3.使用内部property标签定义属性      4.加载顺序：首先加载内部property标签定义的属性，再加载属性文件中的属性。如果有相同的属性，      属性文件中的属性会覆盖内部property标签定义的属性 --> <properties resource="db.properties" >      <property name="db.username" value="root123"/>      <property name="db.password" value="root"/>    </properties>

 

 

1. 1. typeAliases（类型别名）

作用：简称。比如中华人民共和国，简称中国。

 

1. 1. 1. 内置别名

别名	映射类型
_byte	byte
_long	long
_short	short
_int	int
_integer	int
_double	double
_float	float
_boolean	boolean
string	String
byte	Byte
long	Long
short	Short
int	Integer
integer	Integer
double	Double
float	Float
boolean	Boolean
date	Date
decimal	BigDecimal
bigdecimal	BigDecimal
object	Object
map	Map
hashmap	HashMap
list	List
arraylist	ArrayList
collection	Collection
iterator	Iterator

 

说明：

1. 内置别名可以直接使用
2. 别名不区分大小写

 

1. 1. 1. 自定义别名
         1. 方式一

<!-- 自定义别名配置 --> <typeAliases>      <!--配置用户别名，说明：          1.type：别名的类型          2.默认使用类的名称作为别名的名称          3.alias：指定别名的名称        -->      <typeAlias type="cn.bdqn.pojo.User" alias="user"/> </typeAliases>

 

1. 1. 1. 1. 方式二

<!-- 自定义别名配置 --> <typeAliases>      <!--配置用户别名，说明：          1.type：别名的类型          2.默认使用类的名称作为别名的名称          3.alias：指定别名的名称        -->      <!-- <typeAlias type="cn.bdqn.pojo.User" alias="user"/> -->           <!-- 包扫描方式配置别名，说明：          1.name：指定要扫描的包          2.默认都使用类的名称作为别名的名称          3.如果有多个包，在同一个父包下，配置父包即可          4.如果不在同一个父包下，需要配置多个package:<package name="cn.bdqn.po"/>          5.企业项目中，推荐使用包扫描的方式       -->      <package name="cn.bdqn.po"/>      </typeAliases>

 

1. 1. mappers（映射器）

作用：加载映射文件。

1. 1. 1. 方式一

<!-- 加载mapper映射文件 --> <mappers>      <!-- 加载User.xml文件，说明：          resource：指定配置文件的位置       -->      <mapper resource="sqlmap/User.xml"/>      <!-- 加载UserMapper.xml文件 -->      <mapper resource="sqlmap/UserMapper.xml"/>    </mappers>

 

1. 1. 1. 方式二

<!-- 加载mapper映射文件 --> <mappers>      <!-- 加载User.xml文件，说明：          resource：指定配置文件的位置       -->      <mapper resource="sqlmap/User.xml"/>      <!-- 加载UserMapper.xml文件 -->      <!-- <mapper resource="sqlmap/UserMapper.xml"/> -->           <!-- 包扫描方式加载mapper映射文件，说明：          1.前提是mapper代理的开发方法          2.要求mapper映射文件与mapper接口要放在同一目录          3.要求mapper映射文件的名称，与mapper接口的名称一致       -->      <package name="cn.bdqn.mapper"/>    </mappers>

 

 

1. mybatis与hibernate比较
   1. 相同点

都是对jdbc的封装，都是持久层的框架，都用于dao层的开发。

 

1. 1. 不同点
2. hibernate是封装了sql语句，支持数据库无关性，在项目需要支持多种数据库的情况下，代码开发量较少，sql语句优化困难。mybatis是直接使用sql语句操作数据库，不支持数据库的无关性，在项目需要支持多种数据库的情况下，代码开发量较多，sql语句优化容易。
3. hibernate是配置java对象与数据库表的对应关系，多表关联关系配置复杂。mybatis是配置java对象与sql语句的对应关系，多表关联关系配置简单。
4. hibernate是一个相对重量级的框架，学习使用门槛高，适合于需求相对稳定，中小型的项目，比如办公自动化系统（OA），crm。mybatis是一个轻量级的框架，学习门槛低，适合需求变化频繁，大型的项目，比如互联网项目
   1. 缓存
      1. 一级缓存（sqlSession级别的缓存）

/**  * 测试根据用户id查询用户（测试一级缓存）  */ @Test public void oneCacheTest(){           // 1.创建sqlSession对象      SqlSession sqlSession = this.sqlSessionFactory.openSession();           // 2.使用sqlSession对象，获取到mapper接口的代理对象      /**       * getMapper方法：获取mapper接口代理对象       * type参数：被代理接口的字节码       */      UserMapper mapper = sqlSession.getMapper(UserMapper.class);           User user = mapper.queryUserById(2);      System.out.println(user);           System.out.println("----------------------------------");      User user2 = mapper.queryUserById(2);      System.out.println(user2);           // 3.释放资源      sqlSession.close();         }

 

说明：一级缓存本身就存在，不需要我们关心。

 

1. 1. 1. 二级缓存（mapper级别的缓存，在多个sqlSession之间可以共享）
         1. 配置sqlMapConfig.xml文件，开启缓存

 

1. 1. 1. 1. 修改用户pojo，实现序列化接口

 

1. 1. 1. 1. 在UserMapper.xml文件中，配置开启缓存  <cache></cache>

 

1. 1. 1. 1. 测试二级缓存

/**  * 测试根据用户id查询用户（测试一二级缓存）  */ @Test public void twoCacheTest(){           // 1.创建sqlSession对象      SqlSession sqlSession = this.sqlSessionFactory.openSession();           // 2.使用sqlSession对象，获取到mapper接口的代理对象      /**       * getMapper方法：获取mapper接口代理对象       * type参数：被代理接口的字节码       */      UserMapper mapper = sqlSession.getMapper(UserMapper.class);           User user = mapper.queryUserById(2);      System.out.println(user);             // 3.释放资源      sqlSession.close();           System.out.println("----------------------------------");      //4.创建sqlSession对象      SqlSession sqlSession1 = this.sqlSessionFactory.openSession();           // 5.使用sqlSession1对象，获取到mapper接口的代理对象      /**       * getMapper方法：获取mapper接口代理对象       * type参数：被代理接口的字节码       */      UserMapper mapper1 = sqlSession1.getMapper(UserMapper.class);           User user1 = mapper1.queryUserById(2);      System.out.println(user1);             // 6.释放资源      sqlSession1.close();      }

 

说明：mybatis的二级缓存，在企业项目中不推荐使用，只做了解。