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编译器会检查我们所写的程序是否有错误,有错误就会提示出来,如果没有错误就会编译成功. 运行: ...
随机推荐
- log4net各种Filter使用
log4net里面的filter类常用的为: 1.DenyAllFilter 拒绝所用的日志输出 <filter type="log4net.Filter.LevelMatchFilt ...
- MySQL批量SQL插入性能优化
对于一些数据量较大的系统,数据库面临的问题除了查询效率低下,还有就是数据入库时间长.特别像报表系统,每天花费在数据导入上的时间可能会长达几个小时或十几个小时之久.因此,优化数据库插入性能是很有意义的. ...
- linux VM复制多个IP配置出错的处理
device eth0 does not seem to be present, delaying initialization (2012-09-13 21:16:38) 转载▼ 标签: 杂谈 ...
- Hadoop入门进阶课程7--Pig介绍、安装与应用案例
本文版权归作者和博客园共有,欢迎转载,但未经作者同意必须保留此段声明,且在文章页面明显位置给出原文连接,博主为石山园,博客地址为 http://www.cnblogs.com/shishanyuan ...
- Hadoop第13周练习—HBase作业
1 :举例子说明HBase相对简单 1.1 1.2 回答 2 :设计HBase存储站内短信 2.1 2.2 回答 书面作业1:举例子说明HBase相对简单 请举出一例子,使 ...
- [git]用pelican搞一个自己的blog(已完成）
pelican Pelican Static Site Generator, Powered by Python:Pelican是python语言写的静态网站生成器.因为我一直打算用github pa ...
- 判断windows操作系统平台
判断当前Windows系统是win2000,winXP,winVista,win2003,win7... private static IntPtr GetSysTrayWnd() { IntPtr ...
- DotNetCore跨平台~性能测试~可以放心使用了
使用dotnetCore发布站点后,它的处理请求能力不逊色IIS等大型服务的能力,号称每秒能处理115万个请求,太牛X了也. 先看看它支持的数据库 以下主流数据库都是为支持的 Microsoft SQ ...
- BI之SSAS完整实战教程2 -- 开发环境介绍及多维数据集数据源准备
上一篇我们已经完成所有的准备工作,现在我们就开始动手,通过接下来的三篇文章创建第一个多维数据集. 传统的维度和多维数据集设计方法主要是基于现有的单源数据集. 在现实世界中,当开发商业智能应用程序时,很 ...
- jQuery: jquery.json.js
http://api.jquery.com/jQuery.parseJSON/ http://www.json.org/json-zh.html http://fineui.codeplex.com/ ...