Nacos源码解读04——服务发现

SpringBoot自动注入

项目启动的时候会通过自动注入的机制将
NacosDiscoveryClientConfiguration注入在这里插入图片描述
当注入NacosDiscoveryClientConfiguration的时候会将DiscoveryClient一起注入Bean
DiscoveryClient实现了SpringCloud的DiscoveryClient接口，重点是getInstances和getServices方法，而且都是由NacosServiceDiscovery实现
在这里插入图片描述

获取实例信息

NacosDiscoveryClient

	private NacosServiceDiscovery serviceDiscovery;

	public NacosDiscoveryClient(NacosServiceDiscovery nacosServiceDiscovery) {
		this.serviceDiscovery = nacosServiceDiscovery;
	}

	@Override
	public List<ServiceInstance> getInstances(String serviceId) {
		try {
			return serviceDiscovery.getInstances(serviceId);
		}
		catch (Exception e) {
			throw new RuntimeException(
					"Can not get hosts from nacos server. serviceId: " + serviceId, e);
		}
	}

	public List<ServiceInstance> getInstances(String serviceId) throws NacosException {
		String group = discoveryProperties.getGroup();
		List<Instance> instances = namingService().selectInstances(serviceId, group,
				true);
		return hostToServiceInstanceList(instances, serviceId);
	}

NacosServiceDiscovery

	public List<ServiceInstance> getInstances(String serviceId) throws NacosException {
	    //获取分组
		String group = discoveryProperties.getGroup();
		//查询服务下的实例
		List<Instance> instances = namingService().selectInstances(serviceId, group,
				true);
				//填充返回的实例信息数据
		return hostToServiceInstanceList(instances, serviceId);
	}

    @Override
    public List<Instance> selectInstances(String serviceName, String groupName, boolean healthy) throws NacosException {
        return selectInstances(serviceName, groupName, healthy, true);
    }

    @Override
    public List<Instance> selectInstances(String serviceName, String groupName, boolean healthy, boolean subscribe)
            throws NacosException {
        return selectInstances(serviceName, groupName, new ArrayList<String>(), healthy, subscribe);
    }

    @Override
    public List<Instance> selectInstances(String serviceName, String groupName, List<String> clusters, boolean healthy,
            boolean subscribe) throws NacosException {
        
        ServiceInfo serviceInfo;
        String clusterString = StringUtils.join(clusters, ",");
         // 默认是订阅的
        if (subscribe) {
            //从缓存中获取实例信息
            serviceInfo = serviceInfoHolder.getServiceInfo(serviceName, groupName, clusterString);
            //如果获取不到则从服务端拉取
            if (null == serviceInfo) {
                serviceInfo = clientProxy.subscribe(serviceName, groupName, clusterString);
            }
        } else {
             // 如果未订阅服务信息，则直接从服务器进行查询
            serviceInfo = clientProxy.queryInstancesOfService(serviceName, groupName, clusterString, 0, false);
        }
        //获取服务中的实例信息
        return selectInstances(serviceInfo, healthy);
    }

从缓存中拿数据

    public ServiceInfo getServiceInfo(final String serviceName, final String groupName, final String clusters) {
        NAMING_LOGGER.debug("failover-mode: {}", failoverReactor.isFailoverSwitch());
        String groupedServiceName = NamingUtils.getGroupedName(serviceName, groupName);
        String key = ServiceInfo.getKey(groupedServiceName, clusters);
        if (failoverReactor.isFailoverSwitch()) {
            return failoverReactor.getService(key);
        }
        return serviceInfoMap.get(key);
    }

获取服务的实例信息

    private List<Instance> selectInstances(ServiceInfo serviceInfo, boolean healthy) {
        List<Instance> list;
        
        if (serviceInfo == null || CollectionUtils.isEmpty(list = serviceInfo.getHosts())) {
            return new ArrayList<Instance>();
        }
        
        Iterator<Instance> iterator = list.iterator();
        while (iterator.hasNext()) {
            Instance instance = iterator.next();
            // 保留 健康、启用、权重大于0 的实例
            if (healthy != instance.isHealthy() || !instance.isEnabled() || instance.getWeight() <= 0) {
                iterator.remove();
            }
        }
        
        return list;
    }

