微信公众号开发学习

微信公众号开发学习

1、Readme说明：微信公众号平台开发最好用PHP，但Java也是可以实现的，下面代码用Java语言演示了HttpURLConnection的使用，成为公众号开发者，接收微信公众号信息，响应文本消息，发布菜单，获取用户基本信息等操作。

下面会给出供参考的程序源代码。

 

2、XStream简单介绍：

（1）XStream可以将Java对象和xml文档之间相互转换，而且可以修改某个特定的属性和节点名称，而且也支持json的转换。

（2）Java到xml，用toXML()方法。

Xml到Java，用fromXML()方法。

（3）在没有任何设置默认情况下，Java到xml的映射，是Java成员名对应xml的元素名，Java类的全名对应xml根元素的名字。而实际中，往往是xml和java类都有了，需要相互转换，必须进行别名映射。

（4）别名配置包括三种情况：

①类别名，用alias（String name，Class type）

②类成员别名，用aliasField（String alias，Class definedIn， String fieldName）

③类成员作为属性别名，用aliasAttribute（Class definedIn， String attributeName， String alias），单独命名没有意义，还要通过useAttributeFor（Class definedIn， String fieldName）应用到某个类上。

3、下面是包及类的关系图：

4、源代码：

（1）action包

****action

********MainAction.java

********TestAction.java

①MainAction.java

package com.remoa.action;

import java.io.IOException;

import javax.servlet.ServletException;
import javax.servlet.ServletInputStream;
import javax.servlet.ServletOutputStream;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.remoa.common.util.ConfigureUtil;
import com.remoa.common.util.MessageUtil;
import com.remoa.common.util.SignUtil;
import com.remoa.domain.message.TextResponse;
import com.remoa.domain.message.WeixinRequest;

/**
 * 处理事务逻辑的主类（验证登录，接收消息及回复消息等）
 * @author Remoa
 *
 */
@WebServlet("/MainAction")
public class MainAction extends HttpServlet {
	private static final long serialVersionUID = 1L;
    private static final String charset = ConfigureUtil.getValue("charset");   
    
    public MainAction() {
        super();
    }

	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		System.out.println("MainAction.doGet():start!");
		response.setCharacterEncoding(charset);
		request.setCharacterEncoding(charset);
		//获取必要的参数,验证服务器地址的有效性
		String token = request.getParameter("token");//密码
		String signature = request.getParameter("signature");//微信加密签名
		String timestamp = request.getParameter("timestamp");//时间戳
		String nonce = request.getParameter("nonce");//随机数
		String echostr = request.getParameter("echostr");//随机字符串
		System.out.println(signature + " " + echostr);
		//调用登录工具类进行验证
		boolean sign = SignUtil.validSign(signature, token, timestamp, nonce);
		ServletOutputStream outputStream = response.getOutputStream();
		//验证成功则返回随机字符串内容，否则验证失败
		if(sign){	
			outputStream.write(echostr.getBytes());
			outputStream.flush();
		}else{
			outputStream.write("验证失败".getBytes());
			outputStream.flush();
		}
	}

	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		System.out.println("MainAction.doPost():start!");
		request.setCharacterEncoding(charset);
		response.setCharacterEncoding(charset);
		ServletInputStream inputStream = request.getInputStream();//获取微信请求消息
		WeixinRequest xinReq = MessageUtil.fromXmlToWeixinReq(inputStream);//将xml字符串转换为WeixinRequest对象
		TextResponse textResponse = new TextResponse();
		textResponse.setToUserName(xinReq.getFromUserName());//实现响应的开发者微信号
		textResponse.setFromUserName(xinReq.getToUserName());//响应传达的接收方账号
		textResponse.setCreateTime(System.currentTimeMillis());//返回系统当前时间
		textResponse.setMsgType("text");//响应文本消息
		textResponse.setContent("小编已收到您的消息");//回复的消息内容
		String respStr = MessageUtil.toXmlFromResp(textResponse);
		response.getOutputStream().write(respStr.getBytes());
	}	
}

②TestAction.java

package com.remoa.action;

import java.io.IOException;
import java.util.Scanner;

import javax.servlet.ServletException;
import javax.servlet.ServletInputStream;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
 * 此类用于测试连接成功后接收消息是否成功
 * @author Remoa
 *
 */
