Tag: Custom Controller

1. What is an Apex class in Salesforce?

An Apex class in Salesforce is a blueprint or template for creating custom business logic and functionality. It is written in the Apex programming language, which is similar to Java, and is used to define the behavior of objects in the Salesforce platform.

2. Explain the syntax of creating an Apex class.

The syntax for creating an Apex class is as follows:

public class ClassName { 
// Class variables, properties, and methods 
}

The keyword “public” denotes the access level of the class, and it can be either public or private. The class name follows the “class” keyword, and the body of the class is enclosed within curly braces.

3. What is the difference between a standard controller and a custom controller?

A standard controller is a pre-built controller provided by Salesforce for standard objects like Account, Contact, or Opportunity. It provides basic functionality and automatically handles most of the operations related to data retrieval, manipulation, and standard page actions.

On the other hand, a custom controller is a controller that you create to define custom logic and behavior for a Visualforce page or a Lightning component. It allows you to implement custom business processes and extend functionality beyond what is provided by the standard controller.

4. How can you define a method in an Apex class?

public returnType methodName(parameterList) { 
// Method body 
}

5. What is the purpose of the “public” and “private” access modifiers in Apex?

The “public” and “private” access modifiers in Apex control the visibility and accessibility of variables and methods within a class.

1. “public” means that the variable or method can be accessed from outside the class.
2. “private” means that the variable or method can only be accessed within the class itself.

By using these access modifiers, you can define the level of encapsulation and control the interaction with the class’s internal members.

Don’t forget to check out: Are You Here To Know Reasons To Hire Salesforce Developer For Your Business?

6. Explain the difference between “static” and “instance” methods in Apex.

In Apex, the “static” keyword is used to define a method or variable that belongs to the class itself rather than an instance of the class. It means that the method or variable can be accessed without creating an instance of the class.

On the other hand, an “instance” method is a method that operates on a specific instance of a class. It requires an object of the class to be created, and the method is invoked on that object.

“static” methods or variables are associated with the class itself, while “instance” methods or variables are associated with individual instances of the class.

7. How do you define a variable in Apex? What are the different data types available?

In Apex, you can define a variable using the following syntax:

dataType variableName [= initialValue];

The dataType specifies the type of data that the variable can hold, and the variableName is the name you give to the variable. The “= initialValue” part is optional and is used to assign an initial value to the variable.

Apex supports various data types, including primitives like Integer, Boolean, and String, as well as complex types like sObjects, lists, and maps.

8. How can you implement exception handling in Apex?

Ans. Exception handling in Apex allows you to catch and handle errors or exceptional situations that may occur during the execution of your code. You can implement exception handling using try-catch blocks.

try { 
// Code that may throw an exception 
} 
catch (ExceptionType e) { 
// Code to handle the exception 
}

Inside the try block, you place the code that may throw an exception. If an exception occurs, it is caught by the catch block, where you can handle the exception appropriately. The “ExceptionType” specifies the type of exception you want to catch.

You can use “finally” blocks to specify code that should be executed regardless of whether an exception is thrown or not.

9. Explain the difference between a trigger and an Apex class.

A trigger is an Apex code that is executed before or after specific data manipulation operations, such as insert, update, delete, or undelete, on Salesforce objects. Triggers are used to enforce data integrity, perform additional logic, or update related records based on certain conditions.

On the other hand, an Apex class is a general-purpose class that can be written to encapsulate business logic and reusable functionality. It can be invoked from various contexts like triggers, Visualforce pages, or Lightning components.

In summary, a trigger is specific to a particular object and is automatically executed based on data manipulation events, while an Apex class is a reusable piece of code that can be invoked from multiple contexts.

10. How can you write a test class for an Apex class? What is the purpose of test classes?

To write a test class for an Apex class, you create a separate class in Salesforce that contains test methods. Test classes are used to verify that your code works as expected and to achieve code coverage, which is a requirement for deploying Apex code to production.

The purpose of test classes is to simulate different scenarios and assert the expected outcomes. They help ensure that the code is functioning correctly and prevent regressions when making changes.

Test classes follow a naming convention and are annotated with the @isTest annotation. Inside the test class, you write methods with the @isTest annotation to define test methods.

11. What are the best practices for writing efficient Apex code?

