下载文档原格式
mybatis入门到精通以前曾经用过ibatis,这是mybatis的前身，当时在做项目时，感觉很不错，比hibernate灵活。
性能也比hibernate 好。
而且也比较轻量级，因为当时在项目中，没来的及做很很多笔记。
后来项目结束了，我也没写总结文档。
已经过去好久了。
但最近突然又对这个ORM 工具感兴趣。
因为接下来自己的项目中很有可能采用这个ORM工具。
所以在此重新温习了一下mybatis, 因此就有了这个系列的mybatis 教程.什么是mybatisMyBatis是支持普通SQL查询，存储过程和高级映射的优秀持久层框架。
MyBatis消除了几乎所有的JDBC代码和参数的手工设置以及结果集的检索。
MyBatis使用简单的XML或注解用于配置和原始映射，将接口和Java的POJOs （Plan Old Java Objects，普通的Java对象）映射成数据库中的记录.orm工具的基本思想无论是用过的hibernate,mybatis,你都可以法相他们有一个共同点：1. 从配置文件(通常是XML配置文件中)得到sessionfactory.2. 由sessionfactory 产生session3. 在session 中完成对数据的增删改查和事务提交等.4. 在用完之后关闭session 。
\5. 在java 对象和数据库之间有做mapping 的配置文件，也通常是xml 文件。
mybatis实战教程(mybatis in action)之一：开发环境搭建mybatis 的开发环境搭建，选择: eclipse j2ee 版本，mysql 5.1 ,jdk 1.7,mybatis3.2.0.jar包。
这些软件工具均可以到各自的官方网站上下载。
首先建立一个名字为MyBaits 的dynamic web project1. 现阶段，你可以直接建立java 工程，但一般都是开发web项目，这个系列教程最后也是web的，所以一开始就建立web工程。
mybatis基本工作原理MyBatis是一种Java持久化框架，它的基本工作原理是通过XML或注解来描述数据库操作语句，并将这些语句映射为Java对象的方法。
本文将详细介绍MyBatis的基本工作原理。
MyBatis通过配置文件来初始化和配置数据库连接。
配置文件中包含了数据库连接的相关信息，如数据库驱动、连接URL、用户名和密码等。
通过读取这些配置信息，MyBatis可以建立与数据库的连接。
接下来，MyBatis使用SQL映射文件来描述数据库操作语句。
SQL映射文件包含了一组SQL语句，这些语句用于对数据库进行增删改查操作。
每个SQL语句都被映射为一个唯一的ID，以便在Java代码中进行调用。
MyBatis还支持使用注解来描述数据库操作语句。
通过在Java方法上添加注解，可以直接将数据库操作语句与Java方法关联起来，省去了编写XML文件的步骤。
当Java程序调用MyBatis的方法时，MyBatis会根据方法上的注解或XML文件中的映射关系，动态生成一个SQL语句，并将该语句发送给数据库执行。
执行结果会被封装为Java对象，并返回给调用者。
在生成SQL语句时，MyBatis还支持动态SQL语句的生成。
动态SQL 语句可以根据不同的条件来拼接SQL语句的不同部分，从而实现灵活的数据库操作。
MyBatis还提供了一级缓存和二级缓存机制，以提高数据库操作的性能。
一级缓存是指在同一个SqlSession中，对同一个SQL语句的结果进行缓存。
二级缓存是指将查询结果缓存到一个共享的缓存区域，使得多个SqlSession可以共享同一个查询结果。
除了上述基本工作原理外，MyBatis还提供了许多其他功能，如插件机制、事务管理、数据库连接池等。
插件机制可以扩展MyBatis 的功能，比如实现自定义的拦截器。
事务管理可以保证数据库操作的一致性和隔离性。
数据库连接池可以提高数据库连接的复用性和性能。
总结一下，MyBatis的基本工作原理是通过配置文件或注解来描述数据库操作语句，并将这些语句映射为Java对象的方法。
mybatis入门教程MyBatis是一种开源的持久层框架，它可以帮助我们简化数据库操作的过程。
本教程将介绍如何使用MyBatis进行基本的数据访问操作。
第一步：创建数据库和表首先，我们需要创建一个数据库和一个表来存储数据。
假设我们创建了一个名为"mybatis_demo"的数据库，并在其中创建了一个名为"users"的表，该表包含id、name和age三个字段。
第二步：引入MyBatis依赖在使用MyBatis之前，我们需要在项目的pom.xml文件中引入MyBatis的依赖。
可以在Maven仓库中找到最新的MyBatis版本，并将其添加到pom.xml文件中。
<dependency><groupId>org.mybatis</groupId><artifactId>mybatis</artifactId><version>3.5.6</version></dependency>第三步：创建数据源配置文件在src/main/resources目录下创建一个名为"mybatis-config.xml"的文件，并在其中配置数据源信息。
以下是一个示例配置：<?xml version="1.0" encoding="UTF-8"?><configuration><environments default="development"><environment id="development"><transactionManager type="JDBC"/><dataSource type="POOLED"><property name="url"value="jdbc:mysql://localhost:3306/mybatis_demo"/><property name="username" value="root"/></dataSource></environment></environments><mappers><!-- 这里可以配置Mapper接口所在的包 --></mappers></configuration>注意：在实际项目中，我们通常会将数据库连接信息配置在外部的配置文件中，而不是直接写在mybatis-config.xml文件中。
Mybatis 知识点什么是 MybatisMybatis 是一个开源的持久层框架，它提供了一个可以自定义 SQL 映射的方式，以及可以很方便地进行数据库查询和操作的功能。
相比于传统的 ORM 框架，Mybatis 更加灵活，适用于复杂的 SQL 查询和自定义 SQL 语句的情况。
Mybatis 的优点1.灵活性：Mybatis 允许开发者自定义 SQL 映射，可以根据需要编写任意复杂的 SQL 查询语句，更加灵活地操作数据库。
2.性能优化：Mybatis 提供了多种性能优化的手段，比如查询缓存和预编译语句等，可以减少数据库的访问次数，提高系统性能。
3.易于集成：Mybatis 与 Spring 框架完美集成，可以很方便地与 SpringBoot 一起使用，简化开发流程。
Mybatis 的基本使用1. 引入依赖在 Maven 项目的 pom.xml 文件中，添加以下依赖：<dependency><groupId>org.mybatis.spring.boot</groupId><artifactId>mybatis-spring-boot-starter</artifactId><version>2.1.4</version></dependency>2. 配置数据源在 application.properties 文件中配置数据源信息：spring.datasource.url=jdbc:mysql://localhost:3306/mydbername=rootspring.datasource.password=1234563. 创建实体类和 Mapper 接口创建与数据库表对应的实体类和对应的 Mapper 接口，如下所示：public class User {private Long id;private String name;private Integer age;// 省略 getter 和 setter 方法}public interface UserMapper {List<User> getAllUsers();User getUserById(Long id);void addUser(User user);void updateUser(User user);void deleteUser(Long id);}4. 编写 SQL 映射文件在 resources 目录下创建一个 sqlmap 目录，并在该目录下编写 XML 格式的 SQL 映射文件，如下所示：<!-- UserMapper.xml --><mapper namespace="erMapper"><select id="getAllUsers" resultType="er">SELECT * FROM user;</select><select id="getUserById" resultType="er">SELECT * FROM user WHERE id = #{id};</select><insert id="addUser">INSERT INTO user(name, age) VALUES(#{name}, #{age});</insert><update id="updateUser">UPDATE user SET name = #{name}, age = #{age} WHERE id = #{id};</update><delete id="deleteUser">DELETE FROM user WHERE id = #{id};</delete></mapper>5. 配置 Mybatis在 application.properties 文件中配置 Mybatis 相关的配置项，如下所示：mybatis.mapper-locations=classpath*:sqlmap/**/*.xmlmybatis.configuration.map-underscore-to-camel-case=true6. 注入 Mapper在需要使用 Mapper 的地方进行注入，并调用相应的方法即可：@Servicepublic class UserServiceImpl implements UserService {@Autowiredprivate UserMapper userMapper;@Overridepublic List<User> getAllUsers() {return userMapper.getAllUsers();}// 省略其他方法实现}Mybatis 高级特性动态 SQLMybatis 提供了动态 SQL 的支持，可以根据不同的条件生成不同的 SQL 语句，实现更加灵活的查询。
mybatis工作原理MyBatis是一种持久层框架，它提供了一种数据映射技术，可以将程序中操作数据库的代码从java代码中分离出来，避免繁琐的jdbc代码编写。
MyBatis也称为iBATIS，它是Apache的一个开源项目。
MyBatis的工作原理是通过构建一个SQL映射文件，将SQL语句和Java代码关联起来，从而达到解耦的目的。
MyBatis的使用方法是将查询SQL语句写入xml文件中，并将它与Java代码建立映射关系。
xml文件中保存了查询SQL语句，Java代码中则对xml文件中的SQL语句进行参数传递，完成到数据库的查询。
MyBatis的运行原理主要可以分为三个部分：加载配置文件、准备数据和执行SQL语句。
1、加载配置文件MyBatis使用XML文件来配置SQL语句，每个XML文件都包含一个<mapper>标签，它代表一个SQL映射文件，在实际使用中，一般把SQL映射文件和对应的Java实体类放在同一个包中，这样当MyBatis 开始工作的时候，就会自动加载这些映射文件，这是MyBatis的第一步。
2、准备数据当MyBatis加载完SQL映射文件后，它会根据XML文件中的<parameter>标签获取参数，将参数传递给SQL语句，并且根据<result>标签返回SQL查询结果。
3、执行SQL语句最后MyBatis会调用数据库驱动程序来执行SQL语句，将查询结果返回给应用程序，程序也可以根据XML文件中的<result>或<parameter>标签来自动映射Java实体类，从而避免jdbc的反复编写。
MyBatis的工作原理简单易懂，但它的实际实现并不复杂，它能够大大减少java代码的编写，提高数据库查询效率，一般来说，用户仅仅需要配置XML映射文件即可完成对数据库的操作。
MyBatis虽然有着一系列优点，但还是存在一些不足，比如MyBatis不支持复合主键，也不支持多表联查，还有缓存功能不够强大，这些都需要用户注意。
Mybatis教程及使用配置2013-11-22 | 所属分类：Mybatis 教程入门配置12_17一．Mybatis简介MyBatis由Clinton Begin 在2002 年创建，其后，捐献给了Apache基金会，成立了iBatis 项目。
2010 年5 月，将代码库迁至Google Code，并更名为MyBatis。
MyBatis 是一个可以自定义SQL、存储过程和高级映射的持久层框架。
MyBatis 只使用简单的XML 和注解来配置和映射基本数据类型、Map 接口和POJO 到数据库记录。
相对Hibe rnate和Apache OJB等“一站式”ORM解决方案而言，Mybatis 是一种“半自动化”的ORM实现。
二．从JDBC到Mybatis1. JDBC查询数据库数据，一般需要以下七个步骤：（1）加载JDBC驱动（2）建立并获取数据库连接（3）创建 JDBC Statements 对象（4）设置SQL语句的传入参数（5）执行SQL语句并获得查询结果（6）对查询结果进行转换处理并将处理结果返回（7）释放相关资源（关闭Connection，关闭Statement，关闭ResultSet）实现JDBC有七个步骤，哪些步骤是可以进一步封装的，减少我们开发的代码量？2. JDBC演变到Mybatis过程第一步优化：连接获取和释放问题描述：通过JDBC的方式数据库连接频繁的开启和关闭本身就造成了资源的浪费，影响系统的性能；但是现在连接池多种多样，可能存在变化，有可能采用DBCP的连接池，也有可能采用容器本身的JNDI数据库连接池。
解决问题：数据库连接的获取和关闭我们可以使用数据库连接池来解决资源浪费的问题，通过连接池就可以反复利用已经建立的连接去访问数据库了，减少连接的开启和关闭的时间。
同时通过DataSource进行隔离解耦，统一从DataSource里面获取数据库连接，DataSource 具体由DBCP实现还是由容器的JNDI实现都可以，将DataSource的具体实现通过让用户配置来应对变化。
mybatis实战教程(mybatis in action)之三:实现数据的增删改查(2012-12-14 10:24:00)转载▼标签：分类：SpringMVC之三用户园区第二教程前面已经讲到用接口的方式编程。
这种方式，要注意的一个地方就是。
在User.xml 的配置文件中，mapper namespace="com.yihaomen.mybatis.inter.IUserOperation" ，命名空间非常重要，不能有错，必须与我们定义的package 和接口一致。
如果不一致就会出错,这一章主要在上一讲基于接口编程的基础上完成如下事情:1. 用mybatis 查询数据，包括列表2. 用mybatis 增加数据3. 用mybatis 更新数据.4. 用mybatis 删除数据.查询数据，前面已经讲过简单的，主要看查询出列表的查询出列表，也就是返回list, 在我们这个例子中也就是List<User> , 这种方式返回数据，需要在User.xml 里面配置返回的类型resultMap, 注意不是resultType, 而这个resultMap 所对应的应该是我们自己配置的程序代码<!-- 为了返回list 类型而定义的returnMap --><resultMap type="User" id="resultListUser"><id column="id" property="id" /><result column="userName" property="userName" /><result column="userAge" property="userAge" /><result column="userAddress" property="userAddress" /></resultMap>查询列表的语句在User.xml 中程序代码<!-- 返回list 的select 语句，注意resultMap 的值是指向前面定义好的--><select id="selectUsers" parameterType="string" resultMap="resultListUser">select * from user where userName like #{userName}</select>在IUserOperation 接口中增加方法：public List selectUsers(String userName); 现在在Test 类中做测试程序代码public void getUserList(String userName){SqlSession session = sqlSessionFactory.openSession();try {IUserOperationuserOperation=session.getMapper(IUserOperation.class);List users = userOperation.selectUsers(userName);for(User user:users){System.out.println(user.getId()+":"+user.getUserName()+":"+user.getUs erAddress());}} finally {session.close();}}现在在main 方法中可以测试：程序代码public static void main(String[] args) {Test testUser=new Test();testUser.getUserList("%");}可以看到，结果成功查询出来。
简述mybatis的工作流程。
MyBatis工作流程：
1、读取配置文件：MyBatis会首先加载mybatis-config.xml文件，以及其他所有的映射配置文件，来生成SqlSessionFactory类的实例
2、解析映射配置文件：MyBatis会解析映射配置文件以及SQL
映射文件，生成相应的SQL语句
3、创建SqlSession：MyBatis使用SqlSessionFactory类来创建SqlSession，SqlSession是MyBatis的主要操作类，它是与数据库的回话，通过它可以操作MyBatis映射的SQL语句
4、执行SQL：使用SqlSession的提供的API执行指定的SQL语句，它可以接受参数进行查询，更新，插入或者删除操作
5、获取映射结果：MyBatis使用ResultMap对象来封装映射结果，它包含了字段映射和列名映射，以及对象的嵌套映射结果
6、关闭SqlSession：最后，关闭SqlSession，释放相关资源。
- 1 -。
mybatis项目开发步骤
MyBatis是一种基于Java的持久化框架，它可以帮助我们简化数据库操作并提高效率。
下面是使用MyBatis进行项目开发的步骤： 1. 安装MyBatis
首先需要安装MyBatis，可以通过官网下载MyBatis或者使用Maven引入MyBatis依赖。
2. 配置数据库连接
使用MyBatis需要先配置数据库连接，在mybatis-config.xml 文件中配置数据源信息。
3. 创建实体类
与数据库中的表对应的实体类需要实现Serializable接口，并且使用注解或者XML文件进行映射。
4. 创建Mapper接口
Mapper接口是操作数据库的核心接口，需要在Mapper接口中定义与数据库操作对应的方法。
5. 创建Mapper XML文件
Mapper XML文件是Mapper接口的实现类，它与Mapper接口一一对应，需要在XML文件中定义与Mapper接口中方法对应的SQL语句。
6. 编写DAO层代码
DAO层是与数据库直接交互的层，需要在DAO层中使用MyBatis 提供的API操作数据库。
7. 编写Service层代码
Service层是业务逻辑层，需要调用DAO层提供的方法，并且可以进行业务处理。
8. 编写Controller层代码
Controller层是接受请求并响应结果的层，需要调用Service 层提供的方法，并且可以进行请求处理和返回结果。
9. 编写测试代码
编写测试代码对项目进行测试，确保所有功能正常运行。
以上就是使用MyBatis进行项目开发的步骤，通过遵循这些步骤可以快速开发出高效稳定的项目。
mybatis main方法MyBatis Main方法使用指南介绍在MyBatis中，main方法是一个非常常用的方法，它用于启动一个MyBatis应用程序并执行相关的操作。
本文将详细介绍MyBatis main方法的各种用法和注意事项。
使用方法•导入MyBatis的相关依赖 MyBatis需要依赖于一些Jar包，你需要在你的项目中导入这些Jar包。
例如，在Maven 项目中，你可以在文件中添加如下依赖：<dependencies><dependency><groupId></groupId><artifactId>mybatis</artifactId><version></version></dependency><!-- 其他依赖 --></dependencies>•编写MyBatis的配置文件在MyBatis中，配置文件用于定义数据库连接信息以及ORM映射等相关配置。
你需要创建一个文件，并在其中配置相关信息。
例如：<?xml version="" encoding="UTF-8"?><!DOCTYPE configurationPUBLIC "-////DTD Config //EN""<configuration><!-- 数据库连接信息 --><environments default="development"><environment id="development"><transactionManager type="JDBC"/><dataSource type="POOLED"><property name="driver" value=""/> <property name="url" value="jdbc: <property name="username" value="ro ot"/><property name="password" value="ro ot"/></dataSource></environment></environments><!-- ORM映射配置 --><mappers><mapper resource="com/example/mapper/"/> <!--其他映射文件 --></mappers></configuration>•编写Mapper接口和映射文件在MyBatis中，Mapper 接口用于定义与数据库交互的方法，映射文件用于定义SQL语句和结果映射关系。
MyBatis详解⼀篇就够啦第1章MyBatis框架配置⽂件详解1.1 typeHandlers类型转换器 每当MyBatis 设置参数到PreparedStatement 或者从ResultSet 结果集中取得值时，就会使⽤TypeHandler 来处理数据库类型与java 类型之间转换。
下表描述了默认TypeHandlers1.1.1 ⾃定义类型转换器假设表中字段是int类型,⽽实体类与之对应的属性是boolean类型,此时可以采⽤⾃定义类型转换器进⾏对应(1)实体类1 package com.chenyanbin.beans;23 public class Dept {4 private Integer deptNo;5 private String dname;6 private String loc;7 private boolean flag;8 public Integer getDeptNo() {9 return deptNo;10 }11 public boolean isFlag() {12 return flag;13 }14 public void setFlag(boolean flag) {15 this.flag = flag;16 }17 public void setDeptNo(Integer deptNo) {18 this.deptNo = deptNo;19 }20 public String getDname() {21 return dname;22 }23 public void setDname(String dname) {24 this.dname = dname;25 }26 public String getLoc() {27 return loc;28 }29 public void setLoc(String loc) {30 this.loc = loc;31 }32 }(2) 表中字段(3) 开发⾃定义类型转换器：MyTypeHandler.java继承并实现接⼝:TypeHandler.java1 package com.chenyanbin.util;23 import java.sql.CallableStatement;4 import java.sql.PreparedStatement;5 import java.sql.ResultSet;6 import java.sql.SQLException;78 import org.apache.ibatis.jdbc.Null;9 import org.apache.ibatis.type.JdbcType;10 import org.apache.ibatis.type.TypeHandler;11 /*12 * setParameter:这个⽅法在⽣成SQL语句时才被调⽤13 *14 * getResult:查询结束之后，在将ResultSet数据⾏转换为实体类对象时，通知TypeHandler将当前数据⾏某个字段转换为何种类型15 *16 *17 */18 public class MyTypeHandler implements TypeHandler {1920 public void setParameter(PreparedStatement ps, int i, Object parameter, JdbcType jdbcType) throws SQLException {21 if (parameter==null) { //dept.flag=null insertsql flag设置022 ps.setInt(i, 0);23 return;24 }25 Boolean flag=(Boolean)parameter;26 if (flag==true) {27 ps.setInt(i, 1);28 }29 else {30 ps.setInt(i, 0);31 }32 }3334 public Object getResult(ResultSet rs, String columnName) throws SQLException {35 int flag = rs.getInt(columnName); //1 or 036 Boolean myFlag=Boolean.FALSE;37 if (flag==1) {38 myFlag=Boolean.TRUE;39 }40 return myFlag;41 }4243 public Object getResult(ResultSet rs, int columnIndex) throws SQLException {44 // TODO Auto-generated method stub45 return null;46 }4748 public Object getResult(CallableStatement cs, int columnIndex) throws SQLException {49 // TODO Auto-generated method stub50 return null;51 }5253 }(4) 在MyBatis核⼼配置⽂件注册⾃定义类型转换器：myBatis-config.xml1 <?xml version="1.0" encoding="UTF-8"?>2 <!DOCTYPE configuration3 PUBLIC "-////DTD Config 3.0//EN"4 "/dtd/mybatis-3-config.dtd">5 <configuration>6 <!-- 属性配置 -->7 <properties resource="config.properties"></properties>8 <!-- 别名配置 -->9 <typeAliases>10 <package name="com.chenyanbin.beans" />13 <!-- 类型处理器 -->14 <typeHandlers>15 <!-- 从java中的Boolean转jdbc中的NUMERIC -->16 <typeHandler handler="com.chenyanbin.util.MyTypeHandler"17 javaType="Boolean" jdbcType="NUMERIC" />18 </typeHandlers>19 <!-- 环境配置 -->20 <environments default="development">21 <!-- 环境配置 -->22 <environment id="development">23 <!-- 事务管理器 -->24 <transactionManager type="JDBC"></transactionManager>25 <!-- 数据源 -->26 <dataSource type="pooled">27 <property name="driver" value="${jdbc.driver}" />28 <property name="url" value="${jdbc.url}" />29 <property name="username" value="${ername}" />30 <property name="password" value="${jdbc.password}" />31 </dataSource>32 </environment>33 </environments>34 <!-- 映射器 -->35 <mappers>36 <package name="com.chenyanbin.dao" />37 </mappers>38 </configuration>config.properties1 jdbc.driver=com.mysql.jdbc.Driver2 jdbc.url=jdbc:mysql://localhost:3306/sam3 ername=root4 jdbc.password=root(5) 创建接⼝:DeptMapper.java1 package com.chenyanbin.dao;23 import java.util.List;4 import com.chenyanbin.beans.Dept;56 public interface DeptMapper {7 public void deptSave(Dept dept);89 public List<Dept> deptFind();10 }(6) DeptMapper.xml1 <?xml version="1.0" encoding="UTF-8"?>2 <!DOCTYPE mapper3 PUBLIC "-////DTD Mapper 3.0//EN"4 "/dtd/mybatis-3-mapper.dtd">5 <mapper namespace="com.chenyanbin.dao.DeptMapper">6 <insert id="deptSave">7 insert into dept (DEPTNO,DNAME,LOC,flag)8 values(#{deptNo},#{dname},#{loc},#{flag})9 </insert>10 <select id="deptFind" resultType="Dept">11 select deptNo,dname,loc,flag from dept12 </select>13 </mapper>1 <?xml version="1.0" encoding="UTF-8"?>2 <!DOCTYPE configuration3 PUBLIC "-////DTD Config 3.0//EN"4 "/dtd/mybatis-3-config.dtd">5 <configuration>6 <!-- 属性配置 -->7 <properties resource="config.properties"></properties>8 <!-- 别名配置 -->9 <typeAliases>10 <package name="com.chenyanbin.beans" />11 <package name="com.chenyanbin.dao" />12 </typeAliases>13 <!-- 环境配置 -->14 <environments default="development">15 <!-- 环境配置 -->16 <environment id="development">17 <!-- 事务管理器 -->18 <transactionManager type="JDBC"></transactionManager>19 <!-- 数据源 -->20 <dataSource type="pooled">21 <property name="driver" value="${jdbc.driver}" />22 <property name="url" value="${jdbc.url}" />23 <property name="username" value="${ername}" />24 <property name="password" value="${jdbc.password}" />25 </dataSource>26 </environment>27 </environments>28 <!-- 映射器 -->29 <mappers>32 </configuration>⽅式⼆：myBatis-config.xml1 <?xml version="1.0" encoding="UTF-8"?>2 <!DOCTYPE mapper3 PUBLIC "-////DTD Mapper 3.0//EN"4 "/dtd/mybatis-3-mapper.dtd">5 <mapper namespace="com.chenyanbin.dao.DeptMapper">6 <insert id="deptSave">7 insert into dept (DEPTNO,DNAME,LOC,flag)8 values(#{deptNo},#{dname},#{loc},#{flag})9 </insert>10 <resultMap type="dept" id="deptMap">11 <result column="flag" property="flag" typeHandler="com.chenyanbin.util.MyTypeHandler"/>12 </resultMap>13 <select id="deptFind" resultType="Dept">14 select deptNo,dname,loc,flag from dept15 </select>16 </mapper>⽅式⼆：DeptMapper.xml(7) 执⾏单元测试:TestMain_01.java1 package com.chenyanbin.test;23 import java.io.IOException;4 import java.io.InputStream;5 import java.util.List;6 import org.apache.ibatis.io.Resources;7 import org.apache.ibatis.session.SqlSession;8 import org.apache.ibatis.session.SqlSessionFactory;9 import org.apache.ibatis.session.SqlSessionFactoryBuilder;10 import org.junit.After;11 import org.junit.Before;12 import org.junit.Test;13 import com.chenyanbin.beans.Dept;14 import com.chenyanbin.dao.DeptMapper;1516 public class TestMain_01 {17 private SqlSession session;1819 @Before20 public void Start() {21 try {22 InputStream inputStream = Resources.getResourceAsStream("myBatis-config.xml");23 SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(inputStream);24 session = factory.openSession();25 } catch (Exception e) {26 e.printStackTrace();27 }28 }2930 @After31 public void end() {32 if (session == null) {33 session.close();34 }35 }3637 @Test38 public void test01() throws IOException {39 Dept d2 = new Dept();40 d2.setDname("上海事业部");41 d2.setLoc("上海");42 d2.setFlag(false);43 session.insert("deptSave", d2);44 mit();45 session.close();46 }4748 @Test49 public void test02() {50 DeptMapper dao=session.getMapper(DeptMapper.class);51 List<Dept> deptList=dao.deptFind();52 System.out.println("ok");53 }5455 }(8) 项⽬⽬录结构1.2 objectFactory 对象⼯⼚ MyBatis 每次创建结果对象的新实例时，它都会使⽤⼀个对象⼯⼚（ObjectFactory）实例来完成。
MyBatis原理与执⾏流程⾸先感谢尚硅⾕的⽼师讲解!Mybatis流程分四步：1. 返回创建SqlSessionFactory对象2. 返回SqlSession的实现类DefaultSqlSession对象3. 返回⼀个MapperProxy的代理对象4. 执⾏询流程。
第⼀步返回创建SqlSessionFactory对象SqlSessionFactoryBuilder().build(inputStream);如何得到配置⽂件的内容？创建解析器解析全局配置⽂件XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);得到全局配置⽂件的配置内容 , 解析每⼀个标签把详细信息保存在Configuration中//解析配置⽂件标签build(parser.parse());propertiesElement(root.evalNode("properties"));Properties settings = settingsAsProperties(root.evalNode("settings"));loadCustomVfs(settings);typeAliasesElement(root.evalNode("typeAliases"));pluginElement(root.evalNode("plugins"));objectFactoryElement(root.evalNode("objectFactory"));全局配置⽂件中有该属性可以解析mapper.xml⽂件也保存到Configuration中mappers><package name="dao"/></mappers>Mapper.xml中的每个元素解析出来保存到全局配置中将增删改查标签的每⼀个标签每⼀个属性也解析出来封装到⼀个MapperedStatement中⼀个MapperedStatement就代表⼀个增删改查标签的详细信息最后 return configuration;包括全局配置信息和mapper.xml映射⽂件的各种信息返回的configuration通过buildreturn new DefaultSqlSessionFactory(config);configuration中mapperRegistry属性保存的是代理类信息mappedStatement属性保存的是增删查改等标签内容总结：配置⽂件的信息解析保存到Configureation对象中返回包含Configureation的DefaultSqlSessionFactory第⼆步返回SqlSession的实现类DefaultSqlSession对象他⾥⾯包含了Executor（是⽤来增删改查的）和Configuration。
mybatis框架工作原理MyBatis框架工作原理MyBatis是一个开源的持久层框架，它通过简化数据库操作，帮助开发人员更加高效地访问数据库。
MyBatis的工作原理主要包括以下几个方面：SQL映射文件、SqlSessionFactory、SqlSession以及Executor。
SQL映射文件是MyBatis框架的核心之一。
开发人员可以在SQL映射文件中编写SQL语句，并将这些SQL语句与Java方法进行映射。
这样，开发人员就可以通过调用Java方法来执行对应的SQL语句，实现数据的增删改查操作。
SqlSessionFactory是MyBatis框架的另一个核心组件。
SqlSessionFactory负责创建SqlSession对象，SqlSession对象则用于执行SQL语句。
SqlSessionFactory是一个单例对象，一般在应用启动时进行初始化，并在整个应用生命周期中保持不变。
通过SqlSessionFactory，开发人员可以获取SqlSession对象，从而执行对数据库的操作。
接着，SqlSession是MyBatis框架中的一个接口，它提供了对数据库的操作方法，如insert、update、delete、select等。
SqlSession 对象是线程不安全的，因此在使用完毕后需要手动关闭，以避免资源泄漏。
开发人员可以通过SqlSession对象执行SQL语句，并获取执行结果。
Executor是MyBatis框架的执行器，负责执行SQL语句并返回结果。
Executor有两种实现方式：SimpleExecutor和ReuseExecutor。
SimpleExecutor每次执行SQL语句都会创建新的Statement对象，而ReuseExecutor会复用Statement对象，提高了SQL执行的效率。
开发人员可以在MyBatis的配置文件中配置使用哪种Executor。
总的来说，MyBatis框架通过SQL映射文件、SqlSessionFactory、SqlSession以及Executor等组件，实现了对数据库的访问和操作。
mybatis基本工作原理
MyBatis是一种基于Java语言的持久化框架，可以帮助开发人员更轻松地管理数据库操作。
它的基本工作原理如下：
1. 定义映射文件：MyBatis通过XML或注解来定义数据库表和Java对象之间的映射关系。
2. 加载配置文件：MyBatis需要加载一个配置文件来告诉它如何去连接数据库和使用映射文件。
3. 创建SqlSessionFactory：SqlSessionFactory是MyBatis的核心接口之一，它负责创建SqlSession对象。
4. 创建SqlSession：SqlSession是MyBatis的另一个核心接口，它负责执行SQL语句并返回结果。
5. 执行SQL语句：SqlSession会根据映射文件中的信息，执行对应的SQL语句。
执行后，将结果映射到对应的Java对象中，并返回给调用方。
6. 关闭SqlSession：最后，需要关闭SqlSession以释放资源。
MyBatis的基本工作原理就是这样，它通过映射文件来定义Java 对象和数据库表之间的映射关系，并通过SqlSession接口来执行SQL 语句。
同时，MyBatis还提供了很多方便的特性，如动态SQL、缓存等，可以大大提高开发效率和应用程序的性能。
- 1 -。
mybatis 事务原理MyBatis事务原理MyBatis是一个流行的Java持久化框架，它提供了一种简化数据库访问的方式，并支持事务管理。
在MyBatis中，事务是一组数据库操作，要么全部成功提交，要么全部回滚。
MyBatis提供了两种事务管理方式：编程式事务管理和声明式事务管理。
1. 编程式事务管理：在编程式事务管理中，应用程序代码负责显式地开启、提交或回滚事务。
MyBatis通过SqlSession对象提供了一些与事务相关的方法，包括：- `openSession()`方法：用于获取一个SqlSession对象，可以从中开启事务。
- `commit()`方法：提交事务，将数据库操作持久化到数据库中。
- `rollback()`方法：回滚事务，撤销当前事务中的所有操作。
- `close()`方法：关闭SqlSession对象。
使用编程式事务管理时，需要手动调用这些方法，控制事务的边界。
例如： ```javaSqlSession sqlSession = sqlSessionFactory.openSession();try {// 开启事务sqlSession.beginTransaction();// 执行数据库操作sqlSession.insert("insertUser", user);sqlSession.update("updateOrder", order);// 提交事务mit();} catch (Exception e) {// 回滚事务sqlSession.rollback();} finally {// 关闭SqlSessionsqlSession.close();}```2. 声明式事务管理：在声明式事务管理中，事务的边界由框架自动划定，应用程序代码无需关注事务的具体操作。
可以借助Spring框架的事务管理支持来实现声明式事务管理。
