虎啊兄弟
虎啊兄弟

Spring Cloud

文章目录

      • spring cloud 的核心组件
      • 注册中心 Eureka
      • RestTemplate
      • 断路器 Hystrix
        • 降级
        • 请求缓存
        • 熔断
        • 请求合并
        • 隔离
      • 声明式服务调用 Feign
      • 网关 Zuul
        • 请求过滤
        • Spring Cloud Config
        • 加密解密
      • Spring Cloud Bus
        • Spring Cloud Stream

(Spring Cloud本身集合了很多微服务框架,实现分布式系统的快速开发)
Spring Cloud是一系列框架的有序集合。使用springboot的开发风格，实现分布式系统的快速开发。
如服务发现注册、配置中心、消息总线、负载均衡、断路器、数据监控等，都可以用Spring Boot的开发风格做到一键启动和部署

一、 什么是服务注册中心

服务注册中心是服务实现服务化管理的核心组件,类似于目录服务的作用,主要用来存储服务信息，譬如提供者 url 串、路由信息等。服务注册中心是 SOA 架构中最基础的设施之一
  
1 服务注册中心的作用

  • 服务的注册
  • 服务的发现

2 常见的注册中心有哪些

  • Dubbo 的注册中心 Zookeeper
  • Sringcloud 的注册中心 Eureka

3 服务注册中心解决了什么问题

  • 服务管理
  • 服务的依赖关系管理

4 什么是 Eureka 注册中心

  Eureka 是 Netflix 开发的服务发现组件，本身是一个基于 REST 的服务。
  Spring Cloud将它集成在其子项目 spring-cloud-netflix 中，以实现 Spring Cloud 的服务注册于发现，同时还提供了负载均衡、故障转移等能力。
  
5 Eureka 注册中心三种角色

5.1Eureka Server

 通过 Register、Get、Renew 等接口提供服务的注册和发现。
  
5.2Application Service (Service Provider)

 服务提供方把自身的服务实例注册到 Eureka Server 中
  
5.3Application Client (Service Consumer)

 服务调用方通过 Eureka Server 获取服务列表，消费服务

spring cloud 的核心组件

①. 服务发现——Netflix Eureka

一个RESTful服务，用来定位运行在AWS地区（Region）中的中间层服务。
由两个组件组成：Eureka服务器和Eureka客户端。Eureka服务器用作服务注册服务器。
Eureka客户端是一个java客户端，用来简化与服务器的交互、作为轮询负载均衡器，并提供服务的故障切换支持。
Netflix在其生产环境中使用的是另外的客户端，它提供基于流量、资源利用率以及出错状态的加权负载均衡。

②. 客服端负载均衡——Netflix Ribbon

Ribbon，主要提供客户侧的软件负载均衡算法。
Ribbon客户端组件提供一系列完善的配置选项，比如连接超时、重试、重试算法等。
Ribbon内置可插拔、可定制的负载均衡组件。

③. 断路器——Netflix Hystrix

断路器可以防止一个应用程序多次试图执行一个操作，即很可能失败，允许它继续而不等待故障恢复或者浪费 CPU 周期，而它确定该故障是持久的。
断路器模式也使应用程序能够检测故障是否已经解决。
如果问题似乎已经得到纠正，应用程序可以尝试调用操作。

④. 服务网关——Netflix Zuul

类似nginx，反向代理的功能，不过netflix自己增加了一些配合其他组件的特性。

⑤. 分布式配置——Spring Cloud Config

这个还是静态的，得配合Spring Cloud Bus实现动态的配置更新

注册中心 Eureka

服务 服务
eureka集群 注册中心，提供服务的注册和发现
service服务 声明service接口，定义方法，provider和consumer都需要依赖此服务
而且接口中的方法需要使用到SpringMVC的主键
provider服务 提供商品信息查询服务，需要依赖service服务
consumer服务 服务消费者，需要依赖service服务，
同时通过feign调用provider的服务获取商品信息

1.创建SpringBoot项目
  创建一个SpringBoot项目
2.引入相关的依赖
  添加如下的相关依赖
Spring Cloud_第1张图片

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-config</artifactId>
        <version>1.4.5.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-eureka-server</artifactId>
        <version>1.3.2.RELEASE</version>
    </dependency>
</dependencies>

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>Dalston.SR5</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

创建启动器

在启动类中我们需要放开@EnableEurekaServer，表明这是个Eureka的服务端

@SpringBootApplication
@EnableEurekaServer  //表示开启服务注册中心
public class EurekaApplication {

    public static void main(String[] args) {
        SpringApplication.run(EurekaApplication.class, args);
    }

}

修改application.properties文件

# 服务名
spring.application.name=eureka
# 是否将自己注册到 Eureka中,默认为true
eureka.client.register-with-eureka=false
# 是否从 Eureka服务中 获取注册信息,默认为true
eureka.client.fetch-registry=false
# 设置端口
server.port=8761
# 注册地址
eureka.client.service-url.defaultZone=http://127.0.0.1:8761/eureka

启动服务访问web页面

启动服务后访问 http://localhost:8761 可以访问表示启动成功
Spring Cloud_第2张图片
服务提供者
Spring Cloud_第3张图片
修改application.properties文件

spring.application.name=provider
eureka.client.service-url.defaultZone=http://127.0.0.1:8761/eureka
server.port=2000

启动
Spring Cloud_第4张图片服务消费者
Spring Cloud_第5张图片

修改application.properties文件

spring.application.name=consumer
eureka.client.service-url.defaultZone=http://127.0.0.1:8761/eureka
server.port=3000

注册Bean

	@Bean
    @LoadBalanced  //表示具有负载均衡功能的实例,使用这个实例发送的请求,统统都会被拦截,进行负载均衡处理
    RestTemplate restTemplate(){
        return new RestTemplate();
    }

注册服务

@RestController
public class UserHelloCOntroller {
    @Autowired
    private DiscoveryClient discoveryClient;

    @GetMapping("/hello")
    public void hello() throws IOException {
        //根据服务名获取服务的详细信息, 因为propider可能是集群
        List<ServiceInstance> list = discoveryClient.getInstances("provider");
        ServiceInstance serviceInstance = list.get(0);
        String url = "http://" + serviceInstance.getHost() + ":" + serviceInstance.getPort() + "/hello";
        HttpURLConnection con = null;
        URL u = new URL(url);
        con = (HttpURLConnection) u.openConnection();
        con.connect();
        if(con.getResponseCode() == 200){
            BufferedReader br = new BufferedReader(new InputStreamReader(con.getInputStream()));
            String s = br.readLine();
            System.out.println(s);
            br.close();
        }
    }
}

在这里插入图片描述

接口 说明
LoadBalancerClient 负载均衡器，根据服务名称可以获取对应服务的ip和host等信息
RestTemplate Rest服务模板，可以完成服务的调用

负载均衡有好几种实现策略，常见的有：

  1. 随机 (Random)
  2. 轮询 (RoundRobin)
  3. 一致性哈希 (ConsistentHash)
  4. 哈希 (Hash)
  5. 加权（Weighted）

RestTemplate

  SpringRestTemplate是Spring 提供的用于访问 Rest 服务的客端, RestTemplate提供了多种便捷访问远程Http服务的方法，
  能够大大提高客户端的编写效率,所以很多客户端比如Android或者第三方服务商都是使用RestTemplate 请求 restful服务

API方法介绍

API 说明
getForEntity() 发送一个HTTP GET请求，返回的ResponseEntity包含了响应体所映射成的对象
getForObject() 发送一个HTTP GET请求，返回的请求体将映射为一个对象
postForEntity() POST 数据到一个URL，返回包含一个对象的ResponseEntity，这个对象是从响应体中映射得到的
postForObject() POST 数据到一个URL，返回根据响应体匹配形成的对象
headForHeaders() 发送HTTP HEAD请求，返回包含特定资源URL的HTTP头
optionsForAllow() 发送HTTP OPTIONS请求，返回对特定URL的Allow头信息
postForLocation() POST 数据到一个URL，返回新创建资源的URL
put() PUT 资源到特定的URL
delete() 在特定的URL上对资源执行HTTP DELETE操作
exchange() 在URL上执行特定的HTTP方法，返回包含对象的ResponseEntity，这个对象是从响应体中映射得到的
execute() 在URL上执行特定的HTTP方法，返回一个从响应体映射得到的对象

1.环境搭建

Spring Cloud_第6张图片

  commons是一个公共模块，是一个普通的JavaSE工程，主要将实体类写在这个模块中，
  provider和consumer是两个spring boot项目，
  provider将扮演 服务提供者 的角色，
  consumer扮演服务消费者的角色

  然后在provider和consumer模块中添加对commons的依赖，依赖代码如下：

<dependency>
    <groupId>com.i</groupId>
    <artifactId>commons</artifactId>
    <version>0.0.1-SNAPSHOT</version>
</dependency

GET请求
可通过如下两种方式:

第一种：getForEntity

  getForEntity方法的返回值是一个ResponseEntity，
  ResponseEntity是Spring对HTTP请求响应的封装，包括了几个重要的元素，如响应码、contentType、contentLength、响应消息体等。

	@GetMapping("/test1")
    public void test1(){
        Map<String, Object> map = new HashMap<>();
        map.put("id", 1);
        ResponseEntity<User> entity = restTemplate.getForEntity("http://provider/user/?id={id}", User.class);
        System.out.println("entity.getStatusCode() :" + entity.getStatusCode());
        System.out.println("entity.getStatusCodeValue() :"+entity.getStatusCodeValue());
        System.out.println("entity.getBody() :"+entity.getBody());
  }

在这里插入图片描述

  1. getForEntity()第一个参数为 要调用的服务的地址,通过 服务名 而不是 服务地址
  2. getForEntity()第二个参数为 返回类型
  3. getForEntity()第三个参数为 传递的参数

有两种方式传递:

@RequestMapping("/sayhello")
public String sayHello() {
    ResponseEntity<String> responseEntity = restTemplate.getForEntity("http://provider/user/user?name={1}", String.class, "张三");
    return responseEntity.getBody();
}
@RequestMapping("/sayhello2")
public String sayHello2() {
    Map<String, String> map = new HashMap<>();
    map.put("name", "李四");
    ResponseEntity<String> responseEntity = restTemplate.getForEntity("http://provider/user/user?name={name}", String.class, map);
    return responseEntity.getBody();
}
  • 可以用 一个数字做 占位符,最后是一个 可变长度的参数,来一一替换前面的占位符
  • 可以使用name={name}形式,最后一个参数是 map,map的key为 前面占位符的 名字,map的value为 参数值

第二种：getForObject

  getForObject函数是对getForEntity函数的进一步封装,如 只关注返回的消息体的内容,其他不需要,可以使用getForObject

@RequestMapping("/book")
public Book book2() {
    Book book = restTemplate.getForObject("http://hello-service/getbook1", Book.class);
    return book;
}

POST请求

三种方法:

第一种：postForEntity

  @GetMapping("/addUser")
  public User test2() {
      User user = new User();
      user.setId(1);
      ResponseEntity<User> responseEntity = restTemplate.postForEntity("http://provider/user/addUser", user, User.class);
      return responseEntity.getBody();
  }
  1. 参数一: 要调用的服务的地址
  2. 参数二: 上传的参数
  3. 参数三: 返回的数据类型

