SpringCloud的搭建

最新推荐文章于 2023-06-05 22:46:10 发布
最新推荐文章于 2023-06-05 22:46:10 发布
阅读量313 收藏
点赞数
分类专栏： 微服务
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/P_ning/article/details/117199474
版权

SpringCloud的搭建

源码

SpringCloud笔记,该项目必须配合提交版本查看，这里只是写了主要的操作，细节操作必须搭配代码一起查看

Eureka的创建步骤（最终版为2021-5-23版本，每次提交对应下面的一个步骤）

1、Eureka保证AP

eureka 在设计时就先保证可用性。Eureka各个节点都是平等的，几个节点的down机不会影响正常节点的工作，剩余的节点依然可以提供注册和查询服务。而eureka客户端再向某个eureka服务端注册时如果发现连接失败，则会自动切换至其他节点。只要有一台eureka server 是正常运行的，就能保证服务可用(保证服务可用)。只不过查询到的信息可能不是最新的(不保证强一致性)。
除此之外，eureka还有一种自我保护机制：如果在15分钟内超过85%的节点都没有正常的心跳，那么eureka就认为客户端与注册中心出现了网络故障，此时会出现如下几种情况：

  1. eureka 不再从注册列表中移除因为长时间没收到响应和请求而应该过期的服务。
  2. eureka 仍然能够接受新服务的注册和查询请求，但是不会被同步到其他节点上(即保证当前节点依然可用)
  3. 当网络稳定时，当前实例新的注册信息会被同步到其他节点中，因此，eureka可以很好的应对网络故障导致部分节点失去联系的情况而不会像ZooKeeper那样使整个注册服务瘫痪。

2、Eureka的使用

  1. 创建一个Maven父工程，将项目使用工具的版本号和一些子模块常用的依赖添加到pom中
  2. 创建一个api工程里面写入常用的对象和方法
  3. 创建一个provider_dept_8081工程，导入api工程，并且实现一个基于ssm的crud服务
  4. 创建一个consumer_dept_8000工程，导入api工程，并且实现基于provider_dept_8081工程的Restful格式接口
  5. Eureka的Server端建立，创建一个Eureka_7001工程,添加eureka-server服务端依赖，填写yml配置文件，在启动类添加启动标签@EnableEurekaServer
server: 
  port: 7001
eureka: 
  instance:
    hostname: localhost             #eureka服务端的实例名称
  client: 
    register-with-eureka: false     #false表示不向注册中心注册自己。
    fetch-registry: false           #false表示自己端就是注册中心，我的职责就是维护服务实例，并不需要去检索服务
    service-url: 
     defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/       #设置与Eureka Server交互的地址查询服务和注册服务都需要依赖这个地址（单机）。

  1. 将provider_dept_8081工程添加到Eureka的客户端：
    （1）添加pom依赖

    <!-- 将微服务provider侧注册进eureka -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-eureka</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-config</artifactId>
    </dependency>

    （2）添加yml配置文件

    #客户端注册进eureka服务列表内
eureka:
  client:
    service-url:
      defaultZone: http://localhost:7001/eureka

    （3）启动类添加启动标签@EnableEurekaClient

  2. Eureka的展示界面中Eureka客户端自定义模块名字且访问路径可以显示IP地址，只需要在在Eureka的客户端的yml配置文件中添加配置

    eureka:
  client:
    service-url:
      defaultZone: http://localhost:7001/eureka
  instance:
    instance-id: 8081ProviderDept   #自定义名字,否则Eureka自己起的名字
    prefer-ip-address: true         #访问路径可以显示IP地址

  3. 解决Eureka的展示界面中Eureka客户端的info超链接error问题：
    （1）起始父工程pom添加

    <!--放开文件的读取，用于配置Eureka展示界面客户端超链接点击的info界面配置-->
    <build>
        <finalName>SpringCloud</finalName>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <filtering>true</filtering>
            </resource>
        </resources>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-resources-plugin</artifactId>
                <configuration>
                    <delimiters>
                        <delimiter>$</delimiter>
                    </delimiters>
                </configuration>
            </plugin>
        </plugins>
    </build>

    （2） privoider_dept_8081工程添加监视器依赖

            <!-- actuator监控信息完善 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>

    （3）Eureka客户端添加actuator监控依赖且对yml进行配置

    #Eureka展示界面客户端超链接点击的info界面返回的json串信息
