网络编程 java.net
1. 找到对方IP
2. 数据要发送到对方指定的应用程序上,为了标示这些应用程序,给这些应用程序都用数字进行标识,为了方便称呼这个数字叫做端口.
3. 定义通讯规则.也成为协议.国际组织定义了一个通用协议:TCP/IP.
我们编程涉及带传输层和网际层.
IP地址的类:InetAddress.
端口号并未封装成对象,因为只有一个数字.
传输协议:TCP,UDP
UDP:
* 将数据及源和目的封装成数据包,不需要建立连接
* 每个数据报的大小限制在64k内
* 因无连接,是不可靠的协议
* 不需要建立连接,速度快
TCP:
* 建立连接,形成传输数据的通道
* 在连接中进行大量数据传输
* 通过三次握手完成连接,是可靠协议.第一次发过来,对方收到,然后回复,然后再确认.再发出去,就可以传输数据了.
* 必须建立连接,效率会稍低
一:网络传输
网络传输一般是先找到IP地址然后把数据发送到对方指定的应用程序上,网络应用程序都用数字进行标示,就是逻辑端口。通信规则就是协议,国际组织通信规则是TCP/IP。网络参考模型如图所示。
数据传输的时候都是从应用层开始往下推进,每过一层都会被数据封包,再经过传输线路传输到对方的主机上,再从物理层往上层层递进,每过一层都会被数据拆包,最后获得数据。传输层最常见协议是TCP和UDP,网际层常见协议就是IP。应用层是http协议。
二:网络通信三要素
1, IP地址:网络设备标示,本地循环地址127.0.0.1主机名localhost,IP地址是IP使用的32位或128位无符号数字,低级协议,TCP和UDP都是基于它建立而成的。
2, 端口号:标示进程的逻辑地址,0到65535,其中0到1024系统使用或者保留端口。
3, 传输协议:常见的TCP/UDP
Java.net包就是关于网络编程的数据包。
IP地址常用InetAddress类来表示,InetAddress常用的方法:
Socket:套接字
* 是一种为网络服务提供的一种机制
* 通讯的两端都有Socket
* 网络通讯其实就是Socket之间的通讯
* 数据在两个Socket中用IO传输
UDP使用DatagramSocket,
需求:
通过udp传输服务,将一段文字数据发送出去.
思路:
1. 建立UDPSocket服务
2. 提供数据,并将数据封装到数据包
3. 通过Socket服务的发送功能,将数据包发送出去
4. 关闭资源
package netDemos;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
public class UdpSendDemo1 {
public static void main(String[] args) throws IOException {
// TODO 自动生成的方法存根
// 创建udp服务,通过DatagramSocket对象.
DatagramSocket ds = new DatagramSocket(8888);
// 确定数据,并封装成数据包.
byte[] data = "udp comes".getBytes();
DatagramPacket dp = new DatagramPacket(data, data.length, InetAddress.getByName("127.0.0.1"), 10003);
// 通过socket服务将已有的数据包发送出去,通过send();
ds.send(dp);
// 关闭资源
// ds.close();
}
}
改进程序使其可以发送键盘录入:
package netDemos;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
public class UdpSendDemo2 {
public static void main(String[] args) throws IOException {
// TODO 自动生成的方法存根
DatagramSocket ds = new DatagramSocket();
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String line = null;
while((line=br.readLine())!=null)
{
byte[] buf = new byte[line.length()];
buf =line.getBytes();
DatagramPacket dp = new DatagramPacket(buf, line.length(),InetAddress.getByName("127.0.0.1"),10034);
ds.send(dp);
}
}
}
- 定义一个程序用于接受udp协议传输的数据并处理数据的.
- 定义接收端的时候都会监听一个端口,就是给这个接收网络应用程序定义个数字标识,
- 方便于明确哪些数据
- 1.建立udpsocket服务
- 2.定义一个数据包,因为要存储接受到的字节数据,因为数据包对象中有更多功能可以提取字节数据
- 不同数据信息.
- 3.通过socket服务的receive()将受到的数据存入已经定义好的数据包中.
- 4.通过数据包对象的特有功能,将这些不同的数据取出,打印在控制台上.
- 5.关闭资源.
*/
package netDemos;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
public class UdpRecDemo1 {
public static void main(String[] args) throws IOException {
// TODO 自动生成的方法存根
// 1.创建udp socket服务,建立端点
DatagramSocket ds = new DatagramSocket(10003);
// 2.定义数据包用于存储数据
byte[] buf = new byte[1024];
DatagramPacket dp = new DatagramPacket(buf, buf.length);
// 3.通过服务的receive方法将受到的数据存入数据包中
while (true) {
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("received From:\t" + ip + ":" + port + "\r\n" + data);
// ds.close();
}
}
}
需求
编写一个聊天程序.
有接收和发送数据的部分.需要同时运行,因此需要用到多线程技术.收和发是不一致的,因此要定义两个Run方法,要封装到不同的类中.
package netDemos;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
public class ChatDemo {
public static void main(String[] args) throws IOException {
DatagramSocket ss = new DatagramSocket();
DatagramSocket rs = new DatagramSocket(10100);
new Thread(new Send(ss)).start();
new Thread(new Rec(rs)).start();
}
}
/*
* 编写一个聊天程序 同时可以接收和发送,因此需要用到多线程. 要定义两个实现runnable接口的类.
*/
class Send implements Runnable {
private DatagramSocket ds;
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[] buf = line.getBytes();
DatagramPacket dp = new DatagramPacket(buf, buf.length, InetAddress.getByName("127.0.0.1"), 10100);
ds.send(dp);
}
} catch (Exception e) {
throw new RuntimeException("发送失败!");
}
}
}
class Rec implements Runnable {
private DatagramSocket ds;
Rec(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) {
// TODO: handle exception
throw new RuntimeException("发送失败!");
}
}
}
package netDemos;
import java.net.InetAddress;
import java.net.UnknownHostException;
public class IPDemo {
public static void main(String[] args) throws UnknownHostException {
// TODO 自动生成的方法存根
InetAddress[] ia2 = InetAddress.getAllByName("www.zhanqi.tv");
//获取服务器ip,由于网站服务器不止一个,因此ip有多个,那么InetAddress对象也有多个.用InetAddress数组接收.
for(InetAddress is: ia2)
{
System.out.println(is.getHostAddress()+"\t"+is.getHostName());
}
}
}
Socket和ServerSocket
建立客户端和服务器端
建立连接后,通过Socket中的IO流进行数据的传输
关闭Socket
同样,客户端与服务器端是两个独立的应用.
演示Tcp传输:
Tcp分客户端和服务端.
客户端对应Socket,服务端对应ServerSocket.
客户端:通过查阅Socket对象发现该对象建立的时候就可以去连接指定的主机.因为tcp是面向连接的所以在建立Socket服务时就要有服务端存在并连接成功,形成通路后在该通道进行数据传输.
步骤:
创建客户端的Socket服务并指定要连接的主机和端口.通路一旦建立就有一个Socket流,这个流里面就有输入和输出流.getOutputStream(0;getInputStream();
package netDemos;
import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;
public class TcpClientDemo1 {
public static void main(String[] args) throws IOException {
// TODO 自动生成的方法存根
// 创建客户端的socket服务,指定目的主机和端口
Socket s = new Socket("127.0.0.1", 10009);
OutputStream os = s.getOutputStream();
os.write("client run".getBytes());
s.close();
}
}
/*
* * 1.tcp分客户端和服务端 2.服务端对应ServerSocket,客户端对应Socket
*
* 通过查阅Socket发现在该对象建立的时候就应该去连接指定主机. 因为tcp是面向连接的,因此在建立socket服务时就要有服务端存在,并连接成功.
* 形成通路后在该通道进行数据传输
*
* 创建socket服务并指定要连接的主机和端口.
*/
服务端没有流,使用客户端的流与客户端交互.
1. 服务端:定义端点接收数据并打印在控制台上
1. 建立服务端的Socket服务-->ServerSocket();并监听一个端口.
2. 获取连接过来的客户端对象.通过ServerSocket的accept().没有连接就会等(阻塞式方法).
3. 客户端如果发送过来数据,那么服务端要使用对应的客户端对象,并获取到该客户端对象的读取流来读取发过来的数据,并打印在控制台
4. 关闭服务端(可选择操作)
package netDemos;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;
public class TcpServerDemo1 {
public static void main(String[] args) throws IOException {
// TODO 自动生成的方法存根
//建立服务端的socket服务并监听一个端口
ServerSocket ss = new ServerSocket(10009);
//通过accept方法获取连接过来的客户端对象.
Socket s = ss.accept();
System.out.println(s.getInetAddress().getHostAddress()+".....connected");
//获取客户端发送过来的数据,那么要使用客户端的读取流来读取数据.
BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
String line = null;
while((line = br.readLine())!=null)
System.out.println(line);
s.close();
}
}
/*
* *
* 定义端点接收数据并打印到控制台上.
* 服务端:
* 1.建立服务端Socket服务,ServerSocket,并绑定端口.
* 2.获取连接的客户端对象.通过ss的accept();来完成.因此这个方法是阻塞式方法.
* 3.客户端如果发送过来数据,那么服务端要使用对应的客户端对象,并获取到该客户端对象的读取流
* 来读取发送过来的数据,打印在控制台
*
*/
演示Tcp的传输的客户端和服务端的互访:需求:客户端给服务端发送数据,服务端收到后给客户端反馈信息.
客户端:
建立Socket服务,指定要连接的主机和端口
获取Socket中的输出流将数据写到该流中通过网络发送给服务端.
获取Socket流中的输入流.将服务端反馈的数据获取到,并打印
关闭客户端资源
需求:建立一个文本转换服务器,客户端给服务端发送文本,服务端将文本转换成大写换回个以客户端,而且客户端可以不断进行文本转换,当客户端输入over时结束.
分析:
客户端:既然是操作设备上的数据,那么就可以使用io技术,并按照IO操作的规律来死开.
源:键盘录入.
目的:网络输出流.而且操作的是文本数据.
BufferedWriter bufw = new BufferedWriter(new )
步骤:
1. 建立服务
2. 获取键盘录入
3. 将数据发给服务端
4. 获取服务端返回的大写数据,
5. 3,4重复
6. 结束,关闭资源
都是文本数据,可以使用字符流进行操作,同时提高效率,使用Buffered流.
BufferedReader bufr = new BufferedReader(InputStreamReader(System.in));//定义读取键盘数据的流对象
BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));//定义目的,将数据写入到socket输出流,发送给服务端
package netDemos;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.Socket;
public class TcpClientDemo3 {
public static void main(String[] args) throws Exception {
// TODO 自动生成的方法存根
Socket s = new Socket("127.0.0.1",10001);
//定义读取键盘数据的流对象
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
//定义目的,将数据写入到socket输出流,发送给服务端
BufferedWriter bwOut = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
//PrintWriter out = new PrintWriter(s.getOutputStream(),true);
//然后使用out的println()方法直接输出.
//定义一个socke读取流,读取服务端返回的大写信息
BufferedReader brIn = new BufferedReader(new InputStreamReader(s.getInputStream()));
String line = null;
while((line = br.readLine())!=null){
bwOut.write(line);
bwOut.newLine();
// System.out.println(line);
bwOut.flush();
if("over".equals(line))
break;
Thread.sleep(1000);
String inline = brIn.readLine();
System.out.println("Server:"+inline);
}
br.close();
}
}
服务端:
源:Socket读取流
目的:Socket输出流.都是文本.
package netDemos;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.ServerSocket;
import java.net.Socket;
public class TcpServerDemo3 {
public static void main(String[] args) throws IOException {
// TODO 自动生成的方法存根
ServerSocket ss = new ServerSocket(10001);
Socket s = ss.accept();
//读取socket读取流中的数据
String ip = s.getInetAddress().getHostAddress();
System.out.println(ip+".....connected");
BufferedReader brIn = new BufferedReader(new InputStreamReader(s.getInputStream()));
//目的:socket输出流将大写数据写入到socket的输出流中.并发送给客户端
BufferedWriter bwOut = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
// PrintWriter out = new PrintWriter(s.getOutputStream(),true);
//使用out.println()直接输出.
String line = null;
while((line = brIn.readLine())!=null){
bwOut.write(line.toUpperCase());
bwOut.newLine();
bwOut.flush();
// System.out.println(line);
}
s.close();
ss.close();
}
}
/*
* *
* 需求:建立一个文本服务器,处理客户端发送的字符串.服务端可以一直发送,当发送over时转换结束.
*
* 分析:
* 客户端:既然是操作数据,那么就可以使用IO技术并按照IO的操作规律来思考!
* 源:键盘录入
* 目的:网络输出流,网络输出流
* 而且操作的是文本数据.字符流.
*
* 步骤:
* 1.建立服务
* 2.获取键盘录入
* 3.将数据发给服务端
* 4.获取服务端返回的大写数据.
* 5.结束,关资源.
*
* 都是文本数据,可以使用字符流进行操作.同时提高效率,使用Buffered.
*
*
* 服务端:
* 源:socket读取流
* 目的:socket输出流
*
*
* 这个例题出现的问题:
* 现象:
* 客户端和服务端都在莫名等待,readLine()方法读取回车才可以读取得到,
* 解决方案:因此在发送给对方数据时应该newLine()然后再flush();
*
*/
该例出现的问题:
现象:客户端和服务端都在莫名地等待,这就是客户端和服务端都有阻塞式的方法造成的后果.这些方法没有读到结束标记就会一直等,而导致两端都在等待.
开发时,应该查询阻塞式方法readLine().如果没有newLine()则一直等待.
上例中的流可以被PrintWriter替代:
**需求:Tcp复制文件**
分析步骤:
Tcp复制文件:
1. 建立客户端对象,并绑定目标地址和端口.
2. 创建一个BufferedReader读取文件FileReader
3. PrintWriter(s.getOutputStream,true);
4. 发送数据,使用readLine();
5. 服务端:建立服务端对象,创建BufferedReader,PrintWriter(new FileWriter())
6. 使用readLine(),写入到目标文件.
7. 使用PrintWriter返回给客户端信息
8. 关闭资源.
那么文件发送到什么时候才结束呢?我们可以在Socket类里面找一个方法.
shutdownOutput()
shutdownInput()
**服务端实现代码:**
package netDemos;
import java.io.BufferedReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
public class TcpServerDemo4 {
public static void main(String[] args) throws IOException {
// TODO 自动生成的方法存根
ServerSocket ss = new ServerSocket(10081);
// 读取socket读取流中的数据
Socket s = ss.accept();
String ip = s.getInetAddress().getHostAddress();
System.out.println(ip + ".....connnected");
BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
PrintWriter out = new PrintWriter(new FileWriter("server.txt"), true);
String line = null;
String mark = br.readLine();
while ((line = br.readLine()) != null) {
if (mark.equals(line))
break;
out.println(line);
}
PrintWriter pw = new PrintWriter(s.getOutputStream(), true);
pw.println("Upload Success");
out.close();
s.close();
ss.close();
}
}
客户端:
1. 客户端点的建立
2. 建立一个流,读取数据
3. 发送给服务端
4. 接受服务端的反馈信息
5. 关闭
客户端实现代码
```package netDemos;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
public class TcpClientDemo4 {
public static void main(String[] args) throws IOException {
// TODO 自动生成的方法存根
Socket s = new Socket("127.0.0.1", 10081);
BufferedReader br = new BufferedReader(new FileReader("IO"));
PrintWriter out = new PrintWriter(s.getOutputStream(), true);
String line = null;
// 或者也可以使用DataOutputStream发送标记,服务端也使用对应的输入流接收标记.
// long time = System.currentTimeMillis();
// 定义标记麻烦,可以使用Socket中的方法.
// out.println(time);
while ((line = br.readLine()) != null) {
out.println(line);
}
// out.println(time);
s.shutdownOutput();// 关闭客户端输出流,相当于给流中加一个-1标记.
BufferedReader brIn = new BufferedReader(new InputStreamReader(s.getInputStream()));
String linein = brIn.readLine();
System.out.println(linein);
br.close();
s.close();
}
}
需求:TCP练习-客户端并发上传图片:
ServerSocket ss = new ServerSocket(10086);
while (true) {
Socket s = ss.accept();
InputStream is = s.getInputStream();
}
这个服务端有一个局限性,当A客户端连接上以后,被服务端获取到,服务端就在执行代码,直到执行完另一个客户端才可以连接成功.因为服务端还没有处理完A客户端的请求.没有循环回来执行到accept()方法,所以暂时获取不到B客户端对象.
那么为了可以让多个客户端同时并发访问服务端,那么服务端最好就是将每个客户端封装到一个单独的线程中,那样就可以同时处理多个客户端请求.
那么如何定义线程呢?
只要明确了每一个客户端要在服务端执行的代码即可!将该代码存入Run方法中 .
package netDemos;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
public class UploadPicServerDemo {
public static void main(String[] args) throws IOException {
// TODO 自动生成的方法存根
ServerSocket ss = new ServerSocket(10086);
while (true) {
Socket s = ss.accept();
new Thread(new picServer(s)).start();
}
ss.close();
}
}
class picServer implements Runnable {
private Socket s;
picServer(Socket s) {
this.s = s;
}
public void run() {
InputStream in;
String ip = s.getInetAddress().getHostAddress();
int num = 0;
try {
System.out.println(ip + ".....connected");
in = s.getInputStream();
File f = new File(ip+""+num+".jpg");
while(f.exists())
f = new File(ip+""+num+++".jpg");
FileOutputStream fos = new FileOutputStream(f);
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("Upload success".getBytes());
fos.close();
s.close();
} catch (IOException e) {
// TODO 自动生成的 catch 块
throw new RuntimeException(ip + "上传失败!");
}
}
}
那么在客户端,为了服务器性能的考虑,我们应该限制客户发送过大或者其他格式的文件.
package netDemos;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
public class UploadPicClientDemo {
public static void main(String[] args) throws IOException {
// TODO 自动生成的方法存根
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*8){
System.out.println("图片过大!");
return;
}
Socket s = new Socket("127.0.0.1", 10086);
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, 0, num));
fis.close();
s.close();
}
}
/*
-
- 客户端: 1.服务端点 2.读取图片数据 3.通过socket输出流将数据发送给服务端. 4.读取服务端反馈信息 5.关闭socket.
*/
- 客户端: 1.服务端点 2.读取图片数据 3.通过socket输出流将数据发送给服务端. 4.读取服务端反馈信息 5.关闭socket.
**需求:客户端通过键盘录入用户名,服务端对这个用户名进行校验.如果该用户存在那么服务端显示xxx已登录.并在客户端显示xxx欢迎光临.如果用户不存在,服务端显示xxx尝试登录.在客户端显示xxx,该用户不存在.最多登录三次.**
**客户端实现代码**
package netDemos;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
public class LoginClientDemo {
public static void main(String[] args) throws IOException {
// TODO 自动生成的方法存根
Socket s = new Socket("127.0.0.1", 10023);
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
PrintWriter out = new PrintWriter(s.getOutputStream(), true);
BufferedReader brIn = new BufferedReader(new InputStreamReader(s.getInputStream()));
for (int x = 0; x < 3; x++) {
String line = br.readLine();
if(line==null)
break;
out.println(line);
String info = brIn.readLine();
if(info.contains("welcome"))
break;
System.out.println("info:" + info);
}
br.close();
s.close();
}
}
**服务端实现代码**
package netDemos;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
public class LoginServerDemo {
public static void main(String[] args) throws IOException {
// TODO 自动生成的方法存根
ServerSocket ss = new ServerSocket(10023);
while (true) {
Socket s = ss.accept();
new Thread(new UserThread(s)).start();
}
}
}
class UserThread implements Runnable {
private Socket s;
UserThread(Socket s) {
this.s = s;
}
public void run() {
String ip = s.getInetAddress().getHostAddress();
BufferedReader br = null;
System.out.println(ip + ".....connected");
try {
for (int x = 0; x < 3; x++) {
BufferedReader brIn = new BufferedReader(new InputStreamReader(s.getInputStream()));
String name = brIn.readLine();
if (name == null)
break;
br = new BufferedReader(new FileReader("user.txt"));
PrintWriter out = new PrintWriter(s.getOutputStream(), true);
String line = null;
boolean flag = false;
while ((line = br.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 + "用户不存在!");
break;
}
}
br.close();
s.close();
} catch (Exception e) {
// TODO: handle exception
throw new RuntimeException(ip + "校验失败!");
}
}
}
类 **URL** 代表一个统一资源定位符,它是指向互联网“资源”的指针。资源可以是简单的文件或目录,也可以是对更为复杂的对象的引用,例如对数据库或搜索引擎的查询。
与IO流相同,IO流有个类叫做File,net有个类叫做URL.该类使用字符串进行操作.使用该类需要进行异常处理.
参数:
protocol - 要使用的协议名称。
host - 主机名称。
port - 主机端口号。
file - 主机上的文件
package netDemos;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
public class URLDemo {
public static void main(String[] args) throws IOException {
// TODO 自动生成的方法存根
URL url = new URL("http://127.0.0.1:11000/myweb/demo.html");
System.out.println(url.getProtocol());
System.out.println(url.getHost());
System.out.println(url.getPort());
System.out.println(url.getPath());
System.out.println(url.getFile());
}
}
package netDemos;
import java.io.IOException;
import java.io.InputStream;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLConnection;
public class URLConnectionDemo {
public static void main(String[] args) throws IOException {
// TODO 自动生成的方法存根
URL url = new URL("http://localhost:8080");
URLConnection conn = url.openConnection();
// System.out.println(conn);
InputStream is = conn.getInputStream();
byte[] buf = new byte[1024];
int len = 0;
while((len=is.read(buf))!=-1){
System.out.println(new String(buf,0,len));
}
}
}
//通过这段代码可以看出,URL这个类方便于我们进行网络编程,其实URL类内部封装了Socket类我们才得以方便地使用Socket流进.