小蓝xlanll

这个屌丝很懒，什么也没留下！

热门标签

企业微信第三方服务商应用开发及上架教程_企业微信第三方应用开发教程

作者：小蓝xlanll | 2024-05-24 11:20:08

踩

企业微信第三方应用开发教程

之前一直没有写这篇文章，是觉得企微的服务商应用相对简单。第二个原因是最近在弄钉钉的ISV上架，所以时间不是很充足。正题开始……

第一章服务商入驻

1、使用管理员登录服务商管理后台

企业微信-服务商后台-登录地址https://open.work.weixin.qq.com/wwopen/login2、输入基本信息及认证

第二章应用配置

1、登录后，直接创建创建网页应用，如下图。

2、应用详情-使用配置-参照下面的教程。主页地址是固定的，只需要写入自己的appid和redirect_uri的地址就行。这里需要注意，可信域名必须配置一下，需要注意的是这个一级域名一旦使用的服务商应用，那么自建应用是无法在使用这个域名的，即便是不同的二级域名也不可以。这个还是比较坑，导致我们重新申请了一个一级域名来服务自建应用。

3、可信域名配置，使用配置-点击【编辑】，然后点击【校验可信域名归属】，然后下载这个文件到nginx配置的域名文件夹下，只要通过步骤2的地址可以访问到就算验证通过。nginx的配置参照下面的这个文章。

nginx配置websocket或https的转发教程_renkai721的博客-CSDN博客_nginx websocket转发nginx配置http,https,ssl,websocket转发https://blog.csdn.net/renkai721/article/details/125991270

4、数据回调的配置

第三章应用开发

1、pom.xml中添加解析XML格式内容


 
		<!--XML 解析包-->
		<dependency>
			<groupId>org.jdom</groupId>
			<artifactId>jdom2</artifactId>
			<version>2.0.6</version>
		</dependency>
		<dependency>
			<groupId>commons-codec</groupId>
			<artifactId>commons-codec</artifactId>
			<version>1.15</version>
		</dependency>

2、properties文件，不需要那么多，命名更具自己的喜好，这一看就是参照了gitee的binarywang/weixin-java-cp-demo，这个demo如果初学者可以看看，然后自己封装。

3、核心解密controller.java


package cn.renkai721.controller;
 
import cn.renkai721.bean.*;
import cn.renkai721.configuration.QywxProperties;
import cn.renkai721.service.*;
import cn.renkai721.util.HttpUtil;
import cn.renkai721.util.MsgUtil;
import cn.renkai721.util.WxUtil;
import cn.renkai721.wechataes.WXBizMsgCrypt;
import com.alibaba.druid.util.StringUtils;
import com.alibaba.fastjson.JSON;
import lombok.extern.slf4j.Slf4j;
import org.redisson.api.RBucket;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.client.RestTemplate;
 
import javax.annotation.Resource;
import javax.servlet.ServletInputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Map;
 
 
@EnableAsync
@RestController
@RequestMapping("/d3f")
@Slf4j
public class D3f2Controller {
    @Resource
    private RedissonClient redissonClient;
    @Autowired
    private RestTemplate restTemplate;
    @Autowired
    private D3fService d3fService;
 
 
    @GetMapping(produces = "text/plain;charset=utf-8")
    public void d3fGet(@RequestParam(name = "msg_signature", required = false) String signature,
                          @RequestParam(name = "timestamp", required = false) String timestamp,
                          @RequestParam(name = "nonce", required = false) String nonce,
                          @RequestParam(name = "echostr", required = false) String echostr,
                          HttpServletResponse response) throws Exception  {
        
        // 需要返回的明文
       
        return;
    }
 
    @PostMapping(produces = "application/xml; charset=UTF-8")
    public void d3fPost(@RequestParam("msg_signature") String signature,
                     @RequestParam("timestamp") String timestamp,
                     @RequestParam("nonce") String nonce,
                     HttpServletResponse response,
                     HttpServletRequest request) throws Exception {
        
        log.info("接收d3f post请求：[signature=[{}], timestamp=[{}], nonce=[{}], type=[{}], corpid=[{}] ]",
                signature, timestamp, nonce, type, corpid);
    }
 
 
 
}

