Java Beans   «Prev  Next»
Lesson 7

Java Archive Files and JavaBeans Conclusion

This module introduced you to Java archive files, which are used to package Beans for distribution.
You learned how to use the JAR utility to examine JAR files and package Beans in them. The Java JAR (Java Archive) tool, introduced by Sun Microsystems with the Java Development Kit (JDK) in 1996, has remained fundamentally consistent in its core functionality but has seen incremental improvements and minor changes over time under Oracle's maintenance. Below is a concise analysis of its evolution:
Core Functionality (Unchanged) The JAR tool's primary purpose, packaging Java class files, resources, and metadata (like MANIFEST.MF) into a single compressed archive, has not changed. It still supports:
  • Creating JAR files (jar c).
  • Extracting contents (jar x).
  • Listing contents (jar t).
  • Updating existing JARs (jar u).
  • Supporting JavaBeans packaging for distribution.

These core features have been stable since the tool's introduction, ensuring backward compatibility for developers.
Key Changes and Enhancements
While the JAR tool's core has remained consistent, Oracle (which acquired Sun in 2010) introduced several updates to align with modern Java ecosystems and security needs:
  • Performance Improvements:
    • Over time, optimizations in compression algorithms and file handling have improved the speed of JAR creation and extraction, though these are often undocumented and internal to the JDK.
  • Security Enhancements:
    • Manifest Signing: Support for signing JAR files (introduced early by Sun) was enhanced with stronger cryptographic algorithms (e.g., SHA-256 instead of MD5) to meet modern security standards.
    • Security Manager Integration: Oracle tightened integration with Java's Security Manager, allowing better control over signed JARs in applets and enterprise applications.
  • Manifest and Metadata Handling:
    • Oracle introduced better support for manifest attributes like Class-Path, Main-Class, and custom attributes for modular applications.
    • JDK 9 (2017) introduced the Multi-Release JAR feature, allowing JARs to contain classes for different Java versions (e.g., Java 8 and Java 11) in a single archive. The JAR tool was updated to handle the META-INF/versions/ directory.
  • Modularity (Project Jigsaw):
    • With JDK 9's module system, the JAR tool supports creating module-info.class files for modular JARs, though this is primarily handled by the javac compiler and jlink for creating runtime images.
    • The tool can package modular JARs for use in the Java Platform Module System (JPMS).
  • Command-Line Enhancements:
    • New options were added, such as --release for Multi-Release JARs and improved verbose output (-v).
    • Better error messages and diagnostics were introduced for malformed JARs or invalid manifest files.
  • Integration with Modern JDK Tools:
    • Oracle integrated JAR more tightly with tools like jlink and jpackage (introduced in JDK 14) for creating custom runtime images and application bundles, though these are separate from the JAR tool itself.
  • Deprecation of Applets:
    • Since applets (a common use case for signed JARs) were deprecated in JDK 9 and removed in JDK 11, the JAR tool's role in applet packaging has diminished, shifting focus to modular and server-side applications.



Stability and Backward Compatibility
Oracle has prioritized backward compatibility, ensuring that JAR files created with early JDK versions (e.g., JDK 1.1) remain readable and usable with modern JDKs (e.g., JDK 21). The ZIP-based format of JAR files has not changed, maintaining interoperability.
Documentation and Community
  • Sun's original documentation was sparse but functional. Oracle expanded the jar command's man pages and online documentation, providing clearer examples and use cases.
  • Community tools like Maven and Gradle have largely replaced manual JAR creation for many developers, but the jar tool remains essential for low-level tasks and JavaBeans packaging.

Conclusion The JAR tool has not undergone significant overhauls since its introduction by Sun Microsystems. Oracle's changes have been evolutionary, focusing on performance, security, modularity, and integration with modern Java features like Multi-Release JARs and JPMS. The tool remains a reliable, lightweight utility for packaging JavaBeans and other Java components, with its core functionality intact and backward-compatible.

