Mybatis3源码分析(1)生命周期与核心配置解读以及批量操作

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

--------------------利用mapper
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
SqlSession session = sqlSessionFactory.openSession();
try {
    BlogMapper mapper = session.getMapper(BlogMapper.class);
    Blog blog = mapper.selectBlogById(1);
    System.out.println(blog);
} finally {
    session.close();
}
--------------------利用mybatis的接口
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
SqlSession session = sqlSessionFactory.openSession(); // ExecutorType.BATCH
try {
    Blog blog = (Blog) session.selectOne("com.yakax.mapper.BlogMapper.selectBlogById", 1);
    System.out.println(blog);
} finally {
    session.close();
}

1
2

<properties resource="db.properties"></properties>
这样也可以把数据库的信息分离出来；把配置文件放在外部，避免修改后重新编译打包，只需要重启应用；

1
2
3
4
5
6

数据库
create table blogdo (id int not null,blog json null,blog_list json null);
数据
id=1;
blog={"bid": 1, "name": "yakax", "naList": [{"na": "123"}, {"na": "234"}], "authorId": 120};
blog_list=[{"bid": 1, "name": "yakax", "naList": [{"na": "123"}], "authorId": 120}, {"bid": 1, "name": "yakax", "naList": [{"na": "123"}], "authorId": 120}];

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

这个是数据库查询转换后的对象
@Data
@TableName("blogdo")
public class BlogDO {
    private Integer id;
    private Blog blog;
    private List<Blog> blogList;
}
JSON 对象
@Data
public class Blog {
     private Integer bid;
    private String name;
    private Integer authorId;
    private List<Json> naList;
}
@Data
public class Json {
    private String na;
}

 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
63
64
65

@MappedTypes({Blog.class, List.class, Json.class})//要处理对应得Java类型
@MappedJdbcTypes(value = JdbcType.BLOB)//要对什么数据库类型进行操作
public class MyTypeHandlerone<E> extends BaseTypeHandler<E> {

    /**
     * 处理的类型(注册类型与传类型进来)
     */
    private Class<E> type;

    /**
     * 注册类型
     * @param type
     */
    public MyTypeHandlerone(Class<E> type) {
        if (type == null) {
            throw new IllegalArgumentException("Type argument cannot be null");
        }
        this.type = type;
    }
    
    /**
     * 设置非空参数
     */
    @Override
    public void setNonNullParameter(PreparedStatement preparedStatement, int i, E t, JdbcType jdbcType) throws SQLException {
        // set进入数据库
        preparedStatement.setString(i, JSON.toJSONString(t));
    }

    /**
     * 获取空结果集（根据列名），一般都是调用这个
     */
    @Override
    public E getNullableResult(ResultSet resultSet, String s) throws SQLException {
        String sqlJson = resultSet.getString(s);
        if (null != sqlJson) {
            return JSONObject.parseObject(sqlJson, type);
        }
        return null;
    }

    /**
     * 获取空结果集（根据下标值）
     */
    @Override
    public E getNullableResult(ResultSet resultSet, int i) throws SQLException {
        String sqlJson = resultSet.getString(i);
        if (null != sqlJson) {
            return JSONObject.parseObject(sqlJson, type);
        }
        return null;
    }

    /**
     * 存储过程用的
     */
    @Override
    public E getNullableResult(CallableStatement callableStatement, int i) throws SQLException {
        String sqlJson = callableStatement.getString(i);
        if (null != sqlJson) {
            return JSONObject.parseObject(sqlJson, type);
        }
        return null;
    }
}

1
2

  BlogDO blogdo = blogMapper.selectById(1);
  log.info(blogdo.toString());

1
2
3
4
5
6
7
8

cache – 给定命名空间的缓存配置（是否开启二级缓存）。
cache-ref – 其他命名空间缓存配置的引用。这两个标签我准备缓存的时候会详细写。
resultMap - 是最复杂也是最强大的元素，用来描述如何从数据库结果集中来加载对象。
sql – 可被其他语句引用的可重用语句块
insert – 映射插入语句
update – 映射更新语句
delete – 映射删除语句
select – 映射查询语句

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

## if 判断
## choose (when, otherwise)
SELECT * FROM tbl_emp e
<where>
    <choose>
        <when test="empId !=null">
            e.emp_id = #{emp_id, jdbcType=INTEGER}
        </when>
        <otherwise>
         AND e.email = #{email, jdbcType=VARCHAR}
        </otherwise>
    </choose>
</where>
类似于JAVA中的case when default
## trim (where, set) 
去处一些多余的符号的，比如拼接insert语句时最后一个逗号；
<trim prefix="(" suffix=")" suffixOverrides=",">
    <if test="deptId != null">
        dept_id,
    </if>
</trim>
foreach 循环

1

insert into 表名(列名) values (插入的字段值),（插入的字段值），......

1
2
3
4
5

使用Batch Executor 需要开启setting里面的defaultExecutorType 里面有三个参数
也可以在会话 SqlSession session = sqlSessionFactory.openSession(ExecutorType.BATCH);
SIMPLE 默认 普通的sql 对应jdbc的statement
REUSE 执行器会重用预处理语句对应jdbc PreparedStatement ------也就是说我们执行的sql 他会先缓存起来，要用的时候通过缓存拿
BATCH 重用语句并执行批量更新