4、解密工具WXBizMsgCrypt.java


/**
 * 对企业微信发送给企业后台的消息加解密示例代码.
 * 
 * @copyright Copyright (c) 1998-2014 Tencent Inc.
 */
// ------------------------------------------------------------------------
 
/**
 * 针对org.apache.commons.codec.binary.Base64，
 * 需要导入架包commons-codec-1.9（或commons-codec-1.8等其他版本）
 * 官方下载地址：http://commons.apache.org/proper/commons-codec/download_codec.cgi
 */
package cn.renkai721.wechataes;
 
import org.apache.commons.codec.binary.Base64;
 
import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.Charset;
import java.util.Arrays;
import java.util.Random;
 
/**
 * 提供接收和推送给企业微信消息的加解密接口(UTF8编码的字符串).
 * <ol>
 * 	<li>第三方回复加密消息给企业微信</li>
 * 	<li>第三方收到企业微信发送的消息，验证消息的安全性，并对消息进行解密。</li>
 * </ol>
 * 说明：异常java.security.InvalidKeyException:illegal Key Size的解决方案
 * <ol>
 * 	<li>在官方网站下载JCE无限制权限策略文件（JDK7的下载地址：
 *      http://www.oracle.com/technetwork/java/javase/downloads/jce-7-download-432124.html</li>
 * 	<li>下载后解压，可以看到local_policy.jar和US_export_policy.jar以及readme.txt</li>
 * 	<li>如果安装了JRE，将两个jar文件放到%JRE_HOME%\lib\security目录下覆盖原来的文件</li>
 * 	<li>如果安装了JDK，将两个jar文件放到%JDK_HOME%\jre\lib\security目录下覆盖原来文件</li>
 * </ol>
 */
public class WXBizMsgCrypt {
	static Charset CHARSET = Charset.forName("utf-8");
	Base64 base64 = new Base64();
	byte[] aesKey;
	String token;
	String receiveid;
 
	/**
	 * 构造函数
	 * @param token 企业微信后台，开发者设置的token
	 * @param encodingAesKey 企业微信后台，开发者设置的EncodingAESKey
	 * @param receiveid, 不同场景含义不同，详见文档
	 * 
	 * @throws AesException 执行失败，请查看该异常的错误码和具体的错误信息
	 */
	public WXBizMsgCrypt(String token, String encodingAesKey, String receiveid) throws AesException {
		if (encodingAesKey.length() != 43) {
			throw new AesException(AesException.IllegalAesKey);
		}
 
		this.token = token;
		this.receiveid = receiveid;
		aesKey = Base64.decodeBase64(encodingAesKey + "=");
	}
 
	// 生成4个字节的网络字节序
	byte[] getNetworkBytesOrder(int sourceNumber) {
		byte[] orderBytes = new byte[4];
		orderBytes[3] = (byte) (sourceNumber & 0xFF);
		orderBytes[2] = (byte) (sourceNumber >> 8 & 0xFF);
		orderBytes[1] = (byte) (sourceNumber >> 16 & 0xFF);
		orderBytes[0] = (byte) (sourceNumber >> 24 & 0xFF);
		return orderBytes;
	}
 
	// 还原4个字节的网络字节序
	int recoverNetworkBytesOrder(byte[] orderBytes) {
		int sourceNumber = 0;
		for (int i = 0; i < 4; i++) {
			sourceNumber <<= 8;
			sourceNumber |= orderBytes[i] & 0xff;
		}
		return sourceNumber;
	}
 
	// 随机生成16位字符串
	String getRandomStr() {
		String base = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
		Random random = new Random();
		StringBuffer sb = new StringBuffer();
		for (int i = 0; i < 16; i++) {
			int number = random.nextInt(base.length());
			sb.append(base.charAt(number));
		}
		return sb.toString();
	}
 
