网上商城管理系统

网上商城管理系统

摘  要

随着计算机和网络的日趋普及，越来越多的商家在网上升起商店，向消费者展示出一片新鲜的购物大地。在美、日等信息化程度较高的国家和地区，网络商店发展速度迅猛，美国的世界级超一流的零售商，如沃尔玛凯玛特、家庭仓储、科罗格、J.C培尼等纷纷跻身于网络经商的行列。调查表明：美国的家庭已越来越习惯于在家中从网上购物。

清风网上商城管理系统是利用J2EE技术开发的系统，而且还使用了最新的框架struts2。虽然功能上比较简易，页面上比较朴实，但是基本实现了一个网上商城的功能，可以对网上商城所涉及的对象进行有效的管理。

关键词  网络；商城；struts2；功能

On-line shop manage system

Abstract

As more and more people surf the Internet, more and more on-line shops are built by the businesses. The on-line shops make the customers do some shopping on the internet widely. In some countries where the Internet are used widely, the on-line shops make great roles in the life. The retail traders such as Wal-Mart ,Kroger and Penirolol of America are super in the world. They all join to have their own on-line shops. According to survey, the American families are doing some shopping on the Internet more and more.

The freezing on-line shop management system was developed by the J2EE technology. It was constructed by some developed technology and the latest technology which is called struts2. Though the face and index of the system are simple and tidy, it can afford the basic functions for the objects involved in the system.

Keyword  Internet；department；struts2；function

目  录

第1章 绪论

1.1 引言 1

1.2 系统开发背景与意义 2

1.3 系统实现的目标 3

1.4 技术现状 3

第2章 网上购物系统需求分析 5

2.1 逻辑与经济可行性分析 5

2.2 技术可行性分析 5

2.2.1 struts2的简要介绍 5

2.2.2 数据库-MYSQL 6

2.2.3 JDBC的说明 6

2.3 系统功能需求分析 7

第3章 系统设计与功能模块 9

3.1 开发平台选择 9

3.2 功能模块规划 9

3.3 系统设计 11

3.3.1 设计目标 11

3.3.2 系统开发环境 11

3.4 数据库表设计 12

第4章 网上商城管理系统实现过程 1

4.1 系统模块实现方法概要 1

4.1.1 创建与数据库的连接 1

4.2 前台系统设计 16

4.2.1 网站前台展示 16

4.2.2 商城index 16

4.2.3 首页功能栏 16

4.2.4 商品预览功能 17

4.2.5 购买功能 18

4.2.6 用户注册功能 20

4.2.7 查看已购买商品功能 21

4.3 网站后台设计 21

4.3.1 后台总体页面展现 21

4.3.2 后台LOGO 22

4.3.3 后台首页左侧功能栏 22

4.3.4 添加商品功能 23

4.3.5 查看商品信息功能 24

4.3.6 修改商品信息功能 25

4.3.7 商品删除功能 27

4.3.8 确认新订单和处理旧订单 28

第5章 系统测试与评价分析 31

5.1 测试环境简介 31

5.2 系统的不足与修改方法 31

5.3 系统的评价与分析 31

5.3.1 实用性 31

5.3.2 可维护性 32

5.3.2 可扩展性 32

5.4 使用说明 32

5.4.1 系统环境要求 32

5.4.2 系统安装 32

5.4.2 系统运行 33

结  论 34

致  谢 35

参 考 文 献 36

附录A  译文 37

JAVA编程思想 37

附录B  外文原文 44

第1章 绪论

1.1 引言

近年来，随着Internet的迅速崛起，互联网已日益成为收集提供信息的最佳渠道并逐步进入传统的流通领域。于是电子商务开始流行起来，越来越多的商家在网上建起在线商店，向消费者展示出一种新颖的购物理念。

网上购物系统作为B2B，B2C（Business to Customer,即企业对消费者），C2C（Customer to Customer，即消费者对消费者)电子商务的前端商务平台，在其商务活动全过程中起着举足轻重的作用。本文主要考虑的是如何建设B2C的网上购物系统。在美、日等信息化程度较高的国家和地区，网络商店发展速度迅猛，美国的世界级超一流的零售商，如沃尔玛凯玛特、家庭仓储、科罗格、J.C培尼等纷纷跻身于网络经商的行列。调查表明：美国的家庭已越来越习惯于在家中从网上购物。

在我国，网上购物从无到有也不过短短几年时间。我国第一家网上购物发生在1996年，燕莎友谊商场首次通过网上商城售出一个景泰蓝，虽然货款的支付不是在网上进行的，但这毕竟为我国零售业奏出了网上购物的先声。如今，在北京、上海、深圳等大城市，已有200多家商场，专卖店开设了网上商店，还有一些正处在观望阶段。。

网上购物是一种具有交互功能的商业信息系统。它向用户提供静态和动态两类信息资源。所谓静态信息是指那些比经常变动或更新的资源，如公司简介、管理规范和公司制度等等；动态信息是指随时变化的信息，如商品报价，会议安排和培训信息等。网上购物系统具有强大的交互功能，可使商家和用户方便的传递信息，完成电子贸易或EDI交易。这种全新的交易方式实现了公司间文档与资金的无纸化交换。

1.2 系统开发背景与意义

随着计算机和网络的日趋普及，越来越多的商家在网上升起商店，向消费者展示出一片新鲜的购物大地。所以，为了满足消费者购物的需求和购物方式的便捷化，网上商城的开发与应用，已经是刻不容缓的业务。从系统的背景来看，可以看出开发一个网上购物系统有以下几点重大的意义：

1. 投资少，回收快。一项针对中国中小企业的情况调查显示，个人在网下启动销售公司的平均费用至少5万元，而网上开店建店成本非常小。一般说，筹办一家网上的商店投入很小，不用去办营业执照，不用去租门面，不用囤积货品，所需资金不过1500元左右；网上商店比同等规模的地面商店“租金”要低得多，同时租金不会因为营业面积的增加而增加，投资者也不用为延长营业时间而增加额外的费用。  
2. 基本不需要占压资金。传统商店的进货资金少则几千元，多则数万元，而网上商店则不需要压资金。  
3. 24小时营业时间。网上商店延长了商店的营业时间，一天24小时、一年365天不停地运作，无须专人值班看店，都可照常营业。传统店铺的营业时间一般为8-12小时，遇上坏天气或者老板、店员有急事也不得不暂时休息。  
4. 不受店面空间的限制。哪怕只是街边小店，在网上却可以拥有百货大楼那么大的店面，只要投资者愿意，可以摆上成千上万种商品。目前国内最大的专业拍卖网站同时在线的商品要超过10万件，已超过一些大超市。  
5. 不受地理位置影响。不管客户离店有多远，也不管顾客是国内还是国外，在网上，客户一样可以很方便地找到并购买商品。这令消费群体突破了地域的限制，变得无限广阔了。

1.3 系统实现的目标

现在流行的网上购物系统不仅要有漂亮的网页，更要有严谨的规划，注重每一个细小的环节，这样才能使得在电子交易时避免不必要错误发生。我们将使用HTML、JSP等技术来编辑网页，并运用JDBC技术把数据库和动态网页相关联。传统的管理信息系统信息获取方法是由专业文字录入人员将信息输入到管理系统的数据库中，这种方法在数据量不大时有很多的应用场合。当数据量比较大，并且有较强的专业性时，录入的费用和出错的可能性都相应上升。本设计在实际应用中的解决方案是建立网站， 以及自己的数据库，使得所需商品信息可以及时的保存、更新，可以更好的及时了解商品买卖的情况。

1.4 技术现状

目前在国内购物系统的开发，PHP与ASP技术应用最为广泛。而JSP由于是一种较新的技术，国内采用的较少。但在国外，JSP已经是比较流行的一种技术，尤其是电子商务类的网站，多采用JSP。

首先，PHP缺乏规模支持。其次，缺乏多层结构支持，对于大负荷站点，解决方法只有一个：分布计算。数据库、应用逻辑层、表示逻辑层彼此分开，而且同层也可以根据流量分开，组成二维阵列，而PHP则缺乏这种支持。还有上面提到过的一点，PHP提供的数据库接口支持不统一，这就使得它不适合运用在电子商务中。

ASP是Microsoft开发的动态网页语言，也继承了微软产品的一贯传统，即只能运行于微软的服务器产品，IIS(Internet Information Server) (windows NT)和PWS(Personal Web Server)(windows 98)上。Unix下也有ChiliSoft的插件来支持ASP，但是ASP本身的功能有限，必须通过ASP＋COM的组合来扩充，Unix下的COM实现起来非常困难。

JSP则没有以上缺陷，JSP(JavaServer Pages)是由Sun Microsystems公司倡导、许多公司参与一起建立的一种动态网页技术标准。JSP技术有点类似ASP技术，它是在传统的网页HTML文件 (*.htm，*.html)中插入Java程序段(Scriptlet)和JSP标记(tag)，从而形成JSP文件(*.jsp)。

用JSP开发的Web应用是跨平台的，即能在Linux下运行，也能在其他操作系统上运行。

JSP技术使用Java编程语言编写类XML的tags和scriptlets，来封装产生动态网页的处理逻辑。网页还能通过tags和 scriptlets访问存在于服务端的资源的应用逻辑。JSP将网页逻辑与网页设计和显示分离，支持可重用的基于组件的设计，使基于Web的应用程序的开发变得迅速和容易。

Web服务器在遇到访问JSP网页的请求时，首先执行其中的程序段，然后将执行结果连同JSP文件中的HTML代码一起返回给客户。插入的Java程序段可以操作数据库、重新定向网页等，以实现建立动态网页所需要的功能。

总的来说，ASP、PHP、JSP三者都有相当数量的支持者，而这三者也各有所长，在开发过程中，我们应该根据实际的需要来使用最合适的技术，本系统则采用较新的JSP技术，一方面JSP的安全性和跨平台性比较好，另一方面，我也希望能从开发该系统的过程中，深入学习一下这门编程语言。

第2章 网上购物系统需求分析

2.1 逻辑与经济可行性分析

网上购物系统自身具备的即时互动方式可以吸引很多购物者的注意力，这些购物网站能够随时让顾客参与购买、更方便、更详细、更安全。而且在这样的网站中，产品的管理是有秩序的，并将其进行科学化的分类，便于购买者查询。这种网站的网页设计往往制作得更有指导性，并且更加美观，这些都将会吸引大批的购买者。

基于网络的商品销售管理系统的投入，能够提高工作效率，减少工作人员，从而减少劳力资本的投入，在货物管理中节省人力，减轻了劳动强度，达到降低成本及其他费用的目的。通过改进薄弱环节，提高工作效率，提高数据处理的及时性和准确性。所以从经济角度来说，本系统开发完全必要。

2.2技术可行性分析

本系统是基于JSP+struts2+MySQL数据库技术实现的，由于前面已经对JSP技术进行了详细阐述，在这里就不做赘述。现对struts2框架、MySQL数据库和JDBC作简要的介绍。

2.2.1 struts2的简要介绍

Apache Struts在2000年5月由 Craig McClanahan 发起，并于2001年7月发布了1.0版本。从技术的角度上讲，它是在开发Web程序上的一次跨越性的进步，但更重要的是，它是在最恰当的时候出现在了人们的眼前。Struts 一出现便大受欢迎，更成为了以后几年内web开发的实际标准。Struts2是Struts的下一代产品。最初提案Struts Ti所设想的发展方向，在Struts的现有代码的基础上是很难完成的。在发起提案的时候，Patrick  Lightbody 把多个不同的Web框架的领导者邀请到了一起，希望大家能够协力完成一个通用的框架。但因种种原因，只有WebWork和Struts走到了一起。Struts2吸取了Struts1.x和WebWork的各种优点，更改了一些不足的地方，比如移走了原来WebWork中的IOC实现，引入Spring的IOC实现等。Struts2的目标就是——使Web开发更加容易。

2.2.2 数据库—MYSQL

   MySQL是目前最受欢迎的关系型数据库系统之一，在2008年以前由MySQL AB公司开发、发布和支持。2008年1月SUN公司将MySQL AB收购，目前MySQL项目由SUN公司继续开发和维护，SUN公司又被甲骨文收购。MySQL AB中的“AB”是瑞典语“Aktiebolag”或“股份公司”的首字母缩写，可翻译为“MySQL有限公司”。MySQL是一个开源的数据库服务器软件，可以自由从Internet下载和使用，官方站点为：www.mysql.com。MySQL是一个真正的多线程、多用户的SQL数据库服务器，基于客户/服务器结构实现，具有功能强大、使用简单、管理方便、查询速度快、安全可靠等优点。

2.2.3 JDBC的说明

JDBC（Java Data Base Connectivity,javashu数据库连接）是一种用于执行SQL语句的Java API，可以为多种关系数据库提供统一访问，它由一组用Java语言编写的类和接口组成。JDBC为工具/数据库开发人员提供了一个标准的API，据此可以构建更高级的工具和接口，使数据库开发人员能够用纯 Java API 编写数据库应用程序。

　　有了JDBC，向各种关系数据发送SQL语句就是一件很容易的事。换言之，有了JDBC API，就不必为访问Sybase数据库专门写一个程序，为访问Oracle数据库又专门写一个程序，或为访问Informix数据库又编写另一个程序等等，程序员只需用JDBC API写一个程序就够了，它可向相应数据库发送SQL调用。同时，将Java语言和JDBC结合起来使程序员不必为不同的平台编写不同的应用程序，只须写一遍程序就可以让它在任何平台上运行，这也是Java语言“编写一次，处处运行”的优势。

Java数据库连接体系结构是用于Java应用程序连接数据库的标准方法。JDBC对Java程序员而言是API，对实现与数据库连接的服务提供商而言是接口模型。作为API，JDBC为程序开发提供标准的接口，并为数据库厂商及第三方中间件厂商实现与数据库的连接提供了标准方法。JDBC使用已有的SQL标准并支持与其它数据库连接标准，如ODBC之间的桥接。JDBC实现了所有这些面向标准的目标并且具有简单、严格类型定义且高性能实现的接口。

JDBC 扩展了 Java 的功能。例如，用 Java 和 JDBC API 可以发布含有 applet 的网页，而该 applet 使用的信息可能来自远程数据库。企业也可以用 JDBC 通过 Intranet 将所有职员连到一个或多个内部数据库中（即使这些职员所用的计算机有 Windows、 Macintosh 和UNIX 等各种不同的操作系统）。随着越来越多的程序员开始使用Java 编程语言，对从 Java 中便捷地访问数据库的要求也在日益增加。

2.3 系统功能需求分析

通过对淘宝网，拍拍等网上购物的认识和分析，我对网上购物有了基本的了解，我觉得该系统至少应该具有以下的一些基本功能：

1. 注册管理：用户可以自行注册账号。账号注册完成就成为系统用户，可以凭账号登陆系统。
2. 商品浏览：显示商品详情，提供购买链接。浏览商品时不要求用户登录，但下订单前用户必须登录。
3. 订单管理：只有登录的用户可下订单；用户可以查看自己的订单。管理员可以修改订单的状态，确认订单，删除过期订单。
4. 商品管理：管理员可以增添商品种类；修改商品基本信息；删除商品过时商品。
5. 注册用户管理：用户可以注册，管理员可以查询用户，并管理用户的详细信息，可做修改。

以下是该系统的概要的数据流图，主要从前台开始，并且验证管理员身份，通过之后就可以进入后台进行后台的管理，请看以下两图：

图 2.1 网上商城管理系统前台数据流图

图 2.2 网上商城管理系统后台数据流图

第3章 系统设计与功能模块

3.1 开发平台选择

  Microsoft软件是日常生活中使用最为广泛的软件，基于这一特点，我们选用的操作系统是windows7。以上已经做过比较，我们将采用Java Server Page(简称JSP)做为开发技术。数据库方面，我们使用MySQL数据库，它适应于Windows操作系统并能很好的与其应用程序结合，而且MySQL数据库也易操作，从而大大降低了编程难度。具体如下：

1. 采用了Internet架构，Bowser/Server模式。
2. Web服务器采用Tomcat5.0服务器，数据库管理系统为MySQL。
3. 开发工具使用Dreamweaver搭建系统页面框架，再用Eclipse在其中插入JSP语句，JavaBean使用Eclipse编写。

3.2 功能模块规划

网上购物系统是一个典型的JSP数据库开发应用程序，由前台商品展示及销售、后台管理2部分组成。

1. 前台商品展示及销售：该部分主要包括商品浏览、查看已购商品、用户登录、用户注册、进入后台等，前台功能结构展现如图3.1所示。

图3.1 系统前台功能结构图

