04.mybatis高级应用

最新推荐文章于 2023-03-06 11:55:39 发布

松松啊

最新推荐文章于 2023-03-06 11:55:39 发布

阅读量131

点赞数

分类专栏：常用企业框架

本文链接：https://blog.csdn.net/qq_38243113/article/details/101639672

版权

常用企业框架专栏收录该内容

11 篇文章 0 订阅

订阅专栏

Mybatis02-高级应用

第一节：输入参数和输出参数

Mapper.xml映射文件中定义了操作数据库的sql，每个sql是一个statement，映射文件是mybatis的核心。

1.1 环境准备

第一步：创建项目添加依赖

项目名称：day04_mybatis01
依赖信息如下：

<dependencies>
  		<dependency>
           <groupId>mysql</groupId>
           <artifactId>mysql-connector-java</artifactId>
           <version>5.1.41</version>
       </dependency>
       <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
       <dependency>
           <groupId>org.mybatis</groupId>
           <artifactId>mybatis</artifactId>
           <version>3.4.6</version>
       </dependency>
   <!-- https://mvnrepository.com/artifact/log4j/log4j -->
       <dependency>
           <groupId>log4j</groupId>
           <artifactId>log4j</artifactId>
           <version>1.2.17</version>
       </dependency>
</dependencies>

第二步：加入配置文件

Mybatis的核心配置mybatis-config.xml、log4j日志文件log4j.properties

<?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>
	<!-- 和spring整合后 environments配置将废除 -->
	<environments default="development">
		<environment id="development">
			<!-- 使用jdbc事务管理 -->
			<transactionManager type="JDBC" />
			<!-- 数据库连接池 -->
			<dataSource type="POOLED">
				<property name="driver" value="com.mysql.jdbc.Driver" />
				<property name="url"
					value="jdbc:mysql://localhost:3306/mybatis_01?characterEncoding=utf-8" />
				<property name="username" value="root" />
				<property name="password" value="root" />
			</dataSource>
		</environment>
	</environments>
</configuration>

### set log levels - for more verbose logging change 'info' to 'debug' ， 'off' ###
log4j.rootLogger=info, stdout,file

### direct log messages to stdout ###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.err
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

### direct messages to file mylog.log ###
log4j.appender.file=org.apache.log4j.FileAppender
log4j.appender.file.File=d:\\mylog.log
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

第三步：创建POJO

User.java

public class User {
	private int id;
	private String username;// 用户姓名
	private String sex;// 性别
	private Date birthday;// 生日
	private String address;// 地址
	//getter和setter
}

第四步：加入sql映射文件

在resources目录下创建com.qf.mapper文件夹，然后创建UserMapper.xml文件

<?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">
<!-- namespace：命名空间，用于隔离sql-->
<mapper namespace="">
  
</mapper

第五步：加载映射文件

MyBatis框架需要加载UserMapper.xml映射文件,将UserMapper.xml添加在mybatis-config.xml，如下：

<mappers>
        <mapper resource="com/qf/mapper/UserMapper.xml"/>
</mappers>

1.2 parameterType(输入参数)

1.2.1. 传递简单类型

使用#{}占位符，或者${}进行sql拼接。   (order by id 必须使用${})

扩展:如果传递多个简单类型，使用@Param注解实现
List<User> findByWhere(@Param("username") String username, @Param("sex") String sex);
SQL映射文件如下，不需要写parameterType
<select id="findByWhere" resultType="user">
        select * from user where username like #{username} and sex=#{sex};
</select>

1.2.2. 传递pojo对象

#{}或者${}括号中的值为pojo属性名称。

1.2.3. 传递pojo包装对象

开发中通过可以使用pojo传递查询条件。
查询条件可能是综合的查询条件，不仅包括用户查询条件还包括其它的查询条件（比如查询用户信息的时候，将用户购买商品信息也作为查询条件），这时可以使用包装对象传递输入参数。

