代码间接放在 Github 仓库【https://github.com/Damaer/Myb…】，可间接运行，就不占篇幅了。
1. 框架是什么
- 框架（
Framework）是整个或局部零碎的可重用设计，体现为一组形象构件及构件实例间交互的办法; 另一种定义认为，框架是可被利用开发者定制的利用骨架。前者是从利用方面而后者是从目标方面给出的定义。- 一个框架是一个 可复用 的设计构件，它规定了利用的 体系结构 ，说明了整个设计、合作构件之间的依赖关系、责任调配和管制流程，体现为一组抽象类以及其实例之间合作的办法，它为构件复用提供了上下文(Context) 关系。因而构件库的大规模 重用 也须要框架。
- 集体了解：框架最重要的是把咱们罕用的，能够重复使用的性能形象进去，不须要咱们去反复写，咱们只须要调用，或者依照规定配置，依照规定应用就能够了。这样的毛病是很多时候咱们不晓得为什么能够这样子应用，外面实现的细节被屏蔽掉了，这也是很多初学者很懵逼的中央，这时候追根问底就有肯定必要性了。
2.Mybatis 的介绍
Mybatis 原本是 Apache 的一个开源我的项目 iBatis，这个我的项目 2010 年由Apache 迁徙到了Google，更名为 Mybatis，2013 年正式迁徙到Github。
Mybatis是一个 java 中一个长久层的框架，在外面封装了 jdbc 操作，如果还不理解 java 如何应用 jdbc 拜访数据库，那么能够查看这篇文章，封装使开发者只须要把精力放在开发 sql 语句上，不必去注册驱动，创立 Connection，配置 Statement，本人写代码治理事务等等。
Mybatis 通过 xml 或者注解的形式将须要执行的 statement 配置好，通过映射将 java 对象与 sql 中的动静参数一起生成最终的 sql 语句，执行完之后返回对象，其中也是映射的后果。
3.Mybatis 和 Hibernate 比照
1.Hibernate 是全自动的 ORM 框架，也就是齐全实现了 POJO 和数据库表之间的映射，会主动生成 SQL。然而 Mybatis 不会主动生成，SQL 还是须要本人写，然而映射关系框架会主动解决，这样一个益处就是能够看失去 SQL，很多时候零碎主动生成 SQL 并不是高效的，咱们有时候须要优化 SQL，或者一些简单的查问可能自动化的很难做到，毛病就是须要花工夫写。
2. 应用 XML 文件进行配置，拆散了了 sql 与代码，这样比拟容易保护。
3.Mybatis 是一个轻量级的框架。学习老本比 Hibernate 低很多，jar 包依赖也很少，上手比拟快。
4.Mybatis 的结构图：
Mybatis 的运行机制：咱们通过配置 Mybatis.xml(外面配置好数据库，须要扫描的 mapper.xml 文件等)，程序会主动扫描配置好的 mapper 文件，当咱们申请一个接口（申请数据库），接口会间接映射到对应的 sql 标签，同时将咱们所写的配置文件读取并将数据库字段与对象属性匹配（这也是映射，如果不统一，须要本人手写映射关系），将 sql 参数传进去，而后执行相干的 sql，返回时又做了一次映射，把对象返回给咱们。当然，这么形容是很外表的，因为 mybatis 还有事务，缓存等方面，以上只是大略。
5.IDEA 创立第一个程序
这里咱们会应用 idea 创立我的项目，如果 maven 没有配置好，请参考：https://blog.csdn.net/aphysia…
5.1 创立 mysql 数据库
应用一下的命令行:
CREATE DATABASE `test` DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci;
CREATE TABLE `student` (`id` INT NOT NULL AUTO_INCREMENT , `name` VARCHAR(20) NOT NULL ,
`age` INT NOT NULL , `score` DOUBLE NOT NULL , PRIMARY KEY (`id`)) ENGINE = MyISAM; 5.2 应用 idea 创立我的项目(Maven)
我的项目结构图（bean上面放的类对应咱们的数据库外面的 student 表，也就是它的一个实体类，dao包上面放着咱们的数据库的操作，resources上面放着咱们的 xml 或者各种资源）:
new –> Project –> 点击Maven
点击 next,GroupId,ArtifactId 能够本人指定，点击下一步
本人指定project name（我的项目名），点击finish
往 pom.xml 外面增加依赖, 每一个 <dependency></dependency> 之间都是一种依赖包，选中我的项目右键 –> Maven –> Reimport, 这样就能够下载咱们所须要的依赖了：
<dependencies>
<!-- mybatis 外围包 -->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.3.0</version>
</dependency>
<!-- mysql 驱动包 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.29</version>
</dependency>
<!-- junit 测试包 -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.11</version>
<scope>test</scope>
</dependency>
<!-- 日志文件治理包 -->
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.17</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>1.7.12</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>1.7.12</version>
</dependency>
</dependencies>为了能实现日志的打印性能，咱们在 pom.xml 文件中曾经引入了日志 dependency，在这里还须要在 resources 文件夹下新建配置 log4j.properties 文件, 具体配置代表什么意思，能够参考 log4j 与 log4j2 详解
log4j.properties
log4j.rootLogger=DEBUG, stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=[service] %d - %c -%-4r [%t] %-5p %c %x - %m%n
#log4j.appender.R=org.apache.log4j.DailyRollingFileAppender
#log4j.appender.R.File=../logs/service.log
#log4j.appender.R.layout=org.apache.log4j.PatternLayout
#log4j.appender.R.layout.ConversionPattern=[service] %d - %c -%-4r [%t] %-5p %c %x - %m%n
#log4j.logger.com.ibatis = debug
#log4j.logger.com.ibatis.common.jdbc.SimpleDataSource = debug
#log4j.logger.com.ibatis.common.jdbc.ScriptRunner = debug
#log4j.logger.com.ibatis.sqlmap.engine.impl.SqlMapClientDelegate = debug
#log4j.logger.java.sql.Connection = debug
log4j.logger.java.sql.Statement = debug
log4j.logger.java.sql.PreparedStatement = debug
log4j.logger.java.sql.ResultSet =debug配置好这些之后，后面结构图下面写到有一个 mybatis.xml 文件，外面配置了运行的环境（对于数据库的连贯），连贯的数据库能够配置多个，然而必须指定应用哪一个，这样做的起因的世界在 xml 文件进行批改不须要从新编译，更换数据库比较简单, 除此之外，外面还须要配置 mapper.xml, 也就是映射文件，咱们要通知它，咱们将 sql 配置写在哪个文件。
mybatis.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<!-- 配置运行环境 -->
<!-- default 示意默认应用哪一个环境，能够配置多个，比方开发时的测试环境，上线后的正式环境等 -->
<environments default="mysqlEM">
<environment id="mysqlEM">
<transactionManager type="JDBC">
</transactionManager>
<dataSource type="POOLED">
<property name="driver" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://127.0.0.1:3306/test"/>
<property name="username" value="root"/>
<property name="password" value="123456"/>
</dataSource>
</environment>
<environment id="testEM">
<transactionManager type="JDBC">
</transactionManager>
<dataSource type="POOLED">
<property name="driver" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://127.0.0.1:3306/test"/>
<property name="username" value="root"/>
<property name="password" value="123456"/>
</dataSource>
</environment>
</environments>
<!-- 注册映射文件 -->
<mappers>
<mapper resource="mapper.xml"/>
</mappers>
</configuration>配置好 mybatis.xml 文件咱们就须要写 sql 语句，依据下面的 mybatis.xml, 咱们须要写mapper.xml 文件, 上面的 namespace 当初能够随便命名，因为只有一个 mapper.xml 文件,sql 标签的 id 没有反复，执行时就是依据 id 来查找的，同时这里 parameterType 对应的是参数类型，类型要写带残缺路径名的类：
mapper.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="abc">
<insert id="insertStudent" parameterType="bean.Student">
insert into student(name,age,score) values(#{name},#{age},#{score})
</insert>
</mapper>在 bean 包上面创立与数据库对应的 Student 类【在 bean 包下】（这里先把属性名字和数据库的字段名统一，如果不统一须要本人写映射）, 留神外面的办法咱们须要实现 set 和 get 办法，这个在 IDEA 外面，关上以后类，右键 –> Gernarate –>setter and getter全选就能够生成。
Student.class
package bean;
public class Student {
// id 属性
private Integer id;
// 名字属性
private String name;
// 年龄属性
private int age;
// 分数属性
private double score;
// 构造方法，除了 id，因为咱们的 id 在数据库中是自增的
public Student(String name, int age, double score) {super();
this.name = name;
this.age = age;
this.score = score;
}
public Integer getId() {return id;}
public void setId(Integer id) {this.id = id;}
public String getName() {return name;}
public void setName(String name) {this.name = name;}
public int getAge() {return age;}
public void setAge(int age) {this.age = age;}
public double getScore() {return score;}
public void setScore(double score) {this.score = score;}
@Override
public String toString() {
return "Student [id=" + id + ", name=" + name + ", age=" + age
+ ", score=" + score + "]";
}
}
在这里咱们须要写一个接口，来示意操作学生信息，先写一个插入学生信息的接口，那么必定是传一个学生对象进去。
IStduent.class
package dao;
import bean.Student;
public interface IStudentDao {public void insertStu(Student student);
}
上面就是接口的实现类（重点）：
StudentDaoImpl.class
package dao;
import java.io.IOException;
import java.io.InputStream;
import bean.Student;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
public class StudentDaoImpl implements IStudentDao {
// 实现插入的接口办法
public void insertStu(Student student) {
try {
InputStream inputStream;
// 读取配置信息的文件
inputStream = Resources.getResourceAsStream("mybatis.xml");
// 因为这个文件外面配置了 mapper.xml, 框架会帮咱们扫描这些 mapper.xml, 上面是初始化一个 SqlSessionFactory 对象
SqlSessionFactory sqlSessionFactory=new SqlSessionFactoryBuilder().build(inputStream);
// 工厂会获取一个 SqlSession 对象
SqlSession sqlSession=sqlSessionFactory.openSession();
// 通过这个对象能够查找之前 mapper.xml 外面配置好的 sql 的 id 与 `insertStudent` 相等的，执行对应的 sql
sqlSession.insert("insertStudent",student);
} catch (IOException e) {e.printStackTrace();
}
}
}
测试方法, 如果不理解 Junit 测试请参考 Junit 测试详解：
MyTest.class
import bean.Student;
import dao.IStudentDao;
import dao.StudentDaoImpl;
import org.junit.Before;
import org.junit.Test;
public class MyTest {
private IStudentDao dao;
@Before
public void Before(){dao=new StudentDaoImpl();
}
@Test
public void testInsert(){Student student=new Student("1ADAS",23,94.6);
dao.insertStu(student);
}
}测试的后果，从最初三行咱们能够看到执行的 sql 语句，以及参数等：
5.3 应用 Eclipse，MyEclipse 创立我的项目(Maven)
区别不大，间接创立 java Project，如果上面没有 lib 这个文件，就要新建一个，而后把须要的包导（复制粘贴）进去，选中 lib 上面所有的包，右键 –>
Build Path–>Add to Path
上面是 myEclipse 上面的结构图，代码没有扭转，须要本人下载相干的包
申明：这样的写法不是最好的，然而这是初学者最容易接受的写法，前面会缓缓的精简，咱们到时候不须要写接口的实现类，同时会把对于 sqlSessionFactory 相干的操作抽取进去成为一个工具类，就不必写那么多雷同的代码了。
6. 总结
最初总结一下下面写法的思路：
1. 先读取 mybatis.xml 文件流 inputStream，这是最重要的配置文件，外面的内容配置的是数据库环境，比方连贯哪一个数据库链接，除此之外，还有注册映射文件，比方扫描哪一个文件, 咱们配置的是/mapper.xml。
2. 通过inputStream 创立 sqlSessionFactory, 也就是 sql 会话工厂，所谓工厂，必定是用来发明或者制作sqlSession 的。
3.sqlSessionFactory.openSession()能够关上一个 sqlSession，也就是 sql 会话，取得这个操作数据库的会话窗口。
4. 通过sqlSession 提供的办法去操作数据库，提供办法名，和参数即可。比方 sqlSession.insert("insertStudent", student);，这个insertStudent 从哪里冒出来的？当然是后面扫描 mapper.xml 的时候，mapper.xml外面配置的,insertStudent是 id，须要是惟一的，就能通过这个找到对应的 sql 来执行。
5. 提交会话，commit, 不肯定须要，具体看数据库的类型.
6. 敞开会话,sqlSession.close();。
代码曾经放在：https://github.com/Damaer/Myb…
此文章仅代表本人（本菜鸟）学习积攒记录，或者学习笔记，如有侵权，请分割作者删除。人无完人，文章也一样，文笔稚嫩，在下不才，勿喷，如果有谬误之处，还望指出，感激不尽~
技术之路不在一时，山高水长，纵使迟缓，驰而不息。