1. 后台管理：该部分主要对商城内的一些基础数据进行有效管理，包括商品管理、用户管理、订单管理等。商品管理中又分为添加商品，查看商品，修改商品休息，删除商品；会员管理中分为查看会员信息，修改会员信息，删除会员；订单管理中又分为处理新订单，删除旧订单。商城后台管理系统功能结构展现如图3.2所示。

图3.2 网上商城管理系统后台功能结构图

3.3 系统设计

3.3.1 设计目标

本系统在设计时应该满足以下几个目标：

1. 采用人机对话的操作方式，界面设计简洁友好、信息查询灵活、方便、快捷、准确、数据存储安全可靠。
2. 全面展示商城内商品，并且在登陆后才可以购买，保证了安全。
3. 会员可以随时修改自己的会员资料。
4. 实现网上购物。
5. 用户随时都可以查看自己的订单。
6. 对用户输入的数据，系统进行严格的数据检验，尽可能排除人为的错误。
7. 系统最大限度地实现了易维护性和易操作性。
8. 系统运行稳定、安全可靠。

3.3.2 系统开发环境

硬件平台：

CPU：2.00GHz；

内存：2G。

软件平台：

操作系统：Windows 7 旗舰版；

数据库：MYSQL；

开发工具包：JDK 5.0；

JSP服务器：Tomcat 5.0以上；

浏览器：IE 7；

分辨率：最佳效果1024×768。

3.4 数据库表设计

本系统数据库采用MYSQL数据库，系统数据库名称为shopping，共包含3张表。

（1）product表（商品信息表）

商品信息表主要用来保存商品种类以及商品的详细信息。其中包括的字段有商品编号、商品名、商品描述、普通价、优惠价、录入时间。表product的具体结构如表3.1所示。

表3.1 商品信息表

商品信息表（product）
字段	显示名称	数据类型	长度	是否可为空	说明
Id	商品编号	Int	11	否	主键
Name	商品名	Varchar	255
Descr	商品描述	Varchar	255
Normalprice	普通价	Double
Memberprice	优惠价	Double
Pdate	录入时间	Varchar	11

（2）salesorder（会员订单信息表）

会员订单信息表主要用来保存会员在前台下单订购商品之后产生的订单信息。其中包括的字段有订单号、会员号、商品号、商品名、地址、价格、下单时间、状态等。表salesorder的具体结构如表3.2所示。

表3.2 订单信息表

会员订单信息表（salesorder）
字段	显示名称	数据类型	长度	是否可为空	说明
Id	订单号	Int	11	否	主键

续表3.2

Userid	会员号	Int	11	否
Productid	商品号	Int	11	否
Productname	商品名	Varchar	255
Addr	地址	Varchar	255
Price	价格	Double
Odate	下单时间	Varchar	255
Status	状态	Int	11

（3）user表（会员信息表）

会员信息表用来保存本网上商城会员的详细信息。其中包括的字段有会员号、账号、姓名、密码、联系方式、联系地址、注册时间。表user的具体结构如表3.3所示。

表3.3 会员信息表

会员信息表（user）
字段	显示名称	数据类型	长度	是否可为空	说明
Id	会员号	Int	11	否	主键
Account	账号	Varchar	255	否
Username	姓名	Varchar	255
Password	密码	Varchar	255
Phone	联系方式	Varchar	255
Addr	联系地址	Varchar	255
Rdate	注册时间	Varchar	255

第4章 网上商城管理系统实现过程

本系统所采用的是Internet架构， B/S模式，采用JSP+MYSQL数据库技术实现，同时利用了JDBC、JavaBean、struts等技术。本节将首先总体说明一下，然后再介绍系统各部分的实现方法。

4.1 系统各部分的实现方法概要

从系统功能模块划分中可以看出，系统功能模块分为前台和后台。前台包括有用户注册、用户登录、商品展示、购买商品等功能。后台模块总要有添加商品、删除商品、查看商品、增加会员、查看会员、修改会员信息、删除会员、查看新订单、删除旧订单等。各模块虽然是独立的，但又统一于同一数据库中，便于管理员管理维护数据库，同时也便于用户的操作。

4.1.1 创建与数据库的连接

在JSP中可以使用Java的JDBC技术，实现对数据库中表记录的查询、修改和删除等操作。JDBC技术在JSP中占有很重要的位置。JDBC（Java DataBase Connectivity）是Java数据库连接API。简单地说，JDBC能完成三件事：

1. 与一个数据库建立连接
2. 向数据库发送SQL语句
3. 处理数据库返回的结果

本系统中，所有的数据库连接都使用了一个共同的数据库连接类Connect。

在service中，如果需要涉及到数据库操作，创建此类的一个对象就可以加载数据库，运用所创建的对象，调用JDBC提供的方法向数据库发送SQL语句，接收从数据库返回的数据，并进行处理。此处有必要将数据库连接类的主要程序列出，以供参考：

