Android下使用TCP/IP协议实现断点上传

0.使用http协议是不能实现断点上传的，对于文件大小不一，与实际需求可以使用Socket断点上传

1.上传原理：Android客户端发送上传文件头字段给服务器，服务器判断文件是否在服务器上，文件是否有上传的记录，若是文件不存在，服务器则返回一个id（断点数据）通知客户端从什么位置开始上传，客户端开始从获得的位置开始上传文件

2.实例演示

（0）服务器端代码

public class FileServer 
{
	 //线程池
	 private ExecutorService executorService;
	 //监听端口
	 private int port;
	 //退出
	 private boolean quit = false;
	 private ServerSocket server;
	 //存放断点数据
	 private Map<Long, FileLog> datas = new HashMap<Long, FileLog>();
	 
	 public FileServer(int port)
	 {
		 this.port = port;
		 //创建线程池，池中具有(cpu个数*50)条线程
		 executorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors() * 50);
	 }
	 
	 /**
	  * 退出
	  */
	 public void quit()
	 {
		this.quit = true;
		try 
		{
			server.close();
		} 
		catch (IOException e) 
		{
			e.printStackTrace();
		}
	 }
	 
	 /**
	  * 启动服务
	  * @throws Exception
	  */
	 public void start() throws Exception
	 {
		 //实现端口监听
		 server = new ServerSocket(port);
		 while(!quit)
		 {
	         try 
	         {
	           Socket socket = server.accept();
	           //为支持多用户并发访问，采用线程池管理每一个用户的连接请求
	           executorService.execute(new SocketTask(socket));
	         } 
	         catch (Exception e) 
	         {
	             e.printStackTrace();
	         }
	     }
	 }
	 
	 private final class SocketTask implements Runnable
	 {
		private Socket socket = null;
		public SocketTask(Socket socket) 
		{
			this.socket = socket;
		}
		
		@Override
		public void run() 
		{
			try 
			{
				System.out.println("accepted connection "+ socket.getInetAddress()+ ":"+ socket.getPort());
				//这里的输入流PushbackInputStream可以回退到之前的某个点开始进行读取
				PushbackInputStream inStream = new PushbackInputStream(socket.getInputStream());
				//得到客户端发来的第一行协议数据：Content-Length=143253434;filename=xxx.3gp;sourceid=
				//如果用户初次上传文件，sourceid的值为空。
				String head = StreamTool.readLine(inStream);
				System.out.println(head);
				if(head!=null)
				{
					//下面从协议数据中提取各项参数值
					String[] items = head.split(";");
					String filelength = items[0].substring(items[0].indexOf("=")+1);
					String filename = items[1].substring(items[1].indexOf("=")+1);
					String sourceid = items[2].substring(items[2].indexOf("=")+1);		
					//生产资源id，如果需要唯一性，可以采用UUID
					long id = System.currentTimeMillis();
					FileLog log = null;
					if(sourceid!=null && !"".equals(sourceid))
					{
						id = Long.valueOf(sourceid);
						//查找上传的文件是否存在上传记录
						log = find(id);
					}
					File file = null;
					int position = 0;
					//如果上传的文件不存在上传记录,为文件添加跟踪记录
					if(log==null)
					{
						String path = new SimpleDateFormat("yyyy/MM/dd/HH/mm").format(new Date());
						//设置存放的位置与当前应用的位置有关
						File dir = new File("file/"+ path);
						if(!dir.exists()) dir.mkdirs();
						file = new File(dir, filename);
						//如果上传的文件发生重名，然后进行改名
						if(file.exists())
						{
							filename = filename.substring(0, filename.indexOf(".")-1)+ dir.listFiles().length+ filename.substring(filename.indexOf("."));
							file = new File(dir, filename);
						}
						save(id, file);
					}
					// 如果上传的文件存在上传记录,读取上次的断点位置
					else
					{
						//从上传记录中得到文件的路径
						file = new File(log.getPath());
						if(file.exists())
						{
							File logFile = new File(file.getParentFile(), file.getName()+".log");
							if(logFile.exists())
							{
								Properties properties = new Properties();
								properties.load(new FileInputStream(logFile));
								//读取断点位置
								position = Integer.valueOf(properties.getProperty("length"));
							}
						}
					}
					
					OutputStream outStream = socket.getOutputStream();
					String response = "sourceid="+ id+ ";position="+ position+ "\r\n";
					//服务器收到客户端的请求信息后，给客户端返回响应信息：sourceid=1274773833264;position=0
					//sourceid由服务生成，唯一标识上传的文件，position指示客户端从文件的什么位置开始上传
					outStream.write(response.getBytes());
					//
					RandomAccessFile fileOutStream = new RandomAccessFile(file, "rwd");
					//设置文件长度
					if(position==0) fileOutStream.setLength(Integer.valueOf(filelength));
					//移动文件指定的位置开始写入数据
					fileOutStream.seek(position);
					byte[] buffer = new byte[1024];
					int len = -1;
					int length = position;
					//从输入流中读取数据写入到文件中
					while( (len=inStream.read(buffer)) != -1)
					{
						fileOutStream.write(buffer, 0, len);
						length += len;
						Properties properties = new Properties();
						properties.put("length", String.valueOf(length));
						FileOutputStream logFile = new FileOutputStream(new File(file.getParentFile(), file.getName()+".log"));
						//实时记录文件的最后保存位置
						properties.store(logFile, null);
						logFile.close();
					}
					//如果长传长度等于实际长度则表示长传成功
					if(length==fileOutStream.length()) delete(id);
					fileOutStream.close();					
					inStream.close();
					outStream.close();
					file = null;
					
				}
			}
			catch (Exception e) 
			{
				e.printStackTrace();
			}
			finally
			{
	            try
	            {
	                if(socket!=null && !socket.isClosed()) socket.close();
	            } 
	            catch (IOException e)
	            {
	            	e.printStackTrace();
	            }
	        }
		}
	 }
	 
	 public FileLog find(Long sourceid)
	 {
		 return datas.get(sourceid);
	 }
	 //保存上传记录
	 public void save(Long id, File saveFile)
	 {
		 //日后可以改成通过数据库存放
		 datas.put(id, new FileLog(id, saveFile.getAbsolutePath()));
	 }
	 //当文件上传完毕，删除记录
	 public void delete(long sourceid)
	 {
		 if(datas.containsKey(sourceid)) datas.remove(sourceid);
	 }
	 
	 private class FileLog{
		private Long id;
		private String path;
		public Long getId() {
			return id;
		}
		public void setId(Long id) {
			this.id = id;
		}
		public String getPath() {
			return path;
		}
		public void setPath(String path) {
			this.path = path;
		}
		public FileLog(Long id, String path) {
			this.id = id;
			this.path = path;
		}	
	 }
}

