Java⽹络编程（Socket基础，多线程socket，socket中⽂乱码问题）学习笔记
1.概念
2.简单TCP通信代码，⽤两个java程序模拟客户端和服务器端。
客户端代码：
TCP通信的客户端：向服务器发送连接请求，给服务器发送数据，读取服务器回写的数据
表⽰客户端的类:
java.Socket：此类实现客户端套接字（也可以就叫“套接字”）。套接字是两台机器间通信的端点。
套接字：包含了IP地址和端⼝号的⽹络单位
nextint()方法
构造⽅法:
Socket(String host, int port) 创建⼀个流套接字并将其连接到指定主机上的指定端⼝号。
参数:
String host：服务器主机的名称/服务器的IP地址
int port：服务器的端⼝号
成员⽅法:
OutputStream getOutputStream() 返回此套接字的输出流。
InputStream getInputStream() 返回此套接字的输⼊流。
void close() 关闭此套接字。
实现步骤:
1.创建⼀个客户端对象Socket，构造⽅法绑定服务器的IP地址和端⼝号
2.使⽤Socket对象中的⽅法getOutputStream()获取⽹络字节输出流OutputStream对象
3.使⽤⽹络字节输出流OutputStream对象中的⽅法write，给服务器发送数据
4.使⽤Socket对象中的⽅法getInputStream()获取⽹络字节输⼊流InputStream对象
5.使⽤⽹络字节输⼊流InputStream对象中的⽅法read，读取服务器回写的数据
6.释放资源(Socket)
注意:
1.客户端和服务器端进⾏交互，必须使⽤Socket中提供的⽹络流，不能使⽤⾃⼰创建的流对象
2.当我们创建客户端对象Socket的时候，就会去请求服务器和服务器经过3次握⼿建⽴连接通路
这时如果服务器没有启动，那么就会抛出异常ConnectException: Connection refused: connect
如果服务器已经启动，那么就可以进⾏交互了
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.Socket;
import java.util.Scanner;
public class TCPClient {
public static void main(String[] args) throws IOException {
Scanner cin = new Scanner(System.in);
Socket socket = new Socket("127.0.0.1",8888);
InputStream is = InputStream();
while(true)
{
//给服务器端发数据
System.out.println("请输⼊你要向服务器发送的数据：");
String sendMessage = Line();
OutputStream os = OutputStream();
os.Bytes());
//接收服务器端发过来的数据
byte[] getMessage = new byte[1024];
int len = is.read(getMessage);
String message = new String(getMessage,0,len);
System.out.println("收到服务器端发来的数据为： "+message);
}
}
}
服务器端代码：
TCP通信的服务器端：接收客户端的请求，读取客户端发送的数据，给客户端回写数据
表⽰服务器的类:
java.ServerSocket：此类实现服务器套接字。
构造⽅法:
ServerSocket(int port) 创建绑定到特定端⼝的服务器套接字。
服务器端必须明确⼀件事情，必须的知道是哪个客户端请求的服务器
所以可以使⽤accept⽅法获取到请求的客户端对象Socket
成员⽅法:
Socket accept() 侦听并接受到此套接字的连接。此⽅法具有等待功能，等待某⼀个客户端连接
服务器的实现步骤:
1.创建服务器ServerSocket对象和系统要指定的端⼝号
2.使⽤ServerSocket对象中的⽅法accept，获取到请求的客户端对象Socket
3.使⽤Socket对象中的⽅法getInputStream()获取⽹络字节输⼊流InputStream对象
4.使⽤⽹络字节输⼊流InputStream对象中的⽅法read，读取客户端发送的数据
5.使⽤Socket对象中的⽅法getOutputStream()获取⽹络字节输出流OutputStream对象
6.使⽤⽹络字节输出流OutputStream对象中的⽅法write，给客户端回写数据
7.释放资源(Socket,ServerSocket)
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.ServerSocket;
import java.Socket;
public class TCPServer {
public static void main(String[] args) throws IOException {
ServerSocket serverSocket = new ServerSocket(8888);
Socket socket = serverSocket.accept();
InputStream is = InputStream();
OutputStream os = OutputStream();
byte [] bytes = new byte[1024];
int len = 0 , count = 0;
while( (len = is.read(bytes)) != -1)
{
count++;
String getMessage = new String(bytes, 0, len);
System.out.println("服务器端收到的数据为： " + getMessage);
String sendMessage = "收到客户端" + count + "条消息，谢谢！";
os.Bytes());
}
socket.close();
serverSocket.close();
}
}
3.⽂件上传案例
客户端代码：
⽂件上传案例的客户端：读取本地⽂件，上传到服务器，读取服务器回写的数据
明确:
数据源:c:\\1.jpg
⽬的地：服务器
实现步骤:
1.创建⼀个本地字节输⼊流FileInputStream对象，构造⽅法中绑定要读取的数据源
2.创建⼀个客户端Socket对象，构造⽅法中绑定服务器的IP地址和端⼝号
3.使⽤Socket中的⽅法getOutputStream，获取⽹络字节输出流OutputStream对象
4.使⽤本地字节输⼊流FileInputStream对象中的⽅法read，读取本地⽂件
5.使⽤⽹络字节输出流OutputStream对象中的⽅法write，把读取到的⽂件上传到服务器
6.使⽤Socket中的⽅法getInputStream，获取⽹络字节输⼊流InputStream对象
7.使⽤⽹络字节输⼊流InputStream对象中的⽅法read读取服务回写的数据
8.释放资源(FileInputStream,Socket)
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.Socket;
public class TCPClient {
public static void main(String[] args) throws IOException {
//1.创建⼀个本地字节输⼊流FileInputStream对象，构造⽅法中绑定要读取的数据源
FileInputStream fis = new FileInputStream("c:\\1.jpg");
/
/2.创建⼀个客户端Socket对象，构造⽅法中绑定服务器的IP地址和端⼝号
Socket socket = new Socket("127.0.0.1",8888);
//3.使⽤Socket中的⽅法getOutputStream，获取⽹络字节输出流OutputStream对象
OutputStream os = OutputStream();
//4.使⽤本地字节输⼊流FileInputStream对象中的⽅法read，读取本地⽂件
int len = 0;
byte[] bytes = new byte[1024];
while((len = ad(bytes))!=-1){
//5.使⽤⽹络字节输出流OutputStream对象中的⽅法write，把读取到的⽂件上传到服务器
os.write(bytes,0,len);
}
/
*
解决：上传完⽂件，给服务器写⼀个结束标记
void shutdownOutput() 禁⽤此套接字的输出流。
对于 TCP 套接字，任何以前写⼊的数据都将被发送，并且后跟 TCP 的正常连接终⽌序列。        */
socket.shutdownOutput();
//6.使⽤Socket中的⽅法getInputStream，获取⽹络字节输⼊流InputStream对象
InputStream is = InputStream();
//7.使⽤⽹络字节输⼊流InputStream对象中的⽅法read读取服务回写的数据
while((len = is.read(bytes))!=-1){
System.out.println(new String(bytes,0,len));
}
/
/8.释放资源(FileInputStream,Socket)
fis.close();
socket.close();
}
}
服务器端代码：
⽂件上传案例服务器端：读取客户端上传的⽂件，保存到服务器的硬盘，给客户端回写"上传成功"
明确:
数据源：客户端上传的⽂件
⽬的地：服务器的硬盘 d:\\upload\\1.jpg
实现步骤:
1.创建⼀个服务器ServerSocket对象，和系统要指定的端⼝号
2.使⽤ServerSocket对象中的⽅法accept，获取到请求的客户端Socket对象
3.使⽤Socket对象中的⽅法getInputStream，获取到⽹络字节输⼊流InputStream对象
4.判断d:\\upload⽂件夹是否存在，不存在则创建
5.创建⼀个本地字节输出流FileOutputStream对象，构造⽅法中绑定要输出的⽬的地
6.使⽤⽹络字节输⼊流InputStream对象中的⽅法read，读取客户端上传的⽂件
7.使⽤本地字节输出流FileOutputStream对象中的⽅法write，把读取到的⽂件保存到服务器的硬盘上
8.使⽤Socket对象中的⽅法getOutputStream，获取到⽹络字节输出流OutputStream对象
9.使⽤⽹络字节输出流OutputStream对象中的⽅法write，给客户端回写"上传成功"
10.释放资源(FileOutputStream,Socket,ServerSocket)
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.ServerSocket;
import java.Socket;
import java.util.Random;
public class TCPServer {
public static void main(String[] args) throws IOException {
//1.创建⼀个服务器ServerSocket对象，和系统要指定的端⼝号
ServerSocket server = new ServerSocket(8888);
//2.使⽤ServerSocket对象中的⽅法accept，获取到请求的客户端Socket对象
/
*
让服务器⼀直处于监听状态(死循环accept⽅法)
有⼀个客户端上传⽂件，就保存⼀个⽂件
*/
while(true){
Socket socket = server.accept();
/*
使⽤多线程技术，提⾼程序的效率
有⼀个客户端上传⽂件，就开启⼀个线程，完成⽂件的上传
*/
new Thread(new Runnable() {
/
/完成⽂件的上传
@Override
public void run() {
try {
//3.使⽤Socket对象中的⽅法getInputStream，获取到⽹络字节输⼊流InputStream对象
InputStream is = InputStream();
//4.判断d:\\upload⽂件夹是否存在，不存在则创建
File file =  new File("d:\\upload");
if(!ists()){
file.mkdirs();
}
/
*
⾃定义⼀个⽂件的命名规则：防⽌同名的⽂件被覆盖
规则：域名+毫秒值+随机数
*/
String fileName = "itcast"+System.currentTimeMillis()+new Random().nextInt(999999)+".jpg";
//5.创建⼀个本地字节输出流FileOutputStream对象，构造⽅法中绑定要输出的⽬的地
//FileOutputStream fos = new FileOutputStream(file+"\\1.jpg");
FileOutputStream fos = new FileOutputStream(file+"\\"+fileName);
//6.使⽤⽹络字节输⼊流InputStream对象中的⽅法read，读取客户端上传的⽂件
int len =0;
byte[] bytes = new byte[1024];
while((len = is.read(bytes))!=-1){
//7.使⽤本地字节输出流FileOutputStream对象中的⽅法write，把读取到的⽂件保存到服务器的硬盘上
fos.write(bytes,0,len);
}
//8.使⽤Socket对象中的⽅法getOutputStream，获取到⽹络字节输出流OutputStream对象
//9.使⽤⽹络字节输出流OutputStream对象中的⽅法write，给客户端回写"上传成功"
//10.释放资源(FileOutputStream,Socket,ServerSocket)
fos.close();
socket.close();
}catch (IOException e){
System.out.println(e);
}
}
}).start();
}
//服务器就不⽤关闭
//server.close();
}
}
4.多线程TCPSocket通信案例，⽤两个java程序模拟客户端和服务器端
Java编程Socket实现多个客户端连接同⼀个服务端代码：
使⽤多线程的原因：我们的服务端处理客户端的连接请求是同步进⾏的，每次接收到来⾃客户端的连接请求后，都要先跟当前的客户端通信完之后才能再处理下⼀个连接请求。这在并发⽐较多的情况下会严重影响程序的性能，为此，我们可以把它改为如下这种异步处理与客户端通信的⽅式。
服务器端代码：
注意点
服务端从Socket的InputStream中读取数据的操作也是阻塞式的，如果从输⼊流中没有读取到数据程序会⼀直在那⾥不动，直到客户端往Socket的输出流中写⼊了数据，或关闭了Socket的输出流。当然，对于客户端的Socket也是同样如此。
输⼊流中读取客户端发送过来的数据，接下来我们再往输出流⾥⾯写⼊数据给客户端，接下来关闭对应的资源⽂件。⽽实际上上述代码可能并不会按照我们预先设想的⽅式运⾏，因为从输⼊流中读取数据是⼀个阻塞式操作，在上述的while循环中当读到数据的时候就会执⾏循环体，否则就会阻塞，这样后⾯的写操作就永远都执⾏不了了，针对这种情况，通常我们都会约定⼀个结束标记，当客户端发送过来的数据包含某个结束标记时就说明当前的数据已经发送完毕了，这个时候我们就可以进⾏循环的跳出了。
在上述代码中，当服务端读取到客户端发送的结束标记，即“end”时就会结束数据的接收，终⽌循环，这样后续的代码⼜可以继续进⾏了。
package SocketThread;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.ServerSocket;
import java.Socket;
public class ServerSocketThread {
public static void main(String[] args) throws IOException {
ServerSocket serverSocket = new ServerSocket(9999);
while(true)
{
Socket socket = serverSocket.accept();        //socket.accept()⽅法具是阻塞的，会⼀直等待⼀个客户端的连接，⼀个accetp()⽅法对应⼀个客户端，所以要实现多个客户端同时给同⼀个服务端发送数据，就要使⽤多线程。            new Thread(new MyRunnable(socket)).start();  //开启⼀个新线程，将socket作为参数传过去
}
}
static class MyRunnable implements Runnable  //这是⼀个线程
{
private Socket socket;
public MyRunnable(Socket socket)    //接受socket参数
{
this.socket = socket;
}
@Override
public void run() {
try {
ReceiveData(socket);  //将socket参数传到处理数据的函数中
} catch (IOException e) {
e.printStackTrace();
}
}
}
public static void ReceiveData(Socket socket) throws IOException {
InputStream is = InputStream();
OutputStream os = OutputStream();
byte [] bytes = new byte[1024];
int len = 0;
while( (len = is.read(bytes)) != -1 )
{
String getMessage = new String(bytes,0,len,"utf-8");  //⽤String⽅法时，这样写可以有效解决传输过程中的中⽂乱码情况。但是需要服务端和客户端都采⽤相同的编码形式。
System.out.println("客户端的线程  "+Thread.currentThread().getName()+"  正在向服务器发送数据， "+"服务器收到得信息为: "+getMessage);
if("end".equals(getMessage))
{
System.out.println("服务器端收到的数据包含end，关闭服务器！");
break;
}
String sendMessage = Thread.currentThread().getName()+ "发送的数据已收到，谢谢！";
os.Bytes());
}
socket.close();
is.close();
os.close();
}
}
客户端代码：
过程：先是给服务端发送了⼀段数据，之后读取服务端返回来的数据，跟之前的服务端⼀样在读的过程中有可能导致程序⼀直挂在那⾥，永远跳不出while循环，解决⽅法和服务端⼀样，⽤⼀个结束标志。
对于客户端往Socket的输出流⾥⾯写数据传递给服务端要注意⼀点，如果写操作之后程序不是对应着输出流的关闭，⽽是进⾏其他阻塞式的操作（⽐如从输⼊流⾥⾯读数据），记住要flush⼀下，只有这样服务端才能收到客户端发送的数据，否则可能会引起两边⽆限的互相等待。
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.Socket;
public class ClientSocketThread {
public static void main(String[] args) {
for (int i=0;i<20;i++) //创造5个客户端线程
{
new Thread(new Runnable() {
@Override
public void run() {
try {
Socket socket = new Socket("127.0.0.1",9999);
HandleData(socket);        //将socket作为参数调⽤处理数据的HandData函数
} catch (IOException e) {
e.printStackTrace();
}
}
}).start();
}
}
public static  void HandleData(Socket socket) throws IOException {
OutputStream os = OutputStream();
InputStream is = InputStream();
String sendMessage = Thread.currentThread().getName()+"你好，世界！";    //向服务端写数据
os.Bytes());
byte [] bytes = new byte[1024];
int len = 0;
while( (len = is.read(bytes)) != -1 )
{
String message = new String(bytes,0,len);
System.out.println(Thread.currentThread().getName()+"收到服务器端的数据为： "+message);  //接收来⾃服务端的数据                if("end".equals(message))
{
System.out.println("服务器端收到的数据包含end，关闭服务器！");
break;
}
}
}
}

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。