JavaBeat Articles

How to test OSGi Applications?

When you're testing OSGi bundles, each of these types of testing requires a different approach�different from the other phases and also different from how you'd do similar testing for an application intended to run on a JEE server or standalone. We'll start by discussing unit testing, since that's the simplest case in many ways. We'll then show you some tools and strategies that we hope you'll find useful for integration and system testing.

Blueprint and Service Dynamism in OSGi

OSGi is a dynamic environment. Stopping a bundle fragment removed translations, and stopping and starting bundles made special offers appear and disappear. This dynamism is amazingly powerful and allows OSGi applications to do things that aren't possible for conventional applications.

Writing an OSGi Web Application

In Java EE, the Servlet and Java Server Pages models have provided the basic building blocks for Java web applications for many years. OSGi Web Applications are a standardized OSGi version of JEE web applications. An OSGi web bundle is very similar to a JEE WAR, except that it also gets the benefits of operating in an OSGi framework. Enterprise OSGi web bundles are known as WABs. (In contrast to WARs, which are Web ARchives, WABs are Web Application Bundles.)

What is Model View Presenter (MVP) in GWT Application?

One of the main selling points of GWT is that it allows you to use an industry-grade language, with an industry-grade set of tools, to build...well...industry-grade web apps. But, as with any large scale development project, you can easily paint yourself into a corner. Far too many times when building GWT-based apps, we find ourselves slinging code wherever necessary to make the app work, and (sometimes more importantly) look good. Fortunately, there is a well known solution to this problem: build your applications based on the model-view-presenter (MVP) paradigm.

Code Splitting in GWT

Another common engineering issue was how to decrease the load time of the application. It is common for a feature full GWT application to approach a megabyte in size. With broadband, this is generally a fast download, but at the same time users have higher expectations that they did with their 56K modem. Users now judge the speed of your application in hundreds of milliseconds and not seconds. If your application takes a full second to start up, it may be considered as being sluggish. So how can you decrease the start time?.This is where code splitting comes in. If you can cut your code into multiple segments, you can kill two birds with one stone. A smaller initial download means faster startup, and loading less-often accessed code only when it loads means smaller total downloads.

How to create widget in GWT 2.0?

With GWT v2, it is going to be a rare occasion where you need to create a widget directly from the Document Object Model (DOM). This is because GWT 2.0 covers nearly all the widgets we can think of. If you are using a GWT version lower than 2.0 then you may find some things missing (such as a widget wrapping the SPAN element�GWT 2.0 provides InlineLabel, which does that).

The Memory Leak Detector Oracle JRockit

Working with a garbage collected language could easily lead to the hasty conclusion that resource management is a thing of the past, and that memory leaks are impossible. Nothing could be further from the truth. In fact, memory leaks are so common in Java production systems that many IT departments have surrendered. Recurring scheduled restarts of Java production systems are now all too common.

Using Controllers in Play Framework

This chapter will help you to keep your controllers as clean as possible, with a well defined boundary to your model classes. Always remember that controllers are really only a thin layer to ensure that your data from the outside world is valid before handing it over to your models, or something needs to be specifically adapted to HTTP. The chapter will start with some basic recipes, but it will cover some more complex topics later on with quite a bit code, of course mostly explained with examples.

HTML 5.0 Features

HTML 5.0 will be the new standard for html, xhtml and DOM. HTML 5.0 was started by World Wide Consortium(W3C) and the web Hypertext Application Technology Working Group(WHATWG). HTML 5.0 reduces the need for external plugins(like Flash player). HTML5.0 provides better Error Handling. IT provides more mark up to replace scripting.

Flex 4.x - Overview

The support for drag and drop can be added for all Flex components. Flex includes built-in support for drag-and-drop operation for some controls such as List, Tree and DataGrid, This automates processing required to support drag and drop operation. Drag-and-drop operation has 3 main stages: initiation, dragging, and dropping. A drag-and-drop operation will either copy or move data from drag initiator to drop target. On successful drop, Flex adds the data to drop target and, optionally, deletes it in case of a move from the drag initiator.

Stochastic Gradient Ascent

Gradient Ascent uses the whole dataset on each update. This is fine with 100 examples but, with billions of data points containing thousands of features, it is unnecessarily expensive in terms of computational resources. An alternative to this method is to update the weights using only one instance at a time. This is known as Stochastic Gradient Ascent. Stochastic Gradient Ascent is an example of an on-line learning algorithm. This is known as on-line because we can incrementally update the classifier as new data comes in rather than all at once. The all-at-once method is known as batch processing.

What's New in Silverlight 5?

Silverlight 3, 4, and 5 have added an amazing number of new capabilities to the platform in all areas, from core capabilities, to device access, to the introduction of both trusted and sandboxed in and out-of-browser client applications. While Silverlight is still a relatively young technology, it has had 5 major releases in the past four years, as described in table 1.

Spring DMs Event Admin Service Support

The core of the OSGi technology is a standard that's described in the OSGi core specification. OSGi also comes with the compendium services specifications that build on the features provided by the core specification. Each compendium service addresses a particular requirement and can be used on any conformant OSGi platform. The Event Admin Service provides a standardized and centralized service to manage events triggered by entities used within the OSGi container. It's based on an event channel called topic, which makes it possible for entities to subscribe to, receive, and send events. At the moment, Spring DM doesn't support this service directly, but it's possible to implement a bridge between Spring and Spring DM events and the Event Admin Service.

Creating a Custom Pie Chart Component with Degrafa using Flex

Adobe provides data visualization components, but only when you purchase a license for the professional version of the Flash Builder IDE. Because our goal is to do Flex development using only free and open source technologies, we've decided to create our own visualization components�besides, it's more fun.

The Most Popular Collaborative Models

Although all the teams I interviewed collaborated on specifications, the ways they approached that collaboration varied greatly, from large all-hands workshops to smaller workshops, and even to informal conversations. Here are some of the most common models for collaboration along with the benefits the teams obtained.

Choosing a Cloud Vendor

When choosing a public cloud provider, you're often able to purchase services in an on-demand fashion. The advantage of this sort of arrangement is the ability to stop using it at any time. You can experiment with the services at little cost, and if the quality and reliability of the service leaves something to be desired, you can choose to go elsewhere. If you're running an application requiring significant investment that has high business criticality, or if you're considering an annual contract to lower costs, it probably makes sense to proceed cautiously. In this case, the selection and evaluation of a potential cloud provider bears some similarity to how you choose a traditionally outsourced service, such as web hosting or collocation.

Canvas Tag in HTML5

HTML5 is the version of HTML and XHTML that has rekindled the future of HTML and is treated as the future of the web technology. HTML5 originated with the cooperation between the World Wide Web Consortium (W3C) and the Web Hypertext Application Technology Working Group (WHATWG) and has the capability to address the increasing RIA demands. The new features like canvas, video, audio, local storage, web worker, web sockets etc have given HTML5 a real push in the market.

Location tracker in Android using GPS positioning and SQLite

Android is an Open source software stack which has gained market in leaps and bounce. This includes operating system, middleware and key applications. The advantage android brings along with it is the ease of application development. Android application can be developed at a brisk rate with lesser learning curve using the tools and API provided by Android SDK. The tools and key applications have made the life of developers very easy.

Developing the Business Logic in Activiti

Important BPMN 2.0 attributes of the script task construct are scriptFormat and script. The scriptFormat attribute defines the format of the script and is mandatory. The optional script attribute contains the actual script that needs to be executed. If no script is defined, the task will just complete without doing anything.

Adding More Logic with the Email Task in Activiti

Before we can implement the email task in BPMN 2.0 XML and test it in Eclipse or run it later on Activiti Engine for that matter, we need to set up a mail server first. We will use the Apache James project to do that. When our server is running, we will make a tiny process to test the email task and send Miss Piggy a message. This way, you can see how the email task works and make sure that the James environment is configured correctly.

Creating an Activiti Development Environment

