mybatis学习(注解开发)

使用 Mybatis 注解实现基本 CRUD

实体类

//用户实体类
public class User implements Serializable {
    private Integer id;
    private  String username;
    private  String address;
    private  Date birthday;
    private  String sex;
    private List<Account> accounts;
    public List<Account> getAccounts() {
        return accounts;
    }
    public void setAccounts(List<Account> accounts) {
        this.accounts = accounts;
    }
    public User() {
        super();
    }
    public User(Integer id, String username, String address,Date birthday, String sex) {
        this.id = id;
        this.username = username;
        this.address = address;
        this.birthday = birthday;
        this.sex = sex;
    }
    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 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;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", address='" + address + '\'' +
                ", birthday='" + birthday + '\'' +
                ", sex='" + sex + '\'' +
                '}';
    }
}


//账户实体类
public class Account  implements Serializable {
    private Integer aid;
    private Integer uid;
    private  String money;
    private  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 getUid() {
        return uid;
    }

    public void setUid(Integer uid) {
        this.uid = uid;
    }

    public String getMoney() {
        return money;
    }

    public void setMoney(String money) {
        this.money = money;
    }

    @Override
    public String toString() {
        return "Account{" +
                "aid=" + aid +
                ", uid=" + uid +
                ", money='" + money + '\'' +
                '}';
    }
}

持久层

public interface UserMapper {
    //查询所有
    @Select("select * from user")
    List<User> findAll();
    //根据id查一个
    @Select("select * from user where id=#{id}")
    User findUserById(Integer id);
    //更新
    @Update("update  user set username=#{username},address=#{address},birthday=#{birthday},sex=#{sex} where id=#{id}")
    void updateUser(User user);
    //增加
    @Insert("insert into user(username,address,birthday,sex)values(#{username},#{address},#{birthday},#{sex})")
    void insertUser(User user);
    //删除
    @Delete("delete from  user where id=#{id}")
    void deleteUserById(Integer id);
    //模糊查询
    @Select("select * from user where username like #{username}")
    List<User> findByName(String name);
   
    @Select("select count(*) from user")
    int countUser();
}

mybatis-config.xml

<?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 resource="jdbc.properties"></properties>
  
    <typeAliases >
    <typeAlias type="zlb.domain.User" alias="user"></typeAlias>
    <typeAlias type="zlb.domain.Account" alias="account"></typeAlias>
    </typeAliases>
    <environments default="development">
        <environment id="development">
            <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>
        <mapper class="zlb.dao.UserMapper"></mapper>
        <mapper class="zlb.dao.AccountMapper"></mapper>
    </mappers>
</configuration>

jdbc.properties

jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mybatis?useUnicode=true&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=UTC
jdbc.username=root
jdbc.password=151630

测试

public class MybatisTest {

    private  InputStream inputStream;
    private SqlSession sqlSession;

    private  UserMapper userMapper;

    @Before
    public void init() throws Exception {
        inputStream=Resources.getResourceAsStream("mybatis-config.xml");
       SqlSessionFactory factory=new SqlSessionFactoryBuilder().build(inputStream);
        sqlSession=factory.openSession(true);
        userMapper=sqlSession.getMapper(UserMapper.class);
    }
    @After
    public void destroy() throws Exception {
        sqlSession.close();
        inputStream.close();
    }
    @Test
    public  void testFindAll(){
        List<User> users = userMapper.findAll();
        for (User user : users) {
            System.out.println(user);
        }
        System.out.println(users);
    }
    @Test
    public  void testFindById(){
        User user = userMapper.findUserById(55);
        System.out.println(user);
    }
    @Test
    public  void testInsert(){
        User user=new User(null,"爱爱","湖南娄底",new Date(),"男");
       userMapper.insertUser(user);
    }
    @Test
    public  void testUpdate(){
        User user = userMapper.findUserById(55);
        user.setUsername("胡歌");
        user.setAddress("湖南娄底");
        user.setBirthday(new Date());
        user.setSex("男");
        userMapper.updateUser(user);
    }
    @Test
    public  void testDelete(){
      userMapper.deleteUserById(57);
    }
    @Test
    public  void testFindByName(){
        List<User> users = userMapper.findByName("%王%");
        for (User user : users) {
            System.out.println(user);
        }
    }
    @Test
    public  void testCountUser(){
        int countUser = userMapper.countUser();
        System.out.println(countUser);
    }

}

