最近在做计算机网络的一个小实验，多线程模拟rip协议，实现距离向量算法，感觉挺有意思的，需要一定的思考之后才能写出结构比较好的代码。

路由器与网络相连，而不是与路由器直接相连。路由器先给所有直接相连的网络发消息（路由表报文），然后，网络再给所有与它直接相连的路由器转发。

下面贴代码了，可以直接运行

Pair.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
/**
 * 
 * @author 82177
 *
 * @param <T1>
 * @param <T2>
 */

public class Pair<T1, T2> {
	private T1 first;
	private T2 second;
	
	public Pair(T1 first, T2 second) {
		this.first = first;
		this.second = second;
	}
	
	public T1 getFirst() {
		return first;
	}
	
	public T2 getSecond() {
		return second;
	}
}

Message.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
/**
 * 
 * @author 82177
 * 
 * @introduction 路由表信息项类
 */


public class Message {
	private String net; // 目的网络
	private int dist; // 距离
	private String nextRouter; // 下一跳路由器
	
	public Message() {
		net = "————";
		dist = 0;
		nextRouter = "————";
	}
	
	public Message(String net, int dist, String nextRouter) {
		this.net = net;
		this.dist = dist;
		this.nextRouter = nextRouter;
	}
	
	public Message(Message msg) {
		this.net = msg.net;
		this.dist = msg.dist;
		this.nextRouter = msg.nextRouter;
	}
	
	public String getNetName() {
		return net;
	}
	
	public void setNetName(String net) {
		this.net = net;
	}
	
	public int getDist() {
		return dist;
	}
	
	public void setDist(int dist) {
		this.dist = dist;
	}
	
	public String getNextRouter() {
		return nextRouter;
	}
	
	public void setNextRouter(String nextRouter) {
		this.nextRouter = nextRouter;
	}
	
	public String toLocalString() {
		return net + "\t" + dist + "\t" +  nextRouter;
	}
	
	@Override
	public String toString() {
		return net + ", " + dist + ", " + nextRouter;
	}
}

NetWork.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
/**
 * 
 * @author 82177
 * 
 * @introduction 网络类
 */

import java.util.*;

public class NetWork {
	private boolean work; // 工作状态
	private String name; // 名称
	private List<Router> routers; // 连接的路由器
	private Queue<Pair<String, List<Message>>> mq; // 消息队列
	private NetSendRouteTable sendThread; // 发送线程
	
	public NetWork(String name) { // 构造函数
		this.name = name;
		this.routers = new ArrayList<Router>();
		this.mq = new LinkedList<Pair<String, List<Message>>>();
	}
	
	public String getNetName() { // 获取网络名称
		return name;
	}
	
	public boolean isWork() { // 返回工作状态
		return work;
	}
	
	public void start() { // 开始工作
		work = true;
		sendThread = new NetSendRouteTable(this);
		sendThread.start();
	}
	
	public void stop() { // 停止工作
		work = false;
		sendThread.interrupt();
		synchronized(mq) {
			mq.clear();
		}
		selfBroken();
	}
	
	public void selfBroken() { // 自身不可用
		for (int i = 0; i < routers.size(); i++) {
			Router rt = routers.get(i);
			rt.setNetBroken(name);
		}
	}
	
//	public void selfReWork() { // 重新工作
//		Message m = new Message(name, 0, "-");
//		List<Message> list = new ArrayList<Message>();
//		list.add(m);
//		mq.add(new Pair<String, List<Message>>("-", list));
//	}

	public void connectRouter(Router rt) { // 连接路由器
		routers.add(rt);
	}
	
	public void sendMessage() { // 向外发送一个路由表报文
		synchronized(mq) {
			if (!mq.isEmpty()) {
				Pair<String, List<Message>> msg = mq.poll();
				for (int i = 0; i < routers.size(); i++) {
					Router rt = routers.get(i);
					if (rt.getRtName() != msg.getFirst()) {
						rt.receiveMessage(msg);
					}
				}
			}
		}
	}
	
