Spring Cloud Eureka的学习笔记

最新推荐文章于 2022-02-26 15:31:03 发布
最新推荐文章于 2022-02-26 15:31:03 发布
阅读量164 收藏
点赞数
分类专栏： 微服务 Java 文章标签： Spring Cloud Eureka
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lingboo111/article/details/90144961
版权

Spring Cloud Eureka

服务治理

  • 微服架构最为核心和基础的模块，主要用来实现各个微服务实例的自动化注册与发现。

服务注册

每个服务单元向注册中心登记自己提供的服务，将主机与端口号、版本号、通信协议等一些附加信息告知注册中心，注册中心按服务名分类组织服务清单。

服务注册中心还需要以心跳的方式去监测清单中的服务是否可用，若不可用需要从服务清单中剔除，达到排除故障服务的效果。

服务发现

服务间的调用不再指定具体的实例地址来实现，而是通过向服务名发起请求调用实现。所以，服务调用方在调用服务提供方接口的时候，并不知道具体的服务实例位置。

Netflix Eureka

  • 它既包含了服务端组件，也包含了客户端组件。
    • 服务端，也称为服务的注册中心。它支持高可用配置，依托于强一致性提供良好的服务实例可用性。当集群中有分片出现故障时，那么Eureka就转入自我保护模式。它允许分片故障期间继续提供服务的发现和注册，当故障分片恢复运行时，集群中的其他分片会把它们的状态再次同步回来。不同可用区域的服务注册测定中心通过异步模式互相复制各自的状态。
    • 客户端，处理服务的注册与发现。Eureka客户端向注册中心注册自身提供的服务并周期性地发送心跳来更新它的服务租约。同时，它也能从服务端查询当前注册的服务信息并把它们缓存到本地并周期性地刷新服务状态。

高可用注册中心

  • 实质就是Eureka Server将自己作为服务注册到其它的服务中心中。

Eureka详解

基础架构

  • 服务注册中心：Euraka提供的服务端。
  • 服务提供者：提供服务的应用，可以是Spring Boot应用，也可以是其它技术平台且遵循Eureka通信机制的应用。
  • 服务消费者：从服务注册中心获取服务列表，从而使消费者可以知道去何处调用其所需要的服务。

服务治理机制

服务提供者

  • 服务注册：在启动的时候会发送REST请求的方式将自己注册到Eureka Server上，同时带上自身服务的一些元数据信息。元数据信息存储在一个双层结构Map中，其中第一层的key是服务层，第二层的key是具体服务的实例名。配置参数eureka.client.register-with-eureka=false，将不会启动注册操作。
  • 服务同步：服务注册中心之间互相注册服务，所以当服务提供者发送注册请求到一个服务注册中心时，也会将该请求转发给集群中相连的其他注册中心，从而实现注册中心之间的服务同步。通过服务同步，就可以在任意一台注册中心获取注册在其它注册中心的服务。
  • 服务续约：服务提供者会维护一个心跳来持续连接Eureka Server，以防止Eureka Server将该服务实例从服务列表中剔除。

服务消费者

  • 获取服务：启动服务消费者时，会发送一个REST请求给服务注册中心，来获取上面注册的服务清单。Eureka Server会维护一份只读的服务清单来返回给客户端，同时该缓存清单会每隔30秒更新一次。
  • 服务调用：服务消费者在获取服务清单后，通过服务名可以获取具体提供服务的实例名和该实例的元数据信息。
    • 对于访问实例的选择，Eureka中有Region和Zone的概念，一个Region中可以包含多个Zone，每个服务客户端需要被注册到一个Zone中，所以每一个客户端都对应一个Region和一个Zone。
    • 在进行服务调用的时候，优先访问同处一个Zone中的服务提供方，若访问不到，就访问其它的Zone。
  • 服务下线：当服务实例进行正常的关闭操作时，它会触发一个服务下线的REST请求给Eureka Server，告诉服务注册中心它要下线了。服务端在接收到请求之后，将该服务状态设置为下线DOWN，并把该事件传播出去。