info:
  mess: 信息随意配置
  app.name: Pning-SpringCloud       #软件名字
  build.artifactId: $project.artifactId$    #父工程的pom中设置的标识符
  build.version: $project.version$          #父工程的pom中设置的标识符

  4. Eureka的服务发现，类似于快递公司给客户的一个查询接口
    （1）修改provider_dept_8081的controller

    //添加Eureka的服务发现,即给一个接口让客户使用查询服务信息
	@Autowired
    private DiscoveryClient client;

    @GetMapping("/discovery")
    public Object discovery() {
        List<String> list = client.getServices();
        System.out.println("获取到的所有客户端" + list);
        List<ServiceInstance> srvList = client.getInstances("DEPT8081");
        System.out.println("客户端的信息");
        for (ServiceInstance element : srvList) {
            System.out.println(element.getServiceId() + "\t" + element.getHost() + "\t" + element.getPort() + "\t"
                    + element.getUri());
        }
        return this.client;
    }

    （2）启动类添加启动标签@EnableDiscoveryClient

  5. Eureka的集群：
    （1）先进行域名映射，windows系统在C:\Windows\System32\drivers\etc\hosts文件中添加

    	127.0.0.1       eureka7001.com
	127.0.0.1       eureka7002.com
	127.0.0.1       eureka7003.com

（2）模仿Eureka_7001工程创建Eureka_7002和Eureka_7003工程
（3）provider_dept_8081的yml配置文件也添加集群的Eureka集群的地址路径

Ribbon的使用步骤（最终版为2021-5-24版本，每次提交对应下面的一个步骤）

  1. 在consumer_dept_8000项目的pom文件添加Ribbon需要的依赖

    		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-eureka</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-ribbon</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-config</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>

  2. consumer_dept_8000的DeptConsumerController文件里面的固定ip改为微服务名

//private static final String REST_URL_PREFIX = "http://localhost:8081";
    //把ip名改为微服务名
    private static final String REST_URL_PREFIX = "http://DEPTPRIVOIDER";
  1. consumer_dept_8000的ConfigBean文件添加负载均衡注解(默认轮询算法)
@Configuration
public class ConfigBean{

    /**
     * 使用restful风格进行接口访问
     * @return
     */
	@Bean
    @LoadBalanced
	public RestTemplate getRestTemplate()
	{
		return new RestTemplate();
	}

}
  1. 启动类添加Eureka启动标签@EnableEurekaClient
  2. 模仿privoider_dept_8081创建privoider_dept_8082和privoider_dept_8083项目进行负载均衡模拟
    注意点：
    （1）yml配置文件的spring.application.name必须三个都一致
    spring:
  application:
    name: deptPrivoider

（2）yml配置文件的eureka.instance.instance-id必须三个都不一致

		eureka:
		  client:
		    service-url:
		      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/
		  instance:
		    instance-id: ProviderDept-8083   #自定义名字,否则Eureka自己起的名字
		    prefer-ip-address: true         #访问路径可以显示IP地址

自定义负载均衡方法

  1. 创建一个不在启动类同一个包下的配置文件MySelfRule.java（官网规定不能与拥有扫描注解类处于同一个包下，而启动类的SpringBoot注解就拥有包括了扫描注解）
    package com.customize;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import com.netflix.loadbalancer.IRule;
import com.netflix.loadbalancer.RoundRobinRule;

@Configuration
public class MySelfRule
{
	@Bean
	public IRule myRule()
	{
		return new RandomRule_Customize();// 自定义负载均衡算法
	}
}
  2. 创建一个继承了AbstractLoadBalancerRule，在choose方法里面编写自己的负载均衡算法
    import java.util.List;

import com.netflix.client.config.IClientConfig;
import com.netflix.loadbalancer.AbstractLoadBalancerRule;
import com.netflix.loadbalancer.ILoadBalancer;
import com.netflix.loadbalancer.Server;

/**
 * 自定义的负载均衡算法：一个服务调用5次后再调用下一个服务
 */
public class RandomRule_Customize extends AbstractLoadBalancerRule {

	private int total = 0; 			// 总共被调用的次数，目前要求每台被调用5次
	private int currentIndex = 0;	// 当前提供服务的机器号