包装对象：Pojo类中的一个属性是另外一个pojo。

需求1：根据用户名模糊查询用户信息

查询条件放到QueryVo的user属性中。

编写QueryVo

public class QueryVo {
	private User user;
  	private String  username;

	public User getUser() {
		return user;
	}
	public void setUser(User user) {
		this.user = user;
	}
  
  	/get set
}

使用SQL语句：SELECT * FROM user WHERE username LIKE ‘%张%’;

在UserMapper.xml中配置sql，如下。

<select id="findUserByQueryVo" paramenterType="queryVo" resultType="user">
	select * from user where username like #{user.username}
</select>

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

List<User> findUserQueryVo(QueryVo queryVo);

在UserMapperTest增加测试方法，如下：

@Test
public void testQueryUserByQueryVo() {
	// MyBatis和spring整合，整合之后，交给spring管理
	SqlSession sqlSession = MyBatisUtils.openSession();
	// 创建Mapper接口的动态代理对象，整合之后，交给spring管理
	UserMapper userMapper = sqlSession.getMapper(UserMapper.class);

	// 使用userMapper执行查询，使用包装对象
	QueryVo queryVo = new QueryVo();
	// 设置user条件
	User user = new User();
	user.setUsername("%张%");
	// 设置到包装对象中
	queryVo.setUser(user);

	// 执行查询
	List<User> list = userMapper.findUserByQueryVo(queryVo);
	for (User u : list) {
		System.out.println(u);
	}
	sqlSession.close();
}

1.2.4. 传递map集合

需求2：分页查询用户信息

分页属性放入map集合中,注意：map的key要和sql中的占位符保持名字一致。

使用SQL语句：SELECT * FROM user limit #{offset},#{pagesize}

在UserMapper.xml中配置sql，如下。

<!-- 分页：map传参 -->
 <select id="findUserByPage" parameterType="map" resultType="user">
         SELECT * FROM user LIMIT #{offset}, #{pagesize}
 </select>

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

List<User> findUserByPage(Map<String, Object> map);

在UserMapperTest增加测试方法，如下：

@Test
public void testQueryUserByPage() {
	SqlSession sqlSession = MyBatisUtils.openSession();
	UserMapper userMapper = sqlSession.getMapper(UserMapper.class);

	 Map<String, Object> map = new HashMap<String, Object>();
     map.put("offset", 0);
     map.put("pagesize", 2);
	// 执行查询
	List<User> list = userMapper.findUserByPage(map);
	for (User u : list) {
		System.out.println(u);
	}

	sqlSession.close();
}

1.3. resultType(输出参数)

1.3.1. 输出简单类型

需求:查询用户表数据条数

使用sql：SELECT count(*) FROM user

在UserMapper.xml中配置sql，如下：

 <select id="queryUserCount"  resultType="int">
         SELECT count(*) FROM user
 </select>

在UserMapper添加方法，如下：

int queryUserCount();

在UserMapeprTest增加测试方法，如下：

@Test
public void testQueryUserCount() {
	SqlSession sqlSession = MyBatisUtils.openSession();
	
	UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
	// 使用userMapper执行查询用户数据条数
	int count = userMapper.queryUserCount();
	System.out.println(count);

	sqlSession.close();
}

注意：输出简单类型必须查询出来的结果集有一条记录，最终将第一个字段的值转换为输出类型。

1.3.2. 输出pojo对象

已讲

1.3.3. 输出pojo列表

已讲

1.4. resultMap

resultType可以指定将查询结果映射为pojo，但需要pojo的属性名和sql查询的列名一致方可映射成功。

如果sql查询字段名和pojo的属性名不一致，可以通过resultMap将字段名和属性名作一个对应关系，resultMap实质上还需要将查询结果映射到pojo对象中。

resultMap可以实现将查询结果映射为复杂类型的pojo，比如在查询结果映射对象中包括pojo和list实现一对一查询和一对多查询。

