应用后端如何请求Coze工作流

ouyangyifei1991

已于 2025-03-26 17:40:59 修改

阅读量293

点赞数 5

分类专栏：技术文章标签：服务器 java spring boot 人工智能

于 2025-03-20 21:35:37 首次发布

本文链接：https://blog.csdn.net/ouyangyifei1991/article/details/146405645

版权

技术专栏收录该内容

3 篇文章

订阅专栏

Coze官网地址：

扣子，应该还是要注册一下的。

如何创建自己的工作流呢？

工作流创建

点击【+资源】的时候记得选择工作流选项，建好你的工作流，保存并发布后就在列表里啦；

注意：这个有个重要参数，我们需要得到这个【工作流的Id】workFlowId，直接点击这个工作流进去，浏览器url后面的workflow_id参数就是，，如下：

问题来了，在coze建好了工作流，怎么让我们自己的应用接进来呢？

不急，还需要授权，去创建一个OAuth应用吧。

OAuth应用创建

如下，新建一个你自己的oauth应用，记得客户端类型一定是选择【服务类应用】；

在创建过程中，需要【创建key】，创建key的时候会生成一个【公钥指纹】publicKeyZW，还会自动下载一个 private.key.pem文件，打开private.key.pem文件，获取到用于RSA加密的【加密私钥】privateKey。保存完成后，OAuth应用列表显示的【应用Id】clientId 请记下他们

截至现在，我们已经收集到4个参数啦；分别是

【工作流的Id】workFlowId 【公钥指纹】publicKeyZW

【加密私钥】privateKey 【应用Id】clientId

搞了半天了，还没说应用要怎么才能用上这个工作流呢？

下面就是用代码去请求coze工作流的保姆级教程啦！！！

代码环节

下面开始进入codeing环节：

由于coze需要用到jwt鉴权，果断引入jwt包：

  <dependency>
      <groupId>io.jsonwebtoken</groupId>
      <artifactId>jjwt</artifactId>
      <version>0.7.0</version>
  </dependency>

获取JwtToken方法，JwtUtils类

public class JwtUtils {

    public static String getJwtTokenByRS256(Map<String,Object> header, Object payload, String privateKey) {
        try {
            PrivateKey rsaPrivateKey = getPrivateKey(privateKey);
            return Jwts.builder()
                    .setHeader(header)
                    .setPayload(JSON.toJSONString(payload))
                    .signWith(SignatureAlgorithm.RS256, rsaPrivateKey).compact();
        }catch (Exception e){
            e.printStackTrace();
        }
        return "";
    }

    public static PrivateKey getPrivateKey(String key) throws Exception {
        byte[] keyBytes = Base64.getDecoder().decode(key);
        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        PrivateKey privateKey = keyFactory.generatePrivate(keySpec);
        return privateKey;
    }

}

Coze的请求头都长的差不多，封装一下吧：

public class CozeUtils {

    public static Map<String,String> authHeader(String token){
        Map<String,String> header = new HashMap<>(2);
        header.put("Authorization","Bearer "+token);
        return header;
    }

}

获取Coze，accessToken的关键类，包含获取token需要的参数和获取的具体方法：


public class CozeOauth2 {

    public Map<String,Long> tokenCache = new HashMap<>();
    /**
     * 获取 coze AccessToken 地址
     */
    private String cozeTokenUrl = "https://api.coze.cn/api/permission/oauth2/token";
    /**
     * 公钥指纹，在创建应用时获取
     */
    private String publicKeyZw;
    /**
     * 应用列表第一列值
     */
    private String clientId;
    /**
     * 创建应用时，生成公钥私钥时会下载
     */
    private String rsaPrivateKey;
    /**
     * 自定义token过期时间，单位：秒
     */
    private Integer expire;

    private Map<String,Object> params = new HashMap<>(4);

    public CozeOauth2() {
        // 这个是固定参数，coze要求这么写
        addParams("grant_type","urn:ietf:params:oauth:grant-type:jwt-bearer");
    }

    public CozeOauth2(String clientId, String publicKeyZw, String rsaPrivateKey) {
        addParams("grant_type","urn:ietf:params:oauth:grant-type:jwt-bearer");
        this.publicKeyZw = publicKeyZw;
        this.clientId = clientId;
        this.rsaPrivateKey = rsaPrivateKey;
    }

    public CozeOauth2(String publicKeyZw, String clientId, String rsaPrivateKey, Integer expire) {
        this.publicKeyZw = publicKeyZw;
        this.clientId = clientId;
        this.rsaPrivateKey = rsaPrivateKey;
        this.expire = expire;
        addParams("grant_type","urn:ietf:params:oauth:grant-type:jwt-bearer");
        addParams("duration_seconds",this.expire);
    }

    public String getCozeTokenUrl() {
        return cozeTokenUrl;
    }

    public void setCozeTokenUrl(String cozeTokenUrl) {
        this.cozeTokenUrl = cozeTokenUrl;
    }

    public String getPublicKeyZw() {
        return publicKeyZw;
    }

    public void setPublicKeyZw(String publicKeyZw) {
        this.publicKeyZw = publicKeyZw;
    }

    public String getClientId() {
        return clientId;
    }

