import org.springframework.expression.common.LiteralExpression; //导入依赖的package包/类
@Test
public void testGetValue() throws Exception {
	LiteralExpression lEx = new LiteralExpression("somevalue");
	checkString("somevalue", lEx.getValue());
	checkString("somevalue", lEx.getValue(String.class));
	EvaluationContext ctx = new StandardEvaluationContext();
	checkString("somevalue", lEx.getValue(ctx));
	checkString("somevalue", lEx.getValue(ctx, String.class));
	checkString("somevalue", lEx.getValue(new Rooty()));
	checkString("somevalue", lEx.getValue(new Rooty(), String.class));
	checkString("somevalue", lEx.getValue(ctx, new Rooty()));
	checkString("somevalue", lEx.getValue(ctx, new Rooty(),String.class));
	assertEquals("somevalue", lEx.getExpressionString());
	assertFalse(lEx.isWritable(new StandardEvaluationContext()));
	assertFalse(lEx.isWritable(new Rooty()));
	assertFalse(lEx.isWritable(new StandardEvaluationContext(), new Rooty()));
}
 

import org.springframework.expression.common.LiteralExpression; //导入依赖的package包/类
ProducerConfigurationMessageHandler(KafkaTemplate<byte[], byte[]> kafkaTemplate, String topic,
		ExtendedProducerProperties<KafkaProducerProperties> producerProperties,
		ProducerFactory<byte[], byte[]> producerFactory) {
	super(kafkaTemplate);
	setTopicExpression(new LiteralExpression(topic));
	setMessageKeyExpression(producerProperties.getExtension().getMessageKeyExpression());
	setBeanFactory(KafkaMessageChannelBinder.this.getBeanFactory());
	if (producerProperties.isPartitioned()) {
		SpelExpressionParser parser = new SpelExpressionParser();
		setPartitionIdExpression(parser.parseExpression("headers." + BinderHeaders.PARTITION_HEADER));
	}
	if (producerProperties.getExtension().isSync()) {
		setSync(true);
	}
	this.producerFactory = producerFactory;
}
 

import org.springframework.expression.common.LiteralExpression; //导入依赖的package包/类
@Override
protected ExtendedProducerProperties<KinesisProducerProperties> createProducerProperties() {
	ExtendedProducerProperties<KinesisProducerProperties> producerProperties = new ExtendedProducerProperties<>(
			new KinesisProducerProperties());
	producerProperties.setPartitionKeyExpression(new LiteralExpression("1"));
	producerProperties.getExtension().setSync(true);
	return producerProperties;
}
 

import org.springframework.expression.common.LiteralExpression; //导入依赖的package包/类
@Test
public void testGetValueType() throws Exception {
	LiteralExpression lEx = new LiteralExpression("somevalue");
	assertEquals(String.class, lEx.getValueType());
	assertEquals(String.class, lEx.getValueType(new StandardEvaluationContext()));
	assertEquals(String.class, lEx.getValueType(new Rooty()));
	assertEquals(String.class, lEx.getValueType(new StandardEvaluationContext(), new Rooty()));
	assertEquals(String.class, lEx.getValueTypeDescriptor().getType());
	assertEquals(String.class, lEx.getValueTypeDescriptor(new StandardEvaluationContext()).getType());
	assertEquals(String.class, lEx.getValueTypeDescriptor(new Rooty()).getType());
	assertEquals(String.class, lEx.getValueTypeDescriptor(new StandardEvaluationContext(), new Rooty()).getType());
}
 

