Book•
Java Servlet Programming
01 Jan 1998-
TL;DR: The book explains the servlet life cycle, showing how you can use servlets to maintain state information effortlessly and describes how to serve dynamic Web content, including both HTML pages and multimedia data.
Abstract: From the Publisher:
A few years ago, the hype surrounding applets put Java on the map as a programming language for the Web. Today, Java servlets stand poised to take Java to the next level as a Web development language. The main reason is that servlets offer a fast, powerful, portable replacement for CGI scripts.
The Java Servlet API, introduced as the first standard extension to Java, provides a generic mechanism to extend the functionality of any kind of server. Servlets are most commonly used, however, to extend Web servers, performing tasks traditionally handled by CGI programs. Web servers that can support servlets include: Apache, Netscape's FastTrack and Enterprise Servers, Microsoft's IIS, O'Reilly's WebSite, and JavaSoft's Java Web Server.
The beauty of servlets is that they execute within the Web server's process space and they persist between invocations. This gives servlets tremendous performance benefits over CGI programs. Yet because they're written in Java, servlets are far less likely to crash a Web server than a C-based NSAPI or ISAPI extension. Servlets have full access to the various Java APIs and to third-party component classes, making them ideal for use in communicating with applets, databases, and RMI servers. Plus, servlets are portable between operating systems and between servers -- with servlets you can "write once, serve everywhere."
Java Servlet Programming covers everything you need to know to write effective servlets and includes numerous examples that you can use as the basis for your own servlets. The book explains the servlet life cycle, showing how you can use servlets to maintain state information effortlessly. It also describes how to serve dynamic Web content, including both HTML pages and multimedia data. Finally, it explores more advanced topics like integrated session tracking, efficient database connectivity using JDBC, applet-servlet communication, inter-servlet communication, and internationalization.
Citations
More filters
07 Dec 2000
TL;DR: The HP Labs' “Cooltown” project has been exploring opportunities through an infrastructure to support “web presence” for people, places and things, providing a model for supporting nomadic users without a central control point.
Abstract: The convergence of Web technology, wireless networks, and portable client devices provides new design opportunities for computer/communications systems. In the HP Labs' Cooltown project we have been exploring these opportunities through an infrastructure to support Web presence for people, places and things. We put Web servers into things like printers and put information into Web servers about things like artwork; we group physically related things into places embodied in Web servers. Using URLs for addressing, physical URL beaconing and sensing of URLs for discovery, and localized Web servers for directories, we can create a location-aware but ubiquitous system to support nomadic users. On top of this infrastructure we can leverage Internet connectivity to support communications services. Web presence bridges the World Wide Web and the physical world we inhabit, providing a model for supporting nomadic users without a central control point.
711 citations
Cites methods from "Java Servlet Programming"
...A ChaiServer executes objects called chailets, which are similar to servlets (see for example [ 26 ])....
[...]
TL;DR: This work presents several instances of this schema that combine (both syntactically and semantically) different UML modeling languages with a security modeling language for formalizing access control requirements, and generates access control infrastructures for server-based applications built from declarative and programmatic access control mechanisms.
Abstract: We present a new approach to building secure systems. In our approach, which we call Model Driven Security, designers specify system models along with their security requirements and use tools to automatically generate system architectures from the models, including complete, configured access control infrastructures. Rather than fixing one particular modeling language for this process, we propose a general schema for constructing such languages that combines languages for modeling systems with languages for modeling security. We present several instances of this schema that combine (both syntactically and semantically) different UML modeling languages with a security modeling language for formalizing access control requirements. From models in the combined languages, we automatically generate access control infrastructures for server-based applications, built from declarative and programmatic access control mechanisms. The modeling languages and generation process are semantically well-founded and are based on an extension of Role-Based Access Control. We have implemented this approach in a UML-based CASE-tool and report on experiments.
515 citations
Cites methods from "Java Servlet Programming"
...The Java Servlet Specification [15] defines an execution environment for web components implemented in Java....
[...]
...The Java Servlet Speci.cation [Hunter 2001] speci.es an execution environment for web components, called servlets....
[...]
04 Nov 2002
TL;DR: This paper reports the experience of using AspectJ, a general-purpose aspect-oriented extension to Java, to implement distribution and persistence aspects in a web-based information system and proposes architecture-specific guidelines that provide practical advice for both restructuring and implementing certain kinds of persistent and distributed applications with Aspect
Abstract: This paper reports our experience using AspectJ, a general-purpose aspect-oriented extension to Java, to implement distribution and persistence aspects in a web-based information system This system was originally implemented in Java and restructured with AspectJ Our main contribution is to show that AspectJ is useful for implementing several persistence and distribution concerns in the application considered, and other similar applications We have also identified a few drawbacks in the language and suggest some minor modifications that could significantly improve similar implementations Despite the drawbacks, we argue that the AspectJ implementation is superior to the pure Java implementation Some of the aspects implemented in our experiment are abstract and constitute a simple aspect framework The other aspects are application specific but we suggest that different implementations might follow the same aspect pattern The framework and the pattern allow us to propose architecture-specific guidelines that provide practical advice for both restructuring and implementing certain kinds of persistent and distributed applications with AspectJ
308 citations
30 Jul 2007
TL;DR: A quantitative case study that evolves a real-life application to assess various facets of design stability of OO and AO implementations and includes an analysis of the application in terms of modularity, change propagation, concern interaction, identification of ripple-effects and adherence to well-known design principles.
Abstract: Although one of the main promises of aspect-oriented (AO) programming techniques is to promote better software changeability than objectoriented (OO) techniques, there is no empirical evidence on their efficacy to prolong design stability in realistic development scenarios. For instance, no investigation has been performed on the effectiveness of AO decompositions to sustain overall system modularity and minimize manifestation of ripple-effects in the presence of heterogeneous changes. This paper reports a quantitative case study that evolves a real-life application to assess various facets of design stability of OO and AO implementations. Our evaluation focused upon a number of system changes that are typically performed during software maintenance tasks. They ranged from successive re-factorings to more broadly-scoped software increments relative to both crosscutting and non-crosscutting concerns. The study included an analysis of the application in terms of modularity, change propagation, concern interaction, identification of ripple-effects and adherence to well-known design principles.
198 citations
Cites methods from "Java Servlet Programming"
...In the HW system, complaints are registered, updated and queried through a Web client implemented using Java Servlets [ 22 ], represented by the components in the view layer....
[...]
Patent•
28 Feb 2003
TL;DR: In this article, a web service user interface can be automatically generated, thus simplifying development of web applications, and configuration data can be received and proxies to access the web service can be used to facilitate communicate with said web service using the proxies.
Abstract: A web service user interface can be automatically generated, thus simplifying development of web applications. Web service configuration data can be received and proxies to access the web service can be automatically generated. Communication code can also be automatically generated to facilitate communicate with said web service using the proxies. Display code can be automatically generated to display content provided by a web service. In one example, the web service user interface is a portlet.
96 citations