快速教程之 MyBatis（二）

最新推荐文章于 2024-08-09 03:57:56 发布

haogeshuai1981

最新推荐文章于 2024-08-09 03:57:56 发布

阅读量176

点赞数

分类专栏： J2EE框架课程

本文链接：https://blog.csdn.net/haogeshuai1981/article/details/80267813

版权

J2EE框架课程专栏收录该内容

6 篇文章 0 订阅

订阅专栏

1 前言

在快速教程之 MyBatis（一）中，咱们已经初步搭建了 MyBatis 框架，实现了查询所有记录的功能，并用 JUnit 进行了单元测试。接下来，咱们继续体验 MyBatis 框架，并实现增加、修改,删除和模糊查询等四个功能。

2 示例

老规矩，首先给出项目结构图：
这里写图片描述
在实现以下三个功能的时候，咱们需要修改的地方其实并不多，只需要修改两个地方就可以啦，分别是映射文件 PersonMapper.xml 和测试类 Mybatis_demoTest.java。

2.1 增加

第一步：在映射文件 UserMapper.xml 中添加 insert 的 SQL 语句

   <!--插入功能-->
    <insert id="insert" parameterType="com.hwua.entity.Person">
        insert into person values(#{id},#{name},#{age})
    </insert>

第二步：在测试类 Mybatis_demoTest 中添加 testInsert 方法

 @Test
    public void testInsert() throws IOException {
        /**
         *  1、获得 SqlSessionFactory
         *  2、获得 SqlSession
         *  3、调用在 mapper 文件中配置的 SQL 语句
         */
        String resource = "mybatis-config.xml";
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream(resource));
        SqlSession session = sqlSessionFactory.openSession();/*把它看成一个Connection链接对象*/
        Person p = new Person(null,"wangwu",18);
        try {
           session.insert("com.hwua.entity.PersonMapper.insert",p);
           session.commit();//手动提交
        } finally {
            session.close();//关闭session对象
        }

    }

2.2 修改

第一步：在映射文件 PersonMapper.xml 中添加 update 的 SQL 语句

   <!--更新操作-->
    <update id="update" parameterType="com.hwua.entity.Person">
        update person set name = #{name},age = #{age} where id = #{id}
    </update>

第二步：在测试类 Mybatis_demoTest 中添加 testUpdate 方法

@Test
    public void testUpdate() throws IOException {
        /**
         *  1、获得 SqlSessionFactory
         *  2、获得 SqlSession
         *  3、调用在 mapper 文件中配置的 SQL 语句
         */
        String resource = "mybatis-config.xml";
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream(resource));
        SqlSession session = sqlSessionFactory.openSession();/*把它看成一个Connection链接对象*/

        try {
            Person p = session.selectOne("com.hwua.entity.PersonMapper.findOne",2);
            p.setName("chenhao");
            p.setAge(37);
            session.update("com.hwua.entity.PersonMapper.update",p);
            session.commit();//手动提交
        } finally {
            session.close();//关闭session对象
        }

    }

2.3 删除

第一步：在映射文件PersonMapper.xml 中添加 delete 的 SQL 语句

<!--删除功能-->
    <delete id="delete" parameterType="integer">
        delete from person where id=#{id}
    </delete>

第二步：在测试类 Mybatis_demoTest 中添加 testDeleteById 方法

 @Test
    public void testDelete() throws IOException {
        /**
         *  1、获得 SqlSessionFactory
         *  2、获得 SqlSession
         *  3、调用在 mapper 文件中配置的 SQL 语句
         */
        String resource = "mybatis-config.xml";
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream(resource));
        SqlSession session = sqlSessionFactory.openSession();/*把它看成一个Connection链接对象*/
        try {
            session.delete("com.hwua.entity.PersonMapper.delete",1);
            session.commit();//手动提交
        } finally {
            session.close();//关闭session对象
        }

    }

3 完整代码

第一部分：核心配置文件 mybatis-config.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>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/><!--事务管理类型-->
            <dataSource type="POOLED"><!--数据源类型，使用mybatis自带的连接池-->
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/test?characterEncoding=utf-8"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="com/hwua/entity/PersonMapper.xml"/><!--加载映射文件-->
    </mappers>
</configuration>

第二部分：实体类（Person）

package com.hwua.entity;

