微服务框架 SpringCloud微服务架构 微服务面试篇 54 微服务篇 54.6 Nacos与Eureka的区别有哪些？【服务发现】

news2025/3/16 1:39:34

微服务框架

【SpringCloud+RabbitMQ+Docker+Redis+搜索+分布式，系统详解springcloud微服务技术栈课程|黑马程序员Java微服务】

微服务面试篇

文章目录

      • 微服务框架
      • 微服务面试篇
      • 54 微服务篇
        • 54.6 Nacos与Eureka的区别有哪些？【服务发现】
          • 54.6.1 Nacos 的服务拉取和订阅 机制

54 微服务篇

54.6 Nacos与Eureka的区别有哪些？【服务发现】

54.6.1 Nacos 的服务拉取和订阅 机制

服务发现：Nacos支持定时拉取和订阅推送两种模式；Eureka只支持定时拉取模式

【Nacos 的服务拉取 和订阅机制】

先看看Nacos 官方API 文档【查询实例 列表】

在这里插入图片描述

【描述】

查询服务下的实例列表

【请求类型】

GET

【请求路径】

/nacos/v1/ns/instance/list

【请求参数】

名称类型是否必选描述
serviceName字符串是服务名
groupName字符串否分组名
namespaceId字符串否命名空间ID
clusters字符串，多个集群用逗号分隔否集群名称
healthyOnlyboolean否，默认为false是否只返回健康实例

现在 Nacos的 服务端肯定需要有一个 controller 来接收这个请求并 返回实例列表

作为消费者【客户端】就应该向 这个服务端 发送这个请求来获取 实例

【问题】

我们的微服务( 比如order-service )，它是什么时候来做这个拉取的 呢？

因为我们的微服务 都是基于Ribbon 来做的远程 调用和负载均衡，所以，服务拉取的动作也是Ribbon 去做的

进到一个 DynamicServerListLoadBalancer类， 动态 列表服务均衡器

在这里插入图片描述

它在它的构造函数 中就会执行 一系列的初始化动作

public DynamicServerListLoadBalancer(IClientConfig clientConfig, IRule rule, IPing ping, ServerList<T> serverList, ServerListFilter<T> filter, ServerListUpdater serverListUpdater) {
    super(clientConfig, rule, ping);
    this.isSecure = false;
    this.useTunnel = false;
    this.serverListUpdateInProgress = new AtomicBoolean(false);
    this.updateAction = new NamelessClass_1();
    this.serverListImpl = serverList;
    this.filter = filter;
    this.serverListUpdater = serverListUpdater;
    if (filter instanceof AbstractServerListFilter) {
        ((AbstractServerListFilter)filter).setLoadBalancerStats(this.getLoadBalancerStats());
    }

    this.restOfInit(clientConfig); // 注意这个【基于rest 请求的初始化】【即基于rest 请求拉取服务列表】
}

跟进这个方法

在这里插入图片描述

再跟入 updateListOfServers 这个方法

@VisibleForTesting
public void updateListOfServers() {
    List<T> servers = new ArrayList();
    if (this.serverListImpl != null) {
        servers = this.serverListImpl.getUpdatedListOfServers(); //[核心]
        LOGGER.debug("List of Servers for {} obtained from Discovery client: {}", this.getIdentifier(), servers);
        if (this.filter != null) {
            servers = this.filter.getFilteredListOfServers((List)servers);
            LOGGER.debug("Filtered List of Servers for {} obtained from Discovery client: {}", this.getIdentifier(), servers);
        }
    }

    this.updateAllServerList((List)servers);
}

跟入 getUpdatedListOfServers 方法

在这里插入图片描述

@Override
public List<NacosServer> getUpdatedListOfServers() {
   return getServers();
}

getServers 方法就在下面

【是真的复杂，笔者看到这儿，完全不知道怎么做笔记了 …】

直接回到 服务端 的list 接口 了

 */