GRPC请求拉取服务实例信息

    @Override
    public ServiceInfo subscribe(String serviceName, String groupName, String clusters) throws NacosException {
        NAMING_LOGGER.info("[SUBSCRIBE-SERVICE] service:{}, group:{}, clusters:{} ", serviceName, groupName, clusters);
        
        String serviceNameWithGroup = NamingUtils.getGroupedName(serviceName, groupName);
        String serviceKey = ServiceInfo.getKey(serviceNameWithGroup, clusters);
        //定时同步服务端serviceInfo
        serviceInfoUpdateService.scheduleUpdateIfAbsent(serviceName, groupName, clusters);
        //获取ServiceInfo 信息
        ServiceInfo result = serviceInfoHolder.getServiceInfoMap().get(serviceKey);
        //如果没有则从服务端拿
        if (null == result || !isSubscribed(serviceName, groupName, clusters)) {
            //GRPC请求
            result = grpcClientProxy.subscribe(serviceName, groupName, clusters);
        }
        //填充进Map中 这里可以看服务注册最后那部分代码最后也是调用serviceInfoHolder保存的
        serviceInfoHolder.processServiceInfo(result);
        return result;
    }

定时同步服务端ServiceInfo

    public void scheduleUpdateIfAbsent(String serviceName, String groupName, String clusters) {
        String serviceKey = ServiceInfo.getKey(NamingUtils.getGroupedName(serviceName, groupName), clusters);
        if (futureMap.get(serviceKey) != null) {
            return;
        }
        synchronized (futureMap) {
            if (futureMap.get(serviceKey) != null) {
                return;
            }
            //构建任务放到ScheduledFuture执行
            ScheduledFuture<?> future = addTask(new UpdateTask(serviceName, groupName, clusters));
            futureMap.put(serviceKey, future);
        }
    }

缓存订阅信息

    public void cacheSubscriberForRedo(String serviceName, String groupName, String cluster) {
       //拿服务当key
        String key = ServiceInfo.getKey(NamingUtils.getGroupedName(serviceName, groupName), cluster);
        //构建需要缓存的订阅信息
        SubscriberRedoData redoData = SubscriberRedoData.build(serviceName, groupName, cluster);
        //缓存订阅信息
        synchronized (subscribes) {
            subscribes.put(key, redoData);
        }
    }

执行订阅

    public ServiceInfo doSubscribe(String serviceName, String groupName, String clusters) throws NacosException {
       //构建订阅请求
        SubscribeServiceRequest request = new SubscribeServiceRequest(namespaceId, groupName, serviceName, clusters,
                true);
                //执行订阅
        SubscribeServiceResponse response = requestToServer(request, SubscribeServiceResponse.class);
        //设置已订阅
        redoService.subscriberRegistered(serviceName, groupName, clusters);
        return response.getServiceInfo();
    }

设置订阅信息已订阅

    public void subscriberRegistered(String serviceName, String groupName, String cluster) {
        String key = ServiceInfo.getKey(NamingUtils.getGroupedName(serviceName, groupName), cluster);
        synchronized (subscribes) {
            SubscriberRedoData redoData = subscribes.get(key);
             // 标记订阅数据已订阅
            if (null != redoData) {
                redoData.setRegistered(true);
            }
        }
    }

Nacos订阅机制

