import org.springframework.tuple.Tuple; //导入依赖的package包/类
@Test
public void longArray() {
	long[][] inLongArray = new long[2][2];
	inLongArray[0][0] = 0;
	inLongArray[0][1] = 1;
	inLongArray[1][0] = 2;
	inLongArray[1][1] = 3;

	Tensor inTensor = Tensor.create(inLongArray);

	Tuple tuple = TensorTupleConverter.toTuple(inTensor);
	Tensor outTensor = TensorTupleConverter.toTensor(tuple);

	long[][] outLongArray = new long[2][2];
	outLongArray = outTensor.copyTo(outLongArray);

	compareTensors(inTensor, outTensor);
	assertArrayEquals(inLongArray, outLongArray);
}
 

import org.springframework.tuple.Tuple; //导入依赖的package包/类
public static Tuple toTuple(Tensor tensor) {
	ByteBuffer buffer = ByteBuffer.allocate(tensor.numBytes());
	tensor.writeTo(buffer);

	// Retrieve all bytes in the buffer
	buffer.clear();
	byte[] bytes = new byte[buffer.capacity()];

       buffer.get(bytes, 0, bytes.length);

	return TupleBuilder.tuple()
			.put(TF_DATA_TYPE, tensor.dataType().name())
			.put(TF_SHAPE, tensor.shape())
			.put(TF_VALUE, bytes)
			.build();
}
 

import org.springframework.tuple.Tuple; //导入依赖的package包/类
public static Tuple toTuple(Tensor tensor) {
	ByteBuffer buffer = ByteBuffer.allocate(tensor.numBytes());
	tensor.writeTo(buffer);

	// Retrieve all bytes in the buffer
	buffer.clear();
	byte[] bytes = new byte[buffer.capacity()];

	buffer.get(bytes, 0, bytes.length);

	return TupleBuilder.tuple()
			.put(TF_DATA_TYPE, tensor.dataType().name())
			.put(TF_SHAPE, tensor.shape())
			.put(TF_VALUE, bytes)
			.build();
}
 

import org.springframework.tuple.Tuple; //导入依赖的package包/类
@Test
public void testInsertion() {
	Tuple tupleA = TupleBuilder.tuple().of("a", "hello1", "b", 42);
	Tuple tupleB = TupleBuilder.tuple().of("a", "hello2", "b", null);
	Tuple tupleC = TupleBuilder.tuple().of("a", "hello3");
	channels.input().send(MessageBuilder.withPayload(tupleA).build());
	channels.input().send(MessageBuilder.withPayload(tupleB).build());
	channels.input().send(MessageBuilder.withPayload(tupleC).build());
	Assert.assertThat(jdbcOperations.queryForObject(
			"select count(*) from messages where a = ? and b = ?",
			Integer.class, tupleA.getString("a"), tupleA.getInt("b")), is(1));
	Assert.assertThat(jdbcOperations.queryForObject(
			"select count(*) from messages where a = ? and b IS NULL",
			Integer.class, tupleB.getString("a")), is(1));
	Assert.assertThat(jdbcOperations.queryForObject(
			"select count(*) from messages where a = ? and b IS NULL",
			Integer.class, tupleC.getString("a")), is(1));
}
 

import org.springframework.tuple.Tuple; //导入依赖的package包/类
@Override
public GatewayFilter apply(Tuple args) {
	//TODO: allow args to override properties

	return (exchange, chain) -> {
		HttpHeaders headers = exchange.getResponse().getHeaders();

		//TODO: allow header to be disabled
		headers.add(X_XSS_PROTECTION_HEADER, properties.getXssProtectionHeader());
		headers.add(STRICT_TRANSPORT_SECURITY_HEADER, properties.getStrictTransportSecurity());
		headers.add(X_FRAME_OPTIONS_HEADER, properties.getFrameOptions());
		headers.add(X_CONTENT_TYPE_OPTIONS_HEADER, properties.getContentTypeOptions());
		headers.add(REFERRER_POLICY_HEADER, properties.getReferrerPolicy());
		headers.add(CONTENT_SECURITY_POLICY_HEADER, properties.getContentSecurityPolicy());
		headers.add(X_DOWNLOAD_OPTIONS_HEADER, properties.getDownloadOptions());
		headers.add(X_PERMITTED_CROSS_DOMAIN_POLICIES_HEADER, properties.getPermittedCrossDomainPolicies());

		return chain.filter(exchange);
	};
}
 

