个推推送

青旅半醒 2022-05-25 14:26 234阅读 0赞

1.  引入maven依赖
    
        <dependency>
            <groupId>com.gexin.platform</groupId>
            <artifactId>gexin-rp-sdk-http</artifactId>
            <version>4.0.1.17</version>
        </dependency>
    
        <repositories>
            <repository>
                <id>getui-nexus</id>
                <url>http://mvn.gt.igexin.com/nexus/content/repositories/releases/</url>
            </repository>
         </repositories>
    
    2.个推消息接口
    
        package component.invoker.manager.push;
        
        import component.invoker.domain.wrapper.message.PushMessage;
        /**
         * @author wangbowen
         * @description 个推消息接口
         * @Date 2018/5/14
         * @since 1.0.0
         */
        public interface PushMessageExecutor {
            /**
             * 推送消息
             * @param message 消息对象
             * @return boolean
             */
            boolean send(PushMessage message);
        }
    
    3.个推消息实现接口
    
        package component.invoker.manager.push.support;
        
        import com.gexin.rp.sdk.base.IPushResult;
        import component.invoker.domain.wrapper.message.PushMessage;
        import component.invoker.manager.push.PushMessageExecutor;
        import component.invoker.manager.push.template.TransmissionMessageTemplate;
        import org.springframework.stereotype.Component;
        
        import javax.annotation.Resource;
        import java.util.Map;
        import java.util.Objects;
        
        /**
         * @author wangbowen
         * @description
         * @Date 2018/5/14
         * @since 1.0.0
         */
        @Component
        public class PushMessageExecutorSupport implements PushMessageExecutor {
            @Resource
            private MessageHelper notificationMessageHelper;
            @Override
            public boolean send(PushMessage message) {
                if(Objects.nonNull(message)){
                    notificationMessageHelper = new MessageHelper();
                    //设置消息的模板
                    notificationMessageHelper.setMessageTemplate(new TransmissionMessageTemplate());
                    //发送消息
                    IPushResult iPushResult = notificationMessageHelper.sendMessage(message);
                    //获取返回结果
                    Map<String, Object> result = iPushResult.getResponse();
                    String ok = result.get("result").toString();
                    if(ok.equals("ok")){
                        return true;
                    }
        
                }
                return false;
            }
        }
    
    4.个推消息帮助类
    
        package component.invoker.manager.push.support;
        
        import com.gexin.rp.sdk.base.IPushResult;
        import com.gexin.rp.sdk.base.impl.ListMessage;
        import com.gexin.rp.sdk.base.impl.Target;
        import com.gexin.rp.sdk.http.IGtPush;
        import com.gexin.rp.sdk.template.AbstractTemplate;
        import component.invoker.domain.wrapper.message.PushMessage;
        import component.invoker.manager.push.PushMessageExecutor;
        import component.invoker.manager.push.config.MessageProperties;
        import component.invoker.manager.push.constant.MessageConstant;
        import component.invoker.manager.push.template.DefaultNotificationMessageTemplate;
        import component.invoker.manager.push.template.MessageTemplate;
        import org.slf4j.Logger;
        import org.slf4j.LoggerFactory;
        import org.springframework.boot.context.properties.EnableConfigurationProperties;
        import org.springframework.stereotype.Component;
        import org.springframework.util.Assert;
        
        import javax.annotation.Resource;
        import java.util.ArrayList;
        import java.util.List;
        
        /**
         * @author wangbowen
         * @description 个推消息辅助类
         * @Date 2018/5/14
         * @since 1.0.0
         */
        @Component
        @EnableConfigurationProperties(MessageProperties.class)
        public class MessageHelper {
            private Logger logger =LoggerFactory.getLogger(MessageHelper.class);
        
            /**
             * 消息对象
             */
            private PushMessage messageEntity;
            /**
             * 消息模板
             */
            private MessageTemplate messageTemplate;
        
            @Resource
            private MessageProperties messageProperties;
        
        
        
            /**
             * 发送消息
             * @param message 消息
             * @return IPushResult
             */
            public IPushResult sendMessage(PushMessage message){
                return this.setNotificationMessageEntity(message).checkNotNull().execute();
            }
        
            /**
             * 检验
             * @return
             */
            private MessageHelper checkNotNull(){
                Assert.notNull(getNotificationMessageEntity().getText(),"标题不能为空");
                Assert.isTrue(getNotificationMessageEntity().getClientIds().size()>0, "应用App clientId信息不能为空");
                return this;
            }
        
            private IPushResult execute(){
                messageProperties = new MessageProperties();
                logger.info("---------------开始发送消息----------------");
                String appId = messageProperties.getAppId();
                String appKey = messageProperties.getAppKey();
                String masterSecret = messageProperties.getMasterSecret();
                String host = messageProperties.getHost();
        
                IGtPush push = new IGtPush(host, appKey, masterSecret);
                // 定义"点击链接打开通知模板"，并设置标题、内容、链接
                if(messageTemplate==null){
                    messageTemplate = new DefaultNotificationMessageTemplate();
                }else{
                    messageTemplate = getMessageTemplate();
                }
                AbstractTemplate notificationTemplate = messageTemplate.createTemplate(getNotificationMessageEntity());
                notificationTemplate.setAppId(appId);
                notificationTemplate.setAppkey(appKey);
        
                // 定义"AppMessage"类型消息对象，设置消息内容模板、发送的目标App列表、是否支持离线发送、以及离线消息有效期(单位毫秒)
                ListMessage message = createListMessage(notificationTemplate);
                //设置发送群体
                List<Target> targets = getTargets();
                String taskId = push.getContentId(message);
                IPushResult ret = push.pushMessageToList(taskId, targets);
                logger.info("------------发送消息结果："+ret.getResponse().toString()+".------------");
                return ret;
            }
        
            /**
             * 创建消息
             * @param notificationTemplate 消息模板
             * @return ListMessage
             */
            private ListMessage createListMessage(AbstractTemplate notificationTemplate){
                ListMessage message = new	ListMessage();
                message.setData(notificationTemplate);
                // 设置消息离线，并设置离线时间
                message.setOffline(true);
                // 离线有效时间，单位为毫秒，可选
                message.setOfflineExpireTime(MessageConstant.offlineExpireTime);
                return message;
        
            }
        
            /**
             * 消息目标对象
             * @return
             */
            private List<Target> getTargets(){
               List<String> clientIds = getNotificationMessageEntity().getClientIds();
                List<Target> targets = new ArrayList<>();
                clientIds.forEach(clientId->{
                    Target target = new Target();
                    target.setClientId(clientId);
                    target.setAppId(messageProperties.getAppId());
                    targets.add(target);
                });
                return targets;
            }
            public PushMessage getNotificationMessageEntity() {
                return messageEntity;
            }
        
            public MessageTemplate getMessageTemplate() {
                return messageTemplate;
            }
        
            public MessageHelper setNotificationMessageEntity(PushMessage notificationMessageEntity) {
                this.messageEntity = notificationMessageEntity;
                return this;
            }
            public MessageHelper setMessageTemplate(MessageTemplate messageTemplate) {
                this.messageTemplate = messageTemplate;
                return this;
            }
        
            /**
             * 测试
             * @param args
             */
            public static void main(String[] args) {
                String clientId = "f709d9df32970b940844367727e2e76d";
               List<String> clientIds = new ArrayList<>();
                clientIds.add(clientId);
                PushMessage message = new PushMessage();
                message.setText("你有一条最新的消息");
                message.setTitle("消息通知");
                message.setClientIds(clientIds);
                PushMessageExecutor pushMessageExecutor = new PushMessageExecutorSupport();
                pushMessageExecutor.send(message);
            }
        }
    
    5.消息模板接口
    
        package component.invoker.manager.push.template;
        
        import com.gexin.rp.sdk.template.AbstractTemplate;
        import component.invoker.domain.wrapper.message.PushMessage;
        /**
         * @author wangbowen
         * @description 消息模板接口
         * @Date 2018/5/14
         * @since 1.0.0
         */
        public interface MessageTemplate {
            /**
             * 创建消息模板
             * @param message 消息对象
             * @return AbstractTemplate
             */
            AbstractTemplate createTemplate(PushMessage message);
        }
    
    6.消息模板实现接口，默认通知类型的模板
    
        package component.invoker.manager.push.template;
        
        import com.gexin.rp.sdk.template.AbstractTemplate;
        import com.gexin.rp.sdk.template.NotificationTemplate;
        import com.gexin.rp.sdk.template.style.Style0;
        import component.invoker.domain.wrapper.message.PushMessage;
        import component.invoker.manager.push.constant.MessageConstant;
        /**
         * @author wangbowen
         * @description 默认的点击通知打开应用的消息模板
         * @Date 2018/5/14
         * @since 1.0.0
         */
        public class DefaultNotificationMessageTemplate implements MessageTemplate {
            public AbstractTemplate createTemplate(PushMessage message) {
                NotificationTemplate template = new NotificationTemplate();
                // 透传消息设置，1为强制启动应用，客户端接收到消息后就会立即启动应用；2为等待应用启动
                template.setTransmissionType(MessageConstant.TYPE_LAUNCH_APP);
                template.setTransmissionContent(message.getTransmissionContent());
                Style0 style = new Style0();
                // 设置通知栏标题与内容
                style.setTitle(message.getTitle());
                style.setText(message.getText());
                // 配置通知栏图标
                style.setLogo(MessageConstant.logo);
                // 配置通知栏网络图标
                style.setLogoUrl(MessageConstant.logoUrl);
                // 设置通知是否响铃，震动，或者可清除
                style.setRing(true);
                style.setVibrate(true);
                style.setClearable(true);
                template.setStyle(style);
                return template;
            }
        }
    
      
    
    
        package component.invoker.manager.push.template;
        
        import com.gexin.rp.sdk.base.payload.APNPayload;
        import com.gexin.rp.sdk.template.AbstractTemplate;
        import com.gexin.rp.sdk.template.TransmissionTemplate;
        import component.invoker.domain.wrapper.message.PushMessage;
        import component.invoker.manager.push.constant.MessageConstant;
        /**
         * @author wangbowen
         * @description 透传消息模板
         * @Date 2018/5/14
         * @since 1.0.0
         */
        public class TransmissionMessageTemplate implements MessageTemplate {
            public AbstractTemplate createTemplate(PushMessage message) {
                TransmissionTemplate template = new TransmissionTemplate();
                // 透传消息设置，1为强制启动应用，客户端接收到消息后就会立即启动应用；2为等待应用启动
                template.setTransmissionType(MessageConstant.TYPE_WAIT_FOR_CLICK);
                //设置透传消息内容,必须满足以下的格式
                String content = "{title:'"+message.getTitle()+"',content:'"+message.getText()+"',payload:'"+message.getTransmissionContent()+"'}";
                template.setTransmissionContent(content);
                //设置IOS
                APNPayload payload = new  APNPayload();
                payload.setBadge(MessageConstant.TYPE_LAUNCH_APP);
                payload.setContentAvailable(MessageConstant.TYPE_LAUNCH_APP);
                payload.setSound("default");
                payload.setCategory("$由客户端定义");
                payload.setAlertMsg(new APNPayload.SimpleAlertMsg(""));
                //字典模式使用
                // payload.setAlertMsg(getDictionaryAlertMsg());
                template.setAPNInfo(payload);
                return template;
            }
            private static APNPayload.DictionaryAlertMsg getDictionaryAlertMsg(){
                APNPayload.DictionaryAlertMsg alertMsg = new APNPayload.DictionaryAlertMsg();
                alertMsg.setBody("body");
                alertMsg.setActionLocKey("ActionLockey");
                alertMsg.setLocKey("LocKey");
                alertMsg.addLocArg("loc-args");
                alertMsg.setLaunchImage("launch-image");
                // IOS8.2以上版本支持
                alertMsg.setTitle("Title");
                alertMsg.setTitleLocKey("TitleLocKey");
                alertMsg.addTitleLocArg("TitleLocArg");
                return alertMsg;
            }
        
        }
    
      
    
    
        package component.invoker.manager.push.template;
        
        import com.gexin.rp.sdk.template.AbstractTemplate;
        import com.gexin.rp.sdk.template.LinkTemplate;
        import component.invoker.domain.wrapper.message.PushMessage;
        import component.invoker.manager.push.constant.MessageConstant;
        /**
         * @author wangbowen
         * @description 点击通知打开网页模板
         * @Date 2018/5/14
         * @since 1.0.0
         */
        public class LinkMessageTemplate implements MessageTemplate {
            public AbstractTemplate createTemplate(PushMessage message) {
                LinkTemplate template = new LinkTemplate();
                // 设置通知栏标题与内容
                template.setText(message.getTitle());
                template.setText(message.getText());
                // 配置通知栏图标
                template.setLogo(MessageConstant.logo);
                // 配置通知栏网络图标
                template.setLogoUrl(MessageConstant.logoUrl);
                // 设置通知是否响铃，震动，或者可清除
                template.setIsRing(true);
                template.setIsVibrate(true);
                template.setIsClearable(true);
                // 设置打开的网址地址
                template.setUrl(message.getUrl());
                return template;
            }
        }
    
    6.个推配置项
    
        package component.invoker.manager.push.config;
        
        import org.springframework.boot.context.properties.ConfigurationProperties;
        
        /**
         * @author wangbowen
         * @description 个推配置
         * @Date 2018/5/14
         * @since 1.0.0
         */
        @ConfigurationProperties("invoker.gexin")
        public class MessageProperties {
            /**
             *由IGetui管理页面生成，是您的应用与SDK通信的标识之一，每个应用都对应一个唯一的AppID
             */
            private String appId="GQAR1d7BMA6fkk18p76BeA";
        
            /**
             *预先分配的第三方应用对应的Key，是您的应用与SDK通信的标识之一
             */
            private String appKey="Y2anGfezbu5xYe1EPakcY4";
            /**
             * 个推服务端API鉴权码，用于验证调用方合法性。在调用个推服务端API时需要提供
             */
            private String masterSecret="iko2xXLGnf9j6EGCCZWqb8";
        
            /**
             * 应用地址 ：http://sdk.open.api.igexin.com/apiex.htm
             */
            private String  host ="http://sdk.open.api.igexin.com/apiex.htm";
        
            public String getAppId() {
                return appId;
            }
        
            public void setAppId(String appId) {
                this.appId = appId;
            }
        
            public String getAppKey() {
                return appKey;
            }
        
            public void setAppKey(String appKey) {
                this.appKey = appKey;
            }
        
            public String getMasterSecret() {
                return masterSecret;
            }
        
            public void setMasterSecret(String masterSecret) {
                this.masterSecret = masterSecret;
            }
        
            public String getHost() {
                return host;
            }
        
            public void setHost(String host) {
                this.host = host;
            }
        }
    
    7.接口常量类
    
        package component.invoker.manager.push.constant;
        
        /**
         * @author wangbowen
         * @description 个推消息常量
         * @Date 2018/5/14
         * @since 1.0.0
         */
        public interface MessageConstant {
             String logo="";
             String logoUrl="icon.png";
             Integer offlineExpireTime =Integer.MAX_VALUE * 1000 * 3600;
             //透传消息设置，1为强制启动应用，客户端接收到消息后就会立即启动应用；2为等待应用启动
              int TYPE_LAUNCH_APP = 1;
              int TYPE_WAIT_FOR_CLICK = 2;
        }
    
    8.消息传输对象
    
        package component.invoker.manager.push.domain;
        
        import java.util.List;
        
        /**
         * @author wangbowen
         * @description 个推消息实体类
         * @Date 2018/5/14
         * @since 1.0.0
         */
        public class MessageEntity {
            /**
             * 消息标题
             */
            private String  title;
        
            /**
             * 消息内容
             */
            private String  text;
            /**
             * 透传消息
             */
            private String transmissionContent;
        
            /**
             * 消息链接
             */
            private  String  url;
            /**
             * 消息目标对象
             */
            private List<String> clientIds;
        
            public String getTitle() {
                return title;
            }
        
            public void setTitle(String title) {
                this.title = title;
            }
        
            public String getText() {
                return text;
            }
        
            public void setText(String text) {
                this.text = text;
            }
        
            public String getTransmissionContent() {
                return transmissionContent;
            }
        
            public void setTransmissionContent(String transmissionContent) {
                this.transmissionContent = transmissionContent;
            }
        
            public String getUrl() {
                return url;
            }
        
            public void setUrl(String url) {
                this.url = url;
            }
        
            public List<String> getClientIds() {
                return clientIds;
            }
        
            public void setClientIds(List<String> clientIds) {
                this.clientIds = clientIds;
            }
        }