需求：查询订单表order的所有数据

使用sql语句：SELECT id, user_id, number, createtime, note FROM orders

1.4.1.创建pojo对象

Order对象：

public class Order {
	// 订单id
	private int id;
	// 用户id
	private Integer userId;
	// 订单号
	private String number;
	// 订单创建时间
	private Date createtime;
	// 备注
	private String note;
	//get/set。。。
}

1.4.2. Mapper.xml文件

创建OrderMapper.xml配置文件

<?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">
<!-- namespace：命名空间，用于隔离sql，还有一个很重要的作用，Mapper动态代理开发的时候使用，需要指定Mapper的类路径 -->
<mapper namespace="com.qf.mapper.OrderMapper">
	<!-- 查询所有的订单数据 -->
	<select id="queryOrderAll" resultType="order">
		SELECT id, user_id,number,createtime, note FROM `order`
	</select>
</mapper>

1.4.3. Mapper接口

编写接口如下：

public interface OrderMapper {
	/**
	 * 查询所有订单
	 * 
	 * @return
	 */
	List<Order> queryOrderAll();
}

1.4.4. 测试方法

编写测试方法OrderMapperTest如下：

@Test
	public void testQueryAll() {
		// 获取sqlSession
		SqlSession sqlSession = MyBatisUtils.openSession();
		// 获取OrderMapper
		OrderMapper orderMapper = sqlSession.getMapper(OrderMapper.class);

		// 执行查询
		List<Order> list = orderMapper.queryOrderAll();
		for (Order order : list) {
			System.out.println(order);
		}
	}

发现userId为null

解决方案：使用resultMap

1.4.5. 使用resultMap

? 由于上边的mapper.xml中sql查询列(user_id)和Order类属性(userId)不一致，所以查询结果不能映射到pojo中。需要定义resultMap，resultMap将sql查询列(user_id)和Order类属性(userId)对应起来

改造OrderMapper.xml，如下：

<?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">
<!-- namespace：命名空间，用于隔离sql，还有一个很重要的作用，Mapper动态代理开发的时候使用，需要指定Mapper的类路径 -->
<mapper namespace="com.qf.mapper.OrderMapper">

	<!-- resultMap最终还是要将结果映射到pojo上，type就是指定映射到哪一个pojo -->
	<!-- id：设置ResultMap的id -->
	<resultMap type="order" id="orderResultMap">
		<!-- 定义主键 ,非常重要。如果是多个字段,则定义多个id -->
		<!-- property：主键在pojo中的属性名 -->
		<!-- column：主键在数据库中的列名 -->
		<id property="id" column="id" />

		<!-- 定义普通属性 -->
		<result property="userId" column="user_id" />
		<result property="number" column="number" />
		<result property="createtime" column="createtime" />
		<result property="note" column="note" />
	</resultMap>

	<!-- 查询所有的订单数据 -->
	<select id="queryOrderAll" resultMap="orderResultMap">
		SELECT id, user_id,
		number,
		createtime, note FROM `order`
	</select>

</mapper>

再次测试数据没有问题。

1.5 类型转换器

每当MyBatis设置参数到PrepareStatement或者从ResultSet结果集中取值时，就会用到TypeHandler来处理数据库类型与Java类型之间的转换。

myBatis类型转换器适用于 Java实体类中的类型和数据库中的类型不对应时。

下图是默认的TypeHandler：

在这里插入图片描述
案例：假如User中包含一个对象属性Address,如果把数据库中address转成Address对象呢?

具体实现可以参考一下使用#{param1}，#{param2}的方式来获取具体哪一个参数，考虑可能是使用数组的方式来存放参数。这里也是类似的将preparedstatment的第i个参数更改为想要设置的东西。

(1)编写类型转换器

package com.qf.convert;

