diff --git a/src/com/google/inject/ConstructorInjector.java b/src/com/google/inject/ConstructorInjector.java
index 24f56ed..d36ea31 100644
--- a/src/com/google/inject/ConstructorInjector.java
+++ b/src/com/google/inject/ConstructorInjector.java
@@ -16,6 +16,9 @@
 
 package com.google.inject;
 
+import com.google.inject.util.SurrogateAnnotations;
+import com.google.inject.util.DuplicateAnnotationException;
+
 import java.lang.reflect.Constructor;
 import java.lang.reflect.InvocationTargetException;
 
@@ -31,6 +34,9 @@
   final ContainerImpl.ParameterInjector<?>[] parameterInjectors;
   final ConstructionProxy<T> constructionProxy;
 
+  /** Annotation on the constructor. */
+  Inject inject;
+
   ConstructorInjector(ContainerImpl container, Class<T> implementation) {
     this.implementation = implementation;
     Constructor<T> constructor = findConstructorIn(container, implementation);
@@ -53,7 +59,6 @@
   ContainerImpl.ParameterInjector<?>[] createParameterInjector(
       ContainerImpl container, Constructor<T> constructor) {
     try {
-      Inject inject = constructor.getAnnotation(Inject.class);
       return inject == null
           ? null // default constructor.
           : container.getParametersInjectors(
@@ -76,13 +81,23 @@
     Constructor<T>[] constructors
         = (Constructor<T>[]) implementation.getDeclaredConstructors();
     for (Constructor<T> constructor : constructors) {
-      if (constructor.getAnnotation(Inject.class) != null) {
+      Inject inject = null;
+      try {
+        inject = SurrogateAnnotations.findAnnotation(Inject.class, constructor);
+      } catch (DuplicateAnnotationException e) {
+        container.errorHandler.handle(ErrorMessages.DUPLICATE_ANNOTATIONS,
+            Inject.class.getSimpleName(), constructor, e.getFirst(),
+            e.getSecond());
+      }
+
+      if (inject != null) {
         if (found != null) {
           container.errorHandler.handle(
               ErrorMessages.TOO_MANY_CONSTRUCTORS, implementation);
           return ContainerImpl.invalidConstructor();
         }
         found = constructor;
+        this.inject = inject;
       }
     }
     if (found != null) {
diff --git a/src/com/google/inject/ContainerImpl.java b/src/com/google/inject/ContainerImpl.java
index 582684e..7f49d68 100644
--- a/src/com/google/inject/ContainerImpl.java
+++ b/src/com/google/inject/ContainerImpl.java
@@ -21,6 +21,8 @@
 import com.google.inject.util.ReferenceCache;
 import com.google.inject.util.Strings;
 import com.google.inject.util.ToStringBuilder;
+import com.google.inject.util.SurrogateAnnotations;
+import com.google.inject.util.DuplicateAnnotationException;
 
 import net.sf.cglib.reflect.FastClass;
 import net.sf.cglib.reflect.FastMethod;
@@ -334,7 +336,15 @@
       InjectorFactory<M> injectorFactory) {
     for (M member : members) {
       if (isStatic(member) == statics) {
-        Inject inject = member.getAnnotation(Inject.class);
+        Inject inject = null;
+        try {
+          inject = SurrogateAnnotations.findAnnotation(Inject.class, member);
+        } catch (DuplicateAnnotationException e) {
+          errorHandler.handle(ErrorMessages.DUPLICATE_ANNOTATIONS,
+              Inject.class.getSimpleName(), member, e.getFirst(),
+              e.getSecond());
+        }
+
         if (inject != null) {
           try {
             injectors.add(injectorFactory.create(this, member, inject.value()));
@@ -463,18 +473,27 @@
         = Arrays.asList(annotations).iterator();
     int index = 0;
     for (Type parameterType : parameterTypes) {
-      Inject annotation = findInject(annotationsIterator.next());
+      Annotation[] parameterAnnotations = annotationsIterator.next();
+      Inject inject = null;
+      try {
+        inject = SurrogateAnnotations.findAnnotation(Inject.class,
+            parameterAnnotations);
+      } catch (DuplicateAnnotationException e) {
+        errorHandler.handle(ErrorMessages.DUPLICATE_ANNOTATIONS,
+            Inject.class.getSimpleName(), member, e.getFirst(),
+            e.getSecond());
+      }
 
       String name;
       if (defaultNameOverridden) {
         name = defaultName;
-        if (annotation != null) {
+        if (inject != null) {
           errorHandler.handle(
               ErrorMessages.NAME_ON_MEMBER_AND_PARAMETER, member);
         }
       }
       else {
-        name = annotation == null ? defaultName : annotation.value();
+        name = inject == null ? defaultName : inject.value();
       }
 
       Key<?> key = Key.get(parameterType, name);
@@ -497,18 +516,6 @@
     return new ParameterInjector<T>(externalContext, factory);
   }
 
-  /**
-   * Finds the {@link Inject} annotation in an array of annotations.
-   */
-  Inject findInject(Annotation[] annotations) {
-    for (Annotation annotation : annotations) {
-      if (annotation.annotationType() == Inject.class) {
-        return Inject.class.cast(annotation);
-      }
-    }
-    return null;
-  }
-
   static class MethodInjector implements Injector {
 
     final FastMethod fastMethod;
diff --git a/src/com/google/inject/Inject.java b/src/com/google/inject/Inject.java
index 087d6ca..10e4f7c 100644
--- a/src/com/google/inject/Inject.java
+++ b/src/com/google/inject/Inject.java
@@ -16,6 +16,7 @@
 
 package com.google.inject;
 
+import static java.lang.annotation.ElementType.ANNOTATION_TYPE;
 import static java.lang.annotation.ElementType.CONSTRUCTOR;
 import static java.lang.annotation.ElementType.FIELD;
 import static java.lang.annotation.ElementType.METHOD;
@@ -26,11 +27,13 @@
 
 /**
  * <p>Annotates members and parameters which should have their value[s]
- * injected.
+ * injected. If applied to another annotation type, that annotation type
+ * can act as a surrogate and save you from having to repeat the dependency
+ * name over and over.
  *
  * @author crazybob@google.com (Bob Lee)
  */
-@Target({ METHOD, CONSTRUCTOR, FIELD, PARAMETER })
+@Target({ METHOD, CONSTRUCTOR, FIELD, PARAMETER, ANNOTATION_TYPE })
 @Retention(RUNTIME)
 public @interface Inject {
 
diff --git a/src/com/google/inject/util/SurrogateAnnotations.java b/src/com/google/inject/util/SurrogateAnnotations.java
index 3530f07..d461081 100644
--- a/src/com/google/inject/util/SurrogateAnnotations.java
+++ b/src/com/google/inject/util/SurrogateAnnotations.java
@@ -33,9 +33,9 @@
 public class SurrogateAnnotations {
 
   /**
-   * Finds an annotation of the given type on the given element. Looks for
-   * the annotation directly on the element as well as on annotations on the
-   * element non-recursively.
+   * Finds an annotation of the given type on the given element. Looks for the
+   * annotation directly on the element as well as on other annotations on the
+   * element.
    *
    * @returns an instance of the annotation or {@code null} if none is found
    * @throws DuplicateAnnotationException if more than one annotation is found
@@ -43,10 +43,24 @@
   public static <A extends Annotation> A findAnnotation(
       Class<A> annotationType, AnnotatedElement element)
       throws DuplicateAnnotationException {
+    return findAnnotation(annotationType, element.getAnnotations());
+  }
+
+  /**
+   * Finds an annotation of the given type in the given array of annotations.
+   * Looks for the annotation in the array as well as on other annotations in
+   * the array.
+   *
+   * @returns an instance of the annotation or {@code null} if none is found
+   * @throws DuplicateAnnotationException if more than one annotation is found
+   */
+  public static <A extends Annotation> A findAnnotation(
+      Class<A> annotationType, Annotation[] annotations)
+      throws DuplicateAnnotationException {
     Annotation firstAnnotation = null;
     A firstFound = null;
 
-    for (Annotation annotation : element.getAnnotations()) {
+    for (Annotation annotation : annotations) {
       A found = findAnnotation(annotationType, annotation);
       if (found != null) {
         if (firstFound == null) {
diff --git a/test/com/google/inject/AllTests.java b/test/com/google/inject/AllTests.java
index f761411..2e51369 100644
--- a/test/com/google/inject/AllTests.java
+++ b/test/com/google/inject/AllTests.java
@@ -49,6 +49,7 @@
     suite.addTestSuite(ReflectionTest.class);
     suite.addTestSuite(ScopesTest.class);
     suite.addTestSuite(ImplicitBindingTest.class);
+    suite.addTestSuite(InjectTest.class);
 
     suite.addTestSuite(QueryTest.class);
     suite.addTestSuite(ProxyFactoryTest.class);
diff --git a/test/com/google/inject/InjectTest.java b/test/com/google/inject/InjectTest.java
new file mode 100644
index 0000000..7b50c9c
--- /dev/null
+++ b/test/com/google/inject/InjectTest.java
@@ -0,0 +1,71 @@
+/**
+ * Copyright (C) 2006 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.inject;
+
+import junit.framework.TestCase;
+
+import java.lang.annotation.Retention;
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+/**
+ * @author crazybob@google.com (Bob Lee)
+ */
+public class InjectTest extends TestCase {
+
+  public void testSurrogateInjection() throws ContainerCreationException {
+    ContainerBuilder builder = new ContainerBuilder();
+    Bar bar = new Bar(null);
+    builder.bind(Bar.class).named("bar").to(bar);
+    Container container = builder.create(false);
+    Foo foo = container.getInstance(Foo.class);
+    assertSame(bar, foo.field);
+    assertSame(bar, foo.fromConstructor);
+    assertSame(bar, foo.fromMethod);
+    assertSame(bar, foo.fromParameter);
+  }
+
+  @Retention(RUNTIME)
+  @Inject("bar")
+  @interface InjectBar {}
+
+  static class Foo {
+    @InjectBar Bar field;
+
+    Bar fromConstructor;
+    @InjectBar
+    public Foo(Bar fromConstructor) {
+      this.fromConstructor = fromConstructor;
+    }
+
+    Bar fromMethod;
+    @InjectBar
+    void setBar(Bar bar) {
+      fromMethod = bar;
+    }
+
+    Bar fromParameter;
+    @Inject
+    void setBar2(@InjectBar Bar bar) {
+      fromParameter= bar;
+    }
+  }
+
+  static class Bar {
+    // Not injectable.
+    Bar(String s) {}
+  }
+}