uniapp使用unipush推送及java后台推送代码(含本地打包apk使用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.common.ApiResult;
import com.getui.push.v2.sdk.dto.req.Audience;
import com.getui.push.v2.sdk.dto.req.AudienceDTO;
import com.getui.push.v2.sdk.dto.req.Condition;
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.TaskIdDTO;
import com.google.gson.JsonObject;
import com.jshx.update.bean.PushReqBean;
import com.jshx.update.bean.ResultBean;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.util.*;

@Component
public class PushUtil {

    @Resource(name = "myApiHelper")
    private ApiHelper myApiHelper;


    /**
     * 群推透传消息
     * @param bean 推送信息
     * @return 结果
     */
    public ResultBean pushMessageToAll(PushReqBean bean){
        ResultBean rb=new ResultBean();
        PushDTO<String> pushDTO = new PushDTO<String>();
        pushDTO.setRequestId(System.currentTimeMillis() + "");
        pushDTO.setAudience("all");
        PushMessage pushMessage = new PushMessage();
        JsonObject jsonObject=new JsonObject();
        jsonObject.addProperty("title",bean.getTitle());
        jsonObject.addProperty("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 ResultBean pushMessageToCid(PushReqBean bean){
        boolean isMany=bean.getUser().contains(",");
        if (isMany){
            return pushMessageToManyCid(bean);
        }else {
            return pushMessageToSingleCid(bean);
        }
    }

    /**
     * 根据别名推送消息(含批量)
     * @param bean 推送信息
     * @return 结果
     */
    public ResultBean pushMessageToAlias(PushReqBean bean){
        boolean isMany=bean.getUser().contains(",");
        if (isMany){
            return pushMessageToManyAlias(bean);
        }else {
            return pushMessageToSingleAlias(bean);
        }
    }

    //根据cid单推消息
    private ResultBean pushMessageToSingleCid(PushReqBean bean){
        ResultBean rb=new ResultBean();
        PushDTO<Audience> pushDTO = new PushDTO<Audience>();
        pushDTO.setRequestId(System.currentTimeMillis() + "");
        PushMessage pushMessage = new PushMessage();
        JsonObject jsonObject=new JsonObject();
        jsonObject.addProperty("title",bean.getTitle());
        jsonObject.addProperty("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 ResultBean pushMessageToManyCid(PushReqBean bean){
        ResultBean rb = new ResultBean();
        PushDTO pushDTO=new PushDTO();
        PushMessage pushMessage = new PushMessage();
        JsonObject jsonObject=new JsonObject();
        jsonObject.addProperty("title",bean.getTitle());
        jsonObject.addProperty("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 ResultBean pushMessageToSingleAlias(PushReqBean bean){
        ResultBean rb=new ResultBean();
        PushDTO<Audience> pushDTO = new PushDTO<Audience>();
        pushDTO.setRequestId(System.currentTimeMillis() + "");
        PushMessage pushMessage = new PushMessage();
        JsonObject jsonObject=new JsonObject();
        jsonObject.addProperty("title",bean.getTitle());
        jsonObject.addProperty("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 ResultBean pushMessageToManyAlias(PushReqBean bean){
        ResultBean rb = new ResultBean();
        PushDTO pushDTO=new PushDTO();
        PushMessage pushMessage = new PushMessage();
        JsonObject jsonObject=new JsonObject();
        jsonObject.addProperty("title",bean.getTitle());
        jsonObject.addProperty("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 ResultBean pushMessageToTag(PushReqBean bean){
        ResultBean rb=new ResultBean();
        PushDTO<Audience> pushDTO = new PushDTO<Audience>();
        pushDTO.setRequestId(System.currentTimeMillis() + "");
        PushMessage pushMessage = new PushMessage();
        JsonObject jsonObject=new JsonObject();
        jsonObject.addProperty("title",bean.getTitle());
        jsonObject.addProperty("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 ResultBean pushNoticeToAll(PushReqBean bean){
        ResultBean rb=new ResultBean();
        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 ResultBean pushNoticeToCid(PushReqBean bean){
        boolean isMany=bean.getUser().contains(",");
        if (isMany){
            return pushNoticeToManyCid(bean);
        }else {
            return pushNoticeToSingleCid(bean);
        }
    }

    /**
     * 根据别名推送通知(含批量)
     * @param bean 推送信息
     * @return 结果
     */
    public ResultBean pushNoticeToAlias(PushReqBean bean){
        boolean isMany=bean.getUser().contains(",");
        if (isMany){
            return pushNoticeToManyAlias(bean);
        }else {
            return pushNoticeToSingleAlias(bean);
        }
    }

    //根据cid单推通知
    private ResultBean pushNoticeToSingleCid(PushReqBean bean){
        ResultBean rb=new ResultBean();
        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 ResultBean pushNoticeToManyCid(PushReqBean bean) {
        ResultBean rb = new ResultBean();
        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 ResultBean pushNoticeToSingleAlias(PushReqBean bean){
        ResultBean rb=new ResultBean();
        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 ResultBean pushNoticeToManyAlias(PushReqBean bean) {
        ResultBean rb = new ResultBean();
        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 ResultBean pushNoticeToTag(PushReqBean bean){
        ResultBean rb=new ResultBean();
        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 为apk（如果用到，请往下看）

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

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

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

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