Mybatis学习01:Mybatis入门案例及工作原理分析

最新推荐文章于 2022-08-03 12:32:54 发布

ncepu_Chen

最新推荐文章于 2022-08-03 12:32:54 发布

阅读量1.3k

点赞数 4

分类专栏： # JAVA WEB 文章标签： Mybatis Mybatis入门 Java静态资源 Mybatis原理

本文链接：https://blog.csdn.net/ncepu_Chen/article/details/96773713

版权

JAVA WEB 专栏收录该内容

27 篇文章 7 订阅

订阅专栏

Mybatis学习01:Mybatis入门案例及工作原理分析

传统JDBC的分析
Mybatis的使用
Mybatis工作原理分析

传统JDBC的分析

一个传统的JDBC程序如下:

public static void main(String[] args) {
    
    Connection connection = null;
    PreparedStatement preparedStatement = null;
    ResultSet resultSet = null;
    
    try {
        //1. 加载驱动
        Class.forName("com.mysql.jdbc.Driver");
        //2. 获得链接
        connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/database", "username", "password"); 
        //3. 创建statement
        String sql = "select * from user where id = ? and username = ?";
        preparedStatement = connection.prepareStatement(sql);
        preparedStatement.setString(1, "王五");
  		// 4. 执行statement
        resultSet = preparedStatement.executeQuery();
        // 5. 遍历结果
        while (resultSet.next()) {
        	System.out.println(resultSet.getString("id") + "" + resultSet.getString("username"));
        }
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        // 6. 释放资源
        if (resultSet != null) {
            try {resultSet.close(); } catch (SQLException e) {e.printStackTrace(); } 
        }
        if (preparedStatement != null) {
            try {preparedStatement.close(); } catch (SQLException e) {e.printStackTrace(); } 
        }
        if (connection != null) {
            try {connection.close(); } catch (SQLException e) {e.printStackTrace(); } 
        }
    }
}

可以看到,直接使用传统的JDBC,存在以下问题:

频繁创建数据库连接存在性能问题,可以试用数据库连接池来解决
sql语句在代码中硬编码,改变sql需要改变java代码,可以将sql语句写进配置或注解中
对结果集合的解析过程复杂且字段硬编码进java代码中了,可以将数据库记录封装成pojo对象

Mybatis的使用

项目准备

在数据库中创建表users并添加数据

DROP TABLE IF EXISTS `users`;

