Objective

This post will show you how to use Spring JDBC Template to perform real world CRUD operations. I hope I can show you that you do not need overweight Hibernate to interact with database of your choice.

The Problem Domain

Almost all application I have coded needed to store and get data of some sort. In most cases it was relational database. With hibernate being all the rage these days I have used it in multiple projects with varying degree of problems and success. In my personal opinion hibernate tries to solve a problem that really is not there. If you can not wire SQL you should not be using Hibernate or be doing any software development.

I advise the use of Spring JDBC templates. In essence Spring JDBC Template will offload all the mundane steps of database access from you shoulders only requiring you to write SQL and move data from result set into your model objects. Here is how Spring documentation describes responsibilities:

CRUD Example with Spring JDBC Template

For this example you will need spring-core, spring-tx and spring-aop components. We will use spring-tx to manage the transaction so we can get back the auto generated IDs of the persisted objects and aop to set up the transaction management. Here is meat for spring configuration file:

<bean id="propertyPlaceholder" 
      class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer" >
  <property name="location" value="/WEB-INF/config.properties" />
</bean>

<bean id="mysqlDataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" 
      destroy-method="close">
  <property name="driverClass" value="com.mysql.jdbc.Driver"/>
  <property name="jdbcUrl" value="${database.url}"/>
  <property name="user" value="${database.user}"/>
  <property name="password" value="${database.password}"/>
  <property name="initialPoolSize" value="${database.connections.start}"/>
  <property name="maxPoolSize" value="${database.connections.max}"/>  
  <property name="idleConnectionTestPeriod" value="270" />
</bean>

<bean id="txManager" 
      class="org.springframework.jdbc.datasource.DataSourceTransactionManager" >
  <property name="dataSource" ref="mysqlDataSource" />
</bean>

<tx:advice id="txAdvice" transaction-manager="txManager">
  <tx:attributes>
    <!-- all methods starting with 'get' are read-only -->
    <tx:method name="get*" read-only="true"/>
    <tx:method name="list*" read-only="true"/>
      <!-- other methods use the default transaction settings (see below) -->
      <tx:method name="*"/>
    </tx:attributes>
</tx:advice>

<aop:config>
  <aop:pointcut id="uOwnerDataSvcOperation" 
      expression="execution(* com.es.rto.dao.UOwnerDataServiceImpl.*(..))"/>
  <aop:advisor advice-ref="txAdvice" pointcut-ref="uOwnerDataSvcOperation"/>
</aop:config>

<bean id="namedTemplate" 
    class="org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate">
  <constructor-arg index="0" ref="mysqlDataSource"/>   
</bean>

<bean id="qandADao" class="com.es.rto.dao.QandADao" >
  <property name="jdbcTemplate" ref="namedTemplate" />
</bean>

<bean id="uOwnerDataSvc" class="com.es.rto.dao.UOwnerDataServiceImpl" >
  <property name="qandADao" ref="qandADao" />
</bean>

First thing we do we load our config.properties file where we have database configuration defined. Second we define a pooled data source to connect to mysql database. Third bean is a transaction manager that is watching our data source from the step two. Next we set up our transaction manager. We instruct transaction manager that methods starting with “get” and “list” are read only. This means that they will not be subject to transaction management. Then we define named jdbc template and pass in the data source as first constructor argument and then pass in the template into our own DAO bean.

Why do we need Transaction Management?

When we create a new row in a mysql table with autoincrement id value we need a way to get that auto generated id. To do so we need to query the database using same connection. When we use jdbcTemplate.update() or jdbcTemplate.query() it will check out a connection form the pool execute the query, process the results and return this connection to the pool. So if we do update() and then get() to query “SELECT LAST_INSERT_ID()” we will get another connection, which is a problem since we need to do this on the same connection to get the right id. This is where the transaction comes in. Instead of releasing connection back to the pool spring will hold on to it until we are done with it.

Java code side of the Spring JDBC template

We will use 3 beans to illustrate the scenario: question, answer and user.

public class Question {
        private long questionId;
        private long categoryId;
        private long userId;
        private long areaId;
        private String question;
        private String verifyKey;
        private Date created;
        private User user;
        private List<Answer> answers;
        private long answerCount;
        private String name;
        // getters and setters omited...
}

public class Answer {
        private long answerId;
        private long questionId;
        private long userId;
        private String answer;
        private String verifyKey;
        private String url;
        private Date created;
        private User user;
        private String name;
        // getters and setters omited...
}

public class User implements Serializable {
        private long id;
        private String email;
        private String retypeE;
        private String name;
        private String password;
        private String password2;
        private String verifyKey;
        private boolean buyer;
        private boolean seller;
        private boolean active;
        private boolean privacy;
        private int pageSize = 20;
        private String next;
        private boolean administrator;
        // getters and setters omited...
}

Here are the 2 classes that do all the work:

public class QandADao {

  private final Logger logger = Logger.getLogger(QandADao.class);
  protected NamedParameterJdbcTemplate jdbcTemplate = null;
  

  @SuppressWarnings("unchecked")
  public List<Question> getQuestions( String search, int page, int step ) {
    try {
      MapSqlParameterSource params = new MapSqlParameterSource( "search", "%"+search+"%" );
      String sql = "SELECT q.*, count( a.answer_id ) as answers, u.name, u.seller  FROM users u, questions q LEFT JOIN answers a "+
      "ON  a.question_id = q.question_id WHERE a.answer LIKE :search AND q.user_id = u.id "+
      "GROUP BY q.question_id, q.category_id, q.user_id, q.question, q.created, q.area_id, u.name, u.seller "+  
      "UNION "+
      "SELECT q.*, count( a.answer_id ) as answers, u.name, u.seller  FROM users u, questions q LEFT JOIN answers a "+ 
      "ON  a.question_id = q.question_id WHERE q.question LIKE :search AND q.user_id = u.id "+
      "GROUP BY q.question_id, q.category_id, q.user_id, q.question, q.created, q.area_id, u.name, u.seller "+
      "LIMIT "+(step*(page-1))+", "+step;
      logger.debug( sql );
      return jdbcTemplate.query(sql, params, new RowMappers.QuestionsMapper());
    } catch ( DataAccessException exc ) {
      logger.error("FAILED to get Question List", exc);
      return new ArrayList<Question>();
    }
  }

  public Question saveQuestion( Question question ) {
    try {
      BeanPropertySqlParameterSource namedParameters = new BeanPropertySqlParameterSource(question);
      String sql;
      if( question.getQuestionId() == 0 )
        sql = "INSERT INTO questions ( category_id, user_id, question, area_id, uname ) VALUES ( :categoryId, :userId, :question, :areaId, :name )";
      else
        sql = "UPDATE questions SET question=:question, category_id=:categoryId, area_id=:areaId WHERE question_id=:questionId";
      logger.debug( sql );
      jdbcTemplate.update(sql, namedParameters);
      if( question.getQuestionId() == 0 )
        question.setQuestionId( this.getInsertedID() );
        
    } catch ( DataAccessException exc ) {
      logger.error("SAVE answer FAILED!", exc);
      throw exc;
    }
    return question;
  }

  protected long getInsertedID() {
    return jdbcTemplate.queryForLong( "SELECT LAST_INSERT_ID()" , new MapSqlParameterSource());
  }
  
}

public class RowMappers {

