mybatis 3 入门

mybatis 3.5

简介

mybatis是 MyBatis SQL Mapper Framework for Java （sql映射框架）

1）sql mapper ：sql映射
可以把数据库表中的一行数据 映射为 一个java对象。即一行数据可以看做是一个java对象。操作这个对象，就相当于操作表中的数据。
2）Data Access Objects（DAOs）：数据访问
对数据库执行增删改查。

mybatis提供了哪些功能：

1. 提供了创建Connection ,Statement, ResultSet的能力，不用开发人员创建这些对象了
2. 提供了执行sql语句的能力，不用你执行sql
3. 提供了循环sql，把sql的结果转为java对象，List集合的能力
   while (rs.next()) {
   Student stu = new Student();
   stu.setId(rs.getInt(“id”));
   stu.setName(rs.getString(“name”));
   stu.setAge(rs.getInt(“age”));
   //从数据库取出数据转为 Student 对象，封装到 List 集合
   stuList.add(stu);
   }
4. 提供了关闭资源的能力，不用你关闭Connection, Statement, ResultSet

开发人员做的是： 提供sql语句

开发人员提供sql语句————mybatis处理sql————开发人员得到List集合或java对象（表中的数据）

总结：
mybatis是一个sql映射框架，提供的数据库的操作能力。增强的JDBC,使用mybatis让开发人员集中精神写sql就可以了，不必关心Connection,Statement,ResultSet的创建，销毁，sql的执行。

回顾JDBC

    public void findStudent() {
   
        Connection conn = null;
        Statement stmt = null;
        ResultSet rs = null;
        try {
   
            //注册 mysql 驱动
            Class.forName("com.mysql.jdbc.Driver");
            //连接数据的基本信息 url ，username，password
            String url = "jdbc:mysql://localhost:3306/springdb";
            String username = "root";
            String password = "123456";
            //创建连接对象
            conn = DriverManager.getConnection(url, username, password);
            //保存查询结果
            List<Student> stuList = new ArrayList<>();
            //创建 Statement, 用来执行 sql 语句
            stmt = conn.createStatement();
            //执行查询，创建记录集，
            rs = stmt.executeQuery("select * from student");
            while (rs.next()) {
   
                Student stu = new Student();
                stu.setId(rs.getInt("id"));
                stu.setName(rs.getString("name"));
                stu.setAge(rs.getInt("age"));
                //从数据库取出数据转为 Student 对象，封装到 List 集合
                stuList.add(stu);
            }
        } catch (Exception e) {
   
            e.printStackTrace();
        } finally {
   
            try {
   
                //关闭资源
                if (rs != null) 
                {
   
                    rs.close();
                }
                if (stmt != null) {
   
                    stmt.close();
                }
                if (conn != null) {
   
                    conn.close();
                }
            } catch (Exception e) {
   
                e.printStackTrace();
            }
        }
    }

使用JDBC的缺陷

1. 代码比较多，开发效率低

2. 需要关注 Connection ,Statement, ResultSet 对象创建和销毁

3. 对 ResultSet 查询的结果，需要自己封装为 List

4. 重复的代码比较多些

5. 业务代码和数据库的操作混在一起

快速开始：IDEA方式创建第一个MyBatis项目

实现步骤 ∶

1.新建的student表
2.新建web maven工程、加入maven的mybatis坐标、mysal驱动的坐标 
3.创建实体类，Student类--保存表中的一行数据的 
4.创建持久层的dao接口，定义操作数据库的方法 
5.创建一个mybatis使用的配置文件——sql映射xml文件∶ 写sql语句的。一般一个表一个sql映射文件
    5.1 在接口所在IDE目录中
    5.2 文件名称和接口保持一致
    注意：需要加上maven的资源拷贝插件（Maven在打包的时候默认只将src/main/resource里的配置文件（非.java文件）打包编译到 target/classes里。）
6.创建mybatis的主配置文件∶一个项目就一个主配置文件。主配置文件提供了数据库的连接信息和sql映射文件的位置信息 
7.测试。创建使用mybatis类，通过mybatis访问数据库

案例：

1.新建的student表