    public void setClientId(String clientId) {
        this.clientId = clientId;
    }

    public String getRsaPrivateKey() {
        return rsaPrivateKey;
    }

    public void setRsaPrivateKey(String rsaPrivateKey) {
        this.rsaPrivateKey = rsaPrivateKey;
    }

    public Integer getExpire() {
        return expire;
    }

    public void setExpire(Integer expire) {
        this.expire = expire;
        addParams("duration_seconds",this.expire);
    }

    public void addParams(String key,Object val){
        params.put(key,val);
    }


    public String getAccessToken(){
        String jwtToken = JwtUtils.getJwtTokenByRS256(header(this.publicKeyZw),payload(this.clientId),this.rsaPrivateKey);
        String result = HttpUtils.sendJsonPost(this.cozeTokenUrl, this.params, CozeUtils.authHeader(jwtToken));
        JSONObject jsonObject = JSONObject.parseObject(result);
        return jsonObject.getString("access_token");

    }

   
    private static Map header(String pubKeyZw){
        Map<String,String> header = new HashMap<>(4);
        header.put("alg","RS256");
        header.put("typ","JWT");
        header.put("kid",pubKeyZw);
        return header;
    }

    private static Map<String,Object> payload(String clientId){
        Map<String,Object> payload = new HashMap<>();
        payload.put("iss",clientId);
        payload.put("aud","api.coze.cn");
        payload.put("iat",(int) (System.currentTimeMillis()/1000));
        payload.put("exp",(int) ((System.currentTimeMillis()+3600000)/1000));
        payload.put("jti",System.currentTimeMillis()+"");
        return payload;
    }

}

访问coze工作流需要的参数：

public class WorkFlowParams {
    private String  workflow_id;

    private Map<String,Object> parameters = new HashMap<>();


    public WorkFlowParams(String workflowId) {
        this.workflow_id = workflowId;
    }

    public String getWorkflow_id() {
        return workflow_id;
    }

    public void setWorkflow_id(String workflow_id) {
        this.workflow_id = workflow_id;
    }

    public Map<String, Object> getParameters() {
        return parameters;
    }

    public void setParameters(Map<String, Object> parameters) {
        this.parameters = parameters;
    }

    public void addParams(String key,Object val){
        parameters.put(key,val);
    }
}

访问coze工作流的类，

public class CozeWorkFlow {
    /**
     * coze 工作流访问基础路径
     */
    private String cozeWFBaseUrl = "https://api.coze.cn/v1/workflow/run";

    private CozeOauth2 cozeOauth2;

    public CozeWorkFlow() {
    }


    public CozeWorkFlow(String cozeWFBaseUrl, CozeOauth2 cozeOauth2) {
        this.cozeWFBaseUrl = cozeWFBaseUrl;
        this.cozeOauth2 = cozeOauth2;
    }
    public CozeWorkFlow(CozeOauth2 cozeOauth2) {
        this.cozeOauth2 = cozeOauth2;
    }
    public String getCozeWFBaseUrl() {
        return cozeWFBaseUrl;
    }

    public void setCozeWFBaseUrl(String cozeWFBaseUrl) {

        this.cozeWFBaseUrl = cozeWFBaseUrl;
    }

    public CozeOauth2 getCozeToken() {
        return cozeOauth2;
    }

    public void setCozeToken(CozeOauth2 cozeOauth2) {
        this.cozeOauth2 = cozeOauth2;
    }

    public String execute(WorkFlowParams params){
        String token = cozeOauth2.getAccessToken();
        String result = HttpUtils.sendJsonPost(this.cozeWFBaseUrl, params, CozeUtils.authHeader(token));
        return result;
    }
}

好了，编码完成;

下面写一个测试类：

public class CozeWorkFlowTest {
    static String workFlowId = "748******************4299";

    // 公钥指纹，在扣子应用配置中有，应用创建要选服务类应用
    static String publicKeyZW = "esAd5*********************_7NE";

    // 应用id，应用列表显示的第一列就是
    static  String  clientId="117*****623";

    // 私钥，在配置服务类应用，配置生成密钥时会自动下载。
    static String privateKey = "MIIEvQIBADA**********4mPb7C7rwKBgBo+Q3LydqYlIb6i******HkO5/F3Ab8H2k+/1yeboKc6NxYFmnh2*****JGLcwbUc=";

    static String tokenUrl = "https://api.coze.cn/api/permission/oauth2/token";
    public static void main(String[] args) {

        WorkFlowParams wfParmas = new WorkFlowParams(workFlowId);
        // 添加工作流定义的入参
        wfParmas.addParams("filePath","*******************");
        wfParmas.addParams("code","********************");
        wfParmas.addParams("attr","*********************");
        
        // 把从coze获取来的参数填进来，去获取一个请求token
        CozeOauth2 cozeOauth2 = new CozeOauth2(clientId,publicKeyZW,privateKey);
        cozeOauth2.setExpire(900);
        CozeWorkFlow workFlow = new CozeWorkFlow(cozeOauth2);
        // 请求执行工作流，最后打印 一下结果
        String execute = workFlow.execute(wfParmas);
        System.out.println(execute);
    }
}

完结！！