Mybatis的学习（2）

一时失言乱红尘 2024-04-17 20:13 5阅读 0赞

# Mybatis的学习（2） #

# 1.输入映射和输出映射 #

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

## 1.1.环境准备 ##

1.  复制昨天的工程，如下图![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZtazEwMjM_size_16_color_FFFFFF_t_70]
2.  只保留Mapper接口开发相关的文件，其他的删除  
    最终效果如下图：![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZtazEwMjM_size_16_color_FFFFFF_t_70 1]  
    3.如下图修改SqlMapConfig.xml配置文件。Mapper映射器只保留包扫描的方式

<?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>
    	
    	<properties resource="db.properties"></properties>
    <typeAliases>
    		<package name="com.igeek" />
    	</typeAliases>
    
    	
    	<environments default="development">
    		<environment id="development">
    			
    			<transactionManager type="JDBC" />
    			
    			<dataSource type="POOLED">
    				<property name="driver" value="${jdbc.driver}" />
    				<property name="url" value="${jdbc.url}" />
    				<property name="username" value="${jdbc.username}" />
    				<property name="password" value="${jdbc.password}" />
    			</dataSource>
    		</environment>
    	</environments>
    
    	
    	<mappers>
    		
    		<package name="com.igeek"/>
    	</mappers>
    </configuration>

## 1.2.parameterType(输入类型) ##

### 1.2.1.传递简单类型 ###

参考第一天内容。  
使用\#\{\}占位符，或者$\{\}进行sql拼接。

### 1.2.2.传递pojo对象 ###

参考第一天的内容。  
Mybatis使用ognl表达式解析对象字段的值，\#\{\}或者$\{\}括号中的值为pojo属性名称。

### 1.2.3.传递pojo包装对象 ###

开发中可以使用pojo传递查询条件。

查询条件可能是综合的查询条件，不仅包括用户查询条件还包括其它的查询条件（比如查询用户信息的时候，将用户购买商品信息也作为查询条件），这时可以使用包装对象传递输入参数。  
包装对象：Pojo类中的一个属性是另外一个pojo。

需求：根据用户名模糊查询用户信息，查询条件放到QueryVo的user属性中。

#### 1.2.3.1.编写QueryVo ####

public class QueryVo {
      	// 包含其他的pojo
    	private User user;
    
    	public User getUser() {
    		return user;
    	}
    	public void setUser(User user) {
    		this.user = user;
    	}
    }

#### 1.2.3.2.Sql语句 ####

SELECT \* FROM user WHERE username LIKE ‘%张%’

#### 1.2.3.3.Mapper.xml文件 ####

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

<select id="queryUserByQueryVo" parameterType="queryVo" resultType="user">
    		SELECT * FROM `user` WHERE username LIKE '%${user.username}%'
    	</select>

#### 1.2.3.4.Mapper接口 ####

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

/**
    	 * 
    	* @Title: queryUserByQueryVo  
    	* @Description: TODO(根据包装类查询用户)  
    	* @param queryVo
    	* @return
    	 */
    	List<User> queryUserByQueryVo(QueryVo queryVo);

#### 1.2.3.5.测试方法 ####

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

@Test
    public void testQueryUserByQueryVo() {
    	// mybatis和spring整合，整合之后，交给spring管理
    	SqlSession sqlSession = this.sqlSessionFactory.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.queryUserByQueryVo(queryVo);
    	for (User u : list) {
    		System.out.println(u);
    	}
    
    	// mybatis和spring整合，整合之后，交给spring管理
    	sqlSession.close();
    }

#### 1.2.3.6.效果 ####

测试结果如下图：![在这里插入图片描述][20190831114123302.png]

## 1.3.resultType(输出类型) ##

### 1.3.1.输出简单类型 ###

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

sql：SELECT count(*) FROM `user`

#### 1.3.1.1.Mapper.xml文件 ####

在UserMapper.xml中配置sql：

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

#### 1.3.1.2.Mapper接口 ####

在UserMapper添加方法：

/**
    	 * 
    	* @Title: queryUserCount  
    	* @Description: TODO(这里用一句话描述这个方法的作用)  
    	* @return
    	 */
    	int queryUserCount();

#### 1.3.1.3.测试方法 ####

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

