Building Strong FoundationsApex Enterprise Patterns
Andrew Fawcett, FinancialForce.com, CTO@andyinthecloud
All about FinancialForce.comRevolutionizing the Back Office#1 Accounting, Billing and PSA Apps on the Salesforce platform
▪ Native apps
▪ San Francisco HQ, 595 Market St
▪ R&D in San Francisco, Harrogate UK, and Granada ES
▪ We are hiring! Meet us at Rehab!
What's wrong with this picture?
What's wrong with this picture?public with sharing class MyController {
public String theId;
public MyController(ApexPages.StandardController standardController){
theId = (String) ApexPages.currentPage().getParameters().get('id');}
public PageReference actionCheckInvoices(){
// Read the Account recordAccount accountRecord = [select Id, Name from Account where Id = :theId];// Do some processing on the Account record ... then update itupdate accountRecord;return null;
}}
Developer “A” writes an Apex Controller first
Developer “B” writes an Apex Batch job later.
public with sharing class MyBatchJob implements Database.Batchable<SObject> {
public void execute(Database.batchableContext info, List<Account> accounts){
for(Account account : accounts){
MyController myController = new MyController(new ApexPages.StandardController(account));myController.actionCheckInvoices();
}}
public Database.QueryLocator start(Database.BatchableContext info) { ... }
public void finish(Database.batchableContext info) { ... } }
So what was wrong with that picture?
Developer “A”
Developer “B”
MyControllerMyController IssueUse of ApexPages.currentPage() Unnecessary and fragile, utilize instead
stdController.getId() methodError handling No try/catch error handling on controller
method
MyBatchJob IssueUse of ApexPages.currentPage() Is not available in a Batch Apex context, the constructor
code will give an exception.SOQL Query and DML Governors Calling the controller method in a loop will cause a SOQL
query and DML governor issues.Error Handling No try/catch error handling in the the execute methodSeparation of Concerns Developer A did not originally develop the controller logic
expecting or anticipating Developer B’s would in the future try to reuse it from a Batch Context as well.
They did not consider correct Separation of Concerns…
Pattern ChecklistSeparation of Concerns ☐
Service Layer ☐
Domain Layer ☐
Selector Layer ☐
So what is “Separation of Concerns” then?
“The goal is to design systems so that functions can be optimized independently of other functions, so that failure of one function does not cause other functions to fail, and in general to make it easier to understand, design and manage complex interdependent systems”Wikipedia, “Separation of Concerns”
So what is “DRY” then?
Don’t Repeat Yourself“Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.”Wikipedia, “Don’t repeat yourself (DRY)”
Design Patterns for SOC & Force.com Best PracticeService LayerDomain Layer
▪ Yet another Wrapper / Trigger pattern!
Selector LayerReference Martin Fowler
▪ http://martinfowler.com/eaaCatalog/▪ Author of “Patterns of Enterprise
Application Architecture”
Reference ▪ http://wiki.developerforce.com/page/Apex_Enterprise_Patterns_-_Separation_of_Concerns
Demo! “takeaway” a Sample Force.com Application!
GitHub: financialforcedev/fflib-apex-common-samplecode
Sample Application, what’s on the menu?
Platform Feature Patterns UsedCustom Buttons Building UI logic and calling Service Layer code
from ControllersBatch Apex Reusing Service and Selector Layer code from
with a Batch contextIntegration API Exposing an Integration API via Service Layer
using Apex and RESTApex Triggers Factoring your Apex Trigger logic via the Domain
Layer (wrappers)VisualForce Remoting Exposing Service Layer code to HTML5 /
JavaScript libraries such as JQuery
GitHub: financialforcedev/fflib-apex-common-samplecode
Pattern ChecklistSeparation of Concerns ☑
Service Layer ☐
Domain Layer ☐
Selector Layer ☐
Introducing the Service Layer
Introducing the Service LayerNaming Convention
▪ Suffix with ‘Service’, e.g. OpportunitiesService▪ Methods named by purpose not usage, e.g. applyDiscounts
Introducing the Service LayerClear Code Factoring
▪ Encapsulates Processes / Tasks▪ Caller Context Agnostic
Introducing the Service LayerDefined Responsibilities
▪ Supports Bulkifcation▪ Transaction management
Developing and calling a Service Layer
Service Contract
public with sharing class AccountService{
public static void checkOutstandingInvoices(Set<Id> accountIds){
// Read the Account recordsList<Account> accountRecords = [select Id, Name from Account where Id in :accountIds];// Do some processing on the Account and Invoice records ... then update them.update accountRecords;
}}
AccountService.cls
Developer “A” follows Service Layer pattern.
public PageReference actionCheckInvoices(){ try { // Process the Account record AccountService.checkOutstandingInvoices(new Set<Id> { theId }); } catch (Exception e) { ApexPage.addMessages(e); } return null;}
MyController.cls
Developer “A” writes Controller code to consume the Service.
public void execute(Database.batchableContext info, List<Account> accounts){ try {
// Process Account recordsSet<Id> accountIds = new Map<Id, Account>(accounts).keySet();AccountService.checkOutstandingInvoices(accountIds);
} catch (Exception e) { emailError(e); }}
MyBatch.cls
Developer “B” then reuses the Developer “A” code safely.
Code Walkthrough : Sample ServicesManaging DML and Transactions
▪ Unit of Work Pattern
Classes
OpportunitiesService.cls
Code Walkthrough : Custom ButtonsCustom Buttons
▪ Detail and List View▪ Calling Visualforce Controller Code
Visualforce Controllers and Pages▪ Error Handling▪ Interacts with Service Layer
• Utilize bulkified methods • Assume transaction containment• Catch exceptions and display them on the page
Classes and Pages
OpportunityApplyDiscountController.cls• opportunityapplydiscount.page• opportunityapplydiscounts.pageOpportunityCreateInvoiceController.cls• opportunitycreateinvoice.page• opportunitycreateinvoices.page
Code Walkthrough : Batch ApexClasses
CreatesInvoicesJob.cls
▪ Error Handling▪ Interacts with Service Layer
• Utilize bulkified methods • Assume transaction containment• Catch exceptions and logs them for later notificaiton
Code Walkthrough : Exposing an Integration APIClasses
OpportunitiesResource.clsOpportunitiesService.cls
▪ Error Handling• Pass business logic exceptions to caller to handle• Assume transaction containment
▪ Exposing the API• To Apex Developers > Mark Service class and methods as global!
– Package to apply Apex versioning of the API
• To Web / Mobile Developers > Create RESTful API around Service layer
Code Walkthrough : Visualforce RemotingAn “Opportunities Discount Console”
▪ Developer uses a Rich HTML5 Client Library, such as JQuery• Is not using traditional Visualforce markup or action functions on the controller
▪ Utilizing static “remote” methods on the controller (stateless controller)• Able to consume the Service layer functions also!• Assumes transactional integrity• Assumes the caller (JavaScript client) to handle exceptions
Classes
OpportunityConsoleController.cls
Pattern ChecklistSeparation of Concerns ☑
Service Layer ☑
Domain Layer ☐
Selector Layer ☐
Introducing the Domain Layer
Introducing the Domain LayerNaming Convention
▪ Name uses plural name of object, e.g. Opportunities
Introducing the Domain LayerClear Code Factoring
▪ Encapsulates Validation / Defaulting of Fields
▪ Wraps Apex Trigger Logic in Apex Class (Trigger/Wrapper Pattern)
Introducing the Domain LayerDefined Responsibilities
▪ Enforces Bulkifcation for logic▪ Platform security best practice
(honors Users profile)▪ Encapsulates ALL logic / behavior
for each object• e.g. onValidate, onBeforeInsert and
applyDiscount
Introducing the Domain Layer : Apex Trigger Flow
Code Walkthrough : Domain Layer : Apex TriggersWhat no code?!? ☺ Triggers
OpportunitiesTrigger.triggerOpportunityLineItemsTrigger.trigger
Code Walkthrough : Domain Layer : Domain ClassesBulkified Wrappers
▪ Base class fflib_SObjectDomain▪ Apex Trigger Callers▪ Support for DML Free Testing ▪ Able to apply Object Orientated Programming
Apex Classes
Opportunities.clsOpportunityLineItems.clsAccounts.cls
Code Walkthrough : Domain Layer : Service CallersApex Service Callers
▪ Create Domain Instances▪ Bulkified Calls
Apex Classes
OpportunitiesService.cls
Code Walkthrough : Domain : Extends vs Interfaces
Extending Apex Domain Classes▪ Extend or adjust existing behavior of classes of a similar nature
• Base class Chargeable ensures cost is recalculated on insert and update• DeveloperWorkItems Domain Class extends to provide its own calc logic
Implementing Apex Domain Interfaces▪ Good for applying behavior to different types of classes
• Interface InvoiceService.ISupportInvoicing• Implemented by Opportunities Domain Class
Code Walkthrough : Domain Class ExtensionChargeable Base Class
▪ Apply to Custom Objects recording Work▪ Require hours and cost calculations▪ Performs recalculation on insert and update
Pattern ChecklistSeparation of Concerns ☑
Service Layer ☑
Domain Layer ☑
Selector Layer ☐
Introducing the Selector Layer
Introducing the Selector LayerNaming Convention
▪ Plural object name suffixed by Selector• e.g. OpportunitiesSelector
Introducing the Selector LayerClear Code Factoring
▪ Encapsulates Query Logic
Introducing the Selector LayerDefined Responsibilities
▪ Consistency over queried fields▪ Platform security best practice▪ Encapsulates ALL query logic
Code Walkthrough : Selector LayerEncapsulate Query Fields and Logic
▪ Base class fflib_SObjectSelector▪ Defines Common Fields▪ Default SOQL Helpers, FieldSet Support
Apex Classes
OpportunitiesSelector.clsOpportunityLineItemsSelector.clsProductsSelector.clsPricebooksSelector.clsPricebookEntriesSelector.cls
Code Walkthrough : Selector Layer : CallersService Layer Logic : OpportunitiesSelector.selectByIdWithProducts
Domain Layer Logic : AccountsSelector.selectByOpportunity
Apex ClassOpportunitiesService.cls
Apex ClassOpportunities.cls
Code Walkthrough : Selector Layer : CallersBatch Apex : OpportunitiesSelector.queryLocatorReadyToInvoice
Apex ClassCreatesInvoicesJob.cls
Pattern ChecklistSeparation of Concerns ☑
Service Layer ☑
Domain Layer ☑
Selector Layer ☑
Summary
Summary
When is SOC / DRY appropriate (a rough guide)?Solution / Code Base Size
Developers Requirements Scope Number of Client Types and Interactions
SOC/DRY Appropriate?
Small 1 to 2 • Well known and unlikely to change
• One off solutions• Limited number of objects
• Standard UI• Simple VF / Triggers• No Batch Mode• No API• No Mobile
Typically not
Small to Medium 1 to 6 • Well known but may need to evolve rapidly
• Growing number objects and processes interacting
• Product deliverable or larger duration projects
• Standard UI• Advanced VF / JQuery• Batch Mode• API (on roadmap)• Mobile (on roadmap)
Worth considering
Large > 6 • Scope driven by multiple customers and user types
• Large number of objects• Generic product or solution
aimed at Mid to Enterprise market with Customer or Partner Integrations.
• Growing development team!
• Standard UI • Advanced VF / JQuery• Batch Mode• Developer / Partner API • Mobile Clients• New Platform Feature
Ready, Chatter Actions!
Definite benifits
Other Design Patterns Helping with SOC/DRY
Alternative Domain Layer Patterns▪ ‘Apex Trigger Pattern’ (Tony Scott)
• http://developer.force.com/cookbook/recipe/trigger-pattern-for-tidy-streamlined-bulkified-triggers
▪ ‘Salesforce Apex Wrapper Class’ (Mike Leach)• http://www.embracingthecloud.com/2013/09/06/SalesforceApexWrapperClass.aspx
▪ ‘Trigger Architecture Framework’ (Hari Krishnan)• http://krishhari.wordpress.com/category/technology/salesforce/apex-triggers/
Andrew Fawcett
CTO,@andyinthecloud