1) What is the difference between @HttpPatch and @HttpPut annotations in Salesforce?
@HttpPatch is used to partially update a resource, meaning it modifies only specific fields of the resource without replacing it entirely.
@HttpPut is used to fully replace or update the entire resource with the provided data, meaning it requires the full object to be replaced.
2) What is the purpose of the @RestResource annotation in Salesforce?
The @RestResource annotation is used at the class level to expose an Apex class as a REST resource. It is required for creating custom RESTful services in Salesforce, allowing external applications to interact with Salesforce data via HTTP requests. The urlMapping parameter defines the URL pattern for the resource.
3) What are different Apex REST annotations in Salesforce?
1. @RestResource
This annotation is used at the class level to expose an Apex class as a REST resource. The class must be defined as global, and the urlMapping parameter specifies the URL pattern to access the resource.
2. @HttpDelete
This annotation is used to delete a specified resource via a DELETE request. It marks the method as handling HTTP DELETE operations.
3. @HttpGet
This annotation is used to retrieve a specified resource via a GET request. The method marked with @HttpGet is responsible for fetching data from Salesforce.
4. @HttpPatch
This annotation is used to partially update a resource. It modifies only specific parts of the resource, as specified by the incoming request.
5. @HttpPost
This annotation is used to create a new resource in Salesforce via a POST request. It is commonly used to create new records.
6. @HttpPut
This annotation is used to either create or fully update a resource. It replaces the entire resource with the data received in the request.
4) What is the RestRequest class in Salesforce, and what are some of its key methods?
The RestRequest class in Salesforce is used to access incoming requests in Apex REST web services. It provides several methods to handle different aspects of an HTTP request. Some key methods include:
headers: Returns the headers received by the request (Map<String, String>).
httpMethod: Returns the HTTP method used for the request (String), such as GET, POST, DELETE, etc.
params: Returns the parameters received by the request (Map<String, String>).
remoteAddress: Returns the IP address of the client making the request (String).
requestBody: Returns or sets the body of the request (Blob).
requestURI: Returns or sets everything after the host in the HTTP request string (String).
resourcePath: Returns the REST resource path for the request (String).
5) What is the RestResponse class in Salesforce, and what are some of its key methods?
The RestResponse class in Salesforce is used to pass data from an Apex RESTful web service method to the HTTP response. It has several key methods:
responseBody: Returns or sets the body of the response (Blob).
headers: Returns the headers to be sent in the response (Map<String, String>).
statusCode: Returns or sets the HTTP status code for the response (Integer). Common status codes include 200 (OK), 201 (Created), 400 (Bad Request), etc.
For example, if you want to change the default status code of a RESTful service response, you can modify the statusCode property of the RestResponse class, like setting it to 201 (Created) instead of 200 (OK).
6) What is the purpose of the @HttpGet annotation in Salesforce, and how is it used in Apex?
The @HttpGet annotation in Salesforce is used to expose an Apex method as a RESTful GET service. This annotation allows external systems to retrieve data from Salesforce by making an HTTP GET request to the defined URL. The method must be defined as global static within a class annotated with @RestResource. For example, a method annotated with @HttpGet can fetch records like an Account based on an ID provided in the request URL.
7) Can you provide an example of how the @HttpGet annotation works in a Salesforce Apex class?
Here's an example of how the @HttpGet annotation works in an Apex class:
@RestResource(urlMapping='/getAccountOnExternalIdtofetchsinglerecord/*')
global with sharing class getAccounttoSingleRecord {
@HttpGet
global static Account fetchAccount() {
RestRequest req = RestContext.request;
string accId = req.requestURI.substring(req.requestURI.lastIndexOf('/')+1);
Account obj = [SELECT Id, Name FROM Account WHERE Id = :accId];
return obj;
}
}
In this example, the @HttpGet annotation allows the fetchAccount() method to be called when an HTTP GET request is made to the URL /services/apexrest/getAccountOnExternalIdtofetchsinglerecord/{accountId}. The method fetches the Account record based on the ID from the URL and returns the record in JSON format.
8) Can you explain how Salesforce handles multiple HTTP methods in a single Apex class, and what restriction exists regarding their usage?
In Salesforce, a single Apex class can expose multiple HTTP methods (GET, DELETE, POST, PUT, PATCH) through different annotated methods. However, each method can only be annotated with one of these HTTP methods—only one method per HTTP method type is allowed in a class. For example, you can have one method annotated with @HttpGet, another with @HttpPost, and so on, but you cannot have multiple methods using the same annotation (e.g., two @HttpGet methods in the same class). This ensures each HTTP action is uniquely handled by its corresponding method.
9) How can you use the @HttpGet annotation with parameters in the URL in Salesforce?
In Salesforce, the @HttpGet annotation can be used to define a web service that handles GET requests. If parameters are passed in the URL, you can use the params variable of the RestRequest class. The params variable returns a Map<String, String> that contains the parameters received by the request.
For example, if you want to create a web service that fetches a Contact record based on email and phone as parameters, you would use the following code:
@RestResource(urlMapping='/getContactFromEmailAndPhone/*')
global with sharing class getContactRecord {
@Httpget
global static Contact fetchContact() {
Contact obj = new Contact();
RestRequest req = RestContext.request;
RestResponse res = RestContext.response;
Map<String, String> requestParam = req.params;
String conEmail = requestParam.get('email');
String conPhone = requestParam.get('phone');
obj = [SELECT id, lastname, email, phone FROM Contact WHERE email = :conEmail AND phone = :conPhone];
res.statusCode = 201; // Modify HTTP status code to be returned to the external system
return obj;
}
}
This web service can be accessed using a URL like /services/apexrest/getContactFromEmailAndPhone?email=testemail2@gmail.com&phone=123. The parameters email and phone are retrieved from the URL and used to query the Contact record.
10) What are named credentials in Salesforce and how do they improve security when integrating with external services?
Named credentials in Salesforce provide a secure and declarative way to store and manage the authentication details (like usernames, passwords, or OAuth tokens) required for HTTP callouts to external systems. They allow developers to specify the endpoint URL and authentication parameters in one definition, simplifying the setup of authenticated callouts. Named credentials eliminate the need for remote site settings and ensure credentials are stored encrypted, enhancing security. They also make maintaining integrations easier—if an endpoint URL changes, only the named credential needs to be updated, and all related callouts remain functional without modifying the Apex code.
