OrientShare，Java写的跨平台文件传输软件－服务端

    前两天搞的跨平台文件传输软件，仅限局域网内，功能很简单，算是个Demo吧。

主要功能：

     客户端自动上线；

     服务端自动握手链接；

     服务端向客户端进行文件同步操作；

     文件改变时自动发送。

     最小化到托盘，自动运行。

     三种平台（Win Mac Linux）兼容。

说实话，这个跨平台有点作弊的嫌疑，因为本身就是用Java写的，除了做了点判断平台的操作之外，基本没什么技术含量。

最近事情有点多，过两天整理并贴出代码。见谅。

— — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — 

11月9日22:48更新

注意，这里没有讲怎么用Java的Socket进行编程，这方面的教程已经有人写了，而且肯定比我写的好，所以，这里介绍的是应用Socket、Java中的ClientSocket以及ServerSocket的小例子。🌰

 

程序分为服务端和客户端两部分。

流程如下：

　　服务端有三个线程，分别为：

　　　　BroadcastListener，广播监听线程

　　　　SyncThread，文件同步线程

　　　　SyncFolder，目录监视线程

　　客户端有两个线程，分别是：

　　　　BroadcastListener，广播监听线程

　　　　SyncThread，文件同步线程

　　其中界面线程不算在内，因为界面直接是NetBeans的JFormDesigner做的。😄

　　服务端或者客户端启动后，通过5021端口发送上线消息，同时启动广播监听线程，监听并解析消息。如果服务端捕获到了客户端的上线消息，则进行握手并且发送本地文件。在服务端内由文件同步线程监控同步文件夹内的文件更改。如果发现了文件更改，则对当前所有已连接的客户端发送文件。

 

 

本篇先说服务端。

 

服务端在主函数中调用界面MainFrame的构造函数，启动文件同步线程SyncThread。

这里只给出了主函数，MainFrame是继承的JFrame，在构造函数中增加了点其他的初始化操作，具体是：

　　　　增加了个托盘区的图标（Windows和Mac下可用，图标很丑。。。大家将就看吧，也许本来就不会有人来我这荒草院子～）以及响应事件；
　　　　初始化了各组件的位置和大小；
　　　　启动了主界面更新线程。
　　　　注意，这个主要更新的是服务器当前状态，也就是一个字符串，下面各个类里面如果有StatusString，那就是他了～
　　　　

