• Home
  • RSS Feed
  • Log in

Archive for the ‘Java’ Category

Older Entries

Developing and deploying Java on middleware and in the cloud: rise of the Virtual Appliance?
Posted by Andrew Phillips mid-morning: March 9th, 2010

From Java EE to Google App Engine to GigaSpaces, the idea of developing against a middleware or "infrastructure" API is well established in the Java world.
But these are fixed environments. With the (re-)advent of virtualization, it is now becoming feasible to package and rapidly provision your own environment, custom-designed to meet your application's needs.
As the big middleware vendors are realizing, it is not just possible to create such Virtual Appliances, but necessary: a production app's setup inevitably includes more than just a couple of EARs.

Here, we'll look at the current state of cloud and middleware deployment tooling, examine possible future developments and draw parallels between deployment and related processes.
(more...)

  • Share/Bookmark

Tags: cloud, deployment automation, virtual appliance
Filed under Deployment, Java, Middleware, Oracle, Virtualization, websphere | 4 Comments »

Speed up your dev cycle with git
Posted by Iwein Fuld at around evening time: February 28th, 2010

Git has made me more productive, and I will explain in a few words why that is. I could almost do it with twitter, but I like to take a little more time to make my point. The main benefit that git has given me can be found in performance of certain things I want to do when I am managing changes in my code base. The performance improvements of some critical parts of it are even so profound that they have changed the way I am working. In particular the fact that I can skip builds for most of my commits is a big time saver.

There have been many things said about git already and I suggest you use your favorite search index to bring yourself up to speed if you need to. Git is a simple distributed versioning system that is challenging many assumptions I had about development. Let's go over these assumptions. I'll show you my (svn based) assumption and why it doesn't hold if you're using git.
(more...)

  • Share/Bookmark

Filed under GIT, Java, Tools | 4 Comments »

Deployit!
Posted by Vincent Partington mid-morning: February 10th, 2010

We've already been talking about Deployit, XebiaLabs' deployment automation product, for some time. Now we are proud to announce that you can try Deployit for yourself by downloading the Personal Edition of Deployit!

If you don't know what Deployit is yet, have a look at the movie below!

To summarize; Deployit will automate your Java EE application deployments and, because of the overview it offers and the history it keeps, it also allows you to manage and optimize your deployments.
(more...)

  • Share/Bookmark

Filed under Deployment, Java, Middleware, Xebia Labs, websphere | No Comments »

Web performance in seven steps: Summary and Conclusions
Posted by Jeroen Borgers at around evening time: January 20th, 2010

Previous time I blogged about the last step of the seven steps, step 7: Share the responsibility for the whole chain, a non-technical but rather a communication and behavior thing which I found crucial for success. We now have reached the end of this series and I'll sum up the topics we've dealt with and draw some conclusions. (more...)

  • Share/Bookmark

Filed under Architecture, Java, Monitoring, Performance, Process, Quality Assurance, Requirements Management, Testing, Tools | No Comments »

Slow change in agile consultancy
Posted by Luuk Dijkhuis around lunchtime: January 20th, 2010

We as Agilists are extremely result driven: delivering value to the customer as soon as possible is the axle around which our work and vision revolve. This can help us but also hamper us in the process of bringing Agile to a non-Agile environment. Being aware of this may already help us be more effective in bringing about changes in an effective way. The question “is this a quick-change or a slow-change organization” should be an explicit part of your analysis. Be patient!

(more...)

  • Share/Bookmark

Tags: Agile, coaching, patience, slow change
Filed under Java | 2 Comments »

Using Spring JavaConfig on Google App Engine
Posted by Andrew Phillips at around evening time: January 17th, 2010

Recently, I put together a Spring demonstration for jclouds, the Java cloud library. This quickly turned into unexpected multi-dimensional experiment in integrating Guice, Google App Engine and Spring, but after much trial-and-error I finally came across a configuration that does the trick - or at least works1 as well as seems possible on GAE. (more...)

  • Share/Bookmark

Tags: GAE, Google App Engine, Guice, Javaconfig, jclouds, Spring
Filed under Amazon Webservices, Frameworks, Java, Spring | 4 Comments »

Middleware integration testing with JUnit, Maven and VMware, part 3 (of 3)
Posted by Vincent Partington in the wee hours: January 7th, 2010

Last year, before the Christmas holidays ;-) , I described how we do middleware integration testing at XebiaLabs and I described the way we deploy test servlets by wrapping them in WAR and EAR files that get generated on the fly. There is only one thing left to explain; how do we integrate these tests into a continuous build using Maven and VMware?