	public Server choose(ILoadBalancer lb, Object key) {
		if (lb == null) {
			return null;
		}
		Server server = null;
		while (server == null) {
			if (Thread.interrupted()) {
				return null;
			}
			//获取所有有效的服务实例列表
			List<Server> upList = lb.getReachableServers();
			//获取所有服务
			List<Server> allList = lb.getAllServers();

			int serverCount = allList.size();
			if (serverCount == 0) {
				return null;
			}
            if(total < 5)
            {
	            server = upList.get(currentIndex);
	            total++;
            }else {
	            total = 0;
	            currentIndex++;
	            if(currentIndex >= upList.size())
	            {
	              currentIndex = 0;
	            }
            }
			if (server == null) {
				Thread.yield();
				continue;
			}

			if (server.isAlive()) {
				return (server);
			}
			server = null;
			Thread.yield();
		}
		return server;
	}

	@Override
	public Server choose(Object key)
	{
		return choose(getLoadBalancer(), key);
	}

	@Override
	public void initWithNiwsConfig(IClientConfig clientConfig) {
		// TODO Auto-generated method stub
	}

}
  3. 在启动类添加注解，启动时候启动我们自己编写的负载均衡算法
    @SpringBootApplication
@EnableEurekaClient
//在启动该微服务的时候就能去加载我们的自定义Ribbon配置类，从而使配置生效
@RibbonClient(name="DEPTPRIVOIDER",configuration= MySelfRule.class)
public class DeptConsumer8000_App {
    public static void main(String[] args) {
        SpringApplication. run(DeptConsumer8000_App.class,args);
    }
}

Feign的使用步骤（最终版为2021-5-28版本）

  1. 模仿consumer_dept_8000模块创建feign_8001，只需删除与Ribbon的相关信息即可：
    例如：自定义的负载均衡算法，Ribbon依赖（Feign集合了Ribbon无需在导入）和启动类的相关注解
  2. pom添加feign的依赖
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-feign</artifactId>
</dependency>
  3. 把接口放在api模块中，因为这个接口不仅仅使用一次
    （1）给api模块的pom添加feign依赖
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-feign</artifactId>
</dependency>
    (2)在api模块中创建DeptClientService.java,然后重新对api模块进行clean和package操作，对maven仓库进行更新
    	package com.pning.service;

/**
 * @Author Pning
 * @Date 2021/5/25 19:34
 **/
import com.pning.entitys.Dept;
import org.springframework.cloud.netflix.feign.FeignClient;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import java.util.List;

@FeignClient(value = "DEPTPRIVOIDER")
public interface DeptClientService {
    @RequestMapping(value = "/dept/get/{id}", method = RequestMethod.GET)
    public Dept get(@PathVariable("id") long id);

    @RequestMapping(value = "/dept/list", method = RequestMethod.GET)
    public List<Dept> list();

    @RequestMapping(value = "/dept/add", method = RequestMethod.POST)
    public boolean add(Dept dept);
}
  4. 进入feign_8001模块，修改DeptConsumerController.java
    package com.pning.controller;

import com.pning.entitys.Dept;
import com.pning.service.DeptClientService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

/**
 * @Author Pning
 * @Date 2021/5/21 11:16
 **/
@RestController
@RequestMapping("/consumer")
public class DeptConsumerController {

    /**
     * Feign通过接口的方法调用Rest服务（之前是Ribbon+RestTMplate），
     * 一个请求发送到Eureka服务器（例如：Http://DEPTPRIVOIDER:8001/consumer/list）
     * 该请求通过Feign直接找到服务接口，因为Feign在进行服务调用的时候已经整合了Ribbon，
     * 所以无需我们再次添加Ribbon进行负载均衡（默认调用轮询算法）
     */
    @Autowired
    private DeptClientService deptClientService;

    @RequestMapping(value = "/get/{id}")
    public Dept get(@PathVariable("id") Long id) {
        return this.deptClientService.get(id);
    }

    @RequestMapping(value = "/list")
    public List<Dept> list() {
        return this.deptClientService.list();
    }

    @RequestMapping(value = "/add")
    public Object add(Dept dept) {
        return this.deptClientService.add(dept);
    }
}
  5. 启动类Feign_8001_App.java添加启动标签@EnableFeignClients

