学习Mybati（总结）

1，mybatis的简介

1.本是apache的一个开源项目iBatis,是一个基于Java的持久层框架。mybatis提供的持久层框架包括SQL Maps和Data Access Objects（DAOs）.

2.MyBatis 是一款优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。MyBatis 可以使用简单的 XML 或注解来配置和映射原生信息，将接口和 Java 的 POJOs(Plain Ordinary Java Object,普通的 Java对象)映射成数据库中的记录.

特点

• 简单易学：本身就很小且简单。没有任何第三方依赖，最简单安装只要两个jar文件+配置几个sql映射文件易于学习，易于使用，通过文档和源代码，可以比较完全的掌握它的设计思路和实现。

• 灵活：mybatis不会对应用程序或者数据库的现有设计强加任何影响。 sql写在xml里，便于统一管理和优化。通过sql语句可以满足操作数据库的所有需求。

• 解除sql与程序代码的耦合：通过提供DAO层，将业务逻辑和数据访问逻辑分离，使系统的设计更清晰，更易维护，更易单元测试。sql和代码的分离，提高了可维护性。

• 提供映射标签，支持对象与数据库的orm字段关系映射

• 提供对象关系映射标签，支持对象关系组建维护

• 提供xml标签，支持编写动态sql。

总体流程

1.加载配置并初始化

触发条件：加载配置文件

处理过程：将SQL的配置信息加载成为一个个MappedStatement对象（包括了传入参数映射配置、执行的SQL语句、结果映射配置），存储在内存中。

2.接收调用请求

触发条件：调用Mybatis提供的API

传入参数：为SQL的ID和传入参数对象

处理过程：将请求传递给下层的请求处理层进行处理。

3.处理操作请求

触发条件：API接口层传递请求过来

传入参数：为SQL的ID和传入参数对象

处理过程：

(A)根据SQL的ID查找对应的MappedStatement对象。

(B)根据传入参数对象解析MappedStatement对象，得到最终要执行的SQL和执行传入参数。

(C)获取数据库连接，根据得到的最终SQL语句和执行传入参数到数据库执行，并得到执行结果。

(D)根据MappedStatement对象中的结果映射配置对得到的执行结果进行转换处理，并得到最终的处理结果。

(E)释放连接资源。

4.返回处理结果将最终的处理结果返回。

 

功能架构

一般分为3层（API接口层，数据处理层，基础支撑层）

1.API接口层：提供给外部使用的接口API，开发人员通过这些本地API来操纵数据库。接口层一接收到调用请求就会调用数据处理层来完成具体的数据处理。

2.数据处理层：负责具体的SQL查找、SQL解析、SQL执行和执行结果映射处理等。它主要的目的是根据调用的请求完成一次数据库操作。

3.基础支撑层：负责最基础的功能支撑，包括连接管理、事务管理、配置加载和缓存处理，这些都是共用的东西，将他们抽取出来作为最基础的组件。为上层的数据处理层提供最基础的支撑。

 

框架架构

1)加载配置：配置来源于两个地方，一处是配置文件，一处是Java代码的注解，将SQL的配置信息加载成为一个

个MappedStatement对象（包括了传入参数映射配置、执行的SQL语句、结果映射配置），存储在内存中。

(2)SQL解析：当API接口层接收到调用请求时，会接收到传入SQL的ID和传入对象（可以是Map、JavaBean或者基本数据类型），Mybatis会根据SQL的ID找到对应的MappedStatement，然后根据传入参数对象对MappedStatement进行解析，解析后可以得到最终要执行的SQL语句和参数。

(3)SQL执行：将最终得到的SQL和参数拿到数据库进行执行，得到操作数据库的结果。

(4)结果映射：将操作数据库的结果按照映射的配置进行转换，可以转换成HashMap、JavaBean或者基本数据类型，并将最终结果返回。

 

集成

单独使用mybatis是有很多限制的（比如无法实现跨越多个session的事务），而且很多业务系统本来就是使用spring来管理的事务，因此mybatis最好与spring集成起来使用。

spring事务配置

1. <!--自动扫描业务包-->

2. <context:component-scanbase-package="com.xxx.service"/>

3. <!--数据源-->

4. <jee:jndi-lookupid="jndiDataSource"jndi-name="java:comp/env/jdbc/datasource"/>

5. <!--配置事务-->

6. <bean id="txManager"

7. class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