@WebServlet("/TestAction")
public class TestAction extends HttpServlet {
	private static final long serialVersionUID = 1L;
       
    public TestAction() {
        super();
    }
	
	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		response.getWriter().append("Served at: ").append(request.getContextPath());
	}

	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		ServletInputStream inputStream = request.getInputStream();
		Scanner scanner = new Scanner(inputStream, "UTF-8");
		while(scanner.hasNextLine()){
			System.out.println(scanner.nextLine());
		}
		scanner.close();
	}
}

（2）common包

****common

********util

************ConfigureUtil.java

************HttpUtil.java

************MessageUtil.java

************SignUtil.java

①ConfigureUtil.java

package com.remoa.common.util;

import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

/**
 * 获取配置信息工具类
 * @author Remoa
 *
 */
public class ConfigureUtil {
	private static Properties pro;
	static{
		InputStream is = ConfigureUtil.class.getClassLoader().getResourceAsStream("conf.properties");//通过类加载器返回作为输入流读取配置文件
		pro = new Properties();
		try {
			pro.load(is);//从输入流中读取属性列表
			is.close();
		} catch (IOException e) {
			e.printStackTrace();
			System.out.println("发生了I/O异常错误");
		}
	}
	
	/**
	 * 从配置文件中获得属性值
	 * @param key 键
	 * @return value 返回键对应的值
	 */
	public static String getValue(String key){
		return pro.getProperty(key);
	}
	
	/**
	 * 仅用于测试该配置信息工具类是否能获取到配置文件中的值
	 * @param args
	 */
	public static void main(String[] args){
		String value = ConfigureUtil.getValue("charset");
		System.out.println(value);
	}
}

②HttpUtil.java

package com.remoa.common.util;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.Reader;
import java.io.UnsupportedEncodingException;
import java.net.MalformedURLException;
import java.net.ProtocolException;
import java.net.URL;

import sun.net.www.protocol.http.HttpURLConnection;

/**
 * Http连接工具类
 * @author Remoa
 *
 */
public class HttpUtil {
	
	/**
	 * 发送http请求
	 * @param url 请求地址
	 * @param method 请求方法
	 * @param param 请求参数
	 * @param charset 字符集
	 * @return 返回请求结果
	 */
	public static String sendHttpReq(String url, String method, String param, String charset){
		HttpURLConnection httpURLConnection = null;//生成请求连接到Http服务器
		BufferedOutputStream bufferedOutputStream = null;// 缓冲输出流
		BufferedReader bufferedReader = null;//读取字符输入流
		URL urlObj;
		try {
			urlObj = new URL(url);
			httpURLConnection = (HttpURLConnection)urlObj.openConnection();//连接url所引用的远程对象
		} catch (MalformedURLException e) {
			e.printStackTrace();
			System.out.println("出现了使用未知协议错误");
		} catch (IOException e) {
			e.printStackTrace();
			System.out.println("出现了I/O异常错误");
		}
		httpURLConnection.setDoInput(true);//读取指定url服务器的资源
		if(param != null){
			httpURLConnection.setDoOutput(true);//写入数据到指定url服务器
		}
		httpURLConnection.setUseCaches(false);//不允许连接使用缓存
		httpURLConnection.setReadTimeout(1000 * 60);//设置读超时，此处设置为1分钟，单位为毫秒
		httpURLConnection.setConnectTimeout(1000 * 60);//设置建立连接超时，此处设置为1分钟，单位为毫秒
		try {
			httpURLConnection.setRequestMethod(method);
		} catch (ProtocolException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			System.out.println("无法重置方法或者请求的方法对 HTTP 无效");
		}//设置请求方法
		try {
			if(param != null){
				bufferedOutputStream = new BufferedOutputStream(httpURLConnection.getOutputStream());
				bufferedOutputStream.write(param.getBytes());
				bufferedOutputStream.flush();
				bufferedOutputStream.close();
			}
		} catch (IOException e) {
			e.printStackTrace();
			System.out.println("缓冲输出流出现了I/O异常错误");
		}
		try {
			bufferedReader = new BufferedReader(new InputStreamReader(httpURLConnection.getInputStream(), charset));
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			System.out.println("读取字符输入流出现了I/O异常错误");
		}
		StringBuilder stringBuilder = new StringBuilder();//提供了与StringBuffer兼容的api，当字符缓冲区被单个线程所使用时，优先使用此类，因为其比StringBuffer要快
		String line = null;
		//读取一个文本行操作
		try {
			if((line = bufferedReader.readLine()) != null){
				stringBuilder.append(line).append("\n");
			}
			bufferedReader.close();
		} catch (IOException e) {
			e.printStackTrace();
			System.out.println("读取字符输入流出现了I/O异常错误");
		}
		httpURLConnection.disconnect();//指示近期服务器不太可能有其他请求
		return stringBuilder.toString();
	}
	
