BAEL-3091: The Prototype Pattern in Java (changed code based on valid comments from a reader)

spring-integration/src/test/java/com/baeldung/samples/FileCopyIntegrationTest.java

@@ -0,0 +1,41 @@
+/*
+ * Copyright 2002-2013 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
+ *
+ *      http://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 com.baeldung.samples;
+
+import org.junit.Test;
+import org.springframework.context.annotation.AnnotationConfigApplicationContext;
+import org.springframework.context.support.AbstractApplicationContext;
+import org.springframework.context.support.ClassPathXmlApplicationContext;
+
+public final class FileCopyIntegrationTest {
+
+    //
+
+    @Test
+    public void whenFileCopyConfiguration_thanFileCopiedSuccessfully() throws InterruptedException {
+        final AbstractApplicationContext context = new AnnotationConfigApplicationContext(FileCopyConfig.class.getCanonicalName());
+        context.registerShutdownHook();
+        Thread.sleep(5000);
+    }
+
+    @Test
+    public void publish() throws InterruptedException {
+        final AbstractApplicationContext context = new ClassPathXmlApplicationContext("classpath:META-INF/spring/integration/spring-integration-file-publish-context.xml");
+
+        Thread.sleep(15000);
+    }
+
+}

spring-integration/src/test/java/com/baeldung/si/TestSpringIntegrationSecurityExecutorIntegrationTest.java

@@ -0,0 +1,68 @@
+package com.baeldung.si;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.TimeUnit;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.messaging.SubscribableChannel;
+import org.springframework.messaging.support.GenericMessage;
+import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
+import org.springframework.security.test.context.support.WithMockUser;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+import com.baeldung.si.security.MessageConsumer;
+import com.baeldung.si.security.SecurityConfig;
+import com.baeldung.si.security.SecurityPubSubChannel;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(classes = { SecurityPubSubChannel.class, MessageConsumer.class, SecurityConfig.class })
+public class TestSpringIntegrationSecurityExecutorIntegrationTest {
+
+    @Autowired
+    SubscribableChannel startPSChannel;
+
+    @Autowired
+    MessageConsumer messageConsumer;
+
+    @Autowired
+    ThreadPoolTaskExecutor executor;
+
+    final String DIRECT_CHANNEL_MESSAGE = "Direct channel message";
+
+    @Before
+    public void clearData() {
+        messageConsumer.setMessagePSContent(new ConcurrentHashMap<>());
+        executor.setWaitForTasksToCompleteOnShutdown(true);
+    }
+
+    @Test
+    @WithMockUser(username = "user", roles = { "VIEWER" })
+    public void givenRoleUser_whenSendMessageToPSChannel_thenNoMessageArrived() throws IllegalStateException, InterruptedException {
+        startPSChannel.send(new GenericMessage<String>(DIRECT_CHANNEL_MESSAGE));
+
+        executor.getThreadPoolExecutor().awaitTermination(2, TimeUnit.SECONDS);
+
+        assertEquals(1, messageConsumer.getMessagePSContent().size());
+        assertTrue(messageConsumer.getMessagePSContent().values().contains("user"));
+    }
+
+    @Test
+    @WithMockUser(username = "user", roles = { "LOGGER", "VIEWER" })
+    public void givenRoleUserAndLogger_whenSendMessageToPSChannel_then2GetMessages() throws IllegalStateException, InterruptedException {
+        startPSChannel.send(new GenericMessage<String>(DIRECT_CHANNEL_MESSAGE));
+
+        executor.getThreadPoolExecutor().awaitTermination(2, TimeUnit.SECONDS);
+
+        assertEquals(2, messageConsumer.getMessagePSContent().size());
+        assertTrue(messageConsumer.getMessagePSContent().values().contains("user"));
+        assertTrue(messageConsumer.getMessagePSContent().values().contains("ROLE_LOGGER,ROLE_VIEWER"));
+    }
+
+}

spring-integration/src/test/java/com/baeldung/si/TestSpringIntegrationSecurityIntegrationTest.java

@@ -0,0 +1,81 @@
+package com.baeldung.si;
+
+import static org.junit.Assert.assertEquals;
+
+import org.hamcrest.core.IsInstanceOf;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.messaging.SubscribableChannel;
+import org.springframework.messaging.support.GenericMessage;
+import org.springframework.security.access.AccessDeniedException;
+import org.springframework.security.authentication.AuthenticationCredentialsNotFoundException;
+import org.springframework.security.test.context.support.WithMockUser;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+import com.baeldung.si.security.MessageConsumer;
+import com.baeldung.si.security.SecuredDirectChannel;
+import com.baeldung.si.security.SecurityConfig;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(classes = { SecurityConfig.class, SecuredDirectChannel.class, MessageConsumer.class })
+public class TestSpringIntegrationSecurityIntegrationTest {
+
+    @Rule
+    public ExpectedException expectedException = ExpectedException.none();
+
+    @Autowired
+    SubscribableChannel startDirectChannel;
+
+    @Autowired
+    MessageConsumer messageConsumer;
+
+    final String DIRECT_CHANNEL_MESSAGE = "Direct channel message";
+
+    @Test(expected = AuthenticationCredentialsNotFoundException.class)
+    public void givenNoUser_whenSendToDirectChannel_thenCredentialNotFound() {
+        startDirectChannel.send(new GenericMessage<String>(DIRECT_CHANNEL_MESSAGE));
+    }
+
+    @Test
+    @WithMockUser(username = "jane", roles = { "LOGGER" })
+    public void givenRoleLogger_whenSendMessageToDirectChannel_thenAccessDenied() {
+        expectedException.expectCause(IsInstanceOf.<Throwable> instanceOf(AccessDeniedException.class));
+
+        startDirectChannel.send(new GenericMessage<String>(DIRECT_CHANNEL_MESSAGE));
+    }
+
+    @Test
+    @WithMockUser(username = "jane")
+    public void givenJane_whenSendMessageToDirectChannel_thenAccessDenied() {
+        expectedException.expectCause(IsInstanceOf.<Throwable> instanceOf(AccessDeniedException.class));
+
+        startDirectChannel.send(new GenericMessage<String>(DIRECT_CHANNEL_MESSAGE));
+    }
+
+    @Test
+    @WithMockUser(roles = { "VIEWER" })
+    public void givenRoleViewer_whenSendToDirectChannel_thenAccessDenied() {
+        expectedException.expectCause(IsInstanceOf.<Throwable> instanceOf(AccessDeniedException.class));
+
+        startDirectChannel.send(new GenericMessage<String>(DIRECT_CHANNEL_MESSAGE));
+    }
+
+    @Test
+    @WithMockUser(roles = { "LOGGER", "VIEWER", "EDITOR" })
+    public void givenRoleLoggerAndUser_whenSendMessageToDirectChannel_thenFlowCompletedSuccessfully() {
+        startDirectChannel.send(new GenericMessage<String>(DIRECT_CHANNEL_MESSAGE));
+        assertEquals(DIRECT_CHANNEL_MESSAGE, messageConsumer.getMessageContent());
+    }
+
+    @Test
+    @WithMockUser(username = "jane", roles = { "LOGGER", "EDITOR" })
+    public void givenJaneLoggerEditor_whenSendToDirectChannel_thenFlowCompleted() {
+        startDirectChannel.send(new GenericMessage<String>(DIRECT_CHANNEL_MESSAGE));
+        assertEquals(DIRECT_CHANNEL_MESSAGE, messageConsumer.getMessageContent());
+    }
+
+}

spring-integration/src/test/java/com/baeldung/subflows/discardflow/FilterUnitTest.java

@@ -0,0 +1,62 @@
+package com.baeldung.subflows.discardflow;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.Arrays;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.integration.channel.QueueChannel;
+import org.springframework.messaging.Message;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+import com.baeldung.subflows.discardflow.FilterExample.NumbersClassifier;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(classes = { FilterExample.class })
+public class FilterUnitTest {
+    @Autowired
+    private QueueChannel multipleofThreeChannel;
+
+    @Autowired
+    private QueueChannel remainderIsOneChannel;
+
+    @Autowired
+    private QueueChannel remainderIsTwoChannel;
+
+    @Autowired
+    private NumbersClassifier numbersClassifier;
+
+    @Test
+    public void whenSendMessagesToFlow_thenNumbersAreClassified() {
+
+        numbersClassifier.classify(Arrays.asList(1, 2, 3, 4, 5, 6));
+
+        Message<?> outMessage = multipleofThreeChannel.receive(0);
+
+        assertEquals(outMessage.getPayload(), 3);
+
+        outMessage = multipleofThreeChannel.receive(0);
+
+        assertEquals(outMessage.getPayload(), 6);
+
+        outMessage = remainderIsOneChannel.receive(0);
+
+        assertEquals(outMessage.getPayload(), 1);
+        outMessage = remainderIsOneChannel.receive(0);
+
+        assertEquals(outMessage.getPayload(), 4);
+
+        outMessage = remainderIsTwoChannel.receive(0);
+
+        assertEquals(outMessage.getPayload(), 2);
+
+        outMessage = remainderIsTwoChannel.receive(0);
+
+        assertEquals(outMessage.getPayload(), 5);
+
+    }
+
+}

spring-integration/src/test/java/com/baeldung/subflows/publishsubscribechannel/PublishSubscribeChannelUnitTest.java

@@ -0,0 +1,62 @@
+package com.baeldung.subflows.publishsubscribechannel;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.Arrays;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.integration.channel.QueueChannel;
+import org.springframework.messaging.Message;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+import com.baeldung.subflows.publishsubscribechannel.PublishSubscibeChannelExample.NumbersClassifier;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(classes = { PublishSubscibeChannelExample.class })
+public class PublishSubscribeChannelUnitTest {
+    @Autowired
+    private QueueChannel multipleofThreeChannel;
+
+    @Autowired
+    private QueueChannel remainderIsOneChannel;
+
+    @Autowired
+    private QueueChannel remainderIsTwoChannel;
+
+    @Autowired
+    private NumbersClassifier numbersClassifier;
+
+    @Test
+    public void whenSendMessagesToFlow_thenNumbersAreClassified() {
+
+        numbersClassifier.classify(Arrays.asList(1, 2, 3, 4, 5, 6));
+       
+        Message<?> outMessage = multipleofThreeChannel.receive(0);
+
+        assertEquals(outMessage.getPayload(), 3);
+
+        outMessage = multipleofThreeChannel.receive(0);
+
+        assertEquals(outMessage.getPayload(), 6);
+       
+        outMessage = remainderIsOneChannel.receive(0);
+
+        assertEquals(outMessage.getPayload(), 1);
+        outMessage = remainderIsOneChannel.receive(0);
+
+        assertEquals(outMessage.getPayload(), 4);
+      
+        outMessage = remainderIsTwoChannel.receive(0);
+
+        assertEquals(outMessage.getPayload(), 2);
+
+        outMessage = remainderIsTwoChannel.receive(0);
+
+        assertEquals(outMessage.getPayload(), 5);
+
+    }
+
+}

spring-integration/src/test/java/com/baeldung/subflows/routetorecipients/RouteToRecipientsUnitTest.java

@@ -0,0 +1,63 @@
+package com.baeldung.subflows.routetorecipients;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.Arrays;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.integration.channel.QueueChannel;
+import org.springframework.messaging.Message;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+import com.baeldung.subflows.routetorecipients.RouteToRecipientsExample;
+import com.baeldung.subflows.routetorecipients.RouteToRecipientsExample.NumbersClassifier;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(classes = { RouteToRecipientsExample.class })
+public class RouteToRecipientsUnitTest {
+    @Autowired
+    private QueueChannel multipleofThreeChannel;
+
+    @Autowired
+    private QueueChannel remainderIsOneChannel;
+
+    @Autowired
+    private QueueChannel remainderIsTwoChannel;
+
+    @Autowired
+    private NumbersClassifier numbersClassifier;
+
+    @Test
+    public void whenSendMessagesToFlow_thenNumbersAreClassified() {
+
+        numbersClassifier.classify(Arrays.asList(1, 2, 3, 4, 5, 6));
+
+        Message<?> outMessage = multipleofThreeChannel.receive(0);
+
+        assertEquals(outMessage.getPayload(), 3);
+
+        outMessage = multipleofThreeChannel.receive(0);
+
+        assertEquals(outMessage.getPayload(), 6);
+
+        outMessage = remainderIsOneChannel.receive(0);
+
+        assertEquals(outMessage.getPayload(), 1);
+        outMessage = remainderIsOneChannel.receive(0);
+
+        assertEquals(outMessage.getPayload(), 4);
+
+        outMessage = remainderIsTwoChannel.receive(0);
+
+        assertEquals(outMessage.getPayload(), 2);
+
+        outMessage = remainderIsTwoChannel.receive(0);
+
+        assertEquals(outMessage.getPayload(), 5);
+
+    }
+
+}

spring-integration/src/test/java/com/baeldung/subflows/separateflows/SeparateFlowsUnitTest.java

@@ -0,0 +1,75 @@
+package com.baeldung.subflows.separateflows;
+
+import java.util.Arrays;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.integration.channel.QueueChannel;
+import org.springframework.messaging.Message;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+import com.baeldung.subflows.separateflows.SeparateFlowsExample.NumbersClassifier;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(classes = { SeparateFlowsExample.class })
+public class SeparateFlowsUnitTest {
+    @Autowired
+    private QueueChannel multipleOfThreeChannel;
+    @Autowired
+    private QueueChannel remainderIsOneChannel;
+    @Autowired
+    private QueueChannel remainderIsTwoChannel;
+
+    @Autowired
+    private NumbersClassifier numbersClassifier;
+
+    @Test
+    public void whenSendMessagesToMultipleOf3Flow_thenOutputMultiplesOf3() {
+
+        numbersClassifier.multipleofThree(Arrays.asList(1, 2, 3, 4, 5, 6));
+
+        Message<?> outMessage = multipleOfThreeChannel.receive(0);
+
+        assertEquals(outMessage.getPayload(), 3);
+
+        outMessage = multipleOfThreeChannel.receive(0);
+
+        assertEquals(outMessage.getPayload(), 6);
+        outMessage = multipleOfThreeChannel.receive(0);
+        assertNull(outMessage);
+    }
+
+    @Test
+    public void whenSendMessagesToRemainderIs1Flow_thenOutputRemainderIs1() {
+
+        numbersClassifier.remainderIsOne(Arrays.asList(1, 2, 3, 4, 5, 6));
+
+        Message<?> outMessage = remainderIsOneChannel.receive(0);
+
+        assertEquals(outMessage.getPayload(), 1);
+
+        outMessage = remainderIsOneChannel.receive(0);
+
+        assertEquals(outMessage.getPayload(), 4);
+
+    }
+
+    @Test
+    public void whenSendMessagesToRemainderIs2Flow_thenOutputRemainderIs2() {
+
+        numbersClassifier.remainderIsTwo(Arrays.asList(1, 2, 3, 4, 5, 6));
+
+        Message<?> outMessage = remainderIsTwoChannel.receive(0);
+
+        assertEquals(outMessage.getPayload(), 2);
+
+        outMessage = remainderIsTwoChannel.receive(0);
+
+        assertEquals(outMessage.getPayload(), 5);
+
+    }
+
+}

spring-integration/src/test/java/com/baeldung/subflows/subflowmapping/RouterUnitTest.java

@@ -0,0 +1,62 @@
+package com.baeldung.subflows.subflowmapping;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.Arrays;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.integration.channel.QueueChannel;
+import org.springframework.messaging.Message;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+import com.baeldung.subflows.subflowmapping.RouterExample.NumbersClassifier;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(classes = { RouterExample.class })
+public class RouterUnitTest {
+    @Autowired
+    private QueueChannel multipleofThreeChannel;
+
+    @Autowired
+    private QueueChannel remainderIsOneChannel;
+
+    @Autowired
+    private QueueChannel remainderIsTwoChannel;
+
+    @Autowired
+    private NumbersClassifier numbersClassifier;
+
+    @Test
+    public void whenSendMessagesToFlow_thenNumbersAreClassified() {
+
+        numbersClassifier.classify(Arrays.asList(1, 2, 3, 4, 5, 6));
+
+        Message<?> outMessage = multipleofThreeChannel.receive(0);
+
+        assertEquals(outMessage.getPayload(), 3);
+
+        outMessage = multipleofThreeChannel.receive(0);
+
+        assertEquals(outMessage.getPayload(), 6);
+
+        outMessage = remainderIsOneChannel.receive(0);
+
+        assertEquals(outMessage.getPayload(), 1);
+        outMessage = remainderIsOneChannel.receive(0);
+
+        assertEquals(outMessage.getPayload(), 4);
+
+        outMessage = remainderIsTwoChannel.receive(0);
+
+        assertEquals(outMessage.getPayload(), 2);
+
+        outMessage = remainderIsTwoChannel.receive(0);
+
+        assertEquals(outMessage.getPayload(), 5);
+
+    }
+
+}

spring-integration/src/test/java/com/baeldung/tx/TxIntegrationTest.java

@@ -0,0 +1,56 @@
+package com.baeldung.tx;
+
+import org.junit.Assert;
+import org.junit.Test;
+import org.springframework.context.support.AbstractApplicationContext;
+import org.springframework.context.support.ClassPathXmlApplicationContext;
+
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+
+public final class TxIntegrationTest {
+
+    private static final String CONTEXT_CONFIG = "classpath:META-INF/spring/integration/spring-integration-tx-context.xml";
+
+    @Test
+    public void whenFileDoesntStartWithFail_thenTxSuccessful() throws InterruptedException, IOException {
+        final AbstractApplicationContext context =
+                new ClassPathXmlApplicationContext(CONTEXT_CONFIG);
+
+        String fileName = System.getProperty("java.io.tmpdir") + "/tx/test1.txt";
+        FileWriter fw = new FileWriter(fileName);
+        fw.write("PASSED!");
+        fw.close();
+
+        context.registerShutdownHook();
+        Thread.sleep(5000);
+
+        File file = new File(fileName + ".PASSED");
+        Assert.assertTrue(file.exists());
+    }
+
+    @Test
+    public void whenFileStartsWithFail_thenTxFailed() {
+
+        String fileName = System.getProperty("java.io.tmpdir") + "/tx/test2.txt";
+
+        try {
+            final AbstractApplicationContext context =
+                    new ClassPathXmlApplicationContext(CONTEXT_CONFIG);
+
+            FileWriter fw = new FileWriter(fileName);
+            fw.write("FAILED!");
+            fw.close();
+
+            context.registerShutdownHook();
+            Thread.sleep(5000);
+        } catch (Exception e) {
+            // Exception is expected, do nothing
+        }
+
+        File file = new File(fileName + ".FAILED");
+        Assert.assertTrue(file.exists());
+    }
+
+}

spring-integration/src/test/java/org/baeldung/SpringContextIntegrationTest.java

@@ -0,0 +1,21 @@
+package org.baeldung;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+import com.baeldung.si.security.MessageConsumer;
+import com.baeldung.si.security.SecuredDirectChannel;
+import com.baeldung.si.security.SecurityConfig;
+import com.baeldung.si.security.SecurityPubSubChannel;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(classes = { SecurityConfig.class, SecuredDirectChannel.class, SecurityPubSubChannel.class,
+		MessageConsumer.class })
+public class SpringContextIntegrationTest {
+
+    @Test
+    public void whenSpringContextIsBootstrapped_thenNoExceptions() {
+    }
+}

spring-integration/src/test/java/org/baeldung/SpringContextTest.java

@@ -0,0 +1,21 @@
+package org.baeldung;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+import com.baeldung.si.security.MessageConsumer;
+import com.baeldung.si.security.SecuredDirectChannel;
+import com.baeldung.si.security.SecurityConfig;
+import com.baeldung.si.security.SecurityPubSubChannel;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(classes = { SecurityConfig.class, SecuredDirectChannel.class, SecurityPubSubChannel.class,
+		MessageConsumer.class })
+public class SpringContextTest {
+
+    @Test
+    public void whenSpringContextIsBootstrapped_thenNoExceptions() {
+    }
+}

spring-integration/src/test/resources/logback-test.xml

@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<configuration>
+    <appender name="stdout" class="ch.qos.logback.core.ConsoleAppender">
+        <layout class="ch.qos.logback.classic.PatternLayout">
+            # Pattern of log message for console appender
+            <Pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</Pattern>
+        </layout>
+    </appender>
+    
+    <logger name="org.springframework" level="ERROR"/>
+
+    <root level="INFO">
+        <appender-ref ref="stdout" />
+    </root>
+</configuration>