JAVA基础学习day24--Socket基础一UDP与TCP的基本使用
一、网络模型
1.1、OIS参考模型
1.2、TCP/IP参考模型
1.3、网络通讯要素
IP地址：IPV4/IPV6
端口号:0-65535，一般0-1024，都被系统占用，mysql:3306,oracle:1521
传输协议:TCP/UDP
二、类 InetAddress
2.1、InetAddress 主机对象
IP 地址是 IP 使用的 32 位或 128 位无符号数字，它是一种低级协议，UDP 和 TCP 协议都是在它的基础上构建的
2.2、示例
import java.net.*;
class IPDemo
{
public static void main(String[] args) throws Exception
{
//getLoaclHostAddress();
getAllByName();
}
/*
获取本机的IP和主机名
*/
public static void getLoaclHostAddress() throws Exception
{
//返回本地主机
InetAddress ia=InetAddress.getLocalHost();
System.out.println(ia.toString());
//主机名
String hostName=ia.getHostName();
//IP地址
String ip=ia.getHostAddress();
System.out.println("hostName="+hostName+".....ip="+ip);
} /*
获取163或者百度的所有IP地址集合
*/
public static void getAllByName() throws Exception
{
//获取淘宝的主机数组
InetAddress [] ia=InetAddress.getAllByName("www.163.com");
for(InetAddress i:ia)
{
//输出主机IP地址
System.out.println("IP:"+i.getHostAddress());
System.out.println("Name:"+i.getHostName());
}
}
}
三、TCP与UDP
3.1、概述
四、Socket
4.1、Socket
Socket就是为网络服务提供的一种机制
通信两端都有Socket
网络通信其实就是Socket间的通信
数据在两个Socket间通过IO通信
五、UDP
5.1、概述
此类表示用来发送和接收数据报包的套接字。
| 构造方法摘要 | |
|---|---|
DatagramSocket() 构造数据报套接字并将其绑定到本地主机上任何可用的端口。 |
|
protected |
DatagramSocket(DatagramSocketImpl impl)创建带有指定 DatagramSocketImpl 的未绑定数据报套接字。 |
DatagramSocket(int port)创建数据报套接字并将其绑定到本地主机上的指定端口。 |
|
DatagramSocket(int port,创建数据报套接字，将其绑定到指定的本地地址。 |
|
DatagramSocket(SocketAddress bindaddr)创建数据报套接字，将其绑定到指定的本地套接字地址。 |
|
此类表示数据报包。
数据报包用来实现无连接包投递服务。每条报文仅根据该包中包含的信息从一台机器路由到另一台机器。从一台机器发送到另一台机器的多个包可能选择不同的路由，也可能按不同的顺序到达。不对包投递做出保证。
| 构造方法摘要 | |
|---|---|
DatagramPacket(byte[] buf, int length) 构造 DatagramPacket，用来接收长度为length 的数据包。 |
|
DatagramPacket(byte[] buf,构造数据报包，用来将长度为 length 的包发送到指定主机上的指定端口号。 |
|
DatagramPacket(byte[] buf, 构造 DatagramPacket，用来接收长度为 length的包，在缓冲区中指定了偏移量。 |
|
DatagramPacket(byte[] buf,构造数据报包，用来将长度为 length 偏移量为 offset的包发送到指定主机上的指定端口号。 |
|
DatagramPacket(byte[] buf,构造数据报包，用来将长度为 length 偏移量为 offset的包发送到指定主机上的指定端口号。 |
|
DatagramPacket(byte[] buf,构造数据报包，用来将长度为 length的包发送到指定主机上的指定端口号。 |
|
5.2、UDP发送端
/*
发送端
1.创建UDP服务，通过DatagramSocekt，
2.创建发送的数据，并封装为数据包，DatagramPacket
3.发送send
4.关闭DatagramSocekt资源
*/
import java.net.*;
class UdpSend
{
public static void main(String[] args) throws Exception
{
//1.创建UDP服务，通过DatagramSocekt，
DatagramSocket ds=new DatagramSocket();
//2.创建发送的数据，并封装为数据包，DatagramPacket
String say="udp数据!";
byte [] buf = say.getBytes();
InetAddress ia=InetAddress.getByName("localhost");
int port =9898;
DatagramPacket dp=new DatagramPacket(buf,buf.length,ia,port);
//3.发送send
ds.send(dp);
//4.关闭DatagramSocekt资源
ds.close();
}
}
5.3、UDP接收端服务端
/*
接收端，服务端
1.创建UDP，Socket服务对象，DatagramSocket，设置商品
2.创建数据服包对象DatagramPacket包，接收数据报包
3.接收receive,到数据包在
4.通过数据报包，获取其中的数据如IP，数据和端口
5.解析数据转化为字符串,并打印
6.关闭资源
*/
import java.net.*;
class UdpReceive
{
public static void main(String[] args) throws Exception
{
//1.创建UDP，Socket服务对象，DatagramSocket，设置端口
DatagramSocket ds=new DatagramSocket(9898);
//2.创建数据服包对象DatagramPacket包，接收数据报包
//接收内容的字节数据
byte[] buf=new byte[1024];
DatagramPacket dp=new DatagramPacket(buf,buf.length);
//3.接收receive,到数据包在
ds.receive(dp);
//4.通过数据报包，获取其中的数据如IP，数据和端口
//IPD
String ip=dp.getAddress().getHostAddress();
//主机名
String hostname=dp.getAddress().getHostName();
//数据
String data=new String(dp.getData(),0,dp.getLength());
//5.解析数据转化为字符串,并打印
System.out.println(ip+":"+hostname+":"+data);
//6.关闭资源
ds.close();
}
}
5.4、键盘录入
/*
发送端
键盘录入
*/
import java.net.*;
import java.io.*;
class UdpSend2
{
public static void main(String[] args) throws Exception
{
//建立UDPSocket服务对象DatagramSocket
DatagramSocket ds=new DatagramSocket();
//主机对象
InetAddress ia=InetAddress.getByName("localhost");
int port=10001;
//录入数据,字符流，键盘录入
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
String line=null;
while((line=br.readLine())!=null)
{
if("886".equals(line))
break;
//封装为数据报包
byte [] buf=line.getBytes();
DatagramPacket dp=new DatagramPacket(buf,buf.length,ia,port);
//发送
ds.send(dp);
}
//关闭
br.close();
ds.close();
}
}
/*
接收端一直开启
*/
import java.net.*;
class UdpRece2
{
public static void main(String[] args) throws Exception
{
//建立DatagramSocket对象服务，并指定端口
DatagramSocket ds=new DatagramSocket(10001);
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);
}
}
}
5.5、示例
package com.pb.demo1; /*
简单聊天工具
*/
//发送端
import java.net.*;
import java.io.*;
class Send implements Runnable
{
private DatagramSocket ds; public Send( DatagramSocket ds)
{
this.ds=ds;
}
//线程重写方法
public void run()
{
try
{//接收键盘录入
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
InetAddress ia=InetAddress.getByName("192.168.2.255");
int port =10002;
String line=null;
while ((line=br.readLine())!=null)
{
if("886".equals(line))
break;
//封装数据
byte[] buf=line.getBytes();
DatagramPacket dp=new DatagramPacket(buf,buf.length,ia,port);
//发送
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("接收失败!");
}
} }
class ChatDemo
{
public static void main(String[] args) throws Exception
{
//发送
DatagramSocket send=new DatagramSocket();
//接收
DatagramSocket rece=new DatagramSocket(10002);
new Thread(new Send(send)).start();
new Thread(new Rece(rece)).start();
}
}
六、TCP
5.1、概述
5.2、TCP传输一次-简单使用
/*
TCP传输
1.TCP分客户端与服务端
2.客户端：Socket
服务端：ServerSocket */
/*
客户端：
Socket()
通过系统默认类型的 SocketImpl 创建未连接套接字
Socket(InetAddress address, int port)
创建一个流套接字并将其连接到指定 IP 地址的指定端口号。
Socket(InetAddress host, int port, boolean stream)
已过时。 Use DatagramSocket instead for UDP transport.
Socket(InetAddress address, int port, InetAddress localAddr, int localPort)
创建一个套接字并将其连接到指定远程地址上的指定远程端口。
Socket(Proxy proxy)
创建一个未连接的套接字并指定代理类型（如果有），该代理不管其他设置如何都应被使用。
protected Socket(SocketImpl impl)
使用用户指定的 SocketImpl 创建一个未连接 Socket。
Socket(String host, int port)
创建一个流套接字并将其连接到指定主机上的指定端口号。
Socket(String host, int port, boolean stream)
已过时。 使用 DatagramSocket 取代 UDP 传输。
Socket(String host, int port, InetAddress localAddr, int localPort)
创建一个套接字并将其连接到指定远程主机上的指定远程端口。
通过构造方法可以发现:
Socket对象，在建立时，就可以去连接指定主机
因为Tcp是面向连接的，所以在连接成功，形成通路后，
在该通道进行数据的传输
步骤：
1.创建客户端Socket服务，指定主机与端口
2.获取Socket流，socket.getXXX(InputStream或者OutputStream,并封装为字符流或者字节流
3.发送数据
4.关闭socket服务
*/
import java.net.*;
import java.io.*;
class TcpClient
{
public static void main(String[] args) throws Exception
{
//1.创建客户端Socket服务，指定主机与端口
Socket s=new Socket("localhost",10003);
//2.获取Socket流，socket.getXXX(InputStream或者OutputStream,并封装为字符流或者字节流
OutputStream os=s.getOutputStream();
//3.发送数据
String say="Tcp客户端发送，测试数据!";
os.write(say.getBytes());
//4.关闭socket服务
s.close();
}
}
/*
步骤：
1.创建服务端Socket服务，指定端口
2.监听accept,并获取Socket流，没有连接，这个方法是阻塞工的
3.获取对应客户端对象的socket.getXXX(InputStream或者OutputStream,并封装为字符流或者字节流
4.接收数据InptuStream或者发送OutputStream
5.打印
6.(可选一般不关闭)关闭socket服务
*/
class TcpServer
{
public static void main(String[] args) throws Exception
{
//1.创建服务端Socket服务，指定端口
ServerSocket ss=new ServerSocket(10003);
//2.监听accept,并获取Socket流，没有连接，这个方法是阻塞工的
Socket s=ss.accept();
//3.获取对应客户端对象的socket.getXXX(InputStream或者OutputStream,并封装为字符流或者字节流
//4.接收数据InptuStream或者发送OutputStream
InputStream is=s.getInputStream(); //获取客户端IP
String ip=s.getInetAddress().getHostAddress(); //设置缓冲区
byte[] buf=new byte[1024];
//把数据读取到缓冲区中
int len=is.read(buf);
//转换为字符串
String data=new String(buf,0,len);
//5.打印
System.out.println(ip+"........");
System.out.println(data); //6.(可选一般不关闭)关闭socket服务
s.close();
ss.close(); }
}
5.3、SocetKet接收与返回
/*
客户端给服务端发送数据
服务端收到后给客户端反馈信息
客户接收反馈数据
*/ /*步骤：
1.创建客户端Socket服务，指定主机与端口
2.获取Socket流，socket.getXXX(InputStream或者OutputStream,并封装为字符流或者字节流
3.发送数据
4.关闭socket服务
*/
import java.net.*;
import java.io.*;
class TcpClient2
{
public static void main(String[] args) throws Exception
{
//1.建立Socekt服务并指定端口
Socket s=new Socket("localhost",10004);
//2.信息
String sendInfo="客户端发送的信息!";
//3.获取输出流写到服务端
OutputStream os=s.getOutputStream();
os.write(sendInfo.getBytes());
//4.获取输入信息接收服务端信息
InputStream is=s.getInputStream();
byte [] buf=new byte[1024];
int len=is.read(buf);
String rev=new String(buf,0,len);
System.out.println("服务端反馈的信息："+rev);
s.close();
}
}
/*
步骤：
1.创建服务端Socket服务，指定端口
2.监听accept,并获取Socket流，没有连接，这个方法是阻塞工的
3.获取对应客户端对象的socket.getXXX(InputStream或者OutputStream,并封装为字符流或者字节流
4.接收数据InptuStream或者发送OutputStream
5.打印
6.(可选一般不关闭)关闭socket服务
*/
class TcpServer2
{
public static void main(String[] args) throws Exception
{
//建立服务端ServerSocket数据
ServerSocket ss=new ServerSocket(10004);
//获取客户端对象accept,
Socket s=ss.accept();
//获取输入流对象接收客户端信息
InputStream is=s.getInputStream();
//建立缓冲区
byte [] buf=new byte[1024];
int len=is.read(buf);
String clientInfo=new String(buf,0,len);
//获取IP
String ip=s.getInetAddress().getHostAddress();
System.out.println(ip+"....."+clientInfo);
//返回给客户端的信息
String rel="已经收到了";
//获取输出流对象
OutputStream os=s.getOutputStream();
os.write(rel.getBytes());
//关闭 可选
s.close();
ss.close();
}
}
5.4、综合
/*
建立一个转换服务器
客户端输入内容到服务器，服务把内容转成大写再返回给客户端
客户端可以 不断的进行文本输入，
当客户端输入over时结束
*/
/*
客户端
操作设备上的数据，可以使用IO技术
并按照IO的操作规律来完成
源：键盘录入
目的：网络设置，网络输出
而且操作的是文本数据，可以选择
字符流与字符缓冲流
*/
import java.io.*;
import java.net.*;
class TcpClient3
{
public static void main(String[] args) throws Exception
{
//建立服务
Socket s=new Socket("localhost",10005);
//获取键盘录入
BufferedReader br=
new BufferedReader(new InputStreamReader(System.in));
//目的发送给服务端
//BufferedWriter bwOut=new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
//打印流，可以接收字符流、缓冲流、字节流，第二个参数true表示自动刷新
PrintWriter out=new PrintWriter(s.getOutputStream(),true);
//获取服务端返回的信息
BufferedReader brIn=
new BufferedReader(new InputStreamReader(s.getInputStream()));
//键盘录入数据
String line=null;
//服务端返回数据
String recLine=null;
//接收键盘录入
while((line=br.readLine())!=null)
{
if("over".equals(line))
break;
out.println(line);
/*
//将信息写入服务端
bwOut.write(line);
//增加换行
bwOut.newLine();
//刷新缓冲区
bwOut.flush();
*/ //获取取服务端返回的大写数据
recLine=brIn.readLine();
System.out.println("服务器返回信息："+recLine);
}
//结束，关资源
s.close(); }
}
/*
服务器
*/
class TcpServer3
{
public static void main(String[] args) throws Exception
{
//建立服务端对象
ServerSocket ss=new ServerSocket(10005);
//获取客户端Socket对象
Socket s=ss.accept();
String ip=s.getInetAddress().getHostAddress();
System.out.println(ip+"....");
//获取客户端流对象
BufferedReader brIn=
new BufferedReader(new InputStreamReader(s.getInputStream())); //BufferedWriter bwOut=new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
//打印流，可以接收字符流也可以接收字节流，加true自动刷新
PrintWriter out=new PrintWriter(s.getOutputStream(),true);
String line=null;
while((line=brIn.readLine())!=null)
{
System.out.println("客户端说："+line);
out.println(line.toUpperCase());
/*
//转换为大写返回客户端
bwOut.write(line.toUpperCase());
//增加换行
bwOut.newLine();
//刷新缓冲区
bwOut.flush();
*/
}
s.close();
ss.close();
}
}
/*
问题：
客户端和服务端都在莫名的等待
因为客户端和服务端都在阻塞的方法，
这些方法没有读到结束标记，那么就一直等待
而导致两端，都在等待
*/
5.5、示例-TCP文件复制
/*
上传一个文件到服务器
*/
import java.net.*;
import java.io.*;
/*
客户端
*/
class UploadClient
{
public static void main(String[] args) throws Exception
{
//建立客户端服务
Socket s=new Socket("localhost",10009);
//上传文件
File file=new File("d:\\gm.mp3");
//获取文件名
String filename=file.getName();
//建立基本数据流将文件名发送过去
PrintWriter pw=new PrintWriter(s.getOutputStream(),true);
//发送
pw.println(filename);
//建立输入流
FileInputStream fis=new FileInputStream(file);
BufferedInputStream bis=new BufferedInputStream(fis);
//建立流输出
BufferedOutputStream bos=new BufferedOutputStream(s.getOutputStream());
//建立字符缓冲，接收服务端返回的提示信息
BufferedReader br=new BufferedReader(new InputStreamReader(s.getInputStream()));
int len=0;
while((len=bis.read())!=-1)
{
bos.write(len);
bos.flush();
}
//关闭输出流，增加结束标记
s.shutdownOutput();
String str=br.readLine();
System.out.println(str);
bis.close();
fis.close();
s.close(); }
}
/*
服务端
*/
class UploadServer
{
public static void main(String[] args) throws Exception
{
//建立服务
ServerSocket ss=new ServerSocket(10009);
//获取客户端对象
Socket s=ss.accept();
//获取客户端 发送的文件名
BufferedReader br=new BufferedReader(new InputStreamReader(s.getInputStream()));
String filename=br.readLine();
System.out.println("文件名："+filename);
//文件输读流
BufferedInputStream bis=new BufferedInputStream(s.getInputStream());
//文件输出流
File f=new File("f:\\",filename);
BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream(f));
//输出提示信息
PrintWriter pw=new PrintWriter(s.getOutputStream(),true);
int len=0;
while((len=bis.read())!=-1)
{
bos.write(len);
bos.flush();
}
pw.println("上传成功");
bos.close();
s.close();
ss.close(); }
}
JAVA基础学习day24--Socket基础一UDP与TCP的基本使用的更多相关文章
- Python学习 ：socket基础
socket基础 什么是socket? - socket为接口通道,内部封装了IP地址.端口.协议等信息:我们可以看作是以前的通过电话机拨号上网的年代,socket即为电话线 socket通信流程 我 ...
- Java最新学习线路（基础，源码，项目，实战）
如需获取以下学习资源请关注公众号:Java编程指南 我们为自学者编程的或初学java的小伙伴们准备了一整套完整的学习资源和文章,还有我自己在自学路上的一些总结和学习线路,希望能帮到小伙伴们,如果有什么 ...
- <java基础学习>02JAVA的基础组成
Java的基础组成 1 关键字 (被赋予了特殊含义的单词) 2 标识符 3 注释 4 常量和变量 5 运算符 6 语句 7 函数 8 数组 关键字 class Demo{ public static ...
- java基础学习05(面向对象基础01)
面向对象基础01 1.理解面向对象的概念 2.掌握类与对象的概念3.掌握类的封装性4.掌握类构造方法的使用 实现的目标 1.类与对象的关系.定义.使用 2.对象的创建格式,可以创建多个对象3.对象的内 ...
- java安全学习-环境准备/基础知识
补java的坑,开始! 1.Intellij一些快捷键 intell常用快捷键: ctrl+n 快速查找定位类的位置 ctrl+q 快速查看某个类的文档信息 shift + F6 快速类.变量重命名 ...
- Java开发学习(三)----Bean基础配置及其作用范围
一.bean基础配置 对于bean的基础配置如下 <bean id="" class=""/> 其中,bean标签的功能.使用方式以及id和clas ...
- java基础学习05(面向对象基础02)
面向对象基础02 实现的目标 1.String类的使用2.掌握this关键字的使用3.掌握static关键字的使用4.了解内部类 String类 实例化String对象一个字符串就是一个String类 ...
- java基础学习05(面向对象基础01--类实例分析)
面向对象基础01(类实例分析) 实现的目标 1.如何分析一个类(类的基本分析思路) 分析的思路 1.根据要求写出类所包含的属性2.所有的属性都必须进行封装(private)3.封装之后的属性通过set ...
- JAVA多线程基础学习一：基础知识
我们知道多线程是Java编程中重要的一块内容,也是面试重点覆盖区域,所以学好多线程对我们来说极其重要,下面跟我一起开启本次的学习之旅吧. 一.线程基本概念 1 线程:进程中负责程序执行的执行单元(执行 ...
- Java基础学习笔记(一) - 基础语法
1.Java程序开发过程 编译: 是指将我们编写的Java源文件翻译成JVM认识的class文件,javac编译器会检查我们所写的程序是否有错误,有错误就会提示出来,如果没有错误就会编译成功. 运行: ...
随机推荐
- Java知多少（109）数据库更新
数据库更新操作包括数据表创建.删除.以及数据表记录的增加.删除.修改等操作.如果利用数据 SQL命令实现,则利用Statement对旬的executeUpdate()方法,执行SQL的update语句 ...
- 重写js alert
Window.prototype.alert = function(){ //创建一个大盒子 var box = document.createElement("div"); // ...
- 【目录】C#操作Excel组件Spire.XLS系列文章目录
本博客所有文章分类的总目录链接:http://www.cnblogs.com/asxinyu/p/4288836.html 1.C#操作Excel组件Spire.XLS文章目录 1.[原创].NET读 ...
- C++的最佳特性（译）
最近看到了很多优秀的文章,包括<Why mobile web apps are slow>,实在忍不住翻译出来跟大家分享.这篇文章通过大量的实验和参考文献向我们说明移动应用开发所遇到的问题 ...
- 【转载】shell中 dd 命令
转载自:http://blog.chinaunix.net/uid-24958038-id-3416169.html dd if=/dev/zero of=的含义是什么? 一.dd命令的解释 dd:用 ...
- 【转载】C/C++ 函数指针 总结
转载自:http://blog.csdn.net/shihui512/article/details/9787125 什么是函数指针函数指针的声明函数指针的赋值函数指针的使用将函数作为其他函数的参数在 ...
- [linux]重拾linux
起因 因为想重拾起linux,同时需要用docker起几个镜像,用来学习网络知识.本来想直接去阿里云上买,后来一想自己机器上,起一个linux是个不错的选择,毕竟不花钱! 还可以用来做本地测试,学习使 ...
- UPW学习资料整理 .NET C# 转
开发工具下载https://www.visualstudio.com/?Wt.mc_id=DX_MVP5000319 Windows 10 UWP开发视频1http://blogs.windows.c ...
- 轻量级.NET ORM、高性能.NET ORM 之 SqlSugar 开源ORM - ASP.NET
3.0最新API: http://www.cnblogs.com/sunkaixuan/p/5911334.html 1.前言/Preface SqlSugar从去年到现在已经一年了,版本从1.0升到 ...
- mysql模拟rownum的一个方法
mysql> select * from t2; +----+---------------------+ | id | d | +----+---------------------+ :: ...