HttpUrlConnnection

1 从服务器获取内容

从服务器获取内容都是以流的方式获取的，可以获取字符串，文件，图片等等，所有的东西都是通过文件流获取的。
下面是一个从服务端获取内容的完整步骤
网络请求首先需要先开启权限

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

进行网络请求

//网络请求是耗时操作，必须要放在子线程中进行
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    // 0 网络请求时需要捕获一些异常
                    // 1 创建一个URl对象，传入url地址
                    URL url=new URL(sourceUrl);
                    // 2 开启HttpUrlConnection
                    HttpURLConnection connection=(HttpURLConnection)url.openConnection();
                    // 3 设置请求方式,必须要大写
                    connection.setRequestMethod("GET");
                    // 4 设置请求超时时间,单位是毫秒
                    connection.setConnectTimeout(5000);
                    // 5 获取返回码
                    int code=connection.getResponseCode();
                    Log.i("test",""+code);
                    // 6 根据返回码做相应处理
                    if(code==200)
                    {
                        // 7 如果连接正常，则获取返回的输入流
                        InputStream in=connection.getInputStream();
                        // 8 对输入流进行处理
                        // 8.1 初始化一个内存输出流，将输入流读出到内存中
                        ByteArrayOutputStream outputStream=new ByteArrayOutputStream();
                        // 8.2 设置每次读入的字节数特，1024，每次读入1kb
                        byte[] bytes=new byte[1024];
                        // 8.3每次读入的字节数
                        int len=-1;
                        while((len=in.read(bytes))!=-1)
                        {
                            // 8.4 将读入的字节写入内存中
                            outputStream.write(bytes,0,len);
                        }
                        //8.4 关闭输入流，内存输出流不需要关闭
                        in.close();
                        String output=new String(outputStream.toByteArray());

                    }
                } catch (MalformedURLException e) {
                    e.printStackTrace();
                }catch (IOException e)
                {
                    e.printStackTrace();
                }
            }
        }).start();

上面是一个整个的过程，但是一般网络请求，和解析输入流都会写成单独的工具类
将输入流转换成字符串的工具类

public class MyStreamUtil {
    public static String streamToString(InputStream in)
    {
        byte[] bytes=new byte[1024];
        int len=-1;
        ByteArrayOutputStream out=new ByteArrayOutputStream();
        try {
            while((len=in.read(bytes))>0)
            {
                out.write(bytes,0,len);
            }
            in.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

        String string=new String(out.toByteArray());
        return string;
    }
}

网络请求的工具类

public class MyHttpUtil {
    public static void getNews(final String url1, final Context context)
    {
        new Thread(new Runnable() {
             @Override
             public void run() {
                 try {
                     URL url=new URL(url1);
                     HttpURLConnection connection=(HttpURLConnection) url.openConnection();
                     connection.setRequestMethod("GET");
                     connection.setConnectTimeout(5000);
                     int code=connection.getResponseCode();
                     if(code==200)
                     {
                         InputStream in=connection.getInputStream();
                         String jsonString=MyStreamUtil.streamToString(in);
                     }

                 } catch (Exception e) {
                     e.printStackTrace();
                 } finally {
                 }
             }
         }).start();
    }
}

在获取到输入流之后，可以根据相应的需求进行如下处理
1 如果是json字符串，则将输入流转换为String类型的字符串，在对json字符串进行解析
2 如果是文件，图片等类型，则可以不采用内存输出流，直接使用文件流对文件进行存储，或者使用BitmapFactory工厂类对图片类型的流进行处理

2 GET方式向服务器提交数据

GET方式提交数据只能用于少量数据的提交（小于1kb），GET方式其实就是拼接字符串的方式进行数据的发送。
GET方式提交数据和上面网络请求区别很少，只需要吧URL改变即可，
服务器端就可以按照相应的处理GET请求的方式接收数据

//GET方式的url用问好分开，前面是地址，后面是以key-value方式传入的数据
    //每一对数据之间用&分开
    private String name="aaa";
    private int pwd=123;
    private final String getUrl="http://139.129.110.99:8901/test?name="+name+"&pwd="+pwd+"";

3 POST方式提交数据
POST方式向服务端提供数据是以流的方式进行的，和GET方式有以下几点不同
1 url地址中不传入具体的参数
2 请求方式变为POST
3 需要设置请求头信息
4 通过输出流的方式将数据传到服务端
具体过程如下，~~~~~~标出的是和GET方式不同的地方