8. <propertyname="dataSource"ref="jndiDataSource"/>

9. </bean>

10. <!--配置基于注解的事物aop-->

11. <tx:annotation-driventransaction-manager="txManager"proxy-target-class="true"/>

介绍了这么多让我们开始mybatis的实战吧

首先我们先导入mybatis的maven环境；这里我们就选择人气较多的3.4.6了。

<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.4.6</version>
</dependency>

MySQL 依赖：

<dependency>
  <groupId>mysql</groupId>
  <artifactId>mysql-connector-java</artifactId>
  <version>5.1.40</version>
</dependency>
<!-- 引入log4j依赖 -->
<dependency>
  <groupId>log4j</groupId>
  <artifactId>log4j</artifactId>
  <version>1.2.12</version>
</dependency>

测试依赖：

<dependency>
  <groupId>junit</groupId>
  <artifactId>junit</artifactId>
  <version>4.12</version>
  <scope>test</scope>
</dependency>

实体代码简单的crud

这里的话是用的users表

//id
    private String id;
    //用户名
    private String uname;
    //密码
    private String upwd;

    public users() {
    }

    public users(String id, String uname, String upwd) {
        this.id = id;
        this.uname = uname;
        this.upwd = upwd;
    }

    public String getId() {
        return id;
    }

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

    public String getUname() {
        return uname;
    }

    public void setUname(String uname) {
        this.uname = uname;
    }

    public String getUpwd() {
        return upwd;
    }

    public void setUpwd(String upwd) {
        this.upwd = upwd;
    }

    @Override
    public String toString() {
        return "users{" +
                "id='" + id + '\'' +
                ", uname='" + uname + '\'' +
                ", upwd='" + upwd + '\'' +
                '}';
    }