  public static final class QuestionMapper implements RowMapper {
      public Object mapRow(ResultSet rs, int rowNum) throws SQLException {
        Question q = new Question();
        q.setQuestionId(rs.getLong( "question_id" ));
        q.setCategoryId(rs.getLong( "category_id" ));
        q.setUserId(rs.getLong( "user_id" ));
        q.setAreaId( rs.getLong("area_id"));
        q.setQuestion( rs.getString("question"));
        q.setCreated( rs.getTimestamp( "created" ) );
        q.setName( rs.getString("uname") );
        User u = new User();
        u.setName( rs.getString("name") );
        u.setSeller( rs.getBoolean("seller") );
        u.setId(q.getUserId());
        q.setUser(u);
      return q;
    }
  } 
}

So what is going on here? Lets look at the QuestionMapper. It implements one method – mapRow. Its hob is to process a single row of the result set. As you see here we create a Question bean and a User bean which is included in the Questions bean. It can not be more strait forward then this.

QandADao is the class where all the magic happens. First lets examine the getQuestions() method. First we define query parameter(s) using MapSqlParameterSource class. We simply put the values in the map and jdbc template will pull them out by the key. Next we write our sql query. In this case iti is pretty complex to pull out any questions where either question or the answer have the thing we are searching for. We use union to be able to pull out the questions without the answers. Lastly we call query method on the jdbc template and we pass in our query, parameters and the row mapper instance. Spring takes care of all the plumbing. What we get out of this call is a list of Question objects.

saveQuestion() method is not much different. In this case we use BeanPropertySqlParameterSource which maps bean properties to sql parameters. If you define a sql parameter “name” your bean should have “getName()” method. Instead of calling query() we call update() on the jdbc template which only takes sql and the parameters.

Conclusion

You may have noticed that the effort to use the Spring approach to JDCB is very simple, flexible and powerful. You have all the control in all the right places! You write the sql with all the performance hints and tweaks, you write code how to transfer results to the domain objects the way you need it or like it. I only mentioned about one tenth of the options you have with spring. Read The Fine Manual (RTFM) to explore the full potential.

Spring JDBC Template – A leaner alternative to fat Hibernate is a post from: Wet Feet - Online Marketing and Technology Blog

Objective

This article will show you how to persist real world data in Google App Engine. You will learn how to handle inheritance and one-to-many owned relationships in your model objects and store them correctly in the big table implementation of JDO.

The Problem Domain

In my application I need to segregate data by the customer this data belongs to. We will use inheritance in model objects, so all of them will have customer id defined in the base class. We will make the JDO save base class properties in the sub class “table”. We will also learn how to instruct Google App Engine JDO to handle customers with multiple addresses and phone numbers for us. If we define the relationship between model objects correctly JDO will manage storing/retrieving/deleting of these lined objects without our involvement.

Inheritance in Model Classes

First let’s define a superclass for all our model classes:

package com.yourcorp.here;

import java.io.Serializable;

import javax.jdo.annotations.IdGeneratorStrategy;
import javax.jdo.annotations.IdentityType;
import javax.jdo.annotations.Inheritance;
import javax.jdo.annotations.InheritanceStrategy;
import javax.jdo.annotations.PersistenceCapable;
import javax.jdo.annotations.Persistent;
import javax.jdo.annotations.PrimaryKey;

@PersistenceCapable(identityType = IdentityType.APPLICATION, detachable="true")
@Inheritance(strategy=InheritanceStrategy.SUBCLASS_TABLE)
public class ModelBase implements Serializable{

    @PrimaryKey
    @Persistent(valueStrategy = IdGeneratorStrategy.IDENTITY)
    private Long id;
    @Persistent
    protected Long customerId;

    private static final long serialVersionUID = 3039288063578312662L;

    // getters & setters go here
}

What we done here is defined Model Base class that has two properties – ID and customerID and marked them as persistent. We also annotated that our class is persistence capable and defined Inheritance strategy. In this case we chose to use Subclass Table. What this means is that ID and customerID properties will be saved in the table of the class that inherits this one. You can read more about inheritance strategies here.

Now lets define our User class:

package com.yourcorp.here;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;

import javax.jdo.annotations.IdentityType;
import javax.jdo.annotations.PersistenceCapable;
import javax.jdo.annotations.Persistent;

@PersistenceCapable(identityType = IdentityType.APPLICATION, detachable="true")
public class User extends ModelBase implements Serializable {

    @Persistent
    private String email;
    @Persistent
    private String name;
    @Persistent
    private String password;

    private static final long serialVersionUID = 3039288063578312662L;

    // getters & setters go here
}

When you persist an instance of this User class in the big table it will have id, customerId, email, name and password properties in the single user “table”.

One-to-many relationships in Google App Engine JDO

For this example lets define a customer class that has a list on phone and address objects:

package com.yourcorp.here;

import java.util.ArrayList;
import java.util.List;

import javax.jdo.annotations.IdentityType;
import javax.jdo.annotations.PersistenceCapable;
import javax.jdo.annotations.Persistent;
import javax.jdo.annotations.Element;

@PersistenceCapable(identityType = IdentityType.APPLICATION, detachable="true")
public class Customer extends ModelBase {

    @Persistent
    private String name;
    @Persistent
    private String contactName;
    @Persistent
    private String comments;

    @Persistent(mappedBy = "customer")
    @Element(dependent = "true")
    private List<Address> adresses = new ArrayList<Address>();

    @Persistent(mappedBy = "customer")
    @Element(dependent = "true")
    private List phones = new ArrayList();

    private static final long serialVersionUID = 3039288063578312662L;

    // getters &amp; setters go here
}

As you can tell we have defined two lists and annotated them to be persistent. (mappedBy = “customer”) defines this relationship as “owned” – meaning the customer property of the Address and Phone object will hold the reference tho this customer object.
And here is an example of the address object:

package com.yourcorp.here;

import javax.jdo.annotations.IdentityType;
import javax.jdo.annotations.PersistenceCapable;
import javax.jdo.annotations.Persistent;

@PersistenceCapable(identityType = IdentityType.APPLICATION, detachable="true")
public class Address extends EntityBase {

    @PrimaryKey
    @Persistent(valueStrategy = IdGeneratorStrategy.IDENTITY)
    private Key id;
    @Persistent
    private String type;
    @Persistent
    private String name;
    @Persistent
    private String line1;
    @Persistent
    private String line2;
    @Persistent
    private String city;
    @Persistent
    private String state;
    @Persistent
    private String zip;
    @Persistent
    private Customer customer;

    private static final long serialVersionUID = 3039288063578312662L;

    // getters & setters go here
}

You may also notice @Element(dependent = “true”) which means that when the customer object is deleted JDO will delete these child objects for you automatically.

Conclusion

JDO simplifies your life when you need to store and retrieve data if you know how to define all these relationships correctly. Compare the effort required to store and retrieve the same object from your favorite relational database, without using the monster called hibernate……

Google App Engine + JAVA + JDO + Inheritance + One-To-Many Relationships is a post from: Wet Feet - Online Marketing and Technology Blog

Objective

We are talking REST+JSON from browser to the server and back, so we need to report errors nicely. Exception thrown on the server have to be converted to error messages and transmitted to the client in JSON format. Luckily there is a very elegant solution for this in Spring.

HandlerExceptionResolver interface

