mybatis与mybatisplus

已于 2024-04-24 16:55:10 修改
阅读量179 收藏 2
点赞数 3
文章标签： java
于 2024-04-16 22:08:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/happyxin_/article/details/137842577
版权

mybatis

基本使用

整合springboot

1.添加依赖
2.添加配置
spring:
  # 数据源相关配置
  datasource:
    username: root
    password: 123456
    driver-class-name: com.mysql.cj.jdbc.Driver
    #时区必须配置否则报错,注意数据库名切换为自己的数据库名称
    url:  jdbc:mysql://127.0.0.1/itheima?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
#mybatis 相关配置
mybatis:
  # 指定接口映射文件的位置
  mapper-locations: classpath:mapper/*.xml
  # 为POJO类指定别名 指定后使用时不再需要指定包名
  type-aliases-package: com.itheima.integration.pojo
# 开启debug日志
logging:
  level:
    com.itheima.springbootinit4: debug
3.指定DAO接口所在的包

@Mapper、@MapperScan详解

@SpringBootApplication
@MapperScan("com.winter.dao")
public class SpringbootMybatisDemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(SpringbootMybatisDemoApplication.class, args);
    }
}

模糊查询

在这里插入图片描述

获取自增主键

插入数据后获取自增主键的方案有两种，分别是使用<selectKey>和useGeneratedKeys属性
在这里插入图片描述

在这里插入图片描述
扩展 如果id为字符串类型，主键由uuid生成
在这里插入图片描述

ognl 表达式

#{} 【推荐】: 占位符， 相当于PreparedStatement对象, 会自动转换类型
	pojo对象 		 #{对象中的属性名} -- 获取pojo中的属性
	基本数据类型 	  #{参数名}	-- 获取基本类型数据,参数名通过@Param("xxxx")指定
${}	: 拼接符， 相当于字符串直接拼接， 不会自动转换类型，需要手动拼接类型
	pojo对象 		${对象中的属性名}	-- 获取pojo中的属性
	基本数据类型   ${参数名}  -- 获取基本类型数据,参数名通过@Param("xxxx")指定

 User selectById( @Param("id") Integer id);

<!--
    属性
    id              对应方法名，唯一
    parameterType   参数的类型，可以省略
    resultType      返回值类型
-->
<select id="selectById" parameterType="java.lang.Integer" resultType="com.itheima.entity.User">
  select * from t_user where id = #{id}
</select>
<!--
获取mapper传入参数
1.简单类型：四类八种， String  获取：使用`#{}`直接获取参数，名称可以任意写（有注解时与注解保一致）
2.实体对象参数（POJO类）
获取：使用`#{}`直接获取对象的属性（有注解时，注解内容 点 属性）
-->

标签

resultMap 标签

    <!--
    定义映射
        id：映射的名字
        type：实体类
    -->
    <resultMap id="userResultMap" type="User">
        <!--
        定义字段映射，id和result标签分别表示主键字段映射和非主键字段映射
            property    实体类中的属性名
            column      SQL返回结果的列名
            如果property和cloumn的值相同，可以省略
        -->
        <id property="id" column="id"/>
        <result property="userName" column="user_name"/>
        <result property="birthday" column="birthday"/>
        <result property="sex" column="sex"/>
        <result property="homeAddress" column="home_address"/>
    </resultMap>

在这里插入图片描述

where 与 if 标签

    <!--
    where:
        1. where标签就相当于SQL语句中where关键字
        2. 去掉多余的and、or关键字
    if:
        判断条件是否为真，如果为真则将if中字符串拼接到SQL语句中
    -->    
	<select id="selectByUserNameAndSex" resultMap="userResultMap">
        select * from t_user
        <where>
            <if test="userName!=null and userName!=''">
                user_name=#{userName}
            </if>
            <if test="sex!=null and sex!=''">
              and  sex=#{sex}
            </if>
        </where>
    </select>

set 标签

    <!--
    set
        1.一般与if标签配合使用
        2.set用在update语句中，相当于set关键字
        3.会自动去掉能多余的逗号
    -->
    <update id="updateByIdSelective">
        update t_user
        <set>
            <if test="userName!=null">
                user_name = #{userName},
            </if>
            <if test="birthday!=null">
                birthday = #{birthday},
            </if>
            <if test="sex!=null">
                sex = #{sex},
            </if>
            <if test="homeAddress!=null">
                home_address = #{homeAddress},
            </if>
        </set>
        where id=#{id}
    </update>

foreach 标签

    <insert id="insertRecords">
        insert into t_user values
        <foreach collection="users" item="user"  separator=",">
            (#{user.id}, #{user.userName}, #{user.birthday}, #{user.sex}, #{user.homeAddress})
        </foreach>
    </insert>
    <delete id="deleteByIdS">
        delete from t_user where id in
        <!--
           open     遍历开始前添加的符号
           close    遍历完成后添加的符号
        -->
        <foreach collection="ids" item="id" separator="," open="(" close=")">
            #{id}
        </foreach>
    </delete>

在这里插入图片描述

sql/include标签

  1. sql标签：定义一段可以重用的SQL语句
  2. include标签：refid 关联sql标签的id
    <!--定义可重用的代码块-->
    <sql id="conditionSql">
        <if test="condition!=null and condition!=''">
            where user_name like concat('%',#{condition},'%')
            or home_address like concat('%',#{condition},'%')
        </if>
    </sql>
    <!--根据条件查询-->
    <select id="selectByConditon" resultMap="userResultMap">
        select * from t_user
        <!--引用代码块-->
        <include refid="conditionSql"/>
    </select>
    <!--根据条件统计-->
    <select id="countByConditon" resultType="int">
        select count(1) from t_user
        <!--引用代码块-->
        <include refid="conditionSql"/>
    </select>

结果集复杂映射

当SQL查询的结果集复杂，不能(或不方便)使用一个类结构来接收这些数据，我们就称这种映射是复杂映射。复杂映射一般分为两种:一对一、一对多。

一对一映射通过<assosication>标签实现；一对多映射通过<collection>标签实现。

一对一映射

在这里插入图片描述
在这里插入图片描述

一对多

    <!--
    一对多映射
        1. collection标签，用于表示数据查询中的1对多映射
        2. 此时，resultMap和collection都需要指定所有字段的映射，不能省略(同association)
        3. SQL查询的结果集中不能有重复的字段，如果有重复字段，则映射过程中只有第一个字段可以取到正确的值，所以需要给名称重复的字段使用别名。(同association)
    -->
    <resultMap id="userAndOrderResultMap" type="User">
        <id property="id" column="id"/>
        <result property="username" column="username"/>
        <result property="birthday" column="birthday"/>
        <result property="sex" column="sex"/>
        <result property="address" column="address"/>
        <!--
        collection  映射成一个集合
            porperty 类属的属性名
            ofType  集合内元素的类型
        -->
        <collection property="orders" ofType="Order" >
            <id property="id" column="o_id"/>
            <result property="userId" column="o_user_id"/>
            <result property="goods" column="o_goods"/>
            <result property="createTime" column="o_create_time"/>
            <result property="note" column="o_note"/>
        </collection>
    </resultMap>
    <select id="selectUserAndOrderById" resultMap="userAndOrderResultMap">
        SELECT tu.*,
        tor.id o_id,
        tor.user_id o_user_id,
        tor.goods o_goods,
        tor.create_time o_create_time,
        tor.note o_note
        FROM t_user tu join t_order tor on tu.id=tor.user_id
        where tu.id=#{id}
    </select>

在这里插入图片描述

级联(嵌套)查询

在这里插入图片描述

public interface UserMapper{
	 /**
     * 查询所有用户基本信息、拓展细信、订单
     *
     * @return
     */
    List<User> selectAllUserAndInfoAndOrder();
}

    <!--用户详细信映射-->
    <resultMap id="userDetailResultMap" type="User">
        <id property="id" column="id"/>
        <result property="username" column="username"/>
        <result property="birthday" column="birthday"/>
        <result property="sex" column="sex"/>
        <result property="address" column="address"/>
        <!--
        association和collection都可以通过column属性和select属性配合完成级联查询操作
            select  子查询，一个select标签的id
            column  指定参数传递
        -->
        <association property="userInfo" column="id" select="selectUserInfoByUserId"/>
        <collection property="orders"   column="id"  select="selectOrderByUserId"/>
    </resultMap>
    <!--用户拓展信息映射-->
    <resultMap id="userInfoResultMap" type="UserInfo">
        <result property="userId" column="user_id"/>
    </resultMap>
    <!--订单信息映射-->
    <resultMap id="orderResultMap" type="Order">
        <result property="userId" column="user_id"/>
        <result property="createTime" column="create_time"/>
    </resultMap>

    <!--查询用户信息-->
    <select id="selectAllUserAndInfoAndOrder" resultMap="userDetailResultMap">
        select * from t_user
    </select>
    <!--查询用户拓展信-->
    <select id="selectUserInfoByUserId" resultMap="userInfoResultMap">
        select * from t_user_info where user_id=#{userId}
    </select>
    <!--查询订单信-->
    <select id="selectOrderByUserId" resultMap="orderResultMap">
        select * from t_order where user_id=#{userId}
    </select>