@Test
    public void testQueryUserCount() {
    	// mybatis和spring整合，整合之后，交给spring管理
    	SqlSession sqlSession = this.sqlSessionFactory.openSession();
    	// 创建Mapper接口的动态代理对象，整合之后，交给spring管理
    	UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
    
    	// 使用userMapper执行查询用户数据条数
    	int count = userMapper.queryUserCount();
    	System.out.println(count);
    
    	// mybatis和spring整合，整合之后，交给spring管理
    	sqlSession.close();
    }

#### 1.3.1.4.效果 ####

测试结果如下图：  
![在这里插入图片描述][20190831114257107.png]  
注意：输出简单类型必须查询出来的结果集有一条记录，最终将第一个字段的值转换为输出类型。

### 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 `order`

### 1.4.1.声明pojo对象 ###

数据库表如下图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZtazEwMjM_size_16_color_FFFFFF_t_70 2]  
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配置文件，如下：

### 1.4.3.Mapper接口 ###

编写接口如下：

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

### 1.4.4.测试方法 ###

编写测试方法OrderMapperTest如下：

public class OrderMapperTest {
    	private SqlSessionFactory sqlSessionFactory;
    
    	@Before
    	public void init() throws Exception {
    		InputStream inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
    		this.sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
    	}
    
    	@Test
    	public void testQueryAll() {
    		// 获取sqlSession
    		SqlSession sqlSession = this.sqlSessionFactory.openSession();
    		// 获取OrderMapper
    		OrderMapper orderMapper = sqlSession.getMapper(OrderMapper.class);
    
    		// 执行查询
    		List<Order> list = orderMapper.queryOrderAll();
    		for (Order order : list) {
    			System.out.println(order);
    		}
    	}
    }

### 1.4.5.效果 ###

测试效果如下图：  
![在这里插入图片描述][20190831114448574.png]  
发现userId为null  
解决方案：使用resultMap

### 1.4.6.使用resultMap ###

由于上边的mapper.xml中sql查询列(user\_id)和Order类属性(userId)不一致，所以查询结果不能映射到pojo中。  
需要定义resultMap，把orderResultMap将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">
    
    <mapper namespace="com.igeek.mapper.OrderMapper">
    
    	
    	
    	<resultMap type="order" id="orderResultMap">
    		
    		
    		
    		<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 `orders`
    	</select>
    
    </mapper>

### 1.4.7.效果 ###

只需要修改Mapper.xml就可以了，再次测试结果如下：  
![在这里插入图片描述][20190831114532301.png]

# 2.动态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接口 ###

编写Mapper接口：

/**
    	 * 
    	* @Title: queryUserByWhere  
    	* @Description: 根据条件查询用户
    	* @param user
    	* @return
    	 */
    	List<User> queryUserByWhere(User user);

### 2.1.3.测试方法 ###

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

@Test
    public void testQueryUserByWhere() {
    	// mybatis和spring整合，整合之后，交给spring管理
    	SqlSession sqlSession = this.sqlSessionFactory.openSession();
    	// 创建Mapper接口的动态代理对象，整合之后，交给spring管理
    	UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
    
    	// 使用userMapper执行根据条件查询用户
    	User user = new User();
    	user.setSex("1");
    	user.setUsername("张");
    
    	List<User> list = userMapper.queryUserByWhere(user);
    
    	for (User u : list) {
    		System.out.println(u);
    	}
    
    	// mybatis和spring整合，整合之后，交给spring管理
    	sqlSession.close();
    }

### 2.1.4.效果 ###

测试效果如下图：  
![在这里插入图片描述][20190901112208865.png]  
如果注释掉 user.setSex(“1”)，测试结果如下图：  
![在这里插入图片描述][20190901112221302.png]  
测试结果二很显然不合理。  
按照之前所学的，要解决这个问题，需要编写多个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.1.6.效果 ###

![在这里插入图片描述][20190901112255468.png]  
如上图所示，测试OK

## 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>
    		<if test="sex != null">
    			AND sex = #{sex}
    		</if>
    		<if test="username != null and username != ''">
    			AND username LIKE
    			'%${username}%'
    		</if>
    	</where>
    </select>

### 2.2.1.效果 ###

测试效果如下图：  
![在这里插入图片描述][20190901112327599.png]

## 2.3.Sql片段 ##

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

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

