网络编程Socket



网络模型

OSI参考模型

TCP/IP参考模型

可以上网脑补

学的网络编程主要在应用层（我想android、JavaWeb、QQ、梦幻西游等吧，估计是）、传输层和网际层混,每个层都有自己的协议规则。

传输层主要用TCP（同步；面向连接，数据量大）、UDP（异步；面向无连接，大小限制在64k内，QQ聊天、网络视频用的UDP）

网际层主要用IP协议

应用层协议：HTTP

网络通讯要素

IP地址：标识网络上的电脑的，相当于给电脑取个唯一的名字   192.168.1.1，最大只能设置255这是字节的最大数，（8个1的二进制转10进制得出的）

              127.0.0.1本地回环地址。IP地址数据太多也难记，所以取了名字127.0.0.1 = localhost

               IP/v6不IP/v4的组合数更大，IP/6还包含字符

端口号‘：用来标识电脑上的网络应用程序的，（为什么A同学，通过QQ用网络发个信息给B同学，然后B同学只能用QQ接受，而不能用飞秋或其他程序接收呢？或者A同学的QQ怎么准确的发给了B同学的QQ上了呢？这就是端口体现的作用了。）

                0-1024端口，一般留给系统用，有0-65535个端口

传输协议：通讯的规则。(就像A同学用英文，而B同学用中文，他们两能交流吗？)所以网络上的2台电脑要通信就要用同一个规则。

                  国际组织定义了通用的协议是TCP/IP协议，也是我们最常用的。它能用于广域网也能用于局域网。也还有其他的协议。特有的组织或单位有自己特有的通信协议。

Socket

             使用最频繁的三个方法:connect、getInputStream、getOutputStream

             通信的两端都有Socket、网络通信其实就是Socket间的通信、数据在2个Socket之间通过IO流传输。

             套接字，使应用程序能够读写与收发通讯协定（protocol）与资料的程序 。（逻辑上的插座）

             

操作流程（玩Socket主要玩的就是这个流程）

建立发送端，接收端

建立数据包

调用Socket的发送接收方法

关闭Socket。

发送端与接收端是两个独立的运行程序。（类比于服务端和客户端）

Socket的UDP传输协议

DatagramSocket与DatagramPacket

DatagramSocket帮助文档的解说(即发送又接收，客户端服务端都得有)   

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

           数据报套接字是包投递服务的发送或接收点。每个在数据报套接字上发送或接收的包都是单独编址和路由的。从一台机器发送到另一台机器的多个包可能选择不同的路由，也可能按不同的顺序到达。

           在 DatagramSocket 上总是启用 UDP 广播发送。为了接收广播包，应该将 DatagramSocket 绑定到通配符地址。在某些实现中，将 DatagramSocket 绑定到一个更加具体的地址时广播包也可以被接收。

示例：DatagramSocket s = new DatagramSocket(null);

       s.bind(new InetSocketAddress(8888));

 这等价于：DatagramSocket s = new DatagramSocket(8888); 两个例子都能创建能够在 UDP 8888 端口上接收广播的 DatagramSocket。

DatagramPacket（把数据封装成包，接收和封装数据）

              此类表示数据报包。

              数据报包用来实现无连接包投递服务。每条报文仅根据该包中包含的信息从一台机器路由到另一台机器。从一台机器发送到另一台机器的多个包可能选择不同的路由，也可能按不同的顺序到达。不对包投递做出保证。

示例代码：

import java.io.*;
import java.net.*;

/**
 * UDP协议的网络聊天程序(服务器端)
 *
 * @author Terry
 * @date 2014-6-15
 *
 */
public class UdpSend {
	public static void main(String[] args) throws Exception{
		byte[] buf = "我是服务端".getBytes();//创建发送器
		DatagramSocket ds = new DatagramSocket();//创建要发送的包
		DatagramPacket dp =
		  new DatagramPacket(buf,buf.length,InetAddress.getByName("192.168.1.101"),10000);
		ds.send(dp);
		ds.close();
	}
}

