五、mybaitis学习 ——代理方式面向注解编程(mybatis三种编程方式之一)
一、常用注解
@Select:查询
@Update:修改
@Insert:添加
@Delete:删除
@Options:可用于设置封装自增长主键
@Results:用法类是配置文件的ResultMap
@Result:用于配置表字段和javaBean字段的的关联关系
@many:用于封装关联对象为集合
@one::用于封装关联对象为javaBean实体
二、注解的属性
1. select update insert delete 注解中的value
该值用于保存sql语句
说明:对于增删改三个注解之间在mybatis中其实可以混用,这个主要取决于mybatis底层的工作机制,在执行增删改的操作时最终统一调用的都是update方法
2.Options :主要介绍有2个属性
1)useGeneratedKeys = true:设置添加完成后封装自增长主键
2)keyProperty = "id":设置封装的字段名为id
说明:这两个属性必须同时使用才有效,用法同xml配置类似
3.@Results:此注解相当于配置文件的ResultMap ,主要介绍一个属性value
value:属性的值为一个注解集合,用于设置表和实体的关联关系
4.@Result
1)column 值为表字段名
2) property 值为JavaBean实体字段名
3) many 值固定为@many注解,用于配置一对多关联关系,及引用的是封装了javaBean的集合
4) one 值固定为@one注解,用于配置一对一关联关系,及引用的是一个javaBean实体
5.@many: @one: 均有两个属性
1)select:引用的从表sql语句
2)fetchType:主要介绍一个值FetchType
其中FetchType又有三个值(类型为枚举),这里只介绍两个
a.EAGER 不使用延迟加载(one可以使用)
b.LAZY 使用延迟加载(many推荐使用)
说明:注解的多表查询使用的是延迟加载的模式,主要依赖于@many @one两个注解
三、实例说明1.简单的增删改查
1、javaBean实体
账户:
public class Account implements Serializable {
private Integer aid;
private Integer userId;
private Double userMoney;
private User user;
public Account () {
}
public Account (Integer aid, Integer userId, Double userMoney, User user) {
this .aid = aid;
this .userId = userId;
this .userMoney = userMoney;
this .user = user;
}
public User getUser () {
return user;
}
public void setUser (User user) {
this .user = user;
}
public Integer getAid () {
return aid;
}
public void setAid (Integer aid) {
this .aid = aid;
}
public Integer getUserId () {
return userId;
}
public void setUserId (Integer userId) {
this .userId = userId;
}
public Double getUserMoney () {
return userMoney;
}
public void setUserMoney (Double userMoney) {
this .userMoney = userMoney;
}
@Override
public String toString () {
return "Account [aid=" + aid + ", userId=" + userId + ", userMoney=" + userMoney + ", user=" + user + "]" ;
}
}
用户:
public class User implements Serializable {
private Integer id;
private String username;
private Date birthday;
private String sex;
private String address;
private List<Account> accounts;
public User () {
}
public User (Integer id, String username, Date birthday, String sex, String address, List<Account> accounts) {
this .id = id;
this .username = username;
this .birthday = birthday;
this .sex = sex;
this .address = address;
this .accounts = accounts;
}
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 Date getBirthday () {
return birthday;
}
public void setBirthday (Date birthday) {
this .birthday = birthday;
}
public String getSex () {
return sex;
}
public void setSex (String sex) {
this .sex = sex;
}
public String getAddress () {
return address;
}
public void setAddress (String address) {
this .address = address;
}
public List<Account> getAccounts () {
return accounts;
}
public void setAccounts (List<Account> accounts) {
this .accounts = accounts;
}
@Override
public String toString () {
return "User [id=" + id + ", username=" + username + ", birthday=" + birthday + ", sex=" + sex + ", address="
+ address + ", accounts=" + accounts + "]" ;
}
}
2简单的增删该查
用户dao:
public interface UserDao {
/**
*根据id查询用户
*@Select:用于查询的注解
*/
@Select ("select * from user where id =#{uid}" )
User getUserByUid(Integer uid);
/**
*模糊查询用户
* ${value}:基于statement的字符拼接
*/
@Select ("select * from user where username like '%${value}%'" )
List<User> fuzzyQueryUserByUname(String username);
/**
*添加用户
*@Insert:用于添加的注解
*@Options:可以设置封装自增长主键,用法类似基于配置文件编程方式
*useGeneratedKeys = true:设置添加完成后封装自增长主键
*keyProperty = "id":设置封装的字段名为id
*
*/
@Insert ("insert into user (username,sex,birthday,address) values(#{username},#{sex},#{birthday},#{address})" )
@Options (useGeneratedKeys = true , keyProperty = "id" )
int insertUser(User user);
/**
*修改用户,通过用户id
*@Update:用于修改的注解
*/
@Update ("update user set username = #{username} where id =#{id}" )
int update(User user);
/**
*删除用户,通过用户id
*@Update:用于删除的注解
*/
@Delete ("delete from user where id =#{id}" )
int delete(Integer i);
}
3一对多
用户dao:
public interface UserDao {
/**
*根据查询所有用户,并且封装关联对象accounts账户
*@Select:用于查询的注解
*@Results:用法类是配置文件的ResultMap
*@Result:用于配置表字段和javaBean字段的的关联关系
*column:1表字段,
* 2在进行关联对象配置时,则代表用于查询分表的关联字段,相当于Xml中的ofType,javaType
*property:javaBean
*many:1当封装的关联对象为集合是,可以用many进行关联配置,相当于XML配置文件collection标签的作用
* 2值固定为注解@many
*one:1当封装的关联对象为javaBean实体时,可以用one进行关联配置,相当于XML配置文件association标签的作用
* 2值固定为注解@one
*select:@many或者@one注解中的select代表的关联字段sql语句的引用(包全限定名+方法名),
* fetchType=FetchType.LAZY 使用延迟加载(一对多建议使用言辞加载)
* FetchType 主要使用的有两个值 LAZY(延迟加载) EAGER(及时加载)
*/
@Results (value = {
@Result (column="id" ,property="id" ),
@Result (column="username" ,property="username" ),
@Result (column="sex" ,property="sex" ),
@Result (column="birthday" ,property="birthday" ),
@Result (column="address" ,property="address" ),
@Result (
property="accounts" ,
column="id" ,
many=@Many (
select="cn.itcast.demo.dao.AccountDao.getAccountByUid" ,
fetchType=FetchType.EAGER)),
})
@Select ("select * from user" )
List<User> getAll();
}
账户dao:
public interface AccountDao {
/**
*根据id查询账户
*@Select:用于查询的注解
*当javaBean和表字段名称不同时:
* 1可以通过起别名的方式进行封装,
* 2也可以通过Results进行关联配置
*/
@Select ("select id aid ,uid userId ,money userMoney from account where uid = #{uid}" )
List<Account> getAccountByUid(Integer uid);
}
4一对一
账户dao:
public interface AccountDao {
List<Account> findAll(Account ac);
/**
*根据查询所有用户,并且封装关联对象accounts账户
*@Select:用于查询的注解
*@Results:用法类是配置文件的ResultMap
*@Result:用于配置表字段和javaBean字段的的关联关系
*column:1表字段,
* 2在进行关联对象配置时,则代表用于查询分表的关联字段,相当于Xml中的ofType,javaType
*property:javaBean
*many:1当封装的关联对象为集合是,可以用many进行关联配置,相当于XML配置文件collection标签的作用
* 2值固定为注解@many
*one:1当封装的关联对象为javaBean实体时,可以用one进行关联配置,相当于XML配置文件association标签的作用
* 2值固定为注解@one
*select:@many或者@one注解中的select代表的关联字段sql语句的引用(包全限定名+方法名),
* fetchType=FetchType.EAGER 不使用延迟加载(一对一可以不使用延迟加载)
* FetchType 主要使用的有两个值 LAZY(延迟加载) EAGER(及时加载)
*/
@Results ({
@Result (column="id" ,property="aid" ),
@Result (column="uid" ,property="userId" ),
@Result (column="money" ,property="userMoney" ),
@Result (
column="uid" ,
property="user" ,
one=@One (select="cn.itcast.demo.dao.UserDao.getUserByUid" ,
fetchType=FetchType.EAGER)),
})
@Select ("select * from account" )
List<Account> getAll();
}
用户dao:
public interface UserDao {
/**
*根据id查询用户
*@Select:用于查询的注解
*/
@Select ("select * from user where id =#{uid}" )
User getUserByUid(Integer uid);
}
5.user测试类
public class testUser {
private SqlSessionFactory sqlSessionFactory;
@Before
public void befor () throws Exception {
InputStream is = Resources.getResourceAsStream("SqlMapConfig.xml" );
sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
}
@Test
public void testgetAll () throws Exception {
SqlSession sqlSession = sqlSessionFactory.openSession();
UserDao userDao = sqlSession.getMapper(UserDao.class);
List<User> users = userDao.getAll();
for (User user : users) {
System.out.println(user);
}
sqlSession.close();
}
@Test
public void testfuzzyQueryUserByUname () throws Exception {
SqlSession sqlSession = sqlSessionFactory.openSession();
UserDao userDao = sqlSession.getMapper(UserDao.class);
List<User> users = userDao.fuzzyQueryUserByUname("王" );
for (User user : users) {
System.out.println(user);
}
sqlSession.close();
}
@Test
public void testInsert () throws Exception {
SqlSession sqlSession = sqlSessionFactory.openSession();
UserDao userDao = sqlSession.getMapper(UserDao.class);
User user = new User();
user.setUsername("cting" );
user.setBirthday(new Date());
user.setSex("女" );
int row = userDao.insertUser(user);
System.out.println(user);
sqlSession.commit();
sqlSession.close();
}
@Test
public void testUpdate () throws Exception {
SqlSession sqlSession = sqlSessionFactory.openSession();
UserDao userDao = sqlSession.getMapper(UserDao.class);
User user = new User();
user.setUsername("徐" );
user.setId(91 );
int row = userDao.update(user);
sqlSession.commit();
sqlSession.close();
}
@Test
public void testDel () throws Exception {
SqlSession sqlSession = sqlSessionFactory.openSession();
UserDao userDao = sqlSession.getMapper(UserDao.class);
int row = userDao.delete(56 );
sqlSession.commit();
sqlSession.close();
}
}
6.account测试类
public class testAccount {
private SqlSessionFactory sqlSessionFactory;
@Before
public void befor () throws Exception {
InputStream is = Resources.getResourceAsStream("SqlMapConfig.xml" );
sqlSessionFactory = new SqlSessionFactoryBuilder().build(is );
}
@Test
public void testgetAll () throws Exception {
SqlSession sqlSession = sqlSessionFactory.openSession();
AccountDao accountDao = sqlSession.getMapper(AccountDao.class);
List<Account> accounts = accountDao.getAll();
for (Account account : accounts) {
System.out .println(account);
}
sqlSession.close();
}
@Test
public void testgetbyuid () throws Exception {
SqlSession sqlSession = sqlSessionFactory.openSession();
AccountDao accountDao = sqlSession.getMapper(AccountDao.class);
List<Account> accounts = accountDao.getAccountByUid(41 );
for (Account account : accounts) {
System.out .println(account.getUserMoney());
}
sqlSession.commit();
sqlSession.close();
System.out .println("========================================" );
SqlSession sqlSession1 = sqlSessionFactory.openSession();
AccountDao accountDao1 = sqlSession1.getMapper(AccountDao.class);
List<Account> accounts1 = accountDao1.getAccountByUid(41 );
for (Account account1 : accounts1) {
System.out .println(account1.getUserMoney());
}
sqlSession1.close();
}
}