1. Comprensione dell'API del grafico di Facebook:
* Accesso ai dati: L'API del grafico di Facebook è il modo principale di Facebook per gli sviluppatori di interagire con i suoi dati. Dovrai usarlo per recuperare i commenti dai post di Facebook.
* Impostazione dell'app: È necessario creare un'app Facebook tramite la piattaforma Facebook per sviluppatori ([https://developers.facebook.com/ lasting(https://developers.facebook.com/)).
* Permessi: La tua app necessita delle autorizzazioni appropriate per accedere ai commenti. Il `read_stream` (deprecato, ma potrebbe ancora essere necessario per le API più vecchie) o` public_profile` combinato con funzionalità che richiedono una revisione come `pagine_read_engagement` e potenzialmente` page_manage_posts` sono cruciali a seconda dei post/commenti che stai bersaglio. Rivedi attentamente le linee guida di autorizzazione di Facebook. L'accesso ai dati degli utenti è sempre più limitato.
* Accesso token: Otterrai un token di accesso dopo che la tua app è stata autorizzata. Questo token funge da chiave per accedere all'API grafico. Esistono diversi tipi di token (utente, app, pagina). I token utente sono per azioni per conto di un utente. I token dell'app sono per le azioni relative all'app stessa. I token di pagina sono per la gestione di una pagina Facebook. Scegli quello appropriato per il tuo caso d'uso.
2. Impostazione del tuo database MySQL:
* Crea un database: Crea un database nel server MySQL per archiviare i commenti (ad esempio, "Facebook_comments`).
* Crea una tabella: Crea una tabella per contenere i dati dei commenti. Ecco una struttura di esempio:
`` `sql
Crea commenti di tabella (
commento_id varchar (255) chiave primaria, - ID univoco di Facebook per il commento
Post_id Varchar (255), - ID univoco di Facebook per il post
user_id varchar (255), - ID univoco di Facebook per il commentatore
user_name varchar (255), - nome del commentatore
Testo del messaggio, - Il testo del commento
creato_time datetime, - timestamp di quando è stato creato il commento
Mi piace int predefinito 0, - Numero di Mi piace (se stai archiviando questo)
Risposte Int predefinito 0, - Numero di risposte (se stai archiviando questo)
Post di riferimenti a chiave estera (post_id) (post_id) su elimina cascade, - opzionale:collegamento a una tabella 'post'
Tasto straniero (user_id) Riferimenti Utenti (user_id) su Elimina set null - opzionale:collegamento a una tabella "utenti"
);
Crea post da tavolo (
Post_id Varchar (255) chiave primaria, - ID univoco di Facebook per il post
Testo del messaggio, - Il testo post
creato_time datetime, - timestamp di quando è stato creato il post
... altri dati post ...
);
Crea utenti di tabelle (
USER_ID VARCHAR (255) Chiave primaria, - ID univoco di Facebook per l'utente
user_name varchar (255), - Il nome dell'utente
... altri dati utente ...
);
`` `
* Tipi di dati: `Varchar (255)` è adatto per la maggior parte degli ID e nomi. `Testo` è per un contenuto di commenti più lunghi. `DateTime 'memorizza i timestamp.
* Chiave primaria: `comment_id` dovrebbe essere la chiave primaria in quanto è l'identificatore univoco per ogni commento. Allo stesso modo, `post_id` e` user_id` sono chiavi primarie nelle rispettive tabelle.
* Chiavi estere (opzionale ma consigliato): Usa le chiavi straniere per collegare la tabella `commenti` ad altre tabelle come` post` e `utenti '. Questo aiuta a mantenere l'integrità dei dati e semplifica la query. `Su Elimina Cascade` Se elimini un post, anche tutti i commenti associati verranno eliminati. `Su Elimina set null` significa se un utente viene eliminato, la tabella` user_id` nella tabella `commenti 'verrà impostata su null.
* indici: Prendi in considerazione l'aggiunta di indici a colonne frequentemente interrogate (ad esempio, `post_id`,` user_id`, `create_time`) per migliorare le prestazioni delle query.
3. Scrivere il codice (esempio usando Python):
`` `Python
Importa Facebook
Importa mysql.connector
Importa JSON
Facebook_app_id ="your_app_id"
Facebook_app_secret ="your_app_secret"
Access_Token ="your_access_token" # meglio usare un token di lunga durata
Mysql_host ="localhost"
Mysql_user ="your_mysql_user"
Mysql_password ="your_mysql_password"
Mysql_database ="Facebook_comments"
def connect_to_mysql ():
Tentativo:
mydb =mysql.connector.connect (
host =mysql_host,
utente =mysql_user,
password =mysql_password,
database =mysql_database
)
restituisce mydb
Tranne mysql.connector.error come err:
print (f "Errore che si collega a mysql:{err}")
restituire nessuno
def get_facebook_comments (post_id):
"" "Recupera i commenti da un post di Facebook usando l'API grafico." ""
Tentativo:
grafico =Facebook.Graphapi (Access_Token =Access_Token, versione ="v19.0") # Specificare la versione API
commenti =graph.get_connections (id =post_id, connection_name ='commenti', fields ='id, messaggio, creato_time, da {id, nome}, like_count') # Specifica i campi da recuperare
all_comments =[] # Elenco per archiviare tutti i commenti da tutte le pagine
mentre è vero:
Tentativo:
all_comments.extend (commenti ['data']) # Aggiungi commenti dalla pagina corrente
# Tenta di fare una richiesta alla pagina successiva di dati, se esiste.
commenti =graph.get_page (commenti ['paging'] ['next'])
Tranne Keyerror:
# Quando non ci sono più pagine (['paging'] ['next'] non esiste), si rompe dal ciclo.
rottura
restituire all_comments
Tranne Facebook.Graphapieror come E:
print (f "Errore recupera commenti per post {post_id}:{e}")
restituire nessuno
def insert_comment_into_db (mydb, commento):
"" "Inserisce un commento nel database MySQL." ""
Tentativo:
mycursor =mydb.cursor ()
sql ="" "
INSERT IN COMMENTI (comment_id, post_id, user_id, user_name, messaggio, creato_time, like)
Valori ( %s, %s, %s, %s, %s, %s, %s)
"" "
valori =(
commento ['id'],
commento ['post_id'], # supponendo che tu abbia aggiunto il dizionario post_id al commento
commento ['da'] ['id'],
commento ['da'] ['name'],
commento ['messaggio'],
commento ['create_time'],
comment.get ('like_count', 0) # usa .get () per gestire la mancanza 'like_count'
)
mycursor.execute (sql, valori)
mydb.commit ()
print (f "commento inserito:{commento ['id']}")
Tranne mysql.connector.error come err:
print (f "Errore inserendo commento {commento ['id']}:{err}")
mydb.rollback () # rollback in caso di errore
def main ():
"" "Funzione principale per recuperare i commenti e archiviarli nel database." ""
mydb =connect_to_mysql ()
se non mydb:
ritorno
post_ids =["post_id_1", "post_id_2", "post_id_3"] # Sostituisci con ID post effettivi
per post_id in post_ids:
commenti =get_facebook_comments (post_id)
Se commenti:
Per commenti nei commenti:
commento ['post_id'] =post_id # aggiungi il post_id al dizionario del commento
insert_comment_into_db (mydb, commento)
mydb.close ()
Se __Name__ =="__main__":
principale()
`` `
Spiegazione del codice:
* Dipendenze:
* `Facebook-sdk`:Installa con` Pip Installa Facebook-SDK`
* `mysql-connector-python`:installa con` pip installa mysql-connector-pithon`
* Credenziali: Sostituisci `your_app_id`,` your_app_secret`, `your_access_token`,` your_mysql_user`, `your_mysql_password`,` facebook_comments` e i postiholrs `post_id` con i tuoi credenziali reali e ID post.
* `connect_to_mysql ()`: Stabilisce una connessione al tuo database MySQL. Gestisce potenziali errori di connessione.
* `get_facebook_comments (post_id)`:
* Si collega all'API del grafico di Facebook utilizzando il tuo token di accesso.
* Usa `graph.get_connections ()` per recuperare i commenti per un dato `post_id`. I commenti `Connection_name ='dice all'API di recuperare i commenti. Il parametro `Fields` specifica quali campi recuperare da ciascun commento (ridurre il trasferimento di dati non necessario).
* Gestisce la impaginazione. L'API del grafico di Facebook restituisce i dati nelle pagine. Il codice iterate attraverso tutte le pagine dei commenti utilizzando le informazioni "Paging". Questo è cruciale per i post con molti commenti.
* Gestione degli errori usando `Prova ... tranne Facebook.Graphapieror`.
* `Insert_comment_into_db (mydb, commento)`:
* Prepara una dichiarazione SQL `Insert` con segnaposto (`%S`). Questo è il modo migliore per prevenire le vulnerabilità di iniezione di SQL.
* Crea una tupla `valori che contenente i dati da inserire.
* Esegue l'istruzione SQL usando `mycursor.execute (sql, valori)`.
* Commette le modifiche al database usando `mydb.commit ()`.
* Gestisce potenziali errori mysql usando `prova ... tranne mysql.connector.error` e rimuove la transazione usando` mydb.rollback () `se si verifica un errore.
* `main ()`:
* Si collega al database.
* Itera attraverso un elenco di `post_ids`.
* Chiama `get_facebook_comments ()` per recuperare i commenti per ogni post.
* Itera attraverso i commenti recuperati e chiama `insert_comment_into_db ()` per salvarli nel database.
* Chiude la connessione del database.
* `if __name__ ==" __main __ ":`: Ciò garantisce che la funzione `main ()` venga eseguita solo quando lo script viene eseguito direttamente (non quando viene importata come modulo).
Considerazioni importanti:
* Accesso token:
* token utente: Buono per le azioni per conto di un utente. Scadono. Puoi estenderli ma hai ancora bisogno di una nuova autorizzazione.
* token di pagina: Necessario per gestire una pagina Facebook. Li ottieni tramite un token utente con l'autorizzazione `Manage_Pages`. È quindi possibile scambiare il token utente con un token di pagina. Questi sono * più di lunga durata * ma possono ancora scadere.
* token app: Principalmente per impostazioni e analisi delle app. Non per accedere direttamente ai dati dell'utente.
* token di lunga durata: Facebook offre la possibilità di scambiare token di breve durata con quelli di lunga durata. Questo è essenziale per i processi di fondo.
* Gestione token: Implementa un'adeguata gestione dei token nell'applicazione. Conservare i token in modo sicuro e aggiornarli quando necessario.
* Limitazione della velocità: Facebook impone i limiti di tasso per prevenire l'abuso dell'API. Il codice * deve * gestire la limitazione della tariffa. Se superi i limiti, le tue richieste verranno limitate (ritardate) o bloccate. L'API fornisce intestazioni che indicano lo stato del limite di tasso (ad es. `X-app-use"). Implementa la logica di pensionamento con backoff esponenziale per gestire con grazia la tariffa. Il `Facebook-SDK` potrebbe offrire alcuni meccanismi di tentativi integrati.
* Gestione degli errori: La gestione di errori robusta è fondamentale. L'API del grafico di Facebook può restituire vari codici di errore. Gestire questi errori in modo appropriato (ad esempio, registrare l'errore, riprovare la richiesta, avvisare l'amministratore).
* Privacy dei dati: Sii estremamente attento quando si maneggia i dati dell'utente. Rispettare le politiche degli sviluppatori di Facebook e le normative sulla privacy dei dati (ad es. GDPR, CCPA). Ottieni il consenso necessario dagli utenti prima di raccogliere i propri dati. Archiviare i dati in modo sicuro.
* Modifiche alle API di Facebook: L'API del grafico di Facebook è soggetta a modifiche. Rimani aggiornato con l'ultima documentazione e annunci API. Testa regolarmente il tuo codice per assicurarti che funzioni ancora correttamente. Facebook depreca spesso le versioni precedenti dell'API.
* Elaborazione asincrona: Se è necessario elaborare un grande volume di commenti, prendi in considerazione l'utilizzo di elaborazione asincrona (ad es. Utilizzo di una coda di attività come sedano o coda Redis) per evitare di bloccare il thread dell'applicazione principale.
* Delta API (per aggiornamenti quasi in tempo reale): Per il monitoraggio costante di nuovi commenti, l'API Delta (parte dell'API grafico) è utile. Ti consente di recuperare solo le modifiche (nuovi commenti, commenti eliminati, commenti aggiornati) dall'ultima volta che hai controllato. Questo è più efficiente che recuperare ripetutamente tutti i commenti.
* Filtraggio e ricerca (funzionalità API del grafico): Esplora le funzionalità di filtraggio e ricerca dell'API del grafico. Puoi usarli per recuperare commenti in base a criteri specifici (ad esempio commenti contenenti determinate parole chiave).
* Ottimizzazione del database: Ottimizza lo schema e le query del database per le prestazioni. Utilizzare indici, partizionamento e memorizzazione nella cache appropriati.
Flusso semplificato:
1. Setup app: Crea un'app Facebook e ottieni le autorizzazioni necessarie.
2. Token di accesso: Ottieni un token di accesso a lunga durata.
3. Connessione al database: Connettiti al tuo database MySQL.
4. Ottieni ID post: Determina da quali post di Facebook vuoi recuperare i commenti.
5. Presa commenti: Usa l'API grafico per recuperare i commenti per ogni post. Gestire la paginazione e la limitazione della velocità.
6. Trasformazione dei dati: Trasforma i dati dei commenti in un formato adatto al tuo database. Aggiungi l'ID post a ogni commento.
7. Inserisci nel database: Inserire i dati dei commenti nella tabella `commenti '. Utilizzare query parametrizzate per prevenire l'iniezione di SQL.
8. Gestione degli errori: Implementare una gestione completa degli errori durante tutto il processo.
9. Gestione token: Conservare e aggiornare il token di accesso in modo sicuro.
Questa guida completa dovrebbe aiutarti a salvare correttamente i commenti di Facebook nel tuo database MySQL. Ricorda di dare la priorità alla privacy e alla sicurezza dei dati durante il processo di sviluppo. Buona fortuna!
software © www.354353.com