JavaBeat » Tools & IDEs

Creating Simple Web Application Using Apache Maven

Manisha Patil — Sat, 23 Feb 2013 03:30:26 +0000

In the previous post we saw how to create simple Java project using Maven. We will create a simple web application. The goal of this post is to highlight the basic features Maven provides to develop web applications. This post covers the following :

Create simple web application using Maven Archetype plugin.
Prepare the Tomcat Manager application.
Define Tomcat Server in Maven settings.
Point POM to Tomcat Server.
Build and Deploy the web application to Tomcat server.

If you have any questions, please post it in the comments section. If you are interested in receiving the future articles on Java topics, please subscribe here.

Apache Maven 2.0 – Maven Plugins
Buy: Apache Maven Implementation from flipkart.com

Create Simple Web Application using Maven

To create a web application we will use maven-archetype-webapp plugin. Run mvn archetype:generate with an artifactId and a groupId. Open command line window, point to the desired directory (here we are creating project under C:\MVNProject project) and execute the following command:

C:\MVNProject>mvn archetype:generate -DgroupId=net.javabeat -DartifactId=SampleWebapp
-DarchetypeArtifactId=maven-archetype-webapp -DinteractiveMode=false

Maven Commands

mvn : is the Maven command.
archetype:generate : is called a Maven goal, analogous to an ANT target. It describes a unit of work to be completed in a build. The purpose of this goal is to quickly create(goal) a project from an archetype(plugin).
-Dname=value pairs : (DgroupId, DartifactId, DarchetypeArtifactId, DinteractiveMode) These are the arguments which are passed to the goal.They take the form of -D properties, similar to the system property options which you pass to the Java Virtual Machine via the command line.

The output on executing the above command is:

