Android网络技术

---恢复内容开始---

 

一 WebView控件

1.权限声明

因为需要互联网，所以声明权限

<uses-permission android:name="android.permission.INTERNET"/>

2.布局文件

 1 <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
 2     android:layout_width="match_parent"
 3     android:layout_height="match_parent">
 4 
 5     <WebView
 6         android:id="@+id/web_view"
 7         android:layout_width="match_parent"
 8         android:layout_height="match_parent" />
 9 
10 </LinearLayout>

布局文件很简单，只是使用了一个webview控件。

3.MainActivity文件

 1 public class MainActivity extends AppCompatActivity {
 2 
 3     @Override
 4     protected void onCreate(Bundle savedInstanceState) {
 5         super.onCreate(savedInstanceState);
 6         setContentView(R.layout.activity_main);
 7 
 8         WebView webView = (WebView)findViewById(R.id.web_view);
 9         //使用webView的getSetting方法进行设置，而这里设置其支持JavaScript脚本
10         webView.getSettings().setJavaScriptEnabled(true);
11         /*调用了setWebChromeClient()方法，并传入了一个实例。
12         * 作用是当网页跳转时，使用的还是webview，不会打开系统浏览器*/
13         webView.setWebChromeClient(new WebChromeClient());
14         webView.loadUrl("http://www.baidu.com");
15     }
16 }

如上，先对webview进行注册。然后进行相关设置。最后导入目标网址Uri。

 

二 使用HTTPURLConnection发送Http请求

1.步骤

　　1.权限声明，   

<uses-permission android:name="android.permission.INTERNET"/>

　　2.获取HttpURLConnection实例，new一个URL对象并传入目标网址，然后用openConnection（）方法

URL url = new URL("https://www.baidu.com");
HttpURLConnection connection = (HttpURLConnection)url.openConnection();

　　3.获取实例后，设置Http请求使用方法，是get还是post。

connection.setRequestMethod("GET");

　　4.设置其他属性，如连接超时，读取超时的毫秒数。

connection.setConnectTimeout(8000);
connection.setReadTimeout(8000);

　　5.调用getInputStream（）方法获得到服务器返回的输入流。之后就是对输入流进行读取。

InputStream in = connection.getInputStream();

2.实例代码

 1 public class MainActivity extends AppCompatActivity implements View.OnClickListener {
 2 
 3     TextView responseText;
 4 
 5     @Override
 6     protected void onCreate(Bundle savedInstanceState) {
 7         super.onCreate(savedInstanceState);
 8         setContentView(R.layout.activity_main);
 9         Button sendRequest = (Button)findViewById(R.id.send_request);
10         responseText = (TextView)findViewById(R.id.response_text);
11         sendRequest.setOnClickListener(this);
12     }
13 
14     @Override
15     public void onClick(View view) {
16         if(view.getId()==R.id.send_request){
17             sendRequestWithHttpURLConnection();
18         }
19     }
20 
21     private void sendRequestWithHttpURLConnection() {
22         /*开启线程来发起网络请求*/
23         new Thread(new Runnable() {
24             @Override
25             public void run() {
26                 HttpURLConnection connection = null;
27                 BufferedReader reader = null;  //缓冲字符输入流
28                 try{
29                     URL url = new URL("https://www.baidu.com");
30                     connection = (HttpURLConnection)url.openConnection();
31                     connection.setRequestMethod("GET");
32                     connection.setConnectTimeout(8000);
33                     connection.setReadTimeout(8000);
34                     InputStream in = connection.getInputStream();  //获得了服务器返回的输入流
35                     /*下面对获取到的输入流进行读取*/
36                     reader = new BufferedReader(new InputStreamReader(in));
37                     StringBuilder response = new StringBuilder();
38                     String line;
39                     while ((line=reader.readLine())!=null){
40                         response.append(line);
41                     }
42                     showResponse(response.toString());
43                 }catch (Exception e){
44                     e.printStackTrace();
45                 }finally {
46                     if(reader!=null){
47                         try{
48                             reader.close();
49                         } catch (IOException e) {
50                             e.printStackTrace();
51                         }
52                     }
53                     if(connection!=null){
54                         connection.disconnect();
55                     }
56                 }
57             }
58         }).start();
59     }
60 
61     private void showResponse(final String response){
62         runOnUiThread(new Runnable() {
63             @Override
64             public void run() {
65                 //在这里进行ui操作，将结果显示到页面上。
66                 responseText.setText(response);
67             }
68         });
69     }
70 }

 

