Java连接Dynamics 365 CRM并请求数据，通过Oauth2.0认证

最新推荐文章于 2022-12-28 16:23:04 发布
最新推荐文章于 2022-12-28 16:23:04 发布
阅读量376 收藏 1
点赞数
分类专栏： Dynamics 365(online) 文章标签： intellij-idea
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44136823/article/details/119873419
版权 
import com.microsoft.aad.adal4j.AuthenticationResult;
import com.microsoft.aad.adal4j.AuthenticationContext;
import io.vertx.core.json.JsonObject;
import netscape.javascript.JSObject;


import org.apache.http.HttpResponse;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.protocol.HTTP;
import org.apache.http.util.EntityUtils;
import org.apache.olingo.client.api.ODataClient;
import org.apache.olingo.client.api.ODataClientBuilder;
import org.apache.olingo.client.api.domain.ClientEntity;
import org.apache.olingo.client.api.domain.ClientEntitySet;
import org.apache.olingo.client.api.domain.ClientProperty;
import org.apache.olingo.client.core.ODataClientFactory;
import org.apache.olingo.client.core.http.HttpPatch;
import org.apache.olingo.commons.api.format.ContentType;
import org.springframework.security.oauth2.client.DefaultOAuth2ClientContext;
import org.springframework.security.oauth2.client.OAuth2ClientContext;
import org.springframework.security.oauth2.client.OAuth2RestTemplate;
import org.springframework.security.oauth2.client.token.AccessTokenRequest;
import org.springframework.security.oauth2.client.token.DefaultAccessTokenRequest;
import org.springframework.security.oauth2.client.token.grant.password.ResourceOwnerPasswordResourceDetails;
import org.springframework.security.oauth2.common.OAuth2AccessToken;

import java.io.*;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.*;
import java.util.zip.GZIPInputStream;


public class demo {

    private HttpURLConnection urlConnection =null;
    public  demo()
    {

    }
    public static void main(String[] args) throws Exception {
        System.out.println("Hello World!");

        String _token = GetDynamics365Token();// getToken().getAccessToken().toString();

        System.out.println(_token);

         //String ret = GetAccount(_token);
        // testcreateContact(_token);
        // testGetContact(_token);
         testupdateContact(_token);
    }
    private  static  void testupdateContact(String _token)
    {
        String api = APIUrl+"procontacts"+"(1948d283-a404-ec11-b6e6-000d3aa2e3d2)";


        JsonObject json = new JsonObject();
        json.put("name","tested by JAVA API(Data patch)");
        json.put("phone","18824158458_patch");
        json.put("email","7874108@qq.com_patch");
        json.put("fullname","fullname test of java call api");
        json.put("contactid@odata.bind","/contacts(40a42e1b-9900-ec11-94ef-00224858241d)");



        //String b = HttpUtil.doPostToJson(api,json.toString(),_token,"Patch");
        String b = HttpPatch(api,_token,json);
        if(String.valueOf(b).contains("No-Content"))
        {
            System.out.println("Updated.");
        }

    }
    /**
     * patch请求
     *author：fantabulous24
     * @date 2020年7月9日 下午3:24:50
     */
    public static String HttpPatch(String url,String _token,JsonObject json) {
       String  resultObj = null;

        HttpClient httpClient = new DefaultHttpClient();
        HttpPatch httpPatch = new HttpPatch(url);
        httpPatch.setHeader("Content-type", "application/json");
        httpPatch.setHeader("Charset", HTTP.UTF_8);
        httpPatch.setHeader("Accept", "application/json");
        httpPatch.setHeader("Accept-Charset", HTTP.UTF_8);
        httpPatch.setHeader("Authorization","Bearer "+_token);
        try {
            StringEntity entity=null;
            if(json !=null)
            {
               entity = new StringEntity(json.toString(),StandardCharsets.UTF_8);
            }
            else
            {
                return  "";
            }

            httpPatch.setEntity(entity);
            HttpResponse response = httpClient.execute(httpPatch);

            resultObj = response.toString();

        } catch (IOException e) {
            e.printStackTrace();
        }
        return resultObj;
    }