Running the middleware integration tests

So let's start with the Maven configuration. As I mentioned in the first blog of this series, the integration tests are recognizable by the fact that the classnames end in Itest. That means they won't get picked up by the default configuration of the Maven Surefire plugin. And that is fortunate because we don't always want to run these tests. Firstly they require a very specific test setup (the application server configurations should be in an expected state, see below) and secondly they can take a long time to complete and that would get in the way of the quick turnaround we want from commit builds in our continuous integration system.
(more...)

  • Share/Bookmark

Filed under Deployment, JBoss, Java, Maven, Middleware, TDD, Testing, Virtualization, Xebia Labs | 2 Comments »

Integrating Tivoli Access Manager with JBoss AS 4.x
Posted by Mark Bakker in the early morning: December 22nd, 2009

Introduction

Currently I am working at a big Enterprise where they use Tivoli Access Manager as authorization and authentication source for a lot of there applications.

This Enterprise is using JBoss as open source application server platform and is using this more and more. When they began using JBoss they got a TAM plug-in for JBoss from IBM. This plug-in did the complete authorization and authentication by implementing JAAS and registering all the used security roles in TAM. This is done during deployment time.

If you have an application with a lot of roles this is very frustrating because it can take a lot of extra time to start up (think of 30 minutes per application) because TAM is synchronizing all the new roles.

Most applications at this customer are using JAAS but do not have special method level authorizations implemented by using TAM. So only the roles are important.

After realizing this I thought is could be a good idea to create a simpler solution for integration TAM and JBoss. For this I wrote some custom code (only 250 lines).

(more...)

  • Share/Bookmark

Filed under Architecture, JBoss, Java, Middleware, Opensource | No Comments »

Google Guice and Multibinding
Posted by Mischa Dasberg around lunchtime: December 21st, 2009

Last week I started migrating an application that used Spring for DI to Google Guice when I stumbled on multibinding.

Since Google Guice 2.0 we can use Multibinding which allows us to bind multiple objects to a collection.
But the one thing I missed in the current release is the ability to bind objects with a specific annotation. So I thought, why not build it myself :)

(more...)

  • Share/Bookmark

Filed under Java | 7 Comments »

Middleware integration testing with JUnit, Maven and VMware, part 2 (of 3)
Posted by Vincent Partington at around evening time: December 14th, 2009

Last week I wrote about the approach we use at XebiaLabs to test the integrations with the different middleware products our Java EE deployment automation product Deployit supports.

The blog finished with the promise that I would discuss how to test that an application can really use the configurations that our middleware integrations (a.k.a. steps) create. But before we delve into that, let us first answer the question as to why we need this. If the code can configure a datasource without the application server, it must be OK for an application to use it, right? Well, not always. While WebSphere and WebLogic contain some functionality to test the connection to the database and thereby verify whether the datasource has been configured correctly, this functionality is not available for other configurations such as JMS settings. And JBoss has no such functionality at all. So the question is: how can we prove that an application can really work with the configurations created by our steps?
(more...)

  • Share/Bookmark

Filed under Deployment, Java, Maven, Middleware, TDD, Testing, Virtualization, Xebia Labs | No Comments »

Older Entries
Deployment automation for Java application running on Websphere, WebLogic and JBoss

Archives

  • March 2010
  • February 2010
  • January 2010
  • December 2009
  • November 2009
  • October 2009
  • September 2009
  • August 2009
  • July 2009
  • June 2009
  • May 2009
  • April 2009

Xebia Sites

  • Xebia Corporate
  • Xebia France
  • Xebia India

Categories

  • Java (282)
  • Agile (109)
  • General (50)
  • Testing (42)
  • Performance (42)
  • Hibernate (36)
  • Scrum (33)
  • Podcast (31)
  • Architecture (31)
  • Spring (28)
  • SOA (24)
  • Maven (22)
  • Project Management (22)
  • Middleware (23)
    • Deployment (14)
  • Flex (17)
  • JPA (17)
  • Eclipse (15)
  • Xebia Labs (15)
  • Quality Assurance (14)

Tag Cloud

    Spring Performance Seam JavaOne qcon Hibernate Agile Awareness Workshop SOA Closures Groovy Agile Architecture Maven Xebia Introduction to Agile Scrum Testing product owner Ajax esb Java Functional Programming Scala XML fitnesse IntelliJ Poppendieck Grails Semantic Web Lean