	public void receiveMessage(String sourceRouter, List<Message> routeTable) { // 接收路由表
		if (!work) {
			return;
		}
		synchronized(mq) {
			mq.add(new Pair<String, List<Message>>(sourceRouter, routeTable));
		}
	}
}

class NetSendRouteTable extends Thread { // 网络发送线程类
	private NetWork netWork;
	public NetSendRouteTable() {
		
	}
	
	public NetSendRouteTable(NetWork netWork) {
		this.netWork = netWork;
	}
	
	public void run() {
		while (true) {
			try {
				Thread.sleep(10);
			} catch (InterruptedException e) {
				break;
			}
			netWork.sendMessage();
		}
	}
}

Router.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
/**
 * 
 * @author 82177
 * 
 * @introduction 路由器类
 */

import java.text.SimpleDateFormat;
import java.util.*;

public class Router {
	
	private boolean work; // 工作状态
	private long delay = 3000; // delay 毫秒未接收到设为不可达
	private String name; // 名称
	private List<NetWork> netWorks; // 连接的网络
	private List<Router> linkRt; // 相邻路由表
	private List<Message> routeTable; // 路由表
	private List<UpdateInfo> updateLog; // 更新日志
	private Queue<List<Message>> mq; // 缓存队列
	private SendRouteTable sendThread; // 发送线程
	private UpdateRouteTable updateThread; // 更新线程
	private List<ReceiveClock> clock; // 相邻路由器的发送时钟
	
	public Router(String name) { // 构造函数
		this.name = name;
		this.netWorks = new ArrayList<NetWork>();
		this.routeTable = new ArrayList<Message>();
		this.linkRt = new ArrayList<Router>();
		this.updateLog = new ArrayList<UpdateInfo>();
		this.mq = new LinkedList<List<Message>>();
		this.sendThread = new SendRouteTable(this);
		this.updateThread = new UpdateRouteTable(this);
		this.clock = new ArrayList<ReceiveClock>();
	}
	
	public boolean isWork() {
		return work;
	}
	
	public void start() { // 开始工作
		work = true;
		connectNetWork(); // 初始化路由表
		sendThread = new SendRouteTable(this);
		updateThread = new UpdateRouteTable(this);
		sendThread.start();
		updateThread.start();
	}
	
	public void stop() { // 停止工作
		work = false;
		sendThread.interrupt();
		updateThread.interrupt();
		clear();
	}
	
	public void clear() { // 清空相关缓存
		mq.clear();
		routeTable.clear();
		updateLog.clear();
	}
	
	public void connectRouter(Router rt) { // 连接路由器
		linkRt.add(rt);
		clock.add(new ReceiveClock(rt.name, System.currentTimeMillis() + delay));
	}
	
	public void connectNetWork(NetWork net) { // 与某网络连接
		netWorks.add(net);
	}
	
	public void connectNetWork() { // 与相邻网络连接，初始化路由表
		for (NetWork net: netWorks) {
			routeTable.add(new Message(net.getNetName(), 1, "-"));
		}
	}
	
	public void setNetBroken(String net) { // 网络不可用
		for (int i = 0; i < routeTable.size(); i++) {
			Message m = routeTable.get(i);
			if (m.getNetName() == net) {
				m.setDist(16);
			}
		}
	}
	
	public void setRouterBroken(String rt) { // 路由器不可用
		for (int i = 0; i < routeTable.size(); i++) {
			Message m = routeTable.get(i);
			if (m.getNextRouter() == rt) {
				m.setDist(16);
			}
		}
	}
	
	public String getRtName() { // 获取路由器名称
		return name;
	}
	
	public void setRtName(String name) { // 设置路由器名称
		this.name = name;
	}
	
	public List<Message> copyTable(List<Message> routeTable) { // 复制路由表
		List<Message> rt = new ArrayList<Message>();
		for (int i = 0; i < routeTable.size(); i++) {
			rt.add(new Message(routeTable.get(i)));
		}
		return rt;
	}
	