    private  static void testcreateContact(String _token) throws Exception {

        String api = APIUrl+"procontacts";
        JsonObject json = new JsonObject();
        json.put("name","tested by JAVA API");
        json.put("phone","18824158458");
        json.put("email","7874108@qq.com");


       String a =  HttpUtil.doPostToJson(api,json.toString(),_token,"POST");

       if(a=="")
       {
           System.out.println("Created!");
       }

    }

    private  static void testGetContact(String token) throws Exception {
        String ret = null;

        String queryurl = APIUrl + "procontacts?$select=procontactid,email,phone,name,createdon&$top=3";

        ret = HttpUtil.doPostToJson(queryurl,null,token,"GET");

        System.out.println(ret);

    }

        private  static String GetAccount(String token) throws Exception {
        String ret =null;
        HttpURLConnection connection =null;
        String queryurl = APIUrl+ "accounts?$select=accountid,accountnumber,createdon,telephone1&$top=3";
        URL url = new URL(queryurl);

        connection = buildConnection(url,token,"GET");

        int res = connection.getResponseCode();

        if(res==200)
        {

            ClientEntitySet odataEntitySet = GetConnectionResult(connection);

            for (ClientEntity odataEntity: odataEntitySet.getEntities())
            {
                for (ClientProperty curProperty: odataEntity.getProperties())
                {
                    String propertyContent = curProperty.getName()+":"+curProperty.getValue().toString();
                    ret += propertyContent +"\n";
                    System.out.println(propertyContent);
                }
            }
        }

        return ret;
    }

    private static ClientEntitySet GetConnectionResult(HttpURLConnection conn) throws Exception {

        ODataClient client = ODataClientFactory.getClient();

        String jsonObject =null;
        if("gzip".equals(conn.getContentEncoding()))
        {
            Reader reader = new InputStreamReader(new GZIPInputStream(conn.getInputStream()));

            String jsonRawOutput ="";
            while (true)
            {
                int ch = reader.read();

                if(ch==1)
                {
                    break;
                }
                jsonRawOutput += (char)ch;
            }
            jsonObject = jsonRawOutput;
        }
        else
        {
            BufferedReader in = new BufferedReader(new InputStreamReader(conn.getInputStream()));
            String jsonoutput ="";
            while (true)
            {
                int ch = in.read();
                if(ch==-1)
                {
                    break;
                }
                jsonoutput += (char)ch;
            }
            jsonObject = jsonoutput;
        }

        InputStream inputStream = new ByteArrayInputStream(jsonObject.getBytes(StandardCharsets.UTF_8));

        return client.getReader().readEntitySet(inputStream, ContentType.APPLICATION_JSON);
    }

    private  static HttpURLConnection buildConnection( URL _url,String _token,String _RequestMethod ) throws Exception {

        if(_RequestMethod.trim()=="")
        {
            return  null;
        }
        HttpURLConnection _connect = (HttpURLConnection) _url.openConnection();
        _connect.setRequestMethod(_RequestMethod);

        _connect.setRequestProperty("OData-MaxVersion","4.0");
        _connect.setRequestProperty("OData-Version","4.0");
        _connect.setRequestProperty("Accept","application/json");
        _connect.setRequestProperty("Content-Type","application/json");
        _connect.setRequestProperty("Prefer","odata.include-annotations=OData.Community.Display.V1.FormattedValue");
       // _connect.setRequestProperty("Prefer","odata.include-annotations=\\\"Microsoft.Dynamics.CRM.fetchxmlpagingcookie\\");
        _connect.setRequestProperty("Authorization","Bearer "+_token);
        _connect.connect();

        return  _connect;

    }

