java基础16_网络编程

连接，服务器端向客户端写入数据，客户端向服务器端读入数据：

package java基础.Socket;
import java.net.*;
import java.io.*;
/**
* 要  点：
*  1. Java Socket编程步骤
*  2. Socket/ServerSocket类用法
*  3. 通过Socket对象可以获取通信对方Socket的信息
* @author Jobs1127
*/
public class TestServer {
public static void main(String args[]) {
try {
/*
*服务器端new一个ServerSocket对象，占据一个端口
*如果服务器端已经占据了某个端口，再尝试去占用的话，就报异常java.net.BindException: Address already in use: JVM_Bind
*/
ServerSocket s = new ServerSocket(8881);
while (true) {
System.out.println("服务器端已经进入，正在等待接收客户端的Socket");
/**
* 该应用程序一启动就会打印该句话，一旦客户端连接上来，即服务器端监听到Socket,进入这里也会打印一次，每次有连接进来都会打印
*/
Socket s1 = s.accept();//不停的监听连接上来的Socket
if(s1 != null) {
OutputStream os = s1.getOutputStream();//服务器端拿到输出管道，准备给客户端输出写入数据
DataOutputStream dos = new DataOutputStream(os);//包装成数据流DataOutputStream
dos.writeUTF("Hello," + s1.getInetAddress() +
"port#" +s1.getPort() + "  bye-bye!");
dos.flush();
dos.close();
s1.close();
}
}
}catch (IOException e) {
e.printStackTrace();
}
}
}

package java基础.Socket;
import java.net.*;
import java.io.*;
/**
* 要  点：
*  1. Java Socket编程步骤
*  2. Socket/ServerSocket类用法
*  3. 通过Socket对象可以获取通信对方Socket的信息
* @author Jobs1127
* 服务器端Server，客户端Client，服务器端往客户端传输数据即写入到客户端，一般对应OutputStream
* 客户端往服务器端传输数据一般对应的管道为InputStream
*/
public class TestClient {
public static void main(String args[]) {
try {
Socket s1 = new Socket("127.0.0.1", 8881);//new一个连接服务器的Socket，对应好ip和端口
InputStream is = s1.getInputStream();//拿到读入流
DataInputStream dis = new DataInputStream(is);//包装读入流为数据流
System.out.println("已连接上服务器，"+dis.readUTF());//读服务器的数据
dis.close();
s1.close();
} catch (ConnectException connExc) {
connExc.printStackTrace();
System.out.println("服务器连接失败");
} catch (IOException e) {
e.printStackTrace();
}
}
}

程序演示，服务器端和客户端通过输入InputStream输出流OutputStream，包装成数据流DataOutputStream，可以通过写入到writeUTF()，和读入到readUTF()，实现互相通讯