class UdpRece{
	public static void main(String[] args) throws Exception{
		DatagramSocket ds = new DatagramSocket(10000);
		byte[] buf = new byte[1024];
		DatagramPacket dp = new DatagramPacket(buf,buf.length);
		ds.receive(dp);
		String ip = dp.getAddress().getHostAddress();
		String data = new String(dp.getData(),0,dp.getLength());
		int port = dp.getPort();
		System.out.println(ip+"--"+data+"--"+port);
		ds.close();
	}
}

多次接收客户端发来的信息

import java.io.*;
import java.net.*;

/**
 * UDP协议的网络聊天程序(服务器端)
 *
 * @author Terry
 * @date 2014-6-15
 *
 */
public class UdpSend {
	public static void main(String[] args) throws Exception{
		DatagramSocket ds = new DatagramSocket();
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String temp = null;
		while((temp = br.readLine())!=null){
			if(temp.equals("886")){
				break;
			}
			DatagramPacket dp =
			  new DatagramPacket(temp.getBytes(),temp.getBytes().length,InetAddress.getByName("192.168.1.101"),10000);//目的地址，往地址为192.168.1.101的10000端口发送
		    ds.send(dp);
		}
		ds.close();
	}
}

class UdpRece{
	public static void main(String[] args) throws Exception{
		DatagramSocket ds = new DatagramSocket(10000);//接收本主机地址的10000端口的包
		//DatagramSocket ds = new DatagramSocket();
		//ds.connect(InetAddress.getByName("192.168.1.101"),10000);//用这样的方法连接不行。。。这应该是用来连接服务器的
		while(true){
			byte[] buf = new byte[1024*64];
			DatagramPacket dp = new DatagramPacket(buf,buf.length);
			ds.receive(dp);//接收
			String ip = dp.getAddress().getHostAddress();
			String data = new String(dp.getData(),0,dp.getLength());
			int port = dp.getPort();
			System.out.println(ip+"--"+data+"--"+port);
		}
		//ds.close();//服务器不要关闭连接
	}
}

192.168.1.255（最后的255表示这个域里面的广播地址，发给这个地址的信息，在域里面的人都能收到）

模拟聊天程序（出现绑定异常）

import java.io.*;
import java.net.*;
class Send implements Runnable{
	private DatagramSocket ds;
	public Send(DatagramSocket ds){
		this.ds = ds;
	}

	public void run(){
		try{
			while(true){
				byte[] buf = new byte[1024];
				DatagramPacket dp = new DatagramPacket(buf,buf.length);
				ds.receive(dp);
				String ip = dp.getAddress().getHostAddress();
				String data = new String(dp.getData(),0,dp.getLength());
				System.out.println(ip + "--" + data);
			}
		}catch(Exception e){
			throw new RuntimeException("");
		}
	}
}

public class Rece implements Runnable{
	private DatagramSocket ds;
	public Rece(DatagramSocket ds){
		this.ds = ds;
	}

	public void run(){
		try{
			BufferedReader bufr =new BufferedReader(new InputStreamReader(System.in));
			String line = null;
			while((line = bufr.readLine())!=null){
				if("886".equals(line)){
					break;
				}
				byte[] buf = line.getBytes();
				DatagramPacket dp = new DatagramPacket(buf,buf.length,InetAddress.getByName("192.168.1.255"),10002);
				ds.send(dp);
			}
		}catch(Exception e){
			throw new RuntimeException("");
		}
	}
}

class ChatPprogram{
	public static void main(String[] args) throws Exception{
		DatagramSocket sendSocket = new DatagramSocket();
		DatagramSocket receSocket = new DatagramSocket(10002);

		new Thread(new Send(sendSocket)).start();
		new Thread(new Rece(receSocket)).start();
	}
}

Socket（客户端）和ServerSocket(服务端)

简单连接示例代码：

