mybatis一对一，一对多，多对多 注解版

最新推荐文章于 2024-04-19 13:39:02 发布
最新推荐文章于 2024-04-19 13:39:02 发布
阅读量859 收藏 5
点赞数 2

下面三个案例都需要在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>
    <settings>
        <setting name="lazyLoadingEnabled" value="true"/>
        <setting name="aggressiveLazyLoading" value="false"/>
        <setting name="cacheEnabled" value="true"/>
    </settings>
    <!--  懒加载 
    <settings>
        <setting name="lazyLoadingEnabled" value="true"/>
        <setting name="aggressiveLazyLoading" value="false"/>
    </settings> -->
    <environments default="development">
        <environment id="development">
            <!-- 
                type="JDBC":指直接简单使用了JDBC的提交和回滚设置
                type="POOLED"：指让容器实现对事务的管理
             -->    
            <transactionManager type="JDBC" />
            <!-- 配置数据库连接信息 -->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver" />
                <property name="url" value="jdbc:mysql://localhost:3306/test?useUnicode=true&amp;characterEncoding=utf-8" />
                <property name="username" value="root" />
                <property name="password" value="caoxuekun" />
            </dataSource>
        </environment>
    </environments>
    <mappers>
         <!-- 注册userMapper.xml文件， 
         userMapper.xml位于me.gacl.mapping这个包下，所以resource写成me/gacl/mapping/userMapper.xml-->
         <mapper resource="usersMapper.xml"/>
         <mapper resource="relationMapping.xml"/>
         <mapper resource="cache.xml"/>
         <mapper class="com.interfaceMybatis.UsersMapper"/>
         <mapper class="com.interfaceMybatis.mapping.OneToOne" />
         <mapper class="com.interfaceMybatis.mapping.OneToMany" />
         <mapper class="com.interfaceMybatis.mapping.ManyToMany" />

     </mappers>

</configuration>

一对一： 
实体：

package com.entity.oneToOne;

import java.io.Serializable;

public class Person implements Serializable{
    private Integer id;
    private String name;
    private String sex;
    private Integer age;
    private Card card;
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    public Card getCard() {
        return card;
    }
    public void setCard(Card card) {
        this.card = card;
    }
}
package com.entity.oneToOne;


import java.io.Serializable;

public class Card implements Serializable{
    private Integer id;
    private String code;
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getCode() {
        return code;
    }
    public void setCode(String code) {
        this.code = code;
    }
}

 



数据库表：

