Ein full-stack PHP Framework als C basierte Erweiterung

Seine überzeugende Architektur macht Phalcon zum schnellsten PHP Framework das es je gab!

Entwickler müssen C nicht kennen, um Phalcon zu verwenden. Seine Funktionalität wird als PHP-Klassen und Schnittstellen unter dem Phalcon-Namensraum dargestellt, bereit zur Verwendung.
Funktionen
  • Niedriger Overhead
  • ORM
  • PHQL
  • Transaktionen
  • Cache
  • Views & Frontend
  • Template-Engines
  • Template-Engine (Volt)
  • i18n
  • Formular-Builder
  • Flash-Nachrichten

  • Niedriger Overhead
    Geringen Speicherverbrauch und CPU im Vergleich zu herkömmlichen Frameworks
  • MVC & HMVC
    Module, Komponenten, Modelle, Ansichten und Controller
  • Dependency Injection
    Dependency Injection und Lage der Dienste und es ist selbst ein Container für sie.
  • REST
    In diesem Fall können Sie entweder eine micro oder full Stack-Anwendung nutzen, um Ihr Ziel zu erreichen. Darüber hinaus eine leistungsstarke Reihe von HTTP-Helfern.
  • Autoloader
    Stellt den autoloading Mechanismus von PHP-Klassen gemäß PSR-4 zur Verfügung.
  • Router
    Phalcon\Mvc\Router bietet erweiterte routing-Funktionen.
Niedriger Overhead
PHP C-Erweiterung (Phalcon)
  • Zephir/C Erweiterungen werden einmalig zusammen mit PHP bei dem Web-Server Daemon Startprozess geladen
  • Die von der Erweiterung zur Verfügung gestellten Klassen und Funktionen sind bereit in jeder Anwendung verwendet zu werden
  • Der Code wird kompiliert und ist nicht interpretiert, da er bereits für eine bestimmte Plattform und Prozessor kompiliert wurde
  • Dank der Low-Level-Architektur und Optimierungen bietet Phalcon den geringsten Aufwand für MVC-basierte Anwendungen
MVC
Erstellen Sie Einzel- und Multi-Module-Anwendungen mit Leichtigkeit und Freude. Mit den Datei-Strukturen, Schemata und Muster, welche Sie bereits kennen.
                        
single/
    app/
        controllers/
        models/
        views/
    public/
        css/
        img/
        js/

                        
                    
                        
multiple/
     apps/
       frontend/
          controllers/
          models/
          views/
          Module.php
       backend/
          controllers/
          models/
          views/
          Module.php
       public/
       ../
                        
                    
Dependency Injection
Phalcon baut auf einer leistungsstarken und dennoch einfach zu verstehenden und nutzbaren Dependency Injection auf. Initialisieren oder definieren Sie Services einmal - und verwenden sie praktisch überall in der gesamten Anwendung.
                        
// Den Dependency-Injektor-Container erstellen
$di = new Phalcon\DI();

// Registrieren Sie, Klassen, Funktionen, Komponenten
$di->set("request", new Phalcon\Http\Request());

..

// Überall sonst im Code verwenden
$request = $di->getShared('request');
                        
                    
RESTful Services
REST-Server und Anwendungen zu schreiben war noch nie einfacher. Keine vorformulierten Texte. Einfache Services passen in eine Datei.
                        
use Phalcon\Mvc\Micro;

$app = new Micro();

// Zurückgeben von Daten als JSON
$app->get(
    '/check/status',
    function () {
        return $this
            ->response
            ->setJsonContent(
                [
                    'status' => 'important',
                ]
            )
        ;
    }
);

$app->handle();
                        
                    
Autoloader
Registeren Sie Namespaces, Präfixe, Verzeichnisse oder Klassen. Profitieren Sie von den Autoloader Ereignissen und erhalten Sie volle Kontrolle darüber welche Dateien geladen werden und von wo.
                        
use Phalcon\Loader;

// Erstellt den Autoloader
$loader = new Loader();

// Einige Namespaces registrieren
$loader->registerNamespaces(
    [
       'Example\Base'    => 'vendor/example/base/',
       'Example\Adapter' => 'vendor/example/adapter/',
       'Example'         => 'vendor/example/',
    ]
);

// Autoloader registrieren
$loader->register();
                        
                    
Router
Routing, wie es sein soll. Nicht mehr. Nicht weniger.
                        
// Router erstellen
$router = new \Phalcon\Mvc\Router();

// Eine Route definieren
$router->add(
   '/admin/users/my-profile',
   [
       'controller' => 'users',
       'action'     => 'profile',
   ]
);
                        
                    
  • ORM
    Objekt-relationales Mapping
  • PHQL
    Die leistungsfähige und sichere Phalcon Abfragesprache, PHQL
  • Transaktionen
    Transaktionen in Phalcon ermöglichen es, die Integrität der Daten sicherzustellen.
  • Cache
    Verbessere die Leistung mit vielen Back-End-Caches, welche Phalcon bietet
ORM
Eine leistungsstarkes ORM wird von Phalcon bereitgestellt sodass Sie Datenbank-Datensätzen als Klassen und Objekte manipulieren können. MySQL, PostgreSQL und SQLite werden von Grund auf unterstützt.
                        
use Invoices;
use Phalcon\Mvc\Model;

class Customers extends Model
{
    public $cst_id;

    public $cst_name;

    public function initialize()
    {
        $this->hasMany(
            'cst_id',
            Invoices::class,
            'inv_cst_id'
        );
    }
}
                        
                    
PHQL
PHQL ist ein High-Level, Objekt-orientierter SQL-Dialekt, der es ermöglicht Abfragen unter Verwendung einer standardisierten SQL-ähnliche Sprache zu schreiben. PHQL ist als ein Parser (in C geschrieben) implementiert, welcher die Syntax in die des Ziels RDBMS übersetzt. Um die höchste Leistung zu erreichen, bietet Phalcon einen Parser, der die gleiche Technologie wie SQLite verwendet. Diese Technologie bietet einen kleinen speicherinternen Parser mit einem sehr geringen Speicherbedarf, der auch threadsicher ist.
                        
$phql  = 'SELECT * '
       . 'FROM Formula\Cars '
       . 'ORDER BY Formula\Cars.name';
$query = $manager->createQuery($phql);

$phql  = 'SELECT Formula\Cars.name '
       . 'FROM Formula\Cars '
       . 'ORDER BY Formula\Cars.name';
$query = $manager->createQuery($phql);

$phql  = 'SELECT c.name '
       . 'FROM Formula\Cars c '
       . 'ORDER BY c.name';
$query = $manager->createQuery($phql);

$phql = 'SELECT c.* '
      . 'FROM Cars AS c '
      . 'ORDER BY c.name';
$cars = $manager->executeQuery($phql);

foreach ($cars as $car) {
    echo "Name: ", $car->name, "\n";
}
                        
                    
Transaktionen
Wenn ein Prozess mehrere Datenbank-Operationen durchführt, könnte es wichtig sein, dass jeder Schritt erfolgreich abgeschlossen ist, damit die Datenintegrität gewahrt werden kann. Transaktionen bieten die Möglichkeit, sicherzustellen, dass alle Datenbank-Operationen erfolgreich durchgeführt wurden, bevor die Daten an die Datenbank übergeben werden.
                        
use Phalcon\Mvc\Model\Transaction\Failed;
use Phalcon\Mvc\Model\Transaction\Manager;

try {

    // Einen Transaktion Manager erstellen
    $manager = new Manager();

    // Einer Transaktion anfordern
    $transaction = $manager->get();

    // Die Roboter sollen gelöscht werden
    $invoices = Invoices::find(
        'inv_cst_id = 123'
    );

    foreach ($invoices as $invoice) {
        $invoice->setTransaction($transaction);
        if ($invoice->delete() == false) {
            // Etwas stimmt nicht - Rollback-Transaktion
            foreach ($invoice->getMessages() as $message) {
                $transaction
                    ->rollback($message->getMessage());
            }
        }
    }

    // Alles ist OK - Transaktion übertragen
    $transaction->commit();

    echo "Die Roboter wurden erfolgreich gelöscht!";

} catch (Failed $e) {
    echo "Fehlgeschlagen, Grund:  ", $e->getMessage();
}
                        
                    
Cache
Die Cache-Komponente ermöglicht schnelleren Zugriff auf häufig verwendete oder bereits verarbeitete Daten. Es unterstützt viele Backends wie Redis, Memcached, Mongo, Dateien, Apc und mehr
                        
use Phalcon\Cache;
use Phalcon\Cache\AdapterFactory;
use Phalcon\Storage\Serializer\SerializerFactory;

$serializerFactory = new SerializerFactory();
$adapterFactory    = new AdapterFactory($serializerFactory);

$options = [
    'defaultSerializer' => 'Json',
    'lifetime'          => 7200
];

$adapter = $adapterFactory
    ->newInstance('apcu', $options);

$cache = new Cache($adapter);
                        
                    
  • Template-Engines
    Views stellen die Benutzeroberfläche Ihrer Anwendung dar
  • Template-Engine (Volt)
    Eine Template-Engine von Jinja inspiriert aber für PHP in C erstellt
  • i18n
    Einfach Ihre Anwendungen in viele Sprachen übersetzen
  • Formular-Builder
    Einfach HTML-Formulare erstellen
  • Flash-Nachrichten
    Flash-Nachrichten werden verwendet, um den Benutzer über den Status der Aktionen zu informieren.
Template-Engines
Views stellen die Benutzeroberfläche Ihrer Anwendung dar. Views sind oft HTML-Dateien mit eingebetteten PHP-Code, der Aufgaben ausschließlich im Zusammenhang mit der Darstellung der Daten übernimmt. Views übernehmen die Aufgabe der Bereitstellung von Daten an den Web-Browser oder ein anderes Werkzeug, das verwendet wird, um Anfragen aus Ihrer Anwendung durchzuführen.
                        
<html>
    <body>
    <div class='top'>
        <?php $this->partial('shared/ad_banner'); ?>
    </div>
    <div class='content'>
        <h1>Robots</h1>
        <p>
            Check out our specials for robots:
        </p>
        ...
    </div>
    <div class='footer'>
        <?php $this->partial('shared/footer'); ?>
    </div>
    </body>
</html>
                        
                    
Template-Engine (Volt)
Volt ist eine ultraschnelle und Designer freundliche Template-Sprache geschrieben in Zephir/C für PHP. Es bietet Ihnen eine Reihe von Helfern, um Ansichten auf einfache Weise zu schreiben. Volt ist eng mit anderen Komponenten von Phalcon integriert, Sie können es aber auch als eigenständige Komponente in Ihren Anwendungen verwenden.
                        
