Mybatis多表查询的操作（注解开发）

最新推荐文章于 2024-08-26 20:43:46 发布
最新推荐文章于 2024-08-26 20:43:46 发布
阅读量130 收藏
点赞数
文章标签： mybatis intellij idea
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/summeblace/article/details/119269926
版权

Mybatis多表查询

前言

前面介绍过Mybatis的基本操作，这里只整理Mybatis的多表查询的操作，这里介绍注解开发的mybatis操作，以及用注解方式进行多表查询的操作。

一、java目录结构

在这里插入图片描述

二、配置文件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>org.example</groupId>
    <artifactId>Mavenwebcpp</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.9</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.0</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>2.5</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.6</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.32</version>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper</artifactId>
            <version>4.1.6</version>
        </dependency>
        <dependency>
            <groupId>com.github.jsqlparser</groupId>
            <artifactId>jsqlparser</artifactId>
            <version>0.9.5</version>
        </dependency>
    </dependencies>
    <build>
        <!-- 配置了很多插件 -->
        <plugins>
            <!--			配置的jdk的插件-->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>1.7</source>
                    <target>1.7</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
            <!--			配置的tomcat插件-->
            <plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <version>2.1</version>
                <configuration>
                    <port>9090</port>
                    <path>/mgr</path>
                    <uriEncoding>UTF-8</uriEncoding>
                    <server>tomcat7</server>
                </configuration>
            </plugin>

        </plugins>
    </build>
</project>

三、核心配置文件sqmMapConfig.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>
    <!-- 在这里将jdbc.properties的配置文件加载进来 -->
    <properties resource="jdbc.properties"></properties>
    <!-- 数据源环境 -->
    <environments default="developement">
        <environment id="developement">
            <transactionManager type="JDBC"></transactionManager>
            <dataSource type="POOLED"><!-- 数据源为连接池类型 -->
                <!-- jdbc的配置在jdbc.properties中定义 -->
                <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>
    <!-- 核心配置文件在这里添加以后的Mapper映射文件 -->
    <!-- 核心配置文件添加UserMapper映射文件 -->
    <mappers>
        <package name="dao"/>
    </mappers>

</configuration>

四、实体类

package entity;


import java.util.List;

public class Users {

  private long id;
  private String username;
  private String password;
  private String birthday;
  private List<Orders> orderList;
  private List<Role> roleList;

  @Override
  public String toString() {
    return "Users{" +
            "id=" + id +
            ", username='" + username + '\'' +
            ", password='" + password + '\'' +
            ", birthday='" + birthday + '\'' +
            ", orderList=" + orderList +
            ", roleList=" + roleList +
            '}';
  }

  public List<Role> getRoleList() {
    return roleList;
  }

  public void setRoleList(List<Role> roleList) {
    this.roleList = roleList;
  }

  public List<Orders> getOrderList() {
    return orderList;
  }

  public void setOrderList(List<Orders> orderList) {
    this.orderList = orderList;
  }

  public long getId() {
    return id;
  }

  public void setId(long 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;
  }


  public String getBirthday() {
    return birthday;
  }

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

}


package entity;

public class Role {
    private int id;
    private String rolename;
}


package entity;


public class Orders {

  private long id;
  private String ordertime;
  private double total;

  public Users getUser() {
    return user;
  }

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

  @Override
  public String toString() {
    return "Orders{" +
            "id=" + id +
            ", ordertime='" + ordertime + '\'' +
            ", total=" + total +
            ", user=" + user +
            '}';
  }

  private Users user;


  public long getId() {
    return id;
  }

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


  public String getOrdertime() {
    return ordertime;
  }

  public void setOrdertime(String ordertime) {
    this.ordertime = ordertime;
  }


  public double getTotal() {
    return total;
  }

  public void setTotal(double total) {
    this.total = total;
  }



}

五、接口类

package dao;

import entity.Users;
import org.apache.ibatis.annotations.Many;
import org.apache.ibatis.annotations.Result;
import org.apache.ibatis.annotations.Results;
import org.apache.ibatis.annotations.Select;

