Salesforce Apex oktatóanyag kezdőknek

Az Apex segít a fejlesztőknek üzleti logikát hozzáadni a rendszereseményekhez, például a gombokra kattintásokhoz, a kapcsolódó rekordfrissítésekhez és a Visualforce oldalakhoz. Az Apex szintaxisa hasonló a következőhöz: Java. Regisztráljon a Salesforce-ra hogy megismerje a CRM működését.

Az Apex programozási nyelv jellemzői

Íme a Salesforce Apex fontos funkciói:

• Az Apex egy kis- és nagybetűket nem megkülönböztető nyelv.
• Az Apex használatával DML-műveleteket, például INSERT, UPDATE, UPSERT és DELETE műveleteket végezhet az sObject rekordokon.
• Az sObject rekordokat SOQL (Salesforce Object Query Language) és SOSL (Salesforce Object Search Language) használatával kérdezheti le az Apexben.
• Lehetővé teszi a egységteszt és futtassa le az ellenőrzéshez kód lefedettség és a kód hatékonysága az Apexben.
• Az Apex több bérlős környezetben fut, és Salesforce olyan irányítói korlátokat határozott meg, amelyek megakadályozzák, hogy a felhasználó monopolizálja a megosztott erőforrásokat. Bármely kód, amely átlépi a Salesforce irányítói korlátját, sikertelen lesz, és hiba jelenik meg.
• Egy Salesforce objektum adattípusként használható az Apexben. Például:

  Account acc = new Account();

  Itt az Account egy szabványos Salesforce objektum.

• Az Apex automatikusan frissít minden Salesforce-kiadásnál.

Mikor válassza egy fejlesztő az Apexet?

Apex kódot csak akkor szabad írni, ha egy üzleti forgatókönyv túl összetett ahhoz, hogy a Salesforce által biztosított előre elkészített, kattintással vezérelhető funkciókkal megvalósítható legyen.

Az alábbiakban néhány olyan forgatókönyvet láthat, ahol Apex kódot kell írnia:

• Olyan webszolgáltatások létrehozása, amelyek integrálják a Salesforce-t más alkalmazásokkal.
• Egyéni validáció implementálása sObjects objektumokon.
• Egyéni Apex logika végrehajtása DML-művelet végrehajtásakor.
• Olyan funkciók megvalósítása, amelyek nem építhetők fel meglévő deklaratív automatizálási eszközökkel, például a Flow-val.
• Hogy hozzanak létre e-mail szolgáltatások amelyek feldolgozzák a bejövő e-mailek tartalmát, fejléceit és mellékleteit.

Miután megtudtad, mikor a megfelelő választás az Apex, a következő lépés annak megértése, hogy mi történik a kódoddal a mentés után.

Az Apex működési felépítése

Az Apex kód műveleteinek folyamata a következő:

• Fejlesztői művelet: Amikor a fejlesztő kódot ment a platformra, az összes Apex kódot egy olyan utasításkészletté fordítja le, amelyet az Apex futásidejű értelmező megért, és ezeket az utasításokat metaadatként menti a platformon.
• Végfelhasználói művelet: Amikor egy felhasználói esemény Apex kódot hajt végre, a platformkiszolgáló lekéri a lefordított utasításokat a metaadatokból, és lefuttatja azokat az Apex értelmezőn, mielőtt visszaadja az eredményt.

Az alábbi ábra azt mutatja be, hogyan lépnek interakcióba a fejlesztői és a végfelhasználói műveletek a Lightning Platform alkalmazáskiszolgálóval:

Apex fejlesztési környezet

Az Apex kód fejleszthető tesztkörnyezetben vagy a Salesforce Developer Edition szervezetében.

Ajánlott gyakorlat a kódot egy sandbox környezetben fejleszteni, majd éles környezetben telepíteni, az alábbiak szerint:

Apex kódfejlesztő eszközök: Az alábbiakban három eszközt találhat Apex kód fejlesztéséhez a Salesforce összes kiadásában:

• Fejlesztői konzol
• Visual Studio Code a Salesforce Extension Pack csomaggal (ez váltja fel a kifutó Force.com IDE-t)
• Code szerkesztő a Salesforce beállításai felhasználói felületén

Miután elkészítettük a környezetünket, nézzük meg a nyelv építőelemeit, kezdve az adattípusokkal.

Adattípusok az Apexben

Az Apex által támogatott adattípusok a következők:

Primitív

Egész szám, DoubleA , Long, Date, Datetime, Decimal, Time, Blob, String, ID és Boolean értékek primitív adattípusoknak minősülnek. Minden primitív adattípus érték alapján kerül átadásra, nem hivatkozás alapján.

Gyűjtemények

Az Apexben háromféle gyűjtemény érhető el:

• Lista: Ez primitívek, sObject-ek, kollekciók vagy Apex objektumok rendezett gyűjteménye, indexek alapján.
• Készlet: Egyedi elemek rendezetlen gyűjteménye, amely nem tartalmaz ismétlődéseket.
• Térkép: Ez egyedi kulcsok gyűjteménye, amelyek egyetlen értékre vannak leképezve, amelyek lehetnek primitívek, sObject-ek, gyűjtemények vagy Apex objektumok.

sObject

Ez egy speciális adattípus a Salesforce-ban. Hasonló a táblázathoz SQL és olyan mezőket tartalmaz, amelyek hasonlóak az SQL oszlopaihoz.

Enums

Az enum egy hasizmot jelent.tract adattípus, amely egy véges, megadott azonosítókból álló halmaz egy értékét tárolja.

Osztályok, objektumok és interfészek

A felhasználó által definiált Apex osztályok és interfészek szintén használhatók adattípusként. Az objektum bármely, az Apex által támogatott adattípus egy példányára utal.

Apex szintaxis

Változó nyilatkozat

Mivel az Apex egy erősen típusos nyelv, kötelező egy adattípusú változót deklarálni az Apexben.

Például:

Contact con = new Contact();

Itt a con változót Contact adattípussal deklaráljuk.

SOQL lekérdezés

Az SOQL a Salesforce Object Query Language rövidítése. Az SOQL-t sObject rekordok lekérésére használják a Salesforce adatbázisból. Például:

Account acc = [SELECT Id, Name FROM Account LIMIT 1];

A fenti lekérdezés egy fiókrekordot kér le a Salesforce adatbázisból.

Loop nyilatkozat

Egy ciklusutasítás segítségével végig lehet iterálni egy lista rekordjain. Az iterációk száma megegyezik a lista rekordjainak számával. Például:

List<Account> listOfAccounts = [SELECT Id, Name FROM Account LIMIT 100];
// iteration over the list of accounts
for(Account acc : listOfAccounts){
	//your logic
}

A fenti kódrészletben a listOfAccounts egy List adattípusú változó.

Áramlásszabályozási nyilatkozat

A folyamatvezérlési utasítás akkor hasznos, ha bizonyos feltételek alapján bizonyos kódsorokat szeretnénk végrehajtani.

Például:

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
}

A fenti kódrészlet lekérdezi a fiókrekordokat az adatbázisból, és ellenőrzi a lista méretét.

DML-utasítás

A DML a Data Manipulation Language (adatmanipulációs nyelv) rövidítése. A DML utasításokat a Salesforce adatbázisban lévő adatok manipulálására használják. Például:

Account acc = new Account(Name = 'Test Account');
insert acc; //DML statement to create account record.

Apex hozzáférés-meghatározók

Az Apex által támogatott hozzáférés-leírók a következők:

nyilvános

Ez a hozzáférés-leíró hozzáférést biztosít egy osztályhoz, metódushoz vagy változóhoz, amelyet az Apex egy névtéren belül használ.

Magán

