Java模仿路由协议-rip（路由器仿真实验）

前言：

         很久不见，有段时间没有写文章了，本篇文章，由Blue我带各人来复现rip协议。我们以
  b站湖南西席匠所讲rip的视频中的例子为我这篇文章所模仿的路由路径
  如图：
  

  

模仿路径

  视频：http://【深入浅出盘算机网络 - 4.4.3 路由信息协议RIP】https://www.bilibili.com/video/BV1ST411K7nK?vd_source=bb412cc25ca27e171f8e17085daad038
 Rip协议工作原理：

   

• 1、rip协议要求网络中每个路由器都要维护从它本身到其他每一个目的网络的隔断纪录。
  
• 2、rip以为好的路由就是它通过的网路数目少的，及“隔断最短”。
  
• 3、rip最多答应一条路径包罗15个网络。隔断为16时相称于不可达。
  
• 4、仅和相邻路由器交换信息，这里的信息指的是全部网络的最短隔断，以及到每个网络应颠末的下一跳路由
  
• 5、按固定时间隔断交换路由信息
  

   代码实现：

第一步：搭建项目

注意：我搭建的是boot项目，现实我这个复现，并没使用boot，以是你也可以不搭建boot
 项目结构:

第二步：界说路由表中的关键列（目的网络，隔断，下一跳）

RouterTable：

1. package com.example.Kclass;
3. /**
4. * 路由表：
5. * 1、目的网络
6. * 2、距离
7. * 3、下一跳路由器
8. */
9. public class RouterTable implements Cloneable{
10.     private Integer AimNet;
11.     private Integer distance;
12.     private String NextRouter;
14.     public RouterTable() {
15.     }
17.     @Override
18.     protected Object clone() throws CloneNotSupportedException {
19.         return super.clone();
20.     }
22.     public RouterTable(Integer AimNet, Integer distance, String NextRouter) {
23.         this.AimNet = AimNet;
24.         this.distance = distance;
25.         this.NextRouter = NextRouter;
26.     }
28.     /**
29.      * 获取
30.      * @return AimNet
31.      */
32.     public Integer getAimNet() {
33.         return AimNet;
34.     }
36.     /**
37.      * 设置
38.      * @param AimNet
39.      */
40.     public void setAimNet(Integer AimNet) {
41.         this.AimNet = AimNet;
42.     }
44.     /**
45.      * 获取
46.      * @return distance
47.      */
48.     public Integer getDistance() {
49.         return distance;
50.     }
52.     /**
53.      * 设置
54.      * @param distance
55.      */
56.     public void setDistance(Integer distance) {
57.         this.distance = distance;
58.     }
60.     /**
61.      * 获取
62.      * @return NextRouter
63.      */
64.     public String getNextRouter() {
65.         return NextRouter;
66.     }
68.     /**
69.      * 设置
70.      * @param NextRouter
71.      */
72.     public void setNextRouter(String NextRouter) {
73.         this.NextRouter = NextRouter;
74.     }
76.     public String toString() {
77.         return "RouterTable{AimNet = " + AimNet + ", distance = " + distance + ", NextRouter = " + NextRouter + "}";
78.     }
79. }

复制代码

第三步：界说路由器 

 Router:

1. package com.example.Kclass;
3. import java.util.ArrayList;
4. import java.util.HashSet;
5. import java.util.List;
6. import java.util.Set;
8. /**
9. * 路由器的模板类
10. *
11. */
12. public class Router {
13.    private int id;
14.    List<RouterTable> routerTables = new ArrayList<>();
16.     public void setId(int id) {
17.         this.id = id;
18.     }
20.     public int getId() {
21.         return id;
22.     }
24.    public String find(int aimid){
25.         String sc ="完成";
26.         for (RouterTable e : routerTables){
27.             if(e.getAimNet()==aimid){
28.                 System.out.println("需要经过的路由器："+this.id);
29.                 System.out.println("");
30.                 if(e.getNextRouter().equals("直连")){
31.                     return sc;
32.                 }else {
33.                     return e.getNextRouter();
34.                 }
35.             }
36.         }
37.        return sc;
38.    }
40.     //添加操作
41.     public  void add(RouterTable routerTable){
42.         int count=0;
43.         //存在相同的目的网络则不添加
44.         for (RouterTable e1  : routerTables){
45.             if(e1.getAimNet().equals(routerTable.getAimNet())){
46.                 //不添加
47.                 return;
48.             }
49.         }
50.         routerTables.add(routerTable);
51.     }
53.     //更新操作
54.     public void update(List<RouterTable> r1){
55.         /**
56.          * 遍历，看这个路由表满足这几种可能不？
57.          * 1、没有就插入
58.          * 2、有，如果下一跳相同则直接更新
59.          * 3、有，下一跳不同，且r1的距离小于自身的，将下一跳换成r1的下一跳，并且更新
60.          * 4、有，下一跳不同，且r1的距离大于自身的，不管舍弃
61.          */
62.         //遍历
63.         for (int i=0;i<r1.size();i++){
64.             for (int j=0;j<routerTables.size();j++){
65.                 //是否存在相同的目的网络
66.                 if(r1.get(i).getAimNet().equals(routerTables.get(j).getAimNet())){
67.                     //是否下一跳也相同
68.                     if(r1.get(i).getNextRouter().equals(routerTables.get(j).getNextRouter())){
69.                         //相同，直接更新
70.                         routerTables.get(j).setDistance(r1.get(i).getDistance());
71.                         break;
72.                     }else {
73.                         //不同，判断距离
74.                         if(routerTables.get(j).getDistance()>r1.get(i).getDistance()){
75.                             routerTables.get(j).setDistance(r1.get(i).getDistance());
76.                             break;
77.                         }else {
78.                             break;
79.                         }
80.                     }
81.                 }
82.                 if(j==routerTables.size()-1){
83.                     routerTables.add(r1.get(i));
84.                 }
85.             }
86.         }
87.     }
88.     //打印其路由表
89.     public void prints(){
90.         System.out.println(id+"的路由表为：");
91.         System.out.println("---目的网络---距离-----下一跳路由-----");
92.         for(RouterTable e : routerTables){
93.             System.out.println("---"+e.getAimNet()+"-----"+e.getDistance()+"------"+e.getNextRouter());
94.             System.out.println("");
95.         }
96.     }
97.     public  List<RouterTable> deepCopyRouterTables() {
98.         List<RouterTable> copiedList = new ArrayList<>(routerTables.size());
99.         for (RouterTable routerTable : routerTables) {
100.             try {
101.                 copiedList.add((RouterTable) routerTable.clone()); // 深拷贝
102.             } catch (CloneNotSupportedException e) {
103.                 e.printStackTrace(); // 处理异常
104.             }
105.         }
106.         return copiedList;
107.     }
108. }

复制代码

第四步：界说网络

1. <strong>NetWork：</strong>

复制代码

1. package com.example.Kclass;
3. public class NetWork {
4.     private int id;
6.     public NetWork() {
7.     }
9.     public NetWork(int id) {
10.         this.id = id;
11.     }
13.     /**
14.      * 获取
15.      * @return id
16.      */
17.     public int getId() {
18.         return id;
19.     }
21.     /**
22.      * 设置
23.      * @param id
24.      */
25.     public void setId(int id) {
26.         this.id = id;
27.     }
29.     public String toString() {
30.         return "NetWork{id = " + id + "}";
31.     }
32. }

复制代码

第五步：界说User

