关于Mybatis的那点事

1.实现关联表查询

1.1. 一对一关联

1). 提出需求

根据班级id查询班级信息(带老师的信息)

2). 创建表和数据

CREATE TABLE teacher(          t_id INT PRIMARY KEY AUTO_INCREMENT,          t_name VARCHAR(20) ); CREATE TABLE class(          c_id INT PRIMARY KEY AUTO_INCREMENT,          c_name VARCHAR(20),          teacher_id INT ); ALTER TABLE class ADD CONSTRAINT fk_teacher_id FOREIGN KEY (teacher_id) REFERENCES teacher(t_id);    INSERT INTO teacher(t_name) VALUES('LS1'); INSERT INTO teacher(t_name) VALUES('LS2');   INSERT INTO class(c_name, teacher_id) VALUES('bj_a', 1); INSERT INTO class(c_name, teacher_id) VALUES('bj_b', 2);

3). 定义实体类：

public class Teacher {          private int id;          private String name; } public class Classes {          private int id;          private String name;          private Teacher teacher; }

 

4). 定义sql映射文件ClassMapper.xml

select * from class c, teacher t where c.teacher_id=t.t_id and  c.c_id=#{id}                            property="teacher" javaType="_Teacher">                                                               select * from class where c_id=#{id}                                select="getTeacher">                SELECT t_id id, t_name name FROM teacher WHERE t_id=#{id}

 

5). 测试

@Test public void testOO() {          SqlSession sqlSession = factory.openSession();          Classes c = sqlSession.selectOne("com.atguigu.day03_mybatis.test5.OOMapper.getClass", 1);          System.out.println(c); }   @Test public void testOO2() {          SqlSession sqlSession = factory.openSession();          Classes c = sqlSession.selectOne("com.atguigu.day03_mybatis.test5.OOMapper.getClass2", 1);          System.out.println(c); }

总结：

association：用于一对一的关联查询；
property：对象属性的名称；
javaType：对象属性的类型；
column：所对应的外键字段名称
select：使用另一个查询封装的结果

 

1.2. 一对多关联

1). 提出需求

根据classId查询对应的班级信息,包括学生,老师

2). 创建表和数据：

CREATE TABLE student(          s_id INT PRIMARY KEY AUTO_INCREMENT,          s_name VARCHAR(20),          class_id INT ); INSERT INTO student(s_name, class_id) VALUES('xs_A', 1); INSERT INTO student(s_name, class_id) VALUES('xs_B', 1); INSERT INTO student(s_name, class_id) VALUES('xs_C', 1); INSERT INTO student(s_name, class_id) VALUES('xs_D', 2); INSERT INTO student(s_name, class_id) VALUES('xs_E', 2); INSERT INTO student(s_name, class_id) VALUES('xs_F', 2);

 

3). 定义实体类：

public class Student {          private int id;          private String name; }   public class Classes {          private int id;          private String name;          private Teacher teacher;          private List students; }

4). 定义sql映射文件ClassMapper.xml

select * from class c, teacher t,student s where c.teacher_id=t.t_id and c.C_id=s.class_id and  c.c_id=#{id}                                                                                             <collection property="students" ofType="_Student">                                                             select * from class where c_id=#{id}                                         <collection property="students" ofType="_Student" column="c_id" select="getStudent">                SELECT t_id id, t_name name FROM teacher WHERE t_id=#{id}                SELECT s_id id, s_name name FROM student WHERE class_id=#{id}

 

5). 测试：

@Test public void testOM() {          SqlSession sqlSession = factory.openSession();          Classes c = sqlSession.selectOne("com.atguigu.day03_mybatis.test5.OOMapper.getClass3", 1);          System.out.println(c); }   @Test public void testOM2() {          SqlSession sqlSession = factory.openSession();          Classes c = sqlSession.selectOne("com.atguigu.day03_mybatis.test5.OOMapper.getClass4", 1);          System.out.println(c); }

总结：

collection：做一对多关联查询的
ofType：指定集合元素对象的类型

 

2. 动态SQL与模糊查询

2.1. 提出需求:

实现多条件查询用户(姓名模糊匹配, 年龄在指定的最小值到最大值之间)

2.2. 准备数据表和数据:

create table d_user(           id int primary key auto_increment,           name varchar(10),          age int(3) );   insert into d_user(name,age) values('Tom',12);  insert into d_user(name,age) values('Bob',13);  insert into d_user(name,age) values('Jack',18);

2.3. ConditionUser(查询条件实体类)

private String name; private int minAge; private int maxAge;

 

2.4. User(表实体类)

private int id; private String name; private int age;

 

2.5. userMapper.xml(映射文件)