public class ServerWindow extends Frame
{
	private FileServer s = new FileServer(7878);
	private Label label;
	
	public ServerWindow(String title)
	{
		super(title);
		label = new Label();
		add(label, BorderLayout.PAGE_START);
		label.setText("服务器已经启动");
		this.addWindowListener(new WindowListener() 
		{
			@Override
			public void windowOpened(WindowEvent e) 
			{
				new Thread(new Runnable()
				{			
					@Override
					public void run() 
					{
						try 
						{
							s.start();
						}
						catch (Exception e) 
						{
							e.printStackTrace();
						}
					}
				}).start();
			}
			
			@Override
			public void windowIconified(WindowEvent e) {
			}
			
			@Override
			public void windowDeiconified(WindowEvent e) {
			}
			
			@Override
			public void windowDeactivated(WindowEvent e) {
			}
			
			@Override
			public void windowClosing(WindowEvent e) {
				 s.quit();
				 System.exit(0);
			}
			
			@Override
			public void windowClosed(WindowEvent e) {
			}
			
			@Override
			public void windowActivated(WindowEvent e) {
			}
		});
	}
	/**
	 * @param args
	 */
	public static void main(String[] args) 
	{
		ServerWindow window = new ServerWindow("文件上传服务端"); 
		window.setSize(300, 300); 
		window.setVisible(true);
	}
}

