Mybatis 总结02

最新推荐文章于 2024-02-22 21:34:22 发布

Shena1NiZuoMoShi

最新推荐文章于 2024-02-22 21:34:22 发布

阅读量124

点赞数

分类专栏： Mybatis

本文链接：https://blog.csdn.net/Shena1NiZuoMoShi/article/details/101051068

版权

Mybatis 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

输入映射和输出映射

Mapper.xml映射文件中配置了执行statement相关的信息，比如：sql语句、sql中输入参数的映射、sql中输出结果的映射等。

输入映射通过parameterType标签属性来进行的。

输出映射通过resultType或resultMap标签属性来进行的。

1. parameterType(输入类型)
  1. 传递简单类型

参考第一天内容中的根据用户ID查询用户信息的案例。

1. 1. 传递pojo对象

参考第一天内容中的添加用户的案例。

1. 1. 传递pojo包装对象

这时可以使用包装对象传递输入参数。Pojo类中包含pojo。

1. 1. 1. 需求

在综合查询的场景中，需要根据不同的查询条件进行用户列表的查询。这些查询条件中，包括用户名称，还可能包括商品ID或者商品名称。

1. 1. 1. 分析
通过mybatis传递多个查询条件时，需要使用pojo或者map来传递。
判断这多个条件是否属于同一张表，那么就会对应一个实体类。如果不是，则最好声明一个包装pojo（也就是声明一个大对象，其中包含子对象或者子属性）

1. 1. 1. QueryVo

定义包装对象QueryVo

