Added convenience classes for typical JSR-236 setup in a Java EE 7 environment

Introduced DefaultManagedTaskExecutor, DefaultManagedTaskScheduler and DefaultManagedAwareThreadFactory classes, revised related javadoc, and deprecated unsupported JBossWorkManagerTaskExecutor in favor of JSR-236 setup on WildFly 8.

Issue: SPR-8195

Author: jhoeller

spring-context-support/src/main/java/org/springframework/scheduling/commonj/WorkManagerTaskExecutor.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2012 the original author or authors.
+ * 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.
@@ -17,10 +17,9 @@
 package org.springframework.scheduling.commonj;
 
 import java.util.Collection;
+import java.util.concurrent.Callable;
 import java.util.concurrent.Future;
 import java.util.concurrent.FutureTask;
-import java.util.concurrent.Callable;
-
 import javax.naming.NamingException;
 
 import commonj.work.Work;
@@ -53,17 +52,9 @@
  * <p>The CommonJ WorkManager will usually be retrieved from the application
  * server's JNDI environment, as defined in the server's management console.
  *
- * <p><b>Note: At the time of this writing, the CommonJ WorkManager facility
- * is only supported on IBM WebSphere 6.0+ and BEA WebLogic 9.0+,
- * despite being such a crucial API for an application server.</b>
- * (There is a similar facility available on WebSphere 5.1 Enterprise,
- * though, which we will discuss below.)
- *
- * <p><b>On JBoss and GlassFish, a similar facility is available through
- * the JCA WorkManager.</b> See the
- * {@link org.springframework.jca.work.jboss.JBossWorkManagerTaskExecutor}
- * {@link org.springframework.jca.work.glassfish.GlassFishWorkManagerTaskExecutor}
- * classes which are the direct equivalent of this CommonJ adapter class.
+ * <p>Note: On the upcoming EE 7 compliant versions of WebLogic and WebSphere, a
+ * {@link org.springframework.scheduling.concurrent.DefaultManagedTaskExecutor}
+ * should be preferred, following JSR-236 support in Java EE 7.
  *
  * @author Juergen Hoeller
  * @since 2.0
