极光推送经验之谈-Java后台服务器实现极光推送的两种实现方式

╰+攻爆jí腚メ 2022-05-22 13:11 288阅读 0赞

转载自 https://www.cnblogs.com/V1haoge/p/6439313.html

原创作品，可以转载，但是请标注出处地址[http://www.cnblogs.com/V1haoge/p/6439313.html][http_www.cnblogs.com_V1haoge_p_6439313.html]

Java后台实现极光推送有两种方式，一种是使用极光推送官方提供的推送请求API：https://api.jpush.cn/v3/push，另一种则是使用官方提供的第三方Java SDK，这里先进行第一种方式推送的实现代码：

![复制代码][copycode.gif]

import org.apache.http.HttpResponse;
    import org.apache.http.client.HttpClient;
    import org.apache.http.client.methods.HttpPost;
    import org.apache.http.entity.StringEntity;
    import org.apache.http.impl.client.DefaultHttpClient;
    import org.apache.http.util.EntityUtils;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import com.alibaba.fastjson.JSONArray;
    import net.sf.json.JSONObject;
    import sun.misc.BASE64Encoder;
    
    /**
     * java后台极光推送方式一：使用Http API
     * 此种方式需要自定义http请求发送客户端:HttpClient
     */
    @SuppressWarnings({ "deprecation", "restriction" })
    public class JiguangPush {
        private static final Logger log = LoggerFactory.getLogger(JiguangPush.class);
        private String masterSecret = "xxxxxxxxxxxxxxxxxxxx";
        private String appKey = "xxxxxxxxxxxxxxxxxxx";
        private String pushUrl = "https://api.jpush.cn/v3/push";    
        private boolean apns_production = true;    
        private int time_to_live = 86400;
        private static final String ALERT = "推送信息";    
        /**
         * 极光推送
         */
        public void jiguangPush(){
            String alias = "123456";//声明别名
            try{
                String result = push(pushUrl,alias,ALERT,appKey,masterSecret,apns_production,time_to_live);
                JSONObject resData = JSONObject.fromObject(result);
                    if(resData.containsKey("error")){
                        log.info("针对别名为" + alias + "的信息推送失败！");
                        JSONObject error = JSONObject.fromObject(resData.get("error"));
                        log.info("错误信息为：" + error.get("message").toString());
                    }
                log.info("针对别名为" + alias + "的信息推送成功！");
            }catch(Exception e){
                log.error("针对别名为" + alias + "的信息推送失败！",e);
            }
        }
        
        /**
         * 组装极光推送专用json串
         * @param alias
         * @param alert
         * @return json
         */
        public static JSONObject generateJson(String alias,String alert,boolean apns_production,int time_to_live){
            JSONObject json = new JSONObject();
            JSONArray platform = new JSONArray();//平台
            platform.add("android");
            platform.add("ios");
            
            JSONObject audience = new JSONObject();//推送目标
            JSONArray alias1 = new JSONArray();
            alias1.add(alias);
            audience.put("alias", alias1);
            
            JSONObject notification = new JSONObject();//通知内容
            JSONObject android = new JSONObject();//android通知内容
            android.put("alert", alert);
            android.put("builder_id", 1);
            JSONObject android_extras = new JSONObject();//android额外参数
            android_extras.put("type", "infomation");
            android.put("extras", android_extras);
            
            JSONObject ios = new JSONObject();//ios通知内容
            ios.put("alert", alert);
            ios.put("sound", "default");
            ios.put("badge", "+1");
            JSONObject ios_extras = new JSONObject();//ios额外参数
            ios_extras.put("type", "infomation");
            ios.put("extras", ios_extras);
            notification.put("android", android);
            notification.put("ios", ios);
            
            JSONObject options = new JSONObject();//设置参数
            options.put("time_to_live", Integer.valueOf(time_to_live));
            options.put("apns_production", apns_production);
            
            json.put("platform", platform);
            json.put("audience", audience);
            json.put("notification", notification);
            json.put("options", options);
            return json;
            
        }
        
        /**
         * 推送方法-调用极光API
         * @param reqUrl
         * @param alias
         * @param alert
         * @return result
         */
        public static String push(String reqUrl,String alias,String alert,String appKey,String masterSecret,boolean apns_production,int time_to_live){
            String base64_auth_string = encryptBASE64(appKey + ":" + masterSecret);
            String authorization = "Basic " + base64_auth_string;
            return sendPostRequest(reqUrl,generateJson(alias,alert,apns_production,time_to_live).toString(),"UTF-8",authorization);
        }
        
        /**
         * 发送Post请求（json格式）
         * @param reqURL
         * @param data
         * @param encodeCharset
         * @param authorization
         * @return result
         */
        @SuppressWarnings({ "resource" })
        public static String sendPostRequest(String reqURL, String data, String encodeCharset,String authorization){
            HttpPost httpPost = new HttpPost(reqURL);
            HttpClient client = new DefaultHttpClient();
            HttpResponse response = null;
            String result = "";
            try {
                 StringEntity entity = new StringEntity(data, encodeCharset);
                 entity.setContentType("application/json");
                 httpPost.setEntity(entity);
                 httpPost.setHeader("Authorization",authorization.trim());
                 response = client.execute(httpPost);
                 result = EntityUtils.toString(response.getEntity(), encodeCharset);
            } catch (Exception e) {
                log.error("请求通信[" + reqURL + "]时偶遇异常,堆栈轨迹如下", e);  
            }finally{
                client.getConnectionManager().shutdown();
            }
            return result;
        }
        /** 　　　　* BASE64加密工具 　　　　*/
         public static String encryptBASE64(String str) {
             byte[] key = str.getBytes();
           BASE64Encoder base64Encoder = new BASE64Encoder();
           String strs = base64Encoder.encodeBuffer(key);
             return strs;
         }
    }

![复制代码][copycode.gif]

以上代码中使用的是第一种方式实现推送，下面介绍第二种方式：使用java SDK

![复制代码][copycode.gif]

import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import cn.jiguang.common.ClientConfig;
    import cn.jiguang.common.resp.APIConnectionException;
    import cn.jiguang.common.resp.APIRequestException;
    import cn.jpush.api.JPushClient;
    import cn.jpush.api.push.PushResult;
    import cn.jpush.api.push.model.Options;
    import cn.jpush.api.push.model.Platform;
    import cn.jpush.api.push.model.PushPayload;
    import cn.jpush.api.push.model.audience.Audience;
    import cn.jpush.api.push.model.notification.AndroidNotification;
    import cn.jpush.api.push.model.notification.IosNotification;
    import cn.jpush.api.push.model.notification.Notification;
    
    
    /**
     * java后台极光推送方式二：使用Java SDK
     */
    @SuppressWarnings({ "deprecation", "restriction" })
    public class JiguangPush {
        private static final Logger log = LoggerFactory.getLogger(JiguangPush.class);
        private static String masterSecret = "xxxxxxxxxxxxxxxxx";
        private static String appKey = "xxxxxxxxxxxxxxxx";
        private static final String ALERT = "推送信息";    
        /**
         * 极光推送
         */
        public void jiguangPush(){
            String alias = "123456";//声明别名
            log.info("对别名" + alias + "的用户推送信息");
            PushResult result = push(String.valueOf(alias),ALERT);
            if(result != null && result.isResultOK()){
                log.info("针对别名" + alias + "的信息推送成功！");
            }else{
                log.info("针对别名" + alias + "的信息推送失败！");
            }
        }
        
        /**
         * 生成极光推送对象PushPayload（采用java SDK）
         * @param alias
         * @param alert
         * @return PushPayload
         */
        public static PushPayload buildPushObject_android_ios_alias_alert(String alias,String alert){
            return PushPayload.newBuilder()
                    .setPlatform(Platform.android_ios())
                    .setAudience(Audience.alias(alias))
                    .setNotification(Notification.newBuilder()
                            .addPlatformNotification(AndroidNotification.newBuilder()
                                    .addExtra("type", "infomation")
                                    .setAlert(alert)
                                    .build())
                            .addPlatformNotification(IosNotification.newBuilder()
                                    .addExtra("type", "infomation")
                                    .setAlert(alert)
                                    .build())
                            .build())
                    .setOptions(Options.newBuilder()
                            .setApnsProduction(false)//true-推送生产环境 false-推送开发环境（测试使用参数）
                            .setTimeToLive(90)//消息在JPush服务器的失效时间（测试使用参数）
                            .build())
                    .build();
        }
        /**
         * 极光推送方法(采用java SDK)
         * @param alias
         * @param alert
         * @return PushResult
         */
        public static PushResult push(String alias,String alert){
            ClientConfig clientConfig = ClientConfig.getInstance();
            JPushClient jpushClient = new JPushClient(masterSecret, appKey, null, clientConfig);
            PushPayload payload = buildPushObject_android_ios_alias_alert(alias,alert);
            try {
                return jpushClient.sendPush(payload);
            } catch (APIConnectionException e) {
                log.error("Connection error. Should retry later. ", e);
                return null;
            } catch (APIRequestException e) {
                log.error("Error response from JPush server. Should review and fix it. ", e);
                log.info("HTTP Status: " + e.getStatus());
                log.info("Error Code: " + e.getErrorCode());
                log.info("Error Message: " + e.getErrorMessage());
                log.info("Msg ID: " + e.getMsgId());
                return null;
            }    
        }
    }

![复制代码][copycode.gif]

可以看出使用Java SDK实现推送的方式很简单，代码量也少，理解起来也不难，官方提供的SDK中将很多内容都实现了，我们只是需要配置一下信息，然后发起推送即可。需要注意的是使用第二种方式，需要导入极光官网提供的jar包。

直接在maven中的pom文件中加入：

<dependency>
        <groupId>cn.jpush.api</groupId>
        <artifactId>jpush-client</artifactId>
        <version>3.2.15</version>
    </dependency>

注意：在这里极有可能会出现jar包冲突：具体哪个包我也忘记了，好像是个日志包，找到后删除即可，我曾经记录过这个jar包冲突问题，详见[jar包冲突解决][jar]。

原本我们项目中也是采用第二种方式实现的，但是最后在提交代码时发现一个问题，那就是虽然我们只是带导入了官网提供的那个jar包，但是最后一统计，竟然无缘无故增多了80+个jar包，如此多的jar包提交过于臃肿，而且不现实，所以才临时改变方案，采用第一种方式进行编码。

代码中采用的是别名方式进行推送，需要在在手机APP端进行别名设置，最好就是在用户登录之后就设置好，这样只要用户登录一次，它的绑定别名就可以保存到极光服务器，而我们推送时，指定这个别名，就能将信息推送到对应用户的手机上。

其实我们发起推送请求，只是将信息发送到了极光服务器之上，这个信息有一个保存时限，默认一天，只要用户使用手机APP登录系统，极光服务器就会将信息自动推送到对应别名的手机上，由此可见，信息并非由我们后台直接推送到手机，而是通过极光服务器这个中转站，而这正式极光的工作。

注意：这里告知一个技巧，这个别名设置的时候，其实直接将用户ID设置为别名即可，既方便，又安全，不用再去想办法生成一个唯一的串来进行标识，甚至需要在后台数据库中用户表中新增字段。

[http_www.cnblogs.com_V1haoge_p_6439313.html]: http://www.cnblogs.com/V1haoge/p/6439313.html
[copycode.gif]: /images/20220522/6a7bbf9f57064a6193a2e2efe57fe579.png
[jar]: http://www.cnblogs.com/V1haoge/p/6165136.html