JAR file format provides many benefits:

  1. Security: You can digitally sign the contents of a JAR file. Users who recognize your signature can then optionally grant your software security privileges it would not otherwise have.
  2. Decreased download time: If your applet is bundled in a JAR file, the class files of the applet and associated resources can be downloaded to a browser in a single HTTP transaction without the need for opening a new connection for each file.
  3. Compression: The JAR format allows you to compress your files for efficient storage.
  4. Packaging for extensions: The extensions framework provides a means by which you can add functionality to the Java core platform, and the JAR file format defines the packaging for extensions. By using the JAR file format, you can turn your software into extensions as well.
  5. Package Sealing: Packages stored in JAR files can be optionally sealed so that the package can enforce version consistency. Sealing a package within a JAR file means that all classes defined in that package must be found in the same JAR file.
  6. Package Versioning: A JAR file can hold data about the files it contains, such as vendor and version information.
  7. Portability: The mechanism for handling JAR files is a standard part of the Java platform's core API.

Bean Box

Here is a list of the BeanBox toolbox components with descriptions typically associated with each JavaBean from the original JavaBeans development environment:
  1. BeanBox A visual container used to test and wire JavaBeans components together interactively.
  2. QuoteMonitor: A sample Bean that displays or logs stock quotes, often used to demonstrate property changes or event firing.
  3. JellyBean A simple example Bean used to demonstrate introspection and customization. Often has properties like color or flavor.
  4. Juggler An animated Bean that displays a juggling character. Used to showcase animation and custom painting in a JavaBean.
  5. ChangeReporter Listens for property changes in other Beans and logs or reports them. Useful for debugging event propagation.
  6. TickTock A timer-based Bean that alternates between two states ("tick" and "tock"), often used to demonstrate timed events.
  7. Voter A Bean that allows for vote tracking or simulates voting behavior, often used for demonstrating event aggregation.
  8. Molecule Visualizes molecular structures or animations—commonly used to showcase complex rendering in Beans.
  9. OrangeButton A button Bean that is colored orange. Often used to demonstrate Bean customization and property binding.
  10. OurButton A simple custom button Bean used to demonstrate basic Bean behavior and event firing.
  11. BlueButton Similar to OrangeButton but colored blue. Demonstrates how appearance can be a configurable property.
  12. ExplicitButton A Bean that fires events explicitly through user-defined triggers—useful for showing fine-grained event control.
  13. JDBC SELECT A Bean that demonstrates basic SQL queries via JDBC, usually retrieving and displaying database rows.
  14. SorterBean Takes an array of data and sorts it. Often used to demonstrate Beans that manipulate or transform data.
  15. BridgeTester A utility Bean that tests connectivity or event bridging between Beans—used to debug complex interactions.
  16. TransitionalBean A Bean with animation or state transitions—used to show how state changes over time in UI Beans.
  17. EventMonitor Monitors events from other Beans and logs them—ideal for testing event firing and propagation.
Bean Box



In the BeanBox toolbox, each available Bean is listed by name. The Beans that expose an icon have it shown just to the left of the name. Note that Beans are not required to expose an icon, in which case this space is left empty.
To select a Bean to be dropped onto the main form window, just click on it. The cursor will change to a crosshair, indicating that you can drop the Bean on the form by clicking on the spot where you want it placed. There is no visual indication of which Bean you have selected to drop, and there is no way to cancel out of placement mode if you decide not to drop the Bean on the form. You can, of course, remove the Bean from the form if you really did not want to put it there.


Java Archives - Quiz

Before you move on to the next module, make sure you understand the importance of how Java Archive Files are used to package JavaBeans for distribution. Click the Quiz link below to take a multiple-choice quiz that has questions addressing the lessons worked through in this module.
Java Archives - Quiz
In the next module, the structure of Beans will be discussed.
You find out what the different parts of a Bean are, and how they come together to give JavaBeans its flexibility.

SEMrush Software