Mybatis第一天课堂笔记_luhaoyang

合集下载

20150317mybatis课堂笔记

mybatis第一天mybatis基础知识教学思路：整个教学思路以订单商品的项目作为驱动。

mybatis第一天：基础知识mybatis是一个java持久层框架，java中操作关系型数据库用的是jdbc，mybatis是对jdbc的一个封装。

1、从一个jdbc程序开始，通过jdbc 程序找到使用原生态的jdbc开发程序，存在哪些问题？？通过学习mybatis，mybatis是如何解决这些问题。

2、mybatis的架构（重点）3、mybatis的入门程序（重点）实现用户的查询、添加、修改、删除。

4、mybatis开发dao的两种方法。

（重点）原始的dao开发方式（dao接口和dao实现都需要编写）mapper代理方式（只需要写dao接口）5、输入映射类型和输出映射类型。

6、动态sql第二天：高级知识高级映射查询（一对一、一对多、多对多）（重点）查询缓存延迟加载mybatis和spring整合（重点）mybatis逆向工程。

1开发环境jdk1.7.0_72eclipse：eclipse-3.7-indigomysql：mysql5.11.1创建数据库先导入sql_table.sql，再导入sql_data.sql(记录系统的初始化数据)通常需要提供初始化数据的数据库脚本。

2jdbc编程中问题企业开发中，根据项目大小、特点进行技术选型，jdbc操作数据库时效率是很高的，jdbc也是技术选型的参考。

2.1jdbc程序参考教案需要数据库的驱动包：上边是mysql的驱动，下边是oracle的驱动。

2.2jdbc问题总结1、数据库连接频繁的创建和关闭，缺点浪费数据库的资源，影响操作效率设想：使用数据库连接池2、sql语句是硬编码，如果需求变更需要修改sql，就需要修改java代码，需要重新编译，系统不易维护。

设想：将sql语句统一配置在文件中，修改sql不需要修改java代码。

3、通过preparedStatement向占位符设置参数，存在硬编码（参数位置，参数）问题。

MYBATIS第一天课堂笔记

mybatis 第一天 mybatis的基础知识
课程安排：
mybatis和springmvc通过订单商品案例驱动
第一天：基础知识（重点，内容量多）
对原生态jdbc程序（单独使用jdbc开发）问题总结
mybatis框架原理（掌握）
mybatis入门程序
用户的增、删、改、查
mybatis开发dao两种方法：
原始dao开发方法（程序需要编写dao接口和dao实现类）（掌握） mybaits的mapper接口（相当于dao接口）代理开发方法（掌握） mybatis配置文件SqlMapConfig.xml
mybatis核心：
mybatis输入映射（掌握）
mybatis输出映射（掌握）
mybatis的动态sql（掌握）
第二天：高级知识
订单商品数据模型分析
高级结果集映射（一对一、一对多、多对多）
mybatis延迟加载
mybatis查询缓存（一级缓存、二级缓存）
mybaits和spring进行整合（掌握） mybatis逆向工程
1 对原生态jdbc程序中问题总结
1.1 环境
java环境：jdk1.7.0_72
eclipse：indigo
mysql：5.1
1.2 创建mysql数据
导入下边的脚本：。

mybatis 知识点

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 映射文件，如下所示：<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核心技术全解与项目实战》读书笔记1. 第一章 MyBatis简介本章主要介绍了MyBatis的基本概念、特点和优势，以及其在Java企业级应用开发中的重要作用。

MyBatis是一个优秀的持久层框架，它将SQL语句与Java对象映射(POJO)相结合，使得开发人员可以更加方便地操作数据库。

MyBatis的主要目标是简化数据库操作，提高开发效率，同时也提供了良好的数据封装和安全性。

SqlSessionFactory:用于创建SqlSession对象，SqlSession是MyBatis中执行SQL语句的核心接口。

SqlSession:用于执行SQL语句的会话对象，可以通过它来执行增删改查等操作。

Mapper:映射器接口，用于定义SQL语句和Java对象之间的映射关系。

Configuration:MyBatis的全局配置类，用于配置各种属性，如缓存策略、事务管理等。

插件：MyBatis的插件机制，允许开发者自定义拦截器、类型处理器等组件，以实现对MyBatis的功能扩展。

灵活性：MyBatis支持多种存储结构，如JDBC、ODBC、JNDI等，同时还支持自定义类型处理器和插件，使得MyBatis能够满足各种复杂的数据库操作需求。

易用性：MyBatis提供了简洁的XML映射文件来描述SQL语句和Java对象之间的映射关系，使得开发者无需编写复杂的SQL语句即可完成数据库操作。

性能优化：MyBatis通过一级缓存和二级缓存机制来提高查询性能，同时还支持动态SQL、分页查询等功能，使得MyBatis能够在高并发环境下保持良好的性能表现。

安全性：MyBatis提供了严格的权限控制机制，可以限制不同用户对数据库的操作权限，保证数据的安全性。

1.1 MyBatis概念及特点MyBatis是一个优秀的持久层框架，它支持定制化SQL、存储过程以及高级映射。

相比于传统的数据访问技术，MyBatis让开发者能够更加直接地与数据库交互，从而有效地避免了大量繁琐的SQL语句编写工作。

mybatis第一天课堂笔记资料讲解

m y b a t i s第一天课堂笔记mybatis 第一天 mybatis的基础知识课程安排：mybatis和springmvc通过订单商品案例驱动第一天：基础知识（重点，内容量多）对原生态jdbc程序（单独使用jdbc开发）问题总结mybatis框架原理（掌握）mybatis入门程序用户的增、删、改、查mybatis开发dao两种方法：原始dao开发方法（程序需要编写dao接口和dao实现类）（掌握）mybaits的mapper接口（相当于dao接口）代理开发方法（掌握）mybatis配置文件SqlMapConfig.xmlmybatis核心：mybatis输入映射（掌握）mybatis输出映射（掌握）mybatis的动态sql（掌握）第二天：高级知识订单商品数据模型分析高级结果集映射（一对一、一对多、多对多）mybatis延迟加载mybatis查询缓存（一级缓存、二级缓存）mybaits和spring进行整合（掌握）mybatis逆向工程1对原生态jdbc程序中问题总结1.1环境java环境：jdk1.7.0_72eclipse：indigomysql：5.11.2创建mysql数据导入下边的脚本：sql_table.sql：记录表结构sql_data.sql：记录测试数据，在实际企业开发中，最后提供一个初始化数据脚本1.3jdbc程序使用jdbc查询mysql数据库中用户表的记录。

创建java工程，加入jar包：数据库驱动包（mysql5.1）上边的是mysql驱动。

下边的是oracle的驱动。

程序代码：1.4问题总结1、数据库连接，使用时就创建，不使用立即释放，对数据库进行频繁连接开启和关闭，造成数据库资源浪费，影响数据库性能。

设想：使用数据库连接池管理数据库连接。

2、将sql语句硬编码到java代码中，如果sql 语句修改，需要重新编译java代码，不利于系统维护。

设想：将sql语句配置在xml配置文件中，即使sql变化，不需要对java代码进行重新编译。

MyBatis新手入门

