{"id":1664,"date":"2010-02-04T15:31:41","date_gmt":"2010-02-04T14:31:41","guid":{"rendered":"http:\/\/blog.jteam.nl\/?p=1664"},"modified":"2010-02-04T15:31:41","modified_gmt":"2010-02-04T14:31:41","slug":"free-java-hosting-with-the-google-app-engine","status":"publish","type":"post","link":"https:\/\/trifork.nl\/blog\/free-java-hosting-with-the-google-app-engine\/","title":{"rendered":"Free Java hosting with the Google App Engine"},"content":{"rendered":"

Lately I have been looking into and playing around with the Google App Engine<\/a>. In this post I want to give a little introduction to the Google App Engine, why it can be interesting and how to work with it.
\n<\/p>\n

Introduction<\/h2>\n

First I want to describe what the Google App Engine is in a few sentences. But nobody does a better job at explaining than Wikipedia so I’ll just give you a quote instead \ud83d\ude42<\/p>\n

\nGoogle App Engine is a platform for developing and hosting web applications in Google-managed data centers. It was first released as a beta version in April 2008.
\nGoogle App Engine is cloud computing technology. It virtualizes applications across multiple servers and data centers.[1] Other cloud-based platforms include offerings such as Amazon Web Services and Microsoft’s Azure Services Platform.
\nGoogle App Engine is free up to a certain level of used resources. Fees are charged for additional storage, bandwidth, or CPU cycles required by the application.\n<\/p><\/blockquote>\n

Source: http:\/\/en.wikipedia.org\/wiki\/Google_App_Engine<\/a><\/p>\n

To sum this quote up in a few words: Google App Engine is free hosting for Java! For so long technologies like PHP<\/a> have been very cheap (if not free) to host. To host a Java web application on the other hand, you always have to pay good money for it. Probably the biggest reason is that for PHP, it’s easy to have many websites on one server since those websites are just a bunch of standalone scripts. A Java website on the other hand, is an entire application, so the best way to host this is to get a dedicated server with an application server installed. Dedicating an entire server to host your website usually isn’t as cheap as hosting a PHP website.<\/p>\n

Why use the Google App Engine?<\/h2>\n

Next to the fact that Google App Engine is free to use, what else is interesting about it, you ask? Well, let me tell you! Actually, Google App Engine offers you a lot of features which can help your application in different ways. Below are a few examples of features I find the most helpful.<\/p>\n

The dashboard<\/h3>\n

The first thing you will see when you start using the Google App Engine is the Dashboard. The dashboard has both an online version and a local development version.<\/p>\n

The online version of the dashboard allows you to see all sorts of information about your deployed application. You can for example see application logging (filtered by INFO, WARN, etcetera), but also configured cron jobs, the content of your data store and quota details.<\/p>\n

The local development dashboard is kind of a stripped down version of the online one. It helps you control your locally running instance of the application. Using the dashboard you can for example simulate incoming emails, simulate incoming XMPP messages and view running cron jobs.<\/p>\n

Image service<\/h3>\n

Google offers you a service to easily manipulate images. The most common image operations are supported, like: resizing, cropping, flipping, enhancing colors and contrast.<\/p>\n

Data store<\/h3>\n

Using Google’s JPA or JDO implementation you can access the datastore. You can also use an SQL-like query language to access the store directly.<\/p>\n

Cron jobs \/ task queues<\/h3>\n

Instead of using a framework like Quartz<\/a> to schedule jobs, Google App Engine takes care of executing jobs for you. You simply enter a cron-like expression and a URL to call and your job is configured.<\/p>\n

You also have a task queue at your disposal. Your application code can add tasks to a task queue which will be executed later in the future, asynchronously. An example use case is that you don’t want clients to wait for an email to be sent before he sees the next page. Instead you can put the email task on the task queue and the email will be sent asynchronously.<\/p>\n

Security using Google accounts<\/h3>\n

Why use a security framework like Spring Security<\/a> when Google lets you use their own authentication system? When you configure your application to use Google authentication, only people with a Google account are able to login to the application. You can also configure one or more accounts to be the administrator. Administrators could have access to certain parts of the application other users can’t access.<\/p>\n

Service for receiving email<\/h3>\n

Google offers a service that allows your application to receive emails! When an email comes in, a URL is called with the email in the POST body. The body of the request is just the plain mime message text as it was received.<\/p>\n

Applications on the Google App Engine<\/h2>\n

To run your own application on the Google App Engine, it has to follow some guidelines in order to properly function. When I was building a sample application, I sometimes found myself writing workarounds to work with for example the JPA and mailing facilities of the Google App Engine. For the record, I was trying to use the Spring framework with JPA for persistence and Spring MVC for the frontend. I want to share the challenges I faced and how I handled them to get things working.<\/p>\n

Sometimes I had to write custom classes to get things working, I combined all those classes in a tiny open source project called app-engine-workarounds. The project can be found at http:\/\/code.google.com\/p\/app-engine-workarounds\/<\/a>. Below I will sometimes refer to classes in this project.<\/p>\n

Spring and the Java Mail Sender<\/h3>\n

When you’re using Spring and want to send an email from within your application, you will use the JavaMailSenderImpl<\/a> which is packaged with Spring. But when running an application the Google App Engine, you can’t use this class out-of-the-box. The reason is that Google has its own email implementation and does not use SMTP servers for instance. This is why you have to interact differently with the javax.mail.* framework. Luckily you can easily extend the JavaMailSenderImpl to make adjustments. The app-engine-workarounds<\/a>s library actually contains an adjusted JavaMailSender which is called the GaeJavaMailSender. This class is a drop-in replacement for the original JavaMailSenderImpl.<\/p>\n

Handling file uploads in Spring MVC<\/h3>\n

Handling file uploads in Spring MVC requires an implementation of the MultipartResolver<\/a>. The only implementation available in Spring MVC 3.0 is the CommonsMultipartResolver<\/a> which uses commons-fileupload<\/a> to do its job. Unfortunately the way Spring uses commons-fileupload, is not supported by the Google App Engine because it uses the file system, which Google App Engine does not provide. To make this work, you will have to utilize the streaming API<\/a> part of commons-fileupload framework, which does not need the filesystem. I created my own custom implementation of the MultipartResolver that actually uses this streaming API of commons-fileupload. I put this implementation in the app-engine-workarounds<\/a> library too.<\/p>\n

Spring and JPA with transactions<\/h3>\n

You can use JPA with Spring almost like you’re used to, except that the EntityManager factory bean is configured differently. In the section “Other workarounds” on http:\/\/code.google.com\/p\/app-engine-workarounds\/<\/a> I put a description of how to configure JPA in Spring for the Google App Engine.<\/p>\n

Using JPA with the Google App Engine has its limitations. I only tried the JPA implementation and I soon found out that a lot of JPA features are not (yet) supported. Most of these features are related to relationships between entities. I used a relatively simply data model and already encountered the following issues:<\/p>\n