import org.springframework.tuple.Tuple; //导入依赖的package包/类
private List<GatewayFilter> loadGatewayFilters(String id, List<FilterDefinition> filterDefinitions) {
	List<GatewayFilter> filters = filterDefinitions.stream()
			.map(definition -> {
				GatewayFilterFactory filter = this.gatewayFilterFactories.get(definition.getName());
				if (filter == null) {
					throw new IllegalArgumentException("Unable to find GatewayFilterFactory with name " + definition.getName());
				}
				Map<String, String> args = definition.getArgs();
				if (logger.isDebugEnabled()) {
					logger.debug("RouteDefinition " + id + " applying filter " + args + " to " + definition.getName());
				}

				Tuple tuple = getTuple(filter, args, this.parser, this.beanFactory);

				return filter.apply(tuple);
			})
			.collect(Collectors.toList());

	ArrayList<GatewayFilter> ordered = new ArrayList<>(filters.size());
	for (int i = 0; i < filters.size(); i++) {
		ordered.add(new OrderedGatewayFilter(filters.get(i), i+1));
	}

	return ordered;
}
 

import org.springframework.tuple.Tuple; //导入依赖的package包/类
@Test
public void testGetTupleWithSpel() {
	parser = new SpelExpressionParser();
	ArgumentHints argumentHints = new ArgumentHints() {
		@Override
		public List<String> argNames() {
			return Arrays.asList("bean", "arg1");
		}
	};
	Map<String, String> args = new HashMap<>();
	args.put("bean", "#{@foo}");
	args.put("arg1", "val1");
	Tuple tuple = RouteDefinitionRouteLocator.getTuple(argumentHints, args, parser, this.beanFactory);
	assertThat(tuple).isNotNull();
	assertThat(tuple.getValue("bean", Integer.class)).isEqualTo(42);
	assertThat(tuple.getString("arg1")).isEqualTo("val1");
}
 

import org.springframework.tuple.Tuple; //导入依赖的package包/类
private MutableMessage<?> convertToMutable(Message<?> input) throws Exception{
    Object payload = input.getPayload();
    if (payload instanceof Tuple && !(payload instanceof MutableTuple)) {
            payload = TupleBuilder.mutableTuple().putAll((Tuple) payload).build();
    }
    else if (payload instanceof String){
		String strPayload = input.getPayload().toString();
		Iterator<Entry<String, Object>> objects = new ObjectMapper().readValue(strPayload, Map.class).entrySet().iterator();
		TupleBuilder tuples = TupleBuilder.mutableTuple();
		while (objects.hasNext()){
			Entry<String,Object> entry = objects.next();
			tuples.put(entry.getKey(), entry.getValue());
		}        	
		payload = tuples.build();
    }
    return new MutableMessage<>(payload, input.getHeaders());
}
 

import org.springframework.tuple.Tuple; //导入依赖的package包/类
@ServiceActivator(inputChannel=Sink.INPUT)
public void process(Message<?> message) {
	Object payload = message.getPayload();
	if (payload instanceof String) {
		try {
			payload = jsonToTupleTransformer.transformPayload(payload.toString());
		}
		catch (Exception e) {
			throw new MessageTransformationException(message, e.getMessage(), e);
		}
	}
	if (payload instanceof Tuple) {
		processTuple(computeMetricName(message), (Tuple) payload);
	}
	else {
		processPojo(computeMetricName(message), payload);
	}
}
 

import org.springframework.tuple.Tuple; //导入依赖的package包/类
@ServiceActivator(inputChannel = Sink.INPUT)
public void process(Message<?> message) {
	Object payload = message.getPayload();
	if (payload instanceof String) {
		try {
			payload = jsonToTupleTransformer.transformPayload(payload.toString());
		}
		catch (Exception e) {
			throw new MessageTransformationException(message, e.getMessage(), e);
		}
	}
	if (payload instanceof Tuple) {
		processTuple(computeMetricName(message), (Tuple) payload);
	}
	else {
		processPojo(computeMetricName(message), payload);
	}
}
 

import org.springframework.tuple.Tuple; //导入依赖的package包/类
@Override
protected Object convertToInternal(Object payload, MessageHeaders headers, Object conversionHint) {
	Tuple t = (Tuple) payload;
	String json;
	if (this.prettyPrint) {
		try {
			Object tmp = this.objectMapper.readValue(t.toString(), Object.class);
			json = this.objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(tmp);
		}
		catch (IOException e) {
			this.logger.error(e.getMessage(), e);
			return null;
		}
	}
	else {
		json = t.toString();
	}
	return json.getBytes();
}
 