Ez a hozzáférés-leíró hozzáférést biztosít egy osztályhoz, metódushoz vagy változóhoz, amelyet lokálisan, vagy a kód azon szakaszán belül kell használni, ahol definiálva van. Minden olyan metódus és változó, amelyhez nincs definiálva hozzáférés-leíró, az alapértelmezett private hozzáférés-leírót veszi fel.

Védett

Ez a hozzáférés-leíró hozzáférést biztosít egy metódushoz vagy változóhoz, amelyet a meghatározó Apex osztályon belüli belső osztályok használhatnak.

Globál

Ez a hozzáférés-leíró hozzáférést biztosít egy osztályhoz, metódushoz vagy változóhoz, amelyet az Apex egy névtéren belül és azon kívül is használhat. Javasolt, hogy a global kulcsszót ne használjuk, hacsak nem feltétlenül szükséges.

Kulcsszavak az Apexben

Megosztással

Ha egy osztály ezzel a kulcsszóval van definiálva, akkor az aktuális felhasználóra vonatkozó összes megosztási szabály érvényesül. Ha ez a kulcsszó hiányzik, a kód rendszerkörnyezetben fut.

Például:

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

Megosztás nélkül

Ha egy osztály ezzel a kulcsszóval van definiálva, akkor az aktuális felhasználóra vonatkozó megosztási szabályok nem érvényesülnek.

Például:

public without sharing class MyApexClass{
// sharing rules are not enforced when code in this class executes
}

Statikus

A static kulcsszóval definiált változó vagy metódus egyszer inicializálódik, és az osztállyal van társítva. A statikus változók és metódusok közvetlenül az osztály nevével hívhatók meg anélkül, hogy az osztály példányát kellene létrehozni.

vég

Egy final kulcsszóval definiált konstans vagy metódus nem írható felül. Például:

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

Ha megpróbálod felülírni az INT_CONST változó értékét, akkor a következő kivételt kapod: System.FinalException: A végső változó már inicializálva van.

Visszatérés

Ez a kulcsszó egy metódusból származó értéket ad vissza. Például:

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

Null

Egy null konstanst definiál, és hozzárendelhető egy változóhoz. Például:

Boolean b = null;

Tényleges

Ha egy osztály a virtual kulcsszóval van definiálva, akkor az kiterjeszthető és felülírható.

Abstract

Ha egy osztályt az absz.tract kulcsszó, legalább egy metódust kell tartalmaznia az abs kulcsszóvaltract, és ennek a metódusnak csak aláírással kell rendelkeznie.

Például:

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

Apex String

A karakterlánc karakterlánc karakterek halmaza, karakterkorlát nélkül. Például:

String name = 'Test';

A Salesforce String osztálya számos beépített metódust biztosít. Az alábbiakban néhány gyakran használt metódust láthatunk:

rövidít (max. szélesség)

Ez a metódus egy karakterláncot csonkol a megadott hosszúságúra, és visszaadja azt, ha a megadott karakterlánc hossza hosszabb, mint a megadott hosszúság; egyébként az eredeti karakterláncot adja vissza. Ha a maxWidth változó értéke kisebb, mint 4, a metódus futásidejű kivételt dob ​​– System.StringException: A minimális rövidítés szélessége 4.

Például:

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

nagybetűs ()

Ez a módszer a karakterlánc első betűjét nagybetűvé alakítja, és visszaadja.

Például:

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

tartalmaz (alkarakterlánc)

Ez a metódus igaz értéket ad vissza, ha a metódust hívó karakterlánc tartalmazza a megadott részkarakterláncot.

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

egyenlő(stringOrId)

Ez a metódus igaz értéket ad vissza, ha az átadott paraméter nem null, és ugyanazt a bináris karaktersorozatot jelöli, mint a metódust hívó karakterlánc.

Az azonosítóértékek összehasonlításakor az azonosítók hossza nem feltétlenül egyezik meg. Például, ha egy 15 karakteres azonosítót reprezentáló karakterláncot összehasonlítunk egy 18 karakteres azonosítót reprezentáló objektummal, ez a metódus továbbra is igaz értéket ad vissza. Például:

String stringValue15 = '001D000000Ju1zH';
Id idValue18 = '001D000000Ju1zHIAR';
Boolean result = stringValue15.equals(idValue18);
System.debug('result: ' + result); //true

A fenti példában az equals metódus összehasonlít egy 15 karakteres objektumazonosítót egy 18 karakteres objektumazonosítóval, és ha mindkét azonosító ugyanazt a bináris sorozatot jelöli, akkor igaz értéket ad vissza.

Használja ezt a módszert a kis- és nagybetűk megkülönböztetésére.

escapeSingleQuotes(stringToEscape)

Ez a metódus egy escape karaktert (\) ad hozzá minden egyes idézőjel elé egy karakterláncban, és visszaadja az eredményt. Ez a metódus megakadályozza a SOQL injektálást dinamikus SOQL lekérdezés létrehozásakor. Biztosítja, hogy az összes egyes idézőjelet befoglaló karakterláncként kezelje a rendszer, nem pedig adatbázis-parancsként.

Például:

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

eltávolítás (alkarakterlánc)

Ez a metódus eltávolítja az említett részkarakterlánc összes előfordulását a metódust meghívó karakterláncból, és visszaadja az eredményül kapott karakterláncot.

Például:

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

részkarakterlánc (kezdőindex)

Ez a metódus egy olyan részkarakterláncot ad vissza, amely a startIndexben lévő karaktertől kezdődik és a karakterlánc végéig tart.

Például:

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

fordított ()

Ez a metódus megfordítja egy karakterlánc összes karakterét, és visszaadja azt. Például:

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

trim ()

Ez a metódus eltávolítja az összes kezdő és záró szóközt egy karakterláncból, és visszaadja azt.

valueOf(konvertálni)

Ez a metódus a megadott objektum karakterlánc reprezentációját adja vissza.

A sztringek, osztályok és kulcsszavak akkor állnak össze, amikor a logikát újrafelhasználható egységekbe csomagoljuk, és pontosan erre valók az Apex osztályok.

Apex osztály

Az Apex osztály egy tervrajz vagy sablon, amelyből objektumok jönnek létre. Az objektum egy osztály egy példánya.

Háromféleképpen hozhat létre Apex osztályokat a Salesforce-ban:

• Fejlesztői konzol
• Visual Studio Code a Salesforce bővítménycsomaggal
• Apex osztály részleteinek oldala a Beállításokban

Az Apexben definiálhatsz egy külső osztályt, más néven legfelső szintű osztályt, és egy külső osztályon belüli osztályokat is definiálhatsz, ezeket belső osztályoknak nevezzük.

Kötelező hozzáférés-módosítót, például global vagy public használni egy külső osztály deklarációjában.

Nem szükséges hozzáférési módosítót használni a belső osztályok deklarációjában.

Egy Apex osztályt a class kulcsszóval definiálunk, amelyet az osztály neve követ.

Az extends kulcsszó egy meglévő osztály kiterjesztésére szolgál egy Apex osztályban, az implements kulcsszó pedig egy interfész megvalósítására egy Apex osztályban.

A Salesforce Apex nem támogatja a többszörös öröklődést; egy Apex osztály csak egy meglévő Apex osztályt tud kiterjeszteni, de több interfészt is képes megvalósítani.

Egy Apex osztály tartalmazhat felhasználó által definiált konstruktort, és ha ilyen nem áll rendelkezésre, akkor az alapértelmezett konstruktor kerül felhasználásra. A konstruktorban lévő kód akkor fut le, amikor egy osztály egy példánya létrejön.

Egy Apex osztály szintaxisa:

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

Az új kulcsszó egy Apex osztály példányának létrehozására szolgál. Az alábbiakban az Apex osztály példányának létrehozásának szintaxisa látható:

myApexClass obj = new myApexClass();

Apex Getter és Setter