Best practices for writing efficient Apex code include:

1. Bulkify your code: Design your code to process data in bulk to avoid hitting governor limits and improve performance.
2. Use selective queries: Query only the necessary data to minimize database operations and optimize performance.
3. Minimize SOQL and DML statements: Reduce the number of queries and updates to conserve resources.
4. Avoid nested loops: Nested loops can result in poor performance. Use collections and efficient algorithms to avoid nested loops whenever possible.
5. Cache frequently accessed data: Store frequently accessed data in memory for faster access and reduced database calls.
6. Handle exceptions gracefully: Implement proper exception handling to handle errors and prevent unhandled exceptions from impacting the user experience.
7. Follow naming conventions: Use clear and descriptive names for variables, classes, and methods to enhance code readability.
8. Use governor limit-aware coding: Be aware of the Salesforce governor limits and design your code to stay within those limits.
9. Write comprehensive unit tests: Ensure that your code is thoroughly tested to catch any issues early and maintain code quality.

12. How can you query records from the database using SOQL in Apex?

SOQL (Salesforce Object Query Language) is used to query records from the database in Salesforce. In Apex, you can use SOQL statements to retrieve records based on specified conditions.

The basic syntax for a SOQL query in Apex is as follows:

List<SObject> records = [SELECT field1, field2 FROM ObjectName WHERE condition];

1. “List<SObject>” defines the variable to store the query results.
2. “SELECT field1, field2” specifies the fields to retrieve from the object.
3. “FROM ObjectName” specifies the object to query.
4. “WHERE condition” filters the records based on specified conditions.

You can also use additional clauses like ORDER BY, LIMIT, and OFFSET to further refine your queries.

13. What is the purpose of DML statements in Apex? Give examples of different DML operations.

DML (Data Manipulation Language) statements in Apex are used to perform CRUD (Create, Read, Update, Delete) operations on records in the database.
Some examples of DML operations in Apex are:

Inserting a Record:

ObjectName record = new ObjectName(field1 = value1, field2 = value2); 
insert record;

Updating a Record:

ObjectName record = [SELECT field1, field2 FROM ObjectName WHERE Id = 'recordId']; 
record.field1 = newValue; 
update record;

Deleting a Record:

ObjectName record = [SELECT field1, field2 FROM ObjectName WHERE Id = 'recordId']; 
delete record;

DML statements are used to interact with the database and modify record data.

14. How do you enforce sharing rules in an Apex class?

Sharing rules in Salesforce determine the level of access users have to records. In an Apex class, you can enforce sharing rules by using the “with sharing” keyword.

By default, Apex classes run in system mode, which ignores the organization’s sharing rules. However, when you specify “with sharing” in the class definition, the class runs in user mode, respecting the sharing rules.

This means that the code inside the class will honor the record-level access permissions and sharing settings defined by the organization’s sharing rules, profiles, and sharing settings.

Enforcing sharing rules ensures that the Apex class operates within the defined access controls, providing the appropriate level of record visibility and security.

15. Explain the difference between a constructor and a method in Apex.

Ans. In Apex, a constructor is a special method used to initialize the object of a class. It is invoked when an object is created using the “new” keyword. Constructors have the same name as the class and do not specify a return type.

public class MyClass { 
    public MyClass() { 
         // Constructor logic 
    } 
}

On the other hand, a method is a block of code that performs a specific action. Methods are used to encapsulate reusable functionality within a class. They can accept input parameters, execute a series of statements, and optionally return a value.

The main difference between a constructor and a method is that a constructor is automatically invoked when an object is created, whereas a method is called explicitly by the code.

16. What is the “with sharing” keyword in Apex? How does it impact record visibility?

Ans. The “with sharing” keyword in Apex is used to enforce record-level access permissions and sharing rules in a class. When a class is declared with “with sharing,” it runs in user mode and respects the organization’s sharing rules.

The “with sharing” keyword affects the visibility of records based on the user’s access permissions, profile settings, and sharing rules. It ensures that the code in the class only works with the records that the user has proper access to, providing a secure and controlled environment.

By default, Apex classes run in system mode, which ignores sharing rules. However, when “with sharing” is specified, the class operates in user mode and respects the sharing settings.

17. How can you schedule Apex classes to run at specific times?

