dd

src/main/java/com/ekexiu/portal/job/TaskJob.java

@@ -13,6 +13,7 @@ import org.jfw.util.bean.BeanFactory;
import org.jfw.util.context.JfwAppContext;
import com.ekexiu.portal.service.WeixinService;
import com.ekexiu.push.service.PushService;
@Bean
public class TaskJob implements AfterBeanFactory {
@@ -28,6 +29,7 @@ public class TaskJob implements AfterBeanFactory {
		DictTaskJobEntry dtje = (DictTaskJobEntry) bf.getBean("com_ekexiu_portal_job_DictTaskJobEntry");
		HotKeyJobEntry hkje = (HotKeyJobEntry) bf.getBean("com_ekexiu_portal_job_HotKeyJobEntry");
		final WeixinService weixin =(WeixinService)bf.getBean("com_ekexiu_portal_service_WeixinService");
		final PushService pushService =(PushService)bf.getBean("com_ekexiu_push_service_PushService");
		
		long delayTime = tje.getDelayTime();
		long task = getTimeMillis(tje.getTaskTime());
@@ -56,6 +58,12 @@ public class TaskJob implements AfterBeanFactory {
				weixin.refresh();
			}
		}, 0, weixin.getDelayTime(), TimeUnit.SECONDS);
		service.scheduleAtFixedRate(new Runnable() {
			@Override
			public void run() {
				pushService.refresh();				
			}
		}, 0, 2,TimeUnit.SECONDS);
	}
	private static long getTimeMillis(String time) {  
	    try {  

src/main/java/com/ekexiu/push/service/PushService.java

@@ -0,0 +1,303 @@
package com.ekexiu.push.service;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.lang.reflect.Type;
import java.net.HttpURLConnection;
import java.net.URL;
import java.security.MessageDigest;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSession;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;
import org.jfw.apt.web.annotation.Path;
import org.jfw.apt.web.annotation.operate.Post;
import org.jfw.util.ConstData;
import org.jfw.util.io.IoUtil;
import org.jfw.util.json.JsonService;
import org.jfw.util.reflect.TypeReference;
@Path("/push")
public class PushService {
	private static final org.apache.log4j.Logger log = org.apache.log4j.Logger.getLogger(PushService.class);
	private static Type RES_TYPE = new TypeReference<Map<String, Object>>() {
	}.getType();
	private static Map<String, String> CONTENT_TYPE = new HashMap<String, String>();
	private static Map<String,String>  TOKEN_MAP = new ConcurrentHashMap<String,String>();
	private static Map<String, String> ERR_MAP = new HashMap<String, String>();
	final static char[] digits = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
	// UiIGJTfKNR8oXb8apYdGh3
	private String secret = "UiIGJTfKNR8oXb8apYdGh3";
	private String appKey = "FnwUFkK2nt9BLgQ0XjtOl4";
	private String appId = "G3L3npt6LU92DZHkdNxuL4";
	private int timeout = 0;
	private String token = null;
	private long lastBuildTime = 0;
	public String getSecret() {
		return secret;
	}
	public void setSecret(String secret) {
		this.secret = secret;
	}
	public String getAppKey() {
		return appKey;
	}
	public void setAppKey(String appKey) {
		this.appKey = appKey;
	}
	public String getAppId() {
		return appId;
	}
	public void setAppId(String appId) {
		this.appId = appId;
	}
	public int getTimeout() {
		return timeout;
	}
	public void setTimeout(int timeout) {
		this.timeout = timeout;
	}
	private String buildSign(long flag) {
		String p = this.appKey + flag + this.secret;
		MessageDigest messageDigest;
		try {
			messageDigest = MessageDigest.getInstance("SHA-256");
			messageDigest.update(p.getBytes("UTF-8"));
			StringBuilder sb = new StringBuilder();
			for (byte b : messageDigest.digest()) {
				sb.append(digits[(b & 0xf0) >> 4]);
				sb.append(digits[b & 0xf]);
			}
			return sb.toString();
		} catch (Exception e) {
			throw new RuntimeException("jdk unsupported sh256???????????", e);
		}
	}
	private void checkResult(Map<String, Object> ret) {
		Object obj = ret.get("result");
		if ("ok".equals(obj))
			return;
		String errMsg = null;
		errMsg = ERR_MAP.get(obj);
		if (errMsg == null)
			errMsg = "其他错误";
		log.error("调用用个推restApi,返回结果错误：" + obj + ":" + errMsg);
		throw new RuntimeException("调用用个推restApi,返回结果错误：" + obj + ":" + errMsg);
	}
	
	private void checkToken()
	{
		if(this.token==null){
			log.error("token is null");
			throw new RuntimeException("token is null");
		}
	}
	private void buildToken() {
		long time = System.currentTimeMillis();
		String sign = this.buildSign(time);
		StringBuilder sb = new StringBuilder();
		sb.append("{\"sign\":\"").append(sign).append("\",\"timestamp\":\"").append(time).append("\",\"appkey\":\"").append(this.appKey).append("\"}");
		try {
			Map<String, Object> ret = post("https://restapi.getui.com/v1/" + this.appId + "/auth_sign", CONTENT_TYPE, sb.toString().getBytes(ConstData.UTF8));
			this.checkResult(ret);
			String otoken = (String) ret.get("auth_token");
			if (otoken == null) {
				throw new RuntimeException("返回token is null");
			}
			this.token = otoken;
			this.lastBuildTime = System.currentTimeMillis();
			TOKEN_MAP.put("authtoken", this.token);
		} catch (Exception e) {
			this.token = null;
			log.error("build token error", e);
		}
	}
	public void refresh(){
		if((this.token!=null)  && ((System.currentTimeMillis() -  this.lastBuildTime) < (24*60 *60*1000-5000))){
			return ;
		}
		this.buildToken();
	}
	
	public Map<String, Object> post(String url, Map<String, String> header, byte[] data) throws IOException {
		HttpURLConnection connection = getConnection(url);
		try {
			connection.setRequestMethod("POST");
			connection.setUseCaches(false);
			for (Map.Entry<String, String> entry : header.entrySet()) {
				connection.setRequestProperty(entry.getKey(), entry.getValue());
			}
			connection.setDoOutput(true);
			connection.setDoInput(true);
			if (this.timeout > 0) {
				connection.setConnectTimeout(this.timeout);
				connection.setReadTimeout(this.timeout);
			}
			connection.setFixedLengthStreamingMode(data.length);
			OutputStream out = connection.getOutputStream();
			try {
				out.write(data);
			} finally {
				out.close();
			}
			int code = connection.getResponseCode();
			if (code == 200) {
				InputStream in = null;
				byte[] resData = null;
				try {
					in = connection.getInputStream();
					resData = IoUtil.readStream(in, false);
				} catch (IOException e) {
					log.error("Error read http response stream,url:" + url, e);
					throw new IOException("Error read http response stream");
				} finally {
					if (null != in)
						IoUtil.close(in);
				}
				try {
					return JsonService.fromJson(new String(resData, ConstData.UTF8), RES_TYPE);
				} catch (Exception e) {
					log.error("invalid response data,url:" + url, e);
					throw new IOException("invalid response data", e);
				}
			}
			log.error("Error http reponse status:" + code + ",url:" + url);
			throw new IOException("Error http reponse status:" + code);
		} finally {
			connection.disconnect();
		}
	}
	
	
	@Path("/bindAlias")
	@Post
	public boolean bindAlias(String alias,String cid){
		String url = "https://restapi.getui.com/v1/"+this.appId+"/bind_alias";
		StringBuilder sb = new StringBuilder();
		sb.append("{\"alias_list\" : [{\"cid\":\"").append(cid).append("\",\"alias\":\"").append(alias).append("\" }]}");
		try {
			Map<String,Object> ret = post(url, TOKEN_MAP,sb.toString().getBytes(ConstData.UTF8));
			this.checkResult(ret);
			return true;
		} catch (IOException e) {
			log.error("bind alias error[cid:"+cid+",alias:"+alias+"]",e);
			return false;
		}
	}
	
	
	
	public static HttpURLConnection getConnection(String urlString) throws IOException {
		URL url = new URL(urlString);
		HttpURLConnection conn = null;
		conn = (HttpURLConnection) url.openConnection();
		String protocal = url.getProtocol();
		if ((protocal != null) && (protocal.equalsIgnoreCase("https"))) {
			try {
				HttpsURLConnection httpsConn = (HttpsURLConnection) conn;
				httpsConn.setSSLSocketFactory(getTrustAllSSLContext().getSocketFactory());
				HostnameVerifier hv = new HostnameVerifier() {
					public boolean verify(String arg0, SSLSession arg1) {
						return true;
					}
				};
				httpsConn.setHostnameVerifier(hv);
			} catch (Exception e) {
				log.warn("init httpmanager error", e);
				throw new RuntimeException("init httpmanager error", e);
			}
		}
		return conn;
	}
	public static SSLContext getTrustAllSSLContext() throws Exception {
		TrustManager[] trustAllCerts = new TrustManager[1];
		TrustManager trust = new CustomTrustManager();
		trustAllCerts[0] = trust;
		SSLContext sc = SSLContext.getInstance("SSL");
		sc.init(null, trustAllCerts, null);
		return sc;
	}
	static class CustomTrustManager implements TrustManager, X509TrustManager {
		public X509Certificate[] getAcceptedIssuers() {
			return null;
		}
		public boolean isServerTrusted(X509Certificate[] certs) {
			return true;
		}
		public boolean isClientTrusted(X509Certificate[] certs) {
			return true;
		}
		public void checkServerTrusted(X509Certificate[] certs, String authType) throws CertificateException {
		}
		public void checkClientTrusted(X509Certificate[] certs, String authType) throws CertificateException {
		}
	}
	static {
		CONTENT_TYPE.put("Content-Type", "application/json");
		TOKEN_MAP.putAll(CONTENT_TYPE);
		ERR_MAP.put("no_msg", "没有消息体");
		ERR_MAP.put("alias_error", "找不到别名");
		ERR_MAP.put("black_ip", "黑名单ip");
		ERR_MAP.put("sign_error", "鉴权失败");
		ERR_MAP.put("pushnum_overlimit", "推送次数超限");
		ERR_MAP.put("no_appid", "找不到appid");
		ERR_MAP.put("no_user", "找不到对应用户");
		ERR_MAP.put("too_frequent", "推送过于频繁");
		ERR_MAP.put("sensitive_word", "有敏感词出现");
		ERR_MAP.put("appid_notmatch", "appid与cid或者appkey不匹配");
		ERR_MAP.put("not_auth", "用户没有鉴权");
		ERR_MAP.put("black_appid", "黑名单app");
		ERR_MAP.put("invalid_param", "参数检验不通过");
		ERR_MAP.put("alias_notbind", "别名没有绑定cid");
		ERR_MAP.put("tag_over_limit", "tag个数超限");
		ERR_MAP.put("successed_online", "在线下发");
		ERR_MAP.put("successed_offline", "离线下发");
		ERR_MAP.put("taginvalid_or_noauth", "tag无效或者没有使用权限");
		ERR_MAP.put("no_valid_push", "没有有效下发");
		ERR_MAP.put("successed_ignore", "忽略非活跃用户");
		ERR_MAP.put("no_taskid", "找不到taskid");
	}
	public static void main(String[] args) throws Exception {
		PushService s = new PushService();
		s.buildToken();
		s.checkToken();
	}
}