20150317mybatis课堂笔记

合集下载

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第一天课堂笔记

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

]下边的是oracle的驱动。

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

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

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

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

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

设想：将sql语句及占位符号和参数全部配置在xml中。

4、从resutSet中遍历结果集数据时，存在硬编码，将获取表的字段进行硬编码，，不利于系统维护。

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的笔记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+Spring+MySql1.1MyBatis简介MyBatis 是一个可以自定义SQL、存储过程和高级映射的持久层框架。

MyBatis 摒除了大部分的JDBC 代码、手工设置参数和结果集重获。

MyBatis 只使用简单的XML 和注解来配置和映射基本数据类型、Map 接口和POJO 到数据库记录。

相对Hibernate和Apache OJB等“一站式”ORM解决方案而言，Mybatis 是一种“半自动化”的ORM实现。

需要使用的Jar包：mybatis-3.0.2.jar（mybatis核心包）。

mybatis-spring-1.0.0.jar(与Spring结合包)。

下载地址：1.2MyBatis+Spring+MySql简单配置1.2.1搭建Spring环境1,建立maven的web项目；2,加入Spring框架、配置文件；3,在pom.xml中加入所需要的jar包（spring框架的、mybatis、mybatis-spring、junit等）；4,更改web.xml和spring的配置文件；5,添加一个jsp页面和对应的Controller；6,测试。

可参照：。

使用Eclipse的Maven构建SpringMVC项目1.2.2建立MySql数据库建立一个学生选课管理数据库。

表：学生表、班级表、教师表、课程表、学生选课表。

逻辑关系：每个学生有一个班级；每个班级对应一个班主任教师；每个教师只能当一个班的班主任；使用下面的sql进行建数据库，先建立学生表，插入数据（2条以上）。

更多sql请下载项目源文件，在resource/sql中。

Sql代码1./* 建立数据库 */2.CREATE DATABASE STUDENT_MANAGER;E STUDENT_MANAGER;4.5./***** 建立student表 *****/6.CREATE TABLE STUDENT_TBL7.(8. STUDENT_ID VARCHAR(255) PRIMARY KEY,9. STUDENT_NAME VARCHAR(10) NOT NULL,10. STUDENT_SEX VARCHAR(10),11. STUDENT_BIRTHDAY DATE,12. CLASS_ID VARCHAR(255)13.);14.15./*插入学生数据*/16.INSERT INTO STUDENT_TBL (STUDENT_ID,17. STUDENT_NAME,18. STUDENT_SEX,19. STUDENT_BIRTHDAY,20. CLASS_ID)21.VALUES (123456,22.'某某某',23.'女',24.'1980-08-01',25. 12154626. )创建连接MySql使用的配置文件mysql.properties。

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第二天课堂笔记

1MyBatis第二天课堂笔记2输入映射和输出映射2.1parameterType(输入类型)2.1.1传递简单类型参考第一天内容2.1.2传递pojo对象参考第一天内容Mybatis使用ognl表达式解析对象字段的值，#{}或者${}括号中的值为pojo属性名称。

