Mybatis_初阶入门_知识整理_mybatis入门相关知识

MyBatis基础初阶入门

MyBatis的作用: 就是对JDBC代码进行封装

框架介绍

框架就是一个半成品软件，我们可以基于这个半成品软件继续开发，来完成个性化的需求
1

ORM 对象关系映射，数据和实体对象的映射

ORM(Object Relational Mapping)：对象关系映射

指的是持久化数据和实体对象的映射模式，为了解决面向对象与关系型数据库存在的互不匹配的现象的技术
1

映射规则

数据库表结构 == 实体类

表字段 == 成员变量

表数据 == 对象
1
2
3
4
5

扩展

 原始 JDBC 的操作问题分析
    1. 频繁创建和销毁数据库的连接会造成系统资源浪费从而影响系统性能。
    2. sql 语句在代码中硬编码，如果要修改 sql 语句，就需要修改 java 代码，造成代码不易维护。
    3. 查询操作时，需要手动将结果集中的数据封装到实体对象中。
    4. 增删改查操作需要参数时，需要手动将实体对象的数据设置到 sql 语句的占位符。 
     
     原始 JDBC 的操作问题解决方案
     1. 使用数据库连接池初始化连接资源。
     2. 将 sql 语句抽取到配置文件中。
     3. 使用反射、内省等底层技术，将实体与表进行属性与字段的自动映射
1
2
3
4
5
6
7
8
9
10

MyBatis介绍

    MyBatis 是一个优秀的基于 Java 的持久层框架，它内部封装了 JDBC，使开发者只需要关注 SQL 语句本身，而不需要花费精力去处理加载驱动、创建连接、创建执行者等复杂的操作
  
     MyBatis 通过 xml 或注解的方式将要执行的各种 Statement 配置起来，并通过 Java 对象和 Statement 中 SQL 的动态参数进行映射生成最终要执行的 SQL 语句 
    
    最后 MyBatis 框架执行完 SQL 并将结果映射为 Java 对象并返回。采用 ORM 思想解决了实体和数据库映射的问题，对 JDBC 进行了封装，屏蔽了 JDBC API 底层访问细节，使我们不用与 JDBC API 打交道，就可以
完成对数据库的持久化操作 
1
2
3
4
5
6

MyBatis 入门程序

流程
    1. 数据准备。
    2. 导入 jar 包。
    3. 在 src 下创建映射配置文件。
    4. 在 src 下创建核心配置文件。
    5. 编写测试类完成相关 API 的使用。
    6. 运行测试查看结果。  
1
2
3
4
5
6
7

配置映射文件 StudentMapper.xml
    
<?xml version="1.0" encoding="UTF-8" ?>
<!--MyBatis的DTD约束-->
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

    <!--
    mapper：核心根标签
    namespace属性：名称空间
-->
<mapper namespace="StudentMapper">
    <!--
        select：查询功能的标签
        id属性：唯一标识
        resultType属性：指定结果映射对象类型
        parameterType属性：指定参数映射对象类型
    -->
    <select id="selectAll" resultType="student" >
        SELECT * FROM student
    </select>
</mapper>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

核心配置文件

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

    <!--引入数据库配置文件-->
    <properties resource="jdbc.properties"/>
    <!--起别名-->
    <typeAliases>
        <!--给一个类起别名-->
        <typeAlias type="com.itheima.bean.Student" alias="student"/>
        <!--给一个包下的所有类起别名-->
        <!--<package name="com.itheima.bean"/>-->
    </typeAliases>

    <environments default="mysql">
        <environment id="mysql">
            <transactionManager type="JDBC"></transactionManager>
            <dataSource type="POOLED">
                <property name="driver" value="${driver}"/>
                <!--<property name="driver" value="com.mysql.jdbc.Driver" />-->

                <property name="url" value="${url}" />
                <!--<property name="url" value="jdbc:mysql://192.168.93.139:3306/db10" />-->

                <property name="username" value="${username}" />
                <!--<property name="username" value="root" />-->

                <property name="password" value="${password}" />
                <!--<property name="password" value="root" />-->
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper  resource="StudentMapper.xml"/>
    </mappers>
</configuration>

  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

