SpringCloud快速入门（二），渣本Java开发小伙如何一步步成为架构师

本文主要是介绍SpringCloud快速入门（二），渣本Java开发小伙如何一步步成为架构师，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

Feign是Netfix开发的声明式、模板化的HTTP客户端，它可帮助我们更加快捷的调用HTTP API，其中支持自带的注解，JAX-Rs注解，SpringMVC注解，并且还整合了Ribbon与Eureka。通过使用Feign可以把Rest的请求进行隐藏，伪装成类似SpringMVC的Controller一样。你不用再自己拼接url，拼接参数等等操作，一切都交给Feign去做，十分方便。

Feign项目地址：https://github.com/OpenFeign/feign

在前面的学习中，我们使用了Ribbon的负载均衡功能，大大简化了远程调用时的代码：

String user = this.restTemplate.getForObject("http://service-provider/user/" + id, String.class); 

快速入门:

改造springboot-service-consumer工程：

导入依赖：

<dependency>

    <groupId>org.springframework.cloud</groupId>

    <artifactId>spring-cloud-starter-openfeign</artifactId>

</dependency> 

开启Feign功能：在启动类上，添加注解，@EnableFeignClients开启Feign功能

@SpringCloudApplication //组合注解，相当于@SpringBootApplication + @EnableDiscoveryClient + @EnableCircuitBreaker

@EnableFeignClients     //启用feign组件

public class SpringbootServiceConsumerApplication {



    /*@Bean

    @LoadBalanced  //开启负载均衡

    public RestTemplate restTemplate() {

        return new RestTemplate();

    }*/



    public static void main(String[] args) {

        SpringApplication.run(SpringbootServiceConsumerApplication.class, args);

    }



} 

删除RestTemplate：feign已经自动集成了Ribbon负载均衡的RestTemplate。所以，此处不需要再注册RestTemplate。

配置Feign的客户端：

在springboot-service-consumer工程中，添加UserClient接口：

//@FeignClient(value = "service-provider") // 标注该类是一个feign接口

@FeignClient(value = "service-provider",fallback = UserClientFallBack.class)

public interface UserClient {



    @GetMapping("user/{id}")

    User queryById(@PathVariable("id") Long id);

} 

• 首先这是一个接口，Feign会通过动态代理，帮我们生成实现类。这点跟mybatis的mapper很像

• @FeignClient，声明这是一个Feign客户端，类似@Mapper注解。同时通过value属性指定服务名称

• 接口中的定义方法，完全采用SpringMVC的注解，Feign会根据注解帮我们生成URL，并访问获取结果

改造原来的调用逻辑，调用UserClient接口：

@RestController

@RequestMapping("consumer/user")

public class UserController {



    @Autowired

    private UserClient userClient;



    @GetMapping

    public String queryUserById(@RequestParam("id") Long id){

        User user = this.userClient.queryUserById(id);

        return user.toString();

    }



} 

启动测试：

访问接口：

正常获取到了结果。

负载均衡与Hystrix支持：

Feign中本身已经集成了Ribbon依赖和自动配置，因此我们不需要额外引入依赖，也不需要再注册RestTemplate对象。

同时Feign默认也有对Hystrix的集成，只不过，默认情况下是关闭的。我们需要通过下面的参数来开启：(在springboot-service-consumer工程添加配置内容)：

feign:

  hystrix:

    enabled: true # 开启Feign的熔断功能 

但是，Feign中的Fallback配置不像hystrix中那样简单了。首先，我们要定义一个类UserClientFallback，实现刚才编写的UserClient，作为fallback的处理类

@Component

public class UserClientFallBack implements UserClient {

    @Override

    public User queryUserById(Long id) {

        User user = new User();

        user.setUsername("服务器正忙，请稍后再试！！！");

        return user;

    }

} 

然后在UserFeignClient中，指定刚才编写的实现类

@FeignClient(value = "service-provider", fallback = UserClientFallback.class) // 标注该类是一个feign接口

public interface UserClient {



    @GetMapping("user/{id}")

    User queryUserById(@PathVariable("id") Long id);

} 

重启测试：

请求压缩：

Spring Cloud Feign 支持对请求和响应进行GZIP压缩，以减少通信过程中的性能损耗。通过下面的参数即可开启请求与响应的压缩功能：

feign:

  compression:

    request:

      enabled: true # 开启请求压缩

    response:

      enabled: true # 开启响应压缩 

同时，我们也可以对请求的数据类型，以及触发压缩的大小下限进行设置：

feign:

  compression:

    request:

      enabled: true # 开启请求压缩

      mime-types: text/html,application/xml,application/json # 设置压缩的数据类型

      min-request-size: 2048 # 设置触发压缩的大小下限 

注：上面的数据类型、压缩大小下限均为默认值。

