mybatis总结

最新推荐文章于 2022-05-27 19:31:00 发布
最新推荐文章于 2022-05-27 19:31:00 发布
阅读量261 收藏 1
点赞数
分类专栏： mybatis学习 文章标签： 框架

1 Mybatis是什么？

MyBatis 本是apache的一个开源项目iBatis,

Mybatis和hibernate一样，是一个基于JDBC的持久层框架。

Hibernate是一个完全的、标准的ORM框架。

Mybatis是一个不完全的ORM框架。Mybatis可以对输入参数和输出结果进行映射。Mybatis需要程序员去编写sql语句。

Mybatis将sql语句配置到xml配置文件中，然后将输入参数进行映射，由mybatis框架将映射后的sql片段拼接到配置到xml中的sql语句。然后由mybatis框架来执行映射后的sql语句。执行之后的结果将由mybatis框架映射成java对象。

 

2 分析原生态jdbc程序中存在的问题

2.1 原生态Jdbc程序代码


  1. <span style="font-size: 14px;">package net.gbicc.dao;  
  2.   
  3. import java.sql.Connection;  
  4. import java.sql.DriverManager;  
  5. import java.sql.PreparedStatement;  
  6. import java.sql.ResultSet;  
  7. import java.sql.SQLException;  
  8.   
  9. public class JdbcDeom {  
  10.     public static void main(String[] args) {  
  11.         Connection connection = null;  
  12.         PreparedStatement preparedStatement = null;  
  13.         ResultSet resultSet = null;  
  14.           
  15.         try {  
  16.             //1、加载数据库驱动  
  17.             Class.forName("com.mysql.jdbc.Driver");  
  18.             //2、通过驱动管理类获取数据库链接  
  19.             connection =  DriverManager.getConnection("jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8", "root", "root");  
  20.             //3、定义sql语句 ?表示占位符  
  21.         String sql = "select * from user where username = ?";  
  22.             //4、获取预处理statement  
  23.             preparedStatement = connection.prepareStatement(sql);  
  24.             //5、设置参数，第一个参数为sql语句中参数的序号（从1开始），第二个参数为设置的参数值  
  25.             preparedStatement.setString(1, "王五");  
  26.             //6、向数据库发出sql执行查询，查询出结果集  
  27.             resultSet =  preparedStatement.executeQuery();  
  28.             //7、遍历查询结果集  
  29.             while(resultSet.next()){  
  30.                 System.out.println(resultSet.getString("id")+"  "+resultSet.getString("username"));  
  31.             }  
  32.         } catch (Exception e) {  
  33.             e.printStackTrace();  
  34.         }finally{  
  35.             //8、释放资源  
  36.             if(resultSet!=null){  
  37.                 try {  
  38.                     resultSet.close();  
  39.                 } catch (SQLException e) {  
  40.                     // TODO Auto-generated catch block  
  41.                     e.printStackTrace();  
  42.                 }  
  43.             }  
  44.             if(preparedStatement!=null){  
  45.                 try {  
  46.                     preparedStatement.close();  
  47.                 } catch (SQLException e) {  
  48.                     // TODO Auto-generated catch block  
  49.                     e.printStackTrace();  
  50.                 }  
  51.             }  
  52.             if(connection!=null){  
  53.                 try {  
  54.                     connection.close();  
  55.                 } catch (SQLException e) {  
  56.                     // TODO Auto-generated catch block  
  57.                     e.printStackTrace();  
  58.                 }  
  59.             }  
  60.   
  61.         }  
  62.   
  63.     }  
  64. }  
  65. </span>  