Nacos的订阅机制，如果用一句话来描述就是：Nacos客户端通过一个定时任务，每6秒从注册中心获取实例列表，当发现实例发生变化时，发布变更事件，订阅者进行业务处理。该更新实例的更新实例，该更新本地缓存的更新本地缓存。
UpdateTask

 public class UpdateTask implements Runnable {
    public void run() {
            long delayTime = DEFAULT_DELAY;
            
            try {
                  //校验订阅任务是否不对 如果不对就不处理 
                if (!changeNotifier.isSubscribed(groupName, serviceName, clusters) && !futureMap.containsKey(
                        serviceKey)) {
                    NAMING_LOGGER.info("update task is stopped, service:{}, clusters:{}", groupedServiceName, clusters);
                    isCancel = true;
                    return;
                }
                //从缓存中拿 Service信息
                ServiceInfo serviceObj = serviceInfoHolder.getServiceInfoMap().get(serviceKey);
                //如果拿不到则去服务端拉取
                if (serviceObj == null) {
                    serviceObj = namingClientProxy.queryInstancesOfService(serviceName, groupName, clusters, 0, false);              
                    //然后再填充进缓存 
                    serviceInfoHolder.processServiceInfo(serviceObj);
                    //更新下事件
                    lastRefTime = serviceObj.getLastRefTime();
                    return;
                }
                // 过期服务（服务的最新更新时间小于等于缓存刷新时间），从注册中心重新查询
                if (serviceObj.getLastRefTime() <= lastRefTime) {
                    //服务过期了重新查
                    serviceObj = namingClientProxy.queryInstancesOfService(serviceName, groupName, clusters, 0, false);             //在缓存进去
                    serviceInfoHolder.processServiceInfo(serviceObj);
                }
                // 刷新更新时间
                lastRefTime = serviceObj.getLastRefTime();
                if (CollectionUtils.isEmpty(serviceObj.getHosts())) {
                    incFailCount();
                    return;
                }
                // 下次更新缓存时间设置，默认为6秒
                // TODO multiple time can be configured.
                delayTime = serviceObj.getCacheMillis() * DEFAULT_UPDATE_CACHE_TIME_MULTIPLE;
                // 重置失败数量为0
                resetFailCount();
            } catch (Throwable e) {
                incFailCount();
                NAMING_LOGGER.warn("[NA] failed to update serviceName: {}", groupedServiceName, e);
            } finally {
        // 下次调度刷新时间，下次执行的时间与failCount有关
        // failCount=0，则下次调度时间为6秒，最长为1分钟
        // 即当无异常情况下缓存实例的刷新时间是6秒
                if (!isCancel) {
                    executor.schedule(this, Math.min(delayTime << failCount, DEFAULT_DELAY * 60),
                            TimeUnit.MILLISECONDS);
                }
            }
    }
    
}

实例变更事件处理

监听事件的注册

在NacosNamingService的subscribe方法中，通过如下方式进行了监听事件的注册：

    @Override
    public void subscribe(String serviceName, String groupName, List<String> clusters, EventListener listener)
            throws NacosException {
        if (null == listener) {
            return;
        }
        String clusterString = StringUtils.join(clusters, ",");
        changeNotifier.registerListener(groupName, serviceName, clusterString, listener);
        clientProxy.subscribe(serviceName, groupName, clusterString);
    }

这里的changeNotifier.registerListener便是进行具体的事件注册逻辑

   public void registerListener(String groupName, String serviceName, String clusters, EventListener listener) {
        String key = ServiceInfo.getKey(NamingUtils.getGroupedName(serviceName, groupName), clusters);
        ConcurrentHashSet<EventListener> eventListeners = listenerMap.get(key);
        //这里用到了双重检查锁机制
        if (eventListeners == null) {
            synchronized (lock) {
                eventListeners = listenerMap.get(key);
                if (eventListeners == null) {
                    eventListeners = new ConcurrentHashSet<EventListener>();
                    listenerMap.put(key, eventListeners);
                }
            }
        }
        eventListeners.add(listener);
    }

可以看出，事件的注册便是将EventListener存储在InstancesChangeNotifier的listenerMap属性当中了。

这里的数据结构为Map，key为服务实例信息的拼接，value为监听事件的集合。

监听服务变更事件

