調用Windows手機推送通知服務的Java客戶端框架/ API

Question

有誰知道是否有Java客戶端框架/ API來調用Windows手機推送通知服務？我知道有一個JavaPNS項目，這是專門針對Apple PNS的項目。 我正在尋找類似的東西，但特定於Windows手機。

任何幫助？

Answer 1

Java-mpns似乎接近你正在尋找的東西。

https://github.com/notnoop/java-mpns

Answer 2

我已經開發了使用Spring和Apache HTTP共享客戶端的解決方案，用於發送使用WNS（Windows通知推送服務）

插入此依賴關係在你的pom.xml RAW消息：

<dependency> 
    <groupId>org.apache.httpcomponents</groupId> 
    <artifactId>httpclient</artifactId> 
    <version>4.2.1</version> 
</dependency> 
<dependency> 
    <groupId>org.codehaus.jackson</groupId> 
    <artifactId>jackson-mapper-asl</artifactId> 
    <version>1.9.12</version> 
</dependency> 

而上的applicationContext.xml

<bean class="java.lang.String" id="authenticateUrlPostWNS"> 
    <constructor-arg> 
     <value>https://login.live.com/accesstoken.srf</value> 
    </constructor-arg> 
</bean> 
<util:map id="authenticateWNSHeaders"> 
    <entry key="Content-Type" value="application/x-www-form-urlencoded" /> 
</util:map> 
<util:map id="authenticateWNSPostParams"> 
    <entry key="grant_type" value="client_credentials" /> 
    <entry key="client_id" value="ms-app://" /> 
    <entry key="client_secret" value="" /> 
    <entry key="scope" value="notify.windows.com" /> 
</util:map> 
<util:map id="sendMessageWNSHeaders"> 
    <entry key="X-WNS-Type" value="wns/raw" /> 
    <entry key="Content-Type" value="application/octet-stream" /> 
    <entry key="X-WNS-RequestForStatus" value="true" /> 
    <entry key="X-NotificationClass" value="3" /> 
</util:map> 

012以下行

*請務必填寫CLIENT_ID和client_secret

在我的項目，我分了實現四個類，我將在下面說明

OAuthToken用於存儲和格式化訪問令牌：

public class OAuthToken { 
    private String token; 
    private String tokenType; 

    public OAuthToken(String token, String tokenType) { 
     super(); 
     this.token = token; 
     this.tokenType = tokenType; 
    } 

    public String getAuthorization() { 
     return StringUtils.capitalize(tokenType) + " " + token; 
    } 
} 

的HttpClientFactory（以下所示的）被用來只要發送消息來創建一個新的客戶端。如果您重複使用相同的HttpClient發送消息，則發送第二個消息後WNS超時。我不知道爲什麼會發生這種情況，但是當我停止重複使用客戶端時就解決了。

@Service 
public class HttpClientFactory { 
    private static final int TIMEOUT = 20 * 1000; 

    public HttpClient create() { 
     SystemDefaultHttpClient httpClient = new SystemDefaultHttpClient(); 
     httpClient.getParams().setIntParameter(CoreConnectionPNames.CONNECTION_TIMEOUT, TIMEOUT); 
     httpClient.getParams().setIntParameter(CoreConnectionPNames.SO_TIMEOUT, TIMEOUT); 
     httpClient.setHttpRequestRetryHandler(new DefaultHttpRequestRetryHandler(NumberUtils.INTEGER_ZERO, false)); 
     return httpClient; 
    } 

} 

這是一個基類，如你所願，你可以拉下所有代碼WindowsPushNotificationMediator

public abstract class AbstractCloudMediator { 
    private static final Logger LOG = Logger.getLogger(AbstractCloudMediator.class.getSimpleName()); 
    @Autowired 
    private HttpClientFactory clientFactory; 

    @Autowired 
    protected ObjectMapper mapper; 

    public abstract boolean sendMessage(Jogador destinatario, Action mensagem); 

    protected String postToString(HttpPost post) throws IOException, ClientProtocolException { 
     HttpResponse response = executeMethod(post); 

     return responseToString(response); 
    } 

    protected String responseToString(HttpResponse response) throws IOException { 
     InputStream conteudoResposta = response.getEntity().getContent(); 
     try { 
      return IOUtils.toString(conteudoResposta); 
     } finally { 
      IOUtils.closeQuietly(conteudoResposta); 
     } 
    } 

    protected HttpResponse executeMethod(HttpPost post) throws IOException, ClientProtocolException { 
     LOG.info("posting to... " + post); 
     return clientFactory.create().execute(post); 
    } 
} 