import org.springframework.tuple.Tuple; //导入依赖的package包/类
@Test
public void testSendTuple() throws Exception {
	try (ConfigurableApplicationContext context = SpringApplication.run(
			SourceApplication.class, "--server.port=0",
			"--spring.jmx.enabled=false",
			"--spring.cloud.stream.bindings.output.contentType=application/x-spring-tuple")) {
		MessageCollector collector = context.getBean(MessageCollector.class);
		Source source = context.getBean(Source.class);
		Tuple tuple = TupleBuilder.tuple().of("foo","bar");
		source.output().send(MessageBuilder.withPayload(tuple).build());
		Message<byte[]> message = (Message<byte[]>) collector
				.forChannel(source.output()).poll(1, TimeUnit.SECONDS);
		assertThat(message.getHeaders().get(MessageHeaders.CONTENT_TYPE, MimeType.class)
				.includes(MessageConverterUtils.X_SPRING_TUPLE));
		assertThat(TupleBuilder.fromString(new String(message.getPayload()))).isEqualTo(tuple);
	}
}
 

import org.springframework.tuple.Tuple; //导入依赖的package包/类
@Override
public GatewayFilter apply(Tuple args) {
	return (exchange, chain) -> exchange.getSession()
		.map(webSession -> {
			log.debug("Session id: " + webSession.getId());
			webSession.getAttributes().entrySet()
				.forEach(entry ->
				log.debug(entry.getKey() + " => " +
									entry.getValue()));
			return webSession;
		})
		.map(WebSession::save)
		.then(chain.filter(exchange));
}
 

import org.springframework.tuple.Tuple; //导入依赖的package包/类
@Bean
@ConditionalOnMissingBean(name = "tensorflowOutputConverter")
public TensorflowOutputConverter tensorflowOutputConverter() {
	// Default implementations serializes the Tensor into Tuple
	return new TensorflowOutputConverter<Tuple>() {
		@Override
		public Tuple convert(Tensor tensor, Map<String, Object> processorContext) {
			return TensorTupleConverter.toTuple(tensor);
		}
	};
}
 

import org.springframework.tuple.Tuple; //导入依赖的package包/类
private Tensor toFeedTensor(Object value) {
	if (value instanceof Tensor) {
		return (Tensor) value;
	}
	else if (value instanceof Tuple) {
		return TensorTupleConverter.toTensor((Tuple) value);
	}

	return Tensor.create(value);
}
 

import org.springframework.tuple.Tuple; //导入依赖的package包/类
public static Tensor toTensor(Tuple tuple) {
	DataType dataType = DataType.valueOf(tuple.getString(TF_DATA_TYPE));
	long[] shape = (long[]) tuple.getValue(TF_SHAPE);
	byte[] bytes = (byte[]) tuple.getValue(TF_VALUE);

	return Tensor.create(dataType, shape, ByteBuffer.wrap(bytes));
}
 

import org.springframework.tuple.Tuple; //导入依赖的package包/类
@Test(expected = MessageHandlingException.class)
public void testEvaluationIncorrectTupleInput() {
	Tuple incompleteInputTuple = TupleBuilder.tuple()
			//	missing data type
			.put(TF_SHAPE, new long[0])
			.put(TF_VALUE, new byte[0])
			.build();
	testEvaluation(incompleteInputTuple);
}
 

import org.springframework.tuple.Tuple; //导入依赖的package包/类
@Test(expected = MessageHandlingException.class)
public void testEvaluationIncorrectTupleInput() throws InterruptedException {
	Tuple incompleteInputTuple = TupleBuilder.tuple()
			//	missing data type
			.put(TF_SHAPE, new long[0])
			.put(TF_VALUE, new byte[0])
			.build();
	testEvaluation(incompleteInputTuple);
}
 

import org.springframework.tuple.Tuple; //导入依赖的package包/类
@Override
protected void testEvaluation(Object input) throws InterruptedException {

	Map<String, Object> inMap = new HashMap<>();
	inMap.put("Placeholder", input);

	Message<?> inputMessage = MessageBuilder
			.withPayload("Dummy Payload")
			.setHeader("myInputData", inMap)
			.setHeader("passthrough", "passthrough")
			.build();

	channels.input().send(inputMessage);

	Message<?> outputMessage = messageCollector.forChannel(channels.output()).poll(10, TimeUnit.SECONDS);

	assertThat((String) outputMessage.getHeaders().get("passthrough"), equalTo("passthrough"));
	assertThat(((Tuple) outputMessage.getPayload()).getFloat("add"), equalTo(0.29999298f));

	assertThat((String) inputMessage.getPayload(), equalTo("Dummy Payload"));
}
 

import org.springframework.tuple.Tuple; //导入依赖的package包/类
@Bean
@ConditionalOnMissingBean(name = "tensorflowOutputConverter")
public TensorflowOutputConverter tensorflowOutputConverter() {
	// Default implementations serializes the Tensor into Tuple
	return new TensorflowOutputConverter<Tuple>() {

		@Override
		public Tuple convert(Tensor tensor, Map<String, Object> processorContext) {
			return TensorTupleConverter.toTuple(tensor);
		}
	};
}