import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
public class test_01 {
public static void main(String[] args) throws Exception {
//ServerSocket的accept方法是阻塞的
/* for (int i = 0; i < 20; i++) {
method_01();
Thread.sleep(1_000);
}*/
private static void method_01() throws InterruptedException {
Thread thread1 = new Thread(){
@Override
public void run() {
try {
ServerSocket serverSocket = new ServerSocket(8088);
System.out.println("server ready to accept");
Socket socket = serverSocket.accept();
System.out.println("server already accepted the clinet");
serverSocket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
};
Thread thread2 = new Thread(){
@Override
public void run() {
try {
System.out.println("客户端准备连接");
Socket socket = new Socket("localhost",8088);
System.out.println("客户端连接结束");
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
};
thread1.start();
Thread.sleep(5_00);
thread2.start();
/*输出的循环单位如下：
server ready to accept
客户端准备连接
客户端连接结束
server already accepted the clinet
* */
}
//Socket的InputStream的read方法也是阻塞的,inputStream.read方法读取的是byte[]
//method_02();
private static void method_02() throws Exception{
Thread thread1 = new Thread(){
@Override
public void run() {
try {
ServerSocket serverSocket = new ServerSocket(8088);
System.out.println("服务器准备监听8088端口");
Socket accept = serverSocket.accept();
System.out.println("服务器监听端口，取的连接");
byte[] bytes = new byte[1024];
InputStream inputStream = accept.getInputStream();
System.out.println("开始读取字节数组，时间："+System.currentTimeMillis());
inputStream.read(bytes);
System.out.println("读取字节数组结束，时间："+System.currentTimeMillis());
System.out.print("服务器接收信息：\t");
for (int i = 0; i < bytes.length; i++) {
System.out.print((char)bytes[i]);
}
} catch (IOException e) {
e.printStackTrace();
}
}
};
Thread thread2 = new Thread(){
@Override
public void run() {
try {
System.out.println("客户端准备连接");
Socket socket = new Socket("127.0.0.1",8088);
System.out.println("客户端连接完毕");
OutputStream outputStream = socket.getOutputStream();
outputStream.write("你好，服务器".getBytes());
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
};
thread1.start();
Thread.sleep(5_00);
thread2.start();
/*如果客户端只是连接，没有任何输出的话，服务器的inputStream.read(byte[])方法就会一直阻塞，输出为：
服务器准备监听8088端口
客户端准备连接
客户端连接完毕
服务器监听端口，取的连接
开始读取字节数组，时间：1557028218821
* */
/*如果把注释去掉，服务器就会有接收到信息，就不会阻塞
服务器准备监听8088端口
客户端准备连接
客户端连接完毕
服务器监听端口，取的连接
开始读取字节数组，时间：1557028405313
读取字节数组结束，时间：1557028405313
服务器接收信息： ￤ﾽﾠ￥ﾥﾽﾼﾌ￦ﾜﾍ￥ﾊﾡ￥ﾙﾨ
*
* */
}
//初识socket，使用BufferReader接收字符串，可读取为String类型，顺序为Socket.inputStream -->InputStreamReader(inputStream)-->BufferReader(inputStreamReader)
//method_03();
private static void method_03() throws IOException {
ServerSocket serverSocket = new ServerSocket(6666);
Socket socket = serverSocket.accept();
InputStream inputStream = socket.getInputStream();
InputStreamReader inputStreamReader = new InputStreamReader(inputStream);
BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
String getString = "";
while (!"".equals(getString = bufferedReader.readLine())){
System.out.println(getString);
}
OutputStream outputStream = socket.getOutputStream();
outputStream.write("HTTP/1.1 200 OK\r\n\r\n".getBytes());
outputStream.write("<html><body><a href='http:\\www.baidu.com'>i am wxf,welcome</a></body></html>".getBytes());
outputStream.flush();
inputStream.close();
outputStream.close();
socket.close();
serverSocket.close();
} //客户端向服务端传递字符串,使用inputStreamReader.read()读取char[]，会有返回参数，代表读取的char个数，每次读取个数，取决于char[]的大小
//method_04();
private static void method_04() throws Exception{
//服务器线程：
Thread thread1 = new Thread(){
@Override
public void run() {
try {
ServerSocket serverSocket = new ServerSocket(8088);
System.out.println("accept begin at "+System.currentTimeMillis());
Socket socket = serverSocket.accept();
System.out.println("accept end at "+System.currentTimeMillis());
char[] chars = new char[3];
InputStream inputStream = socket.getInputStream();
InputStreamReader inputStreamReader = new InputStreamReader(inputStream);
System.out.println("read begin at "+System.currentTimeMillis());
int readLine = inputStreamReader.read(chars);
while (readLine != -1){
System.out.println("服务器接收到消息："+new String(chars,0,readLine));
readLine = inputStreamReader.read(chars);
}
System.out.println("read end at "+System.currentTimeMillis());
//关闭资源
socket.close();
serverSocket.close();
inputStreamReader.close();
inputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
};
//客户端进程：
Thread thread2 = new Thread(){
@Override
public void run() {
try {
System.out.println("client begin at "+System.currentTimeMillis());
Socket socket = new Socket("127.0.0.1",8088);
System.out.println("client end at "+System.currentTimeMillis());
OutputStream outputStream = socket.getOutputStream();
outputStream.write("你好，客户端，我是你爸爸".getBytes());
outputStream.close();
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
};
thread1.start();
Thread.sleep(5_000);
thread2.start();
/*输出：
accept begin at 1557029408216
client begin at 1557029413215
client end at 1557029413216
accept end at 1557029413216
read begin at 1557029413216
服务器接收到消息：你好，
服务器接收到消息：客户端
服务器接收到消息：，我是
服务器接收到消息：你爸爸
read end at 1557029413217
* */
} //服务端向客户端传递字符串
//method_05();
private static void method_05() throws Exception{
//服务器线程
Thread thread1 = new Thread(){
@Override
public void run() {
try {
ServerSocket serverSocket = new ServerSocket(8088);
System.out.println("服务器监听开始，时间："+System.currentTimeMillis());
Socket socket = serverSocket.accept();
System.out.println("服务器监听结束，时间："+System.currentTimeMillis());
//得到客户端的输出流
OutputStream outputStream = socket.getOutputStream();
System.out.println("服务器开始写入");
outputStream.write("你好，客户端，我是你爸爸".getBytes());
//关闭资源
outputStream.close();
socket.close();
serverSocket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
};
//客户端进程
Thread thread2 = new Thread(){
@Override
public void run() {
try {
System.out.println("客户端准备连接，时间："+System.currentTimeMillis());
Socket socket = new Socket("127.0.0.1",8088);
System.out.println("客户端已连接，时间："+System.currentTimeMillis());
System.out.println("客户端准备接收字符串");
InputStream inputStream = socket.getInputStream();
InputStreamReader inputStreamReader = new InputStreamReader(inputStream);
char[] chars = new char[3];
int readLine = inputStreamReader.read(chars);
while (readLine != -1){
System.out.println(new String(chars,0,readLine));
readLine = inputStreamReader.read(chars);
}
System.out.println("客户端接收字符串结束");
//关闭资源
inputStreamReader.close();
inputStream.close();
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
};
thread1.start();
Thread.sleep(3_000);
thread2.start();
} //多次调用write方法进行写入操作,服务器结束while循环输出的条件是，客户端关闭了outputstream，流到达了末尾，返回-1
//method_06();
private static void method_06() throws Exception{
//服务器进程
Thread thread1 = new Thread(){
@Override
public void run() {
try {
ServerSocket serverSocket = new ServerSocket(8088);
System.out.println("服务器开始监听："+System.currentTimeMillis());
Socket accept = serverSocket.accept();
System.out.println("服务器监听结束："+System.currentTimeMillis());
char[] chars = new char[10];
System.out.println("服务器开始接收字符串："+System.currentTimeMillis());
InputStream inputStream = accept.getInputStream();
InputStreamReader inputStreamReader = new InputStreamReader(inputStream);
int readLine = inputStreamReader.read(chars);
while (readLine != -1){
System.out.println(new String(chars,0,readLine));
readLine = inputStreamReader.read(chars);
}
System.out.println("服务器接收字符串结束："+System.currentTimeMillis());
inputStreamReader.close();
inputStream.close();
accept.close();
serverSocket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
};
//客户端进程
Thread thread2 = new Thread(){
@Override
public void run() {
try {
System.out.println("客户端开始连接");
Socket socket = new Socket("127.0.0.1",8088);
System.out.println("客户端连接结束");
OutputStream outputStream = socket.getOutputStream();
outputStream.write("我是你爸爸".getBytes());
Thread.sleep(3_000);
outputStream.write("我知道你不信".getBytes());
Thread.sleep(3_000);
outputStream.write("可我真的是你爸爸".getBytes());
Thread.sleep(3_000);
outputStream.write("不管你信不信，我永远是你最亲爱的爸爸，爸爸爱你".getBytes());
outputStream.close();
socket.close();
}catch (IOException e){
e.printStackTrace();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
};
thread1.start();
Thread.sleep(3_000);
thread2.start();
} //客户端和服务器多次交流，使用objectInputStream和objectOutputStream来进行交流，当objectInputStream执行flush()方法时，接收端不再进行等待输入的阻塞
//method_07();
private static void method_07() throws Exception{
//服务器进程
Thread thread1 = new Thread(){
@Override
public void run() {
try {
ServerSocket serverSocket = new ServerSocket(8088);
Socket socket = serverSocket.accept();
InputStream inputStream = socket.getInputStream();
ObjectInputStream objectInputStream = new ObjectInputStream(inputStream);
//第一次读入
//读取将要接收的信息的长度，该数据由客户端发送
int byteLength = objectInputStream.readInt();
byte[] bytes = new byte[byteLength];
objectInputStream.readFully(bytes);
System.out.println(new String(bytes));
//第一次输出
OutputStream outputStream = socket.getOutputStream();
String strA = "我是你爸爸A\n";
String strB = "我是你爸爸B\n";
String strC = "我是你爸爸C\n";
int writeLenght = (strA+strB+strC).getBytes().length;
ObjectOutputStream objectOutputStream = new ObjectOutputStream(outputStream);
objectOutputStream.writeInt(writeLenght);
objectOutputStream.flush();
objectOutputStream.write(strA.getBytes());
objectOutputStream.write(strB.getBytes());
objectOutputStream.write(strC.getBytes());
objectOutputStream.flush();
//第二次读入
byteLength = objectInputStream.readInt();
bytes = new byte[byteLength];
objectInputStream.readFully(bytes);
System.out.println(new String(bytes));
//第二次输出
String strD = "我是你爸爸D\n";
String strE = "我是你爸爸E\n";
String strF = "我是你爸爸F\n";
writeLenght = (strD+strE+strF).getBytes().length;
objectOutputStream.writeInt(writeLenght);
objectOutputStream.flush();
objectOutputStream.write(strD.getBytes());
objectOutputStream.write(strE.getBytes());
objectOutputStream.write(strF.getBytes());
objectOutputStream.flush();
//??只关闭了输入流？？？？？输出流不用关闭？？？？？
inputStream.close();
socket.close();
serverSocket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
};
//客户端进程
Thread thread2 = new Thread(){
@Override
public void run() {
try {
Socket socket = new Socket("localhost",8088);
OutputStream outputStream = socket.getOutputStream();
InputStream inputStream = socket.getInputStream();
ObjectOutputStream objectOutputStream = new ObjectOutputStream(outputStream);
//客户端首先第一次向服务器端发送信息
String strA = "我是你爷爷A\n";
String strB = "我是你爷爷B\n";
String strC = "我是你爷爷C\n";
//先告知信息的长度
objectOutputStream.writeInt((strA+strB+strC).getBytes().length);
objectOutputStream.flush();
objectOutputStream.write(strA.getBytes());
objectOutputStream.write(strB.getBytes());
objectOutputStream.write(strC.getBytes());
objectOutputStream.flush();
//客户端第一次接收信息
ObjectInputStream objectInputStream = new ObjectInputStream(inputStream);
int byteLength = objectInputStream.readInt();
byte[] bytes = new byte[byteLength];
objectInputStream.readFully(bytes);
System.out.println(new String(bytes));
//客户端第二次输出信息
String strD = "我是你爷爷D\n";
String strE = "我是你爷爷E\n";
String strF = "我是你爷爷F\n";
objectOutputStream.writeInt((strD+strE+strF).getBytes().length);
objectOutputStream.flush();
objectOutputStream.write(strD.getBytes());
objectOutputStream.write(strE.getBytes());
objectOutputStream.write(strF.getBytes());
objectOutputStream.flush();
//客户端第二次接收信息
byteLength = objectInputStream.readInt();
bytes = new byte[byteLength];
objectInputStream.readFully(bytes);
System.out.println(new String(bytes));
objectOutputStream.close();
outputStream.close();
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
};
thread1.start();
Thread.sleep(5_000);
thread2.start();
} //inpustStream.close会造成socket关闭，InputStream继承了Closeable类，该类在关闭时，会释放与之所有有关联的资源，作者原话：
/*
* Closes this stream and releases any system resources associated
* with it. If the stream is already closed then invoking this
* method has no effect.
* */
//method_08();
private static void method_08() throws Exception{
//服务器线程
Thread thread1 = new Thread(){
@Override
public void run() {
try {
ServerSocket serverSocket = new ServerSocket(8088);
Socket socket = serverSocket.accept();
InputStream inputStream = socket.getInputStream();
byte[] bytes = new byte[30];
int readSize = inputStream.read(bytes);
while (readSize != -1){
System.out.println(new String(bytes,0,readSize));
readSize = inputStream.read(bytes);
}
inputStream.close();
//OutputStream outputStream = socket.getOutputStream();
socket.close();
serverSocket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
};
//客户端进程
Thread thread2 = new Thread(){
@Override
public void run() {
try {
Socket socket = new Socket("127.0.0.1",8088);
OutputStream outputStream = socket.getOutputStream();
outputStream.write("你猜我是不是你爸爸".getBytes());
outputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
};
thread1.start();
Thread.sleep(3_000);
thread2.start();
/*如果把注释去掉，就会出现这样的输出：
你猜我是不是你爸爸
java.net.SocketException: Socket is closed
* 证明，inputStream.close()会关闭socket
* */
} //使用socket传递图片,传递byte数组，至于更好的传输方式，比如ByteBuffer之类的，复习前面的，自行练习
method_09();
private static void method_09() throws Exception{
//4,904,483
//服务器端代码
Thread thread1 = new Thread(){
@Override
public void run() {
try {
FileOutputStream fileOutputStream = new FileOutputStream(new File("F:\\scanner down load\\new_aaa.jpg"));
ServerSocket serverSocket = new ServerSocket(8088);
Socket socket = serverSocket.accept();
InputStream inputStream = socket.getInputStream();
byte[] bytes = new byte[4904483];
int readSize = inputStream.read(bytes);
while (readSize != -1){
fileOutputStream.write(bytes,0,readSize);
readSize = inputStream.read(bytes);
}
fileOutputStream.close();
inputStream.close();
serverSocket.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
};
//客户端代码
Thread thread2 = new Thread(){
@Override
public void run() {
try {
FileInputStream fileInputStream = new FileInputStream(new File("F:\\scanner down load\\aaa.jpg"));
byte[] bytes = new byte[4904483];
fileInputStream.read(bytes);
fileInputStream.close();
Socket socket = new Socket("127.0.0.1",8088);
OutputStream outputStream = socket.getOutputStream();
outputStream.write(bytes);
outputStream.close();
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
};
thread1.start();
thread2.start();
}}
}
扫一扫
916
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