@GetMapping("/list")
@Secured(parser = NamingResourceParser.class, action = ActionTypes.READ)
public ObjectNode list(HttpServletRequest request) throws Exception {
    
     // 解析request 中的namespaceId、serviceName
    String namespaceId = WebUtils.optional(request, CommonParams.NAMESPACE_ID, Constants.DEFAULT_NAMESPACE_ID);
    String serviceName = WebUtils.required(request, CommonParams.SERVICE_NAME);
    NamingUtils.checkServiceNameFormat(serviceName);
    
    String agent = WebUtils.getUserAgent(request);
    
     // 获取集群信息
     String clusters = WebUtils.optional(request, "clusters", StringUtils.EMPTY);
     
    // 客户端【消费者】的IP 和udp 端口
    String clientIP = WebUtils.optional(request, "clientIP", StringUtils.EMPTY);
    int udpPort = Integer.parseInt(WebUtils.optional(request, "udpPort", "0"));
    String env = WebUtils.optional(request, "env", StringUtils.EMPTY);
    boolean isCheck = Boolean.parseBoolean(WebUtils.optional(request, "isCheck", "false"));
    
    String app = WebUtils.optional(request, "app", StringUtils.EMPTY);
    
    String tenant = WebUtils.optional(request, "tid", StringUtils.EMPTY);
    
    boolean healthyOnly = Boolean.parseBoolean(WebUtils.optional(request, "healthyOnly", "false"));
    
    return doSrvIpxt(namespaceId, serviceName, agent, clusters, clientIP, udpPort, env, isCheck, app, tenant,
            healthyOnly);
}

在这里插入图片描述

再进到 doSrvIpxt 方法