创建了User对象,只有id属性,传递到服务提供者去

	@PostMapping("/addUser")
    public User addUser(@RequestBody User user) {
        user.setUsername("阿猫");
        user.setAddress("深圳");
        return user;
    }

服务提供者 接收到服务消费者传来的 User参数,给其他属性 设置上值再返回,调用结果如下:
Spring Cloud_第7张图片

第二种：postForObject

  如果只关注 返回的消息体,可以直接使用postForObject。用法与getForObject一样

第三种：postForLocation
  postForLocation也是提交新资源, 提交成功后,返回新资源的URL,
  postForLocation的参数和前面 两种的参数 基本一致,但 返回值为URI,只需 服务提供者返回 URI即可,
  该URI表示新资源的位置

PUT请求
  RestTemplate中，PUT请求可以通过put方法调用，
  put方法的参数和前面介绍的postForEntity方法的参数基本一致，只是put()方法没有返回值而已。

@RequestMapping("/put")
public void put() {
    User user = new User();
    user.setUsername("阿猫");
    restTemplate.put("http://provider/user/?{1}", user, 99);
}

user对象为 要提交的参数,后面的 99 用来替换前面的占位符

DELETE请求
delete请求我们可以通过delete()方法调用来实现

@RequestMapping("/delete")
public void delete() { 	
	restTemplate.delete("http://provider/user/{1}",99);
}

断路器 Hystrix

灾难性雪崩
在微服务环境中，因为一个节点的故障而造成的其他节点的不可用的情况是比较常见的，
这也就是我们常说的灾难性雪崩现象，而Hystrix给我们提供了解决这种情况的方案

Spring Cloud_第8张图片
正常情况下各个节点相互配置，完成用户请求的处理工作
Spring Cloud_第9张图片
当某种请求增多，造成"服务T"故障的情况时，会延伸的造成"服务U"不可用，及继续扩展，如下
Spring Cloud_第10张图片
最终造成下面这种所有服务不可用的情况
Spring Cloud_第11张图片
这就是灾难性雪崩
原因可归纳为三个:

  1. 服务提供者不可用 (硬件故障,程序BUG,缓存击穿,用户大量请求)
  2. 重试加大流量 (用户重试,代码逻辑重试)
  3. 服务调用者不可用 (同步等待造成的资源耗尽)

最终的结果就是一个服务不可用，导致一系列服务的不可用，而往往这种后果是无法预料的。

如何解决灾难性雪崩效应?

1.降级
  超时降级、资源不足时(线程或信号量)降级，降级后可以 配合降级接口 返回 托底数据。
  实现一个 fallback 方法, 当请求后端服务出现异常的时候, 可以使用 fallback 方法返回的值

2.缓存

  Hystrix 为了降低访问服务的频率，支持将一个请求与返回结果做缓存处理。
  如果再次请求的 URL 没有变化，那么 Hystrix 不会请求服务，而是直接从缓存中将结果返回。
  这样可以大大降低访问服务的压力

3.请求合并

  在微服务架构中，我们将一个 项目拆分 成 很多个 独立的 模块，这些独立的模块通过 远程调用 来互相配合工作，
  但是，在高并发情况下，通信次数 的 增加 会导致 总的通信时间 增加，
  同时，线程池的资源也是有限的，高并发环境会 导致有 大量的 线程处于 等待状态，进而导致 响应延迟，
  为了解决这些问题，我们需要了解 Hystrix 的请求合并。

4.熔断
  当失败率 (如因网络故障/超时造成的失败率高)达到 阀值 自动 触发 降级，
  熔断器触发的 快速失败会进行 快速恢复。

5.隔离（线程池隔离和信号量隔离）

  限制调用分布式服务的资源使用，某一个调用的服务出现问题不会影响其他服务调用。

降级

  超时降级、资源不足时(线程或信号量)降级，降级后可以配合降级接口返回托底数据。
  实现一个 fallback 方法, 当请求后端服务出现异常的时候, 可以使用 fallback 方法返回的值

Spring Cloud_第12张图片

服务消费者中加入断路器

首先我们需要在服务消费者中引入hystrix，如下：
Spring Cloud_第13张图片

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

修改application.properties文件

# 服务名
spring.application.name=hystrix
# 设置端口
server.port=4000
#设置服务注册中心地址，指向另一个注册中心
eureka.client.service-url.defaultZone=http://127.0.0.1:8761/eureka

修改服务消费者启动入口类

引入hystrix之后，我们需要在入口类上通过@EnableCircuitBreaker开启断路器功能，如下:

@SpringBootApplication
@EnableCircuitBreaker  //开启断路器
public class HystrixApplication {

    public static void main(String[] args) {
        SpringApplication.run(HystrixApplication.class, args);
    }

    @Bean
    @LoadBalanced
    RestTemplate restTemplater(){
        return new RestTemplate();
    }
}

我们也可以使用一个名为@SpringCloudApplication的注解代替这三个注解，@SpringBootApplication注解的定义如下：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootApplication
@EnableDiscoveryClient
@EnableCircuitBreaker
public @interface SpringCloudApplication {
}

//@SpringBootApplication
//@EnableCircuitBreaker  //开启断路器
@SpringCloudApplication
public class HystrixApplication {

    public static void main(String[] args) {
        SpringApplication.run(HystrixApplication.class, args);
    }

    @Bean
    @LoadBalanced
    RestTemplate restTemplater(){
        return new RestTemplate();
    }
}

修改Controller

创建一个Service类
业务层代码中在getUsers方法中通过RestTemplate来调用服务，
在方法头部添加@HystrixCommand注解，通过fallbackMethod 属性指定当调用的provider方法异常的时候的fallback方法为fallBack方法，然后在其方法中返回了托底数据

@RestController
public class UserHelloController {
    @Autowired
    RestTemplate restTemplate;

    @HystrixCommand(fallbackMethod = "error")
    public String getUser(){
        return restTemplate.getForObject("http://provider/user/", String.class);
    }

    public String error(){
        return "error";
    }
}

1.RestTemplate执行网络请求的操作我们放在HelloService中来完成。
2.error方法是一个请求失败时回调的方法。
3.在hello方法上通过@HystrixCommand注解来指定请求失败时回调的方法

将Controller的逻辑修改成下面这样

@RestController
public class UserHelloController {
    @Autowired
    RestTemplate restTemplate;

    @Autowired
    HelloService helloService;

    @GetMapping("/hello")
    public String hello(){
        return helloService.hello();
    }
}

此时就开启了断路器功能。

测试
Spring Cloud_第14张图片

启动eureka注册中心，然后启动consumer服务，provider服务不用启动，这样我们访问consumer中的服务的时候就会出现异常，当我们浏览器看到托底数据的话，表示降级成功.

实际开发中，不是所有的请求都要提前预备好 服务降级问题，如果我就是要将服务调用失败的信息展示给用户，那么此时就没必要添加断路器了

自定义Hystrix请求命令
  除了使用@HystrixCommand注解，也可以自定义类继承自HystrixCommand，如下

public class HelloCommand extends HystrixCommand<String> {

    RestTemplate restTemplate;

    public HelloCommand(RestTemplate restTemplate) {
        super(HystrixCommand.Setter.withGroupKey(HystrixCommandGroupKey.Factory.asKey("")));
        this.restTemplate = restTemplate;
    }

    @Override
    protected String run() throws Exception {
        return restTemplate.getForObject("http://provider/hello",String.class);
    }

    @Override
    protected String getFallback() {
        return "error-2";
    }
}

在HelloCommand中注入RestTemplate,然后重写两个方法:

  1. getFallBack(): 该方法在服务调用失败时回调
  2. run():执行请求时调用
  3. 构造方法的第一个参数 主要用来保存一些分组信息

异步请求

1.配置HystrixCommandAspect的Bean
  在项目的入口类中配置HystrixCommandAspect的Bean

	@Bean
    public HystrixCommandAspect hystrixCommandAspect() {
        return new HystrixCommandAspect();
    }

2.通过AsyncResult来执行调用

  还是使用@HystrixCommand注解，但是方法的实现使用AsyncResult

	@HystrixCommand(fallbackMethod = "error")
    public Future<String> hello(){
        return new AsyncResult<String>(){
            @Override
            public String invoke() {
                return restTemplate.getForObject("http://provider/user/", String.class);
            }
        };
    }

之后就可以通过注解来实现异步调用了。调用方式如下:

	@GetMapping("/hello")
    public String hello() throws ExecutionException, InterruptedException {
        Future<String> hello = helloService.hello();
        //调用 get()方法 也可以设置超时时长
        return hello.get();
    }

对响应式函数编程的支持
  Hystrix对响应式函数编程也提供了相应的支持，在获取到BookCommand对象之后，
  也可以通过如下两种方式来获取到一个Observable来对数据进行二次处理

UserCommand userCommand = new UserCommand(HystrixCommand.Setter.withGroupKey(HystrixCommandGroupKey.Factory.asKey("")), restTemplate);
        Observable<User> observe = userCommand.observe();
        Observable<User> bookObservable = userCommand.toObservable();

通过注解支持响应式函数编程

@HystrixCommand(observableExecutionMode = ObservableExecutionMode.EAGER) //表示使用observe模式来执行
@HystrixCommand(observableExecutionMode = ObservableExecutionMode.LAZY)  //表示使用toObservable来执行
  • ObservableExecutionMode.EAGER 表示使用observe模式来执行
  • ObservableExecutionMode.LAZY 表示使用toObservable来执行

异常处理
  在调用服务提供者 时有可能会 抛异常，默认情况下方法抛了异常会 自动进行 服务降级，
  交给服务降级中的方法去处理，在自定义Hystrix请求命令的方式下，
  可以在getFallback方法中调用getExecutionException方法来获取抛出的异常

@Override
protected String run() throws Exception {
    int i = 1/0;
    return restTemplate.getForObject("http://provider/hello",String.class);
}

@Override
protected String getFallback() {
    Throwable t = getExecutionException();
    return "error-2"+t.getMessage();
}

抛出了异常也会自动进行了服务降级
Spring Cloud_第15张图片

采用了注解的方式，只需要在服务降级方法中添加一个Throwable类型的参数就能够获取到抛出的异常的类型，如下:

@HystrixCommand(fallbackMethod = "error")
public String hello(){
    int i = 1/0;
    return restTemplate.getForObject("http://provider/user/", String.class);
}

public String error(Throwable throwable){
    return "error"+throwable.getMessage();
}

在这里插入图片描述

如果有一个异常抛出后,不希望进入到服务降级方法中去处理，而是直接将 异常抛给 用户，那么我们可以在@HystrixCommand注解中添加忽略异常，如下:

@HystrixCommand(fallbackMethod = "error",ignoreExceptions = ArithmeticException.class)
    public String hello(){
        int i = 1/0;
        return restTemplate.getForObject("http://provider/user/", String.class);
    }

    public String error(Throwable throwable){
        return "error"+throwable.getMessage();
    }

Spring Cloud_第16张图片

原理:有个HystrixBadRequestException的异常不会进入到 服务降级方法中去,当定义了ignoreExections为ArithmeticExection.class之后,当抛出 ArithmeticException异常时,Hystrix会将异常信息包装在HystrixBadRequestExection里,然后再抛出,此时就不会触发 服务降级方法了

