SpringCloud入门

SpringCloud
1、    springcloud概述
SpringCloud是一种微服务架构，依赖于SpringBoot，主要用于服务治理（解耦），其中每一个服务都可以独立运行，服务之间没有依懒关系
2、    Eureka注册中心搭建
1、pom.xml配置
<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.2.RELEASE</version>
        <relativePath />
    </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</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-eureka-server</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>
2、application.properties配置
spring.application.name=spring-cloud-eureka
server.port=8000
eureka.client.register-with-eureka=false
eureka.client.fetch-registry=false
eureka.client.serviceUrl.defaultZone=http://localhost:${server.port}/eureka/
eureka.client.register-with-eureka ：表示是否将自己注册到Eureka Server，默认为true。
eureka.client.fetch-registry ：表示是否从Eureka Server获取注册信息，默认为true。
eureka.client.serviceUrl.defaultZone ：服务注册中心的配置内容，指定服务注册中心的位置。默认是http://localhost:8761/eureka ；多个地址可使用 , 分隔。
3、服务启动
@SpringBootApplication
@EnableEurekaServer
public class EurekaApp {
    public static void main(String[] args) {
        SpringApplication.run(EurekaApp.class, args);
    }
}
@EnableEurekaServer：启动一个服务注册中心提供给其他服务进行注册
@SpringBootApplication：扫描当前包及其子包下的带有@Component，@Controller，@Service，@Repository注解的类，并纳入spring容器进行管理配置
4、Eureka集群
1、application.properties配置
application.properties:
spring:
  application:
    name: spring-cloud-eureka
  profiles:
    active: peer1
application-peer1.properties:

spring.profiles=peer1
server.port=8000
eureka.client.serviceUrl.defaultZone=http://peer2:8001/eureka/, http://peer3:8002/eureka/
application-peer2.properties:
spring.profiles=peer2
server.port=8001
eureka.client.serviceUrl.defaultZone=http://peer1:8000/eureka/, http://peer3:8002/eureka/
application-peer3.properties:
spring.profiles=peer3
server.port=8002
eureka.client.serviceUrl.defaultZone=http://peer1:8000/eureka/, http://peer2:8001/eureka/
2、在C:\Windows\System32\drivers\etc下的hosts文件中加入
127.0.0.1  peer1
127.0.0.1  peer2
127.0.0.1  peer3
3、打包
--->maven build …--->clean package
4、依次启动
java -jar E:\java\spring-cloud-eureka\target\spring-cloud-eureka-0.0.1-SNAPSHOT.jar --spring.profiles.active=peer1
java -jar E:\java\spring-cloud-eureka\target\spring-cloud-eureka-0.0.1-SNAPSHOT.jar --spring.profiles.active=peer2
java -jar E:\java\spring-cloud-eureka\target\spring-cloud-eureka-0.0.1-SNAPSHOT.jar --spring.profiles.active=peer3

3、服务提供者
1、pom.xml配置
<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.2.RELEASE</version>
        <relativePath />
    </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-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>
2、application.properties配置
spring.application.name=spring-cloud-provider
server.port=9000
eureka.client.serviceUrl.defaultZone=http://localhost:8000/eureka/
3、服务启动
@SpringBootApplication
@EnableEurekaClient
public class ProviderApp {
    public static void main(String[] args) {
        SpringApplication.run(ProviderApp.class, args);
    }
}
@EnableDiscoveryClient：启用服务注册与发现
@EnableEurekaClient：启用服务注册与发现
4、controller
@RestController
public class ProviderController {
    @RequestMapping("/provider")
    public String proindex(@RequestParam String name) {
        return "hello "+name+"，this is first provider messge";
    }
}

4、服务消费者
1、pom.xml配置
<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.2.RELEASE</version>
        <relativePath />
    </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-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-feign</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-hystrix</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-hystrix-dashboard</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </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>
2、application.properties配置
spring.application.name=spring-cloud-consumer
server.port=9100
eureka.client.serviceUrl.defaultZone=http://localhost:8000/eureka/

3、服务启动
1、rest启动
@SpringBootApplication
@EnableEurekaClient
public class ConsumerApp {
    public static void main(String[] args) {
        SpringApplication.run(ConsumerApp.class, args);
    }
}

