黑马程序员—网络编程之TCP
2014-02-21 20:58
381 查看
TCP的传输建立主要依靠2个类:Socket和ServerSocket。
TCP协议传输的简单演示:
/*
演示tcp传输
1,tcp分客户端和服务端
2,客户端对应的对象是Socket
服务端对应的对象时ServerSocket
*/
/*
客户端
通过查阅socket对象,发现在该对象建立时,就可以去连接指定的主机
因为tcp是面向连接的,所以在建立socket服务时,就要有服务端存在并连接成功。
形成通路后,在该通道进行数据的传输。
需求:给服务端发送一个文本数据。
步骤:
1,创建Socket服务并指定要连接的主机和端口。
2,
*/
import java.io.*;
import java.net.*;
class TcpClient
{
public static void main(String[] args) throws Exception
{
//创建客户端的socket服务,指定目的主机和端口
Socket s = new Socket("192.168.1.107",10005);
//为了发送数据,应该获取socket流中的输出流
OutputStream out = s.getOutputStream();
out.write("tcp ge men lai le !".getBytes());
s.close();
}
}
/*
需求:定义端点接收数据并打印在控制台上
服务端:
1,建立服务端的socket服务,通过ServerSocket();
并监听一个端口。
2,获取连接过来的客户端对象。
通过ServerSocket的accept方法,没有连接就会等待,所以这个方法是阻塞式的。
3,客户端如果发过来数据,那么服务端要使用对应的客户端对象,获取到该客户端对象
的读取流,来读取发过来的数据,并打印在控制台
4,关闭服务端。(可选操作)
*/
class TcpServer
{
public static void main(String[] args) throws Exception
{
//建立服务端的socket服务,并监听一个端口
ServerSocket ss = new ServerSocket(10005);
//通过accept方法获取连接过来的客户端对象
Socket s = ss.accept();
//获取客户端发送过来的数据,那么要使用客户端对象的读取流来读取数据
InputStream in = s.getInputStream();
byte[] buf = new byte[1024];
int len = in.read(buf);
System.out.println(new String(buf,0,len));
String ip = s.getInetAddress().getHostAddress();
System.out.println("ip::"+ip);
s.close();//关闭客户端,服务端可能不关闭自己,但要关闭客户端
ss.close();
}
}
ServerSocket的构造方法ServerSocket(int port,int backlog),其中backlog指的是能连接到服务器的客户端的最大个数。
用TCP协议演示客户端给服务端上传图片:
/*
需求:上传图片。
*/
/*
客户端。
1、服务端点。
2、读取客户端已有的图片数据。
3、通过socket输出流将数据发给服务端。
4、读取服务端反馈信息。
5、关闭
*/
import java.io.*;
import java.net.*;
class PicClient
{
public static void main(String[] args) throws Exception
{
Socket s = new Socket("192.168.1.107",10008);
FileInputStream fis = new FileInputStream("C:\\7ZhICOu.jpg");
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();
}
}
/*
服务端。
这个服务端有个局限性,当A客户端连接上以后,被服务端获取到,服务端执行具体流程。
这时B客户端连接,只有等待。
因为服务端还没有处理完A客户端的请求,还没有循环回来执行下次accept方法。
所以暂时获取不到B客户端对象。
那么为了可以让多个客户端同时并发访问服务端。
服务端最好就是将每个客户端封装到一个单独的线程中,这样就可以同时处理多个客户端请求。
如何定义线程呢?
只要明确了每一个客户端要在服务端执行的代码即可,将该代码存入run方法中。
*/
class PicServer
{
public static void main(String[] args)throws Exception
{
ServerSocket ss = new ServerSocket(10008);
Socket s = ss.accept();
InputStream in = s.getInputStream();
FileOutputStream fos = new FileOutputStream("server.bmp");
byte[] buf = new byte[1024];
int len = 0;
while((len= in.read(buf))!=-1)
{
fos.write(buf,0,len);
}
s.getOutputStream().write("上传成功".getBytes());
fos.close();
s.close();
ss.close();
}
}
将上面的例子进行改进,可以多个客户端并行连接并且上传图片:
/*
需求:上传图片。
*/
/*
客户端。
1、服务端点。
2、读取客户端已有的图片数据。
3、通过socket输出流将数据发给服务端。
4、读取服务端反馈信息。
5、关闭
*/
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.107",10008);
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();
}
}
/*
服务端。
这个服务端有个局限性,当A客户端连接上以后,被服务端获取到,服务端执行具体流程。
这时B客户端连接,只有等待。
因为服务端还没有处理完A客户端的请求,还没有循环回来执行下次accept方法。
所以暂时获取不到B客户端对象。
那么为了可以让多个客户端同时并发访问服务端。
服务端最好就是将每个客户端封装到一个单独的线程中,这样就可以同时处理多个客户端请求。
如何定义线程呢?
只要明确了每一个客户端要在服务端执行的代码即可,将该代码存入run方法中。
*/
class picThread implements Runnable
{
private Socket s;
picThread(Socket s)
{
this.s = s;
}
public void run()
{
String ip = s.getInetAddress().getHostAddress();
try
{
int count = 1;
System.out.println(ip+"......connected");
InputStream in = s.getInputStream();
File file = new File(ip+"("+(count)+")"+".jpg");
while(file.exists())
file = new File(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);
}
s.getOutputStream().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(10008);
while(true)
{
Socket s = ss.accept();
new Thread(new picThread(s)).start();
}
// ss.close();
}
}
建立一个文本转换器:
/*
需求:建立一个文本转换服务器。
客户端给服务端发送文本,服务端会将文本转成大写再返回给客户端。
而且客户端可以不断的进行文本转换,当客户端输入over时,转换就结束。
分析:
客户端:
既然是操作设备上的数据,那么就可以使用io技术,并按照io的操作规律来思考。
源:键盘录入。
目的:网络设备,网络输出流。
而且操作的是文本数据。可以选择字符流。
步骤:
1,建立服务。
2,获取键盘录入。
3,将数据发给服务端。
4,获取服务端返回的大写数据。
5,结束,关资源。
都是文本数据,可以使用字符流进行操作,同时提高效率,加入缓冲。
*/
import java.net.*;
import java.io.*;
class TransClient
{
public static void main(String[] args)throws Exception
{
Socket s = new Socket("192.168.1.107",10005);
//定义读取键盘数据的流对象
BufferedReader bufr =
new BufferedReader(new InputStreamReader(System.in));
//定义目的,将数据写入到socket输出流,发给服务端
BufferedWriter bufwOut =
new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
//定义一个socke读取流,读取服务端返回的大写信息
BufferedReader bufIn =
new BufferedReader(new InputStreamReader(s.getInputStream()));
PrintWriter out = new PrintWriter(s.getOutputStream(),true);
String line = null;
while((line=bufr.readLine())!=null)
{
if(line.equals("over"))
break;
out.println(line);
// bufwOut.write(line);
// bufwOut.newLine();
// bufwOut.flush();
String str = bufIn.readLine();
System.out.println("server:"+str);
}
s.close();
bufr.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();
}
}
/*
该例子出现的问题。
现象:客户端和服务端都在莫名的等待,这时为什么呢?
因为客户端和服务端都是阻塞式的方法,这些方法没有读到结束标记,就会一直等,
而导致两端都在等待。
*/
客户并发登陆:
/*
客户端通过键盘录入用户名。
服务端对这个用户名进行校验。
如果用户名存在,在服务端显示xxx,已登录。
并在客户端显示xxx,欢迎光临。
如果该用户不存在,在用户端显示xxx,尝试登陆。
并在客户端显示xxx,该用户不存在。
最多就登陆三次
*/
import java.io.*;
import java.net.*;
class LoginClient
{
public static void main(String[] args) throws Exception
{
Socket s = new Socket("192.168.1.107",10008);
BufferedReader bufr =
new BufferedReader(new InputStreamReader(System.in));
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 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();
}
}
}
class UserThread implements Runnable
{
private Socket s;
UserThread(Socket s)
{
this.s = s;
}
public void run()
{
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()));
PrintWriter out = new PrintWriter(s.getOutputStream(),true);
String name = bufIn.readLine();
if(name == null)
break;
// if(name.equals("\r\n"))
// {
// out.println("请输入用户名");
// continue;
// }
BufferedReader bufr = new BufferedReader(new FileReader("user.txt"));
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+"校验失败");
}
}
}
要注意的问题:
通路建立了之后,其内部已经封装好了输入输出流,只需用方法获取到这两个流对象就可以使用了。
因为是面向连接的,所以必须先启动服务端。
InetAddress封装的是ip地址,SocketAddress的子类InetSocketAddress封装的是IP地址和端口号。
URL的使用
URL url = new URL("http://192.168.1.107:8080/myweb/demo.html");
URLConnection conn = url.openConnection();
上述操作后就已经连接到主机,无需再使用socket,该对象将应用层的请求头和应用头都封装好了。
TCP协议传输的简单演示:
/*
演示tcp传输
1,tcp分客户端和服务端
2,客户端对应的对象是Socket
服务端对应的对象时ServerSocket
*/
/*
客户端
通过查阅socket对象,发现在该对象建立时,就可以去连接指定的主机
因为tcp是面向连接的,所以在建立socket服务时,就要有服务端存在并连接成功。
形成通路后,在该通道进行数据的传输。
需求:给服务端发送一个文本数据。
步骤:
1,创建Socket服务并指定要连接的主机和端口。
2,
*/
import java.io.*;
import java.net.*;
class TcpClient
{
public static void main(String[] args) throws Exception
{
//创建客户端的socket服务,指定目的主机和端口
Socket s = new Socket("192.168.1.107",10005);
//为了发送数据,应该获取socket流中的输出流
OutputStream out = s.getOutputStream();
out.write("tcp ge men lai le !".getBytes());
s.close();
}
}
/*
需求:定义端点接收数据并打印在控制台上
服务端:
1,建立服务端的socket服务,通过ServerSocket();
并监听一个端口。
2,获取连接过来的客户端对象。
通过ServerSocket的accept方法,没有连接就会等待,所以这个方法是阻塞式的。
3,客户端如果发过来数据,那么服务端要使用对应的客户端对象,获取到该客户端对象
的读取流,来读取发过来的数据,并打印在控制台
4,关闭服务端。(可选操作)
*/
class TcpServer
{
public static void main(String[] args) throws Exception
{
//建立服务端的socket服务,并监听一个端口
ServerSocket ss = new ServerSocket(10005);
//通过accept方法获取连接过来的客户端对象
Socket s = ss.accept();
//获取客户端发送过来的数据,那么要使用客户端对象的读取流来读取数据
InputStream in = s.getInputStream();
byte[] buf = new byte[1024];
int len = in.read(buf);
System.out.println(new String(buf,0,len));
String ip = s.getInetAddress().getHostAddress();
System.out.println("ip::"+ip);
s.close();//关闭客户端,服务端可能不关闭自己,但要关闭客户端
ss.close();
}
}
ServerSocket的构造方法ServerSocket(int port,int backlog),其中backlog指的是能连接到服务器的客户端的最大个数。
用TCP协议演示客户端给服务端上传图片:
/*
需求:上传图片。
*/
/*
客户端。
1、服务端点。
2、读取客户端已有的图片数据。
3、通过socket输出流将数据发给服务端。
4、读取服务端反馈信息。
5、关闭
*/
import java.io.*;
import java.net.*;
class PicClient
{
public static void main(String[] args) throws Exception
{
Socket s = new Socket("192.168.1.107",10008);
FileInputStream fis = new FileInputStream("C:\\7ZhICOu.jpg");
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();
}
}
/*
服务端。
这个服务端有个局限性,当A客户端连接上以后,被服务端获取到,服务端执行具体流程。
这时B客户端连接,只有等待。
因为服务端还没有处理完A客户端的请求,还没有循环回来执行下次accept方法。
所以暂时获取不到B客户端对象。
那么为了可以让多个客户端同时并发访问服务端。
服务端最好就是将每个客户端封装到一个单独的线程中,这样就可以同时处理多个客户端请求。
如何定义线程呢?
只要明确了每一个客户端要在服务端执行的代码即可,将该代码存入run方法中。
*/
class PicServer
{
public static void main(String[] args)throws Exception
{
ServerSocket ss = new ServerSocket(10008);
Socket s = ss.accept();
InputStream in = s.getInputStream();
FileOutputStream fos = new FileOutputStream("server.bmp");
byte[] buf = new byte[1024];
int len = 0;
while((len= in.read(buf))!=-1)
{
fos.write(buf,0,len);
}
s.getOutputStream().write("上传成功".getBytes());
fos.close();
s.close();
ss.close();
}
}
将上面的例子进行改进,可以多个客户端并行连接并且上传图片:
/*
需求:上传图片。
*/
/*
客户端。
1、服务端点。
2、读取客户端已有的图片数据。
3、通过socket输出流将数据发给服务端。
4、读取服务端反馈信息。
5、关闭
*/
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.107",10008);
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();
}
}
/*
服务端。
这个服务端有个局限性,当A客户端连接上以后,被服务端获取到,服务端执行具体流程。
这时B客户端连接,只有等待。
因为服务端还没有处理完A客户端的请求,还没有循环回来执行下次accept方法。
所以暂时获取不到B客户端对象。
那么为了可以让多个客户端同时并发访问服务端。
服务端最好就是将每个客户端封装到一个单独的线程中,这样就可以同时处理多个客户端请求。
如何定义线程呢?
只要明确了每一个客户端要在服务端执行的代码即可,将该代码存入run方法中。
*/
class picThread implements Runnable
{
private Socket s;
picThread(Socket s)
{
this.s = s;
}
public void run()
{
String ip = s.getInetAddress().getHostAddress();
try
{
int count = 1;
System.out.println(ip+"......connected");
InputStream in = s.getInputStream();
File file = new File(ip+"("+(count)+")"+".jpg");
while(file.exists())
file = new File(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);
}
s.getOutputStream().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(10008);
while(true)
{
Socket s = ss.accept();
new Thread(new picThread(s)).start();
}
// ss.close();
}
}
建立一个文本转换器:
/*
需求:建立一个文本转换服务器。
客户端给服务端发送文本,服务端会将文本转成大写再返回给客户端。
而且客户端可以不断的进行文本转换,当客户端输入over时,转换就结束。
分析:
客户端:
既然是操作设备上的数据,那么就可以使用io技术,并按照io的操作规律来思考。
源:键盘录入。
目的:网络设备,网络输出流。
而且操作的是文本数据。可以选择字符流。
步骤:
1,建立服务。
2,获取键盘录入。
3,将数据发给服务端。
4,获取服务端返回的大写数据。
5,结束,关资源。
都是文本数据,可以使用字符流进行操作,同时提高效率,加入缓冲。
*/
import java.net.*;
import java.io.*;
class TransClient
{
public static void main(String[] args)throws Exception
{
Socket s = new Socket("192.168.1.107",10005);
//定义读取键盘数据的流对象
BufferedReader bufr =
new BufferedReader(new InputStreamReader(System.in));
//定义目的,将数据写入到socket输出流,发给服务端
BufferedWriter bufwOut =
new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
//定义一个socke读取流,读取服务端返回的大写信息
BufferedReader bufIn =
new BufferedReader(new InputStreamReader(s.getInputStream()));
PrintWriter out = new PrintWriter(s.getOutputStream(),true);
String line = null;
while((line=bufr.readLine())!=null)
{
if(line.equals("over"))
break;
out.println(line);
// bufwOut.write(line);
// bufwOut.newLine();
// bufwOut.flush();
String str = bufIn.readLine();
System.out.println("server:"+str);
}
s.close();
bufr.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();
}
}
/*
该例子出现的问题。
现象:客户端和服务端都在莫名的等待,这时为什么呢?
因为客户端和服务端都是阻塞式的方法,这些方法没有读到结束标记,就会一直等,
而导致两端都在等待。
*/
客户并发登陆:
/*
客户端通过键盘录入用户名。
服务端对这个用户名进行校验。
如果用户名存在,在服务端显示xxx,已登录。
并在客户端显示xxx,欢迎光临。
如果该用户不存在,在用户端显示xxx,尝试登陆。
并在客户端显示xxx,该用户不存在。
最多就登陆三次
*/
import java.io.*;
import java.net.*;
class LoginClient
{
public static void main(String[] args) throws Exception
{
Socket s = new Socket("192.168.1.107",10008);
BufferedReader bufr =
new BufferedReader(new InputStreamReader(System.in));
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 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();
}
}
}
class UserThread implements Runnable
{
private Socket s;
UserThread(Socket s)
{
this.s = s;
}
public void run()
{
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()));
PrintWriter out = new PrintWriter(s.getOutputStream(),true);
String name = bufIn.readLine();
if(name == null)
break;
// if(name.equals("\r\n"))
// {
// out.println("请输入用户名");
// continue;
// }
BufferedReader bufr = new BufferedReader(new FileReader("user.txt"));
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+"校验失败");
}
}
}
要注意的问题:
通路建立了之后,其内部已经封装好了输入输出流,只需用方法获取到这两个流对象就可以使用了。
因为是面向连接的,所以必须先启动服务端。
InetAddress封装的是ip地址,SocketAddress的子类InetSocketAddress封装的是IP地址和端口号。
URL的使用
URL url = new URL("http://192.168.1.107:8080/myweb/demo.html");
URLConnection conn = url.openConnection();
上述操作后就已经连接到主机,无需再使用socket,该对象将应用层的请求头和应用头都封装好了。
相关文章推荐
- 黑马程序员_网络编程1(IP,TCP和UDP,DatagramSocket与DatagramPacket,TCP传输)
- 黑马程序员——网络编程之UDP、TCP/IP
- 黑马程序员——网络编程之TCP传输
- 黑马程序员_学习笔记第22天——网络编程TCP/UDP
- 黑马程序员——8.网络编程(网络模型、网络地址、传输协议(UDP、TCP/IP)、客户端和服务器端、URL)
- 黑马程序员——网络编程之TCP协议
- 黑马程序员——网络编程TCP
- 黑马程序员——网络编程(TCP传输)
- 黑马程序员——Java基础->网络编程(TCP)
- 黑马程序员<网络编程UDP\TCP>
- 黑马程序员---网络编程TCP
- 黑马程序员------网络编程TCP
- 黑马程序员________Java中UDP和TCP网络编程学习笔记
- 黑马程序员_网络编程一(IP,TCP和UDP, DatagramSocket与DatagramPacket,TCP传输)
- 黑马程序员——Java基础——网络编程(下)之TCP
- 黑马程序员—网络编程之TCP(基础篇)
- 黑马程序员_学习笔记第23天——网络编程TCP/UDP
- 黑马程序员—网络编程TCP(传输层完整篇)
- 黑马程序员——>第二十三天<网络编程(概述-UDP-TCP)>
- 黑马程序员——网络编程(TCP、UDP)