Spring:无法将TaskExecuteImpl类型的值转换为java.util.concurrent.Executor
我有以下bean声明xmlSpring:无法将TaskExecuteImpl类型的值转换为java.util.concurrent.Executor,java,spring,spring-mvc,spring-boot,spring-integration,Java,Spring,Spring Mvc,Spring Boot,Spring Integration,我有以下bean声明xml <bean id="taskExecutor" class="com.XXX.xxx.management.common.executor.TaskExecutorImpl" destroy-method="shutdown"> <constructor-arg name="threadPoolSize" value="5"/> <constructor-arg name="execut
<bean id="taskExecutor" class="com.XXX.xxx.management.common.executor.TaskExecutorImpl"
destroy-method="shutdown">
<constructor-arg name="threadPoolSize" value="5"/>
<constructor-arg name="executionQueueCapacity" value="1000"/>
<constructor-arg name="typeLimit" value="5"/>
</bean>
import java.util.AbstractQueue;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.TreeSet;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.CancellationException;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.FutureTask;
import java.util.concurrent.RejectedExecutionException;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
import javax.annotation.PostConstruct;
public class TaskExecutorImpl implements TaskExecutor {
private final int threadPoolSize;
private final int executionQueueCapacity;
private final int typeLimit;
private BlockingPriorityTaskQueue executionQueue;
private ExecutorService threadPool;
private ConcurrentHashMap<String, AtomicInteger> executionByTypeMap = new ConcurrentHashMap<>();
/**
* Main lock guarding all access
*/
final ReentrantLock mainLock;
/**
* Condition for waiting takes
*/
private final Condition notEmpty;
/**
* Condition for waiting puts
*/
private final Condition notFull;
public TaskExecutorImpl(int threadPoolSize, int executionQueueCapacity, int typeLimit) {
this.threadPoolSize = threadPoolSize;
this.executionQueueCapacity = executionQueueCapacity;
this.typeLimit = typeLimit;
mainLock = new ReentrantLock();
notEmpty = mainLock.newCondition();
notFull = mainLock.newCondition();
}
@PostConstruct
@SuppressWarnings("unchecked")
public void initialize() {
executionQueue = new BlockingPriorityTaskQueue(executionQueueCapacity);
threadPool = new ThreadPoolExecutor(threadPoolSize, threadPoolSize, 0L, TimeUnit.MILLISECONDS,
(BlockingQueue) executionQueue);
// create core threads, required for type control
for (int i = 0; i < threadPoolSize; i++) {
threadPool.execute(new Runnable() {
@Override
public void run() {
// nothing here
}
});
}
}
and other Methdods implementation so on
import java.util.AbstractQueue；
导入java.util.ArrayList；
导入java.util.Collection；
导入java.util.Comparator；
导入java.util.Iterator；
导入java.util.List；
导入java.util.TreeSet；
导入java.util.concurrent.BlockingQueue；
导入java.util.concurrent.CancellationException；
导入java.util.concurrent.ConcurrentHashMap；
导入java.util.concurrent.ExecutionException；
导入java.util.concurrent.ExecutorService；
导入java.util.concurrent.FutureTask；
导入java.util.concurrent.RejectedExecutionException；
导入java.util.concurrent.ThreadPoolExecutor；
导入java.util.concurrent.TimeUnit；
导入java.util.concurrent.TimeoutException；
导入java.util.concurrent.AtomicInteger；
导入java.util.concurrent.locks.Condition；
导入java.util.concurrent.locks.ReentrantLock；
导入javax.annotation.PostConstruct；
公共类TaskExecuteImpl实现TaskExecutor{
私有最终int线程池大小；
专用最终int执行队列容量；
私人最终整数类型限制；
私有阻塞优先级任务队列执行队列；
私人服务线程池；
私有ConcurrentHashMap executionByTypeMap=新ConcurrentHashMap（）；
/**
*保护所有通道的主锁
*/
最终重入锁主锁；
/**
*等候条件
*/
私人最终条件不空；
/**
*等待看跌期权的条件
*/
私人最终条件未满；
公共TaskExecuteImpl（int threadPoolSize、int executionQueueCapacity、int typeLimit）{
this.threadPoolSize=threadPoolSize；
this.executionQueueCapacity=executionQueueCapacity；
this.typeLimit=typeLimit；
mainLock=new ReentrantLock（）；
notEmpty=mainLock.newCondition（）；
notFull=mainLock.newCondition（）；
}
@施工后
@抑制警告（“未选中”）
公共无效初始化（）{
executionQueue=新建BlockingPriorityTaskQueue（executionQueueCapacity）；
threadPool=新的ThreadPoolExecutor（threadPoolSize，threadPoolSize，0L，TimeUnit.毫秒，
（阻塞队列）执行队列）；
//创建类型控制所需的核心线程
对于（int i=0；i