黑马程序员--Java基础--网络编程java.net

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-

网络编程 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];

4000
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();
}

}

<div class="se-preview-section-delimiter"></div>

需求: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 + "上传失败!");
}
}
}

那么在客户端,为了服务器性能的考虑,我们应该限制客户发送过大或者其他格式的文件.

<div class="se-preview-section-delimiter"></div>

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.

*/

**需求:客户端通过键盘录入用户名,服务端对这个用户名进行校验.如果该用户存在那么服务端显示xxx已登录.并在客户端显示xxx欢迎光临.如果用户不存在,服务端显示xxx尝试登录.在客户端显示xxx,该用户不存在.最多登录三次.**

**客户端实现代码**

<div class="se-preview-section-delimiter"></div>

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();
}

}

**服务端实现代码**

<div class="se-preview-section-delimiter"></div>

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 - 主机上的文件

<div class="se-preview-section-delimiter"></div>

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());
}

}

<div class="se-preview-section-delimiter"></div>

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流进.

“`

DNS域名解析:

Domain Network Servise

关于localhost和127.0.0.1 映射关系就在本机上,C:\windows\system\drivers\etc\hosts文件上.

先找本地,本地hosts文件内没有就去dns服务器上查询.

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流进.