<select id="queryUserByWhere" parameterType="user" resultType="user">
    	
    	
    	SELECT <include refid="userFields" /> FROM `user`
    	
    	<where>
    		<if test="sex != null">
    			AND sex = #{sex}
    		</if>
    		<if test="username != null and username != ''">
    			AND username LIKE
    			'%${username}%'
    		</if>
    	</where>
    </select>
    
    
    <sql id="userFields">
    	id, username, birthday, sex, address
    </sql>

如果要使用别的Mapper.xml配置的sql片段，可以在refid前面加上对应的Mapper.xml的namespace  
例如下图  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZtazEwMjM_size_16_color_FFFFFF_t_70 3]

## 2.4.foreach标签 ##

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

根据多个id查询用户信息  
查询sql：  
SELECT \* FROM user WHERE id IN (1,10,24)

### 2.4.1.改造QueryVo ###

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

public class QueryVo {
    	// 包含其他的pojo
    	private User user;
    	
    	private List<Integer> ids;
    
    	public List<Integer> getIds() {
    		return ids;
    	}
    	public void setIds(List<Integer> ids) {
    		this.ids = ids;
    	}
    	public User getUser() {
    		return user;
    	}
    	public void setUser(User user) {
    		this.user = user;
    	}
    }

### 2.4.2.Mapper.xml文件 ###

UserMapper.xml添加sql，如下：

<select id="queryUserByIds" parameterType="queryVo" resultType="user">
    	SELECT * FROM `user`
    	<where>
    		
    		
    		
    		
    		
    		
    		<foreach collection="ids" item="item" open="id IN (" close=")"
    			separator=",">
    			#{item}
    		</foreach>
    	</where>
    </select>

在UserMapper接口中添加如下方法

List<User>  queryUserByIds(QueryVo queryVo);

测试方法如下图：

@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();
    }

### 2.4.3.效果 ###

测试效果如下图：  
![在这里插入图片描述][20190901112600520.png]

# 3.关联查询 #

## 3.1.商品订单数据模型 ##

![在这里插入图片描述][20190901113709980.png]

