rip协议java模拟实现

大二下学期的计算机网络原理课程设计

已同步github

url:https://github.com/leiflee/ripdemo

git:https://github.com/leiflee/ripdemo.git

一、设计题目：距离矢量路由选择算法的模拟实现

二、设计要求

（1）掌握距离矢量路由选择选择算法的工作原理。

（2）采用C、Java等编程语言实现距离矢量路由选择选择算法。

算法输入：

带权图G，如图1所示。

算法输出：

（1）某个顶点v（路由器）在第i次周期后的整个路由表。

（2）路由表的结构<目的网络，跳数，下一跳>

三、设计思路

距离矢量路由选择选择算法有多种，本设计采用的是比较经典的RIP协议，根据设计要求，只要求输出路由器在第i次周期后的整个路由表，为突出设计要求，本设计简化了RIP协议，与RIPv1，RIPv2和RIPng相比，本设计精简了水平分割、毒性逆转和抑制计时功能，本设计采用手动触发更新，即：手动输入循环周期i次，然后执行i次更新，并输出结果。

系统中涉及到三个对象，network，router，routertable，分别表示网络空间，路由器，路由表。其中，系统一共具有1个网络，网络中包括至少一个路由器，每个路由器拥有一个路由表。

系统执行大致分为三个阶段：

阶段一，系统读取配置文件./config/network.properties，通过其中的配置项来初始化网络空间，建立路由表，建立邻接关系。

阶段二，系统提示用户输入周期i，用户将输入反馈给系统。

阶段三，系统根据用户输入，执行响应轮次的路由表更新，输出结果。

配置文件书写规则：

e.g.

routernum=6     //路由器数量networknum=7     //网络数量0=0              //左侧表示路由器编号，右侧表示网络编号1=0,1,3,4        //路由器和网络号都从0开始计数2=1,2           //右侧为该路由器连接的网络，中间用英文","隔开3=3,64=35=4,5

四、源码

//Index.java   主类package rip;import java.util.Scanner;public class Index {    public static void main(String[] args){        Network network = new Network();        network.initNetwork();        network.setnearRouter();        System.out.print("请输入循环轮次:");        Scanner in = new Scanner(System.in);        int i = in.nextInt();        in.close();        for(int j = 0; j < i; j++){            System.out.println("=========================循环轮次"+(j+1)+"===========================");            network.changeAllRouter();        }    }}

//Network.java 网络空间类package rip;import java.util.HashMap;public class Network {    private  int   routernum;    private  int   networknum;    public Router[] routers;    public int getRouternum() {        return routernum;    }    public void setRouternum(int routernum) {        this.routernum = routernum;    }    public int getNetworknum() {        return networknum;    }    public void setNetworknum(int networknum) {        this.networknum = networknum;    }    public Router[] getRouters() {        return routers;    }    public void setRouters(Router[] routers) {        this.routers = routers;    }    public Network() {        super();    }    public void initNetwork(){        HashMap<String, String[]> netconf = Util.readNetworkConfig();        setRouternum(Integer.parseInt(netconf.get("routernum")[0]));        setNetworknum(Integer.parseInt(netconf.get("networknum")[0]));        //TODO 建立各路由器以及路由表       !important        Router routerssss[] = new Router[routernum];        for (int i = 0; i < routernum; i++) {            HashMap<Integer, String[]> list = new HashMap<>();            String[] strings = netconf.get(String.valueOf(i));            for(int j = 0; j < strings.length;j++){                String[] temp = {strings[j],"1", String.valueOf(i)};                list.put(j, temp);            }            RouterTable routerTable = new RouterTable(list, i);            Router router = new Router(i, routerTable);            routerssss[i] = router;        }        setRouters(routerssss);    }    public void setnearRouter(){        for (int i = 0; i < routers.length; i++) {            String str1 = Util.intArray2string(routers[i].getNearNetwork());            String str3 = "";            for(int j = 0; j < routers.length; j++){                String str2 = Util.intArray2string(routers[j].getNearNetwork());                for(int k = 0; k < str2.length(); k++){                    if (str1.contains(str2.substring(k, k+1))) {                        str3 += j;                        break;                    }                }            }            if (str3.length() > 0) {                int p[] = new int[str3.length()];                for (int j = 0; j < str3.length(); j++) {                    p[j] = Integer.parseInt(str3.substring(j, j+1));                }                routers[i].setNearRouter(p);            }        }    }    public void changeAllRouter(){        //TODO for 循环，每个路由器获取其临近路由器的路由表，然后更新自己的路由表        for(int i = 0; i < routers.length; i++){//          System.out.println("外循环********************路由器"+i+"开始获取路由表");            for(int j = 0; j < routers[i].getNearRouter().length; j++){//              System.out.println("内循环********************路由器了获取路由表"+j);                routers[i].changeRouterTable(routers[routers[i].getNearRouter()[j]].getRouterTable());            }            routers[i].echoRoutertable();        }    }}

