Att spara Facebook -kommentarer till en MySQL -databas innebär flera steg, inklusive:
1. Förstå Facebook -graf API:
* Åtkomst till data: Facebook -graf API är Facebooks primära sätt för utvecklare att interagera med sina data. Du måste använda den för att hämta kommentarer från Facebook -inlägg.
* App Setup: Du måste skapa en Facebook -app via Facebook for Developers -plattformen ([https://developers.facebook.com/ute(https://developers.facebook.com/)).
* behörigheter: Din app behöver lämpliga behörigheter för att få åtkomst till kommentarer. "Read_stream" (avskrivna, men kan fortfarande behövas för äldre API:er) eller "public_profile" i kombination med funktioner som kräver granskning som "Pages_read_engagement" och potentiellt "sidor_manage_posts" är avgörande beroende på inlägg/kommentarer du riktar dig. Granska noggrant Facebooks riktlinjer för tillstånd. Tillgången till användardata begränsas alltmer.
* Access Tokens: Du får en åtkomsttoken efter att din app är auktoriserad. Denna token fungerar som din nyckel för att få åtkomst till graf API. Det finns olika typer av tokens (användare, app, sida). Användartokens är för åtgärder för en användares vägnar. Apptokens är för åtgärder relaterade till själva appen. Sidtokens är för att hantera en Facebook -sida. Välj det som är lämpligt för ditt användningsfall.
2. Ställa in din MySQL -databas:
* Skapa en databas: Skapa en databas i din MySQL -server för att lagra kommentarerna (t.ex. `facebook_comments`).
* Skapa en tabell: Skapa en tabell för att hålla kommentardata. Här är ett exempelstruktur:
`` `SQL
Skapa tabellkommentarer (
Comment_id Varchar (255) Primärnyckel, - Facebooks unika ID för kommentaren
Post_id Varchar (255), - Facebooks unika ID för inlägget
user_id Varchar (255), - Facebooks unika ID för kommentaren
user_name varchar (255), - Namn på kommentaren
Meddelande text, - Kommentartexten
Create_Time DateTime, - tidsstämpel av när kommentaren skapades
gillar int standard 0, - antal likes (om du lagrar detta)
Svar Int Standard 0, - Antal svar (om du lagrar detta)
Utländsk nyckel (post_id) referenser inlägg (post_id) på radera kaskad, - valfritt:länk till en "inlägg" -tabell
Foreign Key (user_id) Referenser Användare (user_id) på Radera Set NULL - Valfritt:Länk till en "användare" -tabell
);
Skapa tabellinlägg (
Post_id Varchar (255) Primärnyckel, - Facebooks unika ID för inlägget
Meddelande text, - Inläggstexten
Create_Time DateTime, - tidsstämpel för när inlägget skapades
... andra postdata ...
);
Skapa tabellanvändare (
user_id varchar (255) Primärnyckel, - Facebooks unika ID för användaren
user_name varchar (255), - användarens namn
... annan användardata ...
);
`` `
* Datatyper: `Varchar (255)` är lämplig för de flesta ID och namn. "Text" är för längre kommentarinnehåll. `DateTime` lagrar tidsstämplarna.
* Primärnyckel: `Comment_id` bör vara den primära nyckeln eftersom det är den unika identifieraren för varje kommentar. På liknande sätt är `post_id` och` user_id` primära nycklar i sina respektive tabeller.
* utländska nycklar (valfritt men rekommenderat): Använd utländska nycklar för att länka tabellen "Kommentarer" till andra tabeller som "inlägg" och "användare". Detta hjälper till att upprätthålla dataintegritet och underlättar frågan. "På Radete Cascade" betyder att om du tar bort ett inlägg kommer alla dess tillhörande kommentarer också att raderas. "På radera set null" betyder att om en användare raderas kommer tabellen "user_id" i "kommentarerna" -tabellen att ställas in på null.
* Index: Överväg att lägga till index till ofta frågade kolumner (t.ex. `post_id`,` user_id`, `create_time`) för att förbättra frågeställningen.
3. Skriva koden (exempel med Python):
`` `python
Importera Facebook
importera mysql.connector
import JSON
Facebook API -referenser
Facebook_app_id ="your_app_id"
Facebook_app_secret ="your_app_secret"
Access_Token ="Your_Access_Token" # Bäst att använda ett långlivat token
MySQL -databasuppgifter
Mysql_host ="localhost"
Mysql_user ="your_mysql_user"
Mysql_password ="your_mysql_password"
Mysql_database ="facebook_comments"
def connect_to_mysql ():
försök:
myDB =mysql.connector.connect (
värd =mysql_host,
användare =mysql_user,
lösenord =mysql_password,
databas =mysql_database
)
returnera mydb
Förutom MySQL.Connector.Error som ERR:
tryck (F "-fel som ansluter till MySQL:{Err}")
returnera ingen
def get_facebook_comments (post_id):
"" "Hämtar kommentarer från ett Facebook -inlägg med Graph API." "" "
försök:
graf =facebook.graphapi (access_token =access_token, version ="v19.0") # specificera API -version
Kommentarer =graph.get_connections (id =post_id, connection_name ='kommentarer', fält ='id, meddelande, skapad_tid, från {id, name}, like_count') # ange fält att hämta
all_comments =[] # lista för att lagra alla kommentarer från alla sidor
Även om det är sant:
försök:
all_comments.extend (kommentarer ['data']) # Lägg till kommentarer från den aktuella sidan
# Försök att göra en begäran till nästa sida med data om den finns.
Kommentarer =graph.get_page (kommentarer ['Sökning'] ['Nästa'])
Förutom KeyError:
# När det inte finns fler sidor (['Sökning'] ['Nästa'] finns inte), bryt inte från slingan.
bryta
returnera all_comments
utom facebook.graphapierror som E:
utskrift (f "fel som hämtar kommentarer för post {post_id}:{e}")
returnera ingen
def insert_comment_into_db (myDB, kommentar):
"" "Sätter in en kommentar i MySQL -databasen." ""
försök:
myCursor =mydb.cursor ()
sql ="" "
Infoga i kommentarer (comment_id, post_id, user_id, user_name, meddelande, create_time, gillar)
Värden ( %s, %s, %s, %s, %s, %s, %s)
"" "
värden =(
Kommentar ['id'],
Kommentar ['Post_id'], # Antagande att du har lagt till post_id till kommentarsordboken
kommentera ['från'] ['id'],
kommentera ['från'] ['namn'],
Kommentar ['meddelande'],
Kommentar ['Create_time'],
comment.get ('like_count', 0) # Använd .Get () för att hantera saknade 'LIKE_COUNT'
)
mycursor.execute (SQL, Values)
mydb.commit ()
utskrift (f "insatt Kommentar:{Kommentar ['id']}")
Förutom MySQL.Connector.Error som ERR:
utskrift (f "fel infoga kommentar {kommentar ['id']}:{err}")
mydb.Rollback () # rollback vid fel
def main ():
"" "Huvudfunktion för att hämta kommentarer och lagra dem i databasen." ""
myDB =connect_to_mysql ()
Om inte MyDB:
återvända
Post_ids =["POST_ID_1", "POST_ID_2", "POST_ID_3"] # Ersätt med faktiska post -ID:er
För post_id i post_ids:
Kommentarer =get_facebook)
Om kommentarer:
För kommentarer i kommentarer:
Kommentar ['post_id'] =post_id # Lägg till post_id i kommentaren ordbok
insert_comment_into_db (myDB, kommentar)
mydb.close ()
om __name__ =="__main__":
Main ()
`` `
Förklaring av koden:
* Beroenden:
* `Facebook-SDK`:Installera med` pip installerar facebook-sdk`
* `MySQL-Connector-Python`:Installera med` pip installera mysql-connector-python`
* referenser: Byt ut `your_app_id`,` your_app_secret`, `your_access_token`,` your_mysql_user`, `your_mysql_password`,` facebook_comments` och `post_id` placeholders med dina faktiska krediter och post -id.
* `connect_to_mysql ()`: Upprättar en anslutning till din MySQL -databas. Hanterar potentiella anslutningsfel.
* `get_facebook_comments (post_id)`:
* Ansluter till Facebook -graf API med ditt åtkomsttoken.
* Använder `graph.get_connections ()` för att hämta kommentarer för en given `post_id`. `Connection_Name ='Comments' berättar för API att hämta kommentarer. Parametern "fälten" anger vilka fält som ska hämta från varje kommentar (minska onödig dataöverföring).
* Hanterar pagination. Facebook -grafen API returnerar data på sidor. Koden itererar genom alla sidor med kommentarer med hjälp av "Paging" -informationen. Detta är avgörande för inlägg med många kommentarer.
* Felhantering med `försök ... utom Facebook.graphapierror`.
* `insert_comment_into_db (mydb, kommentar)`:
* Förbereder ett SQL `INSERT 'uttalande med platshållare (`%s`). Detta är det bästa sättet att förhindra SQL -injektionssårbarheter.
* Skapar en "värden" -tupel som innehåller de data som ska sättas in.
* Utför SQL -uttalandet med `mycursor.execute (SQL, Values)`.
* Förbinder ändringarna i databasen med `mydb.commit ()`.
* Hanterar potentiella MySQL -fel med hjälp av `försök ... utom mysql.connector.error` och rullar tillbaka transaktionen med` mydb.rollback () `om ett fel uppstår.
* `main ()`:
* Ansluter till databasen.
* Iterates genom en lista över `post_ids '.
* Ringer `get_facebookBook_Coments ()` för att hämta kommentarer för varje inlägg.
* Iterates genom de hämtade kommentarerna och ringer `insert_comment_into_db ()` för att spara dem i databasen.
* Stänger databasanslutningen.
* `om __Name__ ==" __main __ ":`: Detta säkerställer att funktionen "Main ()" endast körs när skriptet körs direkt (inte när det importeras som en modul).
Viktiga överväganden:
* Access Tokens:
* Användare tokens: Bra för åtgärder för en användares vägnar. De löper ut. Du kan förlänga dem men ändå behöva omförfattare.
* Sidtokens: Behövde hantera en Facebook -sida. Du får dessa genom ett användartoken med tillståndet `Manage_pages '. Du kan sedan byta ut användartoken för en sidtoken. Dessa är * längre livliga * men kan fortfarande löpa ut.
* apptokens: Främst för appinställningar och analyser. Inte för att komma åt användardata direkt.
* Långlivade tokens: Facebook erbjuder förmågan att utbyta kortlivade symboler för långlivade. Detta är viktigt för bakgrundsprocesser.
* tokenhantering: Implementera korrekt tokenhantering i din ansökan. Förvara tokens säkert och uppdatera dem vid behov.
* Ratsbegränsning: Facebook verkställer räntegränser för att förhindra missbruk av API. Din kod * måste * hantera hastighetsbegränsning. Om du överskrider gränserna kommer dina förfrågningar att strypas (försenas) eller blockeras. API tillhandahåller rubriker som indikerar räntestatus (t.ex. `X-App-användningsanvändning). Implementera försök logik med exponentiell backoff för att hantera hastighet begränsande graciöst. "Facebook-SDK" kan erbjuda några inbyggda försöksmekanismer.
* Felhantering: Robust felhantering är kritisk. Facebook -graf API kan returnera olika felkoder. Hantera dessa fel på lämpligt sätt (t.ex. logga felet, försök igen, meddela administratören).
* Datasekretess: Var extremt försiktig när du hanterar användardata. Följ Facebook:s utvecklarpolicyer och regler för integritetsundersökningar (t.ex. GDPR, CCPA). Få nödvändigt samtycke från användare innan de samlar in sina uppgifter. Förvara data säkert.
* Facebook API -ändringar: Facebook -graf API kan ändras. Håll dig uppdaterad med den senaste API-dokumentationen och tillkännagivanden. Testa regelbundet din kod för att säkerställa att den fortfarande fungerar korrekt. Facebook avskriver ofta äldre versioner av API.
* asynkron bearbetning: Om du behöver bearbeta en stor volym kommentarer kan du överväga att använda asynkron bearbetning (t.ex. att använda en uppgiftskö som selleri eller Redis -kö) för att undvika att blockera din huvudapplikationstråd.
* delta API (för nästan realtidsuppdateringar): För att ständigt övervaka nya kommentarer är Delta API (en del av graf API) till hjälp. Det låter dig bara hämta ändringarna (nya kommentarer, raderade kommentarer, uppdaterade kommentarer) sedan förra gången du kontrollerade. Detta är mer effektivt än att upprepade gånger hämta alla kommentarer.
* Filtrering och sökning (graf API -funktioner): Utforska grafen API:s filtrerings- och sökfunktioner. Du kan använda dessa för att hämta kommentarer baserade på specifika kriterier (t.ex. kommentarer som innehåller vissa sökord).
* databasoptimering: Optimera ditt databasschema och frågor för prestanda. Använd lämpliga index, partitionering och cachning.
Förenklat flöde:
1. App Setup: Skapa en Facebook -app och få nödvändiga behörigheter.
2. Access Token: Få ett långlivat åtkomsttoken.
3. databasanslutning: Anslut till din MySQL -databas.
4. få post -ID: Bestäm vilka Facebook -inlägg du vill hämta kommentarer från.
5. hämta kommentarer: Använd graf API för att hämta kommentarer för varje inlägg. Hantera pagination och hastighetsbegränsning.
6. Dataomvandling: Förvandla kommentardata till ett format som är lämpligt för din databas. Lägg till inläggs -ID till varje kommentar.
7. INSERT I DATABASE: Sätt in kommentardata i tabellen "Kommentarer". Använd parametrerade frågor för att förhindra SQL -injektion.
8. Felhantering: Implementera omfattande felhantering under hela processen.
9. tokenhantering: Förvara och uppdatera åtkomsttoken säkert.
Denna omfattande guide bör hjälpa dig att framgångsrikt spara Facebook -kommentarer till din MySQL -databas. Kom ihåg att prioritera datasekretess och säkerhet under hela utvecklingsprocessen. Lycka till!
