Blogging for Knowledge

Beginning EJB3 with JBoss and MySQL

2013-11-16T20:58:00.000-08:00

Here, I am going to show how to begin with EJB and deploy in JBoss server. For this example, I am using MySQL database.

Prerequisites for this example:
- JBoss
- Eclipse
- MySQL

The first step involves the work in JBoss server side.

- Copy jboss\docs\examples\jca\mysql-ds.xml to jboss\server\default\deploy and edit as in the xml below.
- Copy mysql-connector-java-.jar to jboss\server\default\lib.

Let’s run eclipse and create an EJB project. File-->New-->EJB Project.

Click on ‘New Runtime’ button.

Select Jboss 5.0 and click Next.

Browse JBoss root directory and click ‘Finish’.

Click Finish.

Add a file named persistence.xml in ejbModule/META-INF.
Add an entity class User in com.test.user.domain package.

Add a Session Bean(New-->Session Bean(EJB 3.x)).

It will create a session bean and a remote interface.

Run As --> Run on Server

Which shows our service is up and running.

While deploying, if you get an error due to AttachmentStore,you may need to change the content of jboss/server/default/conf/bootstrap/profile.xml. Look for the definition of the AttachmentStore, and change the constructor line so that it starts:
The original one doesn't have the class="java.io.File" attribute.

Now, let’s start with the client.Create a test class with main method as follows.
Here, JNDI lookup can be performed in two ways.

1. By setting properties in the Java class.

As commented above
Or

2. By adding jndi.properties file in src folder.
jndi.properties:

Run UserTest as a Java application.

Output: User has been created successfully.

Spring and Drools

2013-11-11T13:33:00.002-08:00

