Java_17_数据库元数据&Mybatis框架：数据库元数据、Mybatis框架入门


一、数据库元数据

元数据：是指数据库、表、列的定义信息。即用来定义数据表的数据
在这里插入图片描述
回顾元注解
元注解是用来定义注解的注解

元数据分类

数据库元数据：可以获得数据库的版本，驱动版本等信息(了解)
参数元数据：用来获得占位符?的个数以及数据类型，参数指的是SQL语句中占位符?
结果集元数据：用来获得结果集中的列的数量，列的名称，以及列的类型

二、参数元数据–ParameterMetaData

ParameterMetaData（参数元数据）可用于获取有关Preparedstatement对象（预编译对象）中参数的个数和类型。

1
2
select * from user where name=? and password=?
// ParameterMetaData可以用来获取？的个数和类型

获取ParameterMetaData对象

通过 PreparedStatement（预编译对象）的getParameterMetaData() 方法来获取到 ParameterMetaData对象

1
ParameterMetaData getParameterMetaData()

ParameterMetaData对象方法

获取PreparedStatement的SQL语句参数？的个数

1
2
//获得占位符?的个数
int getParameterCount()

获取指定参数的SQL类型。

1
2
3
4
5
6
7
//获得指定第几个占位符的数据类型，从1开始
String getParameterTypeName(int param)

即

//获得指定占位符的数据类型，索引从1开始(了解)
String getParameterTypeName(int index)

注意事项：
不是所有的数据库驱动都能获取到参数类型(MySQL会出异常)

参数元数据ParameterMetaData代码示例1

1
2
3
4
5
6
7
8
9
10
11
12
13
public class Demo01 {
  public static void main(String[] args) throws Exception {
    Connection conn = DataSourceUtils.getConnection();
    String sql = "INSERT INTO  student (name, age, score) VALUES (?, ?, ?)";
    PreparedStatement stmt = conn.prepareStatement(sql);
    ParameterMetaData md = stmt.getParameterMetaData();
    System.out.println("参数个数： " + md.getParameterCount());

    // Parameter metadata not available for the given statement
    // MySQL不支持获取参数类型
    // System.out.println("参数类型： " + md.getParameterTypeName(1));
  }
}

参数元数据ParameterMetaData代码示例2

需求：得到SQL语句的参数元数据。
1、创建学生表：学号,姓名,性别,生日

1
-- 创建学生表：学号,姓名,性别,生日

2、获取参数元数据个数及数据类型

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
/**
    目标：掌握参数元数据的作用和常用方法

    ParameterMetaData参数元数据的作用：用来获得占位符?的个数以及数据类型

    ParameterMetaData参数元数据常用方法：
         int getParameterCount() 获得占位符?的个数
         String getParameterTypeName(int index) 获得指定占位符的数据类型，索引从1开始(了解)

    如何获得ParameterMetaData参数元数据对象
        通过PreparedStatement对象的方法获得，方法如下：
            ParameterMetaData getParameterMetaData();

 */
public class JDBCDemo01 {
    public static void main(String[] args) throws Exception{
        // 需求：往学生表添加一条记录
        // 1. 获得连接对象
        Connection conn = DataSourceUtils.getConnection();
        // 2. 获得预编译对象
        PreparedStatement ps = conn.prepareStatement("insert into student values(null,?,?,?)");
        // 3. 给占位符赋值
        ps.setString(1, "jack");
        ps.setString(2, "男");
        ps.setString(3, "1999-02-20");
        // 4. 获得参数元数据对象
        ParameterMetaData pmd = ps.getParameterMetaData();
        // 调用参数元数据对象的方法获得占位符个数和类型
        int parameterCount = pmd.getParameterCount();
        System.out.println("parameterCount = " + parameterCount);
        for (int index = 1; index <= parameterCount; index++) {
            // 根据索引获得对应占位符的数据类型
            String typeName = pmd.getParameterTypeName(index);
            System.out.println(typeName);
        }
        // 5. 执行SQL语句
        System.out.println(ps.executeUpdate());
        // 6. 关闭资源
        DataSourceUtils.close(conn, ps);
    }
}

默认情况下：因为MySQL驱动的原因，不支持得到参数元数据的类型。
MySQL驱动对参数元数据的数据类型支持不理想，需要如下配置才能得到参数的MySQL数据类型，而且只能得到VARCHAR类型，如果不配置这个参数则会出现异常。

