บทช่วยสอน APEX: คลาสการเขียนโปรแกรม Apex และตัวอย่างการเข้ารหัส

Apex ช่วยให้นักพัฒนาเพิ่มตรรกะทางธุรกิจให้กับเหตุการณ์ของระบบ เช่น การคลิกปุ่ม การอัปเดตบันทึกที่เกี่ยวข้อง และหน้า Visualforce Apex มีไวยากรณ์คล้ายกัน Java. ลงทะเบียนสำหรับ Salesforce เพื่อเรียนรู้วิธีการทำงานของ CRM

คุณสมบัติของภาษาโปรแกรมเอเพ็กซ์

นี่คือคุณสมบัติที่สำคัญของ Salesforce Apex:

• Apex เป็นภาษาที่ไม่คำนึงถึงขนาดตัวพิมพ์
• คุณสามารถดำเนินการ DML เช่น INSERT, UPDATE, UPSERT, DELETE บนเรกคอร์ด sObject โดยใช้ Apex
• คุณสามารถสืบค้นบันทึก sObject ได้โดยใช้ SOQL (ภาษาการสืบค้นวัตถุ Salesforce) และ SOSL (ภาษาการค้นหาวัตถุ Salesforce) ในเอเพ็กซ์
• ช่วยให้คุณสร้าง การทดสอบหน่วย และดำเนินการเพื่อตรวจสอบ ความครอบคลุมของรหัส และประสิทธิภาพของโค้ดในระดับเอเพ็กซ์
• Apex ดำเนินการในสภาพแวดล้อมที่มีผู้เช่าหลายรายและ Salesforce ได้กำหนดขีดจำกัดของผู้ว่าการบางอย่างที่ป้องกันไม่ให้ผู้ใช้ควบคุมทรัพยากรที่ใช้ร่วมกัน รหัสใดๆ ที่เกินขีดจำกัดของผู้ว่าการ Salesforce ล้มเหลว ข้อผิดพลาดจะปรากฏขึ้น
• วัตถุ Salesforce สามารถใช้เป็นประเภทข้อมูลในเอเพ็กซ์ได้ ตัวอย่างเช่น -

  Account acc = new Account();

  ในที่นี้บัญชีคือออบเจ็กต์พนักงานขายมาตรฐาน

• Apex จะอัปเกรดโดยอัตโนมัติทุกครั้งที่มีการเปิดตัว Salesforce

เมื่อใดที่นักพัฒนาควรเลือก Apex

ควรเขียนโค้ด Apex เฉพาะในกรณีที่สถานการณ์ทางธุรกิจมีความซับซ้อนเกินไป และไม่สามารถนำไปใช้งานโดยใช้ฟังก์ชันที่สร้างไว้ล่วงหน้าซึ่งจัดทำโดย Salesforce ได้

ต่อไปนี้เป็นสถานการณ์บางสถานการณ์ที่เราจำเป็นต้องเขียนโค้ด Apex:

• เพื่อสร้างบริการเว็บที่รวม Salesforce เข้ากับแอปพลิเคชันอื่น ๆ
• เพื่อใช้การตรวจสอบแบบกำหนดเองบน sobjects
• เพื่อดำเนินการตรรกะ Apex แบบกำหนดเองเมื่อมีการดำเนินการ DML
• เพื่อใช้ฟังก์ชันการทำงานที่ไม่สามารถใช้งานได้โดยใช้โฟลว์เวิร์กโฟลว์ที่มีอยู่และฟังก์ชันการทำงานของตัวสร้างกระบวนการ
• เพื่อติดตั้ง บริการอีเมลคุณต้องรวมการประมวลผลเนื้อหา ส่วนหัว และไฟล์แนบของอีเมลโดยใช้โค้ด Apex

โครงสร้างการทำงานของเอเพ็กซ์

ในบทช่วยสอน Apex นี้ เราจะเรียนรู้เกี่ยวกับโครงสร้างการทำงานของ Apex:

ต่อไปนี้เป็นลำดับการดำเนินการสำหรับโค้ดเอเพ็กซ์:

• การดำเนินการของนักพัฒนา: โค้ด apex ทั้งหมดที่เขียนโดยนักพัฒนาจะถูกคอมไพล์เป็นชุดคำสั่งที่ตัวแปลรันไทม์ของ apex สามารถเข้าใจได้ เมื่อนักพัฒนาบันทึกโค้ดลงในแพลตฟอร์ม จากนั้นคำแนะนำเหล่านี้จะบันทึกเป็นข้อมูลเมตาลงในแพลตฟอร์ม
• การกระทำของผู้ใช้: เมื่อเหตุการณ์ผู้ใช้รันโค้ด apex เซิร์ฟเวอร์แพลตฟอร์มจะได้รับคำสั่งที่คอมไพล์แล้วจากข้อมูลเมตา และรันคำสั่งเหล่านั้นผ่านล่าม apex ก่อนที่จะส่งคืนผลลัพธ์

ไวยากรณ์เอเพ็กซ์

การประกาศตัวแปร