Egy Apex tulajdonság hasonló egy Apex változóhoz. Egy Apex tulajdonsághoz szükséges egy getter és egy setter. Ezek segítségével kódot lehet végrehajtani, mielőtt a tulajdonság értékéhez hozzáférnénk vagy azt módosítanánk. A get akcesszorban lévő kód akkor hajtódik végre, amikor egy tulajdonság értékét beolvassuk. A set akcesszorban lévő kód akkor hajtódik végre, amikor egy tulajdonság értékét megváltoztatjuk. Minden olyan tulajdonság, amely csak get akcesszorral rendelkezik, csak olvashatónak, minden olyan tulajdonság, amely csak set akcesszorral rendelkezik, csak írhatónak, és minden olyan tulajdonság, amely get és set akcesszorral is rendelkezik, írhatónak és olvashatónak tekinthető. Egy Apex tulajdonság szintaxisa:

public class myApexClass {
// Property declaration
	access_modifier return_type property_name {
	get {
			//code
		}
		set{
			//code
		}
	}
}

Itt az access_modifier a tulajdonság hozzáférés-módosítója, a return_type a tulajdonság adattípusa, a property_name pedig a tulajdonság neve.

Az alábbiakban egy olyan Apex tulajdonság példáját láthatjuk, amely get és set hozzáférési értékekkel is rendelkezik:

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

Itt a tulajdonság neve name, ez egy nyilvános tulajdonság, és egy String adattípust ad vissza.

Nem kötelező kódot tartalmaznia a get és set blokkoknak. Ezek a blokkok üresen hagyhatók egy automatikus tulajdonság definiálásához. Például:

public double MyReadWriteProp{ get; set; }

A Get és set accessorok saját hozzáférés-módosítókkal is definiálhatók. Ha egy accessor módosítóval van definiálva, az felülírja a tulajdonság hozzáférés-módosítóját. Például:

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

Az osztályok újrafelhasználható logikát definiálnak, amelyet explicit módon hívhatsz meg. A következőkben tárgyalt triggerek automatikusan lefutnak, amikor a rekordok megváltoznak.

Apex Trigger

Az Apex-triggerek lehetővé teszik egyéni Apex-triggerek végrehajtását egy DML-művelet végrehajtása előtt és után.

Az Apex a következő két típusú triggert támogatja:

A triggerek előtt: Ezek az eseményindítók egy mező értékének ellenőrzésére és frissítésére szolgálnak, mielőtt a rekordot az adatbázisba mentenék.

Triggerek után: Ezek az eseményindítók a rendszer által beállított mezőértékek (például a rekordazonosító és a LastModifiedDate mező) elérésére szolgálnak, miután egy rekordot véglegesítettek az adatbázisban. Ezek a mezőértékek más rekordok módosítására használhatók. Az eseményindítók után aktiválódó rekordok írásvédettek.

Ajánlott gyakorlat a tömeges triggerek írása. Egy tömeges trigger egyszerre egyetlen rekordot, de több rekordot is képes feldolgozni.

Egy Apex trigger szintaxisa:

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

Itt a TriggerName a trigger neve, az ObjectName annak az objektumnak a neve, amelyre a trigger írva van, a trigger_events pedig az események vesszővel elválasztott listája.

Az Apex triggerek által támogatott események a következők: beszúrás előtt, frissítés előtt, törlés előtt, beszúrás után, frissítés után, törlés után, visszaállítás után.

Statikus kulcsszavak nem használhatók Apex triggerben. A belső osztályokra alkalmazható összes kulcsszó használható Apex triggerben.

Minden trigger implicit változókat definiál, amelyek visszaadják a futásidejű kontextust. Ezeket a változókat a System.Trigger osztályban definiáljuk, és kontextusváltozóknak nevezzük őket. Az alábbi két képernyőkép az Apex triggerek által támogatott kontextusváltozókat sorolja fel:

Az Apex-triggerek kontextusváltozóival kapcsolatban a következőket kell figyelembe venni:

• Ne használja a trigger.new és trigger.old függvényeket DML műveletekben.
• A Trigger.new fájl nem törölhető.
• A Trigger.new csak olvasható a triggerek után.
• A Trigger.new függvény csak az előző triggerek azonos objektumán lévő mezők értékeinek módosítására használható.

Az alábbi két képernyőkép felsorolja a különböző trigger események során végrehajtandó konkrét műveletekkel kapcsolatos szempontokat:

A triggerek valós idejű logikát kezelnek, de egyes feladatok egyszerűen túl nagyok egyetlen tranzakcióhoz. Itt jön képbe a batch Apex.

Batch Class az Apexben

A Salesforce-ban egy batch osztály nagyszámú rekord feldolgozására szolgál, amelyek normál feldolgozás esetén meghaladnák az Apex irányító korlátait. A batch osztály aszinkron módon hajtja végre a kódot.

A kötegelt osztály előnyei a következők:

• Egy batch osztály chunkokban dolgozza fel az adatokat, és ha egy chunk feldolgozása sikertelen, a sikeresen feldolgozott chunkok nem kerülnek visszagörgetésre.
• Egy batch osztály minden adatrészlete új vezérlőkorlátokkal kerül feldolgozásra, ami biztosítja, hogy a kód a vezérlő végrehajtási korlátain belül futjon.

A Database.Batchable felületet egy Apex osztállyal kell implementálni ahhoz, hogy batch osztályként lehessen használni. Három metódust biztosít, amelyeket a batch osztálynak kell implementálnia:

1. kezdés()

Ez a metódus generálja az interfész execute metódusa által feldolgozandó rekordok vagy objektumok hatókörét. A batch végrehajtása során csak egyszer hívódik meg. A metódus vagy egy Database.QueryLocator objektumot, vagy egy Iterable-t ad vissza. A Database.QueryLocator objektum használatával egy SOQL lekérdezéssel lekérhető rekordok száma 50 millió, de egy Iterable használatával a SOQL lekérdezéssel lekérhető rekordok teljes száma csak 50 000. Az Iterable segítségével egy összetett hatókör generálható a batch osztály számára.

A start metódus szintaxisa:

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

2. végrehajtás()

Ez a metódus az egyes adatblokkok feldolgozására szolgál. Az execute metódus minden rekordblokkhoz meghívódik. A végrehajtás alapértelmezett kötegmérete 200 rekord. Az execute metódus két argumentumot fogad el:

Hivatkozás a Database.BatchableContext objektumra,

sObject-ek listája, például List , vagy paraméterezett típusok listája. Az execute metódus szintaxisa:

global void execute(Database.BatchableContext bc, List<P> records){}

3. befejez()

A finish metódus meghívására egyszer kerül sor a batch osztály végrehajtása során. A finish metódusban utófeldolgozási műveletek végezhetők el. Például: visszaigazoló e-mail küldése. Ez a metódus akkor hívódik meg, amikor az összes batch feldolgozásra került. A finish metódus szintaxisa:

global void finish(Database.BatchableContext bc){}

Database.BatchableContext objektum

A Database.Batchable interfész minden metódusa egy Database.BatchableContext objektumra mutató hivatkozással rendelkezik.

Ez az objektum arra szolgál, hogy track a kötegelt feldolgozás előrehaladását.

A BatchableContext által biztosított példánymetódusok a következők:

• getChildJobId(): Ez a metódus visszaadja az aktuálisan feldolgozás alatt álló kötegelt feladat azonosítóját.
• getJobId(): Ez a metódus a kötegelt feladat azonosítóját adja vissza.

Az alábbiakban egy batch osztály szintaxisa látható:

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

Database.executeBatch módszer

A Database.executeBatch metódus egy batch osztály végrehajtására szolgál.

