MyBatis入门知识点总结

最新推荐文章于 2024-04-07 13:16:02 发布
最新推荐文章于 2024-04-07 13:16:02 发布
阅读量1.2k 收藏 3
点赞数
分类专栏： 入门知识总结 文章标签： mybatis java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42266293/article/details/119408322
版权

Mybatis入门

文章目录

相关概念介绍

SSM = springmvc + spring + mybatis 组合框架的一员，是一种持久层框架

持久层主要是完成与数据库的相关操作，数据库访问对象(Data Access Object)，所以也称为DAO层

框架是一个半成品的软件，需要我们遵守对应的规范去完成开发工作

框架类型框架作用典型代表
持久性框架专注于解决数据持久化的框架mybatis、hibernate、spring jdbc
表现层框架专注于解决与用户交互的框架struts2、spring mvc
全栈框架能在各层都给出解决方案的框架spring

原始jdbc存在的问题

  1. 频繁创建数据库连接、释放资源，影响系统性能
  2. sql写在java文件中(俗称硬编码，因为每次修改都要重新编译代码)，不宜于维护
  3. 查询操作，需要将结果集手动封装到实体中

解决方案

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

mybatis简介

MyBatis是一个优秀的基于ORM的半自动轻量级持久层框架，让开发者们只关注于SQL本身，而不需要花费精力去处理例如注册驱动、创建connection、创建statement、手动设置参数、结果集检索等jdbc繁杂的过程代码

ORM思想：Object Relational Mapping 对象关系映射

基本应用

  1. 创建数据库及表
  2. 创建工程，导入依赖
		<!--mybatis坐标-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.4</version>
        </dependency>

        <!--mysql驱动坐标-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.41</version>
            <scope>runtime</scope>
        </dependency>
        
        <!--单元测试坐标-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>

        <!-- 分页助手 -->
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper</artifactId>
            <version>3.7.5</version>
        </dependency>
        <dependency>
            <groupId>com.github.jsqlparser</groupId>
            <artifactId>jsqlparser</artifactId>
            <version>0.9.1</version>
        </dependency>
  1. 编写实体类
  2. 编写对象配置文件 xxxMapper.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="">

</mapper>
  1. 编写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>

    <settings>
        <setting name="lazyLoadTriggerMethods" value="toString()"/>
    </settings>
    <!--批量取别名-->
    <typeAliases>
        <package name="com.hezhe.pojo"/>
    </typeAliases>


    <!--environments: 运行环境-->
    <environments default="development">
        <environment id="development">
            <!--当前的事务事务管理器是JDBC-->
            <transactionManager type="JDBC"></transactionManager>
            <!--数据源信息 POOLED：使用mybatis的连接池-->
            <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 resource="com/hezhe/mapper/UserMapper.xml"></mapper>-->
        <!--批量加载映射-->
        <package name="com.hezhe.mapper"/>
    </mappers>

</configuration>
  1. 编写测试代码

基础的增\删\改\查应用

使用sqlSession会话对象去调selectList | insert | update | detele

查询的参数为（namespace.id），其他均为（namespace.id，param）

对于修改数据库的操作均需要调用sqlSession.commit()

核心配置文件概述

  1. Mybatis核心文件是有强制的层次关系
<!--顶层-->
<configuration>
    <!--子层需要顺序编写-->
	<properties></properties> (属性，常用于配置数据源配置文件)
	<settings></settings> (设置，可设置延迟加载策略)
    <typeAliases></typeAliases> (类型别名)
	<typeHandlers></typeHandlers> (类型处理器)
    <objectFactory></objectFactory> (对象工厂)
    <plugins></plugins> (插件，分页插件)
    <environments> (重点：环境配置)
    	<environment> (环境变量)
        	<transactionManager></transactionManager> (事务管理器)
            <dataSource></dataSource> (数据源)
        </environment>
    </environments>
    <databaseIdProvider></databaseIdProvider> (数据库厂商标识)
    <mappers></mappers> (映射器)
</configuration>
  1. enviroments标签
<!--environments: 运行环境-->
<environments default="development">
  <environment id="development">
     <!--当前的事务事务管理器是JDBC-->
     <transactionManager type="JDBC"></transactionManager>
     <!--数据源信息 POOLED：使用mybatis的连接池-->
     <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>