public class SocketClient 
{
	public static void main(String[] args) 
	{
		try 
		{   
			//这里的套接字根据实际服务器更改
			Socket socket = new Socket("127.0.0.1", 7878);
            OutputStream outStream = socket.getOutputStream();            
            String filename = "QQWubiSetup.exe";
            File file = new File(filename);
            //构造上传文件头，上传的时候会判断上传的文件是否存在，是否存在上传记录
            //若是不存在则服务器会自动生成一个id,给客户端返回
            String head = "Content-Length="+ file.length() + ";filename="+ filename + ";sourceid=1278916111468\r\n";
            outStream.write(head.getBytes());
            
            PushbackInputStream inStream = new PushbackInputStream(socket.getInputStream());	
			String response = StreamTool.readLine(inStream);
            System.out.println(response);
            String[] items = response.split(";");
            //构造开始上传文件的位置
			String position = items[1].substring(items[1].indexOf("=")+1);
			//以读的方式开始访问
			RandomAccessFile fileOutStream = new RandomAccessFile(file, "r");
			fileOutStream.seek(Integer.valueOf(position));
			byte[] buffer = new byte[1024];
			int len = -1;
			int i = 0;
			while( (len = fileOutStream.read(buffer)) != -1)
			{
				outStream.write(buffer, 0, len);
				i++;
				//if(i==10) break;
			}
			fileOutStream.close();
			outStream.close();
            inStream.close();
            socket.close();
        } 
		catch (Exception e) 
		{                    
            e.printStackTrace();
        }
	}
	/**
	* 读取流
	* @param inStream
	* @return 字节数组
	* @throws Exception
	*/
	public static byte[] readStream(InputStream inStream) throws Exception
	{
			ByteArrayOutputStream outSteam = new ByteArrayOutputStream();
			byte[] buffer = new byte[1024];
			int len = -1;
			while( (len=inStream.read(buffer)) != -1)
			{
				outSteam.write(buffer, 0, len);
			}
			outSteam.close();
			inStream.close();
			return outSteam.toByteArray();
	}
}

public class StreamTool 
{
	 
	 public static void save(File file, byte[] data) throws Exception 
	 {
		 FileOutputStream outStream = new FileOutputStream(file);
		 outStream.write(data);
		 outStream.close();
	 }
	 
	 public static String readLine(PushbackInputStream in) throws IOException 
	 {
			char buf[] = new char[128];
			int room = buf.length;
			int offset = 0;
			int c;
     loop:  while (true) {
				switch (c = in.read()) 
				{
					case -1:
					case '\n':
						break loop;
					case '\r':
						int c2 = in.read();
						if ((c2 != '\n') && (c2 != -1)) in.unread(c2);
						break loop;
					default:
						if (--room < 0) {
							char[] lineBuffer = buf;
							buf = new char[offset + 128];
						    room = buf.length - offset - 1;
						    System.arraycopy(lineBuffer, 0, buf, 0, offset);
						   
						}
						buf[offset++] = (char) c;
						break;
				}
			}
			if ((c == -1) && (offset == 0)) return null;
			return String.copyValueOf(buf, 0, offset);
	}
	 
	/**
	* 读取流
	* @param inStream
	* @return 字节数组
	* @throws Exception
	*/
	public static byte[] readStream(InputStream inStream) throws Exception
	{
			ByteArrayOutputStream outSteam = new ByteArrayOutputStream();
			byte[] buffer = new byte[1024];
			int len = -1;
			while( (len=inStream.read(buffer)) != -1){
				outSteam.write(buffer, 0, len);
			}
			outSteam.close();
			inStream.close();
			return outSteam.toByteArray();
	}
}