Ans. You can schedule Apex classes to run at specific times using the Schedulable interface in Apex. The Schedulable interface allows you to define a class as a scheduled job that can be executed according to a specified schedule.

To schedule an Apex class, you need to implement the Schedulable interface and define the schedule using the System.schedule method.

Here’s an example of scheduling an Apex class to run every day at a specific time:

public class MyScheduledClass implements Schedulable { 
     public void execute(SchedulableContext context) { 
     // Logic to be executed on schedule 
     } 
} 
// Schedule the Apex class to run every day at 8 AM String cronExp = '0 0 8 * * ?'; 
String jobName = 'MyScheduledJob'; System.schedule(jobName, cronExp, new MyScheduledClass());

This code schedules the MyScheduledClass to run every day at 8 AM based on the specified cron expression.

18. What is the purpose of the “Database” class in Apex?

Ans. The “Database” class in Apex provides methods to perform database operations like insert, update, upsert, delete, and query records. It also allows you to interact with records in bulk and handle governor limits.

Some common use cases for the “Database” class include:

1. Performing DML operations on records in bulk.
2. Querying records with dynamic SOQL queries.
3. Inserting or updating records while bypassing triggers.
4. Handling partial success and DML exceptions.
5. Retrieving the ID of the inserted or updated record.

The “Database” class provides additional capabilities beyond the standard DML statements and is useful for advanced database operations in Apex.

19. How can you implement asynchronous processing in Apex?

Ans. Asynchronous processing in Apex allows you to execute code in the background without blocking the user interface or other operations. It helps improve performance and provides a way to handle long-running or resource-intensive tasks.

To implement asynchronous processing, you can use features like future methods, batch Apex, and queueable Apex.

1. Future methods: They are annotated with the @future annotation and allow you to execute a method asynchronously. The method is queued for execution and runs in a separate thread.
2. Batch Apex: It allows you to process large sets of data in smaller chunks or batches. Batch Apex jobs are divided into multiple batches, and each batch is processed independently.
3. Queueable Apex: It allows you to chain and schedule the execution of jobs. Each job is added to a queue and executed in sequence, providing flexibility and control over the execution order.

These asynchronous processing methods help handle time-consuming tasks, integrate with external systems, and perform complex operations in a scalable manner.

20. Explain the concept of batch Apex and its use cases

Ans. Batch Apex is a feature in Salesforce that allows you to process large sets of data asynchronously in smaller chunks or batches. It is useful when dealing with large data volumes that exceed the normal governor limits.

Batch Apex jobs are divided into multiple batches, and each batch can process a subset of the data. The data is processed in a batch-by-batch manner, and the results can be collected and processed after each batch or at the end of the job.

Batch Apex jobs follow a specific pattern:

1. Start method: It collects the initial set of records to be processed and sets up the batch job.
2. Execute method: It processes each batch of records and performs the required operations.
3. Finish method: It handles any post-processing tasks after all batches have been executed.

Batch Apex is useful for data transformation, data migration, complex calculations, and other scenarios where large volumes of data need to be processed efficiently.

21. What are governor limits in Apex? How do they impact the execution of code?

Ans. Governor limits in Apex are runtime limits set by Salesforce to ensure the efficient and fair use of shared resources. They restrict the number of resources a transaction or code execution can consume, such as CPU time, heap size, database queries, and DML operations.

Governor limits impact the execution of code by enforcing certain boundaries to prevent abuse, optimize performance, and maintain system stability. If a transaction or code execution exceeds the limits, it results in a runtime exception.

Developers need to be mindful of governor limits when writing Apex code to avoid hitting limits and ensure the code performs optimally.

Examples of governor limits include:

1. CPU time limit: Specifies the maximum amount of CPU time a transaction can use.
2. Query rows limit: Restricts the number of records that can be returned in a single query.
3. Heap size limit: This limits the amount of memory a transaction can use.
4. DML statements limit Limits the number of records that can be inserted, updated, or deleted in a single transaction.

Understanding and optimizing code to stay within governor limits is crucial for maintaining a scalable and efficient Salesforce application.

22. How can you implement triggers in Apex? What are the different trigger events available?

Ans. Triggers in Apex are pieces of code that execute before or after specific data manipulation operations, such as insert, update, delete, or undelete, on Salesforce objects. They are used to enforce data integrity, perform additional logic, or update related records based on certain conditions.

