Home > Posts > Beginner's Guide to Apex

Beginner's Guide to Apex

  ·   15 min read

Introduction to Apex #

What is Apex? #

Apex is a strongly-typed, object-oriented programming language that allows developers to execute flow and transaction control statements on the Salesforce platform. It’s specifically designed for extending the functionality of Salesforce, enabling customization beyond the capabilities of the standard declarative tools like point-and-click configuration. Apex code runs in the Salesforce cloud, directly interacting with Salesforce data and metadata. Think of it as the “back-end” programming language for Salesforce, allowing you to build custom business logic, automate processes, and integrate with external systems. It’s similar to Java in syntax but is tailored to the Salesforce platform’s architecture and data model.

Why use Apex? #

You’d use Apex when declarative tools aren’t sufficient to meet your specific business requirements. Here are some key reasons:

  • Complex Business Logic: When your automation needs extend beyond simple workflows, Apex provides the power to implement intricate logic involving conditional statements, loops, and data manipulation.
  • Custom Business Processes: Create entirely new processes or significantly enhance existing ones by automating tasks, integrating with external services, and reacting to specific events within Salesforce.
  • Data Manipulation: Perform complex data operations beyond the capabilities of standard Salesforce tools, such as bulk data imports, updates, and deletions.
  • Integration with External Systems: Connect Salesforce to other systems through APIs, exchanging data and triggering actions based on external events.
  • User Interface Enhancements: While not the primary purpose, Apex can be used to enhance user interfaces indirectly by creating custom controllers for Visualforce pages or Lightning Web Components.
  • Increased Efficiency and Automation: Automate repetitive tasks, reducing manual effort and increasing overall efficiency.

Apex and Salesforce #

Apex is deeply integrated into the Salesforce ecosystem. It directly interacts with Salesforce objects, fields, and APIs. Apex code runs within the Salesforce governor limits, ensuring that individual Apex executions don’t consume excessive resources and maintain the stability of the platform. Understanding Salesforce’s data model and architecture is essential for writing effective Apex code. Moreover, Apex leverages Salesforce’s security model to ensure data integrity and access control. Any Apex code you write must adhere to Salesforce’s security and governor limits.

Setting up your Development Environment #

To develop Apex code, you’ll need a few key components:

  1. Salesforce Developer Account: You’ll need a Salesforce Developer Edition account or a Developer Org within a paid Salesforce account. This provides you with a sandbox environment to write, test, and deploy your code without affecting your production data. You can sign up for a free Developer Edition account on the Salesforce website.

  2. Salesforce IDE or Tooling API: You have several choices for writing and deploying Apex:

    • Salesforce’s Developer Console: This is a built-in web-based IDE within Salesforce. It’s a good starting point for beginners due to its ease of access and integration with Salesforce.
    • Third-Party IDEs (VS Code, IntelliJ, etc.): These offer advanced features like code completion, debugging, and integrated version control, significantly enhancing productivity. You’ll need to configure them using the Salesforce DX CLI or the Tooling API. VS Code with the Salesforce Extension Pack is a particularly popular choice.

  3. Salesforce CLI (Optional but Recommended): The Salesforce CLI (Command Line Interface) provides a powerful way to interact with your Salesforce org from your terminal. It simplifies tasks like deploying code, creating scratch orgs, and managing metadata.

Once you’ve set up your account and chosen your development environment, you’re ready to begin writing your first Apex code. Remember to refer to the official Salesforce Apex documentation for comprehensive information and best practices.

Basic Apex Syntax #

Data Types #

