09 mybatis的注解开发(注解实现增删改查及多表查询)

最新推荐文章于 2022-01-27 16:55:44 发布
最新推荐文章于 2022-01-27 16:55:44 发布
阅读量158 收藏
点赞数
分类专栏： mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cl66666666/article/details/112687668
版权
本文介绍了如何使用MyBatis注解进行增删改查操作，包括@Insert、@Update、@Delete、@Select的使用。同时，详细展示了如何实现一对一和一对多的结果集映射，以及通过@One和@Many注解处理关联关系。在测试类中，验证了这些功能的正确性。
摘要由CSDN通过智能技术生成
Mybatis常用注解

@Insert：实现新增

@Update：实现更新

@Delete：实现删除

@Select：实现查询

@Result：实现结果集封装

@Results：可以与@Result 一起使用，封装多个结果集

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

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

MyBatisz注解的增删改查

即无需再写（UserMapper.xml）配置文件
在这里插入图片描述

sqlMapConfig.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-->
    <properties resource="jdbc.properties"></properties>

    <!--配置数据源环境-->
    <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="li.chen.com.business.mapper.UserMapper"></mapper>
    </mappers>

<!--    <mappers>-->
<!--        &lt;!&ndash;扫描使用注解的类所在的包&ndash;&gt;-->
<!--        <package name="li.chen.com.business.mapper"></package>-->
<!--    </mappers>-->

</configuration>

UserMapper

package li.chen.com.business.mapper;

import li.chen.com.business.entity.User;
import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.Update;

import java.util.List;

public interface UserMapper {
    @Insert("insert into user(id,userName,passWord) values (#{id},#{userName},#{passWord})")
    public void insert(User user);

    @Update("update user set userName=#{userName},passWord=#{passWord} where id=#{id}")
    public void update(User user);

    @Select("select * from user where id = #{id}")
    public User findById(int id);

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

    @Select("select * from user")
    public List<User> findAll();
}

测试类

package li.chen.com;

import li.chen.com.business.entity.User;
import li.chen.com.business.mapper.UserMapper;
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.Before;
import org.junit.Test;

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

public class MybatisTest {
    private UserMapper  mapper;

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

    @Test
    public void testInsert(){
        User user = new User();
        user.setUserName("anan");
        user.setPassWord("98584785");
        mapper.insert(user);
    }

    @Test
    public void testiUpdate(){
        User user = new User();
        user.setUserName("anny");
        user.setPassWord("000000");
        user.setId(2);
        mapper.update(user);
    }

    @Test
    public void testFindById(){
        User byId = mapper.findById(2);
        System.out.println(byId);
    }

    @Test
    public void testDelete(){
        mapper.delete(2);
    }

    @Test
    public void testFindAll(){
        List<User> userList = mapper.findAll();
        for (User user : userList) {
            System.out.println(user);
        }
    }

}
MyBatisz注解的一对一实现

在这里插入图片描述

Orders

package li.chen.com.business.entity;

import java.util.Date;

public class Orders {
    private Integer id;
    private Date orderTime;
    private Double total;
    private Integer uid;


    //当前订单属于哪个用户 即数据库中uid
    private User user;

    public Integer getId() {
        return id;
    }

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

    public Date getOrderTime() {
        return orderTime;
    }

    public void setOrderTime(Date orderTime) {
        this.orderTime = orderTime;
    }

    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 Integer getUid() {
        return uid;
    }

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

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

OrdersMapper (重点)

package li.chen.com.business.mapper;

import li.chen.com.business.entity.Orders;
import li.chen.com.business.entity.User;
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 java.util.List;

public interface OrdersMapper {

    @Select("select * from orders")
    @Results({
            @Result(column = "oid" , property = "id"),
            @Result(column = "orderTime" , property = "orderTime"),
            @Result(column = "total" , property = "total"),
            @Result(
                    property = "user", //要封装的属性名称
                    column = "uid",    //根据这个字段去查询user表的数据
                    javaType = User.class,  // 要封装的实体类
                    //select 属性  代表查询那接口的方法获得数据
                    one = @One(select = "li.chen.com.business.mapper.UserMapper.findById")
            )
    })
    public List<Orders> findAll();

