MyBatis01

《MyBatis(第1天)-自定义框架-笔记》

回顾

JDBC四个核心对象

DriverManager: 注册驱动，获取连接

Connection: 表示连接，java程序和数据库之间的桥梁

Statement: 执行SQL语句的对象，小货车

ResultSet: 结果集，查询的结果都会保存到结果集中

JDBC操作数据库的步骤

1. 注册驱动
2. 获取连接
3. 获取小货车
4. 执行SQL语句
5. 处理结果集
6. 关闭资源

如何解决SQL注入问题

使用PreparedStatement

学习目标

1. 能够了解什么是框架

2. 掌握mybatis框架开发快速入门

3. 理解自定义mybatis框架

项目名称

mybatis_day01_01_helloworld 体验mybatis第1个项目

mybatis_day0101_02_framework 自定义框架

连接池介绍

目标

学习连接池的原理和好处

没有连接池的现状

1. 之前JDBC访问数据库的步骤：
   创建数据库连接 →运行SQL语句→关闭连接
   每次数据库访问执行这样重复的动作
   

2. 每次创建数据库连接的问题

   • 获取数据库连接需要消耗比较多的资源，而每次操作都要重新获取新的连接对象，执行一次操作就把连接关闭，而数据库创建连接通常需要消耗相对较多的资源，创建时间也较长。这样数据库连接对象的使用率低。
   • 假设网站一天10万访问量，数据库服务器就需要创建10万次连接，极大的浪费数据库的资源，并且极易造成数据库服务器内存溢出

   我们现实生活中每日三餐。我们并不会吃一餐饭就将碗丢掉，而是吃完饭后将碗放到碗柜中，下一餐接着使用。目的是重复利用碗，我们的数据库连接也可以重复使用，可以减少数据库连接的创建次数。提高数据库连接对象的使用率。

连接池的概念: 连接池是创建和管理数据库连接的缓冲池技术。连接池就是一个容器，连接池中保存了一些数据库连接，这些连接是可以重复使用的。

连接池的原理

1. 启动连接池,连接池就会初始化一些连接
2. 当用户需要使用数据库连接,直接从连接池中取出
3. 当用户使用完连接,会将连接重新放回连接池中

连接池好处

连接池中会保存一些连接，这些连接可以重复使用，降低数据资源的消耗

常用连接池的介绍

javax.sql.DataSource表示数据库连接池，是JDK中提供的一个接口，没有具体的实现，它的实现由连接池的厂商去实现。我们只需要学习这个工具如何使用即可。

public interface DataSource {
	Connection getConnection();
	...
}

常用的连接池实现组件有以下这些

1. 阿里巴巴-德鲁伊Druid连接池：Druid是阿里巴巴开源平台上的一个项目
2. C3P0是一个开源的连接池，目前使用它的开源项目有Hibernate，Spring等。
3. DBCP(DataBase Connection Pool)数据库连接池，是Apache上的一个Java连接池项目，也是Tomcat使用的连接池组件。

小结

连接池的原理?

1.启动连接池,连接池就会初始化一些连接
2.当用户需要使用数据库连接,直接从连接池中取出
3.当用户使用完连接,会将连接重新放回连接池中

连接池的好处？

连接池中会存放一些连接，这些连接可以重复使用，降低数据库的资源消耗

C3P0连接池

目标

学习C3P0连接池

C3P0连接池简介

C3P0地址：https://sourceforge.net/projects/c3p0/?source=navbar
C3P0是一个开源的连接池。Hibernate框架，默认推荐使用C3P0作为连接池实现。
C3P0的jar包：c3p0-0.9.1.2.jar

C3P0常用的配置参数解释

参数	说明
initialPoolSize	连接池刚启动时，连接池内包含的连接数量
maxPoolSize	连接池中最多可以放多少个连接
checkoutTimeout	连接池中没有连接时最长等待时间
maxIdleTime	连接池中的空闲连接多久没有使用就会回收。默认是0，0表示不回收

