< exec dir="." executable="wsadmin.bat" logError="true" failonerror="true" output="wsconfig.out" >
< arg line="-lang jython -f ../../createQFactory.py"/ >
< /exec >

All output will be logged to wsconfig.out

I used the following to generate XML from sqlplus:

 select dbms_xmlgen.getxml('select * from user') from dual; 

Output:

< ROWSET >
 < ROW >
  < TNAME >Employee< / TNAME >
  < TABTYPE > TABLE < / TABTYPE >
 < / ROW >
< / ROWSET >

Lets see how that is done here.

1. First lets create a OneListener class that should be able to listen to ActionEvents and also be able to add Commands to itself. Please refer to my previous post on Command,Singleton if you would like to see more about this patterns and there usage.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

package com.shaafshah.jmenus;
 
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
 
import javax.swing.AbstractButton;
 
// Implements the ActionListener and is a Singleton also.
 
public class OneListener implements ActionListener{
 
	private static OneListener oneListener = null;
 
	// Holds the list of all commands registered to this listener
	private ArrayList<Command> commandList = null;
 
	// A private constructor
	private OneListener(){
		commandList = new ArrayList<Command>();
	}
 
	// Ensuring one instance.
	public static OneListener getInstance(){
		if(oneListener != null)	
			return oneListener;
		else return oneListener = new OneListener();
	}
 
	// Add the command and add myself as the listener
	public void addCommand(Command command){
			commandList.add(command);
		    ((AbstractButton)command).addActionListener(this);
	}
 
 
	// All Events hit here.
	@Override
	public void actionPerformed(ActionEvent e) {
		((Command)e.getSource()).execute();
	}
 
}

In the above code, the addCommand method adds the command Object and adds a listener to it.
Now how is that possible.
Basically because I am categorizing my UI objects as Commands with in the system having some UI. And I am also assuming that these commands are Currently AbstractButton i.e. JMenuItem, JButton. Lets have a look at the Command Interface and its Implementation.

1
2
3

public interface Command {
	public void execute();	
}

And the implementation, note that the Command is an interface where as the class is still extending a UI object.

1
2
3
4
5
6
7
8
9
10
11
12
13
14

import javax.swing.JMenuItem;
 
public class TestCmd extends JMenuItem implements Command{
 
	public TestCmd() {
		super("Test");
		OneListener.getInstance().addCommand(this);
	}
 
	@Override
	public void execute() {
		System.out.println("HelloWorld");
	}
}

Personally don’t like calling the OneListener in the constructor of the class but just for the sake of simplicity of this post I have left it that way. There are many different ways to omit it.

So the TestCmd is a JMenuItem but is also a Command and thats what the OneListener understands.
As this commads Listener is also OneListener all ActionEvents are thrown there and from there only the Command.execute is called on.

So now you dont have to worry about what listeners are you in. The only thing you know is that when execute is called you need to do your stuff.

You can download the code from Here.

Hope this helps.

1
2
3
4

 public TestReadFileFromJar() throws FileNotFoundException, IOException {
        InputStream is = getClass().getResource("txtData/states.properties");
        read(is);
}

In the case above txtData is placed in the jar on the root. Remmember to add the path with the /

You want to parameterize objects to perform an action
You want to specify, execute and queue requests at different times.

Just to quickly start you need a command object, An interface will keep it easy going in this case, thus providing you with the option of extending other classes e.g. Swing MenuItem or Button.
Below the execute Method is the one invoked to do something when this command is called or asked to do its stuff.
Where as the getCommandName is assumed as a unique name how ever I am sure we can always come up with a better implementation for uniqueness.

1
2
3
4
5
6

public interface Command {
 
    public void execute();
    public String getCommandName();
 
}

And example implementation of the Command should look as follows
A Command Name, and and execute Method to tell what happens when this command is called.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

public class ForwardCmd implements Command {
 
   private String COMMAND_NAME = "Back";
 