	/**
	 * 实现关闭流、关闭连接的功能
	 * @param reader 关闭字符读取流
	 * @param inputStream 关闭输入流
	 * @param outputStream 关闭输出流
	 * @param httpURLConnection 关闭http服务器连接
	 */
	public static void closeAll(Reader reader, InputStream inputStream, OutputStream outputStream, HttpURLConnection httpURLConnection) {
		//关闭字符流
		if(reader != null){
			try {
				reader.close();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
				System.out.println("发生I/O错误");
			}
		}
		if(inputStream != null){
			try {
				inputStream.close();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
				System.out.println("发生I/O错误");
			}
		}
		if(outputStream != null){
			try {
				outputStream.close();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
				System.out.println("发生I/O错误");
			}
		}
		if(httpURLConnection != null){
			httpURLConnection.disconnect();
		}
	}
	
	/**
	 * 实现上传素材的功能
	 * @param url 请求地址
	 * @param filePath 文件路径
	 * @param charset 字符编码方式
	 * @return String 表单地址
	 */
	public static String upload(String url, String filePath, String charset) {
		HttpURLConnection httpURLConnection = null;//生成请求连接到Http服务器
		BufferedOutputStream bufferedOutputStream = null;// 缓冲输出流
		BufferedReader bufferedReader = null;//读取字符输入流
		BufferedInputStream fileInput = null;
		URL urlObj;
		try {
			urlObj = new URL(url);
			httpURLConnection = (HttpURLConnection)urlObj.openConnection();//连接url所引用的远程对象
		} catch (MalformedURLException e) {
			e.printStackTrace();
			System.out.println("出现了使用未知协议错误");
		} catch (IOException e) {
			e.printStackTrace();
			System.out.println("出现了I/O异常错误");
		}
		httpURLConnection.setDoInput(true);//允许读取指定url服务器的资源
		httpURLConnection.setDoOutput(true);//允许写入数据到指定url服务器
		httpURLConnection.setUseCaches(false);//不允许连接使用缓存
		httpURLConnection.setReadTimeout(1000 * 60);//设置读超时，此处设置为1分钟，单位为毫秒
		httpURLConnection.setConnectTimeout(1000 * 60);//设置建立连接超时，此处设置为1分钟，单位为毫秒
		try {
			httpURLConnection.setRequestMethod("POST");//设置请求方法
		} catch (ProtocolException e) {
			e.printStackTrace();
			System.out.println("无法重置方法或者请求的方法对 HTTP 无效");
		}
		String boundary = String.valueOf(System.currentTimeMillis());
		httpURLConnection.addRequestProperty("Content-Type", "multipart/form-data:boundary=" + boundary);//设置请求头
		StringBuilder headstr = new StringBuilder("----");
		headstr.append(boundary).append("\r\n").append("Content-Disposition: form-data; name=\"file\"; filename=\"").append(filePath).append("\"").append("\r\n").append("Content-Type: application/octet-stream\r\n\r\n");//设置附件表单信息
		try {
			bufferedOutputStream = new BufferedOutputStream(httpURLConnection.getOutputStream());
		} catch (IOException e) {
			e.printStackTrace();
			System.out.println("创建输出流时发生 I/O 错误");
		}
		try {
			bufferedOutputStream.write(headstr.toString().getBytes());//写入表单信息
		} catch (IOException e) {
			e.printStackTrace();
			System.out.println("写入时发生I/O错误");
		}
		try {
			bufferedOutputStream.flush();
		} catch (IOException e) {
			e.printStackTrace();
			System.out.println("刷新缓冲输出流时发生I/O错误");
		}
		//写入附件
		try {
			fileInput = new BufferedInputStream(new FileInputStream(filePath));
		} catch (FileNotFoundException e) {
			e.printStackTrace();
			System.out.println("没有找到文件");
		}
		byte[] bytebuf = new byte[1024];
		int len = 0;
		try {
			while((len = fileInput.read(bytebuf)) != -1){
				bufferedOutputStream.write(bytebuf, 0, len);
				bufferedOutputStream.write(("\r\n--" + boundary + "--\r\n").getBytes(charset));
				bufferedOutputStream.flush();
				bufferedOutputStream.close();
				fileInput.close();
			}
		} catch (IOException e) {
			e.printStackTrace();
			System.out.println("发生I/O异常");
		}
		try {
			bufferedOutputStream.write(("\r\n--" + boundary + "--\r\n").getBytes(charset));
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
			System.out.println("不支持该字符编码");
		} catch (IOException e) {
			e.printStackTrace();
			System.out.println("发生I/O异常");
		}
		try {
			bufferedOutputStream.flush();
			bufferedOutputStream.close();
			fileInput.close();
		} catch (IOException e) {
			e.printStackTrace();
			System.out.println("发生I/O异常");
		}
		StringBuilder stringBuilder = null;
		try {
			bufferedReader = new BufferedReader(new InputStreamReader(httpURLConnection.getInputStream(), charset));
			String line = null;
			stringBuilder = new StringBuilder();//提供了与StringBuffer兼容的api，当字符缓冲区被单个线程所使用时，优先使用此类，因为其比StringBuffer要快
			while((line = bufferedReader.readLine()) != null){
				stringBuilder.append(line).append("\n");
			}
			bufferedReader.close();
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
			System.out.println("不支持该字符编码");
		} catch (IOException e) {
			e.printStackTrace();
			System.out.println("发生I/O异常");
		}
		httpURLConnection.disconnect();
		return stringBuilder.toString();
	}		
}

