黑马程序员_网络编程
------- android培训、java培训、期待与您交流！ ----------
UDP
将数据及源和目的封装成数据包，不需要建立连接；
每个数据包的大小限制在64k内；
因无连接，是不可靠协议；
不需要建立连接，速度快。
TCP
建立连接，形成传输数据的通道；
在连接中进行大数据量传输；
通过三次握手完成连接，是可靠协议；
必须建立连接，效率会稍低。
UDP的socket如何建立？
需求：通过UDP传输方式，将一段文字数据发送出去。
定义一个udp的发送端。
思路：
1、建立udpsocket服务；
2、提供数据，并将数据封装到数据包中；
3、通过socket服务的发送功能将数据包发出去；
4、关闭资源。
import java.net.*;
class xxx
{
publicstatic void main(String[] args) throws Exception
{
//1、创建udp服务，通过DatagramSocket对象;
DatagramSocketds=new DatagramSocket(8888);
//2、确定数据，并封装成数据包DatagramPacket(byte[],int length,InetAddressaddress,int port);
byte[]data=”udp ge men lei le”.getBytes();
DatagramPacketdp=new DatagramPacket(buf,buf.length,InetAddress.getByName(“192.168.9.34”),10000);
//3、通过socket服务，将已有的数据包发送出去，通过send方法
ds.send(dp);
//4、关闭资源
ds.close();
}
}udp接收端
需求：定义一个应用程序，用于接收udp协议传输的协议并处理。
1、定义udpsocket服务。通常会监听一个端口。其实就是给这个接收网络应用程序定义数字标识。方便于明确哪些数据过来该程序可以处理；
2、定义一个数据包，要存储接收到的字节数据，因为数据包对象中有更多功能可以提取字节数据中的不同数据信息；
3、通过socket服务的receive方法将收到的数据存入已定义好的数据包中；
4、通过数据包对象的特有功能，将这些不同的数据取出，打印在控制台；
5、关闭资源。
class UdpRece
{
publicstatic void main(String[] args)
{
//1、创建udp socket，建立断点
DatagramSocket ds=new DatagramSocket(10000);
//2、定义数据包，用于存储数据
byte[] buf=new byte[1024];
DategramPacket dp=new DategramPacket(buf,buf.length);
//3、通过服务的receive方法将收到的数据存入数据包中
ds.recive(dp);//阻塞式方法
//4、通过数据包的方法获取其中的数据
String ip=dp.getAddress().getHostAddress();//获取对象再拿对象的getHostAddress方法
String data=new String(dp.getDate(),0,dp.getLength);
int port=dp.getPort();
System.out.println(ip+”::”+data+”::”+port);
//5、关闭资源
ds.close();
}
}键盘输入发送
import java.net.*;
import java.io.*;//只要用的net包就会用的io包
class UdpSend2
{
publicstatic void main(String[] args)
{
DatagramSocket ds=new DatagramSocket();
BufferedReader bufr=new BufferedReader(newInputStreamReader(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.9.12”),10001);//255是广播地址
ds.send(dp);
}
ds.close();
}
}
class UdpRece2
{
publicstatic void main(String[] args)
{
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);
}
}
}编写一个聊天程序
有收数据的部分和发数据的部分，这两部分需要同时执行，需要用到多线程技术，一个线程控制收，一个线程控制发。
因为收和发是不一致的，所以要定义两个run方法，而且这两个方法要封装到不同的类中
import java.io.*;
import java.net.*;
class Send implements Runnable
{
privateDatagramSocket ds;
publicSend(DategramSocket ds)
{
this.ds=ds;
}
publicvoid run()
{
try
{
BufferedReader bufr=new BufferedReader(new InputStreamReader(System.in));
String line=null;
while((line=bufr.readLine())!=null)
{
if(“886”,equals(lien))
break;
byte[] buf=line.getBytes();
DatagramPacket dp=newDatagramPacket(buf,buf.length,InetAddress.getByName(“192.168.1.255”),10002);
ds.send(dp);
}
}
catch(Exception e)
{
throw new RuntimeException(“发送端失败”);
}
}
}
class Rece implements Runnable
{
privateDatagramSocket ds;
publicSend(DategramSocket ds)
{
this.ds=ds;
}
publicvoid run()
{
try
{
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
{
publicstatic void main(String[] args) throws Exception//监听端口容易出现socket异常
{
DatagramSocket sendSocket=new DatagramSocket();
DatagramSocket receSocket=new DatagramSocket(10002);
new Thread(new Send(sendSocket)).start();
new Thread(new Rece(receSocket)).start();
}
}演示tcp传输
1、tcp分客户端和服务端；
2、客户端对应的对象时Socket。服务端对应的对象时ServerSocket。
客户端：
通过查阅socket对象，发现该对象建立时，就可以去连接指定主机。
因为tcp是面向连接的。所以在建立socket服务时，就要有服务器端存在，并连接成功，形成通路后，在该通道进行数据的传输。
需求：给服务端发送一个文本数据。
import java.io.*;
import java.net.*;
class TcpClient
{
publicstatic void main(String[] args) throws Exception
{
//创建客户端的socket服务，指定目的主机和端口
Socket s=new Socket(“192.168.9.125”,10003);
// 为了发送数据，应该获取socket流中的输出流
OutputStream out=s.getOutputStream();
out.write(“tcp lai le”.getBytes());
s.close();
}
}需求：定义端点接收数据并打印在控制台上。
服务端：
1、建立服务端的socket服务。ServerSocket（），并监听一个端口；
2、获取连接过来的客户端对象。通过ServerSocket的accept方法，所以这个方法是阻塞式的，没有连接就会等；
3、客户端如果发过来数据，那么服务端要使用对应的客户端对象，并获取到该客户端对象的读取流来读发送过来的数据，并打印在控制台；
4、关闭服务端（可选）。
class TcpServer
{
publicstatic void main(String[] args)
{
//建立服务端socket服务，并监听一个端口
ServerSocket ss=new ServerSocket(10003);
//通过accept方法获取连接过来的客户端对象。
Socket s=ss.accept(_);
Sting ip=s.getInetAddress().getHostAddress();
System.out.println(ip+”....connected”);
//获取客户端发送过来的数据，那么要使用客户端对应的读取流对象的读取流来读取数据
InputStream in=s.getInputSteram();
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、关闭客户端资源。
class TcpClients
{
publicstatic void main(String[] args) throws Exception
{
Socket s=new Socket(“192.168.1.254”,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();
}
}
clss TcpServer2
{
publicstatic 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=a.getInputStream();
byte[] buf=new byte[1024];
byte[] buf=in.read(buf);
System.out.println(new String(buf,0,len));
OutputStream out=s.getOutputStream();
out.write(“收到，你也好”.getBytes());
s.close();
ss.close();
}
}需求：建立一个文本转换服务器。
客户端给服务端发送文本，服务端会将文本转成大写在返回给客户端，而且客户端可以不断的进行文本转换，当客户端输入over时，转换就结束。
分析：
客户端：
既然是操作设备上的数据，那么就可以使用io技术，并按照io的操作规律来思考。
源：键盘录入
目的：网络输出流（网络设备）
操作的是文本数据，可以选择字符流。
步骤：
1、建立服务；
2、获取键盘录入；
3、将数据发给服务端；
4、获取服务端返回的大写数据；
5、结束，关资源。
都是文本数据，可以使用字符流进行操作，同时提高效率，加缓冲。
import java.io.*;
import java.net.*;
class TransClient
{
publicstatic void main(String[] args) throws Exception
{
Sockets=new Socket(“192.168.9.254”,10005);
//定义读取键盘数据的流对象
BufferedReaderbufr=new BufferedReader(new InputStreamReader(System.in));
//定义目的。将数据写入到socket输出流，发给服务器
BufferedWriterbufOut=new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
//定义一个socket读取流，读取服务端返回的大写信息
BufferedReaderbufIn=
new BufferedReader(new InputStream(s.getInputStream()));
Stringline=null;
while((line=bufr.readLine())!=null)
{
bufOut.write(line)
if(“over”.equals(line))
break;
bufOut.write(line);
bufOut.newLine();
bufOut.flush();
String str=bufIn.readLine();
System.out.println(“Server” +str);
}
bufr.close();
s.close();
}
}TCP上传图片
客户端
1、服务端点；
2、读取客户端已有的图片数据；
3、通过socket输出流将数据发给服务端；
4、读取服务端反馈信息；
5、关闭。
import java.io.*;
import java.net.*;
class PicClient
{
publicstatic void main(Strings[] args)
{
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*5)
{
System.out.println(“文件过大”);
return;
}
Socket s=new Socket(“192.168.9.254”,10007);
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,num));
fis.close();
s.close();
}
}服务端
这个服务端有个局限性，当A客户端连接上以后，被服务端获取到。服务端执行具体流程。这是B客户端连接，只能等待。因为服务端还没有处理完A客户端的请求，还有循环回来执行下次accept方法。所以暂时获取不到B客户端对象。
那么为了可以让多个客户端同时并发访问服务器。那么服务端最好就是每个客户端封装一个单独的线程，这样，就可以同时处理多个客户端请求。
如果定义线程呢？
只要明确了每一个客户端要在服务端执行的代码即可，将该代码存入run方法中。
class picThread implements Runnable
{
privateSocket s;
PicThread(Sockets)
{
this.s=s;
}
publicvoid run()
{
int count=1;
String ip=s.getInetAddreess().getHostAddress();
try
{
System.out.println(ip+”(”+(count++)+”)”+”...connected”);
InputStream in=s.getInputStream();
File file=new File(ip+”(”+(count)+”)”+”.jpg”);
while(file.exists())
File file=new File(ip+”(”+(count++)+”)”+”.jpg”);
FileOutputStream fos=new FileOutputStream(file);
byte[] buf=new byte[1024];
in 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+”上传失败”);
}
}
}
class PicServer
{
publicstatic void main(string[] args) throws Exception
{
ServerSocket ss=new ServerSocket(10000=7);
while(true)
{
Socket s=ss.accept();
new Thread(new PicThread(s)).start();
}
}
}客户端通过键盘录入用户名。
服务端对这个用户名进行校验。
如果该用户存在，在服务器显示xxx，已登录。
并在客户端显示xxx，欢迎光临。
如果该用户存在，在服务端显示xxx，尝试登陆。
并在客户端显示xxx，该用户不存在。
最多就登陆三次。
user.txt为数据库文件，内容如下：
zhangsan
lisi
wangwu
sunba
import java.io.*;
import java.net.*;
class LoginClient
{
publicstatic void main(String() args) throws Exception
{
Socket s=new Socket(“192.168.1.254”,10008);
BufferedReader bufr=new BufferedReader(newInputStreamReader(System.in));
PrintWriter out=new PrintWriter(s.getOutputStream(),true);
BufferedReader bufIn=new BufferedReader(newInputStreamReader(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
{
privateSocket s;
UserThread(Sockets)
{
this.s=s;
}
publicvoid run()
{
String ip=s.getInetAddress().getHostAddress();
System.out.println(ip+”...connected”);
try
{
for(int x=0;x<3;x++)
{
BufferedReader bufIn=new BufferedReader (newInputStreamReader(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.readLien())!=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+”，用户名不存在”);
}
}
s.close();
}
catch(Exception e)
{
throw new RuntimeException(ip+“校验失败”);
}
}
}
class LoginServer
{
publicstatic void main(String() args)
{
ServerSocket ss=new ServerSocket(10008);
while(true)
{
Socket s=ss.accept();
new Thread(new UserThread(s)).start();
}
}
}SocketAddress下面有InetSocketAddress；
InetAddress代表IP地址；
InetsocketAddress代表IP地址加端口；
ServerSocket设置最大连接个数，socket中的队列长度。