如何将自有应用及Android应用接入Shopify数据库并获取商品列表（需源码）

Hey there! Let's tackle your two Shopify integration questions thoroughly—first covering the general approach for connecting any custom app to Shopify, then diving into the specific Android implementation with working code snippets.

First off, important note: Shopify doesn’t allow direct access to its underlying database for third-party apps. All integrations happen via Shopify’s official APIs (REST or GraphQL), which are designed to safely interact with your store’s data while adhering to Shopify’s security and rate-limiting rules. Here’s the step-by-step process:

• Step 1: Create a Shopify Private/Public App

  1. Log into your Shopify admin dashboard.
  2. Go to Settings > Apps and sales channels > Develop apps > Create an app.
  3. Name your app, assign developer details, and click "Create app".
  4. Under Configuration > Admin API access scopes, enable the permissions your app needs (e.g., read_products for fetching product lists).
  5. Save the scopes, then go to API credentials to get your:
     • API key
     • API password
     • Your store’s domain (e.g., your-store.myshopify.com)

• Step 2: Choose an API Type

  • REST API: Great for straightforward, CRUD operations. Use endpoints like GET /admin/api/{api-version}/products.json to fetch product data.
  • GraphQL API: More flexible for complex queries (you only request the data you need). The endpoint is POST /admin/api/{api-version}/graphql.json.
  • Both APIs require Basic Authentication: Encode your API key:API password string in Base64 and pass it in the Authorization header as Basic {encoded-string}.

For Android, we’ll use Retrofit (a popular HTTP client) to interact with Shopify’s REST API, since it’s easy to set up and integrate with Android’s lifecycle. Here’s the full implementation:

2.1 Project Setup #

First, add these dependencies to your app-level build.gradle (Module) file:

dependencies {
    // Retrofit for API calls
    implementation 'com.squareup.retrofit2:retrofit:2.9.0'
    implementation 'com.squareup.retrofit2:converter-gson:2.9.0'
    // OkHttp for logging (helps debug API requests)
    implementation 'com.squareup.okhttp3:logging-interceptor:4.11.0'
}

2.2 Define API Interface #

Create an interface to map Shopify’s REST endpoints:

import retrofit2.Call
import retrofit2.http.GET
import retrofit2.http.Header
import retrofit2.http.Query

interface ShopifyApiService {
    // Fetch product list with pagination (max 250 items per page)
    @GET("admin/api/2024-07/products.json")
    fun getProducts(
        @Header("Authorization") authHeader: String,
        @Query("limit") limit: Int = 250,
        @Query("page") page: Int = 1
    ): Call<ShopifyProductsResponse>
}

2.3 Data Models (Match Shopify’s JSON Response) #

Create data classes to parse the API response using Gson:

import com.google.gson.annotations.SerializedName

// Top-level response wrapper
data class ShopifyProductsResponse(
    @SerializedName("products") val products: List<ShopifyProduct>
)

// Product data model
data class ShopifyProduct(
    @SerializedName("id") val id: Long,
    @SerializedName("title") val title: String,
    @SerializedName("body_html") val description: String?,
    @SerializedName("vendor") val vendor: String,
    @SerializedName("product_type") val productType: String,
    @SerializedName("images") val images: List<ShopifyProductImage>
)

// Product image model
data class ShopifyProductImage(
    @SerializedName("src") val imageUrl: String
)

2.4 API Client Implementation #

Create a helper class to handle Retrofit initialization, authentication, and API calls:

import android.os.AsyncTask
import okhttp3.OkHttpClient
import okhttp3.logging.HttpLoggingInterceptor
import retrofit2.Retrofit
import retrofit2.converter.gson.GsonConverterFactory
import java.util.Base64

class ShopifyProductClient(
    private val shopDomain: String,
    private val apiKey: String,
    private val apiPassword: String
) {
    private val apiService: ShopifyApiService

    init {
        // Set up logging interceptor to view API requests/responses
        val loggingInterceptor = HttpLoggingInterceptor().apply {
            level = HttpLoggingInterceptor.Level.BODY
        }

        val okHttpClient = OkHttpClient.Builder()
            .addInterceptor(loggingInterceptor)
            .build()

        // Initialize Retrofit
        val retrofit = Retrofit.Builder()
            .baseUrl("https://$shopDomain/")
            .client(okHttpClient)
            .addConverterFactory(GsonConverterFactory.create())
            .build()

        apiService = retrofit.create(ShopifyApiService::class.java)
    }

    // Generate Basic Auth header
    private fun getAuthHeader(): String {
        val credentials = "$apiKey:$apiPassword"
        val encodedCredentials = Base64.getEncoder().encodeToString(credentials.toByteArray())
        return "Basic $encodedCredentials"
    }

    // Fetch products with pagination (uses AsyncTask for simplicity; use Coroutines in production)
    fun fetchProducts(page: Int = 1, callback: (List<ShopifyProduct>?, Throwable?) -> Unit) {
        val call = apiService.getProducts(getAuthHeader(), 250, page)
        AsyncTask.execute {
            try {
                val response = call.execute()
                if (response.isSuccessful) {
                    callback(response.body()?.products, null)
                } else {
                    callback(null, Throwable("Request failed with code: ${response.code()}"))
                }
            } catch (e: Exception) {
                callback(null, e)
            }
        }
    }
}

2.5 Use the Client in an Activity/Fragment #

Here’s how to integrate the client into an Android Activity to fetch and display products:

import android.os.Bundle
import android.widget.Toast
import androidx.appcompat.app.AppCompatActivity

class ProductSyncActivity : AppCompatActivity() {
    private lateinit var shopifyClient: ShopifyProductClient

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_product_sync)

        // Replace these with your actual Shopify credentials
        val shopDomain = "your-store.myshopify.com"
        val apiKey = "your-api-key"
        val apiPassword = "your-api-password"

        shopifyClient = ShopifyProductClient(shopDomain, apiKey, apiPassword)

        // Start fetching first page of products
        fetchProducts(page = 1)
    }

    private fun fetchProducts(page: Int) {
        shopifyClient.fetchProducts(page) { products, error ->
            runOnUiThread {
                when {
                    error != null -> {
                        Toast.makeText(this, "Error: ${error.message}", Toast.LENGTH_SHORT).show()
                    }
                    products != null -> {
                        // Update your UI (e.g., populate a RecyclerView)
                        updateProductList(products)

                        // If we got 250 products, there might be more—fetch next page
                        if (products.size == 250) {
                            fetchProducts(page + 1)
                        }
                    }
                }
            }
        }
    }

    private fun updateProductList(products: List<ShopifyProduct>) {
        // Add your UI update logic here (e.g., RecyclerView adapter)
        products.forEach { product ->
            println("Product: ${product.title} - ${product.vendor}")
        }
    }
}

Key Notes for Production #

• Security: Never hardcode API credentials in your code. Store them securely using Android Keystore or a secure config service.
• API Version: Shopify updates its API every quarter—replace 2024-07 with the latest stable version from Shopify’s docs.
• Background Sync: For regular product syncs, use WorkManager instead of AsyncTask to handle background tasks reliably.
• Rate Limits: Shopify enforces rate limits (2 requests per second for private apps). Add retry logic if you hit limits.

内容的提问来源于stack exchange，提问作者user9045425