一、建立服务器类
Java中有一个专门用来建立Socket服务器的类，名叫ServerSocket,可以用服务器需要使用的端口号作为参数来创建服务器对象。
ServerSocket server = new ServerSocket(9998)
这条语句创建了一个服务器对象，这个服务器使用9998号端口即在端口9998上注册服务，这里稍微要注意的是端口的分配必须是唯一的。因为端口是为了唯一标识每台计算机唯一服务的，另外端口号是从0~65535之间的，前1024个端口已经被Tcp/Ip 作为保留端口，因此你所分配的端口只能是1024个之后的。当一个客户端程序建立一个Socket连接，所连接的端口号为9998时，服务器对象server便响应这个连接，并且server.accept()方法会创建一个Socket对象。服务器端便可以利用这个Socket对象与客户进行通讯。
Socket incoming = server.accept()// 监听窗口,等待连接
进而得到输入流和输出流,并进行封装
BufferedReader in = new BufferedReader(new
InputStreamReader(incoming.getInputStream()))
/*
当读取文件时，先把内容读到缓存中，当调用in.readLine()时，再从缓存中以字符的方式读取数据（以下简称“缓存字节读取方式”）。
*/
PrintWriter ut = new PrintWriter(incoming.getOutputStream(),true)
随后，就可以使用in.readLine()方法得到客户端的输入，也可以使用out.println()方法向客户端发送数据。从而可以根据程序的需要对客户端的不同请求进行回应。
在所有通讯结束以后应该关闭这两个数据流，关闭的顺序是先关闭输出流，再关闭输入流，即使用
out.close()
in.close()
二、建立客户端代码
相比服务器端，客户端要简单一些，客户端只需用服务器所在机器的ip以及服务器的端口作为参数创建一个Socket对象。得到这个对象后，就可以用"建立服务器"部分介绍的方法实现数据的输入和输出。
Socket socket = new Socket("168.160.12.42",9998)
或：
Socket socket = new Socket(InetAddress.getLocalHost(),5678) // 向主机名为InetAddress.getLocalHost()的服务器申请连接
客户机必须知道有关服务器的IP地址，对于着一点Java也提供了一个相关的类InetAddress 该对象的实例必须通过它的静态方法来提供，它的静态方法主要提供了得到本机IP 和通过名字或IP直接得到InetAddress的方法。
in = new BufferedReader(new InputStreamReader(socket.getInputStream()))
out = new PrintWriter(socket.getOutputStream(),true)
以上的程序代码建立了一个Socket对象，这个对象连接到ip地址为168.160.12.42的主机上、端口为9998的服务器对象。并且建立了输入流和输出流，分别对应服务器的输出和客户端的写入。
三、实例分析
服务方:
import java.io.*
import java.net.*
public class MyServer {
public static void main(String[] args) throws IOException{
ServerSocket server=new ServerSocket(5678) //在端口5678上注册服务
Socket client=server.accept() // 监听窗口,等待连接
BufferedReader in=new BufferedReader(new InputStreamReader(client.getInputStream()))
BufferedReader serverInput=new BufferedReader(new InputStreamReader(System.in))
PrintWriter ut=new PrintWriter(client.getOutputStream())
while(true){
String str=in.readLine() //// 读取从client传来的数据信息
str = serverInput.readLine() // 读取用户键盘输入的字符串
System.out.println(str) //服务器控制台输出数据信息
out.println("has receive....") //服务器向客户端发送信息:has receive....
out.flush()
if(str.equals("end"))
break
}
client.close()
}
}
这个程序的主要目的在于服务器不断接收客户机所写入的信息只到，客户机发送"End"字符串就退出程序，并且服务器也会做出"Receive"为回应，告知客户机已接收到消息。
客户机代码:
import java.net.*
import java.io.*
public class Client{
static Socket server
public static void main(String[] args)throws Exception{
server=new Socket(InetAddress.getLocalHost(),5678)// 向主机名为InetAddress.getLocalHost()的服务器申请连接
BufferedReader in=new BufferedReader(new InputStreamReader(server.getInputStream())) //客户端建立输入流并进行封装
PrintWriter ut=new PrintWriter(server.getOutputStream())
BufferedReader wt=new BufferedReader(new InputStreamReader(System.in)) //客户端从键盘输入信息
while(true){
String str=wt.readLine()//客户端读取（获得）键盘的字符串
String str1=in.readLine() // 从服务器获得字符串
out.println(str) //客户端向服务器发送信息
out.flush()
if(str.equals("end")){
break
}
System.out.println(in.readLine())
}
server.close()
}
}
客户机代码则是接受客户键盘输入,并把该信息输出，然后输出"End"用来做退出标识。
这个程序只是简单的两台计算机之间的通讯，如果是多个客户同时访问一个服务器呢？你可以试着再运行一个客户端，结果是会抛出异常的。那么多个客户端如何实现呢?
其实,简单的分析一下，就可以看出客户和服务通讯的主要通道就是Socket本身，而服务器通过accept方法就是同意和客户建立通讯.这样当客户建立Socket的同时。服务器也会使用这一根连线来先后通讯，那么既然如此只要我们存在多条连线就可以了。那么我们的程序可以变为如下:
服务器:
import java.io.*
import java.net.*
public class MyServer {
public static void main(String[] args) throws IOException{
ServerSocket server=new ServerSocket(5678)
while(true){
Socket client=server.accept()
BufferedReader in=new BufferedReader(new InputStreamReader(client.getInputStream()))
PrintWriter ut=new PrintWriter(client.getOutputStream())
while(true){
String str=in.readLine()
System.out.println(str)
out.println("has receive....")
out.flush()
if(str.equals("end"))
break
}
client.close()
}
}
}
这里仅仅只是加了一个外层的While循环，这个循环的目的就是当一个客户进来就为它分配一个Socket直到这个客户完成一次和服务器的交互，这里也就是接受到客户的"End"消息.那么现在就实现了多客户之间的交互了。但是.问题又来了，这样做虽然解决了多客户,可是是排队执行的。也就是说当一个客户和服务器完成一次通讯之后下一个客户才可以进来和服务器交互，无法做到同时服务，那么要如何才能同时达到既能相互之间交流又能同时交流呢？很显然这是一个并行执行的问题了。所以线程是最好的解决方案。
那么下面的问题是如何使用线程.首先要做的事情是创建线程并使得其可以和网络连线取得联系。然后由线程来执行刚才的操作，要创建线程要么直接继承Thread要么实现Runnable接口，要建立和Socket的联系只要传递引用就可以了.而要执行线程就必须重写run方法，而run方法所做的事情就是刚才单线程版本main所做的事情，因此我们的程序变成了这样:
import java.net.*
import java.io.*
public class MultiUser extends Thread{
private Socket client
public MultiUser(Socket c){
this.client=c
}
public void run(){
try{
BufferedReader in=new BufferedReader(new InputStreamReader(client.getInputStream()))
PrintWriter ut=new PrintWriter(client.getOutputStream())
//Mutil User but can't parallel
while(true){
String str=in.readLine()
System.out.println(str)
out.println("has receive....")
out.flush()
if(str.equals("end"))
break
}
client.close()
}catch(IOException ex){
}finally{
}
}
public static void main(String[] args)throws IOException{
ServerSocket server=new ServerSocket(5678)
while(true){
//transfer location change Single User or Multi User
MultiUser mu=new MultiUser(server.accept())
mu.start()
}
}
}
我的类直接从Thread类继承了下来.并且通过构造函数传递引用和客户Socket建立了联系，这样每个线程就有了。一个通讯管道.同样我们可以填写run方法，把之前的操作交给线程来完成，这样多客户并行的Socket就建立起来了。
用Java实现FTP服务器2004-03-10 02:09 来源：eNet论坛
【简 介】
FTP(File Transfer Protocol 文件传输协议)是Internet 上用来传送文件的协议。在Internet上通过FTP 服务器可以进行文件的上传(Upload)或下载(Download)。FTP是实时联机服务，在使用它之前必须是具有该服务的一个用户(用户名和口令)，工作时客户端必须先登录到作为服务器一方的计算机上，用户登录后可以进行文件搜索和文件传送等有关操作，如改变当前工作目录、列文件目录、设置传输参数及传送文件等。使用FTP可以传送所有类型的文件，如文本文件、二进制可执行文件、图象文件、声音文件和数据压缩文件等。
加入收藏 设为首页
--------------------------------------------------------------------------------
FTP 命令
FTP 的主要操作都是基于各种命令基础之上的。常用的命令有：
◆ 设置传输模式，它包括ASCⅡ(文本) 和BINARY 二进制模式
◆ 目录操作，改变或显示远程计算机的当前目录(cd、dir/ls 命令)
◆ 连接操作，open命令用于建立同远程计算机的连接；close命令用于关闭连接
◆ 发送操作，put命令用于传送文件到远程计算机；mput 命令用于传送多个文件到远程计算机
◆ 获取操作，get命令用于接收一个文件；mget命令用于接收多个文件。
编程思路
根据FTP 的工作原理，在主函数中建立一个服务器套接字端口，等待客户端请求，一旦客户端请求被接受，服务器程序就建立一个服务器分线程，处理客户端的命令。如果客户端需要和服务器端进行文件的传输，则建立一个新的套接字连接来完成文件的操作。
编程技巧说明
1.主函数设计
在主函数中，完成服务器端口的侦听和服务线程的创建。我们利用一个静态字符串变量initDir 来保存服务器线程运行时所在的工作目录。服务器的初始工作目录是由程序运行时用户输入的，缺省为C盘的根目录。
具体的代码如下：
public class ftpServer extends Thread{
private Socket socketClient
private int counter
private static String initDir
public static void main(String[] args){
if(args.length != 0) {
initDir = args[0]
}else{ initDir = "c:"}
int i = 1
try{
System.out.println("ftp server started!")
//监听21号端口
ServerSocket s = new ServerSocket(21)
for(){
//接受客户端请求
Socket incoming = s.accept()
//创建服务线程
new ftpServer(incoming,i).start()
i++
}
}catch(Exception e){}
}
2. 线程类的设计
线程类的主要设计都是在run()方法中实现。用run()方法得到客户端的套接字信息，根据套接字得到输入流和输出流，向客户端发送欢迎信息。
3. FTP 命令的处理
(1) 访问控制命令
◆ user name(user) 和 password (pass) 命令处理代码如下：
if(str.startsWith("USER")){
user = str.substring(4)
user = user.trim()
out.println("331 Password")}
if(str.startsWith("PASS"))
out.println("230 User "+user+" logged in.")
User 命令和 Password 命令分别用来提交客户端用户输入的用户名和口令。
◆ CWD (CHANGE WORKING DIRECTORY) 命令处理代码如下：
if(str.startsWith("CWD")){
String str1 = str.substring(3)
dir = dir+"/"+str1.trim()
out.println("250 CWD command succesful")
}
该命令改变工作目录到用户指定的目录。
◆ CDUP (CHANGE TO PARENT DIRECTORY) 命令处理代码如下：
if(str.startsWith("CDUP")){
int n = dir.lastIndexOf("/")
dir = dir.substring(0,n)
out.println("250 CWD command succesful")
}
该命令改变当前目录为上一层目录。
◆ QUIT命令处理代码如下：
if(str.startsWith("QUIT")) {
out.println("GOOD BYE")
done = true
}
该命令退出及关闭与服务器的连接，输出GOOD BYE。
(2) 传输参数命令
◆ Port命令处理代码如下：
if(str.startsWith("PORT")) {
out.println("200 PORT command successful")
int i = str.length() - 1
int j = str.lastIndexOf(",")
int k = str.lastIndexOf(",",j-1)
String str1,str2
str1=""
str2=""
for(int l=k+1l
str1 = str2 + str.charAt(l)
}
for(int l=j+1l<=il++){
str2 = str2 + str.charAt(l)
}
tempPort = Integer.parseInt(str1) * 16 *16 +Integer.parseInt(str2)
}
使用该命令时，客户端必须发送客户端用于接收数据的32位IP 地址和16位 的TCP 端口号。这些信息以8位为一组，使用十进制传输，中间用逗号隔开。
◆ TYPE命令处理代码如下：
if(str.startsWith("TYPE")){
out.println("200 type set")
}
TYPE 命令用来完成类型设置。
(3) FTP 服务命令
◆ RETR (RETEIEVE) 和 STORE (STORE)命令处理的代码
if(str.startsWith("RETR")){
out.println("150 Binary data connection")
str = str.substring(4)
str = str.trim()
RandomAccessFile outFile = new
RandomAccessFile(dir+"/"+str,"r")
Socket tempSocket = new Socket(host,tempPort)
OutputStream outSocket
= tempSocket.getOutputStream()
byte byteBuffer[]= new byte[1024]
int amount
try{
while((amount = outFile.read(byteBuffer)) != -1){
outSocket.write(byteBuffer, 0, amount)
}
outSocket.close()
out.println("226 transfer complete")
outFile.close()
tempSocket.close()
}
catch(IOException e){}
}
if(str.startsWith("STOR")){
out.println("150 Binary data connection")
str = str.substring(4)
str = str.trim()
RandomAccessFile inFile = new
RandomAccessFile(dir+"/"+str,"rw")
Socket tempSocket = new Socket(host,tempPort)
InputStream inSocket
= tempSocket.getInputStream()
byte byteBuffer[] = new byte[1024]
int amount
try{
while((amount =inSocket.read(byteBuffer) )!= -1){
inFile.write(byteBuffer, 0, amount)
}
inSocket.close()
out.println("226 transfer complete")
inFile.close()
tempSocket.close()
}
catch(IOException e){}
}
文件传输命令包括从服务器中获得文件RETR和向服务器中发送文件STOR，这两个命令的处理非常类似。处理RETR命令时，首先得到用户要获得的文件的名称，根据名称创建一个文件输入流，然后和客户端建立临时套接字连接，并得到一个输出流。随后，将文件输入流中的数据读出并借助于套接字输出流发送到客户端，传输完毕以后，关闭流和临时套接字。
STOR 命令的处理也是同样的过程，只是方向正好相反。
◆ DELE (DELETE)命令处理代码如下：
if(str.startsWith("DELE")){
str = str.substring(4)
str = str.trim()
File file = new File(dir,str)
boolean del = file.delete()
out.println("250 delete command successful")
}
DELE 命令用于删除服务器上的指定文件。
◆ LIST命令处理代码如下：
if(str.startsWith("LIST")) {
try{
out.println("150 ASCII data")
Socket tempSocket = new Socket(host,tempPort)
PrintWriter out2= new PrintWriter(tempSocket.getOutputStream(),true)
File file = new File(dir)
String[] dirStructure = new String[10]
dirStructure= file.list()
String strType=""
for(int i=0i
if( dirStructure[i].indexOf(".") == -1) {
strType = "d "}
else
{strType = "- "}
out2.println(strType+dirStructure[i])
}
tempSocket.close()
out.println("226 transfer complete")
}
catch(IOException e){}
LIST 命令用于向客户端返回服务器中工作目录下的目录结构，包括文件和目录的列表。处理这个命令时，先创建一个临时的套接字向客户端发送目录信息。这个套接字的目的端口号缺省为1，然后为当前工作目录创建File 对象，利用该对象的list()方法得到一个包含该目录下所有文件和子目录名称的字符串数组，然后根据名称中是否含有文件名中特有的“.”来区别目录和文件。最后，将得到的名称数组通过临时套接字发送到客户端。
import java.net.*import java.io.*
public class Server {
private ServerSocket ss
private Socket socket
private BufferedReader in
private PrintWriter out
public Server() {
try {
ss = new ServerSocket(8888)
while (true) {
socket = ss.accept()
in = new BufferedReader(new InputStreamReader(socket
.getInputStream()))
out = new PrintWriter(socket.getOutputStream(), true)
String line = in.readLine()
if("hello".equals(line)){
out.println("hello")
out.close()
}
in.close()
socket.close()
}
ss.close()
} catch (IOException e) {
}
}
public static void main(String[] args) {
new Server()
}
}
欢迎分享，转载请注明来源：夏雨云
微信扫一扫
支付宝扫一扫
评论列表（0条）