JavaScript Controller Setup

Oct 13, 2025 by leolavanderia.com.br 106 views

Introduction

In Salesforce Lightning Experience, integrating Apex controllers with JavaScript controllers is a crucial aspect of building custom applications. This article will guide you through the process of retrieving information from an Apex controller using a JavaScript controller and displaying it in your Lightning component.

Prerequisites

Before we dive into the implementation, ensure you have the following:

A Salesforce Lightning Experience account
A custom Apex controller with a method annotated with @AuraEnabled
A JavaScript controller in your Lightning component

Apex Controller Setup

In your Apex controller, you have a method named getParam. This method should be annotated with @AuraEnabled to make it accessible from the JavaScript controller.

public class compController {
  @AuraEnabled
  public static List<ObjectParent> getParam() {
    // Your logic to retrieve data from the database or perform any other operation
    List<ObjectParent> result = new List<ObjectParent>();
    // Add data to the result list
    return result;
  }
}

JavaScript Controller Setup

In your JavaScript controller, you'll use the cmp object to call the Apex method and retrieve the data. Create a new JavaScript controller in your Lightning component and add the following code:

import { LightningElement, wire, api } from 'lwc';
import getParam from '@salesforce/apex/compController.getParam';
export default class MyComponent extends LightningElement {
@wire(getParam)
wiredParam({ error, data }) {
if (data) {
// Process the data
console.log(data);
} else if (error) {
// Handle the error
console.error(error);
}
}
}

In this code:

We import the getParam method from the Apex controller using the @salesforce/apex namespace.
We use the @wire decorator to wire the Apex method to the component's property.
We define a handler function wiredParam to process the data or handle any errors.

Displaying the Data

To display the retrieved data in your Lightning component, you can use a combination of HTML and JavaScript. Create a new HTML template in your component and add the following code:

<template>
  <div>
    <h1>Retrieved Data</h1>
    <ul>
      {#each wiredParam as item}
        <li>{item.name} - {item.value}</li>
      {/each}
    </ul>
  </div>
</template>

In this code:

We use the #each directive to iterate over the wiredParam property and display each item in a list.
We access the name and value properties of each item using the item variable.

Putting it all Together

Here's the complete code for your Lightning component:

import { LightningElement, wire, api } from 'lwc';
import getParam from '@salesforce/apex/compController.getParam';
export default class MyComponent extends LightningElement {
@wire(getParam)
wiredParam({ error, data }) {
if (data) {
// Process the data
console.log(data);
} else if (error) {
// Handle the error
console.error(error);
}
}
}

<template>
  <div>
    <h1>Retrieved Data</h1>
    <ul>
      {#each wiredParam as item}
        <li>{item.name} - {item.value}</li>
      {/each}
    </ul>
  </div>
</template>

Conclusion

In this article, we've covered the process of retrieving information from an Apex controller using a JavaScript controller and displaying it in your Lightning component. By following these steps, you can integrate your Apex controllers with JavaScript controllers and build custom applications in Salesforce Lightning Experience.

Troubleshooting Tips

Ensure that your Apex method is annotated with @AuraEnabled to make it accessible from the JavaScript controller.
Verify that your JavaScript controller is correctly wired to the Apex method using the @wire decorator.
Check the console for any errors or warnings related to the Apex method or JavaScript controller.

Best Practices

Use the @AuraEnabled annotation to make Apex methods accessible from JavaScript controllers.
Use the @wire decorator to wire Apex methods to component properties.
Handle errors and exceptions in your JavaScript controller to ensure robustness and reliability.

Introduction

In our previous article, we covered the process of retrieving information from an Apex controller using a JavaScript controller and displaying it in your Lightning component. In this article, we'll answer some frequently asked questions (FAQs) related to integrating Apex with JavaScript controllers in Salesforce Lightning Experience.

Q: What is the purpose of the `@AuraEnabled` annotation in Apex?

A: The @AuraEnabled annotation in Apex is used to make a method accessible from a JavaScript controller. This annotation allows you to expose your Apex methods to the Lightning Component Framework, enabling you to call them from your JavaScript controllers.

Q: How do I wire an Apex method to a JavaScript controller using the `@wire` decorator?

A: To wire an Apex method to a JavaScript controller using the @wire decorator, you need to import the Apex method using the @salesforce/apex namespace and then use the @wire decorator to wire the method to a component property. Here's an example:

import { LightningElement, wire, api } from 'lwc';
import getParam from '@salesforce/apex/compController.getParam';
export default class MyComponent extends LightningElement {
@wire(getParam)
wiredParam({ error, data }) {
if (data) {
// Process the data
console.log(data);
} else if (error) {
// Handle the error
console.error(error);
}
}
}

Q: What is the difference between `@wire` and `@api` in JavaScript controllers?

A: @wire and @api are both used to call Apex methods from JavaScript controllers, but they serve different purposes. @wire is used to wire an Apex method to a component property, while @api is used to call an Apex method and return the result directly. Here's an example:

import { LightningElement, wire, api } from 'lwc';
import getParam from '@salesforce/apex/compController.getParam';
export default class MyComponent extends LightningElement {
@wire(getParam)
wiredParam({ error, data }) {
if (data) {
// Process the data
console.log(data);
} else if (error) {
// Handle the error
console.error(error);
}
}
@api
callParam() {
return getParam();
}
}

Q: How do I handle errors and exceptions in my JavaScript controller?

A: To handle errors and exceptions in your JavaScript controller, you can use the try-catch block to catch any exceptions that may occur when calling the Apex method. Here's an example:

import { LightningElement, wire, api } from 'lwc';
import getParam from '@salesforce/apex/compController.getParam;
export default class MyComponent extends LightningElement {
@wire(getParam)
wiredParam({ error, data }) {
try {
if (data) {
// Process the data
console.log(data);
} else {
// Handle the case where data is null or undefined
console.log('No data available');
}
} catch (e) {
// Handle the error
console.error(e);
}
}
}

Q: Can I use `@wire` with multiple Apex methods?

A: Yes, you can use @wire with multiple Apex methods. To do this, you need to create a separate property for each Apex method and then use the @wire decorator to wire each method to its corresponding property. Here's an example:

import { LightningElement, wire, api } from 'lwc';
import getParam from '@salesforce/apex/compController.getParam;
import getOtherParam from '@salesforce/apex/compController.getOtherParam;
export default class MyComponent extends LightningElement {
@wire(getParam)
wiredParam({ error, data }) {
if (data) {
// Process the data
console.log(data);
} else if (error) {
// Handle the error
console.error(error);
}
}
@wire(getOtherParam)
wiredOtherParam({ error, data }) {
if (data) {
// Process the data
console.log(data);
} else if (error) {
// Handle the error
console.error(error);
}
}
}

Conclusion

In this article, we've answered some frequently asked questions related to integrating Apex with JavaScript controllers in Salesforce Lightning Experience. By following these best practices and troubleshooting tips, you can build robust and reliable custom applications in Salesforce Lightning Experience.

Additional Resources

Salesforce Documentation: Integrating Apex with JavaScript Controllers
Salesforce Documentation: Using the @wire Decorator
Salesforce Documentation: Using the @api Decorator