import java.io.*;
import java.net.*;
class SocketClientTest{
	public static void main(String[] a) throws Exception{
	    System.out.println("222");
		Socket s = new Socket("192.168.1.100",20000);
		OutputStream out = s.getOutputStream();
		out.write("woshikehuduan".getBytes());
		s.close();
	}
}

class SocketServiceTest{
	public static void main(String[] a) throws Exception{
		System.out.println("111");
		ServerSocket ss = new ServerSocket(20000);
		Socket s = ss.accept();
		String ip = s.getInetAddress().getHostAddress();
		System.out.println(ip + "......connected");
		InputStream in = s.getInputStream();
		byte[] buf = new byte[1024];
		int len = in.read(buf);
		System.out.println(new String(buf,0,len));
		s.close();
		ss.close();
	}
}

客户端发送信息给服务器并接收服务器发回来的信息，服务器接收客户端发送的信息并回复信息给客户端

import java.io.*;
import java.net.*;
class SocketClientTest{
	public static void main(String[] a) throws Exception{
	    System.out.println("222");
		Socket s = new Socket("192.168.1.100",20000);
		OutputStream out = s.getOutputStream();
		out.write("laizhikehuduandewenhou:nihao".getBytes());
		InputStream in = s.getInputStream();
		byte[] buf = new byte[1024];
		int len = in.read(buf);
		System.out.println(new String(buf,0,len));
		s.close();
	}
}

class SocketServiceTest{
	public static void main(String[] a) throws Exception{
		System.out.println("111");
		ServerSocket ss = new ServerSocket(20000);
		Socket s = ss.accept();
		String ip = s.getInetAddress().getHostAddress();
		System.out.println(ip + "......connected");
		InputStream in = s.getInputStream();
		byte[] buf = new byte[1024];
		int len = in.read(buf);
		System.out.println(new String(buf,0,len));
		OutputStream out = s.getOutputStream();
		out.write("shoudaobinghuifu:niyehao".getBytes());
		s.close();
		ss.close();
	}
}

小练习，客户端发送文本给服务端，服务端把收到的文本转成大写后再发给客户端

import java.io.*;
import java.net.*;
class SocketClientTest{
	public static void main(String[] a) throws Exception{
		//创建Socket并与服务端连接
		Socket s = new Socket("192.168.1.100",30000);
		//获得用户输入的源的字符流
		BufferedReader bufr =
		      new BufferedReader(new InputStreamReader(System.in));
		//目的流，要将数据发给谁s.getOutputStream()
		//BufferedWriter bufOut =
			  //new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
		PrintWriter pw = new PrintWriter(s.getOutputStream(),true);
		//读取流，要从谁那读数据
		BufferedReader bufIn =
			  new BufferedReader(new InputStreamReader(s.getInputStream()));
		String line = null;
		while((line = bufr.readLine())!=null){
			if("over".equals(line)){
				break;
			}
			//bufOut.write(line);//这里的方法，内部原理是，它不是直接将数据，写到目的地，而是先//写到内存中，所以服务器那边，连接上了，但是没有收到数据。要//flush(刷新内存)，flush会将内存的数据写入预期目//标
                       // bufOut.newLine();//这里加这个方法的原因是？如果不加这个方法，当我把数据发给服务器//，但是服务器在读的时候，没有发现回车符号，就会一直在那等。//加这个方法的原因是告诉服务器那边，什么时候回车
//好让服务器读一行。
			//bufOut.flush();//这时候服务器就收到数据了
			pw.println(line);
			String str = bufIn.readLine();
			System.out.println("server:"+str);
		}
		bufr.close();
		s.close();//这里关闭了后，在服务器的BufferedReader 就会读到-1.
	}
}