public ObjectNode doSrvIpxt(String namespaceId, String serviceName, String agent, String clusters, String clientIP,
        int udpPort, String env, boolean isCheck, String app, String tid, boolean healthyOnly) throws Exception {
    
    ClientInfo clientInfo = new ClientInfo(agent);
    
    // 创建空的json 对象，作为result【将来的 】
    ObjectNode result = JacksonUtils.createEmptyJsonNode();
    
    // 从注册表 尝试获取服务
    Service service = serviceManager.getService(namespaceId, serviceName);
    long cacheMillis = switchDomain.getDefaultCacheMillis();
    
    // now try to enable the push
    try {
        if (udpPort > 0 && pushService.canEnablePush(agent)) {
            
            // UDP服务端，记录客户端的IP、端口、要监听的服务信息
            pushService
                    .addClient(namespaceId, serviceName, clusters, agent, new InetSocketAddress(clientIP, udpPort),
                            pushDataSource, tid, app);
            cacheMillis = switchDomain.getPushCacheMillis(serviceName);
        }
    } catch (Exception e) {
        Loggers.SRV_LOG
                .error("[NACOS-API] failed to added push client {}, {}:{}", clientInfo, clientIP, udpPort, e);
        cacheMillis = switchDomain.getDefaultCacheMillis();
    }
    
    
   	// 【封装最终结果】
    if (service == null) {
        if (Loggers.SRV_LOG.isDebugEnabled()) {
            Loggers.SRV_LOG.debug("no instance to serve for service: {}", serviceName);
        }
        result.put("name", serviceName);
        result.put("clusters", clusters);
        result.put("cacheMillis", cacheMillis);
        result.replace("hosts", JacksonUtils.createEmptyArrayNode());
        return result;
    }
    
    checkIfDisabled(service);
    
    List<Instance> srvedIPs;
    
    srvedIPs = service.srvIPs(Arrays.asList(StringUtils.split(clusters, ",")));
    
    // filter ips using selector:
    if (service.getSelector() != null && StringUtils.isNotBlank(clientIP)) {
        srvedIPs = service.getSelector().select(clientIP, srvedIPs);
    }
    
    if (CollectionUtils.isEmpty(srvedIPs)) {
        
        if (Loggers.SRV_LOG.isDebugEnabled()) {
            Loggers.SRV_LOG.debug("no instance to serve for service: {}", serviceName);
        }
        
        if (clientInfo.type == ClientInfo.ClientType.JAVA
                && clientInfo.version.compareTo(VersionUtil.parseVersion("1.0.0")) >= 0) {
            result.put("dom", serviceName);
        } else {
            result.put("dom", NamingUtils.getServiceName(serviceName));
        }
        
        result.put("name", serviceName);
        result.put("cacheMillis", cacheMillis);
        result.put("lastRefTime", System.currentTimeMillis());
        result.put("checksum", service.getChecksum());
        result.put("useSpecifiedURL", false);
        result.put("clusters", clusters);
        result.put("env", env);
        result.set("hosts", JacksonUtils.createEmptyArrayNode());
        result.set("metadata", JacksonUtils.transferToJsonNode(service.getMetadata()));
        return result;
    }
    
    Map<Boolean, List<Instance>> ipMap = new HashMap<>(2);
    ipMap.put(Boolean.TRUE, new ArrayList<>());
    ipMap.put(Boolean.FALSE, new ArrayList<>());
    
    for (Instance ip : srvedIPs) {
        ipMap.get(ip.isHealthy()).add(ip);
    }
    
    if (isCheck) {
        result.put("reachProtectThreshold", false);
    }
    
    double threshold = service.getProtectThreshold();
    
    if ((float) ipMap.get(Boolean.TRUE).size() / srvedIPs.size() <= threshold) {
        
        Loggers.SRV_LOG.warn("protect threshold reached, return all ips, service: {}", serviceName);
        if (isCheck) {
            result.put("reachProtectThreshold", true);
        }
        
        ipMap.get(Boolean.TRUE).addAll(ipMap.get(Boolean.FALSE));
        ipMap.get(Boolean.FALSE).clear();
    }
    
    if (isCheck) {
        result.put("protectThreshold", service.getProtectThreshold());
        result.put("reachLocalSiteCallThreshold", false);
        
        return JacksonUtils.createEmptyJsonNode();
    }
    
    ArrayNode hosts = JacksonUtils.createEmptyArrayNode();
    
    for (Map.Entry<Boolean, List<Instance>> entry : ipMap.entrySet()) {
        List<Instance> ips = entry.getValue();
        
        if (healthyOnly && !entry.getKey()) {
            continue;
        }
        
        for (Instance instance : ips) {
            
            // remove disabled instance:
            if (!instance.isEnabled()) {
                continue;
            }
            
            ObjectNode ipObj = JacksonUtils.createEmptyJsonNode();
            
            ipObj.put("ip", instance.getIp());
            ipObj.put("port", instance.getPort());
            // deprecated since nacos 1.0.0:
            ipObj.put("valid", entry.getKey());
            ipObj.put("healthy", entry.getKey());
            ipObj.put("marked", instance.isMarked());
            ipObj.put("instanceId", instance.getInstanceId());
            ipObj.set("metadata", JacksonUtils.transferToJsonNode(instance.getMetadata()));
            ipObj.put("enabled", instance.isEnabled());
            ipObj.put("weight", instance.getWeight());
            ipObj.put("clusterName", instance.getClusterName());
            if (clientInfo.type == ClientInfo.ClientType.JAVA
                    && clientInfo.version.compareTo(VersionUtil.parseVersion("1.0.0")) >= 0) {
                ipObj.put("serviceName", instance.getServiceName());
            } else {
                ipObj.put("serviceName", NamingUtils.getServiceName(instance.getServiceName()));
            }
            
            ipObj.put("ephemeral", instance.isEphemeral());
            hosts.add(ipObj);
            
        }
    }
    
    result.replace("hosts", hosts);
    if (clientInfo.type == ClientInfo.ClientType.JAVA
            && clientInfo.version.compareTo(VersionUtil.parseVersion("1.0.0")) >= 0) {
        result.put("dom", serviceName);
    } else {
        result.put("dom", NamingUtils.getServiceName(serviceName));
    }
    result.put("name", serviceName);
    result.put("cacheMillis", cacheMillis);
    result.put("lastRefTime", System.currentTimeMillis());
    result.put("checksum", service.getChecksum());
    result.put("useSpecifiedURL", false);
    result.put("clusters", clusters);
    result.put("env", env);
    result.replace("metadata", JacksonUtils.transferToJsonNode(service.getMetadata()));
    return result;
}