C3P0配置文件

我们看到要使用C3P0连接池，需要设置一些参数。那么这些参数怎么设置最为方便呢？使用配置文件方式。

配置文件的要求

1. 文件名：c3p0-config.xml
2. 放在源代码即src目录下

配置文件c3p0-config.xml

 <c3p0-config>
   <!-- 使用默认的配置读取连接池对象 -->
   <default-config>
     <!--  连接参数 -->
     <property name="driverClass">com.mysql.jdbc.Driver</property>
     <property name="jdbcUrl">jdbc:mysql://localhost:3306/day16</property>
     <property name="user">root</property>
     <property name="password">root</property>

     <!-- 连接池参数 -->
     <property name="initialPoolSize">5</property>
     <property name="maxPoolSize">10</property>
     <property name="checkoutTimeout">2000</property>
     <property name="maxIdleTime">1000</property>
   </default-config>

   <named-config name="itheimac3p0"> 
     <!--  连接参数 -->
     <property name="driverClass">com.mysql.jdbc.Driver</property>
     <property name="jdbcUrl">jdbc:mysql://localhost:3306/day25</property>
     <property name="user">root</property>
     <property name="password">root</property>

     <!-- 连接池参数 -->
     <property name="initialPoolSize">5</property>
     <property name="maxPoolSize">15</property>
     <property name="checkoutTimeout">2000</property>
     <property name="maxIdleTime">1000</property>
   </named-config>
 </c3p0-config>

API介绍

com.mchange.v2.c3p0.ComboPooledDataSource类表示C3P0的连接池对象，常用2种创建连接池的方式：
1.无参构造，使用默认配置
2.有参构造，使用命名配置

ComboPooledDataSource类API

1. public ComboPooledDataSource()
   无参构造使用默认配置（使用xml中default-config标签中对应的参数）
   

2. public ComboPooledDataSource(String configName)
   有参构造使用命名配置（configName：xml中配置的名称，使用xml中named-config标签中对应的参数）
   

3. public Connection getConnection() throws SQLException
   从连接池中取出一个连接
   

使用步骤

1. 导入jar包c3p0-0.9.5.2.jar和mchange-commons-java-0.2.12.jar
2. 编写c3p0-config.xml配置文件，配置对应参数
3. 将配置文件放在src目录下
4. 创建连接池对象ComboPooledDataSource，使用默认配置或命名配置
5. 从连接池中获取连接对象
6. 使用连接对象操作数据库
7. 关闭资源,将连接还回连接池中

注意事项

C3P0配置文件名称必须为c3p0-config.xml
C3P0命名配置可以有多个

案例代码

1. 准备数据

   CREATE TABLE student (
      id INT PRIMARY KEY AUTO_INCREMENT,
      NAME VARCHAR(20),
      age INT,
      score DOUBLE DEFAULT 0.0
   );
   

2. 配置文件

    <c3p0-config>
      <!-- 使用默认的配置读取连接池对象 -->
      <default-config>
        <!--  连接参数 -->
        <property name="driverClass">com.mysql.jdbc.Driver</property>
        <property name="jdbcUrl">jdbc:mysql://localhost:3306/day25</property>
        <property name="user">root</property>
        <property name="password">root</property>
   
        <!-- 连接池参数 -->
        <property name="initialPoolSize">5</property>
        <property name="maxPoolSize">10</property>
        <property name="checkoutTimeout">2000</property>
        <property name="maxIdleTime">1000</property>
      </default-config>
   
      <named-config name="itheimac3p0"> 
        <!--  连接参数 -->
        <property name="driverClass">com.mysql.jdbc.Driver</property>
        <property name="jdbcUrl">jdbc:mysql://localhost:3306/day25</property>
        <property name="user">root</property>
        <property name="password">root</property>
   
        <!-- 连接池参数 -->
        <property name="initialPoolSize">5</property>
        <property name="maxPoolSize">15</property>
        <property name="checkoutTimeout">2000</property>
        <property name="maxIdleTime">1000</property>
      </named-config>
    </c3p0-config>
   