模拟dao测试类

 @Test
    public void selectAll() throws IOException {
        //1.加载核心配置文件
       // InputStream inputStream = Resources.getResourceAsStream("MyBatisConfig.xml");
       InputStream inputStream = StudentTest01.class.getClassLoader().getResourceAsStream("MybatisConfig.xml");
        //2 获取sqlSession工厂对象
        SqlSessionFactory build = new SqlSessionFactoryBuilder().build(inputStream);
        //3通过sqlSession工厂对象获取sqlSession对象
        SqlSession sqlSession = build.openSession();
        //4执行配置文件的sql语句并接受结果
        List<Student> list = sqlSession.selectList("StudentMapper.selectAll");
        //5处理结果
        for (Student student : list) {
            System.out.println(student);
        }
        //6释放资源
        sqlSession.close();
        inputStream.close();
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

MyBatis 相关 API

Resources

org.apache.ibatis.io.Resources：加载资源的工具类
1

核心方法

SqlSessionFactoryBuilder

org.apache.ibatis.session.SqlSessionFactoryBuilder：获取 SqlSessionFactory 工厂对象的功能类

SqlSessionFactory

org.apache.ibatis.session.SqlSessionFactory：获取 SqlSession 构建者对象的工厂接口

SqlSession

org.apache.ibatis.session.SqlSession：构建者对象接口。用于执行 SQL、管理事务、接口代理。

MyBatis 映射配置文件

映射配置文件包含了数据和对象之间的映射关系以及要执行的 SQL 语句

<?xml version="1.0" encoding="UTF-8" ?>
<!--MyBatis的DTD约束-->
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<!--
    mapper：核心根标签
    namespace属性：名称空间
-->
<mapper namespace="com.itheima.mapper.StudentMapper">
<!--mapper namespace = "com.itheima.mapper.StudentMapper"  权限定名称-->
    <sql id="select" >SELECT * FROM student</sql>
    <sql id="fields">id,name,age</sql>
    <!--
        select：查询功能的标签
        id属性：唯一标识
        resultType属性：指定结果映射对象类型
        parameterType属性：指定参数映射对象类型
    -->
    <select id="selectAll" resultType="student">
        <include refid="select"/>
    </select>

    <select id="selectById" resultType="student" parameterType="int">
        <include refid="select"/> WHERE id = #{id}
    </select>

    <insert id="insert" parameterType="student">
        INSERT INTO student VALUES (#{id},#{name},#{age})
    </insert>

    <update id="update" parameterType="student">
        UPDATE student SET name = #{name},age = #{age} WHERE id = #{id}
    </update>

    <delete id="delete" parameterType="int">
        DELETE FROM student WHERE id = #{id}
    </delete>

    <select id="selectCondition" resultType="student" parameterType="student">
          <include refid="select"/>
--           SELECT * FROM student
        <where>
            <if test="id != null">
                id = #{id}
            </if>
            <if test="name != null">
                AND name = #{name}
            </if>
            <if test="age != null">
                AND age = #{age}
            </if>
        </where>
    </select>

    <select id="selectByIds" resultType="student" parameterType="list">
        <include refid="select"/>
--         SELECT * FROM student
        <where>
            <foreach collection="list" open="id IN (" close=")" item="id" separator=",">
                #{id}
            </foreach>
        </where>
    </select>

    <select id="selectByName" resultType="student" parameterType="string">
       select  <include refid="fields"/> from student where name = #{name}

    </select>
</mapper>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

小结

 <mapper>：核心根标签。
      namespace 属性：名称空间
     
  <select>：查询功能标签。
  <insert>：新增功能标签。
  <update>：修改功能标签。
  <delete>：删除功能标签  
        id 属性：唯一标识，配合名称空间使用
        parameterType 属性：指定参数映射的对象类型
        resultType 属性：指定结果映射的对象类型
            SQL 获取参数
                #{属性名}         
1
2
3
4
5
6
7
8
9
10
11
12

MyBatis 核心配置文件

核心配置文件介绍

 核心配置文件包含了 MyBatis 最核心的设置和属性信息。如数据库的连接、事务、连接池信息等
1

<?xml version="1.0" encoding="UTF-8" ?>
<!--MyBatis的DTD约束-->
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">

<!--configuration 核心根标签-->
<configuration>

    <!--引入数据库连接的配置文件 在同一个文件下直接写配置文件名称,否则写配置文件路径-->
    <properties resource="jdbc.properties"/>

    <!--配置LOG4J-->
    <settings>
        <setting name="logImpl" value="log4j"/>
    </settings>

    <!--起别名-->
    <typeAliases>
        <typeAlias type="com.itheima.bean.Student" alias="student"/>
        <!--<package name="com.itheima.bean"/>-->
    </typeAliases>

    <!--environments配置数据库环境，环境可以有多个。default属性指定使用的是哪个-->
    <environments default="mysql">
        <!--environment配置数据库环境  id属性唯一标识-->
        <environment id="mysql">
            <!-- transactionManager事务管理。  type属性，采用JDBC默认的事务-->
            <transactionManager type="JDBC"></transactionManager>
            <!-- dataSource数据源信息   type属性 连接池-->
            <dataSource type="POOLED">
                <!-- property获取数据库连接的配置信息 -->
                <property name="driver" value="${driver}" />
                <property name="url" value="${url}" />
                <property name="username" value="${username}" />
                <property name="password" value="${password}" />
            </dataSource>
        </environment>
    </environments>

    <!-- mappers引入映射配置文件 -->
    <mappers>
        <!-- mapper 引入指定的映射配置文件   resource属性指定映射配置文件的名称 -->
        <mapper resource="StudentMapper.xml"/>
    </mappers>
</configuration>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

数据库连接配置文件引入

<properties>：引入数据库连接配置文件标签
   属性  resource：数据库连接配置文件路径
    获取数据库连接参数 ${键名}
1
2
3

起别名

 <typeAliases>：为全类名起别名的父标签
      <typeAlias>：为全类名起别名的子标签
     属性 type：指定全类名
          alias：指定别名
      <package>：为指定包下所有类起别名的子标签。(别名就是类名)
     
    用处 给一个类起别名
        给一个包定义别名
     
     Ctrl +f 选中要更改的内容
     Ctrl + r 替换要修改的内容
1
2
3
4
5
6
7
8
9
10
11

MyBatis 传统方式实现 Dao 层

Dao 层传统实现方式

分层思想：控制层(controller)、业务层(service)、持久层(dao)。

控制层 -->业务层–> 持久层 -->DB

LOG4J

功能 :在日常开发过程中，排查问题时难免需要输出 MyBatis 真正执行的 SQL 语句、参数、结果等信息，我们就可以借助 LOG4J 的功能来实现执行信息的输出。

 使用步骤
     1. 导入 jar 包。 log4j-1.2.17.jar
     2. 修改核心配置文件
         <!--配置LOG4J-->
    <settings>
        <setting name="logImpl" value="log4j"/>
    </settings>
    3. 在 src 下编写 LOG4J 配置文件lon4j.properties文件
     
# Global logging configuration
# ERROR WARN INFO DEBUG
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
     
     效果如下
     ...
     DEBUG [main] - Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@5fcd892a]
     DEBUG [main] - ==>  Preparing: SELECT * FROM student 
     ...
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22