在这里插入图片描述

再进到，PushService

在这里插入图片描述

里面有一段静态代码块

static {
    try {
        udpSocket = new DatagramSocket();
        
        Receiver receiver = new Receiver();
        
        Thread inThread = new Thread(receiver);
        inThread.setDaemon(true);
        inThread.setName("com.alibaba.nacos.naming.push.receiver");
        inThread.start();
        
        GlobalExecutor.scheduleRetransmitter(() -> {
            try {
                
                // 定时移除已经 断开的客户端
                removeClientIfZombie();
            } catch (Throwable e) {
                Loggers.PUSH.warn("[NACOS-PUSH] failed to remove client zombie");
            }
        }, 0, 20, TimeUnit.SECONDS);
        
    } catch (SocketException e) {
        Loggers.SRV_LOG.error("[NACOS-PUSH] failed to init push service");
    }
}

再看到 “监听自己” 的 onApplicationEvent方法

@Override
public void onApplicationEvent(ServiceChangeEvent event) {
    
    // 得到发生变化 的服务
    Service service = event.getService();
    
    //得到 服务名称
    String serviceName = service.getName();
    
    // 得到 namespaceId
    String namespaceId = service.getNamespaceId();
    
    // 用线程池 异步执行任务、发送服务最新数据给 所有的监听者
    Future future = GlobalExecutor.scheduleUdpSender(() -> {
        try {
            Loggers.PUSH.info(serviceName + " is changed, add it to push queue.");
            
            // 得到监听当前服务 【namespaceId, serviceName】 的所有的消费者的 客户端 的PushClient
            ConcurrentMap<String, PushClient> clients = clientMap
                    .get(UtilsAndCommons.assembleFullServiceName(namespaceId, serviceName));
            if (MapUtils.isEmpty(clients)) {
                return;
            }
            
            Map<String, Object> cache = new HashMap<>(16);
            long lastRefTime = System.nanoTime();
            for (PushClient client : clients.values()) {
                // 遍历所有的 PushClient
                if (client.zombie()) {
                    
                    // 挂掉 的PushClient，直接移除
                    Loggers.PUSH.debug("client is zombie: " + client.toString());
                    clients.remove(client.toString());
                    Loggers.PUSH.debug("client is zombie: " + client.toString());
                    continue;
                }
                
                // 准备消息
                Receiver.AckEntry ackEntry;
                Loggers.PUSH.debug("push serviceName: {} to client: {}", serviceName, client.toString());
                String key = getPushCacheKey(serviceName, client.getIp(), client.getAgent());
                byte[] compressData = null;
                Map<String, Object> data = null;
                if (switchDomain.getDefaultPushCacheMillis() >= 20000 && cache.containsKey(key)) {
                    org.javatuples.Pair pair = (org.javatuples.Pair) cache.get(key);
                    compressData = (byte[]) (pair.getValue0());
                    data = (Map<String, Object>) pair.getValue1();
                    
                    Loggers.PUSH.debug("[PUSH-CACHE] cache hit: {}:{}", serviceName, client.getAddrStr());
                }
                
                if (compressData != null) {
                    ackEntry = prepareAckEntry(client, compressData, data, lastRefTime);
                } else {
                    ackEntry = prepareAckEntry(client, prepareHostsData(client), lastRefTime);
                    if (ackEntry != null) {
                        cache.put(key, new org.javatuples.Pair<>(ackEntry.origin.getData(), ackEntry.data));
                    }
                }
                
                Loggers.PUSH.info("serviceName: {} changed, schedule push for: {}, agent: {}, key: {}",
                        client.getServiceName(), client.getAddrStr(), client.getAgent(),
                        (ackEntry == null ? null : ackEntry.key));
                
                // 利用UDP 套接字，发送 服务信息
                udpPush(ackEntry);
            }
        } catch (Exception e) {
            Loggers.PUSH.error("[NACOS-PUSH] failed to push serviceName: {} to client, error: {}", serviceName, e);
            
        } finally {
            futureMap.remove(UtilsAndCommons.assembleFullServiceName(namespaceId, serviceName));
        }
        
    }, 1000, TimeUnit.MILLISECONDS);
    
    futureMap.put(UtilsAndCommons.assembleFullServiceName(namespaceId, serviceName), future);
    
}