③MessageUtil.java

package com.remoa.common.util;

import java.io.InputStream;
import java.util.Scanner;

import com.remoa.domain.message.TextResponse;
import com.remoa.domain.message.WeixinRequest;
import com.thoughtworks.xstream.XStream;
/**
 * 消息处理工具类，包括接收消息及发送消息的处理
 * @author Remoa
 *
 */
public class MessageUtil {
	public static final String charset = ConfigureUtil.getValue("charset");
	/**
	 * 将微信请求接收到的xml字符串转换为Java处理微信消息请求的类WeixinRequest对象
	 * @param in ServletInputStream输入流
	 * @return fromXML 返回WeixinRequest对象
	 */
	public static WeixinRequest fromXmlToWeixinReq(InputStream in){
		Scanner scan = new Scanner(in, charset);//从指定流中构造一个新的扫描器
		StringBuffer str = new StringBuffer();
		while(scan.hasNextLine()){
			str.append(scan.nextLine()).append("\r\n");
		}
		scan.close();
		System.out.println(str.toString());
		XStream xStream = new XStream();
		xStream.alias("xml", WeixinRequest.class);
		WeixinRequest fromXML = (WeixinRequest)xStream.fromXML(str.toString());
		System.out.println(fromXML);
		return fromXML;
	}
	
	/**
	 * 将文本消息响应结果转换为xml字符串
	 * @param textResponse 文本消息响应对象
	 * @return toxml 返回xml字符串
	 */
	public static String toXmlFromResp(TextResponse textResponse){
		XStream xStream = new XStream();
		xStream.alias("xml", TextResponse.class);
		String toXml = xStream.toXML(textResponse);
		System.out.println(toXml.toString());
		return toXml;
	}
}

④SignUtil.java

package com.remoa.common.util;

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Arrays;
/**
 * 登录工具类
 * @author Remoa
 *
 */