在这里插入图片描述

自动映射

当自动映射查询结果时，MyBatis 会获取结果（sql查询结果集）中返回的列名并在 Java 类中查找相同名字的属性（忽略大小写）。 这意味着如果发现了 ID 列和 id 属性，MyBatis 会将列 ID 的值赋给 id 属性。

通常数据库列使用大写字母组成的单词命名，单词间用下划线分隔；而 Java 属性一般遵循驼峰命名法约定。
在这里插入图片描述

注解开发

在这里插入图片描述

增删改查注解

@Select(“查询语句”)查询；
@Update(“更新语句”)更新；
@Delete(“删除语句”)删除；
@Insert(“插入语句”)插入；
@SelectKey()

public interface UserMapper {

    @Select(value = "select * from t_user where username like concat('%',#{username},'%')")
    List<User> selectByLike(String username);

    /**
     * 分页查询
     * @param startIndex
     * @param pageSize
     * @return
     */
    @Select(value = "select * from t_user limit #{param1}, #{param2}")
    List<User> selectByPage1(Integer startIndex, Integer pageSize);

    /**
     * 分页查询
     * @param startIndex
     * @param pageSize
     * @return
     */
    @Select(value = "select * from t_user limit #{startIndex}, #{pageSize}")
    List<User> selectByPage2(@Param("startIndex") Integer startIndex, @Param("pageSize") Integer pageSize);

