MyBatis的简介

原始jdbc操作

public class ConnectionTest {
    public static void query() throws Exception {
        //注册驱动
        Class.forName("com.mysql.jdbc.Driver");
        //获得链接
        Connection connection= DriverManager.getConnection("jdbc:mysql:///myweb","root","root");
        //获得statement
        PreparedStatement statement=connection.prepareStatement("select id,username,password from user");
        //执行查询
        ResultSet resultSet=statement.executeQuery();
        //遍历结果集
        while (resultSet.next()){
            //封装实体
            User user=new User();
            user.setId(resultSet.getInt("id"));
            user.setUsername(resultSet.getString("username"));
            user.setPassword(resultSet.getString("password"));
            //user实体封装完毕
            System.out.println(user);
        }
        //释放资源
        resultSet.close();
        statement.close();
        connection.close();
    }

    public static void inert(String uername,String password) throws Exception{
        User user=new User();
        user.setUsername(uername);
        user.setPassword(password);
        //注册驱动
        Class.forName("com.mysql.jdbc.Driver");
        //获得链接
        Connection connection= DriverManager.getConnection("jdbc:mysql:///myweb","root","root");
        //获得statement
        PreparedStatement statement=connection.prepareStatement("insert into user(username,password) values (?,?)");
        //设置占位符
        statement.setString(1, user.getUsername());
        statement.setString(2, user.getPassword());
        //执行查询
        int resultSet=statement.executeUpdate();
        System.out.println(resultSet);
        //释放资源
        statement.close();
        connection.close();
    }

    public static void main(String[] args) throws Exception{
      /*  query();*/
        inert("tom","111");
    }
}

原始jdbc操作分析

问题：

• 数据库连接创建、释放频繁造成系统资源浪费从而影响系统性能。
• sql在代码中编写，不易维护，实际sql可能会变化
• 查询操作时，需要手动将结果的数据手动封装到实体中，插入操作数据需要将实体的数据设置到sql语句的占位符位置

解决方案：

• 使用数据库连接池初始化链接资源
• 将sql语句抽取到xml配置文件中
• 使用反射、内省等底层技术，自动将实体与表进行属性与字段的自动映射

什么是mybatis

• java的持久层框架，内部封装了jdbc，就只需要关注sql语句本身
• mybatis通过xml或注解的方式将要执行的各种statement配置起来，并通过java对象和statement中sql的动态参数进行映射生成最终执行的sql语句。
• 最后mybatis执行sql并将结果映射成java对象并返回，采用ORM思想解决了实体和数据库映射的问题，对jdbc进行了封装，屏蔽了jdbc api底层访问细节，使我们不用与jdbc api打交道，就可以完成对数据库的持久化操作。

Mybatis的快速入门

1、添加mybatis和mysql的jar包

在pom.xml中加载对应的依赖，mysql、mybatis、log4j、junit（mysql版本需要注意下）

2、创建数据库及User实体类

public class User {
    Integer id;
    String  username;
    String  password;

    public User() {
    }
    public User(Integer id, String username, String password) {
        this.id = id;
        this.username = username;
        this.password = password;
    }
    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 getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

3、定义接口类userDao用来管理

import java.util.List;
public interface usrDao {
    List<User> findAll();
}

3、编写映射文件userMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.controller.usrDao"> 
    //resultType 查询的结果集封装到User
    <select id="findAll" resultType="com.dao.User">
        select * from user
    </select>
</mapper>

4、编写核心文件MybatisConfig.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">
<!--mybatis的主配置文件-->
<configuration>
    <!-- 属性文件 -->
    <properties resource="jdbc.properties"></properties>
  <!--  配置环境-->
    <environments default="mysql">
        <!--配置mysql的环境-->
        <environment id="mysql">
            <transactionManager type="jdbc" />
            <!--配置数据源（连接源）-->
            <dataSource type="POOLED">
                <!--配置数据库的4个基本信息-->
                <property name="driver" value="com.mysql.jdbc.Driver" />
                <property name="url" value="jdbc:mysql://localhost:3306/myweb" />
                <property name="username" value="root" />
                <property name="password" value="root" />
            </dataSource>
        </environment>
    </environments>
    <!-- 指定映射文件的位置，指的是每个mapper独立的配置文件 -->
    <mappers>
        <mapper resource="com/mapp/userMapper.xml"/>
    </mappers>
</configuration>

5、编写测试类

public static void main(String[] args) throws IOException {
    //第一个：加载配置文件使用类加载器，只能读类路径的配置文件
    //第二个：使用ServletContext对象的getRealPath（）
    String file = "/mybatis.xml";
     //获取配置文件流
    InputStream resources = Resources.class.getResourceAsStream(file);
     //创建SqlSessionFactory对象
    //创建工厂mybatis使用了构建者模式
    SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
    SqlSessionFactory factory;
    factory = builder.build(resources);
    //使用工厂产生sqlsession对象
    SqlSession session=factory.openSession();
    //使用SqlSession创建Dao接口的代理对象
    usrDao us=session.getMapper(usrDao.class);
    //使用代码对象执行方法
    List<User> users=us.findAll();
    for(User user:users){
        System.out.println(user);
    }
    //释放资源
    session.close();
    resources.close();
}

Mybatis的映射文件

[图片上传失败...(image-d81560-1619415469298)]

Mybatis增删改查

增删改查:

public class mybatisTest {
    public static void main(String[] args) throws Exception {
        delete();
    }

