mysql 自定义结果集_MyBatis（二）参数传递和自定义结果集

一、myBatis的注解使用方式

package com.webcode.mapper;

import java.util.List;

import org.apache.ibatis.annotations.Delete;

import org.apache.ibatis.annotations.Insert;

import org.apache.ibatis.annotations.Select;

import org.apache.ibatis.annotations.SelectKey;

import org.apache.ibatis.annotations.Update;

import com.webcode.pojo.User;

public interface UserMapper {

@Select("select id,last_name lastName,sex from t_user where id = #{id}")

public User queryUserById(Integer id);

//@Select("select id,last_name lastName,sex from t_user")

public List queryUsers();

@SelectKey(statement = "select last_insert_id()", before = false, keyProperty = "id", resultType = Integer.class)

@Insert(value = "insert into t_user(last_name,sex) values(#{lastName},#{sex})")

public int saveUser(User user);

@Delete("delete from t_user where id = #{id}")

public int deleteUserById(Integer id);

@Update("update t_user set last_name = #{lastName},sex = #{sex} where id = #{id}")

public int updateUser(User user);

}

二、mybatis的参数传递

1、一个普通数据类型

Mapper接口的方法：

public interface UserMapper {

public User queryUserById(Integer id);

}

mapper.xml配置文件：

select id,last_name lastName,sex from t_user where id = #{id}

2、多个普通数据类型

方法代码：

public List queryUserByNameAndSex(String name, Integer sex);

配置文件：

select id,last_name lastName,sex from t_user where last_name = #{param1} and sex = #{param2}

2、@Param注解命名参数

方法代码：

public List queryUserByNameAndSex(@Param("name") String name,

@Param("sex") Integer sex);

配置信息：

select id,last_name lastName,sex from t_user where last_name = #{name} and sex = #{sex}

3、传递一个Map对象作为参数

方法代码：

/**

* Map param,我们希望在Map中放name的值和sex的值，来进行查询

*/

public List queryUserByMap(Map param);

配置信息：

select id,last_name lastName,sex from t_user where last_name = #{name} and sex = #{sex}

4、一个JavaBean数据类型

方法代码：

/**

* 我们希望使用user对象的lastName属性和sex属性，来进行查询

*/

public List queryUserByUser(User user);

配置信息：

select id,last_name lastName,sex from t_user where last_name = #{lastName} and sex = #{sex}

5、多个Pojo数据类型

方法代码：

/**

* 我们希望使用第一个user对象的lastName属性和第二个user对象的sex属性，来进行查询

*/

public List queryUserByUsers(User name,User sex);

配置信息：

select id,last_name lastName,sex from t_user where last_name = #{param1.lastName} and sex = #{param2.sex}

6、模糊查询

需求：现在要根据用户名查询用户对象。 也就是希望查询如下： select * from t_user where last_name like '%张%'

方法代码：

/**

* 需求：现在要根据用户名查询用户对象。 也就是希望查询如下：

* select * from t_user where last_name like '%张%'

*/

public List queryUsersByNameLike(String lastName);

7、#{}和${}的区别

#{} 是占位符

${} 是做字符串原样输出，然后和配置的sql语句做字符串拼接。

​

​

8、MySQL的字符串拼接，concat函数实现。

​

