本文将介绍Mybatis系列全解的详细情况，特别是关于二：Mybatis简介与环境搭建的相关信息。我们将通过案例分析、数据研究等多种方式，帮助您更全面地了解这个主题，同时也将涉及一些关于Mybatis

本文将介绍Mybatis系列全解的详细情况，特别是关于二：Mybatis简介与环境搭建的相关信息。我们将通过案例分析、数据研究等多种方式，帮助您更全面地了解这个主题，同时也将涉及一些关于Mybatis 入门之MyBatis环境搭建(第一篇)、MyBatis 学习 之 一、MyBatis 简介与配置 MyBatis+Spring+MySql、mybatis 学习笔记（二）：mybatis SQL注入问题、MyBatis 源码分析（二）：MyBatis 整体架构及原理的知识。

本文目录一览：

• Mybatis系列全解（二）：Mybatis简介与环境搭建（mybatis环境搭建步骤）
• Mybatis 入门之MyBatis环境搭建(第一篇)
• MyBatis 学习 之 一、MyBatis 简介与配置 MyBatis+Spring+MySql
• mybatis 学习笔记（二）：mybatis SQL注入问题
• MyBatis 源码分析（二）：MyBatis 整体架构及原理

Mybatis系列全解（二）：Mybatis简介与环境搭建（mybatis环境搭建步骤）

Mybatis系列全解（二）：Mybatis简介与环境搭建

目录

• Mybatis系列全解（二）：Mybatis简介与环境搭建
  • • • 前言
      • Mybaits系列全解 (持续更新)
      • Mybatis是什么
      • Mybatis的前世今生
      • Mybatis的优势
      • Mybatis整体架构图
      • 环境搭建
      • 总结

封面：洛小汐 作者：潘潘

Mybatis 是一套持久层框架，灵活易用，特别流行。

前言

Mybatis系列全解，我们预计准备10+篇文章，让我们了解到 Mybatis 的基本全貌，真正从入门到上手，从上手到精通，本文为首篇，我们开始。

---

Mybaits系列全解 (持续更新)

• Mybatis系列全解（一）：手写一套持久层框架
• Mybatis系列全解（二）：Mybatis简介与环境搭建
• Mybatis系列全解（三）：Mybatis简单CRUD使用介绍
• Mybatis系列全解（四）：全网最全！Mybatis配置文件XML全貌详解
• Mybatis系列全解（五）：全网最全！详解Mybatis的Mapper映射文件
• Mybatis系列全解（六）：Mybatis最硬核的API你知道几个？
• Mybatis系列全解（七）：全息视角看Dao层两种实现方式之传统方式与代理方式
• Mybatis系列全解（八）：Mybatis的动态sql
• Mybatis系列全解（九）：Mybatis的复杂映射
• Mybatis系列全解（十）：Mybatis注解开发
• Mybatis系列全解（十一）：Mybatis缓存全解
• Mybatis系列全解（十二）：Mybatis插件开发
• Mybatis系列全解（十三）：Mybatis代码生成器
• Mybatis系列全解（十四）：Spring集成Mybatis
• Mybatis系列全解（十五）：SpringBoot集成Mybatis
• Mybatis系列全解（十六）：Mybatis源码剖析

Mybatis是什么

我们先看一下官网简介，Mybatis 官网：https://mybatis.org/mybatis-3/

MyBatis is a first class persistence framework with support for custom sql, stored procedures and advanced mappings. MyBatis eliminates almost all of the JDBC code and manual setting of parameters and retrieval of results. MyBatis can use simple XML or Annotations for configuration and map primitives, Map interfaces and Java POJOs (Plain Old Java Objects) to database records.

大致翻译为：

MyBatis是一款优秀的持久层框架，它支持定制化sql、存储过程以及高级映射。MyBatis避免了几乎所有的JDBC代码和手动设置参数以及获取结果集。MyBatis可以使用简单的XML或注解来配置和映射原生类型、集合接口以及Java的POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。

我目前的理解是，Mybatis 本身抽象了大量的 JDBC 冗余代码，同时基于对象关系映射模型，向外提供了一套灵活易用的 API 和数据库做交互。