 //设置URL地址~~~~~~~~~~~~~~~~~~~~~~~~~~
    private final String postUrl="http://139.129.110.99:8901/posttest";
//设置传入的内容，key-value形式，每一对参数之间用&分开
        final String content="name="+name+"&pwd="+pwd;
        //网络请求是耗时操作，必须要放在子线程中进行
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    // 0 网络请求时需要捕获一些异常
                    // 1 创建一个URl对象，传入url地址
                    URL url=new URL(getUrl);
                    // 2 开启HttpUrlConnection
                    HttpURLConnection connection=(HttpURLConnection)url.openConnection();
                    // 3 设置请求方式,必须要大写~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
                    connection.setRequestMethod("POST");
                    // 3.1 设置请求头信息,Content-Type设置为application/x-www-form-urlencoded，
                    //代表传入的内容是key-value形式的~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
                    connection.setRequestProperty("Content-Type","application/x-www-form-urlencoded");
                    // 3.2 设置传入的内容的长度，就是content的长度~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
                    connection.setRequestProperty("Content-Length",""+content.length());
                    // 4 设置请求超时时间,单位是毫秒
                    connection.setConnectTimeout(5000);
                    // 5设置允许向服务端传数据~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
                    connection.setDoOutput(true);
                    //获取输出流，并将内容传入服务端
                    OutPutStream out=connection.getOutputStream();
                    out.write(content.getBytes());
                    out.close();
                    // 6 获取返回码
                    int code=connection.getResponseCode();
                    Log.i("test",""+code);
                    // 7 根据返回码做相应处理
                    if(code==200)
                    {
                        // 8 如果连接正常，则获取返回的输入流
                        InputStream in=connection.getInputStream();
                        // 9 对输入流进行处理
                        // 9.1 初始化一个内存输出流，将输入流读出到内存中
                        ByteArrayOutputStream outputStream=new ByteArrayOutputStream();
                        // 9.2 设置每次读入的字节数特，1024，每次读入1kb
                        byte[] bytes=new byte[1024];
                        // 9.3每次读入的字节数
                        int len=-1;
                        while((len=in.read(bytes))!=-1)
                        {
                            // 8.4 将读入的字节写入内存中
                            outputStream.write(bytes,0,len);
                        }
                        //9.4 关闭输入流，内存输出流不需要关闭
                        in.close();
                        String output=new String(outputStream.toByteArray());
                        Log.i("test",output);

                    }
                } catch (MalformedURLException e) {
                    e.printStackTrace();
                }catch (IOException e)
                {
                    e.printStackTrace();
                }
            }
        }).start();

关于Content-Type
1 application/x-www-form-urlencoded
这种方式代表传入的为key-value形式，content中的内容就像上面的程序那样，服务端接收时，根据传入的值接收数据
2 application/json
这种方式代表传入一个json字符串，content中的内容就是一个json字符串，服务端接收这个字符串，并解析
3 multipart/form-data
这种方式是最复杂的，代表表单上传。实际中很少直接用httpUrlConnection实现表单的上传，一般都用网络请求框架去实现
这种方式可以实现单个文件的上传，多个文件的上传，带有文件的表单的上传（例如完善注册信息的功能，需要既上传文字，又上传图片）。
步骤
1 模拟http文件上传的格式
文件上传时格式如下，这几个时主要的必须写的，其他的可以不写，都会默认填充。

（boundary是自己定义的，什么样都可以，
  name和filename是自己定义的，其他的都是固定格式。
  无论是否传文件，name和filename都必须有，后台接收文件时按照name接收，但是filename也需要存在）