   public BackCmd() {
       super();
   }
 
   public String getCommandName() {
       return COMMAND_NAME;
    }
 
    public void execute() {
        System.out.println("Your wish, my command");
    }
}

The command manager is the controller in this case. It registers command objects. the “registerCommand” will simply take a command and store it in a list or something alike. This means you could load it out of a jar file, or an xml or path and just pass the object to the “registerCommand” AS a command offcourse.

the “execute” Command will simply execute the Command passed to it.

And the “getCommand” returns a command by looking up a COMMAND_NAME. So if you provide a name to it through you system it should give you an object of type Command and simple pass it to execute. Again this would be a controller logic and not the client one.

1
2
3
4
5
6
7

public abstract class AbstractCommandManager {
 
    public abstract void registerCommand(Command command);
    public abstract Collection getAllCommands();
    public abstract void execute(Command command);
    public abstract Command getCommand(String name);
}

Adapter a structural pattern will let you adapt to a different environment. The joining between different environment is called Adapter. Thus basically giving others the interface that they expect or vice versa when your program becomes the client.

For example the following class expects that the implementing class should be implementing all three methods.

1
2
3
4
5
6
7
8
9

public interface RecordListener {
 
public void eventPrePerformed(RecordEvent recordEvent);
 
public void eventPerformed(RecordEvent recordEvent);}
 
public void eventPostPerformed(RecordEvent recordEvent);
 
}

So lets say our implementing class is a rude one and only wants to implement one method. What do you do as an API designer. hmmm

Thats where we step in with the Adapter.

1
2
3
4
5
6
7
8
9
10
11
12
13

public abstract class RecordAdapter implements RecordListener {
 
public void eventPrePerformed(RecordEvent recordEvent) {}
public void eventPerformed(RecordEvent recordEvent) {}
public void eventPostPerformed(RecordEvent recordEvent) {}
 
}
 
public MyAdapterImpl extends RecordAdapter{
 
public void eventPerformed(RecordEvent recordEvent){}
 
}

Now the only thing left to do is use the adapter. And override any method that you might need .

1
2
3
4
5
6
7
8
9

public MyClientClass {
 
public MyClientClass(){
 
this.addRecordListener(new MyAdapterImpl());
 
}
 
}

I often find my self with this problem.

If you want to delete or create a Websphere profile from your command line try the following. (I have tried on RSA only)

# deleteing a profile
wasprofile -delete -profileName MyProfile

You should get the following message on deletion

INSTCONFSUCCESS: Success: The profile no longer exists.

Creating a websphere profile

wasprofile -create -profileName MyProfile -profilePath \
[PROFILE PATH] -templatePath \
[RSA HOME]runtimes\base_v6\profileTemplates\default \
-nodeName [NODE NAME] -cellName [CELL NAME] -hostName [HOSTNAME].

So today I am talking about the Abstract Factory pattern. Its not an “abstract” class or object that you call a pattern. But its a Factory of facotries and that is what exactly makes it so much wordingly abstract. Having “abstract” classes is there but just some other side of the coin.

When should I use an Abstract Factory:

• Independence of how products are created, composed or represented
• Should be configurable with one of the multiple families or products
• You need enforcable constraints for the products used as a group
• You need to reveal only the interfaces of products and not thier implementation as part of a bigger picture.

So lets begin with the fun.

This is how I plan to implement it:
Has A:
Product has a Specification
Factory has a Product
FactoryManager has FactoryConstants
FactoryManager has ComputerFactory

Is A:
BFactory is a ComputerFactory
AFactory is a ComputerFactory

Not shown.
ProductA is a Product
ProductB is a Product

Diagram:

AbstractFactory

Creating a simple factory that returns products.

1
2
3
4
5
6
7
8
9

public abstract class ComputerFactory {
 
 public abstract String getName();
 
 public abstract Product[] getProducts();
 
 public abstract Product getProduct(int ProductID);
 
}