服务注册中心

  • 失效剔除：Eureka Server在启动的时候会创建一个定时任务，默认每隔一段时间(default 60s)将当前清单中超时(default 90s)没有续约的服务剔除出去。
  • 自我保护：Eureka Server会统计心跳失败的比例在15分钟之内是否低于85%。如果出现低于的情况，会将当前的实例注册信息保护起来，让这些实例不会过期，尽可能保护这些注册信息。
    • 但这就会引发另一个问题：如果这段保护期内实例若出现问题，那么客户端很可能拿到了实际上已经不存在的实例，就会出现调用失败的情况。所以客户端必须要有容错机制。
    • 可以配置参数eureka.server.enable-self-preservation=false来关闭自我保护机制，以确保注册中心可以将不可用的实例正确剔除。

源码分析

  • 将一个Spring Boot应用注册到Eureka Server或是从Eureka Server中获取服务列表时，主要做了两件事：
    1. 在应用类中配置了@EnableDiscoveryClient注解；
    2. 在application.properties中用eureka.client.service-url.defaultZone参数指定了服务注册中心的位置。

对URL列表进行配置

  • 在EndpointUtils类中，有如下方法。从该方法中可以看出，客户端一次加载了两个内容，第一个是Region，第二个是Zone。
public static Map<String, List<String>> getServiceUrlsMapFromConfig(EurekaClientConfig 
								   clientConfig, String instanceZone, boolean preferSameZone) {
    Map<String, List<String>> orderedUrls = new LinkedHashMap<>();
    // 从配置读取了一个Region返回，所以一个微服务应用只可以属于一个Region
    String region = getRegion(clientConfig);
    // 一个region可以对应多个Zone
    String[] availZones = clientConfig.getAvailabilityZones(clientConfig.getRegion());
    if (availZones == null || availZones.length == 0) {
        availZones = new String[1];
        availZones[0] = DEFAULT_ZONE;
    }
    logger.debug("The availability zone for the given region {} are {}", region, availZones);
    int myZoneOffset = getZoneOffset(instanceZone, preferSameZone, availZones);
    String zone = availZones[myZoneOffset];
    // 获取服务路径集合
    List<String> serviceUrls = clientConfig.getEurekaServerServiceUrls(zone);
    if (serviceUrls != null) {
        orderedUrls.put(zone, serviceUrls);
    }
    //
    int currentOffset = myZoneOffset == (availZones.length - 1) ? 0 : (myZoneOffset + 1);
    // 判断是否处于同一个Zone中
    while (currentOffset != myZoneOffset) {
        zone = availZones[currentOffset];
        serviceUrls = clientConfig.getEurekaServerServiceUrls(zone);
        if (serviceUrls != null) {
            orderedUrls.put(zone, serviceUrls);
        }
        if (currentOffset == (availZones.length - 1)) {
            currentOffset = 0;
        } else {
            currentOffset++;
        }
    }
    if (orderedUrls.size() < 1) {
        throw new IllegalArgumentException("DiscoveryClient: invalid serviceUrl specified!");
    }
    return orderedUrls;
}
  • getRegion方法如下
public static String getRegion(EurekaClientConfig clientConfig) {
    String region = clientConfig.getRegion();
    if (region == null) {
        // 如果没有配置，则默认为"default"
        region = DEFAULT_REGION;
    }
    region = region.trim().toLowerCase();
    return region;
}
  • getAvailabilityZones方法如下
public String[] getAvailabilityZones(String region) {
    String value = this.availabilityZones.get(region);
    if (value == null) {
        value = DEFAULT_ZONE;
    }
    // 返回的String数组，所以Zone可以设置多个，并通过","分隔
    return value.split(",");
}
  • getEurekaServerService方法如下
