"J" Networking Definitions & Concepts...

J2EE .. to .. Jumper

Search for Information Technology Items

The Java 2 Platform Enterprise Edition (J2EE) offers great promise for dramatically improving the way enterprise applications are built, and organizations that have adopted the J2EE are gaining a competitive advantage. The industry-standard Unified Modeling Language (UML) has helped countless organizations achieve sortware success through visual modeling. Together, the UML and J2EE form a powerful set of tools, but the intricacies involved with using them in tandem are considerable.

Java 2 Platform, Enterprise Edition (J2EE) from Sun Microsystems defines an environment suitable for the development, deployment, and management of enterprise applications written in the Java language.

Services are specified which are to be provided by platform implementers, in turn providing a standard set of Java APIs for the application developer. Applications developed to the J2EE specification should be deployable across all J2EE platform implementations in a transparent, platform-neutral manner.

J2EE^TM technology and its component based model simplifies enterprise development and deployment. The J2EE platform manages the infrastructure and supports the Web services to enable development of secure, robust and interoperable business applications. The J2EE platform is the foundation technology of the Sun ONE platform and Sun's Web services strategy.

Stands for Java 2 Platform, Enterprise Edition. This is a standardized specification for building Web-based enterprise applications. J2EE services are performed in the middle tier between the user's browser and the enterprise's databases and legacy information systems. J2EE comprises a specification, reference implementation and set of testing suites. Its core component is Enterprise JavaBeans (EJBs), followed by JavaServer Pages (JSPs) and Java servlets and a variety of interfaces for linking to the information resources in the enterprise.

J2EE software revolutionized computing with a stable, secure and feature-complete platform designed from the ground up for the Web. J2EE software allows developers to rapidly develop and deploy solutions across multiple operating environments, in less time, with reduced cost. Most important, J2EE software protects existing and future technology investments by deploying on a platform based upon open standards and endorsed by a strong Java community.

To reduce costs and fast-track enterprise application design and development, the Java 2 Platform, Enterprise Edition (J2EE) technology provides a component-based approach to the design, development, assembly, and deployment of enterprise applications. The J2EE platform offers a multitiered distributed application model, the ability to reuse components, integrated Extensible Markup Language (XML)-based data interchange, a unified security model, and flexible transaction control. Not only can you deliver innovative customer solutions to market faster than ever, but your platform-independent J2EE component-based solutions are not tied to the products and application programming interfaces (APIs) of any one vendor. Vendors and customers enjoy the freedom to choose the products and components that best meet their business and technological requirements.

The J2EE platform uses a multitiered distributed application model. Application logic is divided into components according to function, and the various application components that make up a J2EE application are installed on different machines depending on the tier in the multitiered J2EE environment to which the application component belongs. Figure 1-1 below shows two multitiered J2EE applications divided into the tiers described in the following list. The J2EE application parts shown in Figure 1-1 are presented in J2EE Components.

• Client-tier components run on the client machine.
• Web-tier components run on the J2EE server.
• Business-tier components run on the J2EE server.
• Enterprise information system (EIS)-tier software runs on the EIS server.

Although a J2EE application can consist of the three or four tiers shown in Figure 1-1, J2EE multitiered applications are generally considered to be three-tiered applications because they are distributed over three different locations: client machines, the J2EE server machine, and the database or legacy machines at the back end. Three-tiered applications that run in this way extend the standard two-tiered client and server model by placing a multithreaded application server between the client application and back-end storage.

J2EE Components: J2EE applications are made up of components. A J2EE component is a self-contained functional software unit that is assembled into a J2EE application with its related classes and files and that communicates with other components. The J2EE specification defines the following J2EE components:

• Application clients and applets are components that run on the client.
• Java Servlet and JavaServer Pages (JSP) technology components are Web components that run on the server.
• Enterprise JavaBeans (EJB) components (enterprise beans) are business components that run on the server.

J2EE components are written in the Java programming language and are compiled in the same way as any program in the language. The difference between J2EE components and "standard" Java classes is that J2EE components are assembled into a J2EE application, verified to be well formed and in compliance with the J2EE specification, and deployed to production, where they are run and managed by the J2EE server.

J2EE Clients: A J2EE client can be a Web client or an application client.