Spring provides a very handy HandlerExceptionResolver interface for mapping exceptions to views. If you check the documentation (and you should) you will notice that where are couple exception handlers already implemented, but we will create our own. Just because we can.

Implementing JsonExceptionResolver

Our implementation is very basic, but can be enhanced to return more data about where the exception occurred, etc. To implement HandlerExceptionResolver interface we need to provide one method:

package com.lureto.rjf;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.web.servlet.HandlerExceptionResolver;
import org.springframework.web.servlet.ModelAndView;

public class JsonExceptionResolver implements HandlerExceptionResolver {

        @Override
        public ModelAndView resolveException(HttpServletRequest request, HttpServletResponse response,
                                                 Object handler, Exception exception ) {
                ModelAndView mav = new ModelAndView();
                mav.setViewName("MappingJacksonJsonView");
                mav.addObject("error", exception.getMessage() );
                return mav;
        }

}

resolveException method returns ModelAndView, to which we add a model object “error” holding the message from the exception, and set the view name. The view in this case is MappingJacksonJsonView. Setting error to the exception message comes in handy when we need to return an error from lets say “saveUser” action – we simply throw exception from the controller method like this: throw new Exception(“USER_EMAIL_NOT_UNIQUE”);

Next we need to hook in our exception resolver into Spring context like this:

<bean class="org.springframework.web.servlet.view.ContentNegotiatingViewResolver">
  <property name="mediaTypes">
    <map>
      <entry key="json" value="application/json" />
    </map>
  </property>
  <property name="defaultContentType" value="application/json" />
  <property name="defaultViews">
    <list>
      <bean name="MappingJacksonJsonView"
        class="org.springframework.web.servlet.view.json.MappingJacksonJsonView" />
    </list>
  </property>
</bean>
   
<bean id="exceptionResolver" class="com.lureto.rjf.JsonExceptionResolver" />

We simply define the bean and name call it exceptionResolver. Spring detects implemented interface and automagicaly routes exceptions to this resolver. We needed to modify our view definition – we gave it name, so we can reference it in the code – “MappingJacksonJsonView”.

Conclusion

Trapping exceptions on the server and converting them to JSON error messages can be done with 4 lines of conde and 1 line of xml. You can use this approach to map all sorts of exceptions to custom error jsp pages, JSON errors or any other view type. Your application users do not have to see an ugly Tomcat 500 error page.

Google App Engine + JAVA + Spring + REST + Mapping Exceptions to Errors for JSON is a post from: Wet Feet - Online Marketing and Technology Blog

Objective

After reading this post you will be able to implement robust user authentication and authorization scheme without replicating code to check if user is logged in and if the are authorized to perform a certain action.

The Problem Domain

You, like me, face the same problem with each web application – user authentication and authorization. Who is logged in? Can they delete this entity? Can they see this report? How to solve this problem without copy pasting same piece of code to every servlet/action/controller/whatever? If you are using spring MVC there is a very elegant and powerful solution – Interceptors.

You can have as many interceptors as you like, I usually have one for security and maybe one more for some other task. Interceptor fires before your controller/action gets invoked. If it returns true the flow can continue, if it returns false the execution stops right there – request has been handled by the interceptor.

Step One – Adding an interceptor to our application form part 1

First lets code our interceptor. I named it SessionInerceptor.

package com.lureto.rjf;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;

public class SessionInterceptor extends HandlerInterceptorAdapter {

    public boolean preHandle( HttpServletRequest request, HttpServletResponse response, Object handler) 
                                     throws Exception {
        User user = (User)request.getSession().getAttribute( Constants.SESSION_USER );
        String uri = request.getRequestURI();
        String base = request.getContextPath();
        uri = uri.substring( base.length() );
        if( user == null && !uri.startsWith("/api/login") ) {
                request.getSession().invalidate();
                response.setContentType("application/json");
            response.getWriter().write("{\"error\":\"SESSION-EXPIRED\"}");
            return false;
        }
        return true;
    }
        
}

As you see we are extending HandlerInterceptorAdapter class by implementing preHandle() method. If you need you can use postHandle() to perfor some action after the main handler has finished work. My implementation for this example is pretty simple – check only if the user is present in the session. If no user is present and user is not trying to log in, send back an error. In pure web application you probably would want to send a redirect to the login page.

Now lets add this interceptor to the Spring MVC stack by adding these 5 lines to our rest-json-flex-servlet.xml file.

<bean class="org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping">
        <property name="interceptors">
                <bean class="com.lureto.rjf.SessionInterceptor"/>
        </property>
</bean>

One more thing – we need to enable session in google app engine. Add this line to your appengine-web.xml

<sessions-enabled>true</sessions-enabled>

Step 2 – Implement Login Controller

Now we have our SessionInterceptor stopping us from accessing the services, we need to ad the way to log in. My inplementation of LoginController:

package com.lureto.rjf;

import java.io.IOException;
import java.util.List;

import javax.jdo.PersistenceManager;
import javax.jdo.Query;
import javax.servlet.http.HttpServletRequest;

import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

@Controller
@RequestMapping("/login")
public class LoginController {

        private static Logger logger = Logger.getLogger( LoginController.class );
        
        @Autowired
        private PMF pmf;
        
        @SuppressWarnings("unchecked")
        @ModelAttribute("user")
        @RequestMapping(value = "/", method = RequestMethod.POST)
        public User login( @RequestBody User user, HttpServletRequest request ) throws IOException {
                logger.debug(user);
                
                // Hardcoded for demo website
                if( user.getName().equalsIgnoreCase("user1") && user.getPassword().equals("password1") ) {
                        user.setId(1001);
                        user.setEmail("fake@email.com");
                        request.getSession(true).setAttribute( Constants.SESSION_USER , user);
                        return user;
                }
                
        PersistenceManager pm = pmf.getManager();

                Query query = pm.newQuery("select from com.lureto.rjf.User " +
                                "where password == passwordParam && name == nameParam " +
                                "parameters String passwordParam, String nameParam");
                
                List<User> users;
                try {
                        users = (List<User>) query.execute( user.getPassword(), user.getName() );
                        if( users.size() > 0 ) {
                                User luser = users.get(0);
                                request.getSession(true).setAttribute( Constants.SESSION_USER , luser);
                                return luser;
                        }
                } finally {
                        query.closeAll();
                }

        return null;
        }
        
        public PMF getPmf() {
                return pmf;
        }

        public void setPmf(PMF pmf) {
                this.pmf = pmf;
        }
        
}

What happens here is very strait forward: we construct a query to the big table to find a user matching supplied name and password. If we find one, we create a session and put our user object there. Our SessionInterceptor expects to find this user there once we try access /api/user/ endpoints.
Since Spring is scanning this package and we are using annotation, we do not need to add this controller to the xml file.

Step 4 – Enhance existing User bean to support permissions

Here is my User.java

@PersistenceCapable(identityType = IdentityType.APPLICATION, detachable="true")
public class User {

    @PrimaryKey
    @Persistent(valueStrategy = IdGeneratorStrategy.IDENTITY)
        private Long id;
    @Persistent
    private String email;
    @Persistent
    private String name;
    @Persistent
    private String password;
    @Persistent
    private List<String> permissions;
        
    public User() {
        permissions = new ArrayList<String>();
    }
    
    // getters and setters here
}

Step 5 – Add Login Screen to Flex application

This is how the finished screen looks like, once you log in, you end up in this screen.

