JAVA后端框架--【Mybatis】

框架

框架就是对技术的封装，将基础的技术进行封装，让程序员快速使用，提高开发效率

java后端框架

mybatis

对jdbc进行封装

背景介绍

mybatis是apache下面的一个开源项目，名为ibatis，2010年开发团队转移到谷歌旗下，更名为mybatis

mybatis是一个优秀的数据持久性框架（dao层 数据访问层 数据持久性）

对jdbc进行封装，避免了jdbc中手动设置参数，手动映射结果的操作

mybatis将jdbc中接口进行封装，提供了它自己的类和接口实现。

mybatis可以使用xml配置和注解的方式，将数据库中记录自动映射到java对象中，

是一种orm实现（对象关系映射）将可以自动映射到对象中的这种框架，也称为orm框架

mybatis还提供了动态sql和数据缓存功能

mybatis搭建

1.创建mven项目

2.导入mybatis依赖的jar

 <dependency>
           <groupId>org.mybatis</groupId>
           <artifactId>mybatis</artifactId>
           <version>3.4.2</version>
       </dependency>

3.创建一个全局的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>
    <settings>
        <setting name="logImpl" value="STDOUT_LOGGING"/>
    </settings>
    <!--为类配置别名-->
    <typeAliases>
        <package name="com.wph.mybatis.model"/>
    </typeAliases>

    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver" />
                <property name="url" value="jdbc:mysql://127.0.0.1:3306/ssmdb?serverTimezone=Asia/Shanghai" />
                <property name="username" value="root" />
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>

    <!--注册映射文件-->
    <mappers>
        <mapper resource="Mappers/AdminMapper.xml"></mapper>
    </mappers>
</configuration>

4.创建数据库，创建表

create database ssmdb

create table admin(
id int primary key auto_increment,
account varchar(10),
password varchar(10),
gender varchar(10)
)

5.创建一个访问接口，定义方法

package com.wph.mybatis.dao;

import com.wph.mybatis.model.Admin;
import org.apache.ibatis.annotations.Param;

public interface AdminDao {
    Admin findAdminbyid(int id);

    Admin findAdminbyAccount(String account);

    Admin login(@Param("acc") String account,@Param("pwd") String password);

    Admin login1(Admin admin);

    void deleteadmin(int id);

    void insert(Admin admin);

        void update(Admin admin);
}

6.创建接口对应映射文件

