正文
tcp服务器java代码,tcp服务端代码
提示：扫一扫查出行【扫一扫了解最新限行尾号】
复制提示
java写tcp客户端测试类该怎么写
1.TCP服务端的程序编写
package test;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;
public class MyTcp{
private BufferedReader reader;
private ServerSocket serverSocket;
private Socket socket;
/**
* 创建服务端的程序，读取客户端传来的数据
*/
void getserver(){
try {
serverSocket = new ServerSocket(8998); //实例化服务端socket
System.out.println("服务器套接字已经创建成功");
while (true) {
System.out.println("等待客户机的连接:");
socket = serverSocket.accept(); //实例化socket对象
reader = new BufferedReader(new InputStreamReader(socket.getInputStream())); //实例化BufferReader对象
getClientMessage();
}
} catch (Exception e) {
e.printStackTrace();
}
}
private void getClientMessage() {
try {
while (true) {
System.out.println("客户机传来的信息是："+reader.readLine());
}
} catch (Exception e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
MyTcp myTcp = new MyTcp(); //创建本类对象
myTcp.getserver();
}
}
2.TCP客户端程序编写
package test;
import java.awt.BorderLayout;
import java.awt.Container;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.PrintWriter;
import java.net.Socket;
import java.nio.channels.WritableByteChannel;
import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JTextField;
import javax.swing.border.BevelBorder;
public class MyTcpClient extends JFrame{
private PrintWriter printWriter;
Socket socket;
private JTextField jTextField = new JTextField();
private JTextArea jTextArea = new JTextArea();
Container container;
/**
* 创建的Tcp客户端程序
*/
public MyTcpClient (String title) {
super(title);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
container = this.getContentPane();
final JScrollPane jScrollPane = new JScrollPane();
jScrollPane.setBorder(new BevelBorder(BevelBorder.RAISED)); //显示边框
getContentPane().add(jScrollPane,BorderLayout.CENTER);
jScrollPane.setViewportView(jTextArea);
container.add(jTextField,"South"); //将文本框放在窗体下面
jTextField.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
printWriter.println(jTextField.getText()); //将文本框的信息写入流（为下面的输出流写入信息做准备）
jTextArea.append(jTextField.getText() + "\n");
jTextArea.setSelectionEnd(jTextArea.getText().length());
jTextField.setText(null);
}
});
}
private void connect() {
jTextArea.append("尝试连接中...\n");
try {
socket = new Socket("127.0.0.1",8998);
printWriter = new PrintWriter(socket.getOutputStream(),true); //将printwriter中的信息流写入到套接字的输出流传送给服务端
jTextArea.setText("已完成连接\n\n");
} catch (Exception e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
MyTcpClient myTcpClient = new MyTcpClient("向服务器发送数据");
myTcpClient.setSize(500,200);
myTcpClient.setVisible(true);
myTcpClient.connect();
}
}
3.效果展示
1先将服务端的程序跑起来
2再将客户端的程序跑起来
3.客户端和服务端进行交互
相关问答
Q1: 怎么用java写一个针对各种不同请求的TCP服务端
服务器监听端口 做个无限循环 接到一个连接就创建一个通道线程，并将通道线程存储到一个list集合中
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
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
/*
* 4.用socket通讯写出多个客户端和一个服务器端的通讯，
* 要求客户发送数据后能够回显相同的数据（回显功能）（实用TCP方式）。
*/
public class Test4Server {
// 主入口
public static void main(String[] args) throws IOException {
scoketServer();
}
// 开启的tcp8888监听端口
public static void scoketServer() throws IOException {
ServerSocket server = new ServerSocket(8888);
while (true) {
// 未连通前线程阻塞，连通后开启一个socket通道线程后继续监听8888端口
Socket socket = server.accept();
System.out.println(socket.getInetAddress().getHostAddress()
+ "连接进入");
new SocketThread(socket).start();
}
}
}
// 一个服务器端口中监听多个客服端通道线程
class SocketThread extends Thread {
// 所有通道写入流的集合
private static ListPrintWriter list =new ArrayListPrintWriter();
private BufferedReader bufferedReader;
private PrintWriter printWriter;
public SocketThread(Socket socket) throws IOException {
this.bufferedReader = new BufferedReader(new InputStreamReader(socket
.getInputStream()));
this.printWriter = new PrintWriter(socket.getOutputStream());
list.add(printWriter);
}
@Override
public void run() {
String string = null;
while (true) {
try {
// 服务器在通道中读到的信息回显给客服端
string = bufferedReader.readLine();
System.out.println("客服端信息：" + string);
for(PrintWriter printWriter:list ){
printWriter.write("服务器回显：" + string + "\r\n");
printWriter.flush();
}
} catch (IOException e) {
}
}
}
}
客服端代码 可以用在局域网中用多台来连接测试
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
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.Scanner;
public class Test4Client {
public static Object obj = new Object();
// 客服端的主入口
public static void main(String[] args) throws IOException {
socketClient();
}
// 与服务器连通地址本机（127.0.0.1），局域网中其他机器是（服务器在局域网中的ip地址） 端口都是8888
public static void socketClient() throws IOException {
Socket socket = new Socket("127.0.0.1", 8888);
if (socket.isConnected()) {
// 如果连接成功了就开启写和读的进程
new writer(socket).start();
new read(socket).start();
} else {
System.out.println("服务器未开启");
}
}
}
// 写入到通道的线程
class writer extends Thread {
@SuppressWarnings("unused")
private Socket socket;
private PrintWriter printWriter;
private Scanner scanner = new Scanner(System.in);
private String str = null;
public writer(Socket socket) throws IOException {
this.socket = socket;
this.printWriter = new PrintWriter(socket.getOutputStream());
}
@Override
public void run() {
scanner.useDelimiter("\r\n");
while (true) {
System.out.print("请输入信息：");
// 产生扫描器的线程阻塞
str = scanner.next();
System.out.println("我说："+str);
printWriter.write(str + "\r\n");
printWriter.flush();
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
// 从通道中读取的线程
class read extends Thread {
private Socket socket;
private BufferedReader bufferedReader;
private String str = null;
public read(Socket socket) throws IOException {
this.socket = socket;
this.bufferedReader = new BufferedReader(new InputStreamReader(socket
.getInputStream()));
}
@Override
public void run() {
while (true) {
try {
str = bufferedReader.readLine();
System.out.println(str);
} catch (IOException e) {
}
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
Q2: 在Java中实现TCP协议编程中怎么传
在Java中实现TCP协议编程
ServerSocket：编写TCP网络服务程序,首先要用到java.net.ServerSocket类用以创建服务器Socket
构造方法：
ServerSocket(int port)：创建绑定到特定端口的服务器套接字
ServerSocket(int port, int backlog)：利用指定的backlog(服务器忙时保持连接请求的等待客户数量),创建服务器套接字并将其绑定到指定的本地端口号。
ServerSocket(int port, int backlog, InetAddress bindAddr)：使用指定的端口、侦听 backlog 和要绑定到的本地 IP 地址创建服务器。
Socket：客户端要与服务器建立连接,必须先创建一个Socket对象
常用构造方法
Socket(String host, int port)：创建一个流套接字并将其连接到指定主机上的指定端口号。
Socket(InetAddress address, int port)：创建一个流套接字并将其连接到指定 IP 地址的指定端口号。
服务器端程序调用ServerSocket类中的accept()方法等待客户端的连接请求，一旦accept()接收了客户端连接请求，该方法返回一个与该客户端建立了专线连接的Socket对象，不用程序去创建这个Socket对象。建立了连接的两个Socket是以IO流的方式进行数据交换的，Java提供了Socket类中的getInputStream()返回Socket的输入流对象，getOutputStream()返回Socket的输出流对象。
TCP服务器与TCP客户端间的数据的接受图示：
创建一个TCP服务器端程序的步骤
（1）创建一个ServerSocket
（2）从ServerSocket接受客户连接请求
（3）创建一个服务线程处理新的连接
（4）在服务线程中，从socket中获得I/O流
（5）对I/O流进行读写操作，完成与客户的交互
（6）关闭I/O流
（7）关闭Socket
ServerSocket server=new ServerSocket(port)
Socket s =server.accept();
ObjectInputStream in=new ObjectInputStream(s.getInputStream());
ObjectOutputStream out=new ObjectOutputStream(s.getOutputStream());
out.close();
in.close();
s.close();
创建一个TCP客户端程序的步骤
（1）创建Socket
（2）获得I/O流
（3）对I/O流进行读写操作
（4）关闭I/O流
（5）关闭Socket
Socket connection =new Socket(127.0.0.1,9009);
ObjectInputStream input=new ObjectInputStream(connection.getInputStream());
ObjectOutputStream output=new ObjectOutputStream(connection.getOutputStream());
output.close();
input.close();
connection.close();
用TCP实现服务器与客户端的“聊天”：
实例代码：
客户端：
package com.hbsi.net;
import java.net.Socket;
import java.io.*;
public class TcpClient{
public static void main(String[] args) throws Exception {
// 1.建立tcp客户端socket，要确定要连接的服务器ip，port
Socket s = new Socket("192.168.49.87", 9009);
// 获取键盘录入
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
// 2.通过建立的socket，获取输出流对象
// 数据输出给服务器端
OutputStream out = s.getOutputStream();
BufferedWriter bwout = new BufferedWriter(new OutputStreamWriter(out));
// 获取服务器端返回的数据
// 读取服务器端发过来的信息InputStreamReader()
BufferedReader brin = new BufferedReader(new InputStreamReader(
s.getInputStream()));
String line = null;
while ((line = br.readLine()) != null) {
if (line.equals("over"))
break;
bwout.write(line);
bwout.newLine();
bwout.flush();
String str = brin.readLine();
System.out.println("server:" + str);
}
br.close();
s.close();
}
}
服务器端：
package com.hbsi.net;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.ServerSocket;
import java.net.Socket;
public class TcpServer{
public static void main(String[] args) throws Exception {
// 1.建立服务器socket
ServerSocket ss = new ServerSocket(9009);
// 2.调用accept()
Socket s = ss.accept();
System.out.println(s.getInetAddress().getHostAddress()
+ "...connection");
// 读取客户的信息的输入流
InputStream in = s.getInputStream();
BufferedReader brin = new BufferedReader(new InputStreamReader(in));
// 向客户端发送信息输出流，服务端向客户端返回信息OutputStreamWriter()
BufferedWriter brout = new BufferedWriter(new OutputStreamWriter(
s.getOutputStream())); String line = null;
while ((line = brin.readLine()) != null) {
System.out.println("client:" + line);
brout.write(line.toUpperCase());//服务器端收到信息后，将信息转为大写返回给客户端toUpperCase()
brout.newLine();
brout.flush();
}
s.close();
ss.close();
}
}