public class SignUtil {
	//开发者提交信息后，微信服务器将发送GET请求到填写的服务器地址URL上，GET请求携带四个参数：
	/**
	 * 判断登录的有效性
	 * @param signature 微信加密签名，signature结合了开发者填写的token参数和请求中的timestamp参数、nonce参数。
	 * @param token 密码
	 * @param timestamp 时间戳
	 * @param nonce 随机数
	 * @return boolean 返回判断值true或false
	 */
	public static boolean validSign(String signature, String token, String timestamp, String nonce){
		String[] paramArr = new String[]{token, timestamp, nonce};
		Arrays.sort(paramArr);//Arrays类用来操作数组（比如排序和搜索）的各种方法。sort对数组按数字升序进行排序。
		StringBuilder sb = new StringBuilder(paramArr[0]);
		sb.append(paramArr[1]).append(paramArr[2]);
		String ciphertext = null;
		try {
			MessageDigest md = MessageDigest.getInstance("SHA-1");//为应用程序提供信息摘要算法的功能
			byte[] digest = md.digest(sb.toString().getBytes());
			ciphertext = byteToStr(digest);
		} catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
		}
		return ciphertext != null ? ciphertext.equals(signature.toUpperCase()) : false;
	}
	
	private static String byteToStr(byte[] byteArray) {
		String rst = "";
		for (int i = 0; i < byteArray.length; i++) {
			rst += byteToHex(byteArray[i]);
		}
		return rst;
	}
	
	private static String byteToHex(byte b) {
		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[(b >>> 4) & 0X0F];
		tempArr[1] = Digit[b & 0X0F];
		String s = new String(tempArr);
		return s;
	}
}

（3）domain包

****domain

********AccessToken

************AccessToken.java

********menu

************Menu.java

************MyButton.java

********message

************BaseMessageResponse.java

************ErrorMessage.java

************ImageResponseMessage.java

************TextResponse.java

************WeixinRequest.java

********user

************UserInfo.java

①AccessToken.java

package com.remoa.domain.AccessToken;
/**
 * 接口调用凭据获取类
 * @author Remoa
 *
 */
public class AccessToken {
	private String access_token;//获取到的凭证
	private long expires_in;//凭证有效时间（单位：秒）
	public String getAccess_token() {
		return access_token;
	}
	public void setAccess_token(String access_token) {
		this.access_token = access_token;
	}
	public long getExpires_in() {
		return expires_in;
	}
	public void setExpires_in(long expires_in) {
		this.expires_in = expires_in;
	}
}

②Menu.java

package com.remoa.domain.menu;

import java.util.ArrayList;
import java.util.List;

import com.alibaba.fastjson.JSON;
/**
 * 菜单实体类
 * @author Remoa
 *
 */
public class Menu {
	private List<MyButton> button = new ArrayList<MyButton>();

	public List<MyButton> getButton() {
		return button;
	}
	public void setButton(List<MyButton> button) {
		this.button = button;
	}
	public void addButton(MyButton button){
		this.getButton().add(button);
	}
	public static Menu getDefaultMenu(){
		Menu menu = new Menu();
		MyButton button1 = new MyButton();
		button1.setName("五绝风采");
		button1.setType("click");
		button1.setKey("Superman");
		MyButton button1_1 = new MyButton();
		button1_1.setName("黄药师");
		button1_1.setType("click");
		button1_1.setKey("Doctor Huang");
		MyButton button1_2 = new MyButton();
		button1_2.setName("欧阳锋");
		button1_2.setType("click");
		button1_2.setKey("Feng Ouyang");
		button1.addSub_button(button1_1);
		button1.addSub_button(button1_2);
		
		MyButton button2 = new MyButton();
		button2.setName("百度一下");
		button2.setType("view");
		button2.setUrl("http://www.baidu.com");
		
		menu.addButton(button1);
		menu.addButton(button2);
		return menu;
	}
	public static void main(String[] args){
		Menu menu = Menu.getDefaultMenu();
		System.out.println(JSON.toJSONString(menu, true));
	}
}

③MyButton.java

package com.remoa.domain.menu;

import java.util.ArrayList;
import java.util.List;

/**
 * 菜单上的按钮实体类定义
 * @author Remoa
 *
 */
