Uncategorized

Mobile JSF Kit

laseelan — Fri, 14 Dec 2007 04:36:07 -0700

Internet mobile technology is an indispensable platform for, for example, mobile entertainment, m-commerce and many other mobile applications for internet and enterprises. Increasingly more developers are being faced with the task of moving a web application to mobile end devices.

Front rendering is one of the biggest differences between developing a mobile application and a web application. This is because mobile applications have to cope with hundreds of devices with different markup-language support, different screen sizes and different image support.

Microsoft ASP.NET has the mobile controls that can render for most mobile devices on the market, but Java Enterprise Edition (EE) does not have such a standard today. At the same time, Java EE is a common standard platform for the server-side mobile services.

The Ericsson Mobile JSF Kit provides a JSF library, MobileFaces. It abstracts the difficulties in the development of mobile applications, and enables rendering of different page content for different end devices based on one JSF page. Because of this, MobileFaces can highly reduce the amount of time needed for mobile application development, maintenance and extension.

Spring !!! what it is ?

laseelan — Tue, 19 Jun 2007 02:48:55 -0600

Spring is Java/JEE application framework contains a lot of features, which are well-organized in seven modules

1. Injection features. The basic concept here is the BeanFactory, which provides a sophisticated implementation of the factory pattern which
removes the need for programmatic singletons and allows you to decouple the configuration and specification of dependencies from your actual program logic.

2. The Context package build on the solid base provided by the Core package: it provides a way to access objects in a framework-style
manner in a fashion somewhat reminiscent of a JNDI-registry. The context package inherits its features from the beans package and adds support for internationalization (I18N) (using for example resource bundles), event-propagation, resource-loading, and the transparent creation of contexts by, for example, a servlet container.

3. The DAO package provides a JDBC-abstraction layer that removes the need to do tedious JDBC coding and parsing of database-vendor specific error codes. Also, the JDBC package provides a way to do programmatic as well as declarative transaction management, not only for classes implementing special interfaces, but for all your POJOs (plain old Java objects).

4. The ORM package provides integration layers for popular object-relational mapping APIs, including JPA, JDO, Hibernate, and iBatis. Using the ORM package you can use all those O/R-mappers in combination with all the other features Spring offers, such as the simple declarative transaction management feature mentioned previously.

5. Spring's AOP package provides an AOP Alliance-compliant aspect-oriented programming implementation allowing you to define, for example, method-interceptors and pointcuts to cleanly decouple code implementing functionality that should logically speaking be separated. Using source-level metadata functionality you can also incorporate all kinds of behavioral information into your code, in a manner similar to that of .NET attributes.

6. Spring's Web package provides basic web-oriented integration features, such as multipart file-upload functionality, the initialization of the IoC container using servlet listeners and a web-oriented application
context. When using Spring together with WebWork or Struts, this is the package to integrate with.

7. Spring's MVC package provides a Model-View-Controller (MVC) implementation for web-applications. Spring's MVC framework is not just any old implementation; it provides a clean separation between domain model code and web forms, and allows you to use all the other features of the Spring Framework.

JBoss Seam

laseelan — Tue, 12 Jun 2007 00:58:14 -0600

JBoss Seam is a powerful new application framework for building next generation Web 2.0 applications by unifying and integrating technologies such as Asynchronous JavaScript and XML (AJAX), Java Server Faces (JSF), Enterprise Java Beans (EJB3), Java Portlets and Business Process Management (BPM).

Seam has been designed from the ground up to eliminate complexity at the architecture and the API level. It enables developers to assemble complex web applications with simple annotated Plain Old Java Objects (POJOs), componentized UI widgets and very little XML. The simplicity of Seam 1.0 will enable easy integration with the JBoss Enterprise Service Bus (ESB) and Java Business Integration (JBI) in the future.

http://docs.jboss.com/seam/1.2.1.GA/reference/en/html/tutorial.html

The Return of Scripting Languages (Java 1.6)

laseelan — Tue, 24 Apr 2007 06:24:51 -0600

With the advent of Asynchronous JavaScript and XML (AJAX)-based rich Web applications, scripting languages have made a comeback. This time, the script is meant to run at the client, where scalability generally isn't an issue (each client runs its own browser and hence its own scripts). The result is a very dynamic Web page that includes rich application features with acceptable performance.

Further reasons to use scripting languages in a Web application include dynamic type conversion (automatic conversions from values to strings), access to the operating system environment (as with shell scripts), and the use of specialized Web frameworks for scripting languages. For these reasons, dynamic scripting languages have reemerged on the server as well.

However, this reintroduction of scripting languages has left programmers wanting the following:

Access to the rich resources of the Java platform, as well as custom JAR files, from scripting languages
Access to scripting languages from the Java platform itself

Java SE 6 satisfies both of these requests with JSR 223 (Scripting for the Java Platform). When you join the features of both the Java language and available scripting languages, you can pick and choose the strengths of both environments to use at the same time. For instance, Java developers can access Perl scripts to perform string operations that are best done with Perl. Additionally, AJAX developers can invoke Java objects directly from script embedded within a Web page to perform complex operations. For example, since database access is far less robust (if not impractical) from JavaScript as compared with Java, you can perform this and other complex operations in Java code and simply invoke the Java code from your page's script.

Java SE 6 ships with the Mozilla Rhino scripting engine, but you're free to substitute any available scripting engine that complies with JSR 223. This includes implementations of Python and Ruby. The new javax.script APIs provide access to the scripting environments from Java. For instance, the following code iterates through the list of available scripting engines and outputs the language types and the associated engines:

I will show you a simple example that can both access and modify native Java objects.

ScriptEngineManager mgr = new ScriptEngineManager();

ScriptEngine jsEngine = mgr.getEngineByName("JavaScript");

List<String> namesList = new ArrayList<String>();

  namesList.add("java");

  namesList.add("Servlet");

  namesList.add("JSP");

  namesList.add("JSF");

Invocable invocableEngine = (Invocable)jsEngine;

  try {

    jsEngine.eval("function printNames1(namesList) {" +

                  "  var x;" +

                  "  var names = namesList.toArray();" +

                  "  for(x in names) {" +

                  "    println(names[x]);" +

                  "  }" +

                  "}" +

                  "function addName(namesList, name) {" +

                  "  namesList.add(name);" +

                  "}");

    invocableEngine.invokeFunction("printNames1", namesList);

    invocableEngine.invokeFunction("addName", namesList, "JavaScript");

  } catch (ScriptException ex) {

    ex.printStackTrace();

  } catch (NoSuchMethodException ex) {

    ex.printStackTrace();

You can also create new Java objects in the scripting environment. After importing the necessary Java platform packages, your script can use any native Java class. Instead of printing messages to the console, you could create a Swing message dialog box from your script

try{

    jsEngine.eval("importPackage(javax.swing);" +

        "var optionPane = " +

        "  JOptionPane.showMessageDialog(null, 'Hello, world!');");

}catch (ScriptException ex) {

    ex.printStackTrace();

Welcome to TechieNET.org

Sarath — Sun, 01 Apr 2007 07:23:20 -0600

This is the second try of Drupal for the site after I got tired of the inflexibility of joomla!. Joomla is cool to set up a simple site, or manage the site for non-techinical users. But you if you need to get the things done , you need drupal !