使用URLConnection进行访问

最新推荐文章于 2023-12-21 16:44:43 发布
最新推荐文章于 2023-12-21 16:44:43 发布
阅读量126 收藏
点赞数 1
文章标签： java
原文链接：http://www.cnblogs.com/jinzhiming/p/8533869.html
版权 
package test;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.net.HttpURLConnection;
import java.net.InetSocketAddress;
import java.net.MalformedURLException;
import java.net.ProtocolException;
import java.net.Proxy;
import java.net.URL;
import java.net.URLConnection;
import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.HashMap;
import java.util.Map;

import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSession;
import javax.net.ssl.SSLSocketFactory;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;

import org.apache.log4j.Logger;

import sun.misc.BASE64Encoder;

public class HttpUtil {
    
    private static Logger logger = Logger.getLogger(HttpUtil.class);
    private String DEFAULT_CHARSET = "UTF-8";
    private String DEFAULT_CONTENT_TYPE = "application/x-www-form-urlencoded";
    
    public void setCharSet(String charSet){
        this.DEFAULT_CHARSET = charSet;
    }
    
    public void setContentType(String contentType){
        this.DEFAULT_CONTENT_TYPE = contentType;
    }
    
    public String post(String urlStr, Map<String, String> paramMap){
        return post(urlStr, paramMap, null);
    }
    
    
    public String post(String urlStr, Map<String, String> paramMap, Map<String, Object> proxyMap){
         Map<String, String> formatUrlMap = formatUrlStr(urlStr);
         if(formatUrlMap==null){
             return "";
         }
         
         urlStr = formatUrlMap.get("url");
         logger.info("url请求地址："+urlStr);
         String urlParam = formatUrlMap.get("param");
         
         String allParam = formatParam(urlParam, paramMap);
         logger.info("整合得到参数串："+allParam);
         
         return post(urlStr, allParam, proxyMap);
    }
    
