Annotations

Use the future annotation to identify methods that are executed asynchronously. When you specify future, the method executes when Salesforce.com has available resources.

For example, you can use the future annotation when making an asynchronous Web service callout to an external service. Without the annotation, the Web service callout is made from the same thread that is executing the Apex script, and no additional processing can occur until the callout is complete (synchronous processing).

Methods with the future annotation must be static methods, and can only return a void type.

To make a method in a class execute asynchronously, define the method with the future annotation. For example:

global class MyFutureClass {@future 
  static void myMethod(String a, Integer i) {System.debug('Method called with: ' + a + ' and ' + i);
    //do callout, other long running code  
    
  }
}

The following snippet shows how to specify that a method executes a callout:

  @future (callout=true)
  public static void doCalloutFromFuture() {
   //Add code to perform callout  
    
}

You can specify (callout=false) to prevent a method from making callouts.

To test methods defined with the future annotation, call the class containing the method in a startTest, stopTest code block. All asynchronous calls made after the startTest method are collected by the system. When stopTest is executed, all asynchronous processes are run synchronously.

Methods with the future annotation have the following limits:

• No more than 10 method calls per Apex invocation
  Note

  Asynchronous calls, such as @future or executeBatch, called in a startTest, stopTest block, do not count against your limits for the number of queued jobs.
• Methods with the future annotation can execute 100 SOQL queries when they are in the context of a testMethod
• No more than 200 method calls per Salesforce.com license per 24 hours
• The parameters specified must be primitive dataypes, arrays of primitive datatypes, or collections of primitive datatypes.
• Methods with the future annotation cannot take sObjects or objects as arguments.
• Methods with the future annotation cannot be used in Visualforce controllers in either getMethodName or setMethodName methods, nor in the constructor.

Remember that any method using the future annotation requires special consideration, because the method does not necessarily execute in the same order it is called.

You cannot call a method annotated with future from a method that also has the future annotation. Nor can you call a trigger from an annotated method that calls another annotated method.

The getContent and getContentAsPDF PageReference methods cannot be used in methods with the future annotation.

For more information about callouts, see Invoking Callouts Using Apex.

Use the isTest annotation to define classes or individual methods that only contain code used for testing your application. The isTest annotation is similar to creating methods declared as testMethod.

Note

Classes defined with the isTest annotation do not count against your organization limit of 1 MB for all Apex scripts. Individual methods defined with the isTest annotation do count against your organization limits. For more information, see Understanding Execution Governors and Limits.

Classes and methods defined as isTest must be declared as private. For example:

@isTest
private class MyTest {

// Methods for testing  
    

}

Classes defined as isTest cannot be interfaces or enums.

A class defined as isTest can only be invoked using the Force.comrunTests()API call, or from the Salesforce.com user interface (using the Run Tests button). You cannot call it from another class or trigger.

Use the deprecated annotation to identify methods, classes, exceptions, enums, interfaces, or variables that can no longer be referenced in subsequent releases of the managed package in which they reside. This is useful when you are refactoring code in managed packages as the requirements evolve. New subscribers cannot see the deprecated elements, while the elements continue to function for existing subscribers and API integrations.

The following code snippet shows a deprecated method. The same syntax can be used to deprecate classes, exceptions, enums, interfaces, or variables.

  @deprecated
  // This method is deprecated. Use myOptimizedMethod(String a, String b) instead.  
    
  public void myMethod(String a) {
   
}

Note the following rules when deprecating Apex identifiers:

• Unmanaged packages cannot contain code that uses the deprecated keyword.
• When something in Apex, or when a custom object is deprecated, all global access modifiers that reference the deprecated identifier must also be deprecated. Any global method that uses the deprecated type in its signature, either in an input argument or the method return type, must also be deprecated. A deprecated item, such as a method or a class, can still be referenced internally by the package developer.
• webService methods and variables cannot be deprecated.
• You can deprecate an enum but you cannot deprecate individual enum values.
• You can deprecate an interface but you cannot deprecate individual methods in an interface.
• You can deprecate an abstract class but you cannot deprecate individual abstract methods in an abstract class.
• You cannot remove the deprecated annotation to undeprecate something in Apex after you have released a package version where that item in Apex is deprecated.

For more information about package versions, see Developing Apex in Managed Packages.