一对一注解查询

账户持久层

 /*
    * 查询所有账户信息，并根据外键uid（对应着用户表的主键id,
    * 然后根据用户持久层的根据id查找一个用户的方法，
    * 来找出与账户一一对应的用户信息
    * */
    @Select("select * from account")
    @Results(id ="accountMap",value ={
       @Result(id =true,property ="aid",column = "aid"),
       @Result(property ="money",column = "money"),
       @Result(property ="uid",column = "uid"),
         //这里的property所填内容是账户实体类中的成员变量：用户
         // private  User user;
         //然后根据uid来查询用户信息
        @Result(property ="user",column="uid",
               one=@One(select ="zlb.dao.UserMapper.findUserById",fetchType= FetchType.LAZY))
    } )
    List<Account> findAll();

  /*
    * 根据用户id，查询用户的所有账户信息
    * */
    @Select("select * from  account where uid=#{uid}")
    List<Account> findById(Integer uid);

测试

public class AccountTest {

    private InputStream inputStream;
    private SqlSession sqlSession;

    private AccountMapper accountMapper;

    @Before
    public void init() throws Exception {
        inputStream= Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactory factory=new SqlSessionFactoryBuilder().build(inputStream);
        sqlSession=factory.openSession(true);
       accountMapper=sqlSession.getMapper(AccountMapper.class);
    }
    @After
    public void destroy() throws Exception {
        sqlSession.close();
        inputStream.close();
    }
    @Test
    public  void test01(){
        List<Account> accounts = accountMapper.findAll();
        for (Account account : accounts) {
            System.out.println("每个账户的信息");
            System.out.println(account);
            System.out.println("账户对应的用户信息");
            System.out.println(account.getUser());
            System.out.println("=========");
        }
}

一对多注解查询

用户持久层

public interface UserMapper {
   //查询所有
    @Select("select * from user")
    @Results(id = "userMap",value = {
      @Result(id = true,property = "id",column = "id"),
      @Result(property = "username",column = "username"),
      @Result(property = "address",column = "address"),
      @Result(property = "birthday",column = "birthday"),
      @Result(property = "sex",column = "sex"),
       //property的值为：
       // private List<Account> accounts;中的集合accounts
      @Result(property = "accounts",column = "id",
              //一个用户有多个账户，所以用many
              many = @Many(select = "zlb.dao.AccountMapper.findById",fetchType = FetchType.LAZY ))
    })
    List<User> findAll();
    //根据id查一个
    @Select("select * from user where id=#{id}")
    User findUserById(Integer id);
    }

测试

public class UserTest {

    private InputStream inputStream;
    private SqlSession sqlSession;
    private UserMapper userMapper;

    @Before
    public void init() throws Exception {
        inputStream= Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactory factory=new SqlSessionFactoryBuilder().build(inputStream);
        sqlSession=factory.openSession(true);
       userMapper=sqlSession.getMapper(UserMapper.class);
    }
    @After
    public void destroy() throws Exception {
        sqlSession.close();
        inputStream.close();
    }
    @Test
    public  void test01(){
        List<User> users = userMapper.findAll();
        for (User user : users) {
            System.out.println("每个用户的信息");
            System.out.println(user);
            System.out.println("每个用户的账户信息");
            System.out.println(user.getAccounts());
            System.out.println("=======");
        }
    }
}

mybatis 基于注解的二级缓存

在mybatis配置文件中开启二级缓存支持

<!-- 配置二级缓存 --> <settings>
<!-- 开启二级缓存的支持 --> <setting name="cacheEnabled" value="true"/>
</settings>

在持久层接口中使用注解配置二级缓存

@CacheNamespace(blocking=true)//mybatis 基于注解方式实现配置二级缓存