package net.gbicc.dao;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class JdbcDeom {
	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/mybatis?characterEncoding=utf-8", "root", "root");
			//3、定义sql语句 ?表示占位符
		String sql = "select * from user where username = ?";
			//4、获取预处理statement
			preparedStatement = connection.prepareStatement(sql);
			//5、设置参数，第一个参数为sql语句中参数的序号（从1开始），第二个参数为设置的参数值
			preparedStatement.setString(1, "王五");
			//6、向数据库发出sql执行查询，查询出结果集
			resultSet =  preparedStatement.executeQuery();
			//7、遍历查询结果集
			while(resultSet.next()){
				System.out.println(resultSet.getString("id")+"  "+resultSet.getString("username"));
			}
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			//8、释放资源
			if(resultSet!=null){
				try {
					resultSet.close();
				} catch (SQLException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			if(preparedStatement!=null){
				try {
					preparedStatement.close();
				} catch (SQLException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			if(connection!=null){
				try {
					connection.close();
				} catch (SQLException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}

		}

	}
}

2.2 Jdbc问题总结

1、 数据库连接频繁开启和关闭，会严重影响数据库的性能。

2、 代码中存在硬编码，分别是数据库部分的硬编码和SQL执行部分的硬编码。

3 Mybatis框架原理（核心）

3.1 框架图
两个原理图一样，哪个理解就看哪个

3.2 分析结论

1、 mybatis配置文件，包括Mybatis全局配置文件和Mybatis映射文件，其中全局配置文件配置了数据源、事务等信息；映射文件配置了SQL执行相关的 信息。

2、 mybatis通过读取配置文件信息（全局配置文件和映射文件），构造出SqlSessionFactory，即会话工厂。

3、 通过SqlSessionFactory，可以创建SqlSession即会话。Mybatis是通过SqlSession来操作数据库的。

4、 SqlSession本身不能直接操作数据库，它是通过底层的Executor执行器接口来操作数据库的。Executor接口有两个实现类，一个是普通执行器，一个是缓存执行器（默认）。

5、 Executor执行器要处理的SQL信息是封装到一个底层对象MappedStatement中。该对象包括：SQL语句、输入参数映射信息、输出结果集映射信息。其中输入参数和输出结果的映射类型包括java的简单类型、HashMap集合对象、POJO对象类型。

4 Mybatis入门程序

Mybatis课程的所有代码程序将通过一个订单商品案例来进行讲解。

4.1 需求

对用户信息的增删改查操作。

1、 根据用户ID来查询用户信息；

2、 根据用户名称来模糊查询用户信息列表；

3、 添加用户

4、 删除用户（自己练习）

5、 修改用户（自己练习）

4.2 环境准备

Jdk环境：jdk1.7

Ide环境：eclipse indigo

数据库环境：MySQL 5.1

Mybatis：3.2.7

4.2.1 数据库初始化

4.2.1.1 数据库脚本
sql_data.sql和sql_table.sql
sql_data.sql

  1. <span style="font-size: 14px;">/* 
  2. SQLyog v10.2  
  3. MySQL - 5.1.72-community : Database - mybatis 
  4. ********************************************************************* 
  5. */  
  6.   
  7.   
  8. /*!40101 SET NAMES utf8 */;  
  9.   
  10. /*!40101 SET SQL_MODE=''*/;  
  11.   
  12. /*!40014 SET @OLD_UNIQUE_CHECKS=@@UNIQUE_CHECKS, UNIQUE_CHECKS=0 */;  
  13. /*!40014 SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0 */;  
  14. /*!40101 SET @OLD_SQL_MODE=@@SQL_MODE, SQL_MODE='NO_AUTO_VALUE_ON_ZERO' */;  
  15. /*!40111 SET @OLD_SQL_NOTES=@@SQL_NOTES, SQL_NOTES=0 */;  
  16. /*Data for the table `items` */  
  17.   
  18. insert  into `items`(`id`,`name`,`price`,`detail`,`pic`,`createtime`) values (1,'台式机',3000.0,'该电脑质量非常好！！！！',NULL,'2015-02-03 13:22:53'),(2,'笔记本',6000.0,'笔记本性能好，质量好！！！！！',NULL,'2015-02-09 13:22:57'),(3,'背包',200.0,'名牌背包，容量大质量好！！！！',NULL,'2015-02-06 13:23:02');  
  19.   
  20. /*Data for the table `orderdetail` */  
  21.   
  22. insert  into `orderdetail`(`id`,`orders_id`,`items_id`,`items_num`) values (1,3,1,1),(2,3,2,3),(3,4,3,4),(4,4,2,3);  
  23.   
  24. /*Data for the table `orders` */  
  25.   
  26. insert  into `orders`(`id`,`user_id`,`number`,`createtime`,`note`) values (3,1,'1000010','2015-02-04 13:22:35',NULL),(4,1,'1000011','2015-02-03 13:22:41',NULL),(5,10,'1000012','2015-02-12 16:13:23',NULL);  
  27.   
  28. /*Data for the table `user` */  
  29.   
  30. insert  into `user`(`id`,`username`,`birthday`,`sex`,`address`) values (1,'王五',NULL,'2',NULL),(10,'张三','2014-07-10','1','北京市'),(16,'张小明',NULL,'1','河南郑州'),(22,'陈小明',NULL,'1','河南郑州'),(24,'张三丰',NULL,'1','河南郑州'),(25,'陈小明',NULL,'1','河南郑州'),(26,'王五',NULL,NULL,NULL);  
  31.   
  32. /*!40101 SET SQL_MODE=@OLD_SQL_MODE */;  
  33. /*!40014 SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS */;  
  34. /*!40014 SET UNIQUE_CHECKS=@OLD_UNIQUE_CHECKS */;  
  35. /*!40111 SET SQL_NOTES=@OLD_SQL_NOTES */;</span><span style="font-size: 16pt;">  
  36. </span>  
/*
SQLyog v10.2 
MySQL - 5.1.72-community : Database - mybatis
*********************************************************************
*/


/*!40101 SET NAMES utf8 */;

/*!40101 SET SQL_MODE=''*/;

/*!40014 SET @OLD_UNIQUE_CHECKS=@@UNIQUE_CHECKS, UNIQUE_CHECKS=0 */;
/*!40014 SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0 */;
/*!40101 SET @OLD_SQL_MODE=@@SQL_MODE, SQL_MODE='NO_AUTO_VALUE_ON_ZERO' */;
/*!40111 SET @OLD_SQL_NOTES=@@SQL_NOTES, SQL_NOTES=0 */;
/*Data for the table `items` */

insert  into `items`(`id`,`name`,`price`,`detail`,`pic`,`createtime`) values (1,'台式机',3000.0,'该电脑质量非常好！！！！',NULL,'2015-02-03 13:22:53'),(2,'笔记本',6000.0,'笔记本性能好，质量好！！！！！',NULL,'2015-02-09 13:22:57'),(3,'背包',200.0,'名牌背包，容量大质量好！！！！',NULL,'2015-02-06 13:23:02');

/*Data for the table `orderdetail` */

insert  into `orderdetail`(`id`,`orders_id`,`items_id`,`items_num`) values (1,3,1,1),(2,3,2,3),(3,4,3,4),(4,4,2,3);

/*Data for the table `orders` */

insert  into `orders`(`id`,`user_id`,`number`,`createtime`,`note`) values (3,1,'1000010','2015-02-04 13:22:35',NULL),(4,1,'1000011','2015-02-03 13:22:41',NULL),(5,10,'1000012','2015-02-12 16:13:23',NULL);

/*Data for the table `user` */

insert  into `user`(`id`,`username`,`birthday`,`sex`,`address`) values (1,'王五',NULL,'2',NULL),(10,'张三','2014-07-10','1','北京市'),(16,'张小明',NULL,'1','河南郑州'),(22,'陈小明',NULL,'1','河南郑州'),(24,'张三丰',NULL,'1','河南郑州'),(25,'陈小明',NULL,'1','河南郑州'),(26,'王五',NULL,NULL,NULL);

/*!40101 SET SQL_MODE=@OLD_SQL_MODE */;
/*!40014 SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS */;
/*!40014 SET UNIQUE_CHECKS=@OLD_UNIQUE_CHECKS */;
/*!40111 SET SQL_NOTES=@OLD_SQL_NOTES */;

sql_table.sql

  1. <span style="font-size: 14px;">/* 
  2. SQLyog v10.2  
  3. MySQL - 5.1.72-community : Database - mybatis 
  4. ********************************************************************* 
  5. */  
  6.   
  7.   
  8. /*!40101 SET NAMES utf8 */;  
  9.   
  10. /*!40101 SET SQL_MODE=''*/;  
  11.   
  12. /*!40014 SET @OLD_UNIQUE_CHECKS=@@UNIQUE_CHECKS, UNIQUE_CHECKS=0 */;  
  13. /*!40014 SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0 */;  
  14. /*!40101 SET @OLD_SQL_MODE=@@SQL_MODE, SQL_MODE='NO_AUTO_VALUE_ON_ZERO' */;  
  15. /*!40111 SET @OLD_SQL_NOTES=@@SQL_NOTES, SQL_NOTES=0 */;  
  16. /*Table structure for table `items` */  
  17.   
  18. CREATE TABLE `items` (  
  19.   `id` int(11) NOT NULL AUTO_INCREMENT,  
  20.   `name` varchar(32) NOT NULL COMMENT '商品名称',  
  21.   `price` float(10,1) NOT NULL COMMENT '商品定价',  
  22.   `detail` text COMMENT '商品描述',  
  23.   `pic` varchar(64) DEFAULT NULL COMMENT '商品图片',  
  24.   `createtime` datetime NOT NULL COMMENT '生产日期',  
  25.   PRIMARY KEY (`id`)  
  26. ) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8;  
  27.   
  28. /*Table structure for table `orderdetail` */  
  29.   
  30. CREATE TABLE `orderdetail` (  
  31.   `id` int(11) NOT NULL AUTO_INCREMENT,  
  32.   `orders_id` int(11) NOT NULL COMMENT '订单id',  
  33.   `items_id` int(11) NOT NULL COMMENT '商品id',  
  34.   `items_num` int(11) DEFAULT NULL COMMENT '商品购买数量',  
  35.   PRIMARY KEY (`id`),  
  36.   KEY `FK_orderdetail_1` (`orders_id`),  
  37.   KEY `FK_orderdetail_2` (`items_id`),  
  38.   CONSTRAINT `FK_orderdetail_1` FOREIGN KEY (`orders_id`) REFERENCES `orders` (`id`) ON DELETE NO ACTION ON UPDATE NO ACTION,  
  39.   CONSTRAINT `FK_orderdetail_2` FOREIGN KEY (`items_id`) REFERENCES `items` (`id`) ON DELETE NO ACTION ON UPDATE NO ACTION  
  40. ) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8;  
  41.   
  42. /*Table structure for table `orders` */  
  43.   
  44. CREATE TABLE `orders` (  
  45.   `id` int(11) NOT NULL AUTO_INCREMENT,  
  46.   `user_id` int(11) NOT NULL COMMENT '下单用户id',  
  47.   `number` varchar(32) NOT NULL COMMENT '订单号',  
  48.   `createtime` datetime NOT NULL COMMENT '创建订单时间',  
  49.   `note` varchar(100) DEFAULT NULL COMMENT '备注',  
  50.   PRIMARY KEY (`id`),  
  51.   KEY `FK_orders_1` (`user_id`),  
  52.   CONSTRAINT `FK_orders_id` FOREIGN KEY (`user_id`) REFERENCES `user` (`id`) ON DELETE NO ACTION ON UPDATE NO ACTION  
  53. ) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=utf8;  
  54.   
  55. /*Table structure for table `user` */  
  56.   
  57. CREATE TABLE `user` (  
  58.   `id` int(11) NOT NULL AUTO_INCREMENT,  
  59.   `username` varchar(32) NOT NULL COMMENT '用户名称',  
  60.   `birthday` date DEFAULT NULL COMMENT '生日',  
  61.   `sex` char(1) DEFAULT NULL COMMENT '性别',  
  62.   `address` varchar(256) DEFAULT NULL COMMENT '地址',  
  63.   PRIMARY KEY (`id`)  
  64. ) ENGINE=InnoDB AUTO_INCREMENT=27 DEFAULT CHARSET=utf8;  
  65.   
  66. /*!40101 SET SQL_MODE=@OLD_SQL_MODE */;  
  67. /*!40014 SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS */;  
  68. /*!40014 SET UNIQUE_CHECKS=@OLD_UNIQUE_CHECKS */;  
  69. /*!40111 SET SQL_NOTES=@OLD_SQL_NOTES */;  
  70. </span>  
/*
SQLyog v10.2 
MySQL - 5.1.72-community : Database - mybatis
*********************************************************************
*/


/*!40101 SET NAMES utf8 */;

/*!40101 SET SQL_MODE=''*/;

/*!40014 SET @OLD_UNIQUE_CHECKS=@@UNIQUE_CHECKS, UNIQUE_CHECKS=0 */;
/*!40014 SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0 */;
/*!40101 SET @OLD_SQL_MODE=@@SQL_MODE, SQL_MODE='NO_AUTO_VALUE_ON_ZERO' */;
/*!40111 SET @OLD_SQL_NOTES=@@SQL_NOTES, SQL_NOTES=0 */;
/*Table structure for table `items` */

CREATE TABLE `items` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(32) NOT NULL COMMENT '商品名称',
  `price` float(10,1) NOT NULL COMMENT '商品定价',
  `detail` text COMMENT '商品描述',
  `pic` varchar(64) DEFAULT NULL COMMENT '商品图片',
  `createtime` datetime NOT NULL COMMENT '生产日期',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8;

/*Table structure for table `orderdetail` */

CREATE TABLE `orderdetail` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `orders_id` int(11) NOT NULL COMMENT '订单id',
  `items_id` int(11) NOT NULL COMMENT '商品id',
  `items_num` int(11) DEFAULT NULL COMMENT '商品购买数量',
  PRIMARY KEY (`id`),
  KEY `FK_orderdetail_1` (`orders_id`),
  KEY `FK_orderdetail_2` (`items_id`),
  CONSTRAINT `FK_orderdetail_1` FOREIGN KEY (`orders_id`) REFERENCES `orders` (`id`) ON DELETE NO ACTION ON UPDATE NO ACTION,
  CONSTRAINT `FK_orderdetail_2` FOREIGN KEY (`items_id`) REFERENCES `items` (`id`) ON DELETE NO ACTION ON UPDATE NO ACTION
) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8;

/*Table structure for table `orders` */

CREATE TABLE `orders` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `user_id` int(11) NOT NULL COMMENT '下单用户id',
  `number` varchar(32) NOT NULL COMMENT '订单号',
  `createtime` datetime NOT NULL COMMENT '创建订单时间',
  `note` varchar(100) DEFAULT NULL COMMENT '备注',
  PRIMARY KEY (`id`),
  KEY `FK_orders_1` (`user_id`),
  CONSTRAINT `FK_orders_id` FOREIGN KEY (`user_id`) REFERENCES `user` (`id`) ON DELETE NO ACTION ON UPDATE NO ACTION
) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=utf8;

/*Table structure for table `user` */

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

/*!40101 SET SQL_MODE=@OLD_SQL_MODE */;
/*!40014 SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS */;
/*!40014 SET UNIQUE_CHECKS=@OLD_UNIQUE_CHECKS */;
/*!40111 SET SQL_NOTES=@OLD_SQL_NOTES */;

1、 执行sql_table.sql脚本，创建数据库表；

2、 执行sql_data.sql初始化测试数据。


如何执行，可以新建一个数据库，mybatis01然后用客户端执行上边的sql即可。
4.2.1.2 数据库表

订单商品案例的数据库脚本中，总共包含四张表，其中入门程序只使用user表：

用户表的表结构如下：


4.2.2 下载mybatis

mybaits的代码由github.com管理，下载地址：https://github.com/mybatis/mybatis-3/releases

解压之后的目录结构

Lib：mybatis的依赖包

Mybatis-3.2.7.jar：mybatis的核心包

Mybatis-3.2.7.pdf：mybatis的使用指南

4.3 工程搭建（三步）

4.3.1 第一步：创建java工程

用eclipse创建一个java工程，jdk使用1.7


4.3.2 第二步：加入jar包

加入以下四部分jar包，其中junit的jar包，是非必须的。

1、 Mybatis核心包


2、 Mybatis依赖包（lib目录下的所有包）



3、MySQL驱动包


4、Junit单元测试包（单元测试需要的包）
一共12个包，除去测试包，一共11个jar包
添加jar包的方法无须赘述，可以建一个lib目录添加

4.3.3 第三步：添加log4j.properties文件

Mybatis使用的日志包是log4j的，所以需要添加log4j.properties。

在classpath下创建log4j.properties如下：

文件内容可以从mybatis-3.2.7.pdf中拷贝


  1. # Global logging configuration  
  2. log4j.rootLogger=DEBUG, stdout  
  3. # Console output...  
  4. log4j.appender.stdout=org.apache.log4j.ConsoleAppender  
  5. log4j.appender.stdout.layout=org.apache.log4j.PatternLayout  
  6. log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n  
# Global logging configuration
log4j.rootLogger=DEBUG, stdout
# Console output...
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n

日志级别在开发阶段设置成DEBUG，在生产阶段设置成INFO或者ERROR。

4.4 编程步骤（思路很重要，技术不会可以练，但是思路没有却是什么都不会了）

1、 创建PO类，根据需求创建；

2、 创建全局配置文件SqlMapConfig.xml；

3、 编写映射文件；

4、 加载映射文件，在SqlMapConfig.xml中进行加载；

5、 编写测试程序，即编写Java代码，连接并操作数据库。

思路：

a) 读取配置文件；