"http://mybatis.org/dtd/mybatis-3-mapper.dtd">                             select * from d_user where age>=#{minAge} and age<=#{maxAge}                    and name like #{name}

 

2.6. UserTest(测试)

public class UserTest {            public static void main(String[] args) throws IOException {                                       Reader reader = Resources.getResourceAsReader("conf.xml");                                       SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(reader);                                       SqlSession sqlSession = sessionFactory.openSession();                                       String statement = "com.atguigu.day03_mybatis.test6.userMapper.getUser";                                       List list = sqlSession.selectList(statement, new ConditionUser("%a%", 1, 12));                                       System.out.println(list);          } }

 

MyBatis中可用的动态SQL标签：

if
choose（when，otherwise）
trim（where，set）
foreach

 

3. Mybatis缓存

3.1. 理解MyBatis缓存

正如大多数持久层框架一样，MyBatis 同样提供了一级缓存和二级缓存的支持

1.一级缓存: 基于PerpetualCache 的 HashMap本地缓存，其存储作用域为 Session，当 Session flush 或 close 之后，该Session中的所有 Cache 就将清空。 2. 二级缓存与一级缓存其机制相同，默认也是采用 PerpetualCache，HashMap存储，不同在于其存储作用域为 Mapper(Namespace)，并且可自定义存储源，如 Ehcache。 3. 对于缓存数据更新机制，当某一个作用域(一级缓存Session/二级缓存Namespaces)的进行了 C/U/D 操作后，默认该作用域下所有 select 中的缓存将被clear。

 

3.2. Mybatis一级缓存

1) 提出需求:

         根据id查询对应的用户记录对象

2). 准备数据库表和数据

CREATE TABLE c_user(          id INT PRIMARY KEY AUTO_INCREMENT,          NAME VARCHAR(20),          age INT ); INSERT INTO c_user(NAME, age) VALUES('Tom', 12); INSERT INTO c_user(NAME, age) VALUES('Jack', 11);

3). 创建表的实体类

public class User implements Serializable{            private int id;          private String name;          private int age; }

4). userMapper.xml

select * from c_user where id=#{id}                                        update c_user set                    name=#{name}, age=#{age} where id=#{id}

5). 测试:

 

/*  * 一级缓存: 也就Session级的缓存(默认开启)  */ @Test public void testCache1() {          SqlSession session = MybatisUtils.getSession();          String statement = "com.atguigu.mybatis.test8.userMapper.getUser";          User user = session.selectOne(statement, 1);          System.out.println(user);                   /*           * 一级缓存默认就会被使用           */          /*          user = session.selectOne(statement, 1);          System.out.println(user);          */                   /*           1. 必须是同一个Session,如果session对象已经close()过了就不可能用了           */          /*          session = MybatisUtils.getSession();          user = session.selectOne(statement, 1);          System.out.println(user);          */                   /*           2. 查询条件是一样的           */          /*          user = session.selectOne(statement, 2);          System.out.println(user);          */                   /*           3. 没有执行过session.clearCache()清理缓存           */          /*          session.clearCache();          user = session.selectOne(statement, 2);          System.out.println(user);          */                   /*           4. 没有执行过增删改的操作(这些操作都会清理缓存)           */          /*          session.update("com.atguigu.mybatis.test8.userMapper.updateUser",                             new User(2, "user", 23));          user = session.selectOne(statement, 2);          System.out.println(user);          */ }

 

3.3. Mybatis二级缓存

1). 添加一个在userMapper.xml中

2). 测试

/*  * 测试二级缓存  */ @Test public void testCache2() {          String statement = "com.atguigu.mybatis.test8.userMapper.getUser";            SqlSession session = MybatisUtils.getSession();          User user = session.selectOne(statement, 1);          session.commit();          System.out.println("user="+user);                   SqlSession session2 = MybatisUtils.getSession();          user = session2.selectOne(statement, 1);          session.commit();          System.out.println("user2="+user); }

3). 补充说明

1. 映射语句文件中的所有select语句将会被缓存。 2. 映射语句文件中的所有insert，update和delete语句会刷新缓存。 3. 缓存会使用Least Recently Used（LRU，最近最少使用的）算法来收回。 4. 缓存会根据指定的时间间隔来刷新。 5. 缓存会存储1024个对象

 

eviction="FIFO"  //回收策略为先进先出 flushInterval="60000" //自动刷新时间60s size="512" //最多缓存512个引用对象 readOnly="true"/> //只读

 

4.Mybtis批量插入

问题存在：