第一章用MyBatis实现增删查改第一步下载打开http://mybatis.github.io/看这里使劲点它！跳转到这个页面再使劲点它就会跳转到github仓库，看到这个界面注意：这里只是mybatis的一些发表信息，点一下它终于来到这个下载地方了，特么的好累动一下你的手指，滚动到最下方点它转到到这里看，出来了吧，找的我那么辛苦，当时恨不得点烂它！解压出来，进去看到第二步搭建和配置这个目录结构就对了，用MyEclipse创建一个Web Project，把mybatis-3.2.8.jar拷贝粘贴到自己创建的MyEclipse项目中的lib下（不知道哪里是MyEclipse项目的lib文件夹的人建议转行别写代码了），我的结构是这样的为什么里面还多了一个mysql-connector-java-5.1.6-bin.jar呢？它是干嘛用的呢？我顺手拷贝进去的，看到这个mysql的jdbc驱动大家应该明白我要测试用的数据库是mysql，自己随意，用什么数据库就拷贝什么驱动。

MyBatis里面是没有的，网上多得是，自己要什么驱动就去下载什么驱动。

可以动手了动手去src下创建3个包，我是这样子的我个人比较喜欢收缩着看，比较简洁，看这里点它- Package Presentation – Hierarchial,就变成这样这样命名有自己的含义，我打算inter包专门放接口（Interface），model包放Bean,test包放测试类。

创建一个叫mybatis的数据库，在里面创建一个表叫user，表user的结构如下懒人请复制：CREATE TABLE IF NOT EXISTS `user` (`id` int(11) NOT NULL AUTO_INCREMENT,`userName` varchar(50) DEFAULT NULL,`userAge` int(11) DEFAULT NULL,`userAddress` varchar(200) DEFAULT NULL,PRIMARY KEY (`id`)) ENGINE=InnoDB DEFAULT CHARSET=utf8 AUTO_INCREMENT=7 ; 顺便弄写数据进去INSERT INTO `user` (`id`, `userName`, `userAge`, `userAddress`) VALUES (1, '余小龙', 10, '人民广场'),(3, 'lisiwei', 80, '中山大学南方学院123'),(5, '麦家潮', 20, '中国'),(6, '周杰伦', 30, '北京');在包model下创建一个User类，根据数据库表在类中创建相应的成员变量，如下：private int id;private String userName;private String userAge;private String userAddress;右击鼠标——Source——Generate Getter and Setter点全选——OK，变成这样子创建完User类，接下来在同一个包（model）下创建一个User.xml文件，填以下内容：头部的声明代码太麻烦？懒人请复制<!DOCTYPE mapper PUBLIC"-////DTD Mapper 3.0//EN" "/dtd/mybatis-3-mapper.dtd">接下来,定义一个查询方法，根据用户ID查询User表中的某一条记录，在<mapper></mapper>里面写<select>标签是MyBatis的查询标签，id=”selectUserById”随便改，但是，要记住哦，等下会用到的parameterType是参数类型的意思，resultType是结果类型的意思，把查询的结果封装成一个User对象，有人问过我，为什么我经常在一些表名两边加上反冒号`，如：,知道的请跳过以下内容：在mysql中，有些关键字是不能用的，例如order、database、table等等，我在表名user两端加上`，作用就是告诉mysql，我写这个user不是想要调用mysql关键字，这个user仅仅代表我自己定义的数据库表名，mysql的关键字太多，我不能确定user是不是其中之一，不想去查，所以加上``了事，那么mysql 就不管user是不是mysql关键字，就算不小心user真的是关键字，也当user 不起作用，忽略它。

mybatis

关于MyBatis的笔记1.SQL的动态查询1. 动态sql动态sql是mybatis中的一个核心，什么是动态sql？动态sql即对sql语句进行灵活操作，通过表达式进行判断，对sql进行灵活拼接、组装。

就拿上一篇博文中对用户的综合查询一例来说：假如这个user是null咋整？或者user.sex或者ername为null呢？所以更严谨的做法应该是在执行这个语句之前要先进行判断才对，确保都不为空，那么我再去查询。

这就涉及到了mybatis中的动态sql了。

在mybatis中，动态sql可以使用标签来表示，这很类似于jstl表达式，我们可以将上面的sql语句改成动态sql，如下：上面的代码很好理解，主要就是加了一些判断，条件不为空，才进行查询条件的拼接，让mybatis动态的去执行。

那么在测试代码中，我们可以故意的将user.sex不赋初值，就可以看到查询的结果是不一样的。

2. sql片段那么现在还有个问题，如果好几个statement都需要这样做，而且动态sql 部分都一样，这就会导致一些代码的重复，所以如果遇到这种情况，我们就应该抽取，动态sql也可以抽取，我们可以将动态的这部分sql抽取成sql片段，然后在具体的statement中引用进来即可。

如下：id是给该sql片段起个名字而已，内部就是上面的where动态部分，然后我们将上面原来的动态部分改成对这个sql片段的引用，如下：3. foreach还有个问题：如果我们要向sql传递数组或List该咋整呢？mybatis使用的是foreach解析。

为了模拟这个场景，我们将上面的查询改成多个id查询，有两种查询方式：∙1∙2∙1∙2首先有一点很明确，既然要使用多个id进行查询，那么多个id肯定要作为参数传进来，所以存储多个id的List需要放到UserQueryVo中作为一个属性，这点很好理解，所以我们先在UserQueryVo中增加这个属性：然后我们修改UserMapper.xml中的sql片段（还是写在sql片段中），如下：下面简单介绍一下这个foreach中相关属性的作用：collection：指定输入对象中的集合属性，这里就是这个ids。

Parch系列 - MyBatis学习笔记

接池的环境配置。mappers 元素是包含所有 mappe（映射器）的列表，这些 mapper 的 XML 文件包含 SQL 代码和映射定义信息。
3，不使用 XML 构建 SqlSessionFactory
从 Java 程序而非 XML 文件中直接创建配置实例，或创建配置构建器： DataSource dataSource = BlogDataSourceFactory.getBlogDataSource(); TransactionFactory transactionFactory = new JdbcTransactionFactory(); Environment environment = new Environment("development", transactionFactory, dataSource);
（3）XML 配置文件介绍 XML 配置文件包含对 MyBatis 系统的核心设置，包含获取数据库连接实例的数据源和决定事务范
围和控制的事务管理器。示例： <?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE configuration PUBLIC "-////DTD Config 3.0//EN" &ig.dtd"> <configuration> <environments default="development"> <environment id="development"> <transactionManager type="JDBC"/> <dataSource type="POOLED"> <property name="driver" value="${driver}"/> <property name="url" value="${url}"/> <property name="username" value="${username}"/> <property name="password" value="${password}"/> </dataSource> </environment> </environments> <mappers> <mapper resource="org/mybatis/example/BlogMapper.xml"/> </mappers> </configuration> XML 头部的声明，需要用来验证 XML 文档正确性。environment 元素体中包含对事务管理和连

Mybatis知识点汇总

Mybatis知识点汇总MyBatis是一款优秀的持久层框架，它支持定制化SQL、存储过程以及高级映射。

MyBatis避免了几乎所有的JDBC代码和手动设置参数以及获取结果集。