Ez a metódus két paramétert fogad el: a feldolgozandó batch osztály egy példányát, és egy opcionális scope paramétert, amely a batch méretét adja meg. Ha nincs megadva, akkor a 200-as alapértelmezett méretet használja.

A Database.executeBatch szintaxisa:

Database.executeBatch(myBatchObject, scope)

Egy MyBatchClass nevű batch osztály végrehajtása:

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

Adatbázis.Állapot-nyilvántartó

Egy batch osztály alapértelmezés szerint állapot nélküli. Minden alkalommal, amikor az execute metódus meghívódik, az objektum új másolata érkezik, és az osztály összes változója inicializálódik.

A Database.Stateful implementációja segítségével egy batch osztály állapotkövetővé tehető.

Ha a batch osztályod megvalósítja a adatbázisÁllapotnyilvántartó interfész, az összes példányváltozó megőrzi az értékét, de a statikus változók a tranzakciók között visszaállnak.

Aszinkron Apex Beyond Batch

A Batch Apex csak egy a kód aszinkron futtatásának számos módja közül. A Salesforce négy aszinkron lehetőséget kínál, és a megfelelő kiválasztása attól függ, hogy mennyi adatot dolgoz fel, és hogy a feladatokat láncolni vagy ütemezni kell-e.

• Jövőbeli módszerek: @future megjegyzésekkel ellátva ezek a legalkalmasabbak egyszerű, azonnal aktiválható műveletekhez, például külső webszolgáltatások meghívásához.
• Sorba állítható Apex: Megvalósítja a Queueable interfészt, összetett objektumtípusokat fogad el, feladatazonosítót ad vissza, és támogatja egy feladat láncolását a másikhoz.
• Köteg Apex: Nagyon nagy adatmennyiségeket dolgoz fel darabokban, a fent leírtak szerint.
• Ütemezett Apex: Megvalósítja az Ütemezhető felületet, így egy osztály egy adott időpontban fut, például egy éjszakai takarítási feladat.

típus	Legmegfelelőbb	Kulcsképesség
Jövőbeli módszer	Egyszerű feliratok	Tűz és felejtsd el
Sorba állítható Apex	Szekvenciális feldolgozás	Munkaláncolás és monitorozás
Köteg Apex	Több millió rekord	Darabolt feldolgozás
Ütemezett Apex	Ismétlődő munkák	Cron-alapú időzítés

Bármelyik végrehajtási modellt is választja, minden tranzakciót továbbra is az alább felsorolt ​​platformszintű irányítói limitekhez viszonyítunk.

Apex kormányzói korlátok

Az Apex irányítói korlátok az Apex futtatókörnyezet motorja által érvényesített korlátok, amelyek biztosítják, hogy az elszabadult Apex kódok és folyamatok ne monopolizálják a megosztott erőforrásokat, és ne zavarják meg a többi felhasználó feldolgozását a több-bérlős környezetben. Ezeket a korlátokat minden Apex tranzakciónál ellenőrzik. Az alábbiakban a Salesforce által az egyes Apex tranzakciókra meghatározott irányítói korlátok láthatók:

Leírás	Korlátozni
Szinkron tranzakcióban végrehajtható SOQL lekérdezések	100
Aszinkron tranzakcióban végrehajtható SOQL lekérdezések	200
SOQL lekérdezéssel visszakereshető rekordok	50,000
A Database.getQueryLocator által lehívható rekordok	10,000
Apex tranzakcióban végrehajtható SOSL lekérdezések	20
SOSL lekérdezéssel lehívható rekordok	2,000
Apex tranzakcióban végrehajtható DML utasítások	150
DML utasítás, Approval.process vagy database.emptyRecycleBin eredményeként feldolgozható rekordok	10,000
Apex tranzakcióban végrehajtható lehívások	100
Az Apex tranzakcióban végrehajtott összes lehívás összesített időkorlátja	120 másodperc
A System.enqueueJob segítségével a várólistához hozzáadható Apex-feladatok korlátja	50
Az egyes Apex-tranzakciók végrehajtási határideje	10 perc
Az Apex osztályban és triggerben használható karakterek korlátozása	1 millió
CPU időkorlát szinkron tranzakcióhoz	10,000 milliszekundum
CPU időkorlát aszinkron tranzakcióhoz	60,000 milliszekundum
Teljes halomméret	6 MB (szinkron) / 12 MB (aszinkron)