CREATE TABLE `student` (
 `id` int(11) NOT NULL ,
 `name` varchar(16) DEFAULT NULL,
 `email` varchar(16) DEFAULT NULL,
 `age` int(3) DEFAULT NULL,
 PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

2.新建web maven工程

加入maven的mybatis坐标、mysal驱动的坐标 、maven的资源拷贝插件

    <dependencies>
        <!--mybatis依赖-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.1</version>
        </dependency>
        <!--mysql驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.9</version>
        </dependency>
    </dependencies>

    <build>
        <!--        资源拷贝插件 -->
        <resources>
            <!--            把  resource下 的配置文件打包到classes-->
            <resource>
                <directory>src/main/resources</directory>
            </resource>
            <!--            把  非resource下 的配置文件打包到classes-->
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                </includes>
            </resource>
        </resources>
    </build>

3.创建实体类，Student类–保存表中的一行数据的

public class Student {
   
    //定义属性， 目前要求是属性名和列名一样。
    private Integer id;
    private String name;
    private String email;
    private Integer age;

    public Integer getId() {
   
        return id;
    }

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

    public String getName() {
   
        return name;
    }

    public void setName(String name) {
   
        this.name = name;
    }

    public String getEmail() {
   
        return email;
    }

    public void setEmail(String email) {
   
        this.email = email;
    }

    public Integer getAge() {
   
        return age;
    }

    public void setAge(Integer age) {
   
        this.age = age;
    }

    @Override
    public String toString() {
   
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", email='" + email + '\'' +
                ", age=" + age +
                '}';
    }
}

4.创建持久层的dao接口，定义操作数据库的方法

public interface StudentDao {
   

    //查询student表的所有的数据
    public List<Student> selectStudents();
}

5.创建一个sql映射xml文件

<?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="study.dao.StudentDao">

    <select id="selectStudents" resultType="study.domain.Student" >
        select id,name,email,age from student order by id
    </select>
</mapper>

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">
<mapper namespace="study.dao.StudentDao">
    <!--
       select:表示查询操作。
       id: 你要执行的sql语法的唯一标识， mybatis会使用这个id的值来找到要执行的sql语句
           可以自定义，但是要求你使用接口中的方法名称。

       resultType:表示结果类型的， 是sql语句执行后得到ResultSet,遍历这个ResultSet得到java对象的类型。
          值写的类型的全限定名称
    -->
    <select id="selectStudents" resultType="study.domain.Student" >
        select id,name,email,age from student order by id
    </select>
</mapper>
<!--
  sql映射文件（sql mapper）： 写sql语句的， mybatis会执行这些sql
  1.指定约束文件
     <!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

    mybatis-3-mapper.dtd是约束文件的名称， 扩展名是dtd的。

  2.约束文件作用：  限制，检查在当前文件中出现的标签，属性必须符合mybatis的要求。

  3.mapper 是当前文件的根标签，必须的。
      namespace：叫做命名空间，唯一值的， 可以是自定义的字符串。
                 要求你使用dao接口的全限定名称。

  4.在当前文件中，可以使用特定的标签，表示数据库的特定操作。
   <select>:表示执行查询，select语句
   <update>:表示更新数据库的操作， 就是在<update>标签中 写的是update sql语句
   <insert>:表示插入， 放的是insert语句
   <delete>:表示删除， 执行的delete语句
-->

6.创建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>

    <environments default="mydev">
        <environment id="mydev">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf-8"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>

    <mappers>
        <mapper resource="study/dao/StudentDao.xml"/>
    </mappers>
</configuration>

配置文件解析：

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

    <!--环境配置： 数据库的连接信息
        default:必须和某个environment的id值一样。
        告诉mybatis使用哪个数据库的连接信息。也就是访问哪个数据库
    -->
    <environments default="mydev">
        <!-- environment : 一个数据库信息的配置， 环境
             id:一个唯一值，自定义，表示环境的名称。
        -->
        <environment id="mydev">
            <!--
               transactionManager ：mybatis的事务类型
                   type: JDBC(表示使用jdbc中的Connection对象的commit，rollback做事务处理)
            -->
            <transactionManager type="JDBC"/>
            <!--
               dataSource:表示数据源，连接数据库的
                  type：表示数据源的类型， POOLED表示使用连接池
            -->
            <dataSource type="POOLED">
                <!--
                   driver, user, username, password 是固定的，不能自定义。
                -->
                <!--数据库的驱动类名-->
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <!--连接数据库的url字符串-->
                <!--支持中文的 url：-->
                <property name="url" value="jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf-8"/>
                <!--访问数据库的用户名-->
                <property name="username" value="root"/>
                <!--密码-->
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>

    <!-- sql mapper(sql映射文件)的位置-->
    <mappers>
        <!--一个mapper标签指定一个文件的位置。
           从类路径开始的路径信息。  target/clasess(类路径)  编译后有个target文件夹，下面的clasess目录
        -->
        <mapper resource="study/dao/StudentDao.xml"/>
    </mappers>
</configuration>
<!--
   mybatis的主配置文件： 主要定义了数据库的配置信息， sql映射文件的位置

   1. 约束文件
   <!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">

    mybatis-3-config.dtd：约束文件的名称

  2. configuration 根标签。
-->

7.测试。创建使用mybatis类，通过mybatis访问数据库

public class MyApp {
   

    public static void main(String[] args) throws IOException {
   
        //访问mybatis读取student数据
        //1.定义mybatis主配置文件的名称, 从类路径的根开始（target/clasess）
        String config="mybatis.xml";

        //2.读取这个config表示的文件
        InputStream in = Resources.getResourceAsStream(config);

        //3.创建了SqlSessionFactoryBuilder对象
        SqlSessionFactoryBuilder builder  = new SqlSessionFactoryBuilder();

        //4.创建SqlSessionFactory对象
        SqlSessionFactory factory = builder.build(in);

        //5.获取SqlSession对象，从SqlSessionFactory中获取SqlSession
        SqlSession sqlSession = factory.openSession();

        //6.【重要】指定要执行的sql语句的标识。  sql映射文件中的namespace + "." + 标签的id值
        //String sqlId = "study.dao.StudentDao" + "." + "selectStudents