java网络编程学习之路(3)

最新推荐文章于 2022-07-17 08:54:07 发布
最新推荐文章于 2022-07-17 08:54:07 发布
阅读量1.2k 收藏 1
点赞数
分类专栏： java java网络编程学习之路 文章标签： java 网络编程 线程池
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tjpu_lin/article/details/24554493
版权

第三章、ServerSocket用法简解

由于文章总结的内容太长，看起来很不方便，所以现在开始总结可能会常用的知识点。

ServerSocket是服务器端负责接受客户连接请求的类。

3.1 构造ServerSocket

backlog参数是用来设定客户连接队列的长度，即允许几个客户端连接请求缓存个数。

在以下情况下会采用操作系统限定的队列长度：
1）、backlog参数的值大于操作系统限定的队列最大长度

2）、backlog参数的值小于或等于0

3）、在ServerSocket构造方法中没有设置backlog参数


如果我们设立了backlog参数值为3，当我们用客户端进行服务器端连接请求时，没有运行ServerSocket对象的accept()方法，这种情况下，如果连接请求到了3个以上时，程序就会抛异常，因为连接队列里面已经满了，而且我们没有用accept方法从请求队列中取出连接。所以我们一般把accept方法写到while循环里，这样不出问题的话，会一直接受客户端的连接请求。


3.2 接受和关闭与客户端的连接

就如上面所诉的，ServerSocket通过accept方法来从请求队列中取出一个客户的连接请求，然后创建于客户端连接的Socket对象，并且将它返回。如果队列里面没有请求连接的话，那么accept方法就会一直等下去。
当服务器端正在给一个客户端发送数据时，该客户端断开连接了，这是服务器端就会抛出SocketExcepion异常，这是我们不愿意看到的，因为服务器端还和其他客户端进行着连接，不能因为一个客户端的出错导致整个通信网络瘫痪。所以在单线程服务器中，我们一般对该异常进行捕获。

3.3 关闭ServerSocket

ServerSocket的close方法可以使服务器释放占用的端口，并且断开与所有客户端的连接。不过当一个服务器程序运行结束时，即使没有调用该方法，默认的还是会释放服务器占用的端口。
ServerSocket的isClose方法判断ServerSocket是否关闭，只有执行了ServerSocket的close方法，isClosed才会返回true；否则即使ServerSocket还没有和特定的端口号绑定，isClosed方法也会返回false、
另外ServerSocket还提供了isBound方法判断是否已经与一个端口绑定，只要绑定了，即使它已经关闭了，isBound方法也会返回true。

3.4 获取ServerSocket信息


我们在前面的2章中得知，如果在构造函数时给其分配的端口号是0，那么会由操作系统随机分配端口号，例如ServerSocket serverSocket = new ServerSocket(0)。这时候，我们要想得知其端口号就可以用getLocalPort方法了。

不过多数服务器都会监听固定端口，方便客户端进行方法。匿名端口一般用于服务器和客户进行临时通信，通信结束，就断开连接，释放占用的相关资源。FTP就使用了匿名端口。
FTP使用了两个并行的TCP连接，一个是控制连接，一个是数据连接。控制连接用于在客户和服务器之间发送控制信息，如用户名和口令。改变远程目录的命令或上传和下载文件的命令。数据连接用于传送文件。TCP服务器在21端口上监听控制连接，如果有客户要求上传或下载文件，就另外建立了一个数据连接，通过它来传送文件。数据连接有两种建立方式。如下图所示：
1）、 所有的连接均在特定的端口

2）、 客户端和服务器进行数据连接时先创建一个监听匿名端口的ServerSocket，然通过getLocalPort获取端口号发给TCP服务器，然后由TCP服务器主动建立与客户端的连接。当然服务器端也可以使用匿名端口。

3.5 ServerSocket选项

ServerSocket有以下三个选项

1）、SO_TIMEOUT：表示等待客户连接的超时时间
2）、SO_REUSEADDR：表示允许重用服务器所绑定的地址
3）、SO_RCVBUF：表示接受数据的缓冲区的大小

详细用法见Socket那章，其实是类似的。

3.6 创建多线程的服务器