@@ -80,8 +71,7 @@ public class WorkManagerTaskExecutor extends JndiLocatorSupport
 
 	/**
 	 * Specify the CommonJ WorkManager to delegate to.
-	 * <p>Alternatively, you can also specify the JNDI name
-	 * of the target WorkManager.
+	 * <p>Alternatively, you can also specify the JNDI name of the target WorkManager.
 	 * @see #setWorkManagerName
 	 */
 	public void setWorkManager(WorkManager workManager) {
@@ -90,9 +80,8 @@ public void setWorkManager(WorkManager workManager) {
 
 	/**
 	 * Set the JNDI name of the CommonJ WorkManager.
-	 * <p>This can either be a fully qualified JNDI name,
-	 * or the JNDI name relative to the current environment
-	 * naming context if "resourceRef" is set to "true".
+	 * <p>This can either be a fully qualified JNDI name, or the JNDI name relative
+	 * to the current environment naming context if "resourceRef" is set to "true".
 	 * @see #setWorkManager
 	 * @see #setResourceRef
 	 */
@@ -177,30 +166,22 @@ public boolean prefersShortLivedTasks() {
 	//-------------------------------------------------------------------------
 
 	@Override
-	public WorkItem schedule(Work work)
-			throws WorkException, IllegalArgumentException {
-
+	public WorkItem schedule(Work work) throws WorkException, IllegalArgumentException {
 		return this.workManager.schedule(work);
 	}
 
 	@Override
-	public WorkItem schedule(Work work, WorkListener workListener)
-			throws WorkException, IllegalArgumentException {
-
+	public WorkItem schedule(Work work, WorkListener workListener) throws WorkException {
 		return this.workManager.schedule(work, workListener);
 	}
 
 	@Override
-	public boolean waitForAll(Collection workItems, long timeout)
-			throws InterruptedException, IllegalArgumentException {
-
+	public boolean waitForAll(Collection workItems, long timeout) throws InterruptedException {
 		return this.workManager.waitForAll(workItems, timeout);
 	}
 
 	@Override
-	public Collection waitForAny(Collection workItems, long timeout)
-			throws InterruptedException, IllegalArgumentException {
-
+	public Collection waitForAny(Collection workItems, long timeout) throws InterruptedException {
 		return this.workManager.waitForAny(workItems, timeout);
 	}
 

spring-context/src/main/java/org/springframework/scheduling/concurrent/ConcurrentTaskExecutor.java

@@ -38,8 +38,9 @@
  *
  * <p>Autodetects a JSR-236 {@link javax.enterprise.concurrent.ManagedExecutorService}
  * in order to expose {@link javax.enterprise.concurrent.ManagedTask} adapters for it,
- * exposing a long-running hint based on {@link SchedulingAwareRunnable} and an
- * identity name based on the given Runnable/Callable's {@code toString()}.
+ * exposing a long-running hint based on {@link SchedulingAwareRunnable} and an identity
+ * name based on the given Runnable/Callable's {@code toString()}. For JSR-236 style
+ * lookup in a Java EE 7 environment, consider using {@link DefaultManagedTaskExecutor}.
  *
  * <p>Note that there is a pre-built {@link ThreadPoolTaskExecutor} that allows
  * for defining a {@link java.util.concurrent.ThreadPoolExecutor} in bean style,
@@ -53,21 +54,22 @@
  * @see java.util.concurrent.ExecutorService
  * @see java.util.concurrent.ThreadPoolExecutor
  * @see java.util.concurrent.Executors
+ * @see DefaultManagedTaskExecutor
  * @see ThreadPoolTaskExecutor
  */
 public class ConcurrentTaskExecutor implements SchedulingTaskExecutor {
 
-	private static Class<?> managedExecutorService;
+	private static Class<?> managedExecutorServiceClass;
 
 	static {
 		try {
-			managedExecutorService = ClassUtils.forName(
+			managedExecutorServiceClass = ClassUtils.forName(
 					"javax.enterprise.concurrent.ManagedExecutorService",
 					ConcurrentTaskScheduler.class.getClassLoader());
 		}
 		catch (ClassNotFoundException ex) {
 			// JSR-236 API not available...
-			managedExecutorService = null;
+			managedExecutorServiceClass = null;
 		}
 	}
 
@@ -103,7 +105,7 @@ public ConcurrentTaskExecutor(Executor concurrentExecutor) {
 	public final void setConcurrentExecutor(Executor concurrentExecutor) {
 		if (concurrentExecutor != null) {
 			this.concurrentExecutor = concurrentExecutor;
-			if (managedExecutorService != null && managedExecutorService.isInstance(concurrentExecutor)) {
+			if (managedExecutorServiceClass != null && managedExecutorServiceClass.isInstance(concurrentExecutor)) {
 				this.adaptedExecutor = new ManagedTaskExecutorAdapter(concurrentExecutor);
 			}
 			else {

spring-context/src/main/java/org/springframework/scheduling/concurrent/ConcurrentTaskScheduler.java

@@ -44,7 +44,8 @@
  * <p>Autodetects a JSR-236 {@link javax.enterprise.concurrent.ManagedScheduledExecutorService}
  * in order to use it for trigger-based scheduling if possible, instead of Spring's
  * local trigger management which ends up delegating to regular delay-based scheduling
- * against the {@code java.util.concurrent.ScheduledExecutorService} API.
+ * against the {@code java.util.concurrent.ScheduledExecutorService} API. For JSR-236 style
+ * lookup in a Java EE 7 environment, consider using {@link DefaultManagedTaskScheduler}.
  *
  * <p>Note that there is a pre-built {@link ThreadPoolTaskScheduler} that allows for
  * defining a {@link java.util.concurrent.ScheduledThreadPoolExecutor} in bean style,
@@ -58,21 +59,22 @@
  * @see java.util.concurrent.ScheduledExecutorService
  * @see java.util.concurrent.ScheduledThreadPoolExecutor
  * @see java.util.concurrent.Executors
+ * @see DefaultManagedTaskScheduler
  * @see ThreadPoolTaskScheduler
  */
 public class ConcurrentTaskScheduler extends ConcurrentTaskExecutor implements TaskScheduler {
 
-	private static Class<?> managedScheduledExecutorService;
+	private static Class<?> managedScheduledExecutorServiceClass;
 
 	static {
 		try {
-			managedScheduledExecutorService = ClassUtils.forName(
+			managedScheduledExecutorServiceClass = ClassUtils.forName(
 					"javax.enterprise.concurrent.ManagedScheduledExecutorService",
 					ConcurrentTaskScheduler.class.getClassLoader());
 		}
 		catch (ClassNotFoundException ex) {
 			// JSR-236 API not available...
-			managedScheduledExecutorService = null;
+			managedScheduledExecutorServiceClass = null;
 		}
 	}
 
@@ -139,8 +141,8 @@ public ConcurrentTaskScheduler(Executor concurrentExecutor, ScheduledExecutorSer
 	public final void setScheduledExecutor(ScheduledExecutorService scheduledExecutor) {
 		if (scheduledExecutor != null) {
 			this.scheduledExecutor = scheduledExecutor;
-			this.enterpriseConcurrentScheduler = (managedScheduledExecutorService != null &&
-					managedScheduledExecutorService.isInstance(scheduledExecutor));
+			this.enterpriseConcurrentScheduler = (managedScheduledExecutorServiceClass != null &&
+					managedScheduledExecutorServiceClass.isInstance(scheduledExecutor));
 		}
 		else {
 			this.scheduledExecutor = Executors.newSingleThreadScheduledExecutor();

spring-context/src/main/java/org/springframework/scheduling/concurrent/DefaultManagedAwareThreadFactory.java

@@ -0,0 +1,116 @@
+/*
+ * 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 org.springframework.scheduling.concurrent;
+
+import java.util.Properties;
+import java.util.concurrent.ThreadFactory;
+import javax.naming.NamingException;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+import org.springframework.beans.factory.InitializingBean;
+import org.springframework.jndi.JndiLocatorDelegate;
+import org.springframework.jndi.JndiTemplate;
+
+/**
+ * JNDI-based variant of {@link CustomizableThreadFactory}, performing a default lookup
+ * for JSR-236's "java:comp/DefaultManagedThreadFactory" in a Java EE 7 environment,
+ * falling back to the local {@link CustomizableThreadFactory} setup if not found.
+ *
+ * <p>This is a convenient way to use managed threads when running in a Java EE 7 environment,
+ * simply using regular local threads otherwise - without conditional setup (like profiles).
+ *
+ * <p>Note: This class is not strictly JSR-236 based; it can work with any regular
+ * {@link java.util.concurrent.ThreadFactory} that can be found in JNDI.
+ *
+ * @author Juergen Hoeller
+ * @since 4.0
+ */
+public class DefaultManagedAwareThreadFactory extends CustomizableThreadFactory implements InitializingBean {
+
+	protected final Log logger = LogFactory.getLog(getClass());
+
+	private JndiLocatorDelegate jndiLocator = new JndiLocatorDelegate();
+
+	private String jndiName = "java:comp/DefaultManagedThreadFactory";
+
+	private ThreadFactory threadFactory = this;
+
+
+	/**
+	 * Set the JNDI template to use for JNDI lookups.
+	 * @see org.springframework.jndi.JndiAccessor#setJndiTemplate
+	 */
+	public void setJndiTemplate(JndiTemplate jndiTemplate) {
+		this.jndiLocator.setJndiTemplate(jndiTemplate);
+	}
+
+	/**
+	 * Set the JNDI environment to use for JNDI lookups.
+	 * @see org.springframework.jndi.JndiAccessor#setJndiEnvironment
+	 */
+	public void setJndiEnvironment(Properties jndiEnvironment) {
+		this.jndiLocator.setJndiEnvironment(jndiEnvironment);
+	}
+
+	/**
+	 * Set whether the lookup occurs in a J2EE container, i.e. if the prefix
+	 * "java:comp/env/" needs to be added if the JNDI name doesn't already
+	 * contain it. PersistenceAnnotationBeanPostProcessor's default is "true".
+	 * @see org.springframework.jndi.JndiLocatorSupport#setResourceRef
+	 */
+	public void setResourceRef(boolean resourceRef) {
+		this.jndiLocator.setResourceRef(resourceRef);
+	}
+
+	/**
+	 * Specify a JNDI name of the {@link java.util.concurrent.ThreadFactory} to delegate to,
+	 * replacing the default JNDI name "java:comp/DefaultManagedThreadFactory".
+	 * <p>This can either be a fully qualified JNDI name, or the JNDI name relative
+	 * to the current environment naming context if "resourceRef" is set to "true".
+	 * @see #setResourceRef
+	 */
+	public void setJndiName(String jndiName) {
+		this.jndiName = jndiName;
+	}
+
+	@Override
+	public void afterPropertiesSet() throws NamingException {
+		if (this.jndiName != null) {
+			try {
+				this.threadFactory = this.jndiLocator.lookup(this.jndiName, ThreadFactory.class);
+			}
+			catch (NamingException ex) {
+				if (logger.isDebugEnabled()) {
+					logger.debug("Failed to find [java:comp/DefaultManagedThreadFactory] in JNDI", ex);
+				}
+				if (logger.isInfoEnabled()) {
+					logger.info("Could not find default managed thread factory in JNDI - " +
+							"proceeding with default local thread factory");
+				}
+			}
+		}
+	}
+
+
+	@Override
+	public Thread newThread(Runnable runnable) {
+		return this.threadFactory.newThread(runnable);
+	}
+
+}

spring-context/src/main/java/org/springframework/scheduling/concurrent/DefaultManagedTaskExecutor.java

@@ -0,0 +1,91 @@
+/*
+ * 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 org.springframework.scheduling.concurrent;
+
+import java.util.Properties;
+import java.util.concurrent.Executor;
+import javax.naming.NamingException;
+
+import org.springframework.beans.factory.InitializingBean;
+import org.springframework.jndi.JndiLocatorDelegate;
+import org.springframework.jndi.JndiTemplate;
+
+/**
+ * JNDI-based variant of {@link ConcurrentTaskExecutor}, performing a default lookup for
+ * JSR-236's "java:comp/DefaultManagedExecutorService" in a Java EE 7 environment.
+ *
+ * <p>Note: This class is not strictly JSR-236 based; it can work with any regular
+ * {@link java.util.concurrent.Executor} that can be found in JNDI.
+ * The actual adapting to {@link javax.enterprise.concurrent.ManagedExecutorService}
+ * happens in the base class {@link ConcurrentTaskExecutor} itself.
+ *
+ * @author Juergen Hoeller
+ * @since 4.0
+ */
+public class DefaultManagedTaskExecutor extends ConcurrentTaskExecutor implements InitializingBean {
+
+	private JndiLocatorDelegate jndiLocator = new JndiLocatorDelegate();
+
+	private String jndiName = "java:comp/DefaultManagedExecutorService";
+
+
+	/**
+	 * Set the JNDI template to use for JNDI lookups.
+	 * @see org.springframework.jndi.JndiAccessor#setJndiTemplate
+	 */
+	public void setJndiTemplate(JndiTemplate jndiTemplate) {
+		this.jndiLocator.setJndiTemplate(jndiTemplate);
+	}
+
+	/**
+	 * Set the JNDI environment to use for JNDI lookups.
+	 * @see org.springframework.jndi.JndiAccessor#setJndiEnvironment
+	 */
+	public void setJndiEnvironment(Properties jndiEnvironment) {
+		this.jndiLocator.setJndiEnvironment(jndiEnvironment);
+	}
+
+	/**
+	 * Set whether the lookup occurs in a J2EE container, i.e. if the prefix
+	 * "java:comp/env/" needs to be added if the JNDI name doesn't already
+	 * contain it. PersistenceAnnotationBeanPostProcessor's default is "true".
+	 * @see org.springframework.jndi.JndiLocatorSupport#setResourceRef
+	 */
+	public void setResourceRef(boolean resourceRef) {
+		this.jndiLocator.setResourceRef(resourceRef);
+	}
+
+	/**
+	 * Specify a JNDI name of the {@link java.util.concurrent.Executor} to delegate to,
+	 * replacing the default JNDI name "java:comp/DefaultManagedExecutorService".
+	 * <p>This can either be a fully qualified JNDI name, or the JNDI name relative
+	 * to the current environment naming context if "resourceRef" is set to "true".
+	 * @see #setConcurrentExecutor
+	 * @see #setResourceRef
+	 */
+	public void setJndiName(String jndiName) {
+		this.jndiName = jndiName;
+	}
+
+	@Override
+	public void afterPropertiesSet() throws NamingException {
+		if (this.jndiName != null) {
+			setConcurrentExecutor(this.jndiLocator.lookup(this.jndiName, Executor.class));
+		}
+	}
+
+}