2、feign启动
@SpringBootApplication
@EnableEurekaClient
@EnableFeignClients
public class Consumer1App {
    public static void main(String[] args) {
        SpringApplication.run(Consumer1App.class, args);
    }
}
@EnableFeignClients：启用feign进行远程调用
4、rest调用
1、controller
@RestController
public class ConsumerController {
    @Autowired
    private ConsumerService cs;
    @RequestMapping("/consumer")
    public String conindex() {
        return cs.getConsumer();
    }
}
2、service
@Service
public class ConsumerService {
    @Autowired
    private RestTemplate rt;

public String getConsumer() {
        return rt.getForObject("http://spring-cloud-provider/provider",String.class);
    }
}

5、feign调用
1、controller
@RestController
public class Consumer1Controller {
    @Autowired
    HelloRemote helloRemote;
    @RequestMapping("/consumer1/{name}")
    public String index(@PathVariable("name") String name) {
        return helloRemote.index(name);
    }
}
2、service
@FeignClient(name="spring-cloud-provider1")
public interface HelloRemote {
    @RequestMapping("/provider1")
    public String index(@RequestParam(value = "name") String name);
}
@FeignClient：指定要绑定的远程调用的服务，参数为服务的名字
@RequestMapping为调用的提供者方法的映射名
在SpringMVC中@RequestParam和@RequestHeader注解，如果我们不指定value，则默认采用参数的名字作为其value，但是在Feign中，这个value必须明确指定，否则会报错。
5、hystrix
1、配置文件
feign.hystrix.enabled=true
2、客户端调用
@FeignClient(name="spring-cloud-provider",fallback=FallbackRemote.class)
public interface HelloRemote {
    @RequestMapping(value = "/hello1", method = RequestMethod.GET)
    String hello(@RequestParam("name") String name);
    @RequestMapping(value = "/hello2", method = RequestMethod.GET)
    User hello(@RequestHeader("name") String name, @RequestHeader("age") Integer age);
    @RequestMapping(value = "/hello3", method = RequestMethod.POST)
    String hello(@RequestBody User user);
}
3、启动类
@EnableCircuitBreaker
@EnableHystrixDashboard（开启监控）
6、zuul网关
1、pom文件配置
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-zuul</artifactId>
</dependency>
2、配置
eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8000/eureka/
server:
  port: 9400
spring:
  application:
    name: zuul
