文章目录

@Lookup方法是Spring框架中的一种依赖注入方式，用于解决原型Bean的依赖注入问题。其核心思想是：使用抽象方法声明需要注入的原型Bean，Spring在运行时动态生成子类并重写该抽象方法，从而实现原型Bean的注入。以下是@Lookup方法注入的一些知识点：

  1. @Lookup方法的定义：在抽象类或接口中定义一个抽象方法，方法返回类型即为需要注入的原型Bean类型，方法签名为getBean()或其他。

  2. @Lookup方法的实现：Spring在运行时动态生成一个子类，并重写@Lookup方法，通过查找BeanFactory获取原型Bean的实例，并返回给调用方。

  3. @Lookup方法的使用场景：适用于生命周期较短的原型Bean，如请求级别的Controller中需要注入的request或session级别的Bean。

  4. @Lookup方法的注意事项：只能用于抽象类或接口中的方法定义，且必须在单例Bean中使用，否则会出现无限递归调用的问题。

  5. @Lookup方法的扩展：可以使用属性注入的方式实现@Lookup方法的自动注入，通过设置依赖注入模式为Lookup模式，实现递归注入。

以上是@Lookup方法注入的一些知识点，需要在实际项目开发中灵活应用。

@Lookup方法的定义

@Lookup 是一个 Spring 框架中的注解，用于实现方法级别的依赖注入。其作用是在运行时动态的获取一个被容器管理的 Bean 实例。当我们使用 @Lookup 注解时，Spring 容器会动态生成一个继承于当前类的子类，并覆盖被 @Lookup 注解的方法。在运行时，Spring 会拦截这个被覆盖的方法的调用，并返回容器中已经创建好的 Bean 实例。

@Lookup 注解有以下特点：

  1. @Lookup 注解只能用于方法上，并且这个方法必须是抽象方法或者虚方法，即不能是 final 方法。

  2. 被 @Lookup 注解的方法可以有参数，这些参数将会被传递到容器中获取 Bean 的方法中，用于指定需要获取的 Bean。

  3. @Lookup 注解可以和其他的注解一起使用，例如：@Transactional、@Cacheable 等。

下面是一个使用 @Lookup 注解的例子：

@Component
public abstract class AbstractUserService {

    @Lookup
    public abstract User getUser();

    public void showUser() {
        User user = getUser();
        System.out.println(user);
    }
}

在上面的例子中，我们定义了一个抽象类 AbstractUserService，并且在其中使用了 @Lookup 注解，将 getUser() 方法标注为需要动态获取 Bean 实例的方法。在 showUser() 方法中，我们调用了 getUser() 方法，并通过这个方法获取了一个 User 的 Bean 实例，并完成了相关的逻辑处理。

需要注意的是，由于 @Lookup 注解会动态生成一个子类，并覆盖被注解的方法，所以如果我们在一个单例 Bean 中使用 @Lookup 注解，那么每次获取都会返回一个新的 Bean 实例。因此，使用 @Lookup 注解时需要格外注意。

@Lookup方法的实现

@Lookup方法是Spring中一种特殊的方法注入方式，它可以在运行时通过子类重写父类的方法来获取实例化对象。

具体实现步骤如下：

  1. 在父类中定义一个抽象方法，方法返回类型为需要注入的实例对象类型；

  2. 在子类中重写父类中定义的抽象方法，通过方法名获得实例对象，并返回给父类调用。

示例代码如下：

public abstract class CarFactory {
    public abstract Car createCar();

    public void manufactureCar() {
        Car car = createCar();
        // do something with car
    }
}

public class ToyotaFactory extends CarFactory {
    @Lookup
    public ToyotaCar createCar() {
        return null;
    }
}

在上面的例子中，CarFactory是抽象类，其中定义了一个抽象方法createCar()，返回的是需要注入的对象Car类型。在ToyotaFactory中，通过@Lookup注解重写了createCar()方法，获得了实例对象，并返回给父类调用。当需要调用manufactureCar()方法时，会调用子类中的createCar()方法获得实例对象。

