精华内容
下载资源
问答
  • 微服务框架搭建

    2019-02-26 14:15:49
    参考地址:https://blog.csdn.net/forezp/article/details/81040925
    展开全文
  • spring cloud 学习微服务框架搭建 https://blog.csdn.net/hellozpc/article/details/83692496转载

    spring cloud 学习微服务框架搭建

    https://blog.csdn.net/hellozpc/article/details/83692496转载

    展开全文
  • SpringCloud微服务框架搭建 一、微服务架构 1.1什么是分布式 不同模块部署在不同服务器上 作用:分布式解决网站高并发带来问题 1.2什么是集群 多台服务器部署相同应用构成一个集群 作用:通过负载均衡设备...

    SpringCloud微服务框架搭建

    一、微服务架构

    1.1什么是分布式

    不同模块部署在不同服务器上
    作用:分布式解决网站高并发带来问题
    

    1.2什么是集群

    多台服务器部署相同应用构成一个集群
    作用:通过负载均衡设备共同对外提供服务
    

    1.3什么是RPC

    RPC 的全称是 Remote Procedure Call 是一种进程间通信方式。
    它允许程序调用另一个地址空间(通常是共享网络的另一台机器上)的过程或函数,而不用程序员显式编码这个远程调用的细节。即无论是调用本地接口/服务的还是远程的接口/服务,本质上编写的调用代码基本相同。
    比如两台服务器A,B,一个应用部署在A服务器上,想要调用B服务器上应用提供的函数或者方法,由于不在一个内存空间,不能直接调用,这时候需要通过就可以应用RPC框架的实现来解决
    

    1.3.1restful、soap、rpc

    (1)RESTful是一种架构设计风格,提供了设计原则和约束条件,而不是架构。而满足这些约束条件和原则的应用程序或设计就是 RESTful架构或服务。
    (2)SOAP,简单对象访问协议是一种数据交换协议规范,
    是一种轻量的、简单的、基于XML的协议的规范。SOAP协议和HTTP协议一样,都是底层的通信协议,只是请求包的格式不同而已,SOAP包是XML格式的。
    SOAP的消息是基于xml并封装成了符合http协议,因此,它符合任何路由器、 防火墙或代理服务器的要求。
    soap可以使用任何语言来完成,只要发送正确的soap请求即可,基于soap的服务可以在任何平台无需修改即可正常使用。
    (3)RPC就是从一台机器(客户端)上通过参数传递的方式调用另一台机器(服务器)上的一个函数或方法(可以统称为服务)并得到返回的结果。
    RPC 会隐藏底层的通讯细节(不需要直接处理Socket通讯或Http通讯)
    RPC 是一个请求响应模型。客户端发起请求,服务器返回响应(类似于Http的工作方式)
    RPC 在使用形式上像调用本地函数(或方法)一样去调用远程的函数(或方法)。
    1.3.2rpc远程调用框架
    几种比较典型的RPC的实现和调用框架。 
    (1)RMI实现,利用java.rmi包实现,基于Java远程方法协议(Java Remote Method Protocol) 
    和java的原生序列化。 
    (2)Hessian,是一个轻量级的remoting onhttp工具,使用简单的方法提供了RMI的功能。 基于HTTP协议,采用二进制编解码。 
    (3)thrift是一种可伸缩的跨语言服务的软件框架。thrift允许你定义一个描述文件,描述数据类型和服务接口。依据该文件,编译器方便地生成RPC客户端和服务器通信代码。
    (4)SpringCloud 为开发人员提供了快速构建分布式系统的一些工具,包括配置管理、服务发现、断路器、路由、微代理、事件总线、全局锁、决策竞选、分布式会话等等。
    

    1.4什么是SOA

    业务系统分解为多个组件,让每个组件都独立提供离散,自治,可复用的服务能力
    通过服务的组合和编排来实现上层的业务流程
    作用:简化维护,降低整体风险,伸缩灵活
    

    1.5什么是微服务

    架构设计概念,各服务间隔离(分布式也是隔离),自治(分布式依赖整体组合)其它特性(单一职责,边界,异步通信,独立部署)是分布式概念的跟严格执行
     SOA到微服务架构的演进过程
     作用:各服务可独立应用,组合服务也可系统应用(巨石应用[monolith]的简化实现策略-平台思想)
    

    1.6使用RPC http技术实现会员与订单系统通讯

    二、微服务架构

    三、SpringCloud

    SpringCloud 为开发人员提供了快速构建分布式系统的一些工具,包括配置管理、服务发现、断路器、路由、微代理、事件总线、全局锁、决策竞选、分布式会话等等。它运行环境简单,可以在开发人员的电脑上跑。
    

    四、服务提供者与消费关系

    服务提供者:提供服务被人调用
    消费者:调用被人服务

    五、服务的注册与发现(Eureka )

    在这里,我们需要用的的组件上Spring Cloud Netflix的Eureka ,eureka是一个服务注册和发现模块。
    4.1 服务注册
    4.1.1创建eurekaserver 项目
    4.1.2引入maven依赖
    以上都是概念。


    image.png

    image.png

     

    以上是我的springcloud项目,eureka是注册中心,zuul是注册网关,ribbon和feign都是cloud的rpc远程调用。
    zuul主要是用来配置网关

    <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>1.5.2.RELEASE</version>
            <relativePath /> <!-- lookup parent from repository -->
        </parent>
        <properties>
            <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
            <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
            <java.version>1.8</java.version>
        </properties>
    
        <dependencies>
            <!--eureka server -->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-eureka-server</artifactId>
            </dependency>
            <!-- spring boot test -->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
            </dependency>
        </dependencies>
        <dependencyManagement>
            <dependencies>
                <dependency>
                    <groupId>org.springframework.cloud</groupId>
                    <artifactId>spring-cloud-dependencies</artifactId>
                    <version>Dalston.RC1</version>
                    <type>pom</type>
                    <scope>import</scope>
                </dependency>
            </dependencies>
        </dependencyManagement>
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
            </plugins>
        </build>
        <repositories>
            <repository>
                <id>spring-milestones</id>
                <name>Spring Milestones</name>
                <url>https://repo.spring.io/milestone</url>
                <snapshots>
                    <enabled>false</enabled>
                </snapshots>
            </repository>
        </repositories>
    

    4.3配置application.yml

    server:
      port: 8761
    eureka:
      instance:
        hostname: localhost
      client:
        registerWithEureka: false
        fetchRegistry: false
        serviceUrl:
          defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/
    

    4.4启动EurekaServer

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

    1.eureka.client.registerWithEureka=true #是否将自身注册
    2.eureka.client.fetchRegistry=false #如果为true,启动时报警.
    4.5打开eureka server 界面的

    image.png

    image.png


    4.2 服务提供者
    创建一个服务提供者 (eureka client),当client向server注册时,它会提供一些元数据,例如主机和端口,URL,主页等。Eureka server 从每个client实例接收心跳消息。 如果心跳超时,则通常将该实例从注册server中删除。

     

    4.2.1 创建项目eurekaclient
    4.2.2 引入maven依赖

    <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>1.5.2.RELEASE</version>
            <relativePath /> <!-- lookup parent from repository -->
        </parent>
        <properties>
            <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
            <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
            <java.version>1.8</java.version>
        </properties>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-eureka</artifactId>
            </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>
        </dependencies>
        <dependencyManagement>
            <dependencies>
                <dependency>
                    <groupId>org.springframework.cloud</groupId>
                    <artifactId>spring-cloud-dependencies</artifactId>
                    <version>Dalston.RC1</version>
                    <type>pom</type>
                    <scope>import</scope>
                </dependency>
            </dependencies>
        </dependencyManagement>
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
            </plugins>
        </build>
        <repositories>
            <repository>
                <id>spring-milestones</id>
                <name>Spring Milestones</name>
                <url>https://repo.spring.io/milestone</url>
                <snapshots>
                    <enabled>false</enabled>
                </snapshots>
            </repository>
        </repositories>
    

    4.2.3 application.yml配置

    eureka:
      client:
        serviceUrl:
          defaultZone: http://localhost:8761/eureka/
    server:
      port: 8762
    spring:
      application:
        name: service-hi
    

    4.2.4 发布服务
    通过注解@EnableEurekaClient 表明自己是一个eurekaclient.

    @SpringBootApplication
    @EnableEurekaClient
    @RestController
    public class ServiceHiApplication {
    
        public static void main(String[] args) {
            SpringApplication.run(ServiceHiApplication.class, args);
        }
    
        @Value("${server.port}")
        String port;
    
        @RequestMapping("/hi")
        public String home(@RequestParam String name) {
            return "hi " + name + ",i am from port:" + port;
        }
    
    }
    

    4.2.5演示效果

    需要指明spring.application.name,这个很重要,这在以后的服务与服务之间相互调用一般都是根据这个name 。 启动工程,打开http://localhost:8761 ,即eureka server 的网址:

    image.png

    image.png


    你会发现一个服务已经注册在服务中了,服务名为SERVICE-HI ,端口为7862
    这时打开 http://localhost:8762/hi?name=forezp ,你会在浏览器上看到 :
    hi forezp,i am from port:8762

     

    一、 服务消费者(Feign)

    什么是Feign
    Feign是一个声明式的伪Http客户端,它使得写Http客户端变得更简单。使用Feign,只需要创建一个接口并注解。
    它具有可插拔的注解特性,可使用Feign 注解和JAX-RS注解。Feign支持可插拔的编码器和解码器。
    Feign默认集成了Ribbon,并和Eureka结合,默认实现了负载均衡的效果。
    简而言之:
    Feign 采用的是基于接口的注解
    Feign 整合了ribbon
     准备工作
    继续用上一节的工程, 启动eureka-server,端口为8761; 启动service-hi 两次,端口分别为8762 、8773.
     准备工创建一个feign的服务
    新建一个spring-boot工程,取名为serice-feign,在它的pom文件引入Feign的起步依赖spring-cloud-starter-feign、Eureka的起步依赖
    spring-cloud-starter-eureka、Web的起步依赖spring-boot-starter-web,代码如下:
    
    <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>1.5.2.RELEASE</version>
            <relativePath/> <!-- lookup parent from repository -->
        </parent>
    
        <properties>
            <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
            <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
            <java.version>1.8</java.version>
        </properties>
    
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-eureka</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-feign</artifactId>
            </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>
        </dependencies>
    
        <dependencyManagement>
            <dependencies>
                <dependency>
                    <groupId>org.springframework.cloud</groupId>
                    <artifactId>spring-cloud-dependencies</artifactId>
                    <version>Dalston.RC1</version>
                    <type>pom</type>
                    <scope>import</scope>
                </dependency>
            </dependencies>
        </dependencyManagement>
    
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
            </plugins>
        </build>
    
        <repositories>
            <repository>
                <id>spring-milestones</id>
                <name>Spring Milestones</name>
                <url>https://repo.spring.io/milestone</url>
                <snapshots>
                    <enabled>false</enabled>
                </snapshots>
            </repository>
        </repositories>
    

    application.yml配置
    在工程的配置文件application.yml文件,指定程序名为service-feign,端口号为8765,服务注册地址为http://localhost:8761/eureka/ ,代码如下:

    eureka:
      client:
        serviceUrl:
          defaultZone: http://localhost:8761/eureka/
    server:
      port: 8765
    spring:
      application:
        name: service-feign
    

    定义一个feign接口

    @FeignClient(value = "service-hi")
    public interface SchedualServiceHi {
        @RequestMapping(value = "/hi", method = RequestMethod.GET)
        String sayHiFromClientOne(@RequestParam(value = "name") String name);
    }
    

    一个”/hi”的API接口

    @RestController
    public class HiController {
        @Autowired
        SchedualServiceHi schedualServiceHi;
        @RequestMapping(value = "/hi",method = RequestMethod.GET)
        public String sayHi(@RequestParam String name){
            return schedualServiceHi.sayHiFromClientOne(name);
        }
    }
    

    启动方式

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

    演示效果

    启动程序,多次访问http://localhost:8765/hi?name=forezp(http://localhost:8765/hi?name=forezp),浏览器交替显示:
    
    hi forezp,i am from port:8762
    
    hi forezp,i am from port:8763
    
    

    Hystrix断路器

    在微服务架构中,根据业务来拆分成一个个的服务,服务与服务之间可以相互调用(RPC),在Spring Cloud可以用RestTemplate+Ribbon和Feign来调用。为了保证其高可用,单个服务通常会集群部署。由于网络原因或者自身的原因,服务并不能保证100%可用,如果单个服务出现问题,调用这个服务就会出现线程阻塞,此时若有大量的请求涌入,Servlet容器的线程资源会被消耗完毕,导致服务瘫痪。服务与服务之间的依赖性,故障会传播,会对整个微服务系统造成灾难性的严重后果,这就是服务故障的“雪崩”效应。
    为了解决这个问题,业界提出了断路器模型。
    7.1 什么是Hystrix
    Netflix开源了Hystrix组件,实现了断路器模式,SpringCloud对这一组件进行了整合。 在微服务架构中,一个请求需要调用多个服务是非常常见的,如下图:


    image.png

    image.png

     

    较底层的服务如果出现故障,会导致连锁故障。当对特定的服务的调用的不可用达到一个阀值(Hystric 是5秒20次) 断路器将会被打开。


    image.png

    image.png

    断路打开后,可用避免连锁故障,fallback方法可以直接返回一个固定值。

    准备工作

    这篇文章基于上一篇文章的工程,首先启动上一篇文章的工程,启动eureka-server 工程;启动service-hi工程,它的端口为8762。
    在ribbon使用断路器
    改造serice-ribbon 工程的代码,首先在pox.xml文件中加入spring-cloud-starter-hystrix的起步依赖:

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

    改造service
    改造HelloService类,在hiService方法上加上@HystrixCommand注解。该注解对该方法创建了熔断器的功能,并指定了fallbackMethod熔断方法,熔断方法直接返回了一个字符串,字符串为”hi,”+name+”,sorry,error!”,代码如下:

    @Service
    public class HelloService {
    
        @Autowired
        RestTemplate restTemplate;
    
        @HystrixCommand(fallbackMethod = "hiError")
        public String hiService(String name) {
            return restTemplate.getForObject("http://SERVICE-HI/hi?name=" + name, String.class);
        }
    
        public String hiError(String name) {
            return "hi," + name + ",sorry,error!";
        }
    }
    

    在启动类上加入

    @SpringBootApplication
    @EnableEurekaClient
    @EnableHystrix   //断路器
    public class App {
    
        public static void main(String[] args) {
            SpringApplication.run(App.class, args);
        }
    
        @Bean
        @LoadBalanced
        RestTemplate restTemplate() {
            return new RestTemplate();
        }
    
    }
    

    演示效果

    image.png

    展开全文
  • 微服务框架搭建个人总结(避坑专用)搭建springcloud微服务框架(基础)踩坑记录搭建框架Eureka服务注册中心Gateway网关路由配置Feign服务通信Hystrix 熔断配置重试配置 搭建springcloud微服务框架(基础) 你好! ...

    搭建springcloud微服务框架(基础)

    你好! 这篇文章对于你搭建springcloud框架避坑可能会有帮助,转载请附加说明。

    踩坑记录

    • 把遇到的bug放在前面,希望你们创建的时候多注意一点
      1、集成spring-cloud-gateway 启动报以下错误:
    No qualifying bean of type 'org.springframework.core.convert.ConversionService' available
    

    原因是因为我们在网关中引入了web依赖,去掉即可。
    2、集成feign的时候启动报错:

    Service id not legal hostname
    

    原因是因为:一是路径配置的原因。@FeignClient(name= “/eureka_client”)这个注解配置的是服务名,不用加/。二是因为服务名的原因,feign不支持”_“,需要改成”–“。所以项目刚开始创建就得注意起名。

    搭建框架

    我们使用idea来搭建springcloud框架。

    • 搭建父框架选用maven
      搭建父框架选用maven
      在这里插入图片描述
      在这里插入图片描述
    • 创建成功记得设置jdk和maven。然后把src文件夹删除。
    • 接着创建module,在父模块上新建module
    • 先创建注册中心Eureka模块

    Eureka服务注册中心

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    • 这儿springboot版本可以不关注,因为版本会在父pom里统一配置

    在这里插入图片描述

    • 然后下一步,然后完成finish。我们把没用的文件删除。留下src和pom,对应pom里面的test依赖也用不到了,可以删除,之后的module创建都警醒该操作。
      在这里插入图片描述
      在这里插入图片描述
    • 进行pom操作,先上父pom的,springboot的版本可以自己选择,但是一定要注意和cloud版本的匹配问题。我这儿用的2.1.5的boot版本,对应cloud版本是Greenwich.SR2
    <groupId>com.test.springcloud</groupId>
        <artifactId>muck-up</artifactId>
        <version>1.0-SNAPSHOT</version>
    
        <modules>
            <module>muck-eureka</module>
        </modules>
        
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.1.5.RELEASE</version>
            <relativePath />
        </parent>
        <properties>
            <org.apache.shiro.version>1.4.0</org.apache.shiro.version>
            <mysql-connector.version>5.1.35</mysql-connector.version>
            <mybatis-spring-boot.version>1.3.2</mybatis-spring-boot.version>
            <lombok.version>1.18.10</lombok.version>
        </properties>
    
    
        <dependencyManagement>
            <dependencies>
    
    
                <!-- cloud -->
                <dependency>
                    <groupId>org.springframework.cloud</groupId>
                    <artifactId>spring-cloud-dependencies</artifactId>
                    <version>Greenwich.SR2</version>
                    <type>pom</type>
                    <scope>import</scope>
                </dependency>
                <!-- shiro -->
                <dependency>
                    <groupId>org.apache.shiro</groupId>
                    <artifactId>shiro-core</artifactId>
                    <version>${org.apache.shiro.version}</version>
                </dependency>
                <!--mysql驱动包-->
                <dependency>
                    <groupId>mysql</groupId>
                    <artifactId>mysql-connector-java</artifactId>
                    <version>${mysql-connector.version}</version>
                </dependency>
                <!-- mybatis支持 -->
                <dependency>
                    <groupId>org.mybatis.spring.boot</groupId>
                    <artifactId>mybatis-spring-boot-starter</artifactId>
                    <version>${mybatis-spring-boot.version}</version>
                </dependency>
                <!-- 配置文件小绿叶问题 -->
                <dependency>
                    <groupId>org.springframework.cloud</groupId>
                    <artifactId>spring-cloud-commons-dependencies</artifactId>
                    <version>Greenwich.SR2</version>
                </dependency>
                <!-- lombok -->
                <dependency>
                    <groupId>org.projectlombok</groupId>
                    <artifactId>lombok</artifactId>
                    <version>${lombok.version}</version>
                </dependency>
    
    
            </dependencies>
        </dependencyManagement>
    
    • 然后配置eureka模块的pom,注意parent一定要和父pom的对应
        <parent>
            <groupId>com.test.springcloud</groupId>
            <artifactId>muck-up</artifactId>
            <version>1.0-SNAPSHOT</version>
        </parent>
    
        <artifactId>muck-eureka</artifactId>
        <name>muck-eureka</name>
        <description>Demo project for Spring Boot</description>
    
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
            </dependency>
    
    
        </dependencies>
    
    • 在eureka启动类加上对应开启eureka服务的注解EnableEurekaServer,表示它是eureka服务。
      在这里插入图片描述
    • 配置文件修改,先创建bootstrap.yml文件。因为微服务优先加载。
      在这里插入图片描述
      在这里插入图片描述
    • 然后是bootstrap.yml中的配置
    server:
      port: 8761
    
    eureka:
      instance:
        prefer-ip-address: true
        #hostname: eureka.test.com #eureka服务端的实例名称
    
      server:
        enable-self-preservation: false # 中小规模下,自我保护模式坑比好处多,所以关闭它
        #renewal-threshold-update-interval-ms: 120000  ## 心跳阈值计算周期,如果开启自我保护模式,可以改一下这个配置
        eviction-interval-timer-in-ms: 5000 # 主动失效检测间隔,配置成5秒
        use-read-only-response-cache: false # 禁用readOnlyCacheMap
    
      client:
        register-with-eureka: false     #false表示不向注册中心注册自己。
        fetch-registry: false     #false表示自己端就是注册中心,我的职责就是维护服务实例,并不需要去检索服务
    
    
    • 然后启动服务。看到页面服务中心启动。没有服务。
      在这里插入图片描述

    Gateway网关

    • 然后集成网关中心选用的gateway,依然是创建module模块,起名为muck-gateway,记得在父pom的modules中添加对应模块名。需要注册在eureka注册中心。上pom
        <parent>
            <groupId>com.test.springcloud</groupId>
            <artifactId>muck-up</artifactId>
            <version>1.0-SNAPSHOT</version>
        </parent>
    
        <artifactId>muck-gateway</artifactId>
        <name>muck-gateway</name>
        <description>Demo project for Spring Boot</description>
    
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-gateway</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter</artifactId>
            </dependency>
    
        </dependencies>
    
    • 在启动类上加上euraka的注解EnableEurekaClient,注册到服务中心。这儿注意一个点,有的人注解用的是EnableDiscoveryClient,区别就是用EnableDiscoveryClient是启用服务注册发现功能,而EnableEurekaClient是启用eureka的注册发现。建议使用EnableEurekaClient。
      在这里插入图片描述
    • 然后是配置文件,创建bootstrap.yml,不多说了,上配置
    server:
      port: 7001
    
    spring:
      application:
        name: muck-gateway
    
    #eureka配置
    eureka:
      instance:
        prefer-ip-address: true
        #hostname: eureka.test.com #eureka服务端的实例名称
        instance-id: ${spring.cloud.client.ip-address}:${server.port}
        lease-renewal-interval-in-seconds: 5  # 心跳间隔,5秒
        lease-expiration-duration-in-seconds: 10 # 没有心跳的淘汰时间,10秒
    
      client:
        register-with-eureka: true     #true表示向注册中心注册自己。
        registry-fetch-interval-seconds: 5 # 定时刷新本地缓存时间
        fetch-registry: true     #需要注册中心去检索服务
        service-url:
          defaultZone: http://${spring.cloud.client.ip-address}:8761/eureka/
    
    
    • 然后启动gateway网关,查看注册中心,注册成功。依照此流程可以创建多个模块。进行注册测试。

    路由配置

    • 我选用的是路径匹配路由,在gateway的pom配置文件中添加。
    spring:
      application:
        name: muck-gateway
      #路由配置(根据路径)
      cloud:
        loadbalancer:
          retry:
            enabled: true  # 开启重试机制,默认为关闭
        gateway:
          routes:
            #路由的ID,没有固定规则但要求唯一,建议配合服务名
            - id: muck-gateway
              #匹配后提供服务的路由地址
              uri: http://news.baidu.com
              predicates:
                #断言,路径相匹配的进行路由
                - Path= /guonei/**
    #          filters:
    #            - StripPrefix=1
    
    • 上面配置path是访问网关的匹配路径,uri是匹配后的跳转路径。id可以自己起名,但是要唯一,建议和服务名一样。然后启动服务器。访问:http://localhost:7001/guonei 如下界面:
      在这里插入图片描述
    • 对应如果你添加了其他模块,也可以进行配置,访问网关进行匹配分发请求
    spring:
      application:
        name: muck-gateway
      #路由配置(根据路径)
      cloud:
        loadbalancer:
          retry:
            enabled: true  # 开启重试机制,默认为关闭
        gateway:
          routes:
            #路由的ID,没有固定规则但要求唯一,建议配合服务名
            - id: muck-gateway
              #匹配后提供服务的路由地址
              uri: http://news.baidu.com
              predicates:
                #断言,路径相匹配的进行路由
                - Path= /guonei/**
    #          filters:
    #            - StripPrefix=1
    
            - id: muck-user
              #匹配后提供服务的路由地址
              uri: http://${spring.cloud.client.ip-address}:7002
              predicates:
                #断言,路径相匹配的进行路由
                - Path= /muck-user/**
             
            - id: muck-auth
              #匹配后提供服务的路由地址
              uri: http://${spring.cloud.client.ip-address}:7003
              predicates:
                #断言,路径相匹配的进行路由
                - Path= /muck-auth/**
    

    Feign服务通信

    • 一个服务调用另一个服务的方法,可以采用Feign,它对加了注解FeignClient的类创建代理,如果该服务通过FeignClient注解的类访问的话,会从服务中心eureka获取对应注解中的服务名,然后访问对应方法的路径。
    • 首先在访问端微服务引入pom,启动类加注解。
    <!-- openfeign服务调用 -->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-openfeign</artifactId>
            </dependency>
    

    在这里插入图片描述

    • 然后创建一个访问接口类,用于定义要访问的接口。注意这里FeignClient的value值是注册服务上对应的名字。fallback 的是如果接口访问超时或者发生错误的回滚方法,对应得开启配置文件中的断路器。GetMapping中的路径也可以添加context-path中设置的路径。路径一定要注意,否则会出现404的问题。
    /**
     * @author lyl
     * @create 2021-04-23 11:54
     * @description
     * @FeignClient("生产者实例名") 指定生产者实例名称,在生产者的配置文件中,加上该注解表示其他服务可以
     */
    @FeignClient(value = "muck-auth",fallback = UserFeignClientFallback.class)
    public interface UserClient {
    
        @GetMapping("/muck-auth/auth/getByUserPrint")
        public String getByAuth();
    
    }
    
    
    /**
     * @author lyl
     * @create 2021-04-25 11:57
     * @description 功能描述
     */
    @Component
    public class UserFeignClientFallback implements UserClient {
    
        @Override
        public String getByAuth() {
            return "调用auth异常!";
        }
    }
    
    
    • 配置文件,请求超时时间设置5秒,在接口中打断点5秒不放可以测试fallback方法。注意日志配置一定要加上,这样可以有效的查看你访问的路径,解决因为路径不正确导致的调用不同。
    • connectTimeout连接和读取超时也要配置大点,不然会报错,feign默认1秒
    server:
      port: 7002
      servlet:
        context-path: /muck-user
    spring:
      application:
        name: muck-user
    
    #eureka配置
    eureka:
      instance:
        prefer-ip-address: true
        #hostname: eureka.test.com #eureka服务端的实例名称
        instance-id: ${spring.cloud.client.ip-address}:${server.port}
        lease-renewal-interval-in-seconds: 5  # 心跳间隔,5秒
        lease-expiration-duration-in-seconds: 10 # 没有心跳的淘汰时间,10秒
    
      client:
        register-with-eureka: true     # true表示向注册中心注册自己。
        registry-fetch-interval-seconds: 5 # 定时刷新本地缓存时间
        fetch-registry: true     # 需要注册中心去检索服务
        service-url:
          defaultZone: http://${spring.cloud.client.ip-address}:8761/eureka/
    
    #服务调用配置 feigh自带断路器hystrix
    feign:
      httpclient:
        connection-timeout: 5000 #请求服务超时时间
      client:
        config:
          default:
            connectTimeout: 50000 # 连接超时时间
            readTimeout: 50000   # 读超时时间
      hystrix:
        enabled: true   #打开断路器
    
    #日志
    logging:
      level:
        com.test.auth.service.AuthClient: debug
    
    • 最后要保证不访问的接口存在,路径正确。
    @RestController
    @RequestMapping("/auth")
    public class AuthController {
    
        @Autowired
        AuthClient authClient;
    
        @GetMapping("/getPrint")
        public  Object getPrint() {
            System.out.println("auth-------------------------------11"+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
            System.out.println("auth-------------------------------22"+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
            return "auth----------";
        }
    
        @GetMapping("/getByUserPrint")
        public  String getByUserPrint() {
            System.out.println("auth-------------------------------11"+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
            System.out.println("auth-------------------------------22"+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
            return "feign调用auth成功!";
        }
    }
    

    Hystrix 熔断配置

    • 在网关中进行熔断配置
    • pom中加依赖
    <!-- hystrix -->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
            </dependency>
    
    • 启动类加注解
    @SpringBootApplication
    @EnableEurekaClient
    @EnableHystrix //开启熔断器
    public class MuckGatewayApplication {
    
        public static void main(String[] args) {
            SpringApplication.run(MuckGatewayApplication.class, args);
        }
    
    }
    
    • 配置文件配置
    spring:
      application:
        name: muck-gateway
      #路由配置(根据路径)
      cloud:
        loadbalancer:
          retry:
            enabled: true  # 开启重试机制,默认为关闭
        gateway:
          routes:
            #路由的ID,没有固定规则但要求唯一,建议配合服务名
            - id: muck-gateway
              #匹配后提供服务的路由地址
              uri: http://news.baidu.com
              predicates:
                #断言,路径相匹配的进行路由
                - Path= /guonei/**
    #          filters:
    #            - StripPrefix=1
    
            - id: muck-user
              #匹配后提供服务的路由地址
              uri: http://${spring.cloud.client.ip-address}:7002
              predicates:
                #断言,路径相匹配的进行路由
                - Path= /muck-user/**
              filters:
                - name: Hystrix  # Hystrix Filter的名称、设置成默认的
                  args:  # Hystrix 配置参数
                    name: fallbackcmd   # HystrixCommand 的名字
                    fallbackUrl: forward:/fallback  # 熔断fallback对应的uri
    
            - id: muck-auth
              #匹配后提供服务的路由地址
              uri: http://${spring.cloud.client.ip-address}:7003
              predicates:
                #断言,路径相匹配的进行路由
                - Path= /muck-auth/**
          default-filters:
            - name: Hystrix
              args:
                name: fallbackcmd
                fallbackUri: forward:/default-error
    
    # Hystrix 配置
    hystrix:
      command:
        fallbackcmd: #对应user的Hystrix的name配置参数
          execution:
            isolation:
              thread:
                timeoutInMilliseconds: 5000 # Hystrix 的fallbackcmd 时间
      threadpool:
        default:
          coreSize: 100 # Hystrix 更改默认并发数配置(默认是10,这里改为100)
    
    • 对应的熔断回滚方法要定义好
    @RestController
    @RequestMapping
    public class HystrixFallbackConfiguration {
    
        @RequestMapping(value = "/fallback")
        public String fallBackController() {
            return "服务读取超时";
        }
    
        @RequestMapping("/default-error")
        public String DefaultErrorHandle(){
            return "这是通用错误处理返回的信息。";
        }
    }
    
    

    重试配置

    • gateway网关配置
    ribbon:
      ReadTimeout: 3000  #请求处理的超时时间(时间要小于Hystix的时间,否则没有重试就服务熔断了)
      ConnectTimeout: 3000 #请求连接的超时时间,默认时间为1秒
      OkToRetyrOnAllOperations: true #对所有操作都重试
      MaxAutoRetyiesNextServer: 1 #切换实例的重试次数
      MaxAutoRetries: 1 #对当前实例的重试次数
    
    展开全文
  • Spring Cloud微服务框架搭建 最近开始学习Spring Cloud,主要借助翟永超的《Spring Cloud微服务实战》,书中使用的版本是Spring Cloud为Brixton.SR5版本,Spring Boot 1.3.7。 当前Spring Cloud版本为Finchley RC1...
  • springCloud 微服务框架搭建入门

    万次阅读 2019-01-18 22:23:26
     服务注册与发现对于微服务系统来说非常重要。有了服务发现与注册,你就不需要整天改服务调用的配置文件了,你只需要使用服务的标识符,就可以访问到服务。 cloud-eureka-server:eureka注册服务器 cloud-simple-...
  • 适合微服务的初学者对微服务架构的搭建与设计。
  • 微服务框架 可采用集成.NET Core+Swagger+Consul+Polly+Ocelot+IdentityServer4+Exceptionless+Apollo Consul:实现分布式系统的服务发现与配置https://www.consul.io/ Polly:瞬态故障处理库NuGet>Install...
  • #微服务框架认证授权中心 项目采用spring cloud、oauth2、spring security # 依赖环境 JDK8、 Maven、 Mysql、 Redis 、nacos 注册中心采用阿里巴巴 nacos 缓存使用的是redis oauth2数据存储在数据库中 ...
  • @SpringCloud(Finchley.RELEASE版本)+SpringBoot(2.0.3.RELEASE)微服务框架搭建 eureka注册中心 由于项目需要,以及应对高并发建议搭建高可用注册中心,pow依赖以及配置文件如下: <dependencies> <...
  • JavaWeb_Cloud微服务平台是一款基于SpringCloud框架研发的分布式微服务框架,主要使用技术栈包括: SpringCloud、Vue、ElementUI、MybatisPlus,是一款精心打造的权限(RBAC)及内容管理系统,致力于做更简洁的后台...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,186
精华内容 1,274
关键字:

微服务框架搭建