php注入原理
❶ php依賴注入是在構造函數中注入嗎
PHP 依賴注入
tags: dependency injection,php
by Ryan on January 8, 2009
Dependency injection is the answer to more maintainable, testable, molar code.
依賴注入是對於要求更易維護，更易測試，更加模塊化的代碼的答案。
Every project has dependencies and the more complex the project is the more dependencies it will most likely have. The most common dependency in today』s web application is the database and chances are if it goes down the app will all together stop working. That is because the code is dependent on the database server… and that is perfectly fine. Not using a database server because it could one day crash is a bit ridiculous. Even though the dependency has its flaws, it still makes life for the code, and thus the developer, a lot easier.
每個項目都有依賴（外界提供的輸入）, 項目越復雜，越需要更多的依賴。在現今的網路應用程序中，最常見的依賴是資料庫，其風險在於，一旦資料庫暫停運行，那麼整個程序也因此而停止運行。這是因為代碼依賴資料庫伺服器。。。這已足夠。因為資料庫伺服器有時會崩潰而棄用它是荒謬的。盡管依賴有其自身的瑕疵，它仍然使代碼，因而也使程序開發人員的生活更容易些。
The problem with most dependencies its the way that code handles and interacts with them, meaning, the problem is the code and not the dependency. If you are not using dependency injection, chances are your code looks something like this:
對於大多依賴而言，問題在於代碼如何處理它們及與它們交往。也就是說，問題是代碼本身而非依賴。如果你沒有使用依賴注入，有機會遇到下列代碼：
class Book {
publicfunction __construct(){
$registry = RegistrySingleton::getInstance();
$this->_databaseConnection=$registry->databaseConnection;
// or
global$databaseConnection;
$this->_databaseConnection=$databaseConnection;
}
}
The book object now is given full access to the database once it is constructed. That is good, the book needs to be able to talk to the database and pull data. The problem lies in the way the book gained its access. In order for the book to be able to talk to the database the code must have an outside variable named $databaseConnection, or worse, it must have a singleton pattern class (registry) object containing a record for a databaseConnection. If these don』t exist the book fails, making this code is far from molar.
現在對象book一旦建立，就已經完全連到資料庫。這沒什麼不好，book需要跟資料庫交談並取得數據。問題在於book取得其接入的方法。要使book能夠與資料庫交談，代碼必須有一個外來的變數$databaseConnect, 更糟糕的是，它必須有個singleton類型類(registry)的對象，其包含一個databaseConnection的記錄。如果這些不存在的話，book會無法運行，這就使得這些代碼遠遠不夠模塊化。
This raises the question, how exactly does the book get access to the database? This is where inversion of control comes in.
這就提出一個問題，到底book如何接入資料庫？這就是IoC出現的原因了。
In Hollywood a struggling actor does not call up Martin Scorsese and ask for a role in his next film. No, the opposite happens. Martin Scorsese calls up the broke actor and asks him to play the main character in his next movie. Objects are struggling actors, they do not get to pick the roles they play, the director needs to tell them what to do. Objects do not get to pick the outside systems they interact with, instead, the outside systems are given to the objects. Remember this as Inversion of Control: The Hollywood Way.
在好萊塢，一個瀕臨絕境的演員不會打電話給Martin Scoresese要求在他的下個影片中扮演一個角色。絕不會這樣，實際正相反。Martin Scorese 會打電話給這個困頓的演員並邀請他在下一部影片中扮演重要的角色。對象是掙扎中的演員，他們不會去撿自己所扮演的角色，導演需要告訴他們去做什麼。對象不會到它所接觸的外界挑選系統，相反，外界系統會被賦予對象。記住這就是IoC( Inversion of Control):好萊塢的做法。
This is how a developer tells his objects how to interact with outside dependencies:
如下是開發人員告訴他的對象如何與外界的依賴打交道：
class Book {
publicfunction __construct(){}
publicfunction setDatabaseConnection($databaseConnection){
$this->_databaseConnection=$databaseConnection;
}
}
$book=new Book();
$book->setDatabase($databaseConnection);
This code allows for the book class to be used in any web app. The Book is no longer dependent on anything other than the developer supplying a database shortly after object creation.這代碼允許這個book類能在任何的網頁程序中使用。此book不再依賴任何事項，除了程序開發者要在對象創建後立即要提供一個資料庫。
This is, at its finest, dependency injection. There are two common practices of injecting dependencies. The first being constructor injection and the second being setter injection. Constructor injection involves passing all of the dependencies as arguments when creating a new object. The code would look something like this:
這就是最佳方法—依賴注入。有兩種常用的依賴注入的方式。一種是 constructor (註：構造函數。這種譯法似乎並不恰當，類中此方法更多是用來對某些屬性進行初始化)注入，一種是setter 注入。Constructor注入涉及到將所有依賴作為參數，傳遞給新創建的對象。看起來像這樣：
$book=new Book($databaseConnection,$configFile);
The more dependencies an object has, the messier this construction becomes. There are other reasons why this is a bad approach, involving ideas around code reusability and constructors doing work.
對象的依賴越多，construction就會變得越雜亂。這里還有其他的原因為什麼這是一個壞方法，其涉及到包括代碼重用和constructors要做的工作。
This leaves us with other method of dependency injection, called setting injection, which involves creating a public method inside the object for the dependencies that need injection.
這就給我們留下其他的方法進行依賴注入，稱為設置注入，包含在需要注入依賴的對象里創建一個公共方法：
$book=new Book();
$book->setDatabase($databaseConnection);
$book->setConfigFile($configFile);
This is easy to follow, but it leads writing more and more code for your application. When a book object is created three lines of code are required. If we have to inject another dependency, a 4th line of code is now needed. This gets messy quickly.
這很容易實現，但是它會導致為您的程序寫大量代碼。當創建一個book對象時，需要三行代碼。如果我們必須注入另外的依賴時，必須增加第四行代碼。這很快變得一團糟。
The answer to this problem is a factory, which is class that is designed to create and then inject all the dependencies needed for an object. Here is an example:
此問題的對策是一個工廠factory，它是一個類，用來創建然後注入一個對象的所有依賴。舉例如下：
class Factory {
public static $_database;
public static function makeBook(){
$book=new Book();
$book->setDatabase(self::$_database);
// more injection...（更多注入）
return$book;
}
}
And then:
然後：
$book= Factory::makeBook();
All dependencies should be registered into the factory object ring run time. This object is now the gateway that all dependencies must pass through before they can interact with any classes. In other words, this is the dependency container.
所有的依賴在運行期間都應在此factory對象中注冊。它現在是大門，在依賴可以與任何對象打交道前，都必經此門。
The reason makeBook is a public static function is for ease of use and global access. When I started this article off I made a reference to the singleton pattern and global access being a poor choices of code. They are… for the most part. It is bad design when they control access, but it is perfectly ok when they control creation. The makeBook function is only a shortcut for creation. There is no dependency what-so-ever between the book class and the factory class. The factory class exists so we can contain our dependencies in one location and automatically inject those dependencies with one line of code creation.
makeBook作為一個靜態方法的原因是易用並且可以在全局得到。在本文開頭，我提出使用singleton類型和全局變數對代碼而言是一個糟糕的選擇。多數情形下，確實如此！當他們控制接入時，是一個差設計。但是在他們控制創建時，是一個不錯的選擇。makeBook方法僅僅是創建的一個捷徑。在book類和factory類之間，沒有任何依賴。由於factory類的存在，我們的依賴可以存放在一個地點，並且用一行創建代碼就可自動注入這些依賴。
The factory or container class removes all of the extra work of dependency injection.
此處的factory或者容器類移走了依賴注入的所有額外工作。
Before injection:
以前的注入：
$book=new Book();
And now:
目前的方法：
$book= Factory::makeBook();
Hardly any extra work, but tons of extra benefits.
幾乎沒有任何的額外工作，但是有大量益處。
When test code is run, specifically unit tests, the goal is to see if a method of a class is working correctly. Since the book class requires database access to read the book data it adds a whole layer of complexity. The test has to acquire a database connection, pull data, and test it. All of a sudden the test is no longer testing a single method in the book class, it is now also testing database. If the database is offline, the test would fail. This is FAR from the goal a unit test.當運行測試代碼時，尤其是單元測試，其目標是檢查類中的方法是否正確地工作。由於book類要求接入資料庫並且讀取圖書數據，它增加了一層復雜度。此測試不得不進行資料庫連接，取得數據，然後測試它。瞬間，測試不再是測試book類中的單個方法，它目前同時也測試資料庫。如果資料庫離線，測試就會失敗。這已經遠離了單元測試的目的。
A way of dealing with this is just using a different database dependency for the unit tests. When the test suite starts up a mmy database is injected into the book. The mmy database will always have the data the developer expects it to have. If a live database was used in a unit test the data could potentially change causing tests to unnecessarily fail. There is no need for a unit test to be refactored when a record in a database changes.
解決上述問題的方法是用不同的資料庫依賴來作單元測試。當測試套件開始時，虛擬的資料庫被注入book.虛擬資料庫將永遠擁有開發人員所期待的數據。如果使用一個真實資料庫，數據的潛在變化會導致測試不必要的失敗。當資料庫的記錄改變了，不需因此重新進行單元測試。
The code is more molar because it can dropped into any other web application. Create the book object and inject a database connection with $book->setDatabase(). It does not matter if the database is in Registery::Database, $database, or $someRandomDatabaseVarible. As long as there is a database connection the book will work inside any system.
此代碼現在更加模塊化，因為它可以被放到任何其他的網頁程序。創建book對象並且用$book->setDatabase()注入資料庫連接。此時，資料庫在 Registery::Database, $database,或者$someRandomDatabaseVarible都無關大局。只要有一個資料庫連接，book就可以在任何系統內工作。
The code is more maintainable because each object given exactly what it needs. If separate database connections are required between different instances of the same class then there no extra code needed inside the class what-so-ever. Give book1 access to database1 and book2 access to database2.
代碼更加易維護，因為每個對象都被賦予了它的所需。如果同一類的實例需要不同的資料庫連接，在類內部一點兒也不需要額外的代碼。例如book1連接到資料庫1，book2連接到資料庫2
Factory::$_database=$ourDatabaseVarForDB1;
$book1= Factory::makeBook();
$book2= Factory::makeBook();
$book2->setDatabase($database2);
Dependency injection really is the answer to more maintainable, testable, molar code.
依賴注入真的是更易維護，更易測試和更加模塊化的答案。
❷ PHP如何實現依賴注入
網上都有現成的代碼。我就隨便寫一個吧
❸ php防sql注入的代碼
一、 注入式攻擊的類型
可能存在許多不同類型的攻擊動機，但是乍看上去，似乎存在更多的類型。這是非常真實的-如果惡意用戶發現了一個能夠執行多個查詢的辦法的話。本文後面，我們會對此作詳細討論。
如
果你的腳本正在執行一個SELECT指令，那麼，攻擊者可以強迫顯示一個表格中的每一行記錄-通過把一個例如"1=1"這樣的條件注入到WHERE子句中，如下所示(其中，注入部分以粗體顯示)：
SELECT * FROM wines WHERE variety = 』lagrein』 OR 1=1;』
正如我們在前面所討論的，這本身可能是很有用的信息，因為它揭示了該表格的一般結構(這是一條普通的記錄所不能實現的)，以及潛在地顯示包含機密信息的記錄。
一條更新指令潛在地具有更直接的威脅。通過把其它屬性放到SET子句中，一名攻擊者可以修改當前被更新的記錄中的任何欄位，例如下面的例子（其中，注入部分以粗體顯示）：
UPDATE wines SET type=』red』，』vintage』=』9999』 WHERE variety = 』lagrein』
通過把一個例如1=1這樣的恆真條件添加到一條更新指令的WHERE子句中，這種修改范圍可以擴展到每一條記錄，例如下面的例子（其中，注入部分以粗體顯示）：
UPDATE wines SET type=』red』，』vintage』=』9999 WHERE variety = 』lagrein』 OR 1=1;』
最危險的指令可能是DELETE-這是不難想像的。其注入技術與我們已經看到的相同-通過修改WHERE子句來擴展受影響的記錄的范圍，例如下面的例子（其中，注入部分以粗體顯示）：
DELETE FROM wines WHERE variety = 』lagrein』 OR 1=1;』
二、 多個查詢注入
多個查詢注入將會加劇一個攻擊者可能引起的潛在的損壞-通過允許多條破壞性指令包括在一個查詢中。在使用MySQL資料庫時， 攻擊者通過把一個出乎意料之外的終止符插入到查詢中即可很容易實現這一點-此時一個注入的引號(單引號或雙引號)標記期望變數的結尾；然後使用一個分號終 止該指令。現在，一個另外的攻擊指令可能被添加到現在終止的原始指令的結尾。最終的破壞性查詢可能看起來如下所示：
SELECT * FROM wines WHERE variety = 』lagrein』;
GRANT ALL ON *.* TO 』BadGuy@%』 IDENTIFIED BY 』gotcha』;』
這個注入將創建一個新的用戶BadGuy並賦予其網路特權（在所有的表格上具有所有的特權）；其中，還有一個"不祥"的口令被加入到這個簡單的SELECT語句中。如果你遵循我們在以前文章中的建議－嚴格限制該過程用戶的特權，那麼，這應該無法工作，因為web伺服器守護程序不再擁有你撤回的GRANT特權。但是從理論上講，這樣的一個攻擊可能給予BadGuy自由權力來實現他對你的資料庫的任何操作。
至 於這樣的一個多查詢是否會被MySQL伺服器處理，結論並不唯一。這其中的一些原因可能是由於不同版本的MySQL所致，但是大多數情況卻是由於多查詢存 在的方式所致。MySQL的監視程序完全允許這樣的一個查詢。常用的MySQL GUI-phpMyAdmin，在最終查詢之前會復制出以前所有的內容，並且僅僅這樣做。
但是，大多數的在一個注入上下文中的多查詢都是由PHP的mysql 擴展負責管理的。幸好，默認情況下，它是不允許在一個查詢中執行多個指令的；試圖執行兩個指令(例如上面所示的注入)將會簡單地導致失敗-不設置任何錯 誤，並且沒有生成任何輸出信息。在這種情況下，盡管PHP也只是"規規矩矩"地實現其預設行為，但是確實能夠保護你免於大多數簡單的注入式攻擊。
PHP5中的新的mysqli擴展(參考http://php.net/mysqli)，就象mysql一樣，內在地也不支持多個查詢，不過卻提供了一個mysqli_multi_query()函數以支持你實現多查詢-如果你確實想這樣做的話。
然而，對於SQLite-與PHP5綁定到一起的可嵌入的SQL資料庫引擎(參考http://sqlite.org/和http://php.net/sqlite) 情況更為可怕，由於其易於使用而吸引了大量用戶的關注。在有些情況下，SQLite預設地允許這樣的多指令查詢，因為該資料庫可以優化批查詢，特別是非常 有效的批INSERT語句處理。然而，如果查詢的結果為你的腳本所使用的話（例如在使用一個SELECT語句檢索記錄的情況下）， sqlite_query()函數卻不會允許執行多個查詢。三、 INVISION Power BOARD SQL注入脆弱性
Invision Power Board是一個著名的論壇系統。2005年五月6號，在登錄代碼中發現了一處SQL注入脆弱性。其發現
者為GulfTech Security Research的James Bercegay。
這個登錄查詢如下所示：
$DB->query("SELECT * FROM ibf_members WHERE id=$mid AND password=』$pid』");
其中，成員ID變數$mid和口令ID變數$pid被使用下面兩行代碼從my_cookie()函數中檢索出：
$mid = intval($std->my_getcookie(』member_id』));
$pid = $std->my_getcookie(』pass_hash』);
在此，my_cookie()函數使用下列語句從cookie中檢索要求的變數：
return urldecode($_COOKIE[$ibforums->vars[』cookie_id』].$name]);
【注意】從該cookie返回的值根本沒有被處理。盡管$mid在使用於查詢之前被強制轉換成一個整數，但是$pid卻保持不變。因此，它很容易遭受我們前面所討論的注入類型的攻擊。
因此，通過以如下方式修改my_cookie()函數，這種脆弱性就會暴露出來：
if ( ! in_array( $name，array(』topicsread』， 』forum_read』，』collapseprefs』) ) )
{
return $this->
clean_value(urldecode($_COOKIE[$ibforums->vars[』cookie_id』].$name]));
else
{
return urldecode($_COOKIE[$ibforums->vars[』cookie_id』].$name]);
}
經過這樣的改正之後，其中的關鍵變數在"通過"全局clean_value()函數後被返回，而其它變數卻未進行檢查。
現 在，既然我們大致了解了什麼是SQL注入，它的注入原理以及這種注入的脆弱程度，那麼接下來，讓我們探討如何有效地預防它。幸好，PHP為我們提供了豐富 的資源，因此我們有充分的信心預言，一個經仔細地徹底地使用我們所推薦的技術構建的應用程序將會從你的腳本中根本上消除任何可能性的SQL注入-通過在它 可能造成任何損壞之前"清理"你的用戶的數據來實現。
四、 界定你的查詢中的每一個值
我們推薦，你確保界定了你的查詢中的每一個值。字元串值首當其沖，以及那些你通常期望應該使用"單"(而不是"雙")引號的內容。一方面，如果你使用雙引 號來允許PHP在字元串內的變數替代，這樣可以使得輸入查詢更為容易些；另一方面，這(無可否認，只是極少量地)也會減少以後PHP代碼的分析工作。
下面，讓我們使用我們一開始使用的那個非注入式查詢來說明這個問題：
SELECT * FROM wines WHERE variety = 』lagrein』
或以PHP語句表達為：
$query = "SELECT * FROM wines WHERE variety = 』$variety』";
從技術上講，引號對於數字值來說是不需要使用的。但是，如果你並不介意用引號把例如葡萄酒這樣的一個域相應的一個值括起來並且如果你的用戶把一個空值輸入到你的表單中的話，那麼，你會看到一個類似下面的查詢：
SELECT * FROM wines WHERE vintage =
當然，這個查詢從語法上講是無效的；但是，下面的語法卻是有效的：
SELECT * FROM wines WHERE vintage = 』』
第二個查詢將(大概)不會返回任何果，但是至少它不會返回一個錯誤消息。
五、 檢查用戶提交的值的類型
從前面的討論中我們看到，迄今為止，SQL注入的主要來源往往出在一個意料之外的表單入口上。然而，當你經由一個表單向用戶提供機會提交某些值時，你應該有相當的優勢來確
定 你想取得什麼樣的輸入內容-這可以使得我們比較容易地檢查用戶入口的有效性。在以前的文章中，我們已經討論過這樣的校驗問題；所以，在此，我們僅簡單地總 結當時我們討論的要點。如果你正在期望一個數字，那麼你可以使用下面這些技術之一來確保你得到的真正是一個數字類型：
�6�1 使用is_int()函數(或is_integer()或is_long())。
�6�1 使用gettype()函數。
�6�1 使用intval()函數。
�6�1 使用settype()函數。
為 了檢查用戶輸入內容的長度，你可以使用strlen()函數。為了檢查一個期望的時間或日期是否有效，你可以使用strtotime()函數。它幾乎一定 能夠確保一位用戶的入口中沒有包含分號字元(除非標點符號可以被合法地包括在內)。你可以藉助於strpos()函數容易地實現這一點，如下所示：if( strpos( $variety， 』;』 ) ) exit ( "$variety is an invalid value for variety!" );
正如我們在前面所提到的，只要你仔細分析你的用戶輸入期望，那麼，你應該能夠很容易地檢查出其中存在的許多問題。
六、 從你的查詢中濾去每一個可疑字元
盡管在以前的文章中，我們已經討論過如何過濾掉危險字元的問題；但是在此，還是讓我們再次簡單地強調並歸納一下這個問題：
�6�1 不要使用magic_quotes_gpc指令或它的"幕後搭擋"-addslashes()函數，此函數在應用程序開發中是被限制使用的，並且此函數還要求使用額外的步驟-使用stripslashes()函數。
�6�1 相比之下，mysql_real_escape_string()函數更為常用，但是也有它自己的缺點。
❹ php怎麼實例化有依賴注入的類
PHP依賴注入的理解。分享給大家供大家參考，具體如下：
看Laravel的IoC容器文檔只是介紹實例，但是沒有說原理，之前用MVC框架都沒有在意這個概念，無意中在phalcon的文檔中看到這個詳細的介紹，感覺豁然開朗，復制粘貼過來，主要是好久沒有寫東西了，現在確實很懶變得！
首先，我們假設，我們要開發一個組件命名為SomeComponent。這個組件中現在將要注入一個資料庫連接。
在這個例子中，資料庫連接在component中被創建，這種方法是不切實際的，這樣做的話，我們將不能改變資料庫連接參數及資料庫類型等一些參數。
class SomeComponent {
/**
* The instantiation of the connection is hardcoded inside
* the component so is difficult to replace it externally
* or change its behavior
*/
public function someDbTask()
{
$connection = new Connection(array(
"host" => "localhost",
"username" => "root",
"password" => "secret",
"dbname" => "invo"
));
// ...
}
}
$some = new SomeComponent();
$some->someDbTask();
為了解決上面所說的問題，我們需要在使用前創建一個外部連接，並注入到容器中。就目前而言，這看起來是一個很好的解決方案：
class SomeComponent {
protected $_connection;
/**
* Sets the connection externally
*/
public function setConnection($connection)
{
$this->_connection = $connection;
}
public function someDbTask()
{
$connection = $this->_connection;
// ...
}
}
$some = new SomeComponent();
//Create the connection
$connection = new Connection(array(
"host" => "localhost",
"username" => "root",
"password" => "secret",
"dbname" => "invo"
));
//Inject the connection in the component
$some->setConnection($connection);
$some->someDbTask();
現在我們來考慮一個問題，我們在應用程序中的不同地方使用此組件，將多次創建資料庫連接。使用一種類似全局注冊表的方式，從這獲得一個資料庫連接實例，而不是使用一次就創建一次。
class Registry
{
/**
* Returns the connection
*/
public static function getConnection()
{
return new Connection(array(
"host" => "localhost",
"username" => "root",
"password" => "secret",
"dbname" => "invo"
));
}
}
class SomeComponent
{
protected $_connection;
/**
* Sets the connection externally
*/
public function setConnection($connection){
$this->_connection = $connection;
}
public function someDbTask()
{
$connection = $this->_connection;
// ...
}
}
$some = new SomeComponent();
//Pass the connection defined in the registry
$some->setConnection(Registry::getConnection());
$some->someDbTask();
現在，讓我們來想像一下，我們必須在組件中實現兩個方法，首先需要創建一個新的資料庫連接，第二個總是獲得一個共享連接：
class Registry
{
protected static $_connection;
/**
* Creates a connection
*/
protected static function _createConnection()
{
return new Connection(array(
"host" => "localhost",
"username" => "root",
"password" => "secret",
"dbname" => "invo"
));
}
/**
* Creates a connection only once and returns it
*/
public static function getSharedConnection()
{
if (self::$_connection===null){
$connection = self::_createConnection();
self::$_connection = $connection;
}
return self::$_connection;
}
/**
* Always returns a new connection
*/
public static function getNewConnection()
{
return self::_createConnection();
}
}
class SomeComponent
{
protected $_connection;
/**
* Sets the connection externally
*/
public function setConnection($connection){
$this->_connection = $connection;
}
/**
* This method always needs the shared connection
*/
public function someDbTask()
{
$connection = $this->_connection;
// ...
}
/**
* This method always needs a new connection
*/
public function someOtherDbTask($connection)
{
}
}
$some = new SomeComponent();
//This injects the shared connection
$some->setConnection(Registry::getSharedConnection());
$some->someDbTask();
//Here, we always pass a new connection as parameter
$some->someOtherDbTask(Registry::getConnection());
到此為止，我們已經看到了如何使用依賴注入解決我們的問題。不是在代碼內部創建依賴關系，而是讓其作為一個參數傳遞，這使得我們的程序更容易維護，降低程序代碼的耦合度，實現一種松耦合。但是從長遠來看，這種形式的依賴注入也有一些缺點。
例如，如果組件中有較多的依賴關系，我們需要創建多個setter方法傳遞，或創建構造函數進行傳遞。另外，每次使用組件時，都需要創建依賴組件，使代碼維護不太易，我們編寫的代碼可能像這樣：
//Create the dependencies or retrieve them from the registry
$connection = new Connection();
$session = new Session();
$fileSystem = new FileSystem();
$filter = new Filter();
$selector = new Selector();
//Pass them as constructor parameters
$some = new SomeComponent($connection, $session, $fileSystem, $filter, $selector);
// ... or using setters
$some->setConnection($connection);
$some->setSession($session);
$some->setFileSystem($fileSystem);
$some->setFilter($filter);
$some->setSelector($selector);
我想，我們不得不在應用程序的許多地方創建這個對象。如果你不需要依賴的組件後，我們又要去代碼注入部分移除構造函數中的參數或者是setter方法。為了解決這個問題，我們再次返回去使用一個全局注冊表來創建組件。但是，在創建對象之前，它增加了一個新的抽象層：
class SomeComponent
{
// ...
/**
* Define a factory method to create SomeComponent instances injecting its dependencies
*/
public static function factory()
{
$connection = new Connection();
$session = new Session();
$fileSystem = new FileSystem();
$filter = new Filter();
$selector = new Selector();
return new self($connection, $session, $fileSystem, $filter, $selector);
}
}
這一刻，我們好像回到了問題的開始，我們正在創建組件內部的依賴，我們每次都在修改以及找尋一種解決問題的辦法，但這都不是很好的做法。
一種實用和優雅的來解決這些問題，是使用容器的依賴注入，像我們在前面看到的，容器作為全局注冊表，使用容器的依賴注入做為一種橋梁來解決依賴可以使我們的代碼耦合度更低，很好的降低了組件的復雜性：
class SomeComponent
{
protected $_di;
public function __construct($di)
{
$this->_di = $di;
}
public function someDbTask()
{
// Get the connection service
// Always returns a new connection
$connection = $this->_di->get('db');
}
public function someOtherDbTask()
{
// Get a shared connection service,
// this will return the same connection everytime
$connection = $this->_di->getShared('db');
//This method also requires a input filtering service
$filter = $this->_db->get('filter');
}
}
$di = new Phalcon\DI();
//Register a "db" service in the container
$di->set('db', function(){
return new Connection(array(
"host" => "localhost",
"username" => "root",
"password" => "secret",
"dbname" => "invo"
));
});
//Register a "filter" service in the container
$di->set('filter', function(){
return new Filter();
});
//Register a "session" service in the container
$di->set('session', function(){
return new Session();
});
//Pass the service container as unique parameter
$some = new SomeComponent($di);
$some->someTask();
現在，該組件只有訪問某種service的時候才需要它，如果它不需要，它甚至不初始化，以節約資源。該組件是高度解耦。他們的行為，或者說他們的任何其他方面都不會影響到組件本身。我們的實現辦法
Phalcon\DI 是一個實現了服務的依賴注入功能的組件，它本身也是一個容器。
由於Phalcon高度解耦，Phalcon\DI 是框架用來集成其他組件的必不可少的部分，開發人員也可以使用這個組件依賴注入和管理應用程序中不同類文件的實例。
基本上，這個組件實現了 Inversion of Control 模式。基於此，對象不再以構造函數接收參數或者使用setter的方式來實現注入，而是直接請求服務的依賴注入。這就大大降低了整體程序的復雜性，因為只有一個方法用以獲得所需要的一個組件的依賴關系。
此外，這種模式增強了代碼的可測試性，從而使它不容易出錯。
在容器中注冊服務
框架本身或開發人員都可以注冊服務。當一個組件A要求調用組件B（或它的類的一個實例），可以從容器中請求調用組件B，而不是創建組件B的一個實例。
這種工作方式為我們提供了許多優點：
我們可以更換一個組件，從他們本身或者第三方輕松創建。
在組件發布之前，我們可以充分的控制對象的初始化，並對對象進行各種設置。
我們可以使用統一的方式從組件得到一個結構化的全局實例
服務可以通過以下幾種方式注入到容器：
//Create the Dependency Injector Container
$di = new Phalcon\DI();
//By its class name
$di->set("request", 'Phalcon\Http\Request');
//Using an anonymous function, the instance will lazy loaded
$di->set("request", function(){
return new Phalcon\Http\Request();
});
//Registering directly an instance
$di->set("request", new Phalcon\Http\Request());
//Using an array definition
$di->set("request", array(
"className" => 'Phalcon\Http\Request'
));
在上面的例子中，當向框架請求訪問一個請求數據時，它將首先確定容器中是否存在這個」reqeust」名稱的服務。
容器會反回一個請求數據的實例，開發人員最終得到他們想要的組件。
在上面示例中的每一種方法都有優缺點，具體使用哪一種，由開發過程中的特定場景來決定的。
用一個字元串來設定一個服務非常簡單，但缺少靈活性。設置服務時，使用數組則提供了更多的靈活性，而且可以使用較復雜的代碼。lambda函數是兩者之間一個很好的平衡，但也可能導致更多的維護管理成本。
Phalcon\DI 提供服務的延遲載入。除非開發人員在注入服務的時候直接實例化一個對象，然後存存儲到容器中。在容器中，通過數組，字元串等方式存儲的服務都將被延遲載入，即只有在請求對象的時候才被初始化。
//Register a service "db" with a class name and its parameters
$di->set("db", array(
"className" => "Phalcon\Db\Adapter\Pdo\Mysql",
"parameters" => array(
"parameter" => array(
"host" => "localhost",
"username" => "root",
"password" => "secret",
"dbname" => "blog"
)
)
));
//Using an anonymous function
$di->set("db", function(){
return new Phalcon\Db\Adapter\Pdo\Mysql(array(
"host" => "localhost",
"username" => "root",
"password" => "secret",
"dbname" => "blog"
));
});
以上這兩種服務的注冊方式產生相同的結果。然後，通過數組定義的，在後面需要的時候，你可以修改服務參數：
$di->setParameter("db", 0, array(
"host" => "localhost",
"username" => "root",
"password" => "secret"
));
從容器中獲得服務的最簡單方式就是使用」get」方法，它將從容器中返回一個新的實例：
$request = $di->get("request");
或者通過下面這種魔術方法的形式調用：
$request = $di->getRequest();
Phalcon\DI 同時允許服務重用，為了得到一個已經實例化過的服務，可以使用 getShared() 方法的形式來獲得服務。
具體的 Phalcon\Http\Request 請求示例：
$request = $di->getShared("request");
參數還可以在請求的時候通過將一個數組參數傳遞給構造函數的方式：
$component = $di->get("MyComponent", array("some-parameter", "other"));
❺ 怎麼能通俗易通的了解php中的反射和依賴注入這兩個概念
除非你去開發類似ZendFramework, ThinkPHP, CakePHP之類的框架，幾乎沒有機會用到這個。
這是很底層的東西，尤其是依賴注入這種東西的應用場景就是輔助開發，選型的框架支持依賴注入就行了，沒必要自己實現。而反射這個東西也差不多，在業務邏輯中我從來沒遇到過必須要靠反射解決的問題，同樣也是框架才用到。
❻ 注入漏洞是什麼意思，什麼是注入
隨著B/S模式應用開發的發展，使用這種模式編寫應用程序的程序員也越來越多。但是由於程序員的水平及經驗也參差不齊，相當大一部分程序員在編寫代碼的時候，沒有對用戶輸入數據的合法性進行判斷，使應用程序存在安全隱患。用戶可以提交一段資料庫查詢代碼，根
據程序返回的結果，獲得某些他想得知的數據，這就是所謂的SQL Injection，即SQL注入。
SQL注入是從正常的WWW埠訪問，而且表面看起來跟一般的Web頁面訪問沒什麼區別，所以目前市面的防火牆都不會對SQL注入發出警報，如果管理員沒查看IIS日誌的習慣，可能被入侵很長時間都不會發覺。但是，SQL注入的手法相當靈活，在注入的時候會碰到很多意外的情況。能不能根據具體情況進行分析，構造巧妙的SQL語句，從而成功獲取想要的數據。
據統計，網站用ASP+Access或SQLServer的佔70%以上，PHP+MySQ佔L20%，其他的不足10%。在本文，以SQL-SERVER＋ASP例說明SQL注入的原理、方法與過程。（PHP注入的文章由NB聯盟的另一位朋友zwell撰寫的有關文章）
SQL注入攻擊的總體思路是：
l 發現SQL注入位置；
l 判斷後台資料庫類型；
l 確定XP_CMDSHELL可執行情況
l 發現WEB虛擬目錄
l 上傳ASP木馬；
l 得到管理員許可權；
❼ 偽靜態php網站該如何注入滲透，求大神告知，解答下
thinkphp漏洞還是蠻多的~ 首先你要知道thinkphp的運行方法而不是盲目的去注入
比如Home/Login/index.html
Home/Login/index/ID/1
❽ PHP中如何防止SQL注入
我把問題和贊同最多的答題翻譯了下來。提問：如果用戶的輸入能直接插入到SQL語句中，那麼這個應用就易收到SQL注入的攻擊，舉個例子：$unsafe_variable = $_POST['user_input']; mysqli_query("INSERT INTO table (column) VALUES ('" . $unsafe_variable . "')");用戶可以輸入諸如 ： value'); DROP TABLE table;-- ,SQL語句就變成這樣了:INSERT INTO table (column) VALUES('value'); DROP TABLE table;--')(譯者註：這樣做的結果就是把table表給刪掉了) 我們可以做什麼去阻止這種情況呢？回答：使用prepared statements（預處理語句）和參數化的查詢。這些SQL語句被發送到資料庫伺服器，它的參數全都會被單獨解析。使用這種方式，攻擊者想注入惡意的SQL是不可能的。要實現這個主要有兩種方式：1. 使用 PDO：$stmt = $pdo->prepare('SELECT * FROM employees WHERE name = :name'); $stmt->execute(array(':name' => $name)); foreach ($stmt as $row) { // do something with $row }2. 使用 Mysqli：$stmt = $dbConnection->prepare('SELECT * FROM employees WHERE name = ?'); $stmt->bind_param('s', $name); $stmt->execute(); $result = $stmt->get_result(); while ($row = $result->fetch_assoc()) { // do something with $row }PDO需要注意的是使用PDO去訪問MySQL資料庫時，真正的prepared statements默認情況下是不使用的。為了解決這個問題，你需要禁用模擬的prepared statements。下面是使用PDO創建一個連接的例子：$dbConnection = new PDO('mysql:dbname=dbtest;host=127.0.0.1;charset=utf8', 'user', 'pass'); $dbConnection->setAttribute(PDO::ATTR_EMULATE_PREPARES, false); $dbConnection->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);上面的例子中，錯誤報告模式並不是強制和必須的，但建議你還是添加它。通過這種方式，腳本在出問題的時候不會被一個致命錯誤終止，而是拋出PDO Exceptions，這就給了開發者機會去捕獲這個錯誤。然而第一行的 setAttribute() 是強制性的，它使得PDO禁用模擬的prepared statements並使用真正的prepared statements。這可以確保這些語句和值在被發送到MySQL伺服器之前不會被PHP解析（這使得攻擊者沒有注入惡意SQL的機會）。盡管你可以使用可選的構造函數參數去設置 charset ，但重點需要注意的是小於5.3.6的PHP版本，DSN(Data Source Name)是默認忽略 charset 參數的。說明當你傳一個SQL語句做預處理時會發生什麼？它被資料庫伺服器解析和編譯了。通過指定參數（通過之前例子中的 ? 或者像 :name 這樣的命名式參數）你告訴資料庫引擎你是想過濾它。接著當你調用 execute() 函數時，prepared statements會和你剛才指定的參數的值結合。在此重要的是，參數的值是和編譯過的語句結合，而非一個SQL字元串。SQL注入就是當創建被發送到資料庫的SQL語句時，通過欺騙的手段讓腳本去引入惡意的字元串。因此當你使用單獨的參數發送真實正確的SQL時，你就限制了被某些不是你真實意圖的事情而搞掛掉的風險。使用prepared statements 傳遞的任何參數都會被當做字元串對待（不過資料庫引擎可能會做一些優化，這些參數最終也可能變成numbers）（譯者註：意思就是把參數當做一個字元串而不會去做額外的行為）。比如在上面的例子中，如果 $name 變數的值是 'Sarah'; DELETE * FROM employees ，產生的結果是會去搜索"'Sarah'; DELETE * FROM employees"這一整個字元串，最終的結果你也就不會面對的是一張空表了。使用prepared statements的另一個好處是，如果你在同一session中再次執行相同的語句，也就不會被再次解析和編譯，這樣你就獲得一些速度上的提升。
❾ ecshop中的goods.php是怎麼注入模板變數{$sort_goods_sn}的
$smarty->assign('sort_goodds_sn', '它的值');
在查找商品表時，搜索該欄位，再進行賦值，用的是smarty 的原理，你可以看看smarty 。
❿ 如何在PHP中阻止SQL注入
【一、在伺服器端配置】
安全，PHP代碼編寫是一方面，PHP的配置更是非常關鍵。
我們php手手工安裝的，php的默認配置文件在 /usr/local/apache2/conf/php.ini，我們最主要就是要配置php.ini中的內容，讓我們執行 php能夠更安全。整個PHP中的安全設置主要是為了防止phpshell和SQL Injection的攻擊，一下我們慢慢探討。我們先使用任何編輯工具打開 /etc/local/apache2/conf/php.ini，如果你是採用其他方式安裝，配置文件可能不在該目錄。
(1) 打開php的安全模式
php的安全模式是個非常重要的內嵌的安全機制，能夠控制一些php中的函數，比如system()，
同時把很多文件操作函數進行了許可權控制，也不允許對某些關鍵文件的文件，比如/etc/passwd，
但是默認的php.ini是沒有打開安全模式的，我們把它打開：
safe_mode = on
(2) 用戶組安全
當safe_mode打開時，safe_mode_gid被關閉，那麼php腳本能夠對文件進行訪問，而且相同
組的用戶也能夠對文件進行訪問。
建議設置為：
safe_mode_gid = off
如果不進行設置，可能我們無法對我們伺服器網站目錄下的文件進行操作了，比如我們需要
對文件進行操作的時候。
(3) 安全模式下執行程序主目錄
如果安全模式打開了，但是卻是要執行某些程序的時候，可以指定要執行程序的主目錄：
safe_mode_exec_dir = D:/usr/bin
一般情況下是不需要執行什麼程序的，所以推薦不要執行系統程序目錄，可以指向一個目錄，
然後把需要執行的程序拷貝過去，比如：
safe_mode_exec_dir = D:/tmp/cmd
但是，我更推薦不要執行任何程序，那麼就可以指向我們網頁目錄：
safe_mode_exec_dir = D:/usr/www
(4) 安全模式下包含文件
如果要在安全模式下包含某些公共文件，那麼就修改一下選項：
safe_mode_include_dir = D:/usr/www/include/
其實一般php腳本中包含文件都是在程序自己已經寫好了，這個可以根據具體需要設置。
(5) 控制php腳本能訪問的目錄
使用open_basedir選項能夠控制PHP腳本只能訪問指定的目錄，這樣能夠避免PHP腳本訪問
不應該訪問的文件，一定程度上限制了phpshell的危害，我們一般可以設置為只能訪問網站目錄：
open_basedir = D:/usr/www
(6) 關閉危險函數
如果打開了安全模式，那麼函數禁止是可以不需要的，但是我們為了安全還是考慮進去。比如，
我們覺得不希望執行包括system()等在那的能夠執行命令的php函數，或者能夠查看php信息的
phpinfo()等函數，那麼我們就可以禁止它們：
disable_functions = system,passthru,exec,shell_exec,popen,phpinfo
如果你要禁止任何文件和目錄的操作，那麼可以關閉很多文件操作
disable_functions = chdir,chroot,dir,getcwd,opendir,readdir,scandir,fopen,unlink,delete,,mkdir, rmdir,rename,file,file_get_contents,fputs,fwrite,chgrp,chmod,chown
以上只是列了部分不叫常用的文件處理函數，你也可以把上面執行命令函數和這個函數結合，
就能夠抵制大部分的phpshell了。
(7) 關閉PHP版本信息在http頭中的泄漏
我們為了防止黑客獲取伺服器中php版本的信息，可以關閉該信息斜路在http頭中：
expose_php = Off
比如黑客在 telnet www.12345.com 80 的時候，那麼將無法看到PHP的信息。
(8) 關閉注冊全局變數
在PHP中提交的變數，包括使用POST或者GET提交的變數，都將自動注冊為全局變數，能夠直接訪問，
這是對伺服器非常不安全的，所以我們不能讓它注冊為全局變數，就把注冊全局變數選項關閉：
register_globals = Off
當然，如果這樣設置了，那麼獲取對應變數的時候就要採用合理方式，比如獲取GET提交的變數var，
那麼就要用$_GET['var']來進行獲取，這個php程序員要注意。
(9) 打開magic_quotes_gpc來防止SQL注入
SQL注入是非常危險的問題，小則網站後台被入侵，重則整個伺服器淪陷，
所以一定要小心。php.ini中有一個設置：
magic_quotes_gpc = Off
這個默認是關閉的，如果它打開後將自動把用戶提交對sql的查詢進行轉換，
比如把 ' 轉為 \'等，這對防止sql注射有重大作用。所以我們推薦設置為：
magic_quotes_gpc = On
(10) 錯誤信息控制
一般php在沒有連接到資料庫或者其他情況下會有提示錯誤，一般錯誤信息中會包含php腳本當
前的路徑信息或者查詢的SQL語句等信息，這類信息提供給黑客後，是不安全的，所以一般伺服器建議禁止錯誤提示：
display_errors = Off
如果你卻是是要顯示錯誤信息，一定要設置顯示錯誤的級別，比如只顯示警告以上的信息：
error_reporting = E_WARNING & E_ERROR
當然，我還是建議關閉錯誤提示。
(11) 錯誤日誌
建議在關閉display_errors後能夠把錯誤信息記錄下來，便於查找伺服器運行的原因：
log_errors = On
同時也要設置錯誤日誌存放的目錄，建議根apache的日誌存在一起：
error_log = D:/usr/local/apache2/logs/php_error.log
注意：給文件必須允許apache用戶的和組具有寫的許可權。
MYSQL的降權運行
新建立一個用戶比如mysqlstart
net user mysqlstart fuckmicrosoft /add
net localgroup users mysqlstart /del
不屬於任何組
如果MYSQL裝在d:\mysql ，那麼，給 mysqlstart 完全控制 的許可權
然後在系統服務中設置，MYSQL的服務屬性，在登錄屬性當中，選擇此用戶 mysqlstart 然後輸入密碼，確定。
重新啟動 MYSQL服務，然後MYSQL就運行在低許可權下了。
如果是在windos平台下搭建的apache我們還需要注意一點，apache默認運行是system許可權，
這很恐怖，這讓人感覺很不爽.那我們就給apache降降許可權吧。
net user apache fuckmicrosoft /add
net localgroup users apache /del
ok.我們建立了一個不屬於任何組的用戶apche。
我們打開計算機管理器，選服務，點apache服務的屬性，我們選擇log on，選擇this account，我們填入上面所建立的賬戶和密碼，
重啟apache服務，ok，apache運行在低許可權下了。
實際上我們還可以通過設置各個文件夾的許可權，來讓apache用戶只能執行我們想讓它能乾的事情，給每一個目錄建立一個單獨能讀寫的用戶。
這也是當前很多虛擬主機提供商的流行配置方法哦，不過這種方法用於防止這里就顯的有點大材小用了。
【二、在PHP代碼編寫】
雖然國內很多PHP程序員仍在依靠addslashes防止SQL注入，還是建議大家加強中文防止SQL注入的檢查。addslashes的問題在於黑客可以用0xbf27來代替單引號，而addslashes只是將0xbf27修改為0xbf5c27，成為一個有效的多位元組字元，其中的0xbf5c仍會被看作是單引號，所以addslashes無法成功攔截。
當然addslashes也不是毫無用處，它是用於單位元組字元串的處理，多位元組字元還是用mysql_real_escape_string吧。
另外對於php手冊中get_magic_quotes_gpc的舉例：
if (!get_magic_quotes_gpc()) {
$lastname = addslashes($_POST[『lastname』]);
} else {
$lastname = $_POST[『lastname』];
}
最好對magic_quotes_gpc已經開放的情況下，還是對$_POST[』lastname』]進行檢查一下。
再說下mysql_real_escape_string和mysql_escape_string這2個函數的區別：
mysql_real_escape_string 必須在(PHP 4 >= 4.3.0, PHP 5)的情況下才能使用。否則只能用 mysql_escape_string ，兩者的區別是：mysql_real_escape_string 考慮到連接的
當前字元集，而mysql_escape_string 不考慮。
總結一下：
* addslashes() 是強行加\；
* mysql_real_escape_string() 會判斷字元集，但是對PHP版本有要求；
* mysql_escape_string不考慮連接的當前字元集。
-------------------------------------------------------------------------------------------------
在PHP編碼的時候，如果考慮到一些比較基本的安全問題，首先一點：
1. 初始化你的變數
為什麼這么說呢？我們看下面的代碼：
PHP代碼
<?php
if ($admin)
{
echo '登陸成功！';
include('admin.php');
}
else
{
echo '你不是管理員，無法進行管理！';
}
?>
好，我們看上面的代碼好像是能正常運行，沒有問題，那麼加入我提交一個非法的參數過去呢，那麼效果會如何呢？比如我們的這個頁是http://daybook.diandian.com/login.php，那麼我們提交：http://daybook.diandian.com/login.php?admin=1，呵呵，你想一些，我們是不是直接就是管理員了，直接進行管理。
當然，可能我們不會犯這么簡單錯的錯誤，那麼一些很隱秘的錯誤也可能導致這個問題，比如phpwind論壇有個漏洞，導致能夠直接拿到管理員許可權，就是因為有個$skin變數沒有初始化，導致了後面一系列問題。那麼我們如何避免上面的問題呢？首先，從php.ini入手，把php.ini裡面的register_global =off，就是不是所有的注冊變數為全局，那麼就能避免了。但是，我們不是伺服器管理員，只能從代碼上改進了，那麼我們如何改進上面的代碼呢？我們改寫如下：
PHP代碼
<?php
$admin = 0; // 初始化變數
if ($_POST['admin_user'] && $_POST['admin_pass'])
{
// 判斷提交的管理員用戶名和密碼是不是對的相應的處理代碼
// ...
$admin = 1;
}
else
{
$admin = 0;
}
if ($admin)
{
echo '登陸成功！';
include('admin.php');
}
else
{
echo '你不是管理員，無法進行管理！';
}
?>
那麼這時候你再提交http://daybook.diandian.com/login.php?admin=1就不好使了，因為我們在一開始就把變數初始化為 $admin = 0 了，那麼你就無法通過這個漏洞獲取管理員許可權。
2. 防止SQL Injection (sql注射)
SQL 注射應該是目前程序危害最大的了，包括最早從asp到php，基本上都是國內這兩年流行的技術，基本原理就是通過對提交變數的不過濾形成注入點然後使惡意用戶能夠提交一些sql查詢語句，導致重要數據被竊取、數據丟失或者損壞，或者被入侵到後台管理。
那麼我們既然了解了基本的注射入侵的方式，那麼我們如何去防範呢？這個就應該我們從代碼去入手了。
我們知道Web上提交數據有兩種方式，一種是get、一種是post，那麼很多常見的sql注射就是從get方式入手的，而且注射的語句裡面一定是包含一些sql語句的，因為沒有sql語句，那麼如何進行，sql語句有四大句：select 、update、delete、insert，那麼我們如果在我們提交的數據中進行過濾是不是能夠避免這些問題呢？
於是我們使用正則就構建如下函數：
PHP代碼
<?php
function inject_check($sql_str)
{
return eregi('select|insert|update|delete|'|
function verify_id($id=null)
{
if (!$id) { exit('沒有提交參數！'); } // 是否為空判斷
elseif (inject_check($id)) { exit('提交的參數非法！'); } // 注射判斷
elseif (!is_numeric($id)) { exit('提交的參數非法！'); } // 數字判斷
$id = intval($id); // 整型化
return $id;
}
?>
呵呵，那麼我們就能夠進行校驗了，於是我們上面的程序代碼就變成了下面的：
PHP代碼
<?php
if (inject_check($_GET['id']))
{
exit('你提交的數據非法，請檢查後重新提交！');
}
else
{
$id = verify_id($_GET['id']); // 這里引用了我們的過濾函數，對$id進行過濾
echo '提交的數據合法，請繼續！';
}
?>
好，問題到這里似乎都解決了，但是我們有沒有考慮過post提交的數據，大批量的數據呢？
比如一些字元可能會對資料庫造成危害，比如 ' _ ', ' %'，這些字元都有特殊意義，那麼我們如果進行控制呢？還有一點，就是當我們的php.ini裡面的magic_quotes_gpc = off的時候，那麼提交的不符合資料庫規則的數據都是不會自動在前面加' '的，那麼我們要控制這些問題，於是構建如下函數：
PHP代碼
<?php
function str_check( $str )
{
if (!get_magic_quotes_gpc()) // 判斷magic_quotes_gpc是否打開
{
$str = addslashes($str); // 進行過濾
}
$str = str_replace("_", "\_", $str); // 把 '_'過濾掉
$str = str_replace("%", "\%", $str); // 把' % '過濾掉
return $str;
}
?>
我們又一次的避免了伺服器被淪陷的危險。
最後，再考慮提交一些大批量數據的情況，比如發貼，或者寫文章、新聞，我們需要一些函數來幫我們過濾和進行轉換，再上面函數的基礎上，我們構建如下函數：
PHP代碼
<?php
function post_check($post)
{
if (!get_magic_quotes_gpc()) // 判斷magic_quotes_gpc是否為打開
{
$post = addslashes($post); // 進行magic_quotes_gpc沒有打開的情況對提交數據的過濾
}
$post = str_replace("_", "\_", $post); // 把 '_'過濾掉
$post = str_replace("%", "\%", $post); // 把' % '過濾掉
$post = nl2br($post); // 回車轉換
$post= htmlspecialchars($post); // html標記轉換
return $post;
}
?>
呵呵，基本到這里，我們把一些情況都說了一遍，其實我覺得自己講的東西還很少，至少我才只講了兩方面，再整個安全中是很少的內容了，考慮下一次講更多，包括php安全配置，apache安全等等，讓我們的安全正的是一個整體，作到最安全。
最後在告訴你上面表達的：1. 初始化你的變數 2. 一定記得要過濾你的變數