目录 1、网络概述 2、TCP和UDP
1、网络概述
1.网络模型图如下:
两台主机通信过程:
1.找到对方IP
2.数据要发送到对方指定的应用程序上。为了标示这些应用程序,所以给这些网络应用程序都用数字进行标示。
为了方便称呼这个数字,叫做端口, 此端口为逻辑端口。
3.如何进行通信呢,定义通信规则。这个通信规则称为协议。 国际组织定义了通用协议TCP/IP。
上述即为网络通讯三要素:
IP地址:InetAddress 无构造方法,直接引用即可 :getByName()、getHostName()、getHostAddress()
网络中设备的标识不易记忆,可用主机名本地回环地址:127.0.0.1 主机名:localhost
端口号:用于标识进程的逻辑地址,不同进程的标识,有效端口:0-65535,其中0-1024系统使用或保留端口
传输协议:通讯的规则。 常见协议:TCP、UDP
Socket:是为网络服务提供的一种机制
通信的两端都有Socket, 网络通信其实就是Socket间的通信,数据在两个Socket间通过IO传输
2、TCP和UDP
UDP:面向无连接。发送数据前不需要建立连接。UDP把数据打成数据包,数据会被封包。对方的端口和地址要明确出来。面向无连接不需要连接,它发送的包是有限制的,分成多包发送。不可靠,数据丢失。速度快。不用确定对方在不在,省略确认过程。这种传输方式在我们生活当中如聊天,视频会议,桌面共享,下载是TCP
1) 将数据及源和目的封装成数据包中,不需要建立连接
2) 每个数据报的大小在限制在64k内
3) 因无连接,是不可靠协议
4) 不需要建立连接,速度快
TCP:面向连接,对方必须在,
1) 建立连接,形成传输数据的通道
2) 在连接中进行大数据量传输
3) 通过三次握手完成连接,是可靠协议
4) 必须建立连接,效率会稍低。
TCP相当于打电话,UDP相当于步话机,
Socket:网络编程就是Socket。Socket 就是为网络服务提供的一种机制。通信的两端都有Socket。网络通信其实就是Socket间的通信。数据在两个Socket间通过IO传输。
UDP传输
1) DatagramSocket与DatagramPacket
DatagramSocket:此类表示用来发送和接收数据报包的套接字。
Send(DatagramPacket p):从此套接字发送数据报包。
DatagramPacket :此类表示数据报包。数据报包用来实现无连接包投递服务,每条报文仅根据该包中包含的信息从一台机器路由到另一台机器,从一台机器发送到另一台机器的多个包可能选择不同的路由,也可能按不同的顺序到达,补对包投递做出保证。既用来发送数据也用来封装数据。
2) 建立发送端,接收端
3) 建立数据包
4) 调用Socket的发送接收方法
5) 关闭Socket
发送端与接收端是两个独立的运行程序。
UDP的发送端
需求:通过UDP传输方式,将一段文字数据发送出去
思路:
1,建立UdpSocket服务
2,提供数据,并将数据封装到数据包中
3,通过Socket服务的发送功能,将数据包发出去
4,关闭资源
UDP的接收端
需求:定义一个应用程序,用于接收udp协议传输的数据并处理的
思路:
1,建立udpsocket服务,通常会监听一个端口,其实就是给这个接收网络应用程序定义数字标识,方便于明确哪些数据过来该应用程序可以处理。
2,定义一个数据包,因为要存储接收到的字节数据,因为数据包对象中有更多功能可以提取字节数据中的不同数据信息
3,通过socket服务的receive方法将收到的数据存入已定义好的数据包中
4,通过数据包对象的特有功能,将这些不同的数据取出,打印在控制台上
5,关闭资源
示例
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
public class UdpSent {
/**
* @param args
*/
public static void main(String[] args)throws Exception {
// TODO Auto-generated method stub
//创建UDP服务
DatagramSocket ds=new DatagramSocket();
//确定数据并封装成数据包
byte[] buf="ge laile".getBytes();
DatagramPacket dp=new DatagramPacket(buf, buf.length,InetAddress.getByName("PC"),10000);
//通过数据包将数据发送出去
ds.send(dp);
ds.close();
}
}
class UdpRece{
public static void main(String[] args)throws Exception {
//创建UDPSocket端点
DatagramSocket ds=new DatagramSocket(10000);
//定义数据包用于存储数据
byte[] buf =new byte[1024];
DatagramPacket dp=new DatagramPacket(buf, buf.length);
//通过receive方法将收到的数据存入数据包
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();
}
}
需求:编写一个聊天程序
有收数据的部分,和发数据的部分;这两部分需要同时执行;那就需要用到多线程技术;一个线程控制收,一个线程控制发
因为收和发动作是不一致的,所以要定义两个run方法,而且这两个方法要封装到不同的类中
import java.net.*;
import java.io.*;
public class ChatDemo {
public static void main(String[] args) throws Exception
{
DatagramSocket sendSocket=new DatagramSocket();
DatagramSocket receSocket=new DatagramSocket();
new Thread(new Send(sendSocket)).start();
new Thread(new Rece(receSocket)).start();
}
}
class Send implements Runnable
{
private DatagramSocket ds;
public Send(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"),10000);
ds.send(dp);
}
} catch (Exception e) {
throw new RuntimeException("发送端失败");
}
}
}
class Rece implements Runnable
{
private DatagramSocket ds;
public Rece(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("接收失败");
}
}
}
TCP传输
1) Socket和ServerSocket
Socket此类实现客户端套接字,套接字是两台机器间通信的端点
ServerSocket
2) 建立客户端和服务器端
3) 建立连接后,通过Socket中的IO流进行数据的传输
4) 关闭socket
同样,客户端与服务器端是两个独立的应用程序。
演示TCP传输
1,TCP分客户端和服务端
2,客户端对应的对象是Socket.
服务端对应的对象是serverSocket
import java.io.*;
import java.net.*;
public class TcpClient {
/**客户端
* 通过查阅socket对象,发现在该对象建立时,就可以去连接指定主机
* 因为TCP是面向连接的,所以在建立socket服务时,就要有服务端存在,并连接成功,形成通路后,在该通道进行数据的传输
*需求:给服务端发一个文本数据
* 步骤
* 1,创建socket服务,并指定要连接的主机和端口。
* 2,为发送数据,应该获取socket流中的输出流
* @param args
*/
public static void main(String[] args)throws Exception
{
//创建客户端的socket服务,指定目的主机和端口。
Socket s=new Socket("192.168.1.123",1009);
//为发送数据,应该获取socket流中的输出流
//InputStream in=s.getInputStream();//返回此套接字的输入流。
OutputStream out=s.getOutputStream();
out.write("tcp ge men lai l ".getBytes());
s.close();
}
}
class TcpServer {
/**
* 服务端
* 通过查阅socket对象,发现在该对象建立时,就可以去连接指定主机
*accept():侦听并接受到此套接字的连接。
*需求:定义端点接收数据并打印在控制台上
* 步骤
* 1,建立服务端的socket服务,ServerSocket();
* 并监听一个端口
* 2,获取连接过来的客户端对象 ,
* 通过ServerSocket的accept方法,没有连接就会等,所以这个方法阻塞式的,
* 3,客户端如果发过来数据,那么服务端要使用对应的客户端对象,并获取到该客户端对象的读取流来读取发过来的数据
* 并打印在控制台。
* 4,关闭服务器(可选)
*/
public static void main(String[] args)throws Exception
{
//创建客户端的socket服务,并监听一个端口
ServerSocket ss=new ServerSocket(1009);
//通过accept方法获取连接过来的客户端对象
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();
}
}
建立一个群聊服务端
演示TCP的传输的客户端和服务端的互访
需求:客户端给服务端发送数据,服务端收到后,给客户端反馈信息
客户端
1,建立socket服务,指定要连接的主机和端口
2,获取socket流中的输出流,将数据写到该流中,通过网络发送给服务端。
3,获取socket流中的输入流,将服务端反馈的数据获取到,并打印
4,关闭客户端资源
import java.net.*;
import java.io.*;
public class TcpClient2 {
public static void main(String[] args)throws Exception
{
Socket s=new Socket("192.168.2.1",10004);
OutputStream out=s.getOutputStream();
out.write("服务端,你好".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 TcpServer2 {
public static void main(String[] args)throws Exception
{
ServerSocket ss=new ServerSocket(10004);
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();
Thread.sleep(10000);
out.write("开始吧".getBytes());
s.close();
ss.close();
}
}
需求:建立一个文本转换服务器
客户端给服务端发送文本,服务端会将文本转成大写在返回给客户端
而且客户端可以不断的进行文本转换,当客户端输入over时,转换结束
分析:
客户端
既然是操作设备上的数据,那么就可以使用IO技术,并按照IO的操作规律来思考
源:键盘输入
目的:网络设备,网络输出流
而且操作的是文本数据,可以选择字符流
步骤
1,建立服务
2,获取键盘录入
3,将数据发给服务器
4,后去服务端返回的大写数据
5,结束,关资源。
都是文本数据,可以使用字符流进行操作,同时提高效率,加入缓冲
import java.io.*;
import java.net.*;
public class TransClient {
public static void main(String[] args)throws Exception
{
Socket s=new Socket("192.168.1.123",10005);
//定义读取键盘数据的流对象
BufferedReader bufr=new BufferedReader(new InputStreamReader(System.in));
/*//定义目的,将数据写入到socket 输出流,发给服务端
BufferedWriter bufout=new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));*/
PrintWriter out=new PrintWriter(s.getOutputStream(),true);
//定义一个socket读取流,读取服务端返回的大写信息。
BufferedReader bufIn=new BufferedReader(new InputStreamReader(s.getInputStream()));
String line=null;
while((line=bufr.readLine())!=null)
{
if("over".equals(line))
break;
/*bufout.write(line);
bufout.newLine();
bufout.flush();*/
out.println(line);
String str=bufIn.readLine();
System.out.println("server:"+str);
}
bufr.close();
s.close();//
}
}
服务端
源:socket读取流
目的:socket输出流
都是文本,装饰
该例子出现的问题现象:客户端和服务端都在莫名的等待 ,为何呢?
因为客户端和服务端都有阻塞式方法,这些方法没有读到结束标记,那么就一直等,而导致两端都在等待。开发时如果遇到就查看阻塞式方法
class TransServer{
public static void main(String[] args) throws Exception
{
ServerSocket ss=new ServerSocket(100005);
Socket s=ss.accept();
String ip=s.getInetAddress().getHostAddress();
System.out.println(".....conneced"+ip);
//源:读取socket读取流中的数据
BufferedReader bufIn=new BufferedReader(new InputStreamReader(s.getInputStream()));
/*//目的,socket输出流,将大写数据写入到socket输出流,并发送给客户端
BufferedWriter bufout=new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));*/
PrintWriter out=new PrintWriter(s.getOutputStream(),true);
String line=null;
while((line=bufIn.readLine())!=null)//readLine()阻塞式方法。
{
System.out.println(line);
/*bufout.write(line.toUpperCase());
bufout.newLine();
bufout.flush();*/
out.println(line.toUpperCase());
}
s.close();
ss.close();
}
}
文件的复制
import java.io.*;
import java.net.*;
public class TextClient {
public static void main(String[] args)throws Exception
{
Socket s=new Socket("192.168.2.245",10006);
BufferedReader bufr=new BufferedReader(new FileReader("IpDemo.java"));
PrintWriter out=new PrintWriter(s.getOutputStream(),true);
DataOutputStream dos=new DataOutputStream(s.getOutputStream());//操作基本数据类型的流对象。
long time=System.currentTimeMillis();
dos.writeLong(time);
// out.println(time);
String line=null;
while((line=bufr.readLine())!=null)
{
out.println(line);
}
/* out.println("over");//自定义结束。定义标记,第一种方式自定义结束标记,
dos.writeLong(time);*/
s.shutdownOutput();//关闭客户端的输出流,相当于给流中加入一个结束标记-1.禁止此套接字的输出流
BufferedReader bufIn=new BufferedReader(new InputStreamReader(s.getInputStream()));
String str=bufIn.readLine();
System.out.println(str);
bufr.close();
s.close();
}
}
class TextServer {
public static void main(String[] args) throws Exception
{
ServerSocket ss=new ServerSocket(10006);
Socket s=ss.accept();
String ip=s.getInetAddress().getHostAddress();
System.out.println(ip+"..............connecsed");
DataInputStream dis=new DataInputStream(s.getInputStream());
long l=dis.readLong();//
BufferedReader bufIn=new BufferedReader(new InputStreamReader(s.getInputStream()));
PrintWriter out=new PrintWriter(new FileWriter("server.txt"),true);
String line=null;
while((line=bufIn.readLine())!=null)
{
/*if("over".equals(line))
break;*/
out.println(line);
}
PrintWriter pw=new PrintWriter(s.getOutputStream(),true);
pw.println("上传成功");
out.close();
s.close();
ss.close();
}
}
TCP传输最容易出现的问题
客户端连接上服务端,两端都在等待,没有任何数据传输
通过例程分析:
因为read方法或是readline方法是阻塞式
解决方法:自定义结束标记
使用shutdowninput shutdownoutput方法。
需求:简单的一个客户端和一个服务器上传图片
import java.io.*;
import java.net.*;
public class PicClient {
/**客户端
* 1,服务端点
* 2,读取客户端已有的图片数据
* 3,通过socket输出流将数据发给服务端
* 4,读取服务端反馈信息
* 5,关闭
* @param args
*/
public static void main(String[] args) throws Exception
{ if(args.length!=1)
{
System.out.println("请选择一个jpg格式的图片");
return;
}
File file=new File(args[0]);
if(!(file.exists()&&file.isFile()))
{
System.out.println("该文件有问题,要么不存在,要么不是文件");
return;
}
if(!file.getName().endsWith(".jpg"))
{
System.out.println("图片格式错误,请重新选择");
return ;
}
if(file.length()>1024*1024*8)
{
System.out.println("文件过大。没安好心");
return;
}
Socket s=new Socket("192.168.1.2",1007);
FileInputStream fis=new FileInputStream("c:\\1.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 {
/**服务器
* 这个服务端有个局限性,当A客户端连接上以后,被服务端获取到,服务端执行具体流程
* 这时B客户端连接,只有等待
* 因为服务端还没有处理完A客户端的请求,还有循环回来执行下次accept方法,所以
* 暂时获取不到B客户端对象
* 那么为了可以让多个客户端同时并发访问服务端
* 那么服务端最好就是将每个客户端封装到一个单独的线程中,这样,就可以同时处理多个客户端请求。
* @param args
* 如何定义线程?
* 只要明确了每一个客户端要在服务端执行的代码即可,将该代码存入run方法中。
*/
public static void main(String[] args) throws Exception
{
ServerSocket ss=new ServerSocket(1007);
Socket s=ss.accept();//accept()是阻塞式的。
InputStream in=s.getInputStream();
FileOutputStream fos=new FileOutputStream("server.bmp");
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.*;
public class PicClient {
/**客户端
* 1,服务端点
* 2,读取客户端已有的图片数据
* 3,通过socket输出流将数据发给服务端
* 4,读取服务端反馈信息
* 5,关闭
* @param args
*/
public static void main(String[] args) throws Exception
{ if(args.length!=1)
{
System.out.println("请选择一个jpg格式的图片");
return;
}
File file=new File(args[0]);
if(!(file.exists()&&file.isFile()))
{
System.out.println("该文件有问题,要么不存在,要么不是文件");
return;
}
if(!file.getName().endsWith(".jpg"))
{
System.out.println("图片格式错误,请重新选择");
return ;
}
if(file.length()>1024*1024*8)
{
System.out.println("文件过大。没安好心");
return;
}
Socket s=new Socket("192.168.1.2",1007);
//FileInputStream fis=new FileInputStream("c:\\1.jpg");
FileInputStream fis=new FileInputStream(file);
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 PicThread implements Runnable
{
private Socket s;
PicThread(Socket s)
{
this.s=s;
}
public void run()
{ int count=1;
String ip=s.getInetAddress().getHostAddress();
try {
System.out.println(ip+".....connected");
InputStream in=s.getInputStream();
File file=new File(ip+"("+(count)+")"+".jpg");//ip(1).jpg。
while(file.exists())
file=new File(ip+"("+(count++)+")"+".jpg");
FileOutputStream fos=new FileOutputStream("server.bmp");
byte[] buf=new byte[1024];
int len=0;
while((len=in.read())!=-1)
{
fos.write(buf,0,len);
}
OutputStream out=s.getOutputStream();
out.write("上传成功".getBytes());
} catch (Exception e) {
throw new RuntimeException(ip+"上传失败");
}
}
}
class PicServer {
/**服务器
* 这个服务端有个局限性,当A客户端连接上以后,被服务端获取到,服务端执行具体流程
* 这时B客户端连接,只有等待
* 因为服务端还没有处理完A客户端的请求,还有循环回来执行下次accept方法,所以
* 暂时获取不到B客户端对象
*
* 那么为了可以让多个客户端同时并发访问服务端
* 那么服务端最好就是将每个客户端封装到一个单独的线程中,这样,就可以同时处理多个客户端请求。
* @param args
* 如何定义线程?
* 只要明确了每一个客户端要在服务端执行的代码即可,将该代码存入run方法中。
*/
public static void main(String[] args) throws Exception
{
ServerSocket ss=new ServerSocket(1007);
while(true)
{
/*Socket s=ss.accept();accept()是阻塞式的。
InputStream in=s.getInputStream();
FileOutputStream fos=new FileOutputStream("server.bmp");
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();*/
Socket s=ss.accept();
new Thread(new PicThread(s)).start();
}
//ss.close();
}
}
客户端向服务端发送用户名请求登录,服务端通过验证,返回“欢迎光临”,未通过“用户不存在”。
import java.io.*;
import java.net.*;
/*客户端通过键盘录入用户名
* 服务端对这个用户名进行校验
* 如果该用户存在,在服务端显示xxx已登录,并在客户端显示xxx欢迎光临
* 如果该用户存在,在服务端显示xxx尝试登录,并在客户端显示xxx该用户补存在。
* 最多就登录三次。
* */
public class LoginClient {
public static void main(String[] args)throws Exception
{
Socket s=new Socket("192.168.1.2",10008);
BufferedReader bufr=new BufferedReader(new InputStreamReader(System.in));;
PrintWriter out=new PrintWriter(s.getOutputStream(),true);
BufferedReader bufIn=new BufferedReader(new InputStreamReader(s.getInputStream()));
for(int x=0;x<3;x++)
{
String line=bufr.readLine();
if(line==null)
break;
out.println(line);
String info=bufIn.readLine();
System.out.println("info:"+info);
if(info.contains("欢迎"))
break;
}
bufr.close();
s.close();
}
}
class UserThread implements Runnable
{
private Socket s;
UserThread(Socket s)
{
this.s=s;
}
public void run()
{
String ip=s.getInetAddress().getHostAddress();
System.out.println(ip+"....connected");
try {
for(int x=0;x<3;x++)
{
BufferedReader bufIn =new BufferedReader(new InputStreamReader(s.getInputStream()));
String name=bufIn.readLine();
//读文件
BufferedReader bufr=new BufferedReader(new FileReader("user.txt"));
PrintWriter out=new PrintWriter(s.getOutputStream(),true);
String line=null;
boolean flag=false;//定义一个标记。
while((line=bufr.readLine())!=null)
{
if(line.equals(name))
{
flag=true;
break;
}
}
if(flag)
{
System.out.println(name+",已登录");
out.println(name+",欢迎观临");
break;
}
else
{
System.out.println(name+",尝试登录");
out.println(name+",用户名不存在");
break;
}
}
s.close();
} catch (Exception e) {
throw new RuntimeException(ip+"校验失败");
}
}
}
class LoginServer {
public static void main(String[] args)throws Exception
{
ServerSocket ss=new ServerSocket(10008);
while(true)
{
Socket s=ss.accept();
new Thread(new UserThread(s)).start();
}
}
------- android培训、 java培训、期待与您交流! ----------