	public void sendMessage() { // 发出路由表
		synchronized(routeTable) {
			for (int i = 0; i < netWorks.size(); i++) {
				netWorks.get(i).receiveMessage(name, copyTable(routeTable));
			}
		}
	}
	
	public void receiveMessage(Pair<String, List<Message>> msg) { // 接收路由表
		if (!work) {
			return;
		}
		String sourceRoute = msg.getFirst(); // 源路由器
		List<Message> msg1 = copyTable(msg.getSecond()); // 路由表
		changeRouteStatus(sourceRoute); // 修改发送时钟
		for (int i = 0; i < msg1.size(); i++) { // 对报文中所有项目进行更改
			Message m = msg1.get(i);
			m.setDist(m.getDist() + 1);
			m.setNextRouter(sourceRoute);
		}
		synchronized (mq) {
			mq.add(msg1);
		}
	}
	
	public void insertIntoLog(Message m1, Message m2) { // 将更新记录插入更新日志
		SimpleDateFormat tf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS");
		Message mm1 = new Message(m1);
		Message mm2 = new Message(m2);
		String date = tf.format(new Date());
		updateLog.add(new UpdateInfo(mm1, mm2, date));
	}
	
	public void changeRouteStatus(String rt) { // 收到新消息后，修改接收时钟
		for (int i = 0; i < clock.size(); i++) {
			ReceiveClock rc = clock.get(i);
			if (rc.getRouter() == rt) {
				rc.setTimes(System.currentTimeMillis() + delay);
				break;
			}
		}
	}
	
	public void checkRouteStatus() { // 检查是否在规定时间内收到相邻路由器的信息，并修改状态
		for (int i = 0; i < clock.size(); i++) {
			ReceiveClock rc = clock.get(i);
			if (System.currentTimeMillis() > rc.getTimes()) {
				setRouterBroken(rc.getRouter());
			}
		}
	}
	
	public void updateRoute() { // 更新路由表
		checkRouteStatus(); // 检查状态
		synchronized(routeTable) {
			synchronized(mq) {
				if (!mq.isEmpty()) {
					List<Message> list = mq.poll();
					for (Message msg: list) {
						boolean flag = false;
						for (int i = 0; i < routeTable.size(); i++) {
							Message m = routeTable.get(i);
							if (m.getNetName() == msg.getNetName()) { // 若有到N的路由
								flag = true;
								if (msg.getDist() >= 16) {
									msg.setDist(16);
								}
								if (m.getNextRouter() == msg.getNextRouter()) { // 若下一跳为 X
									insertIntoLog(new Message(m), new Message(msg)); // 更新日志
									m.setDist(msg.getDist());
								} else if (m.getDist() > msg.getDist()) { // 否则比较距离再更新
									insertIntoLog(new Message(m), new Message(msg)); // 更新日志
									m.setDist(msg.getDist());
									m.setNextRouter(msg.getNextRouter());
								}
							}
						}
						if (!flag) { // 若无到网络 N 的路由，则添加
							routeTable.add(new Message(msg));
							insertIntoLog(new Message(), new Message(msg));
						}
					}
				}
			}
			}
	}
	
	public String showRouteTable() {
		String s = "";
		s += name + "\t" + "路由表" + "\r\n";
		s += "网络 \t 距离 \t 下一跳" + "\r\n";
		for (Message m: routeTable) {
			s += m.toLocalString() + "\r\n";
		}
		return s;
	}
	
	public String showLog() { // 展示学习日志
		String s = "\t+--------------------------+" + "\r\n";
		s += "\t | " + name + "\t " + "学习日志" + " |" + "\r\n";
		s += "\t+--------------------------+" + "\r\n";
		s += "\r\n";
		s += "原信息项 \t\t 新信息项 \t\t 时间" + "\r\n";
		s += "--------------------------------------------------";
		s += "--------------------------------------------------" + "\r\n";
		for (int i = 0; i < updateLog.size(); i++) {
			Message m1 = updateLog.get(i).getM1();
			Message m2 = updateLog.get(i).getM2();
			String times = updateLog.get(i).getDate();
			s += m1 + " \t " + m2 + " \t " + times + "\r\n";
		}
		return s;
	}
	
}