	/**
	 * 对明文进行加密.
	 * 
	 * @param text 需要加密的明文
	 * @return 加密后base64编码的字符串
	 * @throws AesException aes加密失败
	 */
	String encrypt(String randomStr, String text) throws AesException {
		ByteGroup byteCollector = new ByteGroup();
		byte[] randomStrBytes = randomStr.getBytes(CHARSET);
		byte[] textBytes = text.getBytes(CHARSET);
		byte[] networkBytesOrder = getNetworkBytesOrder(textBytes.length);
		byte[] receiveidBytes = receiveid.getBytes(CHARSET);
 
		// randomStr + networkBytesOrder + text + receiveid
		byteCollector.addBytes(randomStrBytes);
		byteCollector.addBytes(networkBytesOrder);
		byteCollector.addBytes(textBytes);
		byteCollector.addBytes(receiveidBytes);
 
		// ... + pad: 使用自定义的填充方式对明文进行补位填充
		byte[] padBytes = PKCS7Encoder.encode(byteCollector.size());
		byteCollector.addBytes(padBytes);
 
		// 获得最终的字节流, 未加密
		byte[] unencrypted = byteCollector.toBytes();
 
		try {
			// 设置加密模式为AES的CBC模式
			Cipher cipher = Cipher.getInstance("AES/CBC/NoPadding");
			SecretKeySpec keySpec = new SecretKeySpec(aesKey, "AES");
			IvParameterSpec iv = new IvParameterSpec(aesKey, 0, 16);
			cipher.init(Cipher.ENCRYPT_MODE, keySpec, iv);
 
			// 加密
			byte[] encrypted = cipher.doFinal(unencrypted);
 
			// 使用BASE64对加密后的字符串进行编码
			String base64Encrypted = base64.encodeToString(encrypted);
 
			return base64Encrypted;
		} catch (Exception e) {
			e.printStackTrace();
			throw new AesException(AesException.EncryptAESError);
		}
	}
 
	/**
	 * 对密文进行解密.
	 * 
	 * @param text 需要解密的密文
	 * @return 解密得到的明文
	 * @throws AesException aes解密失败
	 */
	String decrypt(String text) throws AesException {
		byte[] original;
		try {
			// 设置解密模式为AES的CBC模式
			Cipher cipher = Cipher.getInstance("AES/CBC/NoPadding");
			SecretKeySpec key_spec = new SecretKeySpec(aesKey, "AES");
			IvParameterSpec iv = new IvParameterSpec(Arrays.copyOfRange(aesKey, 0, 16));
			cipher.init(Cipher.DECRYPT_MODE, key_spec, iv);
 
			// 使用BASE64对密文进行解码
			byte[] encrypted = Base64.decodeBase64(text);
 
			// 解密
			original = cipher.doFinal(encrypted);
		} catch (Exception e) {
			e.printStackTrace();
			throw new AesException(AesException.DecryptAESError);
		}
 
		String xmlContent, from_receiveid;
		try {
			// 去除补位字符
			byte[] bytes = PKCS7Encoder.decode(original);
 
			// 分离16位随机字符串,网络字节序和receiveid
			byte[] networkOrder = Arrays.copyOfRange(bytes, 16, 20);
 
			int xmlLength = recoverNetworkBytesOrder(networkOrder);
 
			xmlContent = new String(Arrays.copyOfRange(bytes, 20, 20 + xmlLength), CHARSET);
			from_receiveid = new String(Arrays.copyOfRange(bytes, 20 + xmlLength, bytes.length),
					CHARSET);
		} catch (Exception e) {
			e.printStackTrace();
			throw new AesException(AesException.IllegalBuffer);
		}
 
		// receiveid不相同的情况
		System.out.println("------ from_receiveid="+from_receiveid+", receiveid="+receiveid);
		if (!from_receiveid.equals(receiveid)) {
			throw new AesException(AesException.ValidateCorpidError);
		}
		return xmlContent;
 
	}
 
