Share
In deze tutorial is ons doel om een FTP-klasse te maken met PHP die goed geschreven, nuttig en uitbreidbaar is.
Het is altijd belangrijk om eerst precies te beschrijven welke functionaliteit uw klas moet bevatten. In ons geval:
Er zijn verschillende gevallen waarin je dit soort klassen zou kunnen gebruiken. Een paar scenario's kunnen zijn:
Notitie: Het is gemakkelijk om problemen met FTP op te lossen vanwege verschillende serverconfiguraties. Deze code is met succes getest op een aantal FTP-servers.
FTP: "Een standaard netwerkprotocol dat wordt gebruikt om een bestand van de ene naar de andere host te kopiëren."
FTP, of File Transfer Protocol, is zoals gedefinieerd door Wikipedia: "Een standaard netwerkprotocol dat wordt gebruikt om een bestand van de ene naar de andere host te kopiëren via een TCP / IP-gebaseerd netwerk, zoals internet."
In wezen kunt u hiermee een bestand (en) van de ene naar de andere computer kopiëren.
We beginnen zo eenvoudig mogelijk. Maak in de hoofdmap van uw nieuwe project twee bestanden: index.php en ftp_class.php.
De index.php bestand is onze hoofdpagina die het object maakt en de nodige methoden aanroept. De ftp_class.php is gewoon dat: onze ftp-les.
In de volgende stap gaan we het skelet voor onze klas maken. Zodra dit op zijn plaats is, kun je meegaan en elke stap proberen.
De kracht van Object-Oriented Programming (OOP) is om complexe code een eenvoudig te gebruiken interface te geven. Door een klasse te maken - denk aan een klasse als een patroon - kun je de gegevens inkapselen, wat eenvoudigweg een jargon is voor een term die verwijst naar het verbergen van de gegevens. We kunnen deze klasse vervolgens opnieuw en opnieuw gebruiken zonder de code te hoeven herschrijven. In plaats daarvan hoeft u alleen de juiste methoden aan te roepen (de term 'methode" is hetzelfde als functie).
Laten we beginnen met het maken van onze ftp-klasse. Open je ftp_class.php bestand en voeg de volgende code toe. Dit is een skeletstructuur van de basisklasse, die ik heb genoemd 'FTPClient'.
De construeren functie, bekend als een constructor, is een speciale klassenmethode die automatisch door de klasse wordt aangeroepen wanneer u een nieuw object of exemplaar van de klasse maakt. Dit is meestal een goede plaats om wat initialisatie toe te voegen; maar voor het doel van vandaag hebben we het niet nodig. Desondanks houden we het hier voor toekomstig gebruik.
Klasse FTPClient // *** Klasse variabelen publieke functie __construct ()
Houd er rekening mee dat we een dubbele onderstrepen dat construeren methode.
Vervolgens stellen we een aantal klassevariabelen of eigenschappen in.
privé $ connectionId; private $ loginOk = false; privé $ messageArray = array ();
De "privaat"prefix definieert de reikwijdte van de variabele, in dit geval betekent dit dat de variabele niet toegankelijk is vanaf elke plek buiten de klas.
De $ connectionId variabele slaat onze verbindingsstroom op. De andere twee slaan de status en eventuele berichten op. $ loginOk zal nuttig zijn om te bepalen of we correct zijn verbonden.
In bijna elke methode gaan we een methode noemen, genaamd 'LogMessage. Dit is een zeer eenvoudige bericht-handler, die ons in staat stelt alle berichten te vangen die door onze klas zijn gemaakt, zodat we de gebruiker feedback kunnen geven.
Merk op dat we dat niet doen
terugkeerde werkelijke berichten van binnen onze methoden. In plaats daarvan keren we terugwaarofvals, gebaseerd op het al dan niet slagen van een bepaalde operatie. Dit heeft zijn voordelen, maar geeft ook niet gedetailleerd aan de gebruiker wat er gebeurt.
Voeg de volgende twee methoden toe, zodat we kunnen bepalen wat succesvol is.
Deze methode accepteert een variabele, $ message. De inhoud van deze variabele wordt vervolgens opgeslagen in onze klasse-array, dankzij de regel: $ this-> messageArray [] = $ bericht;
persoonlijke functie logMessage ($ bericht) $ this-> messageArray [] = $ bericht;
Omdat $ messageArray is een klassenvariabele, we hebben er toegang toe via de $ This-> schrijfwijze.
In een klas,
$ thisverwijst naar het object zelf.
Om het bericht op te halen, bellen we getMessages.
openbare functie getMessages () return $ this-> messageArray;
Deze methode is een openbare methode. Zoals eerder vermeld, verwijst dit private / publieke bedrijf eenvoudigweg naar het bereik van de variabele, of in dit geval de methode. Een privémethode (of variabele) kan niet buiten de klasse worden geopend, terwijl een openbare methode (of variabele) dat wel kan.
Omdat onze variabele privé is, hebben we een manier nodig om er toegang toe te krijgen. We doen dit door onze klas een te geven openbaar methode, die we dan buiten de klas kunnen gebruiken. Je vraagt je misschien af waarom we het niet gewoon kunnen maken messageArray variabele publiek. We kunnen; dat gezegd hebbende, het is gewoon geen goede gewoonte.
Notitie: Er zijn genoeg voorbeelden op het web van full-blown message handlers, of klassen die eraan zijn gewijd. We werken aan een eenvoudige implementatie voor het doel van deze zelfstudie.
In deze stap voegen we de aansluiten methode. Hierdoor kunnen we verbinding maken met een FTP-server.
Accentsconagua
openbare functie verbinden ($ server, $ ftpUser, $ ftpPassword, $ isPassive = false) // *** Basisverbinding instellen $ this-> connectionId = ftp_connect ($ server); // *** Inloggen met gebruikersnaam en wachtwoord $ loginResult = ftp_login ($ this-> connectionId, $ ftpUser, $ ftpPassword); // *** Schakelt passieve modus in / uit (standaard uitgeschakeld) ftp_pasv ($ this-> connectionId, $ isPassive); // *** Controleer verbinding als ((! $ This-> connectionId) || (! $ LoginResult)) $ this-> logMessage ('FTP-verbinding is mislukt!'); $ this-> logMessage ('Poging om verbinding te maken'. $ server. 'voor gebruiker'. $ ftpUser, true); return false; else $ this-> logMessage ('Verbonden met'. $ server. ', voor gebruiker'. $ ftpUser); $ this-> loginOk = true; geef waar terug; We geven onze verbindingsinformatie door: de server ($ server), gebruikersnaam ($ ftpuser), en wachtwoord ($ ftpPassword) om ons in staat te stellen een verbinding tot stand te brengen.
De eerste regel code opent een FTP-verbinding, met ftp_connect, naar de opgegeven server. We slaan onze verbinding met de klassenvariabele op, $ connectionId hierboven omschreven.
De code, ftp_login logt ons in bij de opgegeven verbinding, doorgeven in onze verbindings id, onze gebruikersnaam en wachtwoord.
Je hebt misschien het ftp_pasv regel van code. Dit schakelt, zoals de opmerking impliceert, de passieve modus in / uit. Ik zou willen voorstellen dat je het laat staan, maar als je problemen hebt met verbinden, probeer het dan aan te zetten. De passieve modus kan bij het verbinden via FTP een beetje een merrie veroorzaken.
We bepalen of de verbinding succesvol was. Vervolgens loggen we de resultaten door te bellen naar onze eenvoudige berichthandler-methode, LogMessage (), en geef de reeks door om te loggen. Vergeet niet: we gebruiken $ This-> om toegang te krijgen LogMessage (), aangezien het een klassenvariabele is.
Nu onze klas aan het werken is, kunnen we het uittesten! Open je index.php bestand en voeg de volgende code toe.
U hebt toegang nodig tot een FTP-server om mee te spelen. Als u uw eigen server wilt instellen, probeer dan Filezilla - het is ook gratis.
U zult merken dat ik de FTP-servergegevens hier heb toegevoegd. Idealiter zouden deze worden opgeslagen in uw config het dossier. Wijzig deze om overeen te komen met de instellingen van uw FTP-server.
Nadat we onze FTP-servergegevens hebben gedefinieerd, nemen we de klasse mee omvatten (ftp_class.php);. Dit betekent: maak de klas beschikbaar op deze pagina. De volgende regel maakt een object van onze FTP-klasse en slaat het op in de variabele, $ ftpObj. $ ftpObj wordt nu gebruikt om toegang te krijgen tot openbare methoden binnen onze klas. Dit wordt gedaan met behulp van de -> notatie, net zoals de volgende regel doet door de $ ftpObj -> verbinden methode en het doorgeven van onze servergegevens.
// *** Definieer de definitie van uw host, gebruikersnaam en wachtwoord ('FTP_HOST', '192.168.1.88'); define ('FTP_USER', 'Blimpf'); define ('FTP_PASS', 'catfish'); // *** Neem de klasse include op ('ftp_class.php'); // *** Maak het FTP-object $ ftpObj = nieuwe FTPClient (); // *** Verbind $ ftpObj -> connect (FTP_HOST, FTP_USER, FTP_PASS); Zoals je kunt zien, is het, zodra onze klas op zijn plaats is, heel eenvoudig om verbinding te maken met onze FTP-server!
In de laatste stap konden we de connect call in een als verklaring, zoals hieronder aangetoond. Als we dan geen verbinding maken, wordt de afhankelijke code niet uitgevoerd. We kunnen dan berichten naar de gebruiker sturen, zoals "verbonden" of "mislukt".
// *** Maak verbinding if ($ ftpObj -> connect (FTP_HOST, FTP_USER, FTP_PASS)) // *** Voeg vervolgens de FTP-code hier toe echo 'connected'; else echo 'Kan geen verbinding maken';
Dit is goed, maar onze code zal snel behoorlijk opgeblazen raken met IF / ELSE-uitspraken, als we dit toevoegen aan al onze oproepen. In plaats daarvan zou ik graag een alternatief aanbieden dat de zaken een beetje schoner en gemakkelijker te volgen zal maken.
Denk aan de methoden voor berichtbehandelaars die we hebben toegevoegd? Als u de berichten van de klas wilt zien - nuttig voor debugging / feedback - kunt u de volgende code toevoegen na elke methode die u belt.
print_r ($ ftpObj -> getMessages ());
Hierdoor wordt het klassenbericht weergegeven.
Uitstekend, nu is het tijd om iets nuttigs te doen. De eerste methode die we gaan maken is de MakeDir methode. Zoals verwacht, maakt deze methode mappen voor ons op de server. De enige parameter die we doorgeven is het directorypad en de mapnaam; we zullen het noemen $ directory. De magische lijn hier is de ftp_mkdir ingebouwde functie. Het maakt gebruik van onze opgeslagen "connectionIden de doorgegeven $ directory variabele om de map te maken.
Voeg de volgende code toe aan uw ftp_class.php het dossier:
openbare functie makeDir ($ directory) // *** Als het maken van een map succesvol is? if (ftp_mkdir ($ this-> connectionId, $ directory)) $ this-> logMessage ('Directory' '. $ directory.' "created with '); geef waar terug; else // ***? Anders, FAIL. $ this-> logMessage ('Failed creating directory "'. $ directory. '"'); return false; En om het van je te noemen index.php bestand, voeg toe:
$ dir = 'photos'; // *** Maak map $ ftpObj-> makeDir ($ dir);
De variabele, $ dir is ingesteld op de naam van de map die we op de server willen maken. In dit geval: "foto's".
De volgende regel roept de methode aan die de map zal maken.
Als u de foutmelding 'Machtiging geweigerd' krijgt, moet u ervoor zorgen dat u in de opgegeven map kunt schrijven. Mogelijk moet u de map binnen een map maken, zoals
/ httpdocs.
We gaan verder en laten we een gefotografeerde foto uploaden zoe.jpg. Bij het uploaden van een bestand moeten we specificeren welk type bestand we uploaden - binair of ascii? Kortom, als u een tekstbestand uploadt, moeten we dit gebruiken ascii; anders moet het worden ingesteld op binair.
We beginnen met het opzetten van een rangschikking met alle extensies die we zouden moeten gebruiken voor een ascii type upload.
$ asciiArray = array ('txt', 'csv'); Vervolgens halen we de extensie van ons bestand op, zodat we kunnen testen of het een van de is ascii types. We bepalen dit door de extensie van het bestand dat we uploaden te verkrijgen. De snelle en vuile methode die ik hier heb gebruikt, is
door het bestand te 'exploderen' met behulp van de '.'als het scheidingsteken. Hiermee wordt het bestand in stukken gesplitst en opgeslagen als een rangschikking. Met behulp van een andere ingebouwde PHP-functie, "einde", selecteren we de laatste rangschikking element dat onze extensie bevat. Het is een net klein stukje code.
$ extension = end (explode ('.', $ fileFrom)); Vervolgens testen we of onze extensie wordt weergegeven in de lijst (met in_array) van bestandsextensies die als type moeten worden geüpload ascii. Als het in de lijst verschijnt, stellen we de variabele in $ functie naar FTP_ASCII; anders gaan we ervan uit dat het van het binaire type is en toewijzen $ functie de waarde FTP_BINARY.
in_array ($ extensie, $ asciiArray)
ftp_put uploadt een bestand van uw lokale locatie naar een bestand op afstand op de ftp-server. We geven het onze "connectionId", het pad naar het bestand waarnaar we willen uploaden ($ Fileto), het pad
van het bestand dat we willen uploaden ($ fileFrom) en de modus ($ functie) die we zojuist hebben vastgesteld.
Voeg vervolgens de volgende methode toe aan uw ftp_class.php het dossier:
public function uploadFile ($ fileFrom, $ fileTo) // *** Stel de overdrachtsmodus $ asciiArray = array ('txt', 'csv') in; $ extension = end (explode ('.', $ fileFrom)); if (in_array ($ extension, $ asciiArray)) $ mode = FTP_ASCII; else $ mode = FTP_BINARY; // *** Upload het bestand $ upload = ftp_put ($ this-> connectionId, $ fileTo, $ fileFrom, $ mode); // *** Controleer de uploadstatus als (! $ Upload) $ this-> logMessage ('FTP-upload is mislukt!'); return false; else $ this-> logMessage ('Uploaded' '. $ fileFrom.' "as" '. $ fileTo); return true; Zeker, u kunt elke gewenste mapnaam maken of uploaden! Voeg dit volgende codefragment toe aan uw index.php bestand en dienovereenkomstig aan te passen.
$ fileFrom = 'zoe.jpg'; $ fileTo = $ dir. '/'. $ FileFrom; // *** Upload lokaal bestand naar nieuwe map op server $ ftpObj -> uploadFile ($ fileFrom, $ fileTo);
Inmiddels zou je moeten leren hoe gemakkelijk deze les te gebruiken is! We voeren slechts enkele oproepen uit om onze taken uit te voeren - allemaal dankzij objectgeoriënteerde programmering!
Laten we nu bevestigen dat ons bestand in de foto map. We kunnen dit doen door te navigeren naar de 'foto'map op onze server en geef dan de inhoud weer.
De changeDir methode gebruikt "ftp_chdir"om de huidige map op de ftp-server te wijzigen, gewoon doorgeven in de directory om naar te veranderen. Eenvoudig en lief.
ftp_class.php:
openbare functie changeDir ($ directory) if (ftp_chdir ($ this-> connectionId, $ directory)) $ this-> logMessage ('Current directory is now:'. ftp_pwd ($ this-> connectionId)); geef waar terug; else $ this-> logMessage ('Kon directory niet veranderen'); return false; getDirListing zal de inhoud van de map waarin u zich bevindt weergeven met behulp van de functie "ftp_nlistDeze functie retourneert een lijst met bestanden in een bepaalde map De huidige map is standaard ingesteld, dus u hoeft geen parameters op te geven.
Als u wilt, kunt u dit overschrijven door het in te geven $ directory pad waar je de inhoud van wilt bekijken. De $ parameters variabele standaard ingesteld op '-la'. Dit is een Linux-opdracht om meer informatie over de map weer te geven. Voel je vrij om het te verwijderen of een lege string door te geven.
openbare functie getDirListing ($ directory = '.', $ parameters = '-la') // haal de inhoud van de huidige map $ contentsArray = ftp_nellijst ($ this-> connectionId, $ parameters. ". $ directory); return $ contentsArray;
De getDirListing methode retourneert een rangschikking welke onze directorylijst bevat.
// *** Ga naar map $ ftpObj-> changeDir ($ dir); // *** Mapinhoud ophalen $ contentsArray = $ ftpObj-> getDirListing (); // *** Uitvoeren van onze reeks mapinhoud echo ''; print_r ($ contentsArray); echo '';
Uw resultaat zou er als volgt uit moeten zien:
Stap 10 - Een bestand downloaden
Terwijl we aan het einde van deze tutorial trekken, gaan we verder met het downloaden van het bestand. De methode begint met dezelfde code als
upload bestand, in dat het bepaalt of het bestand dat we willen downloaden isasciiofbinair.Voor deze methode geeft u gewoon de bestandsnaam (en mogelijk het pad, afhankelijk van of u zich in dezelfde map bevindt als het bestand dat u wilt downloaden) door van het bestand dat u wilt downloaden en de naam die u dat bestand wilt hebben op uw clientcomputer.
Om een bestand te downloaden, moet je bellen
ftp_get.ftp_get ($ this-> connectionId, $ fileTo, $ fileFrom, $ mode, 0)Hiermee downloadt u een bestand van een externe server naar onze lokale computer. Het accepteert de volgende parameter: onze verbindings-id, het pad en de bestandsnaam om op te slaan als lokaal (wordt overschreven als dit
bestaat al) ($ Fileto), de locatie en naam van het bestand op de externe server ($ fileFrom) en de modus ($ functie).ftp_class.php
public function downloadFile ($ fileFrom, $ fileTo) // *** Stel de overdrachtsmodus $ asciiArray = array ('txt', 'csv') in; $ extension = end (explode ('.', $ fileFrom)); if (in_array ($ extension, $ asciiArray)) $ mode = FTP_ASCII; else $ mode = FTP_BINARY; // probeer $ remote_file te downloaden en op te slaan als $ (ifp_get ($ this-> connectionId, $ fileTo, $ fileFrom, $ mode, 0)) return true; $ this-> logMessage ('file' '. $ fileTo.' "succesvol gedownload '); else return false; $ this-> logMessage ('Er was een fout bij het downloaden van het bestand' '. $ fileFrom.' "naar" '. $ fileTo.' "');We gaan hetzelfde bestand downloaden dat we hebben geüpload door het op te slaan met een andere naam op onze clientcomputer.
Notitie: Nogmaals, zorg ervoor dat uw rechten correct zijn ingesteld!
Omdat we nu in onze
fotomap, voegen we geen pad toe aan de$ fileFromvariabele - alleen de bestandsnaam.index.php
$ fileFrom = 'zoe.jpg'; # De locatie op de server $ fileTo = 'zoe-new.jpg'; # Lokale map om op te slaan // Downloadbestand $ ftpObj-> downloadFile ($ fileFrom, $ fileTo);
Stap 11 - Afwerking
Om onze klas te vervolledigen, voegen we de class magic-methode toe,
__deconstruct. Deze methode sluit onze verbinding wanneer de verwijzing naar ons object niet langer bestaat - misschien was de pagina gesloten. In elk geval wordt deze code uitgevoerd en is de verbinding gesloten. Het is altijd een goede gewoonte om dit op te nemen, hoewel het niet helemaal noodzakelijk is.publieke functie __deconstruct () if ($ this-> connectionId) ftp_close ($ this-> connectionId);
Conclusie
Nou dat doet het! Ik hoop dat je nu een beter begrip hebt van het gebruik van FTP met PHP. Je zou nu over de nodige vaardigheden moeten beschikken om deze klasse verder uit te breiden om andere veel voorkomende taken te ondersteunen, zoals het hernoemen of verwijderen van bestanden en mappen.
Laat het ons weten als u coole PHP FTP-clients maakt!