1. package com.example.Kclass;
3. public class User {
4.      private int id ;
5.      private int Routid;
7.     public User() {
8.     }
10.     public User(int id, int Routid) {
11.         this.id = id;
12.         this.Routid = Routid;
13.     }
15.     /**
16.      * 获取
17.      * @return id
18.      */
19.     public int getId() {
20.         return id;
21.     }
23.     /**
24.      * 设置
25.      * @param id
26.      */
27.     public void setId(int id) {
28.         this.id = id;
29.     }
31.     /**
32.      * 获取
33.      * @return Routid
34.      */
35.     public int getRoutid() {
36.         return Routid;
37.     }
39.     /**
40.      * 设置
41.      * @param Routid
42.      */
43.     public void setRoutid(int Routid) {
44.         this.Routid = Routid;
45.     }
47.     public String toString() {
48.         return "User{id = " + id + ", Routid = " + Routid + "}";
49.     }
50. }

复制代码

第六步：Ts代码

1. package com.example.test;
3. import com.example.Kclass.NetWork;
4. import com.example.Kclass.Router;
5. import com.example.Kclass.RouterTable;
6. import com.example.Kclass.User;
8. import java.util.ArrayList;
9. import java.util.List;
10. import java.util.Scanner;
11. import java.util.concurrent.CountDownLatch;
13. /**
14. * 1、四个网络
15. * 2、四个路由器
16. * 3、创建图（利用图来表示链接）
17. * 4、该类目的是弄好路由器的交换表
18. */
19. public class Ts {
20.     public static void main(String[] args) {
22.         List<NetWork> netWorks =new ArrayList<>();
23.         List<Router> routers =new ArrayList<>();
24.         rip(netWorks,routers);
25.         //用户界面
26.         User user =new User(1,1);
27.         MainPannel(routers,user);
29.     }
30.     public static void ppt(List<Router> routers){
31.         for (Router e:routers){
32.             e.prints();
33.         }
34.     }
36.     public static void MainPannel(List<Router> routers,User user){
37.         while (true){
38.             int a;
39.             System.out.println("选项1：打印所有路由表");
40.             System.out.println("选项2：用户传输信息");
41.             System.out.println("选项3：退出");
42.             Scanner s =new Scanner(System.in);
43.             System.out.println("请输入选项：");
44.             a=s.nextInt();
45.             switch (a){
46.                 case 1:
47.                     ppt(routers);
48.                     break;
49.                 case 2:
50.                     userprint(routers,user);
51.                     break;
52.                 case 3:
53.                     return;
54.             }
55.         }
56.     }
58.     public static void userprint(List<Router> routers, User user){
59.         System.out.println("请输入需要传送到的网络");
60.         int a;
61.         Scanner sc = new Scanner(System.in);
62.         a=sc.nextInt();
63.         int t=a;
64.         //知道自己从那个路由出发
65.        int routid= user.getRoutid();
66.         Router router = routers.get(routid - 1);
67.         boolean flage =true;
68.         while (flage){
69.             String s = router.find(t);
70.             if(s.equals("完成")){
71.                 System.out.println("完成");
72.                 return;
73.             }
74.             a = Integer.parseInt(s);
75.             router=routers.get(a-1);
76.         }
77.     }
79.     public static void rip( List<NetWork> netWorks, List<Router> routers) {
80.         //生成四个网络
81.         //令四个网络为1,2,3,4
83.         for (int i=1;i<=4;i++){
84.             NetWork e =new NetWork();
85.             e.setId(i);
86.             netWorks.add(e);
87.         }
88.         //生成四个路由器
89.         //令四个路由器为5,6,7,8
91.         for (int i=5;i<=8;i++){
92.             Router e =new Router();
93.             e.setId(i-4);
94.             routers.add(e);
95.         }
96.         //生成线路
97.         int[][] arry=CreateImage();
98.         //rip基本原理规定：路由器刚开始工作只知道自己到直连网络的距离为1
99.         //根据线路初始化
100.         initialization(routers,arry);
101.         //打印初始化后的每个路由器的路由表
102. //        System.out.println("--------------------路由表的初始化-----------------------");
103. //        for (Router e:routers){
104. //            e.prints();
105. //        }
106.         //根据rip基本原理每个路由器仅和相邻路由器周期性地交换并更新路由信息
107.         find(routers,arry);
108. //        System.out.println("--------------------路由表的最终-----------------------");
109. //        for (Router e:routers){
110. //            e.prints();
111. //        }
112.     }
114.     public static int[][] CreateImage(){
115.         int[][] arry={
116.                 {0,0,0,0,1,1,0,0},//N1所对应的行,0
117.                 {0,0,0,0,1,0,1,0},//N2所对应的行,1
118.                 {0,0,0,0,0,0,1,1},//N3所对应的行,2
119.                 {0,0,0,0,0,1,1,1},//N4所对应的行,3
120.                 {1,1,0,0,0,0,0,0},//R1所对应的行,4
121.                 {1,0,0,1,0,0,0,0},//R2所对应的行,5
122.                 {0,1,1,1,0,0,0,0},//R3所对应的行,6
123.                 {0,0,1,1,0,0,0,0} //R4所对应的行,7
124.         };
125.         return arry;
126.     }
128.     //初始化
129.     public static void initialization(List<Router> routers,int[][] arry){
130.         for (int i=4;i<=7;i++){
131.             for (int j=0;j<4;j++){
132.                 if(arry[i][j]==0){
133.                     continue;
134.                 }
135.                 if(arry[i][j]==1){
136.                     routers.get(i-4).add(new RouterTable(j+1,1,"直连"));
137.                 }
138.             }
139.         }
140.     }
142.     //用于更新
143.     public static void exchenge(Router e1,Router e2){
144.       //先让e1去更新e2
145.         // 深拷贝
146.         List<RouterTable> Copye2 = e2.deepCopyRouterTables();
147.         String next=e2.getId()+"";
149.         //根据rip协议，让其距离加1，下一跳变为e1
150.         for (RouterTable table :Copye2){
151.             table.setDistance(table.getDistance()+1);
152.             table.setNextRouter(next);
153.         }
154.         e1.update(Copye2);
156.         //e2去更新e1
157.         String next2=e1.getId()+"";
158.         //深拷贝
159.         List<RouterTable> copy1 = e1.deepCopyRouterTables();
160.         //根据rip协议，让其距离加1，下一跳变为e2
161.         for (RouterTable table :copy1){
162.             table.setDistance(table.getDistance()+1);
163.             table.setNextRouter(next2);
164.         }
165.         e2.update(copy1);
166.     }
168.     //用于遍历数组,查找相同路由器
169.     public static void find(List<Router> routers,int[][] arry){
170.         //双指针遍历
171.         int A=0;
172.         int B=0;
173.         for (int i=0;i<4;i++){
174.             boolean flage=true;
175.             //优化操作
176.             if(flage) {
177.                 for (int j = 4; j < 8; j++) {
178.                     if (arry[i][j] == 1) {
179.                         A = j;//找到第一个1,然后继续下去找
180.                         B=j;
181.                          flage=false;
182.                          break;
183.                     }
184.                 }
185.             }
187.             for (int j=B+1;j<8;j++){
188.                 if (arry[i][j]==1)
189.                 {
190.                     //执行更新
191.                     exchenge(routers.get(A-4),routers.get(j-4));
192.                     //判断是否还有可能存在相邻
193.                     if(j<7){
194.                         int s=B;
195.                         B=j;
196.                         for (int w=B+1;w<8;w++){
197.                             if(arry[i][w]==1){
198.                                 exchenge(routers.get(A-4),routers.get(w-4));
199.                                 exchenge(routers.get(s-4),routers.get(w-4));
200.                             }else {
201.                                 break;
202.                             }
203.                         }
204.                     }
205.                 }
206.             }
208.         }
209.     }
211. }

复制代码

实现效果：

主页面：

选项1：

选项2：

选项3：

结语：

   你好,我是Blue. 为资助别人少走弯路而写博客 ！！！
  假如本篇文章帮到了你 不妨点个赞吧~ 我会很高兴的 😄 (^ ~ ^) 。想看更多 那就点个关注吧 我会努力带来风趣的内容 😎。
  假如你遇到了标题，本身没法办理，可以私信问我。
  

感谢订阅专栏 三连文章！！