Mybatis基础
1. 什么是mybatis
MyBatis是一个优秀的持久层框架,它对jdbc的操作数据库的过程进行封装,使开发者只需要关注 SQL 本身,而不需要花费精力去处理例如注册驱动、创建connection、创建statement、手动设置参数、结果集检索等jdbc繁杂的过程代码。
2. mybatis入门
项目地址:https://github.com/zhongyushi-git/spring-collection.git。下载代码后,示例代码在mybatis-demo文件夹下。本项目是以原生的jar方式介绍的,同步的maven版本的代码见https://www.cnblogs.com/zys2019/p/14538018.html
2.1入门案例
第一步:先创建一个普通的ava工程
第二步:在根目录下新建一个lib目录
第三步:导入以下jar包
第四步:在src下新建config目录,创建db.properties文件
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/db2020?characterEncoding=utf-8
jdbc.username=root
jdbc.password=zys123456
第四步:新建pojo实体类
package com.entity;
public class User {
private int id;
private String username;
private String password;
//get和set,toString方法在此略,使用时需要生成
}
第五步:创建一个接口用于访问数据库
package com.zxh.dao;
import com.zxh.entity.User;
import java.util.List;
public interface UserDao {
List<User> findAll();
}
接口中的方法要和select的id相同。
第六步:在src下新建mapper文件夹,在mapper下新建一个UserDao.xml文件:
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.dao.UserDao">
<!--查询所有信息
id是这个select的唯一标识
resultType是返回类型
parameterType是参数类型
-->
<select id="findAll" resultType="com.dao.User">
select * from user
</select>
</mapper>
第七步:在config目录下新建配置文件SqlMapConfig.xml
<?xml version="1.0" encoding="uTF-8" ?>
<!-- mybatis核心配置 -->
<!-- 导入约束的路径 -->
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<!-- 配置信息 -->
<configuration>
<!-- 引入并加载外部文件 -->
<properties resource="config/db.properties"></properties>
<!-- 给类取别名 -->
<typeAliases>
<!-- 使用包扫描方式取别名 -->
<package name="com.zxh.entity"/>
</typeAliases>
<!-- 环境配置的集合 -->
<environments default="mysql">
<environment id="mysql">
<!-- 事务管理:type指定事务的管理方式,jdbc:交给jdbc管理,MANAGED:被管理 -->
<transactionManager type="JDBC"></transactionManager>
<!-- 数据库配置:type是否使用连接池,POOLED:使用连接池,UNPOOLED:不使用连接池 -->
<dataSource type="POOLED">
<property name="driver" value="${jdbc.driver}" />
<property name="url" value="${jdbc.url}" />
<property name="username" value="${jdbc.username}" />
<property name="password" value="${jdbc.password}" />
</dataSource>
</environment>
</environments>
<!-- 加载映射文件 -->
<mappers>
<!-- 单独加载映射文件-->
<mapper resource="mapper/UserDao.xml"></mapper>
</mappers>
</configuration>
第八步:编写测试类
package com.zxh.test;
import com.zxh.dao.UserDao;
import com.zxh.entity.User;
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.io.IOException;
import java.io.Reader;
import java.util.List;
public class MyTest {
@Test
public void findAll() throws IOException {
//加载核心配置文件
Reader reader = Resources.getResourceAsReader("config/SqlMapConfig.xml");
//创建SessionFactory
SqlSessionFactory build = new SqlSessionFactoryBuilder().build(reader);
//创建一个session对象
SqlSession session = build.openSession();
UserDao userMapper = session.getMapper(UserDao.class);
List<User> list = userMapper.findAll();
System.out.println(list);
}
}
第八步:执行sql脚本
create database db2020;
CREATE TABLE user (
id int(11) NOT NULL,
username varchar(255) DEFAULT NULL,
password varchar(255) DEFAULT NULL,
PRIMARY KEY (id)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
insert into user values(1,'admin','123');
insert into user values(2,'zhnagsan','456789');
insert into user values(3,'zxh','zxh');
第九步:测试。运行测试方法,在控制台打印了查询的结果。
2.2配置日志文件
已经导入了log4j的jar,主要是在这里使用。
1)在src新建一个log4j.properties文件,配置如下:
### 设置当前日志级别 ###
log4j.rootLogger = debug,stdout,D,E
### 输出信息到控制抬 ###
log4j.appender.stdout = org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target = System.out
log4j.appender.stdout.layout = org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern = [%-5p] %d{yyyy-MM-dd HH:mm:ss,SSS} method:%l%n%m%n
### 输出DEBUG 级别以上的日志到=E://logs/log.log ###
log4j.appender.D = org.apache.log4j.DailyRollingFileAppender
log4j.appender.D.File = E://logs/log.log
log4j.appender.D.Append = true
log4j.appender.D.Threshold = DEBUG
log4j.appender.D.layout = org.apache.log4j.PatternLayout
log4j.appender.D.layout.ConversionPattern = %-d{yyyy-MM-dd HH:mm:ss} [ %t:%r ] - [ %p ] %m%n
### 输出ERROR 级别以上的日志到=E://logs/error.log ###
log4j.appender.E = org.apache.log4j.DailyRollingFileAppender
log4j.appender.E.File =E://logs/error.log
log4j.appender.E.Append = true
log4j.appender.E.Threshold = ERROR
log4j.appender.E.layout = org.apache.log4j.PatternLayout
log4j.appender.E.layout.ConversionPattern = %-d{yyyy-MM-dd HH:mm:ss} [ %t:%r ] - [ %p ] %m%n
需要注意的是,此文件名必须是log4j.properties,另外位置必须放在资源目录下(src根目录)。
2)在测试类中创建日志对象,把信息写到日志文件中,方便查阅:
//创建日志对象
Logger logger = Logger.getLogger(MyTest.class);
3)在查询的方法中添加一个日志的输出
logger.info("我是日志信息");
再次测试会在控制台输出一些日志,这句代码放在类中方法之前,debug信息会自动写到文件中,error信息要在发生异常的地方手动添加。
2.3自定义文件
每次创建xml都比较麻烦,可以自定义一个xml文件,使用起来方便点。操作如下图:
3. mybatis的增删改查
3.1方法优化
由于会重复的SqlSessionFactory对象,因此可以把其提取出来,在类加载时就初始化,提高代码复用性。因此,在测试类添加如下代码:
public SqlSessionFactory build = null;
//这个在方法加载的时候就会初始化
@Before
public void before() {
Reader reader = null;
//加载核心配置文件
try {
reader = Resources.getResourceAsReader("SqlMapConfig.xml");
//创建SessionFactory
build = new SqlSessionFactoryBuilder().build(reader);
} catch (IOException e) {
e.printStackTrace();
}
}
3.2根据id查询
1)在userDao接口添加方法
User findById(Integer id);
2)在UserDao.xml中添加方法
<!-- 如果参数是简单数据类型,可以省略 -->
<select id="findById" parameterType="int" resultType="User">
select * from user where id=#{id}
</select>
3)新建测试方法
@Test
public void findById() {
SqlSession session = build.openSession();
UserDao userMapper = session.getMapper(UserDao.class);
User user = userMapper.findById(2);
System.out.println(user);
}
查询所有的方法在入门案例已介绍,在此略。
3.3根据用户名和密码查询
1)在userDao接口添加方法
User findByNmAndPwd(User user);
2)在UserDao.xml中添加方法
<select id="findByNmAndPwd" parameterType="User" resultType="User">
select * from user where username=#{username} and password=#{password}
</select>
#{ }里面的参数一定要和对象中的属性保持一致
3)新建测试方法
@Test
public void findByNmAndPwd(){
SqlSession session = build.openSession();
UserDao userMapper = session.getMapper(UserDao.class);
User user=new User();
user.setUsername("admin");
user.setPassword("123");
User user2 = userMapper.findByNmAndPwd(user);
System.out.println(user2);
}
3.4添加用户
1)在userDao接口添加方法
int addUser(User user);
2)在UserDao.xml中添加方法
<insert id="addUser" parameterType="User">
insert into user values(null,#{username},#{password})
</insert>
3)新建测试方法
@Test
public void addUser() {
SqlSession session = build.openSession();
UserDao userMapper = session.getMapper(UserDao.class);
User user = new User();
user.setUsername("方启豪5号");
user.setPassword("12315");
int i = userMapper.addUser(user);
session.commit();//提交事务
System.out.println(i);
}
增加、修改、删除修改一定要提交事务
3.5修改用户
1)在userDao接口添加方法
int updateUser(User user);
2)在UserDao.xml中添加方法
<update id="updateUser" parameterType="User">
update user set username=#{username},password=#{password} where id=#{id}
</update>
3)新建测试方法
@Test
public void updateUser() {
SqlSession session = build.openSession();
UserDao userMapper = session.getMapper(UserDao.class);
User user = new User();
user.setId(10);
user.setUsername("方启豪2号");
user.setPassword("123");
userMapper.updateUser(user);
session.commit();
}
3.6删除用户
1)在userDao接口添加方法
int deleteUser(Integer id);
2)在UserDao.xml中添加方法
<delete id="deleteUser"> delete from user where id=#{value} </delete>
3)新建测试方法
@Test
public void deleteUser() {
SqlSession session = build.openSession();
UserDao userMapper = session.getMapper(UserDao.class);
userMapper.deleteUser(10);
session.commit();
}
3.7模糊查询:一个条件
一个条件的模糊查询是特例,使用${},并且括号里面只能写value,这里参数是简单数据类型
1)在userDao接口添加方法
List<User> findByLikeOne(String username);
2)在UserDao.xml中添加方法
<!-- 模糊查询:一个条件,使用${},并且括号里面只能写value --> <select id="findByLikeOne" resultType="User"> select * from user where username like '%${value}%' </select>
3)新建测试方法
@Test
public void findByLikeOne() {
SqlSession session = build.openSession();
UserDao userMapper = session.getMapper(UserDao.class);
List<User> list = userMapper.findByLikeOne("h");
System.out.println(list);
}
3.8模糊查询:多个条件
使用${},并且括号里面要与对象的属性相同。
1)在userDao接口添加方法
List<User> findByLikeMore(User user);
2)在UserDao.xml中添加方法
<!-- 模糊查询:多个条件,使用${},并且括号里面要与对象的属性相同 --> <select id="findByLikeMore" parameterType="User" resultType="User"> select * from user where username like '%${username}%' and password like '%${password}%' </select>
3)新建测试方法
@Test
public void findByLikeMore() {
SqlSession session = build.openSession();
UserDao userMapper = session.getMapper(UserDao.class);
User user = new User();
user.setUsername("h");
user.setPassword("4");
List<User> list = userMapper.findByLikeMore(user);
System.out.println(list);
}
4. 章中小结
4.1#{}和${}的区别
(1)#{}
1)表示一个占位符号,通过#{}可以实现preparedStatement向占位符中设置值,自动进行java类型和jdbc类型转换,可以有效防止sql注入。
2)可以接收简单类型值或pojo属性值。 如果parameterType传输单个简单类型值,#{}括号中可以是value或其它名称。
(2)${}
1)表示拼接sql串,通过${}可以将parameterType 传入的内容拼接在sql中且不进行jdbc类型转换
2) ${}可以接收简单类型值或pojo属性值,如果parameterType传输单个简单类型值,${}括号中只能是value。
4.2parameterType和resultType
parameterType:指定输入参数类型
resultType:指定输出结果类型
4.3mybatis与hibernate的区别
Mybatis是对jdbc的封装,注重的是sql语句,是一种轻量级的半自动框架,适用于敏捷开发,原理是反射
Hibernate注重映射关系,是一种重量级的全自动的框架。
4.4取别名typeAliases
1)mybatis支持别名,映射关系如下表:
别名 | 映射的类型 | 别名 | 映射的类型 |
_byte | byte | string | string |
_long | long | byte | byte |
_short | short | long | long |
_int | int | short | short |
_integer | int | int | int |
_double | double | integer | Integer |
_float | float | double | Double |
_boolean | boolean | float | Float |
decimal | BigDecimal | boolean | Boolean |
bigdecimal | BigDecimal | map | Map |
2)自定义别名方法
在SqlMapConfig.xml中配置:
<typeAliases>
<!-- 单个别名定义 -->
<typeAlias alias="user" type="com.entity.User"/>
<!-- 批量别名定义,扫描整个包下的类,别名为类名(首字母大写或小写都可以) -->
<package name="com.entity"/>
<package name="其它包"/>
</typeAliases>
可以配置单个别名,也可以直接扫描整个包,建议使用第二种方式。
4.6mappers(映射器)
Mapper配置的几种方法:
代码 | 说明 | 示例 | 备注 |
<mapper resource=" " /> | 使用相对于类路径的资源 | <mapper resource="sqlmap/User.xml" /> | |
<mapper class=" " /> | 使用mapper接口类路径 | <mapper class="com.mapper.UserMapper"/> | 要求mapper接口名称和mapper映射文件名称相同,且放在同一个目录中 |
<package name=""/> | 注册指定包下的所有mapper接口 | <package name="com.mapper"/> | 要求mapper接口名称和mapper映射文件名称相同,且放在同一个目录中 |
4.7 dao接口开发规范
只需要编写Mapper接口,非常适用于mybatis,Mapper接口开发需要遵循以下规范,代码在入门中已说明这些:
1、Mapper.xml文件中的namespace与mapper接口的路径相同。
2、Mapper接口方法名和Mapper.xml中定义的每个statement的id相同
3、Mapper接口方法的输入参数类型和mapper.xml中定义的每个sql 的parameterType的类型相同
4、Mapper接口方法的输出参数类型和mapper.xml中定义的每个sql的resultType的类型相同
5.resultMap与parameterMap
5.1复杂条件的查询举例
当参数不属于同一个对象时,使用简单的查询非常麻烦,那么可以把一个对象作为另一个对象的属性结合使用,示例如下。
1)新建三个实体类
Person类
package com.zxh.entity;
public class Person {
private String username;
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
}
People类
package com.zxh.entity; public class People { private String password; public String getPassword() { return password; } public void setPassword(String password) { this.password = password; } }
PVo类:把上面的两个对象作为属性给PVo
package com.zxh.entity;
public class PVo {
private People people;
private Person person;
//get/set方法略
}
2)新建接口方法
int addPvo(PVo pVo);
3)插入语句
<insert id="Pvo" parameterType="PVo"> insert into user values(12,#{person.username},#{people.password}) </insert>
4)测试方法
@Test public void addPvo() { SqlSession session = build.openSession(); UserDao userMapper = session.getMapper(UserDao.class); PVo pVo = new PVo(); People people = new People(); Person person = new Person(); people.setPassword("admin"); person.setUsername("zhangSan"); pVo.setPeople(people); pVo.setPerson(person); userMapper.addPvo(pVo); session.commit();//提交事务 }
5.2 resultMap的使用
当查询的结果不仅仅是一个对象的全部属性时,如果再创建一个对象来封装数据就显得格外的麻烦,那么可以使用resultMap来对属性进行重定义,这样就可以直接返回一个map的结果。具体的用法见代码中的注释。
5.2.1复杂查询一
查询用户的id,用户名以及所对应的成绩的id和具体成绩(一对一)
1)数据库执行sql
create table score ( id int primary key, grade float, u_id int ); insert into score values(1,99,1); insert into score values(2,90,2); insert into score values(3,85,3);
2)新建成绩类
package com.zxh.entity; public class Score { private int id; private double grade; private int u_id; public int getId() { return id; } public void setId(int id) { this.id = id; } public double getGrade() { return grade; } public void setGrade(double grade) { this.grade = grade; } public int getU_id() { return u_id; } public void setU_id(int u_id) { this.u_id = u_id; } @Override public String toString() { return "Score{" + "id=" + id + ", grade=" + grade + ", u_id=" + u_id + '}'; } }
3)给User类添加属性添加set和get及tostring方法
.... private Score score; ....
4)新建接口方法
List<User> findUserAndScore();
5)查询语句
<!-- 复杂查询:查询用户的id,用户名以及所对应的成绩的id和具体成绩 --> <!--定义表数据与组合类的映射关系,id是唯一标识,type是类型--> <resultMap id="userAndScore" type="User"> <!--id是主键映射,result是非主键映射,column是数据库中的列名,properties是对象的属性名--> <!--如果多个表中的属性名一样,要注意区分,如这里的id--> <id column="uid" property="id"></id> <result column="username" property="username"></result> <result column="password" property="password"></result> <!--association对属性是对象的变量的深入映射,适用于一对一的关系--> <association property="score" javaType="Score"> <id column="sid" property="id"></id> <result column="grade" property="grade"></result> <result column="u_id" property="u_id"></result> </association> </resultMap> <!--这里的返回类型必须是map集合--> <select id="findUserAndScore" resultMap="userAndScore"> select user.id uid, username,score.id sid,grade from user,score where user.id=score.u_id </select>
6)测试方法
@Test
public void findUserAndScore(){
SqlSession session = build.openSession();
UserDao userMapper = session.getMapper(UserDao.class);
List<User> list=userMapper.findUserAndScore();
System.out.println(list);
}
分析:在这对一对一的关系中,mybatis使用association来标识另一个对象属性,同时要指定返回的类型是map集合。
5.2.2复杂查询二
查询用户的id,用户名以及所对应的成绩的id和具体成绩(一对多)
1)在插入一条数据。此查询是基于上述查询一的,请按步骤进行。
insert into score values(4,75,2);
2)给User类添加属性并添加set和get及tostring方法
private List<Score> scores;
3)查询语句。需要把查询一的查询语句注释!
<resultMap id="userAndScore" type="User">
<id column="uid" property="id"></id>
<result column="username" property="username"></result>
<result column="password" property="password"></result>
<!--collection对属性是对象的变量的深入映射,适用于一对多的关系-->
<!--javaType指属性是什么类型,ofType指集合中装的什么类型-->
<collection property="scores" javaType="java.util.List" ofType="Score">
<id column="sid" property="id"></id>
<result column="grade" property="grade"></result>
<result column="u_id" property="u_id"></result>
</collection>
</resultMap>
<!--这里的返回类型必须是map集合-->
<select id="findUserAndScore" resultMap="userAndScore">
select user.id uid, username,score.id sid,grade from user,score where user.id=score.u_id
</select>
分析:在这对一对多的关系中,mybatis使用collection来标识另一个集合对象属性,同时要指定返回的类型是map集合。
6.动态sql
6.1 if标签
1)语法
当标签里面test的内容为true时才会去执行if里面的语句。
2)示例
查询:根据id或用户名查询
<select id="findByMap" resultType="User">
select * from user where 1=1
<if test="id!=null">
and id=#{id}
</if>
<if test="username!=null and username!=''">
and username like '%${username}%'
</if>
</select>
此查询语句中,分别以int类型的id和string类型的username进行判断查询。而id并没有判断是否是空串,原因是它不是字符串,同理date类型等其他类型都不能加是否是空串的条件判断,否则会报错。
6.2 where标签
1)语法
where会自动去识别,当sql语句中已经有where那么它会直接拼接where里面的内容,如果没有就直接使用;另外where里面的and也类似,如果已经有where就使用and,如果没有就舍弃第一个and。
2)示例
查询:根据id或用户名查询,如果都为空就查询所有
<select id="findById2" resultType="User">
select * from user
<where>
<if test="value!=null">
and id=#{value}
</if>
</where>
</select>
这个示例其实是对上面示例的对比,两种方式,查询的结果是一样的。
6.3 foreach标签
1)语法
用来遍历集合等,用于传入参数是多个相同类型的查询,可以使用在in,limit,between。。。
2)示例
查询:传入多个id的list集合查询用户信息
<select id="findByIn" parameterType="java.util.List" resultType="User">
select * from user
<!--如果传入参数是list类型,必须使用list获取,并且使用and-->
<if test="list.size()>0 and list!=null">
where id in
<!--collection要遍历的集合,open开始的符号,close结束的符号,separator分隔符-->
<!--index是索引,item是每一条内容,这里是list.get(i)-->
<foreach collection="list" open="(" separator="," close=")" index="i" item="item" >
#{item}
</foreach>
</if>
</select>
测试方法
@Test public void test4() { SqlSession session = build.openSession(); UserDao userMapper = session.getMapper(UserDao.class); List<Integer> list=new ArrayList<Integer>(); list.add(1); list.add(2); list.add(22); List<User> list2 = userMapper.findByIn(list); System.out.println(list2); }
6.4sql片段
将会重复使用的sql语句抽取出来,需要使用的地方直接引入
<!--sql片段-->
<sql id="select">
select * from user
</sql>
<select id="findById2" resultType="User">
<!--引入sql片段-->
<include refid="select"/>
where id=#{value}
</select>
7.延迟加载
需要查询关联信息时,我们先查询一部分信息,再关联查询关联信息,叫延迟加载。主要通过resultMap实现延迟加载。延迟加载需要导入cglib以及asm的jar包。
7.1打开延时加载的开关
在SqlMapConfig.xml中配置:
<settings>
<!-- 延迟加载开关 -->
<setting name="lazyLoadingEnabled" value="true"/>
<!-- 当设置为true的时候,懒加载的对象可能被任何懒属性全部加载。否则,每个属性都按需加载-->
<setting name="aggressiveLazyLoading" value="false"/>
</settings>
7.2写sql语句
根据用户名和密码查询出id,然后再根据id查询对应的成绩
查询之后可以看到先执行一次查询,然后再去执行后面的查询,并没有一次性查询出结果。
8. Mybatis缓存
将从数据库查询的数据存储到内存中缓存起来,这样就不用从数据库中查询数据而从缓存中查询,提高查询的速度,减少对数据库的访问。
8.1一级缓存
1)原理
当执行两条相同的查询语句时,mybatis只执行一次查询,map中存储了sql执行查询的结果集。是session级别的缓存,当执行增删改中的任何一个操作,缓存就会清空。
第一次查询先去缓存中找是否有缓存数据,发现没有,查询数据库,将查询到的数据写入sqlsession的一级缓存区域。
第二次查询先去缓存中找是否有缓存数据,发现有,直接从缓存区域中取出数据返回。如果执行sqlsession的添加、修改、删除等操作,会执行commit,最终会清空缓存。
2)一级缓存查询:
@Test
public void test6(){
SqlSession session = build.openSession();
UserDao userMapper = session.getMapper(UserDao.class);
User user = userMapper.findById(2);
System.out.println(user);
System.out.println("----------");
User user2=userMapper.findById(2);
System.out.println(user2);
}
从查询结果中可以看出只进行了一次的查询,第二次的查询直接从缓存中获取的。
3)一级缓存查询中执行增加操作:
@Test
public void test7(){
SqlSession session = build.openSession();
UserDao userMapper = session.getMapper(UserDao.class);
User user = userMapper.findById(2);
System.out.println(user);
User user3=new User();
user3.setUsername("方启豪6号");
user3.setPassword("12315");
userMapper.addUser(user3);
session.commit();//提交事务
System.out.println("----------");
User user2=userMapper.findById(2);
System.out.println(user2);
}
只要清空了session,那么就清除了缓存,就需要重新查询。也可以手动清空session,语句是
8.2二级缓存
1)原理
二级缓存是mapper(命名空间)级别的缓存,默认是开启的,只有session提交或关闭时才能把结果提交到二级缓存中,当执行增删改中的任何一个操作,缓存就会清空。
不同的sqlsession都要调用mapper下的sql语句发起数据库请求。sqlsession1执行UserMapper下的查询用户请求先从二级缓存中查找有没有数据,如果没有就从数据库中查询,并且将查询到数据存储二级缓存中。
sqlsession2执行UserMapper下的同一个查询用户请求,先从二级缓存中查找有没有数据,如果有就从二级缓存中查询数据,返回。
如果有一个sqlsession3执行UserMapper下添加、修改、删除语句,执行commit操作后,将UserMapper下的所有缓存数据全部清空。
2)二级缓存的使用
二级缓存的使用需要进行配置:
第一步:在SqlMapConfig.xml的settings中加一行代码:
<!--开启并标识二级缓存-->
<setting name="cacheEnabled" value="true"/>
第二步:在userDao.xml中加一行代码:
第三步:User类要实现Serializable接口
由于不经常使用,在此代码省略。
9. Mybatis注解
9.1@Param参数传入
当参数少于4个的时候可以使用注解参数的传入,如果参数过多,就使用原始pojo的方式
UserDao类:
//使用注解Param传递参数,引号里面的参数是要使用的参数,如#{username}
User findByNmAndPwd2(@Param("username")String username,@Param("password")String password);
userDao.xml中sql:
<select id="findByNmAndPwd2" resultType="User">
select * from user where username=#{username} and password=#{password}
</select>
测试类:
@Test
public void test8() {
SqlSession session = build.openSession();
UserDao userMapper = session.getMapper(UserDao.class);
User user = userMapper.findByNmAndPwd2("方启豪","123");
System.out.println(user);
}
9.2@Insert @Update @Delete
此注解不需要userDao.xml文件,这三个用法雷同,以update为例:
UserDao类:
//这里参数传的是一个对象
@Update("update user set username=#{user.username}, password=#{user.password} where id=#{user.id}")
void updateUser2(@Param("user")User user);
测试类:
@Test
public void test9() {
SqlSession session = build.openSession();
UserDao userMapper = session.getMapper(UserDao.class);
User user3 = new User();
user3.setId(10);
user3.setUsername("方启豪7号");
user3.setPassword("123155151");
userMapper.updateUser2(user3);
session.commit();
}
9.3@Select
此注解不需要userDao.xml文件
UserDao类:
@Select("select * from user where id=#{id}")
User findById2(@Param("id") Integer id);
测试类:
@Test
public void test10(){
SqlSession session = build.openSession();
UserDao mapper=session.getMapper(UserDao.class);
User user=mapper.findById(14);
System.out.println(user);
}
10.异常问题
10.1 Mybatis异常 There is no getter for property...
在dao层修改:
List<Article> recommandList(@Param("siteid") Integer siteid);
如上修改,给siteid @Param注入getter 即可。
总结:如果xml的parameterType属性时Map,则不需要加@Param。如果是一个int,string这种类型的参数,需要在Dao层加@Param注解;只有一个参数,xml不用if,可不加。有多个参数,dao层每个参数都要加上@Param。如果传入的参数特别多,建议直接传入一个Map。