Full source code for JsonRestClient.mxml.

Step 6 – User Authorization Implementation

As you see from all the work we have done to this point we are not checking for user permissions. I intentional left it out. The best solution will depend on your particular application. In this case, we need to come up with the permission convention first. I would probably use “action-uri” convention. So to be able to get the user list you need to have “GET-user” permission, to update it would be “POST-user”, etc. You may come up with something better for your situation.

Conclusion

Interceptors in Spring is the perfect way of moving user authentication and authorization code form controllers into centralized place. This makes your controllers cleaner. You already know that the right user with right permissions is performing this action.

Source Code for Java part can be found Here.

Demo application can be found here. (check the LoginController in Step 2 to figure out the user + password to log in )

Leave me a comment what permission checking convention you would use.

Best of Luck!
Tomas

Goolge app engine + java + spring + REST + JSON + Flex – Part 3 is a post from: Wet Feet - Online Marketing and Technology Blog

Objective

Once you are finished with this article, you will be able to store application data in Google App Engine Data store and consume REST service using flex client.

Common Problems and Solutions

In my personal opinion flash player security model is the biggest piece of bullshit I ever encountered. If you sit down and thing just for 10 seconds about how it is implemented you will have to agree that it provides NO security at all. It just makes impossible so do certain things, that’s all. Adobe needs to drop it now.

Here is the problem that we have with REST and Google app engine: Adobe’s implementation of HTTPService only supports GET and POST, to consume REST we need at least 3 methods: GET, POST and DELETE. We can live without PUT – if id is null JDO will create a new persisted object, if it is set JDO will update it. But we still do not have support for DELETE.

If you are implementing Air Application there are good news: as3httpclientlib – a socket implementation of http client that can do all that we need: HEAD, GET, POST, PUT, DELETE. It depends on as3corelib and as3crypto, so grab those too.

If you are implementing a web application in google app engine, you are out of luck with as3httpclientlib. The reason is that adobe has this perverted understanding about security: since as3httpclientlib utilizes the Socket to implement http client adobe flash player tries to “protect” the server that socket is trying to connect by sending
“<policy-file-request/>” to the 843 port to get a scoket policy file, it that fails it tries the port the socket is trying to connect to. Since this is not a http request, google app engine ignores it, and you can not create sockets in google app engine – they are not supported, so you can not write a simple class to send back what flash player wants. The conclusion: Adobe Flex has not yet made it to Web 2.0, it can not talk REST to the server. But there are workarounds and here is mine:

Step one – Add persistence management code to the project we created in part 1

First we need to modify our User.java class to support persistence:

import javax.jdo.annotations.IdGeneratorStrategy;
import javax.jdo.annotations.IdentityType;
import javax.jdo.annotations.PersistenceCapable;
import javax.jdo.annotations.Persistent;
import javax.jdo.annotations.PrimaryKey;

@PersistenceCapable(identityType = IdentityType.APPLICATION, detachable="true")
public class User {

    @PrimaryKey
    @Persistent(valueStrategy = IdGeneratorStrategy.IDENTITY)
    private Long id;
    @Persistent
    private String email;
    @Persistent
    private String name;

    // Getter and setters go here......
}

As you can see we have instructed JDO that we will store User objects at application level, added a primary key and its generation strategy and annotated members to be persisted.

Next we need to get hold of a persistence manager factory, since it is a very very costly operation, we wan to do it only once in the lifetime of our application. For this purpose lets create a singleton which will hold this instance for us:

package com.lureto.rjf;

import javax.jdo.JDOHelper;
import javax.jdo.PersistenceManager;
import javax.jdo.PersistenceManagerFactory;

public class PMF {

    private static final PersistenceManagerFactory pmfInstance = 
JDOHelper.getPersistenceManagerFactory("transactions-optional");

    private PMF() {}

    public static PersistenceManager getManager() {
        return pmfInstance.getPersistenceManager();
    }

    public static PersistenceManagerFactory get() {
        return pmfInstance;
    }

}

The last step is to modify our UserContrller.java to actually store and retrieve the User objects from the data store.

package com.lureto.rjf;

import java.io.IOException;
import java.util.List;

import javax.jdo.PersistenceManager;
import javax.jdo.Query;

import org.apache.log4j.Logger;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

@Controller
@RequestMapping("/user")
public class UserController {

        private static Logger logger = Logger.getLogger( UserController.class );

        @SuppressWarnings("unchecked")
        @ModelAttribute("users")
        @RequestMapping(value = "/", method = RequestMethod.GET)
        public List listUsers() throws IOException {
                PersistenceManager pm = PMF.getManager();
                Query query = pm.newQuery(User.class);
                List users;
                try {
                        users = (List) query.execute();
                } finally {
                        query.closeAll();
                }
                return users;
        }

        @ModelAttribute("user")
        @RequestMapping(value = "/", method = RequestMethod.POST)
        public User saveUser( @RequestBody User user ) throws IOException {
                logger.debug(user);
                PersistenceManager pm = PMF.getManager();
                try {
                    pm.makePersistent(user);
                } finally {
                    pm.close();
                }
                return user;
        }

        @RequestMapping(value = "/{userId}", method = RequestMethod.DELETE )
        public void deleteUser( @PathVariable String userId ) throws IOException {
                deleteUserIntenral(userId);
        }
        
        @RequestMapping(value = "/{userId}/delete", method = RequestMethod.POST )
        public void deleteUser2( @PathVariable String userId ) throws IOException {
                deleteUserIntenral(userId);
        }

        private void deleteUserIntenral( String userId ) throws IOException {
                logger.debug("Deleting user id > "+userId);
        PersistenceManager pm = PMF.getManager();
        try {
                Long id = Long.parseLong(userId);
                User user = pm.getObjectById( User.class, id ); 
            pm.deletePersistent(user);
        } finally {
            pm.close();
        }               
        }
}

As you can see from the code above, saving and getting a list of Users is pretty trivial coding task. You may also notice that we added deleteUser(@PathVariable String userId) method to delete the user when a delete request is made with user id added to the end of the path. To delete the user object first we need to fetch it from the data store and only then ask persistence manager to delete it. We hav two ways to delte the user – sending DELETE requests and sending POST to “/api/user/{userId}/delete”. The post method is there to get around the shortcomings of Actions Scrip 3.

And one last change we need to make to support not so mature flex – to add crossdomain.xml file to /war of our project so flash player security implementation stops throwing security exceptions. Like I said before this adds nothing to the security, but annoys the hell out of the developers. Here is the contents:

<?xml version="1.0"?><!DOCTYPE cross-domain-policySYSTEM 
            "http://www.macromedia.com/xml/dtds/cross-domain-policy.dtd">
<cross-domain-policy>
    <allow-access-from domain="*" to-ports="*"/>
    <allow-http-request-headers-from domain="*" headers="*"/>
</cross-domain-policy>

Step two- Create Flex project to consume the service we just upgraded

First create a Flex Web application project:

and then layout the UI to look like this:

And if you lazy like and want it all right now, here is the complete sudo code mxml file:

<?xml version="1.0" encoding="utf-8"?>
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml" 
      layout="absolute" creationComplete="init()">
  
  <mx:Script>
    <![CDATA[
      import mx.rpc.events.ResultEvent;
      import mx.rpc.events.FaultEvent;
      import mx.rpc.http.HTTPService;
      import mx.managers.PopUpManager;
      import json.JParser;
      import mx.controls.Alert;
      import mx.controls.List;
      
      [Bindable]
      private var users:Array;
      private var uriBase: String = "http://localhost:8080/api/user/";
      private var popupLabel:Label;

      private function init() : void {
        var myUrl : String = Application.application.url;
        if( myUrl.indexOf( "file://" ) != 0 ) 
          uriBase = myUrl.substring( 0, myUrl.lastIndexOf( "/" ) ) + "/api/user/" ;
        refreshUsers()      
      }
      
      private function addNew() : void {
        this.user_id.text = "";
        this.user_email.text = "";
        this.user_name.text = "";
      }

      private function updateEdit() : void {
        this.user_id.text =  this.usersList.selectedItem.id;
        this.user_name.text =  this.usersList.selectedItem.name;
        this.user_email.text =  this.usersList.selectedItem.email;
      }

      private function deleteUser() : void {
        
        if( usersList.selectedItem == null )
          return;
          
        showPopupWait();

        var service: HTTPService = new HTTPService();
        service.contentType = "application/json";
        service.method = "POST";
        service.resultFormat = "text";
        service.url = uriBase + usersList.selectedItem.id + "/delete" ;
        service.useProxy = false;

        service.addEventListener( FaultEvent.FAULT , function(event:FaultEvent):void {
                removePopup();
                Alert.show( event.message.toString() );
            } )      

        service.addEventListener( ResultEvent.RESULT , function(event:ResultEvent):void {
              refreshUsers();           
            } )      

        service.send();

      }
      
      private function saveUser() : void {
        showPopupWait();

        var service: HTTPService = new HTTPService();
        service.contentType = "application/json";
        service.method = "POST";
        service.resultFormat = "text";
        service.url = uriBase;
        service.useProxy = false;

        service.addEventListener( FaultEvent.FAULT , function(event:FaultEvent):void {
                removePopup();
                Alert.show( event.message.toString() );
            } )      

        service.addEventListener( ResultEvent.RESULT , function(event:ResultEvent):void {
              var response: Object = JParser.decode( event.message.body.toString() );
              user_id.text = response.user.id;
              refreshUsers();           
            } )      


        var user:Object = new Object();
        if( this.user_id.text.length > 0 )
          user.id = this.user_id.text
        user.name = this.user_name.text;
        user.email = this.user_email.text;
        
        var json:String = JParser.encode( user );
        var jsonData:ByteArray = new ByteArray();
        jsonData.writeUTFBytes(json);
        jsonData.position = 0;
        var contentType:String = "application/json";

        //client.post(uri, jsonData, contentType);
        
        service.send( jsonData );
      }

      private function refreshUsers() : void {
        showPopupWait();
        
        var service: HTTPService = new HTTPService();
        service.contentType = "application/json";
        service.method = "GET";
        service.resultFormat = "text";
        // add random number to make browser grab new list.... sux, but works.
        service.url = uriBase+"?"+ (new Date).getTime();
        service.useProxy = false;
        
        service.addEventListener( FaultEvent.FAULT , function(event:FaultEvent):void {
                removePopup();
                Alert.show( event.message.toString() );
            } )      

        service.addEventListener( ResultEvent.RESULT , function(event:ResultEvent):void {
              var userList: Object = JParser.decode( event.message.body.toString() );
              users = userList.users as Array ;
                removePopup();
            } )      
        
        service.send();        
      }

      public function showPopup( message:String ) : void {
        if( this.popupLabel == null ) {
          this.popupLabel = new Label();
          this.popupLabel.text =  message ;
          this.popupLabel.setStyle( "fontSize" , "22" );
          this.popupLabel.setStyle( "fontWeight" , "bold" );
          PopUpManager.addPopUp( this.popupLabel, this, true );
          PopUpManager.centerPopUp( this.popupLabel );
        }
      }
      public function showPopupWait() : void {
        this.showPopup( "Please wait.....");
      }
      public function removePopup() : void {
        if( this.popupLabel != null )
          PopUpManager.removePopUp( this.popupLabel );
        this.popupLabel = null;
      }

    ]]>
  </mx:Script>
  
  <mx:DataGrid x="10" y="35" id="usersList" dataProvider="{users}" 
       width="469" height="159" itemClick="updateEdit()">
    <mx:columns>
      <mx:DataGridColumn headerText="ID" dataField="id"/>
      <mx:DataGridColumn headerText="Email" dataField="email"/>
      <mx:DataGridColumn headerText="Name" dataField="name"/>
    </mx:columns>
  </mx:DataGrid>
  <mx:Label x="10" y="10" text="Users" fontSize="14" fontWeight="bold"/>
  <mx:Button x="487" y="59" label="Add New" click="addNew()"/>
  <mx:Button x="487" y="89" label="Delete" width="76" click="deleteUser()"/>
  <mx:Button x="487" y="119" label="Refresh" width="76" click="refreshUsers()"/>
  <mx:Form x="10" y="202" width="469">
    <mx:FormItem label="User ID">
      <mx:TextInput id="user_id" width="353" editable="false"/>
    </mx:FormItem>
    <mx:FormItem label="User Name">
      <mx:TextInput id="user_name" width="353"/>
    </mx:FormItem>
    <mx:FormItem label="User Email">
      <mx:TextInput id="user_email" width="353"/>
    </mx:FormItem>
    <mx:FormItem>
      <mx:Button label="Save" width="96" click="saveUser()"/>
    </mx:FormItem>
  </mx:Form>
  
</mx:Application>

To serialize objects to and from the server we need a JSON library. I chose JSwoof.swc – JSON serializer and parser. I found it to be a little better qauality then the one in as3corelib, but you can use either one.

Once you get the project compiling, start your google app engine project locally, mine is configured to listen on port 8080, and then you can run the flex project. For the lazy (like me) here is the full project all ready to go.

Conclusion

Adding persistence support in google app engine project is not hard, you just need to read documentation carefully.

The harder part is to get flex talking to these services. Like any closed source solution you are at mercy of company making it, like we see in this particular case. Unfortunately there are no better alternative to FLex for building nice looking af functional web application, we just need to deal with its shortcomings.

You can check out the working application at rest-json-flex.appspot.com

In step 3 we will add session management, user authentication and authorization to our google app engine REST application.

Goolge app engine + java + spring + REST + JSON + Flex – Part 2 is a post from: Wet Feet - Online Marketing and Technology Blog

Once you are finished with this article, you will be able to implement REST services in Google Apps Engine using JAVA, Spring 3.0 and JSON. In the next part you will learn how to add flex application to consume the services.

Step one – Getting all required libraries: Google App Engine SDK, Spring and JSON serializer

If you are using Eclipse (my favorite IDE), you can install google plugin from here. If you choose to go another route, you need to download the sdk, create the project and join us back in the next section. Once you install the plugin, restart eclipse and you can see these buttons

you can proceed to the next section.

Step Two – Create new project

Go to new project wizzard

and select Web application project under google. you should get to the project settings screen

choose your project name (can be anything, not necessarily you google application name) and you base package, click finish and you should see the following project structure:

Step Three – Add Spring Support

Go to springsource.org and download latest 3.0 release, unzip it into a folder where you keep your java libs. Copy the following Jars into war\WEB-INF\llib directory:

1. org.springframework.asm-3.0.x.jar
2. org.springframework.beans-3.0.x.jar
3. org.springframework.context-3.0.x.jar
4. org.springframework.core-3.0.x.jar
5. org.springframework.expression-3.0.x.jar
6. org.springframework.oxm-3.0.x.jar
7. org.springframework.web-3.0.x.jar
8. org.springframework.web.servlet-3.0.x.jar

Also grab your favorite version of log4j.jar and commons-logging-1.1.1.jar. The trick with the commons-logging is to rename it to something like commons-fix-logging-1.1.1.jar, google app engine replaces this jar with its own version with crippled packages, by providing different name we keep both versions and make spring happy. Once you copied the jars, open project preferences and add those jars to the build library path.

Now lets get to the fun part – configuring spring.

Lets get rid of the generated servlet – just delete it. And open web.xml. My generated one looks like this:

<?xml version="1.0" encoding="utf-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" version="2.5">
        <servlet>
                <servlet-name>Rest_json_flex</servlet-name>
                <servlet-class>com.lureto.rjf.Rest_json_flexServlet</servlet-class>
        </servlet>
        <servlet-mapping>
                <servlet-name>Rest_json_flex</servlet-name>
                <url-pattern>/rest_json_flex</url-pattern>
        </servlet-mapping>
        <welcome-file-list>
                <welcome-file>index.html</welcome-file>
        </welcome-file-list>
</web-app>

The final version should look like this:

<?xml version="1.0" encoding="utf-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" version="2.5">

        <context-param>
                <param-name>log4jConfigLocation</param-name>
                <param-value>/WEB-INF/log4j.properties</param-value>
        </context-param>
        <listener>
                <listener-class>org.springframework.web.util.Log4jConfigListener</listener-class>
        </listener>

    <servlet>
        <servlet-name>rest-json-flex</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <load-on-startup>1</load-on-startup>
    </servlet>

    <servlet-mapping>
        <servlet-name>rest-json-flex</servlet-name>
        <url-pattern>/api/*</url-pattern>
    </servlet-mapping>

        <welcome-file-list>
                <welcome-file>index.html</welcome-file>
        </welcome-file-list>
        
</web-app>

As you can see I have moved log4j.properties from src to WEB-INF location. I like all my config files in one place, you can leave it in src or move it somewhere else, just adjust the path accordingly.  Second section defines Spring dispatcher servlet, then we map this servlet to /api/* path. All requests with this pattern will get routed to spring dispathcer servlet.

Step Four – Add JSON support

I looked around for good java JSON library and found couple good candidates. Since Spring uses Jackson JSON I decided to go the same route. Grab the library from here and put jackson-core-1.2.1.jar and jackson-mapper-1.2.1.jar file into projects WEB-INF/lib directory. Choose your favorite license when you downloading the jars.

Step Five – Configure Spring

To configure Spring servlet we need to create servletname-servlet.xml file for spring bean configuration. Our file has to be named rest-json-flex-servlet.xml.

<?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-3.0.xsd
        http://www.springframework.org/schema/context 
        http://www.springframework.org/schema/context/spring-context-3.0.xsd">

    <context:component-scan base-package="com.lureto.rjf"/>
    
    <bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter">
        <property name="messageConverters">
                <list>
                        <ref bean="jsonHttpMessageConverter"/>
                </list>
        </property>
        </bean>

    <bean id="jsonHttpMessageConverter"  class="org.springframework.http.converter.json.MappingJacksonHttpMessageConverter" />

        <bean class="com.lureto.rjf.spring.MyContentNegotiatingViewResolver">
                <property name="mediaTypes">
                        <map>
                                <entry key="json" value="application/json" />
                        </map>
                </property>
                <property name="defaultContentType" value="application/json" />
                <property name="defaultViews">
                        <list>
                                <bean class="com.lureto.rjf.spring.JsonView" />
                        </list>
                </property>
        </bean>
        
</beans>

First we tell String to scan “com.lureto.rjf” package for any bean annotations.

<context:component-scan base-package="com.lureto.rjf"/>

Next we define message converter to convert messages sent to the server into beans using MappingJacksonHttpMessageConverter

<bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter">
        <property name="messageConverters">
                <list id="beanList">
                <ref bean="jsonHttpMessageConverter"/>
                </list>
        </property>
</bean>
<bean id="jsonHttpMessageConverter"  class="org.springframework.http.converter.json.MappingJacksonHttpMessageConverter" />

The last part tells spring to render messages sent from the server to the client using JsonView. Here we need to do some bug fixing, as you may have noticed the classes used are from “com.lureto.rjf.spring” and not from “org.springframework.web”.

<bean class="com.lureto.rjf.spring.MyContentNegotiatingViewResolver">
        <property name="mediaTypes">
                <map>
                        <entry key="json" value="application/json" />
                </map>
        </property>
        <property name="defaultContentType" value="application/json" />
        <property name="defaultViews">
                <list>
                        <bean class="com.lureto.rjf.spring.JsonView" />
                </list>
        </property>
</bean>

MyContentNegotiatingViewResolver.java – at the moment of writing this the 3.0.0.RC1 version of ContentNegotiatingViewResolver has bug with the list being singleton.

package com.lureto.rjf.spring;

import java.util.Arrays;
import java.util.List;

import javax.servlet.http.HttpServletRequest;

import org.springframework.http.MediaType;
import org.springframework.web.servlet.view.ContentNegotiatingViewResolver;

public class MyContentNegotiatingViewResolver extends ContentNegotiatingViewResolver {

        protected List<MediaType> getMediaTypes(HttpServletRequest request) { 
                List<MediaType> result = super.getMediaTypes(request); 
                if (result.size() == 1) 
                        result = Arrays.asList(result.get(0)); 
                return result; 
        }

        
}

JsonView.java – is a copy org.springframework.web.servlet.view.json.MappingJacksonJsonView with one change:

@Override
protected void renderMergedOutputModel(Map<String, Object> model,
                HttpServletRequest request,
                HttpServletResponse response) throws Exception {
        model = filterModel(model);
        JsonGenerator generator = objectMapper.getJsonFactory().createJsonGenerator(response.getWriter());
        if (prefixJson) {
                generator.writeRaw("{} && ");
        }
        objectMapper.writeValue(generator, model);
}

I had to change response.getOutputStream() to response.getWriter(), since jetty’s implementation of setting content type and encoding uses writer, if you try grabbing a stream after that, you will get an exception.

Step Six – Lets write a little bit of code

First lets define a model object that we will send across the wire. Here is my User.java class:

public class User {

        private long id;
        private String email;
        private String name;
        
        public long getId() {
                return id;
        }
        public void setId(long id) {
                this.id = id;
        }
        public String getEmail() {
                return email;
        }
        public void setEmail(String email) {
                this.email = email;
        }
        public String getName() {
                return name;
        }
        public void setName(String name) {
                this.name = name;
        }
}

And implement the controller to send and receive data. Here is my UserController.java:

package com.lureto.rjf;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

import org.apache.log4j.Logger;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

@Controller
@RequestMapping("/user")
public class UserController {

        private static Logger logger = Logger.getLogger( UserController.class );
        
        @ModelAttribute("users")
        @RequestMapping(value = "/", method = RequestMethod.GET)
        public List<User> listUsers() throws IOException {    
                List<User> users = new ArrayList<User>();
                
                User user = new User();
                user.setId(10001);
                user.setEmail("user.one@gmail.com");
                user.setName("User UNO");
                
                users.add(user);
                
                return users;
        }
        
        @ModelAttribute("user")
        @RequestMapping(value = "/", method = RequestMethod.POST)
        public User saveUser( @RequestBody User user ) throws IOException {
                logger.debug(user);
                return user;
        }
}

Lest go step my step through this and look at what all these little thing do.
We have marked our class as @Controller which indicates to sprign framework that this is a controller class. @RequestMapping(“/user”) indicates that this controller will handle requests that start with /user, /api/user to be precise, since spring servlet is configured to handle /api/* mappings.

@ModelAttribute("users")
@RequestMapping(value = "/", method = RequestMethod.GET)
public List<User> listUsers() throws IOException {

Here we define a methow which will be invoked when /api/user/ path gets called with GET method. If you running standard config http://localhost:8080/api/user/ would be the url to hit in the browser. @ModelAttribute(“users”) tells spring to put the object returned by this method into users model attribute for the view. Since we have wired everything in xml configuration, if we return the object it will be rendered by default view which serializes beans into JSON strings.
Our method for receiving json objects looks like this:

@ModelAttribute("user")
@RequestMapping(value = "/", method = RequestMethod.POST)
public User saveUser( @RequestBody User user ) throws IOException {
        logger.debug(user);
        return user;
}

@RequestBody annotation tells Spring framework to take request body and convert it into a bean using message converter. We have a single message converter defined in xml configuration file to be MappingJacksonHttpMessageConverter.

Conclusion

As you can see there is little code to write. In next Spring release the 2 bugs we fixed ourselves will probably be fixed, so this project will have only 2 source files, 3 xml files and 2 properties files. All the work is done by Spring framework, we just need to worry about the business logic and model.
Full project can be downloaded from here.
In the next part we will add flex project, so we can read the json object returned and post user object to the server.

UPDATE – October 27, 2009

Uncaught exception from servlet
java.lang.NullPointerException
        at com.google.apphosting.runtime.security.shared.RuntimeVerifier.isInspectable(RuntimeVerifier.java:302)
        at com.google.apphosting.runtime.security.shared.intercept.java.lang.Class_.getEnclosingMethod(Class_.java:237)
        at org.codehaus.jackson.map.util.ClassUtil.isLocalType(ClassUtil.java:88)
        at org.codehaus.jackson.map.deser.BeanDeserializerFactory.isPotentialBeanType(BeanDeserializerFactory.java:613)
        at org.codehaus.jackson.map.deser.BeanDeserializerFactory.createBeanDeserializer(BeanDeserializerFactory.java:61)
        at org.codehaus.jackson.map.deser.StdDeserializerProvider._createDeserializer(StdDeserializerProvider.java:248)
        at org.codehaus.jackson.map.deser.StdDeserializerProvider._createAndCacheValueDeserializer(StdDeserializerProvider.java:181)
        at org.codehaus.jackson.map.deser.StdDeserializerProvider.findValueDeserializer(StdDeserializerProvider.java:100)
        at org.codehaus.jackson.map.ObjectMapper._findRootDeserializer(ObjectMapper.java:1069)
        at org.codehaus.jackson.map.ObjectMapper._readMapAndClose(ObjectMapper.java:1002)
        at org.codehaus.jackson.map.ObjectMapper.readValue(ObjectMapper.java:818)
        ...... SNIP ......

After deploying to app engine I found out that jackson json library is using some unsupported introspection calls and had to make a fix inside jackson library to make it run inside google app engine. I have updated the jars inside the project to catch the exception and let parser to continue on its way. Here is the fix:

public static String isLocalType(Class<?> type)
{
        try {
                // one more: method locals, anonymous, are not good:
                if (type.getEnclosingMethod() != null) {
                        return "local/anonymous";
                }

                /* But how about non-static inner classes? Can't construct
                 * easily (theoretically, we could try to check if parent
                 * happens to be enclosing... but that gets convoluted)
                 */
                if (type.getEnclosingClass() != null) {
                        if (!Modifier.isStatic(type.getModifiers())) {
                                return "non-static member class";
                        }
                }
        } catch (  Exception exc ) {}
        return null;
}

