Cara SpringBoot melaksanakan panggilan tak segerak dengan elegan

Kata Pendahuluan

• Pengaturcaraan segerak: Dalam pengaturcaraan segerak, tugasan dilaksanakan satu demi satu, dan hanya apabila satu tugas selesai, tugas seterusnya akan dinyahsekat.

• Pengaturcaraan Asynchronous: Dalam pengaturcaraan tak segerak, berbilang tugas boleh dilakukan serentak. Anda boleh beralih ke tugasan lain sebelum tugasan sebelumnya selesai.

Dalam Spring Boot, kita boleh menggunakan anotasi @Async untuk melaksanakan gelagat tak segerak.

Langkah pelaksanaan

1 Tentukan antara muka perkhidmatan tak segerakAsyncService.java

public interface AsyncService {

    void asyncMethod() throws InterruptedException;

    Future<String> futureMethod() throws InterruptedException;
}

2. Laksanakan antara muka yang ditentukanAsyncServiceImpl.java

@Service
@Slf4j
public class AsyncServiceImpl implements AsyncService  {

    @Async
    @Override
    public void asyncMethod() throws InterruptedException {
        Thread.sleep(3000);
        log.info("Thread: [{}], Calling other service..", Thread.currentThread().getName());
    }

    @Async
    @Override
    public Future<String> futureMethod() throws InterruptedException {
        Thread.sleep(5000);
        log.info("Thread: [{}], Calling other service..", Thread.currentThread().getName());
        return new AsyncResult<>("task Done");
    }
}

• AsyncServiceImpl ialah spring terurus bean.

• Kaedah tak segerak anda mestilah terbuka dan dihiasi dengan anotasi @Async.

• jenis pemulangan terhad kepada void atau Future.

3 Tentukan pengawal AsyncController.java

@EnableAsync
@RestController
@Slf4j
public class AsyncController {
    @Autowired
    AsyncService asyncService;

    @GetMapping("/async")
    public String asyncCallerMethod() throws InterruptedException {
        long start = System.currentTimeMillis();
        log.info("call async method, thread name: [{}]", Thread.currentThread().getName());
        asyncService.asyncMethod();
        String response = "task completes in :" +
                (System.currentTimeMillis() - start) + "milliseconds";
        return response;
    }

    @GetMapping("/asyncFuture")
    public String asyncFuture() throws InterruptedException, ExecutionException {
        long start = System.currentTimeMillis();
        log.info("call async method, thread name: [{}]", Thread.currentThread().getName());
        Future<String> future = asyncService.futureMethod();
        // 阻塞获取结果
        String taskResult = future.get();
        String response = taskResult + "task completes in :" +
                (System.currentTimeMillis() - start) + "milliseconds";
        return response;
    }
}

• Inti utama ialah menambah anotasi untuk mendayakan tak segerak @EnableAsync, sudah tentu anotasi ini Tidak mengapa untuk menambahkannya di tempat lain.

• Apabila antara muka ini dipanggil secara luaran, asyncMethod() akan dilaksanakan oleh utas lain yang dicipta oleh pelaksana tugas lalai, dan utas utama tidak perlu menunggu penyiapan asynchronous pelaksanaan kaedah.

4. Jalankan

Sekarang mari jalankan dan lihat jika ia kembali secara tidak segerak.

Anda boleh melihat bahawa antara muka /async dipanggil dan kaedah dipanggil pada langkah terakhir.

menelefon /asyncFuture dan mendapati pemulangannya lebih daripada 5 saat. Bukankah ia tidak segerak? Malah, ia juga tidak segerak, seperti yang anda boleh lihat dari log, tetapi apa yang kami kembalikan ialah Future, dan panggilan Futrue.get() disekat.

Pelaksana tugas tak segerak tersuai dan pengendalian pengecualian

Mari kita lihat sekarang apa yang berlaku jika ralat dilaporkan dalam kaedah pengecualian? Ubah suai kod tak segerak seperti berikut, dan pengecualian masa jalan akan dilemparkan:

Laksanakan antara muka tak segerak sekali lagi, seperti yang ditunjukkan di bawah, dan kumpulan benang lalai dan pengendalian pengecualian akan digunakan.

Kami juga boleh menyesuaikan pengendalian pengecualian kaedah tak segerak dan pelaksana tugas tak segerak Kami perlu mengkonfigurasi AsyncUncaughtExceptionHandler, seperti yang ditunjukkan dalam kod berikut:

@Configuration
public class AsynConfiguration extends AsyncConfigurerSupport {
   @Override
   public Executor getAsyncExecutor() {
      ThreadPoolTaskExecutor executor = new 
                ThreadPoolTaskExecutor();
      executor.setCorePoolSize(3);
      executor.setMaxPoolSize(4);
      executor.setThreadNamePrefix("asyn-task-thread-");
      executor.setWaitForTasksToCompleteOnShutdown(true);
      executor.initialize();
      return executor;
  }
  @Override
  public AsyncUncaughtExceptionHandler  
         getAsyncUncaughtExceptionHandler() {
     return new AsyncUncaughtExceptionHandler() {
   
        @Override
        public void handleUncaughtException(Throwable ex, 
           Method method, Object... params) {
           System.out.println("Exception: " + ex.getMessage());
           System.out.println("Method Name: " + method.getName());
           ex.printStackTrace();
        }
    };
  }
}

Menjalankannya semula, hasilnya adalah seperti berikut:

Cara @Async berfungsi

mesti diberi anotasi dengan menggunakan

anotasi pada aplikasi utama kelas atau mana-mana kelas pemanggil kaedah async langsung atau Tidak langsung untuk mendayakan sokongan async. Dilaksanakan terutamanya melalui mod proksi, mod lalai ialah @EnableAsync, yang lain ialah Proxy. Mod proksi hanya membenarkan panggilan dipintas melalui proksi. Jangan sekali-kali memanggil kaedah async daripada kelas yang sama di mana ia ditakrifkan, ia tidak akan berfungsi. AspectJ

Apabila kaedah dianotasi dengan

, ia mencipta proksi untuk objek berdasarkan atribut "@Async". Apabila proxyTargetClass melaksanakan kaedah ini, secara lalai ia mencari definisi kumpulan benang yang berkaitan. Satu-satunya spring bingkai dalam konteks ialah spring atau TaskExecutor bean bernama "taskExecutor". Jika kedua-duanya tidak boleh diselesaikan, rangka kerja spring Executor bean akan digunakan secara lalai untuk mengendalikan pelaksanaan kaedah tak segerak. SimpleAsyncTaskExecutor

Atas ialah kandungan terperinci Cara SpringBoot melaksanakan panggilan tak segerak dengan elegan. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!