ASP.NET个人博客系统的设计与实现|个人网站

摘要

基于Microsoft.Net环境的ASP.NET技术,为开发功能强大的动态网站提供了一种简单、高效的途径。该博客系统以ASP.NET为开发技术，使用C＃为开发语言，实现了博客网站的动态管理，使得对博客信息的管理更加及时、高效，提高了工作效率。同时对系统的背景需求、系统的功能特点和设计方案进行了介绍。该文还以随笔管理为例，对ASP.NET环境下的MVC开发模式进行了简单的介绍。.

关键字：ASP.NET；ADO.NET；博客；系统；数据库

ABSTRACT

Based on Microsoft.Net frame, The ASP.NET provides a simple, efficient way to develop a dynamic web site . The blog system takes ASP.NET as the development technology, uses C # as the development language, has realized the blog website dynamic management, caused to the blog information management even more prompt, to be highly effective, enhanced the working efficiency. Meanwhile , They take an introduction on the system background demand, the system function characteristic and the design project.This article also introduces the MVC pattern under ASP.NET environment by taking an example for the users’ management.

Keywords  ：ASP.NET；ADO.NET,；Blog；System；DataBase

目  录

第1章    引言... 1

1.1 选题背景... 1

1.2 研究目标和意义... 1

1.3 研究思路... 2

第2章    需求分析描述... 3

2.1 ASP.NET 概述... 3

2.1.1 执行效率的大幅提高... 3

2.1.2世界级工具的支持... 3

2.1.3强大性和适应性... 3

2.1.4简易性和易学性... 3

2.1.5高效可管理性... 3

2.1.6多处理器环境的可靠性... 4

2.1.7自定义性和可扩展性... 4

2.1.8安全性... 4

2.2  第一个ASP,NET程序... 4

2.3 ASP.NET基础知识... 5

2.3.1  ASP.NET基本对象... 5

2.3.2  ASP.NET基本控件... 7

2.3.3数据验证... 8

2.3.4 ADO.NET. 8

2.3.5数据绑定... 10

2.4 需求概要介绍... 11

2.4.1、收益需求... 11

2.4.2、日常功能... 11

2.4.3、通过论坛来了解各博客用户的需求... 11

2.4.4、制作邮件调查表... 11

2.4.5设计基本功能... 11

2.4.6设计扩展功能... 12

2.4.6 设计可以扩充功能的接口... 13

2.5 创建流程图... 13

2.6详细描述用例（举例）... 14

第3章    系统分析... 17

3.1        系统中的对象... 17

3.2 开发技术分析... 17

3.2.1多语言... 17

3.2.2服务器处理... 17

3.3 健壮性分析（举例）... 18

3.3.1 事件流分析    …………………………………………………………19

3.3.2 边界对象分析    19

3.3.3 实体对象分析    19

3.3.4 控制对象分析    19

3.4交互设计... 20

3.4.1引入实体对象... 20

3.4.2引入边界对象和参与者... 20

3.4.3 引入控制对象    20

3.4.4 添加类的属性与方法... 20

3.4.5 引入基础类    …………………………………………………………20

第4章    代码实现... 21

4.1 编码之前的工作... 21

4.1.1 在visual studio.net中创建解决方案... 21

4.1.2 文件夹的规划    21

4.2.1 什么是MVC模式？... 21

4.2.2 ASP.NET模式下如何实现MVC？... 22

4.3 用户组件和样式的设计... 22

4.5 系统实现... 26

4.5.1 系统结构图    …………………………………………………………26

4.5.2代码实现... 29

第5章    测试... 40

5.1.引入实体对象... 40

5.2.引入边界对象和参与者... 40

5.3.引入控制对象... 41

5.4.添加类的属性与方法... 41

5.5.引入基类型... 41

结束语    ………………………………………………………………………………..43

参考文献    44

致  谢    ………………………………………………………………………………..45

外文资料原文... 46

翻译文稿    49

                                                                                                                                                              第1章  引言

1.1  选题背景