Goolge app engine + java + spring + REST + JSON + Flex – Part 1 is a post from: Wet Feet - Online Marketing and Technology Blog

I have been inching to try out google app engine and its capabilities, but did not wan to give up the spring. So to day I am starting on my prototype involving Goolge app engine + java + spring + REST + JSON.

The end product will be spring mvc app running in google app engine handling GET, POST, PUT and DELETE http requests with JSON objects in and out utilizing JDO and seesions. This will give me a platform to write clients in Objective C for Ipod/Iphone (aka Coco Touch), Android, Flex, Ajax and maybe couple more platforms.

I am writing this while I am downloading Spring 3.0RC1. Will try to give daily updates if I can. If my prototype works as expected (all the research points to yes), I will have sample project available for download. There will be some trouble getting Flex to talk REST, since it only supports GET and POST and like most Adobe development stuff is not of the greatest maturity……. (opening new tab to check if we have new version of flex… still beta). Anyhow, Flex REST part will be interesting, I have already done some hacking in that area and it can be done – I have to write http client by hand, but who does not like an interesting challenge?

So here you have it. Next update when I have Spring 3 mvc inside google app engine up and running.

The part 1 is now online.

The part 2 is now online.

The part 3 is now online

The part 4 is now online

Goolge app engine + java + spring + REST + JSON is a post from: Wet Feet - Online Marketing and Technology Blog

package com.trx.wfm.model.dao;

import java.io.UnsupportedEncodingException;
import java.util.List;

import javax.naming.NamingException;
import javax.naming.directory.Attributes;
import javax.naming.directory.BasicAttribute;
import javax.naming.directory.BasicAttributes;
import javax.naming.directory.DirContext;
import javax.naming.directory.ModificationItem;

import org.apache.log4j.Logger;
import org.springframework.ldap.InvalidAttributeValueException;
import org.springframework.ldap.NameAlreadyBoundException;
import org.springframework.ldap.NameNotFoundException;
import org.springframework.ldap.OperationNotSupportedException;
import org.springframework.ldap.core.AttributesMapper;
import org.springframework.ldap.core.DistinguishedName;
import org.springframework.ldap.core.LdapTemplate;

import com.trx.wfm.exception.DuplicateUserException;
import com.trx.wfm.exception.LdapSaveException;
import com.trx.wfm.exception.PasswordStrengthException;
import com.trx.wfm.model.User;

public class LdapUserDAO {

    private LdapTemplate ldapTemplate;
    private boolean ldapReadonly;
    private String ldapBase;

	protected static final Logger logger = Logger.getLogger(LdapUserDAO.class);

    public LdapUserDAO() {
    }

    @SuppressWarnings("unchecked")
	public List getAllUsers() {
        return ldapTemplate.search("", "(objectclass=user)",new UserAttributeMapper() );
    }

    @SuppressWarnings("unchecked")
	public User findUser( String email ) {
        List lusers = ldapTemplate.search("", "(&(objectClass=user)(userPrincipalName="+email+"))",new UserAttributeMapper() );
        if( lusers.size() > 0 )
        	return lusers.get(0);
        return null;
    }

    public String getLdapBase() {
		return ldapBase;
	}