<!-- 

1. 其中，事务管理器（transactionManager）类型有两种：
	- JDBC：     
	这个配置就是直接使用了JDBC 的提交和回滚设置，它依赖于从数据源得到的连接来管理事务作用域。

	- MANAGED：     
	这个配置几乎没做什么。它从来不提交或回滚一个连接，而是让容器来管理事务的整个生命周期。     
	例如：		mybatis与spring整合后，事务交给spring容器管理。

2. 其中，数据源（dataSource）常用类型有三种：
	- UNPOOLED：
	这个数据源的实现只是每次被请求时打开和关闭连接。

	- POOLED：
	这种数据源的实现利用“池”的概念将 JDBC 连接对象组织起来。

	- JNDI :
	这个数据源实现是为了能在如 EJB 或应用服务器这类容器中使用，容器可以集中或在外部配置数据源，然后放置一个 JNDI 上下文的数据源引用

-->
  1. properties标签
<!--加载外部的properties文件-->
<properties resource="jdbc.properties"></properties>

<dataSource type="POOLED">
    <!--在此使用-->
	<property name="driver" value="${jdbc.driver}"></property>
</dataSource>
  1. typeAliases标签，用于取别名，方便配置
  2. mappers标签，用于加载映射
<!--1. 使用相对于类路径的资源引用，例如：-->
<mapper resource="org/mybatis/builder/userMapper.xml"/>
<!--2. 使用完全限定资源定位符（URL），例如：-->
<mapper url="file:///var/mappers/userMapper.xml"/>  

《下面两种mapper代理开发中使用:暂时了解》
<!--3. 使用映射器接口实现类的完全限定类名，例如： -->
<mapper class="org.mybatis.builder.userMapper"/>
<!--4. 将包内的映射器接口实现全部注册为映射器，例如： -->
<package name="org.mybatis.builder"/>

Mybatis常用API

  1. Resources工具类帮助加载核心配置文件

  2. SqlSessionFactoryBuilder.bulid(); 构建工厂对象

  3. sqlSessionFactory.openSession([boolean autoCommit]); 获取sqlSession会话对象

  4. sqlSession.增\删\改\查\commit\rollback

Mybatis代理开发方式

需要遵循的规范

  1. Mapper.xml映射文件中的namespace与mapper接口的全限定名相同
  2. Mapper接口方法名和Mapper.xml映射文件中定义的每个statement的id相同
  3. Mapper接口方法的输入参数类型和mapper.xml映射文件中定义的每个sql的parameterType的类型相同
  4. Mapper接口方法的输出参数类型和mapper.xml映射文件中定义的每个sql的resultType的类型相同

这样就可以调用 sqlSession.getMapper(xxxMapper.class) 来获取Mapper代理对象，使用接口中的方法

高级查询

ResultMap

<!--实现手动映射封装            
		resultMap                
			id="userResultMap" 此标签唯一标识                
			type="user" 封装后的实体类型           
		<id column="uid" property="id"></id> 表中主键字段封装                
			column="uid" 表中的字段名                
			property="id" user实体的属性名           
		<result column="NAME" property="username"></result> 表中普通字段封装                			column="NAME" 表中的字段名                
			property="username" user实体的属性名                
		补充：如果有查询结果有 字段与属性是对应的，可以省略手动封装 【了解】    
-->
	<resultMap id="articleWithCommentMap" type="article">
        <id column="id" property="id"/>
        <result column="title" property="title"/>
        <result column="content" property="content"/>
    </resultMap>

多条件查询

方式一：使用 #{arg0}-#{argn} 或者 #{param1}-#{paramn} 获取接口请求参数

方式二：使用注解，接口中引入@Param(“name”)注解，再在配置文件中 #{name}获取参数

方式三：使用pojo对象传递参数，配置文件中按照实体类的属性获取参数

模糊查询

<!--
	List<User> list = userMapper.findByUsername1/2("%王%");
-->

<!--方式1-->
<select id="findByUsername1" parameterType="string" resultType="user">       
    select * from user where username like #{username}    
</select> 

<!--方式2-->
<!--不推荐使用，因为会出现sql注入问题-->    
<select id="findByUsername2" parameterType="string" resultType="user">       
    select * from user where username like '${value}'    
