第一部分 概述
1、网络模型:OSI参考模型和TCP/IP参考模型
图示:
一般来说开发处于传输层和网际层,应用层为:FTP和HTTP协议等,传输层为:UDP和TCP等,网际层为:IP。
通常用户操作的是应用层,而编程人员需要做的是传输层和网际层,用户在应用层操作的数据,经过逐层封包,最后到物理层发送到另一个模型中,再进行逐层解包,图示为:
2、网络通信三要素:IP地址,端口号,传输协议
A、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和主机名。(最好用ip地址去获取,主机名需要解析)
2)static InetAddress[] getAllByName(String host):在给定主机名的情况下,根据系统上配置的名称服务返回IP地址所组成的数组。返回对象不唯一时,用此方法。
3)String getHostAddress():返回IP地址字符串文本形式,以IP地址为主。
4)String getHostName():返回IP地址主机名。
(三)如何获取任意一台主机的IP地址对象:
1)功能:返回InetAddress对象
2)对于任意主机,需要指定传入主机名的参数
注意:如果IP地址和对应的主机名,这种映射关系没有在网络上,就不会解析成功,返回的还是指定的IP。
示例:
package udpdemo;
import java.net.InetAddress;
import java.net.UnknownHostException;
public class IPDemo {
public static void main(String[] args) throws UnknownHostException {
InetAddress i=InetAddress.getLocalHost();
System.out.println(i.toString());
System.out.println(i.getHostAddress());
System.out.println(i.getHostName());
// InetAddress ia=InetAddress.getByName("www.baidu.com");
// System.out.println(ia.getHostAddress());
// System.out.println(ia.getHostName());
}
}
B、端口号:
a、用于标识进程的逻辑地址,不用进程的标识。
b、有效端口:0 ~65535,系统使用或保留的端口是:0~ 1024。
C、传输协议:
即通信规则,包含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,此类表示用发送和接收数据包的套接字,即Socket。
2、方法:
1)创建 UDPSocket发送服务对象:
DatagramSocket(),不指定端口。DatagramSocket(int port),指定端口。
2)发送:void send(DatagramPacket p)
3)接收:void receive(DatagramPacket p)
其中DatagramPacket:数据报包用来实现无连接包投递服务的,每条报文仅根据该包中包含的信息从一台机器路由到另一台机器中。凡是带地址(InetAddress)的都是用于发送包的。
3、步骤
1)发送数据:
a、建立UDPSocket服务,在此无需指定端口,也可以将端口加入。如果不指定的话,系统会随机分配一个端口,如第一次运行时端口为1093,那么第二次就会顺延为1094,再运行会一直顺延,因为之前的端口还没有得到释放,所以会顺延端口号值。
b、提供数据,并将数据封装到数据包中
c、通过socket服务的发送功能,将数据包发送出去
d、关闭资源
2)接收数据:
a、定义UDPSocket服务。通常会监听一个端口,其实就是给这个接收网路应用程序定义数字标识,方便于明确哪些数据过来该应用程序可以处理。
b、定义一个数据包,用来存储接收到的字节数据,因为数据包对象中有更多功能可以提取字节数据中的不同数据信息。
c、通过socket服务的receive方法接收到的数据存入已定义好的数据包中
d、通过数据包对象的特有功能,将这些不同的数据取出,打印在控制台上
e、关闭资源
在定义接收数据的方法中,仍会在DatagramSocket构造函数中传入DatagramPacket的参数,这是因为收到的数据太多,需要解析,通过将数据封装成对象,易于解析,所以需要传入参数。
注意:
1、发送端与接收端是两个独立的运行程序。
2、在发送端,要在数据包对象中明确目的地IP及端口。
3、在接收端,要指定监听的端口。
示例:
package udpdemo;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
public class UdpSend {
public static void main(String[] args) throws Exception {
//创建socket服务
DatagramSocket ds=new DatagramSocket(8888);
//提供数据,并封装成数据包
byte[] but="UDP ge men lai le ".getBytes();
DatagramPacket dp=new DatagramPacket(but, but.length, InetAddress.getByName("192.168.1.104"), 1000);
//通过socket服务,将数据包发送出去
ds.send(dp);
//关闭资源
ds.close();
}
}
package udpdemo;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
/*
* 定义一个UDP应用程序,接受数据包并处理
*/
public class UdpReceive {
public static void main(String[] args) throws Exception {
//创建socket服务
DatagramSocket ds=new DatagramSocket(1000);
//定义数据包用于存储数据
byte[] but=new byte[1024];
DatagramPacket dp=new DatagramPacket(but, but.length);
//接收数据,存入数据包
ds.receive(dp);
//通过数据包方法获取数据方法
String ip=new String(dp.getAddress().getHostAddress());
String data=new String(dp.getData(),0,dp.getLength());
int port=dp.getPort();
System.out.println(ip+"---"+data+"---"+port);
//关闭资源
ds.close();
}
}
练习一
package udpdemo;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
//键盘输入
public class UdpSend2 {
public static void main(String[] args) throws Exception {
DatagramSocket ds=new DatagramSocket();
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
String line=null;
while ((line=br.readLine())!=null) {
if ("886".equals(line)) {
break;
}
byte[] b=line.getBytes();
DatagramPacket dp=new DatagramPacket(b, b.length, InetAddress.getByName("192.168.1.255"), 101);
ds.send(dp);
}
ds.close();
}
}
package udpdemo;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
public class UdpReceive2 {
public static void main(String[] args) throws Exception {
@SuppressWarnings("resource")
DatagramSocket ds=new DatagramSocket(101);
while (true) {
byte[] b=new byte[1024];
DatagramPacket dp=new DatagramPacket(b, b.length);
ds.receive(dp);
String ip=new String(dp.getAddress().getHostAddress());
String data=new String(dp.getData(),0,dp.getLength());
int port=dp.getPort();
System.out.println(ip+"---"+data+"---"+port);
}
}
}
练习二
package udpdemo;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
/*
* 聊天工具
*/
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));
String line=null;
while ((line=br.readLine())!=null) {
if ("886".equals(line)) {
break;
}
byte[] b=line.getBytes();
DatagramPacket dp=new DatagramPacket(b, b.length, InetAddress.getByName("192.168.1.255"), 10002);
ds.send(dp);
}
} catch (Exception e) {
throw new RuntimeException("发送失败");
}
}
}
class Recevie implements Runnable{
private DatagramSocket ds;
public Recevie(DatagramSocket ds){
this.ds=ds;
}
public void run() {
try {
while (true) {
byte[] b=new byte[1024];
DatagramPacket dp=new DatagramPacket(b, b.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("接收失败");
}
}
}
public class ChatDemo {
public static void main(String[] args) {
DatagramSocket sendSocket;
try {
sendSocket = new DatagramSocket();
DatagramSocket receiveSocket=new DatagramSocket(10002);
new Thread(new Send(sendSocket)).start();
new Thread(new Recevie(receiveSocket)).start();
} catch (SocketException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
三、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)关闭服务端(可选)。一般服务端是常开的,因为在实际应用中,随时有客户端在请求连接和服务。但这里需要定时关闭客户端对象流,避免某一个客户端长时间占用服务器端。
示例:
package tcpdemo;
import java.io.OutputStream;
import java.net.Socket;
public class TCPClient {
public static void main(String[] args) throws Exception, Exception {
//创建客户端的Socket服务,指定目的主机和端号
Socket s=new Socket("192.168.1.104",10004);
//为了发送数据,获取客户端的输出流
OutputStream out=s.getOutputStream();
out.write("tcp ge men lai le ".getBytes());
//关闭资源
s.close();
}
}
package tcpdemo;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
public class TCPServer {
public static void main(String[] args) throws Exception {
//通过创建一个服务端Socket服务,并监听一个端口
ServerSocket ss=new ServerSocket(10004);
//通过accept方法连接过来的客户端对象
Socket s=ss.accept();
String ip=s.getInetAddress().getHostAddress();
System.out.println(ip+"....connencted");
//获取客户端发送的数据,那么就要用客户端的读取流来读取
InputStream is=s.getInputStream();
byte[] b=new byte[1024];
int len=is.read(b);
System.out.println(new String(b, 0, len));
//关闭资源
ss.close();
s.close();
}
}
练习一:
package tcpdemo;
//复制文件的客户端
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
public class TextClient {
public static void main(String[] args) throws Exception {
Socket s=new Socket("192.168.1.104",10007);
BufferedReader in=new BufferedReader(new FileReader("F:\\java复制练习.java"));
PrintWriter out=new PrintWriter(s.getOutputStream(),true);
String line=null;
while ((line=in.readLine())!=null) {
out.println(line);
}
s.shutdownOutput();//关闭输出流,提供结束标记
BufferedReader br=
new BufferedReader(new InputStreamReader(s.getInputStream()));
System.out.println(br.readLine());
s.close();
in.close();
}
}
package tcpdemo;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
//复制文件的服务端
public class TextServer {
public static void main(String[] args) throws Exception {
ServerSocket ss=new ServerSocket(10007);
Socket s=ss.accept();
String ip=s.getInetAddress().getHostAddress();
System.out.println(ip+"....connected");
BufferedReader in=new
BufferedReader(new InputStreamReader(s.getInputStream()));
PrintWriter out=new PrintWriter(new FileWriter("F:\\sever.txt"),true);
String line=null;
while ((line=in.readLine())!=null) {
out.println(line);
}
BufferedWriter bwOut=
new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
bwOut.write("上传成功!");
bwOut.flush();
s.close();
ss.close();
out.close();
}
}
练习二:
package tcpdemo;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
/*
* 定义一个文本互访的服务客户端
*/
import java.net.Socket;
public class TransClient {
public static void main(String[] args) throws Exception {
//创建Socket客户端,
Socket s=new Socket("192.168.1.104",10006);
//创建键盘录入
BufferedReader in=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=in.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);
}
in.close();
s.close();
}
}
package tcpdemo;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
public class TransServer {
public static void main(String[] args) throws Exception {
//创建ServerSocket对象,监视一个端口
ServerSocket ss=new ServerSocket(10006);
//接受客户端对象
Socket s=ss.accept();
// String ip=s.getInetAddress().getHostAddress();
// System.out.println(ip+"....connect");
//目的:读取客户端发送的数据
BufferedReader bufIn=
new BufferedReader(new InputStreamReader(s.getInputStream()));
//获取Socket的输出流,返回大写数据给客户端
// BufferedWriter bufOut=
// new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
PrintWriter out=new PrintWriter(s.getOutputStream(),true);
String line=null;
while ((line=bufIn.readLine())!=null) {
out.println(line.toUpperCase());
// bufOut.write(line.toUpperCase());
// bufOut.newLine();
// bufOut.flush();
}
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方法即可。
代码:
package tcpdemo;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
//上传文件客户端
public 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.104",10008);
FileInputStream fis=new FileInputStream(file);
OutputStream os=s.getOutputStream();
byte[] b=new byte[1024];
int len=0;
while ((len=fis.read(b))!=-1) {
os.write(b, 0, len);
}
s.shutdownOutput();
InputStream in=s.getInputStream();
byte[] but=new byte[1024];
int num=0;
num=in.read(but);
System.out.println(new String(but,0,num));
s.close();
fis.close();
}
}
package tcpdemo;
import java.io.File;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
//上传图片服务端
public class PicServer {
public static void main(String[] args) throws Exception {
ServerSocket ss=new ServerSocket(10008);
while (true) {
Socket s=ss.accept();
new Thread(new PicThread(s)).start();
}
}
}
class PicThread implements Runnable{
private Socket s;
public PicThread(Socket s){
this.s=s;
}
public void run() {
String ip=s.getInetAddress().getHostAddress();
int count=1;
try {
System.out.println(ip+"...connected");
File file=new File("F:\\"+ip+"("+count+")"+".jpg");
while (file.exists()) {
file=new File("F:\\"+ip+"("+(count++)+")"+".jpg");
}
InputStream in=s.getInputStream();
FileOutputStream fos=new FileOutputStream(file);
byte[] b=new byte[1024];
int len=0;
while ((len=in.read(b))!=-1) {
fos.write(b, 0, len);
}
OutputStream out=s.getOutputStream();
out.write("上传成功!".getBytes());
//ss.close();
s.close();
fos.close();
} catch (Exception e) {
throw new RuntimeException("失败");
}
}
}
二、客户端并发登录
客户端通过键盘录入用户名,服务端对这个用户名进行校验。
如果该用户存在,在服务端显示xxx,已登陆;并在客户端显示xxx,欢迎光临。
如果用户不存在,在服务端显示xxx,尝试登陆;并在客户端显示xxx,该用户不存在。
最多就登录三次。
代码:
package tcpdemo;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
//登录客户端,最多登录三次
public class LoginClient {
public static void main(String[] args) throws Exception {
Socket s=new Socket("192.168.1.104",8888);
BufferedReader bufIn=new BufferedReader(new InputStreamReader(System.in));
PrintWriter out=new PrintWriter(s.getOutputStream(),true);
BufferedReader in=
new BufferedReader(new InputStreamReader(s.getInputStream()));
for (int i = 0; i < 3; i++) {
String line=bufIn.readLine();
if (line==null) {
break;
}
out.println(line);
String info=in.readLine();
System.out.println("info:"+info);
}
s.close();
bufIn.close();
}
}
package tcpdemo;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
//登录服务端
public class LoginServer {
public static void main(String[] args) throws Exception {
ServerSocket ss=new ServerSocket(8888);
Socket s=ss.accept();
new Thread(new LoginThread(s)).start();
}
}
class LoginThread implements Runnable {
private Socket s;
public LoginThread(Socket s){
this.s =s;
}
public void run() {
String ip=s.getInetAddress().getHostAddress();
System.out.println(ip+"...connected");
try {
for (int i = 0; i < 3; i++) {
BufferedReader bufIn =
new BufferedReader(new InputStreamReader(s.getInputStream()));
String name=bufIn.readLine();
BufferedReader in=new BufferedReader(new FileReader("F:\\user.txt"));
PrintWriter out=new PrintWriter(s.getOutputStream(),true);
String line=null;
boolean flag=false;
while ((line=in.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("登陆失败!");
}
}
}
三、客户端和服务的浏览器演示
浏览器是一个标准的客户端,它可以对服务端传送过来的数据消息进行解析,把符合应用层协议的消息部分解析后,将头信息拆包掉,传送到应用层,只保留了正确的正文主题部分显示在主体部分上。
而由于使用java编译是在传输层和网际层处理的,所以,会接受到全部的消息,包含了头消息。而浏览器处于应用层,已将发送来的头消息去除,只留下了主体信息。
示例:
自定义服务器,用浏览器访问:
package tcpdemo;
import java.io.InputStream;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
/*
* 演示客户端和服务端
* 1、客户端浏览器
* 2、服务端自定义
*/
public class SeverDemo {
public static void main(String[] args) throws Exception {
ServerSocket ss=new ServerSocket(11000);
Socket s=ss.accept();
PrintWriter out=new PrintWriter(s.getOutputStream(),true);
InputStream in=s.getInputStream();
byte[] b=new byte[1024];
int len=in.read(b);
System.out.println(new String(b, 0, len));
out.println("<font color='red' size='7'>客户端你好</font>");
ss.close();
s.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();//获取输出流
示例:
package tcpdemo;
import java.net.MalformedURLException;
import java.net.URL;
//URL用法
public class URLDemo {
public static void main(String[] args) throws MalformedURLException {
URL url=new URL("http://192.168.1.104:8080/myweb/1.html?name=haha&age=30");
System.out.println("getProtocol():"+url.getProtocol());
System.out.println("getHost():"+url.getHost());
System.out.println("getPort():"+url.getPort());
System.out.println("getPath():"+url.getPath());
System.out.println("getFile():"+url.getFile());
System.out.println("getQuery():"+url.getQuery());
}
}
package tcpdemo;
import java.io.InputStream;
import java.net.URL;
import java.net.URLConnection;
public class URLopenConnectionDemo {
public static void main(String[] args) throws Exception {
URL url=new URL("http://192.168.1.104:8080/myweb/1.html");
URLConnection conn=url.openConnection();
InputStream in=conn.getInputStream();
byte[] b=new byte[1024];
int len=in.read(b);
System.out.println(new String(b,0,len));
}
}
package tcpdemo;
//自己定义浏览器,显示网页内容
import java.awt.Button;
import java.awt.Dialog;
import java.awt.FlowLayout;
import java.awt.Frame;
import java.awt.Label;
import java.awt.TextArea;
import java.awt.TextField;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.io.InputStream;
import java.net.URL;
import java.net.URLConnection;
public class MyIE3 {
//创建一个窗口所需的组件
private Frame f;
private TextField tf;
private Button but;
private TextArea ta;
//错误提示窗口组件
private Dialog d;
private Label l;
private Button b;
//构造器
public MyIE3() {
init();
}
public void init(){
//设置窗口
f=new Frame("my window");
f.setBounds(300, 100, 600, 500);
f.setLayout(new FlowLayout());
d=new Dialog(f, "错误提示:", true);
d.setBounds(400, 200, 240, 150);
d.setLayout(new FlowLayout());
//设置组件
tf=new TextField(60);
but=new Button("转到");
ta=new TextArea(25, 70);
l=new Label();
b=new Button("确定");
//添加组件
f.add(tf);
f.add(but);
f.add(ta);
d.add(l);
d.add(b);
//事件监听
myEvent();
//可视化
f.setVisible(true);
}
//添加事件监视器
public void myEvent(){
d.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e){
d.setVisible(false);
}
});
b.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
// TODO Auto-generated method stub
d.setVisible(false);
}
});
//回车监听
tf.addKeyListener(new KeyAdapter() {
public void keyPressed(KeyEvent e){
if (e.getKeyCode()==KeyEvent.VK_ENTER) {
try {
show();
} catch (Exception e2) {
// TODO: handle exception
}
}
}
});
//窗口关闭功能
f.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e){
System.exit(0);
}
});
//Button设置事件监听器
but.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
try {
show();
} catch (Exception e2) {
// TODO: handle exception
}
}
});
}
public void show() throws Exception{
ta.setText("");
String urlpath=tf.getText();
URL url=new URL(urlpath);
URLConnection conn=url.openConnection();
InputStream in=conn.getInputStream();
byte[] b=new byte[1024];
int len=in.read(b);
//System.out.println(new String(b,0,len));
ta.append(new String(b, 0, len));
}
public static void main(String[] args) {
new MyIE3();
}
}
小知识点
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地址找到对应的服务器。
示意图: