ThinkPHP-31

Grundlagen:

1. Grundkonzepte

LAMP

LAMP ist eine offene Ressourcen-Netzwerkentwicklungsplattform, die auf Linux, Apache, MySQL und PHP basiert. Der Begriff stammt aus Europa, wo diese Programme häufig als Standard-Entwicklungsumgebung verwendet wurden. Der Name leitet sich aus dem Anfangsbuchstaben jedes Programms ab. Jedes Programm hält sich an Open-Source-Standards: Linux ist ein offenes System; Apache ist der vielseitigste Webserver; MySQL ist eine relationale Datenbank mit zusätzlichen Tools für die webbasierte Verwaltung; PHP ist eine beliebte Objektskriptsprache viele der besten Funktionen anderer Sprachen, um die Webentwicklung effizienter zu gestalten. Entwickler, die diese Tools im Linux-Umfeld unter dem Windows-Betriebssystem nutzen, werden mit WAMP bezeichnet.
Obwohl diese Open-Source-Programme selbst nicht speziell für die Zusammenarbeit mit mehreren anderen Programmen konzipiert sind, werden diese Komponenten häufig zusammen verwendet, da sie alle einflussreiche Open-Source-Software sind und viele gemeinsame Merkmale aufweisen. In den letzten Jahren hat sich die Kompatibilität dieser Komponenten immer weiter verbessert und ihre gemeinsame Verwendung ist häufiger geworden. Und sie haben bestimmte Erweiterungen erstellt, um die Zusammenarbeit zwischen verschiedenen Komponenten zu verbessern. Derzeit sind diese Produkte standardmäßig in fast allen Linux-Distributionen enthalten. Linux-Betriebssystem, Apache-Server, MySQL-Datenbank und Perl-, PHP- oder Python-Sprache – diese Produkte bilden zusammen eine leistungsstarke Webanwendungsplattform.
Mit der starken Entwicklung des Open-Source-Trends hat Open-Source-LAMP eine dreiseitige Konfrontation mit kommerzieller J2EE- und .Net-Software gebildet, und das Softwareentwicklungsprojekt weist niedrige Investitionskosten in Software auf und wird daher von der gesamten IT bevorzugt Gemeinschaft. Fokus auf. Bezogen auf den Website-Verkehr werden mehr als 70 % des Zugriffsverkehrs von LAMP bereitgestellt, der leistungsstärksten Website-Lösung.

OOP

Objektorientierte Programmierung (OOP, objektorientierte Programmierung) ist eine Computerprogrammierungsarchitektur. Ein Grundprinzip von OOP besteht darin, dass Computerprogramme aus einzelnen Einheiten oder Objekten bestehen, die als Unterprogramme fungieren. OOP erreicht drei Hauptziele des Software-Engineerings: Wiederverwendbarkeit, Flexibilität und Erweiterbarkeit. Um den Gesamtvorgang zu implementieren, kann jedes Objekt Informationen empfangen, Daten verarbeiten und Informationen an andere Objekte senden. OOP besteht hauptsächlich aus den folgenden Konzepten und Komponenten:
Komponente – eine Einheit, in der Daten und Funktionen in einem laufenden Computerprogramm zusammengefügt werden. Komponenten sind die Basis von Modulen und Strukturen in OOP-Computerprogrammen.
Abstraktheit – die Fähigkeit eines Programms, bestimmte Aspekte der verarbeiteten Informationen zu ignorieren, d. h. die Fähigkeit, sich auf die Hauptaspekte der Informationen zu konzentrieren.
Kapselung – auch Informationskapselung genannt: Stellen Sie sicher, dass Komponenten den internen Status anderer Komponenten nicht auf unerwartete Weise ändern. Nur diejenigen Komponenten können auf ihren internen Status zugreifen. Jeder Komponententyp stellt eine Schnittstelle für die Kommunikation mit anderen Komponenten bereit und gibt Methoden an, die andere Komponenten aufrufen können.
Polymorphismus – Komponentenverweise und Klassenassemblys umfassen viele andere unterschiedliche Arten von Komponenten, und die durch die Referenzierung von Komponenten generierten Ergebnisse hängen vom tatsächlichen Aufruftyp ab.
Vererbung – ermöglicht die Erstellung von Unterklassenkomponenten basierend auf vorhandenen Komponenten, wodurch Polymorphismus und Kapselung vereinheitlicht und verbessert werden. In der Regel werden Klassen zum Gruppieren von Komponenten verwendet. Neue Klassen können auch als Erweiterungen vorhandener Klassen definiert werden, sodass Klassen in einer Baum- oder Netzwerkstruktur organisiert werden können, was die Vielseitigkeit von Aktionen widerspiegelt.
Komponentenbasierte Programmierung ist in Skriptsprachen aus Gründen wie Abstraktion, Kapselung, Wiederverwendbarkeit und Benutzerfreundlichkeit besonders beliebt geworden.

MVC

MVC ist ein Entwurfsmuster, das die Trennung von Anwendungseingabe, -verarbeitung und -ausgabe erzwingt. Anwendungen, die MVC verwenden, sind in drei Kernkomponenten unterteilt: Modell (M), Ansicht (V) und Controller (C), von denen jede ihre eigenen Aufgaben übernimmt.
Ansicht: Eine Ansicht ist die Schnittstelle, die Benutzer sehen und mit der sie interagieren. Bei altmodischen Webanwendungen ist die Ansicht eine Schnittstelle, die aus HTML-Elementen besteht. In Webanwendungen neuen Stils spielt HTML immer noch eine wichtige Rolle in der Ansicht, aber es sind immer wieder neue Technologien entstanden, darunter Adobe Flash und einige Auszeichnungssprachen ​​und Webdienste wie XHTML, XML/XSL, WML usw. Der Umgang mit der Benutzeroberfläche einer Anwendung wird immer anspruchsvoller. Einer der großen Vorteile von MVC besteht darin, dass es viele verschiedene Ansichten für Ihre Anwendung verarbeiten kann. In der Ansicht findet keine echte Verarbeitung statt, unabhängig davon, ob die Daten online oder in einer Mitarbeiterliste gespeichert sind. Sie dient lediglich dazu, die Daten auszugeben und dem Benutzer die Möglichkeit zu geben, sie zu bearbeiten.
Modell: Das Modell repräsentiert Unternehmensdaten und Geschäftsregeln. Unter den drei Komponenten von MVC hat das Modell die meisten Verarbeitungsaufgaben. Beispielsweise könnten Komponentenobjekte wie EJBs und ColdFusion-Komponenten zur Verwaltung von Datenbanken verwendet werden. Die vom Modell zurückgegebenen Daten sind neutral, was bedeutet, dass das Modell nichts mit dem Datenformat zu tun hat, sodass ein Modell Daten für mehrere Ansichten bereitstellen kann. Die Codeduplizierung wird reduziert, da der auf das Modell angewendete Code nur einmal geschrieben werden muss und von mehreren Ansichten wiederverwendet werden kann.
Controller: Der Controller akzeptiert Benutzereingaben und ruft Modelle und Ansichten auf, um die Anforderungen des Benutzers zu erfüllen. Wenn also auf einer Webseite auf einen Hyperlink geklickt und ein HTML-Formular gesendet wird, gibt der Controller selbst nichts aus und führt keine Verarbeitung durch. Es empfängt lediglich die Anforderung und entscheidet, welche Modellkomponente aufgerufen werden soll, um die Anforderung zu verarbeiten. Anschließend wird festgelegt, welche Ansicht zum Anzeigen der von der Modellverarbeitung zurückgegebenen Daten verwendet werden soll.
Jetzt fassen wir den MVC-Verarbeitungsprozess zusammen. Zuerst empfängt der Controller die Anfrage des Benutzers und entscheidet, welches Modell zur Verarbeitung aufgerufen werden soll. Anschließend verwendet das Modell die Geschäftslogik, um die Anfrage des Benutzers zu verarbeiten das entsprechende Ansichtsformat. Die vom Modell zurückgegebenen Daten werden transformiert und dem Benutzer über die Präsentationsschicht präsentiert.

ORM

Object/Relation Mapping (kurz ORM) wurde mit der Entwicklung objektorientierter Softwareentwicklungsmethoden geboren. Die objektorientierte Entwicklungsmethode ist die gängige Entwicklungsmethode in der heutigen Anwendungsentwicklungsumgebung auf Unternehmensebene, und die relationale Datenbank ist das gängige Datenspeichersystem, das Daten dauerhaft in der Anwendungsumgebung auf Unternehmensebene speichert. Objekte und relationale Daten sind zwei Ausdrucksformen von Geschäftseinheiten. Geschäftseinheiten werden als Objekte im Speicher und als relationale Daten in der Datenbank dargestellt. Es gibt Assoziationen und Vererbungsbeziehungen zwischen Objekten im Speicher, aber in der Datenbank können relationale Daten keine Viele-zu-Viele-Assoziationen und Vererbungsbeziehungen direkt ausdrücken. Daher existieren objektrelationale Zuordnungssysteme (ORM) im Allgemeinen in Form von Middleware, die hauptsächlich die Zuordnung von Programmobjekten zu relationalen Datenbankdaten implementiert.
Objektorientiert wird auf der Grundlage der Grundprinzipien der Softwareentwicklung (wie Kopplung, Aggregation, Kapselung) entwickelt, während relationale Datenbanken auf der Grundlage der mathematischen Theorie entwickelt werden. Es gibt erhebliche Unterschiede zwischen den beiden Theorien. Um dieses Mismatch-Phänomen zu lösen, wurde die objektrelationale Mapping-Technologie entwickelt.

AOP

AOP (Aspektorientierte Programmierung, aspektorientierte Programmierung) kann als Ergänzung und Verbesserung von OOP (Objektorientierte Programmierung, objektorientierte Programmierung) bezeichnet werden. OOP führt Konzepte wie Kapselung, Vererbung und Polymorphismus ein, um eine Objekthierarchie einzurichten und eine Sammlung allgemeiner Verhaltensweisen zu simulieren. Wenn wir verteilten Objekten öffentliches Verhalten einführen müssen, ist OOP machtlos. Mit anderen Worten: Mit OOP können Sie Beziehungen von oben nach unten definieren, es ist jedoch nicht für die Definition von Beziehungen von links nach rechts geeignet. Zum Beispiel die Protokollierungsfunktion. Protokollierungscode wird in der Regel horizontal über alle Objekthierarchien verteilt und hat nichts mit der Kernfunktionalität der Objekte zu tun, auf die er verteilt wird. Das Gleiche gilt für andere Codetypen, etwa Sicherheit, Ausnahmebehandlung und transparente Persistenz. Diese Art von irrelevantem Code, der überall verstreut ist, wird als übergreifender Code bezeichnet. Im OOP-Design führt er zur Duplizierung einer großen Menge Code und ist der Wiederverwendung verschiedener Module nicht förderlich. Die AOP-Technologie ist genau das Gegenteil. Sie verwendet eine Technologie namens „Cross-Cutting“, um das Innere des gekapselten Objekts zu zerlegen und die öffentlichen Verhaltensweisen, die sich auf mehrere Klassen auswirken, in einem wiederverwendbaren Modul zu kapseln. Die sogenannten „Aspekte“ dienen einfach ausgedrückt dazu, die Logik oder Verantwortlichkeiten zu kapseln, die nichts mit dem Geschäft zu tun haben, aber üblicherweise von den Geschäftsmodulen aufgerufen werden, um die Duplizierung von Code im System und die Kopplung zu reduzieren zwischen Modulen und kommt der Bedienbarkeit und Wartbarkeit zugute. AOP stellt eine horizontale Beziehung dar. Wenn das „Objekt“ ein Hohlzylinder ist, der die Eigenschaften und das Verhalten des Objekts kapselt, dann ist die aspektorientierte Programmiermethode wie ein scharfes Messer, das diese Hohlzylinder in den Körper aufschneidet Informieren Sie sich über das Innere. Der Schnittabschnitt ist der sogenannte „Aspekt“. Anschließend wurden diese ausgeschnittenen Abschnitte mit unglaublichem Geschick wiederhergestellt, ohne Spuren zu hinterlassen.
Mithilfe der „Querschnitts“-Technologie unterteilt AOP das Softwaresystem in zwei Teile: Kernanliegen und Querschnittsanliegen. Der Hauptprozess der Geschäftsabwicklung ist das Kernanliegen, und der Teil, der wenig damit zu tun hat, ist das Querschnittsthema. Ein Merkmal von Querschnittsthemen ist, dass sie häufig an mehreren Stellen innerhalb des Kernanliegens auftreten, im Wesentlichen aber überall ähnlich sind. Zum Beispiel Autoritätsauthentifizierung, Protokollierung und Transaktionsverarbeitung. Die Rolle von Aop besteht darin, verschiedene Anliegen im System zu trennen und Kernanliegen von übergreifenden Anliegen zu trennen. Wie Adam Magee, leitender Lösungsarchitekt bei Avanade, sagte, besteht die Kernidee von AOP darin, „die Geschäftslogik in der Anwendung von den gemeinsamen Diensten zu trennen, die sie unterstützen“. ”

CURD

CURD ist eine Abkürzung in der Datenbanktechnologie. Die Grundfunktionen verschiedener Parameter in der allgemeinen Projektentwicklung sind CURD. Es stellt Erstellungs-, Aktualisierungs-, Lese- und Löschvorgänge dar. CURD definiert grundlegende atomare Operationen zur Verarbeitung von Daten. Der Grund dafür, dass CURD auf den technischen Schwierigkeitsgrad erhoben wird, liegt darin, dass die Leistung beim Abschluss einer aggregationsbezogenen Aktivität mit CURD-Vorgängen in mehreren Datenbanksystemen stark variieren kann, wenn sich die Datenbeziehungen ändern.
CURD verwendet in bestimmten Anwendungen nicht unbedingt die Methoden zum Erstellen, Aktualisieren, Lesen und Löschen, die von ihnen ausgeführten Funktionen sind jedoch dieselben. ThinkPHP verwendet beispielsweise die Methoden add, save, select und delete, um die CURD-Operationen des Modells darzustellen.

ActiveRecord

Active Record (chinesischer Name: Active Record) ist ein Domänenmodellmuster, das durch eine Modellklasse gekennzeichnet ist, die einer relationalen Datenbanktabelle entspricht Eine Instanz der Modellklasse entspricht einer Zeile in der Tabelle. Active Record und Row Gateway sind sich sehr ähnlich, Ersteres ist jedoch ein Domänenmodell und Letzteres ein Datenquellenmodell. Relationale Datenbanken drücken Entitätsbeziehungen häufig über Fremdschlüssel aus, und Active Record ordnet diese Beziehung auch der Objektzuordnung und -aggregation auf Datenquellenebene zu. Active Record eignet sich für sehr einfache Domänenanforderungen, insbesondere wenn Domänenmodell und Datenbankmodell sehr ähnlich sind. Wenn Sie auf eine komplexere Domänenmodellstruktur stoßen (z. B. ein Domänenmodell mit Vererbung und Strategie), müssen Sie häufig ein Domänenmodell verwenden, das Datenquellen trennt, und es mit einem Data Mapper kombinieren.
Das Active Record-Treiber-Framework verfügt im Allgemeinen über die Funktionen des ORM-Frameworks, Active Record ist jedoch kein einfaches ORM, genau wie der Unterschied zum Row Gateway. Es wurde erstmals von Rails vorgeschlagen und folgt dem Standard-ORM-Modell: Tabellen werden Datensätzen zugeordnet, Datensätze werden Objekten zugeordnet und Felder werden Objekteigenschaften zugeordnet. Mit den folgenden Namens- und Konfigurationskonventionen lässt sich die Funktionsweise des Modells weitgehend schnell realisieren und ist prägnant und leicht verständlich.

Einzeleingang

