目录
- Mybatis基于注解的开发
- 01Mybatis的常用注解
- 02使用Mybatis注解实现CRUD
- 2.1 新建maven工程(Mybatis)
- 2.2 数据库还是使用之前的数据库
- 2.3 编写实体类(User.java)
- 2.4 编写 SqlMapConfig 配置文件
- 2.5db.properties和log4j.properties
- 2.6 使用注解方式配置持久层接口(重点在这里)
- 2.7编写测试类(UserTest.java)
- 03使用注解完成复杂的映射关系以及实现延时加载
- 3.1复杂映射关系的说明
- 3.2 复杂映射关系之一对一
- 3.2.1前景提要
- 3.2.2 Account实体类
- 3.2.2 User实体类
- 3.2.3IAccounDao接口(重点)
- 3.2.4 IUserDao接口(重点)
- 3.2.5 AccountTest.java 测试类
- 3.3复杂映射关系之一对多
- 04Mybatis基于注解的二级缓存
Mybatis基于注解的开发
- Mybatis 也可以使用注解开发方式,这样我们就可以减少编写 Mapper 映射文件了(即:IUserDao.xml和IAccountDao.xml)。
01Mybatis的常用注解
@Insert:实现新增
@Update:实现更新
@Delete:实现删除
@Select:实现查询
@Result:实现结果集封装
@Results:可以与@Result 一起使用,封装多个结果集
@ResultMap:实现引用@Results 定义的封装
@One:实现一对一结果集封装
@Many:实现一对多结果集封装
@SelectProvider: 实现动态 SQL 映射
@CacheNamespace:实现注解二级缓存的使用
- 其中对应CRUD的注解为:Insert,Update,Select,Delete
02使用Mybatis注解实现CRUD
- 我们再次做的是单表的 CRUD 操作
2.1 新建maven工程(Mybatis)
- 坐标
<packaging>jar</packaging>
<dependencies>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.4.5</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.6</version>
</dependency>
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.12</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.10</version>
</dependency>
</dependencies>
2.2 数据库还是使用之前的数据库
- 在第一次笔记里面创建的myMybatis数据库
2.3 编写实体类(User.java)
- 注意:此处的实体列属性和数据库字段不是一一对应的
- 实体类要是实现Serializable接口,生成set和get方法,重写toString方法
private Integer userId;
private String userName;
private Date userBirthday;
private String userSex;
private String userAddress;
2.4 编写 SqlMapConfig 配置文件
<?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>
<!-- 配置 properties 文件的位置 -->
<properties resource="jdbcConfig.properties"></properties>
<!-- 配置别名的注册 -->
<typeAliases>
<package name="com.itheima.domain"/>
</typeAliases>
<!-- 配置环境 -->
<environments default="mysql">
<!-- 配置 mysql 的环境 -->
<environment id="mysql">
<!-- 配置事务的类型是 JDBC -->
<transactionManager type="JDBC"></transactionManager>
<!-- 配置数据源 -->
<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>
<package name="com.itheima.dao"/>
</mappers>
</configuration>
- 配置 dao 接口的位置,它有两种方式
第一种:使用 mapper 标签配置 class 属性
第二种:使用 package 标签,直接指定 dao 接口所在的包 - 注意:resource是用来配置xml文件的,当使用注解形式进行开发的时候接口的映射配置文件(IUserDao.xml)是不能存在的,如果存在会报错,因为Mybatis会不知道你要使用哪种形式进行映射(即使不配置class属性也会报错)
2.5db.properties和log4j.properties
- db.properties
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/myMybatis
jdbc.username=root
jdbc.password=12345678
- log4j.properties
# Set root category priority to INFO and its only appender to CONSOLE.
#log4j.rootCategory=INFO, CONSOLE debug info warn error fatal
log4j.rootCategory=debug, CONSOLE, LOGFILE
# Set the enterprise logger category to FATAL and its only appender to CONSOLE.
log4j.logger.org.apache.axis.enterprise=FATAL, CONSOLE
# CONSOLE is set to be a ConsoleAppender using a PatternLayout.
log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
log4j.appender.CONSOLE.layout.ConversionPattern=%d{ISO8601} %-6r [%15.15t] %-5p %30.30c %x - %m\n
# LOGFILE is set to be a File appender using a PatternLayout.
log4j.appender.LOGFILE=org.apache.log4j.FileAppender
log4j.appender.LOGFILE.File=d:\axis.log
log4j.appender.LOGFILE.Append=true
log4j.appender.LOGFILE.layout=org.apache.log4j.PatternLayout
log4j.appender.LOGFILE.layout.ConversionPattern=%d{ISO8601} %-6r [%15.15t] %-5p %30.30c %x - %m\n
2.6 使用注解方式配置持久层接口(重点在这里)
- 通过注解方式,我们就不需要再去编写 UserDao.xml 映射文件了
- IUserDao接口
public interface IUserDao {
/*查询所有用户*/
@Select("select * from user")
//实现对结果集封装的配置,和xml中的resultMap标签功能一样
@Results(id="userMap",
value= {
@Result(id=true,column="id",property="userId"),
@Result(column="username",property="userName"),
@Result(column="sex",property="userSex"),
@Result(column="address",property="userAddress"),
@Result(column="birthday",property="userBirthday")
})
List<User> findAll();
/*根据 id 查询一个用户*/
@Select("select * from user where id = #{uid} ")
//实现引用@Results 定义的封装
@ResultMap("userMap")
User findById(Integer userId);
/*保存操作*/
//先保存后查询
@Insert("insert into user(username, sex, birthday, address)values(#{userName},#{userSex},#{userBirthday},#{userAddress})")
@SelectKey(keyColumn = "id", keyProperty = "userId", resultType = Integer.class, before = false, statement = {"select last_insert_id()"})
int saveUser(User user);
/*更新操作*/
@Update("update user set username=#{userName}, address =#{userAddress}, sex =#{userSex}, birthday =#{userBirthday}where id =#{userId}")
int updateUser(User user);
/*删除用户*/
@Delete("delete from user where id = #{userId} ")
int deleteUser(Integer userId);
/*查询使用聚合函数*/
@Select("select count(*) from user ")
int findTotal();
/*模糊查询*/
@Select("select * from user where username like #{userName} ")
List<User> findByName(String name);
}
- 注意:我们配置的Results只能用来映射接收结果集,查询的时候value中的内容应该是类属性名(可参考Inset操作)
2.7编写测试类(UserTest.java)
public class UserTest {
private InputStream in;
private SqlSessionFactory factory;
private SqlSession session;
private IUserDao userDao;
@Before//junit 的注解
public void init()throws Exception{
//1.读取配置文件
in = Resources.getResourceAsStream("SqlMapConfig.xml");
//2.创建工厂
SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
factory = builder.build(in);
//3.创建 session
session = factory.openSession();
//4.创建代理对象
userDao = session.getMapper(IUserDao.class);
}
@After//junit 的注解
public void destroy()throws Exception {
//提交事务
session.commit();
//释放资源
session.close();
//关闭流
in.close();
}
/**
* 测试查询所有
*/
@Test
public void testFindAll() {
List<User> users = userDao.findAll();
for(User user : users) {
System.out.println(user);
}
}
/**
* 测试查询一个
*/
@Test
public void testFindById() {
User user = userDao.findById(41);
System.out.println(user);
}
/**
* 测试保存
*/
@Test
public void testSave() {
User user = new User();
user.setUserName("mybatis annotation");
user.setUserSex("男");
user.setUserAddress("北京市顺义区");
user.setUserBirthday(new Date());
int res = userDao.saveUser(user);
System.out.println("影响数据库记录的行数: "+res);
System.out.println("插入的主键值: "+user.getUserId());
}
/**
* 测试更新
*/
@Test
public void testUpdate() {
User user = userDao.findById(41);
user.setUserBirthday(new Date());
user.setUserSex("女");
int res = userDao.updateUser(user);
System.out.println(res);
}
/**
* 测试删除
*/
@Test
public void testDelete() {
int res = userDao.deleteUser(63);
System.out.println(res);
}
/**
* 测试查询使用聚合函数
*/
@Test
public void testFindTotal() {
int res = userDao.findTotal();
System.out.println(res);
}
/**
* 测试模糊查询
*/
@Test
public void testFindByName() {
List<User> users = userDao.findByName("%m%");
for(User user : users) {
System.out.println(user);
}
}
}
03使用注解完成复杂的映射关系以及实现延时加载
- 实现复杂关系映射之前我们可以在映射文件中通过配置resultMap来实现,
- 在使用注解开发时我们需要借助@Results 注解, @Result 注解, @One 注解, @Many 注解
3.1复杂映射关系的说明
@Results 注解
代替的是标签<resultMap>
该注解中可以使用单个@Result 注解,也可以使用@Result 集合
例如:
@Results({@Result(), @Result() })或@Results(@Result())
@Resutl 注解
代替了 <id>标签和<result>标签
@Result 中属性介绍:
id 是否是主键字段
column 数据库的列名
property 需要装配的属性名
one 需要使用的@One 注解(@Result(one=@One)()))
many 需要使用的@Many 注解(@Result(many=@many)()))
@One 注解(一对一)
代替了<assocation>标签,是多表查询的关键,在注解中用来指定子查询返回单一对象。
@One 注解属性介绍:
select 指定用来多表查询的 sqlmapper
fetchType 会覆盖全局的配置参数 lazyLoadingEnabled。。
使用格式:
@Result(column=" ",property="",one=@One(select=""))
@Many 注解(多对一)
代替了<Collection>标签,是是多表查询的关键,在注解中用来指定子查询返回对象集合。
注意:聚集元素用来处理“一对多”的关系。需要指定映射的 Java 实体类的属性,属性的 javaType(一般为 ArrayList)但是注解中可以不定义;
使用格式:
@Result(property="",column="",many=@Many(select=""))
3.2 复杂映射关系之一对一
- 需求:加载账户信息时并且加载该账户的用户信息(多对一),根据情况可实现延迟加载。(注解方式实现)
- 多对一关系映射:从表方应该包含一个主表方的对象引用
- 注意:多对一查询和一对一查询是一样的
3.2.1前景提要
- 其中依赖关系,db.properties,log4j.properties,SqlMapConfig.xml内容和前面的一样,
- 我们只需要把IAccounDao接口,IUserDao接口,User实体类,Account实体类中的内容改写即可
3.2.2 Account实体类
private Integer id;
private Integer uid;
private Double money;
//多对一关系映射:从表方应该包含一个主表方的对象引用
private User user;
3.2.2 User实体类
private Integer userId;
private String userName;
private Date userBirthday;
private String userSex;
private String userAddress;
3.2.3IAccounDao接口(重点)
One:相当于association的配置
select 属性:代表将要执行的 sql 语句
fetchType 属性:代表加载方式,一般如果要延迟加载都设置为 LAZY 的值
public interface IAccountDao {
/**
* 查询所有账户,采用延迟加载的方式查询账户的所属用户
* @return
*/
@Select("select * from account")
@Results(id="accountMap",
value= {
@Result(id=true,column="id",property="id"),
@Result(column="uid",property="uid"),
@Result(column="money",property="money"),
@Result(column="uid", property="user",
one=@One(select="com.aismall.dao.IUserDao.findById",
fetchType=FetchType.LAZY
)
)
})
List<Account> findAll();
}
3.2.4 IUserDao接口(重点)
public interface IUserDao {
@Results(id="userMap",
value= {
@Result(id=true,column="id",property="userId"),
@Result(column="username",property="userName"),
@Result(column="sex",property="userSex"),
@Result(column="address",property="userAddress"),
@Result(column="birthday",property="userBirthday")
})
/**
* 根据 id 查询一个用户
* @param userId
* @return
*/
@Select("select * from user where id = #{uid} ")
//@ResultMap("userMap")
User findById(Integer userId);
}
3.2.5 AccountTest.java 测试类
public class AccountTest {
private InputStream in;
private SqlSessionFactory factory;
private SqlSession session;
private IAccountDao accountDao;
@Before//junit 的注解
public void init()throws Exception{
//1.读取配置文件
in = Resources.getResourceAsStream("SqlMapConfig.xml");
//2.创建工厂
SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
factory = builder.build(in);
//3.创建 session
session = factory.openSession();
//4.创建代理对象
accountDao = session.getMapper(IAccountDao.class);
}
@After//junit 的注解
public void destroy()throws Exception {
//提交事务
session.commit();
//释放资源
session.close();
//关闭流
in.close();
}
@Test
public void testFindAll() {
List<Account> accounts = accountDao.findAll();
for (Account account:accounts){
System.out.println("------------");
System.out.println(account);
System.out.println(account.getUser());
}
}
}
3.3复杂映射关系之一对多
- 需求:查询用户信息时,也要查询他的账户列表。使用注解方式实现。
- 分析:一个用户具有多个账户信息,所以形成了用户(User)与账户(Account)之间的一对多关系。
- 一对多关系映射:主表方法应该包含一个从表方的集合引用
- 在一对一的基础上进行改写
3.3.1在User实体类中添加accounts属性
//一对多关系映射:主表方法应该包含一个从表方的集合引用
private List<Account> accounts;
3.3.2在IUserDao接口中添加映射
@Many:相当于xml中的collection的配置
select 属性:代表将要执行的 sql 语句
fetchType 属性:代表加载方式,一般如果要延迟加载都设置为 LAZY 的值
1.添加在@Results标签中的value里面
@Result(column="id",property="accounts",
many=@Many(
select="com.aismall.dao.IAccountDao.findByUid",
fetchType=FetchType.LAZY
)
)
2.查询语句
@Select("select * from user")
@ResultMap("userMap")
List<User> findAll();
3.3.3在IAccountDao接口中添加映射
@Select("select * from account where uid = #{uid} ")
List<Account> findByUid(Integer userId);
3.3.4UserTest.java测试类
public class UserTest {
private InputStream in;
private SqlSessionFactory factory;
private SqlSession session;
private IUserDao userDao;
@Before//junit 的注解
public void init()throws Exception{
//1.读取配置文件
in = Resources.getResourceAsStream("SqlMapConfig.xml");
//2.创建工厂
SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
factory = builder.build(in);
//3.创建 session
session = factory.openSession();
//4.创建代理对象
userDao = session.getMapper(IUserDao.class);
}
@After//junit 的注解
public void destroy()throws Exception {
//提交事务
session.commit();
//释放资源
session.close();
//关闭流
in.close();
}
/**
* 测试查询所有
*/
@Test
public void testFindAll() {
List<User> users = userDao.findAll();
for(User user : users) {
System.out.println("-----每个用户的内容-----");
System.out.println(user);
System.out.println(user.getAccounts());
}
}
}
04Mybatis基于注解的二级缓存
4.1如何开启二级缓存(主配置文件中开启)
- 在 SqlMapConfig 中开启二级缓存支持
<!-- 配置二级缓存 -->
<settings>
<!-- 开启二级缓存的支持 -->
<setting name="cacheEnabled" value="true"/>
</settings>
4.2 如何使用注解配置二级缓存(在持久层接口中配置)
@CacheNamespace(blocking=true)//mybatis 基于注解方式实现配置二级缓存
public interface IUserDao {}