java服务器tcp

㈠ 在java中实现TCP协议编程中怎么传

在Java中实现TCP协议编程

ServerSocket：编写TCP网络服务程序,首先要用到java.net.ServerSocket类用以创建服务器Socket

构造方法：

ServerSocket(intport)：创建绑定到特定端口的服务器套接字

ServerSocket(intport,intbacklog)：利用指定的backlog(服务器忙时保持连接请求的等待客户数量),创建服务器套接字并将其绑定到指定的本地端口号。

ServerSocket(intport,intbacklog,InetAddressbindAddr)：使用指定的端口、侦听backlog和要绑定到的本地IP地址创建服务器。

Socket：客户端要与服务器建立连接,必须先创建一个Socket对象

常用构造方法

Socket(Stringhost,intport)：创建一个流套接字并将其连接到指定主机上的指定端口号。

Socket(InetAddressaddress,intport)：创建一个流套接字并将其连接到指定IP地址的指定端口号。

服务器端程序调用ServerSocket类中的accept()方法等待客户端的连接请求，一旦accept()接收了客户端连接请求，该方法返回一个与该客户端建立了专线连接的Socket对象，不用程序去创建这个Socket对象。建立了连接的两个Socket是以IO流的方式进行数据交换的，Java提供了Socket类中的getInputStream()返回Socket的输入流对象，getOutputStream()返回Socket的输出流对象。

TCP服务器与TCP客户端间的数据的接受图示：

用TCP实现服务器与客户端的“聊天”：

实例代码：

客户端：

packagecom.hbsi.net;

importjava.net.Socket;

importjava.io.*;

publicclassTcpClient{

publicstaticvoidmain(String[]args)throwsException{

//1.建立tcp客户端socket，要确定要连接的服务器ip，port

Sockets=newSocket("192.168.49.87",9009);

//获取键盘录入

BufferedReaderbr=newBufferedReader(newInputStreamReader(System.in));

//2.通过建立的socket，获取输出流对象

//数据输出给服务器端

OutputStreamout=s.getOutputStream();

BufferedWriterbwout=newBufferedWriter(newOutputStreamWriter(out));

//获取服务器端返回的数据

//读取服务器端发过来的信息InputStreamReader()

BufferedReaderbrin=newBufferedReader(newInputStreamReader(

s.getInputStream()));

Stringline=null;

while((line=br.readLine())!=null){

if(line.equals("over"))

break;

bwout.write(line);

bwout.newLine();

bwout.flush();

Stringstr=brin.readLine();

System.out.println("server:"+str);

}

br.close();

s.close();

}

}

服务器端：

packagecom.hbsi.net;

importjava.io.BufferedReader;

importjava.io.BufferedWriter;

importjava.io.InputStream;

importjava.io.InputStreamReader;

importjava.io.OutputStreamWriter;

importjava.net.ServerSocket;

importjava.net.Socket;

publicclassTcpServer{

publicstaticvoidmain(String[]args)throwsException{

//1.建立服务器socket

ServerSocketss=newServerSocket(9009);

//2.调用accept()

Sockets=ss.accept();

System.out.println(s.getInetAddress().getHostAddress()

+"...connection");

//读取客户的信息的输入流

InputStreamin=s.getInputStream();

BufferedReaderbrin=newBufferedReader(newInputStreamReader(in));

//向客户端发送信息输出流，服务端向客户端返回信息OutputStreamWriter()

BufferedWriterbrout=newBufferedWriter(newOutputStreamWriter(

s.getOutputStream())); Stringline=null;

while((line=brin.readLine())!=null){

System.out.println("client:"+line);

brout.write(line.toUpperCase());//服务器端收到信息后，将信息转为大写返回给客户端toUpperCase()

brout.newLine();

brout.flush();

}

s.close();

ss.close();

}

}

㈡ java如何通过tcp向指定的IP发送指令并获得返回的包

以下是一个展示java使用tcp通讯的简单例子，包括服务器和客户端代码：