    private static String tokenUrl = "https://login.microsoftonline.com/common/oauth2/token";
    private static String resource = "https://url.crm5.dynamics.com";
    private static String clientId ="xxxxxxx-e055-4f71-b3c0-xxxxxxxf3";
    private static String username = "youraccount of CLOUD.onmicrosoft.com";
    private static String password = "pwd";
    private static String APIUrl = "https://youraddress.crm5.dynamics.com/api/data/v9.0/";

    private  static  AuthenticationResult getToken() {
        AuthenticationResult token = null;
        AuthenticationContext context = null;
        ExecutorService service = null;
        try
        {
           service = Executors.newFixedThreadPool(1);
           context = new AuthenticationContext(tokenUrl,false,service);
            Future<AuthenticationResult> async = context.acquireToken(resource,clientId,username,password,null);
           token = async.get();

        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        finally {
            service.shutdown();
        }
        return token;
    }

    private static String GetDynamics365Token() throws Exception    {
        String token ="";
        String tokenUrl = "https://login.microsoftonline.com/common/oauth2/token";
        String resource = "https://youaddress.crm5.dynamics.com";
        String clientId ="a0717f72-235-4f71-xxxxx-9cxxxxxx7af3";
        String username = "yourcLOUD.onmicrosoft.com";
        String password = "your password";
        ResourceOwnerPasswordResourceDetails resourceDetails = new ResourceOwnerPasswordResourceDetails();

        resourceDetails.setAccessTokenUri(tokenUrl);
        resourceDetails.setId(clientId);
        Map<String, List<String>> HeadersMap = new HashMap<String,List<String>>();
        HeadersMap.put("Cache-Control", Arrays.asList("no-cache"));
        HeadersMap.put("Content-Type",Arrays.asList("application/x-www-form-urlencoded"));

        AccessTokenRequest atr = new DefaultAccessTokenRequest();
        resourceDetails.setGrantType("password");

        atr.add("Bearer Token","Access_Token");
        atr.add("Client_Id",clientId);
        atr.add("Version","v9.0");
        atr.add("resource",resource);
        atr.add("username",username);
        atr.add("password",password);

        OAuth2ClientContext context = new DefaultOAuth2ClientContext(atr);
        OAuth2RestTemplate template = new OAuth2RestTemplate(resourceDetails,context);

        OAuth2AccessToken _token = template.getAccessToken();

        token = _token.toString();

        return token;
    }
}
/*
另一个封装好的Get, Post类
*/
import io.vertx.core.json.JsonObject;
import org.apache.http.impl.client.DefaultHttpClient;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.http.HttpClient;
import java.security.SecureRandom;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.Map;

import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSession;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;

public class HttpUtil
{
    public static String doPostToJson(String urlPath, String Json,String _token,String HttpMethod) {

        String result = "";
        BufferedReader reader = null;
        HttpURLConnection conn = null;
        try {
            trustAllHosts();
            URL url = new URL(urlPath);
            if (url.getProtocol().toLowerCase().equals("https")) {
                HttpsURLConnection httpsConn = (HttpsURLConnection) url.openConnection();
                httpsConn.setHostnameVerifier(DO_NOT_VERIFY);
                conn = httpsConn;
            }
            else {
                conn = (HttpURLConnection) url.openConnection();
            }

            if(HttpMethod !=null)
            {
                conn.setRequestMethod(HttpMethod);
            }
            else {
                conn.setRequestMethod("POST");
            }
            conn.setDoOutput(true);
            conn.setDoInput(true);
            conn.setUseCaches(false);
            conn.setRequestProperty("Connection", "Keep-Alive");
            conn.setRequestProperty("Charset", "UTF-8");
            conn.setRequestProperty("Content-Type", "application/json; charset=UTF-8");
            // conn.setRequestProperty("accept","*/*");
            conn.setRequestProperty("accept", "application/json");
            conn.setRequestProperty("Authorization","Bearer "+_token);
            if (Json != null) {
                byte[] writebytes = Json.getBytes();
                conn.setRequestProperty("Content-Length", String.valueOf(writebytes.length));
                OutputStream outwritestream = conn.getOutputStream();
                outwritestream.write(Json.getBytes());
                outwritestream.flush();
                outwritestream.close();
            }

            if (conn.getResponseCode() == 200) {
                reader = new BufferedReader(new InputStreamReader(conn.getInputStream(), "utf-8"));
                result = reader.readLine();
            }
            else if(conn.getResponseCode() == 204)
            {
                reader = new BufferedReader(new InputStreamReader(conn.getInputStream(), "utf-8"));
                result = reader.readLine();
            }
        }
        catch (Exception e) {
            e.printStackTrace();
        }
        finally {
            if (reader != null) {
                try {
                    reader.close();
                }
                catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return result;
    }

    final static HostnameVerifier DO_NOT_VERIFY = new HostnameVerifier()
    {
        public boolean verify(String arg0, SSLSession arg1) {
            return true;
        }
    };

    public static void trustAllHosts() {
        TrustManager[] trustAllCerts = new TrustManager[] {new X509TrustManager()
        {

            public X509Certificate[] getAcceptedIssuers() {
                return new X509Certificate[] {};
            }

            public void checkServerTrusted(X509Certificate[] arg0, String arg1) throws CertificateException {

            }

            public void checkClientTrusted(X509Certificate[] arg0, String arg1) throws CertificateException {

            }
        }

        };

        try {
            SSLContext sc = SSLContext.getInstance("TLS");
            sc.init(null, trustAllCerts, new SecureRandom());
            HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());
        }
        catch (Exception e) {
            e.printStackTrace();
        }

    }


}

在工程的POM.XML中需引入下列依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>CRM_DEMO</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>Jar_last</module>
    </modules>