    /**
     * 查询所有
     * @return
     */
    @Select(value = "select * from t_user")
    List<User> selectAll();
    /**
     * 通过id查询用户基础信息
     */
    @Select(value="select * from t_user where id = #{id}")
    User selectById(@Param("id") Integer id);

    /**
     * 更新用户信息基础信息
     * @param user
     * @return
     */
    @Update(value=" update t_user set username=#{username}, birthday=#{birthday}, sex=#{sex}, address=#{address} where id=#{id}")
    int update(User user);
    /**
     * 更新用户信息基础信息
     * @param id
     * @return
     */
    @Delete(value=" delete from  t_user where id=#{id}")
    int deleteById(@Param("id") Integer id);

    /**
     * 插入
     * @param user
     * @return
     */
    @Insert("insert into t_user(username,birthday,sex,address) values (#{username},#{birthday},#{sex},#{address})")
    @SelectKey(resultType = Integer.class,keyProperty ="id",before = false,statement = "select LAST_INSERT_ID()")
    int insert(User user);
}

在这里插入图片描述

结果映射

@Results：
@Result
在这里插入图片描述

@Results：
含义：封装映射关系的父注解。
属性
value: 定义了Result 数组
@Result
含义：封装映射关系的子注解。
属性
id: 是否是主键
column：查询出的表中字段名称
property 属性：实体对象中的属性名称
javaType属性：被包含对象的数据类型

一对一级联查询

@One

@Results(value = {
        @Result(id = true, column = "id", property = "id"),
        @Result(column = "user_name", property = "userName"),
        @Result(column = "sex", property = "sex"),
        @Result(column = "birthday", property = "birthday"),
        @Result(column = "home_address", property = "homeAddress"),
        @Result(
                property = "userInfo",
                column = "id",
                one = @One(select = "com.itheima.dao.UserInfoMapper.selectUserInfoByUserId"))   
})
@Select(value="select * from t_user where id = #{id}")
User selectById(@Param("id") Integer id);

public interface UserInfoMapper {

    @Select("select * from t_user_info where user_id = #{user_id}")
    UserInfo selectUserInfoByUserId(Integer userId);
}

@Results : 映射结果集
@Result: 映射某一列
@One： 一对一映射

