uniapp使用unipush推送及java后台推送代码(含本地打包apk使用unipush推送)_unipush使用后端

你懂的，又是项目用到了，作为程序猿义无反顾需要定时 “进化” ，硬头皮去写，虽然曾经作为android开发者写了很多的推送，但是uniapp的推送也是有所差异的，记录一下，以后留用。

首先uniapp的推送uniPush 是 DCloud 联合个推公司推出的集成型统一推送服务，也就是你不用挑了，就个推了。

其次unipush分1.0版本和2.0版本，这点非常重要，完全不同的概念，不要认为只是简单的升级版。

1.0版本：是传统的推送方式，客户端与服务器端均需要集成个推的服务，由服务器向个推服务器发请求来操作相关推送功能。

2.0版本：就没有你的服务器的事了，相当于是云操作的概念，也就是uniCloud云端一体，也肯定也是uniapp云端技术的必然趋势，功能也很强大，还自带web控制台，既然少了服务器的事，自然流程就简单了。

所以务必根据你的业务需求合理选择版本，本人也是第一次写，想着感受下新版本，结果快写完了，意识到不对劲了，2.0不适合我这次的项目需求，果然换回1.0版本。所以本文仍是介绍1.0版本的使用，以及如果你的uniapp基于本地打包成app,又是如何调整使用。

先说正常情况下(非打包apk)的unipush 1.0的使用

一、开通unipush推送服务

当你新建了uniapp项目之后，选择 manifest.json 中的App模块配置，然后勾选 Push(消息推送)以及对应的版本，这里是unipush 1.0

 然后点击配置，进入到Dcloud开发者中心

这里我不介绍ios相关的，所以可以把选择平台中的IOS取消勾选。这里可以看到需要填写包名及签名。

关于打包，如果你是使用云打包

你也就看到你的包名其实就是uni.你的AppID，就是上方圈出的东西，把它填入到包名那一栏，记得打包时勾选使用Dcloud老版证书。这样一来，你再看下开发者中心签名那一栏的介绍，上面是不是说，如果你使用云打包，并且使用老版证书，签名填什么，它已经告诉你了，复制那段签名填入到签名那栏即可。

最后点击开通应用，开通成功会有弹窗提示。

 二、推送相关知识

写推送，你必须先要了解推送。像传统推送或者说这种实时传递少量信息(即时通讯)，无非是：

1. 轮询方式，也就是定时进行http请求来查询有没有消息要传过来啊，这方式是最笨的方式。

2. 短信，壕 ，请随意

3. 长连接 ，虽然长连接到现在也成熟，但对于手机而言嘛，这种性能消耗还是巨大的。毕竟也不是聊天或者直播。

还好，市面上成熟的第三方推送也早就出现了，例如：极光推送，阿里云推送，个推等，这里不作扩展哈，只是提下。因为有很多人一直从事后台或者非手机端的网页技术开发，对手机推送并不了解，甚至不知道推送是啥。

如图，就是你时而喜欢时而厌烦的手机状态栏的各种弹窗，可以是广告，可以是更新通知，可以是某信消息，也可以是短信等等。而推送并不是仅仅指弹窗，这个弹窗是android自带的功能，也就是notification(通知), 你可以不借助任何推送技术，就可以让自己手机弹出这类弹窗，甚至带上各种图标，音效，震动等。而推送是为了实时传递数据给手机，让手机知道我要开始弹弹窗了，弹窗上显示的内容是什么，或者点击这个弹窗要干嘛，听懂掌声！

其次简说下推送原理，技术架构，我直接拿unipush原图，我画画也不行

说白了，就是你的手机先与unipush服务器(推送服务器)建立连接，这个基本上是通过一个唯一的识别标识建立的，在这里也就是所谓的clientId(cid)。然后你的java服务器集成过推送服务后，就可以通过发请求调用推送服务器的api告诉它，我要给cid是xx的手机推送一条xxx消息，推送服务器就可以通过cid给该台手机推送数据了。

你也看到了，我说的都是手机，设备，而不是说某个人，某个账号。因为账号往往都是咱们自己的服务器的一套账号系统。所以你想要更丰富的推送方式，或者与自己的账号系统关联(也可以直接拿cid设备标识传给自己服务器绑定)，那就需要与cid相关的一套其他推送方式了，也就衍生出了别名(alias)，标签(tag)。有的第三方推送还有更丰富的方式，但大同小异，一般都具有别名，标签这类的方式。

别名(alias) ，一般用于与自己的账号关联。可以是用户的账号，昵称，邮箱，手机号均可，看你自己的需求了。

标签(tag)，一般用于自己账号系统的分组，比如给某一类用户集体推送，或者某一分组下的用户集体推送等。

最后，你还要明白，推送一般分为两种，一种叫通知，一种叫消息(unipush这里叫透传消息)。这俩的区别在于，一个只是为了起到提醒的作用，一个是为了传递数据或者自定义业务逻辑、样式等。