在这里插入图片描述

OK，再次回答 我们 的问题

问题说明：考察对Nacos、Eureka的底层实现的掌握情况

难易程度：难

参考话术：

Nacos与Eureka有相同点，也有不同之处，可以从以下几点来描述：

  • 接口方式：Nacos与Eureka都对外暴露了Rest风格的API接口，用来实现服务注册、发现等功能
  • 实例类型：Nacos的实例有永久和临时实例之分；而Eureka只支持临时实例
  • 健康检测：Nacos对临时实例采用心跳模式检测，对永久实例采用主动请求来检测；Eureka只支持心跳模式
  • 服务发现：Nacos支持定时拉取和订阅推送两种模式；Eureka只支持定时拉取模式【这次说了 这个】

Nacos的服务发现分为两种模式：

  • 模式一：主动拉取模式，消费者定期主动从Nacos拉取服务列表并缓存起来，再服务调用时优先读取本地缓存中的服务列表。
  • 模式二：订阅模式，消费者订阅Nacos中的服务列表，并基于UDP协议来接收服务变更通知。当Nacos中的服务列表更新时，会发送UDP广播给所有订阅者。

与Eureka相比，Nacos的订阅模式服务状态更新更及时，消费者更容易及时发现服务列表的变化，剔除故障服务。

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

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

相关文章

基于STM32单片机智能自动伸缩衣架雨滴重量光强温度检测伸缩速度可调-蓝牙版

基于STM32单片机智能自动伸缩衣架雨滴重量光强温度检测伸缩速度可调-蓝牙版

实践制作DIY- GC0010-智能自动伸缩衣架 一、功能说明&#xff1a; 基于STM32单片机设计-智能自动伸缩衣架 功能介绍&#xff1a; 基于STM32F103C系列&#xff0c;LCD1602显示器&#xff0c;光敏电阻采集光强&#xff0c;雨滴传感器&#xff0c;ULN2003控制步进电机&#xff0…
阅读更多...
【Redis实战专题】「技术提升系列」彻底分析探究Redission实现分布式锁的点点滴滴

【Redis实战专题】「技术提升系列」彻底分析探究Redission实现分布式锁的点点滴滴

Redission的简介 Redission 为 Redis 官网分布式解决方案 官网&#xff1a; Redisson: Redis Java client with features of In-Memory Data Grid 快速入门&#xff1a; https://github.com/redisson/redisson#quick-start github的Redission系列&#xff1a;https://github…
阅读更多...
SpringCloud学习笔记——Eureka 和 Nacos注册

SpringCloud学习笔记——Eureka 和 Nacos注册

SpringCloud01 1.认识微服务 随着互联网行业的发展&#xff0c;对服务的要求也越来越高&#xff0c;服务架构也从单体架构逐渐演变为现在流行的微服务架构。这些架构之间有怎样的差别呢&#xff1f; 1.0.学习目标 了解微服务架构的优缺点 1.1.单体架构 单体架构&#xff…
阅读更多...
2022年人工智能行业研究报告

2022年人工智能行业研究报告

第一章 行业概况 人工智能&#xff08;Artificial Intelligence&#xff09;&#xff0c;英文缩写为AI。它是研究、开发用于模拟、延伸和扩展人的智能的理论、方法、技术及应用系统的一门新的技术科学。 人工智能是计算机科学的一个分支&#xff0c;它企图了解智能的实质&…
阅读更多...
电脑剪辑视频用什么工具？好用的视频剪辑工具推荐

电脑剪辑视频用什么工具？好用的视频剪辑工具推荐

