jdbc、Mybatis、Hibernate介绍（非原创）
文章大纲
一、jdbc介绍
二、Mybatis介绍
三、Hibernate介绍
四、jdbc、Mybatis、Hibernate比较
五、参考文章
一、jdbc介绍
1. jdbc编程步骤
（1）加载数据库驱动
（2）创建并获取数据库链接
（3）创建jdbc statement对象
（4）设置sql语句
（5）设置sql语句中的参数(使用preparedStatement)
（6）通过statement执行sql并获取结果
（7）对sql执行结果进行解析处理
（8）释放资源(resultSet、preparedstatement、connection)
2. jdbc的缺点
（1）工作量比较大，需要连接，然后处理jdbc底层事务，处理数据类型，还需要操作Connection，Statement对象和ResultSet对象去拿数据并关闭他们。
（2）我们对jdbc编程可能产生的异常进行捕捉处理并正确关闭资源。
二、Mybatis介绍
1. Mybatis操作教程
https://www.jianshu.com/p/73cb40bc5d46
2. Mybatis特点
（1）为了解决Hibernate的不足，Mybatis出现了，Mybatis是半自动的框架。之所以称它为半自动，是因为它需要手工匹配提供POJO，sql和映射关系，而全表映射的Hibernate只需要提供pojo和映射关系即可。
（2）Mybatis需要提供的映射文件包含了一下三个部分：sql，映射规则，pojo。在Mybatis里面你需要自己编写sql，虽然比Hibernate配置多，但是Mybatis可以配置动态sql，解决了hibernate表名根据时间变化，
（3）不同条件下列不一样的问题，同时你也可以对sql进行优化，通过配置决定你的sql映射规则，也能支持存储过程，所以对于一些复杂和需要优化性能的sql查询它就更加方便。Mybatis几乎可以做到jdbc所有能做到的事情。
（4）入门简单，即学即用，提供了数据库查询的自动对象绑定功能，而且延续了很好的SQL使用经验，对于没有那么高的对象模型要求的项目来说，相当完美。
（5）可以进行更为细致的SQL优化，可以减少查询字段。
（6）缺点就是框架还是比较简陋，功能尚有缺失，虽然简化了数据绑定代码，但是整个底层数据库查询实际还是要自己写的，工作量也比较大，而且不太容易适应快速数据库修改。
（7）二级缓存机制不佳。
三、Hibernate介绍
1. Hibernate代码实操
1.1 Hibernate的核心组件
在基于MVC设计模式的JAVA WEB应用中，Hibernate可以作为模型层/数据访问层。它通过配置文件(hibernate.properties或hibernate.cfg.xml)和映射文件(***.hbm.xml)把JAVA对象或PO(Persistent Object,持久化对象)映射到数据库中的数据库，然后通过操作PO，对数据表中的数据进行增，删，改，查等操作。
除配置文件，映射文件和持久化类外，Hibernate的核心组件包括以下几部分：
（1）Configuration类：用来读取Hibernate配置文件，并生成SessionFactory对象。
（3）Session接口：用来操作PO。它有get(),load(),save(),update()和delete()等方法用来对PO进行加载，保存，更新及删除等操作。它是Hibernate的核心接口。
（4）Query接口：用来对PO进行查询操。它可以从Session的createQuery()方法生成。
（5）Transaction接口：用来管理Hibernate事务，它主要方法有commit()和rollback()，可以从Session的beginTrancation()方法生成。
1.2 Hibernate的运行过程
（1）应用程序先调用Configration类，该类读取Hibernate的配置文件及映射文件中的信息，并用这些信息生成一个SessionFactpry对象。
（2）然后从SessionFactory对象生成一个Session对象，并用Session对象生成Transaction对象;可通过Session对象的get(),load(),save(),update(),delete()和saveOrUpdate()等方法对PO进行加载，保存，更新，删除等操作;在查询的情况下，可通过Session对象生成一个Query对象，然后利用Query对象执行查询操作;如果没有异常，Transaction对象将 提交这些操作结果到数据库中。
Hibernate的运行过程如下图：
1.3 创建项目并导入jar包
1.4 创建学生实体类
package cn.zhang.entity;
//实体类
public class Student {
private int stuno;
private String stuname;
private int stuage;
private int stuid;
private int stuseat;
public Student() {
super();
// TODO Auto-generated constructor stub
}
public Student(String stuname, int stuage, int stuid, int stuseat) {
super();
this.stuname = stuname;
this.stuage = stuage;
this.stuid = stuid;
this.stuseat = stuseat;
}
public Student(int stuno, String stuname, int stuage, int stuid, int stuseat) {
super();
this.stuno = stuno;
this.stuname = stuname;
this.stuage = stuage;
this.stuid = stuid;
this.stuseat = stuseat;
}
public int getStuid() {
return stuid;
}
public void setStuid(int stuid) {
this.stuid = stuid;
}
public int getStuseat() {
return stuseat;
}
public void setStuseat(int stuseat) {
this.stuseat = stuseat;
}
public int getStuno() {
return stuno;
}
public void setStuno(int stuno) {
this.stuno = stuno;
}
public String getStuname() {
return stuname;
}
public void setStuname(String stuname) {
this.stuname = stuname;
}
public int getStuage() {
return stuage;
}
public void setStuage(int stuage) {
this.stuage = stuage;
}
}
1.5 在src下设计Hibernate配置文件hibernate.cfg.xml
<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<!-- Database connection settings -->
<property name="connection.driver_class">oracle.jdbc.OracleDriver</property>
<property name="connection.url">jdbc:oracle:thin:@localhost:1521:orcl</property>
<property name="connection.username">zhangzong</property>
<property name="connection.password">123</property>
<!-- SQL dialect (SQL 方言)-->
<property name="dialect">org.hibernate.dialect.Oracle10gDialect</property>
<!-- Drop and re-create the database schema on startup -->
<property name="hbm2ddl.auto">update</property>
<!-- Echo all executed SQL to stdout 在控制台打印后台的SQL语句-->
<property name="show_sql">true</property>
<!-- 格式化显示SQL -->
<property name="format_sql">true</property>
<!-- JDBC connection pool (use the built-in) -->
<!-- <property name="connection.pool_size">1</property> -->
<!-- Enable Hibernate's automatic session context management -->
<!-- <property name="current_session_context_class">thread</property> -->
<!-- Disable the second-level cache -->
<!-- <property name="cache.provider_class">org.hibernate.cache.NoCacheProvider</property>-->
<mapping resource="cn/zhang/entity/Student.hbm.xml" />
</session-factory>
</hibernate-configuration>
1.6 在实体类下设计映射文件Student.hbm.xml（在配置文件hibernate.cfg.xml使用)
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="cn.zhang.entity">
<class name="Student" table="stuinfo">
<id name="stuno" column="stuno">
<!-- 主键生成策略：native:
native:如果后台是Oracle
后台是MySQL，自动应用自增 -->
<generator class="native"/>
</id>
<property name="stuname" type="string" column="stuname"/>
<property name="stuage"/>
<property name="stuid" type="int" column="stuid"/>
<property name="stuseat"/>
</class>
</hibernate-mapping>
1.7 更新（新增）一个学生记录
package cn.zhang.test;
//新增一条数据
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.classic.Session;
import cn.zhang.entity.Student;
public class InsertTest {
public static void main(String[] args) {
//准备对象
Student student=new Student("光衣", 12,112333,2);//Student.hbm.xml已配置编号为自增，所以这里不用添加编号了
//读取大配置文件，获取要连接的数据库信息
Configuration configuration=new Configuration().configure();
//创建SessionFactory
SessionFactory factory = configuration.buildSessionFactory();
//加工session
Session openSession = factory.openSession();
Transaction beginTransaction = openSession.beginTransaction();
openSession.save(student);
beginTransaction.commit();
System.out.println("成功");
}
}
1.8 修改一个学生信息
package cn.zhang.test;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.classic.Session;
import cn.zhang.entity.Student;
public class UpdateTest {
/**
* @param args
*/
public static void main(String[] args) {
//1.读取大配置文件，获取要连接的数据库信息
Configuration conf=new Configuration().configure();
//2.创建SessionFactory
SessionFactory factory =conf.buildSessionFactory();
//3加工session
Session session = factory.openSession();
Transaction tx=session.beginTransaction();
//获取对象
Student stu =new Student(1,"光衣", 12,112333,2);
//更新
session.update(stu);
//提交事务
tx.commit();
System.out.println("更新成功");
}
}
1.9 删除一个指定学生信息
package cn.zhang.test;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.classic.Session;
import cn.zhang.entity.Student;
public class DeleteTest {
public static void main(String[] args) {
//1.读取大配置文件，获取要连接的数据库信息
Configuration conf=new Configuration().configure();
//2.创建SessionFactory
SessionFactory factory =conf.buildSessionFactory();
//3.加工session
Session session = factory.openSession();
Transaction tx=session.beginTransaction();
//获取对象
Student stu =new Student();
stu.setStuno(3);//指定要删除的编号
//删除指定
session.delete(stu);
//提交事务
tx.commit();
System.out.println("删除成功");
}
}
1.10 查询一个指定学生信息
package cn.zhang.test;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.classic.Session;
import cn.zhang.entity.Student;
public class SelectTest {
public static void main(String[] args) {
//1.读取大配置文件，获取要连接的数据库信息
Configuration conf=new Configuration().configure();
//2.创建SessionFactory
SessionFactory factory =conf.buildSessionFactory();
//3.打开session
Session session = factory.openSession();
//4.加载数据操作
//如果表中没有你指定的主键列，get()方法的是null
Student student =(Student)session.get(Student.class, 4);
//如果表中没有你指定的主键列，程序运行到student.getStuname()时会抛出异常
//Student student =(Student)session.load(Student.class, 4);
//5.输出数据
System.out.println(student.getStuname());
//6.关闭session
session.close();
}
}
2. Hibernate的优点
（1）消除了代码的映射规则，它全部分离到了xml或者注解里面去配置。
（2）无需在管理数据库连接，它也配置到xml里面了。
（3）一个会话中不需要操作多个对象，只需要操作Session对象。
（4）关闭资源只需要关闭一个Session便可。
（5） 这就是Hibernate的优势，在配置了映射文件和数据库连接文件后，Hibernate就可以通过Session操作，非常容易，消除了jdbc带来的大量代码，大大提高了编程的简易性和可读性。Hibernate还提供了级联，缓存，映射，一对多等功能。Hibernate是全表映射，通过HQL去操作pojo进而操作数据库的数据。
3. Hibernate的缺点
（1）全表映射带来的不便，比如更新时需要发送所有的字段。
（2）无法根据不同的条件组装不同的SQL。
（3）对多表关联和复杂的sql查询支持较差，需要自己写sql，返回后，需要自己将数据封装为pojo。
（4）不能有效的支持存储过程。
（5）虽然有HQL，但是性能较差，大型互联网系统往往需要优化sql，而hibernate做不到。
四、jdbc、Mybatis、Hibernate比较
1. 什么时候使用Hibernate，Mybatis
（1）Hibernate作为留下的Java orm框架，它确实编程简易，需要我们提供映射的规则，完全可以通过IDE生成，同时无需编写sql确实开发效率优于Mybatis。此外Hibernate还提供了缓存，日志，级联等强大的功能，
（2）但是Hibernate的缺陷也是十分明显，多表关联复杂sql，数据系统权限限制，根据条件变化的sql，存储过程等场景使用Hibernate十分不方便，而性能又难以通过sql优化，所以注定了Hibernate只适用于在场景不太复杂，要求性能不太苛刻的时候使用。
（3）如果你需要一个灵活的，可以动态生成映射关系的框架，那么Mybatis确实是一个最好的选择。它几（4）但是它的缺陷是需要你提供映射规则和sql，所以开发工作量比hibernate要大些。
（5）mybatis：机械工具，使用方便，拿来就用，但工作还是要自己来作，不过工具是活的，怎么使由我决定。
（6）hibernate：智能机器人，但研发它(学习、熟练度)的成本很高，工作都可以摆脱他了，但仅限于它能做的事。
2. 多维度比较Hibernate，Mybatis
2.1 开发速度
Mybatis其实要比Hibernate要更好上手，因为Hibernate是对JDBC的深度封装，而Mybatis就显得更加开放，而且简单易学。这也是Mybatis更加流行的原因，正因为如此，Mybatis的开发社区近年来也开始活跃起来，下载一些支持开发的工具也较为方便；Mybatis也有自己的代码生成工具，可以生成简单基本的DAO层方法，针对高级查询，Mybatis需要手动编写SQL语句，以及ResultMap。而Hibernate有良好的映射机制，开发者无需关心SQL的生成与结果映射，可以把更多的精力放在业务流程上。
2.2 系统调优方面
Hibernate可以制定合理的缓存策略，在延迟加载方面处理得较好，有较为合理的Session管理机制，便于批量抓取，同时有合理的O/R映射设计。Mybatis在调优方面，同样有Session机制和二级缓存，同时还可以对SQL进行优化设计；Hibernate一般是查询数据库的所有字段，如果指定字段查询，程序较为繁琐，而Mybatis的SQL是手动编写的，所以可以按需求指定查询的字段。虽然Hibernate具有自己的日志统计，但同样可以通过Log4j进行日志记录。
2.3 对象管理方面
Hibernate 是完整的对象/关系映射解决方案，对象管理功能比较完善，使开发者不用再关注底层数据库系统的细节。也就是说，相对于常见的 JDBC/SQL 持久层方案中需要管理 SQL 语句，Hibernate采用了更自然的面向对象的视角来持久化 Java 应用中的数据。而MyBatis在这方面没有特定的文档说明，但也便于开发者发挥自身的想法来对对象进行管理。
2.4 缓存机制方面
Hibernate的一级缓存是Session缓存，一级缓存是与Session的生命周期相关的。而它的二级缓存是SessionFactory级的缓存其中可分为内置缓存和外置缓存，其中的内置缓存中存放了关于SessionFactory对象的一些集合属性包含的数据，包括映射元素据及预定SQL语句等；而Mybatis一般也可分为二级缓存，一级缓存是 SqlSession 级别的缓存二级缓存是 mapper 级别的缓存，多个 SqlSession 共享，而它默认状态是开启一级缓存，这样对开发者而言是一种便捷。但也有人指出，Mybatis的缓存机制在一定程度上限制了Mybatis的推广。
3. Jdbc,Mybatis,Hibernate的区别
（1）从层次上看，JDBC是较底层的持久层操作方式，而Hibernate和MyBatis都是在JDBC的基础上进行了封装使其更加方便程序员对持久层的操作。
（2）从功能上看，JDBC就是简单的建立数据库连接，然后创建statement，将sql语句传给statement去执行，如果是有返回结果的查询语句，会将查询结果放到ResultSet对象中，通过对ResultSet对象的遍历操作来获取数据；Hibernate是将数据库中的数据表映射为持久层的Java对象，对sql语句进行修改和优化比较困难；MyBatis是将sql语句中的输入参数和输出参数映射为java对象，sql修改和优化比较方便。
（3）从使用上看，如果进行底层编程，而且对性能要求极高的话，应该采用JDBC的方式；如果要对数据库进行完整性控制的话建议使用Hibernate；如果要灵活使用sql语句的话建议采用MyBatis框架。
