阿里云部署Java网站和微信开发调试心得技巧(上)

阿里云部署Java网站和微信开发调试心得技巧（上）
本篇手记旨在帮助大家从0开始：

申请阿里云服务器
搭建出程序的执行环境
在服务器上发布并运行自己的web project
域名解析
微信测试号的申请与连接以获取微信用户信息
全篇文章主要以如何去完成目标为主，因此会以流程的形式来展现，细节方面需要大家多多思考。其中文章的上集实现了1-4，文章的下集实现了5
一、申请阿里云服务器
（1）PC访问阿里云https://www.aliyun.com/，申请阿里云帐号（可以用您的支付宝帐号登录，因为支付宝帐号已经进行了实名认证，使用起来更方便）并登录
（2）找到云服务器ECS购买页面（页面展现随时会变，当前为全部导航->产品->弹性计算->云服务器ECS->选择自己需要的型号(我选择的是入门级)），购买云服务器，这里主要有三种方式：9块9的学生服务器（大家如果不是学生的话可以用还在读大学的小伙伴的学生证来薅羊毛，购买）、包年包月的服务器（不管你怎么使用，按年按月收费）还有按量付费的服务器（按小时计费，不用可以随时注销掉）

操作系统记得选择centos,这里我用的是最新的7.3版本

上半部分的安全设置里面需要填写上root的登录密码，以后咱们需要用这个root帐号来远程登录服务器去做部署，下半部分主要显示的是您选择的阿里云清单

开通成功后，服务器会启动并运行，同时会自动分配一个公网IP，咱们外网就可以通过这个公网IP访问服务器，同时也可以将域名解析到这个服务器中。

这里翔仔的公网IP为47.104.1.235
二、搭建程序的执行环境
搭建程序的执行环境，咱们先列一下常用的执行环境清单：
（1） JDK(这里选择的是JDK1.8)
下载地址为
http://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html
选择的是jdk-8u144-linux-x64.rpm
（2） Tomcat 8
下载地址为
http://tomcat.apache.org/download-80.cgi#8.0.46
选择的是apache-tomcat-8.0.46.tar.gz
（3） Mysql(这里选择的是Mysql5.7)repo源，后通过centos自带的yum安装
下载的地址为
https://dev.mysql.com/downloads/repo/yum/
这里选择mysql57-community-release-el7-11.noarch.rpm
（4） Redis(可选，最好预先安装上，这里选择的版本为4.0.2)
下载地址为
https://redis.io/download
这里选择redis-4.0.2.tar.gz
将上面的软件都下载到本地，并上传到服务器(如果您的系统为MAC或LINUX，直接使用SCP命令行上传，具体指令可以查询网上，如果您的系统为WIN，推荐使用filezilla可视化上传工具上传)，或者您也可以直接登录服务器，wget+ftp地址直接下载这些软件；同时需要大家注意的是，我们在服务器上部署了数据库之后，需要往数据库里面去补充数据，我们的线上数据访问的是线上的数据库而非本地的数据库。图片包也需要上传到服务器并通过配置server.xml确保能读取到这些图片（前提是docBase配置上的路径已经在服务器上创建）

可以在阿里云控制台进入终端

在服务器的终端，正确的情况下就能看到这些软件了。

接下来开始安装这些软件：
安装JDK
Java程序需要运行在JRE里边，因此咱们需要安装JDK，在软件路径里执行
//添加可执行权限
chmod +x jdk-8u144-linux-x64.rpm
//安装RPM软件包
rpm -ivh jdk-8u144-linux-x64.rpm
//查看java的版本信息，若出现版本信息则成功
java –version
安装Mysql
安装用来配置mysql的yum源的rpm包
rpm -Uvh mysql57-community-release-el7-11.noarch.rpm
安装Mysql
yum install mysql-community-server

开启mysql服务
service mysqld start

mysql安装成功后创建的超级用户’root’@‘localhost’的密码会被存储在/var/log/mysqld.log，可以使用如下命令查看密码
grep ‘temporary password’ /var/log/mysqld.log

使用mysql生成的’root’@‘localhost’用户和密码登录数据库，并修改其密码，具体命令
mysql -uroot -p
ALTER USER ‘root’@‘localhost’ IDENTIFIED BY ‘Xiangze230!’;

开启远程连接
通过阿里云控制台开放3306端口
在阿里云控制台咱们的实例页面下面选择安全组->配置规则