	public void setLdapBase(String ldapBase) {
		this.ldapBase = ldapBase;
	}

	public void setLdapTemplate(LdapTemplate ldapTemplate) {
        this.ldapTemplate = ldapTemplate;
    }

	public boolean isLdapReadonly() {
		return ldapReadonly;
	}

	public void setLdapReadonly(boolean ldapReadonly) {
		this.ldapReadonly = ldapReadonly;
	}

	public void deleteUser(User luzer) throws LdapSaveException {
		try {
		    DistinguishedName userDN = userToDistinguishedName( luzer );
		    ldapTemplate.unbind(userDN);
		} catch ( Exception exc ) {
			logger.error( "deleteUser()", exc);
			throw new LdapSaveException( exc.getMessage() );
		}
	}

	public void createUser(User luzer) throws DuplicateUserException, PasswordStrengthException, LdapSaveException {
		try {
		    Attributes personAttributes = new BasicAttributes();

		    personAttributes.put( "objectclass", "person" );
		    personAttributes.put( "objectclass", "user" );
		    personAttributes.put( "givenName", luzer.getFirstName() );
		    personAttributes.put( "userPrincipalName", luzer.getEmailAddress() );
		    personAttributes.put( "sn", luzer.getLastName());
		    personAttributes.put( "description", "Created via WFM 5.0 Flex app" );
		    personAttributes.put( "sAMAccountName", luzer.getFirstName().toUpperCase()+ "." + luzer.getLastName().toUpperCase() );
		    personAttributes.put( "userAccountControl", "512" ); /// 512 = normal luser

		    // PASSWORD stuff.....
		    personAttributes.put("unicodepwd", encodePassword( luzer.getPassword() ) );

		    // Set up user distinguished name and clreate it.
		    DistinguishedName newUserDN = userToDistinguishedName( luzer );
		    ldapTemplate.bind(newUserDN, null, personAttributes);

		} catch ( InvalidAttributeValueException exc ) {
			logger.error( "createUser()", exc);
			throw new LdapSaveException( exc.getMessage() );
		} catch ( NameAlreadyBoundException exc ) {   /// USER EXISTS....
			logger.error( "createUser()", exc);
			throw new DuplicateUserException(  "User ["+ luzer.getEmailAddress() + "] allready exists in AD." );
		} catch ( NameNotFoundException exc ) {
			logger.error( "createUser()", exc);
			throw new LdapSaveException( exc.getMessage() );
		} catch ( OperationNotSupportedException exc ) {  // CAN NOT ADD USER
			logger.error( "createUser()", exc);
			throw new PasswordStrengthException( exc.getMessage() );
		} catch ( Exception exc ) {
			logger.error( "createUser()", exc);
			throw new LdapSaveException( exc.getMessage() );
		}
	}

	public void changePassword( User luzer ) throws PasswordStrengthException {
		try {
		    ModificationItem repitem = new ModificationItem( DirContext.REPLACE_ATTRIBUTE, new BasicAttribute("unicodepwd", encodePassword( luzer.getPassword() )) );
		    DistinguishedName userDN = userToDistinguishedName( luzer );
		    ldapTemplate.modifyAttributes( userDN, new ModificationItem[] { repitem } );
		} catch ( Exception exc ) {
			logger.error( "changePassword()", exc);
			throw new PasswordStrengthException( exc.getMessage() );
		}
	}

	public void updateUser( User luzer ) throws LdapSaveException {
		try {
		    ModificationItem repitem1 = new ModificationItem( DirContext.REPLACE_ATTRIBUTE, new BasicAttribute("givenName", luzer.getFirstName()) );
		    ModificationItem repitem2 = new ModificationItem( DirContext.REPLACE_ATTRIBUTE, new BasicAttribute("sn", luzer.getLastName()) );
		    ModificationItem repitem3 = new ModificationItem( DirContext.REPLACE_ATTRIBUTE, new BasicAttribute("userPrincipalName", luzer.getEmailAddress()) );
		    DistinguishedName userDN = userToDistinguishedName( luzer );
		    ldapTemplate.modifyAttributes( userDN, new ModificationItem[] { repitem1, repitem2, repitem3 } );
		} catch ( Exception exc ) {
			logger.error( "updateUser()", exc);
			throw new LdapSaveException( exc.getMessage() );
		}
	}

	private byte[] encodePassword(String password) throws UnsupportedEncodingException {
		String newQuotedPassword = "\"" + password + "\"";
		return newQuotedPassword.getBytes("UTF-16LE");
	}	

	private DistinguishedName userToDistinguishedName( User luzer ) {
		return new DistinguishedName( "cn=user_"+luzer.getUserId() );
	}

	public class UserAttributeMapper implements AttributesMapper{

	    public Object mapFromAttributes(Attributes attributes) throws NamingException {
	        User user = new User();

	        user.setFirstName( attributes.get("givenName").get().toString() );
	        user.setLastName( attributes.get("sn").get().toString() );
	        user.setEmailAddress( attributes.get("userPrincipalName").get().toString() );

//        	logger.debug( " ====== ATTRIBUTES ============ " );
//	        NamingEnumeration list = attributes.getAll();
//	        while( list.hasMore() ) {
//	        	Attribute attr = list.next();
//	        	String output = " Attribute ID [" + attr.getID() + "] values [" ;
//	        	NamingEnumeration vals = attr.getAll();
//	        	while( vals.hasMore() )
//	        		output = output + "{" + vals.next().toString()+"},";
//	        	output = output + "]";
//	        	logger.debug( output );
//	        }
//
//        	logger.debug( " ============================== " );

	        return user;
	    }

	}

}

Some key sticking points I wan to point out:

- Check your existing users in AD to make sure you provide all required attributes

- OperationNotSupportedException usually indicates that something required is missing or password requirements are not met. If you are getting this exception change userAccountControl value to 2 – user dissabled. This will allow user creation with out password verification.

- Password has to bent to AD in unicode format.

Here is portion of the spring config that pertains to the bean:

	<bean id="ldapContextSource" class="org.springframework.ldap.core.support.LdapContextSource">
		<property name="url" value="${ldap.url}" />
		<property name="base" value="${ldap.base}" />
		<property name="userDn" value="${ldap.admin.bind.userdn}" />
		<property name="password" value="${ldap.admin.bind.password}" />
	</bean>

	<bean id="ldapTemplate" class="org.springframework.ldap.core.LdapTemplate">
		<property name="contextSource" ref="ldapContextSource" />
	</bean>

	<bean id="ldapUserDAO" class="com.trx.wfm.model.dao.LdapUserDAO">
		<property name="ldapTemplate" ref="ldapTemplate" />
		<property name="ldapReadonly" value="${ldap.readonly}" />
		<property name="ldapBase" value="${ldap.base}" />
	</bean>

ldap.base points to the OU where the users are created. This simplifies the operations, since I am checking for users only on this branch of the tree and adding them there too.

And on more point – to change anythign in AD you need to go via secure connection ldaps://your.ldap.server:636. Most likly you will get an certificate error, since my server’s is self signed, so use keytool provided in java home/bin directory to import security certificates into key store. Make sure you specify the path of they keystore file! I did it wihout the keystore file and my app was still getting exceptions. You can provide they keystore location to java as VM startup parameter (RTFM).

Using Microsoft Ad to Create and Authenticate Users is a post from: Wet Feet - Online Marketing and Technology Blog