## 3.2.一对一查询 ##

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

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

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`

### 3.2.1.方法一：使用resultType ###

使用resultType，改造订单pojo类，此pojo类中包括了订单信息和用户信息  
这样返回对象的时候，mybatis自动把用户信息也注入进来了

#### 3.2.1.1.改造pojo类 ####

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

public class OrderUser extends Order{
    	private String username;
    	private String address;
    	public String getUsername() {
    		return username;
    	}
    	public void setUsername(String username) {
    		this.username = username;
    	}
    	public String getAddress() {
    		return address;
    	}
    	public void setAddress(String address) {
    		this.address = address;
    	}
    }

#### 3.2.1.2.Mapper.xml ####

在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
    	`orders` o
    	LEFT JOIN `user` u ON o.user_id = u.id
    </select>

#### 3.2.1.3.Mapper接口 ####

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

/**
    	 * 
    	* @Title: queryOrderUser  
    	* @Description: TODO(一对一关联，查询订单同时包含用户信息)  
    	* @return
    	 */
    	List<OrderUser> queryOrderUser();

#### 3.2.1.4.测试方法： ####

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

@Test
    public void testQueryOrderUser() {
    	// mybatis和spring整合，整合之后，交给spring管理
    	SqlSession sqlSession = this.sqlSessionFactory.openSession();
    	// 创建Mapper接口的动态代理对象，整合之后，交给spring管理
    	UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
    
    	// 使用userMapper执行根据条件查询用户
    	List<OrderUser> list = userMapper.queryOrderUser();
    
    	for (OrderUser ou : list) {
    		System.out.println(ou);
    	}
    
    	// mybatis和spring整合，整合之后，交给spring管理
    	sqlSession.close();
    }

#### 3.2.1.5.效果 ####

测试结果如下图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZtazEwMjM_size_16_color_FFFFFF_t_70 4]

#### 3.2.1.6.小结 ####

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

### 3.2.2.方法二：使用resultMap ###

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

#### 3.2.2.1.改造pojo类 ####

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

改造Order如下代码：

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

#### 3.2.2.2.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="user" javaType="user">
    		
    		<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
    	`orders` o
    	LEFT JOIN `user` u ON o.user_id = u.id
    </select>

#### 3.2.2.3.Mapper接口 ####

编写UserMapper如下代码：

/**
    	 * 
    	* @Title: queryOrderUserResultMap  
    	* @Description: TODO(一对一关联，查询订单，订单内部包含用户属性	)  
    	* @return
    	 */
    	List<Order> queryOrderUserResultMap();

#### 3.2.2.4.测试方法 ####

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

@Test
    public void testQueryOrderUserResultMap() {
    	// mybatis和spring整合，整合之后，交给spring管理
    	SqlSession sqlSession = this.sqlSessionFactory.openSession();
    	// 创建Mapper接口的动态代理对象，整合之后，交给spring管理
    	UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
    
    	// 使用userMapper执行根据条件查询用户
    	List<Order> list = userMapper.queryOrderUserResultMap();
    
    	for (Order o : list) {
    		System.out.println(o);
    	}
    
    	// mybatis和spring整合，整合之后，交给spring管理
    	sqlSession.close();
    }

#### 3.2.2.5.效果 ####

测试效果如下图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZtazEwMjM_size_16_color_FFFFFF_t_70 5]

## 3.3.一对多查询 ##

案例：查询所有用户信息及用户关联的订单信息。  
用户信息和订单信息为一对多关系。

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 `orders` o ON u.id = o.user_id

### 3.3.1.修改pojo类 ###

在User类中加入List orders属性,如下图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZtazEwMjM_size_16_color_FFFFFF_t_70 6]

### 3.3.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">
    		
    		<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 `orders` o ON u.id = o.user_id
    </select>

### 3.3.3.Mapper接口 ###

编写UserMapper接口，如下图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZtazEwMjM_size_16_color_FFFFFF_t_70 7]

### 3.3.4.测试方法 ###

在UserMapperTest增加测试方法，如下

@Test
    public void testQueryUserOrder() {
    	// mybatis和spring整合，整合之后，交给spring管理
    	SqlSession sqlSession = this.sqlSessionFactory.openSession();
    	// 创建Mapper接口的动态代理对象，整合之后，交给spring管理
    	UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
    
    	// 使用userMapper执行根据条件查询用户
    	List<User> list = userMapper.queryUserOrder();
    
    	for (User u : list) {
    		System.out.println(u);
    	}
    
    	// mybatis和spring整合，整合之后，交给spring管理
    	sqlSession.close();
    }

### 3.3.5.效果 ###

测试效果如下图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZtazEwMjM_size_16_color_FFFFFF_t_70 8]

# 4.Mybatis整合spring #

## 4.1.整合思路 ##

1、SqlSessionFactory对象应该放到spring容器中作为单例存在。  
2、传统dao的开发方式中，应该从spring容器中获得sqlsession对象。  
3、Mapper代理形式中，应该从spring容器中直接获得mapper的代理对象。  
4、数据库的连接以及数据库连接池事务管理都交给spring容器来完成。  
4.2.整合需要的jar包  
1、spring的jar包  
2、Mybatis的jar包  
3、Spring+mybatis的整合包。  
4、Mysql的数据库驱动jar包。  
5、数据库连接池的jar包。  
jar包位置如下所示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZtazEwMjM_size_16_color_FFFFFF_t_70 9]

## 4.3.整合的步骤 ##

### 4.3.1.创建工程 ###

如下图创建一个web工程：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZtazEwMjM_size_16_color_FFFFFF_t_70 10]

### 4.3.2.导入jar包 ###

前面提到的jar包需要导入，如下图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZtazEwMjM_size_16_color_FFFFFF_t_70 11]

### 4.3.3.加入配置文件 ###

1.mybatisSpring的配置文件  
2.的配置文件sqlmapConfig.xml  
a)数据库连接及连接池  
b)事务管理（暂时可以不配置）  
c)sqlsessionFactory对象，配置到spring容器中  
d)mapeer代理对象或者是dao实现类配置到spring容器中。

创建资源文件夹config拷贝加入配置文件，如下图  
![在这里插入图片描述][20190901114638260.png]

#### 4.3.3.1.SqlMapConfig.xml ####

配置文件是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">
    <configuration>
    	
    	<typeAliases>
    		
    		<package name="com.igeek.pojo" />
    	</typeAliases>
    
    </configuration>

#### 4.3.3.2.applicationContext.xml ####

SqlSessionFactoryBean属于mybatis-spring这个jar包  
对于spring来说，mybatis是另外一个架构，需要整合jar包。

在项目中加入mybatis-spring-1.2.2.jar的源码，如下图  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZtazEwMjM_size_16_color_FFFFFF_t_70 12]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZtazEwMjM_size_16_color_FFFFFF_t_70 13]  
效果，如下图所示，图标变化，表示源码加载成功：  
![在这里插入图片描述][20190901114751573.png]  
整合Mybatis需要的是SqlSessionFactoryBean，位置如下图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZtazEwMjM_size_16_color_FFFFFF_t_70 14]  
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">
    		<property name="driverClassName" value="${jdbc.driver}" />
    		<property name="url" value="${jdbc.url}" />
    		<property name="username" value="${jdbc.username}" />
    		<property name="password" value="${jdbc.password}" />
    		<property name="maxActive" value="10" />
    		<property name="maxIdle" value="5" />
    	</bean>
    
    	
    	<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    		
    		<property name="configLocation" value="classpath:SqlMapConfig.xml" />
    		
    		<property name="dataSource" ref="dataSource" />
    	</bean>
    </beans>

#### 4.3.3.3.db.properties ####

jdbc.driver=com.mysql.jdbc.Driver
    jdbc.url=jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8
    jdbc.username=root
    jdbc.password=root

#### 4.3.3.4.log4j.properties ####

# Global logging configuration
    log4j.rootLogger=DEBUG, stdout
    # Console output...
    log4j.appender.stdout=org.apache.log4j.ConsoleAppender
    log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
    log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n

#### 4.3.3.5.效果： ####

加入的配置文件最终效果如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZtazEwMjM_size_16_color_FFFFFF_t_70 15]

## 4.4.Dao的开发 ##

两种dao的实现方式：  
1、原始dao的开发方式  
2、使用Mapper代理形式开发方式  
a)直接配置Mapper代理  
b)使用扫描包配置Mapper代理

需求：  
1.实现根据用户id查询  
2.实现根据用户名模糊查询  
3.添加用户

### 4.4.1.创建pojo ###

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

### 4.4.2.传统dao的开发方式 ###

原始的DAO开发接口+实现类来完成。  
需要dao实现类需要继承SqlsessionDaoSupport类

#### 4.4.2.1.实现Mapper.xml ####

编写User.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">
    <mapper namespace="test">
    	
    	<select id="queryUserById" parameterType="int" resultType="user">
    		select * from user where id = #{id}
    	</select>
    
    	
    	<select id="queryUserByUsername" parameterType="string"
    		resultType="user">
    		select * from user where username like '%${value}%'
    	</select>
    
    	
    	<insert id="saveUser" parameterType="user">
    		<selectKey keyProperty="id" keyColumn="id" order="AFTER"
    			resultType="int">
    			select last_insert_id()
    		</selectKey>
    		insert into user
    		(username,birthday,sex,address)
    		values
    		(#{username},#{birthday},#{sex},#{address})
    	</insert>
    
    </mapper>

#### 4.4.2.2.加载Mapper.xml ####

在SqlMapConfig如下图进行配置:  
![在这里插入图片描述][20190901115023466.png]

#### 4.4.2.3.实现UserDao接口 ####

public interface UserDao {
    	/**
    	 * 根据id查询用户
    	 * 
    	 * @param id
    	 * @return
    	 */
    	User queryUserById(int id);
    
    	/**
    	 * 根据用户名模糊查询用户列表
    	 * 
    	 * @param username
    	 * @return
    	 */
    	List<User> queryUserByUsername(String username);
    
    	/**
    	 * 保存
    	 * 
    	 * @param user
    	 */
    	void saveUser(User user);
    
    }

#### 4.4.2.4.实现UserDaoImpl实现类 ####

编写DAO实现类，实现类必须集成SqlSessionDaoSupport  
SqlSessionDaoSupport提供getSqlSession()方法来获取SqlSession

public class UserDaoImpl extends SqlSessionDaoSupport implements UserDao {
    	@Override
    	public User queryUserById(int id) {
    		// 获取SqlSession
    		SqlSession sqlSession = super.getSqlSession();
    
    		// 使用SqlSession执行操作
    		User user = sqlSession.selectOne("queryUserById", id);
    
    		// 不要关闭sqlSession
    
    		return user;
    	}
    
    	@Override
    	public List<User> queryUserByUsername(String username) {
    		// 获取SqlSession
    		SqlSession sqlSession = super.getSqlSession();
    
    		// 使用SqlSession执行操作
    		List<User> list = sqlSession.selectList("queryUserByUsername", username);
    
    		// 不要关闭sqlSession
    
    		return list;
    	}
    
    	@Override
    	public void saveUser(User user) {
    		// 获取SqlSession
    		SqlSession sqlSession = super.getSqlSession();
    
    		// 使用SqlSession执行操作
    		sqlSession.insert("saveUser", user);
    
    		// 不用提交,事务由spring进行管理
    		// 不要关闭sqlSession
    	}
    }

#### 4.4.2.5.配置dao ####

把dao实现类配置到spring容器中，如下图

<bean id="userDao" class="com.igeek.dao.UserDaoImpl">
    		
    		<property name="sqlSessionFactory" ref="sqlSessionFactory"></property>
    	</bean>

#### 4.4.2.6.测试方法 ####

创建测试方法，可以直接创建测试Junit用例。  
创建包：com.igeek.test

编写测试方法如下：

public class UserDaoTest {
    	private ApplicationContext context;
    
    	@Before
    	public void setUp() throws Exception {
    		this.context = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
    	}
    
    	@Test
    	public void testQueryUserById() {
    		// 获取userDao
    		UserDao userDao = this.context.getBean(UserDao.class);
    
    		User user = userDao.queryUserById(1);
    		System.out.println(user);
    	}
    
    	@Test
    	public void testQueryUserByUsername() {
    		// 获取userDao
    		UserDao userDao = this.context.getBean(UserDao.class);
    
    		List<User> list = userDao.queryUserByUsername("张");
    		for (User user : list) {
    			System.out.println(user);
    		}
    	}
    
    	@Test
    	public void testSaveUser() {
    		// 获取userDao
    		UserDao userDao = this.context.getBean(UserDao.class);
    
    		User user = new User();
    		user.setUsername("曹操");
    		user.setSex("1");
    		user.setBirthday(new Date());
    		user.setAddress("三国");
    		userDao.saveUser(user);
    		System.out.println(user);
    	}
    }

### 4.4.3.Mapper代理形式开发dao ###

#### 4.4.3.1.实现Mapper.xml ####

编写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">
    <mapper namespace="com.igeek.mapper.UserMapper">
    	
    	<select id="queryUserById" parameterType="int" resultType="user">
    		select * from user where id = #{id}
    	</select>
    
    	
    	<select id="queryUserByUsername" parameterType="string"
    		resultType="user">
    		select * from user where username like '%${value}%'
    	</select>
    
    	
    	<insert id="saveUser" parameterType="user">
    		<selectKey keyProperty="id" keyColumn="id" order="AFTER"
    			resultType="int">
    			select last_insert_id()
    		</selectKey>
    		insert into user
    		(username,birthday,sex,address) values
    		(#{username},#{birthday},#{sex},#{address})
    	</insert>
    </mapper>

#### 4.4.3.2.实现UserMapper接口 ####

public interface UserMapper {
    	/**
    	 * 根据用户id查询
    	 * 
    	 * @param id
    	 * @return
    	 */
    	User queryUserById(int id);
    
    	/**
    	 * 根据用户名模糊查询用户
    	 * 
    	 * @param username
    	 * @return
    	 */
    	List<User> queryUserByUsername(String username);
    
    	/**
    	 * 添加用户
    	 * 
    	 * @param user
    	 */
    	void saveUser(User user);
    }

#### 4.4.3.3.方式一：配置mapper代理 ####

在applicationContext.xml添加配置  
MapperFactoryBean也是属于mybatis-spring整合包

<bean id="userMapper" class="org.mybatis.spring.mapper.MapperFactoryBean">
    	
    	<property name="mapperInterface" value="com.igeek.mapper.UserMapper" />
    	
    	<property name="sqlSessionFactory" ref="sqlSessionFactory" />
    </bean>

#### 4.4.3.4.测试方法 ####

public class UserMapperTest {
    	private ApplicationContext context;
    
    	@Before
    	public void setUp() throws Exception {
    		this.context = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
    	}
    
    	@Test
    	public void testQueryUserById() {
    		// 获取Mapper
    		UserMapper userMapper = this.context.getBean(UserMapper.class);
    
    		User user = userMapper.queryUserById(1);
    		System.out.println(user);
    	}
    
    	@Test
    	public void testQueryUserByUsername() {
    		// 获取Mapper
    		UserMapper userMapper = this.context.getBean(UserMapper.class);
    
    		List<User> list = userMapper.queryUserByUsername("张");
    
    		for (User user : list) {
    			System.out.println(user);
    		}
    	}
    	@Test
    	public void testSaveUser() {
    		// 获取Mapper
    		UserMapper userMapper = this.context.getBean(UserMapper.class);
    
    		User user = new User();
    		user.setUsername("曹操");
    		user.setSex("1");
    		user.setBirthday(new Date());
    		user.setAddress("三国");
    
    		userMapper.saveUser(user);
    		System.out.println(user);
    	}
    }

#### 4.4.3.5.方式二：扫描包形式配置mapper ####

<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    	
    	<property name="basePackage" value="com.igeek.mapper" />
    </bean>

每个mapper代理对象的id就是类名，首字母小写

# 5.Mybatis逆向工程 #

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

## 5.1.导入逆向工程 ##

使用课前资料已有逆向工程，如下图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZtazEwMjM_size_16_color_FFFFFF_t_70 16]

### 5.1.1.导入逆向工程到eclipse中 ###

如下图方式进行导入：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZtazEwMjM_size_16_color_FFFFFF_t_70 17]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZtazEwMjM_size_16_color_FFFFFF_t_70 18]

## 5.2.修改配置文件 ##

在generatorConfig.xml中配置Mapper生成的详细信息，如下图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZtazEwMjM_size_16_color_FFFFFF_t_70 19]  
注意修改以下几点:  
1.修改要生成的数据库表  
2.pojo文件所在包路径  
3.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">
    
    <generatorConfiguration>
    	<context id="testTables" targetRuntime="MyBatis3">
    		<commentGenerator>
    			
    			<property name="suppressAllComments" value="true" />
    		</commentGenerator>
    		
    		<jdbcConnection driverClass="com.mysql.jdbc.Driver"
    			connectionURL="jdbc:mysql://localhost:3306/mybatis" userId="root" password="root">
    		</jdbcConnection>
    		
    
    		
    		<javaTypeResolver>
    			<property name="forceBigDecimals" value="false" />
    		</javaTypeResolver>
    
    		
    		<javaModelGenerator targetPackage="com.igeek.ssm.po"
    			targetProject=".\src">
    			
    			<property name="enableSubPackages" value="false" />
    			
    			<property name="trimStrings" value="true" />
    		</javaModelGenerator>
    		
    		<sqlMapGenerator targetPackage="com.igeek.ssm.mapper"
    			targetProject=".\src">
    			
    			<property name="enableSubPackages" value="false" />
    		</sqlMapGenerator>
    		
    		<javaClientGenerator type="XMLMAPPER"
    			targetPackage="com.igeek.ssm.mapper" targetProject=".\src">
    			
    			<property name="enableSubPackages" value="false" />
    		</javaClientGenerator>
    		
    		<table schema="" tableName="user"></table>
    		<table schema="" tableName="orders"></table>
    	</context>
    </generatorConfiguration>

## 5.3.生成逆向工程代码 ##

找到下图所示的java文件，执行工程main主函数,  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZtazEwMjM_size_16_color_FFFFFF_t_70 20]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZtazEwMjM_size_16_color_FFFFFF_t_70 21]  
刷新工程，发现代码生成，如下图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZtazEwMjM_size_16_color_FFFFFF_t_70 22]

## 5.4.测试逆向工程代码 ##

1.  复制生成的代码到mybatis\_d02\_c05工程，如下图  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZtazEwMjM_size_16_color_FFFFFF_t_70 23]
2.  修改spring配置文件  
    在applicationContext.xml修改

<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    	
    	
    	<property name="basePackage" value="com.igeek.ssm.mapper" />
    </bean>

1.  编写测试方法：

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);
    	}
    }

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

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZtazEwMjM_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/a20fe92745c2437389f09184b3af8f5b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZtazEwMjM_size_16_color_FFFFFF_t_70 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/59fe80c5dd274208ae4ba13c576fdad4.png
[20190831114123302.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/d74ee8a696a54050ad93cbaa916843d1.png
[20190831114257107.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/9ca9b5f087514569997b23c825bc0a91.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZtazEwMjM_size_16_color_FFFFFF_t_70 2]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/01cd9e72f9a14d3db8d74d8934bbf494.png
[20190831114448574.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/95b9d5c87d014da59b7cec2effec5c95.png
[20190831114532301.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/dc38bd078b4d4efa8dcf2bdce312ce5b.png
[20190901112208865.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/2ecf0d2cac67452086edfd568c4ff412.png
[20190901112221302.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/09f3bc3ca551495ca5db7a599e1d89be.png
[20190901112255468.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/7563d6664662461a82702e3c51792f35.png
[20190901112327599.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/19654f6e284a446eaea36084e11cab8a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZtazEwMjM_size_16_color_FFFFFF_t_70 3]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/3213ff599f9a4131bf979bd68b890ec5.png
[20190901112600520.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/d4a59aa6f5d140c488e2582970b1878f.png
[20190901113709980.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/bc83ff0a39ca4a60b91f3d7fe7097fb9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZtazEwMjM_size_16_color_FFFFFF_t_70 4]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/f7556375d8884128986e4bf0fca13907.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZtazEwMjM_size_16_color_FFFFFF_t_70 5]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/0eccac2c296a439986a257c10a24bc82.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZtazEwMjM_size_16_color_FFFFFF_t_70 6]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/1eb73f7df4c24310a38e3e5b64359cdc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZtazEwMjM_size_16_color_FFFFFF_t_70 7]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/784a7b57a3714e068a58b2b29aa6c9e0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZtazEwMjM_size_16_color_FFFFFF_t_70 8]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/da07cc64e5a8404588937cc43cccaec8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZtazEwMjM_size_16_color_FFFFFF_t_70 9]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/6857cebe987a41209960a58d0cd5bdf4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZtazEwMjM_size_16_color_FFFFFF_t_70 10]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/3c93caf4e2c24434ac66bd00043d7019.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZtazEwMjM_size_16_color_FFFFFF_t_70 11]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/ba01ab3d7a23411491c65c42c157d911.png
[20190901114638260.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/9dd8a8229e024ef1b53e41910953c700.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZtazEwMjM_size_16_color_FFFFFF_t_70 12]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/bfa5152a02a04d95a1863ca84f229eec.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZtazEwMjM_size_16_color_FFFFFF_t_70 13]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/9479c8d52b6c4d31a1ddd784e9b6b6c3.png
[20190901114751573.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/6869445ac3324372aabddc884a376f8a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZtazEwMjM_size_16_color_FFFFFF_t_70 14]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/94cd163ec2c145bc9f5a352c4348dd0c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZtazEwMjM_size_16_color_FFFFFF_t_70 15]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/e6bd97cdddbd4555824b7016ddcba7da.png
[20190901115023466.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/5f1f0c8d517448439c2d2bcbfe64ec9b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZtazEwMjM_size_16_color_FFFFFF_t_70 16]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/67c9630ed29b418eabf63d2251684752.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZtazEwMjM_size_16_color_FFFFFF_t_70 17]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/d8007d5644fb488db005d9aebd31148c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZtazEwMjM_size_16_color_FFFFFF_t_70 18]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/f81249a863c7400ca2db751d8d243df4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZtazEwMjM_size_16_color_FFFFFF_t_70 19]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/6f051e73eb0f44138158e3b0441125dc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZtazEwMjM_size_16_color_FFFFFF_t_70 20]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/67bc452781214f8ab0e8ae8d56f2e9da.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZtazEwMjM_size_16_color_FFFFFF_t_70 21]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/b4a44f0693b540eaaaef92e38d78768a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZtazEwMjM_size_16_color_FFFFFF_t_70 22]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/a507cf8aa7504007aebd469531f6bf9a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZtazEwMjM_size_16_color_FFFFFF_t_70 23]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/e6a465fc5b594010a622eae35335ba7b.png