/**
 * create by 豪哥帅 on 2018.5.10
 */
public class Person {
    private Integer id;
    private String name;
    private Integer age;

    public Person() {
    }

    public Person(Integer id, String name, Integer age) {
        this.id = id;
        this.name = name;
        this.age = 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 Integer getAge() {
        return age;
    }

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

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

第三部分：映射文件 PersonMapper.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="com.hwua.entity.PersonMapper"> <!-- 命名空间，名字可以随意起，只要不冲突即可 -->
    <!--当表中的字段和实体类的成员变量名字一致的时候可以省略,此例子可以省略-->
    <resultMap id="personMap" type="com.hwua.entity.Person">
        <id property="id" column="ID"></id><!--id代表主键 property：pojo类中的属性，column是表中的字段名-->
        <result property="name" column="NAME"></result>
        <result property="age" column="AGE"></result>
    </resultMap>

    <!--id:设置调用的方法名，resultType设置返回的数据类型-->
    <select id="findAll" resultType="com.hwua.entity.Person">
    SELECT * FROM PERSON /*书写sql语句*/
  </select>

    <!--查询指定的人-->
    <select id="findOne" parameterType="integer" resultType="com.hwua.entity.Person">
        select id,name,age from person where id = #{id}
    </select>

    <!--模糊查询-->
    <select id="findLike" parameterType="string" resultType="com.hwua.entity.Person">
        select id,name,age from person where name like #{name}
    </select>

    <!--插入功能-->
    <insert id="insert" parameterType="com.hwua.entity.Person">
        insert into person values(#{id},#{name},#{age})
    </insert>

    <!--更新操作-->
    <update id="update" parameterType="com.hwua.entity.Person">
        update person set name = #{name},age = #{age} where id = #{id}
    </update>

    <!--删除功能-->
    <delete id="delete" parameterType="integer">
        delete from person where id=#{id}
    </delete>

</mapper>

第四部分：测试类MyBatis_demoTest）

package com.hwua.test;

import com.hwua.entity.Person;
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.Test;

import java.io.IOException;
import java.util.List;

public class MyBatis_demoTest {
    @Test
    public void testFindAll() throws IOException {
        /**
         *  1、获得 SqlSessionFactory
         *  2、获得 SqlSession
         *  3、调用在 mapper 文件中配置的 SQL 语句
         */
        String resource = "mybatis-config.xml";
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream(resource));
        SqlSession session = sqlSessionFactory.openSession();/*把它看成一个Connection链接对象*/
        try {
            List<Person> pList = session.selectList("com.hwua.entity.PersonMapper.findAll");
            for (Person person : pList) {
                System.out.println(person);
            }
        } finally {
            session.close();//关闭session对象
        }

    }

    /*测试查询指定的用户*/
    @Test
    public void testFindOne() throws IOException {
        /**
         *  1、获得 SqlSessionFactory
         *  2、获得 SqlSession
         *  3、调用在 mapper 文件中配置的 SQL 语句
         */
        String resource = "mybatis-config.xml";
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream(resource));
        SqlSession session = sqlSessionFactory.openSession();/*把它看成一个Connection链接对象*/
        try {
           Person p = session.selectOne("com.hwua.entity.PersonMapper.findOne",1);
            System.out.println(p);
        } finally {
            session.close();//关闭session对象
        }

    }

    @Test
    public void testInsert() throws IOException {
        /**
         *  1、获得 SqlSessionFactory
         *  2、获得 SqlSession
         *  3、调用在 mapper 文件中配置的 SQL 语句
         */
        String resource = "mybatis-config.xml";
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream(resource));
        SqlSession session = sqlSessionFactory.openSession();/*把它看成一个Connection链接对象*/
        Person p = new Person(null,"wangwu",18);
        try {
           session.insert("com.hwua.entity.PersonMapper.insert",p);
           session.commit();//手动提交
        } finally {
            session.close();//关闭session对象
        }

    }

    @Test
    public void testUpdate() throws IOException {
        /**
         *  1、获得 SqlSessionFactory
         *  2、获得 SqlSession
         *  3、调用在 mapper 文件中配置的 SQL 语句
         */
        String resource = "mybatis-config.xml";
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream(resource));
        SqlSession session = sqlSessionFactory.openSession();/*把它看成一个Connection链接对象*/

