大二下學期的計算機網路原理課程設計

之前整理了github，換了地址，忘了更新了，感謝評論提醒，現在github連結恢復正常了。

已同步github

一、設計題目：距離向量路由選擇演算法的模擬實現

二、設計要求

（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,6
4=3
5=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();
    }


}