【BlossomRPC】接入注册中心

news2024/11/25 6:36:37

文章目录

  • Nacos
  • Zookeeper
  • 自研配置中心

RPC项目

配置中心项目

网关项目

这是BlossomRPC项目的最后一篇文章了，接入完毕注册中心，一个完整的RPC框架就设计完成了。
对于项目对注册中心的整合，其实我们只需要再服务启动的时候将ip/port/servicename注册到注册中心上即可。
注册中心这里只是一个简单的ip/port信息的存储器而已。
那么我们就需要考虑用什么样的一种方式来引入注册中心。
这里可以考虑使用Spring的AutoConfiguration然后配合Conditional类型的注解进行判断使用那个注册中心。
这里我提供了一个RegisterService接口提供抽象的注册方法，只需要实现这个接口就可以再项目中引入自己实现的注册中心了。

public interface RegisterService {

    default void init(){}
    void register(RpcServiceInstance instance);

    default void unregister(RpcServiceInstance instance){}

    RpcServiceInstance discovery(RpcServiceInstance instance);
}

Nacos

我们首先以Nacos为例。实现所有的接口方法。

package blossom.project.rpc.nacos;

import blossom.project.rpc.common.register.RegisterService;
import blossom.project.rpc.common.register.RpcServiceInstance;
import blossom.project.rpc.common.loadbalance.LoadBalanceStrategy;
import blossom.project.rpc.common.loadbalance.PollLoadBalance;
import com.alibaba.nacos.api.exception.NacosException;
import com.alibaba.nacos.api.naming.NamingFactory;
import com.alibaba.nacos.api.naming.NamingService;
import com.alibaba.nacos.api.naming.pojo.Instance;
import lombok.extern.slf4j.Slf4j;

import java.util.List;
import java.util.Objects;

/**
 * @author: ZhangBlossom
 * @date: 2023/12/19 23:46
 * @contact: QQ:4602197553
 * @contact: WX:qczjhczs0114
 * @blog: https://blog.csdn.net/Zhangsama1
 * @github: https://github.com/ZhangBlossom
 * NacosRegisterService类
 */
@Slf4j
public class NacosRegisterService implements RegisterService {

    private NamingService namingService;

    private LoadBalanceStrategy<Instance> loadBalanceStrategy
             = new PollLoadBalance<>();

    public NacosRegisterService(){}

    public NacosRegisterService(String serverAddress) {
        try {
            this.namingService = NamingFactory.createNamingService(serverAddress);
        } catch (NacosException e) {
            throw new RuntimeException(e);
        }
    }

    public NacosRegisterService(String serverAddress, LoadBalanceStrategy loadBalanceStrategy) {
        try {
            this.namingService = NamingFactory.createNamingService(serverAddress);
            this.loadBalanceStrategy = loadBalanceStrategy;
        } catch (NacosException e) {
            throw new RuntimeException(e);
        }
    }


    @Override
    public void register(RpcServiceInstance instance) {
        if (Objects.isNull(instance)) {
            log.info("the Reigster Service Info can not be null!!!");
            return;
        }
        log.info("start to register instance to Nacos: {}",instance);
        try {
            //注册服务  服务名称：blossom.project.rpc.core.service.RpcService
            namingService.registerInstance(instance.getServiceName(), instance.getServiceIp(),
                    instance.getServicePort());
        } catch (NacosException e) {
            log.error("register the ServiceInstance to Nacos failed!!!");
            throw new RuntimeException(e);
        }
    }

    @Override
    public void unregister(RpcServiceInstance instance) {
        if (Objects.isNull(instance)) {
            log.info("the Reigster Service Info can not be null!!!");
            return;
        }
        log.info("start to unregister instance to Nacos: {}",instance);
        try {
            //进行服务注销
            namingService.deregisterInstance(instance.getServiceName(), instance.getServiceIp(),
                    instance.getServicePort());
        } catch (NacosException e) {
            log.error("unregister the ServiceInstance from Nacos failed!!!");
            throw new RuntimeException(e);
        }

    }