To implement triggers, you define trigger handlers that contain the logic to be executed when a trigger event occurs. Trigger handlers can be written as separate classes or as methods within the trigger itself.

Trigger events include:

1. before insert: Triggered before records are inserted.
2. before update: Triggered before records are updated.
3. before delete: Triggered before records are deleted.
4. after insert: Triggered after records are inserted.
5. after update: Triggered after records are updated.
6. after delete: Triggered after records are deleted.
7. after undelete: Triggered after records are undeleted.

By using triggers, you can automate processes, maintain data integrity, and extend the functionality of Salesforce objects.

Check out another amazing blog by Aman here: Mule Dreamin: Shaping MuleSoft+Salesforce Together for a Powerful Integration

23. Explain the difference between a before trigger and an after trigger.

Ans. Before triggers and after triggers are types of triggers in Apex that determine when the trigger logic is executed in relation to the data manipulation operation.

1. Before triggers: They are executed before the data manipulation operation occurs. Before triggers are used to perform validation or modification on the records before they are saved to the database. They are commonly used to enforce business rules and validate data.
2. After triggers: They are executed after the data manipulation operation occurs. After triggers are used to perform additional logic or update related records based on the changes made by the trigger operation. They can be used to update fields, create related records, or invoke external services.

The choice between before and after triggers depends on the specific requirements of the business logic and the timing of the necessary operations.

24. How can you implement a trigger handler class in Apex? What are the benefits of using a trigger handler pattern?

Ans. A trigger handler class in Apex is a design pattern that separates the trigger logic from the trigger itself. It provides a structured way to handle trigger events and improves code maintainability and reusability.

The trigger handler pattern involves creating a separate class to hold the trigger logic. The trigger itself acts as a bridge between the Salesforce platform and the trigger handler class.

Benefits of using a trigger handler pattern include:

1. Separation of concerns: The trigger handler class focuses solely on the trigger logic, making it easier to understand and maintain.
2. Reusability: The same trigger handler class can be used for multiple triggers, reducing code duplication.
3. Testability: The trigger handler class can be unit tested independently of the trigger.
4. Scalability: The trigger handler pattern allows for easier extension and modification of trigger logic as business requirements change.

By adopting the trigger handler pattern, you can write cleaner and more modular trigger code, leading to better code organization and easier maintenance.

25. What is the purpose of the “Schema” class in Apex? How can you use it for dynamic SOQL and DML operations?

Ans. The “Schema” class in Apex provides metadata information about the Salesforce objects, such as fields, relationships, and object definitions. It allows you to dynamically retrieve information about objects and fields at runtime.

The “Schema” class provides methods to access and manipulate metadata, including:

• getGlobalDescribe(): Returns a map of all object describe information.
• getSObjectType(): Returns the SObjectType for a given object name.
• getDescribe(): Returns the describe information for a specific object or field.

You can use the “Schema” class for dynamic SOQL and DML operations, dynamic field retrieval, and generating dynamic user interfaces.

For example, you can dynamically query fields based on user input, dynamically create or modify fields, or generate UI components based on the metadata obtained from the “Schema” class.

26. How do you handle bulkification in Apex code? Why is it important?

Ans. Bulkification in Apex refers to designing code that can efficiently process large sets of data. It involves writing code in a way that operates on collections of records rather than individual records, reducing the number of database queries and DML statements.

Bulkification is important to avoid hitting governor limits and optimize code performance. By processing data in bulk, you can minimize the number of queries and updates, conserve resources, and improve overall execution speed.

To achieve bulkification, you can follow these best practices:

1. Query records in bulk: Use SOQL queries with proper filters and retrieve all necessary records in a single query instead of querying inside a loop.
2. Perform DML operations in bulk: Use collections like lists and sets to hold records and perform DML operations on them outside of loops.
3. Use collections for processing: Iterate over collections of records to perform calculations or operations, rather than processing one record at a time.
4. Minimize SOQL and DML statements: Reduce the number of queries and updates by batching them together.

By adopting these practices, you can ensure your code can handle large volumes of data efficiently and avoid performance issues.

27. Explain the concept of a trigger context variable in Apex.