Einzelner Eintrag bedeutet normalerweise, dass ein Projekt oder eine Anwendung über eine einheitliche (aber nicht unbedingt eindeutige) Eintragsdatei verfügt, was bedeutet, dass alle funktionalen Vorgänge des Projekts über diese Eintragsdatei ausgeführt werden, und oft ist die Eintragsdatei der erste Schritt wird ausgeführt.
Der Vorteil eines einzelnen Eingangs besteht darin, dass das Gesamtprojekt standardisierter ist, da derselbe Eingang häufig dieselben Regeln für verschiedene Vorgänge hat. Ein weiterer Aspekt besteht darin, dass der Vorteil eines einzelnen Zugangs darin besteht, dass die Kontrolle flexibler ist, da das Abfangen bequemer ist und Beurteilungen und Vorgänge wie einige Berechtigungskontrollen und Benutzeranmeldungen einheitlich verarbeitet werden können.
Einige Leute befürchten möglicherweise, dass der Zugriff auf alle Websites über eine Eintragsdatei zu groß ist. Tatsächlich ist dies eine unbegründete Idee.

2. Verzeichnisstruktur

目录/文件	说明
ThinkPHP.php	框架入口文件
Common	框架公共文件目录
Conf	框架配置文件目录
Lang	框架系统语言目录
Lib	系统核心基类库目录
Tpl	系统模板目录
Extend	框架扩展目录（关于扩展目录的详细信息请参考后面的扩展章节）

Hinweis: Wenn Sie die Kernversion herunterladen, ist das Extend-Verzeichnis möglicherweise leer, da ThinkPHP selbst nicht auf Erweiterungen angewiesen ist.

3. Namenskonventionen

Beim Entwickeln mit ThinkPHP sollten Sie versuchen, die folgenden Namenskonventionen zu befolgen:

• Klassendateien haben alle das Suffix .class.php (dies bezieht sich auf die intern von ThinkPHP verwendeten Klassenbibliotheksdateien und stellt keine extern geladenen Klassenbibliotheksdateien dar). Sie werden mit Camel benannt Groß-/Kleinschreibung und die ersten Großbuchstaben, wie z. B. DbMysql.class.php;

• stellen sicher, dass die Dateibenennung und der Aufruf in konsistenter Groß- und Kleinschreibung erfolgen, da bei Unix-ähnlichen Systemen die Groß-/Kleinschreibung beachtet wird ( und ThinkPHP ist Im Debugging-Modus wird die Groß-/Kleinschreibung auch auf der Windows-Plattform streng überprüft);

• Der Klassenname stimmt beispielsweise mit dem Dateinamen überein (einschließlich der oben genannten Groß-/Kleinschreibung). , der Dateiname der UserAction-Klasse ist UserAction.class.php, der Dateiname der InfoModel-Klasse ist InfoModel.class.php und verschiedene Klassenbibliotheken haben bestimmte Standards für die Klassenbenennung; 🎜> Funktionen, Konfigurationsdateien und andere Klassen Dateien, die keine Bibliotheksdateien sind, haben im Allgemeinen ein .php-Suffix (von Dritten eingeführte Dateien sind nicht erforderlich).

• Funktionen werden mit Kleinbuchstaben und benannt Unterstriche, wie z. B. get_client_ip;

• Methoden werden in Kamelbuchstaben benannt, und der erste Buchstabe wird in Kleinbuchstaben geschrieben, oder es wird ein Unterstrich „_“ verwendet, wie z. B. getUserName, _parseType ein Unterstrich sind private Methoden;

• Verwenden Sie beim Benennen von Attributen die Groß-/Kleinschreibung, und der erste Buchstabe sollte ein Kleinbuchstabe sein oder einen Unterstrich „_“ verwenden, z. B. Tabellenname, _Instanz. Normalerweise beginnen Attribute mit ein Unterstrich sind private Attribute;

• Funktionen oder Methoden, die mit einem doppelten Unterstrich „__“ beginnen, werden als magische Methoden verwendet, wie z. B. __call und __autoload;

  Konstantennamen werden mit Großbuchstaben und Unterstrichen benannt, wie zum Beispiel HAS_ONE und MANY_TO_MANY;

• Konfigurationsparameter werden mit Großbuchstaben und Unterstrichen benannt, wie zum Beispiel HTML_CACHE_ON; >
• Sprachvariablen werden mit Großbuchstaben und Unterstrichen benannt, z. B. MY_LANG, beginnend mit einem Unterstrich. Sprachvariablen werden normalerweise für Systemsprachenvariablen verwendet, z. B. _CLASS_NOT_EXIST_; >Es gibt keine obligatorische Spezifikation für die Benennung von Variablen und kann gemäß den Teamspezifikationen erfolgen;

• Die Vorlagendatei von ThinkPHP verwendet standardmäßig .html als Suffix (kann durch Konfiguration geändert werden); >

Datentabellen und -felder werden in Kleinbuchstaben benannt und unterstrichen. Beachten Sie, dass Feldnamen nicht mit beginnen. Mit einem Unterstrich beginnen, wie z. B. die think_user-Tabelle und das Feld user_name, möglicherweise Datentabellenfelder wie _username gefiltert werden.

• In ThinkPHP gibt es einen Sonderfall der Funktionsbenennung, bei der es sich um eine aus einem Buchstaben bestehende Funktion in Großbuchstaben handelt Definition bestimmter Operationen. Zum Beispiel ADSL-Methode und so weiter.
• Ein weiterer sehr wichtiger Punkt ist, dass ThinkPHP standardmäßig die UTF-8-Kodierung verwendet. Stellen Sie daher sicher, dass Ihre Programmdateien im UTF-8-Kodierungsformat gespeichert sind, und entfernen Sie den BOM-Informationsheader (es gibt viele Möglichkeiten, ihn zu entfernen). Verschiedene Editoren verfügen über Einstellungsmethoden und es können auch Tools zur einheitlichen Erkennung und Verarbeitung verwendet werden. Andernfalls kann es zu vielen unerwarteten Problemen kommen.

• 4. CBD-Architektur

ThinkPHP3.0-Version führt ein neues CBD-Architekturmodell (Core Behavior Behavior Driver) ein, denn ab dem In der unteren Ebene übernimmt das Framework ein verhaltensgesteuertes Kernarchitektursystem. Der Kern behält die wichtigsten Teile bei und markiert sie. Andere Funktionen können mithilfe von Verhaltenserweiterungen und Treibern kombiniert werden Bei Bedarf können Sie die unterste Ebene des Frameworks einfach anpassen, indem Sie das Verhalten einer bestimmten Etikettenposition erweitern oder ersetzen, oder Sie können Ihre eigene Etikettenposition und Anwendungszeile in der Anwendungsebene hinzufügen. Die Beschriftungsposition ähnelt dem „Aspekt“ im AOP-Konzept, und die Verhaltensweisen sind um diesen „Aspekt“ herum programmiert. Wenn die integrierte Kernerweiterung des Systems als Standardmodus betrachtet wird, können Benutzer dies tun. Alle Verhaltensanpassungen sind möglich In ein neues Muster verpackt, daher wird es in ThinkPHP als Mustererweiterung bezeichnet. Tatsächlich kann die Mustererweiterung nicht nur Verhaltensweisen ersetzen und hinzufügen, sondern auch die zugrunde liegende MVC ersetzen und ändern, um benutzerdefinierte Anpassungszwecke zu erreichen. Mit dieser neuen Funktion können Entwickler durch Mustererweiterungen ganz einfach ein Entwicklungsframework für sich selbst oder ihr Unternehmen anpassen. Die neue Version der Mustererweiterungen ist der Meister der Framework-Erweiterungen und schafft genau das. Das ist das eigentliche Schöne an der neuen Version .

Entwicklungsprozess

Der allgemeine Entwicklungsprozess für die Erstellung von Anwendungen mit ThinkPHP ist:

Systemdesign, Erstellung von Datenbanken und Datentabellen; optional) )

Benennen Sie das Projekt und erstellen Sie die Projekteintragsdatei, aktivieren Sie den Debugging-Modus

Schließen Sie die Projektkonfiguration ab; >

Projektfunktionsbibliothek erstellen (optional)

• Für das Projekt benötigte Erweiterungen entwickeln (Modus, Treiber, Tag-Bibliothek usw.); )

• Controller-Klasse erstellen

• Modellklasse erstellen; (optional)

• Vorlage erstellen Datei;

• Protokolle ausführen und debuggen;

• Cache-Funktionalität entwickeln und einrichten; (optional)

• Routing-Unterstützung hinzufügen (optional)

• Sicherheitsüberprüfung; (optional)

• Bereitstellung in der Produktionsumgebung.