CREATE TABLE `tb_person` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(100) DEFAULT NULL,
  `sex` varchar(100) DEFAULT NULL,
  `age` int(11) DEFAULT NULL,
  `card_id` int(11) DEFAULT NULL,
  PRIMARY KEY (`id`),
  UNIQUE KEY `card_id` (`card_id`),
  CONSTRAINT `tb_person_ibfk_1` FOREIGN KEY (`card_id`) REFERENCES `tb_card` (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;

CREATE TABLE `tb_card` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `code` varchar(100) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8;



注解配置：

package com.interfaceMybatis.mapping;

import org.apache.ibatis.annotations.One;
import org.apache.ibatis.annotations.Result;
import org.apache.ibatis.annotations.Results;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.mapping.FetchType;

import com.entity.oneToOne.Card;
import com.entity.oneToOne.Person;

public interface OneToOne {
    @Select("select * from tb_card where id = #{id}")
    Card selectCardById(Integer id);

    @Select("select * from tb_person where id = #{id}")
    @Results({
        @Result(id=true,column="id",property="id"),
        @Result(column="name",property="name"),
        @Result(column="sex",property="sex"),
        @Result(column="age",property="age"),
        @Result(column="card_id",property="card",
            one=@One(
                    select="com.interfaceMybatis.mapping.OneToOne.selectCardById",
                    fetchType=FetchType.EAGER
            ))
    })
    Person selectPersonById(Integer id);
}



测试：   

 public static SqlSession getSqlSession() {
        // mybatis的配置文件
        String resource = "conf.xml";
        // 使用类加载器加载mybatis的配置文件（它也加载关联的映射文件）
        InputStream is = Test1.class.getClassLoader().getResourceAsStream(resource);
        // 构建sqlSession的工厂
        SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(is);
        // 使用MyBatis提供的Resources类加载mybatis的配置文件（它也加载关联的映射文件）
        // Reader reader = Resources.getResourceAsReader(resource);
        // 构建sqlSession的工厂
        // SqlSessionFactory sessionFactory = new
        // SqlSessionFactoryBuilder().build(reader);
        // 创建能执行映射文件中sql的sqlSession
        SqlSession session = sessionFactory.openSession();
        return session;
    }

    //oneToOne
    public static void oneToOne(Integer id){
        SqlSession session = getSqlSession();
        OneToOne oto = session.getMapper(OneToOne.class);
//      Card card = oto.selectCardById(id);
//      System.out.println(card.getId()+"==="+card.getCode());

        Person person = oto.selectPersonById(id);
        System.out.println(person.getId()+"==="+person.getName()+"==="+person.getSex()+"==="+person.getAge()+"==="+person.getCard().getId()+"==="+person.getCard().getCode());
        session.commit();
        session.close();
    }

    public static void main(String[] args) {
        oneToOne(1);
//      oneToMany(1);
//      manyTomany();
    }



一对多 
实体：

package com.entity.oneToMany;

import java.io.Serializable;
import java.util.List;

public class Clazz implements Serializable{
    private Integer id;//班级id
    private String code;//班级编号
    private String name;//班级名称
    private List<Student> students;
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getCode() {
        return code;
    }
    public void setCode(String code) {
        this.code = code;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public List<Student> getStudents() {
        return students;
    }
    public void setStudents(List<Student> students) {
        this.students = students;
    }
}
package com.entity.oneToMany;

public class Student {
    private Integer id;
    private String name;
    private String sex;
    private Integer age;
    private Clazz clazz;
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    public Clazz getClazz() {
        return clazz;
    }
    public void setClazz(Clazz clazz) {
        this.clazz = clazz;
    }
}


数据库：

CREATE TABLE `tb_clazz` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `code` varchar(100) DEFAULT NULL,
  `name` varchar(100) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8;

CREATE TABLE `tb_student` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(100) DEFAULT NULL,
  `sex` varchar(18) DEFAULT NULL,
  `age` int(11) DEFAULT NULL,
  `clazz_id` int(11) DEFAULT NULL,
  PRIMARY KEY (`id`),
  KEY `clazz_id` (`clazz_id`),
  CONSTRAINT `tb_student_ibfk_1` FOREIGN KEY (`clazz_id`) REFERENCES `tb_clazz` (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=utf8;



注解配置：

package com.interfaceMybatis.mapping;

import java.util.List;

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 org.apache.ibatis.mapping.FetchType;

import com.entity.oneToMany.Clazz;
import com.entity.oneToMany.Student;

public interface OneToMany {
    @Select("select * from tb_student where clazz_id=#{id}")
    @Results({
        @Result(id=true,column="id",property="id"),
        @Result(column="name",property="name"),
        @Result(column="sex",property="sex"),
        @Result(column="age",property="age")
    })
    List<Student> selectByClazzId(Integer id);

    @Select("select * from tb_clazz where id = #{id}")
    @Results({
        @Result(id=true,column="id",property="id"),
        @Result(column="code",property="code"),
        @Result(column="name",property="name"),
        @Result(column="id",property="students",
            many=@Many(
                    select="com.interfaceMybatis.mapping.OneToMany.selectByClazzId",
                    fetchType=FetchType.LAZY
            )
        )
    })
    Clazz selectClazzByIdToManyStudent(Integer id);
}



测试：     

  public static SqlSession getSqlSession() {
        // mybatis的配置文件
        String resource = "conf.xml";
        // 使用类加载器加载mybatis的配置文件（它也加载关联的映射文件）
        InputStream is = Test1.class.getClassLoader().getResourceAsStream(resource);
        // 构建sqlSession的工厂
        SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(is);
        // 使用MyBatis提供的Resources类加载mybatis的配置文件（它也加载关联的映射文件）
        // Reader reader = Resources.getResourceAsReader(resource);
        // 构建sqlSession的工厂
        // SqlSessionFactory sessionFactory = new
        // SqlSessionFactoryBuilder().build(reader);
        // 创建能执行映射文件中sql的sqlSession
        SqlSession session = sessionFactory.openSession();
        return session;
    }

    //OneToMany
    public static void oneToMany(Integer id){
        SqlSession session = getSqlSession();
        OneToMany otm = session.getMapper(OneToMany.class);

        Clazz clazz = otm.selectClazzByIdToManyStudent(id);
        System.out.println(clazz.getId()+"=="+clazz.getName()+"==="+clazz.getCode());
        for(Student s:clazz.getStudents()){
            System.out.println(s.getId()+"==="+s.getName()+"==="+s.getSex()+"==="+s.getAge());
        }
        session.commit();
        session.close();
    }

    public static void main(String[] args) {
//      oneToOne(1);
        oneToMany(1);
//      manyTomany();
    }


多对多 
实体：

package com.entity.manyToMany;

import java.io.Serializable;
import java.util.List;

public class Article implements Serializable{
    private Integer id;//商品id
    private String name;//商品名称
    private Double price;//商品价格
    private String remark;//商品描述
    private List<Order> orders;
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Double getPrice() {
        return price;
    }
    public void setPrice(Double price) {
        this.price = price;
    }
    public String getRemark() {
        return remark;
    }
    public void setRemark(String remark) {
        this.remark = remark;
    }
    public List<Order> getOrders() {
        return orders;
    }
    public void setOrders(List<Order> orders) {
        this.orders = orders;
    }
}


 

package com.entity.manyToMany;

import java.io.Serializable;
import java.util.List;

public class Order implements Serializable {
    private Integer id;//订单id
    private String code;//订单编号
    private Double total;//订单总金额
    private User user;
    private List<Article> articles;//一个订单可包含多种商品
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getCode() {
        return code;
    }
    public void setCode(String code) {
        this.code = code;
    }
    public Double getTotal() {
        return total;
    }
    public void setTotal(Double total) {
        this.total = total;
    }
    public User getUser() {
        return user;
    }
    public void setUser(User user) {
        this.user = user;
    }
    public List<Article> getArticles() {
        return articles;
    }
    public void setArticles(List<Article> articles) {
        this.articles = articles;
    }
}
package com.entity.manyToMany;

import java.io.Serializable;
import java.util.List;

public class User implements Serializable{
    private Integer id;
    private String username;
    private String loginname;
    private String password;
    private String phone;
    private String address;//收获地址
    private List<Order> orders;//订单
    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 getLoginname() {
        return loginname;
    }
    public void setLoginname(String loginname) {
        this.loginname = loginname;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    public String getPhone() {
        return phone;
    }
    public void setPhone(String phone) {
        this.phone = phone;
    }
    public String getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address;
    }
    public List<Order> getOrders() {
        return orders;
    }
    public void setOrders(List<Order> orders) {
        this.orders = orders;
    }
}


数据库：

//多对多
create table tb_user(
id int PRIMARY key auto_increment,
username VARCHAR(100),
loginname varchar(100),
password VARCHAR(100),
phone varchar(18)
);


create table tb_article(
id int primary key auto_increment,
name VARCHAR(100),
price double,
remark VARCHAR(18)
);


create table tb_order(
id int primary key auto_increment,
code VARCHAR(180),
total double,
user_id int,
FOREIGN key(user_id) REFERENCES tb_user(id)
);

//tb_order和tb_article的中间表
create table tb_item(
order_id int,
article_id int,
amout int,
PRIMARY key(order_id,article_id),
FOREIGN key(order_id) REFERENCES tb_order(id),
FOREIGN key(article_id) REFERENCES tb_article(id)
);



注解配置：

package com.interfaceMybatis.mapping;

import java.util.List;

import org.apache.ibatis.annotations.Many;
import org.apache.ibatis.annotations.One;
import org.apache.ibatis.annotations.Result;
import org.apache.ibatis.annotations.Results;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.mapping.FetchType;

import com.entity.manyToMany.Article;
import com.entity.manyToMany.Order;
import com.entity.manyToMany.User;
import com.sun.scenario.effect.impl.prism.PrImage;

public interface ManyToMany {
    @Select("select * from tb_user where id = #{id}")
    User selectUserById(Integer id);

    @Select("select * from tb_article where id in (select article_id from tb_item where order_id = #{id})")
    List<Article> selectArticles(Integer id);

    @Select("select * from tb_order where id = #{id}")
    @Results({
        @Result(id=true,column="id",property="id"),
        @Result(column="code",property="code"),
        @Result(column="total",property="total"),
        @Result(column="user_id",property="user",
            one=@One(
                    select="com.interfaceMybatis.mapping.ManyToMany.selectUserById",
                    fetchType=FetchType.EAGER
            )
        ),
        @Result(column="id",property="articles",
            many=@Many(
                    select="com.interfaceMybatis.mapping.ManyToMany.selectArticles",
                    fetchType=FetchType.LAZY
            )
        )
    })
    Order selectOrderById(Integer id);

    @Select("select * from tb_order where id in(select order_id from tb_item where article_id = #{id})")
    List<Order> selectOrders(Integer id);

    @Select("select * from tb_article where id = #{id}")
    @Results({
        @Result(id=true,column="id",property="id"),
        @Result(column="name",property="name"),
        @Result(column="price",property="price"),
        @Result(column="remark",property="remark"),
        @Result(column="id",property="orders",
            many=@Many(
                    select="com.interfaceMybatis.mapping.ManyToMany.selectOrders",
                    fetchType=FetchType.LAZY
            )
        )
    })
    Article selectArticleById(Integer id);

}



测试：       

public static SqlSession getSqlSession() {
        // mybatis的配置文件
        String resource = "conf.xml";
        // 使用类加载器加载mybatis的配置文件（它也加载关联的映射文件）
        InputStream is = Test1.class.getClassLoader().getResourceAsStream(resource);
        // 构建sqlSession的工厂
        SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(is);
        // 使用MyBatis提供的Resources类加载mybatis的配置文件（它也加载关联的映射文件）
        // Reader reader = Resources.getResourceAsReader(resource);
        // 构建sqlSession的工厂
        // SqlSessionFactory sessionFactory = new
        // SqlSessionFactoryBuilder().build(reader);
        // 创建能执行映射文件中sql的sqlSession
        SqlSession session = sessionFactory.openSession();
        return session;
    }

    //manyTomany
    public static void manyTomany(){
        SqlSession session = getSqlSession();
        ManyToMany mtm = session.getMapper(ManyToMany.class);

        Order order = mtm.selectOrderById(1);
        System.out.println("order : "+order.getId()+"==="+order.getCode()+"==="+order.getTotal());
        System.out.println("=====Articles=====");
        for(Article a : order.getArticles()){
            System.out.println(a.getId()+"==="+a.getName()+"==="+a.getRemark()+"==="+a.getPrice());
        }
        System.out.println("\r\n========\r\n");
        Article article = mtm.selectArticleById(2);
        System.out.println("article:"+article.getId()+"==="+article.getName()+"==="+article.getRemark()+"==="+article.getPrice());
        for(Order o:article.getOrders()){
            System.out.println("order :"+o.getId()+"==="+o.getCode());
        }

    }

    public static void main(String[] args) {
//      oneToOne(1);
//      oneToMany(1);
        manyTomany();


原文：https://blog.csdn.net/caoxuekun/article/details/76944001 
 

李晚晚
关注
  • 2
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Mybatis Plus一对多完整版实战教学!
qq_41579123的博客
05-19 3037
Mybatis Plus完整版一对多实战教学! 最近做项目用到了mybatis plus 刚使用确实不是很熟练。 增删改查非常方便，但是然项目中需要用到了一对多的一个查询，我却毫无思路，所以在网上查阅了相关资料。结合了多篇文章，才明白了怎么用mybatis做一对多。 进入正题 查阅相关资料，mybatis没办法想jpa那样直接写注解 所以我们今天就是最大程度的简化代码量 首先吧实体类粘出来 这是一个位置的管理实体 @Data @NoArgsConstructor @AllArgsConstructor .
Mybatis中通过注解的方式实现多对多查询
qq_51962134的博客
01-29 876
文章目录前言一、创建数据库1.创建学生信息表2.创建课程信息表3.创建成绩表（中间表）二、创建项目1.配置pom.xml文件2.建立实体类和接口3.创建主配置文件4.创建配置文件4.建立测试5.测试结果总结 前言 文章通过课程与学生之间的多对多关系，（一个学生可以选择多门课程，以及一个课程可以被多个学生选择）来展示mybatis中的相应多表查询。 在mybatis中“一对多”和“多对多”关系通常情况下采用的都是延迟加载。 一、创建数据库 示例：pandas 是基于NumPy 的一种工具，该工具是为了解.
mybatis一对多、多对多查询（注解版）
m0_73404192的博客
11-10 555
这里的多对多查询方法比较繁琐，还有左连接查询等其他查询方法这两个查询主要是要知道注解@Results中参数表示什么意思，property的值是查询表的实体类中的属性名，column是查询的表中的字段名，两者相同的时候可以不写。只要来日可期，今天就值得欣喜。
Mybatis基础学习之一对多关系处理
weixin_45301250的博客
11-13 1162
前言： 小伙伴们，大家好，我是狂奔の蜗牛rz，当然你们可以叫我蜗牛君，我是一个学习Java半年多时间的小菜鸟，同时还有一个伟大的梦想，那就是有朝一日，成为一个优秀的Java架构师。 这个Mybatis基础学习系列是用来记录我学习Mybatis框架基础知识的全过程 (这个系列是参照B站狂神的Mybatis最新教程来写的，由于是之前整理的，但当时没有发布出来，所以有些地方可能有错误，希望大家能够及时指正！) 之后我将尽量以两天一更的速度更新这个系列，还没有学习Mybatis3框架的小伙伴可以参照我的
springboot +mybatis 实现一对多，多对一，多对多 【注解版】
wzbjsz的博客
09-05 5115
MyBatis中的一对多 ，多对一，多对多【注解】 以下的例子就是针对 前端框架中所实现的 省-市-区  选择框的数据接口 前端需要的接口类型：  后台代码： dao层： ProvinceDAO /**  *  * @author 邬志斌  * 2018年9月5日 下午2:51:13  */ @Mapper public interface P...
Mybatis-Plus用纯注解完成一对多&多对多查询
白石的专栏
09-06 8504
Mybatis-Plus用纯注解搞定一对多&多对多查询
MyBatis 一对多嵌套查询
weixin_44560583的博客
01-15 4069
标题MyBatis 一对多结果集嵌套查询 嵌套查询的实现原理为两次查询，比如产品表为主表，图片表为从表通过product_id字段与产品表id字段关联实现一对多，嵌套查询查询两次 首先查询 主表的数据 然后将主表id字段赋值给从表实体类中product_id 字段（productId）然后通过dao接口路径映射找到对应的MyBatis XMl文件SQL语句ID如：com.liao.dao.DImgMapper.selectDImgByProductId 进行子查询也就是第二次查询。然后返回数据 数据库建表
关于mybatis一对一查询，一对多查询遇到的错误
roydon
05-25 4736
springboot整合mybatis项目 博客系统 文章，相册，评论，标签，等表 IDEA为最新版2021.3.3，mysql数据库为最新版Navicat （或许有些字段不支持特定的命名） 也是醉了，以前idea还是19版的，navicat也是老版本的时候mybatis关联查询mapper操作能正常运行，拿到相应字段，并封装，但最近写项目过程中遇到一个离谱的是，过了好久才发现， 当关联查询时，无论一对一还是一对多 除了需要注意javaType和ofType之外，还应该注意各表主键不能同一名称 ...
一对多关联映射查询
RobertChao的博客
02-11 1260
文章目录一对多的关联映射查询SSM 框架中 Mybatis 的映射结果集查询一、SSM 框架，使用 mybatis 进行一对多查询。hibernate 中的注解查询二、使用@OnetoMany ，@ManytoOne 查询。在配置好上述文件之后，我们使用 JPA 注解进一步编写映射的实体类。单向的一对多 @OneToMany单向的多对一 @ManytoOne双向的 @OneToMany，@Man...
mybatis一对一，多对一，一对多--使用自动映射避免繁琐的resultMap
Cloud的专栏
04-19 1096
我们知道，相比较hibernate,mybatis的一对一，一对多都比较繁琐，hibernate可以直接在实体类里面配置好映射关系，获取值的时候就能把一对一和一对多的对象带出来了，而mybatis需要用到resultMap,需要在resultMap中把实体类与表字段的对应关系一一写出来，如果遇到关联表有相同字段名，还要写别名，画风往往是这样的:看着好像还行，但是要知道有些表可是有几十个字段的， 不仅要写resultMap,还要在sql中把所有列名写出来，这酸爽，看着就头疼，幸亏有个大杀器autoMappin
结合mybatis-plus实现简单不需要写sql的多表查询
08-25
在 MyBatis-Plus 中，实现多表查询的关键在于实体类的关联和注解的使用。首先，你需要确保项目中已经集成了 MyBatis-Plus。表关联的规则是通过 @TableId 注解来标识主键字段，MyBatis-Plus 会自动寻找相同名称的属性...
Mybatis中文API多语言版
07-18
Mybatis是一款广受欢迎的Java持久层框架，它简化了数据访问层的开发，通过XML或注解方式将SQL与Java代码绑定，使开发者无需编写大量的DAO（Data Access Object）层代码，就能实现对数据库的操作。这个压缩包" ...
idea,mybatis插件直接可用多版本2018.1可用
07-04
【标题】"idea,mybatis插件直接可用多版本2018.1可用" 描述了这个资源是一个适用于IntelliJ IDEA（简称IDEA）的MyBatis插件，且该插件不仅兼容常规版本，还特别指出支持2018.1这一特定版本的IDEA。MyBatis是一款流行...
springboot整合mybatis-plus实现多表分页查询
06-20
在这些类中，我们可以使用注解来定义一对一和一对多的关联关系，如`@OneToOne`，`@OneToMany`，`@ManyToOne`，`@ManyToMany`等。 在MyBatis-Plus中，我们可以使用`@TableId`，`@TableField`等注解来指定主键和字段...
springmvc3+spring+mybatis3整合项目 注解实现
11-01
总的来说，这个整合项目是一个典型的Java Web应用开发示例，涵盖了前端控制器、服务层、持久层的集成以及事务管理等多个方面，对于学习和理解Spring MVC、Spring和MyBatis的协作机制具有很高的参考价值。通过注解的...
方案-基于云架构的校园信息化建设方案.pdf
最新发布
07-29
方案-基于云架构的校园信息化建设方案.pdf
【创新未发表】Matlab实现蛇群优化算法SO-Kmean-Transformer-LSTM负荷预测算法研究.rar
07-29
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 5.作者介绍：某大厂资深算法工程师，从事Matlab算法仿真工作10年；擅长智能优化算法、神经网络预测、信号处理、元胞自动机等多种领域的算法仿真实验，更多仿真源码、数据集定制私信+。 替换数据可以直接使用，注释清楚，适合新手
【创新未发表】Matlab实现北方苍鹰优化算法NGO-Kmean-Transformer-LSTM组合状态识别算法研究.rar
07-29
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 5.作者介绍：某大厂资深算法工程师，从事Matlab算法仿真工作10年；擅长智能优化算法、神经网络预测、信号处理、元胞自动机等多种领域的算法仿真实验，更多仿真源码、数据集定制私信+。 替换数据可以直接使用，注释清楚，适合新手
【创新未发表】Matlab实现蝗虫优化算法GOA-Kmean-Transformer-BiLSTM组合状态识别算法研究.rar
07-29
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 5.作者介绍：某大厂资深算法工程师，从事Matlab算法仿真工作10年；擅长智能优化算法、神经网络预测、信号处理、元胞自动机等多种领域的算法仿真实验，更多仿真源码、数据集定制私信+。 替换数据可以直接使用，注释清楚，适合新手
Mybatis入门与实战教程：XML与注解版详解
7. **高级使用**：探讨多表关联查询，如一对多、一对一和多对多关系的处理。 8. **高级特性**： - **加载和缓存**：阐述了如何利用MyBatis的延迟加载和缓存功能优化性能。 - **注解开发**：介绍了MyBatis注解的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值