MyBatis可以使用简单的XML或注解进行配置和原始映射，将接口和Java的POJOs （Plain Old Java Objects，普通的Java对象）映射成数据库中的记录。

以下是MyBatis的主要知识点汇总：1.基础概念：o SQL映射文件：MyBatis使用SQL映射文件（或称为Mapper文件）来定义SQL语句，每个映射文件对应数据库中的一张表。

o映射器：映射器是MyBatis的核心，它负责将方法调用映射到SQL语句，并且将结果集映射回Java对象。

o注解：MyBatis支持使用注解来配置SQL语句，这可以减少XML 配置的使用。

2.配置：o mybatis-config.xml：这是MyBatis的主配置文件，其中包含了数据源、事务管理器等信息。

o别名：MyBatis中可以使用别名来简化全限定类名，如使用别名可以使代码更简洁易读。

o配置元素：包括<settings>、<typeAliases>、<environments>等元素。

3.SQL映射：o select：用于执行查询语句，并返回结果集。

o insert：用于插入新的记录。

o update：用于更新已存在的记录。

o delete：用于删除记录。

4.结果映射：o resultMap：用于定义结果集的映射规则，可以将结果集的列映射到Java对象的属性。

o association：用于定义复合主键或是关联其他表的数据。

o collection：用于表示一个对象中有多个集合属性。

5.动态SQL：o if：用于判断条件是否满足，根据条件来决定是否执行某段SQL 语句。

o choose/when/otherwise：类似于Java中的switch语句，根据条件选择执行不同的SQL语句。

Mybatis学习笔记（详细）

Mybatis学习笔记（详细）介绍三层架构：视图层、业务逻辑层、持久层mybatis框架：执⾏数据库操作，完成对数据库的增删改查，封装了jdbcmapper映射，将表中数据转为⼀个Java对象，⼀个表对应⼀个接⼝Mybatis实战使⽤⽅式：直接获取SqlSession，根据sql id执⾏sql⾃定义dao接⼝实现类，使⽤接⼝实现类对象操作（会有⼤量重复代码）使⽤mybatis的代理对象：使⽤getMapper()获取dao对象，直接执⾏⽅法访问数据库。

mybatis框架使⽤步骤：定义实体类定义接⼝定义mapper⽂件定义主配置⽂件：1.数据源，2.mapper⽂件位置使⽤SqlSessionFactoryBuild创建SqlSessionFactory并传⼊xml配置⽂件，通过Factory创建SqlSession，通过SqlSession执⾏⼀系列数据库操作mybatis传递参数dao⽅法有⼀个简单类型，直接使⽤#{任意字符}多个参数：使⽤@Param("xx")指明xml解析的名字使⽤Java对象，mapper中使⽤对象的属性#和$的区别#是占位符，使⽤PreparedStatement执⾏sql，效率⾼表⽰列的值，⼀般放在等号右侧使⽤$是字符串连接，使⽤Statement，效率低，有sql注⼊的风险$⼀般是替换表名、列名mybatis封装sql的执⾏结果标签中的resultType，指明封装结果的对象，可以使⽤别名（需要定义，可以复⽤）标签中的resultMap，指明数据库列名与Java对象属性的对应关系（需要定义，可以复⽤），或者使⽤sql语句的as给列取别名like：直接使⽤#{xxx}，传递参数给mapper动态sql<where>：⾥⾯是if，条件满⾜加⼊where，并去除多余的and，or等关键字<if>：如果条件满⾜，加⼊后⾯的sql语句<foreach>：list或arraymybatis主配置⽂件：配置项有顺序<properties resource=xxx>配置.properties：，使⽤${}引⽤<settings>中可以配置⽇志<typeAliases>配置别名：<typeAlias>给某个类型，<package>把⼀个包中的类作为别名（如果有名称相同的类会有冲突）<plugins>配置插件<environments>配置<dataSource>mapper⽂件的位置：<mapper resource>单个指定，<package name>指定某个包（要求名称与接⼝名相同，并在同⼀个包下）PageHelper分页插件加⼊依赖在执⾏查询前调⽤PageHelper的静态⽅法即可代码pom<?xml version="1.0" encoding="UTF-8"?><project xmlns="/POM/4.0.0"xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/POM/4.0.0 /xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><groupId>com.bingmous</groupId><artifactId>mybatis</artifactId><version>1.0-SNAPSHOT</version><properties><piler.source>11</piler.source><piler.target>11</piler.target></properties><dependencies><dependency><groupId>org.mybatis</groupId><artifactId>mybatis</artifactId><version>3.5.1</version></dependency><dependency><groupId>org.postgresql</groupId><artifactId>postgresql</artifactId><version>42.2.19</version></dependency><dependency><groupId>com.github.pagehelper</groupId><artifactId>pagehelper</artifactId><version>5.2.1</version></dependency><dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId><version>1.18.20</version></dependency><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.13</version><scope>test</scope></dependency></dependencies><build><resources><resource><directory>src/main/java</directory><includes><include>**/*.properties</include><include>**/*.xml</include></includes><filtering>false</filtering></resource></resources></build></project>Mybatis主配置⽂件<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE configurationPUBLIC "-////DTD Config 3.0//EN""/dtd/mybatis-3-config.dtd"><configuration><properties resource="jdbc.properties"></properties><settings><setting name="logImpl" value="STDOUT_LOGGING"/> </settings><typeAliases></typeAliases><plugins><plugin interceptor="com.github.pagehelper.PageInterceptor"></plugin></plugins><environments default="development"><environment id="development"><transactionManager type="JDBC"/><dataSource type="POOLED"><property name="driver" value="${jdbc.drive}"/><property name="url"value="${jdbc.url}"/><property name="username" value="${ername}"/><property name="password" value="${jdbc.password}"/></dataSource></environment></environments><mappers><mapper resource="com/bingmous/dao/StudentDao.xml"/></mappers></configuration>jdbc配置⽂件jdbc.drive=org.postgresql.Driverjdbc.url=jdbc:postgresql://10.194.227.212:5432/zztestername=postgresjdbc.password=hik12345+操作student表的接⼝/*** 操作student表的接⼝* created by Bingmous on 2021/7/6 9:59*/public interface StudentDao {List<Student> selectStudents();//单个简单参数Student selectStudentById(Integer id);//多个简单参数List<Student> selectStudentByNameAndAge(@Param("name") String name, @Param("age") Integer age);//使⽤对象传递参数List<Student> selectStudentByNameAndAge2(Student student);//likeList<Student> selectStudentLike(String name);int insertStudent(Student student); //插⼊数据// List<Student> selectDynamicSQL(Student student);// List<Student> selectDynamicSQL(@Param("name") String name,// @Param("age") Integer age);List<Student> selectDynamicSQL(@Param("age") Integer age);List<Student> selectDynamicSQL2(ArrayList<Student> list);}对应的mybatis配置⽂件<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE mapperPUBLIC "-////DTD Mapper 3.0//EN""/dtd/mybatis-3-mapper.dtd"><mapper namespace="com.bingmous.dao.StudentDao"><resultMap id="studentMap" type="com.bingmous.beans.Student"><id column="id" property="id"></id><result column="name" property="name"></result><result column="email" property="email"></result><result column="age" property="age"></result></resultMap><select id="selectStudents" resultMap="studentMap">select id, name, email, age from student order by id</select><select id="selectStudentById" resultType="com.bingmous.beans.Student">select id, name, email, age from student where id = #{id}</select><select id="selectStudentByNameAndAge" resultType="com.bingmous.beans.Student">select id, name, email, age from student where name = #{name} or age = #{age}</select><select id="selectStudentByNameAndAge2" resultType="com.bingmous.beans.Student">select id, name, email, age from student where name = #{name} or age = #{age}</select><select id="selectStudentLike" resultType="com.bingmous.beans.Student"><include refid="selectFragment"></include> where name like #{name}</select><insert id="insertStudent">insert into student(id, name, email, age)values (#{id}, #{name}, #{email}, #{age})</insert><select id="selectDynamicSQL" resultType="com.bingmous.beans.Student">select id, name, email, age from student<where><if test="age > 0">or age > 0</if></where></select><select id="selectDynamicSQL2" resultType="com.bingmous.beans.Student"><include refid="selectFragment"></include> where id in<foreach collection="list" item="stu" open="(" close=")" separator=",">#{stu.id}</foreach></select><sql id="selectFragment">select id, name, email, age from student</sql></mapper>接⼝实现类测试/*** created by Bingmous on 2021/7/6 14:14*///public class StudentDaoImpl implements StudentDao {// @Override// public List<Student> selectStudents() {// SqlSession sqlSession = MybatisUtils.getSqlSession();// List<Student> list = sqlSession.selectList("com.bingmous.dao.StudentDao.selectStudents"); // mit();// sqlSession.close();// return list;// }//// @Override// public int insertStudent(Student student) {// SqlSession sqlSession = MybatisUtils.getSqlSession();// int nums = sqlSession.insert("com.bingmous.dao.StudentDao.insertStudent", student);// mit();// sqlSession.close();// return nums;// }////}获取连接的⼯具类/*** created by Bingmous on 2021/7/6 13:51*/public class MybatisUtils {private static SqlSessionFactory factory = null; //重量级对象，⼀个项⽬只有⼀份就可以了static {InputStream is = null;is = Resources.getResourceAsStream("mybatis.xml");factory = new SqlSessionFactoryBuilder().build(is);} catch (IOException e) {e.printStackTrace();}}//获取sessionpublic static SqlSession getSqlSession(){if (factory != null) {return factory.openSession();}return null;}}student实体类/*** created by Bingmous on 2021/7/6 9:56*/@Data@AllArgsConstructor@NoArgsConstructorpublic class Student {private Integer id;private String name;private String email;private Integer age;/*** 如果没有⽆参构造⽅法，Mybatis会调⽤全参构造⽅法* 如果没有⽆参，没有全参，会调⽤其他有参，但必须只有⼀个*/// public Student(Integer id, String name) {// this.id = id;// = name;// System.out.println("构造⽅法被调⽤了。