zuul:
  routes:
    api-a:
      path: /provider/**
      service-id: spring-cloud-provider
    api-b:
      path: /consumer/**
      service-id: spring-cloud-consumer
1、zuul默认配置
spring cloud zuul已经帮我们做了默认配置。默认情况下，Zuul会代理所有注册到Eureka Server的微服务，并且Zuul的路由规则如下：
http://ZUUL_HOST:ZUUL_PORT/微服务在Eureka上的serviceId/**
会被转发到serviceId对应的微服务
2、zuul熔断
Zuul 目前只支持服务级别的熔断，不支持具体到某个URL进行熔断。

3、启动类
@EnableZuulProxy
@EnableEurekaClient
@SpringBootApplication
public class AppZull {
     public static void main(String[] args) {
        SpringApplication.run(AppZull.class, args);
    }
}
4、zuul负载均衡
Zuul负载均衡是属于客户端的负载均衡
客户端负载均衡：
基于客户端的负载均衡，简单的说就是在客户端程序里面，自己设定一个调度算法，在向服务器发起请求的时候，先执行调度算法计算出向哪台服务器发起请求，然后再发起请求给服务器。
特点：
1.    由客户端内部程序实现，不需要额外的负载均衡器软硬件投入。
2.    程序内部需要解决业务服务器不可用的问题，服务器故障对应用程序的透明度小。
3.    程序内部需要解决业务服务器压力过载的问题。
使用场景：
1.    可以选择为初期简单的负载均衡方案，和DNS负载均衡一样。
2.    比较适合于客户端具有成熟的调度库函数，算法以及API等
3.    比较适合对服务器入流量较大的业务，如HTTP POST文件上传，FTP文件上传，Memcache大流量写入。
4.    可以结合其他负载均衡方案进行架构。
5、Zuul的核心Filter
1、概述
Filter是Zuul的核心，用来实现对外服务的控制。Filter的生命周期有4个，分别是“PRE”、“ROUTING”、“POST”、“ERROR”；
Zuul大部分功能都是通过过滤器来实现的，这些过滤器类型对应于请求的典型生命周期。
?    PRE： 这种过滤器在请求被路由之前调用。我们可利用这种过滤器实现身份验证、在集群中选择请求的微服务、记录调试信息等。
?    ROUTING：这种过滤器将请求路由到微服务。这种过滤器用于构建发送给微服务的请求，并使用Apache HttpClient或Netfilx Ribbon请求微服务。
?    POST：这种过滤器在路由到微服务以后执行。这种过滤器可用来为响应添加标准的HTTP Header、收集统计信息和指标、将响应从微服务发送给客户端等。
?    ERROR：在其他阶段发生错误时执行该过滤器。
除了默认的过滤器类型，Zuul还允许我们创建自定义的过滤器类型。例如，我们可以定制一种STATIC类型的过滤器，直接在Zuul中生成响应，而不将请求转发到后端的微服务。

2、Zuul中默认实现的Filter
类型    顺序    过滤器                   功能
pre         -3         ServletDetectionFilter         标记处理Servlet的类型
pre         -2         Servlet30WrapperFilter         包装HttpServletRequest请求
pre         -1         FormBodyWrapperFilter     包装请求体
route     1         DebugFilter                 标记调试标志
route     5         PreDecorationFilter         处理请求上下文供后续使用
route     10         RibbonRoutingFilter         serviceId请求转发
route     100     SimpleHostRoutingFilter url    请求转发
route     500     SendForwardFilter             forward请求转发
post     0         SendErrorFilter             处理有错误的请求响应
post     1000     SendResponseFilter         处理正常的请求响应
3、禁用指定的Filter
zuul:
    FormBodyWrapperFilter:
        pre:
            disable: true
4、自定义Filter
public class MyFilter extends ZuulFilter {
    @Override
    String filterType() {
        return "pre"; //定义filter的类型，有pre、route、post、error四种
    }
    @Override
    int filterOrder() {
        return 10; //定义filter的顺序，数字越小表示顺序越高，越先执行
    }
    @Override
    boolean shouldFilter() {
        return true; //表示是否需要执行该filter，true表示执行，false表示不执行
    }
    @Override
Object run() {
return null; //filter需要执行的具体操作
/*
RequestContext ctx = RequestContext.getCurrentContext();
        HttpServletRequest request = ctx.getRequest();
        log.info(String.format("%s >>> %s", request.getMethod(), request.getRequestURL().toString()));
        Object accessToken = request.getParameter("token");
        String refer=request.getHeader("refer");
    
        if (accessToken != null) {
            return null;
        }
        log.warn("token is empty");
        ctx.setSendZuulResponse(false);
        ctx.setResponseStatusCode(401);
        try {
            ctx.getResponse().getWriter().write("token is empty");
        } catch (Exception e) {
        }
        return null;
*/
    }
}
5、将TokenFilter加入到请求拦截队列，在启动类中添加代码：
@Bean
public TokenFilter tokenFilter() {
    return new TokenFilter();
}
7、config配置中心
1、config-server搭建
1、pom依赖
<dependency>
            <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-config-server</artifactId>
</dependency>
2、配置
spring.application.name=config-server
server.port=9200
spring.cloud.config.server.git.uri=https://gitee.com/archimedes123/config.git
spring.cloud.config.server.git.username=
spring.cloud.config.server.git.password=
eureka.client.serviceUrl.defaultZone=http://localhost:8000/eureka/
假设远程配置文件名为config-dev.properties
内容为：hello：hello im dev
它的application是config，profile是dev。client会根据填写的参数来选择读取对应的配置。
仓库中的配置文件会被转换成web接口，访问可以参照以下的规则：
1、/{application}/{profile}[/{label}]
2、/{application}-{profile}.*
3、/{label}/{application}-{profile}.*
3、启动类
@SpringBootApplication
@EnableConfigServer
@EnableEurekaClient
public class ConfigServerApp {
    public static void main(String[] args) {
        SpringApplication.run(ConfigServerApp.class, args);
    }
}
4、webhook机制检测更新配置（需要消息中间件支持rabbitMQ）
1、pom依赖
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-bus-amqp</artifactId>
</dependency>
2、配置文件
server:
  port: 8001
spring:
  application:
    name: spring-cloud-config-server
  cloud:
    config:
      server:
        git:
          uri: https://github.com/ityouknow/spring-cloud-starter/     