通知就比较简单，粗暴，一般就传个标题，内容即可，然后自动显示在手机上，比如用于提醒用户需要更新软件了，您有新消息，新回复等。 

透传消息， 一般你可以自定义数据格式，但json用的居多，其次，你的手机收到透传消息后，不会像通知一样自动弹窗，而是什么反应都没有，只是接收到了数据，你需要根据业务自己弹出弹窗，或者进行后续操作。

个推的流程与其他第三方推送有些许不一样，你需要在app一运行就要获取到cid,然后Java后台写一个接口，app把cid传递给后台服务器，后台服务器来进行cid与别名，标签进行绑定。当用户退出登录后，记得要解绑，否则如果有账号多台设备登录，会有推送错乱的情况。

好了，到这基本上了解这些也就足够了。继续搞代码！

三、uniapp获取clientId与unipush建立联系

我们首先应在App第一次运行的时候，获取clientId，代码如下

getClient: (callback) => {
		// #ifdef APP-PLUS
		let clientInfo = plus.push.getClientInfo();  //获取 clientID
		uni.setStorageSync('clientid', clientInfo.clientid) //缓存到本地
		console.log(clientInfo);
		// #endif
 
}

四、监听收到推送时的处理

我们除了需要获取到cid之外，还需要配置好如何处理收到的推送消息，这里有的代码是借鉴别人的(具体谁的真不清楚了。。。)，加自己的微调整。然后为了方便整体放到到了一个js文件中 unipush.js

export default {
	init: () => {
		// #ifdef APP-PLUS
		plus.push.setAutoNotification(true);  //设置通知栏显示通知 //必须设置
		plus.push.addEventListener("click", function(msg) {
			plus.push.clear(); //清空通知栏
			pushHandle(msg) //处理方法
		}, false);
		// 监听在线消息事件    
		plus.push.addEventListener("receive", function(msg) {			
			console.log("receive:"+JSON.stringify(msg));
			if (plus.os.name=='iOS') {  //由于IOS 必须要创建本地消息 所以做这个判断
				if (msg.payload&& msg.payload!=null&&msg.type=='receive') {
					console.log(msg);
					// {"title": "xxx","content": "xxx","payload": "xxx"} 符合这种 才会自动创建消息  文档地址https://ask.dcloud.net.cn/article/35622
					plus.push.createMessage(msg.title,msg.content,JSON.stringify(msg.payload))  //创建本地消息
				}
			}
			if (plus.os.name=='Android') {
				let options={
					cover:false,
					sound:"system",
					title:msg.title
				}
				plus.push.createMessage(msg.content,msg.payload.content,options);
				// if(!msg.title||!msg.content||!msg.payload){ //  不符合自动创建消息的情况
				// 	 //这里根据你消息字段来创建消息 
				// 	 console.log("这里根据你消息字段来创建消息："+msg.title+","+msg.content+","+msg.payload);
				// 	plus.push.createMessage(msg.payload.content,JSON.stringify(msg.payload))  //创建本地消息
				// }else{
				// 	//符合自动创建消息 
				// 	console.log("符合自动创建消息"+msg.title+","+msg.content+","+msg.payload);
				// 	pushHandle(msg)
				// }	
			}
			 	
		}, false);
		// #endif
	},
 
	getClient: (callback) => {
		// #ifdef APP-PLUS
		let clientInfo = plus.push.getClientInfo();  //获取 clientID
		uni.setStorageSync('clientid', clientInfo.clientid)
		console.log(clientInfo);
		// #endif
 
	},
 
}
const pushHandle = (msg) => {
	if (typeof (msg.payload )=='string') {  //如果是字符串，表示是ios创建的  要转换一下
		msg.payload=JSON.parse(msg.payload )
	}
	if(!msg) return false;
	plus.runtime.setBadgeNumber(0); //清除app角标
	
	//下面的代码根据自己业务来写 这里可以写跳转业务代码
	//跳转到tab
	if (msg.payload.pathType == '1') {
		uni.switchTab({
			url: msg.payload.url
		})
	}
	//跳转到详情
	if (msg.payload.pathType == 0) {
		let url = msg.payload.url
		if (msg.payload.args) {
			url = url + '?id=' + msg.payload.args
		}
		console.log(url);
		uni.navigateTo({
			url: url
		})
	}
}

最后在App.vue里加入如下代码即可

<script>
	import push from 'push/unipush.js';
	export default {
		onLaunch: function() {
			console.log('App Launch');
			push.getClient(); 
			push.init();
		},
		onShow: function() {
			console.log('App Show')
		},
		onHide: function() {
			console.log('App Hide')
		}
	}
</script>
 
<style>
	/*每个页面公共css */
</style>

至此，手机端代码已经完成。还算简单。接下来是java服务器端

五、Java服务器端集成推送

获取秘钥等相关信息，来到开发者中心，在消息推送 -> 配置管理 -> 应用配置里有秘钥相关信息 

我的后台是Springboot，所以在application.yml下填写如下配置即可