Zuul网关

===================================================================

通过前面的学习，使用Spring Cloud实现微服务的架构基本成型，大致是这样的：

• 使用Spring Cloud Netflix中的Eureka实现了服务注册中心以及服务注册与发现；

• 服务间通过Ribbon或Feign实现服务的消费以及均衡负载。

• 为了使得服务集群更为健壮，使用Hystrix的融断机制来避免在微服务架构中个别服务出现异常时引起的故障蔓延。

在该架构中，我们的服务集群包含：内部服务Service A和Service B，他们都会注册与订阅服务至Eureka Server，而Open Service是一个对外的服务，通过均衡负载公开至服务调用方。我们把焦点聚集在对外服务这块，直接暴露我们的服务地址，这样的实现是否合理，或者是否有更好的实现方式呢？

我们可以将权限控制这样的东西从我们的服务单元中抽离出去，而最适合这些逻辑的地方就是处于对外访问最前端的地方，我们需要一个更强大一些的均衡负载器的服务网关。

服务网关是微服务架构中一个不可或缺的部分。通过服务网关统一向外系统提供REST API的过程中，除了具备服务路由、均衡负载功能之外，它还具备了权限控制等功能。Spring Cloud Netflix中的Zuul就担任了这样的一个角色，为微服务架构提供了前门保护的作用，同时将权限控制这些较重的非业务逻辑内容迁移到服务路由层面，使得服务集群主体能够具备更高的可复用性和可测试性。

Zuul网关官网：https://github.com/Netflix/zuul

Zuul加入后的架构

不管是来自于客户端（PC或移动端）的请求，还是服务内部调用。一切对服务的请求都会经过Zuul这个网关，然后再由网关来实现 鉴权、动态路由等等操作。Zuul就是我们服务的统一入口。

快速入门

新建工程：

添加Zuul依赖：

工程目录：

pom.xml文件

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">

    <modelVersion>4.0.0</modelVersion>

    <parent>

        <groupId>org.springframework.boot</groupId>

        <artifactId>spring-boot-starter-parent</artifactId>

        <version>2.2.11.RELEASE</version>

        <relativePath/> <!-- lookup parent from repository -->

    </parent>

    <groupId>com.ly</groupId>

    <artifactId>ly-zuul</artifactId>

    <version>0.0.1-SNAPSHOT</version>

    <name>ly-zuul</name>

    <description>Demo project for Spring Boot</description>



    <properties>

        <java.version>1.8</java.version>

        <spring-cloud.version>Hoxton.SR9</spring-cloud.version>

    </properties>



    <dependencies>

        <dependency>

            <groupId>org.springframework.cloud</groupId>

            <artifactId>spring-cloud-starter-netflix-zuul</artifactId>

        </dependency>

        <dependency>

            <groupId>org.springframework.cloud</groupId>

            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>

            <version>2.0.0.RELEASE</version>

        </dependency>



        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter-test</artifactId>

            <scope>test</scope>

            <exclusions>

                <exclusion>

                    <groupId>org.junit.vintage</groupId>

                    <artifactId>junit-vintage-engine</artifactId>

                </exclusion>

            </exclusions>

        </dependency>



    </dependencies>



    <dependencyManagement>

        <dependencies>

            <dependency>

                <groupId>org.springframework.cloud</groupId>

                <artifactId>spring-cloud-dependencies</artifactId>

                <version>${spring-cloud.version}</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>



</project> 

新建application.yml文件，编写配置

server:

  port: 10010 #服务端口

spring:

  application:

    name: ly-zuul  #指定服务名 

编写引导类：

通过@EnableZuulProxy注解开启Zuul的功能：

@SpringBootApplication

@EnableZuulProxy // 开启网关功能

public class ItcastZuulApplication {



    public static void main(String[] args) {

        SpringApplication.run(ItcastZuulApplication.class, args);

    }

} 

编写路由规则：

我们需要用Zuul来代理service-provider服务，先看一下控制面板中的服务状态：

映射规则：

server:

  port: 10010

spring:

  application:

    name: ly-zuul



