UDP
是面向无连接，明确了对方的端口，无论在不在网上，只管传输，不在就会丢失数据。只求速度，应用于网络视频会议和聊天等应用程序中。
协议特点：
a、面向无连接，即将数据及源和目的封装成数据包中，不建立链接的发送
b、每个数据包的大小限制在64K之内
c、因无连接，是不可靠的协议
d、不建立连接，速度快。
TCP
是面向连接的，必须连接成功才能传输数据，应用于下载等程序上
协议特点：
a、面向连接，在建立连接后，形成传输数据的通道
b、在连接中进行大数据量的传输
c、通过三次握手完成连接，是可靠的协议
d、必须建立连接，效率稍慢
三次握手：第一次本方发送请求，第二次对方确认连接，第三次本方再次确认连接成功。
通信的步骤：
1）找到IP地址
2）数据要发送到对象指定应用程序，为标识这些应用程序，所以给这些网络应用程序都用数字标识，为方便称呼这个数字，叫做端口，即逻辑端口。
3）定义通信规则，称之为协议。国际组织定义了通用协议，即TCP/IP。
注意：必须要有数字标识才能将数据发送到应用程序上。
/*
用键盘录入的方式，来发送数据
*/
import java.net.*;
import java.io.*;
//UDP 发送端
class UdpSend
{
public static void main(String[] args)throws Exception
{
//1、创建udp Socket服务
DatagramSocket ds=new DatagramSocket(9999);
//2、确定数据，从键盘录入，并把键盘录入的数据封装成数据包
DatagramPacket dp=null;
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
String line=null;
while((line=br.readLine())!=null)
{
byte[] buf=line.getBytes();
dp=new DatagramPacket(buf,buf.length,InetAddress.getByName("192.168.1.255"),10000);
//3、通过Socket服务，将已有的数据包发送出去
ds.send(dp);
if ("886".equals(line))
{
break;
}
}
//4、关闭资源
ds.close();
}
}
//UDP 接收端
class UdpReceive
{
public static void main(String[] args)throws Exception
{
//1、创建udp Socket服务
DatagramSocket ds=new DatagramSocket(10000);
//一直处于接收状态
while (true)
{
//2、定义数据包，用于存储数据
byte[] buf=new byte[1024];
DatagramPacket dp=new DatagramPacket(buf,buf.length);
//3、通过Socket服务，将数据接收并存储进数据包中
ds.receive(dp);
//4、通过数据包的方法获取其中的数据
String ip=dp.getAddress().getHostAddress();
String data=new String(dp.getData(),0,dp.getLength());
int port=dp.getPort();
System.out.println("IP:"+ip+"=="+data);
}
//5、关闭资源
//ds.close();
}
}
练习一、
/*
练习
需求：建立一个文本转换服务器
客户端给服务端发送文本，服务端会将文本转成大写再返回给客户端。
而且客户端可以不断的进行文本转换。当客户端输入over时，转换结束。
分析：
客户端：
既然是操作设备上的数据，那么就可以使用io技术，并按照io的操作规律来思考。
源：键盘录入
目的：网络设备，网络输出流。
而且操作的是文本数据。可以选择字符流。
步骤：
1、建立服务
2、获取键盘录入
3、将数据发给服务端
4、获取服务端返回的大写数据
5、结束，管资源。
都是文本数据，可以使用字符流进行操作，同时提高效率，加入缓冲。
此练习出现的问题：
现象：客户端和服务端都在莫名的等待。
原因：因为客户端和服务端都有阻塞式方法。这些方法没有读到结束标记。那么就一直等。而导致两端都在等待。
解决：需要用到刷新和换行的方式将写入和读取的数据从流中刷新到内存中
方式一：可用高效缓冲区类的newLine()换行作为结束标记，并用flush()进行刷新。
方式二：可用PrintWriter(s.getOutputStrean(),true)创建输出流对象，true作用是刷新，通过打印方法println()换行，“ln”表示换行。
*/
import java.io.*;
import java.net.*;
class TcpClient
{
public static void main(String[] args) throws Exception
{
//创建Socket服务
Socket s=new Socket("127.0.0.1",10000);
//定义读取键盘数据的流对象
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
//定义目的，将数据写入到Socket输出流。发给服务端
//BufferedWriter bwout=new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
PrintWriter pw=new PrintWriter(s.getOutputStream(),true);
//定义一个Socket读取流，读取服务端返回的大写信息。
BufferedReader brin=new BufferedReader(new InputStreamReader(s.getInputStream()));
String line=null;
while ((line=br.readLine())!=null)
{
if("over".equals(line))
break;
//bwout.write(line);//写入输出流
//bwout.newLine();//换行
//bwout.flush();//刷新
pw.println(line);//将数据写入流中
String data=brin.readLine();//读取返回的信息
System.out.println(data);
}
br.close();//关流
s.close();
}
}
/*
服务端：
源：Socket读取流
目的：Socket输出流
都是文本，装饰
*/
class TcpServer
{
public static void main(String[] args)throws Exception
{
//创建服务端的ServerSocket服务,并指定监听端口
ServerSocket ss =new ServerSocket(10000);
//获取客户端连接
Socket s=ss.accept();
//获取客户端ip
System.out.println(s.getInetAddress().getHostName()+" connected.......");
//读取Socket读取流中的数据
BufferedReader brin=new BufferedReader(new InputStreamReader(s.getInputStream()));
//将大写数据写入到Socket输出流，并发送给客户端。
//BufferedWriter bwout=new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
PrintWriter pw=new PrintWriter(s.getOutputStream(),true);
String line=null;
while ((line=brin.readLine())!=null)
{
System.out.println(line);
//bwout.write(line.toUpperCase());//将读到数据转换为大写后返回
//bwout.newLine();//换行
//bwout.flush();//刷新
pw.println(line.toUpperCase());//将读到数据转换为大写后返回
}
s.close();//关流
ss.close();关闭资源（可选）
}
}
TCP传输
1、TCP分客户端和服务端。客户端对应的对象是Socket，服务端对应的对象是ServerSocket。
2、方法：
1）创建客户端对象：
Socket()：创建空参数的客户端对象，一般用于服务端接收数据
Socket(String host,int port)，指定要接收的IP地址和端口号
2）创建服务端对象：ServerSocket(int port)：指定接收的客户端的端口
3）Socket accept()：监听并接受到此套接字的连接
4）void shutdownInput()：此套接字的输入流至于“流的末尾”
5）void shutdownOutput()：禁用此套接字的输出流
6）InputStream getInputStream()：返回此套接字的输入流，Socket对象调用
7）OutputStream getOutputStream()：返回套接字的输出流，Socket对象调用
3、基本思路
客户端：
1）客户端需要明确服务器的ip地址以及端口，这样才可以去试着建立连接，如果连接失败，会出现异常。
2）连接成功，说明客户端与服务端建立了通道，那么通过IO流就可以进行数据的传输，而Socket对象已经提供了输入流和输出流对象，通过getInputStream(),getOutputStream()获取即可。
3）与服务端通讯结束后，关闭Socket。
服务端：
1）服务端需要明确它要处理的数据是从哪个端口进入的。
2）当有客户端访问时，要明确是哪个客户端，可通过accept()获取已连接的客户端对象，并通过该对象与客户端通过IO流进行数据传输。
3）当该客户端访问结束，关闭该客户端。
4、步骤
客户端：
通过查阅Socket对象的API文档，发现在该对象在建立时，就可去连接指定主机，因为TCP是面向连接的，所以在建立Socket服务时，就要有服务端存在，并连接成功，形成通路后，再通过该通道进行数据的传输。
1）创建Socket服务，并指定要连接的主机端口。通路一建立，就会产生Socket流（包括输入流和输出流），通过方法获取
2）为了发送数据，应获取Socket中的输出流，如果要接收服务端的反馈信息，还需要获取Socket的输入流
3）通过输出流的write()方法将要发送的数据写入到流中
4）关闭Socket流资源
服务端：
服务器套接字等待请求通过网络传入。它基于该请求执行某些操作，然后可能向请求者返回结果。需监听一个端口。
1）建立服务端的Socket服务，并监听一个端口。通过ServerSocet带端口参数的构造函数
2）获取连接过来的客户对象，通过ServerSocket的accept()方法，此方法是阻塞式的，如果服务端没有连接到就会一直等待
3）客户端如果发过来数据，则服务端要使用对应的客户端对象，并获取到该客户端对象的读取流读取发过来的数据，并输出到指定目的地。
4）关闭服务端（可选）。一般服务端是常开的，因为在实际应用中，随时有客户端在请求连接和服务。但这里需要定时关闭客户端对象流，避免某一个客户端长时间占用服务器端。
/*
练习
需求：建立一个文本转换服务器
客户端给服务端发送文本，服务端会将文本转成大写再返回给客户端。
而且客户端可以不断的进行文本转换。当客户端输入over时，转换结束。
分析：
客户端：
既然是操作设备上的数据，那么就可以使用io技术，并按照io的操作规律来思考。
源：键盘录入
目的：网络设备，网络输出流。
而且操作的是文本数据。可以选择字符流。
步骤：
1、建立服务
2、获取键盘录入
3、将数据发给服务端
4、获取服务端返回的大写数据
5、结束，管资源。
都是文本数据，可以使用字符流进行操作，同时提高效率，加入缓冲。
此练习出现的问题：
现象：客户端和服务端都在莫名的等待。
原因：因为客户端和服务端都有阻塞式方法。这些方法没有读到结束标记。那么就一直等。而导致两端都在等待。
解决：需要用到刷新和换行的方式将写入和读取的数据从流中刷新到内存中
方式一：可用高效缓冲区类的newLine()换行作为结束标记，并用flush()进行刷新。
方式二：可用PrintWriter(s.getOutputStrean(),true)创建输出流对象，true作用是刷新，通过打印方法println()换行，“ln”表示换行。
*/
import java.io.*;
import java.net.*;
class TcpClient
{
public static void main(String[] args) throws Exception
{
//创建Socket服务
Socket s=new Socket("127.0.0.1",10000);
//定义读取键盘数据的流对象
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
//定义目的，将数据写入到Socket输出流。发给服务端
//BufferedWriter bwout=new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
PrintWriter pw=new PrintWriter(s.getOutputStream(),true);
//定义一个Socket读取流，读取服务端返回的大写信息。
BufferedReader brin=new BufferedReader(new InputStreamReader(s.getInputStream()));
String line=null;
while ((line=br.readLine())!=null)
{
if("over".equals(line))
break;
//bwout.write(line);//写入输出流
//bwout.newLine();//换行
//bwout.flush();//刷新
pw.println(line);//将数据写入流中
String data=brin.readLine();//读取返回的信息
System.out.println(data);
}
br.close();//关流
s.close();
}
}
/*
服务端：
源：Socket读取流
目的：Socket输出流
都是文本，装饰
*/
class TcpServer
{
public static void main(String[] args)throws Exception
{
//创建服务端的ServerSocket服务,并指定监听端口
ServerSocket ss =new ServerSocket(10000);
//获取客户端连接
Socket s=ss.accept();
//获取客户端ip
System.out.println(s.getInetAddress().getHostName()+" connected.......");
//读取Socket读取流中的数据
BufferedReader brin=new BufferedReader(new InputStreamReader(s.getInputStream()));
//将大写数据写入到Socket输出流，并发送给客户端。
//BufferedWriter bwout=new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
PrintWriter pw=new PrintWriter(s.getOutputStream(),true);
String line=null;
while ((line=brin.readLine())!=null)
{
System.out.println(line);
//bwout.write(line.toUpperCase());//将读到数据转换为大写后返回
//bwout.newLine();//换行
//bwout.flush();//刷新
pw.println(line.toUpperCase());//将读到数据转换为大写后返回
}
s.close();//关流
ss.close();关闭资源（可选）
}
}
用TCP客户端并发上传图片
1、一对一（单线程）上传的思路：
客户端
a、服务端点。
b、读取客户端已有的图片数据
c、通过Socket输出流将数据发给服务端
d、读取服务端反馈信息。
e、关闭
服务端
a、服务端服务，并监听窗口
b、获取客户端对象，并获取客户ip
c、读取客户端输入流数据
d、写入文件
e、用客户端输出流反馈信息
f、关流
2、单线程的服务端有个局限性。当A客户端连接上以后，被服务端获取到。服务端执行具体流程。这时B客户端连接，只能等待。因为服务端还没有处理完A客户端的请求。还没有循环回来执行下一次accept方法。所以，暂时获取不到B客户端对象。
那么为了可以让多个客户端同时并发访问服务端。服务端最好就是将每个客户端封装到一个单独的线程中，这样，就可以同时处理多个客户端请求。
如何定义线程呢？
只要明确了每一个客户端要在服务端执行的代码，将该代码存入run方法即可。
/*
需求：并发上传图片
*/
import java.io.*;
import java.net.*;
//客户端
class PicClient
{
public static void main(String[] args) throws Exception
{
//对传入的值进行判断
if (args.length!=1)
{
System.out.println("请指定一个图片文件！");
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*5)
{
System.out.println("你上传的文件过大,居心叵测！");
return;
}
//创建服务
Socket s=new Socket("localhost",10000);
//读取图片数据
FileInputStream fis=new FileInputStream(file);
//用Socket服务输出流写入数据
OutputStream out =s.getOutputStream();
BufferedReader in=new BufferedReader(new InputStreamReader(s.getInputStream()));
byte[] buf=new byte[1024];
int len=0;
while ((len=fis.read(buf))!=-1)
{
out.write(buf,0,len);
}
//结束标记，表示文件数据已经上传完了
s.shutdownOutput();
String info=in.readLine();//读取返回信息
System.out.println(info);
fis.close();//关流
s.close();
}
}
//服务端
class PicServer
{
public static void main(String[] args)throws Exception
{
//创建服务，监听端口
ServerSocket ss=new ServerSocket(10000);
while (true)
{
//获取客户端对象
Socket s=ss.accept();
//客户端执行线程
new Thread(new PicThread(s)).start();
}
//ss.close();
}
}
//利用多线程实现并发上传
class PicThread implements Runnable
{
private Socket s;
PicThread(Socket s)
{
this.s=s;
}
public void run()
{
int count=1;
//获取客户端ip
String ip=s.getInetAddress().getHostAddress();
try
{
System.out.println(ip+" connected.....");
//通过客户端的读取流读取数据
InputStream in=s.getInputStream();
//文件保存路径
File dir =new File("C:\\Users\\asus\\Desktop");
//文件名
File file=new File(dir,ip+".jpg");
//判断文件是否存在
while(file.exists())
{
file=new File(dir,ip+"("+(count++)+").jpg");
}
//将数据写入到指定文件中
FileOutputStream fos=new FileOutputStream(file);
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();
}
catch (Exception e)
{
throw new RuntimeException(ip+"图片上传失败");
}
}
}
URL和URLConnection
1、URL：
URI：范围更大，条形码也包含于此范围
URL：范围较小，即域名
方法：
1）构造函数：URL(String protocol,String host,int port,String file);//根据指定 protocol、host、port号和 file 创建 URL对象。
2）String getProtocol();//获取协议名称
3）String getHost();//获取主机名
4）int getPort();//获取端口号
5）String getFile();//获取URL文件名
6）String getPath();//获取此URL的路径部分
7）String getQuery();//获取此URL的查询部，客户端传输的特定信息
注：一般输入网址，是不带端口号的，此时可进行获取，通过获取网址返回的port，若port为-1，则分配一个默认的80端口，如
int port = getPort();
if(port == -1)
port = 80;
2、URLConnection
方法：
1）URLConnection openConnection();//用URL调用此方法，返回一个 URLConnection 对象，它表示到 URL 所引用的远程对象的连接。
2）InputStream getInputStream();//获取输入流
3）OutputStream getOutputStream();//获取输出流
小知识点
1、Socket类的构造函数中，有一个空参数的构造函数：
Socket()//通过系统默认类型的 SocketImpl创建未连接套接字对象
可以通过connect(SocketAddress endpoint)方法来连接服务器。而SocketAddress是一个抽象类，它的子类InetSocketAddress实现了IP套接字地址（IP地址+端口号）。所以就可以连接到服务器了。
2、ServerSocket对象中的构造函数：
ServerSocket(int port,int backlog)，其中的backlog表示队列的最大长度，即最多连入客户端的个数，即最大连接数。
3、在浏览器输入网址访问一台主机所做的操作：
如输入http://61.135.169.125，可以直接连接此ip的主机，而我们一般是输入主机名：http:/www.baidu.ocm（百度主机对应的ip地址就是：61.135.169.125），那么此时浏览器做了神马操作呢？
也就是说如何通过主机名获取IP地址，从而连接到这台主机呢？这就需要将主机名翻译成IP地址，即域名解析：DNS
在进行访问的时候，会先在本地的hosts文件（c:\windows\system32\drivers\ext\host）中找对应的映射。若有，则直接返回请求；若无，则到公网的映射列表即DNS中找对应的映射，找到后，将主机名对应的IP地址返回给本机，本机通过这个IP地址找到对应的服务器。
2671
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