Apex supports a variety of data types to represent different kinds of information. Understanding these data types is crucial for writing well-structured and efficient code. Here are some fundamental data types:

  • Id: A unique identifier for Salesforce records (e.g., Accounts, Contacts).
  • String: Represents text. Enclosed in double quotes (" “).
  • Integer: Represents whole numbers (e.g., 10, -5, 0).
  • Long: Represents larger whole numbers than Integer.
  • Double: Represents floating-point numbers (numbers with decimal points).
  • Decimal: Similar to Double, but specifically designed for currency values. Provides greater precision.
  • Boolean: Represents true or false values.
  • Date: Represents a date (year, month, day).
  • DateTime: Represents a date and time.
  • Object: The base class for all other classes.
  • List<T>: An ordered collection of elements of type T.
  • Set<T>: An unordered collection of unique elements of type T.
  • Map<K,V>: A collection of key-value pairs, where K is the key type and V is the value type.

Variables and Constants #

Variables are used to store data that can change during the execution of your program. Constants store values that remain unchanged.

Declaring Variables:

String name = 'John Doe';
Integer age = 30;
Boolean isEmployed = true;

The syntax is data_type variable_name = value;

Declaring Constants:

Constants are declared using the final keyword:

final Integer MAX_ATTEMPTS = 3;

Once a constant is assigned a value, it cannot be changed.

Operators #

Apex supports various operators for performing calculations and comparisons:

  • Arithmetic Operators: +, -, *, /, % (modulo)
  • Comparison Operators: == (equals), != (not equals), >, <, >=, <=
  • Logical Operators: && (AND), || (OR), ! (NOT)
  • Assignment Operators: =, +=, -=, *=, /=, %=

Control Flow Statements #

Control flow statements determine the order in which code is executed.

if-else Statement:

Integer x = 10;
if (x > 5) {
    System.debug('x is greater than 5');
} else {
    System.debug('x is not greater than 5');
}

for Loop:

for (Integer i = 0; i < 5; i++) {
    System.debug('Iteration: ' + i);
}

while Loop:

Integer i = 0;
while (i < 5) {
    System.debug('Iteration: ' + i);
    i++;
}

Comments #

Comments are used to explain your code and make it easier to understand. Apex supports two types of comments:

  • Single-line comments: Start with //
// This is a single-line comment
  • Multi-line comments: Start with /* and end with */
/*
This is a
multi-line comment
*/
```  Using comments effectively is crucial for code maintainability and collaboration.


## Working with SOQL and DML

### SOQL Queries (`SELECT`, `WHERE`, `LIMIT`, `ORDER BY`)

SOQL (Salesforce Object Query Language) is used to retrieve data from Salesforce.  It's similar to SQL.  Here's a breakdown of common clauses:

* **`SELECT`:** Specifies the fields to retrieve.

```java
List<Account> accounts = [SELECT Name, Industry FROM Account LIMIT 10];

  • FROM: Specifies the object to query (e.g., Account, Contact, Opportunity).

  • WHERE: Filters the results based on specified criteria.

List<Contact> contacts = [SELECT FirstName, LastName FROM Contact WHERE AccountId = '001xxxxxxxxxxxxxxx'];

  • LIMIT: Limits the number of records returned.

  • ORDER BY: Sorts the results.

List<Contact> contacts = [SELECT FirstName, LastName FROM Contact ORDER BY LastName LIMIT 10];

You can combine these clauses to create complex queries. For instance, to retrieve the names of the top 5 accounts in the Technology industry, ordered alphabetically:

List<Account> topAccounts = [SELECT Name FROM Account WHERE Industry = 'Technology' ORDER BY Name LIMIT 5];

DML Operations (INSERT, UPDATE, DELETE, UPSERT) #

DML (Data Manipulation Language) operations allow you to create, update, and delete records in Salesforce.

  • INSERT: Creates new records.
Account newAccount = new Account(Name = 'Acme Corp', Industry = 'Technology');
insert newAccount;
  • UPDATE: Modifies existing records.
Account accToUpdate = [SELECT Id, Name FROM Account WHERE Name = 'Acme Corp' LIMIT 1];
accToUpdate.Industry = 'Manufacturing';
update accToUpdate;
  • DELETE: Deletes records.
List<Account> accountsToDelete = [SELECT Id FROM Account WHERE Name LIKE '%Old%' ];
delete accountsToDelete;
  • UPSERT: Inserts a new record if one doesn’t exist based on a unique key, or updates an existing record if one does exist. Requires specifying the allOrNone parameter to determine behavior for partial failure. It also requires at least one field specified for matching purposes (typically Id or a unique external Id).
Account accToUpsert = new Account(Name = 'Acme Corp', Industry = 'Technology');
upsert accToUpsert; //Will either insert or update

Querying and Manipulating Data #

SOQL is used to query data, and the results are typically stored in lists. DML operations then allow you to modify those records or create new ones based on your query results.

Handling Query Results #

Query results are typically stored in lists of SObjects. You can iterate through these lists using loops to process the data.

List<Account> accounts = [SELECT Name, Industry FROM Account];
for (Account acc : accounts) {
    System.debug('Account Name: ' + acc.Name + ', Industry: ' + acc.Industry);
}

You can also use aggregate functions within SOQL queries to perform calculations on your data like COUNT(), SUM(), AVG(), MIN(), MAX().

Bulkification #

Bulkification is a critical concept for writing efficient Apex code. Instead of performing DML operations on individual records in a loop, you should always work with lists of records. This significantly reduces the number of database interactions and improves performance.

Example of Non-Bulkified (Inefficient) Code:

List<Account> accounts = [SELECT Id FROM Account];
for (Account acc : accounts) {
    acc.Name += ' Inc.';
    update acc; //Inefficient:  Many individual DML operations
}

Example of Bulkified (Efficient) Code:

List<Account> accounts = [SELECT Id, Name FROM Account];
for (Account acc : accounts) {
    acc.Name += ' Inc.';
}
update accounts; //Efficient: Single DML operation on a list

Always strive to process records in batches and execute DML operations on lists instead of individual records to achieve efficient and scalable Apex code. Remember to also be mindful of Salesforce governor limits when working with large datasets.

Building Apex Classes and Triggers #

Creating Apex Classes #

Apex classes are blueprints for creating objects. They encapsulate data (fields) and behavior (methods). To create a class, use the class keyword followed by the class name, and enclose the class body within curly braces {}.

public class AccountHelper {
    // Class members (fields and methods) go here
}

The public keyword indicates that this class can be accessed from other parts of your code. You’ll typically use public for classes that are intended to be used by other parts of your application.

Methods and Constructors #

Methods define the behavior of a class. They perform actions on the class’s data.

public class AccountHelper {
    public static String getAccountName(Account acc) {
        return acc.Name;
    }
}

Constructors are special methods used to initialize objects of a class. They have the same name as the class.

public class Account {
    public String Name;
    public Account(String accName) {
        Name = accName;
    }
}

Access Modifiers #

Access modifiers control the visibility and accessibility of class members (fields and methods).

  • public: Accessible from anywhere.
  • private: Accessible only within the class itself.
  • protected: Accessible within the class and its subclasses (inherited classes).
  • global: Accessible from anywhere, including other orgs (typically used for web services).

It is good practice to use the most restrictive access modifier possible to improve the security and maintainability of your code.

Understanding Triggers (before/after, insert/update/delete) #

Triggers are Apex code that automatically executes before or after specific DML operations (insert, update, delete) on Salesforce records. They allow you to automate processes and enforce business rules.

  • before triggers: Execute before the DML operation. You can modify the records being inserted, updated, or deleted.
  • after triggers: Execute after the DML operation. You can’t modify the records in after triggers, but you can perform actions based on the changes.
  • insert: Triggered when new records are inserted.
  • update: Triggered when existing records are updated.
  • delete: Triggered when records are deleted.

Triggers can respond to a combination of these events (e.g., a before insert and before update trigger).

Writing Efficient Triggers #

Writing efficient triggers is crucial for performance. Here are some best practices:

  • Bulkify your code: Process records in lists, not individually.
  • Use governor limits wisely: Avoid exceeding Salesforce’s governor limits for CPU time, heap size, SOQL queries, and DML operations.
  • Avoid unnecessary SOQL queries: Retrieve only the data you need.
  • Optimize your logic: Write concise and efficient code.
  • Use appropriate trigger context variables: Access data efficiently using context variables.

Trigger Context Variables #

Trigger context variables provide information about the DML operation and the records involved. Important context variables include:

  • Trigger.new: A list of the new records (for insert and update).
  • Trigger.old: A list of the old records (for update and delete).
  • Trigger.isBefore: A boolean indicating whether the trigger is executing before or after the DML operation.
  • Trigger.isDelete: A boolean indicating whether the trigger is for a delete operation.
  • Trigger.isInsert: A boolean indicating whether the trigger is for an insert operation.
  • Trigger.isUpdate: A boolean indicating whether the trigger is for an update operation.

Understanding and effectively using these context variables is vital for writing robust and efficient triggers. They provide a direct way to interact with the data being changed, allowing you to make modifications (in before triggers) or react to those changes (in after triggers).

Error Handling and Best Practices #

Exception Handling (try-catch blocks) #

Exception handling is crucial for writing robust Apex code. try-catch blocks allow you to gracefully handle errors that might occur during the execution of your code.

try {
    // Code that might throw an exception
    Account acc = [SELECT Id FROM Account WHERE Name = 'NonExistent Account'];
} catch (QueryException e) {
    // Handle the QueryException
    System.debug('Error querying Account: ' + e.getMessage());
} catch (Exception e) {
    // Handle other exceptions
    System.debug('An unexpected error occurred: ' + e.getMessage());
}

The try block contains the code that might throw an exception. If an exception occurs, the appropriate catch block is executed. Always handle specific exceptions where possible, and include a general catch (Exception e) block to handle unexpected errors.

Logging and Debugging #

Logging and debugging are essential for identifying and resolving issues in your Apex code.

  • System.debug(): This statement writes messages to the Salesforce debug logs. This is invaluable for tracking the execution flow of your code and identifying potential problems.
System.debug('Entering the method...');
System.debug('The account name is: ' + account.Name);
  • Developer Console: The Salesforce Developer Console provides tools for viewing debug logs and stepping through your code. Use breakpoints to pause execution at specific points in your code.

Testing Your Apex Code #

Thorough testing is crucial to ensure the quality and reliability of your Apex code. Salesforce provides a testing framework that allows you to write unit tests. Unit tests verify that individual components of your code function as expected.

  • Test Classes: Write test classes that contain test methods. Test methods should cover various scenarios, including positive and negative cases.

  • Test Coverage: Salesforce requires a certain level of test coverage (typically 75% or higher) before you can deploy your code to production.

Writing Secure and Efficient Apex #

Security and efficiency are paramount when developing Apex code.

  • Security: Avoid hardcoding sensitive information directly in your code. Use platform features like custom settings or secure external services for storing sensitive data. Validate all user inputs to prevent injection attacks. Use appropriate access modifiers to protect data.

  • Efficiency: Bulkify your DML operations. Avoid unnecessary SOQL queries. Optimize your algorithms for performance. Use appropriate data structures.

Governor Limits #

Salesforce imposes governor limits to ensure the stability and performance of the platform. These limits restrict the amount of resources (CPU time, heap size, SOQL queries, DML operations, etc.) that your Apex code can consume in a single transaction. Exceeding governor limits can lead to errors and prevent your code from running correctly. Understanding and respecting these limits is crucial for developing robust and reliable Apex applications. Refer to the official Salesforce documentation for the most up-to-date information on governor limits. Careful planning and efficient coding practices are necessary to avoid exceeding these limits.

Advanced Apex Topics #

Asynchronous Apex (Future, Queueable) #

Asynchronous Apex allows you to execute long-running processes without blocking the user interface or exceeding governor limits. This is crucial for tasks that might take a significant amount of time to complete.

  • @future annotation: Marks a method to be executed asynchronously. These methods cannot directly interact with the database or user interface. They are ideal for relatively short, independent tasks.
@future
public static void sendEmailAsync(List<String> emails) {
    // Send emails asynchronously
}
  • Queueable interface: Allows for more complex asynchronous operations, including the ability to process data in batches and resume execution across multiple governor limits. This is suitable for longer, potentially more resource-intensive tasks.

Batch Apex #

Batch Apex is designed for processing large volumes of data efficiently. It allows you to divide a large dataset into smaller batches, process each batch individually, and handle failures gracefully.

  • Database.executeBatch(): The core method for executing batch Apex. You’ll create a class that implements the Database.Batchable<SObject> interface. This interface defines methods for querying data (start), processing individual batches (execute), and performing any necessary cleanup (finish). Batch Apex is ideal for operations like bulk updates, data imports, and complex data transformations.

Sharing and Security #

Sharing rules and security best practices are vital for protecting sensitive data.

  • Sharing Rules: Define who has access to specific records. They govern data visibility beyond the standard hierarchy of ownership.

  • Organization-Wide Defaults (OWDs): Set the default access level for all users. They provide a baseline level of data access.

  • Role Hierarchy: Organize users into roles, establishing inheritance of data access permissions.

  • Apex Security: Always validate user inputs and adhere to the principle of least privilege when granting access to data.

Working with Visualforce (Brief Overview) #

Visualforce is a framework for building custom user interfaces within Salesforce. While not strictly Apex, it’s frequently used in conjunction with Apex controllers. Visualforce pages are markup-based, and Apex controllers provide the logic that drives the page’s behavior. Visualforce is largely being replaced by Lightning Web Components (LWC), but understanding its fundamental concepts is still helpful for maintaining legacy code.

Apex REST APIs #

Apex REST APIs allow you to create custom web services that expose Salesforce data and functionality to external applications.

  • @RestResource annotation: Marks a class as a REST resource.

  • HTTP Methods: Use standard HTTP methods like GET, POST, PUT, and DELETE to interact with your REST API.

  • JSON: REST APIs typically use JSON (JavaScript Object Notation) for data exchange.

By using Apex REST APIs, you can build custom integrations with external systems, allowing seamless data exchange between Salesforce and other applications. This unlocks significant possibilities for extending and enhancing the capabilities of your Salesforce org.

←
Beginner's Guide to SAS
Beginner's Guide to Erlang
→
back to top