2.1.3传递pojo包装对象1. 新建包装pojo对象QueryVo/*** 包装pojo* @author Steven*/public class QueryVo {//用户对象private User user;public User getUser() {return user;}public void setUser(User user) {er = user;}}2. 映射文件与sql<select id="getUserByQueryVo"parameterType="queryvo"resultType="er">SELECT * FROM USER WHERE username LIKE '%${ername}%' </select>3. 新增接口方法4. 增加测试方法，完成测试2.2resultType(输出类型)2.2.1输出简单类型<select id="getUserCount"resultType="int">SELECT COUNT(1) FROM USER</select>其它步骤跟前面类似，添加接口方法与测试方法，完成测试。

什么是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层解决⽅案。

如何快速学习使用mybatis以及总结

如何快速学习使用mybatis以及总结第一步让我来介绍下初学者怎么快速更好的使用mybatis这个框架使用mybatis的话，每个Dao就对于一个相应的xml文件，我来给个例子个大家看，先要配置好环境。

在application.xml里面<bean id="dataSource"class="boPooledDataSource"destroy-method="close"><property name="driverClass"value="${jdbc.driverClass}" /><property name="jdbcUrl"value="${jdbc.url}" /><property name="user"value="${er}" /><property name="password"value="${jdbc.password}" /><property name="initialPoolSize"value="${jdbc.initialPoolSize}" /><property name="minPoolSize"value="${jdbc.minPoolSize}" /><property name="maxPoolSize" value="${jdbc.maxPoolSize}" /><propertyname="numHelperThreads" value="20" /><property name="maxStatements" value="100" /><property name="maxIdleTime" value="3600" /><property name="acquireIncrement" value="2" /><propertyname="acquireRetryAttempts" value="5" /><propertyname="acquireRetryDelay" value="600" /><propertyname="testConnectionOnCheckin"value="true" /><propertyname="idleConnectionTestPeriod"value="1200" /><property name="checkoutTimeout" value="10000" /></bean><bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFact oryBean"><property name="dataSource" ref="dataSource" /></bean><bean id="transactionManager"class="org.springframework.jdbc.dat asource.DataSourceTransactionManager"> <property name="dataSource" ref="dataSource" /></bean><beanclass="org.mybatis.spring.mapper.Mappe rScannerConfigurer"><property name="annotationClass" value="org.springframework.stereotype.Repository" /><property name="basePackage" value="com.shishuo.studio.dao" /></bean>然后我在dao层写个类package com.shishuo.studio.dao;import java.util.List;importorg.apache.ibatis.annotations.Param;importorg.springframework.stereotype.Reposito ry;importcom.shishuo.studio.entity.TagSkill;importcom.shishuo.studio.entity.vo.TagSkillVo;@Repositorypublic interface TagSkillDao {/*** 增加** @param tagSkill* @return*/public int addTagSkill(TagSkill tagSkill);/*** 删除** @param skillId* @return*/public int deleteTagSkill(@Param("skillId") long skillId);/**** 通过SkillId修改名字*/public int updateNameBySkillId(@Param("skillId") long skillId,@Param("name") String name);/*** 通过Id查询** @param skillId* @return*/public TagSkillVo getTagSkillByTagId(@Param("skillId") long skillId);/*** 通过名字查询** @param name* @param rows* @return*/public TagSkillVo getTagSkillByName(@Param("name") String name);/*** 通过userId得到所有所有自己的技能** @param userId* @return*/public List<TagSkillVo> getTagSkillListByUserId(@Param("userId") long userId);}然后再就是对应的XML文件TagSkill.xml<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE mapper PUBLIC "-////DTD Mapper 3.0//EN" "/dtd/mybatis-3-mapper.dtd"><mappernamespace="com.shishuo.studio.dao.Tag SkillDao"><insert id="addTagSkill" parameterType="com.shishuo.studio.entit y.TagSkill">insert into tag_skill(name,content,status,createTime)values(#{name},#{content},#{status},#{create Time})<selectKey resultType="long" keyProperty="skillId">SELECT LAST_INSERT_ID()</selectKey></insert><delete id="deleteTagSkill" parameterType="Long">delete from tag_skill where skillId=#{skillId}</delete><update id="updateNameBySkillId">update tag_skill set name=#{name} where skillId=#{skillId}</update><select id="getTagSkillByTagId" parameterType="Long"resultType="com.shishuo.studio.entit y.vo.TagSkillVo">select * from tag_skill where skillId=#{skillId}</select><select id="getTagSkillByName"resultType="com.shishuo.studio.entit y.vo.TagSkillVo">select * from tag_skill where name=#{name}</select><select id="getTagSkillListByUserId"resultType="com.shishuo.studio.entit y.vo.TagSkillVo">SELECTtags.skillId,,tags.content,tags.st atus,tags.createTime FROM shishuo.tag_skilltags,shishuo.teacher_skill teas where tags.skillId=teas.tagSkillId and userId=#{userId};</select></mapper>使用经验1、要记得在TagSkillDao这个类前添加@Repository这个注解，实体的意思2、你发现了没有，在xml文件里面的id 在那个dao层类里面对应的方法名，然后就是在那个XML文件里面，resultType这个参数里面和对应方法里面的返回数据类型想匹配，记住，如果方法返回是int，记得写Internet，是包装类型，不然会出错的，如果是返回对象的话，或者返回一个对象的集合，resultType 里面就要写这个对象，如果是没有返回的可以不需要写，在dao层里面的方法需要传参数的话，需要写parameterType,但是一定要记住是包装类型，不是基本数据类型，在dao层里面的方法如果是要增加，就传一个对象过来，不需要写注解，如果是通过Id删除的话，比如public int deleteTagSkill(@Param("skillId") long skillId);我们在xml文件里面<delete id="deleteTagSkill" parameterType="Long">delete from tag_skill where skillId=#{skillId}</delete>public int deleteTagSkill(@Param("skillId") long skillId);这个#{skillId}就相当于我们函数里面的参数skillId，其它的增删改查都类似。

Mybatis语法笔记

Mybatis语法笔记1.条件查询<sql id="queryColumn">id,name name</sql><select id="findList" resultType="packageName">SELECT<include refid="queryColumn"></include>FROMT_TABLE AWHERE1 = 1<if test="name != null and name != '' ">AND ( like '%${name}' or like '${name}%' or like '%${name}%')</if>ORDER BYA.CREATE_TIME DESC</select>2.函数查询　<select id="queryAreaData" resultType="packageName">SELECT A.ID code, name,　(SELECT group_concat(CONCAT('{"code":"',t.id,'",'),CONCAT('"name":"',,'"}') SEPARATOR '/') FROM (SELECT b.PARENT_ID,b.id, FROM ADS_ADDRESS b where b.level_type =3 GROUP BY b.id,)t where t.PA FROM ADS_ADDRESS AWHERE A.LEVEL_TYPE =2GROUP BY A.ID,</select>3.循环查询<select id="list" resultType="packageName">SELECTID id,NAME nameFROMT_TABLE AWHERE A.ID IN　<foreach item="item" index="index" collection="array" open="(" separator="," close=")"> #{item}</foreach></select>4.循环插⼊　<insert id="insertList">INSERT INTO T_TABLE(ID,NAME)VALUES<foreach collection="list" item="item" index="index" open="(" separator="),(" close=")">#{item.id},#{}</foreach></insert>5.Msp参数判断查询 Map<String, Integer> map = new HashMap<String, Integer>(); map.put("pageIndex", pageIndex); map.put("pageSize", pageSize);<select id="queryBouncePage" parameterType="java.util.Map" resultType="JavaBean">SELECT*FROMT_TABLEWHERE ID IN<foreach collection="ids" item="item" index="index" open="(" separator="," close=")">#{item}</foreach><if test="_parameter.containsKey('pageIndex') and _parameter.containsKey('pageSize')">limit #{pageIndex}, #{pageSize}</if></select>6.属性为对象查询public class StoreInfoDto {private int id;private List<StoreImgDto> imgDtos;// 店铺图⽚private List<StoreLabelDto> labelDtos;// 店铺标签private List<StoreReviewDto> reviewDtos;// 店铺评论private List<StoreErrorDto> errorDtos;// 顾客报错信息private ProvinceDto provinceDto;// 省private CityDto cityDto;// 市private AreaDto areaDto;// 区private String merchantNo;// 商户编号private String code;// 编码CODEprivate String name;// 店名private String alias;// 店别名private String address;// 店铺地址private String addressDetail;// 店铺地址详情.......get、set.......}<sql id="storeInfoColumn">A.ID,A.MERCHANT_NO,A.CODE,,A.ALIAS,A.ADDRESS_DETAIL,A.NEAR_AREA,A.LONGITUDE,TITUDE,A.STATUS,A.PHONE,A.PHONE_STANDBY,A.MOBILE,A.MOBILE_STANDBY,A.OFFICE_HOURS,A.OFFICE_HOURS_PERIODS,A.OFFICE_HOURS_STANDBY,A.OFFICE_HOURS_PERIODS_STANDBY,A.REVIEW_TIMES,A.EFFECT_SCORE,A.ENVIRONMENT_SCORE,A.SERVER_SCORE,A.FAVORITES_TIMES,A.REMARK,A.CREATE_BY,A.CREATE_TIME,A.UPDATE_BY,A.UPDATE_TIME</sql><sql id="storeImgColumn">B.ID B_ID,B.STORE_ID B_STORE_ID,B.TITLE B_TITLE,B.SOURCE B_SOURCE,RGE B_LARGE,B.MEDIUM B_MEDIUM,B.THUMBNAIL B_THUMBNAIL,B.IMAGE_PATH B_IMAGE_PATH,B.TYPE B_TYPE,B.STATUS B_STATUS,B.ORDER_BY B_ORDER_BY,B.CREATE_BY B_CREATE_BY,B.CREATE_TIME B_CREATE_TIME,B.UPDATE_BY B_UPDATE_BY,B.UPDATE_TIME B_UPDATE_TIME</sql><sql id="storeLableColumn">C.ID C_ID,C.STORE_ID C_STORE_ID, C_NAME,C.CODE C_CODE,RGE C_LARGE,C.ORDER_BY C_ORDER_BY,C.CREATE_BY C_CREATE_BY,C.CREATE_TIME C_CREATE_TIME,C.UPDATE_BY C_UPDATE_BY,C.UPDATE_TIME C_UPDATE_TIME</sql><sql id="storeReviewColumn">D.ID D_ID,ER_ID D_USER_ID,D.STORE_ID D_STORE_ID,D.CONTENT D_CONTENT,D.IP D_IP,D.IS_SHOW D_IS_SHOW,D.STATUS D_STATUS,D.SCORE D_SCORE,D.EFFECT_SCORE D_EFFECT_SCORE,D.ENVIRONMENT_SCORE D_ENVIRONMENT_SCORE, D.SERVER_SCORE D_SERVER_SCORE,D.HIT_TIMES D_HIT_TIMES,D.REMARKS D_REMARKS,D.CREATE_BY D_CREATE_BY,D.CREATE_TIME D_CREATE_TIME,D.UPDATE_BY D_UPDATE_BY,D.UPDATE_TIME D_UPDATE_TIME</sql><sql id="storeErrorColumn">E.ID E_ID,ER_ID E_USER_ID,E.STORE_ID E_STORE_ID,E.ERROR_TYPE_CODE E_ERROR_TYPE_CODE,E.REPETITION_STORE_ID E_REPETITION_STORE_ID, E.NEW_LONGITUDE E_NEW_LONGITUDE,E.NEW_LATITUDE E_NEW_LATITUDE,E.AFFIRM_STORE_ID E_AFFIRM_STORE_ID,E.CREATE_BY E_CREATE_BY,E.CREATE_TIME E_CREATE_TIME,E.UPDATE_BY E_UPDATE_BY,E.UPDATE_TIME E_UPDATE_TIME</sql><sql id="storeReviewImgColumn">F.ID F_ID,F.STORE_ID F_STORE_ID,F.STORE_REVIEW_ID F_STORE_REVIEW_ID,F.SOURCE F_SOURCE,RGE F_LARGE,F.MEDIUM F_MEDIUM,F.THUMBNAIL F_THUMBNAIL,F.IMAGE_PATH F_IMAGE_PATH,F.HIT_TIMES F_HIT_TIMES,F.ORDER_BY F_ORDER_BY,F.CREATE_BY F_CREATE_BY,F.CREATE_TIME F_CREATE_TIME,F.UPDATE_BY F_UPDATE_BY,F.UPDATE_TIME F_UPDATE_TIME</sql><sql id="provinceColumn">G.ID G_ID, G_NAME</sql><sql id="cityColumn">H.ID H_ID,H.PROVINCE_ID H_PROVINCE_ID, H_NAME</sql><sql id="areaColumn">I.ID I_ID,I.CITY_ID I_CITY_ID,</sql><sql id="queryColumn"><include refid="storeInfoColumn"></include>,<include refid="storeImgColumn"></include>,<include refid="storeLableColumn"></include>,<include refid="storeReviewColumn"></include>,<include refid="storeErrorColumn"></include>,<include refid="storeReviewImgColumn"></include>,<include refid="provinceColumn"></include>,<include refid="cityColumn"></include>,<include refid="areaColumn"></include></sql><select id="queryStoreList" resultMap="storeInfoMap">SELECT<include refid="queryColumn"></include>FROMlrm_store_info aLEFT JOIN lrm_store_image bON a.id = b.store_idLEFT JOIN lrm_store_label cON a.id = c.store_idLEFT JOIN lrm_store_review dON a.id = d.store_idLEFT JOIN lrm_store_error eON a.id = e.store_idLEFT JOIN lrm_store_review_image fON d.id = f.store_review_idLEFT JOIN lrm_dict_provinces gON a.privince_id = g.idLEFT JOIN lrm_dict_citys hON a.city_id = h.idLEFT JOIN lrm_dict_areas iON a.area_id = i.id</select><resultMap id="storeInfoMap" type="mon.store.entity.StoreInfoDto"><id column="id" property="id" /><result column="merchant_no" property="merchantNo" /><result column="code" property="code" /><result column="name" property="name" /><result column="alias" property="alias" /><result column="address" property="address" /><result column="address_detail" property="addressDetail" /><result column="near_area" property="nearArea" /><result column="longitude" property="longitude" /><result column="latitude" property="latitude" /><result column="status" property="status" /><result column="phone" property="phone" /><result column="phone_standby" property="phoneStandby" /><result column="mobile" property="mobile" /><result column="mobile_standby" property="mobileStandby" /><result column="office_hours" property="officeHours" /><result column="office_hours_periods" property="officeHoursPeriods" /><result column="office_hours_standby" property="officeHoursStandby" /><result column="office_hours_periods_standby" property="officeHoursPeriodsStandby" /><result column="review_times" property="reviewTimes" /><result column="effect_score" property="effectScore" /><result column="environment_score" property="environmentScore" /><result column="server_score" property="serverScore" /><result column="favorites_times" property="favoritesTimes" /><result column="remark" property="remark" /><result column="create_by" property="createBy" /><result column="create_time" property="createTime" /><result column="update_by" property="updateBy" /><result column="update_time" property="updateTime" /><association property="provinceDto" resultMap="provinceMap" columnPrefix="G_" /><association property="cityDto" resultMap="cityMap" columnPrefix="H_"/><association property="areaDto" resultMap="areaMap" columnPrefix="I_"/><collection property="imgDtos" resultMap="storeImgMap" columnPrefix="B_"/><collection property="labelDtos" resultMap="storeLabelMap" columnPrefix="C_"/><collection property="reviewDtos" resultMap="storeReviewMap" columnPrefix="D_"/><collection property="errorDtos" resultMap="storeErrorMap" columnPrefix="E_"/></resultMap><resultMap id="storeImgMap" type="mon.store.entity.StoreImgDto"><id column="id" property="id" /><result column="store_id" property="storeId" /><result column="title" property="title" /><result column="source" property="source" /><result column="large" property="large" /><result column="medium" property="medium" /><result column="thumbnail" property="thumbnail" /><result column="image_path" property="imagePath" /><result column="type" property="type" /><result column="status" property="status" /><result column="order_by" property="orderBy" /><result column="create_by" property="createBy" /><result column="create_time" property="createTime" /><result column="update_by" property="updateBy" /><result column="update_time" property="updateTime" /></resultMap><resultMap id="storeLabelMap" type="mon.store.entity.StoreLabelDto"> <id column="id" property="id" /><result column="store_id" property="storeId" /><result column="name" property="name" /><result column="code" property="code" /><result column="large" property="large" /><result column="order_by" property="orderBy" /><result column="create_by" property="createBy" /><result column="create_time" property="createTime" /><result column="update_by" property="updateBy" /><result column="update_time" property="updateTime" /></resultMap><resultMap id="storeReviewMap" type="mon.store.entity.StoreReviewDto"> <id column="id" property="id" /><result column="user_id" property="userId" /><result column="store_id" property="storeId" /><result column="content" property="content" /><result column="ip" property="ip" /><result column="is_show" property="isShow" /><result column="status" property="status" /><result column="score" property="score" /><result column="effect_score" property="effectScore" /><result column="environment_score" property="environmentScore" /><result column="remarks" property="remarks" /><result column="create_by" property="createBy" /><result column="create_time" property="createTime" /><result column="update_by" property="updateBy" /><result column="update_time" property="updateTime" /><collection property="reviewImgDtos" resultMap="storeReviewImgMap" columnPrefix="F_"/></resultMap><resultMap id="storeReviewImgMap" type="mon.store.entity.StoreReviewImgDto"> <id column="id" property="id" /><result column="store_id" property="storeId" /><result column="store_review_id" property="storeReviewId" /><result column="source" property="source" /><result column="large" property="large" /><result column="medium" property="medium" /><result column="thumbnail" property="thumbnail" /><result column="image_path" property="imagePath" /><result column="hit_times" property="hitTimes" /><result column="order_by" property="orderBy" /><result column="create_by" property="createBy" /><result column="create_time" property="createTime" /><result column="update_by" property="updateBy" /><result column="update_time" property="updateTime" /></resultMap><resultMap id="storeErrorMap" type="mon.store.entity.StoreErrorDto"><id column="id" property="id" /><result column="user_id" property="userId" /><result column="store_id" property="storeId" /><result column="source" property="source" /><result column="error_type_code" property="errorTypeCode" /><result column="repetition_store_id" property="repetitionStoreId" /><result column="new_longitude" property="newLongitude" /><result column="new_latitude" property="newLatitude" /><result column="affirm_store_id" property="affirmStoreId" /><result column="create_by" property="createBy" /><result column="create_time" property="createTime" /><result column="update_by" property="updateBy" /><result column="update_time" property="updateTime" /></resultMap><resultMap id="provinceMap" type="mon.dict.ProvinceDto"><id column="id" property="id" /><result column="name" property="name" /></resultMap><resultMap id="cityMap" type="mon.dict.CityDto"><id column="id" property="id" /><result column="province_id" property="provinceId" /><result column="name" property="name" /></resultMap><resultMap id="areaMap" type="mon.dict.AreaDto"><id column="id" property="id" /><result column="city_id" property="cityId" /><result column="name" property="name" /></resultMap>7.属性为对象插⼊<insert id="insertEpaper">INSERT INTO T_TABLE(ID,USER_ID,NAME)VALUES<foreach collection="list" item="item" index="index" open="(" separator="),(" close=")">#{item.id},#{erDto.id},#{}</foreach></insert>8.批量修改jdbc:mysql://127.0.0.1:3306/database?allowMultiQueries=true<update id="updateList"><foreach collection="list" item="item" index="index" open="" close="" separator=";">UPDATEtableNameSETname = #{},update_time = DATE_FORMAT(#{item.updateTime},'%Y-%c-%d %H:%i:%s')WHEREid = #{item.id}</foreach></update>9.批量删除<delete id="deleteList" parameterType="String">Delete from t_base_user_role WHERE user_id in<foreach collection="list" item="item" open="(" separator="," close=")">#{erId}</foreach></delete>。

Mybatis笔记-SQL标签方法

Mybatis笔记-SQL标签⽅法Mpper.xml映射⽂件中定义了操作数据库的sql，并且提供了各种标签⽅法实现动态拼接sql。

每个sql是⼀个statement，映射⽂件是mybatis的核⼼。

⼀、内容标签1、NamePlaceNamePlace命名空间作⽤就是对sql进⾏分类化管理。

若使⽤Dao开发⽅式，映射⽂件的nameplace可以任意命名；但如果采⽤的是Mapper接⼝代理的⽅式开发，Mapper的映射⽂件中namespace必须为接⼝的全名。

<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE mapperPUBLIC "-////DTD Mapper 3.0//EN""/dtd/mybatis-3-mapper.dtd"><mapper namespace="Mapper.EmpMapper">//CURD操作标签//if⽚段</mapper>2、CRUD标签<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE mapperPUBLIC "-////DTD Mapper 3.0//EN""/dtd/mybatis-3-mapper.dtd"><mapper namespace="Mapper.EmpMapper"><select id="" parameterType="" resultType=""></select><insert id="" parameterType=""></insert><delete id="" parameterType=""></delete><update id="" parameterType=""></update></mapper>3、标签调⽤⽅法（1）selectOne与selectList⽅法selectOne表⽰查询出⼀条结果集进⾏映射，使⽤selectOne查询多条记录会抛出异常。

MyBatis框架思维导图笔记总结

</select>
 <select id="findLike" resultMap="userMap">
select * from user where user_name like "%"#{name}"%" </select>
<update id="updateUser"> update user set user_name=#{userName}, password=#{password} where id=#{id}
select last_insert_id() </selectKey> </insert>

<select id="findUserById" ultMap="userMap"> select * from user where id = #{id}
PUBLIC "-////DTD Mapper 3.0//EN" "/dtd/mybatis-3-mapper.dtd">  <mapper namespace="erMapper">
<insert id="insertUser" parameterType="er" useGeneratedKeys="true" keyProperty="id"> insert into user(id,username,password) values(#{id},#{userName},#{password})

MyBatis部分笔记

mybatis入门小结：mybatis一个半自动化的持久层框架（SQL抽取出来进行手动编写），支持定制化SQL。

1、接口式编程原生：Dao ==> DaoImplmybatis:Mapper ==> xxMapper.xml2、SqlSession代表和数据库的一次回话,用完就要关闭3、SqlSession和Connection一样是非线程安全的,不能写成员变量，每次使用都应该new新的对象4、mapper接口没有实现类，但是mybatis会为接口类型生成一个代理对象5、连个配置文件1）全局配置文件mybatis-config.xml：包含事务管理器，数据源等信息。

2)SQL映射文件:保存了每个SQL语句映射信息,唯一标识，返回结果类型等信息,通过这种方式将关键SQL语句抽取出来自己写。

<mapper resource="EmployeeMapper.xml" />mybatis基本使用过程：1.得到sqlSessionFactory对象2.获取sqlSession对象3.获取接口的实现类对象会为接口自动创建一个代理对象，代理对象执行增删改查操作4.mapper的接口的方法每个线程都应该有它自己的SqlSession 实例。

SqlSession 的实例不能共享使用，它也是线程不安全的。

因此最佳的范围是请求或方法范围。

SqlSession 的实例不是线程安全的，因此是不能被共享的。

mybatis关于缓存？两级缓存：一级缓存：（本地缓存）：sqlSession级别的缓存。

一级缓存是一直开启的；SqlSession级别的一个Map 与数据库同一次会话期间查询到的数据会放在本地缓存中。

以后如果需要获取相同的数据，直接从缓存中拿，没必要再去查询数据库；一级缓存失效情况（没有使用到当前一级缓存的情况，效果就是，还需要再向数据库发出查询）：1、sqlSession不同。

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学习笔记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学习笔记（动力节点学习的）

MyBatis学习笔记（动⼒节点学习的）MyBatis框架什么是框架框架定义框架（Framework）是整个或部分系统的可重⽤设计，表现为⼀组抽象构件及构件实例间交互的⽅法;另⼀种认为，框架是可被应⽤开发者定制的应⽤⾻架、模板。

简单的说，框架其实是半成品软件，就是⼀组组件，供你使⽤完成你⾃⼰的系统。

从另⼀个⾓度来说框架⼀个舞台，你在舞台上做表演。

在框架基础上加⼊你要完成的功能。

框架安全的，可复⽤的，不断升级的软件。

框架解决的问题框架要解决的最重要的⼀个问题是技术整合，在 J2EE 的框架中，有着各种各样的技术，不同的应⽤，系统使⽤不同的技术解决问题。

需要从 J2EE 中选择不同的技术，⽽技术⾃⾝的复杂性，有导致更⼤的风险。

企业在开发软件项⽬时，主要⽬的是解决业务问题。

即要求企业负责技术本⾝，⼜要求解决业务问题。

这是⼤多数企业不能完成的。

框架把相关的技术融合在⼀起，企业开发可以集中在业务领域⽅⾯。

另⼀个⽅⾯可以提供开发的效率。

常⽤框架介绍MyBatis框架MyBatis 是⼀个优秀的基于 java 的持久层框架，内部封装了 jdbc，开发者只需要关注 sql 语句本⾝，⽽不需要处理加载驱动、创建连接、创建 statement、关闭连接，资源等繁杂的过程。

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

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

2013 年 11 ⽉迁移到 Github。

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

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一对多和多对一简单案例笔记

mybatis⼀对多和多对⼀简单案例笔记以案例说明(以下案例代码都敲过验证过)多对⼀（多个学⽣对⼀个⽼师即学⽣集合中都存⼀个⽼师对象）Mybatis多对⼀实现⽅式1：//定义Student 和 Teacher 实体@Datapublic class Student {private int id;private String name;//tid对应teacher的idprivate int tid;private Teacher teacher;}@Datapublic class Teacher {private int id;private String name;}<mapper namespace="mapper.StudentMapper"><resultMap id="stuAboutTea" type="bean.Student"><result property="id" column="ic"></result><result property="name" column="name"></result>//普通查询只需查询selectstudent就好了//多对⼀查询多了association标签我认为这个标签作⽤就是嵌套查询//其中javaType是property中teacher对象的类 select嵌套查询的id<association property="teacher" column="tid" javaType="bean.Teacher" select="selectstubyid"/></resultMap><select id="selectstudent" resultMap="stuAboutTea">select * from student</select><select id="selectstubyid" resultType="bean.Teacher">select * from teacher where id=#{id}</select></mapper>这种⽅式调selectid为selectstudent的sql selectstudent中就嵌套了selectstubyid的查询嵌套的结果集存在private Teacher teacher;Mybatis多对⼀实现⽅式2：<resultMap id="StudentTeacher2" type="bean.Student"><id property="id" column="sid"/><result property="name" column="sname"/><association property="teacher" javaType="bean.Teacher"><result property="name" column="tname"/></association></resultMap><select id="getStudents2" resultMap="StudentTeacher2" >select s.id sid, sname , tnamefrom student s,teacher twhere s.tid = t.id</select>这种⽅式是直接⽤sql将多对⼀的结果查询出来需存到teacher对象中的参数映射在association标签中定义我个⼈认为第⼆种更好⼀点因为遇到复杂的sql更直观--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------⼀对多（⼀个⽼师对⼀个学⽣即teacher实体类中存了student集合对象）Mybatis⼀对多实现⽅式1：@Datapublic class Teacher {private int id;private String name;//⼀个⽼师多个学⽣private List<Student> students;}@Datapublic class Student {private int id;private String name;//tid对应teacher的idprivate int tid;}<resultMap id="TeacherStudent" type="bean.Teacher"><result property="name" column="tname"/>//collection标签同上例类似但它是存student集合的 collection就是集合很好记<collection property="students" ofType="bean.Student"><result property="id" column="sid" /><result property="name" column="sname" /><result property="tid" column="tid" /></collection></resultMap><select id="getTeacher" resultMap="TeacherStudent">select s.id sid, sname , tname, t.id tidfrom student s,teacher twhere s.tid = t.id and t.id=#{id}</select>⼀对多例⼦同上类似只不过将查询多对⼀中存单个对象变为存集合标签collection就是集合。