189 8069 5689
一、 注入式攻击的类型
成都网站设计、成都网站建设、外贸网站建设服务团队是一支充满着热情的团队，执着、敏锐、追求更好，是创新互联的标准与要求，同时竭诚为客户提供服务是我们的理念。创新互联把每个网站当做一个产品来开发，精雕细琢，追求一名工匠心中的细致，我们更用心！
可能存在许多不同类型的攻击动机，但是乍看上去，似乎存在更多的类型。这是非常真实的-如果恶意用户发现了一个能够执行多个查询的办法的话。本文后面，我们会对此作详细讨论。
如
果你的脚本正在执行一个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扩展(参考)，就象mysql一样，内在地也不支持多个查询，不过却提供了一个mysqli_multi_query()函数以支持你实现多查询-如果你确实想这样做的话。
然而，对于SQLite-与PHP5绑定到一起的可嵌入的SQL数据库引擎(参考和) 情况更为可怕，由于其易于使用而吸引了大量用户的关注。在有些情况下，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依赖注入的理解。分享给大家供大家参考，具体如下：
看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"));
我在PHP4环境下写了一个防SQL注入的代码，经过实际使用在PHP5下也兼容，欢迎大家使用修改，使用。
代码如下：
?php
/*
sqlin 防注入类
*/
class sqlin
{
//dowith_sql($value)
function dowith_sql($str)
{
$str = str_replace("and","",$str);
$str = str_replace("execute","",$str);
$str = str_replace("update","",$str);
$str = str_replace("count","",$str);
$str = str_replace("chr","",$str);
$str = str_replace("mid","",$str);
$str = str_replace("master","",$str);
$str = str_replace("truncate","",$str);
$str = str_replace("char","",$str);
$str = str_replace("declare","",$str);
$str = str_replace("select","",$str);
$str = str_replace("create","",$str);
$str = str_replace("delete","",$str);
$str = str_replace("insert","",$str);
$str = str_replace("'","",$str);
$str = str_replace(""","",$str);
$str = str_replace(" ","",$str);
$str = str_replace("or","",$str);
$str = str_replace("=","",$str);
$str = str_replace("%20","",$str);
//echo $str;
return $str;
}
//aticle()防SQL注入函数
function sqlin()
{
foreach ($_GET as $key=$value)
{
$_GET[$key]=$this-dowith_sql($value);
}
foreach ($_POST as $key=$value)
{
$_POST[$key]=$this-dowith_sql($value);
}
}
}
$dbsql=new sqlin();
?
===================================================================================
使用方式：
将以上代码复制新建一个sqlin.php的文件，然后包含在有GET或者POST数据接收的页面
原理：
将所有的SQL关键字替换为空.
给你个例子，是用随机数与session来解决的，请根据你的实际情况进行修改
?php
session_start();
//判断是否刷新*********************
if(isset($_POST['mark'])) {
if($_POST['mark'] == $_SESSION['code']) {
// 处理该表单的语句。。。
}
else {
// 处理刷新时的语句。。。
}
}
//END******************************
$code = mt_rand(0,1000000);
$_SESSION['code'] = $code;
?
form name=form1 method="post"
input type="text" name="text" /
input type="submit" value="submit" /
input type="hidden" name="mark" value="?php echo $code;?"
/form
依赖注入可能是我所知道的最简单设计模式之一，很多情况下可能你无意识中已经使用了依赖注入。不过它也是最难解释的一个。我认为有一部分原因是由于大多数介绍依赖注入的例子缺乏实际意义，让人难理解。因为PHP主要用于Web开发，那就先来看一个简单的web开发实例。
HTTP本身是一个无状态的连接协议，为了支持客户在发起WEB请求时应用程序能存储用户信息，我们就需要通过一种技术来实现存储状态交互。理所当然最简单的是使用cookie，更好的方式是PHP内置的Session机制。
$_SESSION['language'] = 'fr';
上面代码将用户语言存储在了名为language的Session变量中，因此在该用户随后的请求中，可以通过全局数组$_SESSION来获取language：
$user_language = $_SESSION['language'];
依赖注入主要用于面向对像开发，现在让我们假设我们有一个SessionStorage类，该类封装了PHP Session机制：
class SessionStorage
{
function __construct($cookieName = 'PHP_SESS_ID')
{
session_name($cookieName);
session_start();
}
function set($key, $value)
{
$_SESSION[$key] = $value;
}
function get($key)
{
return $_SESSION[$key];
}
// ...
}
同时还有一个User类提供了更高级的封装：
class User
{
protected $storage;
function __construct()
{
$this-storage = new SessionStorage();
}
function setLanguage($language)
{
$this-storage-set('language', $language);
}
function getLanguage()
{
return $this-storage-get('language');
}
// ...
}
代码很简单，同样使用User类也很简单：
$user = new User();
$user-setLanguage('fr');
$user_language = $user-getLanguage();
一切都很美好，除非你的程序需要更好的扩展性。假设现在你想要更改保存session_id的COOKIE键值，以下有一些可供选择的方法：
User类中创建SessionStorage实例时，在SessionStorage构造方法中使用字符串’SESSION_ID’硬编码:
class User
{
function __construct()
{
$this-storage = new SessionStorage('SESSION_ID');
}
// ...
}
在User类外部设置一个常量(名为STORAGE_SESSION_NAME)
class User
{
function __construct()
{
$this-storage = new SessionStorage(STORAGE_SESSION_NAME);
}
// ...
}
define('STORAGE_SESSION_NAME', 'SESSION_ID');
通过User类构造函数中的参数传递Session name
class User
{
function __construct($sessionName)
{
$this-storage = new SessionStorage($sessionName);
}
// ...
}
$user = new User('SESSION_ID');
还是通过User类构造函数中的参数传递Session name，不过这次参数采用数组的方式
class User
{
function __construct($storageOptions)
{
$this-storage = new SessionStorage($storageOptions['session_name']);
}
// ...
}
$user = new User(array('session_name' = 'SESSION_ID'));
上面的方式都很糟糕。
在user类中硬编码设置session name的做法没有真正解决问题，如果以后你还需要更改保存session_id的COOKIE键值，你不得不再一次修改user类(User类不应该关心COOKIE键值)。
使用常量的方式同样很糟，造成User类依赖于一个常量设置。
通过User类构造函数的参数或数组来传递session name相对来说好一些，不过也不完美，这样做干扰了User类构造函数的参数，因为如何存储Session并不是User类需要关心的，User类不应该和它们扯上关联。
另外，还有一个问题不太好解决：我们如何改变SessionStorage类。这种应用场景很多，比如你要用一个Session模拟类来做测试，或者你要将Session存储在数据库或者内存中。目前这种实现方式，在不改变User类的情况下，很难做到这点。
现在，让我们来使用依赖注入。回忆一下，之前我们是在User类内部创建SessionStorage对像的，现在我们修改一下，让SessionStorage对像通过User类的构造函数传递进去。
class User
{
function __construct($storage)
{
$this-storage = $storage;
}
// ...
这就是依赖注入最经典的案例，没有之一。现在使用User类有一些小小的改变，首先你需要创建SessionStorage对像。
$storage = new SessionStorage('SESSION_ID');
$user = new User($storage);
现在，配置session存储对像很简单了，同样如果改变session存储对像也很简单，所有这一切并不需要去更新User类，降低了业务类之间的耦合。
Pico Container 的网站上是这样描述依赖注入：
依赖注入是通过类的构造函数、方法、或者直接写入的方式，将所依赖的组件传递给类的方式。
所以依赖注入并不只限于通过构造函数注入。下面来看看几种注入方式：
构造函数注入
class User
{
function __construct($storage)
{
$this-storage = $storage;
}
// ...
}
setter方法注入
class User
{
function setSessionStorage($storage)
{
$this-storage = $storage;
}
// ...
}
属性直接注入
class User
{
public $sessionStorage;
}
$user-sessionStorage = $storage;
根据经验，一般通过构造函数注入的是强依赖关系的组件，setter方式用来注入可选的依赖组件。
现在，大多数流行的PHP框架都采用了依赖注入的模式实现业务组件间的高内聚低耦合。
// symfony: 构造函数注入的例子
$dispatcher = new sfEventDispatcher();
$storage = new sfMySQLSessionStorage(array('database' = 'session', 'db_table' = 'session'));
$user = new sfUser($dispatcher, $storage, array('default_culture' = 'en'));
// Zend Framework: setter方式注入的例子
$transport = new Zend_Mail_Transport_Smtp('smtp.gmail.com', array(
'auth' = 'login',
'username' = 'foo',
'password' = 'bar',
'ssl' = 'ssl',
'port' = 465,
));
$mailer = new Zend_Mail();
$mailer-setDefaultTransport($transport);
在PHP文件头部这样写
if(get_magic_quotes_gpc())
{
foreach($_GET as $k = $v) $_GET[$k] = stripslashes($v);
}