java-mybatis多表CRUD---延时加载+缓存+注解方式实现

• pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>chinasoft</groupId>
    <artifactId>mybatis_annotation</artifactId>
    <version>1.0-SNAPSHOT</version>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
    </properties>
    

    <dependencies>
        <!--mybatis包-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.6</version>
        </dependency>

        <!--        mysql包-->
        <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.22</version>
        </dependency>

        <!--        日志包-->
        <!-- https://mvnrepository.com/artifact/log4j/log4j -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.12</version>
        </dependency>

        <!--        junit测试-->
        <!-- https://mvnrepository.com/artifact/junit/junit -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>

    </dependencies>

</project>

• mybatis.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"/>

    <typeAliases>
        <package name="com.chinasoft.domain"/>
    </typeAliases>

    <environments default="mysql">
        <environment id="mysql">
            <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>

    <!--    映射器  告知mybatis映射配置文件地址  -->
    <mappers>
        <package name="com/chinasoft/mapper"/>
    </mappers>



</configuration>

• jdbc.properties

jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql:///mybatistest?serverTimezone=Asia/Shanghai
jdbc.username=root
jdbc.password=123456

• domain包

package com.chinasoft.domain;


import java.io.Serializable;

public class Account implements Serializable {
    private Integer id;
    private Integer uid;
    private Double money;

    public Account() {
    }

    public Account(Integer id, Integer uid, Double money) {
        this.id = id;
        this.uid = uid;
        this.money = money;

    }

    public Integer getId() {
        return id;
    }

    public Integer getUid() {
        return uid;
    }

    public Double getMoney() {
        return money;
    }

    public void setId(Integer id) {
        this.id = id;
    }

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

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



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

package com.chinasoft.domain;



import java.io.Serializable;
import java.util.Date;


public class User implements Serializable {
    private Integer id;
    private String username;
    private Date birthday;
    private String sex;
    private String address;



    public User() {
    }

    public User(Integer id, String username, Date birthday, String sex, String address) {
        this.id = id;
        this.username = username;
        this.birthday = birthday;
        this.sex = sex;
        this.address = address;
    }


    public Integer getId() {
        return id;
    }

    public String getUsername() {
        return username;
    }

    public Date getBirthday() {
        return birthday;
    }

    public String getSex() {
        return sex;
    }

