Apex Programming Language

• Apex is a proprietary language developed by Salesforce.com
• Apex is a strongly-typed, object-oriented programming language
• Apex is used to execute flow and transaction control statements on the Salesforce platform in conjunction with calls to the Force.com API
• Apex enables developers to add business logic to system events, such as button clicks, related record updates, and Visualforce pages
• Apex code can be initiated by Web service requests and from triggers

Key Features of Apex

• Integrated: Apex provides built-in support for DML operations, allowing direct database access and manipulation
• Cloud-Based: Apex is stored, compiled, and executed on the Salesforce servers
• Multitenant Aware: Apex code is designed to prevent any single piece of code from monopolizing shared resources
• Easy to Use: Apex syntax is similar to Java and C#, making it easier for developers with experience in these languages to learn
• Data Focused: Apex provides direct access to Salesforce data, with built-in SOQL and DML capabilities
• Versioned: Apex code is saved with specific API versions to maintain consistent behavior as Salesforce evolves
• Secure: Apex enforces security standards such as user-level security and field-level security
• Automated Testing: Apex supports unit testing to ensure code quality and reliability
• Upgradeable: Apex code is automatically upgraded when Salesforce releases new versions

Apex Trigger

• Apex triggers enable custom actions before or after changes to Salesforce records (insertions, updates, or deletions)
• Triggers execute during specific database events such as before insert or after update
• Triggers can be defined for standard objects (Account, Contact, etc.) and custom objects using Apex
• Triggers enforce business rules, validate data, or perform automated tasks
• Syntax: trigger TriggerName on ObjectName (trigger_events) { // Code block }
• trigger_events include before insert, after insert, before update, after update, before delete, after delete, after undelete
• A single trigger can handle multiple events using conditional statements
• Trigger.new and Trigger.old context variables access records initiating the trigger
• Governor limits apply to trigger execution to prevent runaway code
• Best practice involves using a handler class to encapsulate trigger logic and promote reusability

Governor Limits

• Governor limits are runtime constraints enforced by the Apex runtime engine
• They prevent code from monopolizing shared resources in the multitenant environment
• Limits exist for:
  • Total SOQL queries issued
  • Total DML statements issued (insert, update, delete)
  • CPU time used
  • Heap size
  • Number of records processed as a result of DML, queries, or search operations
  • Maximum stack depth
• Failure to adhere to governor limits results in runtime exceptions that halt code execution
• Mitigating strategies include:
  • Bulkifying code
  • Using efficient queries
  • Designing for scale
• future methods, queueable Apex, and batch Apex can process large volumes of data asynchronously, avoiding immediate governor limits

Apex Classes

• Apex classes are blueprints for creating objects and defining variables and methods
• Classes encapsulate logic to be reused across multiple parts of an application
• The class keyword defines a class
• Classes have member variables (properties) and methods (functions)
• Access modifiers (public, private, protected, global) control the visibility and accessibility of class members
• Apex supports object-oriented principles: inheritance, encapsulation, and polymorphism
• Classes can implement interfaces to provide a specific contract of methods
• Constructors initialize objects when they are created
• Static variables and methods belong to the class, not to a specific instance
• Example: public class MyClass { public String myString; public void myMethod() { // Code } }

SOQL (Salesforce Object Query Language)

• SOQL reads information stored in the Salesforce database
• It is similar to SQL but designed specifically for Salesforce data
• SOQL queries can be executed directly in Apex code
• SOQL queries are enclosed in square brackets [ ]
• Basic syntax: SELECT fields FROM object WHERE conditions
• Use the WHERE clause to filter results based on specified conditions
• Operators include =, !=, ``, =, LIKE, IN
• Aggregate functions include COUNT(), SUM(), AVG(), MIN(), MAX()
• Use the GROUP BY clause to group results based on specified fields
• Use the ORDER BY clause to sort results based on specified fields
• Use the LIMIT clause to restrict the number of records returned
• Relationship queries retrieve related records from parent or child objects
• Example: List accounts = [SELECT Id, Name FROM Account WHERE Industry = 'Technology' LIMIT 100];

DML Operations

• DML (Data Manipulation Language) operations insert, update, delete, and undelete data in the Salesforce database
• Operations include:
  • insert: Creates new records
  • update: Modifies existing records
  • delete: Removes records from the database
  • upsert: Inserts new records and updates existing records based on a specified field
  • undelete: Restores previously deleted records from the recycle bin
• Database methods (e.g., Database.insert, Database.update) control the behavior of DML operations, like allowing partial success
• DML operations trigger workflows, validation rules, and triggers
• Best practice is to perform DML operations in bulk to minimize governor limit usage
• Use try-catch blocks to handle exceptions during DML operations

Testing Apex Code

• All Apex code must have at least 75% test coverage before deployment to a production environment
• Test classes verify the functionality and correctness of Apex code
• Test methods should cover positive scenarios, negative scenarios, and bulk scenarios
• Use the @isTest annotation to define test classes and methods
• Use System.assert methods to verify code behavior
• Test methods do not count against governor limits
• Test.startTest() and Test.stopTest() create a fresh set of governor limits for each test method
• Test data should be created within the test method for consistent and isolated test results
• Mock objects can simulate external dependencies and control code behavior under test
• Avoid hardcoding IDs in test methods; use dynamic SOQL queries or test data factories

Asynchronous Apex

• Asynchronous Apex executes long-running operations in a separate thread, outside of the user's request
• This avoids governor limits and improves application performance
• Common types include:
  • Future methods: Methods annotated with @future that run asynchronously when resources are available
  • Queueable Apex: A more advanced form of asynchronous processing that allows chaining of jobs and use of non-primitive data types
  • Batch Apex: Processes large sets of records in batches, splitting the work into smaller chunks
  • Scheduled Apex: Schedules Apex classes to run at specific times or intervals
• System.enqueueJob enqueues a queueable Apex job
• Batch Apex classes implement the Database.Batchable interface and consist of start, execute, and finish methods
• Scheduled Apex classes implement the Schedulable interface and implement the execute method
• Monitor asynchronous Apex jobs using the Apex Jobs page in Salesforce Setup

Visualforce and Apex Interaction

• Visualforce is a markup language for creating custom user interfaces on the Salesforce platform
• Apex controllers handle the logic and data behind Visualforce pages
• Visualforce pages can call Apex methods to perform actions and retrieve data
• Apex controllers can be standard controllers or custom controllers
• Standard controllers provide basic functionality for displaying and manipulating data for a single Salesforce object
• Custom controllers provide more flexibility and control over page behavior
• Action methods in Apex controllers handle button clicks and other user interactions
• Data binding displays data from Apex controllers on Visualforce pages
• Visualforce components create reusable UI elements

Debugging Apex Code

• Debugging Apex code identifies and resolves issues
• System.debug() statements output values and track code execution
• The Salesforce Developer Console views debug logs and inspects variables
• Checkpoints in the Developer Console pause code execution and examine the state of the application
• try-catch blocks handle exceptions and log error messages
• The Limits class monitors governor limit usage during code execution
• Analyze debug logs to identify performance bottlenecks and optimize code
• Logging frameworks provide more advanced debugging and monitoring capabilities