Thursday, October 3, 2013

Create a Google App Engine project that uses Spring + using Maven to create + Eclipse as IDE


I did not find any tutorial to create a maven project that uses Google App Engine and Spring and use Eclipse IDE.  So, I thought I would document what I had done recently to create a Spring MVC project using Maven and deploys to Google App Engine; using Eclipse as IDE.

I am assuming you have Eclipse plugin for Maven (m2e) installed to Eclipse.

Creation of project:
We need to use maven plugin to create a new Google App Engine project.  I used instructions to create using command line from here.  I am sure we can use Eclipse maven project creation wizard as well.

Adding Spring dependencies:
To add Spring dependencies, add dependencies.


  <!-- Spring Dependencies -->  
           <dependency>   
                <groupId>org.springframework</groupId>   
                <artifactId>spring-core</artifactId>   
                <version>${spring.version}</version>   
           </dependency>   
           <dependency>   
                <groupId>org.springframework</groupId>   
                <artifactId>spring-context</artifactId>   
                <version>${spring.version}</version>   
           </dependency>   
           <dependency>   
                <groupId>org.springframework</groupId>   
                <artifactId>spring-beans</artifactId>   
                <version>${spring.version}</version>   
           </dependency>   
           <!-- Spring MVC framework -->   
           <dependency>   
                <groupId>org.springframework</groupId>   
                <artifactId>spring-webmvc</artifactId>   
                <version>${spring.version}</version>   
           </dependency>   
           <dependency>   
                <groupId>org.springframework</groupId>   
                <artifactId>spring-web</artifactId>   
                <version>${spring.version}</version>   
           </dependency>   


Tips:

  • Till Spring 2.5.6, the framework used to provide a single all-encompassing dependency.  From Spring 3.0.x on wards, that is not the case.  So, we will have to include every dependency in pom.xml file.
  • It is important to have same version for all Spring dependencies.  If Spring dependencies don't have the same version, it gives out an error:

 [INFO] java.lang.NoSuchFieldError: APPLICATION_CONTEXT_ID_PREFIX  
 [INFO] at org.springframework.web.servlet.FrameworkServlet.createWebApplicationContext(FrameworkServlet.java:430)  
 [INFO] at org.springframework.web.servlet.FrameworkServlet.createWebApplicationContext(FrameworkServlet.java:458)  
 [INFO] at org.springframework.web.servlet.FrameworkServlet.initWebApplicationContext(FrameworkServlet.java:339)  

  • Dependencies can be checked using this command: mvn dependency:tree
  • When I was iterating through these steps multiple times, I found some old dependencies lingering around. If that happens, this command would clear things up: mvn clean


Create web.xml:
If web.xml has not been created already, create it under ${project}/src/main/webapp/WEB-INF

Add DispatcherServlet to web.xml:
This is a standard Spring stuff you would do in any Spring MVC project.  (I created MVC project, so I did this.  It may or may not done in other cases)  Also, depending on the name given to DispatcherServlet in web.xml, create <dispatcher-servlet-name>-servlet.xml xml file.

Deploying this application now will not work.  Here are some steps I took to get rid of the errors:

  1. First, we need to clean up the maven project.  Right click project -> Run As -> maven clean.
  2. Right click project -> Properties -> Project Facet -> Select "Dynamic Web Project".
  3. Again, Right click project -> Properties -> Deployment Assembly -> Add -> In popup, "Java Build Path Entries" -> Maven Dependencies -> Finish.  All this does is to copy dependency jar to .../WEB-INF/lib.
Hopefully, this helps someone create a project without any errors.
Thanks to these links:

http://stackoverflow.com/a/12600686/1700184
http://stackoverflow.com/a/6083776/1700184
https://developers.google.com/appengine/docs/java/tools/maven#creating_a_new_maven_app_engine_project_using_skeleton-archetype

Tuesday, October 1, 2013

pom.xml for Google App Engine + Spring

I am working on a new project that uses GAE (Google App Engine) and Spring.

I faced a few errors while trying to run the project - all related to incorrect configuration in pom.xml