电脑剪辑视频用什么工具&#xff1f;小编通过搜集&#xff0c;给大家带来了几款比较适合做视频剪辑的工具。 一、Windows自带视频编辑器 win10自带的免费视频编辑器吗&#xff1f;我相信很多人应该不知道吧&#xff01;其实电脑自带的视频编辑器&#xff0c;也是可以进行裁剪视…
阅读更多...
计算机毕业设计 SSM与Vue的宿舍后勤管理系统(源码+论文)

计算机毕业设计 SSM与Vue的宿舍后勤管理系统(源码+论文)

文章目录1 项目简介2 实现效果2.1 界面展示3 设计方案3.1 概述3.2 系统流程3.2.1 系统开发流程3.2.2 系统操作流程3.3 系统结构设计4 项目获取1 项目简介 Hi&#xff0c;各位同学好呀&#xff01; 今天向大家分享一个今年(2022)最新完成的毕业设计项目作品&#xff0c;【基于…
阅读更多...
BCN基团endo-BCN-SS-NHS ester

BCN基团endo-BCN-SS-NHS ester

【产品描述】 endo-BCN-SS-NHS ester中BCN基团可以发生相应的点击反应&#xff0c;二硫键在化学上是一条从结合硫醇而衍生的单共价键。它又称为二硫键或双硫桥&#xff0c;差不多只用于生物化学的范畴。 【中文名称】endo 丙烷环辛炔-双硫键-活性酯 【英文名称】 endo-BCN-SS-N…
阅读更多...
【人脸识别】LBP人脸识别【含GUI Matlab源码 1282期】

【人脸识别】LBP人脸识别【含GUI Matlab源码 1282期】

⛄一、LBP简介 LBP&#xff08;Local Binary Pattern&#xff0c;局部二值模式&#xff09;是一种用来描述图像局部纹理特征的算子&#xff1b;它具有旋转不变性和灰度不变性等显著的优点。它是首先由T. Ojala, M.Pietikinen, 和D. Harwood 在1994年提出&#xff0c;用于纹理特…
阅读更多...
2022注定的不平凡我

2022注定的不平凡我

这次的时光好像没有追溯了&#xff0c;追溯请看这一篇文章拜拜嘞——老东家 时间很短&#xff0c;变化很快&#xff0c;一时间还有些承受不了&#xff0c;入职的两个月零四天&#xff0c;很突然的我被炒鱿鱼了。 依稀记得那个周五&#xff0c;Hr找我谈话&#xff0c;说目前达…
阅读更多...
在3568开发板上开发外设模块——竟如此简单！

在3568开发板上开发外设模块——竟如此简单！

针对这些模块&#xff0c;我们编写了9个实验做成了《itop-3568开发板驱动实验手册》&#xff0c;从实验原理、硬件连接、原理图分析、实验平台、实验步骤一步一步教大家如果配置使用这些模块。 后续《itop-3568开发板驱动实验手册》中的实验也会全部录制成视频教程&#xff01;…
阅读更多...
【Redis技术探索】「底层架构原理」帮你从底层彻底吃透RDB技术原理（入门第一步）

【Redis技术探索】「底层架构原理」帮你从底层彻底吃透RDB技术原理（入门第一步）

每日一句 低头是一种能力&#xff0c;它不是自卑&#xff0c;也不是怯弱&#xff0c;它是清醒中的嬗变。有时&#xff0c;稍微低一下头&#xff0c;或者我们的人生路会更精彩。 前提概要 Redis是一个的键-值&#xff08;K-V&#xff09;对的内存数据库服务&#xff0c;通常包含…
阅读更多...
读取csv格式的数据--Pandas

读取csv格式的数据--Pandas