class ReceiveClock { // 接收消息时钟
	private String router;
	private long times;
	
	public ReceiveClock() {
		router = null;
		times = 0;
	}
	
	public ReceiveClock(String router, long times) {
		this.router = router;
		this.times = times;
	}

	public String getRouter() {
		return router;
	}

	public void setRouter(String router) {
		this.router = router;
	}

	public long getTimes() {
		return times;
	}

	public void setTimes(long times) {
		this.times = times;
	}
}

class UpdateInfo { // 更新日志信息项
	private Message m1;
	private Message m2;
	private String date;
	
	public UpdateInfo() {
		
	}

	public UpdateInfo(Message m1, Message m2, String date) {
		this.m1 = m1;
		this.m2 = m2;
		this.date = date;
	}
	
	public Message getM1() {
		return m1;
	}
	
	public Message getM2() {
		return m2;
	}
	
	public String getDate() {
		return date;
	}
}

class UpdateRouteTable extends Thread { // 更新线程
	private Router router;
	
	public UpdateRouteTable(Router router) {
		this.router = router;
	}
	
	public void run() {
		while (true) {
			try {
				Thread.sleep(50);
				router.updateRoute();
			} catch (InterruptedException e) {
				break;
			}
		}
	}
}

class SendRouteTable extends Thread { // 发送线程
	private Router router;
	
	public SendRouteTable(Router router) {
		this.router = router;
	}
	
	public void run() { // 一秒钟发一次路由表
		while (true) {
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				break;
			}
			router.sendMessage();
		}
	}
}

Window.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Container;
import java.awt.FlowLayout;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.AbstractAction;
import javax.swing.JButton;
import javax.swing.JCheckBox;
import javax.swing.JComboBox;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JTextField;
import javax.swing.border.EtchedBorder;;

public class Window extends JFrame implements ActionListener{
	private String lyq[]= {"路由器1","路由器2","路由器3","路由器4","路由器5"};
	private String wl[]= {"网络1","网络2","网络3","网络4","网络5","网络6","网络7"};
	private String jb[]= {"保存","重置"};
	private JButton jbt[];//按钮
	private JCheckBox jcb[];//选择
	private JPanel JP1,JP2,jp,jp1,jp2,jp3,jp4,jp5,jp6;//面板
	private Container cp;//容器
	private JLabel jl1,jl2,jl3;//
	private JLabel jl[];//
	private NetWork net[];
	private Router rt[];
	private JComboBox<String> jcbb;
	private JScrollPane jsp1;//
	private JTextArea jta1;
	
	public void paint(Graphics g) {
    	super.paint(g);
//    	if (net[1].isWork()) {
    		g.drawLine(10,180,90,130);//网络1
//    	}
//    	if (net[2].isWork()) {
    		g.drawLine(110,130,270,130);//网络2
//    	}
//    	if (net[3].isWork()) {
    		g.drawLine(347,130,450,130);//网络3
//    	}
//    	if (net[4].isWork()) {
    		g.drawLine(527,130,660,150);//网络4
//    	}
//    	if (net[5].isWork()) {
    		g.drawLine(110,130,170,230);//网络5
//    	}
//    	if (net[6].isWork()) {
    		g.drawLine(247,230,350,230);//网络6
//    	}
//    	if (net[7].isWork()) {
    		g.drawLine(427,230,450,150);//网络7
//    	}
    }
	