Logging is an important vehicle to understand what�s going on in a complex framework as a process engine. We�ll see how we can tune the log levels for our needs. At the end, we�ll look at a couple of options you have to run the Activiti engine. But, first, it�s time to find out a little bit more about the Activiti library structure.

OSGi Bundle Repository

The OSGi Bundle Repository (OBR) is officially not an OSGi standard specification; rather, it's a proposal for a specification, internally referred to as RFC 112 in the OSGi Alliance. Because OBR is only an RFC, its details may change in the future, but it's still a useful tool as it is.

How to create EJB project in NetBeans 7.0?

This book does require a minimal knowledge of Java platform, more specifically the language ifself. But the book might as well be used by either beginners, who are trying to dip their toes in new technology, or more experienced developers, who are trying to switch from other IDEs but want to decrease their learning curve of a new environment. NetBeans integrates so many different technologies, many of which are present in this book, that it is beyond the scope of this book to cover all of them in depth. We provide the reader with links and information where to go when further knowledge is required.

HTML5 Multimedia Development Cookbook

HTML5 Multimedia Development Cookbook will show you exactly how to use the latest front-end web technologies like a pro. You'll learn how HTML5 is a quantum leap difference from all previous versions and why it matters. Whether you're a seasoned pro or a total newbie, this book gives you the roadmap to what's next.

Building your own function objects in Scala

A function object is an object that you can use as a function. That doesn�t help you much, so why don�t I show you an example? Here, we create a function object that wraps a foldLeft method

Methods and Pattern Matching in Scala

Expression-oriented programming challenges some good practices from other languages. A common practice in Java programming is having a single point of return for any method. This means that, if there is some kind of conditional logic, the developer creates a variable that contains the eventual return value. As the method flows, this variable is updated with what the method returns. The very last line in every method is a return statement. See an example in listing 1.

Examining Functional Concepts in Google Collections using Scala

The Google Collections API adds a lot of power to the standard Java collections. It brings a nice set of efficient immutable data structures and some functional ways of interacting with your collections, primarily the Function interface and the Predicate interface. These interfaces are used from the Iterables and Iterators classes. Let�s take a look at the Predicate interface (listing 1) and its uses.

Indexing in Practice using MongoDB

Indexes are enormously important. With the right indexes in place, MongoDB can use its hardware efficiently and serve your application's queries quickly. With the wrong indexes, you'll see the exact opposite effect: slow queries and poorly utilized hardware. It stands to reason, then, that anyone wanting to use MongoDB effectively and make the best use of hardware resources must understand indexing.

MongoDB Query Selectors

In this article, we present parts of MongoDB�s query language. Specifically, we discuss general description queries, their semantics, and types.

MongoDB vs. RDBMS Schema Design

This article takes a closer look at the document-oriented data model and at how data is organized at the database, collection, and document level in MongoDB. We start with a brief, general discussion of schema design. This is helpful because a large number of MongoDB users have never designed schemas outside the realm of a traditional relational database management system (RDBMS). This exploration of principles helps set the stage for the second part of the article, where we examine the design of an e-commerce schema in MongoDB. Along the way, I'll explain how this schema differs from an equivalent RDBMS schema, and we'll learn how common relationships between entities, such as one-to-many and many-to-many, are replicated in MongoDB.

Using Liferay's Service Builder, part 2

Liferay's code generator for database persistence, which is called Service Builder, jump-starts portlet development. This utility (which ships as part of Liferay) creates code and SQL for accessing a database from within portlets. Since it uses Spring and Hibernate to implement this, it's not much different from what you would already do manually, with the important exception that it does much of this "grunt work" automatically, freeing time for you to implement your business logic.

Loosely Coupled Data Persistence with Liferay

Liferay�s Service Builder encourages the proper layering of functionality within a portlet application. Generally, when building an application, it�s good practice to separate the various layers of the application: UI, model, persistence, and so on. This is sometimes called separation of concerns. By keeping the layers as separate as possible, you gain the ability to change the implementation of any one layer more easily�if for some reason you find a better way to do it later.

Using Liferay's Service Builder, part 1

If you�re an experienced developer, it�s likely that you�ve dealt with a data-driven application before. Liferay ships with a tool called Service Builder, which makes the creation of data-driven applications very easy. I highly recommend that you use Service Builder when writing applications on Liferay�s platform because it will get you going very quickly. How? By generating a lot of the database plumbing code for you so you can concentrate on your application�s functionality.

Accessing the UIAccelerometer in Iphone and iPad

When you're using the iPhone's orientation notification, the frameworks are doing the work for you: they're taking low-level acceleration reports and turning them into more meaningful events. It's similar to the concept of iPhone actions, which turn low-level touch events into high-level control events.

Adding a map to an application in iPhone and iPad

The view that displays a map is called MKMapView. This class contains quite a bit of functionality including how to display the map, annotations, and user location. We will first be discussing how to add an MKMapView through Interface Builder. Once we add the map to the view, we will connect it to an IBOutlet and set its delegate class.

Preparing your application to use push notifications in iPhone and iPad

Leave it to Apple to make the preparation more complex than the coding. You will find that more time is spent on creating an uploading the signing certificates than actually writing the code to receive the push notifications. We will explain how. Let's begin by setting up the signing certificates.

Simple Accelerometer Movement in iOS4

If you want to write programs using acceleration gestures, we suggest that you download the Accelerometer Graph program available from Apple�s developer site. This is a nice, simple example of accelerometer use; but more important, it also provides you with a clear display of what the accelerometers report as you make different gestures. Make sure you enable the high-pass filter to get the clearest results.

Event Kit Frameworks in iOS4

Calendar apps coming with iOS on iPhone and iPad are really convenient for several reasons. They allow users to check out the schedule on the go and consolidate all the information into one Calendar database

Multitasking on iOS 4

What's multitasking? It's one of the important and exciting API features in iOS 4. When the end user quits an application, instead of termination, the application will enter the background state so that we can use this feature to support fast app switching, running tasks in the background. In this article, we will take a look at the basics of multitasking on iOS 4 and the applications life cycle.

Using an alert view as a task loader in iPad

Some actions, like signing out of an account in an application, require a user to both confirm the action and to indicate the processing of the action. When you need to present this type of flow to a user, an interesting option is to present an alert with a confirm/cancel option and then to use the alert as a loader while the action is being processed.

Debug Logging in iPad

In Cocoa, the default logging function NSLog can be useful for adding some log information to your application but, unfortunately, it runs in all build configurations. On the Mac, that may not be a big deal but, on the iPhone, you can and will notice a performance impact when NSLog calls are being made in a processor-intensive situation. You should use NSLog sparingly; in fact, I prefer not to use it at all and use a debug logging approach like the one outlined in this technique for all my log output.

Handling Configuration at Runtime in Windows Azure

After your application is redeployed and running in the fabric, you can easily modify any of your configuration settings. Select either the production or staging version of the role, and then click Configure. You�re redirected to the page shown in figure 1, in which you can modify the runtime configuration settings for the role that you selected.

Developing with the Table Service in Windows Azure

One of the major issues with traditional SQL Server�based databases is that individual tables can grow too large, slowing down all operations against the table. Although the Windows Azure Table service is highly efficient, storing too much data in a single table can still degrade data access performance.

Cache Management with Windows Azure

A cache is a temporary, in-memory store that contains duplicated data populated from a persisted backing store, such as a database. Because the cache is an in-memory data store, retrieving data from the cache is fast (compared with database retrieval). Since a cache is an in-memory temporary store, if the host process or underlying hardware dies, the cached data is lost and the cache needs to be rebuilt from its persistent store.

Content Types and Storage

The types of content within files vary vastly. We�ve picked two example file format types to examine in this article: the Hierarchical Data Format (HDF), a common file format used to capture scientific information, and Really Simple Syndication (RSS), the most commonly used format to spread news and rapidly changing information.

The Standards of Metadata

While PDF file properties, and HTML page properties are useful for making decisions such as, "Do I care to read this research paper?" or "Is this web page the one I was looking for?", the property names themselves don't tell you everything that you need to know in order to make use of them. For example, is "PDFVersion" an integer, or an alphanumeric? This would be useful to know because it would allow you to compare different "PDFVersion" attributes. What about "Author"? Is it multivalued, meaning that a paper can have multiple authors, or is it only single-valued?

