java类org.springframework.scheduling.annotation.AsyncResult的实例源码

@Test
public void get_witValueLoaderAndNonExistingValue_createsValueFromValueLoaderAndStoresItInCache() throws Exception {

    //Arrange
    MemcachedClientIF client = mock(MemcachedClientIF.class);
    SimpleSpringMemcached cache = new SimpleSpringMemcached(client, "test");
    cache.setExpiration(42);

    when(client.set("myKey", 42, "createdValue")).thenReturn(new AsyncResult<>(true));

    //Act
    String value = cache.get("myKey", () -> "createdValue");

    //Assert
    assertEquals("createdValue", value);
}

@Async
public Future<Integer> test(int i, int size, Date start) {
    try
    {
        Thread.sleep(33);
    }
    catch(Exception e)
    {
        e.printStackTrace();
    }
    if (0 == i %2) {
        throw new RuntimeException("test");
    }
    System.out.println(i);
    return new AsyncResult<Integer>(i);
}

@Async("myTaskAsyncPool")
public Future<Integer> doAsyncTask(String tableName, List<EventData> dataList, String destination) {
    try {
        MDC.put("destination", destination);
        logger.info("thread: " + Thread.currentThread().getName() + " is doing job :" + tableName);
        for (EventData eventData : dataList) {
            SpringUtil.doEvent(eventData.getPath(), eventData.getDbObject());
        }
    } catch (Exception e) {
        logger.error("thread:" + Thread.currentThread().getName() + " get Exception", e);
        return new AsyncResult(0);
    }
    return new AsyncResult(1);
}

@Async
public Future<Employee> readEmployee(Integer empId) {
    try {
        System.out.println("service:readEmployee(empid) task executor: " + Thread.currentThread().getName());
        System.out.println("processing for 2000 ms");
        System.out.println("readEmployee @Async login: " + SecurityContextHolder.getContext().getAuthentication().getPrincipal());
        Thread.sleep(2000);
    } catch (InterruptedException e) {

        e.printStackTrace();
    }
    return new AsyncResult<>(employeeDaoImpl.getEmployee(empId));
}

@Async
public Future<Employee> readEmployee(Integer empId) {
    try {
        System.out.println("service:readEmployee(empid) task executor: " + Thread.currentThread().getName());
        System.out.println("processing for 2000 ms");
        System.out.println("readEmployee @Async login: " + SecurityContextHolder.getContext().getAuthentication().getPrincipal());
        Thread.sleep(2000);
    } catch (InterruptedException e) {

        e.printStackTrace();
    }
    return new AsyncResult<>(employeeDaoImpl.getEmployee(empId));
}

@Async
public Future<Employee> readEmployee(Integer empId) {
    try {
        System.out.println("service:readEmployee(empid) task executor: " + Thread.currentThread().getName());
        System.out.println("processing for 2000 ms");
        System.out.println("readEmployee @Async login: " + SecurityContextHolder.getContext().getAuthentication().getPrincipal());
        Thread.sleep(2000);
    } catch (InterruptedException e) {

        e.printStackTrace();
    }
    return new AsyncResult<>(employeeDaoImpl.getEmployee(empId));
}

@Async
 Future<String> doTaskOne() throws Exception {
    System.out.println("开始做任务一");
    long start = System.currentTimeMillis();
    Thread.sleep(random.nextInt(10000));
    long end = System.currentTimeMillis();
    System.out.println("完成任务一，耗时：" + (end - start) + "毫秒");
    return new AsyncResult<>("任务一OK");
}

@Async
Future<String> doTaskTwo() throws Exception {
    System.out.println("开始做任务二");
    long start = System.currentTimeMillis();
    Thread.sleep(random.nextInt(10000));
    long end = System.currentTimeMillis();
    System.out.println("完成任务二，耗时：" + (end - start) + "毫秒");
    return new AsyncResult<>("任务二OK");
}

@Async
Future<String> doTaskThree() throws Exception {
    System.out.println("开始做任务三");
    long start = System.currentTimeMillis();
    Thread.sleep(random.nextInt(10000));
    long end = System.currentTimeMillis();
    System.out.println("完成任务三，耗时：" + (end - start) + "毫秒");
    return new AsyncResult<>("任务三OK");
}

@Override
@Async
public Future<List<ProcessModelDTO>> findActiveProcessModels(final Pageable pageable) {
  final List<ProcessModelImpl> results = processModelRepository.findActiveProcesses();

  final List<ProcessModelDTO> processModels = createProcessModelDTO(results);

  return new AsyncResult<List<ProcessModelDTO>>(processModels);
}