`
wxq594808632
  • 浏览: 262793 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

CS结构软件自动升级实现（三）

数据结构软件测试SocketGoF# 
阅读更多

原文:http://www.blogjava.net/rochoc/archive/2009/01/09/250740.html

 

AUpdSrvProc.java服务端服务线程，关键代码之一：

 

/** *//********************************************************************
   * 项目名称                ：rochoc<p>
   * 包名称                  ：com.rochoc.autoupdate<p>
   * 文件名称                ：AUpdSrvProc.java<p>
   * 编写者                 ：kfzx-luoc<p>
   * 编写日期                ：2008-12-22<p>
   * 程序功能（类）描述    ：<p>
   * 自动更新服务端处理进程
   * 程序变更日期            ：
  * 变更作者                ：
  * 变更说明                ：
 ********************************************************************/
 package com.rochoc.autoupdate;
 
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.io.StringReader;
 import java.net.Socket;
 import java.util.HashMap;
 
 /** *//**
  * @author kfzx-luoc
  *
  * TODO To change the template for this generated type comment go to
  * Window - Preferences - Java - Code Style - Code Templates
  */
 public class AUpdSrvProc extends Thread
 {
     private Socket socket = null;
     private InputStream socketIn;
     private OutputStream socketOut;    
     private Config config = Config.getInstance();//配置文件对像
     private ClientVerParser cvPaser = null;
     private HashMap cFiles = new HashMap();
     
     byte bFlag [] = new byte[1];//标识位
     byte bCmd[] = new byte[8];//命令
     
     public AUpdSrvProc(Socket socket)
     {
         this.socket = socket;
     }    
    /** *//**
      * 接收客户端的升级请求，并进行处理
      */
     public void run()
     {
         try
         {
             config.refresh();//重新更新配置信息
             socketIn = socket.getInputStream();
             socketOut = socket.getOutputStream();
             byte datahead [] = new byte[5];//数据头部，第一位用于标识是数据，后四位为长度
             byte buffer[] = new byte[AUPD.BUFFER_SIZE];//存放数据头部和数据头部
             byte data[] = new byte[AUPD.DATA_SIZE];//存放具体的数据内容    
             while(true)
             {
                 //读取标志位
                 int len = socketIn.read(bFlag,0,1);
                 if(len!=1)
                 {
                     Config.print(socket.getInetAddress()+":读取标识位失败");
                     socketOut.write(Config.getCmd(AUPD.BYE));//结束
                     break;
                 }
                 if(bFlag[0]==AUPD.CMD_DATA_SECT)//命令行
                 {
                     len = socketIn.read(bCmd,0,8);
                     if(len!=8)
                     {
                         Config.print(socket.getInetAddress()+":读取命令失败,CMD="+bCmd);
                         socketOut.write(Config.getCmd(AUPD.BYE));//结束
                         break;
                     }
                     if(Config.parseCmd(bCmd).equals(AUPD.READY_TO_UPDATE))//客户端已经准备好更新了
                     {
                         Config.print(socket.getInetAddress()+":客户端已经准备好接收更新文件");
                         int ret = sendUpdateFile();
                         switch(ret)
                         {
                             case 0:
                                 socketOut.write(Config.getCmd(AUPD.UPDATED_FAILURE));//失败
                             break;
                             case 1:
                                 socketOut.write(Config.getCmd(AUPD.UPDATED_SUCCESSFUL));//成功
                             break;
                             default:
                                 socketOut.write(Config.getCmd(AUPD.NOTNEED_UPDATED));//无需更新
                             break;
                         }
                     }else if(Config.parseCmd(bCmd).equals(AUPD.BYE))//结束链接
                     {
                         socketOut.write(Config.getCmd(AUPD.BYE));//结束
                         break;
                     }
                 }else if(bFlag[0]==AUPD.MARK_DATA_SECT || bFlag[0]==AUPD.MARK_DATA_END)//数据内容
                {
                    if(Config.parseCmd(bCmd).equals(AUPD.SEND_CLIENT_VERSION))//进行版本信息接收处理
                   {
                        receiveClientVer(bFlag[0]);
                   }else
                    {
                        Config.print("出现非期望数据,"+new String(bCmd));
                        socketOut.write(Config.getCmd(AUPD.BYE));//结束
                        break;
                    }
                }else
                {
                    Config.print(socket.getInetAddress()+":非期望标识位,"+bFlag[0]);
                    socketOut.write(Config.getCmd(AUPD.BYE));//结束
                    break;
                }
            }//END while(ture)
            //关闭资源
            socketIn.close();
            socketOut.close();
            socket.close();
        } catch (IOException e)
        {
            Config.print("处理客户端升级请求失败,"+socket.getInetAddress()+","+e);
            e.printStackTrace();
        }        
    }
    /** *//**
    * 方法名称：sendUpdateFile<p>
     * 方法功能：<p>
     * 参数说明：<p>
     * 返回：int<p>
     * 作者：kfzx-luoc
     * 日期：2008-12-23
     * @return 0.更新失败 1.更新成功 2.无需更新
     */
    private int sendUpdateFile()
    {
        try
        {
            //检查服务器和客户端版本号是否一致，如果一致辞，则无需升级
            if (config.getVerstion().equals(cvPaser.getVerstion()))
            {           
                Config.print(socket.getInetAddress()+":版本一致，无需更新");                
                return 2;
            }
            //开始进行处理
            UpdFile srvFiles [] = config.getFiles();
            boolean isSuccess = true;
            for(int i=0;i<srvFiles.length;i++)
            {
                UpdFile cf = (UpdFile)cFiles.get(srvFiles[i].getName());
                //文件不存在或版本号不一致则需要更新该文件
                if(cf==null || !cf.getVersion().equals(srvFiles[i].getVersion()))
                {
                    if(!sendFile(srvFiles[i]))
                    {
                        isSuccess = false;
                    }                    
                }
            }//END for
            //发送版本信息文件，发送更新信息文件
            if(isSuccess)
            {
                UpdFile verFile = new UpdFile("autoupdate.xml");
                verFile.setPath("." + File.separator + "config");
                verFile.setType(0);
               verFile.setVersion(config.getVerstion());
                if(!sendFile(verFile))
                {
                    Config.print(socket.getInetAddress()+":发送版本文件失败");
                    return 0;
                }
                //发送更新信息
                UpdFile infFile = new UpdFile("history.htm");
                infFile.setPath("." + File.separator + "config");
                infFile.setType(0);
                infFile.setVersion(config.getVerstion());
                if(!sendFile(infFile))
                {
                    Config.print(socket.getInetAddress()+":发送最新信息失败");
                }
                return 1;
            }else
            {
               return 0;
            }
        }catch(Exception e)
        {
            Config.print("处理需要更新文件失败,"+e);
            e.printStackTrace();
            return 0;
        }
    }
    //0.失败 1.成功
    private boolean sendFileAbsPath(String path)
    {
        try
        {
            byte buffer[] = new byte[AUPD.BUFFER_SIZE];
            int len = 0;
            //标识为数据段
            buffer[0] = AUPD.MARK_DATA_SECT;
            Config.copyArray(buffer, Config.getLen(path.getBytes().length), 1, 0, 4);//4位长度
            //组合数据包
            for (int i = 0; i < path.getBytes().length; i++)
                buffer[i + 5] = path.getBytes()[i];
            socketOut.write(buffer, 0, path.getBytes().length + 5);//前五位为头部1位标识+4位长度
            //标识为数据段已结束，并发送至服务器
            buffer[0] = AUPD.MARK_DATA_END;
            socketOut.write(buffer, 0, 1);
            socketOut.flush();
            //检查客户端是否收到            
            len = socketIn.read(bFlag,0,1);
            if(len!=1)
            {
                Config.print(socket.getInetAddress()+":读取标识位失败");
                socketOut.write(Config.getCmd(AUPD.BYE));//结束
                return false;
            }
            //读取命令
           len = socketIn.read(bCmd,0,8);
            if(len!=8)
            {
                Config.print(socket.getInetAddress()+":读取命令失败,CMD="+bCmd);
                socketOut.write(Config.getCmd(AUPD.BYE));//结束
                return false;
            }
            if(Config.parseCmd(bCmd).equals(AUPD.RECEIVED_FILE_ABSOULT))//成功
            {
                Config.print(socket.getInetAddress()+":接收文件路径成功,"+path);
                return true;
            }else if(Config.parseCmd(bCmd).equals(AUPD.BYE))//失败
            {
                Config.print(socket.getInetAddress()+":接收文件路径失败，"+path);
                return false;
            }else//异常
            {
                return false;
            }            
        }catch(Exception e)
        {
            Config.print(socket.getInetAddress()+":发送文件路径失败,"+path);
            e.printStackTrace();
            return false;
        }
    }
    //false.失败 true.成功
    private boolean sendFile(UpdFile file)
    {
       try
       {
           File f = new File(Config.formatPath(file.getPath())+file.getName());
           if(!f.exists()||!f.isFile())
           {
               Config.print(file+",不存在，无法更新");
               return false;
           }
           Config.print(socket.getInetAddress()+":开始传输文件>>"+file);
           socketOut.write(Config.getCmd(AUPD.SEND_FILE_ABSOULT));//发送文件全路径
           String fileAbsPath = Config.formatPath(file.getPath())+file.getName();
           if(!sendFileAbsPath(fileAbsPath))
          {
               return false;
           }
           socketOut.write(Config.getCmd(AUPD.START_TRANSMIT));//开始传输
           FileInputStream fin = new FileInputStream(f);
           //文件数据缓冲区
           byte[] data = new byte[AUPD.DATA_SIZE];
           // 发送数据缓冲区
           byte[] buffer = new byte[AUPD.BUFFER_SIZE];
           int len = -1;
           while ((len=fin.read(data)) != -1)
            {
                // 标识为数据段
                buffer[0] = AUPD.MARK_DATA_SECT;
                Config.copyArray(buffer,Config.getLen(len),1,0,4);//存放长度
                // 组合数据包
                for (int i=0; i<len; i++)
                    buffer[i+5] = data[i];
                socketOut.write(buffer,0,len+5);
            }
           // 标识为数据段已结束，并发送至服务器
            buffer[0] = AUPD.MARK_DATA_END;            
          socketOut.write(buffer,0,1);
            socketOut.flush();
            fin.close();
            //判断客户端是否收到
            len = socketIn.read(bFlag,0,1);
            if(len!=1)
            {
                Config.print(socket.getInetAddress()+":读取标识位失败");
                socketOut.write(Config.getCmd(AUPD.BYE));//结束
                return false;
            }
            //读取命令
            len = socketIn.read(bCmd,0,8);
            if(len!=8)
            {
                Config.print(socket.getInetAddress()+":读取命令失败,CMD="+new String(bCmd));
                socketOut.write(Config.getCmd(AUPD.BYE));//结束
               return false;
           }
            if(Config.parseCmd(bCmd).equals(AUPD.TERMINATE_TRANSMIT))//成功
            {
                Config.print(socket.getInetAddress()+":传输文件'"+file+"'成功");
                return true;
            }else if(Config.parseCmd(bCmd).equals(AUPD.BYE))//失败
            {
                Config.print(socket.getInetAddress()+":传输文件失败，"+file);
                return false;
            }else//异常
            {
                Config.print(socket.getInetAddress()+":传输文件异常，"+file+","+new String(bCmd));
                return false;
           } 
       }catch(Exception e)
       {
           Config.print("传输文件'"+file+"'失败,"+e);
           e.printStackTrace();
           return false;
       }
    }
    private void receiveClientVer(byte flag)//第一位表示是数据内容还是结束内容
    {
        try
        {
            //接收数据缓冲区
            byte flagb[] = new byte[1];//标志
            byte lenb [] = new byte[4];//长度
            //接收版本号信息
            StringBuffer strBuf = new StringBuffer();//用于接收信息
            int len = -1;
           boolean isFirst = true;
           boolean isOk = false;        
            flagb[0] = flag;
            while(true)
            {
                //第一次
                if(isFirst)
                {
                    isFirst = false;        
                }else
                {
                    len = socketIn.read(flagb,0,1);//读取标识位
                    if(len != 1)
                    {
                        Config.print(socket.getInetAddress() + ":读取数据标识位失败");
                        break;
                    }
                }
                //读取数据长度
                if(flagb[0]==AUPD.MARK_DATA_SECT)
               {
                    len = socketIn.read(lenb, 0, 4);
                    if (len != 4)
                    {
                        Config.print(socket.getInetAddress() + ":读取数据头部失败");
                        break;
                    }
                }
                if (flagb[0] == AUPD.MARK_DATA_SECT)//数据内容
                {
                   int cLen = Integer.parseInt(new String(lenb, 0, 4));//数据内容长度
                    byte data[] = new byte[cLen];
                    len = socketIn.read(data, 0, cLen);
                   int totLen = len;
                    while (totLen < cLen)//不足位要重重读取
                    {
                        strBuf.append(new String(data, 0, len));
                       len = socketIn.read(data, 0, cLen - totLen);
                        totLen = totLen + len;
                    }
                    strBuf.append(new String(data, 0, len));
                }else if(flagb[0]==AUPD.MARK_DATA_END)//数据结束
                {
                    isOk = true;
                    break;
                }else
                {
                    Config.print(socket.getInetAddress()+":收到非期望数据,"+new String(flagb,0,1)+"<<");
                    break;
                }
            }//END while(true)
            if(isOk)//成功
            {
                socketOut.write(Config.getCmd(AUPD.RECEIVED_CLIENT_VERSION));//临时测试
                Config.print("接收客户端" + socket.getInetAddress() + " 版本信息成功");
                cvPaser = new ClientVerParser(new StringReader(strBuf
                        .toString()));
                UpdFile files[] = cvPaser.getFiles();
                for (int i = 0; i < files.length; i++)
                {
                    cFiles.put(files[i].getName(), files[i]);
                }
            }else//失败
            {
                socketOut.write(Config.getCmd(AUPD.BYE));//结束
            }
        }catch(Exception e)
        {
            Config.print("接收客户端"+socket.getInetAddress()+" 版本号信息处理失败,"+e);
        }
    }    
}

 

AutoUpdateClient.java客户端升级处理进程，关键代码之二：

 

/** *//********************************************************************
   * 项目名称                ：rochoc<p>
   * 包名称                  ：com.rochoc.autoupdate<p>
   * 文件名称                ：AutoUpdateClient.java<p>
   * 编写者                 ：kfzx-luoc<p>
   * 编写日期                ：2008-12-23<p>
   * 程序功能（类）描述    ：<p>
   * 自动升级客户端对像
   * 程序变更日期            ：
  * 变更作者                ：
  * 变更说明                ：
 ********************************************************************/
 package com.rochoc.autoupdate;
 
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.net.Socket;
 
 /** *//**
  * @author kfzx-luoc
  *
  * TODO To change the template for this generated type comment go to
  * Window - Preferences - Java - Code Style - Code Templates
  */
 public class AutoUpdateClient
 {
     private Socket socket = null;
     private OutputStream socketOut;
     private InputStream socketIn;
     private Config config = Config.getInstance();//配置文件对像
     private String currFileAbs = "";//当前更新文件的全路径
     public AutoUpdateClient()
     {
         try
         {
             socket = new Socket(config.getServerIp(),Integer.parseInt(config.getServerPort()));
             socket.setSoTimeout(30000);//30秒
         }catch(Exception e)
         {
             Config.print("创建与自动升级服务器之间的连接失败,"+e);
             e.printStackTrace();
         }
     }
     public void update()
     {
         if(socket == null)
         {
             Config.print("无法与服务器连接，升级失败");
             return;
         }
         try
         {
             socketOut = socket.getOutputStream();
             socketIn = socket.getInputStream();      
             
             //开始升级处理
             byte flag [] = new byte[1];
             byte cmd[] = new byte[8];//命令
             byte datahead [] = new byte[5];//数据头部，第一位用于标识数据，后四位为长度
             byte buffer[] = new byte[AUPD.BUFFER_SIZE];//存放数据头部和数据头部
             byte data[] = new byte[AUPD.DATA_SIZE];//存放具体的数据内容            
             //发送本地版本信息给服务器                
             socketOut.write(Config.getCmd(AUPD.SEND_CLIENT_VERSION));//发送传输版本信息命令
             sendClientVer();//发送版本信息
             while(true)
             {
                 //读取信息
                 int len = socketIn.read(flag,0,1);
                 if(len!=1)
                 {
                     Config.print("读取标识位失败");
                     socketOut.write(Config.getCmd(AUPD.BYE));//结束
                    break;
                 }
                 if(flag[0]==AUPD.CMD_DATA_SECT)//命令行
                 {
                     len = socketIn.read(cmd,0,8);
                     if(len!=8)
                     {
                         Config.print("读取命令失败");
                         socketOut.write(Config.getCmd(AUPD.BYE));//结束
                         break;
                     }
                     if(Config.parseCmd(cmd).equals(AUPD.RECEIVED_CLIENT_VERSION))//收到版本信息
                     {
                         Config.print("服务器成功收到版本信息");
                         socketOut.write(Config.getCmd(AUPD.READY_TO_UPDATE));
                         continue;
                     }else if(Config.parseCmd(cmd).equals(AUPD.SEND_FILE_ABSOULT))//接收文件全路径
                     {
                         Config.print("开始接收文件路径名");                      
                     }else if(Config.parseCmd(cmd).equals(AUPD.UPDATED_FAILURE))//更新失败
                     {
                         Config.print("版本更新失败");
                         socketOut.write(Config.getCmd(AUPD.BYE));//结束
                         break;
                    }else if(Config.parseCmd(cmd).equals(AUPD.UPDATED_SUCCESSFUL))//更新成功
                    {
                        Config.print("版本更新成功");
                        socketOut.write(Config.getCmd(AUPD.BYE));//结束
                        //打开最新信息
                        openFile(".\\config\\history.htm");
                        break;
                    }else if(Config.parseCmd(cmd).equals(AUPD.NOTNEED_UPDATED))//无需更新
                    {
                        Config.print("已经是最新版本，无需更新");
                        socketOut.write(Config.getCmd(AUPD.BYE));//结束
                       break;
                    }else if(Config.parseCmd(cmd).equals(AUPD.BYE))//结束链接
                    {
                       socketOut.write(Config.getCmd(AUPD.BYE));//结束
                        break;
                    }
                }else if(flag[0]==AUPD.MARK_DATA_SECT || flag[0]==AUPD.MARK_DATA_END)//数据内容
                {
                    if(Config.parseCmd(cmd).equals(AUPD.SEND_FILE_ABSOULT))//接收文件全路径
                     {
                        currFileAbs = receiveFileAbsPath(flag[0]);
                        if(currFileAbs!=null && !currFileAbs.equals(""))//成功
                        {
                            socketOut.write(Config.getCmd(AUPD.RECEIVED_FILE_ABSOULT));
                            Config.print("接收文件全路径‘"+currFileAbs+"’成功");
                        }else
                        {
                            Config.print("接收文件全路径失败");
                            socketOut.write(Config.getCmd(AUPD.BYE));//结束
                            break;
                        }
                   }else if(Config.parseCmd(cmd).equals(AUPD.START_TRANSMIT))//接收文件
                    {
                        if(receiveFile(flag[0]))
                        {
                            socketOut.write(Config.getCmd(AUPD.TERMINATE_TRANSMIT));
                        }else
                        {
                            socketOut.write(Config.getCmd(AUPD.BYE));
                        }
                    }else
                    {
                        Config.print("出现非期望数据,"+new String(cmd));
                       socketOut.write(Config.getCmd(AUPD.BYE));//结束
                       break;
                    }
                }else
                {
                    Config.print("非期望标识位,"+flag[0]);
                    socketOut.write(Config.getCmd(AUPD.BYE));//结束
                    break;
                }
            }//END while(true)
            
           //关闭资源及链接
            socketOut.close();
            socketIn.close();
            socket.close();
            Config.print("自动升级处理完毕");
        }catch(Exception e)
        {
           Config.print("升级处理失败,"+e);
            e.printStackTrace();
        }
    }
    private void openFile(String file)
    {
        try
       {
            Runtime.getRuntime().exec("cmd /c "+file);
        }catch(Exception e)
        {
            e.printStackTrace();
        }
    }
    private String receiveFileAbsPath(byte flag)
    {
        String absPath = "";
        //接收文件全路径
        try
       {
            //接收数据缓冲区
            byte flagb[] = new byte[1];//标志
            byte lenb [] = new byte[4];//长度
            //接收文件全路径
            StringBuffer strBuf = new StringBuffer();//用于接收信息
           int len = -1;
            boolean isFirst = true;
            boolean isOk = false;        
            flagb[0] = flag;
            while(true)
            {
                //第一次
               if(isFirst)
                {
                    isFirst = false;        
                }else
                {
                    len = socketIn.read(flagb,0,1);//读取标识位
                    if(len != 1)
                    {
                        Config.print(socket.getInetAddress() + ":读取数据标识位失败");
                        break;
                    }
                }
               //读取数据长度
                if(flagb[0]==AUPD.MARK_DATA_SECT)
                {
                    len = socketIn.read(lenb, 0, 4);
                    if (len != 4)
                    {
                        Config.print(socket.getInetAddress() + ":读取数据头部失败");
                   break;
                    }
                }
                if (flagb[0] == AUPD.MARK_DATA_SECT)//数据内容
                {
                    int cLen = Integer.parseInt(new String(lenb, 0, 4));//数据内容长度
                    byte data[] = new byte[cLen];
                    len = socketIn.read(data, 0, cLen);
                    System.out.println("len:"+len+"cLen="+cLen+">>"+new String(data,0,len));
                    int totLen = len;
                   while (totLen < cLen)//不足位要重重读取
                    {
                        strBuf.append(new String(data, 0, len));
                        len = socketIn.read(data, 0, cLen - totLen);
                        totLen = totLen + len;
                        System.out.println("len:"+len+"cLen="+cLen);
                    }
                    strBuf.append(new String(data, 0, len));
                }else if(flagb[0]==AUPD.MARK_DATA_END)//数据结束
              {
                    isOk = true;
                    break;
                }else
                {
                    Config.print(socket.getInetAddress()+":收到非期望数据,"+new String(flagb,0,1)+"<<");
                    break;
                }
            }//END while(true)
            if(isOk)//成功
           {            
                absPath = strBuf.toString();
          }else//失败
            {
                socketOut.write(Config.getCmd(AUPD.BYE));//结束
            }
      }catch(Exception e)
        {
            Config.print("接收文件全路径处理失败,"+e);
        }
        return absPath;
   }
    private boolean receiveFile(byte flag)
   {
       try
        {
           if(currFileAbs==null||currFileAbs.equals(""))
            {
                Config.print("无法获取更新文件信息，更新失败");
               return false;
            }
            File file;
           //先检查目录是否存在
            //得到目录
            int idx = currFileAbs.lastIndexOf(File.separator);
           String path = currFileAbs.substring(0,idx);
            file = new File(path);
            if(!file.isDirectory() || !file.exists())
            {
                Config.print("新创建目录:"+path);
                file.mkdir();
            }
           file = new File(currFileAbs);
            FileOutputStream fout = new FileOutputStream(file);
            //接收数据缓冲区
            byte flagb[] = new byte[1];//标志
            byte lenb [] = new byte[4];//长度
            int len = -1;
            boolean isFirst = true;
            boolean isOk = false;
            flagb[0] = flag;
            //接收上传的文件数据
            while (true)
            {
                //第一次
                if(isFirst)
                {
                    isFirst = false;        
                }else
              {
                    len = socketIn.read(flagb,0,1);//读取标识位
                    if(len != 1)
                    {
                        Config.print(socket.getInetAddress() + ":读取数据标识位失败");
                       break;
                    }
              }
                //读取数据长度
                if(flagb[0]==AUPD.MARK_DATA_SECT)
                {
                    len = socketIn.read(lenb, 0, 4);
                    if (len != 4)
                    {
                        Config.print(socket.getInetAddress() + ":读取数据头部失败");
                        break;
                    }
                }
                if (flagb[0] == AUPD.MARK_DATA_SECT)//数据内容
               {
                    int cLen = Integer.parseInt(new String(lenb, 0, 4));//数据内容长度
                   byte data[] = new byte[cLen];
                    len = socketIn.read(data, 0, cLen);
                    int totLen = len;
                   while (totLen < cLen)//不足位要重重读取
                    {
                       fout.write(data,0,len);
                        len = socketIn.read(data, 0, cLen - totLen);
                        totLen = totLen + len;
                  }
                    fout.write(data,0,len);
                }else if(flagb[0]==AUPD.MARK_DATA_END)//数据结束
                {
                    isOk = true;
                    break;
                }else
                {
                    Config.print(socket.getInetAddress()+":收到非期望数据,"+new String(flagb,0,1)+"<<");
                    break;
                }
            }//END while
            fout.flush();
           fout.close();
            if(isOk)
            {
                Config.print("成功更新文件："+file.getAbsolutePath());
                return true;
            }else
            {
                Config.print("更新文件："+file.getAbsolutePath()+"失败");                
                return false;
            }
        }catch(Exception e)
        {
            Config.print("下载更新文件'"+currFileAbs+"'失败,"+e);
            e.printStackTrace();
            return false;
        }
    }
    //发送客户端版本信息
    private void sendClientVer()
    {
        try
      {
            File verFile = new File(Config.cfgFile);
            if(!verFile.isFile() || !verFile.exists())
            {
                Config.print("版本信息文件不存在");
                return;
            }
            //开始发送
            FileInputStream fis = new FileInputStream(verFile);
           byte buffer[] = new byte[AUPD.BUFFER_SIZE];
           byte data[] = new byte[AUPD.DATA_SIZE];
           int len = 0;
            while((len=fis.read(data))!=-1)
            {
               //标识为数据段
                buffer[0] = AUPD.MARK_DATA_SECT;
               Config.copyArray(buffer,Config.getLen(len),1,0,4);//4位长度
                //组合数据包
                for (int i=0; i<len; i++)
                    buffer[i+5] = data[i];//前五位为头部1位标识+4位长度
                socketOut.write(buffer,0,len+5);//发送数据
            }//END while
            //标识为数据段已结束，并发送至服务器
            buffer[0] = AUPD.MARK_DATA_END;
            socketOut.write(buffer,0,1);
            socketOut.flush();
            fis.close();
            Config.print("版本信息传送完毕");
      }catch(Exception e)
        {
            Config.print("发送版本信息给服务器失败,"+e);
            e.printStackTrace();
       }
    }    
    //测试主流程
    public static void main(String args[])
    {
        AutoUpdateClient client = new AutoUpdateClient();
        client.update();
    }
}
 
分享到：
| CS结构软件自动升级实现（二）
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    CS结构自动升级模块（vb.net）

    CS结构自动升级模块是软件开发中的一个重要组成部分，尤其是在桌面应用（Client-Server，简称CS结构）中。VB.NET是一种流行的编程语言，常用于构建这样的应用程序。这个模块的主要目的是确保用户始终运行的是最新...

    面向CS模式下的客户端软件自动升级的实现.rar

    以上是对基于CS模式客户端软件自动升级实现的全面解析，涵盖了从检测更新到安全验证，再到实际升级和用户体验的各个环节。通过理解并应用这些知识点，开发者可以构建出高效、可靠的自动升级系统，为用户提供无缝的...

    用C_实现CS模式下软件自动在线升级

    【C#实现CS模式下软件自动在线升级】 在C/S（Client/Server）架构的软件中，维护性和升级便利性一直是开发者面临的重要挑战。传统的手动升级方式效率低下，且随着软件规模的扩大，升级成本逐渐增加。为了解决这一...

    用C# 实现CS模式下软件自动在线升级.doc

    【C#实现CS模式下软件自动在线升级】 在C/S（Client/Server）模式的应用程序中，由于客户端软件需要在用户设备上安装，因此维护和升级通常是一项挑战。手动升级不仅耗时，而且可能导致用户数据丢失或软件版本不一致...

    用C#实现C/S模式下软件自动在线升级

    在C/S（客户端/服务器）模式下，软件自动在线升级是一项...总之，实现C/S模式下的软件自动在线升级涉及网络请求、XML解析、文件下载和安装等多个步骤。通过合理的代码组织和错误处理，可以为用户提供无缝的更新体验。

    cs系统在线升级

    【cs系统在线升级】是指在Client/Server(C/S)架构的软件中实现自动在线更新的能力。C/S模式的软件在维护、部署和升级方面存在挑战，导致一些企业倾向于选择Browser/Server(B/S)结构。然而，对于那些必须采用C/S模式...

    JAVA CS SWT RCP 在线升级 自动更新 源码

    在Java CS SWT RCP中实现在线升级和自动更新，通常涉及以下几个关键知识点： 1. **SWT**：SWT是Java中的一个图形用户界面（GUI）库，它是Java AWT和Swing的替代品，提供了与操作系统更紧密的集成，提供了更丰富的...

    ASP.NET基于CS结构的企业人事管理系统的设计与实现_project.rar

    综上所述，"ASP.NET基于CS结构的企业人事管理系统"的实现涉及了软件工程的多个方面，包括需求分析、设计、编码、测试和维护。开发者需要掌握ASP.NET框架、.NET Framework、数据库设计以及客户端和服务器端编程等多个...

    winfrom等Cs结构，客户端在线更新程序

    在IT行业中，Windows Forms（通常简称为WinForms）是一种基于.NET Framework的用户界面开发平台，用于构建桌面应用程序。它提供了一种直观的方式...这样的程序能为用户提供无缝的升级体验，提高软件的可靠性和满意度。

    ASP.NET基于CS结构的企业人事管理系统的设计与实现(源代码+论文).zip

    总的来说，ASP.NET基于CS结构的企业人事管理系统设计与实现是一个涵盖了多个IT领域的综合项目，涉及软件工程方法、数据库设计、Web开发技术、用户体验优化以及安全性等多个方面。通过这个项目，开发者不仅能提升技术...

    c# winfrom自动升级，完整源代码例子 fw2.0

    在.NET框架下，C#开发的WinForm应用程序可以利用各种技术实现自动升级功能，以便用户无需手动下载安装新版本。本示例“c# winfrom自动升级，完整源代码例子 fw2.0”提供了一个简单易懂的方法，适用于C# WinForm应用...

    电信设备-一种基于CS结构的织物疵点检测信息管理系统.zip

    总结，这种基于CS结构的织物疵点检测信息管理系统利用先进的信息技术，实现了纺织生产中的自动化疵点检测和信息管理，对提升产品质量、优化生产流程具有重要意义。同时，系统的设计和实施充分考虑了行业特性、用户...

    基于cs结构的仓库智能管理系统毕业论文.doc

    《基于CS结构的仓库智能管理系统》是一篇关于利用面向对象技术设计和开发仓库管理软件的毕业论文。本文主要探讨了如何运用C/S（客户端/服务器）架构构建一个智能化的仓库管理系统，涵盖了系统从构思到实际应用的全...

    omron-cs1d

    - **软件资产共用**：无论是CS1还是CJ1系列，它们之间可以共享支持软件及程序代码，简化了维护与升级过程。 - **模块通用性**：CS系列的各种I/O模块可在CS1D双工系统中通用，这不仅简化了系统的维护工作，也降低了...

    基于CS结构的图书销售系统 使用VS2008+ACCESS开发 功能强大 包括库存、销售统计和客户关系管理功能

    总结，基于CS结构的图书销售系统通过VS2008和ACCESS的结合，实现了图书行业的高效管理。系统的每个模块都紧密围绕着图书销售的核心业务，旨在通过信息化手段提升整体运营效率，同时也为未来的扩展和升级留有空间。...

    横河cs1000 DCS全部随机资料3.rar

    10. **升级与扩展**：横河CS1000系统设计时考虑到了未来扩展的可能性，允许用户根据需要添加新的硬件和软件模块。 压缩包内的"S1B3001"可能代表一个特定的系统部分或者项目编号，具体的内容可能涉及该部分的详细...

    C#aspnet自动更新升级工具源码

    自动升级工具的核心功能是检查服务器上的新版本，并在发现更新时下载并安装。`AppUpdater.cs` 文件很可能是实现这一功能的关键类。它可能包含了检查更新、下载文件、安装更新等逻辑。 3. **XML 文件处理**： `Xml...

    基于CS结构的实验室管理系统方案.doc

    管理信息系统（Management Information System，MIS）起源于20世纪50年代，随着计算机技术的发展，其功能从最初的数据处理逐渐演变为决策支持和业务流程自动化。MIS的基本概念涵盖了信息的收集、处理、存储和传递，...

    C/S结构的在线考试系统

    【C/S结构的在线考试系统】是一种传统的客户端-服务器（Client/Server，简称C/S）架构的软件应用，尤其在教育信息化领域中被广泛应用。在这个系统中，客户端（通常是用户计算机上的应用程序）与服务器端（负责数据...

Magicbox
Global site tag (gtag.js) - Google Analytics