Theory of Language Detection

The ability to consistently name and classify things is essential for fully understanding them. There are thousands of languages in the world, many with multiple dialects or regional variants. Some of the languages are extinct and some are artificial. Some don�t even have names in English! Others, like Chinese, have names whose specific meaning is highly context-sensitive. A standard taxonomy that can name and classify all languages is needed to make it allow information systems to reliably store and process information about languages.

Caching in Spring

In this article, we will discuss about the Caching support provided by the Spring framework. This article assumes that the reader has a basic understanding on Spring framework. The first section of the article illustrates the various APIs provided by Spring such as Cache, Cache Manager and Composite Cache Manager. Plenty of code samples will be provided for illustrating the concepts better. Caching support can be specified for methods using annotations also and the later section of this article provides an in-depth discussion on its usage.

Using the Built-in Analyzers in Lucene

Analysis, in Lucene, is the process of converting field text into its most fundamental indexed representation, terms. These terms are used to determine what documents match a query during searching. For example, if you indexed this sentence in a field the terms might start with for and example, and so on, as separate terms in sequence. An analyzer is an encapsulation of the analysis process. An analyzer tokenizes text by performing any number of operations on it, which could include extracting words, discarding punctuation, removing accents from characters, lowercasing (also called normalizing), removing common words, reducing words to a root form (stemming), or changing words into the basic form (lemmatization). This process is also called tokenization, and the chunks of text pulled from a stream of text are called tokens. Tokens, combined with their associated field name, are terms.

K-Means Clustering Algorithms in Mahout

There are many clustering algorithms in Mahout, and some work well for a given dataset while others don�t. K-Means is a very generic clustering algorithm, which can be molded easily to fit almost all situations. It�s also simple to understand and can easily be executed on parallel computers.

Preference object in Mahout

The quality of recommendations is largely determined by the quantity and quality of data. Garbage in, garbage out was never truer than here. Likewise, recommender algorithms are data intensive, and runtime performance is greatly affected by quantity and representation of data. This article explores classes in Mahout for representing and accessing recommender-related data.

Running in the Cloud

Don't have a hundred machines lying around on which to run these big distributed computations? Fortunately, today, service providers allow you to rent storage and computing time from a computing cloud.

Replacing a Font using iText

PDF files that were created in exactly the same way, except for one difference: in the top PDF, the font (Walt Disney Script v4.1) wasn't embedded. It's a font I've downloaded from a site with plenty of free fonts. The font isn't installed on my operating system. As a result, Adobe Reader doesn't find it, and the words "iText in Action" are shown in Adobe Sans MM, which is quite different from the font shown in the PDF that has the font embedded.

Resizing an Image in an Existing Document using iText

Here�s a question that is often posted to the mailing list: �How do we reduce the size of an existing PDF containing lots of images?� There are many different answers to this question, depending on the nature of the PDF file. Maybe the same image is added multiple times, in which case passing the PDF through PdfSmartCopy could already result in a serious file size reduction. Maybe the PDF wasn�t compressed or maybe there are plenty of unused objects. You could try and see if the PdfReader method removeUnusedObjects() yields any results.

Making Content Visible or Invisible using iText PDF Framework

Beginning with PDF 1.5, we can also add optional content: content that can be selectively viewed or hidden by document authors or consumers. Graphics and text that can be made visible or invisible dynamically are grouped in an optional content group (OCG). Content that belongs to a certain group is visible when the group is on and invisible when the group is off. Figure 1 demonstrates this functionality.

Android's JSON parser

The AJAX(Asynchronous JavaScript and XML) craze that accompanied the rise of the Web 2.0 was a key element to giving modern websites a desktop application like user experience. Interestingly, just like the XMLHttpRequest object, AJAXmade another thing popular, one which had been around for years, but the full potential of which had never really been recognized: JSON, the JavaScript Object Notation. (Never before has the invention, or better, the discovery of a single class made so much difference!).

Routing Slip and Loading Balancer EIPs in Camel

Let's face it, integration is a hard problem. To help deal with the complexity of integration problems, the Enterprise Integration Patterns (EIP) have become the standard way to describe, document, and implement complex integration problems. Gregor Hohpe and Bobby Woolf's book Enterprise Integration Patterns1 has become the bible in the integration space and an essential reading for any integration professional.

HTTP messaging in Java

The standard Java class library already has a solution for HTTP messaging. An open-source implementation of these classes is bundled with Android's class library, which is based on Apache Harmony. It's simple and bare-bones in its structure and, while it supports features like proxy servers, cookies (to some degree), and SSL, the one thing that it lacks more than anything else is a class interface and component structure that doesn't leave you bathed in tears. Still, more elaborate HTTP solutions are often wrappers around the standard Java interfaces and, if you don't need all the abstraction provided, for example, by Apache HttpClient interfaces, the stock Java classes may not only be sufficient, they also perform much better thanks to a much slimmer, more low-level implementation.

Using JSON forms with AJAX in Lift Framework

Lift has several different ways of interacting with forms and AJAX, and you can quite easily configure Lift to create an AJAX form using SHtml. SHtml contains many useful methods and should be your main port of call for all of the out-of-the-box AJAX functionality. One of the other interesting facilities that this object provides is the ability to create forms that are serialized and sent to the server using JSON. Listing 1 details an example of using a JSON form.

Templates in Lift Framework

Templates in Lift are always fully valid, XHTML markup�Lift does not let you write invalid markup. In an abstract sense, think of these templates as XML input to your snippets that actually do the dynamic transformation. However, templates have a lot more functionality than just being a place to invoke snippets! In the same way that Lift helps keep your server code cleanly separated, Lift offers some convenient helpers for your templates as well.

DataSource through Java Naming and Dictionary Interface (JNDI)

That's one hell of a title but don't worry�it's far, far simpler than it sounds! JNDI is one of those technologies that has been kicking around in the Java ecosystem for a long time and has changed as the years have passed. These days, most people are familiar with using JNDI to get a DataSource object for their applications through a servlet or application container such as Jetty or Tomcat.

Routing Using Camel�s Implementation of the EIPs

In Apache Camel, routing is a more general concept. It's defined as a step-by-step movement of the message, which originates from an endpoint in the role of a consumer. The consumer could be receiving the message from an external service, polling for the message on some system, or even creating the message itself. This message then flows through a processing component, which could be an enterprise integration pattern (EIP), a processor, an interceptor, or some other custom creation. The message is finally sent to a target endpoint that is in the role of a producer. A route may have many processing components that modify the message or send it to another location or it may have none, in which case it would be a simple pipeline.

Introduction to Spring LDAP

In this article Spring LDAP which provides a simplified wrapper framework around LDAP implementations is covered in detail. This article assumes that the reader has a basic understanding on Spring framework and LDAP directory server. The first section of the article covers the various operations that can be performed on LDAP. Support for parsing externally stored LDAP data is also covered with the help of LDIF data. The ODM Manager APIs for mapping LDAP objects directly to java objects have also been explored in this article. If you are beginner in learning spring framework, please read Introduction to Spring Framework.

How to integrate legacy views with designer tools in Griffon

Views in Griffon are responsible for composing the visuals of your application. Hundreds of components can be used to create a View. No matter which you choose you will be able to compose them in the same manner, via a specialized domain-specific language (DSL) based on Groovy's SwingBuilder. However, you may not be able to build a new application from scratch every time. There will be times where it's best to reuse an existing View, which may rely on external libraries and/or layouts.

How to configure SwingXBuilder in Griffon

We are going to take a close look at some Griffon-related builder extensions that can make your life as a developer easier. SwingBuilder is one of the builders that can be configured on a Griffon application. SwingXBuilder is one of the official builder extensions. We'll cover each one of them briefly. Let's start with SwingXBuilder.

Creating a Simple Tracer Plugin/Addon in Griffon Framework