import com.qf.pojo.Address;
import org.apache.ibatis.type.JdbcType;
import org.apache.ibatis.type.TypeHandler;

import java.sql.CallableStatement;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

/**
 * wgy 2019/7/6 7:20
 */
public class AddressHandler implements TypeHandler<Address> {
    /**
     * /**
     * 	 * 此方法是在插入是进行设置参数
     * 	 * 参数：	PreparedStatement
     * 	 * 		int	i				为Jdbc预编译时设置参数的索引值
     * 	 * 		Address parameter			要插入的参数值
     * 	 * 		JdbcType jdbcType	要插入JDBC的类型
     *          */
    @Override
    public void setParameter(PreparedStatement ps, int i, Address parameter, JdbcType jdbcType) throws SQLException {
        if(parameter==null){
            ps.setString(i, null);
        }else{
            ps.setString(i, parameter.getAdd());
        }

    }

    /**
     * 该方法是获取参数时执行
     * 参数：	ResultSet rs		查询当前列数据
     * 	 *			String cloumnName	查询当前列名称
     * @param rs
     * @param columnName
     * @return
     * @throws SQLException
     */
    @Override
    public Address getResult(ResultSet rs, String columnName) throws SQLException {
        System.out.println(columnName);
        String value=rs.getString(columnName);
        Address address=new Address(value);
        return address;
    }

    @Override
    public Address getResult(ResultSet rs, int columnIndex) throws SQLException {
        System.out.println("xxxxxxxxx");
        return null;
    }

    @Override
    public Address getResult(CallableStatement cs, int columnIndex) throws SQLException {
        System.out.println("yyyyyyyyy");
        return null;
    }
}

(2)注册类型转换器

在mybatis的核心配置文件中添加

  <!--全局注册类型转换器-->
   <typeHandlers>
        <typeHandler handler="com.qf.convert.AddressHandler" javaType="com.qf.pojo.Address" jdbcType="VARCHAR"></typeHandler>
    </typeHandlers>

(3)测试

第二节：动态sql（重点）

通过mybatis提供的各种标签方法实现动态拼接sql。

需求：根据性别和名字查询用户

查询sql：

SELECT id, username, birthday, sex, address FROM user WHERE sex = 1 AND username LIKE '%张%';

2.1. If标签

2.1.1. Mapper.xml文件

UserMapper.xml配置sql，如下：

<select id="queryUserByWhere" parameterType="user" resultType="user">
	SELECT id, username, birthday, sex, address FROM `user`
	WHERE sex = #{sex} AND username LIKE '%${username}%'
</select>

2.1.2. Mapper接口

public interface UserMapper{
    List<User> queryUserByWhere(User user);
}

2.1.3. 测试方法

在UserMapperTest添加测试方法，如下：

@Test
public void testQueryUserByWhere() {
	SqlSession sqlSession = MyBatisUtils.openSession();
	
	UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
	User user = new User();
	user.setSex("1");
	user.setUsername("张");

	List<User> list = userMapper.queryUserByWhere(user);

	for (User u : list) {
		System.out.println(u);
	}
	sqlSession.close();
}

测试查看结果
如果注释掉user.setSex(1)
再次测试发现问题。
按照之前所学的，要解决这个问题，需要编写多个sql，查询条件越多，需要编写的sql就更多了，显然这样是不靠谱的。
解决方案，使用动态sql的if标签

2.1.5. 使用if标签

改造UserMapper.xml，如下：

<!-- 根据条件查询用户 -->
<select id="queryUserByWhere" parameterType="user" resultType="user">
	SELECT id, username, birthday, sex, address FROM `user`
	WHERE 1=1
	<if test="sex != null and sex != ''">
		AND sex = #{sex}
	</if>
	<if test="username != null and username != ''">
		AND username LIKE '%${username}%'
	</if>
</select>

注意字符串类型的数据需要做不等于空字符串校验。

再次测试没有问题。