然后在pom.xml中集成个推的sdk

<dependency>
    <groupId>com.getui.push</groupId>
    <artifactId>restful-sdk</artifactId>
    <version>1.0.0.8</version>
</dependency>

六、创建推送配置类GTPushConfig

import com.getui.push.v2.sdk.ApiHelper;
import com.getui.push.v2.sdk.GtApiConfiguration;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
 
@Configuration
public class GTPushConfig {
 
//    @Value("https://restapi.getui.com/v2")
//    private String baseUrl;
 
    @Value("${uniPush.appId}")
    private String appId;
 
    @Value("${uniPush.appKey}")
    private String appKey;
 
    @Value("${uniPush.masterSecret}")
    private String masterSecret;
 
    @Bean(name = "myApiHelper")
    public ApiHelper apiHelper() {
        GtApiConfiguration apiConfiguration = new GtApiConfiguration();
        //填写应用配置
        apiConfiguration.setAppId(appId);
        apiConfiguration.setAppKey(appKey);
        apiConfiguration.setMasterSecret(masterSecret);
        // 接口调用前缀，请查看文档: 接口调用规范 -> 接口前缀, 可不填写appId
        //默认为https://restapi.getui.com/v2
        //apiConfiguration.setDomain("https://restapi.getui.com/v2/");
        // 实例化ApiHelper对象，用于创建接口对象
        ApiHelper apiHelper = ApiHelper.build(apiConfiguration);
        return apiHelper;
    }
}

七、封装推送工具类PushUtil及推送消息实体类

推送消息实体类

@Data
public class PushReqBean implements Serializable {
 
    //消息类型  0代表透传消息(使用这个，需要手机自己弹出通知，定义通知样式，content为json串)  1代表是通知(使用这个，标题和内容即手机上显示的通知标题和内容)
    private Integer noticeType;
    //推送用户类型 0 全部用户  1根据cid推送  2根据别名  3根据标签
    private Integer userType;
    //用户标识，可为cid,别名，tag，多个之间逗号隔开
    private String user;
    //推送标题
    private String title;
    //推送内容
    private String content;
 
}

api调用结果封装实体类（可不要）

@Data
public class ResultBean implements Serializable {
 
    public int code;
    public String msg;
    public Object data;
 
}

推送工具类，这个里面，我几乎把所有的功能都融入进去了，比如绑定别名，批量绑定，绑定标签，解绑，根据各种方式推送通知，根据各种方式推送透传消息等。

 
import com.getui.push.v2.sdk.ApiHelper;
import com.getui.push.v2.sdk.api.PushApi;
import com.getui.push.v2.sdk.api.UserApi;
import com.getui.push.v2.sdk.common.ApiResult;
import com.getui.push.v2.sdk.dto.req.*;
import com.getui.push.v2.sdk.dto.req.message.PushDTO;
import com.getui.push.v2.sdk.dto.req.message.PushMessage;
import com.getui.push.v2.sdk.dto.req.message.android.GTNotification;
import com.getui.push.v2.sdk.dto.res.QueryCidResDTO;
import com.getui.push.v2.sdk.dto.res.TaskIdDTO;
import com.google.gson.JsonObject;
import com.njlift.wechat.common.Result;
import com.njlift.wechat.entity.PushReqBean;
import org.springframework.stereotype.Component;
 
import javax.annotation.Resource;
import java.util.*;
 
@Component
public class PushUtil {
 
    @Resource(name = "myApiHelper")
    private ApiHelper myApiHelper;
 
 
    /**
     * 绑定别名
     * @param cid  用户在推送服务器的唯一识别标志
     * @param alias 在自己服务器上的唯一识别标志
     * @return 绑定结果
     */
    public Result bindAlias(String cid,String alias){
        Result rb=new Result();
        CidAliasListDTO cidAliasListDTO=new CidAliasListDTO();
        CidAliasListDTO.CidAlias cidAlias=new CidAliasListDTO.CidAlias();
        cidAlias.setCid(cid);
        cidAlias.setAlias(alias);
        cidAliasListDTO.add(cidAlias);
        UserApi userApi = myApiHelper.creatApi(UserApi.class);
        ApiResult<Void> voidApiResult = userApi.bindAlias(cidAliasListDTO);
        rb.setCode(voidApiResult.getCode());
        rb.setMsg(voidApiResult.getMsg());
        rb.setData(voidApiResult.getData());
        return rb;
    }
 