进入到规则配置页面之后，咱们可以看到目前只有22端口和3389端口支持远程访问，咱们还需要额外开通80端口（微信公众号用），3306端口(mysql)以及6379端口(redis)

配置一个支持远程登录的帐号，这里配置一个work帐号
mysql -u root -p
use mysql;
grant SELECT,UPDATE,INSERT,DELETE on . to ‘work’@’%’ identified by ‘Xiangze230!’;//创建work帐号并授权，同时设置密码
flush privileges;//生效配置
之后便能在我们本地通过调用mysql指令远程登录阿里云服务器上的mysql server中，
mysql -uwork -P3306 -h47.104.1.235 –p //本机远程登录mysql指令
安装redis
redis安装真的特别简单，首先先解压redis安装包
tar -zxvf redis-4.0.2.tar.gz
设置redis以支持远程登录
vi redis-4.0.2/redis.conf
将bind 127.0.0.1这句话用井号注释掉，这样就能支持远程连接了

此外，还需要给redis.conf添加配置以支持redis作为守护进程一直跑在后台
需要加入『daemonize yes』

安装redis
去到解压后的目录里
cd redis-4.0.2
make //安装redis
启动redis服务
src/redis-server redis.conf

redis连接测试
通过redis-cli连接到redis服务器
src/redis-cli
当输入ping 得到pong的回应之后，证明redis配置已经完成

4．安装tomcat 8
tomcat 8的安装更为简单
解压tomcat压缩包
tar -zxvf apache-tomcat-8.0.46.tar.gz
启动tomcat
./apache-tomcat-8.0.46/bin/startup.sh

三、在服务器上发布并运行自己的web project
修改tomcat默认启动端口，从8080修改为80端口，便于微信登录
vi apache-tomcat-8.0.46/conf/server.xml

重启tomcat
./apache-tomcat-8.0.46/bin/shutdown.sh
./apache-tomcat-8.0.46/bin/startup.sh
修改自己本地的网站的配置
这里由于大家自己的java网站项目的配置都不相同，只能说大概的，即把项目里的mysql配置(如果有的话)，redis配置(如果有的话)修改为阿里云服务器对应的配置(即ip，端口，密码等配置修改成服务器里安装好的这些软件的对应的配置)

打出自己项目的war包

将export出来的war包上传到服务器tomcat的webapps目录下
scp o2o.war root@47.104.1.235:/root/apache-tomcat-8.0.46/webapps

上传成功后，没过几秒tomcat便会在webapps目录下自动从项目war包中解析出项目工程目录来

之后通过ip+请求路径的形式便能访问到自己的项目(因为已经设置成80端口，这是http默认访问的端口，所以不需要在URL里添加端口信息了)

四、域名解析
如果通过ip连接微信号，则总会弹出烦人的警告窗口，因此咱们可以先购买一个域名并对域名进行认证(具体的备案步骤不同服务商有不同要求，大家可以按照他们的要求来，主要分有个人认证和企业认证两种，当然大家如果不嫌烦，可以直接用ip即跳过域名解析这一步)，建议大家看看周围的朋友有谁已经有经过验证的域名了，这样可以直接借他的域名创建一个二级域名来用，方便省事，翔仔购买的是阿里云控制台里面的万网域名，购买并认证成功后，会有如下截图，选择购买好的域名并点击解析创建出二级域名

进入到解析的页面，选择添加解析，并在A记录里面设置好O2O，IP里面设置咱们的阿里云服务器公网IP。这样就能创建出o2o.yitiaojieinfo.com这样的域名指向该公网IP

隔一段时间，大概5-10分钟这样子，通过域名访问咱们的站点，就能发现访问是okay的

五、微信测试号的申请与连接以获取微信用户信息
在咱们自己的程序里面编写servlet以响应微信号
在接下来的步骤中，我们将在测试号里面设置接口配置信息的URL，一经设置，微信公众号便会发请求到我们设置好的URL去，我们必须编写程序应答才能顺利连通微信公众号，因此咱们需要编写相应的响应程序
需要编写两个类
【SignUtil】