Mybatis的前世今生

凡事皆有过往，之前我们讲过一篇 JDBC 的介绍与实际应用，并分析对比了 JDBC 与持久层框架的差异，由于 JDBC 需要开发人员编写过多的代码，操作所有对象，既麻烦还特别容易出错，所以在我们实际开发中很少直接使用 JDBC 进行编程，于是 ORM 的登台显得尤为重要，ORM 全称是 Object/Relation Mapping：表示 对象-关系映射 的缩写。

ORM模型 ，简单来说，就是数据库的表和简单 Java 对象的映射关系模型。采用ORM框架后，应用程序不再直接访问底层数据库，而是以 面向对象 的方式来操作持久化对象，而ORM框架则将这些面向对象的操作转换成底层sql操作。ORM框架实现的效果：把对持久化对象的保存、修改、删除 等操作，转换为对数据库的操作。

最初 SUN 公司推出了 Java EE 服务器端组件模型（EJB），不过由于EJB 配置过于复杂，且适应范围小于是很快就被淘汰。后来封装度极高、开发效率极高、全表映射的 ORM 持久层框架Hibernate 出现，成为了当时首选的 Java ORM 模型框架。但是随着互联网的极速发展、复杂业务场景的不断涌现，Hibernate 在许多方面慢慢暴露出了缺点：灵活性不够、无法根据不同条件组装不同sql、对多表关联和复杂SQL查询支持较差、sql优化和性能差、全表映射带来的不便等等。

于是 Mybatis 框架应运而生，弥补了Hibernate的不足，不仅简单易用，而且具有高度灵活、可优化、易维护等特点，成为如今大型互联网项目的首选框架。

Mybatis 野史：Mybatis 前身是 iBATIS，2001年由Clinton Begin发起的一个开源项目，最初侧重于密码软件的开发，后来发展成为一款基于Java的持久层框架，2004年，Clinton 将 iBATIS 的名字和源码捐赠给 Apache 软件基金会，接下来的6年中，开源软件世界发生了巨大的变化，一切开发实践、基础设施、许可，甚至数据库技术都彻底改变了。在2010年6月，核心开发团队把这个项目由 apache software foundation 迁移到了google code，随着开发团队转投 Google Code 旗下，ibatis3.x 正式更名为 Mybatis ，代码于2013年11月迁移到 Github 。

Mybatis的优势

Mybatis 是一个半自动化的持久层框架，对开发人员来说，核心 sql 还是需要自己进行优化，sql 和 java 编码进行分离，功能边界清晰，一个专注业务，一个专注数据。

蓝色区域是 Mybatis 框架功能支持，红色区域是应用了Mybatis 框架的工程项目实际需要操作的2个步骤：

当前有很多 Java 实现的持久化框架，而 MyBatis 流行起来有以下原因：

1、它消除了大量的 JDBC 冗余代码

2、它有低的学习曲线

3、它能很好地与传统数据库协同工作

4、它可以接受 sql 语句

5、它提供了与 Spring 和 Guice 框架的集成支持

6、它提供了与第三方缓存类库的集成支持

7、它引入了更好的性能

Mybatis整体架构图

环境搭建

默认已安装 Java 开发环境、Mysql数据库、Maven 环境。

Mybatis 开发与环境搭建，我们先入门体验，步骤如下：

1、创建 maven 工程

2、添加 MyBatis 仓库坐标（非maven项目则引入jar包）

3、创建user数据表

4、编写User实体类

5、编写映射文件UserMapper.xml

6、编写核心文件sqlMapConfig.xml

7、编写测试类

1、创建 maven 工程

2、添加 MyBatis 仓库坐标

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.encoding>UTF-8</maven.compiler.encoding>
        <java.version>1.8</java.version>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
    </properties>

    <dependencies>

        <!--mybatis坐标-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.5</version>
        </dependency>

        <!--MysqL驱动坐标-->
        <dependency>
            <groupId>MysqL</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.6</version>
            <scope>runtime</scope>
        </dependency>

        <!--单元测试坐标-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>

        <!--日志坐标-->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.12</version>
        </dependency>

    </dependencies>

