Setting up the project in Eclipse

1. First, you will need to set up the GAE plugin for Eclipse.  Google provides easy instructions for this here.  At the time of this posting, the current version of the SDK should be 1.3.1.
2. Create a new project in your Eclipse workspace of type Google Web Application Project
   

   The poject type is under the "Google" folder

   

   Enter the project settings

   You should now have a project with the following setup:

   

   Inital project structure

   The project is now set up, you can run the server by clicking the “Debug” button in Eclipse and visiting localhost:8888 in your browser.

3. Before we start setting up Spring, let’s clean out some of the things in the project we won’t need.  You can delete the GAESpringProjectServlet.java file and change the file war/WEB-INF/web.xml to:

   <?xml version="1.0" encoding="utf-8"?>
   
   <web-app xmlns="http://java.sun.com/xml/ns/javaee" version="2.5">
   
   </web-app>

4. Now that the project is clean we can add in the libraries needed by the Spring framework. Download Spring from the springsource website.  You will also need commons-logging.jar and xalan.jar.  We don’t need to worry about the JSTL jars because GAE includes them for you. Add the following into the war/WEB-INF/lib folder for your project and add them to the build path (the file names have the version information left off, it should be “-3.0.0.RELEASE” for the spring jars):
   1. org.springframework.asm.jar
   2. org.springframework.beans.jar
   3. org.springframework.context.jar
   4. org.springframework.core.jar
   5. org.springframework.expression.jar
   6. org.springframework.web.servlet.jar
   7. org.springframework.web.jar
   8. commons-logging.jar
   9. xalan.jar