import org.springframework.expression.common.LiteralExpression; //导入依赖的package包/类
@Test
@SuppressWarnings("unchecked")
public void testCustomPartitionCountOverridesDefaultIfLarger() throws Exception {
	byte[] testPayload = new byte[2048];
	Arrays.fill(testPayload, (byte) 65);
	KafkaBinderConfigurationProperties binderConfiguration = createConfigurationProperties();
	binderConfiguration.setMinPartitionCount(10);
	Binder binder = getBinder(binderConfiguration);
	QueueChannel moduleInputChannel = new QueueChannel();
	ExtendedProducerProperties<KafkaProducerProperties> producerProperties = createProducerProperties();
	producerProperties.setPartitionCount(10);
	producerProperties.setPartitionKeyExpression(new LiteralExpression("foo"));

	DirectChannel moduleOutputChannel = createBindableChannel("output",
			createProducerBindingProperties(producerProperties));

	ExtendedConsumerProperties<KafkaConsumerProperties> consumerProperties = createConsumerProperties();
	long uniqueBindingId = System.currentTimeMillis();
	Binding<MessageChannel> producerBinding = binder.bindProducer("foo" + uniqueBindingId + ".0",
			moduleOutputChannel, producerProperties);
	Binding<MessageChannel> consumerBinding = binder.bindConsumer("foo" + uniqueBindingId + ".0", null,
			moduleInputChannel, consumerProperties);
	Message<?> message = org.springframework.integration.support.MessageBuilder.withPayload(testPayload)
			.build();
	// Let the consumer actually bind to the producer before sending a msg
	binderBindUnbindLatency();
	moduleOutputChannel.send(message);
	Message<?> inbound = receive(moduleInputChannel);
	assertThat(inbound).isNotNull();
	assertThat((byte[]) inbound.getPayload()).containsExactly(testPayload);

	assertThat(partitionSize("foo" + uniqueBindingId + ".0")).isEqualTo(10);
	producerBinding.unbind();
	consumerBinding.unbind();
}
 

import org.springframework.expression.common.LiteralExpression; //导入依赖的package包/类
@ServiceActivator(inputChannel = "toKafka")
@Bean
public MessageHandler kafkaHandler() throws Exception {
  KafkaProducerMessageHandler<String, String> handler =
      new KafkaProducerMessageHandler<>(kafkaTemplate());
  handler.setTopicExpression(new LiteralExpression(KafkaConfig.getTopic()));
  handler.setMessageKeyExpression(new LiteralExpression(KafkaConfig.getMessageKey()));
  return handler;
}
 

import org.springframework.expression.common.LiteralExpression; //导入依赖的package包/类
@Bean
@ServiceActivator(inputChannel = "producingChannel")
public MessageHandler kafkaMessageHandler() {
  KafkaProducerMessageHandler<String, String> handler =
      new KafkaProducerMessageHandler<>(kafkaTemplate());
  handler.setMessageKeyExpression(new LiteralExpression("kafka-integration"));

  return handler;
}
 

import org.springframework.expression.common.LiteralExpression; //导入依赖的package包/类
@Bean
protected MessageSource<Object> mongoSource() {
    MongoDbMessageSource ms = new MongoDbMessageSource(mongoTemplate, new LiteralExpression(config.getQuery()));
    ms.setCollectionNameExpression(new LiteralExpression(config.getCollection()));
    ms.setEntityClass(String.class);
    return ms;
}
 

import org.springframework.expression.common.LiteralExpression; //导入依赖的package包/类
private Expression detectExpression(String collectionName) {
  Expression expression = EXPRESSION_PARSER.parseExpression(collectionName, ParserContext.TEMPLATE_EXPRESSION);
  return expression instanceof LiteralExpression ? null : expression;
}
 

import org.springframework.expression.common.LiteralExpression; //导入依赖的package包/类
public Expression getComputedNameExpression() {
	return (nameExpression != null ? nameExpression : new LiteralExpression(getName()));
}
 

import org.springframework.expression.common.LiteralExpression; //导入依赖的package包/类
public Expression getUrlExpression() {
	return urlExpression != null ? urlExpression
			: new LiteralExpression(this.url);
}
 

import org.springframework.expression.common.LiteralExpression; //导入依赖的package包/类
public Expression keyExpression() {
	return key != null ? new LiteralExpression(key) : keyExpression;
}
 

import org.springframework.expression.common.LiteralExpression; //导入依赖的package包/类
public Expression queueExpression() {
	return queue != null ? new LiteralExpression(queue) : queueExpression;
}
 

import org.springframework.expression.common.LiteralExpression; //导入依赖的package包/类
public Expression topicExpression() {
	return topic != null ? new LiteralExpression(topic) : topicExpression;
}
 

import org.springframework.expression.common.LiteralExpression; //导入依赖的package包/类
public void setQueueName(String value) {
  setQueueNameExpression(new LiteralExpression(value));
}