    /**
     * 批量解绑别名
     * @param aliasList 别名列表
     * @return 解绑结果
     *
     */
    public Result unbindAlias(List<String> aliasList){
        Result rb=new Result();
        List<CidAliasListDTO.CidAlias> list=new ArrayList<>();
        UserApi userApi = myApiHelper.creatApi(UserApi.class);
        for (String alias:aliasList){
            ApiResult<QueryCidResDTO> queryCidResDTOApiResult = userApi.queryCidByAlias(alias);
            if (queryCidResDTOApiResult.isSuccess()){
                List<String> cidList = queryCidResDTOApiResult.getData().getCid();
                for (String cid:cidList){
                    CidAliasListDTO.CidAlias cidAlias=new CidAliasListDTO.CidAlias();
                    cidAlias.setAlias(alias);
                    cidAlias.setCid(cid);
                    list.add(cidAlias);
                }
            }
        }
        CidAliasListDTO cidAliasListDTO=new CidAliasListDTO();
        cidAliasListDTO.setDataList(list);
        ApiResult<Void> voidApiResult = userApi.batchUnbindAlias(cidAliasListDTO);
        rb.setCode(voidApiResult.getCode());
        rb.setMsg(voidApiResult.getMsg());
        rb.setData(voidApiResult.getData());
        return rb;
    }
 
    /**
     * 一个用户根据cid进行绑定tag标签(次数限制)
     * @param cid 用户在推送服务器的唯一识别标志
     * @param tag 标签名
     * @return 绑定结果
     */
    public Result userBindTagsByCid(String cid,String tag){
        Result rb=new Result();
        UserApi userApi = myApiHelper.creatApi(UserApi.class);
        TagDTO dto=new TagDTO();
        dto.addTag(tag);
        ApiResult<Void> voidApiResult = userApi.userBindTags(cid, dto);
        rb.setCode(voidApiResult.getCode());
        rb.setMsg(voidApiResult.getMsg());
        rb.setData(voidApiResult.getData());
        return rb;
    }
 
    /**
     * 一个用户根据别名进行绑定tag标签(次数限制)
     * @param alias 在自己服务器上的唯一识别标志
     * @param tag 标签名
     * @return 绑定结果
     */
    public Result userBindTagsByAlias(String alias,String tag){
        Result rb=new Result();
        rb.setCode(1);
        UserApi userApi = myApiHelper.creatApi(UserApi.class);
        ApiResult<QueryCidResDTO> queryCidResDTOApiResult = userApi.queryCidByAlias(alias);
        if (queryCidResDTOApiResult.isSuccess()){
            List<String> cidList = queryCidResDTOApiResult.getData().getCid();
            if (cidList.size()==1){
                String cid = cidList.get(0);
                TagDTO dto=new TagDTO();
                dto.addTag(tag);
                ApiResult<Void> voidApiResult = userApi.userBindTags(cid, dto);
                rb.setCode(voidApiResult.getCode());
                rb.setMsg(voidApiResult.getMsg());
                rb.setData(voidApiResult.getData());
            }else {
                rb.setMsg("该别名对应多个cid,无法绑定标签");
            }
        }else {
            rb.setMsg(queryCidResDTOApiResult.getMsg());
        }
        return rb;
    }
 
    /**
     * 一批用户绑定tag标签(每分钟100次，每日10000次)
     * @param cidList 用户在推送服务器的唯一识别标志
     * @param tag 标签名
     * @return 绑定结果
     */
    public Result userBindTagsByAlias(List<String> cidList,String tag){
        Result rb=new Result();
        rb.setCode(1);
        UserApi userApi = myApiHelper.creatApi(UserApi.class);
        UserDTO userDTO=new UserDTO();
        Set<String> cidSet=new HashSet<>(cidList);
        userDTO.setCid(cidSet);
        ApiResult<Map<String, String>> mapApiResult = userApi.usersBindTag(tag, userDTO);
        rb.setCode(mapApiResult.getCode());
        rb.setMsg(mapApiResult.getMsg());
        rb.setData(mapApiResult.getData());
        return rb;
    }
 
    /**
     * 批量用户解绑一个标签
     * @param list 用户集合(可cid集合或alias集合)
     * @param type 0表示alias集合，1表示cid集合
     * @param tag 标签
     * @return 解绑结果
     */
    public Result usersUnbindTag(List<String> list,int type,String tag){
        Result rb=new Result();
        rb.setCode(1);
        UserApi userApi = myApiHelper.creatApi(UserApi.class);
        UserDTO userDTO=new UserDTO();
        List<String> cidList=new ArrayList<>();
        if (type==0){
            for (String alias:list){
                ApiResult<QueryCidResDTO> queryCidResDTOApiResult = userApi.queryCidByAlias(alias);
                if (queryCidResDTOApiResult.isSuccess()){
                    cidList.addAll(queryCidResDTOApiResult.getData().getCid());
                }
            }
        }else {
            cidList.addAll(list);
        }
        Set<String> cidSet=new HashSet<>(cidList);
        userDTO.setCid(cidSet);
        ApiResult<Map<String, String>> mapApiResult = userApi.deleteUsersTag(tag, userDTO);
        rb.setCode(mapApiResult.getCode());
        rb.setMsg(mapApiResult.getMsg());
        rb.setData(mapApiResult.getData());
        return rb;
    }
 
 
 