接口方法

 //查询所有数据(条件查询)
    public List<users> FindAll(users users);
    //查询所有数据(分页)
    public List<users> FindAlls(Map map);
    //增加数据
    public int Add(users users);
    //修改数据
    public int Edit(users users);
    //删除数据
    public int Remove(users users);
    //批量删除数据
    public int Remove1(List<String> list);
    //根据id查询
    public  users FindBYid(users users);
    //获取总行数(分页用的)
    public int  rowscount(users users);

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.zx.mapper.IUser">
<!--查询sql语句-->
    <select id="FindAll" resultType="users" parameterType="users">
        SELECT  * FROM  users where uname like '%${uname}%';
    </select>
    <!--查询sql语句（分页）-->
    <select id="FindAlls" resultType="users" parameterType="java.util.Map">
        SELECT  * FROM  users  limit #{page},#{rows};
    </select>
    <!--查询sql语句（根据id查询）-->
    <select id="FindBYid" resultType="users" parameterType="users">
        SELECT  * FROM  users where id=#{id}
    </select>
    <!--增加sql语句-->
    <insert id="Add" parameterType="users">
        INSERT  into users(id,uname,upwd) VALUE (uuid(),#{uname},#{upwd})
    </insert>
    <!--修改sql语句（这种不太好一般用set  if标签）-->
    <update id="Edit" parameterType="users">
        UPDATE  users set uname=#{uname},upwd=#{upwd} where id=#{id}
          <!--UPDATE  users <set>-->
        <!--<if test="uname!=null">-->
          <!--and    uname=#{uname}-->
        <!--</if>-->
        <!--<if test="upwd!=null">-->
          <!--and  upwd=#{upwd}-->
        <!--</if>-->
    <!--</set>-->
        <!--where id=#{id}-->
    </update>

    <!-- 删除sql语句-->
    <delete id="Remove" parameterType="users">
       DELETE  from users where id=#{id}
    </delete>
    <!--查询总行数sql语句-->
    <select id="rowscount" resultType="java.lang.Integer" parameterType="users">
       SELECT  *,count(id) FROM  users where uname like '%${uname}%';
    </select>

    <!-- 批量删除sql语句 collection集合变量名 item元素名称 open 开始的地方 close 结束的位置 separator分割符-->
    <delete id="Remove1" parameterType="users" >
        DELETE  from users <where>
        <if test="list.size()>0">
            <foreach collection="list" item="str" open="(" close=")" separator="or">
                id=#{str}
            </foreach>
        </if>
    </where>
    </delete>
//批量删除in
    <!--<delete id="Remove1" parameterType="users" >-->
        <!--DELETE  from users <where>-->
        <!--<if test="list.size()>0">-->
            <!--<foreach collection="list" item="str" open="id in (" close=")" separator=",">-->
                <!--#{str}-->
            <!--</foreach>-->
        <!--</if>-->
    <!--</where>-->
    <!--</delete>-->

</mapper>

测试类：

import com.zx.mapper.IUser;
import com.zx.pojo.users;
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.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class UsersController {

    @Test
    public void FindAll() throws  Exception{
       //获取sqlSessionFactory工程
       //读取到你的xml文件
       //得到session
        //使用selectList查询
        //进行查询条件
        SqlSessionFactory sqlSessionFactory=new  SqlSessionFactoryBuilder().build(Resources.getResourceAsStream("mybatis.xml"));
        SqlSession session = sqlSessionFactory.openSession();
//        List<users> iu=session.selectList("FindAll");
//        for (users users:iu){
//            users.setUname("张三");
//            System.out.println(users.getId()+"____"+users.getUname()+"_____"+users.getUpwd());
//        }
      IUser iu= session.getMapper(IUser.class);
          users users=new users();
          users.setUname("李四");
        System.out.println(iu.FindAll(users));
          session.close();
    }



    @Test
    public void FindAlls() throws  Exception{
        //获取sqlSessionFactory工程
        //读取到你的xml文件
        //得到session
        //使用getMapper进行接口写入
        //map进行赋值
        SqlSessionFactory sqlSessionFactory=new  SqlSessionFactoryBuilder().build(Resources.getResourceAsStream("mybatis.xml"));
        SqlSession session = sqlSessionFactory.openSession();
        IUser iu= session.getMapper(IUser.class);
        Map<String,Object> map =new HashMap<>();
        map.put("page",0);
        map.put("rows",1);
        System.out.println(iu.FindAlls(map));
        session.close();
    }

    @Test
    public void FindBYid() throws  Exception{
        //获取sqlSessionFactory工程
        //读取到你的xml文件
        //得到session
        //使用getMapper进行接口写入
        SqlSessionFactory sqlSessionFactory=new  SqlSessionFactoryBuilder().build(Resources.getResourceAsStream("mybatis.xml"));
        SqlSession session = sqlSessionFactory.openSession();
        IUser iu= session.getMapper(IUser.class);
     users u=new users();
     u.setId("e7003c12-9ef6-11ea-a83b-98fa9b223a51");
        System.out.println(iu.FindBYid(u));
        session.close();
    }
    @Test
    public void rowscount() throws  Exception{
        //获取sqlSessionFactory工程
        //读取到你的xml文件
        //得到session
        //使用getMapper进行接口写入
        SqlSessionFactory sqlSessionFactory=new  SqlSessionFactoryBuilder().build(Resources.getResourceAsStream("mybatis.xml"));
        SqlSession session = sqlSessionFactory.openSession();
        IUser iu= session.getMapper(IUser.class);
        users u=new users();
        u.setId("李四");
        System.out.println(iu.rowscount(u));
        session.close();
    }

    @Test
    public void Add() throws  Exception{
        //获取sqlSessionFactory工程
        //读取到你的xml文件
        //得到session
        //使用getMapper进行接口写入

        SqlSessionFactory sqlSessionFactory=new  SqlSessionFactoryBuilder().build(Resources.getResourceAsStream("mybatis.xml"));
        SqlSession session = sqlSessionFactory.openSession();
        IUser iu= session.getMapper(IUser.class);
        users u=new users();
        u.setUname("张三");
        u.setUpwd("123456");
        session.commit();
        session.close();
    }
    @Test
    public void Edit() throws  Exception{
        //获取sqlSessionFactory工程
        //读取到你的xml文件
        //得到session
        //使用getMapper进行接口写入

        SqlSessionFactory sqlSessionFactory=new  SqlSessionFactoryBuilder().build(Resources.getResourceAsStream("mybatis.xml"));
        SqlSession session = sqlSessionFactory.openSession();
        IUser iu= session.getMapper(IUser.class);
        users u=new users();
        u.setUname("张三1");
        u.setUpwd("1234561");
        u.setId("e7003c12-9ef6-11ea-a83b-98fa9b223a51");
        session.commit();
        session.close();
    }

    @Test
    public void Remove() throws  Exception{
        //获取sqlSessionFactory工程
        //读取到你的xml文件
        //得到session
        //使用getMapper进行接口写入

        SqlSessionFactory sqlSessionFactory=new  SqlSessionFactoryBuilder().build(Resources.getResourceAsStream("mybatis.xml"));
        SqlSession session = sqlSessionFactory.openSession();
        IUser iu= session.getMapper(IUser.class);
        users u=new users();
        u.setId("e7003c12-9ef6-11ea-a83b-98fa9b223a51");
        session.commit();
        session.close();
    }


    @Test
    public void Remove1() throws  Exception{
        //获取sqlSessionFactory工程
        //读取到你的xml文件
        //得到session
        //使用getMapper进行接口写入
        //创建list把id传入
        SqlSessionFactory sqlSessionFactory=new  SqlSessionFactoryBuilder().build(Resources.getResourceAsStream("mybatis.xml"));
        SqlSession session = sqlSessionFactory.openSession();
        IUser iu= session.getMapper(IUser.class);
        List<String> ls=new ArrayList<>();
        ls.add("e7003c12-9ef6-11ea-a83b-98fa9b223a51");
        ls.add("758d9473-9ef6-11ea-a83b-98fa9b223a51");
        iu.Remove1(ls);
        session.commit();
        session.close();
    }
}

log4j

# 全局日志配置
log4j.rootLogger=ERROR, stdout
# MyBatis 日志配置
//这个com.zx.mapper是我的包名前缀
log4j.logger.com.zx.mapper=TRACE
# 控制台输出
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n

 

mybatis.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>
    <!--设置log4j-->
    <settings>
        <setting name="logImpl" value="LOG4J"/>
            <!--全局地开启或关闭配置文件中的所有映射器已经配置的任何缓存。 -->
            <setting name="cacheEnabled" value="true"/>
    </settings>
    <!--设置别名-->
  <typeAliases>
      <package name="com.zx.pojo"></package>
  </typeAliases>
    <!--jdbc数据库连接池-->
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <!--数据库连接驱动-->
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <!--数据库连接地址-->
                <property name="url" value="jdbc:mysql://localhost:3306/zx?characterEncoding=UTF-8"/>
                <!--数据库用户名-->
                <property name="username" value="root"/>
                <!--数据库密码-->
                <property name="password" value="sasa"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="com\zx\mapper\UserMapper.xml"/>
    </mappers>
</configuration>

 

下面让我们开始了解mybatis的关系把

这里我讲1v1，1vN，Nv1,NvN.

1v1

XML:  
<!--1v1的方法-->
    <resultMap id="user_root" type="users">
        <id column="id" property="id" ></id>
        <result property="uname" column="uname"></result>
        <result column="upwd" property="upwd"></result>
        <association property="userroot" javaType="userroot">
            <id column="id" property="id"></id>
            <result column="uid" property="uid"></result>
            <result property="utype" column="utype"></result>
        </association>
    </resultMap>
    <!--1v1的sql-->
    <select id="users_rootlist" resultMap="user_root" parameterType="users">
         SELECT  u.*,ur.* FROM  users u INNER JOIN userroot ur ON u.id=ur.uid;
    </select>




POJO: users表
  //id
    private String id;
    //用户名
    private String uname;
    //密码
    private String upwd;
    //1对1的对象userroot
    private  userroot userroot;

    public com.zx.pojo.userroot getUserroot() {
        return userroot;
    }

    public void setUserroot(com.zx.pojo.userroot userroot) {
        this.userroot = userroot;
    }

POJO: userroot表
//角色权限id
	private String id;

//用户id
	private String uid;

//用户类型
	private Long utype;
	//1对1的对象users
	private  users users;


TEXT:

    //1v1
    @Test
    public void user_root() throws  Exception{
        //获取sqlSessionFactory工程
        //读取到你的xml文件
        //得到session
        //使用getMapper进行接口写入
        //创建list把id传入
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream("mybatis.xml"));
        SqlSession session = sqlSessionFactory.openSession();
        IUser iu = session.getMapper(IUser.class);
        iu.users_rootlist();
    }