因为UpdateTask 中假如没有从缓存中拿到服务信息则会通过grpc协议从服务端拉取然后会执行serviceInfoHolder.processServiceInfo方法缓存服务信息，当实例发生变化的话这个方法最终会发送一个InstancesChangeEvent 事件 所以这里会监听InstancesChangeEvent 事件进行处理

InstancesChangeNotifier

public class InstancesChangeNotifier extends Subscriber<InstancesChangeEvent> {
    private final Map<String, ConcurrentHashSet<EventListener>> listenerMap = new ConcurrentHashMap<String, ConcurrentHashSet<EventListener>>();
    @Override
    public void onEvent(InstancesChangeEvent event) {
        String key = ServiceInfo.getKey(NamingUtils.getGroupedName(event.getServiceName(), event.getGroupName()), event.getClusters());
        ConcurrentHashSet<EventListener> eventListeners = listenerMap.get(key);
        if (CollectionUtils.isEmpty(eventListeners)) {
            return;
        }
        for (final EventListener listener : eventListeners) {
            //[] final com.alibaba.nacos.api.naming.listener.Event namingEvent = transferToNamingEvent(event);
            final com.alibaba.nacos.api.naming.listener.Event namingEvent = new NamingEvent(instancesChangeEvent.getServiceName(), instancesChangeEvent.getGroupName(),
                instancesChangeEvent.getClusters(), instancesChangeEvent.getHosts());
            // 最终调度执行listener.onEvent(namingEvent)，只在NacosWatch#start找到了有效的EventListener，见下文
            if (listener instanceof AbstractEventListener && ((AbstractEventListener) listener).getExecutor() != null) {
                ((AbstractEventListener) listener).getExecutor().execute(() -> listener.onEvent(namingEvent));
            } else {
                listener.onEvent(namingEvent);
            }
        }
    }
}
}


public class NacosWatch implements ApplicationEventPublisherAware, SmartLifecycle, DisposableBean {
    private Map<String, EventListener> listenerMap = new ConcurrentHashMap(16);
    private final AtomicBoolean running = new AtomicBoolean(false);

    public void start() {
        if (this.running.compareAndSet(false, true)) {
            EventListener eventListener = (EventListener)this.listenerMap.computeIfAbsent(this.buildKey(), (event) -> {
                return new EventListener() {
                    public void onEvent(Event event) {
                        if (event instanceof NamingEvent) {
                            List instances = ((NamingEvent)event).getInstances();
                            
                            //[] Optional instanceOptional = NacosWatch.this.selectCurrentInstance(instances);
                            
                            // 按IP和端口选择第一个instance作为当前的instance
                            Optional instanceOptional = instances.stream().filter((instance) -> {
                                return this.properties.getIp().equals(instance.getIp()) && this.properties.getPort() == instance.getPort();
                            }).findFirst()
                                
                            instanceOptional.ifPresent((currentInstance) -> {
                                //[] NacosWatch.this.resetIfNeeded(currentInstance);
                                // 重新设置properties的metadata
                                if (!this.properties.getMetadata().equals(instance.getMetadata())) {
                                    this.properties.setMetadata(instance.getMetadata());
                                }
                            });
                        }
                    }
                };
            });
        }
    }

获取服务信息

NacosDiscoveryClient

	@Override
	public List<String> getServices() {
		try {
			return serviceDiscovery.getServices();
		}
		catch (Exception e) {
			log.error("get service name from nacos server fail,", e);
			return Collections.emptyList();
		}
	}

	public List<String> getServices() throws NacosException {
	    //获取分组
		String group = discoveryProperties.getGroup();
		//获取服务信息
		ListView<String> services = namingService().getServicesOfServer(1,
				Integer.MAX_VALUE, group);
		return services.getData();
	}

    @Override
    public ListView<String> getServicesOfServer(int pageNo, int pageSize, String groupName) throws NacosException {
        return getServicesOfServer(pageNo, pageSize, groupName, null);
    }

