网络编程&net.

最新推荐文章于 2024-08-09 10:01:17 发布
最新推荐文章于 2024-08-09 10:01:17 发布
阅读量557 收藏
点赞数
分类专栏： Java基础学习 Java高级应用 文章标签： Java Java网络编程 TCP&UDP
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CS_GaoMing/article/details/84108637
版权

InetAddress

此类表示Internet协议（IP）地址。 IP地址是由IP使用的32位或128位无符号数字，构建UDP和TCP协议的低级协议。 IP地址结构由定义RFC 790: Assigned Numbers ， RFC 1918: Address Allocation for Private Internets ， RFC 2365: Administratively Scoped IP Multicast和RFC 2373: IP Version 6 Addressing Architecture 。 InetAddress的一个实例由一个IP地址和可能的相应主机名组成（取决于它是用主机名构造还是已经完成了反向主机名解析）。

  • 该类的使用主要是借助API查看对应的常用函数

    • 主机ip常用InetAddress.
    • Code eg：
      package NormalFunction;

import java.net.InetAddress;
import java.net.UnknownHostException;

public class TestFuntion {

	/**
	 * @param args
	 * @throws UnknownHostException
	 */
	public static void main(String[] args) throws UnknownHostException {
		/* 静态方法对象-getAllByName&getByName. */
		
		InetAddress address = InetAddress.getByName("192.168.0.168");
		/*获取主机名字*/
		
		String hostName = address.getHostName();
		
		/*获取主机ip*/
		String ip = address.getHostAddress();
		
		System.out.println(hostName + "----" + ip);

	}
}

  • UDP数据报的获取&接收

    此类表示用于发送和接收数据报数据包的套接字。

    数据报套接字是分组传送服务的发送或接收点。 在数据报套接字上发送或接收的每个数据包都被单独寻址和路由。 从一个机器发送到另一个机器的多个分组可以不同地路由，并且可以以任何顺序到达。

    • Send&Receive Code eg：

      /*for example*/
/*发送端与接收端对不能写在一个Java类文件里面DatagramSocket.receive是阻塞式.*/

/*接收端*/
package NormalFunction;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

public class TestReceived {

	/**
	 * @param args
	 * @throws IOException
	 */
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		/* 创建接收端套接字. */
		DatagramSocket rdgs = new DatagramSocket(15000);
		byte[] rbuffer = new byte[1024];
		int rlength = rbuffer.length;
		DatagramPacket rdgp = new DatagramPacket(rbuffer, rlength);
		rdgs.receive(rdgp);
		InetAddress raddress = rdgp.getAddress();
		String ipName = raddress.getHostName();/* 获取发送端主机名. */
		String ipX = raddress.getHostAddress(); /* 获取发送端IP地址. */

		/* 接收端解析并且显示在控制台. */
		byte[] Consolebuffer = rdgp.getData();
		int Consolelength = Consolebuffer.length;
		// String ConsoleString = new String(Consolebuffer);
		String ConsoleString = new String(Consolebuffer, 0, Consolelength);
		System.out.println("ReceivedFromName:" + ipName + "  ip:" + ipX
				+ "  Content:" + ConsoleString);
		rdgs.close();		
	}		
}


/*发送端*/
package NormalFunction;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

public class TestSend {

	public static void main(String[] args) throws IOException {

		/* 创建套接字对象-发送端 */
		DatagramSocket dgs = new DatagramSocket();
		byte[] sendbys = "thisTestSenderData!".getBytes();
		int sendlength = sendbys.length;
		InetAddress address = InetAddress.getByName("192.168.0.168");
		int port = 15000;
		DatagramPacket senddgs = new DatagramPacket(sendbys, sendlength,
				address, port);
		dgs.send(senddgs);
		dgs.close();
	}
}


/*combine_files*/
package NormalFunction;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

public class Sender_Receive {

