上一篇👉: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的知识。如果对您有帮助,可以帮忙点个赞或者来波关注鼓励一下喔😬