@Override
public List<String> getEurekaServerServiceUrls(String myZone) {
	String serviceUrls = this.serviceUrl.get(myZone);
	if (serviceUrls == null || serviceUrls.isEmpty()) {
  		// 从"defaultZone"中获取serviceUrls     
		serviceUrls = this.serviceUrl.get(DEFAULT_ZONE);
	}
	if (!StringUtils.isEmpty(serviceUrls)) {
		final String[] serviceUrlsSplit = StringUtils.commaDelimitedListToStringArray(serviceUrls);
		List<String> eurekaServiceUrls = new ArrayList<>(serviceUrlsSplit.length);
		for (String eurekaServiceUrl : serviceUrlsSplit) {
			if (!endsWithSlash(eurekaServiceUrl)) {
				eurekaServiceUrl += "/";
			}
			eurekaServiceUrls.add(eurekaServiceUrl.trim());
		}
		return eurekaServiceUrls;
	}
	return new ArrayList<>();
}

服务注册

  • 查看DiscoveryClient类的构造函数，其中调用了如下的initScheduledTasks方法。
private void initScheduledTasks() {
    // 服务的获取
    if (clientConfig.shouldFetchRegistry()) {
        // registry cache refresh timer
        int registryFetchIntervalSeconds = clientConfig.getRegistryFetchIntervalSeconds();
        int expBackOffBound = clientConfig.getCacheRefreshExecutorExponentialBackOffBound();
        scheduler.schedule(
                new TimedSupervisorTask(
                        "cacheRefresh",
                        scheduler,
                        cacheRefreshExecutor,
                        registryFetchIntervalSeconds,
                        TimeUnit.SECONDS,
                        expBackOffBound,
                        new CacheRefreshThread()
                ),
                registryFetchIntervalSeconds, TimeUnit.SECONDS);
    }
    // 服务注册与服务续约
    if (clientConfig.shouldRegisterWithEureka()) {
        int renewalIntervalInSecs = instanceInfo.getLeaseInfo().getRenewalIntervalInSecs();
        int expBackOffBound = clientConfig.getHeartbeatExecutorExponentialBackOffBound();
        logger.info("Starting heartbeat executor: " + "renew interval is: {}", renewalIntervalInSecs);
        // Heartbeat timer
        scheduler.schedule(
                new TimedSupervisorTask(
                        "heartbeat",
                        scheduler,
                        heartbeatExecutor,
                        renewalIntervalInSecs,
                        TimeUnit.SECONDS,
                        expBackOffBound,
                        new HeartbeatThread()
                ),
                renewalIntervalInSecs, TimeUnit.SECONDS);
        // InstanceInfoReplicator类实现了的Runnable接口
        instanceInfoReplicator = new InstanceInfoReplicator(
                this,
                instanceInfo,
                clientConfig.getInstanceInfoReplicationIntervalSeconds(),
                2); // burstSize
        statusChangeListener = new ApplicationInfoManager.StatusChangeListener() {
            @Override
            public String getId() {
                return "statusChangeListener";
            }
            @Override
            public void notify(StatusChangeEvent statusChangeEvent) {
                if (InstanceStatus.DOWN == statusChangeEvent.getStatus() ||
                        InstanceStatus.DOWN == statusChangeEvent.getPreviousStatus()) {
                    // log at warn level if DOWN was involved
                    logger.warn("Saw local status change event {}", statusChangeEvent);
                } else {
                    logger.info("Saw local status change event {}", statusChangeEvent);
                }
                instanceInfoReplicator.onDemandUpdate();
            }
        };
        if (clientConfig.shouldOnDemandUpdateStatusChange()) {
            applicationInfoManager.registerStatusChangeListener(statusChangeListener);
        }
 	// 启动该类的start方法
    instanceInfoReplicator.start(clientConfig.getInitialInstanceInfoReplicationIntervalSeconds());
    } else {
        logger.info("Not registering with Eureka server per configuration");
    }
}
  • InstanceInfoReplicator类的run方法如下