Hystrix的使用步骤(最终版为2021-5-28版本)

  1. 模仿之前的privoider_dept_8081模块创建一个privoider_dept_hystrix_8084和privoider_dept_hystrix_8085模块

  2. 添加Hystrix依赖

    	<dependency>
		<groupId>org.springframework.cloud</groupId>
		<artifactId>spring-cloud-starter-hystrix</artifactId>
	</dependency>

  3. 修改DeptController.java，controller有三种请求方法，但是我只修改了其中一个get方法，作为案例已经足够了。

    //方法失败并抛出了错误信息后，会自动调用@HystrixCommand标注好的fallbackMethod调用类中的指定方法
@HystrixCommand(fallbackMethod = "processHystrix_Get")
@GetMapping("/{id}")
public Dept get(@PathVariable("id") Long id){
    Dept dept = service.get(id);
	if(dept==null){
	    throw  new RuntimeException();
    }
    return dept;
}
public Dept processHystrix_Get(@PathVariable("id") Long id){
    return new Dept().setDeptno(id).setDname("该ID：" + id + "没有没有对应的信息,null--@HystrixCommand")
            .setDb_source("no this database in MySQL");
}

  4. 启动类添加@EnableCircuitBreaker开启

    package com.pning;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.circuitbreaker.EnableCircuitBreaker;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

@EnableEurekaClient
@SpringBootApplication
@EnableDiscoveryClient
@EnableCircuitBreaker//对hystrixR熔断机制的支持
public class DeptProvider8084_App{
	public static void main(String[] args){
		SpringApplication.run(DeptProvider8084_App.class, args);
	}
}

  5. 服务降级：通过步骤3可以起到熔断的作用，但是这样代码的耦合性太高了，而且Controller层的每一个方法都需要写一个对应的熔断返回方法，非常不利于后期的维护和业务拓展，所以我将其提炼出来，将原本注解在Controller上的@HystrixCommand注解放在放在api模块里面的公共接口，在创建一个实现了FallbackFactory的DeptClientServiceFallbackFactory接口，通过Spring的异常通知，在接口里面重新编写熔断后的处理方法，为了提高复用性，我们将这个接口放在api模块中。
    （1.）清空原本privoider_dept_hystrix_8085模块中controller层的熔断处理注解和处理方法
    （2.）在api模块新建一个DeptClientServiceFallbackFactory.java

    package com.pning.service;
import java.util.List;
import com.pning.entitys.Dept;
import org.springframework.stereotype.Component;
import feign.hystrix.FallbackFactory;

@Component
public class DeptClientServiceFallbackFactory implements FallbackFactory<DeptClientService>
{
	@Override
	public DeptClientService create(Throwable throwable)
	{
		return new DeptClientService() {
			@Override
			public Dept get(long id)
			{
				return new Dept().setDeptno(id).setDname("该ID：" + id + "没有没有对应的信息,Consumer客户端提供的降级信息,此刻服务Provider已经关闭")
						.setDb_source("no this database in MySQL");
			}

			@Override
			public List<Dept> list()
			{
				return null;
			}

			@Override
			public boolean add(Dept dept)
			{
				return false;
			}
		};
	}
}

    （3.）在原本的DeptClientService公共接口的@FeignClient注解添加fallbackFactory属性

    	package com.pning.service;
/**
 * @Author Pning
 * @Date 2021/5/25 19:34
 **/
import com.pning.entitys.Dept;
import org.springframework.cloud.netflix.feign.FeignClient;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import java.util.List;

@FeignClient(value = "DEPTPRIVOIDER",fallbackFactory=DeptClientServiceFallbackFactory.class)
public interface DeptClientService {

    @RequestMapping(value = "/dept/{id}", method = RequestMethod.GET)
    public Dept get(@PathVariable("id") long id);

    @RequestMapping(value = "/dept/list", method = RequestMethod.GET)
    public List<Dept> list();