Everybody knows that, as an application grows, it gets harder and harder to visualize data flows because the user interacts with it. Oftentimes during development, we rely on two techniques to keep track of the data flow: launch the application in debug mode, attach it to a debugger, place some breakpoints at the appropriate places, and see the data live; or, litter the code with println statements. However, there is a third alternative: dynamically intercept method calls. Seasoned Java developers may recognize this technique as applying an around advice or a before advice, as suggested by Aspect Oriented Programming (or AOP for short). AOP became very popular in the early 2000s and successfully penetrated the enterprise in tandem with the Spring framework. If AOP is an alien concept to you, don't worry, Groovy greatly simplifies applying AOP-like techniques thanks to its extensive metaprogramming capabilities; this means you do not need to learn an AOP framework nor an AOP API in order to enhance your application.

Building a custom security plugin in ActiveMQ

While the built-in security features in ActiveMQ provide enough functionality for the majority of users, an even more powerful feature is available. The ActiveMQ plugin API is extremely flexible and the possibilities are endless. The flexibility in this functionality comes from the BrokerFilter class in ActiveMQ. This class provides the ability to intercept many of the available broker-level operations. Broker operations include such items as adding consumers and producers to the broker, committing transactions in the broker, and adding and removing connections to the broker, to name a few. Custom functionality can be added by extending the BrokerFilter class and overriding a method for a given operation.

Interceptor Plugin in ActiveMQ

ActiveMQ provides the ability to supply custom code in order to extend broker functionality. Doing so requires a good understanding of the ActiveMQ broker internals, which, unfortunately, is outside the scope of this article. However, there are some ActiveMQ broker interceptor plugins that are provided with the ActiveMQ distribution.

PortletSession-based Inter-Portlet Communication

Inter-portlet communication using PortletSession is one of the most widely used techniques since Portlet 1.0. Data stored in APPLICATION_SCOPE of PortletSession can be shared with servlets/portlets that form part of the same portlet application.

Accessing Portlet-specific Objects in JSP Pages

In general, your JSP pages will use a combination of portlet and servlet objects to generate content. For instance, if you want to set the expiration time for the content in the JSP page, you will use the RenderResponse portlet object. If you need to obtain the value of an APPLICATION_SCOPE portlet session attribute, you may prefer to use session (which refers to HttpSession object) or sessionScope (which is a java.util.Map of session attributes stored in HttpSession object) for a JSP implicit object to obtain its value.

Displaying Data Using DataTable in Apache Wicket

Apache Wicket is one of the most famous Java web application frameworks. Wicket simplifies web development and makes it fun. Are you bored of going through countless pages of theory to find out how to get your web development done? With this book in hand, you don't need to go through hundreds of pages to figure out how you will actually build a web application. You will get practical solutions to your common everyday development tasks to pace up your development activities.

Configure Spring Batch to Retrying on Error

You can configure Spring Batch to retry operations transparently when they throw exceptions, without any impact on the application code. Because transient failures cause these exceptions, we call them retriable exceptions.

Using ManifoldCF Styles

The styles that ManifoldCF makes available for a connector's UI component to use are necessarily limited, since every connector must present itself within the confines of the tab structure in the crawler UI. This may offend those readers who bring a graphics design skill set to the process of writing a connector.

Thread Contexts in ManifoldCF

To save work, ManifoldCF provides a mechanism for keeping around data that is local to a persistent thread. This thread-local storage mechanism is called a thread context. You will find that many of the classes and methods in ManifoldCF require a thread context as an argument. The type of the argument is org.apache.manifoldcf.core.interfaces.IThreadContext.

Managing Output Connection Definitions in ManifoldCF

When you click on the List Output Connections link on the navigation menu, you enter the area of the UI that manages output connection definitions. We will need an output connection definition of some kind in order to demonstrate web crawling. But we can certainly make do with an output connection that uses the null output connector. Nevertheless, let's visit some UI pages, so we can discuss them in greater depth.

Exiting Blocks and Methods in Groovy

Although it's nice to have code that reads like a simple list of instructions with no jumping around, it's often vital that control is passed from the current block or method to the enclosing block or the calling method or sometimes even further up the call stack. Just like in Java, Groovy allows this to happen in an expected, orderly fashion with return, break, and continue statements and, in emergency situations, with exceptions. Let's take a closer look.

Objects in Groovy

In Groovy, everything is an object. It is, after all, an object-oriented language. Groovy doesn't have the slight fudge factor of Java, which is object-oriented apart from some built-in types. In order to explain the choices made by Groovy's designers, we'll first go over some basics of Java's type system. We will then explain how Groovy addresses the difficulties presented and, finally, examine how Groovy and Java can still interoperate with ease due to automatic boxing and unboxing where necessary.

JavaScript in PDF Documents using iText

JavaScript is a scripting language that is primarily used to add client-side functionality to an HTML page and to create dynamic web sites. It allows programmatic access to objects within the web browser. JavaScript is also available in PDF viewers such as Adobe Reader. There's a JavaScript API for PDF documents that extends the core Client-Side JavaScript specification and gives you access to Acrobat and Adobe Reader objects. Initially, JavaScript 1.2 was used. Since Acrobat 5.0, the API is based on JavaScript 1.5. The most recent versions of Acrobat and Adobe Reader (since 8.0) use JavaScript 1.6. If you want to know more about the complete set of objects and functions, you can download the PDFs "Developing Acrobat Applications Using JavaScript" and the "JavaScript for Acrobat API Reference" from the adobe.com site. We're going to use some of the objects listed in that reference to learn how to introduce JavaScript in a PDF document using iText.

JavaScript Communication between HTML and PDF in iText

Imagine the following situation: you have a catalogue with thousands of items stored in a database. People can purchase these items online using a PDF form. How will you create that form? Surely, you don't want to embed your complete article database in a choice field inside your PDF. It would be much easier to provide browse or search functionality in an HTML page and then find a way to pass this data from the HTML pages to the PDF form.

Creating a Raw Image in iText

An image consists of a series of pixels. Each pixel has a color. The color value of the sequence of pixels can be stored in a byte array, and the byte array can be compressed, for instance, using zlib/flate compression. Figure 1 shows some images that were created byte per byte.

Dealing with Directories and Directory Trees in Java 7.0

Welcome to J The ability to navigate directories has been given a major overhaul in Java 7. The addition of the new java.nio.file.DirectoryStream interface and its implementing classes allow you to perform the following broad functions:

Core Concepts of the Java Memory Model (JMM)

The Java Memory Model (JMM) is described in section 17.4 of the Java Language Specification (JLS). This is quite a formal part of the spec and describes the JMM in terms of synchronization actions and the mathematical construct known as a partial order. This is great from the point of view of language theorists and implementers of the Java spec (in other words, compiler and VM makers) but not as good for application developers who need to understand the details of how their multithreaded code will execute.

Visualizing Memory Usage with VisualVM

VisualVM is a visualization tool that ships with the standard Oracle JVM. It has plugin architecture and, in one standard configuration, can be used as a more convenient replacement for the now venerable JConsole. In figure 1, we show a standard VisualVM summary screen.

Spring Roo and JPA Entities

In this article, we'll tell you how to relate entities to each other using the Roo shell. You'll use the field reference and field set commands, which establish JPA relationships via collections and references. We will explore various relationships, including one to many, many to many, and inheritance hierarchies. Let's begin by discussing the concept of relationships within JPA.

The Bean Validation API in Spring Roo Framework

The Bean Validation API is a recent standard. It was created by the Java EE Expert Group to address the lack of a standard validation API on the Java EE platform. This API uses Java annotations to define specific rules, which are attached to the attributes of a Java Bean. Some validations are built into the framework,

Internationalization in JSF 1.x

In the current arena of Globalization, the user base of a web application has been extensively increasing day by day. With this huge increase in the user base, it is very essential that the applications are very well understood and interpreted by people of different cultures and different languages. It is then, the whole concept of Internationalization becomes very vital for a web application.

Oracle Weblogic 10.3.2 Campaign