class SocketServiceTest{
	public static void main(String[] a) throws Exception{
		ServerSocket ss = new ServerSocket(30000);
		while(true){//为了让服务器可以处理多人的请求，应该不行，这里要用线程做吧
		Socket s = ss.accept();
		String ip = s.getInetAddress().getHostAddress();
		System.out.println("ip:"+ip+"....connected");
		//从谁那读数据
		BufferedReader bufIn = new BufferedReader(
			new InputStreamReader(s.getInputStream()));
		//把数据写给谁
		//BufferedWriter bufOut = new BufferedWriter(
			//new OutputStreamWriter(s.getOutputStream()));
		PrintWriter pw = new PrintWriter(s.getOutputStream(),true);
		String line = null;
		while((line = bufIn.readLine())!=null){
			//bufOut.write(line.toUpperCase());
			//bufOut.newLine();//这里加这个方法的原因是？如果不加这个方法，当我把数据发给客服端
//，但是客户端在读的时候，没有发现回车符号，就会一直在那等。加这个方法的原因是告诉客服端那边，什么时候回车
//好让客户端读一行。
			//bufOut.flush();
			pw.println(line.toUpperCase());
		}
		s.close();
		}
		//ss.close();
	}
}

网络版的上传文件

import java.io.*;
import java.net.*;
class UploadFileClient{