1
jdbc:mysql://localhost:3306/数据库名?generateSimpleParameterMetadata=true

小结

参数元数据的作用：用来获得占位符个数和类型(都是varchar类型)

如何获取参数元数据对象：通过PreparedStatement对象的方法获得，方法如下：

1
ParameterMetaDate getParameteMetaData()
ParameterMetaData对象常用方法 说明
int getParameterCount() 获得占位符个数
String getParameterTypeName(int param) 获得指定占位符的数据类型

三、结果集元数据–ResultSetMetaData

ResultsetMetaData可用于获取有关Resultset对象中列的数量，列名和列的类型。只有查询才会有结果集元素数据。
在这里插入图片描述

获取ResultSetMetaData对象

查询获得ResultSet后，通过 ResultSet 的 getMetaData() 方法来获取到 ResultSetMetaData 对象

1
2
//获得结果集元数据对象
ResultSetMetaData getMetaData()

ResultSetMetaData对象方法

返回此ResultSet对象中的列数

1
2
//获得列的数量
int getColumnCount()

获取指定列的名称

1
2
//获得指定列的名称，索引从1开始
String getColumnName(int column)

获取指定列的数据库特定类型名称

1
2
//获得指定列的类型，索引从1开始
String getColumnTypeName(int column)

结果集元数据ResultSetMetaData代码示例1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// ResultSetMetaData
public static void test02() throws SQLException {
    Connection conn = DataSourceUtils.getConnection();
    String sql = "SELECT * FROM student WHERE id=1";
    PreparedStatement stmt = conn.prepareStatement(sql);
    ResultSet rs = stmt.executeQuery();
    // 获取结果集元数据
    ResultSetMetaData md = rs.getMetaData();
    int num = md.getColumnCount();
    System.out.println("列数：" + num);
    for (int i = 0; i < num; i++) {
        System.out.println("列名：" + md.getColumnName(i + 1)); // 获取列列名
        System.out.println("列类型：" + md.getColumnTypeName(i + 1)); // 获取类的 类型
        System.out.println("-----------");
    }
}

案例效果
在这里插入图片描述

结果集元数据ResultSetMetaData代码示例2

只有查询才会有结果集元素数据。

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
/**
    目标：掌握结果集元数据的作用和常用方法

    如何获得结果集元数据对象
        通过ResultSet对象的方法获得，方法声明如下：
           ResultSetMetaData getMetaData();

    结果集元数据对象的作用：用来获得结果集中的列的数量，列的名称，以及列的类型

    结果集元数据对象常用方法：
        int getColumnCount(); 获得列的数量
        String getColumnName(int index); 获得指定列的名称，索引从1开始
        String getColumnTypeName(int index); 获得指定列的类型，索引从1开始
 */
public class JDBCDemo01 {
    public static void main(String[] args)throws Exception {
        // 需求：查询所有学生
        // 1. 获得连接对象
        Connection conn = DataSourceUtils.getConnection();
        // 2. 获得预编译对象
        PreparedStatement ps = conn.prepareStatement("select id,name from student;");
        // 3. 执行查询操作获得结果集对象
        ResultSet rs = ps.executeQuery();
        // 4. 通过结果集对象获得结果集元数据对象
        ResultSetMetaData rsm = rs.getMetaData();
        // 获得结果集中列的信息
        // 获得列数量
        int columnCount = rsm.getColumnCount();
        System.out.println("columnCount = " + columnCount);
        // 遍历列获得列名称和类型
        for (int index = 1 ; index <= columnCount; index++) {
            // 获得列名称
            String columnName = rsm.getColumnName(index);
            // 获得列类型
            String typeName = rsm.getColumnTypeName(index);
            System.out.println(columnName+"="+ typeName);
        }
        // 5. 关闭资源
        DataSourceUtils.close(conn, ps, rs);
    }
}

四、数据库元数据应用-封装增删改查方法-简化开发（简版框架）

1、封装增删改方法

我们发现，增删改都需要获取连接，关闭连接，只是SQL语句不同。我们可以使用元数据来自动给SQL设置参数，合并成一个方法。

在 DataSourceUtils 中增加一个方法 update。
增删改都调用update方法，只需要编写SQL语句和设置参数即可,可以减少代码。

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
/**
 重构重复代码的思路
 1. 将重复出现的代码抽取到一个方法中
 2. 将不同的内容作为参数传递
 */