1. 函数功能 读取逗号分隔数据的文件comma-separated values (csv) 2. 函数语法 pandas.read_csv(filepath_or_buffer, *, sep_NoDefault.no_default, delimiterNone, headerinfer, names_NoDefault.no_default, index_colNone, usecolsNone, squeezeNone, prefix_NoDefau…
阅读更多...
氢燃料电池汽车的前景、主要优势及发展难点

氢燃料电池汽车的前景、主要优势及发展难点

氢燃料电池汽车的前景 氢燃料电池&#xff08;电动&#xff09;汽车的关键所在和奥秘之处&#xff0c;在于它的动力来源—氢燃料电池近乎完美和非常理想的工作原理与机制&#xff0c;它名义上叫“电池”&#xff0c;而实质上是一种基于化学原理&#xff0c;将作为“燃料”&…
阅读更多...
java 瑞吉外卖 day5 套餐管理业务 套餐新增，套餐分页查询 套餐修改 套餐停售起售设置 短信服务

java 瑞吉外卖 day5 套餐管理业务 套餐新增，套餐分页查询 套餐修改 套餐停售起售设置 短信服务

新增套餐 准备工作&#xff1a; 套餐信息分页查询 前面已经写了好几个分页查询了&#xff0c;这里查询的关键点&#xff0c;是套餐分类名称&#xff0c;不在套餐表中&#xff0c;我们要到别的表里拿&#xff0c;然后封装进setmealDto GetMapping("/page") public R p…
阅读更多...
二维周期光栅结构的配置

二维周期光栅结构的配置

摘要 复杂光学光栅结构被广泛用于多种应用&#xff0c;如光谱仪、近眼显示系统等。利用傅里叶模态法(FMM&#xff0c;或称RCWA) VirtualLab Fusion 提供了一种用于任意光栅结构严格分析的简单方法。利用图形用户界面&#xff0c;用户可以设置堆栈的几何形状&#xff0c;从而产生…
阅读更多...
【实战】一次简单的log4j漏洞测试

【实战】一次简单的log4j漏洞测试

更新时间&#xff1a;2021.12.19 参考文档&#xff1a;https://www.yuque.com/u8021480/crow/dg9xax 在去年log4j漏洞刚爆发的时候&#xff0c;很多平台都存在漏洞&#xff0c;当时也在第一时间在有授权的情况下对某论坛进行了渗透测试&#xff0c;结果发现存在漏洞&#xff0…
阅读更多...
gitlabjenkins

gitlabjenkins

使用容器安装gitlab 1.添加容器 docker run --detach \ --hostname 192.168.44.103 \ --publish 443:443 --publish 80:80 \ --name gitlab \ --restart always \ --volume $GITLAB_HOME/config:/etc/gitlab:Z \ --volume $GITLAB_HOME/logs:/var/log/gitlab:Z \ …
阅读更多...
用javascript分类刷leetcode9.位运算(图文视频讲解)

用javascript分类刷leetcode9.位运算(图文视频讲解)

位运算基础&#xff1a; 程序中所有的数载计算机内存中都是以二进制存储的&#xff0c;位运算就是直接对整数在内存中的二进制进行操作&#xff0c;由于直接在内存中进行操作&#xff0c;不需要转成十进制&#xff0c;因此处理速度非常快 常见位运算 x & 1 0 //判断奇偶…
阅读更多...
领略设计模式的魅力，谈谈组合模式搭配访问者模式

领略设计模式的魅力，谈谈组合模式搭配访问者模式

组合模式&#xff08;composite&#xff09; 我们都知道文件和文件夹的概念&#xff0c;并且文件是可以存放在文件夹中&#xff0c;文件夹中也可以存放其他文件夹。需要设计一个简单的程序来实现文件夹和文件的关系。 实现思路 文件夹需要存放文件夹和文件&#xff0c;首先想到…
阅读更多...
大恒普信携手昇思推出眼健康AI智能分析系统，为眼科医疗行业数字化转型升级助力

大恒普信携手昇思推出眼健康AI智能分析系统，为眼科医疗行业数字化转型升级助力

电子屏幕时代&#xff0c;人们的用眼强度不断增加&#xff0c;各种眼底疾病也开始广泛出现&#xff0c;如青光眼、病理性近视、糖尿病视网膜病变等&#xff0c;严重时可致盲。其实&#xff0c;对大多数眼底疾病而言&#xff0c;如果能早发现、早治疗&#xff0c;就可以很好地预…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023