 |
INTRODUCTION
Developing Global
Communication for National Engineering Corporation. The main concept of Global
Communication is developing the conference on the net. We can compare the Global Communication with the Telephone Conference. Normally in Telephone Conference, there will be more
than two users connected at a time and all the users are able to here words
from any one of the user. So implementing the same concept on the Net is
nothing but Global Communication
Why to develop Global Communication: Now a day’s
time is becoming more and more precious.100% industries are computerized and
there is a vast development in industries either in the public sector or in the
private sector. The common transactions for any company are sales and purchases. So most of the companies now days made on line sales and
purchases. So distributors, customers and companies can continue their business
dealings using this on-line sales and purchases. By this they can save their
valuable time.
Here the company is the
manufacturer of Transformers and
Stabilizers .For their growth of business they want to develop this sort of
Global Communication. Through this
they will be able to make conferences with their clients (distributors) or with
their customers with timely updates of the company business. So they can
improve their products with respect to the customers view. This will help them
to become a number one position in the current market.
The another advantage is that
the company is having branches throughout the country. So this will help them
to communicate business affairs of the company and live meetings and
conferences between their employees and directors. They can conduct board of
directors meeting It will give On-line solutions from the superiors to the
employees.
Likely
there are so many advantages by developing this Global Communication for a company like NEC.
Features:
Ø Grouping:
Grouping of selected users
Ø Support of multi conference
Ø By selecting the single user from the list, Talk can be achieved
Ø By selecting all the users in the list, Chat can be achieved
ABOUT
THE ORGASNIZATION
NATIONAL
ENGINEERING CORPORATION (NEC) is a
Premier
organization in India HYDERABAD
NEC
has now been in operation for over 23 years and has become an integral part of
a large number of Corporate Sector Organizations. NEC has emerged as an agent
of change in the lives of the people. Information handling has been made more
effective and meaningful through the usage of computer systems because of
presentation in different formats such as graphs and charts of the company’s
annual production and sales which can immediately trigger the imagination and
thinking of decision makers.
Today NEC is playing a vital role in
the lives of the people by facilitating them with their requirements. The
services provided by NEC include the development of TRANSFORMERS and
STABILIZEERS. NEC covers a full ranges
of low tension (up to 660V, 50 to 60 Hz) current transformers both for metering
and protection. Current Transformers are manufactured generally confirming to
the Indian Standards. The type class accuracy and burden of these transformers
depends on the purpose for which they are used. NEC AC Voltage Stabilizer
provides cost-effective solutions to problems of fluctuations by ensuring
constant output voltage. The field of application is very wide for AC
Stabilizer. Keeping in view of the wide
range of our country which spans from Kashmir
to Kanyakumari NEC puts its best effort to provide good quality supply.
The principal role played by NEC, besides changing the
work culture and making the administration more effective and efficient at all
levels, is in the nature of demolishing barriers and in making the working of
the organization more transparent to the public, as well as in making the
information more readily available from one Department to another. The
availability of information, accurately and on a timely basis, required by the
officials concerned, has given a new dimension to the management. NEC is proud
that it has made all this possible. With this support today it is proud to
declare that it is going to launch its site on the INTERNET.
A major resource of NEC is its highly skilled pool
of manpower . The main objective of NEC
is
1.To design and develop Transformers and Stabilizers.
2. To generate, skilled manpower within departments.
With the facility of having its site on the
INTERNET the organization is going to expand than what is today. It can have
orders being placed. Today it has an easy access to all this than what it was
earlier.
PRESENT SYSTEM
Conferences will take part a vital
role for any of the national wide company. A company like National Engineering
Corporation it takes part an important role. Because the company is having
branches through out India
Normally
conferences will be conducted in some place owned by company or in some
conference hall. The person, who has to participate in the conference, has to
travel all the way to participate in the conference. So it will be very risky
to travel for the persons, and it is risky work for the company also to provide
all the felicities to persons. Now a day wherever you see so many strikes are
going. In that case to participate in any important conference or to conduct
any conference will be very tedious. All this may lead to loss of company and
time taking matters. So here the company is decided to develop their
conferences on the net itself.
PROPOSED SYSTEM
The
proposed system is to maintain the conferences, live meetings, general body
meetings on the net. This system is to develop in a client/server environment.
It aims to do the following.
Ø
Grouping: Grouping of selected users
Ø Support of multi conference
Ø By selecting the single user from the list, Talk can be achieved
Ø By selecting all the users in the list, Chat can be achieved
Need for computerization:
Time plays an important
role in today’s world. Any information is useful if it is available on the
right time. Quick and correct information at he right time needs
computerization. Many scientists’ engineers have to spend their valuable time
to attend a conference, which is going on a long distance place. For them even
one second costs millions and millions of dollars. So this project will help
them to participate in the conferences.
The main
concept of Global Communication is developing the conference on the net. We can
compare the Global Communication with
the Telephone Conference. Normally in
Telephone Conference, there will be
more than two users connected at a time and all the users are able to here
words from any one of the user. So implementing the same concept on the Net is
nothing but Global Communication.
This
project is used to:
Ø Conduct
conferences with their employees. So they can get online decisions from
employees from the different branches of the company.
Ø The another
advantage is that the company is having branches throughout the country. So
this will help them to communicate business affairs of the company and live
meetings and conferences between their directors. They can conduct board of
directors meeting.
Ø It will
give On-line solutions from the superiors to the employees.
PLATFORM/PACKAGES SELECTED
WINDOWS NT:
Windows NT
is an operating system developed by Microsoft. Two versions of NT are
available: a server version and a workstation version. Both share the same
architecture, but the server version is optimized for running server
operations, while the workstation version is intended for client machines.
Windows NT workstation is focussed on providing a desktop operating system for
solving complex business needs, offering performance for systems such as
dual-processor workstation or multiprocessor RISC servers.
Windows NT is a 32-bit operating system. It offers much greater data transfer speed than a 16 bit operating system, both with in the processor and to peripherals, and it allows a much larger memory space to be addressed, boosting performance even more. The larger memory space means that 32-bit operating systems have the band width to offer other processing advantages, such as the ability to run different applications in separate memory spaces, perform multitasking and so on.
NT workstation requires a
powerful system. A minimum configuration of a 486 PC with 16 Mbytes of RAM and
200 Mbytes of hard disk is recommended by the Microsoft.
Windows NT workstation uses
pre-emptive multitasking, which allows users to run tasks simultaneously,
without losing system performance. Pre-emptive multitasking assigns processing
resources equally between all the applications that are running, slowing down
all of them equally.
Multitasking,
which is provided by, NT is vital for taking advantage of multiprocessing. It
allows different parts of a program to be handled independently by the
operating systems
Windows NT
provides crash protection by running applications in separate address spaces.
NT protects system resources by giving each application a mirror of the system
resources within its own spaces. If the application crashes only the mirrored
resources, is affected, while the real system resources, continues to function.
NT meets
the security certification requirements for users level security on access to a
standalone workstation. Files, folders and application can be made invisible to
specific users. It also provides secure user profiles to control access to the
desktop applications and system configuration files. A transacted file offers
increased data protection. NT workstation comes with the most common networking
protocols, including Netware, TCP/IP, IPX/SPX/ SLIP and PPP. It also scalable
and runs on a variety of platforms.
As more
powerful mainstream machines are developed, technologies created for NT
workstation will migrate to Windows 95. The advantage is this compatibility
brings to customers an users are that applications can be shared across the two
operating systems, that training needs are reduced as ease of use is increased
and the that the larger volume of application leads to lower software and
support cost.
HTML:
To publish information for
global distribution, one needs a universally understood language, a kind of
publishing mother tongue that all computers may potentially understand. The publishing language used by the World
Wide Web is HTML (Hyper Text Markup Language).
HTML gives authors the means to
Publish
online documents with headings, text, tables, lists, photos, etc. Retrieve online
information via hypertext links, at the click of a button Design forms for
conducting transactions with remote services, for use in searching for
information, making reservations, ordering products etc. Include spread -
sheets, video clips, sound clips, and other applications directly in their
documents.
A brief history of HTML:
HTML was originally
developed by Tim Berners-Lee while at CERN, and popularized by the Mosaic
browser developed at NCSA. During the
course of the 1990s it has blossomed with the explosive growth of the Web
during this time. HTML has been extended
in a number of ways. The Web depends on
Web page authors and vendors sharing the same conventions for HTML. This has motivated joint work on
specifications for HTML.
HTML 2.0
(November 1995) was developed under the aegis of the Internet Engineering Task
Force (IETF) to codify common practice in late 1994. HTML (1993) and
([HTML.30]) (1995) proposed much richer versions of HTML, despite never
receiving consensus in standards discussions, these drafts led to the adoption
of new features. The efforts of the World Wide Web Consortium’s HTML
working group to codify common practice in 1996 resulted in HTML 3.2 (January
1997). Most people agree that HTML
documents should work well across different browsers and platforms. Achieving interoperability lowers costs to
content providers since they must develop only one version of a document. If the effort is not made, there is much
greater risk that the Web will devolve into a proprietary world of incompatible
formats, ultimately reducing the Web’s commercial potential for all
participants.
Tables:
Authors now have greater control
over structure and layout (e.g. column
groups). The ability of designers to recommend column widths user agents to
display table data incrementally (as it arrives) rather than waiting for the
entire table before rendering.
Compound documents:
HTML now offers a
standard mechanism for embedding generic media objects and applications in HTML
documents. The OBJECT element (together with its more specific ancestor
elements IMG and APPLET provides a mechanism for including images, video,
sound, mathematics, specialized applications, and other objects in a document. It also allows authors to specify a hierarchy
of alternate renderings for user agents that don’t support a specific
rendering.
Style sheets:
Style sheets simplify
HTML markup and largely relieve HTML of the responsibilities of presentation. They give both authors and users control over
the presentation of documents- font information, alignment, colors, etc.
Style information can be specified for
specific elements or groups of elements either within an HTML document or in
separate style sheets. The mechanism for associating a style sheet with a
document is independent of the style sheet language. Before the advent of style
sheets, authors had limited control over rendering HTML 3.2 included a number
of attributes and elements offering control over alignment, font size, and text
color. Authors also exploited tables and
images as a means for laying out pages.
The relatively long time it takes for users to upgrade their browsers,
means that these features will continue to be used for some time. However, since style sheets offer more
powerful presentation mechanisms, the World Wide Web Consortium will eventually
phase out many of HTML’s presentation
elements and attributes.
Scripting:
Through scripts, authors may create
“smart forms” that react at users fill them out. Scripting allows designers to create dynamic
Web pages, and to use HTML as a means to build networked applications. The mechanism provided to associate HTML with
scripts are independent of particular scripting languages.
Printing:
Sometimes, authors will want
to make it easy for users to print more than just the current document. When documents form part of a larger work,
the relationships between them can be described using the HTML LINK element or
using W3C’s Resource Description Language.
Designing documents with HTML 4.0:
The following general
principles are observed when working with HTML 4.0
Separate structure and presentation
HTML has its roots in
SGML, which has always been a language for the specification of structural
markup. As HTML matures more and more of
its presentational elements and attributes are being replaced by other
mechanisms, in particular style sheets.
Experience has shown that separating the structure of a document from
its presentational aspects reduces the cost of serving a wide range of
platforms, media, etc., and facilities document revisions.
Accessibility To The Universal Wide |Web:
To make the Web more accessible to
everyone, notably those with disabilities, authors should consider how their
documents, may be rendered on a variety of platforms, speech-based browsers,
Braille readers, etc. We do not
recommend that designers limit their creativity, only that they consider
alternate renderings in their design.
HTML offers a number of mechanisms to this end (e.g., the alt attribute,
the access key attribute, etc).
Furthermore,
authors should keep in mind, that their documents may be reaching a far-off audience
with different computer configurations.
In order for documents to be interpreted correctly, designers should
include in their document information about the natural language and direction
of the text, how the document is encoded, and other issues related to
internationalization. Help user agents with incremental rendering: By carefully
designing their labels and making user of new table features in HTML 4.0,
designers can help users agents render documents more quickly. Authors can learn how to design tables for
incremental rendering.
 |
JAVA SCRIPT:
JavaScript is a
scripting language developed jointly by Sun and Netscape and is meant for the
WWW. A scripting language is a simple programming language designed to enable
programmers to write useful programs quickly. A script is a similar to a macro,
which tells a program how to perform a specific procedure.
JavaScript Facts:
· JavaScript Is
Embedded Into HTML:
JavaScript
code is usually embedded into a HTML document and is
executed, within them. By itself JavaScript has no user
interface. It relies on, HTML to provide the means of interaction with the
user. Most Java Script objects have HTML tags they represent. JavaScript
extends the capabilities of HTML by providing events to HTML tags and provide
event driven code to execute it.
· JavaScript Is Browser Dependent:
JavaScript depends on the Web browser to support it. If the
browser does not support it, JavaScript code will be ignored. Internet Explorer
3.0 and, Netscape Navigator 2.0 onwards support JavaScript.
· JavaScript
Is an Interpreted Language:
JavaScript is interpreted at runtime by the browser before it
is executed it. It is not compiled into a separate program like a .exe but
remains part of the HTML file.
· JavaScript
Is a Loosely Typed Language:
JavaScript
is very flexible compared to Java. You need not specify,
the data type of a variable while declaring
it. Also you need not declare
Variables explicitly. It is perfectly legal
to declare variable as and when you
require them.
· JavaScript
Is an Object-Based Language:
JavaScript
is an object-based language. You can work with objects,
That encapsulates data (properties) and
behavior (method). However JavaScript
object model is instance-based and there
is no inheritance. This is the basic
difference between an object oriented and
an object-based language.
· JavaScript Is Event-Driven:
HTML objects such as buttons are enhanced to
support event
handlers. You can specify the functionality
of a button.
· JavaScript Is Not Java:
Java applet is stored in a separate file and
connected to a HTML file
through the <applet> tag, and it is a
strongly typed, object oriented compiled
language. JavaScript is loosely typed
object based, interpreted language meant
to create scripts.
· JavaScript Is Multifunctional:
JavaScript can be used to
Ø Enhance
HTML pages
Ø Develop
client side applications
Ø Build to a
certain extent client/server Web applications
Ø Create extensions
to a Web server.
Ø
Provide database connectivity without using CGI.
· JavaScript Is Evolving:
JavaScript evolved in December
1995. As the time goes buy,
JavaScript will be embedded and new
features added to it.
· JavaScript
Language Spans Contexts:
JavaScript can be used in server side
Netscape LiveWire Pro
Environment and Microsoft’s
Active X server frame work. It is not just a client
side scripting tool.
WEB Application Frame Work
Ø
Client Side Frame Work
Ø
Client Side Applications
Ø
Smart Pro Support
Ø
Data validation
Ø
Creating Interactive Forms
Ø
Client Side Lookup Tables
Ø
State Maintenance
|
ABOUT JAVA
CREATION OF JAVA:
Java was conceived by
James Gosling, Patrick Naughton, Chris Warth, Ed Frank and Mike Sheridan at SUN
Micro Systems Inc Corporation in 1991. It took 18months to develop the first
working version. This language was initially called "OAK", but was
renamed "JAVA" in 1995. Before the initial implementation of OAK in
1992 and the public announcement of Java in1995, many more contributed to the
design and evolution of the language.
JAVA OVERVIEW:
Java is powerful but lean on Object Oriented programming
language. It has generated a lot of excitement because it makes it possible to
program for Internet by creating applets, programs that can be embedded in web
page. The context of an applet is limited only by one's imagination. For
example, an applet can be an animation with sound, an interactive game or a
ticker tape with constantly updated stock prices. Applets can be just little
decorations to liven up web page, or they can be serious applications like word
processors or spreadsheet.
But Java is more than a
programming language for writing applets. It is being used more and more for
writing standalone applications as well.
It is becoming so popular that many people believe it will become
standard language for both general purpose and Internet programming.
There are many
buzzwords associated with Java, but because of its spectacular growth in
popularity, a new buzz word has appeared ambiguous, Indeed, all indications are
that it will soon be everywhere.
Java builds on the
strength of C++. It has taken the best features of C++ and discarded the more
problematic and error prone parts. To
this lean core, it has added garbage collection (automatic memory management),
multithreading (the capacity for one program to do more than one thing at a
time), security capabilities. The result
is that Java is simple, elegant, powerful and easy to use.
Java is actually a
platform consisting of three components:
1. Java programming language.
2. Java is library of classes and interfaces.
3. Java is a Virtual Machine.
The following sections will say more
about these components:
JAVA IS PORTABLE:
One of the biggest
advantages Java offers is that it is portable. An application written in Java
will run on all the major platforms. Any computer with a Java based browser can
run the applications or applets written in the Java programming language. A programmer no longer has to write one
program to run on a Macintosh, another program to run on a Windows machine,
still another to run on a UNIX machine, and so on. In other words, with Java, developers write
their programs only once. The Virtual Machine is what gives Java its cross
platform capabilities. Rather than being compiled into Machine language, which
is different for each operating systems and computer architecture, Java code is
compiled into byte codes.
With other languages, the
program code is compiled into a language that the computer can understand. The
problem is that other computers with different machine instruction set cannot
understand that language. Java code, on the other hand is compiled into byte
codes rather than a machine language. These byte codes go to the Java Virtual
Machine, which executes them directly or translates them into the language that
is understood by the machine running it.
With JDBC API extending
Java, a programmer writing Java code can access all the major relational
databases on any platform that supports the Java Virtual Machine.
JAVA IS OBJECT-ORIENTED:
The Java programming
language is object oriented, which makes program design focus on what you are
dealing with rather than on how you are going to do something. This makes it more useful for programming in
sophisticated projects because one can break the things down into
understandable components. A big benefit is that these components can then be
reused.
Object oriented
languages use the paradigm of classes.
In simplest term, a class includes both
the data and the functions
to operate on the data. You can create an instance of a class, also
called an object, which will have all the data members and functionality of its
class. Because of this, you can think of a class as being like a template, with
each object being a specific instance of a particular type of class.
The class paradigm
allows one to encapsulate data so that specific data values are those using the
data can not see function implementation. Encapsulation makes it possible to
make the changes in code without breaking other programs that use that
code. If for example the implementation
of a function is changed, the change is invisible to the another programmer who
invokes that function, and it does not affect his/her program, except hopefully
to improve it.
Java includes inheritance, or the ability to
derive new classes from existing classes.
The derived class, also called a subclass, inherits all the data and the
functions of the existing class, referred to as the parent class. A subclass
can add new data members to those inherited from the parent class. As far as
methods are concerned, the subclass can reuse the inherited methods, as it is,
change them, and/or add its own new methods.
JAVA MAKES IT EASY TO WRITE CORRECT CODE:
In addition to being portable and object oriented, Java
facilitates writing correct code.
Programmers spend less time writing Java code and a lot less time
debugging it. In fact, developers have
reported slashing development time by as much as two thirds. The following is a
list of some of Java's features that make it easier to write correct code:
GARBAGE COLLECTION:
Automatically takes
care of allocating and de allocating memory, a huge potential source of
errors. If an object is no longer being
used (has no references to it), then it is automatically removed from memory,
or "Garbage Collected".
Programmers don't have to keep track of what has been allocated and de
allocated themselves, which makes their job a lot easier, but, more importantly
it stops memory leaks.
NO POINTERS:
Eliminates big source
errors. By using object references instead of many pointers, problems with
pointer arithmetic are eliminated, and problems with inadvertently accessing
the wrong memory address are greatly reduced.
STRONG TYPING:
Cuts down on runtime errors.
Because Java enforces strong type checking, many errors are caught when code is
compiled. Dynamic binding is possible and often very useful, but static binding
with strict type checking is used when possible.
SIMPLICITY:
Java is made easier to
learn and use correctly. Java keeps it
simple by having just one way to do something instead of having several
alternatives, as in some languages. Java
also stays lean by not including multiple inheritance, which eliminates the
errors and ambiguity that arise when you create a subclass that inherits from
two or more classes. To replace capabilities, multiple inheritance provides
Java lets you add functionality to a class throw the use of interfaces.
JAVA INCLUDES A LIBRARY OF CLASSES AND INTERFACES:
The Java platform includes an
extensive class library so that programmers can use already existing classes as
it is, create subclasses to modify existing classes, or implement interfaces to
augment the capabilities of classes.
Both classes and interfaces contain data members (fields) and functions
(methods), but there are major differences. In a class, fields may be either
variable or constant, and methods are fully implemented. In an interface,
fields must be constants, and methods are just prototypes with no further
implementations. The prototypes give the
method signature (the return type, the function name, and the number of
parameters, with the type for each parameter), but the programmer must supply
implementations. To use an interface, a
programmer defines a class, declares that it implements the interface, and then
implements all the methods in that interface as part of the class.
These methods are
implemented in a way that is appropriate for the class in which the methods are
being used. Interfaces let one add
functionality to a class and give a great deal of flexibility in doing it. In
other words interfaces provide most of the advantages of multiple inheritance
without its disadvantages.
A package
is a collection of related Java classes and interfaces. The following list, though not complete,
gives examples of some Java packages and what they cover.
java.lang -- This package
is so basic that
it is automatically included
in any Java
program. It includes classes
dealing with numeric, strings, objects, runtime, security and threads.
Java.io -- Classes that manage reading data
from input streams and writing data to the output streams.
Java.util -- Miscellaneous utility classes,
including generic data structures, bit sets, time, date, the string
manipulation, random number generation, system properties, notification and
enumeration of data structures.
Java.net -- Classes for network support.
Java.awt --Classes that manage user interface
components such as windows, dialog boxes, buttons, check boxes, lists,
menus, scrollbars, and text fields; the
"AWT" stands Abstract Window Toolkit.
Java.awt.image -- Classes for managing image
data, including color models, dropping, color filtering, setting pixel values,
and grabbing snapshots.
Java.applet -- The Applet class, which provides
the ability to write applets, this package also includes several interfaces
that connect an applet to its document and to resources for playing audio.
Java.sql -- The JDBC API, classes and
interfaces that access databases and send SQL statements.
The first three
packages listed, java.lang, java.io, and java.util form the foundation, they
are the basic classes and interfaces for general-purpose programming. Java Development Kit Version1.1 added some
new packages, with
JDBC is
being one of them. Other new packages include such things as Remote Method
Invocation, Security and Java Beans the new API for creating reusable
components.
JAVA IS EXTENSIBLE:
A big plus for Java is
the fact it can be extended. It was
purposely written to be lean with the emphasis on doing what it does very well;
instead of trying to do everything from the beginning, it was return so that
extending it is very easy. Programmers
can modify existing classes or write their own new classes or they can write a
whole new package. The JDBC API, the
java.sql package, is one example of a foundation upon which extensions are
being built. Other extensions are being
added or worked on in area such as multimedia, Internet Commerce, conferencing,
and Telephony.
In addition to
extensions there are also main tools being developed to make existing
capabilities easier to use. For example,
there is already a tool that greatly simplifies creating and laying out
Graphical User Interfaces such as menus, dialog boxes and buttons.
JAVA IS SECURE
It is important that a
programmer unable to write subversive code for applications or applets. This is
especially true with the Internet being used more and more extensively for
services such as electronic commerce and electronic distribution of software
and multimedia contents. The Java platform builds security in four ways.
1. The way memory is allocated and laid out: In Java an
object's location in memory is not determined until the runtime, as opposed to
C and C++, where the compiler makes memory layout decisions. As a result, a
programmer not looks at a class definition and figure out how it might be laid
in memory.
2. The way incoming code is checked: The
Java Virtual Machine doesn't trust any incoming code and subjects it to what is
called Byte Code Verification. The byte
code verifier, part of the virtual machine, checks that
a: The
format of incoming code is correct
b: Incoming code doesn't forge
pointers
c: It
doesn't violate access restrictions
d: It accesses objects as what they are
3. The way classes are loaded: The Java
byte code loader, another part of the virtual machine, checks whether classes
loaded during program execution are local or from across a network. Imported
classes cannot be substituted for built in classes, and built in classes cannot
accidentally reference classes bring in over a network.
4. The way
access is restricted for untested code: The Java security manager allows
user to restrict untested Java
applets so that
they cannot access the local
network, local files and other resources.
JAVA PERFORMS WELL:
Java's performance is
better than one might expect. Java's
many advantages, such as having built in security and being interpreted as well
as compiled, do have a cost attached to them. However, various
optimizations have been built in, and the byte code interpreter can run very
fast the cost it doesn't have to do any checking. As a result, Java has done quite respectably
in performance tests. Its performance numbers for interpreted byte codes are
usually more than adequate to run interactive graphical end user applications.
For situations that
require unusually high performance, byte codes can be translated on the fly,
generating the final machine code for the particular CPU on which the
application is running at run time.
High level interpreted
scripting languages generally offer great portability and fast prototyping but
poor performance. Low level compiled
languages like C and C++ offer great performance but require large amounts of
time for writing and debugging code because of problems with areas such as
memory management, pointers and multiple inheritance. Java offers good
performance with the advantages of high level languages but without the
disadvantages of C and C++. In the world
of design trade-off, you can think of Java as providing a very attractive
middle ground.
JAVA IS ROBUST:
The multi platform
environment of the WEB places extraordinary demands on a program, because it
must execute reliably in a variety of systems.
Thus the ability to create robust programs was given a high priority in
the design of Java. To gain reliability,
Java restricts you in a few key areas to force you to find your mistakes early
in program developments. At the same
time, Java frees you from having to worry about many of the most common causes
of programming errors. Because Java is strictly typed language, it checks your
code at compile time. However, it also
checks your code at run time. In fact,
many hard to track down bugs that often turn up in hard to reproduce runtime
situations are simply impossible to create in Java. Knowing that what you have written will
behave in a predictable way under diverse conditions is a key feature of Java.
To understand how Java is robust, consider two
main reasons for program failure:
Memory management mistakes and mishandled
exceptional conditions (run time errors). Memory management can be difficult,
tedious task in traditional programming environments. For example in C/C++ the programmer must
manually allocate and free all dynamic memory. This sometimes leads to
problems. For example some programmers
sometimes forget to free memory that has been previously allocated. Or worse, they may free some memory that
another part of their code is still using.
Java virtually eliminates these
problems by managing memory allocations and de allocations. Java helps in this
area by providing object oriented exception handling. In a well-written Java
program a program should manage all run time errors.
JAVA SCALES WELL:
Java platform is
designed to scale well, from portable consumer electronic devices to powerful
desktop and server machines. The Virtual
Machine takes a small footprint and Java byte code is optimized to be small and
compact. As a result, Java
accommodates the need for low storage and for low bandwidth transmission over
the Internet. In addition the Java Operating System offers a standalone Java
platform that eliminates host operating system overhead while still supporting
the full Java platform API. This makes Java ideal for low cost network
computers whose sole purpose is to access the Internet.
JAVA IS MULTITHREADED:
Multithreading is
simply the ability of a program to do more than one thing at a time. For example an application could be faxing a
document at the same time it is printing another document. Or a program could
process new inventory figures while it maintains a feed for current prices.
Multithreading is particularly important in multimedia: a multimedia program
might often be
running a movie, running a audio track and displaying
text all at the same time.
The Internet helped
catapult Java to the forefront of programming and Java in turn has had a
profound effect on the Internet. The reason is simple: Java expands the
universe of objects that can move about freely in cyberspace. In a network,
there are two broad categories of objects transmitted between the Server and
your Personal Computer: Passive Information and Dynamic, Active Programs. For example, when you read your e-mail, you
are viewing passive data. Even when you
download a program, the program's code is still only passive data until you
execute it. However, there is a second
type of object that can be transmitted to your computer: a dynamic,
self-executing program. Such a program
would be an active agent on the Client computer, yet the Server would initiate
it.
As
desirable as dynamic, networked programs are, they also present serious
problems in the areas of security and portability. Prior to Java cyberspace was
effectively closed to half the entities that now live there. Java addresses
these concerns and doing so, has opened the door to an exiting a new form of
program:
|
JAVA DATABASE CONNECTIVITY (JDBC)
JDBC OVERVIEW:
JDBC is a
Java API for executing SQL statements. (JDBC is a trademarked name and is not
an acronym; nevertheless, JDBC is often thought of as understanding for
"Java Database Connectivity".) It consists of a set of classes and
interfaces written in the Java programming language. JDBC provides a standard
API for tool/database developers and makes it possible to write database
applications using a pure Java API.
Using JDBC, it is easy
to send SQL statements to virtually any relational database. In other words,
with the JDBC API, it is not necessary to write one program to access a Sybase
database, another program to access a Oracle database, another program to
access a Informix database, and so on.. One can write a single program using
the JDBC API, and the program will be able to send SQL statements to the
appropriate database. And with in an application written in Java programming
language, one also doesn't have to worry about writing different applications
to run on different platforms. The combination of Java and JDBC lets a
programmer to write it once run it anywhere.
Java, being robust, secure, easy to
understand, and automatically downloaded on a network, is an excellent language
basis for database applications. What is needed is a way for Java applications
to walk to a variety of different databases. JDBC is the mechanism for doing
this.
JDBC extends the
concepts, which can be done in Java. For example, with Java and JDBC API, it is
possible to publish a web page containing an applet that uses information
obtained from a remote database or an enterprise can use JDBC to connect all
this employees (even if they are using conglomeration of Windows, Macintosh,
and Unix machines) to one or more internal databases via an Internet. With more
and more programmers using the Java programming language, the need for easy
database access from Java is continuing to grow.
MIS managers like the
combination of Java and JDBC because it makes disseminating information easy
and economical. Businesses can continue to use their installed databases and
access information easily even of it is stored on different database management
systems. Development time for new applications is short. Installation and
version controls are greatly simplified. A programmer can write an application
or an update once, put it on the server, and everybody has access to the latest
version. And for business selling information services, Java and JDBC offer a
better way of getting out information updates to external customers.
WHAT DOES JDBC DO?
Simply put, JDBC makes
it possible to do three things:
1. Establish a
connection with the database
2. Send SQL statements
3. Process the
results
The
following code fragment gives a basic example of these three steps:
Connection
con = DriverManeger.getConnection (“Jdbc:odbc:omega”, “login”, “password”);
USING JDBC INSTEAD OF CGI:
Until now, the only way
to access a database through Java has been to use streams in Java to call and
access Common Gateway Interface (CGI) programs. Calling a CGI script from Java
lets you call a separate program that accesses the database and returns results.
Using this approach is
slow and lets more bugs creep into applications. Developing into two different
development languages requires the knowledge of two technologies. When we use
JDBC we need to know only the Java language, whereas when we use CGI we must
use Java and another language.
Another reason to use JDBC is that it is noticeably
faster than CGI approach. Using CGI usually requires that you call another
program that must be executed by the computer. This separate program then
accesses the database and processes the data, returning it to the calling
program in a stream. This requires multiple levels of processing, which in turn
increases wait time as well s enables more bugs to appear. The following figure
displays how CGI program is executed.
Fig.
Calling a CGI script.
Whereas calling a CGI
script involves actually executing a new script, usually through a web server,
executing a JDBC statement against the database requires only some sort of
server that passes the SQL commands through the database. This speeds up
dramatically the time it takes to execute SQL statements. Whereas the CGI
script must actually connect to the database and process the results, the JDBC
solution lets your Java application have the connection to the database so that
thew application can perform all of the processing. The following figure
displays how a JDBC statement is executed.
|
 |
 |
Fig.
Executing a JDBC statement
JDBC
IS A LOW-LEVEL API AND A BASE FOR
HIGER-LEVEL APIs:
JDBC is a “low-level”
interface, which means that it is used to invoke (or “call’) SQL commands
directly. It works very well in this capacity and is easier to use than other
database connectivity. JDBC APIs were also designed to be a base upon which to
build higher-level interfaces and tools. A higher-level interface is
“user-friendly”, using a more understandable or more convenient API that is
translated behind the scenes into a low-level interface such as JDBC. At
present, two kinds of higher-level APIs are under development on top of JDBC:
1.
An embedded SQL for Java: At least one vendor plans to
build this. DBMS implement SQL, a language designed specifically for use with
databases. JDBC requires that SQL statements be passed as strings to Java
methods. An embedded SQL processor allows a programmer to instead mix SQL
statements directly with Java: for ex: a Java variable can be SQL statement to
receive or provide SQL mix into Java with JDBC calls.
2.
A direct mapping of a relational database tables to
Java classes: JavaSoft and others have announced plans to implement this. In
this “object/relational” mapping, each row of the table becomes an instance of
that class, and each column value corresponds to an attribute of that instance.
Programmers can then operate directly on Java objects; the required SQL calls
to fetch and store data are automatically generated “beneath the covers”. More
sophisticated mappings are also provided, for example, where rows of multiple
tables are combined into Java class.
2.1 As
interest in JDBC has grown, more developers have been working in JDBC based
tools to make building programs easier, as well. Programmers have also been
writing applications that make accessing a database easier for the end-user.
For e.g., an application might present a menu of database tasks from which to
choose. After a task is selected, the application presents prompts and blanks
for filling in information needed to carry out the selected task. With the
required input typed in, the application then automatically invokes the necessary
SQL command. With the help of such an application, users can perform database
tasks even when they have little or no knowledge of SQL syntax.
JDBC Vs ODBC AND OTHER APIs:
At this point,
Microsoft’s ODBC (Open Database Connectivity) API is the most widely used
programming interface for accessing relational databases. It offers the ability
to connect to almost all databases on almost all platforms. So why not use ODBC
form Java?
The answer is that you can use ODBC from Java,
but this is best done with the help of JDBC in the form of the JDBC-ODBC Bridge
1.
ODBC is not appropriate for direct use from Java,
because it uses a C interface. Calls from Java to native C-code have a number
of drawbacks in the security, implementation robustness and automatic
probability of applications.
2.
A literal translation of the ODBC C API into a Java
API would not be desirable. For e.g., Java has no pointers, and ODBC makes
copious use of them, including the notoriously error-prone generic pointer
“void *”. You can think of JDBC ac ODBC translated into an object-oriented
interface that is natural for Java programmers.
3.
ODBC is hard to learn. It mixes simple and advanced
features together, and it has complex options even for simple queries. JDBC, on
the other hand was designed to keep simple things simple while allowing more
advanced capabilities where required.
4.
A Java API like JDBC is needed in order to enable a
“pure Java” solution. When ODBC is used, the ODBC driver manager and drivers
must be manually installed on every client machine. When the JDBC driver is
written completely in Java, however, JDBC code is automatically installable,
portable, and secure on all Java platforms from network computers to
mainframes.
In
summary, the JDBC API is a natural Java interface to the basic SQL abstractions
and concepts. It builds on ODBC rather than starting from scratch, so
programmers familiar with ODBC will find it very easy to learn JDBC. JDBC
returns the basic design features of ODBC; in fact both interfaces are based on
the (X/Open SQL CLI (Call Level Interface). The big difference is that JDBC
builds on end reinforces the style and virtues of Java, and, of course it is
easy to use.
More recently, Microsoft has
introduced new APIs beyond ODBC: RDO, ADO
TWO-TIER AND THREE-TIER MODELS:
The JDBC API supports
both two-tier and three-tier models for database access. In the two-tier model,
A Java applet or application talks directly to the database. This requires a
JDBC driver that can communicate with the particular database management system
being accessed. A user’s SQL statements are delivered to the database, and the
results of those statements are sent back to the user. The database may be
located on another machine to which the user is connected via a network. This
is referred to as a client/server configuration, with the user’s machine as the
client, and the machine housing the database as the server. The network can be
the Intranet, which, for example, connects employees within a corporation, or
it can be the Internet.
 |
Fig. Two-tier Architecture
In the three-tier models,
commands are send to a "middle-tier" of services, which then send SQL
statements to the database. The database process the SQL statements and then
send the results back to the middle tier, which then sends them to the user.
MIS directors find the three-tier model very attractive because the middle tier
makes it possible to maintain control over access and the kinds of updates that
can be made to corporate data.
 |
 |
||
Client Server
Fig. Three-Tier Architecture
Until now the middle
tier has typically been written in languages such as C or C++, which offers
fast performance. However, with the introduction of optimizing compilers that
translate Java BYTECODE into efficient machine-specific code, it is becoming
practical to implement the middle tier in Java. This is a big plus, making it
possible to take advantage of Java's robustness, multithreading, and security features.
JDBC is important to allow database access from Java middle tier.
SQL PERFOMANCE:
Structured Query
Language (SQL) is the standard language for accessing relational databases. One
area of difficulty is that most DBMS use a standard form of SQL for basic
functionality, they do not conform to the most recently defined standard SQL
syntax or semantics for more advanced functionality. For example, not all
databases support stored procedure or outer joins, and those that do not
consistent with each other. It is hoped that the portion of SQL that is truly
standard will expand to include more and more functionality. In the mean time, the JDBC API must support
SQL as it is.
One way the JDBC API
deals with this problem is to allow any query string to be passed through to an
underlying DBMS driver. This means that application is free to use as much SQL
functionality as desired, but it runs the risk of receiving an error on some
DBMS. In fact, an application query need not even be SQL, or it may be a specialized
derivative of SQL designed for specific DBMS (for document or image queries,
for example).
A second way DBMS deals
with problems of SQL conformance is to provide ODBC-style clauses.
The escape syntax
provides a standard JDBC syntax for the several of more common areas of SQL
divergence. For example, there are escapes for date literal and for stored
procedure calls.
For example
applications, JDBC deals with SQL conformance in a third way. It provides
description information about the DBMS by means of the Database. MetaData
interface so that applications adapt to the requirements and capabilities of
each DBMS.
Because the JDBC will be
used ad a base API for developing higher-level database access tools and APIs,
it also has to address the problem of conformance for any thing built on it.
The designation "JDBC COMPLAINT" was created to set a standard level
of JDBC functionality on which the users can rely. In order to use this
designation, a driver must support at least, ANSI SQL-2 Entry level. (ANSI
SQL-2 refers to the standard obtained by the American National Standards
Institute in 1992. Enter level refers to a specific list of SQL capabilities.)
Driver developers can ascertain that their drivers meet these standards by
using the test suite available with the JDBC API.
The "JDBC
COMPLAINT" designation indicates that a vendor's JDBC implementation has
passed the conformance tests provided by JavaSoft. These performance tests
check for the existence of all the classes and methods defined in the JDBC API,
and check as much as possible that the SQL Entry Level functionality is
available. Such tests are exhaustive, of course, and JavaSoft is not currently
branding vendor implementations, but this compliance definition provides more
degree of confidence in a JDBC implementation. With wider and wider acceptance
of the JDBC API by database vendors, connectivity vendors, Internet Service
Vendors, and application writers, JDBC is quickly becoming the standard for
Java databases.
JDBC PRODUCTS:
At present, a number of
JDBC-based products have already been developed or under development. Of
course, the information in this section will quickly become dated, so one
should consult the JDBC web page
URL:http://www.javasoft.com/products/jdbc for the
latest information.
JavaSoft Frame work:
Java Soft provides three
JDBC product components as a part of the Java Development Kit (JDK):
·
the JDBC
driver manager
·
the JDBC driver test suit, and
·
the JDBC-ODBC bride
The JDBC driver manager is the
backbone of the JDBC architecture. It actually is quite small and simple; its
primary function is to connect the Java applications to the correct JDBC driver
and then get out of the way.
The JDBC driver test
suite provides some confidence that JDBC drivers will run your program. Only
drivers that pass the JDBC driver suite can be designated JDBC COMPLAINT.
The JDBC-ODBC bridge
allows ODBC drivers to be used as JDBC drivers. It was implemented as a way to
get JDBC off the ground quickly, and long term will provide a way to access
some of the less popular DBMS if JDBC drivers are not implemented for them.
JDBC DRIVER TYPES:
The JDBC drivers that
are available at this time fit into one of the four categories:
1.
JDBC-ODBC bridge plus ODBC driver: The JavaSoft bridge
product provides JDBC access via ODBC drivers. Note that ODBC binary code, and
in many cases database client code, must be loaded on each client machine that
uses this driver.
As a result, this kind is most
appropriate on a corporate network where client installations are not a major
problem, or for application server code written in Java in a three-tier
architecture.
2.
Native-API partly-Java driver: This kind of driver converts
JDBC calls into calls on the client API for Oracle, Sybase, Informix, DB2, or
other DBMS. Note that like the bridge driver, this style of driver requires
that some binary code be loaded on each client machine.
3.
JDBC-Net pure Java driver: This driver translates JDBC
call into DBMS-independent net protocol, which is then translated, to a DBMS
protocol by a server. This net middleware is able to connect its pure Java
clients to many different databases. The specific protocol used depends on the
vendor. In general, this is the most flexible JDBC alternative. It is likely
that all vendors of this solution will provide products suitable for Internet
use. In order for these products to also support Internet access, they must
handle the additional requirements for security, access through firewalls, and
so on, that the Web imposes. Several vendors are adding JDBC drivers to their
existing database middleware products.
4.
Native-protocol pure Java driver: This kind of driver
converts JDBC calls into the network protocol used by the DBMS directly. This
allows a direct call from the client machine to the DBMS server and is a
practical solution for Internet access. Since many of these protocols are
proprietary, the database vendors themselves will be the primary source, and
several database vendors have these in progress.
5.
Eventually, it is expected that driver categories 3
and 4 will be the preferred
way to access databases from JDBC. Driver
categories 1 and 2 are interim
solutions where direct pure Java drivers
are not yet available. There are
possibly variations on categories 1 and 2
that require a connector, but these are
generally less desirable solutions.
Categories 3 and 4 offer all the advantages of
Java, including automatic installation (for
example, downloading the JDBC
driver with an applet that uses it).
The following chart shows the four categories
and their properties:
DRIVER CATEGORY ALL JAVA NET PROTOCOL
1.
JDBC-ODBC bridge No Direct
2.
Native API as basis
No Direct
3.
JDBC- Net Connector
Yes Requires
4.
Native protocol as basis
Yes Direct
JDBC INTERFACES:
Connection Overview:
A connection object
represents a connection with a database. Connection session includes the SQL
statements that are executed and the results are returned over that connection.
A single application can have one or more connections with a single database,
or it can have connections with many different databases.
Opening a connection:
The standard way to
establish a connection with a database is to call the method
DriverManager.getConnection. This method takes a string containing a URL. The
DriverManager class, referred to as the JDBC manager layer, attempts to locate
a driver than it connect to the database represented by that URL. The
DriverManager class maintains a list of registered Driver classes, and when the
method getConnection is called, it checks with each driver in the list until it
finds one that can connect to the database specified in the URL. The driver
method connects uses this URL to actually establish the connection.
The user can by pass the
JDBC management layer and call driver methods directly. This could be useful in
the rare case that two drivers can connect to a database and the user user
wants to explicitly select a particular driver. Normally, however, it is much
easier to just let the DriverManager class handle opening a connection.
The following code
exemplifies opening a connection to a database located at the URL "jdbc:
ODBC: wombat" with the user ID of "oboy" and "12Java"
as the password:
String URL
= "jdbc: ODBC: wombat";
Connection
con=DriverManager.getConnection (url,"oboy","12Java");
DriverManager Overview:
The DriverManager class is the
management layer of JDBC, working between the user and the drivers. It keeps
track of the drivers that are available and handles establishing a connection
between a database and the appropriate driver. In addition, the DriverManager
class attends to things like driver login time limits and the printing of log
and tracing messages.
For simple applications,
the only method in this class that a general needs to use directly is
DriverManager.getConnection. As its name implies, this method establishes a
connection to a database. JDBC allows the user to call the DriverManager
methods getDriver, getDrivers, and registerDriver as well as the driver method
connect, but in most cases it is better to let the DriverManager class manage
the details of Establishing a Connection Statement:
Statement Overview:
A statement object is
used to send SQL statements to a database. There are actually three kinds of
statement objects, all of which act as containers for executing SQL statements
on a given connection: Statement, Prepared statement, which inherits form
statement, and callable statement, which inherits from prepared statement. They
are specialized for sending particular type of SQL statements; a Statement
object is used to execute a simple SQL statement with no parameters; a Prepared
Statement object is used to execute a precompiled SQL statement with or without
IN parameter; and a callable statement object is used to execute a call to the
database stored procedure.
The statement interface provides basic methods
for executing statements and retrieving results. The PreparedStatement
interface adds methods for dealing with IN parameters; CallableStatement adds
methods for dealing with OUT parameters.
|
SERVLETS USING JAVA WEB SERVER
One can
use Java programming statements to produce HTML output. The real power of Java,
however, is the wide array of classes available for use with any Java program.
HTML:
The HTML
Templates feature of the Java Web Server allows easily apply common elements
(“look and feel”) as well as common content to a set of HTML documents without
actually changing the HTML files themselves. All of these common items are
contained in a single file—called the template file.
ADVANTAGES:
The
obvious advantage of using the HTML Templates feature is that you can
establish, and later update, the way multiple files appear all from one
template file. This is especially helpful in cases where content is created
before the presentation is decided or when content from multiple origins must
be combined into some cohesive presentation. Rather than go back and edit all
those files, you simply create a template filewhich uniformly applies the
desired presentation elements.
Besides
the application of headers and footers to your HTML files, you can also define
body content to appear before or after the content of the source HTML
documents. This can be a simple but powerful way of including information.
What the
Java Web Server Does?
When a
browser requests a file from the Java Web Server that has been designated to
have the common elements of the default. Template applied, a special Java
servlet (Template Servlet) is called. The servlet uses the template information
to process the file. The resulting file, now reflecting the specified
appearance, is then passed to the browser. The file being displayed is not
actually changed on disk, only its appearance in the browser is changed. The
Java Web Server provides a sample default Template file, which uses
abbreviations defined
In the default definitions file. These sample files are in the
server_root/public_html/template directory.
File
Specification for Sample:
For the
sample, select the files in the /template directory as the set of the files
that you want the common elements specification applied.
To do this, in the Administration Tool:
1.
Select Web Service and click Manage
2.
Click Setup
3.
Select Servlet Aliases
4.
Scroll through the Alias column.
You should see / template
And, under the Servlets Invoked column,
template.
If there
is no entry for /template in the Alias column, select the last entry in the
Alias field, click Add. This will create a new entry space into which you
should type /template. Hit tab key to move to the Servlet Invoked column and
then type template.
|
Well – formed HTML File:
Be sure that your source HTML files (to which the templates will be
applied) are “we – formed”. This means
that the HTML is correctly formed with an opening <HTML> tag, a head
section enclosed by <HEAD></HEAD> tags, a body section enclosed by
<BODY></BODY> tags, and a closing </HTML> TAG. The template
servlet’s parser is very strict—if you don’t have proper markup, you may see
pages with no content.
The default template file
goes in the document base directory. In general, there needs to be only one
default template file per document set. However, like the default template
files, more can be used in subdirectories to override attributes present in the
parent default template file.
To use the Templates feature:
1.
Specify the Common Elements
Create a file with
named default template. This template file should he a well-formed HTML file
containing: opening HTML tag, a HEAD section, a BODY section, and a closing
HTML tag. Insert one or more presentations, elements into the desired locations
in the template file – just as you would insert these elements into any HTML
files.
Some of the
presentation elements we might want to apply to our files include Document
color scheme (for example, background color, text color, and link color).
Document layout (for example, a table of navigation links) A common header at
the start of each page (for example, the
product name). A common piece of the art work at the start of each page (for
example, the company or product logo)
A common footer at the end of each page
(for example, email address and fax number) The template file should also
contain the following tags :
A: In the HEAD
section, <subset data=”HEAD”></subst>
This is an HTML extension that the
TemplateServlet recognizes. It is a directive to the servlet to copy the
contents of the source document’s HEAD section into the HEAD section of the
template file
B: In the BODY section, <subset
data=”BODY”></subst>
This is another HTML extension that
the Template Servlet recognizes. It is a directive to the servlet to copy the
source document’s BODY into the BODY section of the template file. Because the
directive only copies the contents of the source file’s BODY section, and not
the BODY tag itself, the template’s own BODY tag can set with the desired
common attributes (background color,
text color, etc).
Anything outside the
HEAD and BODY sections of the source documents are ignored. In particular, this
means that frames information in the source document is not copied into the
template file. This template file, default template, should be placed in the
topmost directory containing HTML files to which you want the template applied.
1.
Make sure the Java Web Server has loaded the Template
Servlets in the Administration Tool:
a.
Select Web Service and click Manage
b.
Click the Servlets button
c.
Under Configure, scroll down to template
d.
Click on template
A tabbed notebook will
be shown. The Configuration of the notebook tells you the full class name of
the templates. These are also Loaded at Startup and Loaded Now entries on the
page, these should both indicates Yes. If they do not, then set them to Yes by
pressing the Yes radio button.
1.
Indicates the files to which the Templates should be
applied Specifying the files to which the template should be applied involves
using the Servlet Alias feature of the Java Web Server’s Administration Tool.
Brief instructions are provided below. For more information on mapping files or
directories top servlet aliases, see Servlet Alias.
To map a set of files to a
servlet alias, in the Administration Tool:
a.
Select Web Service and click Manage
b.
Click the Setup button.
c.
Double-click Servlet Aliases.
d.
In the Alias column, enter the / template directory or
a filename pattern (such as *html) to which the alias will apply.
e.
In the Servlet Invoked co lumen, type template. This
will map the directory to the servlet alias template.
Use of HTML Frames:
The template file cannot read in a
frame set from a source file because only the contents of the HEAD section and
the BODY section are copied. However, there is nothing to stop you from using
files processed by the template servlet as content in your own frame set.
Servlets:
Servlets provide a Java
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 BYTECODES 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, pluggable
helper byte code objects on the server side that can be used to dynamically
extend server-side functionality.
For example, an HTTP
servlet can be used to generate dynamic HTML content. When you use servlets to
do dynamic content.
Advantages:
They’re faster and cleaner than CGI scripts
They’re use a standard API (the Servlet API)
They
provide all the advantages of Java (run on a variety of servers without needing
to be rewritten)
The
Attractiveness of Servlets
There are many features of
servlets that make them easy and attractive to use. Servlets are:
1. Easily
configured using the GUI-based Administration Tool.
2. Loaded
and invoked from a local disk or remotely across the network.
3. Linked together, or chained, so that one servlet
can call another servlet, or several servlets in sequence.
4. Called
dynamically from within HTML pages, using server-side include tags.
5.
Secure-even when downloading across the network, the servlet security model and
servlet sandbox protects your system from unfriendly behavior.
The
Advantage of the Servlet API:
One of the great
advantages of the Servlets API is protocol dependence. It assumes nothing
about: The protocol being used to transmission the How it is loaded The server
environment it will be running in these
qualities are important, because it allows the Servlet API to be embedded in
many different kinds of servers. It’s
extensible – you inherit all your functionality from the base classes made
available to you. It’s simple, small,
and easy to use.
Servlets Features:
The Java Web Server
provides several important servlet features. These includes:
1.
Loading and Invoking Servlets: - Servlets can be
loaded both locally and remotely.
2.
Filters and Servlets Chaining: -The Java Web Server
uses mime types to call servlets sequentially.
3. Server-Side Includes: -Servlets can
be invoked from dynamic HTML documents using tags.
4.
Replacing CGI Script: - Servlets are an effective substitute for CGI
script, and provide a faster and cleaner way to generate dynamic document.
SERVLETS
Introduction to Servlets:
The JavaServer product
family provides servers that can be configured to run one or more services:
bodies of the code that implement an application – level protocol, such as FTP,
DHCP, OR SMTP. Servlets are modules that run inside request / response-oriented
services and extends them in some manner.
For example, an HTTP
services responds to its clients by delivering the HTML files they request. A
servlets can extend the capabilities of the HTTP services by taking the client
entered in an HTML order - entry form and applying the business logic servlets
to satisfy a request, if appropriate.
Servlets Architecture Overview:
The central abstraction
in the JSDK is the Servlets interface. All servlets implement this interface,
either directly or, more commonly, by extending a class that implements it such
as Http Servlets. The Servlet interface provides for 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: one is a Servlet Request and the
other is a Servlet Response. The Servlet Request class encapsulates the
communication from the client to the server, while the servlet Response class
encapsulates the communication from the servlet back to the client.
The Sevlet Request
interface allows the servlet access the 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 received it. It also provides the
servlet the access to the input stream, Servlet Input Stream, through which the
servlet gets data from clients that are using application protocols such as the
HTTP POST and PUT methods. Subclasses of Servlet Request allow the servlet to
retrieve more protocol-specific data. For example, Http Servlet Request
contains methods of accessing HTTP-specific header information.
The Servlet Response
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, and provides an
output stream, Servlet Output Stream, and a Writer through which a Servlet can
send the reply data. Subclasses of Servlet Response give the Servlet more
protocol-specific capabilities.
The classes and
interfaces described above make up a basic Servlet. HTTP Servlets have some
additional objects that over ride session tracking capabilities. The Servlet
Writer can use these API’s to maintain state between the Servlet and the client
that persists across multiple connections during some time period.
Servlet Lifecycle:
Services load and run
Servlets, which then accept zero or more requests from clients and return data
to them. They can also remove Servlets. They are the steps of a Servlets life
cycle. The next paragraph describes each step in more details, concentrating on
concurrency issues.
When a service loads a
Servlet, it runs the Servlets init method. Even though most Servlets are run in
multi-threaded services, there are no concurrency issues during Servlets
initialization. This is because the service calls the init method once, when it
loads the Servlet, and will not call it again unless it is reloading the
Servlet. The service can’t reload a Servlet until after it has removed the
Servlet by calling the destroy method. Initialization is allowed to complete
before client requests are handled (i.e. before the service method is called)
or the Servlet is destroyed.
After the service loads
and initializes the servlet, the servlet is able to handle client requests. It
processes them in its service method. Each client’s request has its call to the
service method in its own servlet thread: the method receives the client’s
request, and sends the client its response.
Servlets can run
multiple service methods at a time. It is important, therefore, that service
method be written in a thread-save manner. For example, if a service method
updates a field in the servlet object, that access should be synchronized. If,
for some reason, a service should not run multiple service methods
concurrently. The servlet should implement the SingleThreadModel interface.
This interface guarantees that no two threads will execute the servlets service
methods concurrently.
Servlets run until they
are removed from the service, for example, at the request of a system
administrator. When a service removes a servlet, it runs the servlet’s
destroyed method. The method is run once; the service will not run it again
until after it reloads and reinitializes the servlet. When the destroy method
runs, however, other threads might be running service requests. If, in cleaning
up, it is necessary to access shared resources (such as network connections to
be closed), that access should be synchronized.
During a servlet’s
lifecycle, it is important to write thread-safe code for destroying the servlet
and, unless the servlet implements the ingleThreadModel interface, servicing
client requests.
Lifecycle Methods:
Servlets that manage
resources do so by overriding the lifecycle methods init and destroy. These
servlets might need to be given argument at startup, in order to initialize
correctly.
Overriding the Init Method:
During initialization,
the servlet should prepare the resources it manages, to ready the servlet for
accepting service requests. It can do this without regard for multi-threading
concerns, since there is only a single thread running on behalf of the servlet
during initialization. As soon as the init method returns, the servlet can
receive client requests. If, for some reason, the servlet’s required resources
cannot be made available (for example, a required network connection cannot be
established), or some other initialization error occurs that would make it
impossible for the servlet to handle requests, the init method should throw an
Unavailable Exception exception.
The init method takes a
ServletConfig object as a parameter. The method should save this object, so
that it can be returned by the getServletConfig method. The simplest way to do
this is to have the new init method call super.init. If you don’t this, you
should store the ServletConfig object yourself, and override the
getServletConfig method so that it can obtain the object from its new location.
As you can see, this init method calls the
super. init method to manage the ServletConfig object. The init method also
sets a field, resultsDir, with the directory name that is provided as an initialization
parameter. It no directory name is provided, the servlet throws an unavailable
exception. If the init method completes successfully, the servlet can then
handled client’s requests.
Overriding the Destroy Method:
When a service unloads a
servlet, it calls the servlets destroy method. The destroy method should undo
any initialization work and synchronize persistent state with the current
in-memory state. This section begins with a description of how to write a
simple destroy method, then describes how to structure a servlet if threads
running its service method might still be running when the destroy method is
called.
Though
it is often the case that a servlet that overrides the init method must also
override the destroy method to undo that initialization, this is not required.
For example, the phone servlet, whose init method is used as an example, does
not have a corresponding destroy method. Because initialization involves
reading a file and using its contents to initialize a shared data structure,
there is no work to undo when the service is finished with the servlet.
|
OVERVIEW OF SERVLETS
Servlets provide a Java-based solution used to address the problems
currently associated with doing server-side programming, including in
extensible scripting solutions, platform-specific APIs, and incomplete
interfaces.
Servlets are objects that confirm 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, pluggable helper Byte Code objects on the server side that can be
used to dynamically extend server-side functionality.
For example, an HTTP servlet can be used to generate dynamic HTML
content. When you use servlets to do dynamic content you get the following
advantages:
1. They're faster and cleaner than
CGI scripts
2. They use a standard API (the
Servlet API)
3. They provide all the advantages
of Java (run on a variety of servers without needing to be rewritten)
The Attractiveness of Servlets:
There are many features of servlets
that make them easy and attractive to use. These include easily configured
using the GUI-based Admin Tool. Can be
loaded and invoked from a local disk or remotely across the network.
Can be linked together, or
chained, so that one servlet can call another servlet or several servlets in
sequence. Can be called dynamically from within HTML pages, using server-side
include tags. Are secure - even when downloading across the network, the
servlet security model and Servlet sandbox protect your system from unfriendly
behavior.
The Advantages of the Servlet API:
One of the great advantages of the Servlet API is protocol Independence
The protocol being used to transmit
on the net
How it is loaded
The server environment it will be
running in
These qualities are important,
because it allows the Servlet API to be embedded in many different kinds of
servers. There are other advantages to the Servlet API as well.
These
include: it's extensible - you can
inherit all your functionality from the base classes made available to
you. It’s simple, small, and easy to use
JAVA SERVLET FEATURES:
The Java
Server provides several important servlet features. These include Loading and
Invoking Servlets: Servlets can be loaded both locally and remote Filters and
Servlet Chaining: The Java Server uses mime types to call servlets
sequentially. Server-Side Includes: Servlets can be invoked from dynamic HTML
documents using server-side include tags. Replacing CGI Scripts: Servlets are
an effective substitute for CGI scripts, and provide a faster and cleaner way
to generate dynamic documents.
INTERNAL SERVLETS:
The Java TM Web Server TM servlet architecture is very flexible and the
server takes advantage of this by dividing its work among several internal
servlets. These are:
·
FILE
SERVLET :
The File Servlet provides the standard
document serving capabilities of Java Web Server. This servlet includes a caching mechanism to
speed up response times for frequently accessed files.
·
INVOKER
SERVLET :
The purpose of this servlet is to invoke other servlets which are
explicitly requested by name, that is http://<server-host-name>/servlets/<servlet
name.
·
Server Side
Include Servlet :
Servlets
can be embedded within HTML documents using the servlet tag. When the server detects the servlet tag, it
loads the servlet if necessary, invokes
that servlet, and sends the output of the servlet to the client at the point
where the servlet tag was embedded.
·
Admin
Servlet :
The Admin servlet facilitates
administration of the Java web server through a GUI front end the
Administration Tool.
·
CGI Servlet
:
This
servlet acts as a gateway for the CGI 1.1 interface. This servlet allows any program that utilizes
the CGI 1.1 standard to operate under Java Web Server.
SYSTEM COFIGURATION
Software
Details
Server Operation System
Windows
NT Server
Client Operating System
Windows
NT Work Station
Languages
Used:
Java
2.0(Servlets, Jdbc, ODBC, JavaWebServer3.0)
Java Script,
HTML,
DataBase :
MSACCESS.
Hardware
Details
Server
PENTIUM III 500 MHz, With Dual Processor
128MB
RAM
256
KB EXTERNAL CACHE MEMORY
17
GB HARD DISK
32
BIT ETHER NET
SVGA
COLOR MONITOR
MICROSOFT
MOUSE
108
WINDOWS’95 KEYBOARD
Client
PENTIUM II 500 MHz
64
MB RAM
256
KB EXTERNAL CACHE MEMORY
8
GB HARD DISK
32
BIT ETHERNET
SVGA
COLOR MONITOR
LOGITECH
MOUSE
105
WINDOWS’95 KEYBOARD
LOGICAL DESIGN
Logical design is a process through
which requirements are translated into a representation of software. Initially
the representation depicts a holistic view of software. Subsequent refinement
leads to a design representation that is very close to source code.
The conceptual structure of a
database is called a schema. Schema shows the kinds of data that exists in a
database and how the kinds of data are logically related to each other. A
schema can be regarded as a blueprint that portrays both kind of data used in
building a database and logical relationship that exist among various kinds of
data. At the minimum, the schema must represent all needed data items, must
correctly represent their interrelationships, and must be able to support all
reports. Schema is frequently depicted pictorially using Data Flow Diagrams
(DFD).
Data Flow Diagrams
Data Flow
Diagrams (DFD) depicts information flow and transforms that are applied as data
move from input to output. The DFD is also known as Data Flow Graph or Bubble
Chart. It is the starting point of the design phase that functionality
decomposes the requirement specification down to the lowest level of details.
Thus, a DFD describes what data flows (logical) rather than how they are
processed.Data Flow Diagrams are made up of number of symbols which represent
system components. Data Flow modeling methods used for kinds of symbols. These
symbols are used to represent four kinds of system components. Processes, Data
Stores, External entities, and Data flows.
Processes
Processes
show what system does. Each process has one or more data inputs and produces
one or more data outputs. Processes are represented by round rectangles in DFD.
Data Stores
A file or
data stores is repository of data. Processes can enter data into a store or
retrieve data from data store. The line in the DFD and each store represents
each data store as a unique name.
External Entities
External
entities are outside the system but they supply either input data into the
system or used for the system output. They are entities on which the designer
has no control. There may be an organization or other bodies with which system
interacts.
Data Flows
Data Flows
model the passage of data on the system and represented by the lines joining
the system components. An arrow indicates the direction of flow and line is
labeled by the name of data flow. Flow of data in the system can take place
Ø Between two
processes
Ø From a data
store to a process
Ø From a
process to a process
Ø From source
to a process
Ø From a
process to a sink.
Architectural View of Global
Communication
 |
DFD For Server
 |
|
 |
|||
 |
|||
DFD
For Client
 |
DATABASE DESIGN
1. Table Name: Necdata
Function : Contains
information of clients.
Table Description
:
|
Column
|
Definition
|
Description
|
|
Empname
|
Char(20)
|
Name of the Client
|
|
Dateandtime
|
Date/Time
|
Time of joining
|
|
Emailid
|
Text(50)
|
Mail id of the Client
|
FORM DESIGN
The various input forms and their processing is
given below:
1: Server
Login Screen:
Purpose:
The purpose of the screen is to allow the
administrator to enter into the system.
Details:
·
The Edit boxes are used to enter the username and password.
·
The ok button is used to login into the system.
·
The cancel button is used to clear the text box giving
Permission to login
again.
Screen Design:
2. Employee
Details:
Purpose
The purpose of this screen is to give details of
employees formatted in the html table, to the administrator.
Details
· This table contains three columns.
· The
first column in the table gives employee names
· The second column of this table gives us
employees joining time in the
Company.
· The third column of this table gives us
employees mail id details.
· The ok button is used to go to next screen.
Screen Design
Processing
Empnames will be collected from the table
necdata2 which is created in the MsAccess giving Jdbc connection.
Screen fields
and their data source/destination
The following table gives
the employee names from the table necdata.This table correlates between the
screen and the database.
|
Column
|
Definition
|
Description
|
|
Empname
|
Char(20)
|
Name of the Client
|
|
Dateandtime
|
Date/Time
|
Time of joining
|
|
Address
|
Text
|
Area of Emp
|
|
Occupation
|
Text
|
Designation
|
|
Organisation
|
Text
|
Company
|
|
Emailid
|
Text(50)
|
Mail id of the Client
|
|
Uid
|
Text
|
Userid for login
|
|
Pwd
|
Text
|
Password for login
|
3. Adding
Users TO Conference:
Purpose
The purpose of this screen is to call employees to
conference.
Details
·
The select box will get data from the table, which is created in
MsAccess.
·
The add button will add all selected employees to conference and will
call the next added screen.
Screen Design
Processing
Empnames will be collected from the table
necdata2 which is created in the MsAccess giving Jdbc connection.
Screen fields
and their data source/destination
The following table gives
the employee names from the table necdata2.This table correlates between the
screen and the database.
|
Screen
Variable
|
Database
Field
|
|
Empname
|
Empname
|
4. Conference
List:
Purpose
This screen will give us the final conference list.
Details:
·
The Select box will get final list of employees who are allowed for
participation.
5. Client
Login Screen:
Purpose:
The purpose of the screen is to allow accessible
clients to enter into the system .
Details:
·
The Edit boxes are used to enter the username and password.
·
The ok button is used to verify their name and password.
·
The cancel button is used to clear the text box giving
Permission to login
again.
Screen Design:
6. Conference
Screen:
Purpose:
The purpose of this screen is to allow the clients
to communicate with other persons in the conference.
Details:
·
The select box will give the list of online users in the conference.
·
The text area will display the list of messages that the particular
client has received.
·
The Edit box is used to type the messages to communicate with the other
persons in the conference.
·
The send button is used to send the message that has typed in the text
box to selected persons.
·
The add button is used to get the next screen to add the clients to
conference.
·
The close button is used to come out of the conference screen.
Screen Design:
SYSTEM
TESTING
Software
testing is a critical element of software quality assurance and represents the
ultimate review of software specification, design and coding. The increasing
visibility of software as a system element and the attendant “costs” associated
with a software failure are motivating forces for well planned, thorough
testing. It is not unusual for software. Development organization to expend 40
percent of total project effort on testing. Hence the importance of software
testing and its implications with respect to software quality can not be
overemphasized. Different types of testing have been carried out for this
system, and they are briefly explained below.
Types of Testing:
Two main types of testing
have been carried out to ensure that this system is a quality product, namely
the Unit Testing and Integration
Testing.
Unit Testing:
Unit
Testing focuses verification effort on the smallest unit of software design
module. Using the detailed description as a guide, important control paths are
tested to uncover errors within the boundary of the module. The various modules
that have undergone types of input data were given to ensure the consistency of
the module and to ensure that information properly flows into and out of the
program unit under test. The database integrity is validated during all steps
in the execution.
Integration Testing:
Integration
testing is a systematic technique for constructing the program structure while
at the same time conducting tests to uncover errors associated with
interfacing. The objective is to take unit-tested modules and build a program
structure that has been detected by design. There are two types of integration testing
namely, Top-Down Integration and Bottom-Up Integration. For the system a
combination of both the types known as Sandwich
Testing has been used. The Top-Down Integration was used during the
integration of the various Masters and the Bottom-up Integration method was
used during the integration of the various modules of the process generation
and the report generation.
The
various validations done in this system are given below:
Server Login Screen:
·
The company administrator name is checked whether it
is valid name or not. If he is not a valid person he can not enter into the
system to call employees to conference.
·
The password entered by the administrator will be
checked with the password set by the system. If it is incorrect he can not
login into the system, and also he will get a message like u are not
authenticated to server.
·
If he is a valid person he will get the list of
employees so that he can call require persons to the conference.
Client Login Screen:
·
The client name is checked, whether it exists in the
client details table of the database. If it is invalid he can not enter into
the system to participate in the conference.
·
The password entered by the client will be checked
with the respective client, if it is incorrect then he will get a message like
you are not an authenticated client. When the client name and password is
correct he can enter into the system to participate in the conference.
·
If he is a valid person he will get the list of
employees selected by system administrator. So that he can select required
person to communicate with them.
SYSTEM IMPLEMENTATION
After proper testing and validation,
the question arises whether the system can be implemented or not.
Implementation includes all those activities that take place to convert from
the old system to the new. The new system may be totally new, replacing an
existing module or automated system, or it may be a major modification to an
existing system. In either case proper implementation is essential to provide a
reliable system to meet organization requirements.
All planning has now, be completed
and the transformation to a fully operational system can commence. The first
job will be writing, debugging documenting of all computer programs and their
integration into a total system. The master and transaction files are decided,
and this general processing of the system are established. Programming is
complete when the programs confirmed to the detailed specification.
When the system is ready for
implementation, emphasis switches to communicate with the finance department
staff. Open discussion with the staff is important from the beginning of the
project. Staff can be expected to be concerned about the effect of the
automation on their jobs and the fear of redundancy or loss of status must be
allayed immediately. During the implementation phase it is important that all
staff concerned be appraised of the objectives of overall operation of the
system. They will need shinning on how computerization will change their duties
and need to understand how their role relates to the system as a whole. An
organization-training program is advisable, this can include demonstrations,
newsletters, seminars etc.
The department should allocate a
member of staff, who understands the system and the equipment, and should be
made responsible for the smooth operation of the system. An administrator
should coordinate the users to the system.
Users should be informed about new
aspects of the system that will, affect them. The features of the system
explained with the adequate documentation. New services such as security,
on-line application form and back-ups must be advertised on the staff when the
time is ripe.
Existing documents such as employee
loan details should be entered into the new system. Since these files are very
large, conversion of these may continue long after the system based on current
files has been implemented. Hence we need to assign responsibility for each
activity.
The system may come into full
operation via number of possible routes. Complete change over at one point time
is conceptually the most tidy. But this approach requires careful planning and
coordination, particularly during the changeover. A phased approach, possible
implementing the system of the section relating to one operation or procedure
first and progressing to more novel or complex subsystems in the fullness of
time. These likely to be less traumatic. A phased approach gives the staff time
to adjust to the new system. But depends on being able to split the system,
without reliance on it. Thus approach is sensible when the consequences of
failure are disastrous, but will require extra staff time. The fourth angle, is
pilot operation permits any problems to be tackled on a smaller scale operation.
Pilot operation generally means the implementation of the complete system, but
at one location or branch only.
INSTALLATION AND MAINTENANCE
The Global
Communication project can be installed on the computer using the following
steps:
Creatr dsn:
click
start-> run | give 'odbcad32.exe'
click ADD button on the 'ODBC Data Source Administrator' give DataSource
name as 'GCM' and select the path of the .mdb file by clicking select button
to set the
classpath
set
classpath=C:\jakarta-tomcat-5\dist\common\lib\servlet-api.jar;%classpath%;.;
create
WEB-INF folder and place web.xml file
in web.xml
file write according to the classes present in the project
ex....:-
<web-app>
<servlet>
<servlet-name>ac</servlet-name>
<servlet-class>ac</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>ac</servlet-name>
<url-pattern>/ac</url-pattern>
</servlet-mapping>
</web-app>
============================
javac -d
./WEB-INF/classes *.java
jar -cvf
servlet.war WEB-INF *.html *.class
start
startup.bat from C:\jakarta-tomcat-5\dist\bin
after
running server........
Open
InternetExplorer
give url
:-= http://localhost:8081/manager/html
if it asks
for andy username and password give
username=admin
password=admin
See In the
applications menu whether the path '/servlet' is existing or not
if it
exisists undelopy it using undeploy on
the same line .....
After that
go to deloply war file menu
select the
servlet.war file then click deploy
before
running the project run the server
start java
CommServer
The Hardware and System Requirements
To run the
project, certain hardware and software has to be installed on the system. The
system requirements include
·
Microsoft Windows NT workstation.
·
80486 of higher microprocessor.
·
A hard disk with a minimum of 50 megabytes available
space for a full installation.
·
SVGA or higher-resolution screen supported by
Microsoft Windows.
·
32 MB RAM.
·
1.44’’ floppies drive.
·
A mouse or other suitable pointing device.
Starting Global Communication:
Once the
setup procedure has been completed, Global Communication can be started by
using, the start button in the task bar in Windows NT workstation. By selecting
Netscape navigator or Internet Explorer version2.5 on wards we can run our
project. Before running our project we should run Tomcat Server. To run this
Server we should run this in dos prompt by selecting startup from bin in the
explore session. This Server should run till the end of our project. To check this Server in explorer we should give our
path and system port number. This is the procedure to run our project
successfully.
CONCLUSION
The objective of this project is to
conduct conferences on the Internet or Intranet. Instead of conducting
conferences in some places by using this project they can participate in
conference in their house itself by using their PC.
By using
this project they can
Ø Conduct
conferences with their employees. So they can get online decisions from
employees from the different branches of the company.
Ø The another
advantage is that the company is having branches throughout the country. So
this will help them to communicate business affairs of the company and live
meetings and conferences between their directors. They can conduct board of
directors meeting.
Ø It will
give On-line solutions from the superiors to the employees.
Likely
there are so many advantages by developing this conference on the net.
SCOPE FOR
THE FUTURE
Ø Over a period of time the Global Communication
Project can be implemented to provide audio.
Ø It can be implemented to provide video.
BIBLIOGRAPHY
·
Patrick
Naughton and Herbert Shildt , “
The complete reference Java 2.0.
·
Joseph L.
weber, ‘ Using Java 2.0 ‘ , PHI
Publishers.
·
Karl Moss, ‘
Java Servlets ‘.
·
Jason Hunter with William Crawford , ‘Java Servlet Programming ‘ SPD publications.
·
Tom Negrino and Dori smith, “ Java Script For The world Wide Web”.
·
Roger S Pressman,
‘ Software Engineering’ , McGraw Hill Inc., 3rd Edition, 19998.
·
Jeffrey Ritcher, ‘Adwanced Windows NT’, Microsoft
Press, 1998.
·
David A. Solomon, ‘Inside Windows NT’, Microsoft
Press, Second Edition-1998.
CommServer
No comments:
Post a Comment