文章目录
 
什么是动态路由和概述
动态路由特点
动态路由如何实现
动态路由协议
选择依据：度量值
收敛
动态路由协议分类
什么是RIP
RIP的基本概念
路由表的形成
RIP的度量值与更新时间
RIP协议防环机制
RIP路由协议版本区别
RIP配置命令

 
什么是动态路由和概述
 
动态路由是与静态路由相对的一个概念，指路由器能够根据路由器之间的交换的特定路由信息自动地建立自己的路由表，并且能够根据链路和节点的变化适时地进行自动调整。当网络中节点或节点间的链路发生故障，或存在其它可用路由时，动态路由可以自行选择最佳的可用路由并继续转发报文。
 动态路由概述：动态路由概述：路由器之间用来交换信息的语言
 
动态路由特点
 
1.减少了网络管理
 2.占用了网络带宽（少量，可忽略不计）
 
动态路由如何实现
 
基于某种路由协议实现
 
动态路由协议
 
路由之间用来交换信息的语言
 
选择依据：度量值
 
跳数、带宽、时延、可靠性、成本、负载
 路由器会通过度量值来确定最优路由路径
 
收敛
 
使所有路由器都到达一致状态的过程
 
动态路由协议分类
 
距离矢量路由协议
 ——依据从源网络到目标网络所经过的路由器的个数选择路由 - - RIP、IGIP（思科私有协议）
 链路状态路由协议
 ——综合考虑从源网络到目标网络的各条路径的情况选择路由 - - OSPF、ISIS
 
什么是RIP
 
