网络编程入门
1 Java创建服务端监听
java在服务端监听使用一个类叫做SeverSocket
//创建一个客户端socket，并且连接
Socket socket = new Socket("114.214.72.203",1985);
//获取输入输出流，并封装
InputStream in = socket.getInputStream();
OutputStream out = socket.getOutputStream();
Scanner sc= new Scanner(in);//为了方便读取，用Scanner对输入流做了一个封装
PrintWriter pw = new PrintWriter(out);
//先发送 客户端-》服务端
pw.println("你吃了吗？");
pw.flush();
//服务端-》客户端 ,客户端读取。。。
String msg = sc.nextLine();
System.out.println("服务端说:"+msg);
socket.close();其中，ServerSocket的构造函数中，包含了监听的端口号。
随后获取输入输出流。
并且先读取后写出。 即 先从客户端到服务端，后从服务端发客户端。然后关闭。
这是一个最原始的服务端模型，只接受一次请求，处理一次请求。然后就关闭了。。
2 客户端的编写
java中使用socket类来进行客户端编写，他的构造函数有两个参数，一个是ip或者域名，一个是端口号。
package org.yang;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Scanner;
public class Client {
/**
* @param args
* @throws IOException
* @throws UnknownHostException
*/
public static void main(String[] args) throws UnknownHostException, IOException {
//创建一个客户端socket，并且连接
Socket socket = new Socket("114.214.72.203",1985);
//获取输入输出流，并封装
InputStream in = socket.getInputStream();
OutputStream out = socket.getOutputStream();
Scanner sc= new Scanner(in);//为了方便读取，用Scanner对输入流做了一个封装
PrintWriter pw = new PrintWriter(out);
//先发送 客户端-》服务端
pw.println("你吃了吗？");
pw.flush();
//服务端-》客户端 ,客户端读取。。。
String msg = sc.nextLine();
System.out.println("服务端说:"+msg);
socket.close();
}
}
这个例子中，先连接，后写出，后读取。完成了和上述服务器的一个通讯过程。
服务端的改进
为了让服务端能处理多次请求，我们加了一个循环。
package org.yang;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Date;
import java.util.Scanner;
public class ServerV2 {
/**
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
//创建一个服务端套接字，并且在1985端口监听
System.out.println("start start!");
ServerSocket ss = new ServerSocket(1985);
//等待客户连接，如果来了连接就接受，并返回和这个客户通讯的socket
while(true){
Socket socket = ss.accept();
InputStream in = socket.getInputStream();
OutputStream out = socket.getOutputStream();
/*
* 通过一段时间的脑通，我们设计了一个简单协议：
* 客户端->服务端
* 服务端->客户端
*/
//客户端->服务端 ，服务端接受
String ip = socket.getRemoteSocketAddress().toString();
Scanner sc= new Scanner(in);//为了方便读取，用Scanner对输入流做了一个封装
String msg = sc.nextLine();//读取一样
System.out.println("收到消息: "+ ip + " " + msg );
//服务端->客户端 ,输出
PrintWriter pw = new PrintWriter(out);
pw.println(new Date()+"\n");
pw.flush();
socket.close();
}
//System.out.println("finish");
}
//
}
客户端的改进
每次都是发出一样的消息，不满足需求，所以我们先读取用户的输入，然后发出去。
package org.yang;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Scanner;
public class ClientV2 {
/**
* @param args
* @throws IOException
* @throws UnknownHostException
*/
public static void main(String[] args) throws UnknownHostException, IOException {
System.out.print("请输入:");
Scanner sc_console =new Scanner(System.in);
String myMsg = sc_console.nextLine();
//创建一个客户端socket，并且连接
Socket socket = new Socket("114.214.72.203",1985);
//获取输入输出流，并封装
InputStream in = socket.getInputStream();
OutputStream out = socket.getOutputStream();
Scanner sc= new Scanner(in);//为了方便读取，用Scanner对输入流做了一个封装
PrintWriter pw = new PrintWriter(out);
//先发送 客户端-》服务端
pw.println(myMsg);
pw.flush();
//服务端-》客户端 ,客户端读取。。。
String msg = sc.nextLine();
System.out.println("服务端说:"+msg);
socket.close();
}
}
服务端再改进
上面的服务端虽然可以处理多次请求， 但无法同时处理多个请求，这时候，我们需要一个多线程的写法。
package org.yang;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Date;
import java.util.Scanner;
public class ServerV3 {
/**
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
//创建一个服务端套接字，并且在1985端口监听
System.out.println("start start!");
ServerSocket ss = new ServerSocket(1985);
//等待客户连接，如果来了连接就接受，并返回和这个客户通讯的socket
while(true){
final Socket socket = ss.accept();
new Thread(new Runnable(){
public void run() {
processOne(socket);
}
}).start();
}
//System.out.println("finish");
}
public static void processOne(Socket socket){
try {
InputStream in = socket.getInputStream();
OutputStream out = socket.getOutputStream();
//客户端->服务端 ，服务端接受
String ip = socket.getRemoteSocketAddress().toString();
Scanner sc= new Scanner(in);//为了方便读取，用Scanner对输入流做了一个封装
String msg = sc.nextLine();//读取一样
System.out.println("收到消息: "+ ip + " " + msg );
//服务端->客户端 ,输出
PrintWriter pw = new PrintWriter(out);
pw.println(new Date()+"\n");
pw.flush();
socket.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
//
}
客户端的多次发送
为了能持续发送消息，我们加入一个循环
package org.yang;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Scanner;
public class ClientV3 {
/**
* @param args
* @throws IOException
* @throws UnknownHostException
*/
public static void main(String[] args) throws UnknownHostException, IOException {
while(true){
one();
}
}
public static void one(){
try {
System.out.print("请输入:");
Scanner sc_console =new Scanner(System.in);
String myMsg = sc_console.nextLine();
//创建一个客户端socket，并且连接
Socket socket = new Socket("114.214.72.203",1985);
//获取输入输出流，并封装
InputStream in = socket.getInputStream();
OutputStream out = socket.getOutputStream();
Scanner sc= new Scanner(in);//为了方便读取，用Scanner对输入流做了一个封装
PrintWriter pw = new PrintWriter(out);
//先发送 客户端-》服务端
pw.println(myMsg);
pw.flush();
//服务端-》客户端 ,客户端读取。。。
String msg = sc.nextLine();
System.out.println("服务端说:"+msg);
socket.close();
} catch (UnknownHostException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
扫一扫
194
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