{# app/views/products/show.volt #}
{% block last_products %}
{% for prod in products %}
    * Name: {{ prod.name|e }}
    {% if prod.status == 'Active' %}
       Price: {{ prod.price + prod.taxes/100}}
    {% endif  %}
{% endfor  %}
{% endblock %}
                        
                    
i18n
The component Phalcon\Translate aids in creating multilingual applications. Applications using this component, display content in different languages, based on the user's chosen language supported by the application.
// app/messages/en.php
$messages = [
    'hi'      => 'Hello',
    'bye'     => 'Good Bye',
    'hi-name' => 'Hello %name%',
    'song'    => 'This song is %song%'
];

// app/messages/es.php
$messages = [
    'hi'      => 'Hola',
    'bye'     => 'Adiós',
    'hi-name' => 'Hola %name%',
    'song'    => 'Esta canción es %song%'
];

use Phalcon\Mvc\Controller;
use Phalcon\Translate\Adapter\NativeArray;

// UserController.php
class UserController extends Controller
{
    protected function getTranslation()
    {
        // Browser's best language
        $language = $this
            ->request
            ->getBestLanguage();

        // Check the lang translation file
        $fileName = 'app/messages/'
                  . $language
                  . '.php';
        if (file_exists($fileName) {
            require $fileName;
        } else {
            // Fallback auf einen Standard
            require 'app/messages/en.php';
        }

        // Ein Übersetzungsobjekt zurückgeben
        return new NativeArray(
            array(
                'content' => $messages
            )
        );
    }

    public function indexAction()
    {
        $this->view->name = 'Mike';

        $this->view->t = $this
            ->getTranslation();
    }
}
// user.volt
<p><?php echo $t->_('hi'), ' ', $name; ?></p>
                        
                    
Formular-Builder
Jedes Element im Formular kann nach Bedarf durch den Entwickler gerendert werden. Intern wird Phalcon\Tag verwendet, um den korrekten HTML-Code für jedes Element zu produzieren und Sie können zusätzliche HTML-Attribute als zweiten Parameter der render() Funktion übergeben:
                        
use Phalcon\Forms\Form;
use Phalcon\Forms\Element\Text;
use Phalcon\Forms\Element\Select;

$form = new Form();

$form->add(new Text('name'));

$form->add(new Text('telephone'));

$form->add(
    new Select(
        'telephoneType',
        array(
            'H' => 'Home',
            'C' => 'Cellphone'
        )
    )
);
                        
                    
Flash-Nachrichten
Benutzen Sie den Flash-Notifier um Benachrichtigungen an einen Benutzer in einer Webanwendung anzuzeigen:
                        
use Phalcon\Mvc\Controller;

class PostsController extends Controller
{
    public function saveAction()
    {
        $this->flash->error(
            'es existierten Fehler im Formular'
        );
        $this->flash->success(
            'Ja!, alles ist in Ordnung'
        );
        $this->flash->notice(
            'dies ist ein Hinweis für Benutzer'
        );
        $this->flash->warning(
            'dies ist nur eine Warnung'
        );
    }
}
                        
                    
  • ACL
    Access Control List ermöglicht Benutzern den Zugriff auf Module, zu denen Sie berechtigt sind
  • Sharding
    Verbinden, Speichern und Abrufen von Daten aus vielen Datenbanksystemen zur gleichen Zeit
  • Crypt
    Encrypte/Decrypte wichtige Daten um sie sicher vor Zugriffen Dritter zu machen
  • Ereignisse
    Erweitern Sie der Großteil der Framework-Komponenten durch Festlegen von "hook Punkten". Erstellen Sie Ihre eigenen Ereignisse und machen Sie Ihre Anwendung flexibler und leistungsfähiger
ACL
So kannst Du die Access Control Liste (ACL) erstellen:
                        
use Phalcon\Acl;
use Phalcon\Acl\Enum;
use Phalcon\Acl\Role;
use Phalcon\Acl\Adapter\Memory;

// Erstellen der ACL
$acl = new Memory();

// The default action is DENY access
$acl->setDefaultAction(Enum::DENY);

// Registriere zwei Rollen, Benutzer
// und Gäste
$roles = array(
    'users'  => new Role('Users'),
    'guests' => new Role('Guests')
);

foreach ($roles as $role) {
    $acl->addRole($role);
}
                        
                    
Sharding
Modelle an verschiedenen Datenbanken binden
                        
use Phalcon\Db\Adapter\Pdo\Mysql;
use Phalcon\Db\Adapter\Pdo\PostgreSQL;

// Dieser Service liefert eine MySQL-Datenbank
$container->set(
    'dbMysql',
    function () {
        return new Mysql(
            [
                'host'     => 'localhost',
                'username' => 'root',
                'password' => 'secret',
                'dbname'   => 'tutorial',
            ]
        );
    }
);

// Dieser Service liefert eine PostgreSQL-Datenbank
$container->set(
    'dbPostgres',
    function () {
        return new PostgreSQL(
            [
                'host'     => 'localhost',
                'username' => 'postgres',
                'password' => '',
                'dbname'   => 'invo',
            ]
        );
    }
);
                        
                    
Verschlüsselung
Phalcon bietet Verschlüsselung über die Phalcon\Crypt-Komponente. Diese Klasse bietet einfache objektorientierten Wrapper um die Openssl PHP Verschlüsselungsbibliothek.
                        
use Phalcon\Crypt;

$crypt = new Crypt();

$key  = 'Dies ist ein geheimer Schlüssel (32 Byte).';
$text = 'Der Text, den Sie verschlüsseln möchten.';

$encrypted = $crypt->encrypt($text, $key);

echo $crypt->decrypt($encrypted, $key);
                        
                    
Events Management
Ein Ereignis Manager ermöglicht es uns, Listener an bestimmte Ereignisse zu knüpfen. Der Typ, der uns jetzt interessiert ist "dispatch". Der folgende Code filtert alle Ereignisse, die vom Dispatcher produziert wurden:
                        
use Phalcon\Mvc\Dispatcher;
use Phalcon\Events\Manager;

$container->set(
    'dispatcher',
    function () {
        // Erstellt einen Event-Manager
        $manager = new Manager();

        // Anhören von Ereignissen, die in der
        // dispatcher mit dem SecurityPlugin
        $manager->attach(
            'dispatch:beforeExecuteRoute',
            new SecurityPlugin
        );

        // Ausnahmen bearbeiten und nicht gefunden
        // Ausnahmen mit dem NotFoundPlugin
        $manager->attach(
            'dispatch:beforeException',
            new NotFoundPlugin
        );

        $dispatcher = new Dispatcher();

        // Assign the events manager
        // to the dispatcher
        $dispatcher
            ->setEventsManager($manager);

        return $dispatcher;
    }
);
                        
                    
Ein Polling-App von Grund auf in <15 min erstellt
Sieh Dir das Demo Video an
Kommen Sie zu unserer Vagrant Entwicklergemeinschaft!
Community-Beiträge in Erweiterungen, Plugins, Adaptern, VM, Beispielen, Quellcode... und mehr
Phalcon Mitwirkende
Phalcon wird täglich durch unsere fantastische Community verbessert
Mitwirken