5. Now it’s time to set up the configuration files for Spring.  First war/WEB-INF/web.xml:

   <?xml version="1.0" encoding="utf-8"?>
   
   <web-app xmlns="http://java.sun.com/xml/ns/javaee" version="2.5">
   
   	<servlet>
   		<servlet-name>dispatcher</servlet-name>
   		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
   		<load-on-startup>1</load-on-startup>
   	</servlet>
   
   	<servlet-mapping>
   		<servlet-name>dispatcher</servlet-name>
   		<url-pattern>/a/*</url-pattern>
   	</servlet-mapping>
   
   </web-app>

   The dispatcher servlet handles all user requests and passes them along to the correct controller. The url mapping is to anything under the /a/ directory because of a bug with GAE.  The development server will not accept the url pattern of /* so in development you must add a prefix.  You can remove the /a before you deploy to a production GAE instance.

6. Now create the file war/WEB-INF/dispatcher-servlet.xml and add the contents:

   <?xml version="1.0" encoding="UTF-8"?>
   <beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
   
    <context:component-scan base-package="com.acrhodes.gaespringproject.controllers" />
   
    <bean id="viewResolver"
    class="org.springframework.web.servlet.view.InternalResourceViewResolver"
    p:prefix="/WEB-INF/views/" p:suffix=".jsp" >
    <property name="viewClass" value="org.springframework.web.servlet.view.JstlView" />
    </bean>
   
   </beans>

   This sets several things up for us.  First, the context:component-scan tag tell spring to search the “com.acrhodes.gaespringproject.controllers” package for classes marked with the @Controller annotation so that we don’t have to set them up explicitly in the xml.  The viewResolver bean sets up our views to use JSTL and to return the jsp /WEB-INF/views/home/home.jsp when the view name “home/home” is given.

7. Our final configuration file will tell Spring that we are using annotations to manage all of the bean mapping.  Add the file war/WEB-INF/applicationContext.xml with the contents:

   <?xml version="1.0" encoding="UTF-8"?>
   <beans xmlns="http://www.springframework.org/schema/beans"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xmlns:context="http://www.springframework.org/schema/context"
   xsi:schemaLocation="http://www.springframework.org/schema/beans
   
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
   
   http://www.springframework.org/schema/context
   
   http://www.springframework.org/schema/context/spring-context-3.0.xsd">
   
   <context:annotation-config/>
   
   </beans>

8. Now we are ready to start developing our application.  Create a new package “com.acrhodes.gaespringapplication.controllers” that will house all of the controller classes and create a new HelloController class in it.  HelloController will be a simple login/logout service using the Google User Service.  Add the following code to the class:

   @Controller
   @RequestMapping("/hello")
   public class HelloController {
   
       private UserService userService = UserServiceFactory.getUserService();
   
       @RequestMapping(method = RequestMethod.GET)
       public String hello(HttpServletRequest request, ModelMap model)
       {
           String url = request.getRequestURI();
           String message;
   
           if(request.getUserPrincipal() != null)
           {
               message = new StringBuilder()
               .append("Hello, ")
               .append(request.getUserPrincipal().getName())
               .append("! You can <a href=\"")
               .append(userService.createLogoutURL(url))
               .append("\">Sign Out</a>.").toString();
           }else{
               message = new StringBuilder()
               .append("Please ")
               .append("<a href=\"")
               .append(userService.createLoginURL(url))
               .append("\">Sign In</a>.").toString();
           }
   
           model.addAttribute("message", message);
   
           return "hello/hello";
       }
   
   }

   The class accepts any request of the pattern /a/hello/* and any request using the GET method will call the hello() method.  Spring allows for controller methods to be very flexible.  hello() takes in the request object (to use to check if the user is logged in) and a model object to return data to the view.  The message created is added to the model map and the name of the view is returned (remember “hello/hello” maps to /WEB-INF/views/hello/hello).

9. Finally, we are going to set up the “hello/hello” view.  First, we will set up an includes page that sets up the taglibs we will use.  Create the file war/WEB-INF/views/common/includes.jsp with the contents:

   <%@ page session="false"%>
   <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
   <%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>

   Next,we’ll set up the actual view.  Create the file war/WEB-INF/views/hello/hello.jsp with the contents:

   <%@ page contentType="text/html;charset=UTF-8" language="java" %>
   <%@page isELIgnored="false" %>
   <%@ include file="/WEB-INF/views/common/includes.jsp" %>
   
   <p>${message}</p>
   

   The first line of the jsp sets the contentType and the language of the page.  The next line is needed if you plan to use EL expressions (i.e. ${bean.name}).  Be sure you put isELIgnored, not isElIgnored like the will it play page for GAE has it listed, this took me several hours to figure out. The third line includes the taglibs from the last file we set up.  The final line displays the message attribute that was added to the model in the controller.

You should now be able to click “Debug” and run the application by visiting “localhost:8888/a/hello”.  Next up, I’m going to be adding a tutorial on integrating JDO for GAE’s Datastore into Spring.  If you have any questions or problems with the tutorial, feel free to comment.  I’ll try to get back to them as soon as I can.

References:

• Adent Lord’s Spring 3.0 GAE article: http://www.ardentlord.com/apps/blog/show/829881-spring-3-0-on-google-app-engine
• GAE Documentation: http://code.google.com/appengine/docs/java/gettingstarted/
• Spring 3.0 Documentation: http://static.springsource.org/spring/docs/3.0.x/spring-framework-reference/html/
• Spring MVC 2.5 Tutorial: http://static.springsource.org/docs/Spring-MVC-step-by-step/

The class doesn’t support JSON arrays yet, and has no error reporting, but I plan to keep developing it, as I would like to have a working library for the Chronism project.  At some point I would also like to extend the functionality to encode a map into JSON as well.

If your interested in the project, I’m releasing it under LGPL and it’s being hosted here.  I’d really appriciate any feedback!

Solution: The best solution I’ve found for this is to use a custom classloader task, to load the JSch classes before you need the SCP task. JTools’ Classloader task works great for this.  Simply include the JSch library with they libraries for your other custom ant tasks, then in the build file set the SCP task like this:

<taskdef resource="net/jtools/classloadertask/antlib.xml"
        classpathref="${classpath}"/>
<classloader loader="project" classpath="${internal.lib.dir}/js*.jar"/>
<scp file="myfile.txt" todir="user:password@somehost:/home/chuck"/>

This can save those trying to deploy your application a lot of grief for very little overhead.

So in my last post I talked about my new project idea to start working on a programming portfolio.  Well the site is going to be a social time tracking application called Chronism.  I’ve gone ahead and bought the domain, and I’m starting to work on some of the basic branding like this fancy logo, and a simple site design.  The reaon I’m not jumping into the coding first is that I’ve got a few days left at my summer internship, and quite frankly I need a diversion that is not Java.  Also, design work is definitely something I could use some practice on.

What I want the point of the application to be, is to encourage users to take ownership of what they are spending their time on, and in doing so, focusing more of their energy on creative pursuit.  The complaints I here about Twitter of the Facebook news feed, is that people generally do not care what you are doing most of the time, but I think most of the people you know will have an interest in what you are working on… what you are making.  To that end, I think a major feature of the site, behind time tracking, should be tie-ins to best of breed services like Flikr, Viemo, and Deviant Art as well as an open api to easily integrate with other services.

If your a student in the Atlanta area and your interested in working on the project, I’d love to take on partners interested in figuring out how to pull a web application together.  Stay tuned for more information about the progress of the site.

The application will be Java based, using the Spring Framework, Hibernate for ORM and either JSP or Velocity for the view formatting, all running in Tomcat.  I want to focus on scalability, security, and solid software practices while getting something up and running as quickly as possible.  I’ve decided to use Java because the product I am working on at work uses a similar architecture, and I would like to understand a Tomcat application from the ground up.

I’ll have more to come soon on my plans for the first two weeks of the project and hopefully a catchy name with a snazzy web 2.0 logo.

I found one of their blog posts to be really interesting, mainly because I attend a stand-up meeting every morning at work, and I would have never thought it to be a trendy project management process unless I had started looking into agile development.  Basically, the idea behind a stand up meeting is for your team to meet every morning in a circle and have everyone answer three questions in about a minute: what you did yesterday, what you are planning to do today, what (if any) roadblocks you are facing.  I’ve been attending meetings like this for about 10 minutes every morning for about a month and a half now.  At first, I realized that the meetings were helping to keep the team in sync and could make sure no one was doing duplicate work, but I never really thought much more about how these meetings work for the team (more than it makes sure where all at work by 9:30).

As time goes on, I’ve realized that these meetings also serve as a powerful motivational tool for a team.  I’ve found that I now make sure I stay productive throughout the day to make sure I have something interesting to say each morning.  I now keep a running list of what I’m doing and make to-do lists each morning.  Now, I have even started consciously allotting myself a certain amount of time for certain tasks to make sure that I am not letting other ones fall through the cracks.  Overall, I’ve been really surprised how those 10 minutes in the morning affects how I work through the rest of the day.

This leaves me wondering what practices I can employ to hold myself accountable to my plan for developing my portfolio over the next year, as I will be working on my own.  I’m debating on holding myself to a scrum like schedule and turning out new features every two weeks, or if there is some better way to handle this.  I’ll let you know as I go along.

I’ve been very happy so far with Rackspace.  They are very affordable for having full control of a virtual server and very easy to use.  I litterally had my own Ubuntu instance up and running within 5 minutes, and wordpress up and running another 10 minutes after that.  I’m really looking forward to be able to work on Tomcat, Ruby, and PHP projects all with the same host and with real console access instead of having to use an asinine web front end to administer my site.

Another reason I’m really looking forward to using Rackspace, is that they charge by the hour.  This means that if I want to spin up a server for development or testing, I can do it without having to pay for a full month’s use.    The one thing that did suprise me though, is that you do not stop getting charged when you shut down your severs.  You actually have to delete the server from their web interface.  Rackspace gives a perfectly resonable answer for this in their knowledge base, but it would have been nice if this was made more clear right from the beginning.  They are still cheaper than Amazon’s cloud computing solution, however, and they seem to be easier to use, so I have no complaints.

After four great years in college at Georgia Tech, I’m left with one year before I graduate to prepare myself for the workforce and beyond.  With this being about the worst time in 50 years to be looking for a job, I’ve decided to make a year long project out of preparing a portfolio to show off my skills and to learn as much as I can in the process.  In addition, I’m aiming to use this blog, and the projects I will work on to begin to make a name for myself and ideally make a little money on the side.  To this end, this is my plan for the fist half of the year:

First three months (June – September):

• Begin writing blog posts about what I am learning over the summer, specifically things others might find interesting or helpful.
• Complete one major web-based programming project.
• Finish reading Code Complete by Steve McConnell.
• Monetize this blog and make enough to cover my bandwidth costs for this site (~$1 a month).

Second three months (September – December):

• Learn a new programming language, possibly Ruby.
• Complete another programming project.
• Begin to get involved with an open source project and at least one local professional organization, on campus or elsewhere.
• Increase revenue from the site to cover total hosting costs (~$12 a month)

I’ll obviously be refining this plan as I go along, but I think this gives me plenty to start with.  Feel free to follow along, and give me feedback as I work on this.  I’d love ideas for projects as well!