Hogyan írjunk tesztosztályt Apexben

A Salesforce megköveteli, hogy az Apex kódod legalább 75 százalékát lefedjék egységtesztek, mielőtt éles környezetben is telepíthetnéd, és minden triggernek tartalmaznia kell valamilyen lefedettséget. A tesztosztályok írása ezért alapvető Apex készség, nem pedig opcionális extra.

Egy tesztosztályt @isTest annotálunk, és minden tesztmetódust szintén @isTest jelöl. A tesztmetódusok nem véglegesítenek adatokat az adatbázisba, és nem látják a legtöbb meglévő szervezeti adatot, így minden teszt saját rekordokat hoz létre. A Test.startTest() és Test.stopTest() metódusok új vezérlőkorlátokat adnak a tesztelt kódnak, az assertions pedig ellenőrzik, hogy a logika a vártnak megfelelően viselkedett-e.

Íme egy egyszerű tesztosztály a fióklétrehozási logikához:

@isTest
private class AccountHandlerTest {
    @isTest
    static void testCreateAccount() {
        Account acc = new Account(Name = 'Test Account');
        Test.startTest();
        insert acc;
        Test.stopTest();
        Account result = [SELECT Id, Name FROM Account WHERE Id = :acc.Id];
        System.assertEquals('Test Account', result.Name);
    }
}

Tesztíráskor kövesse az alábbi irányelveket:

• A @testSetup metódussal hozhatsz létre megosztott tesztadatokat egyszer az osztály összes tesztmetódusához.
• Tömeges viselkedés tesztelése 200 rekord beszúrásával, ne csak egymel.
• Fedje le a pozitív, negatív és korlátozott felhasználói forgatókönyveket.
• Mindig használj értelmes System.assert utasításokat; az állítások nélküli lefedettség semmit sem bizonyít.

Apex bevált gyakorlatok

A kezdők gyakran írnak olyan Apex kódot, amely egyetlen rekorddal működik, de a valós tömeges műveletekben kudarcot vall. Az alábbi gyakorlatok a kódot a korlátokon belül tartják, és könnyebben karbantarthatók:

• Mindent tömöríts: Írj olyan logikát, amely rekordok gyűjteményeit kezeli, mivel az eseményindítók akár 200 rekordot is fogadhatnak egyetlen kötegben.
• Tartsd távol a SOQL-t és a DML-t a ciklusoktól: Lekérdezés a ciklus előtt, változások összegyűjtése egy listában, és egy DML utasítás végrehajtása a ciklus után.
• Egy trigger objektumonként: Tartsd a triggereket logikamentesen, és delegáld a munkát kezelő osztályoknak, ami kiszámíthatóvá teszi a végrehajtás sorrendjét.
• Használja megosztással: Rekordszintű biztonság érvényesítése, kivéve, ha dokumentált ok van a rendszerkörnyezetben történő futtatásra.
• Kerüld a fix kódolású azonosítókat: A rekordazonosítók eltérőek a tesztkörnyezetek és az éles környezetek között, ezért kérdezd le őket, vagy használj egyéni metaadatokat.
• Kódban lévő korlátok figyelése: A Limits osztály metódusai, mint például a Limits.getQueries(), lehetővé teszik az erőforrás-felhasználás futásidejű ellenőrzését.

👍 Tipp: Futtassa a kódját 200 rekordon egy sandboxban a telepítés előtt. A legtöbb szabályozási korlát hibája csak nagy mennyiségű adat esetén jelentkezik, és a korai észlelésük sokkal olcsóbb, mint a hibakeresésük éles környezetben.

GYIK