public void run() {
    try {
        discoveryClient.refreshInstanceInfo();
        Long dirtyTimestamp = instanceInfo.isDirtyWithTime();
        if (dirtyTimestamp != null) {
            // 真正触发服务注册的地方
            discoveryClient.register();
            instanceInfo.unsetIsDirty(dirtyTimestamp);
        }
    } catch (Throwable t) {
        logger.warn("There was a problem with the instance info replicator", t);
    } finally {
        Future next = scheduler.schedule(this, replicationIntervalSeconds, TimeUnit.SECONDS);
        scheduledPeriodicRef.set(next);
    }
}
  • discoveryClient.register方法
boolean register() throws Throwable {
    logger.info(PREFIX + "{}: registering service...", appPathIdentifier);
    EurekaHttpResponse<Void> httpResponse;
    try {
        // instanceInfo对象就是注册时客户端给服务端的服务的元数据
        httpResponse = eurekaTransport.registrationClient.register(instanceInfo);
    } catch (Exception e) {
        logger.warn(PREFIX + "{} - registration failed {}", appPathIdentifier, e.getMessage(), e);
        throw e;
    }
    if (logger.isInfoEnabled()) {
        logger.info(PREFIX + "{} - registration status: {}", 
                    appPathIdentifier, httpResponse.getStatusCode());
    }
    // 说明注册操作是通过皮REST请求的方式进行的
    return httpResponse.getStatusCode() == 204;
}

服务获取与服务续约

  • 从initScheduledTasks函数中，服务获取与服务续约的相关代码如下：
private void initScheduledTasks() {
    // 服务的获取
    if (clientConfig.shouldFetchRegistry()) {
        // registry cache refresh timer 注册表缓存的刷新时间
        // 默认为30s,配置参数eureka.client.registry-fetch-interval-seconds
        int registryFetchIntervalSeconds = clientConfig.getRegistryFetchIntervalSeconds();
        int expBackOffBound = clientConfig.getCacheRefreshExecutorExponentialBackOffBound();
        scheduler.schedule(
                new TimedSupervisorTask(
                        "cacheRefresh",
                        scheduler,
                        cacheRefreshExecutor,
                        registryFetchIntervalSeconds,
                        TimeUnit.SECONDS,
                        expBackOffBound,
                        new CacheRefreshThread()
                ),
                registryFetchIntervalSeconds, TimeUnit.SECONDS);
    }
    // 服务注册与服务续约
    if (clientConfig.shouldRegisterWithEureka()) {
        // 默认为30s，配置参数eureka.instance.lease-renewal-interval-in-seconds
        int renewalIntervalInSecs = instanceInfo.getLeaseInfo().getRenewalIntervalInSecs();
        // 默认为90s,配置参数eureka.instance.lease-expiration-duration-in-seconds
        int expBackOffBound = clientConfig.getHeartbeatExecutorExponentialBackOffBound();
        logger.info("Starting heartbeat executor: " + "renew interval is: {}", renewalIntervalInSecs);
        // Heartbeat timer
        scheduler.schedule(
                new TimedSupervisorTask(
                        "heartbeat",
                        scheduler,
                        heartbeatExecutor,
                        renewalIntervalInSecs,
                        TimeUnit.SECONDS,
                        expBackOffBound,
                        new HeartbeatThread()
                ),
                renewalIntervalInSecs, TimeUnit.SECONDS);
        ......
    }
}
  • 服务续约的具体实现方法renew代码如下：
