创建maven项目

这步不用说，注意不要引入任何依赖和框架，这里只是为了研究mybatis

引入依赖如下

  1.   <dependencies>
  2.         <dependency>
  3.             <groupId>org.mybatis</groupId>
  4.             <artifactId>mybatis</artifactId>
  5.             <version>3.5.5</version>
  6.         </dependency>
  7.         <dependency>
  8.             <groupId>mysql</groupId>
  9.             <artifactId>mysql-connector-java</artifactId>
  10.             <version>8.0.22</version>
  11.         </dependency>
  12.         <dependency>
  13.             <groupId>junit</groupId>
  14.             <artifactId>junit</artifactId>
  15.             <version>4.13</version>
  16.             <scope>test</scope>
  17.         </dependency>
  18.     </dependencies>

编写实体类

假设已经存在数据库

  1. package com.wangzhi.pojo;
  3. public class User {
  5.     private Integer id;
  7.     private String name;
  9.     public Integer getId() {
  10.         return id;
  11.     }
  13.     public void setId(Integer id) {
  14.         this.id = id;
  15.     }
  17.     public String getName() {
  18.         return name;
  19.     }
  21.     public void setName(String name) {
  22.         this.name = name;
  23.     }
  25.     @Override
  26.     public String toString() {
  27.         return "User{" +
  28.                 "id=" + id +
  29.                 ", name='" + name + '\'' +
  30.                 '}';
  31.     }
  32. }

编写核心配置文件

这里的核心配置和我们自定义框架的前期是一样的，只不过配置文件的根要注意

  1. 下面是SqlMapperConfig.xml的配置
  2. <?xml version="1.0" encoding="UTF-8" ?>
  3. <!DOCTYPE configuration
  4.         PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  5.         "http://mybatis.org/dtd/mybatis-3-config.dtd">
  6. <configuration>
  7.     <!--指定当前使用的环境-->
  8.     <environments default="dev">
  9.         <!--可以配置多个，比如说开发环境、测试环境、生产环境-->
  10.         <environment id="dev">
  11.             <!--表示使用JDBC的事务-->
  12.             <transactionManager type="JDBC"/>
  13.             <!--表示使用mybatis的连接池-->
  14.             <dataSource type="POOLED">
  15.                 <!--配置数据库连接信息，我这里使用的是mysql8-->
  16.                 <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
  17.                 <property name="url" value="jdbc:mysql:///zdy_mybatis?serverTimezone=UTC&amp;useUnicode=true&amp;characterEncoding=utf-8&amp;useSSL=true"/>
  18.                 <property name="username" value="root"/>
  19.                 <property name="password" value="nrblwbb7"/>
  20.             </dataSource>
  21.         </environment>
  22.     </environments>
  24.     <mappers>
  25.         <mapper resource="UserMapper.xml"/>
  26.     </mappers>
  27. </configuration>
  29. UserMapper.xml的内容如下：
  31. <?xml version="1.0" encoding="UTF-8" ?>
  32. <!DOCTYPE mapper
  33.         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  34.         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  35. <mapper namespace="user">
  36.     <select id="selectAll" resultType="com.wangzhi.pojo.User">
  37.         SELECT * FROM user
  38.     </select>
  39. </mapper>

这里我们还没有接口，直接使用的是xml来进行数据库的交互。

编写测试类进行测试

上面的流程基本配置和所有的准备工作已经完成，接下来测试类的编写

  1. public class test {
  3.     @Test
  4.     public void testQuery() throws IOException {
  5.         InputStream resourceAsStream = Resources.getResourceAsStream("SqlMapperConfig.xml");
  6.         SqlSession sqlSession = new SqlSessionFactoryBuilder().build(resourceAsStream).openSession();
  7.         List<User> users = sqlSession.selectList("user.selectAll");
  8.         users.forEach(System.out::println);
  9.         sqlSession.close();
  10.     }
  11. }