This post is to present the steps for creating a Campaign in Weblogic Portal that illustrates some vague points about it. The campaign target is to show an advertisement in a placeholder, within some interval (start and end dates), with some goals to be reached before the end date of the campaign.

Creating Tags using Rails

Tags in a ticket-tracking application are extremely useful for making similar tickets easier to find and manage. In this article, we will create the interface for adding tags to a new ticket. This involves adding a new field to the new ticket page and defining a has_and_belongs_to_many association between the Ticket model and the not-yet-existent Tag model.

How to write comments controller using Rails?

In a ticket-tracking application, tickets aren't just there to provide information of a particular problem or suggestion; rather, they're there to provide the workflow for it. The general workflow of a ticket is that a user will file it and it'll be classified as a "new" ticket. When the developers of the project look at this ticket and decide to work on it, they'll switch the state on the ticket to "open" and once they're done mark it as "resolved". If a ticket needs more information on it then another state such as "needs more info". A ticket could also be a duplicate of another ticket or it could be something that the developers determine isn't worthwhile putting in. In cases such as this the ticket may be marked as "duplicate" or "invalid," respectively.

Happy Path Testing in Spring TestContext Framework

Among the simplest sort of integration tests are those that test for routine, nonexceptional behavior, often called "happy path" behavior in testing circles. This might involve for instance requesting an object from a web-based interface, having all the backend transactional magic happen (for example, hitting a database), and then verifying that the returned result is what's expected. As this type of test forms the basis for more sophisticated tests, it makes for a good starting point, so we'll explore happy path integration testing in this recipe.

Separating Roles and Permissions in Spring Security

The goal behind separating roles and permissions is to avoid embedding security policy decisions in the code. Such decisions should be set at runtime since they vary across customers, they vary over time, and sometimes they need to be changed immediately (for example, in response to a security breach).

Test Driven Development in Java

Test driven development a software development methodology which ensure at an early stage that the code written by the developer is what it is supposed to do, which eventually improves the design, produces testable code and reduces the amount of re-engineering that would have been necessary because of the wrong assumptions. Test Driven Development (TDD) is widely used in extreme Programming. This document gives an overview on TDD.

Using Channels in Spring Integration

One distinctive trait of Spring Integration, which differentiates it among other enterprise integration frameworks, is the emphasis that the channels play in defining the enterprise integration strategy. They're not just plain information transfer components, but they play an active role in defining the overall application behavior. The business processing takes place in the endpoints, but you just have to alter the channel configuration to completely change the application's runtime characteristics.

Bulletproof Job Scheduling in Java

A bulletproof job is able to handle errors gracefully; it won't fail miserably because of a minor error like a missing comma. It won't fail abruptly either for a major problem like a constraint violation in the database. Before giving some guidelines on the design of a robust job, let's list some requirements that a job must meet.

Launching a Spring Batch Job

You're about to see that launching a Spring Batch job is quite simple thanks to the Spring Batch launcher API. But, how you end up launching your batch jobs depends on many parameters, so we provide you with basic concepts and some guidelines. By the end of this article, you'll know where to look to set up a launching environment for your jobs.

Transaction Management in Spring Batch Components

Spring Batch handles transactions at the step level. This means that Spring Batch will never use only one transaction for a whole job (unless the job has a single step!). You're likely to implement a Spring Batch job in one of two ways: using a tasklet or a chunk-oriented step. Let's see how Spring Batch handles transactions in both cases.

Treating POJOs like POGOs

POGOs have more capabilities than POJOs. For example, all POGOs have a map-based constructor that is very convenient for setting properties. The interesting thing is that, even if a class is written in Java, many of the same conveniences apply as long as it is accessed from Groovy.

Working with BlazeDS Messaging Services using Flex 4.0

The BlazeDS Message Service enabled with publish/subscribe mechanism and infrastructure to allow Flex application to publish and subscribe messages to a collection of messaging destinations with providing the building of real time data push and applications with collaboration. The following steps creates a simple Cricket score card application that helps in understanding the BlazeDS Message Service

Working with BlazeDS Remote Data Services using Flex 4.0

BlazeDS is a collection of data services that help and simplify building of data driven RIA. They also improve the performance of remote data access operations. BlazeDS supports and enables real time data push and asynchronous collaborative applications. BlazeDS service is deployed on Java EE web/application server.

Stateless Session Beans in EJB 3.0

Stateless session beans are probably the most common bean type used in an application. A stateless session bean doesn't maintain a conversational state. This means that session beans tasks must be completed in a single method call. This does not limit a stateless session bean to containing only one method. To the contrary, a stateless session beans usually contain at least several closely related business methods. Of the session bean types, stateless session beans have the best performance characteristics. To understand why, take a close look at figure 1 that shows a high-level schematic of how stateless session clients typically use beans.

Using CDI with EJB 3.0

CDI plays a vital role by providing robust, next-generation, annotation-driven dependency-injection to all Java EE components including EJB 3. In this article, we will show you some of the most common ways CDI is used with EJB 3 namely, as a more robust replacement to JSF-managed beans and complementing EJB with components that are not in the business tier and do not need to use EJB services directly.

What is Broad Assertion in Unit Testing in Java?

A broad assertion is one that is so scrupulous in nailing down every little detail about the behavior it is checking that it becomes brittle and hides its intent under its overwhelming breadth and depth. When you encounter a broad assertion, it's hard to say what exactly is it supposed check and, when you step back to observe, that test is probably breaking far more frequently than the average because it's so picky that any change whatsoever will cause a difference in the expected output.

Working with Message-Driven Beans

Message-driven beans (MDBs) are EJB components designed to consume asynchronous messages. Although MDBs are intended to handle many different kinds of messages, we'll discuss MDBs that process JMS messages because that is what MDBs are most commonly used for.

Charting with Flex 4.0

Flex charts are persuasive with using static charts and as well animated. Flex enables to create interactive and attractive dashboards also. This article describes how to create charts, the customization, use multiple axes, and support user interaction using Flex. Flex Charts can also be programmed to work with drag-and-drop operations and draw selections on a collection of data points.

Custom Validators in Struts 2.0

Java Database Application with Apache Velocity

JDBC stands for Java DataBase Connectivity. The JDBC API helps us to develop Java applications with data base connection. We can use any database like Oracle,MySql,MSAcess etc.. For developing JDBC Applications we have to depend many APIs from the package java.sql. There are certain steps to do this.

Animations and User Interface in CSS 3.0

Animations allow an author to modify CSS property values over time.Using CSS3 we can create animations. We need to use @keyframes rule in CSS3.Keyframes are specified using a specialized CSS at-rule. CSS3 gives some great new features relating to resizing elements, cursors, outlining, box layout and more.In CSS3, outline has been expanded to include outline-offset property.

The Spring Batch Infrastructure

The Spring Batch infrastructure includes components that launch your batch jobs and store job execution metadata. As a batch application developer, you don't have to deal directly with these components because they provide supporting roles to your applications. However, you need to configure this infrastructure at least once in your Spring Batch application. This article gives an overview of the job launcher, job repository, and their interactions, before showing how to configure persistence of the job repository.

Java ME and Web services

Java Micro Edition (Java ME) is a platform for running applications on smaller devices such as mobile phones, PDAs etc. These devices have restrictions in terms of Memory and Processing power. Java ME defines various configurations and profiles. Midlets are java applications that operate on Mobile Information Device Profile (MIDP) which is targeted on Mobile phones that has limited memory and processing power. If you are new to Java ME please refer to the articles Introduction to J2ME and J2ME User Interface in Java Beat.

Flex 4 Components Exposed

If you've been a Flex developer for a little while now, or you've used a different framework for client side interface creation, you may have heard of the conceptual Model-View-Controller (MVC) architecture. The Flex 4 Spark component architecture puts a little spin on the MVC pattern, and adds a fourth part - the skin. This means that every Spark-based component has the following four pieces to it:

Introduction to Spring OXM

Spring OXM stands for Spring Object XML Mappers and it is a module available in Spring to ease the mapping between java objects and XML documents. The module is extensible and hence it provides integration with various popular frameworks like Castor, JAXB, XmlBeans and XStream. In this article, we will see how to serialize and de-serialize java objects and xml documents using various frameworks with the help of Spring.