# 配置git仓库的地址
          search-paths: config-repo                             
# git仓库地址下的相对地址，可以配置多个，用,分割。
          username: username                                        
# git仓库的账号
          password: password                                   
 # git仓库的密码
  rabbitmq:
    host: 192.168.0.6
    port: 5672
    username: admin
    password: 123456
eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8000/eureka/   ## 注册中心eurka地址
management:
  security:
     enabled: false
2、config-client搭建
1、pom依赖
<dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-config</artifactId>
</dependency>
<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>
2、bootstrap.properties配置
spring.application.name=config-client
spring.cloud.config.name=config
spring.cloud.config.profile=dev
spring.cloud.config.label=master
server.port=9300
eureka.client.serviceUrl.defaultZone=http://localhost:8000/eureka/
spring.cloud.config.discovery.enabled=true
spring.cloud.config.discovery.serviceId=config-server
?    spring.cloud.config.name：对应{application}部分
?    spring.cloud.config.profile：对应{profile}部分
?    spring.cloud.config.label：对应git的分支。如果配置中心使用的是本地存储，则该参数无用
?    spring.cloud.config.uri：配置中心的具体地址
?    spring.cloud.config.discovery.service-id：指定配置中心的service-id，便于扩展为高可用配置集群。
特别注意：上面这些与spring-cloud相关的属性必须配置在bootstrap.properties中，config部分内容才能被正确加载。因为config的相关配置会先于application.properties，而bootstrap.properties的加载也是先于application.properties。
@RefreshScope：使用该注解的类，会在接到SpringCloud配置中心配置刷新的时候，自动将新的配置更新到该类对应的字段中。
3、启动类
@SpringBootApplication
@EnableEurekaClient
public class ConfigClientApp {
    public static void main(String[] args) {
        SpringApplication.run(ConfigClientApp.class, args);
    }
}
4、controller
@RestController
@RefreshScope//客户端启动配置中心自动更新
public class TestController {
    @Value("${hello}")
    private String hello;
    @RequestMapping("/getHello")
    public String getHello() {
        return this.hello;
    }
}
8、springcloud负载均衡
zuul也有负载均衡的功能，它是针对外部请求做负载，那客户端ribbon的负载均衡又是怎么一回事？
客户端ribbon的负载均衡，解决的是服务发起方（在Eureka注册的服务）对被调用的服务的负载，比如我们查询商品服务要调用显示库存和商品明细服务，通过商品服务的接口将两个服务组合，可以减少外部应用的请求，比如手机App发起一次请求即可，可以节省网络带宽，也更省电。
ribbon是对服务之间调用做负载，是服务之间的负载均衡，zuul是可以对外部请求做负载均衡。

原文地址：https://www.cnblogs.com/archimedes-euler/p/9975633.html

时间： 2024-10-30 08:36:57

SpringCloud入门的相关文章

SpringCloud 入门

1. 入门概述 SpringBoot专注于快速方便的开发单个个体微服务; SpringCloud:关注全局的微服务协调治理框架,它将SpringBoot开发的一个个单体微服务整合并管理起来, 为各个微服务之间提供配置管理,服务发现,断路器,路由,微代理,事件总线,全局锁,决策竞选,分布式会话等等集成服务; 1.1 Dubbo和SpringCloud比较 Dubbo服务调用方式:RPC SpringCloud服务调用方式:REST API 2. SpringCloud 之 Hello World

【SpringCloud】(1)---SpringCloud入门篇

SpringCloud理解篇 一.微服务概述 1.什么是微服务 目前的微服务并没有一个统一的标准,一般是以业务来划分将传统的一站式应用,拆分成一个个的服务,彻底去耦合,一个微服务就是单功能业务,只做一件事. 与微服务相对的叫巨石 . 2.微服务与微服务架构 微服务是一种架构模式或者一种架构风格,提倡将单一应用程序划分成一组小的服务==独立部署==,服务之间相互配合.相互协调,每个服务运行于自己的==进程==中. 服务与服务间采用轻量级通讯,如HTTP的RESTful API等 避免统一的.集中式

【SpringCloud】(2)---SpringCloud入门篇

