Mybatis简介(快速入门&curd案例)
Mybatis1-课堂笔记
准备Mybatis环境->单表CURD->动态SQL语句拼接->多表查询；
注解配置
一、Mybatis概述
1. 框架简介
1.1 什么是框架
框架：是整个或部分应用的可重用设计，是可定制化的应用骨架。它可以帮开发人员简化开发过程，提高开发效率。
简而言之，框架是一个应用系统的半成品，开发人员在框架的基础上，根据业务需求开发功能。即：别人搭台，你唱戏。
- 框架：让开发人员的代码更简单，功能更强
1.2 框架解决了什么问题
框架主要是解决了技术整合问题
一个应用系统，必定要选用大量的技术来完成业务需求，实现功能。这就导致应用系统依赖于具体的技术，一旦技术发生了变化或者出现问题，会对应用系统造成直接的冲击，这是应该避免的。
框架的出现，解决了这个问题：框架是技术的整合。如果使用了框架，在框架基础上进行开发，那么开发人员就可以直接调用框架的API来实现功能，而不需要关注框架的底层具体使用了哪些技术。这就相当于框架“屏蔽”了具体的技术，实现了应用系统功能和技术的解耦。
框架一般处于低层应用平台（如JavaEE）和高层业务逻辑之间
1.3 有哪些常见的框架
每个框架都是要解决一些具体的问题的，我们可以从JavaEE的三层架构，来说一下常见的框架有哪些。
-
Mybatis：作用在dao层，负责数据库访问的框架。
它原本是Apache的一个开源项目ibatis，后来迁移到了Google code，并改名为Mybatis；之后又迁移到了github上。
它是一个优秀的Java轻量级dao层框架，对JDBC进行了封装，使开发人员只需要关注SQL语句，而不需要关注JDBC的API执行细节。
SQL：面向关系的
-
Hibernate：作用在dao层，负责数据库访问的框架。
Hibernate是一个完全面向对象的Dao层框架，封装程度非常高，开发人员可以完全以面向对象的方式操作数据库，甚至不需要编写SQL语句。
但是，正因为Hibernate的封装程度过高，导致它的执行效率受到了影响，是重量级框架。目前在国内使用的越来越少了。
-
SpringMVC：作用在web层，负责和客户端交互的框架。
SpringMVC是Spring Framework的后续产品，受益于Spring框架的流行，并且因为SpringMVC使用简单、和Spring整合简单，导致SpringMVC框架在国内使用的也越来越多。
-
Struts1/Struts2：作用在web层，负责和客户端交互的框架。
Struts1是比较老的框架，目前已经基本不使用了。
Struts2目前使用的也越来越少，逐步被SpringMVC代替
-
Spring：不是作用在某一层，而是实现web层、Service层、Dao层之间解耦的框架，是三层之间的粘合剂
Spring框架是为了解决应用开发的复杂性而创建的，任何Java应用都可以从Spring中受益。Spring是一个轻量级控制反转（IoC)和面向切面（AOP）的容器框架。
小结：
-
什么是框架：是应用系统的半成品，可以开发人员的代码更简单，但是功能更强
-
框架解决了干什么问题：解决了技术整合的问题
-
有哪些常用框架：
- SSH：Struts1/Struts2 + Spring + Hibernate
- SSM：SpringMVC + Spring + Mybatis。我们学习的这一套
2. Mybatis简介
2.1 JDBC的问题
- 硬编码问题
- 数据库连接信息的硬编码
- SQL语句和参数硬编码
- 结果集封装硬编码
- 大量的重复代码
- 性能问题
//注册驱动
//获取连接
//创建statement/预编译对象
//执行SQL语句
//处理结果
//释放资源- DBUtils + 连接池：解决了jdbc的一些问题
- SQL语句是写死的，封装的结果也是代码里写死的：硬编码问题
- 功能不够强
2.2 Mybatis介绍
Mybatis是一个优秀的Java轻量级持久层框架。
- 它内部封装了JDBC，使开发人员只需要关心SQL语句，而不需要处理繁琐的JDBC步骤
- 它采用了ORM思想，解决了实体和数据库映射的问题。只要提供好sql语句，配置了映射，Mybatis会自动根据参数值动态生成SQL，执行SQL并把结果封装返回给我们。
- 它支持XML和注解两种方式配置映射。
2.3 ORM思想
ORM：Object Relational Mapping，对象关系映射思想。指把Java对象和数据库的表和字段进行关联映射，从而达到操作Java对象，就相当于操作了数据库。查询了数据库，自动封装成JavaBean对象
小结：
- Mybatis：解决了jdbc和dbutils的问题，功能更强
- Mybatis：采用了ORM思想。我们配置了JavaBean对象和表字段的映射关系。我们执行SQL，Mybatis会帮我们把结果封装成JavaBean
- Mybatis的配置：xml方式和注解方式
3. Mybatis下载
- Mybatis官网：http://www.mybatis.org/mybatis-3/zh/index.html
- Mybatis下载地址：https://github.com/mybatis/mybatis-3/releases/download/mybatis-3.4.6/mybatis-3.4.6.zip
- Mybatis源码下载：https://github.com/mybatis/mybatis-3/archive/mybatis-3.4.6.zip
二、Mybatis快速入门
1. 需求描述
查询所有用户信息，获取用户集合List
2. 准备工作
2.1 统一开发环境
- 初始化数据库：执行数据库脚本《资料/mybatisdb.sql》
- 准备开发环境：jdk1.8， Maven和本地仓库，idea
2.2 实现步骤
- 创建Maven项目，准备JavaBean
- 编写Mybatis的代码，查询所有用户
- 编写测试代码
3. 入门案例
3.1 创建Maven项目，准备JavaBean
1) 创建Maven的java项目
因为只涉及Dao层，不涉及客户端，所以只要创建Java项目即可。项目坐标信息如下：
groupId: com.itheima
artifactId: mybatis01_quickstart
version: 1.0-SNAPSHOT
packing: jar2) 在pom.xml中添加依赖
<dependencies>
<dependency>
<groupId>junitgroupId>
<artifactId>junitartifactId>
<version>4.12version>
<scope>testscope>
dependency>
<dependency>
<groupId>mysqlgroupId>
<artifactId>mysql-connector-javaartifactId>
<version>5.1.46version>
dependency>
<dependency>
<groupId>org.mybatisgroupId>
<artifactId>mybatisartifactId>
<version>3.4.6version>
dependency>
<dependency>
<groupId>log4jgroupId>
<artifactId>log4jartifactId>
<version>1.2.17version>
dependency>
<dependency>
<groupId>org.projectlombokgroupId>
<artifactId>lombokartifactId>
<version>1.18.10version>
<scope>providedscope>
dependency>
dependencies>3) 创建JavaBean
public class User {
private Integer id;
private String username;
private Date birthday;
private String sex;
private String address;
//get/set...
//toString...
}3.2 编写Mybatis的代码，查询所有用户
1) 创建dao接口（映射器）
在Mybatis里，把dao层的接口称之为映射器（取 调用接口的方法即相当于操作数据库 之意）。
映射器的类名，可以叫XXXMapper，也可以叫XXXDao。我们这里按照之前的习惯，取名UserDao
注意：只要创建接口即可，不需要创建接口的实现类
public interface UserDao {
List<User> queryAll();
}2) 准备映射配置文件xml
注意：
-
映射配置文件名称要和映射器类名一样。例如：映射器叫UserDao，那么配置文件就叫UserDao.xml
-
映射配置文件位置要和映射器位置一样。例如：映射器在com.itheima.dao里，那么配置文件就应该在resources的com/itheima/dao目录下
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EJlAxMdY-1585403917876)(img/image-20200227110903440.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-S3LgInC4-1585403917876)(img/image-20200227110940352.png)]
<mapper namespace="com.itheima.dao.UserDao">
<select id="queryAll" resultType="com.itheima.domain.User">
select * from user
select>
mapper>3) 准备Mybatis的日志配置文件
Mybatis支持使用log4j输出执行日志信息，但是需要我们提供log4j的配置文件：log4j.properties
注意：
- 如果没有log4j.properties，不影响Mybatis的功能，只是没有详细日志而已
- 如果需要日志的话，要把log4j.properties文件放到resources目录下。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
# 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
4) 准备Mybatis的核心配置文件xml
注意：
- 核心配置文件的名称随意，我们习惯叫 SqlMapConfig.xml
- 核心配置文件的位置随意，我们习惯放到resources的根目录下
<configuration>
<environments default="mysql_mybatis">
<environment id="mysql_mybatis">
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<property name="driver" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql:///mybatis"/>
<property name="username" value="root"/>
<property name="password" value="root"/>
dataSource>
environment>
environments>
<mappers>
<mapper resource="com/itheima/dao/UserDao.xml"/>
mappers>
configuration>3.3 编写测试代码
@Test
public void testQuickStart() throws IOException {
//1. 读取核心配置文件SqlMapConfig.xml
InputStream is = Resources.getResourceAsStream("SqlMapConfig.xml");
//2. 创建SqlSessionFactoryBuilder构造者对象
SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
//3. 使用构造者builder，根据配置文件的信息is，构造一个SqlSessionFactory工厂对象
SqlSessionFactory factory = builder.build(is);
//4. 使用工厂对象factory，生产一个SqlSession对象
SqlSession session = factory.openSession();
//5. 使用SqlSession对象，获取映射器UserDao接口的代理对象
UserDao dao = session.getMapper(UserDao.class);
//6. 调用UserDao代理对象的方法，查询所有用户
List<User> users = dao.queryAll();
for (User user : users) {
System.out.println(user);
}
//7. 释放资源
session.close();
is.close();
}小结
-
准备工作
- 创建Maven的java项目
- 导入依赖坐标：数据库驱动包，mybatis的包，日志log4j包，单元测试junit，lombok
- 创建JavaBean
-
编写代码，使用Mybatis实现功能
- 创建映射器：dao层的一个接口
- 创建映射文件xml，在映射文件里写statement配置
- xml文件位置，和映射器位置相同
- xml文件名称，和映射器名称相同
- 创建核心配置文件，配置数据库环境和映射文件的路径
- 文件位置：放在resources目录里
- 文件名称：sqlMapConfig.xml
- 创建log4j日志文件：
log4j.properties
-
功能测试
//1. 加载配置文件 InputStream is = Resources.getResourceAsStream("sqlMapConfig.xml"); //2. 获取映射器的代理对象：构造者构造一个工厂，工厂生产一个SqlSession，SqlSession创建代理对象 SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder(); SqlSessionFactory factory = builder.build(is); SqlSession session = factory.openSession(); UserDao dao = session.getMapper(UserDao.class); List<User> userList = dao.queryAll(); //3. 释放资源 session.close(); is.close();
- 实际使用mybatis开发，我们通常只要：
- 在映射器里增加方法
- 在映射文件里增加statement配置：即给方法配置SQL语句等
- 使用映射器代理对象，直接调用方法，操作数据库得到结果
- 其它工作：由Spring、及其它配套的jar包帮我们实现了
4. Mybatis的运行过程分析
三、Mybatis实现CURD
1. 需求说明
针对user表进行CURD操作：
- 查询全部用户，得到
List（上节课快速入门已写过，略） - 保存用户（新增用户）
- 修改用户
- 删除用户
- 根据主键查询一个用户，得到
User - 模糊查询
- 查询数量
2. 准备Mybatis环境
2.1 创建Maven项目，准备JavaBean
1) 创建Maven的Java项目，坐标为：
<groupId>com.itheimagroupId>
<artifactId>day47_mybatis01_curdartifactId>
<version>1.0-SNAPSHOTversion>
<packaging>jarpackaging>2) 在pom.xml中添加依赖：
<dependency>
<groupId>junitgroupId>
<artifactId>junitartifactId>
<version>4.12version>
dependency>
<dependency>
<groupId>mysqlgroupId>
<artifactId>mysql-connector-javaartifactId>
<version>5.1.46version>
dependency>
<dependency>
<groupId>log4jgroupId>
<artifactId>log4jartifactId>
<version>1.2.17version>
dependency>
<dependency>
<groupId>org.mybatisgroupId>
<artifactId>mybatisartifactId>
<version>3.4.6version>
dependency>3) 创建JavaBean
public class User {
private Integer id;
private String username;
private Date birthday;
private String sex;
private String address;
//get/set...
//toString...
}2.2 准备Mybatis的映射器和配置文件
1) 创建映射器接口UserDao（暂时不需要增加方法，备用）
public interface UserDao {
}2) 创建映射配置文件UserDao.xml（暂时不需要配置statement，备用）
<mapper namespace="com.itheima.dao.UserDao">
mapper>3) 创建Mybatis的核心配置文件
<configuration>
<environments default="mysql_mybatis">
<environment id="mysql_mybatis">
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<property name="driver" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql:///mybatis"/>
<property name="username" value="root"/>
<property name="password" value="root"/>
dataSource>
environment>
environments>
<mappers>
<mapper resource="com/itheima/dao/UserDao.xml"/>
mappers>
configuration>4) 准备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
2.3 准备单元测试类
在单元测试类中准备好@Before、@After的方法代码备用。编写完成一个功能，就增加一个@Test方法即可。
代码如下：
public class MybatisCURDTest {
private InputStream is;
private SqlSession session;
private UserDao dao;
@Before
public void init() throws IOException {
is = Resources.getResourceAsStream("SqlMapConfig.xml");
SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
SqlSessionFactory factory = builder.build(is);
session = factory.openSession();
dao = session.getMapper(UserDao.class);
}
@After
public void destory() throws IOException {
//释放资源
session.close();
is.close();
}
}3. 编写代码实现需求
3.1 保存/新增用户
1) 在映射器UserDao中增加方法
void save(User user);2) 在映射配置文件UserDao.xml中添加statement
<insert id="save" parameterType="com.itheima.domain.User">
<selectKey resultType="int" keyProperty="id" order="AFTER">
select last_insert_id()
selectKey>
insert into user (id, username, birthday, address, sex)
values (#{id}, #{username}, #{birthday},#{address},#{sex})
insert>注意：
SQL语句中#{}代表占位符，相当于预编译对象的SQL中的?，具体的值由User类中的属性确定
3) 在单元测试类中编写测试代码
@Test
public void testSaveUser(){
User user = new User();
user.setUsername("tom");
user.setAddress("广东深圳");
user.setBirthday(new Date());
user.setSex("男");
System.out.println("保存之前：" + user);//保存之前，User的id为空
dao.save(user);
session.commit();//注意：必须要手动提交事务
System.out.println("保存之后：" + user);//保存之后，User的id有值
}注意：执行了DML语句之后，一定要提交事务：session.commit();
插入功能步骤小结
-
在映射器里增加方法
-
在映射配置文件里增加statement
<insert id="方法名" parameterType="参数类型，全限定类名"> <selectKey resultType="int" keyProperty="属性名" order="AFTER"> select last_insert_id() selectKey> insert语句 insert> -
功能测试
- 执行DML语句之后，一定要提交事务
session.commit()
- 执行DML语句之后，一定要提交事务
3.2 修改用户
1) 在映射器UserDao中增加方法
void edit(User user);2) 在映射配置文件UserDao.xml中添加statement
<update id="edit" parameterType="com.itheima.domain.User">
update user set username = #{username}, birthday = #{birthday},
address = #{address}, sex = #{sex} where id = #{id}
update>3) 在单元测试类中编写测试代码
@Test
public void testEditUser(){
User user = new User();
user.setId(50);
user.setUsername("jerry");
user.setAddress("广东深圳宝安");
user.setSex("女");
user.setBirthday(new Date());
dao.edit(user);
session.commit();
}注意：执行了DML语句之后，一定要提交事务：session.commit();
修改功能的小结
-
在映射器里增加方法
-
在映射配置文件里增加statement
<update id="方法名称" parameterType="参数类型，全限定类名"> update语句 update> -
功能测试
- 执行DML语句，一定要提交事务
session.commit()
- 执行DML语句，一定要提交事务
3.3. 删除用户
1) 在映射器UserDao中增加方法
void delete(Integer id);2) 在映射配置文件UserDao.xml中增加statement
<delete id="delete" parameterType="int">
delete from user where id = #{id}
delete>注意：
如果只有一个参数，且参数是简单类型的，那么#{id}中的id可以随意写成其它内容，例如：#{abc}
简单类型参数：
int, double, short, boolean, … 或者：java.lang.Integer, java.lang.Double, …
string 或者 java.lang.String
3) 在单元测试类中编写测试代码
@Test
public void testDeleteUser(){
dao.delete(50);
session.commit();
}注意：执行了DML语句之后，一定要提交事务：session.commit();
删除功能的小结
-
在映射器里增加方法
-
在映射配置文件里增加statement
<delete id="方法名称" parameterType="参数类型，写全限定类名"> delete from user where id = #{随意写} delete>注意：如果SQL语句只有一个参数，并且是简单类型，在
#{}里边可以写任意值 -
功能测试
- 注意：执行DML语句之后，要提交事务
session.commit()
- 注意：执行DML语句之后，要提交事务
3.4 根据主键查询一个用户
1) 在映射器UserDao中增加方法
User findById(Integer id);2) 在映射配置文件UserDao.xml中增加statement
<select id="findById" parameterType="int" resultType="com.itheima.domain.User">
select * from user where id = #{id}
select>3) 在单元测试类中编写测试代码
@Test
public void testFindUserById(){
User user = dao.findById(48);
System.out.println(user);
}3.5 模糊查询
3.5.1 使用#{}方式进行模糊查询
1) 在映射器UserDao中增加方法
/**
* 使用#{}方式进行模糊查询
*/
List<User> findByUsername1(String username);2) 在映射配置文件UserDao.xml中增加statement
<select id="findByUsername1" parameterType="string" resultType="com.itheima.domain.User">
select * from user where username like #{username}
select>注意：只有一个参数，且是简单参数时， #{username}中的username可以写成其它任意名称
3) 在单元测试类中编写测试代码
/**
* 使用#{}方式进行模糊查询--单元测试方法
*/
@Test
public void testFindUserByUsername1(){
List<User> users = dao.findByUsername1("%王%");
for (User user : users) {
System.out.println(user);
}
}注意：模糊查询的条件值，前后需要有%
3.5.2 使用${value}方式进行模糊查询
1) 在映射器UserDao中增加方法
/**
* 使用${value}方式进行模糊查询
*/
List<User> findByUsername2(String username);2) 在映射配置文件UserDao.xml中增加statement
<select id="findByUsername2" parameterType="string" resultType="com.itheima.domain.User">
select * from user where username like '%${value}%'
select>注意：
${value}是固定写法，不能做任何更改
在SQL语句中已经加了%，那么在测试代码中，传递参数值时就不需要再加%了
3) 在单元测试类中编写测试代码
/**
* 使用${value}方式进行模糊查询--单元测试方法
*/
@Test
public void testFindUserByUsername2(){
List<User> users = dao.findByUsername2("王");
for (User user : users) {
System.out.println(user);
}
}注意：SQL语句中已经加了%， 参数值前后不需要再加%
3.5.3 #{}和${value}的区别（面试题）
-
#{}：表示一个占位符，相当于预编译对象的SQL中的?- 可以有效防止SQL注入；
- Mybatis会自动进行参数的Java类型和JDBC类型转换；
#{}写的是属性名称。如果只有一个参数并且是简单类型，里边可以是value或者其它名称
映射配置文件中的SQL：select * from user where username like #{username} 单元测试中传递实参：%王% 最终执行的SQL：select * from user where username like ? 参数值：%王% -
${}：表示拼接SQL串，相当于把实际参数值，直接替换掉${}-
不能防止SQL注入
-
Mybatis不进行参数的Java类型和JDBC类型转换
-
${}写的是属性名称。如果只有一个参数并且是简单类型，${value}中只能是value，不能是其它名称(Mybatis3.4 里存在这种现象，3.5没有了)
映射配置文件中的SQL：select * from user where username like '%${value}%' 单元测试中传递实参：王 最终执行的SQL：select * from user where username like '%王%' -
3.5.4 模糊查询的小结
功能实现的步骤：
-
在映射器里增加方法
-
在映射配置文件里增加statement
- 第1种：
#{}方式
<select id="search1" parameterType="java.lang.String" resultType="com.itheima.domain.User"> select * from user where username like #{username} select>- 第2种：
${}方式
<select id="search2" parameterType="java.lang.String" resultType="com.itheima.domain.User"> select * from user where username like '%${value}%' select> - 第1种：
-
功能测试
#{}和${}的区别：
#{}本质是预编译方式，可以有效防止SQL注入；${}本质是拼接字符串方式，不能防止SQL注入#{}会自动转换Java类型和JDBC类型；${}不会自动转换Java类型和JDBC类型- 如果只有一个参数，并且是简单类型：
#{}里边可以写任意值${}里边只能写${value}。（Mybatis3.5之前的版本）
3.6 查询数量（聚合函数）
1) 在映射器UserDao中增加方法
Integer findTotalCount();2) 在映射配置文件中UserDao.xml增加statement
<select id="findTotalCount" resultType="int">
select count(*) from user
select>3) 在单元测试类中编写测试代码
@Test
public void testFindTotalCount(){
Integer totalCount = dao.findTotalCount();
System.out.println(totalCount);
}4. CURD功能实现的小结
四、Mybatis的参数和结果集
1. OGNL表达式了解
OGNL：Object Graphic Navigator Language，是一种表达式语言，用来从Java对象中获取某一属性的值。本质上使用的是JavaBean的getXxx()方法。
-
例如：user.getUsername()—> user.username
-
例如：user.getAddress().getProvince()—>user.address.province
list.size()>0,list != null
在#{}里、${}可以使用OGNL表达式，从JavaBean中获取指定属性的值
2. parameterType
2.1 简单类型
- 参数写法：
例如：int, double, short 等基本数据类型，或者string
或者：java.lang.Integer, java.lang.Double, java.lang.Short, java.lang.String
-
SQL语句里获取参数：
如果是一个简单类型参数，写法是：
#{随意}
2.2 POJO（JavaBean）
- 参数写法：
如果parameterType是POJO类型，要写全限定类名
例如：parameterType是com.itheima.domain.User
- SQL语句里获取参数：
#{JavaBean的属性名}
2.3 POJO包装类（复杂JavaBean）–QueryVO
- 参数写法：
在web应用开发中，通常有综合条件的搜索功能，例如：根据商品名称 和 所属分类 同时进行搜索。这时候通常是把搜索条件封装成JavaBean对象；JavaBean中可能还有JavaBean。
- SQL里取参数：
#{xxx.xx.xx}
2.3.1 功能需求
根据用户名搜索用户信息，查询条件放到QueryVO的user属性中。QueryVO如下：
public class QueryVO {
private User user;
//private String className;
public User getUser() {
return user;
}
public void setUser(User user) {
this.user = user;
}
}2.3.1 功能实现
1) 在映射器UserDao中增加方法
List<User> findByVO(QueryVO vo);2) 在映射配置文件中增加配置信息
<select id="findByVO" parameterType="com.itheima.domain.QueryVO" resultType="com.itheima.domain.User">
select * from user where username like #{user.username}
select>3) 在单元测试类中编写测试代码
@Test
public void testFindByVO(){
QueryVO vo = new QueryVO();
User user = new User();
user.setUsername("%王%");
vo.setUser(user);
List<User> users = dao.findByVO(vo);
for (User user1 : users) {
System.out.println(user1);
}
}3. resultType
注意：resultType是查询select标签上才有的，用来设置查询的结果集要封装成什么类型的
3.1 简单类型
例如：int, double, short 等基本数据类型，或者string
或者：java.lang.Integer, java.lang.Double, java.lang.Short, java.lang.String
3.2 POJO（JavaBean）
例如：com.itheima.domain.User
注意：JavaBean的属性名要和字段名保持一致
3.3 JavaBean中属性名和字段名不一致的情况处理
3.3.1 功能需求
有JavaBean类User2，属性名和数据库表的字段名不同。要求查询user表的所有数据，封装成User2的集合。其中User2如下：
public class User2 {
private Integer userId;
private String username;
private Date userBirthday;
private String userSex;
private String userAddress;
public Integer getUserId() {
return userId;
}
public void setUserId(Integer userId) {
this.userId = userId;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public Date getUserBirthday() {
return userBirthday;
}
public void setUserBirthday(Date userBirthday) {
this.userBirthday = userBirthday;
}
public String getUserSex() {
return userSex;
}
public void setUserSex(String userSex) {
this.userSex = userSex;
}
public String getUserAddress() {
return userAddress;
}
public void setUserAddress(String userAddress) {
this.userAddress = userAddress;
}
@Override
public String toString() {
return "User2{" +
"userId=" + userId +
", username='" + username + '\'' +
", userBirthday=" + userBirthday +
", userSex='" + userSex + '\'' +
", userAddress='" + userAddress + '\'' +
'}';
}
}3.3.2 实现方案一：SQL语句中使用别名，别名和JavaBean属性名保持一致（用的少）
1) 在映射器UserDao中增加方法
/**
* JavaBean属性名和字段名不一致的情况处理---方案一
* @return
*/
List<User2> queryAll_plan1();2) 在映射配置文件UserDao.xml中增加statement
<select id="queryAll_plan1" resultType="com.itheima.domain.User2">
select id as userId, username as username, birthday as userBirthday, address as userAddress, sex as userSex from user
select>3) 在单元测试类中编写测试代码
/**
* JavaBean属性名和字段名不一致的情况处理---方案一 单元测试代码
*/
@Test
public void testQueryAllUser2_plan1(){
List<User2> user2List = dao.queryAll_plan1();
for (User2 user2 : user2List) {
System.out.println(user2);
}
}3.3.3 实现方案二：使用resultMap配置字段名和属性名的对应关系（推荐）
1) 在映射器UserDao中增加方法
/**
* JavaBean属性名和字段名不一致的情况处理--方案二
* @return
*/
List<User2> queryAll_plan2();2) 在映射配置文件UserDao.xml中增加statement
<select id="queryAll_plan2" resultMap="user2Map">
select * from user
select>
<resultMap id="user2Map" type="com.itheima.domain.User2">
<id property="userId" column="id"/>
<result property="username" column="username"/>
<result property="userBirthday" column="birthday"/>
<result property="userAddress" column="address"/>
<result property="userSex" column="sex"/>
resultMap>3) 在单元测试类中编写测试代码
/**
* JavaBean属性名和字段名不情况处理--方案二 单元测试代码
*/
@Test
public void testQueryAllUser2_plan2(){
List<User2> user2List = dao.queryAll_plan2();
for (User2 user2 : user2List) {
System.out.println(user2);
}
}