    public static void queryAll() throws Exception {
        //第一个：加载配置文件使用类加载器，只能读类路径的配置文件
        //第二个：使用ServletContext对象的getRealPath（）
        String file = "/mybatis.xml";
        //获取配置文件流
        InputStream resources = Resources.class.getResourceAsStream(file);
        //创建SqlSessionFactory对象
        //创建工厂mybatis使用了构建者模式
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory factory;
        factory = builder.build(resources);
        //使用工厂产生sqlsession对象
        SqlSession session=factory.openSession();
        //使用SqlSession创建Dao接口的代理对象
        usrDao us=session.getMapper(usrDao.class);
        //使用代码对象执行方法
        List<User> users=us.findAll();
        for(User user:users){
            System.out.println(user);
        }
        //释放资源
        session.close();
        resources.close();
    }

    public static void insert() throws Exception{
        //模拟user对象
        User user=new User();
        user.setUsername("lili3");
        user.setPassword("222");
        //第一个：加载配置文件使用类加载器，只能读类路径的配置文件
        //第二个：使用ServletContext对象的getRealPath（）
        String file = "/mybatis.xml";
        //获取配置文件流
        InputStream resources = Resources.class.getResourceAsStream(file);
        //创建SqlSessionFactory对象
        //创建工厂mybatis使用了构建者模式
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory factory;
        factory = builder.build(resources);
        //使用工厂产生sqlsession对象
        SqlSession session=factory.openSession();
        //使用SqlSession创建Dao接口的代理对象
        usrDao us=session.getMapper(usrDao.class);
        us.addUser(user);
    /*    session.insert("usrDao.addUser",user);*/
        //mybatis执行更新操作，需要提交事务
        session.commit();
        //释放资源
        session.close();
        resources.close();
    }

