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