6.网络编程

publicclassMainActivityextendsActivity{

staticImageView iv;
staticMainActivity ma;
staticHandler handler =newHandler(){
//此方法在主线程中调用，可以用来刷新ui
publicvoid handleMessage(android.os.Message msg){
//处理消息时，需要知道到底是成功的消息，还是失败的消息
switch(msg.what){
case1:
//把位图对象显示至imageview
				iv.setImageBitmap((Bitmap)msg.obj);
break;
//将handler设成静态是节省内存，防止内存溢出，那么imageview也的设成静态，
//而toast方法运行时上下文可能还没有，但是本例子的this是存在的，因为oncreat方法先运行
case0:
Toast.makeText(ma,"请求失败",0).show();
break;
}
}
};
@Override
protectedvoid onCreate(Bundle savedInstanceState){
super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);
		iv =(ImageView) findViewById(R.id.iv);
		ma =this;
}

publicvoid click(View v){
//下载图片
//1.确定网址
finalString path ="http://192.168.13.13:8080/dd.jpg";
finalFile file =newFile(getCacheDir(), getFileName(path));
//判断，缓存中是否存在该文件
if(file.exists()){
//如果缓存存在，从缓存读取图片
System.out.println("从缓存读取的");
Bitmap bm =BitmapFactory.decodeFile(file.getAbsolutePath());
			iv.setImageBitmap(bm);
}
else{
//如果缓存不存在，从网络下载
System.out.println("从网上下载的");
Thread t =newThread(){
@Override
publicvoid run(){

try{
//2.把网址封装成一个url对象
						URL url =new URL(path);
//3.获取客户端和服务器的连接对象，此时还没有建立连接
HttpURLConnection conn =(HttpURLConnection) url.openConnection();
//4.对连接对象进行初始化
//设置请求方法，注意大写
						conn.setRequestMethod("GET");
//设置连接超时
						conn.setConnectTimeout(5000);
//设置读取超时
						conn.setReadTimeout(5000);
//5.发送请求，与服务器建立连接
						conn.connect();
//如果响应码为200，说明请求成功
if(conn.getResponseCode()==200){
//获取服务器响应头中的流，流里的数据就是客户端请求的数据
InputStream is = conn.getInputStream();

//读取服务器返回的流里的数据，把数据写到本地文件，缓存起来

FileOutputStream fos =newFileOutputStream(file);
byte[] b =newbyte[1024];
int len =0;
while((len = is.read(b))!=-1){
								fos.write(b,0, len);
}
							fos.close();

//读取出流里的数据，并构造成位图对象
//流里已经没有数据了
//							Bitmap bm = BitmapFactory.decodeStream(is);
Bitmap bm =BitmapFactory.decodeFile(file.getAbsolutePath());

Message msg =newMessage();
//消息对象可以携带数据
							msg.obj = bm;
							msg.what =1;

//把消息发送至主线程的消息队列
							handler.sendMessag
}
else{
Message msg = handler.obtainMessage();
							msg.what =0;
							handler.sendMessage(msg);
}
}catch(Exception e){
// TODO Auto-generated catch block
						e.printStackTrace();
}
                   finally { //					if (connection != null) { //						//最后可以调用disconnect()方法将这个HTTP连接关闭掉，如下所示： //						connection.disconnect(); //					}
}
};
			t.start();
}
}

publicString getFileName(String path){
int index = path.lastIndexOf("/");
return path.substring(index +1);
}
}