    @RequestMapping(value = "/dept/add", method = RequestMethod.POST)
    public boolean add(Dept dept);
}

    (4.)api模块进行clean和install
    (5.)在feign_8001模块的yml文件上添加服务降级配置，这是因为我们上面写的熔断方法针对的是feign模块的接口，那个接口之前被我们抽去公用api模块了，所以配置要在feign_8001模块配置

    	feign: 
  		hystrix: 
    		enabled: true

  6. 服务的监控,首先新建一个hystrix_bashboard_8002模块然后
    (1.)添加依赖

        <dependencies>
    <!-- 自己定义的api -->
    <dependency>
        <groupId>com.pning</groupId>
        <artifactId>api</artifactId>
        <version>${project.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- 修改后立即生效，热部署 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>springloaded</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
    </dependency>
    <!-- Ribbon相关 -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-eureka</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-ribbon</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-config</artifactId>
    </dependency>
    <!-- feign相关 -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-feign</artifactId>
    </dependency>
    <!-- hystrix和 hystrix-dashboard相关 -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-hystrix</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-hystrix-dashboard</artifactId>
    </dependency>
</dependencies>

    (2.)配置启动端口号

    server:
	port: 8002

    (3.)添加启动类

    package com.pning;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.hystrix.dashboard.EnableHystrixDashboard;

@SpringBootApplication
@EnableHystrixDashboard
public class DeptConsumer_DashBoard_App
{
	public static void main(String[] args)
	{
		SpringApplication.run(DeptConsumer_DashBoard_App.class, args);
	}
}

    (4.)在要被接受监督的privoider_dept_hystrix_8084模块下添加依赖

    <!-- actuator监控信息完善 -->
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-actuator</artifactId>
	</dependency>

    (5)在浏览器输入http://localhost:8002/hystrix观看是否有界面出来，然后在privoider_dept_hystrix_8084模块正常使用的情况下在去看http://localhost:8084/hystrix.stream是否能ping通或者使用http://localhost:8002/hystrix测试能否产生图形化界面

Zuul的使用步骤(最终版为2021-5-29版本)

  1. 创建一个zuul_8003模块，添加依赖、启动类和配置文件

    <!-- zuul路由网关 -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-zuul</artifactId>
    </dependency>

    package com.pning;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.zuul.EnableZuulProxy;

@SpringBootApplication
@EnableZuulProxy
public class Zuul_8003_App
{
	public static void main(String[] args)
	{
		SpringApplication.run(Zuul_8003_App.class, args);
	}
}


    server: 
  port: 8003
 
spring: 
  application:
    name: zuul_8003
 
eureka: 
  client: 
    service-url: 
      defaultZone: http://eureka7001.com:7001/eureka,http://eureka7002.com:7002/eureka,http://eureka7003.com:7003/eureka  
  instance:
    instance-id: zuulPning.com
    prefer-ip-address: true 
 
 
zuul: 
  #ignored-services: microservicecloud-dept #可以指定禁用某个服务直接调用服务名来访问
  prefix: /pning                          #使用zuul路由后需要访问路劲前缀
  ignored-services: "*"                 #禁用所有服务直接调用原本服务名来访问
  routes: 
    mydept.serviceId: deptPrivoider     #原本在Eureka的服务名
    mydept.path: /mydept/**             #替代上面服务名


#Eureka展示界面客户端超链接点击的info界面返回的json串信息
info:
  mess: 信息随意配置
  app.name: Pning-SpringCloud
  build.artifactId: $project.artifactId$
  build.version: $project.version$

  2. 进行域名映射，windows系统在C:\Windows\System32\drivers\etc\hosts文件中添加

    	127.0.0.1       zuulPning.com

Spring Cloud Config的使用（最终版为2021-5-31版本）

我因为学校网络原因GitHub经常登不上去所以这里选用的是gitee，后面就以gitee为例

  1. 先进行域名映射，windows系统在C:\Windows\System32\drivers\etc\hosts文件中添加
    	127.0.0.1       configservice7081.com
  2. 在gitee上创建一个仓库，然后下拉到本地,在该文件中添加测试使用的config-test.yml配置文件，并上传到Gitee上，文件记得以utf-8的格式，不然会中文乱码
    config:
 	info: "成功连接https://gitee.com/P_n_ing/spring-cloud-config"
  3. 创建一个config_service_7081模块
    (1.)添加依赖
    <!-- springCloud Config -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-config-server</artifactId>
    </dependency>
    (2.)启动类
    package com.pning;
/**
 * @Author Pning
 * @Date 2021/5/30 21:33
 **/
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.config.server.EnableConfigServer;

@SpringBootApplication
@EnableConfigServer
public class ConfigService_7081_App {
    public static void main(String[] args) {
        SpringApplication.run(ConfigService_7081_App.class, args);
    }
}
    (3.)配置文件
    server:
  port: 7081

spring:
  application:
    name: pning_config_service
  cloud:
    config:
      server:
        git:
          uri: https://gitee.com/P_n_ing/spring-cloud-config #Git上面的git仓库名字
    (4.)通过多种方式查看能否读取到git上的配置文件
    我使用的是第二种：http://localhost:7081/config-test.yml，下面是官网文档截图，可自行参考
    在这里插入图片描述
  4. 模仿privoider_dept_8081模块创建config_client_7071模块作为客户端
    （1.）添加依赖
    		<!-- SpringCloud Config客户端 -->
			<dependency>
				<groupId>org.springframework.cloud</groupId>
				<artifactId>spring-cloud-starter-config</artifactId>
			</dependency>
    （2.）添加配置文件，但注意这次不是application.yml，而是bootstrap.yml，因为bootstrap开头的yml未系统级，application为用户级，级别高的先运行。
    spring:
  cloud:
    config:
      name: config-client7071  #需要从git上读取的资源名称，注意没有yml后缀名
      profile: dev              #本次访问的配置项
      label: master              #分支名
      uri: http://configservice7081.com:7081  #本微服务启动后先去找3344号服务，通过SpringCloudConfig获取Git的服务地址
P_ning
关注
专栏目录
《SpringCloud超级入门，【干货
m0_60746500的博客
08-08 156
编写启动类，代码如下。 @SpringBootApplication public class App { public static void main(String[] args) { SpringApplication.run(App.class, args); } }  启动类使用了 @SpringBootApplication 注解，这个注解表示该类是一个 Spring Boot 应用。直接运行 App 类即可启动，启动成功后在控制台输出信息，默认端口是...
Spring Cloud Alibaba + Dubbo2.7 + Nacos2.0 从零搭建(一)
lwb314的专栏
07-03 1083
@[TOC](Spring Cloud Alibaba + Dubbo2.7 + Nacos2.0 从零搭建(一)) 前言 整体入口： https://blog.csdn.net/lwb314/article/details/108277732 快速搭建 构建工具地址:http://start.aliyun.com 选最基本依赖 代码 把IDEA自动生成的代码删除，只留下启动类,我把修改bootstrap.properties文件格式改成了bootstrap.yml，代码修改如下: spring
手把手教你 SpringBoot + SpringCloud 开发环境搭建（一）
程序员小乐
03-28 1万+
点击上方 "程序员小乐"关注,星标或置顶一起成长每天凌晨00点00分,第一时间与你相约每日英文The best kind of tr...
Spring Cloud教程 第二弹 客户端负载均衡Ribbon
学无止境！
11-04 1177
更多Spring与微服务相关的教程请戳这里Spring与微服务教程合集 1、浅谈负载均衡 负载均衡（Load Balance）,是利用特定方式将流量分摊到多个操作单元上的一种手段。这个应该大家耳熟能详了！ 负载均衡的分类： 硬负载：即利用硬件进行负载均衡处理，如F5 软负载：即利用软件进行负载均衡处理，如nginx 负载均衡的另一种分类： 集中式负载（服务端负载）：集中式负载位于因特网与服务提供者之间，如nginx、F5 进程内负载（客户端负载）：指从一个实例库（即服务注册中心）选取.
Spring Cloud Ribbon负载均衡策略（IRule接口）
Aladdin.Cao的博客
12-04 722
Ribbon 组件自动基于某种规则（如简单轮询，随机连接等）去连接服务提供方得到机器，而IRule就是制定Ribbon要用什么样的规则来实现负载均衡的。IRule 根据特定算法中从服务列表中选取一个要访问的服务。而默认采用轮询算法。
springcloud搭建
07-21
SpringCloud搭建教程 在本文中，我们将深入探讨如何利用Java 8技术和SpringCloud构建一个完整的微服务架构。SpringCloud是一个全面的云应用开发工具集，它为开发者提供了在分布式系统（如配置管理、服务发现、断路...
详解利用SpringCloud搭建一个最简单的微服务框架
08-28
详解利用SpringCloud搭建一个最简单的微服务框架 什么是Spring Cloud？ Spring Cloud是一个基于Spring Boot实现的云应用开发工具，它为基于JVM的云应用开发中的配置管理、服务发现、断路器、智能路由、微代理、...
springcloud入门代码基于Spring Cloud搭建Eureka高可用集群
06-16
在本文中，我们将深入探讨如何使用Spring Cloud搭建Eureka高可用集群，这是一套用于构建分布式微服务架构的重要工具。Eureka是Netflix公司开源的一款服务注册与发现组件，它允许微服务之间相互发现并进行通信。...
使用Spring Cloud搭建微服务项目
weixin_70452974的博客
08-27 2831
使用Spring Cloud搭建微服务项目的案例，使用到Nacos、Dubbo、Sentinel、Seata、gateway等知识。
基于springcloud搭建的微服务程序
最新发布
07-12
【作品名称】：基于springcloud搭建的微服务程序 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。 【项目介绍】： 使用技术 版本：...
[梦中一夜下江南总结]SpringBoot集成负载匀衡Ribbon以及相关的配置
傅鹏程的博客
12-23 398
第一步添加依赖 如果添加过 <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId> <ver...
负载均衡策略之AbstractLoadBalancerRule和RandomRule源码解读
实践求真知
07-26 7021
一 负载均衡类图 二 AbstractLoadBalancerRule解读 //负载均衡策略的抽象类 public abstract class AbstractLoadBalancerRule implements IRule, IClientConfigAware { //该对象能够在具体实现选择服务策略时，获取一些负载均衡器中维护的信息来作为分配依据 privat...
负载均衡器之AbstractLoadBalancer解读
实践求真知
07-24 2514
一 类图 二 AbstractLoadBalancer类解读 //AbstractLoadBalancer是ILoadBalancer接口的抽象实现。 public abstract class AbstractLoadBalancer implements ILoadBalancer { //定义了一个关于服务实例的分组枚举类ServerGroup public enu...
3.springcloudAlibaba-负载均衡器Ribbon
weixin_42093813的博客
08-28 367
ribbon
SpringCloud自定义负载均衡策略--LoadBalancer
热门推荐
m0_57538148的博客
05-14 1万+
使用spring-cloud-starter-netflix-eureka-client依赖实现
微服务负载均衡器Ribbo
m0_69114709的博客
06-05 107
这种负载均衡策略带有重试功能，首先RetryRule又定义了一个subRule,他的实现类是RoundRobbinRule,然后在RetyRule的choose方法中，每次还是采用RoundRobinRule中的choose规则来选择一个服务实例，如果选到的实例正常就返回，如果选择的服务实例为null或者已经失败，则在失效的时间deadline之前不断的进行重试，若果超过了deandline还是没有取到服务实例就返回null。里面的核心方法就是choose方法，用来选择一个服务的实例。
Spring Cloud：使用Ribbon实现负载均衡详解（下）
双鬼带单
03-23 671
为了保证篇幅，在引用源码时，会将不必须的包名和注释删除 使用Ribbon实现负载均衡详解自定义 Ribbon 负载均衡策略1. 继承`AbstractLoadBalancerRule`2. 重写 `choose` 方法使用针对某个服务使用针对全部应用解决实际问题参考 自定义 Ribbon 负载均衡策略 前面讲了如何使用Ribbon以及其内置的几种负载均衡策略(IRULE). 通常情况下，内置的负...
(一) SpringBoot+SpringCloud+SpringCloudAlibaba项目框架搭建对应版本选择
专搞技术的小兔子
11-26 1608
SpringBoot+SpringCloud+SpringCloudAlibaba项目框架搭建 一、SpringBoot, SpringCloud, SpringCloudAlibaba版本选择 版本选择参考文章: https://www.cnblogs.com/yilangcode/p/15451850.html http://blog.itpub.net/31558068/viewspace-2766459/ SpringBoot, SpringCloud, SpringCloudAlibaba..
spring cloud搭建
09-13
Spring Cloud可以帮助开发人员快速搭建分布式系统中的常见模式。它提供了一系列工具，如配置管理、服务发现、断路器、智能路由、微代理和控制总线。下面是使用Spring Cloud搭建的一些步骤： 1. 首先，创建一个空项目。 2. 添加Spring Cloud Feign的依赖，可以通过以下配置来添加： ```xml <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-openfeign</artifactId> <version>2.1.1.RELEASE</version> </dependency> ``` 3. 在项目中添加`@EnableFeignClients`注解来启用Feign客户端。 4. 如果需要使用Ribbon实现客户端负载均衡调用，还需要添加以下依赖： ```xml <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-netflix-ribbon</artifactId> </dependency> ``` 同时，还需要进行相关的配置。 以上是使用Spring Cloud搭建分布式系统的简单步骤。根据具体需求，还可以进一步配置和调整系统。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值