เนื่องจาก Apex เป็นภาษาที่มีการกำหนดประเภทอย่างเข้มงวด จึงจำเป็นต้องประกาศตัวแปรที่มีประเภทข้อมูลใน Apex

ตัวอย่างเช่น:

contact con = new contact(); 

ที่นี่ตัวแปร con ถูกประกาศพร้อมกับ contact เป็นประเภทข้อมูล

แบบสอบถาม SOQL

SOQL ย่อมาจากภาษาคิวรีออบเจ็กต์ Salesforce SOQL ใช้เพื่อดึงบันทึก sObject จากฐานข้อมูล Salesforce ตัวอย่างเช่น-

Account acc = [select id, name from Account Limit 1]; 

ข้อความค้นหาข้างต้นดึงบันทึกบัญชีจากฐานข้อมูล Salesforce

คำสั่งวนรอบ

คำสั่ง Loop ใช้เพื่อวนซ้ำระเบียนในรายการ จำนวนการวนซ้ำเท่ากับจำนวนเรคคอร์ดในรายการ ตัวอย่างเช่น:

list<Account>listOfAccounts = [select id, name from account limit 100];
// iteration over the list of accounts
for(Account acc : listOfAccounts){
	//your logic
}

ในตัวอย่างโค้ดข้างต้น listOfAccounts เป็นตัวแปรของประเภทข้อมูลรายการ

คำชี้แจงการควบคุมการไหล

คำสั่งควบคุมการไหลมีประโยชน์เมื่อคุณต้องการรันโค้ดบางบรรทัดตามเงื่อนไขบางประการ

ตัวอย่างเช่น:

list<Account>listOfAccounts = [select id, name from account limit 100];
// execute the logic if the size of the account list is greater than zero
if(listOfAccounts.size() >0){
	//your logic
}

ข้อมูลโค้ดข้างต้นกำลังค้นหาบันทึกบัญชีจากฐานข้อมูลและตรวจสอบขนาดรายการ

คำสั่ง DML

DML ย่อมาจากภาษาการจัดการข้อมูล คำสั่ง DML ใช้เพื่อจัดการข้อมูลในฐานข้อมูล Salesforce ตัวอย่างเช่น -

Account acc = new Account(Name = ‘ Test Account’);
Insert acc; //DML statement to create account record.

สภาพแวดล้อมการพัฒนาเอเพ็กซ์

ในบทช่วยสอนการเขียนโปรแกรม Apex นี้ เราจะเรียนรู้เกี่ยวกับสภาพแวดล้อมการพัฒนา Apex:

สามารถพัฒนาโค้ด Apex ได้ทั้งในแซนด์บ็อกซ์และรุ่นนักพัฒนาของ Salesforce

แนวทางปฏิบัติที่ดีที่สุดคือการพัฒนาโค้ดในสภาพแวดล้อมแซนด์บ็อกซ์ จากนั้นจึงปรับใช้ไปยังสภาพแวดล้อมการผลิต

เครื่องมือพัฒนาโค้ด Apex: ต่อไปนี้เป็นเครื่องมือสามตัวที่มีให้ใช้งานเพื่อพัฒนาโค้ด Apex ใน Salesforce ทุกรุ่น

• คอนโซลนักพัฒนาซอฟต์แวร์ Force.com
• Force.com IDE
• ตัวแก้ไขโค้ดในส่วนติดต่อผู้ใช้ของ Salesforceคุณ

ชนิดข้อมูลใน Apex

ต่อไปนี้เป็นประเภทข้อมูลที่รองรับโดย Apex:

ดั้งเดิม

จำนวนเต็ม Double, Long, Date, Date Time, String, ID และ Boolean ถือเป็นประเภทข้อมูลดั้งเดิม ประเภทข้อมูลดั้งเดิมทั้งหมดจะถูกส่งผ่านตามค่า ไม่ใช่โดยการอ้างอิง

คอลเลคชั่น

Apex มีคอลเลกชันสามประเภทให้เลือก

• รายการ: เป็นคอลเลกชันดั้งเดิม sObjects คอลเลกชัน หรือวัตถุ Apex ที่เรียงลำดับตามดัชนี
• ชุด: คอลเลกชันดั้งเดิมที่ไม่ซ้ำใครที่ไม่เรียงลำดับ
• แผนที่: เป็นคอลเลกชันของคีย์ดั้งเดิมที่ไม่ซ้ำใครซึ่งแมปกับค่าเดียวซึ่งอาจเป็นวัตถุดั้งเดิม sObjects คอลเลกชันหรือวัตถุ Apex

วัตถุ

นี่เป็นประเภทข้อมูลพิเศษใน Salesforce มันคล้ายกับตารางใน SQL และมีเขตข้อมูลที่คล้ายกับคอลัมน์ใน SQL

เอนัมส์

Enum เป็นประเภทข้อมูลเชิงนามธรรมที่เก็บค่าหนึ่งค่าของชุดอันจำกัดของตัวระบุที่ระบุ

เรียน

วัตถุ

มันหมายถึงประเภทข้อมูลใด ๆ ที่รองรับใน Apex

