JAVA怎样调用https类型的webservice

Posted 2023-05-06

参考技术A 以下主要讲解如何使用https发起post请求：
参考文档：梁栋前辈的《Java加密与解密的艺术》
[java] view plain copy
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.MalformedURLException;
import java.net.URL;
import java.security.GeneralSecurityException;
import java.security.KeyStore;

import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.KeyManagerFactory;
import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManagerFactory;

public class HttpsPost
/**
* 获得KeyStore.
* @param keyStorePath
* 密钥库路径
* @param password
* 密码
* @return 密钥库
* @throws Exception
*/
public static KeyStore getKeyStore(String password, String keyStorePath)
throws Exception
// 实例化密钥库
KeyStore ks = KeyStore.getInstance("JKS");
// 获得密钥库文件流
FileInputStream is = new FileInputStream(keyStorePath);
// 加载密钥库
ks.load(is, password.toCharArray());
// 关闭密钥库文件流
is.close();
return ks;


/**
* 获得SSLSocketFactory.
* @param password
* 密码
* @param keyStorePath
* 密钥库路径
* @param trustStorePath
* 信任库路径
* @return SSLSocketFactory
* @throws Exception
*/
public static SSLContext getSSLContext(String password,
String keyStorePath, String trustStorePath) throws Exception
// 实例化密钥库
KeyManagerFactory keyManagerFactory = KeyManagerFactory
.getInstance(KeyManagerFactory.getDefaultAlgorithm());
// 获得密钥库
KeyStore keyStore = getKeyStore(password, keyStorePath);
// 初始化密钥工厂
keyManagerFactory.init(keyStore, password.toCharArray());

// 实例化信任库
TrustManagerFactory trustManagerFactory = TrustManagerFactory
.getInstance(TrustManagerFactory.getDefaultAlgorithm());
// 获得信任库
KeyStore trustStore = getKeyStore(password, trustStorePath);
// 初始化信任库
trustManagerFactory.init(trustStore);
// 实例化SSL上下文
SSLContext ctx = SSLContext.getInstance("TLS");
// 初始化SSL上下文
ctx.init(keyManagerFactory.getKeyManagers(),
trustManagerFactory.getTrustManagers(), null);
// 获得SSLSocketFactory
return ctx;


/**
* 初始化HttpsURLConnection.
* @param password
* 密码
* @param keyStorePath
* 密钥库路径
* @param trustStorePath
* 信任库路径
* @throws Exception
*/
public static void initHttpsURLConnection(String password,
String keyStorePath, String trustStorePath) throws Exception
// 声明SSL上下文
SSLContext sslContext = null;
// 实例化主机名验证接口
HostnameVerifier hnv = new MyHostnameVerifier();
try
sslContext = getSSLContext(password, keyStorePath, trustStorePath);
catch (GeneralSecurityException e)
e.printStackTrace();

if (sslContext != null)
HttpsURLConnection.setDefaultSSLSocketFactory(sslContext
.getSocketFactory());

HttpsURLConnection.setDefaultHostnameVerifier(hnv);


/**
* 发送请求.
* @param httpsUrl
* 请求的地址
* @param xmlStr
* 请求的数据
*/
public static void post(String httpsUrl, String xmlStr)
HttpsURLConnection urlCon = null;
try
urlCon = (HttpsURLConnection) (new URL(httpsUrl)).openConnection();
urlCon.setDoInput(true);
urlCon.setDoOutput(true);
urlCon.setRequestMethod("POST");
urlCon.setRequestProperty("Content-Length",
String.valueOf(xmlStr.getBytes().length));
urlCon.setUseCaches(false);
//设置为gbk可以解决服务器接收时读取的数据中文乱码问题
urlCon.getOutputStream().write(xmlStr.getBytes("gbk"));
urlCon.getOutputStream().flush();
urlCon.getOutputStream().close();
BufferedReader in = new BufferedReader(new InputStreamReader(
urlCon.getInputStream()));
String line;
while ((line = in.readLine()) != null)
System.out.println(line);

catch (MalformedURLException e)
e.printStackTrace();
catch (IOException e)
e.printStackTrace();
catch (Exception e)
e.printStackTrace();



/**
* 测试方法.
* @param args
* @throws Exception
*/
public static void main(String[] args) throws Exception
// 密码
String password = "123456";
// 密钥库
String keyStorePath = "tomcat.keystore";
// 信任库
String trustStorePath = "tomcat.keystore";
// 本地起的https服务
String httpsUrl = "https://localhost:8443/service/httpsPost";
// 传输文本
String xmlStr = "<?xml version=\"1.0\" encoding=\"UTF-8\"?><fruitShop><fruits><fruit><kind>萝卜</kind></fruit><fruit><kind>菠萝</kind></fruit></fruits></fruitShop>";
HttpsPost.initHttpsURLConnection(password, keyStorePath, trustStorePath);
// 发起请求
HttpsPost.post(httpsUrl, xmlStr);



[java] view plain copy
import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.SSLSession;

/**
* 实现用于主机名验证的基接口。
* 在握手期间，如果 URL 的主机名和服务器的标识主机名不匹配，则验证机制可以回调此接口的实现程序来确定是否应该允许此连接。
*/
public class MyHostnameVerifier implements HostnameVerifier
@Override
public boolean verify(String hostname, SSLSession session)
if("localhost".equals(hostname))
return true;
else
return false;




接收请求的Web应用：
web.xml

[html] view plain copy
<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5"
xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
<servlet>
<servlet-name>rollBack</servlet-name>
<servlet-class>rollBack</servlet-class>
</servlet>

<servlet-mapping>
<servlet-name>rollBack</servlet-name>
<url-pattern>/httpsPost</url-pattern>
</servlet-mapping>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
</web-app>

rollBack servlet

[java] view plain copy
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

import javax.servlet.ServletException;
import javax.servlet.ServletInputStream;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class rollBack extends HttpServlet

public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException
//获取请求流
ServletInputStream sis = request.getInputStream();
BufferedReader in = new BufferedReader(new InputStreamReader(sis));
String line;
if((line = in.readLine()) != null)
System.out.println(line);

in.close();


public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException
this.doGet(request, response);

《java程序设计》周结(10)

在第10周我们接触了一个我们并不是很陌生的知识点，泛型类。在之前学习的过程中Employee类中就有过泛型数组。当然这周的学习是深入的学习什么是泛型，怎样定义，怎样使用。首先就先说说什么是泛型，泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。在使用泛型时可以是泛型类，泛型接口，泛型方法等。还有一种类型通配符。java中的通配符由？表示，主要在方法的形参上使用，为了弥补泛型机制带来的参数传递问题，主要有三种通配符分类 无界通配：?，子类限定：? extends Object（通配符的上限），父类限定：? super Integer（通配符下界）。类型通配符上限通过形如Pair<? extends Number>形式定义，相对应的，类型通配符下限为Pair<? super Number>形式，其含义与类型通配符上限正好相反。虽然这一周的内容对比与其他时候的要熟悉，但也需要在代码上多看多练，才能熟悉掌握。