</select>

${}与#{}的区别

#{}:表示一个占位符号
  1. 通过#{}可以实现preparedStatement向占位符中设置值，自动进行java类型和jdbc类型转换，#{}可以有效防止sql注入。
  2. #{}可以接收简单类型值或pojo属性值。
  3. 如果parameterType传输单个简单类型值，#{}括号中名称随便写。
${}:表示拼接sql串

  1. 通过${}可以将parameterType 传入的内容拼接在sql中且不进行jdbc类型转换，会出现sql注入问题。

  2. ${}可以接收简单类型值或pojo属性值。

  3. 如果parameterType传输单个简单类型值，${}括号中只能是value。

    – (补充：TextSqlNode.java 源码可以证明 )

映射文件深入

返回主键

<!--
	public void save(User user);
-->

<!--方式1：useGeneratedKeys--> 
<!--        
	useGeneratedKeys="true" 声明返回主键        
	keyProperty="id" 把返回主键的值，封装到实体的id属性中 

	注意：只适用于主键自增的数据库，mysql和sqlserver支持，oracle不支持 
-->
<insert id="save" parameterType="user" useGeneratedKeys="true" keyProperty="id">   
    INSERT INTO `user`(username,birthday,sex,address)    
    	values(#{username},#{birthday},#{sex},#{address})
</insert>


<!--方式2：selectKey-->
<!--        
	selectKey 适用范围广，支持所有类型数据库            
	keyColumn="id" 指定主键列名            
	keyProperty="id" 指定主键封装到实体的id属性中            
	resultType="int" 指定主键类型            
	order="AFTER"   设置在sql语句执行前（后），执行此语句
-->
<insert id="save" parameterType="user">    
    <selectKey keyColumn="id" keyProperty="id" resultType="int" order="AFTER">       	
        SELECT LAST_INSERT_ID();    
    </selectKey>   
    INSERT INTO `user`(username,birthday,sex,address)    
    values(#{username},#{birthday},#{sex},#{address})
</insert>

动态SQL

  1. where + if test=“表达式”
  2. set + if test=“表达式”
  3. foreach ~
    • collection：代表要遍历的集合元素
    • open：代表语句的开始部分
    • close：代表结束部分
    • item：代表遍历集合的每个元素，生成的变量名
    • sperator：代表分隔符
    • 如果查询条件为普通类型 List集合，collection属性值为：collection 或者 list
    • 如果查询条件为普通类型 Array数组，collection属性值为：array

SQL片段

介绍：映射文件中可将重复的 sql 提取出来，使用时用 include 引用即可，最终达到 sql 重用的目的

<!--抽取的sql片段-->
<sql id="selectUser">   
    SELECT * FROM `user`
</sql>

<select id="findByList" parameterType="list" resultType="user" >    
    <!--引入sql片段-->    
    <include refid="selectUser"></include>    
    <where>        
        <foreach collection="collection" open="id in(" close=")" item="id" separator=",">           #{id}        
        </foreach>    
    </where>
</select>

Mybatis核心配置文件深入

plugins标签：引入第三方插件

分页助手PageHelper的使用
  1. 导入通用PageHelper的坐标
<!-- 分页助手 -->
<dependency>    
    <groupId>com.github.pagehelper</groupId>    
    <artifactId>pagehelper</artifactId>    
    <version>3.7.5</version>
</dependency>
<dependency>    
    <groupId>com.github.jsqlparser</groupId>    
    <artifactId>jsqlparser</artifactId>    
    <version>0.9.1</version>
</dependency>
  1. 在mybatis核心配置文件中配置PageHelper插件
<!-- 分页助手的插件   -->
<plugin interceptor="com.github.pagehelper.PageHelper">    
    <!-- 指定方言 -->    
    <property name="dialect" value="mysql"/>
</plugin>
  1. 使用分页功能，调用API
@Test
public void testPageHelper(){    
    //设置分页参数    
    PageHelper.startPage(1,2);    
    List<User> select = userMapper2.select(null);    
    for(User user : select){        
        System.out.println(user);   
    }
}

//其他分页的数据
PageInfo<User> pageInfo = new PageInfo<User>(select);
System.out.println("总条数："+pageInfo.getTotal());
System.out.println("总页数："+pageInfo.getPages());
System.out.println("当前页："+pageInfo.getPageNum());
System.out.println("每页显示长度："+pageInfo.getPageSize());
System.out.println("是否第一页："+pageInfo.isIsFirstPage());
System.out.println("是否最后一页："+pageInfo.isIsLastPage());

多表查询

数据库的表及实体类的关系需要对应起来

一对一：子表要有对应的外键，主实体要关联对象的属性，并提供get/set方法

一对多：子表要有对应的外键，主实体要关联对象的集合，并提供get/set方法

多对多：要有关联表提供对应的外键，主实体要关联对象的集合，并提供get/set方法

具体实现：

  • 多对一（一对一）配置：使用+做配置
  • 一对多配置：使用+做配置
  • 多对多配置：使用+做配置
  • 多对多的配置跟一对多很相似，难度在于SQL语句的编写。

嵌套查询：将联合查询分解成几个sql语句

一对一配置：使用+做配置，通过column条件，执行select

查询一对多配置：使用+做配置，通过column条件，执行select

查询多对多配置：使用+做配置，通过column条件，执行select

查询优点：简化多表查询操作

缺点：执行多次sql语句，浪费数据库性能

延迟加载(懒加载)

优点：先从单表查询，需要时再从关联表去关联查询，大大提高数据库性能，因为查询单表要比关联查询多张表速度要快。

缺点：因为只有当需要用到数据时，才会进行数据库查询，这样在大批量数据查询时，因为查询工作也要消耗时间，所以可能造成用户等待时间变长，造成用户体验下降。

注意点：

1. **延迟加载是基于嵌套查询来实现的**
2. **局部配置高于全局配置**
具体实现：

​ 局部配置fetchType属性

​ 全局配置核心配置文件

<settings>    
    <!--开启全局延迟加载功能-->        
    <setting name="lazyLoadingEnabled" value="true"/>
</settings>

核心配置文件中设置延迟加载策略

<settings>    
    <!--所有方法都会延迟加载,针对equals\clone\hashCode\toString-->
    <setting name="lazyLoadTriggerMethods" value="toString()"/>
</settings>

Mybatis缓存

缓存的作用：经常查询一些不经常发生变化的数据，使用缓存来提高查询效率。

一级缓存：sqlSession级别的缓存

  1. 默认开启的
  2. 所以在参数和SQL完全一样的情况下，我们使用同一个SqlSession对象调用一个Mapper方法
  3. 执行SqlSession的CUD操作，或者调用clearCache()、commit()、close()方法，都会清空缓存
  4. 可设置< select flushCache=“true”>来默认查询时清楚缓存

二级缓存：namespace级别的缓存

  1. 二级缓存的开启需要进行配置
<!--核心配置文件-->
<settings>    
    <!-- 因为cacheEnabled的取值默认就为true，所以这一步可以省略不配置。 
		为true代表开启二级缓存；为false代表不开启二级缓存。    -->    
    <setting name="cacheEnabled" value="true"/>
</settings>

<!--对象映射文件-->
<mapper namespace="com.hezhe.dao.UserMapper">    
    <!--当前映射文件开启二级缓存-->    
    <cache></cache>    
    <!-- 
		<select>标签中设置useCache=”true”代表当前这个statement要使用二级缓存。 
		如果不使用二级缓存可以设置为false        
		注意：            
			针对每次查询都需要最新的数据sql，要设置成useCache="false"，禁用二级缓存。 
	-->    
    <select id="findById" parameterType="int" resultType="user" useCache="true" >       
        SELECT * FROM `user` where id = #{id}    
    </select>
</mapper>

  1. 多个SqlSession可以共用二级缓存，二级缓存是跨SqlSession的。

  2. 进行多表查询时会产生脏读问题，需要使用第三方的缓存技术解决问题。

  3. mybatis开启了二级缓存后，那么查询顺序：二级缓存–》一级缓存–》数据库

  4. mybatis的缓存，都不需要我们手动存储和获取数据。mybatis自动维护的。

常用注解

  • @Insert：实现新增，代替了insert标签

  • @Delete：实现删除，代替了delete标签

  • @Update：实现更新，代替了update标签

  • @Select：实现查询，代替了select标签

  • @Result：实现结果集封装，代替了result标签

  • @Results：可以与@Result 一起使用，封装多个结果集，代替了resultMap标签

  • @One：实现一对一结果集封装，代替了association标签

  • @Many：实现一对多结果集封装，代替了collection标签

    注解开发和xml配置优劣分析

    1. 注解开发和xml配置相比，从开发效率来说，注解编写更简单，效率更高。

    2. 从可维护性来说，注解如果要修改，必须修改源码，会导致维护成本增加。xml维护性更强。

    增删改查

public interface UserMapper {        
    @Select("SELECT * FROM `user`")    
    public List<User> findAll(); 
    
    @Insert("INSERT INTO `user`(username,birthday,sex,address) VALUES(#{username},#{birthday},#{sex},#{address})")    
    public void save(User user);    
    
    @Update("UPDATE `user` SET username = #{username},birthday = #{birthday},sex = #{sex},address = #{address} WHERE id = #{id}")    
    public void update(User user);    
    
    @Delete("DELETE FROM `user` where id = #{id}")    
    public void delete(Integer id);
}

复杂映射

一对一
public interface OrderMapper {    
    @Select("SELECT * FROM orders")    
    @Results({            
        @Result(id = true, column = "id", property = "id"),            
        @Result(column = "ordertime", property = "ordertime"),            
        @Result(column = "money", property = "money"),            
        @Result(property = "user", javaType = User.class,                    
                column = "uid", one = @One(select = "com.hezhe.mapper.UserMapper.findById", fetchType = FetchType.EAGER))   })    
    public List<Order> 
        findAllWithUser();
}
一对多
public interface UserMapper {    
    @Select("SELECT * FROM `user`")    
    @Results({        
        @Result(id = true, column = "id", property = "id"),        
        @Result(column = "brithday", property = "brithday"),        
        @Result(column = "sex", property = "sex"),        
        @Result(column = "address", property = "address"),        
        @Result(property = "orderList", javaType = List.class,                
                column = "id" ,                
                many = @Many(select = "com.hezhe.mapper.OrderMapper.findByUid"))   
    })    
    public List<User> findAllWithOrder();
}
多对多
public interface UserMapper {    
    @Select("SELECT * FROM `user`")    
    @Results({        
        @Result(id = true, column = "id", property = "id"),        
        @Result(column = "brithday", property = "brithday"),        
        @Result(column = "sex", property = "sex"),        
        @Result(column = "address", property = "address"),        
        @Result(property = "roleList", javaType = List.class,                
                column = "id" ,                
                many = @Many(select = "com.hezhe.mapper.RoleMapper.findByUid"))   
    })    
    public List<User> findAllWithRole();
}

二级缓存

@CacheNamespace
public interface UserMapper {...}

延迟加载注解

在一对一或时一对多注解中加上fetchType属性即可

MasonHZ
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Mybatis学习总结(结合个人理解)
抵氏的博客
06-16 770
Mybatis 1. MyBatis简介 1.1 什么是Mybatis MyBatis 是一款优秀的持久层框架 MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集的过程 MyBatis 可以使用简单的 XML 或注解来配置和映射原生信息，将接口和 Java 的 实体类 【Plain Old Java Objects,普通的 Java对象】映射成数据库中的记录。 MyBatis 本是apache的一个开源项目ibatis, 2010年这个项目由apache 迁移到了google c
mybatis入门总结
weixin_42772943的博客
10-11 284
概论：　　MyBatis是一个支持普通SQL查询，存储过程和高级映射的优秀持久层框架。MyBatis消除了几乎所有的JDBC代码和参数的手工设置以及对结果集的检索封装。MyBatis可以使用简单的XML或注解用于配置和原始映射，将接口和Java的POJO（Plain Old Java Objects，普通的Java对象）映射成数据库中的记录。 作用： Mybatis将sql语句配置到xml配置文件...
最全MyBatis核心配置文件总结，可以作为工具先收藏了
最新发布
2401_84046545的博客
04-07 366
上面是MyBatis提供的默认映射类型，可以处理大部分需求，如果我们需要有不同的需求，则可以自己定义类型，具体如何定义，在后面的文章会单独分析，在这里不展开，感兴趣的可以关注我，留意后续文章。有些业务场景可能需要自己自定义数据源，MyBatis也是支持的。自定义数据源必须要实现DataSourceFactory接口。
Mybatis框架学习总结
阿火
06-16 727
Mybatis框架学习总结Mybatis是什么？使用它我们可以做什么？MyBatis环境搭建创建MyBatis核心配置文件configuration.xmlMyBatis的核心接口和类MyBatis核心配置文件SQL映射文件MyBatis框架的优点：MyBatis 中 #{} 和 ${} 的区别 原文链接：https://www.cnblogs.com/xiaotie666/p/LiujinMybatisSummary.html Mybatis是什么？使用它我们可以做什么？ MyBatis是一个开源的数据持
初识MyBatis框架
m0_63378258的博客
11-29 387
初识MyBatis:首先，一上来就是配置环境，MyBatis的核心配置文件，这个是非常重要的！MyBatis核心配置文件，一般都命名为mybatis-config.xml，包含的内容有数据库的配置信息（注意，这里数据库可以连接多个），事务处理，映射文件等，初来乍到，还请大家多多斧正，在此拜谢！话不多说，直接开整！
MyBatis总结
qq_45297996的博客
10-17 1752
1. 什么是Mybatis mybatis 是一个优秀的基于java的持久层框架，它内部封装了jdbc，使开发者只需要关注sql语句本身，而不需要花费精力去处理加载驱动、创建连接、创建statement等繁杂的过程。 mybatis通过xml或注解的方式将要执行的各种 statement配置起来，并通过java对象和statement中sql的动态参数进行映射生成最终执行的sql语句。 最后mybatis框架执行sql并将结果映射为java对象并返回。采用ORM思想解决了实体和数据库映射的问题，对jd
MyBatis入门总结
weixin_45641191的博客
09-10 289
MyBatis总结一、MyBatis简介1、基本信息2、特点二、MyBatis开端三、开发第一个应用四、基本的crud操作五、配置优化六、分页的实现七、使用注解实现mybatis八、关于联表的处理九、动态sql 一、MyBatis简介 MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code，并且改名为MyBatis 。2013年11月迁移到Github。 iBATIS一词来源于“internet”
MyBatis的入门总结
qq_45906891的博客
11-27 102
Mybatis快速入门 1.mybatis认识 1.1概念：是一个ORM的数据库持久化框架(java的持久层框架) ORM：对象关系映射 数据库持久化：将数据保存到数据库的过程 mybatis是一个支撑框架，它是以映射SQL语句orm方式来做数据库持久化操作 2.为什么要用mybatis mybatis较与jdbc的优势 jdbc：重复代码比较多，封装对象比较麻烦，没有性能控制...
Mybatis的入门总结
qq_56113699的博客
05-22 364
1.三层架构的介绍 软件中分层 分层的作用 降低层与层之间的耦合性。 提高软件的可维护性。 提升软件的可扩展性。 小结： 三层架构的好处 降低层与层之间的耦合性。 提高软件的可维护性。 提升软件的可扩展性。 什么是框架 之前我们都是根据需求写出所有的相关代码麻烦，累，繁琐。框架是别人写好的代码，是对常见功能的封装，是一个半成品。我们在框架的基础上开发出成品的软件。 假如你要造一辆马车，在没有零件的情况下，你需要自己去伐木，去把木头做成木板，木棍，然后做成轮子，门，等部件，然后组装起来，很麻烦。框架
mybatis新手入门总结
song5648629的博客
01-11 222
mybatis是一个优秀的持久层框架，它将jdbc进行了封装，使得开发者只需要关注sql本身，而不需要关注如何注册数据库驱动，建立连接等操作。mybatis通过xml和注解的方式，将statement或者prepareStatement进行了配置。并且只需要将statement中的sql语句进行映射，最终由mybatis来调用执行sql。     那么我们使用jdbc编程有哪些缺点呢？我们又是通
Mybatis入门资源
01-18
"Mybatis总结.pptx"可能是对整个Mybatis学习过程的全面回顾，包括所有上述知识点的综合，也可能包含实际项目中的一些最佳实践。 至于".txt"文件，如"学习（五）用到的表.txt"、"学习（五、六）用到的表.txt"、"快速...
mybatis入门之jdbc操作数据库
01-28
我们将涵盖连接数据库、预处理语句、传递参数、处理结果集以及关闭资源等关键知识点。 首先，我们需要了解JDBC的基本概念。JDBC是Java语言与各种数据库交互的一种标准接口，它允许开发者执行SQL语句并获取结果。在...
Mybatis基础入门一
04-18
总结来说，Mybatis的基础入门主要涉及以下几个核心知识点： 1. Mybatis全局配置文件`mybatis-config.xml`的配置，包括数据源、事务管理和Mapper文件的加载。 2. 映射文件`MemberMapper.xml`的编写，包括SQL语句的...
Mybatis讲义laodu
11-13
MyBatis入门程序** MyBatis的入门通常包括下载MyBatis框架，配置核心配置文件，创建Mapper接口和XML映射文件，以及编写测试类。同时，为了便于测试，可以引入JUnit和日志框架如logback。 **3. CRUD操作** MyBatis...
mybatis.rar
06-03
这个"mybatis.rar"压缩包可能包含了一个基本的MyBatis入门教程，展示了如何设置项目、配置MyBatis以及实现数据的增删查改（CRUD）操作。下面将详细解释这些知识点。 1. **MyBatis简单入门**： MyBatis的入门涉及几...
mybatis知识点总结(一)-mybatis快速入门
m0_47209867的博客
01-11 508
mybatis知识点总结 1.mybatis是一个持久层的框架，内部封装了jdbc,使得使用者只需要关注sql语句，不需要手动编写注册驱动、创建连接、创建Statement等过程的代码。 2.mybatis使用xml和注解的方式来进行sql语句的配置，通过java对象和sql语句中的动态参数进行映射生成最终的执行语句(动态sql)。 3.mybatis执行sql的最终结果会被映射并封装为java对象，采用ORM的思想，解决了实体类和数据库表之间的映射关系。 mybatis的开发使用步骤：(以xml方式进行实
SSM框架之Mybatis笔记04配置详解
qq_43751506的博客
08-04 215
核心配置文件 mybatis-config.xml 系统核心配置文件 MyBatis 的配置文件包含了会深深影响 MyBatis 行为的设置和属性信息。 能配置的内容如下： configuration（配置） properties（属性） settings（设置） typeAliases（类型别名） typeHandlers（类型处理器） objectFactory（对象工厂） plugins（插件） environments（环境配置） environment（环境变量） transactionMan
【MyBatis】 创建配置文件 工具类与CRUD 添加的对象返回id 别名的配置 日志的处理 #与$的区别 批量操作与动态SQL
snailisBigbull的博客
08-19 148
一.基本认识 二.hello,mybatis 2.1 导包 2.2 基本准备(表,domain) 2.3 创建配置文件 jdbc.properties:数据库的参数 mybatis-config.xml:mybatis的核心配置 ProductMapper.xml:sql语句 2.4 测试 三.工具类与CRUD ...
mybatis的知识点大全
06-09
MyBatis是一款优秀的ORM框架，主要用于数据持久层的开发。以下是MyBatis的一些知识点： 1. MyBatis的基本架构：SqlSessionFactory、SqlSession、Mapper。 2. MyBatis的配置文件：主要包括数据库连接信息、Mapper映射文件、全局配置等。 3. MyBatis的Mapper映射文件：定义了SQL语句、参数类型、返回值类型等。 4. MyBatis的动态SQL：包括if、choose、when、otherwise、foreach、bind等标签。 5. MyBatis的插件：可以对MyBatis的执行过程进行拦截和修改。 6. MyBatis的缓存机制：一级缓存和二级缓存。 7. MyBatis的事务管理：支持基于XML和注解的声明式事务管理。 8. MyBatis的高级功能：包括多表查询、分页、嵌套查询、延迟加载等。 9. MyBatis的整合：可以和Spring、Spring Boot、Spring MVC等框架进行整合。 10. MyBatis的性能优化：包括缓存使用、SQL优化、批量操作等。 以上是MyBatis的一些基本知识点，如果想深入了解MyBatis，可以进一步学习MyBatis的源码和实践。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

MasonHZ

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

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

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

打赏作者

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

抵扣说明：

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

余额充值