黑马程序员——Java基础---网络编程
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------
第一讲 概述
1、网络模型：OSI参考模型和TCP/IP参考模型。
网络参考模型：
一般来讲开发处于传输层和网际层，应用层为：FTTP和HTTP协议等。传输层：UDP和TCP等。网际层：IP。
通常用户操作的是应用层，而编程人员做的是传输层和网际层，用户在应用层操作的数据，经过逐层封包，最后到物理层发送到另一个模型，再进行逐层拆包。
图例：
2、网络通讯要素：IP地址、端口号、传输协议
1）IP地址：
a、网络中设备的标识。
b、不易记忆，可用主机名。
c、本地回环地址：127.0.0.1 主机名：localhost。
IP地址：java中对应InetAddress类，存在于java.net包中。
InetAddress类：
（一）无构造函数，可通过getLocalHost()获取InetAddress对象，此方法是静态的，返回本类对象。
InetAddress i = InetAddress.getLocalHost();
（二）方法：
1）static InetAddress getByName(String host);//获取指定主机的IP和地址名。
2）static InetAddress[] getAllByName(String host);//在给定主机名的情况下，根据系统上配置的名称服务返回其IP地址所组成的数组。返回对象不唯一时，用此方法。
3）String getHostAddress();//返回IP地址字符串文本格式，以IP地址为主。
4）String getHostName();//返回IP地址主机名。
（三）如何获取一台主机的IP地址对象
1）功能：返回InetAddress对象。
2）对于任意主机需要指定传入主机名的参数。
注意：如果IP地址和对应的主机名，这种映射关系没有在网络上，就不会解析成功，返回的还是指定的IP。
示例：
class IPDemo
{
public static void main(String[] args)
{
InetAdderss i = InetAddress.getLocalHost();
System.out.println(i.toString());
String address = i.getHostAddress();
String name = i.getHostName();
System.out.println("address:"+address+"name:"+name)
//获取指定主机名的IP信息
InetAddress ia = InetAddress.getByName("192.168.1.24");
String a = ia.getHostAddress();
String n = ia.getHostName();
System.out.println("address:"+a+"name"+n);
//获取指定主机名的IP信息
InetAddress[] sina = InteAddress.getAllByName(www.sina.com.cn);
for(InetAddress s : sina)
{
String sAddress = s.getHostAddress();
String sName = s.getHostName();
System.out.println("sinaIP:"+sAddress+"sinaName:"+sName);
}
}
}2）端口号：
a、用于标识进程的逻辑地址，不同进程的标识。
b、有效端口：0~65535，其中0~1024系统使用或保留端口。
3）传输协议：
a、通讯的规则。
b、常见协议：TCP，UDP。
UDP
是面向无连接的，明确了对方的端口，无论对方在不在只管传输，不在就丢失数据，只求速度，应用于网络视频会议聊天等应用程序中。
协议特点：
a、将数据及源和目的封装成数据包中，不需要建立连接。
b、每个数据报的大小在限制在64k内。
c、因无连接，是不可靠协议。
d、不需要建立连接，速度快。
TCP
是面向连接的，必须连接成功后才可以传输数据，应用于下载等程序。
协议特点：
a、建立连接，形成传输数据的通道。
b、在连接中进行大数据量传输。
c、通过三次握手完成连接，是可靠协议。
d、必须建立连接，效率会稍低。
三次握手：第一次本方发送请求，第二次对方确认连接，第三次本方确认连接成功。
3、通信的步骤：
1）找到IP地址
2）数据要发送到对象指定应用程序。为了标识这些应用程序，所以给这些网络应用程序都用数字进行标识，这个数字标识就叫做端口，也称逻辑端口。
3）定义通信规则，这个通讯规则称为协议。国际组织定义了通用协议TCP/IP。
第二讲 传输协议
一、Socket
1、形象的可称之为插座，是为网络服务提供的一种机制。
2、通信的两端都有Socket，才能建立服务。
3、网络通信其实就是Socket间的通信，数据在两个Socket间通过IO传输。
二、UDP传输
1、通过DatagramSocket,此类表示用来发送和接受数据包的套接字。
2、方法：
1）创建UdpSocket发送服务对象
DatagramSocket，不指定端口。DatagramSocket(int port)，指定端口。
2）发送：void send(DatagramPacket p)。
3）接受：void receive(DatagramPacket p)。
DatagramPacket：数据报包用来实现无连接包投递服务。每条报文仅根据该包中包含的信息从一台机器路由到另一台机器。只要带地址（InetAddress）都用于发送包的。
3、步骤：
1）发送数据：
a、建立udpsocket服务，
b、提供数据，并将数据封装到数据包中。
c、通过socket服务的发送功能，将数据包发出去。
d、关闭资源。
2）接收数据：
a、定义udpsocket服务。通常会监听一个端口。其实就是给这个接收网络应用程序定义数字标识。方便于明确哪些数据过来该应用程序可以处理。
b、定义一个数据包，因为要存储接收到的字节数据。因为数据包对象中有更多功能可以提取字节数据中的不同数据信息。
c、通过socket服务的receive方法将收到的数据存入已定义好的数据包中。
d、通过数据包对象的特有功能。将这些不同的数据取出。打印在控制台上。
e、关闭资源。
注意：
1、发送端和接收端是两个独立的运行程序。
2、在发送端，要在数据包对象中明确目的地IP和端口。
c、在接收端，要指定监听的端口。
示例：
/*
需求：通过udp传输方式，将一段文字数据发送出去。
*/
import java.net.*;
//定义一个udp发送端。
class UdpSend
{
public static void main(String[] args) throws Exception
{
//1，创建udp服务。通过DatagramSocket对象。
DatagramSocket ds = new DatagramSocket(8888);
//2，确定数据，并封装成数据包。
//DatagramPacket(byte[] buf, int length, InetAddress address, int port)
byte[] buf = "udp i come in ".getBytes();
DatagramPacket dp =
new DatagramPacket(buf,buf.length,InetAddress.getByName("192.168.1.254"),10000);
//3，通过socket服务，将已有的数据包发送出去。通过send方法。
ds.send(dp);
//4，关闭资源。
ds.close();
}
}
/*
需求：
定义一个应用程序，用于接收udp协议传输的数据并处理的。
*/
//定义udp的接收端。
class UdpRece
{
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，通过服务的receive方法将收到数据存入数据包中。
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+"::"+data+"::"+port);
}
//5，关闭资源
//ds.close();
}
}练习一
/*用键盘录入的方式来发送数据*/
import java.net.*;
import java.io.*;
//发送端
class UdpSend
{
public static void main(String[] args) throws Exception
{
//创建udp服务。通过DatagramSocket对象。
DatagramSocket ds = new DatagramSocket();
//确定数据，用键盘录入，并封装成包
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"),10001);
//通过socket服务，将已有的数据包发送出去。
ds.send(dp);
}
//关闭资源
ds.close();
}
}
//接收端
class UdpRece
{
public static void main(String[] args) throws Exception
{
//创建udp socket，建立端点
DatagramSocket ds = new DatagramSocket(10001);
//一直处于接收状态
while(true)
{
//定义数据包。用于存储数据
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());
System.out.println(ip+"::"+data);
}
}
}
练习二
/*
编写一个聊天程序。
有收数据的部分，和发数据的部分。
这两部分需要同时执行。
那就需要用到多线程技术。
一个线程控制收，一个线程控制发。
因为收和发动作是不一致的，所以要定义两个run方法。
而且这两个方法要封装到不同的类中。
*/
import java.io.*;
import java.net.*;
//udp发送线程
class Send implements Runnable
{
//定义socket服务引用
private DatagramSocket ds;
public Send(DatagramSocket ds)
{
this.ds = ds;
}
//复写run方法
public void run()
{
try
{
//确定数据，用键盘录入，并封装成包
BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
String line = null;
while((line=bufr.readLine())!=null)
{
byte[] buf = line.getBytes();
DatagramPacket dp =
new DatagramPacket(buf,buf.length,InetAddress.getByName("192.168.1.255"),10002);
//通过socket服务，将已有的数据包发送出去
ds.send(dp);
if("886".equals(line))
break;
}
//关闭资源
ds.close();
}
catch (Exception e)
{
throw new RuntimeException("发送端失败");
}
}
}
//udp接收端线程
class Rece implements Runnable
{
//定义socket服务引用
private DatagramSocket ds;
public Rece(DatagramSocket ds)
{
this.ds = ds;
}
//复写run方法
public void run()
{
try
{ //一直处于接收状态
while(true)
{
//定义数据包。用于存储数据
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());
if("886".equals(data))
{
System.out.println(ip+"....离开聊天室");
break;
}
System.out.println(ip+":"+data);
}
//ds.close();关闭资源
}
catch (Exception e)
{
throw new RuntimeException("接收端失败");
}
}
}
class ChatDemo
{
public static void main(String[] args) throws Exception
{
DatagramSocket sendSocket = new DatagramSocket();
DatagramSocket receSocket = new DatagramSocket(10002);
new Thread(new Send(sendSocket)).start();
new Thread(new Rece(receSocket)).start();
}
}三、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()：返回此套接字的输入流。
7）OutputStream getOutputStream()：返回此套接字的输出流。
3、基本思路
客户端：
1）客户端需要明确服务器的ip地址以及端口，这样才可以去试着建立连接，如果连接失败，会出现异常。
2）连接成功，说明客户端与服务端建立了通道，那么通过IO流就可以进行数据的传输，而Socket对象已经提供了输入流和输出流对象，通过getInputStream()和getOutputStream()获取即可。
3）与服务端通讯结束后，关闭Socket。
服务端：
1）服务端需要明确它要处理的数据是从哪个端口进入的。
2）当有客户端访问时，要明确是哪个客户端，可通过accept()获取已连接的客户端对象，并通过该对象与客户端通过IO流进行数据传输。
3）当该客户端访问结束，关闭该客户端。
4、步骤
客户端：
通过查阅socket对象，发现在该对象建立时，就可以去连接指定主机。因为tcp是面向连接的。所以在建立socket服务时，就要有服务端存在，并连接成功。形成通路后，在该通道进行数据的传输。
1）创建Socket服务。并指定要连接的主机和端口。通路一建立，就会产生Socket流（包括输入流和输出流），通过方法获取
2）为了发送数据，应该获取socket流中的输出流。如果要接收服务端的反馈信息，还需要获取Socket的输入流
3）通过输出流的write()方法将要发送的数据写入到流中
4）关闭Socket流资源
服务端：
服务器套接字等待请求通过网络传入。它基于该请求执行某些操作，然后可能向请求者返回结果。需监听一个端口。
1）建立服务端socket服务。并监听一个端口。
2）获取连接过来的客户端对象。通过ServerSokcet的 accept方法。没有连接就会等，所以这个方法阻塞式的。
3）客户端如果发过来数据，那么服务端要使用对应的客户端对象，并获取到该客户端对象的读取流来读取发过来的数据。并打印在控制台。
4）关闭服务端。（可选）
示例：
/*
客户端给服务端发送数据，服务端收到后，给客户端反馈信息
*/
//客户端
class TcpClient
{
public static void main(String[] args)throws Exception
{
//创建客户端的socket服务。指定目的主机和端口
Socket s = new Socket("192.168.1.24",10000);
//获取socket流中的输出流
OutputStream out = s.getOutputStream();
out.write("服务端，你好".getBytes());
//获取Socket流中的输入流，用来接收服务端的反馈信息并打印
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 TcpServer
{
public static void main(String[] args) throws Exception
{
//建立服务端socket服务。并监听一个端口
ServerSocket ss = new ServerSocket(10004);
//通过accept方法获取连接过来的客户端对象
Socket s = ss.accept();
//获取客户端ip
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();
out.write("哥们收到,你也好".getBytes());
//关闭资源
s.close();
ss.close();//可选
}
}练习一
/*
需求：建立一个文本转换服务器。
客户端给服务端发送文本，服务端会将文本转成大写在返回给客户端。
而且客户端可以不断的进行文本转换。当客户端输入over时，转换结束。
分析：
客户端：
既然是操作设备上的数据，那么就可以使用io技术，并按照io的操作规律来思考。
源：键盘录入。
目的：网络设备，网络输出流。
而且操作的是文本数据。可以选择字符流。
步骤
1，建立服务。
2，获取键盘录入。
3，将数据发给服务端。
4，获取服务端返回的大写数据。
5，结束，关资源。
都是文本数据，可以使用字符流进行操作，同时提高效率，加入缓冲。
*/
import java.io.*;
import java.net.*;
class TransClient
{
public static void main(String[] args) throws Exception
{
Socket s = new Socket("192.168.1.254",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;
out.println(line);
// bufOut.write(line);
// bufOut.newLine();
// bufOut.flush();
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(10005);
Socket s = ss.accept();
String ip = s.getInetAddress().getHostAddress();
System.out.println(ip+"....connected");
//读取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)
{
System.out.println(line);
out.println(line.toUpperCase());//将数据转为大写后返回
// bufOut.write(line.toUpperCase());
// bufOut.newLine();
// bufOut.flush();
}
s.close();//关流
ss.close();
}
}
/*
该例子出现的问题。
现象：客户端和服务端都在莫名的等待。
原因：
因为客户端和服务端都有阻塞式方法。这些方法么没有读到结束标记。那么就一直等
而导致两端，都在等待。
解决：需要用到刷新和换行的方式将写入和读取的数据从流中刷到内存中
一、可用高效缓冲区类中的newLine()换行作为结束标记，用flush()刷新
二、可用PrintOutputStream(s.getOutputStream(),true)创建输出流对象，true的作用是刷新。
*/练习二
/*需求：向服务器上传一个文件，并返回上传成功信息
1、客户端：
源：硬盘上的文件
目的：网络设备，即网络输出流
2、服务端：
源：socket读取流
目的：socket输出流
*/
import java.io.*;
import java.net.*;
class TextClient
{
public static void main(String[] args) throws Exception
{ //创建socket服务
Socket s = new Socket("192.168.1.254",10006);
//定义读取流读取文件数据
BufferedReader bufr =
new BufferedReader(new FileReader("TcpDemo.java"));
//定义目的，将数据写入到socket输出流，发给服务端
PrintWriter out = new PrintWriter(s.getOutputStream(),true);
String line = null;
while((line=bufr.readLine())!=null)
{
out.println(line);
}
s.shutdownOutput();//关闭客户端的输出流。相当于给流中加入一个结束标记-1.
//定义一个socket读取流，读取服务端返回信息
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
{
//建立服务端socket服务。并监听一个端口
ServerSocket ss = new ServerSocket(10006);
//通过accept方法获取连接过来的客户端对象
Socket s = ss.accept();
//获取客户端ip
String ip = s.getInetAddress().getHostAddress();
System.out.println(ip+"....connected");
//读取socket读取流中的数据
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();
}
}import java.io.*;
import java.net.*;
//客户端
class PicClient
{
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*5)
{
System.out.println("文件过大，没安好心");
return ;
}
//创建服务
Socket s = new Socket("192.168.1.24",10007);
//读取图片数据
FileInputStream fis = new FileInputStream(file);
//用socket服务输出流写入数据
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
{
public static void main(String[] args) throws Exception
{ //创建服务，监听端口
ServerSocket ss = new ServerSocket(10007);
while(true)
{
//获取客户端对象
Socket s = ss.accept();
}
new Thread(new PicThread(s)).start();
}
}
//用多线程实现并发上传
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("d:\\pic");
//文件名
File file = new File(dir,ip+"("+(count)+")"+".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+"上传失败");
}
}
}
class PicServer
{
public static void main(String[] args) throws Exception
{
ServerSocket ss = new ServerSocket(10007);
while(true)
{
Socket s = ss.accept();
new Thread(new PicThread(s)).start();
}
//ss.close();
}
}二、客户端并发登录
代码：
import java.io.*;
import java.net.*;
//客户端
class LoginClient
{
public static void main(String[] args) throws Exception
{
//创建服务
Socket s = new Socket("192.168.1.254",10008);
//键盘录入
BufferedReader bufr =
new BufferedReader(new InputStreamReader(System.in));
//用socket服务输出流写入数据
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()
{
//获取客户端ip
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();
if(name==null)
break;//如果客户端没有发送数据，跳出循环
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+",用户名不存在");
}
}
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();
}
}
}三、客户端和服务端的浏览器演示
浏览器是一个标准的客户端，它可以对服务端传送过来的数据消息进行解析，把符合应用层协议的消息部分解析后，将头信息拆包掉，传送到应用层，只保留了正确的正文主题部分显示在主体部分上。
而由于使用java编译是在传输层和网际层处理的，所以，会接受到全部的消息，包含了头消息。而浏览器处于应用层，已将发送来的头消息去除，只留下了主体信息。
1，
客户端：浏览器 (telnet)
服务端：自定义。
2，
客户端：浏览器。
服务端：Tomcat服务器。
3，
客户端：自定义。(图形界面)
服务端：Tomcat服务器。
示例：
自定义服务器，用浏览器访问：
import java.net.*;
import java.io.*;
//服务器
class ServerDemo
{
public static void main(String[] args) throws Exception
{
//创建服务，监听端口
ServerSocket ss = new ServerSocket(11000);
//获取客户端
Socket s = ss.accept();
System.out.println(s.getInetAddress().getHostAddress());
//读取客户端数据
InputStream in = s.getInputStream();
byte[] buf = new byte[1024];
int len = in.read(buf);
//显示数据
System.out.println(new String(buf,0,len));
//返回信息写入客户端输出流
PrintWriter out = new PrintWriter(s.getOutputStream(),true);
out.println("客户端你好");
s.close();//关流
ss.close();
}
}四、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();//获取输出流
示例：
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.net.*;
class MyIEByGUIDemo
{
//定义所需组件引用
private Frame f;
private TextField tf;
private Button but;
private TextArea ta;
//构造函数
MyIEByGUIDemo()
{
init();
}
//窗体基本设置及功能实现
public void init()
{
//组件实例化
f = new Frame("my window");
but = new Button("转到");
tf = new TextField(30);
ta = new TextArea(15,35);
//基本设置
f.setBounds(300,100,500,400);
f.setLayout(new FlowLayout());
//添加组件
f.add(tf);
f.add(but);
f.add(ta);
myEvent();
f.setVisible(true);
}
//注册事件
private void myEvent()
{
//窗体关闭功能
f.addWindowListener(new WindowAdapter()
{
public void windowClosing(WindowEvent e)
{
System.exit(0);
}
});
//"转到"按钮事件
but.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
try
{
showDir();//显示网页内容在文本区内
}
catch (Exception ex)
{
throw new RuntimeException("显示失败");
}
}
});
//文本框键盘事件
tf.addKeyListener(new KeyAdapter()
{
public void keyPressed(KeyEvent e)
{
try
{
if(e.getKeyCode()==KeyEvent.VK_ENTER)
showDir();
}
catch (Exception ex)
{
throw new RuntimeException("显示失败");
}
}
});
}
//显示网页内容
private void showDir() throws Exception
{
ta.setText("");
String path = tf.getText();//获取输入的路径
//封装地址对象
URL url = new URL(path);
URLConnection conn = url.openConnection();
//读取服务器返回的数据
InputStream in = conn.getInputStream();
byte[] buf = new byte[1024];
int len = in.read(buf);
//将数据显示在文本区内
ta.setText(new String(buf,0,len));
}
public static void main(String[] args)
{
new MyIEByGUIDemo();
}
}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地址找到对应的服务器。
示意图：
host应用：可屏蔽一些恶意网址，即将对应的映射关系写入hosts中，将IP地址改为本机的回环地址，那么会直接找到hosts，就不会将请求发送出去了。
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------