Implementation of the ComputerFactory

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

public class AFactory extends ComputerFactory {
 
public String getName(){
return "A";
}
 
public Product[] getProducts(){
return null;
}
 
public Product getProduct(int productID){
switch(productID){
case 1:
return new ProductA();
 
case 2:
return new ProductB();
 
default:
throw new IllegalArgumentException("Sorry you hit the wrong factory, we closed down in 1600 BC");
}
}
}

A register base for factories. Refer to the main method for use later in this post.

1
2
3
4
5
6

public interface FactoryConstants {
 
 public int A = 1;
 public int B = 2;
 
}

The main Entrant class. the Factory Manager that will give the ComputerFactory resultant. Its assumed to be a Singleton as it registers as a Creator in the system (assumption).

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

public class FactoryManager{
 
 private static FactoryManager factoryManager = null;
 
 private FactoryManager(){
 
 }
 
 public static FactoryManager getInstance(){
  if(factoryManager != null){
   return factoryManager;
  }
  else return factoryManager = new FactoryManager();
 }
 
 public ComputerFactory getFactory(int factory) throws IllegalArgumentException{
 
  switch(factory){
   case FactoryConstants.A:
   return new IBMFactory();
 
   case FactoryConstants.B:
   return new SUNFactory();
 
   default:
   throw new IllegalArgumentException("Sorry you hit the wrong factory, we closed down in 1600 BC");
  } 
 }
}

A main method to test the AbstractFactory

1
2
3
4
5
6
7

 public static void main(String args[]){
 
  System.out.println(FactoryManager.getInstance().getFactory(FactoryConstants.A).getName());
  System.out.println(FactoryManager.getInstance().getFactory(FactoryConstants.B).getName());
  System.out.println(FactoryManager.getInstance().getFactory(3).getName());
 
 }

You can find the complete code listing here:
AbstractFactory source

Create a new branch from trunk:
If you want to create a branch from a specific revision of Trunk following command is handy. It does a remote copy. which means the machine you are on does not need a copy of the whole tree.

$ svn copy -r REVISION TRUNK_URL NEW_BRANCH_URL --username USERNAME --password PASSWORD -m MESSAGE

An example

$ svn copy -r 1234 http://shaafshah.com/trunk http://shaafshah.com/branches/MY_BRANCH --username foo --password bar -m "Remote copy"

When was this branch created?
If you want to know the day branch was created.

$ svn log -v --stop-on-copy BRANCH_URL

The last record will show you the day the branch as created.

List all the branches:
If you want to take a listing of branches or a tree

$ svn ls BRANCHES_URL

e.g. http://shaafshah.com/branches

Merge from Branch to Trunk:

Browse to where you have checkedout trunk in the local directory.

$ cd shaafshah.com/trunk

Update trunk to HEAD.

$ svn update
At revision 1234.

Following will merge from branch to trunk but will not commit.

$ svn merge -r BRANCH_REVISION:TRUNK_REVISION BRANCH_URL

Branch_REVISION will be the revision branch was created if this is the first time you are doing the merge.

$ svn merge -r 1233:1234 http://shaafshah.com/branches/my_new_branch

After this you should do an

svn status

to check the status of the files. the files will be marked with following Characters.

‘A’ Added
‘C’ Conflicted
‘D’ Deleted
‘I’ Ignored
‘M’ Modified

If there is any ‘C’ in the status the files will not be committed if you try an svn commit to save the merge to the trunk.

Merge from Trunk to Branch:

To merge from Trunk to branch you would need to browse to the branch checked out in the local direcotry.

$ cd shaafshah.com/branches/mybranch

$ svn update
At revision 1234.

The following command will try merging trunk from revision 1233 i.e. the day branch was created to branch head.

$ svn merge -r 1233:HEAD TrunkURL BRANCH_URL

Hopefully this should help. However you should definitely refer to SVN Book for more detail.

svnbook at http://svnbook.red-bean.com/