    public String getAddress() {
        return address;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public void setAddress(String address) {
        this.address = address;
    }

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

• mapper包

package com.chinasoft.mapper;

import com.chinasoft.domain.Account;
import com.chinasoft.vo.AccountVO;
import org.apache.ibatis.annotations.*;
import org.apache.ibatis.mapping.FetchType;

import java.util.List;

public interface AccountMapper {
    /**
     * fetchType = FetchType.LAZY开启延时加载
     * 查询账户信息以及其对应的用户信息
     */
    @Select("select * from account")
    @Results(id = "baseMap",value = {
            @Result(property = "id",column = "id",id = true),
            @Result(property = "uid",column = "uid"),
            @Result(property = "money",column = "money"),
//            column属性：如果使用select标签，则column用于将指定的数据传递给select方法作为参数。如果参数有多个，则使用集合形式，
//            如column="{参数1=accountsMap的某column字段,参数2=accountsMap的某column字段,…}"
            @Result(property = "user",column = "uid", one = @One(select = "com.chinasoft.mapper.UserMapper.findOne",fetchType = FetchType.LAZY)),
    })
    List<AccountVO> findAll();

    @Select("select * from account where uid=#{uid}")
    List<Account> findAccountByUid(int uid);
}

package com.chinasoft.mapper;

import com.chinasoft.domain.User;
import com.chinasoft.vo.UserVO;
import org.apache.ibatis.annotations.*;
import org.apache.ibatis.mapping.FetchType;

/**
 *    mybatis:有一级缓存 和 二级缓存
 *
 *    一级缓存为自带缓存： 由sqlsession对象进行缓存，缓存后同一个查询后期连续多次请求将不在查询数据库
 *       当sqlsession对象进行flush或者close，commit 操作的时候会清空缓存
 *
 *    二级缓存：配置mybatis配置文件，在mapper的映射文件中配置cache标签，然后在对应的查询标签里添加属性useCache="true"
 *          二级缓存开启时需要注意：操作的对象必须要实现序列化接口
 *
 *        注解的形式如何开启二级缓存？
 *            1.在mybatis配置文件中打开注解的开关
 *            2.在mapper中添加注解  @CacheNamespace(blocking = true)
 *
 *
 *
 *    延迟加载：
 *      一种xml如何开启延时加载：
 *      注解开启延时加载：
 *
 *
 */

import java.util.List;

//注解的方式开启二级缓存
@CacheNamespace(blocking = true)
public interface UserMapper {
    /**
     * 查询所有用户信息
     */
    @Select("select * from tab_user")
    @Results(id = "baseMap",value = {
            @Result(property = "id",column = "id",id = true),
            @Result(property = "username",column = "username"),
            @Result(property = "address",column = "address"),
    })
    List<User> findAll();

    @Insert("insert into tab_user(username,address) values(#{username},#{address})")
    void addUser(User user);

    @Delete("delete from tab_user where id=#{id}")
    void delUser(int id);

    @Update("update tab_user set username=#{username},adress=#{address} where id=#{id}")
//    @Update("<script>"+"update tab_user set username=#{username},adress=#{address} where id=#{id}"+"</script>")
    void updateUser(int id);

    @Select("select count(id) from tab_user")
//    用于加载条件构造器,method写全限定类名
//    @SelectProvider(method="")
    int countUser();

    @Select("select * from tab_user where id=#{id}")
    User findOne(int id);

    /**
     * 查询用户信息和其对应的账户信息
     */
    @Select("select * from tab_user")
    @Results(id = "userVoMap",value = {
            @Result(property = "id",column = "id",id = true),
            @Result(property = "username",column = "username"),
            @Result(property = "address",column = "address"),
            @Result(property = "sex",column = "sex"),
//            column属性：如果使用select标签，则column用于将指定的数据传递给select方法作为参数。如果参数有多个，则使用集合形式，
//            如column="{参数1=accountsMap的某column字段,参数2=accountsMap的某column字段,…}"
            @Result(property = "accountList",column = "id",many=@Many(select = "com.chinasoft.mapper.AccountMapper.findAccountByUid",fetchType = FetchType.LAZY))
    })
    List<UserVO> findAllUser();

}

• vo包

package com.chinasoft.vo;

import com.chinasoft.domain.Account;
import com.chinasoft.domain.User;

public class AccountVO extends Account {

    //个账户及其对应的用户信息
    private User user;

    public User getUser() {
        return user;
    }

    public void setUser(User user) {
        this.user = user;
    }

    @Override
    public String toString() {
        return "AccountVO{" +
                "id=" + super.getId() +
                ", uid=" + super.getUid() +
                ", money=" + super.getMoney() +
                "user=" + user +
                '}';
    }
}

package com.chinasoft.vo;

import com.chinasoft.domain.Account;
import com.chinasoft.domain.User;

import java.util.List;

public class UserVO extends User{
    //一个用户对应多个账户
    private List<Account> accountList;

    public List<Account> getAccountList() {
        return accountList;
    }

    public void setAccountList(List<Account> accountList) {
        this.accountList = accountList;
    }

    @Override
    public String toString() {
        return "UserVO{" +
                "id=" + super.getId() +
                ", username='" + super.getUsername() + '\'' +
                ", birthday=" + super.getBirthday() +
                ", sex='" + super.getSex() + '\'' +
                ", address='" + super.getAddress() + '\'' +
                "accountList=" + accountList +
                '}';
    }
}

• 测试

package com.chinasoft.mapper;


import com.chinasoft.vo.AccountVO;
import com.chinasoft.vo.UserVO;

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.After;
import org.junit.Before;
import org.junit.Test;




import java.io.IOException;
import java.io.InputStream;
import java.util.List;
import java.util.Optional;

/**
 * 运行测试类
 */
public class MybatisTest {


    InputStream inputStream;
    SqlSession sqlSession;
    AccountMapper accountmapper;
    UserMapper usermapper;
    //    在test测试方式之前执行
    @Before
    public void init() throws IOException {
        //1.读取配置文件
        inputStream= Resources.getResourceAsStream("mybatis.xml");
//        2.创建SqlSessionFactoryBuilder对象
        SqlSessionFactoryBuilder sfd=new SqlSessionFactoryBuilder();//构建者模式
//        3.创建SqlSessionFactory对象
        SqlSessionFactory sqlSessionFactory=sfd.build(inputStream);//工厂模式
//        4.创建SqlSession对象
        sqlSession=sqlSessionFactory.openSession();//可以生成代理对象，可以支持事务的控制
//        5.使用SqlSession获取Mapper代理对象,因为UserMapper.java是一个接口，需要对象实现
        accountmapper = sqlSession.getMapper(AccountMapper.class);//通过制定字节码文件生成了代理对象
        usermapper = sqlSession.getMapper(UserMapper.class);//通过制定字节码文件生成了代理对象
    }

//
    @Test
    public void test01(){
        List<AccountVO> all=accountmapper.findAll();
        Optional<AccountVO> first=all.stream().findFirst();
        System.out.println(first);
        all.stream().forEach(System.out::println);
    }


//    查询用户信息对应的账户信息
    @Test
    public void test02(){
        List<UserVO> all=usermapper.findAllUser();
        //Optional<UserVO> first=all.stream().findFirst();
        //System.out.println(first);
        for (UserVO userVO:all) {
            System.out.println(userVO.toString());
        }
        //all.stream().forEach(System.out::println);
    }


    @After
    public void destroy() throws IOException {
        //        8.释放资源
        sqlSession.close();
        inputStream.close();
    }



}