CREATE TABLE `users` (
  `id` int(11) NOT NULL auto_increment,
  `username` varchar(32) NOT NULL COMMENT '用户名称',
  `birthday` datetime default NULL COMMENT '生日',
  `sex` char(1) default NULL COMMENT '性别',
  `address` varchar(256) default NULL COMMENT '地址',
  PRIMARY KEY  (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

insert  into `users`(`id`,`username`,`birthday`,`sex`,`address`) values (41,'老王','2018-02-27 17:47:08','男','北京'),(43,'小二王','2018-03-04 11:34:34','女','北京金燕龙'),(45,'传智播客','2018-03-04 12:04:06','男','北京金燕龙'),(46,'老王','2018-03-07 17:37:26','男','北京'),(48,'小马宝莉','2018-03-08 11:44:00','女','北京修正');

创建Maven项目并在pom.xml中引入依赖坐标如下

<dependencies>
	<dependency>
		<groupId>org.mybatis</groupId>
		<artifactId>mybatis</artifactId>
		<version>3.4.5</version>
	</dependency>
    
	<dependency>
		<groupId>junit</groupId>
		<artifactId>junit</artifactId>
		<version>4.10</version>
		<scope>test</scope>
	</dependency>
    
	<dependency>
		<groupId>mysql</groupId>
		<artifactId>mysql-connector-java</artifactId>
		<version>5.1.6</version>
		<scope>runtime</scope>
	</dependency>
    
	<dependency>
		<groupId>log4j</groupId>
		<artifactId>log4j</artifactId>
		<version>1.2.12</version>
	</dependency>
</dependencies>

在resources目录下创建log4j的配置文件log4j.properties如下:

# Set root category priority to INFO and its only appender to CONSOLE.
#log4j.rootCategory=INFO, CONSOLE            debug   info   warn error fatal
log4j.rootCategory=debug, CONSOLE, LOGFILE

# Set the enterprise logger category to FATAL and its only appender to CONSOLE.
log4j.logger.org.apache.axis.enterprise=FATAL, CONSOLE

# CONSOLE is set to be a ConsoleAppender using a PatternLayout.
log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
log4j.appender.CONSOLE.layout.ConversionPattern=%d{ISO8601} %-6r [%15.15t] %-5p %30.30c %x - %m\n

# LOGFILE is set to be a File appender using a PatternLayout.
log4j.appender.LOGFILE=org.apache.log4j.FileAppender
log4j.appender.LOGFILE.File=d:\axis.log
log4j.appender.LOGFILE.Append=true
log4j.appender.LOGFILE.layout=org.apache.log4j.PatternLayout
log4j.appender.LOGFILE.layout.ConversionPattern=%d{ISO8601} %-6r [%15.15t] %-5p %30.30c %x - %m\n

创建与数据库表对应的pojo类型User,注意入门程序中我们要求pojo类User属性名和数据库表users的字段名严格相同

package cn.maoritian.domain;

public class User implements Serializable {

    // 属性名和数据库表字段名严格相同
	private Integer id;
	private String username;
	private Date birthday;
	private String sex;
	private String address;

    // 各属性的 set 和 get 方法
	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 Date getBirthday() {return birthday; }
	public void setBirthday(Date birthday) {this.birthday = birthday; }
	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; }

    // toString()方法
	@Override
	public String toString() {
		return "User{" + "id=" + id + ", username='" + username + '\'' + ", birthday=" + birthday + ", sex='" + sex + '\'' + ", address='" + address + '\'' + '}';
	}
}

编写持久层接口IUserDao

package cn.maoritian.dao;

// 持久层接口
public interface IUserDao {

    // 返回所有用户列表
    List<User> findAll();
}

Mybatis入门案例1-使用xml配置sql语句

在resource目录下创建Mybatis配置文件SqlMapConfig.xml如下

<?xml version="1.0" encoding="UTF-8"?>
<!-- 引入Mybatis的xml约束 -->
<!DOCTYPE configuration
	PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
	"http://mybatis.org/dtd/mybatis-3-config.dtd">

<!-- mybatis的主配置文件 -->
<configuration>
    
	<!-- 配置环境,默认使用id为mysql的那套环境配置 -->
	<environments default="mysql">	
        
        <!-- 配置id为mysql的环境配置 -->
		<environment id="mysql">
			<!-- 配置事务的类型 -->
			<transactionManager type="JDBC"></transactionManager>
			<!-- 配置数据源（连接池） -->
			<dataSource type="POOLED">
				<!-- 连接数据库的4个基本信息 -->
				<property name="driver" value="com.mysql.jdbc.Driver"/>
				<property name="url" value="jdbc:mysql://localhost:3306/mydatabase"/>
				<property name="username" value="root"/>
				<property name="password" value="123456"/>
			</dataSource>
		</environment>
        
	</environments>
    
</configuration>

实现持久层接口

我们把sql语句写进xml文件中,让Mybatis框架通过反射给我们提供持久层接口的实现类.

配置持久层接口的sql语句

我们在resource目录下创建cn/maoritian/dao/IUserDao.xml文件.xml文件的路径和文件名与java代码中的包路径和类名严格相同.

使用<mapper>标签配置实现的接口,<select>标签配置接口中的查询方法

<?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">

<!-- 编写实现持久层代码的sql语句,namespace属性为其实现的持久层接口名 -->
<mapper namespace="cn.maoritian.dao.IUserDao">
    <!-- id属性为实现的方法,resultType属性为查询结果包装成的pojo类名 -->
    <select id="findAll" resultType="cn.maoritian.domain.User">
    	<!-- 在select标签内写sql语句 -->
        select * from user
    </select>
</mapper>

在Mybatis配置文件SqlMapConfig.xml中使用mapper标签指定sql语句配置文件.在SqlMapConfig.xml的configure节点下添加如下配置.

<mappers>
    <!-- 每个持久层接口配置在一个单独的文件内 -->
    <mapper resource="cn/maoritian/dao/IUserDao.xml"/>
</mappers>

我们已经完成了一个Mybatis入门项目,写出测试代码如下:

package cn.maoritian.dao.impl;

public class MybatisTest {

    public static void main(String[] args) throws Exception {
        // 1.读取配置文件
        InputStream config = Resources.getResourceAsStream("SqlMapConfig.xml");
        // 2.创建SqlSessionFactory工厂
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory factory = builder.build(config);
        // 3.使用工厂生产SqlSession对象
        SqlSession session = factory.openSession();
        // 4.使用SqlSession创建Dao接口的代理对象
        IUserDao userDao = session.getMapper(IUserDao.class);
        // 5.使用代理对象执行方法
        List<User> users = userDao.findAll();
        for (User user : users) {
            System.out.println(user);
        }
        // 6.释放资源
        session.close();
        config.close();
    }
}

运行测试程序,输出如下,说明代码执行成功

User{id=41, username='老王', birthday=Tue Feb 27 17:47:08 CST 2018, sex='男', address='北京'}
User{id=42, username='小二王', birthday=Fri Mar 02 15:09:37 CST 2018, sex='女', address='北京金燕龙'}
User{id=45, username='传智播客', birthday=Sun Mar 04 12:04:06 CST 2018, sex='男', address='北京金燕龙'}
User{id=46, username='老王', birthday=Wed Mar 07 17:37:26 CST 2018, sex='男', address='北京'}
User{id=48, username='小马宝莉', birthday=Thu Mar 08 11:44:00 CST 2018, sex='女', address='北京修正'}

Mybatis入门案例2-使用注解配置sql语句

在这个案例中,我们将sql语句写在持久层的注解中.数据库结构和测试代码均与上个案例相同.我们只要修改持久层接口IUserDao和Mybatis配置文件

在持久层接口的方法定义上加以@Select注解,其value属性为该方法要执行的sql语句

package cn.maoritian.dao;

// 持久层接口
public interface IUserDao {

    // 返回所有用户列表
    @Select("select * from users")
    List<User> findAll();
}

在Mybatis配置文件SqlMapConfig.xml中配置mapper如下

<mappers>
    <mapper class="cn.maoritian.dao.IUserDao"/>
</mappers>

运行测试程序,输出如下,说明代码执行成功

User{id=41, username='老王', birthday=Tue Feb 27 17:47:08 CST 2018, sex='男', address='北京'}
User{id=42, username='小二王', birthday=Fri Mar 02 15:09:37 CST 2018, sex='女', address='北京金燕龙'}
User{id=45, username='传智播客', birthday=Sun Mar 04 12:04:06 CST 2018, sex='男', address='北京金燕龙'}
User{id=46, username='老王', birthday=Wed Mar 07 17:37:26 CST 2018, sex='男', address='北京'}
User{id=48, username='小马宝莉', birthday=Thu Mar 08 11:44:00 CST 2018, sex='女', address='北京修正'}

Mybatis入门案例3-手动编写持久层实现类

我们使用Mybatis框架就是要使sql语句和java代码解耦,因此实际开发中我们都是让Mybatis框架根据配置好的sql语句通过反射创建持久层实现类,而不会手动编写持久层实现类.但实际上,Mybatis框架允许我们这样做.

创建持久层实现类UserDaoImpl如下:

package cn.maoritian.dao.impl;

public class UserDaoImpl implements IUserDao {

    private SqlSessionFactory factory;

    public UserDaoImpl(SqlSessionFactory factory) {
        this.factory = factory;
    }

    public List<User> findAll() {
        // 1.使用工厂创建SqlSession对象
        SqlSession session = factory.openSession();
        // 2.使用session执行查询所有方法
        List<User> users = session.selectList("cn.maoritian.dao.IUserDao.findAll");
        session.close();
        // 3.返回查询结果
        return users;
    }
}

测试程序也应该做出相应更改如下:

package com.itheima.test;

public class MybatisTest {

    public static void main(String[] args) throws Exception {
        // 1.读取配置文件
        InputStream config = Resources.getResourceAsStream("SqlMapConfig.xml");
        // 2.创建SqlSessionFactory工厂
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory factory = builder.build(config);
        // 3.使用工厂创建dao对象
        IUserDao userDao = new UserDaoImpl(factory);
        // 4.使用代理对象执行方法
        List<User> users = userDao.findAll();
        for (User user : users) {
            System.out.println(user);
        }
        // 5.释放资源
        in.close();
    }
}

入门案例的分析

在入门案例中,有以下几点值得注意

静态资源的读取

对于实际项目中的静态资源,我们不论是用绝对路径或者相对路径,都是不合适的. 我们访问静态资源只有两种情况:

java源代码中resource目录下的文件,构建项目后会被放到类路径下,因此我们通过类字节码或类加载器访问该静态资源.

// 返回当前类字节码所在路径,即 target/classes/类的包路径
this.getClass().getResource("").toString();	
// 返回当前类字节码所在路径下的文件流,即 target/classes/类的包路径/path/file
this.getClass().getResourceAsStream("/path/file");

// 返回类路径,即 target/classes
this.getClass().getClassLoader().getResource("").toString();
// 返回类路径下的文件流,即 target/classes/path/file
this.getClass().getClassLoader().getResourceAsStream("/path/file");

在web项目中webapp目录下的文件,构建项目后会被放到tomcat的web项目路径下,我们通过当前会话的ServletContext访问该静态资源.

某项目在发布到http://localhost:8080/contextPath路径下,在web.xml中配置某Servlet的url-pattern为/servletPath.
在浏览器地址栏中输入http://localhost:8080/contextPath/servletPath即可访问该Servlet.

// 返回当前web项目的实际(绝对)路径 "http://host/contextPath"
request.getSession().getServletContext().getRealPath("");

// 返回java源代码中 web-app目录下的文件流,即java源代码中 "web-app/path/file"
// 亦即web项目中的"http://host/contextPath/path/file"
request.getSession().getServletContext().getResourceAsStream("path/file");
request.getSession().getServletContext().getResourceAsStream("/path/file");

request.getContextPath();	// 返回"/contextPath"
request.getServletPath();	// 返回"/servletPath"

测试代码中创建持久层实现类时用到的几个设计模式

我们创建SqlSessionFactory时用到了构建者模式,我们将配置文件config传递给SqlSessionFactoryBuilder类的build()方法,得到SqlSessionFactory对象.

使用构建者模式,我们将构建工厂类的细节(读取配置文件)隐藏,向外暴露为build()方法
我们获取SqlSession时用到了工厂模式,通过SqlSessionFactory类的openSession()方法生产SqlSession对象.

使用工厂模式,我们降低了SqlSession接口与其实现类之间的耦合
我们创建IUserDao实现类时用到了代理模式,通过动态代理的方法在不修改源代码的情况下对已有方法进行增强.

public static void main(String[] args) throws Exception {
    // 1.读取配置文件
    InputStream config = Resources.getResourceAsStream("SqlMapConfig.xml");
    // 2.创建SqlSessionFactory工厂
    SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
    SqlSessionFactory factory = builder.build(config);
    // 3.使用工厂创建dao对象
    IUserDao userDao = new UserDaoImpl(factory);
    // 4.使用代理对象执行方法
    List<User> users = userDao.findAll();
    for (User user : users) {
        System.out.println(user);
    }
    // 5.释放资源
    in.close();
}

Mybatis工作原理分析

分析入门案例中Mybatis框架的执行流程如下.

在这里插入图片描述

先读取出Mybatis主配置文件SqlMapConfig.xml,其中记录的信息主要有两个
1. 链接数据库的信息: driver,url,username,password.这四个信息用来创建Connection对象
2. mappers信息,mappers信息记录的是持久层接口与其实现类sql语句之间的映射,每个持久层接口的mapper信息都写在一个单独的文件中.这些信息被用来通过反射创建持久层实现类.
对配置文件中的信息进行封装

我们将从配置文件中读取的所有信息封装到Configure类中,其属性除了数据库链接信息driver,url,username,password以外,还有一个Map<String, Mapper> mappers属性,记录所有持久层方法与其sql语句的映射,其键为持久层方法的全限定方法名,值为该方法对应的Mapper对象.

我们将每个持久层方法的sql语句和返回值类型封装成一个Mapper对象,Mapper类有两个属性,分别是queryString表示方法执行的sql语句,resultType表示方法返回值类型的全限定类名
我们将配置文件读取成流之后,传递给SqlSessionFactoryBuilder对象,其build()方法将配置文件流解析为Configuration对象并返回一个工厂类SqlSessionFactory接口的实现类DefaultSqlSessionFactory对象,其构造函数接收一个Configuration配置对象赋值给cfg属性.

SqlSessionFactory类的openSession()方法开启一次数据库会话,即返回一个SqlSession接口的默认实现类DefaultSqlSession对象.其构造函数接收一个Configuration配置对象赋值给cfg属性并根据cfg属性创建数据库链接Connection对象.SqlSession类的getMapper()方法通过代动态理模式创建持久层接口IUserDao的实现类.

ncepu_Chen

关注

4
点赞
踩
18

收藏

觉得还不错? 一键收藏
5
评论
Mybatis学习01:Mybatis入门案例及工作原理分析

Mybatis学习01:Mybatis入门案例传统JDBC的分析使用Mybatis改进持久层项目准备Mybatis入门案例1-使用xml配置sql语句Mybatis入门案例2-使用xml配置sql语句Mybatis入门案例3-手动编写持久层实现类入门案例的分析传统JDBC的分析一个传统的JDBC程序如下:public static void main(String[] args) { ...
复制链接

扫一扫