	/**
	 * 将企业微信回复用户的消息加密打包.
	 * <ol>
	 * 	<li>对要发送的消息进行AES-CBC加密</li>
	 * 	<li>生成安全签名</li>
	 * 	<li>将消息密文和安全签名打包成xml格式</li>
	 * </ol>
	 * 
	 * @param replyMsg 企业微信待回复用户的消息，xml格式的字符串
	 * @param timeStamp 时间戳，可以自己生成，也可以用URL参数的timestamp
	 * @param nonce 随机串，可以自己生成，也可以用URL参数的nonce
	 * 
	 * @return 加密后的可以直接回复用户的密文，包括msg_signature, timestamp, nonce, encrypt的xml格式的字符串
	 * @throws AesException 执行失败，请查看该异常的错误码和具体的错误信息
	 */
	public String EncryptMsg(String replyMsg, String timeStamp, String nonce) throws AesException {
		// 加密
		String encrypt = encrypt(getRandomStr(), replyMsg);
 
		// 生成安全签名
		if (timeStamp == "") {
			timeStamp = Long.toString(System.currentTimeMillis());
		}
 
		String signature = SHA1.getSHA1(token, timeStamp, nonce, encrypt);
 
		// System.out.println("发送给平台的签名是: " + signature[1].toString());
		// 生成发送的xml
		String result = XMLParse.generate(encrypt, signature, timeStamp, nonce);
		System.out.println("call wechat xml message=["+result+"]");
		return result;
	}
 
	/**
	 * 检验消息的真实性，并且获取解密后的明文.
	 * <ol>
	 * 	<li>利用收到的密文生成安全签名，进行签名验证</li>
	 * 	<li>若验证通过，则提取xml中的加密消息</li>
	 * 	<li>对消息进行解密</li>
	 * </ol>
	 * 
	 * @param msgSignature 签名串，对应URL参数的msg_signature
	 * @param timeStamp 时间戳，对应URL参数的timestamp
	 * @param nonce 随机串，对应URL参数的nonce
	 * @param postData 密文，对应POST请求的数据
	 * 
	 * @return 解密后的原文
	 * @throws AesException 执行失败，请查看该异常的错误码和具体的错误信息
	 */
	public String DecryptMsg(String msgSignature, String timeStamp, String nonce, String postData)
			throws AesException {
 
		// 密钥，公众帐号的app secret
		// 提取密文
		Object[] encrypt = XMLParse.extract(postData);
 
		// 验证安全签名
		String signature = SHA1.getSHA1(token, timeStamp, nonce, encrypt[1].toString());
 
		// 和URL中的签名比较是否相等
		// System.out.println("第三方收到URL中的签名：" + msg_sign);
		// System.out.println("第三方校验签名：" + signature);
		if (!signature.equals(msgSignature)) {
			throw new AesException(AesException.ValidateSignatureError);
		}
 
		// 解密
		String result = decrypt(encrypt[1].toString());
		return result;
	}
 
	/**
	 * 验证URL
	 * @param msgSignature 签名串，对应URL参数的msg_signature
	 * @param timeStamp 时间戳，对应URL参数的timestamp
	 * @param nonce 随机串，对应URL参数的nonce
	 * @param echoStr 随机串，对应URL参数的echostr
	 * 
	 * @return 解密之后的echostr
	 * @throws AesException 执行失败，请查看该异常的错误码和具体的错误信息
	 */
	public String VerifyURL(String msgSignature, String timeStamp, String nonce, String echoStr)
			throws AesException {
		String signature = SHA1.getSHA1(token, timeStamp, nonce, echoStr);
		if (!signature.equals(msgSignature)) {
			throw new AesException(AesException.ValidateSignatureError);
		}
		String result = decrypt(echoStr);
		return result;
	}
 
