SpringCloud/spring-functions-catalog
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Prefix function names with spring-

Browse Source 
* Add `spring-` prefix to function names

Fixes: #9

This commit renames each sub-module in the common, consumer, function
and supplier groups with a prefix of `spring-`.

* Update README.adoc links to new prefixed names
This commit is contained in:
Chris Bono
2024-01-02 13:07:00 -06:00
committed by GitHub
parent b9a3e59074
commit 84e732da08
596 changed files with 146 additions and 147 deletions
Download Patch File Download Diff File Expand all files Collapse all files

51
function/spring-payload-converter-function/src/main/java/functions/ByteArrayTextToString.java Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2020-2020 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package functions;
import java.util.function.Function;
import org.springframework.messaging.Message;
import org.springframework.messaging.MessageHeaders;
import org.springframework.messaging.support.MessageBuilder;
import org.springframework.util.MimeTypeUtils;
/**
*
* @author Christian Tzolov
*/
public class ByteArrayTextToString implements Function<Message<?>, Message<?>> {
@Override
public Message<?> apply(Message<?> message) {
if (message.getPayload() instanceof byte[]) {
final MessageHeaders headers = message.getHeaders();
String contentType = headers.containsKey(MessageHeaders.CONTENT_TYPE)
? headers.get(MessageHeaders.CONTENT_TYPE).toString()
: MimeTypeUtils.APPLICATION_JSON_VALUE;
if (contentType.contains("text") || contentType.contains("json") || contentType.contains("x-spring-tuple")) {
message = MessageBuilder.withPayload(new String(((byte[]) message.getPayload())))
.copyHeaders(message.getHeaders())
.build();
}
}
return message;
}
}

80
function/spring-payload-converter-function/src/main/java/functions/JsonBytesToMap.java Normal file
View File

@@ -0,0 +1,80 @@
/*
* Copyright 2023-2023 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package functions;
import java.io.IOException;
import java.util.Map;
import java.util.function.Function;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.core.log.LogAccessor;
import org.springframework.messaging.Message;
import org.springframework.messaging.MessageHeaders;
import org.springframework.messaging.support.MessageBuilder;
import org.springframework.util.MimeTypeUtils;
/**
* The {@link Function} to deserialize {@code byte[]} payload into a Map
* if {@link MessageHeaders#CONTENT_TYPE} header is JSON.
* Otherwise, the message is returned as is.
*
* @author Artem Bilan
*
* @since 4.0
*/
public class JsonBytesToMap implements Function<Message<?>, Message<?>> {
private static final LogAccessor logger = new LogAccessor(JsonBytesToMap.class);
private final ObjectMapper objectMapper;
public JsonBytesToMap(ObjectMapper objectMapper) {
this.objectMapper = objectMapper;
}
@Override
public Message<?> apply(Message<?> message) {
if (message.getPayload() instanceof byte[] payload) {
MessageHeaders headers = message.getHeaders();
String contentType =
headers.containsKey(MessageHeaders.CONTENT_TYPE)
? headers.get(MessageHeaders.CONTENT_TYPE).toString()
: MimeTypeUtils.APPLICATION_JSON_VALUE;
if (contentType.contains("json")) {
message = MessageBuilder.withPayload(payloadToMapIfCan(payload))
.copyHeaders(message.getHeaders())
.build();
}
}
return message;
}
private Object payloadToMapIfCan(byte[] payload) {
try {
return this.objectMapper.readValue(payload, Map.class);
}
catch (IOException ex) {
logger.trace(ex, "Cannot deserialize to Map");
// Was not able to construct the map from byte[] -- returning as is
return payload;
}
}
}

79
function/spring-payload-converter-function/src/test/java/functions/ByteArrayTextToStringTests.java Normal file
View File

@@ -0,0 +1,79 @@
/*
* Copyright 2020-2020 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package functions;
import java.util.Collections;
import java.util.function.Function;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.springframework.messaging.Message;
import org.springframework.messaging.MessageHeaders;
import org.springframework.messaging.support.GenericMessage;
import org.springframework.util.MimeTypeUtils;
import static org.assertj.core.api.Assertions.assertThat;
public class ByteArrayTextToStringTests {
private static final String MESSAGE = "hello world";
private static Function<Message<?>, Message<?>> converter;
@BeforeAll
static void before() {
converter = new ByteArrayTextToString();
}
@Test
public void testDefaultNoContentType() {
Message<?> converted = converter.apply(new GenericMessage<>(MESSAGE.getBytes()));
assertThat(converted).isNotNull().extracting(Message::getPayload).isEqualTo(MESSAGE);
converted = converter.apply(new GenericMessage<>(MESSAGE)); // String
assertThat(converted).isNotNull().extracting(Message::getPayload).isEqualTo(MESSAGE);
}
@Test
public void testApplicationJsonContentType() {
Message<?> converted = converter.apply(new GenericMessage<>(MESSAGE.getBytes(),
Collections.singletonMap(MessageHeaders.CONTENT_TYPE, MimeTypeUtils.APPLICATION_JSON_VALUE)));
assertThat(converted).isNotNull().extracting(Message::getPayload).isEqualTo("hello world");
}
@Test
public void testPlainTextContentType() {
Message<?> converted = converter.apply(new GenericMessage<>(MESSAGE.getBytes(),
Collections.singletonMap(MessageHeaders.CONTENT_TYPE, MimeTypeUtils.TEXT_PLAIN_VALUE)));
assertThat(converted).isNotNull().extracting(Message::getPayload).isEqualTo(MESSAGE);
}
@Test
public void testOctetContentType() {
Message<?> converted = converter.apply(new GenericMessage<>(MESSAGE.getBytes(),
Collections.singletonMap(MessageHeaders.CONTENT_TYPE, MimeTypeUtils.APPLICATION_OCTET_STREAM_VALUE)));
assertThat(converted).isNotNull().extracting(Message::getPayload).isEqualTo(MESSAGE.getBytes());
}
@Test
public void testRandomNonTextContentType() {
Message<?> converted = converter.apply(new GenericMessage<>(MESSAGE.getBytes(),
Collections.singletonMap(MessageHeaders.CONTENT_TYPE, "Random Content Type")));
assertThat(converted).isNotNull().extracting(Message::getPayload).isEqualTo(MESSAGE.getBytes());
}
}