“博客”一词是从英文单词Blog翻译而来。Blog是Weblog的简称，而Weblog则是由Web和Log两个英文单词组合而成。Weblog就是在网络上发布和阅读的流水记录，通常称为“网络日志”，简称为“网志”。它是继Email、BBS、IM之后出现的第四种全新的网络交流方式。它绝不仅仅是一种单向的发布系统，而且有着极其出色的交流功能。另外Blog也提供了非常方便实用的个性化功能。简言之，Blog就是以网络作为载体，简易迅速便捷地发布自己的心得，及时有效轻松地与他人进行交流，再集丰富多彩的个性化展示于一体的综合性平台。

1.2  研究目标和意义

如果说文化是一种生活状态，那么博客文化就是网上最平凡的生活状态之一。也正是这种平凡，才使得博客具有亲和力。加入博客几乎是“零门槛”，并不需要什么特殊技能。以文字为主的博客甚至抛开了视频、声音、图片等表现形式，它以文字最质朴的方式表达人们对生活的态度。只需要一台电脑、一个键盘和思想，你就可以成为博客的一员。网络从第一波的商业化，到后来的收费短信，承载了太多的商业化诉求。也许人们面对越来越华丽的网站制作感到了厌倦，反而觉得质朴的博客最能反映自己的思想，感受网络的平等和自由。

在网络这个大林子里，大鸟、菜鸟、或群居、或四处漂流，各自生存、互不干涉。早些时候，博客也不过是其中普通一种鸟罢了，并无特别之处。但不经意间，博客竟如雨后春笋般冒出来，博得了越来越多网民的欢心，并引发了各种新的应用热潮。它最大的吸引力在于，只要你会发邮件，就可以轻松创建自己的网络媒体。

一般一个博客就是一个页面，它通常由简单而且更新的帖子构成，所有文章都是按照年份和日期排列，有些类似斑竹的日记。看上去平淡无奇，毫无可炫耀之处，但它可以让每个人零成本 、零维护地创建自己的网络媒体，每个人都可以随时把自己的思想火花和灵感更新到博客站点上。

博客的人性化和平民视角使得它提供的消息更贴近人们的生活，而且他们搜集到的新闻资料大多是第一手资料。伊拉克战争就使得上百个个人博客网站成为传统站点消息的来源。

博客的操作方式非常简单，点点鼠标 、敲敲键盘 、随笔 、合影 、链接片刻之间就会出现在博客站点之上。

建立一个博客就是那么简单，有个博客系统的初体验，你还犹豫吗？建立自己的博客吧。在本论文中，我将创建一个自己的个人博客系统，来展示它。

1.3  研究思路

本文通过实现个人博客系统，来对一个完整的博客系统项目进行分析和实现并且针对性的进行测试。下面是各个章节的概要介绍。

第1章的是博客项目的背景及相关描述。

第2章 将向你讲述博客系统的调研过程，和你一起探讨任何进行客户会谈，如何抽取系统的功能，如何进行需求的描述。

第3章 将向你展示实用UML进行系统分析和设计的过程，特别是如何进行系统的健壮性分析，是本论文的重点。

第4章 实现博客系统，分析如何进行代码规范 、检查和单元测试。另外，还将实现文件上传、验证码的生成、图像的缩略生成等功能的实现，这样可以轻而易举地将它们移植到系统中。

第5章 介绍交互测试的方法 、性能测试的方法和Application Test Center工具

第6章 总结项目

结束语

   根据Blog要以网络作为载体，简易迅速便捷地发布自己的心得，及时有效轻松地与他人进行交流，再集丰富多彩的个性化展示于一体的综合性平台的需求前景，从软件工程的角度来实现该系统，先研究分析了市场的需求前景，后进行需求分析，之后代码实现，最后测试和安装调试。本文通过实现个人博客系统，来对一个完整的博客系统项目进行分析和实现并且针对性的进行测试。系统虽然简单，但是完全按照软件工程流程进行设计和开发，设计严谨合理，界面简洁，用户操作方便。

   本系统采用MS ASP.NET2.0开发环境，MS SQL Server2000数据库。部署在Windows 操作系统IIS服务器上。

参考文献

[1] ASP.NET高级编程             清华大学出版社

[2] ASP.NET从入门到精通             人民邮电出版社

[3] 程序员大本营.Net版(CHM)