1vN

XML：
 <!--1v多的方法-->
    <resultMap id="user_rootlist" type="users">
        <id column="id" property="id" ></id>
        <result property="uname" column="uname"></result>
        <result column="upwd" property="upwd"></result>
        <collection property="userroot" ofType="userroot">
            <id column="id" property="id"></id>
            <result column="uid" property="uid"></result>
            <result property="utype" column="utype"></result>
        </collection>
    </resultMap>
    <!--1v多的sql-->
    <select id="users_rootlist1" resultMap="user_rootlist" parameterType="users">
        SELECT  u.*,ur.* FROM  users u INNER JOIN userroot ur ON u.id=ur.uid;
    </select>



POJO: users表
  //id
    private String id;
    //用户名
    private String uname;
    //密码
    private String upwd;

POJO: userroot表
//角色权限id
	private String id;

//用户id
	private String uid;

//用户类型
	private Long utype;
//1对多的集合usersList
	private List<users> usersList;


TEXT:
 @Test
    public void user_root2() throws  Exception{
        //获取sqlSessionFactory工程
        //读取到你的xml文件
        //得到session
        //使用getMapper进行接口写入
        //创建list把id传入
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream("mybatis.xml"));
        SqlSession session = sqlSessionFactory.openSession();
        IUser iu = session.getMapper(IUser.class);
        iu.users_rootlist1();
    }