Web Clients: A Web client consists of two parts: dynamic Web pages containing various types of markup language (HTML, XML, CFML, and so on), which are generated by Web components running in the Web tier, and a Web browser, which renders the pages received from the server.

A Web client is sometimes called a thin client. Thin clients usually do not do things like query databases, execute complex business rules, or connect to legacy applications. When you use a thin client, heavyweight operations like these are off-loaded to enterprise beans executing on the J2EE server where they can leverage the security, speed, services, and reliability of J2EE server-side technologies.

Applets: A Web page received from the Web tier can include an embedded applet. An applet is a small client application written in the Java programming language that executes in the Java virtual machine installed in the Web browser. However, client systems will likely need the Java Plug-in and possibly a security policy file in order for the applet to successfully execute in the Web browser.

Web components are the preferred API for creating a Web client program because no plug-ins or security policy files are needed on the client systems. Also, Web components enable cleaner and more modular application design because they provide a way to separate applications programming from Web page design. Personnel involved in Web page design thus do not need to understand Java programming language syntax to do their jobs.

Application Clients: A J2EE application client runs on a client machine and provides a way for users to handle tasks that require a richer user interface than can be provided by a markup language. It typically has a graphical user interface (GUI) created from Swing or Abstract Window Toolkit (AWT) APIs, but a command-line interface is certainly possible.

Application clients directly access enterprise beans running in the business tier. However, if application requirements warrant it, a J2EE application client can open an HTTP connection to establish communication with a servlet running in the Web tier.

JavaBeans Component Architecture: The server and client tiers might also include components based on the JavaBeans component architecture (JavaBeans component) to manage the data flow between an application client or applet and components running on the J2EE server or between server components and a database. JavaBeans components are not considered J2EE components by the J2EE specification.

JavaBeans components have instance variables and get and set methods for accessing the data in the instance variables. JavaBeans components used in this way are typically simple in design and implementation, but should conform to the naming and design conventions outlined in the JavaBeans component architecture.

J2EE Server Communications: Figure 1-2 below, shows the various elements that can make up the client tier. The client communicates with the business tier running on the J2EE server either directly or, as in the case of a client running in a browser, by going through JSP pages or servlets running in the Web tier.

Your J2EE application uses a thin browser-based client or thick application client. In deciding which one to use, you should be aware of the trade-offs between keeping functionality on the client and close to the user (thick client) and off-loading as much functionality as possible to the server (thin client). The more functionality you off-load to the server, the easier it is to distribute, deploy, and manage the application; however, keeping more functionality on the client can make for a better perceived user experience.

Web Components: J2EE Web components can be either servlets or JSP pages. Servlets are Java programming language classes that dynamically process requests and construct responses. JSP pages are text-based documents that execute as servlets but allow a more natural approach to creating static content.

Static HTML pages and applets are bundled with Web components during application assembly, but are not considered Web components by the J2EE specification. Server-side utility classes can also be bundled with Web components and, like HTML pages, are not considered Web components.

Like the client tier and as shown in Figure 1-3 below, the Web tier might include a JavaBeans component to manage the user input and send that input to enterprise beans running in the business tier for processing.

Business Components: Business code, which is logic that solves or meets the needs of a particular business domain such as banking, retail, or finance, service support is handled by enterprise beans running in the business tier. Figure 1-4 below shows how an enterprise bean receives data from client programs, processes it (if necessary), and sends it to the enterprise information system tier for storage. An enterprise bean also retrieves data from storage, processes it (if necessary), and sends it back to the client program.

There are three kinds of enterprise beans: session beans, entity beans, and message-driven beans. A session bean represents a transient conversation with a client. When the client finishes executing, the session bean and its data are gone. In contrast, an entity bean represents persistent data stored in one row of a database table. If the client terminates or if the server shuts down, the underlying services ensure that the entity bean data is saved.

A message-driven bean combines features of a session bean and a Java Message Service ("JMS") message listener, allowing a business component to receive JMS messages asynchronously. This tutorial describes entity beans and session beans. For information on message-driven beans, see The Java Message Service Tutorial, available at

Java Message Service Tutorial

Enterprise Information System Tier:

The enterprise information system tier handles enterprise information system software and includes enterprise infrastructure systems such as enterprise resource planning (ERP), mainframe transaction processing, database systems, and other legacy information systems. J2EE application components might need access to enterprise information systems for database connectivity, for example.

