不知道为何，不在两个入参上加上lazy就无法成功启动spring,会报找不到对应的bean。于是加上了lazy标签

@param optionalConsumer
@param optionalPublisher
@param serializer
@return
352331
@Bean
	public RemoteServiceCaller remoteServiceCaller(Optional<EasyTransRpcConsumer> optionalConsumer,
			@Lazy Optional<EasyTransMsgPublisher> optionalPublisher, ObjectSerializer serializer,
			QueueTopicMapper queueTopicMapper) {

		EasyTransRpcConsumer consumer = optionalConsumer.orElseGet(() -> new EasyTransRpcConsumer() {

			@Override
			public <P extends EasyTransRequest<R, ?>, R extends Serializable> R call(String appId, String busCode,
					String innerMethod, Map<String, Object> header, P params) {
				throw new RuntimeException("can not find EasyTransRpcConsumer implement but try handle rpc request");
			}

			@Override
			public <P extends EasyTransRequest<R, ?>, R extends Serializable> void callWithNoReturn(String appId,
					String busCode, String innerMethod, Map<String, Object> header, P params) {
				throw new RuntimeException("can not find EasyTransRpcConsumer implement but try handle rpc request");
			}
		});

		EasyTransMsgPublisher publisher = optionalPublisher.orElseGet(() -> new EasyTransMsgPublisher() {

			@Override
			public EasyTransMsgPublishResult publish(String topic, String tag, String key, Map<String, Object> header,
					byte[] msgByte) {
				throw new RuntimeException("can not find EasyTransMsgPublisher implement but try to publish a message");
			}
		});

		return new RemoteServiceCaller(consumer, publisher, serializer, queueTopicMapper);
	}
188464
@Bean
	@ConditionalOnMissingBean(SpringAwareManagedChannelBuilder.class)
	public SpringAwareManagedChannelBuilder managedChannelBuilder(
			Optional<List<GrpcManagedChannelBuilderCustomizer>> customizers) {
		return new SpringAwareManagedChannelBuilder(customizers);
	}
221589
public JodaBeanSer withConverter(StringConvert converter) {
        JodaBeanUtils.notNull(converter, "converter");
        return new JodaBeanSer(indent, newLine, converter, iteratorFactory, shortTypes, deserializers, includeDerived);
    }
160864
public static <T> Publisher<T> then(Publisher<T> publisher, Consumer<T> consumer) {
        return actual -> publisher.subscribe(new CompletionAwareSubscriber<T>() {
            @Override
            protected void doOnSubscribe(Subscription subscription) {
                actual.onSubscribe(subscription);
            }

            @Override
            protected void doOnNext(T message) {
                try {
                    actual.onNext(message);
                    consumer.accept(message);
                } catch (Throwable e) {
                    onError(e);
                }
            }

            @Override
            protected void doOnError(Throwable t) {
                actual.onError(t);
            }

            @Override
            protected void doOnComplete() {
                actual.onComplete();
            }
        });
    }
1081969
public static <T> T convertPublisher(Object object, Class<T> publisherType) {
        Objects.requireNonNull(object, "Invalid argument [object]: " + object);
        Objects.requireNonNull(object, "Invalid argument [publisherType]: " + publisherType);
        if (object instanceof CompletableFuture) {
            @SuppressWarnings("unchecked") Publisher<T> futurePublisher = (Publisher<T>) Publishers.fromCompletableFuture(() -> ((CompletableFuture) object));
            return ConversionService.SHARED.convert(futurePublisher, publisherType)
                    .orElseThrow(() -> new IllegalArgumentException("Unsupported Reactive type: " + object.getClass()));
        } else {
            return ConversionService.SHARED.convert(object, publisherType)
                    .orElseThrow(() -> new IllegalArgumentException("Unsupported Reactive type: " + object.getClass()));
        }
    }
352210
@Override
    public HttpPublishing getHttpPublishing() {
        if (delegate == null) {
            return this.httpPublishing;
        } else {
            return this.httpPublishing == null ? delegate.getHttpPublishing() : this.httpPublishing;
        }
    }
919382
function createPublisher(broker, configurator) {
    var params = getParams(PublisherConfiguration, configurator);
    return Publisher(broker, params.envelope, params.pipeline, params.routeName, params.routePattern, params.logger);
  }
1008130
@Override
  public <T> T publish(Class<T> beanType, Object id, Transaction transaction) {
    methodCalls.add(MethodCall.of(PUBLISH).with("beanType", beanType).with("id", id));
    return !persistPublish ? null : publish.publish(beanType, id, transaction);
  }
172161
public static PublishRequest createPublishReq(PublishElement el) {
		if (el == null) {
			throw new NullPointerException("el is not allowed to be null");
		}

		PublishRequest ret = createPublishReq();
		ret.addPublishElement(el);
		return ret;
	}
668195
function createSerializer(serializer) {
  var applyFn = function serializationWrapper(v, cb) {
    try {
      return cb ? serializer(v, cb) : serializer(v);
    } catch (e) {
      var modifiedError = new Error('Could not serialize value: ' + e.message);
      modifiedError.value = v;
      modifiedError.serializer = serializer;
      throw modifiedError;
    }
  };

  // We can check how many parameters the function has and activate the asynchronous
  // operation if the number of parameters the function accepts is > 1
  return {
    apply: applyFn,
    async: serializer.length > 1
  };
}
1032105
public static <T> void ifNotNull(T object, Consumer<T> consumer) {
        Optional.ofNullable(object).ifPresent(consumer);
    }
756954
@Override
	public TopicSubscriber createDurableSubscriber(Topic topic, String subscriptionName, String messageSelector, boolean noLocal) throws JMSException
    {
    	return createDurableSubscriber(idProvider.createID(), topic, subscriptionName, messageSelector, noLocal);
    }
421804
public Optional<T> ifPresent(final Consumer<? super T> consumer) {
        if (isPresent()) {
            consumer.accept(get());
        }

        return this;
    }
350462
public static HttpResponse fromPublisher(Publisher<?> contentPublisher) {
        return fromPublisher(defaultHttpHeaders, contentPublisher, HttpHeaders.EMPTY_HEADERS, defaultMapper);
    }
245110
public static <T extends Annotation> Optional<T> getAnnotation( Class<T> annotation, List<? extends HasAnnotations>
            hasAnnotationsList ) {
        for ( HasAnnotations accessor : hasAnnotationsList ) {
            if ( accessor.isAnnotationPresent( annotation ) ) {
                return Optional.of( accessor.getAnnotation( annotation ) );
            }
        }
        return Optional.absent();
    }
649317
@Override
	public TopicPublisher createPublisher(Topic topic) throws JMSException
    {
    	externalAccessLock.readLock().lock();
    	try
		{
	        checkNotClosed();
	        LocalTopicPublisher publisher = new LocalTopicPublisher(this,topic,idProvider.createID());
	        registerProducer(publisher);
	        return publisher;
		}
    	finally
    	{
    		externalAccessLock.readLock().unlock();
    	}
    }
1324157
public static <T> Observable<T> toObservable(EventPublisher<T> eventPublisher) {
        PublishSubject<T> publishSubject = PublishSubject.create();
        Subject<T> serializedSubject = publishSubject.toSerialized();
        eventPublisher.onEvent(serializedSubject::onNext);
        return serializedSubject;
    }