b) 通过SqlSessionFactoryBuilder创建SqlSessionFactory会话工厂。

c) 通过SqlSessionFactory创建SqlSession。

d) 调用SqlSession的操作数据库方法。

e) 关闭SqlSession。

要理解orm映射。详见hibernate的orm映射关系图

4.5 代码开发

4.5.1 创建PO类

创建的po类的属性要和数据库中表的列名一致（如果表中的列名是带有下划线，那么po类中对应的的属性名要采用驼峰式命名）

User.java类如下：（与数据表结构一一对应，可以对照着写po类）


  1. Public class User {  
  2.     private int id;  
  3.     private String username;// 用户姓名  
  4.     private String sex;// 性别  
  5.     private Date birthday;// 生日  
  6.     private String address;// 地址  
  7. get/set……  
Public class User {
	private int id;
	private String username;// 用户姓名
	private String sex;// 性别
	private Date birthday;// 生日
	private String address;// 地址
get/set……

4.5.2 创建SqlMapConfig.xml配置文件

在classpath下，创建SqlMapConfig.xml文件

SqlMapConfig.xml（文件头可以从mybatis-3.2.7.pdf文档的2.1.2小节中拷贝）：


  1. <?xml version="1.0" encoding="UTF-8" ?>  
  2. <!DOCTYPE configuration  
  3. PUBLIC "-//mybatis.org//DTD Config 3.0//EN"  
  4. "http://mybatis.org/dtd/mybatis-3-config.dtd">  
  5. <configuration>  
  6. <!-- 配置mybatis的环境信息 -->  
  7. <environments default="development">  
  8.     <environment id="development">  
  9.         <!-- 配置JDBC事务控制，由mybatis进行管理 -->  
  10.         <transactionManager type="JDBC"></transactionManager>  
  11.         <!-- 配置数据源，采用dbcp连接池 -->  
  12.         <dataSource type="POOLED">  
  13.             <property name="driver" value="com.mysql.jdbc.Driver"/>  
  14.             <property name="url" value="jdbc:mysql://localhost:3306/mybatis01?useUnicode=true&characterEncoding=utf8"/>  
  15.             <property name="username" value="root"/>  
  16.             <property name="password" value="root"/>  
  17.         </dataSource>  
  18.     </environment>  
  19. </environments>  
  20. </configuration>  
<?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>
<!-- 配置mybatis的环境信息 -->
<environments default="development">
	<environment id="development">
		<!-- 配置JDBC事务控制，由mybatis进行管理 -->
		<transactionManager type="JDBC"></transactionManager>
		<!-- 配置数据源，采用dbcp连接池 -->
		<dataSource type="POOLED">
			<property name="driver" value="com.mysql.jdbc.Driver"/>
			<property name="url" value="jdbc:mysql://localhost:3306/mybatis01?useUnicode=true&characterEncoding=utf8"/>
			<property name="username" value="root"/>
			<property name="password" value="root"/>
		</dataSource>
	</environment>
</environments>
</configuration>

4.5.3 需求开发

在classpath下，创建sqlmap文件夹。在sqlmap目录下，创建User.xml映射文件。

Mybatis的映射文件头（可以从mybatis-3.2.7.pdf文件中拷贝）：


  1. <span style="font-size: 14px;"><?xml version="1.0" encoding="UTF-8" ?>  
  2. <!DOCTYPE mapper      
  3. PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"      
  4. "http://mybatis.org/dtd/mybatis-3-mapper.dtd"></span>  
<?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">

注意：这点与hibernate不同，hibernate是一般直接在user.java的同级目录下创建User.xml而mybatis是在classpath下创建一个sqlmap文件夹，然后在创建一个User.xml文件。这点要注意一下

4.5.3.1 根据用户ID来查询用户信息
4.5.3.1.1 编写映射文件

在User.xml中添加以下代码：


  1. <span style="font-size: 14px;"><!--   
  2.     namespace：命名空间，它的作用就是对SQL进行分类化管理，可以理解为SQL隔离  
  3.     注意：使用mapper代理开发时，namespace有特殊且重要的作用  
  4.  -->  
  5. <mapper namespace="test">  
  6.   
  7.     <!-- 根据用户ID，查询用户信息 -->  
  8.     <!--   
  9.         [id]：statement的id，要求在命名空间内唯一    
  10.         [parameterType]：入参的java类型  
  11.         [resultType]：查询出的单条结果集对应的java类型  
  12.         [#{}]： 表示一个占位符?  
  13.         [#{id}]：表示该占位符待接收参数的名称为id。注意：如果参数为简单类型时，#{}里面的参数名称可以是任意定义  
  14.      -->  
  15.     <select id="findUserById" parameterType="int" resultType="net.gbicc.dao.User">  
  16.         SELECT * FROM USER WHERE id = #{id}  
  17.     </select>  
  18. </mapper></span>  
<!-- 
	namespace：命名空间，它的作用就是对SQL进行分类化管理，可以理解为SQL隔离
	注意：使用mapper代理开发时，namespace有特殊且重要的作用
 -->
<mapper namespace="test">

	<!-- 根据用户ID，查询用户信息 -->
	<!-- 
		[id]：statement的id，要求在命名空间内唯一  
		[parameterType]：入参的java类型
		[resultType]：查询出的单条结果集对应的java类型
		[#{}]： 表示一个占位符?
		[#{id}]：表示该占位符待接收参数的名称为id。注意：如果参数为简单类型时，#{}里面的参数名称可以是任意定义
	 -->
	<select id="findUserById" parameterType="int" resultType="net.gbicc.dao.User">
		SELECT * FROM USER WHERE id = #{id}
	</select>
</mapper>
注意：resultType对应的是映射的类，但是不要.java后缀名
4.5.3.1.2 加载映射文件（与主配置文件建立关系）

在SqlMapConfig.xml中，添加以下代码：


  1. <!-- 加载mapper -->  
  2. <mappers>  
  3.     <mapper resource="sqlmap/User.xml"/>  
  4. </mappers>  
<!-- 加载mapper -->
<mappers>
	<mapper resource="sqlmap/User.xml"/>
</mappers>

加在<configuration>下就可与<environments>同一级
4.5.3.1.3 编写测试程序

  1. <span style="font-size: 14px;">package net.gbicc.demo;  
  2.   
  3. import java.io.InputStream;  
  4.   
  5. import net.gbicc.dao.User;  
  6.   
  7. import org.apache.ibatis.io.Resources;  
  8. import org.apache.ibatis.session.SqlSession;  
  9. import org.apache.ibatis.session.SqlSessionFactory;  
  10. import org.apache.ibatis.session.SqlSessionFactoryBuilder;  
  11. import org.junit.Test;  
  12.   
  13. public class MybatisFirst {  
  14.     @Test  
  15.     public void findUserByIdTest() throws Exception{  
  16.           
  17.         //1、读取配置文件  
  18.         String resource = "SqlMapConfig.xml";  
  19.         InputStream inputStream = Resources.getResourceAsStream(resource);  
  20.         //2、根据配置文件创建SqlSessionFactory  
  21.         SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);  
  22.         //3、SqlSessionFactory创建SqlSession  
  23.         SqlSession sqlSession = sqlSessionFactory.openSession();  
  24.         //4、SqlSession执行statement，并返回映射结果  
  25.         //第一个参数：statement的id，建议：namespace.statementId（确保唯一）  
  26.         //第二个参数：入参的值，它的类型要和映射文件中对应的statement的入参类型一致  
  27.         User user = sqlSession.selectOne("findUserById", 1);  
  28.           
  29.         //打印输出结果集  
  30.         System.out.println(user);  
  31.           
  32.         //5、关闭SqlSession  
  33.         sqlSession.close();  
  34.     }  
  35. }</span><span style="font-size: 14pt;">  
  36. </span>  
package net.gbicc.demo;

import java.io.InputStream;

import net.gbicc.dao.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;

public class MybatisFirst {
	@Test
	public void findUserByIdTest() throws Exception{
		
		//1、读取配置文件
		String resource = "SqlMapConfig.xml";
		InputStream inputStream = Resources.getResourceAsStream(resource);
		//2、根据配置文件创建SqlSessionFactory
		SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
		//3、SqlSessionFactory创建SqlSession
		SqlSession sqlSession = sqlSessionFactory.openSession();
		//4、SqlSession执行statement，并返回映射结果
		//第一个参数：statement的id，建议：namespace.statementId（确保唯一）
		//第二个参数：入参的值，它的类型要和映射文件中对应的statement的入参类型一致
		User user = sqlSession.selectOne("findUserById", 1);
		
		//打印输出结果集
		System.out.println(user);
		
		//5、关闭SqlSession
		sqlSession.close();
	}
}
这里读取配置文件有多种方式，这只是利用io流操作

4.5.3.2 根据用户名称来模糊查询用户信息列表
4.5.3.2.1 编写映射文件

在User.xml中，添加以下内容：


  1. <span style="font-size: 14px;"><!-- 根据用户名称模糊查询用户信息列表 -->  
  2. <!--   
  3.         [${}]：表示拼接SQL字符串  
  4.         [${value}]：表示要拼接的是简单类型参数。  
  5.          注意：  
  6.         1、如果参数为简单类型时，${}里面的参数名称必须为value   
  7.         2、${}会引起SQL注入，一般情况下不推荐使用。但是有些场景必须使用${}，比如order by ${colname}  
  8. -->  
  9. <select id="findUsersByName" parameterType="String" resultType="</span><span style='font-family: "宋体"; font-size: 14px;'>net.gbicc.dao.User</span><span style='font-family: "宋体"; font-size: 14px;'>"></span><span style="font-size: 14px;">  
  10.     SELECT * FROM USER WHERE username LIKE '%${value}%'  
  11. </select></span>  
<!-- 根据用户名称模糊查询用户信息列表 -->
<!-- 
		[${}]：表示拼接SQL字符串
	 	[${value}]：表示要拼接的是简单类型参数。
		 注意：
		1、如果参数为简单类型时，${}里面的参数名称必须为value 
		2、${}会引起SQL注入，一般情况下不推荐使用。但是有些场景必须使用${}，比如order by ${colname}
-->
<select id="findUsersByName" parameterType="String" resultType="net.gbicc.dao.User">
	SELECT * FROM USER WHERE username LIKE '%${value}%'
</select>

4.5.3.2.2 加载映射文件

已配置，此处无需再次配置。

4.5.3.2.3 编写测试程序

  1. @Test  
  2.     public void findUsersByNameTest() throws Exception {  
  3.         // 1、读取配置文件  
  4.         String resource = "SqlMapConfig.xml";  
  5.         InputStream inputStream = Resources.getResourceAsStream(resource);  
  6.         // 2、根据配置文件创建SqlSessionFactory  
  7.         SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);  
  8.         // 3、SqlSessionFactory创建SqlSession  
  9.         SqlSession sqlSession = sqlSessionFactory.openSession();  
  10.         // 4、SqlSession执行statement，并返回映射结果  
  11.         // 第一个参数：statement的id，建议：namespace.statementId（确保唯一）  
  12.         // 第二个参数：入参的值，它的类型要和映射文件中对应的statement的入参类型一致  
  13.         List<User> users = sqlSession.selectList("test.findUsersByName", "小明");  
  14.   
  15.         // 打印输出结果集  
  16.         System.out.println(users);  
  17.   
  18.         // 5、关闭SqlSession  
  19.         sqlSession.close();  
  20.     }  
@Test
	public void findUsersByNameTest() throws Exception {
		// 1、读取配置文件
		String resource = "SqlMapConfig.xml";
		InputStream inputStream = Resources.getResourceAsStream(resource);
		// 2、根据配置文件创建SqlSessionFactory
		SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
		// 3、SqlSessionFactory创建SqlSession
		SqlSession sqlSession = sqlSessionFactory.openSession();
		// 4、SqlSession执行statement，并返回映射结果
		// 第一个参数：statement的id，建议：namespace.statementId（确保唯一）
		// 第二个参数：入参的值，它的类型要和映射文件中对应的statement的入参类型一致
		List<User> users = sqlSession.selectList("test.findUsersByName", "小明");

		// 打印输出结果集
		System.out.println(users);

		// 5、关闭SqlSession
		sqlSession.close();
	}

4.5.3.3 添加用户
4.5.3.3.1 编写映射文件

  1. <!-- 添加用户 -->  
  2. <!-- 如果主键的值是通过MySQL自增机制生成的，那么我们此处不需要再显示的给ID赋值 -->  
  3. <insert id="insertUser" parameterType="<span style='font-family: "宋体"; font-size: 14px;'>net.gbicc.dao.User</span><span style='font-family: "宋体"; font-size: 12px;'>"></span>  
  4.     INSERT INTO USER(username,sex,birthday,address) VALUES (#{username},#{sex},#{birthday},#{address})  
  5. </insert>  
<!-- 添加用户 -->
<!-- 如果主键的值是通过MySQL自增机制生成的，那么我们此处不需要再显示的给ID赋值 -->
<insert id="insertUser" parameterType="net.gbicc.dao.User">
	INSERT INTO USER(username,sex,birthday,address) VALUES (#{username},#{sex},#{birthday},#{address})
</insert>
4.5.3.3.2 加载映射文件

已配置，此处无需再次配置。

4.5.3.3.3 编写测试程序

注意：增删改操作要对SqlSession执行commit操作。


  1. <span style='font-family: "宋体";'>@Test  
  2.     public void insertUserTest() throws Exception {  
  3.         // 1、读取配置文件  
  4.         String resource = "SqlMapConfig.xml";  
  5.         InputStream inputStream = Resources.getResourceAsStream(resource);  
  6.         // 2、根据配置文件创建SqlSessionFactory  
  7.         SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder()  
  8.                 .build(inputStream);  
  9.         // 3、SqlSessionFactory创建SqlSession  
  10.         SqlSession sqlSession = sqlSessionFactory.openSession();  
  11.         // 4、SqlSession执行statement，并返回映射结果  
  12.           
  13.         //构建user参数，没有赋值的属性采取默认值  
  14.         User user = new User();  
  15.         user.setUsername("东哥1");  
  16.         user.setAddress("清河宝盛西里");  
  17.           
  18.         // 第一个参数：statement的id，建议：namespace.statementId（确保唯一）  
  19.         // 第二个参数：入参的值，它的类型要和映射文件中对应的statement的入参类型一致  
  20.         sqlSession.insert("insertUser", user);  
  21.   
  22.         </span>//切记：增删改操作时，要执行commit操作  
  23.         sqlSession.commit();<span style='font-family: "宋体";'>  
  24.   
  25.         // 5、关闭SqlSession  
  26.         sqlSession.close();  
  27.     }</span>  
@Test
	public void insertUserTest() throws Exception {
		// 1、读取配置文件
		String resource = "SqlMapConfig.xml";
		InputStream inputStream = Resources.getResourceAsStream(resource);
		// 2、根据配置文件创建SqlSessionFactory
		SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder()
				.build(inputStream);
		// 3、SqlSessionFactory创建SqlSession
		SqlSession sqlSession = sqlSessionFactory.openSession();
		// 4、SqlSession执行statement，并返回映射结果
		
		//构建user参数，没有赋值的属性采取默认值
		User user = new User();
		user.setUsername("东哥1");
		user.setAddress("清河宝盛西里");
		
		// 第一个参数：statement的id，建议：namespace.statementId（确保唯一）
		// 第二个参数：入参的值，它的类型要和映射文件中对应的statement的入参类型一致
		sqlSession.insert("insertUser", user);

		//切记：增删改操作时，要执行commit操作
		sqlSession.commit();

		// 5、关闭SqlSession
		sqlSession.close();
	}

4.5.3.3.4 主键返回之MySQL自增主键

思路：

1、MySQL自增主键，是指在insert之前MySQL会自动生成一个自增的主键。

2、我们可以通过MySQL的函数获取到刚插入的自增主键:

LAST_INSERT_ID()

3、 这个函数是在insert语句之后去调用。

修改映射文件：


  1. <!-- 添加用户之自增主键返回（selectKey方式） -->  
  2. <!--   
  3.         [selectKey标签]：通过select查询来生成主键  
  4.         [keyProperty]：指定存放生成主键的属性  
  5.         [resultType]：生成主键所对应的Java类型  
  6.         [order]：指定该查询主键SQL语句的执行顺序，相对于insert语句  
  7.         [last_insert_id]：MySQL的函数，要配合insert语句一起使用  
  8. -->  
  9. <insert id="insertUser" parameterType="<span style='font-family: "宋体"; font-size: 14px;'><strong>net.gbicc.dao.User</strong></span><span style="font-family: Arial, Helvetica, sans-serif; font-size: 12px; font-weight: bold;">"></span>  
  10.     <selectKey keyProperty="id" resultType="int" order="AFTER">  
  11.         SELECT LAST_INSERT_ID()  
  12.     </selectKey>  
  13.     INSERT INTO USER(username,sex,birthday,address) VALUES (#{username},#{sex},#{birthday},#{address})  
  14. </insert>  
<!-- 添加用户之自增主键返回（selectKey方式） -->
<!-- 
		[selectKey标签]：通过select查询来生成主键
		[keyProperty]：指定存放生成主键的属性
		[resultType]：生成主键所对应的Java类型
		[order]：指定该查询主键SQL语句的执行顺序，相对于insert语句
		[last_insert_id]：MySQL的函数，要配合insert语句一起使用
-->
<insert id="insertUser" parameterType="net.gbicc.dao.User">
	<selectKey keyProperty="id" resultType="int" order="AFTER">
		SELECT LAST_INSERT_ID()
	</selectKey>
	INSERT INTO USER(username,sex,birthday,address) VALUES (#{username},#{sex},#{birthday},#{address})
</insert>
4.5.3.3.5主键返回之MySQL函数UUID（自己练习）

注意：使用mysql的uuid()函数生成主键，需要修改表中id字段类型为string，长度设置成35位。


  1. <!-- 添加用户之UUID主键返回 -->  
  2. <!--   
  3.     [uuid]：MySQL的函数，生成的主键是35位的字符串，所以使用它时要修改id的类型为字符类型  
  4.     注意：  
  5.         1、此时order采用BEFORE，因为需要先生成出主键，再执行insert语句  
  6.         2、显式的给ID赋值  
  7. -->  
  8. <insert id="insertUser" parameterType="<span style='font-family: "宋体"; font-size: 14px;'><strong>net.gbicc.dao.User</strong></span><span style="font-family: Arial, Helvetica, sans-serif; font-size: 12px;">"></span>  
  9.     <selectKey keyProperty="id" resultType="string" order="BEFORE">  
  10.         SELECT UUID()  
  11.     </selectKey>  
  12.     INSERT INTO USER(id,username,sex,birthday,address) VALUES (#{id},#{username},#{sex},#{birthday},#{address})  
  13. </insert>  
<!-- 添加用户之UUID主键返回 -->
<!-- 
	[uuid]：MySQL的函数，生成的主键是35位的字符串，所以使用它时要修改id的类型为字符类型
	注意：
		1、此时order采用BEFORE，因为需要先生成出主键，再执行insert语句
		2、显式的给ID赋值
-->
<insert id="insertUser" parameterType="net.gbicc.dao.User">
	<selectKey keyProperty="id" resultType="string" order="BEFORE">
		SELECT UUID()
	</selectKey>
	INSERT INTO USER(id,username,sex,birthday,address) VALUES (#{id},#{username},#{sex},#{birthday},#{address})
</insert>
4.5.3.3.6 主键返回之Oracle序列返回（自己练习）

  1. <!-- 添加用户之sequence返回 -->  
  2. <!--   
  3.     通过Oracle的sequence获取主键方式与MySQL的uuid方式基本一致      
  4. -->  
  5. <insert id="insertUser" parameterType=<span style="font-family: Arial, Helvetica, sans-serif; font-size: 13.33px;">"</span><span style='font-family: "宋体"; font-size: 14px;'><strong>net.gbicc.dao.User</strong></span><span style="font-family: Arial, Helvetica, sans-serif; font-size: 12px;">"></span>  
  6.     <selectKey keyProperty="id" resultType="int" order="BEFORE">  
  7.         SELECT user_seq.nextval() FROM dual  
  8.     </selectKey>  
  9.     INSERT INTO USER(id,username,sex,birthday,address) VALUES (#{id},#{username},#{sex},#{birthday},#{address})  
  10. </insert>  
<!-- 添加用户之sequence返回 -->
<!-- 
	通过Oracle的sequence获取主键方式与MySQL的uuid方式基本一致	
-->
<insert id="insertUser" parameterType="net.gbicc.dao.User">
	<selectKey keyProperty="id" resultType="int" order="BEFORE">
		SELECT user_seq.nextval() FROM dual
	</selectKey>
	INSERT INTO USER(id,username,sex,birthday,address) VALUES (#{id},#{username},#{sex},#{birthday},#{address})
</insert>

4.5.3.4 删除用户
4.5.3.4.1 编写映射文件

  1. <!-- 根据ID删除用户 -->  
  2. <delete id="deleteUser" parameterType="int">  
  3.     DELETE FROM USER WHERE id= #{id}  
  4. </delete>  
<!-- 根据ID删除用户 -->
<delete id="deleteUser" parameterType="int">
	DELETE FROM USER WHERE id= #{id}
</delete>
4.5.3.4.2 加载映射文件

已配置，此处无需再次配置。

4.5.3.4.3 编写测试程序

  1. @Test  
  2. public void deleteUserTest() throws Exception{  
  3.     // 1、读取配置文件  
  4.     String resource = "SqlMapConfig.xml";  
  5.     InputStream inputStream = Resources.getResourceAsStream(resource);  
  6.     // 2、根据配置文件创建SqlSessionFactory  
  7.     SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder()  
  8.                 .build(inputStream);  
  9.     // 3、SqlSessionFactory创建SqlSession  
  10.     SqlSession sqlSession = sqlSessionFactory.openSession();  
  11.     // 4、SqlSession执行statement，并返回映射结果  
  12.     // 第一个参数：statement的id，建议：namespace.statementId（确保唯一）  
  13.     // 第二个参数：入参的值，它的类型要和映射文件中对应的statement的入参类型一致  
  14.     sqlSession.delete("test.deleteUser", 30);  
  15.           
  16.     //切记：增删改操作时，要执行commit操作  
  17.     sqlSession.commit();  
  18.   
  19.     // 5、关闭SqlSession  
  20.     sqlSession.close();  
  21. }  
@Test
public void deleteUserTest() throws Exception{
	// 1、读取配置文件
	String resource = "SqlMapConfig.xml";
	InputStream inputStream = Resources.getResourceAsStream(resource);
	// 2、根据配置文件创建SqlSessionFactory
	SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder()
				.build(inputStream);
	// 3、SqlSessionFactory创建SqlSession
	SqlSession sqlSession = sqlSessionFactory.openSession();
	// 4、SqlSession执行statement，并返回映射结果
	// 第一个参数：statement的id，建议：namespace.statementId（确保唯一）
	// 第二个参数：入参的值，它的类型要和映射文件中对应的statement的入参类型一致
	sqlSession.delete("test.deleteUser", 30);
		
	//切记：增删改操作时，要执行commit操作
	sqlSession.commit();

	// 5、关闭SqlSession
	sqlSession.close();
}
4.5.3.5 修改用户
4.5.3.5.1 编写映射文件

  1. <!-- 根据传入的用户信息修改用户 -->  
  2. <update id="updateUser" parameterType=<span style="font-family: Arial, Helvetica, sans-serif; font-size: 13.33px;">"</span><span style='font-family: "宋体"; font-size: 14px;'><strong>net.gbicc.dao.User</strong></span><span style="font-family: Arial, Helvetica, sans-serif; font-size: 12px;">"></span>  
  3.     UPDATE USER SET username = #{username},sex=#{sex} WHERE id=#{id}  
  4. </update>  
<!-- 根据传入的用户信息修改用户 -->
<update id="updateUser" parameterType="net.gbicc.dao.User">
	UPDATE USER SET username = #{username},sex=#{sex} WHERE id=#{id}
</update>
4.5.3.5.2 加载映射文件

已配置，此处无需再次配置。

4.5.3.5.3 编写测试程序

  1. @Test  
  2. public void updateUserTest() throws Exception{  
  3.     // 1、读取配置文件  
  4.     String resource = "SqlMapConfig.xml";  
  5.     InputStream inputStream = Resources.getResourceAsStream(resource);  
  6.     // 2、根据配置文件创建SqlSessionFactory  
  7.     SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);  
  8.     // 3、SqlSessionFactory创建SqlSession  
  9.     SqlSession sqlSession = sqlSessionFactory.openSession();  
  10.     // 4、SqlSession执行statement，并返回映射结果  
  11.           
  12.     //构建user参数，没有赋值的属性采取默认值  
  13.     User user = new User();  
  14.     user.setId(28);  
  15.     user.setUsername("超哥11");  
  16.     user.setAddress("清河宝盛西里");  
  17.           
  18.     // 第一个参数：statement的id，建议：namespace.statementId（确保唯一）  
  19.     // 第二个参数：入参的值，它的类型要和映射文件中对应的statement的入参类型一致  
  20.     sqlSession.update("test.updateUser", user);  
  21.           
  22.     //切记：增删改操作时，要执行commit操作  
  23.     sqlSession.commit();  
  24.   
  25.     // 5、关闭SqlSession  
  26.     sqlSession.close();  
  27. }  
@Test
public void updateUserTest() throws Exception{
	// 1、读取配置文件
	String resource = "SqlMapConfig.xml";
	InputStream inputStream = Resources.getResourceAsStream(resource);
	// 2、根据配置文件创建SqlSessionFactory
	SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
	// 3、SqlSessionFactory创建SqlSession
	SqlSession sqlSession = sqlSessionFactory.openSession();
	// 4、SqlSession执行statement，并返回映射结果
		
	//构建user参数，没有赋值的属性采取默认值
	User user = new User();
	user.setId(28);
	user.setUsername("超哥11");
	user.setAddress("清河宝盛西里");
		
	// 第一个参数：statement的id，建议：namespace.statementId（确保唯一）
	// 第二个参数：入参的值，它的类型要和映射文件中对应的statement的入参类型一致
	sqlSession.update("test.updateUser", user);
		
	//切记：增删改操作时，要执行commit操作
	sqlSession.commit();

	// 5、关闭SqlSession
	sqlSession.close();
}

4.6小结

4.6.1 parameterType和resultType


parameterType指定输入参数的java类型，可以填写别名或Java类的全限定名。

resultType指定输出结果的java类型，可以填写别名或Java类的全限定名。

4.6.2 #{}和${}

#{}：相当于预处理中的占位符？。

#{}里面的参数表示接收java输入参数的名称。

#{}可以接受HashMap、简单类型、POJO类型的参数。

    当接受简单类型的参数时，#{}里面可以是value，也可以是其他。

#{}可以防止SQL注入。

${}：相当于拼接SQL串，对传入的值不做任何解释的原样输出。

${}会引起SQL注入，所以要谨慎使用。

${}可以接受HashMap、简单类型、POJO类型的参数。

    当接受简单类型的参数时，${}里面只能是value。


4.6.3  selectOne和selectList

selectOne：只能查询0或1条记录，大于1条记录的话，会报错：


kinsyo
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Mybatis总结
qq_43783527的博客
11-10 1598
mybatis框架： 官方文档 ​ SqlMapConfig.xml（名称任意），此文件作为mybatis的全局配置文件，是核心配置文件，配置了mybatis的运行环境等信息。mapper.xml文件即sql映射文件，文件中配置了操作数据库的sql语句；并且 这些文件需要在SqlMapConfig.xml中加载。 [在各自的配置文件里面配置各自的相关功能---解耦。]() ​ 开发mybatis的时候，我们没有service层、controller层，所以使用junit测
MyBatis基础知识总结
最新发布
zhaolk的博客
06-03 455
本文对于Mybatis的来源及优势做了阐述，重点对于Mybatis的实例做了大量的演示操作
MyBatis入门
Princess_Y
11-25 668
文章目录第1章 MyBatis简介1.1 MyBatis历史1.2 MyBatis简介1.3 如何下载MyBatis1.4 为什么要使用MyBatis – 现有持久化技术的对比第2章 HelloWorld2.1 开发环境的准备2.2 创建数据库和表2.3 创建Employee类2.4 创建EmployeeMapper(Dao)接口2.5 创建Mybatis的sql映射文件2.6 创建MyBatis的全局配置文件2.7 测试第3章 MyBatis全局配置文件3.1 MyBatis全局配置文件简介3.2 pro
MyBatis 重要知识点总结
sekever的博客
03-26 396
MyBatis生命周期过程分析SqlSessionFactoryBuilderSqlSessionFactorySqlSessionMapper#{}与${}的不同dao接口工作原理分页处理插件延迟加载执行器 生命周期过程分析 SqlSessionFactoryBuilder 一旦创建了工厂就没用了，推荐成为局部变量 源码分析： 一般先使用两个build方法，不同点只是处理的是字节流还是字符流 最后都会调用build的重载方法，返回一个DefaultSqlSessionFactory（实现工厂接口的类），这
Mybatis详细总结
weixin_53418791的博客
05-27 617
Mybatis 1.1常用框架 MVC框架：其实就是简化了Serviet的开发步骤 流行框架：1.Struts2 2.SpringMVC 持久层框架：完成数据库操作的框架 1.appache DBUtils 2.Hibernate 3.Spring JPA 4.MyBatis 胶水框架：Spring SSM Spring+SpringMVC+Mybatis 1.2Mybatis介绍 mybatis是一个半自动的ORM框架 ORM (Object Relational Mappin
mybatis总结.md
11-30
mybatis总结，可学习
微信好友检测工具微友猎手2.20 (win7新测可用)
04-01
微信猎手一款全球首家微信好友管理辅助软件，她最快只需3秒钟，就能找出已经把你删除的好友。从此我们无需诚惶诚恐群发消息，就能无声无息把他们筛选和标记出来。同时，她还支持备份、导出自己的好友微信号，防止帐号丢失，与朋友失联。
Lenovo ThinkPad T520 W520 Maintenance Manual 拆机教学手册
11-02
Lenovo ThinkPad T520 W520 Maintenance Manual 拆机教学手册 原版
ITV 蓝牙驱动2.608破解版
03-14
好用的蓝牙驱动ITV 蓝牙驱动2.608破解版
MyBatis学习笔记(一):MyBatis configuration和mapper xml配置总结
11-07
mybatis configruation 和 mapper xml 已思维导图方式总结
尚硅谷_Vue核心技术
06-16
尚硅谷HTML5前端视频_Vue核心技术视频 尚硅谷HTML5前端视频_Vue核心技术视频
MyBatis的学习总结
GD的博客
10-28 1632
1、前言 mybatis是一款优秀的持久层框架, 它支持定制化SQL、存储过程、高级映射、逆向工程… mybatis可以使用简单XML或注解用于配置和原始映射,将接口和java的pojo映射成数据库中的记录 为什么要使用MaBatis？ mybatis是一款半自动化的持久层框架 在JDBC中,我们在Java代码中夹杂着大量SQL语句,耦合度高,在我们实际维护的过程中总是需求的sql是有变化的,频繁修改的情况多见 而mybatis框架帮助我们在代码中实现java与sql的分离,一个专注业务,一个专注数据
Mybatis核心技术总结
qq_57186420的博客
08-01 1498
Mybaitsi基本含义 MyBatis 是一款优秀的持久层框架; 它支持自定义 SQL、存储过程以及高级映射。MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。 Mybatis的特性 数据持久化 持久化就是将程序的数据在持久状态和瞬时状态转化的过程 内.
【MyBatis教程】mybatis框架超全面详解总结
d586947的博客
01-18 9076
目录 一、什么是MyBatis 二、Mybatis相对JDBC有哪些优势 三、Mybatis框架的原理介绍 四、Mybatis全局配置文件 1.全局配置文件的类容和顺序 五、映射文件 1.输入映射parameterType 2.resultType结果映射 3.resultMap结果映射 六、Mybatis之传统Dao层的开发(该方式很少用) 1.开发环境准备： 2.需求分析： 3.代码实现 七、Mybatis之Mapper接口的开发方式 1.需求分析 2.Mapper开发代
spring整合mybatis原理和总结
05-27
Spring整合MyBatis的原理可以总结为以下几步： 1. 配置数据源：在Spring配置文件中配置数据源，可以使用Spring自带的数据源或第三方数据源。 2. 配置SqlSessionFactory：SqlSessionFactory是MyBatis的核心配置对象...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值