    @Override
    public ListView<String> getServicesOfServer(int pageNo, int pageSize, String groupName, AbstractSelector selector)
            throws NacosException {
        return clientProxy.getServiceList(pageNo, pageSize, groupName, selector);
    }

GRPC拉取信息

    @Override
    public ListView<String> getServiceList(int pageNo, int pageSize, String groupName, AbstractSelector selector)
            throws NacosException {
            //构建请求
        ServiceListRequest request = new ServiceListRequest(namespaceId, groupName, pageNo, pageSize);
        if (selector != null) {
            if (SelectorType.valueOf(selector.getType()) == SelectorType.label) {
                request.setSelector(JacksonUtils.toJson(selector));
            }
        }
        //采用GRPC协议拉取信息
        ServiceListResponse response = requestToServer(request, ServiceListResponse.class);
        ListView<String> result = new ListView<String>();
        result.setCount(response.getCount());
        result.setData(response.getServiceNames());
        return result;
    }

服务端处理GRPC请求

接收获取服务的请求

ServiceListRequestHandler

    @Override
    @Secured(action = ActionTypes.READ)
    public ServiceListResponse handle(ServiceListRequest request, RequestMeta meta) throws NacosException {
        //根据命名空间获取这个命名空间下的所有服务信息  erviceManager.getInstance().getSingletons这个方法服务注册的时候里有
        Collection<Service> serviceSet = ServiceManager.getInstance().getSingletons(request.getNamespace());
        //构建返回信息
        ServiceListResponse result = ServiceListResponse.buildSuccessResponse(0, new LinkedList<>());
        //服务信息不等于空填充返回信息
        if (!serviceSet.isEmpty()) {
            Collection<String> serviceNameSet = selectServiceWithGroupName(serviceSet, request.getGroupName());
            // TODO select service by selector
            List<String> serviceNameList = ServiceUtil
                    .pageServiceName(request.getPageNo(), request.getPageSize(), serviceNameSet);
            result.setCount(serviceNameSet.size());
            result.setServiceNames(serviceNameList);
        }
        return result;
    }

订阅服务请求

SubscribeServiceRequestHandler

    @Override
    @Secured(action = ActionTypes.READ)
    public SubscribeServiceResponse handle(SubscribeServiceRequest request, RequestMeta meta) throws NacosException {
        //命名空间
        String namespaceId = request.getNamespace();
        //服务名称
        String serviceName = request.getServiceName();
        //分组名称
        String groupName = request.getGroupName();
        String app = request.getHeader("app", "unknown");
        String groupedServiceName = NamingUtils.getGroupedName(serviceName, groupName);
        //构建服务信息
        Service service = Service.newService(namespaceId, groupName, serviceName, true);
        //组装订阅请求
        Subscriber subscriber = new Subscriber(meta.getClientIp(), meta.getClientVersion(), app, meta.getClientIp(),
                namespaceId, groupedServiceName, 0, request.getClusters());
         //获取健康的实例       
        ServiceInfo serviceInfo = ServiceUtil.selectInstancesWithHealthyProtection(serviceStorage.getData(service),               //服务元数据信息    
                metadataManager.getServiceMetadata(service).orElse(null), subscriber);
          //是否订阅      
        if (request.isSubscribe()) {
            clientOperationService.subscribeService(service, subscriber, meta.getConnectionId());
        } else {
            clientOperationService.unsubscribeService(service, subscriber, meta.getConnectionId());
        }
        //构建返回数据
        return new SubscribeServiceResponse(ResponseCode.SUCCESS.getCode(), "success", serviceInfo);
    }

发送订阅事件 后续事件监听可参考服务事件处理的那篇文章

