DingTalk钉钉机器人单聊互动卡片消息的一次实现(附仓库)

已于 2023-07-18 15:55:05 修改
阅读量1.1w 收藏 19
点赞数 9
分类专栏： java 文章标签： java 交互
于 2022-03-31 18:16:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43558927/article/details/123878824
版权

DingTalk钉钉机器人单聊互动卡片消息的一次实现

文章目录

仓库

前言

互动卡片支持自定义按钮, 并在按钮上绑定回调事件, 点击按钮时将通过提前注册的回调URL, 携带卡片数据及配置的自定义按钮参数调用回调URL, 开发者拿到请求后完成业务处理, 并通过更新互动卡片接口将此前发送的卡片数据更新. 按钮的状态, 显示与否均可动态配置.

模块最主要就是对调用SDK接口需要的杂乱无序的参数做抽象和做最常用的封装, 尽可能简化调用.

需求

网站需要在用户注册后发送钉钉消息给客户经理, 同时客户经理操作按钮功能为新用户开通体验服务, 钉钉机器人发互动卡片消息即可满足.

问题

网上群发,单聊的普通消息的实现都有,但也没有说的很清晰的, 群发的互动卡片也是, 但单聊的互动卡片在实现的时候没查到有人写, 钉钉文档关于机器人部分也是一句话带过.

一、前置要求

1.1 配置互动卡片

钉钉开放平台-开放能力-卡片平台 旧版的平台已经迁移到上述平台

这里没有太多可说的, 基本上就是自己建模版, 提示的教程也很简单, 回调的请求上可以携带自定义的参数, 其他不重要不在此过多赘述

1.2 引入项目依赖

分别为旧新版SDK都要引入, 新版SDK在持续迭代中

<!--new-->
<dependency>
	<groupId>com.aliyun</groupId>
	<artifactId>dingtalk</artifactId>
	<version>1.5.58</version>
</dependency>
<!--old-->
<dependency>
	<groupId>com.aliyun</groupId>
	<artifactId>alibaba-dingtalk-service-sdk</artifactId>
	<version>2.0.0</version>
</dependency>

二、代码实现

至于抽象设计, 纯用SDK调接口写硬编码当然可以, 但写久了就像有蚂蚁在身上爬, 能抽象还是尽量抽象

1.1 钉钉应用抽象

package com.hp.dingding.component.application;

import com.hp.dingding.component.factory.app.DingAppFactory;
import org.springframework.beans.factory.SmartInitializingSingleton;

/**
 * 钉钉应用
 * 整个项目基于Spring容器能力，所以最好将APP实现注册到IoC容器中
 * @author hp
 */
public interface IDingApp extends SmartInitializingSingleton {

    String getAppName();

    String getAppKey();

    String getAppSecret();

    Long getAppId();

    @Override
    default void afterSingletonsInstantiated() {
        DingAppFactory.setAppCache(this);
    }
}

1.2 卡片回调接口抽象

07-08-22: 钉钉实现了新的注册回调地址的方式, 这里还是历史方式主动调用接口注册, 也能用

package com.hp.dingding.pojo.message.interactive.callback;

import com.hp.dingding.component.application.IDingBot;
import org.springframework.beans.factory.SmartInitializingSingleton;

import java.util.List;

/**
 * 互动卡片回调地址
 * @author hp
 */
public interface IDingInteractiveCardCallBack extends SmartInitializingSingleton {
    String getCallbackUrl();
    String getCallbackRouteKey();
    List<Class<? extends IDingBot>> getDingBots();
}

package com.hp.dingding.pojo.message.interactive.callback;

import com.hp.dingding.component.application.IDingBot;
import lombok.Getter;

import java.util.List;

/**
 * @author hp 2023/3/17
 */
@Getter
public abstract class AbstractDingInteractiveCardCallback implements IDingInteractiveCardCallBack {
    private final String callbackRouteKey;
    private final String callbackUrl;
    private final List<Class<? extends IDingBot>> dingBots;

    public AbstractDingInteractiveCardCallback(String callbackRouteKey, String callbackUrl, List<Class<? extends IDingBot>> dingBots) {
        this.callbackRouteKey = callbackRouteKey;
        this.callbackUrl = callbackUrl;
        this.dingBots = dingBots;
    }
}

1.3 消息的抽象

package com.hp.dingding.pojo.message;

import com.google.gson.Gson;

/**
 * @author hp
 */
public interface IDingMsg {
    /**
     * 获取以类名直接定义的消息类型
     *
     * @param msg 某个具体类型的消息
     * @return 消息类型（类名第一个字母小写）
     */
    default String msgType(Object msg) {
        final char[] chars = msg.getClass().getSimpleName().toCharArray();
        chars[0] += 32;
        return String.valueOf(chars);
    }