3、创建user数据表

CREATE TABLE `user` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `username` varchar(50) DEFAULT NULL,
  `password` varchar(50) DEFAULT NULL,
  `birthday` varchar(50) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8;

4、编写User实体类

package com.panshenlian.pojo;

/**
 * @Author: panshenlian
 * @Description: 用户实体
 * @Date: Create in 2:08 2020/11/28
 */
public class User {
    private int id;
    private String username;
    private String password;
    private String birthday;

    public int getId() {
        return id;
    }

    public void setId(int 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 getBirthday() {
        return birthday;
    }

    public void setBirthday(String birthday) {
        this.birthday = birthday;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                ", birthday='" + birthday + '\'' +
                '}';
    }
}

5、编写映射文件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">
<mapper namespace="userMapper">

    <select id="findAll" resultType="com.panshenlian.pojo.User">
        select * from User
    </select>

</mapper>

6、编写核心文件sqlMapConfig.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>
    <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://localhost:3306/mybatis" />
                <property name="username" value="root" />
                <property name="password" value="123456" />
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="/UserMapper.xml" />
    </mappers>
</configuration>

7、编写测试类

package com.panshenlian.service;

import com.panshenlian.pojo.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 org.junit.Test;

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

/**
 * @Author: panshenlian
 * @Description: 体验测试类
 * @Date: Create in 2:21 2020/11/28
 */
public class MybatisTest {

    @Test
    public void testQueryUser01() throws IOException {

        //加载核心配置文件
        InputStream resourceAsstream = Resources.getResourceAsstream("sqlMapConfig.xml");

        // 获得sqlSession工厂对象
        sqlSessionFactory sqlSessionFactory = new sqlSessionFactoryBuilder().build(resourceAsstream);

        //获得sqlSession对象
        sqlSession sqlSession = sqlSessionFactory.openSession();

        // 执行sql语句
        List<User> userList = sqlSession.selectList("userMapper.findAll");

        // 打印结果
        for (User user : userList) {
            System.out.println(user);
        }

        // 释放资源
        sqlSession.close();
    }


}

最终通过 Junit 单元测试，运行结果符合预期：

工程结构参考：

总结

我们通过本文介绍，也动手做了一个入门体验的测试工程，基本对 Mybatis 有了初步认识，同时对比了 JDBC 与 Hibernate ，明晰了 Mybatis 诞生的使命，和与生俱来的优势能力。后续我们会继续深入讲解 ，对于 Mybatis 各个知识脉络进行梳理和解析。

本篇完，本系列下一篇我们讲《 Mybatis简单CRUD使用介绍 》。

Mybatis 入门之MyBatis环境搭建(第一篇)

Mybatis的前身叫iBatis，本是apache的一个开源项目, 2010年这个项目由apache software foundation 迁移到了google code，并且改名为MyBatis。这篇文章主要介绍了Mybatis入门第一篇之MyBaits环境搭建，需要的朋友参考下

Mybatis简介

MyBatis的前身叫iBatis，本是apache的一个开源项目, 2010年这个项目由apache software foundation 迁移到了google code，并且改名为MyBatis。

MyBatis是支持普通SQL查询，存储过程和高级映射的优秀持久层框架。MyBatis消除了几乎所有的JDBC代码和参数的手工设置以及结果集的检索。MyBatis使用简单的XML或注解用于配置和原始映射，将接口和Java的POJOs（Plan Old Java Objects，普通的Java对象）映射成数据库中的记录。

下面分步骤给搭建介绍mybatis 环境搭建。

1)在工程下引入mybatis-3.4.1.jar包，再引入数据库（MysqL,mssql..）包.

2)在src下新建一个配置文件conf.xml

这里是通过外部配置文件来存储数据库存信息的，所以加入一个jdbc.properties的数据库存信息

driver=com.microsoft.sqlserver.jdbc.sqlServerDriver url=jdbc:sqlserver://127.0.0.1;databaseName=test username=sa password=123456

3)建立一个映射文件 userMapper.xml

select * from MS_User Select * From Ms_User Where id=#{id}