2.2.Where标签

上面的sql还有where 1=1 这样的语句，很麻烦

可以使用where标签进行改造

改造UserMapper.xml，如下

<!-- 根据条件查询用户 -->
<select id="queryUserByWhere" parameterType="user" resultType="user">
	SELECT id, username, birthday, sex, address FROM `user`
<!-- where标签可以自动添加where，同时处理sql语句中第一个and 、or关键字 -->
	<where>
		<if test="sex != null">
			AND sex = #{sex}
		</if>
		<if test="username != null and username != ''">
			AND username LIKE
			'%${username}%'
		</if>
	</where>
</select>

2.3.Sql片段

Sql中可将重复的sql提取出来，使用时用include引用即可，最终达到sql重用的目的。

把上面例子中的id, username, birthday, sex, address提取出来，作为sql片段，如下：

<!-- 根据条件查询用户 -->
<select id="queryUserByWhere" parameterType="user" resultType="user">
	<!-- SELECT id, username, birthday, sex, address FROM `user` -->
	<!-- 使用include标签加载sql片段；refid是sql片段id -->
	SELECT <include refid="userFields" /> FROM `user`
	<!-- where标签可以自动添加where关键字，同时处理sql语句中第一个and关键字 -->
	<where>
		<if test="sex != null">
			AND sex = #{sex}
		</if>
		<if test="username != null and username != ''">
			AND username LIKE
			'%${username}%'
		</if>
	</where>
</select>

<!-- 声明sql片段 -->
<sql id="userFields">
	id, username, birthday, sex, address
</sql>

2.4. foreach标签

向sql传递数组或List，mybatis使用foreach解析，如下：

根据多个id查询用户信息

查询sql：

SELECT * FROM user WHERE id IN (1,10,24)

2.4.1.改造QueryVo

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

public class QueryVo {
   private User user;
   private List<Integer> ids;
}

2.4.2. Mapper.xml文件

UserMapper.xml添加sql，如下：

<!-- 根据ids查询用户 -->
<select id="queryUserByIds" parameterType="queryVo" resultType="user">
	SELECT * FROM `user`
	<where>
		<!-- foreach标签，进行遍历 -->
		<!-- collection：遍历的集合，这里是QueryVo的ids属性 -->
		<!-- item：遍历的项目，可以随便写，，但是和后面的#{}里面要一致 -->
		<!-- open：在前面添加的sql片段 -->
		<!-- close：在结尾处添加的sql片段 -->
		<!-- separator：指定遍历的元素之间使用的分隔符 -->
		<foreach collection="ids" item="item" open="id IN (" close=")"
			separator=",">
			#{item}
		</foreach>
	</where>
</select>

测试方法

@Test
public void testQueryUserByIds() {
	// MyBatis和spring整合，整合之后，交给spring管理
	SqlSession sqlSession = this.sqlSessionFactory.openSession();
	// 创建Mapper接口的动态代理对象，整合之后，交给spring管理
	UserMapper userMapper = sqlSession.getMapper(UserMapper.class);

	// 使用userMapper执行根据条件查询用户
	QueryVo queryVo = new QueryVo();
	List<Integer> ids = new ArrayList<>();
	ids.add(1);
	ids.add(10);
	ids.add(24);
	queryVo.setIds(ids);

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

	for (User u : list) {
		System.out.println(u);
	}

	// MyBatis和spring整合，整合之后，交给spring管理
	sqlSession.close();
}

第三节：关联查询

表之前的关系包括：一对一、一对多、多对多。

3.1. 一对一查询

需求：查询所有订单信息，关联查询订单用户信息。

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

使用sql语句：

SELECT o.id,o.user_id userId, o.number,o.createtime,o.note,u.username,u.address FROM
orders o LEFT JOIN user u 
ON o.user_id = u.id

方法一：使用resultType

使用resultType，改造订单pojo类，此pojo类中包括了订单信息和用户信息