6. Eintragsdatei

ThinkPHP verwendet einen Einzeleingabemodus für die Projektbereitstellung und den Zugriff. Ein Projekt hat einen einheitlichen (aber nicht unbedingt eindeutigen) Eingang. Es sollte gesagt werden, dass alle Projekte mit der Eintragsdatei beginnen und die Eintragsdateien aller Projekte ähnlich sind:

• Definieren Sie den Framework-Pfad, den Projektpfad und das Projekt Name (optional)

• Definiert zugehörige Konstanten für den Debugging-Modus und den Ausführungsmodus (optional)

• Laden der Framework-Eintragsdatei (erforderlich)

7. Projektverzeichnis

Die generierte Projektverzeichnisstruktur ähnelt dem Systemverzeichnis, einschließlich:

目录	说明
Common	项目公共文件目录，一般放置项目的公共函数
Conf	项目配置目录，项目所有的配置文件都放在这里
Lang	项目语言包目录（可选 如果不需要多语言支持 可删除）
Lib	项目类库目录，通常包括Action和Model子目录
Tpl	项目模板目录，支持模板主题
Runtime	项目运行时目录，包括Cache（模板缓存）、Temp（数据缓存）、Data（数据目录）和Logs（日志文件）子目录，如果存在分组的话，则首先是分组目录。

Wenn Sie index.php aus dem App-Verzeichnis verschieben müssen, müssen Sie nur den Projektnamen und die Projektpfaddefinition zur Eintragsdatei hinzufügen.

1. c9b8cc827117bc84870534ba9795feff 'Index', //Default module

2. 'URL_MODEL' => //URL-Modus

3. 'SESSION_AUTO_START' =>

4. //Weitere Konfigurationsparameter

5. //...

6. );

Bei den Konfigurationsparametern wird die Groß-/Kleinschreibung nicht beachtet (da unabhängig von der Groß- oder Kleinschreibung die Definition in Kleinbuchstaben umgewandelt wird)

Sie können in der Konfigurationsdatei auch zwei Dimensionsarrays verwenden, um weitere Informationen zu konfigurieren, zum Beispiel:

1. //项目配置文件
    return array(
       'DEFAULT_MODULE'     => 'Index', //默认模块
       'URL_MODEL'          => '2', //URL模式
       'SESSION_AUTO_START' => true, //是否开启session
       'USER_CONFIG'        => array(
           'USER_AUTH' => true,
           'USER_TYPE' => 2,
       ),
       //更多配置参数
       //...
    );

Es ist zu beachten, dass die sekundäre Parameterkonfiguration erfolgt Beachten Sie die Groß- und Kleinschreibung, was bedeutet, dass beim Lesen sichergestellt wird, dass es mit der Definition übereinstimmt.

9. Konventionelle Konfiguration und Projektkonfiguration, Debugging-Konfiguration

Konvention vor Konfiguration ist eine wichtige Sache für das System Wenn Sie darüber nachdenken, verfügt das System über eine integrierte Konventionskonfigurationsdatei (Confconvention.php im Systemverzeichnis), die standardmäßig allgemeine Parameter entsprechend den meisten Verwendungszwecken konfiguriert.

Die Projektkonfigurationsdatei ist die am häufigsten verwendete Konfigurationsdatei. Die Projektkonfigurationsdatei befindet sich im Konfigurationsdateiverzeichnis Conf und der Dateiname lautet config.php.
Zusätzlich zum Hinzufügen integrierter Parameterkonfigurationen in der Projektkonfigurationsdatei können Sie auch zusätzliche Konfigurationsparameter hinzufügen, die für das Projekt erforderlich sind.

Wenn der Anwendungsstatus nicht konfiguriert ist, wechselt das System standardmäßig in den Debug-Status, was bedeutet, dass die Standardkonfigurationsparameter sind:

'APP_STATUS' => 'debug', //应用调试模式状态

1. nur Konfigurationsdatei debug.php Es ist erforderlich, andere Parameter oder neue Parameter aus der Projektkonfigurationsdatei und der System-Debugging-Konfigurationsdatei zu konfigurieren.




2. Wenn Sie den Anwendungsstatus im Debug-Modus hinzufügen möchten, z. B. den Teststatus, können Sie die Einstellungen in der Projektkonfigurationsdatei wie folgt ändern:

'APP_STATUS' => 'test', //应用调试模式状态

1. Da der Debug-Modus keinen Cache hat, sind mehr Datei-E/A-Vorgänge und die Echtzeitkompilierung von Vorlagen erforderlich. Wenn also der Debug-Modus aktiviert ist, Die Leistung nimmt bis zu einem gewissen Grad ab, hat jedoch keinen Einfluss auf die Leistung des Bereitstellungsmodus.




2. Hinweis: Sobald der Debugging-Modus deaktiviert wird, wird die Debugging-Konfigurationsdatei des Projekts sofort ungültig.

10. Gruppenkonfiguration und Lesekonfiguration, dynamische Konfiguration

Wenn die Modulgruppierung aktiviert ist, können Sie die definieren Konfigurationsdatei separat für jede Gruppe. Die Gruppenkonfigurationsdatei befindet sich unter:
Projektkonfigurationsverzeichnis/Gruppenname/config.php
Sie können die Gruppierung durch die folgende Konfiguration aktivieren:

1. 'APP_GROUP_LIST' => 'Home,Admin', //项目分组设定
    'DEFAULT_GROUP'  => 'Home', //默认分组

Da nun die Home- und Admin-Gruppen definiert sind, können wir die Gruppenkonfigurationsdatei wie folgt definieren:

Conf/Home/config.php
Conf/Admin/config.php

Die Konfigurationsdatei jeder Gruppe ist Nur in der aktuellen Gruppe gültig. Das Definitionsformat der Gruppenkonfiguration ist dasselbe wie das der Projektkonfiguration.
Hinweis: Bei Gruppennamen wird die Groß-/Kleinschreibung beachtet und sie müssen mit dem definierten Gruppennamen übereinstimmen.

Nachdem Sie die Konfigurationsdatei definiert haben, können Sie die vom System bereitgestellte C-Methode verwenden (wenn Sie es seltsam finden, können Sie das Wort „Config“ verwenden, um sich daran zu erinnern), um die vorhandene Konfiguration zu lesen:

1. C('Parametername')//Den eingestellten Parameterwert abrufen

Zum Beispiel C('APP_STATUS') kann Lesen Sie den Debug-Modus des Systems. Wenn APP_STATUS noch nicht vorhanden ist, wird NULL zurückgegeben.

Die C-Methode kann auch zum Lesen der zweidimensionalen Konfiguration verwendet werden:

1. C('USER_CONFIG.USER_TYPE') //Benutzertypeinstellungen in der Benutzerkonfiguration abrufen

Da die Konfigurationsparameter global gültig sind, kann die C-Methode jede Konfiguration überall lesen, auch wenn ein Einstellungsparameter abgelaufen ist.

In der spezifischen Aktionsmethode können wir bestimmte Parameter weiterhin dynamisch konfigurieren, hauptsächlich die Parameter, die nicht verwendet wurden.
Neuen Wert festlegen:

1. C('Parametername','Neuer Parameterwert');

Zum Beispiel wir Wenn Sie den Gültigkeitszeitraum des Datencaches dynamisch ändern müssen, können Sie

1. C('DATA_CACHE_TIME','60');

kann auch das Lesen und Festlegen von zweidimensionalen Arrays unterstützen, indem die Punktsyntax für Operationen wie folgt verwendet wird:

Den eingestellten Parameterwert abrufen:

1. C(' USER_CONFIG.USER_TYPE');

Neuen Wert setzen:

1. C('USER_CONFIG.USER_TYPE' ,'1');

Ab Version 3.1 unterstützt die C-Funktion die Konfigurationsspeicherfunktion, die nur für Batch-Einstellungen gültig ist Zu verwenden:

1. C($array,'name');

wobei array eine Array-Variable ist, die den Stapelspeicher speichert. Setzen Sie die Konfigurationsparameterliste auf die durch den Namen identifizierten Cache-Daten

Um die zwischengespeicherten Einstellungslistendaten zu erhalten, können Sie

1. C('','name'); //or verwenden C(null,'name');

