diff --git a/src/main/java/com/avaje/ebeaninternal/server/deploy/BeanLifecycleAdapterFactory.java b/src/main/java/com/avaje/ebeaninternal/server/deploy/BeanLifecycleAdapterFactory.java
index 22eb69b27..40bb136c7 100644
--- a/src/main/java/com/avaje/ebeaninternal/server/deploy/BeanLifecycleAdapterFactory.java
+++ b/src/main/java/com/avaje/ebeaninternal/server/deploy/BeanLifecycleAdapterFactory.java
@@ -2,6 +2,8 @@ package com.avaje.ebeaninternal.server.deploy;
 
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.List;
 import java.util.Set;
 
 import javax.persistence.PersistenceException;
@@ -23,7 +25,7 @@ import com.avaje.ebeaninternal.server.deploy.meta.DeployBeanDescriptor;
 /**
  * Helper that looks for methods annotated with lifecycle events and registers an adapter for them.
  * <p>
- * This includes PrePerist, PostPerist, PreUpdate, PostUpdate, PreRemove, PostRemove and PostLoad
+ * This includes PrePersist, PostPersist, PreUpdate, PostUpdate, PreRemove, PostRemove and PostLoad
  * lifecycle events.
  * </p>
  */
@@ -38,7 +40,7 @@ public class BeanLifecycleAdapterFactory {
 
     Method[] methods = deployDesc.getBeanType().getMethods();
 
-    MethodHolder methodHolder = new MethodHolder();
+    MethodsHolder methodHolder = new MethodsHolder();
 
     for (Method m : methods) {
       methodHolder.checkMethod(m);
@@ -52,16 +54,16 @@ public class BeanLifecycleAdapterFactory {
   /**
    * Holds Methods for the lifecycle events.s
    */
-  private static class MethodHolder {
+  private static class MethodsHolder {
 
     private boolean hasListener;
-    private Method preInsert;
-    private Method postInsert;
-    private Method preUpdate;
-    private Method postUpdate;
-    private Method preDelete;
-    private Method postDelete;
-    private Method postLoad;
+    private List<Method> preInserts = new ArrayList<Method>();
+    private List<Method> postInserts = new ArrayList<Method>();
+    private List<Method> preUpdates = new ArrayList<Method>();
+    private List<Method> postUpdates = new ArrayList<Method>();
+    private List<Method> preDeletes = new ArrayList<Method>();
+    private List<Method> postDeletes = new ArrayList<Method>();
+    private List<Method> postLoads = new ArrayList<Method>();
 
     private boolean hasListener() {
       return hasListener;
@@ -69,37 +71,36 @@ public class BeanLifecycleAdapterFactory {
 
     private void checkMethod(Method method) {
       if (method.isAnnotationPresent(PrePersist.class)) {
-        preInsert = method;
+        preInserts.add(method);
         hasListener = true;
       }
       if (method.isAnnotationPresent(PostPersist.class)) {
-        postInsert = method;
+        postInserts.add(method);
         hasListener = true;
       }
 
       if (method.isAnnotationPresent(PreUpdate.class)) {
-        preUpdate = method;
+        preUpdates.add(method);
         hasListener = true;
       }
       if (method.isAnnotationPresent(PostUpdate.class)) {
-        postUpdate = method;
+        postUpdates.add(method);
         hasListener = true;
       }
 
       if (method.isAnnotationPresent(PreRemove.class)) {
-        preDelete = method;
+        preDeletes.add(method);
         hasListener = true;
       }
       if (method.isAnnotationPresent(PostRemove.class)) {
-        postDelete = method;
+        postDeletes.add(method);
         hasListener = true;
       }
 
       if (method.isAnnotationPresent(PostLoad.class)) {
-        postLoad = method;
+        postLoads.add(method);
         hasListener = true;
       }
-
     }
   }
 
@@ -108,9 +109,9 @@ public class BeanLifecycleAdapterFactory {
    */
   private static class Adapter extends BeanPersistAdapter {
 
-    private final MethodHolder methodHolder;
+    private final MethodsHolder methodHolder;
 
-    private Adapter(MethodHolder methodHolder) {
+    private Adapter(MethodsHolder methodHolder) {
       this.methodHolder = methodHolder;
     }
 
@@ -130,61 +131,52 @@ public class BeanLifecycleAdapterFactory {
       }
     }
 
-    private void invoke(Method method, BeanPersistRequest<?> request) {
-      invoke(method, request.getBean());
+    private void invoke(List<Method> methods, BeanPersistRequest<?> request) {
+      if (methods.isEmpty()) return;
+      for (Method method : methods) {
+        invoke(method, request.getBean());
+      }
     }
 
     @Override
     public boolean preDelete(BeanPersistRequest<?> request) {
-      if (methodHolder.preDelete != null) {
-        invoke(methodHolder.preDelete, request);
-      }
+      invoke(methodHolder.preDeletes, request);
       return true;
     }
 
     @Override
     public boolean preInsert(BeanPersistRequest<?> request) {
-      if (methodHolder.preInsert != null) {
-        invoke(methodHolder.preInsert, request);
-      }
+      invoke(methodHolder.preInserts, request);
       return true;
     }
 
     @Override
     public boolean preUpdate(BeanPersistRequest<?> request) {
-      if (methodHolder.preUpdate != null) {
-        invoke(methodHolder.preUpdate, request);
-      }
+      invoke(methodHolder.preUpdates, request);
       return true;
     }
 
     @Override
     public void postDelete(BeanPersistRequest<?> request) {
-      if (methodHolder.postDelete != null) {
-        invoke(methodHolder.postDelete, request);
-      }
+      invoke(methodHolder.postDeletes, request);
     }
 
     @Override
     public void postInsert(BeanPersistRequest<?> request) {
-      if (methodHolder.postInsert != null) {
-        invoke(methodHolder.postInsert, request);
-      }
+      invoke(methodHolder.postInserts, request);
     }
 
     @Override
     public void postUpdate(BeanPersistRequest<?> request) {
-      if (methodHolder.postUpdate != null) {
-        invoke(methodHolder.postUpdate, request);
-      }
+      invoke(methodHolder.postUpdates, request);
     }
 
     @Override
     public void postLoad(Object bean, Set<String> includedProperties) {
-      if (methodHolder.postLoad != null) {
-        invoke(methodHolder.postLoad, bean);
+      if (methodHolder.postLoads.isEmpty()) return;
+      for (Method method : methodHolder.postLoads) {
+        invoke(method, bean);
       }
     }
-
   }
 }
diff --git a/src/test/java/com/avaje/tests/lifecycle/TestLifecyleAnnotatedBean.java b/src/test/java/com/avaje/tests/lifecycle/TestLifecyleAnnotatedBean.java
index 6b9610fd8..90aec657b 100644
--- a/src/test/java/com/avaje/tests/lifecycle/TestLifecyleAnnotatedBean.java
+++ b/src/test/java/com/avaje/tests/lifecycle/TestLifecyleAnnotatedBean.java
@@ -1,5 +1,6 @@
 package com.avaje.tests.lifecycle;
 
+import org.hamcrest.Matchers;
 import org.junit.Assert;
 import org.junit.Test;
 
@@ -10,25 +11,95 @@ import com.avaje.tests.model.basic.EBasicWithLifecycle;
 public class TestLifecyleAnnotatedBean extends BaseTestCase {
 
   @Test
-  public void test() {
-    
+  public void shouldExecutePrePersistMethodsWhenSavingBean() {
     EBasicWithLifecycle bean = new EBasicWithLifecycle();
-    bean.setName("hello there");
-    
+    bean.setName("PrePersist");
+
     Ebean.getServerCacheManager();
     Ebean.save(bean);
-    Assert.assertEquals("prePersist,postPersist,", bean.getBuffer());
-
-    EBasicWithLifecycle beanWasLoaded = Ebean.find(EBasicWithLifecycle.class, bean.getId());
-    Assert.assertEquals("postLoad", beanWasLoaded.getBuffer().toString());
     
-    bean.setName("Changed");
+    Assert.assertThat(bean.getBuffer(), Matchers.containsString("prePersist1"));
+    Assert.assertThat(bean.getBuffer(), Matchers.containsString("prePersist2"));
+  }
+
+  @Test
+  public void shouldExecutePostPersistMethodsWhenSavingBean() {
+    EBasicWithLifecycle bean = new EBasicWithLifecycle();
+    bean.setName("PostPersist");
+
+    Ebean.getServerCacheManager();
+    Ebean.save(bean);
+
+    Assert.assertThat(bean.getBuffer(), Matchers.containsString("postPersist1"));
+    Assert.assertThat(bean.getBuffer(), Matchers.containsString("postPersist2"));
+  }
+
+  @Test
+  public void shouldExecutePostLoadMethodsWhenFindingBean() {
+    EBasicWithLifecycle bean = new EBasicWithLifecycle();
+    bean.setName("PostLoad");
+
+    Ebean.getServerCacheManager();
+    Ebean.save(bean);
+
+    EBasicWithLifecycle loaded = Ebean.find(EBasicWithLifecycle.class, bean.getId());
+    Assert.assertThat(loaded.getBuffer(), Matchers.containsString("postLoad1"));
+    Assert.assertThat(loaded.getBuffer(), Matchers.containsString("postLoad2"));
+  }
+
+  @Test
+  public void shouldExecutePreUpdateMethodsWhenUpdatingBean() {
+    EBasicWithLifecycle bean = new EBasicWithLifecycle();
+    bean.setName("Persisted");
+
+    Ebean.getServerCacheManager();
     Ebean.save(bean);
     
+    bean.setName("PreUpdate");
+    Ebean.save(bean);
+
+    Assert.assertThat(bean.getBuffer(), Matchers.containsString("preUpdate1"));
+    Assert.assertThat(bean.getBuffer(), Matchers.containsString("preUpdate2"));
+  }
+
+  @Test
+  public void shouldExecutePostUpdateMethodsWhenUpdatingBean() {
+    EBasicWithLifecycle bean = new EBasicWithLifecycle();
+    bean.setName("Persisted");
+
+    Ebean.getServerCacheManager();
+    Ebean.save(bean);
+
+    bean.setName("PostUpdate");
+    Ebean.save(bean);
+
+    Assert.assertThat(bean.getBuffer(), Matchers.containsString("postUpdate1"));
+    Assert.assertThat(bean.getBuffer(), Matchers.containsString("postUpdate2"));
+  }
+
+  @Test
+  public void shouldExecutePreRemoveMethodsWhenRemovingBean() {
+    EBasicWithLifecycle bean = new EBasicWithLifecycle();
+    bean.setName("Persisted");
+
+    Ebean.getServerCacheManager();
+    Ebean.save(bean);
     Ebean.delete(bean);
-    
-    Assert.assertEquals("prePersist,postPersist,preUpdate,postUpdate,preRemove,postRemove", bean.getBuffer());
-    
+
+    Assert.assertThat(bean.getBuffer(), Matchers.containsString("preRemove1"));
+    Assert.assertThat(bean.getBuffer(), Matchers.containsString("preRemove2"));
+  }
+
+  @Test
+  public void shouldExecutePostRemoveMethodsWhenRemovingBean() {
+    EBasicWithLifecycle bean = new EBasicWithLifecycle();
+    bean.setName("Persisted");
+
+    Ebean.getServerCacheManager();
+    Ebean.save(bean);
+    Ebean.delete(bean);
+
+    Assert.assertThat(bean.getBuffer(), Matchers.containsString("postRemove1"));
+    Assert.assertThat(bean.getBuffer(), Matchers.containsString("postRemove2"));
   }
-  
 }
diff --git a/src/test/java/com/avaje/tests/model/basic/EBasicWithLifecycle.java b/src/test/java/com/avaje/tests/model/basic/EBasicWithLifecycle.java
index 1ea6067fe..645968341 100644
--- a/src/test/java/com/avaje/tests/model/basic/EBasicWithLifecycle.java
+++ b/src/test/java/com/avaje/tests/model/basic/EBasicWithLifecycle.java
@@ -27,38 +27,73 @@ public class EBasicWithLifecycle {
   transient StringBuilder buffer = new StringBuilder();
   
   @PrePersist
-  public void prePersist() {
-    buffer.append("prePersist,");
+  public void prePersist1() {
+    buffer.append("prePersist1");
+  }
+  
+  @PrePersist
+  public void prePersist2() {
+    buffer.append("prePersist2");
   }
   
   @PostPersist
-  public void postPersist() {
-    buffer.append("postPersist,");
+  public void postPersist1() {
+    buffer.append("postPersist1");
+  }
+
+  @PostPersist
+  public void postPersist2() {
+    buffer.append("postPersist2");
   }
   
   @PreUpdate
-  public void preUpdate() {
-    buffer.append("preUpdate,");
+  public void preUpdate1() {
+    buffer.append("preUpdate1");
+  }
+
+  @PreUpdate
+  public void preUpdate2() {
+    buffer.append("preUpdate2");
   }
   
   @PostUpdate
-  public void postUpdate() {
-    buffer.append("postUpdate,");
+  public void postUpdate1() {
+    buffer.append("postUpdate1");
+  }
+
+  @PostUpdate
+  public void postUpdate2() {
+    buffer.append("postUpdate2");
+  }
+  
+  @PreRemove
+  public void preRemove1() {
+    buffer.append("preRemove1");
   }
 
   @PreRemove
-  public void preRemove() {
-    buffer.append("preRemove,");
+  public void preRemove2() {
+    buffer.append("preRemove2");
   }
   
   @PostRemove
-  public void postRemove() {
-    buffer.append("postRemove");
+  public void postRemove1() {
+    buffer.append("postRemove1");
+  }
+
+  @PostRemove
+  public void postRemove2() {
+    buffer.append("postRemove2");
   }
   
   @PostLoad
-  public void postLoad() {
-    buffer.append("postLoad");
+  public void postLoad1() {
+    buffer.append("postLoad1");
+  }
+
+  @PostLoad
+  public void postLoad2() {
+    buffer.append("postLoad2");
   }
 
   public Long getId() {