请求缓存

  Hystrix 为了降低访问服务的频率，支持将一个请求与返回结果做缓存处理。
  如再次请求的 URL 没有变化，那Hystrix不会请求服务，而是直接从缓存中将结果返回。这样可以大大降低访问服务的压力。

Hystrix 自带缓存。有两个缺点：

  1. 是一个本地缓存。在集群情况下缓存是不能同步的
  2. 不支持第三方缓存容器。Redis，memcache 不支持的

所以我们使用spring的cache
通过注解开启缓存

  • @CacheResult
  • @CacheKey
  • @CacheRemove

@CacheResult
@CacheResult方法可以用在我们之前的Service方法上，
表示给该方法开启缓存，默认情况下方法的所有参数都将作为缓存的key，如下

	@CacheResult
    @HystrixCommand()
    public String hello(Integer id,String a){
        return restTemplate.getForObject("http://provider/user/", String.class);
    }

如果想指定key
@CacheKey
  指定缓存的key

	@CacheResult
    @HystrixCommand()
    public String hello(@CacheKey Integer id, String a){
        return restTemplate.getForObject("http://provider/user/", String.class);
    }

使用了服务降级的话,对应的方法也要加上参数

public String error(Integer id,Throwable throwable){
        return "error"+throwable.getMessage();
    }

测试

	HystrixRequestContext ctx = HystrixRequestContext.initializeContext();
        String hello = helloService.hello(1);
        hello = helloService.hello(1);
        ctx.close();
        return hello;

@CacheRemove
让缓存失效的注解

@CacheRemove(commandKey = "hello")
@HystrixCommand
public Book test(@CacheKey Integer id) {
    return null;
}

通过方法重载开启缓存
使用了自定义Hystrix请求命令的方式来使用Hystrix，那只需重写getCacheKey方法即可实现请求缓存

public class HelloCommand extends HystrixCommand<String> {
    private RestTemplate restTemplate;
    private Integer id;

    public HelloCommand(Integer id,RestTemplate restTemplate) {
        super(HystrixCommand.Setter.withGroupKey(HystrixCommandGroupKey.Factory.asKey("")));
        this.restTemplate = restTemplate;
        this.id = id;
    }

    @Override
    protected String run() throws Exception {
        return restTemplate.getForObject("http://provider/hello",String.class);
    }

    @Override
    protected String getCacheKey() {
        System.out.println("run");
        return String.valueOf(id);
    }
}

系统在运行时会根据getCacheKey方法的返回值来判断这个请求是否和之前执行过的请求一样，即被缓存，如果被缓存，则直接使用缓存数据而不去请求服务提供者，getCacheKey方法将在run方法之前执行。

controller消费

@GetMapping("/hello")
    public String hello() throws ExecutionException, InterruptedException {
        HystrixRequestContext ctx = HystrixRequestContext.initializeContext();
        HelloCommand cmd = new HelloCommand(1,restTemplate);
        HelloCommand cmd2 = new HelloCommand(1,restTemplate);
        String execute = cmd.execute();
        String execute2 = cmd2.execute();
        return execute;
}

注意，在服务请求发起之前，需要先初始化HystrixRequestContext

通过HystrixRequestCache中的clear方法将缓存的数据清除掉，这个时候如果我再发起请求，则又会调用服务提供者的方法

@GetMapping("/hello")
    public String hello() throws ExecutionException, InterruptedException {
    	HystrixCommandKey commandKey = HystrixCommandKey.Factory.asKey("commandKey");
        HystrixRequestContext ctx = HystrixRequestContext.initializeContext();
        HelloCommand cmd = new HelloCommand(1,restTemplate);
        HelloCommand cmd2 = new HelloCommand(1,restTemplate);
        String execute = cmd.execute();
        HystrixRequestCache.getInstance(commandKey, HystrixConcurrencyStrategyDefault.getInstance()).clear(String.valueOf(1l));
        String execute2 = cmd2.execute();
        return execute;
}

熔断

熔断其实是在降级的基础上引入了重试的机制。当某个时间内失败的次数达到了多少次就会触发熔断机制，具体的流程如下
  Spring Cloud_第17张图片

@HystrixCommand(fallbackMethod = "fallback",
            commandProperties = {
                    //默认 20 个;10s 内请求数大于 20 个时就启动熔断器，当请求符合熔断条件时将触发 getFallback()。
            @HystrixProperty(name= HystrixPropertiesManager.CIRCUIT_BREAKER_REQUEST_VOLUME_THRESHOLD,
                    value="10"),
            //请求错误率大于 50%时就熔断，然后 for 循环发起请求，当请求符合熔断条件时将触发 getFallback()。
            @HystrixProperty(name=HystrixPropertiesManager.CIRCUIT_BREAKER_ERROR_THRESHOLD_PERCENTAGE,
                    value="50"),
            //默认 5 秒;熔断多少秒后去尝试请求
            @HystrixProperty(name=HystrixPropertiesManager.CIRCUIT_BREAKER_SLEEP_WINDOW_IN_MILLISECONDS,
                    value="5000"),
            })

Spring Cloud_第18张图片

请求合并

Spring Cloud_第19张图片

什么情况下使用请求合并

  在微服务架构中，我们将一个 项目拆分 成 很多个 独立的 模块，这些独立的模块通过 远程调用 来互相配合工作，
  但是，在高并发情况下，通信次数 的 增加 会导致 总的通信时间 增加，
  同时，线程池的资源也是有限的，高并发环境会 导致有 大量的 线程处于 等待状态，进而导致 响应延迟，
  为了解决这些问题，我们需要了解 Hystrix 的请求合并。
  
请求合并的缺点

  设置请求合并之后，本来一个请求可能 5ms 就搞定了，但是现在必须再等 10ms 看看还有没有其他的请求一起的，这样一个请求的耗时就从 5ms 增加到 15ms 了，不过，如果我们要发起的命令本身就是一个高延迟的命令，那么这个时候就可以使用请求合并了，因为这个时候时间窗的时间消耗就显得微不足道了，另外高并发也是请求合并的一个非常重要的场景。

服务提供者接口

需在服务提供者中提供 批处理接口 调用，如下

@GetMapping("/{ids}")
    public List<User> getUserById(@PathVariable String ids) {
        System.out.println("getUserById" + ids);
        String[] split = ids.split(",");
        List<User> users = new ArrayList<>();
        for (String s:split) {
            User u = new User();
            u.setId(Integer.parseInt(s));
            users.add(u);
        }
        return users;
    }

服务消费者

UserService

  首先在BookService中添加方法用来调用服务提供者提供的接口，如下

public List<User> getUserByIds(List<Integer> ids){
        User[] users = restTemplate.getForObject("http://provider/user/{1}", User[].class, StringUtils.join(ids, ","));
        return Arrays.asList(users);
    }

UserBatchCommand

public class UserBatchCommand extends HystrixCollapser<List<User>,User,Integer> {
    private Integer id;
    private UserService userService;

    public UserBatchCommand(Integer id, UserService userService) {
        super(HystrixCollapser.Setter.withCollapserKey(HystrixCollapserKey.Factory.asKey("")).
                andCollapserPropertiesDefaults(HystrixCollapserProperties.Setter().withTimerDelayInMilliseconds(100)));
        this.id = id;
        this.userService = userService;
    }

    @Override
    public Integer getRequestArgument() {
        return id;
    }

    //请求合并,具体的合并操作在这进行
    @Override
    protected HystrixCommand<List<User>> createCommand(Collection<CollapsedRequest<User, Integer>> collection) {
        List<Integer> ids = new ArrayList<>(collection.size());
        for (CollapsedRequest<User, Integer> request : collection) {
            ids.add(request.getArgument());
        }
        UserCommand userCommand = new UserCommand(userService,ids);
        return userCommand;
    }

    //映射请求 响应到不同的请求上
    @Override
    protected void mapResponseToRequests(List<User> users, Collection<CollapsedRequest<User, Integer>> collection) {
        int count = 0;
        for (CollapsedRequest<User, Integer> request : collection) {
            request.setResponse(users.get(count++));
        }
    }
}

1.构造方法中,设置了请求时间隔为 100ms,即请求时间 间隔在100ms之内的请求会被合并为一个请求
2.createCommand方法用来 合并请求,在这获取 各个请求的id ,将单个的id放到一个集合中,再创建出 UserBatchCommand对象,用该对象去发起一个批量请求
3.mapResponseToRequests方法用来 为每个请求设置请求结果。方法的第一个参数batchResponse表示批处理请求的结果,第二个参数collapsedRequests代表 每一个被合并的请求, 然后通过 遍历batchResponse来为collapsedRequests设置请求结果

测试

@GetMapping("/test1")
    public void test1() throws ExecutionException, InterruptedException {
        HystrixRequestContext ctx = HystrixRequestContext.initializeContext();
        UserBatchCommand cmd1 = new UserBatchCommand(1, userService);
        UserBatchCommand cmd2 = new UserBatchCommand(2, userService);
        UserBatchCommand cmd3 = new UserBatchCommand(3, userService);
        Future<User> q1 = cmd1.queue();
        Future<User> q2 = cmd2.queue();
        Future<User> q3 = cmd3.queue();
        User user1 = q1.get();
        User user2 = q2.get();
        User user3 = q3.get();
        System.out.println(user1);
        System.out.println(user2);
        System.out.println(user3);
        Thread.sleep(3000);
        UserBatchCommand cmd4 = new UserBatchCommand(4, userService);
        Future<User> q4 = cmd4.queue();
        User user4 = q4.get();
        System.out.println(user4);
        ctx.close();
    }

1.首先要初始化HystrixRequestContext
2.创建BookCollapseCommand类的实例来发起请求，先发送3个请求，然后睡眠3秒钟，再发起1个请求，这样，前3个请求就会被合并为一个请求，第四个请求因为间隔的时间比较久，所以不会被合并，而是单独创建一个线程去处理
Spring Cloud_第20张图片

在这里插入图片描述

通过注解实现请求合并

UserService中添加方法

@Service
public class UserService {
    @Autowired
    RestTemplate restTemplate;

    @HystrixCollapser(batchMethod = "getUserByIds",
            collapserProperties = {
                //请求时间间隔在 100ms 之内的请求会被合并为一个请求,默认为 10ms
                @HystrixProperty(name = "timerDelayInMilliseconds",value = "100"),
                //设置触发批处理执行之前，在批处理中允许的最大请求数。
                @HystrixProperty(name = "maxRequestsInBatch",value = "200")
            })
    public Future<User> test(Integer id){
        return null;
    }

    @HystrixCommand
    public List<User> getUserByIds(List<Integer> ids){
        User[] users = restTemplate.getForObject("http://provider/user/{1}", User[].class, StringUtils.join(ids, ","));
        return Arrays.asList(users);
    }
}

  在test方法上添加@HystrixCollapser注解实现请求合并，用batchMethod属性指明请求合并后的处理方法，collapserProperties属性指定其他属性