Thread t =newThread(){
@Override
publicvoid run(){
String path ="http://192.168.13.13/Web/servlet/CheckLogin";
//1.创建客户端对象
HttpClient hc =newDefaultHttpClient();
//2.创建post请求对象
HttpPost hp =newHttpPost(path);

//封装form表单提交的数据
BasicNameValuePair bnvp =newBasicNameValuePair("name", name);
BasicNameValuePair bnvp2 =newBasicNameValuePair("pass", pass);
List<BasicNameValuePair> parameters =newArrayList<BasicNameValuePair>();
//把BasicNameValuePair放入集合中
    	    	parameters.add(bnvp);
    	    	parameters.add(bnvp2);

try{
//要提交的数据都已经在集合中了，把集合传给实体对象
UrlEncodedFormEntity entity =newUrlEncodedFormEntity(parameters,"utf-8");
//设置post请求对象的实体，其实就是把要提交的数据封装至post请求的输出流中
    		    	hp.setEntity(entity);
//3.使用客户端发送post请求
HttpResponse hr = hc.execute(hp);
if(hr.getStatusLine().getStatusCode()==200){
InputStream is = hr.getEntity().getContent();
String text =Utils.getTextFromStream(is);

//发送消息，让主线程刷新ui显示text
Message msg = handler.obtainMessage();
    					msg.obj = text;
    					handler.sendMessage(msg);
}
}catch(Exception e){
// TODO Auto-generated catch block
    				e.printStackTrace();
}
}
};
    	t.start();

publicclassMainActivityextendsActivity{

staticintThreadCount=3;
staticint finishedThread =0;

int currentProgress;
String fileName ="QQPlayer.exe";
//确定下载地址
String path ="http://192.168.13.13:8080/"+ fileName;
privateProgressBar pb;
TextView tv;

Handler handler =newHandler(){
publicvoid handleMessage(android.os.Message msg){
//把变量改成long，在long下运算
			tv.setText((long)pb.getProgress()*100/ pb.getMax()+"%");
}
};
@Override
protectedvoid onCreate(Bundle savedInstanceState){
super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);
		pb =(ProgressBar) findViewById(R.id.pb);
		tv =(TextView) findViewById(R.id.tv);
}

publicvoid click(View v){

Thread t =newThread(){
@Override
publicvoid run(){
//发送get请求，请求这个地址的资源
try{
					URL url =new URL(path);
HttpURLConnection conn =(HttpURLConnection) url.openConnection();
					conn.setRequestMethod("GET");
					conn.setConnectTimeout(5000);
					conn.setReadTimeout(5000);

if(conn.getResponseCode()==200){
//拿到所请求资源文件的长度
int length = conn.getContentLength();

//设置进度条的最大值就是原文件的总长度
						pb.setMax(length);

File file =newFile(Environment.getExternalStorageDirectory(), fileName);
//生成临时文件
RandomAccessFile raf =newRandomAccessFile(file,"rwd");
//设置临时文件的大小
						raf.setLength(length);
						raf.close();
//计算出每个线程应该下载多少字节
int size = length /ThreadCount;

for(int i =0; i <ThreadCount; i++){
//计算线程下载的开始位置和结束位置
int startIndex = i * size;
int endIndex =(i +1)* size -1;
//如果是最后一个线程，那么结束位置写死
if(i ==ThreadCount-1){
								endIndex = length -1;
}
//							System.out.println("线程" + i + "的下载区间是：" + startIndex + "---" + endIndex);
newDownLoadThread(startIndex, endIndex, i).start();
}
}
}catch(Exception e){
// TODO Auto-generated catch block
					e.printStackTrace();
}
}
};
		t.start();
}