[4] Madeleine E Pullman, Gary Thompson. Strategies for integrating capacity with demand in service networks, Journal of Service Research, 2003, Vol.5,No.6:16~20

[5] 用XML轻松开发WEB站点

[6] asp.net宝典

[7] C#.NET 开发者手册

[8] Kenneth J Klassen, Thomas R Rohleder, Combining operations and marketing to manage capacity and demand in services, The Service Industries Journal, 2001, Vol.21,No.2:25~30

[9] Rhyne, David M, the Impact of Demand Management on Service System Performa, the Service Industries Journal, 1988, Vol.8,No.4:26~31

[10] Douglas R Moodie，Demand management: The evaluation of price and due date negotiation strategies using simulation，Production and Operations Management, 1999, Vol.8, No.2:15~23

[11] Eitan Altman, Uri Yechiali, Analysis of customers' impatience in queues with server vacations，Queuing Systems, 2006, Vol.52,No.4:61~63

[12] MySQL开发者SQL权威指南

[13] SQL Server 程序设计 

[14] Ward Whitt, Sensitivity of Performance in the Erlang-A Queuing Model to Changes in the Model Parameters, Operations Research, 2006, Vol.54,No.2:14~18

致  谢

本文是在刘启和老师的热情关心和指导下完成的，他渊博的知识和严谨的治学态度使我受益匪浅，对顺利完成本课题起到了极大的作用。在此向他表示我最衷心的感谢！

此外还要感谢辛勤培育我的老师们，及朝夕相处的同学们，他们的关心使我充满动力，他们在系统设计初期给予的帮助，使此系统的开发，有了一个很好的开端！感谢同学们在专业知识上给予我的帮助，因为他们的协助，才得以顺利完成了设计！

在论文完成过程中，本人还得到了其他老师和许多同学的热心帮助，本人向他们表示深深的谢意！

最后向在百忙之中评审本文的各位专家、老师表示衷心的感谢！

外文资料原文

Web MVC with the Spring Framework

Juergen Hoeller

1.      Introduction: Spring the Application Framework

When first confronted with the Spring Framework, one might be tempted to think: "Oh no, not yet another web framework". This article will outline why Spring isn't particularly a web framework but a generic lightweight application framework with dedicated web support, and show the architectural differences to Struts and WebWork

In contrast to Struts or WebWork, Spring is an application framework for all layers: It offers a bean configuration foundation, AOP support, a JDBC abstraction framework, abstract transaction support, etc. It is a very non-intrusive effort: Your application classes do not need to depend on any Spring classes if not necessary, and you can reuse every part on its own if you like to. From its very design, the framework encourages clean separation of tiers, most importantly web tier and business logic: e.g. the validation framework does not depend on web controllers. Major goals are reusability and testability: Unnecessary container or framework dependencies can be considered avoidable evils.

Of course, Spring's own web support is nicely integrated with the framework's general patterns. Nevertheless, replacing the web solution with Struts, WebWork, or the like is easy. Both with Spring's web support or a different one, Spring allows for building a true dedicated middle tier in the web container, with the option to reuse exactly the same business logic in test environments or standalone applications. And within J2EE, your business logic will not unnecessarily depend on container services like JTA or EJB - allowing complex, well-architected web applications to run in a "simple" container like Tomcat or Resin.

Note that Spring doesn't generally aim to compete with existing solutions. It rather fosters seamless integration with standards like Servlet, JSP, JTA, JNDI, JDBC, and JDO, and well-suited tools like Hibernate, Velocity, Log4J, and Caucho's Hessian/Burlap. The framework is designed to grow with the needs of your applications, in terms of technology choice: For example, you will probably use JTA via Spring's JtaTransactionManager if you need distributed transactions - but only then, as there are perfect replacements for single databases, like DataSourceTransactionManager or HibernateTransactionManager.

2.      Web MVC: The Design of Spring's Web Framework

Spring's web framework is designed around a DispatcherServlet that dispatches requests to handlers, with configurable handler mappings, view resolution, and locale and theme resolution. The default handler is a very simple Controller interface, just offering a "ModelAndView handleRequest(request,response)" method. This can already be used for application controllers, but you will prefer the included implementation hierarchy, consisting of AbstractController, AbstractCommandController, MultiActionController, SimpleFormController, AbstractWizardFormController. Application controllers will typically be subclasses of those. Note that you can choose an appropriate base class: If you don't have a form, you don't need a FormController. This is a major difference to Struts.