Ans. In Apex, a trigger context variable is an object that provides contextual information about the trigger event being executed. It contains information such as the records involved, the operation type, and the trigger execution context.

The trigger context variable is automatically available within a trigger and can be accessed using the Trigger keyword. It provides access to various trigger context variables, such as:

1. Trigger.new: Returns a list of new records being inserted or updated.
2. Trigger.old: Returns a list of old records before they were updated or deleted.
3. Trigger.newMap: Returns a map of new records, with the record IDs as keys.
4. Trigger.oldMap: Returns a map of old records, with the record IDs as keys.
5. Trigger.isInsert: Indicates if the trigger event is an insert operation.
6. Trigger.isUpdate: Indicates if the trigger event is an update operation.
7. Trigger.isDelete: Indicates if the trigger event is a delete operation.

By using the trigger context variables, you can access and manipulate the records involved in the trigger event and perform specific logic based on the operation type.

28. How can you perform unit testing for triggers in Apex?

Ans. Unit testing for triggers in Apex involves writing test classes to ensure the trigger logic behaves as expected and meets the desired requirements. Unit tests help validate the trigger functionality, test different scenarios, and identify potential issues or bugs.

To perform unit testing for triggers, you typically follow these steps:

1. Create test data: Generate the necessary records and data to replicate the trigger scenario and cover different test cases.
2. Execute the trigger event: Perform the specific DML operation that triggers the logic, such as insert, update, or delete.
3. Assert the expected outcome: Check if the trigger behavior matches the expected results and validate the changes made by the trigger.
4. Handle bulk testing: Ensure the trigger handles bulk data correctly by testing with multiple records in a single transaction.
5. Handle governor limits: Verify that the trigger stays within the governor limits and handles large data volumes efficiently.

By writing comprehensive unit tests, you can ensure the reliability and correctness of your trigger logic and avoid regressions when making changes to the code.

29. What is a SOQL injection? How can you prevent it in Apex?

Ans. SOQL injection is a security vulnerability that occurs when an application allows user-supplied input to directly manipulate a SOQL query. It can lead to unauthorized access, data breaches, or data corruption.

To prevent SOQL injection in Apex, it is essential to use parameterized queries and sanitize user input. The recommended approach is to use bind variables in your SOQL queries, where the user input is passed as a parameter rather than concatenated directly into the query.

Here’s an example of a vulnerable query without proper prevention:

String input = 'example';
String query = 'SELECT Id FROM Account WHERE Name = \'' + input + '\'';
List<Account> accounts = Database.query(query);
To prevent SOQL injection, you should use bind variables:
String input = 'example';
List<Account> accounts = [SELECT Id FROM Account WHERE Name = :input];

By using bind variables, the input is automatically sanitized and treated as a parameter, reducing the risk of injection attacks.

30. How can you implement a batchable interface in Apex? When would you use batch Apex?

Ans. The Batchable interface in Apex allows you to process large sets of data by dividing the workload into smaller batches. It provides a way to handle complex or time-consuming operations that exceed the normal governor limits.

To implement the Batchable interface, you need to define three methods:

1. start: Collects the initial set of records to be processed and sets up the batch job.
2. execute: Processes a batch of records and performs the required operations.
3. finish: Handles any post-processing tasks after all batches have been executed.

Batchable jobs can be queued and run asynchronously, allowing for the efficient processing of large data volumes without hitting governor limits.

Batch Apex is typically used for scenarios such as data transformation, data migration, data cleansing, and complex calculations where large volumes of data need to be processed in a controlled and efficient manner.

31. What is the purpose of a queueable interface in Apex? How does it differ from batch Apex?

Ans. The Queueable interface in Apex provides a way to execute code asynchronously in the background. It allows you to chain and schedule the execution of jobs, providing flexibility and control over the order of execution.

Unlike batch Apex, queueable jobs don’t have specific batch size limitations and can be used for smaller-scale processing. They are useful for scenarios where you need to perform lightweight asynchronous processing, integrate with external systems, or handle time-consuming tasks without blocking the user interface.

To implement the Queueable interface, you define a class that implements the interface and implement the execute method. The execute method contains the logic to be executed asynchronously.

Queueable Apex jobs can be enqueued and scheduled to run at a specific time or after the completion of other jobs, allowing for efficient job management and resource utilization.