    /*
    @Select("select *,o.id oid from orders o,user u where o.uid=u.id")
    @Results({
            @Result(column = "oid" , property = "id"),
            @Result(column = "orderTime" , property = "orderTime"),
            @Result(column = "total" , property = "total"),
            @Result(column = "uid" , property = "user.id"),
            @Result(column = "userName" , property = "user.userName"),
            @Result(column = "passWord" , property = "user.passWord"),
            @Result(column = "birthday" , property = "user.birthday")
    })
    public List<Orders> findAll();

     */
}

测试类

package li.chen.com;

import li.chen.com.business.entity.Orders;
import li.chen.com.business.entity.User;
import li.chen.com.business.mapper.OrdersMapper;
import li.chen.com.business.mapper.UserMapper;
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.Before;
import org.junit.Test;

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

public class MybatisTest2 {
    private OrdersMapper  mapper;

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



    @Test
    public void testFindAll(){
        List<Orders> ordersList = mapper.findAll();
        for (Orders orders : ordersList) {
            System.out.println(orders);
        }
    }

}

//---------------------------------------------------------
18:36:43,063 DEBUG findAll:159 - ==>  Preparing: select * from orders 
18:36:43,093 DEBUG findAll:159 - ==> Parameters: 
18:36:43,121 DEBUG findById:159 - ====>  Preparing: select * from user where id = ? 
18:36:43,122 DEBUG findById:159 - ====> Parameters: 1(Integer)
18:36:43,126 DEBUG findById:159 - <====      Total: 1
18:36:43,129 DEBUG findById:159 - ====>  Preparing: select * from user where id = ? 
18:36:43,129 DEBUG findById:159 - ====> Parameters: 2(Integer)
18:36:43,131 DEBUG findById:159 - <====      Total: 1
18:36:43,131 DEBUG findAll:159 - <==      Total: 3
Orders{id=null, orderTime=Wed Dec 12 00:00:00 CST 2018, total=3000.0, uid=null, user=User{id=1, userName='lucy', passWord='123', birthday=Wed Dec 12 00:00:00 CST 2018, roleList=null}}
Orders{id=null, orderTime=Wed Dec 12 00:00:00 CST 2018, total=4000.0, uid=null, user=User{id=1, userName='lucy', passWord='123', birthday=Wed Dec 12 00:00:00 CST 2018, roleList=null}}
Orders{id=null, orderTime=Wed Dec 12 00:00:00 CST 2018, total=5000.0, uid=null, user=User{id=2, userName='haohao', passWord='123', birthday=Thu Dec 12 00:00:00 CST 2019, roleList=null}}
MyBatisz注解的一对多的实现

在这里插入图片描述

UserMapper

package li.chen.com.business.mapper;

import li.chen.com.business.entity.Orders;
import li.chen.com.business.entity.User;
import org.apache.ibatis.annotations.*;

import java.util.List;

public interface UserMapper {
    @Insert("insert into user(id,userName,passWord,birthday) values (#{id},#{userName},#{passWord},#{birthday})")
    public void insert(User user);

    @Update("update user set userName=#{userName},passWord=#{passWord} where id=#{id}")
    public void update(User user);

    @Select("select * from user where id = #{id}")
    public User findById(int id);

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

    @Select("select * from user")
    public List<User> findAll();

    @Select("select * from user")
    @Results({
            @Result(id = true, column = "id", property = "id"),
            @Result(column = "userName", property = "userName"),
            @Result(column = "passWord", property = "passWord"),
            @Result(column = "birthday", property = "birthday"),
            @Result(
                    property = "ordersList",
                    column = "id",
                    javaType = List.class,  //查询结果为list
                    many = @Many(select = "li.chen.com.business.mapper.OrdersMapper.findById")
            )}
    )
    public List<User> findAllOrders();


}

测试类

package li.chen.com;

import li.chen.com.business.entity.Orders;
import li.chen.com.business.entity.User;
import li.chen.com.business.mapper.OrdersMapper;
import li.chen.com.business.mapper.UserMapper;
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.Before;
import org.junit.Test;

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

public class MybatisTest3 {
    private UserMapper  mapper;

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