    public static void update() throws Exception{
        //模拟user对象
        User user=new User();
        user.setId(2);
        user.setUsername("lili2");
        user.setPassword("222");
        //第一个：加载配置文件使用类加载器，只能读类路径的配置文件
        //第二个：使用ServletContext对象的getRealPath（）
        String file = "/mybatis.xml";
        //获取配置文件流
        InputStream resources = Resources.class.getResourceAsStream(file);
        //创建SqlSessionFactory对象
        //创建工厂mybatis使用了构建者模式
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory factory;
        factory = builder.build(resources);
        //使用工厂产生sqlsession对象
        SqlSession session=factory.openSession();
        //使用SqlSession创建Dao接口的代理对象
        usrDao us=session.getMapper(usrDao.class);
        us.updatUser(user);
        //mybatis执行更新操作，需要提交事务
        session.commit();
        //释放资源
        session.close();
        resources.close();
    }
    public  static void delete() throws Exception{
        //第一个：加载配置文件使用类加载器，只能读类路径的配置文件
        //第二个：使用ServletContext对象的getRealPath（）
        String file = "/mybatis.xml";
        //获取配置文件流
        InputStream resources = Resources.class.getResourceAsStream(file);
        //创建SqlSessionFactory对象
        //创建工厂mybatis使用了构建者模式
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory factory;
        factory = builder.build(resources);
        //使用工厂产生sqlsession对象
        SqlSession session=factory.openSession();
        //使用SqlSession创建Dao接口的代理对象
        usrDao us=session.getMapper(usrDao.class);
        us.deleteUser(1);
        //mybatis执行更新操作，需要提交事务
        session.commit();
        //释放资源
        session.close();
        resources.close();
    }
}

插入操作注意：

• 在映射文件中使用parameterType属性指定要插入的数据类型
• sql语句中使用#{实体属性名}方式引用实体中的属性值
• 插入操作涉及数据库变化，所以使用sqlsession对象显示的提交事务，即sqlsession.commit()

删除操作注意：

• sql语句中使用#｛任意字符串｝方式传递的单个参数

Mybastic核心配置文件概述

概述：

[图片上传失败...(image-aa1d35-1619415469299)]

MyBatis常用配置解析

1、environments标签

数据库环境的配置，支持多环境配置

[图片上传失败...(image-b85721-1619415469299)]

事务管理器（transactionManager）类型有两种：

• JDBC：这个配置就是直接使用了JDBC的提交和回滚设置，它依赖于从数据源得到的连接来管理事务作用域；
• MANAGED：这个配置几乎没做什么

数据源（dataSource）类型有三种：

• UNPOOLED：这个数据源的实现只是每次被请求时打开和关闭连接。
• POOLED:这种数据源的实现利用“池”的概念将JDBC连接对象组织起来。

2、mapper标签

加载映射文件mapper，加载方式有如下几种：

• 相对于类路径的资源；<mapper resource="com/mapp/userMapper.xml"/>
• 使用完全限定资源定位符；<mapper url="file:///com/mapp/userMapper.xml"/>
• 使用映射器接口实现类的完全限定类名；<mapper class="com.mapp.userMapper"/>
• 将包内的映射器接口实现全部注册为映射器；<mapper name="com.mapp"/>

3、Properties标签

实际开发中，习惯将数据源的配置信息单独抽取成一个properties文件，该标签可以加载配置的properties文件

[图片上传失败...(image-e9fa0-1619415469299)]

4、typeAliases标签

类型别名是为java类型设置一个短的名字。原来的类型名称配置如下

[图片上传失败...(image-f58aec-1619415469299)]

MyBatis相应API

1、SqlSession工厂构建器SqlSessionFactoryBuilder

[图片上传失败...(image-7aa565-1619415469299)]

2、sqlsession工厂对象sqlsessionFactory

[图片上传失败...(image-6fe883-1619415469299)]

3、sqlsession会话对象

[图片上传失败...(image-9a97a-1619415469299)]

Mybatis的Dao层实现

传统开发方式

编写UserDao接口

public interface usrDao {
    public List<User> findAll();
    public void addUser(User user);
    public void updatUser(User user);
    public void deleteUser(Integer id);
}

编写对应的实现类

public class userDaoImpl implements usrDao{

    public List<User> findAll() throws Exception {
        //第一个：加载配置文件使用类加载器，只能读类路径的配置文件
        //第二个：使用ServletContext对象的getRealPath（）
        String file = "/mybatis.xml";
        //获取配置文件流
        InputStream resources = Resources.class.getResourceAsStream(file);
        //创建SqlSessionFactory对象
        //创建工厂mybatis使用了构建者模式
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory factory;
        factory = builder.build(resources);
        //使用工厂产生sqlsession对象
        SqlSession session=factory.openSession();
        //使用SqlSession创建Dao接口的代理对象
        usrDao us=session.getMapper(usrDao.class);
        //使用代码对象执行方法
        List<User> users=us.findAll();
        return users;
    }

    public void addUser(User user) {

    }

    public void updatUser(User user) {

    }