在value值中，用到了mybatis的变量绑定。用的是#{}方式，还有一种方式${}。
默认情况下,使用#{}语法，MyBatis会用PreparedStatement语句当做占位符，并且安全的设置PreparedStatement参数，
可以避免SQL注入漏洞和钓鱼漏洞，这个过程中MyBatis会进行必要的安全检查和转义。

示例1：用#{}
执行SQL：Select * from emp where name = #{employeeName}
参数：employeeName=>Smith
解析后执行的SQL：Select * from emp where name = ？

 

示例2：用${}
执行SQL：Select * from emp where name = ${employeeName}
参数：employeeName传入值为：Smith
解析后执行的SQL：Select * from emp where name =Smith

 

可以看出，${}方式影响SQL语句的预编译，Oracle编译器解析时会进行硬解析，会造成很多临时游标变量的绑定，导致数据库性能下降。
所以从安全性和性能的角度出发，能使用#{}的情况下就不要使用${}。

SqlServer：对语句的条数和参数的数量都有限制，分别是 1000 和 2100。
Mysql：对语句的长度有限制，默认是 4M。
Mybatis：对动态语句没有数量上的限制。
将一批数据分多批插入，例如一批数据有220条，每次批量插入100条，则分三次执行全部插入。所耗费的时间要比一次执行的时间要短。

5.Mybatis传多个参数

5.1第一种方案：单个参数
DAO层的函数方法 ：public List getXXBeanList(String xxCode);
对应的Mapper.xml文件：

　　select t.* from tableName t where t.id= #{id}

其中方法名和ID一致，#{}中的参数名与方法中的参数名一直， 这里采用的是XXXBean是采用的短名字。

 

5.2第二种方案：多参数
DAO层的函数方法 ：public User selectUser(String name,String area);
对应的Mapper.xml文件：

select * from user_user_t where user_name = #{0} and user_area= #{1}

其中，#{0}代表接收的是dao层中的第一个参数，#{1}代表dao层中第二参数，更多参数一致往后加即可。

5.3第三种方案：此方法采用Map传多参数.
Dao层的函数方法：Public User selectUser(Map paramMap);
对应的Mapper.xml文件：

select * from user_user_t where user_name = #{userName，jdbcType=VARCHAR} and user_area= #{userArea,jdbcType=VARCHAR}

Service层调用：
Private User xxxSelectUser(){
Map paramMap=new hashMap();
paramMap.put(“userName”,”对应具体的参数值”);
paramMap.put(“userArea”,”对应具体的参数值”);
User user=xxx. selectUser(paramMap);
}


5.4第四种方案：多参数传递之注解方式
Dao层的函数方法：Public User selectUser(@param(“userName”) String name, @param(“userArea”) String area);
对应的Mapper.xml

select * from user_user_t where user_name = #{userName，jdbcType=VARCHAR} and user_area = #{userArea,jdbcType=VARCHAR}

注解方法。

5.5第五种方案：List封装in：
Dao层的函数方法：public List getXXXBeanList(List list);
对应的Mapper.xml

　　select 字段... from XXX where id in
　　
　　　　#{item}
　　

foreach 最后的效果是select 字段... from XXX where id in ('1','2','3','4')

5.6第六种方案：

selectList()只能传递一个参数，但实际所需参数既要包含String类型，又要包含List类型时的处理方法：

将参数放入Map，再取出Map中的List遍历。如下：

List list_3 = new ArrayList();
Map map2 = new HashMap();

list.add("1");
list.add("2");
map2.put("list", list); //网址id

map2.put("siteTag", "0");//网址类型

Dao层的函数方法：
public List getSysInfo(Map map2) {
　　return getSqlSession().selectList("sysweb.getSysInfo", map2);
}

对应的Mapper.xml：

　　select t.sysSiteId, t.siteName, t1.mzNum as siteTagNum, t1.mzName as siteTag, t.url, t.iconPath
from TD_WEB_SYSSITE t
left join TD_MZ_MZDY t1 on t1.mzNum = t.siteTag and t1.mzType = 10
WHERE t.siteTag = #{siteTag }
and t.sysSiteId not in

#{item}

resultclass属于隐身映射，在性能方面，resultMap要比resultClass高，所以建议尽量使用resultMap。

返回类型resultMap：resultType是直接表示返回类型的，而resultMap则是对外部ResultMap的引用，但是resultType跟resultMap不能同时存在。

 

传入参数parameterType：
parameterType="int"
parameterType="User"
parameterType="java.lang.Integer"
parameterType="string"
parameterType="java.util.Map"
parameterType="java.util.ArrayList"

返回类型resultType：
resultType="java.lang.Integer"
resultType="实体类"
resultType="java.util.HashMap"
resultType="java.lang.String"

转载于:https://www.cnblogs.com/ZJOE80/p/10184839.html