Nv1

XML:
 <!--多v1的sql-->
    <select id="users_rootlist2" resultMap="user_rootlist1" parameterType="users">
        SELECT  u.*,ur.* FROM  users u INNER JOIN userroot ur ON u.id=ur.uid;
    </select>
    <!--多v多的方法 其实多对多语法和一对多差不多只是需要在双方实体都加上各自的集合对象-->
    <resultMap id="user_rootlist2" type="users">
        <id column="id" property="id" ></id>
        <result property="uname" column="uname"></result>
        <result column="upwd" property="upwd"></result>
        <collection property="userroot" ofType="userroot">
            <id column="id" property="id"></id>
            <result column="uid" property="uid"></result>
            <result property="utype" column="utype"></result>
        </collection>
    </resultMap>



POJO:users表
 //id
    private String id;
    //用户名
    private String uname;
    //密码
    private String upwd;
    //多对1的集合userrootList
    private List<userroot> userrootList;


POJO:userroot表
//角色权限id
	private String id;

//用户id
	private String uid;

//用户类型
	private Long utype;



TEXT:
 @Test
    public void user_root3() throws  Exception{
        //获取sqlSessionFactory工程
        //读取到你的xml文件
        //得到session
        //使用getMapper进行接口写入
        //创建list把id传入
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream("mybatis.xml"));
        SqlSession session = sqlSessionFactory.openSession();
        IUser iu = session.getMapper(IUser.class);
        iu.users_rootlist2();
    }

NvN

XML:
  <!--多v多的方法 其实多对多语法和一对多差不多只是需要在双方实体都加上各自的集合对象-->
    <resultMap id="user_rootlist2" type="users">
        <id column="id" property="id" ></id>
        <result property="uname" column="uname"></result>
        <result column="upwd" property="upwd"></result>
        <collection property="userroot" ofType="userroot">
            <id column="id" property="id"></id>
            <result column="uid" property="uid"></result>
            <result property="utype" column="utype"></result>
        </collection>
    </resultMap>

    <!--多v多的sql-->
    <select id="users_rootlist3" resultMap="user_rootlist2" parameterType="users">
        SELECT  u.*,ur.* FROM  users u INNER JOIN userroot ur ON u.id=ur.uid;
    </select>


POJO:users表
    //id
    private String id;
    //用户名
    private String uname;
    //密码
    private String upwd;
   //多对多的集合userrootList
    private List<userroot> userrootList;



POJO:userroot表
//角色权限id
	private String id;

//用户id
	private String uid;

//用户类型
	private Long utype;
//用户集合
private List<users> usersList;



TEXT:
 @Test
    public void user_root4() throws  Exception{
        //获取sqlSessionFactory工程
        //读取到你的xml文件
        //得到session
        //使用getMapper进行接口写入
        //创建list把id传入
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream("mybatis.xml"));
        SqlSession session = sqlSessionFactory.openSession();
        IUser iu = session.getMapper(IUser.class);
        iu.users_rootlist3();
    }

接口方法：

  //1对1
    public List<users> users_rootlist();

    //1对多
    public List<users> users_rootlist1();
    //多对1
    public List<users> users_rootlist2();
    //多对多
    public List<users> users_rootlist3();

这里为了偷懒把方法都写在一个接口里了 其实还要写一个Iuserroot的接口。

 

 

接下来就开始讲可以装逼的mybatis注解了

我使用的是城市和省份表话不多说直接上代码