什么是Mybatis？最全的Mybatis知识点整合！

什么是Mybatis？最全的Mybatis知识点整合！什么是Mybatis？最全的Mybatis知识点整合！⼀、什么是Mybatis？MyBatis是⼀个半ORM（对象关系映射）框架，它内部封装了JDBC，开发时只需要关注SQL语句本⾝，不需要花费精⼒去加载驱动、创建连接、创建Statement等繁杂过程。

程序员直接编写原⽣态sql，可以严格控制sql执⾏性能，灵活度⾼。

Mybatis可以使⽤XML或注解来配置和映射原⽣信息，将POJO映射成数据库中的记录，避免⼏乎所有JDBC代码和⼿动设置参数以及获得结果集。

通过xml⽂件或注解的⽅式将要执⾏的各种statement配置起来，并通过java对象和statement中sql的动态参数进⾏映射⽣成最终执⾏的sql语句，最后由Mybatis框架执⾏sql并将返回结果映射为java对象并返回。

（从执⾏sql到返回result的过程）。

⼆、Mybatis的优点基于SQL语句编程，相当灵活，不会对应⽤程序或者数据库的现有设计造成任何影响，SQL写在XML⽂件中，接触SQL与程序代码的耦合，便于统⼀管理；提供XML便签，⽀持编写动态SQL语句，并可以重⽤。

与JDBC相⽐，减少了50%以上的代码量，消除了JDBC⼤量冗余的代码，不需要⼿动开关连接。

很好的与各种数据库兼容（因为MyBatis使⽤JDBC来连接数据，所以只要JDBC⽀持数据库MyBatis都⽀持）。

能够与Spring框架很好的集成。

提供映射标签，⽀持对象与数据库的ORM字段关系映射；提供对象关系映射标签，⽀持对象关系组件维护。

三、Mybatis框架的缺点SQL语句的编写⼯作量较⼤，尤其当字段多，关联表多时，对开发⼈员编写SQL语句的功底有⼀定要求。

SQL语句依赖数据库，导致数据库移植性差，不能随意更换数据库。

四、MyBatis框架使⽤场合MyBatis专注于SQL本⾝，是⼀个⾜够灵活的DAO层解决⽅案。

My batis使用笔记