测试

	@GetMapping("/test2")
    public void test2() throws ExecutionException, InterruptedException {
        HystrixRequestContext ctx = HystrixRequestContext.initializeContext();
        Future<User> q1 = userService.test(1);
        Future<User> q2 = userService.test(2);
        Future<User> q3 = userService.test(3);
        User user1 = q1.get();
        User user2 = q2.get();
        User user3 = q3.get();
        System.out.println(user1);
        System.out.println(user2);
        System.out.println(user3);
        Thread.sleep(2000);
        Future<User> q4 = userService.test(4);
        User user4 = q4.get();
        System.out.println(user4);
        ctx.close();
    }

Spring Cloud_第21张图片
@HystrixCollapser

参数 作用/默认值 备注
batchMethod 合并请求的方法
scope 请求方式/REQUEST 请求方式/REQUEST
REQUEST范围只对一个request请求内的多次服务请求进行合并
GLOBAL是多单应用中的所有线程的请求中的多次服务请求合并
timerDelayInMilliseconds 请求时间间隔在10ms之内的请求会被
合并为一个请求/10ms		 建议尽量设置的小一点，如果并发量不大的话，其实也没有必要使用HystrixCollapser来处理
maxRequestsInBatch 设置触发批处理执行之前,在批处理中允许的最大请求数
/Integer.MAX_VALUE

  请求合并的优点已经看到了，多个请求被合并为一个请求进行一次性处理，
  可以有效节省网络带宽和线程池资源，
  但是，有优点必然也有缺点，设置请求合并之后，本来一个请求可能5ms就搞定了，
  但是现在必须再等10ms看看还有没有其他的请求一起的，这样一个请求的耗时就从5ms增加到15ms了，
  不过，如果我们要发起的命令本身就是一个高延迟的命令，
  那么这个时候就可以使用请求合并了，因为这个时候时间窗的时间消耗就显得微不足道了，
  另外高并发也是请求合并的一个非常重要的场景

隔离

  限制调用分布式服务的资源使用，某一个调用的服务出现问题不会影响其他服务调用。
  隔离又分为线程池隔离和信号量隔离

概念介绍
Spring Cloud_第22张图片
Spring Cloud_第23张图片通过上图来看，线程池隔离的作用还是蛮明显的。
但线程池隔离的使用也不是在任何场景下都适用的，线程池隔离的优缺点如下:

优点:

  1. 使用线程池隔离可以完全隔离依赖的服务(如图中的A,B,C服务),请求线程可以快速返回
  2. 当线程池出现问题时,线程池隔离是独立的不会影响其他服务和接口
  3. 当失败的服务再次变得可用时,线程池将清理并可立即修复,而不是需要一个长时间的恢复
  4. 独立的线程池提高了并发性

缺点:
 线程池隔离的主要缺点是它们 增加计算机开销(CPU),每个命令的执行 涉及到 排队,调度 和 上下文切换都是在 一个单独的 线程上运行的

线程池隔离

@HystrixCommand(groupKey="ego-product-provider",
            commandKey = "getUsers",
            threadPoolKey="ego-product-provider",
            threadPoolProperties = {
                    @HystrixProperty(name = "coreSize", value = "30"),//线程池大小
                    @HystrixProperty(name = "maxQueueSize", value = "100"),//最大队列长度
                    @HystrixProperty(name =  "keepAliveTimeMinutes", value = "2"),//线程存活时间
                    @HystrixProperty(name = "queueSizeRejectionThreshold", value = "15")//拒绝请求
            },
            fallbackMethod = "fallback")

线程池隔离参数

参数 作用 默认值 备注
groupKey 服务名
(相同服务用一个名称,如用户,商品等)		 getClass().getSimpleName(); 在consumer里 为每个propvider,
设置group标识,一个group使用一个线程池
commandKey 接口
(服务下面的接口,如购买商品)		 当前执行方法名 consumer的接口名称
threadPoolKey 线程池的名称 默认是分组名groupKey 配置全局唯一标识线程池的名称,
相同线程池名称的线程池是同一个
coreSize 线程池大小
(最大的并发执行数量)		 10 设置标准:每秒最大支撑的请求数(99%平均响应时间+一个缓冲值)
比如:每秒能处理1000个请求,99%的请求响应时间是60ms,公式就是:1000*(0.060+0.012)
maxQueueSize 最大队列长度(设置BlockingQueue的最大长度) -1 如果使用正数,将从同步队列(SynchronousQueue)改为阻塞队列(LinkedBlockingQueue)
keepAliveTimeMinutes 线程存活时间 1分钟(单位) 控制一个线程从实用完成到被释放的时间
queueSizeRejectionThreshold 拒绝请求(设置拒绝请求的临界值) 5 此属性不适于maxQueueSize= -1时
原因是maxQueueSize值运行时不能改变,可通过修改这个变量动态修改允许排队的长度

信号量隔离

信号量隔离其实就是我们定义的队列并发时最多支持多大的访问，其他的访问通过托底数据来响应，如下结构图
  Spring Cloud_第24张图片

@HystrixCommand(fallbackMethod = "fallback",
            commandProperties = {
                    @HystrixProperty(name= HystrixPropertiesManager.EXECUTION_ISOLATION_STRATEGY,value="SEMAPHORE"),// 信号量 隔离
                    @HystrixProperty
                            (name=HystrixPropertiesManager.EXECUTION_ISOLATION_SEMAPHORE_MAX_CONCURRENT_REQUESTS, value="100")//信号量最大并度
            })

信号量隔离参数

参数 作用 默认值 备注
execution.isolation.strategy 隔离策略配置项 THREAD 只有2种,THREAD和SEMAPHORE
execution.isolation.thread.timeoutInMilliseconds 超时时间 1000ms 1.THREAD模式下,达到超时时间,自动中断
2.SEMAPHONE模式下,会等待执行完成后,再去判断是否超时
execution.isolation.thread.interruptOnTimeout 是否打开超时线程中断 TRUE THREAD模式有效
execution.isolation.semaphore.maxConcurrentRequests 信息量最大并发度 10 SEMAPHONE模式有效
fallback.isolation.semaphore.maxConcurrentRequests fallback最大并发度 10 SEMAPHONE模式有效

线程池和信息量的区别

线程池隔离 信息量隔离
线程 请求线程和调用provider线程不是同一条线程 请求线程和调用provider线程是同一条线程
开销 排队,调度,上下文开销等 无线程切换,开销低
异步 支持 不支持
并发支持 支持(最大线程池大小) 支持(最大信息量上限)
传递Header 无法传递http Header 可以传递http Header
支持超时 支持 不支持

什么情况下用线程池隔离?
  请求 并发量大,且 耗时长(请求耗时长一般是计算量大,或读数据库):采用线程隔离策略,
  可以保证大量的 容器(tomcat)线程可用,不会由于服务原因,一直处于阻塞或等待状态,快速失败返回

什么情况下用信息量隔离?
  请求并发量大,且 耗时短(请求耗时短 可能是计算量小,或读缓存):采用信息量隔离策略,
  因为这类服务的返回通常会非常快,不会占用容器线程太长时间,
  而且也减少了线程切换的一些开销,提高了缓存服务的效率

声明式服务调用 Feign

Feign是一种声明式、模板化的HTTP客户端(仅在 consumer 中使用)。

什么是声明式，有什么作用，解决什么问题？
  声明式调用就像调用本地方法一样调用远程方法;无感知远程 http 请求。

1.Spring Cloud 的声明式调用, 可以做到使用 HTTP 请求远程服务时能就像调用本地方法一样的体验，
  开发者完全感知不到这是远程方法，更感知不到这是个 HTTP 请求。

2.它像 Dubbo 一样，consumer 直接调用接口方法调用 provider，
  而不需要通过常规的Http Client 构造请求再解析返回数据。

3.它解决了让开发者调用远程接口就跟调用本地方法一样，
  无需关注与远程的交互细节，更无需关注分布式环境开发。

1.创建普通Spring Boot工程
2.添加依赖
  添加依赖

	<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
            <version>2.2.0.M3</version>
        </dependency>
  1. 属性配置
# 服务名
spring.application.name=feign
# 设置端口
server.port=5000
#设置服务注册中心地址，指向另一个注册中心
eureka.client.service-url.defaultZone=http://127.0.0.1:8761/eureka

4.添加注解
  在工程的入口类上添加@EnableFeignClients注解表示开启Spring Cloud Feign的支持功能

@SpringBootApplication
@EnableFeignClients //开启Feign
public class FeignApplication {

    public static void main(String[] args) {
        SpringApplication.run(FeignApplication.class, args);
    }
}

5.声明服务
定义一个HelloService接口，通过@FeignClient注解来指定服务名进而绑定服务，然后再通过SpringMVC中提供的注解来绑定服务提供者提供的接口

@FeignClient("provider")
public interface HelloService {

    @GetMapping("/user/")
    User getUserById(@RequestParam("id") Integer id);
}

服务提供者提供的接口

@RestController
@RequestMapping("/user")
public class UserController {

    @GetMapping("/")
    public User getUserById(Integer id) {
        User user = new User();
        user.setId(id);
        System.out.println("getUserById :" + id);
        return user;
    }
}

6.Controller中调用服务

@RestController
public class UserController {

    @Autowired
    private UserService userService;

    @GetMapping("/test1")
    public void test1(){
        User userById = userService.getUserById(1);
        System.out.println(userById);
    }
}

测试
在这里插入图片描述

Feign的继承特性
  服务提供者另一种写法,出了错误只用看一边,但是代码间耦合性增加了

创建公共接口

@RequestMapping("/user")
public interface IUserService {

    @GetMapping("/")
    public User getUserById(@RequestParam("id") Integer id);

    @PostMapping("/addUser")
    public User addUser(@RequestBody User user);

    @DeleteMapping("/{id}")
    public void deleteUserById(@PathVariable("id") Integer id) ;

    @PutMapping("/")
    public User updateUser(@RequestBody User user);

    @GetMapping("/{ids}")
    public List<User> getUserById(@PathVariable("ids") String ids);
}

服务提供者中实现接口

 方法的实现还是和上文的一样。不同的是这里不需要在方法上面添加@RequestMapping注解，
 这些注解在父接口中都有，不过在Controller上还是要添加@RestController注解，另外需要注意的是，
 方法中的参数@RequestHeader和@RequestBody注解还是要添加，@RequestParam注解可以不添加。

@RestController
public class UserController implements IUserService {
    
    @Override
    public User getUserById(Integer id) {
        User user = new User();
        user.setId(id);
        System.out.println("getUserById :" + id);
        return user;
    }

    @Override
    public User addUser(@RequestBody User user) {
        user.setUsername("阿猫");
        user.setAddress("深圳");
        return user;
    }

    @Override
    public void deleteUserById(@PathVariable Integer id) {
        System.out.println("deleteUserById :" + id);
    }

    @Override
    public User updateUser(@RequestBody User user) {
        System.out.println("updateUser " + user);
        return user;
    }

    @Override
    public List<User> getUserById(@PathVariable String ids) {
        System.out.println("getUserById" + ids);
        String[] split = ids.split(",");
        List<User> users = new ArrayList<>();
        for (String s:split) {
            User u = new User();
            u.setId(Integer.parseInt(s));
            users.add(u);
        }
        return users;
    }
}

服务消费者中继承接口

这个接口中不需要添加任何方法，方法都在父接口中，这里只需要在类上面添加@FeignClient(“provider”)注解来绑定服务即可

@FeignClient("provider")
public interface UserService extends IUserService {
}