public static int  update(String sql, Object...params) throws Exception{
    // 1. 获得连接对象
    Connection conn = DataSourceUtils.getConnection();
    // 2. 获得预编译对象
    PreparedStatement ps = conn.prepareStatement(sql);

    // 3. 给占位符赋值
    // 3.1 获得参数元数据对象
    ParameterMetaData pmd = ps.getParameterMetaData();
    // 3.2 获得占位符个数 1 2 3
    int parameterCount = pmd.getParameterCount();
    // 3.3 给占位符赋值
    for (int index = 1; index <= parameterCount; index++) {
        // 给占位符赋值
        ps.setObject(index, params[index-1]);
    }
    // 4. 执行SQL并获得结果
    int row = ps.executeUpdate();
    // 5. 释放资源
    DataSourceUtils.close(conn, ps );

    return row;
}

测试增删改方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
/**
  需求：封装增删改方法
 */
public class JDBCDemo02 {
    // 添加数据
    @Test
    public void testInsert() throws Exception{
        DataSourceUtils.update("insert into student values(null,?,?,?);","rose","女","1988-01-20");
    }

    // 更新数据
    @Test
    public void testUpdate()throws Exception{
        int row = DataSourceUtils.update("update student set name = ? where id = ?;","玫瑰花",11);
        System.out.println(row);
    }

    // 删除数据
    @Test
    public void testDelete()throws Exception{
        DataSourceUtils.update("delete from student where id = ?;", 11);
    }
}

2、封装查询方法

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
/**
     * 执行指定的SQL语句
     * @param sql  要执行的查询语句
     * @param clazz  集合存储对象的类型
     * @return 集合
     */
    public static <T> List<T> queryForList(String sql, Class<T> clazz) throws Exception{
        // 创建集合对象
        List<T> list = new ArrayList<>();
   
        // 1. 获得连接对象
        Connection conn = DataSourceUtils.getConnection();
        // 2. 获得预编译对象
        PreparedStatement ps = conn.prepareStatement(sql);
        // 3. 执行SQL语句获得结果集对象
        ResultSet rs = ps.executeQuery();
   
        // 获得结果集元数据对象
        ResultSetMetaData rmd = rs.getMetaData();
        // 获得结果集中列的数量
        int columnCount = rmd.getColumnCount();
   
        // 4. 遍历结果集对象
        while (rs.next()){
            // 4.1 每遍历到一条记录则创建一个对象
            // 通过反射创建对象（传入的字节码对象，对应的实体类）
            T obj = clazz.getConstructor().newInstance();
   
            // 遍历结果集中的列
            for (int index = 1; index <= columnCount; index++) {
                // 根据索引获得列名：name  gender 就是obj的成员变量名称
                String columnName = rmd.getColumnName(index);
                // 根据列名获得值：小波  女
                Object value = rs.getObject(columnName);
                // 获得成员变量Field对象
                Field field = clazz.getDeclaredField(columnName);
                // 暴力反射
                field.setAccessible(true);
                // 给对象obj的成员变量name赋值为value
                field.set(obj, value);
            }
   
            // 4.4. 将对象添加到集合中
            list.add(obj);
   
        }
        // 5. 释放资源
        DataSourceUtils.close(conn, ps, rs);
        // 返回集合
        return list;
    }

测试查询方法

1
2
3
4
5
6
7
8
9
10
11
12
13
/**
  目标：查询所有学生，得到List<Student>
 */
public class JDBCDemo03 {
    public static void main(String[] args)throws Exception {
        // 执行查询获得学生集合
        List<Student> list = DataSourceUtils.queryForList("select id,name from student;", Student.class);
        for (Student stu : list) {
            System.out.println(stu);
        }
    }

}

五、框架概述

1、什么是框架？

框架(Framework)是整个或者部分系统的可重用设计,是J2EE底层技术的封装。框架是可以被应用开发者(程序员)定制的应用骨架。简而言之,框架其实就是别人搭好了舞台,你来做表演。
在这里插入图片描述
理解：Java框架对java原生代码进行一系列的封装使其具有更高的重用型。

2、框架解决的问题

框架解决了技术整合问题

在J2EE体系中,有着各种各样的技术。不同的软件企业,根据自身的业务需求选择不同的技术,容易造成应用依赖技术,增加了项目开发实现的复杂性和技术风险性。企业项目中应该将应用的设计与实现技术解耦。