	public Window(NetWork[] net, Router[] rt) {
		super();
		this.net = net;
		this.rt = rt;
		this.setBounds(100, 200, 1400, 600);//设置窗口大小和位置
		cp=this.getContentPane();
		cp.setLayout(new GridLayout(1,2));
		JP1=new JPanel(new GridLayout(2,1));
		jp=new JPanel();
		jp.setLayout(null);
		
		jbt=new JButton[7];
		jbt[0]=new JButton(lyq[0]);
		jbt[0].setBounds(80, 80, 80, 40);
		jbt[1]=new JButton(lyq[1]);
		jbt[1].setBounds(260, 80, 80, 40);
		jbt[2]=new JButton(lyq[2]);
		jbt[2].setBounds(440, 80, 80, 40);
		jbt[3]=new JButton(lyq[3]);
		jbt[3].setBounds(160, 180, 80, 40);
		jbt[4]=new JButton(lyq[4]);
		jbt[4].setBounds(340, 180, 80, 40);
		
		jp.add(jbt[0]);
		jp.add(jbt[1]);
		jp.add(jbt[2]);
		jp.add(jbt[3]);
		jp.add(jbt[4]);
		
		jl=new JLabel[wl.length];
		jl[0]=new JLabel();
		jl[0].setBounds(4, 65, 50, 50);
		jl[0].setText(wl[0]);
		jl[0].setForeground(Color.RED);
		jl[1]=new JLabel();
		jl[1].setBounds(190, 40, 50, 50);
		jl[1].setText(wl[1]);
		jl[1].setForeground(Color.RED);
		jl[2]=new JLabel();
		jl[2].setBounds(370, 40, 50, 50);
		jl[2].setText(wl[2]);
		jl[2].setForeground(Color.RED);
		jl[3]=new JLabel();
		jl[3].setBounds(565, 55, 50, 50);
		jl[3].setText(wl[3]);
		jl[3].setForeground(Color.RED);
		jl[4]=new JLabel();
		jl[4].setBounds(75, 140, 50, 50);
		jl[4].setText(wl[4]);
		jl[4].setForeground(Color.RED);
		jl[5]=new JLabel();
		jl[5].setBounds(270, 145, 50, 50);
		jl[5].setText(wl[5]);
		jl[5].setForeground(Color.RED);
		jl[6]=new JLabel();
		jl[6].setBounds(457, 130, 50, 50);
		jl[6].setText(wl[6]);
		jl[6].setForeground(Color.RED);
		
		jp.add(jl[0]);
		jp.add(jl[1]);
		jp.add(jl[2]);
		jp.add(jl[3]);
		jp.add(jl[4]);
		jp.add(jl[5]);
		jp.add(jl[6]);

		
		jp.setBorder(new EtchedBorder(EtchedBorder.RAISED));//边界
		JP1.add(jp);
		
		jp1=new JPanel(new GridLayout(5,1));
		jp2=new JPanel(new FlowLayout());
		jl1=new JLabel("请勾选有故障的路由器：");
		jp2.add(jl1);
		jp1.add(jp2);
		
		jp3=new JPanel(new FlowLayout());
		jcb=new JCheckBox[lyq.length+wl.length];
		for(int i=0;i<lyq.length;i++)
		{
			jcb[i]=new JCheckBox(lyq[i]);
			jp3.add(jcb[i]);
		}
		jp3.setBorder(new EtchedBorder(EtchedBorder.RAISED));//边界
		jp1.add(jp3);
		
		jp4=new JPanel(new FlowLayout());
		jl2=new JLabel("请勾选有故障的网络：");
		jp4.add(jl2);
		jp1.add(jp4);
		
		jp5=new JPanel(new FlowLayout());
		for(int i=0;i<wl.length;i++)
		{
			jcb[i+lyq.length]=new JCheckBox(wl[i]);
			jp5.add(jcb[i+lyq.length]);
		}
		jp5.setBorder(new EtchedBorder(EtchedBorder.RAISED));//边界
		jp1.add(jp5);
		
		jp6=new JPanel(new FlowLayout());
		jbt[5]=new JButton(jb[0]);
		jbt[6]=new JButton(jb[1]);
		jp6.add(jbt[5]);
		jp6.add(jbt[6]);
		jp1.add(jp6);
		
		for(int i=0;i<7;i++)
		{
			jbt[i].addActionListener(this);
		}
		
		JP1.add(jp1);
		JP1.setBorder(new EtchedBorder(EtchedBorder.RAISED));//边界
		cp.add(JP1);
		JP2=new JPanel(new FlowLayout());
		jl3=new JLabel();
		jl3.setText("选择路由器查看路由表更新日志：");
		JP2.add(jl3);
		jcbb=new JComboBox<String>(lyq);
		jcbb.addActionListener(new ActionListen());
		JP2.add(jcbb);
	    jta1 = new JTextArea(20, 35);
		jta1.setFont(new Font("微软雅黑", Font.BOLD, 18));
		JScrollPane jsp1 = new JScrollPane(jta1);
		jsp1.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);
		jsp1.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED);
		JP2.add(jsp1);
		cp.add(JP2);
		this.setVisible(true);
		this.setDefaultCloseOperation(EXIT_ON_CLOSE);
	}
	