（1）Android客户端代码：

public class UploadActivity extends Activity 
{
    private EditText filenameText;
    private TextView resulView;
    private ProgressBar uploadbar;
    private UploadLogService logService;
    
    @Override
    public void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        
        logService = new UploadLogService(this);
        filenameText = (EditText)this.findViewById(R.id.filename);
        uploadbar = (ProgressBar) this.findViewById(R.id.uploadbar);
        resulView = (TextView)this.findViewById(R.id.result);
        Button button =(Button)this.findViewById(R.id.button);
        button.setOnClickListener(new View.OnClickListener() 
        {
			@Override
			public void onClick(View v) 
			{
				String filename = filenameText.getText().toString();
				//判断SDCard是否存在
				if(Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED))
				{
					//取得SDCard的目录
					File uploadFile = new File(Environment.getExternalStorageDirectory(), filename);
					if(uploadFile.exists())
					{
						uploadFile(uploadFile);
					}
					else
					{
						Toast.makeText(UploadActivity.this, R.string.filenotexsit, 1).show();
					}
				}
				else
				{
					Toast.makeText(UploadActivity.this, R.string.sdcarderror, 1).show();
				}
			}
		});
    }
    /**
     * 使用Handler给创建他的线程发送消息，
     * 匿名内部类
     */
    private Handler handler = new Handler()
    {
		@Override
		public void handleMessage(Message msg) 
		{
			//获得上传长度的进度
			int length = msg.getData().getInt("size");
			uploadbar.setProgress(length);
			float num = (float)uploadbar.getProgress()/(float)uploadbar.getMax();
			int result = (int)(num * 100);
			//设置显示结果
			resulView.setText(result+ "%");
			//上传成功
			if(uploadbar.getProgress()==uploadbar.getMax())
			{
				Toast.makeText(UploadActivity.this, R.string.success, 1).show();
			}
		}
    };
    
    /**
     * 上传文件,应该启动一个线程，使用Handler来避免UI线程ANR错误
     * @param final uploadFile
     */
	private void uploadFile(final File uploadFile) 
	{
		new Thread(new Runnable() 
		{			
			@Override
			public void run() 
			{
				try 
				{
					//设置长传文件的最大刻度
					uploadbar.setMax((int)uploadFile.length());
					//判断文件是否已有上传记录
					String souceid = logService.getBindId(uploadFile);
					//构造拼接协议
					String head = "Content-Length="+ uploadFile.length() + ";filename="+ uploadFile.getName() + ";sourceid="+
						(souceid==null? "" : souceid)+"\r\n";
					//通过Socket取得输出流
					Socket socket = new Socket("192.168.1.100", 7878);
					OutputStream outStream = socket.getOutputStream();
					outStream.write(head.getBytes());
					
					PushbackInputStream inStream = new PushbackInputStream(socket.getInputStream());	
					//获取到字符流的id与位置
					String response = StreamTool.readLine(inStream);
					String[] items = response.split(";");
					String responseid = items[0].substring(items[0].indexOf("=")+1);
					String position = items[1].substring(items[1].indexOf("=")+1);
					//代表原来没有上传过此文件，往数据库添加一条绑定记录
					if(souceid==null)
					{
						logService.save(responseid, uploadFile);
					}
					RandomAccessFile fileOutStream = new RandomAccessFile(uploadFile, "r");
					fileOutStream.seek(Integer.valueOf(position));
					byte[] buffer = new byte[1024];
					int len = -1;
					//初始化长传的数据长度
					int length = Integer.valueOf(position);
					while( (len = fileOutStream.read(buffer)) != -1)
					{
						outStream.write(buffer, 0, len);
						//设置长传数据长度
						length += len;
						Message msg = new Message();
						msg.getData().putInt("size", length);
						handler.sendMessage(msg);
					}
					fileOutStream.close();
					outStream.close();
		            inStream.close();
		            socket.close();
		            //判断上传完则删除数据
		            if(length==uploadFile.length()) 
		            	logService.delete(uploadFile);
				} 
				catch (Exception e)
				{
					e.printStackTrace();
				}
			}
		}).start();
	}
}