RIP(Routing Information Protocol,路由信息协议）是一种内部网关协议（IGP），是一种动态路由选择协议，用于自治系统（AS）内的路由信息的传递。RIP协议基于距离矢量算法（DistanceVectorAlgorithms），使用“跳数”(即metric)来衡量到达目标地址的路由距离。这种协议的路由器只关心自己周围的世界，只与自己相邻的路由器交换信息，范围限制在15跳(15度)之内，再远，它就不关心了。RIP应用于OSI网络七层模型的应用层。各厂家定义的管理距离（AD，即优先级）如下：华为定义的优先级是100，思科定义的优先级是120。
 
RIP的基本概念
 
RIP是距离矢量路由选择协议
 定期更新（更新路由表）
 邻居
 广播更新
 全路由表更新
 RIP有两个版本：广播更新、组播更新
 
路由表的形成
 
1.路由器会学习到直连路由
 2.rip更新周期30s，每30s路由器会向邻居发送路由表
 3.路由器学习到相邻路由的非直连网段
 4.从哪个接口上学习过来的，nexthop下一跳就是那个接口
 5.再过30s，第二个更新周期到了再次发送路由表，路由器学习并再次更新路由条目
 
RIP的度量值与更新时间
 
RIP度量值为跳数
 ——最大跳数为15跳，16跳为不可达
 RIP更新时间
 ——每隔30s发送路由更新消息，UDP520端口
 RIP路由更新消息
 ——发送整个路由表信息
 
RIP协议防环机制
 
路由毒化：
 ——当路由器发现路由链路进行变更或者down掉后，会将这个路由毒化，标志为16跳，不可达
 水平分割：
 水平分割可以阻止路由环路的发生
 ——从一个接口学习到路由信息，不再从这个接口发送回去，同时也能减少路由更新信息占用的链路带宽资源
 
RIP路由协议版本区别
 

 1.版本1是有类路由协议，有固定边界，不能进行子网划分
 2.版本1是通过广播更新的，版本2是组播224.0.0.9
 3.版本1自动路由汇总无法关闭，版本2是支持自动路由汇总，可以手动关闭
 4.版本1不支持不连续子网，版本2支持不连续子网
 
RIP配置命令
 
【R1】rip 1 启动RIP
 【R1 - rip - 1】version 2 启动版本2（缺省版本1）
 【R1 - rip - 1】undo summary 关闭路由自动聚合（即所有路由信息都会按照IP地址分类归类）
 【R1 - rip - 1】network x.x.x.x 宣告网段
 【R1 - rip - 1】network x.x.x.x 宣告网段

gateway配置路由主要有两种方式，一种是用yml配置文件，一种是写代码里，这两种方式都是不支持动态配置的。如：
 
 
下面就来看看gateway是如何加载这些配置信息的。
 
1 路由初始化
 
无论是yml还是代码，这些配置最终都是被封装到RouteDefinition对象中。
 
 
一个RouteDefinition有个唯一的ID，如果不指定，就默认是UUID，多个RouteDefinition组成了gateway的路由系统。
 
所有路由信息在系统启动时就被加载装配好了，并存到了内存里。我们从源码来看看。
 
圆圈里就是装配yml文件的，它返回的是PropertiesRouteDefinitionLocator，该类继承了RouteDefinitionLocator，RouteDefinitionLocator就是路由的装载器，里面只有一个方法，就是获取路由信息的。该接口有多个实现类，分别对应不同方式配置的路由方式。
 
 
 
 
通过这几个实现类，再结合上面的AutoConfiguration里面的Primary信息，就知道加载配置信息的顺序。
 
PropertiesRouteDefinitionLocator-->|配置文件加载初始化| CompositeRouteDefinitionLocator
 RouteDefinitionRepository-->|存储器中加载初始化| CompositeRouteDefinitionLocator
 DiscoveryClientRouteDefinitionLocator-->|注册中心加载初始化| CompositeRouteDefinitionLocator
 
参考：https://www.jianshu.com/p/b02c7495eb5e
 
https://blog.csdn.net/X5fnncxzq4/article/details/80221488
 
 
这是第一顺序，就是从CachingRouteLocator中获取路由信息，我们可以打开该类进行验证。
 
不管发起什么请求，必然会走上面的断点处。请求一次，走一次。这是将路由信息缓存到了Map中。配置信息一旦请求过一次，就会被缓存到上图的CachingRouteLocator类中，再次发起请求后，会直接从map中读取。
 
如果想动态刷新配置信息，就需要发起一个RefreshRoutesEvent的事件，上图的cache会监听该事件，并重新拉取路由配置信息。
 
通过下图，可以看到如果没有RouteDefinitionRepository的实例，则默认用InMemoryRouteDefinitionRepository。而做动态路由的关键就在这里。即通过自定义的RouteDefinitionRepository类，来提供路由配置信息。
 
 
例如：
 
 
在getRouteDefinitions方法返回你自定义的路由配置信息即可。这里可以用数据库、nosql等等任意你喜欢的方式来提供。而且配置信息修改后，发起一次RefreshRoutesEvent事件即可让配置生效。这就是动态配置路由的核心所在，下面来看具体代码实现。
 
2 基于数据库、缓存的动态路由
 
pom.xml如下
 
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.maimeng</groupId>
    <artifactId>apigateway</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

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

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.6.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
        <spring-cloud.version>Finchley.SR1</spring-cloud.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-gateway</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-webflux</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.51</version>
        </dependency>
        <!--<dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </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>${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>
 
 
注意这里是SR1，经测试SR2有bug，会出问题。
 
@Configuration
public class RedisConfig {

    @Bean(name = {"redisTemplate", "stringRedisTemplate"})
    public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory factory) {
        StringRedisTemplate redisTemplate = new StringRedisTemplate();
        redisTemplate.setConnectionFactory(factory);
        return redisTemplate;
    }

}
 
核心类：
 
@Component
public class RedisRouteDefinitionRepository implements RouteDefinitionRepository {

    public static final String GATEWAY_ROUTES = "geteway_routes";

    @Resource
    private StringRedisTemplate redisTemplate;

    @Override
    public Flux<RouteDefinition> getRouteDefinitions() {
        List<RouteDefinition> routeDefinitions = new ArrayList<>();
        redisTemplate.opsForHash().values(GATEWAY_ROUTES).stream()
                .forEach(routeDefinition -> routeDefinitions.add(JSON.parseObject(routeDefinition.toString(), RouteDefinition.class)));
        return Flux.fromIterable(routeDefinitions);
    }

    @Override
    public Mono<Void> save(Mono<RouteDefinition> route) {
        return null;
    }

    @Override
    public Mono<Void> delete(Mono<String> routeId) {
        return null;
    }

}
 
主要是在get方法里，此处从redis里获取配置好的Definition。
 
然后我们的工作就是将配置信息，放到redis里即可。
 
下面就是我模拟的一个配置，等同于在yml里
 
spring:
  cloud:
    gateway:
      routes:
      - id: header
        uri: http://localhost:8888/header
        filters:
        - AddRequestHeader=header, addHeader
        - AddRequestParameter=param, addParam
        predicates:
        - Path=/jd
 
@Resource
    private StringRedisTemplate redisTemplate;
    @PostConstruct
    public void main() {
        RouteDefinition definition = new RouteDefinition();
        definition.setId("id");
        URI uri = UriComponentsBuilder.fromHttpUrl("http://127.0.0.1:8888/header").build().toUri();
       // URI uri = UriComponentsBuilder.fromHttpUrl("http://baidu.com").build().toUri();
        definition.setUri(uri);

        //定义第一个断言
        PredicateDefinition predicate = new PredicateDefinition();
        predicate.setName("Path");

        Map<String, String> predicateParams = new HashMap<>(8);
        predicateParams.put("pattern", "/jd");
        predicate.setArgs(predicateParams);

        //定义Filter
        FilterDefinition filter = new FilterDefinition();
        filter.setName("AddRequestHeader");
        Map<String, String> filterParams = new HashMap<>(8);
        //该_genkey_前缀是固定的，见org.springframework.cloud.gateway.support.NameUtils类
        filterParams.put("_genkey_0", "header");
        filterParams.put("_genkey_1", "addHeader");
        filter.setArgs(filterParams);

        FilterDefinition filter1 = new FilterDefinition();
        filter1.setName("AddRequestParameter");
        Map<String, String> filter1Params = new HashMap<>(8);
        filter1Params.put("_genkey_0", "param");
        filter1Params.put("_genkey_1", "addParam");
        filter1.setArgs(filter1Params);

        definition.setFilters(Arrays.asList(filter, filter1));
        definition.setPredicates(Arrays.asList(predicate));

        System.out.println("definition:" + JSON.toJSONString(definition));
        redisTemplate.opsForHash().put(GATEWAY_ROUTES, "key", JSON.toJSONString(definition));
    }
 
定义好后，将其放到redis里，之后启动项目访问/jd，再启动后台的localhost:8888项目。即可进行验证。
 
之后如果要动态修改配置，就可以通过类似于上面的方式，来获取json字符串，然后将字符串放到redis里进行替换。替换后，需要通知gateway主动刷新一下。
 
 
 
刷新时，可以定义一个controller，然后调用一下notifyChanged()方法，就能完成新配置的替换了。
 
3 通过REST接口
 
gateway是自带接口能增删改查配置的，这个网上有比较多的教程，随便找个看看就明白了。譬如：
 
http://springcloud.cn/view/368
 
我发个类作为参考
 
package com.maimeng.apigateway.route;

import com.alibaba.fastjson.JSON;
import org.springframework.cloud.gateway.event.RefreshRoutesEvent;
import org.springframework.cloud.gateway.filter.FilterDefinition;
import org.springframework.cloud.gateway.handler.predicate.PredicateDefinition;
import org.springframework.cloud.gateway.route.RouteDefinition;
import org.springframework.cloud.gateway.route.RouteDefinitionWriter;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.context.ApplicationEventPublisherAware;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.web.util.UriComponentsBuilder;
import reactor.core.publisher.Mono;

import javax.annotation.PostConstruct;
import javax.annotation.Resource;
import java.net.URI;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

import static com.maimeng.apigateway.repository.RedisRouteDefinitionRepository.GATEWAY_ROUTES;

/**
 * @author wuweifeng wrote on 2018/10/25.
 */
@Service
public class DynamicRouteService implements ApplicationEventPublisherAware {

    @Resource
    private RouteDefinitionWriter routeDefinitionWriter;

    private ApplicationEventPublisher publisher;

    private void notifyChanged() {
        this.publisher.publishEvent(new RefreshRoutesEvent(this));
    }


    /**
     * 增加路由
     *
     */
    public String add(RouteDefinition definition) {
        routeDefinitionWriter.save(Mono.just(definition)).subscribe();
        notifyChanged();
        return "success";
    }


    /**
     * 更新路由
     */
    public String update(RouteDefinition definition) {
        try {
            this.routeDefinitionWriter.delete(Mono.just(definition.getId()));
        } catch (Exception e) {
            return "update fail,not find route  routeId: " + definition.getId();
        }
        try {
            routeDefinitionWriter.save(Mono.just(definition)).subscribe();
            notifyChanged();
            return "success";
        } catch (Exception e) {
            return "update route  fail";
        }


    }

    /**
     * 删除路由
     *
     */
    public String delete(String id) {
        try {
            this.routeDefinitionWriter.delete(Mono.just(id)).subscribe();

            notifyChanged();
            return "delete success";
        } catch (Exception e) {
            e.printStackTrace();
            return "delete fail";
        }

    }

    @Override
    public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher) {
        this.publisher = applicationEventPublisher;
    }

    @Resource
    private StringRedisTemplate redisTemplate;
    @PostConstruct
    public void main() {
        RouteDefinition definition = new RouteDefinition();
        definition.setId("id");
        URI uri = UriComponentsBuilder.fromHttpUrl("http://127.0.0.1:8888/header").build().toUri();
       // URI uri = UriComponentsBuilder.fromHttpUrl("http://baidu.com").build().toUri();
        definition.setUri(uri);

        //定义第一个断言
        PredicateDefinition predicate = new PredicateDefinition();
        predicate.setName("Path");

        Map<String, String> predicateParams = new HashMap<>(8);
        predicateParams.put("pattern", "/jd");
        predicate.setArgs(predicateParams);

        //定义Filter
        FilterDefinition filter = new FilterDefinition();
        filter.setName("AddRequestHeader");
        Map<String, String> filterParams = new HashMap<>(8);
        //该_genkey_前缀是固定的，见org.springframework.cloud.gateway.support.NameUtils类
        filterParams.put("_genkey_0", "header");
        filterParams.put("_genkey_1", "addHeader");
        filter.setArgs(filterParams);

        FilterDefinition filter1 = new FilterDefinition();
        filter1.setName("AddRequestParameter");
        Map<String, String> filter1Params = new HashMap<>(8);
        filter1Params.put("_genkey_0", "param");
        filter1Params.put("_genkey_1", "addParam");
        filter1.setArgs(filter1Params);

        definition.setFilters(Arrays.asList(filter, filter1));
        definition.setPredicates(Arrays.asList(predicate));

        System.out.println("definition:" + JSON.toJSONString(definition));
        redisTemplate.opsForHash().put(GATEWAY_ROUTES, "key", JSON.toJSONString(definition));
    }
}
 
 