Let us assume that we have dozens of rules that we have to implement, divide into some classes, subclasses, abstractions and of course unit test. This can be difficult and time consuming to both write and support. There are many ways of dealing with this problem and following example leverages one of them - JBoss Drools. Drools is a library specifically created for such purposes like implementing rules. It contains a rule engine that can process rules written using the Drools language (you can also provide rules in Excel spreadsheets! - perfect for Business side to support and management). Here, we will take a look at the way one can integrate JBoss Drools with Spring. (Reference: http://java.dzone.com/articles/drools-integration-spring-vs)

POJO Class:
Main Class:
Service Class:
Util Class:
applicationContext.xml
drools-context.xml
log4j.xml
Rule file(account-rules.drl)
pom.xml Project Structure:

And here goes the output.

Enjoy Drooling!

Velocity Template with Spring

2013-06-22T18:59:00.002-07:00

Below example demonstrates how Velocity Template can be integrated with Spring for sending emails in a given template or write the content to an XML file.
Spring Configuration:

Main Class:

Test Class:

Email Template:

XML Template:

POM:

Output(Email):

Output(Xml File):

Project Structure:

XML to Java Conversion with Smooks

2013-05-03T07:32:00.001-07:00

Here is a simple example of XML to Java Conversion with Smooks.
Enjoy!!

input-message.xml

smooks-config.xml

pom.xml

Project Structure.

Output:

Login page for ActiveMQ using Tomcat and LDAP

2013-05-01T11:42:00.000-07:00

ActiveMQ doesnot come with login page.But for security issues some users might want to have login page to access. So for this I have tried to create a simple login page for ActiveMQ using Tomcat and LDAP. You can use Database or Tomcat instead of LDAP.

Here is a simple example of a login page in ActiveMQ.
Download the latest ActiveMQ from http://activemq.apache.org/download.html. Get the latest Tomcat from http://tomcat.apache.org/. Now lets get started with the coding. For this you have to create a login page.
And the logout page.
Add this in web.xml.
Now add this in main.jsp file inside the decorators folder in activemq for log off functionality.
Now add the appropriate realm to server.xml of tomcat. I have used ldap for authentication.So for ldap, in my case i have these properties.
Here is the folder structure of this project.

Now deploy the activemq in Tomcat. http://localhost:8080/activemq.

Spring Data Support

2013-03-31T17:09:00.003-07:00

Introduction to Spring Data and Setting Up

This tutorial serves as an introduction to Spring Data support. We'll also install a lightweight database Apache Derby that we'll use in subsequent tutorials. We'll learn how to start Derby in Network server mode, and how to connect and run SQL queries using the ij client tool.

Using JDBC without Spring

We'll now implement a simple DAO class that fetches data from the database using JDBC. We'll look at all the boilerplate code we need to write to establish connections, execute queries, close objects and handle exceptions.

Adding Spring and DataSource Configuration

We'll now add the Spring framework to our JDBC project. We'll add dependency injection to our Main and DAO class. We'll also learn how to configure DataSource as a Spring bean and supply connection parameters to it in the XML file.

Using JdbcTemplate

We'll use the JdbcTemplate class provided by Spring to implement a DAO method. We'll see how using the template class makes the DAO methods simple, and how it takes care of much of the boilerplate code we'd have to write otherwise.

Returning Other Datatypes from JdbcTemplate

We returned an integer datatype result from our query in the previous tutorial. In this tutorial, we'll learn how to return other datatypes. We'll implement a method that returns a String query output.

Implementing RowMapper

In this tutorial, we implement a custom RowMapper class to map our domain objects. We then use this class to write fetch methods that return custom model objects.

Performing Write Operations with JdbcTemplate

We'll now implement some database write operations. We'll write a DAO method to update a value in the database, as well as use the execute() method to run a DDL SQL query.

Named Parameter JDBC Template

We'll use the NamedParameterJdbcTemplate class to run queries with named placeholders.

DAO Support Classes

We'll wrap up discussion on the Spring JDBC support by using the DAO support classes that Spring provides out of the box. We'll see how this makes our DAO classes cleaner than ever.

Using Hibernate with Spring

In this video, we'll learn how to integrate the Hibernate framework in our Spring application. We'll create a SessionFactory as a Spring singleton and use that in our DAO class to work with the database.

Spring AOP

2012-01-31T17:00:00.001-08:00

Introduction to AOP

This video provides a brief introduction to Aspect Oriented Programming concepts.

Setting Up AOP Dependencies

In this tutorial, we'll add the additional dependencies required for Spring AOP and we'll configure our project's class path with these dependencies.

The links for the dependencies are:
AspectJ: http://www.eclipse.org/aspectj/downloads.php
AOP Alliance: http://aopalliance.sourceforge.net/
CGILIB: http://cglib.sourceforge.net/
Spring 3 ASM: http://asm.ow2.org/
Writing Our First Aspect Part 1

In this first part of the tutorial, we'll create a Spring project that forms the basis for our Aspect. This is a good refresher of some of the core Spring concepts, and it also give us an opportunity to introduce a service layer in our code that we'll build on in the subsequent tutorials.

Writing Our First Aspect Part 2

Now that we have a basic Spring application, we'll implement the Logging aspect. We'll learn how to create a new Aspect using annotations and configure an advice to run before a getter method.

Pointcuts and Wildcard Expressions

We'll now learn what a Pointcut is, the Pointcut annotation and how to apply advice to multiple pointcuts.

A Few More Pointcut Expressions

In this tutorial, we'll learn about a few other Pointcut expressions that can be used to advice different methods.

JoinPoints and Advice Arguments

We'll now learn about join points, and how we can use arguments in the advice methods to get information about join points.

After Advice Types

We'll learn about the After Advice types: After (finally), AfterReturning and AfterThrowing.

Around Advice Type

This tutorial covers the Around advice type. We'll learn how to use it, and we'll also look at some of the unique and powerful features that are specific to this advice type.

Naming Conventions and Custom Advice Annotations

In this video, I share some thoughts on naming conventions, and how it helps in the case of writing aspects in Spring. We will also understand how to write our own custom annotations to apply advice to methods.

AOP XML configuration

Here, We'll learn how to configure aspects, advice and pointcuts using the traditional XML way.

Understanding AOP Proxies

In this video, we go where no Spring AOP tutorial has gone before! We'll understand how Spring AOP works and how it uses proxy classes to apply advice. And we'll do this by implementing our own simple factory service. The way Spring AOP works is much more complicated, but this simple implementation should give us a solid understanding of proxy objects and clarify the core concepts.

Read from JSON file and persist into MySQL

2012-01-31T16:43:00.000-08:00

Here is a simple example where we are reading contents of a JSON file and inserting into MySQL database. The code is dynamic so it can handle any number of columns no matter what the column name is. All you have to do is match the database column names with JSON content.

For this demo, we are using following jar files.

And this the content of json file(test.json) we have.

And here is what you see in database after executing above code.

Spring/Hibernate Tutorial Links

2011-10-29T19:27:00.000-07:00

krams915.blogspot.com/
www.vaannila.com/
www.mkyong.com
viralpatel.net

www.laliluna.de
javabrains.koushik.org/
www.springbyexample.org
www.springsource.org
www.giantflyingsaucer.com/blog/

www.javacodegeeks.com/
www.myhomepageindia.com
Roseindia
Java2s
Java9s
Lulu
creativeinstantia.blogspot.com

Hibernate Tutorial [Java Brains]

2011-10-17T19:49:00.001-07:00

Hibernate is a popular open source object relational mapping tool for Java platform. It provides powerful, ultra-high performance object/relational persistence and query service for Java. Hibernate lets you develop persistent classes following common Java idiom - including association, inheritance, polymorphism, composition and the Java collections framework. The Hibernate Query Language, designed as a "minimal" object-oriented extension to SQL, provides an elegant bridge between the object and relational worlds.

Introduction To Hibernate

In this tutorial, we'll understand the mismatch between object and relational models and what ORM is.

Setting Up Hibernate

In this tutorial, we'll download Hibernate and set it up in our development environment by configuring it in Eclipse.

Part 1- Writing a Hibernate Application

In this first of a three part video on writing a simple Hibernate application from the scratch, we'll learn how to write the Hibernate configuration XML file, hibernate.cfg.xml.

Part 2- Writing the Model Class with Annotations

We'll now create a Model class and configure it as an Entity using Annotations.

Part 3- Saving Objects using Hibernate APIs

We'll learn how to instantiate Entity objects and save them to the database using Hibernate APIs.

hbm2ddl Configuration and Name Annotations

In this tutorial, we'll look at the schema generation options in Hibernate. We'll also learn some annotations to change the default name generated by Hibernate for entities.

More Annotations

We'll try out a few more annotations to configure our entity class.

Retrieving Objects using session.get

We'll look at one of the several ways we can fetch data from the database using Hibernate: the session.get method.

Primary Keys

Here we'll learn how to configure the primary key in our entity class using the @Id annotation.

Value Types and Embedding Objects

We'll learn the difference between Entity type objects and Value type objects. We'll use the @Embeddable annotations to embed a value type object into our Entity class.

AttributeOverrides and Embedded Object Keys

In this video, we'll learn how to override configuration inside embedded objects, and we'll also explore object keys.

Saving Collections

We'll now learn how to save value types that are collection objects.

Configuring Collections and Adding Keys

More configuration options for collections, including configuring primary keys.

Proxy Objects and Eager and Lazy Fetch Types

Hibernate manages data fetching and optimizations using proxy objects. In this tutorial, we'll learn what they are and how lazy initialization works.

One To One Mapping

One to one mapping of entities.

One To Many Mapping

One To Many mapping of entities.

mappedBy and Many To Many Mapping

Many to Many mapping of entities.

CascadeTypes and Other Things

In this tutorial, we'll look at some concepts like CascadeType which can be configured for entity relationships.

Implementing Inheritance

We'll understand how to configure entity classes that have an inheritance hierarchy.

Implementing Inheritance - Single Table Strategy

Single table inheritance strategy.

Implementing Inheritance With Table Per Class Strategy

Table per class inheritance strategy.

Implementing Inheritance With Joined Strategy

Joined inheritance strategy.

CRUD Operations

Writing code to Create, Read, Update and Delete entities in the database.

Transient, Persistent and Detached Objects

This tutorial discusses three important entity object states in Hibernate: Transient, Persistent and Detached.

Understanding State Changes

We'll understand some of the different ways in which entity objects change from one state to another.

Persisting Detached Objects

This tutorial explores a special case of object state change: from detached to persistent.

Introducing HQL and the Query Object

Introducing HQL and using HQL to run queries on the database.

Select and Pagination in HQL

In this tutorial we'll learn Hibernate's support for pagination. We'll also learn how to write select queries to retrieve only certain columns.

Understanding Parameter Binding and SQL Injection

We'll understand how appending parameters to SQL queries causes SQL injection, and will learn how to use the Parameter Binding feature in Hibernate.

Named Queries

We'll learn about named queries and how to write and access named queries. We'll also write and execute a NamedNativeQuery.

Introduction to Criteria API

This tutorial is an introduction to the Criteria API. Yet another way to work with data in Hibernate.

Understanding Restrictions

Understanding how to apply restrictions to our queries when using Criteria.

Projections and Query By Example

In this tutorial, we'll learn how to use Projections to fine tune the results of the Criteria API. We'll also use Query By Example (QBE) to easily specify multiple where clauses in a single example object.

Cacheing in Hibernate

In this tutorial, we'll learn about Hibernate's cache support: both first level (Session) and second level cache.

Configuring Second Level Cache

We'll configure EHCache as our second level cache, and then put it to work. We'll fetch an object across two sessions, and we'll see how

Hibernate's second level cache comes into play to save a database query.

Using Query Cache

In this tutorial, we'll learn how to cache results that are fetched from the Query object.

Spring Tutorial[Java Brains]

2011-10-17T19:49:00.000-07:00

Spring is a light weight, non-invasive IoC Container and AOP framework. It provides support for JPA, Hibernate, Web services, Schedulers, Ajax, Struts, JSF and many other frameworks. The Spring MVC components can be used to develop MVC based web applications. Spring framework provides many features that makes the development of enterprise application easy.

Understanding Dependency Injection

In this tutorial, we'll understand the concept of Dependency injection.

Setting Up

In this tutorial, we'll learn how to set up our Eclipse development environment to write Spring code.

Understanding Spring Bean Factory

In this tutorial, we'll discuss the role of Spring as a bean container. We'll also have a quick discussion on the Factory pattern, and I'll introduce you to the Spring Bean Factory object.

Writing Code Using the Bean Factory

In this tutorial, we'll write code to implement the BeanFactory concept that we learnt in our previous tutorial. We'll write a Spring XML to configure a Spring bean. Then we'll use the BeanFactory to instantiate our bean in the Spring container.

ApplicationContext and Property Initialization

We'll first replace the BeanFactory with the more powerful ApplicationContext. We'll then make Spring initialize a property of an object by specifying the value in the configuration XML.

Using Constructor Injection

We'll now use constructors to set the member variable values for our Spring beans. We'll also look at some techniques to resolve conflicts in the case of overloaded constructors.

Injecting Objects

In this tutorial, we'll use dependency injection to inject an object dependency to a Spring bean.

Inner Beans, Aliases and idref

In this tutorial, we'll look at some concepts related to bean naming and usage like alias and idref. We'll also understand how to write inner beans.

Initializing Collections

In this tutorial, we'll initialize a member variable that's a collection and each of the elements are references to other beans.

Bean Autowiring

We'll now look at a configuration feature provided by Spring to wire dependencies automatically: Bean Autowiring. We'll learn about different types of autowiring, and we'll write some code to implement bean autowiring by name.

Understanding Bean Scopes

This tutorial covers the concepts of Bean Scopes in Spring. We'll understand when beans are created and how to configure different scopes for the beans.

Using ApplicationContextAware

We'll provide our beans with access to the ApplicationContext object by implementing the ApplicationContextAware interface. We'll also use BeanNameAware interface to get the name of the bean configured in the Spring XML.

Bean Definition Inheritance

In this tutorial, we'll learn what bean definition inheritance is, and how to configure a parent bean definition and have children beans inherit the bean definitions.

Lifecycle Callbacks

We'll use two different ways to run methods on initialization and destruction of beans.

Writing a BeanPostProcessor

In this tutorial, we'll understand what a BeanPostProcessor is. We'll also write a BeanPostProcessor that prints a message upon initializing each and every bean in the Spring XML.

Writing a BeanFactoryPostProcessor

In this tutorial, we'll learn about and write our own BeanFactoryPostProcessor. We'll also try out a handy BeanFactoryPostProcessor that comes with Spring: the PropertyPlaceholderConfigurer.

Coding To Interfaces

When using Spring for dependency injection, it's a good practice to use interfaces for referencing dependencies. In this tutorial, we'll learn how to "code to interfaces".

Introduction to Annotations and the Required Annotation

Here we'll have our first look at Spring annotations. We'll understand and implement the Required annotation, and we'll also learn how it's actually a BeanPostProcessor that's working behind the scenes.

The Autowired Annotation

In this tutorial, we'll use the Autowired annotation to wire up dependencies. We'll learn how to add dependencies by type and name. We'll also use Qualifiers to narrow down dependency contenders.

Some JSR-250 Annotations

We'll learn and implement three JSR-250 annotations that Spring supports:Resource, PostConstruct and PreDestroy.

Component and Stereotype Annotations

We'll now use the Component annotation to define Spring beans. We'll also look at some Stereotype annotations.

Using MessageSource To Get Text From Property Files

In this tutorial, we'll use the MessageSource interface to retrieve messages out of property files.

Event Handling in Spring

We'll now look at Spring's support for Event Handling. We'll write an event listener in this tutorial. i'll also show you how to write custom events and publish them anywhere in the code.

Spring 3 Hello World...

2011-10-12T17:22:00.000-07:00

Download Spring 3.1 from here.

Once you extract, create a user library named Spring3 and include all the jars from spring-framework-3.1.0.M2\dist directory. Add one more jar(commons-logging.jar) that you can find in spring-framework-3.1.0.M2\projects\spring-build\lib\ivy directory.

Create 2 classes as follows.

package com.test;
public class HelloWorld {

   public void printHello(){
       System.out.println("Hello Spring 3.0!");
   }
}

And

package com.test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class HelloWorldTest {

    public static void main(String[] args) {
        //XmlBeanFactory ctx = new XmlBeanFactory(new ClassPathResource("hello.xml")); //Deprecated Approach
        ApplicationContext ctx = new ClassPathXmlApplicationContext("hello.xml");
        HelloWorld hw = (HelloWorld) ctx.getBean("HelloBean");
        hw.printHello();
    }
}

Now, create an xml file hello.xml in src directory.

That's it.

Output:

Android Development Tutorial

2011-03-18T16:57:00.000-07:00

Summary of Tutorial:

1. Install JDK/Eclipse/Android SDK.

Android SDK:
http://dl.google.com/android/installer_r10-windows.exe

2. Set JAVA path. (To verify, go to command prompt and enter javac.)

3. Integrate Android into Eclipse.
       Go to Help-> Install New Software-> Add->

    Name: Android ADT
    URL: https://dl-ssl.google.com/android/eclipse

Let it setup everything by selecting all.

4. Go to Windows-->Preferences-->Android
Enter Android SDK Location.

5. Create a new Android project.

Select a version.
App Name same as Name.
Activity-->Class Name
Version as selected above(8 for 2.2)

6. Add a new device by clicking on Android icon on toolbar.(Maintain version)

7. Click on Run Config-->Android App.
Name-->Anything
Android Tab--> Choose your project.
Target Tab-->Choose your device.

Apply.

8. Run

Java Hibernate Tutorial

2010-12-07T17:23:00.000-08:00

Spring Framework Tutorial (www.java9s.com)

2010-12-07T16:56:00.000-08:00

Spring Framework Tutorial Session 1

This is an introduction to spring framework. Spring framework was introduced by Rod Johnson. Spring offers Dependency Injection and Aspect-oriented Programming. Spring framework contributes to loose coupling and Inversion of Control. This session gives an overview of how spring framework contributes to loose coupling. Spring has modules like Spring jdbc, spring JMS which reduces the complexity in implementing those APIs.

Download the PPT and Example Code

Introduction to spring framework part 1

Introduction to spring framework part 2

Introduction to spring framework part 3

Spring Framework Tutorial Session 2 Basic Bean Wiring - Spring

This Session elaborates on Spring Basic Bean wiring. This video explains about how to inject the values to the bean through the setter methods and the constructor arguments. It also elaborates about spring list configuration, configuring to load set collection, Map, Properties.

It depicts how the spring framework containers work and how the bean life cycle is managed. The first explains about the Spring framework BeanFactory and then ApplicationContext containers.

Download Basic Bean wiring PPT

Download the Basic Bean wiring example

Spring Framework Tutorial Session 3 Spring Auto Wiring - by Type, by Name, by Constructor

This video explains about the advantages of Spring auto wiring. It explains different types of spring Auto wiring like byName, byType and by constructor.

Auto wiring byName:
By using this autowiring- the spring framework checks looks for the properties and checks if any other beans are name with the same name in the xml and if matches then instantiates and injects it into the target bean.

Auto wiring byType:
By using this kind of autowiring, the spring framework looks the type of the property and checks if there is a bean with the same type. If the type matches, it creates the bean and injects it to the target type.

Autowiring by Constructor:
By using this kind of Autowiring, the spring framework checks each and every argument of the constructor and checks if there is a same type of bean present in the configuration. If present, spring instantiates it and injects it through the constructor.

Download the Spring Auto wiring PPT

Download the Spring Auto wiring example

Spring Framework Tutorial Session 4 - Spring Method Injection and Bean Scope

This video elaborates about the Spring Method Injection and Spring Bean Scopes. Spring Framework has this wonderful feature of Method Injection to control what kind of methods need to be executed and also what kind of return types should be returned by the Spring Framework.

Download Spring Method Injection and Bean scope PPT

Download Spring Method Injection and Bean scope example

Email in GWT

2009-07-21T02:54:00.000-07:00

Here is a simple code to send mail in GWT.

Write this code in servletImpl class

String host = "xxx.com.xx";//use your own host
String from = "..........";// email id
String to = ".............";//email id

// Get system properties
Properties properties = System.getProperties();

// Setup mail server
properties.setProperty("mail.smtp.host", host);

// Get the default Session object.
Session session = Session.getInstance(properties);

More...


     // Create a default MimeMessage object.
     try{
     MimeMessage message = new MimeMessage(session);// error is
shown in this line

     // Set the RFC 822 "From" header field using the
     // value of the InternetAddress.getLocalAddress method.
     message.setFrom(new InternetAddress(from));

     // Add the given addresses to the specified recipient type.
     message.addRecipient(Message.RecipientType.TO, new
InternetAddress(to));

     // Set the "Subject" header field.
     message.setSubject("hi..!");

     // Sets the given String as this part's content,
     // with a MIME type of "text/plain".
     message.setText("Hi ......");
     Transport.send(message);

     }catch(MessagingException e){

             e.printStackTrace();
     }
     // Send message

      System.out.println("Message Send.....");

Note: Include activation.jar in library of project

Simple Menubar in GWT

2009-06-23T03:25:00.000-07:00

This is just a simple example of menubar for GWT beginners.
Code:


import com.google.gwt.user.client.Command;
import com.google.gwt.user.client.Window;
import com.google.gwt.user.client.ui.MenuBar;

public class Menubar extends MenuBar{
MenuBar menu = new MenuBar();//main menubar
public Menubar() {


MenuBar home = new MenuBar(true);// Home menu
MenuBar newbar = new MenuBar(true); // New Sub menu
home.addItem("New", newbar);//adding New sub menu to Home menu

/*
* Adding Sub New 1 menu to New sub menu
*/

newbar.addItem("Sub New1",new Command(){
public void execute() {
 Window.alert("Sub New 1 clicked");// define action here 
}
});

newbar.addItem("Sub New2",new Command(){
public void execute() {
 Window.alert("Sub New 2 clicked"); 
}
});

/*
* Adding menu home,support etc to main menubar
*/
this.addItem("Home", home);

this.addItem("Support",new Command(){
public void execute() {
 Window.alert("Support clicked"); 
}
});

this.addItem("Services",new Command(){
public void execute() {
 Window.alert("Services clicked"); 
}
});

this.addItem("Contact",new Command(){
public void execute() {
 Window.alert("Contact clicked"); 
}
});

this.addItem("Help",new Command(){
public void execute() {
 Window.alert("Help clicked"); 
}
});
}
public MenuBar displayMenu(){
return this;
}
}

EntryPoint class:


import com.google.gwt.core.client.EntryPoint;
import com.google.gwt.user.client.ui.RootPanel;

/**
* Entry point classes define onModuleLoad().
*/
public class Index implements EntryPoint {

/**
 * This is the entry point method.
 */
Menubar menu = new Menubar();
public void onModuleLoad() {  
  RootPanel.get().add(menu.displayMenu());
}
}

Output:

Building menubar in GWT

2009-06-23T02:43:00.000-07:00

This is just a simple example on building a menubar with submenus.

Code:

Calculating Sum in Each Group in iReport

2009-06-22T00:23:00.000-07:00

To calculate the sum in each group in iReport, just do as shown in previous post Grouping in iReport. Now add in query, another field of which you want to take out the sum. For example see in figure below.

More...
Now create a new variable named SUM as shown in figure.

Now select and write the fields as shown in figure for variable SUM.

Now arrange all the fields as shown in figure and run the file.

Output:

Grouping in iReport

2009-06-21T23:02:00.000-07:00

Here is a simple example on grouping in iReport. Its steps are as follows:

1. Create a new document as shown in figure.

More...
2. Now go to the Data option and select Report Query and write query in the window that appears as shown below.

3. Now go to View option and select Report Groups and name the group and give the expression of the field by which you want to group as shown in figure.

4.Now put the info required in the bands as shown in figure.

5. Now right click on field and edit the properties as shown in figure.

6. Delete the unnecessary bands and make report clear and keep only necessary bands as shown below.

7.Now run the report and the result will be shown as in figure.

Reading Files From a Certain Location Using JAVA

2009-06-18T01:59:00.000-07:00

Here is a simple example of reading files from any folder and list their names and size on disk. The code goes here:


import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;

public class FileTest {
public static void main(String args[]){
File file = new File("C:/windows/system32");
File files[] = file.listFiles();


try{
BufferedWriter writer =  new BufferedWriter(new FileWriter("c:/ex.txt"));
for(int i=0;i<files.length;i++){
   Long size =(files[i].length());
   String leng= String.valueOf(size);
   Float lg = Float.valueOf(leng)/1024;
   writer.write(files[i]+" ------size ="+lg+"KB");
   writer.newLine();
 }
 writer.close();
}
catch(IOException e){
    e.printStackTrace();
    }
  }
}

Output:

GWT Help For Beginners

2009-04-29T02:40:00.000-07:00

Since I had worked in GWT framework, I would like to share my knowledge as a help to those who want to use GWT and had not been able to do so. I have listed the steps to configure and run GWT projects. This is just the starting and I will post more articles further.

Steps for using GWT

1. Download GWT from here.
(I have just used this version of gwt as an example and you can follow the same procedure for earlier versions as well. As I have not used gwt 1.6 yet, I do not know whether this works for it too.)
More...
2. Extract it to one of your drives.

3. Set path of the folder where applicationcreator and projectcreator files are located.

e.g. D:\gwt-windows-1.5.3\gwt-windows-1.5.3 (As shown in figure)

4. Go to command prompt and create a directory in any of the drives. Now, create a project as shown in the figure.

Click on the image for a large-sized figure.

5. Now open Eclipse IDE and import the project as shown below:

6. Click Finish.

7. Now browse and select the project.

8. Once you click on Run button (), you will see the output as shown in figure.

I hope this post will help you to create your own GWT project.
For further comments and suggestions, you are warmly welcomed.

Introduction

2009-04-10T04:53:00.000-07:00

Hi Everyone,

This is Asmita Sapkota from Kathmandu, Nepal(Currently working in USA). I have just created this blog and for further new, interesting postings you'll have to wait a bit.

Thanks for viewing this blog.