(这里要注意的是，namespace属性，因为，此实例是通过接口映射的方式，所以，namespace属性一点要写成接口的路径)附图：

4)建一个映射接口类

package hw.com.ser; import java.util.List; import hw.com.pojo.User; public interface IUser { public List queryUsers(); public User queryUserById(int id); }

5）建立一个sqlSessionFactory

package hw.com.util; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.io.Reader; import java.util.Properties; 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 sqlSessionFactoryUtil { private static sqlSessionFactory sqlSessionFactory = null; private static final Class CLASS_LOCK = sqlSessionFactoryUtil.class; private sqlSessionFactoryUtil() { } public static sqlSessionFactory initsqlSessionFactory() { String resource = "conf.xml"; InputStream inputStream = null; try { inputStream = Resources.getResourceAsstream(resource); } catch (IOException e) { e.printstacktrace(); } synchronized (CLASS_LOCK) { if (sqlSessionFactory == null) { sqlSessionFactory = new sqlSessionFactoryBuilder().build(inputStream); } } return sqlSessionFactory; } public static sqlSession opensqlSession(){ if(sqlSessionFactory==null){ initsqlSessionFactory(); } return sqlSessionFactory.openSession(); } }

6)建一个pojo

package hw.com.pojo; import java.util.Date; public class User { private String Id; private String UserName; private String UserPwd; private int DeptmentId; private String UserTrueName; private String Email; private int LearnCenterId; private Date CreateDate; private Date LastModifyDate; private int UserStatus; public User() { super(); // Todo Auto-generated constructor stub } public String getId() { return Id; } public void setId(String id) { Id = id; } public String getUserName() { return UserName; } public void setUserName(String userName) { UserName = userName; } public String getUserPwd() { return UserPwd; } public void setUserPwd(String userPwd) { UserPwd = userPwd; } public int getDeptmentId() { return DeptmentId; } public void setDeptmentId(int deptmentId) { DeptmentId = deptmentId; } public String getUserTrueName() { return UserTrueName; } public void setUserTrueName(String userTrueName) { UserTrueName = userTrueName; } public String getEmail() { return Email; } public void setEmail(String email) { Email = email; } public int getLearnCenterId() { return LearnCenterId; } public void setLearnCenterId(int learnCenterId) { LearnCenterId = learnCenterId; } public Date getCreateDate() { return CreateDate; } public void setCreateDate(Date createDate) { CreateDate = createDate; } public Date getLastModifyDate() { return LastModifyDate; } public void setLastModifyDate(Date lastModifyDate) { LastModifyDate = lastModifyDate; } public int getUserStatus() { return UserStatus; } public void setUserStatus(int userStatus) { UserStatus = userStatus; } @Override public String toString() { return "User [Id=" + Id + ", UserName=" + UserName + ", UserPwd=" + UserPwd + ", DeptmentId=" + DeptmentId + ", UserTrueName=" + UserTrueName + ", Email=" + Email + ", LearnCenterId=" + LearnCenterId + ", CreateDate=" + CreateDate + ", LastModifyDate=" + LastModifyDate + ", UserStatus=" + UserStatus + "]"; } }

7) 在main方法下做测试

package hw.com.Day1.main; import java.util.List; import org.apache.ibatis.session.sqlSession; import hw.com.pojo.User; import hw.com.ser.IUser; import hw.com.util.sqlSessionFactoryUtil; public class UserTest { public static void main(String[] args) { sqlSession sqlSession=null; try { sqlSession=sqlSessionFactoryUtil.opensqlSession(); IUser iUser=sqlSession.getMapper(IUser.class); List users=iUser.queryUsers(); if(users.size()>0){ for (User user : users) { System.out.println(user.toString()); } } } catch (Exception e) { e.printstacktrace(); } } }

到此这篇关于Mybatis 入门之MyBatis环境搭建(第一篇)的文章就介绍到这了,更多相关Mybatis 环境搭建入门内容请搜索小编以前的文章或继续浏览下面的相关文章希望大家以后多多支持小编！

MyBatis 学习 之 一、MyBatis 简介与配置 MyBatis+Spring+MySql

一、MyBatis 简介与配置 MyBatis+Spring+MySql

MyBatis 学习 之 一、MyBatis 简介与配置 MyBatis+Spring+MySql

MyBatis 学习 之 二、SQL 语句映射文件 (1) resultMap

MyBatis 学习 之 二、SQL 语句映射文件 (2) 增删改查、参数、缓存

MyBatis 学习 之 三、动态 SQL 语句

MyBatis 学习 之 四、MyBatis 配置文件

1.1MyBatis 简介

      MyBatis 是一个可以自定义 SQL、存储过程和高级映射的持久层框架。MyBatis 摒除了大部分的 JDBC 代码、手工设置参数和结果集重获。MyBatis 只使用简单的 XML 和注解来配置和映射基本数据类型、Map 接口和 POJO 到数据库记录。相对 Hibernate 和 Apache OJB 等 “一站式” ORM 解决方案而言，Mybatis 是一种 “半自动化” 的 ORM 实现。
需要使用的 Jar 包：mybatis-3.0.2.jar（mybatis 核心包）。mybatis-spring-1.0.0.jar (与 Spring 结合包)。

下载地址：
http://ibatis.apache.org/tools/ibator
http://code.google.com/p/mybatis/

 

1.2MyBatis+Spring+MySql 简单配置

1.2.1 搭建 Spring 环境

1, 建立 maven 的 web 项目；
2, 加入 Spring 框架、配置文件；
3, 在 pom.xml 中加入所需要的 jar 包（spring 框架的、mybatis、mybatis-spring、junit 等）；
4, 更改 web.xml 和 spring 的配置文件；
5, 添加一个 jsp 页面和对应的 Controller；
6, 测试。

可参照：http://limingnihao.iteye.com/blog/830409。使用 Eclipse 的 Maven 构建 SpringMVC 项目

1.2.2 建立 MySql 数据库

建立一个学生选课管理数据库。
表：学生表、班级表、教师表、课程表、学生选课表。
逻辑关系：每个学生有一个班级；每个班级对应一个班主任教师；每个教师只能当一个班的班主任；

使用下面的 sql 进行建数据库，先建立学生表，插入数据（2 条以上）。

更多 sql 请下载项目源文件，在 resource/sql 中。

/* 建立数据库 */
CREATE DATABASE STUDENT_MANAGER;
USE STUDENT_MANAGER;

/***** 建立student表 *****/
CREATE TABLE STUDENT_TBL
(
   STUDENT_ID         VARCHAR(255) PRIMARY KEY,
   STUDENT_NAME       VARCHAR(10) NOT NULL,
   STUDENT_SEX        VARCHAR(10),
   STUDENT_BIRTHDAY   DATE,
   CLASS_ID           VARCHAR(255)
);

/*插入学生数据*/
INSERT INTO STUDENT_TBL (STUDENT_ID,
                         STUDENT_NAME,
                         STUDENT_SEX,
                         STUDENT_BIRTHDAY,
                         CLASS_ID)
  VALUES   (123456,
            ''某某某'',
            ''女'',
            ''1980-08-01'',
            121546
            )

创建连接 MySql 使用的配置文件 mysql.properties。

jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/student_manager?user=root&password=limingnihao&useUnicode=true&characterEncoding=UTF-8

 

1.2.3 搭建 MyBatis 环境

顺序随便，现在的顺序是因为可以尽量的少的修改写好的文件。

1.2.3.1 创建实体类: StudentEntity

public class StudentEntity implements Serializable {

	private static final long serialVersionUID = 3096154202413606831L;
	private ClassEntity classEntity;
	private Date studentBirthday;
	private String studentID;
	private String studentName;
	private String studentSex;
	
	public ClassEntity getClassEntity() {
		return classEntity;
	}

	public Date getStudentBirthday() {
		return studentBirthday;
	}

	public String getStudentID() {
		return studentID;
	}

	public String getStudentName() {
		return studentName;
	}

	public String getStudentSex() {
		return studentSex;
	}

	public void setClassEntity(ClassEntity classEntity) {
		this.classEntity = classEntity;
	}

	public void setStudentBirthday(Date studentBirthday) {
		this.studentBirthday = studentBirthday;
	}

	public void setStudentID(String studentID) {
		this.studentID = studentID;
	}

	public void setStudentName(String studentName) {
		this.studentName = studentName;
	}

	public void setStudentSex(String studentSex) {
		this.studentSex = studentSex;
	}
}

 

1.2.3.2 创建数据访问接口

Student 类对应的 dao 接口：StudentMapper。

public interface StudentMapper {
	
	public StudentEntity getStudent(String studentID);
	
	public StudentEntity getStudentAndClass(String studentID);
	
	public List<StudentEntity> getStudentAll();
	
	public void insertStudent(StudentEntity entity);
	
	public void deleteStudent(StudentEntity entity);
	
	public void updateStudent(StudentEntity entity);
}

1.2.3.3 创建 SQL 映射语句文件

Student 类的 sql 语句文件 StudentMapper.xml
resultMap 标签：表字段与属性的映射。
Select 标签：查询 sql。

<?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.manager.data.StudentMapper">

	<resultMap type="StudentEntity" id="studentResultMap">
		<id property="studentID" column="STUDENT_ID"/>
		<result property="studentName" column="STUDENT_NAME"/>
		<result property="studentSex" column="STUDENT_SEX"/>
		<result property="studentBirthday" column="STUDENT_BIRTHDAY"/>
	</resultMap>
	
	<!-- 查询学生，根据id -->
	<select id="getStudent" parameterType="String" resultType="StudentEntity" resultMap="studentResultMap">
		<![CDATA[
			SELECT * from STUDENT_TBL ST
				WHERE ST.STUDENT_ID = #{studentID} 
		]]> 
	</select>
	
	<!-- 查询学生列表 -->
	<select id="getStudentAll"  resultType="com.manager.data.model.StudentEntity" resultMap="studentResultMap">
		<![CDATA[
			SELECT * from STUDENT_TBL
		]]> 
	</select>
	
</mapper>

1.2.3.4 创建 MyBatis 的 mapper 配置文件

在 src/main/resource 中创建 MyBatis 配置文件：mybatis-config.xml。
typeAliases 标签：给类起一个别名。com.manager.data.model.StudentEntity 类，可以使用 StudentEntity 代替。
Mappers 标签：加载 MyBatis 中实体类的 SQL 映射语句文件。

 

<?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>
	<typeAliases>
		<typeAlias alias="StudentEntity" type="com.manager.data.model.StudentEntity"/>
	</typeAliases>
	<mappers>
		<mapper resource="com/manager/data/maps/StudentMapper.xml" />
	</mappers>
</configuration>

1.2.3.5 修改 Spring 的配置文件

主要是添加 SqlSession 的制作工厂类的 bean：SqlSessionFactoryBean，（在 mybatis.spring 包中）。需要指定配置文件位置和 dataSource。
和数据访问接口对应的实现 bean。通过 MapperFactoryBean 创建出来。需要执行接口类全称和 SqlSession 工厂 bean 的引用。

<!-- 导入属性配置文件 -->
<context:property-placeholder location="classpath:mysql.properties" />

<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
	<property name="driverClassName" value="${jdbc.driverClassName}" />
	<property name="url" value="${jdbc.url}" />
</bean>

<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
	<property name="dataSource" ref="dataSource" />
</bean>

<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
	<property name="configLocation" value="classpath:mybatis-config.xml" />
	<property name="dataSource" ref="dataSource" />
</bean>

<!— mapper bean -->
<bean id="studentMapper" class="org.mybatis.spring.MapperFactoryBean">
	<property name="mapperInterface" value="com.manager.data.StudentMapper" />
	<property name="sqlSessionFactory" ref="sqlSessionFactory" />
</bean>

也可以不定义 mapper 的 bean，使用注解：

将 StudentMapper 加入注解

@Repository
@Transactional
public interface StudentMapper {
}

对应的需要在 dispatcher-servlet.xml 中加入扫描：

<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="annotationClass" value="org.springframework.stereotype.Repository"/>
        <property name="basePackage" value="com.liming.manager"/>
        <property name="sqlSessionFactory" ref="sqlSessionFactory"/>
    </bean>

 

1.2.4 测试 StudentMapper

使用 SpringMVC 测试，创建一个 TestController，配置 tomcat，访问 index.do 页面进行测试：

@Controller
public class TestController {

	@Autowired
	private StudentMapper studentMapper;
	
	@RequestMapping(value = "index.do")
	public void indexPage() {	
		StudentEntity entity = studentMapper.getStudent("10000013");
		System.out.println("name：" + entity.getStudentName());
	}	
}

 

使用 Junit 测试：

使用Junit测试：
Java代码
@RunWith(value = SpringJUnit4ClassRunner.class)
@ContextConfiguration(value = "test-servlet.xml")
public class StudentMapperTest {
	
	@Autowired
	private ClassMapper classMapper;
	
	@Autowired
	private StudentMapper studentMapper;
	
	@Transactional
	public void getStudentTest(){
		StudentEntity entity = studentMapper.getStudent("10000013");
		System.out.println("" + entity.getStudentID() + entity.getStudentName());
		
		List<StudentEntity> studentList = studentMapper.getStudentAll();
		for( StudentEntity entityTemp : studentList){
			System.out.println(entityTemp.getStudentName());
		}
		
	}
}

 

mybatis 学习笔记（二）：mybatis SQL注入问题

mybatis 学习笔记（二）：mybatis SQL注入问题

SQL 注入攻击

首先了解下概念，什么叫SQL 注入：

SQL注入攻击，简称SQL攻击或注入攻击，是发生于应用程序之数据库层的安全漏洞。简而言之，是在输入的字符串之中注入SQL指令，在设计不良的程序当中忽略了检查，那么这些注入进去的指令就会被数据库服务器误认为是正常的SQL指令而运行，因此遭到破坏或是入侵。

最常见的就是我们在应用程序中使用字符串联结方式组合 SQL 指令，有心之人就会写一些特殊的符号，恶意篡改原本的 SQL 语法的作用，达到注入攻击的目的。

举个栗子：

比如验证用户登录需要 username 和 password，编写的 SQL 语句如下：

select * from user where (name = ''"+ username +"'') and (pw = ''"+ password +"'');

username 和 password 字段被恶意填入

username = "1'' OR ''1''=''1";

与

password = "1'' OR ''1''=''1";

将导致原本的 SQL 字符串被填为：

select * from user where (name = ''1'' or ''1''=''1'') and (pw = ''1'' or ''1''=''1'');

实际上运行的 SQL 语句将变成：

select * from user;

也就是不再需要 username 和 password 账密即达到登录的目的，结果不言而喻。

mybatis 解决 SQL 注入问题

我们使用 mybatis 编写 SQL 语句时，难免会使用模糊查询的方法，mybatis 提供了两种方式 #{} 和 ${} 。

• #{value} 在预处理时，会把参数部分用一个占位符 ? 替代，其中 value 表示接受输入参数的名称。能有效解决 SQL 注入问题
• ${} 表示使用拼接字符串，将接受到参数的内容不加任何修饰符拼接在 SQL 中，使用${}拼接 sql，将引起 SQL 注入问题。

举个栗子：

1 查询数据库 sample 表 user 中的记录，我们故意使用特殊符号，看能否引起 SQL 注入。使用 mybatis 在 mapper.xml 配置文件中编写 SQL 语句，我们先采用拼接字符串形式，看看结果如何：

 <select id="findUserByName" parameterType="java.lang.String" resultType="cn.itcast.mybatis.po.User">
        <!-- 拼接 MySQL,引起 SQL 注入 -->
        SELECT * FROM user WHERE username LIKE ''%${value}%''
    </select>

注意在配置文件中编写 SQL 语句时，后边不需要加分号。

调用配置文件，编写测试文件，查询数据库内容，采用特殊符号，引起 SQL 注入：

    @Test
    public void testFindUserByName() throws Exception{

        SqlSession sqlSession=sqlSessionFactory.openSession();

        //创建UserMapper代理对象
        UserMapper userMapper=sqlSession.getMapper(UserMapper.class);

        //调用userMapper的方法
        List<User> list=userMapper.findUserByName("'' or ''1''=''1");

        sqlSession.close();

        System.out.println(list);
    }
}