动态路由协议（动态路由和rip）
 
动态路由协议通过路由信息的交换生成并维护转发引擎所需的路由表。当网络拓扑结构改变时动态路由协议可以自动更新路由表，并负责决定数据传输最佳路径。
 在动态路由中，管理员不再需要与静态路由一样，手工对路由器上的路由表进行维护，而是在每台路由器上运行一个路由协议。这个路由协议会根据路由器上的接口的配置（如IP地址的配置）及所连接的链路的状态，生成路由表中的路由表项。
 


 
文章目录
 
动态路由协议（动态路由和rip）
动态路由
动态路由概述
动态路由协议基础
动态路由协议分类
  
rip路由协议
rip路由协议的工作原理
rip路由协议的配置
 

 
动态路由
 
路由行为指的是，当网络设备收到一个IP报文时，会在自己的路由表（Routing-table）中查询报文的目的IP地址，如果能够找到匹配给目的IP地址的路由表项，则根据该表项所指示的下一跳及出接口转发报文；如果没有任何路由表项匹配，则丢弃该报文。
 路由的行为是逐跳的，因此报文从源去往目的地的过程中，沿途的每一个参与数据转发的网络设备都需要具有关于目的网络的路由。
 
动态路由概述
 
动态路由
 基于某种路由协议实现
 