3. java代码

    public class Demo01 {
   
        public static void main(String[] args) throws Exception {
            // 方式一: 使用默认配置（default-config）
            // new ComboPooledDataSource();
    //		 ComboPooledDataSource ds = new ComboPooledDataSource();
   
            // 方式二： 使用命名配置（named-config：配置名）
            // new ComboPooledDataSource("配置名");
            ComboPooledDataSource ds = new ComboPooledDataSource("otherc3p0");
   
    //		for (int i = 0; i < 10; i++) {
    //			Connection conn = ds.getConnection();
    //			System.out.println(conn);
    //		}
   
            // 从连接池中取出连接
            Connection conn = ds.getConnection();
   
            // 执行SQL语句
            String sql = "INSERT INTO student VALUES (NULL, ?, ?, ?);";
            PreparedStatement pstmt = conn.prepareStatement(sql);
            pstmt.setString(1, "张三");
            pstmt.setInt(2, 25);
            pstmt.setDouble(3, 99.5);
   
            int i = pstmt.executeUpdate();
            System.out.println("影响的行数： " + i);
            pstmt.close();
            conn.close(); // 将连接还回连接池中
        }
    }
   

案例效果

1. 正常获取连接池中连接
   

2. 获取连接池中连接超时
   

3. 使用连接池中的连接往数据库添加数据
   

注意：配置文件名称必须为：c3p0-config.xml，将配置文件放在src目录下

使用配置文件方式好处

只需要单独修改配置文件，不用修改代码
多个配置的好处：

1. 可以连接不同的数据库：db1,db2
2. 可以使用不同的连接池参数：maxPoolSize
3. 可以连接不同厂商的数据库：Oracle或MySQL

小结

CP30使用步骤？

1. 导入Jar包:c3p0-0.9.5.2.jar,mchange-commons-java-0.2.12.jar
2. 复制c3p0-config.xml,修改参数
3. c3p0-config.xml放到src里面
4. 在代码中创建C3P0连接池对象,CombopooledDataSource对象
5. 从连接池中获取连接
6. 执行SQL语句
7. 将连接还回连接池中

C3P0常用参数？

initialPoolSize	启动连接池时,初始化的连接数量
maxPoolSize	连接池最大的连接数量
checkoutTimeout	连接池没有连接时,最大的等待时间,单位是毫秒
maxIdleTime	连接池中的连接空闲多久会被销毁,默认是0,0表示不销毁

Druid连接池

目标

学习Druid连接池的使用

Druid连接池介绍

Druid是阿里巴巴开发的号称为监控而生的数据库连接池，Druid是目前最好的数据库连接池。在功能、性能、扩展性方面，都超过其他数据库连接池，同时加入了日志监控，可以很好的监控数据库连接池和SQL的执行情况。Druid已经在阿里巴巴部署了超过600个应用，经过一年多生产环境大规模部署的严苛考验。Druid地址：https://github.com/alibaba/druid 

DRUID连接池使用的jar包：druid-1.0.9.jar

Druid常用的配置参数

参数	说明
initialSize	刚启动连接池时,连接池中包含连接的数量
maxActive	连接池中最多可以放多少个连接
maxWait	获取连接时最大等待时间，单位毫秒

Druid连接池基本使用

API介绍

com.alibaba.druid.pool.DruidDataSourceFactory类有创建连接池的方法

public static DataSource createDataSource(Properties properties)
创建一个连接池，连接池的参数使用properties中的数据

我们可以看到Druid连接池在创建的时候需要一个Properties对象来设置参数，所以我们使用properties文件来保存对应的参数。
Druid连接池的配置文件名称随便，放到src目录下面方便加载
druid.properties文件内容：

driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://127.0.0.1:3306/day17
username=root
password=root
initialSize=5
maxActive=10
maxWait=3000

使用步骤

1. 导入druid的jar包

2. 在src目录下创建一个properties文件，并设置对应参数

3. 加载properties文件的内容到Properties对象中

4. 创建Druid连接池，使用配置文件中的参数

5. 从Druid连接池中取出连接

6. 执行SQL语句

7. 关闭资源

案例代码

1. 在src目录下新建一个Druid配置文件，命名为：druid.properties，内容如下

driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://127.0.0.1:3306/day25
username=root
password=root
initialSize=5
maxActive=10
maxWait=3000

java代码

public class Demo04 {
	public static void main(String[] args) throws Exception {
		// 加载配置文件中的配置参数
		InputStream is = Demo04.class.getResourceAsStream("/druid.properties");
		Properties pp = new Properties();
		pp.load(is);
		
		// 创建连接池，使用配置文件中的参数
		DataSource ds = DruidDataSourceFactory.createDataSource(pp);
		
//		for (int i = 0; i < 10; i++) {
//			Connection conn = ds.getConnection();
//			System.out.println(conn);
//		}
		
		// 从连接池中取出连接
		Connection conn = ds.getConnection();
		
		// 执行SQL语句
		String sql = "INSERT INTO student VALUES (NULL, ?, ?, ?);";
		PreparedStatement pstmt = conn.prepareStatement(sql);
		pstmt.setString(1, "王五");
		pstmt.setInt(2, 35);
		pstmt.setDouble(3, 88.5);
		
		int i = pstmt.executeUpdate();
		System.out.println("影响的行数： " + i);
		
		// 执行查询
		sql = "SELECT * FROM student;";
		ResultSet rs = pstmt.executeQuery(sql);
		
		while (rs.next()) {
			int id = rs.getInt("id");
			String name = rs.getString("name");
			int age = rs.getInt("age");
			double score = rs.getDouble("score");
			System.out.println("id: " + id + " ,name: " + name + " ,age = " + age + " ,score = " + score);
		}
		
		pstmt.close();
		conn.close(); // 将连接还回连接池中
	}
}

案例效果

1. 正常获取连接池中的连接
   
2. 获取连接池中的连接超时
   
3. 使用DRUID连接池中的连接操作数据库
   

小结

Druid使用步骤?

1. 导入Druid的jar包
2. 复制druid.properties到src下,并修改配置
3. 在代码中加载properties到Properties对象中
4. 创建Druid连接池
5. 从Druid连接池中取出连接
6. 执行SQL
7. 关闭

Druid常用的配置参数

参数	说明
initialSize	刚启动连接池时,初始化连接的数量
maxActive	连接池中最大的连接数量
maxWait	没有连接时,最大的等待时间

Druid连接池基本使用不管是C3P0连接池，配置大致都可以分为2种：1.连接数据库的参数，2.连接池的参数，这2种配置大致参数作用都相同，只是参数名称可能不一样。

编写连接池工具类

我们每次操作数据库都需要创建连接池，获取连接，关闭资源，都是重复的代码。我们可以将创建连接池和获取连接池的代码放到一个工具类中，简化代码。

目标

编写一个连接池的工具类，简化Druid连接池的使用

连接池工具类步骤

1. 声明静态连接池成员变量
2. 创建连接池对象
3. 定义得到连接池的方法
4. 定义得到连接对象的方法
5. 定义关闭资源的方法

案例代码

DataSourceUtils.java

public class DataSourceUtils {
	// 1.声明静态数据源成员变量
	private static DataSource ds;