boolean renew() {
    EurekaHttpResponse<InstanceInfo> httpResponse;
    try {
        httpResponse = eurekaTransport.registrationClient.sendHeartBeat(instanceInfo.getAppName(), instanceInfo.getId(), instanceInfo, null);
        logger.debug(PREFIX + "{} - Heartbeat status: {}", appPathIdentifier, httpResponse.getStatusCode());
        if (httpResponse.getStatusCode() == 404) {
            REREGISTER_COUNTER.increment();
            logger.info(PREFIX + "{} - Re-registering apps/{}", appPathIdentifier, instanceInfo.getAppName());
            long timestamp = instanceInfo.setIsDirtyWithTime();
            boolean success = register();
            if (success) {
                instanceInfo.unsetIsDirty(timestamp);
            }
            return success;
        }
        return httpResponse.getStatusCode() == 200;
    } catch (Throwable e) {
        logger.error(PREFIX + "{} - was unable to send heartbeat!", appPathIdentifier, e);
        return false;
    }
}
  • 服务的获取则会根据是否是第一次获取发起不同的REST请求和相应的处理。
private boolean fetchRegistry(boolean forceFullRegistryFetch) {
    Stopwatch tracer = FETCH_REGISTRY_TIMER.start();
    try {
        // If the delta is disabled or if it is the first time, get all
        // applications
        Applications applications = getApplications();
        if (clientConfig.shouldDisableDelta()
                || (!Strings.isNullOrEmpty(clientConfig.getRegistryRefreshSingleVipAddress()))
                || forceFullRegistryFetch
                || (applications == null)
                || (applications.getRegisteredApplications().size() == 0)
                || (applications.getVersion() == -1)) //Client application does not have latest library supporting delta
        {
            logger.info("Disable delta property : {}", clientConfig.shouldDisableDelta());
            logger.info("Single vip registry refresh property : {}", clientConfig.getRegistryRefreshSingleVipAddress());
            logger.info("Force full registry fetch : {}", forceFullRegistryFetch);
            logger.info("Application is null : {}", (applications == null));
            logger.info("Registered Applications size is zero : {}",
                    (applications.getRegisteredApplications().size() == 0));
            logger.info("Application version is -1: {}", (applications.getVersion() == -1));
            getAndStoreFullRegistry();
        } else {
            getAndUpdateDelta(applications);
        }
        applications.setAppsHashCode(applications.getReconcileHashCode());
        logTotalInstances();
    } catch (Throwable e) {
        logger.error(PREFIX + "{} - was unable to refresh its cache! status = {}", appPathIdentifier, e.getMessage(), e);
        return false;
    } finally {
        if (tracer != null) {
            tracer.stop();
        }
    }
    // Notify about cache refresh before updating the instance remote status
    onCacheRefreshed();
    // Update remote status based on refreshed data held in the cache
    updateInstanceRemoteStatus();
    // registry was fetched successfully, so return true
    return true;
}

服务注册中心处理

  • Eureka Server对于各类REST请求的定义都位于com.netflix.eureka.resources包下
  • 以服务注册为例