//	public static void main(String args[])
//	{
//		new Window(null, null);
//	}

	@Override
	public void actionPerformed(ActionEvent e)
	{
		// TODO Auto-generated method stub
		if((JButton)e.getSource()==jbt[5])//点击保存按钮
		{
		    for(int i = 0; i < lyq.length; i++)
		    {
			    if(jcb[i].isSelected())
			    {
				    if (rt[i + 1].isWork()) {
				    	rt[i + 1].stop();//路由器线程暂停
				    }
			    }
			    else {
			    	if (!rt[i + 1].isWork()) {
			    		rt[i + 1].start();
			    	}
			    }
		    }
		
		    for(int i=0;i < wl.length;i++)
		    {
			    if(jcb[i + lyq.length].isSelected())
			    {
			    	if (net[i + 1].isWork()) {
			    		net[i+1].stop();
			    		jl[i].setForeground(Color.green);//网络线程关闭
			    	}
			    }
			    else {
			    	if (!net[i + 1].isWork()) {
			    		net[i+1].start();
			    		jl[i].setForeground(Color.red);
			    	}
			    }
		    }
		}
		
		if((JButton)e.getSource() == jbt[6])//点击重置按钮
		{
			for(int i = 0; i < wl.length; i++)
			{
				jcb[i + lyq.length].setSelected(false);
				if (net[i + 1].isWork()) {
					net[i + 1].stop();
				}
			    net[i + 1].start();
			    jl[i].setForeground(Color.red);
			}
			//路由器+网络线程全部设为工作状态
			for(int i = 0; i < lyq.length; i++)
			{
				jcb[i].setSelected(false);
				if (rt[i + 1].isWork()) {
					rt[i + 1].stop();
				}
				rt[i + 1].start();
			}
		}
		
		if((JButton)e.getSource()==jbt[0])//点击路由器1
		{
			new SubWindow(rt[1].showRouteTable());
		}
		if((JButton)e.getSource()==jbt[1])//点击路由器2
		{
			new SubWindow(rt[2].showRouteTable());
		}
		if((JButton)e.getSource()==jbt[2])//点击路由器3
		{
			new SubWindow(rt[3].showRouteTable());
		}
		if((JButton)e.getSource()==jbt[3])//点击路由器4
		{
			new SubWindow(rt[4].showRouteTable());
		}
		if((JButton)e.getSource()==jbt[4])//点击路由器5
		{
			new SubWindow(rt[5].showRouteTable());
		}
	}
	public class ActionListen implements ActionListener
	{
		public void actionPerformed(ActionEvent e)
		{
			if((String)jcbb.getSelectedItem()=="路由器1")//选择路由器1查看路由表更新日志
			{
				jta1.setText(rt[1].showLog());
			}
			if((String)jcbb.getSelectedItem()=="路由器2")//选择路由器2查看路由表更新日志
			{
				jta1.setText(rt[2].showLog());
			}
			if((String)jcbb.getSelectedItem()=="路由器3")//选择路由器3查看路由表更新日志
			{
				jta1.setText(rt[3].showLog());
			}
			if((String)jcbb.getSelectedItem()=="路由器4")//选择路由器4查看路由表更新日志
			{
				jta1.setText(rt[4].showLog());
			}
			if((String)jcbb.getSelectedItem()=="路由器5")//选择路由器5查看路由表更新日志
			{
				jta1.setText(rt[5].showLog());
			}
		}
	}
}