You can take any object as command or form object: There's no need to implement an interface or derive from a base class. Spring's data binding is highly flexible, e.g. it treats type mismatches as validation errors that can be evaluated by the application, not as system errors. So you don't need to duplicate your business objects' properties as Strings in your form objects, just to be able to handle invalid submissions, or to convert the Strings properly. Instead, it's often preferable to bind directly to your business objects. This is another major difference to Struts which is built around required base classes like Action and ActionForm - for every type of action.  Compared to WebWork, Spring has more differentiated object roles: It supports the notion of a Controller, an optional command or form object, and a model that gets passed to the view. The model will normally include the command or form object but also arbitrary reference data. Instead, a WebWork Action combines all those roles into one single object. WebWork does allow you to use existing business objects as part of your form, but just by making them bean properties of the respective Action class. Finally, the same Action instance that handles the request gets used for evaluation and form population in the view. Thus, reference data needs to be modelled as bean properties of the Action too. These are arguably too many roles in one object.

Regarding views: Spring's view resolution is extremely flexible. A Controller implementation can even write a view directly to the response, returning null as ModelAndView. In the normal case, a ModelAndView instance consists of a view name and a model Map, containing bean names and corresponding objects (like a command or form, reference data, etc). View name resolution is highly configurable, either via bean names, via a properties file, or via your own ViewResolver implementation. The abstract model Map allows for complete abstraction of the view technology, without any hassle: Be it JSP, Velocity, or anything else - every renderer can be integrated directly. The model Map simply gets transformed into an appropriate format, like JSP request attributes or a Velocity template model.

3.      Integration: Using a Different Web Framework with Spring

Many teams will try to leverage their investments in terms of know-how and tools, both for existing projects and for new ones. Concretely, there are not only a large number of books and tools for Struts but also a lot of developers that have experience with it. Thus, if you can live with Struts' architectural flaws, it can still be a viable choice for the web layer. The same applies to WebWork and other web frameworks.

If you don't want to use Spring's web MVC but intend to leverage other solutions that Spring offers, you can integrate the web framework of your choice with Spring easily. Simply start up a Spring root application context via its ContextLoaderListener, and access it via its ServletContext attribute (or Spring's respective helper method) from within a Struts or WebWork action. Note that there aren't any "plugins" involved, therefore no dedicated integration: From the view of the web layer, you'll simply use Spring as a library, with the root application context instance as entry point. All your registered beans and all of Spring's services can be at your fingertips even without Spring's web MVC. Spring doesn't compete with Struts or WebWork in this usage, it just addresses the many areas that the pure web frameworks don't, from bean configuration to data access and transaction handling. So you are able to enrich your application with a Spring middle tier and/or data access tier, even if you just want to use e.g. the transaction abstraction with JDBC or Hibernate.

4.      Feature Check List

If just focussing on the web support, some of Spring's unique features are: .Clear separation of roles: controller vs validator vs command object vs form object vs model object, DispatcherServlet vs handler mapping vs view resolver, etc. .Powerful and straightforward configuration of both framework and application classes as JavaBeans, including easy in-between referencing via an application context, e.g. from web controllers to business objects and validators. .Adaptability, non-intrusiveness: Use whatever Controller subclass you need (plain, command, form, wizard, multi action, or a custom one) for a given scenario instead of deriving from Action/ActionForm for everything. .Reusable business code, no need for duplication: You can use existing business objects as command or form objects instead of mirroring them in special ActionForm subclasses. .Customizable binding and validation: type mismatches as application-level validation errors that keep the offending value, localized date and number binding, etc instead of String-only form objects with manual parsing and conversion to business objects. Customizable handler mapping, customizable view resolution: flexible model transfer via name/value Map, handler mapping and view resolution strategies from simple to sophisticated instead of one single way. Customizable locale and theme resolution, support for JSPs with and without Spring tag library, support for JSTL, support for Velocity without the need for extra bridges, etc. Simple but powerful tag library that avoids HTML generation at any cost, allowing for maximum flexibility in terms of markup code.