    /**
     * 消息类型
     *
     * @return 消息类型
     */
    String getMsgType();

    /**
     * 消息内容
     *
     * @return json消息内容
     */
    default String getMsgParam() {
        return new Gson().toJson(this);
    }
}

1.4 互动卡片消息抽象

package com.hp.dingding.pojo.message.interactive;

import com.hp.dingding.pojo.message.IDingMsg;
import org.springframework.cglib.beans.BeanMap;
import org.springframework.util.Assert;
import org.springframework.util.DigestUtils;

import java.nio.charset.StandardCharsets;
import java.util.HashMap;
import java.util.Map;

public interface IDingInteractiveMsg extends IDingMsg {

    /**
     * 互动卡片全局密码盐，用于对消息对sign值加密
     */
    String GLOBAL_SALT = "dfaen23djf461nJ51FHDowie17hf1";

    /**
     * 同一用这个方法转map，或者改hutool也行
     */
    default Map<String, String> getMap() {
        final BeanMap beanMap = BeanMap.create(this);
        final Map<String, String> map = new HashMap<>();
        beanMap.forEach((k, v) -> {
            if (v != null) {
                map.put(String.valueOf(k), String.valueOf(v));
            }
        });
        return map;
    }

    /**
     * 主要接口，看作消息唯一id
     */
    String getOutTrackId();

    /**
     * 主要参数
     * 卡片的回调路由key，接口也只能配置一个key，多按钮通过接口参数区分
     */
    String getCallbackRouteKey();

    /**
     * 业务历史遗留，简单的通过该加密字段对回调参数做校验
     */
    String getSign();

    /**
     * 主要参数
     * 互动卡片模版Id，卡片后台配置后获取（不需要发布）
     */
    String getTemplateId();

    /**
     * 字段加密方法，简单加密
     */
    static String encryptSign(String outTrackId) {
        Assert.notNull(outTrackId, "参数异常：outTrackId缺失");
        final String combine = outTrackId + GLOBAL_SALT;
        return DigestUtils.md5DigestAsHex(combine.getBytes(StandardCharsets.UTF_8));
    }

    /**
     * 空实现
     * @return
     */
    @Override
    default String getMsgType(){return null;}
}

package com.hp.dingding.pojo.message.interactive;

import com.hp.dingding.pojo.message.interactive.callback.IDingInteractiveCardCallBack;
import lombok.Getter;
import lombok.Setter;

/**
 * @author hp
 */
@Setter
@Getter
public abstract class AbstractDingInteractiveMsg implements IDingInteractiveMsg {

    public String templateId;
    public String callbackRouteKey;
    public String outTrackId;
    public String sign;

    public AbstractDingInteractiveMsg(IDingInteractiveCardCallBack callBack, String outTrackId, String templateId) {
        this.callbackRouteKey = callBack.getCallbackRouteKey();
        this.outTrackId = outTrackId;
        this.templateId = templateId;
        this.sign = IDingInteractiveMsg.encryptSign(this.outTrackId);
    }
}

2.1 抽象的实现及配置

2.1.1 配置
package com.hp.dingtalk.demo.infrastructure.config;

import com.hp.dingding.component.application.IDingBot;
import com.hp.dingding.component.application.IDingMiniH5;
import com.hp.dingding.pojo.message.interactive.callback.IDingInteractiveCardCallBack;
import com.hp.dingtalk.demo.domain.app.DummyMiniH5App;
import com.hp.dingtalk.demo.domain.message.interactive_card.DummyInteractiveCardCallback;
import com.hp.dingtalk.demo.domain.robot.TestBot;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.Collections;

/**
 * 配置类
 * 或者更简化使用匿名内部类来注册bean，这里为了方便理解，还是通过完整实现类注册
 *
 * @author hp 2023/3/17
 */
@Configuration
public class DingConfig {

    /**
     * 如果要做环境隔离，使用此方式配置
     * 否则硬编码+component或者通过configurationProperties自动配置也行
     * 最终目的是将应用注册到工厂中，后续accessToken和接口调用
     */
    @Bean
    public IDingBot testBot() {
        // TODO change the constructor parameters to your own DingTalk application info. app name is for log.
        // Note that the app name is only for logging readability and is fully customizable by you
        return new TestBot("custom bot name", 16757015L, "your bot key", "your bot secret");
    }

    @Bean
    public IDingMiniH5 dummyMiniH5App() {
        return new DummyMiniH5App("custom app name", 16757015L, "your app key", "your app secret");
    }