@POST
@Consumes({"application/json", "application/xml"})
public Response addInstance(InstanceInfo info,
                            @HeaderParam(PeerEurekaNode.HEADER_REPLICATION) String isReplication) {
    logger.debug("Registering instance {} (replication={})", info.getId(), isReplication);
    // validate that the instanceinfo contains all the necessary required fields
    // 对id，hostname等参数的一系列校验
    if (isBlank(info.getId())) {
        return Response.status(400).entity("Missing instanceId").build();
    } else if (isBlank(info.getHostName())) {
        return Response.status(400).entity("Missing hostname").build();
    } else if (isBlank(info.getIPAddr())) {
        return Response.status(400).entity("Missing ip address").build();
    } else if (isBlank(info.getAppName())) {
        return Response.status(400).entity("Missing appName").build();
    } else if (!appName.equals(info.getAppName())) {
        return Response.status(400).entity("Mismatched appName, expecting " + appName + " but was " + info.getAppName()).build();
    } else if (info.getDataCenterInfo() == null) {
        return Response.status(400).entity("Missing dataCenterInfo").build();
    } else if (info.getDataCenterInfo().getName() == null) {
        return Response.status(400).entity("Missing dataCenterInfo Name").build();
    }
    // handle cases where clients may be registering with bad DataCenterInfo with missing data
    DataCenterInfo dataCenterInfo = info.getDataCenterInfo();
    if (dataCenterInfo instanceof UniqueIdentifier) {
        String dataCenterInfoId = ((UniqueIdentifier) dataCenterInfo).getId();
        if (isBlank(dataCenterInfoId)) {
            boolean experimental = "true".equalsIgnoreCase(serverConfig.getExperimental("registration.validation.dataCenterInfoId"));
            if (experimental) {
                String entity = "DataCenterInfo of type " + dataCenterInfo.getClass() + " must contain a valid id";
                return Response.status(400).entity(entity).build();
            } else if (dataCenterInfo instanceof AmazonInfo) {
                AmazonInfo amazonInfo = (AmazonInfo) dataCenterInfo;
                String effectiveId = amazonInfo.get(AmazonInfo.MetaDataKey.instanceId);
                if (effectiveId == null) {
                    amazonInfo.getMetadata().put(AmazonInfo.MetaDataKey.instanceId.getName(), info.getId());
                }
            } else {
                logger.warn("Registering DataCenterInfo of type {} without an appropriate id", dataCenterInfo.getClass());
            }
        }
    }
    // 运行时调用的是InstanceRegistry对象的register方法
    registry.register(info, "true".equals(isReplication));
    return Response.status(204).build();  // 204 to be backwards compatible
}
  • registry方法代码如下
@Override
public void register(InstanceInfo info, int leaseDuration, boolean isReplication) {
   // 传播有新服务注册的事件方法
   handleRegistration(info, leaseDuration, isReplication);
   // 调用父类的register方法，将instanceInfo中的元数据信息存储在concurrentHahsMap对象中
   super.register(info, leaseDuration, isReplication);
}

private void handleRegistration(InstanceInfo info, int leaseDuration,
		boolean isReplication) {
	log("register " + info.getAppName() + ", vip " + info.getVIPAddress()
			+ ", leaseDuration " + leaseDuration + ", isReplication " + isReplication);
    // 将新服务注册的事件传播出去
	publishEvent(new EurekaInstanceRegisteredEvent(this, info, leaseDuration, isReplication));
}
  • 注册中心存储了两层Map结构，第一层的key存储服务名：InstanceInfo中的appName属性；第二层的key存储实例名：InstanceInfo中的instanceId属性。

配置信息

  • 在Eureka的服务治理体系中，主要分为服务端与客户端两个不同的角色，服务端为服务注册中心，而客户端为各个提供接口的微服务应用。
  • 在实际使用Spring Cloud Eureka的过程中，所做的配置几乎都是对Eureka客户端配置进行的操作。分以下方面：
    • 服务注册相关的配置信息，包括服务注册中心的地址、服务获取的间隔时间、可用区域等。
    • 服务实例相关的配置信息，包括服务实例的名称、IP地址、端口号、健康检查路径等。