// Router.java 路由器类package rip;import java.util.HashMap;public class Router {    private  final int routerId;    private RouterTable routerTable;    private int[] nearRouter;    private int[] nearNetwork;    public RouterTable getRouterTable() {        return routerTable;    }    public void setRouterTable(RouterTable routerTable) {        this.routerTable = routerTable;    }    public void changeRouterTable(RouterTable otherRouterTable){        // 规则：                // 1.  传入的为其临近路由器的路由表                // 2. 解析路由表                // 3. 如果有自己路由表里有的网络，检查跳数是否为15，不为15进行以下操作                // 4. 如果“跳数+1” 小于 本路由表对应条目的跳数，则修改记录                // 5. 修改记录 “网络号(不变)”，“跳数+1”,“下一跳路由(该路由条目的来源路由)”                 // 6. else如果有本自己路由表里没有的网路，检查跳数是否为15，不为15进行以下操作                // 7. 添加记录 “网络号”，“跳数+1”,“下一跳路由(该路由条目的来源路由)”        //将自己的路由表里 所有的网络号建立一个String，所有的跳数建立一个String，        //遍历外来路由表的各个网络号，判断是否存在相同的值        //如果存在 判断跳数（1.是否不等于15，2，是否小于自己对应的跳数+1）        //          如果满足，修改路由表对应数据        //           如果不满足。do nothing        //如果不存在，判断跳数是否不等于15，        //            如果满足，添加该路由条目            HashMap<Integer, String[] > otherList = otherRouterTable.getList();            HashMap<Integer, String[] > selfList = routerTable.getList();            String otherNetnum = "";            String otherTiaonum = "";            String selfNetnum = "";            String selfTiaonum = "";            String selfShouldMod = "";            String otherShouldMod = "";            String shouldAdd = "";            for(int i = 0 ; i < otherList.size(); i++){                otherNetnum += otherList.get(i)[0];                otherTiaonum += otherList.get(i)[1];            }            for(int i = 0; i < selfList.size(); i++){                selfNetnum += selfList.get(i)[0];                selfTiaonum += selfList.get(i)[1];            }            for(int i = 0; i < otherNetnum.length(); i++){//              System.out.println("第"+i+"循环检验========================");                int res = selfNetnum.indexOf(otherNetnum.substring(i,i+1));                int p = Integer.parseInt(otherTiaonum.substring(i, i+1));                if (res != -1) {                    int q = Integer.parseInt(selfTiaonum.substring(res, res+1));                    if (p < 15) {                        if ((p+1) < q ) {                            //TODO 修改路由表对应数据//                          System.out.println("premod======="+selfNetnum.substring(res, res+1)+"--------"+otherNetnum.substring(i,i+1));                            selfShouldMod += String.valueOf(res);                            otherShouldMod += String.valueOf(i);                        }                    }                }else if (res == -1) {                    if (p < 15) {                        //TODO 添加该条目//                      System.out.println("preadd====="+otherNetnum.substring(i,i+1));                        shouldAdd += String.valueOf(i);                    }                }else {                    System.err.println("core change err");                }            }            if (selfShouldMod.length() > 0) {                for(int i = 0; i < selfShouldMod.length(); i++){//                  System.out.println("mod");                    selfList.remove(selfShouldMod.substring(i,i+1));                    String newChange[] = {                                otherList.get(Integer.parseInt(otherShouldMod.substring(i, i+1)))[0],                                String.valueOf(Integer.parseInt(otherList.get(Integer.parseInt(otherShouldMod.substring(i,i+1)))[1])+1),                                String.valueOf(otherRouterTable.getRouterID())                            };                     selfList.put(Integer.parseInt(selfShouldMod.substring(i,i+1)), newChange);                }            }            if (shouldAdd.length() > 0) {//              System.out.println("1111111111111self.size================="+selfList.size());                int len = selfList.size();                for(int i = 0; i < shouldAdd.length(); i++){//                  System.out.println("add");                    String newChange[] = {                            otherList.get(Integer.parseInt(shouldAdd.substring(i, i+1)))[0],                            String.valueOf(Integer.parseInt(otherList.get(Integer.parseInt(shouldAdd.substring(i,i+1)))[1])+1),                            String.valueOf(otherRouterTable.getRouterID())                        };                     selfList.put(len+i, newChange);//                  System.out.println("self.size================="+selfList.size());                }            }            routerTable.setList(selfList);            setRouterTable(routerTable);    }    public int[] getNearRouter() {        return nearRouter;    }    public void setNearRouter(int[] nearRouter) {        this.nearRouter = nearRouter;    }    public int[] getNearNetwork() {        return nearNetwork;    }    public void setNearNetwork(int[] nearNetwork) {        this.nearNetwork = nearNetwork;    }    public int getRouterId() {        return routerId;    }    public void echoRoutertable(){        RouterTable rtTables = getRouterTable();         HashMap<Integer, String[]> list = rtTables.getList();        System.out.println("*******路由器 "+getRouterTable().getRouterID()+" 路由表******");        for (int i = 0; i < list.size(); i++) {            String[] pStrings = list.get(i);            System.out.println("网络："+pStrings[0]+"  |   "+"跳数："+pStrings[1]+"   |   "+"下一跳路由器： "+pStrings[2]);        }    }    public Router(int routerId, RouterTable routerTable) {        super();        this.routerId = routerId;        this.routerTable = routerTable;        //TODO 记录临近的网络        int[] p = new int[routerTable.getList().size()];        for(int i = 0; i < routerTable.getList().size(); i++){            p[i] = Integer.parseInt(routerTable.getList().get(i)[0]);        }        this.nearNetwork = p;    }}