    public String post(String urlStr, String paramStr, Map<String, Object> proxyMap){
        URL url = null;
        URLConnection urlConnection = null;
        try {
            url = new URL(urlStr);
            
            if(proxyMap!=null&&proxyMap.size()>0&&proxyMap.get("proxy")!=null){
                Proxy proxy = (Proxy)proxyMap.get("proxy");
                urlConnection = url.openConnection(proxy);
                logger.info("使用代理模式连接");
            }else{
                urlConnection = url.openConnection();
            }
            
        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        
        if(urlConnection==null){
            logger.info("创建url连接失败");
            return "";
        }
        
        if(urlStr.startsWith("https")){
            logger.info("请求地址是https类型，进行设置");
            SSLSocketFactory sslSocketFactory = null;
            try {
                SSLContext sslContext = SSLContext.getInstance("TLS");
                TrustManager[] trustManagers = initTrustManager();
                sslContext.init(null, trustManagers, new SecureRandom());
                sslSocketFactory = sslContext.getSocketFactory();
            } catch (NoSuchAlgorithmException e) {
                e.printStackTrace();
            } catch (KeyManagementException e) {
                e.printStackTrace();
            }
            
            HttpsURLConnection httpsURLConnection = (HttpsURLConnection)urlConnection;
            httpsURLConnection.setSSLSocketFactory(sslSocketFactory);
            httpsURLConnection.setHostnameVerifier(initHostnameVerifier());
        }
        
        HttpURLConnection httpURLConnection = (HttpURLConnection)urlConnection;
        //如果有代理，查看是否有账号密码授权，进行授权
        if(proxyMap!=null&&proxyMap.size()>0&&proxyMap.get("proxy")!=null){
            Object accountObj = proxyMap.get("account");
            Object passwordObj = proxyMap.get("password");
            
            String account = "";
            if(accountObj!=null){
                account = (String)accountObj;
            }
            String password = "";
            if(passwordObj!=null){
                password = (String)passwordObj;
            }
            
            if(!"".equals(account)&&!"".equals(password)){
                logger.info("代理授权账号和密码："+account+" / "+password);
                String headerKey = "Proxy-Authorization";
                BASE64Encoder base64Encoder = new BASE64Encoder();
                String headerVal = "Basic "+base64Encoder.encode((account+":"+password).getBytes());
                httpURLConnection.setRequestProperty(headerKey, headerVal);
            }
        }
        
        httpURLConnection.setDoInput(true);
        httpURLConnection.setDoOutput(true);
        httpURLConnection.setUseCaches(false);
        httpURLConnection.setConnectTimeout(5000);
        httpURLConnection.setReadTimeout(5000);
        httpURLConnection.setRequestProperty("accept", "*/*");
        httpURLConnection.setRequestProperty("connection", "Keep-Alive");
        httpURLConnection.setRequestProperty("User-Agent", "Mozilla/5.0 (X11; U; Linux i686; zh-CN; rv:1.9.1.2) Gecko/20090803 Fedora/3.5.2-2.fc11 Firefox/3.5.2");
        
        //requestMethod默认POST
        try {
            httpURLConnection.setRequestMethod("POST");
        } catch (ProtocolException e) {
            e.printStackTrace();
        }
        httpURLConnection.setRequestProperty("Content-type",DEFAULT_CONTENT_TYPE+";charset="+DEFAULT_CHARSET);
        
        if(paramStr==null){
            paramStr = "";
        }
        httpURLConnection.setRequestProperty("Content-Length", String.valueOf(paramStr.length()));
        
        BufferedWriter bw = null;
        OutputStreamWriter osw = null;
        OutputStream os = null;
        try {
            os = httpURLConnection.getOutputStream();
            osw = new OutputStreamWriter(os);
            bw = new BufferedWriter(osw);
            bw.write(paramStr);
            bw.flush();
            
            httpURLConnection.connect();
            logger.info("连接开启");
        } catch (IOException e) {
            e.printStackTrace();
        } finally{
            try {
                if(bw!=null){
                    bw.close();
                }
                if(osw!=null){
                    osw.close();
                }
                if(os!=null){
                    os.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        
        String result = null;
        BufferedReader br = null;
        InputStreamReader isr = null;
        InputStream is = null;
        try {
            int responseCode = httpURLConnection.getResponseCode();
            logger.info("返回码："+responseCode);
            if(responseCode==200){
                is = httpURLConnection.getInputStream();
                isr = new InputStreamReader(is);
                br = new BufferedReader(isr);
                
                StringBuilder sb = new StringBuilder();
                
                String temp = null;
                while((temp=br.readLine())!=null){
                    sb.append(temp);
                }
                
                result = sb.toString();
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if(br!=null){
                    br.close();
                }
                if(isr!=null){
                    isr.close();
                }
                if(is!=null){
                    is.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        
        httpURLConnection.disconnect();
        logger.info("连接关闭");
        
        return result;
    }
    
    /**
     * 添加代理
     * @param hostname
     * @param port
     * @param account
     * @param password
     * @return
     */
    public Map<String, Object> addProxy(String hostname,int port,String account,String password){
        Proxy proxy = null;
        try {
            InetSocketAddress address = new InetSocketAddress(hostname, port);
            proxy = new Proxy(Proxy.Type.HTTP, address);
        } catch (Exception e) {
            e.printStackTrace();
            logger.error("添加代理异常");
        }
        
        Map<String, Object> map = new HashMap<String, Object>();
        map.put("proxy", proxy);
        map.put("account", account);
        map.put("password", password);
        return map;
    }
    
    
    private static Map<String, String> formatUrlStr(String urlStr){
        Map<String, String> map = new HashMap<String, String>();
        
        if(urlStr==null||urlStr.trim().length()==0){
            logger.warn("URL为空");
            return null;
        }
        
        String param = null;
        if(urlStr.contains("?")){
            int urlEndIndex = urlStr.indexOf("?");
            param = urlStr.substring(urlEndIndex+1);
            urlStr = urlStr.substring(0, urlEndIndex);
        }
        
        if(!urlStr.startsWith("http")){
            if(urlStr.startsWith("//")){
                urlStr = "http:" + urlStr;
            }else{
                urlStr = "http://" + urlStr;
            }
        }
        
        map.put("url", urlStr);
        map.put("param", param);
        return map;
    }
    
    
    private static String formatParam(String param,Map<String, String> paramMap){
        Map<String, String> m = null;
        if(paramMap==null){
            m = new HashMap<String, String>();
        }else{
            m = paramMap;
        }
        
        if(param!=null&&param.length()>0){
            String[] keyAndValues = param.split("&");
            if(keyAndValues!=null&&keyAndValues.length>0){
                for(String keyAndValue :keyAndValues){
                    String[] arr = keyAndValue.split("=",2);
                    if(arr==null||arr.length==0){
                        continue;
                    }
                    String key = arr[0];
                    String value = arr[1];
                    
                    m.put(key, value);
                }
            }
        }
        
        if(m==null||m.size()==0){
            return "";
        }
        
        String rs = "";
        
        for(String key :m.keySet()){
            String value = m.get(key);
            
            rs += (key+"="+value+"&");
        }
        
        return rs;
    }
    
    
    private static TrustManager[] initTrustManager(){
        TrustManager X509TrustManager = new X509TrustManager() {
            
            @Override
            public X509Certificate[] getAcceptedIssuers() {
                return null;
            }
            
            @Override
            public void checkServerTrusted(X509Certificate[] arg0, String arg1)
                    throws CertificateException {
                
            }
            
            @Override
            public void checkClientTrusted(X509Certificate[] arg0, String arg1)
                    throws CertificateException {
                
            }
        };
        
        
        TrustManager[] trustManagers = {X509TrustManager};
        
        return trustManagers;
    }
    
    private static HostnameVerifier initHostnameVerifier(){
        return new HostnameVerifier() {
            
            @Override
            public boolean verify(String hostname, SSLSession session) {
                return true;
            }
        };
    }
    
}

 

转载于:https://www.cnblogs.com/jinzhiming/p/8533869.html

ddak56357
关注
java swing httpurlconnection阻塞_一定要为HttpUrlConnection设置connectTimeout属性以防止连接被阻塞...
weixin_35990136的博客
02-28 515
我们有一个项目中用到了多个子项目，即将多个子项目的连接地址整合在一起。在客户部署环境中，有一个主终端，负责接受用户登陆，在登陆时，由用户选择最终要登陆的子系统。当输入登陆信息之后，由主终端负责解析用户名和密码，待验证通过之后，再通过主终端负责将用户信息直接发往子系统并通过子系统接口转入到后台操作界面。整个流程就类似于一个统一授权中心，由主终端负责用户授权和访问，在获得授权之后，就可以直接操作子系统...
使用URLConnection访问WeatherAPI
m0_62254710的博客
10-28 517
Adroid Studio 使用URLConnection访问WeatherAPI
android网络应用2——URLConnection
06-25 530
http://blog.csdn.net/yijincoldplay/article/details/8275986 ps:以下内容来自对李刚的《疯狂Android讲义》的学习 URL 的openConnection()方法返回一个URLConnection对象，此对象代表程序与URL的通信连接，程序可以通过URLConnection对象向此URL发送请求，读取此URL代表的远程资源。
使用HttpURLConnection访问网络
CSDN_justin的博客
10-05 375
package com.example.justin.httpurlconnection;import android.os.Handler; import android.os.Message; import android.support.v7.app.AppCompatActivity; import android.os.Bundle; import android.view.Vie
简单使用URLConnection、HttpURLConnection和HttpClient访问网络资源
孤云博客
07-17 1万+
随时随地阅读更多技术实战干货，获取项目源码、学习资料，请关注源代码社区公众号(ydmsq666) URL的openConnection方法将返回一个URLConnection，该对象表示应用程序和URL之间的通信连接。程序可以通过它的实例向该URL发送请求，读取URL引用的资源。 下面通过一个简单示例来演示：...
Java-URLConnection介绍
最新发布
架构师之路。。
12-21 1176
Java中的URLConnection类是用于建立与URL之间的连接的抽象类。它是Java标准库中的一部分，位于java.net包下。URLConnection类可以用于与服务器建立HTTP、HTTPS或FTP连接，并通过输入流和输出流与服务器进行数据交互。它提供了一组用于设置请求属性、获取响应属性、发送请求和接收响应的方法。
Android开发使用URLConnection进行网络编程详解
08-28
Android 开发使用 URLConnection 进行网络编程详解 Android 开发使用 URLConnection 进行网络编程是 Android 开发中的一种常见的网络编程方式。URLConnection 是 Java 中的一个类，用于表示应用程序和 URL 之间的...
例10.03 使用URLConnection对象访问远程文件.rar_remote access java_url_远程文件
09-19
总结，使用`URLConnection`访问远程文件涉及多个步骤，包括创建URL对象，建立连接，设置请求属性，读取或写入数据，并处理响应。通过熟练掌握这些概念和方法，开发者可以构建功能强大的网络应用程序，轻松地与远程...
Java使用URLConnection进行POST表单提交
`URLConnection` 可以用于读写数据，创建新的文件或访问远程文件系统。 2. **POST方法**：在HTTP协议中，POST方法用于向指定资源提交数据，请求服务器进行处理（例如提交表单或者上传文件）。数据被包含在请求体中...
URL connection与HttpClientt的用法及区别
xiaosheng_papa的专栏
05-12 1171
URL与HttpClent都是用来远程调用，它们的原理就是通过程序模拟浏览器的行为来获取或者像服务器提交数据。 URL是jdk自带的java.net.URL; HttpClent是apache提供的，它们两个用法及结果都大同小异吧。 URL的用法： public static String testURLconn(String httpUrl){ String html =
URLConnection 的基本用法
weixin_43860634的博客
09-29 450
【代码】URLConnection 的基本用法。
使用HttpURLConnection进行网络访问
qq_32534441的博客
12-13 2996
阅读：https://blog.csdn.net/wei_zhi/article/details/52997246 https://blog.csdn.net/rocoloco/article/details/78057384 一、概述 在Android 上发送HTTP 请求的方式一般有两种：HttpURLConnection 和HttpClient。因为在Android 5.0之后，HttpCl...
使用HttpURLConnection访问URL地址
jonatha_n
08-17 4973
HttpURLConnection连接工具方法
java swing 下载文件_在下载文件时使用swing GUI显示进度条
weixin_34997006的博客
02-24 475
小编典典您的是经典的Swing并发问题。解决方案始终如一-在后台线程中运行长时间的代码，例如可以在SwingWorker中找到的代码。例如，import java.awt.FlowLayout;import java.beans.PropertyChangeEvent;import java.beans.PropertyChangeListener;import java.io.*;import ...
使用HttpURLConnection访问web页面
各研发管理
12-11 172
URLConnection类给应用程序和web资源之间架设起了通信的桥梁，这些web资源通常是通过url来标记的，比如http://java.sun.com。本文将讲述如何使用HttpURLConnection来访问web页面。 URLConnection是个抽象类，它有两个直接子类分别是HttpURLConnection和JarURLConnection。另外一个重要的类是URL，...
HttpUrlConnection使用详解
热门推荐
fightingXia的博客
05-13 7万+
一，HttpURLconnection的介绍在Android开发中网络请求是最常用的操作之一， Android SDK中对HTTP(超文本传输协议)也提供了很好的支持，这里包括两种接口: 1、标准Java接口(java.NET) —-HttpURLConnection，可以实现简单的基于URL请求、响应功能； 2、Apache接口(org.appache.http)—-HttpClient，使用
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值