<?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.wph.mybatis.dao.AdminDao">
    <update id="update" parameterType="Admin">
        update admin set account=#{account},password=#{password},gender=#{gender} where id=#{id}
    </update>
    <select id="findAdminbyid" parameterType="int" resultType="Admin">
            select * from admin where id = #{id}
    </select>

    <select id="findAdminbyAccount" parameterType="String" resultType="Admin">
            select * from admin where account = #{account}
    </select>
    <select id="login" resultType="Admin">
        select * from admin where account=#{acc} and password =#{pwd}
    </select>
    <select id="login1" resultType="Admin">
        select * from admin where account=#{account} and password =#{password}
    </select>
    <delete id="deleteadmin" parameterType="int">
        delete from admin where id=#{id}
    </delete>

    <!--useGeneratedKeys="true" keyProperty="id" keyColumn="id"-->
    <insert id="insert" parameterType="Admin" >
        insert into admin(account,password,gender) values (#{account},#{password},#{gender})
    </insert>
</mapper>

7.测试 MyBatis

读取配置文件 Reader reader = Resources.getResourceAsReader("mybatis-config.xml"); 创建 SqlSessionFactory SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(reader);

创建 SqlSession SqlSession sqlSession = sessionFactory.openSession();

获得接口代理对象 sqlSession.getMapper(接口.class); sqlSession .close();

package com.wph.mybatis.Test;

import com.wph.mybatis.dao.AdminDao;
import com.wph.mybatis.model.Admin;
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 java.io.IOException;
import java.io.Reader;

public class test {
    public static void main(String[] args) throws IOException {
        //1.mybatis读取配置文件
        Reader reader= Resources.getResourceAsReader("mabiatis.xml");
        //2.创建SqlSeaaionFactory ,负责创建SqlSession对象
        SqlSessionFactory sqlSessionFactory=new SqlSessionFactoryBuilder().build(reader);
        //3.创建SqlSession对象
        SqlSession sqlSession=sqlSessionFactory.openSession();
        //创建接口的代理对象
        AdminDao adminDao =sqlSession.getMapper(AdminDao.class);
        Admin admin=adminDao.findAdminbyid(1);//让代理对象帮我们调用映射文件与此接口中相同名称的方法
        System.out.println(admin);
        sqlSession.close();//关闭会话对象
    }
}

关闭 API 接口说明 SqlSessionFactory 接口 使用 SqlSessionFactory 来创建 SqlSession,一旦创建 SqlSessionFactory 就 会在整个应用过程中始终存在。由于创建开销较大,所以没有理由去销毁再创建 它，一个应用运行中也不建议多次创建 SqlSessionFactory。 SqlSession 接口 Sqlsession 意味着创建与数据库链接会话，该接口中封装了对数据库操作的方 法，与数据库会话完成后关闭会话。

package com.wph.mybatis.Test;

import com.wph.mybatis.dao.AdminDao;
import com.wph.mybatis.model.Admin;
import com.wph.mybatis.util.MyBatisUtil;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

public class test3 {

    /*
    单元测试，程序员使用的测试方法，以方法为单位测试
    使用junit组件实现单元测试
    */
    @Test
    public  void  insert(){
        Admin admin=new Admin();
          admin.setAccount("aaa");
          admin.setPassword("123");
          admin.setGender("男");
        SqlSession sqlSession= MyBatisUtil.getSqlsession();
        AdminDao adminDao=sqlSession.getMapper(AdminDao.class);

        adminDao.insert(admin);
        sqlSession.commit();//提交数据库事务，当我们的程序代码执行没有任何问题时，再向数据库发送提交事务操作，数据库真正执行
                           //sql，出现异常则不提交，新增，修改，删除完毕后，都需要手动提交事务
        sqlSession.close();
        /*
        * 数据库事务：是数据库的一个管理机制，是对一次链接数据库过程的管理，
        *           保证一次操作中，执行的多条sql，要么都成功执行，要么都不执行
        * 转账： 链接到数据库
        *   1.先从A账户捡钱sql11
        *   其他代码逻辑（可能出现异常）
        * 2.再向B账户加钱 sql2
        * 提交事务  数据库才会真正的在数据库执行这一次操作中多条sql
        * */
    }

    @Test
    public void delete(){
        SqlSession sqlSession= MyBatisUtil.getSqlsession();
        AdminDao adminDao=sqlSession.getMapper(AdminDao.class);
        adminDao.deleteadmin(1);
        sqlSession.commit();
        sqlSession.close();

    }
    @Test
    public void update(){
        Admin admin=new Admin();
        admin.setAccount("ddd");
        admin.setPassword("666");
        admin.setGender("女");
        admin.setId(1);
        SqlSession sqlSession= MyBatisUtil.getSqlsession();
        AdminDao adminDao=sqlSession.getMapper(AdminDao.class);
        adminDao.update(admin);
    }
}

数据库连接池

链接数据库每次访问数据库时候，创建一个Cinnection,用完关闭，但是访问量大了后，每次都要创建新的连接对象，用完关闭，比较耗时

使用数据库连接池，在池（集合）中事先创建一些链接对象，用完不销毁，还回到池中这样就减小频繁创建销毁链接对象。

package com.wph.mybatis.Test;

import com.wph.mybatis.dao.AdminDao;
import com.wph.mybatis.model.Admin;
import com.wph.mybatis.util.MyBatisUtil;
import org.apache.ibatis.session.SqlSession;

public class test2 {
    public static void main(String[] args) {
        //SqlSession是每次与数据库链接会话对象，用完关闭
        SqlSession sqlSession= MyBatisUtil.getSqlsession();
        AdminDao adminDao=sqlSession.getMapper(AdminDao.class);
        adminDao.findAdminbyid(1);
        Admin admin=adminDao.findAdminbyAccount("admin");
        System.out.println(admin);
        //Admin admin=adminDao.login("admin", "111");
        //System.out.println(admin);
        /*Admin admin1=new Admin();
        admin1.setAccount("admin");
        admin1.setPassword("111");
        Admin admin2=adminDao.login1(admin1);*/
        sqlSession.close();//关闭链接对象，如果使用数据库连接功能，本质上没有关闭，回到池中
    }
}

增删改查

唯一标识" useGeneratedKeys="把新增加的主键赋值到自己定义的 keyProperty " keyProperty=" 接收主键的属性 parameterType="参数类型">

insert into admin(account,password)values(#{account},#{password})

<!--useGeneratedKeys="true" keyProperty="id" keyColumn="id"-->
    <insert id="insert" parameterType="Admin" >
        insert into admin(account,password,gender) values (#{account},#{password},#{gender})
    </insert>

修改 "唯一标识" parameterType="参数类型">

 <update id="update" parameterType="Admin">
        update admin set account=#{account},password=#{password},gender=#{gender} where id=#{id}
    </update>

update admin set account= #{account},password= #{password} where id= #{id}

删除 "唯一标识" parameterType="参数类型"> delete from admin where id= #{id}

 <delete id="deleteadmin" parameterType="int">
        delete from admin where id=#{id}
    </delete>

查询 唯一标识" resultType="返回结果集类型"> select * from admin where id= #{id}

 <resultMap id="adminMap" type="Admin">
        <id column="adminid" property="id"></id>
        <result column="account" property="account"></result>
    </resultMap>
    <select id="findadmin" resultMap="adminMap">
        select id adminid ,account from admin
    </select>

#{} 和${}区别

#{} 占位符，是经过预编译的,编译好 SQL 语句再取值,#方式能够防止 sql 注入

#{}：delete from admin where id=#{id}

结果: delete from admin where id = ?

${}会将将值以字符串形式拼接到 sql 语句,

${ }方式无法防止 Sql 注入 {}： delete from admin where id='{id}'

结果: delete from admin where id='1' 一般是#{ } 向 sql 传值使用, 而使用${ }向 sql 传列名

 <select id="login1" resultType="Admin">
        select * from admin where account=#{account} and password =#{password}
    </select>
    <select id="findbyid" parameterType="java.lang.String" resultType="java.lang.Integer">
        select id from admin where account = ${account}
    </select>
#{}  是占位符，是采用预编译方式向sql中传值，可以防止sql注入，如果我们往sql中传值，使用#{}

${} 是将内容直接拼接到sql语句中，一般不用于向sql中传值，一般用于向sql动态传递列名

区别：

底层实现不同

#{} 采用预编译方式，防止sql注入更加安全

${} 采用字符串拼接，直接将值拼接到sql中

使用场景不同

#{}一般用于向sql中列传值

${}一般用于向sql动态传递列 例如 排序时 order by 后面的列名是可以改变的

特殊处理定义 resultMap

(1). resutlMap 的 id 属性是 resutlMap 的唯一标识，本例中定义为 "adminResultMap"

(2). resutlMap 的 type 属性是映射的 POJO 类型

(3). id 标签映射主键，result 标签映射非主键

(4). property 设置对象属性名称，column 映射查询结果的列名称

多表关联处理结果集

resultMap 元素中 association ， collection 元素. Collection 关联元素处理一对多关联

public class Student {
    private int id;
    private String name;
    private int num;
    private  String gender;
    private int majorid;
    private  Major major;
}
--------------------------------------
public class Major {
    private  int id;
    private String name;
    private List<Student> students;
}
-------------------------------------
  <resultMap id="studentMap" type="Student">
        <id column="id" property="id"></id>
        <result column="num" property="num"></result>
        <result column="name" property="name"></result>
        <result column="gender" property="gender"></result>
        <!--映射关联数据 专业名称-->
        <association property="major" javaType="Major">
            <result column="mname" property="name"></result>
        </association>
    </resultMap>

    <select id="findStudentbyid" resultMap="studentMap">
        select s.id,s.num,s.name,s.gender,m.name mname
        from student s inner join major m on s.majorid=m.id where s.id =#{id}
    </select>
    <select id="findStudents" resultMap="studentMap">
 select s.id,s.num,s.name,s.gender,m.name mname
        from student s inner join major m on s.majorid=m.id </select>

<resultMap id="majorMap" type="Major">
    <id column="id" property="id"></id>
    <result column="name" property="name"></result>
    <collection property="students" javaType="list" ofType="Student">
        <result column="num" property="num"></result>
        <result column="sname" property="name"></result>
    </collection>
</resultMap>
    <select id="findmajorbyid" parameterType="int" resultMap="majorMap">
        select m.id,m.name,s.num,s.name sname
        from major m inner join student s on m.id =s.majorid where m.id=#{id}
    </select>

    <select id="findmajorall" parameterType="int" resultMap="majorMap">
        select m.id,m.name,s.num,s.name sname
        from major m inner join student s on m.id =s.majorid
    </select>

嵌套查询

将一个多表关联查询拆分为多次查询,先查询主表数据,然后查询关联表数据.

(1). select：指定关联查询对象的 Mapper Statement ID 为 findDeptByID

(2). column="dept_id"：关联查询时将 dept_id 列的值传入 findDeptByID， 并将 findDeptByID 查询的结果映射到 Emp 的 dept 属性中

(3).collection 和 association 都需要配置 select 和 column 属性,两者配置方法 相同

 <!--
    =============================================================
    关联查询方式2：嵌套查询  先查询主表（学生表）
    -->

    <resultMap id="studentMap1" type="Student">
        <id column="id" property="id"></id>
        <result column="num" property="num"></result>
        <result column="name" property="name"></result>
        <result column="gender" property="gender"></result>
        <association property="major" javaType="Major" select="findmajorid" column="majorid"></association>
    </resultMap>
    <select id="findbuid" resultMap="studentMap1">
        select id,num,name,gender,majorid from student where id=#{id} ;
    </select>
    <!--嵌套查询学生关联专业-->
    <select id="findmajorid" resultType="Major">
        select name from major where  id=#{majorid}
    </select>

  <resultMap id="majorMap1" type="Major">
        <id column="id" property="id"></id>
        <result column="name" property="name"></result>
        <collection property="students" javaType="list" ofType="Student" select="findStudents" column="id"></collection>
    </resultMap>
    <select id="findmajor" resultMap="majorMap1">
        select id,name from major
    </select>
    <select id="findStudents" resultType="Student">
        select num,name from student where majorid =#{id}
    </select>

Mybatis 动态 SQL

MyBatis 的一个强大的特性之一通常是它的动态 SQL 能力。

如果你有使用 JDBC 或其他 相似框架的经验,你就明白条件地串联 SQL 字符串在一起是多么 的痛苦,确保不能忘了空格或在列表的最后省略逗号。

动态 SQL 可以彻底处理 这种痛苦。

MyBatis 中用于实现动态 SQL 的元素主要有：

If wheretrim set choose (when, otherwise) foreach

<?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.wph.mybatis.dao.TeacherDao">
    <!--
    动态sql中添加逻辑判断
       可以在sql中添加逻辑判断
       if  test 属性条件成立 执行if 标签体，不成立就不执行
       where 标签 当where标签 if 语句有条件成立时，就会动态添加where关键字，
          还可以删除where后面紧跟着的关键字
    -->
  <!--  <select id="teachers" resultType="Teacher">
        select * from teacher
        <where>
            <if test="num!=null">
                num = #{num}
            </if>
            <if test="name!=null">
                and name=#{name}
            </if>
            <if test="gender!=null">
                and gender=#{gender}
            </if>
        </where>
    </select>-->

    <select id="teachers" resultType="Teacher">
        select * from teacher
       <trim prefix="where" prefixOverrides="and|or">
           <choose>
               <when test="name!=null">
                   name =#{name}
               </when>
               <otherwise>
                   name='王老师'
               </otherwise>
           </choose>
       </trim>
    </select>

    <select id="findTeacher" resultType="Teacher">
        select
        <foreach item="col" collection="list" separator=",">
            ${col}
        </foreach>
        from teacher
    </select>

    <update id="updateTeacher" parameterType="Teacher">
        update teacher
        <set>
            <if test="num!=null">
                num=#{num},
            </if>
            <if test="name!=null">
                name=#{name},
            </if>
            <if test="gender!=null">
                gender =#{gender}
            </if>
        </set>

        where id=#{id}
    </update>

    <delete id="deleteTeacher">
        delete from teacher where id in
        <foreach item="id" collection="array" open="(" separator="," close=")">
            ${col}
        </foreach>
        from teacher
    </delete>

    </mapper>

If 元素

if 标签可以对传入的条件进行判断

<where>元素会进行判断，如果它包含的标签中有返回值的话，它就插入一个 'where'。

此外，如果标签返回的内容是以 AND 或 OR 开头，它会剔除掉 AND 或 OR。

trim 元素 where 标签，其实用 trim 也可以表示,当 WHERE 后紧随 AND 或则 OR 的时候，就去除 AND 或者 OR。prefix 前缀，prefixOverrides 覆盖首部指定 内容

Set 元素可以把最后一个逗号去掉

• foreach 元素

主要用在构建 in 条件中，它可以在 SQL 语句中进行迭代一个集合。foreach 元素的属性主要有 item，index，collection，open，separator，close。

item 表示集合中每一个元素进行迭代时的别名，index 指定一个名字，用于 表示在迭代过程中，每次迭代到的位置，open 表示该语句以什么开始， separator 表示在每次进行迭代之间以什么符号作为分隔符，close 表示以什 么结束，在使用 foreach 的时候最关键的也是最容易出错的就是 collection 属性，该属性是必须指定的，但是在不同情况下，该属性的值是不一样的。 -- 如果传入的是单参数且参数类型是一个 List 的时候，collection 属 性值为 list -- 如果传入的是单参数且参数类型是一个 array 数组的时候， collection 的属性值为 array