My batis使用笔记一、搭建Mybatis环境1、mybatis相应的jar包加入到项目中，详情见pom.xml2、把mybatis-config.xml主配置文件放入项目中的classPath路径3、编写一个model类，Person类4、编写dao层接口PersonDao，编写dao层映射文件，PersonDao5、把映射文件加入到主配置文件6、把log4j.properties文件放入到项目中的classPath路径，日志级别设置成debug，不然不会显示SQL语句7、编写mybatis API进行测试二、jdbcType取值java类型jdbcTypeint INTEGERfloat FLOATdouble DOUBLEString(固定长度)CHACHARRString(实际长度)VARDate(年月日)DATEDate(年月日时分秒)TIMESTAMP三、parameterType、parameterMap、resultType、resultMapparameterType属性：参数类型，一般写类的完整路径parameterMap属性：参数映射，参数类的属性名与SQL语句中#{变量}不一样时，需要映射resultType属性：结果集类型，查询结果集中的字段名与结果集类中的属性名相同，就可以使用resultMap属性：结果集映射，把结果集与类中的属性一一对应，一个类对应一个结果集，一个属性对应一个结果集字段四、一级缓存*****1、什么是一级缓存SqlSessionFactory创建SQLSession是分配的一片内存空间，用来缓存查询过的数据，SQLSession管理，又称为：session缓存2、生命周期SqlSessionFactory创建SQLSession一级缓存被分配，SQLSession被close()时，一级缓存被回收3、一级缓存的特点*****a、一级缓存，默认是开启的，直接使用，b、session与session之间不能共享c、一级缓存只认相同的SQL语句，缓存的不是对象，相同的SQL语句只会发一次d、添加、修改、的数据不会在一级缓存中，再次查询还是会发生SQL语句e、一级缓存由session管理，通过session.clearCache()方法清除缓存1、hibernate一级缓存存的是单个对象，mybatis存的是一组数据2、hibernate查询首先会在一级缓存中拿，如果没有就发送SQL语句到数据库查询mybatis只认相同的SQL语句,将数据存入一级缓存的SQL语句如果与将要执行的SQL语句相同，就直接调用一级缓存里面的数据，不再发送SQL语句，如果不同将发送SQL 查询，mybatis只认相同的SQL语句3、hibernate中被session操作过的对象，一定会存一份到一级缓存中，除非是session被清除或关闭mybatis添加、修改、的数据不会在一级缓存中4、hibernate中关闭或清除缓存有4种方式sessio.close()、sessio.clear()、sessio.evict(Object)、sessio.flush() mybatis中关闭或清除缓存只有2种方式SqlSession.close(),SqlSession.clear();五、多表映射*****1、对方是一，在resultMap标签中使用<association></association>标签association标签常用属性：deptid属性：类中外键属性column属性：外键字段resultMap属性：指向外键类的映射2、对方是多，在resultMap标签中使用标签<collection></collection>标签collection标签常用属性：property属性：另一端在本类中的属性名esultMap属性：执行另一个类的结果集映射六、延迟加载（了解）1、在mybatis-config.xml中配置开启懒加载，配置如下<settings><setting name="lazyLoadingEnabled" value="true"/><setting name="aggressiveLazyLoading" value="false"/></settings>2、在多表映射时、关联表的标签使用select属性，不要使用resultMap属性<association property="deptid" column="f_departId" select="findDeparById"/><collection property="emps" select=""/>3、select属性中写一个方法的名字，关联对应表时会执行方法对应的SQL语句，如下：dao接口：public Depart findDeparById(int depId);mapper.xml<select id="findDeparById" resultMap="departMap">select t.f_id as f_dapartId,t.f_name as f_depName from t_depart t where t.f_id=#{depId}</select>七、#{}与${}的区别*****1、#{}是预编译的，${}是字符串替换字符2、#{}处理时使用？代替，PreparedStatement的set方法来赋值${}处理时替换成变量的值3、#{}可以防止sql语句注入，安全性高${}是字符串替换符，会造成SQL语句注入，不安全八、mybatis一级缓存与hibernate一级缓存相同点与不同点相同点：1、一级缓存都是默认开启自动死亡2、一级缓存都是session级别，由session管理3、生命周期一样，session被创建时分配一级缓存空间，session被close时一级缓存被回收4、session与session之间不能共享一级缓存5、查询时都会以一级缓存优先，一级缓存中没有才发送SQL语句到数据库查询不同点：1、hibernate一级缓存缓存的是session操作过的对象，如果查询一组数据也是拆成单个对象存储在一级缓存中mybatis一级缓存，缓存的是查询过的数据映射对象，相同的SQL只会查询一次2、hibernate一级缓存insert 、update、delectable、select操作过的对象都会在一级缓存中存储一份mybatis只有selete操作过的数据会在一级缓存中存储一份3、hibernate一级缓存不受事务影响，事务提交或回滚都不影响一级缓存中存储的对象mybatis一级缓存受事务影响，事务提交或回滚会清除一级缓存4、hibernate管理缓存方式：close回收一级缓存clear清除一级缓存evict清除单个对象flush刷新一级缓存，同步一级缓存与数据库mybatis管理缓存方式：close回收一级缓存clearCache清除一级缓存。

mybatis学习笔记1

第一章回顾jdbc开发1）优点：简单易学,上手快,非常灵活构建SQL，效率高2）缺点：代码繁琐，难以写出高质量的代码（例如：资源的释放，SQL注入安全性等）开发者既要写业务逻辑，又要写对象的创建和销毁，必须管底层具体数据库的语法（例如：分页）。

3）适合于超大批量数据的操作，速度快第二章回顾hibernate单表开发1）优点：不用写SQL，完全以面向对象的方式设计和访问，不用管底层具体数据库的语法，（例如：分页）便于理解。

2）缺点：处理复杂业务时，灵活度差, 复杂的HQL难写难理解，例如多表查询的HQL语句3）适合于中小批量数据的操作，速度慢第三章什么是mybatis，mybatis有什么特点1）基于上述二种支持，我们需要在中间找到一个平衡点呢？结合它们的优点，摒弃它们的缺点，这就是myBatis，现今myBatis被广泛的企业所采用。

2）MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code，并且改名为MyBatis 。

2013年11月迁移到Github。

3）iBATIS一词来源于“internet”和“abatis”的组合，是一个基于Java的持久层框架。

iBATIS提供的持久层框架包括SQL Maps和Data Access Objects（DAO）4）jdbc/dbutils/springdao，hibernate/springorm，mybaits同属于ORM解决方案之一第四章mybatis快速入门1）创建一个mybatis-day01这么一个javaweb工程或java工程2345678第五章mybatis工作流程1）通过Reader对象读取src目录下的mybatis.xml配置文件(该文本的位置和名字可任意) 2）通过SqlSessionFactoryBuilder对象创建SqlSessionFactory对象3）从当前线程中获取SqlSession对象4）事务开始，在mybatis中默认5）通过SqlSession对象读取StudentMapper.xml映射文件中的操作编号，从而读取sql语句6）事务提交，必写7）关闭SqlSession对象，并且分开当前线程与SqlSession对象，让GC尽早回收第六章mybatis配置文件祥解（mybatis.xml）1第七章mybatis映射文件祥解(StudentMapper.xml)1）以下是mybatis.xml文件，提倡放在src目录下，文件名任意第八章MybatisUtil工具类的作用1）在静态初始化块中加载mybatis配置文件和StudentMapper.xml文件一次2）使用ThreadLocal对象让当前线程与SqlSession对象绑定在一起3）获取当前线程中的SqlSession对象，如果没有的话，从SqlSessionFactory对象中获取SqlSession对象4第九章基于MybatisUtil工具类，完成CURD操作12第十章分页查询12第十一章动态SQL操作之查询1）查询条件不确定，需要根据情况产生SQL语法，这种情况叫动态SQL 2）参见<<动态SQL—查询.JPG>>第十二章动态SQL操作之更新1）更新条件不确定，需要根据情况产生SQL语法，这种情况叫动态SQL 2）参见<<动态SQL—更新.JPG>>第十三章动态SQL操作之删除1）根据ID删除学生2）参见<<动态SQL—删除.JPG>>第十四章动态SQL操作之插入1）根据条件，插入一个学生2）参见<<动态SQL—插入.JPG>>第十五章jsp/js/jquery/easyui/json + @springmvc + spring + mybatis + oracle开发【员工管理系统--增加员工】。

Mybatis学习笔记

1.MyBatis入门MyBatis 是支持普通SQL 查询，存储过程和高级映射的优秀持久层框架。

MyBatis 消除了几乎所有的JDBC 代码和参数的手工设置以及结果集的检索。

MyBatis 使用简单的XML或注解用于配置和原始映射，将接口和Java 的POJOs（Plan Old Java Objects ，普通的Java对象）映射成数据库中的记录。

●SqlSessionFactory：每一个MyBatis的应用程序都以一个SqlSessionFactory对象的实例为核心。

即创建SqlSessionFactory对象时一般使用单例模式。

而SqlSessionFactory对象的实例可以通过SqlSessionFactoryBuilder对象来获得。

一旦创建了SqlSessionFactory之后，SqlSessionFactoryBuilder就不需要存在了，所以一般使用匿名对象。