    @Override
    public void subscribeService(Service service, Subscriber subscriber, String clientId) {
        Service singleton = ServiceManager.getInstance().getSingletonIfExist(service).orElse(service);
        Client client = clientManager.getClient(clientId);
        if (!clientIsLegal(client, clientId)) {
            return;
        }
        client.addServiceSubscriber(singleton, subscriber);
        client.setLastUpdatedTime();
        NotifyCenter.publishEvent(new ClientOperationEvent.ClientSubscribeServiceEvent(singleton, clientId));
    }

发送取消订阅事件 后续事件监听可参考服务事件处理的那篇文章

    @Override
    public void unsubscribeService(Service service, Subscriber subscriber, String clientId) {
        Service singleton = ServiceManager.getInstance().getSingletonIfExist(service).orElse(service);
        Client client = clientManager.getClient(clientId);
        if (!clientIsLegal(client, clientId)) {
            return;
        }
        client.removeServiceSubscriber(singleton);
        client.setLastUpdatedTime();
        NotifyCenter.publishEvent(new ClientOperationEvent.ClientUnsubscribeServiceEvent(singleton, clientId));
    }

服务查询请求

ServiceQueryRequestHandler

    @Override
    @Secured(action = ActionTypes.READ)
    public QueryServiceResponse handle(ServiceQueryRequest request, RequestMeta meta) throws NacosException {
        //获取命名空间
        String namespaceId = request.getNamespace();
        //分组明
        String groupName = request.getGroupName();
        //服务名
        String serviceName = request.getServiceName();
        //创建服务信息
        Service service = Service.newService(namespaceId, groupName, serviceName);
        //集群
        String cluster = null == request.getCluster() ? "" : request.getCluster();
        boolean healthyOnly = request.isHealthyOnly();
        //获取服务信息
        ServiceInfo result = serviceStorage.getData(service);
        //获取服务元数据信息
        ServiceMetadata serviceMetadata = metadataManager.getServiceMetadata(service).orElse(null);
        // 获取有保护机制的健康实例
        result = ServiceUtil.selectInstancesWithHealthyProtection(result, serviceMetadata, cluster, healthyOnly, true,
                meta.getClientIp());
                //构建返回信息
        return QueryServiceResponse.buildSuccessResponse(result);
    }

    public ServiceInfo getData(Service service) {
        return serviceDataIndexes.containsKey(service) ? serviceDataIndexes.get(service) : getPushData(service);
    }