动态路由特点
 
减少了管理任务
占用了网络带宽
 
查看路由表
 
display ip routing-table
 
动态路由协议基础
 
动态路由协议概述
 路由器之间用来交换信息的语言
 
度量值
 跳数、带宽、负载、时延、可靠性、成本
 跳数指的是去往目标网络所需要经过的路由器个数。
 
 
收敛
 使所有路由器都达到一致状态的过程
 
静态路由和动态路由的比较
 网络中静态路由和动态路由互相补充
 
动态路由协议分类
 
按照路由执行的算法分类
 距离矢量路由协议
 依据从源网络到目标网络所经过的路由器的个数选择路由
 RIP、IGRP
 
链路状态路由协议
 综合考虑从源网络到目标网络的各条路径的情况选择路由
 OSPF、IS-IS
 
 
rip路由协议
 
RIP（Routing　Information　Protocols，路由信息协议）。
 是应用较早的内部网关协议（IGP）。
 
RIP是距离矢量路由选择协议
 适用于小型网络，是典型的距离矢量协议。
 RIP基于UDP，端口520。
 路由优先级为100。
 RIP有三个版本：RIPv1、RIPv2及RIPng。
 
rip路由协议的工作原理
 
RIP的基本概念
 定期更新（路由每经过一个指定的时间周期，向其他邻居发送更新信息。因此距离矢量路由协议更新方式也被称为‘逐跳’更新，在RFC2453文档中把RIP的更新时间定义为30S）
 