liest die durch den Namen identifizierten Cache-Konfigurationsdaten mit den aktuellen Konfigurationsdaten (zusammenführen).

11. Erweiterte Konfiguration

Die Projektkonfigurationsdatei wird im Bereitstellungsmodus in den Kompilierungscache aufgenommen Das heißt, das Ändern der Projektkonfigurationsdatei nach der Kompilierung wird nicht sofort wirksam. Sie müssen den Kompilierungscache löschen, bevor sie wirksam werden kann. Erweiterte Konfigurationsdateien sind von dieser Einschränkung nicht betroffen. Auch im Bereitstellungsmodus können geänderte Konfigurationen in Echtzeit wirksam werden und das Konfigurationsformat ist dasselbe wie die Projektkonfiguration.

Die erweiterte Konfiguration kann wie folgt festgelegt werden (mehrere Dateien durch Kommas getrennt):

1. 'LOAD_EXT_CONFIG' => 'user,db', // Erweiterte Konfigurationsdatei laden

Das Projekt ist so eingestellt, dass es die erweiterten Konfigurationsdateien user.php und db.php für die Benutzerkonfiguration bzw. Datenbankkonfiguration lädt, dann die Konfigurationsdateien Conf/user.php und db.php darunter Das Projektkonfigurationsverzeichnis wird automatisch geladen.

Wenn Sie die sekundäre Konfigurationsmethode verwenden möchten, können Sie diese wie folgt festlegen:

1. 'LOAD_EXT_CONFIG' => array(

2. 'USER' => 'user', //Benutzerkonfiguration

3. 'DB' => //Datenbankkonfiguration

4. ), // Laden Sie die erweiterte Konfigurationsdatei

Derselbe Inhalt der user.php-Konfigurationsdatei, aber die endgültige Methode zum Abrufen von Benutzerparametern lautet:

1. C('USER.USER_AUTH_ID');

Diese Methode kann Parameterkonfliktprobleme in großen Projektsituationen vermeiden.

Einige der folgenden Konfigurationsdateien werden bereits vom System verwendet. Bitte definieren Sie sie nicht als benutzerdefinierte erweiterte Konfigurationen neu:

12. Funktionsbibliothek

Die Funktionsbibliothek in ThinkPHP kann in Systemfunktionsbibliothek und Projektfunktionsbibliothek unterteilt werden.

Systemfunktionsbibliothek

Bibliothek Die Systemfunktionsbibliothek befindet sich im Common-Verzeichnis des Systems. Es gibt drei Dateien:
common.php Die Basisfunktionsbibliothek kann jederzeit direkt aufgerufen werden.
functions.php ist die öffentliche Funktionsbibliothek des Frameworks. Andere Modi können ihre eigene öffentliche Funktionsbibliothek ersetzen und laden die öffentliche Funktionsbibliothek;
runtime.php ist die Framework-Laufzeitdatei, die nur im Debugging-Modus oder Kompilierungsprozess geladen wird, sodass die darin enthaltenen Methoden nicht direkt im Projekt aufgerufen werden können; >

Projektfunktionsbibliothek

Bibliothek Die Projektfunktionsbibliothek befindet sich normalerweise im Common-Verzeichnis des Projekts. Der Dateiname lautet common.php. Diese Datei wird während der Ausführung automatisch geladen Wenn die Gruppenbereitstellungsmethode für die Projektkompilierung verwendet wird, befindet sich in diesem Verzeichnis eine Datei „Gruppenname/Funktion.php“, die auch automatisch entsprechend der Ausführung der aktuellen Gruppe geladen wird, sodass alle Funktionen in der Die Projektfunktionsbibliothek kann ohne manuelles Laden direkt verwendet werden.

Wenn in der Projektkonfiguration eine dynamische Funktionsladekonfiguration verwendet wird, befinden sich möglicherweise weitere Funktionsdateien im gemeinsamen Verzeichnis des Projekts und dynamisch geladene Funktionsdateien werden nicht in den Kompilierungscache aufgenommen.

In besonderen Fällen kann der Modus den Speicherort oder Namen der automatisch geladenen Projektbibliothek ändern.

Erweiterte Funktionsbibliothek

Bibliothek Wir können eine erweiterte Funktionsbibliothek im öffentlichen Projektverzeichnis definieren, um das Laden und Aufrufen bei Bedarf zu erleichtern. Die Funktionsdefinitionsspezifikationen der erweiterten Funktionsbibliothek sind dieselben wie die der Projektfunktionsbibliothek, mit der Ausnahme, dass der Dateiname der Funktionsbibliothek beliebig benannt werden kann. Im Allgemeinen wird die erweiterte Funktionsbibliothek nicht automatisch geladen, es sei denn, Sie richten das dynamische Laden ein .

Funktionsladen

Funktionen in der Systemfunktionsbibliothek und der Projektfunktionsbibliothek können direkt ohne Laden aufgerufen werden Sie können Folgendes verwenden:

Dynamisches Laden

Wir können den Parameter LOAD_EXT_FILE in der Projektkonfigurationsdatei definieren, zum Beispiel:

"LOAD_EXT_FILE"=> „user,db“

1. Durch die oben genannten Einstellungen werden die erweiterten Funktionsbibliotheksdateien user.php und db.php im öffentlichen Verzeichnis des Projekts während der Ausführung automatisch geladen, sodass sie dies tun können direkt im Projekt aufgerufen werden Die Funktionen in der erweiterten Funktionsbibliothek user.php und db.php sind nun verfügbar und die Funktionsänderungen in der erweiterten Funktionsbibliothek werden in Echtzeit wirksam.
Manuelles Laden

Wenn Ihre Funktion nur gelegentlich von einzelnen Modulen verwendet wird, müssen Sie das automatische Laden nicht verwenden. Sie können die Lademethode verwenden, um sie wie folgt manuell zu laden:

load("@.user")

1. @.user bedeutet das Laden der Benutzerfunktionsdatei des aktuellen Projekts, sodass die Funktionen in der Die Funktionsbibliothek user.php kann direkt erweitert werden.

13. Klassenbibliothek

Die Klassenbibliothek von ThinkPHP umfasst die Basisklassenbibliothek und die Anwendungsklassenbibliothek wie folgt:

Basisklassenbibliothek

类库	规则	示例
控制器类	模块名 Action	例如 UserAction、InfoAction
模型类	模型名 Model	例如 UserModel、InfoModel
行为类	行为名 Behavior	例如CheckRouteBehavior
Widget类	Widget名 Widget	例如BlogInfoWidget
驱动类	引擎名 驱动名	例如DbMysql表示mysql数据库驱动、CacheFile表示文件缓存驱动

Basisklassenbibliothek bezieht sich auf die Systemklassenbibliothek, die den ThinkPHP-Klassenbibliotheksspezifikationen entspricht, einschließlich der zentralen Basisklassenbibliothek und der erweiterten Basisklassenbibliothek von ThinkPHP. Das Verzeichnis der Kern-Basisklassenbibliothek befindet sich im Lib-Verzeichnis des Systems. Die erweiterte Basisklassenbibliothek befindet sich im Verzeichnis Extend/Library und kann die erweiterten Klassenbibliotheken ORG und Com erweitern . Die Rolle der Kernbasisklassenbibliothek besteht darin, die Grundklassen und integrierten Unterstützungsklassen zu vervollständigen, die zur Vervollständigung der universellen Entwicklung des Frameworks erforderlich sind, einschließlich:

Das Kernklassenbibliothekspaket enthält die folgenden Kernklassenbibliotheken:

类名	说明
Action	系统基础控制器类
App	系统应用类
Behavior	系统行为基础类
Cache	系统缓存类
Db	系统抽象数据库类
Dispatcher	URL调度类
Log	系统日志类
Model	系统基础模型类
Think	系统入口和静态类
ThinkException	系统基础异常类
View	视图类
Widget	系统Widget基础类

Anwendungsklassenbibliothek

Anwendungsklassenbibliotheken beziehen sich auf Klassenbibliotheken, die im Projekt definiert oder verwendet werden Klassenbibliotheken Es folgt auch der Namenskonvention von ThinkPHP. Das Anwendungsbibliotheksverzeichnis befindet sich im Lib-Verzeichnis unter dem Projektverzeichnis. Anwendungsbibliotheken verfügen über ein breites Spektrum, darunter Aktionsbibliotheken, Modellbibliotheken oder andere Werkzeugbibliotheken, normalerweise einschließlich:

目录	调用路径	说明
Lib/Action	@.Action或自动加载	控制器类库包
Lib/Model	@.Model或自动加载	模型类库包
Lib/Behavior	用B方法调用或自动加载	应用行为类库包
Lib/Widget	用W方法在模板中调用	应用Widget类库包

项目根据自己的需要可以在项目类库目录下面添加自己的类库包，例如Lib/Common、Lib/Tool等。

类库导入

一、Import显式导入

ThinkPHP模拟了Java的类库导入机制，统一采用import方法进行类文件的加载。import方法是ThinkPHP内建的类库导入方法，提供了方便和灵活的文件导入机制，完全可以替代PHP的require和include方法。例如：

1. import("Think.Util.Session");
    import("App.Model.UserModel");

import方法具有缓存和检测机制，相同的文件不会重复导入，如果导入了不同的位置下面的同名类库文件，系统也不会再次导入

注意：在Unix或者Linux主机下面是区别大小写的，所以在使用import方法的时候要注意目录名和类库名称的大小写，否则会导入失败。对于import方法，系统会自动识别导入类库文件的位置，ThinkPHP的约定是Think、ORG、Com包的导入作为基类库导入，否则就认为是项目应用类库导入。

1. import("Think.Util.Session");
    import("ORG.Util.Page");

上面两个方法分别导入了Think基类库的Util/Session.class.php文件和ORG扩展类库包的Util/Page.class.php文件。

要导入项目的应用类库文件也很简单，使用下面的方式就可以了，和导入基类库的方式看起来差不多：

1. import("MyApp.Action.UserAction");
    import("MyApp.Model.InfoModel");

上面的方式分别表示导入MyApp项目下面的Lib/Action/UserAction.class.php和Lib/Model/InfoModel.class.php类文件。

通常我们都是在当前项目里面导入所需的类库文件，所以，我们可以使用下面的方式来简化代码

1. import("@.Action.UserAction");
    import("@.Model.InfoModel");

二，别名导入

除了命名空间的导入方式外，import方法还可以支持别名导入，要使用别名导入，首先要定义别名，我们可以在项目配置目录下面增加alias.php 用以定义项目中需要用到的类库别名，例如：

1. return array(
       'rbac' =>LIB_PATH.'Common/Rbac.class.php',
       'page' =>LIB_PATH.'Common/Page.class.php',
    );

那么，现在就可以直接使用：

1. import("rbac");
    import("page");

导入Rbac和Page类，别名导入方式禁止使用import方法的第二和第三个参数，别名导入方式的效率比命名空间导入方式要高效，缺点是需要预先定义相关别名。

导入第三方类库

第三方类库统一放置在系统扩展目录下的Vendor 目录，并且使用vendor 方法导入，其参数和 import 方法是 一致的，只是默认的值有针对变化。 例如，我们把 Zend 的 Filter\Dir.php 放到 Vendor 目录下面，这个时候 Dir 文件的路径就是 Vendor\Zend\Filter\Dir.php，我们使用vendor 方法导入只需要使用：

1. Vendor('Zend.Filter.Dir');

就可以导入Dir类库了。
Vendor方法也可以支持和import方法一样的基础路径和文件名后缀参数，例如：

Vendor('Zend.Filter.Dir',dirname(__FILE__),'.class.php');

自动加载

在大多数情况下，我们无需手动导入类库，而是通过配置采用自动加载机制即可，自动加载机制是真正的按需加载，可以很大程度的提高性能。自动加载有三种情况，按照加载优先级从高到低分别是：别名自动加载、系统规则自动加载和自定义路径自动加载。

一、别名自动加载

在前面我们提到了别名的定义方式，并且采用了import方法进行别名导入，其实所有定义别名的类库都无需再手动加载，系统会按需自动加载。

二、 系统规则自动加载

果你没有定义别名的话，系统会首先按照内置的规则来判断加载，系统规则仅针对行为类、模型类和控制器类，搜索规则如下：

类名	规则	说明
行为类	规则1	搜索系统类库目录下面的Behavior目录
	规则2	搜索系统扩展目录下面的Behavior目录
	规则3	搜索应用类库目录下面的Behavior目录
	规则4	如果启用了模式扩展，则搜索模式扩展目录下面的Behavior目录
模型类	规则1	如果启用分组，则搜索应用类库目录的Model/当前分组 目录
	规则2	搜索应用类库下面的Model目录
	规则3	搜索系统扩展目录下面的Model目录
控制器类	规则1	如果启用分组，则搜索应用类库目录的Action/当前分组 目录
	规则2	搜索项目类库目录下面的Action目录
	规则3	搜索系统扩展目录下面的Action目录

注意：搜索的优先顺序从上至下 ，一旦找到则返回，后面规则不再检测。如果全部规则检测完成后依然没有找到类库，则开始进行第三个自定义路径自动加载检测。

三、 自定义路径自动加载

当你的类库比较集中在某个目录下面，而且不想定义太多的别名导入的话，可以使用自定义路径自动加载方式，这种方式需要在项目配置文件中添加自动加载的搜索路径，例如：

'APP_AUTOLOAD_PATH' =>'@.Common,@.Tool',

1. 表示，在当前项目类库目录下面的Common和Tool目录下面的类库可以自动加载。多个搜索路径之间用逗号分割，并且注意定义的顺序也就是自动搜索的顺序。




2. 注意：自动搜索路径定义只能采用命名空间方式，也就是说这种方式只能自动加载项目类库目录和基类库目录下面的类库文件。

------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

控制器：

1. URL模式

传统方式的文件入口访问会变成由URL的参数来统一解析和调度。

ThinkPHP支持四种URL模式，可以通过设置URL_MODEL参数来定义，包括普通模式、PATHINFO、REWRITE和兼容模式。

一、普通模式：设置URL_MODEL 为0
采用传统的URL参数模式

1. http://serverName/appName/?m=module&a=action&id=1

二、PATHINFO模式（默认模式）：设置URL_MODEL 为1
默认情况使用PATHINFO模式，ThinkPHP内置强大的PATHINFO支持，提供灵活和友好URL支持。PATHINFO模式自动识别模块和操作，例如

http://serverName/appName/module/action/id/1/或者
http://serverName/appName/module,action,id,1/

1. 
   

三、REWRITE模式： 设置URL_MODEL 为2
该URL模式和PATHINFO模式功能一样，除了可以不需要在URL里面写入口文件，和可以定义.htaccess 文件外。在开启了Apache的URL_REWRITE模块后，就可以启用REWRITE模式了，具体参考下面的URL重写部分。

四、兼容模式： 设置URL_MODEL 为3
兼容模式是普通模式和PATHINFO模式的结合，并且可以让应用在需要的时候直接切换到PATHINFO模式而不需要更改模板和程序，还可以和URL_WRITE模式整合。兼容模式URL可以支持任何的运行环境。

兼容模式的效果是：

1. http://serverName/appName/?s=/module/action/id/1/

并且也可以支持参数分割符号的定义，例如在URL_PATHINFO_DEPR为~的情况下，下面的URL有效：

1. http://serverName/appName/?s=module~action~id~1

其实是利用了VAR_PATHINFO参数，用普通模式的实现模拟了PATHINFO的模式。但是兼容模式并不需要自己传s变量，而是由系统自动完成URL部分。正是由于这个特性，兼容模式可以和PATHINFO模式之间直接切换，而不需更改模板文件里面的URL地址连接。我们建议的方式是采用PATHINFO模式开发，如果部署的时候环境不支持PATHINFO则改成兼容URL模式部署即可，程序和模板都不需要做任何改动。

2. 模块和操作

http://域名/项目名/分组名/模块名/操作名/其他参数
Dispatcher会根据URL地址来获取当前需要执行的项目、分组（如果有定义的话）模块、操作以及其他参数，在某些情况下，项目名可能不会出现在URL地址中（通常情况下入口文件则代表了某个项目，而且入口文件可以被隐藏）。
每一个模块就是一个控制器类，通常位于项目的Lib\Action目录下面。