SubWindow.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
import java.awt.Container;
import java.awt.Font;

import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;

public class SubWindow extends JFrame{

	private JScrollPane jsp;//
	private Container con;
	
	
	public SubWindow(String s)
	{
		super();
		this.setBounds(470, 300, 400, 400);//设置窗口大小和位置
		con=new Container();
		con=this.getContentPane();
		JTextArea jta = new JTextArea(300, 300);
		jta.setFont(new Font("微软雅黑", Font.BOLD, 18));
		jta.setText(s);
		JScrollPane jsp = new JScrollPane(jta);
		jsp.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);
		jsp.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED);
		con.add(jsp);
		this.setTitle("路由表");
		this.setVisible(true);
	}
}

Main.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
import java.util.*;

/**
 * 
 * @author 82177
 * 
 * @introduction 运行类
 */


public class Main {
	public static Router[] rt;
	public static NetWork[] net;

	public static void addRouter(int n) {
		rt = new Router[n + 1];
		for (int i = 1; i <= n; i++) {
			rt[i] = new Router("路由器" + i);
		}
	}
	
	public static void addNetWork(int n) {
		net = new NetWork[n + 1];
		for (int i = 1; i <= n; i++) {
			net[i] = new NetWork("网络" + i);
		}
	}
	
	public static void initConnection() {
		rt[1].connectNetWork(net[1]);
		rt[1].connectNetWork(net[2]);
		rt[1].connectNetWork(net[5]);
		rt[1].connectRouter(rt[2]);
		rt[1].connectRouter(rt[4]);
		
		rt[2].connectNetWork(net[2]);
		rt[2].connectNetWork(net[3]);
		rt[2].connectRouter(rt[1]);
		rt[2].connectRouter(rt[3]);
		
		rt[3].connectNetWork(net[3]);
		rt[3].connectNetWork(net[4]);
		rt[3].connectNetWork(net[7]);
		rt[3].connectRouter(rt[2]);
		rt[3].connectRouter(rt[5]);
		
		rt[4].connectNetWork(net[5]);
		rt[4].connectNetWork(net[6]);
		rt[4].connectRouter(rt[1]);
		rt[4].connectRouter(rt[5]);
		
		rt[5].connectNetWork(net[6]);
		rt[5].connectNetWork(net[7]);
		rt[5].connectRouter(rt[3]);
		rt[5].connectRouter(rt[4]);
		
		net[1].connectRouter(rt[1]);
		
		net[2].connectRouter(rt[1]);
		net[2].connectRouter(rt[2]);

		net[3].connectRouter(rt[2]);
		net[3].connectRouter(rt[3]);
		
		net[4].connectRouter(rt[3]);

		net[5].connectRouter(rt[1]);
		net[5].connectRouter(rt[4]);

		net[6].connectRouter(rt[4]);
		net[6].connectRouter(rt[5]);
		
		net[7].connectRouter(rt[3]);
		net[7].connectRouter(rt[5]);
	}
	
	public static void startRouter() {
		for (int i = 1; i <= 5; i++) {
			rt[i].start();
		}
	}
	
	public static void startNetWork() {
		for (int i = 1; i <= 7; i++) {
			net[i].start();
		}
	}
	
	public static void showRouteTable() {
		for (int i = 1; i <= 5; i++) {
			rt[i].showRouteTable();
			rt[i].showLog();
		}
	}
	
	public static void main(String[] args) {
		addRouter(5);
		addNetWork(7);
		initConnection();
		startRouter();
		startNetWork();
		new Window(net, rt);
	}
}

文件全部放到一个默认Pakage里就能运行了。