import java.util.List;

public interface UserMapper {
    @Select("select * from users where id = #{uid}" )
    public List<Users> findById(int id);

    @Select("select * from users")
    @Results({
            @Result(id = true,column = "id",property = "id"),
            @Result(column = "username",property = "username"),
            @Result(column = "password",property = "password"),
            @Result(
                    property = "orderList",
                    column = "id",
                    javaType = List.class,
                    many = @Many(select = "dao.OrderMapper.findById")
            )
    })
    List<Users> findAllUserAndOrder();

    @Select("select * from users")
    @Results({
            @Result(id = true,property = "id",column = "id"),
            @Result(property = "username",column = "username"),
            @Result(property = "password",column = "password"),
            @Result(property = "birthday",column = "birthday"),
            @Result(
                    property = "roleList",
                    column = "id",
                    javaType = List.class,
                    many = @Many(select = "dao.RoleMapper.findByUid"))
            })
    List<Users> findAllUserAndRole();
}


package dao;

import entity.Role;
import org.apache.ibatis.annotations.Select;

import java.util.List;

public interface RoleMapper {
    @Select("select * from sys_role r,sys_user_role ur where r.id=ur.roleid and ur.userid=#{uid}")
    List<Role> findByUid(int uid);
}


package dao;

import entity.Orders;
import entity.Users;
import org.apache.ibatis.annotations.*;

import java.util.List;

public interface OrderMapper {
    @Select("select * from orders")
    @Results({
            @Result(column = "id",property = "id"),
            @Result(column = "ordertime",property = "ordertime"),
            @Result(column = "total",property = "total"),
            @Result(
                    property = "user",  //受封装的属性名称
                    column = "uid",  //根据哪个字段去查询user表数据
                    javaType = Users.class, //受封装的实体类
                    //select属性 代表查询哪个接口的方法获取数据
                    one=@One(select = "dao.UserMapper.findById")
            )
    })
    public List<Orders> findAll();

    @Insert("insert into orders values(4,'2018-12-12',2000,2)")
    public void add();

    @Update("update orders set ordertime='2019-12-12' where id=4 ")
    public void update();

    @Delete("delete from orders where id=4")
    public void Ddelete();

    @Select("select * from orders where uid=#{uid}")
    List<Orders> findById(int uid);
}

六、测试类

import dao.OrderMapper;
import entity.Orders;
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;

public class Demo1 {
    private OrderMapper mapper;
    private SqlSession sqlSession;
    @After
    public void after(){
        sqlSession.close();
    }

    @Before
    public void bef() throws IOException {
        InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
        SqlSessionFactory build = new SqlSessionFactoryBuilder().build(resourceAsStream);
        sqlSession = build.openSession(true);
        mapper = sqlSession.getMapper(OrderMapper.class);
    }

    @Test
    //查询所有Order订单（注解方式）
    public void test5() throws IOException {
        bef();
        List<Orders> all = mapper.findAll();
        for(Orders order:all)
        {
            System.out.println(order);
        }
        after();
    }
    @Test
    //增加Order订单（注解方式）
    public void test6() throws IOException {
        bef();
        mapper.add();
        after();
    }
    @Test
    //修改Order订单（注解方式）
    public void test7() throws IOException {
        bef();
        mapper.update();
        after();
    }
    @Test
    //删除Order订单（注解方式）
    public void test8() throws IOException {
        bef();
        mapper.Ddelete();
        after();
    }
}


import dao.OrderMapper;
import dao.UserMapper;
import entity.Orders;
import entity.Role;
import entity.Users;
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;

public class Demo2 {
    private UserMapper mapper;
    private SqlSession sqlSession;
    @After
    public void after(){
        sqlSession.close();
    }

    @Before
    public void bef() throws IOException {
        InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
        SqlSessionFactory build = new SqlSessionFactoryBuilder().build(resourceAsStream);
        sqlSession = build.openSession(true);
        mapper = sqlSession.getMapper(UserMapper.class);
    }