อินเตอร์เฟซ

ตัวระบุการเข้าถึงเอเพ็กซ์

ต่อไปนี้เป็นตัวระบุการเข้าถึงที่รองรับโดย Apex:

สาธารณะ

ตัวระบุการเข้าถึงนี้ให้การเข้าถึงคลาส วิธีการ ตัวแปรที่จะใช้โดยเอเพ็กซ์ภายในเนมสเปซ

ส่วนตัว

ตัวระบุการเข้าถึงนี้ให้สิทธิ์การเข้าถึงคลาส วิธีการ ตัวแปรที่จะใช้ภายในเครื่องหรือภายในส่วนของโค้ดตามที่ถูกกำหนดไว้ เทคนิคทั้งหมด ตัวแปรที่ไม่มีตัวระบุการเข้าถึงที่กำหนดไว้มีตัวระบุการเข้าถึงเริ่มต้นเป็นส่วนตัว

มีการป้องกัน

ตัวระบุการเข้าถึงนี้ให้สิทธิ์ในการเข้าถึงเมธอด ซึ่งเป็นตัวแปรที่จะใช้โดยคลาสภายในใดๆ ภายในการกำหนดคลาส Apex

เหตุการณ์ที่

ตัวระบุการเข้าถึงนี้ให้การเข้าถึงคลาส วิธีการ ตัวแปรที่จะใช้โดยเอเพ็กซ์ภายในเนมสเปซและภายนอกเนมสเปซ แนวทางปฏิบัติที่ดีที่สุดคืออย่าใช้คำหลักสากลจนกว่าจำเป็น

คีย์เวิร์ดใน Apex

ด้วยการแชร์

หากคลาสถูกกำหนดด้วยคีย์เวิร์ดนี้ กฎการแบ่งปันทั้งหมดจะมีผลกับผู้ใช้ปัจจุบัน และหากไม่มีคีย์เวิร์ดนี้ โค้ดจะดำเนินการภายใต้บริบทของระบบ

ตัวอย่างเช่น:

public with sharing class MyApexClass{
// sharing rules enforced when code in this class execute
}

โดยไม่ต้องแบ่งปัน

หากคลาสถูกกำหนดด้วยคีย์เวิร์ดนี้ กฎการแบ่งใช้ทั้งหมดที่ใช้กับผู้ใช้ปัจจุบันจะไม่ถูกบังคับใช้

ตัวอย่างเช่น:

public without sharing class MyApexClass{
// sharing rules is not enforced when code in this class execute
}

คงที่

ตัวแปร วิธีการถูกกำหนดด้วยคำหลักคงที่จะเริ่มต้นครั้งเดียวและเชื่อมโยงกับชั้นเรียน ตัวแปรคงที่ วิธีการสามารถเรียกตามชื่อคลาสได้โดยตรงโดยไม่ต้องสร้างอินสแตนซ์ของคลาส

สุดท้าย

ค่าคงที่ วิธีการถูกกำหนดด้วยคำหลักสุดท้ายที่ไม่สามารถแทนที่ได้ ตัวอย่างเช่น:

public class myCls {
static final Integer INT_CONST = 10;
}

หากคุณพยายามแทนที่ค่าสำหรับตัวแปร INT_CONST นี้ คุณจะได้รับข้อยกเว้น – System.FinalException: ตัวแปรสุดท้ายได้รับการเตรียมใช้งานแล้ว

บริการรถส่ง

คำหลักนี้ส่งคืนค่าจากวิธีการ ตัวอย่างเช่น:

public String getName() {
return  'Test' ;
}

โมฆะ

มันกำหนดค่าคงที่เป็นโมฆะและสามารถกำหนดให้กับตัวแปรได้ ตัวอย่างเช่น

 Boolean b = null;

เสมือน

หากคลาสถูกกำหนดด้วยคีย์เวิร์ดเสมือน คลาสนั้นสามารถขยายและแทนที่ได้

นามธรรม

หากคลาสถูกกำหนดด้วยคีย์เวิร์ด abstract จะต้องมีอย่างน้อยหนึ่งวิธีที่มีคีย์เวิร์ด abstract และวิธีการนั้นควรมีเพียงลายเซ็นเท่านั้น

ตัวอย่างเช่น

public abstract class MyAbstrtactClass {
abstract Integer myAbstractMethod1();
}

สายเอเพ็กซ์

สตริงคือชุดอักขระที่ไม่มีการจำกัดจำนวนอักขระ ตัวอย่างเช่น:

String name = 'Test';

มีวิธีการในตัวหลายวิธีที่จัดทำโดยคลาส String ใน Salesforce ต่อไปนี้เป็นฟังก์ชันที่ใช้บ่อยและบ่อยที่สุด:

ย่อ(maxWidth)

