Enterprise Collaboration Tool Analysis
Disclaimer: This dissertation has been submitted by a student. This is not an example of the work written by our professional dissertation writers. You can view samples of our professional work here.
Any opinions, findings, conclusions or recommendations expressed in this material are those of the authors and do not necessarily reflect the views of UK Essays.
Enterprise Collaboration Tool is rethinking how technology can help companies manage customer relationships. ECT, the market leading CRM application, delivers a feature-rich set of business processes that enhance marketing effectiveness, drive sales performance, improve customer satisfaction and provide executive insight into business performance. Supported by deep collaboration and administration capabilities that adapt to how your company operates, ECT is delighting customers of all sizes across a broad range of industries.
Enterprise Collaboration Tool is a powerful modular Internet/Intranet application framework. It features a scheduler, Meetings, Messaging, address book, file upload and download and feedback. Everything is designed to collaborate online.
Effective planning and scheduling of time bound work and monitoring the work done by the employee's and effective use of online system to communicate and collaborate with the members of other centers of a decentralized organization.
System with adaptability to any organization to monitor the work done by people with respect to time and also assigning work.
- Captures daily work done by employees
- Provides communication module.
- Summary reports on work done by employees.
- Attendance report based on the entered work details.
- Online work log entry and work assignment.
- Address book to store the contact numbers and personal info
- Scheduler to keep mark notes on a particular day.
- Feedback, which ensures the management to look up the comments by the employee.
- Uploading and downloading facility
- Information about all the existing branches of the organization.
- The newsletters regarding the day-to-day affairs of the organization.
The proposed Enterprise Collaboration Tool consists of a login screen from which the users and administrator could logon in to the system. In this System, the users are given different roles. Each role is associated with some services. The various roles are administrator & employee, programmers etc. Admin is the head of all branches and is responsible for user management and branch administration.
The Enterprise Collaboration Tool process starts with the creation of users and mapping their roles from the administrator login. The system will maintain the check-in time and checkout time daily and will allow the users to enter their worklog daily and has a provision to enter the yesterday's worklog details also (exemption given to enter backlogs of previous day).
Verza Soft is quickly emerging as an innovative and essential business software applications development resource. Since 1985, Verza Soft has provided custom design, implementation and support solutions to a variety of information management industries and business environments. Experienced and intuitive, the professionals at Verza Soft understand how fast technologies change and we remain committed to solving the unique information management application challenges of today's business world while developing and evolving strategies for tomorrows.
With over twenty combined years of professional software development experience, the principals at Verza Soft are business applications authorities. As specialists, we've learned to anticipate individual client application needs and design software suites to complement virtually every hardware technology. We offer 24-hour customer service and employ a qualified team of trainers, technicians and creative designers who assist in developing the comprehensive, user-friendly software programs that distinguish Verza Soft as the perfect answer to the often puzzling questions inherent in contemporary information management technologies.
We've been working on an offshore development model from day 1 and have perfected the process of onsite-offshore interaction over the past seven years. Our services are highly cost effective enabling our clients to get the best value for their money
Working primarily within Sun family of productsto combine expert use of hardware technology and state-of-the-art software, Verza Soft is "ware" it's at! From software programming and applications development including custom Internet integration to system architecture and technical design, through continuous support solutions, Verza Soft pieces together today's information management puzzle to create optimal, full integrated, interactive packages that best meet global business demands.
Working one-on-one, we can develop innovative applications that not only satisfy your specific business requirements, but also complement your company's investment in essential information management technologies. We're dedicated to making you look good custom design "ware" by Verza Soft it's the solution that fits!
Verza Soft understands the significance of a good quality assurance (QA) process for creating world-class products. With hundreds of person-years of experience in the field of testing, it has expertise in the development and execution of tests for applications in the client/server, internet/web and the mobile space, using both automated and manual methodologies. Functional testing verifies whether a product/application performs as per specifications
Here the existing system is nothing but a manual system using which the administrator task from the main branch becomes more complex to prepare schedules for all the employees working in different branches and sent them manually and tracking their status. Generating the different reports by co-relating different things is a tedious process.
In this system the sub center individually manually maintains their database regarding employees daily work log, scheduled work, progress of work, attendance, leaves, payments etc.. and sends reports to the main centre through email attachments or by post.
Unless and until the main centre manager receives reports from sub centers, he is unable to take decisions regarding employees and their salary, promotions, meetings, daily schedules, scheduled projects, customer details etc.
- Doesn't provide effective co-ordination between different branches
- Doesn't provide role based security for the data
- Generating different kinds of reports becomes more complex
- Doesn't provide effective communication for our employees with in the company
- Doesn't allow the administrator to monitor overall activities of the company.
These drawbacks of the existing system leads to the present web based application called Enterprise Collaboration Tool. There by the management is now relieved from all tensions from which they faced previously.
The proposed system is a software solution for the existing system. It is a powerful modular Internet/Intranet application framework which provides good co-ordination between our branches and allows the administrator to effectively track activities of the company. It features a scheduler, Worklog, Meetings, Messaging, address book, file upload and download and feedback. Everything is designed to collaborate online.
- Provides effective co-ordination between different branches regarding work schedules through scheduler and worklog facilities.
- Improves the quality in planning and managing works
- Generating different reports will be very easy
- Provides a facility for the administrator to track overall activities of the company
- Provides good communication channel for the employees to interact with in the company
- Provides upload and download facilities to share the documents
- Provides a facility to collect the feedback from the employees
- Provides a facility for the employees to maintain the contacts in their address book.
Feasibility steady is an important phase in the software development process. It enables the developer to have an assessment of the product being developed. It refers to the feasibility study of the product in terms of out comes of the product, operational use and technical support required for implementing it.
Feasibility study should be performed on the basis of various criteria and parameters. The various feasibility studies are:
- Economic Feasibility
- Operational Feasibility
- Technical Feasibility
It refers to the benefits or outcomes we are deriving from the product as compared to the total cost we are spending for developing the product. If the benefits are more or less the same as the older system, then it is not feasible to develop the product. In this product if we have developed this application then the amount of time spent in preparing the schedules, sending it different branches and monitor the work will be reduced which indirectly increases the production for the company.
It refers to the feasibility of the product to be operational. Some products may work very well at design and implementation but may fail in the real time environment. It includes the study of additional human resource required and their technical expertise. This application will also work in any environment with out any problems since we are implementing this project in java language.
It refers to whether the software that is available in the market fully supports the present application. It studies the pros and cons of using a particular software for the development and its feasibility. It also studies the additional training needed to be given to the people to make the application work. For this project we need not recruit any additional staff to make use of this application. If we train our staff for one hour then it will be enough to work with application. Since this application uses the softwares which are already used by the company so that the company need not purchase new software to run this project.
Software and Hardware Requirements:
Pentium IV processes architecture
1. 512 MB RAM.
2. 160 GB Hard Disk Space.
3. Ethernet card.
Database : Oracle 10g XE
Web Server : Apache Tomcat 5.0
Front end : JSP / Servlets, J2SDK 1.5, HTML, Java Script
Functional Requirements & Non Functional Requirements:
The main purpose of functional requirements within the requirement specification document is to define all the activities or operations that take place in the system. These are derived through interactions with the users of the system. Since the Requirements Specification is a comprehensive document & contains a lot of data, it has been broken down into different Chapters in this report.
But the general Functional Requirements arrived at the end of the interaction with the Users are listed below. A more detailed discussion is presented in the Chapters, which talk about the Analysis & Design of the system.
- The system holds the details of the employees and their braches.
- It holds the schedules of different employees of the company.
- It holds the details of all works done by the employees.
- The system allows the administrator to manage different users.
- It also allows the administrator to prepare the schedules and assigns them to different employees.
- It allows the administrator to post the meeting details which will be displayed for all the employees.
- It allows the employees to store the customer contacts in their address book.
- It allows the administrator and employees to share the documents using upload and download facilities.
- It allows the employees to post their feedback
- It allows the administrator to view customer feedbacks.
- It allows the administrator to broadcast the news information
- It allows the employees to send a message to other employees or a group of employees at once.
- It allows the administrator to view work pending report
The non-functional requirements consist of
These are the requirements that are not directly related to the functionality of the system. These should be considered as mandatory when the system is developed. The following Constraints were arrived at for the system:
- The system should be available over the intranet so that the Users like the administrator & employees can use the system from their respective locations which could be with in the company.
- For gaining entry into the system the employees should be registered by the administrator and should be able use login & passwords for gaining access to the system.
- The users should be able to change their passwords for increased security.
- The system should be easy to understand and organized in a structured way. The users should also receive appropriate messages about any errors that occur.
- There should be no limitation about the hardware platform that is to be used to run the system.
- Data integrity should be maintained if an error occurs or the whole system comes down.
We have discussed mandatory requirements in the previous section. The requirements in this section should be taken as suggestions & they should be thought of as recommendations to further enhance the usability of the system.
- The system should display a menu for users to choose from.
- The system should display users' requests in a reasonable time.
- Services of the system should be available 24 hours a day.
- The system should be designed in such a way that it is easy to enhance it with more functionality. It should be scalable & easily maintainable.
The different phases of the implementation of the project here is
Phase 1 - Business Process & Requirements analysis
Phase 2 - System Requirements Specifications
Phase 3 - Design and Development
Phase 4 - Testing & Debugging
Phase 5 - Implementation
Phase 1 - Business Process & Requirements analysis
Business Process & Requirements analysis is the phase when the relevant business area is studied in detail. This process brings out the gaps between the existing systems and identifies the areas where the business operations should be modified, keeping in view the way it needs to be carried out to encounter the problems during this phase the required documents are prepared defining the existing and required setup for the project
Phase 2 - System Requirements Specifications
The information about the requirements is collected which contains the information about the current user system and the proposed system as seen from the user perspective. At the end of this phase a detailed requirement specification document is prepared and approved.
Phase 3 - Design and Development
In this phase the framework for the design of the proposed product is designed to meet the requirements specifications documented.
The product is developed as per the framework to meet the objectives of the system requirement specifications approved.
Phase 4 - Testing & Debugging
This phase contains the preparation of test cases and the standards of testing. The end users using the dummy User Ids carry out the testing.
Phase 5 - Implementation
The project enters the implementation phase when the product is ready to be implemented/piloted on the production environment and after thorough training to all the end users the product is implemented
The estimated time lines for completing the implementation of the application identified and its approach is enumerated as below
Duration in weeks
1 - Business Process & Req.Analysis
2 - System Requirements Specifications
3 - Design and Development
4 - Testing & Debugging
5 - Implementation
Dubious use of the System
If the user is deliberately going to handle the system improperly, like he can enter incorrect time/out or he may submit wrong worklog or feedback. The System is to be further developed to countercheck the employee's entries with that of the local authorities.
Design for WebApps encompasses technical and non-technical activities. The look and feel of content is developed as part of graphic design; the aesthetic layout of the user interface is created as part of interface design; and the technical structure of the WebApp is modeled as part of architectural and navigational design.
Dix argues that a Web engineer must design an interface so that it answers three primary questions for the end-user;
- Where am I? - The interface should (1) provide an indication of the WebApp has been accessed and (2) inform the user of her location in the content.
- What can I do now? - The interface should always help the user understand his current options- what functions are available, what links are live, what content is relevant.
- Where have I been; where am I going? - The interface must facilitate navigation. Hence it must provide a “map” of where the user has been and what paths may be taken to move else where in the WebApp.
Design goals- the following are the design goals that are applicable to virtually every WebApp regardless of application domain, size, or complexity.
- Visual appeal
Design leads to a model that contains the appropriate mix of aesthetics, content, and technology. The mix will vary depending upon the nature of the WebApp, and as a consequence the design activities that are emphasized will also vary.
The activities of the Design process;
1. Interface design-describes the structure and organization of the user interface. Includes a representation of screen layout, a definition of the modes of interaction, and a description of navigation mechanisms.
Interface Control mechanisms- to implement navigation options, the designer selects form one of a number of interaction mechanism;
a. Navigation menus
b. Graphic icons
c. Graphic images
Interface Design work flow- the work flow begins with the identification of user, task, and environmental requirements. Once user tasks have been identified, user scenarios are created and analyzed to define a set of interface objects and actions.
2. Aesthetic design-also called graphic design, describes the “look and feel” of the WebApp. Includes color schemes, geometric layout. Text size, font and placement, the use of graphics, and related aesthetic decisions.
3. Content design-defines the layout, structure, and outline for all content that is presented as part of the WebApp. Establishes the relationships between content objects.
4. Navigation design-represents the navigational flow between contents objects and for all WebApp functions.
5. Architecture design-identifies the overall hypermedia structure for the WebApp. Architecture design is tied to the goals establish for a WebApp, the content to be presented, the users who will visit, and the navigation philosophy that has been established.
a. Content architecture, focuses on the manner in which content objects and structured for presentation and navigation.
b. WebApp architecture, addresses the manner in which the application is structure to manage user interaction, handle internal processing tasks, effect navigation, and present content. WebApp architecture is defined within the context of the development environment in which the application is to be implemented.
J2EE uses MVC architecture;
6. Component design-develops the detailed processing logic required to implement functional components.
Scheduler & Work Log Module:
User Management & Branch Management Module:
Communication Module (Messages, Meetings, Notices Module & News):
Address Book & Feedback Module:
Scheduler & Work Log Module:
This module helps in preparing the work schedules and monitors work simply by sitting at the main branch. It provides user friendly screens which include calendars to select the date. Once the administrator has added the work to the schedule then it will displayed to all the employees in all the branches. It will be easy for an employee now to know his work schedule, complete it and intimate it to the administrator by entering the work details in the work log so that the administrator can monitor easily.
User Management & Branch Management Module:
This module helps the administrator to add new branch details to the database, edit the existing branch details and delete the branch. It also provides a facility to the administrator to add the employee details and create the logins for the required employees, edit the user details and the delete the user information from the database.
Communication Module (Messages, Meetings, Notices Module & News):
This module provides a facility to the employees to communicate each other very easily by sending the messaged in this application. The messages provides options to send a message to another employee, view the message list, open a message a message, delete a message and send a message to all the employees in a group at a time.
This module provides a facility to the employees to know the details of the meetings which are going to be conducted just by clicking view meeting details option in meetings link. The users can also post the meetings details at any point of time.
This module provides a facility to the employees to send the notices prepared by one branch to another branch then these people can upload the notice document and that will be downloaded by another branch people. It is just like sharing the documents across the branches.
This module helps the administrator to post the news details which will be displayed to all the users when ever they logged in.
Address Book & Feedback Module:
This module provides a facility to the employees to store their individual contact details in the address book. It allows us to add, edit and delete the contact details in the address book.
This module helps the users to post their feedback about a policy which was implemented by company from online and allows the administrator to view the feedbacks posted by all the employees.
This module allows the administrator to view different kinds of reports according to his requirement. It generates the reports based on employees, employee work report, groups reports and employee report.
Data Modeling Overview
A data model is a conceptual representation of the data structures that are required by a database. The data structures include the data objects, the associations between data objects, and the rules which govern operations on the objects. As the name implies, the data model focuses on what data is required and how it should be organized rather than what operations will be performed on the data. To use a common analogy, the data model is equivalent to an architect's building plans.
A data model is independent of hardware or software constraints. Rather than try to represent the data, as a database would see it, the data model focuses on representing the data as the user sees it in the "real world". It serves as a bridge between the concepts that make up real-world events and processes and the physical representation of those concepts in a database.
There are two major methodologies used to create a data model: the Entity-Relationship (ER) approach and the Object Model.
Data Modeling In the Context of Database Design
Database design is defined as: "design the logical and physical structure of one or more databases to accommodate the information needs of the users in an organization for a defined set of applications". The design process roughly follows five steps:
- planning and analysis
- conceptual design
- Logical design
- Physical design
The data model is one part of the conceptual design process. The other, typically is the functional model. The data model focuses on what data should be stored in the database while the functional model deals with how the data is processed. To put this in the context of the relational database, the data model is used to design the relational tables. The functional model is used to design the queries, which will access and perform operations on those tables.
Components of a Data Model
The data model gets its inputs from the planning and analysis stage. Here the modeler, along with analysts, collects information about the requirements of the database by reviewing existing documentation and interviewing end-users. The data model has two outputs. The first is an entity-relationship diagram which represents the data structures in a pictorial form. Because the diagram is easily learned, it is valuable tool to communicate the model to the end-user. The second component is a data document. This is a document that describes in detail the data objects, relationships, and rules required by the database. The dictionary provides the detail required by the database developer to construct the physical database.
Why is Data Modeling Important?
Data modeling is probably the most labor intensive and time consuming part of the development process. Why bother especially if you are pressed for time? A common response by practitioners who write on the subject is that you should no more build a database without a model than you should build a house without blueprints.
The goal of the data model is to make sure that the all data objects required by the database are completely and accurately represented. Because the data model uses easily understood notations and natural language, it can be reviewed and verified as correct by the end-users.
The data model is also detailed enough to be used by the database developers to use as a "blueprint" for building the physical database. The information contained in the data model will be used to define the relational tables, primary and foreign keys, stored procedures, and triggers. A poorly designed database will require more time in the long-term. Without careful planning you may create a database that omits data required to create critical reports, produces results that are incorrect or inconsistent, and is unable to accommodate changes in the user's requirements.
A data model is a plan for building a database. To be effective, it must be simple enough to communicate to the end user the data structure required by the database yet detailed enough for the database design to use to create the physical structure.
1) Table Name: LOGIN_TWM
2) Table Name: LOGINOUT_TWM
3) Table Name: MESSAGES_TWM
4) Table Name: GROUPS_TWM
5) Table Name: GROUPUSERS_TWM
6) Table Name: MEETINGS_TWM
7) Table Name: SCHEDULAR_TWM
8) Table Name: ADDRESSBOOK_TWM
9) Table Name: WORKLOG_TWM
10) Table Name: FEEDBACK_TWM
11) Table Name: NEWS_TWM
12) Table Name: NOTICEBOARD_TWM
13) Table Name: DOWNLOAD_TWM
14) Table Name: BRANCH_TWM
HTML, an initialism of Hypertext Markup Language, is the predominant markup language for web pages. It provides a means to describe the structure of text-based information in a document — by denoting certain text as headings, paragraphs, lists, and so on — and to supplement that text with interactive forms, embedded images, and other objects. HTML is written in the form of labels (known as tags), surrounded by angle brackets. HTML can also describe, to some degree, the appearance and semantics of a document, and can include embedded scripting language code which can affect the behavior of web browsers and other HTML processors.
HTML is also often used to refer to content of the MIME type text/html or even more broadly as a generic term for HTML whether in its XML-descended form (such as XHTML 1.0 and later) or its form descended directly from SGML
Hypertext Markup Language (HTML), the languages of the World Wide Web (WWW), allows users to produces Web pages that include text, graphics and pointer to other Web pages (Hyperlinks).
HTML is not a programming language but it is an application of ISO Standard 8879, SGML (Standard Generalized Markup Language), but specialized to hypertext and adapted to the Web. The idea behind Hypertext is that instead of reading text in rigid linear structure, we can easily jump from one point to another point. We can navigate through the information based on our interest and preference. A markup language is simply a series of elements, each delimited with special characters that define how text or other items enclosed within the elements should be displayed. Hyperlinks are underlined or emphasized works that load to other documents or some portions of the same document.
HTML can be used to display any type of document on the host computer, which can be geographically at a different location. It is a versatile language and can be used on any platform or desktop.
HTML provides tags (special codes) to make the document look attractive. HTML tags are not case-sensitive. Using graphics, fonts, different sizes, color, etc., can enhance the presentation of the document. Anything that is not a tag is part of the document itself.
Basic HTML Tags:
<! -- --> specifies comments
<A>……….</A> Creates hypertext links
<B>……….</B> Formats text as bold
<BIG>……….</BIG> Formats text in large font.
<BODY>…</BODY> Contains all tags and text in the HTML document
<CENTER>...</CENTER> Creates text
<DD>…</DD> Definition of a term
<DL>...</DL> Creates definition list
<FONT>…</FONT> Formats text with a particular font
<FORM>...</FORM> Encloses a fill-out form
<FRAME>...</FRAME> Defines a particular frame in a set of frames
<H#>…</H#> Creates headings of different levels ( 1 - 6 )
<HEAD>...</HEAD> Contains tags that specify information about a document
<HR>...</HR> Creates a horizontal rule
<HTML>…</HTML> Contains all other HTML tags
<META>...</META> Provides meta-information about a document
<SCRIPT>…</SCRIPT> Contains client-side or server-side script
<TABLE>…</TABLE> Creates a table
<TD>…</TD> Indicates table data in a table
<TR>…</TR> Designates a table row
<TH>…</TH> Creates a heading in a table
The attributes of an element are name-value pairs, separated by "=", and written within the start label of an element, after the element's name. The value should be enclosed in single or double quotes, although values consisting of certain characters can be left unquoted in HTML (but not XHTML).Leaving attribute values unquoted is considered unsafe.
Most elements take any of several common attributes: id, class, style and title. Most also take language-related attributes: lang and dir.
The id attribute provides a document-wide unique identifier for an element. This can be used by stylesheets to provide presentational properties, by browsers to focus attention on the specific element or by scripts to alter the contents or presentation of an element. The class attribute provides a way of classifying similar elements for presentation purposes. For example, an HTML document (or a set of documents) may use the designation class="notation" to indicate that all elements with this class value are all subordinate to the main text of the document (or documents). Such notation classes of elements might be gathered together and presented as footnotes on a page, rather than appearing in the place where they appear in the source HTML.
An author may use the style non-attributal codes presentational properties to a particular element. It is considered better practice to use an element's son- id page and select the element with a style sheet, though sometimes this can be too cumbersome for a simple ad hoc application of styled properties. The title is used to attach sub textual explanation to an element. In most browsers this title attribute is displayed as what is often referred to as a tool tip. The generic inline span element can be used to demonstrate these various non-attributes.
The preceding displays as HTML (pointing the cursor at the abbreviation should display the title text in most browsers).
- A HTML document is small and hence easy to send over the net.
- It is small because it does not include formatted information.
- HTML is platform independent.
- HTML tags are not case-sensitive.
- Validate the contents of a form and make calculations.
- Add scrolling or changing messages to the Browser's status line.
- Animate images or rotate images that change when we move the mouse over them.
- Detect the browser in use and display different content for different browsers.
- Detect installed plug-ins and notify the user if a plug-in is required.
- It is more flexible than VBScript.
Initially the language was called as “oak” but it was renamed as “Java” in 1995. The primary motivation of this language was the need for a platform-independent (i.e., architecture neutral) language that could be used to create software to be embedded in various consumer electronic devices.
- Java is a programmer's language.
- Java is cohesive and consistent.
- Except for those constraints imposed by the Internet environment, Java gives the programmer, full control.
- Finally, Java is to Internet programming where C was to system programming.
Importance of Java to the Internet
Java has had a profound effect on the Internet. This is because; Java expands the Universe of objects that can move about freely in Cyberspace. In a network, two categories of objects are transmitted between the Server and the Personal computer. They are: Passive information and Dynamic active programs. The Dynamic, Self-executing programs cause serious problems in the areas of Security and probability. But, Java addresses those concerns and by doing so, has opened the door to an exciting new form of program called the Applet.
Java can be used to create two types of programs
Applications and Applets: An application is a program that runs on our Computer under the operating system of that computer. It is more or less like one creating using C or C++. Java's ability to create Applets makes it important. An Applet is an application designed to be transmitted over the Internet and executed by a Java -compatible web browser. An applet is actually a tiny Java program, dynamically downloaded across the network, just like an image. But the difference is, it is an intelligent program, not just a media file. It can react to the user input and dynamically change.
Features of Java Security
Every time you that you download a “normal” program you are risking a viral infection. Prior to Java, most users did not download executable programs frequently, and those who did scan them for viruses prior to execution. Most users still worried about the possibility of infecting their systems with a virus. In addition, another type of malicious program exists that must be guarded against. This type of program can gather private information, such as credit card numbers, bank account balances, and passwords. Java answers both these concerns by providing a “firewall” between a network application and your computer.
When you use a Java-compatible Web browser, you can safely download Java applets without fear of virus infection or malicious intent.
For programs to be dynamically downloaded to all the various types of platforms connected to the Internet, some means of generating portable executable code is needed .As you will see, the same mechanism that helps ensure security also helps create portability. Indeed, Java's solution to these two problems is both elegant and efficient.
The Byte code
The key that allows the Java to solve the security and portability problems is that the output of Java compiler is Byte code. Byte code is a highly optimized set of instructions designed to be executed by the Java run-time system, which is called the Java Virtual Machine (JVM). That is, in its standard form, the JVM is an interpreter for byte code.
Translating a Java program into byte code helps makes it much easier to run a program in a wide variety of environments. The reason is, once the run-time package exists for a given system, any Java program can run on it.
Although Java was designed for interpretation, there is technically nothing about Java that prevents on-the-fly compilation of byte code into native code. Sun has just completed its Just In Time (JIT) compiler for byte code. When the JIT compiler is a part of JVM, it compiles byte code into executable code in real time, on a piece-by-piece, demand basis. It is not possible to compile an entire Java program into executable code all at once, because Java performs various run-time checks that can be done only at run time. The JIT compiles code, as it is needed, during execution.
Java Virtual Machine (JVM)
Beyond the language, there is the Java virtual machine. The Java virtual machine is an important element of the Java technology. The virtual machine can be embedded within a web browser or an operating system. Once a piece of Java code is loaded onto a machine, it is verified. As part of the loading process, a class loader is invoked and does byte code verification makes sure that the code that's has been generated by the compiler will not corrupt the machine that it's loaded on. Byte code verification takes place at the end of the compilation process to make sure that is all accurate and correct. So byte code verification is integral to the compiling and executing of Java code.
Picture showing the development process of JAVA Program
Java programming uses to produce byte codes and executes them. The first box indicates that the Java source code is located in a. Java file that is processed with a Java compiler called javac. The Java compiler produces a file called a. class file, which contains the byte code. The .Class file is then loaded across the network or loaded locally on your machine into the execution environment is the Java virtual machine, which interprets and executes the byte code.
Java architecture provides a portable, robust, high performing environment for development. Java provides portability by compiling the byte codes for the Java Virtual Machine, which is then interpreted on each platform by the run-time environment. Java is a dynamic system, able to load code when needed from a machine in the same room or across the planet.
Compilation of code
When you compile the code, the Java compiler creates machine code (called byte code) for a hypothetical machine called Java Virtual Machine (JVM). The JVM is supposed to execute the byte code. The JVM is created for overcoming the issue of portability. The code is written and compiled for one machine and interpreted on all machines. This machine is called Java Virtual Machine.
Introduction to Servlets
Servlets provide a Java(TM)-based solution used to address the problems currently associated with doing server-side programming, including inextensible scripting solutions, platform-specific APIs, and incomplete interfaces.
Servlets are objects that conform to a specific interface that can be plugged into a Java-based server. Servlets are to the server-side what applets are to the client-side -- object byte codes that can be dynamically loaded off the net. They differ from applets in that they are faceless objects (without graphics or a GUI component). They serve as platform-independent, dynamically loadable, plug gable helper byte code objects on the server side that can be used to dynamically extend server-side functionality.
What is a Servlet?
Servlets are modules that extend request/response-oriented servers, such as Java-enabled web servers. For example, a servlet might be responsible for taking data in an HTML order-entry form and applying the business logic used to update a company's order database.
Servlets are to servers what applets are to browsers. Unlike applets, however, Servlets have no graphical user interface. Servlets can be embedded in many different servers because the servlet API, which you use to write Servlets, assumes nothing about the server's environment or protocol. Servlets have become most widely used within HTTP servers; many web servers support the Servlet API.
- Use Servlets instead of CGI Scripts:
- Servlets are an effective replacement for CGI scripts. They provide a way to generate dynamic documents that is both easier to write and faster to run. Servlets also address the problem of doing server-side programming with platform-specific APIs: they are developed with the Java Servlet API, a standard Java extension.
- So use Servlets to handle HTTP client requests. For example, have Servlets process data posted over HTTPS using an HTML form, including purchase order or credit card data. A servlet like this could be part of an order-entry and processing system, working with product and inventory databases, and perhaps an on-line payment system.
- Other Uses for Servlets
Here are a few more of the many applications for Servlets:
- Allowing collaboration between people. A servlet can handle multiple requests concurrently, and can synchronize requests. This allows Servlets to support systems such as on-line conferencing.
- Forwarding requests. Servlets can forward requests to other servers and Servlets. Thus Servlets can be used to balance load among several servers that mirror the same content, and to partition a single logical service over several servers, according to task type or organizational boundaries.
- Architecture of the Servlet Package
- The javax.servlet package provides interfaces and classes for writing Servlets. The architecture of the package is described below.
The Servlet Interface:
- The central abstraction in the Servlet API is the Servlet interface. All Servlets implement this interface, either directly or, more commonly, by extending a class that implements it such as HttpServlet.
- The Servlet interface declares, but does not implement, methods that manage the servlet and its communications with clients. Servlet writers provide some or all of these methods when developing a servlet.
- When a servlet accepts a call from a client, it receives two objects:
- A ServletRequest, which encapsulates the communication from the client to the server.
- A ServletResponse, which encapsulates the communication from the servlet back to the client.
- ServletRequest and ServletResponse are interfaces defined by the javax.servlet package.
The ServletRequest Interface:
- The ServletRequest interface allows the servlet access to: Information such as the names of the parameters passed in by the client, the protocol (scheme) being used by the client, and the names of the remote host that made the request and the server that receive the input stream, ServletInputStream. Servlets use the input stream to get data from clients that use application protocols such as the HTTP POST and PUT methods.
Interfaces that extend ServletRequest interface allow the servlet to retrieve more protocol-specific data. For example, the HttpServletRequest interface contains methods for accessing HTTP-specific header information.
The ServletResponse Interface:
The ServletResponse interface gives the servlet methods for replying to the client. It:
- Allows the servlet to set the content length and MIME type of the reply.
- Provides an output stream, ServletOutputStream, and a Writer through which the servlet can send the reply data.
Interfaces that extend the ServletResponse interface give the servlet more protocol-specific capabilities. For example, the HttpServletResponse interface contains methods that allow the servlet to manipulate HTTP-specific header information.
Additional Capabilities of HTTP Servlets
The classes and interfaces described above make up a basic Servlet. HTTP Servlets have some additional objects that provide session-tracking capabilities. The servlet writer can use these APIs to maintain state between the servlet and the client that persists across multiple connections during some time period. HTTP Servlets also have objects that provide cookies. The servlet writer uses the cookie API to save data with the client and to retrieve this data.
The classes mentioned in the Architecture of the Servlet Package section are shown in the example in bold:
- SimpleServlet extends the HttpServlet class, which implements the Servlet interface.
- SimpleServlet overrides the doGet method in the HttpServlet class. The doGet method is called when a client makes a GET request (the default HTTP request method) and results in the simple HTML page being returned to the client.
- Within the doGet method,
An HttpServletRequest object represents the user's request.
o An HttpServletResponse object represents the response to the user.
o Because text data is returned to the client, the reply is sent using the Writer object obtained from the HttpServletResponse object.
Each servlet has the same life cycle:
- A server loads and initializes the servlet
- The servlet handles zero or more client requests
- The server removes the servlet
Initializing a Servlet
When a server loads a servlet, the server runs the servlet's init method. Initialization completes before client requests are handled and before the servlet is destroyed.
Even though most Servlets are run in multi-threaded servers, Servlets have no concurrency issues during servlet initialization. The server calls the init method once, when the server loads the servlet, and will not call the init method again unless the server is reloading the servlet. The server cannot reload a servlet until after the server has destroyed the servlet by calling the destroy method.
The init Method:
The init method provided by the HttpServlet class initializes the servlet and logs the initialization. To do initialization specific to your servlet, override the init () method following these rules:
If an initialization error occurs that renders the servlet incapable of handling client requests, throw an Unavailable Exception.
The second version of the init method calls the getInitParameter method. This method takes the parameter name as an argument and returns a String representation of the parameter's value.
The specification of initialization parameters is server-specific. In the Java Web Server, the parameters are specified with a servlet is added then cond in the Administration Tool. For an explanation of the Administration screen where this setup is performed, see the Administration Tool: Adding Servlets online help document.
If, for some reason, you need to get the parameter names, use the getParameterNames method.
Destroying a Servlet:
Servlets run until the server is destroys them, for example at the request of a system administrator. When a server destroys a servlet, the server runs the servlet's destroy method. The method is run once; the server will not run that servlet again until after the server reloads and reinitializes the servlet.
When the destroy method runs, another thread might be running a service request. The Handling Service Threads at Servlet Termination section shows you how to provide a clean shutdown when there could be long-running threads still running service requests.
Using the Destroy Method:
The destroy method provided by the HttpServlet class destroys the servlet and logs the destruction. To destroy any resources specific to your servlet, override the destroy method. The destroy method should undo any initialization work and synchronize persistent state with the current in-memory state.
A server calls the destroy method after all service calls have been completed, or a server-specific number of seconds have passed, whichever comes first. If your servlet handles any long-running operations, service methods might still be running when the server calls the destroy method. You are responsible for making sure those threads complete. The next section shows you how.
The destroy method shown above expects all client interactions to be completed when the destroy method is called, because the servlet has no long-running operations.
Java Server Pages
Java Server Pages technology lets you put snippets of servlet code directly into a text-based document. A JSP page is a text-based document that contains two types of text: static template data, which can be expressed in any text-based format such as HTML, WML, and XML, and JSP elements, which determine how the page constructs dynamic content.
Java Server Page™ (JSP): An extensible Web technology that uses template data, custom elements, scripting languages, and server-side Java objects to return dynamic content to a client. Typically the template data is HTML or XML elements, and in many cases the client is a Web browser.
According to JSP model1 we can develop the application as,
According to above model the presentation logic has to be implemented in JSP page and the business logic has to be implemented as part of Java bean This model help us in separating the presentation and business logic. For large-scale projects instead of using model1 it is better to use model2 (MVC). Struts framework is based on model 2.
Java Server Pages (JSP) lets you separate the dynamic part of your pages from the static HTML. You simply write the regular HTML in the normal manner, using whatever Web-page-building tools you normally use. You then enclose the code for the dynamic parts in special tags, most of which start with "<%" and end with "%>". For example, here is a section of a JSP page that results in something like "Thanks for ordering Core Web Programming
For URL of http://host/OrderConfirmation.jsp?title=Core+Web+Programming:
Thanks for ordering
<I><%= request.getParameter("title") %></I>
You normally give your file a .jsp extension, and typically install it in any place you could place a normal Web page. Although what you write often looks more like a regular HTML file than a servlet, behind the scenes, the JSP page just gets converted to a normal servlet, with the static HTML simply being printed to the output stream associated with the servlet's service method. This is normally done the first time the page is requested, and developers can simply request the page themselves when first installing it if they want to be sure that the first real user doesn't get a momentary delay when the JSP page is translated to a servlet and the servlet is compiled and loaded. Note also that many Web servers let you define aliases that so that a URL that appears to reference an HTML file really points to a servlet or JSP page.
Aside from the regular HTML, there are three main types of JSP constructs that you embed in a page: scripting elements, directives, and actions. Scripting elements let you specify Java code that will become part of the resultant servlet, directives let you control the overall structure of the servlet, and actions let you specify existing components that should be used, and otherwise control the behavior of the JSP engine. To simplify the scripting elements, you have access to a number of predefined variables such as request in the snippet above.
J2EE Platform Overview
The J2EE platform is designed to provide server-side and client-side support for developing distributed, multi-tier applications. Such applications are typically cond as a client tier to provide the user interface, one or more middle-tier modules that provide client services and business logic for an application, and back-end enterprise information systems providing data management.
The J2EE platform provides a multi-tier distributed application model. This means that the various parts of an application can run on different devices. The J2EE architecture defines a client tier, a middle tier (consisting of one or more sub-tier), and a back-end tier. The client tier supports a variety of client types, both outside and inside of corporate firewalls. The middle tier supports client services through Web containers in the Web tier and supports business logic component services through JavaBeans TM. On the back end, the enterprise information systems in the tier are accessible by way of standard APIs.
Container-Based Component Management
Central to the J2EE component-based development model is the notion of containers. Containers are standardized runtime environments that provide specific services to components. Components can expect these services to be available on any J2EE platform from any vendor. For example, all J2EE Web containers provide runtime support for responding to client requests, performing request-time processing (such as invoking JSP pages or servlet behavior), and returning results to the client. In addition, they provide APIs to support user session management. All WEB containers provide automated support for transaction and life cycle management of WEB components, as well as bean lookup and other services. Containers also provide standardized access to enterprise information systems; for example, providing access to relational data through the JDBC API. In addition, containers provide a mechanism for selecting application behaviors at assembly or deployment time. Through the use of deployment descriptors (XML files that specify component and container behavior), components can be cond to a specific container's environment when deployed, rather than in component code. Features that can be cond at deployment time include security checks, transaction control, and other management responsibilities.
While the J2EE specification defines the component containers that a platform implementation must support, it doesn't specify or restrict the containers' configurations. Thus, both container types can run on a single platform, Web containers can live on one platform and WEB containers on another or a J2EE platform can be made up of multiple containers on multiple platforms.
Support for Client Components
The J2EE client tier provides support for a variety of client types, both within the enterprise firewall and outside. Clients can be offered through Web browsers by using plain HTML pages, HTML generated dynamically by Java Server PagesTM.
Support for Business Logic Components
While simple J2EE applications may be built largely in the client tier, business logic is often implemented on the J2EE platform in the middle tier as Java Beans components (also known as enterprise beans). Enterprise beans allow the component or application developer to concentrate on the business logic while the complexities of delivering a reliable, scalable service are handled by the WEB container.
In many ways, the J2EE platform and Java Beans architecture have complementary goals. The Java Beans component model is the backbone of industrial-strength application architectures in the J2EE programming model. The J2EE platform complements the specification by:
- Fully specifying the APIs that an enterprise bean developer can use to implement enterprise beans
- Defining the larger, distributed programming environment in which enterprise beans are used as business logic components
J2EE Platform Benefits
With features designed to expedite the process of developing distributed applications, the J2EE platform offers several benefits:
- Simplified architecture and development
- Freedom of choice in servers, tools, and components
- Integration with existing information systems
- Scalability to meet demand variations
- Flexible security model
Simplified Architecture and Development
The J2EE platform supports a simplified, component-based development model. Because it is based on the Java programming language and the Java 2 Platform, Standard Edition (J2SETM platform), this model offers “Write-Once-Run-Anywhere” portability, supported by any server product that conforms to the J2EE standard.
The component-based J2EE development model can enhance application development productivity in a number of ways:
- Maps easily to application functionality—Component-based application models map easily and flexibly to the functionality desired from an application. As the examples presented throughout this book illustrate, the J2EE platfor
Cite This Dissertation
To export a reference to this article please select a referencing stye below:Reference Copied to Clipboard.Reference Copied to Clipboard.Reference Copied to Clipboard.Reference Copied to Clipboard.Reference Copied to Clipboard.Reference Copied to Clipboard.Reference Copied to Clipboard.