    /**
     * 如果要做环境隔离，使用此方式配置
     * 否则硬编码+component或者通过configurationProperties自动配置也行
     */
    @Bean
    public IDingInteractiveCardCallBack dummyInteractiveCardCallback() {
        // TODO change the constructor parameters to your own custom configuration.
        // Note that the third parameter, robots on your DingTalk, indicates that those robots will be used to register callback url when the system is ready.
        return new DummyInteractiveCardCallback("your callback route key(no space)", "http://sdavw8.natappfree.cc/dummy/test/callback", Collections.singletonList(TestBot.class));
    }
}
2.1.2 机器人实现
package com.hp.dingtalk.demo.domain.robot;

import com.hp.dingding.component.application.IDingBot;
import lombok.Getter;

/**
 * @author hp 2023/3/17
 */
@Getter
public class TestBot implements IDingBot {

    private final String appName;
    private final Long appId;
    private final String appKey;
    private final String appSecret;

    public TestBot(String appName, Long appId, String appKey, String appSecret) {
        this.appName = appName;
        this.appId = appId;
        this.appKey = appKey;
        this.appSecret = appSecret;
        this.afterSingletonsInstantiated();
    }
}
2.1.3 卡片回调实现
package com.hp.dingtalk.demo.domain.message.interactive_card;

import com.hp.dingding.component.application.IDingBot;
import com.hp.dingding.pojo.message.interactive.callback.AbstractDingInteractiveCardCallback;

import java.util.List;

/**
 * @author hp 2023/3/17
 */
public class DummyInteractiveCardCallback extends AbstractDingInteractiveCardCallback {

    public DummyInteractiveCardCallback(String callbackRouteKey, String callbackUrl, List<Class<? extends IDingBot>> dingBots) {
        super(callbackRouteKey, callbackUrl, dingBots);
    }
}
2.1.4 卡片实现
package com.hp.dingtalk.demo.domain.message.interactive_card;

import com.hp.dingding.pojo.message.interactive.AbstractDingInteractiveMsg;
import com.hp.dingding.pojo.message.interactive.callback.IDingInteractiveCardCallBack;
import lombok.Getter;
import lombok.Setter;
import lombok.experimental.Accessors;

/**
 * @author hp 2023/3/17
 */
@Accessors(chain = true)
@Getter
@Setter
public class DummyInteractiveCard extends AbstractDingInteractiveMsg {

    /**
     * 模版属性
     */
    private String dummyName;
    private String otherInformation;
    private int button;

    /**
     * 模版id可以写死或者暂时自己实现动态配置
     */
    public DummyInteractiveCard(IDingInteractiveCardCallBack callBack, String outTrackId) {
        // TODO change the templateId parameter to your own template id that you previously created on the DingTalk interactive card platform.
        super(callBack, outTrackId, "your interactive card template id");
    }
}

2.2 注册互动卡片按钮的回调URL

因为只要注册一次, 我在SpringBoot启动后通过事件机制调用注册流程

package com.hp.dingding.component;

import com.hp.dingding.component.application.IDingBot;
import com.hp.dingding.component.factory.app.DingAppFactory;
import com.hp.dingding.pojo.message.interactive.callback.IDingInteractiveCardCallBack;
import com.hp.dingding.service.IDingInteractiveMessageHandler;
import com.taobao.api.ApiException;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.jetbrains.annotations.NotNull;
import org.springframework.boot.context.event.ApplicationReadyEvent;
import org.springframework.context.ApplicationListener;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import java.util.List;

/**
 * springboot ready后 调用注册
 *
 * @author hp
 */
@Slf4j
@Component
@RequiredArgsConstructor
public class DingBooter implements ApplicationListener<ApplicationReadyEvent> {

    private final List<IDingInteractiveCardCallBack> callBacks;

    @Override
    public void onApplicationEvent(@NotNull ApplicationReadyEvent applicationReadyEvent) {
        if (CollectionUtils.isEmpty(callBacks)) {
            return;
        }
        callBacks.forEach(callBack ->
                callBack.getDingBots().forEach(clazz -> {
                    final IDingBot app = DingAppFactory.app(clazz);
                    try {
                        IDingInteractiveMessageHandler.registerCallBackUrl(app, callBack, true);
                    } catch (ApiException e) {
                        log.error("注册回调地址失败：应用：{}, 回调地址：{}, 路由键：{}", app.getAppName(), callBack.getCallbackUrl(), callBack.getCallbackRouteKey());
                        log.error("注册回调地址失败：异常：{}", e.getCause(), e);
                    }
                })
        );
    }
}

2.3 机器人通过接口发送消息处理器抽象

对于机器人应用, 钉钉文档中提及两种发送消息方式

  1. 通过消息接口发送, 本例
  2. 通过webhook发送, 例如用户向机器人发送单聊消息, 钉钉调用开发者在应用后台配置的回调接口, 请求体中包含了webhooh地址和webhook Session的信息用于此场景发送消息
package com.hp.dingding.service;