Portlets are easy

Portlets are how all functionality is implemented in Liferay Portal, as well as in any other Java portal. Liferay is an ideal platform for serving and aggregating applications of all kinds, from collaborative message boards and wikis to sales force automation tools, customer relationship management tools and other business applications, to social applications such as photo sharing and games. The choices are limited only by your ingenuity and imagination, which I believe are practically limitless because I�ve seen the Liferay community doing all of the above and more with Liferay.

Deploying ActiveMQ for large numbers of concurrent applications

We are going to look at scaling your ActiveMQ applications and examine three techniques to allow you to do that. We will start with vertical scaling, where a single broker is used for thousands of connections and Queues. Then we will look at scaling connections to tens of thousands of connections by using techniques for horizontally scaling your applications using networks. Finally, we will examine traffic partitioning, which will balance scaling and performance but will add more complexity to your ActiveMQ application.

New Features in CSS 3.0

CSS 3.0 is the latest version of CSS. It is completely backwards compatible and all the browsers will always support CSS 2.0. Some latest browsers have implemented the properties of CSS 3.0.

Finding Duplicate Input Elements Using jQuery

This article deals with finding the input elements with duplicate values. Please find below the screenshot of the sample output.

Getting Response through GWT using Http Protocol

This article deals with getting the response from the server side using Google Web ToolKit Framework and Ajax. Google Web ToolKit is one of the Ajax frameworks which is mainly aimed at Java Developers.The main advantage of GWT is that it comes with a compiler which will translate the Java code written by the developers to highly optimized , browser independent Java Script, thereby eliminating the need of front-end developers to know Java.

JSON response from JavaFX HTTP Request

JavaFX is one of the emerging technologies for building RIAs from Sun Microsystems. This document explains how to connect to server from JavaFX applications and parse the response.

Asynchronous File Upload using Ajax, jQuery Progress Bar and Java

In this tutorial you will learn about Asynchronous File Upload using Ajax, jQuery Progress Bar and Java The image below shows a screenshot of the file upload that we are going to learn in this tutorial.

Apache Axis2 Web Services

SOA, in practicality web services, is becoming the enabler for application integration. Since the introduction of web services, Apache Software Foundation has played a major role and produced several good web services frameworks. This book covers the defector Java Web Service framework, also known as Apache Axis2. This book covers several important facts that you would want to know about web services and writing, from simple web services to complex web services. By the end of this book, you will have learned about Axis2, its architectures and features, writing and deploying a simple service, writing service extensions and quality of services, POJO and JAX-WS services, clusters, and secure reliable web services.

Accessing Server Side Data using Flex 4.0

Flex provides 3 classes to communicate with servers namely HttpService,WebService and RemoteObject HTTPService component of Flex 4 can be used with any kind of server-side technology, including PHP pages, ColdFusion Pages, JavaServer Pages (JSPs), Java servlets.

Custom Interceptors in Struts 2.0

Struts 2.0 is the popular Open Source Presentation Tier framework developed by Apache Group. It is based on MVC Model 2 design pattern. Dispatcher Filter is the front controller for the struts2 based applications. Struts 2.0 has simplified web development for its users by introducing POJO based actions, interceptors, flexible validation and support for many different result types. Struts can be used to build the user interface tier of the enterprise application. Interceptors can be used to embed the cross cutting or plumbing logic of the application in a clean and reusable manner. This article explains the concept of custom interceptors.

Jasper Reports and Data Sources

In this article the focus will be on the last point; i.e. the Support Jasper Reporting architecture provides for accessing data from various kinds of data sources. We will look into how a developer can use the powerful API support that jasper provides to handle the following types of data sources for creating the reports.

Spring with Apache Velocity

Spring is an open source framework, created by Rod Johnson. We can develop many kinds of applications using Springwhich includes basic java programs and enterprise applications. Any Java application can benefit from Spring in terms of simplicity, testability, and loose coupling. Spring supports integration with Struts, WebWork, Apache velocity , Hibernate, JDO, TopLink, EJB, RMI, JNDI, JMS, Web Services, etc.

Introduction to Spring REST Services

This article provides an introduction to Spring's REST services. The first section of the article provides a good introductory knowledge to the basics of REST services following by a sample application. The next section extends the introductory part by providing a bit complicated implementation by supporting the various protocol methods exposed and supported by the service. Later on, the article goes on in explaining the RestTemplate API , which is the client interface template for accessing RESTful services. The final section of this article provides a sample thereby integrating the RESTful services in the Spring's Web Tier. If you are beginner looking for basic concepts on Spring Framework, please read Introduction to Spring Framework.

Introduction to Spring Validation

In this article, we will see the usage of Spring Validators. Spring provides a simplified set of APIs and supporting classes for validating domain objects. As always, the framework is extensible and it is possible to hook-in custom validator implementations into the framework. This article starts in explaining the basics of Spring validator by guiding to write a custom validators for simple and complex objects. Later on, it explores the theory behind 'message codes resolver' and illustrates the usage of writing customized version of the same. Finally, the article concludes in the usage of validator in the Web tier. This article assumes that readers has the sufficient knowledge on Spring Framework. If you are beginner looking for basic concepts on Spring Framework, please read Introduction to Spring Framework.

Struts 2.0 and JPA Integration

Struts 2.0 is the popular Open Source Presentation Tier framework developed by Apache Group. It is based on MVC Model 2 design pattern. Dispatcher Filter is the front controller for the struts2 based applications. Struts 2.0 has simplified web development for its users by introducing POJO based actions, interceptors, flexible validation and support for many different result types. Struts can be used to build the user interface tier of the enterprise application. Whereas, any of the popular ORMs like Hibernate, JPA, iBatis can be used for the persistence tier of the application. Struts2 provides easy integration with these persistence tier frameworks. This article demonstrates the integration of Struts 2.0 applications with the Java Persistence API (JPA). The concept is explained with the help of a sample application. Knowledge of JPA and Struts 2.0 is the prerequisite for this article.

Invoking SOAP and RESTful Web Services using Flex 4.0

Flex 4.0 framework facilitates to interact with various kinds of RPC services. Flex Applications can invoke traditional Web Services or Restful web services that returns XML, JSON etc. MXML�s RPC components provides access to SOAP (Simple Object Access Protocol) based web services and Restful web services using HTTP Services. Flex supports requests and responses of web services which are defined as SOAP messages. SOAP defines a standard for communicating the request and response using XML between the Service provider and consumer. The proxy service for LCDS (LiveCycle Data Services) and BlazeDS intercepts requests to web services located remotely, redirects the requests, and returns the responses to the consumers.

Creating Services in Android

Services in Android are components which run in the background. They do not have any user interface. One application can start a service and the service can run in the background even if this application is switched with a new application by the user. There are two types of services namely Unbound Service and Bound Service Unbound Service is a kind of service which runs in the background indefinitely, even if the activity which started this service ends. Bound Service is a kind of service which runs till the lifespan of the activity which started this service. In this article we are going to see step by step procedure to how to create an unbound service.

Create applications using ObjectDb and JPA in NetBeans

I have been developing Java applications for a long time and the major difficulty was the coding part related to database manipulations. Recently I shifted to use Object-Relational Mapping through JPA. I have used TopLink, EclipseLink, and Hibernate. Although I could achieve the functionally I want with ease, the output was slower when compared to normal method of database connection with JDBC. Then I used some Object databases like neoDatis. They were quite faster, yet I was reluctant to proceed as most of them had their own standards and did not comply to JPA. Finally I found the ObjectDB, an Object database for Java which completely supports JPA.

Integrating Struts 2.0 applications with Hibernate