package com.imooc.o2o.util.weixin;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Arrays;
/**
* 微信请求校验工具类
*/
public class SignUtil {
// 与接口配置信息中的Token要一致
private static String token = "myo2o";
/**
* 验证签名
*
* @param signature
* @param timestamp
* @param nonce
* @return
*/
public static boolean checkSignature(String signature, String timestamp, String nonce) {
String[] arr = new String[] { token, timestamp, nonce };
// 将token、timestamp、nonce三个参数进行字典序排序
Arrays.sort(arr);
StringBuilder content = new StringBuilder();
for (int i = 0; i < arr.length; i++) {
content.append(arr[i]);
}
MessageDigest md = null;
String tmpStr = null;
try {
md = MessageDigest.getInstance("SHA-1");
// 将三个参数字符串拼接成一个字符串进行sha1加密
byte[] digest = md.digest(content.toString().getBytes());
tmpStr = byteToStr(digest);
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
content = null;
// 将sha1加密后的字符串可与signature对比，标识该请求来源于微信
return tmpStr != null ? tmpStr.equals(signature.toUpperCase()) : false;
}
/**
* 将字节数组转换为十六进制字符串
*
* @param byteArray
* @return
*/
private static String byteToStr(byte[] byteArray) {
String strDigest = "";
for (int i = 0; i < byteArray.length; i++) {
strDigest += byteToHexStr(byteArray[i]);
}
return strDigest;
}
/**
* 将字节转换为十六进制字符串
*
* @param mByte
* @return
*/
private static String byteToHexStr(byte mByte) {
char[] Digit = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
char[] tempArr = new char[2];
tempArr[0] = Digit[(mByte >>> 4) & 0X0F];
tempArr[1] = Digit[mByte & 0X0F];
String s = new String(tempArr);
return s;
}
}

【WechatController】

package com.imooc.o2o.web.wechat;
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import com.imooc.o2o.util.wechat.SignUtil;
@Controller
//一会在设置的URL里面就设置上这个路由
@RequestMapping("wechat")
public class WechatController {
private static Logger log = LoggerFactory.getLogger(WechatController.class);
@RequestMapping(method = { RequestMethod.GET })
public void doGet(HttpServletRequest request, HttpServletResponse response) {
log.debug("weixin get...");
// 微信加密签名，signature结合了开发者填写的token参数和请求中的timestamp参数、nonce参数。
String signature = request.getParameter("signature");
// 时间戳
String timestamp = request.getParameter("timestamp");
// 随机数
String nonce = request.getParameter("nonce");
// 随机字符串
String echostr = request.getParameter("echostr");
// 通过检验signature对请求进行校验，若校验成功则原样返回echostr，表示接入成功，否则接入失败
PrintWriter out = null;
try {
out = response.getWriter();
if (SignUtil.checkSignature(signature, timestamp, nonce)) {
log.debug("weixin get success....");
out.print(echostr);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
if (out != null)
out.close();
}
}
}

之后重新部署一版最新的程序

访问微信测试号登录页面，通过打开自己手机的微信，扫一扫登录
https://mp.weixin.qq.com/debug/cgi-bin/sandbox?t=sandbox/login
图片描述
进入到测试号页面后，分别看到如下信息
【测试号信息】
appID:开发者ID，是公众号开发识别码，配合开发者密码可以调用微信公众号接口，如获取微信昵称等
appsecret:开发者密码，是检验公众号开发者身份的密码，具有极高的安全性。切记不要把密码交给第三方开发者或者编写到代码里
图片描述
【接口配置信息】
URL: 是开发者用来接收微信消息和事件的接口URL
Token:由开发者可以任意填写，用作生成签名（该Token会和接口URL中包含的Token进行比对，从而验证安全性）

【JS接口安全域名】
域名：想调用jssdk(如想要通过微信公众号js接口获取地图等工具)必须得填写此域名，在此域名的范围内才能调用jssdk工具，注意这里必须是域名，不是带有http之类的URL，这里直接填写o2o.yitiaojieinfo.com
图片描述
【测试号二维码】
里面包含了测试号二维码以及已经关注了的用户信息

【体验接口权限表】
这里主要介绍【网页服务】里面的【网页帐号】
网页帐号主要用来设置OAuth2.0里面的网页授权域名，用户在网页授权页同意授权给公众号后，微信会将授权数据传给一个回调页面，回调页面需在此域名下，以确保安全可靠。沙盒号回调地址支持域名和ip，正式公众号回调地址只支持域名。这里直接设置为o2o.yitiaojieinfo.com
图片描述

有不清楚的地方可以直接参考微信官方文档
https://mp.weixin.qq.com/wiki?t=resource/res_main&id=mp1421135319
接下来需要编写自己的程序以获取关注此公众号的用户信息
需要编写5个类 WechatLoginController.java，UserAccessToken.java，WechatUser.java，WechatUtil.java以及MyX509TrustManager.java
【WechatLoginController】主要用来获取已关注此微信号的用户信息并做相应处理

package com.imooc.o2o.web.wechat;
import java.io.IOException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import com.imooc.o2o.dto.UserAccessToken;
import com.imooc.o2o.dto.WechatUser;
import com.imooc.o2o.util.wechat.WeiXinUserUtil;
@Controller
@RequestMapping("wechatlogin")
/**
* 获取关注公众号之后的微信用户信息的接口，如果在微信浏览器里访问
* https://open.weixin.qq.com/connect/oauth2/authorize?appid=您的appId&redirect_uri=http://o2o.yitiaojieinfo.com/o2o/wechatlogin/logincheck&role_type=1&response_type=code&scope=snsapi_userinfo&state=1#wechat_redirect
* 则这里将会获取到code,之后再可以通过code获取到access_token 进而获取到用户信息
*
* @author xiangze
*
*/
public class WechatLoginController {
private static Logger log = LoggerFactory.getLogger(WechatLoginController.class);
@RequestMapping(value = "/logincheck", method = { RequestMethod.GET })
public String doGet(HttpServletRequest request, HttpServletResponse response) {
log.debug("weixin login get...");
// 获取微信公众号传输过来的code,通过code可获取access_token,进而获取用户信息
String code = request.getParameter("code");
// 这个state可以用来传我们自定义的信息，方便程序调用，这里也可以不用
// String roleType = request.getParameter("state");
log.debug("weixin login code:" + code);
WechatUser user = null;
String openId = null;
if (null != code) {
UserAccessToken token;
try {
// 通过code获取access_token
token = WeiXinUserUtil.getUserAccessToken(code);
log.debug("weixin login token:" + token.toString());
// 通过token获取accessToken
String accessToken = token.getAccessToken();
// 通过token获取openId
openId = token.getOpenId();
// 通过access_token和openId获取用户昵称等信息
user = WeiXinUserUtil.getUserInfo(accessToken, openId);
log.debug("weixin login user:" + user.toString());
request.getSession().setAttribute("openId", openId);
} catch (IOException e) {
log.error("error in getUserAccessToken or getUserInfo or findByOpenId: " + e.toString());
e.printStackTrace();
}
}
// ======todo begin======
// 前面咱们获取到openId后，可以通过它去数据库判断该微信帐号是否在我们网站里有对应的帐号了，
// 没有的话这里可以自动创建上，直接实现微信与咱们网站的无缝对接。
// ======todo end======
if (user != null) {
// 获取到微信验证的信息后返回到指定的路由（需要自己设定）
return "frontend/index";
} else {
return null;
}
}
}

【UserAccessToken】用户AccessToken实体类，用来接收accesstoken以及openid等信息

package com.imooc.o2o.dto;
import com.fasterxml.jackson.annotation.JsonProperty;
/**
* 用户授权token
*
* @author xiangze
*
*/
public class UserAccessToken {
// 获取到的凭证
@JsonProperty("access_token")
private String accessToken;
// 凭证有效时间，单位：秒
@JsonProperty("expires_in")
private String expiresIn;
// 表示更新令牌，用来获取下一次的访问令牌，这里没太大用处
@JsonProperty("refresh_token")
private String refreshToken;
// 该用户在此公众号下的身份标识，对于此微信号具有唯一性
@JsonProperty("openid")
private String openId;
// 表示权限范围，这里可省略
@JsonProperty("scope")
private String scope;
public String getAccessToken() {
return accessToken;
}
public void setAccessToken(String accessToken) {
this.accessToken = accessToken;
}
public String getExpiresIn() {
return expiresIn;
}
public void setExpiresIn(String expiresIn) {
this.expiresIn = expiresIn;
}
public String getRefreshToken() {
return refreshToken;
}
public void setRefreshToken(String refreshToken) {
this.refreshToken = refreshToken;
}
public String getOpenId() {
return openId;
}
public void setOpenId(String openId) {
this.openId = openId;
}
public String getScope() {
return scope;
}
public void setScope(String scope) {
this.scope = scope;
}
@Override
public String toString() {
return "accessToken:" + this.getAccessToken() + ",openId:" + this.getOpenId();
}
}

【WechatUser】微信用户实体类，用来接收昵称 openid等用户信息

package com.imooc.o2o.dto;
import java.io.Serializable;
import com.fasterxml.jackson.annotation.JsonProperty;
/**
* 微信用户实体类
*
* @author xiangze
*
*/
public class WechatUser implements Serializable {
/**
*
*/
private static final long serialVersionUID = -4684067645282292327L;
// openId,标识该公众号下面的该用户的唯一Id
@JsonProperty("openid")
private String openId;
// 用户昵称
@JsonProperty("nickname")
private String nickName;
// 性别
@JsonProperty("sex")
private int sex;
// 省份
@JsonProperty("province")
private String province;
// 城市
@JsonProperty("city")
private String city;
// 区
@JsonProperty("country")
private String country;
// 头像图片地址
@JsonProperty("headimgurl")
private String headimgurl;
// 语言
@JsonProperty("language")
private String language;
// 用户权限，这里没什么作用
@JsonProperty("privilege")
private String[] privilege;
public String getOpenId() {
return openId;
}
public void setOpenId(String openId) {
this.openId = openId;
}
public String getNickName() {
return nickName;
}
public void setNickName(String nickName) {
this.nickName = nickName;
}
public int getSex() {
return sex;
}
public void setSex(int sex) {
this.sex = sex;
}
public String getProvince() {
return province;
}
public void setProvince(String province) {
this.province = province;
}
public String getCity() {
return city;
}
public void setCity(String city) {
this.city = city;
}
public String getCountry() {
return country;
}
public void setCountry(String country) {
this.country = country;
}
public String getHeadimgurl() {
return headimgurl;
}
public void setHeadimgurl(String headimgurl) {
this.headimgurl = headimgurl;
}
public String getLanguage() {
return language;
}
public void setLanguage(String language) {
this.language = language;
}
public String[] getPrivilege() {
return privilege;
}
public void setPrivilege(String[] privilege) {
this.privilege = privilege;
}
@Override
public String toString() {
return "openId:" + this.getOpenId() + ",nikename:" + this.getNickName();
}
}

【WechatUtil】主要用来提交https请求给微信获取用户信息

package com.imooc.o2o.util.wechat;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.ConnectException;
import java.net.URL;
import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSocketFactory;
import javax.net.ssl.TrustManager;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.imooc.o2o.dto.UserAccessToken;
import com.imooc.o2o.dto.WechatUser;
/**
* 微信工具类
*
* @author xiangze
*
*/
public class WechatUtil {
private static Logger log = LoggerFactory.getLogger(WechatUtil.class);
/**
* 获取UserAccessToken实体类
*
* @param code
* @return
* @throws IOException
*/
public static UserAccessToken getUserAccessToken(String code) throws IOException {
// 测试号信息里的appId
String appId = "您的appId";
log.debug("appId:" + appId);
// 测试号信息里的appsecret
String appsecret = "您的appsecret";
log.debug("secret:" + appsecret);
// 根据传入的code,拼接出访问微信定义好的接口的URL
String url = "https://api.weixin.qq.com/sns/oauth2/access_token?appid=" + appId + "&secret=" + appsecret
+ "&code=" + code + "&grant_type=authorization_code";
// 向相应URL发送请求获取token json字符串
String tokenStr = httpsRequest(url, "GET", null);
log.debug("userAccessToken:" + tokenStr);
UserAccessToken token = new UserAccessToken();
ObjectMapper objectMapper = new ObjectMapper();
try {
// 将json字符串转换成相应对象
token = objectMapper.readValue(tokenStr, UserAccessToken.class);
} catch (JsonParseException e) {
log.error("获取用户accessToken失败: " + e.getMessage());
e.printStackTrace();
} catch (JsonMappingException e) {
log.error("获取用户accessToken失败: " + e.getMessage());
e.printStackTrace();
} catch (IOException e) {
log.error("获取用户accessToken失败: " + e.getMessage());
e.printStackTrace();
}
if (token == null) {
log.error("获取用户accessToken失败。");
return null;
}
return token;
}
/**
* 获取WechatUser实体类
*
* @param accessToken
* @param openId
* @return
*/
public static WechatUser getUserInfo(String accessToken, String openId) {
// 根据传入的accessToken以及openId拼接出访问微信定义的端口并获取用户信息的URL
String url = "https://api.weixin.qq.com/sns/userinfo?access_token=" + accessToken + "&openid=" + openId
+ "&lang=zh_CN";
// 访问该URL获取用户信息json 字符串
String userStr = httpsRequest(url, "GET", null);
log.debug("user info :" + userStr);
WechatUser user = new WechatUser();
ObjectMapper objectMapper = new ObjectMapper();
try {
// 将json字符串转换成相应对象
user = objectMapper.readValue(userStr, WechatUser.class);
} catch (JsonParseException e) {
log.error("获取用户信息失败: " + e.getMessage());
e.printStackTrace();
} catch (JsonMappingException e) {
log.error("获取用户信息失败: " + e.getMessage());
e.printStackTrace();
} catch (IOException e) {
log.error("获取用户信息失败: " + e.getMessage());
e.printStackTrace();
}
if (user == null) {
log.error("获取用户信息失败。");
return null;
}
return user;
}
/**
* 发起https请求并获取结果
*
* @param requestUrl
* 请求地址
* @param requestMethod
* 请求方式（GET、POST）
* @param outputStr
* 提交的数据
* @return json字符串
*/
public static String httpsRequest(String requestUrl, String requestMethod, String outputStr) {
StringBuffer buffer = new StringBuffer();
try {
// 创建SSLContext对象，并使用我们指定的信任管理器初始化
TrustManager[] tm = { new MyX509TrustManager() };
SSLContext sslContext = SSLContext.getInstance("SSL", "SunJSSE");
sslContext.init(null, tm, new java.security.SecureRandom());
// 从上述SSLContext对象中得到SSLSocketFactory对象
SSLSocketFactory ssf = sslContext.getSocketFactory();
URL url = new URL(requestUrl);
HttpsURLConnection httpUrlConn = (HttpsURLConnection) url.openConnection();
httpUrlConn.setSSLSocketFactory(ssf);
httpUrlConn.setDoOutput(true);
httpUrlConn.setDoInput(true);
httpUrlConn.setUseCaches(false);
// 设置请求方式（GET/POST）
httpUrlConn.setRequestMethod(requestMethod);
if ("GET".equalsIgnoreCase(requestMethod))
httpUrlConn.connect();
// 当有数据需要提交时
if (null != outputStr) {
OutputStream outputStream = httpUrlConn.getOutputStream();
// 注意编码格式，防止中文乱码
outputStream.write(outputStr.getBytes("UTF-8"));
outputStream.close();
}
// 将返回的输入流转换成字符串
InputStream inputStream = httpUrlConn.getInputStream();
InputStreamReader inputStreamReader = new InputStreamReader(inputStream, "utf-8");
BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
String str = null;
while ((str = bufferedReader.readLine()) != null) {
buffer.append(str);
}
bufferedReader.close();
inputStreamReader.close();
// 释放资源
inputStream.close();
inputStream = null;
httpUrlConn.disconnect();
log.debug("https buffer:" + buffer.toString());
} catch (ConnectException ce) {
log.error("Weixin server connection timed out.");
} catch (Exception e) {
log.error("https request error:{}", e);
}
return buffer.toString();
}
}

【MyX509TrustManager】主要继承X509TrustManager做https证书信任管理器

package com.imooc.o2o.util.wechat;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import javax.net.ssl.X509TrustManager;
/**
* 证书信任管理器（用于https请求）
*
* @author xiangze
*
*/
public class MyX509TrustManager implements X509TrustManager {
public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {
}
public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {
}
public X509Certificate[] getAcceptedIssuers() {
return null;
}
}

之后重新打包一个新的war包并发布到服务器tomcat webapps目录下
发布成功后，关注你自己的测试号(即扫描测试号的那个二维码)，然后在手机微信里面或者微信开发者工具里访问相应链接：
https://open.weixin.qq.com/connect/oauth2/authorize?appid=您的appid&redirect_uri=http://o2o.yitiaojieinfo.com/o2o/wechatlogin/logincheck&role_type=1&response_type=code&scope=snsapi_userinfo&state=1#wechat_redirect
图片描述
之后查看日志信息，便能发现确实能够获取到用户的信息了

至此咱们已经从无到有完成了阿里云部署Java网站和微信公众号的开发，文章虽长，但是干货多多，都是傻瓜式的配置，希望大家喜欢。
注意事项：