这样返回对象的时候，mybatis自动把用户信息也注入进来了

OrderUser类继承Order类后OrderUser类包括了Order类的所有字段，只需要定义用户的信息字段即可，如下

public class OrderUser extends Order {
    private String username;
    private String addrss;

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getAddrss() {
        return addrss;
    }

    public void setAddrss(String addrss) {
        this.addrss = addrss;
    }
}

在UserMapper.xml添加sql，如下

<!-- 查询订单，同时包含用户数据 -->
<select id="queryOrderUser" resultType="orderUser">
	SELECT
	o.id,
	o.user_id
	userId,
	o.number,
	o.createtime,
	o.note,
	u.username,
	u.address
	FROM
	`order` o
	LEFT JOIN `user` u ON o.user_id = u.id
</select>

在UserMapper接口添加方法，如下：

public interface UserMapper {
	List<OrderUser> queryOrderUser();
}

在UserMapperTest添加测试方法，如下：

@Test
public void testQueryOrderUser() {
	
	SqlSession sqlSession = MyBatisUtils.openSession();
	
	UserMapper userMapper = sqlSession.getMapper(UserMapper.class);

	List<OrderUser> list = userMapper.queryOrderUser();

	for (OrderUser ou : list) {
		System.out.println(ou);
	}
	sqlSession.close();
}

定义专门的pojo类作为输出类型，其中定义了sql查询结果集所有的字段。此方法较为简单。

方法二：使用resultMap

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

改造pojo类

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

改造Order如下：

 	// 订单id
    private int id;
    // 用户id
    private Integer userId;
    // 订单号
    private String number;
    // 订单创建时间
    private Date createtime;
    // 备注
    private String note;
    // 用户
    private User user;

Mapper.xml

这里resultMap指定orderUserResultMap，如下：

<resultMap type="order" id="orderUserResultMap">
	<id property="id" column="id" />
	<result property="userId" column="user_id" />
	<result property="number" column="number" />
	<result property="createtime" column="createtime" />
	<result property="note" column="note" />

	<!-- association ：配置一对一属性 -->
	<!-- property:order里面的User属性名 -->
	<!-- javaType:属性类型 -->
	<association property="user" javaType="user">
		<!-- id:声明主键，表示user_id是关联查询对象的唯一标识-->
		<id property="id" column="user_id" />
		<result property="username" column="username" />
		<result property="address" column="address" />
	</association>

</resultMap>

<!-- 一对一关联，查询订单，订单内部包含用户属性 -->
<select id="queryOrderUserResultMap" resultMap="orderUserResultMap">
	SELECT
	o.id,
	o.user_id,
	o.number,
	o.createtime,
	o.note,
	u.username,
	u.address
	FROM
	`order` o
	LEFT JOIN `user` u ON o.user_id = u.id
</select>

Mapper接口

编写UserMapper如下：

List<Order> queryOrderUserResultMap();

测试方法

在UserMapperTest增加测试方法，如下：

@Test
public void testQueryOrderUserResultMap() {
	
	SqlSession sqlSession = MyBatisUtils.openSession();
	UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
	List<Order> list = userMapper.queryOrderUserResultMap();
	for (Order o : list) {
		System.out.println(o);
	}
	sqlSession.close();
}

3.2. 一对多查询

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

用户信息和订单信息为一对多关系。

sql语句：
SELECT
 u.id,
 u.username,
 u.birthday,
 u.sex,
 u.address,
 o.id oid,
 o.number,
 o.createtime,
 o.note
FROM
 user u
LEFT JOIN order o ON u.id = o.user_id

1.修改pojo类

在User类中加入Listorders属性,如下图：

public class User {   
	private Integer id;
    private String username;// 用户姓名
    private String sex;// 性别
    private Date birthday;// 生日
    private String address;// 地址
    private List<Order> orders;//订单
}

2.Mapper.xml

