精华内容
下载资源
问答
  • springcloud服务发现

    万次阅读 2019-10-15 22:45:30
    下面我们接着上一篇eureka的自我保护继续讲springcloud服务发现 controller层代码: package com.atguigu.springcloud.controller; import java.util.List; import org.springframework.beans.factory....

    下面我们接着上一篇eureka的自我保护继续讲springcloud服务发现

    controller层代码:

    package com.atguigu.springcloud.controller;
    
    import java.util.List;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.cloud.client.ServiceInstance;
    import org.springframework.cloud.client.discovery.DiscoveryClient;
    import org.springframework.web.bind.annotation.PathVariable;
    import org.springframework.web.bind.annotation.RequestBody;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RequestMethod;
    import org.springframework.web.bind.annotation.RestController;
    
    import com.atguigu.springcloud.entities.Dept;
    import com.atguigu.springcloud.service.DeptService;
    
    import javax.annotation.Resource;
    
    @RestController
    public class DeptController {
    
    	@Autowired
    	private DeptService service;
    
    	//@Autowired
    	@Resource
    	private DiscoveryClient client;
    
    	@RequestMapping(value = "/dept/add", method = RequestMethod.POST)
    	public boolean add(@RequestBody Dept dept) {
    		return service.add(dept);
    	}
    
    	@RequestMapping(value = "/dept/get/{id}", method = RequestMethod.GET)
    	public Dept get(@PathVariable("id") Long id) {
    		return service.get(id);
    	}
    
    	@RequestMapping(value = "/dept/list", method = RequestMethod.GET)
    	public List<Dept> list() {
    		return service.list();
    	}
    
    	
    //	@Autowired
    //	private DiscoveryClient client;
    	@RequestMapping(value = "/dept/discovery", method = RequestMethod.GET)
    	public Object discovery() {
    		List<String> list = client.getServices();
    		System.out.println("**********" + list);
    		List<ServiceInstance> srvList = client.getInstances("MICROSERVICECLOUD-DEPT");
    		for (ServiceInstance element : srvList) {
    			System.out.println(element.getServiceId() + "\t" + element.getHost() + "\t" + element.getPort() + "\t"
    					+ element.getUri());
    		}
    		return this.client;
    	}
    
    }
    
    注入服务发现
    @Resource
    private DiscoveryClient client;

     

    service层代码

    package com.atguigu.springcloud.service.impl;
    
    import java.util.List;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    
    import com.atguigu.springcloud.dao.DeptDao;
    import com.atguigu.springcloud.entities.Dept;
    import com.atguigu.springcloud.service.DeptService;
    
    @Service
    public class DeptServiceImpl implements DeptService {
    	@Autowired
    	private DeptDao deptDao;
    	
    	@Override
    	public boolean add(Dept dept)
    	{
    		return deptDao.addDept(dept);
    	}
    
    	@Override
    	public Dept get(Long id)
    	{
    		return deptDao.findById(id);
    	}
    
    	@Override
    	public List<Dept> list()
    	{
    		return deptDao.findAll();
    	}
    
    }
    

    dao层代码

    @Mapper
    //@Component
    @Repository
    public interface DeptDao {
    
    	public boolean addDept(Dept dept);
    	public Dept findById(Long id);
    	public List<Dept> findAll();
    }
    

    代码结构:

     

    mapper的核心配置文件mybatis.cfg.xml

    <?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE configuration
      PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
      "http://mybatis.org/dtd/mybatis-3-config.dtd">
    
    <configuration>
    
    	<settings>
    		<setting name="cacheEnabled" value="true" /><!-- 二级缓存开启 -->
    	</settings>
    
    </configuration>
    
    

     

    mapper的sql映射文件DeptMapper.xml

    <?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
    "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    
    <mapper namespace="com.atguigu.springcloud.dao.DeptDao">
    
    	<select id="findById" resultType="Dept" parameterType="Long">
    		select deptno,dname,db_source from dept where deptno=#{deptno};
    	</select>
    	<select id="findAll" resultType="Dept">
    		select deptno,dname,db_source from dept;
    	</select>
    	<insert id="addDept" parameterType="Dept">
    		INSERT INTO dept(dname,db_source) VALUES(#{dname},DATABASE());
    	</insert>
    
    </mapper>
     
    
    

    启动类:

    package com.atguigu.springcloud;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
    import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
    
    @SpringBootApplication
    @EnableEurekaClient //本服务启动后会自动注册进eureka服务中
    @EnableDiscoveryClient //服务发现
    public class DeptProvider8001_App {
    
    	public static void main(String[] args) {
    
    		SpringApplication.run(DeptProvider8001_App.class, args);
    	}
    }
    

     

    展开全文
  • Eureka服务发现注册详解

    万次阅读 2019-06-25 16:48:38
    Eureka是Netflix开发的服务发现框架,本身是一个基于REST的服务,主要用于定位运行在AWS域中的中间层服务,以达到负载均衡和中间层服务故障转移的目的。SpringCloud将它集成在其子项目spring-cloud-netflix中,以...

    一、服务发现简介

            1.服务提供者、服务消费者、服务发现组件三者之间的关系大致如下:

    • 各个微服务在启动时时,将自己的网络地址等信息注册到服务发现组件上(eureka,zookeeper,Consul,spring cloud alibaba的nacos),服务发现组件会存储这些信息。
    • 服务消费者会从服务发现组件查询服务提供者的网络地址,然后根据该地址调用服务提供者的接口。
    • 各个微服务与服务发现组件使用一定的机制来维持心跳,服务发现组件若发现有服务没有提供心跳,那么服务发现组件会将该服务剔除。
    • 微服务网络地址发生变更(例如实例增减或者IP端口发生变化等),会重新注册到服务发现组件上,使用这种方式,可以避免因网络变化导致服务之间的通讯停止,服务消费者也无须人工的修改网络地址。

    二、Eureka简介

            Eureka是Netflix开发的服务发现框架,本身是一个基于REST的服务,主要用于定位运行在AWS域中的中间层服务,以达到负载均衡和中间层服务故障转移的目的。SpringCloud将它集成在其子项目spring-cloud-netflix中,以实现SpringCloud的服务发现功能。

            1.Eureka包含两个组件:Eureka Server和Eureka Client。

    Eureka Server提供服务注册服务,各个节点启动后,会在Eureka Server中进行注册,这样EurekaServer中的服务注册表中将会存储所有可用服务节点的信息,服务节点的信息可以在界面中直观的看到。

    Eureka Client是一个java客户端,用于简化与Eureka Server的交互,客户端同时也就是一个内置的、使用轮询负载算法的负载均衡器。

           2.在应用启动后,将会向Eureka Server发送心跳,默认周期为30秒,如果Eureka Server在多个心跳周期内没有接收到某个节点的心跳,Eureka Server将会从服务注册表中把这个服务节点移除(默认90秒)。

           3.Eureka Server之间通过复制的方式完成数据的同步,Eureka还提供了客户端缓存机制,即使所有的Eureka Server都挂掉,客户端依然可以利用缓存中的信息消费其他服务的API。综上,Eureka通过心跳检查、客户端缓存等机制,确保了系统的高可用性、灵活性和可伸缩性。

     

    三、Eureka一些特性及配置过程时需要注意的问题

           1.Eureka能够保证AP,即当Eureka中的某个节点挂掉后,剩余的节点继续仍然可以提供服务的发现与注册服务。而Eureka的客户端在向某个Eureka或者发现了当前的Eureka不可用时,会自动切换到其他的节点,也就是说Eureka的节点是平等的,只要有一台Eureka服务器在,就能保证服务的可以继续被使用。

           2.Eureka的自我保护机制,我们在注册服务时,如发生断网的情况,Eureka不能接收到当前服务的任何心跳请求,Eureka会在默认的90s后,将该服务进行强制剔除,这样就能保证到网络故障时,虽然失去了部分节点,但不会像zookeeper那样会使整个注册服务瘫痪。当网络稳定时,新的实例会同步到其他节点中。

          3.相关配置问题

             服务端的配置如下,不注册自身:

    security:
      basic:
        enabled: true
      user:
        name: user
        password: password123
    eureka:
      client:
        register-with-eureka: false
        fetch-registry: false
        service-url:
          defaultZone: http://user:password123@localhost:8761/eureka

    如果我们需要使用ip地址来配置的话,先添加一行:

       eureka.instance.prefer.IpAddress=true;

    如果我们想要关闭保护机制,则设置以下代码:
    eureka.server.enable-self-preservation=false
    设置eureka剔除服务的时间间隔:
    eureka.server.eviction-interval-timer-in-ms=3000

     需要注意的是要在应用类的头上添加@EnableEurekaServer来启用Eureka服务器。

    接下来:访问Eureka,Url为:http://localhost:8761/

    可以发现eureka注册中心就启动了!!!

    在这里解释一下register-with-eureka=fasle和fetch-registry的用法,如果不指定该属性,服务端会将自身作为一个服务注册到注册中心去,因此我们需要在服务端启动前,指定这两个属性值为false。

    假如我们把以下代码给注释掉,指定一个应用名,重新启动eureka-server端:

    security:
      basic:
        enabled: true
      user:
        name: user
        password: password123
    
    server:
      port: 8888
    
    eureka:
      instance:
        hostname: 192.168.43.246
        prefer-ip-address: true
        instance-id: ${eureka.instance.hostname}:${server.port}
      client:
    #    register-with-eureka: false
    #    fetch-registry: false
        service-url:
          defaultZone: http://user:password123@${eureka.instance.hostname}:${server.port}/eureka
    spring:
      application:
        name: eureka-server
    

    发现eureka-server也注册到eureka上去了!

     

    注:

        如果使用ip地址来注册时,一定要添加以下两行代码:

        第一种方式: ,使用参数占位符来引用已经配置好的信息:

           eureka.instance.prefer-ip-adderss=true

            eureka.instance.instance-id=${eureka.instance.hostname}:${server.port}

         第二种方式: 使用springcloud来自动获取ip地址: 

         eureka.instance.hostname=${spring.cloud.client.ip-address}
         eureka.instance.instance-id=${eureka.instance.hostname}:${server.port}

    eureka客户端的配置添加上这两行代码,可以发现,添加以上两行代码的服务是以ip地址形式来注册的,没有添加的则以默认的方式来进行注册,即使用的主机名的方式来注册:

     

    附上使用ip地址注册服务的完整配置:

    eureka服务端:

    security:
      basic:
        enabled: true
      user:
        name: user
        password: password123
    
    server:
      port: 8888
    eureka:
      instance:
        hostname: 192.168.43.246
    #    使用ip地址的方式进行注册
    #    prefer-ip-address: true
    #    instance-id: ${eureka.instance.hostname}:${server.port}
      client:
    #    不注册自身
    #    register-with-eureka: false
    #    fetch-registry: false
        service-url:
          defaultZone: http://user:password123@${eureka.instance.hostname}:${server.port}/eureka
    spring:
      application:
        name: eureka-server
    

    eureka客户端:

    security:
      basic:
        enabled: true
      user:
        name: user
        password: password123
    
    server:
      port: 9999
    spring:
      application:
        name: eurekaClient
    eureka:
      instance:
        hostname: 192.168.43.246
        prefer-ip-address: true
        instance-id: ${eureka.instance.hostname}:${server.port}
      client:
       service-url:
          defaultZone: http://user:password123@${eureka.instance.hostname}:8888/eureka
    

    此处的server-url的端口号要为服务端的端口号。注: 是 deafaultZone, 不是default-zone

     附:使用指定的ip去注册

    客户端配置如下,如果你在pom文件中添加了如下依赖,客户端可以不用在启动类上面添加@EnableEurekaClient注解。只需要在applicantion.properties文件中添加配置即可:

     eureka客户端和eureka服务端:

     <!-- eureka-server-->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-eureka-server</artifactId>
                <version>1.2.3.RELEASE</version>
            </dependency>
    
            <!--eureka-client-->
    
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-eureka</artifactId>
                <version>1.2.3.RELEASE</version>
            </dependency>

     

     

     

     

    四、EurekaServer和EurekaClient的作用分析 

               1.  EurekaServer提供服务发现的能力,当有服务来注册时,EurekaServer会将这些服务的信息存储到起来。

               2.  EurekaClient是一个java客户端,可以与服务发现组件来交互。

               3.  续约。微服务启动后,会默认底向EurekaServer发送心跳,默认时间为30s,这样的作用就是续约自己的租约。

               4.  剔除。如果Eureka在一定时间内没有收到客户端的心跳,那么EurekaServer会剔除掉没有发生心跳客户端,默认时间为90s。  

               5. 缓存。EurekaClient会缓存服务器的信息,这种方式的好处是当EurekaServer宕机时,,服务消费者依然可以访问服务。

               6. eureka 服务器默认是将自身注册到服务器里。可以使用如下代码不讲自身注册进去:

         eureka:
      client:
    #    不注册自身
    #    register-with-eureka: false

               7. 如果设置多个eureka时,需要设置 eureka.client.fetchRegistry=true,表示多个服务器之间的数据同步。单个节点直接设置成false即可。

     

     

    五、Eureka开发实战

              1. 在Spring Cloud Edgware以及更高的版本中,只需要添加相关依赖,即可自动注册服务到EurekaServer中,在实际的项目中,我们可以直接实现服务消费者连接服务提供者,这样我们可以不用将服务注册到eureka上,以便于调试。

              2.  如果不想将服务注册到EurekaServer上,只需要设置spring.cloud.service-registry.auto-registration.enabled=false,或使用注解@EnableDiscoveryClient(auto-Registry=false)。

               为了便宜调试,可以直接使用服务提供者直连服务消费者的方式进行调试,服务调试可以参考我另外一篇博客: 

              https://blog.csdn.net/qq_33036061/article/details/103989170

     

     

     

    展开全文
  • 整合SpringCloud(配置中心+服务发现)3.1 写配置3.2 创建父工程demo3.3 创建nacos-provider 子工程pom 文件创建bootstrap.yml创建主程序创建controller3.4 创建nacos-consumer 子工程pom 文件创建bootstrap.yml创建...

    教程原稿 https://gitee.com/fakerlove/joker-nacos

    3. 整合SpringCloud(配置中心+服务发现)

    3.1 写配置

    image-20210113104707209

    image-20210113134337305

    3.2 创建父工程demo

    记住springboot 版本需要在2.0到2.3 之间,以上的话。nacos 是不支持的

    2.2.12 版本是nacos 所支持的最高版本

    pom文件

    <?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.2.12.RELEASE</version>
            <relativePath/> <!-- lookup parent from repository -->
        </parent>
    
        <groupId>com.example</groupId>
        <artifactId>demo</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <name>demo</name>
        <description>Demo project for Spring Boot</description>
        <modules>
            <module>nacos-provider</module>
            <module>nacos-consumer</module>
        </modules>
        <properties>
            <java.version>11</java.version>
            <nacos-config>2.2.3.RELEASE</nacos-config>
            <nacos-discovery>2.2.3.RELEASE</nacos-discovery>
    
        </properties>
    
        <dependencyManagement>
            <dependencies>
                <!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-dependencies -->
                <dependency>
                    <groupId>org.springframework.cloud</groupId>
                    <artifactId>spring-cloud-dependencies</artifactId>
                    <version>Hoxton.SR9</version>
                    <type>pom</type>
                    <scope>runtime</scope>
                </dependency>
                <!-- https://mvnrepository.com/artifact/com.alibaba.cloud/spring-cloud-starter-alibaba-nacos-discovery -->
                <dependency>
                    <groupId>com.alibaba.cloud</groupId>
                    <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
                    <version>${nacos-discovery}</version>
                </dependency>
    
                <!-- https://mvnrepository.com/artifact/com.alibaba.cloud/spring-cloud-starter-alibaba-nacos-config -->
                <dependency>
                    <groupId>com.alibaba.cloud</groupId>
                    <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
                    <version>${nacos-config}</version>
                </dependency>
            </dependencies>
        </dependencyManagement>
    
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
            </plugins>
        </build>
    
    </project>
    
    

    3.3 创建nacos-provider 子工程

    pom 文件

    <?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
        <parent>
           <artifactId>demo</artifactId>
            <groupId>com.example</groupId>
            <version>0.0.1-SNAPSHOT</version>
        </parent>
    
        <groupId>com.example</groupId>
        <artifactId>nacos-provider</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <name>nacos-provider</name>
        <description>Demo project for Spring Boot</description>
    
        <properties>
            <java.version>11</java.version>
        </properties>
    
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
            </dependency>
    
            <!-- https://mvnrepository.com/artifact/com.alibaba.cloud/spring-cloud-starter-alibaba-nacos-discovery -->
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
            </dependency>
    
            <!-- https://mvnrepository.com/artifact/com.alibaba.cloud/spring-cloud-starter-alibaba-nacos-config -->
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
            </dependency>
    
        </dependencies>
    
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
            </plugins>
        </build>
    
    </project>
    
    

    创建bootstrap.yml

    bootstrap.yml 优先级是高于application.yml,效果是一样的

    如果你的 nacos 在本地的话,application.yml 是没有问题的

    如果是在网上的话,需要使用bootstrap.yml ,

    不然其中的server-addr 是没有效果的

    server:
      port: 8070
    spring:
      application:
        name: nacos-provider
      cloud:
        # nacos服务地址
        nacos:
          config:
            server-addr: 47.100.104.187:8848
            namespace: cf6270d3-a5d2-46ac-a36a-051ef8fd0151
            group: DEFAULT_GROUP
            file-extension: yaml
            prefix: nacos-provider
          discovery:
            server-addr: 47.100.104.187:8848
            namespace: cf6270d3-a5d2-46ac-a36a-051ef8fd0151
    

    创建主程序

    @EnableDiscoveryClient开启服务发现

    package com.example.nacosprovider;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
    import org.springframework.web.bind.annotation.PathVariable;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RequestMethod;
    import org.springframework.web.bind.annotation.RestController;
    
    @SpringBootApplication
    @EnableDiscoveryClient
    public class NacosProviderApplication {
    
        public static void main(String[] args) {
            SpringApplication.run(NacosProviderApplication.class, args);
        }
    
    }
    

    创建controller

    package com.example.nacosprovider.controller;
    
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.cloud.context.config.annotation.RefreshScope;
    import org.springframework.web.bind.annotation.*;
    
    import java.time.LocalTime;
    
    @RefreshScope
    @RestController
    public class ProviderController {
        @Value("${provider.name}")
        private String devConfig;
    
        /**
         * 这个是用来测试配置是否正确的方法
         * @return
         */
        @GetMapping("invoke")
        public String invoke() {
            return LocalTime.now() + " invoke,name:" + devConfig;
        }
    
        /**
         * 这个是用来服务发现的服务方法
         * @param string
         * @return
         */
        @RequestMapping(value = "/echo/{string}", method = RequestMethod.GET)
        public String echo(@PathVariable String string) {
            return "8070 端口--提供服务的方法 " + string;
        }
    }
    

    3.4 创建nacos-consumer 子工程

    pom 文件

    <?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
        <parent>
            <artifactId>demo</artifactId>
            <groupId>com.example</groupId>
            <version>0.0.1-SNAPSHOT</version>
        </parent>
    
        <groupId>com.example</groupId>
        <artifactId>nacos-consumer</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <name>nacos-consumer</name>
        <description>Demo project for Spring Boot</description>
    
        <properties>
            <java.version>11</java.version>
        </properties>
    
        <dependencies>
    
            <!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-starter-openfeign -->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-openfeign</artifactId>
                <version>2.2.6.RELEASE</version>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
            </dependency>
    
            <!-- https://mvnrepository.com/artifact/com.alibaba.cloud/spring-cloud-starter-alibaba-nacos-discovery -->
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
            </dependency>
    
            <!-- https://mvnrepository.com/artifact/com.alibaba.cloud/spring-cloud-starter-alibaba-nacos-config -->
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
            </dependency>
        </dependencies>
    
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
            </plugins>
        </build>
    
    </project>
    
    

    创建bootstrap.yml

    server:
      port: 8071
    spring:
      application:
        name: nacos-consumer
      cloud:
        # nacos服务地址
        nacos:
          server-addr: 47.100.104.187:8848
          config:
            namespace: cf6270d3-a5d2-46ac-a36a-051ef8fd0151
            group: DEFAULT_GROUP
            file-extension: yaml
            server-addr: 47.100.104.187:8848
          discovery:
            server-addr: 47.100.104.187:8848
            namespace: cf6270d3-a5d2-46ac-a36a-051ef8fd0151
    

    创建主程序

    package com.example.nacosconsumer;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
    import org.springframework.cloud.client.loadbalancer.LoadBalanced;
    import org.springframework.context.annotation.Bean;
    import org.springframework.web.bind.annotation.PathVariable;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RequestMethod;
    import org.springframework.web.bind.annotation.RestController;
    import org.springframework.web.client.RestTemplate;
    
    @SpringBootApplication
    @EnableDiscoveryClient
    public class NacosConsumerApplication {
    
        public static void main(String[] args) {
            SpringApplication.run(NacosConsumerApplication.class, args);
        }
    
        @LoadBalanced
        @Bean
        public RestTemplate restTemplate() {
            return new RestTemplate();
    
        }
    
        /**
         * 这个是是用来测试 消费端能否连接服务端的
         */
        @RestController
        public class TestController {
            private final RestTemplate restTemplate;
    
            @Autowired
            public TestController(RestTemplate restTemplate) {this.restTemplate = restTemplate;}
            @RequestMapping(value = "/echo/{str}", method = RequestMethod.GET)
            public String echo(@PathVariable String str) {
                return restTemplate.getForObject("http://nacos-provider/echo/" + str, String.class);
            }
        }
    }
    
    

    创建controller

    package com.example.nacosconsumer.controller;
    
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.cloud.context.config.annotation.RefreshScope;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    import java.time.LocalTime;
    
    @RefreshScope
    @RestController
    public class ConsumerController {
        @Value("${consumer.name}")
        private String devConfig;
    
        /**
         * 这个是用来测试 消费端的接口是否正确
         * @return
         */
        @GetMapping("invoke")
        public String invoke() {
            return LocalTime.now() + " invoke,name:" + devConfig;
        }
    }
    

    3.5 测试

    测试provider 配置信息是否成功

    http://localhost:8070/invoke
    

    image-20210113135356397

    测试consumer 配置信息是否成功

    http://localhost:8071/invoke
    

    image-20210113135434343

    查看consumer 能否调用 provider

    http://localhost:8071/echo/22
    

    image-20210113135524712

    查看是否注册成功

    image-20210113135606956

    两个服务都成功

    展开全文
  • 如何理解服务注册和服务发现

    千次阅读 2019-05-06 11:49:28
    三者的关系是:通过服务注册机制将启动服务的信息上传至服务注册表,服务发现机制通过服务注册表实时获取可用服务的信息。 服务注册的方式包括:自注册和第三方注册。自注册的意思是当服务启动时,服务自动将信息...

    服务注册、服务注册表、服务发现

    三者的关系是:通过服务注册机制将启动服务的信息上传至服务注册表,服务发现机制通过服务注册表实时获取可用服务的信息。

    服务注册的方式包括:自注册和第三方注册。自注册的意思是当服务启动时,服务自动将信息上传至服务注册表,并通过心跳进行同步。第三方注册的意思是通过一个第三方的服务将启动服务的信息上传至服务注册表,并通过一定机制保持更新。缺点是要保证第三方服务的高可用性。

    服务注册表也是一个服务集群,维护了一个数据库,数据库中存储的是可用服务的信息。

    服务发现的意思是当需要使用服务时,通过读取服务注册表获取可用的服务信息,客户端可以通过此信息连接服务器。服务发现的方式包括:客户端服务发现和服务端服务发现。

    详细描述此文章 点击打开 讲的很清楚。

    展开全文
  • 服务发现和服务注册

    千次阅读 2018-06-10 10:17:52
    一 硬编码问题1 适用场景有局限:如果服务提供者的网络地址(IP和端口)发生了变化,将会影响服务消费者。例如,用户微服务的网络地址发生了变化,就需要修改电影微服务的配置,...二 服务发现服务提供者、服务消...
  • nacos源码阅读--服务发现

    万次阅读 2021-03-07 01:13:41
    } 1.5 debug有如下日志: 字面意思是动态服务列表,进去看看源代码 有一个定时任务scheduleWithFixedDelay,会一直周期执行更新操作: 一直找进去,发现有一个scheduleUpdateIfAbsent的方法,里边又有一个Update...
  • 我们先从服务发现相关接口开始分析 服务发现相关 核心接口DiscoveryClient DiscoveryClient public interface DiscoveryClient extends Ordered { int DEFAULT_ORDER = 0; //描述 String description(); //通过
  • 发现和被调用服务,C.接口服务 ,D. client服务; C服务调用B 服务,并且C 服务对外提供接口供D 服务使用 注意:示例只提供基本的逻辑,不做业务处理。 各个服务结构图如下: 服务A: pom文件: <...
  • 什么是服务发现

    千次阅读 2018-09-07 11:34:52
    引言 ... 服务发现是什么 服务发现的模式 客户端模式 服务端模式 几种服务发现框架的简介 Eureka 服务注册反注册机制 Consul ...
  • Spring cloud服务发现之服务提供者和服务消费者 1.服务提供者 2.服务提供者 3.启动运行 4.综上 1.服务提供者根据上节讲述的服务注册之Eureka注册中心,这节讲述服务提供者和服务消费者,首先新建一个工程,...
  • SpringCloud服务发现与服务注册

    万次阅读 2018-01-17 07:21:05
    服务发现与服务注册更多干货spring cloud 微服务spring cloud 知识点服务发现与服务注册定制Rabbon客户端负载均衡策略Spring Cloud Feign使用1SpringCloud Feign使用二SpringCloud Hystrix 实现SpringCloud超时机制...
  • 浅谈服务发现

    万次阅读 多人点赞 2017-08-27 09:19:13
    这片文章简单地介绍了服务发现,包括服务发现的两种模式,以及Eureka(偏向于AP)以及Consul(偏向于CP)两个微服务框架。
  • NodeJs服务注册与服务发现实现

    千次阅读 2019-01-09 12:38:04
    前言 由于作者才刚开始学习NodeJs,水平实在有限,本文更像是一篇学习笔记,适合同刚开始学习...服务注册与服务发现就是这其中一种机制,大概的流程为: 其中: 注册中心:zookeeper 服务提供者:NodeJs应用服...
  • 利用etcd实现服务注册和服务发现

    千次阅读 2019-03-31 16:45:37
    文章目录服务注册服务发现协议编写服务端实现客户端实现实验结果参考文章 服务注册 主要逻辑在go func函数里面,先是去etcd获取一下服务,没有获取到的话就注册进去。 package etcdservice import ( "context" ...
  • 服务发现框架中,服务提供端的作用是为消费端提供接口调用,提供端应该首先启动,依次完成服务注册、接口暴露等等。 首先看下提供端的配置信息: /** * @Author zxm * @Description * @Date Create in 下午 ...
  • Istio:服务发现和Pilot的架构机制

    千次阅读 2020-01-11 23:03:09
    Istio服务发现 Istio服务配置 stio服务发现&规则管理与Kubernetes结合 ShowCase Istio架构&Pilot介绍 Istio架构 Pilot功能 服务发现 服务配置 Istio服务发现 服务发现基本原理 a.app 88.88....
  • Prometheus 通过 consul 实现自动服务发现

    万次阅读 热门讨论 2019-11-12 09:23:07
    Consul 是基于 GO 语言开发的开源工具,主要面向分布式,服务化的系统提供服务注册、服务发现和配置管理的功能。Consul 提供服务注册/发现、健康检查、Key/Value存储、多数据中心和分布式一致性保证等功能。之前我们...
  • Nacos服务发现控制台预览

    千次阅读 2018-10-10 09:39:28
    Nacos是阿里巴巴中间件部门最近开源的一款用于服务发现和配置管理的产品。在既0.1版本发布基本功能和0.2版本发布与Spring生态结合的功能后,0.3版本将释放全新的控制台界面。配置管理功能相关的控制台,将会由阿里云...
  • Eureka Eureka是Spring Cloud Netfix微服务套件中的一部分,可以和SpringBoot构建的微服务很容易的...SpringCloud将它集成在自己的子项目 spring-cloud-netflix中,实现SpringCloud的服务发现功能。 Eureka包含两...
  • Eureka与ZooKeeper做服务发现对比

    千次阅读 2018-01-04 09:31:20
    Eureka与ZooKeeper做服务发现对比
  • 使用docker安装consul服务发现

    千次阅读 2019-05-24 19:18:57
    1. 拉取consul镜像 docker pull consul:latest 2. consul参数详解 –net=host docker参数, ...-server consul支持以server或client的模式运行, server是服务发现模块的核心, client主要用于转发请求 -advertis...
  • Kubernetes之服务发现Service

    千次阅读 2019-02-15 17:54:56
    原文:Kubernetes学习之路(十四)之服务发现Service 作者系列文章:https://www.cnblogs.com/linuxk/category/1248289.html 一、Service的概念  Kubernetes Pod 是有生命周期的,它们可以被创建,也可以被...
  • NsdService服务发现协议

    千次阅读 2013-03-28 20:42:32
    自android 4.1 开始实现了一个网络服务的发现服务NsdService,其基于苹果的Bonjour服务发现协议,支持远程服务的发现和零配置。  Bonjour协议包括IP地址的自动分配、服务名称与地址的转换以及服务的发现三部分...
  • spring cloud服务发现注解之@EnableDiscoveryClient与@EnableEurekaClient在之前的一篇文章Spring Cloud feign使用中在使用服务发现的时候提到了两种注解,一种为@EnableDiscoveryClient,一种为@EnableEurekaClient,...
  • 本文使用SpringCloud结合Nacos服务发现,Feign远程调用做一个简单的Demo。 1 Nacos 关于Nacos之前写了两篇文章关于SpringBoot对它的使用,感兴趣可以查看一下。 《SpringBoot使用Nacos配置中心》 《SpringBoot使用...
  • java框架篇spring cloud之服务发现consul

    千次阅读 2018-09-11 10:55:58
    上篇文章提到利用eureka做服务发现,spring config server做集中配置,但是由于eureka 2.0已经停止开源开发,建议开发者切换到consul或者zookeeper上。 除了上篇文件提到的架构: 我们可以考虑利用consul实现...
  • 服务发现系统consul

    千次阅读 2016-03-25 11:12:54
    支持多数据中心下,分布式高可用的,服务发现和配置共享。 consul支持健康检查,允许存储键值对。 一致性协议采用 Raft 算法,用来保证服务的高可用. 成员管理和消息广播 采用GOSSIP协议,支持ACL访问控制。...
  • 两种服务发现方式 常见的第三方注册工具 后记 前言 好一阵子没有更新了,有些小伙伴在后台问我有没有更新,看来大家还是挺喜欢看我的文章的嘛。主要是这段是间忙着复习算法的一些东西,也不想随便写一篇繁衍。**...
  • golang使用服务发现系统consul

    千次阅读 2017-07-08 16:38:47
    golang使用服务发现系统consul

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 174,081
精华内容 69,632
关键字:

服务发现