接下来，将CUD也测试一下

  1.  <insert id="insertUser" parameterType="com.wangzhi.pojo.User">
  2.         INSERT INTO user VALUES (#{id}, #{name})
  3.     </insert>
  5.     <update id="updateUser" parameterType="com.wangzhi.pojo.User">
  6.         UPDATE user SET name = #{name} WHERE id = #{id}
  7.     </update>
  9.     <delete id="deleteUser" parameterType="java.lang.Integer">
  10.         DELETE FROM user WHERE id = #{id}
  11.     </delete>
  15.   测试类
  17.   @Test
  18.     public void testInsert() throws IOException {
  19.         InputStream resourceAsStream = Resources.getResourceAsStream("SqlMapperConfig.xml");
  20.         SqlSession sqlSession = new SqlSessionFactoryBuilder().build(resourceAsStream).openSession();
  21.         User user = new User();
  22.         user.setId(2);
  23.         user.setName("芊芊");
  24.         sqlSession.insert("user.insertUser", user);
  25.         sqlSession.commit();
  26.         sqlSession.close();
  27.     }
  29.     @Test
  30.     public void testUpdate() throws IOException {
  31.         InputStream resourceAsStream = Resources.getResourceAsStream("SqlMapperConfig.xml");
  32.         SqlSession sqlSession = new SqlSessionFactoryBuilder().build(resourceAsStream).openSession();
  33.         User user = new User();
  34.         user.setId(2);
  35.         user.setName("芊儿");
  36.         sqlSession.update("user.updateUser", user);
  37.         sqlSession.commit();
  38.         sqlSession.close();
  39.     }
  41.     @Test
  42.     public void testDelete() throws IOException {
  43.         InputStream resourceAsStream = Resources.getResourceAsStream("SqlMapperConfig.xml");
  44.         SqlSession sqlSession = new SqlSessionFactoryBuilder().build(resourceAsStream).openSession();
  45.         sqlSession.delete("user.deleteUser", 1);
  46.         sqlSession.commit();
  47.         sqlSession.close();
  48.     }

注意于查询不相同的地方在于增删改必须要显示提交事务，否则操作不会保存在数据库中。

传统Dao的开发方式和代理开发方式，这个也在自定义框架里面设计，无论是传统开发方式还是代理开发方式，接口的存在是必须的，区别在于传统开发方式需要有实现类，由实现类去进行操作。代理开发方式是接口于sqlMapper直接映射，利用反射等技术来进行实现。
传统开发方式：

  1. public interface UserMapper {
  3.     List<User> findAll() throws IOException;
  5.     List<User> selectAll();
  6. }
  8. public class UserMapperImpl implements UserMapper {
  9.     @Override
  10.     public List<User> findAll() throws IOException {
  11.         // 加载配置文件，将配置文件转为字节输入流
  12.         InputStream resourceAsStream = Resources.getResourceAsStream("SqlMapperConfig.xml");
  13.         // 解析配置文件，创建SqlSessionFactory工厂，生产会话对象，会隐式开始事务，构造方法传入true会隐式提交事务
  14.         SqlSession sqlSession = new SqlSessionFactoryBuilder().build(resourceAsStream).openSession();
  15.         // 调用数据库方法，selectList、selectOne、update、delete、insert，如果在创建会话对象的时候没有传入true，需要显式提交事务
  16.         List<User> users = sqlSession.selectList("user.selectAll");
  17.         sqlSession.close();
  18.         return users;
  19.     }
  21.     @Override
  22.     public List<User> selectAll() {
  23.         return null;
  24.     }
  25. }

其实传统开发就是将我们前面的测试类移动到实现类中就可以，代理开发方式我们需要一些约束，也就是将接口于xml进行映射，能产生关联，具体在四个地方：

  • xml的namespace，必须是接口所在的路径
  • xml中操作标签的id，要与接口的方法对应
  • xml的操作标签的parameterType要与方法的参数的类型相同
  • xml的操作标签的resultType要与方法的返回值类型相同

具体的代码如下：

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE mapper
  3.         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  4.         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  5. <mapper namespace="com.wangzhi.dao.UserMapper">
  6.     <select id="selectAll" resultType="com.wangzhi.pojo.User">
  7.         SELECT * FROM user
  8.     </select>
  9. </mapper>
  11. // 接口
  12. public interface UserMapper {
  14.     List<User> selectAll();
  15. }
  17. // 测试
  18. @Test
  19.     public void testProxyQuery() throws IOException {
  20.         InputStream resourceAsStream = Resources.getResourceAsStream("SqlMapperConfig.xml");
  21.         SqlSession sqlSession = new SqlSessionFactoryBuilder().build(resourceAsStream).openSession();
  22.         UserMapper mapper = sqlSession.getMapper(UserMapper.class);
  23.         List<User> all = mapper.selectAll();
  24.         all.forEach(System.out::println);
  25.     }