    <properties>
        <maven.compiler.source>16</maven.compiler.source>
        <maven.compiler.target>16</maven.compiler.target>
    </properties>
    <dependencies>
        <dependency>
            <groupId>commons-httpclient</groupId>
            <artifactId>commons-httpclient</artifactId>
            <version>3.1</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.security.oauth</groupId>
            <artifactId>spring-security-oauth2</artifactId>
            <version>2.3.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>io.vertx</groupId>
            <artifactId>vertx-core</artifactId>
            <version>4.1.0</version>
        </dependency>
        <dependency>
            <groupId>org.apache.olingo</groupId>
            <artifactId>odata-client-api</artifactId>
            <version>4.5.0</version>
        </dependency>
        <dependency>
            <groupId>org.apache.olingo</groupId>
            <artifactId>odata-client-core</artifactId>
            <version>4.5.0</version>
        </dependency>
        <dependency>
            <groupId>org.apache.olingo</groupId>
            <artifactId>odata-commons-core</artifactId>
            <version>4.5.0</version>
        </dependency>
        <dependency>
            <groupId>org.apache.olingo</groupId>
            <artifactId>odata-commons-api</artifactId>
            <version>4.5.0</version>
        </dependency>
        <dependency>
            <groupId>org.mortbay.jetty</groupId>
            <artifactId>jetty-util</artifactId>
            <version>6.1.25</version>
        </dependency>