    @Override
    public RpcServiceInstance discovery(RpcServiceInstance instance) {
        try {
            List<Instance> instances = namingService.selectInstances(instance.getServiceName(),
                    instance.getGroupName(), true);
            Instance rpcInstance = loadBalanceStrategy.choose(instances);
            if (Objects.nonNull(rpcInstance)) {


                return RpcServiceInstance.builder()
                        .serviceIp(rpcInstance.getIp())
                        .servicePort(rpcInstance.getPort())
                        .serviceName(rpcInstance.getServiceName())
                        .build();
            }
            return null;
        } catch (NacosException e) {
            log.error("discovery the ServiceInstance from Nacos failed!!!");
            throw new RuntimeException(e);
        }
    }


}

之后，我们得考虑，如何让用户无感知的只需要启动项目和引入依赖，就可以完成服务的注册。
我们考虑使用@AutoConfiguration的方式来进行。
同时，还得预留一种情况，就是用于自研的注册中心。

package blossom.project.rpc.nacos;

import blossom.project.rpc.common.constants.RpcCommonConstants;
import blossom.project.rpc.common.loadbalance.LoadBalanceStrategy;
import blossom.project.rpc.common.loadbalance.PollLoadBalance;
import blossom.project.rpc.common.register.RegisterService;
import org.springframework.beans.BeansException;
import org.springframework.boot.autoconfigure.AutoConfiguration;
import org.springframework.boot.autoconfigure.AutoConfigureBefore;
import org.springframework.boot.autoconfigure.AutoConfigureOrder;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.EnvironmentAware;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Conditional;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.core.env.Environment;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Map;
import java.util.Objects;

/**
 * @author: ZhangBlossom
 * @date: 2023/12/22 18:50
 * @contact: QQ:4602197553
 * @contact: WX:qczjhczs0114
 * @blog: https://blog.csdn.net/Zhangsama1
 * @github: https://github.com/ZhangBlossom
 * NacosAutoConfiguration类
 */
@Configuration
//@AutoConfiguration
//@AutoConfigureBefore(value = RegisterService.class)
@AutoConfigureOrder(value = Integer.MAX_VALUE)
//@Conditional(OnNacosClientClassCondition.class)
public class NacosAutoConfiguration implements
        ApplicationContextAware, EnvironmentAware {

    /**
     * 这个bean只会在存在nacos的依赖的时候才会创建
     *
     * @return
     */
    @Primary
    @Bean(name = "nacosRegisterService")
    @ConditionalOnMissingBean(name = "spiRegisterService")
    public RegisterService nacosRegisterService() {

        //创建注册中心
        // 优先检查是否存在 SPI 实现类
        // 获取Nacos相关配置，例如服务器地址等
        //String serverAddress = "localhost:8848"; // 从配置中读取Nacos服务器地址
        // ... 其他所需配置
        String registerAddress = environment.getProperty(RpcCommonConstants.REGISTER_ADDRESS);
        try {
            // 使用反射创建NamingService实例
            //Class<?> namingFactoryClass =
            //        Class.forName("com.alibaba.nacos.api.naming.NamingFactory");
            //Method createNamingServiceMethod =
            //        namingFactoryClass.getMethod("createNamingService", String.class);
            //Object namingServiceInstance = createNamingServiceMethod.invoke(null, serverAddress);

            // 创建NacosRegisterService实例
            Class<?> nacosRegisterServiceClass = Class.forName(RpcCommonConstants.NACOS_REGISTER_CLASS);
            Constructor<?> constructor = nacosRegisterServiceClass.getConstructor(String.class,
                    LoadBalanceStrategy.class);
            return (RegisterService) constructor.newInstance(registerAddress, new PollLoadBalance<>());
        } catch (ClassNotFoundException | NoSuchMethodException | IllegalAccessException | InstantiationException |
                 InvocationTargetException e) {
            throw new IllegalStateException("Failed to create NacosRegisterService", e);
        }
    }

    private ApplicationContext applicationContext;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }

    private Environment environment;

    @Override
    public void setEnvironment(Environment environment) {
        this.environment = environment;
    }
}