SpringCloud理解篇 一.微服务概述 1.什么是微服务 目前的微服务并没有一个统一的标准,一般是以业务来划分将传统的一站式应用,拆分成一个个的服务,彻底去耦合,一个微服务就是单功能业务,只做一件事. 与微服务相对的叫巨石 . 2.微服务与微服务架构 微服务是一种架构模式或者一种架构风格,提倡将单一应用程序划分成一组小的服务==独立部署==,服务之间相互配合.相互协调,每个服务运行于自己的==进程==中. 服务与服务间采用轻量级通讯,如HTTP的RESTful API等 避免统一的.集中式

SpringCloud 入门理论知识

SpringCloud 入门问题 微服务概念 微服务之间如何通信 SpringCloud与Dubbo的区别 SpringBoot与SpringCloud的关系 服务熔断和服务降级概念 微服务的优缺点 微服务技术栈 eureka和zookeeper的区别 微服务概述 微服务起源:微服务 微服务将单一应用程序划分为一组小服务,每个服务独立在及自己的进程中,通过Restful方式互相沟通.调用.每个服务提供单个业务功能,去耦合. 微服务与微服务架构 微服务:指系统中的一个服务应用. 微服务架构:架构风

SpringCloud入门1-服务注册与发现(Eureka)

前言 Oracle转让Java,各种动态语言的曝光率上升,Java工程师的未来在哪里?我觉得Spring Cloud让未来有无限可能.拖了半年之久的Spring Cloud学习就从今天开始了.中文教材不多,而且大多都是简单的离散的信息,想要找到企业级的一体化解决方案很少.不过,对于入门来说,简单就够了,等到用的时候自然而然的汇总起来. 目标是把springcloud的子项目过一遍. Component Edgware.SR2 Finchley.M7 Finchley.BUILD-SNAPSHOT

微服务和SpringCloud入门

微服务是什么 微服务的核心是将传统的一站式应用,根据业务拆分成一个一个的服务,彻底去耦合,每个微服务提供单个业务功能的服务,一个服务做一件事情,从技术角度看就是一种小而独立的处理过程,类似进程概念,能够进行单独启动和销毁,可以拥有独立的数据库. 微服务与微服务架构的区别 微服务:它强调的事服务的大小,它关注的是某个点,是具体解决某一个问题/提供落地对应服务的一个服务应用 微服务架构:它是一种架构模式,它提成将单一应用程序划分成一组小的服务,服务之间相互配合协调,为服务提供最终价值.每个服务运行在

springcloud入门之断路器Hystrix（四）

什么是断路器 断路器模式源于Martin Fowler的Circuit Breaker一文."断路器"本身是一种开关装置,用于在电路上保护线路过载,当线路中有电器发生短路时,"断路器"能够及时的切断故障电路,防止发生过载.发热.甚至起火等严重后果. 在分布式架构中,断路器模式的作用也是类似的,当某个服务单元发生故障(类似用电器发生短路)之后,通过断路器的故障监控(类似熔断保险丝),向调用方返回一个错误响应,而不是长时间的等待.这样就不会使得线程因调用故障服务被长时间

SpringCloud入门[转]

原文链接 一.  网站的架构演变    网络架构由最开始的三层mvc渐渐演变.传统的三层架构后来在互联网公司让几百人几千人同时开发一个项目已经变得不可行,并且会产生代码冲突的问题.基于SOA面向服务开发的架构,渐渐产生了微服务架构.微服务的架构的特点就是项目拆分成各个子项目,进行解耦操作,提供外部访问接口,属于敏捷开发,其实也可以视为面向接口开发. 一旦有了多个子项目,比如把淘宝网的订单系统和会员系统分开来看,就回产生如何管理接口.负载均衡.高并发情况下怎么限流断路等问题.那么这就有Spring

SpringCloud入门(八)： Zuul 过滤器详解

Zuul 过滤器 zuul 有四种过滤器类型,分别是: 1.Pre:过滤器在请求被路由之前调用.我们可利用这种过滤器实现身份验证.在集群中选择请求的微服务.记录调试信息等: 2.Routing:过滤器将请求路由到微服务.这种过滤器用于构建发送给微服务的请求,并使用Apache HttpClient或Netfilx Ribbon请求微服: 3.Post:过滤器在路由到微服务以后执行.这种过滤器可用来为响应添加标准的HTTP Header.收集统计信息和指标.将响应从微服务发送给客户端: 4.Err