Development in J2EE (Struts, Hibernate, Spring)
Today's enterprises gain competitive advantage by quickly developing and deploying custom applications that provide unique business services. Whether they're internal applications for employee productivity or Internet applications for specialized customer or vendor services, quick development and deployment are key to success.
Portability and scalability are also important for long term viability. Enterprise applications must scale from small working prototypes and test cases to complete 24 x 7, enterprise-wide services, accessible by tens, hundreds, or even thousands of clients simultaneously.
However, multitier applications are hard to architect. They require bringing together a variety of skill sets and resources, legacy data and legacy code. In today's heterogeneous environment, enterprise applications have to integrate services from a variety of vendors with a diverse set of application models and other standards. Industry experience shows that integrating these resources can take up to 50% of application development time.
As a single standard that can sit on top of a wide range of existing enterprise systems -- database management systems, transaction monitors, naming and directory services, and more -- the J2EE platform breaks the barriers inherent between current enterprise systems. The unified J2EE standard wraps and embraces existing resources required by multitier applications with a unified, component-based application model. This enables the next generation of components, tools, systems, and applications for solving the strategic requirements of the enterprise.
The J2EE specification also supports emerging Web Services technologies through inclusion of the WS-I Basic Profile. WS-I Basic Profile compliance means that the developers can build applications on the J2EE platform as Web services that interoperate with Web services from non-J2EE compliant environments.
With simplicity, portability, scalability, and legacy integration, the J2EE platform is the platform for enterprise solutions.
The J2EE platform takes advantage of many features of the Java 2 Platform, Standard Edition (J2SE), such as
> "Write Once, Run Anywhere" portability
> JDBC API for database access
> CORBA technology for interaction with existing enterprise resources
> Security model that protects data even in internet applications, Building on this base, the Java 2 Platform, Enterprise Edition adds full support for
> Enterprise JavaBeans components
> Java Servlets API, Java Server Pages and XML technology.
The J2EE standard includes complete specifications and compliance tests to ensure portability of applications across the wide range of existing enterprise systems capable of supporting the J2EE platform. In addition, the J2EE specification now ensures Web services interoperability through support for the WS-I Basic Profile.
Struts
Struts is open source software that helps developers build web applications quickly and easily. Struts rely on standard technologies—such as JavaBeans, Java servlets, and Java Server Pages (JSP).By taking a standards-based, "fill-in-the-blanks" approach to software development; Struts can alleviate much of the time-consuming grunt work that comes with every new project.
The Struts framework allows you to focus your attention on developing business logic, instead of concerning yourself with peripheral functionality like program flow, validation. Struts accomplish this by providing specific components for each piece of the MVC architecture.
Features:
> Simplified Design - Programming the abstract classes instead of interfaces is one of design problem of struts1 framework that has been resolved in the struts 2 framework. Most of the Struts 2 classes are based on interfaces and most of its core interfaces are HTTP independent. Struts 2 Action classes are framework independent and are simplified to look as simple POJOs. Framework components are tried to keep loosely coupled.
> Simplified Actions - Actions are simple POJOs. Any java class with execute() method can be used as an Action class. Even we don't need to implement interfaces always. Inversion of Control is introduced while developing the action classes. This make the actions to be neutral to the underlying framework .
> No more ActionForms - ActionForms feature is no more known to the struts2 framework. Simple JavaBean flavored actions are used to put properties directly. No need to use all String properties.
> Simplified testability - Struts 2 Actions are HTTP independent and framework neutral. This enables to test struts applications very easily without resorting to mock objects.
> Intelligent Defaults - Most configuration elements have a default value which can be set according to the need. Even there are xml-based default configuration files that can be overridden according to the need.
> Improved results - Unlike ActionForwards, Struts 2 Results provide flexibility to create multiple type of outputs and in actual it helps to prepare the response.
> Better Tag features - Struts 2 tags enables to add style sheet-driven markup capabilities, so that we can create consistent pages with less code. Struts 2 tags are more capable and result oriented. Struts 2 tag markup can be altered by changing an underlying stylesheet. Individual tag markup can be changed by editing a FreeMarker template. Both JSP and FreeMarker tags are fully supported.
> Annotations introduced - Applications in struts 2 can use Java 5 annotations as an alternative to XML and Java properties configuration. Annotations minimize the use of xml.
> Stateful Checkboxes - Struts 2 checkboxes do not require special handling for false values.
> QuickStart - Many changes can be made on the fly without restarting a web container.
> Customizing Controller - Struts 1 lets to customize the request processor per module, Struts 2 lets to customize the request handling per action, if desired.
> Easy Spring integration - Struts 2 Actions are Spring-aware. Just need to add Spring beans!
> Easy plugins - Struts 2 extensions can be added by dropping in a JAR. No manual configuration is required!
> AJAX support - The AJAX theme gives interactive applications a significant boost. The framework provides a set of tags to help you ajaxify your applications, even on Dojo.
The AJAX features include:
1. AJAX Client Side Validation
2. Remote form submission support (works with the submit tag as well)
3. An advanced div template that provides dynamic reloading of partial HTML
4. An advanced template that provides the ability to load and evaluate JavaScript remotely
5. An AJAX-only tabbed Panel implementation
6. A rich pub-sub event model
7. Interactive auto complete tag
Hibernate
Hibernate is an open source object/relational mapping tool for Java.
Hibernate lets you develop persistent classes following common Java idiom - including association, inheritance, polymorphism, composition and the Java collections framework.
Hibernate not only takes care of the mapping from Java classes to database tables (and from Java data types to SQL data types), but also provides data query and retrieval facilities and can significantly reduce development time otherwise spent with manual data handling in SQL and JDBC.
Hibernates goal is to relieve the developer from 95 percent of common data persistence related programming tasks.
Some of the main features of hibernate are listed below:
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 Prepared Statement caching
J2EE integration
> JMX support
> Integration with J2EE architecture (optional)
Spring
Spring is a layered Java/J2EE application platform, based on code published in Expert One-on-One J2EE Design and Development.
Spring's layered architecture gives you a lot of flexibility. All its functionality builds on lower levels. So you can e.g. use the JavaBeans configuration management without using the MVC framework or AOP support. But if you use the web MVC framework or AOP support, you'll find they build on the core Spring configuration, so you can apply your knowledge about it immediately.
You can use all of spring's functionality in any J2EE server, and most of it also in non-managed environments. A central focus of Spring is to allow for reusable business and data access objects that are not tied to specific J2EE services. Such objects can be reused across J2EE environments (web or EJB), standalone applications, test environments, etc without any hassle.
Features:
> The most complete lightweight container, providing centralized, automated configuration and wiring of your application objects. The container is non-invasive, capable of assembling a complex system from a set of loosely-coupled components (POJOs) in a consistent and transparent fashion. The container brings agility and leverage, and improves application testability and scalability by allowing software components to be first developed and tested in isolation, then scaled up for deployment in any environment (J2SE or J2EE).
> A common abstraction layer for transaction management, allowing for pluggable transaction managers, and making it easy to demarcate transactions without dealing with low-level issues. Generic strategies for JTA and a single JDBC DataSource are included. In contrast to plain JTA or EJB CMT, spring's transaction support is not tied to J2EE environments.
> A JDBC abstraction layer that offers a meaningful exception hierarchy (no more pulling vendor codes out of SQLException), simplifies error handling, and greatly reduces the amount of code you'll need to write. You'll never need to write another finally block to use JDBC again. The JDBC-oriented exceptions comply to Spring's generic DAO exception hierarchy.
> Integration with Toplink, Hibernate, JDO, and iBATIS SQL Maps: in terms of resource holders, DAO implementation support, and transaction strategies. First-class Hibernate support with lots of IoC convenience features, addressing many typical Hibernate integration issues. All of these comply to Spring's generic transaction and DAO exception hierarchies.
> AOP functionality, fully integrated into Spring configuration management. You can AOP-enable any object managed by Spring, adding aspects such as declarative transaction management. With Spring, you can have declarative transaction management without EJB... even without JTA, if you're using a single database in Tomcat or another web container without JTA support.
> A flexible MVC web application framework, built on core Spring functionality. This framework is highly configurable via strategy interfaces, and accommodates multiple view technologies like JSP, Velocity, Tiles, iText, and POI. Note that a Spring middle tier can easily be combined with a web tier based on any other web MVC framework, like Struts, WebWork, or Tapestry.