import com.dingtalk.api.DefaultDingTalkClient;
import com.dingtalk.api.DingTalkClient;
import com.dingtalk.api.request.OapiImChatScencegroupInteractivecardCallbackRegisterRequest;
import com.hp.dingding.component.IDingApi;
import com.hp.dingding.component.application.IDingBot;
import com.hp.dingding.component.factory.token.DingAccessTokenFactory;
import com.hp.dingding.constant.DingConstant;
import com.hp.dingding.pojo.message.interactive.IDingInteractiveMsg;
import com.hp.dingding.pojo.message.interactive.callback.IDingInteractiveCardCallBack;
import com.taobao.api.ApiException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.List;

/**
 * 发送钉钉互动卡片，高级版，普通版暂不实现
 * 以下接口都是使用钉钉userId模式，不推荐unionId模式
 * <p>
 * unionid是员工在当前开发者企业账号范围内的唯一标识，由系统生成：
 * 同一个企业员工，在不同的开发者企业账号下，unionid是不相同的。
 * 在同一个开发者企业账号下，unionid是唯一且不变的，例如同一个服务商开发的多个应用，或者是扫码登录等场景的多个App账号。
 *
 * @author hp
 */
public interface IDingInteractiveMessageHandler extends IDingApi {
    Logger logger = LoggerFactory.getLogger(IDingInteractiveMessageHandler.class);

    /**
     * 发送互动卡片至单聊
     * 机器人对用户单聊
     * 这里不对是否转发，针对某个用户的私域数据，@用户做处理
     *
     * @param bot            调用应用
     * @param userIds        接收用户
     * @param interactiveMsg 卡片消息：包含必要配置信息：卡片id，callbackUrl等
     * @return outTrackId for additional usage
     */
    String sendInteractiveMsgToIndividual(IDingBot bot, List<String> userIds, IDingInteractiveMsg interactiveMsg);

    /**
     * 发送互动卡片至群聊
     *
     * @param bot                调用应用
     * @param userIds            为空则群内所有成员可见，不为空则指定人员可见
     * @param openConversationId 场景群id
     * @param interactiveMsg     卡片消息：包含必要配置信息：卡片id，callbackUrl等
     * @return outTrackId
     * @deprecated 还没仔细验证过群聊场景，验证后再逐渐增加业务常用参数，近期业务用不到群聊场景，暂时不更新
     */
    @Deprecated
    String sendInteractiveMsgToGroup(IDingBot bot, List<String> userIds, String openConversationId, IDingInteractiveMsg interactiveMsg);

    /**
     * 更新互动卡片
     *
     * @param bot                调用应用
     * @param openConversationId 场景群id
     * @param interactiveMsg     卡片消息：包含必要配置信息：卡片id，callbackUrl等
     * @return 互动卡片唯一id（outTrackId）
     */
    String updateInteractiveMsg(IDingBot bot, String openConversationId, IDingInteractiveMsg interactiveMsg);

    /**
     * 注册互动卡片回调api
     *
     * @param bot         调用应用
     * @param callback    回调url配置
     * @param forceUpdate 是否强制更新，在不区分环境的情况下，强制更新，容易出现开发或测试更新到上线的问题，项目启动时默认为true，期望客户端能正确将配置通过环境区分
     * @throws ApiException 调用钉钉API异常
     */
    static void registerCallBackUrl(IDingBot bot, IDingInteractiveCardCallBack callback, boolean forceUpdate) throws ApiException {
        if (bot == null || callback == null) {
            return;
        }
        logger.info("注册回调地址,应用:{},路由键:{},路由地址:{}", bot.getAppName(), callback.getCallbackRouteKey(), callback.getCallbackUrl());
        DingTalkClient client = new DefaultDingTalkClient(DingConstant.REGISTER_CALLBACK);
        OapiImChatScencegroupInteractivecardCallbackRegisterRequest requset = new OapiImChatScencegroupInteractivecardCallbackRegisterRequest();
        requset.setCallbackUrl(callback.getCallbackUrl());
        requset.setApiSecret(bot.getAppSecret());
        requset.setCallbackRouteKey(callback.getCallbackRouteKey());
        requset.setForceUpdate(forceUpdate);
        client.execute(requset, DingAccessTokenFactory.accessToken(bot));
    }
}

2.4 发送互动卡片消息

官方文档一句话: 非场景群机器人单聊发送：chatBotId和robotCode都不填写，直接用支持单聊的机器人应用来发送。