3.1版本开始，增加ACTION_SUFFIX配置参数，用于设置操作方法的后缀。
例如，如果设置：

1. 'ACTION_SUFFIX'=>'Act'

那么访问某个模块的add操作对应读取模块类的操作方法则由原来的add方法变成addAct方法。

3. 定义控制器和空操作，空模块

一个应用如果不需要和数据库交互的时候可以不需要定义模型类，但是必须定义Action控制器，一般位于项目的Lib/Action目录下面。
Action控制器的定义非常简单，只要继承Action基础类就可以了，例如：

1. Class UserAction extends Action{}

控制器文件的名称是UserAction.class.php。

Leere Operation bedeutet, dass das System, wenn es die angegebene Operationsmethode nicht finden kann, die leere Operationsmethode (_empty) zur Ausführung findet. Mit diesem Mechanismus können wir die Optimierung von Fehlerseiten und einigen URLs realisieren.

Das Konzept des leeren Moduls bedeutet, dass das System versucht, das leere Modul zu finden (EmptyAction), wenn das System den angegebenen Modulnamen nicht finden kann. Mit diesem Mechanismus können wir Fehlerseiten und URLs anpassen Optimierung.

4. Modulgruppierung

Zu den Konfigurationsparametern im Zusammenhang mit der Modulgruppierung gehören:

配置参数	说明
APP_GROUP_LIST	项目分组列表（配置即表示开启分组）
DEFAULT_GROUP	默认分组（默认值为Home）
TMPL_FILE_DEPR	分组模板下面模块和操作的分隔符，默认值为“/”
VAR_GROUP	分组的URL参数名，默认为g（普通模式URL才需要）

Wenn wir beispielsweise das aktuelle Projekt in zwei Gruppen aufteilen, Home und Admin, die jeweils Front-End- und Back-End-Funktionen darstellen, müssen wir der Projektkonfiguration nur die folgende Konfiguration hinzufügen:

1. 'APP_GROUP_LIST ' => 'Home,Admin', //Projektgruppeneinstellung

2. 'DEFAULT_GROUP' => Gruppe

Mehrere Gruppen können durch Kommas getrennt werden. Standardmäßig darf nur eine Gruppe festgelegt werden.

5. URL pseudostatisch

ThinkPHP unterstützt pseudostatische URL-Einstellungen, Sie können den Parameter URL_HTML_SUFFIX festlegen Fügen Sie nach Belieben in der URL am Ende das gewünschte statische Suffix hinzu, ohne die normale Ausführung des aktuellen Vorgangs zu beeinträchtigen. Wenn wir beispielsweise

1. 'URL_HTML_SUFFIX'=>'shtml'

festlegen, können wir die folgende URL

1. http://serverName/Blog/read/id/1

wird zu

1. http:// serverName/Blog/read/id/1.shtml

Letztere hat die URL-Eigenschaften einer statischen Seite, hat aber den gleichen Ausführungseffekt wie die vorherige URL und hat keinen Einfluss auf das Original Parameter der Nutzung.

Hinweis: Das pseudostatische Suffix muss beim Festlegen nicht das „.“ enthalten. Daher ist die folgende Konfiguration tatsächlich gleichwertig:

1. 'URL_HTML_SUFFIX'=>'.shtml'

Nach pseudostatischer Einstellung, If Sie müssen dynamisch eine konsistente URL generieren. Sie können die U-Methode verwenden, um die URL in der Vorlagendatei zu generieren.

Ab Version 3.1 können standardmäßig alle statischen Suffixe unterstützt werden, und das aktuelle pseudostatische Suffix wird in der Konstante __EXT__ aufgezeichnet, hat jedoch keinen Einfluss auf den normalen Seitenzugriff. Wenn Sie das aktuelle pseudostatische Suffix erhalten möchten, rufen Sie es einfach über die Konstante __EXT__ ab.

Wenn Sie nur das konfigurierte pseudostatische Suffix unterstützen möchten, können Sie es direkt so einstellen, dass es mehrere Suffixe unterstützt, zum Beispiel:

1. 'URL_HTML_SUFFIX'=> 'html|shmtl |. Das erste Suffix wird standardmäßig verwendet. Es unterstützt auch die Angabe eines Suffixes zum Generieren einer URL-Adresse.

6. URL-Routing

Um die Routing-Funktion zu aktivieren, müssen Sie den Parameter URL_ROUTER_ON auf true setzen . Nachdem die Routing-Funktion aktiviert und der Parameter URL_ROUTE_RULES konfiguriert wurde, erkennt das System die Route automatisch. Wenn in der Routendefinition ein Routenname gefunden wird, der mit der aktuellen URL übereinstimmt, wird eine Routenanalyse und -umleitung durchgeführt.

Weitere Informationen finden Sie unter: http://doc.thinkphp.cn/manual/url_route.html

7. URL-Umschreibung

Einzelheiten finden Sie unter: http://doc.thinkphp.cn/manual/url_rewrite.html

<code><code><code><code><code><code><code><code><code>8. URL-Generierung<code><code><code><code><code><code> <code> <code><code><code>Um den verwendeten URL-Modus anzupassen, müssen wir in der Lage sein, die entsprechende URL-Adresse basierend auf den aktuellen URL-Einstellungen dynamisch zu generieren. Zu diesem Zweck bietet ThinkPHP eine integrierte Funktion U-Methode zur dynamischen Generierung von URLs. Sie kann sicherstellen, dass das Projekt während des Migrationsprozesses nicht von der Umgebung beeinflusst wird. Die Definitionsregeln der U-Methode lauten wie folgt (die Parameter in eckigen Klammern werden entsprechend der tatsächlichen Anwendung bestimmt):

<code><code><code><code><code><code><code><code><code>为了配合所使用的URL模式，我们需要能够动态的根据当前的URL设置生成对应的URL地址，为此，ThinkPHP内置提供了U方法，用于URL的动态生成，可以确保项目在移植过程中不受环境的影响。
U方法的定义规则如下（方括号内参数根据实际应用决定）： U('[Gruppe/Modul/Operation]?Parameter' [,'Parameter','Pseudostatisches Suffix ','Ob springen soll',' Domainnamen anzeigen'])

<code><code><code><code><code><code><code><code><code> Wenn das Projekt und das Modul nicht definiert sind, wird der aktuelle Projekt- und Modulname angezeigt. Hier einige einfache Beispiele:

<code><code><code><code><code><code><code><code><code>如果不定义项目和模块的话 就表示当前项目和模块名称，下面是一些简单的例子：U('User/add') // Erzeuge die URL-Adresse von die Add-Operation des Benutzermoduls

U('Blog/read?id=1') // Generieren Sie die Leseoperation des Blog-Moduls und die URL-Adresse mit der ID 1

1. U('Admin/User/select') // Generieren Sie die URL-Adresse der Auswahloperation des Benutzermoduls der Admin-Gruppe

2. <code><code><code><code><code><code> <code><code><code><code><code>Der zweite Parameter der U-Methode unterstützt zwei Definitionsmethoden: Array und string. Wenn es sich nur um einen String-Parameter handelt, kann er im ersten Parameter definiert werden, zum Beispiel: U( 'Blog/cate',array('cate_id'=>1,'status'=>1))

3. U('Blog/cate','cate_id=1&status= 1')

<code><code><code><code><code><code><code><code><code>U方法的第二个参数支持数组和字符串两种定义方式，如果只是字符串方式的参数可以在第一个参数中定义，例如：U('Blog/cate?cate_id=1&status= 1')

<code><code><code><code><code><code><code><code><code>三种方式是等效的，都是 生成Blog模块的cate操作 并且cate_id为1 status为1的URL地址
但是不允许使用下面的定义方式来传参数

1. U('Blog/cate/cate_id/1/status/1')

<code><code><code><code><code><code><code><code><code>

根据项目的不同URL设置，同样的U方法调用可以智能地对应产生不同的URL地址效果，例如针对

1. U（'Blog/read?id=1'）这个定义为例。