在UserMapper.xml添加sql，如下：

<resultMap type="user" id="userOrderResultMap">
	<id property="id" column="id" />
	<result property="username" column="username" />
	<result property="birthday" column="birthday" />
	<result property="sex" column="sex" />
	<result property="address" column="address" />

	<!-- 配置一对多的关系 -->
	<collection property="orders" javaType="list" ofType="order">
		<!-- 配置主键，是关联Order的唯一标识 -->
		<id property="id" column="oid" />
		<result property="number" column="number" />
		<result property="createtime" column="createtime" />
		<result property="note" column="note" />
	</collection>
</resultMap>

<!-- 一对多关联，查询订单同时查询该用户下的订单 -->
<select id="queryUserOrder" resultMap="userOrderResultMap">
	SELECT
	u.id,
	u.username,
	u.birthday,
	u.sex,
	u.address,
	o.id oid,
	o.number,
	o.createtime,
	o.note
	FROM
	`user` u
	LEFT JOIN `order` o ON u.id = o.user_id
</select>

3.Mapper接口

编写UserMapper接口，如下图：

public class UserMapper{
  	List<User> queryUserOrder();
}

4. 测试方法

在UserMapperTest增加测试方法，如下

@Test
public void testQueryUserOrder() {
	SqlSession sqlSession = MyBatisUtils.openSession();
	UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
	List<User> list = userMapper.queryUserOrder();

	for (User u : list) {
		System.out.println(u);
	}
	sqlSession.close();
}

第四节：Mybatis自动生成器

使用官方网站的Mapper自动生成工具mybatis-generator-core-1.3.7来生成po类和Mapper映射文件

官网地址:http://mybatis.org/generator/

github:https://github.com/mybatis/generator/releases

4.1 pom.xml文件中添加generator插件

插件依赖信息

<plugin>
  <groupId>org.mybatis.generator</groupId>
  <artifactId>mybatis-generator-maven-plugin</artifactId>
  <version>1.3.7</version>
  <executions>
    <execution>
      <id>Generate MyBatis Artifacts</id>
      <goals>
        <goal>generate</goal>
      </goals>
    </execution>
  </executions>
  <dependencies>
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.45</version>
    </dependency>
  </dependencies>
</plugin>

4.2添加加配置文件

在main\resources下在添加generatorConfig.xml中

配置如下：

<?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">

<generatorConfiguration>
	<context id="testTables" targetRuntime="MyBatis3">
		<commentGenerator>
			<!-- 是否去除自动生成的注释 true：是 ： false:否 -->
			<property name="suppressAllComments" value="true" />
		</commentGenerator>
		<!--数据库连接的信息：驱动类、连接地址、用户名、密码 -->
		<jdbcConnection driverClass="com.mysql.jdbc.Driver"
			connectionURL="jdbc:mysql://localhost:3306/mybatis_01" 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>
			<property name="forceBigDecimals" value="false" />
		</javaTypeResolver>

		<!-- targetProject:生成PO类的位置 -->
		<javaModelGenerator targetPackage="com.qf.xiaomi.pojo"
			targetProject="src/main/java">
			<!-- enableSubPackages:是否让schema作为包的后缀 -->
			<property name="enableSubPackages" value="false" />
			<!-- 从数据库返回的值被清理前后的空格 -->
			<property name="trimStrings" value="true" />
		</javaModelGenerator>
        <!-- targetProject:mapper映射文件生成的位置 -->
		<sqlMapGenerator targetPackage="com.qf.xiaomi.mapper"
			targetProject="src/main/java">
			<!-- enableSubPackages:是否让schema作为包的后缀 -->
			<property name="enableSubPackages" value="false" />
		</sqlMapGenerator>
		<!-- targetPackage：mapper接口生成的位置 -->
		<javaClientGenerator type="XMLMAPPER"
			targetPackage="com.qf.xiaomi.mapper"
			targetProject="src/main/java">
			<!-- enableSubPackages:是否让schema作为包的后缀 -->
			<property name="enableSubPackages" value="false" />
		</javaClientGenerator>
		<!-- 指定数据库表 -->
		<table schema="" tableName="user" domainObjectName="MyUser"></table>
		<table schema="" tableName="orders" domainObjectName="MyOrders"></table>
		
		<!-- 有些表的字段需要指定java类型
		 <table schema="" tableName="">
			<columnOverride column="" javaType="" />
		</table> -->
	</context>