	public static void main(String[] a) throws Exception{
		Socket s = new Socket("192.168.1.100",10010);//连接服务器
		//客户端找自己机子上的文件
		BufferedReader bufr = new BufferedReader(new FileReader("F:\\test\

\SocketTest.java"));
		//把Socket的OutputStream包装一下，这里是装饰者设计模式
		PrintWriter out = new PrintWriter(s.getOutputStream(),true);//true代表

自动flush
                String line = null;
		while((line = bufr.readLine())!=null){//读文件
			out.println(line);//写文件
		}
		//out.println("over");//不加这个结束标识的话，都在等待着读的情况发生，

但是用over也不好，万一文件里面有一行就写的是over呢？
		s.shutdownOutput();//禁用Socket的输出流，类似于打标记
		//把Socket的InputStream包装一下，这里是装饰者设计模式
		BufferedReader bufIn = new BufferedReader(new InputStreamReader

(s.getInputStream()));
		String str = bufIn.readLine();//不写over这里会一直等待读
		System.out.println(str);

		bufr.close();
		s.close();
	}
}

class UploadFileServer{
	public static void main(String[] a) throws Exception{
		ServerSocket ss = new ServerSocket(10010);//绑定端口
		Socket s = ss.accept();
		String ip = s.getInetAddress().getHostAddress();
		System.out.println("ip:"+ip+"....connected");
		//Socket的流
		BufferedReader bufIn = new BufferedReader(new InputStreamReader

(s.getInputStream()));
		//服务器本地的流
		PrintWriter out = new PrintWriter(new FileWriter("C:\\Users\\JSON\

\Desktop\\UploadFileServer.java"));
		String line = null;
		while((line = bufIn.readLine())!=null){//不写over这里会一直等着读
			//if("over".equals(line)){
				//break;
			//}
			out.println(line);
		}
		//out.flush();
		//Socket的流
		PrintWriter pw = new PrintWriter(s.getOutputStream(),true);
		pw.println("上传成功！");
		out.close();
		s.close();
	}
}

单人上传图片

import java.io.*;
import java.net.*;
class PicClient{
	public static void main(String[] a)throws Exception{
		Socket s = new Socket("192.168.1.100",10007);
		FileInputStream fis = new FileInputStream("F:\\java\\图片<a target=_blank href="file://\\dmhyrz-9420648415.jpg">\\dmhyrz-9420648415.jpg</a>");
		OutputStream out = s.getOutputStream();
		byte[] buf = new byte[1024];
 		int len = 0;
		while((len=fis.read(buf))!=-1){
			out.write(buf,0,len);
		}
		s.shutdownOutput();
		InputStream in = s.getInputStream();
		byte[] bufIn = new byte[1024];
		int num = in.read(bufIn);
		System.out.println(new String(bufIn,0,num));
		fis.close();
		s.close();
	}
}

class PicServer{
	public static void main(String[] a) throws Exception{
		ServerSocket ss = new ServerSocket(10007);
		Socket s = ss.accept();
		InputStream in = s.getInputStream();
		FileOutputStream fos = new FileOutputStream("C:\\Users\\JSON\\Desktop\\shangchuan.jpg");
		byte[] buf = new byte[1024];
		int len = 0;
		while((len=in.read(buf))!=-1){
			fos.write(buf,0,len);
		}
		OutputStream out = s.getOutputStream();
    		out.write("上传成功".getBytes());
		fos.close();
		s.close();
		ss.close();
	}
}

接收多人上传图片或其他文件的服务器 

import java.io.*;
import java.net.*;
class PicClient{
	public static void main(String[] a)throws Exception{
		Socket s = new Socket("192.168.1.100",10007);
		FileInputStream fis = new FileInputStream("F:\\java\\图片\\dmhyrz-9420648415.jpg");
		OutputStream out = s.getOutputStream();
		byte[] buf = new byte[1024];
 		int len = 0;
		while((len=fis.read(buf))!=-1){
			out.write(buf,0,len);
		}
		s.shutdownOutput();
		InputStream in = s.getInputStream();
		byte[] bufIn = new byte[1024];
		int num = in.read(bufIn);
		System.out.println(new String(bufIn,0,num));
		fis.close();
		s.close();
	}
}

class PicServer{
	public static void main(String[] a) throws Exception{
		final ServerSocket ss = new ServerSocket(10007);
		new Thread(new Runnable(){
			@Override
			public void run(){
				try{
					while(true){
						Socket s = ss.accept();
						InputStream in = s.getInputStream();
						FileOutputStream fos = new FileOutputStream("C:\\Users\\JSON\\Desktop\

\"+System.currentTimeMillis()+".jpg");
						byte[] buf = new byte[1024];
						int len = 0;
						while((len=in.read(buf))!=-1){
							fos.write(buf,0,len);
						}
						OutputStream out = s.getOutputStream();
    						out.write("上传成功".getBytes());
						fos.close();
						s.close();
					}
					//ss.close();
				    }catch(Exception e){
					e.printStackTrace();
				    }
			}
		}).start();
	}
}

URL类（get方法）

 URLConnection openConnection()
          返回一个 URLConnection 对象，它表示到 URL 所引用的远程对象的连接。

相关知识点：

遇见的问题：

一、在学的过程中遇见过这样一个问题，在F:盘下有一个Test.java文件

package lie14_1;

public class Test {

 /**
  * @param args
  */
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  System.out.println(11);
 }

}

当在cmd下运行javac Test.java的时候，运行用过，但是用java Test的时候报错，最后发现是包的问题package lie14_1;把包删除就可以了。具体原因不详。





时间： 2024-03-05 05:06:50

网络编程Socket的相关文章

java-初学Java网络编程socket，为何我的服务器打不开？

问题描述 初学Java网络编程socket,为何我的服务器打不开? 初学Java网络编程socket,写了个服务器,但是打不开,求指导.代码如下 import java.io.*; import java.net.*; import java.util.*; import javafx.application.Application; import javafx.application.Platform; import javafx.scene.Scene; import javafx.scen

Linux网络编程socket选项之SO_LINGER,SO_REUSEADDR

                       Linux网络编程socket选项之SO_LINGER,SO_REUSEADDR Linux网络编程中,socket的选项很多.其中几个比较重要的选项有:SO_LINGER(仅仅适用于TCP,SCTP), SO_REUSEADDR.   SO_LINGER 在默认情况下,当调用close关闭socke的使用,close会立即返回,但是,如果send buffer中还有数据,系统会试着先把send buffer中的数据发送出去,然后close才返回.

linux网络编程socket介绍

  一.概念介绍 网络程序分为服务端程序和客户端程序.服务端即提供服务的一方,客户端为请求服务的一方.但实际情况是有些程序的客户端.服务器端角色不是这么明显,即互为客户端和服务端. 我们编写网络程序时,一般是基于TCP协议或者UDP协议进行网络通信的. TCP:(Transfer Control Protocol)传输控制协议是一种面向连接的协议, 当我们的网络程序使用这个协议的时候,网络可以保证我们的客户端和服务端之间的传输是可靠的. UDP:(User Datagram Protocol)用

网络编程-socket编程中的accept函数

问题描述 socket编程中的accept函数 一个简单的客户/服务器的实现中,connect成功了,但是accept失败,它的返回值为0,这是怎么回事? 解决方案 已解决,原来是其中 = 的运算级别问题,加了个括号就行了,多谢楼上各位! 解决方案二: 名称 accept() 接收一个套接字中已建立的连接 使用格式 #include <sys/types.h> #include <sys/socket.h> int accept(int sockfd,struct sockaddr

linux网络编程-Socket编程，写了结束子进程的程序，但是运行起来有问题

问题描述 Socket编程,写了结束子进程的程序,但是运行起来有问题 在ubuntu上写的一个socket的程序,select并发的,当客户端断开,子进程要被结束,测试在ubuntu本地运行是没有问题的,同样的程序上传到服务器(CentOS)上,发现客户端关闭后,服务端没有办法结束生成的子进程,请问各位大大这是什么原因造成的啊... 出现问题的代码如下主函数中写了 signal(SIGCHLDsig_child); 函数实现如下: void sig_child(int signo) { pid_

网络编程socket基本API详解

socket socket是在应用层和传输层之间的一个抽象层,它把TCP/IP层复杂的操作抽象为几个简单的接口供应用层调用已实现进程在网络中通信. socket起源于UNIX,在Unix一切皆文件哲学的思想下,socket是一种"打开-读/写-关闭"模式的实现,服务器和客户端各自维护一个"文件",在建立连接打开后,可以向自己文件写入内容供对方读取或者读取对方内容,通讯结束时关闭文件. socket 类型     常见的socket有3种类型如下.      (1)流

Socket 网络编程实践经验

目录 目录 相关文章 Socket 与 HTTP 的区别 生产实践考虑 网络断开重连问题 Heartbeat 心跳机制 使用非阻塞模式下的 select 函数进行 Socket 连接检查 会话过期问题 同步还是异步问题 数据缓存问题 完全断开连接问题 相关文章 NOTE:本文假设你已经对 Socket 的使用有一定的了解. Python Module_Socket_网络编程 Socket 与 HTTP 的区别 首先通过对比法来了解两者不同的特性: HTTP:超文本传输协议,首先它是一个协议,并且

Python Socket 网络编程

原文:Python Socket 网络编程 Socket 是进程间通信的一种方式,它与其他进程间通信的一个主要不同是:它能实现不同主机间的进程间通信,我们网络上各种各样的服务大多都是基于 Socket 来完成通信的,例如我们每天浏览网页.QQ 聊天.收发 email 等等.要解决网络上两台主机之间的进程通信问题,首先要唯一标识该进程,在 TCP/IP 网络协议中,就是通过 (IP地址,协议,端口号) 三元组来标识进程的,解决了进程标识问题,就有了通信的基础了. 本文主要介绍使用 Python 进

Java的Socket网络编程基础知识入门教程_java

一.TCP/IP简介 TCP/IP协议族是互联网使用的协议,也可以用在独立的专用网络中. TCP/IP协议族包括了IP协议.TCP协议和UDP协议. IP协议使用IP地址来分发报文,但它是尽力而为的服务,报文可能丢失.乱序或者 重复发送.TCP和UDP协议在IP协议基础上增加了端口号,从而在两台主机的应用 程序间建立起透明的连接. 不同的是,TCP协议会对IP层的错误进行修复,它通过握手消息在主机间建立连接, 之后通过在消息中加入序列号来恢复消息中的错误.而UDP只是简单地扩展了IP协议, 使它