数据库中的user表：
目录结构：
User实体类：
public class User implements Serializable {
private Integer id;
private String username;
private String address;
private String sex;
private Date birthday;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public Date getBirthday() {
return birthday;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
}
使用注解方式开发DAO接口：
/**
* <p>
* 用户的持久层接口
*/
public interface IUserDao {
/**
* 查询所有用户，同时获取到用户所属的所有角色信息
* @return
*/
@Select("select * from user")
List<User> findAll();
}
主配置文件：
<?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配置别名，它只能配置domain中类的别名 -->
<typeAliases>
<package name="com.zhu.domain"></package>
</typeAliases>
<!--配置环境-->
<environments default="mysql">
<!-- 配置mysql的环境-->
<environment id="mysql">
<!-- 配置事务 -->
<transactionManager type="JDBC"></transactionManager>
<!--配置连接池-->
<dataSource type="POOLED">
<property name="driver" value="${jdbc.driver}"></property>
<property name="url" value="${jdbc.url}"></property>
<property name="username" value="${jdbc.username}"></property>
<property name="password" value="${jdbc.password}"></property>
</dataSource>
</environment>
</environments>
<!-- 配置映射文件的位置 -->
<mappers>
<package name="com.zhu.dao"></package>
</mappers>
</configuration>
测试类:
/**
* 注解开发测试类
*/
public class MybatisAnnoTest {
/**
* 测试基于注解的mybatis使用
* @param args
*/
public static void main(String[] args) throws Exception{
//1.获取字节输入流
InputStream in = Resources.getResourceAsStream("SqlMapConfig.xml");
//2.根据字节输入流构建SqlSessionFactory
SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
//3.根据SqlSessionFactory生产一个SqlSession
SqlSession session = factory.openSession();
//4.使用SqlSession获取Dao的代理对象
IUserDao userDao = session.getMapper(IUserDao.class);
//5.执行Dao的方法
List<User> users = userDao.findAll();
for(User user : users){
System.out.println(user);
}
//6.释放资源
session.close();
in.close();
}
}
测试结果：
----->项目源码
在mybatis中针对CRUD一共有四个注解
@Insert:实现新增
@Update:实现更新
@Delete:实现删除
@Select:实现查询
上文已经使用了@Select，接下来补充其他几种来进行单表的CRUD。
在DAO接口中添加各个方法：
/**
* <p>
* 用户的持久层接口
*/
public interface IUserDao {
/**
* 查询所有用户，同时获取到用户所属的所有角色信息
* @return
*/
@Select("select * from user")
List<User> findAll();
/**
* 保存用户
* @param user
*/
@Insert("insert into user(username,address,sex,birthday)values(#{username},#{address},#{sex},#{birthday})")
void saveUser(User user);
/**
* 更新用户
* @param user
*/
@Update("update user set username=#{username},sex=#{sex},birthday=#{birthday},address=#{address} where id=#{id}")
void updateUser(User user);
/**
* 删除用户
* @param userId
*/
@Delete("delete from user where id=#{id} ")
void deleteUser(Integer userId);
/**
* 根据id查询用户
* @param userId
* @return
*/
@Select("select * from user where id=#{id} ")
User findById(Integer userId);
/**
* 根据用户名称模糊查询
* @param username
* @return
*/
@Select("select * from user where username like '%${value}%' ")
List<User> findUserByName(String username);
/**
* 查询总用户数量
* @return
*/
@Select("select count(*) from user ")
int findTotalUser();
}
测试类：
/**
* 注解方式CRUD的测试
*/
public class AnnotationCRUDTest {
private InputStream in;
private SqlSessionFactory factory;
private SqlSession session;
private IUserDao userDao;
@Before
public void init()throws Exception{
in = Resources.getResourceAsStream("SqlMapConfig.xml");
factory = new SqlSessionFactoryBuilder().build(in);
session = factory.openSession();
userDao = session.getMapper(IUserDao.class);
}
@After
public void destroy()throws Exception{
session.commit();
session.close();
in.close();
}
@Test
public void testSave(){
User user = new User();
user.setUsername("梅西");
user.setAddress("西班牙");
userDao.saveUser(user);
}
@Test
public void testUpdate(){
User user = new User();
user.setId(7);
user.setUsername("梅老板");
user.setAddress("西班牙马德里");
user.setSex("男");
user.setBirthday(new Date());
userDao.updateUser(user);
}
@Test
public void testDelete(){
userDao.deleteUser(7);
}
@Test
public void testFindOne(){
User user = userDao.findById(6);
System.out.println(user);
}
@Test
public void testFindByName(){
List<User> users = userDao.findUserByName("林");
for(User user : users){
System.out.println(user);
}
}
@Test
public void testFindTotal(){
int total = userDao.findTotalUser();
System.out.println(total);
}
}
测试结果略…
使用XML方式开发时，实现复杂关系映射可在映射文件中通过配置<resultMap>来实现， 在使用注解开发时，对应地，我们需要使用@Results 注解， @Result 注解， @One 注解， @Many 注解 。
当实体类的属性与数据库中表的列名不一致时，需要通过@Results 注解来建立它们之间的对应关系。
在IUserDao的相应方法上添加@Results注解：
@Results 注解代替的是标签<resultMap>
该注解中可以使用单个@Result 注解，也可以使用@Result 集合
@Results（{@Result（）， @Result（） }）或@Results（@Result（））
/**
* 查询所有用户，同时获取到用户所属的所有角色信息
* @return
*/
@Select("select * from user")
@Results(id="userMap",value={
@Result(id=true,column = "id",property = "userId"),
@Result(column = "username",property = "userName"),
@Result(column = "address",property = "userAddress"),
@Result(column = "sex",property = "userSex"),
@Result(column = "birthday",property = "userBirthday")
})
List<User> findAll();
@Result中的属性：
id 是否是主键字段
column 数据库的列名
property 需要装配的属性名
如此，测试findAll（）方法就能进行正常的封装，但是别的查询方法（如findById）依然不能封装。
其实 @Results注解是可复用的，使用@ResultMap即可：
/**
* 根据id查询用户
* @param userId
* @return
*/
@Select("select * from user where id=#{id} ")
@ResultMap(value = {"userMap"})
User findById(Integer userId);
简写为 @ResultMap(“userMap”)。
除了用户，还有用户的钱包！
现在的需求是：查询钱包时，同时查询出对应用户的信息，这是多对一关系，在mybatis中为一对一关系。
参考Mybatis的多表查询实例，再建立一张（钱包）表与对应的实体类：
Wallet表：
实体类：
public class Wallet implements Serializable {
private Integer id;
private Integer uid;
private Double money;
// 从表实体应该包含一个主表实体的对象引用
private User user;
public User getUser() {
return user;
}
public void setUser(User user) {
this.user = user;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public Integer getUid() {
return uid;
}
public void setUid(Integer uid) {
this.uid = uid;
}
public Double getMoney() {
return money;
}
public void setMoney(Double money) {
this.money = money;
}
@Override
public String toString() {
return "Wallet{" +
"id=" + id +
", uid=" + uid +
", money=" + money +
'}';
}
}
接着新建IWalletDao并添加查询方法：
public interface IWalletDao {
/**
* 查询所有钱包，同时还要获取到当前钱包的所属用户信息
* @return
*/
@Select("select * from wallet")
@Results(id="walletMap",value = {
@Result(id=true,column = "id",property = "id"),
@Result(column = "uid",property = "uid"),
@Result(column = "money",property = "money"),
@Result(property = "user",column = "uid",one=@One(select="com.zhu.dao.IUserDao.findById",fetchType= FetchType.EAGER))
})
List<Wallet> findAll();
}
@One 注解 （一对一）代替了<assocation>标签，是多表查询的关键，在注解中用来指定子查询返回单一对象。
使用格式：
@Result(column=" ",property="",one=@One(select=""))
@One 注解属性介绍：
select 指定用来多表查询的 sqlmapper
fetchType 会覆盖全局的配置参数 lazyLoadingEnabled，有三种属性：
分别为懒加载、立即加载和默认。
最后测试钱包的findAll方法：
需求：查询用户时，还要把用户名下的所有钱包信息查询出来。
那么需要在实体类中体现一对多关系，就得包含对方对象的集合引用：
User.java:
public class User implements Serializable {
private Integer id;
private String username;
private String address;
private String sex;
private Date birthday;
//一对多关系映射：主表实体应该包含从表实体的集合引用
private List<Wallet> wallets;
public List<Wallet> getWallets() {
return wallets;
}
编写IUserDao：
/**
* 查询所有用户，同时获取到用户下所有账户的信息
* @return
*/
@Select("select * from user")
@Results(id="userMap",value={
@Result(property = "wallets",column = "id",
many = @Many(select = "com.zhu.dao.IWalletDao.findWalletByUid",
fetchType = FetchType.LAZY))
})
List<User> findAll();
@Many 注解代替了<Collection>标签,是是多表查询的关键，在注解中用来指定子查询返回的对象集合。
格式：
@Result(property="",column="",many=@Many(select=""))
同时要在IWalletDao 中添加findWalletByUid方法:
/**
* 根据用户id查询钱包信息
* @return
*/
@Select("select * from wallet where uid = #{Uid}")
List<WalletUser> findWalletByUid();
测试User的fingAll()：
与xml方式一样，先得在主配置中开启二级缓存支持：
<!-- 配置二级缓存 -->
<settings>
<!-- 开启二级缓存的支持 -->
<setting name="cacheEnabled" value="true"/>
</settings>
接着需要在DAO接口中使用注解来配置二级缓存：
@CacheNamespace(blocking=true) //mybatis 基于注解方式实现配置二级缓存
public interface IUserDao {}