精华内容
下载资源
问答
  • 安卓 网络编程

    2021-06-08 15:30:37
    安卓 网络编程Socket服务端客户端服务端客户端安卓Socket客户端1——实现类似前后左右控制小车MainActivity.javaTest.javaactivity_main.xml效果实现倒计时(通过Handler)安卓Socket客户端2——显示服务端发来的...

    Socket服务端客户端

    安卓Socket服务端开发注意事项:
    网络访问不能在主线程(UI线程)中进行,否则程序会崩溃
    要创建线程来发起网络访问

    服务端

    import java.io.IOException;
    import java.io.InputStream;
    import java.io.OutputStream;
    import java.net.ServerSocket;
    import java.net.Socket;
    import java.util.Scanner;
    
    
    public class Test {
    	public static void main(String[] args){
    		
    		byte[] data = new byte[128];
    		int len;
    		try {
    			ServerSocket socket = new ServerSocket(8888); //创建套接字
    			System.out.println("套接字建立成功 等待连接");
    			 	
    			while(true){
    				final Socket con = socket.accept(); // 连接
    				System.out.println("有数据接入");
    				
    				new Thread(new Runnable() { //创建线程来发起网络访问
    					
    					public void run() {
    						// TODO Auto-generated method stub
    						InputStream in; // 获取数据接收通道
    						OutputStream out; // 获得数据发送通道
    						try {
    							in = con.getInputStream();
    							byte[] data = new byte[128];
    							int len = 0;
    							len = in.read(data);
    							System.out.println("读到数据:"+new String(data, 0, len));
    							
    							out = con.getOutputStream(); 
    							Scanner sc = new Scanner(System.in);
    							String message = sc.next();
    							out.write(message.getBytes());
    							
    						} catch (IOException e) {
    							// TODO Auto-generated catch block
    							e.printStackTrace();
    						} 
    						
    					}
    				}).start();
    				
    			}
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		
    	}
    }
    
    

    客户端

    import java.io.IOException;
    import java.io.InputStream;
    import java.io.OutputStream;
    import java.net.Socket;
    import java.net.UnknownHostException;
    import java.util.Scanner;
    
    
    public class Test {
    	public static void main(String[] args) {
    		try {
    			Socket client = new Socket("192.168.106.1", 8888); //连接
    			OutputStream out = client.getOutputStream(); // 获得数据发送通道
    			
    			Scanner sc = new Scanner(System.in);
    			String message = sc.next();
    			out.write(message.getBytes());
    			
    			InputStream in = client.getInputStream();
    			int len;
    			byte[] data = new byte[128];
    			len = in.read(data);
    			System.out.println("获取服务单的数据"+new String(data, 0, len));
    			
    			
    		}catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		
    	}
    }
    
    

    安卓Socket客户端1——实现类似前后左右控制小车

    MainActivity.java

    package com.example.linmu.learn;
    
    import android.app.Activity;
    import android.os.Bundle;
    import android.view.View;
    
    import com.example.linmu.learn.nets.Test;
    
    public class MainActivity extends Activity {
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
        }
    
    
        
        public void command(View v){
        	switch(v.getId()){
        		case R.id.go:
        			Test.sendmessagehandle("go");
        			break;
        		case R.id.back:
        			Test.sendmessagehandle("back");
        			break;
        		case R.id.left:
        			Test.sendmessagehandle("left");
        			break;
        		case R.id.right:
        			Test.sendmessagehandle("right");
        			break;	
    			
        	}
        	
       	}
    }
    

    Test.java

    package com.example.linmu.learn.nets;
    
    import java.io.IOException;
    import java.io.OutputStream;
    import java.net.Socket;
    
    
    public class Test {
    	
    
    	public static void sendmessagehandle(final String string){
    		new Thread(new Runnable() {
    			
    			@Override
    			public void run() {
    				// TODO Auto-generated method stub
    				try {
    					Socket client = new Socket("192.168.106.1", 8888); //连接
    					OutputStream out = client.getOutputStream(); // 获得数据发送通道
    					
    					String message = string;
    					
    					out.write(message.getBytes());
    					
    //					InputStream in = client.getInputStream();
    //					int len;
    //					byte[] data = new byte[128];
    //					len = in.read(data);
    //					System.out.println("获取服务单的数据"+new String(data, 0, len));
    					
    					
    				}catch (IOException e) {
    					// TODO Auto-generated catch block
    					e.printStackTrace();
    				}
    			}
    		}).start();
    		
    		
    	}
    }
    
    

    activity_main.xml

    <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:tools="http://schemas.android.com/tools"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:paddingBottom="@dimen/activity_vertical_margin"
        android:paddingLeft="@dimen/activity_horizontal_margin"
        android:paddingRight="@dimen/activity_horizontal_margin"
        android:paddingTop="@dimen/activity_vertical_margin"
        android:background="@drawable/beijing"
        tools:context=".MainActivity" >
    
        <Button
            android:id="@+id/go"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_alignLeft="@+id/back"
            android:layout_alignParentTop="true"
            android:layout_marginTop="133dp"
            android:background="#8a2be2"
            android:onClick="command"
            android:text="前进" />
    
        <Button
            android:id="@+id/right"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_below="@+id/go"
            android:layout_marginLeft="15dp"
            android:layout_marginTop="27dp"
            android:layout_toRightOf="@+id/go"
            android:background="#8a2be2"
            android:onClick="command"
            android:text="右转" />
    
        <Button
            android:id="@+id/left"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_alignBaseline="@+id/right"
            android:layout_alignBottom="@+id/right"
            android:layout_toLeftOf="@+id/go"
            android:background="#8a2be2"
            android:onClick="command"
            android:text="左转" />
    
        <Button
            android:id="@+id/back"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_below="@+id/left"
            android:layout_centerHorizontal="true"
            android:layout_marginTop="32dp"
            android:background="#8a2be2"
            android:onClick="command"
            android:text="后退" />
    
    </RelativeLayout>
    

    效果

    在这里插入图片描述

    实现倒计时(通过Handler)

    Handler的工作机制
    1.Message 消息,理解为线程间通讯的数据单元。例如后台子线程在处理数据完毕后需要更新UI,则可发送一条包含更新信息的Message给UI线程。
    2.Message Queue 消息队列,用来存放通过Handler发布的消息,按照先进先出执行。
    3.Handler是Message的主要处理者,负责将Message添加到消息队列以及对消- 息队列中的Message进行处理。
    4.Looper 循环器,扮演Message Queue和Handler之间桥梁的角色,循环取出Message
    Queue里面的Message,并交付给相应的Handler进行处理。

    抽象来说就是UI主线程家里的“电话”,处理一些其他进程不能处理的事件

    package com.example.linmu;
    
    import android.app.Activity;
    import android.os.Bundle;
    import android.os.Handler;
    import android.os.Message;
    import android.view.View;
    import android.widget.TextView;
    
    public class MainActivity extends Activity {
    
    	public Handler h;
    	public TextView textview;
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            
            textview = (TextView) findViewById(R.id.textview);
            h = new Handler(){ // UI主线程家里的电话,处理一些其他进程不能处理的事件
            	@Override
            	public void handleMessage(Message msg) {
            		// TODO Auto-generated method stub
            		super.handleMessage(msg);
            		textview.setText(msg.what+"s");
            	}
            };
        }
    
        public void start(View v){
        	new Thread(new Runnable() {
    			
    			@Override
    			public void run() {
    				// TODO Auto-generated method stub
    				for (int i = 9; i > -1; i--) {
    					Message msg = new Message();
    					msg.what = i;
    					h.sendMessage(msg); // "打电话"去把UI要显示,要处理的事交给线程的handler去做
    					try {
    						Thread.sleep(1000);
    					} catch (InterruptedException e) {
    						// TODO Auto-generated catch block
    						e.printStackTrace();
    					}
    				}
    			}
    		}).start();
        	
        }
        
        
    }
    
    

    安卓Socket客户端2——显示服务端发来的数据能不断刷新

    MainActivity.java

    package com.example.linmu.learn;
    
    import android.app.Activity;
    import android.os.Bundle;
    import android.os.Handler;
    import android.os.Message;
    import android.view.View;
    import android.widget.TextView;
    
    import com.example.linmu.learn.nets.Test;
    
    public class MainActivity extends Activity {
    
    	Handler h;
    	TextView textview;
    	
    	
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            textview = (TextView) findViewById(R.id.textview);
            
            h = new Handler(){
            	@Override
            	public void handleMessage(Message msg) {
            		// TODO Auto-generated method stub
            		super.handleMessage(msg);
            		Bundle b = msg.getData();
            		String string = b.getString("msg");
            		textview.setText(string); //显示数据
            	}
            };
        }
        
        public void start(View v){
        	switch(v.getId()){
        		case R.id.button1:
        			Test.sendmessagehandle("goforward", h);
        			break;
        	}
        	
       	}
    }
    
    

    Test.java

    package com.example.linmu.learn.nets;
    
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.OutputStream;
    import java.net.Socket;
    
    import android.os.Bundle;
    import android.os.Handler;
    import android.os.Message;
    
    
    
    
    public class Test {
    	
    
    	public static void sendmessagehandle(final String string, final Handler h){
    		new Thread(new Runnable() {
    			
    			@Override
    			public void run() {
    				// TODO Auto-generated method stub
    				try {
    					Socket client = new Socket("192.168.106.1", 8888); //连接
    					OutputStream out = client.getOutputStream(); // 获得数据发送通道					
    					String message = string;					
    					out.write(message.getBytes());
    					
    					InputStream in = client.getInputStream(); //获得数据发送通道
    					int len;
    					byte[] data = new byte[128];
    					len = in.read(data);
    					String str = new String(data,0,len);
    					Message msg = new Message();
    					Bundle b = new Bundle();
    					b.putString("msg", str); 
    					msg.setData(b);
    					h.sendMessage(msg); //去把UI要显示,要处理的事交给线程的handler去做
    					
    				}catch (IOException e) {
    					// TODO Auto-generated catch block
    					e.printStackTrace();
    				}
    			}
    		}).start();
    		
    		
    	}
    }
    
    

    activity_main.xml

    <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:tools="http://schemas.android.com/tools"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:paddingBottom="@dimen/activity_vertical_margin"
        android:paddingLeft="@dimen/activity_horizontal_margin"
        android:paddingRight="@dimen/activity_horizontal_margin"
        android:paddingTop="@dimen/activity_vertical_margin"
        android:background="#000000"
        tools:context=".MainActivity" >
    
        <Button
            android:id="@+id/button1"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_alignParentTop="true"
            android:layout_centerHorizontal="true"
            android:onClick="start"
            android:text="发起网络请求" />
    	
        <TextView 
            android:id="@+id/textview"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_centerInParent="true"
            android:textColor="#ffffff"
            android:textSize="35dp"
            android:textStyle="bold"
            android:text="666"
            
            />
        
    
    </RelativeLayout>
    
    展开全文
  • 安卓网络编程

    千次阅读 2018-05-08 12:43:03
    网络编程安卓网络编程主要分三种方式: * Socket 应用基本不用。 * HttpURLConnection 比较常用的网络编程方式。 * HttpClient 在2.3之前推荐使用,2.3之后被HttpURLConnection所代替。网上比较常用的开源框架:...

    网络编程

    安卓网络编程主要分三种方式:

     * Socket 应用基本不用。 

     * HttpURLConnection 比较常用的网络编程方式。 

     * HttpClient 在2.3之前推荐使用,2.3之后被HttpURLConnection所代替。

    网上比较常用的开源框架:

    开源项目:网络图片查看器android-smart-image-view-master。

        <com.loopj.android.image.SmartImageView 
        android:id="@+id/iv"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        />
    
        //1.确定网址
        String path = "http://192.168.13.13:8080/dd.jpg";
        //2.找到智能图片查看器对象
        SmartImageView siv = (SmartImageView) findViewById(R.id.iv);
        //3.下载并显示图片
        siv.setImageUrl(path);
    

    HttpURLConnection

    GET:

        Thread t = new Thread(){
            @Override
            public void run() {
    //提交的数据需要经过url编码,英文和数字编码后不变
    String path = "http://192.168.13.13/Web2/servlet/LoginServlet?name=" + URLEncoder.encode(name) + "&pass=" + pass;
                try {
                    URL url = new URL(path);
                    //获取连接对象,此时还未建立连接
                    HttpURLConnection conn = (HttpURLConnection) url.openConnection();
                    conn.setRequestMethod("GET");
                    conn.setConnectTimeout(5000);
                    conn.setReadTimeout(5000);
                    //先建立连接,然后获取响应码
                    if(conn.getResponseCode() == 200){
                        //拿到服务器返回的输入流,流里的数据就是html的源文件
                        InputStream is = conn.getInputStream();
                        //从流里把文本数据取出来
                        String text = Utils.getTextFromStream(is);
    
                        //发送消息,让主线程刷新ui,显示源文件
                        Message msg = handler.obtainMessage();
                        msg.obj = text;
                        handler.sendMessage(msg);
                    }
                } catch (Exception e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        };
        t.start();
    

    post方式提交数据。

        final String name = et_name.getText().toString();
        final String pass = et_pass.getText().toString();
    
        Thread t = new Thread(){
            @Override
            public void run() {
                //提交的数据需要经过url编码,英文和数字编码后不变
                @SuppressWarnings("deprecation")
                String path = "http://192.168.13.13/Web2/servlet/LoginServlet";
    
                try {
                    URL url = new URL(path);
                    HttpURLConnection conn = (HttpURLConnection) url.openConnection();
                    conn.setRequestMethod("POST");
                    conn.setConnectTimeout(5000);
                    conn.setReadTimeout(5000);
    
                    //拼接出要提交的数据的字符串
                    String data = "name=" + URLEncoder.encode(name) + "&pass=" + pass;
                    //添加post请求的两行属性
                    conn.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
                    conn.setRequestProperty("Content-Length", data.length() + "");
    
                    //设置打开输出流
                    conn.setDoOutput(true);
                    //拿到输出流
                    OutputStream os = conn.getOutputStream();
                    //使用输出流往服务器提交数据
                    os.write(data.getBytes());
                    if(conn.getResponseCode() == 200){
                        InputStream is = conn.getInputStream();
                        String text = Utils.getTextFromStream(is);
    
                        Message msg = handler.obtainMessage();
                        msg.obj = text;
                        handler.sendMessage(msg);
                    }
                } catch (Exception e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        };
        t.start();
    

    HTTPClient在2.3之前推荐使用

    get方式提交数据。

        public void get(View v){
        EditText et_name = (EditText) findViewById(R.id.et_name);
        EditText et_pass = (EditText) findViewById(R.id.et_pass);
    
        final String name = et_name.getText().toString();
        final String pass = et_pass.getText().toString();
    
    
        Thread t = new Thread(){
            @Override
            public void run() {
                String path = "http://192.168.13.13/Web/servlet/CheckLogin?name=" + URLEncoder.encode(name) + "&pass=" + pass;
                //使用httpClient框架做get方式提交
                //1.创建HttpClient对象
                HttpClient hc = new DefaultHttpClient();
    
                //2.创建httpGet对象,构造方法的参数就是网址
                HttpGet hg = new HttpGet(path);
    
                //3.使用客户端对象,把get请求对象发送出去
                try {
                    HttpResponse hr = hc.execute(hg);
                    //拿到响应头中的状态行
                    StatusLine sl = hr.getStatusLine();
                    if(sl.getStatusCode() == 200){
                        //拿到响应头的实体
                        HttpEntity he = hr.getEntity();
                        //拿到实体中的内容,其实就是服务器返回的输入流
                        InputStream is = he.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();
    
    }
    

    post方式提交。

        public void post(View v){
        EditText et_name = (EditText) findViewById(R.id.et_name);
        EditText et_pass = (EditText) findViewById(R.id.et_pass);
    
        final String name = et_name.getText().toString();
        final String pass = et_pass.getText().toString();
    
        Thread t = new Thread(){
            @Override
            public void run() {
                String path = "http://192.168.13.13/Web/servlet/CheckLogin";
                //1.创建客户端对象
                HttpClient hc = new DefaultHttpClient();
                //2.创建post请求对象
                HttpPost hp = new HttpPost(path);
    
                //封装form表单提交的数据
                BasicNameValuePair bnvp = new BasicNameValuePair("name", name);
                BasicNameValuePair bnvp2 = new BasicNameValuePair("pass", pass);
                List<BasicNameValuePair> parameters = new ArrayList<BasicNameValuePair>();
                //把BasicNameValuePair放入集合中
                parameters.add(bnvp);
                parameters.add(bnvp2);
    
                try {
                    //要提交的数据都已经在集合中了,把集合传给实体对象
                    UrlEncodedFormEntity entity = new UrlEncodedFormEntity(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();      
    }
    

    断点续传原理:

        ##多线程断点下载
    

    原理:服务器CPU分配给每条线程的时间片相同,服务器带宽平均分配给每条线程,所以客户端开启的线程越多,就能抢占到更多的服务器资源

    确定每条线程下载多少数据

    • 发送http请求至下载地址

      String path = "http://192.168.1.102:8080/editplus.exe";     
      URL url = new URL(path);
      HttpURLConnection conn = (HttpURLConnection) url.openConnection();
      conn.setReadTimeout(5000);
      conn.setConnectTimeout(5000);
      conn.setRequestMethod("GET");                   
      
    • 获取文件总长度,然后创建长度一致的临时文件

      if(conn.getResponseCode() == 200){
          //获得服务器流中数据的长度
          int length = conn.getContentLength();
          //创建一个临时文件存储下载的数据
          RandomAccessFile raf = new RandomAccessFile(getFileName(path), "rwd");
          //设置临时文件的大小
          raf.setLength(length);
          raf.close();
      
    • 确定线程下载多少数据

          //计算每个线程下载多少数据
          int blockSize = length / THREAD_COUNT;
      

    计算每条线程下载数据的开始位置和结束位置

        for(int id = 1; id <= 3; id++){
            //计算每个线程下载数据的开始位置和结束位置
            int startIndex = (id - 1) * blockSize;
            int endIndex = id * blockSize - 1;
            if(id == THREAD_COUNT){
                endIndex = length;
            }
    
            //开启线程,按照计算出来的开始结束位置开始下载数据
            new DownLoadThread(startIndex, endIndex, id).start();
        }
    

    线程:再次发送请求至下载地址,请求开始位置至结束位置的数据

        String path = "http://192.168.1.102:8080/editplus.exe";
    
        URL url = new URL(path);
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.setReadTimeout(5000);
        conn.setConnectTimeout(5000);
        conn.setRequestMethod("GET");
    
        //向服务器请求部分数据,"bytes="不要有空格,不然会出错。
        conn.setRequestProperty("Range", "bytes=" + startIndex + "-" + endIndex);
        conn.connect();
    
    • 下载请求到的数据,存放至临时文件中

      if(conn.getResponseCode() == 206){
          InputStream is = conn.getInputStream();
          RandomAccessFile raf = new RandomAccessFile(getFileName(path), "rwd");
          //指定从哪个位置开始存放数据
          raf.seek(startIndex);
          byte[] b = new byte[1024];
          int len;
          while((len = is.read(b)) != -1){
              raf.write(b, 0, len);
          }
          raf.close();
      }
      

    带断点续传的多线程下载

    • 定义一个int变量记录每条线程下载的数据总长度,然后加上该线程的下载开始位置,得到的结果就是下次下载时,该线程的开始位置,把得到的结果存入缓存文件

      //用来记录当前线程总的下载长度
      int total = 0;
      while((len = is.read(b)) != -1){
          raf.write(b, 0, len);
          total += len;
          //每次下载都把新的下载位置写入缓存文本文件
          RandomAccessFile raf2 = new RandomAccessFile(threadId + ".txt", "rwd");
          raf2.write((startIndex + total + "").getBytes());
          raf2.close();
      }
      
    • 下次下载开始时,先读取缓存文件中的值,得到的值就是该线程新的开始位置

      FileInputStream fis = new FileInputStream(file);
      BufferedReader br = new BufferedReader(new InputStreamReader(fis));
      String text = br.readLine();
      int newStartIndex = Integer.parseInt(text);
      //把读到的值作为新的开始位置
      startIndex = newStartIndex;
      fis.close();
      
    • 三条线程都下载完毕之后,删除缓存文件

      RUNNING_THREAD--;
      if(RUNNING_THREAD == 0){
          for(int i = 0; i <= 3; i++){
              File f = new File(i + ".txt");
              f.delete();
          }
      }
      

    手机版的断点续传多线程下载器

    • 把刚才的代码直接粘贴过来就能用,记得在访问文件时的路径要改成Android的目录,添加访问网络和外部存储的路径

    用进度条显示下载进度

    • 拿到下载文件总长度时,设置进度条的最大值

      //设置进度条的最大值
      pb.setMax(length);
      
    • 进度条需要显示三条线程的整体下载进度,所以三条线程每下载一次,就要把新下载的长度加入进度条

      • 定义一个int全局变量,记录三条线程的总下载长度

        int progress;
        
      • 刷新进度条

        while((len = is.read(b)) != -1){
            raf.write(b, 0, len);
        
        
            //把当前线程本次下载的长度加到进度条里
            progress += len;
            pb.setProgress(progress);
        
    • 每次断点下载时,从新的开始位置开始下载,进度条也要从新的位置开始显示,在读取缓存文件获取新的下载开始位置时,也要处理进度条进度

      FileInputStream fis = new FileInputStream(file);
      BufferedReader br = new BufferedReader(new InputStreamReader(fis));
      String text = br.readLine();
      int newStartIndex = Integer.parseInt(text);
      
      //新开始位置减去原本的开始位置,得到已经下载的数据长度
      int alreadyDownload = newStartIndex - startIndex;
      //把已经下载的长度设置入进度条
      progress += alreadyDownload;
      

    添加文本框显示百分比进度

        tv.setText(progress * 100 / pb.getMax() + "%");
    展开全文
  • Android myFirstIntnet 安卓网络编程的登陆和查询包含有服务类
  • 安卓网络编程入门

    2021-02-27 12:10:43
    1、网络编程入门 2、AsyncTask 为了方便子线程中对U进行操作, Android提供了一些好用的工具类到主线程,它的原理也是基于异步消息处理机制的AsyncTaskAsyncTask就是其中之一。借助,可以十分简单地从子线程切换 ...

    1、网络编程入门
    在这里插入图片描述

    在这里插入图片描述
    2、AsyncTask

    • 为了方便子线程中对U进行操作, Android提供了一些好用的工具类到主线程,它的原理也是基于异步消息处理机制的AsyncTaskAsyncTask就是其中之一。借助,可以十分简单地从子线程切换
      AsyncTask是一个抽象类,它有三个泛型参数,分别如下所示:
    • Params:执行异步任务时需要传入的参数,用于后合任务中使用
    • Progress后台任务执行时,如果需要在界面上显示当前的进度,则使用该参数作为进度单位
    • Result:当任务执行完毕后,如果需要对结果进行返回时,则使用该参数作为返回值类型
      在这里插入图片描述
    展开全文
  • 网络编程安卓中是一个很重要的部分,除非你做的是单机app,不然都要用到网络编程 介绍一下C/S架构,即客户端服务器的网络架构,C是Client客户端,S是Server服务端,基本流程就是客户端发送请求然后服务端做相应的...

    网络编程(一)网络编程概述

    • 网络编程在安卓中是一个很重要的部分,除非你做的是单机app,不然都要用到网络编程
    • 介绍一下C/S架构,即客户端服务器的网络架构,C是Client客户端,S是Server服务端,基本流程就是客户端发送请求然后服务端做相应的响应并且返回数据(如果需要)。
    • 根据连接的方式来说分为长连接和短连接,长连接就是socket网络编程,短连接就是http编程,长连接建立连接后,连接不会关闭,交互时可以直接使用socket中的I/O流即可,通常用于即时通信(IM)和大型游戏(LOL),短连接在发送请求后需要建立连接,返回响应后,连接断开,释放资源,这样可以节约服务端资源。
    • 另外还有一些协议和更深的内容会在后面更新
    展开全文
  • 零、前言 1.初衷 安卓一大堆网络框架,会用倒是会用,但总觉得封装得太多...为了更清晰的认识网络,打算从起点来看一下安卓的安卓网络编程 2.本文测试的url为已在服务器上,可访问: 访问返回Json地址:ht...
  • 第一步,依旧还是添加一下网络权限。 然后布局的话,随便建一个按钮添加点击事件就好。  下面放代码: 完整代码 package com.example.a4_17android_async_http; import android.os....
  • 安卓网络编程——HttpURLConnection

    千次阅读 2019-04-16 21:45:43
    安卓网络编程 引言 从2010年移动互联网的概念提出到如今,不管下一个风口是物联网还是大数据亦或是人工智能,未来的事不好预测,移动互联网的全面覆盖已经是板上钉钉。而网络编程技术自然是移动互联网绕不开的...
  • 随着H5性能的不断提升,虽然离原生APP还有一段不小的距离,但是WebAPP的体验比之当时,无疑是提升了不少。 今天介绍一个组件,可以实现将一个WebAPP->APP(俗称套壳APP? 大雾) 或者简单的理解——就是一个在...
  •  很早就想写关于网络编程的文章,今天先总结下;首先声明,在网上也找了好多资料,但上面的网址讲解的还是很基础、透彻的,别人的劳动成果,不敢贪天之功!  这里只是自己做些总结!  1、socket:是一种...
  • 实现场景:手机A作为客户端,手机B作为服务端,通过Socket实现信息交互...虽然是个简单的测试,但基本涵盖了Socket编程的所有基础知识 页面布局 socket编程1png 服务端显示效果 打开服务以及有设备加...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 762
精华内容 304
关键字:

安卓网络编程