Saturday, July 12, 2008

HIBERNATE - Features of Hibernate

HIBERNATE - Features of Hibernate

Transparent persistence without byte code processing
Transparent persistence
JavaBeans style properties are persisted
No build-time source or byte code generation / processing
Support for extensive subset of Java collections API
Collection instance management
Extensible type system
Constraint transparency
Automatic Dirty Checking
Detached object support
Object-oriented query language
Powerful object-oriented query language
Full support for polymorphic queries
New Criteria queries
Native SQL queries
Object / Relational mappings
Three different O/R mapping strategies
Multiple-objects to single-row mapping
Polymorphic associations
Bidirectional associations
Association filtering
Collections of basic types
Indexed collections
Composite Collection Elements
Lifecycle objects
Automatic primary key generation
Multiple synthetic key generation strategies
Support for application assigned identifiers
Support for composite keys
Object/Relational mapping definition
XML mapping documents
Human-readable format
XDoclet support
HDLCA (Hibernate Dual-Layer Cache Architecture)
Thread safeness
Non-blocking data access
Session level cache
Optional second-level cache
Optional query cache
Works well with others
High performance
Lazy initialization
Outer join fetching
Batch fetching
Support for optimistic locking with versioning/timestamping
Highly scalable architecture
High performance
No "special" database tables
SQL generated at system initialization time
(Optional) Internal connection pooling and PreparedStatement caching
J2EE integration
JMX support
Integration with J2EE architecture (optional)
New JCA support

Java Features In 9.21.

The following Java features were introduced in Version 9.21.

JVM 1.2 Support in J/Foundation

Dynamic Server supports Version 1.2 of the Java Virtual Machine (JVM).

Default Values of Java Configuration Parameters

The default values of the JDKVERSION, JVPJAVAHOME, JVPJAVALIB, and JVPJAVAVM parameters in the ONCONFIG file have changed for Dynamic Server.

JDBC 2.0 Support

IBM Informix JDBC driver is bundled with Embedded SQLJ 1.10.1.JC1, a product for embedding SQL statements in Java. Dynamic Server supports the following JDBC 2.0 features:
  • Complex data types
  • Collections
  • Scrollable cursors
  • Batch updates
  • Interval data types
  • Extensions to prepared statement
  • Callable statements

GLS Support for J/Foundation

Dynamic Server supports the following GLS features:
  • New connection properties (NEWLOCALE and NEWCODESET) for mapping a locale or code set in the JDBC driver

update_jars.sql Script

Use the update_jars.sql script to update the names of jar files in a database after you rename the database.

Java Runtime Environment Variables

Dynamic Server supports the JVM_MAX_HEAP_SIZEJAR_TEMP_PATHJAVA_COMPILER, andAFDEBUG environment variables.

Partial Support for Variable-Length Opaque-Types

You can now write UDRs and DataBlade modules in Java.
Dynamic Server supports the following items:
  • Variable-length opaque data types
  • Data I/O conversion routines:
    • input/output
    • send/receive
    • import/export
    • importbin/exportbin

References to J/Foundation Features

For more information on J/Foundation features, see these manuals.
Use JVM 1.2. Use JCBC 2.0 features. Write UDRs and DataBlade modules in Java.J/Foundation Developer's Guide
Specify Java environment variables.J/Foundation Developer's Guide
IBM Informix Guide to SQL: Reference
Specify Java configuration parameters.J/Foundation Developer's Guide
IBM Informix Dynamic Server Administrator's Reference
Set GLS environment variables. Use the connection properties.J/Foundation Developer's Guide
IBM Informix GLS User's Guide
Use the update_jars.sql script.IBM Informix Guide to SQL: Syntax

Java For Mac


Getting Started

