หน้านี้มีตัวอย่างไลบรารีของไคลเอ็นต์สำหรับการเข้าถึง Google Health API
Google Health API สร้างขึ้นในรูปแบบ HTTP และ JSON ไคลเอ็นต์ HTTP มาตรฐานต่างๆ จึงส่งคำขอไปยัง API นี้และแยกวิเคราะห์การตอบกลับได้
อย่างไรก็ตาม คุณอาจต้องการใช้ตัวอย่างและดาวน์โหลดไลบรารีของไคลเอ็นต์ที่แสดงที่นี่แทนการสร้างคำขอ HTTP และแยกวิเคราะห์การตอบกลับด้วยตนเอง
Java
- เพิ่มไลบรารีของไคลเอ็นต์ Google API:
- รวมไลบรารีไว้ในโปรเจ็กต์ (ใช้ Maven หรือ Gradle)
- ใช้ขั้นตอน OAuth 2.0:
- ใช้
google-auth-library-javaเพื่อจัดการขั้นตอน OAuth
- ใช้
- ส่งคำขอ API:
- ใช้ไคลเอ็นต์ที่เริ่มต้นแล้วเพื่อส่งคำขอไปยัง Google Health API
import com.google.api.client.auth.oauth2.Credential;
import com.google.api.client.googleapis.auth.oauth2.GoogleAuthorizationCodeFlow;
import com.google.api.client.googleapis.auth.oauth2.GoogleClientSecrets;
import com.google.api.client.googleapis.auth.oauth2.GoogleCredential;
import com.google.api.client.googleapis.javanet.GoogleNetHttpTransport;
import com.google.api.client.http.HttpTransport;
import com.google.api.client.json.JsonFactory;
import com.google.api.client.json.gson.GsonFactory;
import com.google.api.client.util.store.FileDataStoreFactory;
import com.google.api.services.health.v1.Health; // Assuming a generated Google Health API client
import com.google.api.services.health.v1.model.DataResponse; // Example: Response model
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.security.GeneralSecurityException;
import java.util.Collections;
import java.util.List;
import java.util.Objects;
import java.util.Scanner;
public class GoogleHealthApiExample {
private static final String CLIENT_SECRETS_PATH = "path/to/your/client_secret.json";
private static final String TOKENS_DIRECTORY_PATH = "tokens";
private static final String API_KEY = "YOUR_API_KEY";
private static final List<String> SCOPES = Collections.singletonList("https://www.googleapis.com/auth/health");
private static final String APPLICATION_NAME = "Google Health API Example";
private static final String DISCOVERY_URL = "https://health.googleapis.com/$discovery/rest"; // Adjust if needed
private static final JsonFactory JSON_FACTORY = new GsonFactory();
private static FileDataStoreFactory dataStoreFactory;
private static HttpTransport httpTransport;
static {
try {
httpTransport = GoogleNetHttpTransport.newTrustedTransport();
dataStoreFactory = new FileDataStoreFactory(new File(TOKENS_DIRECTORY_PATH));
} catch (GeneralSecurityException | IOException e) {
throw new RuntimeException("Error initializing HttpTransport or DataStoreFactory", e);
}
}
public static void main(String[] args) {
try {
Health healthService = createHealthService();
fetchHealthData(healthService);
} catch (Exception e) {
System.err.println("Error during execution: " + e.getMessage());
e.printStackTrace();
}
}
private static Health createHealthService() throws IOException {
Credential credential = getCredentials();
return new Health.Builder(httpTransport, JSON_FACTORY, credential)
.setApplicationName(APPLICATION_NAME)
.setGoogleClientRequestInitializer(request -> {
request.set("key", API_KEY);
})
.setRootUrl(DISCOVERY_URL)
.build();
}
private static Credential getCredentials() throws IOException {
// Load client secrets
InputStream in = Objects.requireNonNull(GoogleHealthApiExample.class.getClassLoader().getResourceAsStream(CLIENT_SECRETS_PATH),
"client_secret.json not found");
GoogleClientSecrets clientSecrets = GoogleClientSecrets.load(JSON_FACTORY, new InputStreamReader(in));
// Build flow and trigger user authorization request.
GoogleAuthorizationCodeFlow flow = new GoogleAuthorizationCodeFlow.Builder(
httpTransport, JSON_FACTORY, clientSecrets, SCOPES)
.setDataStoreFactory(dataStoreFactory)
.setAccessType("offline") // Allows for refresh tokens
.build();
Credential credential = flow.loadCredential("user"); // "user" is a key for storing/loading credentials.
if (credential == null || !credential.getAccessToken() != null && credential.getExpiresInSeconds() <= 60) {
// Prompt user to authorize and get new credentials
System.out.println("Please open the following URL in your browser and authorize the app:");
System.out.println(flow.newAuthorizationUrl().setRedirectUri("urn:ietf:wg:oauth:2.0:oob").build());
System.out.print("Enter the authorization code: ");
String code = new Scanner(System.in).nextLine();
credential = flow.createAndStoreCredential(
flow.newTokenRequest(code).setRedirectUri("urn:ietf:wg:oauth:2.0:oob").execute(), "user"
);
}
return credential;
}
private static void fetchHealthData(Health client) throws IOException {
try {
// Example: Replace with actual API method calls
Health.Users.Data.List request = client.users().data().list();
DataResponse response = request.execute();
System.out.println("Health data: " + response);
} catch (Exception e) {
System.err.println("Error fetching health data: " + e.getMessage());
e.printStackTrace();
}
}
}
// Process the response
if (response.statusCode() == 200) {
System.out.println("API Response: " + response.body());
} else {
System.err.println("Error: " + response.statusCode() + " " + response.body());
}
- นำเข้าไลบรารี:
com.google.api.client.*: ไลบรารีหลักสำหรับไคลเอ็นต์ Google APIcom.google.api.services.health.*: คลาสที่สร้างขึ้นสำหรับ Google Health API (คุณจะต้องสร้างสิ่งนี้โดยอิงตามเอกสารการค้นพบของ API)
- การกำหนดค่า:
CLIENT_SECRETS_PATH: เส้นทางไปยังไฟล์client_secret.jsonTOKENS_DIRECTORY_PATH: เส้นทางสำหรับจัดเก็บโทเค็นAPI_KEY: คีย์ API ของคุณSCOPES: สิทธิ์ที่จำเป็นDISCOVERY_URL: URL เพื่อรับคำจำกัดความของ API
mainวิธีการ:- เริ่มต้นไคลเอ็นต์ Google Health API และเรียก
fetchHealthData
- เริ่มต้นไคลเอ็นต์ Google Health API และเรียก
createHealthService():- สร้างอินสแตนซ์ของไคลเอ็นต์ Google Health API โดยตั้งค่าข้อมูลเข้าสู่ระบบ ชื่อแอป และคีย์ API
getCredentials():- โหลดรหัสลับไคลเอ็นต์จากไฟล์
- สร้าง
GoogleAuthorizationCodeFlow - พยายามโหลดข้อมูลเข้าสู่ระบบที่จัดเก็บไว้
- หากไม่พบข้อมูลเข้าสู่ระบบหรือพบข้อมูลเข้าสู่ระบบที่หมดอายุแล้ว ระบบจะแจ้งให้ผู้ใช้ระบุ รหัสการให้สิทธิ์ และจัดเก็บข้อมูลเข้าสู่ระบบใหม่
- แสดงผลออบเจ็กต์ข้อมูลเข้าสู่ระบบ
fetchHealthData():- ทำการเรียก API ไปยัง Google Health API (แทนที่ตัวอย่างด้วยการเรียกเมธอดที่เฉพาะเจาะจงของคุณ )
- พิมพ์คำตอบ
- การจัดการข้อผิดพลาด: โค้ดมีบล็อก
try...catchพื้นฐานสำหรับการจัดการข้อผิดพลาด
JavaScript
- ติดตั้งไลบรารีของไคลเอ็นต์ Google API:
- รวมไลบรารีไว้ในโปรเจ็กต์ คุณใช้ CDN หรือ npm ได้
- ใช้ขั้นตอน OAuth 2.0:
- ใช้ไลบรารี Google Identity Services เพื่อจัดการขั้นตอน OAuth (ผลลัพธ์ 16.1)
- ส่งคำขอ API:
- ใช้ไคลเอ็นต์ที่เริ่มต้นแล้วเพื่อส่งคำขอไปยัง Google Health API
import { google } from 'https://apis.google.com/js/api.js';
import { GoogleIdentityServices } from 'https://accounts.google.com/gsi/client';
const CLIENT_ID = 'YOUR_CLIENT_ID';
const API_KEY = 'YOUR_API_KEY';
const DISCOVERY_URL = 'https://health.googleapis.com/$discovery/rest'; // Replace with actual discovery URL if needed
const SCOPES = 'https://www.googleapis.com/auth/health'; // Add other scopes as needed
let tokenClient;
async function initClient() {
await new Promise((resolve, reject) => {
google.load('client', { callback: resolve, onerror: reject });
});
await google.client.init({
apiKey: API_KEY,
discoveryDocs: [DISCOVERY_URL],
});
tokenClient = await new Promise((resolve, reject) => {
const client = GoogleIdentityServices.oauth2.initTokenClient({
client_id: CLIENT_ID,
scope: SCOPES,
callback: (response) => {
if (response && response.access_token) {
resolve(response.access_token);
} else {
reject(new Error('Failed to get token'));
}
},
error_callback: (error) => {
reject(error);
},
});
resolve(client);
});
console.log("Client initialized");
await authorize();
}
async function authorize() {
if (google.client.getToken()) {
console.log("Already authorized");
return;
}
return await new Promise((resolve, reject) => {
if(tokenClient){
tokenClient.requestAccessToken();
resolve();
}
else {
reject(new Error('Token client not initialized'));
}
});
}
async function fetchHealthData() {
try{
await authorize();
// Example: Replace with actual API method calls
const response = await google.client.health.users.data.list();
console.log('Health data:', response.result);
} catch (error) {
console.error('Error fetching data:', error);
}
}
initClient().then(() => {
fetchHealthData();
});
- นำเข้าไลบรารี:
https://apis.google.com/js/api.js: โหลดไคลเอ็นต์ Google API หลักhttps://accounts.google.com/gsi/client: โหลด Google Identity Services เพื่อการตรวจสอบสิทธิ์
- การกำหนดค่า:
CLIENT_ID,API_KEY: แทนที่ด้วยข้อมูลเข้าสู่ระบบจริงDISCOVERY_URL: URL ที่ใช้รับคำจำกัดความของ API คุณอาจต้องปรับ ค่านี้ตามการตั้งค่า Google Health API ขั้นสุดท้ายSCOPES: กำหนดสิทธิ์ที่จำเป็นซึ่งแอปของคุณจะต้องมี (เช่น สิทธิ์ในการอ่านข้อมูลสุขภาพ )
initClient():- โหลดไคลเอ็นต์ Google API
- เริ่มต้นไคลเอ็นต์ด้วยคีย์ API และเอกสารการค้นพบ
- เริ่มต้นไคลเอ็นต์โทเค็นของ Google Identity Services
authorize():- ตรวจสอบว่ามีโทเค็นอยู่แล้วหรือไม่
- หากยังไม่ได้ลงชื่อเข้าใช้ ระบบจะเรียกใช้
tokenClient.requestAccessToken()เพื่อเริ่มโฟลว์ OAuth
fetchHealthData():- เรียกใช้
authorize()เพื่อให้มั่นใจว่าผู้ใช้ได้รับการตรวจสอบสิทธิ์แล้ว - ทำการเรียก API ไปยัง Google Health API (แทนที่ตัวอย่างด้วยการเรียกที่เฉพาะเจาะจงของคุณ)
- บันทึกการตอบกลับ
- เรียกใช้
- การจัดการข้อผิดพลาด: โค้ดมีบล็อก
try...catchพื้นฐานสำหรับการจัดการข้อผิดพลาด
Python
- ติดตั้งไลบรารีของไคลเอ็นต์ Google API:
- ใช้
pipเพื่อติดตั้งไลบรารีที่จำเป็น
- ใช้
- ใช้ขั้นตอน OAuth 2.0:
- ใช้ไลบรารี
google-auth-oauthlibเพื่อจัดการขั้นตอน OAuth
- ใช้ไลบรารี
- ส่งคำขอ API:
- ใช้ไคลเอ็นต์ที่เริ่มต้นแล้วเพื่อส่งคำขอไปยัง Google Health API
import google.auth
from google.auth.transport.requests import Request
from google.oauth2.credentials import Credentials
from google_auth_oauthlib.flow import InstalledAppFlow
import googleapiclient.discovery
import os
import json
# --- REPLACE WITH YOUR VALUES ---
CLIENT_SECRETS_FILE = 'path/to/your/client_secret.json'
API_KEY = 'YOUR_API_KEY'
SCOPES = ['https://www.googleapis.com/auth/health'] # Add other scopes as needed
DISCOVERY_URL = 'https://health.googleapis.com/$discovery/rest' # Adjust if needed
TOKEN_FILE = 'token.json'
def get_credentials():
"""Gets or creates OAuth 2.0 credentials."""
creds = None
# The file token.json stores the user's access and refresh tokens, and is
# created automatically when the authorization flow completes for the first
# time.
if os.path.exists(TOKEN_FILE):
with open(TOKEN_FILE, 'r') as token:
creds = Credentials.from_authorized_user_info(json.load(token), SCOPES)
# If there are no (valid) credentials available, let the user log in.
if not creds or not creds.valid:
if creds and creds.expired and creds.refresh_token:
creds.refresh(Request())
else:
flow = InstalledAppFlow.from_client_secrets_file(
CLIENT_SECRETS_FILE, SCOPES
)
creds = flow.run_local_server(port=0)
# Save the credentials for the next run
with open(TOKEN_FILE, 'w') as token:
token.write(creds.to_json())
return creds
def create_health_client(creds):
"""Creates a Google Health API client."""
return googleapiclient.discovery.build(
'health',
'v1', # Replace with the actual API version if needed
credentials=creds,
discoveryServiceUrl=DISCOVERY_URL,
developerKey=API_KEY
)
def fetch_health_data(client):
"""Fetches health data using the API client."""
try:
# Example: Replace with actual API method calls
response = client.users().data().list().execute()
print('Health data:', response)
except Exception as e:
print(f'Error fetching data: {e}')
if __name__ == '__main__':
try:
creds = get_credentials()
health_client = create_health_client(creds)
fetch_health_data(health_client)
except Exception as e:
print(f"An error occurred: {e}")