运行结果如下图所示：

可以看到执行语句其实变为了

select * from user

将user 表中的全部记录打印出来了。发生了 SQL 注入。

2 如果将配置文件中的 SQL 语句改成 #{} 形式，可避免 SQL 注入。

 <select id="findUserByName" parameterType="java.lang.String" resultType="cn.itcast.mybatis.po.User">
        <!-- 使用 SQL concat 语句,拼接字符串,防止 SQL 注入 -->
        SELECT * FROM USER WHERE username LIKE CONCAT(''%'',#{value},''%'' )
    </select>

再次运行测试程序，控制台输出如下：

可以看到程序中参数部分用 ? 替代了，很好地解决了 SQL 语句的问题，防止了 SQL 注入。查询结果将为空。

MyBatis 源码分析（二）：MyBatis 整体架构及原理

一、Mybatis 整体架构导图

 

二、Mybatis 的核心组成

SqlSessionFactoryBuilder（构造器）：

根据配置信息（XML）生成 SqlSessionFactory 工厂接口，构造器使用了 org.apache.ibatis.builder.xml 包下的 XMLConfigBuilder 对 Mybatis-config 配置文件解析，该 XML 解析类使用了 org.apache.ibatis.parsing 解析包下的工具解析 XML 各个节点的信息，构建 Configuration，再用 Configuration 创建 SqlSessionFactory，然后 SqlSessionFactoryBuilder 生命周期结束。其中，默认生成的是 DefaultSqlSessionFactory。

 

SqlSessionFactory（工厂接口）：

依靠工厂来生成 SqlSession 会话接口，生命周期贯穿整个应用，重复创建工厂接口会消耗更多数据库连接资源。

 

SqlSession（会话接口）：

发送 SQL 去执行并返回结果，还能获取 Mapper 的接口，生命周期存在于请求数据库处理事务中，结束后要关闭，线程不安全。它里面主要有四大对象：

1. Executor 执行器：SIMPLE、REUSER、BATCH
2. StatementHandler 数据库会话器：SimpleStatementHandler、PreparedStatementHandler、CallableStatementHandler，通过 RoutingStatementHandler 的适配器模式穿建不同的 StatementHandler 对象
3. ParameterHandler SQL 参数处理器：对预编译的 SQL 语句进行参数设置，完成预编译参数的设置，从 parameterObject 对象中取得参数，然后同 TypeHandler 进行参数处理
4. ResultHandler 结果处理器：组装结果集来返回的，里面有处理存储过程输出参数的方法，还有包装结果集的方法，默认情况下用 DefaultResultSetHandler 类，这个接口的实现有点复杂，涉及到 JAVASSIST 或者 CGLIB 作为延迟加载，然后用 TypeHandler 和 ObjectFactory 进行结果组装结果再返回

SqlSession 内部运行图：

 

SQL Mapper（Java 接口 + XML 文件 或者 Java 接口 + Java 注解）：

有对应的 SQL 和映射规则，负责发送 SQL 执行，并返回结果。映射器的内部由 3 部分组成：

MappedStatement，保存映射的一个节点 <select|insert|delete|update>，包括配置的 SQL，SQL 的 id、缓存信息、resultMap、parameterType、resultType、languageDriver 等配置内容；

SqlSource，提供 SqlBound 对象，是 MappedStatement 的一个属性；

SqlBound，建立 SQL 和参数的地方，有 3 个常用属性，sql、parameterObject，parameterMappings。

 

我们今天的关于Mybatis系列全解和二：Mybatis简介与环境搭建的分享已经告一段落，感谢您的关注，如果您想了解更多关于Mybatis 入门之MyBatis环境搭建(第一篇)、MyBatis 学习 之 一、MyBatis 简介与配置 MyBatis+Spring+MySql、mybatis 学习笔记（二）：mybatis SQL注入问题、MyBatis 源码分析（二）：MyBatis 整体架构及原理的相关信息，请在本站查询。

本文标签：

• Mybatis
• 环境搭建
• 简介
• 全解