    @Test
    public void testFindAll(){
        List<User> mapperAllOrders = mapper.findAllOrders();
        for (User mapperAllOrder : mapperAllOrders) {
            System.out.println(mapperAllOrder);
        }
    }

}

//------------------------------------

19:35:35,153 DEBUG findById:159 - ====>  Preparing: select * from orders where uid=? 
19:35:35,155 DEBUG findById:159 - ====> Parameters: 1(Integer)
19:35:35,157 DEBUG findById:159 - <====      Total: 2
19:35:35,158 DEBUG findById:159 - ====>  Preparing: select * from orders where uid=? 
19:35:35,159 DEBUG findById:159 - ====> Parameters: 2(Integer)
19:35:35,160 DEBUG findById:159 - <====      Total: 1
19:35:35,161 DEBUG findById:159 - ====>  Preparing: select * from orders where uid=? 
19:35:35,162 DEBUG findById:159 - ====> Parameters: 4(Integer)
19:35:35,163 DEBUG findById:159 - <====      Total: 0
19:35:35,163 DEBUG findById:159 - ====>  Preparing: select * from orders where uid=? 
19:35:35,164 DEBUG findById:159 - ====> Parameters: 5(Integer)
19:35:35,164 DEBUG findById:159 - <====      Total: 0
19:35:35,165 DEBUG findAllOrders:159 - <==      Total: 4
User{id=1, userName='lucy', passWord='123', birthday=Wed Dec 12 00:00:00 CST 2018, ordersList=[Orders{id=1, orderTime=Wed Dec 12 00:00:00 CST 2018, total=3000.0, uid=1, user=null}, Orders{id=2, orderTime=Wed Dec 12 00:00:00 CST 2018, total=4000.0, uid=1, user=null}]}
User{id=2, userName='haohao', passWord='123', birthday=Thu Dec 12 00:00:00 CST 2019, ordersList=[Orders{id=3, orderTime=Wed Dec 12 00:00:00 CST 2018, total=5000.0, uid=2, user=null}]}
User{id=4, userName='anan', passWord='98584785', birthday=Wed Jan 13 19:32:51 CST 2021, ordersList=[]}
User{id=5, userName='anan', passWord='98584785', birthday=Wed Jan 13 17:58:15 CST 2021, ordersList=[]}
MyBatisz注解的多对多的实现

在这里插入图片描述

Role

package li.chen.com.business.entity;

public class Role {
    private Integer id;
    private String roleName;
    private String roleDesc;

    public Integer getId() {
        return id;
    }

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

    public String getRoleName() {
        return roleName;
    }

    public void setRoleName(String roleName) {
        this.roleName = roleName;
    }

    public String getRoleDesc() {
        return roleDesc;
    }

    public void setRoleDesc(String roleDesc) {
        this.roleDesc = roleDesc;
    }

    @Override
    public String toString() {
        return "Role{" +
                "id=" + id +
                ", roleName='" + roleName + '\'' +
                ", roleDesc='" + roleDesc + '\'' +
                '}';
    }
}

User

package li.chen.com.business.entity;

import java.util.Date;
import java.util.List;

public class User {
    private Integer id;
    private String userName;
    private String passWord;
    private Date birthday;

    //描述的是当前用户存在哪些订单
    private List<Orders> ordersList;

    //描述的是当前用户具备哪些角色
    private List<Role> roleList;

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

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

    public List<Orders> getOrdersList() {
        return ordersList;
    }

    public void setOrdersList(List<Orders> ordersList) {
        this.ordersList = ordersList;
    }

    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;
    }

