Java 类org.apache.camel.BeanInject 实例源码

/**
 * A strategy method to allow implementations to perform some custom JBI
 * based injection of the POJO
 *
 * @param bean the bean to be injected
 */
protected void injectFields(final Object bean, final String beanName) {
    ReflectionHelper.doWithFields(bean.getClass(), new ReflectionHelper.FieldCallback() {
        public void doWith(Field field) throws IllegalArgumentException, IllegalAccessException {
            PropertyInject propertyInject = field.getAnnotation(PropertyInject.class);
            if (propertyInject != null && getPostProcessorHelper().matchContext(propertyInject.context())) {
                injectFieldProperty(field, propertyInject.value(), propertyInject.defaultValue(), bean, beanName);
            }

            BeanInject beanInject = field.getAnnotation(BeanInject.class);
            if (beanInject != null && getPostProcessorHelper().matchContext(beanInject.context())) {
                injectFieldBean(field, beanInject.value(), bean, beanName);
            }

            EndpointInject endpointInject = field.getAnnotation(EndpointInject.class);
            if (endpointInject != null && getPostProcessorHelper().matchContext(endpointInject.context())) {
                injectField(field, endpointInject.uri(), endpointInject.ref(), endpointInject.property(), bean, beanName);
            }

            Produce produce = field.getAnnotation(Produce.class);
            if (produce != null && getPostProcessorHelper().matchContext(produce.context())) {
                injectField(field, produce.uri(), produce.ref(), produce.property(), bean, beanName);
            }
        }
    });
}

protected void setterInjection(Method method, Object bean, String beanName) {
    PropertyInject propertyInject = method.getAnnotation(PropertyInject.class);
    if (propertyInject != null && getPostProcessorHelper().matchContext(propertyInject.context())) {
        setterPropertyInjection(method, propertyInject.value(), propertyInject.defaultValue(), bean, beanName);
    }

    BeanInject beanInject = method.getAnnotation(BeanInject.class);
    if (beanInject != null && getPostProcessorHelper().matchContext(beanInject.context())) {
        setterBeanInjection(method, beanInject.value(), bean, beanName);
    }

    EndpointInject endpointInject = method.getAnnotation(EndpointInject.class);
    if (endpointInject != null && getPostProcessorHelper().matchContext(endpointInject.context())) {
        setterInjection(method, bean, beanName, endpointInject.uri(), endpointInject.ref(), endpointInject.property());
    }

    Produce produce = method.getAnnotation(Produce.class);
    if (produce != null && getPostProcessorHelper().matchContext(produce.context())) {
        setterInjection(method, bean, beanName, produce.uri(), produce.ref(), produce.property());
    }
}

protected void setterInjection(Method method, Object bean, String beanName) {
    PropertyInject propertyInject = method.getAnnotation(PropertyInject.class);
    if (propertyInject != null && matchContext(propertyInject.context())) {
        setterPropertyInjection(method, propertyInject.value(), propertyInject.defaultValue(), bean, beanName);
    }

    BeanInject beanInject = method.getAnnotation(BeanInject.class);
    if (beanInject != null && matchContext(beanInject.context())) {
        setterBeanInjection(method, beanInject.value(), bean, beanName);
    }

    EndpointInject endpointInject = method.getAnnotation(EndpointInject.class);
    if (endpointInject != null && matchContext(endpointInject.context())) {
        setterInjection(method, bean, beanName, endpointInject.uri(), endpointInject.ref(), endpointInject.property());
    }

    Produce produce = method.getAnnotation(Produce.class);
    if (produce != null && matchContext(produce.context())) {
        setterInjection(method, bean, beanName, produce.uri(), produce.ref(), produce.property());
    }
}