    /**
     * 群推透传消息
     * @param bean 推送信息
     * @return 结果
     */
    public Result pushMessageToAll(PushReqBean bean){
        Result rb=new Result();
        PushDTO<String> pushDTO = new PushDTO<String>();
        pushDTO.setRequestId(System.currentTimeMillis() + "");
        pushDTO.setAudience("all");
        PushMessage pushMessage = new PushMessage();
        JsonObject jsonObject=new JsonObject();
        jsonObject.addProperty("m_title",bean.getTitle());
        jsonObject.addProperty("m_content",bean.getContent());
        pushMessage.setTransmission(jsonObject.toString());
        pushDTO.setPushMessage(pushMessage);
        PushApi pushApi = myApiHelper.creatApi(PushApi.class);
        ApiResult<TaskIdDTO> apiResult = pushApi.pushAll(pushDTO);
        rb.setCode(apiResult.getCode());
        rb.setMsg(apiResult.getMsg());
        rb.setData(apiResult.getData());
        return rb;
    }
 
    /**
     * 根据cid推送消息(含批量)
     * @param bean 推送信息
     * @return 结果
     */
    public Result pushMessageToCid(PushReqBean bean){
        boolean isMany=bean.getUser().contains(",");
        if (isMany){
            return pushMessageToManyCid(bean);
        }else {
            return pushMessageToSingleCid(bean);
        }
    }
 
    /**
     * 根据别名推送消息(含批量)
     * @param bean 推送信息
     * @return 结果
     */
    public Result pushMessageToAlias(PushReqBean bean){
        boolean isMany=bean.getUser().contains(",");
        if (isMany){
            return pushMessageToManyAlias(bean);
        }else {
            return pushMessageToSingleAlias(bean);
        }
    }
 
    //根据cid单推消息
    private Result pushMessageToSingleCid(PushReqBean bean){
        Result rb=new Result();
        PushDTO<Audience> pushDTO = new PushDTO<Audience>();
        pushDTO.setRequestId(System.currentTimeMillis() + "");
        PushMessage pushMessage = new PushMessage();
        JsonObject jsonObject=new JsonObject();
        jsonObject.addProperty("m_title",bean.getTitle());
        jsonObject.addProperty("m_content",bean.getContent());
        pushMessage.setTransmission(jsonObject.toString());
        pushDTO.setPushMessage(pushMessage);
        Audience audience = new Audience();
        audience.addCid(bean.getUser());
        pushDTO.setAudience(audience);
        PushApi pushApi = myApiHelper.creatApi(PushApi.class);
        ApiResult<Map<String, Map<String, String>>> apiResult = pushApi.pushToSingleByCid(pushDTO);
        rb.setCode(apiResult.getCode());
        rb.setMsg(apiResult.getMsg());
        rb.setData(apiResult.getData());
        return rb;
    }
 
    //批量根据cid推送消息
    private Result pushMessageToManyCid(PushReqBean bean){
        Result rb = new Result();
        PushDTO pushDTO=new PushDTO();
        PushMessage pushMessage = new PushMessage();
        JsonObject jsonObject=new JsonObject();
        jsonObject.addProperty("m_title",bean.getTitle());
        jsonObject.addProperty("m_content",bean.getContent());
        pushMessage.setTransmission(jsonObject.toString());
        pushDTO.setPushMessage(pushMessage);
        PushApi pushApi = myApiHelper.creatApi(PushApi.class);
        ApiResult<TaskIdDTO> msg = pushApi.createMsg(pushDTO);
        if (msg.isSuccess()){
            AudienceDTO audienceDTO=new AudienceDTO();
            audienceDTO.setTaskid(msg.getData().getTaskId());
            audienceDTO.setAsync(true);
            List<String> users = Arrays.asList(bean.getUser().split(","));
            Audience audience=new Audience();
            for (String user:users){
                audience.addCid(user);
            }
            audienceDTO.setAudience(audience);
            PushApi pushApi1 = myApiHelper.creatApi(PushApi.class);
            ApiResult<Map<String, Map<String, String>>> mapApiResult = pushApi1.pushListByCid(audienceDTO);
            rb.setCode(mapApiResult.getCode());
            rb.setMsg(mapApiResult.getMsg());
            rb.setData(mapApiResult.getData());
        }else {
            rb.setCode(msg.getCode());
            rb.setMsg(msg.getMsg());
            rb.setData(msg.getData());
        }
        return rb;
    }
 
    //根据别名单推消息
    private Result pushMessageToSingleAlias(PushReqBean bean){
        Result rb=new Result();
        PushDTO<Audience> pushDTO = new PushDTO<Audience>();
        pushDTO.setRequestId(System.currentTimeMillis() + "");
        PushMessage pushMessage = new PushMessage();
        JsonObject jsonObject=new JsonObject();
        jsonObject.addProperty("m_title",bean.getTitle());
        jsonObject.addProperty("m_content",bean.getContent());
        pushMessage.setTransmission(jsonObject.toString());
        pushDTO.setPushMessage(pushMessage);
        Audience audience = new Audience();
        audience.addAlias(bean.getUser());
        pushDTO.setAudience(audience);
        PushApi pushApi = myApiHelper.creatApi(PushApi.class);
        ApiResult<Map<String, Map<String, String>>> apiResult = pushApi.pushToSingleByAlias(pushDTO);
        rb.setCode(apiResult.getCode());
        rb.setMsg(apiResult.getMsg());
        rb.setData(apiResult.getData());
        return rb;
    }
 