    public Date getBirthday() {
        return birthday;
    }

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

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", userName='" + userName + '\'' +
                ", passWord='" + passWord + '\'' +
                ", birthday=" + birthday +
                ", ordersList=" + ordersList +
                ", roleList=" + roleList +
                '}';
    }
}

RoleMapper

package li.chen.com.business.mapper;

import li.chen.com.business.entity.Role;
import org.apache.ibatis.annotations.Select;

import java.util.List;

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

UserMapper

package li.chen.com.business.mapper;

import li.chen.com.business.entity.User;
import org.apache.ibatis.annotations.*;

import java.util.List;

public interface UserMapper {

    @Select("select * from user")
    @Results({
            @Result(id = true, column = "id", property = "id"),
            @Result(id = true, column = "userName", property = "userName"),
            @Result(id = true, column = "passWord", property = "passWord"),
            @Result(
                    property = "roleList",
                    column = "id",
                    javaType = List.class,  //查询结果为list
                    many = @Many(select = "li.chen.com.business.mapper.RoleMapper.findByUid")
            )}
    )
    public List<User> findUserAndRole();
}

测试类

package li.chen.com;

import li.chen.com.business.entity.User;
import li.chen.com.business.mapper.UserMapper;
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.Before;
import org.junit.Test;

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

public class MybatisTest4 {
    private UserMapper  mapper;

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

