精华内容
下载资源
问答
  • Rest环境搭建:服务提供者和消费者 4.1 介绍 我们会使用一个Dept部门模块做一个微服务通用案例Consumer消费者(Client)通过REST调用Provider提供者(Server)提供的服务。 回顾Spring,SpringMVC,Mybatis等以往学习的...

    Rest环境搭建:服务提供者和消费者

    4.1 介绍

    • 我们会使用一个Dept部门模块做一个微服务通用案例Consumer消费者(Client)通过REST调用Provider提供者(Server)提供的服务。
    • 回顾Spring,SpringMVC,Mybatis等以往学习的知识。
    • Maven的分包分模块架构复习。
    一个简单的Maven模块结构是这样的:
    
    -- app-parent: 一个父项目(app-parent)聚合了很多子项目(app-util\app-dao\app-web...)
      |-- pom.xml
      |
      |-- app-core
      ||---- pom.xml
      |
      |-- app-web
      ||---- pom.xml
      ......
    

    一个父工程带着多个Moudule子模块

    MicroServiceCloud父工程(Project)下初次带着3个子模块(Module)

    • microservicecloud-api 【封装的整体entity/接口/公共配置等】
    • microservicecloud-consumer-dept-80 【服务消费者】
    • microservicecloud-provider-dept-8001 【服务提供者】

    版本选择

    大版本说明

    SpringBoot SpringCloud 关系
    1.2.x Angel版本(天使) 兼容SpringBoot1.2x
    1.3.x Brixton版本(布里克斯顿) 兼容SpringBoot1.3x,也兼容SpringBoot1.4x
    1.4.x Camden版本(卡姆登) 兼容SpringBoot1.4x,也兼容SpringBoot1.5x
    1.5.x Dalston版本(多尔斯顿) 兼容SpringBoot1.5x,不兼容SpringBoot2.0x
    1.5.x Edgware版本(埃奇韦尔) 兼容SpringBoot1.5x,不兼容SpringBoot2.0x
    2.0.x Finchley版本(芬奇利) 兼容SpringBoot2.0x,不兼容SpringBoot1.5x
    2.1.x Greenwich版本(格林威治)

    实际开发版本关系

    spring-boot-starter-parent spring-cloud-dependencles
    版本号 发布日期 版本号 发布日期
    1.5.2.RELEASE 2017-03 Dalston.RC1 2017-x
    1.5.9.RELEASE 2017-11 Edgware.RELEASE 2017-11
    1.5.16.RELEASE 2018-04 Edgware.SR5 2018-10
    1.5.20.RELEASE 2018-09 Edgware.SR5 2018-10
    2.0.2.RELEASE 2018-05 Fomchiey.BULD-SNAPSHOT 2018-x
    2.0.6.RELEASE 2018-10 Fomchiey-SR2 2018-10
    2.1.4.RELEASE 2019-04 Greenwich.SR1 2019-03

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Zr7qtaGV-1610696537728)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210114191102105.png)]

    使用后两个

    创建父工程

    • 新建父工程项目springcloud,切记Packageing是pom模式
    • 主要是定义POM文件,将后续各个子模块公用的jar包等统一提取出来,类似一个抽象父类
      在这里插入图片描述

    pom.xml

    <?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>com.haust</groupId>
        <artifactId>springcloud</artifactId>
        <version>1.0-SNAPSHOT</version>
        <modules>
            <module>springcloud-api</module>
            <module>springcloud-provider-dept-8001</module>
            <module>springcloud-consumer-dept-80</module>
            <module>springcloud-eureka-7001</module>
            <module>springcloud-eureka-7002</module>
            <module>springcloud-eureka-7003</module>
            <module>springcloud-provider-dept-8002</module>
            <module>springcloud-provider-dept-8003</module>
            <module>springcloud-consumer-dept-feign</module>
            <module>springcloud-provider-dept-hystrix-8001</module>
            <module>springcloud-consumer-hystrix-dashboard</module>
            <module>springcloud-zuul-9527</module>
            <module>springcloud-config-server-3344</module>
            <module>springcloud-config-client-3355</module>
            <module>springcloud-config-eureka-7001</module>
            <module>springcloud-config-dept-8001</module>
        </modules>
    
        <!--打包方式  pom-->
        <packaging>pom</packaging>
    
        <properties>
            <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
            <maven.compiler.source>1.8</maven.compiler.source>
            <maven.compiler.target>1.8</maven.compiler.target>
            <junit.version>4.12</junit.version>
            <log4j.version>1.2.17</log4j.version>
            <lombok.version>1.16.18</lombok.version>
        </properties>
    
        <dependencyManagement>
            <dependencies>
                <dependency>
                    <groupId>org.springframework.cloud</groupId>
                    <artifactId>spring-cloud-alibaba-dependencies</artifactId>
                    <version>0.2.0.RELEASE</version>
                    <type>pom</type>
                    <scope>import</scope>
                </dependency>
                <!--springCloud的依赖-->
                <dependency>
                    <groupId>org.springframework.cloud</groupId>
                    <artifactId>spring-cloud-dependencies</artifactId>
                    <version>Greenwich.SR1</version>
                    <type>pom</type>
                    <scope>import</scope>
                </dependency>
                <!--SpringBoot-->
                <dependency>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-dependencies</artifactId>
                    <version>2.1.4.RELEASE</version>
                    <type>pom</type>
                    <scope>import</scope>
                </dependency>
                <!--数据库-->
                <dependency>
                    <groupId>mysql</groupId>
                    <artifactId>mysql-connector-java</artifactId>
                    <version>5.1.47</version>
                </dependency>
                <dependency>
                    <groupId>com.alibaba</groupId>
                    <artifactId>druid</artifactId>
                    <version>1.1.10</version>
                </dependency>
                <!--SpringBoot 启动器-->
                <dependency>
                    <groupId>org.mybatis.spring.boot</groupId>
                    <artifactId>mybatis-spring-boot-starter</artifactId>
                    <version>1.3.2</version>
                </dependency>
                <!--日志测试~-->
                <dependency>
                    <groupId>ch.qos.logback</groupId>
                    <artifactId>logback-core</artifactId>
                    <version>1.2.3</version>
                </dependency>
                <dependency>
                    <groupId>junit</groupId>
                    <artifactId>junit</artifactId>
                    <version>${junit.version}</version>
                </dependency>
                <dependency>
                    <groupId>log4j</groupId>
                    <artifactId>log4j</artifactId>
                    <version>${log4j.version}</version>
                </dependency>
                <dependency>
                    <groupId>org.projectlombok</groupId>
                    <artifactId>lombok</artifactId>
                    <version>${lombok.version}</version>
                </dependency>
            </dependencies>
        </dependencyManagement>
    
    </project>
    

    父工程为springcloud,其下有多个子mudule,详情参考完整代码了解

    在这里插入图片描述

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ph2yN66N-1610696537730)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210114203950885.png)]

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Vbj1pl9v-1610696537733)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210114205910420.png)]

    springcloud-provider-dept-8001(提供者)

    server:
      port: 8001
    mybatis:
      type-aliases-package: com.kuang.springcloud.pojo
      config-location: classpath:mybatis/mapper-config.xml
      mapper-locations: classpath:mybatis/mapper/*.xml
    
    
    # spring配置
    spring:
      application:
        name: springcloud-provider-dept
      datasource:
        type: com.alibaba.druid.pool.DruidDataSource
        driver-class-name: com.mysql.jdbc.Driver
        url: jdbc:mysql://localhost:3306/db01?userSSL=true&useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
        username: root
        password: 123456
    

    springcloud-consumer-dept-80访问springcloud-provider-dept-8001下的controller使用REST方式

    springcloud-consumer-dept-80(消费者)

    80端口请求的时候不用带端口号

    DeptConsumerController.java

    /**
     * @Auther: csp1999
     * @Date: 2020/05/17/22:44
     * @Description:
     */
    @RestController
    public class DeptConsumerController {
    
        /**
         * 理解:消费者,不应该有service层~
         * RestTemplate .... 供我们直接调用就可以了! 注册到Spring中
         * (地址:url, 实体:Map ,Class<T> responseType)
         * <p>
         * 提供多种便捷访问远程http服务的方法,简单的Restful服务模板~
         */
        @Autowired
        private RestTemplate restTemplate;
    
        /**
         * 服务提供方地址前缀
         * <p>
         * Ribbon:我们这里的地址,应该是一个变量,通过服务名来访问
         */
        private static final String REST_URL_PREFIX = "http://localhost:8001";
        //private static final String REST_URL_PREFIX = "http://SPRINGCLOUD-PROVIDER-DEPT";
    
        /**
         * 消费方添加部门信息
         * @param dept
         * @return
         */
        @RequestMapping("/consumer/dept/add")
        public boolean add(Dept dept) {
            // postForObject(服务提供方地址(接口),参数实体,返回类型.class)
            return restTemplate.postForObject(REST_URL_PREFIX + "/dept/add", dept, Boolean.class);
        }
    
        /**
         * 消费方根据id查询部门信息
         * @param id
         * @return
         */
        @RequestMapping("/consumer/dept/get/{id}")
        public Dept get(@PathVariable("id") Long id) {
            // getForObject(服务提供方地址(接口),返回类型.class)
            return restTemplate.getForObject(REST_URL_PREFIX + "/dept/get/" + id, Dept.class);
        }
    
        /**
         * 消费方查询部门信息列表
         * @return
         */
        @RequestMapping("/consumer/dept/list")
        public List<Dept> list() {
            return restTemplate.getForObject(REST_URL_PREFIX + "/dept/list", List.class);
        }
    }
    

    RestTemplete

    使用RestTemplete先需要放入Spring容器中

    提供多种便捷访问远程http服务的方法,简单的Restful服务模板~

    ConfigBean.java

    @Configuration
    public class ConfigBean {//@Configuration -- spring  applicationContext.xml
    
        //配置负载均衡实现RestTemplate
        // IRule
        // RoundRobinRule 轮询
        // RandomRule 随机
        // AvailabilityFilteringRule : 会先过滤掉,跳闸,访问故障的服务~,对剩下的进行轮询~
        // RetryRule : 会先按照轮询获取服务~,如果服务获取失败,则会在指定的时间内进行,重试
        @Bean
        public RestTemplate getRestTemplate(){
            return new RestTemplate();
        }
    }
    

    springcloud-provider-dept-8001的dao接口调用springcloud-api模块下的pojo,可使用在springcloud-provider-dept-8001的pom文件导入springcloud-api模块依赖的方式:

     <!--我们需要拿到实体类,所以要配置api module-->
            <dependency>
                <groupId>com.haust</groupId>
                <artifactId>springcloud-api</artifactId>
                <version>1.0-SNAPSHOT</version>
            </dependency>
    

    springcloud-consumer-dept-80和springcloud-provider-dept-8001的pom.xml和父工程下的依赖基本一样,直接看完整代码即可,不再添加重复笔记。

    进行测试

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MFsAuSs9-1610696537737)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210114231512178.png)]

    展开全文
  • Spring cloud服务发现之服务提供者和服务消费者 1.服务提供者 2.服务提供者 3.启动运行 4.综上 1.服务提供者根据上节讲述的服务注册之Eureka注册中心,这节讲述服务提供者和服务消费者,首先新建一个工程,...

    Spring cloud服务发现之服务提供者和服务消费者


    • 1.服务提供者

    • 2.服务提供者

    • 3.启动运行

    • 4.综上

    1.服务提供者


    根据上节讲述的服务注册之Eureka注册中心,这节讲述服务提供者和服务消费者,首先新建一个工程,命名为microservice-provider-user,其中pom.xml文件如下:

    <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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <parent>
            <artifactId>micorservice-study</artifactId>
            <groupId>cn.com</groupId>
            <version>1.0-SNAPSHOT</version>
        </parent>
        <modelVersion>4.0.0</modelVersion>
    
        <artifactId>microservice :: provider :: user</artifactId>
        <packaging>jar</packaging>
    
        <name>microservice :: provider :: user</name>
        <url>http://maven.apache.org</url>
    
        <properties>
            <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        </properties>
    
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
            </dependency>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-eureka</artifactId>
            </dependency>
        </dependencies>
    </project>
    

    ProviderApplication为:

    package cn.com.provider;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
    
    /**
     * Created by xiaxuan on 17/2/26.
     */
    @SpringBootApplication
    @EnableDiscoveryClient
    public class ProviderApplication {
    
        public static void main(String[] args) {
            SpringApplication.run(ProviderApplication.class, args);
        }
    }
    

    实体类User:

    package cn.com.provider.domain;
    
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    
    /**
     * Created by xiaxuan on 17/2/26.
     */
    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class User {
    
        private Long id;
    
        private String username;
    
        private Integer age;
    }
    

    提供一个service,提供简单的获取User对象的服务,代码为以下:
    UserService:

    package cn.com.provider.service;
    
    import cn.com.provider.domain.User;
    import org.springframework.stereotype.Service;
    
    import java.util.HashMap;
    import java.util.Map;
    
    /**
     * Created by xiaxuan on 17/2/26.
     */
    @Service
    public class UserService {
    
        private static Map<Long, User> users = new HashMap<>();
    
        static {
            users.put(1L, new User(1L, "xiaxuan", 24));
            users.put(2L, new User(2L, "bingwen", 24));
        }
    
        public User findUserById(Long id) {
            return users.get(id);
        }
    }
    

    提供controller为UserController,代码如下:

    package cn.com.provider.controllers;
    
    import cn.com.provider.domain.User;
    import cn.com.provider.service.UserService;
    import org.apache.log4j.BasicConfigurator;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.PathVariable;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    /**
     * Created by xiaxuan on 17/2/26.
     */
    @RestController
    @RequestMapping("/user")
    public class UserController {
    
        private static final Logger LOGGER = LoggerFactory.getLogger(UserController.class);
    
        @Autowired
        private UserService userService;
    
        /**
         * 目前图简便,就用缺省的配置了
         */
        static {
            BasicConfigurator.configure();
        }
    
        @GetMapping("/{id}")
        private User findById(@PathVariable Long id) {
            User user = userService.findUserById(id);
            LOGGER.info("获取用户id为 {} 的用户,详细信息为 {}", id, user);
            return user;
        }
    }
    

    启动类ProviderApplication:

    package cn.com.provider;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
    
    /**
     * Created by xiaxuan on 17/2/26.
     */
    @SpringBootApplication
    @EnableDiscoveryClient
    public class ProviderApplication {
    
        public static void main(String[] args) {
            SpringApplication.run(ProviderApplication.class, args);
        }
    }
    

    启动类上加上注解@EnableDiscoveryClient,开启服务发现能力。

    配置文件为:

    server:
      port: 8011
    spring:
      application:
        name: microservice-provider-user
    
    eureka:
      client:
        serviceUrl:
          defaultZone: http://eureka:8000/eureka/
      instance:
        preferIpAddress: true

    标明application名字,运行端口,注册中心地址,具体不再详述了。

    2.服务提供者


    再次新建一个module,命名为microservice-consumer-user,pom文件和上面消费提供者的一样就不再贴出来了。
    启动类ConsumerApplication:

    package cn.com.consumer;
    
    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.client.RestTemplate;
    
    /**
     * Created by xiaxuan on 17/2/26.
     */
    @SpringBootApplication
    @EnableDiscoveryClient
    public class ConsumerApplication {
    
        @Bean
        @LoadBalanced
        public RestTemplate restTemplate() {
            return new RestTemplate();
        }
    
        public static void main(String[] args) {
            SpringApplication.run(ConsumerApplication.class, args);
        }
    }
    

    同样,加上@EnableDiscoveryClient,开启服务发现能力,同时提供一个RestTemplate的Bean,因为在spring cloud中,服务之间的调用是通过rest来实现的,等下要使用restTemplate来调用服务提供者提供的服务,在其中有一个注解@LoadBalanced,这个是开启负载均衡使用的,使用到了Ribbon技术,这个放到后面来讲。

    实体类不再贴出,其中service ConsumerService为:

    package cn.com.consumer.services;
    
    import cn.com.consumer.domain.User;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    import org.springframework.web.client.RestTemplate;
    
    /**
     * Created by xiaxuan on 17/2/26.
     */
    @Service
    public class ConsumerService {
    
        @Autowired
        private RestTemplate restTemplate;
    
        public User findById(Long id) {
            return restTemplate.getForObject("http://MICROSERVICE-PROVIDER-USER/user/" + id, User.class);
        }
    }
    

    在以上中,我们调用服务提供者中的地址并不是localhost:8011,而是MICROSERVICE-PROVIDER-USER,这是因为我们开启了服务发现之后可以直接通过服务名来调用服务,而不需要写ip加端口,这样的好处是如果服务提供者是集群模式,就不用调用ip和端口的方式了,同时也能做到负载均衡的能力。

    Controller为ConsumerController:

    package cn.com.consumer.controllers;
    
    import cn.com.consumer.domain.User;
    import cn.com.consumer.services.ConsumerService;
    import org.apache.log4j.BasicConfigurator;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.PathVariable;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    /**
     * Created by xiaxuan on 17/2/26.
     */
    @RestController
    @RequestMapping("/consumer")
    public class ConsumerController {
    
        private static final Logger LOGGER = LoggerFactory.getLogger(ConsumerController.class);
    
        @Autowired
        private ConsumerService consumerService;
    
        /**
         * 采用缺省配置
         * */
        static {
            BasicConfigurator.configure();
        }
    
        @GetMapping("/{id}")
        public User findById(@PathVariable Long id) {
            User user = consumerService.findById(id);
            LOGGER.info("获取到的用户id为 {}, User为 {}", id, user);
            return user;
        }
    }
    

    比较简单,就是简单的获取user服务。

    3.启动运行


    启动运行需要有三个模块,分别为:

    • microservice-eureka 注册中心

    • microservice-provider-user 服务提供者

    • microservice-consumer-user 服务消费者

    依次按照顺序启动上面三个服务,在浏览器上输入http://eureka:8000,图示如下:


    以上注册了两个服务。

    现在浏览器上输入:http://localhost:8012/consumer/1,如下:

    调用成功。

    4.综上


    • 我们再通过服务注册和消费的时候,其实内部还是使用了Ribbon的相关技术,这个放到后面和fegin一起讲。

    • spring cloud服务之间的调用是通过rest的方式完成的,这个的效率相对于使用rpc来说还是要差一点,后面讲怎样将dubbo和dubbox整合起来一起使用。

    • 下一期讲eureka的高可用和服务提供者、服务消费者集群之间的调用方式。

    展开全文
  • SpringCloud之服务提供者和服务消费者

    千次阅读 2017-10-18 16:44:01
    编写服务提供者 编写服务消费者 微服务构建的是分布式系统,各个微服务之间通过网络进行通信。一般我们用服务提供者和服务消费者来描述微服务之间的调用关系: 服务提供者 服务被调用方 服务...
    • 编写服务提供者
    • 编写服务消费者

    微服务构建的是分布式系统,各个微服务之间通过网络进行通信。一般我们用服务提供者和服务消费者来描述微服务之间的调用关系:

    服务提供者

    服务被调用方

    服务消费者

    服务的调用方

    以售票系统为例,用户向12306售票系统发起购票请求,在进行购买业务之前,12306售票系统需要先调用用户微服务接口,查看用户的相关信息是否符合购买标准等相关信息,这里,用户微服务就是服务的提供者,售票系统微服务就是服务消费者。下面依次在Intellij idea中手动创建这两个微服务:

    先创建用户微服务:maven的pom.xml文件信息如下:

    <?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>com.simons.cn</groupId>
        <artifactId>user-provider</artifactId>
        <version>1.0-SNAPSHOT</version>
    
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>1.4.3.RELEASE</version>
        </parent>
        <properties>
            <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
            <java.version>1.7</java.version>
        </properties>
        <dependencies>
            <!--支持web应该用开发,包括spring-mvc、jackson、tomcat、spring-webmvc-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
            <!--springboot Actuator提供了众多检测端点,了解应用程序的运行状况-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-actuator</artifactId>
            </dependency>
            <!--配置mybatis启动器依赖-->
            <dependency>
                <groupId>org.mybatis.spring.boot</groupId>
                <artifactId>mybatis-spring-boot-starter</artifactId>
                <version>1.2.0</version>
            </dependency>
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>5.1.22</version>
            </dependency>
            <!--lombok依赖-->
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>1.16.12</version>
                <scope>provided</scope>
            </dependency>
    
        </dependencies>
        <!-- 引入spring cloud的依赖 -->
        <dependencyManagement>
            <dependencies>
                <dependency>
                    <groupId>org.springframework.cloud</groupId>
                    <artifactId>spring-cloud-dependencies</artifactId>
                    <version>Camden.SR4</version>
                    <type>pom</type>
                    <scope>import</scope>
                </dependency>
            </dependencies>
        </dependencyManagement>
        <!-- 添加spring-boot的maven插件 -->
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
            </plugins>
        </build>
    </project>
    

    生成项目后,把通过mybatis反向生成的实体和xml文件copy到相关目录(mybatis反向生成点这里),目录如图:

    这里要注意要修改UserMapper.xml中Mapper和User类为你实际路径。

    接着编写启动类ProviderUserApplication:

    import org.mybatis.spring.annotation.MapperScan;
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    
    //扫描*Mapper.java接口文件
    @MapperScan("com.simons.cn.mapper")
    @SpringBootApplication
    public class PrividerUserApplication {
        public static void main(String[] args) {
            SpringApplication.run(PrividerUserApplication.class);
        }
    }

    @SpringBootApplication是一个组合注解,它整合了@Configuration、@EnableAutoConfiguration和@ComponentScan注解,并且开启了springboot程序组件扫描和自动配置功能;@MapperScan注解用来扫描mapper接口。

    接着编写UserController类:

    import com.simons.cn.bean.User;
    import com.simons.cn.service.UserServiceImpl;
    import com.simons.cn.util.CommonEnum;
    import com.simons.cn.util.CommonResult;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.*;
    import java.util.List;
    
    @Slf4j
    @RestController
    public class UserController {
    
        @Autowired
        private UserServiceImpl userService;
    
        @GetMapping(value = "/getuserinfo")
        public CommonResult getUserInfo(@RequestParam(required = false,value = "name") String name){
            List<User> userList = userService.getUserByName(name);
            return CommonResult.success(CommonEnum.SUCESS.getCode(),CommonEnum.SUCESS.getMessage(),userList);
        }
    }

    @RestController注解声明等价于@Controller和@ResponseBody注解联合作用,标识该类均返回一个rest风格的data;@GetMapping是spring4.3提供的新注解,等价于@RequestMapping(value="/{id}",method=RequestMethod.GET),同理还有@PostMapping()等。

    接着编写配置文件application.yml或application.properties均可,我这里是application.yml

    server:
      port: 8000
    # 数据库连接信息
    spring:
      datasource:
               url: jdbc:mysql://×××:3306/simons?rewriteBatchedStatements=true&characterEncoding=utf-8
               username: ×××
               password: ×××
               driver-class-name: com.mysql.jdbc.Driver
    # mybatis扫描信息
    mybatis:
      typeAliasesPackage: com.simonsfan.study.bean  #实体对象所以在包
      mapper-locations: classpath:mapper/*.xml       #xml文件位置

    需要注意的是,yml文件中冒号后面要空一格,例如port: 8000冒号后面一定要空格再接8000

    接下来可以启动ProviderUserApplication启动类。

    测试:浏览器访问http://localhost:8000/getuserinfo?name=jack,返回

    {
      "code": "0",
      "message": "success",
      "data": [{
        "id": 125,
        "name": "jack",
        "role": "system"}]
    }

    这样,用户微服务就顺利完成。同理,可以编写售票系统的服务消费者。pom.xml文件基本不变

    <?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>com.simons.cn</groupId>
        <artifactId>ticket-coucumer</artifactId>
        <version>1.0-SNAPSHOT</version>
        <packaging>jar</packaging>
    
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>1.4.3.RELEASE</version>
        </parent>
        <properties>
            <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
            <java.version>1.7</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-actuator</artifactId>
            </dependency>
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>5.1.22</version>
            </dependency>
            <!--lombok依赖-->
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>1.16.12</version>
                <scope>provided</scope>
            </dependency>
        </dependencies>
        <!-- 引入spring cloud的依赖 -->
        <dependencyManagement>
            <dependencies>
                <dependency>
                    <groupId>org.springframework.cloud</groupId>
                    <artifactId>spring-cloud-dependencies</artifactId>
                    <version>Camden.SR4</version>
                    <type>pom</type>
                    <scope>import</scope>
                </dependency>
            </dependencies>
        </dependencyManagement>
        <!-- 添加spring-boot的maven插件 -->
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
            </plugins>
        </build>
    </project>
    

    接着我把刚才服务提供者里面要用的一些类都copy到服务消费者来,目录结构如下:

    编写启动类ConsumerApplication:

    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.context.annotation.Bean;
    import org.springframework.web.client.RestTemplate;
    
    @SpringBootApplication
    public class ConsumerApplication {
    
        @Bean
        public RestTemplate restTemplate() {
            return new RestTemplate();
        }
    
        public static void main(String[] args) {
            SpringApplication.run(ConsumerApplication.class, args);
        }
    }

    其中@Bean是一个方法注解,作用是实例化一个Bean并使用该方法的名称命名,本例中的用法等价于RestTemplate restTemplate = new RestTemplate()

    接着创建TicketController:

    import com.simons.cn.util.CommonResult;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RequestParam;
    import org.springframework.web.bind.annotation.RestController;
    import org.springframework.web.client.RestTemplate;
    
    @Slf4j
    @RestController
    public class TicketController {
    
        @Autowired
        private RestTemplate restTemplate;
    
        @GetMapping("/ticketpurchase")
        public CommonResult purchaseTicket(@RequestParam(required = false,value = "name") String name){
            //模拟判断用户身份
            CommonResult result = restTemplate.getForObject("http://localhost:8000/getuserinfo?name=" + name, CommonResult.class);
            //买票下单逻辑略
            return result;
        }
    
    }

    这里要注意的是,刚才编写的CommonResult类中一定要添加无参构造函数,否则上面的调用会报错!!!

    编写application.yml文件:

    server:
      port: 8888
    

    这样,售票微服务也完成了。启动ConsumerApplication启动类

    测试:浏览器访问:http://localhost:9000/ticketpurchase?name=jack,结果如下:

    {
      "code": "0",
      "message": "success",
      "data": [{
        "id": 125,
        "name": "jack",
        "role": "system"
        }]
    }

    说明售票微服务已经可以正常使用RestTemplate和用户微服务API通信了。

    项目的github:https://github.com/simonsfan/SpringCloud.git

    展开全文
  • spring cloud服务提供者与服务消费者

    千次阅读 2018-06-10 09:26:12
    一 Spring Tool Suit官网下载https://spring.io/tools/sts/legacy下载3.8.3版本二 服务提供者和服务消费者服务提供者:服务的被调用方,即为其他服务提供服务的服务。服务消费者:服务的调用方,即依赖其他服务...
    一 Spring Tool Suit官网下载
    下载3.8.3版本
    二 服务提供者和服务消费者
    服务提供者:服务的被调用方,即为其他服务提供服务的服务。
    服务消费者:服务的调用方,即依赖其他服务的服务。
    三 服务提供者编写过程
    2 创建用户微服务
    3 点击生成项目
    生成 microservice-simple-provider-user.zip
    4 创建电影微服务
    microservice-simple-consumer-movie.zip
    四 导入用户微服务
    五 编写服务提供者
    1 pom.xml
    <?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.0http://maven.apache.org/xsd/maven-4.0.0.xsd">
      <modelVersion>4.0.0</modelVersion>
      <groupId>com.itmuch.cloud</groupId>
      <artifactId>microservice-simple-provider-user</artifactId>
      <version>0.0.1-SNAPSHOT</version>
      <packaging>jar</packaging>
      <!-- 引入spring boot的依赖 -->
      <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.4.3.RELEASE</version>
      </parent>
      <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <java.version>1.8</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-data-jpa</artifactId>
        </dependency>
        <dependency>
          <groupId>com.h2database</groupId>
          <artifactId>h2</artifactId>
        </dependency>
        <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
      </dependencies>
      <!-- 引入spring cloud的依赖 -->
      <dependencyManagement>
        <dependencies>
          <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>Camden.SR4</version>
            <type>pom</type>
            <scope>import</scope>
          </dependency>
        </dependencies>
      </dependencyManagement>
      <!-- 添加spring-boot的maven插件 -->
      <build>
        <plugins>
          <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
          </plugin>
        </plugins>
      </build>
    </project>
    2 准备好建表语句,在项目的classpath下建立schema.sql.
    drop table user if exists;
    create table user (id bigint generated by default as identity, username varchar(40), name varchar(20), age int(3), balance decimal(10,2), primary key (id));
    3 准备好几条数据,在classpath下建立文件data.sql
    insert into user (id, username, name, age, balance) values (1, 'account1', '张三', 20, 100.00);
    insert into user (id, username, name, age, balance) values (2, 'account2', '李四', 28, 180.00);
    insert into user (id, username, name, age, balance) values (3, 'account3', '王五', 32, 280.00);
    4 创建实体类
    package com.itmuch.cloud.study.entity;
    
    import java.math.BigDecimal;
    
    import javax.persistence.Column;
    import javax.persistence.Entity;
    import javax.persistence.GeneratedValue;
    import javax.persistence.GenerationType;
    import javax.persistence.Id;
    
    @Entity
    public class User {
      @Id
      @GeneratedValue(strategy = GenerationType.AUTO)
      private Long id;
      @Column
      private String username;
      @Column
      private String name;
      @Column
      private Integer age;
      @Column
      private BigDecimal balance;
    
      public Long getId() {
        return this.id;
      }
    
      public void setId(Long id) {
        this.id = id;
      }
    
      public String getUsername() {
        return this.username;
      }
    
      public void setUsername(String username) {
        this.username = username;
      }
    
      public String getName() {
        return this.name;
      }
    
      public void setName(String name) {
        this.name = name;
      }
    
      public Integer getAge() {
        return this.age;
      }
    
      public void setAge(Integer age) {
        this.age = age;
      }
    
      public BigDecimal getBalance() {
        return this.balance;
      }
    
      public void setBalance(BigDecimal balance) {
        this.balance = balance;
      }
    
    }
    5 创建DAO
    package com.itmuch.cloud.study.repository;
    
    import org.springframework.data.jpa.repository.JpaRepository;
    import org.springframework.stereotype.Repository;
    
    import com.itmuch.cloud.study.entity.User;
    
    @Repository
    public interface UserRepository extends JpaRepository<User, Long> {
    }
    6 创建Controller
    package com.itmuch.cloud.study.controller;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.PathVariable;
    import org.springframework.web.bind.annotation.RestController;
    
    import com.itmuch.cloud.study.entity.User;
    import com.itmuch.cloud.study.repository.UserRepository;
    
    @RestController
    public class UserController {
      @Autowired
      private UserRepository userRepository;
    
      @GetMapping("/{id}")
      public User findById(@PathVariable Long id) {
        User findOne = this.userRepository.findOne(id);
        return findOne;
      }
    }
    6 编写启动类
    package com.itmuch.cloud.study;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    
    @SpringBootApplication
    public class ProviderUserApplication {
      public static void main(String[] args) {
        SpringApplication.run(ProviderUserApplication.class, args);
      }
    }
    7 编写配置文件
    server:
      port: 8000
    spring:
      jpa:
        generate-ddl: false
        show-sql: true
        hibernate:
          ddl-auto: none
      datasource:                           # 指定数据源
        platform: h2                        # 指定数据源类型
        schema: classpath:schema.sql        # 指定h2数据库的建表脚本
        data: classpath:data.sql            # 指定h2数据库的数据脚本
    logging:                                # 配置日志级别,让hibernate打印出执行的SQL
      level:
        root: INFO
        org.hibernate: INFO
        org.hibernate.type.descriptor.sql.BasicBinder: TRACE
        org.hibernate.type.descriptor.sql.BasicExtractor: TRACE
       
    ## INFO
    info:
      app:
        name: @project.artifactId@
        encoding: @project.build.sourceEncoding@
        java:
          source: @java.version@
          target: @java.version@
    8 测试
    六 编写服务消费者
    1 pom.xml
    <?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.0http://maven.apache.org/xsd/maven-4.0.0.xsd">
      <modelVersion>4.0.0</modelVersion>
      <groupId>com.itmuch.cloud</groupId>
      <artifactId>microservice-simple-consumer-movie</artifactId>
      <version>0.0.1-SNAPSHOT</version>
      <packaging>jar</packaging>
      <!-- 引入spring boot的依赖 -->
      <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.4.3.RELEASE</version>
      </parent>
      <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <java.version>1.8</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-actuator</artifactId>
        </dependency>
      </dependencies>
      <!-- 引入spring cloud的依赖 -->
      <dependencyManagement>
        <dependencies>
          <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>Camden.SR4</version>
            <type>pom</type>
            <scope>import</scope>
          </dependency>
        </dependencies>
      </dependencyManagement>
      <!-- 添加spring-boot的maven插件 -->
      <build>
        <plugins>
          <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
          </plugin>
        </plugins>
      </build>
    </project>
    2 实体类
    package com.itmuch.cloud.study.user.entity;
    import java.math.BigDecimal;
    public class User {
      private Long id;
      private String username;
      private String name;
      private Integer age;
      private BigDecimal balance;
      public Long getId() {
        return this.id;
      }
      public void setId(Long id) {
        this.id = id;
      }
      public String getUsername() {
        return this.username;
      }
      public void setUsername(String username) {
        this.username = username;
      }
      public String getName() {
        return this.name;
      }
      public void setName(String name) {
        this.name = name;
      }
      public Integer getAge() {
        return this.age;
      }
      public void setAge(Integer age) {
        this.age = age;
      }
      public BigDecimal getBalance() {
        return this.balance;
      }
      public void setBalance(BigDecimal balance) {
        this.balance = balance;
      }
    }
    3 启动类
    package com.itmuch.cloud.study;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.context.annotation.Bean;
    import org.springframework.web.client.RestTemplate;
    
    @SpringBootApplication
    public class ConsumerMovieApplication {
      @Bean
      public RestTemplate restTemplate() {
        return new RestTemplate();
      }
    
      public static void main(String[] args) {
        SpringApplication.run(ConsumerMovieApplication.class, args);
      }
    }
    4 Controller
    package com.itmuch.cloud.study.user.controller;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.PathVariable;
    import org.springframework.web.bind.annotation.RestController;
    import org.springframework.web.client.RestTemplate;
    
    import com.itmuch.cloud.study.user.entity.User;
    
    @RestController
    public class MovieController {
      @Autowired
      private RestTemplate restTemplate;
    
      @GetMapping("/user/{id}")
      public User findById(@PathVariable Long id) {
        return this.restTemplate.getForObject("http://localhost:8000/" + id, User.class);
      }
    }
    5 application.yml
    server:
      port: 8010
    6 测试
    展开全文
  • 第三篇 服务提供者和服务消费者

    千次阅读 2018-02-10 20:22:24
    一、服务提供者和服务消费者概念服务提供者:服务的被调用方(即:为其他服务提供服务的服务)服务消费者: 服务的调用方(即: 依赖其他服务的服务)二、编写一个服务提供者 (自动生成框架:...lt;...
  • Laravel:服务提供者

    千次阅读 2019-05-29 17:33:32
    事实上,Laravel 有好几十个服务提供者,用于管理框架核心组件的容器绑定。几乎框架里每一个组件的容器绑定都是靠服务提供者来完成的。你可以在config/app.php这个配置文件里查看项目目前有哪些服务提供者(从 ...
  • (新手问题)如题,网上看过部分SpringCloud的文章都提到了将一个微服务注入到Eureka中,然后服务消费者使用Feign或rest+ribbon调用服务提供者的具体接口进行消费。 但是其中有一个比较关键的问题好像都没有提到...
  • laravel 注册服务提供者

    千次阅读 2018-12-15 17:25:02
    laravel所有的服务提供者都是通过配置文件,config/app.php中进行注册,该文件包含了一个列出所有服务提供者名字的provider数组。 如果要注册你自己的服务提供者,只需往数组里追加到该数组: 'providers' =&amp...
  • 文章目录Nacos服务注册与发现-实现服务提供者于消费者框架版本介绍编写服务提供者引入依赖修改配置文件编写Controller编写服务消费者引入依赖修改配置文件声明RestTemplate编写Controller测试代码地址 框架版本 ...
  • Eureka 服务提供者与消费者

    千次阅读 2018-07-04 11:08:00
    我们需要实现服务提供者(Provider)与服务调用者(Consumer) 服务提供者 1:修改pom.xml文件,引入依赖包,代码如下: &lt;dependencyManagement&gt; &lt;dependencies&gt; &lt;depende...
  • Eureka的高可用以及服务提供者、服务消费者集群之间的调用方式 1.为什么要进行Eureka的集群 2.搭建eureka集群 3.服务提供者注册到高可用eureka上 4.服务提供者集群状态 5.服务消费者消费 6.综上 上文我们...
  • 在分布式系统中基本没有绝对的服务提供者也没有绝对的服务消费者,即便有那也是极少极少的情况。什么时候会出现这种情况呢?比如说一个分布式系统中有一个日志处理的子系统,那么好了这个子系统基本上就是一个服务的...
  • 服务提供者:被其他微服务调用的微服务2.服务消费者:调用的其他微服务的微服务二、服务提供者首先打开http://start.spring.io,如下图所示,如下图,创建报名,项目名最后点击下方的“Generate Project”按钮, 将...
  • 文章目录三、Spring Cloud的配置 之 服务提供者 配置1、创建2、服务的提供者的相关配置2.1 pom依赖配置2.2 pom依赖的导入2.3 配置文件的引入2.4 创建Controller类2.4.1 创建文件夹2.4.2 创建HelloController类2.5 ...
  • 在开始学习使用SpringCloud进行开发之前,我们先来了解一下什么是“服务提供者”和“服务消费者”,然后分别编写一个简单的“服务提供者”和“服务消费者”。 一、概念 我们拿第一篇博文《【Spring Cloud总结】1....
  • 一 架构图二 服务提供者1 服务注册“服务提供者”在启动的时候会通过REST请求的方式将自己注册到Eureka Server上,同时带上自身服务的一些元数据信息。Eureka Server接收到这个REST请求之后,将元数据信息存储在...
  • 在微服务中最基本最基本的两个角色是服务提供者与服务消费者。 之前所有代码都在同一个框架的时候,比如Controller调用Service的,直接注入Service bean即可进行调用了。现在做成微服务之后,那么我们就需要有一个...
  •  什么是服务提供者和服务消费者?  服务提供者:是指服务的被调用方(即:为其它服务提供服务的服务)  服务消费者:是指服务的调用方(即:依赖其它服务的服务) 二、编写服务提供者  首先,我们需要访问...
  • 这篇来讲一下如何创建并向Eureka Server集群注册一个或多个服务提供者、服务消费者。服务消费端这是我们开发环境中的目录结构我们需要的maven的依赖:&lt;dependencies&gt; &lt;dependency&gt; ...
  • 服务容器我也还不太会,只是知道该怎么使用,所以没有进行讲解,这里的重点就是如何注册自定义的服务提供者以及设置调用时间。
  • 服务提供者:被其他微服务的调用的微服务。 服务消费者:调用其他服务的微服务。 如图所示: 在上图中:电影微服务需要去调用用户信息 并做相关的操作(例如把这张票记入用户已经购买的数据中) 在这里 电影微服务...
  • 一、服务是平级的图中是一些服务的提供者和服务的管理...二、服务管理者和服务提供者的划分Service和AbstractService提供了服务提供者自动注入服务管理者的机制。通过服务管理者能获得任何的服务提供者,而通过服务提供
  • 2、dubbo通过Spring加载配置文件后,是如何触发注册中心、服务提供者、服务消费者按照Dubbo的设计执行相关的功能。 所谓的执行相关功能如下: 1)注册中心启动,监听消息提供者的注册服务、接收消息消费者的服务...
  • 其中一个可能的原因是linux服务器上这个提供者服务本身的端口,被linux防火墙...在centos7上这样开放端口,假设服务提供者本身的端口为20880 firewall-cmd --add-port=20880/tcp 然后服务消费者可以调用此服务成功。
  • Eureka的高可用以及服务提供者、服务消费者集群之间的调用方式 1.为什么要进行Eureka的集群 2.搭建eureka集群 3.服务提供者注册到高可用eureka上 4.服务提供者集群状态 5.服务消费者消费 6....
  • 服务提供者(provider)与服务消费者(ribbon版本)-微服务架构 冬天手冷,能少写一句代码,就少写一句代码了,服务注册中心,还是用上一篇文章的注册中心,我这里重新搭建一个服务提供者,和服务消费者即可(哦,忘了点...
  • 服务提供者暴露一个服务的详细过程: 上图是服务提供者暴露服务的主过程: 首先ServiceConfig类拿到对外提供服务的实际类ref,然后将ProxyFactory类的getInvoker方法使用ref生成一个AbstractProxyInvoker实例,到...
  • 微服务Spring Cloud | 2.1 创建一个服务提供者和消费者 一、 概念 服务提供者:是指服务的被调用方(即:为其它服务提供服务的服务) 服务消费者:是指服务的调用方(即:依赖其它服务的服务) 二、 业务...
  • dubbo的服务提供者在tomcat启动失败的问题处理

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 55,756
精华内容 22,302
关键字:

服务提供者