    //批量根据别名推送消息
    private Result pushMessageToManyAlias(PushReqBean bean){
        Result rb = new Result();
        PushDTO pushDTO=new PushDTO();
        PushMessage pushMessage = new PushMessage();
        JsonObject jsonObject=new JsonObject();
        jsonObject.addProperty("m_title",bean.getTitle());
        jsonObject.addProperty("m_content",bean.getContent());
        pushMessage.setTransmission(jsonObject.toString());
        pushDTO.setPushMessage(pushMessage);
        PushApi pushApi = myApiHelper.creatApi(PushApi.class);
        ApiResult<TaskIdDTO> msg = pushApi.createMsg(pushDTO);
        if (msg.isSuccess()){
            AudienceDTO audienceDTO=new AudienceDTO();
            audienceDTO.setTaskid(msg.getData().getTaskId());
            audienceDTO.setAsync(true);
            List<String> users = Arrays.asList(bean.getUser().split(","));
            Audience audience=new Audience();
            for (String user:users){
                audience.addAlias(user);
            }
            audienceDTO.setAudience(audience);
            PushApi pushApi1 = myApiHelper.creatApi(PushApi.class);
            ApiResult<Map<String, Map<String, String>>> mapApiResult = pushApi1.pushListByAlias(audienceDTO);
            rb.setCode(mapApiResult.getCode());
            rb.setMsg(mapApiResult.getMsg());
            rb.setData(mapApiResult.getData());
        }else {
            rb.setCode(msg.getCode());
            rb.setMsg(msg.getMsg());
            rb.setData(msg.getData());
        }
        return rb;
    }
 
    //根据标签推送消息
    public Result pushMessageToTag(PushReqBean bean){
        Result rb=new Result();
        PushDTO<Audience> pushDTO = new PushDTO<Audience>();
        pushDTO.setRequestId(System.currentTimeMillis() + "");
        PushMessage pushMessage = new PushMessage();
        JsonObject jsonObject=new JsonObject();
        jsonObject.addProperty("m_title",bean.getTitle());
        jsonObject.addProperty("m_content",bean.getContent());
        pushMessage.setTransmission(jsonObject.toString());
        pushDTO.setPushMessage(pushMessage);
        Audience audience = new Audience();
        Condition condition=new Condition();
        condition.setKey("custom_tag");
        List<String> tags=new ArrayList<>();
        if (bean.getUser().contains(",")){
            tags.addAll(Arrays.asList(bean.getUser().split(",")));
        }else {
            tags.add(bean.getUser());
        }
        Set<String> sets=new HashSet<>();
        for (String tag:tags){
            sets.add(tag);
        }
        condition.setValues(sets);
        condition.setOptType("and");
        audience.addCondition(condition);
        pushDTO.setAudience(audience);
        PushApi pushApi = myApiHelper.creatApi(PushApi.class);
        ApiResult<TaskIdDTO> apiResult = pushApi.pushByTag(pushDTO);
        rb.setCode(apiResult.getCode());
        rb.setMsg(apiResult.getMsg());
        rb.setData(apiResult.getData());
        return rb;
    }
 
 
    /**
     * 群推通知
     * @param bean 推送信息
     * @return 结果
     */
    public Result pushNoticeToAll(PushReqBean bean){
        Result rb=new Result();
        PushDTO<String> pushDTO = new PushDTO<String>();
        pushDTO.setRequestId(System.currentTimeMillis() + "");
        pushDTO.setAudience("all");
        PushMessage pushMessage = new PushMessage();
        GTNotification notification = new GTNotification();
        notification.setTitle(bean.getTitle());
        notification.setBody(bean.getContent());
        notification.setClickType("none");
        pushMessage.setNotification(notification);
        pushDTO.setPushMessage(pushMessage);
        PushApi pushApi = myApiHelper.creatApi(PushApi.class);
        ApiResult<TaskIdDTO> apiResult = pushApi.pushAll(pushDTO);
        rb.setCode(apiResult.getCode());
        rb.setMsg(apiResult.getMsg());
        rb.setData(apiResult.getData());
        return rb;
    }
 
    /**
     * 根据cid推送通知(含批量)
     * @param bean 推送信息
     * @return 结果
     */
    public Result pushNoticeToCid(PushReqBean bean){
        boolean isMany=bean.getUser().contains(",");
        if (isMany){
            return pushNoticeToManyCid(bean);
        }else {
            return pushNoticeToSingleCid(bean);
        }
    }
 