select id,last_name lastName,sex from t_user where last_name like concat('%',#{lastName},'%')

二、自定义结果集

1、的作用。

ResultMap标签可以给那些查询出来的结果要封装成为的Bean对象。是复杂bean对象的情况。

原来我们查询出来的结果，封装的对象里面的属性都是普通的属性。不包含子的javaBean对象。也不包含Bean对象的集合。那种叫普通的javabean。

那些Bean对象中又包含了子的Bean对象的情况，或者是Bean对象中又包含的bean对象集合的情况，叫复杂的Bean对象。

这种情况，只能使用ResultMap标签来将结果集转换成为复杂的Bean对象。而简单的不需要。简单的Bean对象，只需要使用ResultType属性即可。

2、创建一对一数据库表

## 一对一数据表

## 创建锁表

create table t_lock(

`id` int primary key auto_increment,

`name` varchar(50)

);

## 创建钥匙表

create table t_key(

`id` int primary key auto_increment,

`name` varchar(50),

`lock_id` int ,

foreign key(`lock_id`) references t_lock(`id`)

);

## 插入初始化数据

insert into t_lock(`name`) values('阿里巴巴');

insert into t_lock(`name`) values('华为');

insert into t_lock(`name`) values('联想');

insert into t_key(`name`,`lock_id`) values('马云',1);

insert into t_key(`name`,`lock_id`) values('任正非',2);

insert into t_key(`name`,`lock_id`) values('柳传志',3);

3、创建实体对象

public class Lock {

private Integer id;

private String name;

public class Key {

private Integer id;

private String name;

private Lock lock;

4、一对一级联属性使用

Mapper接口的代码：

public interface KeyMapper {

public Key queryKeyByIdForSample(Integer id);

}

KeyMapper配置文件的内容：

select

t_key.* ,t_lock.name lock_name

from

t_key left join t_lock

on

t_key.lock_id = t_lock.id

where

t_key.id = #{id}

4.2、嵌套结果集映射配置

select

t_key.* ,t_lock.name lock_name

from

t_key left join t_lock

on

t_key.lock_id = t_lock.id

where

t_key.id = #{id}

4.3、 定义分步(立即)查询

KeyMapper接口：

public interface KeyMapper {

// 分两次查，只查key

public Key queryKeyByIdForTwoStep(Integer id);

}

LockMapper接口：

public interface LockMapper {

// 只查锁

public Lock queryLockById(Integer id);

}

LockMapper配置信息：

select id,name from t_lock where id = #{id}

KeyMapper的配置信息：

select="com.webcode.mapper.LockMapper.queryLockById"/>

select id,name,lock_id from t_key where id = #{id}

5、延迟加载

延迟加载在一定程序上可以减少很多没有必要的查询。给数据库服务器提升性能上的优化。

要启用延迟加载，需要在mybatis-config.xml配置文件中，添加如下两个全局的settings配置。

懒加载还需要同时引入两个jar包(注意: 3.2.8版本需要导以下两个包)

​​

5.2、延迟加载的一对一使用示例

三、多对一、一对多的使用示例

1、创建一对多数据库

## 一对多数据表

## 创建班级表

create table t_clazz(

`id` int primary key auto_increment,

`name` varchar(50)

);

## 插入班级信息

insert into t_clazz(`name`) values('javaEE20170228');

insert into t_clazz(`name`) values('javaEE20170325');

insert into t_clazz(`name`) values('javaEE20170420');

insert into t_clazz(`name`) values('javaEE20170515');

## 创建学生表

create table t_student(

`id` int primary key auto_increment,

`name` varchar(50),

`clazz_id` int,

foreign key(`clazz_id`) references t_clazz(`id`)

);

## 插入班级信息

insert into t_student(`name`,`clazz_id`) values('stu0228_1',1);

insert into t_student(`name`,`clazz_id`) values('stu0228_2',1);

insert into t_student(`name`,`clazz_id`) values('stu0228_3',1);

insert into t_student(`name`,`clazz_id`) values('stu0325_1',2);

insert into t_student(`name`,`clazz_id`) values('stu0325_2',2);

insert into t_student(`name`,`clazz_id`) values('stu0420_1',3);

2、 一对多，立即加载

public class Student {

private Integer id;

private String name;

public class Clazz {

private Integer id;

private String name;

private List stus;

ClazzMapper接口的代码：

public interface ClazzMapper {

// 一次全部查询出来

public Clazz queryClazzByIdForSimple(Integer id);

}

ClazzMapper配置信息：

select

t_clazz.*,t_student.id stu_id,t_student.name stu_name,t_student.clazz_id

from

t_clazz left join t_student

on

t_clazz.id = t_student.clazz_id

where

t_clazz.id = #{id}

3、一对多，分步查询赖加载

ClazzMapper接口方法：

public interface ClazzMapper {

// 分两次查，这边只查班级

public Clazz queryClazzByIdForTwoStep(Integer id);

}

StudentMapper接口方法：

public interface StudentMapper {

// 只查学生，

public List queryStudentByClazzId(Integer clazzId);

}

StudentMaper的配置内容：

select id,name from t_student where clazz_id = #{clazzId}

ClazzMapper的配置内容：

select="com.webcode.mapper.StudentMapper.queryStudentByClazzId"/>

select id,name from t_clazz where id = #{id}

4、双向关联

StudentMapper接口

public interface StudentMapper {

// 按班级id查学生。还可以关联查班级

public List queryStudentsByClazzIdForTwoStep(Integer clazzId);

}

StudentMapper的配置：

select="com.webcode.mapper.ClazzMapper.queryClazzByIdForTwoStep"/>

resultMap="queryStudentsByClazzIdForTwoStep_resultMap">

select id,name,clazz_id from t_student where clazz_id = #{clazzId}

ClazzMapper的配置信息修改：

select="com.webcode.mapper.StudentMapper.queryStudentsByClazzIdForTwoStep"/>

select id,name from t_clazz where id = #{id}

测试：

@Test

public void testQueryClazzByIdForTwoStep() {

SqlSession session = sqlSessionFactory.openSession();

try {

ClazzMapper mapper = session.getMapper(ClazzMapper.class);

Clazz clazz = mapper.queryClazzByIdForTwoStep(1);

session.clearCache();//清缓存，可以看到后面再次关联班级时的查询

System.out.println(clazz.getName());

List stus = clazz.getStus();

for (Student student : stus) {

session.clearCache();//清缓存，可以看到后面再次关联班级时的查询

System.out.println( "学生姓名：" + student.getName() );

System.out.println( "学生所在班级名称：" + student.getClazz().getName() );

}

} catch (Exception e) {

e.printStackTrace();

} finally {

session.close();

}

}

注意：双向关联常见问题，就是死循环：

解决方法一：不要调用任何一方的toString方法

解决方法二：最后一次的查询使用resultType，而不是使用ResultMap