如果当前URL设置为普通模式的话，最后生成的URL地址是： 
http://serverName/index.php?m=Blog&a=read&id=1
如果当前URL设置为PATHINFO模式的话，同样的方法最后生成的URL地址是： 
http://serverName/index.php/Blog/read/id/1
如果当前URL设置为REWRITE模式的话，同样的方法最后生成的URL地址是： 
http://serverName/Blog/read/id/1
如果当前URL设置为REWRITE模式，并且设置了伪静态后缀为.html的话，同样的方法最后生成的URL地址是： 
http://serverName/Blog/read/id/1.html
U方法还可以支持路由，如果我们定义了一个路由规则为：

1.  'news/:id\d'=>'News/read'

那么可以使用

1. U（'/news/1'）

最终生成的URL地址是：

1. http://serverName/index.php/news/1

注意：如果你是在模板文件中直接使用U方法的话，需要采用 {:U('参数1', '参数2'…)} 的方式，具体参考模板引擎章节的8.3 使用函数内容。

如果你的应用涉及到多个子域名的操作地址，那么也可以在U方法里面指定需要生成地址的域名，例如：

1. U('Blog/read@blog.thinkphp.cn','id=1');

@后面传入需要指定的域名即可。
此外，U方法的第5个参数如果设置为true，表示自动识别当前的域名，并且会自动根据子域名部署设置APP_SUB_DOMAIN_DEPLOY和APP_SUB_DOMAIN_RULES自动匹配生成当前地址的子域名。
如果开启了URL_CASE_INSENSITIVE，则会统一生成小写的URL地址。

9. URL大小写

只要在项目配置中，增加：

1. 'URL_CASE_INSENSITIVE' =>true

就可以实现URL访问不再区分大小写了。

这里需要注意一个地方，如果我们定义了一个UserTypeAction的模块类，那么URL的访问应该是：

1. http://serverName/index.php/user_type/list

2.  //而不是

3. http://serverName/index.php/usertype/list

利用系统提供的U方法可以为你自动生成相关的URL地址。
如果设置

1. 'URL_CASE_INSENSITIVE' =>false

的话，URL就又变成：

1. http://serverName/index.php/UserType/list

注意：URL不区分大小写并不会改变系统的命名规范，并且只有按照系统的命名规范后才能正确的实现URL不区分大小写。

10. 前置和后置操作

系统会检测当前操作是否具有前置和后置操作，如果存在就会按照顺序执行，前置和后置操作的方法名是在要执行的方法前面加 _before_和_after_，例如：

1. class CityAction extends Action{
       //前置操作方法
       public function _before_index(){
           echo 'before';
       }
       public function index(){
           echo 'index';
       }
       //后置操作方法
       public function _after_index(){
           echo 'after';
       }
    }

对于任何操作方法我们都可以按照这样的规则来定义前置和后置方法。

<code><code><code><code><code><code><code><code><code>

如果当前的操作并没有定义操作方法，而是直接渲染模板文件，那么如果定义了前置 和后置方法的话，依然会生效。真正有模板输出的可能仅仅是当前的操作，前置和后置操作一般情况是没有任何输出的。
需要注意的是，在有些方法里面使用了exit或者错误输出之类的话 有可能不会再执行后置方法了。
例如，如果在当前操作里面调用了系统Action的error方法，那么将不会再执行后置操作，但是不影响success方法的后置方法执行。

<code><code><code><code><code><code><code><code><code>

11. 跨模块调用

<code>例如，我们在Index模块调用User模块的操作方法

1. class IndexAction extends Action{
       public function index(){
           //实例化UserAction
           $User = new UserAction();
           //其他用户操作
            //...
           $this->display(); //输出页面模板
       }
    }

因为系统会自动加载Action控制器，因此 我们不需要导入UserAction类就可以直接实例化。
并且为了方便跨模块调用，系统内置了A方法和R方法。    $User = A('User');

<code>事实上，A方法还支持跨分组或者跨项目调用，默认情况下是调用当前项目下面的模块。<br>跨项目调用的格式是：<br>A('[项目名://][分组名/]模块名')<br>例如：

1. A('User') //表示调用当前项目的User模块
   A('Admin://User') //表示调用Admin项目的User模块
   A('Admin/User') //表示调用Admin分组的User模块
   A('Admin://Tool/User') //表示调用Admin项目Tool分组的User模块

R方法表示调用一个模块的某个操作方法，调用格式是：
R('[项目名://][分组名/]模块名/操作名',array('参数1','参数2'…))
例如：

1. R('User/info') //表示调用当前项目的User模块的info操作方法
   R('Admin/User/info') //表示调用Admin分组的User模块的info操作方法
   R('Admin://Tool/User/info') //表示调用Admin项目Tool分组的User模块的info操作方法

R方法还支持对调用的操作方法需要传入参数，例如User模块中我们定义了一个info方法：

1. class UserAction extends Action{
       protected function info($id){
           $User = M('User');
           $User->find($id);
           //...
       }
    }

接下来，我们可以在其他模块中调用：

1. R('User/info',array(15))

表示调用当前项目的User模块的info操作方法，并且id参数传入15

12. 页面跳转

<code><code>系统的Action类内置了两个跳转方法success和error，用于页面跳转提示，而且可以支持ajax提交。使用方法很简单，举例如下：

1. $User = M('User'); //实例化User对象
   $result = $User->add($data); 
   if($result){
       //设置成功后跳转页面的地址，默认的返回页面是$_SERVER['HTTP_REFERER']
       $this->success('新增成功', 'User/list');
   } else {
       //错误页面的默认跳转页面是返回前一页，通常不需要设置
       $this->error('新增失败');
   }

Success和error方法都有对应的模板，并且是可以设置的，默认的设置是两个方法对应的模板都是：

1. //默认错误跳转对应的模板文件
   'TMPL_ACTION_ERROR' => THINK_PATH . 'Tpl/dispatch_jump.tpl';
   //默认成功跳转对应的模板文件
   'TMPL_ACTION_SUCCESS' => THINK_PATH . 'Tpl/dispatch_jump.tpl';

也可以使用项目内部的模板文件

1. //默认错误跳转对应的模板文件
   'TMPL_ACTION_ERROR' => 'Public:error';
   //默认成功跳转对应的模板文件
   'TMPL_ACTION_SUCCESS' => 'Public:success';

模板文件可以使用模板标签，并且可以使用下面的模板变量：

$msgTitle	操作标题
$message	页面提示信息
$status	操作状态 1表示成功 0 表示失败 具体还可以由项目本身定义规则
$waitSecond	跳转等待时间 单位为秒
$jumpUrl	跳转页面地址

success和error方法会自动判断当前请求是否属于Ajax请求，如果属于Ajax请求则会调用ajaxReturn方法返回信息，具体可以参考后面的AJAX返回部分。

3.1版本开始，error和success方法支持传值，无论是跳转模板方式还是ajax方式 都可以使用assign方式传参。例如：

1. $this->assign('var1','value1');
   $this->assign('var2','value2');
   $this->error('错误的参数','要跳转的URL地址');

当正常方式提交的时候，var1和var2变量会赋值到错误模板的模板变量。
当采用AJAX方式提交的时候，会自动调用ajaxReturn方法传值过去（包括跳转的URL地址url和状态值status）

13. 重定向

Action类的redirect方法可以实现页面的重定向功能。
redirect方法的参数用法和U函数的用法一致（参考上面的URL生成部分），例如：

1. //重定向到New模块的Category操作
   $this->redirect('New/category', array('cate_id' => 2), 5, '页面跳转中...');

上面的用法是停留5秒后跳转到News模块的category操作，并且显示页面跳转中字样，重定向后会改变当前的URL地址。
如果你仅仅是想重定向要一个指定的URL地址，而不是到某个模块的操作方法，可以直接使用redirect方法重定向，例如：

1. //重定向到指定的URL地址

2. redirect('/New/category/cate_id/2', 5, '页面跳转中...')

Redirect方法的第一个参数是一个URL地址。

14. 获取系统变量

1. $this->方法名("变量名",["过滤方法"],["默认值"])

<code><code><code>方法名可以支持：

方法名	含义
_get	获取GET参数
_post	获取POST参数
_param	自动判断请求类型获取GET、POST或者PUT参数（3.1新增）
_request	获取REQUEST 参数
_put	获取PUT 参数
_session	获取 $_SESSION 参数

以上就是ThinkPHP- 31的内容，更多相关内容请关注PHP中文网（www.php.cn）！