BAEL-1911 - Spring Session with JDBC

apache-solrj/src/test/java/com/baeldung/solrjava/SolrJavaIntegrationTest.java → apache-solrj/src/test/java/com/baeldung/solrjava/SolrJavaLiveTest.java

@@ -12,7 +12,7 @@
 import org.junit.Before;
 import org.junit.Test;
 
-public class SolrJavaIntegrationTest {
+public class SolrJavaLiveTest {
 
     private SolrJavaIntegration solrJavaIntegration;
 

core-java-io/src/test/java/org/baeldung/java/io/JavaInputStreamToXUnitTest.java

@@ -14,8 +14,10 @@
 import java.io.*;
 import java.nio.charset.Charset;
 import java.nio.charset.StandardCharsets;
+import java.nio.file.Path;
 import java.nio.file.StandardCopyOption;
 import java.util.Scanner;
+import java.util.UUID;
 
 import static org.apache.commons.lang3.RandomStringUtils.randomAlphabetic;
 import static org.hamcrest.Matchers.equalTo;
@@ -111,6 +113,19 @@ public final void givenUsingCommonsIoWithCopy_whenConvertingAnInputStreamToAStri
 
         assertThat(writer.toString(), equalTo(originalString));
     }
+
+    @Test
+    public final void givenUsingTempFile_whenConvertingAnInputStreamToAString_thenCorrect() throws IOException {
+        final String originalString = randomAlphabetic(DEFAULT_SIZE);
+        final InputStream inputStream = new ByteArrayInputStream(originalString.getBytes());
+
+        // When
+        Path tempFile = java.nio.file.Files.createTempDirectory("").resolve(UUID.randomUUID().toString() + ".tmp");
+        java.nio.file.Files.copy(inputStream, tempFile, StandardCopyOption.REPLACE_EXISTING);
+        String result = new String(java.nio.file.Files.readAllBytes(tempFile));
+
+        assertThat(result, equalTo(originalString));
+    }
 
     // tests - InputStream to byte[]
 

core-kotlin/src/main/java/com/baeldung/mavenjavakotlin/Application.java

@@ -0,0 +1,26 @@
+package com.baeldung.mavenjavakotlin;
+
+import com.baeldung.mavenjavakotlin.services.JavaService;
+import com.baeldung.mavenjavakotlin.services.KotlinService;
+
+public class Application {
+
+    private static final String JAVA = "java";
+    private static final String KOTLIN = "kotlin";
+
+    public static void main(String[] args) {
+        String language = args[0];
+        switch (language) {
+            case JAVA:
+                new JavaService().sayHello();
+                break;
+            case KOTLIN:
+                new KotlinService().sayHello();
+                break;
+            default:
+                // Do nothing
+                break;
+        }
+    }
+
+}

core-kotlin/src/main/java/com/baeldung/mavenjavakotlin/services/JavaService.java

@@ -0,0 +1,9 @@
+package com.baeldung.mavenjavakotlin.services;
+
+public class JavaService {
+
+    public void sayHello() {
+        System.out.println("Java says 'Hello World!'");
+    }
+
+}

core-kotlin/src/main/kotlin/com/baeldung/mavenjavakotlin/services/KotlinService.kt

@@ -0,0 +1,9 @@
+package com.baeldung.mavenjavakotlin.services
+
+class KotlinService {
+
+    fun sayHello() {
+        System.out.println("Kotlin says 'Hello World!'")
+    }
+
+}

ejb/wildfly/wildfly-mdb/pom.xml

@@ -0,0 +1,21 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <artifactId>widlfly-mdb</artifactId>
+
+    <parent>
+        <groupId>com.baeldung.wildfly</groupId>
+        <artifactId>wildfly-example</artifactId>
+        <version>0.0.1-SNAPSHOT</version>
+    </parent>
+
+    <dependencies>
+        <!-- Dependency for java ee -->
+        <dependency>
+            <groupId>javax</groupId>
+            <artifactId>javaee-api</artifactId>
+            <version>${javaee-api.version}</version>
+            <scope>provided</scope>
+        </dependency>
+    </dependencies>
+</project>

ejb/wildfly/wildfly-mdb/src/com/baeldung/wildfly/mdb/ReadMessageMDB.java

@@ -0,0 +1,28 @@
+package com.baeldung.wildfly.mdb;
+
+import javax.ejb.ActivationConfigProperty;
+import javax.ejb.MessageDriven;
+import javax.jms.JMSException;
+import javax.jms.Message;
+import javax.jms.MessageListener;
+import javax.jms.TextMessage;
+
+/**
+ * Message-Driven Bean implementation class for: ReadMessageMDB
+ */
+@MessageDriven(
+        activationConfig = { 
+            @ActivationConfigProperty(propertyName = "destination", propertyValue = "tutorialQueue"), 
+            @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Queue")
+})
+public class ReadMessageMDB implements MessageListener {
+
+    public void onMessage(Message message) {
+        TextMessage textMessage = (TextMessage) message;
+        try {
+            System.out.println("Message received: " + textMessage.getText());
+        } catch (JMSException e) {
+            System.out.println("Error while trying to consume messages: " + e.getMessage());
+        }
+    }
+}

ejb/wildfly/wildfly-mdb/src/com/baeldung/wildfly/mdb/SendMessageServlet.java

@@ -0,0 +1,52 @@
+package baeldung.com.example.servlet;
+
+import java.io.IOException;
+
+import javax.jms.Connection;
+import javax.jms.ConnectionFactory;
+import javax.jms.JMSException;
+import javax.jms.MessageProducer;
+import javax.jms.Queue;
+import javax.jms.Session;
+import javax.jms.TextMessage;
+import javax.naming.Context;
+import javax.naming.InitialContext;
+import javax.naming.NamingException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+
+@WebServlet("/SendMessageServlet")
+public class SendMessageServlet extends HttpServlet {
+
+    @Override
+    protected void doGet(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException {
+        String text = req.getParameter("text") != null ? req.getParameter("text") : "Hello World";
+
+        try (
+            Context ic = new InitialContext();
+
+            ConnectionFactory cf = (ConnectionFactory) ic.lookup("/ConnectionFactory");
+            Queue queue = (Queue) ic.lookup("queue/tutorialQueue");
+
+            Connection connection = cf.createConnection();
+        ) {
+            Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
+            MessageProducer publisher = session.createProducer(queue);
+
+            connection.start();
+
+            TextMessage message = session.createTextMessage(text);
+            publisher.send(message);
+
+        } catch (NamingException | JMSException e) {
+            res.getWriter().println("Error while trying to send <" + text + "> message: " + e.getMessage());
+        } 
+
+        res.getWriter().println("Message sent: " + text);
+    }
+
+}

javax-servlets/README.md

@@ -6,3 +6,4 @@
 - [Example of Downloading File in a Servlet](http://www.baeldung.com/servlet-download-file)
 - [Returning a JSON Response from a Servlet](http://www.baeldung.com/servlet-json-response)
 - [Java EE Servlet Exception Handling](http://www.baeldung.com/servlet-exceptions)
+- [Context and Servlet Initialization Parameters](http://www.baeldung.com/context-servlet-initialization-param)

persistence-modules/spring-hibernate-3/src/main/resources/exceptionDemoPersistenceConfig.xml

@@ -17,7 +17,7 @@
 
     <context:annotation-config />
     <context:component-scan base-package="org.baeldung.persistence" />
-    <context:property-placeholder location="classpath:persistence-mysql.properties"/>
+    <context:property-placeholder location="classpath:persistence-h2.properties"/>
 
 
 

persistence-modules/spring-hibernate-3/src/main/resources/persistenceConfig.xml

@@ -5,7 +5,7 @@
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd"
 >
 
-    <context:property-placeholder location="classpath:persistence-mysql.properties"/>
+    <context:property-placeholder location="classpath:persistence-h2.properties"/>
 
     <bean id="sessionFactory" class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
         <property name="dataSource" ref="dataSource"/>

pom.xml

@@ -269,7 +269,7 @@
         <module>java-ee-8-security-api</module>
         <module>spring-webflux-amqp</module>
         <module>antlr</module>
-	      <module>maven-archetype</module>
+        <module>maven-archetype</module>
         <module>apache-meecrowave</module>
     </modules>
 

spring-batch/src/main/java/org/baeldung/batchscheduler/SpringBatchScheduler.java

@@ -0,0 +1,172 @@
+package org.baeldung.batchscheduler;
+
+import java.util.Date;
+import java.util.IdentityHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import org.baeldung.batchscheduler.model.Book;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.batch.core.Job;
+import org.springframework.batch.core.JobExecution;
+import org.springframework.batch.core.JobParametersBuilder;
+import org.springframework.batch.core.Step;
+import org.springframework.batch.core.configuration.annotation.EnableBatchProcessing;
+import org.springframework.batch.core.configuration.annotation.JobBuilderFactory;
+import org.springframework.batch.core.configuration.annotation.StepBuilderFactory;
+import org.springframework.batch.core.launch.JobLauncher;
+import org.springframework.batch.core.launch.support.SimpleJobLauncher;
+import org.springframework.batch.core.repository.JobRepository;
+import org.springframework.batch.core.repository.support.MapJobRepositoryFactoryBean;
+import org.springframework.batch.item.ItemWriter;
+import org.springframework.batch.item.file.FlatFileItemReader;
+import org.springframework.batch.item.file.builder.FlatFileItemReaderBuilder;
+import org.springframework.batch.item.file.mapping.BeanWrapperFieldSetMapper;
+import org.springframework.batch.support.transaction.ResourcelessTransactionManager;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.core.io.ClassPathResource;
+import org.springframework.scheduling.TaskScheduler;
+import org.springframework.scheduling.annotation.EnableScheduling;
+import org.springframework.scheduling.annotation.Scheduled;
+import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
+import org.springframework.scheduling.support.ScheduledMethodRunnable;
+
+@Configuration
+@EnableBatchProcessing
+@EnableScheduling
+public class SpringBatchScheduler {
+
+    private final Logger logger = LoggerFactory.getLogger(SpringBatchScheduler.class);
+
+    private AtomicBoolean enabled = new AtomicBoolean(true);
+
+    private Date currentLaunchDate;
+
+    private final Map<Object, ScheduledFuture<?>> scheduledTasks = new IdentityHashMap<>();
+
+    @Autowired
+    private JobBuilderFactory jobBuilderFactory;
+
+    @Autowired
+    private StepBuilderFactory stepBuilderFactory;
+
+    @Scheduled(fixedRate = 2000)
+    public void launchJob() throws Exception {
+        Date date = new Date();
+        logger.debug("scheduler starts at " + date);
+        if (enabled.get()) {
+            currentLaunchDate = date;
+            JobExecution jobExecution = jobLauncher().run(job(), new JobParametersBuilder().addDate("launchDate", currentLaunchDate)
+                .toJobParameters());
+            logger.debug("Batch job ends with status as " + jobExecution.getStatus());
+        }
+        logger.debug("scheduler ends ");
+    }
+
+    public Date getCurrentLaunchDate() {
+        return currentLaunchDate;
+    }
+
+    public void stop() {
+        enabled.set(false);
+    }
+
+    public void start() {
+        enabled.set(true);
+    }
+
+    @Bean
+    public TaskScheduler poolScheduler() {
+        return new CustomTaskScheduler();
+    }
+
+    private class CustomTaskScheduler extends ThreadPoolTaskScheduler {
+
+        private static final long serialVersionUID = -7142624085505040603L;
+
+        @Override
+        public ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period) {
+            ScheduledFuture<?> future = super.scheduleAtFixedRate(task, period);
+
+            ScheduledMethodRunnable runnable = (ScheduledMethodRunnable) task;
+            scheduledTasks.put(runnable.getTarget(), future);
+
+            return future;
+        }
+
+    }
+
+    public void cancelFutureSchedulerTasks() {
+        scheduledTasks.forEach((k, v) -> {
+            if (k instanceof SpringBatchScheduler) {
+                v.cancel(false);
+            }
+        });
+    }
+
+    @Bean
+    public Job job() {
+        return jobBuilderFactory.get("job")
+            .start(readBooks())
+            .build();
+    }
+
+    @Bean
+    public JobLauncher jobLauncher() throws Exception {
+        SimpleJobLauncher jobLauncher = new SimpleJobLauncher();
+        jobLauncher.setJobRepository(jobRepository());
+        jobLauncher.afterPropertiesSet();
+        return jobLauncher;
+    }
+
+    @Bean
+    public JobRepository jobRepository() throws Exception {
+        MapJobRepositoryFactoryBean factory = new MapJobRepositoryFactoryBean();
+        factory.setTransactionManager(new ResourcelessTransactionManager());
+        return (JobRepository) factory.getObject();
+    }
+
+    @Bean
+    protected Step readBooks() {
+        return stepBuilderFactory.get("readBooks")
+            .<Book, Book> chunk(2)
+            .reader(reader())
+            .writer(writer())
+            .build();
+    }
+
+    @Bean
+    public FlatFileItemReader<Book> reader() {
+        return new FlatFileItemReaderBuilder<Book>().name("bookItemReader")
+            .resource(new ClassPathResource("books.csv"))
+            .delimited()
+            .names(new String[] { "id", "name" })
+            .fieldSetMapper(new BeanWrapperFieldSetMapper<Book>() {
+                {
+                    setTargetType(Book.class);
+                }
+            })
+            .build();
+    }
+
+    @Bean
+    public ItemWriter<Book> writer() {
+        return new ItemWriter<Book>() {
+
+            @Override
+            public void write(List<? extends Book> items) throws Exception {
+                logger.debug("writer..." + items.size());
+                for (Book item : items) {
+                    logger.debug(item.toString());
+                }
+
+            }
+        };
+    }
+
+}