	public String getXmlTextMessage(String FromUserName,String ToUserName, String sendMsgText){
		// 文本消息
		String timestamp = Long.toString(System.currentTimeMillis()/1000L);
		return "<xml>" +
				"  <ToUserName><![CDATA["+FromUserName+"]]></ToUserName>" +
				"  <FromUserName><![CDATA["+ToUserName+"]]></FromUserName>" +
				"  <CreateTime>"+timestamp+"</CreateTime>" +
				"  <MsgType><![CDATA[text]]></MsgType>" +
				"  <Content><![CDATA["+sendMsgText+"]]></Content>" +
				"</xml>";
	}
 
	public String getXmlNewsMessage(String FromUserName,String ToUserName, String Title, String Description, String Url, String PicUrl){
		// 图文消息
		String timestamp = Long.toString(System.currentTimeMillis()/1000L);
		return "<xml>" +
				"  <ToUserName><![CDATA["+FromUserName+"]]></ToUserName>" +
				"  <FromUserName><![CDATA["+ToUserName+"]]></FromUserName>" +
				"  <CreateTime>"+timestamp+"</CreateTime>" +
				"  <MsgType><![CDATA[news]]></MsgType>" +
				"  <Content><![CDATA[]]></Content>" +
				"  <ArticleCount>1</ArticleCount>" +
				"  <Articles>" +
				"  	<item>" +
				"  		<Title><![CDATA["+Title+"]]></Title>" +
				"  		<Description><![CDATA["+Description+"]]></Description>" +
				"  		<Url><![CDATA["+Url+"]]></Url>" +
				"  		<PicUrl><![CDATA["+PicUrl+"]]></PicUrl>" +
				"  	</item>" +
				"  </Articles>" +
				"  <FuncFlag>0</FuncFlag>" +
				"</xml>";
	}
 
}

5、WxUtil.java


package cn.renkai721.util;
 
import org.jdom2.Document;
import org.jdom2.Element;
import org.jdom2.JDOMException;
import org.jdom2.input.SAXBuilder;
 
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.*;
 
public class WxUtil {
    /**
     * 将 Map 转化为 XML
     *
     * @param map
     * @return
     */
    public static String transferMapToXml(SortedMap<String, Object> map) {
        StringBuffer sb = new StringBuffer();
        sb.append("<xml>");
        for (String key : map.keySet()) {
            sb.append("<").append(key).append(">")
                    .append(map.get(key))
                    .append("</").append(key).append(">");
        }
        return sb.append("</xml>").toString();
    }
 
    /**
     * 将 XML 转化为 map
     *
     * @param strxml
     * @return
     * @throws IOException
     */
    public static Map transferXmlToMap(String strxml) throws IOException {
        strxml = strxml.replaceFirst("encoding=\".*\"", "encoding=\"UTF-8\"");
        if (null == strxml || "".equals(strxml)) {
            return null;
        }
        Map m = new HashMap();
        InputStream in = new ByteArrayInputStream(strxml.getBytes("UTF-8"));
        SAXBuilder builder = new SAXBuilder();
        Document doc = null;
        try {
            doc = builder.build(in);
        } catch (JDOMException e) {
            throw new IOException(e.getMessage()); // 统一转化为 IO 异常输出
        }
        // 解析 DOM
        Element root = doc.getRootElement();
        List list = root.getChildren();
        Iterator it = list.iterator();
        while (it.hasNext()) {
            Element e = (Element) it.next();
            String k = e.getName();
            String v = "";
            List children = e.getChildren();
            if (children.isEmpty()) {
                v = e.getTextNormalize();
            } else {
                v = getChildrenText(children);
            }
            m.put(k, v);
        }
        //关闭流
        in.close();
        return m;
    }
 
    // 辅助 transferXmlToMap 方法递归提取子节点数据
    private static String getChildrenText(List<Element> children) {
        StringBuffer sb = new StringBuffer();
        if (!children.isEmpty()) {
            Iterator<Element> it = children.iterator();
            while (it.hasNext()) {
                Element e = (Element) it.next();
                String name = e.getName();
                String value = e.getTextNormalize();
                List<Element> list = e.getChildren();
                sb.append("<" + name + ">");
                if (!list.isEmpty()) {
                    sb.append(getChildrenText(list));
                }
                sb.append(value);
                sb.append("</" + name + ">");
            }
        }
        return sb.toString();
    }
}