需要注意的是，@Lookup注解只能用在抽象方法上，并且该方法不能是static或private方法。同时，@Lookup方法必须要在容器中有对应的Bean实例才能执行，否则会抛出异常。

使用@Lookup方法可以使代码更加灵活，避免了在父类中对注入对象的依赖，同时也可以通过子类来实现特定的逻辑。

@Lookup方法的使用场景

@Lookup方法是Spring框架中的一个注解，它可以用于创建一个新的实例并返回它，也可以用于获取一个现有的实例并返回它。这个注解通常用于单例Bean中引用原型Bean的情况，以及在Bean中引用相同类型的另一个Bean的情况。

下面是@Lookup方法的一些使用场景：

  1. 原型Bean的引用：当我们在一个单例Bean中需要引用一个原型Bean时，可以使用@Lookup方法注解。通过@Lookup方法注解，可以确保每次调用方法时都会创建一个新的原型Bean实例。这种技术对于那些需要通过注入来保持状态的原型Bean非常有用，因为每次调用方法时，都会创建一个新的实例，从而保持了Bean的状态。

  2. 动态获取Bean：当我们需要在运行时动态获取Bean时，可以使用@Lookup方法注解。Spring框架中的BeanFactory和ApplicationContext都提供了getBean方法，但是它们只能在初始化时获取Bean，而无法在运行时动态获取Bean。@Lookup方法注解可以在运行时动态获取Bean，因此在某些情况下非常有用。

  3. 防止循环依赖：当我们需要在两个或多个Bean之间建立循环依赖时，可以使用@Lookup方法注解。循环依赖在Spring框架中是不被允许的，因为它会导致Bean的初始化失败。但是，通过使用@Lookup方法注解，我们可以控制Bean的初始化顺序，从而避免循环依赖。

总之，@Lookup方法注解是Spring框架中一个非常有用的注解，它可以用于创建和获取Bean实例，并有助于解决一些复杂的Bean依赖问题。

@Lookup方法的注意事项

@Lookup方法是Spring框架支持的一种依赖注入方式，它可以在每次调用时动态获取一个bean的实例。但是，使用@Lookup方法时需要注意以下几个事项：

  1. 该方法必须定义在一个抽象类或者一个接口中，并且返回类型必须是一个实现类。

  2. 该方法不能被private、final或static修饰，否则会抛出异常。

  3. 在XML配置文件中声明要被注入的bean的时候，必须要在其scope属性中设置为prototype，因为每次调用@Lookup方法都会创建一个新的实例。

  4. 在使用@Lookup注解时，必须要提供一个方法名，该方法名必须是被注入bean的方法名，否则会抛出异常。

  5. @Lookup方法不能用于注入基本类型或String类型的属性，只能用于注入对象类型的属性。

  6. 如果一个类中存在多个@Lookup方法，需要指定具体的bean名称，可以通过@Qualifier注解或者方法名后添加字符串“Bean”进行区分。

  7. 如果需要在@Lookup方法中注入其他依赖，可以使用@Lazy注解来延迟依赖注入。

总之，在使用@Lookup方法时，需要确保每次调用该方法都能够获取到一个新的实例，否则会导致应用程序出现一些预料之外的问题。同时，在使用@Lookup方法时，需要注意一些细节，以免出现不必要的错误。

@Lookup方法的扩展

@Lookup方法是Spring框架中的一个重要特性，它可以让我们以一种简单而又灵活的方式从容器中获取一个新的Bean实例。当我们使用@Lookup注解时，Spring会动态生成一个代理类，来动态获取Bean实例。在这个代理类中，@Lookup注解会被解析并转换成一个方法，在方法中可以通过容器来获取一个新的Bean实例，并进行返回。