public class MyButton {
	private List<MyButton> sub_button = new ArrayList<MyButton>();//二级菜单数组，个数应为1~5个
	private String type;//菜单的响应动作类型
	private String name;//菜单标题，不超过16个字节，子菜单不超过40个字节
	private String key;//菜单KEY值，用于消息接口推送，不超过128字节,click等点击类型必须
	private String url;//网页链接，用户点击菜单可打开链接，不超过1024字节,view类型必须
	private String media_id;//调用新增永久素材接口返回的合法media_id,media_id类型和view_limited类型必须
	public void addSub_button(MyButton button){
		this.sub_button.add(button);
	}
	public List<MyButton> getSub_button() {
		return sub_button;
	}
	public void setSub_button(List<MyButton> sub_button) {
		this.sub_button = sub_button;
	}
	public String getType() {
		return type;
	}
	public void setType(String type) {
		this.type = type;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getKey() {
		return key;
	}
	public void setKey(String key) {
		this.key = key;
	}
	public String getUrl() {
		return url;
	}
	public void setUrl(String url) {
		this.url = url;
	}
	public String getMedia_id() {
		return media_id;
	}
	public void setMedia_id(String media_id) {
		this.media_id = media_id;
	}
	@Override
	public String toString() {
		// TODO Auto-generated method stub
		return "Button [sub_button=" + sub_button + ",type=" + type + ",name=" + name + "]";
	}
}

④BaseMessageResponse.java

package com.remoa.domain.message;
/**
 * 回复各类信息其所含参数构成的基础类
 * @author Remoa
 *
 */
public class BaseMessageResponse {
	private String ToUserName;//开发者微信号
	private String FromUserName;//发送方账号，一个openID
	private long CreateTime;//消息创建时间 （整型）
	private String MsgType;//消息类型
	public String getToUserName() {
		return ToUserName;
	}
	public void setToUserName(String toUserName) {
		ToUserName = toUserName;
	}
	public String getFromUserName() {
		return FromUserName;
	}
	public void setFromUserName(String fromUserName) {
		FromUserName = fromUserName;
	}
	public long getCreateTime() {
		return CreateTime;
	}
	public void setCreateTime(long createTime) {
		CreateTime = createTime;
	}
	public String getMsgType() {
		return MsgType;
	}
	public void setMsgType(String msgType) {
		MsgType = msgType;
	}
}

⑤ErrorMessage.java

package com.remoa.domain.message;
/**
 * 出现错误时信息类
 * @author Remoa
 *
 */
public class ErrorMessage {
	private long errcode;//错误码
	private String errmsg;//错误信息
	public long getErrcode() {
		return errcode;
	}
	public void setErrcode(long errcode) {
		this.errcode = errcode;
	}
	public String getErrmsg() {
		return errmsg;
	}
	public void setErrmsg(String errmsg) {
		this.errmsg = errmsg;
	}
}

⑥ImageResponseMessage.java

package com.remoa.domain.message;
/**
 * 回复图片消息
 * @author Remoa
 *
 */
public class ImageResponseMessage extends BaseMessageResponse{
	private Image image = new Image();
	public String getMediaId() {
		return image.getMediaId();
	}
	public void setMediaId(String mediaId) {
		image.setMediaId(mediaId);
	}
	public Image getImage() {
		return image;
	}
	public void setImage(Image image) {
		this.image = image;
	}
}
/**
 * 图片类
 * @author Remoa
 *
 */
class Image{
	private String MediaId;//图片消息媒体id，可以调用多媒体文件下载接口拉取数据。
	public String getMediaId() {
		return MediaId;
	}
	public void setMediaId(String mediaId) {
		MediaId = mediaId;
	}
}

⑦TextResponse.java

package com.remoa.domain.message;
/**
 * 回复文本消息
 * @author Remoa
 *
 */
public class TextResponse extends BaseMessageResponse{
	private String Content;//文本消息内容
	public String getContent() {
		return Content;
	}

	public void setContent(String content) {
		Content = content;
	}
}

⑧WeixinRequest.java

package com.remoa.domain.message;
/**
 * 处理公众号请求类
 * @author Remoa
 *
 */
public class WeixinRequest {
	private String ToUserName;//接收方帐号（收到的OpenID）
	private String FromUserName;//开发者微信号
	private long CreateTime;//消息创建时间 （整型）
	private String MsgType;//消息类型
	private String Content;//回复文本消息特有，回复的消息内容（换行：在content中能够换行，微信客户端就支持换行显示）
	//用户未关注时，进行关注后的事件推送的特有参数
	private String MsgId;//回复图片消息，通过素材管理接口上传多媒体文件，得到的id。
	private String Event;//事件类型，subscribe
	private String EventKey;//事件KEY值，qrscene_为前缀，后面为二维码的参数值
	private String Ticket;//二维码的ticket，可用来换取二维码图片

	public String getToUserName() {
		return ToUserName;
	}

	public void setToUserName(String toUserName) {
		ToUserName = toUserName;
	}