    @Test
    public void testFindAll(){
        List<User> mapperUserAndRole = mapper.findUserAndRole();
        for (User user : mapperUserAndRole) {
            System.out.println(user);
        }

    }

}
//----------------------------------------------------
23:20:56,802 DEBUG findByUid:159 - ====>  Preparing: select * from sys_user_role ur,sys_role r where r.id=ur.roleId and ur.userId=? 
23:20:56,804 DEBUG findByUid:159 - ====> Parameters: 1(Integer)
23:20:56,807 DEBUG findByUid:159 - <====      Total: 2
23:20:56,812 DEBUG findByUid:159 - ====>  Preparing: select * from sys_user_role ur,sys_role r where r.id=ur.roleId and ur.userId=? 
23:20:56,813 DEBUG findByUid:159 - ====> Parameters: 2(Integer)
23:20:56,816 DEBUG findByUid:159 - <====      Total: 2
23:20:56,817 DEBUG findByUid:159 - ====>  Preparing: select * from sys_user_role ur,sys_role r where r.id=ur.roleId and ur.userId=? 
23:20:56,818 DEBUG findByUid:159 - ====> Parameters: 4(Integer)
23:20:56,819 DEBUG findByUid:159 - <====      Total: 0
23:20:56,820 DEBUG findByUid:159 - ====>  Preparing: select * from sys_user_role ur,sys_role r where r.id=ur.roleId and ur.userId=? 
23:20:56,821 DEBUG findByUid:159 - ====> Parameters: 5(Integer)
23:20:56,822 DEBUG findByUid:159 - <====      Total: 0
23:20:56,822 DEBUG findUserAndRole:159 - <==      Total: 4
User{id=1, userName='lucy', passWord='123', birthday=Wed Dec 12 00:00:00 CST 2018, ordersList=null, roleList=[Role{id=1, roleName='CTO', roleDesc='CTO'}, Role{id=2, roleName='COO', roleDesc='COO'}]}
User{id=2, userName='haohao', passWord='123', birthday=Thu Dec 12 00:00:00 CST 2019, ordersList=null, roleList=[Role{id=1, roleName='CTO', roleDesc='CTO'}, Role{id=2, roleName='COO', roleDesc='COO'}]}
User{id=4, userName='anan', passWord='98584785', birthday=Wed Jan 13 19:32:51 CST 2021, ordersList=null, roleList=[]}
User{id=5, userName='anan', passWord='98584785', birthday=Wed Jan 13 17:58:15 CST 2021, ordersList=null, roleList=[]}
岿然如故
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
MyBatis研习录(06)——基于注解的增删改查操作
谷哥的小弟
11-27 806
除了之前的DAO和Mapper接口方式以外，MyBatis还支持使用注解对数据库进行增删改查操作。该方式特点如下：1、不用再编写xxxMapper.xml映射文件。利用注解替换原在xxxMapper.xml中的操作。2、保留原xxxMapper.java接口并在mybatis-config.xml中利用class配置mapper3、注解方式适用于简单的增删改查操作，不宜复杂操作4、在同一项目中注解方式可以和xml方式混合使用
mybatis基于注解实现增删改查（详细介绍）
weixin_43880289的博客
11-11 3545
mybatis高级查询——基于注解开发（详细介绍） 文章目录mybatis高级查询——基于注解开发（详细介绍）一、mybatis基于注解实现增删改查1.1 搭建环境1.2 实现增删改查二、使用步骤1.引入库2.读入数据总结 提示 一、mybatis基于注解实现增删改查 在上篇文章中我详细介绍了mybatis的SQL映射文件可以基于xml的方式配置，但是我们发现在映射文件中书写sql语句比较繁琐。因此Mybatis为用户提供了快速的开发方式，即基于注解(Annnotation)的配置方式，其可以提高开发效
mybatis注解开发增删改查
xzj80927的博客
04-17 189
1、添加 @Insert(" INSERT INTO audio (audio_id,audio_name,use_count,audio_text,audio_path,audio_type,create_time,create_by,type,version_number) " + " VALUES (#{audioId},#{audioName},#{useCount},...
Mybatis——多表查询注解开发实现
jhin_lx的博客
10-08 1065
目录多表查询相关注解数据表与实体类一对一 多表查询OrderMapperUserMapper测试一对多 多表查询UserMapperOrderMapper测试多对多 多表查询OrderMapperRoleMapper测试 多表查询相关注解 实现复杂关系映射之前可以在映射文件中通过配置resultMap来实现，使用注解开发后，则可以使用@Results注解，@Result注解，@One注解，@Many注解组合完成复杂关系的配置 数据表与实体类 这里有涉及到java.util.Date类型与数据库中bigi
Spirng Boot整合Mybatis实现增删改查案例-注解版
脚踏实地，慢慢来
01-04 6148
前面的文章介绍了Spring Boot整合JPA实现数据库的访问功能，这里再次介绍Spring Boot整合Mybatis实现数据的增删改查功能。 一、Maven依赖 这里贴出Spring Boot整合Mybatis的完整pom.xml文件代码： project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xs
Mybatis基于注解实现多表查询功能
08-25
Mybatis基于注解实现多表查询功能 Mybatis基于注解实现多表查询功能是指使用Mybatis框架中的注解来实现多表查询的功能。这种方法可以简化配置，提高开发效率。下面我们将详细介绍如何使用Mybatis基于注解实现多表...
Mybatis开发环境搭建实现数据的增删改查功能
08-31
"Mybatis开发环境搭建实现数据的增删改查功能" 本资源主要介绍了 Mybatis 开发环境搭建实现数据的增删改查功能，带来了非常高的参考借鉴价值，需要的朋友可以参考下。下面是对该资源的详细解读和知识点总结： ...
基于ssm实现注解式开发(增删改查)
07-15
本文将深入探讨如何在SSM框架下利用注解进行增删改查的开发。 首先，Spring框架是整个应用的核心，它负责管理Bean的生命周期和依赖注入。在注解式开发中，我们通常会使用`@Component`、`@Service`、`@Repository`和...
Springboot 整合Mybatis +thymeleaf 实现增删改查，包含前端HTML页面
09-21
在本教程中，我们将深入探讨如何使用Spring Boot整合Mybatis和Thymeleaf来实现一个基本的CRUD（创建、读取、更新、删除）应用。这个实例特别适合初学者，因为它提供了一个从前端到后端完全功能的示例。 首先，...
springboot+mybatis+mysql+layUI+thymeleaf实现增删改查
04-04
在本项目中，我们利用了SpringBoot、MyBatis、MySQL、LayUI和Thymeleaf这五种核心技术，构建了一个完整的Web应用程序，实现了学生信息管理系统的增删改查功能。下面将对这些技术及其在项目中的应用进行详细解释。 *...
Mybatis 多表实现多对多查询、添加操作
zzvar的博客
05-20 3452
Mybatis 多表实现多对一查询、添加操作学习内容：1. 多对多之添加操作1.1、需求1.2、数据库表(多对多数据库设计需要设计中间表)1.3、类设计1.4、Mapper 接口和 Mapper XML 文件编写1.5、编写单元测试类2. 单向多对多之额外 SQL 查询2.1、需求2.2、需要添加 Mapper 接口 和 Mapper XML2.3、单元测试方法总结： 学习内容： 1. 多对多之添加操作 1.1、需求 保存两个学生和两个老师，且这两个老师都教了这个两个学生。 1.2、数据库表(多对多数据库
mybatis注解开发（增删改查多表查询）
小匠心的博客
08-10 673
1.创建personDao public interface PersonDao { @Select("select * from person where id = #{id}") @Results(value = { @Result(column = "id", property = "id", id = true), ...
Mybatis入门-基于注解实现单表、多表的增删改查
小小张自由—>张有博
04-12 3110
Mybatis入门—基于注解实现单表、多表的增删改查。需要我们多记住一些注解@select @insert @update @delete @result @results @results @resuleMap.多记注解多练习。加油
MyBatis框架进阶（二），Mybatis注解开发，实现单表的增删改查与多表关联查询
成长，编程，生活
04-07 487
Mybatis注解开发，实现单表的增删改查与多表关联查询并实现延迟加载。
MyBatis -- 对表进行增删改查(基于注解的实现)
Guus
08-07 1万+
1、MyBatis对数据库表进行增/删/改/查 前一篇使用基于XML的方式实现对数据库的增/删/改/查 下面我们来看怎么使用注解的方式实现对数据库表的增/删/改/查 1.1  首先需要定义映射sql的接口，代码如下： package org.guus.inter; import java.util.List; import org.apache.ibatis.annotations.D
Mybatis注解学习-增删改查
justleavel的博客
01-27 1083
自动提交事务： 增删改查：去掉了Mapper.xml文件，改成了使用注解： import com.ftz.Demo.dao.UserMapper; import com.ftz.Demo.po.User; import com.ftz.Demo.utils.MybatisUtil; import org.apache.ibatis.session.SqlSession; import org.junit.Test; public class TestUser { @Test pub
mysql的delete语句_mysql删除语句
weixin_33451125的博客
01-18 4575
展开全部mysql删除语句如下：1、delete删除一行：delete from student where id=1。2、delete删除多行：delete from student where in (1,2,3)3。3、删62616964757a686964616fe78988e69d8331333433623162除表的所有数据：delete from student，请使用不带where...
Mybatis入门学习篇（二）之基于注解的增删改查
Program with head, not hand
01-02 6989
工程环境: JDK1.8 + Mybatis3 + JUnit + Mysql    1. 在数据库中建表 学生表: create table student(id int auto_increment primary key,name varchar(10) unique, age int);   2.  运用Mybatis Generator反向生成model,mapper...
mybatis3使用@Select等注解实现增删改查
热门推荐
ZJE
04-04 2万+
1.需要的jar包 2.目录树 3.具体代码 一.需要的jar包 第一个：mybatis的jar包 第二个：mysql数据的驱动 二.目录树 三.具体代码 使用框架，配置文件先行！ conf.xml：（配置 登录数据库，映射文件） <!DOCTYPE configuration PUBLIC "-//mybatis.org//D
SpringBoot+Mybatis+Thymeleaf：MySQL快速实现增删改查
本篇文章主要介绍了如何使用SpringBoot、Mybatis和Thymeleaf技术栈配合MySQL数据库实现基本的增删改查操作。首先，文章的背景是站在已有的SpringBoot框架基础上，利用Mybatis作为ORM工具处理数据持久层，而Thymeleaf...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

岿然如故

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值