private void processAnnotatedType(@Observes ProcessAnnotatedType<?> pat) {
    if (pat.getAnnotatedType().isAnnotationPresent(Vetoed.class)) {
        pat.veto();
    }
    if (hasAnnotation(pat.getAnnotatedType(), Converter.class)) {
        converters.add(pat.getAnnotatedType().getJavaClass());
    }
    if (hasAnnotation(pat.getAnnotatedType(), BeanInject.class, Consume.class, EndpointInject.class, Produce.class, PropertyInject.class)) {
        camelBeans.add(pat.getAnnotatedType());
    }
    if (hasAnnotation(pat.getAnnotatedType(), Consume.class)) {
        eagerBeans.add(pat.getAnnotatedType());
    }
    if (hasAnnotation(pat.getAnnotatedType(), ImportResource.class)) {
        resources.add(pat.getAnnotatedType().getAnnotation(ImportResource.class));
    }
}

public void testBeanInject() throws Exception {
    CamelPostProcessorHelper helper = new CamelPostProcessorHelper(context);

    MyBeanInjectBean bean = new MyBeanInjectBean();
    Field field = bean.getClass().getField("foo");

    BeanInject beanInject = field.getAnnotation(BeanInject.class);
    Class<?> type = field.getType();
    Object value = helper.getInjectionBeanValue(type, beanInject.value());
    field.set(bean, value);

    String out = bean.doSomething("World");
    assertEquals("Hello World", out);
}

public void testBeanInjectByType() throws Exception {
    CamelPostProcessorHelper helper = new CamelPostProcessorHelper(context);

    MyBeanInjectByTypeBean bean = new MyBeanInjectByTypeBean();
    Field field = bean.getClass().getField("foo");

    BeanInject beanInject = field.getAnnotation(BeanInject.class);
    Class<?> type = field.getType();
    Object value = helper.getInjectionBeanValue(type, beanInject.value());
    field.set(bean, value);

    String out = bean.doSomething("Camel");
    assertEquals("Hello Camel", out);
}

/**
 * A strategy method to allow implementations to perform some custom JBI
 * based injection of the POJO
 *
 * @param bean the bean to be injected
 */
protected void injectFields(final Object bean, final String beanName) {
    Class<?> clazz = bean.getClass();
    do {
        Field[] fields = clazz.getDeclaredFields();
        for (Field field : fields) {
            PropertyInject propertyInject = field.getAnnotation(PropertyInject.class);
            if (propertyInject != null && matchContext(propertyInject.context())) {
                injectFieldProperty(field, propertyInject.value(), propertyInject.defaultValue(), bean, beanName);
            }

            BeanInject beanInject = field.getAnnotation(BeanInject.class);
            if (beanInject != null && matchContext(beanInject.context())) {
                injectFieldBean(field, beanInject.value(), bean, beanName);
            }

            EndpointInject endpointInject = field.getAnnotation(EndpointInject.class);
            if (endpointInject != null && matchContext(endpointInject.context())) {
                injectField(field, endpointInject.uri(), endpointInject.ref(), endpointInject.property(), bean, beanName);
            }

            Produce produce = field.getAnnotation(Produce.class);
            if (produce != null && matchContext(produce.context())) {
                injectField(field, produce.uri(), produce.ref(), produce.property(), bean, beanName);
            }
        }
        clazz = clazz.getSuperclass();
    } while (clazz != null && clazz != Object.class);
}