    </dependencies>
</project>

测试结果如下，能正常输出
在这里插入图片描述

Fei-AX&CRM
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
Java的oauth2.0 服务端与客户端的实现 （完整源码、demo）
09-14
Java的oauth2.0 服务端与客户端的实现.zip 封装了oauth2.0的基本架构和实现，对照我的博客http://blog.csdn.net/jing12062011/article/details/78147306使用该源码。 下载项目压缩包，解压，里面两个maven项目：...
JavaMail连接Office 365使用XOAUTH2身份认证
Fanor_的博客
09-30 4656
JavaMail实现 OAuth 2.0 身份验证、弃用 Exchange Online 中的基本身份验证、连接Office365使用XOAUTH2身份认证
ews java + Oauth2实现office 365发送邮件
zyjlovehjl的博客
12-28 4795
最新推荐是使用Oauth令牌验证access,进行邮箱服务，可参考官网https://learn.microsoft.com/en-us/exchange/client-developer/exchange-web-services/how-to-authenticate-an-ews-application-by-using-oauth。第一步注册应用，获得client_id, tenant_id 和client_secret.第二步，获取token.
Dynamics 365 组织服务空问题?在Azure Active Directory配置应用授予相关权限配置步骤,OAuth认证方式连接Dynamics 365-online
Little Monkey的博客
11-18 708
在Azure Active Directory配置应用授予Microsoft Graph中User.Read.All权限配置步骤OAuth认证方式连接Dynamics 365 在做Dynamics 365 online项目的过程中，也是踩过了很多的坑，这个坑还是比较重要，所以想分享出来，供大家参考，也是给坑提供一个可以解决的方法。 目录在Azure Active Directory配置应用授予Microsoft Graph中User.Read.All权限配置步骤OAuth认证方式连接Dynamics 365
配置Postman通过OAuth 2 implicit grant获取Dynamics 365 CE Online实例的Access Token
qq_35382207的博客
08-28 429
微软动态CRM专家罗勇 ，回复335或者20190516可方便获取本文，同时可以在第一间得到我发布的最新博文信息，follow me. 对于测试Web API, Get 类型，不需要设定特别request header的还好，登录系统后直接在浏览器中即可测试。 但是对于其他请求就不是很好做，本文就是要解决这些问题，环境设置请参考官方文档： Set up a Postman environment，本文还参考了官方文档： Microsoft identity platform and Implic...
Dynamics CRM 配置 OAuth 2.0
weixin_30604651的博客
03-26 301
关注本人微信和易信公众号：微软动态CRM专家罗勇，回复124或者20140324可方便获取本文，同时可以在第一时间得到我发布的最新的博文信息，followme！ 本博文主要参考但不限于如下资料： 1. Post-installation and configuration guidelines for Microsoft Dynamics CRM 2013 2. SDK上 Write...
Dynamics 365Online 使用connection strings连接组织服务
Vic的博客
04-14 2714
虽然web api非常好用，在现实的应用场景中也够用，但还是有场景需要用组织服务，本篇分享下如何利用connection strings来连接dynamics 365online组织服务。    代码很简单，下面的demo中我是获取了下客户的数据string connectionString = "Url=https://contoso.crm.dynamics.com;Username=vic@
Spring Security Oauth2.0认证授权专题
06-19
Spring boot+Spring Security Oauth2.0，Sprint cloud+Spring Security Oauth2集成。四种认证方式。附带有代码，和案例，案例，还有视频链接。我保证看完就回，如果视频链接失效，评论回复我，我单独再给你一份。
webapi基于Owin中间件的oauth2.0身份认证
10-07
基于Owin中间件的OAuth2.0身份认证，文章位置https://blog.csdn.net/u013938578/article/details/82956188
视频配套笔记_Spring Security OAuth2.0认证授权_v1.1.rar
04-30
视频配套笔记_Spring Security OAuth2.0认证授权_v1.1 完整详细 pdf无障碍阅读，代码完整可复制
Dynamics 365Online Server-Side OAuth身份认证
Vic的博客
12-25 3359
在上篇演示了在html页面中通过调用online的OAuth身份验证后再通过web api取10条客户数据并展示，本篇继续讲述如何在server-side程序中调用online的OAuth认证再通过web api取客户数据。 azure的应用程序设置本篇就不做过多说明，可参照上篇,在设置应用程序的类型时有些区别，这里选择的是本机客户端应用程序。 贴上源代...
oauth2 提供的接口/oauth/token，第一个参数是接口Principal，参数的实际类型是UsernamePasswordAuthenticationToken
热门推荐
a469517790的博客
10-31 1万+
最近在看oauth的源码 ，发现TokenEndpoint 这个类里面，/oauth/token 这个接口的第一个请求参数是接口Principal类型，实际上传过来的是UsernamePasswordAuthenticationToken类型，UsernamePasswordAuthenticationToken实现了Principal接口。 那么框架是在哪将请求参数封装成UsernamePa...
Dynamics 365Online V9.0 OAuth认证后调web api报基础连接已关闭的问题
Vic的博客
09-03 623
在3年前我写过一篇博文，介绍在online环境下如何在服务端使用oAuth身份验证拿到token后调用web api,如果你还没操作过并且感兴趣的可以移步之前的博客，关于Azure中的一些操作的设置已经有些许不同，就懒得再去更新截图了， 如发现和你的实际情况有出入，可以查看博文中链接的docs原文。 今天在做一个POC，使用一个最新的9.1版本的Online拿到Token后去调...
SpringSecurity直接用username构造UsernamePasswordAuthenticationToken
十二翼堕落天使
01-08 5571
结论 添加在UsernamePasswordAuthenticationFilter之前的 JWT 过滤器中可以直接用username去构造UsernamePasswordAuthenticationToken： UsernamePasswordAuthenticationToken token = new UsernamePasswordAuthenticationToken(username, null); SecurityContextHolder.getCont
shiro-springmvc-mybatis登录认证 权限控制
MR_wb的博客
07-28 1万+
shiro-springmvc权限控制
Dynamics 365 CRM Online 使用Ribbon Workbench 2016在view或form上添加按钮并实现CURD
weixin_44136823的博客
12-08 2654
目标： Dynamics 365 CRM Online 使用Ribbon Workbench 2016在view或form上方添加按钮并根据View中所选中的记录实现CURD 内容步骤： 1、 安装Ribbon workbench 2016, 可参照官网如何下载与安装 2、 创建供Ribbon workbench 2016所需的solution 3、 使用Ribbon workbench 2016加载并打开solution 4、 在Ribbon workbench 2016界面中添加button 5、
Dynamics 365 CRM (online) 使用WebApi调用全局action（Plugin)执行批量更新操作， 前端JS批量上传记录到CRM中
weixin_44136823的博客
06-16 1643
创建一个action process,如下图，分别有两个inputparameter 和一个outputparameter 2.使用visual studio 2019编写一个plugin dll， 功能是根据电话，邮件，会员编号为查找条件查Contact表，然后更新某一个实体的记录，代码如下 using Microsoft.Xrm.Sdk; using Microsoft.Xrm.Sdk.Query; using System; using System.Linq; namespace APM_P.
在Dynamics 365 CRM 中使用Xrm.WebApi实现增，删，改，查(需V9.0或以上）
weixin_44136823的博客
07-21 1106
增加一条记录 function createAccount() { // collect account data var data = { "name": document.getElementById("txtname").value, "address1_city": document.getElementById("txtcity").value, "telephone1": document.getElementB
java 实现shopify的oauth 2.0认证流程
最新发布
05-11
OAuth 2.0是一种开放标准的协议，用于授权第三方应用程序使用用户在某些网站或服务中的资源，而不必向其提供用户名和密码。Shopify可以使用OAuth 2.0来允许第三方应用程序访问商户的店铺数据。 要实现OAuth 2.0认证流程，我们首先需要在Shopify开发者门户中注册一个应用程序。在注册时，我们需要提供应用程序的名称、URI和回调URL。回调URL是当认证成功时Shopify将重定向到的URL。 为了开始OAuth认证流程，第三方应用程序需要向客户端授权页面发出GET请求，该页面将提示用户允许应用程序访问他们的店铺数据。一旦用户同意授权，Shopify将会重定向回调URL，并附带一个授权码作为查询参数。 下一步，第三方应用程序需要使用授权码向Shopify发送POST请求，以获取访问令牌。访问令牌是用于访问Shopify API的凭证。令牌使用JSON Web Token格式进行编码，并包含有关该令牌的元数据。 获取令牌后，第三方应用程序就可以使用该令牌访问Shopify API并获取所需的数据。如果令牌过期或被撤销，则需要使用刷新令牌获取新令牌。 总之，通过实现OAuth 2.0认证流程，第三方应用程序可以安全地访问Shopify API并获取商户的店铺数据，这为商户提供了更好的业务解决方案。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Fei-AX&CRM

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值