classDownLoadThreadextendsThread{
int startIndex;
int endIndex;
int threadId;

publicDownLoadThread(int startIndex,int endIndex,int threadId){
super();
this.startIndex = startIndex;
this.endIndex = endIndex;
this.threadId = threadId;
}

@Override
publicvoid run(){
//再次发送http请求，下载原文件
try{
File progressFile =newFile(Environment.getExternalStorageDirectory(), threadId +".txt");
//判断进度临时文件是否存在
if(progressFile.exists()){
FileInputStream fis =newFileInputStream(progressFile);
BufferedReader br =newBufferedReader(newInputStreamReader(fis));
//从进度临时文件中读取出上一次下载的总进度，然后与原本的开始位置相加，得到新的开始位置
int lastProgress =Integer.parseInt(br.readLine());
					startIndex += lastProgress;

//把上次下载的进度显示至进度条
					currentProgress += lastProgress;
					pb.setProgress(currentProgress);

//发送消息，让主线程刷新文本进度
					handler.sendEmptyMessage(1);
					fis.close();
}
System.out.println("线程"+ threadId +"的下载区间是："+ startIndex +"---"+ endIndex);
HttpURLConnection conn;
				URL url =new URL(path);
				conn =(HttpURLConnection) url.openConnection();
				conn.setRequestMethod("GET");
				conn.setConnectTimeout(5000);
				conn.setReadTimeout(5000);
//设置本次http请求所请求的数据的区间
				conn.setRequestProperty("Range","bytes="+ startIndex +"-"+ endIndex);

//请求部分数据，相应码是206
if(conn.getResponseCode()==206){
//流里此时只有1/3原文件的数据
InputStream is = conn.getInputStream();
byte[] b =newbyte[1024];
int len =0;
int total =0;
//拿到临时文件的输出流
File file =newFile(Environment.getExternalStorageDirectory(), fileName);
RandomAccessFile raf =newRandomAccessFile(file,"rwd");
//把文件的写入位置移动至startIndex
					raf.seek(startIndex);
while((len = is.read(b))!=-1){
//每次读取流里数据之后，同步把数据写入临时文件
						raf.write(b,0, len);
						total += len;
System.out.println("线程"+ threadId +"下载了"+ total);

//每次读取流里数据之后，把本次读取的数据的长度显示至进度条
						currentProgress += len;
						pb.setProgress(currentProgress);
//发送消息，让主线程刷新文本进度
						handler.sendEmptyMessage(1);

//生成一个专门用来记录下载进度的临时文件
RandomAccessFile progressRaf =newRandomAccessFile(progressFile,"rwd");
//每次读取流里数据之后，同步把当前线程下载的总进度写入进度临时文件中
						progressRaf.write((total +"").getBytes());
						progressRaf.close();
}
System.out.println("线程"+ threadId +"下载完毕-------------------小志参上！");
					raf.close();

					finishedThread++;
synchronized(path){
//三条线程都下载完毕之后，删除缓存文件
if(finishedThread ==ThreadCount){
for(int i =0; i <ThreadCount; i++){
File f =newFile(Environment.getExternalStorageDirectory(), i +".txt");
								f.delete();
}
							finishedThread =0;
}
}
}
}catch(Exception e){
// TODO Auto-generated catch block
				e.printStackTrace();
}
}
}
}

publicclassHttpUtil{
publicstaticvoid sendHttpRequest(finalString address,
finalHttpCallbackListener listener){
newThread(newRunnable(){
@Override
publicvoid run(){
HttpURLConnection connection =null;
try{
					URL url =new URL(address);
					connection =(HttpURLConnection) url.openConnection();
					connection.setRequestMethod("GET");
					connection.setConnectTimeout(8000);
					connection.setReadTimeout(8000);
					connection.setDoInput(true);
					connection.setDoOutput(true);

InputStream in = connection.getInputStream();
BufferedReader reader =newBufferedReader(
newInputStreamReader(in));
StringBuilder response =newStringBuilder();
String line;
while((line = reader.readLine())!=null){
						response.append(line);
}
if(listener !=null){
// 回调onFinish()方法
						listener.onFinish(response.toString());
}
}catch(Exception e){
if(listener !=null){
// 回调onError()方法
						listener.onError(e);
}
}finally{
if(connection !=null){
						connection.disconnect();
}
}
}
}).start();
}
}

HttpUtil.sendHttpRequest(address,newHttpCallbackListener(){
@Override
publicvoid onFinish(String response){
// 在这里根据返回内容执行具体的逻辑
}
@Override
publicvoid onError(Exception e){
// 在这里对异常情况进行处理
}
});