	/**
	 * @param args
	 * @throws IOException
	 */
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		// TODO Auto-generated method stub
		/* 创建接收端套接字. */
		DatagramSocket rdgs = null;
		try {
			rdgs = new DatagramSocket(15000);
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		byte[] rbuffer = new byte[1024];
		int rlength = rbuffer.length;
		DatagramPacket rdgp = new DatagramPacket(rbuffer, rlength);
		try {
			rdgs.receive(rdgp);
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		InetAddress raddress = rdgp.getAddress();
		String ipName = raddress.getHostName();/* 获取发送端主机名. */
		String ipX = raddress.getHostAddress(); /* 获取发送端IP地址. */

		/* 接收端解析并且显示在控制台. */
		byte[] Consolebuffer = rdgp.getData();
		int Consolelength = Consolebuffer.length;
		// String ConsoleString = new String(Consolebuffer);
		String ConsoleString = new String(Consolebuffer, 0, Consolelength);
		System.out.println("ReceivedFromName:" + ipName + "  ip:" + ipX
				+ "  Content:" + ConsoleString);
		rdgs.close();
		System.out.println("this is a deviding line!");

		/* 创建套接字对象-发送端 */
		DatagramSocket dgs = new DatagramSocket();
		byte[] sendbys = "thisTestSenderData!".getBytes();
		int sendlength = sendbys.length;
		InetAddress address = InetAddress.getByName("192.168.0.168");
		int port = 15000;
		DatagramPacket senddgs = new DatagramPacket(sendbys, sendlength,
				address, port);
		dgs.send(senddgs);
		dgs.close();		
	}		
}

  • 数据发送=>聊天窗口

  • 将上述的单条数据发送改为由键盘输入的发送，并且接收，用多线程实现，不使用多线程为上代码问题。。

    • UDP:Code eg-runable实现：
      /*实现runble接口实现方式.*/
package NormalFunction;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;

class sender implements Runnable {
	private DatagramSocket sd_sender;

	public sender(DatagramSocket sd_sender) {
		this.sd_sender = sd_sender;
	}