一对多级联查询

@Many： 一对多映射

@Results(value = {
        @Result(id = true, column = "id", property = "id"),
        @Result(column = "user_name", property = "userName"),
        @Result(column = "sex", property = "sex"),
        @Result(column = "birthday", property = "birthday"),
        @Result(column = "home_address", property = "homeAddress"),
        @Result(
                property = "userInfo",
                column = "id",
                one = @One(select = "com.itheima.dao.UserInfoMapper.selectUserInfoByUserId")),
        @Result(
                property = "orders",
                column = "id",
                many = @Many(select = "com.itheima.dao.OrderMapper.selectOrderListByUserId"))
})
@Select(value="select * from t_user where id = #{id}")
User selectById(@Param("id") Integer id);

public interface UserInfoMapper {

    @Select("select * from t_user_info where user_id = #{user_id}")
    UserInfo selectUserInfoByUserId(Integer userId);
}

@Results : 映射结果集
@Result: 映射某一列
@Many： 一对多映射

原理

一级,二级缓存

MyBatis的缓存
@Transactional注解和Mybatis缓存问题
mybatis springboot 开启缓存

mybatis缓存分为 一级缓存和二级缓存
注：
缓存只针对于DQL语句，也就是说缓存机制只对应select语句。
在springboot中,使用了数据库连接池,默认每次查询后自动提交(commite),导致两次查询 不是一个sqlSession,根据一级缓存原理,它不会生效
缓存优先级: 二级>一级>数据库

1. ⼀级缓存：一级缓存的范围是SqlSession！

①⼀级缓存默认是开启的，不需要做任何配置。
②原理：只要使⽤同⼀个SqlSession对象执⾏同⼀条SQL语句，就会⾛缓存。

2. ⼆级缓存： ⼆级缓存的范围是SqlSessionFactory对象！

使⽤⼆级缓存需要具备以下⼏个条件：

① 全局性地开启或关闭所有映射器配置⽂件中已配置的任何缓存。默认就是true，⽆需设置（默认>二级缓存就是开启的）！
②在需要使⽤⼆级缓存的SqlMapper.xml⽂件中添加一个标签：
③使⽤⼆级缓存的实体类对象必须是可序列化的，也就是必须实现java.io.Serializable接⼝
④SqlSession对象关闭或提交之后，⼀级缓存中的数据才会被写⼊到⼆级缓存当中；此时⼆级缓存才可⽤。

3.MyBatis集成第三方缓存EhCache（了解）

集成EhCache是为了代替MyBatis⾃带的⼆级缓存，⼀级缓存是⽆法替代的！

懒加载

Mybatis懒加载

mybatisPlus

国内研发,在 MyBatis 的基础上只做增强不做改变
官网

依赖

    <!--SpringBoot-->
    <dependency>
        <groupId>com.baomidou</groupId>
        <!--下面坐标根据自己使用的SpringBoot版本二选一-->
        <!--SpringBoot2使用此版本-->
        <artifactId>mybatis-plus-boot-starter</artifactId>
        <!--3.5.4开始,支持SpringBoot3使用此版本-->
        <artifactId>mybatis-plus-spring-boot3-starter</artifactId>
        <version>最新版本</version>
    </dependency>

配置

配置文件

mybatis-plus:

  mapper-locations: classpath:net/cnki/editor/expense/dao/impl/*.xml
  #类型：String[]
  #默认值：["classpath*:/mapper/**/*.xml"] 
  #MyBatis Mapper 所对应的 XML 文件位置，如果您在 Mapper 中有自定义方法(XML 中有自定义实现)，需要进行该配置，告诉 Mapper 所对应的 XML 文件位置,Maven 多模块项目的扫描路径需以 classpath*: 开头 （即加载多个 jar 包下的 XML 文件）
  
  type-aliases-package: net.cnki.editor.expense.dos
  #类型：String
  #默认值：null
  #MyBaits 别名包扫描路径，通过该属性可以给包中的类注册别名，注册后在 Mapper 对应的 XML 文件中可以直接使用类名，而不用使用全限定的类名(即 XML 中调用的时候不用包含包名)
  
  configuration.map-underscore-to-camel-case: true
   #类型：boolean
   #默认值：true
   #是否开启自动驼峰命名规则（camel case）映射，即从经典数据库列名 A_COLUMN（下划线命名） 到经典 Java 属性名 aColumn（驼峰命名） 的类似映射。
  
  global-config.db-config.id-type: assign_id
    # 类型：com.baomidou.mybatisplus.annotation.IdType
    #默认值：ASSIGN_ID
    #全局默认主键类型