	// 2.创建连接池对象
	static {
		// 加载配置文件中的数据
		InputStream is = DataSourceUtils.class.getResourceAsStream("/druid.properties");
		Properties pp = new Properties();
		try {
			pp.load(is);
			// 创建连接池，使用配置文件中的参数
			ds = DruidDataSourceFactory.createDataSource(pp);
		} catch (IOException e) {
			e.printStackTrace();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	// 3. 定义得到数据源的方法
	public static DataSource getDataSource() {
		return ds;
	}

	// 4. 定义得到连接对象的方法
	public static Connection getConnection() throws SQLException {
		return ds.getConnection();
	}

	// 5.定义关闭资源的方法
	public static void close(Connection conn, Statement stmt, ResultSet rs) {
		if (rs != null) {
			try {
				rs.close();
			} catch (SQLException e) {}
		}

		if (stmt != null) {
			try {
				stmt.close();
			} catch (SQLException e) {}
		}

		if (conn != null) {
			try {
				conn.close();
			} catch (SQLException e) {}
		}
	}

	// 6.重载关闭方法
	public static void close(Connection conn, Statement stmt) {
		close(conn, stmt, null);
	}
}

测试类代码

public class Demo03 {
	public static void main(String[] args) throws Exception {
		// 拿到连接
		Connection conn = DataSourceUtils.getConnection();

		// 执行sql语句
		String sql = "INSERT INTO student VALUES (NULL, ?, ?, ?);";
		PreparedStatement pstmt = conn.prepareStatement(sql);
		pstmt.setString(1, "李四");
		pstmt.setInt(2, 30);
		pstmt.setDouble(3, 50);
		int i = pstmt.executeUpdate();
		System.out.println("影响的函数: " + i);

		// 关闭资源
		DataSourceUtils.close(conn, pstmt);
	}
}

使用连接池工具类后可以简化代码，我们重点是写SQL去执行。

小结

编写连接池工具类步骤

1. 声明静态连接池成员变量
2. 创建连接池对象
3. 返回连接池中的连接
4. 定义close关闭资源

项目三层架构介绍

分层介绍-公司中分层

软件中分层

分层的作用

1. 解耦：降低层与层之间的耦合性。
2. 可维护性：提高软件的可维护性，对现有的功能进行修改和更新时不会影响原有的功能。
3. 可扩展性：提升软件的可扩展性，添加新的功能的时候不会影响到现有的功能。

小结

三层架构

表示层：和用户交互的界面

业务层(Service)：处理业务逻辑

数据访问层(DAO/ Data Access Object)：操作数据库的

三层架构好处：

1. 降低层与层之间的耦合性。
2. 提高软件的可维护性
3. 提升软件的可扩展性

使用三层架构完成用户登录案例

目标

使用三层架构完成用户登录案例

小结

框架概述

我们在企业开发中为了提高开发效率会使用框架进行开发ssm。什么是框架呢？

目标

1. 学习框架的概念

2. 框架解决了哪些问题

什么是框架

之前我们都是根据需求写出所有的相关代码麻烦，累，繁琐。框架是对常见功能的封装，一个半成品。我们在框架的基础上开发出成品的软件。

假如你要造一辆马车，在没有零件的情况下，你需要自己去伐木，去把木头做成木板，木棍，然后做成轮子，门，等部件，然后组装起来，很麻烦。

框架就相当于现成的轮子，门等部件。我们只需要拿过来使用即可。

框架是别人写好的代码，是对常见功能的封装，是一个半成品。

常见框架如：Spring，SpringMVC，Mybatis，JdbcTemplate，Bootstrap等等。

框架解决的问题

提升了开发效率

企业项目中使用框架，程序员不再需要重复造轮子，只需要专注实现业务需求，提升了开发效率。

提升了系统稳定性

一个成熟的框架，经过了在众多企业项目中的验证使用，稳定性有保障。

项目分层

在J2EE应用中，通常把项目整体进行分层设计。有表现层、业务层、持久层。

分层开发下常见框架

持久层框架

MyBatis是一款优秀的持久层框架，MyBatis 避免了几乎所有的 JDBC代码和手动设置参数以及获取结果集。

关于持久层的框架，还有一个封装程度更高的框架（hibernate）。该框架相对比较重量级，以及其它各个方面的原因，目前流行程度下降了很多，企业项目中用的越来越少了。

表现层框架

SpringMVC是一种基于Java，实现了Web MVC设计模式，将Web层进行解耦。SpringMVC可以简化我们日常Web开发。

整合的框架

Spring是一个轻量级控制反转(IoC)和面向切面(AOP)的容器框架。让开发变的更简单。

小结

什么是框架，它解决了哪些问题?

1. 什么是框架？框架是别人写好的代码，是对常见功能的封装，是一个半成品。
2. 框架解决了哪些问题：提高开发效率，提高稳定性。

mybatis框架介绍和下载

mybatis是企业中非常流行的框架，是ssm中的m

目标

mybatis框架介绍

学习mybatis下载

mybatis框架介绍

mybatis是Apache软件基金会下的一个开源项目，前身是iBatis框架。2010年这个项目改名为mybatis。是一个持久层框架

mybatis的优点

1. 简单易学：不需要关注JDBC的资源获取和释放，配置几个SQL映射文件即可。
2. 解除SQL与程序代码的耦合：SQL语句和代码分离，提高了可维护性。

mybatis的两种SQL映射方式

1. 使用XML的配置文件来实现映射
2. 可以通过注解来实现

官方网站

http://www.mybatis.org/mybatis-3/

框架包下载

连接到github地址：https://github.com/mybatis/mybatis-3/releases

小结

1. mybatis框架一个什么框架？

   持久层框架，操作数据库的
   

2. 如何下载mybatis?

   https://github.com/mybatis/mybatis-3/releases
   

   

mybatis入门案例：环境的搭建

目标

1. 了解mybatis的开发步骤
   

2. mybatis开发环境的搭建
   

需求

利用mybatis框架，从MySQL中查询所有的用户

[外链图片转存失败(img-DzESUALv-1564982999456)(1557583413350.png)]

用户表SQL

CREATE TABLE USER (
  id INT PRIMARY KEY AUTO_INCREMENT,
  username VARCHAR(20) NOT NULL,
  birthday DATE,
  sex CHAR(1) DEFAULT '男',
  address VARCHAR(50)
);

INSERT INTO USER VALUES (NULL, '孙悟空','1980-10-24','男','花果山水帘洞');
INSERT INTO USER VALUES (NULL, '白骨精','1992-11-12','女','白虎岭白骨洞');
INSERT INTO USER VALUES (NULL, '猪八戒','1983-05-20','男','福临山云栈洞');
INSERT INTO USER VALUES (NULL, '蜘蛛精','1995-03-22','女','盤丝洞');

SELECT * FROM USER;

mybatis开发步骤

1. 创建新模块
2. 加入mybatis相关jar包
3. 编写用户实体类（User）
4. 准备配置文件：sqlMapConfig.xml
5. 编写用户 dao 接口（UserMapper）
6. 编写用户 dao 接口映射文件（UserMapper.xml）
7. 编写测试代码

环境搭建

1.   创建模块：mybatis01_01_helloworld
   

2. 加入mybatis相关jar包：在模块下新建lib文件夹，复制mybatis框架jar包到lib文件夹下
   mybatis 框架包
   mysql 数据库驱动包
   log4j 日志包
   

3. 编写用户实体类（User）

   /**
    用户实体类对象 */
   public class User {
   
       private Integer id;
       private String username;
       private Date birthday;
       private String sex;
       private String address;
   
   	// 省略构造方法/getter/setter/toString
   }
   

配置文件

复制log4j.properties到 src 下

### 设置Logger输出级别和输出目的地 ###
log4j.rootLogger=debug, stdout

### 把日志信息输出到控制台 ###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.SimpleLayout

小结

mybatis的环境搭建做了哪几件事情？

1. 创建模块
2. 导入mybatis相关jar包：log4j-xxx.jar, mybatis-3.5.0.jar, junit-xxx.jar, mysql-connector-java-xxx.jar
3. 编写User实体类
4. 复制log4j.properties到 src 下

mybatis入门案例：配置文件和接口

Mybatis配置文件分类

mybatis为了灵活，将数据库相关数据和SQL语句写到XML配置文件中。

1. 核心配置文件：sqlMapConfig.xml 配置数据库连接的信息，账号，密码。。。
2. 接口的映射文件：UserMapper.xml 配置SQL语句

目标

1. 编写核心配置文件：sqlMapConfig.xml
2. 编写接口的映射文件：UserMapper.xml

核心配置文件sqlMapConfig.xml

复制source\资料\01_mybatis约束\sqlMapConfig.xml到src下，说明：它是mybatis框架的核心配置文件，mybatis就是靠这些信息来运行的。

<?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>
    <!--可以配置多个环境，可以访问不同种类的数据库：mysql, oracle-->
    <environments default="default">
        <!-- 其中的一个配置环境，这个配置方案的唯一标识 -->
        <environment id="default">
            <!--
            指定事务管理器的类型：
            JDBC：使用JDBC来管理事务
            -->
            <transactionManager type="JDBC"/>
            <!--
            数据源的类型：
            1. POOLED：使用mybatis创建的连接池
            2. UNPOOLED：不使用连接池，每次都创建和关闭连接
            -->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>

    <!--加载接口映射文件-->
    <mappers>
        
    </mappers>
</configuration>

UserMapper接口的创建

创建com.itheima.dao包，创建UserMapper接口。编写查询所有用户的方法：List<User> findAllUsers();

/**
 定义DAO中方法
 */
public interface UserMapper {
    /**
     查询所有的用户
     */
    List<User> findAllUsers();
}

UserMapper.xml映射文件

在com.itheima.dao包中创建UserMapper.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">

<!--namespace属性：指定DAO接口中类全名-->
<mapper namespace="com.itheima.dao.UserMapper">
    <!--
    id:接口中方法的名字
    resultType: 返回的数据类型，如果是集合类型，这里应该指定集合中元素的类型全名
    文本：SQL语句
    -->
    <select id="findAllUsers" resultType="com.itheima.entity.User">
        select * from user;
    </select>
</mapper>

核心配置文件sqlMapConfig.xml

在src/sqlMapConfig.xml添加UserMapper.xml的映射

<!--加载其它的实体映射文件-->
<mappers>
    <!--指定要加载的映射文件-->
    <mapper resource="com/itheima/dao/UserMapper.xml"/>
</mappers>

mybatis入门案例：测试类

目标

编写mybatis访问数据库的Java代码

效果

开发流程

三大对象

1. SqlSessionFactoryBuilder：负责构建SqlSessionFactory
2. SqlSessionFactory：创建SqlSession实例的工厂
3. SqlSession：用于执行持久化操作的对象

编写代码流程

1. 创建SqlSessionFactoryBuilder对象
2. 得到会话工厂SqlSessionFactory类
3. 创建SqlSession对象
4. 通过SqlSession对象得到Mapper接口的代理对象
5. Mapper接口的代理对象执行数据库的查询操作

代码

package com.itheima.test;

import com.itheima.dao.UserMapper;
import com.itheima.entity.User;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;

public class TestUserMapper {

    public static void main(String[] args) throws IOException {
        //1. 得到核心配置文件的输入流
        InputStream inputStream = Resources.getResourceAsStream("sqlMapConfig.xml");

        //2. 创建会话工厂建造类
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();

        //3. 创建会话工厂
        SqlSessionFactory factory = builder.build(inputStream);

        //4. 通过会话工厂得到会话对象
        SqlSession session = factory.openSession();

        //5. 由会话对象得到DAO接口的对象，由mybatis生成接口的代理对象。
        UserMapper userMapper = session.getMapper(UserMapper.class);

        //6. 实现CRUD
        List<User> userList = userMapper.findAllUsers();
        for (User user : userList) {
            System.out.println(user);
        }

        //7. 释放资源
        session.close();
    }

}

注：UserMapper的对象是由mybatis生成的接口代理对象

小结

学习总结

1. 能够使⽤用C3P0连接池

   1. 导入jar包c3p0-0.9.5.2.jar和mchange-commons-java-0.2.12.jar
   2. 编写c3p0-config.xml配置文件，配置对应参数
   3. 将配置文件放在src目录下
   4. 创建连接池对象ComboPooledDataSource，使用默认配置或命名配置
   5. 从连接池中获取连接对象
   6. 使用连接对象操作数据库
   7. 关闭资源,将连接还回连接池中

2. 能够使⽤用DRUID连接池

   1. 导入druid的jar包
   2. 在src目录下创建一个properties文件，并设置对应参数
   3. 加载properties文件的内容到Properties对象中
   4. 创建Druid连接池，使用配置文件中的参数
   5. 从Druid连接池中取出连接
   6. 执行SQL语句
   7. 关闭资源

3. 能够编写连接池工具类

   /*
   Durid连接池工具类
    */
   public class DataSourceUtils {
       // 1.声明静态连接池成员变量
       private static DataSource ds;
   
       // 2.创建连接池对象
       static {
           Properties pp = new Properties();
           try {
               pp.load(DataSourceUtils.class.getResourceAsStream("/druid.properties"));
               // 创建Druid连接池
               ds = DruidDataSourceFactory.createDataSource(pp);
           } catch (IOException e) {
               e.printStackTrace();
           } catch (Exception e) {
               e.printStackTrace();
           }
       }
   
       // 3.返回连接池中的连接
       public static Connection getConnection() throws SQLException {
           Connection conn = ds.getConnection();
           return conn;
       }
   
       public static void close(Connection conn, Statement stmt) {
           close(conn, stmt, null);
       }
   
       // 关闭资源
       public static void close(Connection conn, Statement stmt, ResultSet rs) {
           if (rs != null) {
               try {
                   rs.close();
               } catch (SQLException e) {}
           }
   
           if (stmt != null) {
               try {
                   stmt.close();
               } catch (SQLException e) {}
           }
   
           if (conn != null) {
               try {
                   conn.close();
               } catch (SQLException e) {}
           }
       }
   }
   

4. 能够了解什么是框架

   别人写好的代码，对常见功能的封装，是一个半成品

5. 掌握mybatis框架开发快速入门

   

   

6. 理解自定义mybatis框架

   核心1： sqlSession.getMapper(UserMapper.class); 返回接口的代理对象，实现类

   核心2：调用 List<User> allUsers = mapper.findAllUsers(); 得到方法所在的接口名和方法名 -》 com.itheima.dao.UserMapper.findAllUsers 会去接口映射文件中

   

   // 2.创建连接池对象
   static {
       Properties pp = new Properties();
       try {
           pp.load(DataSourceUtils.class.getResourceAsStream("/druid.properties"));
           // 创建Druid连接池
           ds = DruidDataSourceFactory.createDataSource(pp);
       } catch (IOException e) {
           e.printStackTrace();
       } catch (Exception e) {
           e.printStackTrace();
       }
   }
   
   // 3.返回连接池中的连接
   public static Connection getConnection() throws SQLException {
       Connection conn = ds.getConnection();
       return conn;
   }
   
   public static void close(Connection conn, Statement stmt) {
       close(conn, stmt, null);
   }
   
   // 关闭资源
   public static void close(Connection conn, Statement stmt, ResultSet rs) {
       if (rs != null) {
           try {
               rs.close();
           } catch (SQLException e) {}
       }
   
       if (stmt != null) {
           try {
               stmt.close();
           } catch (SQLException e) {}
       }
   
       if (conn != null) {
           try {
               conn.close();
           } catch (SQLException e) {}
       }
   }
   

   }

7. 能够了解什么是框架

   别人写好的代码，对常见功能的封装，是一个半成品