zuul:

  routes:

    service-provider: /service-provider/** #路由名称，可以随便起，习惯上是服务名

      path: /service-provider/**   # 这里是映射路径

      url: http://localhost:8081 # 映射路径对应的实际url地址 

我们将符合path 规则的一切请求，都代理到 url参数指定的地址

本例中，我们将 /service-provider/**开头的请求，代理到http://localhost:8081

启动测试:

访问的路径中需要加上配置规则的映射路径，我们访问：http://localhost:10010/service-provider/user/2

面向服务的路由

在刚才的路由规则中，我们把路径对应的服务地址写死了！如果同一服务有多个实例的话，这样做显然就不合理了。我们应该根据服务的名称，去Eureka注册中心查找 服务对应的所有实例列表，然后进行动态路由才对！

对ly-zuul工程修改优化，添加Eureka客户端依赖：

<dependency>

    <groupId>org.springframework.cloud</groupId>

    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>

</dependency> 

添加Eureka配置，获取服务信息：

eureka:

  client:

    registry-fetch-interval-seconds: 5 # 获取服务列表的周期：5s

    service-url:

      defaultZone: http://localhost:10086/eureka 

开启Eureka客户端发现功能：

@SpringBootApplication

@EnableZuulProxy  //启用zuul网关组件

@EnableDiscoveryClient  //启用客户端

public class LyZuulApplication {



    public static void main(String[] args) {

        SpringApplication.run(LyZuulApplication.class, args);

    }



} 

修改映射配置，通过服务名称获取:

因为已经有了Eureka客户端，我们可以从Eureka获取服务的地址信息，因此映射时无需指定IP地址，而是通过服务名称来访问，而且Zuul已经集成了Ribbon的负载均衡功能。

zuul:

  routes:

    service-provider: # 这里是路由id，随意写

      path: /service-provider/** # 这里是映射路径

      serviceId: service-provider # 指定服务名称 

启动测试:

再次启动，这次Zuul进行代理时，会利用Ribbon进行负载均衡访问：

路由配置的四种方式： (一般使用的是第三种)

zuul:

  routes:

    service-provider: 

      path: /service-provider/** #路由名称，可以随便起，习惯上是服务名

      url: http://localhost:8081

    

zuul:

  routes:

    service-provider:

      path: /service-provider/**   #路由名称，可以随便起，习惯上是服务名

      serviceId: service-provider  #指定服务名

      

#而大多数情况下,路由名称往往和服务名会写成一样的,因此Zuul就提供了一种简化的配置语法：

zuul:

  routes:

    service-provider: /provider/** #路由名称，可以随便起，习惯上是服务名

 

-不用配置，默认就是服务id开头路径 

-Zuul就指定了默认的路由规则：默认情况下,一切服务的映射路径就是服务名本身 

测试第三种方法：使用prefix: /*配置虚拟路径

zuul:

  routes:

    service-provider: /provider/** #路由名称，可以随便起，习惯上是服务名

  prefix: /api  #虚拟路径 

过滤器

Zuul作为网关的其中一个重要功能，就是实现请求的鉴权。而这个动作我们往往是通过Zuul提供的过滤器来实现的。

ZuulFilter：

ZuulFilter是过滤器的顶级父类。在这里我们看一下其中定义的4个最重要的方法：

public abstract ZuulFilter implements IZuulFilter{



    abstract public String filterType();



    abstract public int filterOrder();

    

    boolean shouldFilter();// 来自IZuulFilter



    Object run() throws ZuulException;// IZuulFilter

} 

• shouldFilter：返回一个Boolean值，判断该过滤器是否需要执行。返回true执行，返回false不执行。

• run：过滤器的具体业务逻辑。

• filterType：返回字符串，代表过滤器的类型。包含以下4种：

  • pre：请求在被路由之前执行

  • route：在路由请求时调用

  • post：在route和errror过滤器之后调用

  • error：处理请求时发生错误调用

• filterOrder：通过返回的int值来定义过滤器的执行顺序，数字越小优先级越高。

过滤器执行生命周期:

这张是Zuul官网提供的请求生命周期图，清晰的表现了一个请求在各个过滤器的执行顺序。

正常流程：

• 请求到达首先会经过pre类型过滤器，而后到达route类型，进行路由，请求就到达真正的服务提供者，执行请求，返回结果后，会到达post过滤器。而后返回响应。

异常流程：

• 整个过程中，pre或者route过滤器出现异常，都会直接进入error过滤器，在error处理完毕后，会将请求交给POST过滤器，最后返回给用户。

• 如果是error过滤器自己出现异常，最终也会进入POST过滤器，将最终结果返回给请求客户端。

• 如果是POST过滤器出现异常，会跳转到error过滤器，但是与pre和route不同的是，请求不会再到达POST过滤器了。

所有内置过滤器列表：

使用场景:

• 请求鉴权：一般放在pre类型，如果发现没有访问权限，直接就拦截了

• 异常处理：一般会在error类型和post类型过滤器中结合来处理。

• 服务调用时长统计：pre和post结合使用。

自定义过滤器:

接下来我们来自定义一个过滤器，模拟一个登录的校验。基本逻辑：如果请求中有access-token参数，则认为请求有效，放行。

定义过滤器类:

@Component

public class LoginFilter extends ZuulFilter {



    @Override

    public String filterType() {

        return "pre";

    }

这篇关于SpringCloud快速入门（二），渣本Java开发小伙如何一步步成为架构师的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！