6、XmlUtil.java


package cn.renkai721.util;
 
import javax.xml.bind.JAXBContext;
import javax.xml.bind.Unmarshaller;
import java.io.StringReader;
 
 
public class XmlUtil {
 
 
        /**
         * 解析XMl内容，转换为POJO类
         *
         * @param clazz 要解析的对象
         * @param xml 解析的xml字符串
         * @return 解析完成的对象
         */
        public static Object xmlStrToObject(Class clazz, String xml) {
            Object xmlObject = null;
            try {
                JAXBContext context = JAXBContext.newInstance(clazz);
                // 进行将Xml转成对象的核心接口
                Unmarshaller unmarshaller = context.createUnmarshaller();
                StringReader sr = new StringReader(xml);
                xmlObject = unmarshaller.unmarshal(sr);
            } catch (Exception e) {
                e.printStackTrace();
            }
            return xmlObject;
        }
 
 
}

7、AesException.java


package cn.renkai721.wechataes;
 
@SuppressWarnings("serial")
public class AesException extends Exception {
 
	public final static int OK = 0;
	public final static int ValidateSignatureError = -40001;
	public final static int ParseXmlError = -40002;
	public final static int ComputeSignatureError = -40003;
	public final static int IllegalAesKey = -40004;
	public final static int ValidateCorpidError = -40005;
	public final static int EncryptAESError = -40006;
	public final static int DecryptAESError = -40007;
	public final static int IllegalBuffer = -40008;
	//public final static int EncodeBase64Error = -40009;
	//public final static int DecodeBase64Error = -40010;
	//public final static int GenReturnXmlError = -40011;
 
	private int code;
 
	private static String getMessage(int code) {
		switch (code) {
		case ValidateSignatureError:
			return "签名验证错误";
		case ParseXmlError:
			return "xml解析失败";
		case ComputeSignatureError:
			return "sha加密生成签名失败";
		case IllegalAesKey:
			return "SymmetricKey非法";
		case ValidateCorpidError:
			return "corpid校验失败";
		case EncryptAESError:
			return "aes加密失败";
		case DecryptAESError:
			return "aes解密失败";
		case IllegalBuffer:
			return "解密后得到的buffer非法";
//		case EncodeBase64Error:
//			return "base64加密错误";
//		case DecodeBase64Error:
//			return "base64解密错误";
//		case GenReturnXmlError:
//			return "xml生成失败";
		default:
			return null; // cannot be
		}
	}
 
	public int getCode() {
		return code;
	}
 
	AesException(int code) {
		super(getMessage(code));
		this.code = code;
	}
 
}

8、ByteGroup.java


package cn.renkai721.wechataes;
 
import java.util.ArrayList;
 
public class ByteGroup {
	ArrayList<Byte> byteContainer = new ArrayList<Byte>();
 
	public byte[] toBytes() {
		byte[] bytes = new byte[byteContainer.size()];
		for (int i = 0; i < byteContainer.size(); i++) {
			bytes[i] = byteContainer.get(i);
		}
		return bytes;
	}
 
	public ByteGroup addBytes(byte[] bytes) {
		for (byte b : bytes) {
			byteContainer.add(b);
		}
		return this;
	}
 
	public int size() {
		return byteContainer.size();
	}
}

9、D3fService.java


package cn.renkai721.biz;
 
import cn.renkai721.bean.*;
import cn.renkai721.configuration.QywxProperties;
import cn.renkai721.util.HttpUtil;
import cn.renkai721.util.MsgUtil;
import com.alibaba.druid.util.StringUtils;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;
import org.redisson.api.RBucket;
import org.redisson.api.RedissonClient;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Component;
import org.springframework.web.client.RestTemplate;
 
import javax.annotation.Resource;
import java.util.*;
import java.util.concurrent.TimeUnit;
 
 
@Slf4j
@Component
public class D3fBiz {
 