注解

官网注解

@MapperScan

在 Spring Boot 启动类中添加 @MapperScan 注解，扫描 Mapper 文件夹：
每天一个注解之@MapperScan

@SpringBootApplication
@MapperScan("com.baomidou.mybatisplus.samples.quickstart.mapper")
public class Application {

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }

}

@TableName

描述：表名注解，标识实体类对应的表
使用位置：实体类

@TableId

描述：主键注解
使用位置：实体类主键字段

@TableField(opens new window)

描述：字段注解（非主键）

使用

springboot整合

1.添加依赖
2.添加配置文件
3.添加启动类扫描

@Mapper、@MapperScan详解

@SpringBootApplication
@MapperScan("com.winter.dao")
public class SpringbootMybatisDemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(SpringbootMybatisDemoApplication.class, args);
    }
}
4.添加实体类
@TableName("tb_user")
@Data
public class User {
    //设置id生成策略:AUTO 数据库自增
    @TableId(type = IdType.AUTO)
    private Long id;
    //@TableField("user_name")
    private String userName;

    private String password;
    private String name;
    private Integer age;
    private String email;
    //不希望该值存入数据库
   // @TableField(exist = false)
   // private String info;

}
5.创建mapper(可通过插件生成)
/**
 * 使用mp定义Mapper，需要让Mapper接口继承 BaseMapper接口。
 */

public interface UserMapper extends BaseMapper<User> {
}
6.创建service

public interface _UserService extends IService<User> {
}

@Service
public class _UserServiceImpl extends ServiceImpl<UserMapper, User> implements _UserService {}
7.分页查询,添加分页拦截器
@Configuration
public class PageConfig {

    /**
     * 3.4.0之前的版本用这个
     * @return
     */
   /* @Bean
    public PaginationInterceptor paginationInterceptor(){
        return  new PaginationInterceptor();
    }*/

    /**
     * 3.4.0之后提供的拦截器的配置方式
     * @return
     */
   @Bean
   public MybatisPlusInterceptor mybatisPlusInterceptor(){
       MybatisPlusInterceptor mybatisPlusInterceptor = new MybatisPlusInterceptor();
       mybatisPlusInterceptor.addInnerInterceptor(new PaginationInnerInterceptor());
       return mybatisPlusInterceptor;
   }
}

/**
     * 分页查询：
     *  1. 当前页码：currentPage
     *  2. 每页显示条数：size
     *
     *  注意：使用mp的分页要设置一个拦截器！！！
            */
    @Test
    public void testSelectPage() {
        int current = 1;//当前页码
        int size = 2;//每页显示条数
        IPage<User> page = new Page(current,size);
        userMapper.selectPage(page,null);

        List<User> records = page.getRecords();//当前页的数据
        long pages = page.getPages();//总页数 2
        long total = page.getTotal();//总记录数 4
        System.out.println(records);
        System.out.println(pages);
        System.out.println(total);
    }
8.条件构造器
基础比较查询
Wrapper()包装器://条件构建器
 1.QueryWrapper
     LambdaQueryWrapper
 2.UpdateWrapper
     LambdaUpdateWrapper

方法:
eq( ) :  等于 =
ne( ) :  不等于 <>
gt( ) :  大于 >
ge( ) :  大于等于  >=
lt( ) :  小于 <
le( ) :  小于等于 <=
between ( ) :  BETWEEN 值1 AND 值2 
notBetween ( ) :  NOT BETWEEN 值1 AND 值2 
in( ) :  in
notIn( ) ：not in

逻辑查询
or( ) ：让紧接着下一个方法用or连接 

模糊查询
like 查询关键字前后都加%
notLike
likeLeft
likeRight

排序查询
orderBy
orderByAsc通过某个条件正排
orderByDesc反排

select：指定需要查询的字段

@Test
    public void testWrapper2(){
        //1.创建查询条件构建器
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        //2.设置条件
        wrapper.eq("user_name","lisi")
                .or()
                .lt("age",23)
                .in("name","李四","王五");
        /*
            select * from tb_user where user_name = ? or age < ? and name in (?,?)
         */
        List<User> users = userMapper.selectList(wrapper);
        System.out.println(users);
    }

