Book Image

Salesforce Platform Enterprise Architecture - Fourth Edition

By : Andrew Fawcett
Book Image

Salesforce Platform Enterprise Architecture - Fourth Edition

By: Andrew Fawcett

Overview of this book

Salesforce makes architecting enterprise grade applications easy and secure – but you'll need guidance to leverage its full capabilities and deliver top-notch products for your customers. This fourth edition brings practical guidance to the table, taking you on a journey through building and shipping enterprise-grade apps. This guide will teach you advanced application architectural design patterns such as separation of concerns, unit testing, and dependency injection. You'll also get to grips with Apex and fflib, create scalable services with Java, Node.js, and other languages using Salesforce Functions and Heroku, and find new ways to test Lightning UIs. These key topics, alongside a new chapter on exploring asynchronous processing features, are unique to this edition. You'll also benefit from an extensive case study based on how the Salesforce Platform delivers solutions. By the end of this Salesforce book, whether you are looking to publish the next amazing application on AppExchange or build packaged applications for your organization, you will be prepared with the latest innovations on the platform.

Related Content you might be interested in

Current Title:

Small book image
Salesforce Platform Enterprise Architecture - Fourth Edition
Andrew Fawcett
Mar, 2023 | 712 pages
Small book image
Mastering Apex Programming
Paul Battisson
Nov, 2023 | 394 pages
Small book image
Mastering Apex Programming.
Paul Battisson
Nov, 2020 | 368 pages
Small book image
Learning Salesforce Lightning Application Development
Mohit Shrivatsava
Jul, 2018 | 458 pages
Table of Contents (23 chapters)
Preface
Preface
Who this book is for
What this book covers
To get the most out of this book
Get in touch
1
Part I: Key Concepts for Application Development
Part I: Key Concepts for Application Development
Free Chapter
2
Building and Publishing Your Application
Building and Publishing Your Application
Introducing Salesforce DX
Required organizations
Introducing the book’s sample application
Package types and benefits
Creating your first managed package
Package platform feature dependencies
Supporting package upgradability
Becoming a Salesforce partner and the benefits of doing so
Introduction to AppExchange and listings
Installing and testing your package
Understanding how to license your package
Providing support
Customer metrics
Trialforce and Test Drive
Distributing Salesforce Connected Apps
Summary
3
Leveraging Platform Features
Leveraging Platform Features
Packaging and upgradable components
Understanding Custom Field features
Understanding the available security features
Platform APIs
Localization and translation
Building customizable user interfaces
Email customization with email templates
Flow
Social features and mobile
Creating and testing a new package version
Summary
4
Application Storage
Application Storage
Mapping out end user storage requirements
Understanding the different storage types
Record identification, uniqueness, and auto-numbering
Record relationships
Reusing existing Standard Objects
Importing and exporting data
Options for replicating data
External data sources
Creating a new FormulaForce package version
Summary
5
Apex Execution and Separation of Concerns
Apex Execution and Separation of Concerns
Execution contexts
Apex governors and namespaces
Where is Apex used?
Separation of concerns
Patterns of Enterprise Application Architecture
Unit testing versus system testing
Packaging the code
Summary
6
Part II: Backend Logic Patterns
Part II: Backend Logic Patterns
7
Application Service Layer
Application Service Layer
Introducing the Service layer pattern
Implementation of design guidelines
Handling DML with the Unit of Work pattern
Services calling services
Contract-driven development
Testing the Service layer
Calling the Service layer
Summary
8
Application Domain Layer
Application Domain Layer
Introducing the Domain layer pattern
Implementing design guidelines
Domain class template
Implementing Domain trigger logic
Implementing custom Domain logic
Object-oriented programming
Testing the Domain layer
Calling the Domain layer
Updating the FormulaForce package
Summary
9
Application Selector Layer
Application Selector Layer
Introducing the Selector layer pattern
Implementing design guidelines
The Selector class template
Implementing the standard query logic
Implementing custom query logic
Introducing the Selector factory
Updating the FormulaForce package
Summary
10
Additional Languages, Compute, and Data Services
Additional Languages, Compute, and Data Services
FormulaForce Web and API requirements
Expanding FormulaForce automation experiences
Solution overview
Building web experiences with Node.js and Heroku
Building OpenAPI-enabled APIs with Heroku
Extending automation with Java and Salesforce Functions
Wrapping Functions and Heroku APIs in Apex Service classes
Summary
11
Part III: Developing the Frontend
Part III: Developing the Frontend
12
Building User Interfaces
Building User Interfaces
What devices should you target?
Leveraging standard and custom UIs
Leveraging the Salesforce standard UIs and tools
Generating downloadable content
Generating printable content
Client-server communication
Managing limits
Object and field level security
Managing performance and response times
Considerations for using third-party JavaScript libraries
Custom Publisher Actions
Creating websites and communities
Mobile applications
Custom report UIs and the Analytics API
Updating the FormulaForce package
Summary
13
User Interfaces and the Lightning Component Framework
User Interfaces and the Lightning Component Framework
Building a basic standalone Lightning page
Lightning architecture
FormulaForce Lightning Components
Making components customizable
Integrating with Lightning Experience
Integrating with Lightning Flow
Integrating with Lightning Communities
Exposing components with Lightning Out
Updating the FormulaForce package
Summary
14
Part IV: Extending, Scaling, and Testing an Application
Part IV: Extending, Scaling, and Testing an Application
15
Providing Integration and Extensibility
Providing Integration and Extensibility
Reviewing your integration and extensibility needs
Standard platform APIs for integration
Application integration APIs
Extending application logic with platform extensibility features
Extending application logic with Apex interfaces
Extending application logic with Flow
The MuleSoft platform
Summary
16
Asynchronous Processing and Big Data Volumes
Asynchronous Processing and Big Data Volumes
Creating an object for race data
Indexes, being selective, and query optimization
Handling billions of records with Big Objects
Asynchronous processing
Summary
17
Unit Testing
Unit Testing
Comparing unit testing and integration testing
Introduction to unit testing with Apex
Writing unit tests with the Apex Stub API
ApexMocks and Apex Enterprise Patterns
Unit testing with Lightning Web Components
Unit testing with Salesforce Functions
Summary
18
Source Control and Continuous Integration
Source Control and Continuous Integration
Development workflow and infrastructure
Developing with source control
Hooking up continuous integration
Releasing from source control
Automated regression testing
Alternative Salesforce-oriented CI/CD servers
Summary
19
Integrating with External Services
Integrating with External Services
Understanding inbound and outbound integrations
Managing inbound integrations
Understanding options for outbound integrations
Summary
20
Adding AI with Einstein
Adding AI with Einstein
Understanding Salesforce Einstein services and products
Understanding Einstein Prediction Builder
Understanding Einstein Discovery
Understanding Einstein Platform Services
Summary
21
Other Books You May Enjoy
Other Books You May Enjoy
22
Index
Index

Object-oriented programming

One of the big advantages of using Apex classes is the ability to leverage the power of object-oriented programming (OOP). OOP allows you to observe commonalities in data or behavior across your objects to share code or apply common processing across different objects.

An example of such a commonality in the Formula 1 world is rules; every aspect of the sport has a set of rules and regulations to comply with, such as drivers owning an FIA Super License, the weight of the car they drive should be at least above a defined minimum, and ensuring that a team has not exceeded the maximum distance while testing their cars. Such compliances are checked regularly, both before and after a race.

Creating a compliance application framework

In our FormulaForce application, we want to create a compliance framework that will check these regulations across the different objects while also providing a consistent user interface experience for the end user to...

Previous Section
End of Section 7
Next Section