public static void main(String args[]) throws Exception {
//NetBeans Generate Code.
java.awt.EventQueue.invokeLater(new Runnable() {
            public void run() {
                MainFrame mf;
                mf = new MainFrame();
                mf.setVisible(true);
            }
        });
        sync = new SyncThread();
        sync.start();
｝

　　在SyncThread的构造函数中，做了如下几件事情：

　　　　创建服务端的UUID；构造记录用户IP与UUID的HashMap；

　　　　构造封装好的广播发送类，BroadcastSend sender。

　　　　判断当前操作系统的类型，启动SyncFolder线程；

　　在线程的执行函数中执行如下两个操作：

　　　　循环判断服务器当前状态；

　　　　每隔1s发送消息；（注意，这里有个BUG。）

 

　　发送广播的时候，服务端发送的是最简单的本机的UUID和消息代码，在客户端中，我们发送的广播是比较详细的。

 

package widekuan;

import java.io.IOException;
import java.util.Iterator;
import java.util.Map;
import java.util.Properties;
import java.util.UUID;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 *
 * @author sunkuan
 */
public class SyncThread extends Thread{
    UserMap map;
    BroadcastSend sender;
    BroadcastListenThread listener;
    FileShareServer client;
    String globalUuid;
    String osName;
    SyncFolder Folder;
    /*
     * int status:
     * 0:idle.
     * 1:online.
     * 2:offline.
     */
    int status;
    String FileName;
    public int osFlag;
    public String StatusString;
    
    public SyncThread() throws Exception{
        map = new UserMap();
        globalUuid = UUID.randomUUID().toString();//length:36.
        sender = new BroadcastSend(map,this);
        /*
         * 3:Server is online.
         */
        globalUuid = globalUuid.concat("3");
        sender.SendMessage(globalUuid);
        /*
         * osFlag:
         * 0:Mac
         * 1:Linux
         * 2:Win
         */
        Properties props=System.getProperties();
        osName = props.getProperty("os.name");
        System.out.println(osName);
        if(osName.startsWith("Mac")){
            FileName = "DFT/Send/";  
        }else if(osName.startsWith("Linux")){
            FileName = "DFT/Send/";
        }else if(osName.startsWith("Win")){
            FileName = "DFT\\Send\\";
        }
        Folder = new SyncFolder(FileName,this);
        Folder.start();
        status = 0;
        this.listener = sender.listener;
        StatusString = "Initialize.";
    }
    
    @Override
    public void run(){
        while(true){
            switch(status){
                case 0:
                    //idle.
                    StatusString = "Waiting Client online.";
                    break;
                case 1:
                    //online.
                    StatusString = "Client online";
                    Iterator iterIPID = map.MapIPID.entrySet().iterator(); 
                    
                    //The MapIPID has NO next entry,but the folder is changed. 
                    while (iterIPID.hasNext()){
                        Map.Entry entryIPID = (Map.Entry) iterIPID.next();
                        
                        for(int i = 0;i < Folder.fileList.size();i++){
                                //Creat a new Server.
                            try {
                                StatusString = "Connecting Client @ "+entryIPID.
                                        getValue().toString();
                                client = new FileShareServer(entryIPID.getValue().toString());
                                StatusString = "Connected Client @ "+entryIPID.getKey().toString();
                                client.UUID = entryIPID.getKey().toString();
                                StatusString = "Get respons from client @"+entryIPID.getValue().toString();
                                client.getRespond(Folder.fileList.get(i).getAbsolutePath());
                                //Must have a little nap here.
                                //Or the AcceptFlag can NOT work correctly.
                                Thread.sleep(1000);
                            } catch (Exception ex) {
                                Logger.getLogger(SyncThread.class.getName()).log(Level.SEVERE, null, ex);
                            }
                            StatusString = "Waiting for server accept file.";
                        while(!listener.respondFlag);
                        if(!listener.AcceptFlag){
                            //Wait the client to repond.
                            //If ANY respond recieved,it won't be online here.
                            StatusString = "Client refused file.";
                            client.closeServer();
                            StatusString = "Client @ "+entryIPID.getValue().toString()+"rejected file "+Folder.fileList.get(i).getName();
//                            System.out.println("Rejected.");
                            continue;
                           
                        }else{
                            
                            StatusString = "Client @ "+entryIPID.getValue().toString()+"accepted file "+Folder.fileList.get(i).getName();
//                            System.out.println("Client Accept.");
                            try {
                                StatusString = "Sending file to Client @ "+entryIPID.getValue().toString()+"File name:"+Folder.fileList.get(i).getName();
                                client.Send(Folder.fileList.get(i).getAbsolutePath());
                                client.closeServer();
                                } catch (IOException ex) {
                                    Logger.getLogger(SyncThread.class.getName()).log(Level.SEVERE, null, ex);
                                    }
                                /*
                                 * Make the flag flase here.
                                 * So the next file we need to check that bitch again.
                                 * And that's MAYBE make sense.
                                 */
                                listener.AcceptFlag = false;
                                listener.respondFlag = false;
                        }
                            
                            }
                    }
                    Folder.isChanged = false;
                    System.out.println("All Done.");
                    status = 0;
                    break;
                case 2:
                    //offline.
                    
                    break;
            }
            try {
                StatusString = "Broadcasting online message.";
                Thread.sleep(1000);
                sender.SendMessage(globalUuid);
            } catch (Exception ex) {
                System.out.println(ex.getMessage());
            }
        }
    }

}

 

　　下面是BroadcastSend类，主要负责发送消息，因为服务端需要发送的消息比较少，因此只对这个类进行了最简单的封装。

　　

package widekuan;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

/**
 *
 * @author sunkuan
 */
public class BroadcastSend {
    public DatagramSocket server;// UDP
    private InetAddress broadcastAddress;//Broadcast Addr.
    private int port;// Listen port.
    BroadcastListenThread listener;
    /**
     * 
     * @param UserMap,contains the users' UUID and IP address.
     */
    public BroadcastSend(UserMap usermapArg,SyncThread syncArg){
        try {
            port = 5021;
            server = new DatagramSocket(port);
            broadcastAddress = InetAddress.getByName("255.255.255.255");
            if(listener == null)
            {
                listener = new BroadcastListenThread(server,usermapArg,syncArg);
                listener.start();
            }
        } catch (Exception ex) {
            System.err.println("Socket Connection FAIL");
        }
    }
    public void sendBroadcast(byte[] data, InetAddress address) {
        try {
            DatagramPacket dp = new DatagramPacket(data, data.length, address, port);
            server.send(dp);
        } catch (IOException ex) {
            System.err.println("Send Broadcast FAIL.");
        }
    }    
    /**
     * @param Message need to send.
     * @return void.
     * @exception Exceptions.
     */
    public void SendMessage(String msgArg) throws Exception{
        //String sendMSG = new String("Fuck!");
        sendBroadcast(msgArg.getBytes(), broadcastAddress);
        
    }
}

 

　　文件同步类，SyncFolder，通过文件夹的修改时间来判断其中文件是否有变化。

package widekuan;

import java.io.File;
import java.util.ArrayList;

/**
 *
 * @author sunkuan
 */
public class SyncFolder extends Thread{
    File file;
    ArrayList<File> fileList;
    File[] fileArray;
    String FolderName;
    long lastmodifiedOld;
    boolean isChanged;
    SyncThread syncThread;
    public SyncFolder(String FolderNameArg,SyncThread syncThreadArg){
        FolderName = FolderNameArg;
        file = new File(FolderName);
        lastmodifiedOld = file.lastModified();
        //ScanFile(FolderName);
        isChanged = false;
        syncThread = syncThreadArg;
        
        if(file.isDirectory()){
           fileArray = file.listFiles();
        }else{
            System.err.println("The file name is not a FOLDER!");
        }
        fileList = new ArrayList<File>();
        ScanAllFile(file);
        lastmodifiedOld = file.lastModified();
    }
    /*
     * Don't use this.
     */
    private void ScanFile(String PathArg){
        File searchFile = new File(PathArg);
        if(searchFile.isDirectory()){
           fileArray = file.listFiles();
        }
        fileList = new ArrayList<>();
        for(int i = 0;i < fileArray.length;i++){
            if(fileArray[i].getName().startsWith(".")){
                continue;
            }
            if(fileArray[i].isDirectory()){
                ScanFile(fileArray[i].getName());
            }
            fileList.add(fileArray[i]);
            System.out.println(fileArray[i].getName());
        }
    }
    private void ScanAllFile(File fileArg){
        File[] foo;
        /*
         * We must guarantee the arg is a folder.
         */
        foo = fileArg.listFiles();
        for(int i = 0;i <foo.length;i++){
            if(foo[i].isDirectory()){
                ScanAllFile(foo[i]);
            }else{
                if(!foo[i].getName().startsWith(".")){
                    if(!fileList.contains(foo[i])){
                        fileList.add(foo[i]);
                        System.out.println(foo[i].getAbsoluteFile());
                    }else{
                        continue;
                    }
                }
            }
        }
    }
    @Override
    public void run(){
        while(true){
            try {
                Thread.sleep(5000);
            } catch (InterruptedException ex) {
                continue;
            }
            if(lastmodifiedOld != file.lastModified()){
                //File modify detected.
                ScanAllFile(file);
                lastmodifiedOld = file.lastModified();
                System.err.println("File Changed.");
                isChanged = true;
                syncThread.status = 1;
            }else{
                //No motified files.
                //Do NOTHING here.Modify the boolean in the sync Thread.
                
            }  
            
        }
    }
}

　　万事具备，只欠客户端发来的上线消息了～所以我们需要一个监听客户端发来消息的东东，BroadcastListener。

　　客户端发来的消息都是明码，所以这个代码也就很浅显易懂了。

　　

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package widekuan;

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.util.HashMap;


public class BroadcastListenThread extends Thread{

    private DatagramSocket server;
    public UserMap userMap;
    public HashMap<String,Integer> respondMap;
    private SyncThread sync;
    String msg;
    DatagramPacket dp;
    boolean DoneFlag;
    boolean respondFlag;
    boolean AcceptFlag;
    InetAddress RespondIP;
    public BroadcastListenThread(
            DatagramSocket serverArg, 
            UserMap usermapArg,SyncThread syncArg) throws Exception{
            server = serverArg;
            userMap = usermapArg;
            sync = syncArg;
            AcceptFlag = false;
            DoneFlag = false;
            respondFlag = false;
            RespondIP = null;
            
    }
    
    @Override
    public void run() {
        dp = new DatagramPacket( new byte[1024], 1024);
                while (true) {
                    try {
                            server.receive(dp);
                            //decode broadcast pakage.
                            msg = new String(dp.getData(),
                                                    0, dp.getLength(), "UTF-8");
                    } catch (Exception e) {
                        msg = "";
                    }
                    if(msg.endsWith("online") && !userMap.MapIPID.containsKey(msg)){
                        sync.status = 1;
                        userMap.add(msg, dp.getAddress());
                        System.out.printf("Client count is %d \n",
                                                            userMap.MapIPID.size());
                        //continue;
                    }else if(msg.endsWith("online") && userMap.MapIPID.containsKey(msg)){
                        //Client send a useless online message.
                        //continue;
                    }else if(msg.length()<36||msg.length() == 36){
                        //No client here.
                        sync.status = 0;
                        continue;
                    }else if(msg.endsWith("offline")){
                        System.out.println("Client offline.");
//                        userMap.remove(msg,dp.getAddress());
//                        if(userMap.MapIPID.isEmpty()){
//                            sync.status = 2;
//                        }
                        
                        //Modify the HashMap .
                        //So the server won't send file to it.
                        //The orignal version has a wrong String.
                        userMap.remove(msg.replaceAll("offline", "online"), RespondIP);
                        continue;
                    }else if(msg.endsWith("accept")){
                        //Client Accept the file.
                        //System.out.println(msg);
                        AcceptFlag = true;
                        RespondIP = dp.getAddress();
                        respondFlag = true;
                        continue;
                    }else if(msg.endsWith("reject")){
                        AcceptFlag = false;
                        RespondIP = dp.getAddress();
                        respondFlag = true;
                        continue;
                    }else if(msg.endsWith("done")){
                        DoneFlag = true;
                        respondFlag = false;
                        AcceptFlag = false;
                        continue;
                    }else if(msg.endsWith("done")){
                        DoneFlag = true;
                        respondFlag = false;
                        AcceptFlag = false;
                        continue;
                    }
                }
        }
    
}

 

　　由BroadcastListener的功能可知，这个线程只是根据客户端发来的消息更改了几个“Flag”变量，那么，这几个“Flag”变量是怎么被应用的呢？让我们回头看下SyncThread 的执行函数。我们会发现，在case 1（客户端上线）中，有两个个判断。首先是判断当前有木有客户端连接上，如果木有，则继续等待；如果有，则循环发送文件列表中的所有文件。发送文件的过程中，则又有一个问题。如果客户端不想要这个文件怎么办呢？我们不能强塞给人家啊，所以就需要一个AcceptFlag。服务端首先发送的是文件名以及文件大小（当然这个完全可以用MD5和Hash值替代啊～），然后由客户端判断这个文件是不是我们所要的。如果文件重复的话（光靠文件名和大小是不能判断重复的！这里只是做个演示啊！），则拒绝该文件，这时服务端的AcceptFlag当然是false。如果客户端接受文件的话，AcceptFlag显然就为true了，我们就可以调用FlieShareServer去发送文件了。当然，不管是客户端拒绝还是接受，总得给个回应是吧，这就是respondFlag的用处，首先先判断下客户端是否发送回应给我们。这个标识位是用于扩展程序功能以及防止丢包的。

　　那么，FileShareServer是怎么发送文件的呢？下面的代码就是答案。

package widekuan;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

/**
 *
 * @author sunkuan
 */
public class FileShareServer {
    private String SERVER_IP;
    private static final int SERVER_PORT = 5020;
     
    private ServerSocket server;
    private Socket client;
    //private DataInputStream dis;
    private DataInputStream fis;
    private DataOutputStream dos;
    public int osFlag;
    String UUID;
    public float progress;
    public FileShareServer(String IPArg) throws IOException{
        SERVER_IP = IPArg.substring(1, IPArg.length());
        //System.out.println("try to connect server.");
        if(server == null){
            server = new ServerSocket(SERVER_PORT);
        }
        //System.out.println("Connected.");
    }
    
    
    public void Send(String FileNameArg) throws IOException{
        File carbageFile = new File(FileNameArg);
        //dis = new DataInputStream(new BufferedInputStream(client.getInputStream()));
        fis = new DataInputStream(new BufferedInputStream(new FileInputStream(FileNameArg)));
        //dos = new DataOutputStream(client.getOutputStream());
        dos = new DataOutputStream(new BufferedOutputStream(client.getOutputStream()));
        //Send the File name and length again?
//        dos.writeUTF(carbageFile.getName());
//        dos.flush();
//        dos.writeLong((long) carbageFile.length());
//        dos.flush();
        int bufferSize = 8192;
        byte[] buffer = new byte[bufferSize];
        while (true) {
            int read = 0;
            if (fis != null) {
                read = fis.read(buffer);
            }
            if (read == -1) {
                break;
            }
            dos.write(buffer, 0, read);
            progress += (float) ((bufferSize/carbageFile.length())*100);
        }
        dos.flush();
        fis.close();
        client.close();
        server.close();
        System.out.println("Done.");
    }
    
    /*
     * Send the filename and length,and wait for the client to response
     * in the SyncThread.
     */
    public void getRespond(String FileNameArg) throws IOException{
        File carbageFile = new File(FileNameArg);
        client = server.accept();
        fis = new DataInputStream(new BufferedInputStream(new FileInputStream(FileNameArg)));
        dos = new DataOutputStream(new BufferedOutputStream(client.getOutputStream()));
        dos.writeUTF(carbageFile.getName());
        dos.flush();
        dos.writeLong((long) carbageFile.length());
        dos.flush();
    }
    public void closeServer(){
        try {
            server.close();
        } catch (IOException ex) {
            System.err.println("Server Closed ERROE");
        }
    }
}

　　我们可以看到，在getRespond这个函数中我们只发送了文件名和大小，然后交给客户端去判断。实际上，这个地方改称哈希值要更好些。

 

　　对了，上文中的UserMap就是个HashMap，之所以封装一下是为了以后拓展一些功能。

 

　　服务端到这里基本就结束了，Quite simple～？

 

PS.第一次在博客园发文章，写的不好，见谅。之前主页里面还有一些东西，不过空间都已经删了，而且自己的地盘，写起来总是有点肆无忌惮，不提了。

PPS.最近复习的跟shi一样。。。也不是没有努力，只是感觉自己好笨。数学学不好也许只有一辈子当码农了，玩不了什么高级的东西了。

PPPS.客户端的代码近期内贴出来，并且最后会打包发到pudn上。