        try {
            Person p = session.selectOne("com.hwua.entity.PersonMapper.findOne",2);
            p.setName("chenhao");
            p.setAge(37);
            session.update("com.hwua.entity.PersonMapper.update",p);
            session.commit();//手动提交
        } finally {
            session.close();//关闭session对象
        }

    }

    @Test
    public void testDelete() throws IOException {
        /**
         *  1、获得 SqlSessionFactory
         *  2、获得 SqlSession
         *  3、调用在 mapper 文件中配置的 SQL 语句
         */
        String resource = "mybatis-config.xml";
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream(resource));
        SqlSession session = sqlSessionFactory.openSession();/*把它看成一个Connection链接对象*/
        try {
            session.delete("com.hwua.entity.PersonMapper.delete",1);
            session.commit();//手动提交
        } finally {
            session.close();//关闭session对象
        }

    }

    @Test
    public void testLike() throws IOException {
        /**
         *  1、获得 SqlSessionFactory
         *  2、获得 SqlSession
         *  3、调用在 mapper 文件中配置的 SQL 语句
         */
        String resource = "mybatis-config.xml";
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream(resource));
        SqlSession session = sqlSessionFactory.openSession();/*把它看成一个Connection链接对象*/
        try {
            List<Person> pList = session.selectList("com.hwua.entity.PersonMapper.findLike", "%c%");
            for (Person person : pList) {
                System.out.println(person);
            }
        } finally {
            session.close();//关闭session对象
        }

    }
}

小结：

mybatis实现模糊查询的两种方式：
1、使用#{}

    <!--模糊查询-->
    <select id="findLike" parameterType="string" resultType="com.hwua.entity.Person">
        select id,name,age from person where name like #{name}
    </select>

   try {
            List<Person> pList = session.selectList("com.hwua.entity.PersonMapper.findLike", "%c%");
            for (Person person : pList) {
                System.out.println(person);
            }
        } finally {
            session.close();//关闭session对象
        }

2、使用${}

    <!--模糊查询-->
    <select id="findLike" parameterType="string" resultType="com.hwua.entity.Person">
        select id,name,age from person where name like '%${value}%'
        /*如果传入的参数是简单数据类型，${}里面必须写value*/
    </select>

 SqlSession session = sqlSessionFactory.openSession();/*把它看成一个Connection链接对象*/
        try {
            List<Person> pList = session.selectList("com.hwua.entity.PersonMapper.findLike", "c");
            for (Person person : pList) {
                System.out.println(person);
            }
        } finally {
            session.close();//关闭session对象
        }

#{}和${}区别？
#{}表示一个占位符号，通过#{}可以实现preparedStatement向占位符中设置值，自动进行java类型和jdbc类型转换。#{}可以有效防止sql注入。 #{}可以接收简单类型值或pojo属性值。如果parameterType传输单个简单类型值，#{}括号中可以是value或其它名称。
${}表示拼接sql串，通过$ {}可以将parameterType 传入的内容拼接在sql中且不进行jdbc类型转换， ${}可以接收简单类型值或pojo属性值，如果parameterType传输单个简单类型值，$ {}括号中只能是value。

parameterType和resultType
parameterType：指定输入参数类型，mybatis通过ognl从输入对象中获取参数值拼接在sql中。
resultType：指定输出结果类型，mybatis将sql查询结果的一行记录数据映射为resultType指定类型的对象。如果有多条数据，则分别进行映射，并把对象放到容器List中

selectOne和selectList
selectOne查询一条记录，如果使用selectOne查询多条记录则抛出异常：

org.apache.ibatis.exceptions.TooManyResultsException: Expected one result (or null) to be returned by selectOne(), but found: 3
    at org.apache.ibatis.session.defaults.DefaultSqlSession.selectOne(DefaultSqlSession.java:70)

selectList可以查询一条或多条记录。