package java基础.Socket;
import java.io.*;
import java.net.*;
/**
* 服务器端
* @author Jobs1127
*
*/
public class TestSockServer {
public static void main(String[] args) {
InputStream in = null;
OutputStream out = null;
int i = 0;
try {
ServerSocket ss = new ServerSocket(5888);
System.out.println("服务器端监听5888端口"+i++);
Socket socket = ss.accept();//没有放在死循环里，只要服务器端监听并接收了客户端的Socket就马上关闭服务器
if(socket != null) {
in = socket.getInputStream();
out = socket.getOutputStream();
DataOutputStream dos = new DataOutputStream(out);
DataInputStream dis = new DataInputStream(in);
String s = null;
if ((s = dis.readUTF()) != null) {
System.out.println(s);
System.out.println("from: " + socket.getInetAddress());
System.out.println("Port: " + socket.getPort());
}
dos.writeUTF("hi 客户端");
dis.close();
dos.close();
socket.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}

package java基础.Socket;
import java.net.*;
import java.io.*;
/**
* 客户端
* @author Jobs1127
*
*/
public class TestSockClient {
public static void main(String[] args) {
InputStream is = null;
OutputStream os = null;
try {
/**
* java.net.ConnectException: Connection refused: connect
* 如果服务器端没有监听该端口，尝试去访问该端口，就会报上面异常
*/
Socket socket = new Socket("localhost", 5888);
is = socket.getInputStream();
os = socket.getOutputStream();
DataInputStream dis = new DataInputStream(is);
DataOutputStream dos = new DataOutputStream(os);
dos.writeUTF("hey servers");
String s = null;
if ((s = dis.readUTF()) != null);
System.out.println(s);
dos.close();
dis.close();
socket.close();
} catch (UnknownHostException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}

包装输出、输入流来实现服务器端和客户端的交流互动

BufferedReader可以读取一行readLine()，PrintWriter可以打印写入一行

package java基础.Socket;

import java.io.*;
import java.net.*;
import java.applet.Applet;

public class talkserver {
public static void main(String args[]) {
try {
ServerSocket server = null;
try {
server = new ServerSocket(4700);
} catch (Exception e) {
System.out.println("can not listen to:" + e);
}
Socket socket = null;
try {
socket = server.accept();
} catch (Exception e) {
System.out.println("Error:" + e);
}
String line;
BufferedReader is = new BufferedReader(new InputStreamReader(socket.getInputStream()));
PrintWriter os = new PrintWriter(socket.getOutputStream());
BufferedReader sin = new BufferedReader(new InputStreamReader(System.in));
System.out.println("Client:" + is.readLine());
line = sin.readLine();
/**
* 只要不输入bye，就不关闭管道，即不关闭连接
*/
while (!line.equals("bye")) {
os.println(line);
os.flush();
System.out.println("Server:" + line);
System.out.println("Client:" + is.readLine());
line = sin.readLine();
}
is.close();
os.close();
socket.close();
server.close();
} catch (Exception e) {
System.out.println("Error" + e);
}
}
}

package java基础.Socket;

import java.io.*;
import java.net.*;

public class talkclient {
public static void main(String args[]) {
try {
Socket socket = new Socket("127.0.0.1", 4700);
BufferedReader sin = new BufferedReader(new InputStreamReader(System.in));
PrintWriter os = new PrintWriter(socket.getOutputStream());
BufferedReader is = new BufferedReader(new InputStreamReader(socket.getInputStream()));
String readline;
readline = sin.readLine();
/**
* 只要不输入bye，就不关闭管道，即不关闭连接
*/
while (!readline.equals("bye")) {
os.println(readline);
os.flush();
System.out.println("Client:" + readline);
System.out.println("Server:" + is.readLine());
readline = sin.readLine();
}
os.close();
is.close();
socket.close();
} catch (Exception e) {
System.out.println("Error" + e);
}
}
}

测试TCP：

package java基础.Socket;
import java.net.*;
import java.io.*;
public class TCPServer {
public static void main(String[] args) throws Exception {
ServerSocket ss = new ServerSocket(6666);
while (true) {
Socket s = ss.accept();
System.out.println("a client connect!");
DataInputStream dis = new DataInputStream(s.getInputStream());
System.out.println(dis.readUTF());
dis.close();
s.close();
}
}
}

package java基础.Socket;
import java.net.*;
import java.io.*;

public class TCPClient {
public static void main(String[] args) throws Exception {
Socket s = new Socket("127.0.0.1", 6666);
OutputStream os = s.getOutputStream();
DataOutputStream dos = new DataOutputStream(os);
Thread.sleep(30000);
dos.writeUTF("hello server!");
dos.flush();
dos.close();
s.close();
}
}

测试UDP：

package java基础.Socket;
import java.net.*;
import java.io.*;

public class TestUDPServer {
public static void main(String args[]) throws Exception {
byte buf[] = new byte[1024];
DatagramPacket dp = new DatagramPacket(buf, buf.length);
DatagramSocket ds = new DatagramSocket(5678);
while (true) {
ds.receive(dp);
ByteArrayInputStream bais = new ByteArrayInputStream(buf);
DataInputStream dis = new DataInputStream(bais);
System.out.println(dis.readLong());
}
}
}

package java基础.Socket;

import java.net.*;
import java.io.*;

public class TestUDPClient {
public static void main(String args[]) throws Exception {
long n = 10000L;
ByteArrayOutputStream baos = new ByteArrayOutputStream();
DataOutputStream dos = new DataOutputStream(baos);
dos.writeLong(n);

byte[] buf = baos.toByteArray();
System.out.println(buf.length);

DatagramPacket dp = new DatagramPacket(buf, buf.length,
new InetSocketAddress("127.0.0.1", 5678));
DatagramSocket ds = new DatagramSocket(9999);
ds.send(dp);
ds.close();
}
}

根据网络编程编写的聊天程序：

package java基础.Socket.myChat1;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
public class ChatServer {
public static void main(String[] args) {
//服务器端建立监听
ServerSocket ss = IoTools.getServerSocket(9999);
try {
Socket s = ss.accept();//服务器已经建立了监听，如果没有监听到客户端的连接，是不会往下执行的，监听到连接后开始往下执行
System.out.println("一个客户端已经和服务器端建立了连接");
//开始通讯
IoTools.read_UTF(s);//服务器端读取客户端发送过来的信息,通过Socket桥梁去读取
String context = "server say:hi client!";
IoTools.send_UTF(s, context);

//要和客户端端聊天，只要不输入bye就不结束聊天，通过BufferedReader/PrintWriter测试通讯
System.out.println("haha0-----");
System.out.println("client say:"+IoTools.read_buf_socket(s));//读取客户端发来的信息，如果在s管道里没有读取到，则停留在这里等待，直到读取成功才往下执行
System.out.println("haha1---");
String str = IoTools.read_buf_system_in(System.in);
System.out.println("end haha---");//如果没有服务器端没有输入，程序执行不到这里，一直等待输入，只有输入了才会往下执行

while(!str.equalsIgnoreCase("bye")) {
IoTools.send_buf(s,str);//服务器端尝试从Socket管道发送数据给服务器端
System.out.println("server say:"+str);
System.out.println("client say:"+IoTools.read_buf_socket(s));//读取客户端发来的信息
str = IoTools.read_buf_system_in(System.in);
}
//通讯结束后，关闭相关资源,断开连接
IoTools.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}

package java基础.Socket.myChat1;

import java.net.Socket;

public class ChatClient {
public static void main(String[] args) {
//与服务器端建立连接
Socket s = IoTools.getClientSokect("localhost", 9999);
System.out.println("与服务器端建立连接");
//开始通讯
//通过DataOutputStream/DataInputStream测试通讯
String context = "client say:我要给服务器发送一条信息，hi,chatserver";
IoTools.send_UTF(s,context);
IoTools.read_UTF(s);
//要和服务器端聊天，只要不输入bye就不结束聊天，通过BufferedReader/PrintWriter测试通讯
String str = IoTools.read_buf_system_in(System.in);
while(!str.equalsIgnoreCase("bye")) {
IoTools.send_buf(s,str);//客户端尝试从Socket管道发送数据给服务器端
System.out.println("client say:"+str);
System.out.println("server say:"+IoTools.read_buf_socket(s));//读取服务器端发来的信息
str = IoTools.read_buf_system_in(System.in);
}
//结束通讯后，关闭相关资源
IoTools.close();
}
}

package java基础.Socket.myChat1;

import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.UnknownHostException;
/**
* 封装Io操作数据的方法
* @author Jobs1127
*
*/
public class IoTools {
public static ServerSocket ss = null;//服务器端Socket
public static Socket s = null;//客户端Socket
/**
* DataInputStream提供了readUTF()
*/
public static DataInputStream di = null;
/**
* BufferedReader提供了readLine(),readLine()
读取一个文本行。
*/
public static BufferedReader br = null;
public static BufferedReader bre = null;
public static InputStreamReader ir = null;

/**
* DataOutputStream提供了writeUTF();
* writeUTF(String str)
以与机器无关方式使用 UTF-8 修改版编码将一个字符串写入基础输出流。
*/
public static DataOutputStream dout = null;
/**
* PrintWriter提供了println();println(String x)
打印 String，然后终止该行。
*/
public static PrintWriter pw = null;
public static PrintWriter pwe = null;

public static DataInputStream getDataInputStream(InputStream in) {
di = new DataInputStream(in);
return di;
}
public static DataOutputStream getDataOutputStream(OutputStream out) {
dout = new DataOutputStream(out);
return dout;
}

public static BufferedReader getBufferedReader(InputStream in) {
ir = new InputStreamReader(in);
br = new BufferedReader(ir);
return br;
}
public static PrintWriter getPrintWriter(OutputStream out) {
pw = new PrintWriter(out);
return pw;
}
public static ServerSocket getServerSocket(int port) {
try {
ss = new ServerSocket(port);
} catch (IOException e) {
e.printStackTrace();
}
return ss;
}
public static Socket getClientSokect(String host,int port) {
try {
s = new Socket(host,port);
} catch (UnknownHostException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return s;
}
public static void send_UTF(Socket s,String context) {
try {
if(dout == null) {
dout = new DataOutputStream(s.getOutputStream());
}
dout.writeUTF(context);
} catch (IOException e) {
e.printStackTrace();
}
}
public static void read_UTF(Socket s) {
try {
if(di == null) {
di = new DataInputStream(s.getInputStream());
}
System.out.println(di.readUTF());
} catch (IOException e) {
e.printStackTrace();
}
}
public static void send_buf (Socket s,PrintWriter pw,String str) {
try {
pw = new PrintWriter(s.getOutputStream());
pw.println(str);
pw.flush();
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 往同一根管道里写入数据
* @param s
* @param str
*/
public static void send_buf(Socket s,String str) {
try {
pw = new PrintWriter(s.getOutputStream());
pw.println(str);//把内存里的数据，写入到服务器端
pw.flush();
} catch (IOException e) {
e.printStackTrace();
}
}
public static String read_buf_socket(Socket s) {
String str = null;
try {
br = new BufferedReader(new InputStreamReader(s.getInputStream()));
str = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
public static String read_buf_system_in(InputStream in) {
String str = null;
try {
bre = new BufferedReader(new InputStreamReader(in));
str = bre.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
/**
* 关闭资源
*/
public static void close() {
try {
if (di != null) {
di.close();
}
if (dout != null) {
dout.close();
}
if(ir != null) {
ir.close();
}
if(br != null) {
br.close();
}
if(bre != null) {
bre.close();
}
if(pw != null) {
pw.close();
}
if(pwe != null) {
pwe.close();
}
if(ss != null) {
ss.close();
}
if(s != null) {
s.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}