Fork me on GitHub

Spring Lookup注解

发表于 | 分类于 | | 阅读次数:
字数统计: 1,574 | 阅读时长 ≈ 7

前言

今天我们看下Spring的Lookup注解，这个注解可以使Spring替换一个bean原有的，获取其它对象具体的方法，并自动返回在容器中的查找结果。

正文

在了解它之前，我们先来看下一个例子。

我们有一个Bean，TestClassB，它是多例的。大致如下：

1
2
3
4
5
6
7
@Component
@Scope(value = SCOPE_PROTOTYPE)
public class TestClassB {
    public void printClass() {
        System.out.println("This is TestClass B: " + this);
    }
}

现在一个单例Bean，TestClassA，使用到了TestClassB，代码大致如下：

1
2
3
4
5
6
7
8
9
10
@Component
public class TestClassA {
    @Autowired
    private TestClassB testClassB;

    public void printClass() {
        System.out.println("This is TestClass A: " + this);
        testClassB.printClass();
    }
}

我们进行下测试，可以发现一些问题。

1
2
3
4
5
6
7
8
9
10
11
12
@RunWith(SpringRunner.class)
@SpringBootTest
public class LookUpTests {
    @Autowired
    private TestClassA testClassA;
    @Test
    public void test(){
        for (int i=0;i<5;i++){
            testClassA.printClass();
        }
    }
}

可以看到输出结果：

1
2
3
4
5
6
7
8
9
10
This is TestClass A: com.zwt.demo.util.TestClassA@2c768ada
This is TestClass B: com.zwt.demo.util.TestClassB@c1fca2a
This is TestClass A: com.zwt.demo.util.TestClassA@2c768ada
This is TestClass B: com.zwt.demo.util.TestClassB@c1fca2a
This is TestClass A: com.zwt.demo.util.TestClassA@2c768ada
This is TestClass B: com.zwt.demo.util.TestClassB@c1fca2a
This is TestClass A: com.zwt.demo.util.TestClassA@2c768ada
This is TestClass B: com.zwt.demo.util.TestClassB@c1fca2a
This is TestClass A: com.zwt.demo.util.TestClassA@2c768ada
This is TestClass B: com.zwt.demo.util.TestClassB@c1fca2a

对于TestClassA，它因为是单例，所以一直是一个实例，我们是可以理解的，但是对于TestClassB，我们明明设置了多例，但是我们发现它仍是一个实例，相当于单例。

对于这种情况的产生，很好理解，因为TestClassA为单例，因此TestClassB只有一次注入的机会，即在生成单例TestClassA的时候，因此导致了TestClassB的多例不体现，仍相当于个单例模式。

如果我们要求TestClassB必须为多例的，那么上面这种情况是会出现问题的。

如何解决这种问题呢？

其实我们最常用的一种方法是拿到SpringContext，然后手动获取Bean。代码大致如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
@Component
public class SpringUtils implements ApplicationContextAware {
    private static ApplicationContext applicationContext;
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        SpringUtils.applicationContext=applicationContext;
    }
    public static ApplicationContext getApplicationContext(){
        return applicationContext;
    }
    public static <T> T getBean(Class<T> clazz){
        return applicationContext.getBean(clazz);
    }
}

同时TestClassA里的方法如下：

1
2
3
4
5
6
7
@Component
public class TestClassA {
    public void printClass(){
        System.out.println("This is TestClass A: " + this);
        SpringUtils.getBean(TestClassB.class).printClass();
    }
}

可以看到输出结果,TestClassB已经是多例的了。

1
2
3
4
5
6
7
8
9
10
This is TestClass A: com.zwt.demo.util.TestClassA@7c447c76
This is TestClass B: com.zwt.demo.util.TestClassB@1640c151
This is TestClass A: com.zwt.demo.util.TestClassA@7c447c76
This is TestClass B: com.zwt.demo.util.TestClassB@5d5b5fa7
This is TestClass A: com.zwt.demo.util.TestClassA@7c447c76
This is TestClass B: com.zwt.demo.util.TestClassB@2a32fb6
This is TestClass A: com.zwt.demo.util.TestClassA@7c447c76
This is TestClass B: com.zwt.demo.util.TestClassB@6107165
This is TestClass A: com.zwt.demo.util.TestClassA@7c447c76
This is TestClass B: com.zwt.demo.util.TestClassB@164a62bf

当然也可以让TestClassA继承ApplicationContextAware直接拿到ApplicationContext，然后获取TestClassB。

这种方式在项目使用中还是比较多的，也是很方便的。

还有其他方法吗？

下面我们来说另一种方式，当然就是我们今天的主角，Lookup注解。那具体如何使用呢，我们来看下。