Struts 2.0 is one of the popularly used Presentation tier framework for Java web Applications.It is based on the WebWork2 technology.Struts 2.0 framework implements MVC 2 architecture by centralizing the control using a Front Controller strategy. The extensible and flexible nature of Struts 2.0 makes it the favourite choice of Java web developers. The major features of Struts 2.0 are user interface tags, Interceptor, result and validation. A strong persistence framework is critical to the success and scalability of any application that we develop. Today we have a lot of data access frameworks like Hibernate, JDBC, JPAs, etc available in the market. Sturts can be integrated easily with any of these popularly used data access frameworks.

Introduction to Groovy Server Pages (GSP)

This article is about Groovy Server Pages basic concepts. Groovy Server Pages (GSP) is a view technology which can be used for designing web application using Grails Framework. Developing GSP are very much similar to that of designing web pages with Active Server Pages (ASP) and Java Server Pages (JSP) but coding is very much simpler and easier than both of them. Users are provided with facility of having static, dynamic as well as mix of both contents at a time in a single application. The output can be dynamically rendered to different forms like : HTML, XML, text and any other format based on Web client request object.If you are beginner in learning groovy, please read Introduction to Groovy - Scripting Language.

Introduction to Spring Converters and Formatters

In this article, we will provide introductory details on Spring Converters and Formatters. Converter components are used for converting one type to another type and also to provide a cleaner separation by forcing to place all such conversion related code in one single place. Spring already supports built-in converters for the commonly used types and the framework is extensible enough for writing custom converters as well. Spring Formatters come into picture to format the data according to the display where it is rendered. Examples may include formatting date/timestamp values according to locales etc. The first section of this article deals with Converters whereas the rest deals with Formatters and plenty of code samples are given at appropriate places for better illustration. This article assumes that readers has the sufficient knowledge on Spring Framework and its workflow. If you are beginner looking for basic concepts on Spring Framework, please read Introduction to Spring Framework and Introduction to Spring Web Flow (SWF). The following section provides the list of popular articles in the Spring Framework.

Extending ViewResolver and Chaining ViewResolvers in Spring MVC

In Spring MVC view resolvers help the Dispatcher Servlet in identifying the views which has to be rendered in response for a request. There are lot view resolvers available in Spring framework. For example: InternalResourceViewResolver, ResourceBundleViewResolver, XmlViewResolver etc. If needed, the programmers can have custom view resolvers by extending existing view resolver implementation or implementing the ViewResolver interface. Spring applications also support configuration of multiple view resolvers. This article, will explain, chaining view resolvers and extending view resolvers in detail. This article assuming that reads have the basic knowledge on the Spring MVC framework. If you don't have sufficuent knowledge on the topic, please read Introduction to Spring MVC before start reading this article.If you are looking ot buy spring books, here is the list of spring books.

Introduction to Spring Expression Language (SpEL)

The article Introduction to Spring Expression Language (SpEL) will provide introductory details in writing expression languages using Spring's Expression framework. The reader is expected to having a basic understanding on the core concepts of Spring before reading this article (Read: Introduction to Spring Framework). This article explains the usage of Spring's Expression API for writing and parsing expressions. This article includes plenty of code samples for illustrating the concepts of expressions by explaining how to write custom functions and custom bean resolvers, accesing java methods etc. Later on, the article provides details about writing expressions pertaining to collections and modifying variables. The miscellaneous section of the article explains the usage of T operator and null-safe operator.

New Features in Google Android 2.3

Android is the first open source software stack for mobile/handheld devices. Android predominantly provides support for building rich and flexible mobile apps. Android platform includes a compatible Linux kernel based OS, rich UI, applications, support libraries, application frameworks, support for multimedia, and more. The underlying OS components are written in C/C++ and user applications are built for Android in Java.

Internationalisation(i18n) in GWT Application

Internationalization is the technique of designing the application to be attuned with different regions or countries where the application needs to be run. Internationalization requires separation of the usage data to be internationalized into properties file. In the Java programming language, internationalization is usually implemented by means of Resource Bundles i.e., a .properties file for each locale that needs to be supported. GWT also uses the same mechanism of implementing internationalization using Resource Bundles.

Using YUI to attach JavaScript event listeners

Welcome to Yahoo User Interface 2.x Cookbook. The Yahoo! User Interface (YUI) Library is a set of utilities and controls, written in JavaScript, for building richly interactive web applications using techniques such as DOM scripting, DHTML, and AJAX. Although you can create stylish Internet applications by modifying its default components, even advanced users find it challenging to create impressive feature-rich Internet applications using YUI. This book will help you learn how to use YUI 2.x to build richer, more interactive web applications that impress clients and wow your friends. It starts by explaining the core features of YUI 2.x, the utilities that the rest of the library depends on and that will make your life easier. It then explains how to build UI components and make AJAX requests using the YUI framework. Each recipe will cover the most common ways to use a component and how to configure it, and then explain any other features that may be available. We wrap things up by looking at some of the recent beta components and explain how to use them, and how they may be useful on your web application.

OSGi and Apache Felix 3.0

The OSGi specification is a module system and service platform that implements a complete and dynamic component model. Wasn't that a complicated definition! So how would you really use it to practical modular applications? Let this book break down the seemingly overwhelming OSGi standards for you by explaining Apache Felix's powerful architecture in a simple and easy-to-understand manner using Apache Felix framework to get you up and running sooner than you expect.

JBoss AS 5 Performance Tuning

JBoss AS 5 Performance Tuning will teach you how to deliver fast applications on the JBoss Application Server and Apache Tomcat, giving you a decisive competitive advantage over your competitors. You will learn how to optimize hardware resources, meeting your application requirements with less expenditure. The performance of Java Enterprise applications is the sum of a set of components including the Java Virtual Machine configuration, the application server configuration (in our case, JBoss AS), the application code itself, and ultimately the operating system. This book will show you how to apply the correct tuning methodology and use the tuning tools that will help you to monitor and address any performance issues.

Google Web Toolkit (GWT) 2.0 Application Development

GWT 2.0 radically improves the web experience for users by using the existing Java tools to build a no-compromise AJAX for any modern browser. It provides a solid platform so that the other great libraries can be built on top of the GWT. Creating web applications efficiently and making them impressive, however, is not as easy as it sounds. Writing web applications for multiple browsers can be quite tasking. In addition, building, reusing, and maintaining large JavaScript code bases and AJAX components can be difficult. GWT 2.0 Application Development Cookbook eases these burdens by allowing the developers to build and maintain complex, yet highly efficient JavaScript frontend applications in the Java programming language quickly. It tells you how to make the web experience all the more thrilling and hassle-free by using various tools along with the GWT SDK.

Google App Engine Java and GWT Application Development

This book is designed to give developers the tools they need to build their own Google App Engine (GAE) with Google Web Toolkit (GWT) applications, with a particular focus on some of the technologies useful for building social-media-oriented applications. The book is centered on a GAE + GWT Java application called Connectr, which is developed throughout the chapters and demonstrates, by example, the use of the technologies described in the book. The application includes social-media information gathering and aggregation activities and incorporates the use of many App Engine services and APIs, as well as GWT design patterns and widget examples. Several stages of the Connectr application are used throughout the book as features are added to the app. Code is included with the book for all application stages, and each chapter indicates the stage used.

History Management in GWT

GWT is a toolkit used to write AJAX applications using java language. It comes with Java to JavaScript compiler and a special browser that helps in debugging the GWT applications. GWT Provides lot of user interface widgets that can be utilized to create new applications.There are two modes of running GWT application. They are: 1. Development mode 2.Production mode. In Development Mode, the application runs java byte code within the JVM. As it runs within the JVM it takes the advantage of java�s debugging facilities. In Production Mode ,the application run�s as JavaScript and HTML using GWT compiler which converts Java code to JavaScript.

New Features in Flex 4.0

This article explains the new features introduced in the latest version Flex 4.0. Initial version of Adobe Flex has been released in 2004. In 2008 Adobe has released the version Flex 3.0. But, the latest version of Flex has many improvements compare to its previous releases. If you are not familiar with developing applications using the Flex framework, please read our previous article on Creating RIA with Adobe Flex framework by Raja. That article explains more about the setting up the flex environment and writing the simple hello world example. It is recommended to read before jumping into this article.