    /**
     * 根据别名推送通知(含批量)
     * @param bean 推送信息
     * @return 结果
     */
    public Result pushNoticeToAlias(PushReqBean bean){
        boolean isMany=bean.getUser().contains(",");
        if (isMany){
            return pushNoticeToManyAlias(bean);
        }else {
            return pushNoticeToSingleAlias(bean);
        }
    }
 
    //根据cid单推通知
    private Result pushNoticeToSingleCid(PushReqBean bean){
        Result rb=new Result();
        PushDTO<Audience> pushDTO = new PushDTO<Audience>();
        pushDTO.setRequestId(System.currentTimeMillis() + "");
        PushMessage pushMessage = new PushMessage();
        GTNotification notification = new GTNotification();
        notification.setTitle(bean.getTitle());
        notification.setBody(bean.getContent());
        notification.setClickType("none");
        pushMessage.setNotification(notification);
        pushDTO.setPushMessage(pushMessage);
        Audience audience = new Audience();
        audience.addCid(bean.getUser());
        pushDTO.setAudience(audience);
        PushApi pushApi = myApiHelper.creatApi(PushApi.class);
        ApiResult<Map<String, Map<String, String>>> apiResult = pushApi.pushToSingleByCid(pushDTO);
        rb.setCode(apiResult.getCode());
        rb.setMsg(apiResult.getMsg());
        rb.setData(apiResult.getData());
        return rb;
    }
 
    //批量根据cid推送通知
    private Result pushNoticeToManyCid(PushReqBean bean) {
        Result rb = new Result();
        PushDTO pushDTO=new PushDTO();
        PushMessage pushMessage = new PushMessage();
        GTNotification notification = new GTNotification();
        notification.setTitle(bean.getTitle());
        notification.setBody(bean.getContent());
        notification.setClickType("none");
        pushMessage.setNotification(notification);
        pushDTO.setPushMessage(pushMessage);
        PushApi pushApi = myApiHelper.creatApi(PushApi.class);
        ApiResult<TaskIdDTO> msg = pushApi.createMsg(pushDTO);
        if (msg.isSuccess()){
            AudienceDTO audienceDTO=new AudienceDTO();
            audienceDTO.setTaskid(msg.getData().getTaskId());
            audienceDTO.setAsync(true);
            List<String> users = Arrays.asList(bean.getUser().split(","));
            Audience audience=new Audience();
            for (String user:users){
                audience.addCid(user);
            }
            audienceDTO.setAudience(audience);
            PushApi pushApi1 = myApiHelper.creatApi(PushApi.class);
            ApiResult<Map<String, Map<String, String>>> mapApiResult = pushApi1.pushListByCid(audienceDTO);
            rb.setCode(mapApiResult.getCode());
            rb.setMsg(mapApiResult.getMsg());
            rb.setData(mapApiResult.getData());
        }else {
            rb.setCode(msg.getCode());
            rb.setMsg(msg.getMsg());
            rb.setData(msg.getData());
        }
        return rb;
    }
 
    //根据别名单推通知
    private Result pushNoticeToSingleAlias(PushReqBean bean){
        Result rb=new Result();
        PushDTO<Audience> pushDTO = new PushDTO<Audience>();
        pushDTO.setRequestId(System.currentTimeMillis() + "");
        PushMessage pushMessage = new PushMessage();
        GTNotification notification = new GTNotification();
        notification.setTitle(bean.getTitle());
        notification.setBody(bean.getContent());
        notification.setClickType("none");
        pushMessage.setNotification(notification);
        pushDTO.setPushMessage(pushMessage);
        Audience audience = new Audience();
        audience.addAlias(bean.getUser());
        pushDTO.setAudience(audience);
        PushApi pushApi = myApiHelper.creatApi(PushApi.class);
        ApiResult<Map<String, Map<String, String>>> apiResult = pushApi.pushToSingleByAlias(pushDTO);
        rb.setCode(apiResult.getCode());
        rb.setMsg(apiResult.getMsg());
        rb.setData(apiResult.getData());
        return rb;
    }
 
    //批量根据别名推送通知
    private Result pushNoticeToManyAlias(PushReqBean bean) {
        Result rb = new Result();
        PushDTO pushDTO=new PushDTO();
        PushMessage pushMessage = new PushMessage();
        GTNotification notification = new GTNotification();
        notification.setTitle(bean.getTitle());
        notification.setBody(bean.getContent());
        notification.setClickType("none");
        pushMessage.setNotification(notification);
        pushDTO.setPushMessage(pushMessage);
        PushApi pushApi = myApiHelper.creatApi(PushApi.class);
        ApiResult<TaskIdDTO> msg = pushApi.createMsg(pushDTO);
        if (msg.isSuccess()){
            AudienceDTO audienceDTO=new AudienceDTO();
            audienceDTO.setTaskid(msg.getData().getTaskId());
            audienceDTO.setAsync(true);
            List<String> users = Arrays.asList(bean.getUser().split(","));
            Audience audience=new Audience();
            for (String user:users){
                audience.addAlias(user);
            }
            audienceDTO.setAudience(audience);
            PushApi pushApi1 = myApiHelper.creatApi(PushApi.class);
            ApiResult<Map<String, Map<String, String>>> mapApiResult = pushApi1.pushListByAlias(audienceDTO);
            rb.setCode(mapApiResult.getCode());
            rb.setMsg(mapApiResult.getMsg());
            rb.setData(mapApiResult.getData());
        }else {
            rb.setCode(msg.getCode());
            rb.setMsg(msg.getMsg());
            rb.setData(msg.getData());
        }
        return rb;
    }
 