通过这种方式，只要引入了Nacos的依赖，在项目启动的时候就会使用Nacos作为项目的注册中心。
同时，如果用户也提供了自己的注册中心，那么会优先使用用户自己的注册中心来进行服务注册。
而用户自己的注册中心的实现，使用的是SPI的方式。

package blossom.project.rpc.core.proxy.spring;

import blossom.project.rpc.common.constants.RpcCommonConstants;
import blossom.project.rpc.common.loadbalance.LoadBalanceStrategy;
import blossom.project.rpc.common.loadbalance.PollLoadBalance;
import blossom.project.rpc.common.register.RegisterService;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.EnvironmentAware;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.env.Environment;

import java.util.Map;
import java.util.ServiceLoader;

@Configuration
public class SpringRegisterServicePostProcessor implements
        BeanDefinitionRegistryPostProcessor ,
        EnvironmentAware,
        ApplicationContextAware {

    private Environment environment;


    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
        ServiceLoader<RegisterService> serviceLoader = ServiceLoader.load(RegisterService.class);
        if (!serviceLoader.iterator().hasNext()) {
            // 没有通过SPI找到实现，加载Nacos或Zookeeper的实现
            String registerAddress = environment.getProperty(RpcCommonConstants.REGISTER_ADDRESS);
            registerServiceBeanDefinition(registry, registerAddress);
        } else {
            // 通过SPI找到了实现，将其注册到Spring容器
            registerServiceViaSpi(serviceLoader, registry);
        }
    }

    private void registerServiceViaSpi(ServiceLoader<RegisterService> serviceLoader, BeanDefinitionRegistry registry) {
        // 获取SPI的RegisterService实现
        RegisterService registerService = serviceLoader.iterator().next();

        // 创建BeanDefinition
        BeanDefinition beanDefinition = BeanDefinitionBuilder
                .genericBeanDefinition(registerService.getClass())
                .getBeanDefinition();

        // 注册BeanDefinition到Spring容器
        registry.registerBeanDefinition("spiRegisterService", beanDefinition);
    }

    private void registerServiceBeanDefinition(BeanDefinitionRegistry registry, String registerAddress) {
        try {
            registerReflectiveService(registry, RpcCommonConstants.NACOS_REGISTER_CLASS, registerAddress);
        } catch (Exception e) {
            registerReflectiveService(registry, RpcCommonConstants.ZK_REGISTER_CLASS, registerAddress);
        }
    }

    private void registerReflectiveService(BeanDefinitionRegistry registry, String className, String registerAddress) {
        try {
            Class<?> registerServiceClass = Class.forName(className);
            BeanDefinition beanDefinition =
                    BeanDefinitionBuilder.genericBeanDefinition(registerServiceClass)
                    .getBeanDefinition();
            registry.registerBeanDefinition(className, beanDefinition);
            System.out.println(registry.getBeanDefinition(className));
        } catch (Exception e) {
            throw new RuntimeException("Failed to register " + className, e);
        }
    }

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        // No implementation required for this method in this context
    }

    @Override
    public void setEnvironment(Environment environment) {
        this.environment = environment;
    }

    private ApplicationContext applicationContext;
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }


}

好的，这里我们已Nacos为例，对服务进行启动。
成功完成服务实例的注册
在这里插入图片描述启动多个服务实例也可以
在这里插入图片描述
同理，对于zk，也是一样的方法。

Zookeeper

@Slf4j
public class ZookeeperRegisterService implements RegisterService {

    private static final String REGISTRY_PATH = "/rpc_registry";