框架解决了提升开发效率的问题

企业项目中使用框架,程序员不再需要重复造轮子,只需要专注实现业务需求。使用框架的方便性,提升了开发效率。

框架解决了稳定性的问题

一个成熟的框架,经过了在众多企业项目中的验证使用。稳定性有保障。

理解：
框架的好处：代码重用性高，达到简化开发。提高开发效率，降低开发难度

3、项目分层–三层架构

在J2EE应用中，通常把项目整体进行分层设计。分为表现层、业务层、持久层，称为三层架构。

简单理解：即把代码按作用分成三类，放在src下三个文件夹
表现层（也称web层）：
业务层（也称service层）：
持久层（也称dao层）：
在这里插入图片描述
javaweb——初用idea创建一个三层架构的web项目（Dao，service，controller）：https://blog.csdn.net/qq_38261445/article/details/87927006

4、项目分层后常用的框架

在这里插入图片描述

持久层框架MyBatis

在这里插入图片描述
关于持久层的框架,还有一个封装程度更高的框架(hibernate),该框架相对比较重量级,以及其它各个方面的原因, 目前流行程度下降了很多,企业项目中用的越来越少了。

业务层（通常不使用框架，业务逻辑自己实现）

表现层框架Spring MVC

在这里插入图片描述

解决技术整合的框架

在这里插入图片描述

小结

1、框架组合简称：
SSM：
springmvc
spring
mybatis

SSH
struct2
spring
hibernate

2、三层架构中，每一层最常用的框架分别是什么？
web层：springmvc
service层：spring
dao层：mybatis

六、MyBatis 框架快速入门

1、Mybatis框架介绍