三 使用OkHttp

1.添加依赖

因为okhttp不是原生库，需要添加依赖，在app/build.gradle文件中的 dependencies 闭包中添加依赖：

compile 'com.squareup.okhttp3:okhttp:3.4.1'

2.步骤

　　1.创建一个OkHttpClient实例

OkHttpClient client = new OkHttpClient();

　　2.创建一个Request对象，和之前创建通知时类似，使用builder构造器，将要加的属性加在后面，最后加上build（）。默认是get请求

1 Request request = new Request.Builder()
2              .url("http://www.baidu.com")
3              .build();

　　3.使用OKhttpclient的newCall（）来创造一个call对象，并调用他的执行方法execute（）来发送请求并获得服务器返回的数据。其中Response（响应）对象就是服务器返回的数据

Response response = client.newCall(request).execute();

　　4.得到返回的具体内容

String responseData = response.body().string();

　　5.如果是post请求，则需要先构造出RequestBody对象来存储要提交的数据。

1 RequestBody requestBody = new FormBody.Builder()
2          .add("username","admin")
3          .add("password","123123")
4          .build();

　　然后在第二步中的Request.builder中调用一下post（）方法，将RequestBody对象传入：

1 Request request = new Request.Builder()
2          .url("http://www.baidu.com")
3          .post(requestBody)
4          .build();

3.实例代码：

 1 public class MainActivity extends AppCompatActivity implements View.OnClickListener {
 2 
 3     TextView responseText;
 4 
 5     @Override
 6     protected void onCreate(Bundle savedInstanceState) {
 7         super.onCreate(savedInstanceState);
 8         setContentView(R.layout.activity_main);
 9         Button sendRequest = (Button) findViewById(R.id.send_request);
10         responseText = (TextView) findViewById(R.id.response_text);
11         sendRequest.setOnClickListener(this);
12     }
13 
14     @Override
15     public void onClick(View view) {
16         if (view.getId() == R.id.send_request) {
17             sendRequestWithOkHttp();
18         }
19     }
20 
21     private void sendRequestWithOkHttp() {
22         /*开启线程来发起网络请求*/
23         new Thread(new Runnable() {
24             @Override
25             public void run() {
26                 try {
27                     OkHttpClient client = new OkHttpClient();
28                     Request request = new Request.Builder()
29                             .url("http://www.baidu.com")
30                             .build();
31                     Response response = client.newCall(request).execute();
32                     String responseData = response.body().string();
33                     showResponse(responseData);
34                 } catch (Exception e) {
35                     e.printStackTrace();
36                 }
37             }
38         }).start();
39     }
40 
41     private void showResponse(final String response) {
42         runOnUiThread(new Runnable() {
43             @Override
44             public void run() {
45                 //在这里进行ui操作，将结果显示到页面上。
46                 responseText.setText(response);
47             }
48         });
49     }
50 }

 

四 解析XML格式数据

1.搭建服务器以及创建xml文件

Apache官方下载地址：官方下载地址

下载后点击http.exe即可打开服务器。然后在Apache\htdoce目录下创建xml文件。名为get_data.xml：

 1 <apps>
 2     <app>
 3         <id>1</id>
 4         <name>Google Maps</name>
 5         <version>1.0</version>
 6     </app>
 7     <app>
 8         <id>2</id>
 9         <name>chorme</name>