    //根据标签推送通知
    public Result pushNoticeToTag(PushReqBean bean){
        Result rb=new Result();
        PushDTO<Audience> pushDTO = new PushDTO<Audience>();
        pushDTO.setRequestId(System.currentTimeMillis() + "");
        PushMessage pushMessage = new PushMessage();
        GTNotification notification = new GTNotification();
        notification.setTitle(bean.getTitle());
        notification.setBody(bean.getContent());
        notification.setClickType("none");
        pushMessage.setNotification(notification);
        pushDTO.setPushMessage(pushMessage);
        Audience audience = new Audience();
        Condition condition=new Condition();
        condition.setKey("custom_tag");
        List<String> tags=new ArrayList<>();
        if (bean.getUser().contains(",")){
            tags.addAll(Arrays.asList(bean.getUser().split(",")));
        }else {
            tags.add(bean.getUser());
        }
        Set<String> sets=new HashSet<>();
        for (String tag:tags){
            sets.add(tag);
        }
        condition.setValues(sets);
        condition.setOptType("and");
        audience.addCondition(condition);
        pushDTO.setAudience(audience);
        PushApi pushApi = myApiHelper.creatApi(PushApi.class);
        ApiResult<TaskIdDTO> apiResult = pushApi.pushByTag(pushDTO);
        rb.setCode(apiResult.getCode());
        rb.setMsg(apiResult.getMsg());
        rb.setData(apiResult.getData());
        return rb;
    }
 
 
}

其实工具类里的内容大致也能猜出含义，具体可以看个推服务器文档    推送API-个推文档中心

其实也就是构建参数，请求，然后请求个推服务器进行操作而已。

八、打包测试

如果你想在模拟器或者手机上直接运行是没有效果的，因为uniapp运行分为标准基座和自定义基座。

简述就是标准基座就是用于简单的调试的，在原生层不变的情况下，可以动态加载新代码，热重载运行。但如果你修改了原生层，就需要打包了，打成android的apk或者ios的ipa包。这样一来，你连日志什么的都不好监控了，对于调试开发阶段会很麻烦，所以有了自定义基座。

点击运行 ->  运行到手机或模拟器 -> 制作自定义调试基座即可

 

官方说的也很明白，有了自定义基座，这些第三方sdk配置也就生效了，而且只需要打包一次就行，除非你又修改了配置。

制作比较简单，我这里建议使用自有证书，这样没啥限制，生成证书在博客最底下的文章里有，就是那个jks文件，有的人是其他格式的，无所谓，是安卓证书就行。然后选择打自定义调试基座，传统打包，然后确定等待打包就行。

 再点击运行，选择运行自定义基座就可以直接运行在模拟器或者电脑连的真机，进行推送联调看效果了

九、本地打包uniapp 为apk（如果用到，请往下看）

如果使用本地android studio打包apk这种方式，你除了需要上面的操作外，还需要导入jar/aar包。关于如何使用本地打包uniapp这个在之前的博客中已经讲解了，这里就不多说了。

在之前下载的项目工程里的SDK文件夹里有对应的jar/aar包

按需要摘取，不是全放进去哈，我是放了这些

 

 然后在项目的build.gradle下(不是最外面的build.gradle),在android下添加manifestPlaceholders代码如下，总共四个值，你的uniapp 的appid，然后就是unipush的配置，最后是你的android工程的包名，那个applicationId就是包名，你要填的要与applicationId保持一致

 最后最后，记得去开发者中心修改你的包名和签名

填写你android studio里的包名，以及你打包apk证书的sha1值，这个也是之前打包的那个博客里讲解过，这里不赘述了，至此，已经全部结束。

打包博客地址：  Hbuilderx uniapp本地打包android 项目_我靠_叫我大当家的的博客-CSDN博客_hbuilder开发安卓app

额外话

最后还有需要注意的地方是，某米手机会把推送隐藏在不重要的通知里(并非没收到通知消息)，想要解决这个问题，需要的到某米开发平台去申请Channel，来调整消息的级别，设为重要级别就可以了。这个有时间我再更新到这里吧。先自己看这个文档吧：文档中心

本人个人原创，如有雷同，纯属巧合，或者与本人联系，做改动。请转载或者CV组合标明出处，谢谢！（如有疑问或错误欢迎指出，本人QQ:752231513）