下一個類應該做的主要工作，但記得要創建一個cloudMessagingDAO檢索和存儲您的訪問令牌。 您應該爲包含客戶端URL的另一個類替換類Jogador，該類用於將消息發送到Windows Phone設備。

@Service(SharedConstants.WINDOWS_CLOUD_BEAN) 
public class WindowsPushNotificationMediator extends AbstractCloudMediator { // NO_UCD (test only) 
    private static final Logger LOG = Logger.getLogger(WindowsPushNotificationMediator.class.getName()); 
    private static final String KEY_ACCESS_TOKEN = "access_token"; 
    private static final String KEY_TOKEN_TYPE = "token_type"; 

    @Resource(name = "authenticateWNSHeaders") 
    private Map<String, String> authenticateWNSHeaders; 

    @Resource(name = "authenticateWNSPostParams") 
    private Map<String, String> authenticateWNSPostParams; 

    @Resource(name = "sendMessageWNSHeaders") 
    private Map<String, String> sendMessageWNSHeaders; 

    @Autowired 
    @Qualifier("authenticateUrlPostWNS") 
    private String authenticateUrlPostWNS; 

    @Autowired 
    private CloudMessagingDAO cloudMessagingDAO; 

    private OAuthToken oathToken; 

    @Override 
    public boolean sendMessage(Jogador destinatario, Action mensagem) { 
     try { 
      OAuthToken token = getToken(); 
      String jsonString = mapper.writeValueAsString(mensagem); 
      StringEntity entity = new StringEntity(jsonString, Consts.UTF_8); 
      return sendMessage(destinatario, entity, token); 
     } catch (IOException e) { 
      LOG.log(Level.SEVERE, e.getMessage(), e); 
      throw new RuntimeException(e); 
     } 
    } 

    private boolean sendMessage(Jogador destinatario, HttpEntity entity, OAuthToken token) throws IOException { 
     HttpPost post = new HttpPost(destinatario.getCloudMessagingInfo());// this is the client url 

     post.addHeader("Authorization", token.getAuthorization()); 
     addPostHeaders(post, sendMessageWNSHeaders); 

     post.setEntity(entity); 
     HttpResponse response = executeMethod(post); 
     if (response.getStatusLine().getStatusCode() == HttpStatus.SC_UNAUTHORIZED) { 
      return sendMessage(destinatario, entity, getNewToken()); 
     } 
     Header[] allHeaders = response.getAllHeaders(); 
     StringBuilder builder = new StringBuilder(); 
     for (Header header : allHeaders) { 
      builder.append(header.getName() + ": " + header.getValue()); 
      builder.append('\n'); 
     } 
     LOG.info(builder.toString()); 
     return response.getStatusLine().getStatusCode() == HttpStatus.SC_OK; 
    } 

    private void addPostHeaders(HttpPost post, Map<String, String> postHeaders) { 
     for (String key : postHeaders.keySet()) { 
      post.addHeader(key, postHeaders.get(key)); 
     } 
    } 

    private OAuthToken getToken() throws IOException { 
     if (oathToken == null) { 
      //You should store your access token, so you can reuse it until it expires 
      String token = cloudMessagingDAO.getValue(KEY_ACCESS_TOKEN); 
      String tokenType = cloudMessagingDAO.getValue(KEY_TOKEN_TYPE); 
      if (StringUtils.isNotBlank(token) && StringUtils.isNotBlank(tokenType)) { 
       return oathToken = new OAuthToken(token, tokenType); 
      } 
      return getNewToken(); 
     } 
     return oathToken; 
    } 

    private OAuthToken getNewToken() throws IOException { 
     HttpPost post = new HttpPost(authenticateUrlPostWNS); 
     addPostHeaders(post, authenticateWNSHeaders); 
     List<NameValuePair> params = new ArrayList<>(); 
     for (String key : authenticateWNSPostParams.keySet()) { 
      params.add(new BasicNameValuePair(key, authenticateWNSPostParams.get(key))); 
     } 
     post.setEntity(new UrlEncodedFormEntity(params)); 
     HttpResponse response = executeMethod(post); 
     String conteudo = responseToString(response); 

     LOG.info(conteudo); 
     if (response.getStatusLine().getStatusCode() != HttpStatus.SC_OK) { 
      throw new NegocioException("Falha ao autenticar no serviço: " + conteudo); 
     } 

     @SuppressWarnings("unchecked") 
     Map<String, String> resultMap = mapper.readValue(conteudo, HashMap.class); 
     cloudMessagingDAO.setValues(resultMap); 
     return oathToken = new OAuthToken(resultMap.get(KEY_ACCESS_TOKEN), resultMap.get(KEY_TOKEN_TYPE)); 
    } 
}