วิธีการนี้จะตัดทอนสตริงให้เหลือความยาวตามที่ระบุ และส่งคืนหากความยาวของสตริงที่กำหนดยาวกว่าความยาวที่ระบุ มิฉะนั้นจะส่งคืนสตริงต้นฉบับ หากค่าสำหรับตัวแปร maxWidth น้อยกว่า 4 วิธีการนี้ส่งคืนข้อยกเว้นรันไทม์ – System.StringException: ความกว้างของตัวอักษรย่อขั้นต่ำคือ 4

ตัวอย่างเช่น:

String s = 'Hello World';
String s2 = s.abbreviate(8);
System.debug('s2'+s2); //Hello...

ใช้ตัวพิมพ์ใหญ่ ()

เมธอดนี้จะแปลงอักษรตัวแรกของสตริงเป็นตัวพิมพ์ชื่อเรื่องและส่งกลับ

ตัวอย่างเช่น:

String s = 'hello;
String s2 = s.capitalize();
System.assertEquals('Hello', s2);

มี (สตริงย่อย)

เมธอดนี้จะคืนค่าเป็นจริงหากสตริงที่เรียกเมธอดนี้มีสตริงย่อยที่ระบุ

String name1 = 'test1';
String name2 = 'test2';
Boolean flag = name.contains(name2);
System.debug('flag::',+flag); //true

เท่ากับ (stringOrId)

เมธอดนี้จะคืนค่าเป็นจริงหากพารามิเตอร์ที่ส่งผ่านไม่เป็นโมฆะ และระบุลำดับไบนารีของอักขระเดียวกันกับสตริงที่เรียกใช้เมธอด

ในขณะที่เปรียบเทียบค่า Id ความยาวของ ID อาจไม่เท่ากัน ตัวอย่างเช่น: หากเปรียบเทียบสตริงที่แสดงถึง 15 ตัวอักษร id กับอ็อบเจ็กต์ที่แสดงถึง 18 ตัวอักษร ID วิธีการนี้จะคืนค่าเป็นจริง ตัวอย่างเช่น:

Id idValue15 = '001D000000Ju1zH';
Id idValue18 = '001D000000Ju1zHIAR';
Boolean result4 = stringValue15.equals(IdValue18);
System.debug('result4', +result4); //true

ในตัวอย่างข้างต้น วิธีการเท่ากับคือการเปรียบเทียบรหัสวัตถุ 15 ตัวอักษรกับรหัสวัตถุ 18 ตัวอักษร และหากรหัสทั้งสองนี้แสดงถึงลำดับไบนารี่เดียวกัน ก็จะคืนค่าเป็นจริง

ใช้วิธีนี้เพื่อทำการเปรียบเทียบแบบคำนึงถึงขนาดตัวพิมพ์

หลบหนี SingleQuotes (stringToEscape)

เมธอดนี้จะเพิ่มอักขระ Escape (\) ก่อนเครื่องหมายคำพูดเดี่ยวใดๆ ในสตริงและส่งกลับ วิธีนี้จะป้องกันการแทรก SOQL ในขณะที่สร้างแบบสอบถาม SOQL แบบไดนามิก วิธีการนี้ช่วยให้แน่ใจว่าเครื่องหมายคำพูดเดี่ยวทั้งหมดถือเป็นสตริงที่ล้อมรอบ แทนที่จะเป็นคำสั่งฐานข้อมูล

ตัวอย่างเช่น:

String s = 'Hello Tom';
system.debug(s); // Outputs 'Hello Tom'
String escapedStr = String.escapeSingleQuotes(s);
// Outputs \'Hello Tom\'

ลบ (สตริงย่อย)

วิธีนี้จะลบการเกิดขึ้นทั้งหมดของสตริงย่อยที่กล่าวถึงออกจากสตริงที่เรียกใช้เมธอดและส่งกลับสตริงผลลัพธ์

ตัวอย่างเช่น

String s1 = 'Salesforce and force.com';
String s2 = s1.remove('force');
System.debug( 's2'+ s2);// 'Sales and .com'

สตริงย่อย (startIndex)

วิธีการนี้ส่งคืนสตริงย่อยที่เริ่มต้นจากอักขระที่ startIndex ขยายไปจนถึงตัวสุดท้ายของสตริง

ตัวอย่างเช่น:

String s1 = 'hamburger';
String s2 = s1.substring(3);
System.debug('s2'+s2); //burger

ย้อนกลับ ()

วิธีนี้จะกลับอักขระทั้งหมดของสตริงและส่งกลับ ตัวอย่างเช่น:

String s = 'Hello';
String s2 = s.reverse();
System.debug('s2::::'+s2);// olleH  // Hello

trim(): วิธีการนี้จะลบช่องว่างนำหน้าทั้งหมดออกจากสตริงและส่งคืน

มูลค่าของ (เพื่อแปลง)

วิธีการนี้จะส่งคืนการแสดงสตริงของวัตถุที่ส่งผ่าน

ขีดจำกัดผู้ว่าการเอเพ็กซ์