/**
*TCPServer
*/
import java.io.*;
import java.net.*;
class TCPServer{
public static void main(String[] args)throws IOException{
ServerSocket listen = new ServerSocket(5050);

Socket server = listen.accept();
InputStream in = server.getInputStream();
OutputStream out = server.getOutputStream();
char c = (char)in.read();
System.out.println("收到:" + c);
out.write('s');

out.close();
in.close();
server.close();
listen.close();
}
}

/**
*TCPClient
*/
import java.io.*;
import java.net.*;
class TCPClient{
public static void main(String[] args)throws IOException{
Socket client = new Socket("127.0.0.1" , 5050);
InputStream in = client.getInputStream();
OutputStream out = client.getOutputStream();

out.write('c');
char c = (char)in.read();
System.out.println("收到:" + c);
out.close();
in.close();
client.close();
}
}

㈢ JAVA的TCP服务器搭建

请自行参考TCP/udp连接基础解释，然后根据自身问题进行排查。

㈣ 用java做一个TCP服务器怎么样

想要用java做一个TCP服务器，就可以使用java网络编程中的java Socket！
服务器的socket是ServerSocket这个类，他的构造方法是：
ServerSocket ss=new ServerSocket(9999);//在端口9999监听
ss.accpect();//静静等待客户端连接！

㈤ java如何通过tcp发送指令

以下是一个展示java使用tcp通讯的简单例子，包括服务器和客户端代码：

/**
*TCPServer
*/
import java.io.*;
import java.net.*;
class TCPServer{
public static void main(String[] args)throws IOException{
ServerSocket listen = new ServerSocket(5050);

Socket server = listen.accept();
InputStream in = server.getInputStream();
OutputStream out = server.getOutputStream();
char c = (char)in.read();
System.out.println("收到:" + c);
out.write('s');

out.close();
in.close();
server.close();
listen.close();
}
}

/**
*TCPClient
*/
import java.io.*;
import java.net.*;
class TCPClient{
public static void main(String[] args)throws IOException{
Socket client = new Socket("127.0.0.1" , 5050);
InputStream in = client.getInputStream();
OutputStream out = client.getOutputStream();

out.write('c');
char c = (char)in.read();
System.out.println("收到:" + c);
out.close();
in.close();
client.close();
}
}

㈥ 怎么用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 List<PrintWriter> list =new ArrayList<PrintWriter>();

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();
}
}
}
}

㈦ java中，用哪一个类来表示tcp协议的服务器socket对象

服务端监听：ServerSocket server=new ServerSocket(port);//port：绑定的端口号
Socket client=server.accept();//监听端口，一旦取得连接则获得客户端的socket连接对象client

客户端： Socket s=new Socket(ip,port);//要连接的服务器的ip以及端口号

如果正常连接上之后，socket的对象可以获得InputStream和OutputStreame，然后就可以进行通信了

完成通信之后，执行socket对象的close（）方法关闭连接，完成一次完整的socket连接

㈧ java的TCP和HTTP的区别和联系是什么

TCP是传输层协议，定义数据传输和连接方式的规范。握手过程中传送的包里不包含数据，三次握手完毕后，客户端与服务器才正式开始传送数据。

HTTP 超文本传送协议(Hypertext Transfer Protocol )是应用层协议，定义的是传输数据的内容的规范。

HTTP协议中的数据是利用TCP协议传输的，特点是客户端发送的每次请求都需要服务器回送响应，它是TCP协议族中的一种，默认使用 TCP 80端口。

好比网络是路，TCP是跑在路上的车，HTTP是车上的人。每个网站内容不一样，就像车上的每个人有不同的故事一样。

㈨ 想用JAVA做一个服务器，请问怎么利用TCP和线程，实现多个客户端同时在线，能与服务器进行交互

服务器监听端口 做个无限循环 接到一个连接就创建一个通道线程，并将通道线程存储到一个list集合中

importjava.io.BufferedReader;
importjava.io.IOException;
importjava.io.InputStreamReader;
importjava.io.PrintWriter;
importjava.net.ServerSocket;
importjava.net.Socket;
importjava.text.SimpleDateFormat;
importjava.util.ArrayList;
importjava.util.Date;
importjava.util.List;