32. How can you handle exceptions and errors in Apex? What are the best practices?

Ans. Exception handling in Apex allows you to handle and recover from runtime errors, ensuring the stability and reliability of your code. When an exception occurs, the normal flow of execution is disrupted, and control is transferred to the exception handling code.

In Apex, you can handle exceptions using try-catch blocks. The try block contains the code that may throw an exception, and the catch block handles the exception and defines the desired behavior.

Here’s an example of exception handling in Apex:

try { 
     // Code that may throw an exception Integer result = 10 / 0; 
     // Division by zero 
    } 
catch (Exception e) { 
    // Exception handling code System.debug('An exception occurred: ' + e.getMessage()); 
}

In the example, if an exception occurs during the division operation, the control is transferred to the catch block, and the exception message is logged.

Best practices for exception handling in Apex include:

1. Catch specific exceptions: Handle specific exceptions rather than using a general catch-all block to handle different types of exceptions differently.
2. Provide meaningful error messages: Log or display informative error messages to help with troubleshooting and debugging.
3. Graceful error handling: Handle exceptions gracefully and provide fallback or alternative paths of execution when errors occur.
4. Use system exceptions when appropriate: Utilize standard system exceptions for common error conditions, such as DmlException or QueryException.

By implementing effective exception handling, you can improve the robustness and reliability of your Apex code.

33. Explain the concept of a “helper” class in Apex. Why would you use it?

Ans. In Apex, a “helper” class refers to a class that provides reusable methods or functionality to assist other classes or components. Helper classes are used to modularize code, improve code organization, and promote reusability.

Here are some reasons why you would use a helper class:

1. Code organization: Helper classes separate specific functionality from the main class, making the codebase more manageable and maintainable.
2. Reusability: Helper methods can be shared and used by multiple classes or components, avoiding code duplication.
3. Encapsulation: By encapsulating related functionality in a helper class, you can provide a clean and concise API to other classes, abstracting the underlying implementation details.
4. Testability: Helper methods can be unit tested independently, simplifying the testing process and ensuring the correctness of the functionality.
5. Modularity: Helper classes can be easily updated or replaced without affecting the main class, promoting code extensibility and flexibility.

Overall, using helper classes helps improve code structure, maintainability, and code reuse in Apex development.

34. How can you make a callout to an external system from Apex code?

Ans. To make a callout to an external system from Apex code, you can use Apex HTTP classes. Salesforce provides a robust set of classes for making HTTP requests and handling responses.

Here’s an example of making a callout using Apex HTTP classes:

HttpRequest request = new HttpRequest(); 
request.setEndpoint('https://api.example.com/endpoint'); 
request.setMethod('GET'); 
HttpResponse response = new HttpResponse(); 
Http http = new Http(); try { response = http.send(request); 
if (response.getStatusCode() == 200) { 
     // Handle successful response String responseBody = response.getBody(); 
     // Process the response 
     } 
     else { 
     // Handle error response String errorMessage = 'Callout error: ' + response.getStatusCode() + ' - ' + response.getStatus(); // Handle the error 
     } 
} 
catch (Exception e) { 
// Handle exception System.debug('Exception: ' + e.getMessage()); 
}

In the example, an HTTP GET request is made to an external API endpoint. The response is then handled based on the status code and processed accordingly.

Apex HTTP classes allow you to make various types of HTTP requests, set request headers, handle request and response bodies, and handle errors or exceptions that may occur during the callout.

35. What is the purpose of a future method in Apex? When would you use it?

Ans. The “future” method in Apex is used to perform long-running or time-consuming operations asynchronously. It allows you to execute a method in the background without blocking the user interface.

A future method is defined using the @future annotation and must return void. It can be called trigger handlers, Visualforce pages, or other Apex code.

Here’s an example of a future method:

public class MyFutureClass { 
     @future public static void performLongOperation() 
     { 
          // Perform long operation asynchronously // ... 
     } 
}

In the example, the performLongOperation the method is marked with the @future annotation, indicating that it should be executed asynchronously.

Future methods are commonly used for tasks such as sending emails, making external callouts, performing calculations, or executing any other operations that may take a significant amount of time.

By using future methods, you can offload time-consuming operations to run asynchronously and ensure a smooth user experience.