2.3具体实现

  @Override
    public String sendInteractiveMsgToIndividual(IDingBot bot, List<String> userIds, IDingInteractiveMsg interactiveMsg) {
        log.debug("机器人发送互动卡片至用户,机器人:{},用户id:{},内容:{}", bot.getAppName(), userIds, interactiveMsg.getMap());
        try {
            com.aliyun.dingtalkim_1_0.Client client = new com.aliyun.dingtalkim_1_0.Client(this.config());
            SendInteractiveCardHeaders sendInteractiveCardHeaders = new SendInteractiveCardHeaders();
            sendInteractiveCardHeaders.xAcsDingtalkAccessToken = DingAccessTokenFactory.accessToken(bot);
            SendInteractiveCardRequest.SendInteractiveCardRequestCardData cardData = new SendInteractiveCardRequest.SendInteractiveCardRequestCardData();
            cardData.setCardParamMap(interactiveMsg.getMap());
            SendInteractiveCardRequest sendInteractiveCardRequest = new SendInteractiveCardRequest()
                    .setCardTemplateId(interactiveMsg.getTemplateId())
                    .setReceiverUserIdList(userIds)
                    .setConversationType(0)
                    .setCallbackRouteKey(interactiveMsg.getCallbackRouteKey())
                    .setCardData(cardData)
                    .setOutTrackId(interactiveMsg.getOutTrackId());

            client.sendInteractiveCardWithOptions(sendInteractiveCardRequest, sendInteractiveCardHeaders, new RuntimeOptions());
            return interactiveMsg.getOutTrackId();
        } catch (TeaException err) {
            if (StringUtils.hasText(err.code) && StringUtils.hasText(err.message)) {
                log.error("机器人发送互动卡片至用户异常,机器人:{},异常信息:{},{}", bot.getAppName(), err.code, err.message);
            }
            throw new DingApiException("机器人发送互动卡片至用户异常", err);
        } catch (Exception e) {
            TeaException err = new TeaException(e.getMessage(), e);
            if (StringUtils.hasText(err.code) && StringUtils.hasText(err.message)) {
                log.error("机器人发送互动卡片至用户异常,机器人:{},异常信息:{},{}", bot.getAppName(), err.code, err.message);
            }
            throw new DingApiException("机器人发送互动卡片至用户异常", e);
        }
    }

2.5 用户点击互动卡片的互动按钮

钉钉调用2.2注册的URLPOST请求