网关 Zuul

  API网关是一个更为智能的应用服务器，它有点类似于我们微服务架构系统的门面，
  所有的外部访问都要先经过API网关，然后API网关来实现请求路由、负载均衡、权限验证等功能。
  Spring Cloud中提供的Spring Cloud Zuul实现了API网关的功能
Spring Cloud_第25张图片1.创建Spring Boot工程并添加依赖
Spring Cloud_第26张图片

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-netflix-zuul</artifactId>
		</dependency>

2.添加注解
入口类上添加@EnableZuulProxy注解表示开启Zuul的API网关服务功能

@SpringBootApplication
@EnableZuulProxy
public class ZuulApplication {

	public static void main(String[] args) {
		SpringApplication.run(ZuulApplication.class, args);
	}

}

3.配置路由规则

# 基础信息配置
spring.application.name=zuul
# API网关也将作为一个服务注册到eureka-server上
eureka.client.service-uri.defaultZone=http://127.0.0.1:1111/eureka

测试

代理的路径 就是服务注册的名字
Spring Cloud_第27张图片
在这里插入图片描述

# 路由规则配置
zuul.routes.i.path=/i/**
zuul.routes.i.service-id=provider

定制路径
  配置了路由规则所有符合/i/**的请求都将被转发到provider服务上，至于provider服务的地址到底是什么则由eureka-server去分析，我们这里只需要写上服务名即可。
  以上面的配置为例，如果我请求http://localhost:8761/i/hello1接口则相当于请求http://localhost:8761/hello1(我这里provider的地址为http://localhost:8761)，我们在路由规则中配置的i是路由的名字，可以任意定义，但是一组path和serviceId映射关系的路由名要相同。

在这里插入图片描述

简化写法

zuul.routes.feign=/aaa/**

 feign表示服务名
在这里插入图片描述

在这里插入图片描述

如果不想做映射,可以加上,忽略

zuul.ignored-services=hystrix

如果有多个服务要排除，服务名称通过","连接

zuul.ignored-services=hystrix,feign

由于服务太多，不可能手工一个个加，故路由排除所有服务，然后针对要
路由的服务进行手工加

# 先忽略所有的请求
zuul.ignored-services=*
# 然后单独放开e-book-order的服务
zuul.routes.e-book-order.path=/i/**

也可以通过排除指定关键字的路径

# 排除所有含有findAll关键字的请求
zuul.ignored-patterns=/**/findAll/**
# 放开e-book-order服务，同时也会排除 findAll的请求
zuul.routes.e-book-order.path=/bobo/**

指定路由前缀

也就是给提前的url添加一个前缀

zuul.prefix=/i
zuul.routes.e-book-product.path=/product-provider/**

Spring Cloud_第28张图片

请求过滤

请求过滤有点类似于Java中Filter过滤器，先将所有的请求拦截下来，然后根据现场情况做出不同的处理

定义过滤器
  继承自ZuulFilter

@Component
public class PermissFilter extends ZuulFilter {

    //返回值为过滤器的类型,过滤器的类型决定了过滤器在哪个生命周期执行,pre表示在路由之前执行过滤器，其他可选值还有post、error、route和static,也可自定义
    @Override
    public String filterType() {
        return "pre";
    }

    //过滤器的优先级,执行顺序
    @Override
    public int filterOrder() {
        return 0;
    }

    //用来判断过滤器是否执行
    @Override
    public boolean shouldFilter() {
        return true;
    }

    //表示过滤的具体逻辑
    @Override
    public Object run() throws ZuulException {
        //获取当前上下文
        RequestContext ctx = RequestContext.getCurrentContext();
        //获取当前用户的请求
        HttpServletRequest request = ctx.getRequest();
        String username = request.getParameter("username");
        String password = request.getParameter("password");
        if(!"i".equals(username) || !"123".equals(password)){
            ctx.setSendZuulResponse(false); //表示不对该请求进行路由
            ctx.setResponseStatusCode(401); //设置响应码
            ctx.setResponseBody("非法请求"); //设置响应值
            ctx.addZuulResponseHeader("content-type","text/html;charset=utf-8");  //添加头信息,防止乱码
        }
        return null;
    }
}

1.filterType方法的返回值为过滤器的类型，过滤器的类型决定了过滤器在哪个生命周期执行，
  pre表示在路由之前执行过滤器，其他可选值还有post、error、route和static，当然也可以自定义。
2.filterOrder方法表示过滤器的执行顺序，当过滤器很多时，这个方法会有意义。
3.shouldFilter方法用来判断过滤器是否执行，true表示执行，false表示不执行，在实际开发中，我们可以根据当 前请求地址来决定要不要对该地址进行过滤，这里直接返回true。
4.run方法则表示过滤的具体逻辑，假设请求地址中携带了login参数的话，则认为是合法请求，
 否则就是非法请求，如果是非法请求的话，首先设置ctx.setSendZuulResponse(false);
 表示不对该请求进行路由，然后设置响应码和响应值。
 这个run方法的返回值在当前版本(Dalston.SR3)中暂时没有任何意义，可以返回任意值。

测试
在这里插入图片描述

在这里插入图片描述

API网关作为系统的的统一入口，将微服务中的内部细节都屏蔽掉了，而且能够自动的维护服务实例，实现负载均衡的路由转发，同时，它提供的过滤器为所有的微服务提供统一的权限校验机制，使得服务自身只需要关注业务逻辑即可

Spring Cloud Config

随着我们的分布式项目越来越大，我们可能需要将配置文件抽取出来单独管理，Spring Cloud Config对这种需求提供了支持。
Spring Cloud Config为分布式系统中的外部配置提供服务器和客户端支持。
我们可以使用Config Server在所有环境中管理应用程序的外部属性，Config Server也称为分布式配置中心，本质上它就是一个独立的微服务应用，用来连接配置仓库并将获取到的配置信息提供给客户端使用；客户端就是我们的各个微服务应用，我们在客户端上指定配置中心的位置，客户端在启动的时候就会自动去从配置中心获取和加载配置信息。
Spring Cloud Config可以与任何语言运行的应用程序一起使用。服务器存储后端的默认实现使用git，因此它轻松支持配置信息的版本管理，当然我们也可以使用Git客户端工具来管理配置信息。

构建配置中心

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

入口类上添加@EnableConfigServer注解，表示开启配置中心服务端功能

@SpringBootApplication
@EnableConfigServer
public class ConfigserverApplication {

    public static void main(String[] args) {
        SpringApplication.run(ConfigserverApplication.class, args);
    }

}

在application.properties中配置一下git仓库的信息，这里就不自己搭建git服务端了，直接使用GitHub（当然也可以使用码云），这里需要我首先在我的Github上创建一个名为scConfig的项目，创建好之后，再做如下配置：

spring.application.name=configserver
server.port=2007
spring.cloud.config.server.git.uri=https://github.com/113XXXX/cloudconfig.git
spring.cloud.config.server.git.username=1135XXXX@qq.com
spring.cloud.config.server.git.password=200XXXX
spring.cloud.config.server.git.search-paths=client

1.服务名
2.端口
3.uri表示配置中心所在仓库的位置
4.search-paths表示仓库下的子目录
5.username表示你的GitHub用户名
6.password表示你的GitHub密码

构建配置仓库

需要在github上设置好配置中心，首先在本地建一个空文件夹，在该文件夹中创建一个文件夹叫configRepo，然后在configRepo中创建四个配置文件，如下：
Spring Cloud_第29张图片

如此之后，配置文件就上传到GitHub上了。此时启动我们的配置中心，通过/{application}/{profile}/{label}就能访问到我们的配置文件了，其中application表示配置文件的名字，对应我们上面的配置文件就是app，profile表示环境，我们有dev、test、prod还有默认，label表示分支，默认我们都是放在master分支上，我们在浏览器上访问结果如下
在这里插入图片描述
在这里插入图片描述客户端配置

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

创建bootstrap.properties文件，来获取配置信息，注意这些信息一定要放在bootstrap.properties文件中才有效

spring.application.name=client1
server.port=2008
spring.cloud.config.uri=http://127.0.0.1:2007
spring.cloud.config.label=master
spring.cloud.config.profile=dev

这里的name对应了配置文件中的application部分，profile对应了profile部分，label对应了label部分，uri则表示配置中心的地址。配置完成之后创建一个测试Controller

@RestController
public class HelloController {
    @Value("${i}")
    String i;

    @GetMapping("hello")
    public String hello(){
        return i;
    }
}

测试
在这里插入图片描述

Spring Cloud_第30张图片

加密解密

默认情况下我们的JRE中自带了JCE(Java Cryptography Extension)，但是默认是一个有限长度的版本，我们这里需要一个不限长度的JCE，这个JCE我们可以直接百度然后在Oracle官网下载，下载之后解压，我们可以看到如下三个文件：

Spring Cloud_第31张图片

我们需要将这里的两个jar包拷贝到我们的jdk安装目录下，\jre\lib\security，覆盖该目录下原有的文件

对称加解密

对称加解密比较简单，直接配置密钥就可以了，在我们前文创建出来的config-server中配置密钥，但是注意这个密钥需要配置在bootstrap.properties中，另外这里还有非常重要一点：Spring Cloud的Dalston.SR3和Dalston.SR2版本在这个问题上是有BUG的，如果用这两个版本在这里测试会没有效果，应该避开使用这两个版本，我这里使用的是Dalston.SR4版本

encrypt.key=123

配置完成之后，启动我们的config-server工程，然后访问如下地址http://localhost:2007/encrypt/status，如果看到如下访问结果，表示环境搭建成功了：
在这里插入图片描述

此时我们就可以通过第三方工具如POSTMAN、RestClient等来访问/encrypt和/decrypt接口，比如说我要给123这个字符加密，方式如下(我这里以POSTMAN为例，注意是POST请求)：
Spring Cloud_第32张图片
在这里插入图片描述
 配置文件的值如果是以{cipher}开头，表示该值是一个加密字符，配置中心config-server在获取到这个值之后会先对值进行解密，解密之后才会返回给客户端使用

服务化配置中心
 在config-client中配置config-server地址的时候都是直接将地址写死，这种方式显然不够灵活，这里可以结合eureka注册中心，然后在配置的时候直接使用服务名即可

config-server改造

  服务端改造和客户端改造都是分三步走：1.添加依赖；2.修改application.properties.

	<dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>

eureka.client.service-url.defaultZone=http://127.0.0.1:8761/eureka

config-client改造

	<dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>

spring.application.name=client1
server.port=2008
# spring.cloud.config.uri=http://127.0.0.1:2007
spring.cloud.config.label=master
spring.cloud.config.profile=test

eureka.client.service-url.defaultZone=http://127.0.0.1:8761/eureka
spring.cloud.config.discovery.enabled=true
spring.cloud.config.discovery.service-id=configserver

解释:
1.eureka.client.service-url.defaultZone设置了注册中心的地址,将config-client注册到eureka注册中心去
2.spring.cloud.config.discovery.enabled表示开启 通过服务名来访问config-server
3.spring.cloud.config.discovery.service-id=configserver表示config-server的服务名

失败快速响应

  不作任何额外配置的情况下，失败响应有点迟钝，举个简单的例子，关掉config-server，我们直接启动config-client，此时启动会报错，但是报错时间较晚，报错的时候系统已经打印了许多启动日志了，如果我们希望在启动失败时能够快速响应，方式很简单，config-client中添加如下配置即可：

spring.cloud.config.fail-fast=true

  此时不启动config-server直接启动config-client依然会报错，但是我们看到报错时间较早，系统都没打印几条启动日志。

重试机制
 如果由于网络抖动等原因导致config-client在启动时候访问config-server没有访问成功从而报错，遇到这种情况我们希望config-client最好能重试几次，重试机制在这里也是受支持的，引入依赖

<dependency>
     <groupId>org.springframework.retry</groupId>
     <artifactId>spring-retry</artifactId>
 </dependency>

# 配置重试次数,默认为6
spring.cloud.config.retry.max-attempts=10
# 初始化重试间隔时间,默认 1000ms
spring.cloud.config.retry.initial-interval=1000
# 最大间隔时间,默认 2000ms
spring.cloud.config.retry.max-interval=3000
# 间隔乘数,默认1.1
spring.cloud.config.retry.multiplier=1.2

在这里插入图片描述
动态刷新配置
  有的时候，动态的更新了Git仓库中的配置文件，那如何让我的config-client能够及时感知到呢？首先在config-client中添加如下依赖：

		<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>

该依赖中包含了/refresh端点的实现，我们将利用这个端点来刷新配置信息。然后需要在application.properties中配置忽略权限拦截：

management.endpoints.web.exposure.include=*

在这里插入图片描述

利用Git客户端工具，将app-dev.properties中的内容修改一下，修改成功之后，先用POST请求访问http://localhost:2008/refresh地址
在这里插入图片描述

Spring Cloud Bus

 Spring Cloud Bus也是微服务架构系统中的必备组件。
 Spring Cloud Bus可以将分布式系统的节点与轻量级消息代理链接，然后可以实现广播状态更改（例如配置更改）或广播其他管理指令。
 Spring Cloud Bus就像一个分布式执行器，用于扩展的Spring Boot应用程序，但也可以用作应用程序之间的通信通道。
 消息代理,Spring Cloud Bus支持RabbitMQ和Kafka

RabbitMQ安装配置

docker run -d --hostname my-rabbit --name some-rabbit -P rabbitmq:3-management

账号密码一致
Spring Cloud_第33张图片
Spring Cloud_第34张图片Spring Cloud_第35张图片
当我的微服务A/微服务B启动的时候，会从Config-Server中加载配置文件，而Config-Server则会通过git clone命令将配置中心的配置文件先clone下来在本地保存一份，然后再返回给微服务A/微服务B。
这是之前的工作流程，现在结合Spring Cloud Bus来实现配置文件的动态更新。
使用Spring Cloud Bus来实现配置文件的动态更新原理，如上图，当我的配置文件更新后，我向Config-Server中发送一个/bus/refresh请求，Config-Server收到这个请求之后，会将这个请求广播出去，这样所有的 微服务就都收到这个请求了，微服务收到这个请求之后就会 自动去更新自己的 配置文件。
在这个系统中，从RabbitMQ的角度来看，所有的微服务都是一样的，所以这个/bus/refresh请求我也可以在 微服务节点上发出，一样能够实现 配置文件动态更新的效果，但是这样做就 破坏了 微服务的结构，使得 微服务节点之间有了区别，所以 刷新配置的请求还是放在Config-Server上来做比较合适

1.工程创建
添加依赖
Spring Cloud_第36张图片

		<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-bus</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-stream-binder-rabbit</artifactId>
        </dependency>

2.属性配置
在application.properties中配置RabbitMQ的连接信息

spring.rabbitmq.port=32771
spring.rabbitmq.host=192.168.230.176
spring.rabbitmq.username=guest
spring.rabbitmq.password=guest

3.配置消息队列Bean

@SpringBootApplication
public class RabbitmqApplication {

    public static void main(String[] args) {
        SpringApplication.run(RabbitmqApplication.class, args);
    }

    @Bean
    Queue queue(){
        return new Queue("i.com");
    }
}

4.创建消息生产者

@SpringBootTest
class RabbitmqApplicationTests {

    @Autowired
    AmqpTemplate amqpTemplate;

    @Test
    void contextLoads() {
        amqpTemplate.convertAndSend("i.com","hello cloud bus");
    }
}

5.创建消息消费者

@Component
public class MessageConsumer {
    @RabbitListener(queues = "i.com")
    public void receive(String msg) {
        System.out.println(msg);
    }
}

Spring Cloud_第37张图片
在这里插入图片描述

在这里插入图片描述

Spring Cloud Stream

 Spring Cloud Stream是一个构建消息驱动的微服务框架。
 它构建在Spring Boot之上用以创建工业级的应用程序，并且通过Spring Integration提供了和消息代理的连接。
 Spring Cloud Stream为一些供应商的消息中间件产品提供了个性化的自动化配置实现(目前仅支持RabbitMQ和Kafka)，同时引入了发布订阅、消费组和分区的语义概念
Spring Cloud_第38张图片1.创建工程

	<dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-amqp</artifactId>
      </dependency>
      <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-web</artifactId>
      </dependency>
      <dependency>
          <groupId>org.springframework.cloud</groupId>
          <artifactId>spring-cloud-stream</artifactId>
      </dependency>
      <dependency>
          <groupId>org.springframework.cloud</groupId>
          <artifactId>spring-cloud-stream-binder-rabbit</artifactId>
      </dependency>

2.创建接收器

@EnableBinding(Sink.class)
public class MySink {
    @StreamListener(Sink.INPUT)
    public void receive(String msg) {
        System.out.println(msg);
    }
}

 使用了@EnableBinding注解实现对消息通道的绑定，在该注解中还传入了一个参数Sink.class，Sink是一个接口，该接口是Spring Cloud Stream中默认实现的对输入消息通道绑定的定义。
 然后在SinkReceiver类中定义了receive方法，并在该方法上添加了@StreamListener注解，该注解表示该方法为 消息中间件上 数据流的 事件监听器，Sink.INPUT参数表示这是input消息通道上的监听处理器

在这里插入图片描述

消息分组

 由于我们的服务可能会有多个实例同时在运行，如果不做任何设置，此时发送一条消息将会被所有的实例接收到，但是有的时候我们可能只希望消息被一个实例所接收，这个需求我们可以通过消息分组来解决。
 方式很简单，给项目配置消息组和主题，如下：

spring.cloud.stream.bindings.mychannel-input.destination=i
spring.cloud.stream.bindings.mychannel-output.destination=i

spring.cloud.stream.bindings.mychannel-input.group=i
spring.cloud.stream.bindings.mychannel-output.group=i

 这里我们设置该工程都属于 i 消费组，输入通道的主题名则为 i 。这里配置完成之后，我们在消息发送方做如下配置：

spring.cloud.stream.bindings.mychannel-output.destination=i

 也配置消息主题名为 i （如果发送和接收就在同一个应用中，则这里可以不配置）。
 此时我们将我们的项目启动两个实例，注意两个实例的端口不一样，此时如果我们再发送消息，
 则只会被两个实例中的一个接收到，另外一个应用则接收不到，但是到底是两个实例中的哪一个接收，则是随机的

消息分区
 有的时候，我们可能需要相同特征的消息能够总是被发送到同一个消费者上去处理，如果我们只是单纯的使用消费组则无法实现功能，此时我们需要借助于消息分区，消息分区之后，具有相同特征的消息就可以总是被同一个消费者处理了，配置方式如下(这里的配置都是在消费组的配置基础上完成的)：

消费者上添加如下配置:

# 消息输入通道配置
spring.cloud.stream.bindings.mychannel-input.consumer.partitioned=true
spring.cloud.stream.instance-count=2
spring.cloud.stream.instance-index=0
  1. 第一行 表示开启 消息分区
  2. 第二行 表示当前消费者 的总的实例个数
  3. 第三行 表示当前实例的索引,从 0 开始,当开启多实例时,需要在 启动时 在命令行配置索引

消息生产者上添加如下配置:

# 消息输出通道配置
spring.cloud.stream.bindings.mychannel-output.producer.partition-key-expression=payload
spring.cloud.stream.bindings.mychannel-outpot.producer.partition-count=2
  1. 第一行 配置了 分区键的表达式规则
  2. 第二行 设置了 消息分区数量

此时再次启动多个消费者实例，然后重复发送多条消息，这些消息都将被同一个消费者处理掉
Spring Cloud_第39张图片

你可能感兴趣的:(Spring Cloud)

  • SpringBlade dict-biz/list 接口 SQL 注入漏洞 文章永久免费只为良心 oracle数据库
    SpringBladedict-biz/list接口SQL注入漏洞POC:构造请求包查看返回包你的网址/api/blade-system/dict-biz/list?updatexml(1,concat(0x7e,md5(1),0x7e),1)=1漏洞概述在SpringBlade框架中，如果dict-biz/list接口的后台处理逻辑没有正确地对用户输入进行过滤或参数化查询（PreparedSta
  • spring如何整合druid连接池？ 惜.己 springspringjunit数据库javaidea后端xml
    目录spring整合druid连接池1.新建maven项目2.新建mavenModule3.导入相关依赖4.配置log4j2.xml5.配置druid.xml1)xml中如何引入properties2)下面是配置文件6.准备jdbc.propertiesJDBC配置项解释7.配置druid8.测试spring整合druid连接池1.新建maven项目打开IDE（比如IntelliJIDEA,Ecl
  • SpringCloudAlibaba—Sentinel(限流) 菜鸟爪哇
    前言：自己在学习过程的记录，借鉴别人文章，记录自己实现的步骤。借鉴文章：https://blog.csdn.net/u014494148/article/details/105484410Sentinel介绍Sentinel诞生于阿里巴巴，其主要目标是流量控制和服务熔断。Sentinel是通过限制并发线程的数量（即信号隔离）来减少不稳定资源的影响，而不是使用线程池，省去了线程切换的性能开销。当资源
  • springboot+vue项目实战一-创建SpringBoot简单项目 苹果酱0567 面试题汇总与解析springboot后端java中间件开发语言
    这段时间抽空给女朋友搭建一个个人博客，想着记录一下建站的过程，就当做笔记吧。虽然复制zjblog只要一个小时就可以搞定一个网站，或者用cms系统，三四个小时就可以做出一个前后台都有的网站，而且想做成啥样也都行。但是就是要从新做，自己做的意义不一样，更何况，俺就是专门干这个的，嘿嘿嘿要做一个网站，而且从零开始，首先呢就是技术选型了，经过一番思量决定选择-SpringBoot做后端，前端使用Vue做一
  • Spring MVC 全面指南：从入门到精通的详细解析 一杯梅子酱 技术栈学习springmvcjava
    引言：SpringMVC，作为Spring框架的一个重要模块，为构建Web应用提供了强大的功能和灵活性。无论是初学者还是有一定经验的开发者，掌握SpringMVC都将显著提升你的Web开发技能。本文旨在为初学者提供一个全面且易于理解的学习路径，通过详细的知识点分析和实际案例，帮助你快速上手SpringMVC，让学习过程既深刻又高效。一、SpringMVC简介1.1什么是SpringMVC？Spri
  • Spring Boot中实现跨域请求 BABA8891 springboot后端java
    在SpringBoot中实现跨域请求（CORS，Cross-OriginResourceSharing）可以通过多种方式，以下是几种常见的方法：1.使用@CrossOrigin注解在SpringBoot中，你可以在控制器或者具体的请求处理方法上使用@CrossOrigin注解来允许跨域请求。在控制器上应用：importorg.springframework.web.bind.annotation.
  • 博客网站制作教程 2401_85194651 javamaven
    首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
  • RabbitMQ生产者重复机制与确认机制 java炒饭小能手 java-rabbitmqrabbitmqjava
    重复机制生产者发送消息时，出现了网络故障，导致与MQ的连接中断。为了解决这个问题，SpringAMQP提供的消息发送时的重试机制。即：当RabbitTemplate与MQ连接超时后，多次重试。需要修该发送端模块的application.yaml文件，添加下面的内容：spring:rabbitmq:connection-timeout:1s#设置MQ的连接超时时间template:retry:ena
  • 非对称加密算法————RSA理论及详情 hu19930613
    转自：https://www.kancloud.cn/kancloud/rsa_algorithm/48484一、一点历史1976年以前，所有的加密方法都是同一种模式：（1）甲方选择某一种加密规则，对信息进行加密；（2）乙方使用同一种规则，对信息进行解密。由于加密和解密使用同样规则（简称"密钥"），这被称为"对称加密算法"（Symmetric-keyalgorithm）。这种加密模式有一个最大弱点
  • 加载资源时报错-ERR_CONNECTION_RESET，需要多次请求才能拿到资源的有效解决方案 Mebius1916 前端开发前端javascriptreact.js前端框架typescriptvue.js
    初次加载资源时无法正常加载，需要多次刷新、请求才能拿到资源的有效解决方案前言在使用cloudinary进行图片上传并获取图片链接作为用户头像时发现，图片链接网址初次加载会报错：ERR_CONNECTION_RESET必须刷新几次才能获取到，原因可能是cloudinary没有国内的节点，而我用的是在新加坡的节点，所以会导致初次加载的时候被重定向。而这个错误会直接导致用户头像无法加载，因为在img中此
  • 【Java】已解决：org.springframework.jdbc.datasource.lookup.DataSourceLookupFailureException 屿小夏 java开发语言
    文章目录一、分析问题背景问题背景描述出现问题的场景二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项已解决：org.springframework.jdbc.datasource.lookup.DataSourceLookupFailureException在使用Spring框架进行开发时，数据源的配置和使用是非常关键的一环。然而，有时候我们可能会遇到org.springframewo
  • SpringBoot和SpringMVC是什么关系?SpringBoot替代SpringMVC了吗? 瑞金彭于晏 springboot后端javaMVCspring数据库
    SpringBoot和SpringMVC都是SpringFramework生态系统中的一部分，但它们各自扮演着不同的角色和提供不同的功能集。理解它们之间的关系，首先需要了解SpringFramework本身。SpringFrameworkSpringFramework是一个全面的、开源的应用程序开发框架，它提供了广泛的功能来支持企业应用开发的几乎所有方面。SpringFramework的核心特性之
  • spring mvc @RequestBody String类型参数 zoyation spring-mvcspringmvc
    通过如下配置：text/html;charset=UTF-8application/json;charset=UTF-8在springmvc的Controller层使用@RequestBody接收Content-Type为application/json的数据时，默认支持Map方式和对象方式参数@RequestMapping(value="/{code}/saveUser",method=Requ
  • Java -jar 如何在后台运行项目 vincent_hahaha
    撸了今年阿里、头条和美团的面试，我有一个重要发现.......>>>说到运行jar包通常我们都会以下面的方式运行:java-jarspringboot-0.0.1-SNAPSHOT.jar这样运行的话会有一个问题，就是我们一关闭当前窗口就会停止运行项目，要想解决这个问题，就需要在后台运行。nohupjava-jarbabyshark-0.0.1-SNAPSHOT.jar >log.file 2>&
  • spring security中几大组件的作用和执行顺序 阿信在这里 javaspring
    springsecurity中几大组件的作用和执行顺序在SpringSecurity中，AuthenticationProvider、GroupPermissionEvaluator、PermissionEvaluator、AbstractAuthenticationProcessingFilter、DefaultMethodSecurityExpressionHandler和ManageSecu
  • 探索Zebra4J：构建高效企业级Web应用的微服务框架 叶准鑫Natalie
    探索Zebra4J：构建高效企业级Web应用的微服务框架ZebraZebra4J/Zebra4Js基于SpringBoot的JavaWeb/Nodejs框架项目地址:https://gitcode.com/gh_mirrors/zebra/Zebra项目介绍在当今快速发展的技术环境中，构建高效、可扩展的企业级Web应用是每个开发团队的追求。Zebra4J作为一款基于SpringBoot的全新微服务
  • 基于JavaWeb开发的Java+SpringMvc+vue+element实现上海汽车博物馆平台 网顺技术团队 成品程序项目javavue.js汽车课程设计springboot
    基于JavaWeb开发的Java+SpringMvc+vue+element实现上海汽车博物馆平台作者主页网顺技术团队欢迎点赞收藏⭐留言文末获取源码联系方式查看下方微信号获取联系方式承接各种定制系统精彩系列推荐精彩专栏推荐订阅不然下次找不到哟Java毕设项目精品实战案例《1000套》感兴趣的可以先收藏起来，还有大家在毕设选题，项目以及论文编写等相关问题都可以给我留言咨询，希望帮助更多的人文章目录基
  • 分布式锁和spring事务管理 暴躁的鱼 锁及事务分布式springjava
    最近开发一个小程序遇到一个需求需要实现分布式事务管理业务需求用户在使用小程序的过程中可以查看景点，对景点地区或者城市标记是否想去，那么需要统计一个地点被标记的人数，以及记录某个用户对某个地点是否标记为想去，用两个表存储数据，一个地点表记录改地点被标记的次数，一个用户意向表记录某个用户对某个地点是否标记为想去。由于可能有多个用户同时标记一个地点，每个用户在前端点击想去按钮之后，后台接收到请求，从数据
  • Java面试笔记记录6 今天背八股了吗 java面试笔记
    1.Spring是什么？特性？有哪些模块？Spring是一个轻量级、非入侵式的控制反转Ioc和面向切面AOP的框架。特性：1.Ioc和DISpring的核心就是一个大的工厂容器，可以维护所有对象的创建和依赖关系，Spring工厂用于生成Bean，并且管理Bean的生命周期，实现高内聚低耦合的设计理念。2.AOP编程Spring提供面向切面编程，可以方便实现对程序进行权限拦截、运行监控等切面功能。3
  • Sentinel 眼泪落在琴弦 springcloudjavajava
    Sentinel（服务熔断降级限流）1.引入spring-cloud-starter-alibaba-sentinel2.下载sentinel服务器3.配置application地址信息4.在控制台调整参数【默认所以流控设置保存在内存中，重启失效】5.想实时监控需每个微服务导入actuator，并配置application暴露所有端口6.自定义sentinel流控返回数据7.配置sentinel类
  • Spring @Async 深度解读：默认线程池执行器的配置与优化 小码快撩 springjava前端
    在Spring中，@Async注解用于异步执行方法。默认情况下，@Async注解的任务是由一个线程池执行的。然而，这个默认的线程池是如何初始化的呢？本文将深入探讨这一过程，帮助你理解Spring异步任务背后的线程池执行器的初始化原理。1.@Async的基本使用首先，让我们快速回顾一下@Async的基本用法。@Async通常用于标注在需要异步执行的方法上，比如：@Servicepublicclass
  • Sentinel实时监控不展示问题 朱杰jjj sentinelsentinel
    问题官方插件Endpoint支持，可以实时统计出SpringBoot的健康状况和请求的调用信息在使用Endpoint特性之前需要在Maven中添加spring-boot-starter-actuator依赖，并在配置中允许Endpoints的访问。SpringBoot1.x中添加配置management.security.enabled=false。暴露的endpoint路径为/sentinelS
  • 36. MyBatis如何支持多数据库操作？如何配置不同的数据源？ 这孩子叫逆 Mybatis笔记mybatis数据库
    在许多企业级应用中，可能需要访问多个数据库。MyBatis可以通过配置多个数据源和动态切换数据源来支持多数据库操作。下面介绍如何在MyBatis中配置和使用多个数据源。1.多数据源的基本配置1.1配置多个数据源要支持多个数据源，首先需要在Spring或SpringBoot中配置不同的数据源。假设我们要连接两个数据库db1和db2，可以通过以下步骤进行配置。SpringBoot示例：applicat
  • Cloud Native Weekly | 华为云抢先发布Redis5.0，红帽宣布收购混合云提供商 weixin_34302561 数据库devops大数据
    1——华为云抢先发布Redis5.02——DigitalOceanK8s服务正式上线3——红帽宣布收购混合云提供商NooBaa4——微软发布多项AzureKubernetes服务更新1华为云抢先发布Redis5.012月17日，华为云在DCS2.0的基础上，快人一步，抢先推出了新的Redis5.0产品，这是一个崭新的突破。目前国内在缓存领域的发展普遍停留在Redis4.0阶段，华为云率先发布了Re
  • Halo 开发者指南——容器私有化部署 SHENHUANJIE DockerHalo华为云SWRRegistry
    华为云SWR私有化部署镜像构建dockerbuild-thalo-dev/halo:2.20.0.上传镜像镜像标签sudodockertag{镜像名称}:{版本名称}swr.cn-south-1.myhuaweicloud.com/{组织名称}/{镜像名称}:{版本名称}sudodockertaghalo-dev/halo:2.20.0swr.cn-south-1.myhuaweicloud.co
  • SpringBoot整合ES搜索引擎 实现网站热搜词及热度计算 码踏云端 springbootElasticsearchspringbootelasticsearch后端热搜词热度计算java
    博主简介：历代文学网（PC端可以访问：https://literature.sinhy.com/#/literature?__c=1000，移动端可微信小程序搜索“历代文学”）总架构师，15年工作经验，精通Java编程，高并发设计，Springboot和微服务，熟悉Linux，ESXI虚拟化以及云原生Docker和K8s，热衷于探索科技的边界，并将理论知识转化为实际应用。保持对新技术的好奇心，乐于
  • Spring Security静态资源过滤（11） 小黑屋说YYDS spring
    在一个实际项目中，并非所有的请求都需要经过SpringSecurity过滤器，有一些特殊的请求，例如静态资源等，一般来说并不需要经过SpringSecurity过滤器链，用户如果访问这些静态资源，直接返回对应的资源即可。回顾关于WebSecurity的讲解，提到它里边维护了一个ignoredRequests变量,该变量，记录的就是所有需要被忽略的请求，这些被忽略的请求将不再经过SpringSecu
  • Spring Security定义多个过滤器链（10） 小黑屋说YYDS spring
    在SpringSecurity中可以同时存在多个过滤器链，一个WebSecurityConfigurerAdapter的实例就可以配置一条过滤器链。我们来看如下一个案例：@ConfigurationpublicclassSecurityConfig{@BeanUserDetailsServiceus(){InMemoryUserDetailsManagerusers=newInMemoryUser
  • java 技术 架构 相关文档 圣心 java架构开发语言
    在Java中，有许多不同的技术和架构，这里我将列举一些常见的Java技术和架构，并提供一些相关的文档资源。SpringFrameworkSpring是一个开源的Java/JavaEE全功能框架，以Apache许可证形式发布，提供了一种实现企业级应用的方法。官方文档：SpringFrameworkSpringBootSpringBoot是Spring的一个子项目，旨在简化创建生产级的Spring应用
  • Python国内常用镜像源和使用方法 wfqlt163 Python基础操作python开发语言
    常用的镜像源：1、企业镜像：豆瓣https://pypi.doubanio.com/simple/网易https://mirrors.163.com/pypi/simple/阿里云https://mirrors.aliyun.com/pypi/simple/腾讯云https://mirrors.cloud.tencent.com/pypi/simple2、高校镜像：清华大学（推荐）：https:/
  • 对于规范和实现，你会混淆吗？ yangshangchuan HotSpot
    昨晚和朋友聊天，喝了点咖啡，由于我经常喝茶，很长时间没喝咖啡了，所以失眠了，于是起床读JVM规范，读完后在朋友圈发了一条信息： JVM Run-Time Data Areas：The Java Virtual Machine defines various run-time data areas that are used during execution of a program. So
  • android 网络 百合不是茶 网络
    android的网络编程和java的一样没什么好分析的都是一些死的照着写就可以了,所以记录下来  方便查找   ,  服务器使用的是TomCat   服务器代码;  servlet的使用需要在xml中注册 package servlet; import java.io.IOException; import java.util.Arr
  • [读书笔记]读法拉第传 comsci 读书笔记
          1831年的时候,一年可以赚到1000英镑的人..应该很少的...       要成为一个科学家,没有足够的资金支持,很多实验都无法完成       但是当钱赚够了以后....就不能够一直在商业和市场中徘徊......
  • 随机数的产生 沐刃青蛟 随机数
    c++中阐述随机数的方法有两种：   一是产生假随机数（不管操作多少次，所产生的数都不会改变）          这类随机数是使用了默认的种子值产生的，所以每次都是一样的。   //默认种子 for (int i = 0; i < 5; i++) { cout<<
  • PHP检测函数所在的文件名 IT独行者 PHP函数
    很简单的功能，用到PHP中的反射机制，具体使用的是ReflectionFunction类，可以获取指定函数所在PHP脚本中的具体位置。 创建引用脚本。 代码：   [php]   view plain copy // Filename: functions.php    <?php&nbs
  • 银行各系统功能简介 文强chu 金融
    银行各系统功能简介 　 业务系统 核心业务系统 业务功能包括：总账管理、卡系统管理、客户信息管理、额度控管、存款、贷款、资金业务、国际结算、支付结算、对外接口等 清分清算系统 以清算日期为准，将账务类交易、非账务类交易的手续费、代理费、网络服务费等相关费用，按费用类型计算应收、应付金额，经过清算人员确认后上送核心系统完成结算的过程 国际结算系
  • Python学习1(pip django 安装以及第一个project) 小桔子 pythondjangopip
        最近开始学习python,要安装个pip的工具。听说这个工具很强大，安装了它，在安装第三方工具的话so easy!然后也下载了，按照别人给的教程开始安装，奶奶的怎么也安装不上！ 第一步：官方下载pip-1.5.6.tar.gz, https://pypi.python.org/pypi/pip easy! 第二部：解压这个压缩文件，会看到一个setup.p
  • php 数组 aichenglong PHP排序数组循环多维数组
    1 php中的创建数组 $product = array('tires','oil','spark');//array()实际上是语言结构而不  是函数 2 如果需要创建一个升序的排列的数字保存在一个数组中，可以使用range()函数来自动创建数组 $numbers=range(1,10)//1 2 3 4 5 6 7 8 9 10 $numbers=range(1,10,
  • 安装python2.7 AILIKES python
    安装python2.7 1、下载可从 http://www.python.org/进行下载#wget https://www.python.org/ftp/python/2.7.10/Python-2.7.10.tgz 2、复制解压 #mkdir -p /opt/usr/python #cp  /opt/soft/Python-2
  • java异常的处理探讨 百合不是茶 JAVA异常
    //java异常  /* 1，了解java 中的异常处理机制，有三种操作 a,声明异常  b,抛出异常  c,捕获异常 2，学会使用try-catch-finally来处理异常 3，学会如何声明异常和抛出异常 4，学会创建自己的异常   */   //2，学会使用try-catch-finally来处理异常  
  • getElementsByName实例 bijian1013 element
    实例1： <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/x
  • 探索JUnit4扩展：Runner bijian1013 java单元测试JUnit
            参加敏捷培训时，教练提到Junit4的Runner和Rule，于是特上网查一下，发现很多都讲的太理论，或者是举的例子实在是太牵强。多搜索了几下，搜索到两篇我觉得写的非常好的文章。         文章地址：http://www.blogjava.net/jiangshachina/archive/20
  • [MongoDB学习笔记二]MongoDB副本集 bit1129 mongodb
    1. 副本集的特性   1)一台主服务器(Primary),多台从服务器(Secondary)   2)Primary挂了之后，从服务器自动完成从它们之中选举一台服务器作为主服务器，继续工作，这就解决了单点故障，因此，在这种情况下，MongoDB集群能够继续工作   3)挂了的主服务器恢复到集群中只能以Secondary服务器的角色加入进来   2
  • 【Spark八十一】Hive in the spark assembly bit1129 assembly
    Spark SQL supports most commonly used features of HiveQL. However, different HiveQL statements are executed in different manners: 1. DDL statements (e.g. CREATE TABLE, DROP TABLE, etc.)
  • Nginx问题定位之监控进程异常退出 ronin47
    nginx在运行过程中是否稳定，是否有异常退出过？这里总结几项平时会用到的小技巧。 1. 在error.log中查看是否有signal项，如果有，看看signal是多少。 比如，这是一个异常退出的情况： $grep signal error.log 2012/12/24 16:39:56 [alert] 13661#0: worker process 13666 exited on s
  • No grammar constraints (DTD or XML schema).....两种解决方法 byalias xml
    方法一：常用方法   关闭XML验证 工具栏：windows => preferences => xml => xml files => validation => Indicate when no grammar is specified:选择Ignore即可。 方法二：（个人推荐） 添加 内容如下 <?xml version=
  • Netty源码学习-DefaultChannelPipeline bylijinnan netty
    package com.ljn.channel; /** * ChannelPipeline采用的是Intercepting Filter 模式 * 但由于用到两个双向链表和内部类，这个模式看起来不是那么明显，需要仔细查看调用过程才发现 * * 下面对ChannelPipeline作一个模拟，只模拟关键代码： */ public class Pipeline {
  • MYSQL数据库常用备份及恢复语句 chicony mysql
    备份MySQL数据库的命令，可以加选不同的参数选项来实现不同格式的要求。 mysqldump -h主机 -u用户名 -p密码 数据库名 > 文件 备份MySQL数据库为带删除表的格式，能够让该备份覆盖已有数据库而不需要手动删除原有数据库。 mysqldump -–add-drop-table -uusername -ppassword databasename > ba
  • 小白谈谈云计算--基于Google三大论文 CrazyMizzz Google云计算GFS
        之前在没有接触到云计算之前，只是对云计算有一点点模糊的概念，觉得这是一个很高大上的东西，似乎离我们大一的还很远。后来有机会上了一节云计算的普及课程吧，并且在之前的一周里拜读了谷歌三大论文。不敢说理解，至少囫囵吞枣啃下了一大堆看不明白的理论。现在就简单聊聊我对于云计算的了解。     我先说说GFS   &n
  • hadoop 平衡空间设置方法 daizj hadoopbalancer
    在hdfs-site.xml中增加设置balance的带宽，默认只有1M： <property>   <name>dfs.balance.bandwidthPerSec</name>     <value>10485760</value>     <description&g
  • Eclipse程序员要掌握的常用快捷键 dcj3sjt126com 编程
      判断一个人的编程水平，就看他用键盘多，还是鼠标多。用键盘一是为了输入代码（当然了，也包括注释），再有就是熟练使用快捷键。 曾有人在豆瓣评 《卓有成效的程序员》：“人有多大懒，才有多大闲”。之前我整理了一个 程序员图书列表，目的也就是通过读书，让程序员变懒。  程序员作为特殊的群体，有的人可以这么懒，懒到事情都交给机器去做，而有的人又可以那么勤奋，每天都孜孜不倦得
  • Android学习之路 dcj3sjt126com Android学习
    转自：http://blog.csdn.net/ryantang03/article/details/6901459 以前有J2EE基础，接触JAVA也有两三年的时间了，上手Android并不困难，思维上稍微转变一下就可以很快适应。以前做的都是WEB项目，现今体验移动终端项目，让我越来越觉得移动互联网应用是未来的主宰。 下面说说我学习Android的感受，我学Android首先是看MARS的视
  • java 遍历Map的四种方法 eksliang javaHashMapjava 遍历Map的四种方法
    转载请出自出处： http://eksliang.iteye.com/blog/2059996 package com.ickes; import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.Map.Entry; /** * 遍历Map的四种方式
  • 【精典】数据库相关相关 gengzg 数据库
    package C3P0; import java.sql.Connection; import java.sql.SQLException; import java.beans.PropertyVetoException; import com.mchange.v2.c3p0.ComboPooledDataSource; public class DBPool{
  • 自动补全 huyana_town 自动补全
    <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml&quo
  • jquery在线预览PDF文件，打开PDF文件 天梯梦 jquery
    最主要的是使用到了一个jquery的插件jquery.media.js，使用这个插件就很容易实现了。   核心代码 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.
  • ViewPager刷新单个页面的方法 lovelease androidviewpagertag刷新
      使用ViewPager做滑动切换图片的效果时，如果图片是从网络下载的，那么再子线程中下载完图片时我们会使用handler通知UI线程，然后UI线程就可以调用mViewPager.getAdapter().notifyDataSetChanged()进行页面的刷新，但是viewpager不同于listview，你会发现单纯的调用notifyDataSetChanged()并不能刷新页面
  • 利用按位取反（~）从复合枚举值里清除枚举值 草料场 enum
    以 C# 中的 System.Drawing.FontStyle 为例。   如果需要同时有多种效果， 如：“粗体”和“下划线”的效果，可以用按位或（|） FontStyle style = FontStyle.Bold | FontStyle.Underline;   如果需要去除 style 里的某一种效果，
  • Linux系统新手学习的11点建议 刘星宇 编程工作linux脚本
    　　随着Linux应用的扩展许多朋友开始接触Linux，根据学习Windwos的经验往往有一些茫然的感觉：不知从何处开始学起。这里介绍学习Linux的一些建议。 　　一、从基础开始：常常有些朋友在Linux论坛问一些问题，不过，其中大多数的问题都是很基础的。例如：为什么我使用一个命令的时候，系统告诉我找不到该目录，我要如何限制使用者的权限等问题，这些问题其实都不是很难的，只要了解了 Linu
  • hibernate dao层应用之HibernateDaoSupport二次封装 wangzhezichuan DAOHibernate
    /** * <p>方法描述:sql语句查询 返回List<Class> </p> * <p>方法备注: Class 只能是自定义类 </p> * @param calzz * @param sql * @return * <p>创建人：王川</p> * <p>创建时间：Jul
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他