内部网关协议RIP的模拟程序
内部网关协议RIP的模拟程序
一、题目
一）设计内容
采用Java等编程语言模拟实现内部网关协议RIP。
二） 设计要求
- 掌握内部网关协议RIP的工作原理；
- 模拟程序能够初始化网络拓扑结构（图1所示），并生成每个路由器上的路由表。
- 模拟可以模拟RIP协议的执行：定期根据网络拓扑结构的变化，更新每台路由器上的路由表。
4)可通过命令或操作（通过图形化界面），更改网络拓扑结构。 - 在RIP协议的执行过程中，模拟程序能够输出指定路由器的路由表。路由表的数据结构为<目的网络，跳数，下一跳>。
图1 模拟网络的拓扑结构
三）说明
模拟程序涉及三类对象：网络、路由器和路由表。其中，模拟程序具有6个网络，网络中包含至少6台路由器，每台路由器拥有一个路由表。模拟程序主要有四个功能：
1、初始化网络拓扑、建立路由表、建立邻接关系、设置定期更新时间。
2、在执行的过程中，用户可以输入更改网络拓扑结构的命令/操作：网络加入、网络退出、路由器故障等。
3、根据网络拓扑结构的变化，RIP协议定期更新每台路由器中的路由表。
4、可以通过命令暂停模拟程序的执行，并输出当前状态下，指定路由器的路由表。
二、功能：
以上为课程设计要求，鄙人才疏学浅，实现功能较少，主要包括：
（1）初始化，
（2）显示当前各路由表信息，
（3）根据循环轮次更新路由表，
（4）更改网络拓扑结构
三、参考
源程序参考的博客如下：
RIP协议的模拟实现
rip协议java模拟实现
计算机网络实验三（java代码实现RIP）
其中Router类、Information类、路由更新的核心算法直接用的上述博客中的源代码。
四、源程序
Information类
import java.io.Serializable;
//路由表中的信息
public class Information implements Serializable {
private String targetNetwork; //目的网络
private int distance; //距离
private String nextJumpRouter; //下一跳路由器
public Information() {
}
/*return targetNetwork+" "+
distance+" "+
nextJumpRouter+"\n";
*/
@Override
public String toString() {
return "\n"+targetNetwork+
"\t"+distance+
"\t"+nextJumpRouter;
}
public void setTargetNetwork(String targetNetwork) {
this.targetNetwork = targetNetwork;
}
public void setDistance(int distance) {
this.distance = distance;
}
public void setNextJumpRouter(String nextJumpRouter) {
this.nextJumpRouter = nextJumpRouter;
}
public String getTargetNetwork() {
return targetNetwork;
}
public int getDistance() {
return distance;
}
public String getNextJumpRouter() {
return nextJumpRouter;
}
public Information(String targetNetwork, int distance, String nextJumpRouter) {
this.targetNetwork = targetNetwork;
this.distance = distance;
this.nextJumpRouter = nextJumpRouter;
}
}
Router类
import java.io.Serializable;
import java.util.List;
import java.util.Map;
//路由器
public class Router implements Serializable {
private String routerName; //路由器地址
private Map<String,Information> information;//路由器中路由表信息
private List<Router> nearRouter; //相邻路由器
public Router() {
}
public Router(String routerName, Map<String, Information> information) {
this.routerName = routerName;
this.information = information;
}
public String getRouterName() {
return routerName;
}
public Map<String, Information> getInformation() {
return information;
}
public void setRouterName(String routerName) {
this.routerName = routerName;
}
public void setInformation(Map<String, Information> information) {
this.information = information;
}
public void setNearRouter(List<Router> nearRouter) {
this.nearRouter=nearRouter;
}
public List<Router> getNearRouter(){
return nearRouter;
}
/*return "路由表名称:"+routerName+"\n"+
"目的网络"+" "+"跳数"+" "+"下一跳路由器\n"+
information.values()+"\n";
"Router{\n"+
*/
@Override
public String toString() {
return "routerName: "+routerName+
"\ninformation:\n"+information.values()+
"\n";
}
}
Network类
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
public class Network {
private int routerNum; //路由器个数
private List<Router> routerList; //路由器集合
public int getRouterNum() {
return routerNum;
}
public void setRouterNum(int routerNum) {
this.routerNum = routerNum;
}
public List<Router> getRouterList() {
return routerList;
}
public void setRouterList(List<Router> routerList) {
this.routerList = routerList;
}
//初始化路由表
public void initRouter(){
routerNum=6;
this.routerList= new ArrayList<Router>();
Map<String,Information> informationA=new HashMap<>();
informationA.put("N1",new Information("N1",1,"null"));
informationA.put("N2",new Information("N2",1,"null"));
informationA.put("N3",new Information("N3",1,"null"));
this.routerList.add(new Router("A",informationA));
Map<String,Information> informationB=new HashMap<>();
informationB.put("N3",new Information("N3",1,"null"));
informationB.put("N4",new Information("N4",1,"null"));
this.routerList.add(new Router("B",informationB));
Map<String,Information> informationC=new HashMap<>();
informationC.put("N4",new Information("N4",1,"null"));
informationC.put("N5",new Information("N5",1,"null"));
this.routerList.add(new Router("C",informationC));
Map<String,Information> informationD=new HashMap<>();
informationD.put("N2",new Information("N2",1,"null"));
informationD.put("N6",new Information("N6",1,"null"));
this.routerList.add(new Router("D",informationD));
Map<String,Information> informationE=new HashMap<>();
informationE.put("N1",new Information("N1",1,"null"));
informationE.put("N6",new Information("N6",1,"null"));
this.routerList.add(new Router("E",informationE));
Map<String,Information> informationF=new HashMap<>();
informationF.put("N5",new Information("N5",1,"null"));
informationF.put("N6",new Information("N6",1,"null"));
this.routerList.add(new Router("F",informationF));
}
//初始化相邻路由
public void initNearRouter() {
/*观察初始路由表项，可以发现相邻的路由表具有一个表项交集，
* 因此可以根据是否有交集，判断他们是否相邻
*/
for(int i=0;i<this.routerNum;i++) {
//得到路由表(例如A)的关键字存放在Set集合中
Set<String> set=this.routerList.get(i).getInformation().keySet();
List<Router> nearRouter=new ArrayList<Router>();
//遍历其他路由表
for(int j=0;j<this.routerNum;j++) {
if(i!=j) {
/*若此路由表(例如B)中有关键字为s的表项，则B与A相邻
* 将B加入A的相邻路由器集合中；
*/
for(String s:set) {
if(this.routerList.get(j).getInformation().containsKey(s))
nearRouter.add(this.routerList.get(j));
}
}
}
this.routerList.get(i).setNearRouter(nearRouter);
}
}
//输出路由器相邻路由器
/*for(int i=0;i nearRouter=new ArrayList();
nearRouter=this.routerList.get(i).getNearRouter();
for(int j=0;j
//初始化网络拓扑
public void initNetwork() {
initRouter();
initNearRouter();
}
}
Function类
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Scanner;
public class Function {
public static void fun1(Network network) {
network.initNetwork();
if(network.getRouterList().size()==network.getRouterNum())
System.out.println("初始化成功!!!");
fun2(network);
}
public static void fun2(Network network) {
for(int i=0;i<network.getRouterList().size();i++) {
System.out.println(network.getRouterList().get(i));
}
}
public static void updateTable(Network network) throws IOException, ClassNotFoundException {
List<Router> routerList=network.getRouterList();
for(int i=0;i<routerList.size();i++) {
Router router1=routerList.get(i);
//Map map1=routerList.get(i).getInformation();
//System.out.println(router1);
List<Router> nearRouter=routerList.get(i).getNearRouter();
for(int j=0;j<nearRouter.size();j++) {
Router router=nearRouter.get(j);
//Router router2=new Router();
//router2=router;
//如果没有信息，什么也不做
if(router.getInformation()==null || router.getInformation().size()==0 || router1==router){
break;
}
//对router2的复制，避免直接修改路由器router2的路由表
ByteArrayOutputStream baos=new ByteArrayOutputStream();
ObjectOutputStream oos=new ObjectOutputStream(baos);
oos.writeObject(router);
oos.close();
byte[] bs=baos.toByteArray();
ByteArrayInputStream bais=new ByteArrayInputStream(bs);
ObjectInputStream ois=new ObjectInputStream(bais);
Router router2= (Router) ois.readObject();
ois.close();
//System.out.println(router2);
for(Information information:router2.getInformation().values()) {
//距离小于16时加1
if(information.getDistance()<16) {
information.setDistance(information.getDistance()+1);
}
information.setNextJumpRouter(router2.getRouterName());
}
//System.out.println(router2);
Information information=null;
for(String s:router2.getInformation().keySet()) {
//原路由表中不包括目的网络N,则添加到路由表中
if(!router1.getInformation().containsKey(s)) {
information=new Information(s,router2.getInformation().get(s).getDistance(),router2.getRouterName());
router1.getInformation().put(s, information);
}else {
//如果下一跳相同，替换原路由表中的项目，
if(router1.getInformation().get(s).getNextJumpRouter().equals(router2.getRouterName())){
router1.getInformation().put(s,router2.getInformation().get(s));//直接替换
}else {
//若收到的项目中的距离小于路由表中的距离，则进行更新，
if(router2.getInformation().get(s).getDistance()<router1.getInformation().get(s).getDistance()){
router1.getInformation().put(s,router2.getInformation().get(s));
}
}
}
}
//System.out.println(router1);
}
}
}
public static void fun3(Network network) throws IOException, ClassNotFoundException {
System.out.print("请输入循环轮次:");
Scanner in = new Scanner(System.in);
int sum = in.nextInt();
//in.close();
for(int a = 0; a < sum; a++){
System.out.println("---循环轮次"+(a+1)+"---");
updateTable(network);
for(int i=0;i<network.getRouterNum();i++) {
System.out.println(network.getRouterList().get(i));
}
}
}
public static void fun4_1(Network network) {
System.out.println("请输入要加入的网络名称：");
String net;
Scanner in=new Scanner(System.in);
net=in.nextLine();
System.out.println("请输入与该网络相邻的路由器名称：");
String str=in.nextLine();
String routers[]=str.split(" ");
for(int i=0;i<routers.length;i++) {
for(int j=0;j<network.getRouterList().size();j++) {
Router router=network.getRouterList().get(j);
if(router.getRouterName().equals(routers[i])) {
router.getInformation().put(net,new Information(net,1,"null"));
}
}
}
for(int i=0;i<network.getRouterNum();i++) {
System.out.println(network.getRouterList().get(i));
}
}
public static void fun4_2(Network network) {
System.out.println("请输入要退出的网络名称：");
String net;
Scanner in=new Scanner(System.in);
net=in.nextLine();
for(int i=0;i<network.getRouterList().size();i++) {
Router router=network.getRouterList().get(i);
if(router.getInformation().containsKey(net)) {
router.getInformation().remove(net);
}
}
for(int i=0;i<network.getRouterNum();i++) {
System.out.println(network.getRouterList().get(i));
}
}
public static void fun4_3(Network network) throws ClassNotFoundException, IOException {
System.out.println("请输入发生故障的路由器名称：");
String rt;
Scanner in=new Scanner(System.in);
rt=in.nextLine();
Iterator<Router> it1=network.getRouterList().iterator();
while(it1.hasNext()) {
Router router=(Router)it1.next();
if(router.getRouterName().equals(rt)) {
//得到其(C)相邻路由器
List<Router> nearRouter=router.getNearRouter();
for(int i=0;i<nearRouter.size();i++) {
Router r1=nearRouter.get(i);
//从相邻路由器(例如D)的相邻路由表中删除C
for(int j=0;j<r1.getNearRouter().size();j++) {
if(r1.getNearRouter().get(j).getRouterName().equals(rt)) {
r1.getNearRouter().remove(j);
}
}
}
//清空Map集合
router.getInformation().clear();
//将此路由器从List集合删除
it1.remove();
network.setRouterNum(network.getRouterNum()-1);
}
}
Iterator<Router> it=network.getRouterList().iterator();
while(it.hasNext()) {
Router router=(Router)it.next();
//删除下一跳为rt的表项
Iterator<String> its=router.getInformation().keySet().iterator();
while(its.hasNext()) {
String str=(String)its.next();
if(router.getInformation().get(str).getNextJumpRouter().equals(rt)) {
its.remove();
}
}
}
/*Iterator its=router.getInformation().values().iterator();
while(its.hasNext()) {
Information infor=(Information)its.next();
if(infor.getNextJumpRouter().equals(rt)) {
its.remove();
}
}
*/
/*for(int i=0;i
/*for(int i=0;i
for(int i=0;i<network.getRouterList().size();i++) {
System.out.println(network.getRouterList().get(i));
}
/*
updateTable(network);
for(int i=0;i
}
public static void fun4(Network network) throws ClassNotFoundException, IOException {
int choose; //输入的选项
Scanner scanner=new Scanner(System.in);
System.out.println("1.网络加入");
System.out.println("2.网络退出");
System.out.println("3.路由器故障");
System.out.println("4.取消");
System.out.println("请选择：");
choose=scanner.nextInt();
switch(choose) {
case 1:
fun4_1(network);
break;
case 2:
fun4_2(network);
break;
case 3:
fun4_3(network);
break;
case 4:
break;
}
}
}
Main类
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
public class Main {
public static void main(String[] args) throws IOException, ClassNotFoundException {
Network network=new Network();
int choose; //输入的选项
Scanner scanner=new Scanner(System.in);
boolean flag=false;
while(true){
System.out.println("1.初始化");
System.out.println("2.显示当前各路由表信息");
System.out.println("3.根据循环轮次更新路由表");
System.out.println("4.更改网络拓扑结构");
System.out.println("5.结束");
choose=scanner.nextInt();
switch (choose){
case 1:
Function.fun1(network);
flag=true;
break;
case 2:
if(!flag) {
System.out.println("未初始化，请先完成初始化！\n");
break;
}else {
Function.fun2(network);
break;
}
case 3:
if(!flag) {
System.out.println("未初始化，请先完成初始化！\n");
break;
}else {
Function.fun3(network);
break;
}
case 4:
if(!flag) {
System.out.println("未初始化，请先完成初始化！\n");
break;
}else {
Function.fun4(network);
break;
}
case 5:
System.exit(0);
break;
}
}
}
}
五、运行演示
1、初始化
2、根据循环轮次更新路由表
3、更改网络拓扑结构
（1）添加网络
路由器 C 和 D 先添加了目的网络N7，再通过更新路由表可以实现其他路由表也含有目的网络N7（这里不再贴图）。
（2）删除网络
（3）路由器故障
循环更新两次后结果：
