Java学习日志（23-3-网络编程-TCP）

TCP传输

建立客户端和服务器端

建立连接后通过Socket中IO流进行数据传输

关闭socket

*客户端Socket与服务器端ServerSocket是两个独立的应用

/*
TCP传输
TCP分为客户端和服务端
客户端对应对象是Socket
服务端对应对象是ServerSocket

客户端:
在该对象建立时，就可以连接指定主机
因为TCP是面向连接的，所以在建立服务时，需要有服务官存在并连接成功
形成通路后，在该通道进行数据的传输
给服务端发送文本数据
1.创建Socket服务，并指定要连接的主机和端口
*/
import java.io.*;
import java.net.*;
class TCPClient{
public static void main(String[] args)throws Exception{
// 创建客户端的socket服务，指定目的主机和端口
Socket s=new Socket("192.168.1.1",10003);
// 为了发送数据，应该获取socket流中的输出流
OutputStream out=s.getOutputStream();
out.write("tcp".getBytes());
s.close();
}
}
/*
服务端
1.建立服务端的Socket服务，ServerSocket();
并监听一个端口
2.获取连接的客户端对象，通过accept方法，没有连接就会等，属于阻塞式
3.如果客户端发来数据，服务端使用对应的客户端对象，并获取到该对象的读取流
4.关闭服务器
*/
class TCPServer{
public static void main(String[] args)throws Exception{
// 建立服务端Socket服务，监听端口
ServerSocket ss=new ServerSocket(10003);
// 通过accept获取对象
Socket s=ss.accept();
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));
s.close();//关闭客户端
ss.close();//关闭服务端
}
}

客户端与服务器互访

/*
演示TCP客户端和服务端的互访
客户端给服务端发送数据，服务端收到后给客户端反馈信息

客户端:
1.建立Socket服务，指定连接主机和端口
2.获取Socket的输出流，将数据写到流中，通过网络发送给服务端
3.获取Socket流中的输入流，将服务端反馈的数据并获取打印
4.关闭资源
*/
import java.io.*;
import java.net.*;
class TCPClient2{
public static void main(String[] args)throws Exception{
Socket s=new Socket("192.168.1.135",10004);
OutputStream out=s.getOutputStream();
out.write("服务端，你好".getBytes());
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 TCPServer2{
public static void main(String[] args)throws Exception{
ServerSocket ss=new ServerSocket(10004);
Socket s=ss.accept();
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技术来思考
源-键盘录入
目的-网络设备，网络输出流
操作的是文本数据，可以选择字符流
1.建立服务
2.获取键盘录入
3.发给服务端
4.返回大写数据
5.关闭资源
都是文本数据，可以使用字符流操作，同时提高效率，加入缓冲
*/
import java.io.*;
import java.net.*;
class TrainsClient{
public static void main(String[] args)throws Exception{
Socket s=new Socket("192.168.135",10024);
// 定义读取键盘数据的流对象
BufferedRe
7fe0
ader 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 TrainsServer{
public static void main(String[] args)throws Exception{
ServerSocket ss=new ServerSocket(10024);
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());
// readLine必须读到回车才会停止，必须添加结束标志
// bufOut.newLine();
// bufOut.flush();
}
s.close();
ss.close();
}
}
/*
该例出现的问题:
现象-客户端与服务端都在等待
客户端和服务端都有阻塞式的方法，这些方法没有读到结束标记就会一直等

*/

TCP上传文件

import java.io.*;
import java.net.*;
class TextClient{
public static void main(String[] args)throws Exception{
Socket s=new Socket("192.168.1.135",10006);
BufferedReader bufr=
new BufferedReader(new FileReader("IPDemo.java"));
PrintWriter out=new PrintWriter(s.getOutputStream(),true);

// 加入时间戳
// DataOutputStream dos=new DataOutputStream(s.getOutputStream());
// long time=System.currentTimeMillis();
// out.println(time);
// dos.writeLong(time);

String line=null;
while((line=bufr.readLine())!=null){
out.println(line);
}

// dos.writeLong(time);
// out.println("");
s.shutdownOutput();// 关闭客户端输入流，相当于-1

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{
ServerSocket ss=new ServerSocket(10006);
Socket s=ss.accept();
String ip=s.getInetAddress().getHostAddress();
System.out.println(ip+".....connected");

// DataInputStream dis=new DataInputStream(s.getInputStream());
// long l=dis.readLong

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

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.135",10007);
FileInputStream fis=new FileInputStream(1.bmp);
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对象
为了让多个客户端同时访问，服务端将每个客户端封装到单独的线程中
*/
class PisServer{
public static void main(String[] args)throws Exception{
ServerSocket ss=new ServerSocket(10007);
Socket s=ss.accept();
InputStrream 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);
}
OutputStream out=s.getOutputStream();
out.write("上传成功".getBytes());
fos.close();
s.close();
ss.close();
}
}

TCP上传图片-多人上传

/*
上传图片
客户端
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.135",10007);
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();
}
}
/*
定义线程
明确每一个客户端需要在服务端执行的代码即可，将之存入run();
*/
class PicThread implements Runnable{
private Socket s;
PicThread(Socket s){
this.s=s;
}
public void run(){
int count=0;
String ip=s.getInetAddress().getHostAddress();
try{
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);
}
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();
}
}

TCP-并发登录

/*
客户端通过键盘录入用户名
服务端对这个用户名进行校验

如果该用户存在，在服务端显示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.135",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=1;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(){
String ip=s.getInetAddress().getHostAddress();
System.out.println(ip+"....connected");
try{
for(int x=1;x<=3;x++){
BufferedReader bufIn=
new BufferedReader(new InputStreamReader(s.getInputStream()));
String name=bufIn.readLine();
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(name==null){
break;
}
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;
}
}
}
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();
}
}
}