mybatis是Apache软件基金会下的一个开源项目，前身是ibatis框架。2010年这个项目由apache软件基金会迁移到google code下，改名为mybatis, 2013年11月又迁移到了github (https://github.com/mybatis/mybatis3/releases)。github网站是全球最大的代码托管平台

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

mybatis框架通过xml或注解进行配置，将java对象与sql语句中的参数自动映射生成最终执行的sql语句，并将sql语句执行结果自动映射成java对象

三句话概括介绍:
1、mybatis框架早期版本叫做ibatis, 目前源代码托管在github
2、mybatis框架是对jdbc操作数据库的封装，是一个持久层的框架
3、mybatis框架通过xml或者注解进行配置，实现java对象与sql语句的自动对应关系(映射)

2、官方网站及框架包下载

MyBatis官网

官方文档地址：http://www.mybatis.org/mybatis-3/
在这里插入图片描述

MyBatis框架包下载

官网下载
在这里插入图片描述

github下载框架地址：https://github.com/mybatis/mybatis-3/releases
在这里插入图片描述

3、使用MyBatis框架的开发方式

XML配置方式
注解配置方式

小结

官方文档地址：http://www.mybatis.org/mybatis-3/

下载框架地址：https://github.com/mybatis/mybatis-3/releases

1、Mybatis框架早期版本叫做ibatis，目前源代码托管在github。
2、Mybatis框架是对jdbc操作数据库的封装，是一个持久层的框架。
3、Mybatis框架通过xml或者注解进行配置，实现java对象与sql语句的自动对应关系（映射）

七、MyBatis入门案例体验

案例需求

使用mybatis框架查询数据库user表的全部用户数据，并打印到控制台上
在这里插入图片描述

数据准备

在MySQL数据库创建表和插入数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
-- 创建用户表
create table user (
  id int primary key auto_increment,
  username varchar(20) not null,
  birthday date,
  sex char(1) default '男',
  address varchar(50)
);

-- 添加用户数据
insert into user values (null, '孙悟空','1980-10-24','男','花果山水帘洞');
insert into user values (null, '白骨精','1992-11-12','女','白虎岭白骨洞');
insert into user values (null, '猪八戒','1983-05-20','男','福临山云栈洞');
insert into user values (null, '蜘蛛精','1995-03-22','女','盤丝洞');

-- 查询用户数据
select * from user;

开发流程

1 创建项目
2 加入 mybatis 框架 jar 包
3 准备配置文件：sqlMapConfig.xml，log4j.properties
4 编写用户实体类（User）
5 编写用户 dao 接口（UserMapper）
6 编写用户 dao 接口映射文件（UserMapper.xml）
7 在 sqlMapConfig.xml 中，加载 UserMapper.xml
8 编写测试代码

开发流程实现（1-3）环境搭建

1、在IDEA项目创建模块，模块名自定义。

2、导入Mybatis框架jar包

模块下创建lib文件夹，加入jar包。
1、mybatis框架包
2、mysql数据库驱动包
3、log4j日志包

右键lib文件夹 -> “Add as Library”
在这里插入图片描述
Log4j是由Apache提供的日志操作包，用于帮助用户处理日志信息。

log4j是什么，log4j解决了什么问题，log4j怎么用：
https://blog.csdn.net/weixin_41356040/article/details/79102654

3、准备配置文件

sqlMapConfig.xml（mybatis核心配置，执行入口）

sqlMapConfig.xml它是 mybatis 框架的核心配置文件，是执行入口。

在src下创建文件，命名为sqlMapConfig.xml（右键src，new File->sqlMapConfig.xml）。先创建，等下编写

1
<?xml version="1.0" encoding="UTF-8" ?>

log4j.properties

在 src 下准备日志配置文件log4j.properties。
固定内容不用记，整个文件复制过来

1
2
3
4
5
6
# 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

开发流程实现–编写sqlMapConfig.xml文件

完成mybatis主配置文件相关信息的配置：数据库环境信息配置，包括如下：
1、导入mybatis约束(复制约束信息)，即sqlMapConfig.xml开头约束
2、数据库事务配置
3、连接池配置

编写SqlMapConfig.xml主配置文件

1、配置要操作的数据库mysql
2、配置事务管理器：使用JDBC事务管理
3、配置数据源：数据库地址url、数据库驱动driver、账号username、密码password
4、使用mysql默认的连接池
5、dao接口映射文件（后面补充）

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

    <!--
        environments标签的作用：配置数据库环境：告诉mybatis框架要操作哪个数据
            可以配置多个，但一般就一个
    -->
    <environments default="mysql">
        <!--
            environment标签的作用：配置一个数据库环境
                id属性：设置环境的唯一标识

            transactionManager标签的作用：配置事务管理器
                type属性：设置事务管理器的类型，可用值如下：
                    "JDBC"：mybatis的事务管理使用jdbc的事务管理方式，目前都选择该值
                    "MANAGED" 事务交个容器管理，后续事务都是交给spring容器管理

             dataSource标签的作用：配置数据源(连接池)
                    type属性：设置数据源的类型，可用值如下：
                        pooled：使用mybatis自定义的连接池
                        unpooled：不使用连接池，每次都是重新获得连接对象，操作完毕直接销毁连接
                        jnid：使用外部配置的连接池

        -->
        <environment id="mysql">
            <!-- 配置事务管理器 -->
            <transactionManager type="JDBC"></transactionManager>
            <!--配置数据源-->
            <dataSource type="pooled">
                <property name="url" value="jdbc:mysql:///day17"/>
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>
   
    <!--实体类映射文件，即dao接口映射文件-->
    <mappers>
        <mapper resource=""/>
    </mappers>
</configuration>

Mybatis主配置文件的作用：
配置事务管理器
配置数据源参数(连接池信息)

开发流程实现（4-7）编写代码

1、编写用户实体类（User）

在Java中，实体类就是一个拥百有Set和Get方法的类。实体类通常总是和数据库度之类的（所谓持久层数据）联系在一起。这种联系是借由框架知（如Hibernate）来建立的。

1、实体类的名字尽量和数据库的表的名字对应相同
2、实体类有属性和方法，属性对应数据库中表的字段，主要有getter和setter方法。有参、无参构造方法
2、实体类应该实现java.io.Serializable接口。
3、实体类还应该有个属性serialVersionUID（参考序列化流）

Java实体类(entity)作用
https://zhidao.baidu.com/question/299895038.html

实体类代码User.class

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
package com.itheima.entity;

import java.util.Date;

public class User {
    private int id;
    private String username;
    private String sex;
    private Date birthday;
    private String address;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", sex='" + sex + '\'' +
                ", birthday=" + birthday +
                ", address='" + address + '\'' +
                '}';
    }
}

2、编写用户 dao 接口（UserMapper）

DAO全称Data Access Object，即数据访问对象，是一个面向对象的数据库接口。
数据访问对象（data access object，DAO）是为某种类型的数据库或其他持久性机制提供一个抽象接口的对象。通过映射应用程序对持久层的调用，DAO提供一些特定的数据操作，而无需暴露数据库细节。