</generatorConfiguration>

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

4.3编写测试方法

public class UserMapperTest{
	@Test
	public void testInsert() {
      	SqlSession sqlSession = MyBatisUtils.openSession();
		UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
		User user = new User();
		user.setUsername("刘德华");
		user.setSex("1");
		user.setBirthday(new Date());
		user.setAddress("香港");

		userMapper.insert(user);
	}

	@Test
	public void testSelectByExample() {
		SqlSession sqlSession = MyBatisUtils.openSession();
		UserMapper userMapper = sqlSession.getMapper(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() {
		SqlSession sqlSession = MyBatisUtils.openSession();
		UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
		User user = userMapper.selectByPrimaryKey(1);
		System.out.println(user);
	}
}

注意：

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

第五节：MyBatis的注解开发方式（了解）

从MyBatis3开始，注解提供了一种简单的方式来实现简单映射语句，这种方式不会引入大量的开销。但是灵活性较差，不易扩展。

Mybatis常用注解对应的目标和标签如表所示:

注解	目标	对应的XML标签
@Select	方法
@Insert	方法
@Update	方法
@Delete	方法
@Param	参数	无
@SelectKey	方法
@One	方法
@Many	方法

示例如下：

package com.qf.mapper;

import com.qf.pojo.User;
import org.apache.ibatis.annotations.*;

import java.util.List;

/**
 * wgy 2019/7/5 15:24
 */
public interface UserMapper {
    @Select(value = "select * from user where id=#{id}")
    public User queryById(Integer id);
    @Select(value = "select * from user")
    public List<User> queryAll();
    @Insert(value = "insert into user(username,birthday,sex,address) values(#{username},#{birthday},#{sex},#{address});")
    @SelectKey(keyProperty = "id",before = false,resultType = Integer.class,statement = "select LAST_INSERT_ID()")
    public void saveUser(User user);
    @Select(value = "select * from user where username like #{username} and sex=#{sex}")
    public List<User> findByWhere(@Param("username") String username, @Param("sex") String sex);
    @Update(value = "update user set username=#{username},birthday=#{birthday},sex=#{sex},address=#{address} where id=#{id}")
    public void updateUser(User user);

}

总结

输入参数和输出参数

? 输入参数: (1)简单类型： string 基本类型包装类 #{任意} ${value} ，可以传递多个简单类型 param1 param2 @Param("")

? (2) pojo 对象：#{属性} ${属性}

? (3) 包装 pojo：QueryVo

? (4) Map集合 Map<String,Object> #{key}

? (5) 集合和数组 list arrray

? 输出类型:

? (1) 简单类型：数据个数

? (2) list集合 selectList();

? (3) pojo对象 selectOne();

? (4) resultMap配置对象属性和数据库的表的列名不一致使用

? 类型转换器 TypeHandler接口

? 注册

动态sql

关联查询

? 一对一 association

? 一对多 collection

MyBatis自动生成器

注解方式

松松啊

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
04.mybatis高级应用

Mybatis02-高级应用第一节：输入参数和输出参数Mapper.xml映射文件中定义了操作数据库的sql，每个sql是一个statement，映射文件是mybatis的核心。1.1 环境准备第一步：创建项目添加依赖项目名称：day04_mybatis01依赖信息如下：<dependencies> <dependency> &l...
复制链接

扫一扫