outTrackId(卡片唯一id)回调的时候可以用这个参数更新卡片状态

    @PostMapping("此前自定义的callbackurl")
    public void interactiveCardCallback(
    		//此类在仓库中可以找到,根据回调数据写的一个对象
			@RequestBody DingInteractiveCardCallBackPayload payload
) {
        try {
            final DingInteractiveCardCallBackPayload.Value value = payload.getValue();
            final DingInteractiveCardCallBackPayload.CardPrivateData cardPrivateData = value.getCardPrivateData();
			//使用自己的业务对象获取编辑卡片按钮回调时自定义携带的参数
			/* 
			* 问题: 因为返回的json参数层级较多, 自定义的返回参数在最里面一层, gson无法直接将这部分数据序列化为业务对象, 返回的是一个map集合, 
			* 这里的操作就是重写get时再用gson反序列化一下, 能到达效果, 但感觉不太好
			*/
            final T params = cardPrivateData.getParams(T.class);
			//根据卡片实现的卡片模版类中的自定义sign属性值简单校验一下 (不强制)
            Assert.isTrue(Objects.equals(IDingInteractiveMsg.encryptSign(payload.getOutTrackId()), params.getSign()), "!!! ILLEGAL ACCESS !!!");

	//完成业务操作
	...
	...
    //最后获取此前提交的卡片数据, 我这里是从db查出
    IDingInteractiveMsg msg = (IDingInteractiveMsg) new Gson().fromJson(message, Class.forName(messageLog.getClazz()));
    //调用更新卡片接口, 这里的 msg 对于我写的钉钉模块中就是互动卡片消息类
    new DingBotMessageHandler().updateInteractiveMsg(DingAppFactory.app(Long.valueOf(messageLog.getAppId())), null, msg);
	//方法结束
	}

2.6 更新卡片数据

此次处理是在发送消息时保存卡片的json数据, 需要更新时查出来直接反序列化为对应卡片模版实例, 更新值对象后调用接口更新卡片数据

	@SneakyThrows
    @Override
    public String updateInteractiveMsg(IDingBot bot, String openConversationId, IDingInteractiveMsg interactiveMsg) {
        log.debug("机器人更新互动卡片至用户,机器人:{},会话Id:{},内容:{}", bot.getAppName(), openConversationId, interactiveMsg.getMap());
        com.aliyun.dingtalkim_1_0.Client client = new com.aliyun.dingtalkim_1_0.Client(this.config());
        UpdateInteractiveCardHeaders updateInteractiveCardHeaders = new UpdateInteractiveCardHeaders();
        updateInteractiveCardHeaders.xAcsDingtalkAccessToken = DingAccessTokenFactory.accessToken(bot);
        UpdateInteractiveCardRequest.UpdateInteractiveCardRequestCardOptions cardOptions = new UpdateInteractiveCardRequest.UpdateInteractiveCardRequestCardOptions().setUpdateCardDataByKey(true).setUpdatePrivateDataByKey(true);
        UpdateInteractiveCardRequest.UpdateInteractiveCardRequestCardData cardData = new UpdateInteractiveCardRequest.UpdateInteractiveCardRequestCardData().setCardParamMap(interactiveMsg.getMap());
        UpdateInteractiveCardRequest updateInteractiveCardRequest = new UpdateInteractiveCardRequest().setOutTrackId(interactiveMsg.getOutTrackId()).setCardData(cardData).setUserIdType(1).setCardOptions(cardOptions);
        try {
            client.updateInteractiveCardWithOptions(updateInteractiveCardRequest, updateInteractiveCardHeaders, new RuntimeOptions());
            return interactiveMsg.getOutTrackId();
        } catch (TeaException err) {
            if (StringUtils.hasText(err.code) && StringUtils.hasText(err.message)) {
                log.error("机器人更新互动卡片至用户异常,机器人:{},异常信息:{},{}", bot.getAppName(), err.code, err.message);
            }
            throw new DingApiException("机器人更新互动卡片至用户异常", err);
        } catch (Exception e) {
            TeaException err = new TeaException(e.getMessage(), e);
            if (StringUtils.hasText(err.code) && StringUtils.hasText(err.message)) {
                log.error("机器人更新互动卡片至用户异常,机器人:{},异常信息:{},{}", bot.getAppName(), err.code, err.message);
            }
            throw new DingApiException("机器人更新互动卡片至用户异常", e);
        }
    }

2.7 业务API

package com.hp.dingtalk.demo.controller;

import com.dingtalk.api.response.OapiV2UserGetResponse;
import com.google.gson.Gson;
import com.hp.dingding.component.factory.DingAppFactory;
import com.hp.dingding.pojo.callback.DingInteractiveCardCallBackPayload;
import com.hp.dingding.pojo.message.interactive.IDingInteractiveMsg;
import com.hp.dingding.pojo.message.interactive.callback.IDingInteractiveCardCallBack;
import com.hp.dingding.service.message.DingBotMessageHandler;
import com.hp.dingding.service.user.DingUserHandler;
import com.hp.dingtalk.demo.domain.login.request.DingTalkLoginRequest;
import com.hp.dingtalk.demo.domain.login.service.DingTalkLoginService;
import com.hp.dingtalk.demo.domain.message.interactive_card.DummyInteractiveCard;
import com.hp.dingtalk.demo.domain.robot.TestBot;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.time.LocalDateTime;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;

/**
 * @author hp 2023/3/17
 */
@Slf4j
@RestController
@RequiredArgsConstructor
@RequestMapping("/dummy")
public class DummyApiController {

    private final IDingInteractiveCardCallBack dummyInteractiveCardCallback;
    private final DingTalkLoginService dingTalkLoginService;

    private static final Map<String, IDingInteractiveMsg> LOCAL_CACHE = new HashMap<>(16);

    @PostMapping("/test/interactive-card")
    public String testSendInteractiveCardMessage() {
        final DingBotMessageHandler dingBotMessageHandler = new DingBotMessageHandler();
        final DingUserHandler dingUserHandler = new DingUserHandler();
        final DummyInteractiveCard card = new DummyInteractiveCard(dummyInteractiveCardCallback, String.valueOf(System.currentTimeMillis()))
                .setDummyName(" Hello Human ")
                .setOtherInformation(" Surprise Mother发卡... ")
                .setButton(0);
        final TestBot app = DingAppFactory.app(TestBot.class);
        // TODO change the second parameter to a phone number that exists in your organization.
        final String dingTalkUserId = dingUserHandler.findUserIdByMobile(app, "The phone number that equals the phone number on the DingTalk profile");
        final String outTrackId = dingBotMessageHandler.sendInteractiveMsgToIndividual(app, Collections.singletonList(dingTalkUserId), card);
        LOCAL_CACHE.putIfAbsent(outTrackId, card);
        return "successfully sent, and the outTrackId is: " + outTrackId;
    }

    @PostMapping("/test/callback")
    public void testUpdateInteractiveCardMessage(@RequestBody DingInteractiveCardCallBackPayload payload) {
        log.info("callback payload: {}", new Gson().toJson(payload));
        final String outTrackId = payload.getOutTrackId();
        final IDingInteractiveMsg msg = LOCAL_CACHE.get(outTrackId);
        if (!(msg instanceof DummyInteractiveCard)) {
            return;
        }
        ((DummyInteractiveCard) msg)
                .setDummyName("Oops! I got updated")
                .setOtherInformation(" Updated Time: " + LocalDateTime.now())
                .setButton(1);
        // openConversationId 为null 钉钉根据卡片实例id更新卡片
        new DingBotMessageHandler().updateInteractiveMsg(DingAppFactory.app(TestBot.class), null, msg);
    }

    @PostMapping("/test/login")
    public String login(@RequestBody DingTalkLoginRequest request) {
        final OapiV2UserGetResponse.UserGetResponse userGetResponse = dingTalkLoginService.queryDingDing(request);
        final String userid = userGetResponse.getUserid();
        /*
            ...后续查询系统用户信息校验等等
         */
        return "token:" + userid;
    }
}

三、其他

这里调用的效果就不展示了, 如果感兴趣, 可以尝试配置钉钉开放后台的相关资源后, 可以使用demo项目调用测试下.

1.1 常见问题

  • 2022-07-26
    在这里插入图片描述
    有人问多个按钮回调时如何区分, 这里配置时并没有对按钮区分, 都是同一个回调接口,但是参数可以自定义, 参数一旦自定义,那么如何区分问题也就一目了然了

1.2 尝试

在模块中实现了一个简单的状态机, 最近在用其配合钉钉机器人的消息回调功能模拟类似shell交互的方式提供业务功能, 有兴趣的同好可以看下模块里状态机的实现, 提提优化意见或建议. much appreciate 😃

四、总结

官方文档东一块西一块的比较容易看乱了, 本文的实现集中于机器人单聊互动卡片的操作, 流程单一, 清晰, 按照本文提供的实现完成发送业务会相对快一些.

发送钉钉卡片消息
weixin_73864870的博客
11-24 1176
/** * 使用 Token 初始化账号Client * @return Client * @exception Exception */ public static Client createClient() throws Exception { Config config = new Config(); config.protocol = "https"; config.regionId = "cen
钉钉机器人实现卡片互动
qq_20668827的博客
01-10 4715
目录 一、实现效果（需求） 二、代码实现 一、实现效果（需求） 二、代码实现
钉钉机器人单聊实现互动卡片推送
时间静止
04-12 2810
基于钉钉实现卡片推送服务
钉钉小程序生态7—企业机器人加互动卡片，改善用户体验的开始！
summon的博客
01-04 2052
企业机器人，具备完整的接收消息和发送消息的能力。它与Webhoook 机器人不同，Webhoook 机器人只能出现在群里面，而企业机器人不仅可以在群里出现，还可以以单聊的形式出现，企业机器人很多时候都是以"xx小蜜"或"xx助手"命名。企业机器人属于功能版块- 点进去是机器人推送给你的信息钉钉互动卡片是一种新型的消息类型，它具有动态性、可交互性、多端统一等特点。它能够极大地丰富消息类型，并且促进用户的沟通互动。互动卡片具有以下特点。
Dingtalk：钉钉机器人消息封装——Golang
最新发布
gitblog_00230的博客
03-28 594
Dingtalk：钉钉机器人消息封装——Golang dingtalk golang钉钉机器人客户端。支持文本、链接、Markdown、ActionCard、FeedCard类型消息的发送，Outgoing机器人消息的接收。通过钉钉机器人接口和不同消息的封装，达到简单快速发送不同类型消息的目的。 ...
钉钉机器人
WADE
04-05 2991
const http = require(‘http’) const rest = require(‘restler’) const later = require(‘later’)var composite = [ {h: [9], m: [30]}, {h: [15], m: [30]}}, {h: [18], m: [30]}} ]var ex
python实现钉钉群机器人消息通知（消息卡片）
sweetCat009的博客
10-31 846
Python实现自动化报告推送钉钉机器人消息卡片
钉钉单聊/群聊机器人实现思路
wanglei_storage的博客
03-01 3225
钉钉官网文档：https://open.dingtalk.com/document/group/robot-overview 一、钉钉开发平台 1.申请机器人 应用开发-企业内部开发-基础信息-机器人-创建机器人 2.开发管理 设置开发服务器出口IP列表 3.回调接口 设置钉钉扫码后的回调后端接口 （用于消息接收） 4.权限设置 企业内机器人发送消息权限 二、消息接收 获取post后的消息数据及各字段 1.通用字段 conversationType = req_data['conversatio
java集成钉钉实现卡片消息发送
xuweilin的博客
12-24 1767
在Java中集成钉钉并发送卡片消息，你可以使用钉钉提供的Open API。以下是一个基本的步骤指南和示例代码，展示如何实现这一目标。
钉钉互动卡片对接-普通互动卡片接入流程
ray的博客
01-23 1874
钉钉互动卡片对接-普通互动卡片接入流程
java实现推送钉钉消息(带图片,连接)demo
05-28
java后台推送钉钉卡片消息带图片已经连接一个简单demo，需要更改为自己的AgentId,AppSecret,运行main方法即可
java实现钉钉机器人消息推送的示例代码
08-25
本文提供了一个完整的java实现钉钉机器人消息推送的示例代码，涵盖了钉钉机器人的基本概念、java语言实现细节和测试场景等方面的内容。开发者可以根据实际需求，修改和扩展本示例代码，以满足不同的业务需求。 知识...
C# 钉钉机器人对接（需要在钉钉生成access-token）
04-02
在企业或团队的工作流自动化中，通过钉钉机器人的API，可以实现消息推送、任务提醒等功能，提高工作效率。下面将详细阐述这个过程中的关键知识点。 首先，了解**钉钉机器人**。钉钉机器人是钉钉为企业提供的自动化...
钉钉企业机器人单聊消息发送实践-大数据平台(XSailboat)消息中心消息推送
OkGogooXSailboat的博客
01-22 1768
在笔者开发的中有模块，用来全平台的消息收集，整理分拆、订阅发送等功能。消息推送方式支持钉钉群聊、钉钉单聊、短信通知。现记录一下企业机器人消息单聊推送的实现过程。
简单几步，钉钉机器人秒变通义千问对话机器人
AliCloudROS的博客
02-29 1653
Appflow是阿里云计算巢团队自主研发的一款应用与数据集成平台，目前开发团队已经支持了众多公共连接器，您可以尽情发挥您的想象，使用AppFlow为您免去繁琐的重复接入和开发工作，为你的工作提速提效！点击页面左侧"连接流"Tab，去创建你自己的Flow吧~
钉钉互动卡片回调按钮无响应问题解决
brf8888的博客
01-16 843
钉钉互动卡片回调按钮无响应问题解决
java对接钉钉 发送/更新 互动卡片消息
weixin_40428553的博客
11-30 4954
java对接钉钉发送互动卡片消息一、准备工作二、发送互动卡片消息三、更新互动消息卡片 先看下效果图 点击相应的积分按钮，就会给对应的申请人发送对应的积分（对接到我们自己的系统发送），审核完之后，按钮变成已审核。 接下来就开始吧！ 一、准备工作 参考钉钉提供的 互动卡片消息发送流程 步骤一：创建消息模板 这里简单给出示例，具体可以参考钉钉给的示例 步骤二：注册卡片回调地址 需要告诉钉钉用户点击卡片后，要回调到我们自己系统的哪个接口 部分代码如下： public void interactiveCardR
DingTalk钉钉消息通知
小乔流水仁家的博客
08-19 4267
开发文档：Link 钉钉消息通知简单分为单纯的消息通知(没有回复) 和 会话。 1、自定义机器人开发通知不需要sdk包。 <?php function request_by_curl($remote_server, $post_string) { $ch = curl_init(); curl_setopt($ch, CURLOPT_URL, $remote_server); curl_setopt($ch, CURLOPT_POST, 1); .
钉钉机器人单聊python
09-11
钉钉机器人是阿里巴巴钉钉平台上的一种自动化工具，它可以帮助开发者实现与钉钉用户之间消息的发送和接收。通过钉钉机器人，可以在不打开钉钉应用的情况下，直接通过编程方式发送消息到钉钉群或者个人（单聊）。 要在Python中实现与钉钉机器人的交互，主要包括以下几个步骤： 1. 创建机器人：在钉钉群中添加机器人，获取其Webhook URL，这是一个特殊的URL，用于发送消息到该机器人。 2. 发送消息：使用Python的requests库，通过HTTP POST请求将消息发送到Webhook URL。消息内容需要按照钉钉官方提供的消息格式进行组织。 3. 处理响应：根据发送请求后得到的响应进行相应的处理，比如检查是否发送成功。 下面是一个简单的Python示例代码，展示了如何使用钉钉机器人发送消息到个人（单聊）： ```python import requests import json # 钉钉机器人的Webhook URL webhook_url = 'https://oapi.dingtalk.com/robot/send?access_token=你的access_token' # 构建消息内容 message = { "msgtype": "text", # 消息类型为文本 "text": { "content": "你好，这是通过Python发送的单聊消息！" # 消息内容 }, "at": { "isAtAll": False # 不@所有人 } } # 发送消息 headers = {'Content-Type': 'application/json'} response = requests.post(webhook_url, headers=headers, data=json.dumps(message)) # 打印响应内容 print(response.text) ``` 注意：上述代码中的`access_token`需要替换为你自己创建的钉钉机器人的实际Token。 在实际使用时，还需要处理网络请求的异常情况以及验证发送消息的安全性。
评论 26
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值