但是，@Lookup方法在使用时存在一些局限性，比如只能在抽象类或者接口中声明，不能在普通类中使用。为了解决这些问题，Spring框架提供了@Lookup注解的扩展，下面我们来详细介绍一下：

  1. 使用@Lookup的三种方式

在介绍@Lookup注解的扩展前，让我们先来回顾一下它的使用方式。@Lookup注解一般有三种使用方式：

第一种方式是在抽象类或者接口中声明一个不带参数的抽象方法，使用@Lookup注解标记这个方法。这时，Spring会在运行时动态生成一个代理类，代理类中会有一个实现这个抽象方法的逻辑，逻辑中会通过容器获取Bean实例并进行返回。

第二种方式是在抽象类或者接口中声明一个带参数的抽象方法，使用@Lookup注解标记这个方法，并在注解中指定要获取Bean实例的名称。这时，Spring会在运行时动态生成一个代理类，并在代理类中实现这个抽象方法。在实现这个方法时，会从容器中获取指定名称的Bean实例，并进行返回。

第三种方式是在普通类中使用@Lookup注解。这时，需要在普通类的@Bean方法中使用@Lookup注解，来获取一个新的Bean实例。这时，Spring会动态生成一个代理类，并在代理类中实现这个@Bean方法。在实现这个方法时，会从容器中获取指定名称的Bean实例，并进行返回。

  1. 使用@Lookup的限制

虽然@Lookup注解非常灵活，但是在使用时也有一些限制。比如，我们只能在抽象类或者接口中使用@Lookup注解，不能在普通类中使用。而且，在同一个类中通常只能使用一种@Lookup注解的方式。这些限制在实际使用中可能会给我们带来一些不便，因此，Spring框架提供了@Lookup注解的扩展来解决这些问题。

  1. @Lookup注解的扩展

在Spring4.1之后的版本中，@Lookup注解提供了一种新的使用方式，即使用@Lookup注解的value属性。在使用value属性时，我们可以在任何普通的方法中使用@Lookup注解，而不仅仅是在@Bean方法中。这时，@Lookup注解的作用是告诉Spring容器，需要获取一个指定名称的Bean实例，并将其注入到当前方法中。

具体来说，我们可以这样定义一个带参数的普通方法：

@Component
public class MyComponent {

  @Lookup("myBean")
  public MyBean getMyBean(MyBean myBean) {
    //这里的myBean会被容器注入，而不是通过new方式创建
    return myBean;
  }
}

在这个例子中，@Lookup注解的value属性指定了要获取的Bean实例的名称。Spring会在运行时动态生成一个代理类，并覆盖这个方法。在覆盖这个方法时，会从容器中获取指定名称的Bean实例，并将其注入到方法参数中。

需要注意的是，在使用@Lookup注解的扩展时，方法的类型可以是任意的，而不仅仅是@Bean方法。这种使用方式提供了更加灵活的注入方式，可以在任何方法中获取Bean实例，而不必受到注解类型或者方法参数的限制。

总结：

通过@Lookup注解的扩展，我们可以在普通类中灵活地获取Bean实例，而不受抽象类或者接口的限制。这种方式提供了更加灵活的注入方式，可以在任何方法中获取Bean实例，而不必受到注解类型或者方法参数的限制。

@Lookup方法的底层工作原理

@Lookup是一个SpringAnnotation，它可以被用于方法级别上。@Lookup的作用是用于解析Bean的实例。这个注解的本质是一个动态代理，它会在方法执行之前调用BeanFactory.getBean()方法去获取Bean的实例。

@Lookup注解的使用方法如下：

首先，将@Lookup与抽象方法一起使用。因为它是一个动态代理，所以抽象方法是必须的。

public abstract class PrototypeBean {
    public void doSomething(){
        System.out.println("PrototypeBean doSomething");
    }

    public abstract SingletonBean getSingletonBean();
}

@Component
public class SingletonBean {
    public void doSomething(){
        System.out.println("SingletonBean doSomething");
    }
}

@Component
public class PrototypeBeanImpl extends PrototypeBean {
    @Lookup
    public SingletonBean getSingletonBean(){
        return null;
    }
}