public class Connect {

//连接名

private Connection conn;

// 连接数据库驱动名

private String driver = "com.mysql.jdbc.Driver";

// 数据库的url

private String url = "jdbc:mysql://localhost:3306/shopping";

// 数据库用户名

private String user = "root";

// MySQL配置时的密码

private String password = "root";

public Connection getConn() {

try {

// 加载驱动程序

Class.forName(driver);

} catch (ClassNotFoundException e) {

e.printStackTrace();

}

// 连接数据库

try {

 conn = DriverManager.getConnection(url,

user, password);

} catch (SQLException ex) {

ex.printStackTrace();

}

System.out.println("success");

return conn;

}

4.2 前台系统设计

4.2.1 网站前台展示

在清风网上商城的首页中，用户可以浏览商城的商品，登录后可以购买所心仪的商品，同时，如果曾经已经买过商品，在这里也能通过查看已买商品来了解过去的信息。如果新用户还没有注册账户，在首页中，有用户注册功能可以完成新用户的注册和生成。首页最后一项功能是进入网上商城的后台管理系统，此处需要经过管理员身份和密码确认。清风网上商城前台首页的运行结果各个部分如下面一组图所示。

4.2.2 商城index

图4.1 网上商城前台首页

此部分主要功能是展示网站的名称，给商城用户留下好的印象。对应的处理代码文件是top.html，此处不作引用。

4.2.3 首页功能栏

图4.2 网上商城前台首页左边功能显示

此部分主要功能是通过点击所需链接而呈现出各个链接所可以实现的功能，此处的功能实现，下文会对各项功能做详细说明与展现，实现此页的文件是front_left.jsp，主要是处理页面，无关键逻辑关系。

4.2.4 商品预览功能

商品预览功能。点击图4.2中商品预览后，就可以查看商城所展现商品信息，效果如下图所示：

图4.3 商品预览功能展示

此部分的效果是，当客户点击预览商品之后，在首页主体部分展现出来的商品的信息，由于本系统主要注重后台的一些管理功能，前台的简单功能只是为了方便后台的处理，所以比较简洁，没有做太过详细、复杂的功能，实现这部分功能的文件是showProduct.jsp，这里使用了struts2提供的标签，这里需要做主要摘录，如下：

<s:iterator value="productList" id="productList">

<input name="productId" type="hidden" value="${productId}">

<tr>

<td>${productId}</td>

<td>${productName}</td>

<td>${productDetail}</td>

<td>${productPrice}</td>

<td>${discount}</td>

<td>

<a href="<%=basePath%>order/toAddOrder?Id=${productId}" style="margin-right: 5px;">购买</a>

</td>

</tr>

</s:iterator>

主要的后台处理文件是showProduct.java，这部分将商城所要展现的商品从数据库中调到后台，其中包括对数据库连接类的引用，这里不作详细摘录。

4.2.5 购买功能

点击图4.3中的购买功能，如果客户已经登录，那就可以展现此商品的信息，同时客户可以做相应的登记，效果如下图：

图4.4 商品购买确认

此功能主要是为了在购买商品前，让用户可以确认商品的信息，其中商品名称和价格这两项是不可修改的，用户可以根据需要填入相应的地址，展现这一功能的页面文件是addorder.jsp，这里对不可修改的两项做具体阐述，使用了input标签的readonly属性，摘要部分代码，如下：

<tr>

<td>价  格：</td><td><input name="order.productPrice" type="text" value="${product.discount}" readonly="readonly"></td>

</tr>

这一段页面显示虽然简洁，但是从页面程序可以看出，其实这边的处理还是挺复杂，其中要得到客户的id，这需要通过web内置对象将从前台页面得到的数据传到后台，这在struts2中不能直接使用web内置对象，必须让对应的action继承sessionAware接口，然后初始化session对象，之后才可以使用session，这一段的后台程序牵连较多，主要的文件是addOrder.java和userLoginAction.java，主要代码如下：

private Map<String,Object> session;

public void setSession(Map<String, Object> session) {

// TODO Auto-generated method stub

this.session = session;

}

第二部分：

Connect connect = new Connect();

conn = connect.getConn();

pst = conn.prepareStatement(addOrderSql);

pst.setInt(1, order.getUserId());

pst.setInt(2, order.getProductId());

pst.setString(3, order.getProductName());

pst.setString(4, order.getUserAddress());

pst.setDouble(5, order.getProductPrice());

pst.setString(6, sdf.format(date));

pst.setInt(7, 0);

pst.executeUpdate();

closeConn();

4.2.6 用户注册功能

用户注册功能。点击图4.2所示的用户注册，即可实现用户注册功能，效果如下图所示：

图4.5 清风网上商城前台用户注册功能效果图

当用户尚未有本商城的账号时，就可以使用此功能注册新账号，注册功能实际就是添加新用户，此功能没有太多牵连，主要呈现的文件是addUser.jsp，这里主要是从页面上获取数据，有兴趣可从程序中看具体传参情况。

主要的后台处理文件是addUsers.java，主要功能是将从前台获得的用户信息数据用一个实体bean来接收，然后通过数据库连接类将这些数据插入到数据库当中，如有兴趣可从程序中看具体操作。

4.2.7 查看已购商品功能

查看已购商品功能。相当于简单的购物车，因为本系统前台不是主要实现任务，所以没有具体的购物车，做一个简单的查看商品功能，效果如下图所示：

图4.6 网上商城前台首页查看已购商品

此功能可以展现当前登录用户的所以订单（在一定日期范围之内），但是只是做了查看，没有其他太多的功能，在此不做进一步添加，本功能的展现文件是selectOrderByuserid.jsp，此处主要也是需要注意登录后用户id的获取，前面已经做过代码展现，这里就不再赘述，如有兴趣可到指定文件查看。

主要的后台处理文件是selectOrderByuserid.ava，此文件必须根据已登录用户的相关信息来选择其已经产生的订单，而用户的id传入是比较麻烦的，前面已经对session对象的建立以及如何通过session对象获取用户id做了说明，这里不再赘述。

4.3 网站后台设计

4.3.1 后台总体页面展现

首先看一下后台页面的布局，后台页面的布局跟前台类似。在后台，我们大致有以下的功能操作。商品添加，商品查看（商品信息修改，商品删除）；用户查看（用户信息修改，用户删除）；确认新订单，处理旧订单。下面看一下后台页面总体图，如下：

图4.7 网上商城后台整体布局

接下来，会对此界面的各个部分做分解。

4.3.2 后台LOGO

图4.8 网上商城后台LOGO

此部分主要功能是展示网站后台管理的名称，给使用者留下好的印象。对，应的处理代码文件是back_top.html，这里无需再作详述。

4.3.3 后台首页左侧功能栏

后台首页左侧功能栏。展示了后台管理的所具有的功能，如下图所示：

图4.9 网上商城后台左侧功能栏

这一部分的主要作用是展现了后台管理系统的功能。对于每一项功能，都可以通过点击链接产生相应的功能效果，会展现在浏览器右侧那部分里面，对于每一项功能的展现，下文会做分解。实现上面这项功能程序的文件主要是index01.jsp，这里主要是一些超链接技术以及展现页面区域的指定技术，无需再作详述。

4.3.4 添加商品功能

添加商品功能。点击图4.9中商品管理下的商品添加链接，就可展现此功能，效果如下图：

图4.10 网上商城后台商品添加功能

商品添加功能，主要是让后台管理员可以根据情况添加商品。添加商品时，此处商品号已经经过处理。添加商品的展现文件主要是addProduct.jsp，主要功能是从页面获取管理员输入的商品信息，然后传给一个product对象。这里不对代码作详细分析。

后台的处理程序文件为addProduct.java，此处后台处理程序，将从action处获得的商品信息的对象，再将对象中的数据信息传入对应的存入数据库字段中，当商品信息存入成功，关闭数据库连接。这里不再引用程序做详解。

4.3.5 查看商品信息功能

查看商品信息功能。点击图4.9中查看商品信息连接，就可以在右边区域展现商品的信息，具体呈现如下图：

图4.11 后台管理商品信息查看功能

本页可以列出商品信息，同时有操作栏，如果需要修改商品信息或者删除某商品，可以从操作栏选择。展现本页的主要文件是selectProduct.jsp。在这里需要说明的一点是隐藏的input标签，因为有些字段不要呈现给用户，但是涉及到程序逻辑流程，所以需要隐藏。摘录的主要程序代码如下：

<input name="productId" type="hidden" value="${productId}">

查看商品的后台处理程序主要是selectProduct.java，将数据库中符合条件的商品信息调到后台，存放在javaBean中，然后将此对象结果集通过action返回，传到页面，通过页面呈现出来。这里需要说明下连接数据库的方法和选取商品信息的方法，并且做了如下摘录：

private String selectAllsql = "SELECT * FROM product ORDER BY id asc";

public List<Product> selectAll() {

conn = new Connect().getConn();

try {

pst = conn.prepareStatement(selectAllsql);

rs = pst.executeQuery();

while(rs.next()){

Product product = new Product();

product.setProductId(rs.getInt(1));

product.setProductName(rs.getString(2));

product.setProductDetail(rs.getString(3));

product.setProductPrice(rs.getDouble(4));

product.setDiscount(rs.getDouble(5));

productSet.add(product);

}

在开发过程中，当这里的sql语句写在方法外面时，执行就会发生错误，后来通过查找，知道这里是动态执行，写在方法里面更容易被识别。

4.3.6 修改商品信息功能

修改商品信息。点击如图4.11中的修改链接，就可以实现修改功能。此时进入一个修改的确认页面，如果修改后，点击保存则修改成功。具体展现如下图所示：

图4.12 清风网上商城后台商品信息修改功能

此功能可以对已存在的某件商品的信息进行修改，修改完成后再进行保存。主要的处理文件是modifyProduct.jsp，这里主要是呈现后台传来的商品信息数据，没有太多的逻辑处理，如有兴趣，可以查看指定的文件。

此处的后台处理比较繁琐，需要首先将对应的商品信息从数据库中选出来，这里还是选择的环节，需要注意sql语句的位置。这里有必要列出来说明，实现这一操作的方法代码主要是下面的一段：

public Product selectbyId(Integer id) {

String selectsql = "select * from product where id = ? ";

Connect connect = new Connect();

conn = connect.getConn();

try {

pst = conn.prepareStatement(selectsql);

pst.setInt(1, id);

rs = pst.executeQuery();

然后还要将从页面改动过后接受过来的商品新信息重新存入数据库，也就是更新数据库操作，实现这一功能的代码方法大致如下：

public void modify(int productId, Product product) {

private String modifysql = "UPDATE product SET NAME=?,descr=?,normalprice=?,memberprice=?,pdate=? WHERE id=?";

conn = new Connect().getConn();

try {

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

Date date = new Date();

PreparedStatement pst = conn.prepareStatement(modifysql);

4.3.7 商品删除功能

点击如图4.11所示中的删除功能，将会展现要删除商品的信息，等管理确认删除，才真正将此条商品信息删除。具体效果如下图：

图4.13 商城后台管理商品删除功能

当商城中没有某商品，或者某商品不再符合销售规则时，就会将此商品从商品列表中删除，进入删除页面之后，就等管理员确认删除信息，此时点解删除按钮，则将会删除此商品的信息。处理商品删除的页面主要是deleteProduct.jsp。如有兴趣可查看指定的代码文件。

删除操作的后台处理程序文件主要是deleteProduct.java。这里也有两个过程，首先将要删除的商品信息选出来，此时通过商品的编号来标记该商品信息集合。通过商品编号找到商品后，再执行删除操作，则可以删除此商品。这里过程比较简单，不作代码引用详述。

选出来该商品的信息，待管理员确认要删除后，就会调用下面的方法来完成对该商品的删除，如下：

public void delete(Integer id) {

conn = new Connect().getConn();

String deletesql = "delete from product where id = ? ";

pst = conn.prepareStatement(deletesql);

pst.setInt(1, id);

pst.executeUpdate();

}

由于用户管理的操作跟商品管理有很多雷同之处，在此就不再详述用户管理内容，以免累赘。

4.3.8 确认新订单和处理旧订单

确认新订单。当用户在前台下单之后，后台就可以接受到新的订单。此时，后台管理员就可以根据情况处理这些新订单，效果如下图：

图6-14 后台管理确认新订单功能

前台的订单下达之后，管理员会在这里看到，然后再根据商品的情况来做下一步的处理，如果状态值是0，那就未处理，则会在此表中展现，这里的处理页面主要是selectOrder0.jsp，只是作一个展现，没有太复杂的逻辑关系，这里不引用代码作详述。

图6-15 后台管理处理旧订单功能

处理旧订单。就是当已经经过管理员处理完毕的订单，状态值会变成1，然后这些订单有保存的价值，但是已经区别于新生成的订单，所以这里就会将它们另外展现，如果保存时间已经超过，也就是没有了保存的价值，那么久可以做删除操作，删除后补课恢复。这里主要处理页面的代码程序文件是selectOrder1.jsp，除了处理的操作，此文件跟上一个文件的内容相似。这里不需要详述。

此两个功能的后台处理代码是同一个，根据传入的状态值来决定是哪个功能。如果传入的状态值为0，那么展现所用的页面就是上文所提的selectOrder0.jsp，如果传入的状态值是1，那么展现所用的页面是上文所提的selectOrder1.jsp。而这里的处理文件是selectOrders.java，主要方法的程序代码如下：

public List<Order> selectOrder0(Integer status){

Connect connect = new Connect();

conn = connect.getConn();

String selectOrderSql = "select * from salesorder where status = ? order by id asc ";

try {

pst = conn.prepareStatement(selectOrderSql);

pst.setInt(1, status);

rs = pst.executeQuery();

while(rs.next()){

Order order = new Order();

}

以上展现了本系统的所有管理功能，并且对使用的过程和方法做了详细的说明讲解，对个别功能的实现还做了深入的剖析，功能介绍就到这里，如果有什么问题，可以再做修正。

第5章 系统测试与评价分析

5.1 测试环境简介

硬件平台：Inter(R) Pentium(TM)2 Duo，内存2GB，硬盘160GB

软件平台：Windows 7操作系统，MYSQL数据库，IE7.0浏览器，Tomcat 6.0， JSP开发的网上商城管理系统。

Everest ultimate是一个测试软硬件系统信息的工具，它可以详细的显示出PC每一个方面的信息。支持上千种(3400+)主板，支持上百种(360+)显卡，支持对并口/串口/USB这些PNP设备的检测，支持对各式各样的处理器的侦测。目前Everest Home已经能支持包括中文在内的30种语言，让你轻松使用。而且经过几次大的更新，现在的Everest已经具备了一定的硬件测试能力，让您对自己电脑的性能有个只管的认识。

5.2 系统的不足及修改方法

第一个问题就是本系统主要是后台的功能。前台的功能比较简洁，只是做一些辅助后台的工作，重点是为了用户注册和订单的生成，所以前台有很多细节考虑不是很周密，还望见谅。

第二问题就是本人主要实现了系统的业务功能，由于个人水平有限，在美工和细节校验方面做得不是很到位，因此系统可能比较简洁，朴素，在今后的学习中一定注重各方面能力的培养。

5.3 系统的评价分析

5.3.1 实用性

本系统是典型的商城管理系统，对于商品销售管理信息的日常管理有很大的帮助作用，能在很短的时间内完成一项日常管理，减少了人力、财力、物力的消耗。并且系统功能可以满足管理者对商品信息管理的需要，界面友好简单，很容易被用户掌握。

5.3.2 可维护性

网上商城管理系统的优越性体现在：首先，是基于B/S的开发模式，开发者只需对服务器上的处理程序进行修订，而客户端不用做任何改变，就可以照常使用系统；其次，由于JSP技术是一种开放的、跨平台的结构，因此Web服务器、平台及其他组件能很容易升级或切换，且不会影响JSP基本的应用程序。

5.3.3 可扩展性

网上商城管理系统是一个不断扩展的系统，本系统采用B/S模式开发，可以不改变系统架构的基础上，直接添加模块，增加系统功能。如果用户想给本系统添加更多的模块可以将其他模块作为模板，只是稍微改一下数据库的参数和将新模块包含到所需的页面中，这样就可以在一定程度上扩展系统的功能，比如说支付功能，数量添加功能等等。这些功能我在开发过程中都曾考虑过，但由于时间和经验关系，没能够及时的呈现给用户。

5.4 使用说明

5.4.1 系统环境要求

硬件环境：硬盘：10G+， 内存：512M+。

软件环境：windowsXp/2000+；jdk1.5+；Tomcat5.X+；MySQL；IE6.0+。

5.4.2 系统安装

1. 将整个项目发布到Tomcat中。

2. 将db_shop数据库导入到MySQL中。

5.4.3 系统运行

1. 启动Tomcat和Mysql服务。

2. 访问首页：http://localhost:8080/eShop0505/

结 论

顺利如期的完成本次毕业设计给了我很大的信心，让我了解专业知识的同时也对本专业的发展前景充满信心，网上购物系统采用的是JSP技术编程。 它有着许多的优越性，但也存在一定的不足，这些不足在一定程度上限制了我们的创造力。只有发现问题面对问题才有可能解决问题，不足和遗憾不会给我打击只会更好的鞭策我前行。

经过这次毕业设计和对相关资料的收集，让我清楚的感到随着网络科技的不断发展和网络的广泛应用，使我们的生活离不开它了。网络它以自己的独特的优点征服了我们。在教育越来越受重视的21世纪，随着商务类型的不断增加和商务管理要求的不断提高，管理方面的工作量将会越来越大，并且其工作将是一件十分烦琐和非常容易出错的事情。在这样的情况下有一个实用网上购物系统是有其必然性的，如果能做出一个完善的网上购物管理系统就使管理方面的工作量减少很多。在这次的毕业设计中，我学会了很多，也感到自身知识的贫乏，希望在日后的努力中能做出更完善的系统。

致　谢

经过两个多月的努力，自己终于完成了毕业设计和毕业论文的写作工作，在这里我要感谢我的设计指导老师XXX老师，是他在设计的技术方向上给我提出许多宝贵的设计意见，在最后的测试修改阶段又在百忙之中抽出时间为我提供了必要的帮助，这样使得我得以顺利的完成毕业设计开发工作，老师渊博的知识、敏锐的思路和实事求是的工作作风给我留下了深刻的印象，这将使得我终身受益，谨此向老师表示衷心的感谢。

感谢在校的老师们，在我大学时间里对我的谆谆教诲和无私帮助，在实际的开发工作中，我深深体会到了基础理论知识的重要性，在大学阶段只有好好学习，掌握好扎实的理论基础，这样才能在将来的工作中更快的学习，从而得心应手，有所成就，真正成为一个对社会和他人有用的人。

最后还要感谢我的同学们，在这次毕业设计及论文写作中给我的支持和帮助。

参 考 文 献

1  清宏计算机工作室.JSP编程技巧.机械工业出版社,2000.1

2  柏亚军.JSP编程基础及应用实例集锦.人民邮电出版社,2001.7

3  Donny.JSP与网站开发编程实战.科学出版社,2001.7

4  武延军 黄飞跃.精通JSP编程技术.人民邮电出版社,2001.8

5  Karl Moss. Java Servlet开发人员指南.清华大学出版社，2002

6  Steven Holzner.Java技术内幕.机械工业出版社，2002.1

7  陈海山.深入Java Servlet网络编程[.清华大学出版社,2002.2

8  Phil Hanna .JSP技术大全.机械工业出版社,2002.3

9  周影.网络编程语言JSP实例教程.电子工业出版社,2003.6

10  蔡剑 景楠. Java Web应用开发：J2EE和Tomcat.清华大学出版社. 2005

11  王国辉 牛强.JSP信息系统开发实例精选.机械工业出版社,2005.7

12  王国辉 王易.JSP数据库系统开发案例精选.人民邮电出版社，2006.5

13  赵森. 中文SQL Server 2005 程序设计教程. 冶金工业出版社, 2006.7

附录A  译文

JAVA编程思想

对象的说明

“我们将自然分解开来，将它组织成各种概念，并且如我们所愿的加上不同的意义。我们很大程度上都有这样的意识，就是我们有我们语言的共性，而且是以我们的语言的组件来构成。我们需要认同这种意识所结集的信息的组织与分类，否则我们一点也不能交流。”本杰明 李 霍夫（1897-1941）

计算机革命的起源是一部机器。因此我们编程语言的起源看上去也像那部机器。

但是计算机不是这样的机器，因为它们是思想扩大的工具（“自行车是思想”，正如斯蒂文.乔布斯所喜欢的成语一样）和一种不同种类的有表现力的媒介。因此，这种工具看上去不像一台机器而更像我们心灵的一部分，而且像其他的表达方式，比如：书写，绘画，雕刻，卡通和电影。面向对象的编程（OOP）是这种行动的一部分。这种行动用计算机作为富有表现力的媒介。

本章将为你介绍面向对象的基本概念，包括开发方法的初步了解。本章，乃至这本书，将为你 呈现一些编程的经验，尽管不了解C语言。如果你觉得你在使用本书之前还要做更多的准备，你应该通读一下Thinking in C multimedia seminar（《C语言多媒体研讨编程思想》），下载网站：www.MindView.net.

本章是补充的背景材料。很多人在没有了解概况之前接触面向对象编程时感到很不舒服。因此，这里有很多会介绍很多概念，让你对OOP有粗略的认识。然而，还有很多人直到很吃力的情况才对粗略概念有一定了解，这些人如果不写一些代码来指引可能会陷入僵局，迷失。如果你是后一种情况的人而且渴望学习这种语言的细节，感觉很轻松—那跳过这一点将不会给你写程序或者学习这门语言带来什么影响。然而，最终你会回过头来拓展自己的知识面。这样，你就明白对象的重要性而且知道怎么去设计对象。

抽象化的发展

所有的编程语言都提供了抽象化。一般都认为，你可以解决的问题的复杂度直接跟抽象化的种类和质量有关。所谓“种类”，就是你正在抽象什么？集成化的语言（机器语言）是底层机器的初步抽象。紧随着很多所谓的过程化的语言（比如FORTRAN、BASIC和 C）是集成化语言的抽象。这些语言相对于集成化的语言是很大的提高。但是，在电脑结构相对于你要解决的问题的结构方面，它们主要的抽象化仍然需要你去考虑。程序员必须完成机器模型（在“解决方案空间”里，是你实施解决方案的空间，譬如电脑）和你实际要解决问题的模型（在“问题空间”里，问题存在的空间，譬如说业务）之间的连接。效果要呈现出这种意图，而程序语言外在问题的事实，产生了这样的程序。这样的程序难编写困难，维护昂贵，对整个“程序设计方法”行业产生了副作用。

建立机器模型就是建立你要解决的问题的模型。早期的语言（比如LISP和APL）选择了世界上特别的观点（“所有的问题最终被列出来”或者“所有的问题都是符合算法的”，二者独立）。而Prolog语言将所有的问题归结于决策链。很多语言的产生是为了基于事务的编程或者只用于操作图形符号。（后者被证明太局限了。）对于他们设计的特定层次的问题，这些方法中的每一个都能成为一个很好的解决方案。但是，当你走出那个领域，它们将毫无用处。

面向对象的方法给程序员提供了一种工具来表示问题空间里的元素，这使得面向对象的方法取得了长足的进步。这些表示符号大体上做够了以至于程序员不受任何特殊类型问题的限制。我们将问题空间中的这些元素和解决方案空间中它们对应的表示符号称作“对象”。（你还将需要其他一些在问题空间中没有相似的对象。）这种思想是，通过增加对象的新类型了，允许程序自适应成问题的特性。所以，当你在阅读描述解决方案的代码时，其实你是在看问题的描述。这是一种比我们以前见过的更灵活、更强大的抽象语言。因此，面向对象的编程让你描述问题时就根据问题本身而言，而不要考虑解决方案运行的计算机环境。但是依然跟计算机有联系：任何一个对象看上去非常像一个小的计算机—它有状态，有你可以命令它执行的操作。然而，在现实世界中对于对象来说这并不是一个差的比喻—它们都有特性和行为。

Smalltalk是第一个运行成功的面向对象的语言，也是Java为所基于的语言之一。阿伦.凯总结了Smalltalk的五个特点。这五个特点代表了解面向对象编程的最好的方法：

1.一切都是对象。将一个对象假想成一个变量；它存储数据，但是你可以对那个对象“提出要求”，让它对自己产生不同的操作。理论上，在你努力解决的问题（狗，建筑物，服务等）你可以使用任何的概念组件，然和在你的程序里用一个对象来表示。

2.一个程序就是很多对象通过消息相互调用而完成操作。为了调用一个对象，你给那个对象“发送信息”。更具体点，你可以认为，一个消息就是对一个特定对象里的方法调用的需求。

3.每一个对象本身都是由其他对象构成的。换句话说，通过将已经存在的很多对象打包，你可以建立一个新的对象。因此，你在程序中可以建得很复杂，尽管很多对象的分类是隐藏的。

4.每一个对象都有类型。以这种说法，每一个对象都是一个类的实例，这里的“类”就跟“类型”同类。一个类最重要的辨别特点就是“你可以给它传什么信息？”

5.所有特殊类型的对象都可以接受相同的消息。这的确是一个加载的声明，正如你今后看到的。因为一个“圆”类型的对象必定是一个“形状”类型的对象，一个“圆”肯定会接受“形状”的信息。这就意味着你可以写操作“形状”的代码，这些代码也自动地控制符合“形状”描述的一切。这种可替代性是面向对象编程中最强大的概念之一。

波什给对象提供了更加简洁的描述：

一个对象有声明，行为和标识。

这意味着一个对象可以有内部数据（定义了声明），方法（产生了行为）以及一个对象可以有唯一的标识区别于其他的所有对象—为了有具体的呈现，每个对象在内存里有唯一的地址。

一个对象有一个接口

亚里斯多德很可能是第一个开始仔细研究类型概念的人；他说过“鱼类和鸟类。”这种思想表明，一切对象，尽管是独一无二的，仍然是对象类的一部分，而这种对象类有共同的特点和行为。这种思想直接被用在了第一门面向对象的语言Simula-67中，其最根本的关键字“类”被引入到程序。

Simula-67（模拟）,正如它的名字所表明的，它的创建是为了建立一些模型，比如说“银行出纳问题”。这这种情况下，我们有很多的出纳员，顾客，账户，交易和很多钱—很多的“对象”。对象都是相同的，除了它们的状态在程序执行被分组成“对象类”。那也是关键字“类”的来源。创建抽象数据类型（类）是面向对象编程里面的基本概念。抽象数据类型跟基本数据类型几乎是一样运行的。你可以建立一个类型的变量（在面向对象的声明中称为对象或者实例）然后操作这个变量（称作发送消息或者调用，你发送一个消息然后对象辨别如何处理）。每个类的成员（元素）都有共性：每一个账户都有一个均衡，每个出纳可以接受一笔存款等等。同时，每个成员有自己的声明：每个账户有不同的均衡，每个出纳有名字。因此，出纳，顾客，账户，交易等等，在程序里面都分别可以用一个实体表示。这个实体就是对象，每个对象属于定义了它的特点和行为的类。

所以，尽管在面向对象的编程里我们真正做的是创建新数据类型，几乎所有面向对象的编程语言都用“类”关键字。当你看到了“type（类型）”就去联想“class（类）”，反之亦然。

因为类描述了一组有相同特点（数据元素）和行为（功能）的对象，一个类其实就是一个数据类型。因为比如有一个浮点型的数，也有一组特点和行为。不同点是，程序员根据程序需要定义了一个类，而不必使用设计好了的存储在机器上的数据类型。通过根据你的需求增加新的具体数据类型，扩展编程语言。程序系统接纳新的类，而且给它们所有的类型检查，这些检查跟基本类型是一样的。

面向对象的方法并不只限于构建模型。不管你是否同意，任何程序都是你所设计的系统的模型。面向对象技术的应用很容易的减少了一大堆问题，这样就很容易的得到简单的结论。

一旦一个类完成了，你可以根据自己的需要新建这个类的很多对象，然后你可以操作这个对象，就把这个对象当成你要解决的问题中的一个元素一样。事实上，面向对象编程的挑战之一，就是在问题空间中的元素与解决方案空间的的对象之间创建一对一的对应关系。

但是你怎么使一个对象为你做有用的事情呢？需要有个途径对这个对象产生需求，然后它将做些事情，比如完成一个交易，在屏幕上画出什么或者打开一个开关。而且一个对象只能满足特定的需求。你可以通过一个对象的接口对一个对象产生需求，类型就是用来决定接口的。一个简单的亮灯例子，或许是一个很好的展示：

图 附录X

接口决定了你对一个特定类所做的需求。然而，某个地方必须有代码来满足这个需求。这个包括隐藏的数据和实施。从程序的立场来看，这个并不这么复杂。一个类型有一个方法跟各个可能的需求相联系，当你对一个对象产生了一个特定的需求，那个方法就被调用了。这个过程通常被总结成说你“发送了信息”（产生了需求）给一个对象，而且这个对象知道如何去处理这个信息（它将执行代码）。

这里，类型/类的名称是Light(灯)，这个Light类的特定对象的名称是lt，你可以对一个Light对象的需求是打开灯，关闭灯，使得灯更亮，或者使得灯更暗。你通过定义了一个lt参数来创建Light的对象，然后通过调用new来新建一个Light类型的对象。为了给那个对象发送消息，你声明了对象的名称，然后将它跟那个时间需要的信息相联系。从一个预定义类的用户角度来看，使用对象对于编程来说是相当的好了。

前期图表是根据UML（统一建模语言）的规范来做的。一个方框表示一个类，方框的顶部是类型名。你所定义的任何数据成员都在方框的中部，然后这些方法（这些对象的功能，用来接收你发给对象的信息）在方框的底部。通常，只有类名和公开方法在UML设计图表里显示，所以，在这种情况下，方框的中部是不显示的。如果你只对类名感兴趣，那么方框的底部也不需要显示了。

一个对象提供了服务

当你努力开发或者理解程序设计的时候，最好的方法之一就是将对象考虑成“服务的提供者”。你的程序本身就是给用户提供服务的，而且它会通过其他对象提供的服务完成这个。你的目的就是产生（或者更好一点，定位到已经存在的代码库）一系列的对象，这些对象提供理想的服务来解决你的问题。

开始做这个的一个途径就是问。“如果我可以魔术般的把它们从帽子里拉出来，什么对象可以立刻解决我的问题呢？”比如，假设你正在创建一个簿记程序。你或许会设想一些对象，它们包含簿记输入屏幕的预定义，其他的一些对象显示簿记的计算，还有一个对象操作所有不同打印机上发票和结算的打印。或许这些对象中的一些已经存在了，或者一些不存在，它们看上去是什么样的呢？这些对象会提供什么服务？它们需要什么对象来完成它们的义务呢？如果你坚持这么做，最终你会达到一种境界，然和可以这么说“对象看上去这么简单，坐下来就能写出”或者“我知道那个对象已经存在了”。这是一个合理的途径来将问题分解成一组对象。

把一个对象当作服务提供者还有另外的益处：它可以提高对象的凝聚力。高内聚是软件设计的基本质量要求：这意味着各个不同的软件组件（例如一个对象，尽管它可能应用于某个方法或者一个对象库）很好的结合在一起。人们在设计对象时遇到的一个问题是将很多的方法塞到一个对象里面。比如说，在你的发票打印模型中，你觉得你需要一个对象，这个对象知道所有的格式和打印。你很可能会发现，这对于一个对象来说太多了，所以你需要三个或者三个以上的对象。一个对象或许是所有可能的账单的目录，可以用来查询怎样打印账单的信息。另一个或者一组对象可以作为继承的打印接口，可以了解所有不同种类的打印机（但是没有关于簿记的，相对于亲自写这个，还不如买）。然后，第三个对象可以使用其他两个提供的服务来完成任务。因此，每个对象有一系列它所提供的聚合服务。在一个好的面向对象的设计中，每一个对象都把一件事做的很好，但是不尝试做很多。这样不仅允许对象是买来的（打印机接口对象），而且产生了一些可以在其他地方再次使用的新对象（账单布局的目录）。

把对象当作服务提供者是个很好的分类工具。这个不但在设计的过程中很有用，在别人想理解你的代码或者再次利用对象时也很有用。如果他们基于这个对象所提供的服务而看到这个对象的价值时，那将使它更容易的融入到设计中去。

隐性操作

在类的创建者（创建新类型的人）和程序员客户（那些在他们的应用程序中使用这些类型的人）领域取得突破是大有益处的。程序员客户的需求就是收集一个工具箱，它充满了那些用于快速开发应用程序的类。那些类的创建者的目标就是创建一个类，这个类只公开那些对程序员客户来说需要的部分而隐藏其他的一切。为什么呢?因为如果它是隐藏着的，那些程序员就不能接触到它，也就是说，这些类的创建者可以随便的修改那些隐藏的部分而不需要担心对其他任何人的影响。这些隐藏的部分通常代表着一个对象内部的方案，它很容易被一个粗心的或者不正规的程序员所损坏了，所以将这些操作隐藏起来以减少程序的错误。

附录B  外文原文

Thinking in java

Introduction to Objects

“We cut nature up, organize it into concepts, and ascribe significances as we do, largely because we are parties to an agreement that holds throughout our speech community and is codified in the patterns of our language…we cannot talk at all except by subscribing to the organization and classification of data which the agreement decrees. ”Benjamin Lee Whorf（1897-1941）

The genesis of the computer revolution was in a machine. The genesis of our programming languages thus tends to look like that machine.

But computers are not so much machines as they are mind amplification tools (“bicycles for the mind,” as Steve Jobs is fond of saying) and a different kind of expressive medium. As a result, the tools are beginning to look less like machines and more like parts of our minds, and also like other forms of expression such as writing, painting, sculpture, animation, and filmmaking. Object-oriented programming(OOP) is part of this movement toward using the computer as an expressive medium.

This chapter will introduce you to the basic concepts of OOP, including an overview of development methods. This chapter, and this book, assumes that you have some programming experience, although not necessarily in C. If you think you need more preparation in programming before tackling this book, you should work through the Thinking in C multimedia seminar, downloadable from www.MindView.net.

This chapter is background and supplementary material. Many people do not feel comfortable wading into object-oriented programming without understanding the big picture first. Thus, there are many concepts that are introduced here to give you a solid overview of OOP. However, other people may not get the big picture concepts until they’ve seen some of the mechanics first; these people may become bogged down and lost without some code to get their hands on. If you’re part of this latter group and are eager to get to the specifics of the language, feel free to jump past this chapter—skipping it at this point will not prevent you from writing programs or learning the language. However, you will want to come back here eventually to fill in your knowledge so you can understand why objects are important and how to design with them.

The progress of abstraction

All programming languages provide abstractions. It can be argued that the complexity of the problems you’re able to solve is directly related to the kind and quality of abstraction. By “kind” I mean, “What is it that you are abstracting?” Assembly language is a small abstraction of the underlying machine. Many so-called “imperative” languages that followed (such as FORTRAN, BASIC, and C) were abstractions of assembly language. These languages are big improvements over assembly language, but their primary abstraction still requires you to think in terms of the structure of the computer rather than the structure of the problem you are trying to solve. The programmer must establish the association between the machine model (in the “solution space,” which is the place where you’re implementing that solution, such as a computer) and the model of the problem that is actually being solved (in the “problem space,” which is the place where the problem exists, such as a business). The effort required to perform this mapping, and the fact that it is extrinsic to the programming language, produces programs that are difficult to write and expensive to maintain, and as a side effect created the entire “programming methods” industry.

The alternative to modeling the machine is to model the problem you’re trying to solve. Early languages such as LISP and APL chose particular views of the world (“All problems are ultimately lists” or “All problems are algorithmic,” respectively). Prolog casts all problems into chains of decisions. Languages have been created for constraint-based programming and for programming exclusively by manipulating graphical symbols. (The latter proved to be too restrictive.)Each of these approaches may be a good solution to the particular class of problem they’re designed to solve, but when you step outside of that domain they become awkward.

The object-oriented approach goes a step further by providing tools for the programmer to represent elements in the problem space. This representation is general enough that the programmer is not constrained to any particular type of problem. We refer to the elements in the problem space and their representations in the solution space as “objects.”(You will also need other objects that don’t have problem-space analogs.) The idea is that the program is allowed to adapt itself to the lingo of the problem by adding new types of objects, so when you read the code describing the solution, you’re reading words that also express the problem. This is a more flexible and powerful language abstraction than what we’ve had before. Thus, OOP allows you to describe the problem in terms of the problem, rather than in terms of the computer where the solution will run. There`s still a connection back to the computer: Each object looks quite a bit like a little computer—it has a state, and it has operations that you can ask it to perform. However, this doesn`t seem like such a bad analogy to objects in the real world—they all have characteristics and behaviors.

Alan Kay summarized five basic characteristics of Smalltalk, the first successful object-oriented language and one of the languages upon which Java is based. These characteristics represent a pure approach to object-oriented programming:

1. Everything is an object. Think of an object as a fancy variable; it stores data, but you can “make requests” to that object, asking it to perform operations on itself. In theory, you can take any conceptual component in the problem you’re trying to solve (dogs, buildings, services, etc.) and represent it as an object in your program.
2. A program is a bunch of objects telling each other what to do by sending messages. To make a request of an abject, you “send a message” to that object. More concretely, you can think of a message as a request to call a method that belongs to a particular object.
3. Each object has its own memory made up of other objects. Put another way, you create a new kind of object by making a package containing existing objects. Thus, you can build complexity into a program while hiding it behind the simplicity of objects.
4. Every object has a type. Using the parlance, each object is an instance of a class, in which “class” is synonymous with “type.” The most important distinguishing characteristic of a class is “What messages can you send to it?”
5. All objects of a particular type can receive the same messages. This is actually a loaded statement, as you will see later. Because an object of type “circle” is also an object of type “shape,” a circle is guaranteed to accept shape messages. This means you can write code that talks to shapes and automatically handle anything that fits the description of a shape. This substitutability is one of the powerful concepts in OOP.

Booch offers an even more succinct description of an object:

An object has state, behavior and identity.

This means that an object can have internal data (which gives it state), methods(to produce behavior), and each object can be uniquely distinguished from every other object—to put this in a concrete sense, each object has a unique address in memory.

An object has an interface 

Aristotle was probably the first to begin a careful study of the concept of type; he spoke of “the class of fishes and the class of birds.” The idea that all objects, while being unique, are also part of a class of objects that have characteristics and behaviors in common was used directly in the first object-oriented language, Simula-67, with its fundamental keyword class that introduces a new type into a program.

Simula-67, as its name implies, was created for developing simulations such as the classic “bank teller problem.” In this, you have numerous tellers, customers, accounts, transactions, and units of money— a lot of “objects.” Objects that are identical except for their state during a program’s execution are grouped together into “classes of objects,” and that’s where the keyword class came from. Creating abstract data types (classes) is fundamental concept in object-oriented programming. Abstract data types work almost exactly like built-in types: You can create variables of a type (called objects or instances in object-oriented parlance) and manipulate those variables (called sending messages or requests; you send a message and the object figures out what to do with it). The members (elements) of each class share some commonality: Every account has a balance, every teller can accept a deposit, etc. At the same time, each member has its own state: Each account has a different balance, each teller has a name. Thus, the tellers, customers, accounts, transactions, etc, can each be represented with a unique entity in the computer program. This entity is the object, and each object belongs to a particular class that defines its characteristics and behaviors.

So, although what we really do in object-oriented programming is create new data types, virtually all object-oriented programming languages use the “class” keyword. When you see the word “type” think “class” and vice versa.

Since a class describes a set of objects that have identical characteristics (data elements) and behaviors(functionality), a class is really a data type because a floating point number, for example, also has a set of characteristics and behaviors. The difference is that a programmer defines a class to fit a program rather than being forced to use an existing data type that was designed to represent a unit of storage in a machine. You extend the programming language by adding new data types specific to your needs. The programming system welcomes the new classes and gives them all the care and type checking that it gives to built-in types.

The object-oriented approach is not limited to building simulations. Whether or not you agree that any program is a simulation of the system you’re designing, the use of OOP techniques can easily reduce a large set of problems to a simple solution.

Once a class is established, you can make as many objects of that class as you like, and then manipulate those objects as if they are the elements that exist in the problem you are trying to solve. Indeed, one of the challenges of object-oriented programming is to create a one-to-one mapping between the elements in the problem space and object in the solution space.

But how do you get an object to do useful work for you? There needs to be a way to make a request of the object so that it will do something, such as complete a transaction, draw something on the screen, or turn on a switch. And each object can satisfy only certain requests. The requests you can make of an object are defined by its interface, and the type is what determines the interface. A simple example might be a representation of a light bulb:

The interface determines the requests that you can make for a particular object. However, there must be code somewhere to satisfy that request. This, along with the hidden data, comprises the implementation. From a procedural programming standpoint, it is not that complicated. A type has a method associated with each possible request, and when you make a particular request to an object, that method is called. This process is usually summarized by saying that you “send a message” (make a request) to an object, and the object figures out what to do with that message (it executes code).

Here, the name of the type/class is Light, the name of this particular Light object is lt, and the requests that you can make of a Light object are to turn it on, turn it off, make it brighter, or make it dimmer. You create a Light object by defining a “reference” (lt) for that object and calling new to request a new object of that type. To send a message to the object, you state the name of the object and connect it to the message request with a period (dot). From the standpoint of the user of a predefined class, that’s pretty much all there is to programming with objects.

The preceding diagram follows the format of the Unified Modeling Language (UML). Each class is represented by a box, with the type name in the top portion of the box, any data members that you care to describe in the middle portion of the box, and the methods (the functions that belong to this object, which receive any messages you send to that object) in the bottom portion of the box. Often, only the name of the class and the public methods are shown in UML design diagrams, so the middle portion is not shown, as in this case. If you’re interested only in the class name, then the bottom portion doesn’t need to be shown, either.

An object provides services

While you’re trying to develop or understand a program design, one of the best ways to think about objects is as “service providers.” Your program itself will provide services to the user, and it will accomplish this by using the services offered by other objects. Your goal is to produce (or even better, locate in existing code libraries) a set of objects that provide the ideal services to solve your problem.

A way to start doing this is to ask, “If I could magically pull them out of a hat, what objects would solve my problem right away?” For example, suppose you are creating a bookkeeping program. You might imagine some objects that contain pre-defines bookkeeping input screens, another set of objects that perform bookkeeping calculations, and an object that handles printing of checks and invoices on all different kinds of printers. Maybe some of these objects already exist, and for the ones that don’t, what would they look like? What services would those objects provide, and what objects would they need to fulfill their obligations? If you keep doing this, you will eventually reach a point where you can say either, “That object seems simple enough to sit down and write” or “I’m sure that object must exist already.” This is a reasonable way to decompose a problem into a set of objects.

Thinking of an object as a service provider has an additional benefit: It helps to improve the cohesiveness of the object. High cohesion is a fundamental quality of software design: It means that the various aspects of a software component (such as an object, although this could also apply to a method or a library of objects) “fit together” well. One problem people have when designing objects is cramming too much functionality into one object. For example, in your check printing module, you may decide you need an object that knows all about formatting and printing. You’ll probably discover that this is too much for one object, and that what you need is three or more objects. One object might be a catalog of all the possible check layouts, which can be queried for information about how to print a check. One object or set of objects can be a generic printing interface that knows all about different kinds of printers (but nothing about bookkeeping-this one is a candidate for buying rather than writing yourself). And a third object could use the services of the other two to accomplish the task. Thus, each object has a cohesive set of services it offers. In a good object-oriented design, each object does one thing well, but doesn’t try to do too much. This not only allows the discovery of objects that might be purchased (the printer interface object), but it also produces new objects that might be reused somewhere else (the catalog of check layouts).

Treating objects as service providers is a great simplifying tool. This is useful not only during the design process, but also when someone else is trying to understand your code or reuse an object. If they can see the value of the object based on what service it provides, it makes it much easier to fit it into the design.

The hidden implementation

It is helpful to break up the playing field into class creators (those who create new data types) and client programmers (the class consumers who use the data types in their applications). The goal of the client programmer is to collect a toolbox full of classes to use for rapid application development. The goal of the class creator is to build a class that exposes only what’s necessary to the client programmer and keeps everything else hidden. Why? Because if it’s hidden, the client programmer can’t access it, which means that the class creator can change the hidden portion at will without worrying about the impact on anyone else. The hidden portion usually represents the tender insides of an object that could easily be corrupted by a careless or uninformed client programmer, so hiding the implementation reduces program bugs.