package com.zking.mapper;

import com.zking.pojo.city;
import org.apache.ibatis.annotations.*;

import java.util.Set;

public interface Icity {

    //增加@insert
    @Insert("insert into city() value(uuid(),#{cname},#{pid})")
    public int Addcity(city c);
    //修改@Update
   @Update("update city set cname=#{cname},pid=#{pid} where cid=#{cid}")
    public int Editcity(city c);
    //删除@Delete
    @Delete("delete from  city where cid=#{cid}")
    public int Deletecity(city c);
     
    //查询@select
    @Select("select * from city where pid=#{pid}")
    @Results({
            @Result(id = true,property = "cid",column = "cid"),
            @Result(property = "cname",column = "cname"),
            @Result(property = "pid",column = "pid")
    })
     //1对1
    public city FindAll(String pid);

    @Select("select * from city where pid=#{pid}")
    @Results({
            @Result(id = true,property = "cid",column = "cid"),
            @Result(property = "cname",column = "cname"),
            @Result(property = "pid",column = "pid")
    })
//多对多
    public Set<city> FindAlls(String pid);
}





package com.zking.mapper;

import com.zking.pojo.province;
import org.apache.ibatis.annotations.*;

import javax.annotation.Resources;
import java.util.List;

public interface Iprovince {
     //增加@insert
    @Insert("insert into province() value(uuid(),#{pname}) ")
    public int AddProvince(province province);
    //修改@update
    @Update("update province set pname=#{pname} where pid=#{pid}")
    public int EditProvince(province province);

   //1v1关系
    @Select("select * from province")
    @Results({
            @Result(id = true, property = "pid", column = "pid"),
            @Result(property = "pname", column = "pname"),
            @Result(property = "city", column = "pid", one = @One(select = "com.zking.mapper.Icity.FindAll"))
    })
  //多对多关系
    public List<province> FindAll();
    @Select("select * from province")
    @Results({
            @Result(id = true, property = "pid", column = "pid"),
            @Result(property = "pname", column = "pname"),
            @Result(property = "citySet", column = "pid", many = @Many(select = "com.zking.mapper.Icity.FindAlls"))
    })
    public List<province> FindAlls();
}

 

测试：

import com.zking.mapper.Icity;
import com.zking.mapper.Iprovince;
import com.zking.pojo.city;
import com.zking.pojo.province;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

public class Test {


    @org.junit.Test
    public void dome01() throws Exception {

        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream("mybatis-config.xml"));
        SqlSession sqlSession = sqlSessionFactory.openSession();
        Iprovince iprovince = sqlSession.getMapper(Iprovince.class);
        province p = new province();
        p.setPname("湖北");
        iprovince.AddProvince(p);
        sqlSession.commit();
        sqlSession.close();

    }
    @org.junit.Test
    public void dome02() throws Exception {

        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream("mybatis-config.xml"));
        SqlSession sqlSession = sqlSessionFactory.openSession();
        Iprovince iprovince = sqlSession.getMapper(Iprovince.class);
        province p = new province();
        p.setPid("96dbb233-0c4b-11ea-a8ef-fc459698e2bd");
        p.setPname("湖北");
        iprovince.EditProvince(p);
        sqlSession.commit();
        sqlSession.close();

    }


    @org.junit.Test
    public void dome03() throws Exception {

        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream("mybatis-config.xml"));
        SqlSession sqlSession = sqlSessionFactory.openSession();
        Icity mapper = sqlSession.getMapper(Icity.class);
        city c=new city();
        c.setCname("长沙");
        c.setPid("96dbb233-0c4b-11ea-a8ef-fc459698e2bd");
        mapper.Addcity(c);
        sqlSession.commit();
        sqlSession.close();

    }

    @org.junit.Test
    public void dome04() throws Exception {
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream("mybatis-config.xml"));
        SqlSession sqlSession = sqlSessionFactory.openSession();
        Icity mapper = sqlSession.getMapper(Icity.class);
        city c=new city();
        c.setCid("9495f3f5-0c55-11ea-ab6e-fc459698e2bd");
        c.setCname("长沙");
        c.setPid("96dbb233-0c4b-11ea-a8ef-fc459698e2bd");
        mapper.Editcity(c);
        sqlSession.commit();
        sqlSession.close();

    }

    @org.junit.Test
    public void dome05() throws Exception {
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream("mybatis-config.xml"));
        SqlSession sqlSession = sqlSessionFactory.openSession();
        Icity mapper = sqlSession.getMapper(Icity.class);
        city c=new city();
        c.setCid("9495f3f5-0c55-11ea-ab6e-fc459698e2bd");
        mapper.Deletecity(c);
        sqlSession.commit();
        sqlSession.close();

    }

    @org.junit.Test
    public void dome06() throws Exception {
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream("mybatis-config.xml"));
        SqlSession sqlSession = sqlSessionFactory.openSession();
        Iprovince mapper = sqlSession.getMapper(Iprovince.class);
        mapper.FindAll();
        sqlSession.close();

    }
    @org.junit.Test
    public void dome07() throws Exception {
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream("mybatis-config.xml"));
        SqlSession sqlSession = sqlSessionFactory.openSession();
        Iprovince mapper = sqlSession.getMapper(Iprovince.class);
        mapper.FindAlls();
        sqlSession.close();

    }
}

 