ขีดจำกัดของ Apex governor คือขีดจำกัดที่บังคับใช้โดย Apex runtime engine เพื่อให้แน่ใจว่าโค้ดและกระบวนการ Apex ของรันเวย์ใดๆ จะไม่ควบคุมทรัพยากรที่ใช้ร่วมกันและไม่ละเมิดการประมวลผลสำหรับผู้ใช้รายอื่นในสภาพแวดล้อมแบบมัลติเทแนนท์ ขีดจำกัดเหล่านี้จะได้รับการตรวจสอบกับธุรกรรม Apex แต่ละรายการ ต่อไปนี้คือขีดจำกัดของ governor ที่กำหนดโดย Salesforce ในแต่ละธุรกรรม Apex:

Descriptไอออน	ลิมิตสวิตช์
แบบสอบถาม SOQL ที่สามารถทำได้ในธุรกรรมแบบซิงโครนัส	100
แบบสอบถาม SOQL ที่สามารถทำได้ในธุรกรรมแบบอะซิงโครนัส	200
บันทึกที่สามารถดึงข้อมูลได้โดยการสืบค้น SOQL	50000
บันทึกที่สามารถดึงข้อมูลได้โดย Database.getQueryLocator	10000
คำสั่ง SOSL ที่สามารถทำได้ในธุรกรรมเอเพ็กซ์	20
บันทึกที่สามารถดึงข้อมูลได้โดยแบบสอบถาม SOSL	2000
คำสั่ง DML ที่สามารถทำได้ในธุรกรรมเอเพ็กซ์	150
เรกคอร์ดที่สามารถประมวลผลเป็นผลจากคำสั่ง DML, Approval.process หรือ Database.emptyRecycleBin	10000
คำบรรยายภาพที่สามารถทำได้ในธุรกรรมเอเพ็กซ์	100
ขีดจำกัดการหมดเวลาสะสมสำหรับคำบรรยายทั้งหมดที่กำลังดำเนินการในธุรกรรมเอเพ็กซ์	วินาที 120
ขีดจำกัดงานเอเพ็กซ์ที่สามารถเพิ่มลงในคิวด้วย System.enqueueJob	50
กำหนดเวลาดำเนินการสำหรับธุรกรรม Apex แต่ละรายการ	10 นาที
ขีดจำกัดอักขระที่ใช้ในคลาสเอเพ็กซ์และทริกเกอร์	1 ล้าน
ขีดจำกัดเวลา CPU สำหรับการทำธุรกรรมแบบซิงโครนัส	10,000 มิลลิวินาที
ขีดจำกัดเวลา CPU สำหรับธุรกรรมอะซิงโครนัส	60,000 มิลลิวินาที

เอเพ็กซ์เก็ตเตอร์และเซ็ตเตอร์

คุณสมบัติ Apex คล้ายกับตัวแปร apex Getter และ setter จำเป็นต่อคุณสมบัติเอเพ็กซ์ Getter และ setter สามารถใช้เพื่อรันโค้ดก่อนที่จะเข้าถึงหรือเปลี่ยนแปลงค่าคุณสมบัติ รหัสใน get accessor จะดำเนินการเมื่อมีการอ่านค่าคุณสมบัติ รหัสในชุด accessor ทำงานเมื่อค่าคุณสมบัติมีการเปลี่ยนแปลง คุณสมบัติใด ๆ ที่มี get accessor จะถือว่าเป็นแบบอ่านอย่างเดียว คุณสมบัติใด ๆ ที่ตั้งค่า accessor จะถือว่าเขียนเฉพาะคุณสมบัติใด ๆ ที่มีทั้ง get และ set accessor จะถือว่าเป็นแบบอ่าน-เขียน ไวยากรณ์ของคุณสมบัติเอเพ็กซ์:

public class myApexClass {
// Property declaration
	access_modifierreturn_typeproperty_name {
	get {
			//code  
		}
		set{
			//code
		}
	}

ในที่นี้ access_modifier คือตัวแก้ไขการเข้าถึงของคุณสมบัติ return_type คือ dataType ของคุณสมบัติ property_name คือชื่อของคุณสมบัติ

ด้านล่างนี้เป็นตัวอย่างของคุณสมบัติ apex ที่มีทั้งตัวรับและตั้งค่าตัวเข้าถึง

public class myApex{
	public String name{
		get{ return name;}
		set{ name = 'Test';}
	}
}

ในที่นี้ ชื่อคุณสมบัติคือชื่อ และเป็นทรัพย์สินสาธารณะ และส่งคืน dataType สตริง

ไม่จำเป็นต้องมีโค้ดบางส่วนในบล็อกรับและตั้งค่า บล็อกเหล่านี้สามารถเว้นว่างไว้เพื่อกำหนดคุณสมบัติอัตโนมัติ ตัวอย่างเช่น:

public double MyReadWriteProp{ get; set; } 

รับและตั้งค่า accessor ยังสามารถกำหนดได้ด้วยตัวแก้ไขการเข้าถึง หากมีการกำหนดตัวเข้าถึงด้วยตัวแก้ไข มันจะแทนที่ตัวแก้ไขการเข้าถึงสำหรับคุณสมบัตินั้น ตัวอย่างเช่น:

public String name{private get; set;}// name is private for read and public to write.

เอเพ็กซ์คลาส

คลาสเอเพ็กซ์คือพิมพ์เขียวหรือเทมเพลตที่ใช้สร้างออบเจ็กต์ วัตถุเป็นตัวอย่างของชั้นเรียน

มีสามวิธีในการสร้างคลาส apex ใน Salesforce:

คอนโซลนักพัฒนาซอฟต์แวร์

Force.com IDE

หน้ารายละเอียดคลาส Apex

ใน apex คุณสามารถกำหนดคลาสภายนอกที่เรียกว่าคลาสระดับบนสุดได้ และคุณยังสามารถกำหนดคลาสภายในคลาสภายนอกที่เรียกว่าคลาสภายในได้ด้วย

จำเป็นต้องใช้ตัวแก้ไขการเข้าถึงเช่น global หรือ public ในการประกาศของคลาสภายนอก

ไม่จำเป็นที่จะต้องใช้ตัวดัดแปลงการเข้าถึงในการประกาศคลาสภายใน

คลาสเอเพ็กซ์ถูกกำหนดโดยใช้คีย์เวิร์ดคลาสตามด้วยชื่อคลาส

คีย์เวิร์ดขยายใช้เพื่อขยายคลาสที่มีอยู่โดยคลาสเอเพ็กซ์ และคีย์เวิร์ด Implement ถูกใช้เพื่อใช้อินเทอร์เฟซโดยคลาสเอเพ็กซ์

Salesforce Apex ไม่รองรับการสืบทอดหลายรายการ คลาส apex สามารถขยายคลาส apex ที่มีอยู่ได้เพียงคลาสเดียว แต่สามารถใช้อินเทอร์เฟซหลายรายการได้

คลาส apex สามารถมีคอนสตรัคเตอร์ที่ผู้ใช้กำหนดได้ และหากไม่มีคอนสตรัคเตอร์ที่ผู้ใช้กำหนด ก็ใช้คอนสตรัคเตอร์เริ่มต้น รหัสในตัวสร้างดำเนินการเมื่อมีการสร้างอินสแตนซ์ของคลาส

ไวยากรณ์ของตัวอย่างคลาส Apex:

public class myApexClass{
// variable declaration
//constructor
	public myApexClass{
	}
//methods declaration
}

คำหลักใหม่จะใช้เพื่อสร้างอินสแตนซ์ของคลาสเอเพ็กซ์ ด้านล่างนี้เป็นไวยากรณ์สำหรับการสร้างอินสแตนซ์ของคลาสเอเพ็กซ์

myApexClass obj = new myApexClass();

เอเพ็กซ์ทริกเกอร์

ทริกเกอร์ Apex ช่วยให้คุณสามารถดำเนินการ Apex ที่กำหนดเองได้ก่อนและหลังการดำเนินการ DML

Apex รองรับทริกเกอร์สองประเภทดังต่อไปนี้:

ก่อนทริกเกอร์: ทริกเกอร์เหล่านี้ใช้เพื่อตรวจสอบและอัปเดตค่าของฟิลด์ก่อนที่เรกคอร์ดจะบันทึกลงในฐานข้อมูล

หลังจากทริกเกอร์: ทริกเกอร์เหล่านี้ใช้เพื่อเข้าถึงฟิลด์ (ID เรกคอร์ด, ฟิลด์ LastModifiedDate) ที่กำหนดโดยระบบหลังจากเรกคอร์ดที่คอมมิตกับฐานข้อมูล ค่าฟิลด์เหล่านี้สามารถใช้เพื่อแก้ไขเรกคอร์ดอื่นๆ ได้ บันทึกที่เริ่มทำงานหลังจากทริกเกอร์จะเป็นแบบอ่านอย่างเดียว

แนวทางปฏิบัติที่ดีที่สุดในการเขียนทริกเกอร์ขนาดใหญ่ ทริกเกอร์ขนาดใหญ่สามารถประมวลผลบันทึกเดียวและหลายบันทึกพร้อมกันได้

ไวยากรณ์ของทริกเกอร์เอเพ็กซ์:

trigger TriggerName on ObjectName (trigger_events) {
	//Code_block
 }

ในที่นี้ TriggerName คือชื่อของทริกเกอร์ ObjectName คือชื่อของออบเจ็กต์ที่จะเขียนทริกเกอร์ trigger_events คือรายการเหตุการณ์ที่คั่นด้วยเครื่องหมายจุลภาค

ต่อไปนี้เป็นเหตุการณ์ที่รองรับโดยทริกเกอร์ Apex: ก่อนแทรก ก่อนการอัปเดต ก่อนการลบ หลังแทรก หลังการอัปเดต หลังการลบ หลังจากการยกเลิกการลบ

ไม่สามารถใช้คีย์เวิร์ดแบบคงที่ในทริกเกอร์ Apex คีย์เวิร์ดทั้งหมดที่ใช้ได้กับคลาสภายในสามารถใช้ในทริกเกอร์ Apex ได้

มีตัวแปรโดยนัยที่กำหนดโดยทุกทริกเกอร์ที่ส่งคืนบริบทรันไทม์ ตัวแปรเหล่านี้ถูกกำหนดไว้ในระบบ คลาสทริกเกอร์ ตัวแปรเหล่านี้เรียกว่าตัวแปรบริบท ภาพหน้าจอด้านล่างแสดงตัวแปรบริบทที่รองรับโดยทริกเกอร์เอเพ็กซ์

ต่อไปนี้คือการพิจารณาตัวแปรบริบทในทริกเกอร์ Apex:

• อย่าใช้ trigger.new และ trigger.old ในการดำเนินการ DML
• Trigger.new ไม่สามารถลบได้
• Trigger.new เป็นแบบอ่านอย่างเดียว
• Trigger.new สามารถใช้เพื่อเปลี่ยนค่าของฟิลด์บนออบเจ็กต์เดียวกันก่อนทริกเกอร์เท่านั้น

ภาพหน้าจอด้านล่างแสดงรายการข้อควรพิจารณาเกี่ยวกับการดำเนินการเฉพาะในเหตุการณ์ทริกเกอร์ต่างๆ

คลาสแบทช์ในเอเพ็กซ์

คลาสแบตช์ใน Salesforce ใช้ในการประมวลผลข้อมูลจำนวนมากซึ่งจะเกินขีดจำกัดของ Apex Governor หากดำเนินการตามปกติ คลาสแบตช์จะดำเนินการโค้ดแบบอะซิงโครนัส

ต่อไปนี้เป็นข้อดีของการเรียนแบบแบตช์:

• คลาสแบทช์ประมวลผลข้อมูลเป็นกลุ่ม และหากกลุ่มล้มเหลวในการประมวลผลสำเร็จ กลุ่มทั้งหมดที่ประมวลผลสำเร็จจะไม่ย้อนกลับ
• ข้อมูลทุกก้อนในคลาสแบทช์ที่ประมวลผลด้วยชุดขีดจำกัดใหม่ของ Governor ซึ่งทำให้มั่นใจได้ว่าโค้ดจะดำเนินการภายในขีดจำกัดการดำเนินการของ Governor
• ฐานข้อมูล ต้องใช้อินเทอร์เฟซแบบแบตช์โดยคลาสเอเพ็กซ์เพื่อใช้เป็นคลาสแบตช์ มีวิธีการสามวิธีที่ต้องใช้โดยคลาสแบตช์

ต่อไปนี้เป็นสามวิธีที่ฐานข้อมูลให้มา อินเทอร์เฟซแบบแบตช์:

1.เริ่มต้น()

วิธีการนี้จะสร้างขอบเขตของเรกคอร์ดหรืออ็อบเจ็กต์ที่จะประมวลผลโดยวิธีอินเทอร์เฟซที่ดำเนินการ ในระหว่างการดำเนินการแบบแบตช์ จะมีการเรียกใช้เพียงครั้งเดียว วิธีการนี้อาจส่งคืนอ็อบเจ็กต์ Database.QueryLocator หรือ Iterable จำนวนเรกคอร์ดที่เรียกค้นโดยแบบสอบถาม SQL โดยใช้อ็อบเจ็กต์ Database.QueryLocator คือ 50 ล้านเรกคอร์ด แต่หากใช้ iterable จำนวนเรกคอร์ดทั้งหมดที่สามารถเรียกค้นโดยแบบสอบถาม SQL ได้คือ 50000 เท่านั้น Iterable จะใช้เพื่อสร้างขอบเขตที่ซับซ้อนสำหรับคลาสแบบแบตช์

ไวยากรณ์ของวิธีการเริ่มต้น:

global (Database.QueryLocator | Iterable<sObject>) start(Database.BatchableContextbc) {}

2.ดำเนินการ()

วิธีนี้ใช้สำหรับการประมวลผลข้อมูลแต่ละก้อน สำหรับแต่ละส่วนของบันทึกวิธีการดำเนินการเรียกว่า ขนาดแบตช์เริ่มต้นสำหรับการดำเนินการคือ 200 เรกคอร์ด วิธีการดำเนินการจะใช้เวลาสองข้อโต้แย้ง:

การอ้างอิงถึงวัตถุ Database.BatchableContext

รายการ sObjects เช่น List หรือรายการประเภทที่กำหนดพารามิเตอร์ ไวยากรณ์ของวิธีการดำเนินการ:

global void execute(Database.BatchableContext BC, list<P>){}

3.เสร็จสิ้น()

วิธีการ Finish จะถูกเรียกหนึ่งครั้งระหว่างการดำเนินการของคลาสแบตช์ การดำเนินการหลังการประมวลผลสามารถดำเนินการได้ในวิธีการ Finish ตัวอย่างเช่น: การส่งอีเมลยืนยัน วิธีการนี้จะถูกเรียกเมื่อแบตช์ทั้งหมดได้รับการประมวลผล รูปแบบของวิธีการ Finish:

global void finish(Database.BatchableContext BC){}

วัตถุ Database.BatchableContext

แต่ละวิธีของฐานข้อมูล อินเทอร์เฟซ Batchable มีการอ้างอิงถึงวัตถุ Database.BatchableContext

ออบเจ็กต์นี้ใช้เพื่อติดตามความคืบหน้าของงานแบตช์

ต่อไปนี้เป็นวิธีการอินสแตนซ์ที่ BatchableContext จัดทำไว้:

• getChildJobId(): วิธีการนี้จะส่งคืน ID ของงานแบทช์ที่กำลังประมวลผลอยู่

• getJobId(): วิธีการนี้ส่งคืน ID ของงานแบตช์

ด้านล่างนี้เป็นไวยากรณ์ของคลาสแบทช์:

global class MyBatchClass implements Database.Batchable<sObject> {
	global (Database.QueryLocator | Iterable<sObject>) start(Database.BatchableContextbc) {
// collect the batches of records or objects to be passed to execute
}
global void execute(Database.BatchableContextbc, List<P> records){
// process each batch of records
}
global void finish(Database.BatchableContextbc){
// execute any post-processing operations
}
}

วิธี Database.executeBatch

เมธอด Database.executeBatch ใช้สำหรับการดำเนินการคลาสแบตช์

วิธีการนี้ใช้พารามิเตอร์สองตัว: อินสแตนซ์ของคลาสแบตช์ที่จะประมวลผล พารามิเตอร์ตัวเลือกเพื่อระบุขนาดแบตช์หากไม่ได้ระบุไว้ จะใช้ขนาดเริ่มต้นที่ 200

ไวยากรณ์ของ Database.executeBatch :

Database.executeBatch(myBatchObject,scope)

การดำเนินการชื่อคลาสแบตช์ MyBatchClass :

MyBatchClassmyBatchObject = new MyBatchClass(); 
Id batchId = Database.executeBatch(myBatchObject,100);

ฐานข้อมูลสถานะ

คลาสแบทช์ไม่มีสถานะตามค่าเริ่มต้น ทุกครั้งที่เรียกเมธอดเอ็กซีคิวต์ว่าได้รับสำเนาใหม่ของอ็อบเจ็กต์ ตัวแปรทั้งหมดของคลาสจะถูกเตรียมใช้งาน

Database.stateful ถูกนำไปใช้เพื่อทำให้คลาสแบตช์มีสถานะ

หากคลาสแบทช์ของคุณใช้งาน ฐานข้อมูล อินเทอร์เฟซ stateful ตัวแปรอินสแตนซ์ทั้งหมดจะรักษาค่าไว้ แต่ตัวแปรคงที่จะถูกรีเซ็ตระหว่างธุรกรรม

สรุป

• Apex เป็นประเภทที่เข้มงวดและมุ่งเน้นวัตถุ ภาษาโปรแกรม ที่รวบรวมและรันบนแพลตฟอร์ม force.com
• ภาษาโปรแกรม Apex เป็นภาษาที่ไม่คำนึงถึงขนาดตัวพิมพ์
• โฟลว์ของการดำเนินการสองประเภทใน Apex คือ 1) การกระทำของนักพัฒนา 2) การกระทำของผู้ใช้ปลายทาง
• Apex ช่วยคุณสร้างบริการเว็บที่รวม Salesforce เข้ากับแอปพลิเคชันอื่น ๆ
• ประเภทข้อมูลที่สนับสนุนโดย apex คือ: 1).ดั้งเดิม 2) คอลเลกชัน 3) sObject, Enums, 4) คลาส, 5) วัตถุและอินเทอร์เฟซ
• Apex ระบุการสนับสนุนสาธารณะ ส่วนตัว ป้องกัน และทั่วโลก
• คีย์เวิร์ดที่ใช้ใน Apex คือ: 1) พร้อมการแชร์ 2) ไม่มีการแชร์ 3) คงที่ 4) สุดท้าย 5) การส่งคืน 6) Null 7) เสมือน 8) บทคัดย่อ
• สตริงคือชุดอักขระที่ไม่มีการจำกัดจำนวนอักขระ
• ขีดจำกัดผู้ว่าการเอเพ็กซ์คือขีดจำกัดที่บังคับใช้โดยเอ็นจิ้นรันไทม์ของเอเพ็กซ์ เพื่อให้แน่ใจว่าโค้ดและกระบวนการเอเพ็กซ์ของรันเวย์ใดๆ
• Getter และ setter สามารถใช้เพื่อรันโค้ดก่อนที่จะเข้าถึงหรือเปลี่ยนแปลงค่าคุณสมบัติ
• มีสามวิธีในการสร้างคลาส apex ใน Salesforce: 1)Developer Console 2)Force.com IDE และ 3) หน้ารายละเอียดคลาส Apex
• ทริกเกอร์ Apex ช่วยให้คุณสามารถดำเนินการ Apex ที่กำหนดเองได้ก่อนและหลังการดำเนินการ DML
• คลาสแบทช์ใน Salesforce ใช้เพื่อประมวลผลบันทึกจำนวนมากที่อาจเกินขีดจำกัดของ apex Governor หากประมวลผลตามปกติ