( J ava 2 Platform, E nterprise E dition) A platform from Sun for building distributed enterprise applications. J2EE services are performed in the middle tier between the user's machine and the enterprise's databases and legacy information systems. J2EE comprises a specification, reference implementation and set of testing suites. Its core component is Enterprise JavaBeans (EJBs), followed by JavaServer Pages (JSPs) and Java servlets and a variety of interfaces for linking to the information resources in the enterprise.

The J2EE interfaces include JDBC for databases, JNDI for directories, JTA for transactions, JMS for messaging, JavaMail for e-mail systems and JavaIDL for CORBA connectivity. In December 1999, J2EE Version 1.2 was introduced as the first formal release of the specification. In September 2001, Version 1.3 was released. Java Connectors are interfaces to a variety of legacy applications. See EJB , JSP , servlet , Java Connector , Java 2 and J2ME .

Pure J2EE Environment

This is a fully compliant J2EE Web server and application server environment showing the interfaces to all information sources in the enterprise. This is an "ideal" Java-only deployment. In practice, other server-side scripts and applications may be used as in the illustration below.

Mixed Environment

In practice, Web servers and application servers use a variety of server-side processing techniques. This illustration depicts the various methods.

Jabber is a random transmission of data on a shared network cable by a faulty transceiver at a network node. The random data can corrupt the transmission of other stations. A jabber control function in the device is used to inhibit further transmissions if a certain time is exceeded that corresponds to the transmitted frame size.

If a network is flooded with garbage data, a transceiver or a network card with built-in transceiver may be bad. You can use the testing tools discussed under "Testing Equipment and Technologies" or a management system to isolate the problem. Alternatively, on small networks you can remove stations or segment the network to determine which side still has the garbage data, then further segment it until you locate the source of the problem.

In a network that uses the CSMA/CD media access method, a device that helps prevent a node from transmitting constantly (for example, if the node is malfunctioning).

In an Ethernet network, a meaningless transmission generated by a network node because of a network malfunction (such as a faulty transceiver) or other error. A jabber packet is larger than the maximum size (1,518 bytes for Ethernet) and contains a bad CRC value. In contrast, long frames exceed the maximum frame length, but have a valid CRC value.

In regards to collision handling, if a collision occurs, the physical layer notifies the link management, which then transmits a bit sequence call a jam. This sequence ensures that every station on the network recognizes the collision. The transmit link management then terminates the transmission it started and schedules a retransmission attempt after a calculated amount of time. If there are repeated collisions, the link management uses a process called backing off, which involves increasing the time waited before retransmission followed each successive collision. The method used to determine the amount of time to wait is the binary exponential backoff method described for the IEEE 802.3 CSMA/CD standard. On the receiving side, the link management is responsible for recognizing and filtering out fragments of frames that resulted from a transmission that was interrupted by a collision. Any frame that is less than the minimum size is assumed to be a collision fragment. These fragments are not reported to the client layer as errors.

The Japanese counterpart to ANSI (American National Standards Institute) in the United States or to the CSA (Canadian Standards Association) in Canada.

A research network for noncommercial institutions and organizations.

The Java programming language and environment was designed by Sun Microsystems to solve a number of problems in modern programming practice. It started as part of a larger project to develop advanced software for consumer electronics. These devices are small, reliable, portable, distributed, real-time embedded systems. When Sun started the project, it intended to use C++, but encountered a number of problems. Initially, these were just compiler technology problems, but as time passed, the company encountered other problems that were best solved by changing the language.

Java is a simple, object-oriented, distributed, interpreted, robust, secure, architecture-neutral, portable, high-performance, multithreaded, and dynamic language.

Most programmers these days use C, and most programmers doing object-oriented programming use C++, which requires a lot of training. Java was designed to be as close to C++ as possible in order to make the system more comprehensible; yet it is very simple and easy to program with. Java omits many rarely used, poorly understood features of C++ that in many cases bring more grief than benefit. A good example of a common source of complexity in many C and C++ applications is storage management, i.e., pointers: the allocation and freeing of memory. By virtue of having automatic garbage collection, the Java language not only makes the programming task easier, it also cuts down on bugs. Another aspect of being simple is being small. One of the goals of Java is to enable the construction of software that can run as stand-alone in small machines. The size of the basic interpreter and class support is about 40KB.