SqlSessionFactoryBuilder 对象可以从XML 配置文件，或从Configuration 类的习惯准备的实例中构建SqlSessionFactory 对象。

●SqlSession：每个线程都应该有自己的SqlSession实例，不能够共享，是非线程安全的。

●Session：关闭很重要，应该确保使用finally块来关闭它。

1.1. Mybatis的基本配置文件：1.1.1.配置核心配置文件Configuration.xml：该配置文件中可以得到SqlSessionFactoryBuilder 对象，从而得到SqlSessionFactory对象：<?xml version="1.0"encoding="UTF-8"?><!DOCTYPE configuration PUBLIC"-////DTD Config3.0//EN""/dtd/mybatis-3-config.dtd"><configuration><environments default="development"><environment id="development"><transactionManager type="JDBC"/><dataSource type="POOLED"><property name="driver"value="${driver}"/><property name="url"value="${url}"/><property name="username"value="${username}"/><property name="password"value="${password}"/></dataSource></environment></environments><mappers><mapper resource="com/afei/PersonMapper.xml"/></mappers></configuration>1.1.2.配置PersonMapper.xml文件：该文件与Configuration.xml相关联，并由其调用。

MyBatis 快速入门总结知识点思维导图脑图

MyBatis 简介一款优秀的持久层框架，用于简化JDBD开发javaEE三层架构：表现层，业务层，持久层持久层负责将数据保存到数据库的那一层代码框架一个半成品软件，是一套可重用的，通用的，软件基础代码模型在框架的基础之上构建软件编写更加高效，规范，通用，可扩展JDBC缺点硬编码注册驱动，获取连接sql语句Mybatis免除了几乎所有的JDBC代码以及设置参数和获取结果集的工作操作繁琐手动设置参数手动封装结果集MyBatis简化硬编码---》配置文件注册驱动，获取连接sql语句操作繁琐---》自动完成手动设置参数手动封装结果集MyBatis快速入门创建user表，添加数据创建模块，导入坐标编写MyBatis核心配置文件--->替换连接信息，解决硬编码问题编写SQL映射文件--->统一管理sql语句，解决硬编码问题编码定义POJO类加载核心配置文件，获取SqlSessionFactory对象获取SqlSession对象，执行SQL语句释放资源MyBatis代理开发目的解决原生方式中的硬编码简化后期执行SQL使用Mapper代理方式完成入门案例定义于SQL映射文件同名的Mapper接口，并且将Mapper接口和SQL映射文件放置在同一目录下设置SQL映射文件的namespace属性为Mapper接口全限定名在Mapper接口中定义方法，方法名就是SQL映射文件中sql语句的id，并保持参数类型和返回值类型一致编码通过sqlSession的getMapper方法获取Mapper接口的代理对象调用对应方法完成sql的执行细节如果Mapper接口名称和SQL映射文件名称相同，并在同一目录下，则可以使用包扫瞄的方式简化SQL映射文件的加载MyBatis核心配置文件MyBatis核心配置文件的顶层结构类型别名(typeAliases)<typeAliases><package name="com.itylf.pojo"/></typeAliases>细节配置各个标签时，需要遵守前后顺序配置文件完成增删改查查询查询所有数据实体类属性名和数据库表列明不一致，不能自动封装数据起别名：在sql语句中，对不一样的列名起别名，别名和实体类属性名一样，也可以定义片段，提升复用性resultMap:定义完成不一致的属性名和列名的映射查看详情参数占位符#{}:执行时，会将#{}占位符替换为?将来自动设置参数值${}:拼sql，会存在SQL注入问题使用时机参数传递，都使用#{}如果要对表名，列名进行动态设置，只能使用￥{}进行sql拼接parameterType用于设置参数类型，该参数可以省略sql语句中的特殊字符处理转移字符条件查询动态条件查询从多个条件中选择一个choose(when-类似于case,otherwise-类似于default):选择，类似于java中的switch语句添加修改修改全部字段修改动态字段删除删除一个批量删除MyBatis参数传递接口方法中可以接受各种各样的参数，MyBatis底层对于这些参数进行不同的封装处理方式单个参数POJO类型：直接使用，实体类属性名和参数占位符名称一致Map集合：直接使用，键名和参数占位符名称一致Collection：封装为Map集合List：封装为Map集合Array:封装为Map集合其他类型：直接使用多个参数封装为Map集合将来都使用@Param注解来修改Map集合中默认的键名，并使用修改后的名称来获取值，这样可读性更高注解完成增删改查格式@Select("sql语句")public User selectById;查询：@Select添加：@Insert修改：@Update删除：@Delete注解完成简单功能，配置文件完成复杂功能。

springmvc - day01 - 课堂笔记

springmvc - day01 - 课堂笔记springmvc 入门课程回顾：1、 mybatis的输入映射和输出映射? 输入映射（传递的参数类型）--- parameterType1、基本类型2、 pojo（包装pojo）3、集合? 输出映射（返回的结果类型）--- resultType（一一对应）、resultMap（可以将不一致的列名映射到指定属性上；高级映射（一对一、一对多）） 1、基本类型2、pojo 3、集合2、 mybatis的动态sql? 概念：通过mybatis提供的标签将符合条件的sql语句拼接到一起组成一个完整的sql语句。

? if、where? foreach：list：单个list、对象包装list? sql片段：好处：将公共的sql提取，提高sql的重用性 3、 mybatis的高级映射 ? resultMap1、一对一管理关系：association：property javaType2、一对多关联关系：collection：property ofType4、 mybatis与spring的整合? 目的：将mybatis交给spring管理1、加载外部资源文件2、数据源管理3、管理SQLSessionFactory4、批量代理对象的管理5、 mybatis的逆向工程? 实现原理：通过模板技术：freemarker、velocity ? 学会调用生成的方法（crud） hibernate和mybatis区别： 1、 sql的编写2、维护性（hibernate：传统项目；mybatis：互联网、电商）3、 hibernate：全自动化的orm框架；mybatis不完全的orm框架。

4、 mybatis：对数据库无关性要求更高；#{}、${}mybatis：输入、输出、sql ---- orm课程计划：1、 springmvc介绍和框架原理2、编写入门程序3、 ssm整合（springmvc-sprign-mybatis）4、 springmvc的参数绑定5、 struts2和springmvc的区别1 springmvc介绍和框架原理1.1 介绍springmvc：它是一个表现层框架（web层框架：获取数据，将数据处理完成后响应给用户）。

Mybatis常用知识点

Sql元素用来定义一个可以复用的SQL 语句段，供其它语句调用。

比如：[xml]view plaincopy1.2.<sql id="selectStudentAll">3. SELECT ST.STUDENT_ID,4. ST.STUDENT_NAME,5. ST.STUDENT_SEX,6. ST.STUDENT_BIRTHDAY,7. ST.CLASS_ID8. FROM STUDENT_TBL ST9.</sql>这样，在select的语句中就可以直接引用使用了，将上面select语句改成：[xml]view plaincopy1.2.<select id="getStudent"parameterType="String"resultMap="studentResultMap">3.<include refid="selectStudentAll"/>4. WHERE ST.STUDENT_ID = #{studentID}</select>1.获取自动增长的id在Mybatis Mapper文件中添加属性“useGeneratedKeys”和“keyProperty”，其中keyProperty是Java对象的属性名，而不是表格的字段名。

