上一篇👉:MyBatis----自定义mybatis的分析和实现（一）
文章目录
🚴大家好！我是近视的脚踏实地，后边这系列主要是记录自己MyBatis的学习笔记，这篇文章主要来继续学习自定义mybatis的分析的实现
唯有行动 才能解除你所有的不安
4 自定义mybatis的编码–解析XML工具类的介绍
先把工具类复制粘贴，然后会报很多错
package monster.zf.mybatis.utils;
import com.sun.org.apache.bcel.internal.generic.Select;
import monster.zf.mybatis.io.Resources;
import javax.security.auth.login.Configuration;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.ParameterizedType;
/**
* @author Monster丶ZF
* @version 1.8
* @remakeTodo 用于解析配置文件
* @Package monster.zf.mybatis.utils
* @date 2020/11/6 9:45
*/
public class XMLConfigBuilder {
/**
* 解析主配置文件，把里面的内容填充到DefaultSqlSession所需要的地方
* 使用的技术：
* dom4j+xpath
*/
public static Configuration loadConfiguration(InputStream config){
try{
//定义封装连接信息的配置对象（mybatis的配置对象）
Configuration cfg = new Configuration();
//1.获取SAXReader对象
SAXReader reader = new SAXReader();
//2.根据字节输入流获取Document对象
Document document = reader.read(config);
//3.获取根节点
Element root = document.getRootElement();
//4.使用xpath中选择指定节点的方式，获取所有property节点
List<Element> propertyElements = root.selectNodes("//property");
//5.遍历节点
for(Element propertyElement : propertyElements){
//判断节点是连接数据库的哪部分信息
//取出name属性的值
String name = propertyElement.attributeValue("name");
if("driver".equals(name)){
//表示驱动
//获取property标签value属性的值
String driver = propertyElement.attributeValue("value");
cfg.setDriver(driver);
}
if("url".equals(name)){
//表示连接字符串
//获取property标签value属性的值
String url = propertyElement.attributeValue("value");
cfg.setUrl(url);
}
if("username".equals(name)){
//表示用户名
//获取property标签value属性的值
String username = propertyElement.attributeValue("value");
cfg.setUsername(username);
}
if("password".equals(name)){
//表示密码
//获取property标签value属性的值
String password = propertyElement.attributeValue("value");
cfg.setPassword(password);
}
}
//取出mappers中的所有mapper标签，判断他们使用了resource还是class属性
List<Element> mapperElements = root.selectNodes("//mappers/mapper");
//遍历集合
for(Element mapperElement : mapperElements){
//判断mapperElement使用的是哪个属性
Attribute attribute = mapperElement.attribute("resource");
if(attribute != null){
System.out.println("使用的是XML");
//表示有resource属性，用的是XML
//取出属性的值
String mapperPath = attribute.getValue();//获取属性的值"com/itheima/dao/IUserDao.xml"
//把映射配置文件的内容获取出来，封装成一个map
Map<String,Mapper> mappers = loadMapperConfiguration(mapperPath);
//给configuration中的mappers赋值
cfg.setMappers(mappers);
}else{
System.out.println("使用的是注解");
//表示没有resource属性，用的是注解
//获取class属性的值
String daoClassPath = mapperElement.attributeValue("class");
//根据daoClassPath获取封装的必要信息
Map<String,Mapper> mappers = loadMapperAnnotation(daoClassPath);
//给configuration中的mappers赋值
cfg.setMappers(mappers);
}
}
//返回Configuration
return cfg;
}catch(Exception e){
throw new RuntimeException(e);
}finally{
try {
config.close();
}catch(Exception e){
e.printStackTrace();
}
}
}
/**
* 根据传入的参数，解析XML，并且封装到Map中
* @param mapperPath 映射配置文件的位置
* @return map中包含了获取的唯一标识（key是由dao的全限定类名和方法名组成）
* 以及执行所需的必要信息（value是一个Mapper对象，里面存放的是执行的SQL语句和要封装的实体类全限定类名）
*/
private static Map<String,Mapper> loadMapperConfiguration(String mapperPath)throws IOException {
InputStream in = null;
try{
//定义返回值对象
Map<String,Mapper> mappers = new HashMap<String,Mapper>();
//1.根据路径获取字节输入流
in = Resources.getResourceAsStream(mapperPath);
//2.根据字节输入流获取Document对象
SAXReader reader = new SAXReader();
Document document = reader.read(in);
//3.获取根节点
Element root = document.getRootElement();
//4.获取根节点的namespace属性取值
String namespace = root.attributeValue("namespace");//是组成map中key的部分
//5.获取所有的select节点
List<Element> selectElements = root.selectNodes("//select");
//6.遍历select节点集合
for(Element selectElement : selectElements){
//取出id属性的值 组成map中key的部分
String id = selectElement.attributeValue("id");
//取出resultType属性的值 组成map中value的部分
String resultType = selectElement.attributeValue("resultType");
//取出文本内容 组成map中value的部分
String queryString = selectElement.getText();
//创建Key
String key = namespace+"."+id;
//创建Value
Mapper mapper = new Mapper();
mapper.setQueryString(queryString);
mapper.setResultType(resultType);
//把key和value存入mappers中
mappers.put(key,mapper);
}
return mappers;
}catch(Exception e){
throw new RuntimeException(e);
}finally{
in.close();
}
}
/**
* 根据传入的参数，得到dao中所有被select注解标注的方法。
* 根据方法名称和类名，以及方法上注解value属性的值，组成Mapper的必要信息
* @param daoClassPath
* @return
*/
private static Map<String,Mapper> loadMapperAnnotation(String daoClassPath)throws Exception{
//定义返回值对象
Map<String,Mapper> mappers = new HashMap<String, Mapper>();
//1.得到dao接口的字节码对象
Class daoClass = Class.forName(daoClassPath);
//2.得到dao接口中的方法数组
Method[] methods = daoClass.getMethods();
//3.遍历Method数组
for(Method method : methods){
//取出每一个方法，判断是否有select注解
boolean isAnnotated = method.isAnnotationPresent(Select.class);
if(isAnnotated){
//创建Mapper对象
Mapper mapper = new Mapper();
//取出注解的value属性值
Select selectAnno = method.getAnnotation(Select.class);
String queryString = selectAnno.value();
mapper.setQueryString(queryString);
//获取当前方法的返回值，还要求必须带有泛型信息
Type type = method.getGenericReturnType();//List<User>
//判断type是不是参数化的类型
if(type instanceof ParameterizedType){
//强转
ParameterizedType ptype = (ParameterizedType)type;
//得到参数化类型中的实际类型参数
Type[] types = ptype.getActualTypeArguments();
//取出第一个
Class domainClass = (Class)types[0];
//获取domainClass的类名
String resultType = domainClass.getName();
//给Mapper赋值
mapper.setResultType(resultType);
}
//组装key的信息
//获取方法的名称
String methodName = method.getName();
String className = method.getDeclaringClass().getName();
String key = className+"."+methodName;
//给map赋值
mappers.put(key,mapper);
}
}
return mappers;
}
}
接着去pom文件中导入dom4j的依赖
导入后，大部分的错误就会消失，但是这里注意的是圈起来部分就是dom4j的扩展内容，叫做xpath,因为前边没接触过，所以这段就不用他在意，因为我们现在学的是mybatis的执行过程，解析xml我们也学过了一些其他的方式，总而言之都是把主配置文件sqlMapConfig.xml里边的内容，其实这里的property就是在找主配置文件中的property标签，就是为了拿到里边4个连接数据库的信息
那么这个时候要用到xpath，就得还要导入一个坐标，但是里边的错误还是很多
接着创建Configuration类，然后再工具类中导入这个类
package monster.zf.mybatis.cfg;
/**
* @author Monster丶ZF
* @version 1.8
* @remakeTodo 自定义mybatis的配置类
* @Package monster.zf.mybatis.cfg
* @date 2020/11/6 10:41
*/
public class Configuration {
private String driver;
private String url;
private String username;
private String password;
public String getDriver() {
return driver;
}
public void setDriver(String driver) {
this.driver = driver;
}
public String getUrl() {
return url;
}
public void setUrl(String url) {
this.url = url;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
}
然后发现工具类还需要一个叫做Mapper的类，那么前面自定义分析的时候，说过了，它里边应该包含两部分，第一部分是执行的SQL语句，第二部分是封装结果的实体类全限定类名
那么就要再去定义Mapper类,用于封装执行的SQL语句和结果类型的全限定类名
package monster.zf.mybatis.cfg;
/**
* @author Monster丶ZF
* @version 1.8
* @remakeTodo 用于封装执行的SQL语句和结果类型的全限定类名
* @Package monster.zf.mybatis.cfg
* @date 2020/11/6 10:49
*/
public class Mapper {
private String queryString; //SQL语句
private String resultType; // 实体类的全限定类名
public String getQueryString() {
return queryString;
}
public void setQueryString(String queryString) {
this.queryString = queryString;
}
public String getResultType() {
return resultType;
}
public void setResultType(String resultType) {
this.resultType = resultType;
}
}
接着在工具类中导入这个类，那么什么时候把那两个属性封装进Mapper中呢，可以发现这有两个方法，这两个方法的含义分别表示是用XML配置和使用注解配置
然后由于现在没有涉及到注解配置，所以可以先把工具类中和注解相关的先注释掉
那么就是先来看XML的配置，当它找到Mappers的Mapper
那么Mappers的Mapper就是在配置文件中
然后可能以后在这里面还会有多个mapper标签，也就是说会有别的dao，所以是使用了一个集合，当遍历这个集合的时候，我们取出来这个属性叫resource，当然如果是注解配置，属性就是class，那么到底是resource还是class，那么就判断这个属性的值，resource有值，那么就是xml配置，如果没有值，那么就是注解配置，然后现在注解暂时被注释掉了
那么这里就先使用getValue()获取到了resource属性的值，接下来就把这个一串值作为一个参数传到loadMapperConfiguration方法中，那么这个方法干了什么事呢，那么可以看到它首先定义了一个Map。
前边也分析过了，因为可能会有很多的这样的信息存起来，所以我们需要一个集合，那么为什么是Map而不用List呢，原因就是我们有获取或者说查找的需求，那这个时候肯定map集合的查询速度更加快，接着用到之前getResourceAsStream工具类。
接着又用到xml的解析，找到select标签，那么此时已经进入到了映射配置文件，找到select的信息，接着就是遍历，取出各个对应的id即findAll方法，以及resultType的值，即封装的实体类全限定类名，接着是取出velue
那么把这些都取出来之后，前边分析也讲过了，key就是namespace加上id，然后把这些内容封装到Mapper对象里边去，然后把key和mapper对象存入map集合中，就和前面的契合上了， 那这个时候，你有一个Mapper，就会在Map里边添加一个Key-value，有两个就会添加两个，那么走完这个流程后，就会从这个loadMapperConfiguration方法中把mappers返回回去，然后是返回回来后，发现setMappers报错，那么就说Mapper方法中还缺少这个方法，也就是我们的Configuration还不够完整，所以在Configuration里边我们还要定义一个mappers
那么这里它的get和set方法，set方法使用的赋值，也就是等于的方式，那么就是当我们遍历一次mapper标签，在这就会赋一次值，那么如果我有两个mapper，那么他就会循环两次，那第二次再调用赋值的时候，在这个Configuration里面会干什么事呢？毫无疑问，后边的值会把前边的值覆盖掉，那么不就成了我们的主配置文件中的mapper永远只能有一个了吗，那显然这是不对，于是这个Configuration中的set方法不能不使用直接赋值的方式，应该使用如下修改👇:也就说要把后边的内容一起加进来，而不是覆盖掉
那么工具类就没什么报错的了，那么我们把这个都准备好之后就OK了，那么有了这个工具类，就可以创建Factory了
5 自定义mybatis的编码–创建两个默认实现类并分析类之间的关系
那么我们就可以回到SqlSessionFactoryBuilder中把build方法写完，首先先得到一个Configuration 对象，但是我们还是没有得到一个工厂
所以我们需要创建它的一个实现类，
因为创建了SqlSession，SqlSession就要操作了，但是在操作的时候，他必须得有连接信息，于是这个时候我们就需要把刚刚得到的cfg拿过来，那么就在SqlSessionFactoryBuilder传递过去，然后在通过构造方法来初始化变量
那么就在实现类中拿到了Configuration对象，那Configuration里边包含了什么呢，去打开看看里边包含的就是连接数据库的信息，以及我们所需要的执行的sql语句和封装的结果类型，那此时，我们说工厂有了，其实就代表每个Session都有了，为什么这么说的，那么我们可以再创建一个SqlSession的实现类 ，重写里边的方法
package monster.zf.mybatis.sqlsession.defaults;
import monster.zf.mybatis.cfg.Configuration;
import monster.zf.mybatis.sqlsession.SqlSession;
/**
* @author Monster丶ZF
* @version 1.8
* @remakeTodo SqlSession接口的实现类
* @Package monster.zf.mybatis.sqlsession.defaults
* @date 2020/11/6 16:03
*/
public class DefaultSqlSession implements SqlSession {
private Configuration cfg;
public DefaultSqlSession(Configuration cfg){
this.cfg = cfg;
}
/**
* 用于创建代理对象
* @param daoInterfaceClass dao的接口字节码
* @param <T>
* @return
*/
public <T> T getMapper(Class<T> daoInterfaceClass) {
return null;
}
/**
* 用于释放资源
*/
public void close() {
}
}
那么接着就可以在工厂实现类中返回一个创建好的Session对象，这样的话，我们解析配置文件就跟工厂的构建连接起来了，那么构建者，就给我们构建出工厂，工厂就给我们生产一个sqlSession，那么这个sqlSession要干的事还有很多，比如说创建代理对象，实现查询所有的功能，所以还有很多事情要逐步地去完成。只不过现在我们这些类和接口之间就都有了关系，就是我们读取配置文件用到了io包里边的Resources类，读出来这个流，也就是我们找到了我们要找的信息，然后交给了构建者SqlSessionFactoryBuilder，接着构建者使用工具类给我们构建了一个工厂对象DefaultSqlSessionFactory，工厂对象里边的OpenSession给我们提供了一个session方法，接下来我们要干的事情就是在session方法里边去实现创建代理对象和查询所有的操作。
6 自定义mybatis的编码–实现基于XML的查询所有操作
接下来就来写创建代理对象方法，这个我们知道用的是Proxy.newProxyInstance()方法，之前分析的时候也说了，第一个参数类加载器，就是你代理谁，就用谁的类加载器，那么第二个参数就是你代理谁，就要跟谁有相同的接口，实现相同的接口，那么因为传过来的参数本来就是一个接口了，所以就可以直接new 一个Class数组，把这个接口传进去，而第三个参数，说的是如何代理，那我们这里就要写一个自己的代理方式。
那么接下来就要去创建出MapperProxy这个类，然后这个类一定要实现InvocationHandler接口，然后重写里边invoke方法，这个方法用于对方法进行增强的，我们的增强其实就是调用selectList方法
那么调用selectList方法，我们得把我们要准备的内容准备出来，那要准备什么内容呢？就是你在增强方法中要执行，就得拿出sql语句，得拿出来那些映射信息，那就可以把cfg.getMappers()传过去
那么传过来后，就可以在MapperProxy方法中定义一个构造方法进行对mappers初始化，因为你要执行方法必须要有mappers里边的sql语句
那么接下来就可以在invoke方法中干活了，首先第一步我们要在Map集合里边找到我们的mapper，所以要知道map的Key是全限定类名+方法名，所以第一步是获取方法名，第二步获取方法所在类的名称，第三步组合Key，第四步获取mappers中的mapper对象，第五步判断释放有mapper，没有报错误信息，有就调用工具类，执行查询所有，那么接下来就先把工具类创建出来，这个工具类里边就是封装了执行selectList方法
package monster.zf.mybatis.utils;
import monster.zf.mybatis.cfg.Mapper;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Method;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.util.ArrayList;
import java.util.List;
/**
* @author Monster丶ZF
* @version 1.8
* @remakeTodo 负责执行SQL语句，并且封装结果集
* @Package monster.zf.mybatis.utils
* @date 2020/11/6 17:23
*/
public class Executor {
public <E> List<E> selectList(Mapper mapper, Connection conn) {
PreparedStatement pstm = null;
ResultSet rs = null;
try {
//1.取出mapper中的数据
String queryString = mapper.getQueryString();//select * from user
String resultType = mapper.getResultType();monster.zf.domain.User
Class domainClass = Class.forName(resultType);
//2.获取PreparedStatement对象
pstm = conn.prepareStatement(queryString);
//3.执行SQL语句，获取结果集
rs = pstm.executeQuery();
//4.封装结果集
List<E> list = new ArrayList<E>();//定义返回值
while(rs.next()) {
//实例化要封装的实体类对象
E obj = (E)domainClass.newInstance();
//取出结果集的元信息：ResultSetMetaData
ResultSetMetaData rsmd = rs.getMetaData();
//取出总列数
int columnCount = rsmd.getColumnCount();
//遍历总列数
for (int i = 1; i <= columnCount; i++) {
//获取每列的名称，列名的序号是从1开始的
String columnName = rsmd.getColumnName(i);
//根据得到列名，获取每列的值
Object columnValue = rs.getObject(columnName);
//给obj赋值：使用Java内省机制（借助PropertyDescriptor实现属性的封装）
PropertyDescriptor pd = new PropertyDescriptor(columnName,domainClass);//要求：实体类的属性和数据库表的列名保持一种
//获取它的写入方法
Method writeMethod = pd.getWriteMethod();
//把获取的列的值，给对象赋值
writeMethod.invoke(obj,columnValue);
}
//把赋好值的对象加入到集合中
list.add(obj);
}
return list;
} catch (Exception e) {
throw new RuntimeException(e);
} finally {
release(pstm,rs);
}
}
private void release(PreparedStatement pstm, ResultSet rs){
if(rs != null){
try {
rs.close();
}catch(Exception e){
e.printStackTrace();
}
}
if(pstm != null){
try {
pstm.close();
}catch(Exception e){
e.printStackTrace();
}
}
}
}
然后可以发现这个工具类需要传入一个Connection对象，然后接着刚刚第六步，相应地传进去,那么还得通过构造方法给Connection对象实例化
那么这个MapperProxy类的代码就写好了
package monster.zf.mybatis.sqlsession.proxy;
import monster.zf.mybatis.cfg.Mapper;
import monster.zf.mybatis.utils.Executor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.sql.Connection;
import java.util.Map;
/**
* @author Monster丶ZF
* @version 1.8
* @remakeTodo
* @Package monster.zf.mybatis.sqlsession.proxy
* @date 2020/11/6 16:33
*/
public class MapperProxy implements InvocationHandler {
//map的key是全限定类名+方法名
private Map<String, Mapper> mappers;
private Connection conn;
public MapperProxy(Map<String, Mapper> mappers,Connection conn) {
this.mappers = mappers;
this.conn = conn;
}
/**
* 用于对方法进行增强的，我们的增强其实就是调用selectList方法
* @param proxy
* @param method
* @param args
* @return
* @throws Throwable
*/
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//1.获取方法名
String methodName = method.getName();
//2.获取方法所在类的名称
String className = method.getDeclaringClass().getName();
//3.组合Key
String key = className + "." + methodName;
//4.获取mappers中的mapper对象
Mapper mapper = mappers.get(key);
//5.判断释放有mapper
if(mapper == null){
//IllegalArgumentException是个runtime异常
throw new IllegalArgumentException("传入的参数有误");
}
//6.调用工具类，执行查询所有
return new Executor().selectList(mapper,conn);
}
}
接着因为DefaultSqlSessio调用了它创建代理对象，所以需要多传入一个Connection对象，那么可以在构造方法中创建出来
那么接下来创建一个DataSourceUtil
package monster.zf.mybatis.utils;
import monster.zf.mybatis.cfg.Configuration;
import java.sql.Connection;
import java.sql.DriverManager;
/**
* @author Monster丶ZF
* @version 1.8
* @remakeTodo 用于创建数据源的工具类
* @Package monster.zf.mybatis.utils
* @date 2020/11/6 17:40
*/
public class DataSourceUtil {
/**
* 用于获取一个连接
* @param cfg
* @return
*/
public static Connection getConnection(Configuration cfg){
try {
Class.forName(cfg.getDriver());
return DriverManager.getConnection(cfg.getUrl(),cfg.getUsername(),cfg.getPassword());
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}
那么接着所有的报错就结束了，就可以开始打开测试类，准备测试，然后在测试之前，要注意的是，刚才在介绍Configuration里边的setMappers方法的时候，提到不能用赋值号，而是使用put的方式，所以前边要先new一个hasMap，才能正常追加进map集合集合
运行后发现功能实现是没有任何问题的，那么这个时候整个自定义的过程就分析完了，它里边和之前时有一些差距的，可能之前一个类写完就拉倒，而现在自定义分了那么多个包，那么多个类才完成。
其实这些类和包都是有相关性的，那么其实这里边的关系也是非常简单了，就是我们需要最后实现的是查询所有，而查询所有的功能是在Executor工具类里边，我们最后就是要调用这个工具类，什么时候调用呢，就是实现dao，增强的时候，那么什么时候创建dao的实现类呢，也就是创建代理对象，增强MapperProxy里边的方法，MapperProxy类里边就是从某个地找出来要执行的语句和封装的结果，那么从哪找呢，就是从配置文件，那配置文件怎么读呢，那么就是XMLConfigBuilder工具类来负责，但是读取完后，不存起来又不行，所以我们又使用了一个Configuration对象把它存起来，那么整个的流程就是这么一个过程，跟开始分析的那张图是一样的。
7 自定义mybatis的编码–实现基于注解配置的查询所有
那么接下使用注解来实现功能，首先把主配置文件中的xml配置方式注释，然后使用使用注解配置
接着第二件事就要去dao接口上边加上@select注解并写上语句
那么select报错，应该它没有这个注解，所以我们需要在mybatis包下，自己创建一个注解
package monster.zf.mybatis.annotations;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* @author Monster丶ZF
* @version 1.8
* @remakeTodo 查询的注解
* @Package monster.zf.mybatis.annotations
* @date 2020/11/7 8:50
*/
//改变注解的声明周期,同时还要改变一下它改变的位置
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Select {
/**
* 配置sql语句的
* @return
*/
String value();
}
那么接下来的事情非常简单，刚才我们在导那个工具类的时候，那个注解的解析和xml的解析，不就是看看有没有resouces属性嘛，那么先把之前注释掉的部分都打开，然后把相应的包导进去即可
然后在里边是使用了反射的注解的方式，那么里边干了什么事呢，其实很简单，仍然是先填充mappers，因为只要Configuration里边的mappers准备好，后边的代码都不用动
那么这里首先是解析注解，如果是class属性的时候，那么这个时候得到的就是dao的classPath，换句话说就是得到dao的全限定类名
然后有了这个接口的全限定类名，我们就可以得到dao接口中的方法，遍历接口中每一个方法，看看哪个方法上有select注解，如果有select注解，我们就需要取出注解的属性，那么注解的value属性就是sql语句，意思就是说，只要我找到这个注解，找到这个value属性，其实就找到了那条sql语句，然后mappers里边除了要有sql语句，还要有返回结果类型，那么结果类型其实就是接口中List的泛型，直接获取即可，那么怎么拿呢，就是先得到方法的返回值，注意是带有泛型的，Generic在java中表示泛型，然后进一步拿到里边的User
那么取出来之后就是拼装这个Key，然后value，就是mappers对象，然后添加到map集合中
那么接着把项目运行起来，发现同样可以实现功能，那么其实不管是注解还xml配置，其实都是在准备mappers，而后边的内容都一样。所以说整个的思想其实只有两件事，第一件事，创建代理对象，第二件事执行查询所有。
下一篇👉MyBatis----回顾mybatis自定义和环境搭建+完善自定义Mybatis的注解开发
本篇博客到这就完啦，非常感谢您的阅读🙏，那么下一篇将会继续往下学习mybatis的知识。如果对您有帮助，可以帮忙点个赞或者来波关注鼓励一下喔😬
299
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