Object-oriented design is very powerful because it facilitates the clean definition of interfaces and makes it possible to provide reusable "software pieces". Simply stated, object-oriented design is a technique that focuses design on the data (objects) and on the interfaces to it.

Distributed, Java has an extensive library of routines for coping easily with TCP/IP protocols such as HTTP and FTP. Java applications can open and access objects across the net via URLs with the same ease that programmers are used to when accessing a local file system. Java is intended for writing programs that must be reliable in a variety of ways. Java puts a lot of emphasis on early checking for a possible problem, later dynamic (run-time) checking, and eliminating situations that are error-prone.

Java is intended to be used in networked/distributed environments. Toward that end, a lot of emphasis has been placed on security. Java enables the construction of systems more resistant to viruses, tampering, or infiltration (but it remains to be seen if these techniques are totally temperproof). The authentication techniques are based on public-key encryption.

The History of Java

People often speak of "Dog Years" to refer to things happening seemingly faster than real time. Java's history is much like this. In the years between (1995-1997), Java has gone from being a fad to becoming a solid programming environment that companies are using to develop commercially viable aplications.

The Java programming language was created by James Gosling and other engineers at Sun Microsystems. It was developed in 1991, as part of the Green Project, and officially announced on May 23, 1995, at SunWorld; being released in November. Java was initially designed as a replacement to C++ (although the feature set is more similiar to Objective C) and known as Oak (in honour of a tree outside Gosling's office); however, Oak was previously copyrighted. Java is owned by Sun Microsystems; the term Java is a trademark of Sun Microsystems.

In case you blinked, here is a brief history of Java in review:

The JavaBeans white paper defines a Bean as follows:

A Java Bean is a reusable sofware component that can be manipulated visually in a builder tool.

As of this writing (June 1997), the only tool available for the Mac which comes close to implementing a the spirit of JavaBeans is Symantec Visual Café.

Well, if you have to sum it up in one sentence, this is as good as any. But it's pretty difficult to sum up an entire component architecture in one sentence. Beans will range greatly in their features and capabilities. Some will be very simple and others complex; some will have a visual aspect and others won't. Therefore, it isn't easy to put all Beans into a single category. Let's take a look at some of the most important features and issues surrounding Beans.

The high level concept is simple -- there is a modular component architecture for the creation of developer components. Although some mention is made of JavaBeans as a compound document architecture, there is virtually no support for end user manipulation.

JavaScript, formerly called LiveScript, is a programming language for adding functionality and features to HTML pages. JavaScript scripts are embedded in HTML files and run on the browser side. JavaScript is a Netscape innovation that has the suport of many other commercial organizations, but, like many Netscape enhancements, it currently runs only on Netscape and Microsoft browsers.

Netscape's JaveScript, a scripting language, has only a passing resemblance to Sun Microsystem's Java programming language, but because of the names the two are easily confused. JavaScript is a simple language that works only in Web browsers; Jave is a more comprehensive programming language that can be used just about anywhere.

According to the press release made jointly by Netscape communications and Sun Microsystems, "JavaScript is an easy-to-use object scripting language designed for creating live online applications that link together objects and resources on both clients and servers. JavaScript is designed for use by HTML page authors and enterprise application developers to dynamically script the behavior of objects running on either a client or server."

Put simply, what this means is that by using JavaScript, you can add functionality to your Web pages, which in the past would have demanded access to complex CGI-based programs on a Web server. In many ways, JavaScript is a lot like Visual Basic -- the user-friendly programming languge developed by Microsoft -- in that even if you have little or no programming knowledge, you can use JavaScript to create complex Web-based applications.

What makes JavaScript different, however, is the unique way in which it integrates itself with the World Wide Web. Instead of being stored as a separate file -- like a CGI script -- JavaScript code is included as part of a standard HTML document, just like any other HTML tags and elements. In addition, unlike CGI scripts, which run on a Web Server, JavaScript scripts are run by the Web browser itself. Thus they are portable across any Web b rowser that includes JavaScript support, regardless of the computer type or operating system.

In summary, JavaScript is not the same as Java. It is a scripting tool created by Netscape and Sun (as stated above) to insert code statements directly into the hypertext markup language (HTML) of a web page, adding functionality and improving the overall appearance and/or function of the Web page.

A set of library routines specific to the Java language that allows a Java application to easily connect to and process SQL statements aginst an Oracle and other SQL databases.

JDBC is a Java Database connectivity API that lets you access virtually any tabular data source from a Java application. In addition to providing connectivity to a wide range of SQL databases, JDBC allows you to access other tabular data sources such as spreadsheets or flat files. Although JDBC is often thought of as an acronym for Java Database Connectivity, the trademarked API name is actually JDBC.

JDBC defines a low-level API (Application Programming Interface) designed to support basic SQL functionality independently of any specific SQL implementation. This means the focus is on executing RAW SQL staements and retrieving their results. JDBC is based on the X/Open SQL Call Level Interface, an international standard for programming access to SQL databases, which is also the basis for Microsoft's ODBC interface.

The JDBC 2.0 API includes two packages: java.sql, known as the JDBC 2.0 core API; and javax.sql, known as the JDBC Standard Extension. Together, they contain the neccessary classes to develop database applications using Java. As a core of the Java 2 Platform, the JDBC is available on any platform running Java.

The JDBC 3.0 Specification, released in Octorber 2001, introduces several features, including extensions to the support of various data types, additional MetaData capabilities, and ehancements ot a number of interfaces.

The JDBC Extension Package (javax.sql) was introduced to contain the parts of the JDBC API that are closely related to other pieces of the Java platform that are themselves optional packages, such as the Java Naming and Directory Interface (JNDI) and the Java Transaction Services (JTS). In addition, some advanced features that are easily separable from the core JDBC API, such as connection pooling and rowsets, have been added to javax.sql. Putting these advanced facilities into an optional package instead of into the JDBC 2.0 core API helps to keep the core JDBC API small and focused.

In signaling, a variation in the timing between the source's and receiver's clocks or in the constancy of the source clock rate. Phaser jitter can cause the signal to be slightly out of phase. In amplitude jitter, the amplitude of a signal varies over time.

Frequently the data you want resides in two or more tables in your database. The two ways to accomplish this retreeval are using joins and unions. Let's look first at joins.

Suppose you want to query all the movie titles in the Action genre, and you know that the GenreID for Action is 1. You would use the following query:

SELECT TitleID, Title
FROM Title
WHERE GenreID = 1

A jukebox is an optical disk device that can automatically load and unload optical disks and provide as much as 500 gigabytes of near-line information. The devices are often called optical disk libraries, robotic drives, or autochangers. Jukebox devices may have up to 50 slots for disks and picking device either traverses the slots, or the slots move to align with the packing device. The arrangement of the slots ad picking devices affects performance, depending on the space between a disk and the picking device. Seek times are around 85 milliseconds and transfer rates are in the 700Kbits/sec range.

Jukeboxes are used in high-capacity storage environments such as imaging, archiving, and hierarchical storage management (HSM). HSM is a strategy that moves little used or unused files from fast magnetic storage to optical jukebox devices in a process called migration. If the files are needed, they are de-migrated back to magnetic disk. After a certain period of time or nonuse, the files on optical disk might be moved to magnetic tape archives.

A standard Julian date is a five-digit number in which the first two digits represent the year and the last three digits represent the day of the year. Thus, the Julian date form of January 1, 2001. is 01001, while June 23 of that same year is 01174. To provide a full four-digits for the year, an extended Julian date is preferable. An extended Julian date is a seven-digit number in which the first four digits represent the year. Thus, the extended Julian date for June 23, 2001, is 2001174; a date three weeks later is represented as 2001295 (2001174 + 21). Julian dates work well for calculations with dates that fall in the same year, but extra steps are needed, for example, to add five weeks to December 3 or to calculate the number of days between one year and the next, such as between August 13 and the following April 27.

Is an option in the IPv6 internet protocol that supports larger payloads, indicated when the Payload Length is set to zero.

A wire or metal bridge whose placement can be used to close a circuit. A jumper can establish electrical connections that indicate configuration settings. Jumpers are alternatives to DIP switches for storing configuration values. A group of jumpers is called a jumper block.

Search for Information Technology Items

Return back to Network & Concepts Index

Networking "J" Definitions and Concepts

This site is brought to you by
Bob Betterton; 2001 - 2011.

This page was last updated on 01/09/2007
Copyright, RDB Prime Engineering