10         <version>2.1</version>
11     </app><app>
12         <id>31</id>
13         <name>Google Play</name>
14         <version>2.3</version>
15     </app>
16 </apps>

在浏览器中访问 127.0.0.1/get_data.xml就可以进行访问到了：

2.Pull 解析方法

　　1.在request的builde（）中设置url为本机地址： .url（“http://10.0.2.2/get_data.xml”).build(); 。并且调用parseXMLWithPull（）方法来解析服务器返回的数据。

　　2.在parseXMLWithPull（）中，首先先要获取一个XmlPullParserFactory的实例，并通过实例获取XmlPullParser对象。

XmlPullParserFactory factory = XmlPullParserFactory.newInstance();
XmlPullParser xmlPullParser = factory.newPullParser();

　　3.调用XmlPullParser的setInput方法，将服务器返回的xml数据设置进去开始解析。

xmlPullParser.setInput(new StringReader(xmlData));

　　4.解析过程：首先通过getEventType（）可以得到当前的解析事件，在while循环中进行解析，如果解析事件没结束，在循环结束时，调用next（）获取下一个解析事件。

1 int eventType = xmlPullParser.getEventType();
2 while (eventType != XmlPullParser.END_DOCUMENT) {
3     ······
4     eventType = xmlPullParser.next();
5 }

　　5.在while中，使用getNAME（）得到当前节点名字，如果等于id，name，version等关键字，则使用newtText（）来获取到节点中的内容。每解析完一个app节点后打印。

 1             String nodeName = xmlPullParser.getName();
 2                 switch (eventType) {
 3                     //开始解析某个节点
 4                     case XmlPullParser.START_TAG: {
 5                         if ("id".equals(nodeName)) {
 6                             id = xmlPullParser.nextText();
 7                         } else if ("name".equals(nodeName)) {
 8                             name = xmlPullParser.nextText();
 9                         } else if ("version".equals(nodeName)) {
10                             version = xmlPullParser.nextText();
11                         }
12                         break;
13                     }
14                     //完成解析某个节点
15                     case XmlPullParser.END_TAG: {
16                         if ("app".equals(nodeName)) {
17                             Log.d("MainAcitvity", "id is " + id);
18                             Log.d("MainAcitvity", "name is " + name);
19                             Log.d("MainAcitvity", "version is " + version);
20                         }
21                         break;
22                     }
23                     default:
24                         break;
25                 }        

 

整体代码如下：

 1     private void sendRequestWithOkHttp() {
 2         /*开启线程来发起网络请求*/
 3         new Thread(new Runnable() {
 4             @Override
 5             public void run() {
 6                 try {
 7                     Log.d("MainActivity", "进入线程");
 8                     OkHttpClient client = new OkHttpClient();
 9                     Request request = new Request.Builder()
10                             .url("http://10.0.2.2/get_data.xml")
11                             .build();
12                     Response response = client.newCall(request).execute();
13                     String responseData = response.body().string();
14                     parseXMLWithPull(responseData);
15                 } catch (Exception e) {
16                     e.printStackTrace();
17                 }
18             }
19         }).start();
20     }
21 
22     private void parseXMLWithPull(String xmlData) {
23         try {
24             XmlPullParserFactory factory = XmlPullParserFactory.newInstance();
25             XmlPullParser xmlPullParser = factory.newPullParser();
26             xmlPullParser.setInput(new StringReader(xmlData));
27             String id = "";
28             String name = "";
29             String version = "";
30             int eventType = xmlPullParser.getEventType();
31             while (eventType != XmlPullParser.END_DOCUMENT) {
32                 String nodeName = xmlPullParser.getName();
33                 switch (eventType) {
34                     //开始解析某个节点
35                     case XmlPullParser.START_TAG: {
36                         if ("id".equals(nodeName)) {
37                             id = xmlPullParser.nextText();
38                         } else if ("name".equals(nodeName)) {
39                             name = xmlPullParser.nextText();
40                         } else if ("version".equals(nodeName)) {
41                             version = xmlPullParser.nextText();
42                         }
43                         break;
44                     }
45                     //完成解析某个节点
46                     case XmlPullParser.END_TAG: {
47                         if ("app".equals(nodeName)) {
48                             Log.d("MainAcitvity", "id is " + id);
49                             Log.d("MainAcitvity", "name is " + name);
50                             Log.d("MainAcitvity", "version is " + version);
51                         }
52                         break;
53                     }
54                     default:
55                         break;
56                 }
57                 eventType = xmlPullParser.next();
58             }
59         } catch (Exception e) {
60             e.printStackTrace();
61         }
62     }

 