在上面的示例中，我们使用了@Lookup注解来获取SingletonBean的实例。同时，我们使用了抽象方法来强制执行具体的实现。

当我们在调用getSingletonBean()方法时，Spring会动态生成一个代理类，代理类会在方法被调用之前去获取SingletonBean的实例。这个代理类的工作原理如下：

public class PrototypeBeanImpl$$EnhancerBySpringCGLIB$$9cb3e5ff extends PrototypeBeanImpl {
    @Override
    public SingletonBean getSingletonBean() {
        SingletonBean beanInstance = super.getSingletonBean();
        if(beanInstance == null){
            beanInstance = BeanFactory.getBean(SingletonBean.class);
            setSingletonBean(beanInstance);
        }
        return beanInstance;
    }
}

代理类会先调用父类的方法获取SingletonBean的实例，如果获取到了就直接返回，如果没有获取到，就会调用BeanFactory.getBean()方法去获取实例，并且将实例设置到PrototypeBean中，然后再返回实例。

这个代理类的生成过程是在运行时生成的。每次调用getSingletonBean()方法时，都会生成一个新的代理类。这也意味着代理类的性能会受到影响。如果我们需要频繁调用getSingletonBean()方法，那么可能会导致系统性能下降。

总之，@Lookup注解的主要作用是获取Bean的实例。它可以被用于方法级别上，通过动态代理的方式获取Bean的实例。

@Lookup方法实战的问题与解决方案

@Lookup注解是Spring框架提供的一种注解方式，可以用于解决在原型bean中获取其他bean的问题。在实际开发中，我们经常会遇到需要从Spring容器中获取多个相同类型的bean实例的情况，而这些bean实例都是基于同一个原型bean创建的，如果直接使用@Autowired注解进行依赖注入的话，只能获取到一个bean实例，无法获取其他的实例，这时就需要使用@Lookup注解来帮助我们解决这个问题。

举个例子，假设我们有一个原型bean A，它包含一个方法getB()，用来获取另一个bean B的实例，代码如下：

@Component
@Scope("prototype")
public class A {
 
    public B getB() {
        return null;
    }
}

现在我们需要在另一个bean C中获取多个B的实例，我们可以在C中使用@Autowired注解获取A的实例，并通过A的getB()方法获取B的实例，但是这样只能获取到一个B的实例，无法获取多个。这时可以使用@Lookup注解，将getB()方法的返回类型改为B，并在A类上添加@Lookup注解，代码如下：

@Component
@Scope("prototype")
public class A {
 
    @Lookup
    public B getB() {
        return null;
    }
}

然后在C类中使用getB()方法获取B的实例，Spring会自动创建一个新的B实例并返回，代码如下：

@Component
public class C {
 
    @Autowired
    private A a;
 
    public void test() {
        B b1 = a.getB();
        B b2 = a.getB();
        // ...
    }
}

这样就可以获取到多个B实例了。

但是，@Lookup注解也存在一些问题，例如：

  1. 无法使用构造函数进行注入：@Lookup注解只能用于方法上，无法用于构造函数上，因此无法使用构造函数进行依赖注入。
  2. 不能在非单例bean中使用：@Lookup注解只能应用于单例bean上，无法应用于非单例bean上，因为在非单例bean中，每次调用getB()方法都会创建一个新的bean实例，这可能导致应用程序的性能问题。

为了解决这些问题，可以结合其他的技术来使用@Lookup注解，例如在构造函数中使用@Autowired注解注入父类的一个方法，然后在子类中重写该方法并使用@Lookup注解，这样就可以在非单例bean中使用@Lookup注解了。

总之，虽然@Lookup注解存在一些问题，但在某些场景下，它可以帮助我们解决一些很棘手的问题，因此我们仍然可以充分利用它的优势来优化应用程序的性能。

转自：
https://blog.csdn.net/java_wxid/article/details/131341198