public class QueryVo {

private User user;

public User getUser() {

return user;

}

public void setUser(User user) {

this.user = user;

}

1. 1. 1. SQL语句

SELECT * FROM user where username like '%小明%'

1. 1. 1. Mapper文件

<!-- 使用包装类型查询用户

使用ognl从对象中取属性值，如果是包装对象可以使用.操作符来取内容部的属性

-->

SELECT * FROM user where username like '%${user.username}%'

</select>

1. 1. 1. Mapper接口

/**

* 用户管理mapper

public interface UserMapper {

//综合查询用户列表

public List<User> queryUserList(QueryVo vo)throws Exception;

}

1. 1. 1. 测试方法

在UserMapperTest测试类中，添加以下测试代码：

@Test

public void testQueryUserList() throws Exception {

SqlSession sqlSession = sqlSessionFactory.openSession();

//获得mapper的代理对象

UserMapper userMapper = sqlSession.getMapper(UserMapper.class);

//创建QueryVo对象

QueryVo queryVo = new QueryVo();

//创建user对象

User user = new User();

user.setUsername("小明");

queryVo.setUser(user);

//根据queryvo查询用户

List<User> list = userMapper.queryUserList(queryVo);

System.out.println(list);

sqlSession.close();

}

1. 1. 传递map类型

通过map类型传参和通过pojo类传参是一样的。

Pojo类型传参的要求，pojo中的属性名称和映射文件中的#{}里面的值一致。

Map类型传参的要求，map中的key和映射文件中的#{}里面的值一致。

1. resultType(输出类型)

resultType本质上也是使用resultMap完成映射的。

1. 1. 使用要求

使用resultType进行输出映射时，要求sql语句中查询的列名和要映射的pojo的属性名一致。

1. 1. 输出简单类型
    1. 需求

在综合查询用户列表时，要求分页查询，而分页查询需要查询符合条件的记录总数。

1. 1. 1. Mapper映射文件

select count(1) from user where username like '%${user.username}%'

</select>

1. 1. 1. Mapper接口

//综合查询用户总数

public int queryUserCount(QueryVo queryVo) throws Exception;

1. 1. 1. 测试代码

在UserMapperTest测试类中，添加以下测试代码：

@Test

public void testQueryUserList() throws Exception {

SqlSession sqlSession = sessionFactory.openSession();

//获得mapper的代理对象

UserMapper userMapper = sqlSession.getMapper(UserMapper.class);

//创建QueryVo对象

QueryVo queryVo = new QueryVo();

//创建user对象

User user = new User();

user.setUsername("小明");

queryVo.setUser(user);

//根据queryvo查询用户

List<User> list = userMapper.queryUserList(queryVo);

System.out.println(list);

int count = userMapper.queryUserCount(user);

System.out.println(count);

sqlSession.close();

}

注意：输出简单类型必须查询出来的结果集只有一列。

1. 1. 1. 总结

查询结果只有一列的时候，才能使用resultType的简单类型完成映射。

1. 1. 输出pojo对象

参考第一天内容之根据用户ID查询用户信息的案例

1. 1. 输出pojo列表

参考第一天内容之根据用户名称模糊查询用户列表的案例。

1. 1. 总结

输出映射，是发送在哪个JDBC的8步操作中的哪些步骤？

首先确定，输出映射的前提，是已经执行完sql语句，并且拿到ResultSet对象了。

也就是说输出映射就是将ResultSet中的值

按照[列名]取出结果集中的值，然后封装到一个pojo类型的[属性]中。

1. resultMap
  1. 使用要求

如果sql查询列名和pojo的属性名不一致，可以通过resultMap将列名和属性名作一个对应关系，最终将查询结果映射到pojo对象中。

1. 1. 需求

将以下sql的查询结果进行映射：

SELECT id id_,username username_,birthday birthday_ FROM user

1. 1. Mapper接口

// resultMap入门

public List<User> findUserResultMap() throws Exception;

1. 1. Mapper映射文件

由于sql查询列名和Users类属性名不一致，所以不能使用resultType进行结构映射。

需要定义一个resultMap将sql查询列名和Users类的属性名对应起来，完成结果映射。

<!--

type：指定查询结果要映射的pojo的类型

id：指定resultMap的唯一标示

-->

<!--

id标签：映射查询结果的唯一列（主键列）

column：查询sql的列名

property：映射结果的属性名

-->

</resultMap>

SELECT id id_,username username_,birthday birthday_ FROM user

</select>

<id />：此属性表示查询结果集的唯一标识，非常重要。如果是多个字段为复合唯一约束则定义多个<id />。

Property：表示User类的属性。

Column：表示sql查询出来的字段名。

Column和property放在一块儿表示将sql查询出来的字段映射到指定的pojo类属性上。

<result />：普通结果，即pojo的属性。

动态sql

通过mybatis提供的各种标签方法实现动态拼接sql，常用的动态标签包括：if、where、foreach和sql片段。

1. if

综合查询的案例中，查询条件是由页面传入，页面中的查询条件可能输入用户名称，也可能不输入用户名称。

SELECT * FROM user where 1=1

AND username like '%${user.username}%'

</if>

</select>

注意：要做『不等于空』字符串校验。

1. where

上边的sql中的1=1，虽然可以保证sql语句的完整性：但是存在性能问题。Mybatis提供where标签解决该问题。

代码修改如下：

SELECT * FROM user

<where>

AND username like '%${user.username}%'

</if>

</where>

</select>

1. sql片段

在映射文件中可使用sql标签将重复的sql提取出来，然后使用include标签引用即可，最终达到sql重用的目的，具体实现如下：

原映射文件中的代码：

SELECT * FROM user

<where>

AND username like '%${user.username}%'

</if>

<foreach collection="ids" item="id" open=" AND id IN ( "

close=" ) " separator=",">

#{id}

</foreach>

</if>

</where>

</select>

将where条件抽取出来：

AND username like '%${user.username}%'

</if>

<foreach collection="ids" item="id" open=" AND id IN ( "

close=" ) " separator=",">

#{id}

</foreach>

</if>

</sql>

使用include引用：

SELECT * FROM user

<where>

</where>

</select>

注意：如果引用其它mapper.xml的sql片段，则在引用时需要加上namespace，如下：

<include refid="namespace.sql片段”/>

1. foreach

向sql传递数组或List参数，mybatis使用foreach解析

1. 1. 需求

传入多个id查询用户信息，用下边两个sql实现：

SELECT * FROM USERS WHERE username LIKE '%小明%' AND (id =1 OR id =10 OR id=16)

SELECT * FROM USERS WHERE username LIKE '%小明%' AND id IN (1,10,16)

1. 1. 修改POJO

在pojo中定义list属性ids存储多个用户id，并添加getter/setter方法

1. 1. Mapper映射文件

SELECT * FROM user

<where>

AND username like '%${user.username}%'

</if>

<!--

collection：指定输入的集合参数的参数名称

item：声明集合参数中的元素变量名

open：集合遍历时，需要拼接到遍历sql语句的前面

close：集合遍历时，需要拼接到遍历sql语句的后面

separator：集合遍历时，需要拼接到遍历sql语句之间的分隔符号

-->

#{id}

</foreach>

</if>

</where>

</select>

1. 1. 测试代码

在UserMapperTest测试代码中，修改testFindUserList方法，如下：

@Test

public void testQueryUserList() throws Exception {

SqlSession sqlSession = sqlSessionFactory.openSession();

// 获得mapper的代理对象

UserMapper userMapper = sqlSession.getMapper(UserMapper.class);

// 创建QueryVo对象

QueryVo queryVo = new QueryVo();

// 创建user对象

User user = new User();

user.setUsername("小明");

queryVo.setUser(user);

List<Integer> ids = new ArrayList<Integer>();

ids.add(1);// 查询id为1的用户

ids.add(10); // 查询id为10的用户

queryVo.setIds(ids);

// 根据queryvo查询用户

List<User> list = userMapper.queryUserList(queryVo);

System.out.println(list);

sqlSession.close();

}

关联查询
1. 商品订单数据模型

用户表：user

记录了购买商品的用户信息

Id：唯一标识一个用户

订单表：orders

记录了用户创建的订单

创建用户:user_id(外键)

订单号

创建时间

订单状态

一对一：一个订单只能由一个用户创建

一对多：一个用户可以创建多个订单

注意：因为一个订单信息只会是一个人下的订单，所以从查询订单信息出发，关联查询用户信息为一对一查询。如果从用户信息出发，查询用户下的订单信息则为一对多查询，因为一个用户可以下多个订单。

1. 一对一查询
  1. 需求

查询所有订单信息，关联查询下单用户信息。

1. 1. Sql语句

SELECT

orders.*,

user.username,

user.address

FROM

orders

user

WHERE orders.user_id = user.id

主信息：订单信息

从信息：用户信息

1. 1. 方法一：resultType

使用resultType进行结果映射。

1. 1. 1. 分析
如果使用resultType进行结果映射，则查询的列名和映射pojo的属性名称要一致。
关联查询的结果集，既包含订单信息，又包含用户信息。使用订单po或者用户po类都无法完成结果映射。
需要定义扩展po类，此类继承订单信息po类，同时还要包括用户信息：

1. 1. 1. 定义扩展po类

扩展Po类中应该包括上边sql查询出来的所有字段，如下：

public class OrdersExt extends Orders {

private String username;// 用户名称

private String address;// 用户地址

get/set。。。。

OrdersExt类继承Orders类后，便会继承Orders类的所有字段，除此之外只需要定义用户信息字段即可。

1. 1. 1. Mapper映射文件

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

SELECT

orders.*,

user.username,

user.address

FROM

orders, user

WHERE orders.user_id = user.id

</select>

1. 1. 1. Mapper接口

在UserMapper接口中，添加以下接口方法：

public List<OrdersExt> findOrdersAndUser() throws Exception;

1. 1. 1. 测试代码

在UserMapperTest测试类中，添加测试代码：

public void testFindOrdersAndUser()throws Exception{

//获取session

SqlSession session = sqlSessionFactory.openSession();

//获限mapper接口实例

UserMapper userMapper = session.getMapper(UserMapper.class);

//查询订单信息

List<OrdersExt> list = userMapper.findOrdersAndUser();

System.out.println(list);

//关闭session

session.close();

}

1. 1. 1. 小结
使用resultType完成结果映射，映射的java对象中的属性都是简单类型属性（不包括pojo属性）。
1. 1. 方法二：resultMap

使用resultMap完成结果映射，是需要将关联信息，映射为对象嵌套对象的关系。

使用resultMap进行结果映射，定义专门的resultMap用于映射一对一查询结果。

1. 1. 1. 修改扩展po类

在OrdersExt类中加入User属性，user属性中用于存储关联查询的用户信息，因为订单关联查询用户是一对一关系，所以这里使用单个User对象存储关联查询的用户信息。

public class OrdersExt extends Orders {

private String username;// 用户名称

private String address;// 用户地址

private User user;// 用户对象

get/set。。。。

1. 1. 1. Mapper映射文件

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

<!--

property:Orders对象的user属性

javaType：user属性对应的类型

-->

<association property="user" javaType="cn.itcast.mybatis.po.User">

</association>

</resultMap>

SELECT

o.*,

u.username,

u.address

FROM

orders o

JOIN `user` u ON u.id = o.user_id

</select>

association：表示进行一对一关联查询映射

property：表示关联查询的结果存储在cn.itcast.mybatis.po.Orders的user属性中

javaType：表示关联查询的映射结果类型

1. 1. 1. Mapper接口

在UserMapper接口中，添加以下接口方法：

public List<OrdersExt> findOrdersAndUserRstMap() throws Exception;

1. 1. 1. 测试代码

在UserMapperTest测试类中，添加测试代码：

Public void testfindOrdersAndUserRstMap()throws Exception{

//获取session

SqlSession session = sqlSessionFactory.openSession();

//获限mapper接口实例

UserMapper userMapper = session.getMapper(UserMapper.class);

//查询订单信息

List<OrdersExt> list = userMapper.findOrdersAndUserRstMap();

System.out.println(list);

//关闭session

session.close();

}

1. 1. 1. 小结

使用resultMap进行结果映射时，具体是使用association完成关联查询的映射，将关联查询信息映射到pojo对象中。

1. 1. 总结

特殊映射要求：对象嵌套对象。

一般映射要求：将查询结果都映射成一个pojo的简单类型属性。

没有特殊映射要求，在一对一映射的时候，使用resultType更简单。建议使用resultType完成结果映射。

resultMap在一些更特殊的情况（延迟加载）下，必须使用它完成映射。

在mybatis中，mapper代理获取的对象使用的是JDK代理。延迟加载的对象代理就是使用的cglib。

1. 一对多查询

使用resultType完成结果映射，查询记录有多少条，则映射成几个结果对象。

1. 1. 需求

查询所有用户信息及用户关联的订单信息。

1. 1. Sql语句

SELECT

user.*,

orders.`id` ordersId,

orders.`number`

FROM

USER,

orders

WHERE user.`id` = orders.`user_id`

主信息：用户信息

从信息：订单信息

1. 1. 分析

在一对多关联查询时，只能使用resultMap进行结果映射。

一对多关联查询时，sql查询结果有多条，而映射对象是一个。
resultType完成结果映射的方式的一条记录映射一个对象。
resultMap完成结果映射的方式是以[主信息]为主对象，[从信息]映射为集合或者对象，然后封装到主对象中。
1. 1. 修改po类

在User类中加入List<Orders> orders属性

1. 1. Mapper映射文件

在UserMapper.xml文件中，添加以下代码：

</collection>

</resultMap>

SELECT

user.*,

orders.`id` ordersId,

orders.`number`

FROM

USER,

orders

WHERE user.`id` = orders.`user_id`

</select>

Collection标签：定义了一对多关联的结果映射。

property="orders"：关联查询的结果集存储在User对象的上哪个属性。

ofType="orders"：指定关联查询的结果集中的对象类型即List中的对象类型。此处可以使用别名，也可以使用全限定名。

1. 1. Mapper接口

// resultMap入门

public List<User> findUserAndOrdersRstMap() throws Exception;

1. 1. 测试代码

@Test

public void testFindUserAndOrdersRstMap() {

SqlSession session = sqlSessionFactory.openSession();

UserMapper userMapper = session.getMapper(UserMapper.class);

List<User> result = userMapper.findUserAndOrdersRstMap();

for (User user : result) {

System.out.println(user);

}

session.close();

}

Mybatis整合spring
1. 整合思路

使用spring管理mybatis的实例。

数据库的连接以及数据库连接池事务管理都交给spring容器来完成。
SqlSessionFactory对象应该放到spring容器中进行单例管理。
传统dao的开发方式中，dao实现类应该交由spring管理。
Mapper代理开发方式中，mapper的代理对象应该交由spring管理。

1. 整合需要的jar包
Mysql的数据库驱动jar包。
数据库连接池的jar包。
Mybatis的jar包
spring的jar包
Spring+mybatis的整合包。

1. 整合的步骤

第一步：创建一个java工程。

第二步：导入jar包。（上面提到的jar包）

此步骤之前，需要将po类创建。

第三步：mybatis的配置文件sqlmapConfig.xml

第四步：编写Spring的配置文件

1、数据库连接及连接池

2、事务管理（暂时可以不配置）

3、sqlsessionFactory对象，配置到spring容器中

4、mapeer代理对象或者是dao实现类配置到spring容器中。

第五步：编写映射文件

第六步：编写dao代码或者mapper接口

第七步：测试。

1. 1. SqlMapConfig.xml

在classpath目录下，创建mybatis目录，然后创建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">

</typeAliases>

</mappers>

</configuration>

1. 1. applicationContext.xml

在classpath目录下，创建spring目录，然后创建applicationContext.xml文件

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

<beans xmlns="http://www.springframework.org/schema/beans"

xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"

xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd

http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd

http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd

http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd">

<context:property-placeholder location="classpath:db.properties" />

<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"

destroy-method="close">

</bean>

</bean>

</beans>

1. 1. db.properties

在classpath目录下，创建db.properties文件。

jdbc.driver=com.mysql.jdbc.Driver

jdbc.url=jdbc:mysql://localhost:3306/ssm?characterEncoding=utf-8

jdbc.username=root

jdbc.password=root

1. Dao的开发

三种dao的实现方式：

1、传统dao的开发方式

2、使用mapper代理形式开发方式

3、使用扫描包配置mapper代理。

1. 1. 传统dao开发方式

开发dao接口和实现类。整合spring之后的dao实现类需要继承SqlsessionDaoSupport类

1. 1. 1. Dao实现类

public class UserDaoImpl extends SqlSessionDaoSupport implements UserDao {

@Override

public User findUserById(int id) throws Exception {

//不能关闭SqlSession，让spring容器来完成

return User user = this.getSqlSession().selectOne("test.findUserById", id);

}

@Override

public void insertUser(User user) throws Exception {

SqlSession session = this.getSqlSession();

session.insert("test.insertUser", user);

session.commit();

//session.close();

}

1. 1. 1. 配置dao

把dao实现类配置到spring容器中

applicationContext.xml中添加以下配置：

</bean>

1. 1. 1. 测试方法

@Test

public void testFindUserById() throws Exception {

UserDao userDao = (UserDao) applicationContext.getBean("userDao");

User user = userDao.findUserById(1);

System.out.println(user);

}

1. 1. Mapper代理开发方式
    1. 开发mapper接口和映射文件

1. 1. 1. 配置mapper代理
      1. 方式1

</bean>

1. 1. 1. 1. 方式2（推荐）

</bean>

注意：spring中mapper代理对象的bean的id就是类名（首字母小写）

1. 1. 1. 测试方法

public class UserMapperTest {

private ApplicationContext applicationContext;

@Before

public void setUp() throws Exception {

applicationContext = new ClassPathXmlApplicationContext("classpath:spring/applicationContext.xml");

}

@Test

public void testGetUserById() {

UserMapper userMapper = applicationContext.getBean(UserMapper.class);

User user = userMapper.getUserById(1);

System.out.println(user);

}

Mybatis逆向工程

使用官方网站的Mapper自动生成工具mybatis-generator-core-1.3.2来生成po类和Mapper映射文件和mapper接口（注意，只能针对单表进行生成，关联关系无法生成）。

1. 导入逆向工程

使用课前资料已有逆向工程，如下图：

1. 1. 复制逆向工程到工作空间中

复制的效果如下图：

1. 1. 导入逆向工程到eclipse中

如下图方式进行导入：

1. 修改配置文件

在generatorConfig.xml中配置Mapper生成的详细信息，如下图：

注意修改以下几点:

修改要生成的数据库表
pojo文件所在包路径
Mapper所在的包路径

配置文件如下:

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

<!DOCTYPE generatorConfiguration

PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"

"http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">

</commentGenerator>

<jdbcConnection driverClass="com.mysql.jdbc.Driver"

connectionURL="jdbc:mysql://localhost:3306/mybatis" userId="root" password="root">

</jdbcConnection>

<!-- <jdbcConnection driverClass="oracle.jdbc.OracleDriver" connectionURL="jdbc:oracle:thin:@127.0.0.1:1521:yycg"

userId="yycg" password="yycg"> </jdbcConnection> -->

<!-- 默认false，把JDBC DECIMAL 和 NUMERIC 类型解析为 Integer，为 true时把JDBC DECIMAL

和 NUMERIC 类型解析为java.math.BigDecimal -->

</javaTypeResolver>

<javaModelGenerator targetPackage="cn.itcast.ssm.po"

targetProject=".\src">

</javaModelGenerator>

<sqlMapGenerator targetPackage="cn.itcast.ssm.mapper"

targetProject=".\src">

</sqlMapGenerator>

<javaClientGenerator type="XMLMAPPER"

targetPackage="cn.itcast.ssm.mapper" targetProject=".\src">

</javaClientGenerator>

</context>

</generatorConfiguration>

1. 生成逆向工程代码

找到下图所示的java文件，执行工程main主函数,

刷新工程，发现代码生成，如下图：

1. 测试逆向工程代码

1. 复制生成的代码到mybatis-spring工程，如下图

2. 修改spring配置文件

在applicationContext.xml修改

</bean>

3. 编写测试方法：

public class UserMapperTest {

private ApplicationContext context;

@Before

public void setUp() throws Exception {

this.context = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");

}

@Test

public void testInsert() {

// 获取Mapper

UserMapper userMapper = this.context.getBean(UserMapper.class);

User user = new User();

user.setUsername("曹操");

user.setSex("1");

user.setBirthday(new Date());

user.setAddress("三国");

userMapper.insert(user);

}

@Test

public void testSelectByExample() {

// 获取Mapper

UserMapper userMapper = this.context.getBean(UserMapper.class);

// 创建User对象扩展类，用户设置查询条件

UserExample example = new UserExample();

example.createCriteria().andUsernameLike("%张%");

// 查询数据

List<User> list = userMapper.selectByExample(example);

System.out.println(list.size());

}

@Test

public void testSelectByPrimaryKey() {

// 获取Mapper

UserMapper userMapper = this.context.getBean(UserMapper.class);

User user = userMapper.selectByPrimaryKey(1);

System.out.println(user);

}

注意：

逆向工程生成的代码只能做单表查询
不能在生成的代码上进行扩展，因为如果数据库变更，需要重新使用逆向工程生成代码，原来编写的代码就被覆盖了。
一张表会生成4个文件

Shena1NiZuoMoShi

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Mybatis 总结02

输入映射和输出映射Mapper.xml映射文件中配置了执行statement相关的信息，比如：sql语句、sql中输入参数的映射、sql中输出结果的映射等。输入映射通过parameterType标签属性来进行的。输出映射通过resultType或resultMap标签属性来进行的。 parameterType(输入类型) 传递简单类型参考第一天内容...
复制链接

扫一扫