	@Resource
	private RedissonClient redissonClient;
	@Resource
	private RestTemplate restTemplate;
 
	public String get_suite_ticket(){
		return get_suite_ticket;
	}
 
	public String get_suite_access_token(){
		RBucket<String> idBucket = redissonClient.getBucket(QywxProperties.suite_access_token_key);
		
		return suite_access_token;
	}
 
	public String get_access_token(String corpId){
		String suite_access_token = this.get_suite_access_token();
		RBucket<String> idBucket = redissonClient.getBucket(QywxProperties.corpId_suiteId_agentId+"_"+corpId);
		return access_token;
	}
 
 
	public void sendD3fTextMsg(String corpId, String toUser, String message){
		log.info("sendD3fTextMsg corpId={},toUser={},message={}"
				,corpId,toUser,message);
	}
 
	public void sendD3fNewsMsg(String corpId, String toUser, String Title,
							   String Description, String Url, String PicUrl){
		log.info("sendD3fNewsMsg corpId={},toUser={},Title={},Description={},Url={},PicUrl={},"
				,corpId,toUser,Title,Description,Url,PicUrl);
		log.info("sendNewsMsg body={},",jsonObject);
	}
 
	public void sendMarkdownMsg(String corpId,String toUser,String message) {
		log.info("sendMarkdownMsg corpId={},toUser={},message={}"
				,corpId,toUser,message);
	}
 
}

10、开发代码测试的时候，记得把服务器IP添加到白名单，使用管理员登录服务商后台，点击企业信息，然后输入IP。

第四章应用上架

1、开发结束后，登录到企业服务商管理后台，普通的管理员也可以操作。

2、【应用和模板上线】-【提交上线】-选一个要上线的应用-【确定】。

3、如果失败了，服务商后台的消息会收到通知，成功也会收到通知。

4、上线成功后，可以设置应用市场可搜索的配置，发布上线还是要填写一些东西，包括图片，需要美工制作专门格式的图片才可以。

第五章企微官方接口及其它参考文章

企业微信服务商-开发前必读 - 接口文档https://developer.work.weixin.qq.com/document/path/91201 企微服务商平台收费接口对接教程_renkai721的博客-CSDN博客_企微服务商前言1、以前的流程是用户添加第三方应用，然后登录，然后操作。2、现在的流程是用户添加第三方应用，然后服务商购买账号，服务商在用户添加第三方应用时或用户登录时或接收到【unlicensed_notify】接口许可失效通知时，授权激活该用户，然后用户登录，然后操作。企微官方文档面向服务商进行平台收费模式调整的说明平台接口许可付费企微服务商后台管理操作教程1、用户在企微应用市场搜索服务商开发的第3方应用，假如应用名字【天气助手】。然后点击安装。2、这时候服务商的后台服务会收到腾讯服https://blog.csdn.net/renkai721/article/details/124970456 解读：企微面向服务商进行平台收费模式调整的说明_renkai721的博客-CSDN博客前言1、以前的流程是用户添加第三方应用，然后登录，然后操作。2、现在是服务商购买账号，服务商在用户添加第三方应用时或用户登录时授权激活该用户，然后用户登录，然后操作。企微官方文档面向服务商进行平台收费模式调整的说明平台接口许可付费一、如果不购买【基础帐号】，那么【身份验证】【小程序登录】【发送应用消息】这3个接口无法调用。表现出来的场景为：1、第三方应用和小程序的用户是无法登录的。2、也不能调用接口API发送消息给用户。二、如果不购买【互通帐号】，那么【获取.https://blog.csdn.net/renkai721/article/details/124675211

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小蓝xlanll/article/detail/617214

企业微信第三方服务商应用开发及上架教程_企业微信第三方应用开发教程

第一章 服务商入驻

第二章 应用配置

第三章 应用开发

第四章 应用上架

第五章 企微官方接口及其它参考文章

第一章服务商入驻

第二章应用配置

第三章应用开发

第四章应用上架

第五章企微官方接口及其它参考文章