Configuring Multiple Databases in Hibernate

Hibernate is designed to be used with a large set of databases. The details of those databases are configured in an XML file called hibernate.cfg.xml. This configuration files could be given any name and is usually placed in the root of your application class path. There are many configuration parameters available that makes the mapping of domain model to relational model easier. The same configurations can be done from your Java class uning org.hibernate.cfg.Configuration class. If you are beginner in Hibernate, please read our article on Introduction to Hibernate ORM Framework by Raja.

What is Ext GWT 2.0?

Ext GWT 2.0: Beginner's Guide is a practical book that teaches you how to use the Ext GWT library to its full potential. It provides a thorough, no-nonsense explanation of the Ext GWT library, what it offers, and how to use it through practical examples. This book provides clear, step-by-step instructions for getting the most out of Ext GWT and offers practical examples and techniques that can be used for building your own applications in Ext GWT.

Creating Database aware applications in Ruby on Rails

In this article, we will explore the capabilities of Ruby with respect to the Data Tier. One can understand the power of Ruby which greatly simplifies the development of data aware applications after reading this article. This is mainly because of the abstraction introduced in Ruby in the form of Active Record. Active Record defines the object relational mapping between Ruby objects and Database tables. The first section of this article will deal with Active Record and how to work with CRUD operations using it. The later section of the article guides in developing a full-blown web application using the Active Record API.

Managing transactions in EJB 3.0

Transaction represents a group of activities that must be performed as a single work unit. This clarifies that a transaction is complete if and only if all the work items within a work group results in success. If any of the work items fails, then the transaction as a whole will be treated as a failure. Managing transactions is vital not only for Enterprise applications but also for any flavour of applications. In this article we will explore the various services provided by the EJB container with respect to transaction management. This article assumes that the reader has a basic understanding on EJB technology such the various EJB containers, enterprise beans etc along with the fundamental concepts of transactions such as ACID properties, commit and rollback.

Integrating Spring Web Flow with JSF

Spring Web Flow is a framework that provides abilities to developers to capture the workflow of a web application in the form of configurational constructs called Flows. JSF is a UI framework that provides support for developing complex user interface components along with simplified page navigation rules and event handling. In this article we will discuss about the integration techniques between Spring Web Flow and JSF with the assumption that the readers have a good understanding of these two technologies.

Creating RIA with Adobe Flex framework

Adobe Flex provides a platform for developing Rich Internet applications (RIA). Adobe Flex is not one thing but it is a combination of various languages, frameworks and builders like MXML, Action Script, SDK and Flex Builder. For creating Adobe Flex applications, we use the markup language MXML which is similar to XML in syntax. Action Script is the scripting language that provides dynamic capabilities. The Adobe Flex SD includes a rich set of APIs for building complex user applications and finally Flex Builder is an IDE based on Eclipse base platform that provides developmental support for building applications.

SimpleDB versus RDBMS

We have all used a Relational Database Management System (RDBMS) at some point in our careers. These relational databases are ubiquitous and are available from a wide range of companies such as Oracle, Microsoft, IBM, and so on. These databases have served us well for our application needs. However, there is a new breed of applications coming to the forefront in the current Internet-driven and socially networked economy. The new applications require large scaling to meet demand peaks that can quickly reach massive levels. This is a scenario that is hard to satisfy using a traditional relational database, as it is impossible to requisition and provision the hardware and software resources that will be needed to service the demand peaks. It is also non-trivial and difficult to scale a normal RDBMS to hundreds or thousands of nodes. The overwhelming complexity of doing this makes the RDBMS not viable for these kinds of applications. SimpleDB provides a great alternative to an RDBMS and can provide a solution to all these problems. However, in order to provide this solution, SimpleDB makes some choices and design decisions that you need to understand in order to make an informed choice about the data storage for your application domain.

How to perform indexing in MySQL?

MySQL is the most popular open-source database and is also known for its easy set up feature. However, proper configuration beyond the default settings is still a challenge, along with some other day-to-day maintenance tasks such as backup and restoring, performance tuning, and server monitoring.

Cloning Internet Applications with Ruby

One of the most dominant Internet services today is the social networking service. According to a report by the Nielsen Company, in January 2010, the amount of time an average person spent on Facebook is more than seven hours per month, which amounts to more than 14 minutes per day. If you lump together the time spent on Google, Yahoo!, YouTube, Bing, Wikipedia, and Amazon, it still doesn't beat Facebook! By March 2010, Facebook accounted for more than seven percent of all Internet traffic in the United States, surpassing visits to Google. Social networking services have risen in the past few years to be more than just a passing fad, to be an important communications tool as well as a part of daily life.

Writing JSF applications for J2ME clients

JSF is a Web framework for developing Component oriented web applications in the User Interface layer. Amongst the various capabilities that JSF provides, one of the major strengths of JSF is that it is not tied to any specific target device. For example, currently most of the JSF applications are running in a web server and are accessible through a web browser. However, web browser is not the only target for a JSF application to be viewed; it can be even accessed through a hand-held device, for example through a mobile phone. In this example, we will see how to develop JSF applications targeted for mobile phones. This article assumes that the reader has a good understanding of JSF, its life-cycle and some understanding on JSF renderer kits.

Securing EJB Applications

In this article, we will see the various aspects in securing an EJB Application. Security is vital not only for an enterprise application but also for any kind of application. It is essential to identify the system or the users accessing the applications and to provide access or denial for resources within the application based on some criteria. The point is that not every user should be given the rights to access sensible data and there must be some identification mechanism to distinguish this boundary. EJB specification for security falls in Declarative and Programmatic mode, the EJB Container owns the responsibility of establishing security for enterprise beans in the former mode whereas the application developer has to embed security specific code in the enterprise bean in the latter mode.

Service-Oriented Architecture� An Integration Blueprint

The Trivadis Integration Architecture Blueprint specifies the building blocks needed for the effective implementation of integration solutions. It ensures consistent quality in the implementation of integration strategies as a result of a simple, tried-and-tested structure, and the use of familiar integration patterns (Hohpe, Wolf 2004).

Introduction to Ruby On Rails

This article provides an introduction to Ruby on Rails. Ruby is a programming language that is interpreted and Rails is a framework written on top of Ruby for writing Web Applications. The article starts with an introduction to Ruby with respect to the basic syntax usage and provides plenty of samples for illustrating conditional constructs and looping constructs. Also the advanced concepts like Classes /Objects and modules will also explained with examples. The later section of the article explains Rails and it starts with the basics of the Model View Controller Architecture for writing Rails application.

BIRT 2.6 Data Analysis and Reporting

BIRTis an open source business intelligence and reporting tool, built on top of the Eclipse Framework. BIRTis used by developers for building reports that can best represent data and tell a story of that data that is easy to follow. In addition, BIRTcan be integrated into a product, to allow that product to provide reporting capabilities. This book will walk the user through the basics of building reports with BIRTand introduce them to the various sections of the BIRTenvironment.

Groovy for Domain-Specific Languages

The Java virtual machine runs on everything from the largest mainframe to the smallest microchip and supports every conceivable application. But Java is a complex and sometimes arcane language to develop with. Groovy allows us to build targeted singlepurpose minilanguages, which can run directly on the JVM alongside regular Java code. This book provides a comprehensive tutorial on designing and developing miniGroovybased Domain-Specific Languages. It is a complete guide to the development of several miniDSLs with a lot of easy-to-understand examples. This book will help you to gain all of the skills needed to develop your own Groovy-based DSLs.

Designing and Developing Secure Java EE Applications using GlassFish Security

We are living in a world full of dazzling wonders, and ifor one always enjoy encountering them. Software development is one of the wonders that dazzles me because of its enormously vast domain, including many concerns and subjects of interest. Looking at this domain from any distance, we will see one big and sometimes blurry-edged spot named security. Security, an orthogonal and inseparable part of software systems, is not for preventing others from accessing some information and system resources but for allowing them access in an appropriate way, by implementing necessary means to precisely check any attempt to access a resource and either allow it to go further or not and record all information related to examining this attempt for further review.