在单线程的情况下，服务器往往不能同时和多个客户同学，服务器给一个客户发送信息时，队列中的其他客户就必须排队等服务器和那个客户的通信结束。
许多实际应用要求服务器具有同时为多个客户提供服务的能力。HTTP服务器就是最明显的例子。任何时刻，HTTP服务器都可能接受大量的客户请求，每个客户都希望快速得到HTTP服务器的响应，如果长时间让客户等待，那估计就没人访问了。
可以用并发性能来衡量一个服务器同时响应多个客户的能力。一个具有好的并发性能的服务器，必须符合两个条件：
1).能同时接受并处理多个客户连接；
2).对于每个客户，都会迅速给与响应。
为了实现以上的并发，我们可以使用多线程。
1).为每个客户分配一个工作线程.
2).创建一个线程池，由其中的工作线程来为客户服务。
3).利用JDK的java类库中现成的线程池，由它的工作线程来为客户服务。

3.6.1 为每个客户分配一个线程

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

public class EchoServer {
	private int port = 8000;
	private ServerSocket serverSocket;
	public EchoServer() throws IOException{
		serverSocket = new ServerSocket(port);
		System.out.println("服务器已启动");
	}
	
	public void service() throws IOException{
		while(true){
			Socket socket = null;
			socket = serverSocket.accept();
			Thread workThread = new Thread(new Handler(socket));
			workThread.start();
		}
	}
}

class Handler implements Runnable{
	private Socket socket;
	public Handler(Socket socket){
		this.socket = socket;
	}
	private PrintWriter getWriter(Socket socket) throws IOException{
		PrintWriter pw = new PrintWriter(socket.getOutputStream(),true);
		return pw;
	}
	private BufferedReader getReader(Socket socket) throws IOException{
		InputStreamReader in = new InputStreamReader(socket.getInputStream());
		BufferedReader br = new BufferedReader(in);
		return br;
	}
	public String echo(String msg){
		return "echo:"+msg;
	}
	@Override
	public void run() {
		System.out.println("new connection accepted"+socket.getLocalAddress()+";"+socket.getLocalPort());
		try {
			BufferedReader br = getReader(socket);
			PrintWriter pw = getWriter(socket);
			String msg = null;
			while((msg = br.readLine())!=null){
				System.out.println(msg);
				pw.println(echo(msg));
				if("bye".equals(msg)){
					break;
				}
			}
		} catch (IOException e) {
			e.printStackTrace();
		} finally{
			if(socket!=null)
				try {
					socket.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
		}
		
	}
	
}



把跟客户端进行数据接受发送的代码写到一个新的线程的run方法里去，当调用线程的start方法就执行了run方法里面的代码。

3.6.2 创建线程池

以上的多线程的代码多少效率上有些不高，反复的线程创建和销毁所造成的的资源开销太大。所以我们引入了线程池的概念，所谓线程池就是一个池子里事先装入了N个线程，当你要用时就拿一个，不用时就放回来，这样就不会返回的创建和销毁线程。 
import java.util.LinkedList;

public class ThreadPool extends ThreadGroup{
	private boolean isClosed = false;  //线程池是否关闭
	private LinkedList<Runnable> workQueue; //表示工作队列
	private static int threadPoolID;//表示线程的ID
	private int threadID; //表示工作线程的ID
	
	public ThreadPool(int poolSize){  //指定线程池中工作线程的数目
		super("ThreadPool-"+(threadPoolID++));
		setDaemon(true);  //守护线程
		workQueue = new LinkedList<Runnable>();
		for(int i = 0;i < poolSize;i++){
			new WorkThread().start();
		}
	}
	
	/**向工作队列中加入一个新任务，由工作线程去执行该任务*/
	public synchronized void execute(Runnable task){
		if(isClosed){      //如果线程池被关闭，则抛出异常
			throw new IllegalStateException();
		}
		if(task != null){
			workQueue.add(task);
			notify();    //唤醒正在getTask方法中等待人物的工作线程
		}
	}
	
	/**从工作队列中取出一个任务，工作线程会调用此方法
	 * @throws InterruptedException */
	protected synchronized Runnable getTask() throws InterruptedException{
		while(workQueue.size()==0){
			if(isClosed){
				return null;
			}
			wait();        //如果工作队列中没有任务，就等待任务
		}
		return workQueue.removeFirst();
	}
	
