Open Source Repository

Home /spring/spring-context-3.0.5 | Repository Home



org/springframework/scheduling/config/TaskExecutorFactoryBean.java
/*
 * Copyright 2002-2010 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.config;

import org.springframework.beans.BeanWrapper;
import org.springframework.beans.BeanWrapperImpl;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.FactoryBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.core.JdkVersion;
import org.springframework.core.task.TaskExecutor;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.util.StringUtils;

/**
 * FactoryBean for creating ThreadPoolTaskExecutor instances, choosing
 * between the standard concurrent and the backport-concurrent variant.
 *
 @author Mark Fisher
 @author Juergen Hoeller
 @since 3.0
 */
public class TaskExecutorFactoryBean implements
    FactoryBean<TaskExecutor>, BeanNameAware, InitializingBean, DisposableBean {

  private String poolSize;

  private Integer queueCapacity;

  private Object rejectedExecutionHandler;

  private Integer keepAliveSeconds;

  private String beanName;

  private TaskExecutor target;


  public void setPoolSize(String poolSize) {
    this.poolSize = poolSize;
  }

  public void setQueueCapacity(int queueCapacity) {
    this.queueCapacity = queueCapacity;
  }

  public void setRejectedExecutionHandler(Object rejectedExecutionHandler) {
    this.rejectedExecutionHandler = rejectedExecutionHandler;
  }

  public void setKeepAliveSeconds(int keepAliveSeconds) {
    this.keepAliveSeconds = keepAliveSeconds;
  }

  public void setBeanName(String beanName) {
    this.beanName = beanName;
  }


  public void afterPropertiesSet() throws Exception {
    Class<?> executorClass = (shouldUseBackport() ?
        getClass().getClassLoader().loadClass("org.springframework.scheduling.backportconcurrent.ThreadPoolTaskExecutor":
        ThreadPoolTaskExecutor.class);
    BeanWrapper bw = new BeanWrapperImpl(executorClass);
    determinePoolSizeRange(bw);
    if (this.queueCapacity != null) {
      bw.setPropertyValue("queueCapacity"this.queueCapacity);
    }
    if (this.keepAliveSeconds != null) {
      bw.setPropertyValue("keepAliveSeconds"this.keepAliveSeconds);
    }
    if (this.rejectedExecutionHandler != null) {
      bw.setPropertyValue("rejectedExecutionHandler"this.rejectedExecutionHandler);
    }
    if (this.beanName != null) {
      bw.setPropertyValue("threadNamePrefix"this.beanName + "-");
    }
    this.target = (TaskExecutorbw.getWrappedInstance();
    if (this.target instanceof InitializingBean) {
      ((InitializingBeanthis.target).afterPropertiesSet();
    }
  }

  private boolean shouldUseBackport() {
    return (StringUtils.hasText(this.poolSize&& this.poolSize.startsWith("0"&&
        JdkVersion.getMajorJavaVersion() < JdkVersion.JAVA_16);
  }

  private void determinePoolSizeRange(BeanWrapper bw) {
    if (StringUtils.hasText(this.poolSize)) {
      try {
        int corePoolSize;
        int maxPoolSize;
        int separatorIndex = this.poolSize.indexOf('-');
        if (separatorIndex != -1) {
          corePoolSize = Integer.valueOf(this.poolSize.substring(0, separatorIndex));
          maxPoolSize = Integer.valueOf(this.poolSize.substring(separatorIndex + 1this.poolSize.length()));
          if (corePoolSize > maxPoolSize) {
            throw new IllegalArgumentException(
                "Lower bound of pool-size range must not exceed the upper bound");
          }
          if (this.queueCapacity == null) {
            // no queue-capacity provided, so unbounded
            if (corePoolSize == 0) {
              // actually set 'corePoolSize' to the upper bound of the range
              // but allow core threads to timeout
              bw.setPropertyValue("allowCoreThreadTimeOut"true);
              corePoolSize = maxPoolSize;
            }
            else {
              // non-zero lower bound implies a core-max size range
              throw new IllegalArgumentException(
                  "A non-zero lower bound for the size range requires a queue-capacity value");
            }
          }
        }
        else {
          Integer value = Integer.valueOf(this.poolSize);
          corePoolSize = value;
          maxPoolSize = value;
        }
        bw.setPropertyValue("corePoolSize", corePoolSize);
        bw.setPropertyValue("maxPoolSize", maxPoolSize);
      }
      catch (NumberFormatException ex) {
        throw new IllegalArgumentException("Invalid pool-size value [" this.poolSize + "]: only single " +
            "maximum integer (e.g. \"5\") and minimum-maximum range (e.g. \"3-5\") are supported", ex);
      }
    }
  }


  public TaskExecutor getObject() {
    return this.target;
  }

  public Class<? extends TaskExecutor> getObjectType() {
    if (this.target != null) {
      return this.target.getClass();
    }
    return (!shouldUseBackport() ? ThreadPoolTaskExecutor.class : TaskExecutor.class);
  }

  public boolean isSingleton() {
    return true;
  }


  public void destroy() throws Exception {
    if (this.target instanceof DisposableBean) {
      ((DisposableBeanthis.target).destroy();
    }
  }

}