    public void deleteUser(Integer id) {

    }
}

再根据实现类去调用对应的方法。

代理开发方式

Mapper接口开发方法只需要编写Mapper接口（相当于Dao接口），由Mybatis框架根据接口定义创建接口的动态代理对象，代理对象的方法体同上边dao接口实现类方法。

Mapper接口开发需要遵循以下规范：

1、Mapper.xml文件中namespace与mapper接口的全限定名相同

2、mapper接口方法名和Mapper.xml中定义的statement的id相同

3、mapper接口方法输入的参数与Mapper.xml中parameterType一致

4、mapper接口方法输出的参数与Mapper.xml中resultType一致

实现：

userMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.controller.usrDao">
    <select id="findAll" resultType="com.dao.User">
        select * from user
    </select>
    <insert id="addUser" parameterType="com.dao.User">
        insert into user values (#{id},#{username},#{password})
    </insert>
    <update id="updatUser" parameterType="com.dao.User">
        update user set username=#{username},password=#{password} where id=#{id}
    </update>
    <delete id="deleteUser" parameterType="Integer">
        delete from user where id=#{id}
    </delete>
</mapper>

mapper接口----usrDao.class

public interface usrDao {
    List<User> findAll() throws Exception;
    void addUser(User user);
    void updatUser(User user);
    void deleteUser(Integer id);
}

使用时需要对dao进行实现

//使用SqlSession创建Dao接口的代理对象
usrDao us=session.getMapper(usrDao.class);

[图片上传失败...(image-342e08-1619415469299)]

Mybatis隐射文件深入

动态sql语句

• if
• foreach

动态SQL之if

如传入查询的条件可能传入多个查询条件，如 id= and username =

<select id="finduer" resultType="com.dao.User" parameterType="com.dao.User">
    select * from user
    <where>
        <if test="id!=0">
            and id=#{id}
        </if>
        <if test="username!=null">
            and username=#{username}
        </if>
        <if test="password!=null">
            and password=#{password}
        </if>
    </where>
</select>

动态SQL之foreach

要查询的条件有多个，如id=1 or id=2...

<select id="findByids" resultType="com.dao.User" parameterType="list">
    select * from user
    <where>
       <foreach collection="list" open="id in(" close=")" item="id" separator=",">
                #{id}
       </foreach>
    </where>
</select>

接口：List<User> findByids(List<Integer> id);
测试：List<Integer> list = new ArrayList<Integer>();
        list.add(2);
        list.add(3);
        findbyids(list);

SQL片段抽取

sql中可以将重复的sql提取出来，使用时用include引用即可，最终达到sql重用的目的。

<!-- sql语句的抽取-->
 <sql id="selectUser">select * from user</sql>
    
 <select id="findAll" resultType="com.dao.User">
     <include refid="selectUser"/>
 </select>

Mybatis核心配置文件深入

typeHandlers标签

无论mybatis在预处理语句（PreparedStatement）中设置一个参数时，还是从结果集中取出一个值时，都会用类型处理器将获取的值以合适的方式转换成java类型。

[图片上传失败...(image-f7616d-1619415469299)]

plugins标签

Mybatis可以使用第三方插件对功能进行扩展，分页助手PageHelper是将分页的复杂操作进行封装，使用简单的方式即可获得分页的相关数据

开发步骤：

①导入通用PageHelper的坐标

②在mybatis核心配置文件中配置pageHelper插件

③测试分页数据获取

导入依赖

<dependency>
    <groupId>com.github.pagehelper</groupId>
    <artifactId>pagehelper</artifactId>
    <version>5.1.10</version>
</dependency>
<dependency>
     <groupId>net.sf.jsqlparser</groupId>
     <artifactId>jsqlparser</artifactId>
     <version>0.8.0</version>
</dependency>

在mybatis核心配置文件中配置pageHelper插件

<!--配置分页助手插件-->
<plugins>
    <plugin interceptor="com.github.pagehelper.PageHelper">
        <property name="dialect" value="mysql"/>
    </plugin>
</plugins>

测试分页数据获取

public static void queryAll() throws Exception {
    //第一个：加载配置文件使用类加载器，只能读类路径的配置文件
    //第二个：使用ServletContext对象的getRealPath（）
    String file = "/mybatis.xml";
    //获取配置文件流
    InputStream resources = Resources.class.getResourceAsStream(file);
    //创建SqlSessionFactory对象
    //创建工厂mybatis使用了构建者模式
    SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
    SqlSessionFactory factory;
    factory = builder.build(resources);
    //使用工厂产生sqlsession对象
    SqlSession session=factory.openSession();
    //使用SqlSession创建Dao接口的代理对象
    usrDao us=session.getMapper(usrDao.class);

    //设置分页相关参数，当前页+每页显示的条数
    PageHelper.startPage(1,3);
    
    //使用代码对象执行方法
    List<User> users=us.findAll();
    for(User user:users){
        System.out.println(user);
    }
    //释放资源
    session.close();
    resources.close();
}

/*获取分页相关参数*/
PageInfo<User> pageInfo=new PageInfo<User>();
System.out.println("当前页"+pageInfo.getPageNum());
System.out.println("每页显示条数"+pageInfo.getPageSize());
System.out.println("总条数"+pageInfo.getTotal());
System.out.println("总页数"+pageInfo.getPages());
System.out.println("上一页"+pageInfo.getPrePage());
System.out.println("下一页"+pageInfo.getNextPage());
System.out.println("是否是第一页"+pageInfo.isIsFirstPage());
System.out.println("是否是最后一页"+pageInfo.isIsLastPage());

Mybatis多表操作

一对一查询

<mapper namespace="com.controller.taskDao">
    <resultMap id="taskMap" type="task">
        <!--手动指定字段与实体属性的映射关系
            column:数据表的字段名称
            property：实体的属性名称
        -->
        <id column="tid" property="id"></id>
        <result column="userid" property="userid"></result>
        <result column="taskname" property="taskname"></result>
        <result column="taskexplain" property="taskexplain"></result>
        <result column="taskstatus" property="taskstatus"></result>
        <result column="taskresult" property="taskresult"></result>
        <result column="tasktime" property="tasktime"></result>
        <result column="uid" property="user.id"></result>
        <result column="username" property="user.username"></result>
        <result column="password" property="user.password"></result>
    </resultMap>
    
    <select id="findAll" resultMap="taskMap">
        SELECT *,t.id tid FROM task t,USER u WHERE t.userid=u.id
    </select>
</mapper>

另外一种写法：

<mapper namespace="com.controller.taskDao">
    <resultMap id="taskMap" type="task">
        <!--手动指定字段与实体属性的映射关系
            column:数据表的字段名称
            property：实体的属性名称
        -->
        <id column="tid" property="id"></id>
        <result column="userid" property="userid"></result>
        <result column="taskname" property="taskname"></result>
        <result column="taskexplain" property="taskexplain"></result>
        <result column="taskstatus" property="taskstatus"></result>
        <result column="taskresult" property="taskresult"></result>
        <result column="tasktime" property="tasktime"></result>
<!--        <result column="uid" property="user.id"></result>
        <result column="username" property="user.username"></result>
        <result column="password" property="user.password"></result>-->
        <association property="user" javaType="user">
            <id column="uid" property="id"></id>
            <result column="uid" property="user.id"></result>
            <result column="username" property="username"></result>
            <result column="password" property="password"></result>
        </association>
    </resultMap>
    
    <select id="findAll" resultMap="taskMap">
        SELECT *,t.id tid FROM task t,USER u WHERE t.userid=u.id
    </select>
</mapper>

一对多

<resultMap id="userMapper" type="com.dao.User">
    <id column="uid" property="id"></id>
    <result column="username" property="username"></result>
    <result column="password" property="password"></result>
   <!-- 配置集合信息
        property：集合名称
   -->
    <collection property="taskList" ofType="com.dao.Task">
        <id column="tid" property="id"></id>
        <result column="userid" property="userid"></result>
        <result column="taskname" property="taskname"></result>
        <result column="taskexplain" property="taskexplain"></result>
        <result column="taskstatus" property="taskstatus"></result>
        <result column="taskresult" property="taskresult"></result>
        <result column="tasktime" property="tasktime"></result>
    </collection>
</resultMap>

 <!--一对多查询-->
<select id="findUser" resultMap="">
select * from user u,task t where u.id=t.userid
</select>

多对多

总结

image.png

Mybatis注解开发

常用注解

这几年来注解开发越来越流行，Mybatis也可以使用注解开发方式，这样我们就可以减少编写mapper映射文件了。我们先围绕一些基本的CRUD来学习，再学习复杂映射多表操作。

@insert:实现新增

@Update：实现更新

@Delete：实现删除

@Select：实现查询

@Result：实现结果集封装

@Results：可以与@result一起使用，封装多个

@One：实现一对一结果集封装

@Many：实现一对多结果集封装

注解开发-xml完成基本的crud

1、使用@Before来优化测试

public class testUser {
    usrDao us;
    @Before
    public void before(){
        //第一个：加载配置文件使用类加载器，只能读类路径的配置文件
        String file = "/mybatis.xml";
        InputStream in= Resources.class.getResourceAsStream(file);
        SqlSessionFactoryBuilder builder=new SqlSessionFactoryBuilder();
        SqlSessionFactory factory;
        factory = builder.build(in);
        //使用工厂产生sqlsession对象
        SqlSession session=factory.openSession();
        //使用SqlSession创建Dao接口的代理对象
        us=session.getMapper(usrDao.class);
    }
    @Test
    public void insert(){
        //模拟user对象
        User user=new User();
        user.setUsername("lili9");
        user.setPassword("222");
        us.addUser(user);
        /*    session.insert("usrDao.addUser",user);*/
    }

    @Test
    public void query()throws Exception{
        //使用代码对象执行方法
        List<User> users=us.findAll();
        for(User user:users){
            System.out.println(user);
        }
    }

    @Test
    public void modify() throws Exception{
        //模拟user对象
        User user=new User();
        user.setId(2);
        user.setUsername("lili2");
        user.setPassword("222");
        us.updatUser(user);
    }

    @Test
    public void delete()throws Exception{
        us.deleteUser(2);
    }

}

使用简单注解来

1、修改Mybatis.xml

<mappers>
    <package name="com.controller"/>
</mappers>

2、配置下User的接口

public interface usrDao {
    @Select("select * from user")
    List<User> findAll() throws Exception;
    
    @Insert("insert into user values (#{id},#{username},#{password})")
    void addUser(User user);
    
    @Update("update user set username=#{username},password=#{password} where id=#{id}")
    void updatUser(User user);
    
    @Delete("delete from user where id=#{id}")
    void deleteUser(Integer id);
}

3、进行测试

Mybatis的注解实现复杂映射开发

实现复杂关系映射之前我们可以在映射文件中通过配置<resultMap>实现，使用注解开发后，我们可以使用@Results注解，@Result注解，@One注解，@Many注解组合完成复杂关系配置

@Results：代替的是标签<resultMap>该注解中可以使用当个@result注解，也可以使用@result集合，使用格式：

@Results({
    @Result(),
    @Result(),
    @Result()
})

@Result:代替了<id>标签和<result>标签，

            @Result属性有：column:数据库的列名；property：需要装配的属性名；one：需要使用的@One注解（@Result（one=@One）()）;many：需要使用的@Many注解

一对一封装

1、修改taskDao

public interface taskDao {
    @Select("SELECT *,t.id tid FROM task t,USER u WHERE t.userid=u.id")
    @Results({
        @Result(column="tid",property="id"),
        @Result(column="userid",property="userid"),
        @Result(column="taskname",property="taskname"),
        @Result(column="taskexplain",property="taskexplain"),
        @Result(column="taskstatus", property="taskstatus"),
        @Result(column="taskresult", property="taskresult"),
        @Result(column="tasktime", property="tasktime"),
        @Result(column="uid", property="user.id"),
        @Result(column="username", property="user.username"),
        @Result(column="password", property="user.password")
    })
    List<Task> findAll();
}

另外一种方式：

public interface taskDao {
    @Select("SELECT *,t.id tid FROM task t,USER u WHERE t.userid=u.id")
    @Results({
        @Result(column="tid",property="id"),
        @Result(column="userid",property="userid"),
        @Result(column="taskname",property="taskname"),
        @Result(column="taskexplain",property="taskexplain"),
        @Result(column="taskstatus", property="taskstatus"),
        @Result(column="taskresult", property="taskresult"),
        @Result(column="tasktime", property="tasktime"),
        @Result(
                property = "userList",//要封装的属性名称
                column = "uid",//根据哪个字段去查询User表的数据
                javaType = User.class,//要封装的实体类
                //select属性 代表查询那个接口的方法获取数据
                one = @One(select = "com.controller.userDao.findUserByid")
        )
    })
    List<Task> findAll();
}

一对多

@Select("select * from user u,task t where u.id=t.userid")
@Results({
        @Result(column="uid",property="id"),
        @Result(column="username",property="username"),
        @Result(column="password",property="password"),
        @Result(
                property = "taskList",//要封装的属性名称
                column = "tid",//根据哪个字段去查询User表的数据
                javaType = Task.class,//要封装的实体类
                //select属性 代表查询那个接口的方法获取数据
                many = @Many(select = "com.controller.taskDao.findTaskAll")
        )
})
List<User> findUser();