[html]view plaincopy1.<insert id="insert"parameterType="Spares"eGeneratedKeys="true"keyProperty="id">3. insert into system(name) values(#{name})4.</insert>2.Mybatis执行完插入语句后，自动将自增长值赋值给对象systemBean的属性id。

MyBatis学习笔记（XML配置）

MyBatis学习笔记（XML配置）本⽂是本⼈在学习MyBatis过程中对于⼀些知识点的⼀些⼩总结，由于本⼈能⼒有限，若有不对的还望指正 1、快速开始⾸先要从xml中获得SqlSessionFactory，再从SqlSessionFactory获得SqlSession，代码如下：public class JavaDemo {//获得SqlSessionFactorypublic static SqlSessionFactory getSqlFactory() {InputStream inputStream=null;try {String resource = "mybatis-config.xml";inputStream = Resources.getResourceAsStream(resource);return new SqlSessionFactoryBuilder().build(inputStream);} catch (IOException e) {e.printStackTrace();} finally {try {if(inputStream!=null)inputStream.close();} catch (IOException e) {e.printStackTrace();}}return null;}@Testpublic void test() {SqlSessionFactory sqlFactory = JavaDemo.getSqlFactory();SqlSession sqlSession = sqlFactory.openSession();}} 再通过SqlSession获得接⼝对象，调⽤接⼝对象的函数，最后将SqlSession关闭，代码如下： AuthorMapper mapper = sqlSession.getMapper(AuthorMapper.class); System.out.println(mapper.getAutById(1)); sqlSession.close(); 其中mapper.getAutById(1)调⽤了select⽅法，MyBatis配置⽂件如下：<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE configurationPUBLIC "-////DTD Config 3.0//EN""/dtd/mybatis-3-config.dtd"><configuration><properties resource="jdbc.properties"></properties><typeAliases><package name="com.study.day01"/></typeAliases><environments default="development"><environment id="development"><transactionManager type="JDBC"/><dataSource type="POOLED"><property name="driver" value="${jdbc.driver}"/><property name="url" value="${jdbc.url}"/><property name="username" value="${ername}"/><property name="password" value="${jdbc.password}"/></dataSource></environment></environments><databaseIdProvider type="DB_VENDOR"><property name="MySQL" value="mysql"/><property name="Oracle" value="oracle"/><property name="SQL Server" value="sqlserver"/></databaseIdProvider><mappers><mapper resource="mapper/AuthorMapper.xml"/><mapper resource="mapper/BookMapper.xml"/></mappers></configuration> 对于简单的MyBatis demo，我们只需要关注 mappers、environments、properties标签，映射⽂件如下：<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE mapperPUBLIC "-////DTD Mapper 3.0//EN""/dtd/mybatis-3-mapper.dtd"><mapper namespace="com.study.day01.AuthorMapper"><resultMap id="MyAuthor" type="com.study.day01.Author"><id column="id" property="id"></id><result column="name" property="name"></result><result column="nation" property="nation"></result></resultMap><select id="getAutById" resultMap="MyAuthor">select * from authors where id=#{id}</select></mapper> 映射⽂件需要保存在mapper/下。

Mybatis知识点整理

Mybatis知识点整理作为常⽤的orm框架，mybatis承接了SQL的预编译，执⾏，响应结果映射等SQL处理的各个环节。

在这⾥整理下这个框架的⼀些知识点，⽅便后续复习。

原⽣的mybatis初始化流程如下图所⽰：在XMLConfigBuilder中针对xxxMapper.xml⽂件进⾏了初始化，转换成了MapperStatement对象缓存到了Configuration中。

后续SQLSession使⽤时基于statementId定位到MapperStatement发起具体的执⾏。

在spring环境中，会基于mybatis-spring将mapper注册为⼀个spring的bean，然后基于IOC框架注⼊到各个依赖点。

springboot中，mybatis的初始化流程如下：这个流程⽐较有意思的是在SqlSessionTemplate，其中内置了⼀个sqlsessionProxy，其代理了所有的SQL请求，在具体执⾏时，会在事务开始时动态⽣成⼀个sqlsession，后续⼀个事务内的都会共享⼀个sqlsession。

⽽在MapperProxy中的sqlsession是sqlsessionTemplate⾃⼰，相当于2层代理。

第⼀层是MapperProxy，其将Mapper对外动态创建了⼀个Spring的Bean，然后业务调⽤mapper的method时，是请求到了sqlSessionTemplate的实例，然后内部⼜是通过sqlsessionProxy发起真实的请求。

sqlSession发起执⾏后，会筛选出具体的MapperStatement，然后委托给executor具体执⾏，⼀般都是使⽤的SimpleExecutor，然后看是否开启⼆级缓存进⽽在其上包装⼀个CacheExecutor。

sqlsession的⼀级缓存是默认开启的，也可以通过⼀定的⽅式进⾏缓存的强制刷新，⼀级缓存的⽣命周期是sqlsession级别的，事务或者会话结束，则缓存⽆效。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

Mybatis第一天mybatis的基础知识课程安排：Mybatis和springmvc通过订单商品案例驱动第一天：基础知识(重点、内容量大)对原生态jdbc程序(单独使用jdbc开发)问题总结Mybatis框架原理（掌握）Mybatis入门程序用户的增、删、改、查Mybatis开发dao两种方法原始dao开发方法(程序需要编写dao接口和dao实现类)(掌握)Mybatis的mapper接口(相当于dao接口)代理开发方法（掌握）Mybatis配置文件SqlMapConfig.xmlMybatis核心：Mybatis输入映射（掌握）Mybatis输出映射（掌握）Mybatis的动态sql第二天：高级知识订单商品数据模型分析高级结果集映射(一对一、一对多、多对多)Mybatis延迟加载Mybatis查询缓存(一级缓存、二级缓存)Mybatis和Spring进行整合(掌握)Mybatis的逆向工程1.对原生态jdbc程序问题总结1.1环境Java环境：jdk1.7.0_72Eclipse：indigoMysql:5.11.2创建mysql数据导入下边的脚本：Sql_table.sql:记录表机构Sql_data.sql:记录测试数据，在实际企业开发中，最后提供一个初始化数据脚本1.3jdbc程序使用jdbc查询mysql数据库中用户表的记录创建java工程，加入jar包。

数据库驱动包(mysql5.1)上边的是mysql驱动下边的是oracle的驱动1.4问题总结1.数据库连接，使用时就创建，不使用立即释放，对数据库进行频繁连接开启和关闭，造成数据库资源浪费，影响数据库性能。

设想：使用数据库连接池管理数据库连接。

2.将sql语句硬编码到java代码中，如果sql语句修改，需要重新编译java代码，不利于系统维护。

设想：将sql语句配置在xml配置文件中，即使sql变化，不需要对java代码进行重新编译。

3.向preparedStatement中设置参数，对占位符号位置和设置参数值，硬编码到java代码中，不利于系统维护。

设想：将sql语句以及占位符和参数全部配置在xml中4.从resultSet中遍历结果集数据时，存在硬编码，将获取表的字段进行硬编码，不利于系统维护。

设想：将查询的结果集，自动映射成java对象。

2.Mybatis框架2. 1 mybatis是什么？Mybatis是一个持久层的框架，是apache下面的顶级项目。

Mybatis托管到goolecode下，再后来托管到github下(https:///mybatis/mybatis-3/releases)。

Mybatis让程序员将主要精力放在sql上，通过mybatis提供的映射方式，自由灵活生成(半自动化，大部分需要程序员编写sql)满足需要的sql语句。

Mybatis可以将向preparedStatement中的输入参数自动进行输入映射，将查询结果集灵活映射成java对象。

（输出映射）。

2.2mybatis框架mysql3.入门程序3.1需求根据用户id(主键)查询用户信息根据用户名称模糊查询用户信息添加用户删除用户更新用户3.2环境Java环境：jdk1.7.0_75Eclipse:indigoMysql：5.1Mybatis运营环境(jar包)从https:///mybatis/mybatis-3/releases下载，3.2.7版本Lib下：依赖包Mybatis-3.2.7.jar：核心包Mybatis-3.2.7.pdf:操作指南加入mysql的驱动包3.2log4j.properties3.3工程结构3.4SqlMapConfig.xml配置mybatis的运行环境，数据源，事务等。

3.5根据用户id(主键)来查询用户信息3.5.1创建po类3.5.2映射文件映射文件命名：User.xml（原始ibatis命名），mapper代理开发映射文件名称为xxxMapper.xml，比如:UserMapper.xml,ItemsMapper.xml在配置文件中配置Sql语句。

3.5.3在SqlMapConfig.xml加载映射文件在sqlMapConfig.xml中加载User.xml:3.5.4程序编写3.6根据用户名称模糊查询用户信息3.6.1映射文件使用User.xml，添加根据用户名称模糊查询用户信息的sql语句。

3.7添加用户3.7.1映射文件在user.xml中配置添加用户的Statement3.7.3自增主键返回Mysql自增主键，执行insert提交之前自动生成一个自增主键。

通过mysql函数获取到刚插入记录的自增主键：Last_insert_id()是insert之后调用此函数。

3.7.4非自增主键返回(使用uuid())使用mysql的uuid()函数生成主键，需要修改表中id字段类型为string，长度设置成35位。

执行思路：先通过uuid()查询到主键，将主键输入到sql语句中。

执行uuid()语句顺序相对于insert语句之前执行。

通过oracle的序列生成主键：<selectKey keyProperty="id" order="BEFORE"resultType="ng.String">SELECT 序列名.nextval()</selectKey>insert into user(id,username,birthday,sex,address) value(#{id},#{username},#{birthday},#{sex},#{address})3.8删除用户3.8.1映射文件3.9.1映射文件3.10总结3.10.1parameterType在映射文件中通过parameterType制定输入参数的类型3.10.2resultType在映射文件中通过resultType指定输出结果的类型3.10.3#{}和${}#{}表示一个占位符号，#{}接受输入参数，类型可以是简单类型，pojo，hashmap。

如果接收简单类型，#{}中可以写成value或者其他名称。

#{}接收pojo对象值，通过OGNL读取对象的属性值，通过属性.属性.属性…的方式获取对象属性值。

${}表示一个拼接符号，会引起sql注入，所以不建议使用${}${}接收输入参数，类型可以使简单类型，pojo，hashmap如果接收简单类型，${}中只能写成value${}接收pojo对象值，通过OGNL读取对象中的属性值，通过属性.属性.属性…的方式获取对象属性值。

3.10.4selectOne和selectListselectOne表示查询出一条记录进行映射，如果使用selectOne可以实现使用SelectList也可以实现(list中只有一个对象).selectList表示查询出一个列表（多条记录）进行映射，如果使用selectList查询多条记录，不能使用selectOne如果使用selectOne报错：org.apache.ibatis.exceptions.TooManyResultsException: Expected one result (or null) to be returned by selectOne(), but found: 43.11mybatis和hibernate本质区别和应用场景Hibernate：是一个标准ORM框架(对象关系映射)。

入门门槛较高，不需要程序员编写sql，sql语句自动生成了。

对sql语句进行优化、修改比较困难。

应用场景：使用与需求变化不多的中小型项目，比如：后台管理系统，erp，orm，oa。

Mybatis：专注是sql本身，需要程序员自己编写sql语句，sql修改、优化比较方便。

Mybatis 是一个不完全的ORM框架，虽然程序员自己写sql，mybatis也可以实现映射（输入映射、输出映射）应用场景：适用于需求变化较多的项目，比如：互联网项目。

企业进行技术选型，以低成本，高回报作为技术选型的原则，根据项目组的技术力量进行选择。

4 mybatis开发dao的方法4.1SqlSession使用范围4.1.1SqlSessionFactoryBuilder通过SqlSessionFactoryBuilder创建回话工厂SqlSessionFactory，将SqlSessionFactoryBuilder当成一个工具类使用即可，不需要使用单例管理SqlSes sionFactoryBuilder。

在需要创建SqlSessionFactory的时候，只需要new一次SqlSessionFactoryBuilder即可。

4.1.2SqlSessionFactory通过SqlSessionFactory创建SqlSession，使用单例模式管理SqlSessionFactory(工厂一旦创建，使用一个实例)。

将来mybatis和spring整合后，使用单例模式来管理SqlSessionFactory。

4.1.3SqlSessionSqlSession是一个面向用户(程序员)的接口。

SqlSession中提供了很多操作数据库的方法：如selectOne(返回单个对象)，selectList（返回单个或者多个对象）。

SqlSession是线程不安全的，在SqlSession实现类中出了有接口中的方法（操作数据库的方法），还有数据域属性。

SqlSession最佳应用场合是在方法体内，定义成局部变量使用。

4.2原始dao开发方法（程序员需要写dao接口和dao实现类）4.2.1思路程序员需要些dao接口和dao实现类需要向dao实现类中注入sqlSessionFactory，在方法体重通过SqlSessionFactory创建SqlSession4.2.2dao接口4.2.3dao接口实现类public class UserDaoImpl implements UserDao {// 需要向dao实现类中注入SqlSessionFactory// 这里通过构造方法注入private SqlSessionFactory sqlSessionFactory;public UserDaoImpl(SqlSessionFactory sqlSessionFactory) { this.sqlSessionFactory = sqlSessionFactory;}@Overridepublic User findUserById(int id) throws Exception { SqlSession sqlSession = sqlSessionFactory.openSession();User user = sqlSession.selectOne("test.findUserById", id);// 释放资源sqlSession.close();return user;}@Overridepublic void insertUser(User user) throws Exception {SqlSession sqlSession = sqlSessionFactory.openSession();//执行插入操作sqlSession.insert("test.insertUser", user);// 提交事务mit();// 释放资源sqlSession.close();}@Overridepublic void deleteUser(int id) throws Exception {SqlSession sqlSession = sqlSessionFactory.openSession();//执行插入操作sqlSession.delete("test.deleteUser", id);// 提交事务mit();// 释放资源sqlSession.close();}}4.2.4 测试代码4.2.5总结原始dao开发问题1、dao接口实现类方法中存在大量模板方法，设想能否将这些代码提取出来，大大减轻程序员的工作量。