Content-Type: multipart/form-data; boundary=-------zzzz(文件头，一组文件只要一个)
---------zzzz（每一个文件开始的标志，在boundary前面加2个-）
Content-Disposition: form-data; name="ttt"; filename="123"
第一个空行
第二个空行
abece（这个是名字为ttt的内容）
---------zzzz
Content-Disposition: form-data; name="aaa"; filename="aaa.jpg"
第一个空行
第二个空行
图片文件.
.
.(有多少个文件，就按这种方式写多少个)
.
.
---------zzzz--（文件尾，一组文件只要一个。结尾另起新的一行，在前面定义的boundary前后各加2个-）

所以按照上面的格式，就可以自己仿照文件上传的格式进行文件上传
下面的代码在一个表单中上传了2个文件，如果要继续上传文件，按照格式写就可以

new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    //定义自己的boundary
                    String boundary="------zzzz";
                    URL url=new URL(postUrl);
                    HttpURLConnection connection=(HttpURLConnection)url.openConnection();
                    connection.setRequestMethod("POST");
                    connection.setConnectTimeout(5000);
                    connection.setDoOutput(true);
                    //定义文件头
                    connection.setRequestProperty("Content-Type","multipart/form-data;boundary="+boundary);
                    //获取输出流
                    OutputStream out=connection.getOutputStream();
                    //第一个文件开始，这个其实是一个key-value对
                    //先定义一个sb字符串，用于传送第一个文件的各种信息
                    StringBuilder sb=new StringBuilder();
                    //开头是--------zzzz，然后加\r\n,回车并换行
                    sb.append("--").append(boundary).append("\r\n");
                    //第二行的内容，定义好name和filename
                    sb.append("Content-Disposition:form-data;name=\"ttt\";filename=\"ttt1vv.tt\"");
                    //再空两行
                    sb.append("\r\n\r\n");
                    //第一个文件的内容，这里就是一个字符串，所以直接加了进行
                    sb.append("zyl");
                    //将第一个文件的内容加入输出流
                    out.write(sb.toString().getBytes());
                    //在输出流里加入换行，开始第二个文件，每个文件都需要新起一行
                    out.write("\r\n".getBytes());
                    //第二个文件开始
                    //定义字符串
                    StringBuilder sb1=new StringBuilder();
                    //开头是--------zzzz，然后加\r\n,回车并换行
                    sb1.append("--"+boundary+"\r\n");
                    //第二行的内容，定义好name和filename
                    sb1.append("Content-Disposition:form-data;name=\"aaa\";filename=\"aaavv\"");
                    //空两行，后面是文件的内容
                    sb1.append("\r\n\r\n");
                    //先将这些加入输出流，因为这个文件的内容是一个文件，所以后面直接把内容加入输出流
                    out.write(sb1.toString().getBytes());
                    //获取到对应的问价
                    File file=new File(Environment.getExternalStorageDirectory(),"Pictures");
                    Log.i("test",file.getAbsolutePath());
                    if(!file.exists())
                    {
                        file.mkdirs();
                    }
                    File newFile=new File(file,"b.png");
                    if(!newFile.exists())
                    {
                        newFile.createNewFile();
                    }

                        FileInputStream fileInputStream=new FileInputStream(newFile);
                        int len=-1;
                        byte[] bytes=new byte[1024];
                    //将文件加入输出流
                        while ((len=fileInputStream.read(bytes))!=-1)
                        {
                            out.write(bytes,0,len);
                        }
                    //定义文件组的结尾
                    byte[] endData=("\r\n--"+boundary+"--"+"\r\n").getBytes();
                    //将结尾加入输出流
                    out.write(endData);
                    //关闭输出流，输出流被上传到服务器
                    out.close();
                    //后面再开始接收服务器返回的内容，这里就不继续写了
                    Log.i("test",""+connection.getResponseCode());
                } catch (MalformedURLException e) {
                    e.printStackTrace();
                    Log.i("test","0");
                }catch (IOException e)
                {
                    e.printStackTrace();
                    Log.i("test","1");
                }
            }
        }).start();