Mybatis 框架CRUD的操作 案例

基于代理 Dao 实现 CRUD 操作

使用要求：
1、持久层接口和持久层接口的映射配置必须在相同的包下
2、持久层映射配置中 mapper 标签的 namespace 属性取值必须是持久层接口的全限定类名
3、SQL 语句的配置标签,,,的 id 属性必须和持久层接口的
方法名相同

-----------mybatis 环境搭建步骤

第一步：创建 maven 工程

第二步：导入坐标

<?xml version="1.0" encoding="UTF-8"?>

4.0.0

<groupId>com.fhw</groupId>
<artifactId>testMybatise001</artifactId>
<version>1.0-SNAPSHOT</version>

jar

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

mysql:数据库的源码：

DROP TABLE IF EXISTS user;

CREATE TABLE user (
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 user(id,username,birthday,sex,address) values (41,‘老王’,‘2018-02-27 17:47:08’,‘男’,‘北京’),(42,‘小二王’,‘2018-03-02 15:09:37’,‘女’,‘北京金燕龙’),(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’,‘女’,‘北京修正’);

DROP TABLE IF EXISTS account;

CREATE TABLE account (
ID int(11) NOT NULL COMMENT ‘编号’,
UID int(11) default NULL COMMENT ‘用户编号’,
MONEY double default NULL COMMENT ‘金额’,
PRIMARY KEY (ID),
KEY FK_Reference_8 (UID),
CONSTRAINT FK_Reference_8 FOREIGN KEY (UID) REFERENCES user (id)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

insert into account(ID,UID,MONEY) values (1,41,1000),(2,45,1000),(3,41,2000);

DROP TABLE IF EXISTS role;

CREATE TABLE role (
ID int(11) NOT NULL COMMENT ‘编号’,
ROLE_NAME varchar(30) default NULL COMMENT ‘角色名称’,
ROLE_DESC varchar(60) default NULL COMMENT ‘角色描述’,
PRIMARY KEY (ID)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

insert into role(ID,ROLE_NAME,ROLE_DESC) values (1,‘院长’,‘管理整个学院’),(2,‘总裁’,‘管理整个公司’),(3,‘校长’,‘管理整个学校’);

DROP TABLE IF EXISTS user_role;

CREATE TABLE user_role (
UID int(11) NOT NULL COMMENT ‘用户编号’,
RID int(11) NOT NULL COMMENT ‘角色编号’,
PRIMARY KEY (UID,RID),
KEY FK_Reference_10 (RID),
CONSTRAINT FK_Reference_10 FOREIGN KEY (RID) REFERENCES role (ID),
CONSTRAINT FK_Reference_9 FOREIGN KEY (UID) REFERENCES user (id)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

insert into user_role(UID,RID) values (41,1),(45,1),(41,2);

第三步：编写必要代码（实体类和持久层接口）

实体类

package com.fhw.domain;

import java.io.Serializable;
import java.util.Date;

/**

• User表的实体类 实现 序列化接口
  */
  public class User implements Serializable{
  private int id;
  private String username;
  private Date birthday;
  private String sex;
  private String address;
  get set toString 方法 的 在IDEA 里 生成 即可

---

package com.fhw.domain;

import java.io.Serializable;

public class QieryVo implements Serializable {
private User user;

public User getUser() {
    return user;
}

public void setUser(User user) {
    this.user = user;
}

}

持久层接口

package com.fhw.dao;

import com.fhw.domain.QieryVo;
import com.fhw.domain.User;
import org.junit.Test;

import java.util.List;

/**
y优化持久层接口
/
public interface IUserDao {
/
* 查询所有用户
* @return
/
List findAll();
/*
* 根据id 查询
* @param userId
* @return
/
User findById(Integer userId);
/*
* 保存用户
* @param user
/
void saveUser(User user);
/ //*
* 更新用户
* @param user
*/
void updateUser(User user);

/**
 * 根据id 删除   将 获取的 id 字符串 通过Integer
 * @param userId
 */
void daleteUser(Integer userId);

/**
 * 根据  名称like 模糊查询用户信息
 * @param Username
 * @return
 */
List<User>  findByName(String Username);

/**
 * 聚合函数的查询 ：总记录数
 * @return
 */
int  findTotal();
/**
 * @param vo
 * @return
 */
List<User> findUserByVo(QieryVo vo);

}

**

第四步：编写 SqlMapConfig.xml

**

主配置文件xml

<?xml version="1.0" encoding="UTF-8"?>

<typeAliases>
    <!--typeAlias用于配置别名。type属性指定的是实体类全限定类名。alias属性指定别名，当指定了别名就再区分大小写
  <typeAlias type="com.itheima.domain.User" alias="user"></typeAlias>-->
  <!--  <package name="com.fhw.domain"></package>--><!-- 而且还不区分 大小写 -->
</typeAliases>
<!-- 我们就在下面  使用 ${} 来 引用的 properties配置文件的   可以在其他 的类里来使用-->

第五步：编写映射配置文件

<?xml version="1.0" encoding="UTF-8"?>

select * from user;

<select id="findById" resultType="com.fhw.domain.User" parameterType="int">
   select * from user where id = #{uid};
</select><!--#{} :代表占位符，相当于原来 jdbc 部分所学的?，都是用于执行语句时替换实际的数据。

具体的数据是由#{}里面的内容决定的 由于数据类型是基本类型，所以此处可以随意写 -->

insert into user (username,birthday,sex,address)values (#{username},#{birthday},#{sex},#{address}); select last_insert_id();

<!--更新用户 parameterType 参数类型 是类-->
  <update id="updateUser" parameterType="com.fhw.domain.User">
  update user set username=#{username},birthday=#{birthday},sex=#{sex},address=#{address} where id=#{id};
</update>
<!--删除用户 parameterType 参数类型是 integer是java.lang.Integer -->
<delete id="daleteUser" parameterType="java.lang.Integer">
    delete from user where id =#{uid}; /*只有一个参数 就是 占位符 的就行 */
</delete>
<!--根据  名称like 模糊查询用户信息-->
<select id="findByName" parameterType="String" resultType="com.fhw.domain.User">
        select *from user where username like #{name} /*只有一个参数 就是 占位符 的就行 %%百分号的模糊条件 要么在 这里 要么在Test测试里 */
</select>
<!--聚合函数的 用户 总记录数  根据id 获取总记录数-->
<select id="findTotal" resultType="int">
   select count(id)from user ;
</select>
<!--根据queryVo 来查询用户 参数 类型 QieryVo ：作为查询条件封装的类    结果集 是user
   user 类 是作为 QieryVo 类 里的属性  直接调用到 -->
<select id="findUserByVo" parameterType="com.fhw.domain.QieryVo" resultType="com.fhw.domain.User">
 select * from user where username where like #{user.username};
</select>

log4j.properties文件的准备（我之前的文章里 有相关源码）

第六步：编写测试

public class MyBatiseTest {
private InputStream In;
private SqlSessionFactory factory;
private SqlSession sqlSession;
private IUserDao userDao;

/* 解决 这些 啰嗦的 代码  在这里 用init（）方法来执行初始化
 * 在定义 了这些需要的 类 的作为属性*/
@Before//用于在测试方法执行之前执行
public void init() throws Exception {
    //定义了哦获取这些类的初始化
    // 当前 读取配置文件 ， 生成字节码输入流   需要释放
    In = Resources.getResourceAsStream("SqlMapConfig01.xml");

//读取sqlSessionFactory 工厂
factory = new SqlSessionFactoryBuilder().build(In);
//获取SqlSession对象、、需要释放的对象
sqlSession = factory.openSession();
//获取dao的代理对象getMapper() 参数的接口获取的貌似匿名类 ？
userDao = sqlSession.getMapper(IUserDao.class);//是从集合的 字节码 来获该匿名类的方法
}
@After// 在测试 放之后执行

public void destory() throws Exception {

// 提交事务
sqlSession.commit();
//释放资源
sqlSession.close();
In.close();
}

/**
 * 测试 查询所有
 */
@Test
public void testFindAll() {//手动的 抛出 throws
    //执行查询所有的方法
    List<User> users = userDao.findAll();//当前接口方法 还有很多 注释为一个 方法
    for (User user : users) {
        System.out.println(user);
    }

}

/**
 * 保存
 */
@Test
public void testSave() {
    User user = new User();
    user.setUsername("fhw");
    user.setBirthday(new Date());
    user.setSex("男");
    user.setAddress("西安市长安区");
    System.out.println("保存操作之前"+user);
    // 执行的方法
    userDao.saveUser(user);
    // 提交事务   查看 库里就会 发现的：出现了 没有显式的 事务回滚 id 被用的作用
  //  sqlSession.commit();
    System.out.println("保存操作之后："+user);
}

/**
 *更新用户的操作
 */
@Test
public  void updateTest(){

    User user = new User();
    //由于还没写 根据id 来查询的所以 setId（）
    user.setId(51);
    user.setUsername("fhwUpdateUser");
    user.setBirthday(new Date());
    user.setSex("女");
    user.setAddress("西安市长安区");

    // 执行的方法
    userDao.updateUser(user);

}
/* 删除delete的 测试*/
@Test
public void deleteTest(){
userDao.daleteUser(51);
}
@Test/根据id 来查询 对象/
public void testFindOne(){
//6 执行操作
User user=userDao.findById(50);
System.out.println(user);
}

 /*模糊查询like
 根据name 字符串 来查询
 */

@Test
public void findByName(){
List wang = userDao.findByName("%王%");
for (User user : wang) {
System.out.println(user);
}
}
@Test/聚合函数 总记录数/
public void findTotalTest(){
int total = userDao.findTotal();
System.out.println(“聚合函数 总记录数：”+total);
}
/* OGNL表达式的 方式*/

public void findUserByVoTest(){
User user = new User();
QieryVo vo = new QieryVo();
user.setUsername("%王%");
vo.setUser(user);
List users = userDao.findUserByVo(vo);
for (User user1 : users) {
System.out.println(user1);
}
}
}

模糊查询的另一种配置方式

第一步：修改 SQL 语句的配置，配置如下：

select * from user where username like '%${value}%' 我们在上面将原来的#{}占位符，改成了${value}。注意如果用模糊查询的这种写法，那么${value}的写 法就是固定的，不能写成其它名字。 第二步：测试，如下： /** * 测试模糊查询操作 */ @Test public void testFindByName(){ //5.执行查询一个方法 List users = userDao.findByName("王"); for(User user : users){ System.out.println(user); } }

附： #{}与${}的区别

#{}表示一个占位符号通过#{}可以实现 preparedStatement 向占位符中设置值，自动进行 java 类型和 jdbc 类型#{}可以有效防止 sql 注入。 #{}可以接收简单类型值或 pojo 属性值。 如果 parameterType 传输单个型值，#{}括号中可以是 value 或其它名称。

${}表示拼接 sql 串通过${}可以将 parameterType 传入的内容拼接在 sql 中且不进行 jdbc 类型转换， ${}可以单类型值或 pojo 属性值，如果 parameterType 传输单个简单类型值，${}括号中只能是 value

全部呈现 到 我们主题的 代码 后

我们来逐步 推进 ==============》
还是那个User

实体类 implements Serializable 序列化 之后

一个基本的查询的 操作 （简单明了 的

回顾了基本的操作 ）

**》》》》 IUser 接口 里** 
 我们就写一个  抽象方法

List findAll();
》》》》 主配置文件
<!-- 默认

指定 的–>

 <transactionManager type="JDBC"></transactionManager>

<!-- 我们就在下面 的value 使用 ${} 来 引用的 properties配置文

件的 value值 可以在其他 的类里来使用–>
<property name=“driver”

value=“com.mysql.jdbc.Driver”><!–本机默认的端口号 就可以省略不写

jdbc:mysql:///testMybatise001–>
<property name=“url”

value=“jdbc:mysql://localhost:3306/fhw_mybatise01”>
<property

name=“username” value=“root”>
<property name=“password”

value=“root”>

映射配置文件的位置，映射配置文件指的是每个dao独立的配置文件 -->

#*# 》》》》在映射

文件IUser.xml*

  里: <select id="findAll" resultType="com.fhw.domain.User">

select * from user;

》》》》
我们 查询 期待的是 IDEA 测试 成功为-------》绿色

User{userId=null, userName=‘老王’, userAddress=‘null’, userSex=‘null’,

userBirthday=null}
User{userId=null, userName=‘小二王’, userAddress=‘null’,

userSex=‘null’, userBirthday=null}
User{userId=null, userName=‘小二王’,

userAddress=‘null’, userSex=‘null’, userBirthday=null}
User{userId=null, userName='红卫博客
',
userAddress=‘null’, userSex=‘null’, userBirthday=null}
User{userId=null,

userName=‘老王’, userAddress=‘null’, userSex=‘null’, userBirthday=null}
User

{userId=null, userName=‘小马宝莉’, userAddress=‘null’, userSex=‘null’,

userBirthday=null}
User{userId=null, userName=‘fhw’, userAddress=‘null’, userSex=‘null’,

userBirthday=null}

保存 操作 我们就有 新的问题的分析与进步 的 认识

附===》
OGNL表达式： Object对象 Graphic图 Navigation 导航Language 语言
OGNL： 把get 方法

给省略了 通过 对象的取值方法 来获取数据

》》》》》 在 IUser接口 里 增加 一个保存的 抽

象方法
void saveUser（User user）；
》》》》》 在 IUser.xml里
继续写 我们的SQL语

句 我们使用了MyBatise 的OGNL表达式
#{}占位符 的操作 （可能按照以往的操作 是几个问号 ？？？？ 的）
<insert

id=“saveUser” parameterType=“com.fhw.domain.User”>
insert into user

(username,address,sex,birthday)values(#{userName},#{userAddress},#{userSex},#

{userBirthday});

=================================》
更新的操作
在 IUser接口里继续的 编写的
void updateUesr （User user）；

在 IUser.xml映射文件里继续的 编写的

update user set username=#{userName},address=#{userAddress},sex=#

{userAex},birthday=#{userBirthday} where id=#{userId}

sql 语句中使用#{}字符：它代表占位符，相当于原来 jdbc 部分所学的问号 ?，
都是用于执行语句时替换实际的数据。具体的数据是由#{}里面的内容决定的。#{}中内容的写法：

由于数据类型是基本类型，
￥￥￥￥====================》
要明白：是表与实体类一样：就是一个 占位符
要是 实体类的与表 不一样 就映射文件里的就要严格的按照java 语法操作-----》这里的实体

类就与 表 不一样

测试： 就是 （复制一个 保存的）
@Test
public void updateTest(){

    User user = new User();
    //由于还没写 根据id 来查询的所以 setId（）
    user.setUserId(51);
    user.setUserName("fhwUpdateUser");
    user.setUserBirthday(new Date());
    user.setUserSex("女");
    user.setUserAddress("西安市长安区");

（更新 的 顺序不分 前后）
// 执行的方法
userDao.updateUser(user);
}
测试成功的日志
：fhwUpdateUser(String), 西安市长安区(String), 女(String), 2018-11-27 18:41:13.773

(Timestamp), 54(Integer)
========> 删除的 操作

在 IUser接口里继续的 编写的
void updateUesr （Integer id）；

在 IUser.xml映射文件里继续的 编写的
（注意删除的 的值 包装类 转 int）

delete from user where id = #{uid}

测试 方法
/* 删除delete的 测试*/
@Test
public void deleteTest(){
userDao.daleteUser(55);
}
分享 ===》删除成功 的日志 翻译 片段

2018-11-27 18:52:30,847 606 [ main] DEBUG com.fhw.dao.IUser.daleteUser

• ==> Parameters: 55(Integer)
  2018-11-27 18:52:30,858 617 [ main] DEBUG com.fhw.dao.IUser.daleteUser

• <== Updates: 1
  2018-11-27 18:52:30,858 617 [ main] DEBUG ansaction.jdbc.JdbcTransaction

• Committing JDBC Connection
  译：jdbc 事务-提交JDBC连接
  [com.mysql.jdbc.JDBC4Connection@433defed]
  2018-11-27 18:52:30,951 710 [ main] DEBUG ansaction.jdbc.JdbcTransaction

• Resetting autocommit to true on JDBC Connection

[com.mysql.jdbc.JDBC4Connection@433defed]
译：jdbc 事务 -在JDBC连接上重新设置autocommit为true
2018-11-27 18:52:30,952 711 [ main] DEBUG
ansaction.jdbc.JdbcTransaction - Closing JDBC Connection
译：jdbc 事务–关闭 JDBC连接 [com.mysql.jdbc.JDBC4Connection@433defed]

总结：
写到 这里 ----》 我们找到 通过反复渐进编写 意识到的一些规律（也就是说套路）
在做好maven 与MyBatise 的框架 之后 这几个CURD 操作就是
在：接口—映射xml的mapper文件----- 编写测试类里的语言 >

--------------------------》根据id 来查询
IUser接口：------- User findById（Integer userId）;
IUser.xml:-------

<select id="findById" parameterType="int" resultType="com.fhw.domain.User">
     select * from user where id = #{uid}
 </select>

测试 类里
/* @Test*//根据id 来查询 对象/
@Test
public void testFindOne(){
//6 执行操作
User user=userDao.findById(50);
System.out.println(user);
}
--------------------------》根据 字符串 条件 模糊查询
IUser接口：------- User findByName（String Username）;
IUser.xml:-------

<select id="findByName" parameterType="String"    resultType="com.fhw.domain.User">
     select * from user where id = #{name}

select * from user where username like '%KaTeX parse error: Expected '}', got 'EOF' at end of input: …%王%");// 在 xml%{value}%
for (User user : wang) {
System.out.println(user);
}
}
根据名称模糊查询-----select—id。。。parameterType（string）只有一个参数 就是 占位符

的就行

---- xml 与 测试类 里这2个方式是的 对比是：-----测试类里的好

%%百分号的模糊条件：
要么在Test测试里 在xml里的SQL里直接就是 %${value}%
value 的从源码的意思是 ：kye的名字就是 value 就只能是value 了

xml 里的改模糊条件 是 ：效率不高 字符串拼接
测试类 里改模糊条件 是：效率好一点 参数 占位符 格式： #{…占位符.}
（对比后 ）还是直观的 在 的在测试类里就写 模糊条件 就行了
。。。。。。程序 最终是根据 xml里来执行的，你在xml里写的是占位符
要是在xml里拼接 字符串 效率就慢了
日志的验证01:改模糊条件----测试类里参数：“%字符串%”xml就是占位符
2018-11-27 20:06:07,479 635 [ main] DEBUG com.fhw.dao.IUser.findByName

• ==> Preparing: select * from user where username like ?-----------》
  ${name}/*这里的占位符 前提是： 测试类里参数：“%字符串%” */

日志的验证02:改模糊条件----xml里 使用：%${value}%
2018-11-27 20:28:59,574 591 [ main] DEBUG com.fhw.dao.IUser.findByName

• ==> Preparing: select * from user where username like ‘%王%’
  显然就在执行是 拼接字符串

（注意根据id 的 的值 包装类 转 int）

我们 在 select 与 delete 都会有一个 where的 id
有时 要获取保存的id 应该怎么做
还是先出SQL语句里 开始推导 在insert 语句 执行之后 select last_insert_id 就可以查到

添加到最后的id
这时 xml 配置 会在再写

/* 配置插入操作后，获取插入数据的id keyProperty=“userId” 对应 的是实体类属性的

名称
keyColumn=“id” 就是数据库表的 id：有分别 有对应 写正确 将来还有类似 的写法 */

select last_insert_id();

insert into user(username,address,sex,birthday)values(#{userName},#

{userAddress},#{userSex},#{userBirthday});

测试=========》
/**
* 保存 id 的写法
*/
@Test
public void testSave() {
User user = new User();
user.setUserName(“fhw”);
user.setUserBirthday(new Date());
user.setUserSex(“男”);
user.setUserAddress(“西安市长安区”);
System.out.println(“保存操作之前”+user);//验证id
// 执行的方法
userDao.saveUser(user);
// 提交事务 查看 库里就会 发现的：出现了 没有显式的 事务回滚 id 被用的作用
sqlSession.commit();
System.out.println(“保存操作之后：”+user);
}
日志：
保存操作之前User{userId=null, userName=‘fhw’,。。。。。。（id是null）
保存操作之后：User{userId=56, 。。。。。。。（id已有数）

查询使用聚合函数
在持久层接口中添加模糊查询方法/*
** 查询总记录条数* @return*/int findTotal();
在用户的映射配置文件中配置
select count(*) from user;

加入聚合查询的测试方法
@Test
public void testFindTotal() throws Exception {
//6.执行操作
int res = userDao.findTotal(); System.out.println(res)

日志截取：
==> Preparing: select count(*) from user; /select count(id) from user;/
2018-11-27 22:04:13,387 600 [ main] DEBUG com.fhw.dao.IUser.findTotal

• ==> Parameters:
  2018-11-27 22:04:13,628 841 [ main] DEBUG com.fhw.dao.IUser.findTotal

• <== Total: 1
  聚合函数 总记录数：10

  Mybatis 与 JDBC 编程的比较

1.数据库链接创建、释放频繁造成系统资源浪费从而影响系统性能，如果使用数据库链接池可解决

此问题。
‘’解决：在 SqlMapConfig.xml 中配置数据链接池，pooled 使用连接池管理数据库链接。

2.Sql 语句写在代码中造成代码不易维护，实际应用 sql 变化的可能较大，sql 变动需要改变

java 代码。
解决：将 Sql 语句配置在 XXXXmapper.xml 文件中与 java 代码分离。

3.向 sql 语句传参数麻烦，因为 sql 语句的 where 条件不一定，可能多也可能少，占位符需要和

参数对应。
解决：Mybatis 自动将 java 对象映射至 sql 语句，
通过
statement 中的 parameterType 定义输入参数的类型。

4.对结果集解析麻烦，sql 变化导致解析代码变化，且解析前需要遍历，如果能将数据库记录封装

成 pojo 对象解析比较方便。
解决：Mybatis 自动将 sql 执行结果映射至 java 对象，
通过 statement 中的 resultType 定义输出结果的类型
简总：
，pooled
XXX·Xmapper.xml
parameterType
resultType
===========》我们已知道mybatise了这四点 》

‘’

parameterType 的 上输入类型 ： 有 简单 类型 也可以传递Pojo 类型

现在 可能对于 pojo 与OGNL 有些模糊

传递 pojo 包装对象： 就是 类里有类 作为成员属性的类变量

开发中通过 pojo 传递查询条件 ，查询条件是综合的查询条件，不仅包括用户查询条件还包括其它

的查
询条件（比如将用户购买商品信息也作为查询条件），这时可以使用包装对象传递输入参数。
Pojo 类中包含 pojo。
需求：根据用户名查询用户信息，查询条件放到 QueryVo 的 user 属性中

OGNL ： 对象图导航语言

相当于类 的写法:User.garUsername();
OGNL 可直接写为 user.username
因为在Mybatise里 ParameterType（）里 已将属性 的类 --所以就不写对象名
而 直接写： 属性名
所以接下来 可以在xml 里进行这些改进

我们在 传递pojo 的时候 可能 不是完整 或全部----》
查询条件就是 综合条件 这时 我们就要 pojo 类作为封装–查询条件

我 定义QueryVo ==译：Qeury查询Vo命令–》查询命令–的类
Class的 属性：定义了用户类user --类变量作为属性
pojo类组件------------
public class QueryVo {
private User user;

public User getUser() {
    return user;
}

public void setUser(User user) {
    this.user = user;
}

}
IUser接口------------
int findTotal();
/**使用pojo 类组件
* @param vo
* @return
*/
List findUserByVo(QueryVo vo);
IUser.xml-----------

<select id="findUserByVo" parameterType="com.fhw.domain.QueryVo" 

resultType=“com.fhw.domain.User”>
select * from user where username like #{user.userName}/*最终还是User类 的属性

:所以这里还是 正确的写法userName*/

测试------------------
/* 使用pojo 与 OGNL表达式的 方式 来进行 模糊查询*/
@Test
public void findUserByVoTest(){
User user = new User();
QueryVo vo = new QueryVo();
user.setUserName("%王%");
vo.setUser(user);/vo 调用 自己set方法 也就是 user自己的set的模糊条件/
List users = userDao.findUserByVo(vo);
for (User user1 : users) {
System.out.println(user1);
}
}
日志：异常
Could not resolve type alias ‘com.itheima.domain.QueryVo’. Cause:

java.lang.ClassNotFoundException: Cannot find class: com.itheima.domain.QueryVo
修改了包的层级 错误
ReflectionException: There is no getter for property named ‘username’ in 'class

com.fhw.domain.User’ 译文：为名为“用户名”的属性没有getter
修改类sql语句里的OGNL表达式 将#{user.useruame} 改好：#{user.userName}
重申—》￥￥￥￥====================》
要明白：是表与实体类一样：就是一个 占位符
要是 实体类的与表 不一样 就映射文件里的就要严格的按照java 语法操作-----》这里的实体

类就与 表 不一样
日志： 成功---------

• ==> Parameters: %王%(String)
  2018-11-28 00:02:01,790 2023 [ main] DEBUG com.fhw.dao.IUser.findUserByVo

• <== Total: 4
  User{userId=null, userName=‘老王’, userAddress=‘null’, userSex=‘null’,

userBirthday=null}
User{userId=null, userName=‘小二王’, userAddress=‘null’, userSex=‘null’,

userBirthday=null}
User{userId=null, userName=‘小二王’, userAddress=‘null’, userSex=‘null’,

userBirthday=null}
User{userId=null, userName=‘老王’, userAddress=‘null’, userSex=‘null’,

userBirthday=null}

在用这句》》》》重申—》￥￥￥￥====================》
要明白：是表与实体类一样：就是一个 占位符
要是 实体类的与表 不一样 就映射文件里的就要严格的按照java 语法操作-----》这里的实体

类就与 表 不一样