A guided introduction and learning path for developers new to Java in Mac OS X.
Mac OS X is the only major consumer operating system that comes complete with a fully configured and ready-to-use Java runtime and development environment. Professional Java developers are increasingly turning to the feature-rich Mac OS X as the operating system of choice for both Mac-based and cross-platform Java development projects. Mac OS X includes the full version of J2SE 1.5, pre-installed with the Java Development Kit (JDK) and the HotSpot virtual machine (VM), so you don't have to download, install, or configure anything.
Deploying Java applications on Mac OS X takes advantage of many built-in features, including 64-bit support, resolution independence, automatic support of multiprocessor hardware, native support for the Java Accessibility API, and the native Aqua look and feel. As a result, Java applications on Mac OS X look and perform like native applications on Mac OS X. Read more...

Java for Mac OS X 10.5, Update 1

Java for Mac OS X 10.5, Update 1 is now available via Software Update.  This update adds Java SE 6 version 1.6.0_05 to 64-bit Intel Macs.
For more details on this update, visit:

Java Articles

Featured Content

Java on Mac OS X Leopard
Java in Leopard brings improvements such as better performance, 64-bit computing, and new tools to better analyse your Java code. Read this article to see how Leopard provides the best possible Java experience on Mac OS X while preserving compatibility, and supporting the latest hardware. .

Related Links

Java Reference Library


Essential information for developers using the Mac OS X built-in Java support.

API Reference

Java programming specifications, organized by package and class.

Mailing Lists

Macintosh Java-Dev Mailing List

Mailing list run by Apple about Java development on Mac OS.

Business Resources

Mac Market

Business Development

Product Development



Mac Products Guide

Java Technology Features

Here we list the basic features that make Java a powerful and popular programming language:
  • Platform Independence
    • The Write-Once-Run-Anywhere ideal has not been achieved (tuning for different platforms usually required), but closer than with other languages.
  • Object Oriented
    • Object oriented throughout - no coding outside of class definitions, including main().
    • An extensive class library available in the core language packages.
  • Compiler/Interpreter Combo
    • Code is compiled to bytecodes that are interpreted by a Java virtual machines (JVM) .
    • This provides portability to any machine for which a virtual machine has been written.
    • The two steps of compilation and interpretation allow for extensive code checking and improved security.
  • Robust
    • Exception handling built-in, strong type checking (that is, all data must be declared an explicit type), local variables must be initialized.
  • Several dangerous features of C & C++ eliminated:
    • No memory pointers 
    • No preprocessor
    • Array index limit checking
  • Automatic Memory Management
    • Automatic garbage collection - memory management handled by JVM.
  • Security
    • No memory pointers
    • Programs runs inside the virtual machine sandbox.
    • Array index limit checking
    • Code pathologies reduced by
      • bytecode verifier - checks classes after loading
      • class loader - confines objects to unique namespaces. Prevents loading a hacked "java.lang.SecurityManager" class, for example.
      • security manager - determines what resources a class can access such as reading and writing to the local disk.
  • Dynamic Binding
    • The linking of data and methods to where they are located, is done at run-time.
    • New classes can be loaded while a program is running. Linking is done on the fly.
    • Even if libraries are recompiled, there is no need to recompile code that uses classes in those libraries.

      This differs from C++, which uses static binding. This can result in fragile classes for cases where linked code is changed and memory pointers then point to the wrong addresses.
  • Good Performance
    • Interpretation of bytecodes slowed performance in early versions, but advanced virtual machines with adaptive and just-in-time compilation and other techniques now typically provide performance up to 50% to 100% the speed of C++ programs.
  • Threading
    • Lightweight processes, called threads, can easily be spun off to perform multiprocessing.
    • Can take advantage of multiprocessors where available
    • Great for multimedia displays.
  • Built-in Networking
    • Java was designed with networking in mind and comes with many classes to develop sophisticated Internet communications.
Features such as eliminating memory pointers and by checking array limits greatly help to remove program bugs. The garbage collector relieves programmers of the big job of memory management. These and the other features can lead to a big speedup in program development compared to C/C++ programming.