    @Test
    //查询所有Order订单（注解方式）
    public void test5() throws IOException {
        bef();
        List<Users> all = mapper.findAllUserAndOrder();
        for(Users user : all) {
            System.out.println(user.getUsername());
            List<Orders> orderList = user.getOrderList();
            for (Orders order : orderList) {
                System.out.println(order);
            }
            System.out.println("-----------------------------");
        }
        after();
    }
    @Test
    //增加Order订单（注解方式）
    public void test6() throws IOException {
        bef();
        List<Users> all = mapper.findAllUserAndRole();
        for(Users user : all)
        {
            System.out.println(user.getUsername());
            List<Role> roleList = user.getRoleList();
            for(Role role : roleList)
            {
                System.out.println(role);
            }
            System.out.println("----------------------------------");
        }
        after();
    }
}

七、数据库

/*
Navicat MySQL Data Transfer

Source Server         : mysql
Source Server Version : 50147
Source Host           : localhost:3306
Source Database       : test

Target Server Type    : MYSQL
Target Server Version : 50147
File Encoding         : 65001

Date: 2019-04-20 16:37:34
*/

SET FOREIGN_KEY_CHECKS=0;

-- ----------------------------
-- Table structure for orders
-- ----------------------------
DROP TABLE IF EXISTS `orders`;
CREATE TABLE `orders` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `ordertime` varchar(255) DEFAULT NULL,
  `total` double DEFAULT NULL,
  `uid` int(11) DEFAULT NULL,
  PRIMARY KEY (`id`),
  KEY `uid` (`uid`),
  CONSTRAINT `orders_ibfk_1` FOREIGN KEY (`uid`) REFERENCES `user` (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8;

-- ----------------------------
-- Records of orders
-- ----------------------------
INSERT INTO `orders` VALUES ('1', '2018-12-12', '3000', '1');
INSERT INTO `orders` VALUES ('2', '2018-12-12', '4000', '1');
INSERT INTO `orders` VALUES ('3', '2018-12-12', '5000', '2');

-- ----------------------------
-- Table structure for sys_role
-- ----------------------------
DROP TABLE IF EXISTS `sys_role`;
CREATE TABLE `sys_role` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `rolename` varchar(255) DEFAULT NULL,
  `roleDesc` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;

-- ----------------------------
-- Records of sys_role
-- ----------------------------
INSERT INTO `sys_role` VALUES ('1', 'CTO', 'CTO');
INSERT INTO `sys_role` VALUES ('2', 'COO', 'COO');

-- ----------------------------
-- Table structure for sys_user_role
-- ----------------------------
DROP TABLE IF EXISTS `sys_user_role`;
CREATE TABLE `sys_user_role` (
  `userid` int(11) NOT NULL,
  `roleid` int(11) NOT NULL,
  PRIMARY KEY (`userid`,`roleid`),
  KEY `roleid` (`roleid`),
  CONSTRAINT `sys_user_role_ibfk_1` FOREIGN KEY (`userid`) REFERENCES `sys_role` (`id`),
  CONSTRAINT `sys_user_role_ibfk_2` FOREIGN KEY (`roleid`) REFERENCES `user` (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

-- ----------------------------
-- Records of sys_user_role
-- ----------------------------
INSERT INTO `sys_user_role` VALUES ('1', '1');
INSERT INTO `sys_user_role` VALUES ('2', '1');
INSERT INTO `sys_user_role` VALUES ('1', '2');
INSERT INTO `sys_user_role` VALUES ('2', '2');

-- ----------------------------
-- Table structure for user
-- ----------------------------
DROP TABLE IF EXISTS `user`;
CREATE TABLE `user` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `username` varchar(50) DEFAULT NULL,
  `password` varchar(50) DEFAULT NULL,
  `birthday` varchar(50) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;

-- ----------------------------
-- Records of user
-- ----------------------------
INSERT INTO `user` VALUES ('1', 'lucy', '123', '2018-12-12');
INSERT INTO `user` VALUES ('2', 'haohao', '123', '2019-12-12');

总结

全部代码在这里，以及java目录文件，数据库等，可以运行成功的项目，喜欢的可以自行构建。

summeblace
关注
mybatis使用注解方式实现多表查询
ayaYoumu的博客
07-06 1660
多对多查询的需求：查询学生以及所对应的课程信息 1.mybatis主配置文件 <configuration> <environments default="development"> <environment id="development"> <transactionManager type="JDBC"/> <dataSource type="POOLED">
MyBatis注解开发（多表查询）
我要记录学习博客
05-09 2018
MyBatis注解开发 这几年来注解开发越来越流行，Mybatis也可以使用注解开发方式，这样我们就可以减少编写Mapper 映射文件了。 常见的注解开发： @Insert：实现新增 @Update：实现更新 @Delete：实现删除 @Select：实现查询 @Result：实现结果集封装 @Results：可以与@Result 一起使用，封装多个结果集 @One：实现一对一结果集封装 @Many：实现一对多结果集封装 项目搭建 创建mybatis-anno项目
Mybatis基于注解实现多表查询功能
08-25
主要介绍了Mybatis基于注解实现多表查询功能，非常不错，具有一定的参考借鉴价值,需要的朋友可以参考下
Mybatis注解开发
itzhuzhu的博客
12-05 2295
Mybatis注解开发： Mybatis使用注解开发方式，可以减少编写Mapper映射文件。 常用注解： 名称 作用 @Insert 实现新增 @Update 实现更新 @Delete 实现删除 @Select 实现查询 @Result 实现结果集封装 @Results 可以与@Result 一起使用，封装多个结果集 @One 实现一对一结果集封装 @Many 实现一对多结果集封装 注解属性： @Results：封装映射关系的父注解。 Result[]
Mybatis&多表关联查询&注解方式&动态SQL详细笔记
最新发布
谜语人的博客
08-26 1372
是占位符,是采用预编译方式向sql中传递,可以防止sql注入,如果往sql中传值,使用#{}一般用于向sql中的列传值。
Mybatis多表查询和注解开发
m0_69266818的博客
04-22 578
介绍了mybatis多表查询还有如何用注解开发
总结mybatis多表查询（注解方式，注解详细说明）
qq_42524262的博客
07-29 7791
总结mybatis多表查询（注解方式） 前言 在之前的总结mybatis多表查询（xml方式）的博客中，已经对多表查询做了一定的介绍，而且总结了基于xml的mybatis多表查询，一些通用的技术点可以翻阅上一篇博客。这次我们总结基于注解的mybatis多表查询。多对多查询的xml和注解方式我会再写个博客。 数据库表及关系 为了方便查看，这里再次给出user和account表 一对多查询 首先和...
mybatis多表查询.zip
08-06
对于更简洁的编码风格，MyBatis也支持使用注解来定义多表查询。通过在Mapper接口的方法上使用`@Select`注解，并直接写入SQL语句，可以完成多表查询。同时，可以利用`@ResultMap`和`@Results`注解来处理查询结果的...
多表联合分页查询（Mybatis注解）.zip_9AB_mybatis_skillwoc_全注解_多表关联分页查询
09-19
本案例主要探讨的是如何使用Mybatis的注解进行多表联合分页查询，这对于提高开发效率和优化数据库性能至关重要。 首先，我们需要理解Mybatis注解的基本用法。Mybatis注解允许我们直接在Java类和方法上声明SQL语句，...
MyBatis多条件查询、动态SQL、多表操作、注解开发详细教程
m0_71777195的博客
08-03 2145
MyBatis封装了JDBC通过Mapper代理的方式，以前繁琐的操作通过“属性与字段映射”就简单化解，MyBatis的动态SQL完美展现了DBMS的独特魅力。
三、Mybatis多表查询&注解开发&整合Spring
9.冄2.7.號的博客
07-04 235
1.Mybatis多表查询 1.1 一对一查询 1.1.1 一对一查询的模型MapperScannerConfigurer 用户表和订单表的关系为，一个用户有多个订单，一个订单只从属于一个用户 一对一查询的需求：查询一个订单，与此同时查询出该订单所属的用户 1.1.2一对一查询的语句 对应的sql语句：select * from orders o,user u where o.uid=u.id; 查询的结果如下： 1.1.3 创建Order和User实体 public class Order {
MyBatis实现多表查询方式三(注解的方式)
qq_44066201的博客
08-17 348
在没有映射文件的情况下，如何实现查询呢。 在上次的代码上(MyBatis实现多表查询方式二)删掉3个映射文件，然后修改配置文件中加载映射文件为加载Dao接口： <mappers> <mapper class="com.xyj.dao.GenderDao"/> <mapper class="com.xyj.dao.GradeDao"/> <ma...
Mybatis——多表查询注解开发实现
jhin_lx的博客
10-08 1215
目录多表查询相关注解数据表与实体类一对一 多表查询OrderMapperUserMapper测试一对多 多表查询UserMapperOrderMapper测试多对多 多表查询OrderMapperRoleMapper测试 多表查询相关注解 实现复杂关系映射之前可以在映射文件中通过配置resultMap来实现，使用注解开发后，则可以使用@Results注解，@Result注解，@One注解，@Many注解组合完成复杂关系的配置 数据表与实体类 这里有涉及到java.util.Date类型与数据库中bigi
MyBatis10_基于注解的多表查询
CodeAction的博客
05-20 270
上一篇文章我们学习了MyBatis使用注解实现单表的CRUD，通过上篇文章的学习我们对MyBatis基于注解开发有了一个基本的理解。这篇文章我们学习一下MyBatis使用注解实现多表查询。 一、复杂关系映射的注解说明 @Results注解 代替的是标签<resultMap> 该注解中可以使用单个@Result注解，也可以使用@Result集合 @Results({@Result()， @Result()})或@Results(@Result()) @Result注解 代替了<id.
mybatis：多表查询&&注解开发
weixin_43912954的博客
02-08 333
mybatis：多表操作 1. 一对一查询 关键：如何在mapper中定义一个对象的映射 解决：resultMap（+association） 实体： order.class public class Order { private int id; private Date ordertime; private double total; private User user; ♥ } 模型： 查询数据库语句：select *,o.oid oid from orders o,user
MyBatis(四)实现多表查询
qq_41443616的博客
10-09 1229
一、MyBatis实现多表查询 mybatis实现多表查询方式 业务装配：对两个表编写单表查询语句，在业务中把查询的两个结果进行关联。 使用Auto Mappering特性，在实现两表联合查询时通过别名完成映射。 使用MyBatis的标签进行实现。 多表查询时，勒种包含另一个类的对象的分类 单个对象 集合对象 二、resultMap标签 resultMap标签写在mapper.xml中，由程序员控制SQL查询结果与实体类的映射关系 默认MyBatis使用Auto Mappering特性
mybatis-day03笔记
weixin_45185764的博客
09-18 172
1.Mybatis多表查询 一对一 人-1-----1-身份证号 一对多 多对一 USER ==1============N==orders 多对多 用户 =1=====N==中间表==N====1== 角色 1.1 一对一查询 1.1.1 一对一查询的模型 用户表和订单表的关系为，一个用户有多个订单，一个订单只从属于一个用户 一对一查询的需求：查询一个订单，与此同...
MyBatis知识（3.注解开发多表查询）
m0_59619191的博客
04-25 1418
目录 1.Mybatis的多表查询 1.一对一查询 2. 一对多查询 3 多对多查询 2.Mybatis的注解开发 1.Mybatis的多表查询 1.一对一查询 查询思路（附代码） 1.查询关系：一个用户有多个订单，一个订单只从属于一个用户，一对一查询的需求：查询一个订单，与此同时查询出该订单所属的用户 2.查询语句：select * from orders o,user u where o.uid=u.id; 3.创建Order和User实体 public class Ord
深入理解MyBatis注解开发-SSM框架学习实践
不仅能掌握单表查询，还能熟练进行多表关联查询，从而测试自己是否对Mybatis注解开发有深刻的理解。 最后，压缩包中提供的文件清单包括了项目的主要组成部分，如MyBatisStudy.iml为项目的模块文件，jar包说明.txt为...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值