MyBatis学习笔记（2）

最新推荐文章于 2023-08-28 19:21:54 发布

MY.BOO

最新推荐文章于 2023-08-28 19:21:54 发布

阅读量154

点赞数

分类专栏： SSM 文章标签： java maven java-ee intellij-idea mybatis

本文链接：https://blog.csdn.net/m0_52138519/article/details/119278504

版权

SSM 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

小技巧：当没必要传整个User的所有属性时，可以传一个map作为参数，自由设置需要的属性。

int addUser2(Map<String,Object> map);

<insert id="addUser2" parameterType="map">
    insert into mybatis.user(id, name, pwd) values (#{userid},#{username},#{password});
</insert>

@Test
public void test6(){
    SqlSession sqlSession=MybatisUtils.getSqlSession();
    UserDao userDao = sqlSession.getMapper(UserDao.class);
    Map<String, Object> map = new HashMap<String, Object>();
    map.put("userid",5);
    map.put("username","李云龙");
    map.put("password","123123");
    userDao.addUser2(map);
    sqlSession.commit();
    sqlSession.close();
}

4.配置解析

MyBatis 的配置文件包含了会深深影响 MyBatis 行为的设置和属性信息。配置文档的顶层结构如下：

configuration（配置）
properties（属性）
settings（设置）
typeAliases（类型别名）
typeHandlers（类型处理器）
objectFactory（对象工厂）
plugins（插件）
environments（环境配置）
environment（环境变量）
transactionManager（事务管理器）
dataSource（数据源）
databaseIdProvider（数据库厂商标识）
mappers（映射器）

注意：所有设置必须按以上顺序编写

4.1环境配置（environments）

Mybatis可以配置成适应多种环境，不过每个SqlSessionFactory只能选择一种环境。

默认的事务管理器是JDBC，数据源是POOLED。

4.2属性（properties）

我们可以通过properties属性来引用配置文件。

在这里插入图片描述

4.3类型别名（typeAliases）

用来减少类的完全限定名的冗余，具体见官方文档的解释

在这里插入图片描述

4.4设置（settings）

在这里插入图片描述

4.5映射器（mappers）

注册绑定我们的Mapper文件

方式一：

<mappers>
    <mapper resource="dao/UserMapper.xml"/>
</mappers>

方式二：使用class文件（接口）

<mappers>
    <mapper class="dao.UserMapper"/>
</mappers>

注意：

接口和他的Mapper配置文件必须同名（所以一般把接口命名为xxxMapper）
接口和他的Mapper配置文件必须在同一包下

5.解决属性名和字段名不一致的问题

假设现在数据库中的字段为 id name pwd，

而实体类中的属性为id name password。

那么就可以通过如下方式实现结果集映射（在Mapper文件中）：

<resultMap id="UserMap" type="pojo.User">
    <result column="id" property="id"/>
    <result column="name" property="name"/>
    <result column="pwd" property="password"/>
</resultMap>
<select id="getUserList" resultMap="UserMap">
    select * from mybatis.user;
</select>

首先把resultType改为resultMap，然后添加字段到属性之间的联系。

column表示数据库中的字段而property表示实体类中的属性。

注意：当字段名和属性名一样时，可以不用显式声明，所以下面这两句可以删掉。

<result column="id" property="id"/>   
<result column="name" property="name"/>

6.日志

6.1日志工厂

如果一个数据库操作出现了异常，我们需要排错，日志就是最好的助手！

通过以下代码添加日志

<settings>
    <setting name="logImpl" value="STDOUT_LOGGING"/>
</settings>

在这里插入图片描述

6.2Log4j

1.导包

<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</version>
</dependency>

2.在resources目录下添加log4j.properties

#将等级为DEBUG的日志信息输出到console和file这两个目的地，console和file的定义在下面的代码
log4j.rootLogger=DEBUG,console,file

#控制台输出的相关设置
log4j.appender.console = org.apache.log4j.ConsoleAppender
log4j.appender.console.Target = System.out
log4j.appender.console.Threshold=DEBUG
log4j.appender.console.layout = org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPattern=[%c]-%m%n
log4j.appender.Console.encoding=UTF-8
#文件输出的相关设置
log4j.appender.file = org.apache.log4j.RollingFileAppender
log4j.appender.file.File=./log/qj.log
log4j.appender.file.MaxFileSize=10mb
log4j.appender.file.Threshold=DEBUG
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=[%p][%d{yy-MM-dd}][%c]%m%n

#日志输出级别
log4j.logger.org.mybatis=DEBUG
log4j.logger.java.sql=DEBUG
log4j.logger.java.sql.Statement=DEBUG
log4j.logger.java.sql.ResultSet=DEBUG
log4j.logger.java.sql.PreparedStatement=DEBUG

<settings>
    <setting name="logImpl" value="LOG4J"/>
</settings>

简单使用：

1.在要使用Log4j的类中，导入包org.apache.log4j.Logger

2.获得日志对象，参数为当前类的class

static Logger logger = Logger.getLogger(UserDaoTest.class);

7.使用注解开发

1.注解在接口上实现

@Select("select * from user")
List<User> getUserList();

2.在核心配置文件中绑定接口

<mappers>
    <mapper class="dao.UserDao"/>
</mappers>

3.测试

本质：反射机制实现

底层：动态代理

在这里插入图片描述

上图是使用注解实现简单的CRUD

小技巧：

public static SqlSession getSqlSession(){
    return sqlSessionFactory.openSession(true);
}

工具类中将true作为参数传进去可以实现自动提交事务！

关于@Param（）注解

基本类型的参数或者String类型的参数，需要加上
引用类型不需要加
我们在SQL中用#{}引用的就是@Param中设定的属性名

8.多对一处理

8.1搭建测试环境

创建两个表

CREATE TABLE `teacher` (
  `id` INT(10) NOT NULL,
  `name` VARCHAR(30) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8;

INSERT INTO teacher(`id`, `name`) VALUES (1, '秦老师');

CREATE TABLE `student` (
  `id` INT(10) NOT NULL,
  `name` VARCHAR(30) DEFAULT NULL,
  `tid` INT(10) DEFAULT NULL,
  PRIMARY KEY (`id`),
  KEY `fktid` (`tid`),
  CONSTRAINT `fktid` FOREIGN KEY (`tid`) REFERENCES `teacher` (`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8;

INSERT INTO `student` (`id`, `name`, `tid`) VALUES (1, '小明', 1);
INSERT INTO `student` (`id`, `name`, `tid`) VALUES (2, '小红', 1);
INSERT INTO `student` (`id`, `name`, `tid`) VALUES (3, '小张', 1);
INSERT INTO `student` (`id`, `name`, `tid`) VALUES (4, '小李', 1);
INSERT INTO `student` (`id`, `name`, `tid`) VALUES (5, '小王', 1);

1.新建实体类Teacher，Student

2.建立Mapper接口

3.建立Mapper.xml文件

4.在核心配置文件中注册

5.测试

8.2按照查询嵌套处理（类似子查询）

<select id="getStudent2" resultMap="StudentMap2">
    select * from mybatis.student
</select>
<resultMap id="StudentMap2" type="pojo.Student">
    <result column="id" property="id"></result>
    <result column="name" property="name"></result>
    <association column="tid" property="teacher" javaType="pojo.Teacher" select="getTeacher">
    </association>
</resultMap>
<select id="getTeacher" resultType="pojo.Teacher">
    select *from mybatis.teacher where id=#{id}
</select>

8.3按照结果嵌套处理（类似连表查询）

<resultMap id="StudentMap" type="pojo.Student">
    <result column="sid" property="id"></result>
    <result column="sname" property="name"></result>
    <association property="teacher" javaType="pojo.Teacher">
        <result column="tname" property="name"></result>
    </association>
</resultMap>
<select id="getStudent" resultMap="StudentMap">
    select s.id sid,s.name sname,t.name tname 
    from mybatis.student s,mybatis.teacher t 
    where s.tid=t.id
</select>

9.一对多处理

<select id="getTeacher" resultMap="TeacherMap">
    select s.id sid,s.name sname,t.name tname,t.id tid 
    from student s,teacher t 
    where s.tid=t.id and t.id=#{tid}
</select>
<resultMap id="TeacherMap" type="pojo.Teacher">
    <result column="tid" property="id"></result>
    <result column="tname" property="name"></result>
    <collection property="students" ofType="pojo.Student">
        <result column="sid" property="id"></result>
        <result column="sname" property="name"></result>
        <result column="tid" property="tid"></result>
    </collection>
</resultMap>

注意：在多对一处理时，Student类含有一个Teacher类属性，Teacher类中的属性和数据库表中的一致。

在一对多处理时，Teacher类含有一个List属性，Student类中的属性和数据库表中的一致。

小结：

1.association（关联）：多对一

2.collection（集合）：一对多

3.JavaType和ofType的区别：

JavaType用来指定实体类当中属性的类型
ofType用来指定映射到List或者集合中的pojo类型，即泛型中的约束类型

10.动态SQL

10.1搭建测试环境

新建表，并插入数据。

CREATE TABLE `blog`(
  `id` VARCHAR(50) NOT NULL COMMENT '博客id',
  `title` VARCHAR(100) NOT NULL COMMENT '博客标题',
  `author` VARCHAR(30) NOT NULL COMMENT '博客作者',
  `create_time` DATETIME NOT NULL COMMENT '创建时间',
  `views` INT(30) NOT NULL COMMENT '浏览量'
)ENGINE=INNODB DEFAULT CHARSET=utf8

int addBlog(Blog blog);

<insert id="addBlog" parameterType="pojo.Blog">
    insert into mybatis.blog(id, title, author, create_time, views)
    values (#{id},#{title},#{author},#{createTime},#{views})
</insert>

@Test
public void test(){
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
    Blog blog = new Blog();
    blog.setId(IDutils.getId());
    blog.setTitle("Mybatis如此简单");
    blog.setAuthor("狂神说");
    blog.setCreateTime(new Date());
    blog.setViews(9999);

    mapper.addBlog(blog);

    blog.setId(IDutils.getId());
    blog.setTitle("Java如此简单");
    mapper.addBlog(blog);

    blog.setId(IDutils.getId());
    blog.setTitle("Spring如此简单");
    mapper.addBlog(blog);

    blog.setId(IDutils.getId());
    blog.setTitle("微服务如此简单");
    mapper.addBlog(blog);

    sqlSession.close();


}

10.2 if标签

List<Blog> queryBlogIf(Map map);

<select id="queryBlogIf" parameterType="map" resultType="pojo.Blog">
    select * from mybatis.blog where 1=1
    <if test="title!=null">
        and title=#{title}
    </if>
    <if test="author!=null">
        and author=#{author}
    </if>
</select>

@Test
public void test2() {
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
    HashMap<String, Object> hashMap = new HashMap<String, Object>();
    hashMap.put("title","Java如此简单");
    mapper.queryBlogIf(hashMap);
    sqlSession.close();
}

10.3 trim、where、set

where 元素只会在子元素返回任何内容的情况下才插入 “WHERE” 子句。而且，若子句的开头为 “AND” 或 “OR”，where 元素也会将它们去除。

上面那个例子可以改写为：

<select id="queryBlogIf" parameterType="map" resultType="pojo.Blog">
    select * from mybatis.blog
    <where>
        <if test="title!=null">
            title=#{title}
        </if>
        <if test="author!=null">
            author=#{author}
        </if>
    </where>
</select>

用于动态更新语句的类似解决方案叫做 set。set 元素可以用于动态包含需要更新的列，忽略其它不更新的列。

<update id="updateBlog" parameterType="map">
    update mybatis.blog
    <set>
        <if test="title!=null">
            title=#{title},
        </if>
        <if test="author!=null">
            author=#{author},
        </if>
    </set>
    where id=#{id}
</update>

这个例子中，set 元素会动态地在行首插入 SET 关键字，并会删掉额外的逗号（这些逗号是在使用条件语句给列赋值时引入的）。

where元素和set元素的本质都是trim元素。

<trim prefix="WHERE" prefixOverrides="AND |OR ">
  ...
</trim>

<trim prefix="SET" suffixOverrides=",">
  ...
</trim>

10.4 choose、when、otherwise

在这里插入图片描述

10.5 foreach

在这里插入图片描述

动态SQL就是在拼接SQL语句，所以可以先在Mysql中写出完整的SQL语句，再对应的去修改成为我们的动态SQL实现通用即可。

11.缓存

11.1一级缓存

默认开启，是SQLSession级别的缓存，也称为本地缓存。

11.2二级缓存

需要手动开启和配置，是namespace级别的缓存，也叫全局缓存。（一个Mapper对应一个二级缓存）

<cache/>

这个简单语句的效果如下:

映射语句文件中的所有 select 语句的结果将会被缓存。
映射语句文件中的所有 insert、update 和 delete 语句会刷新缓存。
缓存会使用最近最少使用算法（LRU, Least Recently Used）算法来清除不需要的缓存。
缓存不会定时进行刷新（也就是说，没有刷新间隔）。
缓存会保存列表或对象（无论查询方法返回哪种）的 1024 个引用。
缓存会被视为读/写缓存，这意味着获取到的对象并不是共享的，可以安全地被调用者修改，而不干扰其他调用者或线程所做的潜在修改。

这些属性可以通过 cache 元素的属性来修改。比如：

<cache
  eviction="FIFO"
  flushInterval="60000"
  size="512"
  readOnly="true"/>

这个更高级的配置创建了一个 FIFO 缓存，每隔 60 秒刷新，最多可以存储结果对象或列表的 512 个引用，而且返回的对象被认为是只读的，因此对它们进行修改可能会在不同线程中的调用者产生冲突。

可用的清除策略有：

LRU – 最近最少使用：移除最长时间不被使用的对象。
FIFO – 先进先出：按对象进入缓存的顺序来移除它们。
SOFT – 软引用：基于垃圾回收器状态和软引用规则移除对象。
WEAK – 弱引用：更积极地基于垃圾收集器状态和弱引用规则移除对象。

默认的清除策略是 LRU。

flushInterval（刷新间隔）属性可以被设置为任意的正整数，设置的值应该是一个以毫秒为单位的合理时间量。默认情况是不设置，也就是没有刷新间隔，缓存仅仅会在调用语句时刷新。

size（引用数目）属性可以被设置为任意正整数，要注意欲缓存对象的大小和运行环境中可用的内存资源。默认值是 1024。

readOnly（只读）属性可以被设置为 true 或 false。只读的缓存会给所有调用者返回缓存对象的相同实例。因此这些对象不能被修改。这就提供了可观的性能提升。而可读写的缓存会（通过序列化）返回缓存对象的拷贝。速度上会慢一些，但是更安全，因此默认值是 false。

注意：开启缓存时必须使实体类序列化，否则就会报错！！！

小结：

1.只要开启了二级缓存，再同一个Mapper中就有效。

2.所有的数据优先放在一级缓存中，只有当会话提交或者关闭的时候，才会提交到二级缓存中。
新（也就是说，没有刷新间隔）。

缓存会保存列表或对象（无论查询方法返回哪种）的 1024 个引用。
缓存会被视为读/写缓存，这意味着获取到的对象并不是共享的，可以安全地被调用者修改，而不干扰其他调用者或线程所做的潜在修改。

这些属性可以通过 cache 元素的属性来修改。比如：

<cache
  eviction="FIFO"
  flushInterval="60000"
  size="512"
  readOnly="true"/>

可用的清除策略有：

LRU – 最近最少使用：移除最长时间不被使用的对象。
FIFO – 先进先出：按对象进入缓存的顺序来移除它们。
SOFT – 软引用：基于垃圾回收器状态和软引用规则移除对象。
WEAK – 弱引用：更积极地基于垃圾收集器状态和弱引用规则移除对象。

默认的清除策略是 LRU。

size（引用数目）属性可以被设置为任意正整数，要注意欲缓存对象的大小和运行环境中可用的内存资源。默认值是 1024。

注意：开启缓存时必须使实体类序列化，否则就会报错！！！

小结：

1.只要开启了二级缓存，再同一个Mapper中就有效。

2.所有的数据优先放在一级缓存中，只有当会话提交或者关闭的时候，才会提交到二级缓存中。

MY.BOO

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
MyBatis学习笔记（2）

小技巧：当没必要传整个User的所有属性时，可以传一个map作为参数，自由设置需要的属性。int addUser2(Map<String,Object> map);<insert id="addUser2" parameterType="map"> insert into mybatis.user(id, name, pwd) values (#{userid},#{username},#{password});</insert>@Testpubli
复制链接

扫一扫