Three2Tango » ATG & Java

XMLDOM Parser:ATG

Sam — Sun, 08 Aug 2010 13:20:23 +0000

The code below explains how to get the value of a particular node from an XML. Dont forget to take a look into the imports in the class as the XMLToDOMParser and ApacheXMLToolsFactory are two very important packages you can’t forget for this code to work. “xPath” gives the node we have to find. The string variable “xPath” is defined in a particular way. The path in the eg: file(testParsingXML.java) will lead you to the node named “category“. Here is another example to know how to write the xPath:= /root/son[@name=\"firstchild\"]/grandson[@name=\"gs1\"]

This xpath will lead you to grandson node. All other things in the code are self explanatory. An xml specified in the code is also provided., make sure you copy the xml(test.xml) in the same path mentioned in the java code. Hope the code snippet helps. This code will work fine within an ATG environment. I tried successfully.

Drawback:

This code will definitely help you find the value of known node, but wont help you in finding a dynamic node.Which means you need to specify the node name to get the value.Eg: you can’t read all “category” nodes of “granddaughter” just by specifying xpath till “granddaughter”.

1 . “testParsingXML.java”

import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.Enumeration;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import atg.xml.tools.XMLToDOMParser;
import atg.xml.tools.apache.ApacheXMLToolsFactory;

public class testParsingXML{
public static void main(String[] argS){
		XMLToDOMParser xtdParser;
		ApacheXMLToolsFactory axtFactory = new ApacheXMLToolsFactory();
		xtdParser = axtFactory.createXMLToDOMParser();
		File xmlFile = null;
		FileInputStream fis= null;
		xmlFile = new File("E:\\test.xml");

		try {
			fis = new FileInputStream(xmlFile);	 // Should wrap with try catch block
			byte fileContent[] = new byte[(int)xmlFile.length()];
			fis.read(fileContent); 	// Should wrap with try catch block
			ByteArrayInputStream bis = new ByteArrayInputStream(fileContent);
			Document document = xtdParser.parse(bis ,false ,null);
			String xPath ="/root/daughter[@name=\"secondchild\"]/granddaughter[@name=\"three2tango\"]/category[@name=\"c1\"]";
			Enumeration nodes = axtFactory.createXSLQueryEngine().select(xPath, document, null);
			Node node = nodes.nextElement();
			if (node.hasAttributes())
			{
			NamedNodeMap attributes = node.getAttributes();
			System.out.println(attributes.item(1));
			System.out.println(attributes.getNamedItem("name").getTextContent());
			System.out.println(attributes.getNamedItem("value").getTextContent());
			}
		} catch (FileNotFoundException e) {
		} catch (IOException e) {
			e.printStackTrace();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

2. “test.xml”

Installing a Decompiler plugin(JAD) for Eclipse

Lloyd — Fri, 30 Jul 2010 21:58:35 +0000

A decompiler does the reverse of a compiler, a lowel byte code into a high level language.Java decompiler will help you decompile a byte code file so that you can see the java code.
Steps in installing JADClipse(An eclipse plugin for decompiling)
1. Create a folder parallel to the eclipse installation named “JAD”, place the “jad.exe” file inside the folder.
2. Run the “jad.exe”.
3. Copy the jar file to the plugins folder in eclipse.(“jadclipse_3.2.2.jar”)
4. Restart your eclipse.
5.Go to window –>preferences–>Java–>jadeclipse. (Check the Picture below)

6.Set the “Path to Decompiler” as your “jad.exe” location.
7.Set the “Directory for temperary files “ as “D\.jadeclipse”
8. Restart eclipse once more to use JAD.

The decompiler will come handy when you are moving back and forth through ATG Out of the Box components. If JAD is there OOTB components and can be read and understood easily. Click ToDownload JAD Utility.

ATG Tag Library:DSP Tags

Lloyd — Tue, 29 Jun 2010 19:00:36 +0000

There are many ATG Out Of The Box(OOTB) droplets to cater the various needs in developing an application.Droplet’s main use in a jsp page is to dispay the contents dynamically. The OOTBox components are used in JSP with the help of DSP tags. DSP is a tag library provided by ATG, it acts as layer above the JSP tags. The DSP tag library lets you access all data types in ATG’s Nucleus framework. Other functions provided by these tags are managing transactions and rendering data in a Java Server Page. Tags from the DSP tag library are used only for tasks that involve Dynamo Application Framework (DAF) resources.

In the API documentation of ATG the class hierarchy is: atg.nucleus.GenericService —> atg.servlet.DynamoServlet. And the classes for sample droplets “Switch” and “ForEach” droplets are “atg.droplet.Switch” and “atg.droplet.ForEach” respectively. Before using the DSP tags in a page, it must be imported in the beginning of the page.

<%@ taglib uri=”/dspTaglib” prefix=”dsp”%>

DSP PAGE tag:
The dsp:page surrounds the content body of the JSP. It is required to use this tag as such whenever your pages include DSP tags.”dsp:page” tag initiates the page rendering process by creating an instance of the “DynamoHTTPServletRequest”. This tag is preceded only by the page directives and import statements.
["content of the page.It can be any dsp or jsp or html tags"]

DSP IMPORTBEAN tag:
dsp:importbean can import a servlet or java bean component into a JSP.It is usually given at the top of the page so that it facilitates reference to all other elements.The tag has 3 attributes BEAN,VAR and SCOPE, of which bean is a compulsory attribute and can’t be omitted.The bean attribute accepts a fully qualified nucleuspath and name of the servlet bean that we want to import. The VAR attribute names an EL variable so that it can be used by other tags in the page. If SCOPE is not mentioned a default page is used.SCOPE determines where the servlet bean specified by VAR is stored and who all can access it.PAGE,REQUEST,SESSION & APPLICATION are the various options available. Now a small eg: will serve a better understanding.
Sample Code:

Here the Switch, RequestLocale and Redirect droplets are imported to the page. The RequestLocale component is imported to a VAR attribute so that the dsp:setvalue and dsp:param tags can access RequestLocale with EL. EL is enumerated language so it requires the EL tag libraries as well(JSTL).*

* Not going into the details of JSTL as it will divert from the aim of this article, which is just to provide an understanding of the main DSP tags and attributes.

Ideal Production Environment for an e-commerce site

Sam — Mon, 07 Jun 2010 08:32:40 +0000

A production setup is normally an alien environment to normal developers. On top of the e-commerce site setup locally, a few patch ups needs to be done to work in the production environment or rather there are large differences. Before going into the details of a production scenario a few important things needs to be brought into your attention; Content Administration (CA), Search Indexer, and electronic Store front. CA is Content or data related thing, the ATG CA lets the product data and other data flow into our website. The need of a CA in a retail website is due the frequent change of data and the changes are to be done by the business itself not a database administrator. Search module of the website is clubbed to CA because it is also a portion which needs frequent business intervention. The search administration and merchandising modules are kept as part of the CA ear in a seperate server(Server1). The search indexer which does the indexing is kept in another server(Server-2), this server will have the indexing engine(ATGSearch.exe) in it. The index files generated will be put into a folder which is accessible to the answer servers as well. An answer server(AS-1,2,3) is a server which caters to the requests coming from the front end or the consumer side. For eg: a customer enter the webaddress, visits the website, he want to buy a TV, he searches for it, the search requests will be routed to different answer servers for load balancing. This is done through a routing module. The answer servers will look into the index files which is deployed in the shared folder.

The Search Indexer does all the indexing jobs create the .IDX and .STG files. The estore servers(Server-3 & 4) caters the store related requests. Each of the estore servers has many number of instances to handle large number of customer requests.

Droplet & A Repository Query

Sam — Wed, 19 May 2010 10:08:45 +0000

How to write a droplet??
How to execute a SELECT query in ATG repository??

A droplet is an ATG concept which is implemented with the help of java. We can say a droplet is complete when the java class and a properties file of the java class are combined. The scope of a droplet is always global. The droplet class extends DynamoServlet. It is same as that of a servlet class in java and it contains a service( ) method also. The two parameters of the service method are of type DynamoHttpServletRequest and DynamoHttpServletResponse. And it throws ServletException and IOException.
Following the previous example of an Employee table (refer), here also we are using the same itemDescriptor (employeeItemDescriptor) and same repository xml, for sake of clarity. Here the droplet is used to get the list of all employees (same names should not get repeated) and display it in dropdown list. A simple select query(select * from employeeTB) is used instead of using (select distinct EName from employeeTB). So the example will address both questions.

Three key parts while addressing the questions are,
1. JSP file where the employee names (EName) are displayed.
2. The droplet class or the java class (employeeNamesDroplet.java).
3. The corresponding properties file of the class (employeeNamesDroplet.properties)

1.JSP File(test.jsp)



<%@ taglib uri="/dspTaglib" prefix="dsp"%>
<%@ taglib uri="/dspCoreTaglib" prefix="core"%>





 Sample Page 


<%-- page content --%>

	 Employee Name 

   
    Select
    <%--Our droplet --%>
	
        	  
     <%--ATG OUT OF THE BOX DROPLET --%>
      	
        	 
	 
 
	 
	 
<%--eid, employeename are property values from SampleRepositoryXML file --%>

2.“employeeNamesDroplet”

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import javax.servlet.ServletException;
import atg.repository.Query;
import atg.repository.Repository;
import atg.repository.RepositoryException;
import atg.repository.RepositoryItem;
import atg.repository.RepositoryView;
import atg.servlet.DynamoHttpServletRequest;
import atg.servlet.DynamoHttpServletResponse;
import atg.servlet.DynamoServlet;

public class employeeNamesDroplet extends DynamoServlet
{
private static final String OUTPUT = "output";
private static final String EMPTY = "empty";
private static final String E_NAMES="enameslist";
private Repository repository;
private String ItemDescriptor;

public void service(DynamoHttpServletRequest DHSRequest,DynamoHttpServletResponse DHSResponse) throws ServletException, IOException
{
   List eNamesList = getNames();
   if (eNamesList.size() > 0)
  {
       	DHSRequest.setParameter(E_NAMES, eNamesList);
         	DHSRequest.serviceParameter(OUTPUT,DHSRequest,DHSResponse);
   } else {
	DHSRequest.serviceParameter(EMPTY,DHSRequest,DHSResponse);
	}
}

private List getNames(){
  List tempNames = new ArrayList();
  List eNames = new ArrayList();
  if(getRepository() != null){
	RepositoryView rView;
	Query query;
	try{
	rView = getRepository().getView(“employeeItemDescriptor”);
	query = (Query) rView.getQueryBuilder().createUnconstrainedQuery();
	RepositoryItem[] rItems = rView.executeQuery(query);
   for(int ri=0; ri < rItems.length; )
   {if(tempNames.contains((String)(rItems[ri].getPropertyValue("employeename")))= = false)
    { tempNames.add((String)(rItems[ri].getPropertyValue("employeename")));
      eNames.add((RepositoryItem)rItems[ri]);
      ri++;
    }else{
 ri++;}
   	 }
}
catch(RepositoryException re)
{
System.out.print(“..”+re);
}
catch(Exception ex)
{System.out.print(“..”+ex);
}
}
return (List)eNames;
}// end of getnames method

public Repository getRepository() {
return repository;
}
public void setRepository(Repository repository) {
this.repository = repository;
}

}// end of the class

3.Properties File of the Droplet(“employeeNamesDroplet.properties”)
$class=droplet. employeeNamesDroplet
$scope=global
Repository = Give the name of your repository here.

ATG SearchAdmin UI & How Indexing is done?

Sam — Tue, 11 May 2010 13:47:11 +0000

What I intend to share in this article is a familiarity towards the admin UI screens of the ATGsearch.This article will give you an idea on how search indexing is done, not the code but the front end working in the search application.This will give you a fair idea on what the search guy should do get the products indexed once the coding part is over.Or simply configuring the search project. Figure one shows the BCC(Business control center) which is configured by adding certain UIs in the ATGSearch module.
Figure 2 shows the “Search Administration” tab with 4 different options.Search Project administration,New Search Project,Browse Search Projects,Open Search Workbench.Each of these will take you to different options for creating a search project or edit already created ones. Figure 3 and its sub shows how to create a project. Figure 4 shows a project you created and under the name of your project there are 4 steps, of which the last 3 are essential parts of configuring a search project. Content means adding or giving location of the file from which the indexing starts.It is normally “ProductCatalogOutputConfig.properties“. Environment tab will help you set up an environment for indexing, which tells where should the search engine run,in local setup your computer name is given. Indexing tab does the indexing job.

Picture looks a bit blurred in the site but if you save it to your machine the claritty is better,regret the inconveniance.Also the pictures are numbered

[View with PicLens]

ATG Search Architecture

Sam — Thu, 06 May 2010 10:29:26 +0000

Objective of the article: is to give a better understanding to a person who is new to this technology.This article will give the reader a walk through on what s/he is going to do and s/he will see once the ATG Search installation is done and also how the entire Search structure pieces fit in.

ATG search runs with a standard platform installation.Search requires high performance, so it is better dedicating a seperate machine for the search purposes.

Components of Search
Search Administration:
Is the interface where we create projects, index the data, add content,setting auto indexing rules,deploy indexes etc.We should have only one instance of search administartion in our installation.The SearchAdmin.AdminUI module is required to run the search administration.

Search Engine:
It serves answers to queries generated by end users.Our installation can have any number of search engines.But make sure only one engine runs per processor.ATG docs say a single search engine can take upto 1.4GB of memory.The “DAF.Search.Routing” module starts the Search engines locally or remotely.It co-ordinates the communication between client application, the search database and the answer servers(search engines).

Search Database:
Consists of two repositories, one consists of information of search engine,index structure and deployment information.The other repository stores information about users and the search administration. Search engine, administration and routing should have access to the “shared deployment directory“. This directory is the place where the master copy of index files are stored. Search engine and routing should have access to directory in order to deploy the indexes.

How to install ATG Search

Sam — Tue, 20 Apr 2010 13:23:43 +0000

For installing and using ATG Search, we need to get ATG licenced install files from ATG, which include a set of EXE files a few JAR files which contains the patches and latest updates. When you have all the necessary files you can start the job. The very first thing you need to install is the

1.ATG2007_1.exe
2.ATG-Merchandising2007_1.exe
3.ATGSearch2007_1-Windows.exe

With these three files the basic installation is over, now a set of patches need to be installed.
ATG2007_1_p1: This is usually supplied as a JAR file.Open th JAR file using winzip or some similar application.You will find a readme file which will tell you perfectly, how to do the installation and uninstallation of the patches. Incase the readme is not there here are the steps:
1. Shut down ATG 2007.1. If SOLID is running, you must also shut down SOLID before installing the patch. You must also shut down any HTTP servers you may have running.
2. Download/copy the ATG2007_1_p1.jar file to your patch directory.
3. From the command prompt, unjar the patch archive file using the command: ” jar xvf ATG2007_1_p1.jar “. This command creates a directory named ATG2007.1_p1 that contains the patch files.
4. Change to the newly created directory. WARNING: Do not modify or delete files in the patch directory(/patch/ATG2007.1_p1) at any time. Modifying or deleting these files will prevent subsequent installation or uninstallation of patch files.
5. Run the install script using the following command:
On Windows: bin\install.bat
On UNIX: bin/install.sh
The script will install and update several files in your ATG 2007.1 installation.

ATG2007_1_p2 : The step involved in installing this patch is same as that of the above.

Now a few search specific hotfixes are there; which are to be installed inside the Search Directory. Make a folder named hotfix inside the Search2007.1 directory. Unjar the jar file named pr147589_tld. There are two hotfixes mainly and steps for installation are explained below.

Hotfix jsp
(1) Backup folder {DYNAMO_HOME}\Search2007.1\SearchAdmin\AdminUI\j2ee-apps\AdminUI.ear\AdminUI.war
(2) Unjar the pr147589_jsp.jar file into the {DYNAMO_HOME}\Search2007.1\SearchAdmin\AdminUI\j2ee-apps\AdminUI.ear\AdminUI.war
directory to extract the modified jsp files.

Hotfix tld
1. Create a hotfix directory and place pr147589_tld.jar into it (e.g., /hotfix/pr147589_tld.jar).
2.Copy {DYNAMO_HOME}\Search2007.1\SearchAdmin\AdminUI\j2ee-apps\AdminUI.ear\AdminUI.war\WEB-INF\lib\searchadminui1_0.jar into the directory created in (1)
3.Unjar the pr147589_tld.jar into the directory created in (1)
4.Run the command: jar umf META-INF/MANIFEST.MF searchadminui1_0.jar atg/searchadmin/adminui/taglib/ui/elwrap/PagingTagWrapper.class atg/searchadmin/adminui/taglib/ui/PagingTag.class META-INF/searchadminui1_0.tld META-INF/searchadminuiEL1_0.tld
5.Copy the updated file searchadminui1_0.jar back to {DYNAMO_HOME}\Search2007.1\SearchAdmin\AdminUI\j2ee-apps\AdminUI.ear\AdminUI.war\WEB-INF\lib
Note: assuming that the AdminUI.war was backed up in (I-1)

The Evolution Of Java

Dileep — Sun, 18 Apr 2010 00:36:28 +0000

Smalltalk, the first object-oriented language, had a major influence on the design of Java.
Key founders – James Gosling, Patrick Naughton, Chris Warth, Ed Frank, & Frank Sheridan.
Was initially called Oak. Got renamed Java in 1995.

Design Goals

Was originally meant to be a platform-neutral language for embedded-software in devices.
The goal was to move away from platform and OS-specific compilers.
The language could be used to produce platform-neutral code.

Role of WWW

The World Wide Web played a catalytic role in the evolution of Java.
The emergence of the WWW propelled the rise of Java because the WWW demanded portability.
The scope of the language therefore widened from embedded controllers to the Internet.

Java made the Internet host of dynamic self-executing programs.
Applets are dynamic self-executing programs that Java made possible.
It can react to user input, and dynamically change the content of Web pages in which they are embedded.

The Java Architecture

Bytecode is the key to both security and portability.
Write source code.
Compile to bytecode contained in .class files.
Bytecode is a highly optimized set of instructions.
Bytecode is executed by the Java Virtual Machine(JVM).
The JVM is an interpreter for bytecode.

Java Virtual Machine – JVM

The JVM will differ from platform to platform, and is, platform-specific.
All versions of JVM interpret the same Java bytecode.Interpreted code runs much slower compared to executable code.
The use of bytecode enables Java runtime system to execute programs much faster.
Java facilitates on-the-fly compilation of bytecode into native code.
When a program is interpreted, it generally runs substantially slower than it would run if compiled to executable code. However, with Java, the difference between the two is not so great. The use of bytecodes makes this possible.

The Adaptive Optimizer

Another type of execution engine is the adaptive optimizer.
Identifies the most heavily used areas of code, and optimizes these.
The rest of the code, which is not heavily used, remain as bytecodes which the virtual machine continue to interpret.

The Class Loader

The class loader is that part of the VM that is important from a security standpoint, and for network mobility.
The class loader loads a compiled Java source file(.class files represented as bytecode) into the Java Virtual Machine(JVM).
The bootstrap class loader loads classes, including the classes of the Java API, in some default way from the local disk.
Bootstrap class loader – also called primordial class loader or default class loader.

The Java .class file – The Java class file helps make Java suitable for networks mainly in the areas of – platform independence and network mobility.

The Java language allows you to write programs that take advantage of many software technologies – object-orientation, multithreading, structured error-handling, garbage collection, dynamic linking, dynamic extension.

The Java Buzzwords

Simple – Small language, large libraries. Small interpreter(40 k), but large runtime libraries(175 k).
Object-Oriented – Supports encapsulation, inheritance, abstraction, and polymorphism.
Distributed – Libraries for network programming. Remote Method Invocation.
Architecture neutral – Java bytecodes are interpreted by the JVM.
Secure – Difficult to break Java security mechanisms. Java Bytecode verification. Signed Applets.
Portable – Primitive data type sizes and their arithmetic behavior specified by the language. Libraries define portable interfaces.
Mutithreaded – Threads are easy to create and use.
Dynamic – Finding Runtime Type Information is easy.

Functions

Functions are the building blocks of a Java program.
main() is the first function to be executed.
return_type function_name(argument list)
Prototyping required but variable name is not necessary.

public class Hello {
public statis void main(String [] args) {
System.out.println(”Hello World”);
}
}

Compilation – javac Hello.java
Execution – java Hello

A static member of a class is independent of instances of the class, and a static method can therefore be invoked without creating an object of the class.
The main() is declared as public to ensure it’s visibility outside it’s class, i.e, to the Java Runtime Environment.

Data Types

Integer – int, long, short, byte
Character – char, String
Floating Point – float, double
Boolean

A variable is an item of data named by an identifier.
Scope- The section of code where the variable’s simple name can be used is the variable’s scope.
The Java programming language has two categories of data types – primitive and reference. A variable of primitive type contains a value.

Java is a strongly typed language.
The Java compiler enforces type checking of each assignment made in a program at compile time.
If the type checking fails, then a compile-time error is issued.

Strong typing facilitates two functions of the same name to coexist.
A function signature constitutes the function name, the number, order and the data type of the arguments.
Such functions are said to be overloaded.

The final keyword – Mechanism of telling the compiler that a piece of data is “constant”.

ATG Search: A few key things to note

Sam — Thu, 08 Apr 2010 12:18:52 +0000

While answering the question, what is a commerce search?? the key concepts one must explain is the difference of a normal keyword search and a commerce search.ATG Search will help you in setting up a commerce search in your website. Implementing a Commerce Search on your site involves the following steps:
1. Specify repository items and attributes to index through an XML file.
2. Based on the information in the XML file, the repository items are transformed into XHTML documents.
3. These XHTML documents are indexed by ATG Search.
4. Using search forms in your website(form handlers that communicate with ATG Search), visitors can search through these indexed documents.

There are a couple of formhandlers which are out of the box components and are used to build forms for issuing queries to the ATG Search.These formhandlers are provided inside the package “atg.search.query.formhandlers“.

QueryFormHandler
StructuredQueryFormHandler
BrowseFormHandler
ViewInContextFormHandler
SimilarDocsFormHandler
CategorizeFormHandler

All the above form handlers extends from an abstract class “BaseSearchFormHandler“.Another important class is a “SearchContext” class which is a session scoped component for maintaining state information between requests.