	@Override
	public void run() {
		try {
			/* 键盘获取数据. */
			BufferedReader br = new BufferedReader(new InputStreamReader(
					System.in));
			String line = null;
			while ((line = br.readLine()) != null) {
				if ("over!".equals(line)) {
					break;
				}
				/* 数据打包并且发送. */
				byte[] bys = line.getBytes();
				DatagramPacket dp_sender = new DatagramPacket(bys, bys.length,
						InetAddress.getByName("192.168.0.255"), 15360);
				sd_sender.send(dp_sender);
			}
			sd_sender.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

class receiver implements Runnable {
	private DatagramSocket ds_receiver;

	public receiver(DatagramSocket ds_receiver) {
		this.ds_receiver = ds_receiver;
	}

	@Override
	public void run() {
		try {
			while (true) {
				byte[] bys = new byte[1024];
				DatagramPacket dp_receiver = new DatagramPacket(bys, bys.length);
				ds_receiver.receive(dp_receiver);

				/* parseData */
				String ip = dp_receiver.getAddress().getHostAddress();
				String s = new String(dp_receiver.getData(), 0,
						dp_receiver.getLength());
				System.out.println("from " + ip + " data is : " + s);
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

public class MultiThreadSend_Receive {
	public static void main(String[] args) throws SocketException {
		DatagramSocket ds_client = new DatagramSocket();
		DatagramSocket ds_receiver = new DatagramSocket(15360);

		sender sender_client = new sender(ds_client);
		receiver receiver_client = new receiver(ds_receiver);

		Thread thread_client = new Thread(sender_client);
		Thread thread_receive = new Thread(receiver_client);
		thread_client.start();
		thread_receive.start();
	}

}
    • UDP:Code eg-extends实现：
      package NormalFunction;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;

import com.sun.webkit.ThemeClient;

class sender extends Thread {
	private DatagramSocket sd_sender;

	public sender(DatagramSocket sd_sender) {
		this.sd_sender = sd_sender;
	}

	@Override
	public void run() {
		try {
			/* 键盘获取数据. */
			BufferedReader br = new BufferedReader(new InputStreamReader(
					System.in));
			String line = null;
			while ((line = br.readLine()) != null) {
				if ("over!".equals(line)) {
					break;
				}
				/* 数据打包并且发送至广播域. */
				byte[] bys = line.getBytes();
				DatagramPacket dp_sender = new DatagramPacket(bys, bys.length,
						InetAddress.getByName("192.168.0.255"), 15360);
				sd_sender.send(dp_sender);
			}
			sd_sender.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

class receiver extends Thread {
	private DatagramSocket ds_receiver;

	public receiver(DatagramSocket ds_receiver) {
		this.ds_receiver = ds_receiver;
	}

	@Override
	public void run() {
		try {
			while (true) {
				byte[] bys = new byte[1024];
				DatagramPacket dp_receiver = new DatagramPacket(bys, bys.length);
				ds_receiver.receive(dp_receiver);

				/* parseData */
				String ip = dp_receiver.getAddress().getHostAddress();
				String s = new String(dp_receiver.getData(), 0,
						dp_receiver.getLength());
				System.out.println("from " + ip + " data is : " + s);
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

public class MultiThreadSend_Receive {
	public static void main(String[] args) throws SocketException {
		DatagramSocket ds_client = new DatagramSocket();
		DatagramSocket ds_receiver = new DatagramSocket(15360);

		sender sender_client = new sender(ds_client);
		receiver receiver_client = new receiver(ds_receiver);

		sender_client.start();
		receiver_client.start();
	}

}

  • TCP实现的数据传送

    UDP数据包是非连接方式传播的，也就是说只保证自己的数据在网内广播，不是针对性的链接，同时也不保证数据被指定的机器接收到，TCP是连接式连接的，保证数据的传送，但是效率偏低，同样UDP也存在着一个问题就是容易产生垃圾广播数据，尤其是在非令牌环路广播域中，产生大量垃圾数据，造成网络速度迟缓。

    • TCP：Code实现单条数据的传输与发送.

      /*for example*/

/*数据发送端*/
package CompareTool;

import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;

public class TCP_Client {
	public static void main(String[] args) throws UnknownHostException,
			IOException {		
		Socket clientSocket = new Socket("192.168.119.9", 15360);
		OutputStream clientStream = clientSocket.getOutputStream();
		clientStream.write("thisSenderData!".getBytes());
		clientSocket.close();
	}
}

/*数据服务器端*/
package CompareTool;

import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class TCP_Server {
	public static void main(String[] args) throws IOException {
		ServerSocket serverSocket = new ServerSocket(15360);
		Socket nextSocket = serverSocket.accept();
		byte[] bysServer = new byte[1024];
		
		InputStream ServerStream = nextSocket.getInputStream();
		int serverLength = ServerStream.read(bysServer);
		String getString = new String(bysServer, 0, serverLength);
		System.out.println("ReceivedData:" + getString);
		serverSocket.close();
	}
}

/*服务器端实现方式二：*/
package CompareTool;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;

public class TCP_Server {
	public static void main(String[] args) throws IOException {
		ServerSocket serverSocket = new ServerSocket(15360);
		Socket nextSocket = serverSocket.accept();

		BufferedReader serverReader = new BufferedReader(new InputStreamReader(
				nextSocket.getInputStream()));
		String lineServer = null;
		while ((lineServer = serverReader.readLine()) != null) {
			System.out.println("ReceivedData:" + lineServer);
		}
		serverSocket.close();
	}
}

    • TCP：Code实现的由键盘输入实现和数据发送-控制台显示.

      /*客户端*/
package ImproveTCP;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.Socket;

public class ClientPort {
	public static void main(String[] args) throws IOException {
		/* 创建套接字对象 */
		Socket clientSocket = new Socket("192.168.119.9", 15360);
		
		/*输入输出流的定义.*/
		BufferedReader clientReader = new BufferedReader(new InputStreamReader(
				System.in));	 /*从键盘获取流，因此是reader.*/
		BufferedWriter clientWrite = new BufferedWriter(new OutputStreamWriter(
				clientSocket.getOutputStream()));	/*将套接字的数据流暴露出来，进行写入，发送。*/
		String clientString = null;
		
		/*每一行输出一次，遇到over!终止发送数据.*/
		while((clientString = clientReader.readLine())!= null){
			if ("over!".equals(clientString)) {
				break;
			}
			clientWrite.write(clientString);
			clientWrite.newLine();
			clientWrite.flush();
		}		
		clientSocket.close();
	}			
}


/*服务器端*/
package ImproveTCP;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;

public class ServerPort {

	public static void main(String[] args) throws IOException {
		ServerSocket serverSocket = new ServerSocket(15360);

		/* 收到数据需要提示发送端，当前已收到数据 */
		Socket nextSocket = serverSocket.accept();
		String serverString = null;
		BufferedReader serverReader = new BufferedReader(new InputStreamReader(
				nextSocket.getInputStream()));
		while ((serverString = serverReader.readLine()) != null) {
			System.out.println("ServerPort: current receivedData:" + serverString);
		}
		serverSocket.close();
	}
}

    • TCP：Code实现的由键盘输入实现和数据发送-数据写入到文本文档.

      /*client code*/
package TCP_TXT;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.Socket;

public class ClientFiles {

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		Socket clientSocket = new Socket("192.168.119.9", 15360);
		BufferedReader clientReader = new BufferedReader(new InputStreamReader(
				System.in));
		BufferedWriter clientWriter = new BufferedWriter(
				new OutputStreamWriter(clientSocket.getOutputStream()));
		String clientString = null;
		while ((clientString = clientReader.readLine()) != null) {
			clientWriter.write(clientString);
			clientWriter.newLine();
			clientWriter.flush();
		}
		clientSocket.close();
	}

}



/*server code*/
package TCP_TXT;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;

public class ServerFiles {
	public static void main(String[] args) throws IOException {
		File files = new File("test.txt");
		BufferedWriter fileWriter = new BufferedWriter(new FileWriter(files));
		ServerSocket serverSocket = new ServerSocket(15360);
		Socket nextSocket = serverSocket.accept();
		BufferedReader serverReader = new BufferedReader(new InputStreamReader(
				nextSocket.getInputStream()));

		String serverString = null;
		while ((serverString = serverReader.readLine()) != null) {
			if (serverString.equals("over!")) {
				fileWriter.close();
				break;
			}
			fileWriter.write(serverString);
			fileWriter.newLine();
			fileWriter.flush();
		}
		serverSocket.close();

	}
}

  • TCP：Code，服务器端接受由客户端文本文件发送的数据-

    • 显示在控制台&写入到文本文件两种方式，尤其提示，服务器端一定要注意关闭流/flush二者必选其一，不然无法显示，但是逻辑没有警告也不报错，但是就是达不到显示or复制文件的效果。

    • Code如下：

      /*for example----客户端*/
package TCP_TXT_TO_SERVER;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.net.Socket;

public class ClientPort {
	public static void main(String[] args) throws IOException {
		/*socket对象*/
		Socket clientSocket = new Socket("192.168.119.9", 15360);
		
		/*文本文件流*/
		BufferedReader clientfiles = new BufferedReader(new FileReader(
				"F:\\Java\\TestCc\\SourceTxt.txt"));
		
		/*通道数据流 */
		BufferedWriter clientWriter = new BufferedWriter(
				new OutputStreamWriter(clientSocket.getOutputStream()));
		/*行内容的读取并且写入发送*/
		String clientString = null;
		while ((clientString = clientfiles.readLine()) != null) {
			clientWriter.write(clientString);
			clientWriter.newLine();
			clientWriter.flush();
		}
		/*通道流，文件流，套接字的关闭.*/
		clientfiles.close();
		clientWriter.close();
		clientSocket.close();
	}
}


/*for example----服务器端*/
package TCP_TXT_TO_SERVER;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;

public class ServerPort {
	public static void main(String[] args) throws IOException {
		/*服务套接字对象*/
		ServerSocket serverSocket = new ServerSocket(15360);
		
		/*解析获取套接字，准备解析。*/
		Socket nextSocket = serverSocket.accept();
		
		/*将套接字的通道流暴露出来，准备读取通道流，属于流的读取，相对于内存是写入。*/
		BufferedReader serverReader = new BufferedReader(new InputStreamReader(
				nextSocket.getInputStream()));
		
		/*文本流的创建， 准备写入到文本写出内存。*/
		BufferedWriter filesWriter = new BufferedWriter(new FileWriter(
				"ServerText.txt"));
		
		String serverString = null;
		/* this Console expression. */		
		 while ((serverString = serverReader.readLine()) != null) {
		  System.out.println(serverString); } 
		 
		/* this store to text files. */
		/*while ((serverString = serverReader.readLine()) != null) {
			filesWriter.write(serverString);
			filesWriter.newLine();
			filesWriter.flush();
		}*/
		filesWriter.close();
		serverReader.close();
		nextSocket.close();
		serverSocket.close();
	}
}

    • 带提示的TCP文本传输，完成后提示客户端且关闭连接-实现上个人认为比较完美。

      /*for example-服务器端*/
package TCP_TXT_TO_SERVER;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.ServerSocket;
import java.net.Socket;

public class ServerPort {
	public static void main(String[] args) throws IOException {
		/* 服务套接字对象 */
		ServerSocket serverSocket = new ServerSocket(15360);

		/* 解析获取套接字，准备解析。 */
		Socket nextSocket = serverSocket.accept();

		/* 将套接字的通道流暴露出来，准备读取通道流，属于流的读取，相对于内存是写入。 */
		BufferedReader serverReader = new BufferedReader(new InputStreamReader(
				nextSocket.getInputStream()));

		/* 文本流的创建， 准备写入到文本写出内存。 */
		BufferedWriter filesWriter = new BufferedWriter(new FileWriter(
				"ServerText.txt"));

		String serverString = null;
		while ((serverString = serverReader.readLine()) != null) {
			filesWriter.write(serverString);
			filesWriter.newLine();
			filesWriter.flush();
		}
		/* 给客户端发送提示：传输完成！ */
		BufferedWriter tipServer = new BufferedWriter(new OutputStreamWriter(
				nextSocket.getOutputStream()));
		tipServer.write("传输完成！");
		tipServer.newLine();	/*此行可略。*/
		tipServer.flush();	/*无此行，客户端收到提示为null.*/
		/nextSocket.shutdownOutput();  /*可略，因为后面有关闭.*/

		/* 释放对应资源。 */
		filesWriter.close();
		serverReader.close();
		nextSocket.close();
		serverSocket.close();
	}
}


/*for example-客户端*/
package TCP_TXT_TO_SERVER;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.Socket;

public class ClientPort {
	public static void main(String[] args) throws IOException {
		/* socket对象 */
		Socket clientSocket = new Socket("192.168.119.9", 15360);

		/* 文本文件流 */
		BufferedReader clientfiles = new BufferedReader(new FileReader(
				"F:\\Java\\TestCc\\SourceTxt.txt"));

		/* 通道数据流 */
		BufferedWriter clientWriter = new BufferedWriter(
				new OutputStreamWriter(clientSocket.getOutputStream()));
		/* 行内容的读取并且写入发送 */
		String clientString = null;
		while ((clientString = clientfiles.readLine()) != null) {
			clientWriter.write(clientString);
			clientWriter.newLine();/*此两行不影响显示效果.*/
			clientWriter.flush();
		}
		/* 通道流，文件流，套接字的关闭. */
		clientSocket.shutdownOutput();

		/* 接收服务器端的提示：传输完成！ */
		BufferedReader tipFromServer = new BufferedReader(
				new InputStreamReader(clientSocket.getInputStream()));
		String temp = tipFromServer.readLine();
		System.out.println("提示：" + temp);

		clientfiles.close();
		clientSocket.close();
	}
}

    • TCP-服务器端同时接收多个客户端的上传.

      /*for example*/
	- 要实现线程的多线程访问，需要做到的是，将服务器端主实现部分分割，客户端保留。同时主函数调用服务器线程，一旦客户端运行就可以捕捉到数据包，然后将文件存档，利用CurrentMillionTime可以实现名称问题，但是仍然存在一个同时访问情况下的高并发问题。

/*客戶端*/
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.Socket;

public class UploadClient {
	public static void main(String[] args) throws IOException {
		
		Socket s = new Socket("192.168.119.9", 15360);	
		BufferedReader br = new BufferedReader(new FileReader(
				"TestAa.java"));
		
		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(
				s.getOutputStream()));

		String line = null;
		while ((line = br.readLine()) != null) {
			bw.write(line);
			bw.newLine();
			bw.flush();
		}	
		s.shutdownOutput();
	
		BufferedReader brClient = new BufferedReader(new InputStreamReader(
				s.getInputStream()));
		String client = brClient.readLine();
		System.out.println(client);
	
		br.close();
		s.close();
	}
}


/*服务器线程*/
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.Socket;

public class UserThread implements Runnable {
	private Socket s;

	public UserThread(Socket s) {
		this.s = s;
	}

	@Override
	public void run() {
		try {			
			BufferedReader br = new BufferedReader(new InputStreamReader(
					s.getInputStream()));			

			/*文件名問題*/
			String newName = System.currentTimeMillis() + ".java";
			BufferedWriter bw = new BufferedWriter(new FileWriter(newName));

			String line = null;
			while ((line = br.readLine()) != null) { // 阻塞
				bw.write(line);
				bw.newLine();
				bw.flush();
			}

			/*提示*/
			BufferedWriter bwServer = new BufferedWriter(
					new OutputStreamWriter(s.getOutputStream()));
			bwServer.write("Over!");		
			bwServer.flush();
			
			bw.close();
			s.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

}


/*服务器主函数*/
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

public class UploadServer {
	public static void main(String[] args) throws IOException {
		/*创建ServerSocket对象但是关闭ss.*/
		ServerSocket ss = new ServerSocket(11111);
		while (true) {
			Socket s = ss.accept();
			new Thread(new UserThread(s)).start();
		}
	}
}

    总结：数据的传输需要

    发送端-套接字，写入到内存-BufferedReader-Socket.getInputStreamReader匹配->写入到流，BufferedWriter->socket.getOutputStreamWriter…然后自动发送。

    服务器端则需要定义ServerSocket，accep函数获取Socket，然后将通道流暴露出来，然后利用BufferReader将流读取到内存，对应BufferedReader.readLine()，获取为String，然后可以直接显示在控制台，or创建BufferWriter->new BufferedWriter(new FileWriter(“path”))->利用BufferedWriter对象，调用writer()函数，注意要显示效果，需要传输关闭流/flush即可。

CS_GaoMing
关注
专栏目录
Net网络编程
qq_48494965的博客
03-27 1332
网络编程
大三上期末复习【IT项目管理&java网络编程&IT组网】.zip
01-14
大三上期末复习资料（GZHU）
.net 网络编程与技术实现
12-27
了解I/O技术，时应用程序开发人员最重要的基础课题，.net应用数据流的概念处理各种类型的数据读写操作，Stream累封装了I/O技术的通用基础功能，本书将从此类开始，逐步带领读者了解如何在.net平台下，应用其内建的网络与I/O功能，同时针对发展网络应用程序所需了解的相关技术，提供完整的说明。
.net网络编程之一:Socket编程
热门推荐
周公（周金桥）的专栏
03-18 2万+
 在.net下进行网络编程其实也相对比较简单，因为在.net类库已经提供了大量封装好的类。在.net下网络编程比较底层的类是System.Net.Sockets.Socket类，这个类提供了丰富的方法和属性，并且还提供了异步数据传输支持。对Socket类做一个简单的介绍，它有如下常见方法：public Socket Accept ()：为新建连接创建新的 Socket。    public voi
IP地址封装类（InetAddress类）
最新发布
weixin_74141222的博客
08-09 872
当我们想要获取到通信对方的IP地址、主机地址等信息时，我们可以使用InetAddress类。InetAddress类在java的net包中。一、IP地址是什么？IP地址 (Internet Protocol address) 是一组用于标识和定位计算机网络中设备的数字。IP地址的作用类似于门牌号，用于识别网络中的设备。它由32位或128位的数字组成，以点分四组或冒号分八组进行表示。在IPv4中，通常以 xxx.xxx.xxx.xxx 的形式表示，其中每个xxx可以是0-255之间的数字。
.NET网络编程学习(一)
weixin_34354173的博客
08-11 73
最近在学习.NET下的网络编程,关于它的方便和强大就不说了,以下是个人学习过程的一些体会,整理如下. .NET网络编程主要涉及到两个命名空间:System.Net和System.Net.Sockets 先来看看System.Net命名空间   (1)Dns类 public static class Dns Dns 类是一个静态类，它从 Internet 域名系统 (DNS) 检索关...
linux C++ 基于Reactor事件机制的网络编程框架源码.zip
03-05
linux C++ 基于Reactor事件机制的网络编程框架源码.zip。linux网络编程框架（C++）基于Reactor事件机制，支持线程池，异步非阻塞，高并发，高性能。linux C++ 基于Reactor事件机制的网络编程框架源码.zip。linux网络...
学习笔记(04):Python网络编程&并发编程-什么是socket
01-06
1.什么是网络编程？ 答：网络编程也叫做socket编程即套接字编程，基于遵循socket套接字的规定进行的编程 2.什么是socket？ 答：socket就是一组简单的接口！socket抽象层位于TCP运输层和应用层之间，socket抽象层将...
学习笔记(11):Python网络编程&并发编程-粘包底层原理分析
12-22
 1.send和recv底层分析 1）不管是recv还是send都不是直接接收对方数据或者发送给对方数据，而是对自己的操作系统内存进行操作； 2）客户端与服务端并不是一个send对于一个recv； 3）send过程分析（此处以客户端向...
Visual C++网络编程案例实战.pdf
09-24
《Visual C++网络编程案例实战》一书深入探讨了如何利用Visual C++及MFC类库进行网络编程，尤其强调了Windows Socket的应用。本书不仅覆盖了理论基础，还提供了丰富的实践案例，帮助读者掌握网络编程的核心技能。 #...
C#.net网络编程
07-26
C#.net网络编程，相当好的一本书，深入浅出，学习C#和网络编程的利器
Visual C#.NET网络编程.pdf
10-26
Visual C#.NET网络编程
Visual.C_#.NET网络编程
12-01
很好的学习Visual.C_#.NET 网络编程的电子书，个人使用起来感觉值得学习，因此推荐给大家~
C#.NET网络编程.part1
07-03
本书结合大量实例，全面介绍了基于visual c#.net的网络编程，内容包括web forms、asp.net、tcp、udp端口通信、远程访问、msmq消息队列、电子邮作客户端系统、网络编程应用技巧与web services等。<br>本书所有的源代码可以通过http://www.tupwk.com.cn下载到，用户无需输入任何内容，即可使用本书中展示的所有技巧。<br>本书结构清晰，内容全面，由浅及深、注重实用，适合于初级和中级网络程序员、网络软件开发人员、网络管理员及广大计算机编程爱好者阅读。<br>第1章 net平台<br>1.1 net平台简介<br>1.1.1 什么是.net<br>1.1.2 net的功能<br>1.1.3 net的核心组件<br>1.2 net平台特点<br>1.3 net平台架构<br>1.4 本章小结<br>第2章 c#web编程基础<br>2.1 internet发展简史<br>2.1.1 www与internet<br>2.1.2 web的工作原理<br>2.1.3 超文本传输协议<br>2.2 web编程起步<br>2.2.1 html页面<br>2.2.2 html表单<br>2.2.3 静态和动态web页面<br>2.2.4 web的演化过程<br>2.3 netweb编程<br>2.3.1 aspnet<br>2.3.2 webforms<br>2.4 本章小结<br>第3章 基于asp.net的网络编程<br>3.1 webforms<br>3.1.1 创建第一个web窗体<br>3.1.2 在web窗体上添加控件<br>3.1.3 将控件与数据绑定<br>3.1.4 webforms的事件响应<br>3.2 服务器端控件<br>3.3 自定义控件<br>3.3.1 创建项目<br>3.3.2 将控件添加到工具箱<br>3.3.3 个性化控件<br>3.3.4 创建自定义设计器<br>3.3.5 测试控件<br>3.4 html控件<br>3.5 aspnet应用程序<br>3.5.1 什么是应用程序<br>3.5.2 配置web.config<br>3.5.3 编写global.asax<br>3.5.4 应用和会话<br>3.5.5 安全访问控制<br>3.6 本章小结<br>第4章 基于tcp／udp协议的socket编程<br>4.1 hternet和socket简介<br>4.1.1 tcp协议简介<br>4.1.2 udp协议简介<br>4.1.3 端口简介<br>4.1.4 system.net名称空间<br>4.1.5 system.net.sockets名称空间<br>4.2 基于tcp协议的网络会话实例<br>4.2.1 服务器端编程<br>4.2.2 客户端编程<br>4.2.3 编译运行<br>4.3 基于tcp的p2p文件共享应用<br>4.3.1 qremotefilestream协议<br>4.3.2 qremotefilestreamserver类<br>4.3.3 qremotefilestreamproxy类<br>4.3.4 qfilesharingpeer类<br>4.3.5 p2p-gui程序的编写和编译运行<br>4.4 基于udp协议的网络会话实例<br>4.4.1 服务器端编程<br>4.4.2 客户端编程<br>4.4.3 编译运行<br>4.5 基于udp广播的自动收报机的实现<br>4.5.1 服务器和客户端的公共类<br>4.5.2 服务器端编程<br>4.5.3 客户端编程<br>4.5.4 编译运行<br>4.6 基于udp的客户一服务器聊天应用的实现<br>4.6.1 qtcpserversession类<br>4.6.2 qtcpserver类<br>4.6.3 聊天协议<br>4.6.4 qchatserver类<br>4.6.5 qchatclient类<br>4.6.6 编译和运行程序<br>4.7 网络资料的访问<br>4.7.1 代理的概念<br>4.7.2 访问网络资源的客户端程序<br>4.8 本章小结<br>第5章 远程访问<br>……<br>第6章 基于msmq的消息队列<br>第7章 电子邮件客户端系统<br>第8章 网络编程实用技巧示例<br>第9章 xmlwebservices编程<br>第10章 一个大整数计算的webserrices<br>
.NET网络高级编程
05-10
网络编程是.NET企业级应用程序开发的重要内容，也是开发人员当前所面临的难点之一。本书共分为11章，全面深入地介绍了.NET网络编程技术，内容分别涉及到物理网络的体系结构、网络协议和OSI模型、.NET中的套接字编程、TCP和UDP、HTTP和多播套接字、Internet编程和用于发送电子邮件的.NET类、.NET中的密码术以及身份验证协议等。 本书适合那些熟悉C#基础编程知识、并希望切实掌握.NET网络编程技术的各类开发人员；本书并不要求您先前了解网络，但具有网络编程的相关知识有利于学习本书。
网络编程 NET
超域的博客
04-19 168
网络协议：一套规则 网络模型： 七层模型———— 物理层 水晶头 什么线 几根 铜线还是什么？ 什么颜色 数据链路层 怎么传 多高电压 ，多高电流 信号怎怎么传 网络层 传输层 会话层 先打招呼 表示层 应用层 以上是理论模型，真正干活时是四层： 链路层 网络层 传输层 应用层 每一层都有相应的协议负责交换信息或协同工作 TCP/IP协议族 关于网络传输的一大块 IP地址...
net包之：网络编程
LYQ2332826438的博客
08-02 585
net包之：网络编程（Socket套接字、单vs单网络聊天） 一、如何构建一个服务器 1.方法 利用套接字Socket来实现网络之间的通信。 2.ServerSocket类 实现服务器套接字。服务器套接字等待请求通过网络传入。 Socket        accept();  //侦听并接受到此套接字的连接 void        close();   //关闭此套接字 3. So...
C＃网络编程初探
shinerpipul的专栏
01-05 1066
C＃网络编程初探作者： 马金虎   www.ASPCool.com 时间:2002-6-25 18:00:06  阅读次数:11074      我们知道C＃和C＋＋的差异之一，就是他本身没有类库，所使用的类库是.Net框架中的类库--.Net FrameWork SDK。在.Net FrameWork SDK中为网络编程提供了二个名称空间："Sys
UNIX网络编程的unp.h
07-27
UNIX网络编程（UNIX Network Programming）是一本经典的网络编程书籍，由W. Richard Stevens和Bill Fenner合著。这本书详细介绍了在UNIX系统上进行网络编程的各种技术和方法。 unp.h是该书中提供的一个头文件，它...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值