private boolean shouldDeployDefaultCamelContext(Set<Bean<?>> beans) {
    return beans.stream()
        // Is there a Camel bean with the @Default qualifier?
        // Excluding internal components...
        .filter(bean -> !bean.getBeanClass().getPackage().equals(getClass().getPackage()))
        .filter(hasType(CamelContextAware.class).or(hasType(Component.class))
            .or(hasType(RouteContainer.class).or(hasType(RoutesBuilder.class))))
        .map(Bean::getQualifiers)
        .flatMap(Set::stream)
        .filter(isEqual(DEFAULT))
        .findAny()
        .isPresent()
        // Or a bean with Camel annotations?
        || concat(camelBeans.stream().map(AnnotatedType::getFields),
                  camelBeans.stream().map(AnnotatedType::getMethods))
        .flatMap(Set::stream)
        .map(Annotated::getAnnotations)
        .flatMap(Set::stream)
        .filter(isAnnotationType(Consume.class).and(a -> ((Consume) a).context().isEmpty())
            .or(isAnnotationType(BeanInject.class).and(a -> ((BeanInject) a).context().isEmpty()))
            .or(isAnnotationType(EndpointInject.class).and(a -> ((EndpointInject) a).context().isEmpty()))
            .or(isAnnotationType(Produce.class).and(a -> ((Produce) a).context().isEmpty()))
            .or(isAnnotationType(PropertyInject.class).and(a -> ((PropertyInject) a).context().isEmpty())))
        .findAny()
        .isPresent()
        // Or an injection point for Camel primitives?
        || beans.stream()
        // Excluding internal components...
        .filter(bean -> !bean.getBeanClass().getPackage().equals(getClass().getPackage()))
        .map(Bean::getInjectionPoints)
        .flatMap(Set::stream)
        .filter(ip -> getRawType(ip.getType()).getName().startsWith("org.apache.camel"))
        .map(InjectionPoint::getQualifiers)
        .flatMap(Set::stream)
        .filter(isAnnotationType(Uri.class).or(isAnnotationType(Mock.class)).or(isEqual(DEFAULT)))
        .findAny()
        .isPresent();
}

private boolean shouldDeployDefaultCamelContext(BeanManager manager, Set<SyntheticBean<?>> beans) {
    // TODO: find a way to 'pre-filter' by refining the bean types passed to the bean manager
    return concat(manager.getBeans(Object.class, ANY).stream(), beans.stream())
        // Is there a Camel bean with the @Default qualifier?
        // Excluding internal components...
        .filter(bean -> !bean.getBeanClass().getPackage().equals(getClass().getPackage()))
        .filter(hasType(CamelContextAware.class).or(hasType(Component.class))
            .or(hasType(RouteContainer.class).or(hasType(RoutesBuilder.class))))
        .map(Bean::getQualifiers)
        .flatMap(Set::stream)
        .anyMatch(isEqual(DEFAULT))
        // Or a bean with Camel annotations?
        || concat(camelBeans.stream().map(AnnotatedType::getFields),
                  camelBeans.stream().map(AnnotatedType::getMethods))
        .flatMap(Set::stream)
        .map(Annotated::getAnnotations)
        .flatMap(Set::stream)
        .anyMatch(isAnnotationType(Consume.class).and(a -> ((Consume) a).context().isEmpty())
            .or(isAnnotationType(BeanInject.class).and(a -> ((BeanInject) a).context().isEmpty()))
            .or(isAnnotationType(EndpointInject.class).and(a -> ((EndpointInject) a).context().isEmpty()))
            .or(isAnnotationType(Produce.class).and(a -> ((Produce) a).context().isEmpty()))
            .or(isAnnotationType(PropertyInject.class).and(a -> ((PropertyInject) a).context().isEmpty())))
        // Or an injection point for Camel primitives?
        || concat(manager.getBeans(Object.class, ANY).stream(), beans.stream())
        // Excluding internal components...
        .filter(bean -> !bean.getBeanClass().getPackage().equals(getClass().getPackage()))
        .map(Bean::getInjectionPoints)
        .flatMap(Set::stream)
        .filter(ip -> getRawType(ip.getType()).getName().startsWith("org.apache.camel"))
        .map(InjectionPoint::getQualifiers)
        .flatMap(Set::stream)
        .anyMatch(isAnnotationType(Uri.class).or(isEqual(DEFAULT)));
}

@BeanInject
public void setInjectBeanMethod(PropertyInjectBean bean) {
    injectBeanMethod = bean;
}

@BeanInject
public void setInjectBeanMethod(PropertyInjectBean bean) {
    injectBeanMethod = bean;
}

private void camelAnnotations(@Observes @WithAnnotations({BeanInject.class, Consume.class,
    EndpointInject.class, Produce.class, PropertyInject.class}) ProcessAnnotatedType<?> pat) {
    camelBeans.add(pat.getAnnotatedType());
}