kuraki丶
关注
专栏目录
黑马程序员-SpringCloud-学习笔记-03-Eureka注册中心
06-18
黑马程序员-SpringCloud-学习笔记-03-Eureka注册中心
springcloud学习笔记.pdf
03-12
Spring Cloud 学习笔记 本笔记主要介绍了从单体架构到微服务架构的演变过程，以及 Spring Cloud 中的微服务架构搭建。下面是本笔记的详细知识点总结： 一、单体架构 单体架构是指整个系统只有一个工程，打包往往...
基于eureka多实例的优雅上线
jiawa12的博客
02-26 479
eureka多实例平滑部署项目
eruka快速刷新和kafka配置
heqiang1995的博客
05-07 450
Kafka partition扩充并且需要迁移数据 生产不用指定具体分区，会自动分配 拉取也不用指定具体分区，会自动拉多个分区 可以同时拉取多个topic kafka配置 <dependency> <groupId>org.apache.kafka</groupId> <artifactId>kafka_2.12</artifactId> <version>2.3.0</version> &lt...
Eureka核⼼源码剖析5--Eureka Client注册服务和刷新缓存,心跳续约
二缺和傻宝宝的博客
08-16 192
启动过程：Eureka客户端在启动时也会装载很多配置类，我们通过spring-cloud- netflix-eureka-client-2.1.0.RELEASE.jar下的spring.factories⽂件可以看到加载的配置类 引⼊jar就会被⾃动装配，分析EurekaClientAutoConfiguration类头 如果不想作为客户端，可以设置eureka.client.enabled=false 回到主配置类EurekaClientAutoConfiguration 思考：EurekaClient启
SpringCloud常⻅问题及解决方案
rzpy_qifengxiaoyue的博客
08-27 476
1. Eureka 服务发现慢问题 如果你刚刚接触Eureka，对Eureka的设计和实现都不是很了解，可能就会遇到一些无法快速解决的问 题，这些问题包括:新服务上线后，服务消费者不能访问到刚上线的新服务，需要过一段时间后才能访 问?或是将服务下线后，服务还是会被调用到，一段时候后才彻底停止服务，访问前期会导致频繁报 错?这些问题还会让你对 Spring Cloud 产生严重的怀疑，这难道不是一个 Bug? 问题场景： 上线一个新的服务实例，但是服务消费者无感知，过了一段时间才知道 某一个服务实例下线了，服
DiscoveryClient_UNKNOWN/DESKTOP-8S3CENH:1111 - was unable to send heartbeat!
热门推荐
程序猿学社的博客
11-26 1万+
apollo和eureka client一起使用，发现一个问题 apollo和eureka配置如下，如果不把注释地方打开就会有报错出现 server: port: 1111 app: id : apollo-test apollo: meta: http://127.0.0.1:8080 #eureka: # client: # register-with-e...
Spring Cloud 学习笔记.pdf
03-26
Spring Cloud的五大核心组件包括：Eureka、Ribbon、Hystrix、Feign和Zuul。其中，Eureka是服务注册与发现中心，Ribbon和Feign是服务调用组件，Hystrix用于实现熔断模式，而Zuul则是微服务网关。Spring Cloud Alibaba...
SpringCloud学习笔记SpringCloud学习笔记
最新发布
07-21
Spring Cloud是基于Spring框架的一系列开源微服务工具和服务，它提供了一种开箱即用的方式来构建云原生应用，支持分布式系统常见的组件和服务，如配置管理、服务发现、API网关、负载均衡、断路器、熔断器、智能路由...
Spring Cloud学习笔记（一）Eureka搭建
01-07
Spring Cloud简介（摘自百度百科） Spring Cloud是一系列框架的有序集合。它利用Spring Boot的开发便利性巧妙地简化了分布式系统基础设施的开发，如服务发现注册、配置中心、消息总线、负载均衡、断路器、数据监控等...
Java 面试题
lingboo111的博客
03-27 2012
基础知识 实例方法和静态方法的区别 实例方法： 当类的字节码文件加载到内存中时，类的实例方法并没有被分配入口地址，只有当该类的对象创建以后，实例方法才被分配了入口地址，所以，实例方法并不能被**类名.**调用。 当我们创建第一个类的对象时，实例方法的入口地址就会完成分配，在后续创建的对象时，不会再重新分配新的入口地址，也就是说，该类的实例对象共享该实例方法的入口地址，当该类的所有实例对象全部被...
Dubbo框架及其组成
lingboo111的博客
03-19 1888
Dubbo 分布式基础理论 概念 分布式系统是若干个独立计算机的集合，这些计算机对于用户来说就像单个相关系统。 分布式系统(distributed system)是建立在网络之上的软件系统。 常规的垂直应用架构已经无法应对日常的网站需求，分布式服务架构以及流动计算架构势在必行，亟需一个治理系统确保架构有条不紊的演进。 发展演变 单一应用架构： 当网站流量很小的时候，只需一个应用，将所有功能...
数据库：Oracle和MySQL
lingboo111的博客
03-15 1372
关系型数据库 概念 关系数据库，是建立在关系模型基础上的数据库，借助于集合代数等数学概念和方法来处理数据库中的数据。 关系模型由关系数据结构、关系操作集合、关系完整性约束三部分组成。 简单说，关系型数据库是由多张能互相联接的二维行列表格组成的数据库。 因而一个关系型数据库就是由二维表及其之间的联系组成的一个数据组织。 JDBC 注册数据库驱动 获取数据库连接 创建发送sql的statemen...
JVM的内部结构与详述
lingboo111的博客
03-15 414
JVM 前言 该文章是本人在学习java时，总结的笔记心得。基本来源于各大网络文章或博客。现在不记得出处了，所以如有雷同，望请海涵哈。 概念 JVM(Java Virtual Machine):Java虚拟机，简称JVM，是运行所有Java程序的假想计算机，是Java程序的运行环境，是Java最具吸引力的特性之一。Java代码，都运行在JVM之上。 JRE(Java Runtime Envi...
Java 基础知识 02
lingboo111的博客
03-29 394
Java 基础知识 02 计算机基础 位运算符 Java定义了位运算符，应用于整数类型(int)，长整型(long)，短整型(short)，字符型(char)，和字节型(byte)等类型。 位运算符作用在所有的位上，并且按位运算。假设A = 60，B = 13;它们的二进制格式表示将如下： A = 0011 1100 B = 0000 1101 ---------------------- A...
spring cloud feign
lingboo111的博客
06-11 323
spring cloud feign Spring Cloud Feign具有可插拔的注解支持，包括Feign注解和JAX-RS注解。 快速入门 创建应用主类FeignApplication，并通过@EnableFeignClients注解开启Spring Cloud Feign的支持功能。 @EnableFeignClients @EnableDiscoveryClient @Sprin...
XSS和CSRF攻击
lingboo111的博客
03-19 319
XSS和CSRF 概念 XSS(Cross-site scripting)攻击全称跨站脚本攻击，是一种经常出现在web应用中的计算机安全漏洞，它允许web用户恶意将代码植入到提供给其它用户使用的页面中。比如这些代码包括HTML代码和客户端脚本。攻击者利用XSS漏洞旁路掉访问控制——例如同源策略(same origin policy)。这种类型的漏洞由于被骇客用来编写危害性更大的网络钓鱼攻击而变得...
MySQL数据库优化
lingboo111的博客
03-15 296
MySQL数据库优化 客户/服务器端通信协议 MySQL客户端/服务端通信协议是半双工的：在任意时刻，要么是服务器向客户端发送数据，要么是客户端向服务器发送数据，这两个动作不能同时发生。 一旦一端开始发送消息，另一端要接收完整个消息才能响应它，所以我们无法也无须将一个消息切成小块独立发送，也没有办法进行流量控制。 当查询语句很长的时候，需要设置max_allowed_packet参数。但是需要注...
spring cloud ribbon源码分析总结
lingboo111的博客
05-19 268
Spring Cloud Ribbon笔记总结01 Spring Cloud Ribbon只是一个工具类框架，虽然不需要独立部署，但是几乎存在于每一个Spring Cloud构建的微服务和基础设施中。而且，ribbon实现的是客户端的负载均衡。 客户端负载均衡 负载均衡是对系统的高可用，网络压力的环节和处理能力扩容的重要手段之一。分为硬件负载均衡和软件负载均衡。 硬件负载均衡：通过服务器...
springcloud学习笔记
10-13
2. Spring Cloud Netflix：包含了一些 Netflix OSS 组件的集成，例如 Eureka、Hystrix、Zuul 等。 3. Spring Cloud Bus：用于在分布式系统中传播状态变化，例如配置变更事件。 4. Spring Cloud Security：提供了在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值