MySql 返回自增主键

   <!--mysql返回自增主键-->
    <insert id="savePerson" parameterType="com.hwua.entity.Person">
        /*
        selectKey 标签实现查询返回主键值
        keyColumn 表中的主键字段名
        keyProperty 对应pojo类中主键属性
        resultType 设置返回主键的数据类型
        order 设置在执行insert语句前执行查询主键的sql，
              还是在执行insert语句之后执行查询主键的sql，值可以是AFTER或BEFORE
        */
        <selectKey keyColumn="id" keyProperty="id" order="AFTER" resultType="int">
            select last_insert_id()
            /*LAST_INSERT_ID():是mysql的函数，返回auto_increment自增列新记录id值*/
        </selectKey>
        insert into person(id,name,age) values(#{id},#{name},#{age})
    </insert>

        String resource = "mybatis-config.xml";
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream(resource));
        SqlSession session = sqlSessionFactory.openSession();/*把它看成一个Connection链接对象*/
        Person p = new Person(null,"xiaohong",35);
        try {

            int res = session.insert("com.hwua.entity.PersonMapper.savePerson", p);
            System.out.println(res);
            session.commit();
            System.out.println(p.getId());
        } finally {
            session.close();//关闭session对象
        }

mysql返回UUID主键值

 <!--mysql返回UUID主键值-->
    <insert id="saveUser" parameterType="com.hwua.entity.User">
        /*
        selectKey 标签实现查询返回主键值
        keyColumn 表中的主键字段名
        keyProperty 对应pojo类中主键属性
        resultType 设置返回主键的数据类型
        order 设置在执行insert语句前执行查询主键的sql，
        还是在执行insert语句之后执行查询主键的sql，值可以是AFTER或BEFORE
        */
        <selectKey keyColumn="no" keyProperty="no" order="BEFORE" resultType="string">
            select uuid()
            /*uuid():是mysql的函数，返回唯一的一个字符串*/
        </selectKey>
        insert into user(no,name) values(#{no},#{name})
    </insert>

        String resource = "mybatis-config.xml";
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream(resource));
        SqlSession session = sqlSessionFactory.openSession();/*把它看成一个Connection链接对象*/
        User user = new User();
        user.setName("chenhao");
        try {

            int res = session.insert("com.hwua.entity.PersonMapper.saveUser", user);
            System.out.println(res);
            session.commit();
            System.out.println(user.getNo());
        } finally {
            session.close();//关闭session对象
        }

Mybatis解决jdbc编程的问题
1、数据库连接创建、释放频繁造成系统资源浪费从而影响系统性能，如果使用数据库连接池可解决此问题。
解决：在SqlMapConfig.xml中配置数据连接池，使用连接池管理数据库链接。
2、Sql语句写在代码中造成代码不易维护，实际应用sql变化的可能较大，sql变动需要改变java代码。
解决：将Sql语句配置在XXXXmapper.xml文件中与java代码分离。
3、向sql语句传参数麻烦，因为sql语句的where条件不一定，可能多也可能少，占位符需要和参数一一对应。
解决：Mybatis自动将java对象映射至sql语句，通过statement中的parameterType定义输入参数的类型。
4、对结果集解析麻烦，sql变化导致解析代码变化，且解析前需要遍历，如果能将数据库记录封装成pojo对象解析比较方便。
解决：Mybatis自动将sql执行结果映射至java对象，通过statement中的resultType定义输出结果的类型。

mybatis与hibernate不同
Mybatis和hibernate不同，它不完全是一个ORM框架，因为MyBatis需要程序员自己编写Sql语句。mybatis可以通过XML或注解方式灵活配置要运行的sql语句，并将java对象和sql语句映射生成最终执行的sql，最后将sql执行的结果再映射生成java对象。

Mybatis学习门槛低，简单易学，程序员直接编写原生态sql，可严格控制sql执行性能，灵活度高，非常适合对关系数据模型要求不高的软件开发，例如互联网软件、企业运营类软件等，因为这类软件需求变化频繁，一但需求变化要求成果输出迅速。但是灵活的前提是mybatis无法做到数据库无关性，如果需要实现支持多种数据库的软件则需要自定义多套sql映射文件，工作量大。

Hibernate对象/关系映射能力强，数据库无关性好，对于关系模型要求高的软件（例如需求固定的定制化软件）如果用hibernate开发可以节省很多代码，提高效率。但是Hibernate的学习门槛高，要精通门槛更高，而且怎么设计O/R映射，在性能和对象模型之间如何权衡，以及怎样用好Hibernate需要具有很强的经验和能力才行。
总之，按照用户的需求在有限的资源环境下只要能做出维护性、扩展性良好的软件架构都是好架构，所以框架只有适合才是最好。