POJO

package com.zking.pojo;

public class city {
    private  String cid;
    private String cname;
    private String pid ;


    public city() {
    }

    public city(String cid, String cname, String pid) {
        this.cid = cid;
        this.cname = cname;
        this.pid = pid;
    }

    public String getCid() {
        return cid;
    }

    public void setCid(String cid) {
        this.cid = cid;
    }

    public String getCname() {
        return cname;
    }

    public void setCname(String cname) {
        this.cname = cname;
    }

    public String getPid() {
        return pid;
    }

    public void setPid(String pid) {
        this.pid = pid;
    }
}







package com.zking.pojo;

import java.util.Set;

public class province {

    private String pid;
    private String pname;
    private city city;
    private Set<city> citySet;


    public province() {
    }

    public province(String pid, String pname) {
        this.pid = pid;
        this.pname = pname;
    }

    public Set<com.zking.pojo.city> getCitySet() {
        return citySet;
    }

    public void setCitySet(Set<com.zking.pojo.city> citySet) {
        this.citySet = citySet;
    }

    public com.zking.pojo.city getCity() {
        return city;
    }

    public void setCity(com.zking.pojo.city city) {
        this.city = city;
    }

    public String getPid() {
        return pid;
    }

    public void setPid(String pid) {
        this.pid = pid;
    }

    public String getPname() {
        return pname;
    }

    public void setPname(String pname) {
        this.pname = pname;
    }
}

 

讲完注解 我们开始讲一下mybatis的缓存把

一级缓存（sqlsession （自动打开））

原理图：

总结

1.在同一个 SqlSession 中, Mybatis 会把执行的方法和参数通过算法生成缓存的键值， 将键值和结果存放在一个 Map 中， 如果后续的键值一样， 则直接从 Map 中获取数据；

2.不同的 SqlSession 之间的缓存是相互隔离的；

3.用一个 SqlSession， 可以通过配置使得在查询前清空缓存；

4.任何的 UPDATE, INSERT, DELETE 语句都会清空缓存。
 

二级缓存（mapper）

2.1.1 全局开关
在 mybatis 中， 二级缓存有全局开关和分开关， 全局开关， 在 mybatis-config.xml 中如下配置:

<settings>
  <!--全局地开启或关闭配置文件中的所有映射器已经配置的任何缓存。 -->
  <setting name="cacheEnabled" value="true"/>
</settings>

默认是为 true， 即默认开启总开关。

2.1.2 分开关
分开关就是说在 *Mapper.xml 中开启或关闭二级缓存， 默认是不开启的。 

//需要在你的mapper.xml上面加cache打开二级缓存
<cache><cache/>

 

注意事项

1.由于在更新时会刷新缓存， 因此需要注意使用场合：查询频率很高， 更新频率很低时使用， 即经常使用 select, 相对较少使用delete, insert, update。

2.缓存是以 namespace 为单位的，不同 namespace 下的操作互不影响。但刷新缓存是刷新整个 namespace 的缓存， 也就是你 update 了一个， 则整个缓存都刷新了。

3.最好在 「只有单表操作」 的表的 namespace 使用缓存， 而且对该表的操作都在这个 namespace 中。 否则可能会出现数据不一致的情况。
 

 

这就是我最近学习mybatis的一些总结，有很多地方还没学习到，还有些地方可能还不是很齐全，很抱歉。（希望大佬们不要喷，可以指出来一起学习，一起加油）