1
2
3
4
5
6
7
8
9
10
11
@Component
public class TestClassA {
    @Lookup
    public TestClassB getTestClassB() {
        return null;
    }
    public void printClass() {
        System.out.println("This is TestClass A: " + this);
        getTestClassB().printClass();
    }
}

我们运行测试类，可以看到输出结果：

1
2
3
4
5
6
7
8
9
10
This is TestClass A: com.zwt.demo.util.TestClassA$$EnhancerBySpringCGLIB$$a967ae38@5a00eb1e
This is TestClass B: com.zwt.demo.util.TestClassB@1aac188d
This is TestClass A: com.zwt.demo.util.TestClassA$$EnhancerBySpringCGLIB$$a967ae38@5a00eb1e
This is TestClass B: com.zwt.demo.util.TestClassB@7026b7ee
This is TestClass A: com.zwt.demo.util.TestClassA$$EnhancerBySpringCGLIB$$a967ae38@5a00eb1e
This is TestClass B: com.zwt.demo.util.TestClassB@2d23faef
This is TestClass A: com.zwt.demo.util.TestClassA$$EnhancerBySpringCGLIB$$a967ae38@5a00eb1e
This is TestClass B: com.zwt.demo.util.TestClassB@7cb8437d
This is TestClass A: com.zwt.demo.util.TestClassA$$EnhancerBySpringCGLIB$$a967ae38@5a00eb1e
This is TestClass B: com.zwt.demo.util.TestClassB@62a4417

发现TestClassB是多例的，可是我们根据上面的代码，感觉TestClassB返回应该不是null么。

当然，这就要来了解下Lookup注解了，我们分析一下它的源码：

1
2
3
4
5
6
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Lookup {
	String value() default "";
}

可以看到该注解作用于方法上，有一个参数value，这个值可以指定要look up的Bean的名字。如果不指定，就会默认方法返回的类型寻找Bean并进行Look up。

我们在Spring源码中寻找下该注解 @Lookup，会发现只有一个地方使用到了该注解。

在AutowiredAnnotationBeanPostProcessor类的determineCandidateConstructors方法里。该方法部分内容如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
public Constructor<?>[] determineCandidateConstructors(Class<?> beanClass, final String beanName)
		throws BeanCreationException {

	// Let's check for lookup methods here..
	if (!this.lookupMethodsChecked.contains(beanName)) {
		try {
			ReflectionUtils.doWithMethods(beanClass, new ReflectionUtils.MethodCallback() {
				@Override
				public void doWith(Method method) throws IllegalArgumentException, IllegalAccessException {
					Lookup lookup = method.getAnnotation(Lookup.class);
					if (lookup != null) {
						LookupOverride override = new LookupOverride(method, lookup.value());
						try {
							RootBeanDefinition mbd = (RootBeanDefinition) beanFactory.getMergedBeanDefinition(beanName);
							mbd.getMethodOverrides().addOverride(override);
						}
						catch (NoSuchBeanDefinitionException ex) {
							throw new BeanCreationException(beanName,
									"Cannot apply @Lookup to beans without corresponding bean definition");
						}
					}
				}
			});
		}
		catch (IllegalStateException ex) {
			throw new BeanCreationException(beanName, "Lookup method resolution failed", ex);
		}
		catch (NoClassDefFoundError err) {
			throw new BeanCreationException(beanName, "Failed to introspect bean class [" + beanClass.getName() +
					"] for lookup method metadata: could not find class that it depends on", err);
		}
		this.lookupMethodsChecked.add(beanName);
	}
       //部分代码略......

可以看到Spring会首先判断该Bean是否有Lookup注解的方法，现在缓存里看，缓存没有的话会尝试获取方法上的Lookup注解，如果存在，拿到需要重写（覆盖）的方法信息放入LookupOverride，最后为RootBeanDefinition添加LookupOverride的属性。这个方法最终会被AbstractAutowireCapableBeanFactory类中的createBeanInstance方法调用，去生成新的Bean并重写，实现改变Bean的效果。

因此原理大致为：方法执行返回的对象，使用 Spring 内原有的这类对象替换，通过改变方法返回值来动态改变方法。内部实现为使用 cglib 方法，重新生成子类，重写配置的方法和返回对象，达到动态改变的效果。因此Bean的多列特性也被体现了。

总结

通过解决一个单例Bean（无状态Bean）调用多例Bean（有状态Bean）的问题，我们了解了Lookup注解的一些简单用法，对Spring也有了一些深入的认识。




-------------文章结束啦 ~\(≧▽≦)/~ 感谢您的阅读-------------

SakuraTears wechat
扫一扫关注我的公众号
您的支持就是我创作的动力！
0%