	/**关闭线程池*/
	public synchronized void close(){
		if(!isClosed){
			isClosed = true;
			workQueue.clear(); //清空工作队列
			interrupt();         //中断所有的工作线程，该方法继承自ThreadGroup
		}
	}
	
	/**等待工作线程把所有的任务执行完*/
	public void join(){
		synchronized (this) {
			isClosed = true;
			notifyAll();      //唤醒还在getTask方法中等待任务的工作线程
		}
		Thread[] threads = new Thread[activeCount()];
		//enumerate()方法继承自ThreadGroup类，获得线程中当前所有活着的工作线程
		int count = enumerate(threads);
		for(int i=0; i<count; i++){
			try {
				threads[i].join();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
	
	/** 内部类：工作线程*/
	private class WorkThread extends Thread{
		public WorkThread(){
			//加入当前的ThreadPool线程组中
			super(ThreadPool.this,"WorkThread-"+(threadID++));   //在线程组中创建线程
		}
		
		public void run(){
			while(!isInterrupted()){      //判断线程是否被中断
				Runnable task = null;
				try {
					task = getTask();
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				if(task == null) return;
				task.run();
			}
		}
	}
}

在ThreadPool类中定义了一个workQueue用来存放线程池要执行的任务，每个任务都是Runnable的实例。ThreadPool类的客户程只要调用ThreadPool中的execute方法就能向线程池提交任务。该方法将任务加到工作队列中，并且唤醒正在等待任务的工作线程。即有了工作任务就通知线程去执行这个任务。工作线程执行完该任务后，再从工作队列中取下一个任务并执行，如果没有就wait。
线程池的join和close都可以关闭线程池，不过join在关闭前会确保工作队列中的任务都执行完毕。join的这一功能具体实现是靠enumerate方法的。

先new一个Thread数组threads，activeCount()方法返回此线程组中活动线程的估计数。然后用enumerate方法来将线程组复制到刚new出来的数组里。

然后再调用线程的join方法来等待线程数组中每一个线程的终止。


下面用一个例子来调用以上线程池

public class ThreadPoolTester {
	public static void main(String[] args) {
		int numTasks = 5;
		int poolSize = 3;
		ThreadPool threadPool = new ThreadPool(poolSize); //创建线程池
		
		//运行任务
		for(int i=0; i<numTasks; i++){
			threadPool.execute(createTask(i));
		}
		threadPool.join();
	}

	private static Runnable createTask(final int i) {
		
		return new Runnable() {
			
			@Override
			public void run() {
				System.out.println("Task"+i+":start");
				try {
					Thread.sleep(500);
				} catch (InterruptedException e) {
					
				}
				System.out.println("Task"+i+":end");
			}
		};
	}
}

运行结果： 

Task1:start
Task2:start
Task0:start
Task2:end
Task3:start
Task1:end
Task4:start
Task0:end
Task3:end


一共5个任务，线程池中线程的个数为3，通过运行其实可以发现最多一次性连续执行的任务数是3，因为线程总数为3，一个线程在没有执行完一个任务时，是没法去执行下一个任务。

JDK自带的类库也提供了一个线程池供我们去使用，在java.util.concurrent包里面。具体用法后面有个例子。

3.6.3 使用线程池需要注意的事项

虽然线程池能大大提高服务器的并发性能，但是使用它会存在一定的风行。
1.死锁
任何多线程应用程序都存在死锁风险。所谓死锁，典型的例子就是线程A占用了资源1，它需要资源2才能继续执行下去,线程B占用了资源2，它需要资源1才能继续执行下去，两个线程都不释放自己占用的资源并且都在等着对方的资源，这样下去就产生了死锁。线程池会导致这种死锁以外的另一种死锁，假定线程池中的所有工作线程都在执行各自的任务时被阻塞，它们都在等待某一个任务A的执行结果，而任务A依然在工作队列中，由于没有空闲的线程去执行任务A，所以线程池中的工作线程都永远阻塞下去了。

2.系统资源不足
如果设计的线程池中线程的数目很多，而且使用效率不高，打个比方如果有100个线程，只需要执行10个任务，这样就严重浪费了资源了。

3.并发错误
如果没有线程池中的wait和notify方法使用不正确，导致notify没有唤醒一个wait线程，这样该工作线程就会一直空闲的wait下去。

4.线程泄漏
工作线程在执行一个任务时被阻塞，如等待用户的输入数据，但由于用户迟迟没有输入数据，导致这个线程一直处于阻塞状态，线程池所能使用的工作线程就会减少。如果很多这样的工作线程没执行完任务处于阻塞状态会导致线程池无法执行新的任务。

5.任务过载
当工作队列中有大量任务排着队，这些任务本身执行会消耗很多系统资源，如果我们在这些任务调度执行时没有一个很好的安排，例如，任务A执行过程中需要任务B的执行结果，我们先把A加了进去就不太合适了。还有任务的种类不同，有些是会经常阻塞的IO操作，有些是执行一直不会阻塞的运算操作。前者时断时续地占用CPU资源，后者对CPU资源利用率更高。所以我们要对任务进行合理的分类，根据任务的不同设置对个工作队列，对其进行不同的调度处理。

3.7 关闭服务器

服务器如何能在恰当的时刻关闭自己是我们所想要实现的。
以下代码是可以关闭自己的一个服务器例子 
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.net.SocketException;
import java.net.SocketTimeoutException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.RejectedExecutionException;
import java.util.concurrent.TimeUnit;

public class EchoServer2 {
	private int port = 8000;
	private ServerSocket serverSocket;
	private ExecutorService  executorService; //JDK自带的线程池
	private final int POOL_SIZE = 4; //单个CPU时线程池中工作线程的数目
	
	private int portForShutdown = 8001;     //用于监听关闭服务器命令的端口
	private ServerSocket serverSocketForShutdown;
	private boolean isShutdown = false;
	
	private Thread shutdownThread = new Thread(){
		public void start(){
			this.setDaemon(true);
			super.start();
		}
	public void run(){
		while(!isShutdown){
			Socket socketForShutdown = null;
			try {
				socketForShutdown = serverSocketForShutdown.accept();
				BufferedReader br = new BufferedReader(new InputStreamReader(socketForShutdown.getInputStream()));
				String command = br.readLine();
				if("shutdown".equals(command)){
					long beginTime = System.currentTimeMillis();
					socketForShutdown.getOutputStream().write("服务器正在关闭\r\n".getBytes());
					isShutdown = true;
					//请求关闭线程池
					//线程池不再接受新的任务，但是会继续执行完工作队列中现有的任务
					executorService.shutdown();
					//等待关闭线程池，每次等待的超时时间为30秒
					while(!executorService.isTerminated()){
						executorService.awaitTermination(30, TimeUnit.SECONDS);
					}
					serverSocket.close();//关闭与EchoClient客户同学的ServerSocket
					long endTime = System.currentTimeMillis();
					socketForShutdown.getOutputStream().write(("服务器已经关闭,"+"关闭服务器用了"+(endTime-beginTime)+"毫秒\r\n").getBytes());
					socketForShutdown.close();
				}else{
					socketForShutdown.getOutputStream().write("错误的命令\r\n".getBytes());
					socketForShutdown.close();
				}
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} 
		}
	}
};

public EchoServer2() throws IOException {
	serverSocket = new ServerSocket(port);
	serverSocket.setSoTimeout(60000); //设定等待用户连接的超时时间为60秒
	serverSocketForShutdown = new ServerSocket(portForShutdown);
	
	//创建线程池
	executorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors()*POOL_SIZE);
	shutdownThread.start(); //启动负责关闭服务器的线程
	System.out.println("服务器启动");
}

public void service(){
	while(!isShutdown){
		Socket socket = null;
		try {
			socket = serverSocket.accept();
			socket.setSoTimeout(60000);//把等待客户发送数据的超时时间设置为60秒
			executorService.execute(new Handler1(socket));
		} catch (SocketTimeoutException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}catch (RejectedExecutionException e) {
			if(socket!=null){
				try {
					socket.close();
				} catch (IOException e1) {
					// TODO Auto-generated catch block
					e1.printStackTrace();
				}
			}
			e.printStackTrace();
		} catch (SocketException e) {
			//如果由于在执行serverSocket的accept方法时
			//ServerSocket被ShutdownThread线程关闭而导致的异常，就退出service方法
			if(e.getMessage().indexOf("socket closed")!=-1)return;
		} catch(IOException e){
			e.printStackTrace();
		}
		}
	}

	public static void main(String[] args) throws IOException {
		new EchoServer2().service();
	}
}


class Handler1 implements Runnable{
	private Socket socket;
	public Handler1(Socket socket){
		this.socket = socket;
	}
	private PrintWriter getWriter(Socket socket) throws IOException{
		PrintWriter pw = new PrintWriter(socket.getOutputStream(),true);
		return pw;
	}
	private BufferedReader getReader(Socket socket) throws IOException{
		InputStreamReader in = new InputStreamReader(socket.getInputStream());
		BufferedReader br = new BufferedReader(in);
		return br;
	}
	public String echo(String msg){
		return "echo:"+msg;
	}
	@Override
	public void run() {
		System.out.println("new connection accepted"+socket.getLocalAddress()+";"+socket.getLocalPort());
		try {
			BufferedReader br = getReader(socket);
			PrintWriter pw = getWriter(socket);
			String msg = null;
			while((msg = br.readLine())!=null){
				System.out.println(msg);
				pw.println(echo(msg));
				if("bye".equals(msg)){
					break;
				}
			}
		} catch (IOException e) {
			e.printStackTrace();
		} finally{
			if(socket!=null)
				try {
					socket.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
		}
		
	}
	
}



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

public class AdminClient {
	public static void main(String[] args) {
		Socket socket = null;
		
		try {
			socket = new Socket("localhost",8001);
			//发送关闭命令
			OutputStream socketOut = socket.getOutputStream();
			socketOut.write("shutdown\r\n".getBytes());
			
			//获取服务器反馈
			BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
			
			String msg = null;
			while((msg=br.readLine())!=null){
				System.out.println(msg);
			}
		} catch (UnknownHostException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally{
			if(socket!=null)
				try {
					socket.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
		}
	}
}

主要的思路是在服务器程序中另外建立一个ServerSocket监听那种类似于管理员权限的客户端发送的消息，如果发送的命令为shutdown，则关闭服务器端。

小白晒太阳
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
网络编程-狂神说Java学习笔记
07-20
网络编程—狂神说Java学习笔记
Java网络编程学习汇总
大鱼的博客
03-02 1万+
Java网络编程（一）概念 未完待续！！！！！ 写作不易，如果您觉得写的不错，欢迎给博主点赞、收藏、评论、收藏来一波~让博主更有动力吧！ 路漫漫其修远兮，吾必将上下求索~
史上最强 Java 学习路线图！
热门推荐
沉默王二
04-24 24万+
网上看到一首诗：“代码尽头谁为峰，一见秃头道成空。编程修真路破折，一步一劫渡飞升。”感觉还挺有意境的。 第一部分：Java 基础篇 这个阶段就是编程入门，掌握 Java 这门编程语言的基本语法，为后面的修行之路打好基础。 包括的知识点有： 环境搭建——Intellij IDEA 一站式搞定 Java 基础语法 面向对象——封装、继承、多态 数组 字符串 集合框架 IO 反射 注解 网络编程 并发编程 这方面的资源我给大家梳理下： 1）针对 Intellij IDEA，GitHub 上有一份简体中文版教
Java 网络编程之Socket详解
sunnyday0426的博客
02-21 5267
Java Socket概念TCPJava SocketSocket APITCP编程服务器端客户端多线程实现服务器与多客户端之间通信步骤Socket通信基本示例基础模式双向通信，发送消息并接收消息如何告知对方已发送完命令服务端优化结语   同学们，今天我们来一起学习Java网络编程里的socket，通过本文的内容，我们就能掌握socket的基本概念以及基本使用。 概念 TCP TCP（传输控制协议）是面向连接的可靠的，基于字节流的传输通信协议。在简化的计算机网络OSI模型中（如下图所示），它完成第四层传输层
Java学习路线总结，搬砖工逆袭Java架构师
学Java，找哪吒
09-07 24万+
定期分享Java硬核技术干货、分享Java学习路线、分享Java经典面试题
Java网络编程——Socket 编程
涛涛的个人博客
07-17 1万+
Java网络编程——Socket 编程
Java进阶学习网络服务器编程.rar
07-10
Java进阶学习网络服务器编程.rar
Java-Java网络编程教程
11-14
va 网络编程教程 资源为视频教程资源 希望对你的 Java 学习有所帮助。
java网络编程学习java聊天程序代码分享
09-04
java聊天程序代码分享,大家参考使用吧
java基础之网络编程讲解，适合初级人员入门学习
最新发布
04-10
java基础之网络编程讲解，适合初级人员入门学习
用Scanner实现多次输入数据
Tro_picana的专栏
09-04 1万+
import java.util.Scanner; public class ScannerTest { public static void main(String[] args) { Scanner sc = new Scanner(System.in); String str=null; while(!(str=sc.nextLine()).equals("exit")){//当输
用java代码实现从excel表格读取数据然后写入生成国际化配置文件properties
Tro_picana的专栏
03-01 4046
你看struts2国际化的properties文件发现这个格式都是xx=xxx,然后换行 所以只要能拿到excel中的数据（当然前提是excel数据以有规律的格式编写的）再写入到一个文本文件就可以了
java反编译查看字节码
Tro_picana的专栏
04-01 1979
深入理解字节码点击这里  jdk中的bin里面自带有反编译的程序，叫javap.exe,利用他可以从编译生成的.class查看出对应的字节码代码 具体方法如下: 1.javap -verbose ** >> **.txt 例: 随便写个java类Person class Person{ String name; char sex; int age; Person(){
java网路编程学习之路(1)
Tro_picana的专栏
04-11 1860
要想进行网络编程，首先得理解网络。
java网路编程学习之路(2)
Tro_picana的专栏
04-15 1831
第二章  Socket用法详解 在客户端和服务器端进行通信时，客户端需要主动创建yu
java反射的作用------hibernate插入功能的j简单实现
Tro_picana的专栏
04-12 1730
很久以前在看java反射的相关内容，但是运行来运行去，
测试HashMap几种遍历的时间
Tro_picana的专栏
11-27 1525
import java.util.HashMap; import java.util.Iterator; import java.util.LinkedHashMap; import java.util.Map; import java.util.Map.Entry; /** * Created by Kevin on 2014/11/20. */ public class Test {
socket网络编程--简单的多人聊天
Tro_picana的专栏
09-05 1469
//本代码参考于马士兵的代码，做了一些简单的改动，例如获取主机名称好让用户知道那句话是谁发的，Swing方面基本上全改了，关键地方加了我所理解的注释，关键线程方面的代码基本上用马老师的import java.awt.FlowLayout; import java.io.DataInputStream; import java.io.DataOutputStream; import java.io.
如何巧用jmeter进行接口测试
Tro_picana的专栏
08-12 1393
最近在做一个项目，给安卓端写y
java网络编程 pdf
12-10
Java网络编程是指使用Java语言进行网络通信和连接的技术。它可以实现网络服务器和客户端之间的数据传输和交互。 Java网络编程的基本原理是通过Java提供的网络编程API来创建网络应用程序。其中，常用的API有Socket、ServerSocket、URLConnection和URL等类。 Java网络编程的优点包括跨平台性强、能够处理多个连接、数据传输可靠性高以及支持各种网络协议等。通过Java的网络编程技术，开发人员可以轻松地实现各种网络应用，如多人在线游戏、聊天程序、文件传输等。 当我们需要使用Java网络编程时，需要了解网络编程的基本知识和概念，如IP地址、端口号、TCP/IP协议等。在使用Java网络编程时，通常需要创建一个服务器端和一个客户端。服务器端通过ServerSocket类监听指定的端口，客户端通过Socket类与服务器端进行连接。一旦连接建立，就可以通过输入输出流进行数据的传输和交互。 对于Java网络编程的学习和应用，我们可以参考各种网络编程相关的书籍和教程，其中包括了《Java网络编程指南》、《深入理解Java网络编程》等。此外，也可以参考官方文档和在线资源，如Oracle官方网站等。 总之，Java网络编程是一项重要的技术，它允许我们创建强大的网络应用程序。通过学习和应用Java网络编程技术，我们能够更好地理解和应对网络通信和连接的需求，并且能够实现各种功能丰富的网络应用程序。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值