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. 一定记得要过滤你的变量