什么是 DAO：
https://www.leiue.com/2494

UserMapper接口

编写用户 dao 接口，提供操作数据库的方法

1
2
3
4
5
6
7
8
9
/**
  数据访问层接口
 */
public interface UserMapper {
    /**
    * 查询所有用户
    */
    List<User> findAllUsers();
}

3、编写用户 dao 接口映射文件（UserMapper.xml）

用户 dao 接口映射文件与dao接口一同放在dao包下。

UserMapper.xml

1、配置要映射的dao接口位置（dao接口路径）
2、映射的dao接口方法
3、方法返回值类型（封装数据的实体类）
4、方法要执行的SQL语句

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
<?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">
<!--
    须知：一个映射文件就对应一个接口，但一个接口是可以有多个映射文件的
    但一般都是一对一关系：一个接口对应一个映射文件

    mapper标签常用属性
           namespace：设置接口的位置：接口的类全名字符串
-->
<mapper namespace="com.itheima.dao.UserMapper">
    <!-- select标签作用：用来执行查询SQL语句
            id属性：对应接口中方法的名称
            resultType属性：设置方法返回值类型
                * 如果是集合类型，则resultType设置集合元素的类型即可
                * 如果引用类型(非集合)，则直接引用类型的类全名字符串即可

            标签体：要执行的SQL语句
    -->
    <select id="findAllUsers" resultType="com.itheima.entity.User">
        select * from user;
    </select>
</mapper>

4、在sqlMapConfig.xml中加载接口映射配置文件

在sqlMapConfig.xml中增加接口映射

SqlMapConfig.xml

1
2
3
4
5
6
7
<mappers>
    <!--mapper标签的作用：关联接口映射文件
          resource属性：关联本地的接口映射文件
          url属性：关联互联网上的接口映射文件，比如：http://www.itcast.cn/xxx.xml
    -->
    <mapper resource="com/itheima/dao/UserMapper.xml"></mapper>
</mappers>

小结

使用Mybatis框架以后数据访问层还用写实现类吗？那么如何操作？
答：不需要有接口实现类，需要有接口映射文件

开发流程实现（8）编写测试代码

1、通过Resources类，加载sqlMapConfig.xml，得到文件输入流对象

2、实例化会话工厂创建类SqlSessionFactoryBuilder

3、通过会话工厂创建类，读取上面的输入流，得到会话工厂SqlSessionFactory类

4、使用SqlSessionFactory对象，创建SqlSession对象
a、它相当于JDBC中的Connection对象，提供了操作数据库的CRUD方法
b、它提供了一个getMapper()方法，获取接口的实现对象。

5、获取接口 UserMapper 实现类对象

6、执行数据库的查询操作，输出用户信息

7、关闭会话，释放资源。

测试类代码

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
/**
 * 测试类
 */
public class TestUserMapper {


    @Test
    public void testFindAllUsers() throws Exception{
        // 1. 通过Resources类，加载sqlMapConfig.xml，得到文件输入流对象
        // Resources类专门从src下加载资源文件并获得输入流
        InputStream in = Resources.getResourceAsStream("sqlMapConfig.xml");
        // 2. 实例化会话工厂创建类SqlSessionFactoryBuilder
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        // 3. 通过会话工厂创建类，读取上面的输入流，得到会话工厂SqlSessionFactory类
        SqlSessionFactory sqlSessionFactory = builder.build(in);

        // 4. 使用SqlSessionFactory对象，创建SqlSession对象 (等价于Connection对象)
        SqlSession sqlSession = sqlSessionFactory.openSession();
        // a) 它相当于JDBC中的Connection对象，提供了操作数据库的CRUD方法
        // b) 它提供了一个getMapper()方法，获取接口的实现对象。
        // 5. 获取接口 UserMapper 实现类对象
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        System.out.println("userMapper ===>" + userMapper);
        // 6. 执行数据库的查询操作，输出用户信息
        List<User> list = userMapper.findAllUsers();
        for (User user : list) {
            System.out.println(user);
        }
        // 7. 关闭会话，释放资源。
        sqlSession.close();
    }
}

测试效果

在这里插入图片描述
UserMapper 这个对象是由 mybatis 生成的代理类
在这里插入图片描述

Mybatis入门案例项目结构

在这里插入图片描述