基于JSP的在线书店销售系统的设计与实现外文文献及翻译
基于JSP校园二手交易系统的设计与实现外文翻译
1. SimpleWe wanted to build a system that could be programmed easily without a lot of eso-teric training and which leveraged today’s standard practice. So even though we found that C++ was unsuitable, we designed Java as closely to C++ as possible in order to make the system more comprehensible. Java omits many rarely used, poorly understood, confusing features of C++ that, in our experience, bring more grief than benefit.The syntax for Java is, indeed, a cleaned-up version of the syntax for C++. There is no need for header files, pointer arithmetic (or even a pointer syntax), structures, unions, operator overloading, virtual base classes, and so on. (See the C++ notes interspersed throughout the text for more on the differences between Java and C++.) The designers did not, however, attempt to fix all of the clumsy features of C++. For example, the syn-tax of the switch statement is unchanged in Java. If you know C++, you will find the tran- sition to the Java syntax easy. If you are used to a visual programming environment (such as Visual Basic), you will not find Java simple. There is much strange syntax (though it does not take long to get the hang of it). More important, you must do a lot more programming in Java. The beauty of Visual Basic is that its visual design environment almost automatically pro-vides a lot of the infrastructure for an application. The equivalent functionality must be programmed manually, usually with a fair bit of code, in Java. There are, however, third-party development environ ments that provide “drag-and-drop”-style program development.2.Object OrientedSimply stated, object-oriented design is a technique for programming that focuses on the data (= objects) and on the interfaces to that object. To make an analogy with carpentry, an “object-oriented” carpenter would be mostly concerned with the chair he was building, and secondarily with the tools used to make it; a “non-object-oriented” carpenter would think primarily of his tools. The object-oriented facilities of Java are essentially those of C++.Object orientation has proven its worth in the last 30 years, and it is inconceivable that a modern programming language would not use it. Indeed, the object-oriented features of Java are comparable to those of C++. The major difference between Java and C++ lies in multiple inheritance, which Java has replaced with the simpler concept of interfaces, and in the Java metaclass model.work-SavvyJava has an extensive library of routines for coping with TCP/IP protocols like HTTP and FTP. Java applications can open and access objects across the Net via URLs with the same ease as when accessing a local file system.4.RobustJava is intended for writing programs that must be reliable in a variety of ways. Java puts a lot of emphasis on early checking for possible problems, later dynamic (runtime) checking, and eliminating situations that are error-prone. . . . The single biggest difference between Java and C/C++ is that Java has a pointer model that elim- inates the possibility of overwriting memory and corrupting data.5.SecureJava is intended to be used in networked/distributed environments. Toward that end, a lot of emphasis has been placed on security. Java enables the construction of virus-free, tamper-free systems.From the beginning, Java was designed to make certain kinds of attacks impossible,among them:•Overrunning the runtime stack—a common attack of worms and viruses•Corrupting memory outside its own process space•Reading or writing files without permission6.Architecture NeutralThe compiler generates an architecture-neutral object file format—the compiled code is executable on many processors, given the presence of the Java runtime sys-tem. The Java compiler does this by generating bytecode instructions which have nothing to do with a particular computer architecture. Rather, they are designed to be both easy to interpret on any machine and easily translated into native machinecode on the fly.7.PortableUnlike C and C++, there are no “implementation-dependent” aspects of the specifi- cation. The sizes of the primitive data types are specified, as is the behavior of arith-metic on them.For example, an int in Java is always a 32-bit integer. In C/C++, int can mean a 16-bit integer, a 32-bit integer, or any other size that the compiler vendor likes. The only restriction is that the int type must have at least as many bytes as a short int and cannot have more bytes than a long int. Having a fixed size for number types eliminates a major porting headache. Binary data is stored and transmitted in a fixed format, eliminating confusion about byte ordering. Strings are saved in a standard Unicode format..8.InterpretedThe Java interpreter can execute Java bytecodes directly on any machine to which the interpreter has been ported. Since linking is a more incremental and lightweight process, the development process can be much more rapid and exploratory.9.High PerformanceWhile the performance of interpreted bytecodes is usually more than adequate, there are situations where higher performance is required. The bytecodes can be translated on the fly (at runtime) into machine code for the particular CPU the application is running on.10.Multithreaded[The] benefits of multithreading are better interactive responsiveness and real-time behavior.11.DynamicIn a number of ways, Java is a more dynamic language than C or C++. It was designed toadapt to an evolving environment. Libraries can freely add new meth- ods and instance variables without any effect on their clients. In Java, finding out runtime type information is straightforward..This is an important feature in those situations in which code needs to be added to a running program. A prime example is code that is downloaded from the Internet to run in a browser. In Java 1.0, finding out runtime type information was anything but straightforward, but current versions of Java give the programmer full insight into both the structure and behavior of its objects. This is extremely useful for systems that need to analyze objects at runtime, such as Java GUI builders, smart debuggers, pluggable components, and object databases.Common Misconceptions about Java1.Java is an extension of HTML.Java is a programming language; HTML is a way to describe the structure of a web page. They have nothing in common except that there are HTML extensions for placing Java applets on a web page.2.I use XML, so I don’t need Java.Java is a programming language; XML is a way to describe data. You can process XML data with any programming language, but the Java API contains excellent support for XML processing. In addition, many important third-party XML tools are implemented in Java. See V olume II for more information.3.Java is an easy programming language to learn.No programming language as powerful as Java is easy. You always have to distinguish between how easy it is to write toy programs and how hard it is to do serious work. Also, consider that only four chapters in this book discuss the Java language.4.Java will become a universal programming language for all platforms.This is possible, in theory, and it is certainly the case that every vendor but Microsoft seems to want this to happen. However, many applications, already working perfectly well on desktops, would not work well on other devices or inside a browser. Also, these applications have been written to take advantage of the speed of the processor and the native user interface library and have been ported to all the important platforms any-way. Among these kinds of applications are word processors, photo editors, and web browsers. They are typically written in C or C++, and we see no benefit to the end user in rewriting them in Java.5.Java is just another programming language.Java is a nice programming language; most programmers prefer it over C, C++, or C#. But there have been hundreds of nice programming languages that never gained wide- spread popularity, whereas languages with obvious flaws, such as C++ and Visual Basic, have been wildly successful.Why? The success of a programming language is determined far more by the utility of the support system surrounding it than by the elegance of its syntax. Are there useful, convenient, and standard libraries for the features that you need to implement? Are there tool vendors that buildgreat programming and debugging environments? Does the language and the toolset integrate with the rest of the computing infrastructure? Java is successful because its class libraries let you easily do things that were hard before, such as networking and multithreading. The fact that Java reduces pointer errors is a bonus and so programmers seem to be more productive with Java, but these factors are not the source of its success.6.Now that C# is available, Java is obsolete.C# took many good ideas from Java, such as a clean programming language, a virtual machine, and garbage collection. But for whatever reasons, C# also left some good stuff behind, in particular security and platform independence. If you are tied to Windows, C# makes a lot of sense. But judging by the job ads, Java is still the language of choice for a majority of developers.7.Java is proprietary, and it should therefore be avoided.Sun Microsystems licenses Java to distributors and end users. Although Sun has ulti- mate contr ol over Java through the “Java Community Process,” they have involved many other companies in the development of language revisions and the design of new libraries. Source code for the virtual machine and the libraries has always been freely available, but only for inspection, not for modification and redistribution. Up to this point, Java has been “closed source, but playing nice.”8.Java is interpreted, so it is too slow for serious applications.In the early days of Java, the language was interpreted. N owadays, except on “micro”platforms such as cell phones, the Java virtual machine uses a just-in-time compiler. The“hot spots” of your code will run just as fast in Java as they would in C++, and in some cases, they will run faster.Java does have some additional overhead over C++. Virtual machine startup time is slow, and Java GUIs are slower than their native counterparts because they are painted in a platform-independent manner.People have complained for years that Java applications are too slow. How ever, today’s computers are much faster than they were when these complaints started.A slow Java program will still run quite a bit better than those blazingly fast C++ programs did afew years ago. At this point, these complaints sound like sour grapes, and some detrac- tors have instead started to complain that Java user interfaces are ugly rather than slow.9.All Java programs run inside a web page.All Java applets run inside a web browser. That is the definition of an applet—a Java program running inside a browser. But most Java programs are stand-alone applications that run outside of a web browser. In fact, many Java programs run on web servers and produce the code for web pages.10.Java programs are a major security risk.11.JavaScript is a simpler version of Java.JavaScript, a scripting language that can be used inside web pages, was invented by Netscape and originally called LiveScript. JavaScript has a syntax that is reminiscent of Java, but otherwise there are no relationships (except for the name, of course). A subset of JavaScript is standardized as ECMA-262. JavaScript is more tightly integrated with browsers than Java applets are. In particular, a JavaScript program can modify the document that is being displayed, whereas an applet can only control the appearance of a limited area.12.With Java, I can replace my computer with a $500 “Internet appliance.”When Java was first released, some people bet big that this was going to happen. Ever since the first edition of this book, we have believed it is absurd to think that home users are going to give up a powerful and convenient desktop for a limited machine with no local storage. We found the Java-powered network computer a plausible option for a “zero administration initiative” to cut the costs of computer ownership in a business,but even that has not happened in a big way.On the other hand, Java has become widely distributed on cell phones. We must confess that we haven’t yet seen a must-have Java application running on cell phones, but the usual fare of games and screen savers seems to be selling well in many markets.1.简单性人们希望构建一个无需深奥的专业训练就可以进行编程的系统，并且要符合当今的标准惯例。
基于JSP的在线书店销售系统的设计与实现
毕业设计说明书基于JSP的在线书店销售系统的设计与实现专业学生姓名班级学号指导教师完成日期基于JSP的在线书店销售系统的设计与实现摘要：21世纪，随着计算机科学技术的发展，贸易的全球化和网络的全球化两大特征走到了一起，形成了如今风靡全球的电子商务。
电子商务在Internet中的应用越来越广泛，为广大网络用户提供了更加周到和人性化的服务已逐渐成为当今Web应用的潮流，而购物网站正是这种活动的具体表现形式。
网上购物在我国的发展虽不如欧美，但当今发展很快，众多网上购物网站不断涌现，较有代表的如eBay易趣、taobao淘宝、1pai雅虎新浪一拍等。
随着我国互联网的更加普及和电子商务的日趋成熟，会有越来越大的消费群体，市场潜力会得到充分发挥。
与传统C/S相比，B/S更具优势（如客户端无须安装软件等）。
合理规划和设计B/S模式的电子商务网站，直接关系到网络销售系统的运行效率，以及消费者的兴趣。
对网络销售系统不合时宜的设计，不仅无助于问题的解决，而且会耽误商机，使自己处于被动地位。
临渊羡鱼，不如退而结网。
网络购物系统的完善和便捷将是现代社会必然的需求。
任务书研究了基于JSP技术和SQL Server数据库开发网络图书销售系统的全过程。
关键词：电子商务；网络图书销售系统；JSPDesign and implementation of online bookstore salessystem based on JSPAbstract：In the 21st century, with the development of science and technology of the computer, trade globalization and two major characteristics of globalization of the network got togather, have formed the nowadays-fashionable e-commerce in the world. The application in Internet of e-commerce is more and more extensive, have already nowadays become the trend that Web uses gradually users more thoughtful and more humanized service after offering to the masses of network, and the shopping website is exactly this kind of concrete form of expression of moving about. Although the development of online shopping in our country is not so good as America and Europe, nowadays develop quickly, emerge constantly, have relatively on behalf of if eBay E, taobao, 1pai,etc. With Internet popularization and e-commerce of our country ripe becoming, there are bigger and bigger consumption colonies; the market potential will be given full play to. Compared with traditional C/S, B/S has even more advantages (such as needn't install software in the client, etc.). Rational planning and designing the e-commerce website of B/S mode, concern the operational efficiency of the marketing system of the network, and consumers' interest directly. The unseasonable design to the marketing system of the network is not only helpless to the settlement of the problem, but alse delay the business opportunity, will make oneself in the passive position. It's better to go back and make a net than to stand by the pond and long for fish. The systematic perfection and convenient of shopping at network will be modern society's inevitable demands. This text has studied the whole course of books marketing system of network on the basis of JSP technology and SQL Server database. Key words：E-commerce; books marketing system of network; ASP目录1概述 (1)1.1课题背景 (1)1.2课题研究的意义和现状 (1)1.3课题的系统概述 (2)2在线书店销售系统的相关技术介绍 (3)2.1B ROWSER/SERVER结构 (3)2.1.1三层结构 (4)2.2JSP的运作模式 (4)2.3SQL S ERVER 2005简介 (5)3 基于JSP的在线书店销售系统的设计 (5)3.1需求分析 (5)3.1.1系统需要解决的主要问题 (5)3.1.2系统开发环境 (6)3.2系统具备的功能 (6)3.3用例模型 (6)3.3.1用户U SE CASE图 (6)3.3.2管理员U SE CASE图 (7)3.3.3书店销售系统E-R图 (7)3.4数据库的设计与实现 (8)3.4.1数据库的需求分析 (8)3.4.2数据库的逻辑设计 (8)3.5数据库的结构创建 (9)4基于JSP的在线书店销售系统的实现 (12)4.1后台系统和数据库的配置 (12)4.1.1后台服务器配置 (12)4.1.2后台数据库的配置 (12)4.1.3后台全局配置文件 (12)4.2前端网络页面的开发与设计 (13)4.2.1用户注册网页 (13)4.2.2用户登录页面 (17)4.2.3管理员操作页面 (18)4.2.4用户购物操作 (20)4.2.5管理员管理页面 (23)4.2.6个人资料修改页面 (24)5系统测试 (26)5.1软件测试的目的和原则 (26)5.2测试的方法 (26)5.2.1黑盒测试 (26)5.2.2白盒测试 (26)5.3测试实例(测试集)的研究与选择 (27)5.4系统的维护 (27)6结束语 (28)参考文献 (29)致谢 (31)基于JSP的在线书店销售系统的设计与实现1概述1.1课题背景新世纪的到来，Internet和计算机网络技术的蓬勃发展，网络化和全球化已成为不可抗拒的世界潮流。
外文翻译 基于ASPNET的网上图书销售系统的设计与实现
外文翻译基于ASPNET的网上图书销售系统的设计与实现Active Server Pages (ASP) is a server-side scripting environment that enables the development of dynamic web ns。
With ASP。
developers can create and deploy web server ns that incorporate HTML pages。
script orders。
ActiveX modules。
and powerful web ns。
The ASP platform is highly flexible and allows for easy n and n of web ns.One of the key benefits of ASP is its ability to combine HTML pages and script orders to create dynamic web pages。
This feature enables developers to create highly interactive and responsive web ns that can adapt to changing user needs and preferences。
nally。
ASP supports the use of ActiveX modules。
which further enhances the nality and performance of web ns.Another advantage of ASP is its ease of development and n。
The platform provides a user-friendly interface that allows developers to quickly and easily create and modify web ns。
基于JSP的网上书店系统的设计与实现
２ ０ １ ４ 年 第１ １ 期ｌ 科 技创 新与应 用
ቤተ መጻሕፍቲ ባይዱ
基于 Ｊ Ｓ Ｐ的 网上书店系统 的设计与实现
梁 红 硕
（ 石 家庄职业技术学院 ， 河北 石 家庄 ０ ５ ０ ０ ０ ０ ）
摘 要： 本文是基于 Ｊ ｓ ｐ的 网上 书店 系统 的设 计 ， 文 中给 出该 店 系统 的 主要 功 能模 块 ， 根据 实体 Ｅ － Ｒ图进 行 了相 应 数 据表 的设 计， 并 对 个功 能模 块 进行 了详 细设 计 。
个， 而使用哪个视 图则由控制器决定， 在视图层 ， 可以采用 Ｊ ｓ ｐ页面来 实现 。控制层 （ Ｃ ｏ ｎ ｔ ｒ ｏ ｌ ｌ ｅ ｒ ） 可 以理解 为—个 分发装 置 ， 它 的主要功能 就是 协调并调用需要的资源尉 象来完成用户请求。 通常控制器会为任务调 用合适的模型， 以及选择合适的视图。模型层（ Ｍｏ ｄ ｅ １ ） 是指用于数据之 上 的数据 内容 和数据 规则 ，它一 般对 应 于应 用程 序所要 管理 的对 象 。 在软件系统中，任何事物都可以被抽象成可以被某种方式处理的数据 模型。数据模型的处理过程对其它层来说是黑箱操作，模型层接受视 图层请求的数据 ， 然后返回相应的处理结果。 ４功能 模块详 细设计 该 网上 书店 系统主要 包 含 了两 大模 块 ， 消 费用 户前 台和 书店 管理 后 台。 消费用 户模 块 ： 实现 了用户 注册 、 登录、 用 户浏览 商 品 、 下 订单 、 修 改用户密码、 注销用户等功能。 后台管理模块 ： 实现了管理员登录、 删除 消费用户 、 增加修改删除商品信息， 查看发送客户订单等功能。
＼ 鼹蔓书 难孬 茂ｉ ＼
ｌ
信息是否正确 ， 并可以进行个人资料的修改。 购买 图书时 ， 在该 图书查看 页面点 击“ 加入购 物车 ” ， 在购 物车 页面 消费用户可以修改购物车中的购买的数量 ， 继续购物等功能 ， 可以对商 ｌ 品下订单。 用户提交订单， 信息会传给后台， 管理员对订单进行处理后， Ｌ — Ｌ 慝 上 ］ 广 』 ＿ ■ ■ 消费用户 可 以查 看 “ 我 的订单 ” ， 了解 订单状 态 。 管理员 登 录可以对 商品 进行管理 ， 对用户进行管理， 对订单进行管理三部分。 ４ ＿ ２消 费用户模 块设 计 消费用户模块主要包括用户信息的注册 、 用户信息的修改和用户 对商品加入购物车、 生成Ｓ Ｔ ＠、 提交订单这几部分。 骜 ｔ ４ ． ２ ． １注册用户信息 ：用户通过该功能能够注册一个网站用户帐 ｜ 薯 ｜ ｊ ｜ ｉ ｌ ｜ ｜ 蛩 号。用户首先填写自己的个人信息 ， 系统会检验用户名是否已被注册， 图 １网上 书店 系统主要 功能模 块 图 如果 已有该用户名， 贝 峪 出提示 ， 如果所有信息填写正确 ， 则注册成功。 ２数据 库设计 ４ ． ２ ． ２修改用户信息： 用户登录后， 点击 “ 个人信息” ， 可以进行个人 网上书店 系统 前 台主要 实现客 户端 ，后 台是 管理 的 网购平 台 ， 涉 信息的查看及修改 。 如果要修改信息 ， 必须提供密码保护问题和密保答 及商品信息、 消费用户信息 、 购买商品生成订单等多个实体。 案。 ２ ． １消费用 户实体 Ｅ — Ｒ图 ４ ． ２ ． ３用户购 物 ： 用户 进入某 商 品的详 细介绍 页 面 ， 点击 “ 加 入购 物 网上 书 店 系统 将管 理所 有 消 费用 户 的信 息 ，在对 商 品加 入购 物 车 ” ， 系统在 购物 车 中记 录下用 户所 选购 的商 品 ， 如该 商品在 购 物车 中 车、 提交订单操作时， 会直接引用消费用户的实体屙 。消费用户实体 已经 存在 ， 只需 要将 相应 数量 进行 加 １ 操作 ， 如果 该 商品不 存在 ， 则在 包 括用 户 名称 、 用 户密 码 、 地址 、 电话 、 Ｅ － ｍ ａ ｉ ｌ 、 注册 时 间 、 密 保 问题 、 密 购物 车 中创 建新 纪录 ， 并将 数量 设置为 １ 。 在购 物车 页面可 以对商 品的 保 答案 等属性 。 数量进行增加或减少， 用户单击“ 继续购物” ， 系统关闭购物车视图转到 ２ ． ２图书商品实体 Ｅ — Ｒ图 主页面 ， 点击“ 生成订单” ， 并提交订单 ， 则该订单会在我的订单中记录 图书商品信息是网上书店系统 的基本信息，维护图书商品的添 保存 。 加、 修改、 删除等操作。图书商品实体包括图书编号 、 图书名称、 图书描 ４ － ３管理员 模块 述、 图书单 价 、 图书数量 、 图书 图片名称 、 入库 时 间 、 图书类 型属性 。 管理员 模块 主包 括商 品管理 、 用 户管 理 和订单 管 理三个 部分 。下 ２ ． ３订 单实体 Ｅ － Ｒ图 面 以商品管 理功 能为主 ， 介 绍商 品管理模块 实现 的业务逻 辑 。 订单 实体 是 消 费用 户对 自己购 买 物 品的 了解 。其 中订 单 表 中包 ４ ． ３ ． １商品管理 ： 主要对图书商品货物信息的管理 ， 查看商品信息 ， 括： 订 单编 号 、 用户名 称 、 商 品总价 、 订 购 时间 、 订 购状态 、 订购 数量 等属 可以对商品进行删除和修改功能。根据货物需求 ，及时的添加商品信 Ｉ 书瞧镇璃攘块 ｜ ｜ ＼ 薯 ｜ 濑强豫产梭块罄 ｌ ｌ ＼＼萋 。 ≮ ≈ 漩磬鞭 羲 § § 《
jsp网上商城系统毕业设计答辩外文文献及译文
毕业设计说明书英文文献及中文翻译学生姓名：学号：学院：专业：指导教师：Struts——an open-source MVC implementationBy: Malcolm Davis.Source: Struts--an open-source MVC implementation[J].IBM Systems JournalThis article introduces Struts, a Model-View-Controller implementation that uses servlets and JavaServer Pages (JSP) technology. Struts can help you control change in your Web project and promote specialization. Even if you never implement a system with Struts,you may get some ideas for your future servlets and JSP page implementation.IntroductionKids in grade school put HTML pages on the Internet. However, there is a monumental difference between a grade school page and a professionally developed Web site. The page designer (or HTML developer) must understand colors, the customer, product flow, page layout, browser compatibility, image creation, JavaScript, and more. Putting a great looking site together takes a lot of work, and most Java developers are more interested in creating agreat looking object interface than a user interface. Java Server Pages (JSP) technology provides the glue between the page designer and the Java developer.If you have worked on a large-scale Web application, you understand the term change.Model-View-Controller (MVC) is a design pattern put together to help control change. MVC decouples interface from business logic and data. Struts is an MVC implementation that uses Servlets 2.2 and JSP 1.1 tags, from the J2EE specifications, as part of the implementation. Y ou may never implement a system with Struts, but looking at Struts may give you some ideas on your future Servlets and JSP implementations.Model-View-Controller (MVC)JSP tags solved only part of our problem. We still have issues with validation, flow control, and updating the state of the application. This is where MVC comes to the rescue.MVC helps resolve some of the issues with the single module approach by dividing theproblem into three categories:• ModelThe model contains the core of the application's functionality. The model encapsulates thestate of the application. Sometimes the only functionality it contains is state. It knows nothing about the view or controller.• View• The view provides the presentation of the model. It is the look of the application. The view can access the model getters, but it has no knowledge of the setters. In addition, it knows nothing about the controller. The view should be notified when changes to the model occur. ControllerThe controller reacts to the user input. It creates and sets the model.MVC Model 2The Web brought some unique challenges to software developers, most notably the stateless connection between the client and the server. This stateless behavior made it difficult for the model to notify the view of changes. On the Web, the browser has to re-query the server to discover modification to the state of the application.Another noticeable change is that the view uses different technology for implementation than the model or controller. Of course, we could use Java (or PERL, C/C++ or what ever) code to generate HTML. There are several disadvantages to that approach:• Java programmers should develop services, not HTML.• Changes to layout would require changes to code.• Customers of the service should be able to create pages to meet their specific needs.• The page designer isn't able to have direct involvement in page development.• HTML embedded into code is ugly.For the Web, the classical form of MVC needed to change.MVC Model 2 Struts, an MVC 2 implementation Struts is a set of cooperating classes, servlets, and JSP tags that make up a reusable MVC 2 design. This definition implies that Struts is a framework, rather than a library, but Struts also contains an extensive tag library and utility classes that work independently of the framework.• Client browserAn HTTP request from the client browser creates an event. The Web container will respond with an HTTP response.• ControllerThe Controller receives the request from the browser, and makes the decision where to send the request. With Struts, the Controller is a command design pattern implemented as a servlet. The struts-config.xml file configures the Controller.• Business logicThe business logic updates the state of the model and helps control the flow of the application.With Struts this is done with an Action class as a thin wrapper to the actual business logic.• Model stateThe model represents the state of the application. The business objects update the application state. ActionForm bean represents the Model state at a session or request level, and not at a persistent level. The JSP file reads information from the ActionForm bean using JSP tags.• ViewThe view is simply a JSP file. There is no flow logic, no business logic, and no model information -- just tags. Tags are one of the things that make Struts unique compared to other frameworks like V elocity.Struts detailsDisplayed in Figure 6 is a stripped-down UML diagram of the org.apache.struts.action package and shows the minimal relationships among ActionServlet (Controller), ActionForm (Form State), and Action (Model Wrapper).The ActionServlet classDo you remember the days of function mappings? Y ou would map some input event to a ointer to a function. If you where slick, you would place the configuration information into ale and load the file at run time. Function pointer arrays were the good old days of structured rogramming in C.Life is better now that we have Java technology, XML, J2EE, and all that. The Struts ontroller is a servlet that maps events (an event generally being an HTTP post) to classes. guess what -- the Controller uses a configuration file so you don_t have to hard-code the alues. Life changes, but stays the same.ActionServlet is the Command part of the MVC implementation and is the core of the ramework. ActionServlet (Command) creates and uses Action, an ActionForm, and ctionForward. As mentioned earlier, the struts-config.xml file configures the command. uring the creation of the Web project, Action and ActionForm are extended to solve the pecific problem space. The file struts-config.xml instructs ActionServlet on how to use the xtended classes. There are several advantages to this approach:• The entire logical flow of the application is in a hierarchical text file. This makes itasier to view and understand, especially with large applications.• The page designer does not have to wade through Java code to understand the flow of e application.• The Java developer does not need to recompile code when making flow changes. Command functionality can be added by extending ActionServlet.The ActionForm classActionForm maintains the session state for the Web application. ActionForm is anbstract class that is sub-classed for each input form model. When I say input form model, Im saying ActionForm represents a general concept of data that is set or updated by a HTML form. For instance, you may have a UserActionForm that is set by an HTML Form. The Struts framework will:• Check to see if a UserActionForm exists; if not, it will create an instance of the class.• Struts will set the state of the UserActionForm using corresponding fields from the HttpServletRequest. No more dreadful request.getParameter() calls. For instance, the Struts framework will take fname from request stream and call UserActionForm.setFname().• The Struts framework updates the state of the UserActionForm before passing it to the business wrapper UserAction.• Before passing it to the Action class, Struts will also conduct form state validation by calling the validation() method on UserActionForm. Note: This is not always wise to do. There might be ways of using UserActionForm in other pages or business objects, where the validation might be different. V alidation of the state might be better in the UserAction class.• The UserActionForm can be maintained at a session level.Notes:• The struts-config.xml file controls which HTML form request maps to which ActionForm. • Multiple requests can be mapped UserActionForm.• UserActionForm can be mapped over multiple pages for things such as wizards.The Action classThe Action class is a wrapper around the business logic. The purpose of Action class is to translate the HttpServletRequest to the business logic. To use Action, subclass and overwrite the process() method.The ActionServlet (Command) passes the parameterized classes to ActionForm using the perform() method. Again, no more dreadful request.getParameter() calls. By the time the event gets here, the input form data (or HTML form data) has already been translated out of the request stream and into an ActionForm class.Note: "Think thin" when extending the Action class. The Action class should control the flow and not the logic of the application. By placing the business logic in a separate package or EJB, we allow flexibility and reuse.Another way of thinking about Action class is as the Adapter design pattern. The purpose of the Action is to "Convert the interface of a class into another interface the clients expect. Adapter lets classes work together that couldn_t otherwise because of incompatibility interface" (from Design Patterns - Elements of Reusable OO Software by Gof). The client in this instance is the ActionServlet that knows nothing about our specific business class interface. Therefore, Struts provides a business interface it does understand, Action. By extending the Action, we make our business interface compatible with Struts business interface. (An interesting observation is that Action is a class and not an interface. Action started as an interface and changed into a class over time. Nothing's perfect.)The Error classesThe UML diagram (Figure 6) also included ActionError and ActionErrors. ActionError encapsulates an individual error message. ActionErrors is a container of ActionError classes that the View can access using tags. ActionErrors is Struts way of keeping up with a list of errors.UML diagram of the relationship of the Command (ActionServlet) to the Model (Action) The ActionMapping classAn incoming event is normally in the form of an HTTP request, which the servlet Container turns into an HttpServletRequest. The Controller looks at the incoming event and dispatches the request to an Action class. The struts-config.xml determines what Action class the Controller calls. The struts-config.xml configuration information is translated into a set of ActionMapping, which are put into container of ActionMappings. (If you have not noticed it, classes that end with s are containers) The ActionMapping contains the knowledge of how a specific event maps to specific Actions. The ActionServlet (Command) passes the ActionMapping to the Action class via the perform() method. This allows Action to access the information to control flow.ActionMappingsActionMappings is a collection of ActionMapping objects.Struts pros Use of JSP tag mechanism The tag feature promotes reusable code and abstracts Java code from the JSP file. This feature allows nice integration into JSP-based development tools that allow authoring with tags.• Tag libraryWhy re-invent the wheel, or a tag library? If you cannot find something you need in the library, contribute. In addition, Struts provides a starting point if you are learning JSP tag technology.• Open sourceY ou have all the advantages of open source, such as being able to see the code and having everyone else using the library reviewing the code. Many eyes make for great code review.• Sample MVC implementationStruts offers some insight if you want to create your own MVC implementation.• Manage the problem spaceDivide and conquer is a nice way of solving the problem and making the problem manageable.中北大学2014届毕业设计英文文献译文Struts 一个开源的MVC实现作者：马尔科姆·戴维斯。
基于JSP的网上书店系统设计
基于JSP的网上书店系统设计随着互联网的普及和电子商务的发展，网上书店系统已成为人们购物生活中不可或缺的一部分。
使用Java Server Pages（JSP）技术，可以帮助开发人员快速创建动态的、交互式的Web应用程序。
本文将介绍如何设计一个基于JSP的网上书店系统。
在开始设计网上书店系统之前，我们需要对系统的需求进行详细的分析。
主要包括以下几个方面：用户注册与登录：允许用户注册账户并登录系统。
书籍浏览与搜索：展示所有书籍供用户浏览，并支持用户按照书名、作者、出版社等关键字搜索书籍。
购物车功能：允许用户将感兴趣的书籍加入购物车，并可以查看购物车中的书籍信息。
订单生成与支付：用户可以从购物车中删除书籍或者修改数量，最后生成订单并完成支付。
后台管理：管理员可以管理书籍信息、用户信息和订单信息等。
根据上述需求分析，我们可以将系统设计为以下几个模块：用户模块：包括用户注册、登录、浏览书籍、搜索书籍、添加书籍到购物车、删除书籍、修改数量、生成订单、支付等功能。
管理员模块：包括用户管理、书籍管理、订单管理等。
数据库模块：用于存储用户信息、书籍信息、订单信息等。
在JSP技术中，我们可以使用JavaBean组件来封装数据，使用Servlet 来处理业务逻辑，使用JSP页面来展示数据和交互。
数据库连接：使用Java数据库连接（JDBC）技术，与数据库建立连接，实现数据的增删改查操作。
JSP与Servlet交互：使用JSP页面接收用户输入，通过Servlet处理业务逻辑，并返回结果给JSP页面展示。
JavaBean组件：使用JavaBean组件封装数据，减少代码冗余，提高代码复用性。
HTML5与CSS3：使用HTML5和CSS3技术实现页面的布局和美化。
JavaScript与JSP交互：使用JavaScript技术实现页面的动态效果和交互效果，同时可以与JSP页面进行交互，实现前后台的交互。
支付接口：使用第三方支付接口实现支付功能，保证支付安全可靠。
基于JSP的在线书店销售系统的设计与实现外文文献及翻译
基于JSP的在线书店销售系统的设计与实现 - 外文文献及翻译文献来源本文献选自2019年IEEE会议论文集，作者为Qiuyue Luo、Liangye He。
原文题目为Design and Implementation of Online Bookstore Sales System based on JSP。
文献摘要随着网络技术的快速发展，越来越多的商业活动正在向线上迁移。
在线书店作为一个重要的商业模式之一，成为了一个备受关注的领域。
本文献介绍了一种基于JSP技术的在线书店销售系统的设计与实现。
该系统包括用户注册、书籍浏览、购物车、订单管理等功能模块。
通过对系统的详细设计，提高了系统的可靠性、安全性、稳定性和性能，从而为用户提供更好的在线购物体验。
文献翻译随着互联网技术的飞速发展，越来越多的商业活动正在向线上迁移。
在线书店成为了一个备受关注的领域。
为了更好地满足用户的需求，设计和实现一个高效可靠的在线书店销售系统显得尤为重要。
本文献介绍了一种基于JSP技术的在线书店销售系统的设计和实现。
该系统包括用户注册、书籍浏览、购物车、订单管理等功能模块。
通过本系统的详细设计，提高了系统的可靠性、安全性、稳定性和性能，为用户提供更好的在线购物体验。
具体来说，本系统的设计和实现主要包括以下方面：1.用户注册和登录功能：用户可以使用自己的账号和密码登录系统，也可以选择注册新的账号。
2.书籍浏览和搜索功能：用户可以浏览所有书籍的详细信息，并根据自己的需求进行搜索。
3.购物车功能：用户可以将自己喜欢的书籍添加到购物车中，并随时查看购物车中的商品数量和价格。
4.订单管理功能：用户可以查看自己的订单，并对订单进行管理和修改。
本系统采用了JSP技术和MySQL数据库，可以实现高效、可靠和安全的在线交易。
值得注意的是，为了提高系统的安全性和可靠性，我们采用了多个措施。
首先，用户的账号和密码将被加密保存，避免被不法之徒获取。
基于JSP网上书店系统的设计与实现
目录概要 (2)前言 (2)第1章概述 (3)1.1 开发背景.......................................................................................................................... 错误!未定义书签。
1.2 JAVA简介......................................................................................................................... 错误!未定义书签。
1.3 SQL简介 (3)第2章需求分析........................... 错误!未定义书签。
2.1 系统组成：...................................................................................................................... 错误!未定义书签。
2.2 系统要求配置.................................................................................................................. 错误!未定义书签。
第3章详细设计.. (8)3.1 数据库设计 (9)3.1.1 数据库需求分析 (9)3.1.2 数据库逻辑结构设计 (11)3.2 人机一体化设计 (13)3．2．1后台管理部分 (13)3．2．2前台部分 (13)第4章系统测试 (29)4.1 数据库连接 (29)4.2 检测网站运行速度 (29)第5章总结 (32)参考文献 (33)致谢 (34)概要随着Internet技术的发展，人们的日常生活已经离不开网络。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
毕业设计(论文) 外文文献翻译
专业
学生姓名
班级
学号
指导教师
外文资料名称：An Overview of Servlet
and JSP Technology 外文资料出处：Internet
附件： 1.外文资料翻译译文
2.外文原文
Servlet和JSP技术简述
Nagle and Wiegley
XX译
摘要：Servlet程序在服务器端运行，动态地生成Web页面与传统的CGI和许多其他类似CGI的技术相比，Java Servlet具有更高的效率，更容易使用，功能更强大，具有更好的可移植性，更节省投资。
关键字：JSP技术，Servlet，HTTP服务
1.1Servlet的功能
Servlets是运行在Web或应用服务器上的Java程序，它是一个中间层，负责连接来自Web浏览器或其他HTTP客户程序的请求和HTTP服务器上的数据库或应用程序。
Servlet的工作是执行西门的任务，如图1.1所示。
图1.1Web中间件的作用
（1）读取客户发送的显式数据。
最终用户一般在页面的HTML表单中输入这些数据。
然而，数据还有可能来自applet或定制的HTTP客户程序。
（2）读取由浏览器发送的隐式请求数据。
图1.1中显示了一条从客户端到Web服务器的单箭头，但实际上从客户端传送到Web服务器的数据有两种，它们分别为用户在表单中输入的显式数据，以及后台的HTTP信息。
两种数据都很重要。
HTTP信息包括cookie、浏览器所能识别的媒体类型和压缩模式等。
（3）生成结果。
这个过程可能需要访问数据库、执行RMI或EJB调用、调用Web服务，或者直接计算得出对应的响应。
实际的数据可能存储在关系型数据库中。
该数据库可能不理解HTTP，或者不能返回HTML形式的结果，所有Web浏览器不能直接与数据库进行会话。
即使它能够做到这一点，为了安全上的考虑，我们也不希望让它这么做。
对应大多数其他应用程序，也存在类似的问题。
因此，我们需要Web中间层从HTTP流中提取输
入数据，与应用程序会话，并将结果嵌入到文档中。
（4）向客户发送显式数据（即文档）。
这个文档可以用各种格式发送，包括文本（HTML或XML），二进制（GIF图），甚至可以式建立在其他底层格式之上的压缩格式，如gzip。
但是，到目前为止，HTML 式最常用的格式，故而servelt和JSP的重要任务之一就式将结果包装到HTML中。
（5）发送隐式的HTTP响应数据。
图1.1中显示了一条从Web中间层到客户端的单箭头。
但是，实际发送的数据有两种：文档本身，以及后台的HTTP信息。
同样，两种数据对开发来说都式至关重要的。
HTTP响应数据的发送过程涉及告知浏览器或其他客户程序所返回文档的类型（如HTML），设置cookie和缓存参数，以及其他类似的任务。
1.2动态构建网页的原因
预先建立的文档可以满足客户的许多请求，服务器无需调用servlet就可以处理这些请求。
然而，许多情况下静态的结果不能满足要求，我们需要针对每个请求生成一个页面。
实时构建页面的理由有很多种：
1、网页基于客户发送的数据。
例如，搜索引擎生成的页面，以及在线商店的订单确认页面，都要针对特定的用户请求而产生。
在没有读取到用户提交的数据之前，我们不知道应该显示什么。
要记住，用户提交两种类型的数据：显示（即HTML表单的数据）和隐式（即HTTP请求的报头）。
两种输入都可用来构建输出页面。
基于cookie值针对具体用户构建页面的情况尤其普遍。
2、页面由频繁改变的数据导出。
如果页面需要根据每个具体的请求做出相应的改变，当然需要在请求发生时构建响应。
但是，如果页面周期性地改变，我们可以用两种方式来处理它：周期性地在服务器上构建新的页面（和客户请求无关），或者仅仅在用户请求该页面时再构建。
具体应该采用哪种方式要根据具体情况而定，但后一种方式常常更为方便，因为它只需简单地等待用户的请求。
例如，天气预报或新闻网站可能会动态地构建页面，也有可能会返回之前构建的页面（如果它还是最新的话）。
3、页面中使用了来自公司数据库或其他数据库断数据源的信息。
如果数据存储在数据库中，那么，即使客户端使用动态Web内容，比如applet，。