    public Optional<ServiceMetadata> getServiceMetadata(Service service) {
        return Optional.ofNullable(serviceMetadataMap.get(service));
    }

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

观察者设计模式

观察者设计模式

package com.jmj.pattern.observer;/*抽象观察者类*/ public interface Observer {void update(String message);}package com.jmj.pattern.observer;/*** 抽象主题角色*/ public interface Subject {//添加观察者对象void attach(Observer observer);//删除订阅者void detach(…
阅读更多...
Docker的常用基本命令（基础命令）

Docker的常用基本命令（基础命令）

文章目录 1. Docker简介2. Docker环境安装Linux安装 3. 配置镜像加速4. Docker镜像常用命令列出镜像列表搜索镜像下载镜像查看镜像版本删除镜像构建镜像推送镜像 5. Docker容器常用命令新建并启动容器列出容器停止容器启动容器进入容器删除容器&#xff08;慎用&#xff09;查看…
阅读更多...
AI创作ChatGPT源码+AI绘画（Midjourney绘画）+DALL-E3文生图+思维导图生成

AI创作ChatGPT源码+AI绘画（Midjourney绘画）+DALL-E3文生图+思维导图生成

一、AI创作系统 SparkAi创作系统是基于ChatGPT进行开发的Ai智能问答系统和Midjourney绘画系统&#xff0c;支持OpenAI-GPT全模型国内AI全模型。本期针对源码系统整体测试下来非常完美&#xff0c;可以说SparkAi是目前国内一款的ChatGPT对接OpenAI软件系统。那么如何搭建部署AI…
阅读更多...
安装selenium+chrome详解

安装selenium+chrome详解

1、创建yaml文件 创建yaml文件，命名为：docker-compose-chrome.yaml，具体内容如下： version: "3.9" services:spiderdriver:image: selenium/standalone-chrome:114.0restart: alwayshostname: spiderdrivercontainer_name: spiderdriverdeploy:resources:limit…
阅读更多...
为何全球电商都在拼“质价比”？

为何全球电商都在拼“质价比”？

远在西雅图的希拉里&#xff0c;在著名的“黑色星期五”大促开始之前&#xff0c;她就已经准备好了一份购物清单。 然而&#xff0c;她发现身边的朋友们总是拉她组团购物。 在朋友和社交媒体的持续轰炸下&#xff0c;希拉里决定尝试一下这个让人贼上头的Temu。 最终&#xf…
阅读更多...
4.OpenResty系列之Nginx负载均衡

4.OpenResty系列之Nginx负载均衡

1. 负载均衡配置 上篇文章中&#xff0c;代理仅仅指向一个服务器。但是&#xff0c;网站在实际运营过程中&#xff0c;大部分都是以集群的方式运行&#xff0c;这时需要使用负载均衡来分流。nginx 也可以实现简单的负载均衡功能。 假设这样一个应用场景&#xff1a;将应用部署…
阅读更多...
鸿蒙绘制折线图基金走势图

鸿蒙绘制折线图基金走势图

鉴于鸿蒙下一代剥离aosp&#xff0c;对于小公司而言&#xff0c;要么用h5重构&#xff0c;要么等大厂完善工具、等华为出转换工具后跟进&#xff0c;用鸿蒙重新开发一套代码对于一般公司而言成本会大幅增加。但对于广大开发者来说&#xff0c;暂且不论未来鸿蒙发展如何&#xf…
阅读更多...
在PyCharm中运行OpenCV

在PyCharm中运行OpenCV

一、安装Anaconda配置python环境 这里选用清华大学开源软件镜像站&#xff1a;anaconda | 镜像站使用帮助 | 清华大学开源软件镜像站 | Tsinghua Open Source Mirror 下载的速度更快。 点击下载链接&#xff1a;Index of /anaconda/archive/ | 清华大学开源软件镜像站 | Tsin…
阅读更多...
神经网络模型预训练

神经网络模型预训练

根据神经网络各个层的计算逻辑用程序实现相关的计算&#xff0c;主要是&#xff1a;前向传播计算、反向传播计算、损失计算、精确度计算等&#xff0c;并提供保存超参数到文件中。 # coding: utf-8 import sys, os sys.path.append(os.pardir) # 为了导入父目录的文件而进行的…
阅读更多...
Redis对象

Redis对象

Redis根据基本数据结构构建了自己的一套对象系统。主要包括字符串对象、列表对象、哈希对象、集合对象和有序集合对象 同时不同的对象都有属于自己的一些特定的redis指令集&#xff0c;而且每种对象也包括多种编码类型&#xff0c;和实现方式。 Redis对象结构 struct redisOb…
阅读更多...
SSM SpringBoot vue社团事务管理系统

SSM SpringBoot vue社团事务管理系统

SSM SpringBoot vue社团事务管理系统 系统功能 登录 个人中心 人员信息管理 考勤信息管理 空闲时间管理 现金日记账管理 经费预算管理 物品租借管理 会议信息管理 活动信息管理 项目任务管理 公告通知管理 物资信息管理 开发环境和技术 开发语言&#xff1a;Java 使用框架:…
阅读更多...
华为1+x网络系统建设与运维（中级）-练习题2

华为1+x网络系统建设与运维（中级）-练习题2

一.设备命令 LSW1 [Huawei]sys LSW1 同理可得&#xff0c;给所有设备改名 二.VLAN LSW1 [LSW1]vlan ba 10 20 [LSW1]int g0/0/1 [LSW1-GigabitEthernet0/0/1]port link-type trunk [LSW1-GigabitEthernet0/0/1]port trunk allow-pass vlan 10 20 [LSW1-GigabitEthernet0/0/1]in…
阅读更多...
【Casbin】一篇文章入门Casbin

【Casbin】一篇文章入门Casbin

Casbin Casbin模型基础&#xff08;PERM&#xff09;Policy定义Request定义MatchersEffect ACL模型RBAC模型Go语言实战使用前先下载casbin包新建一个Casbin enforcer判断是否能通过增加Policy删除Policy更新Policy获取Policy Casbin 权限管理在几乎每个系统中都是必备的模块。…
阅读更多...
Spring Cloud Gateway与spring-cloud-circuitbreaker集成与理解

Spring Cloud Gateway与spring-cloud-circuitbreaker集成与理解

官方文档地址 本文以 spring-cloud2021版本为例子 spring-cloud-gateway文档地址&#xff1a; https://spring.io/projects/spring-cloud-gateway#overview spring-cloud-circuitbreaker文档地址&#xff1a; https://spring.io/projects/spring-cloud-circuitbreaker 两者…
阅读更多...
【LeetCode:1423. 可获得的最大点数 | 滑动窗口】

【LeetCode:1423. 可获得的最大点数 | 滑动窗口】

&#x1f680; 算法题 &#x1f680; &#x1f332; 算法刷题专栏 | 面试必备算法 | 面试高频算法 &#x1f340; &#x1f332; 越难的东西,越要努力坚持&#xff0c;因为它具有很高的价值&#xff0c;算法就是这样✨ &#x1f332; 作者简介&#xff1a;硕风和炜&#xff0c;…
阅读更多...
matlab 计算两点云之间的放缩倍数

matlab 计算两点云之间的放缩倍数

目录 一、算法原理1、原理概述2、参考文献二、代码实现三、结果展示本文由CSDN点云侠原创，原文链接。如果你不是在点云侠的博客中看到该文章，那么此处便是不要脸的爬虫与GPT。 一、算法原理 1、原理概述 放缩倍数即尺度参数，尺度参数可由２个公共点在不同坐标系下的距离之…
阅读更多...
leetcode：225. 用队列实现栈

leetcode：225. 用队列实现栈

一、题目 链接&#xff1a;225. 用队列实现栈 - 力扣&#xff08;LeetCode&#xff09; 函数原型&#xff1a; typedef struct { } MyStack; MyStack* myStackCreate() void myStackPush(MyStack* obj, int x) int myStackPop(MyStack* obj) int myStackTop(MyStack* obj) …
阅读更多...
【ArcGIS Pro微课1000例】0041：Pro强大的定位搜索功能、定位窗格、地图上查找地点

【ArcGIS Pro微课1000例】0041：Pro强大的定位搜索功能、定位窗格、地图上查找地点

一谈到搜索，你是不是还停留在矢量数据的属性表中呢？今天给大家介绍ArcGIS Pro中定位搜索强大功能的使用，可以基于在线地图、矢量数据等多种数据源，进行地址、地名、道路、坐标等的查找。 文章目录 一、定位工具介绍二、在线地图搜索三、本地矢量数据搜索四、无地图搜索五、…
阅读更多...
如何使用vue组件

如何使用vue组件

目录 1&#xff1a;组件之间的父子关系 2&#xff1a;使用组件的三个步骤 3&#xff1a;components组件的是私有子组件 4&#xff1a;在main.js文件中使用Vue.component全局注册组件 1&#xff1a;组件之间的父子关系 一&#xff1a;首先封装好的组件是不存在任何的关系的…
阅读更多...
scrapy-redis

scrapy-redis

一、什么是scrapy-redis Scrapy-Redis 是 Scrapy 框架的一个扩展&#xff0c;它提供了对 Redis 数据库的支持&#xff0c;用于实现分布式爬取。通过使用 Scrapy-Redis&#xff0c;你可以将多个 Scrapy 进程连接到同一个 Redis 服务器&#xff0c;共享任务队列和去重集&#xf…
阅读更多...
最新文章

Copyright @ 2022~2023