    /**
     * zk注册中心
     */
    private final ServiceDiscovery<RpcServiceInstance> serviceDiscovery;

    private LoadBalanceStrategy<ServiceInstance<RpcServiceInstance>> loadBalanceStrategy;

    public ZookeeperRegisterService(String serverAddress,LoadBalanceStrategy loadBalanceStrategy) throws Exception {
        CuratorFramework client = CuratorFrameworkFactory
                .newClient(serverAddress,
                        new ExponentialBackoffRetry(2000, 3));
        client.start();
        JsonInstanceSerializer<RpcServiceInstance> serializer = new JsonInstanceSerializer<>(RpcServiceInstance.class);
        this.serviceDiscovery =
                ServiceDiscoveryBuilder.builder(RpcServiceInstance.class)
                        .client(client)
                        .serializer(serializer)
                        .basePath(REGISTRY_PATH)
                        .build();
        this.serviceDiscovery.start();
        this.loadBalanceStrategy = loadBalanceStrategy;
    }

    @Override
    public void register(RpcServiceInstance instance) {
        if (Objects.isNull(instance)) {
            log.info("the Reigster Service Info can not be null!!!");
            return;
        }
        log.info("start to register instance to Zookeeper: {}",instance);
        try {
            ServiceInstance<RpcServiceInstance> serviceInstance =
                    ServiceInstance.<RpcServiceInstance>builder()
                            .name(instance.getServiceName()).address(instance.getServiceIp()).port(instance.getServicePort()).payload(instance).build();
            this.serviceDiscovery.registerService(serviceInstance);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public RpcServiceInstance discovery(RpcServiceInstance instance) {
        Collection<ServiceInstance<RpcServiceInstance>> serviceInstances = null;
        try {
            serviceInstances = this.serviceDiscovery.queryForInstances(instance.getServiceName());
            ServiceInstance<RpcServiceInstance> serviceInstance =
                    this.loadBalanceStrategy.choose((List<ServiceInstance<RpcServiceInstance>>) serviceInstances);
            if (serviceInstance != null) {
                return serviceInstance.getPayload();
            }
            return null;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

}

public class OnZookeeperClientClassCondition implements Condition {


    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        try {
            Class.forName(ZK_DISCOVERY_CLASS);
            return true;
        } catch (ClassNotFoundException e) {
            return false;
        }
    }

自研配置中心

上文提到，有可能用户会使用自己的注册中心。所以我提供了基于spi机制的方式，来让用户引入自己的注册中心。
在这里插入图片描述
用户在项目启动的时候通过SPI的方式提供自己实现的注册中心代码即可。
如果不存在会扫描是否存在Nacos/Zk，如果都不存在，就报错，否则优先使用用户自定义的配置中心。

到此为止，一个简单的自研配置中心就完成了。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1561648.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

商城业务-检索服务

商城业务-检索服务

文章目录 前言一、搭建页面环境1.1 静态界面搭建1.2 Nginx 动静分离1.3 Windows 上传文件1.4 引入 thymeleaf 依赖1.5 Nginx 反向代理1.4 Nginx 配置1.5 gateway 网关配置 二、调整页面跳转2.1 引入依赖2.2 页面跳转 三、检索查询参数模型分析抽取3.1 检索业务分析3.2 检索语句…
阅读更多...
齿轮“红宝书”

齿轮“红宝书”

​在齿轮行业&#xff0c;有两本书被广大从业者尊称为“红宝书”。这两部作品深入剖析了齿轮技术的精髓&#xff0c;为从业者提供了宝贵的指导和启示。它们犹如行业的明灯&#xff0c;照亮了齿轮制造的每一个角落&#xff0c;使得从业者在探索中不再迷茫。 这两本红宝书的内容…
阅读更多...
离散数学-

离散数学-

数学
阅读更多...
遥感动态监测技术

遥感动态监测技术

很多人对动态监测和动态检测两个名词有疑惑。我们可以这样理解&#xff0c;动态监测是一个广义的名词&#xff0c;泛指数据预处理、变化信息发现与提取、变化信息挖掘与应用等&#xff0c;以对整个流程的叙述。动态检测是一个狭义的名词&#xff0c;主要指部分数据预处理、变化…
阅读更多...
【御控物联】JavaScript JSON结构转换（7）：数组To数组——键值互换属性重组

【御控物联】JavaScript JSON结构转换（7）：数组To数组——键值互换属性重组

文章目录 一、JSON结构转换是什么&#xff1f;二、案例之《JSON数组 To JSON数组》三、代码实现四、在线转换工具五、技术资料 一、JSON结构转换是什么&#xff1f; JSON结构转换指的是将一个JSON对象或JSON数组按照一定规则进行重组、筛选、映射或转换&#xff0c;生成新的JS…
阅读更多...
前端（三）React踩坑记录

前端（三）React踩坑记录

一、引言 作者最近新的平台项目是需要用react的&#xff0c;和vue区别还是比较大的&#xff0c;这里记录下踩坑和使用经验。 二、环境 框架&#xff1a;antd 依赖&#xff1a; "dependencies": {"ant-design/icons": "^4.7.0","ant-desig…
阅读更多...
Linux使用Docker部署RStudio Server结合内网穿透实现公网访问本地服务

Linux使用Docker部署RStudio Server结合内网穿透实现公网访问本地服务

文章目录 前言1. 安装RStudio Server2. 本地访问3. Linux 安装cpolar4. 配置RStudio server公网访问地址5. 公网远程访问RStudio6. 固定RStudio公网地址 前言 RStudio Server 使你能够在 Linux 服务器上运行你所熟悉和喜爱的 RStudio IDE&#xff0c;并通过 Web 浏览器进行访问…
阅读更多...
卷积层+多个输入通道

卷积层+多个输入通道

卷积层多输入输出通道 在深度学习中&#xff0c;卷积神经网络&#xff08;CNN&#xff09;通常用于处理具有多个输入通道的数据。当输入数据具有多个通道&#xff08;例如彩色图像的RGB通道&#xff09;时&#xff0c;卷积操作可以同时在每个通道上进行&#xff0c;并将各通道的…
阅读更多...
【成功案例】间隔数月双团伙先后利用某ERP0day实施入侵和勒索的解密恢复项目

【成功案例】间隔数月双团伙先后利用某ERP0day实施入侵和勒索的解密恢复项目

1.背景 在2024年3月23日&#xff0c;我们的Solar应急响应团队&#xff08;以下简称Solar团队&#xff09;应某公司之邀&#xff0c;介入处理了一起财务系统服务器遭受黑客攻击的事件。该事件导致服务器上大量文件被加密。我们的团队迅速获取了一个被加密的文件&#xff0c;并立…
阅读更多...
面试题：MySQL 优化篇

面试题：MySQL 优化篇

定位慢查询 &#x1f496; 开源工具 调试工具&#xff1a;Arthas&#xff08;阿尔萨斯&#xff09;运维工具&#xff1a;Prometheus&#xff08;普罗米修斯&#xff09;、Skywalking &#x1f496; MySQL 慢查询日志 # 开启 MySQL 慢查询日志开关 slow_query_log1 # 设置慢…
阅读更多...
HWOD：整型数组排序

HWOD：整型数组排序

一、知识点 while(1){}表示永久循环 使用break结束循环 二、题目 1、描述 输入整型数组和排序标识&#xff0c;对其元素按照升序或降序进行排序 2、数据范围 1<n<1000 0<val<100000 3、输入 第一行输入数组元素个数 第二行输入待排序的数组&#x…
阅读更多...
安装JupyterLab的集成环境

安装JupyterLab的集成环境

Python集成环境安装 不要半途而废&#xff0c;不要作业太多就抛下你手中的笔&#xff0c;拿起你旁边的手机&#xff0c;你觉得这样很有意义吗&#xff1f;一个小时一道题都没做&#xff0c;盯着手机屏幕它能给你一个未来吗&#xff1f;少分心就能多做一道题&#xff0c;多学样本…
阅读更多...
编程新手必看，Python开发环境工具揭秘：高效编程的必备工具（2）

编程新手必看，Python开发环境工具揭秘：高效编程的必备工具（2）

1、Python主流的开发工具介绍&#xff1a; Python的主流开发工具主要包括PyCharm、Visual Studio Code&#xff08;VS Code&#xff09;、IDLE等。具体介绍如下&#xff1a; 1.1、PyCharm&#xff1a; PyCharm是由JetBrains开发的&#xff0c;专为Python设计的IDE&#xff0…
阅读更多...
生成 SSH 公钥

生成 SSH 公钥

Windows 用户建议使用 Windows PowerShell 或者 Git Bash&#xff0c;在 命令提示符 下无 cat 和 ls 命令。 1、通过命令 ssh-keygen 生成 SSH Key&#xff1a; ssh-keygen -t ed25519 -C "Gitee SSH Key"-t key 类型 -C 注释 输出&#xff0c;如&#xff1a; 中间…
阅读更多...
【tensorflow框架神经网络实现鸢尾花分类_Keras】

【tensorflow框架神经网络实现鸢尾花分类_Keras】

文章目录 1、前言2、鸢尾花分类3、结果打印 1、前言 【tensorflow框架神经网络实现鸢尾花分类】一文中使用自定义的方式&#xff0c;实现了鸢尾花数据集的分类工作。在这里使用tensorflow中的keras模块快速、极简实现鸢尾花分类任务。 2、鸢尾花分类 import tensorflow as t…
阅读更多...
python如何画奥运五环

python如何画奥运五环

绘制奥运五环主要涉及到Python中的turtle绘图库运用&#xff1a; 程序源代码为&#xff1a; import turtle turtle.width(10) turtle.color(black) turtle.circle(50) turtle.penup() turtle.goto(120,0) turtle.pendown() turtle.color(red) turtle.circle(50) turtle.penup()…
阅读更多...
KT-0850——三箱社交箱

KT-0850——三箱社交箱

动物行为学是一门跨学科的科学&#xff0c;致力于研究动物的行为模式、决策过程以及它们如何在不同的环境中进行社交互动。在探索动物王国的奥秘时&#xff0c;科学家们发展出了多种实验方法&#xff0c;其中三箱社交实验是一种被广泛采用的技术&#xff0c;用于揭示动物在社交…
阅读更多...
力扣热题100_链表_141_环形链表

力扣热题100_链表_141_环形链表

文章目录 题目链接解题思路解题代码 题目链接 141. 环形链表 给你一个链表的头节点 head &#xff0c;判断链表中是否有环。 如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针再次到达&#xff0c;则链表中存在环。 为了表示给定链表中的环&#xff0c;评测系统…
阅读更多...
从C到C++：深入理解基础语法差别

从C到C++：深入理解基础语法差别

C基础语法讲解 前言1.输入输出2.命名空间2.1命名空间的理解&#xff1a;2.2命名空间的使用方式 3.缺省参数3.1概念&#xff1a;3.2分类&#xff1a;半缺省函数注意事项&#xff1a; 3.3使用案例&#xff1a;顺序表的初始化 4.函数重载4.1参数重载类型类型&#xff1a; 5.引用5.…
阅读更多...
企业员工在线培训系统功能介绍

企业员工在线培训系统功能介绍

随着信息技术的飞速发展&#xff0c;企业员工培训方式正逐步从传统的面授转向灵活高效的在线培训。一个综合性的企业员工在线培训系统能够为员工提供多样化的学习资源、便捷的学习途径和有效的学习监督&#xff0c;以下是该系统的主要功能详细介绍&#xff1a; 1. 课程功能 线…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023