	public String getFromUserName() {
		return FromUserName;
	}

	public void setFromUserName(String fromUserName) {
		FromUserName = fromUserName;
	}

	public long getCreateTime() {
		return CreateTime;
	}

	public void setCreateTime(int createTime) {
		CreateTime = createTime;
	}

	public String getMsgType() {
		return MsgType;
	}

	public void setMsgType(String msgType) {
		MsgType = msgType;
	}

	public String getContent() {
		return Content;
	}

	public void setContent(String content) {
		Content = content;
	}

	public String getMsgId() {
		return MsgId;
	}

	public void setMsgId(String msgId) {
		MsgId = msgId;
	}

	public String getEvent() {
		return Event;
	}

	public void setEvent(String event) {
		Event = event;
	}

	public String getEventKey() {
		return EventKey;
	}

	public void setEventKey(String eventKey) {
		EventKey = eventKey;
	}

	public String getTicket() {
		return Ticket;
	}

	public void setTicket(String ticket) {
		Ticket = ticket;
	}

	@Override
	public String toString() {
		return "WeiXinReq [ToUserName=" + ToUserName + ", FromUserName=" + FromUserName + ", CreateTime=" + CreateTime + ", MsgType=" + MsgType + ", Content=" + Content + ", MsgId=" + MsgId + ", Event=" + Event + ", EventKey=" + EventKey + ", Ticket=" + Ticket + "]";
	}
}

⑨UserInfo.java

package com.remoa.domain.user;
 /* 获取用户基本信息（UnionID机制）在关注者与公众号产生消息交互后，公众号可获得关注者的OpenID
 * （加密后的微信号，每个用户对每个公众号的OpenID是唯一的。对于不同公众号，同一用户的openid不同）。
 * 公众号可通过本接口来根据OpenID获取用户基本信息，包括昵称、头像、性别、所在城市、语言和关注时间。
 * @author Remoa
 *
 */
public class UserInfo {
	private int subscribe;//用户是否订阅该公众号标识，值为0时，代表此用户没有关注该公众号，拉取不到其余信息。
	private String openid;//用户的标识，对当前公众号唯一
	private int sex;//用户的性别，值为1时是男性，值为2时是女性，值为0时是未知
	private String city;//用户所在城市
	private String country;//用户所在国家
	private String province;//用户所在省份
	private String language;//用户的语言，简体中文为zh_CN
	private String headimgurl;//用户头像，最后一个数值代表正方形头像大小（有0、46、64、96、132数值可选，0代表640*640正方形头像），用户没有头像时该项为空。若用户更换头像，原有头像URL将失效。
	private String subscribe_time;//用户关注时间，为时间戳。如果用户曾多次关注，则取最后关注时间
	private String unionid;//只有在用户将公众号绑定到微信开放平台帐号后，才会出现该字段。
	private String remark;//公众号运营者对粉丝的备注，公众号运营者可在微信公众平台用户管理界面对粉丝添加备注
	private String groupid;//用户所在的分组ID
	public int getSubscribe() {
		return subscribe;
	}
	public void setSubscribe(int subscribe) {
		this.subscribe = subscribe;
	}
	public String getOpenid() {
		return openid;
	}
	public void setOpenid(String openid) {
		this.openid = openid;
	}
	public int getSex() {
		return sex;
	}
	public void setSex(int sex) {
		this.sex = sex;
	}
	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 getProvince() {
		return province;
	}
	public void setProvince(String province) {
		this.province = province;
	}
	public String getLanguage() {
		return language;
	}
	public void setLanguage(String language) {
		this.language = language;
	}
	public String getHeadimgurl() {
		return headimgurl;
	}
	public void setHeadimgurl(String headimgurl) {
		this.headimgurl = headimgurl;
	}
	public String getSubscribe_time() {
		return subscribe_time;
	}
	public void setSubscribe_time(String subscribe_time) {
		this.subscribe_time = subscribe_time;
	}
	public String getUnionid() {
		return unionid;
	}
	public void setUnionid(String unionid) {
		this.unionid = unionid;
	}
	public String getRemark() {
		return remark;
	}
	public void setRemark(String remark) {
		this.remark = remark;
	}
	public String getGroupid() {
		return groupid;
	}
	public void setGroupid(String groupid) {
		this.groupid = groupid;
	}
}