public class DBOpenHelper extends SQLiteOpenHelper 
{
	public DBOpenHelper(Context context) 
	{
		super(context, "upload.db", null, 1);
	}
	@Override
	public void onCreate(SQLiteDatabase db) 
	{
		db.execSQL("CREATE TABLE uploadlog (_id integer primary key autoincrement, uploadfilepath varchar(100), sourceid varchar(10))");
	}
	@Override
	public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) 
	{
		db.execSQL("DROP TABLE IF EXISTS uploadlog");
		onCreate(db);		
	}
}

public class UploadLogService 
{
	private DBOpenHelper dbOpenHelper;
	//给出上下文对象
	public UploadLogService(Context context)
	{
		this.dbOpenHelper = new DBOpenHelper(context);
	}
	//保存上传文件断点数据
	public void save(String sourceid, File uploadFile)
	{
		SQLiteDatabase db = dbOpenHelper.getWritableDatabase();
		db.execSQL("insert into uploadlog(uploadfilepath, sourceid) values(?,?)",
				new Object[]{uploadFile.getAbsolutePath(),sourceid});
	}
	//删除上传文件断点数据
	public void delete(File uploadFile)
	{
		SQLiteDatabase db = dbOpenHelper.getWritableDatabase();
		db.execSQL("delete from uploadlog where uploadfilepath=?", new Object[]{uploadFile.getAbsolutePath()});
	}
	//根据文件的上传路径得到绑定的id
	public String getBindId(File uploadFile)
	{
		SQLiteDatabase db = dbOpenHelper.getReadableDatabase();
		Cursor cursor = db.rawQuery("select sourceid from uploadlog where uploadfilepath=?", 
				new String[]{uploadFile.getAbsolutePath()});
		if(cursor.moveToFirst())
		{
			return cursor.getString(0);
		}
		return null;
	}
}

public class StreamTool 
{
	 
	 public static void save(File file, byte[] data) throws Exception 
	 {
		 FileOutputStream outStream = new FileOutputStream(file);
		 outStream.write(data);
		 outStream.close();
	 }
	 
	 public static String readLine(PushbackInputStream in) throws IOException 
	 {
			char buf[] = new char[128];
			int room = buf.length;
			int offset = 0;
			int c;
loop:		while (true) {
				switch (c = in.read()) {
					case -1:
					case '\n':
						break loop;
					case '\r':
						int c2 = in.read();
						if ((c2 != '\n') && (c2 != -1)) in.unread(c2);
						break loop;
					default:
						if (--room < 0) {
							char[] lineBuffer = buf;
							buf = new char[offset + 128];
						    room = buf.length - offset - 1;
						    System.arraycopy(lineBuffer, 0, buf, 0, offset);
						   
						}
						buf[offset++] = (char) c;
						break;
				}
			}
			if ((c == -1) && (offset == 0)) return null;
			return String.copyValueOf(buf, 0, offset);
	}
	 
	/**
	* 读取流
	* @param inStream
	* @return 字节数组
	* @throws Exception
	*/
	public static byte[] readStream(InputStream inStream) throws Exception
	{
			ByteArrayOutputStream outSteam = new ByteArrayOutputStream();
			byte[] buffer = new byte[1024];
			int len = -1;
			while( (len=inStream.read(buffer)) != -1)
			{
				outSteam.write(buffer, 0, len);
			}
			outSteam.close();
			inStream.close();
			return outSteam.toByteArray();
	}
}

评论

1 楼 chenjia66804610 2011-10-27  

你好，能不能把你的两个工程发给我一下，谢谢
我的邮箱[e-mail]