Book Image

Apex Design Patterns

By : Anshul Verma, Jitendra Zaa
Book Image

Apex Design Patterns

By: Anshul Verma, Jitendra Zaa

Overview of this book

Apex is an on-demand programming language providing a complete set of features for building business applications – including data models and objects to manage data. Apex being a proprietor programming language from Salesforce to be worked with multi tenant environment is a lot different than traditional OOPs languages like Java and C#. It acts as a workflow engine for managing collaboration of the data between users, a user interface model to handle forms and other interactions, and a SOAP API for programmatic access and integration. Apex Design Patterns gives you an insight to several problematic situations that can arise while developing on Force.com platform and the usage of Design patterns to solve them. Packed with real life examples, it gives you a walkthrough from learning design patterns that Apex can offer us, to implementing the appropriate ones in your own application. Furthermore, we learn about the creational patterns that deal with object creation mechanism and structural patterns that helps to identify the relationship between entities. Also, the behavioural and concurrency patterns are put forward explaining the communication between objects and multi-threaded programming paradigm respectively. We later on, deal with the issues regarding structuring of classes, instantiating or how to give a dynamic behaviour at a runtime, with the help of anti-patterns. We learn the basic OOPs principal in polymorphic and modular way to enhance its capability. Also, best practices of writing Apex code are explained to differentiate between the implementation of appropriate patterns. This book will also explain some unique patterns that could be applied to get around governor limits. By the end of this book, you will be a maestro in developing your applications on Force.com for Salesforce

Related Content you might be interested in

Current Title:

Small book image
Apex Design Patterns
Anshul Verma | Jitendra Zaa
Apr, 2016 | 256 pages
No titles found
Table of Contents (12 chapters)
Apex Design Patterns
Apex Design Patterns
Credits
Credits
About the Authors
About the Authors
About the Reviewer
About the Reviewer
www.PacktPub.com
www.PacktPub.com
Preface
Preface
Free Chapter
1
An Introduction to Apex Design Pattern
An Introduction to Apex Design Pattern
Innovation
Design patterns and learning
Object-Oriented Programming (OOP)
OOPs in play
An interface
An abstract class
Advantages of design patterns
Design patterns and Apex
Gang of Four (GoF)
The SOLID principle
Summary
2
Creational Patterns
Creational Patterns
Factory method pattern
Abstract factory pattern
The singleton pattern
The builder pattern
The prototype pattern
Summary
3
Structural Patterns
Structural Patterns
The facade pattern
The adapter pattern
The bridge pattern
The composite pattern
The decorator pattern
The flyweight pattern
Summary
4
Behavioral Patterns
Behavioral Patterns
The chain of responsibility pattern
The command pattern
The interpreter pattern
The iterator pattern
The visitor pattern
The memento pattern
The observer pattern
The state pattern 
The strategy pattern
Summary
5
Handling Concurrency in Apex
Handling Concurrency in Apex
Understanding concurrency issues
Reproducing concurrency problems in Apex
The active object pattern
Summary
6
Anti-patterns and Best Practices
Anti-patterns and Best Practices
Over usage of formula fields
Functional decomposition
Ignoring the equals() and hashcode() methods while performing object comparison
Circular dependencies
The ignoring toString() method
Avoid the God class
Error hiding
Hard-coding
Magic strings and numbers
Inheritance hell
SOQL inside a loop
DML inside a loop
Summary

Design patterns and Apex

Apex is a proprietary programming language for Salesforce and, therefore, is different from other programming languages, such as Java, C#, and C. Even though the syntax of Apex resembles to Java and C#; however, programming on the Force.com platform is quite different. We will discuss many standard design patterns in the next section of this chapter; however, every pattern may not be suitable for Apex.

A few important differences between Apex and other Object-Oriented Programming (OOP) languages are as follows:

  • Apex runs on the multi-tenant platform; therefore, in order to make sure that other tenants are not impacted, Salesforce enforces various limits. As developers, we need to make sure that our code does not breach any governor limits.
  • Other programming languages do not mandate code coverage for deployments. However, in the case of Salesforce, the Apex code needs to have a minimum code coverage of 75% (the entire code in the environment) for production deployments.
  • Static variables in Java persist until the Java Virtual Machine (JVM) execution lifespan, which may last from days to months or even years. In the case of Apex, a static variable lasts for the duration of an individual user request execution only (until the time the user request is being processed on a server).

Note

Governor limits are Salesforce's way to force programmers to write efficient code. As Apex runs in a multitenant environment, a strict enforcement of all limits becomes a necessity for the Apex runtime engine so that no code monopolizes the shared resources. If because of a bad design or nonrecommended architecture, any code does not comply with governor limits, the Apex runtime throws a runtime exception, which cannot be handled within Apex. Apex also exposes many limit methods to check the limit consumption. Read more about this in detail at  https://developer.salesforce.com/docs/atlas.en-us.apexcode.meta/apexcode/apex_gov_limits.htm.

Previous Section
End of Section 9
Next Section