Some of the problems I faced are:

  • [ERROR] Failed to execute goal net.kindleit:maven-gae-plugin:0.8.0:run (default-cli) on project XYZ: ${gae.home} is not a directory: ${gae.home} is not a directory:[ERROR] Please set the sdkDir configuration in your pom.xml to a valid directory. Make sure you have correctly extracted the app engine sdk.
  • [ERROR] Failed to execute goal net.kindleit:maven-gae-plugin:0.8.0:run (default-cli) on project XYZ: Execution default-cli of goal net.kindleit:maven-gae-plugin:0.8.0:run failed: Plugin net.kindleit:maven-gae-plugin:0.8.0 or one of its dependencies could not be resolved: Could not transfer artifact com.google.appengine:appengine-tools-sdk:jar:1.4.0 from/to central (http://repo.maven.apache.org/maven2): No response received after 60000 -> [Help 1]





 <?xml version="1.0"?>  
 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">  
  <modelVersion>4.0.0</modelVersion>  
  <groupId>xx.xx.xx</groupId>  
  <artifactId>XYZ</artifactId>  
  <packaging>war</packaging>  
  <version>0.0.1</version>  
  <name>XYZ Webapp</name>  
  <url>http://maven.apache.org</url>  
       <dependencies>  
      <!-- Spring framework -->  
      <dependency>  
           <groupId>org.springframework</groupId>  
                <artifactId>spring</artifactId>  
                <version>2.5.6</version>  
           </dependency>  
           <dependency>   
                <groupId>org.springframework</groupId>   
                <artifactId>spring-core</artifactId>   
                <version>${spring.version}</version>   
           </dependency>   
           <dependency>   
                <groupId>org.springframework</groupId>   
                <artifactId>spring-context</artifactId>   
                <version>${spring.version}</version>   
           </dependency>   
           <dependency>   
                <groupId>org.springframework</groupId>   
                <artifactId>spring-beans</artifactId>   
                <version>${spring.version}</version>   
           </dependency>   
           <!-- Spring MVC framework -->   
           <dependency>   
                <groupId>org.springframework</groupId>   
                <artifactId>spring-webmvc</artifactId>   
                <version>${spring.version}</version>   
           </dependency>   
           <dependency>   
                <groupId>org.springframework</groupId>   
                <artifactId>spring-web</artifactId>   
                <version>${spring.version}</version>   
           </dependency>   
           <!-- Apache Commons Upload -->   
           <dependency>   
                <groupId>commons-fileupload</groupId>   
                <artifactId>commons-fileupload</artifactId>   
                <version>1.2.2</version>   
           </dependency>   
           <!-- Apache Commons Upload -->   
           <dependency>   
                <groupId>commons-io</groupId>   
                <artifactId>commons-io</artifactId>   
                <version>1.3.2</version>   
           </dependency>   
            <!-- JSTL -->   
           <dependency>   
                <groupId>javax.servlet</groupId>   
                <artifactId>jstl</artifactId>   
                <version>1.1.2</version>   
           </dependency>   
            <dependency>   
                <groupId>taglibs</groupId>   
                <artifactId>standard</artifactId>   
                <version>1.1.2</version>   
           </dependency>  
           <dependency>  
                <groupId>com.google.appengine</groupId>  
                <artifactId>appengine-tools-sdk</artifactId>  
                <version>1.8.0</version>  
           </dependency>  
           <dependency>  
                <groupId>com.google.appengine</groupId>  
                <artifactId>appengine-api-1.0-sdk</artifactId>  
                <version>1.8.0</version>  
           </dependency>  
           <dependency>  
       <groupId>net.kindleit</groupId>  
       <artifactId>gae-runtime</artifactId>  
       <version>${gae}</version>  
       <type>pom</type>  
     </dependency>  
      </dependencies>  
      <build>   
      <finalName>SpringFileUpload</finalName>   
           <plugins>   
                <plugin>   
                     <groupId>org.apache.tomcat.maven</groupId>   
                     <artifactId>tomcat7-maven-plugin</artifactId>   
                     <version>2.1</version>   
                     <configuration>   
                          <url>http://localhost:8080/manager/text</url>   
                          <server>my-tomcat</server>   
                          <path>/SpringFileUpload</path>   
                     </configuration>   
                </plugin>   
                <plugin>   
                     <groupId>org.apache.maven.plugins</groupId>   
                     <artifactId>maven-compiler-plugin</artifactId>   
                     <version>3.0</version>   
                     <configuration>   
                          <source>${jdk.version}</source>   
                          <target>${jdk.version}</target>   
                     </configuration>   
                </plugin>  
                <plugin>  
                     <groupId>net.kindleit</groupId>  
                     <artifactId>maven-gae-plugin</artifactId>  
                     <version>0.8.0</version>  
                     <configuration>  
                          <unpackVersion>1.8.0</unpackVersion>  
                          <gae.home>C:\Users\koushik\.m2\repository\com\google\appengine\appengine-java-sdk\1.8.0\appengine-java-sdk-1.8.0</gae.home>  
                     </configuration>  
                </plugin>  
           </plugins>   
      </build>  
      <profiles>  
        <profile>  
          <id>repositories</id>  
                <repositories>  
                     <repository>  
                          <id>maven-gae-plugin-repo</id>  
                          <name>maven-gae-plugin repository</name>  
                          <url>http://maven-gae-plugin.googlecode.com/svn/repository</url>  
                     </repository>  
                </repositories>  
                <pluginRepositories>  
                     <pluginRepository>  
                          <id>maven-gae-plugin-repo</id>  
                          <name>maven-gae-plugin repository</name>  
                          <url>http://maven-gae-plugin.googlecode.com/svn/repository</url>  
                     </pluginRepository>  
                </pluginRepositories>  
                <properties>  
                     <gae.home>C:\Users\koushik\.m2\repository\com\google\appengine\appengine-java-sdk\1.8.0\appengine-java-sdk-1.8.0</gae.home>  
                </properties>  
        </profile>  
      </profiles>  
      <properties>  
           <spring.version>3.0.5.RELEASE</spring.version>  
           <jdk.version>1.5</jdk.version>  
           <gae.home>C:\Users\koushik\.m2\repository\com\google\appengine\appengine-java-sdk\1.8.0\appengine-java-sdk-1.8.0</gae.home>  
           <gae>1.4.0</gae>  
      </properties>  
 </project>  

Thursday, September 26, 2013

A Quick tip on Data Structure for DFS/BFS

Breadth-First Search and Depth-First Search are two very common graph traversal algorithms for any Graph.

There are two ways of representing graph - Adjacency Matrix and Adjacency Lists.  Well, this link gives more ways of representing a Graph.  But, let us not get into that.

Both DFS and BFS requires us to iterate over the children of a node.  This will be done for almost all nodes.

  • Iterating through all children is O(n) in Adjacency Matrix.
  • It is O(branches) in Adjacency Lists.

In a sparsely connected Graph, O(branches) is much smaller than O(n).  So, if we need to do a DFS, we should always choose Adjacency Lists over Adjacency Matrix.

Tuesday, September 24, 2013

Create an Android Activity as a popup

For the most of your popup needs, Android's Dialog should be good enough.  To popup some message, use AlertDialog.  Always use AlertDialog.Builder to build a new AlertDialog.  If you need a custom set of controls in the main message, use AndroidDialog.Builder's setView() method to set appropriate layout.

Now, if we need to popup a special kind of Activity that a Dialog cannnot solve, we can still do that.  But using Activity as a popup has a few problems.  In this post, I would like to discuss some of the approaches that I had taken to solve the problems.

How to disable back button in Android

Android phones come with a back button to go to previous activity.



http://docs.xamarin.com/static/guides/android/application_fundamentals/activity_lifecycle/Images/image4.png


There can be workflows where you may not want to go to previous Activity unless certain action is completed.  Sometimes, the current workflow may be in unstable state.  Sometimes, going back may not make any sense in the workflow.

The simple way to avoid using back button is to implement

onBackPressed() event in the activity.

If you are using a old version of Android, you may have to override onKeyDown.

public boolean onKeyDown(int keyCode, KeyEvent event)

Just check for (keyCode == KeyEvent.KEYCODE_BACK).

-----

This leads to another button that may close the Application - the Home button.  Home button takes you to Android device home.  Should that be overridden too?

It is unwise to override Home button.  Instead of trying to handle Home button's press, the Application's workflow should be designed to handle Home button is press during its execution. Here is a www.stackoverflow.com discussion on this topic.

Happy coding

Find the longest shortest-path between any two points in a graph

Given a graph, G, with edges E with weights W and vertices V.  You will have a path between two connected vertices.  Of the multiple paths between two vertices there should be one of the path that has the minimum weight.  Take the shortest path between every two points and return the one that has the maximum value.

This is a classic case of Floyd-Warshall algorithm.  The algorithm finds the shortest path between every two vertices in a graph.  We can use this to find all distances and then finally, find the maximum path.

Floyd-Warshall algorithm takes every pair of vertices in a graph and computes the distance of path through a third vertex.  This gives shortest path between any two vertices.  The complexity of the algorithm is O(|V|3)

A more efficient solution: We can calculate the path from a vertex V1 such that it is shortest path between V1 and one of the vertex and is longer than shortest path between any other vertex.  See this post for an algorithm.  Then, we can iterate through every vertex and find the longest path with every vertex as the root.  Once we have the list of all longest shortest-path, we can find the one that has the max value and return it.


find maxDepthInGraph(G)
{
  V <- G.vertices()
  E <- G.edges()

  for every vertex v in V:
    depth[v]=do breadth-first-search(v) and get the longest-  shortest-path

  maxDepth = -1
  for every vertex v in V:
    if maxDepth < depth[v]:
      maxDepth = depth[v]

  return maxDepth
}

Sunday, September 22, 2013

Find the longest route from a vertex to any other vertex in a graph

Given a graph, G, with vertices, V, and edges, E, and V1 is one of the vertices in the graph, find the path in G such that it is the shortest path between V1 and a vertex and the path is greater than the shortest path between V1 and any other vertex in the graph.


For example, take this graph



In this graph, given V1 = node 4; the path that should result is 4 -> 1 -> 3 -> 5.  The reason is that, the path 4-1-3-5 is the shortest path between 5 and 4 and it is the path that is longer than shortest paths between node 4 and any every other vertices.

Solution: We need to do a Breadth-First Search.

1) Take V1 as the root node.  Then take all its children in a queue.

2) Do this till there is no more nodes in the queue:
2.a) If the children has been processed before, ignore it.
2.b) Otherwise, if the depth is the highest yet found, note down the path and depth for next iteration.
3) When all nodes are processed, return the highest yet depth and path.