LambdaQueryWrapper：消除代码中的硬编码

@Test
    public void testWrapper7(){
        LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(User::getUserName,"zhangsan");
        userMapper.selectOne(wrapper);
    }

LambdaQueryWrapper原理

代码生成工具,IDE插件

在这里插入图片描述

我不是彭于晏灬
关注
  • 3
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
mybatis和mybatis-plus
qq_45866940的博客
09-03 1006
mybatis完整请求流程 mybatis和mybatis-plus mybatis 持久层框架,支持自定义sql查询,存储过程和高级映射, 几乎消除了JDBC代码和手动设置以及结果集的检索 JDBC编程问题 数据库建立连接创建,释放频繁造成资源浪费 SQL写在java代码中,维护难 使用preparedStatement向占位符传参数存在硬编码,SQL语句where条件中占位符个数可能改变,修改SQL还需修改Java代码,系统维护难 对结果集解析存在硬编码,SQL语句变化导致解析代码变化,维护难 m
【MyBatis】 MyBatis与MyBatis-Plus的区别
四季轮换叶，一路招摇胜
09-12 5万+
mybatis-plus 是 mybatis 的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。
MyBatis Plus 和 MyBatis 的区别？选哪一个框架更好？
最新发布
m0_61604045的博客
06-03 1182
MyBatis Plus 和 MyBatis 的区别？选哪一个框架更好？
Mybatis和Mybatis plus
qq_37902466的博客
09-15 3987
如果项目只需进行简单的增删改查操作，追求快速开发和高效率，并且不强调对底层SQL的细节控制，可以选择MyBatis Plus。在这个示例中，通过继承MyBatis Plus提供的IService接口和ServiceImpl类，Service层可以直接使用MyBatis Plus提供的方法来完成单表数据的增删改查操作。在MyBatis Plus中，通过Service层继承Service类和Mapper层继承BaseMapper接口，都可以实现单表数据的增删改查操作。三、MyBatis Plus使用示例。
Mybatis和Mybatisplus
m0_71409306的博客
07-28 2786
Mybatis和Mybatisplus
Mybatis-Plus详解
热门推荐
互联网底层民工的博客
07-15 6万+
Mybatis-Plus是一个Mybatis（opens new window）的增强工具，在Mybatis的基础上只做增强不做改变，为简化开发。无侵入：只做增强不做改变，引入它不会对现有工程产生影响。 损耗小：启动即会自动注入基本CURD，性能基本无损耗，直接面向对象操作。 强大的CRUD操作：内置通用Mapper、通用Service，仅仅通过少量配置即可实现单表大部分CRUD操作，更有强大的条件构造器，满足各类使用需求。支持Lambda形式调用：通过 Lambda 表达式，方便的编写各类查询条件，无需
Mybatis-plus和Mybatis的区别和详情讲解（附代码详解）
m0_46741750的博客
01-25 1万+
文章目录1.简介2.Mybatis2.1Mapper层2.2Service层2.3Controller层3.Mybatis-plus3.1为什么使用mybatis-plus？3.2如何使用它Mybatis-plus？3.3如何实现一些特殊的sql语句呢？4.总结 1.简介 首先，在介绍Mybatis-plus之前呢，明怀我想给大家介绍一下Mybatis，其实mp(mybatis-plus)是对mybatis的一个增强，我更推荐大家在使用的时候可以结合着Mybatis和mp一起使用 2.Mybatis 2.
springmvc4+mybatis+mybatisplus整合
03-18
在IT行业中，SpringMVC、MyBatis以及MyBatisPlus是常见的Java Web开发框架，它们各自在不同的层面上提供强大的功能。SpringMVC作为Spring框架的一部分，专注于处理Web应用程序的请求和响应；MyBatis则是一个轻量级的...
Springboot+MyBatis+MyBatisPlus+MySQL+Bootstrap增删改查登录分页源码+数据库
09-18
MyBatis与MyBatisPlus共同处理数据库交互，MyBatis提供基本的SQL映射，MyBatisPlus则提供更便捷的CRUD操作。MySQL作为数据库，存储所有业务数据。Bootstrap用于前端界面的设计，提供美观的UI元素和响应式布局。用户...
springboot2+mybatis+mybatisplus+jwt+mpvue供货商城系统
04-28
供货商城系统，springboot2+mybatis+mybatisplus+jwt+mpvue,本系统是一个完整的商城系统，包括小程序+API+管理理后台，非常适合学习或者二次开发使用，也可以直接使用，商城功能：商品多规格、文章管理、购物车、...
Springboot+MyBatis+MyBatisPlus+MySQL+Bootstrap增删改查登录分页
09-18
在本教程中，我们将探讨如何使用Spring Boot、MyBatis、MyBatisPlus、MySQL和Bootstrap来构建一个完整的Web应用，包括用户登录功能和用户管理模块，实现增删改查及分页显示。以下是各个技术组件在项目中的作用和实现...
浅析Mybatis Plus和Mybatis的区别
09-07
主要介绍了Mybatis Plus和Mybatis的区别,需要的朋友可以参考下
最强大的数据库框架，秒杀mybatis、mybatisplus、hibernate
01-25
本篇文章将深入探讨“最强大的数据库框架”，并对比分析Mybatis、MybatisPlus和Hibernate这三大主流框架，以及提及的esdk-master项目。 首先，让我们来看看Mybatis。Mybatis是一个轻量级的Java持久层框架，它允许...
认识MyBatis与Mybatis-plus及两者的区别
m0_67402970的博客
04-29 6898
一、认识Mybatis MyBatis 是持久层框架，它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。MyBatis 可以使用简单的 XML 或注解来配置和映射原生信息，将接口和 Java 的 POJOs(Plain Ordinary Java Object,普通的 Java对象)映射成数据库中的记录。 1、功能架构 Mybatis的功能架构分为三层： (1)API接口层：提供给外部使用的接口API，开发人员通过这些本地API来操纵
MyBatis和MyBatis Plus比较详解
a342874650的专栏
03-21 2566
本文旨在探讨在SpringBoot框架下，MyBatis与MyBatis Plus这两个持久层框架之间的差异、各自的优缺点以及适用场景。通过对比分析，帮助开发者更好地理解和选择适合自己项目的持久层解决方案。
MyBatis与MyBatis-plus的区别
郝南过的博客
11-14 1171
Mybatis Plus的宗旨是简化开发，但是它在提供方便的同时却容易造成代码层次混乱，我们可能会把大量数据逻辑写到service层甚至contoller层中，使代码难以阅读。凡事过犹不及，在使用Mybatis Plus时一定要做分析，不要将所有数据操作都交给Mybatis Plus去实现。毕竟Mybatis Plus只是Mybatis的增强工具，它并没有侵入Mybatis的原生功能，在使用Mybatis Plus的增强功能的同时，原生Mybatis的功能依然是可以正常使用的。
MyBatis教程[8]----使用MyBatis-Plus简化开发
yky的博客
04-07 872
前面用了7篇博客，讲完了mybatis。掌握了前面7篇博客的内容，便可以自如应对spring下的mybatis开发了。 然而，很多时候Mybatis的表现并不是那么完美，比如很多简单的CURD语句还需要开发者手动完成；不支持分页功能，需要开发者写代码实现分页逻辑等等。。。。 这时候，就不得不提MyBatis-Plus了，MyBatis-Plus正是为简化Mybatis的开发而诞生的。 1. MyB...
MyBatis与MyBatis-Plus的区别？
jakelihua
06-14 1万+
MyBatis的编程风格更加传统，需要定义mapper.xml文件并根据传入的参数使用相应的SQL查询语句，需要实现 Mybatis 提供的各种方法；而MyBatis-Plus是在MyBatis框架上的封装，通过对于增强简化后的API更加方便地进行开发，并且在性能、效率和易用性上都有一定的优化。MyBatis-Plus相比于MyBatis提供了很多额外的功能，例如像条件构造器、代码生成器、分页插件、性能分析拦截器等实用的组件，使得开发者可以轻松快速完成业务逻辑的开发。
mybatis、mybatisPlus
m0_46391590的博客
05-24 1178
MyBatis是一款优秀的基于java的持久层框架，它内部封装了jdbc，使开发者只需要关注sql语句本身，而不需要花费精力去处理加载驱动、创建连接、创建statement等繁杂的过程。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值