// RouterTable.java  路由表类package rip;import java.util.HashMap;public class RouterTable {    private HashMap<Integer, String[] > list;    private int routerID;    public HashMap<Integer, String[]> getList() {        return list;    }    public void setList(HashMap<Integer, String[]> list) {        this.list = list;    }    public int getRouterID() {        return routerID;    }    public void setRouterID(int routerID) {        this.routerID = routerID;    }    public RouterTable(HashMap<Integer, String[]> list, int routerID) {        super();        this.list = list;        this.routerID = routerID;    }}

// Util.java  通用函数类package rip;import java.io.BufferedReader;import java.io.FileInputStream;import java.io.FileNotFoundException;import java.io.IOException;import java.io.InputStream;import java.io.InputStreamReader;import java.util.Enumeration;import java.util.HashMap;import java.util.Properties;public class Util {    private final static String propertiesUrl = "./config/network.properties";/** * 读取网络配置信息 * ###网络配置信息相关文档见readme.md * @return hashmap */    public static HashMap<String, String[]> readNetworkConfig(){        HashMap<String, String[]> netconf = new HashMap<>();        Properties Networkconfig = new Properties();        try {            Networkconfig.load(new FileInputStream(propertiesUrl));        } catch (FileNotFoundException e) {            // TODO Auto-generated catch block            e.printStackTrace();        } catch (IOException e) {            // TODO Auto-generated catch block            e.printStackTrace();        }         @SuppressWarnings("rawtypes")        Enumeration enumm = Networkconfig.propertyNames();                  while(enumm.hasMoreElements()) {                      String strKey = (String) enumm.nextElement();                      String strValue = Networkconfig.getProperty(strKey);                      String[] strValueArray = strValue.split(",");                      netconf.put(strKey, strValueArray);               }                  return netconf;    }    /**     * 将int[]数组转为string     * @param intarr int[]     * @return string     */    public static String intArray2string(int intarr[]){        String string = "";        for(int i = 0; i < intarr.length; i++){            string += String.valueOf(intarr[i]);        }        return string;    }    public static String callCmd(String cmd) throws IOException, InterruptedException {                // 使用Runtime来执行command，生成Process对象                Process process = Runtime.getRuntime().exec(new String[] { "/bin/sh", "-c", cmd });                // int exitCode = process.waitFor();                // 取得命令结果的输出流                InputStream is = process.getInputStream();                // 用一个读输出流类去读                InputStreamReader isr = new InputStreamReader(is);                // 用缓冲器读行                BufferedReader br = new BufferedReader(isr);                String line = null;                StringBuilder sb = new StringBuilder();                while ((line = br.readLine()) != null) {                    System.out.println(line);                    sb.append(line);                }                is.close();                isr.close();                br.close();                return sb.toString();    }}