Usar métodos futuros

• Fazer callouts para serviços da Web externos. Se você estiver fazendo callouts a partir de um acionador ou após realizar uma operação DML, tem que usar um método futuro ou que permita a execução em fila. Um callout em um acionador manteria a conexão com o banco de dados aberta pela duração do callout e isso é inaceitável em um ambiente multilocatário.
• Operações que você deseja executar em seu próprio thread, quando o tempo permitir, como um tipo de cálculo ou processamento de registros com consumo intenso de recursos.
• Isolar operações DML em diferentes tipos de sObject para evitar o erro de DML combinada. Isto é um caso extremo, mas você pode passar por este problema. Consulte sObjects que não podem ser usados juntos em operações DML para obter mais detalhes.

public class SomeClass {
  @future
  public static void someFutureMethod(List<Id> recordIds) {
    List<Account> accounts = [Select Id, Name from Account Where Id IN :recordIds];
    // process account records to do awesome stuff
  }
}

Amostra de código de callout

Para fazer um callout de um serviço da Web para um serviço ou API, crie uma classe de Apex com um método futuro marcado com (callout=true). A classe abaixo tem métodos para fazer callout de forma síncrona e assíncrona onde callouts não são permitidos. Inserimos um registro em um objeto de registro personalizado para monitorar o status do callout simplesmente porque sempre é divertido fazer o registro! 

A classe SmsMessage e o sObject SMS_Log__c no exemplo são hipotéticos e mostrados apenas para demonstrar o padrão de callout.

public class SMSUtils {
    // Call async from triggers, etc, where callouts are not permitted.
    @future(callout=true)
    public static void sendSMSAsync(String fromNbr, String toNbr, String m) {
        String results = sendSMS(fromNbr, toNbr, m);
        System.debug(results);
    }
    // Call from controllers, etc, for immediate processing
    public static String sendSMS(String fromNbr, String toNbr, String m) {
        // Calling 'send' will result in a callout
        String results = SmsMessage.send(fromNbr, toNbr, m);
        insert new SMS_Log__c(to__c=toNbr, from__c=fromNbr, msg__c=results);
        return results;
    }
}

@isTest
public class SMSCalloutMock implements HttpCalloutMock {
    public HttpResponse respond(HttpRequest req) {
        // Create a fake response
        HttpResponse res = new HttpResponse();
        res.setHeader('Content-Type', 'application/json');
        res.setBody('{"status":"success"}');
        res.setStatusCode(200);
        return res;
    }
}

@IsTest
private class Test_SMSUtils {
  @IsTest
  private static void testSendSms() {
    Test.setMock(HttpCalloutMock.class, new SMSCalloutMock());
    Test.startTest();
      SMSUtils.sendSMSAsync('111', '222', 'Greetings!');
    Test.stopTest();
    // runs callout and check results
    List<SMS_Log__c> logs = [select msg__c from SMS_Log__c];
    System.assertEquals(1, logs.size());
    System.assertEquals('success', logs[0].msg__c);
  }
}

• Verifique se os métodos futuros estão sendo executados o mais rápido possível.
• Se você estiver usando callouts de serviço da Web, tente agrupar todos os callouts do mesmo método futuro, em vez de usar um método futuro separado para cada callout.
• Realize testes completos na escala. Teste se um acionador que coloca na fila as chamadas @future é capaz de lidar com uma coleção de acionadores de 200 registros. Isto ajuda a determinar se podem ocorrer atrasos devido ao projeto nos volumes atuais e futuros.
• Considere usar o Apex de lote em vez de métodos futuros para processar um grande número de registros de forma assíncrona. Isto é mais eficiente que criar uma solicitação de futuro para cada registro.

• Métodos com a anotação @future têm de ser métodos estáticos e só podem retornar um tipo void.
• Os parâmetros especificados têm de ser tipos de dados primitivos, matrizes de tipos de dados primitivos ou coleções de tipos de dados primitivos. Métodos futuros não podem ter objetos como argumentos.
• Métodos futuros não são executados necessariamente na mesma ordem em que são chamados. Além disso, é possível que dois métodos futuros sejam executados simultaneamente, o que poderia resultar em bloqueio de registro se os dois métodos estivessem atualizando o mesmo registro.
• Os métodos futuros não podem ser usados com controladores Visualforce em getMethodName(), setMethodName() nem no construtor.
• Não é possível chamar um método futuro a partir de um método futuro. Também não é possível invocar um acionador que chame um método futuro enquanto executa um método futuro. Veja o link em Recursos para evitar chamadas recursivas de método futuro.
• Os métodos getContent() e getContentAsPDF() não podem ser usados em métodos com anotação @future.
• Há uma limitação de 50 chamadas futuras por invocação Apex e um limite adicional no número de chamadas em um período de 24 horas. Para mais informações sobre limites, acesse o link abaixo.