在完成java单机五子棋后，我开始尝试写联机五子棋（局域网内，因为没有公网IP）。上次的五子棋写的很乱，全部写在一个类中，这次我采用面向对象的思想，把特定的功能和属性都写成一个类。代码分为两部分，客户端和服务端。客户端是用AWT写的，主要由一个五子棋面板和一个功能键面板构成。网络通信使用的是TCP，通过序列化和反序列化完成消息的读和写。运行的时候先运行服务端程序，接着运行两个客户端，代码放在了文章的最后。
下面是客户端运行的效果：
这里是代码包的结构：
接着我来依次说下这些类所完成的功能
Media包
Media包：主要是放了五子棋的背景图片和播放音乐的类以及音乐内容
播放音乐这个类是我从室友那拿的，所以我也不是很懂，瞄了一眼是用Applet完成的，只能处理.wav后缀的音乐
Net包
Net包：包含两个类，细心的小伙伴应该注意到客户端是没有主方法的。客户端中其实是包含与服务端进行通信的socket的，其中包含一些读和写的方法。服务端我采用的是线程池的方法来处理客户端的请求（线程池这部分我也不是特别了解，用起来和多线程感觉差不多）。
View包
View包：包含四个类，分别是ChessBoard,ChessPanel,Pieces和WhoWin 类
ChessBoard是一个包含Main方法的JFrame,命令面板和棋盘面板都是添加到这个JFrame中的。
ChessPanel是一个棋盘面板，里面完成了如：画19*19的棋盘线条，加载背景图片，不停的接收来自服务端的消息并处理（把棋子加到面板），处理每次点击后添加棋子到面板并发送棋子到服务器，判断胜负并且给出提示消息。
Pieces是一个棋子，其中有包含如颜色，棋子半径，棋子位置和命令（和前面的命令面板配合使用，默认是发送）等属性。
WhoWin就是五子棋中判断谁输谁赢的部分。每下一步就需要判断。
播放音乐的类：
|
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
|
package Media.Music;import java.io.File;import java.io.IOException;import javax.sound.sampled.AudioInputStream;import javax.sound.sampled.AudioSystem;import javax.sound.sampled.Clip;import javax.sound.sampled.LineUnavailableException;import javax.sound.sampled.UnsupportedAudioFileException;public class PlayMusic { private Clip clip; public PlayMusic(String filePath) throws LineUnavailableException, UnsupportedAudioFileException, IOException { File file = new File(filePath); AudioInputStream audioInputStream = AudioSystem.getAudioInputStream(file); clip = AudioSystem.getClip(); clip.open(audioInputStream); } public void play() { clip.setFramePosition(1); clip.start(); } public void loop() { clip.loop(Clip.LOOP_CONTINUOUSLY); } public void stop() { clip.stop(); }} |
TcpClient:
|
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
|
package net;import view.Pieces;import java.io.*;import java.net.Socket;public class TcpClient{ private Socket socket; private ObjectInputStream ois; private ObjectOutputStream oos; public TcpClient(Socket socket,ObjectInputStream ois,ObjectOutputStream oos){ this.socket= socket; this.ois = ois; this.oos = oos; } public Socket getSocket() { return socket; } public void setSocket(Socket socket) { this.socket = socket; } public ObjectInputStream getOis() { return ois; } public void setOis(ObjectInputStream ois) { this.ois = ois; } public ObjectOutputStream getOos() { return oos; } public void setOos(ObjectOutputStream oos) { this.oos = oos; } public void send(Pieces pieces) throws IOException { oos.writeObject(pieces); System.out.println(socket+"向服务器发送消息"); } public Pieces accept() throws IOException, ClassNotFoundException { Pieces pieces = (Pieces) ois.readObject(); System.out.println(socket+"从服务器读取消息"); return pieces; } public void close(){ ; }} |
TcpServer:
|
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
|
package net;import view.Pieces;import java.io.*;import java.net.ServerSocket;import java.net.Socket;import java.net.SocketException;import java.util.ArrayList;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;public class TcpServer { public static void main(String[] args) { // 保存客户端处理的线程 ArrayList<UserThread> userList = new ArrayList<>(); // 固定大小的线程池只支持两个线程，用来处理客户端 ExecutorService es = Executors.newFixedThreadPool(2); try { ServerSocket server = new ServerSocket(10086); System.out.println("服务器已经启动，正在等待客户端连接......"); while (true) { //接收客户端的Socket，如果没有客户端连接就一直卡在这里 Socket socket = server.accept(); // 每来一个用户就创建一个线程 UserThread user = new UserThread(socket, userList); // 开启线程 es.execute(user); } } catch (IOException e) { e.printStackTrace(); } }} class UserThread implements Runnable { private Socket socket = null; private static ArrayList<UserThread> list; // 客户端线程集合 private ObjectOutputStream oos; private ObjectInputStream ois; private boolean flag = true;// 标记 public UserThread(Socket socket, ArrayList<UserThread> list) { this.socket = socket; this.list = list; list.add(this); // 把当前线程加入list中 } @Override public void run() { UserThread user = null; try { System.out.println("客户端:" + socket.getInetAddress().getHostAddress() + "已经连接"); ois = new ObjectInputStream(socket.getInputStream()); oos = new ObjectOutputStream(socket.getOutputStream()); while(true){ Pieces pieces = (Pieces) ois.readObject(); // 客户端发给服务端的消息，把他写到其它套接字中去 int size = list.size(); for (int i = 0; i < size; i++) { user = list.get(i); if (user.socket != socket) { user.oos.writeObject(pieces); System.out.println("从"+socket+"向"+user.socket+"发送消息"); } } } } catch(SocketException e){ // todo 客户端掉线后，移除客户端。没想好{1.从客户端列表移除当前元素，关闭当前：socket，通知另一方：这一方已经掉线，然后关闭这一方的socket} try { int i = list.size(); if (i ==2){ list.remove(user); System.out.println("已经删除了一个客户端"); list.get(0).oos.writeObject(new Pieces("对方掉线")); }else if (i==1){ list.remove(0); System.out.println("又移除了另一个客户端"); } } catch (IOException ex) { ex.printStackTrace(); } } catch (IOException e) { e.printStackTrace(); } catch (ClassNotFoundException e) { e.printStackTrace(); } }} |
ChessBoard:
|
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
|
/** 1.变量值不变的问题* 2.输入输出流先后顺序的问题（socket阻塞）* 3.socket 短连接不关闭输入输出流，为何看起来就像长连接一样（长短连接的区别是什么）* */// todo 一个提示框package view;import Media.Music.PlayMusic;import javax.sound.sampled.LineUnavailableException;import javax.sound.sampled.UnsupportedAudioFileException;import javax.swing.*;import java.awt.*;import java.awt.event.ActionEvent;import java.awt.event.ActionListener;import java.io.IOException;public class ChessBoard extends JFrame implements ActionListener { private JButton PlayMusic = new JButton("播放音乐"); private ChessPanel chessPanel; private Panel CommandPanel = new Panel(); private JButton reStart = new JButton("重新开始"); private JButton fail = new JButton("认输"); private JButton Regret = new JButton("悔棋"); private String command=null; // 触发按钮后发送的命令 private PlayMusic music = null; private int count = 1; // todo 静态语句块 { try { music = new PlayMusic("./src/Media/Music/bg3.wav"); } catch (LineUnavailableException e) { e.printStackTrace(); } catch (UnsupportedAudioFileException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } } public ChessBoard() { this.setTitle("欢乐五子棋"); chessPanel = new ChessPanel(); this.add(chessPanel,BorderLayout.CENTER); reStart.addActionListener(this); fail .addActionListener(this); Regret.addActionListener(this); PlayMusic.addActionListener(this); CommandPanel.add(reStart); CommandPanel.add(fail); CommandPanel.add(Regret); CommandPanel.add(PlayMusic); this.add(CommandPanel,BorderLayout.SOUTH); this.setBounds(10, 10, 800, 800); this.setVisible(true); this.setResizable(false); this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); } public static void main(String[] args) { ChessBoard Board = new ChessBoard(); } @Override public void actionPerformed(ActionEvent e) { if(e.getSource()==reStart){ command ="重新开始"; chessPanel.canPlay = true; }else if(e.getSource()==fail){ command ="认输"; JOptionPane.showMessageDialog(chessPanel,"It's a pity,you have fail the game!"); chessPanel.canPlay = false; }else if (e.getSource()==Regret){ command ="悔棋"; }else if (e.getSource()==PlayMusic){ // todo 播放音乐,单数次播放； if (count%2==1){ music.play(); }else { music.stop(); } count++; command = null; } if(command!=null){ Pieces pieces = new Pieces(command); try { this.chessPanel.client.send(pieces); } catch (IOException ex) { ex.printStackTrace(); } } }} |
ChessPanel:
|
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
|
package view;// 五子棋面板，就是在这里面画图。// todo 背景图片 ，也许一个背景音乐import net.TcpClient;import javax.swing.*;import java.awt.*;import java.awt.event.MouseEvent;import java.awt.event.MouseListener;import java.io.IOException;import java.io.ObjectInputStream;import java.io.ObjectOutputStream;import java.net.ConnectException;import java.net.Socket;import java.util.ArrayList;import java.util.Iterator;public class ChessPanel extends JPanel implements MouseListener{ // TODO 从服务器接收来的棋子 ，值不变有问题// Pieces accept_pieces = new Pieces();// Pieces send_pieces = new Pieces(); whoWin ifWin =new whoWin() ; // 是否胜利 TcpClient client = null; // 客户端 boolean canPlay = true; // 是否能继续玩 boolean isBlack = true; // 是否黑子，黑1,白2 ArrayList<Pieces> allPieces = new ArrayList<>(); // 存储棋子对象,就是通过这个画图的 int [][] allChess = new int[19][19]; int PanelWidth; int PanelHeight; int width = 600; int height = 600; int temp = width / 18; int xbase,ybase; Image image = Toolkit.getDefaultToolkit().getImage("./src/Media/bg.jpeg"); // "./"表示当前项目下 public ChessPanel(){ this.addMouseListener(this); try { Socket socket = new Socket("172.27.29.190", 10086); //TODO 构建输出输入流,输入输出流问题，先输出后输入 ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream()); ObjectInputStream ois = new ObjectInputStream(socket.getInputStream()); client = new TcpClient(socket,ois,oos); new Thread(new getMessage()).start(); // 开启读取的线程 } catch (ConnectException e){ System.out.println("服务器拒绝连接！"); } catch (IOException e) { e.printStackTrace(); }catch(Exception e ){ e.printStackTrace(); } } // 画图部分 public void paintComponent(Graphics g) { super.paintComponent(g); PanelWidth = this.getSize().width; // 这两步骤 PanelHeight = this.getSize().height; xbase = (PanelWidth - width) / 2; ybase = (PanelHeight - height) / 2; Graphics2D g2d = (Graphics2D) g;// this.setBackground(new Color(246, 186, 114)); g2d.drawImage(image,0,0,this.getWidth(),this.getHeight(),this); int x1, y1, x2, y2; // 画线 for (int i = 0; i < 19; i++) { if (i == 0 || i == 18) { g2d.setStroke(new BasicStroke(3.0f)); } else g2d.setStroke(new BasicStroke(1.0f)); x1 = xbase + temp * i; y1 = ybase; y2 = ybase + 18 * temp; g2d.drawLine(x1, y1, x1, y2); x1 = xbase; y1 = ybase + temp * i; x2 = xbase + temp * 18; g2d.drawLine(x1, y1, x2, y1); } // 开始画棋子 int radius ; int xPos,yPos; Iterator it = allPieces.iterator(); // 迭代器遍历arraylist while(it.hasNext()){ Pieces pieces = (Pieces) it.next(); radius = pieces.getRadius(); xPos = pieces.getxPos(); yPos = pieces.getyPos(); System.out.println(pieces.getColor()+","+pieces.getxPos()+","+pieces.getyPos()); if (pieces.getColor() == 1){ g2d.setColor(Color.black); g2d.fillOval(xPos*temp+xbase-radius/2,yPos*temp+ybase-radius/2,radius,radius); } else if (pieces.getColor() == 2) { g2d.setColor(Color.white); g2d.fillOval(xPos * temp + xbase - radius / 2, yPos * temp + ybase - radius / 2, radius, radius); } } } @Override public void mousePressed(MouseEvent e) { int x ,y ; if (canPlay) { x = e.getX(); y = e.getY(); // 判断鼠标点击位置 if (x >= xbase & x <= (xbase + 18 * temp) & y >= ybase & y < (ybase + 18 * temp)) { // 判断是不是下在空的位置 int tempX = (x - xbase) / temp, tempY = (y - ybase) / temp; // todo 这里是关键判断这点坐标的数组下标是什么 if ((x - xbase) % temp > temp / 2) { x = tempX + 1; } else x = tempX; if ((y - ybase) % temp > temp / 2) y = tempY + 1; else y = tempY; // 先判断有没有棋子，处理没有棋子的情况 if (allChess[x][y] != 0) { JOptionPane.showMessageDialog(this, "这里有棋子了"); } else { Pieces send_pieces = new Pieces(); send_pieces.setxPos(x); send_pieces.setyPos(y); if (isBlack){ send_pieces.setColor(1); allChess[x][y] = 1; isBlack = false; } else{ send_pieces.setColor(2); allChess[x][y]=2; isBlack = true; } allPieces.add(send_pieces); // 向棋子队列加入当前棋子 canPlay = false;// canPlay在true情况下， 点击一次后不能点击了 this.repaint(); ifWin = new whoWin(allChess,x,y); // 如果赢了，就不能玩了，并且给出提示消息，你赢了; if(ifWin.isWin()){ canPlay = false; JOptionPane.showMessageDialog(this,"Congratulations you have won tha game !"); } try { if (client!=null){ client.send(send_pieces); } } catch (IOException ex) { ex.printStackTrace(); } } } } } // 读取来自服务器端的信息 class getMessage implements Runnable{ private boolean flag = true; public void setFlag(boolean flag) { this.flag = flag; } @Override public void run() { // 循环读 while(flag){ if(client!=null){ try { Pieces accept_pieces = client.accept(); String command = accept_pieces.getCommand(); int color = accept_pieces.getColor(); switch (command){ case "发送":{ canPlay = true; if (color == 1){ isBlack = false;//对方为黑我为白 }else{ isBlack = true; } allPieces.add(accept_pieces); allChess[accept_pieces.getxPos()][accept_pieces.getyPos()]= accept_pieces.getColor(); ChessPanel.this.repaint(); ifWin.setY(accept_pieces.getyPos()); ifWin.setX(accept_pieces.getxPos()); ifWin.setAllChess(allChess); if(ifWin.isWin()){ canPlay = false; JOptionPane.showMessageDialog(ChessPanel.this,"It's a pity you have fail the game!"); } break; } case "悔棋":{ int i = JOptionPane.showConfirmDialog(ChessPanel.this,"对方请求悔棋，是否同意！"); // yes 0,no 1,cancel 2,closed -1 Pieces pieces = new Pieces(); if (i == 0){ // 同意悔棋:1.同意对方悔棋 pieces.setCommand("同意悔棋"); // arraylist 去除末尾的两个值，对应allChess置0 int size = allPieces.size(); for (int j = 1;j<=2;j++){ allChess[allPieces.get(size-j).getxPos()][allPieces.get(size-j).getyPos()]=0; allPieces.remove(size-j); } ChessPanel.this.repaint(); }else if(i==1){ pieces.setCommand("不同意悔棋"); } client.send(pieces); break; } case "认输":{ // 不能继续玩下去，你已经胜利 JOptionPane.showMessageDialog(ChessPanel.this,"对方认输"); canPlay = false; JOptionPane.showMessageDialog(ChessPanel.this,"Congratulations you have won tha game !"); break; } case "重新开始":{ // 是否同意重新开始 int i = JOptionPane.showConfirmDialog(ChessPanel.this,"对方请求重新开始，是否同意"); Pieces pieces = new Pieces(); if(i == 0){// allChess 和 allPieces全部置0; pieces.setCommand("同意重新开始"); int size = allPieces.size(); System.out.println("arraylist 长度："+size); for (int j = 0;j<size;j++){// 移除队首元素 allChess[allPieces.get(0).getxPos()][allPieces.get(0).getyPos()] = 0; allPieces.remove(0); } canPlay = true; ChessPanel.this.repaint(); }else if (i ==1){ pieces.setCommand("不同意重新开始"); } client.send(pieces); break; } case "同意悔棋":{// allpieces 和 allchess 回退 JOptionPane.showMessageDialog(ChessPanel.this,"对方同意悔棋"); int size = allPieces.size(); for (int j = 1;j<=2;j++){ allChess[allPieces.get(size-j).getxPos()][allPieces.get(size-j).getyPos()]=0; allPieces.remove(size-j); } ChessPanel.this.repaint(); break; } case "不同意悔棋":{ JOptionPane.showMessageDialog(ChessPanel.this,"对方不同意悔棋"); break; } case "同意重新开始":{ // 全部置0,调用repaint 方法 JOptionPane.showMessageDialog(ChessPanel.this,"对方同意重新开始"); int size = allPieces.size(); for (int j = 0;j<size;j++){ // todo 移除队首元素arraylist 长度改变；序列也发生改变 allChess[allPieces.get(0).getxPos()][allPieces.get(0).getyPos()] = 0; allPieces.remove(0); } canPlay = true; ChessPanel.this.repaint(); break; } case "不同意重新开始":{ JOptionPane.showMessageDialog(ChessPanel.this,"对方不同意重新开始"); break; } case "对方掉线":{ // 对方已经掉线 JOptionPane.showMessageDialog(ChessPanel.this,"不好意思，对方已经掉线！"); canPlay = false; break; } } } catch (IOException e) { e.printStackTrace(); } catch (ClassNotFoundException e) { e.printStackTrace(); } } } } } @Override public void mouseClicked(MouseEvent e) { } @Override public void mouseReleased(MouseEvent e) { } @Override public void mouseEntered(MouseEvent e) { } @Override public void mouseExited(MouseEvent e) { } } |
Pieces:
|
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
|
package view; import java.io.Serializable;// 存储棋子的相关信息public class Pieces implements Serializable { private int radius = 16; private int color = 0; private int xPos ; private int yPos; private String command = "发送"; public String getCommand() { return command; } public void setCommand(String command) { this.command = command; } public Pieces(int color, int xPos, int yPos){ this.color = color; this.xPos = xPos; this.yPos = yPos; } public Pieces(){ } public Pieces(String command){ this.command = command; } public int getRadius() { return radius; } public void setRadius(int radius) { this.radius = radius; } public int getColor() { return color; } public void setColor(int color) { this.color = color; } public int getxPos() { return xPos; } public void setxPos(int xPos) { this.xPos = xPos; } public int getyPos() { return yPos; } public void setyPos(int yPos) { this.yPos = yPos; }} |
WhoWin：
|
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
|
package view;public class whoWin { // 判断是谁赢了 private int allChess[][] = new int[19][19]; private int x = 0; private int y = 0; public whoWin(){ } public whoWin(int allChess[][],int x,int y){ this.allChess = allChess; this.x = x; this.y = y; } public void setAllChess(int allChess[][]){ this.allChess = allChess; } public void setX(int x){ this.x = x; } public void setY(int y ){ this.y = y; } public boolean isWin() { int color = allChess[x][y]; int count; count = this.Count(1, 0, color); // 对横方向的判断 if (count >= 5) { return true; } else { count = this.Count(0, 1, color); // 对竖方向的判断 if (count >= 5) { return true; } else { count = this.Count(1, 1, color); // 对左上方向的判断 if (count >= 5) return true; else { count = this.Count(1, -1, color); // 对右上方向的判断 if (count >= 5) return true; } } } return false; } private int Count(int xChange, int yChange, int color) { int count = 1; int tempX = xChange, tempY = yChange; while (color == allChess[x + xChange][y + yChange]) { count++; if (xChange != 0) { xChange++; } if (yChange != 0) { if (yChange > 0) yChange++; else yChange--; } } xChange = tempX; yChange = tempY; while (color == allChess[x - xChange][y - yChange]) { count++; if (xChange != 0) xChange++; if (yChange != 0) { if (yChange > 0) yChange++; else yChange--; } } return count; }} |
最后，希望我的代码能对你有所帮助，大家一起加油呀！
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持服务器之家。
原文链接：https://blog.csdn.net/qq_47764019/article/details/122021403
