文章目录
Mybatis第一章
一、内容介绍
-
框架的介绍
-
介绍mybatis框架
-
JDBC于Mybatis框架的比较
-
自定义Mybatis框架
-
mybatis框架的快速入门
二、框架的介绍
1、什么是框架
1. 半成品，
2. 饭店：买菜，油盐酱醋-- 洗菜 -- 炒菜--做饭 -- 刷锅，洗碗
3. 框架（Framework）是整个或部分系统的可重用设计，表现为一组抽象构件及构件实例间交互的方法；另一种定义认为，框架是可被应用开发者定制的应用骨架。前者是从应用方面而后者是从目的方面给出的定义。
简而言之，框架其实就是某种应用的半成品，就是一组组件，供你选用完成你自己的系统，或者说是使用别人搭好的舞台，你来做表演。框架一般是成熟的，不断升级的软件。
2、框架能解决什么问题
1、把技术封装起来
2、在开发中不应该考虑技术, 专注于逻辑（业务）开发
3、框架时位于底层技术 和应用程序之间的代码
4、框架要解决的最重要的一个问题是技术整合的问题，在JavaEE的 框架中，有着各种各样的技术，不同的软件企业需要从JavaEE中选择不同的技术，这就使得软件企业最终的应用依赖于这些技术，技术自身的复杂性和技术的风险性将会直接对应用造成冲击。而应用是软件企业的核心，是竞争力的关键所在，因此应该将应用自身的设计和具体的实现技术解耦。这样，软件企业的研发将集中在应用的设计上，而不是具体的技术实现，技术实现是应用的底层支撑，它不应该直接对应用产生影响。
3、软件开发的分层重要性
框架的重要性在于它实现了部分功能，并且能够很好的将低层应用平台和高层业务逻辑进行了缓和。为了实现软件工程中的“高内聚、低耦合”。把问题划分开来各个解决，易于控制，易于延展，易于分配资源。我们常见的MVC软件设计思想就是很好的分层思想。
通过分层更好的实现了各个部分的职责，在每一层将再细化出不同的框架，分别解决各层关注的问题。
4、三层架构中常用的框架
a、web：表现层: 处理用户请求和响应
servlet -- struts(放弃) -- struts2(放弃) -- springMVC(主流)
b、service:业务层
自己写业务 --- ejb -- spring(整合框架,业务)(不可取代)
c、dao: 持久层（数据接收对象）
jdbc--dbutils--BeanUtils -- jdbcTemplate -- hibernate(放弃)--mybatis(主流)--spring data jpa(趋势)
主流：整合： springmvc + spring + mybatis = ssm
趋势：整合：springmvc + spring +spring data = spring全家桶
-
解决数据持久化问题的框架
Mybatis MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code，并且改名为MyBatis 。2013年11月迁移到Github。 作为持久层的框架，还有一个封装程度更高的框架就是Hibernate，但这个框架因为各种原因目前在国内的流行程度下降太多，现在公司开发也越来越少使用。目前Mybatis框架是主流，未来使用Spring Data来实现数据持久化也是一种趋势。 -
解决WEB层问题的框架
SpringMVC Spring MVC属于SpringFrameWork的后续产品，已经融合在Spring Web Flow里面。Spring 框架提供了构建 Web 应用程序的全功能 MVC 模块。使用 Spring 可插入的 MVC 架构，从而在使用Spring进行WEB开发时，可以选择使用Spring的SpringMVC框架或集成其他MVC开发框架，如Struts1(现在一般不用)，Struts2(一般老项目使用)等。 -
解决技术整合问题的框架
Spring框架是由于软件开发的复杂性而创建的。Spring使用的是基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅仅限于服务器端的开发。从简单性、可测试性和松耦合性角度而言，绝大部分Java应用都可以从Spring中受益。 ◆目的：解决企业应用开发的复杂性 ◆功能：使用基本的JavaBean代替EJB，并提供了更多的企业应用功能 ◆范围：任何Java应用 Spring是一个轻量级控制反转(IoC)和面向切面(AOP)的容器框架。 -
Mybatis框架概述
Mybatis是一个优秀的基于Java的持久层框架，它内部封装了Jdbc，使开发者只需要关注sql语句本身，而不需要花费精力去处理加载驱动、创建连接、创建statement等繁杂的过程。 Mybatis通过xml或注解的方式将要执行的各种statement配置起来，并通过java对象和statement中sql的动态参数进行映射生成最终执行的sql语句，最后由Mybatis框架执行sql并将结果映射为java对象并返回。 采用ORM思想解决了实体和数据库映射的问题，对Jdbc进行了封装，屏蔽了Jdbc Api底层访问细节，使我们不用与Jdbc Api打交道，就可以完成对数据库的持久化操作。 ORM ：操作对象既是操作数据库 为了我们能够更好掌握框架运行的内部过程，并且有更好的体验，下面我们将从自定义Mybatis框架开始来学习框架。此时我们将会体验框架从无到有的过程体验，也能够很好的综合前面阶段所学的基础。
三、mybatis框架的介绍
1、jdbc中的代码
package com.sgw;
import com.sgw.domain.User;
import org.junit.Test;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;
/**
* 回顾jdbc代码
*/
public class TestJDBC {
@Test
public void test(){
List<User> userList = new ArrayList<>();
//1. 注册驱动
try {
Class.forName("com.mysql.jdbc.Driver");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
String url = "jdbc:mysql://localhost:3306/mybatisdb_sgw";
String username = "root";
String password = "root";
Connection conn = null;
PreparedStatement pst = null;
ResultSet rs = null;
try {
//2. 获取连接
conn = DriverManager.getConnection(url, username ,password);
// 3. SQL语句
String sql = "select * from user";
//4. 创建statement对象: Statement , PreparedStatement
pst = conn.prepareStatement(sql);
//5. 执行SQL语句，返回结果集
rs = pst.executeQuery();
//6. 处理结果集
while(rs.next()){//判断是否有下一条记录，如果有，说明有一个User对象
User user = new User();
//获取ResultSet中的值，赋值给user对象
int id = rs.getInt("id");
user.setId(id);
user.setUsername(rs.getString("username"));
user.setPassword(rs.getString("password"));
user.setSex(rs.getString("sex"));
user.setAddress(rs.getString("address"));
//添加到集合中
userList.add(user);
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
//7. 释放资源: 先开后关
if(rs != null){
try {
rs.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if(pst != null){
try {
pst.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if(conn != null){
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
//打印结果
for (User user : userList) {
System.out.println(user);
}
}
}
2、jdbc代码中的问题
a、频繁创建和释放数据库的连接对象，造成资源的浪费. 使用数据库连接池可以解决（c3p0 ,dbcp, spring jdbc ,durid）
b、sql语句硬编码(写死),如果数据库发生改变，需要重新编译代码，再运行 。 可以考虑把sql语句写到配置文件中
c、传参数硬编码，必须按照特定的顺序传参
d、处理结果集硬编码，如果改变了数据库，结果集的映射必须重新写，需要重新编译代码，再运行
e、连接的配置信息硬编码
3、mybatis框架的概述
MyBatis是一个优秀的持久层框架，它对jdbc的操作数据库的过程进行封装，使开发者只需要关注SQL本身，而不需要花费精力去处理例如注册驱动、创建connection、创建statement、手动设置参数、结果集检索等jdbc繁杂的过程代码。
实现基本的数据库操作功能的流程如下：
1.编写xml文件，配置运行环境。
2.通过IO流载入xml文件，创建SqlSessionFactory对象（会话工厂）。
3.由会话工厂，创建SqlSession对象（会话）。
4.通过SqlSession对象，操作数据库。注意增删改操作需要提交事务，否则对数据库做出的修改不会更改数据库中的记录。
5.最后需要关闭SqlSession对象和IO流，释放资源。
四、自定义框架（原理）
五、Mybatis框架的快速入门（重点）
1、添加依赖(jar)
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.4.5</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.6</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
2、编写pojo对象
package com.sgw.domain;
/**
* 包装类型： 初始值为null
* 基本数据类型：本身的值就是一个状态
*
*/
public class User {
private Integer id;
private String username;
private String password;
private String sex;
private String address;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
@Override
public String toString() {
return "User{" +
"id=" + id +
", username='" + username + '\'' +
", password='" + password + '\'' +
", sex='" + sex + '\'' +
", address='" + address + '\'' +
'}';
}
}
3、编写映射文件
<?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="com.sgw.dao.UserDao">
<select id="findAll" resultType="com.sgw.domain.User">
select * from user
</select>
</mapper>
4、编写核心配置文件
<?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>
<environments default="development">
<environment id="development">
<transactionManager type="JDBC" />
<dataSource type="POOLED">
<property name="driver" value="com.mysql.jdbc.Driver" />
<property name="url" value="jdbc:mysql://127.0.0.1:3306/mybatisdb_sgw?characterEncoding=utf8" />
<property name="username" value="root" />
<property name="password" value="root" />
</dataSource>
</environment>
</environments>
<!--关联映射文件-->
<mappers>
<mapper resource="com/sgw/mapper/UserMapper.xml"></mapper>
</mappers>
</configuration>
5、测试框架
package com.sgw;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Test;
import java.io.InputStream;
import java.util.List;
public class TestCustomFrame {
@Test
public void test(){
//获取配置文件的输入流对象
InputStream inputStream = this.getClass().getClassLoader().getResourceAsStream("SqlMapConfig.xml");
//创建SqlSessionFactoryBuilder对象
SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
//创建SqlSessionFactory对象
SqlSessionFactory sessionFactory = sqlSessionFactoryBuilder.build(inputStream);
//获取sqlSession对象
SqlSession sqlSession = sessionFactory.openSession();
//执行sql语句
List list = sqlSession.selectList("com.sgw.dao.UserDao.findAll");
//遍历结果集
for (Object o : list) {
System.out.println(o);
}
//关闭资源
sqlSession.close();
}
}
六、工厂模式
什么是工厂模式
1.工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
2.在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，是通过使用一个共同的接口来指向新创建的对象。
栗子
您需要一辆汽车，可以直接从工厂里面提货，而不用去管这辆汽车是怎么做出来的，以及这个汽车里面的具体实现。
优缺点
优点： 1、一个调用者想创建一个对象，只要知道其名称就可以了。 2、扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。 3、屏蔽产品的具体实现，调用者只关心产品的接口。
缺点：每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。
七、构建者模式
什么是构建者模式
构建者模式一般用在构建流程或者组成部件固定的场合，将这些部件分开构建成为组件对象，再将这些组件对象整合成为目标对象。
栗子
组装台式电脑的情况，我们可以分别购买主板、CPU、内存、硬盘等部件，然后将这些部件组装在一起就形成了一台完整的电脑。
构建者模式和工厂模式的区别
工厂模式一般都是创建一个产品，注重的是把这个产品创建出来就行，只要创建出来，不关心这个产品的组成部分。从 代码上看，工厂模式就是一个方法，用这个方法就能生产出产品。
构建者模式也是创建一个产品，但是不仅要把这个产品创建出来，还要关心这个产品的组成细节，组成过程。从代码上看，建造者模式在建造产品时，这个产品有很多方法，建造者模式会根据这些相同方法但是不同执行顺序建造出不同组成细节的产品
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