邻居(与其相连的路由器)在距离矢量具有协议中，可以额理解与其直接相连的路由器
 
广播更新(Ripv1 255.255.255.255)
 
组播更新(Ripv2 224.0.0.9)
 
泛洪路由表(路由器将从邻居学习到的路由放进自己的路由表中，然后将路由表所有路由信息在通告给其他路由器，直到整个网络学习到)
 
Metric：也称为度量值，RIP协议以Hop（跳数）作为度量值，每经过一台设备被视为1跳，RIP协议最大跳数15跳，而16跳是一个无穷大的值，如果为该值，可视为不可达
 
最大跳数的设定虽然解决了度量值技术到无穷大的问题，但是却也极大地限制了RIP所能支持的网络的规模。
 
RIPv1报文格式
 RIPv2报文格式
 区别：
 1.RIP1是一个有类路由协议，即所有的更新包中不含子网掩码，不支持VLSM，
 所以就要求网络中所有设备必须使用相同的子网掩码，否则就会出错，
 而RIP2是一个无类的路由协议，它使用子网掩码。
 
2.第二个不同的地方是RIP1是发送更新包的时候使用的是广播包，
 而RIP2默认使用的是组播224.0.0.9，也支持广播发送，
 这样相对于RIP1来说就节省了一部分网络带宽。
 
3.第三个就是RIP2支持明文或者是 MD5验证，要求两台路由器在同步路由表的时候必须进行验证，
 通过才可以进行路由同步，这样可以加强安全性。
 
rip路由协议的配置
 
rip 1   ###起rip进程
version 2    ###开启RIP 2版本
network  网络号  ###把要宣告的网段说出去  2个路由器的网段必须要宣告，否则不能建立关系
 
例如：
 
 
rip 1
version 2
network 192.168.1.0
network 192.168.12.0

定义
 
静态路由：是指路由器中设置固定的路由表，除非网络管理员进行干预，否则静态路由项不会发生变化。
动态路由：是指路由器能够自动建立路由表，根据网络中路由器之间通信，传递信息，利用收到的路由信息更新路由表。
优点
 
静态路由：简单、高效、可靠、网络安全、转发效率高、不占用网络带宽。
动态路由：灵活，能够自动适应网络结构的变化，无需管理员手工维护，减轻了管理员的工作负担。
缺点
 
静态路由：网络管理员难以了解整个网络的拓扑结构、网络状态动态变化时需要大范围的调整、生故障时不能重选路由。​​​​​​​
动态路由：占用网络带宽（用于传输路由更新信息）、安全性不如静态路。
使用场景
 
静态路由：网络规模小，拓扑固定的网络。
动态路由：网络规模大，拓扑复杂的网络。