五 解析JSON格式数据

1.创建json格式数据

同上在htdocs目录中创建一个get_data.json如下：

[{"id":"5","version":"5.1","name":"the one"},
{"id":"6","version":"6.1","name":"the two"},
{"id":"7","version":"7.1","name":"the three"}]

在浏览器上访问本地数据如下：

 

2.使用JSONObject解析数据

因为服务器中定义的是一个json数组，将传入数据先放在一个JSONArray中，然后遍历这个JSONArray，取出每一个JSONObject对象，并使用getString（）取出每一个数据进行打印。

 1     private void parseJSONWithJSONObject(String jsonData) {
 2         try{
 3             /*服务器定义的是一个json数据，遍历jsonArray数组中每一个对象都是一个JSONObject对象*/
 4             JSONArray jsonArray = new JSONArray(jsonData);
 5             for(int i= 0;i<jsonArray.length();i++){
 6                 JSONObject jsonObject = jsonArray.getJSONObject(i);
 7                 String id = jsonObject.getString("id");
 8                 String name = jsonObject.getString("name");
 9                 String version = jsonObject.getString("version");
10                 Log.d("MainActivity","id is "+id);
11                 Log.d("MainActivity","name is "+id);
12                 Log.d("MainActivity","version is "+version);
13             }
14         }catch (Exception e){
15             e.printStackTrace();
16         }
17     }

整体代码简单易懂。

 

3.使用GSON方法解析

GSON库可以将一段json格式字符串自动映射为一个对象。

　　1.添加GSON库的依赖

　　在app/build.gradle的dependdependncies中添加依赖

compile 'com.google.code.gson:gson:2.7'

　　2.如果一段json格式数据如下： {“name”：“tom”，“age”：“29”}  那么可以定义一个person类，创建name和age两个字段，然后简单的调用如下代码就可以将json自动解析为一个person对象。

Gson gson = new gson();
Person person = gson.fromJson(jsonData,Person.class);

　　3.如果是一段json数组格式数据。需要借助TypeToken将期望解析成的数据类型传入到jsonFrom方法中：如下

List<Person> people = gson.fromJson(jsonData,new TypeToken<List<Person>>(){}.getType());

 

实例如下：

新建一个App类：

 1 public class App {
 2     private String id;
 3     private String name;
 4     private String version;
 5 
 6     public String getId() {
 7         return id;
 8     }
 9 
10     public String getName() {
11         return name;
12     }
13 
14     public String getVersion() {
15         return version;
16     }
17 
18     public void setId(String id) {
19         this.id = id;
20     }
21 
22     public void setName(String name) {
23         this.name = name;
24     }
25 
26     public void setVersion(String version) {
27         this.version = version;
28     }
29 }

修改MainActivity中解析部分的代码：

1     private void parseJSONWithGSON(String jsonData) {
2         Gson gson = new Gson();
3         List<App> appList = gson.fromJson(jsonData,new TypeToken<List<App>>(){}.getType());
4         for(App app:appList){
5             Log.d("MainActivity","id is "+app.getId());
6             Log.d("MainActivity","name is "+app.getName());
7             Log.d("MainActivity","version is "+app.getVersion());
8         }
9     }

 

转载于:https://www.cnblogs.com/Mask-D/p/9549935.html