C:\MVNProject>mvn archetype:generate -DgroupId=net.javabeat -DartifactId=SampleWebapp
-DarchetypeArtifactId=maven-archetype-webapp -DinteractiveMode=false
[INFO] Scanning for projects...
Downloading: https://www.javabeat.net/pluginrepo1/org/codehaus/mojo/maven-metadata.xml
Downloading: https://www.javabeat.net/pluginrepo1/org/apache/maven/plugins/maven-metadata.xml
[WARNING] Could not transfer metadata org.apache.maven.plugins/maven-metadata.xml from pluginrepo1
(https://www.javabeat.net/pluginrepo1/): Error transferring file: Connection reset
[WARNING] Could not transfer metadata org.codehaus.mojo/maven-metadata.xml from pluginrepo1
(https://www.javabeat.net/pluginrepo1/): Error transferring file: Connection reset
Downloading: https://www.javabeat.net/pluginrepo1/org/apache/maven/plugins/maven-archetype-plugin/maven-metadata.xml
[WARNING] Could not transfer metadata org.apache.maven.plugins:maven-archetype-plugin/maven-metadata.xml
from pluginrepo1 (https://www.javabeat.net/pluginrepo1/): Error transferring file: Connection reset
[INFO]
[INFO] ------------------------------------------------------------------------
[INFO] Building Maven Stub Project (No POM) 1
[INFO] ------------------------------------------------------------------------
Downloading: https://www.javabeat.net/pluginrepo1/org/apache/maven/plugins/maven-metadata.xml
Downloading: https://www.javabeat.net/pluginrepo1/org/codehaus/mojo/maven-metadata.xml
[WARNING] Could not transfer metadata org.apache.maven.plugins/maven-metadata.xml from pluginrepo1
(https://www.javabeat.net/pluginrepo1/): Error transferring file: Connection reset
[WARNING] Could not transfer metadata org.codehaus.mojo/maven-metadata.xml from pluginrepo1
(https://www.javabeat.net/pluginrepo1/): Error transferring file: Connection reset
Downloading: https://www.javabeat.net/pluginrepo1/org/apache/maven/plugins/maven-archetype-plugin/maven-metadata.xml
[WARNING] Could not transfer metadata org.apache.maven.plugins:maven-archetype-plugin/maven-metadata.xml
from pluginrepo1 (https://www.javabeat.net/pluginrepo1/): Error transferring file: Connection reset
[INFO]
[INFO] >>> maven-archetype-plugin:2.0:generate (default-cli) @ standalone-pom >>>
[INFO]
[INFO] <<< maven-archetype-plugin:2.0:generate (default-cli) @ standalone-pom <<<
[INFO]
[INFO] --- maven-archetype-plugin:2.0:generate (default-cli) @ standalone-pom ---
[INFO] Generating project in Batch mode
[INFO] ----------------------------------------------------------------------------
[INFO] Using following parameters for creating project from Old (1.x) Archetype: maven-archetype-webapp:1.0
[INFO] ----------------------------------------------------------------------------
[INFO] Parameter: groupId, Value: net.javabeat
[INFO] Parameter: packageName, Value: net.javabeat
[INFO] Parameter: package, Value: net.javabeat
[INFO] Parameter: artifactId, Value: SampleWebapp
[INFO] Parameter: basedir, Value: C:\MVNProject
[INFO] Parameter: version, Value: 1.0-SNAPSHOT
[INFO] ********************* End of debug info from resources from generated POM ***********************
[INFO] project created from Old (1.x) Archetype in dir: C:\MVNProject\SampleWebapp
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 10:01.500s
[INFO] Finished at: Fri Feb 22 21:32:54 IST 2013
[INFO] Final Memory: 8M/24M
[INFO] ------------------------------------------------------------------------

Maven creates the complete web based java application project structure as in the screen below:

We see that a default pom.xml has been created. POM file generated is:


  4.0.0
  net.javabeat
  SampleWebapp
  war
  1.0-SNAPSHOT
  SampleWebapp Maven Webapp
  http://maven.apache.org
  
    
      junit
      junit
      3.8.1
      test
    
  
  
    SampleWebapp

Here we notice that the packaging element has a value war. A project with a war packaging creates a WAR file in the target directory. Default name of this file is ${artifactId}-${version}.war. Hence our WAR generated would be in target/SampleWebapp-1.0-SNAPSHOT.war. The element finalName customizes the name of the generated WAR.

Maven also created a sample JSP Source file index.jsp:


   
      Hello World!

Prepare the Tomcat Manager application

We will deploy our web application to Tomcat server. We first need to ensure that we can access the Tomcat Manager application at: http://localhost:8080/manager/html. Just ensure that the /conf/tomcat-users.xml file has the following defined:(where is the Tomcat installed directory).

To login into Tomcat Manager app we will use:


Username=admin
 Password=admin

Define Tomcat Server in Maven settings

Edit the Maven settings.xml (e.g:C:\Documents and Settings\Manisha\.m2\settings.xml), add a server myserver. Add the credentials to log into the Tomcat Manager application:


	
	 
	   myserver
	   admin
	   admin
	
	
	.......
	.....

Point POM to Tomcat Server

Edit section in the the pom.xml file (under the directory C:\MVNProject\SampleWebapp\pom.xml) as follows:


    SampleWebapp
    
      
         org.codehaus.mojo
            tomcat-maven-plugin
              
                myserver
                /SampleWebapp

We have added the Tomcat plugin for Maven. The section points to the server we defined in settings.xml (‘myserver’). Through and the we define the web context we want to deploy to. We’ll be able to access our application at http://localhost:8080/SampleWebapp.

Build and Deploy the web application to Tomcat server

Open the command window console, and go to the directory where pom.xml is located (C:\MVNProject\SampleWebapp\pom.xml). Execute the following command:
mvn tomcat:deploy
If “BUILD SUCCESS” message appears, then access the application at:

http://localhost:8080/SampleWebapp/.

If you want to deploy again, then use the following command:
mvn tomcat:redeploy

Summary

Apache Maven 2.0 – Maven Plugins
Buy: Apache Maven Implementation from flipkart.com

In this post we did learn how to create a simple webapp using the Maven archetype plugin. We checked the directory structure and the generated source code. We then did learn about how to build and deploy this simple web app in the Tomcat server using Maven command. If you have any questions, please post it in the comments section. If you are interested in receiving the future articles on Java topics, please subscribe here.

Quartz Job Scheduler – Example Code

krishnas — Thu, 21 Feb 2013 04:37:31 +0000

Connect to us ( @twitter | @facebook )

In this section we are going to develop a simple Quartz Scheduler application with the help of Quartz framework. That will display “Hello World Quartz Scheduler :” on the console window after specified time schedule.

Before using Scheduler you have to instantiate it. For doing this some users may keep an instance of a factory serialized in a JNDI store, and some other users may find it just to instantiate and use a factory instance. Firstly create the instance of SchedulerFactory by getting the reference of org.Quartz.impl.StdSchedulerFactory Class. Invoke the getScheduler() method by this instance to instantiate the Scheduler.

Description of code:

execute(): Any software components you want to schedule then you must implement the Job interface and override it execute() method.

JobExecutionContext: The JobExecutionContext object that is passed to execute() method provides the job instance with information about its “run-time” environment – a handle to the Scheduler that executed it, a handle to the Trigger that triggered the execution, the job’s JobDetail object, and a few other items.

SchedulerFactory: SchedulerFactory is a interface provides a mechanism for obtaining client-usable handles to Scheduler instances.

StdSchedulerFactory(): A Class StdSchedulerFactory is a class and it is implementation of SchedulerFactory interface. Here it just using for create an instance of SchedulerFactory instance.

Scheduler: Scheduler interface is the main interface (API) to this functionality. It provides some simple operations like scheduling jobs, unschedulingjobs, starting/stopping/pausing the scheduler.

getScheduler():SchedulerFactoy interface having the getScheduler() method that returns an instance of Scheduler.

start(): This method is used to starts the Scheduler’s threads that fire Triggers. At the first time when we create the Scheduler it is in “stand-by” mode, and will not fire triggers. The scheduler can also be send back into stand-by mode by invoking the standby() method.

JobDetail(String name, String group, Class jobclass): The JobDetail object is created at the time the Job is added to scheduler. It contains various property settings like job name, group name and job class name. It can be used to store state information for a given instance of job class.

SimpleTrigger(String name, String group, Date startTime, Date endTime, int repeatCount, long repeatInterval): Trigger objects are used to firing the execution of jobs. When you want to schedule the job, instantiate the trigger and set the properties to provide the scheduling.

DEFAULT_GROUP: It is a constant, specified that Job and Trigger instances are belongs to which group..

REPEAT_INDEFINITELY: It is a constant used to indicate the ‘repeat count‘ of the trigger is indefinite.

scheduleJob(JobDetail jd, SimpleTrigger st): This method is used to add the JobDetail to the Scheduler, and associate the Trigger with it.

Here is the code of Job Class:

import org.quartz.Job;

import org.quartz.JobExecutionContext;

import org.quartz.JobExecutionException;

import java.util.Date;

public class HelloJob implements Job {public void execute(JobExecutionContext arg0) throws JobExecutionException{

System.out.println(“Hello World Quartz Scheduler: ” + new Date());
}
}

Here is the code of Scheduler Class:

import java.util.Date; import org.quartz.JobDetail; import org.quartz.Scheduler; import org.quartz.SchedulerFactory; import org.quartz.SimpleTrigger; import org.quartz.impl.StdSchedulerFactory;

public class HelloSchedule {
public HelloSchedule()throws Exception{
SchedulerFactory sf=new StdSchedulerFactory();
Scheduler sched=sf.getScheduler();
sched.start();
JobDetail jd=new JobDetail(“myjob”,sched.DEFAULT_GROUP,HelloJob.class);
SimpleTrigger st=new SimpleTrigger(“mytrigger”,sched.DEFAULT_GROUP,new Date(),
null,SimpleTrigger.REPEAT_INDEFINITELY,60L*1000L);
sched.scheduleJob(jd, st);
}
public static void main(String args[]){
try{
new HelloSchedule();
}catch(Exception e){}
}
}

Creating Simple Java Project Using Apache Maven

Manisha Patil — Wed, 20 Feb 2013 15:39:35 +0000

Connect to us ( @twitter | @facebook )

Maven is a build and project management tool for java based application development. In previous article(“Apache Maven for Beginners“), we talked about installing and configuring maven on windows operating system. In this article, we shall see how to create a simple Maven project, check the created directories and build the project.

If you have any questions, please post it in the comments section. If you are interested in receiving the future articles on Java topics, please subscribe here.

Buy: Apache Maven Implementation from flipkart.com

Maven uses archetype plugins to create projects. To create a simple java application, we’ll use maven-archetype-quickstart plugin from command line. In the example below, We’ll create a maven based java application project in C:\MVNProject folder.

Open the command line window and type the below command, Maven creates a blank java project with all default options.

C:\MVNProject>mvn archetype:generate -DgroupId=net.javabeat -DartifactId=
SampleJavaProject -DarchetypeArtifactId=maven-archetype-quickstart
-DinteractiveMode=false

Note: If you have just installed Maven, and if its your first run, it may take a while, because Maven downloads the most recent artifacts (plugin jars and other files) into your local repository (to your .m2 directory). You may also need to execute the command a couple of times before it succeeds. This is because the remote server may time out before your downloads are complete.

Maven commands

mvn : is the Maven command.
archetype:create : is called a Maven goal, analogous to an ANT target. It describes a unit of work to be completed in a build. The purpose of this goal is to quickly create(goal) a project from an archetype(plugin)
-Dname=value pairs : (DgroupId, DartifactId, DarchetypeArtifactId, DinteractiveMode) These are the arguments which are passed to the goal.They take the form of -D properties, similar to the system property options which you pass to the Java Virtual Machine via the command line.

The output on executing the above command is

[INFO] Scanning for projects...
[INFO] ------------------------------------------------------------------------
[INFO] Building Maven Stub Project (No POM) 1
[INFO] ------------------------------------------------------------------------
[INFO]
[INFO] >>> maven-archetype-plugin:2.0:generate (default-cli) @ standalone-pom >>>
[INFO]
[INFO] <<< maven-archetype-plugin:2.0:generate (default-cli) @ standalone-pom <<<
[INFO]
[INFO] --- maven-archetype-plugin:2.0:generate (default-cli) @ standalone-pom ---
[INFO] Generating project in Batch mode
[INFO] ----------------------------------------------------------------------------
[INFO] Using following parameters for creating project from Old (1.x) Archetype: maven-archetype-quickstart:1.0
[INFO] ----------------------------------------------------------------------------
[INFO] Parameter: groupId, Value: net.javabeat
[INFO] Parameter: packageName, Value: net.javabeat
[INFO] Parameter: package, Value: net.javabeat
[INFO] Parameter: artifactId, Value: SampleJavaProject
[INFO] Parameter: basedir, Value: C:\MVNProject
[INFO] Parameter: version, Value: 1.0-SNAPSHOT
[INFO] ********************* End of debug info from resources from generated POM ***********************
[INFO] project created from Old (1.x) Archetype in dir: C:\MVNProject\SampleJavaProject
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 13:03.812s
[INFO] Finished at: Sun Feb 17 08:37:52 IST 2013
[INFO] Final Memory: 8M/24M
[INFO] ------------------------------------------------------------------------

Once the project is created, a directory structure is created as shown below. This directory structure adheres to the standard Maven directory layout.

The details of the basic directories is as follows:

SampleJavaProject: This directory contains src folder and pom.xml. Maven Archetype plugin creates this directory, value matching the artifactId SampleJavaProject
src/main/java: This directory contains java code files under the package structure (net/javabeat).
src/main/test: This directory contains test java code files under the package structure (net/javabeat).

We see that a default pom.xml has been created. POM file generated is:



  4.0.0
  net.javabeat
  SampleJavaProject
  jar
  1.0-SNAPSHOT
  SampleJavaProject
  http://maven.apache.org
  
    
      junit
      junit
      3.8.1
      test

Maven Archetype plugin also created a sample Java Source file(C:\MVNProject\SampleJavaProject\src\main\java\net\javabeat\App.java) and Java Test file(C:\MVNProject\SampleJavaProject\src\test\java\net\javabeat\AppTest.java).

App.java, is a single 13-line Java class, with a static main function that prints a simple “Hello World!” message.

package net.javabeat;

/**
 * Hello world!
 *
 */
public class App
{
    public static void main( String[] args )
    {
        System.out.println( "Hello World!" );
    }
}

AppTest.java

package net.javabeat;

import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;

/**
 * Unit test for simple App.
 */
public class AppTest
    extends TestCase
{
    /**
     * Create the test case
     *
     * @param testName name of the test case
     */
    public AppTest( String testName )
    {
        super( testName );
    }

    /**
     * @return the suite of tests being tested
     */
    public static Test suite()
    {
        return new TestSuite( AppTest.class );
    }

    /**
     * Rigourous Test  
     */
    public void testApp()
    {
        assertTrue( true );
    }
}

Build project

Once the project is created with the Maven Archetype plugin as seen above, we can build and package the application. To do so, run mvn install from the directory that contains the pom.xml(in our case it is C:\MVNProject\SampleJavaProject):

C:\MVNProject\SampleJavaProject>mvn install
[INFO] Scanning for projects...
[INFO]
[INFO] ------------------------------------------------------------------------
[INFO] Building SampleJavaProject 1.0-SNAPSHOT
[INFO] ------------------------------------------------------------------------
[INFO]
[INFO] --- maven-resources-plugin:2.4.3:resources (default-resources) @ SampleJavaProject ---
[WARNING] Using platform encoding (Cp1252 actually) to copy filtered resources, i.e. build is platform dependent!
[INFO] skip non existing resourceDirectory C:\MVNProject\SampleJavaProject\src\main\resources
[INFO]
[INFO] --- maven-compiler-plugin:2.3.2:compile (default-compile) @ SampleJavaProject ---
[WARNING] File encoding has not been set, using platform encoding Cp1252, i.e. build is platform dependent!
[INFO] Compiling 1 source file to C:\MVNProject\SampleJavaProject\target\classes
[INFO]
[INFO] --- maven-resources-plugin:2.4.3:testResources (default-testResources) @ SampleJavaProject ---
[WARNING] Using platform encoding (Cp1252 actually) to copy filtered resources, i.e. build is platform dependent!
[INFO] skip non existing resourceDirectory C:\MVNProject\SampleJavaProject\src\test\resources
[INFO]
[INFO] --- maven-compiler-plugin:2.3.2:testCompile (default-testCompile) @ SampleJavaProject ---
[WARNING] File encoding has not been set, using platform encoding Cp1252, i.e. build is platform dependent!
[INFO] Compiling 1 source file to C:\MVNProject\SampleJavaProject\target\test-classes
[INFO]
[INFO] --- maven-surefire-plugin:2.5:test (default-test) @ SampleJavaProject ---
[INFO] Surefire report directory: C:\MVNProject\SampleJavaProject\target\surefire-reports

-------------------------------------------------------
 T E S T S
-------------------------------------------------------
Running net.javabeat.AppTest
Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.453 sec

Results :

Tests run: 1, Failures: 0, Errors: 0, Skipped: 0

[INFO]
[INFO] --- maven-jar-plugin:2.3.1:jar (default-jar) @ SampleJavaProject ---
[INFO] Building jar: C:\MVNProject\SampleJavaProject\target\SampleJavaProject-1.0-SNAPSHOT.jar
[INFO]
[INFO] --- maven-install-plugin:2.3.1:install (default-install) @ SampleJavaProject ---
[INFO] Installing C:\MVNProject\SampleJavaProject\target\SampleJavaProject-1.0-SNAPSHOT.jar to C:\Documents and Settings\Manisha\.m2\repository\net\javabeat\SampleJavaProject\1.0-SNAPSHOT\SampleJavaProject-1.0-SNAPSHOT.jar
[INFO] Installing C:\MVNProject\SampleJavaProject\pom.xml to C:\Documents and Settings\Manisha\.m2\repository\net\javabeat\SampleJavaProject\1.0-SNAPSHOT\SampleJavaProject-1.0-SNAPSHOT.pom
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 37.375s
[INFO] Finished at: Sun Feb 17 12:17:10 IST 2013
[INFO] Final Memory: 11M/27M
[INFO] ------------------------------------------------------------------------

Executing the mvn install, we have just created, compiled, tested, packaged and installed the simple java project by Maven. We can also clean the target directories by using the clean command as mvn clean install.

Execute the program from command line as follows:

C:\MVNProject\SampleJavaProject\target\classes>java net.javabeat.App
Hello World!

Summary

Buy: Apache Maven Implementation from flipkart.com

In this article we saw how to create a simple Java project using Maven archetype plugins. We checked the directory structure, the generated source code.We then did learn about how to build this simple Java project using Maven command.In the next article we shall create a web application project using Maven.

If you have any questions, please post it in the comments section. If you are interested in receiving the future articles on Java topics, please subscribe here.

Apache Maven for Beginners

Manisha Patil — Wed, 13 Feb 2013 00:48:17 +0000

Connect to us ( @twitter | @facebook )

What is Maven?

Apache Maven is project management tool which is following the concept of a project object model (POM). Mavan can manage project’s build and documentation from a central place. Maven 1 actually was started as a sub project of Apache Turbine in 2002 (by Sonatype’s Jason van Zyl). It was released in July 2004 as v1.0. Maven 2 was released in Oct 2005. It was a complete rewrite of the previous project. It was not backward compatible.
Maven 3 was released in October 2010. It is same as Maven 2 but more stable. This article explores the very basic concepts needed for the beginners who want to learn and get started with the Maven. Before the popularity of using Maven, most of the projects used Ant Script for the projects build which is used only for the build purpose.

If you have any questions, please post it in the comments section. If you are interested in receiving the future articles on Java topics, please subscribe here.

Buy: Apache Maven Implementation from flipkart.com

Maven Definition

Definition of Maven from the Maven site(http://maven.apache.org/):
“Apache Maven is a software project management and comprehension tool. Based on the concept of a project object model (POM), Maven can manage a project’s build, reporting and documentation from a central piece of information.

Maven is an open source software engineering platform. The intent of Maven is to make intra-project development highly manageable in the hopes of providing more time for cross-project development. You may say it as sharing of project development knowledge. The core functionality of Maven is automated project building, distribution and website creation.

Maven features

Dependency System: Superior dependency management including automatic updating, dependency closures (also known as transitive dependencies). Maven encourages the use of a central repository of JARs and other dependencies. Maven has a mechanism which helps your project’s clients to download any required JARs for building your project from a central JAR repository.This allows reuse of JARs across projects for Maven users.This also helps in dealing with backward compatibility issues.
Multi-module builds: Able to easily work with multiple projects at the same time
Consistent project structure: Consistent structure across all projects means no ramp up time for new developers coming onto a project
Consistent build model: Maven is able to build any number of projects into predefined output types such as a JAR, WAR, or distribution based on metadata about the project, without the need to do any scripting in most cases.
Plugin oriented: The Maven functionality is implemented in terms of plugins.
Project generated sites: Maven generates a website or a PDF file using the same metadata as for the build process.You can include any documentation to this site and the standard report about the state of development of the project.Examples of this information can be seen at the bottom of the left-hand navigation of this site under the “Project Information” and “Project Reports” sub menus.

Comparison of Maven with Apache ANT:

Major differences between Maven and ANT are:

Maven is description of a project whereas ANT is development of a build script per project.
Maven follows conventions like a common project directory structure whereas ANT needs to be told about the exactly where to find the source and where to put the output.
Maven has invocation of defined goals (targets) whereas in ANT script you have invocation of project specific targets.
Maven has build life cycle, standard project layout where as ANT doesn’t and it has too complex scripts(You have to define goals and goal dependencies). You have to attach a sequence of tasks to each goal manually.
Maven has reusable plugins, repositories whereas ANT scripts are not reusable.
Maven is declarative.All you have to do is create a pom.xml file and put your source in the default directory. Maven takes care of the rest.ANT is procdeural which means you need to tell it to compile,copy and then compress.

Maven POM

POM stands for Project Object Model.It describes following data about a project:

Metadata: Location of Directories, Developers/Contributors, Dependencies, Repositories
Dependencies (Transitive Dependencies), Inheritance, and Aggregation
Key Elements
- Project
- Model Version
- Group ID
- Packaging
- Artifact ID
- Version
- Name
- URL
- Description
- Plugins
- Profiles (Alternate build configurations)

(Note:Transitive Dependencies definition- A dependency that should be included when declaring project itself is a dependency.Example: ProjectA depends on ProjectB. If ProjectC depends on ProjectA then ProjectB is automatically included. Only compile and run time scopes are transitive)

POM has four categories

General project information-this includes project information like name,URL for project,sponsor organization,list of developers,license for the project.
Build settings-This include customization of default Maven build behaviour.
Build environment-This inlcudes profiles that can be used and activated for working in different environments(example development server,production server).
POM relationships-This includes inheritance of POM settings of parent projects.

Standard Directory Layout

Install Maven

Download the latest Maven from http://maven.apache.org/download.cgi.
- The installed file is:apache-maven-3.0-bin.zip
- Extract the archive to the directory you wish to install Maven.We have extracted to the following folder:
- C:\tools\apache-maven-3.0
Test Maven
In order to test Maven setup,you need Java installed/configured on your machine.Assuming you have JDK installed at C:\Program Files\Java\jdk1.7.0_11\bin, execute the following commands which sets your System Environment with Java and Maven paths.
```
set MAVEN_HOME=C:\tools\apache-maven-3.0
set MAVEN_OPTS=-Xms256m -Xmx512m
set JAVA_HOME=C:\Program Files\Java\jdk1.7.0_11
set path=%path%,%JAVA_HOME%\bin;%MAVEN_HOME%\bin
```

Verify Maven installation
Open the command prompt and execute the following command:

c:\> mvn --version

This should give the current installed version of Maven.

Apache Maven 3.0 (r1004208; 2010-10-04 17:20:56+0530)
Java version: 1.7.0_11
Java home: C:\Program Files\Java\jdk1.7.0_11\jre
Default locale: en_US, platform encoding: Cp1252
OS name: "windows xp" version: "5.1" arch: "x86" Family: "windows"

Basic User specific Maven Configuration

Now that you have installed Maven, it is a good idea to setup the .m2 directory, where Maven creates its local repository. To create .m2 directory, assuming “Manisha” is logged in user, open the command console and execute the following command, to create the .m2 directory.

mkdir C:\Documents and Settings\Manisha\.m2

The settings.xml file(under the .m2 directory) contains user-specific configuration for authentication, repositories,and other information to customize the behavior of Maven. Sample settings file is:



 
   server1
   user1
   password1
 
 
    server2
    user2
    password2
 

 



   
	mirror1
	Internal network access to any repository
	repo1
	https://www.javabeat.net/repo1/
   




   
     profile1
	
	 true
	
	 
               
	         repo1
	         https://www.javabeat.net/repo1/
       
      
	
		pluginrepo1
		Repos (public/proxied)
		https://www.javabeat.net/pluginrepo1/
		
			false
		
		
			true

Summary

Buy: Apache Maven Implementation from flipkart.com

In this article we saw basic overview about Apache Maven, its installation and basic configuration.The next article would deal with creating a simple Java project using Maven. I would write the series of tutorials on Apache Maven and how to use Apache Maven in your projects. If you have any questions, please post it in the comments section. If you are interested in receiving the future articles on Java topics, please subscribe here.

HelloWorld with Netbeans 7.2 beta and Scala 2.9

Smita — Tue, 05 Jun 2012 00:00:16 +0000

Connect to us ( @twitter | @facebook )

Here is the step by step procedure to set up the scala(2.9) environment with Netbeans(7.2) on a Windows Vista system

1. Install Netbeans 7.2 Beta if not already installed from here.

2. Download the Scala installable from here. Install Scala on your system.

3. Set the environment variable SCALA_HOME pointing it to the Scala installation directory. (On Windows Vista, Go to Start Menu ->Right click on Computer -> Select Properties -> From the left menu, Click on Advanced system Settings -> Click on the Environment variables button on the bottom right corner -> Create new System variable named SCALA_HOME pointing to the Scala installation directory).

4. Now we need to install Scala plugin for Netbeans. Download the plugin here and extract the content into an appropriate folder.

5. Open Netbeans IDE.

6. On the Menu Bar, choose Tools -> Plugin

7. Choose Downloaded tab. Click on Add Plugins button. Browse to the folder containing scala plugins. Choose all the *.nbm files and hit the Install button on the bottom left corner.

5. You need to hit the Next / Continue button and accept the agreements on all the windows that pop up after that.

Plugin auto installs everything.

6. Create New Project. You should now be able to see a new category named Scala. Choose Scala Application. Choose your project name / location and click on Finish. An object named Main which prints out “Hello World” gets created by default. You can run this file as is by hitting Shift+F6 just to check if the environment is correctly set. HelloWorld should get printed as output.

Writing a first Scala program on Netbeans 7.2 seemed a breeze. No headache of conf file changes. But Netbeans 7.2 does seem a lot lot slower than its earlier version 7.0(I have not tried 7.1). Probably because it still is a Beta version.

Following are some gotchas if you are trying to get Scala to work on Netbeans 7.0 or an earlier version of Scala-

1. After installing the plugin, you should be able to create a new Scala project. In case you are not, check if any of the scala plugins are not activated. Select them and activate them.

2. Error message – Could not load definitions from resource scala/tools/ant/antlib.xml. It could not be found.

Solution – Check if Scala has been correctly installed. Append “-J-Dscala.home=scalahomepath” property to the end of “netbeans_default_options” in NetBeansInstallationPath/etc/netbeans.conf where scalahomepath is the actual path to the Scala installation directory.

Please do let me know how your Scala environment setup with Netbeans went. I will be happy to respond to your questions if any. Please feel free to add your comments below.

Adios until the next post !

Flex 4.x – Overview

krishnas — Mon, 22 Aug 2011 23:42:58 +0000

Connect to us ( @twitter | @facebook )

Type of technology

Flex is a highly productive, free open source framework available for building and maintaining web applications which deploy consistently on major browsers, desktops and operating systems.

Look and Feel

Drag and Drop

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.

Type of Technology

Adobe Flex is a collection of technologies based on Adobe Flash platform. Currently Adobe Flex applications are build using Flex 3 SDK. Other technologies used with it are Livecycle Data Services (J2EE application integration). Flex applications are viewed on Adobe Flash Player.

Application architecture

Most of the web applications are usually build in MVC architecture in the case of a Flex RIA. The Controller can take form of the Service (or business object) on the application server which reads and updates a Database (the Model).When it receives the requests from the Flex application and itself, represents the Database records to the user.

Environment

For render response in terms of web pages, it requires a browser having Adobe Flash plugin installed on the client machine. For deployment purpose Flex 3 SDK is required on the server machine.

Tools Availability

Flash Builder 4 is the IDE for developing a Flex application. It has end to end support for building a Flex application, component etc. It has all the components given in palettes to that the designing of front end becomes very easy. However, flex application can be written in any text based tool and executed on machine having Flex 3 SDK.

Community Support

Since Flex is a very popular framework for developing RIAs, a huge community support is available. One very popular among them is CFLEX (Community Adobe Flex). This community is dedicated to Adobe Flex.

Frameworks supported

In Flex you have several options to choose for back-end server software (ranging from JEE to Dotnet etc). Few examples are -

Flex with Struts:

With Flex, you can provide a rich front end to your Struts applications. There are two approaches for integrating Flex with Struts application which are based on 2 different ways a Flex application communicates with remote systems i.e. By using the traditional HTTP request/response mechanism or by using SOAP to invoke methods on remote services. Basically Flex can be taken as part of the View in a distributed MVC framework.

Flex with Spring:

This integration is done with the help of Flex Data services i.e. BlazeDS. The BlazeDS adds Remoting Service, Message Service, and Proxy Service to the Flex application. Using Remoting Service a Flex application directly invokes methods of Java objects deployed in the application server. Spring beans are Java objects and so can be accessed using the remoting service of BlazeDS. BlazeDS supports the concept of a factory to configure the Spring container for instantiating Spring beans. The role of the factory is simply to provide ready to use instances of components for BlazeDS (instead of letting BlazeDS instantiate these components).

Flex with Ruby on Rails:

Using this we can do more with very less code. Using Flex we can create the user interface for displaying data. Then we can design this user interface using Flex components for nice look and feel. Then setup the corresponding rails application. Flex can then talk to rails by using the HTTPService to call the different methods in your Rails application.

Animation/ Multimedia support

Flex is developed by Adobe Systems and so is closely related to Flash. Both Flash and Flex Work using ActionScript 3.0, both outputs a SWF format, and both of them use Flash Player to display their content. But Flash is good in animation and Flex by contrast is best at the developing applications and things that are associated with it—charting, handling data, and such. So, Flex can focuses on animations such as transitions that place as menus expand, or items such as image scaling to different sizes and in different states. To add more animation capability we can integrate Flash and Flex in three ways: By using Flash for creating skins and component animations, by adding complex timeline animations, and by adding in Flash multimedia clips that can be controlled in Flex.

Ease of testing

Flex Builder comes with debugging tools which helps in unit testing of a Flex application. Breakpoints can be set both in ActionScript as well as in MXML code that allow application execution to pause at a specified code location. Flex 3 comes with an option of profiling the application. The profiler helps in identifying the performance bottlenecks and memory leaks in the application. It tells about Call frequency, Method duration, Call stacks, Number of instances, Object size and Garbage collection. Apart from these many external tools are available for testing flex application like FlexMonkey, FunFx, QuickTestProfessional etc

Flexibility and Scalability

Flex application is backend agnostic and can work with any kind of backend server till it sends and receive data in the format/protocol supported by Flex. Scalability of Flex application basically depends upon the underlying application server. The Flex application scales upto the level of support provided by the application server.

Browsers dependence

Flex is doesn’t directly depend on the type of browser but is dependent on the Flash Player web browser plug-in. But as per the statistics 98% of browsers available currently have Flash Player plug-in with version 7-9 installed. So, a Flex-generated code works on each client regardless of browser/platform. So, flex has a limitation in this respect that they are limited by the constraints of Flash Player and cannot display anything outside the boundaries of the player’s space embedded in the web page.

Network performance

The Flex client-side processing model and configuration ability helps in improving the network performance. For example, the network bandwidth and connections can be improved by embedding the product images within the SWF file. The SWF file would increase to 60K (or, a total size of 260K), but the application would require 15 fewer network connections to the server. A second potential improvement is to disable the Flex history management feature if it is not required; this prevents the Flex application from transmitting the history management HTML page, thereby reducing network overhead. (Source: Macromedia White Paper, Flex Performance Brief: A Comparison of Flex and Java Server Pages Applications May 2004)

Client Performance

Flex offers the ability to create Rich Internet Applications (RIAs). Misusing this power can result in areas of poor performance. Flex is like any other programming model because certain coding practices can be detrimental to the overall performance of the client. So, depending upon the coding techniques follow are affected at client side:

Startup time
Playing complex effects smoothly
Performance of charting components
Streaming of multimedia content

Client Validation Support

As we know, Flex is best used for good user interface. The data that user enters in user interface control might or might not be appropriate for our application. Adobe Flex applications, uses a validator to ensure that values in the fields of the form meet certain criteria.

Flex includes some set of validators for common types of user input datas, such as zip code, phone numbers, and credit card numbers etc. Validators are created in MXML by using a validator tag such asor. Validators uses following 2 properties to specify the item which needs to be validated:

source: This specifies the object which contains the property to be validated .We can set this for an instance of a component or to a data model. You can use data binding syntax in MXML for specifying the value for the source property.
property: A String that specifies the name of the source property that contains value to validate. This property support dot-delimited Strings for specifying nested properties.

What’s New in Silverlight 5?

krishnas — Sun, 31 Jul 2011 23:41:43 +0000

Connect to us ( @twitter | @facebook )

This article is based on Silverlight 5 in Action , published on June 2011. It is being reproduced here by permission from Manning Publications. Manning publishes MEAP (Manning Early Access Program,) eBooks and pBooks. MEAPs are sold exclusively through Manning.com. All pBook purchases include free PDF, mobi and epub. When mobile formats become available all customers will be contacted and upgraded. Visit Manning.com for more information. [ Use promotional code 'java40beat' and get 40% discount on eBooks and pBooks ]

Introduction

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.

Table 1 shows just a few of the major enhancements delivered in each version of Silverlight over the last four years. In the remainder of this article, we’ll look at the features, especially those new to Silverlight 4 and 5, in more detail. The advancements in Silverlight can be loosely grouped into four main areas: business and client applications, media and graphics, user interaction, and text.

Features for business and client applications

Though Silverlight 2 could have been used to build rich business applications, it didn’t have the chops to be a strong contender in that space yet. Three versions later, that story has certainly changed. Many of the features in this article are useful in applications of all sorts; I hate to classify them under the heading of “business,” but that’s the largest consumer of these features.

Validation was one of the biggest new features for business applications. Silverlight didn’t add just validation but included support for validation through attributes, validation through exceptions, and even asynchronous validation, all of which work with the Silverlight controls. Silverlight even made it possible to completely customize the style of the validation information provided to the end-user.

One technology that builds heavily on the validation stack is WCF RIA Services. A good bit of the validation functionality rolled into the Silverlight runtime actually came from that project. WCF RIA Services provides a way to share validation and logic between the client and the server as well as a framework for validation, data access, and security, shareable between Silverlight and other clients.

WCF RIA Services builds upon the WCF stack, but it’s not the only enhancement there. The Silverlight networking stack was greatly enhanced to support in-browser and out-of-browser operation, as well as SOAP 1.2 and a number of new protocol enhancements, including WS-Trust. We’ve also done a lot to optimize networking performance and reduce latency in Silverlight 5. These changes make it easier to use Silverlight behind a firewall where the services often have different requirements than those on the Internet.

Despite the promises of a paperless office, printing is still a staple of business applications everywhere. Printing in Silverlight 4 was optimized for relatively short reports or documents, as well as for the equivalent of print-screen operations. Silverlight 5 adds a new Postscript or true vector printing mode to the existing bitmap approach, making serious printing and print-preview now possible.

Finally, we come to a biggie: out-of-browser sandboxed and trusted applications. Out-of-browser mode was one of the most significant enhancements made to how Silverlight operates. Silverlight 3 introduced the basic out-of-browser mode with a sandbox roughly equivalent to the one in browser. Silverlight 4 opened up whole new classes of applications by adding the trusted application mode with its reduction in prompts, increased file access, and (on Windows) access to IDispatch COM Automation servers. All of these features add up to a platform that’s more than capable of being the client for our complex business applications.

One of the next major areas of enhancement for Silverlight is media.

Media and graphics enhancements

Silverlight was first and best known for its media capabilities. The Silverlight media team didn’t rest on that, instead pumping out enormous advances in media in each update to Silverlight.

Silverlight 2 included a Media Stream Source API for pushing media through the pipeline. But that API required that the bits be preencoded into one of the formats natively understood at the time. Though useful, this could lead to double-encoding and made transcoding even more difficult.

Silverlight 3 added support for pushing raw video and audio out of custom Media Stream Source implementations. As a result, you can write a managed codec for any type of media or even do something crazy like I did and use it to generate audio and video in real time for an emulator.

Speaking of codecs, one of the new codecs added was H.264 for video. H.264 has emerged as one of the most popular codecs for TV and video for devices. It was a logical choice for an additional native Silverlight format because now content producers can use even more of their content without reencoding. Silverlight 5 expanded on the H.264 support by adding hardware decoding to improve performance, especially on lower-power devices. To appeal to the same audience, Silverlight also continued to improve DRM capabilities, including the addition of offline DRM and seamless switching between DRM media sources.

One common request in the media space was for the ability to play video at double speed. Commonly called Trick Play, this has been added to Silverlight 5. Now you can watch my tutorial videos in 15 minutes instead of half an hour, with automatic pitch correction so I don’t sound like a chipmunk.

An exciting feature introduced in Silverlight 4 was built-in support for video and audio capture devices or, specifically, webcams and microphones. Though not yet quite at the level that would allow you to create a real-time video chat application, the support does open up a number of new possibilities for application development. Under the covers, Silverlight now has support for all formats of portable network graphics (PNG), something that was only partially supported in previous versions. Silverlight 4 also introduced support for pixel shaders and a set of built-in performance-tuned effects such as drop-shadow and blur.

Easily the most anticipated feature in Silverlight 5, the GPU-accelerated 3D programming interface will enable all sorts of scenarios, from games to data visualization to custom third-party 3D rendering and scene management systems. This system also provides us with the ability to have immediate-mode 2D graphics—another frequent request.

With all of these advancements plus a number of performance optimizations and even additions such as the Silverlight Media Framework, Silverlight continues its leadership in the media space, offering everything you need to build rich media-centric applications.

Sometimes what you want is more than just a media experience; you want an application that can be truly interactive. Silverlight has your back there, too.

User interaction

Since Silverlight 2, user interaction has received a number of important enhancements. Two of the most requested features, mouse scroll wheel and right-click mouse support, are now baked into the Silverlight core runtime.

One of the newer and hotter user interaction mechanisms is multitouch. The ability to support multipoint interaction with the user interface, especially in kiosk and handheld/tablet scenarios, is quickly becoming a requirement for many applications. Silverlight now includes core runtime support for multipoint-touch interaction with Silverlight application.

Another user interaction piece missing from Silverlight 2 was the easy ability to show dialogs and pop-up windows (simulated) within your applications. Silverlight now not only has those but also notification toast.

Finally, all the interaction in the world has no value if your user can’t read the text on the screen. Happily, Silverlight includes plenty of improvements in text as well.

Text

By far, the biggest improvement to text since Silverlight 2 is proper ClearType font rendering. Silverlight 2 performed only grayscale rendering, giving text a fuzzy appearance, unless you carefully picked your color schemes. Silverlight 5 has expanded on this to provide even better and faster text rendering, much like we did with WPF 4.

While ClearType may be important for font rendering in general, right-to-left or bidirectional (BiDi) text is something that’s absolutely essential for the correct rendering of many non-European languages. Silverlight supports not only BiDi text but also input method editors (IMEs) for complex composite characters for many languages, especially Asian and Middle Eastern languages.

Silverlight 5 added enhancements to better improve layout and typography. For example, multicolumn and linked text now enables magazine-like layouts with fluid text flow around other elements. Tracking and leading, always important to the typography-aware (you know, the people who go around wearing shirts that say “Helvetica”), was also added.

Finally, one great improvement to text rendering and entry is the inclusion of the rich text box control. This control allows you to display or edit text that includes multiple fonts and styles. The control can even embed other elements that can be interactive when the control is in read-only mode.

Summary

Between Silverlight 4 and Silverlight 5, we’ve seen a huge number of great features and improvements added. Before I joined Microsoft, I heard rumors about people with sleeping bags in their offices and coffee delivered by the gallon. I suspect I now know which team they work for, and I have to say that I’m “super” impressed with the results.

Creating a Custom Pie Chart Component with Degrafa using Flex

krishnas — Sun, 31 Jul 2011 23:39:52 +0000

Connect to us ( @twitter | @facebook )

This article is based on Flex on Java , published on October 2010. It is being reproduced here by permission from Manning Publications. Manning publishes MEAP (Manning Early Access Program,) eBooks and pBooks. MEAPs are sold exclusively through Manning.com. All pBook purchases include free PDF, mobi and epub. When mobile formats become available all customers will be contacted and upgraded. Visit Manning.com for more information. [ Use promotional code 'java40beat' and get 40% discount on eBooks and pBooks ]

Creating a Custom Pie Chart Component with Degrafa

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.

Drawing in Flex

Flex and Flash provide powerful drawing libraries that we could leverage to create our custom graph components, but we’re going to leverage an open source graphics library called Degrafa. Using Degrafa gives us the ability to declaratively build our graphing components rather than having to deal with the complex calculations involved in drawing pie chart slices as illustrated in listing 1, which shows an example ActionScript class specifically for drawing a pie chart slice found at http://www.adobe.com/devnet/flash/articles/adv_draw_methods.html. Notice how much trigonometry is involved in creating something as simple as a pie chart slice from scratch.

Listing 1 Example of drawing in ActionScript

/*-------------------------------------------------------------
	mc.drawWedge is a method for drawing pie shaped
	wedges. Very useful for creating charts. Special
	thanks to: Robert Penner, Eric Mueller and Michael
	Hurwicz for their contributions.
-------------------------------------------------------------*/
	MovieClip.prototype.drawWedge = function(x, y, startAngle, arc,
	radius, yRadius) {
	==============
		// mc.drawWedge() - by Ric Ewing (ric@formequalsfunction.com) -
		version 1.3 - 6.12.2002
		//
		// x, y = center point of the wedge.
		// startAngle = starting angle in degrees.
		// arc = sweep of the wedge. Negative values draw clockwise.
		// radius = radius of wedge. If [optional] yRadius is defined,
		then radius is the x radius.
		// yRadius = [optional] y radius for wedge.
		// ==============
		// Thanks to: Robert Penner, Eric Mueller and Michael Hurwicz
		for their contributions.
		// ==============
		if (arguments.length<5) {
			return;
		}
		// move to x,y position
		this.moveTo(x, y);
		// if yRadius is undefined, yRadius = radius
		if (yRadius == undefined) {
			yRadius = radius;
		}
		// Init vars
		var segAngle, theta, angle, angleMid, segs, ax, ay, bx, by, cx, cy;
		// limit sweep to reasonable numbers
		if (Math.abs(arc)>360) {
			arc = 360;
		}
		// Flash uses 8 segments per circle, to match that, draw in a maximum
		// of 45 degree segments. First calculate how many segments are needed
		// for our arc.
		segs = Math.ceil(Math.abs(arc)/45);
		// Now calculate the sweep of each segment.
		segAngle = arc/segs;
		// The math requires radians rather than degrees. To convert from degrees
		// use the formula (degrees/180)*Math.PI to get radians.
		theta = -(segAngle/180)*Math.PI;
		// convert angle startAngle to radians
		angle = -(startAngle/180)*Math.PI;
		// draw the curve in segments no larger than 45 degrees.
		if (segs>0) {
			// draw a line from the center to the start of the curve
			ax = x+Math.cos(startAngle/180*Math.PI)*radius;
			ay = y+Math.sin(-startAngle/180*Math.PI)*yRadius;
			this.lineTo(ax, ay);
			// Loop for drawing curve segments
			for (var i = 0; i

Adobe has released the specifications for its declarative graphics library, called FXG. It appears that the Degrafa team has collaborated with the Adobe team to create this specification, but the FXG functionality is only a subset of what is available from the Degrafa library. This may be a library to keep your eye on as it’s being developed.

Common Degrafa concepts

Before diving into developing the component, let’s familiarize ourselves with some of the terms and concepts that we’ll see as we work through this example.

Surface—This is the base component for everything you’ll do in Degrafa. All other Degrafa components will be composed within a Surface.
GeometryGroup—After the Surface, this is the next level of composition. The GeometryGroup tag allows you to group Degrafa components to compose an object.
Stroke—Stroke is the object that is used to define the look of an object’s outline, in terms of color, thickness, and style. Degrafa provides different Stroke objects for your use depending on the style of stroke you want: SolidStroke, Linear-Gradient, and RadialGradient.
Fill—Fill refers to the appearance of the bounded area of a graphical component. Degrafa provides the
following fills: SolidFill, LinearGradient, Radial-Gradient, BitmapFill, BlendFill, and ComplexFill.
Shapes—Degrafa supports drawing many different shapes out of the box, such as Circle, Ellipse, RegularRectangle, RoundedRectangle, Polygon, and more. For irregular shapes, Degrafa also has an extensive library of auto shapes and enables defining any shape you’d like by providing a Scalable Vector Graphics (SVG) path.
Repeaters—This gives you the ability to repeat a shape any number of times on the surface.

Much like other Flex components, the Degrafa components are considered either container components, meaning they will contain other Degrafa components, or graphical elements. Figure 1 shows the relationship of the common components.

We’re only going to scratch the surface; to learn more about Degrafa, you can start with the Foundation section of the documentation at http://www.degrafa.org/samples/foundation.html.

Creating a pie chart for fun and profit

Now that we have some of the basic concepts, let’s get on with the task of creating a custom pie chart component. We were inspired by a blog posting by Derrick Grigg titled appropriately enough Degrafa Pie Chart, which can be found at http://www.dgrigg.com/post.cfm/04/15/2008/Degrafa-Pie-Chart. After we decomposed it and removed some of the extra visual effects such as tweening and gradients, it barely resembles what we started with. Figure 2 shows a mock-up of the chart we’ll be developing in this article.

For this example you’ll be developing only a single pie chart component, but some of the concepts illustrated here could potentially be applied to creating any number of charting components.

The component you’ll develop is a combination of a pie chart and a data grid, which will serve the purpose of a legend for the pie chart. Without this it may be difficult for someone looking at the chart to differentiate between data points on the graph. The pie chart will consist of the pie chart itself and another component for each of the slices that make up the chart. You’ll also develop a simple custom ItemRenderer for the chart legend to draw a simple box inside one of the cells in the data grid.

You’ll also be adding a label and a combo box to the GraphView to allow the user to change the data the chart shows. By changing the value of the combo box the user can show how many issues there are by project, type, status, or severity.

New custom event

We’re going to create a new custom event for our pie chart. The reason we’re creating a new one is that if we ever wanted to put more than one pie chart component into our application, we’d need to be able to distinguish which component fired the event.

Listing 2 PieChartEvent.as

package org.foj.event {
		import flash.events.Event;
		public class PieChartEvent extends Event{
			public static const DATA_PROVIDER_UPDATED:String =
			"dataProviderUpdated";
			public var data:*;
			public var id:*;					#1
			public function PieChartEvent(type : String,
				bubbles : Boolean = true,
				cancelable : Boolean = false)
			{
				super(type, bubbles, cancelable);
			}
		}
	}
	#1 id property

This event differs from the one created previously in the addition of an id property (#1). This is done so that the presenter can decide whether or not it needs to react to the event. With the new event created, you can move on to creating the component itself.

PieChart component

First, you’ll develop the view that contains the pie chart and legend. You’ll create these view components in a new package, so create a file named PieChart.mxml in the org.foj.components package of your project. The following listing shows the first part of the code for the PieChart view.

Listing 3 PieChart.mxml


									#1
												#2
			
		
		
			
		
		...
	
	#1 CreationComplete handler
	#2 HorizontalLayout
	#3 Define presenter field
	#4 Define data provider field
	#5 Pass component's id to presenter
	#6 Set property for data provider

You set the creationComplete event (#1) to call the init method. Next, you set the layout of your component to use HorizontalLayout (#2). Then, you declare a couple of private member variables for the data provider and its presenter (#3, #4).

Inside the init method, you bootstrap your presenter (#5). Last, you create a set property (#6) for the data provider where you create an event to notify the presenter that the data provider was updated. Listing 4 shows the rest of your pie chart component.

Listing 4 PieChart.mxml (continued)


		...
		
										#1
								#2
								#3
				
					
										#4
			
		
								#5
			
				
				
				
			
		
	
	#1 Spacer to help lay out the component
	#2 Degrafa surface
	#3 Geometry group containing pie chart
	#4 Drop shadow for pie chart
	#5 Legend for pie chart
	#6 Custom ItemRenderer

First, you added a spacer (#1) to the component to put a bit of padding between your pie chart and its surrounding components. Next you added a Degrafa Surface component (#2) and a GeometryGroup (#3) to hold the rest of the Degrafa components necessary for the pie chart component. The GeometryGroup is the component to which you’ll add your pie chart slices when you create them. You’ve also added a Drop-ShadowFilter (#4) to the GeometryGroup to add a bit of visual flair to the pie chart. Last you defined the DataGrid component (#5) for your chart legend, with a custom Item-Renderer (#6) to display the color that corresponds to the data in the chart, which you’ll create in a bit.

PieChartSlice

Now that we’ve defined the pie chart component, let’s move on to defining the slices that will make up the pie chart. The pie chart slice is a rather simple component. We probably could have created the pie chart slice programmatically in ActionScript; however, this approach allows us to define sensible defaults declaratively in MXML, adding behavior as well.

Listing 5 PieChartSlice.mxml


								#1
		
			
		
		
	
	Extends GeometryGroup
	Your pie chart slice
	Adds EllipticalArc

The pie chart slice will extend from GeometryGroup (#1). Next, you define a refresh method (#2) to abstract behavior away from your presenter. Last you add an EllipticalArc component to the component (#3) and set default values such as its width, height, and most importantly closureType property, which you set to “pie”.

Custom ItemRenderer

The next component you’re going to create is the custom ItemRenderer for the pie chart legend. This simple component will draw a colored box in the data grid cell to correspond with the colors of the pie chart.

Listing 6 PieLegendRenderer.mxml


						#1
										#2
		
			
											#3
					
						{data.legend}"	#4
					
				
				
			
		
	
	#1 Extends HBox Spacer to help align box
	#2 SolidFill for rectangle
	#3 Color of legend item
	#4 Rectangle

The ItemRenderer is extending HBox (#1) because all ItemRenderer objects for the DataGrid component must be halo components. Add a Spacer component (#2) to help align the rectangle the way you want it. The SolidFill component (#3) defines the fill color for the RegularRectangle (#5). Now that you’ve finished creating all the visual components for the pie chart, let’s move on to creating the Presenter. An implicitly defined variable is available to the ItemRenderer named data, which corresponds to the item in the dataProvider that you’re rendering. Use this implicit variable to set the color of the Fill object (#4), which is contained in the legend property of the object.

Presenter for the PieChart

Now that all the visual components are created for the pie chart, let’s create the Presenter. The Presenter for the pie chart becomes more involved than any of your previous ones, but it shouldn’t be hard to follow.

Listing 7 PieChartPresenter.as

package org.foj.presenter {
		import com.degrafa.paint.SolidFill;
	import org.foj.components.PieChart;
	import mx.collections.ArrayCollection;
	import org.foj.components.PieChartSlice;
	import org.foj.event.EventDispatcherFactory;
	import org.foj.event.PieChartEvent;
	import org.foj.model.PieChartModel;
	public class PieChartPresenter {
		private var _view:PieChart;								#1
		private var _model:PieChartModel;
		private var _id:String;
		private var _dataProvider:ArrayCollection;
		public function PieChartPresenter(view:PieChart, id:String) {				#2
			this._view = view;
			this._model = new PieChartModel();
			this._id = id;
			EventDispatcherFactory.getEventDispatcher()
				.addEventListener(PieChartEvent.DATA_PROVIDER_UPDATED,
				refreshData);
			}
			public function set dataProvider(data:ArrayCollection):void {			#3
				_view.legendDataGrid.dataProvider = data;
				this._dataProvider = data;
			}
			public function get dataProvider():ArrayCollection {
				return this._dataProvider;
			}
			private function refreshData(event:PieChartEvent = null):void {			#4
				if (event.id == _id) {
					changeData(event.data);
				}
			}
			private function changeData(data:ArrayCollection):void {
				dataProvider = data;
				createSlices();
			}
			private function createSlices():void {						#5
				while (dataProvider.length > _view.pieGroup.numChildren) {
					_view.pieGroup.addChild(new PieChartSlice());
				}
			setLegendColors();
			redrawSlices();
		}
		private function setLegendColors():void {						#6
			for (var i:int = 0; i < dataProvider.length; i++)
			{
				dataProvider.getItemAt(i).legend = _model.getLegendColorForIndex(i);
			}
		}
		private function redrawSlices():void {							#7
			var currentAngle:Number = 0;
			var totalUnits:Number = _model.getTotalUnits(_dataProvider);
			for (var i:int = 0; i < _view.pieGroup.numChildren; i++) {
				var slice:PieChartSlice = _view.pieGroup.getChildAt(i)
					as PieChartSlice;
				var legendColor:Number = _model.getLegendColorForIndex(i);
				var arc:Number = i < dataProvider.length ?
					_model.getAngleForItem(
				dataProvider[i].units, totalUnits) : 0;
				// workaround for weird display if only one arc and it's 360 degrees
				arc = arc < 360 ? arc : 359.99;						#8
				redrawSlice(slice, currentAngle, arc, legendColor);
				currentAngle += arc;
			}
			_view.pieGroup.draw(null, null);
		}
		private function redrawSlice(slice:PieChartSlice,					#9
			startAngle:Number,
			arc:Number,
			color:Number):void {
			slice.arc.fill = new SolidFill(color, 1);
			slice.arc.startAngle = startAngle;
			slice.arc.arc = arc;
			slice.refresh();
		}
	}
	}
	#1 Private member variables
	#2 Constructor
	#3 Set property for dataProvider
	#4 Event handler
	#5 Create slices method
	#6 Set legend colors on data
	#7 Redraw slices after update
	#8 Workaround
	#9 Redraw slice

You first define private member variables to hold onto references to the view and the model, the id of the component this Presenter belongs to, and the dataProvider for your pie chart (#1). The constructor (#2) for this Presenter not only takes in a reference to the view, but also is used to bootstrap the id for the view component because there may be multiple pie charts contained in the application. You also define an event listener for the dataProvider being updated in the view component. Next you define a pair of get and set properties (#3) for the dataProvider you leverage to update the dataProvider property of the legend data grid whenever the data-Provider for the pie chart is updated.

You then define the event handler method for the event that is fired whenever the dataProvider for the view is updated (#4). Inside this method you check to see if the id of the component firing the event is the same as the id that created this Presenter.

That way if there are multiple pie chart components, this method can determine whether or not it needs to react.

The createSlices method (#5) checks to see if the data provider has more elements contained in it than there are pie chart slices in your pie chart. If there are more elements in the data provider, it will create more pie chart slices. In the set-LegendColors method (#6) you iterate through the items in the dataProvider and set the legend property of the item to the corresponding color, which you’ll get from the pie chart model class.

After all of that, refresh your pie chart with a call to the redrawSlices method (#7).

This will iterate over the pie chart slices and update the data values, such as the start angle of the slice and its arc. You iterate over the pie chart slices instead of the data provider because there may be more slices than items in the dataProvider, and this will draw the extra slices with an arc of 0. There is also a little workaround (#8) for when there is only a single slice and its arc is 360, which sets its arc to 359.99 so that it would draw correctly.

After all of the data for the slice is updated, it is passed into the redrawSlice method (#9) to tell the slice to redraw itself.

Model for the PieChart

Now you only have one piece of the MVP triad to complete for your pie chart. Even though the pie chart doesn’t need to call out to any remote services, you’ve still refactored a couple of methods that could be considered business logic rather than presentation logic and have no need to maintain any kind of state. The following listing shows the code for the pie chart model.

Listing 8 PieChartModel.as

package org.foj.model {
		import mx.collections.ICollectionView;
		public class PieChartModel {
			private var colors:Array = [						#1
				0x468966,
				0xFFB03B,
				0xFFF0A5,
				0x999574,
				0x007D9F,
				0x8E2800,
				0x8E28F4,
				0x0528F4,
				0xF42105,
				0x0CF405
			];
			public function getLegendColorForIndex(index:Number):Number {		#2
				return colors[index];
			}
			public function getAngleForItem(units:Number,
				totalUnits:Number):Number {					#3
				return ((((units / totalUnits) * 100) * 360) / 100) ;
			}
			public function getTotalUnits(dataProvider:ICollectionView):Number {	#4
				var total:Number = 0;
				for each(var item:Object in dataProvider) {
					total += item.units;
				}
				return total;
			}
		}
	}
	#1 Array of colors for legend
	#2 Convenience method for getting color
	#3 Calculate angle for item
	#4 Calculate total number of items for pie chart

An array of 10 different hex values (#1) corresponds to the colors you want the pie chart to use for its data points. This number could easily be increased should the need arise for more data points in your graphs; for this example this number should suffice.

Next, you define a convenience method (#2) for getting the color value for a specific index. The method getAngleForItem (#3) takes care of the calculation for determining the size of the angle for an item based on the total number of items contained within the pie chart and the number of items passed in. The last method you define (#4) in your model iterates through the data set passed in and returns back the total number of items for the pie chart.

Summary

In this article, we’ve introduced the Degrafa framework and created a custom pie chart component. Using Degrafa gives us the ability to declaratively build our graphing components rather than having to deal with complex calculations.

How to create EJB project in NetBeans 7.0?

krishnas — Mon, 13 Jun 2011 23:30:32 +0000

Connect to us ( @twitter | @facebook )

NetBeans IDE 7 CookbookWelcome to the NetBeans Cookbook.

NetBeans is a Java Integrated Development Environment, IDE, which enables fast
application development with the most adopted frameworks, technologies, and servers.

Different than other IDEs, NetBeans comes already pre-packaged with a wide range of
functionality out of the box, such as support for different frameworks, servers, databases,
and mobile development.

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.

What This Book Covers

Chapter 1, NetBeans Head First introduces the developer to the basics of NetBeans by
creating basic Java projects and importing Eclipse or Maven projects.

Chapter 2, Basic IDE Usage covers the creation of packages, classes, and constructors, as
well as some usability feature.

Chapter 3, Designing Desktop GUI Applications goes through the process of creating
a desktop application, then connecting it to a database and even modifying it to look
more professional.

Chapter 4, JDBC and NetBeans helps the developer to setup NetBeans with the most
common database systems on the market and shows some of the functionality built-in to
NetBeans for handling SQL.

Chapter 5, Building Web Applications introduces the usage of web frameworks such as
JSF, Struts, and GWT.3

Chapter 6, Using JavaFX explains the basic of JavaFX application states and connecting
our JavaFX app to a web service interface.

Chapter 7, EJB Application goes through the process of building an EJB application
which supports JPA, stateless, and stateful beans and sharing a service through a web
service interface.

Chapter 8, Mobile Development teaches how to create your own CLDC or CDC
applications with the help of NetBeans Visual Mobile Designer.

Chapter 9, Java Refactoring lets NetBeans refactor your code to extract classes,
interfaces, encapsulate fields, and other options.

Chapter 10, Extending the IDE includes handy examples on how to create your own
panels and wizards so you can extend the functionality of the IDE.

Chapter 11, Profiling and Testing covers NetBeans Profiler, HTTP Monitor, and
integration with tools that analyze code quality and load generator.

Chapter 12, Version Control shows how to configure NetBeans to be used with the most
common version control systems on the market.

EJB ApplicationIn this chapter, we will cover:

Creating an EJB project
Adding JPA support
Creating Stateless Session Bean
Creating Stateful Session Bean
Sharing a service through Web Service
Creating a Web Service client

Introduction

Enterprise Java Beans (EJB) is a framework of server-side components that encapsulates
business logic.

These components adhere to strict specifications on how they should behave. This ensures
that vendors who wish to implement EJB-compliant code must follow conventions, protocols,
and classes ensuring portability.

The EJB components are then deployed in EJB containers, also called application servers,
which manage persistence, transactions, and security on behalf of the developer.

If you wish to learn more about EJBs, visit http://jcp.org/en/jsr/detail?id=318 or

https://www.packtpub.com/developer-guide-for-ejb3/book.

For our EJB application to run, we will need the application servers.

Application servers are responsible for implementing the EJB specifications and creating the
perfect environment for our EJBs to run in.

Some of the capabilities supported by EJB and enforced by Application Servers are:

Remote access
Transactions
Security Scalability

NetBeans 6.9, or higher, supports the new Java EE 6 platform, making it the only IDE so far
to bring the full power of EJB 3.1 to a simple IDE interface for easy development.

NetBeans makes it easy to develop an EJB application and deploy on different Application
Servers without the need to over-configure and mess with different configuration files. It’s
as easy as a project node right-click.

Creating EJB project

In this recipe, we will see how to create an EJB project using the wizards provided
by NetBeans.

Getting ready

It is required to have NetBeans with Java EE support installed to continue with this recipe.

If this particular NetBeans version is not available in your machine, then you can download it
from http://download.netbeans.org.

There are two application servers in this installation package, Apache Tomcat or GlassFish,
and either one can be chosen , but at least one is necessary.

In this recipe, we will use the GlassFish version that comes together with NetBeans 7.0
installation package.

How to do it…

Lets create a new project by either clicking File and then New Project, or by pressing
Ctrl+Shift+N.
In the New Project window, in the categories side, choose Java Web and in Projects
side, select WebApplication, then click Next.
In Name and Location, under Project Name, enter EJBApplication.
Tick the Use Dedicated Folder for Storing Libraries option box.
Now either type the folder path or select one by clicking on browse.
After choosing the folder, we can proceed by clicking Next.
In Server and Settings, under Server, choose GlassFish Server 3.1.
Tick Enable Contexts and Dependency Injection.
Leave the other values with their default values and click Finish.

The new project structure is created.

How it works…

NetBeans creates a complete file structure for our project.

It automatically configures the compiler and test libraries and creates the GlassFish
deployment descriptor.

The deployment descriptor filename specific for the GlassFish web server is
glassfish-web.xml.

HTML5 Multimedia Development Cookbook

krishnas — Sat, 11 Jun 2011 17:29:03 +0000

Connect to us ( @twitter | @facebook )

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.

Starting with an overview of what’s new in HTML5, we quickly move on to practical
examples. From there, we continue our exploration, all the way to the most cutting-edge
experiments. There’s much to know about the new HTML5 specification. This book
examines spec excerpts and relates them to examples currently in use. Woven with a rich
tapestry of theory, practicality, code samples, screenshots, business wisdom, and links to
additional resources, this book will have eager developers coming back to it again and
again. HTML5 Multimedia Development Cookbook is the essential guide to the latest
front-end web development technologies.

What This Book Covers

In Chapter 1, Structuring for Rich Media Applications, we’ll begin by examining
HTML5′s state of readiness by analyzing browser support. Then we’ll lay the groundwork
for how to use HTML5′s new elements successfully.

Chapter 2, Supporting the Content, makes us rethink the approach the developers used to
create generic containers to house various types of content.

Chapter 3, Styling with CSS, demonstrates how to use CSS3 to support HTML5. We’ll
also look at styling in modern vs. legacy browsers and what to expect.

Chapter 4, Creating Accessible Experiences, is not a typical regurgitation of Section 508.
Instead, we’ll employ some of the freshest technologies to support our online experiences.

Chapter 5, Learning to Love Forms, we’ll closely examine the new HTML5 input types.
Also included is an analysis of which browsers support each new type.

Chapter 6, Developing Rich Media Applications Using Canvas, is the most forwardthinking
chapter of the entire book. The discussion will center on how to develop for this
new type of interactivity and includes some surprising browser support statistics.

Chapter 7, Interactivity using JavaScript, is jam packed with recipes to extend the new
HTML5 audio and video elements. Roll up your sleeves for this one!

Chapter 8, Embracing Audio and Video, we dig into the core HTML audio and video
experiences. We will construct our own player while still supporting accessibility.

Chapter 9, Data Storage, takes a detailed look at a unique aspect of HTML5 and how to
wield it. Recipes include working with JSON, SQL, and GeoLocation.

Supporting the ContentIn this chapter, we will cover:

Structuring a blog article
Highlighting text using the mark element
Using the time element
Specifying the pubdate of an article
Displaying comment blocks using the article element
Adding fonts dynamically with @font-face
Adding drop shadow effect to fonts
Applying gradient effects to fonts
Annotating visual elements using the figure tag

Introduction

“On the web, a man should not be judged by the color of his skin but by the content
of his content.” – Internet meme

One of the most significant differences between HTML5 and all previous versions of HTML
is that before we built generic

s and other such generic containers without much
knowledge of what content would go in them. With the advent of HTML5, that comes to an end.
To be correct according to the specification semantically, we need to know what the content
is so we can wrap it with the most appropriate new element tag. While this may mean we
developers have to think differently, a new challenge is exactly why we’re here. In this chapter
we’ll look at some examples of how to do just that using several of HTML5′s new elements.

“In case of confl ict, consider users over authors over implementers over specifiers
over theoretical purity.” – Priority of Constituencies

Throughout this chapter, we’ll show you how to use the new

element to mark up
both blog posts and comments, add a meaningful publication date to an

, use
the new element to highlight text, and how to note visual elements using the new

element. We’ll then turn our attention to some new methods of styling text with
font replacement techniques, as well as adding drop shadows and gradients to our text.

Structuring a blog article

“The

element represents a self-contained composition in a document,
page, application, or site and that is, in principle, independently distributable or
reusable, e.g. in syndication. This could be a forum post, a magazine or newspaper
article, a blog entry, a user-submitted comment, an interactive widget or gadget,
or any other independent item of content.” – WHATWG’s HTML5 Draft Standard -

http://whatwg.org/html5

Getting ready

Blog entries are perfect candidates for the new

element, which is designed for
syndicated content.

For this recipe, let’s start by identifying the major elements of a blog

: There’s
usually a headline in the form of a heading tag, the blog entry itself consisting of several
paragraphs and perhaps one or more images, and some information that usually includes the
author’s name and other related metadata. Notice this is all self-contained related content.

How to do it…

We’re going to continue using the new HTML5

and

elements. The
headline, entry and meta-information should be wrapped in their own unique tags, like

,
multiple

s and the new

Let’s start with a foundation very similar to what we used in the last chapter, and add our new

element twice:

     Blog Title       Headline
 
 First paragraph
 Second paragraph
 Meta information.
 
   Headline
 
 First paragraph
 Second paragraph
 Meta information.

Put your code on a diet?

Ready for a shocker? Want to have your mind blown? The and and
tags (as well as their closing tags) are now optional in the HTML5 specification. Sure, you
could leave them in there, and your pages will validate just fine, but why should we? If remove
them from the previous code, we are left with the spartan:

   Blog Title     Headline
 
 First paragraph
 Second paragraph
 Meta information.
 
   Headline
 
 First paragraph
 Second paragraph
 Meta information.

Don’t believe me? Run that code through the World Wide Web Consortium’s validator at:
http://validator.w3.org, and you’ll see it displays correctly in the browser.

Well, not so fast buster. The problem is that removing those elements breaks our code
for screen readers. Uh oh. Strike one. Also, removing the tag breaks our new
HTML5-enabling JavaScript for Internet Explorer. Strike two. And guess what? You can see it
coming, can’t you? Yes, removing the tag removes the language of the page. There it
is: Strike three.

So let’s add those elements back in, shall we?

     Blog Title       Headline
 
 First paragraph
 Second paragraph
 Meta information.
 
   Headline
 
 First paragraph
 Second paragraph
 Meta information.

There, that’s better.

How it works…

Remember, the new

element is a collection of related information intended for
syndication via RSS or another means.

There’s more…

Richer, more meaningful semantics is perhaps the most significant goal for HTML5. It’s better
for machines, better for authors, and most importantly, better for our audiences.

Validation as an aid, not a crutch

As we saw previously, removing the and and tags render a still valid
page. So that begs the question of how valid validators are. Unlike the XML world, HTML5 can
use incorrect syntax and still render just fine.

The author makes every effort to validate his code whenever possible. It’s not necessary
to be slavish to the validator, but it’s always a good quality control check. And the closer you
get to valid code, the better chance browsers will display your work in as consistent a manner
as possible.

Eric Meyer’s funny

The author loves how CSS guru Eric Meyer thinks about validators:

Where to find validators

You can make good use of code validators at:

http://validator.nu
http://validator.w3.org

JavaBeat » Tools & IDEs

Creating Simple Web Application Using Apache Maven

Create Simple Web Application using Maven

Maven Commands

Hello World!

Prepare the Tomcat Manager application

Define Tomcat Server in Maven settings

Point POM to Tomcat Server

Build and Deploy the web application to Tomcat server

Summary

Quartz Job Scheduler – Example Code

Creating Simple Java Project Using Apache Maven

Maven commands

Build project

Summary

Apache Maven for Beginners

What is Maven?

Maven Definition

Maven features

Comparison of Maven with Apache ANT:

Maven POM

Install Maven

Basic User specific Maven Configuration

Summary

HelloWorld with Netbeans 7.2 beta and Scala 2.9

Flex 4.x – Overview

Type of technology

Look and Feel

Drag and Drop

Type of Technology

Application architecture

Environment

Tools Availability

Community Support

Frameworks supported

Flex with Struts:

Flex with Spring:

Flex with Ruby on Rails:

Animation/ Multimedia support

Ease of testing

Flexibility and Scalability

Browsers dependence

Network performance

Client Performance

Client Validation Support

What’s New in Silverlight 5?

Introduction

Features for business and client applications

Media and graphics enhancements

User interaction

Text

Summary

Creating a Custom Pie Chart Component with Degrafa using Flex

Creating a Custom Pie Chart Component with Degrafa

Drawing in Flex

Common Degrafa concepts

Creating a pie chart for fun and profit

New custom event

PieChart component

PieChartSlice

Custom ItemRenderer

Presenter for the PieChart

Model for the PieChart

Summary

How to create EJB project in NetBeans 7.0?

What This Book Covers

Introduction

Creating EJB project

Getting ready

How to do it…

How it works…

HTML5 Multimedia Development Cookbook

What This Book Covers

Introduction

Structuring a blog article

Getting ready

How to do it…