/*
*4.用socket通讯写出多个客户端和一个服务器端的通讯，
*要求客户发送数据后能够回显相同的数据（回显功能）（实用TCP方式）。
*/
publicclassTest4Server{

	
	
	//主入口
	publicstaticvoidmain(String[]args)throwsIOException{
		scoketServer();
	}

	//开启的tcp8888监听端口
	publicstaticvoidscoketServer()throwsIOException{
		ServerSocketserver=newServerSocket(8888);
		while(true){
			//未连通前线程阻塞，连通后开启一个socket通道线程后继续监听8888端口
			Socketsocket=server.accept();
			System.out.println(socket.getInetAddress().getHostAddress()
					+"连接进入");
			newSocketThread(socket).start();
		}
	}
	
	

}

//一个服务器端口中监听多个客服端通道线程
{
//所有通道写入流的集合
	privatestaticList<PrintWriter>list=newArrayList<PrintWriter>();
	
	;
	privatePrintWriterprintWriter;

	publicSocketThread(Socketsocket)throwsIOException{
		this.bufferedReader=newBufferedReader(newInputStreamReader(socket
				.getInputStream()));
		this.printWriter=newPrintWriter(socket.getOutputStream());
		list.add(printWriter);
	}

	@Override
	publicvoidrun(){
		Stringstring=null;
		while(true){
			try{
				//服务器在通道中读到的信息回显给客服端
				string=bufferedReader.readLine();
				System.out.println("客服端信息："+string);
				for(PrintWriterprintWriter:list){
					printWriter.write("服务器回显："+string+"
");
					printWriter.flush();
				}
			}catch(IOExceptione){

			}
		}

	}
}

客服端代码 可以用在局域网中用多台来连接测试

importjava.io.BufferedReader;
importjava.io.IOException;
importjava.io.InputStreamReader;
importjava.io.PrintWriter;
importjava.net.Socket;
importjava.util.Scanner;

publicclassTest4Client{
	publicstaticObjectobj=newObject();

	//客服端的主入口
	publicstaticvoidmain(String[]args)throwsIOException{
		socketClient();
	}

	//与服务器连通地址本机（127.0.0.1），局域网中其他机器是（服务器在局域网中的ip地址）端口都是8888
	publicstaticvoidsocketClient()throwsIOException{
		Socketsocket=newSocket("127.0.0.1",8888);
		if(socket.isConnected()){
			//如果连接成功了就开启写和读的进程
			newwriter(socket).start();
			newread(socket).start();
		}else{
			System.out.println("服务器未开启");
		}
	}
}

//写入到通道的线程
classwriterextendsThread{
	@SuppressWarnings("unused")
	privateSocketsocket;
	privatePrintWriterprintWriter;
	privateScannerscanner=newScanner(System.in);
	privateStringstr=null;

	publicwriter(Socketsocket)throwsIOException{
		this.socket=socket;
		this.printWriter=newPrintWriter(socket.getOutputStream());

	}

	@Override
	publicvoidrun(){
		scanner.useDelimiter("
");

		while(true){
				System.out.print("请输入信息：");
				//产生扫描器的线程阻塞
				str=scanner.next();
				System.out.println("我说："+str);
				printWriter.write(str+"
");
				printWriter.flush();
			try{
				Thread.sleep(200);
			}catch(InterruptedExceptione){
				e.printStackTrace();
			}
		}
	}
}

//从通道中读取的线程
classreadextendsThread{
	privateSocketsocket;
	;
	privateStringstr=null;

	publicread(Socketsocket)throwsIOException{
		this.socket=socket;
		this.bufferedReader=newBufferedReader(newInputStreamReader(socket
				.getInputStream()));
	}

	@Override
	publicvoidrun(){
		while(true){

				try{
					str=bufferedReader.readLine();
					System.out.println(str);
				}catch(IOExceptione){
				}
			try{
				Thread.sleep(200);
			}catch(InterruptedExceptione){
			
				e.printStackTrace();
			}
		}
	}
}