Jsp最佳實踐外文翻譯@中英文翻譯@外文文獻翻譯

沈陽航空工業(yè)學院畢業(yè)設計（論文） 1 JSP best practices JavaServer Pages (JSPs) technology is an extension of Java servlet technology and combines HTML and Java code into a single file. While Java servlet technology focuses on Java classes capable of generating HTML output with PrintWriter.println() statements, JSP technology abstracts this concept to a higher level. With JavaServer Pages, a Web developer can write static HTML pages and simply add Java code in those sections of the page that need to be dynamically generated. While this flexibility enables rapid development of simple Web applications, it can be abused, resulting in unnecessarily complex applications that are difficult to maintain, reuse, and enhance. To avoid needlessly complex applications, follow the practices I present in this article: 1. Separate HTML from Java 2. Place business logic in JavaBeans 3. Factor general behavior out of custom tag handler classes 4. Favor HTML in Java handler classes over Java in JSPs 5. Use an appropriate inclusion mechanism 6. Use a JSP template mechanism 7. Use stylesheets 8. Use the MVC pattern 9. Use available custom tag libraries 10. Use JSP comments in most cases 11. Follow HTML best practices 12. Utilize the JSP exception mechanism These tips will help you write JSPs that are reusable and easy to maintain. (1)Separate HTML from Java It can be tempting to throw all Java and HTML code necessary for a Webpage into a single JSP file. In simple system development, such an approach makes it easy for someone new to the system to locate all relevant code in one place and understand how it 沈陽航空工業(yè)學院畢業(yè)設計（論文） 2 all interacts. However, this approach becomes burdensome and costly when the application grows more complex and more developers become involved. Combining HTML and Java in the same source code can make the code significantly less readable. To enhance software readability, developers often use indentation； but mixing HTML and Java scriptlets in the same file can make useful indentation extremely difficult to maintain. Many Web development methodologies and architectures now emphasize the separation of HTML from Java code so different developers can focus on their strengths. Properly separating Java and HTML, including HTML-like JSP tags and custom tags, allows Web designers and HTML coders to work on the HTML (presentation) aspects, while Java developers work on the application s Java (processing logic) portions. Java developers focus on business logic as they implement the behavior behind the custom tags； Web designers then use these custom tags just as they use ordinary HTML tags. (2)Place business logic in JavaBeans Java code included directly inside a JSP is not as readily accessible to other JSPs as Java code contained within a JavaBean. Common behavior and business logic placed in JavaBeans can not only be used by other JSPs but also by other portions of the application. That is because JavaBeans are merely Java classes that satisfy some basic conventions (such as a constructor with no arguments and public get/set methods for private data members) and can be used as any other Java class. Note that Enterprise JavaBeans (EJBs) are also useful for storing behaviors and data common to all components of the application. (3)Factor general behavior out of custom tag handler classes Java classes known as custom tag handlers implement custom tags. Unlike JavaBeans, custom tag handler classes are not readily used like ordinary Java utility classes. Instead, custom tag handler classes implement specific interfaces - or extend classes that provide these interfaces basic implementations. Because they are not readily reused outside JSPs, custom tag handlers should contain only specific behavior that would not be useful outside that custom tag - that is, outside the JSP. Custom tags often require support for common behaviors or business logic and can utilize JavaBeans or EJBs that perform those common behaviors. (4)Favor HTML in Java handler classes over Java in JSPs 沈陽航空工業(yè)學院畢業(yè)設計（論文） 3 Sometimes cleanly separating HTML, JSP tags, and HTML-like custom tags from Java requires unnecessarily convoluted code. In these cases, you either include Java scriptlets and expressions in the JSP or put some HTML code in the Java tag handler class. I d rather see a small amount of HTML code in the Java class than see Java, such as scriptlets and expressions, in the JSP. Since custom tag handlers are specific to the custom tags they implement (and not reusable outside JSPs), placing necessary HTML there is not troublesome. Sun s Java 2 Platform, Enterprise Edition (J2EE) Blueprints documentation discusses this issue further. (5)Use an appropriate inclusion mechanism It is rarely good design to reproduce code commonly used by different application pieces each time another piece of that application needs that functionality. Factoring common JSP or HTML code out of multiple pages and into a single file improves maintainability (you need to make changes in only one location) and reusability. Two JSP include mechanisms reduce code redundancy and promote reusability； to ensure that you use the appropriate include mechanism, it is important to know the differences between the two. Generally, I use the include directive unless I can justify a need for the include action. Question 7 in the Blueprints Web Tier section provides a good resource for understanding the differences between the two include mechanisms and determining which to use in a particular situation. (6)Use a JSP template mechanism A template mechanism allows for a common file to control Webpage, or JSP, layout. Then, when you want to change the layout, you need to modify only one file, and all the other pages will reflect the layout change. This doesn t just make for more maintainable code； using templates to control layout also makes Webpages more aesthetically pleasing to users who see consistent layouts for all an application s pages. (7)Use stylesheets Just as templates enable developers to place layout control in a single location, stylesheets enable developers to place appearance control in a single location. I use Cascading Style Sheets (CSS) to control such items as font families, font sizes, and table characteristics. Like templates, stylesheets allow the developer to make changes in one 沈陽航空工業(yè)學院畢業(yè)設計（論文） 4 location； those changes immediately reflect on all appropriate pages, resulting in increased maintainability and consistent appearance to users. (8)Use the MVC pattern While other design patterns can be used effectively with JSPs, I often use the Model-View-Controller (MVC) architecture with JSP technology. MVC enables the development of applications that are easier to create, test, maintain, and enhance. In JSP terminology, implementation of an MVC architecture is often referred to as Model 2 (from an early JSP specification). The J2EE Blueprints samples are based on MVC. (9)Use available custom tag libraries Why should developers spend time reinventing the wheel and worrying about testing and debugging when custom tag libraries are readily available for many different purposes? Some vendors provide custom tag libraries to their customers for free or for individual purchase, but many custom tags can be found online. Resources provides a good starting point for locating potentially useful tag libraries. While these third-party custom tag libraries occasionally have bugs, most likely such problems will be discovered, since many developers use these libraries and test them in their own applications. Also, many custom tags are open source, so you can edit them to meet your needs. I find it well worth my time to keep informed of available custom tags, since these libraries often provide functionality common to most Web applications. While learning about available custom tag libraries requires a small time investment, reusing already-available custom tags saves the time of writing, testing, and debugging my own custom tags. As mentioned above, many tag libraries are also open source； in these cases, I can readily adapt general behavior to my specific project s situation. (10)Use JSP comments in most cases Appropriate commenting seems to challenge software developers. JSPs, like other types of code, should include comments that describe complex or extraordinary functionality, the pages purpose, and other general information typically commented out in source code. Since JSPs allow developers to intermix Java, JSP tags, and HTML tags in the same page, there are multiple ways to comment a JSP page. Developers should carefully consider which type of comment to employ in the page. HTML comments will be 沈陽航空工業(yè)學院畢業(yè)設計（論文） 5 viewable in the compiled JSP s HTML source code, and both major browsers make viewing this source easy. JSP comments, on the other hand, are not placed in the HTML document created by the JSP compilation process. These comments cannot be viewed as part of the page s source through the browser, and they do not increase the size of the rendered page s generated source. Java comments can also occur in a JSP inside Java scriptlet sections. These are not viewable in the browser either, but including Java comments in the JSP page violates the principle of separating Java from the HTML. Code comments are usually meant for developers who write and maintain code. Therefore, use JSP comments unless there is a compelling reason to have the comments display in the browser upon request. (11)Follow HTML best practices When Java is factored out of the JSP and into JavaBeans and custom tag handlers, the JSP consists mostly of JSP tags, including custom tags, and HTML tags. To make the JSP easier to understand and maintain, follow best practices related to HTML development. (12)Utilize the JSP exception mechanism While a thrown exception s stack trace proves extremely useful for developers when debugging their code, it is rarely desirable to share an entire exception stack trace with the software s users. Lengthy stack traces are not aesthetically pleasing and can increase security risks by exposing information that does not need to be released. JSPs allow developers to catch and handle exceptions in the code, resulting in more secure and aesthetically pleasing exception handling. See Resources for details on the mechanics of JSP exception handling. Exception information is more useful if information besides the stack trace is included. JSPs can use session variables to store information about the current page and current operation being performed. Then, if an exception does occur, the exception page will be called； it will have access to both the thrown exception and the information about the original page that caused the exception. The exception page can utilize underlying Java code, in JavaBeans or EJBs, to store in the database the complete exception information, related session information, and the exception s date and time. To reduce the unsightly error messages printed to the screen and improve security, the exception page need only print out a simple error message and perhaps an identifying 沈陽航空工業(yè)學院畢業(yè)設計（論文） 6 number that allows developers to locate more detailed exception information in the database. For aesthetic and security reasons, I prefer storing most of the exception information in a database or flat file rather than printing it all to the screen. Storing the exception information in a database or flat file also allows the information to be persisted even when a user exits the application. Note that during development you should print full exception information to the screen for regular testing and debugging. 沈陽航空工業(yè)學院畢業(yè)設計（論文） 1 Jsp最佳實踐 Jsp 技術是 servlet 技術的擴展，結合 html、 java 代碼于一個文件。 Java servlet技術關注于利用 PrintWriter.println()語句產生 html 輸出的 java 類， Jsp 將這個概念抽象到一個更高的層次。使用 jsp， web 開發(fā)者可以寫靜態(tài)的 html 和將 java 代碼片段加入到需要動態(tài)產生的頁面中，從而，這 種靈活的技術使簡單 web 應用的快速開發(fā)成為可能。然而它能被濫用，從而形成難以維護、重用和改進的不必要的復雜的應用軟件。 遵循以下提示的技巧可以避免這種不必要的復雜應用。 1、 分離 html和 java 2、 將業(yè)務邏輯放在 javaBean 中 3、 從標簽定制管理器類中分離出常用行為 4、 較之 java 代碼在 jsps 中，更傾向于 html 在 java 管理器類中 5、 使用適當的包含機制 6、 使用 jsp 模版機制 7、 使用 CSS 樣式表 8、 使用 MVC 模式 9、 使用有效的標簽定制庫。 10、 盡可能多使用 jsp 注 釋 11、 遵循 html最佳實踐 12、 利用 jsp 異常機制 這些可幫助你寫出可重用、易維護的 jsp 一、分離 html和 java 將一個 web 頁的所有必須的 java、 html 代碼放入一個 jsp 文件中是誘人的。這種方法使初學者定位相關聯的代碼和理解它們如何相互作用變的容易。然而，當應用變的更加復雜、開發(fā)者變的更加棘手時，這樣方式將變的更加繁重和昂貴。 沈陽航空工業(yè)學院畢業(yè)設計（論文） 2 結合 html 和 java 在同一的代碼來源使程序變的非常不可讀。為增強可讀性，很多開發(fā)者使用縮排格式，但是混合 html 和 java 片段的文件使有益的縮排格式變的極其難 以維護。 許多 web 開發(fā)方法和機制強調 html 和 java 代碼的分離，從而不同的開發(fā)者可以將精力集中在他們擅長的方面。適當地將 java 代碼和包括 jsp 標簽、定制標簽在內的 html 分離，可以使 web 設計者、 html 編寫者工作在 html（表述）方面，而 java開發(fā)者工作在應用的邏輯處理部分。當 Java 開發(fā)者實現 jsp 定制標簽后的行為時關注的是業(yè)務邏輯， web 設計者則象使用普通 html 標簽一樣使用這些定制標簽。 二、將業(yè)務邏輯放在 JavaBean中 直接包含在 jsp中的 java代碼并不象包含在 JavaBean中的 java代碼那樣容易被其他 jsp 頁面理解，通用行為和業(yè)務邏輯放在 JavaBean 中不僅可以被其它 jsp，也可以被應用的其它部分使用，這是因為 JavaBean僅僅是滿足一些基本約定（比如不含參數的構造器，為 private 類屬性設置 set/get 方法）的 java 類，也能作為任意其它類使用。值得注意的是， ejb 在封裝針對應用中所有組件通用的行為和數據時也是有用的。 三、從標簽定制管理器類中分離出常用行為 作為定制標簽管理器類的 java 類實現定制標簽，并不象 JavaBean，它不能如普通 java 工具類一樣易于使用，而 是，定制標簽管理器類實現特定的接口或繼承提供這些接口基本實現的類。由于它們不易于在 jsp 外使用，定制標簽管理器類應當僅包含那些不能在定制標簽之外、 jsp 之外使用的特定行為。定制標簽常常需要針對通用行為和業(yè)務邏輯的支撐，并利用提供通用行為的 JavaBeans 和 EJBs 四、較之 java 代碼在 jsp 中，更傾向于 html 在 java 管理器類中 有時從 java 中分離 html、 jsp 標簽和如定制標簽的 html 會需要不必要的令人費解的代碼，基于此，你要么將 java 片段和表述放入 jsp 中，要么將 html 代碼放入 java標簽 管理器類。 較之看到在 jsp 中作為腳本的 java，我更愿意看到在 java 類中的一小部分 html代碼。由于定制標簽管理器針對它們所實現的定制標簽是特定的（同時也不能在 jsp之外使用），放入一些 html 代碼不會有什么麻煩， SUN 的 J2EE藍皮書對此有更深入的討論。 沈陽航空工業(yè)學院畢業(yè)設計（論文） 3 對此標準也有例外：如果在 jsp 中包含一行或兩行 java 代碼片段和在 java 管理器類中包含許多行 html 代碼解決的問題一樣，那么允許在 jsp 中存在 java 代碼應該是明智的。 五、使用適當的包含機制 包含機制在代碼重用方面是少有的好的設計。從多個頁面中分 離出通用的 jsp和 html代碼放入一個文件可以提高可維護性（僅需要在一處改變）和可重用性。 有兩種包含機制縮小了代碼冗余促進了代碼重用。為確保能夠使用適當的包含機制，理解它們二者間的不同是重要的。除非我可以證明需要 include 動作是正當的，一般地情況下我使用 include 指令。在藍皮書“ web 層”部分中的第七個問題，對理解兩種包含機制的不同和確定在一特定情況使用哪一種提供了很好的資源。 六、使用 jsp 模版機制 一個模版機制允許一個公用的文件來控制 web 頁、 jsp、頁面布局。于是，當你想改變頁面布局時， 你僅僅需要修改一個文件，所有其它的頁面將反映出頁面布局的改變。這不僅是使代碼更加具有可維護性，頁面布局模版機制對那些看到所有應用軟件頁面都協(xié)調一致的用戶來說，使 web 頁面顯得更加美觀和友好。 七、使用 CSS 樣式表 正如模版可以使開發(fā)者將頁面布局控制放于一處，樣式表可以使開發(fā)者將外觀控制放于一處。我使用 CSS 樣式表來控制諸如字體格式、尺寸，表特征等項目。象模版一樣，樣式表允許開發(fā)者在一處改變，這些改變會立刻映射到所有外觀頁面，從而促進可維護性和給用戶一致的外觀。 八、使用 MVC 設計模式 當然、其它設計模式可以 在 jsp 中有效的使用，而我經常使用模型 ?視圖 ?