DEX450

课程介绍

今天我们来聊聊Salesforce中的两种主要开发方式：Apex和可视化工具SF-DEX 450-SG。 首先，Apex是Salesforce的一种编程语言，它类似于Java，专门用于在Salesforce平台上构建复杂的业务逻辑和数据处理功能。你可以把Apex想象成一种强大的工具，能够让你在Salesforce中编写自定义的代码，实现那些标准功能无法满足的需求。比如，你可以用Apex来创建复杂的触发器、批处理任务，或者与外部系统进行集成。 而SF-DEX 450-SG则是一种可视化开发工具。它允许你通过拖拽组件、配置参数的方式来构建应用，而不需要编写大量的代码。这种方式非常适合那些没有编程背景，但又需要快速构建应用的业务用户。你可以通过SF-DEX 450-SG来设计用户界面、定义数据流程，甚至创建一些简单的业务逻辑。 总结一下，Apex适合那些需要高度定制化和复杂逻辑的场景，而SF-DEX 450-SG则更适合快速开发和业务用户使用。两者各有优势，具体选择哪种方式，取决于你的项目需求和团队的技术能力。 希望这个解释能帮助你更好地理解Apex和SF-DEX 450-SG的区别和用途。如果你有任何问题，随时问我！

课程章节

本课程共有 461 个章节

• 1

  Programmatic Development Using Apex and Visualforce

  第 1 页

  今天我们来聊聊Salesforce中的两种主要开发方式：Apex和可视化工具SF-DEX 450-SG。 首先，Apex是Salesforce的一种编程语言，它类似于Java，专门用于在Salesforce平台上构建复杂的业务逻辑和数据处理功能。你可以把Apex想象成一种强大的工具，能够让你在Salesforce中编写自定义的代码，实现那些标准功能无法满足的需求。比如，你可以用Apex来创建复杂的触发器、批处理任务，或者与外部系统进行集成。 而SF-DEX 450-SG则是一种可视化开发工具。它允许你通过拖拽组件、配置参数的方式来构建应用，而不需要编写大量的代码。这种方式非常适合那些没有编程背景，但又需要快速构建应用的业务用户。你可以通过SF-DEX 450-SG来设计用户界面、定义数据流程，甚至创建一些简单的业务逻辑。 总结一下，Apex适合那些需要高度定制化和复杂逻辑的场景，而SF-DEX 450-SG则更适合快速开发和业务用户使用。两者各有优势，具体选择哪种方式，取决于你的项目需求和团队的技术能力。 希望这个解释能帮助你更好地理解Apex和SF-DEX 450-SG的区别和用途。如果你有任何问题，随时问我！

  ▶ 播放视频 查看详情
• 2

  a0eIh000000m032

  第 2 页

  同学们，今天我们来聊聊Salesforce中的一个常见问题——翻译失败。这个问题通常出现在我们尝试将某些内容从一种语言翻译成另一种语言时。 想象一下，你正在使用Salesforce的某个功能，比如发送邮件或者创建记录，突然系统提示你“翻译失败”。这就像是你请了一个翻译官，但他突然告诉你：“对不起，我不知道怎么翻译这句话。” 那么，为什么会出现这种情况呢？通常有几个原因： 1. ，源文本缺失，：就像你看到的错误信息里提到的“SourceText: is required”，意思是系统需要你提供要翻译的原始文本。如果没有这个文本，翻译官就不知道要翻译什么。 2. ，语言设置问题，：有时候，Salesforce的语言设置可能没有正确配置，导致系统不知道应该用哪种语言来翻译。 3. ，翻译服务问题，：Salesforce可能依赖于外部的翻译服务，如果这个服务出现了问题，比如网络连接不稳定或者服务本身有故障，也会导致翻译失败。 那么，遇到这种情况我们该怎么办呢？ 1. ，检查源文本，：首先，确保你提供了要翻译的文本。如果没有，赶紧补上。 2. ，检查语言设置，：进入Salesforce的设置，看看语言配置是否正确。如果有问题，及时调整。 3. ，联系支持，：如果以上方法都试过了还是不行，那就联系Salesforce的支持团队吧。他们会有更专业的解决方案。 总之，翻译失败虽然让人头疼，但只要我们耐心排查，问题总能解决的。希望今天的讲解对你们有所帮助！

  ▶ 播放视频 查看详情
• 3

  a0eIh000000m033

  第 3 页

  同学们，今天我们来聊聊Salesforce中的一个小问题。有时候，我们在使用Salesforce时，可能会遇到一些错误提示。比如，刚才提到的这个错误：“翻译失败: [TencentCloudSDKException] code:InvalidParameter message:SourceText: is required requestId:98332c47-3d06-4acb-b3b4-8c69cd4e0be8”。 这个错误的意思是，系统在尝试翻译某些内容时，发现缺少了一个必要的参数，叫做“SourceText”。简单来说，就是系统需要你提供一些文本内容来进行翻译，但你没有提供，所以它就报错了。 那么，怎么解决这个问题呢？其实很简单，你只需要确保在调用翻译功能时，提供了需要翻译的文本内容就可以了。比如，如果你在使用某个API或者插件来进行翻译，检查一下你的代码或者设置，看看是不是漏掉了这个“SourceText”参数。 总结一下，遇到这个错误时，不要慌，先检查一下你的输入内容，确保所有必要的参数都填写完整了。这样，问题就能迎刃而解了。 好了，今天的分享就到这里，希望对你们有所帮助。如果有任何问题，随时问我哦！

  ▶ 播放视频 查看详情
• 4

  a0eIh000000m034

  第 4 页

  同学们，今天我们来聊聊Salesforce中的一个小问题。有时候，我们在使用Salesforce的时候，可能会遇到一些错误提示，比如“翻译失败”。这个错误通常是因为我们在进行某些操作时，缺少了必要的参数。 举个例子，假设我们正在尝试使用一个叫做“TencentCloudSDK”的工具，这个工具可以帮助我们做一些云服务相关的操作。但是，当我们尝试使用它的时候，系统却提示我们“翻译失败”，并且给出了一个错误代码“InvalidParameter”。这个错误代码的意思是“无效的参数”，也就是说，我们提供给这个工具的信息不完整或者不正确。 具体来说，错误信息中提到的“SourceText: is required”意味着我们需要提供一个叫做“SourceText”的参数，这个参数是必须的，但我们没有提供。所以，系统就无法完成我们想要的操作。 那么，怎么解决这个问题呢？很简单，我们只需要检查一下我们的代码或者操作步骤，确保我们提供了所有必要的参数。在这个例子中，我们需要确保我们提供了“SourceText”这个参数。 总结一下，当我们在Salesforce中遇到“翻译失败”这样的错误时，首先要看错误信息，找出缺少或者错误的参数，然后补充或者修正这些参数，问题就可以解决了。 好了，今天的讲解就到这里，希望对大家有所帮助。如果有任何问题，欢迎随时提问。

  ▶ 播放视频 查看详情
• 5

  Course Agenda

  第 5 页

  大家好，欢迎来到AW Computing的Salesforce课程。今天，我们将一起探索Salesforce的世界，从基础到高级，一步步深入了解这个强大的平台。 第1课，我们将简单介绍AW Computing，让你了解我们的教学理念和目标。 第2课和第3课，我们会深入探讨如何构建和使用对象和字段。这是Salesforce的基础，掌握它们对你后续的学习至关重要。 第4课，我们将进入Apex编程的世界。Apex是Salesforce的编程语言，通过它，你可以创建复杂的业务逻辑。 第5课和第6课，我们将学习如何使用SOQL查询语言来检索数据。这是处理数据的关键技能。 第7课到第10课，我们将讨论TLR（Trigger Logic Reuse）、触发器、Apex交易的保存顺序等高级主题。这些内容将帮助你更好地理解Salesforce的内部工作机制。 第11课和第12课，我们将专注于测试。测试是确保你的代码质量和性能的重要环节。 第13课和第14课，我们将探讨设计高效Apex解决方案和触发器的策略。这些策略将帮助你在实际工作中更有效地解决问题。 第15课到第20课，我们将转向Visualforce，这是Salesforce的页面开发框架。我们将学习如何创建页面、使用控制器、以及进行有效的测试。 每一课都将为你提供实用的知识和技能，帮助你在Salesforce的世界中更加自信和熟练。让我们一起开始这段旅程吧！

  ▶ 播放视频 查看详情
• 6

  Module 4: Programming with Apex

  第 87 页

  同学们，今天我们来聊聊Salesforce中的Apex编程。Apex是Salesforce平台上的一种强大的编程语言，它类似于Java，专门用于处理业务逻辑和数据操作。 首先，Apex是一种面向对象的语言，这意味着你可以创建类、对象和方法来处理复杂的业务需求。你可以通过Apex来创建触发器、批处理作业、自定义控制器等等。 举个例子，假设你需要在每次创建新客户记录时自动发送一封欢迎邮件。你可以编写一个Apex触发器，当客户记录被插入时，触发器会自动执行，调用发送邮件的方法。 Apex还支持SOQL（Salesforce Object Query Language）和SOSL（Salesforce Object Search Language），这使得你可以轻松地查询和操作Salesforce中的数据。 总的来说，Apex是一个非常强大的工具，可以帮助你自动化业务流程，提高工作效率。希望这个简单的介绍能帮助你理解Apex编程的基础概念。如果有任何问题，随时问我！

  ▶ 播放视频 查看详情
• 7

  Understanding Apex

  第 88 页

  让我们开始今天的Apex学习之旅吧！首先，Apex是Salesforce平台上的一种编程语言，它有点像Java和C#，但也有一些独特的地方。Apex是专门为处理Salesforce的数据和业务逻辑设计的，这意味着它可以直接与Salesforce数据库交互，执行查询和更新操作。 现在，让我们谈谈Apex与其他语言的不同之处。Apex是一种强类型的语言，这意味着所有的变量都必须声明类型。此外，Apex运行在Salesforce的多租户环境中，这就要求我们在编写代码时必须考虑到Apex的交易和监管者限制。这些限制是为了确保所有用户都能公平地使用系统资源，防止某个用户或进程占用过多资源。 接下来，我们会学习如何执行简单的Apex代码。Apex支持多种数据类型，包括sObject类型，这是Salesforce中表示数据库记录的对象。我们还会学习基元数据类型，比如整数、字符串和布尔值，以及如何使用基本的控制语句，如if语句和循环。 最后，我们会通过一些例子来加深理解。记住，学习Apex的过程中，你可以随时查阅Salesforce的官方文档来获取更多信息和帮助。这样，你就可以在实践中不断进步，更好地掌握Apex编程。让我们一起开始这段学习旅程吧！

  ▶ 播放视频 查看详情
• 8

  Module Agenda - 89

  第 89 页

  同学们，今天我们来聊聊Salesforce中的Apex编程。首先，我们会从“开始使用Apex”这一部分讲起。Apex是Salesforce的一种强大的编程语言，它允许开发者创建复杂的业务逻辑和自定义功能。 接下来，我们会探讨“Apex为何与众不同”。Apex是一种面向对象的语言，它直接在Salesforce平台上运行，这意味着它可以无缝地与Salesforce的数据和用户界面集成。此外，Apex还提供了强大的数据库操作能力，使得处理大量数据变得简单高效。 然后，我们会进入“使用s对象”这一部分。在Salesforce中，s对象是数据表的基础，它们代表了数据库中的表。通过Apex，我们可以创建、读取、更新和删除这些s对象中的数据，这是构建自定义应用的关键步骤。 最后，我们会深入“模块4：使用Apex编程”。在这里，我们将学习如何编写Apex代码，包括类、触发器、测试类等。我们还会探讨如何优化代码性能，确保我们的应用既快速又可靠。 通过这些模块的学习，你们将能够掌握Apex编程的基础，并能够在Salesforce平台上构建强大的自定义应用。让我们一起开始这段学习之旅吧！

  ▶ 播放视频 查看详情
• 9

  4-1: Logging In to a Sandbox

  第 90 页

  同学们，今天我们来学习如何在Salesforce的沙盒环境中登录，并且使用开发人员控制台来执行一些简单的Apex代码。 首先，我们需要登录到Salesforce的沙盒环境。沙盒环境是一个安全的空间，我们可以在里面进行各种测试和开发，而不会影响到实际的生产环境。登录后，我们会看到一个叫做“开发人员控制台”的工具，这是我们今天要重点使用的。 开发人员控制台是一个非常强大的工具，它允许我们编写、测试和调试Apex代码。Apex是Salesforce的一种编程语言，类似于Java，专门用于在Salesforce平台上进行定制开发。 接下来，我会展示一段简单的Apex代码。这段代码的作用是创建一个新的联系人记录，并将其插入到Salesforce的数据库中。代码是这样的： ```apex 联系人 contactToAdd = new 联系人(); contactToAdd.firstName = "六月"; contactToAdd.lastName = "摩根"; 插入 contactToAdd; System.debug('contactToAdd 的 recordID 是：' + contactToAdd.id); ``` 让我们一步步来看这段代码： 1. 首先，我们创建了一个新的联系人对象，命名为`contactToAdd`。 2. 然后，我们给这个联系人的`firstName`属性赋值为“六月”，`lastName`属性赋值为“摩根”。 3. 接着，我们使用`插入`语句将这个联系人记录插入到Salesforce的数据库中。 4. 最后，我们使用`System.debug`语句来输出这个新创建的联系人记录的ID。这个ID是Salesforce自动生成的唯一标识符，用于标识这条记录。 在下一张幻灯片中，我们会更详细地讨论这段代码的作用和每个部分的具体功能。现在，你们可以先尝试在开发人员控制台中执行这段代码，看看会发生什么。 记住，沙盒环境是安全的，所以不用担心会影响到实际的数据。大胆尝试，遇到问题随时提问！

  ▶ 播放视频 查看详情
• 10

  4-2: See Apex in Action

  第 91 页

  同学们，今天我们来学习如何在Salesforce中使用开发人员控制台执行一些简单的Apex代码。首先，我们会打开开发人员控制台，这是一个非常强大的工具，可以帮助我们编写和测试代码。 接下来，我会展示一段简单的Apex代码。这段代码的作用是创建一个新的联系人记录。我们首先定义了一个名为`contactToAdd`的联系人对象，然后给它设置了名字和姓氏，分别是“六月”和“摩根”。之后，我们使用`insert`语句将这个联系人记录保存到数据库中。最后，我们使用`System.debug`语句来输出这个新创建的联系人记录的ID，这样我们就可以在日志中看到它。 在下一张幻灯片中，我们会详细讨论这段代码的每一部分，以及它们是如何协同工作的。这样，你们就能更好地理解Apex代码的基本结构和功能了。 现在，让我们打开开发人员控制台，一起动手试试这段代码吧！

  ▶ 播放视频 查看详情
• 11

  Examining the Code

  第 92 页

  让我们来聊聊这段Apex代码的几个关键点。首先，这段代码的目的是让你开始熟悉Apex，特别是如果你有Java或C#的背景，你会发现Apex的语法和结构非常相似。 1. ，代码执行的结果，：当你运行这段代码时，它会在Salesforce的数据库中插入一条新的联系人记录。具体来说，代码做了以下几件事： - 创建了一个新的联系人对象。 - 设置了联系人的名字和姓氏。 - 使用DML（数据操作语言）语句将这个对象插入到数据库中。 - 在日志中插入了一条调试信息，这条信息包含了新插入记录的ID。 2. ，代码中熟悉的部分，：如果你之前用过Java或C#，你会发现很多语法都很相似： - 类的构造（第1行）。 - 对象字段的设置（第2、3行）。 - 使用系统方法输出调试信息（第5行）。 - 字符串的连接操作（第5行）。 - 使用分号结束语句（所有行）。 - 使用点符号访问对象的字段（第2、3、5行）。 3. ，Apex与数据库的交互，：代码中与数据库交互的部分是`insert`语句。这个语句直接将联系人对象插入到数据库中，并且会自动为这个对象分配一个唯一的ID。你不需要手动创建Contact类，因为Salesforce已经为你提供了这个类，并且你可以直接使用在UI中定义的字段。 通过这些简单的步骤，你已经开始了Apex的学习之旅。随着我们深入探讨，你会发现Apex的更多强大功能。希望这个解释能帮助你更好地理解这段代码！

  ▶ 播放视频 查看详情
• 12

  What is Apex?

  第 93 页

  让我们来聊聊Apex吧。想象一下，Apex就像是Salesforce世界里的一个超级英雄，它拥有强大的力量，可以帮助我们在这个平台上做很多酷炫的事情。 首先，Apex是一种面向对象的编程语言。这意味着它像是一个聪明的建筑师，能够设计和构建复杂的结构。在Salesforce中，这些结构就是我们的应用程序和功能。 Apex是Force.com平台的一部分，这个平台就像是Salesforce的家。Apex和Salesforce的组织以及数据是紧紧绑在一起的。你可以通过Apex发出各种命令，使用各种库和对象来操作数据。 最棒的是，Apex是基于云的，这意味着你不需要在电脑上安装任何东西。只要你有网络连接，你就可以随时随地使用Apex来编写代码。 Apex从2007年就开始存在了，它一直在帮助我们更好地使用Salesforce。它是Lightning平台的专有语言，也就是说，它是专门为Salesforce设计的，不能在其他系统上运行。 Apex之所以这么特别，是因为它和Salesforce平台紧密结合。当你在Salesforce中创建一个对象时，Apex可以自动访问和操作这些对象中的数据。你还可以配置Salesforce的工具来调用Apex代码，这样你就可以创建更强大的工作流和自动化流程。 最后，Apex还支持多租户环境。这意味着即使有很多人同时在Salesforce上使用Apex，每个人的代码都不会互相干扰，系统依然可以稳定运行。当然，这需要我们遵循推荐的设计模式来开发代码。 所以，Apex就像是Salesforce中的一把瑞士军刀，功能强大，用途广泛。掌握了Apex，你就可以在Salesforce的世界里大展拳脚了！

  ▶ 播放视频 查看详情
• 13

  Apex Classes and Triggers

  第 94 页

  今天我们来聊聊Apex课程和触发器的一些基础概念。首先，我们要明白，Apex是一种编程语言，专门用于在Salesforce平台上编写业务逻辑。你可以把它想象成一种工具，帮助我们自动化处理Salesforce中的数据。 首先，我们来说说“类”。在Apex中，类就像是一个容器，用来存放代码。你可以把它想象成一个盒子，里面装满了各种工具和方法。这些工具和方法可以帮助我们完成特定的任务。类在Apex中非常类似于Java或C#中的类，如果你之前学过这些语言，理解起来会更容易。 接下来，我们谈谈“触发器”。触发器是一种特殊的Apex代码，它会在某些特定的事件发生时自动执行。比如说，当你在Salesforce中创建、更新或删除一条记录时，触发器就会被触发。触发器总是与某个特定的对象关联，比如“客户”对象或“订单”对象。当这个对象的数据发生变化时，触发器就会自动运行，执行你预先写好的代码。 总结一下，类是一个存放代码的容器，而触发器则是在特定事件发生时自动执行的代码。通过这两者，我们可以在Salesforce中实现复杂的业务逻辑和自动化流程。 希望这个解释能帮助你更好地理解Apex中的类和触发器。如果你有任何问题，随时问我！

  ▶ 播放视频 查看详情
• 14

  4-3: Create and Use an Apex Class

  第 95 页

  让我们来聊聊如何在Salesforce中创建和使用Apex类。今天我们要学习的是如何将代码移动到类中，创建类，以及如何调用类中的方法。我们还会提到一个叫做“静态上升点”的概念。 首先，想象一下，Apex类就像是一个工具箱，里面装满了各种工具（也就是方法）。我们可以创建这个工具箱，然后在需要的时候，从里面拿出工具来使用。 现在，我们来看一个例子。假设我们想要创建一个类，这个类可以帮助我们添加联系人到Salesforce中。我们可以创建一个叫做`ContactManager`的类。在这个类里面，我们会定义一个方法，叫做`addContact`。这个方法需要两个参数：联系人的姓和名。它会创建一个新的联系人记录，并将其插入到数据库中，最后返回这个新联系人的ID。 下面是这个类的代码： ```apex public class ContactManager { public static Id addContact(String lastNameToInsert, String firstNameToInsert) { Contact contactToAdd = new Contact( FirstName = firstNameToInsert, LastName = lastNameToInsert ); insert contactToAdd; return contactToAdd.Id; } } ``` 在这个代码中，`addContact`方法被定义为`static`，这意味着我们可以直接通过类名来调用这个方法，而不需要先创建类的实例。 接下来，我们来看看如何调用这个类中的方法。假设我们想要添加一个姓为“Guardman”，名为“Areil”的联系人，我们可以这样做： ```apex Id contactId = ContactManager.addContact('Guardman', 'Areil'); System.debug('contactToAdd record ID is: ' + contactId); ``` 在这段代码中，我们调用了`ContactManager`类中的`addContact`方法，并传入了两个参数：'Guardman'和'Areil'。这个方法会返回新创建的联系人的ID，我们将其存储在`contactId`变量中，并使用`System.debug`来打印这个ID。 这就是今天的内容。我们学习了如何创建Apex类，如何在类中定义方法，以及如何调用这些方法。希望你们能够理解并尝试自己动手编写代码。如果有任何问题，随时问我！

  ▶ 播放视频 查看详情
• 15

  Reviewing the Code

  第 96 页

  让我们来回顾一下这些要点，我会尽量用简单易懂的方式来解释。 首先，我们提到了，具有命名参数的构造函数，。这是什么意思呢？想象一下，你在建房子，你可以选择先建墙，再装窗户，或者反过来。在Apex中，构造函数就像建房子的步骤，而命名参数就是你可以指定先做哪一步。这样，你可以更灵活地创建对象。 接下来是，DML，，也就是数据操作语言。在Salesforce中，DML是用来操作数据的，比如插入、更新或删除记录。你可以把它想象成你在数据库中进行的一系列操作，就像你在Excel表格中添加或删除行一样。 然后我们提到了，不区分大小写，。这意味着在Apex中，变量名、方法名等是不区分大小写的。比如，`myVariable`和`myvariable`在Apex中是一样的。这就像你在写名字时，不管你是用大写还是小写，名字的意思不会变。 现在，让我们来看看教学要点。 1. ，API版本的用途，：每次Salesforce发布新版本时，都会引入一个新的API版本。当你保存代码时，你会选择一个API版本。这样做的目的是为了保证你的代码在新版本发布后仍然能够正常运行，不会因为新版本的变化而出错。你可以把它想象成你在写一本书，每次出新版时，你都会保留旧版的内容，这样读者可以继续阅读旧版，而不会因为新版的变化而感到困惑。 2. ，代码结构，：在这段代码中，我们看到了类声明、方法声明、对象构造和返回语句。这些都是代码的基本组成部分。在Apex中，每条语句后面都需要用分号结束，就像你在写句子时需要用句号结束一样。另外，我们使用大括号`{}`来创建语句块，即使只有一条语句，我们也建议使用大括号，这样代码会更清晰。 3. ，与Java或C#的不同，：在Apex中，构造对象时可以指定命名参数，这让你可以更灵活地创建对象。另外，Apex中的DML语句是独立的，你可以直接插入、更新或删除记录。最后，Apex中的变量名是不区分大小写的，这和Java或C#不同，在那些语言中，变量名是区分大小写的。 希望这些解释能帮助你更好地理解这些概念！如果有任何问题，随时问我哦。

  ▶ 播放视频 查看详情
• 16

  Versioning

  第 97 页

  今天我们来聊聊Salesforce中的版本控制，特别是关于Apex类、触发器、Visualforce页面和组件的版本控制。听起来有点技术性，但别担心，我会用简单的方式来解释。 首先，想象一下，Salesforce平台就像是一个不断进化的生态系统。每年，Salesforce都会发布三次主要的更新，每次更新都会带来一些新的功能和改进。这就意味着，Salesforce的API（应用程序编程接口）也会随之更新。API是让我们的代码和Salesforce平台沟通的桥梁。 现在，这里有个问题：如果Salesforce更新了API，我们的代码会不会出问题呢？这就是版本控制的用武之地了。 在Salesforce中，每当我们创建一个Apex类、触发器、Visualforce页面或组件时，我们都会为它们指定一个API版本号。这个版本号就像是给我们的代码打上一个标签，告诉Salesforce：“嘿，我的代码是基于这个版本的API写的。” 这样做的好处是，无论Salesforce如何更新，只要我们的代码是基于某个特定的API版本写的，Salesforce就会在那个版本的上下文中运行我们的代码。这意味着，即使Salesforce发布了新的API版本，我们的旧代码仍然可以正常运行，不会因为平台的更新而出现问题。 所以，版本控制在这里的作用是确保我们的代码在不同的Salesforce版本中都能稳定运行。它不是指我们通常理解的文件的版本控制，比如在Git中管理文件的不同版本。而是指我们的代码与Salesforce API版本之间的兼容性。 总结一下，通过为我们的Apex类、触发器、Visualforce页面和组件指定API版本号，Salesforce能够确保我们的代码在每个Salesforce版本中都能正常工作，即使平台在不断更新和进化。这样，我们就可以放心地开发和部署我们的应用，而不必担心平台的更新会影响到我们的代码。 希望这个解释能帮助你理解Salesforce中的版本控制。如果有任何问题，随时问我哦！

  ▶ 播放视频 查看详情
• 17

  4-4: Observe the Effects of Versioning

  第 98 页

  同学们，今天我们来聊聊Salesforce中的版本控制，特别是关于Apex类的版本如何影响编译。我们将通过一个简单的实验来观察这一点。 首先，我们需要创建一个新的Apex类来测试版本控制。这个类将帮助我们理解不同版本下，哪些对象可以被编译。具体来说，我们将关注两个对象：FeedPost和FeedProject。这两个对象都是用来存储Chatter帖子的，但它们在不同的版本中可能会有不同的表现。 接下来，我们会更改Apex类的版本，看看这些更改如何影响编译过程。我们的目标是理解，随着版本的更新，哪些对象仍然可以被编译，哪些则不行。 在这个过程中，我们会发现一个名为“chatter”的功能，它随着版本的更改，s对象（即标准对象）会有所不同。这意味着，某些对象可能只在特定的版本中被支持，因此只有在这些版本中才能成功编译。 总结一下，今天的教学点主要是解释FeedProject和FeedPost这两个存储Chatter帖子的s对象，以及如何通过更改Apex类的版本来观察这些对象在不同版本中的编译情况。希望这能帮助大家更好地理解Salesforce中的版本控制和对象编译。

  ▶ 播放视频 查看详情
• 18

  Versioning Discussion

  第 99 页

  让我们来聊聊Salesforce的版本化问题，特别是关于FeedPost和FeedItem的变化，以及为什么开发人员可能需要更新他们的Apex类到更高版本。 首先，关于FeedPost和FeedItem的问题。Salesforce在版本22.0中决定不再支持FeedPost，转而引入了FeedItem。这种变化是为了改进数据模型，使其更加强大和灵活。但是，Salesforce并没有立即切断对FeedPost的支持。在版本17.0到21.0之间，FeedPost仍然被支持，这样做的目的是给开发人员足够的时间来适应新的FeedItem模型，而不会立即破坏他们现有的定制和集成。这种逐步过渡的策略确保了系统的稳定性和向后兼容性。 接下来，为什么开发人员可能会选择将现有的Apex类更新到更高版本呢？这主要是因为新版本通常会引入一些新功能或改进，这些新功能可能会让开发工作变得更简单或更高效。例如，在Spring '18（版本42）中，List类新增了CONTAINS(..)方法，这个方法以前只在Set类上可用。如果开发人员想要利用这个新功能，他们就需要将他们的Apex类更新到至少版本42。 最后，这种版本化的做法给开发人员带来了什么好处呢？最大的好处就是向后兼容性和稳定性。Salesforce每年都会发布三个新版本，每个版本都可能添加、删除或更改功能。通过将每个类或触发器与特定的版本关联，Salesforce平台能够优雅地处理这些变化，确保即使在新版本中，旧代码仍然能够运行，不会因为新功能的引入而出现问题。这种策略使得开发人员可以在不担心破坏现有功能的情况下，逐步采用新功能。 总的来说，Salesforce的版本化策略是为了确保平台的稳定性和灵活性，同时也为开发人员提供了逐步适应新变化的机会。通过这种方式，Salesforce能够持续创新，同时保护开发人员的投资。

  ▶ 播放视频 查看详情
• 19

  Where is Your Code?

  第 100 页

  让我们来聊聊Salesforce中的Apex代码存储和执行的过程。想象一下，你正在编写一段Apex代码，这段代码就像是你给Salesforce的一个指令，告诉它该做什么。 当你写完代码并成功编译后，Salesforce会把这个代码保存为一种叫做“元数据”的东西。元数据就像是Salesforce的一个内部数据库，专门用来存储这些编译好的代码。这样，无论何时Salesforce需要执行这段代码，它都可以从这个数据库中快速找到并运行它。 但是，这里有一个特殊情况。如果你使用的是“匿名执行”，也就是你直接在Salesforce的开发者控制台或者通过API临时运行一段代码，那么这段代码不会被保存为元数据。相反，它会被立即发送到Apex执行环境中去执行，执行完后就不会再保存了。 所以，总结一下： - 通常，编译成功的Apex代码会被保存为Salesforce的元数据。 - Apex代码只能在Salesforce平台上运行，不能在其他地方执行。 - 使用匿名执行时，代码不会保存，而是直接执行。 希望这样解释能帮助你更好地理解Apex代码的存储和执行过程！

  ▶ 播放视频 查看详情
• 20

  Data Types: Primitives

  第 101 页

  今天我们来聊聊Salesforce Apex语言中的数据类型，特别是那些被称为“Primitives”的基本类型。首先，Apex语言是基于Java的，所以如果你对Java有些了解，那么理解Apex会容易很多。 在Apex中，我们有一些基本的数据类型，比如字符串（String）、整数（Integer）、布尔值（Boolean）等。这些类型在Apex中被称为“Primitives”，但它们实际上更像是Java中的包装类。这意味着，尽管它们看起来像是基本类型，但在Apex中，它们其实是以对象的形式存在的。 这里有个小细节需要注意：在Apex中，如果你声明了一个变量但没有给它赋值，那么这个变量会被自动初始化为空（null）。这一点和Java中的包装类是一样的。所以，当你使用这些“Primitives”类型时，要记得它们可能包含空值。 我建议，对于这些数据类型，我们不需要深入讨论太多细节。因为在实际开发中，你可以根据需要查阅Salesforce的官方文档来获取更详细的信息。 最后，唐老师提醒我们，所有在Apex中声明的变量，无论它们是“Primitives”还是其他类型，实际上都是对象。这意味着，当你操作这些变量时，你实际上是在操作对象的引用。这一点对于理解Apex中的变量行为非常重要。 好了，这就是今天关于Apex中数据类型的小讲解。希望这些信息对你有所帮助，记得在实际操作中多加练习哦！

  ▶ 播放视频 查看详情
• 21

  Conditional and Loops

  第 102 页

  同学们，今天我们来聊聊Salesforce中的有条件和循环控制语句。这些是编程中非常基础但极其重要的部分，它们帮助我们控制程序的流程，让程序能够根据不同的条件做出不同的反应，或者重复执行某些操作。 首先，我们来看看条件语句。在Salesforce中，条件语句主要是用来判断某个条件是否成立，如果成立，就执行某段代码；如果不成立，就跳过或者执行另一段代码。这就像是我们日常生活中的决策过程，比如“如果今天下雨，我就带伞；如果不下雨，我就不带伞。”在Salesforce中，我们通常使用`if`语句来实现这种逻辑。 接下来是循环语句。循环语句允许我们重复执行某段代码，直到满足某个条件为止。在Salesforce中，我们有几种不同类型的循环，比如`for`循环和`while`循环。`for`循环通常用于我们知道要重复执行多少次的情况，而`while`循环则用于我们不知道具体次数，但知道在某个条件满足时继续执行的情况。 在Salesforce中，循环和条件语句的设计是为了让代码运行得更快、更高效。这是因为Salesforce平台是为处理大量数据和复杂业务逻辑而设计的，所以它的控制语句需要非常快速和灵活。 在接下来的课程中，我们会详细讨论`for`循环的不同类型，以及如何在Salesforce中有效地使用它们。我们会通过实际的例子来演示如何编写和优化这些控制语句，以确保我们的代码既高效又易于维护。 记住，掌握这些基本的控制语句是成为Salesforce开发高手的第一步。所以，让我们开始吧，一步步深入理解这些强大的工具！

  ▶ 播放视频 查看详情
• 22

  Collections

  第 103 页

  今天我们来聊聊Salesforce中的收藏（Collections）。收藏在Salesforce中是非常重要的概念，它们帮助我们更有效地管理和操作数据。 首先，我们来看一下Salesforce中的三种基本收藏类型：列表（List）、集合（Set）和映射（Map）。 1. ，列表（List），：列表是一个有序的集合，可以包含重复的元素。你可以把它想象成一个购物清单，上面列出的每一项都是按顺序排列的，而且你可以有多个相同的项目。列表允许你通过索引来访问元素，也就是说，你可以直接获取列表中的第一个、第二个或第N个元素。 2. ，集合（Set），：集合是一个无序的集合，不允许有重复的元素。你可以把它想象成一个装满了不同颜色球的袋子，每个球都是独一无二的，而且你无法确定它们的顺序。集合主要用于当你需要确保所有元素都是唯一的时候。 3. ，映射（Map），：映射是一个键值对的集合，每个键都对应一个值。你可以把它想象成一个电话簿，每个人的名字（键）对应一个电话号码（值）。映射允许你通过键来快速查找对应的值，这在处理复杂数据时非常有用。 这三种收藏类型各有其特点和用途。列表适合需要保持顺序和允许重复的场景；集合适合需要唯一性的场景；而映射则适合需要通过键来快速查找值的场景。 希望这些解释能帮助你更好地理解Salesforce中的收藏类型。如果你有任何问题，随时问我哦！

  ▶ 播放视频 查看详情
• 23

  4-5: Take a Quick Tour of Apex

  第 104 页

  同学们，今天我们来快速游览一下Apex的几个教学点。首先，我们要审查一个解决方案的要求。这个解决方案需要处理两个输入：一个是旧课程列表，另一个是新课程列表。我们的目标是生成一个只包含净新课程的数据结构作为输出。 接下来，我们来复习一下测试课程。Apex有一个内置的测试框架，这个框架在将代码从沙箱环境迁移到生产环境时非常有用。我们会在后面的模块中详细讨论这个测试框架和开发环境。 现在，让我们打开开发人员控制台，找到CourseManager_Test这个测试类。你会看到这个类被标记为测试类，这意味着它包含了用于测试的代码。 然后，我们回顾一下班级执行的任务。我们有两个主要的代码文件：CourseManager.cls和TestClassCourseManager.cls。在CourseManager.cls中，有一个findDuplicates方法，这个方法用于查找重复的课程。而在TestClassCourseManager.cls中，我们有一个测试类，用于测试CourseManager中的方法。 最后，注意一下，在下一个练习中，你们将在这个班级中编写自己的测试方法和方法。这将帮助你们更好地理解Apex的测试框架和代码结构。希望这些信息对你们有帮助，我们继续加油！

  ▶ 播放视频 查看详情
• 24

  Module Agenda - 105

  第 105 页

  今天我们来聊聊Salesforce的Apex编程。首先，我们来看看这个模块的议程。 ，模块议程：， 1. 开始使用Apex 2. Apex为何与众不同？ 3. 使用s对象 4. 使用Apex编程 ，1. 开始使用Apex， Apex是Salesforce平台上的一种强大的编程语言，它允许你创建复杂的业务逻辑和自定义功能。你可以把它想象成Salesforce的“大脑”，它能够处理数据、执行操作，并且与其他系统进行交互。 ，2. Apex为何与众不同？， Apex与其他编程语言不同，它是专门为Salesforce设计的。这意味着它可以直接访问Salesforce的数据和功能，而不需要通过API或其他中间件。Apex是强类型的，这意味着在编译时就会检查类型错误，这有助于减少运行时错误。 ，3. 使用s对象， 在Apex中，s对象（sObject）是Salesforce中标准对象和自定义对象的通用表示。你可以把s对象想象成数据库中的表，每个s对象都有字段（列）和记录（行）。通过Apex，你可以轻松地查询、插入、更新和删除这些s对象。 ，4. 使用Apex编程， 最后，我们将深入探讨如何使用Apex进行编程。你将学习如何编写Apex类、触发器、测试类等。我们还会讨论一些最佳实践，比如如何优化代码性能，如何确保代码的安全性等。 通过这个模块，你将掌握Apex的基础知识，并能够开始编写自己的Apex代码来扩展Salesforce的功能。希望你能享受这个学习过程，并从中获得宝贵的技能！

  ▶ 播放视频 查看详情
• 25

  Apex Transactions

  第 106 页

  今天我们来聊聊Apex中的交易要点。首先，Apex交易是什么呢？简单来说，Apex交易是指在Salesforce中执行的一系列操作，这些操作要么全部成功，要么全部失败。这就像你去超市买东西，要么你把所有东西都买回家，要么你什么都不买，不会出现只买了一半的情况。 接下来，我们说说非数据库事务。在Apex中，有些操作并不直接涉及到数据库的更改，比如发送邮件或者调用外部API。这些操作虽然不改变数据库，但它们也是交易的一部分，如果这些操作失败了，整个交易也会失败。 单个工作单元是什么意思呢？这指的是在Apex中，所有的操作都被视为一个整体。比如，如果你在一个方法中更新了10条记录，那么这10条记录的更新要么全部成功，要么全部失败，不会出现部分成功的情况。 最后，我们来说说“击中服务器”。在Apex中，当你执行一个操作时，比如更新记录，这个操作会被发送到Salesforce的服务器进行处理。服务器处理完这个操作后，会返回结果给你。这个过程就叫做“击中服务器”。 现在，我们来看看教学要点。假设你有两个方法，方法1和方法2。在方法1完成之前，执行匿名窗口中的代码是不会完成的。而在方法2完成之前，方法1也不会完成。这是因为方法调用会被放置在堆栈上，只有当方法2完成后，方法1才会从堆栈中移除，然后匿名窗口中的代码才会继续执行。 简单来说，这就像你在排队买票，只有前面的人买完票走了，你才能继续前进。这就是Apex交易的基本概念，希望你们能理解。如果有任何问题，随时问我哦！

  ▶ 播放视频 查看详情
• 26

  Apex Transactions that Operate on the Database

  第 107 页

  让我们来聊聊在Salesforce中，当我们在Apex中执行DML（数据操作语言）操作时，会发生什么有趣的事情。想象一下，你正在编写一段代码，比如插入一个新的联系人记录。这看起来很简单，对吧？但实际上，背后发生的事情比你想象的要复杂得多。 首先，当你执行DML操作时，比如插入、更新或删除记录，Salesforce会启动一个Apex事务。这个事务就像是一个包裹，里面包含了所有相关的操作。这些操作都是紧密相连的，它们要么全部成功，要么全部失败。这就是我们常说的“原子性”。 现在，让我们来看看这个事务中可能发生的事情。当你插入一个联系人时，这个操作可能会触发一个触发器。触发器是Salesforce中的一种自动化工具，它可以在特定事件发生时自动执行一些代码。比如，当联系人被插入时，触发器可能会自动更新相关的账户记录。 但是，事情并没有结束。这个触发器的执行可能会进一步触发工作流规则。工作流规则是另一种自动化工具，它可以在记录满足特定条件时自动执行一些操作，比如发送电子邮件或更新字段。 更复杂的是，这些操作可能会再次触发触发器，形成一个循环。这就是我们所说的“递归”。递归可能会导致系统性能问题，甚至可能导致无限循环。因此，作为一名Apex程序员，你需要非常小心地处理这种情况，确保你的代码不会陷入递归的陷阱。 总结一下，当你在Apex中执行DML操作时，你不仅仅是在操作数据库中的记录。你实际上是在启动一个复杂的事务，这个事务可能会触发一系列的自动化和业务流程。因此，编写健壮的代码，考虑到这些潜在的影响，是非常重要的。 希望这个解释能帮助你更好地理解Apex事务和DML操作的复杂性。记住，成为一名出色的Apex程序员，不仅仅是编写代码，更是理解代码背后的整个生态系统。

  ▶ 播放视频 查看详情
• 27

  4-6: Examine Implicit Operations

  第 108 页

  同学们，今天我们来学习如何检查Salesforce中的隐式操作任务。这个任务主要是关于在用户界面（UI）中创建课程参与者记录时，系统自动执行的一些后台操作。我们的目标是理解这些操作是如何被隐式调用的，并通过查看日志来验证这些操作。 首先，我们需要在Salesforce的UI中创建一个课程参与者记录。这个步骤很简单，就像你平时添加任何记录一样。创建记录后，Salesforce会自动触发一些后台操作，这些操作可能是由触发器或工作流规则引起的。 接下来，我们要查看系统日志。日志会详细记录所有因触发器或工作流规则而隐式调用的操作。在我们的例子中，代码段包含了触发器和工作流规则。触发器是“课程参与者触发器”，而工作流规则是“向与会者发送通知”。 在日志中，你应该能够看到触发器被触发时执行的操作，以及工作流规则被触发时发送通知的操作。通过检查这些日志，我们可以确认这些操作是否按预期执行。 这个过程大约需要10分钟。请确保你仔细查看日志中的每一项记录，这样你就能全面理解在创建课程参与者记录时，Salesforce后台发生了什么。 这就是今天的内容，希望你们都能掌握如何检查和理解Salesforce中的隐式操作。如果有任何疑问，随时提问。谢谢大家！

  ▶ 播放视频 查看详情
• 28

  What are Apex Governor Limits?

  第 109 页

  今天我们来聊聊Salesforce中的Apex州长限制。想象一下，我们正在烤饼干，这就是我们的Apex交易。每个饼干都需要一定的材料和步骤，就像每个Apex交易都需要一定的资源和操作。 首先，为什么Apex交易这么重要呢？因为Salesforce对每个交易都有一些限制，我们称之为州长限制。这些限制确保了系统的稳定性和公平性，防止任何一个交易占用过多的资源，影响到其他用户。 在烤饼干的过程中，我们需要考虑几个关键点： 1. ，查询的数量，：就像你不能无限制地使用面粉一样，Apex交易中你也不能无限制地进行数据库查询。 2. ，CPU时间，：烤饼干需要一定的时间，Apex交易也需要在一定的CPU时间内完成。 3. ，数据库操作次数，：每次你打开烤箱门，都会影响饼干的烤制，同样，Apex交易中的数据库操作次数也是有限制的。 4. ，堆空间，：就像你的烤盘大小有限一样，Apex交易中使用的内存（堆空间）也是有限的。 这些限制的具体数值可能会随着Salesforce的每次更新而变化，所以我们需要时刻关注最新的限制信息。 最后，记住，由于你无法预知哪些其他的Apex代码会作为你交易的一部分运行，所以在编写代码时，一定要考虑到优化，确保你的代码在这些限制内高效运行。 这就是Apex州长限制的基本概念，希望这能帮助你在Salesforce的世界里更好地“烤制”你的Apex代码！

  ▶ 播放视频 查看详情
• 29

  4-7: Profile Limits Using the Developer Console

  第 110 页

  同学们，今天我们来聊聊Salesforce中的开发人员控制台，特别是如何用它来查看和分析我们的任务执行限额。 首先，开发人员控制台是Salesforce提供的一个非常强大的工具，它可以帮助我们开发者调试代码、查看日志、分析性能等。在我们日常的开发工作中，了解如何有效地使用这个工具是非常重要的。 现在，假设我们有一个任务，我们需要查看这个任务在执行过程中使用了多少系统资源，比如CPU时间、数据库查询次数等。这些信息对于优化我们的代码和避免超出Salesforce的系统限制非常关键。 在开发人员控制台中，我们可以通过查看日志来获取这些信息。日志中会详细记录每次执行的详细信息，包括执行的Apex代码、触发的触发器、执行的SOQL查询等。通过分析这些日志，我们可以清楚地看到我们的任务在执行过程中消耗了多少资源。 具体来说，我们可以通过以下步骤来查看日志中的限额分析信息： 1. 打开开发人员控制台。 2. 在“日志”标签页中，找到并打开我们感兴趣的日志。 3. 在日志详情页面，我们可以看到“限额”部分，这里会列出所有相关的系统限额信息，比如CPU时间、SOQL查询次数、DML操作次数等。 4. 通过分析这些数据，我们可以判断我们的任务是否接近或已经超出了Salesforce的系统限制。 通过这种方式，我们不仅可以监控我们的任务执行情况，还可以及时发现潜在的性能问题，从而进行优化。 好了，这就是今天的内容。希望你们能够通过开发人员控制台更好地监控和优化你们的Salesforce任务。如果有任何问题，随时提问哦！

  ▶ 播放视频 查看详情
• 30

  Module Agenda - 111

  第 111 页

  今天我们来聊聊Salesforce的Apex编程。首先，我们会从“开始使用Apex”这个模块开始。Apex是Salesforce平台上的一种强大的编程语言，它允许开发者创建复杂的业务逻辑和自定义功能。 接下来，我们会探讨“Apex为何与众不同”。Apex是专门为Salesforce设计的，它可以直接与Salesforce的数据模型和用户界面集成，这使得它在处理Salesforce数据时非常高效和直接。 然后，我们会进入“使用s对象”这一部分。在Salesforce中，s对象是数据表的基础，每个s对象都代表了一个数据表，比如客户、联系人等。在Apex中，你可以直接操作这些s对象，进行数据的增删改查。 最后，我们会来到“模块4：使用Apex编程”。在这个模块中，我们会深入Apex的编程细节，包括如何编写触发器、批处理类、测试类等。我们会通过实际的例子来学习如何有效地使用Apex来解决实际的业务问题。 这就是我们今天要讨论的模块议程。希望你们能通过这些模块，对Apex有一个全面的了解，并能够在Salesforce平台上有效地使用它。

  ▶ 播放视频 查看详情
• 31

  Working with Data in Apex: A Common Pattern

  第 112 页

  让我们来聊聊在Apex中如何处理数据。想象一下，你有一个装满信息的宝箱，我们的目标就是打开它，看看里面有什么，然后根据需要调整这些信息，最后再把它们安全地放回去。这就是我们在Apex中处理数据的三个主要步骤：获取数据、修改数据、保存数据。 首先，，获取数据，。这就像是你打开宝箱的第一步。在Apex中，我们可以从数据库或者用户那里获取数据。比如，你可能需要从Salesforce的数据库中提取客户的联系信息，或者让用户通过表单输入他们的需求。这一步非常关键，因为你需要确保你获取的数据是准确和有用的。 接下来是，修改数据，。这一步就像是你检查宝箱里的物品，看看哪些需要修理或者更新。在Apex中，这意味着你可能需要更新记录、删除不再需要的数据，或者添加新的信息。例如，如果客户的地址变了，你就需要更新他们的记录。 最后，，保存数据，。这一步确保所有的更改都被安全地保存回数据库。就像你把宝箱重新锁好，确保里面的物品安全无虞。在Apex中，这意味着你需要将修改后的数据写回Salesforce数据库，确保所有的更新都被记录下来。 在接下来的模块中，我们会更详细地探讨每一个步骤，确保你能够熟练地在Apex中处理数据。记住，掌握这些基本的数据处理模式，将帮助你在Salesforce的世界里更加自信和高效。

  ▶ 播放视频 查看详情
• 32

  What is an sObject?

  第 113 页

  让我们来聊聊Salesforce中的s对象。想象一下，s对象就像是Salesforce世界里的各种“东西”。这些“东西”可以是Salesforce自己提供的，比如账户、联系人、案例这些标准对象，也可以是你自己通过用户界面创建的，比如你可能需要一个“课程”或者“课程交付”这样的自定义对象。 在Apex编程中，当你想要操作这些“东西”时，你就是在操作s对象。每一个s对象都有一个共同的“爸爸”，叫做sBody。这个sBody是所有s对象的超类，也就是说，无论是标准对象还是自定义对象，它们都继承了sBody的一些基本特性。 所以，当你听到s对象这个词时，你可以想象它代表的是Salesforce数据库中的一条记录，这条记录有它自己的类型，比如“账户”或者“课程”，同时它也是这个类型的一个具体实例，比如“张三的账户”或者“2023年春季的课程”。 记住，sBody是用来描述这些对象类型和它们的实例的术语。简单来说，s对象就是你在Salesforce中操作的各种数据和记录。

  ▶ 播放视频 查看详情
• 33

  Common Terminology

  第 114 页

  同学们，今天我们来聊聊Salesforce中的一些常用术语，我会尽量用简单的话来解释，让大家都能听懂。 首先，我们来说说“对象”。在Salesforce中，对象就像是你在页面上看到的东西，比如一个客户信息表或者一个产品列表。你可以通过页面布局或者Visualforce页面来操作这些对象。 接下来是“记录”。记录就像是对象中的一行数据。比如，如果你有一个客户对象，那么每个客户的具体信息就是一条记录。 然后是“sObjects”。这个词听起来有点技术性，但其实很简单。在Apex代码中，sObjects就是用来装数据的容器。你可以把它想象成一个盒子，里面放着各种数据，比如客户的名字、电话等。 最后是“元数据”。元数据就像是数据的描述信息。当你定义一个sObject时，这个定义就会被存储为元数据。这样，无论是数据库还是Apex代码，都知道这个sObject长什么样子，里面有什么数据。 总结一下，UI、数据库和Apex中的数据容器虽然有不同的名字，但它们其实都是在处理数据。定义sObject时，这个定义会变成元数据，帮助数据库和Apex理解和使用这些数据。 希望这些解释能帮助大家更好地理解Salesforce中的这些术语。如果有任何问题，随时问我哦！

  ▶ 播放视频 查看详情
• 34

  What's Familiar in this Code Segment?

  第 115 页

  让我们一起来看一下这段代码，看看它有什么特别之处，以及它和Java或C#有什么不同。 首先，这段代码声明了一个方法。这个方法没有返回值，也就是说，它是一个“void”方法。它接受一个参数，这个参数是一个列表，列表中的元素是Course_Delivery_c类型的sObject。sObject是Salesforce中的一种特殊对象，类似于数据库中的记录。 接下来，我们来看看代码的每一行都做了什么： 1. 第一行是方法的声明，它告诉我们这个方法的名字和它接受的参数类型。 2. 第二行声明了一个列表变量，并用列表的构造函数来初始化它。 3. 第三行是一个for循环，它会遍历列表中的每一个元素。 4. 第四行是一个if语句，它检查某个条件是否为真。 5. 第五行是一个赋值语句，它将一个值赋给某个变量。 6. 第六行是一个方法调用，它将一个元素添加到列表中。 现在，我们来看看这段代码和Java或C#有什么不同： - 在第四行，我们使用了“==”符号来比较字符串和字段值。在Java中，我们通常会使用equals方法来比较字符串。 - 在第五行，字符串是用单引号括起来的，而在Java和C#中，我们通常使用双引号。 - 在第六行，变量名是不区分大小写的，这意味着“myVariable”和“myvariable”在Salesforce中是一样的。 - 在第九行，我们看到了一个DML UPDATE语句，这是Salesforce特有的，用于更新数据库中的记录。 通过这些比较，我们可以看到Salesforce的Apex语言和Java或C#有一些相似之处，但也有一些独特的特点。希望这些解释能帮助你更好地理解这段代码！

  ▶ 播放视频 查看详情
• 35

  sObjects and the Declarative Configuration

  第 116 页

  让我们来聊聊Salesforce中的s对象和声明性描述的一些关键点。首先，声明性字段，也就是那些我们在Salesforce界面上通过点击和配置来创建的字段，它们其实也可以在Apex代码中使用。这是一个很酷的功能，因为它意味着你可以在代码中直接操作这些字段，进行数据读取或更新等操作。 但是，这里有一个重要的注意事项：一旦你在Apex代码中使用了某个声明性字段，你就不能随意删除这个字段了。为什么呢？因为如果删除了这个字段，那么依赖于它的Apex代码就会出错，导致功能无法正常运行。所以，在删除字段之前，一定要确保没有任何Apex代码还在使用它。 接下来，我们来看看声明性和程序性是如何在Salesforce平台上相互关联的。简单来说，声明性指的是通过Salesforce的界面进行配置和设置，而程序性则是指通过编写代码（如Apex）来实现功能。这两者并不是孤立的，而是可以相互配合使用的。 举个例子，假设你在Apex代码中引用了一个s对象的字段。那么，你就不能随意删除或修改这个字段，因为这会影响声明性接口中的代码。也就是说，你的Apex代码和Salesforce的声明性配置是紧密相连的，一方的变动可能会影响到另一方。 最后，当你将Apex代码从一个环境迁移到另一个环境时，比如从开发环境迁移到生产环境，你需要确保Apex代码所引用的所有声明性元素（如字段、对象等）都已经存在于目标环境中，或者是你正在迁移的“包”的一部分。否则，代码在目标环境中可能无法正常运行。 好了，这就是关于s对象和声明性描述的一些要点。希望这些内容能帮助你更好地理解Salesforce中的声明性和程序性是如何相互关联的。如果你有任何问题，随时问我哦！

  ▶ 播放视频 查看详情
• 36

  How is an sObject Named in Apex?

  第 117 页

  今天我们来聊聊在Salesforce的Apex中如何命名s对象。首先，我们需要理解s对象和字段的命名规则。在Salesforce中，对象的命名分为标准对象和自定义对象两种。 对于标准对象，它们的API名称通常遵循一个通用的模式。比如，我们常见的Account、Contact等，这些都是标准对象，它们的API名称就是它们的名字本身。 而对于自定义对象，情况就稍微复杂一点。自定义对象的API名称是在你创建对象时设定的名称后面加上“__c”。这个“__c”是Salesforce用来区分标准对象和自定义对象的一个标识。比如，如果你创建了一个自定义对象叫做“Project”，那么它的API名称就是“Project__c”。 现在，你可能会问，这些API名称在哪里可以找到呢？其实，有几种方式可以查看这些名称。首先，你可以使用Salesforce的架构生成器，这是一个图形化的工具，可以帮助你查看和管理你的数据模型。其次，你也可以在设置菜单中找到与对象关联的UI页面，那里也会显示API名称。最后，如果你是一个开发者，你还可以在开发者控制台中查看这些API名称。 需要注意的是，虽然大多数API名称都可以按照上述规则预测，但在某些特殊情况下，它们可能会有所不同。例如，Price Book的API名称就是“PriceBook2”，而不是我们可能预期的“PriceBook”。 好了，这就是今天关于如何在Apex中命名s对象的内容。希望这些信息对你有所帮助，让你在Salesforce的开发之旅上更加顺利。如果你有任何问题，随时欢迎提问！

  ▶ 播放视频 查看详情
• 37

  Using the sObject API Name

  第 118 页

  让我们来一步步解析这段代码，并回答你的问题。 首先，我们来看这段代码： ```apex 联系人 contactToAdd = new 联系人(lastName='Jensen', firstName='Sam'); contactToAdd.firstName = "John"; contactToAdd.lastName = 'Test2'; insert contactToAdd; System.debug('contactToAdd record ID 是：' + contactToAdd.Id); ``` ### 1. 使用s对象API名称 在这段代码中，`联系人`是标准对象的API名称。在Salesforce中，标准对象的API名称通常是单数形式，比如`Account`、`Contact`等。在这里，`联系人`就是`Contact`对象的API名称。 ### 2. 示例-标准对象 `Contact`是Salesforce中的一个标准对象，用于存储联系人的信息。在这段代码中，我们创建了一个新的`Contact`对象实例，并设置了`lastName`和`firstName`字段。 ### 3. 示例-自定义对象 如果我们要使用自定义对象，比如`Certification_Held__c`，我们可以这样写： ```apex Certification_Held__c cert = new Certification_Held__c(Name='Salesforce Admin'); insert cert; ``` ### 4. 在哪一行 - ，联系人是否用作变量的数据类型？， 是的，在第一行 `联系人 contactToAdd = new 联系人(lastName='Jensen', firstName='Sam');` 中，`联系人`被用作变量`contactToAdd`的数据类型。 - ，联系方式是构造函数的名称吗？， 是的，`联系人`在这里也是构造函数的名称。构造函数用于创建对象实例。 - ，联系是否用作方法的返回数据类型？， 在这个例子中，没有直接使用`联系人`作为方法的返回数据类型。但如果你有一个方法返回`Contact`对象，那么`联系人`就会用作返回数据类型。 - ，Certification_Held__c是否用作参数的数据类型？， 在这个例子中，没有使用`Certification_Held__c`作为参数的数据类型。但如果有一个方法接受`Certification_Held__c`类型的参数，那么它就会用作参数的数据类型。 ### 5. 构造s对象时，您可以选择在构造函数中指定字段值 在Apex中，当你创建一个sObject实例时，你可以在构造函数中直接指定字段的值。例如： ```apex Contact contactToAdd = new Contact(lastName='Jensen', firstName='Sam'); ``` 这里，我们在创建`Contact`对象时，直接设置了`lastName`和`firstName`字段的值。 ### 6. 要点总结 - ，s对象API名称与任何其他数据类型一样使用。， 你可以像使用其他数据类型一样使用sObject的API名称，比如`Contact`、`Account`等。 - ，将字段值列表与构造函数一起使用-仅适用于sObjects，不适用于从Apex自定义类实例化的对象。， 这种在构造函数中直接设置字段值的方式只适用于sObjects，不适用于自定义的Apex类。 ### 答案 - ，线1A，：`联系人`被用作变量的数据类型。 - ，线1A，：`联系人`也是构造函数的名称。 - ，线1B，：在这个例子中，`联系人`没有用作方法的返回数据类型。 - ，线1B，：在这个例子中，`Certification_Held__c`没有用作参数的数据类型。 希望这个解释能帮助你更好地理解这段代码！如果有任何问题，随时问我哦！

  ▶ 播放视频 查看详情
• 38

  Referencing Fields within an sObject

  第 119 页

  今天我们来聊聊Salesforce中的自定义字段，特别是那些以“__c”结尾的字段。这些字段是你在Salesforce中自己创建的，用来存储特定的数据。比如，你可能需要一个字段来记录客户的生日，或者一个字段来跟踪产品的特殊属性。这些字段就是自定义字段。 首先，记住一点，所有的自定义字段在Salesforce中都会以“__c”结尾。这个“__c”是Salesforce用来区分标准字段和自定义字段的一个标志。标准字段是Salesforce自带的，比如“Name”或“CreatedDate”，而自定义字段是你自己添加的，所以它们会有这个特殊的后缀。 接下来，我们来说说如何在sObjects中找到这些自定义字段的关系字段名称。sObjects是Salesforce中的对象，比如“Account”或“Contact”。有时候，你可能需要找到这些对象之间的关系字段，比如一个客户（Account）和它的联系人（Contact）之间的关系。 在Salesforce中，找到这些关系字段的名称可能会有点棘手，但你可以使用一些工具来帮助你。比如，你可以使用Salesforce的工作台（Workbench）或者Eclipse IDE。在这些工具中，你可以执行一些查询，来查看对象的结构，包括所有的字段和它们之间的关系。 总的来说，自定义字段是Salesforce中非常强大的一部分，它们让你可以根据自己的需求来定制数据存储。记住它们的命名规则，以及如何找到它们的关系字段，这样你就能更好地管理和使用这些字段了。希望这些信息对你有帮助！

  ▶ 播放视频 查看详情
• 39

  Using Apex to Get Data from the Database

  第 120 页

  同学们，今天我们来聊聊如何使用Apex从Salesforce数据库中获取数据。这里有几个关键点需要记住。 首先，我们使用SOQL（Salesforce Object Query Language）来查询数据。SOQL是专门为Salesforce设计的查询语言，类似于SQL，但更简单一些。 假设我们要从数据库中获取联系人的信息。联系人（Contact）是Salesforce中的一个标准对象，用来存储联系人的详细信息。 在Apex中，当我们使用SOQL查询时，返回的结果通常是一个列表（List）。这个列表中的每个元素都是一个sObject，也就是Salesforce中的对象。在这个例子中，我们查询的是联系人，所以返回的列表类型是List。 举个例子，如果我们想获取所有联系人的名字和邮箱，我们可以这样写： ```apex List contacts = [SELECT Name, Email FROM Contact]; ``` 这段代码的意思是，我们从Contact对象中查询Name和Email字段，并将结果存储在contacts列表中。这个列表中的每个元素都是一个Contact对象，包含了我们查询的字段信息。 简单来说，SOQL查询返回的是一个列表，列表中的每个元素都是我们查询的对象。在这个例子中，我们查询的是联系人，所以返回的是List。 希望这个解释对你们有帮助！如果有任何问题，随时问我哦。

  ▶ 播放视频 查看详情
• 40

  4-8: Work with a Custom Object

  第 121 页

  同学们，今天我们要学习的是如何在Salesforce中使用自定义对象。这个练习特别有趣，因为它会让我们看到用户界面（UI）上的信息是如何转换成变量类型的。这就像是把我们在屏幕上看到的东西，变成计算机能理解的语言。 首先，我们要知道，在这个练习中，我们不会涉及到任何关系字段。也就是说，我们只关注单个对象内部的数据，不涉及它与其他对象的联系。 接下来，我们会用到几个特定的字段，它们的UI名称分别是： 1. 课程交付编号：这就像是每门课程的唯一身份证号码，帮助我们快速识别和查找特定的课程。 2. 区域：这个字段告诉我们课程是在哪个地区进行的，比如北京、上海等。 3. 位置：这指的是课程具体在哪里举行，可能是某个具体的地址或会议室。 4. 开始日期：这个字段告诉我们课程什么时候开始，帮助我们安排时间。 5. 状态：这个字段显示课程的当前状态，比如是“已开始”、“未开始”还是“已结束”。 通过这些字段，我们可以更好地管理和跟踪我们的课程信息。现在，让我们开始动手操作，看看这些UI信息是如何转换成变量类型的吧！

  ▶ 播放视频 查看详情
• 41

  Referencing a Relationship Field on a Child sObject

  第 122 页

  让我们来聊聊Salesforce中的关系字段，特别是关于“孩子”和“父母”的关系。想象一下，你有一个家庭，孩子和父母之间的关系。在Salesforce中，这种关系是通过关系字段来建立的。 首先，问题来了：一个孩子有多少父母？在Salesforce中，通常一个孩子对象只能有一个父母对象。这就像在现实生活中，一个孩子通常有两个父母，但在Salesforce的数据模型中，我们简化了这个关系，通常一个孩子只关联到一个父母。 现在，让我们深入一点。每个关系字段在Salesforce中都有两个含义。对于标准对象，比如Account（账户），我们有一个约定俗成的字段名，比如`AccountId`。这个字段有两个作用： 1. ，ID字段，：当你设置这个字段为父对象的ID时，比如`AccountId = '001XXXXXXXXXXXX'`，你实际上是在告诉Salesforce：“这个孩子对象是属于这个特定的父对象的。”这就像给孩子一个家庭地址，让他知道自己的家在哪里。 2. ，参考字段，：当你通过父对象的单一形式来初始化这个字段时，比如`Account.Name`，你实际上是在说：“给我这个父对象的某个字段的值。”这就像孩子问父母：“爸爸，你的名字是什么？”然后父母回答：“我叫张三。” 在Apex代码中，这种关系字段会被转化为两个字段：一个是ID字段，用来存储父对象的ID；另一个是参考字段，用来访问父对象的字段。 举个例子，如果你想在Apex中设置一个孩子对象的父对象，你可以这样做： ```apex childObject.AccountId = '001XXXXXXXXXXXX'; // 设置父对象的ID ``` 然后，如果你想从孩子对象访问父对象的某个字段，比如父对象的名字，你可以这样做： ```apex String parentName = childObject.Account.Name; // 访问父对象的名字 ``` 这样，你就可以通过孩子对象轻松地获取到父对象的信息了。 总结一下，关系字段在Salesforce中非常重要，它们帮助我们建立对象之间的联系，就像家庭中的父母和孩子一样。通过理解这些关系字段的用法，你可以更好地管理和操作你的Salesforce数据。希望这个解释对你有帮助！

  ▶ 播放视频 查看详情
• 42

  Referencing a Relationship Field on a Child sObject (cont.)

  第 123 页

  让我们来聊聊Salesforce中的关系字段，特别是引用子对象上的关系字段。这部分内容听起来可能有点复杂，但我会尽量用简单的方式来解释。 首先，想象一下，你有两个对象，比如“认证”和“用户”。你想在“用户”对象上创建一个字段，用来引用“认证”对象。这就是我们所说的自定义关系字段。 在Salesforce中，当你创建一个自定义关系字段时，默认情况下，这个字段的名称会基于父对象的名称。比如，如果父对象是“认证”，那么默认的关系字段名称可能就是“认证__c”。这里的“__c”表示这是一个自定义字段。 但是，作为管理员，你可以改变这个默认的名称，给它一个更符合你业务逻辑的名字。 现在，如果你想在“用户”对象上引用“认证”对象，你会使用“认证__c”这个字段。这个字段实际上存储的是“认证”对象的ID，也就是外键（FK）。这意味着，通过这个字段，你可以找到对应的“认证”记录。 但是，如果你想在“用户”对象上直接访问“认证”对象的某个字段，比如“名称”，你就需要使用“认证__r.Name”。这里的“__r”表示这是一个关系字段，它允许你通过关系字段访问父对象的字段。 最后，回答你的问题：是的，你可以在两个标准对象之间建立自定义关系。Salesforce允许你在任何两个对象之间建立关系，无论是标准对象还是自定义对象。 总结一下，理解关系字段的关键在于记住“__c”用于存储外键，而“__r”用于访问父对象的字段。希望这个解释能帮助你更好地理解Salesforce中的关系字段。如果有任何疑问，随时提问！

  ▶ 播放视频 查看详情
• 43

  What Fieldnames Should You Use?

  第 124 页

  同学们，今天我们来讨论一下在Salesforce中如何选择和使用字段名称。这是一个非常重要的技能，因为正确的字段命名不仅能帮助我们更好地理解数据，还能让我们的系统更加高效。 首先，我们来看一下这些字段名称： 1. ，名字 (Name)，：这是最基本的字段，通常用于标识记录的名称。 2. ，认证_元素__c (Certification_Element__c)，：这是一个自定义字段，用于存储与认证相关的元素。 3. ，认证_元素__r.名称 (Certification_Element__r.Name)，：这是一个关系字段，表示与“认证_元素__c”相关联的记录的名称。 4. ，认证_候选人__r.姓名 (Certification_Candidate__r.Name)，：这是另一个关系字段，表示与“认证_候选人__c”相关联的记录的姓名。 5. ，认证_candidate__r.Account.name (Certification_Candidate__r.Account.Name)，：这是一个更深层次的关系字段，表示与“认证_候选人__c”相关联的账户的名称。 6. ，状态__c (Status__c)，：这是一个自定义字段，用于存储记录的状态。 接下来，我们来看一个SOQL查询的例子，这个查询会从“认证_尝试__c”对象中选择一些字段： ```sql SELECT Id, Name, Certification_Element__c, Certification_Element__r.Name, Certification_Candidate__r.Name, Certification_Candidate__r.Account.Name FROM Certification_Attempt__c WHERE Status__c = '已安排' ``` 在这个查询中，我们选择了以下几个字段： - ，Id，：记录的唯一标识符。 - ，Name，：记录的名称。 - ，Certification_Element__c，：与认证相关的元素。 - ，Certification_Element__r.Name，：与“认证_元素__c”相关联的记录的名称。 - ，Certification_Candidate__r.Name，：与“认证_候选人__c”相关联的记录的姓名。 - ，Certification_Candidate__r.Account.Name，：与“认证_候选人__c”相关联的账户的名称。 最后，我们还有一个条件，即，Status__c = '已安排'，，这意味着我们只选择那些状态为“已安排”的记录。 同学们，记住，字段命名和关系字段的使用是非常重要的。它们帮助我们更好地组织和管理数据。希望今天的讲解对你们有所帮助！如果有任何问题，随时问我。

  ▶ 播放视频 查看详情
• 44

  What Data Type Should You Use When Going from Child to Parent?

  第 125 页

  同学们，今天我们来讨论一个非常有趣的话题：在Salesforce中，当我们需要从“孩子”对象关联到“父母”对象时，应该使用什么数据类型。这个问题在实际开发中非常常见，所以大家一定要认真听哦！ 首先，我们来看一下代码示例。在这个代码中，我们有一个名为`Certification_Attempt__c`的对象，它有一个字段叫做`certification_Element__c`，这个字段是用来存储“孩子”对象与“父母”对象之间的关联的。 ### 数据类型的选择 1. ，ID，：当我们想要存储“孩子”对象与“父母”对象之间的关联时，通常会使用`ID`数据类型。`ID`是Salesforce中用来唯一标识一个记录的字段类型。在这个例子中，`certification_Element__c`字段就是一个`ID`类型的字段，它存储了“孩子”对象与“父母”对象之间的关联。 2. ，联系（Contact），：如果“父母”对象是一个联系人（Contact），那么我们可以使用`Contact`数据类型来存储这个关联。在这个例子中，`certification_candidate__r`字段就是一个`Contact`类型的字段，它存储了与“孩子”对象关联的联系人记录。 3. ，账户（Account），：如果“父母”对象是一个账户（Account），那么我们可以使用`Account`数据类型来存储这个关联。在这个例子中，`certification_candidate__r.Account`字段就是一个`Account`类型的字段，它存储了与“孩子”对象关联的账户记录。 ### 代码解析 让我们来看一下代码的具体实现： ```java if (oldCertAttempts.size() > 0) { Certification_Attempt__c certificationAttempt = oldCertAttempts[0]; Id var1 = certificationAttempt.certification_Element__c; // 使用ID数据类型 Contact var2 = certificationAttempt.certification_candidate__r; // 使用Contact数据类型 Account var3 = certificationAttempt.certification_candidate__r.Account; // 使用Account数据类型 } ``` 在这个代码中： - `var1`是一个`ID`类型的变量，它存储了`certification_Element__c`字段的值。 - `var2`是一个`Contact`类型的变量，它存储了`certification_candidate__r`字段的值。 - `var3`是一个`Account`类型的变量，它存储了`certification_candidate__r.Account`字段的值。 ### 总结 所以，当我们需要从“孩子”对象关联到“父母”对象时，通常会使用`ID`、`Contact`或`Account`数据类型。具体使用哪种数据类型，取决于“父母”对象的类型。 好了，今天的课程就到这里。希望大家能够理解并掌握这些知识点。如果有任何问题，欢迎随时提问！ --- ，板书内容：， - ，数据类型选择：， - `ID`：用于存储“孩子”与“父母”之间的关联。 - `Contact`：如果“父母”是联系人。 - `Account`：如果“父母”是账户。 - ，代码示例：， ```java if (oldCertAttempts.size() > 0) { Certification_Attempt__c certificationAttempt = oldCertAttempts[0]; Id var1 = certificationAttempt.certification_Element__c; Contact var2 = certificationAttempt.certification_candidate__r; Account var3 = certificationAttempt.certification_candidate__r.Account; } ```

  ▶ 播放视频 查看详情
• 45

  Referencing a Relationship Field on a Parent sObject

  第 126 页

  让我们来聊聊在Salesforce中如何引用父对象和子对象之间的关系字段。这个话题对于理解数据模型和编写Apex代码非常重要。 首先，想象一下，你有一个家庭，家庭中有父母和孩子。在Salesforce中，父对象就像是父母，而子对象就像是孩子。一个父母可以有多个孩子，这就是所谓的“一对多”关系。 在Apex代码中，当你想要访问父对象的子对象时，你会使用一个列表来引用这些子对象。这个列表的名字通常是子对象的复数形式。比如，如果你有一个叫做“联系人”的子对象，那么在Apex中，你会使用“联系人s”来引用这些子对象的列表。 这里有一个小技巧：对于标准的对象关系，比如联系人，你只需要在对象名字后面加个“s”就可以了。但是，如果你使用的是自定义对象关系，比如你有一个自定义对象叫做“课程”，那么在Apex中，你会把“课程__c”变成“课程__r”来引用这些子对象的列表。 最后，记住，子对象上会有一个字段，默认情况下，这个字段会引用到父对象。这样，你就可以轻松地在子对象和父对象之间建立联系了。 希望这个解释能帮助你更好地理解Salesforce中的对象关系。如果你有任何问题，随时问我！

  ▶ 播放视频 查看详情
• 46

  What Data Type Should You Use When Going from Parent to Child?

  第 127 页

  同学们，今天我们来聊聊在Salesforce中，当数据从父母对象传递到孩子对象时，应该使用什么数据类型。这个问题其实很常见，尤其是在处理对象之间的关系时。 首先，我们要明确的是，当我们在处理一对多的关系时，也就是说，一个父母对象可能对应多个孩子对象，这时候我们就需要使用复数形式来表示这些孩子对象。在Salesforce中，这通常通过使用“__r”后缀来实现。 举个例子，假设我们有一个名为“Certification_Element__c”的父母对象，它有一个孩子对象叫做“Certification_Attempt__c”。那么，当我们想要从父母对象访问孩子对象时，我们应该使用“Certification_Attempt__r”来表示这些孩子对象。 接下来，我们来看一段代码示例： ```apex List oldCertElements = [SELECT Id, Name, (SELECT Id, Name, Certification_Candidate__r.Name FROM Certification_Attempts__r) FROM Certification_Element__c WHERE Type__c = 'Lab']; if (oldCertElements.size() > 0) { Certification_Element__c certificationElement = oldCertElements[0]; List certAttempts = certificationElement.Certification_Attempts__r; } ``` 在这段代码中，我们首先查询了所有类型为“Lab”的“Certification_Element__c”对象，并且通过子查询获取了每个“Certification_Element__c”对象对应的“Certification_Attempt__c”对象。这里的关键点在于，我们使用了“Certification_Attempts__r”来访问这些孩子对象。 最后，我们检查了查询结果是否为空，如果不为空，我们就获取了第一个“Certification_Element__c”对象，并且通过“Certification_Attempts__r”获取了所有相关的“Certification_Attempt__c”对象。 总结一下，当我们在Salesforce中处理从父母到孩子的数据传递时，应该使用复数形式的数据类型，并且通过“__r”后缀来访问这些孩子对象。希望这个解释对你们有所帮助！

  ▶ 播放视频 查看详情
• 47

  Data Type: Id

  第 128 页

  今天我们来聊聊Salesforce中的ID数据类型，特别是15字符和18字符的ID。这个知识点对于理解Salesforce的数据处理非常重要。 首先，Salesforce中的ID是用来唯一标识一个记录的。你可能会注意到，有时候ID是15个字符，有时候是18个字符。这两种ID都是区分大小写的，这意味着如果你在Salesforce中使用它们时，大小写必须完全匹配，否则系统无法识别。 15字符的ID通常可以在经典用户界面的对象详细信息页面的URL中看到。而18字符的ID则出现在日志和Lightning用户界面中，这是Salesforce推荐的表示方式。 那么，为什么会有两个版本呢？15字符的ID是存储在数据库中的原始形式。后来，为了支持不区分大小写的应用程序，Salesforce在API 2.0及更高版本中引入了18字符的ID。这是因为如果外部系统将15字符的ID视为不区分大小写，可能会导致唯一性问题，即两个不同的ID可能被错误地认为是相同的。而18字符的ID则确保了即使在不区分大小写的情况下，每个ID也是唯一的。 因此，当你在使用API时，应该始终使用18字符的ID。这样可以避免在数据比较时出现错误。 如果你需要将15字符的ID转换为18字符的ID，可以参考一些在线资源，比如Salesforce的官方文档或者社区论坛，那里有详细的转换方法和工具。 最后，记住一点：永远不要硬编码ID。因为ID在不同的Salesforce环境中是不同的，硬编码会导致代码在不同的环境中无法正常工作。 希望这个解释能帮助你更好地理解Salesforce中的ID数据类型。如果你有任何问题，随时提问！

  ▶ 播放视频 查看详情
• 48

  4-9: Use Record Ids to Access an Account in the UI

  第 129 页

  同学们，今天我们来学习如何使用记录ID在Salesforce中访问语音信箱中的帐户。这个过程其实很简单，我们只需要几个步骤就可以完成。 首先，我们需要查询数据库中的联系人记录。我们只需要查询两个字段：ID和姓名。这个ID是每个记录在Salesforce中的唯一标识符，就像每个人的身份证号码一样，是独一无二的。 查询完成后，我们会得到一个记录列表。在这个列表中，我们需要找到我们感兴趣的那个联系人记录，然后复制它的ID。这个ID就是我们接下来要使用的关键。 接下来，我们使用这个ID在Salesforce的用户界面（UI）中显示关联的联系人页面。你只需要在浏览器的地址栏中输入这个ID，然后按下回车键，Salesforce就会自动跳转到这个联系人的详细页面。 通过这个过程，我们不仅学会了如何使用记录ID来访问特定的联系人记录，还探索了记录ID在Salesforce中的重要性。记录ID是我们在Salesforce中快速定位和访问特定记录的关键。 好了，这就是我们今天的内容。希望你们都能掌握这个技能，并在实际工作中灵活运用。如果有任何问题，随时提问。我们下次再见！

  ▶ 播放视频 查看详情
• 49

  Key Takeaways - 130

  第 130 页

  今天我们来聊聊Salesforce中的Apex语言。Apex是一种非常强大的面向对象的编程语言，它让你能够在Salesforce的Lightning平台上自定义和创建应用程序。你可以把它想象成一种工具，帮助你更灵活地使用Salesforce。 Apex是Salesforce平台的一部分，这意味着它能够与平台的其他功能无缝交互。比如，你可以用Apex来操作数据、自动化业务流程，甚至创建复杂的逻辑。不过，Apex并不是孤立的，它依赖于Salesforce的其他功能，比如数据库、用户界面等。 在使用Apex时，有一个非常重要的概念叫做“州长限制”（Governor Limits）。这些限制是为了确保系统的稳定性和公平性。简单来说，Salesforce会监控你的Apex代码，确保它不会占用过多的系统资源。比如，你不能在一个事务中查询过多的数据，或者执行过多的操作。这些限制是为了防止某个用户或应用程序占用太多资源，影响其他用户的使用。 接下来，我们来说说s对象。s对象是Apex中用来表示Salesforce中标准或自定义对象的类。你不需要自己定义这些类，Salesforce已经为你准备好了。比如，如果你想操作一个客户记录，你可以直接使用Account这个s对象，而不需要从头开始定义一个类。 最后，有几个关键点需要记住： 1. Apex是Salesforce的一部分，它与其他平台功能紧密集成。 2. 你不需要自己定义s对象类，Salesforce已经为你准备好了。 3. Salesforce了解Apex，所以你可以直接使用平台提供的功能。 4. 如果你在Apex代码中使用了某个字段，你就不能删除这个字段，否则代码会出错。 5. 州长限制是为了确保系统的稳定性和公平性，所以编写代码时要注意这些限制。 希望这些内容能帮助你更好地理解Apex和Salesforce的关系。如果你有任何问题，随时问我！

  ▶ 播放视频 查看详情
• 50

  Knowledge Check - 131

  第 131 页

  让我们来一步步解答这些问题。 首先，关于“什么可以正确完成最终陈述？”这个问题，其实是在问我们如何确保一个陈述或结论是正确的。在编程中，这通常意味着我们需要确保我们的代码逻辑是正确的，数据是准确的，并且我们使用的条件或表达式能够准确地反映出我们想要的结果。 接下来，我们来看第二个问题：“使用什么条件表达来确定两个s对象的内容是否相等？”这里给出了四个选项： 1. `sObj1 == sObj2` 2. `sObj1.equals(sObj2)` 3. `sObj1 = sObj2` 4. `sObj1.eq(sObj2)` 在Java或Apex（Salesforce的编程语言）中，`==` 是用来比较两个对象的引用是否相同，也就是说，它们是否指向内存中的同一个对象。而 `.equals()` 方法则是用来比较两个对象的内容是否相等。所以，正确的答案是 `sObj1.equals(sObj2)`，也就是选项B。 最后，我们来看第三个问题，关于知识检查的代码片段。这里有一些变量需要填充： ```java Certification_Attention__c certAttention = ...; // 假设这是从数据库填充的。 String 证书元素名称 = ...; Certification_Element__c certElement = ...; // 假设这是从数据库填充的。 List 认证尝试 = ...; ``` 根据给出的答案： 1. `certAttement.Certification_Element__r.Name;` 这里应该是 `certAttention.Certification_Element__r.Name;`，用来获取与 `certAttention` 相关联的 `Certification_Element__c` 记录的 `Name` 字段值。 2. `certElement.Certification_Attempts__r.size();` 这里应该是 `certElement.Certification_Attempts__r.size();`，用来获取与 `certElement` 相关联的 `Certification_Attempt__c` 记录的数量。 所以，正确的代码应该是： ```java String 证书元素名称 = certAttention.Certification_Element__r.Name; List 认证尝试 = certElement.Certification_Attempts__r; ``` 希望这些解释能帮助你更好地理解这些问题！如果有任何疑问，随时问我哦。

  ▶ 播放视频 查看详情
• 51

  Knowledge Check (cont.)

  第 132 页

  让我们来聊聊这个问题。当你在Salesforce中编写代码时，有时候可能会不小心超出系统设定的管理器限制。那么，如果发生了这种情况，系统会怎么处理呢？ 首先，系统不会让你继续执行那些超出限制的代码。它会立即停止这些代码的运行，以防止对系统造成更大的影响。然后，系统会抛出一个异常。这个异常是不可恢复的，也就是说，一旦抛出，代码就无法继续执行下去了。 所以，正确的答案是第4个选项：系统会抛出不可恢复的异常。这意味着你需要回去检查你的代码，找出哪里超出了限制，并进行修复，然后才能再次尝试运行。 希望这个解释能帮助你理解当代码超出管理器限制时会发生什么。如果你还有其他问题，随时问我哦！

  ▶ 播放视频 查看详情
• 52

  Trailhead Homework - 133

  第 133 页

  今天我们来聊聊关于Salesforce Trailhead的家庭作业教学要点。首先，Trailhead是一个非常棒的学习平台，特别是对于那些想要复习和提升PD1（Platform Developer 1）技能的同学来说。它提供了很多实用的模块，可以帮助大家更深入地理解我们在课堂上讨论的各种概念和技术。 这次的家庭作业，我给大家推荐了一个特定的Trailhead模块，链接我已经放在这里了：https://trailhead.salesforce.com/projects/quickstart-apex。这个模块主要是关于Apex的基础知识，Apex是Salesforce的一种编程语言，非常强大，可以用来创建复杂的业务逻辑和自定义功能。 这个作业的目的是让你们在课后自己动手实践，通过完成这个模块，你们可以更好地掌握Apex的基础知识，比如如何编写和调试Apex代码，如何理解Apex的语法结构等。记住，这个作业是让你们在课后完成的，课堂上我们会有其他的活动和讨论。 所以，请大家在课后抽时间完成这个Trailhead模块，通过实践来巩固和加深对Apex的理解。如果在学习过程中遇到任何问题，随时可以来问我。希望你们都能从这个作业中学到很多，加油！

  ▶ 播放视频 查看详情
• 53

  Module 5: Use SOQL to Query Your Org's Data

  第 134 页

  同学们，今天我们来聊聊如何在Salesforce中使用SOQL查询来获取收件箱的数据。SOQL，全称是Salesforce Object Query Language，你可以把它想象成一种专门用来和Salesforce数据库对话的语言。 首先，让我们回顾一下上一模块的内容。你们已经学习了Apex的基本语法，对吧？Apex是Salesforce的一种编程语言，它让我们能够编写逻辑来处理数据。今天，我们要把Apex和SOQL结合起来使用。 SOQL的基本语法其实很简单。想象一下，你有一个大箱子，里面装满了各种物品，而SOQL就是帮助你从这个箱子里找到你想要的物品的工具。比如，如果你想找到所有未读的邮件，你可以写一个SOQL查询，就像这样： ```apex SELECT Id, Subject, IsRead FROM EmailMessage WHERE IsRead = false ``` 这个查询的意思是说：“请给我所有未读邮件的ID、主题和是否已读的状态。” 这里的`EmailMessage`是Salesforce中的一个标准对象，代表邮件。 接下来，我们如何把这个SOQL查询嵌入到Apex代码中呢？很简单，你可以使用Apex中的`Database.query`方法，或者直接在Apex中使用SOQL语句。比如： ```apex List unreadEmails = [SELECT Id, Subject, IsRead FROM EmailMessage WHERE IsRead = false]; ``` 这段代码会把所有未读的邮件存储在一个列表中，然后你就可以在Apex中处理这些数据了。 记住，作为初级程序员，你们不需要担心如何分组和汇总结果。这些高级功能我们会在后续的模块中慢慢学习。今天的目标是掌握基本的SOQL语法，并学会如何在Apex中使用它。 好了，这就是今天的内容。希望你们能通过这个简单的例子，理解SOQL的基本用法。如果有任何问题，随时问我哦！

  ▶ 播放视频 查看详情
• 54

  Working with Data in Apex: A Common Pattern - 135

  第 135 页

  今天我们来聊聊在Apex中如何使用数据，特别是处理联系人（Contacts）的常见模式。这个过程其实很简单，主要分为三个步骤：删除、修改和保存。 首先，，从数据库中删除要修改的联系人，。这一步是为了确保我们有一个干净的开始。你可以想象，就像你在整理书架前，先把旧书拿下来一样。在Apex中，我们使用`delete`语句来从数据库中移除这些联系人。 接下来，，修改内存中的联系人对象，。这一步就像你在书桌上修改笔记一样。我们在内存中对联系人对象进行修改，比如更新他们的电话号码或者地址。这些修改暂时只存在于内存中，还没有影响到数据库。 最后，，将修改后的联系人对象持久保存到数据库，。这一步就像你把修改好的笔记重新放回书架。在Apex中，我们使用`update`语句来将这些修改保存回数据库，确保数据的持久性。 ，要点，：在整个过程中，我们始终专注于数据。无论是删除、修改还是保存，每一步都是围绕着数据进行的。记住，数据是Apex编程的核心，理解如何有效地操作数据，是掌握Apex的关键。 希望这个简单的解释能帮助你更好地理解在Apex中处理数据的常见模式。如果你有任何问题，随时问我！

  ▶ 播放视频 查看详情
• 55

  Using SOQL to Query Your Org's Data

  第 136 页

  同学们，今天我们来聊聊如何在Salesforce中使用SOQL查询收件箱的数据。听起来有点复杂，但别担心，我会一步步带你们理解。 首先，SOQL是Salesforce Object Query Language的缩写，简单来说，就是Salesforce用来查询数据的语言。就像你用SQL查询数据库一样，SOQL是用来查询Salesforce中的数据。 ### 第一步：编写基本查询 假设你想查询收件箱中与案例相关的数据，你可以这样写一个基本的SOQL查询： ```sql SELECT Id, Subject, Status FROM Case ``` 这个查询的意思是，从Case对象中选择Id、Subject和Status这三个字段。Case对象在Salesforce中代表的是案例，也就是客户的问题或请求。 ### 第二步：在Apex中处理查询结果 接下来，你需要在Apex代码中处理这个查询的结果。Apex是Salesforce的编程语言，类似于Java。你可以这样写： ```apex List cases = [SELECT Id, Subject, Status FROM Case]; for (Case c : cases) { System.debug('Case Subject: ' + c.Subject); } ``` 这段代码的意思是，首先执行SOQL查询，把结果存到一个叫`cases`的列表中。然后，我们用一个`for`循环遍历这个列表，打印出每个案例的主题。 ### 第三步：动态创建查询 有时候，你可能需要在运行时动态创建查询。比如，用户可能会选择不同的过滤条件。你可以这样写： ```apex String statusFilter = 'New'; String query = 'SELECT Id, Subject, Status FROM Case WHERE Status = :statusFilter'; List cases = Database.query(query); ``` 这里，我们定义了一个`statusFilter`变量，用来存储用户选择的过滤条件。然后，我们把这个变量插入到查询字符串中，最后用`Database.query`方法执行这个动态生成的查询。 ### 总结 所以，总结一下，使用SOQL查询收件箱的数据主要分为三步： 1. 编写基本的SOQL查询。 2. 在Apex中处理查询结果。 3. 在运行时动态创建查询。 希望这些内容对你们有帮助！如果有任何问题，随时问我哦！

  ▶ 播放视频 查看详情
• 56

  The Case Object

  第 137 页

  让我们来聊聊Salesforce中的案例对象，特别是在服务和销售云中的应用。想象一下，AW Computing这家公司，他们使用Salesforce已经有一年多了，主要用来管理销售、营销、支持和人力资源。他们用Sales Cloud来跟踪销售活动，从捕捉潜在客户到将这些潜在客户转化为销售机会，再到销售周期的各个阶段。同时，他们也用Service Cloud来管理和解决客户的问题。 在Service Cloud中，有几个关键的标准对象我们需要了解： 首先是“帐户”对象。这个对象用来存储客户、竞争对手和合作伙伴的信息。每个帐户都会记录姓名、地址和电话号码等基本信息。 接下来是“联系人”对象。这个对象是用来跟踪与你的业务帐户相关的个人。比如，一个客户公司下的具体联系人。 最后，我们重点要讲的是“案例”对象。案例是用来描述客户的反馈、问题或疑问的。每当客户有问题或需要帮助时，就可以创建一个案例来跟踪和解决这个问题。通过案例，支持团队可以有效地管理客户的问题，确保每个问题都能得到妥善的处理和解决。 所以，简单来说，案例对象在Salesforce中扮演着非常重要的角色，特别是在处理客户服务和支持时。它帮助公司更好地理解客户的需求，及时响应和解决问题，从而提升客户满意度。

  ▶ 播放视频 查看详情
• 57

  Module Agenda - 138

  第 138 页

  同学们，今天我们来聊聊Salesforce中的SOQL查询。SOQL，全称是Salesforce Object Query Language，它是用来从Salesforce数据库中检索数据的。我们可以把它想象成一种特殊的语言，用来和Salesforce数据库“对话”。 首先，我们会从查询编辑器开始。在这里，你们可以练习编写一些临时的查询语句。这就像是学习一门新语言的基础语法。你们会学到如何构造查询，比如选择哪些字段，从哪里选择数据，以及如何设置条件。当然，一开始可能会犯一些语法错误，这很正常，就像学走路时可能会摔倒一样。重要的是从错误中学习，慢慢掌握正确的语法。 接下来，我们会把查询语句从查询编辑器移到Apex代码中。Apex是Salesforce的一种编程语言，它允许我们更灵活地处理数据。在这里，你们会学习如何在Apex中执行SOQL查询，以及如何处理查询结果。这就像是把基础语法应用到实际的对话中，让你们的“对话”更加流畅和自然。 最后，我们会学习如何在运行时动态地构建和执行SOQL查询。这意味着查询语句不是固定的，而是根据程序运行时的条件来决定的。这就像是根据不同的情况，灵活地调整你们的“对话”内容，使其更加符合实际需求。 记住，学习SOQL查询就像学习一门新语言，需要时间和实践。不要害怕犯错，每一次错误都是学习的机会。随着你们不断练习，你们会越来越熟练，最终能够自如地与Salesforce数据库“对话”。加油！

  ▶ 播放视频 查看详情
• 58

  Which Fields Can You Query in the Case Object?

  第 139 页

  今天我们来聊聊在Salesforce中如何查询Case对象中的字段。首先，我们需要知道每个字段的API名称和它的类型。API名称就像是字段的身份证，是我们在编写查询时必须使用的。而字段类型则告诉我们这个字段存储的是什么样的数据，比如是文本、数字、日期还是选择列表等。 举个例子，假设我们有一个Case对象，里面有一个字段叫做“Status”，它的API名称可能是“Status__c”。这个字段的类型是picklist，也就是一个选择列表，意味着它有几个预设的选项供用户选择，比如“New”、“In Progress”、“Closed”等。 当我们编写查询时，如果我们要查询所有状态为“New”的Case，我们可能会写一个SOQL查询语句，比如：SELECT Id, Subject FROM Case WHERE Status__c = 'New'。这里，“Status__c”就是字段的API名称，而“New”是这个picklist字段的一个可能值。 了解这些字段的API名称和类型，对于我们编写有效的查询非常重要。特别是当字段类型是日期时间或者picklist时，我们可能需要特别注意查询的格式和条件，以确保我们能够准确地获取到我们需要的数据。 希望这个解释能帮助你更好地理解如何在Salesforce中查询Case对象的字段。如果有任何疑问，随时提问哦！

  ▶ 播放视频 查看详情
• 59

  5-1: Create and Run a Query in the Developer Console

  第 140 页

  同学们，今天我们来学习如何在Salesforce的开发人员控制台中创建并运行查询。这个技能对于理解和管理我们的数据非常重要。 首先，打开你的Salesforce环境，然后点击右上角的设置图标，选择“开发人员控制台”。这是一个强大的工具，可以帮助我们查看和操作Salesforce中的数据。 在开发人员控制台中，你会看到一个查询编辑器。这里，我们可以输入SOQL（Salesforce Object Query Language）语句来查询数据。SOQL是Salesforce中用来查询数据的语言，类似于SQL。 假设我们想要查看所有的Case记录，我们可以在查询编辑器中输入以下SOQL语句： ```sql SELECT Id, CaseNumber, Subject, Status FROM Case ``` 这条语句的意思是：从Case对象中选择Id、CaseNumber、Subject和Status这几个字段。 输入完查询语句后，点击“执行”按钮。开发人员控制台会运行这条查询，并在下方的查询结果窗口中显示所有匹配的Case记录。 通过这种方式，我们可以轻松地查看和审查我们的Case数据。这对于理解数据结构和调试问题非常有帮助。 好了，这就是今天的内容。希望你们能够通过这个练习，更好地理解如何在Salesforce中使用开发人员控制台来查询数据。如果有任何问题，随时提问。我们下次再见！

  ▶ 播放视频 查看详情
• 60

  What is SOQL?

  第 141 页

  让我们来聊聊SOQL，也就是Salesforce对象查询语言。想象一下，你有一个巨大的图书馆，里面装满了各种书籍，每本书都代表Salesforce数据库中的一条记录。现在，如果你想找到一本特定的书，比如一本关于“销售技巧”的书，你会怎么做呢？你会使用图书馆的目录系统，对吧？SOQL就像是Salesforce的目录系统，它帮助你在庞大的数据库中快速找到你需要的信息。 SOQL允许你根据自己设定的条件来查询数据。比如，你可以说：“给我所有姓‘张’的客户记录。”SOQL就会帮你找到这些记录。你可以在开发人员控制台这样的工具中临时进行查询，也可以在你的Apex代码或API中编写SOQL查询，让程序自动执行这些查询。 简单来说，SOQL就是Salesforce用来检索记录的一种语言。它和SQL（结构化查询语言）有点像，但它是专门为Salesforce设计的，所以它更懂得如何与Salesforce的数据打交道。使用SOQL，你可以轻松地从Salesforce数据库中提取出你需要的数据，无论是为了分析、报告还是其他任何目的。

  ▶ 播放视频 查看详情
• 61

  SOQL is Not SQL

  第 142 页

  让我们来聊聊SOQL和SQL之间的一个关键区别，特别是关于“表”的概念。 在SQL中，我们通常操作的是数据库中的“表”。表是由行和列组成的，每一行代表一条记录，每一列代表一个字段。比如，你可能有一个“客户”表，里面有客户的姓名、地址、电话等信息。 但在Salesforce中，SOQL（Salesforce Object Query Language）操作的不是“表”，而是“对象”。你可以把对象想象成Salesforce中的一种特殊表。每个对象都有字段，这些字段相当于表中的列。比如，在Salesforce中，你可能会有一个“客户”对象，里面同样有姓名、地址、电话等字段。 不过，这里有个重要的区别：在SQL中，你可以对表进行各种操作，比如插入、更新、删除等。但在SOQL中，你只能进行SELECT查询。也就是说，SOQL只能用来读取数据，不能用来修改数据。 所以，简单来说，SOQL和SQL在“表”这个概念上的主要区别就是：SQL操作的是表，而SOQL操作的是对象。而且，SOQL只能用来查询数据，不能用来修改数据。 希望这个解释能帮助你更好地理解SOQL和SQL之间的区别。如果你有任何问题，随时问我！

  ▶ 播放视频 查看详情
• 62

  SOQL SELECT Syntax

  第 143 页

  同学们，今天我们来聊聊SOQL的选择语法。SOQL，也就是Salesforce Object Query Language，是我们在Salesforce中用来查询数据的语言。想象一下，它就像是你去图书馆找书时用的检索系统，只不过这里我们找的是数据。 首先，SOQL的SELECT语句是用来从Salesforce的对象中选取数据的。你可以把它想象成在图书馆的目录中搜索特定的书籍。在SOQL中，你只需要指定一个对象，就像你只能在一个图书馆的目录中搜索一样。 WHERE子句是可选的，这就像是你可以在搜索时加上一些条件，比如只找某个作者的书，或者只找某个年份出版的书。如果你用了WHERE子句，那么你就要指定一个条件，这个条件会决定你从对象中筛选出哪些数据。 SOQL还支持一些高级功能，比如计数、分组、排序和限制结果数量。这些功能就像是图书馆的高级搜索选项，比如你可以选择只显示最近出版的书籍，或者只显示某个类别的书籍。 最后，为了确保你的查询语法是正确的，你可以在Salesforce的开发人员控制台的查询编辑器中执行你的查询。这就像是在图书馆的电脑上输入你的搜索条件，然后看看系统能不能找到你想要的书籍。 记住，虽然SOQL支持很多高级功能，但作为初学者，我们只需要掌握基本的SELECT查询就可以了。随着我们学习的深入，我们会逐步接触到更多的高级功能。现在，让我们先从简单的查询开始，慢慢来，不要急。

  ▶ 播放视频 查看详情
• 63

  A SOQL Example

  第 144 页

  同学们，今天我们来聊聊SOQL，也就是Salesforce Object Query Language。SOQL是Salesforce中用来查询数据的语言，就像我们用SQL在数据库中查询数据一样。不过，SOQL是专门为Salesforce设计的，所以它有一些特别的地方。 首先，我们来看一个简单的SOQL查询示例。假设我们想要查询所有状态为“新”的案例（Case）。我们可以这样写： ```sql SELECT CaseNumber, Description, Id, RecordTypeId FROM Case WHERE Status = 'New' ``` 在这个查询中，我们选择了几个字段：CaseNumber（案例编号）、Description（描述）、Id（唯一标识符）和RecordTypeId（记录类型ID）。这些字段都是从Case对象中选取的。 接下来，我们有一个WHERE子句，用来过滤数据。这里我们只想要状态为“新”的案例，所以我们在WHERE子句中指定了`Status = 'New'`。 同学们，记住，SOQL查询总是从某个对象开始，比如这里的Case对象。然后我们选择需要的字段，最后用WHERE子句来过滤数据。 好了，这就是一个基本的SOQL查询。希望大家能理解并记住这些关键点。如果有任何问题，随时问我哦！

  ▶ 播放视频 查看详情
• 64

  WHERE Clause Operators

  第 145 页

  同学们，今天我们来聊聊Salesforce中的WHERE条款操作符。WHERE条款在查询中非常重要，它帮助我们筛选出我们需要的数据。让我们通过两个简单的例子来理解它。 ，第一个例子，：假设我们想要查询一个特定的案件，案件号是'0001001'。这时候，我们可以使用WHERE条款来指定这个条件。具体的SQL语句会是这样的： ```sql SELECT 案件号, 主题 FROM 案件 WHERE 案件号 = '0001001'; ``` 在这个查询中，我们使用了`=`操作符来精确匹配案件号。这样，数据库就会返回案件号正好是'0001001'的那条记录。 ，第二个例子，：现在，假设我们想要查询所有主题中包含“打印机”这个词的案件。这里，我们需要使用`LIKE`操作符，并且配合通配符`%`来匹配任意字符。具体的SQL语句会是这样的： ```sql SELECT 案件号, 主题 FROM 案件 WHERE 主题 LIKE '%打印机%'; ``` 在这个查询中，`%`表示任意数量的任意字符。所以，`'%打印机%'`表示主题中包含“打印机”这个词的所有案件，不管这个词出现在主题的开头、中间还是结尾。 ，总结一下，： - 使用`=`操作符来进行精确匹配。 - 使用`LIKE`操作符和`%`通配符来进行模糊匹配。 这两个例子展示了如何使用WHERE条款来筛选数据。希望你们能通过这些例子更好地理解WHERE条款的使用。如果有任何问题，随时问我哦！

  ▶ 播放视频 查看详情
• 65

  Type-Specific Considerations for the WHERE Clause

  第 146 页

  大家好，今天我们来聊聊在Salesforce中使用SOQL查询时，WHERE子句的一些关键点，特别是关于日期和布尔值的注意事项。 首先，我们来说说日期。在SOQL查询中，你可以指定一个具体的日期，或者使用日期文字。日期文字是一种表示相对时间范围的固定表达式，比如“上个月”或“下一年”。但要注意，Salesforce中的日期时间字段值是以协调世界时（UTC）存储的。这意味着，当你在Salesforce应用中看到这些值时，系统会根据你组织的时区设置自动调整显示时间。所以，如果你的应用需要处理这些时间数据，记得要考虑时区转换的问题。 再来说说布尔值。在SOQL中，布尔值就是简单的True和False。它们用于表示逻辑上的真或假，使用起来相对直接。 关于日期格式，有几个小细节需要注意。比如，使用“今天”这个日期文字时，它实际上是从当天的12:00:00开始，持续24小时。另外，日期值在SOQL中不需要用单引号括起来，直接写日期就可以了。 最后，我们还要知道，SOQL查询中的日期有一个有效范围。最早的日期是1700年1月1日午夜之后，最晚的日期是4000年12月31日午夜之后。超出这个范围的日期在SOQL中是无效的。 希望这些信息对你们在使用Salesforce时有所帮助。如果有更多问题，欢迎随时提问。我们下次再见！

  ▶ 播放视频 查看详情
• 66

  5-2: Write a SOQL Query that Uses a WHERE Clause

  第 147 页

  同学们，现在我们来做一个练习，这个练习是关于如何在SOQL查询中使用WHERE子句的。SOQL是Salesforce Object Query Language的缩写，它是用来从Salesforce数据库中检索数据的。 在这个练习中，你需要自己动手编写一个SOQL查询，使用WHERE子句来过滤数据。WHERE子句可以帮助你根据特定的条件来获取记录，比如日期、选择列表的值或者记录类型等。 举个例子，如果你想要查询所有在2023年创建的客户记录，你可以这样写： ```sql SELECT Name, CreatedDate FROM Account WHERE CreatedDate = THIS_YEAR ``` 这个查询会返回所有在今年创建的客户记录，并且只显示客户的名称和创建日期。 如果你想要查询某个特定记录类型的记录，你可以使用记录类型的ID或者名称来过滤。比如： ```sql SELECT Name FROM Account WHERE RecordType.Name = 'Customer' ``` 这个查询会返回所有记录类型名称为“Customer”的客户记录。 记住，SOQL查询是区分大小写的，所以在写查询的时候要注意大小写。另外，如果你想要了解更多关于如何动态获取记录类型的ID，可以参考提供的额外材料链接。 现在，轮到你们了，尝试自己编写一个SOQL查询，使用WHERE子句来过滤数据。你可以尝试不同的条件，比如日期、选择列表的值或者记录类型，看看你能得到什么样的结果。加油！

  ▶ 播放视频 查看详情
• 67

  Module Agenda - 148

  第 148 页

  同学们，今天我们要学习的是如何在Salesforce中进行数据查询。这个过程分为三个主要步骤，我会一步步带你们了解。 首先，我们会从查询编辑器开始。在这里，你们将学习如何编写临时的查询语句。这个阶段主要是让你们熟悉查询的语法，以及如何识别和修正语法错误。记住，这个阶段我们不需要担心数据分组的问题，所以你们可以专注于掌握基础的查询技巧。 接下来，我们会把在查询编辑器中编写的查询语句迁移到Apex中。Apex是Salesforce的一种编程语言，它允许我们更灵活地处理数据。在这个阶段，你们将学习如何在Apex中执行SOQL查询，并处理返回的数据。这是非常重要的一步，因为它将帮助你们理解如何在更复杂的场景中使用查询。 最后，我们会学习如何在运行时动态地构建和执行SOQL查询。这意味着你们的查询语句可以根据程序运行时的条件来动态变化，这在实际开发中非常有用。通过这个阶段的学习，你们将能够编写更加灵活和强大的查询语句。 好了，这就是我们今天课程的主要内容。希望你们能够通过这三个步骤，逐步掌握在Salesforce中进行数据查询的技巧。如果有任何疑问，随时提问，我会在这里帮助你们。加油！

  ▶ 播放视频 查看详情
• 68

  Working with Existing Case Data in Apex

  第 149 页

  同学们，今天我们来聊聊如何在Apex中使用SOQL来获取Salesforce数据库中的数据。SOQL，全称是Salesforce Object Query Language，你可以把它想象成一种特殊的语言，专门用来和Salesforce数据库对话，告诉它我们需要哪些数据。 首先，利亚·M老师告诉我们，SOQL是一种从Salesforce数据库中获取数据的编程手段。想象一下，数据库就像是一个巨大的图书馆，里面存放着各种各样的书籍（数据）。SOQL就是我们的图书管理员，我们告诉它我们需要哪本书（数据），它就会帮我们找到并拿出来。 现在，假设我们有一个案例（Case）的数据，我们想要从数据库中获取这些数据。我们不会直接拿到一个字符串列表，即使CaseNode看起来像是一个字符串。实际上，SOQL查询返回的是一个sObject的列表。sObject是Salesforce中的一种特殊对象，它代表了数据库中的一条记录。 举个例子，如果我们想要获取所有的案例数据，我们可以写一个SOQL查询，像这样： ```apex List caseList = [SELECT Id, Subject, Status FROM Case]; ``` 这里，`[SELECT Id, Subject, Status FROM Case]`就是我们的SOQL查询。它告诉Salesforce：“请给我所有Case记录的Id、Subject和Status字段。”查询的结果会被存储在一个`List`类型的变量`caseList`中。 所以，同学们，记住，SOQL查询返回的是一个sObject的列表，而不是一个简单的字符串列表。这样，我们就可以在Apex中方便地处理和操作这些数据了。 希望这个解释对你们有帮助！如果有任何问题，随时问我哦！

  ▶ 播放视频 查看详情
• 69

  Syntax for Using a SOQL Query in Apex

  第 150 页

  同学们，今天我们来聊聊在Apex中使用SOQL查询时需要注意的一些关键点。SOQL，也就是Salesforce Object Query Language，是我们在Salesforce中用来查询数据的语言。它非常强大，但也有一些小陷阱需要我们注意。 首先，我们来看一下`Database.query()`这个方法。这个方法允许我们动态地构建和执行SOQL查询。听起来很方便，对吧？但是，使用这个方法时，我们需要特别小心。为什么呢？因为动态查询可能会带来一些安全风险，比如SOQL注入攻击。这就像是给黑客开了一扇门，他们可以通过构造特殊的查询字符串来访问或修改你的数据。 为了避免这种情况，我们应该尽量避免直接在代码中拼接字符串来构建查询。相反，我们可以使用绑定变量或者预定义的查询模板来确保查询的安全性。 另外，使用`Database.query()`时，我们还需要注意查询的性能。动态查询可能会导致查询计划不稳定，从而影响性能。所以，在可能的情况下，尽量使用静态SOQL查询，这样Salesforce可以更好地优化查询性能。 最后，记得在使用`Database.query()`之前，先检查一下查询字符串是否有效，避免运行时错误。我们可以使用`Database.query()`的`try-catch`块来捕获和处理这些错误。 好了，这就是今天关于在Apex中使用SOQL查询的一些警告和注意事项。希望这些信息对你们有所帮助，记得在实际开发中多加注意哦！

  ▶ 播放视频 查看详情
• 70

  Return Types for a SOQL Query in Apex: sObject List

  第 151 页

  同学们，今天我们来聊聊Apex中的SOQL查询返回类型。特别是，我们要关注的是`sBody`和`sBody List`这两种类型。 首先，SOQL查询在Apex中通常返回一个列表。比如，如果你查询`Case`对象，返回的类型就是`List`。这意味着，无论查询结果有多少条记录，返回的都会是一个列表。即使查询没有找到任何匹配的记录，返回的也是一个空列表，而不是`null`。这一点很重要，因为你可以安全地遍历这个列表，而不需要担心空指针异常。 举个例子，假设你写了这样一条SOQL查询： ```apex List cases = [SELECT Id, Subject FROM Case WHERE Status = 'New']; ``` 如果数据库中没有状态为“New”的Case，`cases`变量会是一个空列表，而不是`null`。所以你可以直接使用`cases.size()`来检查是否有记录，而不需要额外的空值检查。 接下来，我们来看看如何优化列表的遍历。假设你有一个`List`，并且你想遍历它。标准的做法是： ```apex for (Case c : cases) { // 处理每个Case } ``` 这种写法是高效的，因为`cases`列表的大小只被评估一次。如果你在循环中每次都调用`cases.size()`，那就会增加不必要的开销。所以，尽量在循环外部评估列表的大小，这样可以提高代码的性能。 总结一下，SOQL查询返回的列表类型是`List`，即使没有记录也不会返回`null`。在遍历列表时，尽量在循环外部评估列表的大小，这样可以优化代码的性能。 希望这些内容对你们理解Apex中的SOQL查询有所帮助！如果有任何问题，随时问我。

  ▶ 播放视频 查看详情
• 71

  Return Types for SOQL Queries in Apex: sObject

  第 152 页

  同学们，今天我们来聊聊Apex中的SOQL查询。SOQL是Salesforce Object Query Language的缩写，它允许我们从Salesforce数据库中检索数据。 假设我们有一个案例（Case）对象，我们想要查询一个特定的案例。我们可以使用SOQL来做到这一点。比如，我们想要查询案例编号为'00001007'的案例，我们可以这样写： ```apex Case aCase = [SELECT Subject FROM Case WHERE CaseNumber = '00001007']; ``` 这里，`aCase`是一个变量，它存储了我们查询到的单个案例记录。我们使用了`SELECT`语句来选择案例的`Subject`字段，并且通过`WHERE`子句来指定我们要查询的案例编号。 但是，同学们要注意，如果我们不能保证每次查询都只返回一个案例记录，那么我们应该将查询结果存储在一个列表中，而不是单个变量中。比如： ```apex List caseList = [SELECT Subject FROM Case WHERE CaseNumber = '00001007']; ``` 这样，即使查询返回了多个记录，我们也可以安全地处理它们。 最后，老师要提醒大家，虽然我们在这里没有使用`LIMIT`关键字，但在实际开发中，如果你知道你要查询的记录ID，你仍然可以直接使用它来获取单个记录。这样可以避免不必要的查询和性能问题。 好了，今天的课程就到这里，希望大家能够理解并掌握这些知识点。如果有任何疑问，欢迎随时提问。

  ▶ 播放视频 查看详情
• 72

  The Wrong Return Type

  第 153 页

  今天我们来聊聊Salesforce中的SOQL查询和返回类型的问题。这个问题听起来有点技术性，但其实很简单，只要你理解了几个关键点。 首先，SOQL是Salesforce Object Query Language的缩写，它是用来从Salesforce数据库中查询数据的。当你写一个SOQL查询时，你通常会期望它返回一些数据，对吧？但有时候，事情并不总是如我们所愿。 假设你写了一个查询，期望它返回一个特定的记录。你可能会这样写： ```apex Case aCase = [SELECT Id, Subject FROM Case WHERE Id = 'someId']; ``` 这里，你期望查询返回一个Case对象，并且你把它赋值给了一个单一的Case变量`aCase`。但是，如果查询没有返回任何记录，或者返回了多个记录，Salesforce就会抛出一个异常。 为什么呢？因为Salesforce认为你期望的是一个单一的记录，所以它尝试把查询结果赋值给一个单一的变量。如果查询结果不符合这个预期，它就会告诉你：“嘿，这里有问题！” 那么，怎么解决这个问题呢？很简单，如果你不确定查询会返回多少条记录，或者你希望处理多条记录，你应该使用一个列表来存储查询结果。比如： ```apex List caseList = [SELECT Id, Subject FROM Case WHERE Id = 'someId']; ``` 这样，无论查询返回多少条记录，甚至是零条，都不会有问题。你可以安全地遍历这个列表，处理每一条记录。 总结一下，关键点就是：如果你确定查询只会返回一条记录，你可以用单一的变量来存储结果。但如果你不确定，或者希望处理多条记录，最好使用列表。这样可以避免异常，让你的代码更加健壮。 希望这个解释对你有帮助！如果有任何问题，随时问我。

  ▶ 播放视频 查看详情
• 73

  5-3: Write and Execute a SOQL Query in Apex

  第 154 页

  同学们，今天我们来学习如何在Apex中编写并执行SOQL查询，并将查询结果打印到调试日志中。SOQL是Salesforce Object Query Language的缩写，它是一种专门用于查询Salesforce数据的语言。 首先，我们需要了解如何查询单个案例并将其打印到调试日志中。假设我们有一个名为“Case”的对象，我们想要查询一个特定的案例。我们可以使用以下代码： ```apex Case singleCase = [SELECT Id, Subject, Status FROM Case LIMIT 1]; System.debug('单个案例信息: ' + singleCase); ``` 在这段代码中，我们使用`SELECT`语句从`Case`对象中选择`Id`、`Subject`和`Status`字段，并且使用`LIMIT 1`来确保只查询一个案例。然后，我们使用`System.debug`将查询结果打印到调试日志中。 接下来，我们来看看如何查询多个案例并将它们打印到调试日志中。我们可以使用以下代码： ```apex List multipleCases = [SELECT Id, Subject, Status FROM Case LIMIT 5]; for (Case c : multipleCases) { System.debug('案例信息: ' + c); } ``` 在这段代码中，我们同样使用`SELECT`语句从`Case`对象中选择`Id`、`Subject`和`Status`字段，但这次我们使用`LIMIT 5`来查询最多5个案例。然后，我们使用一个`for`循环遍历查询结果，并使用`System.debug`将每个案例的信息打印到调试日志中。 通过这种方式，我们可以在Apex中轻松地编写和执行SOQL查询，并将结果打印到调试日志中，以便进行调试和分析。希望这些内容对你们有所帮助！如果有任何问题，随时提问。

  ▶ 播放视频 查看详情
• 74

  Working with Selected Field Values

  第 155 页

  同学们，今天我们来聊聊Salesforce中的一个重要概念——如何使用选定的字段值。这个知识点听起来可能有点复杂，但其实很简单，我会用最通俗的语言来解释。 首先，记住一个关键点：在Salesforce中，你只会得到你想要的。这是什么意思呢？就是说，当你从数据库中查询数据时，你只会获取到你明确指定的那些字段。如果你没有选择某个字段，那么即使这个字段在数据库中有值，你也不会得到它。 现在，让我们来看一个例子。假设你正在处理一个Case对象，你写了一个SOQL查询来获取一些Case记录。在这个查询中，你只选择了Case的Subject和Description字段。但是，如果你尝试在代码中访问Case的Submit字段，会发生什么呢？你会遇到一个异常，提示你“System.SObidExcept：通过SOQL检索SObid行，而未查询请求的字段：Case.Submit”。这是因为你没有在查询中选择Submit字段，所以Salesforce无法提供这个字段的值给你。 那么，为什么有时候我们会想要分配一个尚未选择的字段呢？一个可能的原因是，你可能不关心这个字段在数据库中的当前值，但你确实想要更新它。在这种情况下，你可以为这个字段分配一个新值，然后执行一个DML操作（比如更新操作），将这个更改保存回数据库。 总结一下，使用选定的字段值时，一定要确保你在查询中选择了所有你需要的字段。如果你尝试访问一个未选择的字段，Salesforce会抛出异常。同时，如果你想要更新某个字段，即使你之前没有选择它，你也可以在代码中为它分配一个新值并保存更改。 希望这个解释对你们有帮助！如果有任何问题，随时提问。

  ▶ 播放视频 查看详情
• 75

  Exceeding the Heap Size Limit

  第 156 页

  同学们，今天我们来聊聊Salesforce中的一个常见问题——堆大小限制。这个问题可能会在你处理大量数据时出现，特别是当你试图一次性加载太多数据到内存中时。 首先，什么是堆大小限制呢？简单来说，就是Salesforce为了防止系统资源被过度使用，对每次操作可以使用的内存量设置了一个上限。如果你尝试加载的数据超过了这个上限，系统就会抛出一个错误，告诉你“堆大小超过了限制”。 那么，我们如何防止这种情况发生呢？这里有几个关键点： 1. ，使用过滤器，：当你从数据库中检索数据时，尽量使用WHERE子句来过滤掉不需要的数据。比如，如果你只需要查看某个特定状态的案例，就可以在SOQL查询中加入状态条件，这样返回的数据量就会大大减少。 2. ，分批处理数据，：如果确实需要处理大量数据，可以考虑使用SOQL的FOR循环来分批检索数据。这样，每次只处理一部分数据，就不会一次性占用太多内存。 3. ，优化查询，：在编写SOQL查询时，尽量只选择你真正需要的字段，而不是使用“SELECT *”来获取所有字段。这样可以减少每次查询返回的数据量。 目前，对于你们来说，最直接的方法就是使用WHERE子句来过滤数据。接下来，我们会学习如何使用SOQL FOR循环来更高效地处理大量数据。 记住，合理使用这些技巧，可以帮助你避免堆大小限制的问题，让你的Salesforce应用运行得更加顺畅。希望这些内容对你们有所帮助！如果有任何问题，随时提问哦。

  ▶ 播放视频 查看详情
• 76

  Using List<sObject> Iteration Variable

  第 157 页

  同学们，今天我们来聊聊在Salesforce中使用列表进行迭代的一些技巧和注意事项。 首先，想象一下你有一个装满200个sObjects的列表。每次你想对这个列表做点什么，比如更新或者删除，你都需要通过一个for循环来遍历这个列表。这里的关键是，每次循环都会处理整个200个sObjects的列表。这听起来可能有点复杂，但如果你需要在循环内部使用TLR（Transaction Limit and Rollback）语句，这种方法是非常有用的。因为每个TLR语句可以一次性处理整个sObjects列表，这样可以提高效率，减少资源消耗。 接下来，Lydia老师提到的一个非常重要的点是，将查询放在循环内部和放在循环外部是有很大区别的。如果你把查询放在循环内部，每次循环都会执行一次查询，这可能会导致性能问题，尤其是在处理大量数据时。相反，如果你把查询放在循环外部，你只需要执行一次查询，然后在循环中处理这些数据，这样可以大大提高效率。 所以，记住，当你在处理sObjects列表时，考虑你的查询位置和循环的使用方式，这对于优化你的代码性能是非常关键的。希望这些信息对你们有所帮助！如果有任何疑问，随时提问哦！

  ▶ 播放视频 查看详情
• 77

  What Happens with a List<sObject> Iteration Variable?

  第 158 页

  让我们来聊聊在Salesforce中，当我们处理大量的数据时，如何有效地使用列表迭代变量来避免堆大小限制的问题。 首先，想象一下你有一个包含很多记录的列表，比如200条记录。如果你一次性处理所有这些记录，可能会遇到堆大小限制的问题，这就像是你试图一次性搬太多东西，结果手忙脚乱，甚至可能搬不动。 为了避免这种情况，我们可以使用一种叫做“分块处理”的方法。这意味着我们将这个大列表分成几个小块，每次只处理一小块。这样，每次处理的记录数量就减少了，堆大小也就不会那么容易达到限制了。 具体来说，我们可以使用一个for循环来遍历这个列表。但是，我们不是一次性处理整个列表，而是每次只处理200条记录。这样，即使列表中有更多的记录，我们也可以分批次处理，每次只处理200条，直到所有记录都被处理完毕。 举个例子，假设我们有一个包含205条记录的列表。我们可以这样处理： - 第一次循环，处理前200条记录。 - 第二次循环，处理剩下的5条记录。 这样，我们就避免了堆大小限制的问题，同时也能有效地处理所有的记录。 总结一下，使用列表迭代变量和分块处理的方法，可以帮助我们在Salesforce中高效地处理大量数据，避免堆大小限制的问题。希望这个解释对你有帮助！

  ▶ 播放视频 查看详情
• 78

  Module Agenda - 159

  第 159 页

  同学们，今天我们来聊聊Salesforce中的SOQL查询。SOQL，全称是Salesforce Object Query Language，是Salesforce中用来查询数据的语言。我们可以把它想象成一种特殊的“问问题”的方式，用来从Salesforce的数据库中获取我们需要的信息。 首先，我们会从查询编辑器开始。这是一个非常友好的工具，可以帮助我们练习编写SOQL查询。在这里，你可以尝试不同的查询语句，看看它们是如何工作的。这个阶段，我们不需要担心分组（Group By）这样的高级功能，主要是熟悉基本的语法和避免常见的错误。 接下来，我们会把在查询编辑器中编写的查询语句搬到Apex代码中。Apex是Salesforce的一种编程语言，它允许我们在Salesforce平台上编写更复杂的逻辑。在Apex中处理SOQL查询，意味着我们可以动态地构建查询语句，根据不同的条件来获取数据。 最后，我们会学习如何在运行时动态地确定和执行SOQL查询。这意味着我们的查询语句可以根据用户的操作或其他条件在程序运行时动态生成，这样我们的应用就可以更加灵活和智能。 记住，学习SOQL就像学习一门新语言，一开始可能会有些挑战，但随着练习的增加，你会越来越熟练。所以，不要害怕犯错，多尝试，多练习，你会很快掌握它的！

  ▶ 播放视频 查看详情
• 79

  Binding in the WHERE Clause

  第 160 页

  让我们来聊聊Apex中的SOQL和SOSL查询，特别是关于“绑定”这个概念。想象一下，你正在写一个查询，想要从Salesforce数据库中获取一些数据。但是，你希望这个查询能够根据不同的情况动态变化，比如根据用户输入或者程序中的变量来调整查询条件。这时候，“绑定”就派上用场了。 绑定，简单来说，就是让你在SOQL或SOSL查询中使用Apex代码中的变量或表达式。你只需要在变量或表达式前面加上一个冒号（:），Apex解析器就会在执行查询之前，先评估这个变量或表达式的值，然后用这个值去执行查询。 举个例子，假设你有一个变量叫做`caseNumber`，你想根据这个变量的值来查询特定的案例记录。你可以这样写： ```apex String caseNumber = &#39;00001000&#39;; List cases = [SELECT Id FROM Case WHERE CaseNumber = :caseNumber]; ``` 在这个例子中，`caseNumber`变量被绑定到了SOQL查询中。Apex会先评估`caseNumber`的值，然后用这个值去执行查询，找出所有`CaseNumber`等于`00001000`的案例记录。 绑定不仅可以用在简单的变量上，还可以用在更复杂的表达式上。比如，你可以这样写： ```apex List cases = [SELECT Id FROM Case WHERE CaseNumber = :(&#39;0000&#39; + &#39;1000&#39;)]; ``` 这里，Apex会先计算表达式`(&#39;0000&#39; + &#39;1000&#39;)`的值，得到`00001000`，然后用这个值去执行查询。 总的来说，绑定是一个非常强大的工具，它让你能够动态地构建查询，根据程序中的变量或表达式的值来调整查询条件。这样，你的代码就更加灵活和强大了。 希望这个解释对你有帮助！如果你有任何问题，随时问我哦！

  ▶ 播放视频 查看详情
• 80

  Creating and Executing a Query at Run Time

  第 161 页

  今天我们来聊聊Salesforce中的动态SOQL。动态SOQL是一种在运行时通过Apex代码创建SOQL查询的技术。这种技术非常有用，因为它可以让你的应用更加灵活。比如说，你可以根据用户的输入来动态生成查询语句。 想象一下，你正在开发一个搜索功能，用户可以在搜索框中输入任何他们想要查找的内容。使用动态SOQL，你可以根据用户的输入来构建查询语句，而不是预先写好固定的查询。这样，你的应用就能更好地响应用户的需求。 不过，使用动态SOQL时，有一个非常重要的安全问题需要注意，那就是SOQL注入。SOQL注入是一种攻击手段，攻击者可以通过输入特定的字符串来操纵你的SOQL查询，从而执行他们想要的数据库操作。为了防止这种情况发生，你需要对用户输入的内容进行严格的检查和处理。 Salesforce提供了一个非常方便的方法来防止SOQL注入，那就是使用`String.escapeSingleQuotes`方法。这个方法会在所有的单引号前面加上一个反斜杠，这样单引号就不会被误认为是查询语句的一部分，而是被当作普通的字符串来处理。 总结一下，动态SOQL是一个非常强大的工具，可以让你的应用更加灵活和强大。但是，使用它的时候一定要注意安全问题，特别是要防止SOQL注入。通过使用`String.escapeSingleQuotes`方法，你可以有效地保护你的应用免受这种攻击。 如果你对这个话题感兴趣，可以访问Salesforce的官方文档，那里有更多详细的资料和示例代码。希望今天的讲解对你有帮助，我们下次再见！

  ▶ 播放视频 查看详情
• 81

  5-4: Write a Dynamic Query in Apex

  第 162 页

  同学们，今天我们来学习如何在Apex中编写动态查询。动态查询是一个非常强大的工具，它允许我们在运行时根据不同的条件来构建查询语句。这样，我们的代码就可以更加灵活和适应性强。 首先，我们来看一下如何使用绑定变量来指定过滤条件。绑定变量是一种在查询中动态插入值的方式。比如，我们有一个案例列表，我们想要根据用户输入的状态来过滤这些案例。我们可以这样写： ```apex String status = &#39;Open&#39;; // 假设这是用户输入的状态 List cases = [SELECT Id, Subject FROM Case WHERE Status = :status]; ``` 在这个例子中，`:status`就是一个绑定变量，它会在运行时被替换为用户输入的实际值。 接下来，我们来看一下如何使用`Database.select()`方法来修复任务1中的代码。假设我们有一个错误的代码片段，它试图查询所有状态为“Open”的案例，但是查询语句写错了。我们可以这样修复它： ```apex String query = &#39;SELECT Id, Subject FROM Case WHERE Status = \&#39;Open\&#39;&#39;; List cases = Database.query(query); ``` 在这个修复后的代码中，我们使用了`Database.query()`方法来执行动态查询。这样，我们就可以在运行时构建查询语句，并且确保它的正确性。 最后，我们来看一下如何使用绑定变量按记录类型进行查询。假设我们想要查询所有记录类型为“Customer Support”的案例，我们可以这样写： ```apex String recordTypeName = &#39;Customer Support&#39;; List cases = [SELECT Id, Subject FROM Case WHERE RecordType.Name = :recordTypeName]; ``` 在这个例子中，`:recordTypeName`就是一个绑定变量，它会在运行时被替换为实际的记录类型名称。 好了，同学们，这就是我们今天要学习的内容。通过使用绑定变量和`Database.select()`方法，我们可以编写出更加灵活和强大的动态查询。希望你们能够掌握这些技巧，并在实际开发中灵活运用。如果有任何问题，随时问我哦！

  ▶ 播放视频 查看详情
• 82

  Key Takeaways - 163

  第 163 页

  同学们，今天我们来聊聊Salesforce中的SOQL查询语言。SOQL，全称是Salesforce Object Query Language，它是Salesforce平台上用来查询数据的语言。你可以把它想象成一种特殊的“搜索工具”，帮助我们快速找到存储在Salesforce中的数据。 首先，SOQL查询可以在两种情况下运行：一种是临时运行，就像你突然想查个数据，直接在开发者控制台里输入查询语句；另一种是在Apex代码中运行，Apex是Salesforce的编程语言，SOQL查询嵌入在Apex代码里，可以自动化地获取数据。 在Apex中，SOQL查询通常会返回一个sObject的列表。sObject是Salesforce中所有对象的基类，你可以把它理解为一个“数据容器”，里面装着各种字段和数据。 接下来，我们来说说SOQL FOR循环。当你在Apex中使用SOQL FOR循环时，如果循环的迭代变量是一个列表，那么每次循环处理的最大记录数是200条。这是Salesforce的一个限制，目的是防止一次性处理太多数据导致系统资源耗尽。 SOQL还支持在WHERE子句中使用绑定变量和绑定表达式。绑定变量就像是一个占位符，你可以在运行时给它赋值，这样查询就更加灵活了。比如，你可以根据用户输入的条件动态生成查询语句。 在Apex中，你还可以使用`Database.query()`方法来执行动态SOQL查询。动态查询的意思是说，查询语句是在代码运行时才生成的，而不是事先写死的。这给了我们更大的灵活性，可以根据不同的情况生成不同的查询。 最后，我们再来回顾一下SOQL中的一些关键限制，也就是所谓的“州长限制”。这些限制是为了保证系统的稳定性和性能，比如每次查询返回的记录数、每次事务中可以执行的查询次数等。 好了，今天的课程就到这里。希望大家对SOQL有了更清晰的理解。如果有任何问题，随时提问哦！

  ▶ 播放视频 查看详情
• 83

  Knowledge Check - 164

  第 164 页

  让我们来一步步解答这些问题。 首先，关于查询“选择 * 来自案例”的问题。在Salesforce中，SOQL（Salesforce Object Query Language）不支持使用“*”来选择所有字段。这意味着开发人员不能简单地写“SELECT *”来获取所有字段。相反，他们需要明确列出他们想要查询的字段。例如，如果他们想要查询案例的“CaseNumber”和“Subject”字段，他们应该写“SELECT CaseNumber, Subject FROM Case”。 接下来，关于WHERE子句支持的通配符。在SOQL中，LIKE操作符支持使用通配符。例如，如果你想查找所有以“A”开头的案例主题，你可以写“SELECT Subject FROM Case WHERE Subject LIKE &#39;A%&#39;”。这里的“%”就是一个通配符，代表任意数量的字符。 然后，关于SOQL支持变量绑定的问题。SOQL确实支持在多个子句中使用变量绑定，包括WHERE子句。这意味着你可以在查询中使用变量来动态地构建查询条件。例如，如果你有一个变量“searchTerm”，你可以这样写查询：“SELECT Name FROM Account WHERE Name LIKE :searchTerm”。这里的“:searchTerm”就是变量绑定，它允许你在运行时将变量的值插入到查询中。 最后，关于如何将queryString指定为Database.query()的参数。假设你已经有一个字符串变量queryString，它包含了你的SOQL查询，比如“SELECT Name FROM Account”。你可以直接将这个变量传递给Database.query()方法，如下所示：“Database.query(queryString);”。这样，Salesforce就会执行这个查询并返回结果。 希望这些解释能帮助你更好地理解SOQL的使用。如果有任何疑问，随时提问！

  ▶ 播放视频 查看详情
• 84

  Trailhead Homework - 165

  第 165 页

  同学们，今天我们来聊聊关于Salesforce的Trailhead家庭作业。Trailhead是一个非常棒的学习平台，特别是对于复习PD1（Platform Developer 1）技能来说。今天我要给大家介绍两个特别有用的模块，它们能帮助你们更深入地理解我们课堂上讨论的内容。 第一个模块是关于Apex和数据库的。Apex是Salesforce的一种编程语言，专门用来处理数据库操作。这个模块会教你如何用Apex来查询和操作Salesforce数据库中的数据。这对于想要深入了解Salesforce后端开发的同学来说，是非常宝贵的资源。 第二个模块是关于数据库基础知识的，特别是针对.NET开发者的。虽然这个模块主要是为.NET开发者设计的，但里面的数据库基础知识对任何开发者都是通用的。它会帮助你理解数据库的基本概念，比如表、记录、字段等，这些都是处理任何数据库系统的基础。 这两个模块都是作为家庭作业来完成的，不需要在课堂上做。你们可以在课后自己安排时间，按照自己的节奏来学习。记得，学习是一个持续的过程，不要急于求成，慢慢来，确保你真正理解了每一个概念。 好了，这就是今天的家庭作业要点。希望你们能从这些模块中学到很多，为你们的Salesforce开发之路打下坚实的基础。加油！

  ▶ 播放视频 查看详情
• 85

  Module 6: Use SOQL to Query Parent-Child Relationships

  第 166 页

  同学们，今天我们来聊聊如何在Salesforce中使用SOQL进行查询，特别是涉及到亲子关系的时候。SOQL，也就是Salesforce Object Query Language，是Salesforce中用来查询数据的语言，它和SQL有点像，但更专注于Salesforce的数据模型。 首先，我们得明白什么是亲子关系。在Salesforce中，对象之间可以有父子关系，比如一个客户（Account）可以有多个联系人（Contact），这里客户就是父对象，联系人就是子对象。理解这种关系对我们写查询非常重要。 接下来，我们来看看如何用SOQL来查询这种关系。假设我们想查询所有客户以及他们的联系人，我们可以这样写： ```sql SELECT Name, (SELECT LastName FROM Contacts) FROM Account ``` 这里，`Name`是客户的名字，`Contacts`是客户下的联系人列表。注意，我们在查询客户的同时，也查询了每个客户的联系人列表。这就是所谓的亲子关系查询。 现在，假设我们想把这种查询嵌入到Apex代码中。Apex是Salesforce的编程语言，它允许我们编写更复杂的逻辑。我们可以这样写： ```apex List accountsWithContacts = [SELECT Name, (SELECT LastName FROM Contacts) FROM Account]; for(Account acc : accountsWithContacts) { System.debug(&#39;Account Name: &#39; + acc.Name); for(Contact con : acc.Contacts) { System.debug(&#39;Contact Last Name: &#39; + con.LastName); } } ``` 这段代码首先查询了所有客户及其联系人，然后遍历每个客户，打印出客户的名字和每个联系人的姓氏。 同学们，记住，作为初级程序员，我们不需要一开始就掌握所有复杂的查询技巧，比如分组和汇总。先从简单的开始，慢慢来，随着经验的积累，你会越来越熟练的。好了，今天的课程就到这里，希望你们能理解并掌握这些基础知识。如果有任何问题，随时问我哦！

  ▶ 播放视频 查看详情
• 86

  Module Objectives

  第 167 页

  同学们，今天我们要聊的是一个非常有趣的话题——如何在Salesforce中使用SOQL进行更复杂的查询，特别是涉及到父子关系的查询。这些查询我们称之为“关系连接”。 首先，让我们回顾一下，到目前为止，你们已经学会了如何编写一些基本的SOQL查询，这些查询主要是从单个对象中选取数据，就像你们在SQL中做的那样。但是，Salesforce中的数据模型是非常丰富的，很多时候数据是分布在多个相关联的对象中的。比如，一个客户可能有多个订单，这就是一个典型的父子关系。 那么，如何在SOQL中处理这种关系呢？这里就需要用到“关系连接”了。简单来说，关系连接允许你在一个查询中同时访问父对象和子对象的数据。这样，你就可以一次性获取到所有相关的信息，而不需要多次查询。 举个例子，假设我们有一个客户对象（Customer）和一个订单对象（Order），每个客户可以有多个订单。如果我们想要获取某个客户的所有订单信息，我们可以这样写SOQL查询： ```sql SELECT Name, (SELECT OrderNumber, OrderDate FROM Orders) FROM Customer WHERE Id = &#39;001xx000003DGb0&#39; ``` 在这个查询中，`Orders`是`Customer`对象的子对象。通过这种嵌套查询的方式，我们可以一次性获取到客户的基本信息和他们的所有订单信息。 最后，当我们获取到这些数据后，如何在Apex中处理这些关系查询的结果呢？这可能会比处理简单的SELECT查询要复杂一些，因为你需要遍历这些嵌套的数据结构。但不用担心，随着我们课程的深入，我会一步步教你们如何操作。 好了，今天的课程就到这里。希望你们对关系连接有了一个初步的了解。下次课我们会更深入地探讨这个话题，并做一些实际的练习。记得复习今天的内容哦！

  ▶ 播放视频 查看详情
• 87

  Module Agenda - 168

  第 168 页

  同学们，今天我们来聊聊Salesforce中的一个非常有趣且实用的功能——关系查询，特别是关于如何查询亲子关系。这个功能在我们处理家庭数据或者任何需要关联两个对象的场景中都非常有用。 首先，让我们从理解“关系预设”开始。在Salesforce中，关系预设是指我们如何定义和存储两个对象之间的关系。比如，我们可以设定一个孩子对象和一个父母对象，然后定义它们之间的关系。这样，当我们查询一个孩子时，我们也能轻松地获取到他的父母信息，反之亦然。 接下来，我们会通过一些实际的例子来询问孩子与父母的关系，以及父母与孩子的关系。这不仅能帮助我们理解数据是如何在Salesforce中相互关联的，还能让我们更好地掌握如何利用这些关系来优化我们的查询。 在模块6中，我们将重点学习如何使用SOQL（Salesforce Object Query Language）来查询这些亲子关系。SOQL是Salesforce中用于查询数据的语言，它非常强大，可以帮助我们精确地获取我们需要的信息。 最后，作为教师，我会特别注意激发大家对学习关系查询语法的兴趣和需求。我们还会一起设置一个认证应用程序，这样大家就可以在实际操作中应用今天学到的知识了。 希望今天的课程能让大家对Salesforce中的关系查询有一个清晰的理解，并能在未来的工作中灵活运用。如果有任何疑问，随时提问哦！

  ▶ 播放视频 查看详情
• 88

  Understanding The Certification Application - 169

  第 169 页

  同学们，今天我们来聊聊Salesforce中的认证申请流程。想象一下，你是一家名为AW的公司的培训经理，你需要跟踪哪些服务技术人员参加了你们的课程，并且他们是否尝试或获得了AW的认证。我们不会跟踪他们的Salesforce认证，只关注AW的认证。 首先，我们来看第一个问题，对应的是紫色行的对象。在这个场景中，我们已经创建了“帐户”和“联系人”这两个对象。每个“联系人”都会关联到一个“帐户”，这样我们就知道每个技术人员属于哪个公司。 接下来是第二个问题，引入了绿色行的对象。这里我们创建了“与会者”对象。每个“与会者”都会关联到一个“授课内容”（也就是具体的课程实例）和一个“联系人”（即参加课程的技术人员）。这样，我们就可以知道哪些技术人员参加了哪些课程。 最后是第三个问题，对应的是蓝色行的对象。这里我们修改了“尝试”对象。目前，这个修改不会直接影响其他记录，但如果未来我们能够自动确定并创建“证书持有”对象，那就更好了。这意味着，如果技术人员通过了认证，系统可以自动为他们生成证书。 总结一下，通过这三个问题，我们逐步引入了“帐户”、“联系人”、“与会者”和“尝试”这几个对象，并且理解了它们之间的关系。这样，我们就可以有效地跟踪技术人员的认证申请情况了。希望这个讲解对你们有所帮助！

  ▶ 播放视频 查看详情
• 89

  Reminder: What is an sObject Relationship?

  第 170 页

  今天我们来聊聊Salesforce中的s对象关系。想象一下，如果你有一个公司，这个公司有很多员工。在Salesforce中，我们可以把公司看作是一个“帐户”对象，而员工则是“联系人”对象。这里，“帐户”和“联系人”之间就存在一种关系，我们称之为s对象关系。 这种关系是预先在Salesforce的模式中定义好的。也就是说，Salesforce知道“帐户”可以有多个“联系人”，但一个“联系人”只能属于一个“帐户”。这就是我们所说的0对多关系。 在Salesforce的用户界面中，你可以很容易地看到这种关系。比如，当你查看一个“帐户”记录时，你会看到一个相关列表，里面列出了所有属于这个“帐户”的“联系人”。这就是s对象关系在UI中的体现。 但是，有一点需要注意，你不能随意地根据城市或其他条件来建立这种关系。关系必须在Salesforce的模式中预先定义好。这意味着，如果你想在Apex代码中使用这些关系，Salesforce必须已经知道这些关系是数据库模式的一部分。 简单来说，s对象关系就是Salesforce中不同对象之间的连接方式，它们帮助我们构建和管理数据之间的关系。希望这个解释能帮助你更好地理解s对象关系！

  ▶ 播放视频 查看详情
• 90

  Review of Types of Relationships

  第 171 页

  让我们来聊聊Salesforce中的两种关系类型：标准关系和自定义关系。 首先，标准关系就像是Salesforce已经为你准备好的“现成”的关系。它们是在两个标准对象之间预先定义好的，你不需要做任何额外的设置就可以直接使用。比如说，Salesforce中的“账户”和“联系人”之间就有一个标准关系。这意味着，当你创建一个账户时，你可以直接关联到多个联系人，而不需要自己去定义这种关联方式。 然后，我们来看看自定义关系。这种关系是你根据自己的业务需求来创建的。Salesforce允许你定义对象之间的特定关系，以满足你的独特需求。举个例子，假设你有一个“课程”对象和一个“认证”对象，你可能希望创建一个自定义关系来跟踪哪些课程是获得某个认证所必需的。这样，你就可以根据自己的业务流程来定制Salesforce的功能。 简单来说，标准关系是Salesforce自带的，而自定义关系是你自己设计的。两者都非常有用，但选择哪一种取决于你的具体需求。希望这个解释能帮助你更好地理解这两种关系类型！

  ▶ 播放视频 查看详情
• 91

  What is a Relationship Query?

  第 172 页

  让我们来聊聊关系查询。想象一下，你有一个大箱子，里面装满了各种小盒子。每个小盒子里又有更小的盒子。现在，如果你想找到某个特定的东西，你可能需要打开一个又一个盒子，直到找到它。在Salesforce中，关系查询就像是这个过程。 关系查询是一种方法，它允许我们从一个对象（比如一个大盒子）穿越到另一个相关的对象（比如一个小盒子），以获取我们想要的信息。这些对象之间通过一种叫做“外部键”的东西连接起来，就像盒子之间的标签或线索。 举个例子，假设我们有一个“课程”对象和一个“参加者”对象。如果我们想知道哪些课程将在今年6月交付，我们可以使用关系查询来查找与“课程”对象相关的“交付日期”信息。同样，如果我们想知道某个参加者参加了哪些课程，我们也可以使用关系查询来穿越“参加者”和“课程”之间的关系，找到答案。 关系查询的一个有趣特点是，虽然你只能直接访问一个级别的“孩子”对象（就像你只能直接打开一个盒子），但你可以访问多达五个级别的“祖先”对象（就像你可以追溯到一个盒子的前五个大盒子）。这给了我们很大的灵活性来获取我们需要的数据。 希望这个解释能帮助你理解关系查询的概念。如果你有任何问题，随时问我！

  ▶ 播放视频 查看详情
• 92

  Module Agenda - 173

  第 173 页

  同学们，今天我们来聊聊Salesforce中的一个非常有趣且实用的功能——使用SOQL查询来探索数据之间的关系，特别是亲子关系。这个模块的内容会帮助你理解如何在Salesforce中查询和展示这些关系。 首先，让我们简单了解一下什么是关系预设。在Salesforce中，数据之间的关系是通过关系字段来建立的。比如，一个“孩子”记录可能会有一个字段指向“父母”记录，这样我们就建立了一个从孩子到父母的关系。 接下来，我们会通过两个步骤来探索这种关系： 1. 询问孩子与父母的关系：这里我们会学习如何从一个孩子的记录出发，查询出与之相关的父母记录。 2. 询问父母与孩子的关系：然后，我们会反过来，从父母的记录出发，查询出所有相关的孩子记录。 在模块6中，我们将重点学习如何使用SOQL（Salesforce Object Query Language）来执行这些查询。SOQL是Salesforce中用于查询数据的语言，非常强大。 教师注意事项：在开始教学时，我们会先从孩子到父母的查询开始，因为这种查询在语法上相对简单一些，更容易理解和掌握。掌握了这个之后，我们再逐步过渡到更复杂的父母到孩子的查询。 希望这个简短的介绍能帮助你们对即将学习的内容有一个清晰的认识。接下来，我们会一步步深入，确保每个人都能跟上并掌握这些技能。准备好了吗？让我们开始吧！

  ▶ 播放视频 查看详情
• 93

  Terminology: Types of Child-to-Parent Relationship Queries

  第 174 页

  让我们来聊聊Salesforce中的“子女与父母关系查询类型”。想象一下，我们有一个家庭，这个家庭里有两位家长和四个孩子。家长A是孩子A的父母，家长B是孩子B和孩子C的父母。而孩子D呢，他没有父母，我们通常称这样的孩子为“孤儿”。 现在，如果我们想要查询这些孩子，我们可以根据他们与父母的关系来分类查询。 首先，如果我们想要查询“所有孩子”，那么我们会得到孩子A、B、C和D。这很简单，对吧？就是所有的孩子，不管他们有没有父母。 接下来，如果我们只想要查询“有父母的孩子”，那么我们就会得到孩子A、B和C。因为孩子D没有父母，所以他不包括在这个查询结果里。 最后，如果我们想要查询“孤儿”，也就是那些没有父母的孩子，那么我们就会得到孩子D。因为只有孩子D没有父母。 通过这样的分类查询，我们可以很容易地根据孩子与父母的关系来筛选出我们需要的数据。接下来，我们会把这个概念应用到实际的例子中，然后学习如何在Salesforce中构建这些查询。这样，你就可以在实际工作中灵活运用这些查询技巧了。

  ▶ 播放视频 查看详情
• 94

  Which Rows Will be Fetched?

  第 175 页

  让我们来聊聊这个问题。首先，我们需要明确几个概念：在这个场景中，，认证，是“父母”，而，课程，是“孩子”。也就是说，认证和课程之间有一种父子关系，认证是父级，课程是子级。 现在，我们来看一下具体的问题： 1. ，如果您选择了所有课程，无论课程是否有相关认证（即，“所有孩子”）？， - 这意味着我们要选择所有的课程，不管它们有没有关联的认证。根据给定的数据，总共有3门课程。所以，答案是 ，3，。 2. ，如果您仅选择具有相关认证的课程（即，“有父母的孩子”）？， - 这里我们只选择那些有认证的课程。根据数据，有1门课程是有相关认证的。所以，答案是 ，1，。 3. ，如果您仅选择了没有相关认证的课程（即，“孤儿”）？， - 最后，我们只选择那些没有认证的课程。根据数据，有2门课程是没有相关认证的。所以，答案是 ，2，。 总结一下： - 所有课程（无论是否有认证）：，3， - 有认证的课程：，1， - 没有认证的课程：，2， 希望这个解释能帮助你更好地理解这个问题！如果还有疑问，随时问我哦。

  ▶ 播放视频 查看详情
• 95

  Referencing the Child-to-Parent Relationship

  第 176 页

  让我们来聊聊Salesforce中的“子对父关系查询”。想象一下，你有一个家庭，父母和孩子。在Salesforce中，数据之间的关系也可以这样理解。比如，你有一个“孩子”对象和一个“父母”对象，它们之间有关系。 当你想要查询“孩子”对象，并且还想获取一些“父母”对象的信息时，你就需要使用“子对父关系查询”。这就像是你问孩子：“你爸爸叫什么名字？”你通过孩子来获取他爸爸的信息。 在Salesforce中，查询的语法会根据关系的类型有所不同。如果“孩子”和“父母”之间的关系是标准的（就像大多数家庭一样），你可以这样写查询：`父.字段`。这里的“父”代表父母对象，“字段”是你想要获取的信息。 但如果这个关系是自定义的（就像有些家庭可能有继父或养父），你就需要稍微改变一下语法，写成：`父__r.字段`。这里的“__r”是Salesforce用来表示自定义关系的方式。 格雷格的笔记里提到，这种查询是在LOS分句中指定子对象，并通过点标记来引用父对象中的字段。简单来说，就是你在查询孩子的时候，顺便问一下他父母的信息。 希望这个解释能帮助你更好地理解“子对父关系查询”。如果有任何问题，随时问我哦！

  ▶ 播放视频 查看详情
• 96

  All Children – Standard Relationship

  第 177 页

  同学们，今天我们来聊聊Salesforce中的一些基本概念和查询技巧。首先，我们来看一下如何在Salesforce中处理与账户（Account）和联系人（Contact）相关的数据。 1. ，账户和联系人的关系，： - 在Salesforce中，每个联系人（Contact）都可以关联到一个账户（Account）。这意味着你可以在联系人记录中看到它所属的账户信息。 - 例如，如果你想查看某个联系人的账户名称，你可以通过查询来实现。 2. ，查询语句，： - 这里有两个查询语句的例子，它们都可以用来获取联系人的名字、姓氏以及他们所属账户的名称和ID。 - 第一个查询是：`SELECT FirstName, LastName, AccountId, Account.Name FROM Contact` - 第二个查询是：`SELECT FirstName, LastName, Account.Id, Account.Name FROM Contact` - 这两个查询的效果是一样的，它们都会返回联系人的名字、姓氏，以及他们所属账户的ID和名称。 3. ，注意事项，： - 在Salesforce中，当你通过一个对象访问另一个对象的字段时，比如通过联系人访问账户的名称，你需要使用点符号（.）来表示这种关系。这就是为什么我们在查询中使用了`Account.Name`。 - 另外，记住在Salesforce中，父对象的名称总是单数形式。所以即使你在处理多个联系人，你也会使用`Account.Name`而不是`Accounts.Name`。 希望这些信息对你们理解Salesforce中的数据关系和查询有所帮助。如果有任何疑问，随时提问哦！

  ▶ 播放视频 查看详情
• 97

  All Children – Custom Relationship

  第 178 页

  同学们，今天我们来聊聊Salesforce中的自定义对象和关系。首先，想象一下，我们有一个叫做“课程”的自定义对象，这个对象和另一个叫做“认证”的对象有关系。这种关系在Salesforce中是通过字段来建立的。 现在，假设我们想要从“课程”对象中获取一些信息，比如课程的名称，以及与之相关的“认证”的名称。在Salesforce中，我们可以通过两种方式来实现这一点。 第一种方式是直接使用“认证”对象的ID字段，这个字段在“课程”对象中通常命名为“Certification__c”。这个字段存储的是“认证”对象的记录ID。 第二种方式是通过关系字段来获取“认证”对象的名称。在Salesforce中，当我们建立了一个自定义关系后，系统会自动为我们生成一个以“__r”结尾的关系字段。这个字段允许我们直接访问相关对象的字段，比如“认证”对象的名称。 所以，如果我们想要查询“课程”对象的名称以及与之相关的“认证”对象的名称，我们可以写这样的SOQL查询： ```sql SELECT Name, Certification__c, Certification__r.Name FROM Course__c ``` 或者，如果我们想要获取“认证”对象的ID和名称，我们可以这样写： ```sql SELECT Name, Certification__r.Id, Certification__r.Name FROM Course__c ``` 这两种查询都是有效的，它们都能帮助我们获取到我们需要的信息。记住，在自定义关系中，我们使用带有“__r”后缀的父对象名来访问相关对象的字段。 好了，这就是今天的内容。希望大家能够理解并记住这些要点。如果有任何问题，随时提问哦！

  ▶ 播放视频 查看详情
• 98

  Parented Children – Custom Relationship

  第 179 页

  同学们，今天我们来聊聊Salesforce中的一个重要概念——主从关系（Master-Detail Relationship）。这个关系就像父母和孩子的关系一样，孩子总是需要有一个父母，没有父母的孩子是不存在的。在Salesforce中，这意味着每条子记录（孩子）都必须有一个父记录（父母）。 现在，假设我们有一个自定义对象叫做“认证__c”，我们想要查询那些没有父记录的“孤儿”记录。在黑板上，我写下了这个查询条件：`WHERE 认证__c = 空`。但是，这里有个问题，因为主从关系的设计，子记录总是有一个父记录，所以这个查询实际上是没有意义的，因为不会有任何记录符合这个条件。 为了帮助大家更好地理解，我建议大家参考练习指南附录A中的数据模型图。这个图会清晰地展示出主从关系是如何在对象之间建立的，以及为什么我们不能有“孤儿”记录。 在讨论幻灯片中，我们还会进一步探讨这个主题，确保每个人都能够理解并应用这个概念。记住，理解主从关系对于在Salesforce中设计有效的数据模型至关重要。

  ▶ 播放视频 查看详情
• 99

  6-1: Write and Test Child-to-Parent Relationship Queries

  第 180 页

  同学们，今天我们来学习如何在Salesforce中编写和测试一个查询，这个查询是关于儿童与父母关系的。我们的目标是探索认证应用程序中不同对象之间的关系。 首先，我们需要选择所有的联系人以及他们相关的账户。这个步骤很简单，我们只需要使用SOQL（Salesforce Object Query Language）来查询联系人和账户。我们可以这样写： ```sql SELECT Id, Name, Account.Name FROM Contact ``` 这个查询会返回所有联系人的ID、名字以及他们所属账户的名字。 接下来，我们需要选择那些具有相关认证的课程。假设我们有一个对象叫做“认证课程”，我们可以这样查询： ```sql SELECT Id, Name FROM Certified_Course__c ``` 这个查询会返回所有认证课程的ID和名字。 现在，我们需要把这两个查询结合起来，找到那些联系人（儿童）和他们所属的账户（父母）之间的关系。我们可以这样做： ```sql SELECT Id, Name, Account.Name FROM Contact WHERE AccountId IN (SELECT AccountId FROM Certified_Course__c) ``` 这个查询会返回所有那些账户下有认证课程的联系人。 最后，我们需要测试这个查询，确保它返回了我们想要的结果。你可以在Salesforce的开发者控制台中运行这个查询，看看结果是否符合预期。 好了，这就是今天的任务。你们有20分钟的时间来完成这个查询和测试。如果有任何问题，随时问我。现在，轮到你动手了！

  ▶ 播放视频 查看详情
• 100

  Module Agenda - 181

  第 181 页

  同学们，今天我们来聊聊Salesforce中的一个比较有趣的话题——父母与孩子的关系查询。这个部分可能会比我们之前学过的孩子与父母的关系查询要复杂一些，因为它可能会涉及到嵌套查询。 首先，我们得明白，在Salesforce中，对象之间的关系是非常重要的。比如，我们有一个“客户”对象和一个“订单”对象，这里“客户”就是父母，“订单”就是孩子。通常，我们查询孩子对象时，可以直接通过父母对象的ID来找到相关的孩子记录，这相对简单。 但是，当我们想要从孩子对象查询到父母对象时，情况就稍微复杂一些了。这时候，我们可能需要使用嵌套查询。嵌套查询的意思就是在一个查询里面再放一个查询。比如，我们想要找到所有有订单的客户，我们可能首先需要查询订单对象，然后在每个订单中找到对应的客户ID，再通过这些ID去查询客户对象。 这种查询方式虽然复杂，但它非常强大，可以帮助我们获取到更精确的数据。所以，虽然一开始可能会觉得有点难，但一旦掌握了，你会发现它非常有用。 好了，这就是今天关于父母与孩子关系查询的简单介绍。希望大家能够理解，并在实践中多加练习。如果有任何问题，随时提问哦！

  ▶ 播放视频 查看详情
• 101

  Terminology: Types of Parent-to-Child Relationships

  第 182 页

  同学们，今天我们来聊聊一个非常有趣的话题——父母对子女的资助类型。想象一下，我们有一个小社区，里面有三位家长和四个孩子。我们的任务是了解这些家长是如何资助他们的孩子的。 首先，我们有三位家长：家长A、家长B和家长C。家长A和家长B已经有了孩子，而家长C目前还没有孩子，但他们未来可能会成为父母。 现在，如果我们想要查询所有家长的信息，不管他们有没有孩子，我们就会得到家长A、家长B和家长C的信息。这是因为我们是在查询所有的家长，不论他们是否有孩子。 接下来，如果我们只查询那些已经有孩子的家长，那么我们就会得到家长A和家长B的信息。这是因为家长C目前还没有孩子，所以他们不在这个查询结果中。 最后，如果我们想要查询那些还没有生育的家长，也就是潜在的父母，那么我们就会得到家长C的信息。这是因为家长A和家长B已经有了孩子，而家长C还没有。 通过这个简单的例子，我们可以看到，根据不同的查询条件，我们可以得到不同的结果。这在实际应用中非常有用，比如在Salesforce中，我们可以根据不同的条件来筛选和查询数据，以便更好地管理和分析信息。 接下来，我们会将这个简单的概念应用到更复杂的现实世界例子中，并学习如何在Salesforce中构建这些查询。这样，你们就能更好地理解如何在实际工作中应用这些知识了。

  ▶ 播放视频 查看详情
• 102

  Referencing the Parent-to-Child Relationship

  第 183 页

  让我们来聊聊Salesforce中的父子关系查询，就像父母教育孩子一样，我们要一层一层地来理解。 首先，想象一下，你有一个家庭，父母和孩子。在Salesforce中，我们也有一对多的关系，就像父母可以有多个孩子一样。这种关系在Salesforce中被称为父子关系。 现在，假设你想查询这些数据，就像你想了解你的家庭一样。在Salesforce中，我们使用SOQL（Salesforce Object Query Language）来查询数据。但是，这里有一个重要的注意事项：你只能直接查询你的孩子，而不能直接查询你的孙子。也就是说，你只能访问直接与父对象相关的子对象，而不能跳过子对象直接访问孙对象。 那么，如何在查询中访问子对象呢？这里就需要用到嵌套查询。嵌套查询就像是你问孩子：“你的朋友是谁？”然后孩子告诉你他们的朋友的名字。在SOQL中，嵌套查询的语法会根据关系的类型有所不同： 1. 如果是标准关系（比如Account和Contact），你可以这样写查询：`SELECT Id, Name, (SELECT Id, Name FROM Contacts) FROM Account`。这里的`Contacts`就是Account的子对象。 2. 如果是自定义关系（比如你自定义了一个对象`Child__c`，并且它与`Parent__c`有父子关系），你需要使用`__r`来表示关系，查询会是这样：`SELECT Id, Name, (SELECT Id, Name FROM Child__r) FROM Parent__c`。这里的`Child__r`表示`Parent__c`的子对象。 简单来说，就是你要一层一层地查询，先查父母，再查孩子，不能跳过孩子直接查孙子。希望这个比喻能帮助你更好地理解Salesforce中的父子关系查询！

  ▶ 播放视频 查看详情
• 103

  All Parents – Standard Relationship

  第 184 页

  让我们来聊聊Salesforce中的父子关系查询。想象一下，你有一个家庭，父母和孩子。在Salesforce中，我们也有类似的关系，比如一个公司（父）和它的员工（子）。 1. ，从父到子查询，：当你想从父母那里获取孩子的信息时，你需要使用一个嵌套的选择语句。这就像你问父母：“你们家有哪些孩子？”然后父母会列出所有孩子的名字。在Salesforce中，这个查询看起来像这样： ```sql SELECT Name, (SELECT LastName FROM Contacts) FROM Account ``` 这里，`Account`是父对象，`Contacts`是子对象。我们通过嵌套的`SELECT`语句来获取所有联系人的姓氏。 2. ，从子到父查询，：反过来，如果你想从孩子那里获取父母的信息，那就简单多了。你只需要使用点符号。这就像孩子直接告诉你：“我的父母是某某。”在Salesforce中，这个查询看起来像这样： ```sql SELECT Account.Name FROM Contact ``` 这里，`Contact`是子对象，`Account`是父对象。我们通过点符号直接访问父对象的字段。 所以，记住，当你从父母转向孩子时，需要嵌套选择；而从孩子转向父母时，只需使用点符号。这样，你就能轻松地在Salesforce中处理父子关系了。试试看，你会发现点符号真的很方便！

  ▶ 播放视频 查看详情
• 104

  All Parents – Custom Relationship

  第 185 页

  同学们，今天我们来聊聊Salesforce中的自定义关系查询。想象一下，你有一个叫做“认证”的对象，这个对象下面有一些子对象，我们称之为“课程”。现在，你想要查询所有的认证，并且同时获取每个认证下的所有课程的名称。 首先，我们来看一下这个查询的结构。在Salesforce中，当你有一个自定义关系时，比如“课程”是“认证”的子对象，你可以通过使用“__r”后缀来引用这个子对象。这里的“r”代表“relationship”，也就是关系的意思。 所以，我们的查询语句会是这样： ```sql SELECT Name, (SELECT Name FROM 课程__r) FROM 认证__c ``` 这里，“课程__r”表示的是“认证”对象下的“课程”子对象。通过这个查询，我们可以获取所有认证的名称，以及每个认证下所有课程的名称。 接下来，我们来看一下标准关系和自定义关系的区别。在标准关系中，比如“联系人”是“账户”的子对象，你可以直接使用“联系人”来引用，而不需要“__r”后缀。但在自定义关系中，你必须使用“__r”后缀来明确表示这是一个子对象。 最后，我建议你们在黑板上写下这个查询语句，并且标注出“__r”后缀的作用。这样可以帮助你们更好地理解和记忆。 好了，这就是今天的内容。希望你们能够理解并掌握如何在Salesforce中使用自定义关系进行查询。如果有任何问题，随时提问！

  ▶ 播放视频 查看详情
• 105

  Parents with Related Children – Custom Relationship

  第 186 页

  同学们，今天我们来聊聊如何在Salesforce中定制查询，特别是针对那些有相关孩子的父母。想象一下，你有一张名单，上面列出了所有的父母，但你需要找出那些没有特定类型孩子的父母。这时候，我们就需要用到SQL中的“NOT IN”语句。 首先，我们要在黑板上写下我们的查询目标：找出那些不在特定列表中的父母。这个列表可能包括非父母，或者那些可能仍然是父母的人。为了做到这一点，我们需要在WHERE子句中嵌套一个选择语句。 举个例子，假设我们有一个表叫“Parents”，还有一个表叫“Children”。我们想要找出那些在“Parents”表中，但他们的ID不在“Children”表中的特定列表里的记录。我们的查询可能会是这样写的： ```sql SELECT Name FROM Parents WHERE ID NOT IN (SELECT ParentID FROM Children WHERE Type = &#39;SpecificType&#39;) ``` 在这个查询中，我们首先从“Children”表中选择出所有类型为“SpecificType”的孩子的ParentID，然后在“Parents”表中选择那些ID不在这个列表中的父母的名字。 同学们，这个技巧在实验室中会非常有用，所以请大家特别注意这一点。在编写查询时，确保你理解“NOT IN”是如何工作的，以及如何正确地嵌套选择语句。这样，你就可以轻松地过滤出你需要的数据了。

  ▶ 播放视频 查看详情
• 106

  6-2: Query Account and Related Contacts

  第 187 页

  同学们，今天我们来学习如何在Salesforce中编写查询，特别是涉及到父子关系的查询。我们有两个主要任务：一是选择所有帐户及其相关的联系人，二是选择所有具有相关课程的认证。 首先，我们来看第一个任务：选择所有帐户及其相关联系人。在Salesforce中，帐户（Account）和联系人（Contact）之间有一个父子关系，即一个帐户可以有多个联系人。为了查询这些数据，我们需要使用SOQL（Salesforce Object Query Language）。 我们可以这样写查询语句： ```sql SELECT Id, Name, (SELECT Id, Name FROM Contacts) FROM Account ``` 这个查询的意思是：从Account对象中选择Id和Name字段，同时选择与每个Account相关联的所有Contact的Id和Name字段。这样，我们就可以得到一个包含所有帐户及其相关联系人的列表。 接下来是第二个任务：选择所有具有相关课程的认证。假设在认证应用程序中，认证（Certification）和课程（Course）之间也存在父子关系。我们可以使用类似的SOQL查询来获取这些数据。 查询语句可以这样写： ```sql SELECT Id, Name, (SELECT Id, Name FROM Courses) FROM Certification ``` 这个查询的意思是：从Certification对象中选择Id和Name字段，同时选择与每个Certification相关联的所有Course的Id和Name字段。这样，我们就可以得到一个包含所有认证及其相关课程的列表。 通过这两个例子，我们可以看到如何在Salesforce中使用SOQL来查询父子关系的数据。希望这些内容对你们有所帮助，如果有任何问题，随时提问。

  ▶ 播放视频 查看详情
• 107

  Key Takeaways - 188

  第 188 页

  同学们，今天我们来聊聊Salesforce中的SOQL查询，特别是如何通过点符号来穿越查询中的父子关系。这听起来可能有点复杂，但别担心，我会用简单的方式来解释。 首先，想象一下Salesforce中的数据就像是一个大家族，有父母和孩子。在查询数据时，我们有时候需要从父母那里获取孩子的信息，或者反过来。这时候，点符号就派上用场了。它就像是一座桥，帮助我们从一个对象跳到另一个相关的对象。 举个例子，假设我们有一个“客户”对象和一个“订单”对象。每个客户可能有多个订单。如果我们想查询某个客户的所有订单，我们可以使用点符号来穿越这个关系。查询语句可能会是这样：`SELECT Name, (SELECT OrderNumber FROM Orders) FROM Customer`。这里，`Orders`是`Customer`的子对象，我们通过嵌套的SELECT语句来获取每个客户的订单信息。 接下来，记住一个规则：在SOQL查询中，你可以访问最多5个祖先级别或1个后代级别的字段。这意味着你可以向上查询5层父母，或者向下查询1层孩子。我们简称为“5上，1下”。 最后，关于预定义的模式关系。Salesforce中的对象之间有很多预定义的关系，比如“客户”和“订单”之间的关系。了解这些关系对于编写有效的SOQL查询非常重要。 好了，这就是今天的主要内容。如果有任何问题，随时举手提问。我们一起来掌握这些关键要点，让Salesforce的数据查询变得更加得心应手！

  ▶ 播放视频 查看详情
• 108

  Module 7: DML Essentials

  第 189 页

  同学们，今天我们来聊聊模块7的TLR要点。TLR，也就是“Trigger Logic Review”，是Salesforce开发中非常重要的一部分。它主要关注的是触发器逻辑的审查和优化。 首先，我们要明白触发器是什么。触发器就像是一个自动化的“小助手”，当你在Salesforce中执行某些操作时，比如创建、更新或删除记录，触发器就会自动运行，执行你预先设定好的逻辑。 那么，TLR的要点是什么呢？ 1. ，逻辑清晰，：触发器的逻辑要尽量简单明了，避免复杂的嵌套和多重条件判断。这样不仅便于维护，也能减少出错的可能性。 2. ，性能优化，：触发器中的代码要尽量高效，避免不必要的数据库操作和循环。记住，Salesforce对每个事务的执行时间是有严格限制的，所以我们要确保触发器能在规定时间内完成。 3. ，避免重复触发，：有时候，一个操作可能会触发多个触发器，这会导致重复执行和资源浪费。我们要通过合理的逻辑设计，避免这种情况的发生。 4. ，测试充分，：在部署触发器之前，一定要进行充分的测试。确保在各种场景下，触发器都能按预期工作，不会引发意外的错误。 5. ，文档齐全，：最后，别忘了为触发器编写详细的文档。包括触发器的目的、逻辑流程、测试用例等。这样不仅便于自己日后维护，也能帮助其他开发者快速理解和使用。 好了，以上就是模块7的TLR要点。希望大家在实际开发中，能够灵活运用这些原则，写出高效、稳定的触发器代码。如果有任何问题，随时欢迎提问！

  ▶ 播放视频 查看详情
• 109

  Module Objectives - 190

  第 190 页

  同学们，今天我们要聊的是Salesforce中的TLR操作，也就是事务处理和记录锁定。听起来有点复杂，但其实很简单，就像你在玩一个游戏，需要确保每一步都正确无误，才能顺利通关。 首先，我们要了解的是，调用TLR操作有几种不同的方式。你可以直接使用标准的DML操作，比如`insert`，或者使用更高级的`Database.insert()`方法。这两种方式的主要区别在于错误处理。使用`Database.insert()`，你可以更细致地控制当出现错误时应该怎么做，比如只插入那些没有错误的记录，而不是全部失败。 接下来，我们要学习如何用Apex代码来调用这些TLR操作。Apex是Salesforce的一种编程语言，它让我们可以编写逻辑来处理数据。比如，我们可以编写一个Apex类来更改联系人的信息，然后将这些更改保存到数据库中。这里的关键是，我们需要确保在保存数据之前，所有的更改都是正确的，否则就可能会遇到错误。 在处理TLR操作时，我们还需要了解如何设置保存点和回滚。保存点就像是在游戏中设置一个检查点，如果之后的操作出了问题，我们可以回滚到这个点，重新开始。这在处理复杂的事务时非常有用，可以避免数据不一致的问题。 最后，我们要学会如何处理TLR操作中可能出现的错误和异常。在Apex中，我们可以使用try-catch块来捕获这些错误，并根据错误的类型来决定如何处理。比如，如果是因为数据验证失败，我们可以提示用户重新输入数据；如果是系统错误，我们可能需要记录日志并通知管理员。 好了，今天的内容就到这里。记住，处理TLR操作就像是在玩一个需要精确操作的游戏，每一步都要小心谨慎。希望你们都能掌握这些技巧，成为Salesforce的高手！

  ▶ 播放视频 查看详情
• 110

  Module Agenda - 191

  第 191 页

  让我们来聊聊模块7的内容，也就是TLR的要点。首先，我们会讨论模块的议程，这就像是我们的学习地图，告诉我们接下来要学什么。然后，我们会探讨持久数据的选项，这部分内容会帮助我们理解如何在Salesforce中保存和管理数据，确保信息不会丢失。 接下来，我们会学习如何排队TLR活动。这就像是我们在餐厅排队等候一样，我们需要知道如何安排和处理这些活动，确保它们能够顺利进行。最后，我们会讨论如何处理TLR中的错误和进行调试。这就像是我们在做菜时，如果发现味道不对，我们需要知道如何调整和修正。 通过这些内容的学习，你将能够更好地理解TLR的核心要点，掌握在Salesforce中处理数据和活动的技巧。希望这些内容能够帮助你更自信地使用Salesforce，解决实际工作中的问题。

  ▶ 播放视频 查看详情
• 111

  Working with Data in Apex: A Common Pattern - 192

  第 192 页

  今天我们来聊聊在Apex中如何使用数据，特别是关于删除和修改联系人的常见模式。这个过程其实很简单，我们可以把它分成几个步骤来理解。 首先，，删除联系人，。在Apex中，如果你想要从数据库中删除一个联系人，你可以使用`delete`语句。这个操作会直接从数据库中移除这个联系人的记录。记住，一旦删除了，数据就无法恢复了，所以操作前要三思哦。 接下来是，修改联系人，。修改联系人通常涉及两个步骤：首先是从数据库中读取联系人信息到内存中，然后在内存中对这些信息进行修改。你可以使用`SOQL`查询来获取联系人对象，然后在Apex代码中修改这个对象的属性。 最后一步是，将修改后的数据保存回数据库，。在Apex中，你可以使用`update`语句来将内存中修改后的联系人对象保存回数据库。这样，数据库中的联系人信息就会被更新为你在内存中修改后的版本。 总结一下，处理数据的基本流程就是：从数据库读取数据到内存，在内存中进行修改，最后将修改后的数据保存回数据库。这个过程在Apex中非常常见，掌握了它，你就能处理很多数据操作的任务了。 希望这个解释能帮助你更好地理解在Apex中如何处理数据。如果有任何疑问，随时提问哦！

  ▶ 播放视频 查看详情
• 112

  Sales CRM Data Model

  第 193 页

  让我们来聊聊Salesforce中的销售CRM数据模型。这个模型是帮助我们更好地管理销售流程的。首先，我们要了解几个关键的对象，这些对象是Salesforce中用来存储和管理数据的基本单元。 首先，我们有，Campaign，，这是用来规划和跟踪我们的营销活动的。比如，如果我们有一个新的产品发布，我们可以创建一个Campaign来跟踪所有相关的营销活动。 接下来是，Lead，，也就是潜在客户。这些是我们认为有可能成为我们客户的人或公司。我们需要收集他们的信息，并评估他们是否真的有可能购买我们的产品或服务。 然后是，Account，，这是我们的客户、竞争对手或合作伙伴的信息。每个Account都会存储一些基本信息，比如公司名称、地址和电话号码等。 与Account紧密相关的是，Contact，，这些是与Account相关联的个人。比如，如果ABC Labs是我们的客户，那么Arnold Adam和Bertha Boxer可能就是我们在ABC Labs中的联系人。 最后是，Opportunity，，这是我们正在跟踪的销售交易。每个Opportunity都代表一个潜在的销售机会，我们会记录这个交易的状态、金额等信息。 这些对象之间有一些预定义的关系。比如，一个Account可以有多个Contact，这就是一对多的关系。Account是父对象，Contact是子对象。在Salesforce中，我们可以从一个Account记录轻松地查看所有相关的Contact记录，反之亦然。 所以，简单来说，Salesforce的销售CRM数据模型帮助我们通过几个关键对象来管理我们的销售流程，从营销活动到潜在客户，再到客户和销售机会，一切都井井有条。希望这能帮助你更好地理解Salesforce的销售CRM数据模型！

  ▶ 播放视频 查看详情
• 113

  Demo: Saving Changes to Contacts in the Developer Console

  第 194 页

  同学们，今天我们来学习如何在Salesforce的开发人员控制台中保存对联系人记录的更改。首先，让我们回顾一下，你们已经学会了使用SOQL来查询数据库，现在我们要进一步探索如何通过开发人员控制台来持久化这些数据更改。 首先，想象一下，如果你们想在Salesforce的用户界面中创建或更改记录，你们会怎么做呢？可能会通过记录详细信息页面、列表视图、Salesforce Mobile应用，或者使用Salesforce的操作按钮。这些都是常见的方法。 现在，假设你们是开发人员，使用开发人员控制台中的SOQL查询来获取一组记录。你们可能会想，如何直接在控制台中修改这些记录呢？让我们一步步来看。 首先，打开开发人员控制台，找到查询编辑器。在这里，输入以下SOQL查询： ```sql SELECT ID, LastName, LeadSource FROM Contact WHERE LeadSource = &#39;Trade Show&#39; ``` 执行这个查询后，你会看到一系列符合条件的联系人记录。 接下来，双击第一个联系人的LeadSource字段，将其内容改为“Partner”。记得记下你刚刚更新的联系人的姓氏，这样我们稍后可以验证更改是否成功。 完成修改后，点击“保存行”按钮。这样，你就成功地在开发人员控制台中更新了这条联系人记录。 为了验证更改是否确实保存了，我们可以再次执行一个查询： ```sql SELECT ID, LastName, FirstName, HomePhone FROM Contact WHERE LastName = &#39;你刚刚更新的联系人的姓氏&#39; ``` 执行这个查询后，检查结果，确认LeadSource字段是否已经更新为“Partner”。 最后，为了保持数据的原始状态，我们可以将LeadSource字段改回“Trade Show”，然后再次点击“保存行”。 通过这个过程，你们学会了如何在开发人员控制台中直接修改和保存联系人记录。接下来，我们将探讨如何在Apex代码中实现类似的功能。这将是一个更高级的话题，但相信你们已经准备好迎接新的挑战了！

  ▶ 播放视频 查看详情
• 114

  Example: Saving Changes to Contacts Programmatically

  第 195 页

  同学们，今天我们来学习如何以编程的方式保存对联系人的更改。首先，我们需要从数据库中获取我们想要修改的联系人数据。这一步就像是去图书馆找到你想要的那本书。 接下来，我们在内存中对这些数据进行修改。想象一下，你在这本书上做了一些笔记或者标记，但还没有把书放回书架。 然后，我们使用一个叫做“更新”的TLR命令，将这些更改保存回数据库。这就像是你把修改后的书放回图书馆的书架上，这样其他人也能看到你的更改。 最后，我们可以再次从数据库中获取这些数据，来验证我们的更改是否已经成功保存。这就像是再次去图书馆确认你的笔记是否还在那本书上。 记住，TLR命令不仅仅有“更新”，还有其他几种类型，我们会在接下来的课程中一一介绍。这样，你们就能更全面地掌握如何在Salesforce中以编程方式操作数据了。

  ▶ 播放视频 查看详情
• 115

  Match the Programming Scenario to the DML Command

  第 196 页

  让我们一起来理解这些编程场景和DML命令的匹配。DML（数据操作语言）命令是用来在Salesforce中操作数据的，比如插入、更新、删除等。我们来看一下每个场景和对应的DML命令。 1. ，场景1，：我们需要将LeadSource为‘Trade Show’的联系人检索到内存中，并将其LeadSource修改为“Other”，然后将这个修改保存到组织中。这个操作涉及到检索和更新数据，所以对应的DML命令是，UPDATE，（B）。 2. ，场景2，：在内存中创建一个新的联系人实例，并将其保存到组织中。这个操作是创建一个新的记录，所以对应的DML命令是，INSERT，（A）。 3. ，场景3，：通过用户界面错误地输入了一些联系人，我们需要将这些联系人检索到内存中，并使用它们的ID值将它们从组织中删除。这个操作是删除记录，所以对应的DML命令是，DELETE，（D）。 4. ，场景4，：在内存中创建新的联系人，并修改已经加载到内存中的现有联系人，然后发出一条命令将这些新的和修改后的联系人保存到组织中。这个操作涉及到插入和更新，所以对应的DML命令是，UPSERT，（C）。 5. ，场景5，：实际上，场景3中删除的联系人是正确创建的，我们需要使用SOQL将这些联系人从回收站检索到内存中，然后恢复这些联系记录。这个操作是恢复被删除的记录，所以对应的DML命令是，UNDELETE，（E）。 总结一下，答案就是： 1-B、2-A、3-D、4-C、5-E。 希望这个解释能帮助你更好地理解这些场景和DML命令的匹配。如果有任何问题，随时问我哦！

  ▶ 播放视频 查看详情
• 116

  Module Agenda - 197

  第 197 页

  同学们，今天我们来聊聊模块7的内容，这个模块主要是关于TLR（Transaction Log Replay）的一些关键点。我会用简单易懂的方式来讲解，确保大家都能跟上。 首先，我们来看一下模块的议程。这个模块主要分为三个部分： 1. ，持久数据的选项，：我们会讨论在Salesforce中，如何确保数据在系统重启或故障后仍然能够保存下来。这里会涉及到一些持久化存储的技术和策略。 2. ，排队TLR活动，：TLR活动是指事务日志重放活动。我们会讲解如何将这些活动进行排队管理，确保它们能够有序、高效地执行。 3. ，处理TLR错误和调试，：最后，我们会探讨在TLR过程中可能遇到的错误，以及如何进行调试和解决这些问题。这部分内容非常重要，因为在实际操作中，错误是不可避免的，掌握调试技巧可以帮助我们快速定位和解决问题。 接下来，我会逐一详细讲解这三个部分的内容，确保大家能够全面理解并掌握TLR的要点。如果有任何问题，随时可以提出来，我们一起讨论解决。

  ▶ 播放视频 查看详情
• 117

  Two Ways of Writing DML Commands

  第 198 页

  同学们，今天我们来聊聊编写TLR命令的两种方法。虽然这两种方法看起来非常相似，但它们实际上有很大的不同。理解这些差异对我们以后的学习非常重要，所以千万不要跳过这部分内容哦。 首先，我们来看第一种方法，就是使用Datab.DML命令。这种方法非常直接，你可以通过它来执行插入、更新、删除等操作。简单来说，Datab.DML命令就像是你直接对数据库进行操作的工具，非常强大且灵活。 第二种方法呢，就是独立合并命令。这个方法比较特别，因为它没有对应的数据库系统方法。也就是说，你不能直接通过数据库来执行这个命令。不过，我们今天的重点不是学习合并命令，所以大家只需要知道有这么一回事就可以了。 为了帮助大家更好地理解，我给大家准备了一个额外的学习材料链接，里面详细介绍了Apex语言中的DML操作。大家可以课后去阅读一下，加深理解。 好了，今天的课程就到这里。希望大家能够记住这两种方法的关键点，以后在编写TLR命令时能够灵活运用。如果有任何问题，随时来找我讨论哦！

  ▶ 播放视频 查看详情
• 118

  Demo: What Happens When You Insert Incomplete Contacts?

  第 199 页

  同学们，今天我们来做一个简单的演示，看看在Salesforce中插入不完整的联系人时会发生什么。这个演示会帮助我们理解数据插入时的错误处理机制。 首先，我们需要打开Salesforce的开发者控制台。你可以通过点击右上角的设置图标，然后选择“开发者控制台”来打开它。 接下来，在开发者控制台的“匿名执行”窗口中，我们会输入一段代码。这段代码的目的是尝试插入一个不完整的联系人记录。具体来说，我们会尝试插入一个只有姓氏（Last Name）而没有名字（First Name）的联系人。 当我们运行这段代码时，Salesforce会立即抛出一个错误。这是因为在Salesforce中，某些字段是必填的，比如联系人的名字（First Name）。如果我们不提供这些必填字段，记录就无法成功插入。 现在，我们来查看一下这个错误。错误信息会告诉我们具体是哪个字段缺失了，导致插入失败。 接下来，我们使用查询编辑器来执行一个SOQL查询。这个查询的目的是检查是否有一个姓氏为“Santoyo”的联系人被成功插入。查询语句是这样的：`SELECT LastName FROM Contact WHERE LastName = &#39;Santoyo&#39;`。你会发现，查询结果为空，因为刚才的插入操作失败了，没有记录被插入。 现在，我们来做一个小调整。我们把代码中的第4行和第5行的顺序颠倒一下，然后重新运行代码和查询。你会发现，无论我们怎么调整代码的顺序，只要有一条记录插入失败，所有的记录都不会被插入。这就是Salesforce的事务性特性：要么全部成功，要么全部失败。 最后，我们再次执行SOQL查询，确认一下是否有任何记录被插入。你会发现，结果依然是空的，因为插入操作失败了。 总结一下，这个演示告诉我们，在Salesforce中插入记录时，如果有一条记录不符合要求（比如缺少必填字段），那么所有的记录都不会被插入。这就是为什么我们在开发时，要特别注意数据的完整性和准确性。 好了，今天的演示就到这里。希望你们通过这个简单的例子，对Salesforce的数据插入和错误处理有了更深的理解。如果有任何问题，欢迎随时提问！

  ▶ 播放视频 查看详情
• 119

  Partial Processing of Records

  第 200 页

  今天我们来聊聊Salesforce中的DML操作，特别是完全处理和部分处理的区别。这个知识点对于理解如何在Salesforce中高效地处理数据非常重要。 首先，DML操作，也就是数据操作语言，包括插入、更新、删除等操作。在Salesforce中，DML操作可以有两种处理方式：完全处理和部分处理。 完全处理，顾名思义，就是要么全部成功，要么全部失败。这就像你在一家餐厅点了一桌菜，如果其中一道菜出了问题，整个订单都会被取消。在Salesforce中，如果你使用标准的DML语句，比如`insert`或`update`，并且没有设置任何特殊参数，那么如果其中一条记录失败了，整个操作都会回滚，所有记录都不会被处理。 而部分处理则更加灵活。这就像你在餐厅点菜，如果有一道菜出了问题，服务员会先上其他菜，然后再尝试重新做那道有问题的菜。在Salesforce中，如果你使用`Database`类的方法，比如`Database.insert`或`Database.update`，并且将`allOrNone`参数设置为`false`，那么即使有部分记录失败了，其他记录仍然会被处理。Salesforce会尝试多次处理这些记录，直到所有可能的记录都被处理或者达到重试次数的上限。 具体来说，Salesforce会进行三次尝试： 1. 第一次尝试处理所有记录，如果有记录失败，这些记录会被搁置。 2. 第二次尝试只处理那些在第一次尝试中没有失败的记录。 3. 如果第二次尝试还有记录失败，Salesforce会进行最后一次尝试，只处理那些在前两次尝试中都没有失败的记录。 如果在最后一次尝试中还有记录失败，那么整个操作就会失败，并显示一个错误消息，告诉你“在存在Apex触发器和部分失败的情况下进行的批处理重试次数太多”。 总结一下，完全处理适合那些需要确保所有记录都成功处理的场景，而部分处理则适合那些可以容忍部分记录失败的场景。理解这两种处理方式的区别，可以帮助你更好地设计和优化你的Salesforce应用。 希望这个解释对你有帮助！如果你有更多问题，随时问我。

  ▶ 播放视频 查看详情
• 120

  Are There Other Options for Partial Processing?

  第 201 页

  让我们来聊聊Salesforce中的部分处理选项。首先，你知道在Salesforce中，当我们尝试插入多个记录时，如果其中一条记录失败了，整个操作都会失败，对吧？这就是所谓的“全有或全无”原则。但是，有时候我们可能希望即使有部分记录失败，其他成功的记录也能被插入。这时候，我们就需要用到“部分处理”这个功能。 在Salesforce中，实现部分处理的方法其实只有一种，那就是在使用数据库方法时，将`AllOrNone`参数设置为`false`。这个参数默认是`true`，意味着如果任何一条记录失败，整个操作都会回滚。但如果我们把它设置为`false`，那么即使有部分记录失败，其他成功的记录也会被插入。 举个例子，假设我们有一个联系人列表，我们想用`Database.insert`方法来插入这些联系人。如果我们希望即使有部分联系人插入失败，其他联系人也能成功插入，我们可以这样写代码： ```apex Database.insert(contacts, false); ``` 这里的`contacts`是我们要插入的联系人列表，`false`就是`AllOrNone`参数，表示我们允许部分处理。 另外，你提到的`Database.insert(contacts, true);`，这里的`true`表示我们不允许部分处理，如果任何一条记录失败，整个操作都会失败。 最后，你提到的`Database.insert(contacts, inbox);`，这里的`inbox`可能是一个自定义的参数或者变量，但通常情况下，`Database.insert`方法的第二个参数是用来控制`AllOrNone`的布尔值，所以这个用法可能不太常见。 总结一下，部分处理的唯一方法就是在使用数据库方法时，将`AllOrNone`参数设置为`false`。这样，即使有部分记录失败，其他成功的记录也能被插入。希望这个解释对你有帮助！

  ▶ 播放视频 查看详情
• 121

  Finding the Id of a Successfully Inserted Record

  第 202 页

  今天我们来聊聊如何在Salesforce中查找成功插入的记录的关键点——也就是记录的ID。这个知识点非常实用，尤其是在你处理数据插入操作时。 首先，想象一下，你正在向Salesforce中插入一条新的记录。这个记录可能是一个客户信息、一个销售机会，或者任何你定义的对象。当你执行插入操作时，Salesforce会为这条新记录生成一个唯一的ID。这个ID就像是这条记录的身份证，是它在数据库中的唯一标识。 现在，这里有一个小技巧。在你插入记录之前，你可能会有一个变量来存储这条记录的数据。但是，在你执行插入操作之前，这个变量是没有ID的，因为记录还没有真正存在于数据库中。也就是说，你不能通过这个变量来获取ID，因为ID还没有生成。 但是，一旦你成功地将记录插入到Salesforce中，Salesforce就会为这条记录分配一个ID，并且这个ID会自动更新到你之前用来存储记录数据的变量中。这时候，你就可以通过这个变量来获取新插入记录的ID了。具体来说，你可以使用`变量.Id`来查看这个ID。 举个例子，假设你有一个变量叫做`newAccount`，你用它来存储一个新的客户记录。在你执行插入操作之前，`newAccount.Id`是空的。但是，一旦你执行了插入操作，并且操作成功，`newAccount.Id`就会自动填充为这个新客户的唯一ID。 所以，记住，成功插入记录后，你可以通过`变量.Id`来轻松获取新记录的ID。这个小技巧在你需要进一步处理新插入的记录时非常有用，比如更新记录或者创建相关的记录。 希望这个解释对你有帮助，如果你有任何问题，随时问我！

  ▶ 播放视频 查看详情
• 122

  7-1: Execute DML Commands

  第 203 页

  同学们，今天我们来学习如何在Salesforce中使用Apex代码插入联系人。我们会通过两种方式来实现这个目标：一种是使用独立的插入声明，另一种是使用数据库类的方法。最后，我们还会测试一下我们的代码，确保它能正常工作。 ### 1. 使用独立的插入声明插入联系人 首先，我们来看第一种方法，使用独立的插入声明。这种方法非常简单，你只需要创建一个新的联系人对象，然后使用`insert`语句将它插入到数据库中。 ```apex // 创建一个新的联系人对象 Contact newContact = new Contact(); newContact.FirstName = &#39;John&#39;; newContact.LastName = &#39;Doe&#39;; newContact.Email = &#39;john.doe@example.com&#39;; // 使用insert语句插入联系人 insert newContact; ``` 在这段代码中，我们首先创建了一个`Contact`对象，并设置了它的`FirstName`、`LastName`和`Email`字段。然后，我们使用`insert`语句将这个联系人插入到数据库中。 ### 2. 使用数据库类方法插入联系人 接下来，我们来看第二种方法，使用数据库类的方法。这种方法比第一种稍微复杂一点，但它提供了更多的灵活性，比如可以处理部分成功的情况。 ```apex // 创建一个新的联系人对象 Contact newContact = new Contact(); newContact.FirstName = &#39;Jane&#39;; newContact.LastName = &#39;Smith&#39;; newContact.Email = &#39;jane.smith@example.com&#39;; // 使用Database.insert方法插入联系人 Database.SaveResult result = Database.insert(newContact, false); // 检查插入是否成功 if (result.isSuccess()) { System.debug(&#39;联系人插入成功，ID: &#39; + result.getId()); } else { for(Database.Error err : result.getErrors()) { System.debug(&#39;错误信息: &#39; + err.getMessage()); } } ``` 在这段代码中，我们同样创建了一个`Contact`对象，并设置了它的字段。然后，我们使用`Database.insert`方法来插入联系人。`Database.insert`方法的第二个参数`false`表示我们允许部分成功，也就是说，即使插入失败，也不会抛出异常。最后，我们通过`Database.SaveResult`对象来检查插入是否成功，并输出相应的信息。 ### 3. 测试代码 最后，我们需要测试一下我们的代码，确保它能正常工作。你可以通过Salesforce的开发者控制台来运行这些代码，并查看调试日志中的输出。 ```apex // 测试代码 System.debug(&#39;开始测试插入联系人...&#39;); // 使用独立的插入声明插入联系人 Contact newContact1 = new Contact(); newContact1.FirstName = &#39;John&#39;; newContact1.LastName = &#39;Doe&#39;; newContact1.Email = &#39;john.doe@example.com&#39;; insert newContact1; // 使用数据库类方法插入联系人 Contact newContact2 = new Contact(); newContact2.FirstName = &#39;Jane&#39;; newContact2.LastName = &#39;Smith&#39;; newContact2.Email = &#39;jane.smith@example.com&#39;; Database.SaveResult result = Database.insert(newContact2, false); // 检查插入是否成功 if (result.isSuccess()) { System.debug(&#39;联系人插入成功，ID: &#39; + result.getId()); } else { for(Database.Error err : result.getErrors()) { System.debug(&#39;错误信息: &#39; + err.getMessage()); } } System.debug(&#39;测试完成。&#39;); ``` 在这段测试代码中，我们首先输出一条调试信息，表示测试开始。然后，我们分别使用两种方法插入联系人，并检查插入是否成功。最后，我们输出一条调试信息，表示测试完成。 好了，同学们，这就是我们今天的内容。通过这两种方法，你可以在Salesforce中轻松地插入联系人。希望你们能掌握这些知识，并在实际项目中灵活运用。如果有任何问题，随时问我哦！

  ▶ 播放视频 查看详情
• 123

  Module Agenda - 204

  第 204 页

  同学们，今天我们来聊聊模块7：TLR要点。这个模块主要分为三个部分，我会用简单易懂的方式来给大家讲解。 首先，我们来看，持久数据的选项，。持久数据，顾名思义，就是那些需要长期保存的数据。在Salesforce中，我们有几种方式来存储这些数据。最常见的就是使用标准对象和自定义对象。标准对象是Salesforce自带的，比如Account、Contact等；而自定义对象则是根据业务需求自己创建的。此外，我们还可以使用外部数据库来存储数据，通过API与Salesforce进行数据交互。 接下来是，排队TLR活动，。TLR是Transaction Log Replay的缩写，简单来说，就是记录和重放事务日志。在Salesforce中，TLR活动可以帮助我们追踪数据的变更历史。排队TLR活动意味着我们要把这些活动按照一定的顺序排列，确保它们能够按照正确的顺序执行。这就像是在餐厅排队点餐，先来后到，确保每个人都能按顺序得到服务。 最后，我们来看，处理TLR错误和调试，。在TLR过程中，难免会遇到一些错误。这些错误可能是因为数据不一致、网络问题或者其他原因导致的。处理这些错误的关键是找到问题的根源。我们可以通过查看日志、调试代码来定位问题。调试的过程就像是侦探破案，一步步排查，直到找到问题的源头。 总结一下，今天的内容主要讲了持久数据的存储方式、如何排队TLR活动以及如何处理TLR错误和调试。希望大家能够理解这些概念，并在实际工作中灵活运用。如果有任何问题，随时提问哦！

  ▶ 播放视频 查看详情
• 124

  Which Code Blocks Result in an Exception?

  第 205 页

  同学们，今天我们来聊聊在Salesforce开发中，哪些代码块可能会导致异常。异常，简单来说，就是代码在运行过程中遇到了问题，无法继续正常执行。我们来看一下几个常见的例子： ，A：好， 这个选项表示代码运行正常，没有异常。所以，A选项不会导致异常。 ，B：缺少必需字段， 这个选项表示在插入或更新记录时，缺少了必需的字段。比如，你在插入一个联系人记录时，没有填写“姓氏”这个字段，Salesforce就会抛出异常，提示你“RECIRED_FIELD_MISSING”。所以，B选项会导致异常。 ，C：空对象， 这个选项表示你在代码中尝试操作一个空对象。比如，你有一个列表，但列表是空的，而你却试图访问列表中的第一个元素。这时，Salesforce会抛出“System.ListException”异常。所以，C选项也会导致异常。 ，D：州长限制， Salesforce有一个叫做“州长限制”的机制，用来防止代码消耗过多的资源。比如，你在一个事务中查询了超过100条记录，或者在一个循环中执行了太多的DML操作，Salesforce就会抛出“LimitException”异常。所以，D选项也会导致异常。 ，E：字符串太长， 这个选项表示你尝试插入或更新的字段值超过了字段的最大长度。比如，你有一个字段的最大长度是50个字符，但你却试图插入一个100个字符的字符串，Salesforce就会抛出“STRING_TOO_LONG”异常。所以，E选项也会导致异常。 总结一下，除了A选项，其他选项都可能导致异常。我们在编写代码时，一定要注意这些细节，避免出现这些问题。 如果你对这些问题感兴趣，可以访问这个链接，了解更多可能导致Salesforce Apex代码出现问题的原因：[额外材料](http://opfocus.com/blog/5-things-that-could-give-your-custom-salesforce-apex-code-hiccups/) 好了，今天的讲解就到这里，希望大家在编写代码时能够避免这些常见的异常。如果有任何问题，欢迎随时提问！

  ▶ 播放视频 查看详情
• 125

  Overcoming Exceptions

  第 206 页

  同学们，今天我们来聊聊Salesforce开发中一个非常常见但又让人头疼的问题——异常处理。想象一下，你正在编写一段代码，突然，程序报错了，这就是我们所说的异常。那么，如何有效地处理这些异常呢？让我们一起来看看。 首先，我们来看一下幻灯片上的几个例子： ，A：不会造成异常， 这种情况是最理想的，代码运行得非常顺利，没有任何问题。但现实往往不会这么简单。 ，B：System.DmlException: 插入失败。第0行上的第一个异常;第一个错误：REQUIRED_FIELD_MISSING， 这个错误告诉我们，某个必填字段没有填写。比如，你在插入一条记录时，忘记填写某个必填字段，Salesforce就会抛出这个异常。解决方法是检查你的代码，确保所有必填字段都有值。 ，C：System.ListException: TLR陈述在位置0处发现空SObitch//RST异常，该异常发生在TLR陈述执行期间， 这个错误通常发生在你试图访问一个空列表或空对象时。比如，你试图从一个空列表中获取第一个元素，就会抛出这个异常。解决方法是确保你操作的列表或对象不为空。 ，D：限制例外， 这个错误通常与Salesforce的某些限制有关，比如API调用次数超过限制、存储空间不足等。解决方法是优化你的代码，减少资源消耗，或者申请更高的限制。 ，E：System.DmlException: 插入失败。第0行上的第一个异常;第一个错误：WRONG_TOO_LONG，姓氏：数据值太大， 这个错误告诉我们，某个字段的值超出了允许的最大长度。比如，你试图插入一个姓氏，但这个姓氏的长度超过了字段定义的最大长度。解决方法是检查字段的长度限制，并确保输入的数据符合要求。 最后，我还给大家准备了一个额外的学习材料，链接在这里：[5 Things That Could Give Your Custom Salesforce Apex Code Hiccups](http://opfocus.com/blog/5-things-that-could-give-your-custom-salesforce-apex-code-hiccups/)。这个链接里有很多关于Salesforce Apex代码中常见问题的讨论，建议大家课后可以去看一看。 好了，今天的课程就到这里。希望大家在编写Salesforce代码时，能够更好地处理这些异常，写出更健壮的程序。如果有任何问题，随时来找我讨论。谢谢大家！

  ▶ 播放视频 查看详情
• 126

  Catching Exceptions

  第 207 页

  同学们，今天我们来聊聊Salesforce中的DML操作和异常处理。首先，我们来看一个常见的场景：当你使用`Database.insert(X, false)`这样的语句时，你可能会注意到，即使有些记录插入失败了，代码也不会抛出异常。这是为什么呢？ 这是因为`Database.insert(X, false)`中的`false`参数告诉Salesforce，即使有记录插入失败，也不要立即抛出异常。相反，它会继续尝试插入所有记录，并将所有失败的记录和相关的错误信息收集起来，放在一个叫做`DMLException`的对象中。这样，你就可以在操作完成后，统一处理这些失败的记录和错误。 接下来，我们来看另一个教学点。如果你希望执行一个“全有或全无”的DML操作，也就是说，要么所有记录都成功插入，要么一个都不插入，那么你应该使用`Database.insert(X, true)`。在这种情况下，如果任何一个记录插入失败，Salesforce会立即抛出异常，并且整个操作会回滚，就像什么都没发生过一样。这种方式被称为“优雅的失败”，因为它确保了数据的一致性，避免了部分成功的情况。 总结一下，`Database.insert(X, false)`允许你处理部分失败的记录，而`Database.insert(X, true)`则确保要么全部成功，要么全部失败。根据你的业务需求，选择合适的方式来处理DML操作，是非常重要的。 希望这个解释对你们有帮助！如果有任何问题，随时提问哦！

  ▶ 播放视频 查看详情
• 127

  Capturing the Result of Partial Processing

  第 208 页

  今天我们来聊聊在Salesforce中使用Apex进行数据库操作时，如何处理插入和更新操作的结果。特别是当我们使用`Database.insert`或`Database.update`方法时，系统会返回一个`SaveResult`对象的数组。这个数组中的每个元素都对应着我们传递给方法的`sObject`数组中的每一个记录。 举个例子，假设我们有一个`sObject`数组，里面有两个记录。当我们调用`Database.insert(sObjects, false)`时，系统会返回一个包含两个`SaveResult`对象的数组。第一个`SaveResult`对象对应数组中的第一个`sObject`，第二个`SaveResult`对象对应第二个`sObject`。如果数组中只有一个`sObject`，那么返回的`SaveResult`数组也只有一个元素。 每个`SaveResult`对象都包含了关于该记录操作是否成功的信息。如果操作成功，我们可以通过`SaveResult`对象获取到新记录的ID；如果操作失败，我们可以通过`SaveResult`对象获取到错误信息，帮助我们了解为什么操作失败了。 这种机制非常有用，因为它允许我们批量处理记录，并且能够精确地知道每一条记录的处理结果。这样，我们就可以在代码中根据这些结果做出相应的处理，比如记录日志、发送通知或者进行重试等。 希望这个解释能帮助你更好地理解在Salesforce中如何处理数据库操作的结果。如果你有任何问题，随时问我哦！

  ▶ 播放视频 查看详情
• 128

  Processing a List<Database.SaveResult>

  第 209 页

  同学们，今天我们来聊聊如何在Salesforce中处理一个叫做``的列表。这个列表里包含了我们尝试保存到数据库中的每个对象的保存结果。每个结果都是一个`SaveResult`对象，它告诉我们保存操作是成功了还是失败了。 首先，当你尝试保存一组对象时，比如通过`Database.insert`或`Database.update`方法，Salesforce会返回一个``的列表。这个列表中的每个元素都对应你尝试保存的每一个对象。 对于每一个`SaveResult`，你可以调用`isSuccess()`方法来检查这个对象的保存是否成功。如果返回`true`，那就意味着这个对象已经成功保存到数据库中了，你不需要再做任何事情。 但是，如果`isSuccess()`返回`false`，那就意味着保存失败了。这时候，你需要进一步处理错误。你可以通过调用`getErrors()`方法来获取一个`Database.Error`对象的列表，这个列表会告诉你为什么保存失败了。每个`Database.Error`对象都包含了错误的详细信息，比如错误消息和错误代码，这样你就可以根据这些信息来决定如何处理这个错误。 总结一下，处理``列表的基本步骤是：首先检查每个保存结果是否成功，如果成功就继续，如果失败就处理错误。这样，你就可以确保你的数据在Salesforce中正确地保存了。希望这个解释对你们有帮助！如果有任何疑问，随时提问哦。

  ▶ 播放视频 查看详情
• 129

  7-2: Handle DML Errors and Exceptions

  第 210 页

  同学们，今天我们来学习如何处理Salesforce中的错误和异常任务。特别是当我们尝试插入联系人到数据库时，可能会遇到一些问题。我们的目标是找出这些错误的原因，并学会如何处理它们。 首先，我们需要了解的是，当我们尝试插入联系人时，可能会因为多种原因失败。比如，联系人信息不完整，或者违反了某些业务规则。为了找出这些错误，我们可以使用Salesforce提供的调试工具来查看错误信息。 接下来，我们需要编写一些代码来尝试插入联系人，并捕获可能出现的错误。我们可以使用try-catch语句来捕获异常，并在catch块中打印出错误信息。这样，我们就可以清楚地知道是什么原因导致了插入失败。 例如，我们可以这样写代码： ```apex try { // 尝试插入联系人 insert new Contact(LastName=&#39;Doe&#39;, Email=&#39;doe@example.com&#39;); } catch (DmlException e) { // 捕获异常并打印错误信息 System.debug(&#39;插入联系人失败，原因：&#39; + e.getMessage()); } ``` 在这段代码中，我们尝试插入一个姓为“Doe”，电子邮件为“doe@example.com”的联系人。如果插入失败，catch块会捕获异常，并使用System.debug方法打印出错误信息。 最后，我们需要测试我们的代码，确保它能够正确地捕获和处理错误。我们可以在Salesforce的开发者控制台中运行这段代码，并查看调试日志，确认错误信息是否正确打印。 这就是今天的内容，希望大家能够理解并掌握如何处理Salesforce中的错误和异常任务。如果有任何问题，欢迎随时提问。谢谢大家！

  ▶ 播放视频 查看详情
• 130

  Staying Within Governor Limits When Using DML (1)

  第 211 页

  让我们来聊聊Salesforce中的DML操作和调控器限制。首先，DML是Data Manipulation Language的缩写，简单来说，就是用来在Salesforce中创建、更新、删除记录的操作。 现在，想象一下，你有一个任务，需要更新150条记录。你可能会想，直接在循环中一条一条更新不就行了吗？但这里有个陷阱！Salesforce有一个叫做“调控器限制”的东西，它就像是一个安全网，防止你的代码消耗太多资源。在这个例子中，如果你尝试在循环中更新超过150条记录，系统就会抛出异常，告诉你：“嘿，你超出了限制！” 那么，怎么避免这个问题呢？这里有几个步骤： 1. ，查找限制指南，：首先，你需要知道Salesforce的具体限制是多少。你可以在Salesforce的官方文档中找到这些信息，这就像是你的操作手册，告诉你哪些可以做，哪些不能做。 2. ，使用SOQL for Loop，：接下来，你可以使用SOQL for Loop来改进你的代码。SOQL是Salesforce Object Query Language的缩写，它可以帮助你更有效地查询数据。在这个改进的版本中，你可以在循环中一次处理一条记录，这样可以避免一次性处理太多数据而触调控器限制。 3. ，优化列表处理，：最后，你可以进一步优化你的代码，使用List的形式来处理数据。这样，你可以在循环中“中间更新”列表，而不是在循环外维护一个单独的列表。这样做的好处是，可以减少内存的使用，避免堆大小的问题。 总结一下，处理Salesforce中的数据时，要时刻注意调控器限制，合理使用SOQL和DML操作，确保你的代码既高效又安全。希望这些信息对你有帮助！

  ▶ 播放视频 查看详情
• 131

  Staying Within Governor Limits When Using DML (2)

  第 212 页

  同学们，今天我们来聊聊Salesforce中的DML操作，特别是如何在操作时保持调控器的限制范围内。记住，调控器限制是我们的安全线，永远不要越界！ 首先，我们来看一下这张幻灯片。它提到了一个重要的限制——6MB的堆大小限制。这个限制是什么意思呢？简单来说，就是你的代码在运行时，使用的内存不能超过6MB。如果超过了，Salesforce就会抛出错误，你的代码就会停止运行。 幻灯片中提到了一个具体的例子：当你在循环外部添加记录到一个列表时，可能会达到堆大小的限制。这是因为每次循环迭代时，记录都被添加到同一个列表中，这个列表会越来越大，最终可能超过6MB的限制。 那么，我们怎么解决这个问题呢？这里有一个技巧，就是使用SOQL for Loop的List形式。这种方式允许我们在每次循环迭代时，只处理一部分记录，而不是一次性加载所有记录到内存中。这样，我们就可以避免在循环外部维护一个巨大的列表，从而避免堆大小的问题。 总结一下，关键点就是：在使用DML操作时，要时刻注意调控器的限制，特别是堆大小的限制。通过使用SOQL for Loop的List形式，我们可以有效地管理内存使用，确保我们的代码既高效又安全。 希望这个解释对你们有帮助，如果还有疑问，随时提问哦！

  ▶ 播放视频 查看详情
• 132

  Staying Within Governor Limits When Using DML (3)

  第 213 页

  让我们来聊聊在使用Salesforce的TLR（Transaction Log Replay）时，如何保持在州长限制内的三个关键点。首先，我们要记住的是，每200条记录中，你最终会在第5行使用一条TLR声明。这个时候，你可能需要和学生们一起查看“查询/查询更多”的功能，这有助于更好地理解数据是如何被处理和更新的。 接下来，背景部分告诉我们，通过使用SOQL For Loop的List形式，我们可以解决将List置于Loop之外的潜在堆大小问题。这里的关键是，每次迭代列表都可以“在中间更新”，这样做的好处是避免了在循环之外拥有一个单独的列表集合，从而减少了堆大小的问题。 简单来说，就是通过优化我们的代码结构，确保在处理大量数据时，不会超出Salesforce的州长限制，同时保持代码的效率和性能。这样，我们就可以更有效地管理和更新数据，确保系统的稳定运行。

  ▶ 播放视频 查看详情
• 133

  Key Takeaways - 214

  第 214 页

  同学们，今天我们来聊聊Salesforce中的Apex数据操纵语言。这个语言非常强大，它允许我们将新的数据或者修改后的数据保存到我们的Salesforce组织中。简单来说，就是通过Apex代码来操作数据。 在Apex中，有几个基本的命令可以帮助我们完成数据的增删改查。这些命令包括：插入（Insert）、更新（Update）、删除（Delete）和取消删除（Undelete）。这些命令就像是我们的工具箱，可以帮助我们处理数据。 使用这些命令有两种方式：一种是直接使用独立的命令，比如直接写“insert account;”来插入一个新的账户记录。另一种是使用数据库类的方法，比如“Database.insert(account);”。这两种方式都可以达到相同的目的，但使用数据库类的方法可以提供更多的控制选项，比如可以设置是否允许部分成功。 举个例子，如果我们有一批数据要插入，但其中有些数据可能不符合要求，我们可以使用“Database.insert(accounts, false);”这样的语句。这里的“false”表示如果其中有一条记录插入失败，那么所有的记录都不会被插入。如果我们设置为“true”，那么即使有部分记录插入失败，其他记录仍然会被插入。 好了，这就是今天的主要内容。希望大家能够理解Apex数据操纵语言的基本概念和使用方法。如果有任何疑问，欢迎随时提问。我们下次课再见！

  ▶ 播放视频 查看详情
• 134

  Module 8: Trigger Essentials

  第 215 页

  同学们，今天我们来聊聊Salesforce中的触发器，也就是Apex Triggers。触发器是一个非常强大的工具，它可以在数据库操作发生时自动执行一些代码。想象一下，当你在Salesforce中添加或更新一条记录时，触发器就像是一个小助手，自动帮你完成一些额外的任务。 触发器主要有四种类型：在插入记录之前（Before Insert）、在插入记录之后（After Insert）、在更新记录之前（Before Update）和在更新记录之后（After Update）。每种类型都有其特定的用途。 1. ，Before Insert，：这种触发器在记录被插入数据库之前执行。你可以在这里做一些验证或者修改记录的数据。比如，你可以检查某个字段是否符合特定的格式要求，如果不符合，就阻止记录的插入。 2. ，After Insert，：这种触发器在记录被插入数据库之后执行。这里通常用于触发一些后续的操作，比如发送通知或者创建相关的记录。 3. ，Before Update，：这种触发器在记录被更新之前执行。你可以在这里检查更新的数据是否符合业务规则，如果不符合，可以阻止更新操作。 4. ，After Update，：这种触发器在记录被更新之后执行。这里通常用于触发一些后续的操作，比如更新相关的记录或者发送更新通知。 触发器的机制其实很简单：当某个事件（比如插入或更新）发生时，Salesforce会自动调用相应的触发器代码。你只需要编写好这些代码，Salesforce就会在适当的时候执行它们。 为了更深入地理解触发器，我建议大家去查看一下Salesforce开发者网站上的一个深度讲解触发器的网络研讨会，链接我已经放在资源部分了。这个研讨会会帮助你更好地理解触发器的工作原理和如何有效地使用它们。 好了，今天关于触发器的基本介绍就到这里。记住，触发器是Salesforce自动化的重要组成部分，掌握它们可以大大提高你的工作效率。下次我们会继续探讨触发器的更多细节和最佳实践。谢谢大家！

  ▶ 播放视频 查看详情
• 135

  Module Objectives - 216

  第 216 页

  同学们，今天我们来聊聊Salesforce中的触发器（Trigger）。触发器是一个非常强大的工具，它可以帮助我们在数据库中自动执行某些操作，比如在特定条件下自动更新记录、发送通知或者阻止某些操作的发生。 首先，触发器的用途是什么呢？简单来说，触发器就是一段代码，它会在数据库中的记录被插入、更新或删除时自动运行。比如，如果我们想要确保课程预约不会安排在假期开始的时候，我们就可以使用触发器来实现这个逻辑。 接下来，我们来看看触发器的定义语法。触发器是写在Apex代码中的，它的基本结构是这样的： ```apex trigger TriggerName on ObjectName (trigger_events) { // 触发器逻辑 } ``` 这里的`TriggerName`是你给触发器起的名字，`ObjectName`是你想要监控的对象（比如课程预约），`trigger_events`是触发器触发的事件，比如`before insert`、`after update`等。 在这个例子中，我们想要阻止课程预约被安排在假期开始的时候，所以我们可能会在`before insert`或`before update`事件中写一些逻辑来检查预约的日期，如果日期在假期内，就阻止这个预约的创建或更新。 最后，我们还需要使用触发上下文变量。这些变量可以帮助我们获取当前触发器的上下文信息，比如当前操作是插入、更新还是删除，以及操作涉及的具体记录。常用的触发上下文变量有`Trigger.isBefore`、`Trigger.isAfter`、`Trigger.new`等。 总结一下，触发器可以帮助我们自动执行一些逻辑，确保数据的完整性和业务规则的执行。通过定义触发器的语法和使用触发上下文变量，我们可以灵活地控制数据库中的操作。 现在，让我们回到我们的业务问题：如何确保课程预约不能安排在假期开始？我们可以创建一个触发器，在课程预约被创建或更新之前检查预约的日期，如果日期在假期内，就阻止这个操作。这样，我们就可以确保课程预约不会安排在假期开始的时候了。 希望这个解释对你们有帮助！如果有任何问题，随时问我哦。

  ▶ 播放视频 查看详情
• 136

  Module Agenda - 217

  第 217 页

  同学们，今天我们来聊聊Salesforce中的“触发要素”。这个模块其实非常有趣，因为它涉及到如何让Salesforce系统自动帮我们做一些事情。想象一下，如果你有一个小助手，能在特定情况下自动帮你完成一些任务，是不是很省心呢？这就是触发器的魔力！ 首先，我们来看看“自动化逻辑”。简单来说，自动化逻辑就是告诉Salesforce在什么情况下应该做什么事情。比如，当一个新的客户记录被创建时，系统可以自动发送一封欢迎邮件。这就是一个自动化逻辑的例子。 接下来是“定义触发器”。触发器是Salesforce中的一种特殊工具，它可以在某些事件发生时自动执行一些操作。比如，当某个字段的值发生变化时，触发器可以自动更新其他相关记录。定义触发器就是告诉Salesforce在什么事件发生时应该触发这个自动化逻辑。 最后，我们来看看“定义触发逻辑”。触发逻辑就是具体的操作步骤，告诉Salesforce在触发器被触发后应该做什么。比如，如果触发器是在客户记录被创建时触发的，那么触发逻辑可能就是发送一封欢迎邮件。 总结一下，触发要素模块就是教我们如何利用Salesforce的自动化功能，让系统在特定情况下自动帮我们完成一些任务。通过定义触发器、自动化逻辑和触发逻辑，我们可以大大提高工作效率，减少手动操作的麻烦。 好了，今天的课程就到这里，希望大家对触发要素有了更清晰的理解。如果有任何问题，随时提问哦！

  ▶ 播放视频 查看详情
• 137

  Working with Data in Apex: A Common Pattern - 218

  第 218 页

  今天我们来聊聊在Apex中如何使用数据，特别是那些常见的模式。想象一下，你手里有一堆联系人信息，你需要对这些信息进行一些操作，比如删除、修改，然后再保存回数据库。这个过程听起来简单，但在Apex中，我们需要遵循一些特定的步骤和模式。 首先，我们来看第一个步骤：从数据库中删除要修改的联系人。这就像是你从你的手机通讯录中删掉一个不再需要的联系人。在Apex中，我们使用`delete`语句来执行这个操作。这个操作会直接从数据库中移除指定的联系人记录。 接下来，我们进入第二个步骤：修改内存中的联系人对象。这一步就像是你编辑手机通讯录中的联系人信息。在Apex中，我们首先需要从数据库中检索出这些联系人信息，然后在内存中进行修改。这里的关键是，所有的修改都是在内存中进行的，还没有影响到数据库。 最后，我们来到第三个步骤：将修改后的联系人对象中的数据持久保存到数据库。这一步就像是你点击“保存”按钮，将你编辑好的联系人信息保存回手机通讯录。在Apex中，我们使用`update`语句来将内存中的修改写回到数据库中。 现在，让我们来谈谈一个重要的教学点：触发器（Trigger）的运行时机。在Apex中，触发器是在数据操作的最右边区块中运行的。这意味着，当你在Apex中执行数据操作（如插入、更新、删除）时，触发器会在这些操作的最后阶段被触发。理解这一点对于掌握Apex中的数据流非常重要。 总结一下，我们在Apex中处理数据时，通常遵循删除、修改、保存的模式。同时，我们需要记住触发器在数据操作的最后阶段运行。希望这些信息能帮助你在Apex中更有效地处理数据。如果有任何疑问，随时提问哦！

  ▶ 播放视频 查看详情
• 138

  Determining if a Course Delivery starts on a Holiday

  第 219 页

  让我们来聊聊这个场景。假设你正在管理一个培训课程，这个课程有一个开始日期。现在，我们想要确保这个开始日期不会落在假期里。如果开始日期是假期，我们就需要做一些调整。 首先，我们需要知道什么是假期。在Salesforce里，有一个叫做“Holiday”的对象，它是系统自带的，你可以把它想象成一个日历，里面标记了所有的公共假期。这个对象是专门用来帮助我们管理日期的，和其他的业务对象没有直接关系。 现在，回到我们的场景。我们有一个课程交付的开始日期，我们需要检查这个日期是否在“Holiday”对象里标记为假期。如果是，我们就需要做一些调整，比如把课程的开始日期推迟到下一个工作日。 为了简化问题，我们暂时只关注开始日期。即使课程的其他部分有假期，我们也不做调整。这样，我们就可以集中精力解决开始日期的问题。 接下来，我们会逐步构建一个触发器，这个触发器会自动检查开始日期是否是假期，并做出相应的调整。这个过程会涉及到一些Apex编程，但我们会一步一步来，确保你能跟上。 所以，这就是我们的场景和我们要解决的问题。通过这个例子，你会学习到如何在Salesforce中使用触发器和Apex来处理复杂的业务逻辑。希望这个解释对你有帮助，如果有任何问题，随时问我！

  ▶ 播放视频 查看详情
• 139

  Why Can't You Build this Logic Declaratively?

  第 220 页

  让我们来聊聊为什么Jason Beck不能使用声明性的方式来实现这个逻辑。首先，我们需要理解Salesforce中的声明性工具，比如验证规则、工作流程、Process Builder等，它们都是非常强大的工具，可以帮助我们自动化很多业务流程，但有时候它们也有自己的限制。 在这个案例中，Jason想要阻止在特定假日（Holiday）期间创建培训交付记录（TLR）。听起来很简单，对吧？但是，问题出在Holiday对象上。Holiday对象是一个特殊的对象，它不是标准的Salesforce对象，也不是全局对象，这意味着我们不能直接通过跨对象公式字段来访问它。跨对象公式字段通常用于访问相关对象的字段，但Holiday对象并不在Course_Delivery_c对象的关联范围内。 接下来，我们来看看工作流程。工作流程可以用来自动化一些任务，比如发送电子邮件或者更新字段，但它不能直接访问Holiday对象，也不能阻止对象的创建。所以，工作流程在这里也帮不上忙。 验证规则呢？验证规则是用来确保数据输入的准确性的，它们可以在数据保存之前检查某些条件。但是，验证规则只能处理当前对象的字段，不能处理不相关对象的字段。所以，验证规则也无法帮助我们检查Holiday对象。 最后，我们来看看Process Builder。Process Builder是一个非常强大的工具，可以用来创建复杂的业务流程。理论上，Process Builder可以访问Holiday对象，但是这样做会让流程变得非常复杂，尤其是当你需要处理多个条件和多个对象时。而且，使用Process Builder来处理这种情况，可能会涉及到使用流的收件箱，这会让整个流程变得更加复杂。 所以，总结一下，虽然Salesforce提供了很多声明性的工具来帮助我们自动化业务流程，但在某些情况下，比如需要访问特殊对象或者处理复杂的跨对象逻辑时，这些工具可能就不够用了。这时候，我们可能需要考虑使用Apex代码来实现这些逻辑，因为Apex提供了更大的灵活性和控制力。

  ▶ 播放视频 查看详情
• 140

  A Trigger Provides a Code-Based Solution

  第 221 页

  大家好，今天我们来聊聊Salesforce中的触发器（Triggers）。触发器是一个非常强大的工具，它可以在数据库操作（DML）发生时自动执行一些代码。这意味着，当你在Salesforce中创建、更新或删除记录时，触发器可以自动启动，执行你预设的逻辑。 首先，触发器可以定义在标准对象上，比如Account或Contact，也可以定义在自定义对象和一些标准子对象上。一旦创建，触发器默认就是激活状态。当指定的数据库事件发生时，比如插入或更新记录，Salesforce就会自动触发这些触发器。 触发器的一个常见用途是根据特定条件来修改相关记录，或者限制某些操作的发生。例如，你可以使用触发器来验证字段值，或者更新记录上的字段。这些都是通过Salesforce的用户界面中的点击式工具无法完成的任务。 触发器特别适合在以下情况下使用： - 当你需要访问与当前操作无关的对象时。 - 当你需要中止正在进行的DML操作时。 - 当你需要实施Apex共享时。 - 当发起用户不能访问出于正当理由而被“锁定”的数据时。 触发器在系统模式下执行，这意味着它们可以查看所有对象和数据，无论用户的权限如何。 此外，Andres提到一个有趣的点：在软保存已经发生之后，BEFORE触发器可以在稍后的执行保存顺序中再次运行。这意味着BEFORE触发器不仅仅发生在软存储之前，它们可能在保存过程中被多次调用。 在接下来的模块中，我们会更深入地探讨保存执行顺序，并展示触发器的一些其他调用方式，而不仅仅是DML操作。 如果你想了解更多关于触发器的信息，可以参考以下资源： - [Apex Triggers](https://developer.salesforce.com/docs/atlas.en-us.apexcode.meta/apexcode/apex_triggers.htm) - [Order of Execution for Triggers](https://developer.salesforce.com/docs/atlas.en-us.apexcode.meta/apexcode/apex_triggers_order_of_execution.htm) 希望这些信息对你们有所帮助，我们下次再见！

  ▶ 播放视频 查看详情
• 141

  What Are the Two Types of Triggers Used For?

  第 222 页

  让我们来聊聊Salesforce中的触发器类型。触发器主要有两种类型：Before触发器和After触发器。听起来好像是在说它们什么时候运行，但实际上，它们的主要区别在于它们能做什么。 首先，Before触发器。这种触发器在记录被保存到数据库之前运行。这意味着你可以在数据真正进入数据库之前，对数据进行修改或验证。比如，如果你想要确保某个字段在保存前必须满足特定条件，你就可以在Before触发器中添加这个逻辑。 然后，After触发器。这种触发器在记录已经被保存到数据库之后运行。这时候，你可以访问系统自动分配的字段，比如记录的ID。如果你需要在记录保存后，基于这个记录的ID做一些操作，比如创建相关的记录或者发送通知，After触发器就是你的好帮手。 举个例子，如果你需要在插入一条课程交付记录后，发布一个指向这条记录的链接，你就需要一个After触发器，因为你需要这条记录的ID来生成链接。 记住，虽然Before和After触发器听起来像是关于时间的，但它们更多的是关于你能在触发器中做什么。在后面的学习中，我们会更深入地探讨触发器的执行顺序和其他调用方式，但现在，最重要的是理解这两种触发器的主要用途和它们能做的事情。 希望这能帮助你更好地理解Salesforce中的触发器类型！如果有任何疑问，随时提问哦！

  ▶ 播放视频 查看详情
• 142

  Module Agenda - 223

  第 223 页

  同学们，今天我们来聊聊Salesforce中的“触发要素”。这个模块其实挺有意思的，它主要讲的是如何在Salesforce中设置自动化逻辑，让系统在特定条件下自动执行一些操作。听起来是不是有点像魔法？其实没那么神秘，我们一步步来。 首先，我们要理解什么是“触发器”。触发器就像是Salesforce里的一个小哨兵，它时刻盯着数据库里的变化。一旦有记录被创建、更新或删除，这个小哨兵就会立刻行动起来，执行我们预先设定好的逻辑。 接下来，我们要定义“触发逻辑”。这个逻辑就是我们希望系统在什么情况下做什么事情。比如，当一个新的客户记录被创建时，我们可能希望自动发送一封欢迎邮件。这个“当……时，就……”的逻辑，就是我们要定义的触发逻辑。 在这个模块里，我们会学习如何设置这些触发器，如何编写触发逻辑，以及如何测试和调试这些自动化流程。听起来是不是有点复杂？别担心，我们会通过一些实际的例子来一步步讲解，确保大家都能跟上。 好了，这就是我们今天要讲的“触发要素”模块的概览。接下来，我们会深入每个部分，详细讲解如何操作。准备好了吗？那我们开始吧！

  ▶ 播放视频 查看详情
• 143

  Four Key Questions to Ask Before Writing a Trigger

  第 224 页

  同学们，今天我们来聊聊在Salesforce中撰写触发器之前需要问的四个关键问题。这些问题能帮助我们更好地理解触发器的使用场景和目的，确保我们的代码既高效又符合业务需求。 首先，第一个问题是：，触发器的对象是什么？， 在这个例子中，我们的触发器是针对`Course_Delivery__c`这个对象的。这意味着当这个对象的记录发生变化时，触发器会被触发。 第二个问题是：，触发器会在什么事件下触发？， 这里我们关注的是有意义的保存事件，比如记录的插入或更新。也就是说，当有新的课程交付记录被创建，或者现有的记录被修改时，触发器就会启动。 第三个问题是：，触发器是在事件之前还是之后执行？， 在这个案例中，我们选择在事件之前执行触发器。这是因为我们主要进行的是验证工作。如果验证通过，记录就会被保存；如果不通过，记录就不会被保存。虽然也可以在事件之后执行触发器，但在这里并不必要。 最后一个问题是：，触发器的目的是什么？， 在这个例子中，触发器的目的是确保课程交付的开始日期不是假期。如果开始日期是假期，触发器会阻止记录的保存，从而避免业务逻辑上的错误。 总结一下，这四个问题帮助我们明确了触发器的对象、触发事件、执行时机以及目的。通过回答这些问题，我们可以更有针对性地编写触发器，确保它们既符合业务需求，又不会造成不必要的资源浪费。 希望这些信息对你们有所帮助，如果还有任何疑问，随时提问哦！

  ▶ 播放视频 查看详情
• 144

  Syntax for Defining a Trigger

  第 225 页

  让我们来聊聊Salesforce中的触发器，特别是关于触发器的警告要点和如何定义它们。 首先，触发器（Trigger）是Salesforce中一个非常重要的概念。它是一段Apex代码，可以在特定的数据库事件发生时自动执行。触发器通常用于在数据被插入、更新或删除时执行一些自定义的逻辑。 ### 触发器的定义 触发器是保存Apex代码的两种主要方式之一，另一种方式是在类（Class）中。触发器的名称通常遵循一个特定的模式，比如 `Trigger`。这里的 `` 是你想要触发器的对象名称，比如 `Account` 或 `Contact`。 ### 触发器的位置 触发器是在sObject“上”定义的。这意味着当某个特定的TLR（Trigger、Load、Rollback）事件发生在该对象上时，触发器就会被触发。你可以为支持触发器的标准对象（如 `Account` 或 `Contact`）、一些标准子对象（如 `CaseComment`）以及自定义对象定义触发器。 ### 触发器支持的TLR事件 触发器支持多种TLR事件，包括： - ，Before Insert，：在记录被插入数据库之前触发。 - ，After Insert，：在记录被插入数据库之后触发。 - ，Before Update，：在记录被更新之前触发。 - ，After Update，：在记录被更新之后触发。 - ，Before Delete，：在记录被删除之前触发。 - ，After Delete，：在记录被删除之后触发。 - ，After Undelete，：在记录被恢复之后触发。 ### 触发器的警告要点 1. ，避免递归触发，：如果触发器在某种情况下反复触发自己，可能会导致无限循环。要小心处理这种情况。 2. ，性能考虑，：触发器中的代码应该尽量高效，避免复杂的逻辑和大量的数据库操作，以免影响系统性能。 3. ，错误处理，：确保触发器中有适当的错误处理机制，以防止数据不一致或系统崩溃。 4. ，测试覆盖率，：确保你的触发器有足够的测试覆盖率，以验证其在不同场景下的行为。 ### 示例 假设我们有一个 `Account` 对象，我们想在每次插入新账户时自动设置一个默认值。我们可以这样定义一个触发器： ```apex trigger AccountTrigger on Account (before insert) { for (Account acc : Trigger.new) { if (acc.Name == null) { acc.Name = &#39;Default Account Name&#39;; } } } ``` 这个触发器会在每次插入新账户之前检查账户名称是否为空，如果为空，则设置为默认值。 希望这些内容能帮助你更好地理解Salesforce中的触发器。如果你有任何问题，随时问我！

  ▶ 播放视频 查看详情
• 145

  Put it All Together: Write the Trigger Definition

  第 226 页

  让我们一起来学习如何在Salesforce中编写触发器。今天我们要讨论的是在`Course_Delivery__c`对象上创建一个触发器，这个触发器会在记录被插入之前和更新之前执行。 首先，触发器的定义是非常重要的。我们需要明确触发器是在哪个对象上触发的，以及在什么情况下触发。在这个例子中，我们选择的是`Course_Delivery__c`对象，并且我们希望触发器在记录被插入之前和更新之前执行。 触发器的基本结构是这样的： ```apex trigger CourseDeliveryTrigger on Course_Delivery__c (before insert, before update) { // 这里放置业务逻辑 } ``` 在这个结构中，`trigger`关键字后面跟着触发器的名称`CourseDeliveryTrigger`，然后是在哪个对象上触发`on Course_Delivery__c`，最后是触发条件`(before insert, before update)`。这意味着每当有新的`Course_Delivery__c`记录被插入或者现有的记录被更新时，这个触发器就会执行。 在触发器的花括号`{}`内，我们可以编写任何我们需要的业务逻辑。这些逻辑可以是验证数据、自动填充字段、发送通知等等。 为了帮助你更好地理解，你可以参考Salesforce的官方文档，那里有更多关于如何定义触发器的详细信息。你可以访问这个链接：[Salesforce触发器定义帮助文档](https://help.salesforce.com/apex/HTViewHelpDoc?id=code_define_trigger.htm)。 希望这个解释能帮助你理解如何在Salesforce中编写触发器。如果你有任何问题，随时问我！

  ▶ 播放视频 查看详情
• 146

  8-1: Define a Trigger

  第 227 页

  同学们，今天我们来学习如何在Salesforce中定义一个触发器。触发器是一个非常强大的工具，它可以在特定的数据库事件发生时自动执行一些操作。比如，当我们在Course_Delivery__c这个对象上插入、更新或删除记录时，触发器可以自动执行一些我们预设的逻辑。 首先，我们需要明确触发器的目标。在这个例子中，我们的目标是在Course_Delivery__c对象上定义一个触发器。这个触发器会在记录被插入、更新或删除时触发。 接下来，我们来看一下如何定义这个触发器。在Salesforce中，触发器是用Apex语言编写的。我们可以通过Salesforce的开发者控制台或者任何支持Apex的IDE来编写和部署触发器。 触发器的基本结构是这样的： ```apex trigger TriggerName on ObjectName (trigger_events) { // 触发器逻辑 } ``` 在这个结构中，`TriggerName`是你给触发器起的名字，`ObjectName`是你想要触发器的对象名，比如这里的Course_Delivery__c。`trigger_events`是你希望触发器响应的事件，比如`before insert`, `after update`等。 举个例子，如果我们想要在Course_Delivery__c对象上插入记录后执行一些操作，我们可以这样定义触发器： ```apex trigger CourseDeliveryTrigger on Course_Delivery__c (after insert) { // 这里写插入记录后要执行的逻辑 } ``` 在这个例子中，触发器会在每次有新的Course_Delivery__c记录被插入后自动执行我们写在里面的逻辑。 好了，这就是如何在Salesforce中定义一个触发器的基本步骤。记住，触发器是一个非常强大的工具，但也要谨慎使用，因为不当的使用可能会影响系统的性能。希望这个简短的介绍能帮助你们理解触发器的基本概念和使用方法。如果有任何问题，随时提问哦！

  ▶ 播放视频 查看详情
• 147

  Module Agenda - 228

  第 228 页

  让我们来聊聊Salesforce中的触发器（Triggers）。触发器是Salesforce中非常强大的工具，它允许你在数据库操作（如插入、更新、删除等）发生时自动执行特定的Apex代码。这就像是在你的Salesforce系统中设置了一个自动反应机制，当某些事件发生时，触发器就会自动启动，执行你预设的逻辑。 首先，我们需要定义触发器。触发器是与特定对象相关联的，比如Account、Contact等。你可以在Salesforce中为这些对象创建触发器。触发器的定义包括指定它应该在哪种数据库操作发生时触发，比如在记录被插入、更新或删除之前或之后。 接下来是定义触发逻辑。这是触发器的核心部分，你在这里编写Apex代码来指定当触发器被激活时应该执行什么操作。例如，你可能希望在每次创建一个新的联系人记录时，自动更新相关的客户记录。 在模块8：触发要素中，我们会深入探讨触发器的各个组成部分，包括如何编写高效的触发器代码，如何测试触发器，以及如何确保触发器的逻辑不会导致性能问题或数据不一致。 通过这个模块，你将学会如何利用触发器来增强你的Salesforce应用，使其更加自动化和高效。记住，触发器是强大的工具，但也要谨慎使用，确保它们不会对你的系统性能产生负面影响。

  ▶ 播放视频 查看详情
• 148

  Trigger Logic Can Access the Trigger Context

  第 229 页

  同学们，今天我们来聊聊Salesforce中的触发逻辑和上下文变量。这些概念听起来可能有点复杂，但我会用简单的方式来解释，让你们都能轻松理解。 首先，触发逻辑是Salesforce中一种强大的工具，它允许我们在数据发生变化时自动执行一些操作。比如，当一条记录被插入、更新或删除时，触发器就会自动运行。 现在，让我们来看看触发上下文中的一些关键点： 1. ，解释变量，：在触发器中，我们可以使用一些特殊的变量来访问当前操作的相关信息。比如，`Trigger.New`包含了在插入或更新操作中所有被处理的记录。而`Trigger.Old`则提供了在更新操作之前记录的旧版本，或者在删除操作中已经被删除的记录列表。 2. ，旧的不能用在插件上，：这里的意思是，`Trigger.Old`变量在插入操作中是不可用的，因为插入操作没有“旧”的记录。 3. ，没什么旧的，：同样地，在插入操作中，因为没有旧的记录，所以`Trigger.Old`是空的。 4. ，返回NULL，：在某些情况下，比如在插入操作中尝试访问`Trigger.Old`，它会返回NULL，因为没有任何旧的记录。 5. ，插入前无法使用newMap，：在记录被插入之前，`Trigger.NewMap`是不可用的，因为此时记录还没有被分配ID。 6. ，尚未分配ID，：在记录被插入之前，它们还没有被分配Salesforce的唯一标识符（ID），所以在这个阶段，我们无法使用`Trigger.NewMap`。 接下来，我们来看看如何使用这些上下文变量： - ，访问记录，：要访问导致触发器触发的记录，我们可以使用上下文变量。例如，`Trigger.New`包含了所有在插入或更新操作中被处理的记录。如果是一次批量操作，`Trigger.New`可能会包含多条记录。 - ，事件类型，：上下文变量还能告诉我们触发器是被哪种事件触发的，比如是插入、更新还是删除。同时，它们也能告诉我们当前正在执行的是哪种类型的触发器。 通过这些上下文变量，我们可以编写出更加智能和灵活的触发器，来满足不同的业务需求。希望这些解释能帮助你们更好地理解Salesforce中的触发逻辑和上下文变量。如果有任何疑问，随时提问哦！

  ▶ 播放视频 查看详情
• 149

  Using Context Variables to Determine What Logic Executes

  第 230 页

  让我们来聊聊Salesforce中的触发器上下文变量。这些变量非常有用，因为它们可以帮助我们确定触发器是在什么情况下被触发的，以及我们应该执行哪些逻辑。 首先，所有的Salesforce触发器都内置了一些隐式变量，这些变量属于System.Trigger类。通过这些变量，我们可以访问触发器运行时的上下文信息。比如，isBefore和isAfter就是两个布尔类型的变量，它们告诉我们触发器是在记录保存之前（before）还是之后（after）被触发的。 接下来，我们来看两个非常实用的变量：isExec和isUpdate。isExec变量会在触发器因为插入操作（无论是通过Salesforce用户界面、Apex代码还是API）被触发时返回true。而isUpdate变量则是在触发器因为更新操作被触发时返回true。 使用这些变量，我们可以编写更加智能和高效的触发器代码。例如，如果我们只想在记录被插入时执行某些逻辑，我们就可以检查isExec变量是否为true。同样，如果我们只想在记录被更新时执行某些操作，我们就可以检查isUpdate变量。 通过这些上下文变量，我们可以确保我们的触发器只在正确的时机执行正确的逻辑，从而提高代码的效率和可维护性。希望这些信息对你有帮助！如果你有更多问题，随时问我。

  ▶ 播放视频 查看详情
• 150

  What is in Trigger.New and Trigger.Old?

  第 231 页

  让我们来聊聊Salesforce中的Trigger.New和Trigger.Old这两个概念。想象一下，你正在处理一些数据记录，比如课程的开始日期。Trigger.New和Trigger.Old就像是两个小助手，帮助你在数据发生变化时，知道变化前后的情况。 首先，Trigger.New和Trigger.Old是在内存中创建的，这意味着在触发器实际触发之前，它们就已经准备好了。这就像是你在做菜前，先把所有的食材都准备好一样。 现在，让我们看看具体的情况： 1. ，Trigger.New，：这个助手会告诉你，触发器触发时，记录的新状态是什么。比如，如果你在2月2日有一个课程的开始日期，Trigger.New会告诉你这个日期。 2. ，Trigger.Old，：这个助手则告诉你，触发器触发前，记录的旧状态是什么。如果记录之前没有状态，比如是新建的记录，那么Trigger.Old会是空的（NULL）。 举个例子，假设你在3月2日更新了一个课程的开始日期： - ，Trigger.New，会显示新的开始日期，也就是3月2日。 - ，Trigger.Old，会显示旧的开始日期，也就是2月2日。 所以，当你运行触发器时，你可以通过System.debug语句看到这些日期。比如，如果你在触发器中有System.debug(Trigger.New)，你会看到新的开始日期；如果有System.debug(Trigger.Old)，你会看到旧的开始日期。 希望这个解释能帮助你更好地理解Trigger.New和Trigger.Old的作用。如果有任何疑问，随时问我哦！

  ▶ 播放视频 查看详情
• 151

  Working With Trigger.new and Trigger.oldMap

  第 232 页

  同学们，今天我们来聊聊Salesforce中的触发器（Trigger），特别是两个非常重要的上下文变量：`Trigger.new` 和 `Trigger.oldMap`。 首先，`Trigger.new` 是一个列表，它包含了触发器当前正在处理的所有新记录。这些记录可能是刚刚被插入的，或者是即将被更新的。你可以把它想象成一个“新鲜出炉”的记录集合。 然后，我们有 `Trigger.oldMap`，这是一个映射（Map），它包含了触发器处理之前记录的旧值。这个映射的键是记录的ID，值是对应的旧记录。你可以把它看作是“历史记录”的集合。 现在，这里有一个重要的点需要注意：`Trigger.oldMap` 中的记录顺序可能与 `Trigger.new` 中的顺序不同。这意味着，如果你在 `Trigger.new` 中遍历记录，并试图通过记录的ID在 `Trigger.oldMap` 中找到对应的旧记录，你可能会发现它们的顺序并不一致。 接下来，我们来看两种常见的触发器模式： 1. ，使用 `for` 循环遍历 `Trigger.new`，：在这种模式下，你会在 `Trigger.new` 上使用一个 `for` 循环，逐个处理每个记录。你可以在循环内部执行业务逻辑，比如验证数据、更新字段等。 2. ，使用 `Trigger.oldMap` 访问旧值，：在这种模式下，你会使用 `Trigger.oldMap` 来获取更新前的记录值。这对于比较新旧值、记录历史变化或者执行基于旧值的逻辑非常有用。 记住，理解这两个上下文变量的使用和它们之间的关系，对于编写有效的触发器逻辑至关重要。希望这些信息对你们有所帮助，如果有什么问题，随时提问哦！

  ▶ 播放视频 查看详情
• 152

  Triggers Execute on Implicitly Batched Data

  第 233 页

  同学们，今天我们来聊聊Salesforce中的触发器，特别是当它们处理批量数据时的关键点。首先，记住一个重要的规则：触发器在处理数据时，每次最多只能处理200条记录。这是Salesforce的一个硬性限制，我们称之为“州长限制”。 想象一下，如果你有200个销售对象（我们称之为s对象），触发器会运行一次来处理这些数据。但是，如果你有300个s对象会发生什么呢？触发器会运行两次，因为300除以200等于1.5，向上取整就是2次。所以，触发器会分两次处理这300条记录。 不过，这种情况在实际操作中并不常见。通常，当你使用触发器处理大量数据时，Salesforce会自动将数据分成多个批次，每批最多200条记录，然后触发器会为每一批数据运行一次。 还有一个重要的点是API的限制。当你通过API操作数据时，每次也只能处理最多200条记录。这意味着，无论你是直接在Salesforce中操作数据，还是通过外部系统使用API，这个200条记录的限制都是适用的。 总结一下，触发器在处理批量数据时，每次最多处理200条记录。如果你有更多的数据，触发器会分批次处理，每批200条。这个规则帮助我们确保系统的稳定性和性能，避免因为处理过多数据而导致系统过载。希望这个解释对你们理解Salesforce触发器的工作原理有所帮助！

  ▶ 播放视频 查看详情
• 153

  Using AddError to Prevent a DML Action in a Trigger

  第 234 页

  今天我们来聊聊如何在Salesforce的触发器中使用`addError`方法来防止DML操作。这个方法非常有用，尤其是在你需要确保某些数据操作符合特定规则时。 首先，`addError`方法可以在触发器中对记录或字段调用，用来阻止插入、更新或删除操作。具体来说，在`INSERT`和`UPDATE`触发器中，你可以对`Trigger.new`中的记录使用`addError`；而在`DELETE`触发器中，则是对`Trigger.old`中的记录使用。 使用`addError`的好处是，它会在用户尝试保存记录时显示一个自定义的错误消息。如果用户是通过Salesforce的用户界面操作，这个错误消息会直接显示在界面上；如果是通过数据加载器等工具批量操作，错误信息则会出现在操作日志中。 这里有个小技巧：尽量在`BEFORE`触发器中使用`addError`。这样做的好处是，如果操作不符合规则，系统会提前失败，这样用户感受到的响应时间会更短，体验也更好。 总结一下，`addError`是一个非常强大的工具，可以帮助你在数据操作前进行验证，确保数据的完整性和准确性。希望这个小技巧能帮助你在Salesforce的开发中更加得心应手！

  ▶ 播放视频 查看详情
• 154

  8-2: Define the Trigger's Business Logic

  第 235 页

  同学们，今天我们来学习如何定义一个触发器的业务逻辑。我们的任务是创建一个假期，并且通过触发器来确保只有在特定条件下才能保存这个假期。具体来说，我们要确保如果课程交付没有计划在假期开始时，那么这个假期才能被保存。 首先，我们需要创建一个假期。这个假期可以是一个自定义对象，我们可以在Salesforce中轻松地创建它。接下来，我们要创建一个触发器。触发器是一种在特定事件发生时自动执行的代码块。在这个例子中，我们希望在尝试保存假期时触发我们的逻辑。 触发器的逻辑是这样的：如果课程交付没有计划在假期的开始日期，那么假期就可以被保存。如果有课程交付计划在假期开始时，那么触发器将阻止假期的保存，并可能给出一个错误消息。 最后，我们需要测试这个触发器的逻辑。我们可以创建一个测试假期，并尝试在不同的条件下保存它，以确保触发器按预期工作。 整个过程大约需要15分钟。现在，让我们一起动手操作，确保我们理解并能够实现这个触发器的业务逻辑。

  ▶ 播放视频 查看详情
• 155

  Key Takeaways - 236

  第 236 页

  让我们来聊聊Salesforce中的触发器（Triggers）。触发器是一种强大的工具，当你在Salesforce中无法通过声明性选项（比如工作流、流程构建器等）实现某些复杂的业务逻辑时，触发器就派上用场了。 首先，触发器可以在记录保存到数据库之前运行。这意味着你可以在记录被保存之前，修改某些字段的值，或者执行一些高级的验证。比如，你可以检查某个字段是否符合特定的条件，如果不符合，就阻止记录保存。 其次，触发器分为两种类型：Before触发器和After触发器。Before触发器在记录保存之前运行，而After触发器在记录保存之后运行。After触发器特别有用，因为它可以访问系统生成的值，比如记录的Id。你还可以在After触发器中执行一些额外的操作，比如更新相关的记录。 Salesforce提供了一个叫做System.Trigger的类，这个类有很多布尔变量，可以帮助你确定触发器中的逻辑何时执行以及为什么执行。比如，你可以使用System.Trigger.isBefore来判断触发器是否在记录保存之前运行，或者使用System.Trigger.isUpdate来判断触发器是否在记录更新时运行。 最后，触发器可以访问并有时可以修改调用触发器操作的数据。这意味着你可以在触发器中读取和修改正在处理的记录，甚至可以对相关的记录进行操作。 总结一下，触发器是一个非常灵活的工具，可以帮助你实现复杂的业务逻辑。当你发现声明性选项无法满足你的需求时，触发器就是你最好的选择。希望这些信息对你有帮助！

  ▶ 播放视频 查看详情
• 156

  Knowledge Check - 237

  第 237 页

  让我们来聊聊Salesforce中的触发器（Trigger）和一些相关的概念。我会尽量用简单易懂的方式来解释，这样你听起来也会觉得轻松。 首先，触发器是Salesforce中的一种自动化工具，它可以在某些特定的操作发生时自动执行一段代码。这些操作通常包括记录的插入（Insert）、更新（Update）、删除（Delete）等。 ### 1. 哪种类型的操作会触发触发器？ 触发器会在以下几种操作发生时被触发： - ，插入（Insert），：当你向数据库中插入一条新记录时。 - ，更新（Update），：当你修改一条已经存在的记录时。 - ，删除（Delete），：当你从数据库中删除一条记录时。 - ，取消删除（Undelete），：当你恢复一条已经被删除的记录时。 ### 2. 在哪种类型的触发器中可以有意义地使用触发上下文变量“old”？ 触发上下文变量“old”主要用于，更新（Update），和，删除（Delete），触发器。在这些触发器中，“old”变量会保存记录在操作发生之前的状态。比如，在更新触发器中，你可以通过“old”变量来查看记录在更新前的字段值，从而进行比较或记录历史。 ### 3. 您可以在哪种类型的触发器中编辑trigger.new? 你可以在，插入之前（Before Insert），和，更新之前（Before Update），触发器中编辑`trigger.new`。在这些触发器中，`trigger.new`包含了即将被插入或更新的记录。你可以在这里修改这些记录的值，然后再让它们被保存到数据库中。 ### 4. 知识检查TLR事件的执行。 TLR（Trigger Logic Reordering）是Salesforce中的一种优化机制，它可以帮助系统更高效地执行触发器。简单来说，TLR会重新排列触发器的执行顺序，以减少数据库操作和提高性能。你不需要手动控制TLR，Salesforce会自动处理。 ### 5. 旧（和旧地图） “旧”（old）和“旧地图”（oldMap）是触发器中非常有用的上下文变量： - ，old，：在更新和删除触发器中，`old`变量保存了记录在操作发生之前的状态。 - ，oldMap，：这是一个映射（Map），它包含了所有在触发器中涉及的记录的旧状态。你可以通过记录的ID来访问这些旧状态。 ### 6. 插入之前、更新之前。 - ，插入之前（Before Insert），：在记录被插入到数据库之前触发。你可以在这里修改记录的值。 - ，更新之前（Before Update），：在记录被更新到数据库之前触发。你可以在这里修改记录的值，或者根据旧值和新值进行比较。 希望这些解释能帮助你更好地理解Salesforce中的触发器和相关概念。如果你有任何问题，随时问我！

  ▶ 播放视频 查看详情
• 157

  Trailhead Homework - 238

  第 238 页

  今天我们来聊聊关于Salesforce Trailhead的家庭作业教学要点。首先，Trailhead是一个非常棒的学习平台，特别适合用来复习和巩固你的PD1（Platform Developer 1）技能。通过Trailhead，你可以通过互动的方式学习到很多实用的Salesforce知识。 今天给大家布置的家庭作业是完成一个关于Apex触发器的模块。Apex触发器是Salesforce中非常强大的工具，它可以在数据库操作（如插入、更新、删除）前后自动执行特定的Apex代码。这个模块会帮助你更深入地理解Apex触发器的工作原理以及如何在实际项目中应用它们。 这个作业不需要在课堂上完成，你们可以在课后自己安排时间去做。完成这个模块后，你们不仅能够复习到PD1的相关知识，还能提升你们在Apex编程方面的技能。 作业的链接我已经放在这里了：https://trailhead.salesforce.com/modules/apex_triggers。请大家点击链接，开始学习吧！如果在学习过程中遇到任何问题，随时可以来问我。加油！

  ▶ 播放视频 查看详情
• 158

  Module 9: Apex Class Essentials

  第 239 页

  今天我们来聊聊Apex类的备忘录教学要点。Apex类是Salesforce平台上的一种编程语言，它允许我们创建自定义的业务逻辑和功能。理解Apex类的基础知识对于在Salesforce中进行开发非常重要。 首先，Apex类是一种面向对象的编程语言，这意味着它使用对象和类来组织代码。每个类可以包含变量、方法、构造函数等。变量用于存储数据，方法用于执行操作，而构造函数则用于初始化对象。 在Apex中，类可以定义为公共的（public）或私有的（private）。公共类可以被其他类访问，而私有类只能在定义它的类内部访问。此外，Apex类还可以实现接口，这允许类遵循特定的行为模式。 接下来，我们来看看如何定义一个简单的Apex类。首先，你需要使用关键字“public class”后跟类名来声明一个类。然后，你可以在类体内定义变量和方法。例如： ```apex public class MyFirstClass { // 定义一个变量 public String myVariable; // 定义一个方法 public void myMethod() { System.debug(&#39;Hello, Salesforce!&#39;); } } ``` 在这个例子中，我们定义了一个名为`MyFirstClass`的公共类，它包含一个公共变量`myVariable`和一个公共方法`myMethod`。方法`myMethod`在被调用时，会在调试日志中打印出“Hello, Salesforce!”。 最后，记住Apex类在Salesforce中是非常强大的工具，它们可以帮助你自动化业务流程、集成外部系统以及创建复杂的业务逻辑。掌握Apex类的基础知识，将为你打开Salesforce开发的大门。 希望这些信息对你有帮助，如果你有任何问题，随时提问！

  ▶ 播放视频 查看详情
• 159

  Module Objectives - 240

  第 240 页

  同学们，今天我们来回顾一下这个模块的主要内容。首先，我们要一起看看本模块涉及的对象。这些对象是我们解决问题的关键。还记得那些蓝框里的业务问题吗？我们就是通过在这个模块中构建的触发器来解决这些问题的。 这个模块是“基本”模块，所以我们的重点是回顾如何创建Apex类的基础知识。Apex类是Salesforce开发中的核心部分，掌握好这些基础知识对我们后续的学习非常重要。 不过，这里我要提醒大家，虽然我们在这个模块中会学到很多有用的知识，但并不是所有的提示和技巧都会在这里透露。为什么呢？因为我们在后面的模块中还会用到它们，到时候我们会更深入地探讨和应用这些技巧。 所以，大家现在要做的就是打好基础，理解并掌握这些基本概念和操作。这样，当我们在后续模块中遇到更复杂的内容时，就能更好地应对了。好了，让我们开始吧！

  ▶ 播放视频 查看详情
• 160

  Module Agenda - 241

  第 241 页

  同学们，今天我们来聊聊Salesforce中的Apex类。Apex类是Salesforce平台上的一种编程语言，它允许我们创建自定义的业务逻辑和功能。我们可以把它想象成一个工具箱，里面装满了各种工具，帮助我们完成特定的任务。 首先，我们要定义Apex类。定义Apex类就像是在创建一个新的工具箱。我们需要给它一个名字，然后决定这个工具箱里要放哪些工具。这些工具就是类中的方法，每个方法都可以执行特定的操作。 接下来，我们要确定Apex类的数据访问权限。这就像是在决定谁可以使用这个工具箱。我们可以设置权限，确保只有特定的人或角色可以访问和使用这个类中的方法。这样可以保护我们的数据安全，防止未经授权的访问。 总结一下，Apex类是Salesforce中非常强大的工具，通过定义类和设置权限，我们可以创建出符合我们业务需求的自定义功能。希望今天的讲解能帮助大家更好地理解Apex类的基本概念。如果有任何问题，随时提问哦！

  ▶ 播放视频 查看详情
• 161

  Where is a Class Defined?

  第 242 页

  今天我们来聊聊Salesforce中的“包”这个概念。你可以把包想象成一个盒子，这个盒子里可以装很多东西，小到一个小小的组件，大到一整套相关的应用。当你创建了一个包之后，你可以把它分享给其他的Salesforce用户或者组织，甚至可以是公司外部的用户和组织。 现在，包有两种主要的形式：非托管包和托管包。 首先，我们来说说非托管包。这种包通常用来分发一些开源项目或者应用模板，给开发者提供一些基础的构建模块。当你从非托管包中安装了一些组件后，你可以在你的组织里对这些组件进行编辑。但是，创建和上传这个非托管包的开发者，他们无法控制这些已经安装的组件，也不能对它们进行更改或升级。所以，如果你想把组件从沙箱环境迁移到生产环境，非托管包并不是一个好的选择。这时候，你应该使用更改集。 接下来是托管包。这种包通常是由Salesforce的合作伙伴用来向客户分发和销售应用的。这些包必须从Developer Edition组织中创建。通过AppExchange和许可证管理应用（LMA），开发者可以向应用出售和管理基于用户的许可证。托管包还有一个很大的优点，就是它们是完全可升级的。为了确保升级过程顺利，你不能进行一些破坏性的更改，比如删除对象或字段。 如果你想了解更多关于包的信息，可以参考这个资源链接：[Salesforce帮助文档](https://help.salesforce.com/apex/HTViewHelpDoc?id=sharing_apps.htm&amp;language=en)。 希望这些信息对你有帮助！如果你有任何问题，随时问我哦。

  ▶ 播放视频 查看详情
• 162

  Apex Class Use Cases

  第 243 页

  今天我们来聊聊Apex类的一些常见用例。Apex类是Salesforce中非常强大的工具，它们可以帮助我们封装和重用业务逻辑。让我们从几个常见的场景开始。 首先，，通过触发器调用Apex类，。触发器是在数据库操作（如插入、更新、删除）发生时自动执行的代码。但是，触发器中的逻辑如果过于复杂，会变得难以维护。这时候，我们可以把复杂的逻辑放到Apex类中，然后在触发器里调用这个类。这样不仅让代码更清晰，还能让逻辑更容易测试和重用。 接下来，，封装可重复使用的测试数据，。在编写测试类时，我们经常需要创建一些测试数据。如果每次都手动创建这些数据，不仅麻烦，还容易出错。我们可以把这些数据生成逻辑封装到一个Apex类的方法中，这样每次测试时只需要调用这个方法，就能快速生成所需的测试数据。 再来，，控制Visualforce页面，。Visualforce页面是Salesforce中的自定义用户界面。有时候，我们需要在页面上执行一些复杂的逻辑，比如根据用户输入动态改变页面内容。这些逻辑可以放在Apex类中，然后在Visualforce页面的控制器中调用。这样可以让页面的逻辑更清晰，也更容易维护。 然后，，测试，。Apex类的一个重要用途是编写测试代码。Salesforce要求我们为所有Apex代码编写测试类，以确保代码的质量和覆盖率。我们可以把测试逻辑封装到Apex类中，这样不仅能让测试代码更模块化，还能提高测试的效率和可维护性。 最后，，建模数据和动作，。Apex类可以用来定义数据模型和业务逻辑。比如，我们可以创建一个类来表示一个复杂的业务对象，然后在这个类中定义各种操作这些对象的方法。这样可以让我们的代码更符合面向对象的设计原则，也更容易扩展和维护。 总结一下，Apex类的主要用途是封装和重用业务逻辑。无论是通过触发器调用、生成测试数据、控制Visualforce页面，还是编写测试代码，Apex类都能帮助我们让代码更清晰、更易于维护。记住，只有两种方式可以保存Apex代码：触发器或类。所以，类是用来处理所有不需要由触发器完成的逻辑的。 希望这些内容对你有帮助！如果有任何问题，随时问我哦！

  ▶ 播放视频 查看详情
• 163

  Apex Class Use Cases (cont.)

  第 244 页

  今天我们来聊聊Salesforce中的Apex类继承，以及如何使用它来让我们的代码更加灵活和强大。 首先，想象一下你有一个基础的模板，这个模板定义了一些通用的行为或属性。然后，你希望基于这个模板创建一些更具体的版本，每个版本都有自己独特的特性。这就是继承的用武之地。在Apex中，我们可以通过创建虚拟类或抽象类来实现这一点。 虚拟类是可以被其他类继承的类。它们可以包含具体的方法实现，也可以包含抽象方法，这些抽象方法需要在子类中被具体实现。虚拟类的一个好处是，它们可以被实例化，也就是说，你可以直接创建虚拟类的对象。 抽象类则更进一步，它们不能被实例化。抽象类通常用于定义一个基础框架，要求子类必须实现某些方法。这样，抽象类确保了所有子类都遵循一定的规则或模式。 除了虚拟类和抽象类，Apex还支持接口。接口是一种特殊的类，它只定义了方法的签名，而不包含任何实现。实现接口的类必须提供这些方法的具体实现。接口是一种强大的工具，它允许不同的类以相同的方式被使用，即使它们的内部实现完全不同。 在实际开发中，你可能会遇到需要将一种类型的对象转换为另一种类型的情况。这就是所谓的“类型转换”或“casting”。在Apex中，你可以通过类型转换来访问特定类的特有方法或属性。 最后，我提供了一些资源链接，你可以通过这些链接深入了解虚拟类、接口以及类型转换的更多细节。这些资源将帮助你更好地理解这些概念，并在实际开发中应用它们。 希望今天的讲解能帮助你更好地理解Apex中的继承和接口。如果你有任何问题，随时提问，我会在这里帮助你。

  ▶ 播放视频 查看详情
• 164

  Module Agenda - 245

  第 245 页

  同学们，今天我们来聊聊Salesforce中的Apex类。Apex类是Salesforce平台上的一种编程语言，它允许我们创建自定义的业务逻辑和功能。想象一下，Apex类就像是你在厨房里用的食谱，它告诉Salesforce如何准备和处理数据。 首先，我们来看看如何定义一个Apex类。定义一个Apex类就像是在写一个新的食谱。你需要给它一个名字，然后列出所有的配料（也就是变量）和步骤（也就是方法）。例如，你可以创建一个名为“CustomerService”的类，里面包含处理客户数据的方法。 接下来，我们要确定Apex类的数据访问权限。这就像是决定谁能进厨房使用你的食谱。在Salesforce中，你可以通过设置类的访问修饰符（如public、private等）来控制谁可以访问这个类。例如，如果你想让所有的用户都能使用这个类，你可以把它设为public。 最后，我们来看看如何使用Apex类。一旦你定义了一个Apex类，你就可以在Salesforce的其他地方调用它，比如在触发器、Visualforce页面或者Lightning组件中。这就像是你按照食谱做菜，然后把菜端给客人享用。 好了，这就是我们今天关于Apex类的基础知识。希望你们能像掌握新食谱一样，掌握Apex类的使用。下次我们会深入探讨更多高级功能，记得回来哦！

  ▶ 播放视频 查看详情
• 165

  Defining an Apex Class

  第 246 页

  让我们来聊聊Apex类的基本结构。Apex类是Salesforce中用来封装数据和行为的核心构建块。你可以把它想象成一个蓝图，定义了对象的结构和行为。 首先，我们来看一个简单的Apex类定义： ```apex public class MyClass { DataType memberVariable; DataType memberProperty { get; set; } public MyClass() { // 构造器逻辑 } public void memberMethod() { // 方法逻辑 } } ``` ### 1. ，访问修饰符：谁可以看到这个类？， - `public`：这个关键字表示这个类可以被其他Apex类或外部系统访问。如果你想让这个类在整个应用中可见，就用`public`。 - 如果没有指定访问修饰符，默认是`private`，意味着这个类只能在同一个命名空间或包内访问。 ### 2. ，共享：类可以看到哪些记录？， - `with sharing` 或 `without sharing`：这两个关键字决定了类在执行时是否遵循用户的记录访问权限。 - `with sharing`：类会遵循用户的记录访问权限，只能看到用户有权访问的记录。 - `without sharing`：类会忽略用户的记录访问权限，可以看到所有记录，即使这些记录对用户是不可见的。 ### 3. ，成员变量， - 成员变量是类中存储数据的部分。你可以有0个或多个成员变量。比如`DataType memberVariable;`就是一个成员变量，它存储了某种类型的数据。 ### 4. ，构造器， - 构造器是用来初始化类的实例的。你可以有0个或多个构造器。比如`public MyClass()`就是一个构造器，它在创建类的实例时执行一些初始化逻辑。 ### 5. ，属性， - 属性是类中用来封装数据的特殊方法。你可以有0个或多个属性。比如`DataType memberProperty { get; set; }`就是一个属性，它允许外部代码读取或设置这个值。 ### 6. ，方法， - 方法是类中定义行为的部分。你可以有0个或多个方法。比如`public void memberMethod()`就是一个方法，它定义了类可以执行的某些操作。 ### 教学要点 - 这个幻灯片的主要目的是让你了解Apex类的基本结构。我们希望你掌握以下几点： - 类可以是`public`的，这样其他代码可以访问它。 - 类可以包含成员变量、构造器、属性和方法。 - 我们会在后续的课程中详细介绍访问修饰符和记录访问权限。 ### 资源 - 如果你想深入了解Apex类的属性，可以参考这个链接：[Apex Classes and Properties](https://developer.salesforce.com/docs/atlas.en-us.apexcode.meta/apexcode/apex_classes_properties.htm) 希望这些内容能帮助你更好地理解Apex类的基本概念！如果有任何问题，随时问我哦！

  ▶ 播放视频 查看详情
• 166

  Accessing an Apex Class or Class Member

  第 247 页

  让我们来聊聊Salesforce Apex中的访问修饰符。想象一下，你有一个班级，这个班级里有不同的学生和老师。访问修饰符就像是班级的门锁，它决定了谁可以进入班级，谁可以看到班级里的东西。 首先，访问修饰符决定了类或类成员的访问范围。也就是说，它控制着哪些代码可以访问这个类或类的成员。比如，有些班级可能只允许本班的学生进入，而有些班级可能允许全校的学生进入。 接下来，修饰符是按照从上到下的顺序列出的，从限制性最低到限制性最高。这就像是班级的门锁有不同的级别，有的锁很容易打开，有的锁则需要更多的权限才能打开。 然后，成员的限制性可以与定义它们的类一样或更严格，但限制性不能更小。这就像是班级里的学生，他们的权限不能超过班级的权限。如果班级的门锁很严格，那么学生也不能随便带外人进来。 最后，默认情况下，成员是私人的。这意味着如果你不特别说明，那么班级里的东西只有班级内部的人才能看到和使用。这就像是班级里的私人物品，只有班级成员才能使用。 所以，当你编写Apex代码时，记得使用合适的访问修饰符来控制你的类和成员的可见性，就像管理班级的门锁一样，确保只有合适的人才能访问。

  ▶ 播放视频 查看详情
• 167

  Applying Static and Final to a Class Member

  第 248 页

  今天我们来聊聊在Apex编程中，如何使用`FINAL`和`STATIC`这两个关键字来定义“常数”。这里的“常数”指的是那些一旦设定后就不应该被改变的变量。 首先，我们来看`FINAL`关键字。当你用`FINAL`来定义一个变量时，这个变量就变成了一个“最终”的变量。这意味着，一旦你给这个变量赋值后，你就不能再改变它的值了。你可以在声明这个变量的时候直接给它赋值，或者在类的构造函数中给它赋值。但是，一旦赋值完成，这个变量的值就固定了，不能再被修改。 接下来是`STATIC`关键字。`STATIC`用于定义那些属于类本身，而不是类的某个特定实例的变量。这意味着，无论你创建了多少个类的实例，这个`STATIC`变量都只有一个副本，所有的实例共享这个变量。你可以在静态初始化代码块中给`STATIC`变量赋值，但是你不能在构造函数中给它赋值。这是因为构造函数是在创建类的实例时调用的，而`STATIC`变量是属于类本身的，不是属于某个实例的。 总结一下，`FINAL`用于定义那些一旦赋值后就不能再改变的变量，而`STATIC`用于定义那些属于类本身的变量。这两个关键字可以帮助你更好地控制变量的作用域和生命周期，使你的代码更加安全和易于维护。 希望这个解释能帮助你理解`FINAL`和`STATIC`在Apex中的应用。如果你有任何问题，随时提问！

  ▶ 播放视频 查看详情
• 168

  Applying Access Modifiers

  第 249 页

  让我们来聊聊应用访问修改器这个教学点。首先，想象一下你有一个房间，房间里有一些家具和装饰品。现在，这个房间就是你的类（Class），而家具和装饰品就是类里面的方法和变量。 在这个房间里，有些家具是你想让所有人都能看到的，比如客厅的沙发，这就是公共的（Public）。而有些家具是你不想让别人看到的，比如卧室里的床，这就是私有的（Private）。 现在，我们来看一下代码。在7A行，我把一个公共方法改成了私有方法。这就好比你突然把客厅的沙发搬到了卧室，并且关上了卧室的门。这样一来，外面的人就看不到沙发了，也就不能使用它了。 所以，当触发器（Trigger）试图调用这个私有方法时，它就会遇到一个错误，因为触发器看不到这个方法，就像外面的人看不到卧室里的沙发一样。这就是为什么类保存正确，但触发器会产生“方法不可见”的错误。 总结一下，应用访问修改器就是控制谁可以看到和使用类里面的方法和变量。公共的（Public）是所有人都能看到的，而私有的（Private）是只有类内部才能看到的。希望这个比喻能帮助你更好地理解这个概念。

  ▶ 播放视频 查看详情
• 169

  9-1: Define an Apex Class

  第 250 页

  同学们，今天我们来学习如何定义Apex类，并且通过触发器来触发这个类。我们的目标是让触发器更加易于阅读和维护。这个过程大概需要15分钟，所以请大家集中注意力。 首先，Apex类是Salesforce中用来封装业务逻辑的一种方式。你可以把它想象成一个工具箱，里面装满了各种工具（方法），这些工具可以帮助我们完成特定的任务。 接下来，我们需要创建一个Apex类。这个类将包含一些方法，这些方法会在触发器被触发时执行。这样做的好处是，我们可以把复杂的逻辑从触发器中移出来，放到类里面，这样触发器就会变得简洁明了。 然后，我们需要从触发器触发这个类。触发器是Salesforce中用来在记录被插入、更新或删除时自动执行代码的一种机制。我们可以在触发器中调用我们刚刚创建的类中的方法，这样当触发器被触发时，类中的方法就会被执行。 最后，我们需要测试这个触发器。测试是非常重要的，因为它可以确保我们的代码按预期工作。我们可以编写测试类来模拟触发器的触发情况，并验证类中的方法是否正确执行。 通过这个过程，我们不仅创建了一个Apex类，还通过触发器触发了它，并且进行了测试。这样，我们的触发器就变得更加易于阅读和维护了。 好了，这就是我们今天的内容。希望大家能够理解并掌握如何定义Apex类，并通过触发器来触发它。如果有任何问题，欢迎随时提问。

  ▶ 播放视频 查看详情
• 170

  Module Agenda - 251

  第 251 页

  同学们，今天我们来聊聊Salesforce中的Apex类。Apex类是Salesforce平台上的一种编程语言，它允许我们创建自定义的业务逻辑和功能。想象一下，Apex类就像是你在厨房里用的食谱，它告诉Salesforce如何一步步地完成特定的任务。 首先，我们要定义Apex类。这就像是在写一个新的食谱。你需要给这个食谱起个名字，然后列出所有的配料和步骤。在Apex中，我们使用关键字`class`来定义一个类，然后给它一个名字。例如： ```apex public class MyFirstClass { // 这里我们会添加方法和变量 } ``` 接下来，我们要确定Apex类的数据访问权限。这就像是你决定谁可以看你的食谱。在Salesforce中，我们可以通过访问修饰符来控制谁可以访问这个类。比如，`public`意味着任何地方都可以访问这个类，而`private`则意味着只有这个类内部可以访问。 ```apex public class MyFirstClass { // 这个类可以被任何地方访问 } private class MySecretClass { // 这个类只能在这个文件内部访问 } ``` 最后，我们要使用Apex类。这就像是你按照食谱做菜。你可以创建这个类的实例，然后调用它的方法来执行特定的任务。 ```apex MyFirstClass myObject = new MyFirstClass(); // 现在我们可以使用myObject来调用类中的方法 ``` 记住，Apex类是一个非常强大的工具，它可以帮助我们自动化复杂的业务流程，提高工作效率。希望你们能通过这个模块，掌握Apex类的基本知识，为以后更深入的学习打下坚实的基础。

  ▶ 播放视频 查看详情
• 171

  Reviewing Data Access

  第 252 页

  让我们来回顾一下在Salesforce中如何控制和管理数据访问。这主要涉及到三个关键功能：对象凭证、字段级安全性和共享及所有权模式。 首先，，对象凭证，决定了用户是否有权限访问特定的表，也就是我们说的对象。比如，如果你想让用户查看客户信息，他们必须首先有权限访问“客户”这个对象。 接下来是，字段级安全性，，这决定了用户是否有权限查看或编辑表中的特定列，也就是字段。例如，即使一个用户可以访问客户对象，他们可能没有权限查看客户的敏感信息，如社会安全号码。 最后，，共享和所有权模式，决定了用户是否有权限访问特定的行，也就是记录。这意味着即使一个用户可以访问客户对象和所有字段，他们可能只能看到他们自己创建或共享给他们的客户记录。 为了确保终端用户能够查看特定记录上的特定字段，他们必须同时具备对对象的读取权限、对字段的读取权限以及对记录的读取权限。 现在，让我们回答两个问题： 1. ，对象凭证和字段级安全性有什么共同之处？， 两者都是在配置文件和权限集上定义的。这意味着你可以通过设置用户配置文件或权限集来控制用户对对象和字段的访问权限。此外，这两种设置都被Apex代码忽略，这意味着在Apex代码中，你可以访问任何对象和字段，而不受这些设置的限制。 2. ，Apex的操作与数据访问有什么关系？， Apex通过SOQL（Salesforce Object Query Language）和DML（Data Manipulation Language）操作来访问和修改数据。SOQL用于查询数据，而DML用于插入、更新和删除数据。这些操作允许开发者在Apex代码中直接与数据库交互，不受对象凭证和字段级安全性的限制。 希望这些信息能帮助你更好地理解Salesforce中的数据访问控制。如果你有更多问题，随时提问！

  ▶ 播放视频 查看详情
• 172

  An Apex Class…

  第 253 页

  让我们来聊聊Apex类和它在Salesforce中的一些特性。首先，Apex类是Salesforce平台上的一种编程语言，它允许开发者创建复杂的业务逻辑和自定义功能。 现在，我们来看一下Apex类如何处理对象CRED。简单来说，Apex类可以设置为忽略对象CRED。这意味着，当你在Apex代码中操作数据时，比如执行SOQL查询或使用点符号穿越对象关系，Apex类不会考虑对象CRED的限制。这给了开发者更大的灵活性，但也意味着需要更加小心地处理数据访问权限。 接下来，我们谈谈Apex类如何处理运行用户的记录级访问。Apex类可以被编程为尊重或忽略运行用户在数据操作期间的记录级访问。这意味着，你可以选择让Apex代码在执行时考虑当前用户的权限，或者完全忽略这些权限。这取决于你的业务需求和安全性考虑。 最后，我们来看一下Apex类如何处理字段级安全性（FLS）。Apex类会忽略FLS，这意味着无论字段的访问权限如何设置，Apex代码都可以访问和修改这些字段。这再次强调了在编写Apex代码时需要谨慎，确保不会无意中暴露或修改敏感数据。 总结一下，本幻灯片的目的是表明Apex仅尊重记录级共享模型。这意味着Apex类在处理数据时，主要关注的是记录级别的访问控制，而不是对象或字段级别的安全性。理解这一点对于在Salesforce平台上开发安全且高效的应用程序至关重要。希望这些信息对你有所帮助！

  ▶ 播放视频 查看详情
• 173

  Using the With/Without Sharing Keyword Phrase

  第 254 页

  让我们来聊聊Salesforce中的共享关键字，特别是`WITH SHARING`和`WITHOUT SHARING`，以及`inherited sharing`的使用。 首先，`WITH SHARING`和`WITHOUT SHARING`这两个关键字是用来控制Apex类中的记录访问权限的。简单来说，`WITH SHARING`意味着这个类会遵循Salesforce的共享规则，也就是说，用户只能看到他们有权限看到的记录。而`WITHOUT SHARING`则相反，它允许类绕过这些共享规则，访问所有记录，无论用户是否有权限。 现在，让我们谈谈`inherited sharing`。这个关键字是Salesforce引入的一个新特性，它的目的是让类的行为更加灵活和明确。当你使用`inherited sharing`时，这个类会根据调用它的类的共享模式来决定自己的行为。如果调用它的类使用了`WITH SHARING`，那么这个类也会遵循共享规则；如果调用它的类使用了`WITHOUT SHARING`，那么这个类就会绕过共享规则。 这里有一个重要的区别：如果一个类没有明确声明`WITH SHARING`或`WITHOUT SHARING`，那么它默认是不安全的，也就是说，它不会自动遵循共享规则。但是，如果你使用了`inherited sharing`，那么这个类默认会遵循共享规则，除非它被明确地从没有共享的上下文中调用。 总结一下，使用`inherited sharing`可以让你的代码更加安全和灵活，因为它会根据上下文自动调整行为，同时也能帮助你通过Salesforce的安全审查。这对于开发Lightning组件、Visualforce页面、Apex REST服务等场景非常有用。 希望这个解释能帮助你更好地理解这些共享关键字的作用和区别。如果有任何疑问，随时提问！

  ▶ 播放视频 查看详情
• 174

  Enforcing Ownership and the Sharing Model

  第 255 页

  让我们来聊聊Salesforce中的强制所有权和共享模型，以及它们如何影响数据的访问权限。 首先，强制所有权意味着在Salesforce中，每个记录都必须有一个所有者。这个所有者通常是创建记录的用户，或者是被指定为记录所有者的用户。所有权决定了谁可以查看和编辑记录。 共享模型则是Salesforce用来控制用户对记录的访问权限的机制。它允许记录所有者与其他用户或用户组共享记录，即使这些用户不是记录的所有者。 现在，假设我们有110个帐户记录，其中有50个记录对某个用户具有读取访问权限。这意味着这个用户只能看到这50个记录，而不能看到其他的60个记录。 接下来，我们来看两个示例方法：fetchAccounts(A)和fetchAccounts(B)。 在顶部（A）示例中的fetchAccounts()方法，如果这个方法尊重共享模型，那么它将只返回用户有权限访问的50个s对象。这是因为共享模型限制了用户只能访问他们有权限的记录。 而在底部（B）示例中的fetchAccounts()方法，如果这个方法忽视共享模型，那么它将返回所有的110个s对象，无论用户是否有权限访问这些记录。这是因为忽视共享模型意味着不考虑用户的访问权限，直接返回所有记录。 所以，答案是： - 顶部（A）示例中的fetchAccounts()将返回50个s对象。 - 底部（B）示例中的fetchAccounts()将返回110个s对象。 这个例子很好地展示了强制所有权和共享模型如何影响用户对数据的访问权限。希望这个解释能帮助你更好地理解这些概念！

  ▶ 播放视频 查看详情
• 175

  Does this Class Respect the Running User's Sharing Model?

  第 256 页

  让我们来聊聊这个课程是否尊重正在运行的用户的共享模式。首先，我们要明白一个关键点：在这个课程中，我们没有特别指定“带共享”或“不带共享”的关键字。这意味着什么呢？这意味着这个类的行为会根据它被调用的方式来决定是否尊重共享模式。 简单来说，如果这个类是在一个尊重共享模式的上下文中被调用，那么它就会遵循用户的共享设置。反之，如果它是在一个不关心共享模式的上下文中被调用，那么它就会忽略这些设置。所以，这个课程的设计是非常灵活的，它会根据实际的使用场景来决定如何处理共享模式。 希望这个解释能帮助你更好地理解这个课程的设计思路。如果你还有任何疑问，随时告诉我哦！

  ▶ 播放视频 查看详情
• 176

  Using SObject and Field Describe Information

  第 257 页

  今天我们来聊聊如何在Salesforce中使用Apex描述信息来避免硬编码，并且如何利用这些信息来检查用户的访问权限。 首先，什么是硬编码呢？简单来说，硬编码就是在代码中直接写入一些固定的值，比如对象名称、字段标签等。这样做虽然简单，但有一个很大的问题：如果这些值在Salesforce中发生了变化，比如字段标签被修改了，那么你的代码就会出错，需要手动去修改代码中的这些固定值。这显然不是一个好的做法。 那么，如何避免硬编码呢？我们可以使用Apex的描述信息（Describe Information）来动态获取这些元数据信息。Salesforce提供了一个强大的工具，叫做“动态描述信息”，它允许我们在代码中动态地获取对象和字段的详细信息，比如字段的标签、字段的大小、字段的类型、字段是否可搜索等等。 举个例子，假设你想获取一个对象的字段标签，你可以使用`Schema.DescribeFieldResult`类来获取这个字段的描述信息，然后通过`getLabel()`方法来获取字段的标签。这样，即使字段的标签在Salesforce中被修改了，你的代码也不需要做任何改动，因为它总是动态地获取最新的标签。 接下来，我们再来看看如何利用这些描述信息来检查用户的访问权限。在Salesforce中，不同的用户可能对同一个对象或字段有不同的访问权限。比如，有些用户可以创建新记录，有些用户只能查看记录，有些用户则不能访问某些字段。 通过Apex的描述信息，我们可以动态地检查用户是否有权限执行某些操作。比如，你可以使用`Schema.DescribeSObjectResult`类来获取对象的描述信息，然后通过`isCreateable()`、`isUpdateable()`等方法来检查用户是否有权限创建或更新记录。同样地，你也可以使用`Schema.DescribeFieldResult`类来检查用户是否有权限访问某个字段。 总结一下，使用Apex的描述信息可以帮助我们避免硬编码，使代码更加灵活和可维护。同时，它还可以帮助我们动态地检查用户的访问权限，确保我们的应用程序在安全性方面做得更好。 希望这些内容对你有帮助！如果你有任何问题，随时问我。

  ▶ 播放视频 查看详情
• 177

  Enforcing Object and Field Security

  第 258 页

  今天我们来聊聊Salesforce中的对象和字段安全，这是一个非常重要的主题，尤其是在开发Apex代码时。 首先，我们要明白，Apex代码默认是在“系统模式”下运行的。这意味着，Apex代码可以访问所有的对象和字段，不管当前用户是否有权限。这听起来很方便，对吧？因为这样代码可以轻松地满足业务需求。但是，这也带来了一些安全风险。 所以，作为Salesforce开发人员，我们需要仔细考虑我们的业务需求。我们需要问自己：我们的代码是否需要强制执行对象和字段级别的权限检查？如果答案是“是”，那么我们就需要使用Apex的描述信息来确定当前用户的访问级别。这样，我们就可以确保代码只访问用户有权访问的数据。 特别是对于那些在AppExchange上提供托管包的独立软件开发商（ISV），这一点尤为重要。他们必须始终强制执行CRUD（创建、读取、更新、删除）和FLS（字段级安全）检查，除非他们能在安全审查期间向Salesforce提供强有力的理由，说明为什么不需要这样做。 总结一下，虽然Apex在系统模式下运行很方便，但我们不能忽视安全性。我们需要根据业务需求来决定是否需要强制执行权限检查，并在必要时使用Apex的描述信息来确保代码的安全性。 如果你对这个主题感兴趣，可以访问这个链接了解更多信息：[Enforcing CRUD and FLS](https://developer.salesforce.com/page/Enforcing_CRUD_and_FLS)。 希望这个讲解对你有帮助！如果有任何问题，随时问我哦。

  ▶ 播放视频 查看详情
• 178

  Key Takeaways - 259

  第 259 页

  让我们来聊聊Salesforce中的Trigger和Apex类的关键要点，我会尽量用简单易懂的方式来解释。 首先，，Trigger的用途，。Trigger是Salesforce中的一种自动化工具，它可以在某些事件发生时自动执行代码。比如，当你在系统中创建、更新或删除一条记录时，Trigger可以自动触发一些操作。它的主要目的是在数据发生变化时，自动执行一些业务逻辑，而不需要手动干预。 接下来，，业务逻辑应封装在Apex类中，。这是什么意思呢？简单来说，就是不要把所有的代码都写在Trigger里面。Trigger应该只负责触发事件，而具体的业务逻辑（比如计算、验证、数据处理等）应该放在Apex类中。这样做的好处是，代码更清晰、更容易维护，也更容易复用。 然后，，类之间的继承，。在Apex中，你可以使用抽象类或虚拟类来实现类之间的继承。继承的意思是，一个类可以从另一个类“继承”属性和方法。这样，你可以创建一个通用的类，然后让其他类继承它，避免重复写代码。 再来说说，访问修饰符，。访问修饰符决定了Apex类、方法或变量的可见性。比如，你可以用`public`、`private`、`protected`等关键字来控制谁可以访问这些代码。`public`表示所有人都可以访问，`private`表示只有类内部可以访问，`protected`表示只有子类可以访问。 接下来是，共享关键字，。在Apex中，你可以使用`with sharing`或`without sharing`来控制类可以访问的数据。`with sharing`表示类会遵循用户的权限设置，只能访问用户有权访问的数据；`without sharing`则表示类可以访问所有数据，不受用户权限的限制。 最后，，强制执行对象和字段级访问，。这是开发人员的责任。在Apex类中，你需要确保代码不会绕过Salesforce的安全设置，比如对象和字段的权限。即使你在代码中写了访问某些数据的逻辑，也要确保这些逻辑符合系统的安全规则。 总结一下，Trigger是用来在数据变化时自动执行代码的工具，而业务逻辑应该放在Apex类中。通过继承、访问修饰符和共享关键字，你可以更好地控制代码的可见性和数据访问权限。同时，开发人员有责任确保代码符合Salesforce的安全规则。 希望这些解释对你有帮助！如果有任何问题，随时问我哦！

  ▶ 播放视频 查看详情
• 179

  Knowledge Check - 260

  第 260 页

  让我们来一一解答这些问题，确保你能够轻松理解。 1. ，哪个访问修饰符表示只能在您的应用程序或命名空间内访问的类？， - 答案是，“无需共享”，。这个访问修饰符意味着类只能在你的应用程序或命名空间内部访问，外部无法直接访问。 2. ，哪个关键字短语确保Apex类可以访问数据库中的所有记录？， - 答案是，“公开”，。使用`public`关键字可以让Apex类访问数据库中的所有记录，无论这些记录的共享设置如何。 3. ，可以使用什么来实现Apex类之间的继承？， - 答案是，“界面和虚拟类”，。通过使用`interface`和`virtual`类，你可以实现Apex类之间的继承。`virtual`类允许其他类继承它，而`interface`则定义了一组方法，任何实现该接口的类都必须提供这些方法的具体实现。 4. ，哪个关键字表示只能分配类中的变量在声明中还是在类的构造器中？， - 答案是，“最终”，。使用`final`关键字声明的变量只能在声明时或类的构造器中进行赋值，之后不能再修改。 希望这些解释能帮助你更好地理解这些概念！如果有任何疑问，随时问我哦。

  ▶ 播放视频 查看详情
• 180

  Trailhead Homework - 261

  第 261 页

  今天我们来聊聊关于Salesforce Trailhead的家庭作业。Trailhead是一个非常棒的学习平台，特别是对于那些想要复习和提升PD1（Platform Developer 1）技能的同学来说。今天，我给大家推荐两个特别有用的Trailhead模块，它们能帮助你们更深入地理解我们课堂上讨论的一些关键概念。 第一个模块是关于数据安全的。在这个模块中，你们将学习如何在Salesforce中保护数据，确保只有合适的人才能访问敏感信息。这是非常重要的，因为数据安全是任何系统的基础。你们可以通过这个链接访问这个模块：[数据安全模块](https://trailhead.salesforce.com/en/modules/data_security)。 第二个模块是关于数据泄露防护的。这个模块会教你们如何防止数据泄露，确保公司的信息不会被未经授权的人获取。这对于维护公司的声誉和客户的信任至关重要。你们可以通过这个链接访问这个模块：[数据泄露防护模块](https://trailhead.salesforce.com/modules/data-leak-prevention)。 这两个模块都是家庭作业，所以请你们在课后完成。它们不仅能帮助你们巩固课堂上学到的知识，还能让你们在实际操作中更好地理解和应用这些概念。记得，学习是一个持续的过程，Trailhead是一个很好的工具，可以帮助你们不断提升自己的技能。 好了，今天的家庭作业就介绍到这里。希望大家能够认真完成，并在学习过程中发现更多的乐趣和挑战。如果有任何问题，随时可以来找我讨论。加油！

  ▶ 播放视频 查看详情
• 181

  Module 10: The Save Order of Execution and Apex Transactions

  第 262 页

  同学们，今天我们来聊聊模块10的内容——保存执行令和Apex交易。这两个概念在Salesforce开发中非常重要，理解它们能帮助我们更好地管理数据和确保系统的稳定性。 首先，我们来谈谈，保存执行令，。在Salesforce中，当你对记录进行修改时，比如创建、更新或删除记录，系统会按照一定的顺序来处理这些操作。这个顺序就是保存执行令。它决定了哪些操作先执行，哪些后执行。比如，系统会先验证数据，然后触发触发器，最后才真正保存数据。理解这个顺序可以帮助我们避免一些常见的错误，比如在触发器里修改了数据，结果又触发了另一个触发器，导致无限循环。 接下来是，Apex交易，。Apex交易是指一组操作，这些操作要么全部成功，要么全部失败。这就像你去超市买东西，要么你把所有东西都买下来，要么什么都不买，不能只买一部分。在Apex中，我们可以通过使用`Database.savepoint`来设置一个保存点，如果在交易过程中出现了问题，我们可以回滚到这个保存点，确保数据的一致性。 举个例子，假设你在处理一个订单，需要同时更新库存和创建发票。如果库存更新成功了，但创建发票失败了，那么整个交易就会回滚，库存也会恢复到之前的状态。这样可以避免数据不一致的问题。 总结一下，保存执行令帮助我们理解系统如何处理数据操作，而Apex交易则确保了一组操作的原子性，要么全部成功，要么全部失败。这两个概念在实际开发中非常有用，希望大家能够好好掌握。 好了，今天的课程就到这里，如果有任何问题，欢迎随时提问。我们下次再见！

  ▶ 播放视频 查看详情
• 182

  The Order of Execution and Apex Transactions

  第 263 页

  让我们来聊聊Salesforce中的执行顺序和Apex交易的生命周期。这些概念对于理解触发器如何工作以及它们如何影响数据操作非常重要。 首先，执行顺序指的是在Salesforce中，当一个记录被创建、更新或删除时，系统会按照特定的步骤来处理这些操作。这个顺序包括验证规则、工作流规则、流程构建器、触发器等等。理解这个顺序可以帮助我们预测和调试我们的触发器行为。 触发器是Apex代码的一部分，它们在记录操作之前或之后自动执行。触发器可以响应多种事件，比如在记录插入之前、更新之后等。触发器必须适应Salesforce的执行顺序，这意味着它们需要在正确的时间点执行，以确保数据的一致性和完整性。 Apex交易的生命周期指的是从交易开始到结束的整个过程。这包括所有的DML操作（如插入、更新、删除）、触发器执行、以及任何相关的数据库操作。理解这个生命周期有助于我们确保所有的操作都是按预期执行的，并且在出现错误时能够正确地回滚。 最后，静态属性的内存生命周期是指静态变量在Apex中的生命周期。静态变量在类的生命周期内保持其值，这意味着它们在类的所有实例之间共享，并且在请求之间保持其值，直到服务器重置或类被重新加载。 关于您提到的触发器突然无法正常工作的问题，我们需要检查触发器的逻辑是否与当前的执行顺序和交易生命周期相匹配。可能的原因包括触发器逻辑错误、执行顺序的改变、或者是静态变量的不当使用。我们可以通过调试日志来查看触发器的执行情况，以及检查是否有任何异常或错误发生。 希望这些信息对您有所帮助，如果您有更多问题或需要进一步的帮助，请随时告诉我。

  ▶ 播放视频 查看详情
• 183

  Module Agenda - 264

  第 264 页

  同学们，今天我们要聊的是一个非常有趣的话题——Salesforce中的执行保存顺序和Apex事务。这个模块会帮助我们理解在Salesforce中，数据是如何被处理和保存的。 首先，我们来看看“执行保存顺序”。在Salesforce中，当你提交一个记录时，系统会按照一个特定的顺序来处理这个记录。这个顺序包括验证规则、工作流规则、触发器等等。理解这个顺序非常重要，因为它会影响到你的数据最终是如何被保存的。 接下来，我们会深入“Apex事务”。Apex是Salesforce的一种编程语言，它允许我们创建复杂的业务逻辑。在Apex中，事务是一个非常重要的概念。一个事务可以包含多个操作，比如插入、更新、删除记录等。Salesforce会确保这些操作要么全部成功，要么全部失败，这保证了数据的一致性。 在这个模块中，我们会通过一些实际的例子来演示这些概念是如何在实际中应用的。我们会看到如何编写Apex代码来管理事务，以及如何确保我们的数据操作是安全和可靠的。 好了，这就是我们今天要讨论的主要内容。希望你们能从中获得一些有用的知识，帮助我们更好地理解和使用Salesforce。如果有任何问题，随时提问哦！

  ▶ 播放视频 查看详情
• 184

  10-1: Explore the Implicit Firing of Triggers

  第 265 页

  让我们来聊聊Salesforce中的触发器，特别是它们的执行顺序。想象一下，触发器就像是一个小助手，当你在Salesforce中做某些操作时，比如添加或修改数据，这个小助手就会自动跳出来帮你做一些事情。 在这个模块里，我们会用一个日志来帮助我们理解这一切是怎么发生的。这个日志就像是一个记录本，它会记下所有触发器和工作流规则被触发的时刻。 我们来看一个例子：假设你有一个叫做“Course”的对象，当你修改这个对象时，Course对象上的触发器就会被触发。但是，这个触发器不仅仅影响Course对象，它还会去修改另一个叫做“Course Delivery”的对象。这样一来，Course Delivery对象上的触发器也会被触发。 这个练习其实和之前的一些练习有点像，那时候你们已经看过日志里发生了什么。现在，我们要更深入地理解这些触发器是怎么一个接一个地被触发的。 通过这种方式，你可以更清楚地看到Salesforce内部的工作机制，就像是在看一场精心编排的舞蹈，每个动作都紧密相连，确保一切都能顺利进行。

  ▶ 播放视频 查看详情
• 185

  The Save Order of Execution

  第 266 页

  让我们来聊聊Salesforce中的保存执行顺序。想象一下，当你在Salesforce中插入、更新或删除一条记录时，背后其实有一系列精心编排的步骤在默默地工作。这些步骤就像是一场精心策划的舞蹈，每个动作都按照特定的顺序进行，确保数据能够正确、安全地保存。 首先，当你点击保存按钮时，Salesforce会开始执行一系列的系统检查。这些检查包括验证数据的有效性、确保所有的必填字段都已经填写，以及检查是否有任何触发器需要被触发。这些步骤就像是在舞台上，舞者们先进行热身，确保一切准备就绪。 接下来，Salesforce会执行任何自定义的验证规则和触发器。这些规则和触发器就像是舞蹈中的特别动作，它们根据你的业务需求定制，确保数据在保存之前符合特定的标准。 然后，Salesforce会处理任何相关的字段更新和公式计算。这就像是舞者们根据音乐的节奏调整他们的步伐，确保每一步都精准无误。 最后，当所有的步骤都顺利完成，数据就会被保存到数据库中。但请注意，这并不意味着数据已经提交。在Salesforce中，数据提交通常发生在多个事件之后，比如当整个事务完成时。 虽然我们主要讨论了保存操作，但删除和取消删除操作也有类似的执行顺序。这些操作同样遵循一系列的步骤，确保数据的安全性和一致性。 如果你想要更深入地了解这些步骤，或者想要查看特定对象的执行顺序，可以参考Salesforce的官方文档。那里有更详细的信息和示例，帮助你更好地理解这个过程。 希望这个解释能帮助你更好地理解Salesforce中的保存执行顺序。如果你有任何问题，随时提问，我会在这里帮助你。

  ▶ 播放视频 查看详情
• 186

  What Business Processes are Part of the Save Order of Execution?

  第 267 页

  同学们，今天我们来聊聊Salesforce中执行保存令时涉及的业务流程。首先，我们需要理解什么是“保存令”。简单来说，当你在Salesforce中创建或更新一条记录时，系统会执行一系列的操作来确保数据的准确性和完整性。这些操作就是所谓的“保存令”。 现在，让我们来看看哪些业务流程是执行保存令的一部分。主要包括以下几种： 1. ，触发，：这是最基础的部分，当你对记录进行任何操作时，触发器会被激活。 2. ，声明性操作，：这包括工作流程规则、流程构建器/流程、验证规则和系统验证。这些都是在不需要编写代码的情况下，通过配置来实现的自动化操作。 接下来，我们来讨论这些操作的执行顺序。当你在Salesforce中添加或修改一个联系人、账户或其他任何对象时，系统会按照以下顺序执行这些操作： 1. ，系统验证，：首先，Salesforce会检查记录是否符合系统定义的基本规则，比如必填字段是否填写了。 2. ，验证规则，：然后，系统会应用你定义的验证规则，确保数据符合业务逻辑。 3. ，工作流程规则，：如果记录通过了验证，工作流程规则会被触发，可能会自动更新字段或发送通知。 4. ，流程构建器/流程，：最后，流程构建器或流程会执行更复杂的自动化任务，比如创建相关记录或调用外部系统。 需要注意的是，公式字段和通过Apex代码发送的电子邮件不会影响这个执行顺序。公式字段是在记录保存后计算的，而Apex代码发送的电子邮件是在所有保存操作完成后才发送的。 在讨论的最后，我们进入下一部分：这些操作按执行顺序何时发生？它们如何相互互动或冲突？这个问题很重要，因为理解这些操作的顺序和相互作用可以帮助我们更好地设计和优化我们的业务流程。 希望今天的讲解能帮助大家更好地理解Salesforce中的保存令和相关的业务流程。如果有任何疑问，欢迎随时提问！

  ▶ 播放视频 查看详情
• 187

  What Happens Before the Save to the Database?

  第 268 页

  让我们来聊聊在Salesforce中，当你尝试保存一条记录到数据库之前，会发生哪些事情。这个过程其实挺有趣的，就像是一场精心编排的舞蹈，每个步骤都有它的节奏和顺序。 首先，想象一下你正在填写一个表单，准备保存一条新的记录。当你点击保存按钮的那一刻，Salesforce就开始了一系列的操作。 ，动画1：加载数据并初始化sObject， Salesforce首先会检查这条记录是否已经存在于数据库中。如果是新记录，它会创建一个新的sObject（Salesforce中的对象实例）来承载这些数据。如果记录已经存在，它会加载现有的数据。 ，动画2：加载新数据+系统验证， 接下来，Salesforce会加载你刚刚输入的新数据，并进行系统验证。这些验证规则是Salesforce内置的，比如检查必填字段是否填写了，或者日期格式是否正确。如果数据来自用户界面，这些验证会在数据进入系统之前进行。 ，动画3：BEFORE触发器， 然后，BEFORE触发器就登场了。这个触发器在数据被保存到数据库之前运行，它的主要任务是修改数据。比如，你可能希望在保存之前自动填充某些字段，或者根据某些条件调整数据。这里有个小提示：虽然Salesforce允许你定义多个BEFORE触发器，但最好只使用一个，因为多个触发器的执行顺序是不确定的，这可能会导致一些意想不到的结果。 ，动画4：系统验证和自定义验证， 在BEFORE触发器之后，Salesforce会再次进行系统验证，同时也会执行你定义的自定义验证规则。这些规则可以确保数据符合你的业务需求。 ，动画5：复制规则， 接下来是复制规则的处理。这些规则主要用于防止重复记录的产生。比如，如果你有一个客户管理系统，你可能不希望同一个客户被录入两次。 ，动画6：数据无效的情况， 最后，如果在这个过程中有任何步骤导致数据无效，比如验证规则未通过，或者触发器修改了数据导致不符合要求，Salesforce会阻止记录被保存，并给出相应的错误信息。 在整个过程中，Salesforce还会处理一些其他的细节，比如Picklist的验证是在浏览器端进行的，这样可以减少服务器的负担。而且，Salesforce对于递归保存也有一定的限制，以防止无限循环的情况发生。 这就是在Salesforce中保存记录到数据库之前的大致流程。希望这个解释能帮助你更好地理解这个过程。如果你有任何问题，随时问我哦！

  ▶ 播放视频 查看详情
• 188

  What Happens After the Save to the Database? Part 2: Triggers and Processes

  第 270 页

  让我们来聊聊当数据保存到数据库后会发生什么，特别是关于触发器和进程的要点。 首先，想象一下，当你点击保存按钮的那一刻，Salesforce就像是一个忙碌的邮局，开始处理你的数据包裹。这个过程中，有几个关键步骤会发生。 ，1. 触发器的触发：， 当数据被保存时，Salesforce会检查是否有触发器（Trigger）被设置在这个对象上。触发器就像是一个自动的响应机制，它会在数据被插入、更新或删除时自动执行。这些触发器可以在数据被保存之前（Before）或之后（After）触发。所以，如果你的数据发生了变化，触发器会立即行动起来，执行你预先设定的逻辑。 ，2. 自定义验证规则的再次运行：， 接下来，Salesforce会再次运行你的自定义验证规则。这些规则是你为了确保数据质量而设置的，比如检查某个字段是否填写了，或者某个值是否符合特定的格式。与工作流规则不同，工作流规则的字段更新不会再次触发验证规则，但进程字段更新会。这意味着，如果你的进程字段更新导致了数据的变化，Salesforce会再次检查这些数据是否符合你的验证规则。 ，3. 进程字段更新的影响：， 进程字段更新可能会导致数据库进行额外的保存操作。这就像是你寄出一个包裹后，邮局发现包裹里有些东西需要重新包装，于是他们又打开包裹，重新处理了一次。这个过程可能会再次触发触发器，因为数据又发生了变化。 ，4. 系统验证的再次检查：， Salesforce还会再次检查大多数系统验证步骤，比如确保所有必填字段都有值，并且这些值符合要求。不过，如果这个请求是来自标准UI编辑页面，Salesforce不会再次运行特定于布局的规则。 总结一下，当数据保存到数据库后，Salesforce会通过触发器和进程字段更新来确保数据的完整性和准确性。这些步骤可能会多次触发验证规则和触发器，确保你的数据始终符合你的业务规则。 希望这个解释能帮助你更好地理解Salesforce中的数据保存过程。如果有任何疑问，随时问我哦！

  ▶ 播放视频 查看详情
• 189

  What Happens After the Save to the Database? Part 3

  第 271 页

  让我们继续聊聊保存到数据库后会发生什么。现在，我们来到了第三部分，这里有几个关键点需要你特别关注。 首先，我们来看一下动画部分。动画会帮助你更直观地理解接下来的内容。所以，请确保你的眼睛盯着屏幕，不要错过任何细节。接下来，我们会进入下一张幻灯片，那里有更多精彩的内容等着你。 现在，让我们谈谈教学要点。当你保存数据到数据库时，特别是当你涉及到计算汇总字段时，会发生什么呢？这里有个小秘密：计算汇总字段可能会导致其他记录也被保存。这是因为汇总字段的值是基于其他记录计算得出的，所以当这些记录发生变化时，汇总字段也需要更新。这就像是一个连锁反应，一个变化可能会引发一系列的变化。 最后，我们来看看提交后的逻辑。提交后，系统可能会执行一些额外的操作，比如发送电子邮件或者排队传出消息。这些都是为了确保数据的完整性和系统的流畅运行。所以，当你点击“保存”按钮时，背后其实有很多事情在悄悄发生。 好了，这就是今天的课程内容。希望你能跟上节奏，理解这些关键点。下一张幻灯片，我们会更深入地探讨这些话题。准备好了吗？让我们继续前进！

  ▶ 播放视频 查看详情
• 190

  What Happens When Another DML Save Operation is Performed?

  第 272 页

  让我们来聊聊当你执行另一个TLR（Trigger、Lightning组件、或Record-Triggered Flow）保存操作时会发生什么。首先，想象一下你正在看一个动画，这个动画会展示整个过程的流程。当你点击保存按钮时，系统不会立即提交你的更改，而是会等到所有相关的操作都完成之后，也就是在OOE（Order of Execution，执行顺序）结束时，才会真正提交这些更改。 现在，重点来了：任何可以修改记录的步骤，比如更新字段或者创建新记录，都可能触发另一个过程。这些被触发的流程我们称之为“衍生”流程。但是，这些衍生流程有一个特点，它们不会包括提交和提交后的操作。也就是说，它们不会立即把更改保存到数据库中，也不会执行那些只有在记录提交后才能进行的操作。 为了方便理解，我们在这里使用“当前流程”这个短语，而不是更专业的“Apex Transaction”。这是因为我们还没有深入讨论Apex Transaction的概念，但别担心，下一个主题我们会详细解释这一点。 所以，简单来说，当你执行一个保存操作时，系统会按照一定的顺序处理所有相关的步骤，包括可能触发的其他流程，但最终所有的更改都会在OOE结束时一起提交。希望这个解释能帮助你更好地理解这个过程！

  ▶ 播放视频 查看详情
• 191

  Additional Steps

  第 273 页

  同学们，今天我们来聊聊Salesforce中的保存顺序和触发器执行顺序。特别是，我们会探讨哪些事件会导致新的TLR（Trigger Logic Re-execution）事件。 首先，我们需要理解，当你在Salesforce中保存一个记录时，系统会按照一定的顺序执行一系列的事件。这些事件包括触发器的执行、验证规则的检查、工作流的触发等等。 现在，让我们来看看哪些特定的规则或事件会导致新的TLR事件： 1. ，分配规则，：当你设置了分配规则，系统在保存记录时会根据这些规则自动分配记录给特定的用户或队列。这个过程可能会触发新的TLR事件。 2. ，自动响应规则，：这些规则用于自动发送电子邮件响应给客户。当记录保存时，如果触发了自动响应规则，这也可能导致新的TLR事件。 3. ，递增规则，：递增规则用于自动递增某些字段的值，比如案例编号。这种自动更新可能会触发TLR事件。 4. ，权限规则，：权限规则控制用户对记录的访问权限。如果保存操作触发了权限规则的重新评估，这也可能导致TLR事件。 5. ，作业规则，：特别是针对案例和线索的作业规则，当这些规则被触发时，可能会引起TLR事件。 6. ，自动响应规则-案例和线索，：类似于普通的自动响应规则，但专门针对案例和线索。这些规则的触发也可能导致TLR事件。 7. ，升级规则-案例，：这些规则用于在满足特定条件时自动升级案例。升级操作可能会触发TLR事件。 8. ，权利规则=案例和工作订单，：这些规则用于管理案例和工作订单的权利。当这些规则被触发时，可能会引起TLR事件。 最后，如果你想要更深入地了解这些事件和触发器的执行顺序，可以参考Apex开发人员指南中的“触发器和执行顺序”部分。此外，提交后的逻辑，如电子邮件发送和@future方法（用于异步处理），也可能影响TLR事件的发生。 希望这些信息对你们理解Salesforce的保存顺序和触发器执行顺序有所帮助。如果有任何疑问，随时提问！

  ▶ 播放视频 查看详情
• 192

  What Events in the Save Order of Execution Cause a New DML Event?

  第 274 页

  让我们来聊聊Salesforce中的保存顺序和TLR事件。TLR，也就是“Trigger, Load, and Rollup”的缩写，是Salesforce中一个非常重要的概念。它涉及到数据保存时的一系列事件和规则。 首先，我们来看看哪些事件会导致新的TLR事件。在Salesforce中，当你保存一条记录时，系统会按照一定的顺序执行一系列的事件。这些事件包括系统验证规则、自定义验证规则、重复规则等。如果在这些事件中，有任何一个规则被触发，那么就会导致一个新的TLR事件。 接下来，我们来看看触发之前会发生什么。在触发之前，系统会先执行系统验证规则和自定义验证规则。这些规则是用来确保数据的完整性和准确性的。如果数据不符合这些规则，那么记录就无法保存。 然后，我们来看看触发后会发生什么。在触发之后，系统会执行工作流程、流程、计算汇总字段和跨对象工作流程。这些事件是用来处理数据的进一步操作和计算的。比如，工作流程可以用来发送邮件或者更新其他记录，而计算汇总字段则可以用来计算和显示汇总数据。 最后，我们来看看评估基于标准的共享。这是Salesforce中一个非常强大的功能，它可以根据一定的标准来决定哪些用户可以访问哪些数据。这个功能可以帮助你更好地管理和控制数据的访问权限。 总结一下，执行保存顺序中的事件会导致新的TLR事件，这些事件包括系统验证规则、自定义验证规则、重复规则等。在触发之前，系统会先执行验证规则，确保数据的完整性和准确性。在触发之后，系统会执行工作流程、流程、计算汇总字段和跨对象工作流程，处理数据的进一步操作和计算。最后，评估基于标准的共享可以帮助你更好地管理和控制数据的访问权限。 希望这个解释能帮助你更好地理解Salesforce中的保存顺序和TLR事件。如果你有任何问题，随时问我哦！

  ▶ 播放视频 查看详情
• 193

  What Might Cause the Commit to Not Happen?

  第 275 页

  让我们来聊聊为什么有时候在Salesforce中，我们的操作不会像预期那样被保存下来。想象一下，你正在做一个项目，每一步都需要完美无缺才能完成。如果中间有任何一步出了问题，整个项目可能就要从头再来。Salesforce中的事务处理也是类似的。 首先，系统验证是一个常见的拦路虎。比如，如果你在一个只能填数字的地方不小心输入了文字，或者忘记填写那些必须填的字段，系统就会说“不行，这不对”，然后整个操作就会被取消。 接着，对象的验证规则也可能导致问题。比如，规则可能要求你输入一个1到25之间的数字，但如果你输入了26，系统就会拒绝这个操作。 触发器也可能是个问题。如果触发器在执行过程中遇到了错误，比如超出了Salesforce设定的某些限制（比如处理的数据量太大），那么整个事务也会被回滚。 流程或流中的错误也会导致同样的问题。比如，如果你在流程中设置了一个字段更新，但这个更新尝试进行一个不合法的操作，比如除以零，这就会引发一个异常，导致整个事务失败。 工作流规则也可能是个麻烦制造者。举个例子，如果你设置了一个工作流规则，当某个字段为空时，自动将其设置为“已批准”。但如果这个更改导致父记录中的某个验证规则被违反（比如，父记录不允许有超过一个“已批准”的子记录），那么整个事务就会被回滚，子记录也不会被保存。 所以，你看，Salesforce中的每一步都需要小心翼翼，确保所有的规则和限制都被遵守，否则就可能需要从头再来。希望这些例子能帮助你更好地理解为什么有时候承诺不会发生。

  ▶ 播放视频 查看详情
• 194

  What Happens If There is a Failure?

  第 276 页

  让我们来聊聊如果在Salesforce中提交数据时失败了，会发生什么。首先，想象一下你正在看一个动画，这个动画会展示数据提交的过程。如果在这个过程中出现了问题，比如数据没有成功提交，那么动画会有一个箭头指示，告诉你所有的操作都会回滚。这意味着，所有你之前尝试保存的数据都会回到最初的状态，就像什么都没发生过一样。 接下来，如果这个失败是因为某些错误导致的，比如你使用了`addLock`方法将错误添加到记录中，那么触发器会继续完成它的工作，但仅限于当前这一批数据。这样做的目的是确保所有的错误都能被捕捉并报告回来，让你知道哪里出了问题。 所以，总结一下，如果提交失败，所有的保存操作都会回滚，不会继续执行后续的步骤。同时，如果使用了特定的方法来处理错误，那么这些错误会被记录下来，帮助你更好地理解和解决问题。希望这个解释能帮助你更好地理解Salesforce中的数据提交过程！

  ▶ 播放视频 查看详情
• 195

  What Conditions Within Apex Can Cause a Rollback?

  第 277 页

  让我们来聊聊Apex中的回滚和插入操作。首先，回滚是什么意思呢？简单来说，回滚就是当某些操作出错时，系统会自动撤销之前的所有操作，恢复到操作前的状态。这在Apex中是非常重要的，特别是在处理数据时。 那么，Apex中哪些情况会导致回滚呢？主要有两种情况： 1. ，未处理的异常，：如果在Apex代码中发生了错误，比如空指针异常或者除零错误，而且这个错误没有被捕获和处理，那么整个事务就会回滚。也就是说，所有在这个事务中做的修改都会被撤销。 2. ，AllOrNone操作中的错误，：当你在Apex中使用`Database.insert(records, true)`这样的操作时，如果其中任何一个记录插入失败，那么所有的记录都不会被插入，系统会回滚整个操作。 接下来，我们来看看如何在Apex中插入一组课程记录，并且允许部分保存。也就是说，即使有些记录插入失败了，其他有效的记录仍然可以被保存。这里有几个方法可以实现： 1. ，直接插入，：`insert courses;` 这种方式是“全有或全无”的，也就是说，如果任何一个记录插入失败，所有的记录都不会被插入。 2. ，Database.insert(records)，：这种方式和直接插入类似，也是“全有或全无”的。 3. ，Database.insert(records, true)，：这种方式明确指定了“全有或全无”，如果任何一个记录插入失败，所有的记录都不会被插入。 4. ，Database.insert(records, false)，：这种方式允许部分保存。也就是说，即使有些记录插入失败了，其他有效的记录仍然可以被保存。系统会返回一个结果列表，你可以检查哪些记录成功，哪些失败了。 所以，如果你希望插入一组课程记录，并且允许部分保存，你应该使用`Database.insert(courses, false)`这种方式。这样，即使有些记录有问题，其他有效的记录仍然可以被保存下来。 希望这些解释能帮助你更好地理解Apex中的回滚和插入操作！如果有任何问题，随时问我哦！

  ▶ 播放视频 查看详情
• 196

  10-2: View the Events that Occur During a Rollback

  第 278 页

  让我们一步一步来理解这个场景。 首先，想象一下你正在更新一个课程（Course）记录。这个更新动作会触发一个触发器（Trigger），这个触发器会去检查与这个课程相关的课程交付记录（Course Delivery Records）。在检查过程中，触发器发现其中一条记录有问题，于是它在这条记录中添加了一个错误提示（addAlert()）。这个错误提示导致整个保存操作被回滚，也就是说，所有的更改都不会被保存到数据库中。 现在，我们来讨论一下如果使用`Database.update(courseDeliveryUpdate.values())`会发生什么。这个方法允许你部分成功更新记录，也就是说，即使有些记录更新失败了，其他记录仍然可以被成功更新。但是，在这个场景中，由于原始事务（transaction）已经被回滚，所以即使使用这个方法，所有的更新操作仍然不会提交到数据库中。 接下来，我们来看看如何提高CourseDeliveryTrigger的效率。目前，触发器会对每个课程交付记录进行查询，这可能会消耗大量的资源和时间。为了提高效率，我们可以使用`Trigger.old`来排除那些日期值没有改变的记录。`Trigger.old`包含了触发器执行前的记录状态，通过比较`Trigger.old`和当前记录的状态，我们可以只对那些真正需要更新的记录进行操作，从而减少不必要的查询和更新，提高整体的效率。 总结一下，通过理解触发器的执行流程和利用`Trigger.old`，我们可以更有效地管理和优化Salesforce中的数据处理。希望这个解释对你有帮助！如果有任何问题，随时提问。

  ▶ 播放视频 查看详情
• 197

  Module Agenda - 279

  第 279 页

  同学们，今天我们来聊聊Salesforce中的一个非常重要的概念——执行和Apex事务的保存顺序。这个模块的内容可能会有点技术性，但我会尽量用简单易懂的方式来解释。 首先，我们要理解什么是“保存顺序”。在Salesforce中，当你对记录进行更改并保存时，系统会按照一定的顺序来处理这些更改。这个顺序非常重要，因为它决定了数据是如何被更新和保存的。 接下来，我们要探讨的是“Apex事务”。Apex是Salesforce的一种编程语言，它允许开发者编写自定义的业务逻辑。当一个Apex事务开始时，所有的数据库操作都会被当作一个整体来处理。这意味着，如果事务中的任何一个操作失败了，整个事务都会回滚，所有的更改都会被撤销。 在这个模块中，我们会详细讲解以下几点： 1. ，保存顺序，：我们会看看Salesforce是如何决定保存顺序的，以及这个顺序如何影响你的数据。 2. ，Apex事务，：我们会深入探讨Apex事务的工作原理，以及如何确保你的代码在事务中正确执行。 3. ，最佳实践，：最后，我们会分享一些最佳实践，帮助你在开发过程中避免常见的错误。 通过这个模块的学习，你将能够更好地理解Salesforce的数据处理机制，并能够编写出更高效、更可靠的Apex代码。希望这些内容对你有所帮助，我们开始吧！

  ▶ 播放视频 查看详情
• 198

  What is an Apex Transaction?

  第 280 页

  让我们来聊聊Apex交易。想象一下，你在玩一个游戏，这个游戏有很多关卡。每个关卡都需要你完成一系列的任务，只有当你完成了所有的任务，你才能进入下一个关卡。Apex交易就像是这个游戏中的一个关卡，它包含了一系列的操作，比如创建、更新或删除记录等。 在Apex中，一个交易从你开始执行一个方法开始，直到这个方法以及它调用的所有其他方法都执行完毕。这就好比你在游戏中，只有当你完成了当前关卡的所有任务，你才能说这个关卡结束了。在Apex中，只有当所有的方法都执行完毕，我们才能说这个交易完成了。 举个例子，假设你有一个方法叫做“更新客户信息”，这个方法会调用另一个方法“验证客户信息”。在这个例子中，交易从“更新客户信息”开始，直到“验证客户信息”也完成，整个交易才算结束。 但是，当我们谈到TLR（Trigger Logic Reuse）时，情况就有点不同了。TLR允许我们在不同的触发器之间共享逻辑，这意味着一个交易可能会跨越多个触发器。这就好比你在这个游戏中，有些任务可能会影响多个关卡，使得确定一个关卡何时结束变得不那么直接。 总的来说，Apex交易是一个包含了一系列操作的完整过程，从开始到结束，所有的操作都需要成功完成。理解这一点对于掌握Apex编程是非常重要的。

  ▶ 播放视频 查看详情
• 199

  Why Do You Care?

  第 281 页

  今天我们来聊聊Salesforce中的一个非常重要的概念——限制类（Limits Class）。这个话题听起来可能有点技术性，但其实很简单，我会用通俗易懂的方式来解释。 首先，为什么我们要关心限制类呢？因为在Salesforce中，每个组织都有一定的资源限制。这些限制是为了确保系统的稳定性和公平性。想象一下，如果没有任何限制，一个用户可能会占用大量的资源，导致其他用户无法正常工作。所以，了解和管理这些限制是非常重要的。 在Salesforce中，我们可以通过两种方法来获取这些限制信息：`Limits.getXXX()` 和 `Limits.getLimitXXX()`。这里的`XXX`代表不同的资源类型，比如CPU时间、数据库查询次数等。 - `Limits.getXXX()`：这个方法返回的是当前已经使用的资源量。比如，`Limits.getQueries()`会告诉你到目前为止，你已经执行了多少次数据库查询。 - `Limits.getLimitXXX()`：这个方法返回的是你总共可以使用的资源量。比如，`Limits.getLimitQueries()`会告诉你，在这个事务中，你最多可以执行多少次数据库查询。 举个例子，假设你正在编写一个Apex代码，你需要知道你已经使用了多少数据库查询，以及你还能使用多少。你可以这样写： ```apex Integer usedQueries = Limits.getQueries(); Integer totalQueries = Limits.getLimitQueries(); System.debug(&#39;你已经使用了 &#39; + usedQueries + &#39; 次查询，总共可以使用 &#39; + totalQueries + &#39; 次查询。&#39;); ``` 通过这种方式，你可以实时监控你的资源使用情况，确保不会超出限制。 总结一下，限制类帮助我们了解和管理Salesforce中的资源使用情况。通过`Limits.getXXX()`和`Limits.getLimitXXX()`，我们可以获取当前使用的资源和总的可用资源，从而更好地优化我们的代码和操作。 希望这个解释对你有帮助！如果有任何问题，随时问我哦。

  ▶ 播放视频 查看详情
• 200

  Apex Transactions that Invoke Triggers: Part 1

  第 282 页

  让我们来聊聊Salesforce中的Apex交易和触发器。想象一下，你在玩一个游戏，每一步操作都是游戏的一部分，直到你完成整个关卡。在Salesforce中，当你进行一系列操作时，比如保存一条记录，这些操作就像游戏中的每一步，它们都属于同一个“交易”。 这个交易就像是一个大包裹，里面装着你所有的操作。无论你做了多少事情，比如更新记录、发送邮件、或者调用其他Apex代码，它们都包含在这个大包裹里。这就是为什么我们说“一切都是同一笔交易的一部分”。 现在，让我们谈谈调用栈。调用栈就像是你玩游戏时的步骤记录。每当你执行一个操作，比如保存记录，Salesforce会记录下这个操作，并且如果这个操作触发了其他Apex代码，这些代码也会被记录下来。所有这些记录下来的步骤，都会按照它们发生的顺序，被包含在同一个Apex交易中。 所以，当你看到调用栈时，你实际上是在看这个交易中的所有操作，它们是如何一个接一个地发生的。这就像是你回顾游戏中的每一步，看看你是怎么一步步完成整个关卡的。 总结一下，Apex交易是一个包含所有相关操作的大包裹，而调用栈则是记录这些操作顺序的步骤记录。理解这一点，对于掌握Salesforce中的Apex编程非常重要。希望这个解释能帮助你更好地理解Apex交易和触发器的概念！

  ▶ 播放视频 查看详情
• 201

  Apex Transactions that Invoke Triggers: Part 2

  第 283 页

  让我们来聊聊Salesforce中的Apex事务和触发器。想象一下，你正在玩一个游戏，这个游戏有一个规则：所有的动作都必须在一个回合内完成。这个回合，就是我们的Apex事务。 首先，Apex事务开始了。这就像是你按下了游戏的开始按钮。在这个回合里，所有的操作都是同一笔交易的一部分。这意味着，无论你做了多少动作，它们都是在同一个“回合”里完成的。 接下来，我们来看看执行顺序。想象一下，你有一张任务清单，上面列出了你需要完成的所有任务。这些任务就是TLR操作，也就是触发器、工作流规则和验证规则。当你开始执行这些任务时，它们会按照一定的顺序进行，但这时候，游戏还没有真正“保存”你的进度。 在内存中，我们创建了一些对象，这些对象就像是游戏中的道具，它们暂时存放在你的“背包”里，等待被使用。 然后，我们开始执行第二个执行顺序。这就像是你继续完成你的任务清单上的下一个任务。同样，这时候游戏还是没有“保存”你的进度。 最后，当你完成了所有的任务，游戏会一次性“保存”所有的进度。这就像是Apex事务的提交阶段，所有的更改都会被一次性提交到数据库中。这时候，Apex事务就结束了，你的“回合”也完成了。 所以，记住，所有的操作都是在同一个Apex事务中完成的，就像是在同一个游戏回合中完成所有的任务一样。这就是Salesforce中Apex事务和触发器的工作原理。希望这个比喻能帮助你更好地理解这个概念！

  ▶ 播放视频 查看详情
• 202

  Apex Transactions that Begin with Triggers

  第 284 页

  让我们来聊聊Salesforce中的Apex触发器以及它们如何影响事务处理。首先，Apex触发器是一种强大的工具，它可以在数据库操作（如插入、更新或删除记录）发生时自动执行代码。但是，使用触发器时，我们需要特别注意事务的处理。 在Salesforce中，一个事务可以包含多个操作，比如更新多个记录或调用多个触发器。这些操作可能会非常复杂，尤其是在处理大量数据或执行多个业务逻辑时。事务的长度和复杂性可能会影响系统的性能和响应时间。 现在，让我们谈谈一个重要的概念：当操作不是通过Apex代码启动时，比如通过用户界面或API调用，Salesforce会自动开始一个事务。这个事务会从第一个Apex代码执行开始，一直持续到所有操作完成并提交到数据库。这意味着，即使你的触发器代码执行得非常快，整个事务可能仍然需要等待其他操作完成才能结束。 理解这一点非常重要，因为它可以帮助我们更好地设计和优化我们的Apex代码，确保事务处理既高效又可靠。希望这个解释能帮助你更好地理解Apex触发器及其在事务处理中的作用。如果有任何疑问，随时提问哦！

  ▶ 播放视频 查看详情
• 203

  What Will This Apex Transaction Include?

  第 285 页

  让我们一起来探讨这个Apex交易的过程。想象一下，这个过程就像是一场接力赛，每个步骤都紧密相连，直到最后完成整个交易。 首先，Apex交易开始于用户保存账户记录的那一刻。这就像是接力赛的起跑枪声，一旦响起，比赛就开始了。 接下来，账户上的After触发器被触发，它负责更新联系人记录。这就像是接力赛中的第一棒选手，接过接力棒后开始奔跑。 然后，联系人的Before触发器被执行。这就像是接力赛中的第二棒选手，准备接过接力棒继续比赛。 紧接着，联系人的工作流规则被触发，更新联系人记录上的字段。这就像是接力赛中的第三棒选手，接过接力棒后继续前进。 之后，联系人的Before触发器再次被执行。这就像是接力赛中的第四棒选手，接过接力棒后继续奔跑。 在整个过程中，没有发生任何错误或异常，这就像是接力赛中所有选手都顺利完成了自己的部分，没有掉棒。 现在，让我们回答几个关键问题： 1. Apex交易何时开始？ 当用户保存账户记录时，Apex交易就开始了。 2. 哪些触发器被视为交易的一部分？ 所有在这个过程中被触发的触发器都是交易的一部分，包括账户的After触发器、联系人的Before触发器以及工作流规则触发的更新。 3. Apex交易何时结束？ 当所有步骤都顺利完成，最后提交到数据库时，Apex交易就结束了。 4. 账户记录何时提交到数据库？ 在账户记录的执行顺序结束时，账户记录会被提交到数据库。 5. 联系人记录何时提交到数据库？ 联系人记录与账户记录同时提交到数据库，就像接力赛中的最后一棒选手和前一棒选手同时冲过终点线。 这个过程虽然复杂，但每个步骤都是有序进行的，就像接力赛中的每一棒都紧密相连，直到最后完成整个交易。希望这个比喻能帮助你更好地理解Apex交易的过程。

  ▶ 播放视频 查看详情
• 204

  Static Attributes and Apex Transactions

  第 286 页

  今天我们来聊聊Salesforce中的静态属性和Apex事务的一些要点。首先，静态变量在Apex中是非常有用的，特别是在处理事务时。 想象一下，静态变量就像是一个共享的笔记本，所有在这个事务中运行的代码都可以在这个笔记本上写字和读取。这个笔记本在整个事务的生命周期内都是可用的，也就是说，从事务开始到结束，这个笔记本一直都在。 举个例子，如果你在一个触发器中使用了一个静态变量，那么这个变量在整个触发器执行的过程中都是可用的。这意味着，如果同一个触发器被多次调用，比如因为批量操作，每次调用都可以访问和修改这个静态变量。这对于管理数据或者防止触发器中的重复操作非常有用。 但是，这里有一个小细节需要注意。如果你在触发器内部直接声明了一个静态变量，那么这个变量只能在这个触发器内部使用，其他触发器或者类是无法看到它的。所以，最佳实践是在类中声明静态变量，这样它们就可以在整个类中被访问，甚至可以被其他类通过类的实例访问。 使用静态变量的一个常见场景是管理触发器中的潜在回归问题，或者收集数据以便后续处理。比如，你可能想要记录下所有被触发器处理过的记录ID，然后在事务的最后统一处理这些记录。 总结一下，静态变量在Apex事务中非常有用，可以帮助你在事务的生命周期内共享数据。但是，记得要在类中声明它们，以确保它们可以在需要的地方被访问。这样，你就可以更有效地管理你的Apex代码，避免重复和不必要的复杂性。希望这个解释对你有帮助！

  ▶ 播放视频 查看详情
• 205

  10-3: See the Save Order of Execution in Action

  第 287 页

  让我们来一步步解析这些问题和答案，确保大家都能理解清楚。 首先，我们来看第一个问题：，发生了什么DML操作？， 答案是：，插入了一条任务记录，。这里需要注意的是，其他操作（比如课程参与者的插入）是在用户界面中进行的，所以这些操作不会记录在日志中。DML操作指的是对数据库的直接操作，比如插入、更新或删除记录。 接下来是第二个问题：，CourseAttendeeTrigger是什么类型的触发器？， 答案是：，在插入后触发，。这意味着当有新的课程参与者记录被插入到系统中时，这个触发器会在插入操作完成后自动运行。 第三个问题有点复杂：，我是不是发生了一起工作流程火灾？如果是这样的话，是什么连锁事件导致了它的起火？， 答案是：，是的，发生了工作流程火灾，。具体来说，当插入课程参与者时，系统会自动更新课程交付的汇总摘要。这个更新操作会触发工作流程规则，导致工作流程“起火”。你可以把它想象成一个多米诺骨牌效应：一个操作引发了另一个操作，最终触发了工作流程。 接下来是第四个问题：，CourseAttendeeTrigger会触发多少次？， 答案是：，两次，。你可以在“签入执行概述窗格”的“已执行单位”选项卡中看到这个信息。触发器运行两次是因为它处理的是批量的记录。 第五个问题：，是什么导致CourseAttendeeTrigger多次触发？， 答案是：，因为插入了205条Course_Attendee__c记录，。触发器运行两次是因为它每次最多处理200条记录，所以205条记录会被分成两个批次处理。 最后一个问题：，在数据设置之外，工作流触发的频率是多少？是什么决定了它的触发次数？， 答案是：，工作流会根据学生注册的每一门课程触发，。也就是说，每当你有一批新的学生注册课程时，工作流就会被触发一次。触发次数取决于有多少批次的记录需要处理。 总结一下，这些问题的核心在于理解触发器和工作流程的运作机制。触发器是在特定事件（如插入、更新、删除）发生时自动运行的代码，而工作流程则是在满足某些条件时自动执行的操作。理解这些概念有助于你更好地管理和优化Salesforce中的自动化流程。 希望这些解释对你有帮助！如果还有任何疑问，随时问我。

  ▶ 播放视频 查看详情
• 206

  Summary

  第 288 页

  今天我们来聊聊Salesforce中Apex代码的执行顺序，特别是关于“摘要保存执行顺序”的内容。这个话题听起来有点复杂，但我会尽量用简单的方式来解释，让你轻松理解。 首先，想象一下你在玩一个游戏，游戏里有很多步骤，每个步骤都要按顺序来，不能乱来。Apex代码的执行也是一样的，它有一个明确的执行顺序。 1. ，触发器的执行，：在Salesforce中，触发器（Trigger）是自动执行的代码块，当某些事件发生时（比如记录被插入、更新或删除），触发器就会启动。所以，Apex代码的执行顺序通常是从触发器开始的。 2. ，隐式保存点，：在Apex代码执行的过程中，Salesforce会自动设置一个“隐式保存点”。你可以把它想象成一个游戏存档点。如果在执行过程中出现了问题，系统可以回滚到这个保存点，确保数据不会出错。 3. ，数据库事务，：Apex代码的执行通常是在一个数据库事务中进行的。事务的意思就是一组操作，要么全部成功，要么全部失败。如果事务中的任何一步失败了，整个事务都会回滚，就像游戏里你失败了，系统会把你送回存档点一样。 4. ，TLR操作，：TLR（Transaction Log Replay）操作是Salesforce中的一种高级功能，它会在事务提交到数据库后结束。你可以把它想象成游戏里的最终关卡，只有通过了这个关卡，游戏才算真正结束。 5. ，静态变量，：在Apex代码中，静态变量（Static Variables）在整个Apex交易的持续时间内都会保留它们的值。这就像你在游戏里收集的道具，只要游戏还在进行，这些道具就一直有效。 6. ，总结，：所有的Apex代码都需要考虑到这些事件之间的交互，因为它们都是执行顺序的一部分。Apex交易可能会很漫长和复杂，所以我们要特别注意调节器限制和静态变量的使用。 好了，今天的讲解就到这里。希望你能对Apex代码的执行顺序有了更清晰的理解。如果你有任何问题，随时问我哦！

  ▶ 播放视频 查看详情
• 207

  Trailhead Homework - 289

  第 289 页

  今天我们来聊聊关于Salesforce的Trailhead家庭作业。Trailhead是一个非常棒的学习平台，特别是对于那些想要复习和提升PD1（Platform Developer 1）技能的同学来说。今天我要给大家介绍两个特别有用的Trailhead模块，它们将帮助你们更好地理解我们在课堂上讨论的一些概念。 第一个模块是关于Apex基础知识的，特别是映射概念。这个模块会教你如何在Salesforce中使用Apex来处理数据映射，这是开发中非常关键的一部分。通过这个模块，你可以学习到如何将数据从一个对象映射到另一个对象，这对于创建高效的数据处理流程非常重要。 第二个模块是关于开发者控制台的。开发者控制台是Salesforce开发者的一个重要工具，它可以帮助你编写、调试和测试代码。这个模块会教你如何使用开发者控制台的各种功能，比如查看日志、执行匿名代码块等。掌握这些技能，将大大提高你的开发效率。 这两个模块都是作为家庭作业来完成的，不需要在课堂上做。你们可以在课后自己安排时间去学习。记得，学习这些内容不仅能帮助你们更好地理解课堂上的知识，还能在实际工作中大显身手。 好了，这就是今天的家庭作业要点。希望你们能够利用好Trailhead这个资源，不断提升自己的技能。如果有任何问题，随时可以来问我。加油！

  ▶ 播放视频 查看详情
• 208

  Module 11: Testing Essentials

  第 290 页

  同学们，今天我们来聊聊Salesforce中的Apex测试方法。这个模块的主要任务就是教会大家如何编写和运行这些测试方法。听起来可能有点技术性，但别担心，我会尽量用简单的方式来解释。 首先，Apex测试方法是什么呢？简单来说，它们就像是你代码的“体检医生”。你写了一段代码，想要确保它在各种情况下都能正常工作，这时候就需要测试方法来帮忙了。它们会模拟各种场景，看看你的代码是不是真的“健康”。 在这个模块里，我们不会深入讨论所有关于测试的高级技巧和好处。为什么呢？因为那些内容会在下一个模块中详细讲解。如果我们在这里就把所有的“秘密”都告诉你们，那下一个模块就没啥好讲的了，对吧？ 所以，今天我们的重点就是掌握基本的测试方法编写和运行。学会了这些，你们就能为自己的代码做初步的“体检”了。等到下一个模块，我们再一起探讨如何让这些测试更加高效和全面。 好了，这就是今天的主要内容。希望大家能跟上节奏，如果有任何问题，随时提问。我们下节课再见！

  ▶ 播放视频 查看详情
• 209

  Module Objectives - 291

  第 291 页

  同学们，今天我们要学习的是如何在Salesforce中使用Apex测试框架来确保我们的代码在部署到生产环境之前是可靠的。这个模块的目标有三个主要部分： 首先，我们会描述Apex的测试框架。这个框架是Salesforce提供的一套工具，帮助我们编写和运行测试代码，确保我们的Apex代码按预期工作。 接下来，我们会学习如何创建测试数据。在测试环境中，我们通常需要一些模拟数据来测试我们的代码。这些数据不会影响实际的生产数据，所以我们可以放心地进行各种测试。 最后，我们会编写并运行Apex测试。这意味着我们会实际编写一些测试代码，然后运行这些测试，看看我们的触发器或其他Apex代码是否按预期工作。 特别要注意的是，在将代码部署到生产环境之前，测试是非常重要的。比如，我们有一个触发器，它的作用是确保在度假期间不安排课程。我们需要通过测试来确保这个触发器在各种情况下都能正常工作。 所以，今天的课程就是要帮助大家掌握这些技能，确保我们的代码在部署之前是经过充分测试的。大家准备好了吗？我们开始吧！

  ▶ 播放视频 查看详情
• 210

  Module Agenda - 292

  第 292 页

  同学们，今天我们来聊聊Salesforce中的Apex测试框架。这个框架是Salesforce用来确保我们的代码质量的一个非常重要的工具。想象一下，你写了一段代码，但你怎么知道它真的能按预期工作呢？这时候，Apex测试框架就派上用场了。 首先，我们会简单介绍一下Apex测试框架是什么。它其实是一套规则和工具，帮助我们编写测试代码，这些测试代码会模拟各种情况，看看我们的主代码是否能正确处理。 接下来，我们会学习如何创建测试数据。在Salesforce中，测试数据是专门用来测试的，不会影响到我们实际的数据。这样，我们就可以放心大胆地测试，不用担心会破坏什么。 最后，我们会动手编写和运行Apex测试。这是最有趣的部分，因为你可以看到你的代码在测试中的表现，确保它在各种情况下都能稳定运行。 好了，这就是我们今天要讲的内容。希望大家能跟上，我们一起确保我们的代码既强大又可靠！

  ▶ 播放视频 查看详情
• 211

  Testing Apex Code is a Part of the Salesforce ALM

  第 293 页

  同学们，今天我们来聊聊Salesforce中的测试顶点代码，这是应用程序生命周期管理（ALM）中的一个非常关键的部分。首先，我们需要理解的是，为了确保我们的代码质量，Salesforce要求我们在部署或打包代码之前，必须进行单元测试，并且这些测试需要覆盖至少75%的Apex代码。不过，我建议大家尽量达到90%的覆盖率，这样可以更好地保证代码的稳定性和可靠性。 在进行测试时，有几个要点需要注意： 1. 每个触发器至少需要有一行代码被测试覆盖。这意味着我们不能忽略任何一个触发器，即使它看起来很简单。 2. 我们的测试不应该引发任何异常。如果在测试过程中出现了异常，那就说明我们的代码可能存在问题，需要进一步检查和修复。 3. 如果测试中的断言失败了，那么这通常意味着我们的代码没有按预期工作，这时我们需要仔细检查并修正代码。 另外，从2015年夏季开始，Salesforce对测试的要求变得更加严格。特别是对于if语句的分支，我们必须测试每一个可能的分支，而不能仅仅将其视为一个简单的语句。同时，调试语句（如System.debug）是不需要被测试的。 在部署代码到生产环境之前，所有的单元测试都必须成功完成。Salesforce会自动执行组织命名空间中的每一个单元测试。记住，虽然我们只需要达到75%的代码覆盖率，但我们的目标应该是确保所有的应用场景都被测试到，包括正常情况和异常情况，以及处理大量数据和单条记录的情况。 最后，所有的类和触发器都必须能够成功编译，这是部署代码的基本要求。 希望这些信息对你们有所帮助，如果你们想了解更多，可以参考我提供的资源链接。记得，好的测试是高质量代码的基石，不要忽视它的重要性哦！

  ▶ 播放视频 查看详情
• 212

  The Platform Includes a Testing Framework

  第 294 页

  同学们，今天我们来聊聊Salesforce中的测试框架。这个框架是Apex语言的一部分，它允许开发人员编写、运行和分析测试代码。听起来是不是很酷？ 首先，开发人员会在测试类里面编写测试方法。这些方法就像是小实验，用来检查我们的代码是否按预期工作。当Salesforce收到特定的命令时，它就会运行这些测试。 Salesforce不仅会运行这些测试方法，还会运行这些方法调用的任何代码。这意味着我们可以确保整个功能模块都能正常工作。测试完成后，Salesforce会生成一个报告，告诉我们哪些测试成功了，哪些失败了，以及我们的代码有多少被测试覆盖了。 这里有两个重要的概念要记住：测试代码和业务代码。测试代码是用来测试业务代码的，确保业务代码能够正确执行。另外，我们还有功能测试和单元测试。功能测试是检查整个功能是否正常工作，而单元测试则是检查代码中的单个部分或单元。 总之，Salesforce的测试框架是一个非常强大的工具，可以帮助我们确保代码的质量和稳定性。希望大家能够好好利用这个工具，编写出更健壮的代码！

  ▶ 播放视频 查看详情
• 213

  What is an Apex Test Method?

  第 295 页

  让我们来聊聊Apex测试方法。想象一下，你写了一段代码，你希望确保它在Salesforce平台上运行得既顺畅又准确。这时候，Apex测试方法就派上用场了。 首先，Apex测试方法是一种特殊的类方法，它的主要任务是验证你的代码是否按预期工作。为了标记一个方法是测试方法，你需要使用`@isTest`注解。这个注解告诉Salesforce，这个方法是一个测试方法，不应该包含在实际运行的代码中。 关于Apex测试方法的几个要点： 1. ，类注解，：你需要在类定义前加上`@isTest`，这样Salesforce就知道这个类包含测试方法。 2. ，方法注解，：每个测试方法前也需要加上`@isTest`。虽然以前可以使用`testMethod`关键字，但现在推荐使用`@isTest`注解。 3. ，方法特性，：测试方法应该是静态的（`static`），返回类型为`void`，并且不接受任何参数。 举个例子，假设你有一个方法用来计算两个数的和，你可以写一个测试方法来验证这个方法是否正确： ```apex @isTest public class CalculatorTest { @isTest static void testSum() { Integer result = Calculator.sum(2, 3); System.assertEquals(5, result, &#39;The sum method did not return the expected result.&#39;); } } ``` 在这个例子中，`testSum`方法会调用`Calculator`类中的`sum`方法，并验证返回的结果是否等于5。如果结果正确，测试就会通过；如果不正确，测试就会失败，并显示错误信息。 通过编写这样的测试方法，你可以确保你的代码在各种情况下都能正常工作，这对于开发稳健、无错误的Salesforce应用至关重要。希望这个解释能帮助你理解Apex测试方法的基本概念！

  ▶ 播放视频 查看详情
• 214

  Module Agenda - 296

  第 296 页

  同学们，今天我们来聊聊Salesforce中的Apex测试框架。这个框架非常重要，因为它帮助我们确保我们的代码是可靠的，没有错误。 首先，Apex测试框架是Salesforce提供的一个工具，它允许我们编写测试代码来检查我们的Apex代码是否按预期工作。这些测试代码不会影响我们的实际数据，因为它们是在一个隔离的环境中运行的。 接下来，我们会学习如何创建测试数据。在Salesforce中，测试数据是用来模拟真实数据的，这样我们就可以在不影响实际业务数据的情况下进行测试。创建测试数据时，我们需要确保数据的准确性和完整性，这样才能得到可靠的测试结果。 然后，我们会学习如何编写和运行Apex测试。编写测试代码时，我们需要考虑各种可能的场景，包括正常情况和异常情况。运行测试时，Salesforce会执行这些测试代码，并告诉我们哪些测试通过了，哪些没有。 最后，我们会讨论测试文档的重要性。测试文档记录了我们的测试计划、测试用例和测试结果，这对于维护和更新我们的代码非常有帮助。 好了，这就是我们今天要学习的内容。希望你们能够理解并掌握这些知识，这样你们就能编写出更可靠、更高效的Apex代码了。

  ▶ 播放视频 查看详情
• 215

  Test Data

  第 297 页

  同学们，今天我们来聊聊关于测试数据的一些要点。首先，我们要确保我们的测试数据覆盖了所有可能的情况，这样我们才能确保我们的系统在各种情况下都能正常工作。 首先，我们需要准备一些假期数据。这些数据可以帮助我们测试系统在假期期间的表现。接下来，我们需要准备一些课程数据。这里有一个小技巧，我们需要准备一条“好”的课程数据和一条“坏”的课程数据。这样，我们就可以测试系统在遇到不同质量的课程数据时的反应。 然后，我们需要准备大量的课程数据，大约200条。这些数据中，有些是“好”的，有些是“坏”的。这样做的目的是为了测试系统在处理大量数据时的稳定性和准确性。 接下来，我们还需要测试创建“好”的课程数据，然后将其更新为“坏”的。这个过程可以帮助我们测试系统在数据更新时的表现。 每个班级都应该有多种独立的测试方法。这意味着我们需要为每个班级准备不同的测试场景，以确保我们的系统在各种情况下都能正常工作。 现在，让我们来看看教师注意事项。这是讨论幻灯片的内容。我们需要讨论假期数据、课程数据、“好”的课程交付和“坏”的课程交付。我们还需要讨论假期数据、课程数据、许多课程通知（一些“好”，一些“坏”）。最后，我们需要讨论假期数据、课程数据、良好的课程交付（在测试中更新）。 另一个需要问的好问题是：如果第一个方框发生变化，并且现在我们正在通过数据加载器加载课程交付记录，会发生什么？在这种情况下，您将需要测试多个记录。这个问题可以帮助我们理解系统在数据加载时的表现，以及如何处理多个记录的情况。 好了，同学们，这就是我们今天要讨论的内容。希望这些信息对你们有所帮助，记得在实际操作中多加练习，这样才能更好地掌握这些知识。

  ▶ 播放视频 查看详情
• 216

  Loading Test Data Declaratively Using a Static Resource

  第 298 页

  今天我们来聊聊如何在Salesforce中使用静态资源声明性地加载测试数据。这个方法非常实用，尤其是当你需要加载大量记录时，它可以大大简化你的工作。 首先，想象一下，你正在编写一个测试方法，通常你需要手动创建很多数据记录来测试你的代码。这可能会让你写很多行代码，既耗时又容易出错。但是，使用`Test.loadData`方法，你可以轻松地解决这个问题。 具体怎么做呢？很简单，你只需要将你的测试数据放在一个CSV文件中。然后，你可以在Salesforce中为这个CSV文件创建一个静态资源。静态资源就像是Salesforce中的一个文件库，你可以随时调用这些文件。 接下来，在你的测试方法中，你只需要调用`Test.loadData`方法，并传入两个参数：一个是`sObject`类型标记，也就是你要加载的数据类型，比如“Account”或“Contact”；另一个是你刚才创建的静态资源的名称。这样，Salesforce就会自动从CSV文件中读取数据，并加载到你的测试环境中。 举个例子，如果你的CSV文件包含了假期的数据，你可以将静态资源命名为“Test_Holidays”。然后在测试方法中，你就可以通过`Test.loadData(&#39;Holiday__c&#39;, &#39;Test_Holidays&#39;)`来加载这些数据。 为什么要使用静态资源来获取测试数据呢？主要有几个好处： 1. ，数据可控，：你可以制作少量但非常精确的数据，这对于测试来说非常重要。 2. ，自动化测试，：在机器人或自动化测试中，使用静态资源可以确保每次测试的结果都是可预测的。 3. ，易于维护，：如果你的测试数据需要更新，你只需要更新CSV文件，而不需要改动测试代码。 总之，使用静态资源加载测试数据是一个非常高效的方法，它可以帮助你节省时间，减少错误，并且使你的测试更加可靠。希望这个方法能帮助你在Salesforce的开发和测试中更加得心应手！

  ▶ 播放视频 查看详情
• 217

  Loading Related Data Using a Static Resource

  第 299 页

  同学们，今天我们来聊聊如何在Salesforce中使用静态资源来加载相关数据。这个方法非常酷，而且操作起来也很简单！ 首先，我们知道在Salesforce中，每个记录都有一个唯一的ID。当我们使用`Test.loadData()`方法从静态资源中加载测试数据时，每次加载的记录ID都会不同。这就带来了一个问题：如果我们有两个相关联的对象，比如父对象和子对象，我们怎么确保子对象能够正确地指向父对象呢？ 这里有一个小技巧：我们可以在父对象上创建一个“伪ID”字段，在子对象上创建一个“伪父ID”字段。这些字段不需要是真实的Salesforce ID，它们只是用来在数据加载过程中帮助我们建立关系的。 具体怎么做呢？我们可以在静态资源的数据文件中，预先为父对象和子对象填充这些伪ID字段。这样，无论每次加载时父对象的真实ID如何变化，子对象上的伪父ID都能始终指向正确的父对象。 举个例子，假设我们有一个父对象“Account”和一个子对象“Contact”。在静态资源的CSV文件中，我们可以为每个Account记录设置一个伪ID，比如“A1”、“A2”等。然后在Contact记录中，我们设置一个伪父ID字段，指向相应的Account伪ID。这样，当我们加载数据时，Salesforce会自动根据这些伪ID字段来建立Account和Contact之间的关系。 这个方法的好处是，我们不需要编写额外的代码来处理这些关系，Salesforce会自动帮我们搞定。虽然官方文档中提到可能需要额外的代码，但实际上，经过验证，这个方法是可以直接使用的。 总结一下，使用静态资源加载相关数据的关键点就是：在父对象和子对象上创建伪ID字段，并在静态资源中预先填充这些字段。这样，无论记录的ID如何变化，我们都能轻松地建立和维护对象之间的关系。 希望这个方法对你们有帮助！如果有任何问题，随时问我哦！

  ▶ 播放视频 查看详情
• 218

  Creating Test Data in a Test Factory Class vs. Method

  第 300 页

  今天我们来聊聊在Salesforce中如何有效地创建测试数据，特别是在测试工厂类中。这个过程听起来可能有点复杂，但其实掌握了关键点后，你会发现它非常有用且高效。 首先，我们谈谈手动创建数据。在Salesforce的测试类中，你可以手动创建数据，这意味着你可以在测试环境中设置一些特定的记录，用来模拟真实世界的数据。这样做的好处是，你可以确保每次测试都在相同的条件下进行，从而保证测试结果的准确性。 接下来，我们来看看@TestSetup注解。这是一个非常强大的工具，它允许你在一个测试类中设置一次数据，然后这个数据可以被类中的所有测试方法共享。想象一下，如果你有多个测试方法，每个方法都需要相同的数据，那么使用@TestSetup就可以避免重复创建数据的麻烦。这不仅节省了时间，还减少了系统资源的消耗。 使用@TestSetup方法时，你只需要在一个公共的、用@isTest注解的类中定义一个方法，并用@TestSetup来标记它。在这个方法中，你可以创建所有测试方法都会用到的记录。这些记录在测试类执行结束时会自动回滚，这意味着它们不会影响到你的实际数据库。 此外，由于这些记录是在测试设置方法中一次性创建的，而不是在每个测试方法中重复创建，所以它们的使用更加高效。这不仅可以减少测试执行时间，尤其是在处理大量记录时，还可以减少系统资源的消耗。 总结一下，使用@TestSetup方法在Salesforce测试类中创建测试数据，不仅可以提高测试的效率，还可以确保测试的准确性和一致性。希望这些信息对你有所帮助，让你在Salesforce的测试工作中更加得心应手！

  ▶ 播放视频 查看详情
• 219

  Does Test Data Permanently Change the Database?

  第 301 页

  让我们来聊聊Salesforce中的测试数据会不会永久改变数据库这个问题。首先，我们要明白，Salesforce提供了一个非常强大的测试框架，这个框架允许我们在不影响到实际数据库的情况下进行各种测试。 当你运行测试时，Salesforce会创建一个临时的环境。在这个环境中，你可以创建、修改、删除数据，就像你在实际环境中操作一样。但是，这里的关键点是，所有这些操作都是在“沙盒”中进行的，也就是说，它们不会影响到你的实际数据库。 一旦测试完成，Salesforce会自动回滚所有在测试过程中所做的更改。这意味着，测试数据不会留下任何“足迹”，你的数据库会保持原样，就像测试从未发生过一样。 所以，简单来说，测试数据不会永久更改数据库。你可以放心地进行各种测试，而不必担心会影响到实际的数据。这就是Salesforce测试框架的一个非常棒的特性，它让我们可以在一个安全的环境中自由地测试我们的代码，确保一切都能按预期工作。 希望这个解释能帮助你更好地理解Salesforce中的测试数据管理。如果你有任何疑问，随时欢迎提问！

  ▶ 播放视频 查看详情
• 220

  Using Live Data to Test

  第 302 页

  今天我们来聊聊在Salesforce中进行测试时，如何处理实时数据的问题。首先，我们有一个重要的原则要记住：尽量避免使用`SeeAllData=True`。为什么呢？因为这样做会让你的测试访问到所有的实时数据，这可能会带来一些问题。 想象一下，如果你的测试代码突然能够看到所有的客户数据、交易记录，甚至是敏感的健康信息，这不仅可能会违反一些法律，比如HIPAA，还可能会让你的测试结果变得不可预测。因为实时数据总是在变化的，今天测试通过，明天可能就失败了，因为数据变了。 但是，有些情况下，你可能不得不使用`SeeAllData=True`。比如，当你测试的对象是某些设置对象，或者你需要继承一些已经测试过的代码时。这时候，重构测试代码可能会非常困难，所以你可能需要暂时使用这个设置。 还有一种情况是，在部署到生产环境之前，你可能需要运行最后一组测试，确保在生产环境中没有异常情况。这时候，使用`SeeAllData=True`可能是必要的。 总的来说，使用`SeeAllData=True`要非常小心。在大多数情况下，我们应该尽量避免使用它，只在确实需要的时候才使用。这样，我们既能保证测试的准确性，又能保护数据的安全。 希望这些信息对你有帮助！如果你有更多问题，随时问我。

  ▶ 播放视频 查看详情
• 221

  11-1: Make Test Data Available to Test Methods

  第 303 页

  同学们，今天我们来聊聊如何在Salesforce中创建测试数据，这对于测试我们的认证应用程序非常重要。我们有两种主要的方法来创建这些数据：使用静态资源和以编程方式创建。 首先，我们来看看使用静态资源创建测试数据。静态资源是Salesforce中存储文件的一种方式，比如CSV文件。我们可以将测试数据存储在CSV文件中，然后上传到Salesforce作为静态资源。在测试方法中，我们可以加载这个静态资源，并将数据插入到Salesforce的对象中。这种方法非常适合当你有一组固定的测试数据时使用。 接下来，我们谈谈以编程方式创建测试数据。这种方法意味着我们直接在Apex代码中创建数据记录。我们可以使用Apex的DML语句，比如`insert`，来创建新的记录。这种方法的好处是灵活性高，你可以根据需要动态地创建数据。例如，如果你需要测试不同场景下的数据，你可以编写代码来生成这些数据。 现在，让我们花10分钟时间，一起动手实践一下。首先，我会展示如何使用静态资源加载测试数据，然后我们会编写一些Apex代码来以编程方式创建数据。这样，你们就能看到两种方法在实际操作中是如何工作的了。 准备好了吗？让我们开始吧！

  ▶ 播放视频 查看详情
• 222

  Module Agenda - 304

  第 304 页

  同学们，今天我们来聊聊Salesforce中的Apex测试框架。这个框架非常重要，因为它帮助我们确保我们的代码是可靠的，没有错误。 首先，Apex测试框架是Salesforce提供的一个工具，它允许我们编写测试代码来验证我们的Apex代码是否按预期工作。这些测试代码可以模拟用户操作，比如创建记录、更新记录等，然后检查结果是否符合预期。 接下来，我们会讲到如何创建测试数据。在Salesforce中，测试数据是专门用于测试的数据，它不会影响我们实际的生产数据。我们可以使用Apex代码来创建这些测试数据，这样我们就可以在测试环境中自由地测试我们的代码，而不用担心会影响到真实的数据。 然后，我们会学习如何编写和运行Apex测试。编写测试代码其实和编写普通的Apex代码差不多，但是我们会使用一些特殊的注解和方法来定义测试。编写好测试代码后，我们就可以在Salesforce中运行这些测试，看看我们的代码是否通过了所有的测试。 最后，我们会讨论测试文档的重要性。测试文档记录了我们的测试计划、测试用例和测试结果，这对于团队协作和代码维护非常有帮助。 好了，这就是我们今天要讲的内容。希望大家能够理解Apex测试框架的重要性，并学会如何创建测试数据、编写和运行Apex测试。如果有任何问题，随时提问哦！

  ▶ 播放视频 查看详情
• 223

  What Expected Outcomes Do You Need to Test?

  第 305 页

  让我们来聊聊这个测试场景。想象一下，你正在管理一个课程交付系统，你需要确保系统能够正确处理各种情况，无论是插入还是更新课程交付记录。 首先，我们来看看插入操作。当你插入一个“良好”的课程交付记录时，系统应该能够顺利接收并保存这个记录，没有任何错误提示。相反，如果你插入一个“糟糕”的课程交付记录，系统应该能够识别出问题，并给出相应的错误提示，阻止这个记录被保存。 接下来是更新操作。当你更新一个“良好”的课程交付记录时，系统应该能够接受这些更改，并成功更新记录。但如果更新的是一个“糟糕”的课程交付记录，系统同样应该能够识别出问题，并阻止更新操作。 现在，让我们考虑一下批量操作。当你同时插入或更新200个课程交付记录时，系统应该能够处理这些记录，但需要特别注意那些“糟糕”的记录。系统应该能够识别出这些记录，并阻止它们被保存或更新，同时允许“良好”的记录顺利通过。 最后，我们还需要考虑特殊情况，比如有些员工正在度假，他们的课程交付记录不应该被保存。系统应该能够识别出这些情况，并正确处理这些记录。 总结一下，我们需要测试的主要结果包括：插入和更新“良好”和“糟糕”的课程交付记录时的系统反应，以及批量操作时系统如何处理这些记录。通过这些测试，我们可以确保系统在各种情况下都能稳定运行，正确处理各种数据。

  ▶ 播放视频 查看详情
• 224

  An Apex Test Method Inside an Apex Test Class

  第 306 页

  今天我们来聊聊Apex测试类中的测试方法。首先，Apex测试方法是用来验证你的代码是否按预期工作的。你可以把它们想象成一个小实验，确保你的代码在各种情况下都能正常运行。 ### 为什么测试类和方法是私有的？ 你可能会问，为什么测试类和方法通常是私有的呢？这是因为测试方法和类主要是给开发人员用的，而不是给最终用户或其他人用的。如果测试方法是公开的，那么任何人都可以调用它们，这可能会带来安全风险。特别是如果测试方法涉及到敏感数据，比如访问组织中的所有数据，那就更不安全了。所以，为了安全起见，我们通常会把测试类和方法设为私有的。 ### 测试方法和类不计入代码大小限制 还有一个好消息是，测试方法和类不计入Salesforce的总体代码大小限制。这意味着你可以写很多测试代码，而不必担心会占用你的代码配额。这对于确保你的代码质量非常重要，因为你可以尽可能多地测试各种情况，而不必担心代码大小的限制。 ### 弹出窗口的解释 有时候，在测试过程中，你可能会遇到弹出窗口。这些弹出窗口通常是用来提示你某些信息，比如测试是否通过，或者是否有错误发生。你可以通过查看这些弹出窗口来快速了解测试的结果。如果测试通过了，那就说明你的代码在这个测试场景下是没问题的；如果测试失败了，那就需要你回去检查一下代码，看看哪里出了问题。 ### 总结 总的来说，Apex测试方法和类是用来确保你的代码在各种情况下都能正常工作的工具。它们通常是私有的，以确保安全性，并且不计入代码大小限制。通过编写和运行这些测试，你可以更有信心地发布你的代码，知道它在各种情况下都能正常运行。 希望这些内容对你有帮助！如果你有任何问题，随时问我哦。

  ▶ 播放视频 查看详情
• 225

  Testing for Expected Outcomes Using Assertions

  第 307 页

  今天我们来聊聊在Salesforce中使用断言（Assertions）来测试预期结果。断言，你可以把它想象成一个“你最好是”的方法。它用来确保你的代码按照你预期的方式运行。 首先，什么是断言呢？断言是一种声明，它让你能够测试你对程序的假设。比如说，如果你写了一个方法来计算粒子的速度，你可能会断言计算出来的速度应该小于光速。每个断言都包含一个布尔表达式，你希望这个表达式在执行时是真的。如果不是真的，系统就会抛出一个错误。通过这种方式，断言帮助你确认你的程序行为是否符合预期，从而增加你对程序正确性的信心。 在Salesforce的Apex代码中，虽然测试覆盖率要求是75%，但这并不意味着你需要为每一行代码都写断言。不过，对于你的业务逻辑，尤其是那些关键的部分，使用断言是非常必要的。这可以帮助你确保这些逻辑在未来的代码修改中仍然正确无误。 对于中小企业来说，保持断言的使用与Java中的相似性是一个好习惯。这样不仅可以帮助你更好地理解和维护代码，也使得代码更加健壮和可靠。 最后，如果你想更深入地了解断言的使用，可以参考Salesforce的官方文档或者Oracle的Java文档，这些资源都提供了很好的解释和示例。 希望这些信息对你有帮助，如果你有任何问题，随时提问！

  ▶ 播放视频 查看详情
• 226

  Running a Test in the Developer Console

  第 308 页

  今天我们来聊聊在Salesforce的开发人员控制台中运行测试的一些要点。首先，你要知道，Salesforce提供了很多工具来帮助我们运行测试，而开发人员控制台就是其中一个非常方便的地方。 在开发人员控制台中运行测试，你可以实时看到测试的进展情况，包括哪些测试通过了，哪些失败了，以及测试覆盖了多少代码。这些信息对于确保你的代码质量非常重要。 另外，当你准备将代码部署到生产环境时，Salesforce会自动运行这些测试。这是为了确保你的新代码不会破坏现有的功能。所以，运行测试不仅是开发过程中的一个步骤，也是部署前的一个重要检查点。 如果你对如何在开发人员控制台中运行测试还有疑问，可以参考Salesforce的帮助文档，那里有详细的步骤和解释。希望这些信息对你有帮助，让你在Salesforce的开发之旅更加顺利。

  ▶ 播放视频 查看详情
• 227

  11-2: Write and Run an Apex Test

  第 309 页

  我们现在来一起学习如何编写并运行一个Apex测试。这个测试的目的是验证我们的触发器和类的业务逻辑是否正确。具体来说，我们要确保只有在课程交付不属于假期的情况下，才能创建认证申请。 首先，我们需要理解业务逻辑。假设我们有一个触发器，它在认证申请被创建之前会检查课程交付的日期。如果这个日期落在假期内，那么触发器会阻止认证申请的创建。 接下来，我们需要编写一个测试类来模拟这个过程。测试类的主要任务是创建一个测试环境，模拟课程交付的日期，并尝试创建认证申请。然后，我们需要验证触发器是否正确地阻止了在假期内创建认证申请。 编写测试类时，我们通常会使用`@isTest`注解来标记这个类是一个测试类。然后，我们会定义一个或多个测试方法，每个方法都会测试一个特定的场景。在我们的例子中，我们需要测试两个场景：一个是课程交付日期不在假期内，另一个是课程交付日期在假期内。 在测试方法中，我们会首先设置测试数据，比如创建一个课程交付记录，并设置其日期。然后，我们会尝试创建认证申请，并使用`System.assert`或`System.assertEquals`来验证结果是否符合预期。 最后，我们需要运行这个测试类。在Salesforce中，我们可以通过开发者控制台或者使用命令行工具来运行测试。运行测试后，Salesforce会生成一个测试报告，告诉我们哪些测试通过了，哪些没有通过。 这就是我们如何编写并运行一个Apex测试来验证触发器和类的业务逻辑。通过这种方式，我们可以确保我们的代码在各种情况下都能正常工作。

  ▶ 播放视频 查看详情
• 228

  Key Takeaways - 310

  第 310 页

  同学们，今天我们来聊聊Salesforce的测试框架，这个框架让测试变得更加简单，也让我们的Apex代码更容易、更快地运行。 首先，我们有一个叫做`@isTest`的注释。这个注释是用来标记测试类中的方法的，这些方法就是专门用来测试我们的Apex代码的。你可以把它想象成一个标签，告诉Salesforce：“嘿，这个方法是为了测试用的，不是实际运行的代码。” 接下来，我们来说说测试数据。在Salesforce中，你可以用两种方式来提供测试数据：一种是声明性的，就是直接在代码里定义好数据；另一种是编程式的，就是通过代码动态生成数据。这两种方式都很灵活，你可以根据需要选择最适合的方式。 最后，我们有一个非常重要的概念叫做“断言”。断言是用来验证我们的应用程序在某个时间点的状态是否符合预期。简单来说，就是检查一下我们的代码运行后，结果是不是我们想要的。如果结果和预期一致，那么测试就通过了；如果不一致，那就说明我们的代码可能有问题。 好了，这就是我们今天要回顾的关键要点。希望大家能够理解并记住这些内容，这样在编写和测试Apex代码时，就能更加得心应手了。如果有任何问题，随时问我哦！

  ▶ 播放视频 查看详情
• 229

  Knowledge Check - 311

  第 311 页

  让我们来简单理解一下这些知识点。 首先，Salesforce要求至少75%的Apex代码必须通过测试方法来执行。这意味着，你写的代码大部分都需要有相应的测试来验证它的正确性。 接下来，我们谈谈测试设置方法。这些方法是用`@testSetup`注解标记的。它们的作用是在测试开始之前创建一些测试数据。这样，你就不需要在每个测试方法中都重复创建这些数据了。测试框架会先执行这些设置方法，然后再执行其他的测试方法。 在测试设置方法中创建的数据，可以在整个测试类中的所有测试方法中使用。而且，这些数据在测试结束后会自动回滚，也就是说，它们不会影响到你的实际数据库。 如果在某个测试方法中修改了这些数据，比如更新了某个字段或者删除了某条记录，这些修改也会在每个测试方法执行完后回滚。这样，下一个测试方法看到的还是原始的数据状态。 最后，如果测试方法没有引发任何断言异常，那么测试就算是通过了。这意味着你的代码在这个测试场景下是符合预期的。 简单来说，测试设置方法帮助你准备测试数据，测试方法验证你的代码，而所有的数据修改都会在测试结束后回滚，确保测试的独立性和数据的干净。

  ▶ 播放视频 查看详情
• 230

  Trailhead Homework - 312

  第 312 页

  今天我们来聊聊关于Salesforce Trailhead的家庭作业教学要点。首先，Trailhead是一个非常棒的学习平台，特别适合用来复习和巩固你的PD1（Platform Developer 1）技能。通过Trailhead，你可以通过互动的方式学习Salesforce的各种功能和开发技巧。 今天给大家布置的家庭作业是完成一个叫做“Apex Testing”的模块。这个模块会帮助你更好地理解如何在Salesforce中进行Apex代码的测试。测试是开发过程中非常重要的一部分，它确保你的代码不仅能够运行，而且运行得正确无误。 这个模块会教你如何编写测试类，如何运行测试，以及如何确保你的代码覆盖率达到标准。这些都是PD1考试中非常重要的知识点，所以一定要认真完成。 记住，这是家庭作业，不需要在课堂上完成。你可以在家里或者任何你觉得舒适的地方，按照自己的节奏来学习。完成这个模块后，你会对Apex测试有一个更深入的理解，这对你未来的Salesforce开发工作会有很大的帮助。 好了，这就是今天的家庭作业。希望大家都能通过Trailhead学到更多，加油！

  ▶ 播放视频 查看详情
• 231

  Module 12: Testing Strategies

  第 313 页

  让我们来聊聊Salesforce中的测试。在这个模块里，我们要讨论的是你作为开发者，在编写代码时，测试这部分代码的责任是什么，以及什么是“完整”的测试。 首先，测试你的代码是你的责任。这意味着你需要确保你的代码不仅能够正常工作，而且还要在各种情况下都能稳定运行。这包括处理错误输入、边界条件以及确保代码的性能符合预期。 那么，什么是“完整”的测试呢？完整测试意味着你需要覆盖所有可能的场景和用例。这包括正常流程、异常流程以及边界条件。你需要确保你的测试案例能够验证代码的每一个部分，包括所有的分支和逻辑路径。 接下来，我们来谈谈总体测试策略。一个好的测试策略应该包括单元测试、集成测试和系统测试。单元测试关注的是代码的最小部分，确保每个函数或方法都能正确执行。集成测试则是确保不同的模块或服务能够正确地协同工作。系统测试则是在整个系统层面上进行，确保所有部分都能一起正常工作。 在Salesforce中，我们通常使用开发人员沙盒来进行测试。开发人员沙盒是一个隔离的环境，你可以在不影响生产环境的情况下测试你的代码。这让你可以自由地尝试和修改代码，而不用担心会影响到实际的业务操作。 最后，完整的沙盒是一个更接近生产环境的测试环境。它不仅包含你的代码，还包括数据、配置和用户信息。这使得你可以在一个非常接近真实世界的环境中进行测试，确保你的代码在实际部署时能够顺利运行。 总之，测试是确保你的代码质量和稳定性的关键步骤。通过全面的测试策略和适当的测试环境，你可以大大提高你的代码的可靠性和性能。

  ▶ 播放视频 查看详情
• 232

  Module Objectives - 314

  第 314 页

  同学们，今天我们来聊聊Salesforce开发中的一个重要环节——确保你的Apex代码在部署到生产环境之前是经过充分测试的。这个环节非常关键，因为它能帮助我们避免在生产环境中遇到各种意外问题。 首先，我们要明确一个目标：在将代码从沙箱环境迁移到生产环境之前，确保你的代码覆盖率达到了100%。虽然Salesforce官方要求的最低覆盖率是75%，但为了更高的代码质量和稳定性，我们建议追求100%的覆盖率。这意味着你的测试用例需要覆盖到代码中的每一个可能的执行路径。 接下来，我们来看看如何实现这个目标。首先，你需要确定你的代码覆盖率。这可以通过Salesforce提供的工具来完成，它会告诉你哪些代码行已经被测试覆盖，哪些还没有。这样，你就可以有针对性地编写测试用例，确保每一行代码都被测试到。 然后，使用最佳实践来创建测试。这意味着你的测试用例不仅要覆盖代码，还要确保它们能够有效地验证代码的功能和逻辑。编写测试时，要考虑到各种边界情况和异常情况，确保代码在这些情况下也能正常工作。 最后，确保你的Apex代码符合你的编码标准。这不仅包括代码的格式和风格，还包括代码的可读性和可维护性。良好的编码标准可以帮助团队更高效地协作，减少错误的发生。 总之，通过确保100%的代码覆盖率和遵循最佳实践来创建测试，你可以大大提高代码的质量和稳定性，确保在将代码部署到生产环境时不会遇到意外问题。希望这些内容对你们有所帮助，祝你们在Salesforce开发中取得成功！

  ▶ 播放视频 查看详情
• 233

  Module Agenda - 315

  第 315 页

  同学们，今天我们来聊聊Salesforce中的测试模块。首先，我们要了解的是，测试在Salesforce中是非常重要的，因为它帮助我们确保我们的代码在部署到生产环境之前是稳定和可靠的。 首先，我们会讨论测试的副作用。在编写测试时，我们可能会不小心引入一些副作用，比如改变了数据库中的数据，这可能会影响到其他测试或者实际的生产数据。因此，我们需要非常小心，确保我们的测试是独立的，不会影响到其他部分。 接下来，我们会学习如何使用最佳实践进行测试。这包括编写清晰、可维护的测试代码，确保测试覆盖了所有重要的业务逻辑，以及使用模拟数据来避免对实际数据的依赖。 在模块12的课程中，我们会详细介绍Apex测试框架。Apex测试框架是Salesforce提供的一个强大的工具，它允许我们编写和执行测试用例，以确保我们的Apex代码按预期工作。我们会学习如何创建测试类，如何编写测试方法，以及如何运行和评估测试结果。 记住，良好的测试习惯不仅能帮助我们捕捉错误，还能提高代码的质量和可维护性。所以，让我们开始学习如何有效地进行测试吧！

  ▶ 播放视频 查看详情
• 234

  Avoiding Issues Caused By Tests Running in Parallel

  第 316 页

  让我们来聊聊如何在Salesforce中避免在并行测试执行时遇到的一些常见问题。首先，我们需要理解什么是并行测试执行。简单来说，就是Salesforce可以同时运行多个测试，这样可以节省时间。但是，这有时候也会带来一些问题，比如数据冲突。 第一个常见的问题是“Unable_to_lock_row”错误。这个错误通常发生在两个测试同时尝试更新同一条记录时。想象一下，如果两个人同时想要编辑同一个文档，系统就会混乱，不知道应该保存谁的更改。在Salesforce中，这种情况会导致锁定错误。 为了避免这种问题，我们有几个策略： 1. ，创建自己的测试数据，：不要依赖现有的组织数据，而是为每个测试类创建自己的测试数据。这可以通过使用`@testSetup`注解来实现。这样，每个测试都有自己的数据，不会与其他测试冲突。 2. ，禁用并行测试，：如果你发现并行测试导致问题，可以选择关闭它。这可以通过Salesforce的设置来完成。具体步骤是：进入设置，找到“开发”部分，然后选择“Apex测试执行”，在选项中选择“禁用并行Apex测试”。 3. ，重构代码，：如果可能，尝试将相关的测试方法放在同一个测试类中。虽然测试类是并行运行的，但类中的测试方法是按顺序执行的，这可以减少冲突的可能性。 最后，记得在时间允许的情况下进行演示，这样你可以更直观地看到这些策略的效果。希望这些信息对你有帮助，让你在Salesforce的测试过程中更加顺利！

  ▶ 播放视频 查看详情
• 235

  How is Code Coverage Calculated?

  第 317 页

  让我们来聊聊Salesforce中的代码覆盖率是怎么一回事。首先，想象一下你的代码就像一本书，而代码覆盖率就是告诉你这本书有多少页被真正“读过”了。在Salesforce中，这个“读过”的部分指的是那些被测试执行过的代码行。 现在，不是所有的代码行都会被计入覆盖率。比如，注释、空行、只有部分语句的行、System.DEBUG()语句，还有那些只有大括号{}的行，这些都不会被算作覆盖行。但是，如果一行上有多个语句，它们会被当作一行来计算。如果是一个多行的表达式，那么每一行都会单独计算。 举个例子，假设你有一段代码，我们可以把它分成几个部分：C1、C2、T1、C3、T2和C4。如果测试覆盖了C1、C2、T1和C3，那么覆盖率就是75%，因为T2和C4没有被覆盖。但是，每个触发器至少需要有一行被覆盖，这是最低要求。不过，C4这一部分不需要被覆盖。 Salesforce要求你的代码覆盖率至少达到75%，但为了代码的质量和稳定性，你应该努力达到90%以上。 计算代码覆盖率的时候，有两个关键的时间点：一个是你显式执行测试的时候，另一个是你进行部署的时候。这两个时间点都会计算覆盖率，但它们是不同的。显式执行测试通常是通过用户界面来调用的，比如使用开发者控制台。测试会排队异步运行，完成后，代码覆盖率表会根据测试结果更新。 希望这个解释能帮助你理解Salesforce中的代码覆盖率是如何计算的。记住，高覆盖率意味着你的代码更健壮，更不容易出错。所以，尽量让你的覆盖率保持在90%以上吧！

  ▶ 播放视频 查看详情
• 236

  Viewing Testing Results and Code Coverage

  第 318 页

  让我们来聊聊如何在Salesforce中查看测试结果和代码覆盖率。这其实是一个非常重要的步骤，尤其是在你准备将代码部署到生产环境之前。 首先，当你运行了Apex测试后，你会想要检查测试是否通过了，以及你的代码覆盖率是多少。你可以在开发人员控制台里找到这些信息。想象一下，你打开了一个测试结果的页面，这里会显示哪些测试通过了，哪些失败了。失败的部分通常会以红色高亮显示，这样你一眼就能看出哪里出了问题。 接下来，我们来看看代码覆盖率。代码覆盖率是一个百分比，它告诉你你的测试覆盖了多少代码。Salesforce要求至少75%的代码覆盖率才能部署到生产环境。这个覆盖率是通过计算所有被测试覆盖的代码行数除以总代码行数得出的。在开发人员控制台的“测试”选项卡里，你可以看到一个“总体代码覆盖率”面板，这里会显示每个Apex类的覆盖率以及整体的覆盖率。 这里有个小技巧，当你查看覆盖率时，绿色的部分表示这些代码已经被测试覆盖了，而红色的部分则表示这些代码还没有被测试到。你可以点击这些红色的部分，看看是哪些代码没有被覆盖，然后回去修改你的测试用例，确保这些代码也能被测试到。 最后，记住在进行部署时，Salesforce会自动运行测试并计算覆盖率。如果覆盖率不达标，部署就会失败。而且，这些覆盖率数据不会存储在数据库中，这是为了支持部署失败时的回滚操作。如果部署失败，所有的更改都会被撤销，包括那些覆盖率数据，这样可以避免指向不存在的代码行。 希望这些信息对你有帮助，让你在Salesforce的世界里更加得心应手！

  ▶ 播放视频 查看详情
• 237

  Stored Code Coverage Calculations

  第 319 页

  让我们来聊聊Salesforce中的代码覆盖率这个话题。首先，代码覆盖率是一个非常重要的指标，它告诉我们有多少比例的代码被测试覆盖了。这个比例越高，说明我们的代码质量越好，潜在的错误也越少。 但是，这里有一个小陷阱。你可能会看到某个代码覆盖率的百分比，但这个数字可能是旧的。为什么呢？因为Salesforce不会自动更新这个百分比，除非你重新运行测试。所以，如果你最近对代码做了修改，比如添加了新的触发器或者修改了现有的类，那么旧的覆盖率数字就不再准确了。 举个例子，假设你的组织中有50行代码，这些代码都被测试覆盖了，所以覆盖率是100%。然后，你添加了一个新的触发器，这个触发器有50行代码，但这些代码还没有被测试覆盖。现在，你的总代码行数变成了100行，但只有50行被测试覆盖了。所以，你的代码覆盖率就从100%下降到了50%。 因此，为了得到准确的代码覆盖率，你需要定期重新运行测试。这样，Salesforce会重新计算覆盖率，确保你看到的数字是最新的。记住，只有当测试重新运行后，代码覆盖率的百分比才会更新。 所以，下次当你看到代码覆盖率的时候，记得问自己：“这个数字是最新的吗？”如果不是，那就赶紧重新运行测试吧！这样，你就能确保你的代码质量始终保持在最佳状态。

  ▶ 播放视频 查看详情
• 238

  12-1: Explore Code Coverage

  第 320 页

  同学们，今天我们来聊聊Salesforce中的代码覆盖率。这是一个非常重要的概念，尤其是在我们编写Apex代码时。代码覆盖率可以帮助我们了解我们的测试类是否足够全面，是否覆盖了所有可能的代码路径。 首先，我们需要准备一个实验室环境。这个环境可以是你的开发者组织，或者是一个沙盒环境。确保你有权限在这个环境中运行Apex代码和测试类。 接下来，我们要运行一个测试类。你可以选择一个你已经写好的测试类，或者创建一个新的。运行测试类的方法很简单，打开开发者控制台，找到你的测试类，然后点击“运行测试”。 运行完测试类后，我们就可以查看代码覆盖范围了。在开发者控制台中，点击“测试”标签，然后选择“查看覆盖范围”。这里你会看到一个百分比，这个百分比表示你的测试类覆盖了多少代码。理想情况下，我们希望这个百分比尽可能高，最好是100%。 最后，我们的目标是使用开发者控制台来探索代码覆盖范围。你可以尝试修改你的测试类，看看覆盖范围如何变化。你也可以尝试添加新的测试方法，看看是否能提高覆盖率。 好了，这就是今天的任务。希望你们能通过这个实验，更好地理解代码覆盖率的重要性。现在，轮到你动手试试吧！

  ▶ 播放视频 查看详情
• 239

  Module Agenda - 321

  第 321 页

  同学们，今天我们来聊聊Salesforce中的测试模块。首先，我们要了解的是测试的副作用。在编程中，当我们运行测试时，有时候会无意中改变数据或者系统的状态，这就是所谓的副作用。在Salesforce中，我们特别要注意这一点，因为我们的测试可能会影响到实际的数据。 接下来，我们会讨论如何使用最佳实践来进行测试。最佳实践就是那些被广泛认可和推荐的方法，它们可以帮助我们更有效地进行测试，减少错误，提高代码的质量。在Salesforce中，这包括编写独立的测试用例，确保测试覆盖所有可能的场景，以及使用断言来验证测试结果。 现在，让我们进入模块12：测试课程。在这一部分，我会先给大家介绍Apex测试框架。Apex是Salesforce的一种编程语言，而Apex测试框架则是用来测试Apex代码的工具。这个框架可以帮助我们确保我们的代码在部署到生产环境之前是可靠的，没有bug的。 记住，测试是开发过程中非常重要的一环，它帮助我们确保我们的应用是稳定和可靠的。所以，让我们开始学习如何有效地进行测试吧！

  ▶ 播放视频 查看详情
• 240

  Testing Data Conditions: Valid, Invalid, and Bulk

  第 322 页

  同学们，今天我们来聊聊Salesforce中的测试数据条件，特别是关于有效、无效和批量数据的处理。我会用简单的语言来解释这些概念，确保大家都能跟上。 首先，我们来看，有效数据，。有效数据指的是那些符合我们预期，能够被系统正确处理的数据。在我们的例子中，有效数据包括两种情况：一种是带有电话号码的账户，另一种是没有电话号码的账户。虽然空电话看起来可能不太完整，但如果我们的系统设计是允许这种情况的，那么它也是有效的。所以，我们需要测试这两种情况：插入一个带有电话号码的账户，以及插入一个没有电话号码的账户。 接下来是，无效数据，。无效数据通常是指那些不符合我们预期，或者系统没有明确处理的数据。在这个例子中，如果我们有一个空的名单，这就是一种无效数据。因为我们的系统可能没有设计去处理这种情况，所以我们需要确保我们的代码能够优雅地处理这种异常情况，而不是崩溃。 最后，我们来看，批量数据，。批量数据测试是为了确保我们的代码能够处理大量的数据，而不仅仅是单个记录。在我们的例子中，我们需要测试插入200个账户，其中一些有电话号码，另一些没有。这可以帮助我们确保代码在处理数据列表时能够正常工作，而不仅仅是单个记录。 总结一下，我们需要进行以下测试： 1. 插入一个带有电话号码的单一账户。 2. 插入一个没有电话号码的单一账户。 3. 插入一个包含200个账户的列表，其中一些有电话号码，另一些没有。 通过这些测试，我们可以确保我们的代码在各种情况下都能稳定运行。希望这些解释对大家有帮助，如果有任何问题，随时提问！

  ▶ 播放视频 查看详情
• 241

  Testing Limits

  第 323 页

  让我们来聊聊Salesforce中的测试方法，特别是`startTest`和`stopTest`这两个方法。想象一下，你在做一道菜，`startTest`就像是开始烹饪的那一刻，而`stopTest`则是你完成烹饪，准备上菜的时候。 首先，`startTest`方法在测试代码中标记了一个点，表示测试正式开始。在这之前，你可以做一些准备工作，比如设置变量、填充数据等，这些都是为了确保测试能够顺利进行。每个测试方法中，`startTest`只能被调用一次。 当你调用`startTest`之后，系统会给你一组新的调控器限制。这就像是你在烹饪时，突然有了更多的食材可以使用。但是，一旦你调用`stopTest`，系统就会回到原来的限制，就像是你用完了额外的食材，只能回到原来的食材库。 `stopTest`方法则是在测试结束时标记的点。它和`startTest`是成对使用的，每个测试方法中也只能调用一次。在`stopTest`之后执行的代码，会回到调用`startTest`之前的限制。 此外，`startTest`之后的所有异步调用都会被系统收集起来，当执行`stopTest`时，这些异步进程会同步运行。这就像是你在烹饪时，同时开了几个锅，但最终所有锅里的菜都会在同一时间完成。 所以，使用`startTest`和`stopTest`方法，可以帮助你更好地控制测试的流程和限制，确保测试的准确性和效率。希望这个解释能帮助你更好地理解这两个方法的作用！

  ▶ 播放视频 查看详情
• 242

  Testing with Sharing Using System.RunAs(User u)

  第 324 页

  今天我们来聊聊Salesforce中的System.RunAs方法，这是一个在测试中非常有用的工具。想象一下，你正在编写一些Apex代码，这些代码需要根据不同的用户权限和记录共享规则来运行。但是，Apex代码默认是在系统模式下运行的，这意味着它不会考虑当前用户的权限或记录共享设置。这时候，System.RunAs就派上用场了。 使用System.RunAs，你可以在测试方法中模拟一个特定用户的上下文。这样，你就可以测试你的代码在不同用户权限下的行为，特别是记录共享的部分。不过要注意，RunAs方法只会影响记录共享，不会改变用户的权限或字段级别的权限。 举个例子，假设你有一个用户u，你想测试这个用户是否能访问某些记录。你可以在测试方法中使用System.RunAs(u)来模拟这个用户的上下文，然后检查相关的记录共享规则是否按预期工作。 另外，RunAs方法还有一个很酷的特性，就是它不受用户许可证的限制。即使你的组织没有额外的用户许可证，你仍然可以使用RunAs来创建新用户进行测试。 还有一点需要注意的是，每次调用RunAs都会计入DML语句的总数。所以如果你在测试中频繁使用RunAs，可能会影响到DML语句的限制。 最后，RunAs方法还有一个重载版本，可以接受包版本作为参数。这个版本允许你测试特定版本的托管包代码。 总结一下，System.RunAs是一个非常强大的工具，可以帮助你在测试中模拟不同用户的上下文，特别是用于测试记录共享规则。希望这些信息对你有帮助！如果你有更多问题，随时问我哦。

  ▶ 播放视频 查看详情
• 243

  Setting Up Data for System.RunAs(User u)

  第 325 页

  同学们，今天我们来聊聊如何在Salesforce中使用`System.runAs`方法来模拟不同用户的操作，并通过测试来验证我们的代码。我们有两个代码片段需要解释，分别是代码A和代码B。我会一步步引导大家理解这些代码的作用。 ### 代码A的解释 首先，我们来看代码A。这段代码的主要目的是计算今天创建的证书持有记录的总数。具体步骤如下： 1. ，计算记录总数，：我们使用SOQL查询来查找今天创建的证书持有记录。这里需要注意的是，我们没有使用`AllData=TRUE`，所以只会计算当前用户可见的记录。根据我们的测试设置，应该只有两条记录。 2. ，查找TA1用户，：接下来，我们使用SOQL查询来找到名为TA1的用户。TA1是一个培训管理员用户。 3. ，设置用户上下文，：使用`System.runAs(TA1)`，我们将当前的用户上下文切换到TA1用户。这意味着接下来的操作都会以TA1的身份执行。 4. ，调用方法并统计记录，：我们调用`CountDailyCertHeld`方法，这个方法会返回当前用户（即TA1）今天创建的证书持有记录的总数。 5. ，断言验证，：最后，我们使用`System.assertEquals`来验证`CountDailyCertHeld`方法返回的记录数是否与我们之前计算的记录数一致。如果一致，测试通过；如果不一致，测试失败。 ### 代码B的解释 接下来，我们来看代码B。这段代码的目的是验证一个没有证书记录的用户（UA2）在调用`CountDailyCertHeld`方法时，返回的记录数是否为0。具体步骤如下： 1. ，查找UA2用户，：我们使用SOQL查询来找到名为UA2的用户。UA2是一个标准用户，并且没有任何证书记录。 2. ，设置用户上下文，：使用`System.runAs(UA2)`，我们将当前的用户上下文切换到UA2用户。这意味着接下来的操作都会以UA2的身份执行。 3. ，调用方法并统计记录，：我们调用`CountDailyCertHeld`方法，这个方法会返回当前用户（即UA2）今天创建的证书持有记录的总数。由于UA2没有任何证书记录，所以返回的记录数应该是0。 4. ，断言验证，：最后，我们使用`System.assertEquals`来验证`CountDailyCertHeld`方法返回的记录数是否为0。如果是0，测试通过；如果不是0，测试失败。 ### 测试设置方法 在开始测试之前，我们需要设置一些测试数据。这就是`@TestSetup`方法的作用。在这个方法中，我们创建了三个用户： 1. ，培训管理员（TA1），：这是一个拥有管理权限的用户。 2. ，标准用户（UA2），：这是一个拥有两个证书记录的用户。 3. ，标准用户（UA3），：这是一个没有任何证书记录的用户。 通过这种方式，我们可以在测试中使用这些用户来验证我们的代码是否按预期工作。 ### 总结 通过这两段代码，我们学会了如何使用`System.runAs`来模拟不同用户的操作，并通过测试来验证我们的代码。我们首先计算了记录总数，然后切换用户上下文，最后通过断言来验证结果。希望这些内容对大家理解Salesforce中的测试方法有所帮助。如果有任何问题，欢迎随时提问！

  ▶ 播放视频 查看详情
• 244

  Breaking Up Your Test Classes

  第 326 页

  让我们来聊聊Salesforce中的测试课程要点。首先，想象一下你有一个商务舱，这是你的主要工作环境，所有的开发工作都在这里进行。然后，你还有一个测试舱，这是你用来测试代码的地方。这样做的好处是，你可以确保你的代码在投入生产环境之前是经过充分测试的。 现在，关于测试方法，我们提倡使用很多小测试方法，而不是一个大型的测试类。这样做有几个好处： 1. ，测试数据隔离，：每个小测试方法都有自己的测试数据，这样就不会因为数据冲突而导致测试失败。 2. ，测试类可以并行运行，：小测试方法可以同时运行，这样可以加快测试的速度。 3. ，测试案例隔离，：每个测试方法都是独立的，一个测试方法的失败不会影响到其他测试方法。 教学点的最佳做法是，每个班（即每个开发环境）都应该有一个对应的测试班。这意味着，不要创建单个的大型测试类，而是应该创建多个小型的、专注的测试类。这样做可以确保每个测试类都专注于测试一个特定的功能或模块，从而提高测试的准确性和效率。 总之，通过分解测试课程要点，使用小测试方法，并确保每个班都有一个测试班，你可以更有效地进行Salesforce开发，确保代码的质量和稳定性。希望这些信息对你有所帮助！

  ▶ 播放视频 查看详情
• 245

  Ensuring Test Data is Created Properly When Deployed

  第 327 页

  同学们，今天我们来聊聊在Salesforce部署时，如何确保正确创建测试数据。这里有两个关键点需要注意： 首先，，确保加载静态资源，。静态资源，比如我们这里提到的“Test Holidays”，在生产环境中必须是可用的。这意味着在部署之前，你需要确认这些资源已经上传并且可以在生产环境中访问。如果静态资源没有正确加载，那么依赖于这些资源的测试数据就无法正确创建，这会导致测试失败。 其次，，不要硬编码ID，。在Salesforce中，每个记录都有一个唯一的ID，这个ID在不同的环境中是不一样的。如果你在测试数据中硬编码了某个ID，比如第6行提到的配置文件ID，那么这个ID在生产环境中可能就不存在了。这会导致第8行的代码无法正确执行，因为它在尝试插入一个不存在的ID。为了避免这种情况，你应该避免在测试数据中使用硬编码的ID，而是使用动态的方式来获取或创建这些ID。 总结一下，确保静态资源可用和避免硬编码ID是确保测试数据正确创建的两个重要步骤。这样做可以帮助你避免在部署时遇到不必要的麻烦。希望这些信息对你们有帮助！

  ▶ 播放视频 查看详情
• 246

  Key Takeaways - 328

  第 328 页

  让我们来聊聊Salesforce测试中的一些关键要点。首先，测试代码时，可能会遇到一些副作用，比如影响代码覆盖率的计算。这时候，你可以通过重新运行测试来刷新这些计算结果，确保数据的准确性。 在计算代码覆盖率时，不是所有的代码都会被计入。比如，空白行和调试语句就不会影响你的代码覆盖率百分比。所以，即使你看到覆盖率不是100%，也不必过于担心，只要确保核心逻辑被充分测试即可。 要实现条件语句的100%覆盖率，你需要测试每一个可能的分支。这意味着，如果你的代码中有多个条件判断，每个条件都需要被测试到，这样才能确保代码的健壮性。 在编写测试数据时，尽量避免硬编码ID。硬编码ID可能会导致测试在不同环境中失败。相反，应该动态生成数据，这样测试会更加灵活和可靠。 为了全面测试你的代码，不仅要测试正常情况，还要测试各种异常情况和批量数据。这样可以确保你的代码在各种情况下都能正常工作。 System.runAs() 是一个非常有用的方法，它可以帮助你测试共享模型。通过这个方法，你可以模拟不同用户的权限，确保你的共享规则和权限设置是正确的。 最后，Test类中有一些方法可以帮助你划定测试方法中的新上下文边界。这对于测试调节器限制特别有用，可以确保你的代码在资源限制下也能正常运行。 总结一下，测试是确保代码质量的关键步骤。通过全面、细致的测试，你可以大大提高代码的可靠性和稳定性。希望这些要点能帮助你在Salesforce开发中更加得心应手！

  ▶ 播放视频 查看详情
• 247

  Module 13: Strategies for Designing Efficient Apex Solutions

  第 329 页

  今天我们来聊聊Salesforce中的Apex Solutions，特别是如何高效设计策略。Apex是Salesforce的一种编程语言，它允许我们创建复杂的业务逻辑和自定义功能。但是，要想高效地使用Apex，我们需要一些设计策略。 首先，我们要明白，Apex代码是在Salesforce的多租户环境中运行的，这意味着我们的代码需要高效，不能占用太多资源。所以，我们在设计Apex解决方案时，要考虑到性能优化。 一个重要的策略是尽量减少数据库操作。每次我们访问数据库，都会消耗资源。所以，我们应该尽量在一次操作中获取所有需要的数据，而不是多次访问数据库。这可以通过使用SOQL查询的批量处理来实现。 其次，我们要避免在循环中进行数据库操作。这会导致所谓的“SOQL查询在循环中”问题，它会显著降低性能。我们应该在循环外部获取数据，然后在循环内部处理这些数据。 另外，我们还要注意Apex的触发器设计。触发器是在数据库操作（如插入、更新、删除）前后自动执行的代码。为了保持触发器的效率，我们应该遵循“一个对象一个触发器”的最佳实践，这样可以避免触发器之间的冲突和性能问题。 最后，我们要确保我们的Apex代码是可维护的。这意味着我们要编写清晰的、有良好注释的代码，并且遵循Salesforce的最佳实践和编码标准。这样，不仅我们自己以后可以更容易地理解和修改代码，其他开发人员也能更容易地接手和维护。 总之，高效设计Apex解决方案的关键在于性能优化、避免不必要的数据库操作、合理设计触发器，以及编写可维护的代码。记住这些策略，你就能在Salesforce平台上创建出既强大又高效的Apex解决方案了。

  ▶ 播放视频 查看详情
• 248

  Apex Best Practices

  第 330 页

  让我们来聊聊Apex最佳实践，特别是如何编写易于维护和扩展的代码，以及如何避免常见的性能问题。 首先，编写易于维护和扩展的代码是非常重要的。这意味着你的代码应该清晰、简洁，并且有良好的注释。你可以通过使用有意义的变量名和方法名来做到这一点。此外，尽量遵循单一职责原则，即每个类或方法只做一件事。这样，当需求变化时，你可以更容易地修改或扩展代码，而不影响其他部分。 接下来，假设批量数据作为输入来编写触发器和类。这意味着你的代码应该能够处理大量数据，而不仅仅是单条记录。例如，在触发器中，你应该使用`Trigger.new`或`Trigger.old`来处理一组记录，而不是逐条处理。这样可以避免在大量数据时触发器的性能问题。 在查询和使用TLR（Transaction Log Records）时，与数据库高效配合使用代码也非常关键。你应该尽量减少数据库查询的次数，尽量在一次查询中获取所有需要的数据。使用`SOQL`查询时，尽量避免在循环中执行查询，这样可以减少数据库的负载，提高性能。 现在，关于你提到的遗留触发器失败和限制问题，我们可以从以下几个方面来修复： 1. ，优化查询，：检查触发器中的查询，确保它们是最优的。避免在循环中执行查询，尽量使用集合和映射来减少查询次数。 2. ，批量处理，：确保触发器能够处理批量数据。使用`Trigger.new`来处理一组记录，而不是逐条处理。 3. ，测试案例，：确保你的测试案例覆盖了各种场景，包括批量数据和边界情况。这样可以帮助你发现潜在的问题。 4. ，监控限制，：使用`System.debug`或`Limits`类来监控代码中的限制使用情况。这样可以帮助你识别哪些部分代码消耗了过多的资源。 5. ，代码重构，：如果可能，重构遗留代码，使其更符合最佳实践。这可能包括拆分大型触发器为多个小型触发器，或者将业务逻辑移到辅助类中。 通过这些步骤，你可以逐步修复遗留触发器的问题，并确保你的代码更高效、更易于维护。希望这些建议对你有所帮助！

  ▶ 播放视频 查看详情
• 249

  Module Agenda - 331

  第 331 页

  同学们，今天我们来聊聊Salesforce中的Apex编程，特别是如何设计高效的Apex解决方案。这个模块的内容非常实用，可以帮助你们在Salesforce开发中更加得心应手。 首先，我们要讲的是，高效使用数据库，。在Salesforce中，数据库操作是非常频繁的，所以如何高效地使用数据库就显得尤为重要。我们要学会使用SOQL和SOSL查询语言，尽量减少查询次数，避免在循环中进行查询，这样可以大大减少数据库的负载。 接下来是，设计触发器，。触发器是Salesforce中非常强大的工具，可以在记录插入、更新或删除时自动执行一些操作。但是，触发器如果设计不当，可能会导致性能问题。所以，我们要确保触发器中的逻辑简洁高效，避免在触发器中执行复杂的操作，尽量把复杂的逻辑放到Apex类中处理。 最后，我们要讲的是，设计课程，。这里的“课程”其实是指如何系统地学习和掌握Apex编程。我们要从基础开始，逐步深入，理解Apex的核心概念，比如类、对象、方法等。然后通过实际的项目来巩固这些知识，这样才能真正掌握Apex编程。 总结一下，今天的内容主要是围绕如何设计高效的Apex解决方案展开的。我们讨论了高效使用数据库、设计触发器以及如何系统地学习Apex编程。希望这些内容对你们有所帮助，能够在实际开发中派上用场。 好了，今天的课程就到这里，大家有什么问题可以随时提问。谢谢！

  ▶ 播放视频 查看详情
• 250

  Key Query Limits

  第 332 页

  同学们，今天我们来聊聊Salesforce中的SOQL查询限制，特别是关于堆大小和事务内存使用的问题。 首先，SOQL是Salesforce Object Query Language的缩写，它是用来从Salesforce数据库中检索数据的。但是，Salesforce对SOQL查询有一些限制，主要是为了防止资源过度使用，保证系统的稳定性和性能。 ，堆大小限制，：每次事务执行时，Salesforce都会分配一定量的内存，这就是所谓的堆大小。如果SOQL查询返回的数据量太大，或者你在一个事务中执行了太多的查询，就可能会超出这个堆大小的限制，导致错误。 ，事务内存使用，：每个事务在执行时，都会消耗一定的内存。如果你在一个事务中执行了多个SOQL查询，或者查询返回了大量的数据，这都会增加内存的使用量。如果超出了Salesforce设定的限制，事务就会失败。 ，讨论这些限制的含义，：这些限制意味着我们在编写代码时，必须非常小心。我们需要确保我们的SOQL查询是高效的，避免不必要的数据检索，特别是在循环中执行SOQL查询，这会导致每次循环都执行一次查询，极大地增加了内存的使用。 ，下一张幻灯片将回顾不良代码和解决方案，：接下来，我们会看一些常见的错误代码示例，以及如何优化这些代码来避免超出Salesforce的限制。我们会学习如何重构代码，比如将SOQL查询移出循环，或者使用批量处理来减少查询次数。 记住，理解并遵守这些限制，不仅能帮助我们避免错误，还能提高我们应用的整体性能和用户体验。希望大家在编写代码时，都能时刻注意这些要点。

  ▶ 播放视频 查看详情
• 251

  Anti-Pattern: Querying within a Loop

  第 333 页

  同学们，今天我们来聊聊一个在Salesforce开发中非常常见但需要特别注意的问题——在循环内进行查询。这个做法被称为“反模式”，也就是说，它是一种不太好的编程习惯，可能会导致你的代码出现问题。 首先，让我们看看这段代码。这段代码的目的是在循环中查询每个课程参与者的信息，并收集他们的电子邮件地址。看起来好像没什么问题，对吧？但实际上，这里有一个很大的隐患。 问题出在循环内的查询。每次循环执行时，都会触发一次数据库查询。想象一下，如果你有100个课程参与者，那么这段代码就会执行100次查询！这听起来可能不多，但在Salesforce中，每次查询都会消耗一定的资源。Salesforce对每次执行的代码都有严格的资源限制，称为“Apex调控器限制”。这些限制包括查询次数、查询返回的行数、执行时间等。 如果你在循环内进行查询，很容易就会超出这些限制。比如，Salesforce规定每次执行最多只能进行100次查询。如果你的循环次数超过100次，代码就会因为超出查询限制而失败。这不仅会导致功能无法正常工作，还可能影响整个系统的性能。 所以，正确的做法是尽量避免在循环内进行查询。你可以考虑在循环外部一次性查询所有需要的数据，然后在循环中处理这些数据。这样，你只需要执行一次查询，大大减少了资源消耗，也避免了超出调控器限制的风险。 总结一下，记住这个关键点：在Salesforce开发中，尽量避免在循环内进行查询。这不仅能让你的代码更高效，还能避免很多潜在的问题。希望这个讲解对你们有帮助，下次写代码时一定要注意哦！

  ▶ 播放视频 查看详情
• 252

  Principle: Use Collections to Minimize the Number of Queries

  第 334 页

  同学们，今天我们来聊聊一个在Salesforce开发中非常重要的原则——使用集合来最大限度地减少查询数量。这个原则听起来可能有点复杂，但其实很简单，我们一步步来理解。 首先，想象一下，如果你每次需要数据时都去数据库里查询一次，那会非常耗时，对吧？特别是在循环中，如果每次循环都去查询一次，那效率就会非常低。这就是我们说的“循环中查询的反模式”。 那么，我们怎么解决这个问题呢？步骤#1就是排除SOQL查询。SOQL是Salesforce的查询语言，用来从数据库中获取数据。我们需要构造一个标准，看看有多少个SOQL查询是可以避免的。 这里的关键是使用集合。集合是什么呢？简单来说，集合就是一组数据的容器。我们可以先把需要的数据一次性查询出来，放到集合里，然后在循环中使用这个集合，而不是每次都去查询数据库。 举个例子，假设我们有一组客户记录，我们需要对每个客户进行一些操作。如果我们每次循环都去查询一次客户记录，那就会非常慢。但如果我们先把所有客户记录查询出来，放到一个集合里，然后在循环中使用这个集合，那就会快很多。 所以，同学们，记住这个原则：使用集合来最大限度地减少查询数量。这样不仅能提高代码的效率，还能减少对数据库的压力。希望这个解释对你们有帮助！

  ▶ 播放视频 查看详情
• 253

  Be Aware: Parent-Child Queries are Counted Differently

  第 335 页

  今天我们来聊聊Salesforce中的SOQL查询和它们的限额计数，特别是当涉及到父子关系的时候。首先，SOQL是Salesforce Object Query Language的缩写，它是用来从Salesforce数据库中检索数据的。 在Salesforce中，每次执行SOQL查询都会消耗一定的限额。这个限额是有限制的，所以我们需要非常注意如何编写我们的查询，以确保我们不会超出这个限额。 现在，让我们来看看两个关键点： 1. ，主SOQL查询，：每次执行一个主SOQL查询，它会计为100个查询限额中的1个。这意味着如果你执行了100个这样的查询，你就达到了你的限额。 2. ，嵌套SOQL查询，：当你有一个嵌套的SOQL查询，也就是在查询中包含子查询时，情况就有点不同了。每个嵌套的SOQL查询会计为300个查询限额中的1个。这是因为嵌套查询通常涉及更复杂的操作，比如处理父子关系，所以Salesforce给它们更高的限额。 这里有一个教学要点：包含子查询的查询可能会影响你的限额计数。这意味着如果你在查询中使用了子查询，特别是涉及到父子关系的子查询，你需要更加小心，因为这些查询会更快地消耗你的限额。 为了帮助你更好地理解这一点，我建议你查看Salesforce的官方文档和社区论坛。这些资源提供了关于SOQL查询限额的详细信息，包括如何处理父子关系查询以及如何优化你的查询以避免超出限额。 记住，合理使用SOQL查询，不仅可以提高你的应用性能，还可以避免不必要的限额消耗。希望这些信息对你有所帮助，如果你有任何问题，随时提问！

  ▶ 播放视频 查看详情
• 254

  Principle: Bring Back What You Need in a Single Query

  第 336 页

  同学们，今天我们来聊聊Salesforce中的一个重要原则——在一次查询中带回你需要的内容。这个原则听起来简单，但实际操作中却非常关键。 想象一下，你去超市买东西。如果你每次只买一样东西，然后回家，再去买另一样，这样来回跑不仅浪费时间，还消耗精力。同样地，在Salesforce中，如果你每次只查询一小部分数据，然后再去查询更多，这样不仅效率低下，还可能影响系统的性能。 所以，我们的目标是：在一次查询中，尽可能多地收集你需要的所有数据。这就是我们说的“不要再回去拿更多了”。 具体怎么做呢？首先，你需要明确你需要哪些数据。然后，在你的SOQL查询中，直接从相关的sObject中引入这些字段。这样，你就能在一次查询中获取所有必要的信息，而不需要多次往返数据库。 举个例子，如果你需要客户的姓名、地址和最近的订单信息，你应该在一个查询中同时获取这些数据，而不是分别查询姓名、地址和订单。 记住，优化你的查询不仅能提高效率，还能让你的应用运行得更顺畅。所以，下次写查询时，记得这个原则：一次查询，带回所有你需要的内容。 好了，这就是今天的内容。希望你们能理解并应用这个原则，让你们的Salesforce开发更加高效。如果有任何问题，随时提问！

  ▶ 播放视频 查看详情
• 255

  Principle: Reducing the Data Set

  第 337 页

  同学们，今天我们来聊聊如何在Salesforce中优化我们的触发器（Trigger），特别是如何通过减少数据集来提高效率。想象一下，你有一个大箱子，里面装满了各种颜色的球，但你只需要红色的球。如果你把整个箱子都倒出来找红色的球，那会非常耗时。所以，我们得想办法只拿出红色的球，这样效率就高多了。 在我们的Salesforce触发器里，情况也类似。假设我们有一个触发器，它会在每次有200条记录被更新时触发。但是，我们真正关心的可能只有其中的20条记录。如果我们不加以筛选，直接处理这200条记录，那就会浪费很多资源。 那么，我们怎么做到只处理我们关心的那20条记录呢？这里就需要用到过滤器了。我们可以设置一个条件，比如只处理那些状态没有改变的记录。在Salesforce中，我们可以使用`Trigger.oldMap`来获取更新前的记录状态，然后与更新后的状态进行比较。如果状态没有改变，我们就可以跳过这些记录，不对它们进行SOQL查询，这样就大大减少了不必要的数据处理。 总结一下，我们的目标是通过添加过滤器，只带回我们需要的数据，就像只从箱子里拿出红色的球一样。这样做不仅能提高触发器的执行效率，还能减少系统的负担。希望这个比喻能帮助大家更好地理解这个概念。如果有任何疑问，随时提问哦！

  ▶ 播放视频 查看详情
• 256

  Principle: Use SOQL For Loops to Reduce Heap Size

  第 338 页

  今天我们来聊聊SOQL For Loops，这是一个非常实用的工具，可以帮助我们更有效地处理Salesforce中的数据。 首先，SOQL For Loops是一种特殊的循环方式，它允许我们分批处理从SOQL查询中返回的大量记录。这样做的好处是可以减少内存的使用，也就是我们常说的“堆大小”。在Salesforce中，堆大小是有限的，所以我们需要尽可能地优化我们的代码，以避免超出这个限制。 使用SOQL For Loops时，Salesforce会自动将查询结果分成较小的批次，通常是200条记录一批。这样，我们就可以在每次循环中只处理一小部分数据，而不是一次性加载所有数据到内存中。这种方法特别适合处理大量数据，因为它可以显著减少内存的消耗。 举个例子，假设我们有一个查询返回了1000条记录。如果我们不使用SOQL For Loops，而是直接将这1000条记录加载到内存中，那么堆大小会迅速增加。但是，如果我们使用SOQL For Loops，Salesforce会将这些记录分成5个批次，每批200条。这样，每次循环我们只需要处理200条记录，大大减少了内存的使用。 总结一下，SOQL For Loops是处理大量数据时的好帮手。它通过分批处理数据，帮助我们有效地管理堆大小，避免内存溢出的问题。希望这个简单的解释能帮助你更好地理解和使用SOQL For Loops。

  ▶ 播放视频 查看详情
• 257

  Tip for Improving SOQL Performance

  第 339 页

  今天我们来聊聊如何提高SOQL查询的性能。虽然我们不会深入探讨所有细节，但有几个关键点可以帮助你优化查询。 首先，，滤波器，的使用非常重要。在SOQL查询中，尽量使用那些已经被索引的字段作为过滤条件。索引字段就像是书的目录，能快速帮你找到需要的信息，而不是一页一页地翻。比如，使用`CreatedDate`或`Id`这样的字段，通常比使用非索引的字符串或整数字段要快得多。 其次，，外部Id，也是一个很好的选择。如果你在查询中使用了外部Id字段，Salesforce会自动为这些字段创建索引，这样查询速度会更快。外部Id通常用于集成场景，比如从外部系统导入数据时使用。 最后，如果你想了解更多关于哪些字段是默认被索引的，可以参考Salesforce的官方文档。文档中列出了哪些字段类型会自动被索引，比如`CreatedDate`、`LastModifiedDate`、`Id`等。 总结一下，优化SOQL查询的关键在于选择合适的过滤条件，尽量使用索引字段或外部Id，这样可以大大提高查询效率。希望这些小技巧对你有帮助！

  ▶ 播放视频 查看详情
• 258

  13-1: Refactor a Trigger to Avoid SOQL Limits

  第 340 页

  同学们，今天我们来聊聊如何重构Salesforce中的触发器，以避免SOQL查询限制的问题。首先，我们需要理解什么是SOQL查询限制。在Salesforce中，每个事务（比如保存一条记录）最多只能执行100次SOQL查询。如果超过了这个限制，系统就会抛出“SOQL查询太多”的错误。 现在，假设我们有一个触发器，它会在课程记录被插入或更新时执行一些操作。这个触发器可能会在每次记录操作时执行一个SOQL查询，来获取相关的数据。如果我们一次性插入或更新多条记录，这个触发器就会为每条记录执行一次SOQL查询，这样很容易就会超过100次的限制。 为了避免这种情况，我们需要重构我们的触发器。重构的关键在于减少SOQL查询的次数。我们可以通过以下几种方式来实现： 1. ，批量处理，：确保触发器能够处理一组记录，而不是单个记录。这样，我们就可以在触发器外部收集所有需要的数据，然后一次性执行SOQL查询。 2. ，使用集合，：在触发器中，使用集合（如Set或Map）来存储和处理数据，这样可以减少重复的SOQL查询。 3. ，优化查询，：尽量编写高效的SOQL查询，避免不必要的字段和条件，减少查询的复杂度。 4. ，使用静态变量，：如果某些数据在事务中是静态的，可以使用静态变量来存储这些数据，避免重复查询。 接下来，我们可以在Salesforce用户界面中测试这个触发器，确保它在处理单个记录时工作正常。然后，我们需要编写单元测试代码，用多个记录来测试触发器，确保它在批量操作时也不会超过SOQL查询限制。 最后，根据测试结果，我们可能需要进一步调整和优化触发器的代码，确保它在各种情况下都能高效运行，不会触发SOQL查询限制。 这就是我们今天的内容，希望大家能够理解并掌握如何重构触发器以避免SOQL查询限制。如果有任何问题，欢迎随时提问。

  ▶ 播放视频 查看详情
• 259

  Key DML Limits

  第 341 页

  同学们，今天我们来聊聊Salesforce中的一些关键限制，特别是关于TLR（Transaction Log Replay）的限制。这些限制对于确保系统的稳定性和性能非常重要。 首先，我们来看第一个限制：，已发布的TLR声明总数，。这个限制指的是在Salesforce中，你可以发布的TLR声明的最大数量。TLR声明是用来记录事务的，所以这个限制实际上是在控制你可以记录多少事务。如果超过了这个限制，系统可能会拒绝新的TLR声明，导致一些事务无法被记录。 接下来是第二个限制：，由于TLR声明而处理的记录总数，。这个限制关注的是由于TLR声明而被处理的记录数量。也就是说，每次TLR声明可能会涉及到多个记录的更新或创建。这个限制是为了防止单个TLR声明处理过多的记录，从而避免系统资源的过度消耗。 最后，我们来看第三个限制：，总堆大小，。堆大小是指Salesforce在执行事务时使用的内存大小。这个限制是为了防止单个事务占用过多的内存，从而影响其他事务的执行。如果堆大小超过了限制，系统可能会抛出异常，导致事务失败。 总结一下，这三个限制都是为了保护Salesforce系统的稳定性和性能。它们分别控制了TLR声明的数量、每个TLR声明处理的记录数量以及事务使用的内存大小。理解这些限制有助于我们在开发和管理Salesforce应用时，避免超出系统的承载能力。 下一张幻灯片，我们将进一步检查这些限制的具体数值和如何在实际应用中应对这些限制。希望大家能跟上节奏，有任何问题随时提问！

  ▶ 播放视频 查看详情
• 260

  Anti-Pattern: DML statements

  第 342 页

  让我们来聊聊Salesforce中的反模式，特别是关于TLR（Trigger Logic Reuse）声明的问题。 首先，什么是TLR声明呢？简单来说，TLR声明是一种在触发器中使用的方法，目的是为了重用逻辑代码。听起来不错，对吧？但是，如果在循环中进行ADL（Apex Data Loader）操作，你的代码可能会遇到一些严重的问题。 想象一下，你有一个触发器，它在每次记录更新时都会执行一些逻辑。如果你在循环中对每个记录都执行TLR声明，那么每次循环都会触发一次完整的逻辑执行。这不仅效率低下，而且你的代码可能会很快达到Apex管理器的限制。 Apex管理器有一些严格的限制，比如每个事务中最多只能执行100个SOQL查询，或者最多只能执行10,000条DML语句。如果你的代码在循环中频繁执行TLR声明，很容易就会超过这些限制，导致代码失败。 所以，为了避免这种情况，我们应该尽量避免在循环中进行TLR声明。相反，可以考虑在循环外部执行一次TLR声明，然后在循环内部只处理必要的逻辑。这样不仅可以提高代码的效率，还能避免达到Apex管理器的限制。 总结一下，TLR声明虽然有用，但在循环中使用时要特别小心。记住，好的代码不仅要功能正确，还要高效且符合平台的最佳实践。希望这个解释对你有帮助！

  ▶ 播放视频 查看详情
• 261

  Principle: Batch Data for DML Statements

  第 343 页

  让我们来聊聊TLR陈述的批数据处理要点。首先，我们要明白，处理大量数据时，效率是关键。这里，我们使用集合（Set）来帮助我们提高效率。 ，步骤#1：排除因素， 在处理TLR（假设这是一个特定的数据记录类型）时，我们首先需要排除那些不需要处理的记录。这就像你在整理收件箱时，先过滤掉那些垃圾邮件一样。通过排除这些因素，我们可以减少需要处理的数据量，从而提高效率。 ，集合的使用， 集合在这里起到了非常重要的作用。集合是一种数据结构，它不允许有重复的元素。这意味着，当我们把TLR记录放入一个集合中时，任何重复的记录都会被自动排除。这样，我们就避免了多次处理相同的TLR陈述，从而节省了时间和资源。 ，教学要点， 使用集合不仅简化了数据处理流程，还显著提高了效率。特别是在处理像收件箱记录这样的数据时，集合帮助我们避免了重复处理，确保每一条记录只被处理一次。这种方法不仅节省了时间，还减少了出错的可能性。 总结一下，通过使用集合来排除重复的TLR陈述，我们可以更高效地处理批数据，确保每一条记录都得到适当的处理，而不会浪费资源在重复的任务上。希望这个解释能帮助你更好地理解TLR批数据处理的要点！

  ▶ 播放视频 查看详情
• 262

  Principle: Use SOQL For Loops to Make Batches of 200

  第 344 页

  让我们来聊聊如何在Salesforce中使用SOQL For Loops来批量处理数据，特别是当我们需要创建大量记录时，比如200条记录。这个方法不仅高效，还能帮助我们减少堆大小，避免系统资源的过度消耗。 首先，SOQL For Loops是什么？简单来说，它是一种在Apex中处理大量数据的有效方式。当你执行一个SOQL查询时，如果返回的结果集非常大，直接处理可能会导致堆大小超出限制。SOQL For Loops通过分批处理数据来解决这个问题。 现在，假设我们需要创建200条记录。如果我们一次性处理所有数据，可能会遇到性能问题。但是，如果我们使用SOQL For Loops，就可以将这些记录分成更小的批次来处理，比如每次处理20条记录。这样做的好处是，每次只处理一小部分数据，堆大小就会保持在较低水平，从而避免系统资源的过度消耗。 具体来说，你可以这样写代码： ```apex for (List records : [SELECT Id, Name FROM YourObject__c LIMIT 200]) { // 在这里处理每一批记录 // 比如，创建新的记录 List newRecords = new List(); for (YourObject__c record : records) { YourObject__c newRecord = new YourObject__c(); newRecord.Name = record.Name + &#39; - Copy&#39;; newRecords.add(newRecord); } insert newRecords; } ``` 在这个例子中，我们首先查询了最多200条记录，然后使用SOQL For Loops来分批处理这些记录。每次循环中，我们只处理一小部分记录，这样就有效地减少了堆大小。 总结一下，SOQL For Loops是一个非常强大的工具，特别是在处理大量数据时。它不仅能帮助我们高效地处理数据，还能避免系统资源的过度消耗。所以，下次当你需要处理大量数据时，记得使用SOQL For Loops，让你的代码更加高效和可靠。

  ▶ 播放视频 查看详情
• 263

  13-2: Refactor a Trigger to Avoid DML Limits

  第 345 页

  同学们，今天我们来聊聊如何重构Salesforce中的触发器，以避免“TLR行太多”的错误。这个错误通常发生在触发器处理大量记录时，超出了Salesforce对触发器执行行数的限制。我们的目标是让触发器更高效，同时确保它在处理多个记录时依然能够正常工作。 首先，我们需要检查当前的课程触发器。打开你的开发环境，找到那个触发器，看看它的代码结构。通常，触发器会包含一些逻辑来处理插入、更新或删除操作。我们需要确保这些逻辑是简洁且高效的。 接下来，我们要重构代码。重构的目的是减少触发器中的行数，同时保持其功能不变。我们可以通过以下几种方式来实现： 1. ，将逻辑移到Apex类中，：触发器中的复杂逻辑可以移到Apex类中。这样不仅减少了触发器的行数，还使得代码更易于维护和测试。 2. ，使用批量处理，：确保触发器能够处理批量记录，而不是逐条处理。这样可以减少触发器的执行次数，从而避免TLR错误。 3. ，优化查询和DML操作，：尽量减少在触发器中的查询和DML操作次数。可以通过合并查询或使用集合来优化这些操作。 重构完成后，我们需要进行单元测试。编写测试代码时，确保使用多个记录来测试触发器。这样可以模拟真实场景，确保触发器在处理大量数据时不会出错。 最后，运行你的测试代码，检查触发器是否能够正确处理多个记录，并且没有出现“TLR行太多”的错误。如果一切正常，恭喜你，你已经成功重构了触发器！ 记住，重构是一个持续的过程。随着业务需求的变化，你可能需要不断地优化和调整你的代码。保持代码的简洁和高效，是每个开发者的责任。 好了，今天的课程就到这里。希望你们能够掌握如何重构触发器以避免TLR限制。如果有任何问题，随时提问。下次见！

  ▶ 播放视频 查看详情
• 264

  Module Agenda - 346

  第 346 页

  同学们，今天我们来聊聊如何在Salesforce中设计高效的Apex解决方案。这个模块的内容非常实用，尤其是当你需要处理大量数据时，掌握这些策略会让你的工作事半功倍。 ### 1. 高效使用数据库 首先，我们要学会如何高效地使用数据库。在Salesforce中，数据库操作是非常常见的，但如果不注意，很容易导致性能问题。这里有几个小技巧： - ，批量处理，：尽量使用批量处理，而不是逐条处理数据。这样可以减少数据库的调用次数，提高效率。 - ，选择性查询，：在查询时，尽量只选择你需要的字段，避免使用`SELECT *`。这样可以减少数据传输量，提高查询速度。 - ，索引优化，：确保你的查询条件使用了索引字段，这样可以加快查询速度。 ### 2. 设计触发器 接下来，我们来看看如何设计触发器。触发器是Apex中非常强大的工具，但如果不小心使用，可能会导致性能问题。这里有几个设计触发器的要点： - ，避免递归触发，：确保触发器不会无限递归调用自己。可以通过使用静态变量来控制触发器的执行次数。 - ，批量处理，：触发器应该能够处理批量数据，而不是只处理单条记录。这样可以提高触发器的效率。 - ，逻辑分离，：尽量将复杂的逻辑放在Apex类中，而不是直接写在触发器里。这样可以提高代码的可维护性和可测试性。 ### 3. 设计课程 最后，我们来谈谈如何设计课程。这里的“课程”指的是你在Salesforce中设计的业务流程或逻辑。设计课程时，要注意以下几点： - ，模块化设计，：将复杂的业务流程分解成多个小模块，每个模块负责一个特定的功能。这样可以提高代码的可读性和可维护性。 - ，重用性，：尽量设计可重用的代码，避免重复造轮子。可以通过创建通用的Apex类或方法来实现。 - ，测试驱动开发，：在设计课程时，先编写测试用例，然后再编写代码。这样可以确保你的代码符合预期，并且易于调试。 好了，今天的课程就到这里。希望大家能够掌握这些设计高效Apex解决方案的策略，并在实际工作中灵活运用。如果有任何问题，随时提问哦！

  ▶ 播放视频 查看详情
• 265

  Multiple Triggers on the Same Object

  第 347 页

  同学们，今天我们来聊聊Salesforce中一个比较有趣但又有点棘手的话题——同一对象上的多个触发器。这个话题听起来可能有点技术性，但我会尽量用简单的话来解释，让大家都能明白。 首先，我们来说说优点。其实，同一对象上的多个触发器并没有太多优点，更多的是缺点。但有一点可以提一下，那就是你不需要使用所谓的“交通警察模式”。这意味着你不需要特别安排触发器的执行顺序，它们可以相对自由地运行。此外，你还可以将触发器的逻辑分成“之前”和“之后”两部分，这样可以让代码更有条理。 但是，缺点就比较多了。首先，最大的问题是，当你有多个触发器作用在同一个对象上时，Salesforce无法保证哪个触发器会先执行。这就好像你去参加一个派对，但没有人告诉你什么时候该跳舞，什么时候该吃饭，结果可能会很混乱。这种不确定性使得调试变得非常困难，因为你不知道哪个触发器导致了问题。 其次，所有的触发器都共享同一组资源。这意味着如果多个触发器都在做类似的事情，比如查询数据库，那么它们可能会重复执行相同的查询，这不仅浪费资源，还可能导致你超出Salesforce的州长限制。州长限制是Salesforce为了防止系统过载而设置的一些规则，比如你一天内只能执行一定数量的数据库查询。如果你不小心超出了这些限制，你的应用可能会被暂时禁用。 所以，同学们，虽然多个触发器听起来很方便，但实际上它们可能会带来很多麻烦。在设计你的Salesforce应用时，最好尽量减少同一对象上的触发器数量，或者使用其他方法来组织你的代码，比如使用“触发器框架”来更好地管理和控制触发器的执行。 好了，今天的内容就到这里。希望你们能理解同一对象上多个触发器的优缺点，并在实际开发中做出明智的选择。如果有任何问题，随时问我哦！

  ▶ 播放视频 查看详情
• 266

  Principle: One Trigger Per Object

  第 348 页

  大家好，今天我们来聊聊Salesforce中的一个重要原则——每个对象一个触发器。这个原则听起来可能有点技术性，但其实很简单，就是建议我们在Salesforce中，每个对象只使用一个触发器。这样做的好处是，它可以帮助我们保持代码的整洁和易于管理。 首先，让我们理解一下为什么会有这样的建议。想象一下，如果你有多个触发器在同一个对象上运行，那么当这个对象的数据发生变化时，所有的触发器都会被触发。这可能会导致一些意想不到的结果，比如触发器之间的冲突，或者性能问题。所以，使用一个触发器可以避免这些问题，使得我们的系统更加稳定和高效。 但是，这里有一个例外，那就是当你使用第三方托管包时。这些包可能已经包含了它们自己的触发器，这时候你可能需要调整你的策略。 接下来，我们来看看触发器的基础设置。一个常见的决策点是，触发器是否应该列出所有可能的上下文。这样做的好处是，它使得触发器更容易扩展，因为你可以很容易地添加新的逻辑。同时，这也可能鼓励开发者不要为每个小功能都写一个新的触发器。但是，这也意味着触发器在每种情况下都会被触发，这可能会带来一些额外的负担。 另一个决策点是，我们应该使用什么形式的条件语句。使用单一的方法调用来处理After/Insert和After/Update事件，可以让代码看起来更加简洁。但是，如果你需要为不同的上下文添加新的业务逻辑，比如只针对After/Insert事件，那么你可能需要重新组织或重复一些条件语句。 总的来说，每个对象一个触发器的原则是为了帮助我们更好地管理和维护Salesforce中的触发器。虽然在某些情况下可能需要做出一些妥协，但遵循这个原则通常会让我们的工作更加高效和有序。希望这些信息对你们有所帮助，谢谢大家的聆听！

  ▶ 播放视频 查看详情
• 267

  Example of Conditional Pattern for Easy Modification

  第 349 页

  今天我们来聊聊Salesforce中的触发器（Trigger）设计模式，特别是关于如何让我们的代码更易于修改和扩展。 首先，想象一下你在写一个触发器，这个触发器会在记录插入或更新时执行一些操作。你可能会写出这样的代码： ```apex if (Trigger.isBefore &amp;&amp; Trigger.isInsert) { // 在记录插入之前做一些事情 } else if (Trigger.isAfter &amp;&amp; Trigger.isInsert) { // 在记录插入之后做一些事情 } else if (Trigger.isBefore &amp;&amp; Trigger.isUpdate) { // 在记录更新之前做一些事情 } else if (Trigger.isAfter &amp;&amp; Trigger.isUpdate) { // 在记录更新之后做一些事情 } ``` 这种写法看起来挺直观的，对吧？每个条件分支都对应一个特定的触发器事件组合。但是，如果你以后需要添加新的功能，比如在记录插入之后做一些额外的事情，你会发现你只需要在`After/Insert`的分支中添加代码，而不需要改动其他部分。这就是所谓的“易于扩展”。 但是，如果你需要在`Before/Insert`上添加新的业务逻辑，你可能就需要修改现有的条件分支了。这可能会导致代码变得复杂，难以维护。 那么，有没有更好的方法呢？专家们建议，我们可以预先为所有可能的触发器事件组合都写好分支，即使有些分支暂时是空的。这样做的好处是： 1. ，可重复使用性和通用性，：所有的触发器事件都被覆盖了，代码更加通用，可以在不同的场景下重复使用。 2. ，易于修改，：当你需要添加新功能时，你只需要在相应的分支中添加代码，而不需要改动现有的条件逻辑。这样，你的代码结构会更加稳定，修改起来也更加轻松。 举个例子，你可以这样写： ```apex if (Trigger.isBefore &amp;&amp; Trigger.isInsert) { // 在记录插入之前做一些事情 } else if (Trigger.isAfter &amp;&amp; Trigger.isInsert) { // 在记录插入之后做一些事情 } else if (Trigger.isBefore &amp;&amp; Trigger.isUpdate) { // 在记录更新之前做一些事情 } else if (Trigger.isAfter &amp;&amp; Trigger.isUpdate) { // 在记录更新之后做一些事情 } else if (Trigger.isBefore &amp;&amp; Trigger.isDelete) { // 在记录删除之前做一些事情 } else if (Trigger.isAfter &amp;&amp; Trigger.isDelete) { // 在记录删除之后做一些事情 } ``` 这样，无论你以后需要添加什么新的业务逻辑，你都可以在相应的分支中添加代码，而不需要改动现有的条件结构。这就是为什么这种模式被称为“易于修改”的原因。 总结一下，预先为所有可能的触发器事件组合写好分支，不仅能让你的代码更加通用和可重复使用，还能让你在添加新功能时更加轻松，不需要担心破坏现有的代码结构。希望这个讲解对你有帮助！

  ▶ 播放视频 查看详情
• 268

  How Should You Modularize Your Code?

  第 350 页

  让我们来聊聊如何在Salesforce中模块化你的代码。首先，想象一下，如果你的触发器里塞满了各种商业逻辑，那就像是在一个房间里堆满了各种家具，想要找到一件特定的东西会非常困难，对吧？这就是为什么我们要模块化代码。 ，模块化代码的好处，： 1. ，易于测试，：当你把代码分成小块，每块只负责一个功能，测试起来就简单多了。你可以单独测试每一块，确保它们都工作正常。 2. ，易于理解和维护，：模块化的代码就像是一本分章节的书，每章都有明确的主题，这样你或其他人以后想要修改或扩展代码时，就能快速找到需要改动的部分。 3. ，易于扩展，：如果你的业务需求变了，或者需要添加新的功能，模块化的代码结构让你可以轻松地添加新的模块，而不需要重写整个代码。 4. ，权限控制，：模块化还可以帮助你更好地控制用户的权限。你可以为每个模块设置不同的权限，确保只有有权限的用户才能执行特定的操作。 ，如何实现模块化，： - ，使用Apex类和方法，：将相关的商业逻辑封装在Apex类的方法中。这样，你的触发器只需要调用这些方法，而不是直接包含逻辑。 - ，使用接口和抽象类，：这可以帮助你定义通用的行为，让不同的类实现这些行为，从而提高代码的复用性和灵活性。 - ，分离关注点，：确保每个类或方法只负责一件事。比如，一个类处理数据验证，另一个类处理数据保存。 ，避免的问题，： - ，触发器中的商业逻辑，：这会让触发器变得复杂，难以管理和测试。把逻辑移到类中，让触发器只负责调用。 - ，难以阅读和维护的代码，：模块化可以让代码结构清晰，易于理解和维护。 - ，难以扩展，：模块化的设计让你可以轻松添加新功能，而不影响现有代码。 总之，模块化你的Salesforce代码，就像整理你的房间，让每样东西都有其固定的位置，这样无论是使用还是维护，都会变得更加高效和愉快。希望这些建议能帮助你在Salesforce开发中更加得心应手！

  ▶ 播放视频 查看详情
• 269

  Principle: Keep Business Logic Out of Your Trigger

  第 351 页

  同学们，今天我们来聊聊Salesforce开发中的一个重要原则：让商业逻辑远离触发器。这个原则听起来可能有点抽象，但别担心，我会用简单的例子来解释。 首先，想象一下交通警察。他们的工作是确保交通顺畅，而不是去修路或者设计交通信号灯。同样，在Salesforce中，触发器的主要职责是响应数据的变化，比如当一条记录被插入、更新或删除时。触发器的任务就是“指挥交通”，而不是去处理复杂的商业逻辑。 为什么这么说呢？因为如果我们在触发器里塞满了商业逻辑，就像让交通警察去修路一样，事情会变得非常混乱。触发器会变得难以维护和调试，尤其是当你有多个触发器时，问题会变得更加复杂。 所以，很多中小企业都建议，尽量把商业逻辑从触发器中剥离出来。你可以把商业逻辑放在其他地方，比如Apex类或者服务层。这样，触发器就只负责响应数据变化，而商业逻辑则由专门的类来处理。这样做的好处是，代码更清晰，更容易维护，也更容易调试。 举个例子，假设你有一个触发器，在插入记录时调用一个方法`grantDirectorSharingAccess`。如果触发器是在插入操作时触发的，那么`Trigger.oldMap`会是空的，因为没有旧的记录。如果你不小心，可能会把空值传递给这个方法，导致错误。所以，我们需要确保在调用方法之前，检查一下`Trigger.oldMap`是否为空。 总结一下，让商业逻辑远离触发器，就像让交通警察专注于指挥交通一样，可以让你的代码更清晰、更易于维护。你可以参考一些高级的触发器模式，比如我们刚才提到的那些链接，或者阅读Dan Appleman的《高级Apex编程》，来进一步了解如何更好地组织你的代码。 好了，今天的课程就到这里，希望你们能理解这个原则，并在实际开发中应用它。如果有任何问题，随时问我！

  ▶ 播放视频 查看详情
• 270

  Should You Explicitly Pass Trigger Context Data?

  第 352 页

  让我们来聊聊Salesforce中的触发器和上下文数据传递的问题。首先，想象一下触发器就像是一个小助手，它在数据库中的某些操作发生时自动跳出来帮忙。比如，当你添加或修改一条记录时，这个助手就会开始工作。 现在，问题来了：这个助手需要知道它是在什么样的环境下工作的，对吧？这就是所谓的“上下文数据”。有时候，我们需要明确地告诉助手这些信息，有时候则不需要。这就像是你去一个朋友家，有时候你需要告诉他们你带了什么，有时候则不需要，因为他们已经知道了。 Ryan，这里提到的一个人物，他会告诉你你的组织选择了哪种方式。这就像是在说，每个家庭（组织）都有自己的规矩，Ryan就是那个告诉你规矩的人。 在不同的类中重用方法，这就像是你有一个工具箱，里面的工具可以在不同的项目中使用。如果你能让这些工具在不同的情况下都能工作，那么你的工作就会更高效。这就是为什么有时候我们选择不传递具体的值，而是让方法自己去“感知”它需要的信息。 隐性使用需要选角，这听起来有点复杂，但其实很简单。就像是在电影中，有时候演员需要扮演不同的角色，但他们不需要每次都重新学习如何表演。他们只需要根据剧本（上下文）来调整自己的表演。 最后，记住，这只是一个讨论的幻灯片。每个人都有自己的看法，但重要的是，学生们应该知道他们不必总是传递具体的值。有时候，让方法自己去“感知”环境，会让代码更加灵活和可重用。 所以，总结一下，是否传递触发上下文数据，取决于你的组织和你想要达到的目标。有时候传递是必要的，有时候则不是。关键是找到最适合你情况的方法。

  ▶ 播放视频 查看详情
• 271

  Module Agenda - 353

  第 353 页

  同学们，今天我们来聊聊如何在Salesforce中设计高效的Apex解决方案。这个模块的内容非常实用，尤其是当你需要处理大量数据时，掌握这些策略会让你的工作事半功倍。 首先，我们来看，高效使用数据库，。在Salesforce中，数据库操作是非常关键的。每次你查询或更新数据时，都会消耗一定的资源。所以，我们要尽量减少不必要的数据库操作。比如，尽量避免在循环中进行查询或更新操作，因为这样会导致多次访问数据库，效率很低。相反，你可以先把数据批量查询出来，然后在内存中进行处理，最后再批量更新回去。这样不仅能减少数据库的访问次数，还能提高整体的性能。 接下来是，设计触发器，。触发器是Apex中非常强大的工具，但如果不小心使用，可能会导致性能问题。一个好的做法是，尽量让触发器保持简洁，专注于单一职责。比如，一个触发器只处理一种类型的操作（如插入、更新或删除），并且尽量避免在触发器中写复杂的业务逻辑。你可以把这些逻辑放到辅助类中，这样不仅能让触发器更清晰，还能方便以后的维护和测试。 最后，我们谈谈，设计课程，。这里的“课程”其实是指你如何组织和规划你的Apex代码。一个好的设计模式是，把代码分成不同的层次，比如数据访问层、业务逻辑层和用户界面层。这样可以让你的代码更加模块化，易于维护和扩展。另外，记得多使用注释和文档，这样不仅你自己以后能看懂，别人接手你的代码时也能快速理解。 总结一下，设计高效的Apex解决方案，关键在于，减少数据库操作，、，合理设计触发器，和，模块化代码结构，。掌握了这些策略，你就能在Salesforce开发中游刃有余了。 好了，今天的课程就到这里，希望大家能把这些技巧应用到实际项目中。如果有任何问题，随时问我！

  ▶ 播放视频 查看详情
• 272

  Principle: Modularize Business Logic

  第 354 页

  让我们来聊聊业务逻辑模块化的一个重要原则——OOP（面向对象编程）实践。这个原则听起来可能有点技术性，但其实很简单，就是让我们的代码更加清晰、易于管理和重用。 首先，我们来说说“如果不需要实例，静态会有所帮助”。在编程中，有时候我们写的方法并不需要依赖于某个特定的对象状态。比如，一个简单的数学计算，像加法或乘法，它们不需要知道任何关于对象的信息，只需要输入数字就能工作。这时候，我们就可以把这个方法设为静态的。这样做的好处是，我们不需要创建对象实例就能直接调用这个方法，既节省了资源，又让代码更简洁。 接下来是“打破方法”和“简短的专业方法”。这里的“打破方法”并不是真的把方法打碎，而是指我们应该把复杂的功能拆分成多个小方法。每个小方法只负责完成一个具体的任务。这样做的好处是，每个方法都变得简单明了，容易理解和测试。而且，如果我们需要修改某个功能，只需要改动相关的小方法，不会影响到其他部分。 再来说说“一个方法应该做一件事，只做一件事并且做好”。这是OOP中的一个核心原则。想象一下，如果一个方法既要处理数据，又要发送邮件，还要更新数据库，那么这个方法的职责就太多了。一旦出现问题，我们很难快速定位问题所在。所以，我们应该让每个方法只专注于完成一个任务，这样不仅代码更清晰，也更容易重用。 最后，我们来看一个实际的例子。假设我们有一个网页，页面上有多个子菜单。我们想要突出显示第一个子菜单。按照我们刚才讲的原则，我们可以写一个专门的方法来完成这个任务。这个方法只负责找到第一个子菜单并改变它的样式，而不需要关心其他子菜单或页面的其他部分。这样，如果以后我们需要修改突出显示的样式，只需要改动这个方法就可以了。 总结一下，业务逻辑模块化的要点就是让我们的代码更加模块化、职责单一、易于管理和重用。通过遵循这些OOP的最佳实践，我们可以写出更高质量的代码，让我们的工作更加高效。

  ▶ 播放视频 查看详情
• 273

  Considerations Around Trigger Batches

  第 355 页

  让我们来聊聊Salesforce中的触发器批处理注意事项。首先，想象一下你有一堆记录需要处理，Salesforce会把这些记录分成小批次，每个批次最多200条记录。这就是我们说的“200”原则。 现在，这里有个小问题：这些记录的处理顺序是不可预测的。就像案例00026950中提到的，你不能确定哪条记录会先被处理。所以，在设计触发器时，你不能依赖于记录处理的顺序。 接下来，我们来看看“一次一个”的原则。Salesforce会一次处理一个批次，而不是同时处理多个批次。这意味着你的触发器需要能够处理一个批次中的所有记录，而不是依赖于多个批次同时处理。 最后，我们回到“相同的原则”。无论你处理多少个批次，每个批次都遵循200条记录的限制，处理顺序不可预测，并且一次只处理一个批次。 现在，让我们把这些原则应用到你的触发器设计中。你需要问自己：我的触发器设计应该预期处理多少条记录？答案是：你应该始终考虑到多批次的情况，因为Salesforce会分批处理记录。 动画1会告诉你：通过触发器发送记录的顺序是否可以预测？答案是不可以。你无法控制记录在批次中的出现顺序或批处理的顺序。 动画2会展示：批次是一次处理一个还是并行处理？答案是一次处理一个批次。 最后，动画3会解释：这如何应用于课程？由于触发器最佳实践建议使用类来处理业务逻辑，因此实际上需要处理批处理记录的是类及其方法。这意味着你应该把复杂的逻辑放在类中，而不是直接在触发器中处理。 希望这些解释能帮助你更好地理解Salesforce中的触发器批处理注意事项。记住，设计触发器时要考虑到这些原则，以确保你的代码既高效又可靠。

  ▶ 播放视频 查看详情
• 274

  Key Takeaways - 356

  第 356 页

  让我们来聊聊Salesforce开发中的一些关键要点，这些要点能帮助你写出更高效、更可靠的代码。 首先，，查询前收集数据，。这意味着在你执行任何操作之前，先收集好你需要的所有数据。这样可以避免在代码执行过程中频繁地去查询数据库，减少不必要的资源消耗。 其次，，在执行TLR（Trigger Logic Runner）操作之前收集数据，。TLR是Salesforce中用来处理触发器逻辑的工具。在执行这些操作之前，确保你已经收集了所有必要的数据，这样可以避免在执行过程中出现数据缺失或错误。 接下来，，使用每个对象一个触发器原则，。这意味着每个对象（比如Account、Contact等）应该只有一个触发器。这样可以避免触发器之间的冲突，也更容易管理和维护代码。 ，让业务逻辑远离触发器，。触发器应该只负责处理数据的插入、更新、删除等操作，而业务逻辑应该放在Apex类中。这样可以让代码更加模块化，也更容易测试和维护。 ，始终设计触发器和类方法来处理批量输入，。Salesforce中的数据操作通常是批量进行的，所以你的代码应该能够处理多条记录，而不是单条记录。这样可以提高代码的效率，也能避免超出系统限制。 ，循环的SOQL可以帮助你的代码避免超出限制，。SOQL是Salesforce中的查询语言，如果你在循环中执行SOQL查询，可能会导致超出查询限制。为了避免这种情况，你可以使用循环来分批查询数据，这样可以减少每次查询的记录数，避免超出限制。 接下来，我们来看看需要避免的一些做法： ，在循环内卸载，。这意味着不要在循环中执行复杂的操作，比如调用外部服务或执行大量的计算。这样会导致性能问题，甚至可能超出系统限制。 ，循环内部的TLR，。同样地，不要在循环中执行TLR操作。这会导致触发器被多次触发，增加系统的负担，也可能导致数据不一致。 总结一下，这些关键要点可以帮助你写出更高效、更可靠的Salesforce代码。记住，在编写代码时，始终要考虑批量处理、避免不必要的查询和操作，以及将业务逻辑与触发器分离。这样不仅能提高代码的性能，还能让代码更容易维护和扩展。

  ▶ 播放视频 查看详情
• 275

  Module 14: Trigger Design Strategy

  第 357 页

  今天我们来聊聊Salesforce中的触发设计策略。这个话题听起来可能有点技术性，但其实很简单，我会用通俗易懂的方式来解释。 首先，什么是触发器呢？触发器是Salesforce中的一种自动化工具，它可以在某些特定事件发生时自动执行一些操作。比如，当你在系统中创建或更新一条记录时，触发器可以自动帮你做一些事情，比如更新其他相关记录，或者发送通知。 那么，触发设计策略是什么呢？简单来说，就是我们在设计触发器时应该遵循的一些最佳实践和原则。这些策略可以帮助我们写出更高效、更可靠的触发器代码。 首先，，保持触发器简洁，。触发器的代码应该尽量简单明了，不要在里面写太多复杂的逻辑。如果逻辑太复杂，可以考虑把这些逻辑放到一个单独的类里面，然后在触发器里调用这个类。这样不仅代码更清晰，也更容易维护。 其次，，避免递归触发，。递归触发是指触发器在执行过程中又触发了自己，导致无限循环。这种情况会消耗大量的系统资源，甚至可能导致系统崩溃。为了避免这种情况，我们可以使用一些技巧，比如设置一个静态变量来标记触发器是否已经执行过。 第三，，批量处理，。Salesforce中的触发器是批量处理的，也就是说，它一次可以处理多条记录。所以我们在写触发器时，要考虑到批量处理的情况，确保触发器在处理多条记录时也能正常工作。 最后，，测试和调试，。写完触发器后，一定要进行充分的测试，确保它在各种情况下都能正常工作。Salesforce提供了强大的测试工具，我们可以利用这些工具来测试我们的触发器。 总结一下，触发设计策略就是我们在设计触发器时应该遵循的一些最佳实践，包括保持代码简洁、避免递归触发、批量处理和充分测试。遵循这些策略，可以帮助我们写出更高效、更可靠的触发器代码。 好了，今天的课程就到这里，希望你们对触发设计策略有了更清晰的理解。如果有任何问题，随时问我哦！

  ▶ 播放视频 查看详情
• 276

  Architectural Strategy

  第 358 页

  让我们来聊聊如何在Salesforce平台上设计一个架构策略，特别是关于如何自动化地确定候选人是否完成了认证要素并有资格持有认证。 首先，我们需要了解Salesforce提供的声明性机制，这些机制可以帮助我们实现复杂的业务逻辑，而不需要编写代码。声明性机制包括工作流规则、流程构建器、验证规则、公式字段等。这些工具非常适合处理一些标准化的、重复性的任务，比如自动发送电子邮件、更新记录字段、或者根据某些条件自动创建任务。 但是，声明性机制也有它们的局限性。例如，它们可能不适合处理非常复杂的逻辑，或者需要与外部系统集成的场景。在这些情况下，我们可能需要使用编程性解决方案，比如Apex代码。 接下来，我们可以探讨如何结合使用声明性和编程性功能来改进我们的解决方案。例如，我们可以使用流程构建器来触发一个Apex类，这个类可以处理更复杂的逻辑，或者与外部API进行交互。这样，我们既利用了声明性工具的简便性，又保留了编程性工具的灵活性。 回到我们的具体问题：自动化确定候选人是否完成认证要素并有资格持有认证。我们可以设计一个流程，首先使用声明性工具来检查候选人是否完成了所有必要的认证要素。如果所有要素都已完成，我们可以触发一个Apex类来进一步验证这些信息，并最终决定是否授予认证。 通过这种方式，我们不仅利用了Salesforce平台的强大功能，还确保了我们的解决方案既高效又灵活。希望这能帮助你理解如何在Salesforce平台上设计一个有效的架构策略。

  ▶ 播放视频 查看详情
• 277

  Module Agenda - 359

  第 359 页

  同学们，今天我们来聊聊Salesforce中的触发设计策略。这个模块的议程很简单，主要分为两个部分：分析问题和产生解决方案。 首先，，分析问题，。在Salesforce中，触发器（Trigger）是非常强大的工具，它们可以在记录被插入、更新或删除时自动执行一些操作。但是，如果设计不当，触发器可能会导致性能问题，甚至引发数据不一致的情况。所以，我们需要仔细分析当前的需求，看看触发器是否真的是解决问题的最佳方式。 接下来，，产生解决方案，。一旦我们明确了问题，就可以开始设计触发器了。这里有几个关键点需要注意： 1. ，单一职责原则，：每个触发器应该只负责一个特定的任务，这样可以避免复杂的逻辑和潜在的错误。 2. ，批量处理，：确保触发器能够处理批量操作，而不是只针对单条记录。这样可以提高性能。 3. ，避免递归，：触发器可能会引发递归调用，导致无限循环。我们需要设计好逻辑，避免这种情况发生。 通过这样的分析和设计，我们可以确保触发器既高效又可靠，帮助我们在Salesforce中实现复杂的业务逻辑。 好了，这就是今天的内容。希望你们能理解并应用到实际的项目中去。如果有任何问题，随时问我！

  ▶ 播放视频 查看详情
• 278

  Automatically Creating Certification Held Records

  第 360 页

  同学们，今天我们来聊聊如何在Salesforce中自动创建持有证书的记录。想象一下，你正在参加一个网络认证考试，这个考试有两个部分：实验部分和多项选择考试。你可能会在不同的时间尝试这两个部分。 首先，假设你第一次尝试就通过了实验部分，这很棒！然后你尝试了多项选择考试，但这次没那么幸运，没有通过。没关系，你可以再试一次。第二次尝试时，你终于通过了多项选择考试。这时候，你已经通过了所有必需的考试部分，所以系统应该自动为你创建一个认证持有的记录。 这个过程是这样的：每次你尝试一个考试部分，系统都会记录你的尝试状态——可能是“已安排”、“进行中”、“通过”或“失败”。如果你失败了，你可以再次尝试。但只有当你通过了所有考试部分时，系统才会自动为你创建一个认证持有的记录。 这个自动化的过程确保了只有真正通过所有考试的人才能获得认证，同时也减少了手动操作的错误和遗漏。希望这个解释能帮助你们更好地理解这个过程！如果有任何疑问，随时提问哦！

  ▶ 播放视频 查看详情
• 279

  What Criteria Will Determine if a Certification Held Record Should Be Created?

  第 361 页

  让我们来聊聊如何决定是否应该为候选人创建一个认证持有记录。这个问题其实挺简单的，我们只需要关注几个关键点。 首先，我们需要知道候选人是否通过了这次认证尝试。如果他们没有通过，那自然就不需要创建认证持有记录了。 其次，我们要清楚这次尝试是针对哪个认证的。因为不同的认证有不同的要求和标准，所以明确认证的类型是非常重要的。 接下来，我们还需要了解与这个认证相关的其他要素。比如，有些认证可能要求候选人通过多个考试或完成特定的培训课程。我们需要确认候选人是否已经满足了所有这些要求。 最后，我们要确保候选人已经全部通过了这些相关的认证要素。如果还有未完成的部分，那么即使通过了主要的认证考试，也不能算是完全通过了认证。 总结一下，决定是否创建认证持有记录，我们需要确认候选人是否通过了认证尝试，这次尝试是针对哪个认证的，与认证相关的其他要素有哪些，以及候选人是否全部通过了这些要素。只要这些条件都满足了，我们就可以为候选人创建一个认证持有记录啦。

  ▶ 播放视频 查看详情
• 280

  How Do You Get the Needed Data?

  第 362 页

  让我们来聊聊如何获取我们需要的数据，以及这个过程为什么有时候会让人觉得有点头疼。 首先，想象一下，你正在处理一个关于认证的系统。每当有人尝试通过认证时，系统就会记录下这次尝试。我们的目标是找出哪些人通过了认证，以及他们是通过了哪些具体的认证要素。 ，1. 对哪个对象的更改可能会触发此触发器？， 这里的关键对象是“认证尝试”。每当有人尝试通过认证时，这个对象就会被更新或创建，从而可能触发我们的触发器。 ，2. 您是如何找到相关认证的？， 每个认证尝试都会关联到一个具体的认证。你可以通过查看认证尝试对象中的“认证ID”来找到相关的认证。 ，3. 您如何找到与该认证相关的要素？， 每个认证都由多个要素组成。你可以使用认证ID去查询“认证元素”表，这样就能找到所有与这个认证相关的要素。 ，4. 你如何确定应聘者是否通过了这些要素？， 接下来，你需要检查每个认证要素是否已经被这个候选人成功完成。你可以通过查询“认证尝试”表，找到那些状态为“已完成”或“已通过”的记录，然后将这些记录与认证要素匹配起来。 ，5. 处理批处理数据会让它变得更容易还是更难？， 这里有个小挑战。如果你处理的是单个候选人的数据，那可能还比较简单。但如果你要处理的是大批量的数据，比如同时处理多个候选人和多个认证，那情况就复杂多了。你需要确保每个候选人的每个认证尝试都能正确地匹配到相应的认证要素，这就像是在玩一个复杂的拼图游戏。 ，动画提示：， 想象一下，如果我们要处理的是成千上万的候选人和认证，这个匹配过程会变得多么复杂。每个候选人都可能有多个认证尝试，每个认证又包含多个要素。随着数据量的增加，这个匹配过程的复杂性也会呈指数级增长。 所以，这就是为什么我们需要结合声明性和程序性的方法来解决这个问题。声明性的方法可以帮助我们快速定义规则和关系，而程序性的方法则可以帮助我们处理那些复杂的、需要精细控制的数据匹配过程。 希望这个解释能帮助你更好地理解这个过程！

  ▶ 播放视频 查看详情
• 281

  Can the Solution Use Something Besides Matching?

  第 363 页

  让我们来聊聊这个有趣的话题。今天我们要讨论的是，在Salesforce中，除了简单的匹配之外，我们还可以用计数的方法来确定是否应该创建认证持有记录。这个方法特别适用于那些规定候选人只能对特定认证元素进行一次“完整/通过”尝试的场景。 首先，想象一下，我们有一个认证，里面包含了好几个元素，比如考试、项目、面试等。我们的第一个动画就是展示如何确定这个认证中到底有多少个元素。这一步很重要，因为我们需要知道总共有多少个关卡需要候选人去挑战。 接下来，第二个动画会展示我们如何计算候选人已经“完成/通过”这些元素的次数。这里的关键是，我们假设候选人每个元素只能尝试一次，所以每次“完成/通过”都是独一无二的。 最后，第三个动画会展示一个简单的逻辑：如果候选人“完成/通过”的次数和认证中元素的总数相匹配，那么恭喜这位候选人，他们已经成功地通过了每一个要素，应该获得认证持有记录。 这种方法的好处是，它不仅简单直观，而且非常有效。通过计数，我们可以清晰地看到候选人是否已经满足了所有的认证要求，而不需要复杂的匹配逻辑。这样，无论是对于管理员还是候选人来说，整个过程都变得更加透明和易于理解。 希望这个解释能帮助你更好地理解在Salesforce中如何利用计数来确定认证持有记录的创建。如果你有任何问题，随时欢迎提问！

  ▶ 播放视频 查看详情
• 282

  What Tool Should Be Used to Create a Solution?

  第 364 页

  让我们来聊聊在Salesforce中创建解决方案时应该使用哪些工具。首先，我们可以考虑一些声明性的选项，比如工作流程和流程构建器。这些工具非常适合那些不需要编写代码的场景，因为它们通过图形界面来设置逻辑和自动化任务。 但是，如果你发现工作流程的功能不足以满足你的需求，那么流程构建器可能是一个更好的选择。流程构建器比工作流程更强大，可以处理更复杂的业务逻辑。不过，使用流程构建器可能会有些复杂，特别是对于初学者来说。 如果流程构建器也无法满足你的需求，那么你可能需要考虑使用触发器。触发器是Apex代码的一部分，它们可以在数据库操作（如插入、更新或删除记录）之前或之后自动执行。触发器非常强大，可以处理几乎任何复杂的业务逻辑，但编写和维护触发器需要一定的编程知识。 所以，总结一下，如果你的需求比较简单，工作流程和流程构建器是不错的选择。但如果需要处理更复杂的逻辑，触发器可能是最好的解决方案。希望这些信息对你有帮助！

  ▶ 播放视频 查看详情
• 283

  Module Agenda - 365

  第 365 页

  同学们，今天我们来聊聊Salesforce中的触发设计策略。这个模块的议程分为两部分：首先是分析问题，然后是产生解决方案。 首先，，分析问题，。在Salesforce中，触发器（Trigger）是非常强大的工具，它们可以在记录被插入、更新、删除或取消删除时自动执行一些操作。但是，如果设计不当，触发器可能会导致性能问题，甚至引发复杂的逻辑冲突。所以，我们需要仔细分析业务需求，明确触发器应该在什么情况下触发，以及它们需要完成哪些任务。 接下来，，产生解决方案，。在设计触发器时，我们需要遵循一些最佳实践。比如，尽量保持触发器的逻辑简单，避免在触发器中编写复杂的业务逻辑。我们可以将这些逻辑移到Apex类中，通过调用类的方法来实现。此外，我们还要注意触发器的执行顺序，确保它们不会互相干扰。最后，测试是非常重要的一步，确保触发器在各种情况下都能正常工作。 这就是我们今天的内容，希望大家能够理解并应用到实际项目中。如果有任何问题，随时提问哦！

  ▶ 播放视频 查看详情
• 284

  What Type of Trigger is Needed?

  第 366 页

  让我们来聊聊Salesforce中的触发器类型，特别是针对认证尝试（Certification_Attention__c）这个对象。 首先，我们需要确定的是，我们想要在什么时候触发这个触发器。是在记录被创建或更新之前（Before），还是之后（After）？这个决定很关键，因为它会影响我们如何编写触发器和处理数据。 在这个案例中，我们关注的是状态字段。我们希望在记录被创建或更新时，能够自动将状态设置为“完成/通过”。为了实现这一点，我们需要考虑两种操作：插入（Insert）和更新（Update）。 现在，让我们来看看使用Before触发器和After触发器的区别。 如果我们选择使用Before触发器，我们需要在触发器内部计算通过认证尝试的数量。这意味着我们需要查看trigger.new中的记录（即即将被插入或更新的记录），以及数据库中已经存在的记录，然后将它们结合起来计算总数。这可能会比较复杂，因为我们需要确保我们的计算是准确的，并且不会遗漏任何记录。 另一方面，如果我们选择使用After触发器，事情就会简单得多。在After触发器中，所有的认证尝试记录都已经保存到数据库中，所以我们可以直接从数据库中统计通过的认证尝试数量。此外，After触发器中的认证尝试记录已经具有正确的状态，这意味着我们不需要担心状态字段的更新问题。 因此，基于这些考虑，我们决定使用After触发器。这样，我们可以更简单、更有效地处理认证尝试的状态更新，确保我们的触发器既高效又准确。 希望这个解释能帮助你理解为什么在这个案例中选择使用After触发器。如果你有任何疑问，随时问我！

  ▶ 播放视频 查看详情
• 285

  How Many Queries are Needed for the Solution?

  第 367 页

  让我们来聊聊这个问题。首先，我们需要明确的是，每个查询通常需要一个独立的收件箱来处理数据。在这个场景中，我们有三个主要的查询任务： 1. ，查找相关认证，：这个查询需要从系统中提取所有相关的认证信息。 2. ，查找与每个认证相关的元素数量，：这个查询需要统计每个认证下有多少个元素。 3. ，查找每位候选人通过的每项相关认证的尝试，：这个查询需要追踪每位候选人对每项认证的尝试次数。 由于每个查询都是独立的，并且处理的数据类型和目的不同，因此每个查询都需要一个独立的收件箱来确保数据的准确性和处理的高效性。所以，根据这个初步的解决方案，我们至少需要，三个收件箱，来分别处理这三个查询任务。 总结一下，每个独立的查询任务通常需要一个独立的收件箱，这样可以确保数据处理的清晰和高效。在这个案例中，三个查询任务意味着我们需要三个收件箱。希望这个解释对你有帮助！

  ▶ 播放视频 查看详情
• 286

  How Can You Use Declarative Features to Reduce the Number of Queries?

  第 368 页

  让我们来聊聊如何利用Salesforce的声明性功能来减少收件箱的数量。首先，声明性功能意味着我们不需要编写代码，而是通过配置和设置来实现目标。这非常适合那些不熟悉编程的用户。 ### 1. ，理解问题， 首先，我们需要明确为什么收件箱会变得杂乱。通常，这可能是因为有太多的通知、任务或者未处理的记录。我们的目标是通过自动化来减少这些不必要的干扰。 ### 2. ，使用自动化工具， Salesforce提供了几种声明性工具来帮助我们自动化流程，比如，工作流规则，、，流程构建器，和，批准过程，。这些工具可以帮助我们自动处理一些任务，从而减少手动操作。 ### 3. ，创建公式字段， 你提到的动画部分，其实是一个很好的例子。假设我们有一个数据模型，其中包含“认证尝试”记录。我们可以创建一个公式字段来显示认证ID。这样，每当有新的认证尝试时，系统会自动填充这个字段，而不需要手动输入。 ### 4. ，设置通知规则， 接下来，我们可以设置通知规则，确保只有重要的信息才会发送到收件箱。例如，我们可以设置只有当认证尝试失败时，才会发送通知。这样，成功的认证尝试就不会占用收件箱的空间。 ### 5. ，使用流程构建器， 流程构建器是一个非常强大的工具。我们可以用它来创建一个流程，当某个条件满足时（比如认证尝试失败），自动创建一个任务或者发送一封邮件。这样，我们就可以减少手动处理这些任务的时间。 ### 6. ，定期审查和优化， 最后，定期审查我们的自动化设置是非常重要的。随着时间的推移，业务需求可能会变化，我们需要确保我们的自动化流程仍然有效。 ### 总结 通过使用Salesforce的声明性功能，我们可以大大减少收件箱的杂乱。关键在于理解问题，选择合适的工具，并定期优化我们的设置。希望这些建议对你有帮助！如果你有任何问题或者需要进一步的解释，随时告诉我。

  ▶ 播放视频 查看详情
• 287

  14-1: Create a Formula Field to Eliminate a Query

  第 369 页

  同学们，今天我们来学习如何在Salesforce中创建一个公式字段，这个字段可以帮助我们消除查询任务。具体来说，我们要在“认证尝试”对象上创建一个隐藏的公式字段，目的是让“认证尝试”对象上的“认证ID”能够被使用。 首先，我们需要理解什么是公式字段。公式字段是一种特殊类型的字段，它不存储数据，而是根据我们定义的公式动态计算并显示结果。这个公式可以包括其他字段的值、运算符、函数等。 现在，我们来看一下具体的步骤： 1. ，进入对象管理器，：首先，我们需要进入Salesforce的设置界面，找到“对象管理器”，然后选择“认证尝试”这个对象。 2. ，创建新字段，：在“认证尝试”对象的字段部分，点击“新建”按钮，选择“公式”作为字段类型。 3. ，定义公式，：接下来，我们需要定义公式。在这个例子中，我们的目标是让“认证ID”可用。假设“认证ID”是“认证尝试”对象上的一个字段，我们可以直接在公式中引用它。比如，公式可以是简单的 `Certification_ID__c`，这样公式字段就会显示“认证ID”的值。 4. ，设置字段属性，：在定义好公式后，我们需要设置一些字段属性。比如，我们可以选择字段的数据类型（文本、数字等），以及是否要将这个字段隐藏。在这个例子中，我们希望这个字段是隐藏的，所以我们可以选择“隐藏”选项。 5. ，保存并测试，：最后，保存我们的设置，并在“认证尝试”对象上测试这个新字段，确保它能够正确显示“认证ID”的值。 通过以上步骤，我们就成功创建了一个隐藏的公式字段，它可以帮助我们消除查询任务，直接显示“认证ID”的值。这样，我们在处理“认证尝试”对象时，就不需要每次都去查询“认证ID”了，大大提高了效率。 好了，这就是今天的内容，希望大家能够理解并掌握如何在Salesforce中创建公式字段。如果有任何问题，欢迎随时提问。谢谢大家！

  ▶ 播放视频 查看详情
• 288

  How Can You Use Declarative Features to Reduce the Number of Queries? (cont.)

  第 370 页

  今天我们来聊聊如何利用Salesforce的声明性功能来减少收件箱的数量。首先，我们需要理解的是，Salesforce提供了很多工具和功能，可以帮助我们自动化和管理数据，从而减少手动操作的需求。 ### 动画1：使用汇总摘要字段 想象一下，你有一个认证记录，这个记录下面有很多相关的元素，比如认证尝试。这些元素和认证记录之间有一个主-细节关系。为了知道有多少个元素与这个认证相关，我们可以使用一个叫做“汇总摘要字段”的功能。这个字段可以自动计算并显示与主记录相关的子记录的数量。这样，你就不需要手动去数了，系统会自动帮你完成这个工作。 ### 动画2：轻松访问认证尝试的价值 接下来，我们来看看如何让认证尝试记录更容易访问。你可以在认证尝试记录上创建一个公式字段，这个字段会自动显示与之相关的认证ID。这样，当你查看认证尝试记录时，你就能立刻知道它属于哪个认证，而不需要跳转到另一个页面去查找。 ### 动画3：使用公式字段 最后，我们还可以使用公式字段来简化数据管理。比如，你可以在认证尝试记录上创建一个公式字段，这个字段会自动从相关的认证记录中提取信息并显示出来。这样，你就能在认证尝试记录上直接看到重要的信息，而不需要每次都去查找认证记录。 通过这些方法，我们可以大大减少收件箱中的手动操作，让数据管理变得更加高效和自动化。希望这些技巧能帮助你更好地使用Salesforce！

  ▶ 播放视频 查看详情
• 289

  14-2: Create Fields for Counting Certification Elements

  第 371 页

  同学们，今天我们来学习如何在Salesforce中创建计算认证元素的字段。这个任务分为两部分：首先是在认证对象上创建一个汇总字段，然后是在认证尝试对象上创建一个隐藏的公式字段。我们的目标是让认证尝试元素能够显示与其关联的认证元素的数量。 首先，我们来看如何在认证对象上创建汇总字段。这个字段的作用是统计与认证对象相关联的认证元素的数量。你可以通过以下步骤来完成： 1. 打开认证对象的字段管理页面。 2. 点击“新建”按钮，选择“汇总”字段类型。 3. 在汇总字段的设置中，选择“认证元素”作为相关的子对象。 4. 选择“计数”作为汇总函数，这样就能统计出与认证对象相关联的认证元素的数量。 5. 保存并部署这个字段。 接下来，我们来看如何在认证尝试对象上创建隐藏的公式字段。这个字段的作用是引用认证对象上的汇总字段，从而在认证尝试元素上显示认证元素的数量。你可以通过以下步骤来完成： 1. 打开认证尝试对象的字段管理页面。 2. 点击“新建”按钮，选择“公式”字段类型。 3. 在公式字段的设置中，选择“文本”作为返回类型。 4. 在公式编辑器中，输入公式来引用认证对象上的汇总字段。例如，你可以使用类似`Certification__r.Certification_Element_Count__c`的公式来引用认证对象上的汇总字段。 5. 将这个字段设置为隐藏，这样它就不会在页面上显示，但仍然可以在后台使用。 6. 保存并部署这个字段。 通过以上步骤，你就成功地在认证对象上创建了汇总字段，并在认证尝试对象上创建了隐藏的公式字段。这样，认证尝试元素就能够显示与其关联的认证元素的数量了。 希望这个讲解对你有帮助，如果有任何问题，欢迎随时提问！

  ▶ 播放视频 查看详情
• 290

  What Queries Do We Need Now?

  第 372 页

  同学们，让我们来聊聊我们现在需要做什么。首先，我们有一个原始收件箱，里面有一些任务需要完成。我们需要找到相关的认证，然后看看每个认证有多少个元素与之相关。接着，我们还需要找到每个相关候选人通过的认证尝试。 听起来有点复杂，对吧？但别担心，我们有一个简单的方法来解决这个问题。通过添加三个声明性字段，我们现在可以在认证尝试记录上获取所有需要的信息。这意味着，我们只需要一个查询就能搞定所有事情！ 所以，总结一下，我们现在只需要一个查询，就能找到所有相关的认证、元素数量以及候选人通过的尝试。这样一来，我们的工作就变得简单多了，效率也大大提高了。希望这个解释对你们有帮助！

  ▶ 播放视频 查看详情
• 291

  Which Records in Trigger.new Should Be Considered?

  第 373 页

  让我们来聊聊在Salesforce的触发器（Trigger）中，如何有效地处理`Trigger.new`中的记录。特别是当我们想要查询和过滤认证尝试记录时，应该注意哪些关键点。 首先，`Trigger.new`包含了触发器触发时所有被插入或更新的记录。在这个场景中，我们关注的是认证尝试记录。我们的目标是构建一个查询，只检索那些对我们有用的记录，这样可以减少处理的数据量，提高效率。 ### 1. 过滤记录 我们首先可以排除那些状态不是“通过”的认证尝试记录。因为这些记录不会对持有认证的人产生贡献。所以，我们的查询应该只包含那些状态为“通过”的记录。 ### 2. 检查记录是否刚刚获得“完整/通过”状态 如果触发器是在记录更新时触发的，我们需要确定哪些记录是刚刚获得“完整/通过”状态的。为了做到这一点，我们可以使用`Trigger.old`来查看更新前的记录状态。如果`Trigger.old`中的状态不是“完整/通过”，而`Trigger.new`中的状态是“完整/通过”，那么这条记录就是刚刚获得这个状态的。 ### 示例 假设我们有以下字段： - ，记录ID，：在`Trigger.new`中，这些记录已经有ID，因为触发器是在记录已经插入或更新后触发的（后触发状态）。 - ，候选人ID，：标识尝试认证的候选人。 - ，认证ID，：标识具体的认证。 - ，与认证相关的元素数量，：可能与认证相关的其他元素数量。 - ，尝试状态，：标识认证尝试的当前状态。 ### 查询构建 我们可以构建一个查询，只选择那些状态为“通过”的记录，并且检查这些记录是否刚刚从其他状态变为“通过”。这可以通过比较`Trigger.old`和`Trigger.new`中的状态来实现。 ### 代码示例 ```apex for (Certification_Attempt__c attempt : Trigger.new) { // 检查状态是否为“通过” if (attempt.Status__c == &#39;Passed&#39;) { // 检查是否刚刚获得“通过”状态 Certification_Attempt__c oldAttempt = Trigger.oldMap.get(attempt.Id); if (oldAttempt.Status__c != &#39;Passed&#39;) { // 这条记录刚刚获得“通过”状态 // 在这里添加你的处理逻辑 } } } ``` 通过这种方式，我们可以确保只处理那些真正需要关注的记录，从而提高触发器的效率和性能。希望这个解释对你有帮助！如果有任何问题，随时问我。

  ▶ 播放视频 查看详情
• 292

  Using Filters in Queries to Minimize Row Count

  第 374 页

  让我们一步一步来理解如何在Salesforce中使用筛选器来减少查询返回的行数。 首先，想象一下你有一个触发器，这个触发器在数据库中的某些记录被更新或创建后运行。这些记录在触发器中被称作`Trigger.new`。我们的目标是只从数据库中获取那些我们真正需要的记录，而不是所有的记录。 ，动画1，：你可能会问，为什么触发器中的记录会出现在数据库中呢？这是因为我们使用的是“After”触发器，这意味着触发器在记录已经被保存到数据库之后运行。 ，动画2，：现在，让我们开始过滤这些记录。我们的第一步是只从数据库中获取那些在触发器中的候选人记录。 ，动画3，：这样做的好处是，我们可以立即减少查询结果中的记录数量，因为我们只关注那些与候选人相关的记录。 ，动画4，：接下来，我们进一步过滤，只获取那些已经通过认证的记录。 ，动画5，：这一步会进一步减少我们的查询结果，因为我们只保留那些既与候选人相关，又已经通过认证的记录。 ，动画6，：最后，我们只选择那些状态为“Complete/Pass”的记录。 ，动画7，：经过这三步过滤，我们得到了一组非常精确的记录，这些记录不仅与候选人相关，而且已经通过认证，并且状态是“Complete/Pass”。 ，动画8，：现在，让我们思考一下，为什么这条特定的记录会被检索到？因为它符合我们所有的筛选条件：它是候选人集合中的一部分，它已经通过认证，并且它的状态是“Complete/Pass”。 ，动画9，：总结一下，我们通过候选人、认证和状态这三个条件来筛选记录，这样可以确保我们只获取那些真正需要的记录。 ，动画10，：最后，为了更有效地管理这些数据，我们将在认证尝试对象上设置一个公式字段。这个公式字段将帮助我们理解每个认证尝试与哪个认证相关联，这样我们就可以更轻松地进行筛选和管理。 希望这能帮助你理解如何在Salesforce中使用筛选器来优化你的查询！

  ▶ 播放视频 查看详情
• 293

  14-3: Create Collections to Filter the Query

  第 375 页

  同学们，今天我们来学习如何在Salesforce中创建集合来过滤查询任务。这个任务的目标是编写代码，创建一个查询过滤器，然后循环SOQL的结果，最后更改代码以调用一个新的类处理程序方法的逻辑。我们还会测试这个新的触发逻辑。 首先，我们需要创建一个查询，这个查询将带回认证尝试的记录。我们可以使用SOQL（Salesforce Object Query Language）来实现这一点。SOQL是一种类似于SQL的查询语言，专门用于查询Salesforce中的数据。 假设我们有一个对象叫做“认证尝试”（Certification_Attempt__c），我们想要查询所有状态为“成功”的记录。我们可以这样写SOQL查询： ```apex List successfulAttempts = [SELECT Id, Name, Status__c FROM Certification_Attempt__c WHERE Status__c = &#39;成功&#39;]; ``` 这个查询会返回所有状态为“成功”的认证尝试记录，并将它们存储在`successfulAttempts`这个列表中。 接下来，我们需要循环这个列表，对每一条记录进行处理。我们可以使用一个`for`循环来实现这一点： ```apex for (Certification_Attempt__c attempt : successfulAttempts) { // 在这里处理每一条记录 System.debug(&#39;认证尝试名称: &#39; + attempt.Name); } ``` 在这个循环中，我们简单地打印出每一条认证尝试的名称。你可以根据实际需求在这里添加更多的处理逻辑。 现在，假设我们想要将处理逻辑封装到一个新的类中。我们可以创建一个新的Apex类，比如叫做`CertificationAttemptHandler`，并在其中定义一个方法来处理这些记录： ```apex public class CertificationAttemptHandler { public static void processSuccessfulAttempts(List attempts) { for (Certification_Attempt__c attempt : attempts) { // 在这里处理每一条记录 System.debug(&#39;认证尝试名称: &#39; + attempt.Name); } } } ``` 然后，我们可以在原来的代码中调用这个新的方法： ```apex List successfulAttempts = [SELECT Id, Name, Status__c FROM Certification_Attempt__c WHERE Status__c = &#39;成功&#39;]; CertificationAttemptHandler.processSuccessfulAttempts(successfulAttempts); ``` 这样，我们就将处理逻辑封装到了一个独立的类中，使得代码更加模块化和易于维护。 最后，我们需要测试这个新的触发逻辑。你可以创建一个测试类，使用`Test.startTest()`和`Test.stopTest()`方法来模拟触发器的执行，并验证结果是否符合预期。 这就是我们今天的内容，希望你们能够理解并掌握如何创建集合来过滤查询任务。如果有任何问题，随时提问！

  ▶ 播放视频 查看详情
• 294

  How is the Count for Passed Certification Attempts Accomplished?

  第 376 页

  同学们，今天我们来聊聊如何通过认证尝试的计数来帮助我们决定是否应该创建认证持有记录。这个过程其实挺有意思的，我们一步步来。 首先，我们已经收集了所有需要的数据。现在的问题是，我们怎么用这些数据来判断是否需要为某个候选人创建认证持有记录呢？ 第一步，我们需要做的是汇总结果。具体来说，就是对于每一个候选人ID和认证ID的唯一组合，我们要看看有多少条记录。这就像是在数一数，每个候选人尝试了多少次某个认证。 接下来，我们怎么存储这些结果呢？这里，动画1会展示给我们看。我们使用一个叫做Map的数据结构。Map非常适合这个任务，因为它的键（key）可以是候选人ID和认证ID的组合，而值（value）就是这个组合出现的次数。这样，我们就能轻松地知道每个候选人尝试了多少次某个认证。 最后，动画2会带我们一步步创建这个Map，并计算每个唯一组合的元素计数。这样，我们就能清楚地看到哪些候选人已经尝试了足够多的次数，可能需要创建认证持有记录了。 这个过程听起来是不是很简单？通过这样的方法，我们就能有效地管理和跟踪认证尝试的情况了。希望这能帮助大家更好地理解如何使用数据来做出决策。

  ▶ 播放视频 查看详情
• 295

  14-4: Use a Map to Aggregate Results

  第 377 页

  同学们，今天我们来学习如何在Salesforce中使用地图（Map）来汇总查询结果。这个任务的目标是帮助我们确定候选人是否已经通过了所有的认证要素。我们将在20分钟内完成这个任务。 首先，我们需要理解什么是地图（Map）。在Salesforce中，Map是一种数据结构，它允许我们将键（Key）和值（Value）配对存储。这样，我们可以通过键快速查找对应的值。 接下来，我们来看如何构建并使用Map来聚合查询结果。假设我们有一个查询，返回了所有候选人的认证信息。我们需要将这些信息汇总，看看每个候选人是否已经通过了所有的认证要素。 我们可以这样做： 1. 首先，创建一个Map，键是候选人的ID，值是一个布尔值，表示该候选人是否通过了所有认证。 2. 然后，遍历查询结果。对于每个记录，我们检查候选人是否通过了当前认证要素。如果通过了，我们就在Map中更新该候选人的状态。 3. 最后，我们可以通过查看Map中的值，快速确定每个候选人是否已经通过了所有的认证要素。 现在，我们来测试一下这个逻辑。假设我们有一个候选人，他已经通过了两个认证要素，但还有一个没有通过。我们期望在Map中，这个候选人的值应该是false，表示他还没有通过所有的认证要素。 通过这种方式，我们可以有效地汇总查询结果，并快速确定候选人是否已经通过了所有的认证要素。这不仅提高了我们的工作效率，也使得数据处理更加清晰和有条理。 好了，这就是我们今天的内容。希望你们能够理解并掌握如何使用Map来汇总查询结果。如果有任何问题，随时提问。我们下次再见！

  ▶ 播放视频 查看详情
• 296

  14-5: Create Certification Held Records

  第 379 页

  同学们，今天我们来学习如何为合格的候选人创建认证持有记录。这个任务非常重要，因为它帮助我们跟踪和管理那些已经通过认证的候选人。我们将在15分钟内完成这个任务。 首先，我们需要明确什么是认证持有记录。简单来说，这就是一个记录，用来证明某个候选人已经通过了特定的认证。这个记录通常包括候选人的姓名、认证类型、通过日期等信息。 接下来，我们来看看如何创建这个记录。在Salesforce中，我们可以通过以下几个步骤来完成： 1. ，登录Salesforce，：首先，我们需要登录到Salesforce系统。确保你有足够的权限来创建和修改记录。 2. ，导航到对象，：在Salesforce中，认证持有记录通常是一个自定义对象。我们需要找到这个对象。你可以通过搜索或者导航菜单找到它。 3. ，创建新记录，：找到对象后，点击“新建”按钮来创建一个新的认证持有记录。 4. ，填写信息，：在弹出的表单中，填写候选人的相关信息。比如，候选人的姓名、认证类型、通过日期等。确保所有信息都准确无误。 5. ，保存记录，：填写完所有信息后，点击“保存”按钮。这样，一个新的认证持有记录就创建成功了。 6. ，测试解决方案，：创建完记录后，我们需要测试一下这个解决方案是否有效。你可以尝试查找这个记录，看看是否能正确显示所有信息。 好了，这就是创建认证持有记录的基本步骤。接下来，你可以自己动手试试看。记住，实践是最好的学习方式。如果在操作过程中遇到任何问题，随时可以问我。 祝你们学习愉快！

  ▶ 播放视频 查看详情
• 297

  How Can You Avoid Creating Duplicate Certification Held Records?

  第 380 页

  让我们来聊聊如何避免在Salesforce中创建重复的认证持有记录。这个问题其实很常见，但解决起来也有几种方法。我会尽量用简单的语言来解释，这样你听起来也会觉得轻松。 首先，我们得明白什么是“认证持有记录”。简单来说，就是记录某人持有某种认证的信息。比如，小明持有“Salesforce管理员”认证，这就是一条认证持有记录。 现在，问题来了：如果小明不小心被记录了两次，或者通过不同的方式（比如通过用户界面和触发器）被记录了两次，那就会产生重复的记录。这显然是我们不希望看到的。 那么，怎么避免这种情况呢？这里有三种方法： 1. ，使用重复规则功能，：这个方法听起来不错，但其实不太适合我们这个问题。因为重复规则主要是基于两个关系字段来工作的，而我们的认证持有记录可能并不完全符合这个条件。 2. ，使用工作流程，：这个方法就比较实用了。我们可以设置一个工作流程，当有新的认证持有记录被创建时，自动检查是否已经存在相同的记录。如果存在，就阻止新记录的创建，或者更新已有的记录。这样，就能有效避免重复了。 3. ，在触发器中执行，：如果你已经在使用触发器来处理认证持有记录，那么可以在触发器中加入检查重复的逻辑。这样，无论是通过用户界面还是触发器创建记录，都能确保不会重复。 最后，为了更彻底地解决这个问题，我们还可以创建一个新的文本字段，这个字段由两个值组成，并且标记为唯一。这样，每当有新的认证持有记录被创建时，Salesforce会自动检查这个唯一字段，确保没有重复的记录被创建。 总结一下，避免创建重复的认证持有记录，我们可以通过设置工作流程、在触发器中加入检查逻辑，或者创建一个唯一字段来实现。希望这些方法能帮助你更好地管理Salesforce中的认证持有记录！

  ▶ 播放视频 查看详情
• 298

  14-6: Use a Workflow to Avoid Creation of Duplicate Records (Optional)

  第 381 页

  今天我们来学习如何使用工作流程来避免在Salesforce中创建重复的记录。这个技巧非常实用，尤其是在管理认证持有者这样的重要数据时。 首先，我们需要创建一个新的隐藏文本字段。这个字段将用来存储一些关键信息，帮助我们识别记录是否重复。你可以把这个字段想象成一个秘密的标签，只有系统知道它的存在和内容。 接下来，我们要创建一个工作流规则。这个规则的作用是，当有新的记录被创建时，它会自动检查这个新记录是否与现有的记录重复。如果发现有重复，工作流规则就会自动填充我们之前创建的那个隐藏文本字段。这样，我们就可以通过这个字段来识别和阻止重复记录的创建。 然后，我们需要对所有现有的记录执行这个工作流规则。这一步是为了确保我们的系统中所有的记录都符合这个新的规则，没有遗漏。 最后，别忘了测试你的工作流规则。你可以尝试创建一个新的记录，看看系统是否能够正确地识别并阻止重复记录的创建。如果一切正常，那么恭喜你，你已经成功地使用工作流程来避免创建重复记录了！ 这个过程大约需要10分钟，但它的效果会持续很长时间，帮助你保持数据的清洁和准确。现在，轮到你动手试试看了！

  ▶ 播放视频 查看详情
• 299

  Key Takeaways - 382

  第 382 页

  让我们来聊聊在Salesforce中创建解决方案时需要考虑的几个关键点。首先，我们要关注的是，声明性业务逻辑选项，。这是什么意思呢？简单来说，声明性业务逻辑就是通过配置而不是编写代码来实现业务需求。Salesforce提供了很多这样的工具，比如流程构建器、工作流规则、验证规则等等。这些工具可以帮助你快速实现业务逻辑，而不需要写复杂的代码。 接下来，我们要谈谈，声明性功能，，比如公式字段和汇总字段。这些功能非常强大，可以帮助你简化和提高代码的性能。举个例子，公式字段可以让你在不写代码的情况下，通过简单的公式计算出一个字段的值。而汇总字段则可以帮助你自动汇总相关记录的数据，比如计算某个客户的所有订单总额。 使用这些声明性功能的好处是，它们不仅易于设置和维护，还能显著提高系统的性能。因为它们是Salesforce内置的功能，所以运行起来非常高效，不会像自定义代码那样可能带来性能瓶颈。 总结一下，当你在Salesforce中创建解决方案时，优先考虑使用声明性业务逻辑选项和声明性功能。它们不仅能帮助你快速实现业务需求，还能让你的系统运行得更顺畅。希望这些建议对你有所帮助！

  ▶ 播放视频 查看详情
• 300

  Module 15: Creating Visualforce Pages

  第 383 页

  今天我们来聊聊如何在Salesforce中创建一个视觉力量页面，也就是Visualforce页面。Visualforce是Salesforce提供的一种强大的工具，它允许你创建自定义的用户界面，完全按照你的需求来设计。 首先，打开Salesforce的开发者控制台。你可以通过点击右上角的设置图标，然后选择“开发者控制台”来进入。 在开发者控制台中，点击“文件”菜单，然后选择“新建”，接着选择“Visualforce页面”。这时，系统会提示你输入页面的名称。你可以根据自己的需求来命名，比如“MyFirstPage”。 接下来，你会看到一个代码编辑器，里面已经有一些默认的代码。这些代码是Visualforce页面的基本结构。你可以在这里编写你的HTML和Visualforce标签来设计页面。 例如，如果你想在页面上显示一段文字，你可以这样写： ```html <h1>欢迎来到我的第一个Visualforce页面！</h1> <p>这是一个简单的示例页面。</p> ``` 这段代码会在页面上显示一个大标题和一段文字。 编写完代码后，点击“保存”按钮。然后，你可以通过点击“预览”按钮来查看你的页面效果。如果一切正常，你应该能在浏览器中看到你设计的页面。 最后，别忘了测试你的页面，确保它在不同的设备和浏览器上都能正常显示。如果有任何问题，回到代码编辑器进行调整。 这就是创建Visualforce页面的基本步骤。希望你能通过这个简单的例子，开始你的Visualforce页面设计之旅。如果有任何问题，随时提问，我会在这里帮助你。

  ▶ 播放视频 查看详情
• 301

  Creating Visualforce Pages

  第 384 页

  今天我们来聊聊如何在Salesforce中创建Visualforce页面。Visualforce页面是Salesforce中用来构建自定义用户界面的强大工具。我们可以用它来创建一些非常酷的功能，比如打印课程完成证书。 首先，我们需要创建一个Visualforce页面。这个页面将是我们展示数据和功能的地方。你可以把它想象成一个网页，但它是在Salesforce内部运行的。 接下来，我们需要参考标准控制器。标准控制器是Salesforce提供的一个工具，它可以帮助我们轻松地与标准对象（比如学生或课程记录）进行交互。通过标准控制器，我们可以轻松地访问和操作这些记录的数据。 然后，我们需要使用自定义按钮来启动这个Visualforce页面。自定义按钮可以放在记录页面上，当用户点击它时，就会打开我们创建的Visualforce页面。这样，运营团队就可以轻松地访问这个页面，并为学生打印证书。 最后，我们需要在Visualforce页面中显示记录中的数据。这意味着我们要从Salesforce数据库中提取学生的课程完成信息，并在页面上展示出来。这样，运营团队就可以看到每个学生的完成情况，并为他们生成证书。 总结一下，创建Visualforce页面的步骤包括：创建页面、参考标准控制器、使用自定义按钮启动页面，以及在页面中显示数据。通过这些步骤，我们可以为运营团队提供一个强大的工具，帮助他们更高效地管理学生的课程完成情况。 希望这个解释对你有帮助！如果你有任何问题，随时问我。

  ▶ 播放视频 查看详情
• 302

  Module Agenda - 385

  第 385 页

  同学们，今天我们来聊聊Salesforce中的Visualforce页面。Visualforce是Salesforce提供的一种强大的工具，它允许我们创建自定义的用户界面，这些界面可以直接与Salesforce的数据交互。 首先，我们要了解什么是Visualforce。简单来说，Visualforce是一种基于标签的语言，类似于HTML，但它更加强大，因为它可以直接与Salesforce的后端数据模型交互。这意味着你可以创建完全定制的页面，这些页面可以显示、编辑和操作Salesforce中的数据。 接下来，我们会学习如何创建一个Visualforce页面。创建Visualforce页面的过程其实很简单。你只需要在Salesforce的开发环境中，使用Visualforce标签来定义页面的结构和内容。你可以添加按钮、表单、表格等元素，甚至可以嵌入Apex代码来处理更复杂的逻辑。 然后，我们会探讨如何卸载记录数据并启动Visualforce页面。在Salesforce中，数据是以记录的形式存储的。我们可以通过Visualforce页面来展示这些记录，或者让用户通过页面来输入新的记录。启动Visualforce页面通常是通过在Salesforce的标准界面中添加一个自定义按钮或者链接来实现的。 最后，我们会进入模块15，这是一个实践环节，我们将一起动手创建一个Visualforce页面。在这个过程中，我会一步步指导你们如何操作，确保你们能够掌握创建Visualforce页面的技能。 好了，这就是我们今天要学习的内容。希望你们能够通过这个模块，对Visualforce有一个清晰的理解，并且能够自己动手创建出功能强大的自定义页面。让我们一起开始吧！

  ▶ 播放视频 查看详情
• 303

  Mapping Salesforce elements to the MVC

  第 386 页

  让我们一起来探索Salesforce中的MVC模型，也就是模型（Model）、视图（View）和控制器（Controller）这三个关键部分。我会用简单的例子来帮助你理解这些概念。 首先，想象一下你在Salesforce中查看一个课程记录。这个记录显示在屏幕上，这就是视图。在Salesforce中，视图通常是通过页面布局来呈现的。页面布局决定了哪些字段和按钮会显示给用户，以及它们如何排列。所以，当你在学生指南的“视图”框中填写时，你应该写“页面布局”。 接下来，假设你想要编辑这个课程记录。你点击编辑，更改了一些信息，然后点击保存。这个保存的动作会被Salesforce的控制器捕获。控制器是处理用户输入和更新数据的地方。在Salesforce中，每个对象都有一个标准控制器，它负责处理这些操作。所以，在“控制器”框中，你应该填写“标准控制器”。 最后，当你点击保存后，你所做的更改会被保存到数据库中。这就是模型。在Salesforce中，模型是由对象和记录组成的，它们代表了存储在数据库中的数据。因此，在“模型”框中，你应该填写“标准对象和自定义对象”。 总结一下，Salesforce中的每个标准和自定义对象都遵循这个MVC模式。视图是页面布局，控制器是标准控制器，模型是标准对象和自定义对象。 现在你已经了解了这些基础知识，我们可以进一步探讨如何在Salesforce中修改视图层和控制器层，以满足更复杂的需求。希望这个解释对你有帮助！

  ▶ 播放视频 查看详情
• 304

  What is Visualforce? - Markup

  第 387 页

  今天我们来聊聊Salesforce中的Visualforce，也就是视觉力量。首先，Visualforce是Salesforce提供的一种强大的工具，它允许开发者创建自定义的用户界面。你可以把它想象成是Salesforce版的HTML，但它更加强大，因为它可以直接与Salesforce的数据和逻辑交互。 Visualforce主要由两部分组成：标记和控制器。标记部分，也就是Visualforce Markup，是一种基于标签的语言，非常类似于HTML。你可以使用这些标签（我们通常称之为组件）来构建页面，就像你用HTML标签来构建网页一样。这些组件可以是按钮、表格、输入框等等，它们帮助你在Salesforce中创建出符合你需求的用户界面。 接下来是控制器部分。控制器是处理用户交互和业务逻辑的地方。它决定了当用户点击按钮或者提交表单时，系统应该做什么。控制器可以是标准的，也可以是自定义的。标准控制器是Salesforce自动提供的，而自定义控制器则允许你编写自己的逻辑来处理更复杂的需求。 所以，当你想要修改视图和控制器时，你会使用Visualforce。通过Visualforce Markup，你可以设计页面的外观和布局，而通过控制器，你可以控制页面的行为和响应。这样，你就可以在Salesforce中创建出既美观又功能强大的自定义页面了。 希望这个解释能帮助你理解Visualforce的基本概念。如果你有任何问题，随时问我哦！

  ▶ 播放视频 查看详情
• 305

  What is Visualforce? - Controllers

  第 388 页

  让我们来聊聊Salesforce中的视觉力量（Visualforce）和它的控制器。 首先，想象一下视觉力量就像是你用来构建网页的工具。在Salesforce中，你可以用视觉力量来创建自定义的用户界面，这样用户就可以以特定的方式查看和与数据互动。 现在，说到控制器，你可以把它想象成是视觉力量页面的“大脑”。控制器决定了页面上显示什么数据，以及用户与页面互动时会发生什么。 Salesforce提供了一些现成的控制器，叫做标准控制器和列表控制器。这些控制器是自动为每个自定义和标准对象创建的。标准控制器让你能够对单个记录执行标准的操作，比如查看、编辑或删除。列表控制器则让你能够处理一组记录，比如显示一个列表或执行批量操作。 但是，这些标准控制器和列表控制器是固定的，你不能直接编辑它们。如果你需要更复杂的功能，你可以自己编写自定义控制器或控制器扩展。这些自定义控制器是用Apex编写的，Apex是Salesforce的编程语言。通过自定义控制器，你可以创建非常特定的功能，满足你业务上的独特需求。 总结一下，视觉力量控制器是视觉力量页面的核心，它控制着页面的行为和数据的展示。标准控制器和列表控制器是Salesforce提供的，而自定义控制器则让你能够实现更高级的功能。希望这能帮助你理解视觉力量和控制器的基本概念！

  ▶ 播放视频 查看详情
• 306

  What is a Visualforce Page?

  第 389 页

  让我们来聊聊Visualforce页面吧！你可以把它想象成一个“容器”，就像是一个盒子，里面可以装很多东西。这个盒子是用来在Salesforce平台上展示内容的，比如数据、表单、按钮等等。 首先，Visualforce页面是以``这个标签开头的，这个标签就像是盒子的盖子，告诉Salesforce：“嘿，这是一个Visualforce页面！”然后，你可以在这个盒子里放很多东西，不仅仅是Visualforce自己的标记，还可以放HTML、CSS、JavaScript这些标准的网页内容。所以，Visualforce页面非常灵活，你可以用它来创建各种各样的网页。 另外，Visualforce页面还可以和Visualforce控制器一起工作。控制器就像是页面的“大脑”，它决定了页面上的数据从哪里来，以及用户点击按钮时会发生什么。不过，Visualforce页面并不一定非要和控制器一起使用，它也可以独立工作。 总结一下，Visualforce页面是一个灵活的容器，可以用来展示各种内容，并且可以和控制器配合使用，但也可以独立工作。希望这个解释能帮你更好地理解Visualforce页面！

  ▶ 播放视频 查看详情
• 307

  Visualforce Pages and the MVC

  第 390 页

  让我们来聊聊Salesforce中的Visualforce页面和MVC模型。首先，MVC代表的是模型（Model）、视图（View）和控制器（Controller），这是一种设计模式，帮助开发者将应用程序的不同部分分开管理，使得代码更加清晰和易于维护。 在Salesforce中，模型部分通常指的是你的数据模型，也就是你在Salesforce中创建的自定义对象。这些对象就像是数据库中的表，存储着你的业务数据。 视图部分，就是用户看到和交互的界面。在Salesforce中，这通常是通过Visualforce页面来实现的。Visualforce页面允许你使用HTML、CSS和JavaScript等标准网页技术来创建自定义的用户界面。你可以完全控制页面的布局和样式，使其符合你的业务需求。 控制器部分，是处理用户输入和业务逻辑的地方。在Salesforce中，控制器可以是标准的，也可以是自定义的。标准控制器是Salesforce提供的，可以直接与标准对象交互。而自定义控制器则是你用Apex语言编写的，可以处理更复杂的业务逻辑。 Visualforce页面不一定要包含大量的Visualforce标记，它可以是大部分或几乎全部是HTML、CSS、JS等。这意味着你可以利用你现有的网页开发技能来创建Salesforce应用。 总结一下，Salesforce的MVC模型让你可以清晰地分离数据、界面和逻辑，而Visualforce页面则是实现这一点的强大工具。通过Visualforce，你可以在Salesforce平台上创建完全定制的、基于Web的应用程序，满足你的业务需求。

  ▶ 播放视频 查看详情
• 308

  Module Agenda - 391

  第 391 页

  同学们，今天我们来聊聊Salesforce中的Visualforce页面。Visualforce是Salesforce提供的一种强大的工具，它允许我们创建自定义的用户界面，这些界面可以直接与Salesforce的数据和逻辑集成。 首先，我们要了解什么是Visualforce。简单来说，Visualforce是一种基于标签的语言，类似于HTML，但它更加强大，因为它可以直接与Salesforce的后端数据交互。这意味着你可以创建完全定制的页面，这些页面可以显示、编辑和操作Salesforce中的数据。 接下来，我们会学习如何创建一个Visualforce页面。创建Visualforce页面的过程其实很简单。你只需要在Salesforce中打开开发者控制台，然后使用Visualforce标签来定义页面的结构和内容。你可以添加按钮、表格、输入框等元素，甚至可以嵌入JavaScript和CSS来增强页面的功能和外观。 然后，我们会讨论如何卸载记录数据并启动Visualforce页面。在Salesforce中，你可以通过标准的页面布局来查看和编辑记录，但有时候你可能需要一个更定制化的视图。这时，你可以创建一个Visualforce页面来替代标准的页面布局。通过Visualforce页面，你可以控制哪些字段显示，如何显示，以及用户如何与这些字段交互。 最后，我们会进入模块15，深入探讨如何创建Visualforce页面。在这个模块中，我们会通过实际的例子来演示如何从头开始创建一个Visualforce页面，包括如何定义控制器、如何使用标准控制器和自定义控制器，以及如何将页面与Salesforce的其他功能集成。 好了，这就是我们今天要讨论的内容。希望你们能够通过这些学习，掌握创建和使用Visualforce页面的技能，从而在Salesforce中实现更加强大和灵活的数据展示和操作。如果有任何问题，随时提问，我们一起探讨解决。

  ▶ 播放视频 查看详情
• 309

  Tools for Creating a Visualforce Page

  第 392 页

  大家好，今天我们来聊聊创建Visualforce页面的工具。首先，我们有几种工具可以选择，包括内联编辑器、开发人员控制台、Force.com插件，以及用于Visual Studio代码的Salesforce扩展。 如果你刚刚开始，内联编辑器是个不错的选择。它非常直观，你做的任何更改都会立即显示出来，这样你就可以实时看到效果，非常适合快速调整和即时反馈。 如果你已经对Salesforce有了一定的了解，可能会更倾向于使用开发人员控制台。这个工具提供了更多的调试功能，帮助你更好地理解整个定制流程，从开始到结束。 对于需要将页面从一个环境迁移到另一个环境的开发者，Force.com IDE是个好帮手。它不仅提供了调试工具，还能帮助你管理和部署页面。此外，它也是与源代码控制系统集成的最佳选择。 当然，如果你只需要进行一些快速的小修改，你也可以直接在Salesforce的设置中找到开发|页面选项，直接在那里编辑Visualforce页面。 最后，市场上还有很多第三方工具，比如Mavensmate和aside.io等。每个开发者都有自己的偏好，你可以根据自己的需要和习惯选择最适合你的工具。 希望这些信息能帮助你在创建和编辑Visualforce页面时更加得心应手。如果你有任何问题，随时提问，我们一起来解决。

  ▶ 播放视频 查看详情
• 310

  Elements of a Visualforce Page: Visualforce Markup

  第 393 页

  让我们来聊聊Visualforce页面的元素和一些关键点。首先，Visualforce是Salesforce提供的一种标记语言，它允许你创建自定义的用户界面。你可以把它想象成一种速记方式，Salesforce会把这些标记转换成HTML页面，这样用户就能在浏览器中看到和使用这些页面了。 ### 1. ，对控制器的引用， 在Visualforce页面中，控制器就像是页面的“大脑”。它决定了页面的行为和数据的处理方式。你可以通过``标签的`controller`属性来引用一个控制器。比如： ```html ``` 这里的`MyCustomController`就是你自定义的Apex类，它负责处理页面的逻辑。 ### 2. ，静态资源的使用， 静态资源可以是图片、CSS文件、JavaScript文件等。你可以通过``或``标签来引用这些资源。比如： ```html ``` 这样，你就可以在页面中使用这些资源来美化页面或添加交互功能。 ### 3. ，包括Java脚本， JavaScript可以用来增强页面的交互性。你可以直接在Visualforce页面中嵌入JavaScript代码，或者通过外部文件引入。比如： ```html ``` 或者通过``标签引入外部的JavaScript文件。 ### 4. ，用于显示的标记， Visualforce提供了很多标签来帮助你显示数据。比如``、``等。这些标签可以帮助你快速构建复杂的UI。比如： ```html ``` 这段代码会生成一个表格，显示Opportunity的名称和金额。 ### 5. ，扩展类， 有时候，标准的控制器可能无法满足你的需求，这时你可以通过扩展类来增强控制器的功能。比如： ```apex public class OppExtension { public Case thisCase { get; set; } public List opps { get; set; } public OppExtension(ApexPages.StandardController controller) { thisCase = [SELECT AccountId FROM Case WHERE Id = :controller.getRecord().Id]; Account acc = [SELECT Name, (SELECT Name, Amount FROM Opportunities) FROM Account WHERE Id = :thisCase.AccountId]; opps = acc.Opportunities; } } ``` 在这个例子中，`OppExtension`类扩展了标准控制器的功能，允许你在页面中显示与某个Case相关的Opportunity数据。 ### 总结 编写Visualforce页面就像是用速记编写HTML一样，Salesforce会帮你把复杂的标记转换成用户友好的界面。通过引用控制器、使用静态资源、嵌入JavaScript以及使用各种显示标记，你可以快速构建出功能强大的自定义页面。 希望这些内容对你有帮助！如果有任何问题，随时问我哦！

  ▶ 播放视频 查看详情
• 311

  The Visualforce Component Reference

  第 394 页

  同学们，今天我们来聊聊Visualforce组件参考。Visualforce是Salesforce中用来构建自定义用户界面的强大工具。在Visualforce页面中，我们使用各种标签来创建和布局页面元素。 首先，你们可能会注意到，很多Visualforce标签都是以``开头的，比如``、``等。这些标签是Visualforce的核心，用来定义页面的结构、表单、按钮等。 但是，Visualforce不仅仅只有``标签。实际上，还有其他名称空间的标签，比如``。这些标签通常与Salesforce的特定功能相关。例如，``标签通常用于与Salesforce的Chatter功能集成，比如显示Feed、评论等。 当你在开发Visualforce页面时，可能会遇到需要实现某些特定功能的情况。这时，查看Visualforce组件参考会非常有帮助。你可以在参考中找到所有可用的标签，并了解它们的作用和用法。 所以，记住，Visualforce标签不仅仅是以``开头的，还有其他名称空间的标签可以帮助你实现更多功能。在开发过程中，多查阅Visualforce组件参考，会让你事半功倍。 好了，这就是今天关于Visualforce组件参考的简要介绍。希望这对你们有所帮助！如果有任何问题，随时问我。

  ▶ 播放视频 查看详情
• 312

  Expression Syntax

  第 395 页

  今天我们来聊聊Salesforce中的“卷发爆炸”语法，也就是我们常说的{!...}。这个语法非常有用，它告诉Salesforce，大括号里面的内容不是普通的文本，而是需要系统动态计算的东西。Salesforce会先计算这个表达式的值，然后用这个值替换掉整个“卷发爆炸”部分。 举个例子，如果你在页面上写{!Account.Name}，Salesforce会去查找当前记录的Account对象，并获取它的Name字段的值，然后把这个值显示在页面上。 在这个“卷发爆炸”里面，我们还可以用点符号来访问对象的字段和属性。比如，如果你有一个自定义对象叫MyObject__c，它有一个自定义字段叫MyField__c，你就可以这样写：{!MyObject__c.MyField__c}。注意，这里的__c表示这是自定义对象和自定义字段。如果是标准对象或标准字段，你就不需要加__c了。 另外，页面还可以访问一些全局数据，这些数据总是以$开头。比如，你可以用{!$User.FirstName}来获取当前用户的名字，或者用{!$Page.SomeField}来获取页面上的某个字段的值。 总结一下，“卷发爆炸”语法就是让Salesforce动态计算并显示数据的一种方式，你可以用它来访问对象的字段、属性，甚至是全局数据。希望这个解释能帮助你更好地理解和使用这个功能！

  ▶ 播放视频 查看详情
• 313

  15-1: Create a Simple Visualforce Page

  第 396 页

  同学们，今天我们来学习如何在Salesforce中创建一个简单的Visualforce页面。这个页面的目标是显示你的名字。听起来很简单，对吧？我们一步一步来。 首先，打开你的Salesforce开发者控制台。如果你还没有打开，可以在你的Salesforce界面的右上角找到它，点击“开发者控制台”就可以打开了。 接下来，我们要使用内联编辑器来创建Visualforce页面。在开发者控制台中，点击“文件”菜单，然后选择“新建”，再选择“Visualforce页面”。给这个页面起个名字，比如“MyNamePage”。 现在，你会看到一个空白的Visualforce页面。在这个页面上，我们可以添加一些静态文本。比如，我们可以写“你好，我的名字是：”。然后，我们需要添加一个对全局用户变量的引用，这样页面就能显示你的名字了。 在Visualforce页面中，我们可以使用表达式语言来引用全局变量。要显示你的名字，你可以使用`{!$User.FirstName}`。这个表达式会从当前登录的用户记录中提取名字。 所以，你的Visualforce页面代码看起来应该是这样的： ```html <h1>你好，我的名字是：{!$User.FirstName}</h1> ``` 这段代码创建了一个简单的页面，页面上有一个标题，标题后面跟着你的名字。 最后，保存你的页面，然后点击“预览”按钮，你就可以看到页面上显示你的名字了。 好了，这就是如何在Salesforce中创建一个简单的Visualforce页面来显示你的名字。整个过程应该不会超过10分钟。希望你们都能跟上，如果有任何问题，随时问我。我们下次再见！

  ▶ 播放视频 查看详情
• 314

  Module Agenda - 397

  第 397 页

  今天我们来聊聊Salesforce中的Visualforce页面。Visualforce是Salesforce提供的一种强大的工具，它允许我们创建自定义的用户界面，这些界面可以直接与Salesforce的数据交互。 首先，我们会从“了解Visualforce”开始。Visualforce使用一种类似于HTML的标记语言，但它更加强大，因为它可以直接与Salesforce的后端逻辑和数据模型集成。这意味着你可以创建出完全符合你业务需求的页面，而不仅仅是标准的Salesforce界面。 接下来，我们会进入“创建Visualforce页面”的部分。在这里，我会教你如何使用Visualforce的标记语言来构建页面。你会学习到如何定义页面的布局，如何添加输入字段，以及如何将页面与Salesforce的数据模型连接起来。 然后，我们会讨论“卸载记录数据并启动Visualforce页面”。这一部分会教你如何在Visualforce页面中处理数据，比如如何从Salesforce中检索数据，如何在页面上显示这些数据，以及如何将用户输入的数据保存回Salesforce。 最后，我们会有一个专门的模块，叫做“模块15：创建Visualforce页面”。在这个模块中，我们会通过一个实际的例子来综合运用之前学到的所有知识。你将有机会亲手创建一个完整的Visualforce页面，从设计到实现，一步步来。 通过这个课程，你将能够掌握创建自定义Salesforce页面的技能，这将大大增强你在Salesforce平台上开发应用的能力。希望你能享受这个学习过程，并从中获得实用的技能。

  ▶ 播放视频 查看详情
• 315

  Creating a Course Completion Certificate

  第 398 页

  同学们，今天我们来聊聊如何在Salesforce中创建一个课程完成证书。这个证书是为了表彰学员完成特定课程的学习。我们的目标是利用Course对象中的数据来构建这个证书，并决定如何启动这个页面。 首先，我们需要从Course对象中提取一些关键数据。这些数据可能包括课程名称、完成日期、学员姓名等。这些信息将直接显示在证书上，确保每个证书都是独一无二的，并且准确地反映了学员的成就。 接下来，我们需要决定如何启动这个证书页面。在Salesforce中，这通常涉及到创建一个自定义的Visualforce页面或者使用Lightning组件。我们可以设计一个按钮，当学员完成课程后，点击这个按钮就可以生成并查看他们的完成证书。 在设计这个页面时，我们要确保它既美观又实用。证书的设计应该简洁明了，突出显示关键信息，同时也要考虑到打印的便利性，因为很多学员可能希望打印出他们的证书作为纪念。 最后，我们还需要考虑如何自动化这个过程。我们可以设置一个触发器或者工作流，当Course对象中的某个字段（比如“课程状态”）更新为“完成”时，自动生成证书并发送给学员。 总之，创建课程完成证书是一个结合数据提取、页面设计和自动化流程的过程。通过精心设计和实施，我们可以为学员提供一个既专业又个性化的学习体验。希望这些信息对你们有所帮助，如果有任何问题，随时提问！

  ▶ 播放视频 查看详情
• 316

  Binding Data to Visualforce Controllers

  第 399 页

  让我们来聊聊如何在Visualforce页面中绑定数据到控制器。这个过程其实很简单，就像是在给一个故事设定主角一样。 首先，当你创建一个Visualforce页面时，你需要给它一个“主角”，也就是一个标准控制器。这个控制器就像是页面的导演，它决定了页面可以展示哪些数据和功能。当你把页面和控制器关联起来时，页面就能访问控制器所管理的对象的数据和方法了。 在这个控制器中，有一个特别重要的属性，叫做“记录”。这个记录就像是故事的主角，它包含了所有的关键信息。你可以通过URL传递一个记录ID给这个属性，这样页面就知道它需要展示哪一条记录了。 想象一下，控制器就像是一个顶级俱乐部，而记录就是俱乐部里的一个会员。通过URL参数，你可以指定哪个会员（记录）来参加这个聚会（页面）。当你设置了这个参数，你就是在告诉控制器和页面：“嘿，这个会员是我们今天的主角，所有的焦点都应该放在他身上。” 所以，简单来说，通过将记录ID作为URL参数传递，你可以将特定的记录绑定到控制器的记录属性上。这样，页面就能展示这条记录的详细信息了。这就是数据绑定到Visualforce控制器的基本过程，希望这能帮助你更好地理解这个概念。

  ▶ 播放视频 查看详情
• 317

  Launching Visualforce Pages

  第 400 页

  今天我们来聊聊如何在Salesforce中启动Visualforce页面。Visualforce页面是Salesforce中用来创建自定义用户界面的强大工具。我们可以通过几种不同的方式来启动这些页面，每种方式都有它自己的用途和场景。 首先，最简单的方式是通过URL直接访问。这种方式非常适合独立页面或者在开发过程中使用。你只需要知道页面的URL，就可以在任何浏览器中打开它。 接下来，如果你希望从某个记录中启动一个页面，并且希望它以弹出窗口的形式出现，那么你可以使用自定义按钮和链接。这种方式非常适合需要从特定记录快速访问额外信息的场景。 如果你想替换标准的视图或编辑页面，以添加一些自定义功能，比如快速编辑，那么你可以选择覆盖标准操作。这种方式允许你完全控制用户如何与数据交互。 如果你希望创建一个页面，让用户可以通过应用程序的标签快速访问，那么你可以使用自定义VF标签。这种方式非常适合那些需要频繁访问的页面。 还有一种方式是将Visualforce页面直接嵌入到页面布局中，这就是所谓的添加内联。这种方式可以让你的自定义页面与标准页面无缝集成。 对于快速自定义操作，特别是针对移动设备的操作，自定义操作是一个很好的选择。它可以让用户快速执行特定任务，而不需要离开当前页面。 最后，如果你专门为Salesforce Mobile创建页面，你可以创建一张手机卡。这种方式只能通过Salesforce Mobile访问，非常适合移动用户。 需要注意的是，虽然Visualforce页面可以在Salesforce Mobile中使用，但它们不会自动为移动设备重新设置样式。这意味着它们在移动设备上的外观可能与在Web界面上完全相同。如果你使用它们来覆盖标准操作或作为标签使用，这可能会带来一些问题。因此，如果你打算让你的Visualforce页面在移动设备上访问，最好控制相应的样式，可能使用CSS而不是带有自己样式的标签。 这就是启动Visualforce页面的几种主要方法。每种方法都有其特定的用途，选择合适的方法可以帮助你更好地满足业务需求。我们将在下一个模块中更详细地讨论这些方法，特别是如何在移动设备上优化Visualforce页面的样式和功能。

  ▶ 播放视频 查看详情
• 318

  Launching a Visualforce Page with a Custom Button

  第 401 页

  同学们，今天我们来聊聊一个在Salesforce Lightning Experience中可能会遇到的小问题。这个问题是关于自定义按钮和Visualforce页面的。 首先，我们知道在Salesforce中，我们可以创建自定义按钮来执行特定的操作，比如打开一个Visualforce页面。通常，我们会设置这个按钮的行为为“在新窗口中显示”，这样点击按钮后，页面就会在一个新的浏览器标签或窗口中打开。 但是，在Lightning Experience中，如果你设置了自定义按钮的行为为“在新窗口中显示”，并且这个按钮是用来启动一个Visualforce页面的，那么你可能会发现，页面并没有像预期的那样在新窗口中打开。这是一个已知的问题，Salesforce官方也已经确认了这一点。 这个问题可能会影响你的用户体验，因为用户可能期望点击按钮后页面会在新窗口中打开，但实际上并没有。所以，如果你在Lightning Experience中使用自定义按钮来启动Visualforce页面，并且希望它在新窗口中打开，你可能需要寻找其他的解决方案，或者等待Salesforce修复这个问题。 目前，你可以参考Salesforce官方提供的链接，那里有更多关于这个问题的详细信息，以及可能的解决方案或变通方法。希望这个小提示对你们有所帮助！如果有任何疑问，随时提问哦。

  ▶ 播放视频 查看详情
• 319

  15-2: Display Data in a Visualforce Page

  第 402 页

  让我们一步一步来完成这个任务。首先，我们需要在Visualforce页面中显示数据，并且使用一个预先存在的图像文件作为证书的横幅。这个任务听起来有点复杂，但别担心，我会带你一步步完成。 ### 第一步：上传预先存在的图像文件 1. 打开Salesforce，进入“设置”。 2. 在左侧的搜索栏中输入“文档”，然后点击“文档”。 3. 点击“新建文件夹”来创建一个新的文件夹，命名为“证书横幅”。 4. 点击“上传文件”，选择你预先准备好的图像文件，然后上传到这个文件夹中。 ### 第二步：使用开发人员控制台创建新的Visualforce页面 1. 打开开发人员控制台。你可以通过点击右上角的齿轮图标，然后选择“开发者控制台”来打开它。 2. 在开发者控制台中，点击“文件”菜单，选择“新建”，然后选择“Visualforce页面”。 3. 给页面命名，比如“CourseCompletionCertificate”。 4. 在编辑器中，编写Visualforce代码来显示证书内容。你可以使用以下代码作为起点： ```html <h1>课程完成证书</h1> <p>恭喜 {!Course__c.Student_Name__c} 完成了 {!Course__c.Course_Name__c} 课程。</p> ``` ### 第三步：创建自定义按钮以启动新的Visualforce页面 1. 回到Salesforce的设置页面，搜索“对象管理器”。 2. 找到并点击“课程”对象（假设你有一个自定义对象叫做“课程”）。 3. 在左侧菜单中选择“按钮、链接和操作”。 4. 点击“新建按钮或链接”。 5. 选择“Visualforce页面”作为内容源，然后选择你刚刚创建的“CourseCompletionCertificate”页面。 6. 设置按钮的标签和名称，比如“打印证书”。 7. 保存按钮，并将其添加到页面布局中。 ### 第四步：测试新页面 1. 回到Salesforce的主界面，找到一条课程记录。 2. 点击你刚刚添加的“打印证书”按钮。 3. 你应该能看到一个新的页面弹出，显示课程完成证书，并且使用了你上传的图像作为横幅。 这样，你就完成了在Visualforce页面中显示数据，并使用图像作为证书横幅的任务。希望这个过程对你来说既简单又有趣！如果有任何问题，随时问我。

  ▶ 播放视频 查看详情
• 320

  Key Takeaways - 403

  第 403 页

  让我们来聊聊Visualforce，这是Salesforce中一个非常强大的工具，它允许你自定义用户界面和业务逻辑。 首先，Visualforce是基于标签的标记语言，这意味着你可以使用类似于HTML的标签来构建页面。这些页面可以非常灵活地展示数据，并且可以包含复杂的业务逻辑。 Visualforce页面通常由两部分组成：视图和控制器。视图就是你看到的页面布局和样式，而控制器则负责处理数据和业务逻辑。控制器可以是标准的，也可以是自定义的。标准控制器提供了一些基本的功能，比如访问和操作标准对象的数据。如果你需要更复杂的功能，你可以创建自定义控制器。 标准控制器的一个好处是，它已经内置了对Salesforce标准对象的支持，比如Account、Contact等。这意味着你可以很容易地访问这些对象的数据，并执行常见的数据库操作，比如查询、插入、更新和删除。 Visualforce页面可以通过多种方式启动。比如，你可以创建一个自定义按钮，当用户点击这个按钮时，就会打开你的Visualforce页面。你也可以覆盖标准的操作，比如“新建”或“编辑”，这样当用户执行这些操作时，就会显示你的自定义页面。此外，你还可以创建一个自定义的Visualforce选项卡，这样用户就可以直接从导航栏访问你的页面。 总的来说，Visualforce是一个非常灵活的工具，可以帮助你根据业务需求定制Salesforce的用户界面和功能。通过使用标准控制器和自定义控制器，你可以轻松地访问和操作数据，并通过多种方式启动你的Visualforce页面。希望这些信息对你有帮助！

  ▶ 播放视频 查看详情
• 321

  Trailhead Homework - 404

  第 404 页

  今天我们来聊聊关于Salesforce的Trailhead家庭作业。Trailhead是一个非常棒的学习平台，特别是对于那些想要复习和提升PD1（Platform Developer 1）技能的同学来说。今天我要给大家介绍两个特别有用的模块，它们能帮助你们更深入地理解我们课堂上讨论的内容。 第一个模块是“Visualforce基础”。这个模块会带你了解Visualforce的基础知识，包括如何创建页面、使用控制器和如何将页面与Salesforce数据集成。这是理解Salesforce自定义界面开发的基础。 第二个模块是“快速入门：Visualforce”。这个项目模块更加实用，它会通过一系列的小任务，帮助你快速上手Visualforce的实际应用。你将学习如何创建和自定义Visualforce页面，以及如何使这些页面与Salesforce的数据和逻辑交互。 这两个模块都是作为家庭作业来完成的，不需要在课堂上做。你们可以在家里，按照自己的节奏来学习。完成这些模块不仅能帮助你们巩固课堂上学到的知识，还能让你们在实际操作中更加熟练。 记得，学习是一个逐步积累的过程，不要急于求成。慢慢来，确保每一步都理解透彻。如果在学习过程中遇到任何问题，随时可以来问我。加油，我相信你们都能做得很好！

  ▶ 播放视频 查看详情
• 322

  Module 16: Exploring the View and Controller Layers of Visualforce

  第 405 页

  今天我们来聊聊Salesforce中的视图和控制器，以及它们如何共同工作来构建强大的用户界面。这部分内容非常有趣，因为它直接关系到用户如何与Salesforce系统互动。 首先，让我们从“视图”开始。在Salesforce中，视图就是用户看到的页面布局。这包括所有的按钮、字段、表格和任何其他用户界面元素。你可以把视图想象成一个舞台，所有的演员（数据）都在这里表演。视图的设计决定了用户如何浏览和操作数据。 接下来是“控制器”。控制器是背后的逻辑处理者。它决定了当用户点击一个按钮或者输入数据时，系统应该如何反应。控制器处理所有的业务逻辑，比如验证数据、调用其他服务或者更新数据库。你可以把控制器看作是导演，它指导演员（数据）在舞台（视图）上如何表演。 现在，让我们谈谈“视觉力量的层次”。这指的是视图和控制器如何分层工作，以提供强大而灵活的用户体验。在Salesforce中，这种分层允许开发者创建既美观又功能强大的应用程序。视图层专注于展示和用户交互，而控制器层则处理所有的后台逻辑。这种分离使得开发更加模块化，也更容易维护和更新。 举个例子，假设你有一个销售机会的页面。视图层会展示机会的名称、金额、阶段等信息，而控制器层则负责当用户更改机会阶段时，自动更新相关的字段或触发其他业务流程。 总之，理解视图和控制器的关系以及它们如何分层工作，对于构建高效、用户友好的Salesforce应用程序至关重要。希望这能帮助你更好地掌握Salesforce的视觉力量层次！

  ▶ 播放视频 查看详情
• 323

  Exploring the View and Controller Layers of Visualforce

  第 406 页

  让我们一起来探索如何在Salesforce中创建一个Visualforce页面，这个页面将帮助我们一目了然地查看技术人员的状态。我们将分几个简单的步骤来完成这个任务。 首先，我们需要创建一个Visualforce页面。你可以把它想象成一个网页，这个网页将展示我们想要的信息。在Salesforce中，你可以通过开发者控制台或者直接在设置中创建一个新的Visualforce页面。给这个页面起一个名字，比如“TechnicianStatusPage”。 接下来，我们需要在这个页面上显示相关的数据。这些数据包括技术人员的认证信息、他们注册的课程以及他们正在进行的任何认证。为了实现这一点，我们需要使用Visualforce的标记语言来定义页面的布局和内容。你可以使用标签来定义页面的基本结构，然后使用或者来显示具体的字段数据。 然后，我们需要重复标准控制器的操作。标准控制器是Salesforce提供的一个功能，它允许我们轻松地与标准对象（如技术人员记录）进行交互。通过使用标准控制器，我们可以轻松地实现记录的查看、编辑和删除操作。在Visualforce页面中，你可以使用标签来创建一个表单，然后使用来添加按钮，比如“编辑”按钮，这样用户就可以直接在这个页面上编辑技术人员的记录。 最后，我们需要确保这个页面允许用户轻松地导航到相关的记录。你可以使用和来创建一个表格，显示技术人员的列表。然后，你可以为每个技术人员添加一个链接，点击这个链接就可以导航到他们的详细记录页面。 通过以上步骤，你就可以创建一个Visualforce页面，这个页面不仅能够清晰地展示技术人员的状态，还能让用户轻松地进行导航和编辑操作。希望这个解释对你有帮助，如果你有任何问题，随时问我！

  ▶ 播放视频 查看详情
• 324

  Module Agenda - 407

  第 407 页

  同学们，今天我们来聊聊Salesforce的几个重要模块。首先，我们来看一下“模块议程”。这个模块主要是帮助我们了解整个课程的结构和每个部分的学习目标。这样，我们就能更好地规划学习时间，确保每个知识点都能掌握。 接下来是“相关记录上的删除数据”。在这个模块中，我们会学习如何在Salesforce中安全地删除数据。删除数据听起来简单，但在Salesforce中，我们需要特别注意数据的关系和依赖。我们会学习如何检查相关记录，确保删除操作不会影响到其他数据。 然后，我们会进入“探索Visual force标签和内置造型”。Visual force是Salesforce中用于创建自定义用户界面的强大工具。在这个模块中，我们会学习如何使用Visual force标签来构建页面，以及如何利用内置的样式来美化我们的界面。这样，我们就能创建出既功能强大又美观的页面。 最后，我们会进入“模块16：探索Visual force的视图和控制器层”。这个模块会深入探讨Visual force的视图和控制器。视图是我们看到的页面，而控制器则是背后的逻辑。我们会学习如何将两者结合起来，创建出动态、交互性强的页面。通过这个模块，大家将能够更好地理解Visual force的工作原理，并能够自己动手创建复杂的页面。 好了，这就是我们今天要学习的内容。希望大家能够跟上节奏，有任何问题随时提问。我们开始吧！

  ▶ 播放视频 查看详情
• 325

  Traversing an sObject Relationship in an Expression

  第 408 页

  今天我们来聊聊在Salesforce中如何通过表达式穿越对象关系。这个技巧在开发自定义页面或者处理复杂数据时非常有用。 首先，想象一下Salesforce中的数据就像是一栋大楼，每一层都代表一个对象，比如客户、订单、产品等。这些对象之间通过关系连接，就像大楼里的楼梯和电梯。 当你使用标准控制器时，你可以通过表达式语法轻松地从一个对象“走”到另一个对象，获取你需要的数据。这就像是你在大楼里从一个房间走到另一个房间，不需要额外的工具。 但是，有时候你需要的数据可能不在标准控制器提供的路径上。这时候，你就需要编写自定义控制器或者控制器扩展。这就像是你要去一个没有电梯的楼层，你需要自己找到楼梯或者建造一个新的通道。 在自定义控制器中，你可以使用SOQL查询来引入你需要的额外数据。这就像是你在大楼里安装了一个新的电梯，可以直接到达你想要去的任何楼层。 在穿越对象关系时，你可以进行方向上的改变。比如，如果你的数据模型包含多层关系，你可以从父对象向下穿越到子对象，然后再从子对象向上穿越到更上层的对象。这就像是你在大楼里从顶层下到地下室，然后再从地下室上到另一个顶层。 总之，通过表达式穿越对象关系，你可以灵活地访问和操作Salesforce中的数据，就像是在一栋大楼里自由穿梭一样。希望这个比喻能帮助你更好地理解这个概念。如果有任何问题，随时问我哦！

  ▶ 播放视频 查看详情
• 326

  Determining Which Controller to Use

  第 409 页

  让我们一步一步来理解这个问题。首先，我们需要确定在Salesforce中，哪些页面可以使用标准控制器，哪些需要自定义控制器。 ，第一页：显示课程名称、日期和学生的班级名册。， - 这里你可以使用标准的课程交付控制器。这个控制器已经内置了处理课程和班级名册的功能，所以你可以直接使用它来创建这个页面。 ，第二页：显示所有相关的认证尝试和认证记录上的认证。， - 对于这个页面，标准控制器可能就不够用了。因为你需要显示的是认证尝试和认证记录，这些可能涉及到更复杂的数据关系和逻辑处理。所以，这里你可能需要下降两个级别，使用自定义控制器来满足需求。 ，第三页：技术员状态页面，显示技术员姓名、雇主名称、持有的证书和参加的课程。， - 这个页面可以使用标准的联系人控制器。因为技术员的信息通常与联系人对象相关联，标准的联系人控制器已经能够处理这些信息。我们在这个模块中就会创建这样一个页面。 总结一下： - 第一页：使用标准课程交付控制器。 - 第二页：需要自定义控制器。 - 第三页：使用标准联系人控制器。 希望这样解释能帮助你更好地理解如何选择和使用控制器。如果有任何疑问，随时问我！

  ▶ 播放视频 查看详情
• 327

  Creating a Technician Status Page

  第 410 页

  今天我们来聊聊如何在Salesforce中创建一个技术员状态页面，并且如何通过这个页面来展示技术员已经注册的课程列表。 首先，想象一下，你有一个技术员，他可能已经注册了多门课程。你希望在一个页面上，不仅能看到这个技术员的基本信息，还能一目了然地看到他所有注册的课程。这就是我们今天要做的。 在Salesforce中，我们可以使用Visualforce页面来实现这个功能。Visualforce是Salesforce提供的一种强大的工具，它允许我们创建自定义的用户界面。 在这个例子中，我们会在页面的顶部使用一个叫做``的标签。这个标签非常有用，它可以自动显示一个记录的所有详细信息，比如技术员的名字、联系方式等。你不需要手动去编写代码来显示这些信息，Salesforce会帮你自动完成。 接下来，我们会在页面的下方展示技术员已经注册的课程列表。这个列表是通过另一个Visualforce组件来实现的，它会查询并显示所有与技术员相关的课程记录。 虽然这个页面目前看起来可能不是最终版本，但它已经具备了基本的功能。在接下来的练习中，我们会进一步完善这个页面，比如添加更多的交互功能或者美化页面布局。 所以，现在你可以花几分钟时间浏览一下这个目标页面，看看它是如何工作的。你会发现，通过使用``标签和自定义的课程列表，我们可以轻松地创建一个既实用又直观的技术员状态页面。 这就是今天的内容，希望你能理解并喜欢这个简单的教程。如果有任何问题，随时提问哦！

  ▶ 播放视频 查看详情
• 328

  How Can You Display Child Records in a Visualforce Page?

  第 411 页

  让我们来聊聊如何在Visualforce页面中显示子记录。想象一下，你有一本相册，里面有很多照片。每一张照片都是相册中的一个子记录。现在，你想在Visualforce页面上展示这些照片，就像翻看相册一样。 在Visualforce中，我们使用一种叫做“迭代器标记”的东西来实现这个功能。这就像是一个“for循环”，它会自动帮你翻看每一张照片，并展示出来。 首先，你需要在Visualforce页面上定义一个集合，这个集合就是你的相册，里面包含了所有的照片。然后，你为这个集合选择一个变量名，比如“photo”。这个变量名就像是你在翻看相册时，当前看到的那张照片的标签。 接下来，在迭代器标记的内部，你可以使用这个变量名来引用当前照片的详细信息，比如照片的名字、拍摄日期等。Visualforce页面会自动遍历集合中的每一张照片，并为每一张照片重复展示这些信息。 举个例子，假设你有一个相册集合叫做“album”，你可以这样写代码： ```html ``` 在这个例子中，`value=&quot;{!album}&quot;` 指定了你要展示的集合是“album”，而 `var=&quot;photo&quot;` 则定义了当前照片的变量名。`` 标签则用来展示每张照片的名字和拍摄日期。 通过这种方式，Visualforce页面会像翻看相册一样，自动展示每一张照片的详细信息。希望这个比喻能帮助你更好地理解如何在Visualforce页面中显示子记录。如果你还想了解更多细节，可以参考《Visualforce组件参考》，里面有更多详细的例子和用法说明。

  ▶ 播放视频 查看详情
• 329

  Classic vs. Lightning Styling

  第 412 页

  今天我们来聊聊Salesforce中的Visualforce页面，特别是关于如何在Classic和Lightning Experience两种界面风格之间切换的要点。 首先，Visualforce页面默认是以Classic的外观来渲染的。这意味着，如果你不进行任何特别的设置，你的页面会看起来像是Salesforce的旧版界面，也就是Classic风格。 但是，如果你想让你的页面在Lightning Experience中看起来更现代、更符合新的设计风格，你可以通过一个简单的设置来实现。你只需要在Visualforce页面的标签中添加一个属性，叫做lightningStylesheets，并将其值设置为“true”。这样，当用户在Lightning Experience中查看这个页面时，页面就会自动应用Lightning的设计风格。 不过，这里有一个重要的注意事项：这个lightningStylesheets属性只在Lightning Experience中有效。如果用户是在Classic界面中查看这个页面，那么这个属性就不会起作用，页面还是会以Classic的样式显示。 这个功能在2018年夏天变得普遍可用。在此之前，开发人员需要手动应用CSS类来实现类似的效果，但现在，Salesforce已经为我们简化了这个过程。 如果你对这个功能感兴趣，或者想要了解更多细节，你可以访问Salesforce的官方文档，那里有更详细的说明和示例。 希望这个简单的解释能帮助你理解如何在Visualforce页面中切换Classic和Lightning Experience的界面风格。如果你有任何问题，随时欢迎提问！

  ▶ 播放视频 查看详情
• 330

  How Should We Launch This Page?

  第 413 页

  让我们来聊聊如何启动这个页面。首先，我们可以通过自定义按钮或链接来启动页面。这个方法非常简单，你只需要在页面布局中添加一个按钮或链接，就可以直接从任何记录启动页面了。而且，这个按钮或链接在移动设备上也能正常显示，非常方便。 如果你希望协调员总是能看到新的视图，而不需要每次都点击按钮来启动它，那么你可以考虑覆盖标准的操作。这样，页面就会自动显示新的视图，而不是标准的联系人布局。不过，这里有个小问题，就是它会覆盖所有记录类型的视图，除非你为不同的记录类型设置不同的VF页面来重定向。另外，如果你有移动用户，页面覆盖可能会带来一些问题。所以，最佳实践是，除非你确定希望在所有环境下都使用这个页面，否则最好不要使用覆盖。 还有一个方法是使用自定义VF页签，但这个方法不太适合我们，因为它不会将页面与特定的记录关联起来，而我们通常需要显示特定的记录。 最后，我们还可以考虑在页面布局中使用内联的方式，但这会导致信息大量重复，所以也不是很理想。 总的来说，最简单直接的方法还是使用自定义按钮或链接来启动页面。希望这些信息对你有帮助！

  ▶ 播放视频 查看详情
• 331

  16-1: Create a Simple Technician Status Page

  第 414 页

  同学们，今天我们来学习如何创建一个简单的技术员状态页面。这个页面会显示技术员的姓名、他们所属的账户名称，以及他们注册的课程。我们还会在技术员的页面布局上添加一个自定义按钮，用来启动这个页面。最后，我们会测试这个新页面，确保一切运行正常。 首先，我们需要一个记录来作为开发的上下文。这个记录可以是任何技术员的记录，我们会在开发过程中使用它来测试我们的页面。 接下来，我们开始创建技术员状态页面。这个页面会使用一个自定义的Visualforce页面来显示信息。我们会在这个页面上添加几个字段：技术员的姓名、账户名称和注册的课程。这些信息会从Salesforce的数据库中提取出来，显示在页面上。 然后，我们需要在技术员的页面布局上添加一个自定义按钮。这个按钮的作用是启动我们刚刚创建的Visualforce页面。当我们设置这个按钮时，Salesforce会提供一个下拉列表，让我们选择要启动的页面。这是因为我们在创建Visualforce页面时指定了一个控制器，这个控制器决定了页面的行为和显示的内容。 最后，我们需要测试这个新页面。我们会在Salesforce中导航到技术员的记录，点击我们添加的自定义按钮，看看页面是否正确显示了技术员的姓名、账户名称和注册的课程。 这就是我们今天要完成的任务。整个过程大约需要15分钟。让我们一起动手，创建一个简单但功能齐全的技术员状态页面吧！

  ▶ 播放视频 查看详情
• 332

  Module Agenda - 415

  第 415 页

  今天我们来聊聊Salesforce中的几个重要模块。首先，我们来看一下模块议程。这个议程会帮助我们了解接下来要学习的内容，确保我们不会遗漏任何重要的知识点。 接下来，我们会讨论如何在相关记录上删除数据。这是一个非常实用的技能，因为在Salesforce中，数据管理是非常关键的。我们会学习如何安全、有效地删除不再需要的数据，同时确保不会影响到其他相关的记录。 然后，我们会探索Visualforce标签和内置造型。Visualforce是Salesforce中用来创建自定义用户界面的强大工具。通过使用各种标签和内置的样式，我们可以设计出既美观又功能强大的页面，提升用户体验。 最后，我们会进入模块16，深入探索Visualforce的视图和控制器层。视图层负责展示数据，而控制器层则负责处理业务逻辑。理解这两层的工作原理，对于我们构建复杂的自定义应用至关重要。 好了，这就是我们今天要学习的内容。希望大家能够跟上节奏，如果有任何问题，随时提问。我们开始吧！

  ▶ 播放视频 查看详情
• 333

  Refine the Technician Status Page

  第 416 页

  同学们，今天我们来聊聊如何完善技术人员状态页面。这个页面主要是用来展示技术人员的工作状态和相关信息。我们的目标是让这个页面更加简洁、直观，同时提供一些实用的功能，比如快速导航到相关的课程交付记录。 首先，我们来看一下当前的页面。页面上可能显示了很多字段，有些可能并不是我们经常需要的。为了优化用户体验，我们可以选择只显示那些最关键的字段。比如，技术人员的姓名、职位、当前状态等。这样，页面看起来会更加清爽，用户也能更快地找到他们需要的信息。 接下来，我们可以在页面上添加一个“编辑”按钮。这个按钮的作用是让用户能够快速编辑技术人员的记录。比如，如果技术人员的状态发生了变化，用户可以直接点击这个按钮进行更新，而不需要跳转到其他页面。 最后，我们还可以为每个注册的课程添加一个链接。这个链接会直接指向该课程的交付记录页面。这样，用户就可以轻松地查看每个课程的具体情况，而不需要在系统中到处寻找。 总结一下，优化后的技术人员状态页面会更加简洁、功能更加强大。用户可以通过这个页面快速获取信息、编辑记录，并且轻松导航到相关的课程交付记录。希望这些改进能让你们的工作更加高效！

  ▶ 播放视频 查看详情
• 334

  Coarse- vs. Fine-Grained Visualforce Tags

  第 417 页

  让我们来聊聊Salesforce中的Visualforce标签，特别是粗粒度和细粒度标签的区别和使用。 首先，想象一下你在设计一个Salesforce页面。粗粒度的Visualforce标签就像是给你一个大块的积木，你可以用它来快速搭建页面的主要部分。比如，这个标签，它就像是一个大盒子，里面装满了记录的详细信息，包括字段、相关列表等等。你只需要把这个标签放到页面上，Salesforce就会自动帮你展示所有的内容。而且，这个标签还有一些属性，比如你可以设置是否允许内联编辑，或者是否显示相关列表，这样你就可以轻松地控制页面的外观和行为。 但是，有时候你可能想要更精细地控制页面的布局和内容。这时候，细粒度的Visualforce标签就派上用场了。这些标签就像是小块的积木，你可以用它们来精确地构建页面的每一个部分。比如，和标签，它们允许你选择特定的字段，并决定它们在页面上的位置和样式。这样，你就可以完全按照自己的需求来设计页面了。 现在，假设我们决定用一些标签来替换标签。这样做的好处是，我们可以更灵活地控制页面的布局和内容。但是，这样做也会带来一个问题：我们会丢失标签自带的编辑按钮。别担心，下一张幻灯片我们会教你如何重新添加这个功能。 总之，粗粒度和细粒度的Visualforce标签各有各的用途。粗粒度标签适合快速搭建页面的主要部分，而细粒度标签则适合精细控制页面的每一个细节。希望这个解释能帮助你更好地理解和使用这些标签！

  ▶ 播放视频 查看详情
• 335

  How Can You Call Action Methods?

  第 418 页

  同学们，今天我们来聊聊如何在Visualforce页面中调用行动方法。首先，我们需要了解的是，有六个警告感知标签可以帮助我们实现这一点。但今天，我们主要关注两个最常用的标签：命令按钮（CommandButton）和命令链接（CommandLink）。 想象一下，你正在设计一个页面，用户需要保存他们的输入。你可能会问：“我该如何设置这个按钮，让它调用保存操作呢？”很简单，你只需要在命令按钮或命令链接的`action`属性中指定你想要执行的操作。比如，如果你想调用保存操作，你可以这样写： ```html ``` 这里的`{!save}`就是调用保存操作的方法。 接下来，如果你想让用户删除某个记录，你可以这样设置： ```html ``` 同样，`{!delete}`就是调用删除操作的方法。 现在，让我们来谈谈保存和快速保存的区别。保存操作（`save`）在更新记录后会将用户重定向到另一个页面，通常是记录的详情页。而快速保存（`quickSave`）则会在更新记录后，让用户留在当前页面，不会进行页面跳转。这在用户需要连续输入多个记录时非常有用。 所以，如果你想让用户保存后继续留在当前页面，你可以这样写： ```html ``` 希望这些信息对你们有帮助！如果有任何问题，随时提问哦！

  ▶ 播放视频 查看详情
• 336

  Navigating with Output Links

  第 419 页

  今天我们来聊聊如何在Salesforce的Visualforce页面中使用标签来创建链接。这个标签可以帮助我们生成HTML链接，并且非常灵活，可以用在很多不同的场景中。 首先，标签的主要作用是在页面上创建一个链接。你可以把链接指向Salesforce内部的记录视图，也可以指向外部的URL。这个标签的`value`属性会被转换成HTML中的`href`属性，也就是链接的目标地址。 举个例子，假设你想在页面上创建一个链接，点击后可以查看某个记录的详细信息。你可以这样做： ```html 查看记录 ``` 这里，`{!recordId}`是一个动态的值，表示当前记录的ID。当页面渲染时，Salesforce会自动把这个ID替换成实际的记录ID，生成一个完整的URL。 不过，Salesforce推荐使用第二种方法，也就是使用`URLFOR`函数来生成链接。虽然这种方法写起来稍微长一点，但它更灵活，也更安全。比如： ```html 查看账户 ``` 在这个例子中，`URLFOR`函数生成了一个指向账户记录的查看页面的链接。这样做的好处是，即使Salesforce将来改变了URL的结构，你的代码仍然可以正常工作。 除了链接到记录视图，你还可以用`URLFOR`函数链接到其他Visualforce页面、静态资源，甚至是压缩文件。比如： ```html 跳转到另一个页面 查看图片 ``` 第一个例子中，链接会跳转到另一个Visualforce页面；第二个例子中，链接会指向一个静态资源中的图片。 最后，如果你想了解更多关于标签和`URLFOR`函数的详细信息，可以参考Salesforce的官方文档。文档里有很多实用的例子，可以帮助你更好地理解和使用这些功能。 希望这些内容对你有帮助！如果有任何问题，随时问我哦。

  ▶ 播放视频 查看详情
• 337

  16-2: Refine Your Page and Add Navigational Links

  第 420 页

  让我们来聊聊如何在Salesforce中优化页面并添加导航链接和热门标签。首先，想象一下你有一个页面，上面有两个相关的列表。这两个列表是相互关联的，但有一个列表需要先显示它的父列表，才能填充数据。这就是我们所说的依赖字段。 为了处理这种情况，我们可以使用内联编辑功能。内联编辑允许用户直接在页面上编辑记录，而不需要跳转到另一个页面。这大大提高了用户体验。 在Salesforce中，我们通常使用PageBlockTable或DataTable来展示这些列表。这两个组件都是迭代组件，这意味着它们可以遍历一组记录，并将每条记录显示在表格中。你可以先获取第一组记录，然后将它们放入PageBlockTable中。然后，你可以在这个范围内进行更多的遍历，比如从每条记录中获取更多的信息。 至于导航链接和热门标签，你可以将它们添加到页面上，帮助用户快速找到他们需要的信息。这些链接和标签可以指向特定的记录或页面，让用户能够轻松地浏览和查找数据。 最后，虽然这个模块可能涉及到一些复杂的概念，比如快速查询参数和默认操作组件，但这些都是为了帮助你更好地管理和展示数据。通过理解和应用这些概念，你可以创建出更加高效和用户友好的Salesforce页面。 希望这些信息对你有帮助！如果你有任何问题，随时问我。

  ▶ 播放视频 查看详情
• 338

  Key Takeaways - 421

  第 421 页

  今天我们来聊聊Salesforce中的一些关键要点，特别是关于Visualforce页面的部分。我会尽量用简单易懂的语言来解释，这样你们听起来也会更轻松。 首先，Visualforce是Salesforce用来构建用户界面的一个强大工具。你可以把它想象成一个画布，你可以在上面画出你想要的页面布局和功能。 ### 1. 表达语法 在Visualforce中，你可以使用一种叫做“表达语法”的东西，来从与当前对象相关的其他对象中检索数据。这就像是你有一个朋友，你可以通过他找到他朋友的联系方式一样。这种语法让你能够轻松地获取和显示相关数据。 ### 2. 集合标签 接下来，我们来看看几个常用的Visualforce标签，这些标签可以帮助你处理集合数据（比如列表、表格等）： - ，，：这个标签可以用来创建一个表格，显示一组数据。你可以把它想象成一个Excel表格，每一行代表一条记录，每一列代表一个字段。 - ，，：这个标签和类似，但它更灵活，你可以自定义表格的样式和布局。 - ，，：这个标签用来显示一个列表，适合展示简单的数据集合。 - ，，：这个标签可以让你重复显示某个元素，比如在一个列表中重复显示每一条记录。 ### 3. 操作感知标签 在Visualforce中，你还可以使用一些“操作感知标签”来调用控制器中的方法。这些标签就像是按钮或链接，点击它们时，会触发后台的某些操作。 - ，，：这是一个按钮，点击它时，可以执行某个操作，比如保存数据或提交表单。 - ，，：这是一个链接，点击它时，也可以触发某个操作。 - ，，：这个标签可以定时执行某个操作，比如每隔几秒钟刷新一次页面。 - ，，：这个标签可以让你在某个事件发生时（比如点击或鼠标悬停）触发一个操作。 - ，，：这个标签可以让你在JavaScript中调用控制器的方法。 ### 4. 标签 最后，别忘了标签，它是每个Visualforce页面的根标签。你可以把它想象成一个页面的“外壳”，所有的内容都要放在这个标签里面。 --- 总结一下，今天我们学习了如何在Visualforce中使用表达语法来获取相关数据，以及如何使用一些常用的标签来处理集合数据和触发操作。希望这些内容对你们有帮助！如果有任何问题，随时问我哦！

  ▶ 播放视频 查看详情
• 339

  Module 17: Working with Custom Controllers and Controller Extensions

  第 422 页

  今天我们来聊聊Salesforce中的自定义控制器和控制器扩展。这两个概念听起来可能有点技术性，但其实它们是为了帮助我们更好地控制和管理页面上的数据和逻辑。 首先，，自定义控制器，是什么？简单来说，它是一个Apex类，专门用来处理Visualforce页面的逻辑。Salesforce自带的标准控制器已经可以处理很多常见的操作，比如保存记录、删除记录等。但有时候，我们需要一些更复杂的逻辑，或者想要自定义页面的行为，这时候就可以用自定义控制器来替代标准控制器。 举个例子，假设我们有一个页面，需要根据用户的输入动态生成一些数据，或者需要调用外部API来获取信息。这些操作标准控制器是做不到的，但自定义控制器可以轻松实现。 接下来是，控制器扩展，。控制器扩展其实是对标准控制器或自定义控制器的扩展。它允许我们在不改变原有控制器的情况下，添加新的功能或逻辑。你可以把它想象成一个“插件”，给现有的控制器增加一些额外的能力。 比如，假设我们有一个标准控制器，它已经可以处理记录的基本操作，但我们还想在页面上显示一些额外的信息，或者添加一些自定义的按钮操作。这时候，我们就可以创建一个控制器扩展，来添加这些功能，而不需要重写整个控制器。 总结一下： - ，自定义控制器，：完全由你编写的Apex类，用来处理页面的逻辑，适合需要高度自定义的场景。 - ，控制器扩展，：用来扩展标准控制器或自定义控制器的功能，适合在现有控制器基础上添加新功能。 这两个工具都非常强大，可以帮助我们构建更灵活、更复杂的Visualforce页面。希望这个解释能让你对它们有更清晰的理解！

  ▶ 播放视频 查看详情
• 340

  Extending Standard Controllers

  第 423 页

  让我们来聊聊如何在Salesforce中扩展标准控制器。想象一下，标准控制器就像是一个基础工具包，它已经帮我们处理了很多常见的任务，比如查看、编辑和保存记录。但有时候，我们需要一些额外的功能，这时候就需要扩展标准控制器了。 首先，我们需要创建一个控制器扩展。这个扩展就像是一个附加的工具包，它可以帮助我们添加一些标准控制器没有的功能。比如，你可能想在用户点击一个按钮时执行一些特殊的逻辑，或者根据某些条件动态地改变页面的显示内容。 接下来，我们需要创建一个自定义控制器。这个控制器是完全由我们自己编写的，它不依赖于标准控制器。自定义控制器给了我们更大的灵活性，可以完全按照我们的需求来处理数据和逻辑。 然后，我们需要与属性一起工作。属性就像是控制器中的变量，它们可以存储数据，并且可以在Visualforce页面中使用。比如，你可以创建一个属性来存储当前用户的名称，然后在页面上显示出来。 使用页面引用是另一个重要的部分。页面引用可以帮助我们在用户执行某些操作后，将他们重定向到另一个页面。比如，当用户保存了一个记录后，你可能希望将他们带回到记录列表页面。 最后，我们需要在Visualforce页面中初始化自定义方法。这些方法可以在页面加载时自动执行，或者在用户执行某些操作时触发。比如，你可以在页面加载时自动填充一些默认值，或者在用户点击按钮时执行一些复杂的逻辑。 总结一下，扩展标准控制器可以帮助我们添加一些标准控制器无法提供的功能。通过创建控制器扩展、自定义控制器、与属性一起工作、使用页面引用以及在Visualforce页面中初始化自定义方法，我们可以实现更复杂和个性化的功能。希望这些内容对你有帮助！

  ▶ 播放视频 查看详情
• 341

  Module Agenda - 424

  第 424 页

  今天我们来聊聊Salesforce中的自定义控制器和控制器扩展。这部分内容听起来可能有点技术性，但别担心，我会用简单的方式来解释。 首先，什么是自定义控制器和控制器扩展呢？简单来说，它们就像是Salesforce页面的“大脑”，控制着页面上发生的事情。比如，当用户点击一个按钮时，控制器决定了接下来会发生什么。 接下来，我们来看看Getters和Setters。这两个词听起来可能有点复杂，但其实它们就是用来获取和设置数据的。比如，你有一个文本框，用户在里面输入了名字，Getters就是用来获取这个名字的，而Setters则是用来设置这个名字的。 然后，我们还有行动方法。这些方法就像是控制器中的“动作”，当用户做了某些事情（比如点击按钮）时，这些方法就会被调用，执行一些特定的操作。 当然，处理错误也是很重要的一部分。在编程中，错误是难免的，但我们可以通过编写代码来优雅地处理这些错误，确保用户不会看到一堆看不懂的错误信息。 最后，我们来说说返回空而不是PageReference的情况。在一些高级场景中，比如使用Ajax技术时，我们可能不需要跳转到新的页面，而是只需要更新当前页面的一部分内容。这时候，返回空就是合适的。 好了，这就是今天的内容。希望你们能对自定义控制器和控制器扩展有一个基本的了解。如果有任何问题，随时问我哦！

  ▶ 播放视频 查看详情
• 342

  Referencing Custom Controller Code

  第 425 页

  让我们来一步步看看如何实现这个需求。首先，我们需要理解的是，Visualforce页面是Salesforce中用来创建自定义用户界面的工具。而控制器则是用来处理页面逻辑和数据交互的。 在这个案例中，我们需要在账户页面布局上显示与该账户相关的技术人员持有的所有认证。卡西·埃文斯已经为我们编写了获取这些数据所需的控制器扩展。我们的任务就是在Visualforce页面中引用这个控制器扩展。 首先，我们需要创建一个新的Visualforce页面。在Salesforce中，你可以通过设置菜单找到“开发”部分，然后选择“Visualforce页面”来创建新页面。 创建页面时，我们需要指定一个控制器。这里，我们不需要从头编写控制器，而是使用卡西已经写好的控制器扩展。在页面的顶部，我们会使用``标签来定义页面，并通过`controller`属性来指定我们的控制器扩展。例如： ```html ``` 这里的`YourControllerExtension`应该替换为卡西提供的实际控制器扩展的名称。 接下来，我们需要在页面上显示数据。我们可以使用``和``等标签来组织数据的显示。例如： ```html ``` 在这个例子中，`{!certifications}`是控制器扩展中返回认证列表的方法或属性。`var=&quot;cert&quot;`定义了在表格中每一行的变量名，我们可以通过这个变量来访问每一行的数据。 最后，我们需要将这个Visualforce页面添加到账户页面布局中。这可以通过页面布局编辑器来完成，将Visualforce页面作为一个组件拖放到布局的适当位置。 这样，当用户查看账户页面时，他们就能看到与该账户相关的技术人员持有的所有认证了。希望这个解释对你有帮助！如果有任何疑问，随时提问。

  ▶ 播放视频 查看详情
• 343

  Why Can’t You Use a Standard Controller?

  第 426 页

  今天我们来聊聊为什么有时候我们不能使用标准控制器，以及什么时候我们需要考虑使用自定义控制器或控制器扩展。 首先，标准控制器在Salesforce中是一个非常方便的工具，它允许我们进行一些基本的操作，比如查看、编辑、删除记录等。这些操作通常是在我们处理单一对象的数据时使用的。标准控制器还能帮我们处理一些简单的数据关系，比如删除一个对象下方一级内的数据，或者删除对象上方五个级别内的数据。 但是，标准控制器也有它的局限性。比如说，如果你需要处理的数据来自另一个完全不相关的对象，或者数据关系比当前对象高出五个级别以上，这时候标准控制器就帮不上忙了。因为这些情况超出了标准控制器的处理范围。 在这种情况下，我们就需要用到自定义控制器或控制器扩展了。自定义控制器和控制器扩展给了我们更多的灵活性。比如，我们可以使用它们来调用HTTP服务或Web服务，这样就能处理更复杂的数据交互。此外，自定义控制器还能让我们更好地控制页面上信息的展示方式，比如决定哪些信息显示给用户，哪些不显示。 总结一下，标准控制器适合处理简单的、单一对象的数据操作。但当我们需要处理更复杂的数据关系，或者需要与外部系统交互时，就需要使用自定义控制器或控制器扩展了。这样我们就能更灵活地控制我们的应用，满足更复杂的需求。 希望这个解释能帮助你理解为什么有时候我们不能使用标准控制器，以及什么时候应该考虑使用自定义控制器或控制器扩展。如果你有任何问题，随时问我哦！

  ▶ 播放视频 查看详情
• 344

  What Can Controller Extensions and Custom Controllers Provide?

  第 427 页

  让我们来聊聊Salesforce中的控制器扩展和自定义控制器，以及Getter/Setter和Property Butter的区别。 首先，控制器扩展和自定义控制器在Salesforce中是用来增强标准页面功能或者创建全新的自定义页面的。控制器扩展允许你在不改变标准控制器逻辑的情况下，添加额外的功能。而自定义控制器则是完全由你编写的，用于处理页面的所有逻辑。 接下来，我们来看看Getter/Setter和Property Butter。Getter和Setter是两种方法，用于获取和设置对象的属性值。在Java中，你可能会看到这样的代码： ```java public class MyClass { private int myVar; public int getMyVar() { return myVar; } public void setMyVar(int value) { myVar = value; } } ``` 而在C#中，你可以使用属性语法来简化这个过程： ```csharp public class MyClass { public int MyVar { get; set; } } ``` 这两种方式做的事情是一样的，都是用来获取和设置属性的值。属性语法是C#中的一种简化写法，它自动为你生成了getter和setter方法。 总结一下，控制器扩展和自定义控制器让你能够更灵活地控制Salesforce页面的行为，而Getter/Setter和Property Butter则是两种不同的语法，用于管理对象的属性。希望这些信息对你有帮助！

  ▶ 播放视频 查看详情
• 345

  Why Must a Page Use a Controller Extension?

  第 428 页

  让我们来聊聊为什么页面必须使用控制器扩展，以及为什么在某些情况下选择控制器扩展比自定义控制器更合适。 首先，想象一下，你有一个页面，这个页面需要与Salesforce的标准功能或者你已经创建的自定义功能一起工作。这时候，控制器扩展就派上用场了。控制器扩展允许你在保留原有控制器功能的基础上，添加一些额外的功能或者修改一些行为。这就好比你在已有的基础上进行装修，而不是重新建造一座房子。 其次，如果你希望你的页面能够与Salesforce的一些声明性功能（比如页面布局、自定义按钮或者自定义操作）无缝集成，那么使用控制器扩展是必须的。因为这些功能通常依赖于标准控制器，而控制器扩展可以与标准控制器或自定义控制器一起使用，确保这些功能能够正常工作。 举个例子，如果你的页面需要嵌入到账户布局中，那么你就必须使用控制器扩展。因为只有这样，你的页面才能与账户的标准控制器协同工作，确保页面布局中的各种功能都能正常使用。 总结一下，选择控制器扩展而不是自定义控制器的两个主要原因： 1. 你想保留标准或自定义控制器的大部分功能。 2. 你需要页面与依赖于标准控制器的声明性Salesforce功能一起使用。 所以，当你需要在现有功能的基础上进行扩展，或者需要与Salesforce的标准功能集成时，控制器扩展是一个非常明智的选择。希望这个解释能帮助你更好地理解控制器扩展的作用和重要性。

  ▶ 播放视频 查看详情
• 346

  Choosing a Custom Controller vs. a Controller Extension

  第 429 页

  今天我们来聊聊Salesforce中的定制控制器和控制器扩展。这两个概念在开发自定义页面时非常重要，但它们的用途和适用场景有所不同。我会尽量用简单的语言来解释，让你更容易理解。 首先，，定制控制器，和，控制器扩展，都是用来控制页面的逻辑的，但它们的使用方式有些不同。 ### 1. 定制控制器 定制控制器是一个完全由你编写的控制器，它不依赖于任何标准控制器。你可以把它想象成一个完全自定义的“大脑”，专门为你的页面服务。它适合以下场景： - ，多个对象平等展示，：如果你的页面需要同时展示多个对象，并且没有一个对象是“主对象”，那么定制控制器是个好选择。 - ，不涉及标准操作，：比如你要做一个多页面的向导，或者一个搜索页面，这些页面不需要标准的保存、删除等操作，定制控制器会更合适。 - ，完全系统上下文，：如果你希望页面在系统上下文中运行（即“不共享”模式），定制控制器可以帮你实现。 ### 2. 控制器扩展 控制器扩展则是基于标准控制器的扩展。它依赖于标准控制器的功能，但允许你添加自定义逻辑。控制器扩展适合以下场景： - ，需要标准控制器功能，：比如你想使用标准控制器的内置保存、删除等功能，但又想添加一些自定义逻辑，这时控制器扩展就很合适。 - ，依赖标准控制器的声明性功能，：比如你想在页面布局中包含某些标准功能，或者通过自定义按钮启动页面，控制器扩展可以帮助你实现。 ### 什么时候用定制控制器？什么时候用控制器扩展？ - ，必须用控制器扩展的情况，：如果你需要使用标准控制器的功能（比如内置的保存、删除操作），或者你的页面依赖于标准控制器的声明性功能（比如自定义按钮启动页面），那么你必须使用控制器扩展。 - ，可以考虑定制控制器的情况，：如果你的页面不需要标准控制器的功能，或者你希望页面的逻辑更清晰、更独立，那么定制控制器可能是更好的选择。定制控制器可以让你的代码更简洁，其他开发人员也更容易理解。 ### 为什么有时候定制控制器更好？ 有时候，虽然你可以用控制器扩展来实现某些功能，但这并不意味着你应该这么做。如果你的页面不需要标准控制器的功能，使用定制控制器可以让代码更清晰，避免不必要的复杂性。特别是当你的页面没有一个明确的“主对象”时，使用定制控制器可以避免随意选择一个对象来使用标准控制器，从而让代码更易读。 总结一下，选择定制控制器还是控制器扩展，主要取决于你的页面需求。如果你需要标准控制器的功能，控制器扩展是必须的；如果你希望页面逻辑更独立、更清晰，定制控制器可能是更好的选择。 希望这个解释对你有帮助！如果有任何问题，随时问我哦！

  ▶ 播放视频 查看详情
• 347

  Invoking Controller Extensions and Custom Controllers in Visualforce Pages

  第 430 页

  让我们来聊聊Visualforce页面中控制器和控制器扩展的使用。首先，想象一下你正在做一个项目，你需要一个主控制器来管理主要的逻辑，但有时候你可能还需要一些额外的功能，这时候控制器扩展就派上用场了。 在Visualforce页面中，你可以通过``标签来指定使用哪种控制器。如果你想要使用Salesforce提供的标准控制器，你可以这样写： ```html ``` 这里的`standardController`属性指定了你要使用的标准控制器，比如`Account`控制器。 如果你想要使用自定义的控制器，你可以这样写： ```html ``` 这里的`controller`属性指定了你的自定义控制器类名，比如`CustomAccountController`。 现在，如果你想要添加一些额外的功能，你可以使用控制器扩展。控制器扩展是通过`extensions`属性来指定的，你可以列出多个扩展，它们会按照你列出的顺序从左到右被评估。例如： ```html ``` 在这个例子中，`Extension1`会首先被检查，然后是`Extension2`。如果`Extension1`中有你想要调用的方法，比如`save`，那么这个方法会被执行。如果`Extension1`中没有这个方法，那么Visualforce会继续检查`Extension2`，如果还没有，最后会回到标准控制器或自定义控制器中的方法。 记住，你只能选择一个主控制器，要么是标准的，要么是自定义的，不能同时使用两者。但是，无论你选择哪种主控制器，你都可以添加多个控制器扩展。 希望这个解释能帮助你理解如何在Visualforce页面中使用控制器和控制器扩展。如果有任何疑问，随时问我！

  ▶ 播放视频 查看详情
• 348

  Referencing a Property Value in a Visualforce Page

  第 431 页

  让我们来聊聊如何在Visualforce页面中引用属性值。假设你已经创建了一个只读属性，用来获取与当前账户相关的持有证书列表。现在，你想在Visualforce页面中展示这个列表。 首先，你需要在Visualforce页面中使用一种叫做“表达式语法”的东西。这个语法看起来像这样：`{!属性名}`。在这个例子中，如果你的属性名叫做“结果”，那么你就可以在页面中这样写：`{!结果}`。这样，页面就会自动显示这个属性所包含的证书列表了。 简单吧？就像你在页面上放了一个小窗口，通过这个窗口，你可以看到后台代码中“结果”这个属性里装的所有东西。 另外，你还可以用这个表达式语法来设置值，不过这个我们会在下一个话题中详细讲解。现在，你只需要记住，用`{!属性名}`就可以在页面上展示你想要的数据了。

  ▶ 播放视频 查看详情
• 349

  17-1: Reference a Controller Extension in a Visualforce Page

  第 432 页

  让我们一步一步来完成这个任务。首先，我们需要理解什么是控制器扩展。在Salesforce中，控制器扩展是一个Apex类，它扩展了标准或自定义控制器的功能。这意味着我们可以在不改变原有控制器的情况下，添加新的功能或逻辑。 ### TODO#1：在Visualforce页面中引用控制器扩展 1. ，创建控制器扩展，：首先，你需要将提供的控制器扩展代码复制并粘贴到你的Salesforce组织中，作为一个新的Apex类。这个类将会包含查询所有认证持有记录的逻辑。 2. ，在Visualforce页面中引用控制器扩展，：接下来，你需要在Visualforce页面中引用这个控制器扩展。你可以在``标签中使用`standardController`属性来指定标准控制器（例如`Account`），并使用`extensions`属性来引用你刚刚创建的控制器扩展。 例如： ```html ``` ### TODO#2：创建完整的内容以显示结果 1. ，使用``显示结果，：在Visualforce页面中，你可以使用``来显示查询结果。这个标签会创建一个表格，表格的每一行代表一条记录，每一列代表记录中的一个字段。 2. ，指定表格的列，：你需要指定表格有三列，分别是“尝试#”、“认证候选人”和“认证元素”。你可以在``标签中使用``标签来定义每一列。 例如： ```html ``` ### 在帐户页面布局上创建一个部分以显示新页面 1. ，将Visualforce页面添加到帐户页面布局，：在Salesforce的设置中，找到“帐户”页面布局，然后添加一个新的部分。在这个部分中，你可以选择你刚刚创建的Visualforce页面。 2. ，测试新页面，：最后，保存你的更改并导航到一个帐户记录页面，你应该能够看到新添加的部分，其中显示了与当前帐户相关的所有认证持有记录。 ### 总结 通过以上步骤，你已经成功地在Visualforce页面中引用了控制器扩展，并创建了一个页面来显示所有认证持有记录。你还将这个页面嵌入到了帐户页面布局中，并进行了测试。希望这个过程对你来说既简单又有趣！如果有任何问题，随时提问。

  ▶ 播放视频 查看详情
• 350

  Module Agenda - 433

  第 433 页

  今天我们来聊聊Salesforce中的自定义控制器和控制器扩展。首先，想象一下，你在网上找代码片段时，经常会看到一些方法返回的是“空”（void）而不是PageReference。这在一些高级场景下是完全可以的，比如当你使用Ajax进行页面部分刷新时。 首先，我们来看看什么是自定义控制器和控制器扩展。简单来说，自定义控制器是你自己写的Apex类，用来控制页面的行为和逻辑。而控制器扩展则是在现有控制器的基础上，添加额外的功能或修改现有功能。 接下来，我们谈谈Getters和Setters。这些是Apex类中的方法，用来获取（get）和设置（set）类的属性值。比如，你有一个变量叫做“name”，你可以通过getter方法来获取它的值，通过setter方法来设置它的值。 然后，我们来看看行动方法。这些是你在页面上点击按钮或链接时触发的方法。它们可以执行一些逻辑，比如保存数据、导航到另一个页面等。有时候，这些方法不需要返回一个页面，所以它们可以返回“空”。 最后，我们来谈谈错误处理。在编写代码时，难免会遇到错误。处理这些错误是非常重要的，比如你可以使用try-catch块来捕获异常，并给用户一个友好的错误提示。 总结一下，今天我们学习了自定义控制器和控制器扩展，Getters和Setters，行动方法以及错误处理。希望这些内容能帮助你更好地理解和使用Salesforce。如果有任何问题，随时问我哦！

  ▶ 播放视频 查看详情
• 351

  Writing a Read-Only Property

  第 434 页

  让我们来聊聊如何在Salesforce中创建一个只读的Visualforce页面，来展示与某个账户相关的当前正在进行的认证尝试。 首先，我们需要理解什么是只读属性。在编程中，只读属性意味着这个属性的值可以被读取，但不能被修改。在Salesforce的Visualforce页面中，我们通常使用只读属性来展示数据，而不允许用户进行编辑。 接下来，我们需要创建一个新的Visualforce页面。这个页面将嵌入到账户的页面布局中，用来展示与该账户相关的认证尝试。为了做到这一点，我们需要编写一个控制器扩展。控制器扩展是一个Apex类，它扩展了标准控制器的功能，允许我们添加自定义逻辑来获取和展示数据。 在这个例子中，我们的控制器扩展需要访问与账户相关的认证尝试数据。我们可以通过编写一个Apex方法来查询这些数据，并将它们绑定到Visualforce页面上。 最后，我们需要确保这个Visualforce页面是只读的。这意味着我们需要在页面上使用只读的输入组件，比如``或``，而不是可编辑的组件如``。 总结一下，我们需要做以下几步： 1. 创建一个新的Visualforce页面。 2. 编写一个控制器扩展来获取与账户相关的认证尝试数据。 3. 在Visualforce页面上使用只读组件来展示这些数据。 这样，当用户查看某个账户的页面时，他们就能看到与该账户相关的当前正在进行的认证尝试，而且这些信息是只读的，不能被修改。希望这个解释对你有帮助！如果有任何问题，随时问我。

  ▶ 播放视频 查看详情
• 352

  Controller Extension Constructors

  第 435 页

  让我们来聊聊Salesforce中的控制器扩展构造者。首先，控制器扩展是一个非常强大的工具，它允许我们在标准的Salesforce页面控制器的基础上添加自定义的功能。 当你创建一个控制器扩展时，你可以选择将列表控制器作为参数传递进去。这意味着你的扩展可以操作和显示一组记录，而不仅仅是单个记录。我们会在后续的课程中更详细地探讨列表控制器的使用。 接下来，如果你只需要访问对象上的数据，比如获取记录的ID或者整个记录本身，你只需要在控制器扩展中包含`getID`或`getRecord`方法。这样，你就可以轻松地获取和使用这些数据了。 有时候，你可能会遇到需要创建一个空构造函数的控制器扩展。这种情况通常发生在你的扩展不需要使用标准控制器提供的功能时。也就是说，你的扩展可能只是用来添加一些自定义的方法，而不需要访问标准控制器中的字段。 最后，如果你的控制器扩展只是用来添加一些方法，而不需要访问或修改任何字段，那么你可以选择不保存控制器本身。这意味着你的扩展将更加轻量级，只包含你需要的功能。 总结一下，控制器扩展构造者是一个非常灵活的工具，它可以根据你的需求来定制。无论是处理单个记录还是多个记录，无论是访问数据还是添加方法，控制器扩展都能帮助你实现。希望这些信息对你有所帮助，我们下次再见！

  ▶ 播放视频 查看详情
• 353

  Writing a Getter Method

  第 436 页

  今天我们来聊聊Salesforce中的Getter方法。首先，记住一个原则：除非你有特别的理由不这么做，否则使用共享模式通常是最佳的选择。共享模式，有时候也被称为“在系统模式下运行”，这意味着你的代码可以访问所有数据，不受用户权限的限制。 现在，如果你在编写控制器扩展或自定义控制器时，没有特别声明使用共享或不共享模式，那么系统默认会给你系统模式。这意味着你的代码将拥有访问所有数据的权限，这在某些情况下非常有用。 接下来，我们来看看标准控制器。所有的标准控制器都有一个叫做getBody()的方法。这个方法允许你通过{!object.field}这样的语法来访问对象的数据。这是一个非常方便的特性，因为它让你能够轻松地从页面上获取和显示数据。 再来说说Getter方法。这个方法通常用于根据URL中的id参数来查询并获取特定记录的数据。你可以使用这样的代码来实现： ```apex ID recordId = ApexPages.currentPage().getParameters().get(&#39;id&#39;); return [SELECT id, listofotherfields FROM Object WHERE id = :recordId]; ``` 这段代码的作用是从数据库中查询出与URL中提供的id相匹配的记录，并且只返回那些你明确列出的字段。这样，你就可以在页面上访问这些数据了。 最后，记住，这种模式不仅限于标准控制器，你也可以在自定义控制器的代码中使用它。这样，你就可以根据需要灵活地获取和展示数据了。 希望这些信息对你有帮助，如果你有任何问题，随时问我！

  ▶ 播放视频 查看详情
• 354

  Referencing a Getter Method

  第 437 页

  让我们来聊聊Salesforce中的Getter方法。想象一下，Getter方法就像是一个小助手，它的工作是去获取一些数据，然后把数据带回来给你。这个方法的名字通常是以“get”开头，后面跟着你想要获取的数据的名字，比如getDataName()。 当你在Visualforce页面上使用这个数据时，你不需要再叫它“getDataName”了，你只需要叫它“DataName”。这就好比你叫你的朋友“小明”，而不是“叫小明过来”。 现在，让我们来做个小测试。如果你在控制器里声明了一个公共的字符串名字，同时在页面上也使用了Getter方法来获取数据，那么页面上会显示哪一个呢？是公共字符串还是Getter方法的结果呢？答案是Getter方法的结果。因为Getter方法就像是那个最后把数据递给你的人，所以页面上会显示它带回来的数据。 希望这个解释能帮助你更好地理解Getter方法在Salesforce中的应用。如果有任何疑问，随时问我哦！

  ▶ 播放视频 查看详情
• 355

  Writing a Setter Method

  第 438 页

  今天我们来聊聊如何在Salesforce中编写一个Setter方法。Setter方法的主要作用是设置一个变量的值。在这个例子中，我们将使用Setter方法来存储用户在页面上输入的搜索文本。 首先，我们来看一下为什么我们不使用DML（数据操作语言）来将数据持久化到数据库中。在这个场景中，我们只是暂时存储用户输入的搜索文本，以便在同一控制器的第二个页面上使用它来显示搜索结果。这意味着我们不需要将数据保存到数据库中，只需要在控制器中临时存储即可。 接下来，我们来看一下如何在Visualforce页面中使用表达式语法来引用Setter方法。在Visualforce页面中，你可以使用`{!DataName}`这样的表达式来引用Setter方法。这样，当用户在输入框中输入文本并点击搜索按钮时，输入的文本就会被传递给Setter方法，并存储在控制器中。 现在，我们来看一个完整的示例代码： ```apex // 控制器类 public class SearchTextController { public String searchText; // Getter方法 public String getSearchText() { return searchText; } // Setter方法 public void setSearchText(String s) { searchText = s; } // 操作方法 public void search() { System.debug(&#39;Search Text = &#39; + searchText); // 打印Visualforce页面中的用户输入 } } ``` ```html ``` 在这个示例中，`SearchTextController`类有一个`searchText`变量，以及对应的Getter和Setter方法。当用户在Visualforce页面的输入框中输入文本并点击“Search”按钮时，输入的文本会通过Setter方法存储在`searchText`变量中。然后，`search`方法会被调用，打印出用户输入的搜索文本。 需要注意的是，Setter方法总是在操作方法之前触发。这一点非常重要，因为它确保了在操作方法执行之前，所有的数据都已经设置好了。这样，你就可以在操作方法中放心地使用这些数据了。 希望这个解释对你有帮助！如果有任何问题，随时问我哦。

  ▶ 播放视频 查看详情
• 356

  Using Properties for Getting and Setting

  第 439 页

  让我们来聊聊如何在Salesforce中使用属性来获取和设置数据。首先，想象一下你正在构建一个Visualforce页面，这个页面有一个输入字段，用户可以在那里输入一些信息。你可能会想知道，如何将这些输入的数据传递到你的Apex控制器中呢？这里，属性就派上用场了。 属性是一种特殊类型的变量，它允许你通过简单的语法来读取和写入数据。当你想要获取数据时，属性会自动调用一个“获取访问器”（getter），而当你想要设置或更改数据时，它会调用一个“设置访问器”（setter）。这种方式比传统的getter和setter方法更简洁，也更符合现代编程的趋势。 举个例子，假设你有一个属性叫做`userInput`，你可以这样使用它： ```apex public String userInput { get; set; } ``` 这行代码创建了一个名为`userInput`的属性，它既可以读取也可以写入。当你在Visualforce页面上设置这个属性时，比如通过一个输入字段，Apex会自动处理数据的获取和设置。 大多数情况下，使用属性就足够了，因为它简单直接。但在某些特殊情况下，比如你需要进行一些复杂的计算或者逻辑处理时，你可能还是会选择使用传统的getter和setter方法。 最后，如果你想要深入了解属性的所有功能和细节，可以查阅Salesforce提供的Apex语言参考文档。那里有更详细的解释和示例，帮助你更好地掌握属性的使用。 希望这个解释对你有帮助！如果你有任何问题，随时问我。

  ▶ 播放视频 查看详情
• 357

  Using Properties of SObjects

  第 440 页

  今天我们来聊聊如何在Salesforce中使用SObjects的属性。这个知识点对于开发Visualforce页面和Apex控制器非常重要。 首先，假设你有一个Apex控制器，里面有一个getter方法或者属性。这个方法或属性可以返回一个SObject，比如一个Account对象，或者返回一个自定义的Apex类。这个类里面也有自己的getter和setter方法。 那么，在Visualforce页面中，你可以通过点符号来访问这些属性和方法。比如说，如果你有一个Account对象，你可以直接在页面上使用`{!account.Name}`来访问或设置Account的名称字段。同样，如果你想访问Account的父账户的类型，你可以使用`{!account.Parent.Type}`。 这样做的好处是什么呢？它大大简化了Apex代码的编写。你不需要为每一个你想在页面上使用的SObject字段都写一个自定义的getter和setter方法。你只需要在控制器中返回整个SObject或者Apex类，然后在Visualforce页面中通过点符号来访问这些字段。 总结一下，通过使用SObjects的属性，你可以更高效地在Visualforce页面和Apex控制器之间传递数据，减少了代码量，提高了开发效率。希望这个解释对你有帮助！

  ▶ 播放视频 查看详情
• 358

  17-2: Create a Simple Read-Only Property

  第 441 页

  让我们一步一步来完成这个任务。首先，我们需要创建一个简单的只读属性，名为“TO多斯”。这个属性将帮助我们获取一些特定的记录，并在Visualforce页面上显示它们。 ，TODO#1 - 在扩展中编写控制器扩展构造函数， 首先，我们需要在控制器扩展中编写一个构造函数。这个构造函数的目的是获取一个特定的账户记录。我们可以这样做： ```apex public class AccountExtension { private final Account acct; public AccountExtension(ApexPages.StandardController stdController) { this.acct = (Account)stdController.getRecord(); } } ``` 在这个代码中，我们创建了一个名为`AccountExtension`的类，并在其中定义了一个构造函数。这个构造函数接收一个标准的控制器对象，并从中获取账户记录。 ，TODO#2 - 在扩展中编写属性以获取Certification_Attention__c记录， 接下来，我们需要编写一个属性，这个属性将返回一个列表，列表中包含状态为“不完整/通过”或“完整/失败”的`Certification_Attention__c`记录。我们可以指定我们想要获取的字段。代码如下： ```apex public List getCertificationAttentions() { return [SELECT Id, Name, Status__c FROM Certification_Attention__c WHERE Account__c = :acct.Id AND (Status__c = &#39;Incomplete/Passed&#39; OR Status__c = &#39;Complete/Failed&#39;)]; } ``` 这里，我们定义了一个名为`getCertificationAttentions`的方法，它返回一个`Certification_Attention__c`对象的列表。我们使用SOQL查询来获取与当前账户相关的记录，并且只选择那些状态符合我们要求的记录。 ，TODO#3 - 在VF页面中添加标准控制器和扩展属性， 现在，我们需要在Visualforce页面中设置标准控制器和扩展。我们可以这样做： ```html ``` 在这个代码中，我们指定了标准控制器为`Account`，并且使用了我们刚刚创建的`AccountExtension`作为扩展。 ，TODO#4 - 在VF页面中添加标签， 最后，我们需要在Visualforce页面中添加一个``标签来显示我们的记录。我们可以这样做： ```html ``` 在这里，我们使用了`value`属性来绑定我们之前创建的`certificationAttentions`属性，并使用`var`属性来定义每一行的变量名`ca`。然后，我们定义了两列，分别显示`Name`和`Status__c`字段。 这样，我们就完成了创建一个简单的只读属性“TO多斯”的任务，并在Visualforce页面上显示了相关的记录。希望这个过程对你来说清晰易懂！如果有任何疑问，随时问我。

  ▶ 播放视频 查看详情
• 359

  Module Agenda - 442

  第 442 页

  今天我们来聊聊Salesforce中的自定义控制器和控制器扩展。这部分内容听起来可能有点技术性，但别担心，我会用简单的方式来解释。 首先，什么是自定义控制器？简单来说，它就像是你自己编写的一个小助手，专门用来处理页面上的一些特殊逻辑。比如说，你可能需要在用户点击一个按钮后，做一些复杂的计算或者从数据库中获取一些数据。这时候，自定义控制器就派上用场了。 接下来是控制器扩展。这个可以理解为是对标准控制器的一个补充。标准控制器已经帮我们处理了很多基础的功能，但有时候我们需要更多的控制，这时候就可以用控制器扩展来添加一些额外的功能。 在编写这些控制器时，我们会用到Getters和Setters。这两个词听起来可能有点复杂，但其实很简单。Getter就是用来获取数据的，而Setter则是用来设置数据的。比如说，你有一个输入框，用户输入了他们的名字，你就可以用Getter来获取这个名字，然后用Setter来把这个名字保存到数据库中。 还有一个重要的概念是行动方法。这些方法通常是在用户执行某个操作时被调用的，比如点击一个按钮。在行动方法中，你可以定义点击按钮后应该发生什么，比如跳转到另一个页面或者保存数据。 最后，我们还要学会处理错误。在编程中，错误是不可避免的，但我们可以通过编写一些代码来优雅地处理这些错误，给用户一个友好的提示，而不是让程序崩溃。 至于你提到的返回空而不是PageReference的例子，这通常用于一些不需要页面跳转的场景，比如Ajax请求。在这种情况下，我们可能只是更新页面的一部分内容，而不是整个页面。 好了，这就是今天的内容。希望这些解释能帮助你更好地理解Salesforce中的自定义控制器和控制器扩展。如果有任何问题，随时问我哦！

  ▶ 播放视频 查看详情
• 360

  Creating the Course Delivery Search Page

  第 443 页

  同学们，今天我们来聊聊如何在Salesforce中创建一个课程交付搜索页面。这个功能特别适合像尼基·桑切斯这样的培训协调员，他们需要为技术人员报名参加培训，并且希望能够同时搜索多门课程，查看所有即将交付的课程，以便更好地安排时间表。 首先，我们需要明确几个关键点： 1. ，教学点，：这是指课程交付的具体地点。在搜索页面中，我们需要能够选择或输入教学点，以便筛选出特定地点的课程。 2. ，重点，：这里指的是课程的关键信息，比如课程名称、课程代码、讲师等。这些信息应该清晰地展示在搜索结果中，方便用户快速浏览。 3. ，读蓝色，：这可能是指界面中的某些元素或提示信息用蓝色标注，以引起用户的注意。在Salesforce中，我们可以通过自定义页面布局或使用条件格式来实现这一点。 4. ，与课程相关的复选框，：在搜索页面中，我们可以为每门课程添加复选框，这样用户就可以选择多门课程进行批量操作，比如报名或添加到日程表中。 接下来，我们来看看如何一步步实现这个功能： 1. ，创建自定义对象，：首先，我们需要创建一个自定义对象来存储课程交付的信息，比如课程名称、教学点、交付日期等。 2. ，设计页面布局，：在Salesforce中，我们可以使用Lightning App Builder来设计搜索页面的布局。我们可以添加搜索栏、筛选器、数据表格等组件，确保用户能够方便地进行搜索和筛选。 3. ，添加筛选器，：为了让用户能够根据教学点、课程名称等条件进行筛选，我们需要在页面中添加相应的筛选器组件。这些筛选器可以根据用户的选择动态更新搜索结果。 4. ，展示搜索结果，：在搜索结果部分，我们可以使用数据表格组件来展示课程信息。每门课程旁边可以添加一个复选框，方便用户选择多门课程。 5. ，实现批量操作，：通过Apex控制器和Lightning Web Components，我们可以实现批量操作功能。比如，当用户选择多门课程后，可以点击一个按钮将这些课程添加到日程表中。 6. ，优化用户体验，：最后，我们可以通过调整页面布局、使用条件格式（比如将重要信息用蓝色标注）等方式，进一步提升用户体验。 通过以上步骤，我们就可以创建一个功能强大且用户友好的课程交付搜索页面，帮助培训协调员更高效地管理培训计划。 希望这个讲解对大家有所帮助！如果有任何问题，欢迎随时提问。

  ▶ 播放视频 查看详情
• 361

  What Do You Need to Implement the Search Page?

  第 444 页

  让我们来一步步理解如何实现这个搜索页面，特别是如何处理复选框和课程的绑定。 首先，想象一下我们的搜索页面。页面上有一个课程列表，每个课程旁边都有一个复选框，还有一个搜索按钮。我们的目标是让用户能够选择他们感兴趣的课程，然后点击搜索按钮来获取这些课程的详细信息。 为了实现这个功能，我们需要在Salesforce的控制器中存储一些关于每个课程的信息。具体来说，我们需要知道每个课程的名称和ID，以及用户是否选择了这个课程（即复选框是否被勾选）。为了存储这些信息，我们可以使用一个叫做“包装器类”的东西。 包装器类就像一个容器，它有两个主要部分：一个是“选定”（表示复选框是否被选中），另一个是“课程”（包含课程的名称和ID）。对于列表中的每一门课程，我们都会创建一个这样的包装器对象，并将所有这些对象存储在一个列表中。 接下来，我们会使用这个列表来填充页面上的课程列表。这样，当用户浏览页面时，他们可以看到所有的课程，并且可以选择他们感兴趣的课程。 现在，让我们来讨论一下这个页面应该使用哪种类型的控制器。在Salesforce中，你可以选择使用自定义控制器或者控制器扩展。在这个案例中，我们应该选择自定义控制器。为什么呢？因为这个页面并不需要使用标准控制器的任何内置功能，所以使用控制器扩展并不会带来任何额外的好处。 总结一下，我们通过创建一个包装器类来存储每门课程的信息，并使用这个类来管理用户的选择。然后，我们使用自定义控制器来处理页面的逻辑，确保用户可以有效地搜索和选择他们感兴趣的课程。这样，我们的搜索页面就能既直观又高效地工作了。

  ▶ 播放视频 查看详情
• 362

  What is a Wrapper Class?

  第 445 页

  让我们来聊聊包装类。想象一下，你有一个购物清单，上面列出了你想要买的东西。现在，假设你不仅想列出这些物品，还想为每个物品添加一个复选框，这样你就可以标记哪些是你已经买好的。在Salesforce中，包装类就像是这个购物清单的升级版。 包装类是一种特殊的数据结构，它允许我们在控制器中创建一些“字段”。比如，我们可以有一个字段是Course__c，这代表一个课程；另一个字段是一个布尔值，也就是一个复选框，用来表示这个课程是否被选中。 我们通过一个构造函数来创建这个包装类。构造函数就像是一个工厂，它接收一个Course__c对象，然后生产出一个新的courseWrapper对象。这个courseWrapper对象不仅包含了课程的信息，还包含了那个复选框的状态。 这样做的目的是什么呢？想象一下，你有一个课程列表，但你想要从中选择一些特定的课程。如果你只是存储普通的课程列表，你就无法轻松地标记和选择这些课程。但是，如果你存储的是CourseWrappers列表，你就可以利用那个复选框来轻松地识别和选择你想要的那些课程。 在Visualforce页面中，使用复选框从列表中选择多个记录是一个非常常见的用例。包装类让这一切变得简单而高效。所以，下次当你在Salesforce中需要处理类似的选择列表时，记得考虑使用包装类，它会让你的工作更加轻松。

  ▶ 播放视频 查看详情
• 363

  17-3: Creating a Read/Write Property in a Custom Controller

  第 446 页

  让我们一步一步来完成这个任务。首先，我们要在自定义控制器中创建一个叫做`CourseWrapper`的类。这个类有两个字段：一个是`Course`，用来存储课程信息；另一个是`Checked`，用来标记这个课程是否被选中。我们还需要为这个类创建一个构造函数，这样当我们创建`CourseWrapper`对象的时候，就可以直接传入`Course`和`Checked`的值。 接下来，我们要在控制器中编写一个`CourseList`的Get属性。这个属性会返回一个包含所有课程的列表。我们还需要在控制器中创建一个空的`listDeliveries`方法，这个方法现在不需要做任何事情，但我们需要它，因为页面会调用这个方法。 现在，我们转到课程搜索页面。在这里，我们需要添加一个顶端的命令按钮，并且让这个按钮调用我们刚才创建的`listDeliveries`方法。然后，我们要创建一个页面块表，这个表会显示所有的课程。我们需要在页面块表标记中设置`Value`和`var`属性，这样页面就知道从哪里获取数据和如何显示数据。我们还会提供列的宽度，确保表格看起来整齐。 最后，我们需要测试页面的这一部分是否正常工作。页面应该能够显示课程列表，并且当我们选中一些课程并点击搜索按钮时，`CourseList`应该更新每个`CourseWrapper`对象的`Checked`字段的值。在Java中，我们通常会将`CourseList`打印到控制台来检查，但在这里，我们可以通过查看页面上的课程列表和选中状态来确认代码是否正常工作。 这就是我们今天的任务。希望你们能够顺利完成，并且通过测试确认一切都在按预期工作。如果有任何问题，随时提问，我会在这里帮助你们。

  ▶ 播放视频 查看详情
• 364

  Implementing the Search Button

  第 447 页

  让我们来聊聊如何在Salesforce中实现一个搜索按钮，以及在这个过程中需要注意的一些关键点。 首先，想象一下你有一个页面，页面上有一个搜索按钮。当用户点击这个按钮时，我们希望页面能够根据用户输入的条件去搜索一些课程信息。为了实现这个功能，我们需要在后台编写一些代码，这些代码会处理用户的输入，执行搜索，并返回结果。 ### 实现搜索按钮的要点 1. ，Action方法，：当用户点击搜索按钮时，会触发一个Action方法。这个方法是写在Apex控制器中的。它的主要任务是接收用户输入的数据，然后根据这些数据去查询数据库，找到符合条件的课程信息。 2. ，更新课程包装，：在Action方法中，我们会调用一些“设置器”（setter）方法来更新一个叫做“课程包装”的对象。这个包装类是用来封装课程信息的，它可以帮助我们更好地管理和展示数据。 3. ，包装类的作用，：包装类不仅仅是一个数据的容器，它还可以告诉我们用户选择了哪些课程。比如，用户可能在页面上勾选了一些课程，这些信息会被存储在包装类中，方便我们在后续的操作中使用。 ### 教学点 现在，让我们来讨论一个重要的教学点：，这个页面应该使用自定义控制器还是控制器扩展？， - ，自定义控制器，：如果这个页面不需要使用标准控制器的任何内置功能（比如标准的保存、删除等操作），那么使用自定义控制器是一个更好的选择。自定义控制器可以完全按照你的需求来编写逻辑，灵活性更高。 - ，控制器扩展，：控制器扩展通常用于在标准控制器的基础上添加一些额外的功能。如果你的页面需要用到标准控制器的某些功能，那么可以考虑使用控制器扩展。但在这个案例中，由于我们不需要标准控制器的任何功能，所以使用扩展并没有太大的好处。 总结一下，如果你的页面功能相对独立，不需要依赖标准控制器的功能，那么使用自定义控制器会更加合适。这样你可以完全掌控页面的逻辑，实现你想要的功能。 希望这些内容能帮助你更好地理解如何在Salesforce中实现搜索按钮，并做出合适的技术选择。如果有任何问题，随时问我！

  ▶ 播放视频 查看详情
• 365

  How Will the Search Page Work?

  第 448 页

  让我们来聊聊搜索页面是如何工作的。想象一下，你正在一个在线课程平台上寻找你感兴趣的课程。你可能会选择一些课程类型或者输入一些关键词，然后点击“搜索”按钮。这时候，页面背后会发生一些有趣的事情。 首先，当你点击搜索按钮的那一刻，页面会先运行所有的setter方法。这些setter方法的作用是更新你选择的课程信息，确保它们都是最新的。这就像是你告诉页面：“嘿，我选了这些课程，请确保它们的信息都是最新的。” 接下来，页面会执行Search方法。这个方法会创建一个新的列表，这个列表里只包含你选择的那些课程。这就像是页面在说：“好的，我已经更新了所有信息，现在我来筛选出你真正感兴趣的课程。” 最后，这个新创建的列表会被用来在下一页面上显示搜索结果。这样，当你翻到下一页时，你就能看到所有符合你选择的课程了。 简单来说，搜索页面的工作流程就是：选择课程 -&gt; 点击搜索 -&gt; 更新信息 -&gt; 筛选课程 -&gt; 显示结果。希望这个解释能帮助你更好地理解搜索页面的工作原理！

  ▶ 播放视频 查看详情
• 366

  Using Action Methods

  第 449 页

  今天我们来聊聊如何在Visualforce页面中使用Action方法。你可以把Action方法想象成一个按钮背后的“魔法”，当你点击按钮时，这个“魔法”就会被触发，执行一些特定的操作。 首先，我们来看一个简单的例子。假设你有一个自定义的Action方法，名字叫`myCustomAction`。你可以在Visualforce页面上使用``标签，把这个Action方法绑定到一个按钮上。就像这样： ```html ``` 这里，`action=&quot;{!myCustomAction}&quot;`表示当用户点击这个按钮时，系统会调用`myCustomAction`这个方法。`value=&quot;My Custom Action Button&quot;`则是按钮上显示的文字。 同样地，你也可以使用标准的Action方法，比如`save`。这个`save`方法是Salesforce自带的一个标准方法，用来保存记录。你可以这样使用它： ```html ``` 这个按钮的作用就是保存当前记录。 ，教学要点：， 1. ，自定义Action方法，：你可以创建自己的Action方法，并在Visualforce页面上通过按钮来调用它们。 2. ，标准Action方法，：Salesforce提供了一些标准的Action方法，比如`save`，你可以直接使用它们，而不需要自己写代码。 3. ，绑定方式，：无论是自定义的还是标准的Action方法，你都可以通过``标签的`action`属性来绑定它们。 总结一下，使用Action方法就像给按钮赋予了一个任务，点击按钮时，这个任务就会被执行。你可以用自定义的任务，也可以用系统自带的任务，非常灵活。 希望这个解释对你有帮助！如果有任何问题，随时问我哦！

  ▶ 播放视频 查看详情
• 367

  17-4: Implement the Search Button

  第 450 页

  让我们来聊聊如何在Salesforce中实现一个搜索按钮，并且按照TODO的步骤来完成这个功能。 首先，我们来看TODO#1：创建所选课程的地图。为什么要用地图呢？因为列表是允许有重复项的，而地图则不同，它是以键值对的形式存储数据，键是唯一的。所以，如果我们把课程的ID作为键，课程对象作为值，那么我们就可以确保每个课程只被添加一次，避免了重复。 接下来是TODO#2：确保所选课程列表已清除。这一步很重要，因为在我们添加新的课程之前，我们需要确保列表是空的，这样就不会把旧的课程和新的课程混在一起。 然后是TODO#3：将选定的课程添加到地图中。这一步就是实际的操作了，我们需要遍历用户选择的课程，然后把它们添加到我们之前创建的地图中。 最后，测试。在开发过程中，测试是非常重要的。我们需要确保我们的代码按预期工作。在这个例子中，我们可能需要打印出或查看所选课程列表的内容，来确认我们的方法是否有效。虽然我不确定什么是最佳实践，但打印出来查看通常是一个简单有效的方法。 这就是实现搜索按钮的基本步骤。希望这能帮助你理解如何在Salesforce中处理这样的任务。如果有任何疑问，随时问我！

  ▶ 播放视频 查看详情
• 368

  Navigating and Displaying Search Results

  第 451 页

  同学们，今天我们来聊聊Salesforce中的导航和搜索结果的处理。想象一下，你正在使用一个Salesforce应用，比如一个在线学习平台。你点击了一个按钮，比如说“查看即将推出的课程通知”。这时候，系统需要做什么呢？ 首先，系统需要理解你的请求。你点击了这个按钮，意味着你想要看到所有即将推出的课程。系统会去数据库中搜索这些课程的信息。找到之后，它需要把这些信息整理好，展示给你看。 接下来，就是导航的部分了。系统需要把你从当前的页面，带到一个新的页面。这个新页面会展示所有你感兴趣的课程信息。这个过程就像是你在网上购物，点击了一个商品，然后页面跳转到了商品的详情页。 那么，如何确保这个过程顺利进行呢？首先，开发者需要在后台设置好逻辑，确保当用户点击“查看即将推出的课程通知”时，系统能够正确地搜索并找到所有相关的课程。然后，系统需要把这些课程信息整理成一个列表，展示在新的页面上。 最后，就是用户体验的部分了。页面需要设计得简洁明了，让用户一眼就能看到他们想要的信息。比如，课程的名称、开课时间、讲师信息等，都应该清晰地展示出来。 总结一下，当用户点击“查看即将推出的课程通知”时，系统需要完成搜索、整理信息、导航到新页面，并在新页面上清晰地展示所有结果。这个过程需要前后端的紧密配合，确保用户能够顺利地找到他们想要的信息。 好了，这就是今天的内容。希望你们对Salesforce中的导航和搜索结果处理有了更清晰的理解。如果有任何问题，随时提问哦！

  ▶ 播放视频 查看详情
• 369

  How Will the Search Page Work? - 452

  第 452 页

  让我们来聊聊这个搜索页面是怎么工作的。想象一下，你有一个魔法盒子，里面装满了你之前挑选的课程包装器。现在，你想从这个盒子里找出所有未来要上的课程。这个搜索页面就是你的魔法棒，它会帮你做到这一点。 首先，这个页面会打开你的魔法盒子，也就是获取你之前选中的课程包装器列表。然后，它会用这些包装器作为线索，去查询所有未来的课程交付。这就像是用一张地图，根据你标记的地点，找到所有你要去的目的地。 查询完成后，页面就会把这些未来的课程展示给你看。你可以看到课程的名称、时间、地点等信息，就像是在看一张详细的行程表。这样，你就能轻松地知道接下来要上哪些课，什么时候上，在哪里上。 简单来说，这个搜索页面就是一个帮你从一堆课程中找出未来课程的工具，让你能够轻松规划你的学习旅程。

  ▶ 播放视频 查看详情
• 370

  Working with PageReferences

  第 453 页

  今天我们来聊聊Salesforce中的PageReference对象。这个对象在Salesforce开发中非常有用，尤其是在处理页面导航和URL参数时。 首先，PageReference对象主要用于两件事：一是查看或设置页面的URL查询字符串参数，也就是我们常说的URL中的那些“?name=value”部分；二是作为操作方法的结果，将用户从一个页面导航到另一个页面。 想象一下，你正在开发一个Salesforce应用，用户点击一个按钮后，你需要将他们带到另一个页面，并且还要传递一些信息。这时候，PageReference就派上用场了。你可以创建一个PageReference对象，指定目标页面的URL，并添加必要的查询参数。 举个例子，假设你有一个页面叫“AccountDetail”，你想在用户点击按钮后跳转到这个页面，并且传递一个账户ID作为参数。你可以这样做： ```apex PageReference pageRef = new PageReference(&#39;/apex/AccountDetail&#39;); pageRef.getParameters().put(&#39;id&#39;, &#39;001XXXXXXXXXXXXXXX&#39;); return pageRef; ``` 这段代码创建了一个指向“AccountDetail”页面的PageReference对象，并添加了一个名为“id”的查询参数。当用户点击按钮时，他们就会被带到这个页面，并且页面上可以使用这个“id”参数来显示相应的账户信息。 除了这些基本功能，PageReference还有一些高级用法，比如获取或设置cookie、获取或设置页面锚点（就是URL中的“#”部分），甚至获取页面的标题。不过这些功能超出了我们今天的讨论范围。 最后，PageReference还提供了两个非常有用的方法：getContent和getContentAsPDF。getContent可以获取页面的HTML内容，而getContentAsPDF则可以将页面内容转换为PDF格式。这在需要生成报告或导出页面内容时非常有用。 好了，今天关于PageReference的介绍就到这里。希望这些内容能帮助你在Salesforce开发中更好地使用这个强大的对象。如果有任何问题，随时问我！

  ▶ 播放视频 查看详情
• 371

  Instantiating Pages Using PageReferences

  第 454 页

  让我们来聊聊如何在Salesforce中实例化页面。简单来说，实例化页面就是创建一个页面的引用，这样我们就可以在代码中操作这个页面了。根据页面的类型，我们有四种不同的方法来实例化页面。 首先，如果你想要引用当前正在显示的页面，你可以使用`ApexPages.currentPage()`。这个方法会返回一个`PageReference`对象，它代表的就是当前页面。 接下来，如果你想要引用一个Visualforce页面，你可以使用`Page.visualforcePageName`。这里需要注意的是，`visualforcePageName`是你Visualforce页面的名字。使用这个方法时，这个Visualforce页面必须存在，否则你的代码在编译时就会出错。 第三种情况是，如果你想要引用Salesforce中的一个页面，但这个页面可能不是Visualforce页面，你可以使用`new PageReference(&#39;partialURL&#39;)`。这里的`partialURL`是指在你Salesforce服务器的URL之后的部分。比如说，如果你想要引用一个特定记录的详细信息页面，你可以使用`&#39;/&#39; + &#39;recordID&#39;`，其中`recordID`就是那个记录的ID。 最后，如果你想要引用一个非Salesforce的网站页面，你可以使用`new PageReference(&#39;fullURL&#39;)`。这里的`fullURL`就是那个网站的完整URL地址。 总结一下，根据你想要的页面类型，你可以选择不同的方法来实例化页面。希望这些信息对你有帮助！

  ▶ 播放视频 查看详情
• 372

  Working With URL Parameters

  第 455 页

  让我们来聊聊如何在Salesforce中使用URL参数。想象一下，你正在浏览一个网站，有时候你会注意到网址后面跟着一些奇怪的字符和数字，比如“?id=12345”。这些就是URL参数，它们可以帮助网站知道你想要查看的具体内容。 在Salesforce中，我们也可以使用URL参数来控制页面的行为。比如说，如果你有一个Visualforce页面，这个页面可以显示某个特定的记录，比如一个课程完成证书。你可以通过URL参数告诉这个页面：“嘿，我需要看的是ID为12345的记录。” 在代码中，我们通常会使用一个叫做“setRedirect”的方法，或者它的集合版本，来设置这些参数。虽然在我们当前的例子中可能用不到这个方法，但了解它的存在是很重要的。这样，当你需要让页面根据不同的记录显示不同的内容时，你就可以轻松地添加相应的参数了。 所以，下次当你看到一个URL后面跟着一串参数时，你就知道，这些小小的字符其实在背后做了很多工作，帮助我们获取到正确的信息。

  ▶ 播放视频 查看详情
• 373

  Navigating to a New Page Using a PageReference

  第 456 页

  让我们来聊聊如何在Salesforce中使用`PageReference`来导航到新页面。这个过程其实很简单，我会用通俗易懂的方式来解释。 首先，`PageReference`是Salesforce中的一个类，它可以帮助我们在Apex代码中控制页面的跳转。比如，当用户点击一个按钮后，我们可能希望他们被带到另一个页面。这时候，`PageReference`就派上用场了。 我们来看一个简单的例子。假设我们有一个控制器类`MySecondController`，里面有一个方法`Save`。这个方法的作用是保存一个`Account`记录，然后跳转到这个`Account`的详情页面。 ```apex public class MySecondController { Account account; public Account getCal() { if (account == null) account = new Account(); return account; } public PageReference Save() { insert account; PageReference acctPage = new ApexPages.StandardController(account).view(); acctPage.setRedirect(true); return acctPage; } } ``` ### 代码解析： 1. ，Account对象，：我们有一个`Account`对象，用来存储用户输入的数据。 2. ，getCal方法，：这个方法用来获取`Account`对象。如果`Account`对象是空的，我们就创建一个新的`Account`对象。 3. ，Save方法，：这是我们的重点。这个方法做了几件事： - ，插入记录，：首先，我们使用`insert account;`将`Account`记录保存到数据库中。 - ，创建PageReference，：然后，我们使用`new ApexPages.StandardController(account).view();`创建一个`PageReference`对象。这个对象会指向刚刚保存的`Account`记录的详情页面。 - ，设置重定向，：我们调用`acctPage.setRedirect(true);`来确保页面跳转时，浏览器会重新加载页面。 - ，返回PageReference，：最后，我们返回这个`PageReference`对象，Salesforce会自动将用户带到这个页面。 ### 教学要点： - ，PageReference的作用，：它可以帮助我们在Apex代码中控制页面的跳转。 - ，StandardController，：这是一个内置的控制器，它可以帮助我们轻松地操作标准对象的记录。 - ，setRedirect(true)，：这个方法确保页面跳转时，浏览器会重新加载页面，这样可以避免缓存问题。 ### 总结： 通过`PageReference`，我们可以轻松地在Apex代码中实现页面跳转。在这个例子中，我们保存了一个`Account`记录，然后跳转到这个记录的详情页面。这个过程非常直观，也很容易理解。 希望这个解释对你有帮助！如果你有任何问题，随时问我哦！

  ▶ 播放视频 查看详情
• 374

  17-5: Redirecting to a Results Page

  第 457 页

  同学们，今天我们来学习如何在Salesforce中实现重定向至结果页面的功能。这个功能在很多业务场景中都非常有用，比如在搜索后展示结果，或者在提交表单后跳转到另一个页面。我们一步步来，确保大家都能跟上。 ### 1. 在控制器中添加返回页面引用的行（TODO#1） 首先，我们需要在控制器中添加一行代码，用来导航到`listDeliveries`中的`ListCourseDeliveries`页面。这个页面是用来展示课程交付信息的列表。你可以想象成，当你点击某个按钮后，系统会自动跳转到这个列表页面。 ```apex public PageReference listDeliveries() { PageReference pageRef = new PageReference(&#39;/apex/ListCourseDeliveries&#39;); pageRef.setRedirect(true); return pageRef; } ``` 这段代码的意思是，当我们调用`listDeliveries`方法时，系统会创建一个新的页面引用，指向`ListCourseDeliveries`页面，并且设置重定向为`true`，确保页面跳转。 ### 2. 编写交付属性（TODO#2） 接下来，我们需要在控制器中编写交付属性。这个属性是用来存储我们从数据库中查询到的交付信息。你可以把它想象成一个容器，用来存放我们要展示的数据。 ```apex public List deliveries { get; set; } public YourControllerClass() { deliveries = [SELECT Id, Name, Course__c, Start_Date__c, End_Date__c FROM Course_Delivery__c]; } ``` 在这段代码中，我们定义了一个`deliveries`属性，它是一个`Course_Delivery__c`对象的列表。在控制器的构造函数中，我们查询了所有`Course_Delivery__c`记录，并将结果赋值给`deliveries`属性。 ### 3. 添加`newSearch()`方法（TODO#2） 接下来，我们需要添加一个`newSearch()`方法。这个方法的作用是清空当前的搜索结果，并重新加载页面，以便用户可以开始新的搜索。 ```apex public PageReference newSearch() { deliveries.clear(); return null; } ``` 这个方法很简单，它只是清空了`deliveries`列表，并返回`null`，表示页面不需要跳转。 ### 4. 在页面中添加页面块表（TODO#3） 现在，我们来到页面的部分。我们需要在页面上添加一个表格，用来展示我们查询到的交付信息。这个表格应该包含以下几列：`Name`、`Course`、`Start Date`和`End Date`。 ```html ``` 这段代码创建了一个表格，每一行对应一个`delivery`对象，每一列展示`delivery`的不同属性。 ### 5. 在页面顶部添加`newSearch`按钮（TODO#4） 最后，我们需要在页面的顶部添加一个`newSearch`按钮。这个按钮的作用是让用户能够重新开始搜索。 ```html ``` 这个按钮会调用我们之前定义的`newSearch()`方法，清空当前的搜索结果，并重新加载页面。 --- 好了，同学们，这就是我们今天要学习的内容。我们一步步实现了从控制器到页面的重定向功能，并且添加了搜索结果的展示和重新搜索的功能。希望大家都能理解并掌握这些知识点。如果有任何问题，随时提问！

  ▶ 播放视频 查看详情
• 375

  Module Agenda - 458

  第 458 页

  同学们，今天我们来聊聊Salesforce中的自定义控制器和控制器扩展。这部分内容听起来可能有点技术性，但其实只要理解了基本概念，就会发现它其实挺直观的。 首先，什么是自定义控制器？简单来说，它就是一段Apex代码，用来控制页面的行为和逻辑。你可以把它想象成一个指挥家，指挥着页面上各个元素如何互动和响应。 接下来是控制器扩展。这就像是在已有的控制器上添加一些额外的功能。比如，你有一个基础控制器，但你想在某个特定页面上添加一些特殊的功能，这时候就可以用控制器扩展来实现。 在编写这些控制器时，我们会经常用到Getters和Setters。Getter是用来获取数据的，而Setter是用来设置数据的。想象一下，你有一个盒子，Getter就是打开盒子看看里面有什么，Setter就是往盒子里放东西。 然后我们还有行动方法。这些方法定义了当用户点击按钮或执行某些操作时，应该发生什么。比如，用户点击“保存”按钮后，数据应该如何保存。 当然，编写代码时难免会遇到错误。处理基本错误就是确保当出现问题时，系统能够优雅地处理，而不是直接崩溃。 最后，关于返回空而不是PageReference的例子。在一些高级场景，比如使用Ajax进行页面部分刷新时，返回空是完全可以接受的。这意味着页面不会跳转，而是只更新页面的某一部分。 好了，这就是今天的内容。希望这些解释能帮助大家更好地理解Salesforce中的自定义控制器和控制器扩展。如果有任何问题，随时提问哦！

  ▶ 播放视频 查看详情
• 376

  Writing Controller Code to HANDLE Errors

  第 459 页

  让我们来聊聊如何在Salesforce的Visualforce页面中处理错误。这其实就像是在做菜时，有时候火候不对，菜可能会糊掉，我们需要提前做好准备，防止这种情况发生。 首先，我们有两种主要的情况需要处理错误： 1. ，第一种情况，：当你的操作可能会引发异常时，比如你尝试保存一条记录，但这条记录违反了某些验证规则。这时候，我们可以使用`try/catch`块来捕获这些异常。就像你在厨房里，如果锅里的油开始冒烟，你会立即关火，防止火灾发生。在代码中，`try`块里是你尝试执行的操作，而`catch`块则是你处理异常的地方。如果`try`块里的操作出了问题，程序就会跳到`catch`块，执行里面的代码，这样你就可以给用户一个友好的错误提示，而不是让程序崩溃。 2. ，第二种情况，：有些错误不会引发异常，比如用户输入了两个相同的值，而你的业务逻辑要求这两个值必须不同。这时候，你就需要自己编写逻辑来检查这种情况。这就像是你做菜前，会检查食材是否新鲜，调料是否齐全。在代码中，你可以在执行操作之前，先检查用户输入的值是否符合要求。如果不符合，你可以直接给用户一个提示，告诉他们哪里出错了，而不是等到操作失败后再处理。 总结一下，处理错误就像是做菜时的风险管理。对于可能引发异常的操作，使用`try/catch`来捕获和处理；对于不会引发异常的错误，提前检查并给出提示。这样，你的Visualforce页面就能更加健壮，用户体验也会更好。

  ▶ 播放视频 查看详情
• 377

  Displaying Error Messages in Visualforce Pages

  第 460 页

  今天我们来聊聊如何在Visualforce页面中处理错误消息。首先，我们有两个非常重要的标签：``和``。 ``是一个非常强大的标签，它可以显示与页面相关的所有错误消息，不管这些消息是从哪里来的。这意味着，无论是验证错误、Apex代码中的错误，还是其他任何类型的错误，只要它们与页面相关，这个标签都能捕捉并显示出来。 而``则是一个用来显示单个消息的标签。它和``看起来很像，但它只显示一条消息。这个标签非常适合用来显示那些你希望用户始终能看到的警告或错误信息。 这里有一个小技巧：当你在使用``标签时，一定要记得使用``。如果你不这样做，用户可能就看不到表单保存时生成的错误消息了（当然，输入字段的验证错误除外）。 最后，如果你想更深入地了解如何在Visualforce页面中使用黄色背景框来显示错误消息，可以参考这个链接：[额外材料](https://eltoroit.herokuapp.com/Blog.app?页面=显示错误在Visual Force页面使用黄色背景框)。这个链接会带你到一个更详细的教程，帮助你更好地掌握这个技巧。 好了，这就是今天的内容。希望这些信息对你有帮助，如果你有任何问题，随时问我！

  ▶ 播放视频 查看详情
• 378

  17-6: Handle Basic Save Errors in Your Method

  第 461 页

  让我们一步一步来完成这个任务。首先，我们需要确保在用户点击“查看即将推出的课程通知”按钮之前，他们已经选择了一个课程。如果没有选择课程，我们需要显示一个错误消息。 ### 第一步：添加条件逻辑来检查所选课程 在你的控制器中，找到处理按钮点击的方法。在这个方法中，我们需要添加一些条件逻辑来检查用户是否选择了课程。假设你有一个列表来存储用户选择的课程，我们可以检查这个列表是否为空。 ```apex public PageReference viewUpcomingCourses() { if (selectedCourses.isEmpty()) { ApexPages.addMessage(new ApexPages.Message(ApexPages.Severity.ERROR, &#39;请至少选择一个课程。&#39;)); return null; } // 如果有选择课程，继续执行重定向或其他逻辑 return Page.UpcomingCoursesPage; } ``` 在这段代码中，`selectedCourses` 是一个存储用户选择课程的列表。如果这个列表为空，我们使用 `ApexPages.addMessage` 方法来添加一个错误消息，并返回 `null` 来阻止页面重定向。 ### 第二步：将标签添加到您的Visualforce页面 接下来，我们需要在Visualforce页面上显示这个错误消息。你可以在页面的顶部添加一个 `` 标签来显示所有的消息。 ```html ``` `` 标签会自动显示所有通过 `ApexPages.addMessage` 添加的消息。 ### 第三步：测试代码更改 最后，我们需要测试我们的代码更改。你可以尝试以下步骤： 1. 不选择任何课程，直接点击“查看即将推出的课程通知”按钮。你应该会看到一个错误消息提示你选择至少一个课程。 2. 选择一个或多个课程，然后点击按钮。页面应该正常重定向到“即将推出的课程”页面。 通过这些步骤，我们成功地添加了简单的错误处理逻辑，确保用户在点击按钮之前已经选择了课程。这不仅提高了用户体验，还避免了潜在的错误。

  ▶ 播放视频 查看详情
• 379

  Key Takeaways - 462

  第 462 页

  让我们来聊聊Salesforce中的一些关键概念，特别是关于自定义控制器和控制器扩展的部分。我会尽量用简单易懂的方式来解释，这样你听起来也会觉得轻松。 首先，想象一下，Salesforce的标准控制器就像是一个现成的工具箱，里面有很多常用的工具，可以帮助你完成大部分的工作。但是，有时候你可能需要一些特别的工具，来完成一些特别的任务，这时候标准控制器可能就不够用了。这时候，你就可以创建一个自定义控制器，或者一个控制器扩展。 自定义控制器就像是自己动手做一个全新的工具箱，里面装的全是你自己需要的工具。而控制器扩展则是在现有的工具箱里，添加一些新的工具。如果你还需要使用标准控制器里的工具，那么选择控制器扩展会更好，因为这样你既可以使用原有的工具，又可以添加新的工具。 接下来，我们聊聊Getter和Setter方法。Getter方法就像是问问题，视图（也就是你看到的页面）可以通过它来问控制器：“嘿，这个数据是什么？”然后控制器就会回答它。Setter方法则是视图告诉控制器：“嘿，我想把这个数据改成这样。”然后控制器就会按照视图的指示去修改数据。 属性（Property）在Salesforce中是一个很方便的东西，它可以直接使用Getter和Setter方法，这样你就不用每次都手动去调用这些方法了。 动作方法（Action Method）可以返回一个PageReference，这就像是告诉Salesforce：“好了，我们现在要去这个页面。”这样你就可以实现页面的跳转，或者执行一些自定义的逻辑。 最后，标签是一个非常有用的东西。它可以在页面上显示错误信息，这样当用户操作出错时，他们就能立刻知道哪里出了问题，而不是一脸茫然。 好了，这就是今天的内容。希望这些解释能帮助你更好地理解Salesforce中的这些概念。如果有任何问题，随时问我哦！

  ▶ 播放视频 查看详情
• 380

  Knowledge Check - 463

  第 463 页

  让我们来聊聊这段代码和SOQL的一些基础知识。 首先，SOQL（Salesforce Object Query Language）是Salesforce中用来查询数据的语言。它和SQL有点像，但有一些不同之处。比如，SOQL不支持像SQL中的`SELECT *`这样的语法。也就是说，你不能简单地用`SELECT *`来获取所有字段。你必须明确指定你想要查询的字段。比如，你想查询`Id`和`Name`字段，你就得写成`SELECT Id, Name`。 接下来，我们来看这段Apex代码。这段代码的目的是查询`Certification_Attempt__c`对象的数据，并将结果存储在一个列表中。代码中有一个`get`方法，它会在`certAttempts`为空时执行一个SOQL查询，查询的结果会被存储在`certAttempts`这个列表中。 但是，这里有一个小问题。在SOQL查询中，如果你查询的是多个记录，那么你必须用一个列表来存储这些记录。你不能用一个单一的对象来存储多个记录。所以，如果你查询的结果可能有多条记录，你就必须用一个列表来接收这些结果。 在这段代码中，`certAttempts`是一个列表，所以它是可以存储多个`Certification_Attempt__c`对象的。但是，如果你尝试用一个单一的对象来接收查询结果，比如`Certification_Attempt__c certAttempt = [SELECT Id, Name FROM Certification_Attempt__c LIMIT 10];`，这就会导致运行时异常，因为查询可能会返回多个记录，而单个对象无法存储多个记录。 最后，SOQL支持在查询中使用变量绑定，特别是在`WHERE`子句中。这意味着你可以在查询中动态地插入变量的值，使得查询更加灵活。 总结一下，SOQL要求你明确指定查询的字段，查询多个记录时要用列表来存储结果，并且支持在查询中使用变量绑定。希望这些解释能帮助你更好地理解SOQL和这段Apex代码。

  ▶ 播放视频 查看详情
• 381

  Module 18: Working with List Controllers and SOSL Queries

  第 464 页

  今天我们来聊聊Salesforce中的两个非常实用的工具：列表控制器和SOSL。这两个工具可以帮助我们更高效地处理和查询数据。 首先，让我们来谈谈列表控制器。列表控制器是Salesforce提供的一个强大的工具，它允许我们在Apex代码中处理一组记录。想象一下，你有一堆数据记录，比如客户信息或者销售机会，列表控制器可以帮助你轻松地管理这些记录。你可以用它来添加、删除或者更新记录，甚至可以对记录进行排序和分页显示。这样，当你在开发页面或者处理大量数据时，列表控制器可以大大简化你的工作。 接下来，我们来看看SOSL，全称是Salesforce Object Search Language。SOSL是一种搜索语言，它允许你在Salesforce中跨多个对象进行全文搜索。比如，你可能想同时搜索客户、联系人和销售机会，看看哪些记录包含特定的关键词。SOSL就可以帮你做到这一点。它非常灵活，可以搜索文本、电子邮件、电话号码等多种类型的数据。使用SOSL，你可以快速找到你需要的信息，而不需要分别查询每个对象。 总结一下，列表控制器和SOSL是Salesforce中两个非常有用的工具。列表控制器帮助你管理一组记录，而SOSL则让你能够跨多个对象进行高效的搜索。掌握这两个工具，可以让你的Salesforce开发工作更加得心应手。希望今天的讲解对你有帮助，如果有任何问题，随时提问哦！

  ▶ 播放视频 查看详情
• 382

  Working with Lists

  第 465 页

  让我们一步一步来，我会尽量用简单易懂的方式来解释。 首先，我们需要了解什么是标准列表控制器。在Salesforce中，标准列表控制器是一个内置的功能，它可以帮助我们轻松地显示和管理对象（比如联系人）的列表。它已经内置了很多功能，比如分页、排序等，所以我们不需要从头开始写代码。 接下来，我们需要创建一个SOSL查询。SOSL是Salesforce Object Search Language的缩写，它是一种用于在多个对象和字段中搜索文本的查询语言。与SOQL（Salesforce Object Query Language）不同，SOSL可以在多个字段中搜索关键词，而SOQL只能在特定的字段中搜索。所以，如果你想要在联系人的所有文本字段中搜索某个关键词，SOSL是非常适合的。 然后，我们需要创建一个自定义列表控制器。虽然标准列表控制器很好用，但有时候我们需要更多的自定义功能。这时候，我们可以创建一个自定义的Apex类来作为列表控制器。这个类会包含我们需要的逻辑，比如执行SOSL查询，处理搜索结果等。 最后，我们需要创建一个Visualforce页面来显示搜索结果。这个页面会使用我们自定义的列表控制器，并且会显示搜索到的联系人列表。用户可以在页面上输入关键词，点击搜索按钮，然后页面会显示所有匹配的联系人。 总结一下，我们需要做以下几件事： 1. 了解标准列表控制器。 2. 创建一个SOSL查询来搜索联系人的所有文本字段。 3. 创建一个自定义的Apex类作为列表控制器。 4. 创建一个Visualforce页面来显示搜索结果。 这样，用户就可以通过这个页面轻松地搜索联系人了。希望这个解释对你有帮助！如果有任何问题，随时问我。

  ▶ 播放视频 查看详情
• 383

  Exploring Global Search

  第 466 页

  今天我们来聊聊Salesforce中的全球搜索功能，以及什么时候你可能需要创建一个自定义的搜索页面。 首先，全球搜索是一个非常强大的工具，它允许你在整个Salesforce组织中快速找到你需要的信息。比如说，如果你想找一家叫Acme的公司，你只需要在顶部的全球搜索栏中输入“Acme”，然后点击搜索。搜索结果会显示所有与Acme相关的记录，比如客户、联系人、机会等。如果你想看到更多的结果，可以点击页面底部的“搜索全部”，这样就能看到更全面的搜索结果了。 那么，什么时候你可能需要创建一个自定义的搜索页面呢？主要有两种情况： 1. ，定制搜索的字段或对象，：如果你发现默认的全球搜索不能满足你的需求，比如你需要搜索一些特定的字段或者特定的对象，这时候你就可能需要创建一个自定义的搜索页面。这样，你可以根据自己的需求来设置搜索条件，让搜索更加精准。 2. ，不同的用户界面或数据表示，：有时候，你可能希望搜索结果以不同的方式展示出来，或者你希望用户界面更加友好、直观。这时候，自定义搜索页面就能派上用场了。你可以设计一个符合你需求的界面，让用户在使用时更加方便。 总的来说，全球搜索是一个非常方便的工具，但在某些特定情况下，创建一个自定义的搜索页面可能会让你的工作更加高效。希望这些信息对你有帮助！如果有任何问题，随时问我哦！

  ▶ 播放视频 查看详情
• 384

  Module Agenda - 467

  第 467 页

  今天我们来聊聊Salesforce中的列表控制器和SOSL查询。这部分内容非常实用，能帮助你在Salesforce中更高效地管理和查询数据。 首先，我们会学习如何使用标准列表控制器。标准列表控制器是Salesforce提供的一个非常方便的工具，它可以帮助你快速地在页面上展示和操作数据列表。你不需要写太多代码，就能实现数据的展示、排序、分页等功能。 接下来，我们会编写一个简单的SOSL查询。SOSL是Salesforce Object Search Language的缩写，它是一种用于在多个对象中搜索数据的语言。通过SOSL，你可以同时搜索多个对象中的记录，这在处理复杂的数据查询时非常有用。 然后，我们会创建一个自定义列表控制器。虽然标准列表控制器很方便，但有时候我们需要更灵活的控制，这时候自定义列表控制器就派上用场了。通过自定义列表控制器，你可以完全按照自己的需求来设计和控制数据的展示和操作。 最后，我们会把这些知识应用到实际场景中，创建一个收件箱模块。这个模块会使用列表控制器和SOSL查询来展示和管理收件箱中的信息。通过这个模块，你可以更好地理解如何在实际项目中使用这些技术。 好了，这就是我们今天的主要内容。希望你能通过这些学习，掌握Salesforce中列表控制器和SOSL查询的使用，提升你的开发效率。如果有任何问题，随时提问哦！

  ▶ 播放视频 查看详情
• 385

  Standard List Controllers

  第 468 页

  今天我们来聊聊Salesforce中的标准列表控制器。这个工具非常有用，特别是当你想要超越Salesforce提供的标准用户界面时。 首先，标准列表控制器允许你在Visualforce页面上展示一组记录。你可以使用它来创建一个完全自定义的用户体验。比如，你可能不想用Salesforce默认的列表视图，而是希望记录显示在一个网格里，或者在一个单独的标签页中查看它们。这就是标准列表控制器派上用场的地方。 在Visualforce页面中，你会用到`recordSetVar`属性。这个属性只是用来给页面上的记录集合起个名字，方便你在页面上引用这些记录。而`standardController`属性则是用来指定你想要操作的对象类型，比如账户、联系人或者机会等。 这里有个小提示：不是所有的Salesforce对象都支持标准列表控制器。目前，只有一些特定的对象可以使用这个功能，比如账户、联系人、机会等。如果你使用的是自定义对象，那么它也是支持的。 总结一下，标准列表控制器是一个强大的工具，可以帮助你创建更符合业务需求的用户界面。通过它，你可以自由地设计和实现不同于标准Salesforce界面的用户体验。希望这能帮助你更好地理解和使用标准列表控制器！

  ▶ 播放视频 查看详情
• 386

  List Views and Standard List Controllers

  第 469 页

  今天我们来聊聊Salesforce中的列表视图和标准列表控制器。这两个功能在日常工作中非常实用，能帮助我们更高效地管理和查看数据。 首先，列表视图是什么呢？简单来说，列表视图就是你在Salesforce中查看记录的一种方式。比如，你有一堆客户记录，列表视图可以帮你把这些客户按照一定的条件筛选出来，并且只显示你关心的那些字段。这样，你就不用在一大堆信息中找来找去了。 那么，标准列表控制器又是什么呢？它其实是一个Apex控制器，专门用来处理列表视图中的数据。它可以帮助你在页面上显示记录，并且支持分页、排序、筛选等操作。有了它，你就可以轻松地在页面上展示和管理数据了。 接下来，我会带大家进入Salesforce的组织，看看在哪里可以找到和使用列表视图。我们不需要做复杂的配置，只需要知道如何利用列表视图来过滤记录，并选择显示哪些字段就可以了。 比如，假设你想查看所有“未关闭”的销售机会，你可以在列表视图中设置一个过滤器，只显示状态为“未关闭”的记录。然后，你可以选择只显示机会名称、金额和关闭日期这几个字段。这样一来，你就能快速找到你需要的信息了。 好了，这就是今天关于列表视图和标准列表控制器的简单介绍。希望大家能通过这个功能，更高效地管理Salesforce中的数据。如果有任何问题，随时问我哦！

  ▶ 播放视频 查看详情
• 387

  Standard List Controllers Example

  第 470 页

  让我们来聊聊这个标准列表控制器的示例。这个示例主要是教我们如何使用Salesforce的标准列表控制器来显示一个账户记录的列表。你可以把这个代码复制到你的Visualforce页面中，这样你就能看到实际的效果了。 首先，这个页面使用的是账户的标准列表控制器。这意味着它专门用来处理和显示账户相关的数据。在这个页面上，你会看到一个表格，这个表格显示了所有账户的名称。具体显示哪些账户呢？这取决于用户上次使用的列表视图。也就是说，如果你之前筛选过某些账户，那么这次显示的也会是那些账户。 这个页面没有特别指定筛选器，所以它会默认显示你上次使用的筛选器（也就是列表视图）。这就像你在Force.com API中查询数据一样，你可以使用表达式语言语法来从相关的记录中检索数据。和标准控制器一样，你可以遍历从子到父关系的五个级别，以及从父到子关系的一个级别。 当你使用标准列表控制器时，返回的记录会按照当前视图定义的第一列数据进行排序，即使这一列没有在页面上显示出来。如果你使用扩展或自定义的列表控制器，你就可以控制排序的方法了。不过要注意的是，列表控制器最多只能返回10,000条记录。 这就是这个示例的主要内容。希望这能帮助你理解如何使用标准列表控制器来显示账户记录。如果你有任何问题，随时问我哦！

  ▶ 播放视频 查看详情
• 388

  Filtering Records

  第 471 页

  同学们，今天我们来聊聊如何在Salesforce中过滤记录。这个功能非常实用，可以帮助我们快速找到我们需要的信息。 首先，如果你不指定任何过滤器，那么当你打开一个使用标准列表控制器的页面时，它会自动显示你上次访问时使用的过滤器。这意味着，系统会记住你上次的筛选条件，让你可以快速回到之前的工作状态。 接下来，如果你想向学生展示如何查看列表视图，你可以直接进入组织设置，向他们展示在哪里可以找到这些视图。这里不需要进行复杂的配置，列表视图已经内置了过滤功能，允许用户根据自己的需求筛选记录，并决定哪些字段需要显示。 最后，有一个技术细节需要注意：如果你在页面上使用了`selectList`组件，这个组件必须嵌套在`apex:form`组件中。这是因为`selectList`需要表单的支持来正确处理用户的选择和提交。 简单来说，过滤记录就是让数据更有序，帮助我们更快地找到需要的信息。记住这些小技巧，你的Salesforce使用会更加得心应手！

  ▶ 播放视频 查看详情
• 389

  Using the <apex:actionSupport> Tag

  第 472 页

  今天我们来聊聊Salesforce中的标签，以及它如何利用AJAX技术来提升用户体验。 首先，什么是AJAX呢？AJAX是“Asynchronous JavaScript and XML”的缩写，简单来说，它是一种让网页能够在不重新加载整个页面的情况下，与服务器交换数据并更新部分内容的技术。想象一下，你在查看邮件时，点击“刷新”按钮，只有收件箱部分更新了，而页面的其他部分保持不变，这就是AJAX的魔力。 在Salesforce的Visualforce页面中，标签就是用来实现这种AJAX功能的。它允许你在用户执行某些操作（比如点击按钮或改变下拉菜单选项）时，触发一个服务器端的动作，然后只更新页面的一部分，而不是整个页面。 但是，使用标签时有一个重要的注意事项：它必须作为标签的子元素使用。这意味着你需要确保你的标签是嵌套在一个标签里面的。 除了，Visualforce还提供了其他一些支持AJAX功能的标签，比如。这些标签可以帮助你更灵活地控制页面的动态更新。 如果你想深入了解这些标签的使用方法和更多细节，我推荐你查阅《Visualforce开发人员指南》，那里有更详细的解释和示例。 希望这些信息对你有帮助，如果你有任何问题，随时问我！

  ▶ 播放视频 查看详情
• 390

  Pagination with Standard List Controllers

  第 473 页

  今天我们来聊聊Salesforce中的标准列表控制器，特别是如何进行翻页操作。这个功能非常实用，尤其是在处理大量数据时。 首先，标准列表控制器是Salesforce提供的一个强大的工具，它可以帮助我们轻松地管理和展示数据。这个控制器内置了很多方法，比如翻页、排序、筛选等，这些都可以帮助我们更好地控制数据的展示方式。 现在，我们重点来看看如何进行翻页。在标准列表控制器中，有一个叫做`pageSize`的属性。这个属性决定了每页显示多少条记录。比如，如果你设置`pageSize`为10，那么每页就会显示10条记录。你可以根据实际需求调整这个数值，以适应不同的展示需求。 举个例子，假设你有一个包含100条记录的列表，如果你设置`pageSize`为10，那么整个列表就会被分成10页，每页显示10条记录。用户可以通过点击“下一页”或“上一页”来浏览不同的页面。 如果你想了解更多关于标准列表控制器的其他方法，可以参考Salesforce的官方文档。文档中详细列出了所有可用的方法和属性，帮助你更好地掌握这个工具。 总之，通过设置`pageSize`属性，你可以轻松控制每页显示的记录数，从而实现翻页功能。希望这个讲解对你有帮助！如果有任何问题，随时问我哦。

  ▶ 播放视频 查看详情
• 391

  Using Pagination Methods

  第 474 页

  同学们，今天我们来聊聊如何在Salesforce中使用分页功能。分页是一个非常实用的功能，尤其是在处理大量数据时，它可以帮助我们更有效地浏览和管理数据。 首先，我们来看一下代码。在这段代码中，我们有四个按钮：“First”（第一页）、“Previous”（上一页）、“Next”（下一页）和“Last”（最后一页）。这些按钮的功能非常直观，它们允许用户在数据集中快速导航。 这些按钮的实现依赖于几个关键的方法：`pageSize`、`pageNumber`和`ResultSize`。`pageSize`定义了每页显示多少条记录，`pageNumber`告诉我们当前是第几页，而`ResultSize`则告诉我们总共有多少条记录。这些方法都是标准集控制器（StandardSetController）的一部分，这个控制器提供了很多有用的方法来处理分页。 如果你想要查看所有可用的方法，可以访问这个链接：[StandardSetController Methods](https://developer.salesforce.com/docs/atlas.en-us.pages.meta/pages/apex_ApexPages_StandardSetController_methods.htm)。这个链接在上一个幻灯片的注释中也有提供。 接下来，我们来看一下代码的具体实现。代码中使用了`apex:commandButton`来创建这些按钮，每个按钮都有一个`action`属性，这个属性绑定到了标准集控制器的相应方法上，比如`{!First}`、`{!Previous}`、`{!Next}`和`{!Last}`。这些方法会根据用户的点击来更新当前显示的记录。 此外，代码中还有一个`apex:outputText`组件，它用来显示当前页的记录范围，比如“1到10条记录，共100条”。这个信息是通过计算`pageNumber`、`pageSize`和`ResultSize`得出的。 最后，代码中还有一个`apex:selectList`组件，它允许用户选择一个过滤器来筛选显示的记录。这个功能可以帮助用户更精确地找到他们需要的数据。 好了，这就是我们今天的内容。希望你们对Salesforce中的分页功能有了更清晰的理解。如果有任何问题，随时提问！

  ▶ 播放视频 查看详情
• 392

  18-1: Create a Page to Display a List of Records

  第 475 页

  让我们来聊聊如何在Salesforce中创建一个页面来显示记录列表。这个功能非常实用，尤其是在你需要快速查看和管理大量数据时。 首先，我们使用了一个叫做``的标签。这个标签可以帮助我们在页面上创建一个表格，用来展示我们的记录。在这个表格里，每一行代表一个记录，每一列则代表记录中的一个字段。 在这个例子中，我们展示了一个账户列表。我们通过`value=&quot;{!accounts}&quot;`来绑定数据源，这里的`accounts`是一个在后台控制器中定义的变量，它包含了我们要展示的所有账户记录。然后，我们使用`var=&quot;acct&quot;`来定义一个变量，这个变量在表格的每一行中代表一个账户记录。 接下来，我们使用``标签来定义表格中的每一列。每一列都对应账户记录中的一个字段，比如账户名称（`Name`）、电话（`Phone`）、行业（`Industry`）、网站（`Website`）和支持级别（`Support_Level__c`）。这样，当页面加载时，每个账户的这些信息就会整齐地显示在表格中。 此外，我们还使用了一个叫做``的标签。这个标签允许我们在用户进行某些操作时（比如改变选择列表中的选项），动态地更新页面上的内容。在这个例子中，当用户改变选择列表中的选项时，``会触发一个重新渲染的动作，更新`accountList`区域的内容。同时，我们还设置了一个状态提示``，当系统在处理用户的请求时，会显示“Working...”来告知用户系统正在工作。 总的来说，这个页面通过简单的标签和逻辑，就能有效地展示和管理Salesforce中的记录，非常适合需要快速查看和操作数据的场景。希望这个解释能帮助你更好地理解如何在Salesforce中创建和使用这样的页面。

  ▶ 播放视频 查看详情
• 393

  Module Agenda - 476

  第 476 页

  同学们，今天我们来聊聊Salesforce中的列表控制器和SOSL查询。这个模块的内容非常实用，能帮助你们更好地管理和查询数据。 首先，我们会学习如何使用标准列表控制器。这个控制器是Salesforce提供的一个内置工具，它能帮助我们轻松地展示和操作数据列表。比如，你可以用它来显示一组客户记录，并且允许用户对这些记录进行排序、筛选等操作。 接下来，我们会编写一些简单的SOSL查询。SOSL是Salesforce Object Search Language的缩写，它是一种强大的搜索语言，可以跨多个对象进行搜索。比如，你可以用SOSL来查找所有包含某个关键词的客户、联系人或者机会记录。 然后，我们会创建一个自定义列表控制器。这个控制器允许你根据自己的需求来定制数据列表的展示方式。比如，你可以控制哪些字段显示在列表中，或者添加一些自定义的按钮和操作。 最后，我们会把这些知识应用到实际场景中，创建一个收件箱功能。这个收件箱会使用列表控制器和SOSL查询来展示和管理用户的邮件记录。 好了，这就是我们今天要学习的内容。希望大家能跟上节奏，有任何问题随时提问。我们开始吧！

  ▶ 播放视频 查看详情
• 394

  Anatomy of a Simple SOSL FIND Statement

  第 477 页

  让我们来聊聊SOSL，也就是Salesforce Object Search Language。你可以把它想象成一个超级方便的搜索引擎，但它不是用来搜索网页的，而是用来搜索Salesforce里面的数据。 首先，SOSL的核心就是“FIND”这个关键字。你只需要用“FIND”加上你想要搜索的文本，SOSL就会帮你在Salesforce的所有对象中查找包含这个文本的记录。比如，你想找所有提到“客户支持”的记录，你就可以用SOSL来搜索。 这里有个小提示：SOSL搜索是不区分大小写的。也就是说，无论你输入的是“客户支持”还是“客户支持”，它都能找到相关的结果。 Andres P.曾经说过，SOQL是用来查询的，而SOSL是用来搜索的。这句话很好地概括了两者的区别。SOQL更像是精确的数据库查询，而SOSL则更像是一个广泛的文本搜索工具。 在接下来的课程中，我们会通过一些具体的例子来深入探讨SOSL的用法，这样你就能更好地理解如何在Salesforce中使用它来找到你需要的信息了。

  ▶ 播放视频 查看详情
• 395

  The FIND Clause: Using Wildcards in SOSL Search Terms

  第 478 页

  今天我们来聊聊Salesforce中的SOSL搜索，特别是关于如何使用通配符来优化我们的搜索。SOSL，也就是Salesforce Object Search Language，是一种非常强大的工具，可以帮助我们在Salesforce中快速找到我们需要的数据。 首先，我们来看看星号（*）的使用。星号在SOSL中代表零个或多个字符。但是，它只能用在搜索词的中间或末尾，不能用在开头。举个例子，如果你搜索“John*”，那么你可能会找到John、Johnson或者Johnny这样的结果。再比如，搜索“mi*Meyers”可能会找到Mike Meyers或者Michael Meyers。如果你需要搜索一个实际的星号字符，记得在星号前面加上一个反斜杠（\）来转义它。 接下来是问号（？）的使用。问号代表一个字符，它也只能用在搜索词的中间或末尾。比如，搜索“Jo？n”可能会找到John或者Joan，但不会找到Jon或者Johan。 在SOSL中，你还可以使用逻辑运算符，比如AND、OR、AND NOT等，来构建更复杂的查询。例如，你可以使用“Find{A？M*}”这样的混合查询，这在查询编辑器中是有效的。 最后，对于中文、日文、韩文和泰文（CJKT）的搜索，除了精确短语搜索外，单个字符的末尾会自动附加一个通配符（*），这有助于提高搜索的灵活性和准确性。 希望这些信息能帮助你在Salesforce中更有效地使用SOSL进行搜索。如果你有更多问题，随时欢迎提问！

  ▶ 播放视频 查看详情
• 396

  The IN Clause: Specifying a Search Group

  第 479 页

  今天我们来聊聊Salesforce中的IN子句，特别是关于如何指定搜索组。这个功能可以帮助我们更精确地找到我们需要的数据。 首先，IN子句允许我们指定在哪些字段中进行搜索。如果我们不指定IN子句，Salesforce默认会在所有可搜索的字段中进行查找。这听起来很方便，但有时候我们可能只需要在特定的字段中搜索，比如电子邮件或名称字段。 例如，如果我们只想在电子邮件字段中搜索，我们可以使用“IN EMAIL FIELDS”。这样，Salesforce就只会查看电子邮件字段，而忽略其他字段。同样地，如果我们只想在名称字段中搜索，我们可以使用“IN NAME FIELDS”。这对于自定义对象特别有用，因为我们可以指定哪个字段作为名称字段。 此外，还有电话字段的搜索选项，即“IN PHONE FIELDS”，这让我们可以仅搜索电话号码字段。 不过，有一个叫做“边栏字段”的搜索选项，虽然它曾经很流行，但现在用得比较少了。这个选项允许我们搜索边栏下拉列表中列出的有效记录。与应用程序中的搜索不同，这里的星号(*)通配符不会自动附加到搜索字符串的末尾。 最后，需要注意的是，当我们选择“所有字段”进行搜索时，并不是所有的字段都会被搜索。例如，文本、电子邮件和电话字段不会被搜索。此外，一些特定的对象和字段，如选择列表、数字、日期或复选框字段，以及某些对象的附件记录，也不会被搜索。如果我们需要搜索这些类型的数据，我们可能需要使用Query()调用。 希望这些信息能帮助你更好地理解和使用Salesforce中的IN子句和搜索功能。如果有任何疑问，随时提问哦！

  ▶ 播放视频 查看详情
• 397

  The RETURNING Clause

  第 480 页

  今天我们来聊聊Salesforce中的RETURNING子句。这个子句在SOQL查询中非常有用，它允许我们指定查询返回哪些字段或对象。听起来有点复杂，但其实很简单，我们一步步来看。 首先，RETURNING子句是用来决定查询结果中返回哪些数据的。它不会影响我们搜索哪些数据，只会影响我们最终看到哪些数据。 举个例子，如果我们只想从一个对象中返回Id字段，我们可以这样写： ```sql SELECT Id FROM Account ``` 这里，我们只返回了Account对象的Id字段。 如果我们想从多个对象中返回Id字段，比如Account和Contact，我们可以这样写： ```sql SELECT Id FROM Account SELECT Id FROM Contact ``` 这样，我们就能同时看到Account和Contact的Id了。 接下来，如果我们想从一个对象中返回特定的字段，比如Account的Name和Phone字段，我们可以这样写： ```sql SELECT Name, Phone FROM Account ``` 这样，查询结果中就会包含Account的Name和Phone信息。 最后，如果我们只想返回满足特定条件的记录，比如所有名字中包含“Acme”的Account，我们可以这样写： ```sql SELECT Id, Name FROM Account WHERE Name LIKE &#39;%Acme%&#39; ``` 这里，我们使用了WHERE子句来筛选出名字中包含“Acme”的Account，并且只返回这些Account的Id和Name字段。 总结一下，RETURNING子句帮助我们精确控制查询结果中返回哪些数据，而不会影响我们搜索哪些数据。希望这个解释能帮助你更好地理解RETURNING子句的用法。如果有任何问题，随时问我哦！

  ▶ 播放视频 查看详情
• 398

  Where Can You Use SOSL?

  第 481 页

  让我们来聊聊SOSL（Salesforce Object Search Language）的使用场景和一些教师需要注意的事项。 首先，SOSL主要用于在Salesforce中进行跨对象的搜索。想象一下，你有一个大图书馆，里面有各种各样的书，SOSL就像是一个超级智能的图书管理员，可以帮助你快速找到你需要的书，不管它们放在哪个书架上。 在Apex编程中，SOSL的使用有一个特别的要求：你必须使用RETURNING子句。这个子句告诉Salesforce你想要从哪些对象中返回数据。比如，如果你想找所有关于“Acme”公司的记录，你可能会写一个SOSL查询，指定你想要从“Account”和“Contact”这两个对象中返回数据。 但是，这里有一个小陷阱。在Developer控制台的查询编辑器中，你可以直接写一个简单的搜索，比如“查找{Acme}”，这在那里是可行的。然而，如果你在Apex代码中尝试这样做，就会遇到问题，因为Apex要求你必须明确指定RETURNING子句。 所以，作为教师，你需要确保学生们理解这一点：在Apex中使用SOSL时，RETURNING子句是必不可少的。这不仅帮助他们编写正确的代码，也让他们更好地理解Salesforce的数据检索机制。 希望这个解释对你有帮助！如果你有任何问题，随时问我。

  ▶ 播放视频 查看详情
• 399

  Comparing SOSL and SOQL

  第 482 页

  大家好，今天我们来聊聊Salesforce中的两种查询语言：SOQL和SOSL。虽然它们都可以用来查询数据，但它们各有特点和适用场景。 首先，SOQL，也就是Salesforce Object Query Language，主要用于从单个对象中查询数据。它非常适合当你需要从特定的对象中获取数据，并且你知道具体要查询哪些字段时使用。SOQL的查询非常精确，可以指定具体的字段和条件来获取数据。 而SOSL，即Salesforce Object Search Language，则更适合进行文本搜索。当你需要在多个对象中搜索包含特定文本的记录时，SOSL就显得非常有用。它特别适用于用户交互场景，比如用户在移动设备上搜索信息时，SOSL可以帮助他们快速找到所需内容，而不需要浏览一长串的选项。 在使用这两种查询语言时，有几个注意事项需要记住： 1. 如果你在搜索表达式中使用了前导通配符或包含词，SOSL通常会比SOQL更快。 2. 当SOQL查询中使用多个WHERE筛选器时，即使字段已被索引，也可能无法使用索引。这时，将查询分解为多个简单的查询，然后组合结果，可能会更有效。 3. 避免在WHERE筛选器中使用空值进行查询，因为这会导致无法使用索引，从而需要扫描整个数据库。 4. 如果查询字段可能传入空值，先检查空值，避免不必要的查询执行。 在设计定制查询或搜索界面时，记得： - 尽量减少查询的字段数量，特别是在大数据环境中，这样可以更容易进行性能调优。 - 根据需求决定使用SOQL、SOSL还是它们的组合。 希望这些信息能帮助大家更好地理解和使用SOQL和SOSL。如果有任何疑问，欢迎随时提问！

  ▶ 播放视频 查看详情
• 400

  Choosing Between SOSL and SOQL

  第 483 页

  同学们，今天我们来聊聊在Salesforce中如何选择使用SOSL还是SOQL。这两种查询语言各有特点，适用于不同的场景。我们通过几个例子来理解它们的使用场景。 首先，SOSL，也就是Salesforce Object Search Language，它主要用于在多个字段和多个对象中搜索文本。比如，如果你想要查找所有包含“笔记本电脑”这个词的记录的名称和ID，SOSL就非常合适。因为它可以在多个字段中搜索，找到所有相关的记录。 接下来是SOQL，Salesforce Object Query Language，它主要用于在一个对象中查询满足特定条件的记录，并且可以对结果进行排序。比如，如果你想要按交付日期的顺序列出未来某个课程的所有交付，SOQL就是你的好帮手。你可以指定条件，比如只选择未来的交付，并且按日期排序。 再来看一个例子，如果你需要计算名称字段中带有“Acme”的机会记录的数量，SOQL也能胜任。你可以写一个查询，只选择那些名称中包含“Acme”的记录，然后使用COUNT()函数来计算数量。 总结一下，如果你需要在多个字段和对象中搜索文本，选择SOSL。如果你需要在一个对象中查询特定条件并对结果进行排序或计数，选择SOQL。希望这些例子能帮助你们更好地理解何时使用SOSL和SOQL。

  ▶ 播放视频 查看详情
• 401

  What Does a SOSL Search Return?

  第 484 页

  让我们来聊聊SOSL搜索返回的内容。想象一下，你正在使用SOSL进行搜索，就像是在一个大型图书馆里寻找不同类型的书籍。SOSL搜索的结果会返回一个列表，这个列表里包含了你在搜索时指定的各种类型的s对象。 具体来说，这个列表是一个“s对象列表的列表”。这是什么意思呢？简单来说，就是每个你在REITURNING条款中指定的s对象类型，都会有一个对应的列表。这些列表里装的就是符合你搜索条件的s对象。 举个例子，如果你在REITURNING条款中指定了Account和Contact这两种s对象，那么SOSL返回的列表就会有两个子列表：一个装的是Account对象，另一个装的是Contact对象。而且，这些子列表的顺序和你指定的顺序是一致的。 所以，要点就是：SOSL的结果是一个包含多种类型s对象的列表，每种类型的s对象都有自己的专属列表。 接下来，我们会看看如何处理这些SOSL结果，通过代码来操作这些列表，找到你需要的信息。这样，你就能更灵活地使用SOSL来满足你的业务需求了。

  ▶ 播放视频 查看详情
• 402

  Use Multiple For Loops to Process a <List<List<sObject>>

  第 485 页

  同学们，今天我们来聊聊如何在Salesforce中使用多个For循环来处理一个包含多个列表的列表，也就是`List&gt;`。听起来有点复杂，但其实很简单，我们一步步来。 首先，想象一下你有一个大盒子，这个大盒子里装了很多小盒子，每个小盒子里又装了一些小球。在Salesforce中，这个大盒子就是`List&gt;`，小盒子是`List`，小球就是`sObject`，也就是我们的数据记录。 现在，假设我们有两个小盒子，分别叫`acmes[0]`和`acmes[1]`。`acmes[0]`是第一个小盒子，里面装了一些小球；`acmes[1]`是第二个小盒子，里面也装了一些小球。我们的任务是逐个查看这些小盒子里的每个小球。 我们可以用两个For循环来完成这个任务。第一个For循环用来遍历大盒子里的每个小盒子，第二个For循环用来遍历小盒子里的每个小球。 让我们来看一下代码： ```apex List&gt; acmes = new List&gt;(); // 假设我们已经给acmes添加了一些数据 for (List smallBox : acmes) { for (sObject ball : smallBox) { System.debug(&#39;小球的信息: &#39; + ball); } } ``` 在这个代码中，第一个For循环`for (List smallBox : acmes)`会逐个取出大盒子`acmes`里的小盒子`smallBox`。然后，第二个For循环`for (sObject ball : smallBox)`会逐个取出小盒子`smallBox`里的小球`ball`，并打印出小球的信息。 你可以把这个代码复制到Salesforce的开发人员控制台的执行匿名窗口中运行。运行后，记得在日志中过滤只显示调试信息，这样你就能看到每个小球的信息被打印出来了。 通过这种方式，我们可以轻松地处理嵌套的列表结构，确保每个数据记录都被正确处理。希望这个解释对你有帮助，如果有任何问题，随时问我！

  ▶ 播放视频 查看详情
• 403

  Variable and Expression Binding in SOSL Searches

  第 486 页

  今天我们来聊聊SOSL搜索中的变量和表达绑定。这个知识点其实和SOQL中的绑定非常相似，但有一些小细节需要注意。 首先，什么是变量绑定呢？简单来说，就是我们在查询中使用变量来代替具体的值。这样做的好处是，可以让我们的查询更加灵活和动态。比如，我们可以在不同的情况下，使用不同的变量值来执行同一个查询。 在SOSL中，变量绑定是通过“：”来实现的。也就是说，当我们在查询中使用变量时，需要在变量名前加上一个冒号。比如，如果我们有一个变量叫做`searchTerm`，那么在SOSL查询中，我们就可以这样写： ```apex FIND :searchTerm IN ALL FIELDS RETURNING Account(Name), Contact(FirstName, LastName) ``` 这里，`searchTerm`就是一个变量，它会在查询执行时被替换成具体的值。 需要注意的是，SOSL中的变量绑定和SOQL中的绑定方式是一样的，都是使用“：”来绑定变量。所以，如果你已经熟悉了SOQL中的变量绑定，那么在SOSL中使用变量绑定也会非常容易上手。 总结一下，SOSL中的变量绑定是通过“：”来实现的，和SOQL中的绑定方式相同。这样做可以让我们的查询更加灵活和动态。希望这个解释能帮助你更好地理解SOSL中的变量绑定。如果有任何问题，随时问我哦！

  ▶ 播放视频 查看详情
• 404

  Governor Limits for SOSL Searches in Apex

  第 487 页

  让我们来聊聊Apex中的SOSL（Salesforce Object Search Language）和它的总督限制。首先，SOSL是一种在Salesforce中搜索多个对象的强大工具，但就像任何强大的工具一样，它也有一些使用上的限制，我们称之为“总督限制”。 这些限制主要包括三个方面： 1. ，发出的SOSL搜索总数，：这意味着在你的Apex代码中，你只能执行一定数量的SOSL搜索。这个数量是有限制的，所以你需要确保你的代码不会超过这个限制。 2. ，单次SOSL搜索检索到的记录总数，：每次你执行一个SOSL搜索，它只能返回一定数量的记录。如果你需要处理大量数据，你可能需要分多次搜索来处理。 3. ，堆的总大小，：这是指你的Apex代码在执行过程中使用的内存总量。SOSL搜索也会占用一部分内存，所以你需要确保你的代码不会因为内存使用过多而失败。 这些限制不仅适用于普通的SOSL搜索，也适用于临时SOSL搜索。所以，无论你是在开发新的功能还是在维护现有的代码，都需要时刻注意这些限制。 如果你想了解更多关于这些限制的具体数值，你可以通过Salesforce的帮助和培训资源搜索“Apex Governor Limits”来找到最新的信息。同时，我建议你查看相关的PDF文档，那里会有更详细的说明和当前的限制数值。 记住，了解并遵守这些限制，可以帮助你编写出更高效、更稳定的Apex代码。希望这些信息对你有所帮助！

  ▶ 播放视频 查看详情
• 405

  Testing SOSL Searches

  第 488 页

  让我们来聊聊Salesforce中的SOSL搜索和如何在Apex测试中使用它。 首先，SOSL是Salesforce Object Search Language的缩写，它允许你在多个对象中搜索特定的文本。这在Apex代码中非常有用，尤其是当你需要跨多个对象查找数据时。 但是，当你在Apex测试方法中使用SOSL查询时，默认情况下，Salesforce不会返回任何搜索结果。这是为了确保测试的独立性和可重复性，避免测试结果受到实际数据的影响。 那么，如何在测试中模拟SOSL查询的返回结果呢？这里就用到`Test.setFixedSearchResults`方法了。这个方法允许你定义一个固定的搜索结果集，这样当你的测试方法执行SOSL查询时，它会返回你预先设定的记录ID列表。 具体来说，`Test.setFixedSearchResults`方法接受一个ID列表作为参数。这个列表中的ID代表了SOSL查询应该返回的记录。当你调用这个方法后，任何在测试方法中执行的SOSL查询都会返回这些ID对应的记录。 例如，假设你有一个SOSL查询在测试中搜索特定的客户名称。你可以使用`Test.setFixedSearchResults`来设置一些预定义的客户ID，这样当测试执行时，SOSL查询就会返回这些客户记录，而不是空的搜索结果集。 总结一下，`Test.setFixedSearchResults`是一个非常强大的工具，它允许你在Apex测试中控制SOSL查询的返回结果，确保你的测试既可靠又可预测。希望这个解释对你有帮助！如果你有任何问题，随时问我。

  ▶ 播放视频 查看详情
• 406

  18-2: Integrate SOSL Search in a Visualforce Page

  第 489 页

  让我们来聊聊如何在Visualforce页面中集成SOSL搜索，以及一些相关的知识点。 首先，SOSL（Salesforce Object Search Language）是Salesforce提供的一种搜索语言，它允许你在多个对象和字段中执行搜索。与SOQL（Salesforce Object Query Language）不同，SOSL可以跨对象搜索，非常适合在需要广泛搜索时使用。 ### 1. 在SOSL搜索中使用IN Name Fields条款 你可能会问，什么时候会在SOSL搜索中使用`IN Name Fields`条款呢？简单来说，当你想要将搜索限制在那些`nameField`属性设置为`true`的字段时，就可以使用这个条款。这些字段通常是对象的名称字段，比如Account的“Name”字段。通过使用`IN Name Fields`，你可以确保搜索只在这些特定的字段中进行，从而提高搜索的精确度。 ### 2. SOSL中的通配符 接下来，我们来看看SOSL中可以使用哪些通配符。SOSL支持两种通配符： - ，?（问号），：这个通配符用于匹配单个字符。比如，如果你搜索`te?t`，它可以匹配到“test”或“text”。 - ，\，*（星号）：这个通配符用于匹配多个字符。比如，如果你搜索`te*t`，它可以匹配到“test”、“text”甚至“teapot”。 这些通配符可以帮助你在搜索时更加灵活，尤其是在你不确定完整的关键词时。 ### 3. 将SOSL集成到Visualforce页面中 现在，让我们来看看如何将SOSL搜索集成到Visualforce页面中。你可以通过以下步骤来实现： 1. ，创建Apex控制器，：首先，你需要在Apex中编写一个控制器，用于处理SOSL搜索的逻辑。这个控制器会接收用户输入的搜索词，并执行SOSL查询。 2. ，编写Visualforce页面，：在Visualforce页面中，你可以添加一个输入框和一个按钮，让用户输入搜索词并触发搜索。当用户点击搜索按钮时，页面会调用Apex控制器中的方法，执行SOSL搜索。 3. ，显示搜索结果，：搜索完成后，你可以将结果显示在Visualforce页面上。你可以使用``或``等标签来展示搜索结果。 ### 示例代码 以下是一个简单的示例，展示了如何在Visualforce页面中集成SOSL搜索： ```apex // Apex控制器 public class SearchController { public String searchTerm { get; set; } public List&gt; searchResults { get; set; } public void performSearch() { searchResults = [FIND :searchTerm IN ALL FIELDS RETURNING Account(Name), Contact(FirstName, LastName)]; } } ``` ```html ``` 在这个示例中，用户可以在输入框中输入搜索词，点击“Search”按钮后，页面会调用Apex控制器中的`performSearch`方法，执行SOSL搜索，并将结果显示在页面上。 ### 总结 通过将SOSL搜索集成到Visualforce页面中，你可以为用户提供一个强大的搜索功能，帮助他们快速找到所需的信息。记住，SOSL非常适合跨对象搜索，而通配符则可以让搜索更加灵活。希望这些内容对你有所帮助！

  ▶ 播放视频 查看详情
• 407

  Module Agenda - 490

  第 490 页

  今天我们来聊聊Salesforce中的列表控制器和SOSL查询。这个模块的内容非常实用，能帮助你在Salesforce中更高效地处理数据。 首先，我们会学习如何使用标准列表控制器。这个控制器是Salesforce提供的一个内置工具，它可以帮助你轻松地展示和管理数据列表。比如，你可以用它来显示一组客户记录，或者展示某个特定项目的任务列表。标准列表控制器非常强大，而且使用起来也很简单，你只需要在Visualforce页面中引用它，就可以自动获取和处理数据了。 接下来，我们会学习如何编写简单的SOSL查询。SOSL是Salesforce Object Search Language的缩写，它是一种用于在多个对象中搜索数据的查询语言。与SOQL（Salesforce Object Query Language）不同，SOSL可以在多个对象中同时搜索数据，非常适合用于全局搜索的场景。我们会通过一些简单的例子，来帮助你理解如何编写SOSL查询，并且如何在你的应用中使用它。 然后，我们会进入创建自定义列表控制器的部分。虽然标准列表控制器已经非常强大，但有时候你可能需要更灵活的控制方式。这时候，自定义列表控制器就派上用场了。我们会教你如何从头开始创建一个自定义列表控制器，并且如何根据你的需求来定制它的行为。通过自定义列表控制器，你可以实现更复杂的数据处理逻辑，比如过滤、排序、分页等等。 最后，我们会把这些知识综合起来，应用到实际的场景中。我们会创建一个“收件箱”应用，这个应用会使用列表控制器和SOSL查询来展示和管理用户的邮件或任务。通过这个项目，你可以把前面学到的知识融会贯通，并且在实际开发中应用它们。 好了，这就是我们今天要学习的内容。希望你能通过这些课程，掌握Salesforce中列表控制器和SOSL查询的使用技巧，并且能够在实际项目中灵活运用它们。如果你有任何问题，随时可以问我，我们一起来解决。

  ▶ 播放视频 查看详情
• 408

  Creating a Simple Search Page

  第 491 页

  同学们，今天我们来学习如何在Salesforce中创建一个简单的搜索页面。这个页面的功能是让用户能够在联系人对象的所有文本字段中进行搜索，并将搜索结果以表格的形式展示出来。 首先，我们需要明确几个关键点： 1. ，对象选择，：我们选择的是“联系人”对象，这是Salesforce中常用的标准对象之一。 2. ，搜索字段，：我们需要搜索联系人对象上的所有文本字段。这意味着我们需要动态地获取这些字段，而不是硬编码。 3. ，结果显示，：搜索结果需要以表格的形式展示，这样用户可以一目了然地看到相关信息。 接下来，我们一步步来实现这个功能。 ### 第一步：创建Visualforce页面 我们首先需要创建一个Visualforce页面。Visualforce是Salesforce提供的一种用于构建用户界面的框架。 ```apex ``` 在这个页面中，我们有一个输入框用于输入搜索关键词，一个按钮用于触发搜索操作，以及一个表格用于展示搜索结果。 ### 第二步：创建Apex控制器 接下来，我们需要创建一个Apex控制器来处理搜索逻辑。 ```apex public class ContactSearchController { public String searchKeyword { get; set; } public List searchResults { get; set; } public ContactSearchController() { searchResults = new List(); } public void search() { if (String.isNotBlank(searchKeyword)) { String searchQuery = &#39;FIND :searchKeyword IN ALL FIELDS RETURNING Contact(Id, Name, Email, Phone)&#39;; List&gt; searchList = search.query(searchQuery); searchResults = (List) searchList[0]; } else { searchResults.clear(); } } } ``` 在这个控制器中，我们定义了一个`searchKeyword`属性来存储用户输入的关键词，以及一个`searchResults`列表来存储搜索结果。`search`方法使用Salesforce的SOSL（Salesforce Object Search Language）来在所有文本字段中搜索联系人，并将结果存储在`searchResults`中。 ### 第三步：测试和部署 最后，我们需要测试这个页面，确保它能够正常工作。你可以在Salesforce的开发者控制台中预览这个页面，输入关键词并点击搜索按钮，看看是否能正确返回结果。 如果一切正常，你就可以将这个页面部署到生产环境中，供用户使用了。 ### 总结 通过以上步骤，我们成功创建了一个简单的搜索页面，用户可以在联系人对象的所有文本字段中进行搜索，并以表格的形式查看结果。这个页面虽然简单，但涵盖了Visualforce页面的创建、Apex控制器的编写以及SOSL的使用，是学习Salesforce开发的一个很好的起点。 希望这个讲解对你们有所帮助，如果有任何问题，欢迎随时提问！

  ▶ 播放视频 查看详情
• 409

  Creating a Custom List Controller

  第 492 页

  让我们来聊聊自定义列表控制器。想象一下，你有一个魔法盒子，这个盒子可以帮助你管理和展示一系列的数据记录。在Salesforce中，这个魔法盒子就是我们的列表控制器。 通常，我们会使用标准的列表控制器来管理数据，但有时候，我们需要更多的灵活性。这时候，自定义列表控制器就派上用场了。它继承了标准SetController类的所有功能，这意味着你可以使用所有标准的方法，比如翻页、选择记录等。 但自定义列表控制器的特别之处在于，你可以使用自定义的记录列表，或者通过SOSL、SOQL查询来获取记录集。这就像是你不仅可以打开魔法盒子，还可以决定盒子里装什么。 而且，你还可以在自定义列表控制器中添加你自己的方法。这就像是在魔法盒子上加装了一些特别的按钮，按下去就能执行你想要的特定操作。 所以，自定义列表控制器不仅继承了标准的功能，还给了你更多的自由和力量，让你能够更灵活地管理和展示你的数据。在下一张幻灯片上，我们会具体展示如何做到这一点。

  ▶ 播放视频 查看详情
• 410

  Instantiating the StandardSetController Class

  第 493 页

  今天我们来聊聊Salesforce中的StandardSetController类。这个类在开发中非常有用，特别是当你需要处理一组记录时，比如在列表视图或批量操作中。 首先，StandardSetController有一个重要的限制：它最多只能处理10,000条记录。如果你尝试用返回超过10,000条记录的查询定位器来实例化StandardSetController，系统会抛出一个叫做LimitResponse的异常。这意味着你不能直接处理超过10,000条记录的结果集。 但是，这里有一个小技巧。如果你用一个包含超过10,000条记录的列表来实例化StandardSetController，系统不会抛出异常。相反，它会自动把记录截断到10,000条。也就是说，只有前10,000条记录会被包含在StandardSetController中，剩下的记录会被忽略。 所以，当你使用StandardSetController时，一定要记住这个限制。如果你需要处理大量记录，可能需要考虑其他方法，比如分批处理或者使用更高效的查询策略。 希望这个解释对你有帮助！如果你有任何问题，随时问我。

  ▶ 播放视频 查看详情
• 411

  Passing in User Input

  第 494 页

  让我们来聊聊这个控制器的摘录。在这个例子中，学生们正在学习如何使用用户输入的字符串来构建一个SOSL查询，从而获取联系人列表。 首先，SOSL是Salesforce Object Search Language的缩写，它是一种在Salesforce中搜索多个对象的强大工具。与SOQL（Salesforce Object Query Language）不同，SOSL可以同时搜索多个对象，并且它更适合处理全文搜索。 在这个控制器中，学生们会获取用户输入的字符串，比如一个名字或者一个关键词。然后，他们会使用这个字符串来构建一个SOSL查询。这个查询会在Salesforce中搜索联系人对象，找到与用户输入相匹配的记录。 举个例子，如果用户输入了“John”，那么SOSL查询可能会是这样的： ```apex List&gt; searchList = [FIND &#39;John&#39; IN ALL FIELDS RETURNING Contact(Name, Email)]; ``` 这个查询会在所有字段中搜索“John”，并返回匹配的联系人记录，包括他们的名字和电子邮件。 通过这种方式，学生们可以学习如何动态地根据用户输入来构建查询，并且理解SOSL在Salesforce中的应用场景。这不仅帮助他们掌握技术细节，还能让他们更好地理解如何在实际项目中应用这些知识。 希望这个解释对你有帮助！如果有更多问题，随时问我哦。

  ▶ 播放视频 查看详情
• 412

  18-3: Create a Simple Search Page

  第 495 页

  我们来一步步完成这个任务。首先，我们需要创建一个简单的搜索页面，这个页面将允许用户输入搜索词，然后显示匹配的联系人列表。我们将使用Visualforce页面和自定义控制器来实现这个功能。 ### 第一步：编写自定义控制器 首先，我们需要编写一个Apex类作为自定义控制器。这个控制器将处理用户的搜索请求，并返回匹配的联系人列表。 ```apex public class ContactSearchController { // 定义一个公共变量来存储用户输入的搜索词 public String searchTerm { get; set; } // 定义一个公共变量来存储搜索结果 public List searchResults { get; set; } // 构造函数 public ContactSearchController() { searchResults = new List(); } // 搜索方法 public void search() { if (String.isNotBlank(searchTerm)) { // 使用SOSL进行搜索 List&gt; searchResultsList = [FIND :searchTerm IN ALL FIELDS RETURNING Contact(Id, Name, Email)]; searchResults = (List) searchResultsList[0]; } else { searchResults.clear(); } } } ``` ### 第二步：创建Visualforce页面 接下来，我们需要创建一个Visualforce页面来显示搜索框和搜索结果。 ```html ``` ### 第三步：测试新页面 1. 保存并部署你的Apex类和Visualforce页面。 2. 在Salesforce中，导航到“设置” -&gt; “开发” -&gt; “Visualforce页面”。 3. 找到你刚刚创建的页面，点击“预览”按钮。 4. 在搜索框中输入一个搜索词，比如“John”，然后点击“搜索”按钮。 5. 你应该会看到一个包含匹配联系人的列表。 ### 总结 通过这个简单的任务，我们创建了一个可以搜索联系人的Visualforce页面，并使用自定义控制器来处理搜索逻辑。这个页面可以很容易地扩展和定制，以满足更多的业务需求。 希望这个讲解对你有帮助！如果有任何问题，随时问我。

  ▶ 播放视频 查看详情
• 413

  Key Takeaways - 496

  第 496 页

  让我们来聊聊Salesforce中的几个关键概念，我会尽量用简单的方式来解释。 首先，，标准列表控制器，。这个工具非常有用，特别是当你需要创建一个Visualforce页面来显示和操作一组记录时。它比普通的控制器更强大，因为它提供了额外的翻页功能，这意味着你可以轻松地在记录之间前后翻页。 接下来是，filterId，。这是一个设置，允许你过滤列表控制器中显示的记录。想象一下，你有一大堆记录，但你只想看到符合特定条件的那些，filterId就能帮你做到这一点。 然后是，SOSL，，全称是Salesforce Object Search Language。这个工具非常酷，因为它允许开发人员同时搜索多个对象中的文本、电子邮件、URL和电话字段。SOSL查询的结果是一个sObjects列表的列表，这意味着你可以使用多个for循环来处理这些数据。 最后，，自定义列表控制器，。这是基于SOQL查询或自定义记录列表创建的。SOQL是Salesforce Object Query Language的缩写，它允许你从Salesforce数据库中检索数据。通过自定义列表控制器，你可以更灵活地控制哪些记录显示在你的Visualforce页面上。 总结一下，标准列表控制器、filterId、SOSL和自定义列表控制器都是Salesforce开发中非常有用的工具，它们帮助你更有效地管理和展示数据。希望这些解释对你有帮助！

  ▶ 播放视频 查看详情
• 414

  Knowledge Check - 497

  第 497 页

  让我们来聊聊Salesforce中的SOSL搜索和一些相关的知识点。首先，SOSL是一种非常强大的搜索工具，它可以帮助我们在Salesforce中查找信息。SOSL可以搜索任何被标记为可搜索的文本字段，这包括电子邮件和电话字段。但是，它不能搜索关系字段、数字字段、日期字段或复选框字段。 接下来，我们来看看自定义列表控制器。这个控制器可以基于SOSL搜索、SOQL查询或s对象列表来工作。这意味着你可以根据不同的需求来定制你的搜索和查询方式。 关于SOSL搜索的返回类型，它只有一种可能的返回类型，那就是s对象列表列表。这个列表包含了搜索返回的每个对象的一个sBody列表。你可以使用多个for循环来处理这些列表，这样就可以迭代每个sBody列表，获取你需要的信息。 最后，我们来看看在标记中如何使用recordSetVar属性。当你在标签中包括recordSetVar属性时，这告诉页面使用标准列表控制器，而不是对象的常规控制器。recordSetVar属性的值会成为你在页面中引用显示的记录列表的属性的名称。这样，你就可以更方便地管理和显示你的数据了。 希望这些信息能帮助你更好地理解Salesforce中的SOSL搜索和相关功能。如果你有任何问题，随时问我哦！

  ▶ 播放视频 查看详情
• 415

  Module 19: Visualforce Development Considerations

  第 498 页

  今天我们来聊聊Salesforce中的视觉力量开发，也就是Visualforce。Visualforce是Salesforce提供的一种强大的工具，允许你创建自定义的用户界面。想象一下，你可以用Visualforce来设计一个完全符合你业务需求的页面，就像你定制一件衣服一样，完全按照你的尺寸和风格来。 首先，我们得考虑几个关键因素。首先是性能。Visualforce页面加载速度要快，用户才不会等得不耐烦。你可以通过优化控制器逻辑和减少页面上的组件数量来提升性能。 其次是安全性。确保你的Visualforce页面安全，防止数据泄露。Salesforce提供了很多安全特性，比如字段级别的安全设置和页面访问控制，你要充分利用这些特性。 再来是用户体验。一个好的Visualforce页面不仅要功能强大，还要易于使用。这意味着你要考虑页面的布局、导航和交互设计，确保用户能够轻松地找到他们需要的信息。 最后，别忘了测试。在发布之前，彻底测试你的Visualforce页面，确保它在不同的设备和浏览器上都能正常工作。 总之，开发Visualforce页面时，要综合考虑性能、安全性、用户体验和测试，这样才能创建出既美观又实用的页面。希望这些建议能帮助你在Salesforce的世界里大展拳脚！

  ▶ 播放视频 查看详情
• 416

  Visualforce Development Considerations

  第 499 页

  同学们，今天我们来聊聊Visualforce开发时需要考虑的一些重要因素。Visualforce是Salesforce提供的一个强大的工具，允许我们创建自定义的用户界面。但在我们开始编写代码之前，有几个关键点需要先考虑清楚。 首先，，确定是否存在声明性解决方案，。Salesforce提供了很多即开即用的工具，比如标准对象、页面布局、流程构建器等。在决定使用Visualforce之前，先看看这些工具是否能满足你的需求。如果它们可以解决问题，那就没必要写代码了，这样可以节省时间和资源。 接下来，，描述常见的州长限制问题和安全问题，。Salesforce有一个叫做“州长限制”的机制，这是为了防止资源被过度使用。比如，一个页面加载时执行的代码不能超过一定的时间限制，或者不能查询过多的数据。我们需要在设计Visualforce页面时考虑到这些限制，确保页面运行高效且不会触发这些限制。 此外，，安全问题，也非常重要。Visualforce页面可以访问敏感数据，所以我们必须确保页面是安全的，防止未经授权的访问。比如，使用适当的权限设置，确保只有有权限的用户才能访问特定的数据。 最后，，描述Visualforce最佳实践，。这包括使用标准控制器和扩展控制器来简化代码，避免在页面中直接嵌入复杂的逻辑。同时，确保页面加载速度快，用户体验良好。还有，尽量重用代码，减少重复，这样不仅代码更简洁，也更容易维护。 总结一下，开发Visualforce页面时，我们需要先看看是否有现成的工具可以使用，然后注意州长限制和安全问题，最后遵循最佳实践来编写代码。这样，我们才能创建出既高效又安全的Visualforce页面。希望这些内容对你们有所帮助！

  ▶ 播放视频 查看详情
• 417

  Module Agenda - 500

  第 500 页

  同学们，今天我们来聊聊Salesforce中的Visualforce开发。Visualforce是Salesforce提供的一种强大的页面开发工具，它允许我们创建自定义的用户界面，这些界面可以完全集成到Salesforce的标准功能中。 首先，我们来看看何时使用Visualforce。当你需要创建一些标准Salesforce页面无法提供的复杂用户界面时，Visualforce就派上用场了。比如，你可能需要一个特定的数据输入表单，或者一个复杂的报表展示页面。 接下来，我们要讨论的是Visualforce和州长限制。Salesforce平台对资源的使用有一些限制，这些限制被称为州长限制。在使用Visualforce时，我们需要特别注意这些限制，比如视图状态的大小、控制器方法的执行时间等，以确保我们的页面既高效又符合平台的最佳实践。 安全是开发中不可忽视的一部分。在使用Visualforce时，我们需要确保我们的页面是安全的，防止常见的安全漏洞，比如跨站脚本攻击（XSS）。Salesforce提供了一些内置的安全特性，比如自动的HTML编码，但我们还是需要自己进行一些额外的安全检查。 随着移动设备的普及，开发移动设备友好的页面变得越来越重要。Visualforce允许我们创建响应式的页面，这些页面可以在不同的设备上良好地显示。我们可以使用Salesforce提供的移动设计模板，或者使用自定义的CSS和JavaScript来优化移动体验。 说到JavaScript，它在Visualforce页面中扮演着重要的角色。我们可以使用JavaScript来增强页面的交互性，比如动态显示或隐藏页面元素，或者在不刷新页面的情况下与服务器进行通信。但是，使用JavaScript时也要注意不要违反Salesforce的安全和性能最佳实践。 最后，我们会在模块19中深入探讨Visualforce开发的考虑因素。这包括如何设计高效的页面，如何优化性能，以及如何确保我们的Visualforce页面能够随着业务需求的变化而灵活调整。 好了，这就是我们今天的内容。希望这些信息能帮助你们更好地理解和使用Visualforce。如果有任何问题，随时提问哦！

  ▶ 播放视频 查看详情
• 418

  A Page Layout vs. A Visualforce Page

  第 501 页

  今天我们来聊聊Salesforce中的页面布局和它的视觉力量。页面布局，简单来说，就是一个工具，它帮助开发者在记录的详细信息页面上安排各种元素，比如字段、按钮和相关列表。你可以把它想象成一个画布，你可以在上面摆放不同的组件，但要注意的是，这个画布有一些固定的规则。 首先，字段总是出现在相关列表的上方。这意味着，当你查看一个记录的详细信息时，你会先看到字段，然后才是相关列表。其次，按钮总是出现在字段的上方。所以，如果你在页面上添加了一个按钮，它会自动跳到字段的上面去。 另外，s控件和自定义链接也有它们自己的位置。它们只能放在特定的区域，不能随意摆放。这些规则确保了页面的整洁和一致性，使得用户在使用时能够快速找到他们需要的信息。 虽然页面布局在显示信息方面没有提供太大的灵活性，但它确保了信息的组织是有序的，这对于用户体验来说是非常重要的。通过合理利用页面布局，你可以创建一个既美观又实用的用户界面，让用户在使用你的应用时感到舒适和高效。

  ▶ 播放视频 查看详情
• 419

  19-1: Determine Whether a Declarative Solution Exists

  第 502 页

  让我们一起来看一下这些练习问题的答案，确保我们理解了每个场景下Visualforce是否是最佳解决方案。 1. ，认证小组希望在每个认证记录上添加聊天提要。， - 虽然Visualforce确实支持Chatter提要，但这里的最佳做法是使用标准页面布局。你可以在设置中找到“自定义”选项，然后进入“Chatter”设置，打开“提要跟踪”功能。这样，你就可以在认证记录上添加Chatter提要，而不需要编写任何代码。 2. ，认证团队希望仅当课程交付的状态设置为计划时才显示开始日期字段。， - 虽然Visualforce可以实现部分页面刷新，但这里更简单的方法是使用页面布局、记录类型和工作流规则的组合。你可以设置一个工作流规则，当课程交付的状态更新为“计划”时，自动更新记录类型，从而改变页面布局，只显示开始日期字段。 3. ，认证团队希望课程交付相关列表是课程记录上显示的唯一相关列表。， - 这个需求可以通过简单地调整页面布局来实现。你只需要在页面布局中删除其他相关列表，只保留课程交付相关列表即可。这样，课程记录上就只会显示你希望看到的相关列表。 4. ，联系人对象有很多字段，需要滚动才能看到所有信息。认证团队希望每个部分和相关列表都显示为单独的选项卡，点击后即可查看。， - 在这种情况下，Visualforce是唯一的解决方案。因为标准的页面布局不支持将字段和相关列表分成多个选项卡。使用Visualforce，你可以创建一个自定义页面，将不同的字段和相关列表组织在不同的选项卡中，用户点击选项卡即可查看相应的内容。 5. ，认证团队希望课程列表视图与其公司网站的外观相匹配。， - 只有Visualforce能够支持这种高度的自定义需求。通过Visualforce，你可以完全控制列表视图的样式和布局，使用自定义的样式表来确保列表视图与公司网站的外观一致。标准的列表视图无法提供这种级别的自定义。 总结一下，虽然Visualforce非常强大，但在很多情况下，使用Salesforce的标准功能（如页面布局、记录类型和工作流规则）可以更简单地实现需求。只有在标准功能无法满足需求时，才需要考虑使用Visualforce。希望这些解释对你有帮助！

  ▶ 播放视频 查看详情
• 420

  Module Agenda - 503

  第 503 页

  同学们，今天我们来聊聊Salesforce中的Visualforce开发。Visualforce是Salesforce提供的一种强大的工具，它允许我们创建自定义的用户界面，这些界面可以直接集成到Salesforce环境中。 首先，我们来看看何时使用Visualforce。当你需要创建一个标准Salesforce界面无法提供的特定功能或布局时，Visualforce就派上用场了。比如，你可能需要一个复杂的表单，或者一个包含特定业务逻辑的页面。 接下来是Visualforce和州长限制。Salesforce对资源的使用有一些限制，这些限制被称为州长限制。在使用Visualforce时，我们需要确保我们的代码不会超出这些限制，比如对数据库的查询次数或者执行时间。 安全考虑因素也非常重要。在开发Visualforce页面时，我们必须确保数据的安全性，防止SQL注入等安全威胁。这意味着我们需要对用户输入进行验证，并使用Salesforce提供的安全功能。 开发移动设备页面也是一个关键点。随着移动设备的普及，我们需要确保我们的Visualforce页面在手机和平板电脑上也能良好地显示和工作。这通常涉及到响应式设计和对不同屏幕尺寸的适配。 最后，我们来看看Visualforce中的JavaScript。JavaScript可以增强Visualforce页面的交互性，但我们也需要注意不要过度使用，以免影响页面的性能。 这就是我们今天要讨论的Visualforce开发考虑因素。记住，好的开发不仅仅是让页面看起来漂亮，更重要的是确保它的功能性、安全性和性能。希望这些信息对你们有所帮助！

  ▶ 播放视频 查看详情
• 421

  What Governor Limits Should be Considered?

  第 504 页

  今天我们来聊聊在使用Salesforce时，特别是涉及到Visualforce页面时，你需要考虑的一些州长限制（Governor Limits）。这些限制是为了确保系统的稳定性和性能，所以理解它们非常重要。 首先，Visualforce的自定义控制器和控制器扩展是受到Apex调节器限制的。这意味着它们和你在匿名块或SDF方法中使用的Apex代码一样，受到相同的限制。比如，你可能会遇到执行时间限制、查询行数限制等。 接下来，Visualforce中的迭代组件，比如``和``，它们在迭代集合时，最多只能处理1,000个项目。如果你尝试处理更多的项目，系统会抛出错误。 还有一个重要的限制是Visualforce页面的最大视图状态大小，这个大小被限制在135 KB。视图状态是页面在服务器和客户端之间传递的数据，如果超过了这个大小，页面可能无法正常工作。 此外，单个Visualforce页面请求中，查询检索到的最大行数是50,000行。这意味着如果你在一个请求中尝试获取超过50,000行的数据，系统会阻止这个操作。 最后，StandardSetController的最大记录限制是10,000。StandardSetController通常用于处理列表视图中的数据，所以如果你在处理大量数据时，这个限制也需要特别注意。 总结一下，使用Visualforce时，你需要关注以下几个主要的州长限制： 1. 自定义控制器和控制器扩展的Apex调节器限制。 2. 迭代组件的1,000个项目限制。 3. 视图状态大小的135 KB限制。 4. 单个请求中查询的最大行数50,000限制。 5. StandardSetController的10,000记录限制。 理解这些限制，可以帮助你更好地设计和优化你的Visualforce页面，避免在运行时遇到意外的错误。希望这些信息对你有帮助！

  ▶ 播放视频 查看详情
• 422

  What is View State?

  第 505 页

  让我们来聊聊Salesforce中的视图状态（View State）。想象一下，你在使用一个网页，填写了一些信息，然后点击了一个按钮。这时候，页面需要把这些信息发送到服务器去处理。但是，服务器处理完之后，页面需要重新加载，那么你之前填写的信息怎么办呢？这就是视图状态的作用。 在Salesforce的Visualforce页面中，视图状态就像是一个小型的“记忆库”。它保存了页面上所有组件、字段和控制器（Controller）的值。这样，当页面需要重新加载时，这些信息不会丢失，而是可以重新显示出来。 具体来说，当你在Visualforce页面中使用标签时，Salesforce会自动生成一个加密的隐藏表单字段。这个字段里面就包含了视图状态。视图状态实际上是一个Base64编码的字符串，它保存了页面的当前状态和需要在回发（Postback）期间保留的值。 简单来说，视图状态就是帮助页面记住用户输入和页面状态的一种机制。它确保了在页面与服务器之间来回传递数据时，用户的数据不会丢失。 如果你想更深入地了解视图状态，可以参考Salesforce官方文档中的介绍，那里有更详细的解释和示例。希望这个解释能帮助你更好地理解视图状态的概念！

  ▶ 播放视频 查看详情
• 423

  Transient Variables Example

  第 506 页

  同学们，今天我们来聊聊Salesforce中的，暂时变量，，也就是用`transient`关键字声明的变量。这个知识点特别重要，尤其是当你开发Visualforce页面时，想要优化性能、减少页面加载时间的时候。 ### 什么是暂时变量？ 暂时变量就是用`transient`关键字标记的变量。它的特点是：，不会被保存在页面的视图状态中，。视图状态是Salesforce用来保存页面数据的一种机制，但如果数据量太大，可能会影响页面性能。所以，如果你有一些数据不需要在页面回发（比如刷新或提交）时保留，就可以用`transient`来声明它。 ### 为什么要用暂时变量？ 举个例子，假设你在页面上显示一些临时数据，比如当前时间或者一些计算出来的值。这些数据不需要在用户操作后保留，那么用`transient`声明它们，可以减少视图状态的大小，从而让页面加载更快。 ### 示例代码 下面是一个完整的例子，我们来看一下： ```apex public class MyController { // 这是一个普通的变量，会被保存在视图状态中 public String normalVariable { get; set; } // 这是一个暂时变量，不会被保存在视图状态中 public transient String transientVariable { get; set; } public MyController() { normalVariable = &#39;这是普通变量，会被保存&#39;; transientVariable = &#39;这是暂时变量，不会被保存&#39;; } } ``` 在这个例子中： - `normalVariable`是一个普通的变量，它的值会被保存在视图状态中。 - `transientVariable`是一个暂时变量，它的值不会被保存。 ### 在Visualforce页面中使用 接下来，我们在Visualforce页面中使用这个控制器： ```html <p>普通变量: {!normalVariable}</p> <p>暂时变量: {!transientVariable}</p> ``` 当你运行这个页面时，两个变量都会正常显示。但是，如果你刷新页面或者提交表单，`transientVariable`的值会丢失，因为它没有被保存在视图状态中，而`normalVariable`的值会保留。 ### 总结 - ，暂时变量，用`transient`关键字声明，不会被保存在视图状态中。 - 适合用于临时数据，比如计算值、当前时间等。 - 使用暂时变量可以减少视图状态大小，提升页面性能。 希望这个例子能帮助大家理解暂时变量的用法。如果有任何问题，欢迎随时提问！

  ▶ 播放视频 查看详情
• 424

  Minimizing the Risk of Hitting Governor Limits

  第 507 页

  今天我们来聊聊如何在Salesforce开发中避免触及调速器限制，以及如何优化页面和代码的性能。 首先，我们要明白，调速器限制是Salesforce为了防止资源过度使用而设置的一种机制。如果你的代码或页面加载了太多数据，就可能会触及这个限制，导致性能下降甚至功能失效。 ，1. 避免无边界页面， 在显示记录列表时，永远不要让页面“无边界”。也就是说，不要一次性加载所有记录。为什么呢？因为随着数据量的增加，页面加载时间会变长，甚至可能直接超时。所以，一定要限制显示的最大记录数。比如，你可以设置每次只加载20条记录，用户需要更多时再加载下一页。这样既能提升性能，又能避免触及调速器限制。 ，2. 延迟加载， 延迟加载是一种很好的优化方式。它的核心思想是：不要一次性加载所有数据，而是按需加载。比如，当用户滚动到页面底部时，再加载更多记录。这样可以减少初始加载时间，提升用户体验。你可以参考Salesforce官方文档中关于延迟加载的详细说明，链接我已经放在这里了。 ，3. 减少组件嵌套， 在开发页面时，尽量避免过多的组件嵌套。嵌套太深会导致页面加载变慢，甚至增加视图状态的大小，从而影响性能。你可以通过简化页面结构、减少不必要的组件来优化性能。关于这一点，Salesforce官方文档和社区论坛都有详细的讨论，链接我也提供了。 ，4. 缓存属性值， 在Apex类中，如果你有一些属性是通过复杂计算得到的，可以考虑缓存这些值。也就是说，第一次计算后把结果存起来，下次再访问时直接使用缓存的值，而不是重新计算。这样可以减少不必要的计算和数据库查询，提升性能。同时，你可以将getter方法配置为只在对象为空时才去查询数据，避免重复查询。 总结一下，优化Salesforce性能的关键在于：限制数据加载、延迟加载、减少组件嵌套和缓存属性值。通过这些方法，你可以有效避免触及调速器限制，同时提升用户体验。希望这些技巧对你有帮助！如果有任何问题，随时问我哦！

  ▶ 播放视频 查看详情
• 425

  Module Agenda - 508

  第 508 页

  同学们，今天我们来聊聊Salesforce中的Visualforce开发。Visualforce是Salesforce提供的一种强大的工具，它允许我们创建自定义的用户界面，这些界面可以直接集成到Salesforce应用中。 首先，我们来看看何时使用Visualforce。当你需要创建一些标准Salesforce界面无法提供的功能时，比如复杂的表单、自定义的报表或者独特的用户交互体验，这时候Visualforce就派上用场了。 接下来是Visualforce和州长限制。州长限制是Salesforce为了确保系统的稳定性和性能而设置的一些限制。在使用Visualforce时，我们需要特别注意这些限制，比如视图状态的大小、Apex调用的次数等，以确保我们的页面既功能强大又不会超出系统的限制。 然后是Visualforce的安全考虑因素。安全性是开发中非常重要的一部分。我们需要确保我们的Visualforce页面能够防止常见的安全威胁，比如跨站脚本攻击（XSS）和SQL注入。Salesforce提供了一些内置的安全功能，但我们作为开发者也需要采取额外的措施来保护我们的应用。 开发移动设备页面也是一个重要的议题。随着移动设备的普及，我们需要确保我们的Visualforce页面在移动设备上也能良好地显示和工作。这通常涉及到响应式设计和移动优化的布局。 最后，我们来谈谈Visualforce中的JavaScript。JavaScript可以增强Visualforce页面的交互性和动态功能。但是，使用JavaScript时也需要注意不要违反Salesforce的安全模型和州长限制。 这就是我们今天要讨论的主要内容。希望大家能够理解Visualforce开发中的这些关键考虑因素，并在实际开发中加以应用。如果有任何问题，欢迎随时提问。

  ▶ 播放视频 查看详情
• 426

  Security for Apex Classes and Controllers

  第 509 页

  今天我们来聊聊Apex类和控制器的安全性。这个话题听起来可能有点技术性，但其实理解起来并不复杂。 首先，Apex类默认情况下是能够读取和更新组织内的所有数据的。这意味着，如果你不特别设置一些限制，Apex类可以访问和修改你Salesforce组织中的任何数据。 但是，当我们使用标准控制器时，情况就有所不同了。标准控制器在用户模式下执行，这意味着它会尊重当前用户的权限、字段级安全性和共享规则。所以，如果你扩展了标准控制器来构建Visualforce页面，那么这些页面会自动尊重用户的权限设置。 这里有个小细节需要注意：Apex类的权限检查只在顶层进行。举个例子，如果类A调用了类B，而用户的配置文件只能访问类A，不能直接访问类B，用户仍然可以执行类B中的代码。同样，如果Visualforce页面使用了带有控制器的自定义组件，那么只会检查与页面关联的控制器的安全性。 最后，如果用户拥有“Author Apex”权限，他们就可以访问组织中所有的Apex类，不管这些类的安全设置如何。这是一个比较高级的权限，通常只有管理员或者开发人员才会有。 希望这些信息能帮助你更好地理解Apex类和控制器的安全性。如果你有更多问题，随时欢迎提问！

  ▶ 播放视频 查看详情
• 427

  SOQL Injection

  第 510 页

  今天我们来聊聊SOQL注入这个话题。首先，SOQL是Salesforce自己的一种数据库查询语言，它比我们常见的SQL要简单一些，功能也相对有限。但是，就像SQL注入一样，SOQL注入也是一个安全问题，我们需要特别注意。 SOQL注入的原理其实很简单。想象一下，如果我们的应用程序允许用户输入一些信息，然后我们直接用这些信息去构建一个SOQL查询语句。如果这些输入没有经过严格的检查，那么黑客就可以通过输入一些特殊的SOQL命令，来改变我们原本的查询逻辑，甚至可能获取到他们不应该看到的数据。 举个例子，假设我们有一个搜索功能，用户可以输入一个名字来查找相关的记录。如果我们直接把用户输入的名字拼接到SOQL查询语句中，而没有做任何处理，那么黑客就可以输入一些特殊的字符，比如单引号或者分号，来改变查询的逻辑，这就会导致SOQL注入。 那么，我们怎么防止SOQL注入呢？其实方法也很简单。首先，我们应该尽量避免直接拼接用户输入到SOQL语句中。其次，我们可以使用绑定变量，这样Salesforce会自动帮我们处理这些输入，防止注入攻击。最后，我们还可以对用户输入进行严格的验证和清理，确保它们不包含任何可能引发注入的字符。 总之，虽然SOQL注入的风险比SQL注入低，但我们也不能掉以轻心。通过采取一些简单的预防措施，我们就可以有效地保护我们的应用程序免受SOQL注入的威胁。 如果你对SOQL注入还有更多的疑问，或者想深入了解如何防止这种攻击，可以参考我提供的两个资源链接。它们会给你更详细的指导和帮助。希望今天的讲解对你有帮助，我们下次再见！

  ▶ 播放视频 查看详情
• 428

  SOQL Injection Defenses

  第 511 页

  今天我们来聊聊SOQL注入防御的一些要点。首先，SOQL是Salesforce Object Query Language的缩写，它是用来查询Salesforce数据库中数据的语言。动态SOQL是一种在运行时构建查询的方式，它非常灵活，但同时也可能带来安全风险，比如SOQL注入。 SOQL注入是一种安全漏洞，攻击者可以通过构造恶意的输入来操纵SOQL查询，从而访问或修改他们本不应该访问的数据。为了防止这种情况发生，我们需要采取一些防御措施。 首先，当你在编写动态SOQL时，尽量避免直接将用户输入拼接到查询字符串中。这样做很容易被攻击者利用。相反，你应该使用绑定变量。绑定变量是Salesforce提供的一种安全机制，它可以将用户输入作为参数传递给SOQL查询，而不是直接拼接到查询字符串中。这样，Salesforce会自动处理这些输入，确保它们不会被误解为SOQL代码的一部分。 例如，如果你有一个查询需要根据用户输入的名字来过滤记录，你可以这样写： ```apex String name = &#39;John&#39;; String query = &#39;SELECT Id, Name FROM Account WHERE Name = :name&#39;; List accounts = Database.query(query); ``` 在这个例子中，`:name`就是一个绑定变量，它会安全地将用户输入的名字传递给查询。 但是，需要注意的是，绑定变量只能用在WHERE子句中，不能用在SELECT列表或FROM关键字后面。这是因为SELECT列表和FROM关键字需要的是具体的字段名和对象名，而不是变量值。 总之，使用动态SOQL时，一定要小心处理用户输入，尽量使用绑定变量来避免SOQL注入的风险。这样，你的Salesforce应用就会更加安全可靠。希望这些信息对你有帮助！

  ▶ 播放视频 查看详情
• 429

  19-2: Defend Against SOQL Injection

  第 512 页

  同学们，今天我们要学习如何防御SOQL注入攻击。SOQL注入是一种安全漏洞，攻击者可以通过输入恶意数据来操纵你的SOQL查询，从而访问或修改不应该被访问的数据。为了防止这种情况，我们需要对代码进行“消毒”，也就是确保用户输入的数据不会直接影响到我们的查询。 首先，我们需要创建一个自定义的Visualforce控制器。这个控制器将负责处理页面的逻辑和数据。然后，我们会创建一个Visualforce页面，这个页面将使用我们刚刚创建的控制器来显示数据。 接下来，我们要实现一个功能，让用户可以通过输入认证编号来搜索现有的认证记录。当用户输入一个认证编号并提交后，页面会显示该认证的详细信息，包括认证名称和相关的专业人员名称，同时还会显示拥有该认证的专业人员总数。 现在，关键的部分来了——防御SOQL注入。在原始的代码中，可能会使用动态SOQL查询，这意味着查询字符串是直接由用户输入的数据拼接而成的。这种做法非常危险，因为如果用户输入了恶意数据，就可能引发SOQL注入。 为了防御这种攻击，我们需要将动态查询替换为静态查询，并使用绑定变量。绑定变量是SOQL查询中的占位符，它们会在查询执行时被安全地替换为用户输入的数据。这样做的好处是，即使用户输入了恶意数据，这些数据也不会被解释为SOQL代码的一部分，从而防止了注入攻击。 具体来说，我们需要修改Visualforce页面的控制器代码。在控制器中，我们会定义一个静态的SOQL查询，并使用绑定变量来引用用户输入的认证编号。这样，无论用户输入什么，查询都会安全地执行，不会受到注入攻击的影响。 好了，这就是我们今天要学习的内容。记住，防御SOQL注入的关键是使用静态查询和绑定变量，确保用户输入的数据不会直接影响到我们的查询。现在，轮到你动手实践了，试着修改你的Visualforce页面控制器，确保它能够防御SOQL注入攻击。加油！

  ▶ 播放视频 查看详情
• 430

  Module Agenda - 513

  第 513 页

  今天我们来聊聊Salesforce中的Visualforce开发。Visualforce是Salesforce提供的一种强大的工具，它允许开发者创建自定义的用户界面，这些界面可以完全集成到Salesforce环境中。 首先，我们来看看何时使用Visualforce。当你需要创建标准Salesforce界面无法提供的特定功能或自定义视图时，Visualforce就派上用场了。比如，你可能需要一个独特的表单布局，或者一个复杂的报表展示方式。 接下来，我们要讨论Visualforce和州长限制。州长限制是Salesforce为了确保系统资源的公平使用而设置的一些限制。在使用Visualforce时，你需要了解这些限制，比如视图状态的大小限制、Apex调用的次数限制等，以确保你的页面既高效又符合Salesforce的最佳实践。 安全考虑因素也是开发Visualforce页面时不可忽视的一部分。你需要确保你的页面能够防止常见的安全威胁，比如跨站脚本攻击（XSS）和跨站请求伪造（CSRF）。Salesforce提供了一些内置的安全特性，比如自动转义和CSRF令牌，但作为开发者，你也需要采取额外的措施来保护你的应用。 开发移动设备页面时，Visualforce同样非常有用。你可以创建响应式设计的页面，确保它们在不同设备上都能良好显示。Salesforce Lightning Experience提供了更好的移动支持，但Visualforce仍然是一个强大的工具，特别是在你需要深度定制时。 最后，我们来谈谈Visualforce中的JavaScript。JavaScript可以增强Visualforce页面的交互性和动态性。你可以在Visualforce页面中直接嵌入JavaScript代码，或者通过使用JavaScript Remoting来调用Apex控制器的方法。这为创建动态和响应迅速的用户界面提供了极大的灵活性。 总结一下，Visualforce是一个功能强大的工具，可以帮助你创建高度定制化的Salesforce应用。通过理解何时使用Visualforce、遵守州长限制、考虑安全因素、开发移动友好的页面以及有效利用JavaScript，你可以构建出既安全又高效的应用。希望这些信息对你有所帮助，让我们在模块19中继续深入探讨Visualforce开发的更多细节。

  ▶ 播放视频 查看详情
• 431

  UI Considerations for Mobile

  第 514 页

  今天我们来聊聊在Salesforce中设计Mobile Visualforce页面时需要考虑的UI因素。首先，我们要明白，移动设备的屏幕空间是有限的，所以设计时要特别注意这一点。我们需要决定页面要支持哪些设备，比如是手机、平板，还是两者都要支持。 接下来，我们要针对移动环境来开发。这意味着我们可以利用移动设备的特有功能，比如地理定位和摄像头，来增强用户体验。但记住，移动版本不需要包含所有复杂的功能，简洁往往更有效。我们应该专注于优化最常见的移动用例，比如数据发现、数据输入和搜索等。 在技术实现上，我们可以使用``来避免使用标准的样式表，这样可以更好地控制页面的外观和感觉。此外，采用响应式设计原则是非常重要的，这可以确保页面在不同设备上都能良好地显示和操作，这与Salesforce 1应用程序的设计理念是一致的。 总之，设计移动Visualforce页面时，我们要考虑到设备的限制，利用设备特有的功能，保持设计的简洁性，并确保页面的响应式布局，以提供最佳的用户体验。

  ▶ 播放视频 查看详情
• 432

  What are Lightning Components?

  第 515 页

  让我们来聊聊什么是闪电组件（Lightning Components）。你可以把它想象成是Salesforce平台上的一个“积木工具箱”，专门用来搭建网页应用。无论是手机还是电脑，闪电组件都能帮你快速构建出既漂亮又实用的用户界面。 闪电组件框架是基于一个叫做Aura的开源技术，这个技术是Salesforce自己开发的，专门用来支持他们的平台。Aura就像是闪电组件的“地基”，让闪电组件能够稳定地运行，并且不断地进化。 现在，你可能会问，那Visualforce呢？Visualforce是Salesforce早期的一个开发工具，它并没有被淘汰，依然在很多地方使用。但是，如果你正在为Salesforce的新界面——Lightning Experience或者Salesforce的移动应用开发，或者你正在开始一个新项目，那么使用闪电组件会是一个更好的选择。闪电组件能提供更多的功能和更好的用户体验。 不过，如果你需要生成PDF文件，那么Visualforce还是你的好帮手，因为闪电组件目前还不支持这个功能。 总结一下，闪电组件是Salesforce平台上构建现代网页应用的一个强大工具，它让开发更加快速、模块化，并且能直接连接到Salesforce的数据和业务流程。如果你正在为Salesforce的新界面开发，或者开始一个新项目，那么闪电组件绝对值得一试。

  ▶ 播放视频 查看详情
• 433

  Module Agenda - 516

  第 516 页

  同学们，今天我们来聊聊Salesforce的Lightning Components。这是一个非常强大的工具，可以帮助你们创建更加动态和交互式的用户界面。 首先，如果你们对Lightning Components感兴趣，想要深入了解或者尝试自己创建一些组件，我推荐你们访问一个非常有用的网站：https://developer.salesforce.com/devcenter/lightning。这里有很多资源，可以指导你们如何使用Lightning Components来创建你们的第一个应用程序。 此外，如果你们想要系统地学习，可以参加我们的课程dev 601：Lightning Components编程。这个课程会从基础讲起，逐步深入到更高级的应用，非常适合想要提升自己技能的同学们。 还有，不要忘了Salesforce的Trailhead平台，那里有一个专门的模块叫做“Lightning Experience Development Overview”，你们可以通过这个模块来了解Lightning的未来发展方向和一些实用的开发技巧。链接在这里：https://trailhead.salesforce.com/en/modules/lex_dev_overview/units/lex_dev_overview_future。 总之，无论是通过官方文档、在线课程还是实践项目，都有很多途径可以帮助你们掌握Lightning Components。希望你们能够利用这些资源，不断提升自己的技能。加油！

  ▶ 播放视频 查看详情
• 434

  Creating Custom Buttons that Use JavaScript

  第 517 页

  让我们来聊聊如何在Salesforce的Visualforce页面中使用JavaScript来创建一个自定义的收件箱。这个过程其实很简单，只需要几个步骤就能完成。 首先，我们需要一个JavaScript文件，这个文件里包含了我们想要在页面上使用的所有逻辑。你可以自己写这个文件，或者使用现成的JavaScript库。 接下来，我们需要把这个JavaScript文件上传到Salesforce中，作为静态资源。你可以把它想象成把文件放进一个安全的盒子里，Salesforce会帮你保管好它。 上传完成后，我们就可以在Visualforce页面中引用这个JavaScript文件了。这里我们会用到两个标签：和$Resource。标签告诉Salesforce我们要包含一个JavaScript文件，而$Resource则是用来指定我们之前上传的那个文件。 最后，一旦文件被正确引用，你就可以在页面上调用JavaScript文件中的函数了。这些函数可以帮助你实现各种功能，比如创建一个自定义的收件箱。 总结一下，整个过程分为三步： 1. 上传JavaScript文件作为静态资源。 2. 在Visualforce页面中使用和$Resource引用这个文件。 3. 调用JavaScript文件中的函数来实现你的功能。 这样，你就可以在Salesforce中创建一个功能丰富的自定义收件箱了。希望这个解释对你有帮助！

  ▶ 播放视频 查看详情
• 435

  19-3: Create a Custom Button that Uses JavaScript (Optional)

  第 518 页

  同学们，今天我们来学习如何在Salesforce中创建一个使用JavaScript的自定义按钮。这个按钮将帮助我们返回到“联系人详细信息”页面，而不是仅仅依赖浏览器的返回按钮。 首先，我们需要将JavaScript代码作为静态资源上传到Salesforce。这个JavaScript代码将包含一个确认对话框，询问用户是否真的想要取消当前操作并返回。 接下来，我们打开“技术员状态可视化”页面，找到TODO部分，这里我们需要填写一些代码。我们将使用``标签来创建这个按钮。在这个标签中，我们设置`action`属性为`{!cancel}`，这样当按钮被点击时，Salesforce会执行取消操作。我们还设置`onclick`属性为`return confirmCancel()`，这样在按钮被点击时，会先执行我们的JavaScript函数`confirmCancel()`。 这个JavaScript函数会弹出一个确认对话框，询问用户是否确定要取消。如果用户点击“确定”，函数返回`true`，Salesforce会继续执行取消操作并返回到“联系人详细信息”页面。如果用户点击“取消”，函数返回`false`，操作将被中止，页面不会跳转。 最后，别忘了在`onclick`属性中使用`return`关键字，这是确保JavaScript函数返回值能够正确传递给Salesforce的关键。 完成这些步骤后，保存并测试你的按钮，确保它按预期工作。这样，我们就成功地在“技术员状态可视化”页面上添加了一个自定义按钮，提升了用户体验。希望这个讲解对你们有帮助，如果有任何疑问，随时提问！

  ▶ 播放视频 查看详情
• 436

  Key Takeaways - 519

  第 519 页

  今天我们来聊聊Salesforce中的一些关键要点，特别是关于Visualforce和Lightning Components的使用。我会尽量用简单易懂的语言来解释这些概念，让你能够轻松理解。 首先，，Visualforce，。Visualforce是Salesforce提供的一种强大的工具，可以用来创建自定义的用户界面。但是，记住一点：，只有在需要重写标准行为或者需要更改页面的外观时，才使用Visualforce，。为什么呢？因为Visualforce页面及其关联的自定义控制器和控制器扩展是受到限制的。这意味着它们可能会增加系统的复杂性，并且可能会影响性能。 接下来，我们来谈谈，视图状态，。视图状态是Salesforce用来保存页面状态的一种机制。但是，如果视图状态过大，可能会导致页面加载变慢。所以，，使用transient关键字来减少视图状态，，从而减少有效负载。transient关键字告诉Salesforce不要保存某些变量的状态，这样可以减少视图状态的大小，提高页面性能。 再来说说，查询，。在Salesforce中，查询是非常常见的操作。但是，，始终过滤您的查询，。这意味着你应该尽量缩小查询的范围，只获取你需要的数据。这样可以减少数据库的负载，提高查询的效率。 接下来是，数据安全性，。在编写Apex代码时，，始终尝试在类中使用“with sharing”，。这可以确保你的代码遵守用户的权限设置，防止用户访问他们不应该看到的数据。这是Salesforce中非常重要的一个安全措施。 最后，我们来聊聊，Lightning Components，。Lightning Components是Salesforce的新一代用户界面框架，特别适合用于开发，Lightning Experience，和，移动设备，的页面。与Visualforce相比，Lightning Components更加现代化，性能更好，用户体验也更佳。所以，如果你正在开发新的页面，特别是为Lightning Experience或移动设备开发，，优先考虑使用Lightning Components，。 总结一下，今天我们学习了几个关键要点： 1. 只在必要时使用Visualforce。 2. 使用transient关键字减少视图状态。 3. 始终过滤查询以提高效率。 4. 在Apex类中使用“with sharing”确保数据安全。 5. 优先使用Lightning Components开发新页面。 希望这些内容对你有所帮助！如果有任何问题，随时问我。

  ▶ 播放视频 查看详情
• 437

  Trailhead Homework - 520

  第 520 页

  今天我们来聊聊关于Salesforce Trailhead的家庭作业教学要点。Trailhead是一个非常棒的学习平台，特别是对于那些想要复习和提升PD1（Platform Developer 1）技能的同学来说。今天我要给大家介绍两个特别有用的Trailhead模块，它们能帮助你们更深入地理解我们课程中涉及的一些关键概念。 第一个模块是关于数据安全的，链接在这里：[数据安全模块](https://trailhead.salesforce.com/en/modules/data_security)。这个模块会教你如何在Salesforce中保护你的数据，确保只有合适的人才能访问敏感信息。这对于任何想要在Salesforce平台上开发安全应用的人来说都是非常重要的。 第二个模块是关于数据泄露防护的，链接在这里：[数据泄露防护模块](https://trailhead.salesforce.com/modules/data-leak-prevention)。这个模块会教你如何防止数据泄露，确保你的数据不会意外地落入不该拥有它的人手中。这对于维护客户信任和遵守数据保护法规至关重要。 这两个模块都是作为家庭作业来完成的，不需要在课堂上做。你们可以在自己的时间里，按照自己的节奏来学习。完成这些模块不仅能帮助你们巩固课堂上学到的知识，还能让你们在实际工作中更加自信地应用这些技能。 记得，学习是一个持续的过程，Trailhead提供了丰富的资源来支持你们的学习之旅。所以，不要犹豫，开始你们的Trailhead冒险吧！

  ▶ 播放视频 查看详情
• 438

  Module 20: Testing Visualforce Controllers

  第 521 页

  今天我们来聊聊Salesforce中的“测试视觉力量”和“控制器”。这两个概念听起来可能有点复杂，但其实它们都是为了帮助我们更好地管理和展示数据。 首先，我们来说说“测试视觉力量”。在Salesforce中，视觉力量（Visualforce）是一种用来创建自定义用户界面的技术。你可以把它想象成一个画布，你可以在上面画出你想要的任何界面元素，比如按钮、表格、图表等等。但是，画好了之后，我们怎么知道它能不能正常工作呢？这就需要“测试”了。测试视觉力量，就是通过编写一些代码来模拟用户的操作，看看这些界面元素是否能够按照我们的预期来工作。比如，点击一个按钮，看看它是否能正确地提交数据，或者显示我们想要的信息。 接下来，我们聊聊“控制器”。控制器是视觉力量页面的“大脑”。它负责处理用户的输入，比如点击按钮、填写表单等，然后根据这些输入来决定页面应该显示什么内容。你可以把控制器想象成一个指挥家，它指挥着页面上的各个元素，让它们按照一定的规则来工作。控制器通常是用Apex语言编写的，Apex是Salesforce的一种编程语言，专门用来处理业务逻辑。 总结一下，测试视觉力量是为了确保我们的自定义界面能够正常工作，而控制器则是这些界面的“大脑”，负责处理用户的输入和决定页面的显示内容。希望这个解释能帮助你更好地理解这两个概念。如果你有任何问题，随时问我哦！

  ▶ 播放视频 查看详情
• 439

  Testing Visualforce Controllers

  第 522 页

  让我们来聊聊如何测试Visualforce控制器。首先，Visualforce控制器是Salesforce中用来处理页面逻辑的部分，它负责与视图（也就是用户看到的页面）进行交互。为了确保控制器能够正常工作，我们需要对它进行测试。 首先，你需要了解控制器是如何与视图交互的。简单来说，控制器会接收用户在页面上输入的数据，处理这些数据，然后返回结果给视图显示。测试这一部分，就是要确保控制器能够正确地接收和处理数据。 接下来，我们要测试控制器的构造器。构造器是控制器初始化时调用的方法，它负责设置控制器的初始状态。测试构造器就是要确保控制器在创建时能够正确地初始化所有必要的变量和对象。 然后，我们需要测试控制器的动作方法、getter和setter。动作方法是用户点击按钮或链接时触发的方法，它们通常包含主要的业务逻辑。Getter和setter是用来获取和设置控制器属性的方法。测试这些方法就是要确保它们能够正确地执行预期的操作，并且属性能够正确地被获取和设置。 最后，我们需要测试控制器的属性。属性是控制器中存储数据的变量。测试属性就是要确保这些变量能够正确地存储和返回数据。 总结一下，测试Visualforce控制器主要包括测试它与视图的交互、构造器、动作方法、getter、setter和属性。通过这些测试，我们可以确保控制器能够正常工作，从而为用户提供流畅的体验。希望这些信息对你有帮助！

  ▶ 播放视频 查看详情
• 440

  Module Agenda - 523

  第 523 页

  同学们，今天我们来聊聊Salesforce中的Visualforce控制器测试。这个模块的内容非常实用，能帮助我们确保我们的Visualforce页面和控制器能够正常工作。 首先，我们要了解什么是Visualforce控制器测试。简单来说，就是写一些代码来检查我们的控制器是否按预期工作。这包括检查控制器的构造器、行动方法以及Getters和Setters。 接下来，我们会学习如何测试Visualforce控制器的构造器。构造器是控制器初始化时调用的方法，我们需要确保它在各种情况下都能正确初始化控制器。 然后，我们会讨论如何测试行动方法。这些方法是用户与页面交互时调用的，比如点击按钮或提交表单。我们需要确保这些方法能够正确处理用户输入并返回正确的结果。 最后，我们会学习如何测试Getters、Setters和属性。这些是控制器中用来获取和设置数据的方法和属性。我们需要确保它们能够正确地读取和写入数据。 通过这些测试，我们可以大大提高我们的Visualforce页面的稳定性和可靠性。希望这些内容对你们有所帮助，让我们开始吧！

  ▶ 播放视频 查看详情
• 441

  Visualforce Controllers are Like Other Apex Classes

  第 524 页

  让我们来聊聊Visualforce控制器的测试。想象一下，你正在开发一个在线调查问卷，这个问卷有三个页面，都是用Visualforce做的，而且它们共享同一个控制器。现在，假设用户在第一页没有填写任何信息就点击了保存按钮，这时候应该会出现一个错误页面。 在测试这个功能时，我们不能让真实的用户去点击页面，所以我们需要写一些代码来模拟用户的行为。这里有几个关键步骤： 1. ，设置页面，：首先，我们需要告诉测试代码从哪个页面开始。我们可以使用`PageReference`类来指定页面，比如`Page.firstPage`，然后使用`Test.setCurrentPage`方法将这个页面设置为当前页面。 2. ，实例化控制器，：页面准备好了，但控制器还没有。我们需要创建一个控制器的实例，比如`QuestionnaireController`。 3. ，模拟用户操作，：接下来，我们需要模拟用户点击保存按钮的行为。这可以通过直接调用控制器的`save`方法来实现。这个方法会返回一个页面URL，我们可以通过`getUrl`方法获取这个URL。 4. ，验证结果，：我们需要检查是否正确地跳转到了错误页面。我们可以使用`System.assertEquals`来比较`save`方法返回的URL和我们预期的错误页面URL是否一致。 5. ，模拟用户输入，：如果用户提供了输入，我们需要在页面URL中添加参数来模拟这一点。比如，我们可以使用`ApexPages.currentPage().getParameters().put`来添加参数。 6. ，重新实例化控制器并测试，：添加参数后，我们需要重新实例化控制器，并再次调用`save`方法，确保一切正常工作。最后，我们再次使用`System.assertEquals`来验证是否跳转到了正确的页面。 通过这些步骤，我们可以确保我们的控制器在各种情况下都能正确地处理用户的输入和操作。这就是测试Visualforce控制器的基本流程。希望这能帮助你更好地理解和应用这些概念！

  ▶ 播放视频 查看详情
• 442

  What's Different About Testing Controllers?

  第 525 页

  让我们来聊聊Salesforce中的测试控制器，特别是与Visualforce页面和用户交互相关的内容。首先，我们要明白，控制器在Salesforce中扮演着非常重要的角色，它就像是页面的“大脑”，负责处理数据和用户的操作。 当我们创建一个Visualforce页面时，控制器会自动被实例化，也就是说，系统会自动调用控制器的构造函数来设置页面。这个构造函数会初始化一些必要的变量和对象，确保页面加载时一切就绪。 在页面上，我们通常会使用一些元素，比如文本框、按钮等。这些元素可以通过调用控制器的Getter和Setter方法来获取或设置数据。Getter方法用于从控制器中获取数据并显示在页面上，而Setter方法则用于将用户输入的数据传回控制器。这样，页面和控制器之间就形成了一个双向的数据流。 当用户点击页面上的按钮或链接时，会触发控制器的操作方法。这些方法可以执行各种任务，比如保存数据、导航到其他页面等。在测试这些操作方法时，我们需要确保它们能够正确地执行，并且返回预期的结果。 在测试控制器时，除了我们之前学过的测试基础知识外，还有一些特殊的事情需要考虑。比如，我们需要确保控制器的构造函数能够正确地实例化，操作方法能够被正确调用，并且返回的结果是我们期望的。此外，我们还需要测试Getter和Setter方法，确保它们能够正确地获取和设置数据。 在本模块中，我们会通过一些示例来详细讲解这些内容，帮助大家更好地理解和掌握如何测试Salesforce中的控制器。希望这些内容对大家有所帮助，让我们一起加油，成为Salesforce的高手吧！

  ▶ 播放视频 查看详情
• 443

  Understanding the Technician Status Page and Extension

  第 526 页

  今天我们来聊聊技术员状态页面和一些扩展的教学要点。这个页面你可能已经见过，但这次我们做了一些小调整，让它更符合我们的需求。 首先，当你把鼠标悬停在课程交付日期上时，你会看到表格下方出现一个字符串，这个字符串列出了课程中的所有参与者。这个功能是通过一个叫做`actionSupport`的标签来实现的，它能够在不刷新页面的情况下获取数据并显示出来。 接下来，你会注意到页面上有三个编辑按钮。虽然它们看起来都差不多，但它们的工作原理却有所不同： 1. ，第一个按钮，：它直接调用了Salesforce标准控制器的编辑方法。这是最直接的方式，点击后就会进入编辑页面。 2. ，第二个按钮，：它调用了一个自定义方法，这个方法内部再调用标准控制器的编辑方法。这种方式给了我们更多的灵活性，可以在进入编辑页面前做一些额外的操作。 3. ，第三个按钮，：它直接导航到编辑页面的URL。这种方式比较直接，适合在特定情况下使用。 在接下来的课程中，我们会更详细地探讨这些不同的方法，帮助你理解它们的使用场景和优缺点。这样，你就能在实际工作中灵活运用这些技巧了。 希望这些内容对你有帮助，如果有任何问题，随时问我哦！

  ▶ 播放视频 查看详情
• 444

  Module Agenda - 527

  第 527 页

  同学们，今天我们要来聊聊Salesforce中的一个非常有趣且重要的主题——测试Visualforce控制器。这个模块的议程分为四个部分，我们会一步步来探讨。 首先，我们会，了解Visualforce控制器测试，。这部分主要是让大家明白为什么我们需要测试Visualforce控制器，以及测试能帮助我们解决哪些问题。简单来说，测试就像是给我们的代码做一次体检，确保它在各种情况下都能正常工作。 接下来，我们会，测试Visualforce控制器的构造器，。构造器是控制器中非常重要的部分，它负责初始化控制器中的变量和对象。我们会看看如何编写测试代码来确保构造器能够正确地完成它的工作。 然后，我们会，测试行动方法，。行动方法是用户与Visualforce页面交互时调用的方法，比如点击按钮后执行的操作。我们会学习如何模拟这些用户操作，并验证行动方法是否按预期执行。 最后，我们会，测试Getters、Setters和属性，。这些是控制器中用于获取和设置数据的方法和属性。我们会确保这些方法和属性能够正确地处理数据，保证数据的准确性和一致性。 好了，这就是我们今天要学习的内容。希望大家能够跟上节奏，如果有任何问题，随时提问。我们开始吧！

  ▶ 播放视频 查看详情
• 445

  Testing the Constructor

  第 528 页

  让我们来聊聊如何测试构建者，也就是我们常说的控制器扩展。首先，你需要明白，测试构建者的工作就是确保它所做的每一件事都能按预期运行。这听起来可能有点抽象，但别担心，我会慢慢解释。 在我们的例子中，这个构建者是一个控制器扩展。这意味着它必须能够实例化标准控制器。简单来说，就是它需要能够创建一个标准控制器的实例，这样才能正常工作。 现在，你可能看到接下来的几张幻灯片展示了几种不同的测试技术。但请注意，并不是所有这些技术在我们的例子中都是必要的。为什么呢？因为我们的控制器扩展并没有使用到每一个被测试的元素。不过，这些技术都是测试Visualforce控制器时非常常见的方法，所以了解它们还是很有帮助的。 总结一下，测试构建者就是要确保它能正确地实例化标准控制器，并且按预期工作。虽然并不是所有的测试技术都适用于我们的例子，但了解这些技术对于测试Visualforce控制器是非常有用的。希望这能帮助你更好地理解如何测试构建者！

  ▶ 播放视频 查看详情
• 446

  Testing Controller Constructors: Setting currentPage()

  第 529 页

  让我们来聊聊如何在Salesforce中测试控制器的构造器，特别是如何设置和测试`currentPage()`。这个过程其实挺有意思的，就像你在搭建一个小舞台，然后看看演员（也就是你的代码）在上面怎么表演。 首先，想象一下，你有一个控制器类，叫做`MyController`。这个类有一个构造器，它的任务是在对象创建的时候，获取当前的Visualforce页面，并把它保存起来。这个页面信息是通过`ApexPages.currentPage()`这个方法获取的。 现在，我们要测试这个构造器，确保它真的能正确地获取并保存页面信息。为了做到这一点，我们需要模拟一个Visualforce页面，这样`ApexPages.currentPage()`就能返回我们设定的页面，而不是真的去访问一个页面。 这里是怎么做的： 1. ，创建测试页面引用，：首先，我们创建一个`PageReference`对象，指向我们想要测试的页面，比如`Page.MyPage`。这就像是在说，“嘿，假设我们现在就在这个页面上”。 2. ，设置当前页面，：然后，我们使用`Test.setCurrentPage()`方法，把我们刚才创建的页面引用设置为当前的页面。这就像是把我们的模拟页面放到舞台上，让`ApexPages.currentPage()`能够看到它。 3. ，实例化控制器，：接下来，我们创建`MyController`的一个实例。当这个实例被创建时，它的构造器会自动运行，尝试获取当前的页面，并保存它。 4. ，验证结果，：最后，我们需要检查一下，看看构造器是否真的把页面信息保存下来了。这通常涉及到检查控制器的某个属性，确保它和我们设置的模拟页面匹配。 通过这样的步骤，我们就可以确保我们的控制器构造器在不同的情况下都能正确地工作。这不仅帮助我们理解代码的行为，也确保我们的应用在各种情况下都能稳定运行。 希望这个解释能帮助你更好地理解如何在Salesforce中测试控制器的构造器。如果有任何疑问，随时问我哦！

  ▶ 播放视频 查看详情
• 447

  Testing Controller Constructors: Setting Page Parameters

  第 530 页

  同学们，今天我们来聊聊如何在Salesforce中测试控制器的构造器。这个构造器的作用是设置页面参数，并且填充HTTP查询字符串参数，这样控制器就能找到这些参数了。 首先，我们需要创建一个测试账户。这个账户会用来模拟真实的数据。创建好之后，我们会用到这个账户的Id。这个Id会被填充到测试页面的Id参数中。这样做的好处是，我们可以确保控制器在测试时使用的是真实的数据，而不是凭空想象的数据。 接下来，构造器会做一件很重要的事情：它会将当前的Id参数存储为一个变量，我们这里叫它curId。这个curId会在稍后的测试过程中被使用。这样做的目的是为了确保在测试的不同阶段，我们都能访问到这个Id，而不会丢失或者混淆。 简单来说，这个过程就是：创建测试数据 -&gt; 填充到页面参数 -&gt; 存储为变量以备后用。这样，我们的控制器就能在测试中准确地找到并使用这些参数了。 希望这个解释对你们有帮助，如果还有疑问，随时提问哦！

  ▶ 播放视频 查看详情
• 448

  Testing Controller Extensions: Mocking the Controller

  第 531 页

  同学们，今天我们来聊聊如何在Salesforce中测试控制器扩展。首先，我们要明白，控制器扩展通常会依赖于它所扩展的控制器的一些方法或数据。这就意味着，在测试控制器扩展时，我们需要“嘲笑”或模拟这些控制器，以确保我们的测试能够顺利进行。 想象一下，你有一个控制器扩展，它需要从一个标准的控制器中获取一些数据。为了测试这个扩展，我们不能直接使用真实的控制器，因为那样可能会引入不必要的外部依赖，导致测试结果不可预测。所以，我们需要创建一个“假”的控制器，也就是我们说的“嘲笑”控制器。 接下来，我们来看一个简单的例子。假设我们有一个名为`MyControllerExt`的控制器扩展，它依赖于一个标准的`ApexPages.StandardController`。在测试代码中，我们首先创建一个测试用的`Account`对象，并填充一些测试数据。然后，我们实例化一个`ApexPages.StandardController`，并将这个测试用的`Account`对象传递给它。 ```apex Account testAccount = new Account(); // 填充测试数据 ApexPages.StandardController stdCtrl = new ApexPages.StandardController(testAccount); MyControllerExt testExt = new MyControllerExt(stdCtrl); ``` 在这个例子中，`stdCtrl`就是我们“嘲笑”的控制器。我们将它传递给`MyControllerExt`，这样在测试过程中，`MyControllerExt`就可以使用这个模拟的控制器来获取数据或调用方法，而不会影响到真实的控制器。 最后，我们可以调用`MyControllerExt`中的setter、action和getter方法，来验证它们的行为是否符合预期。这样，我们就能够在不依赖真实控制器的情况下，全面测试我们的控制器扩展了。 希望这个解释能帮助大家更好地理解如何在Salesforce中测试控制器扩展。如果有任何问题，欢迎随时提问！

  ▶ 播放视频 查看详情
• 449

  20-1: Write the Test Methods for the Constructor

  第 532 页

  同学们，今天我们要学习如何为Salesforce中的“技术员状态”页面编写测试方法。这个页面的控制器有一个扩展版本，我们需要确保这个扩展的构造函数能够被成功调用。我们将分几个步骤来完成这个任务。 首先，我们需要上传两个文件：一个是控制器的代码，另一个是页面的标记代码。这两个文件是页面的核心，控制着页面的行为和显示。 接下来，我们要创建一个单元测试方法。这个方法的目的是测试扩展的构造函数。我们需要确保当页面加载时，构造函数能够正确地初始化所有必要的变量和对象。 创建测试方法后，我们需要运行这个测试，看看它是否能够正确地验证构造函数的调用。如果测试通过，那么我们就可以确信我们的扩展构造函数是有效的。 最后，我们要回顾一下整个过程，确保我们的测试方法覆盖了所有重要的逻辑，并且能够准确地反映出页面的行为。 这个过程大约需要20分钟。现在，轮到你们动手实践了。记住，编写测试方法是一个非常重要的技能，它可以帮助我们确保代码的质量和稳定性。加油！

  ▶ 播放视频 查看详情
• 450

  Module Agenda - 533

  第 533 页

  同学们，今天我们来聊聊Salesforce中的Visualforce控制器测试。这个模块的内容非常重要，因为它能帮助我们确保我们的Visualforce页面和控制器能够正常工作。 首先，我们要了解什么是Visualforce控制器测试。简单来说，就是写一些代码来检查我们的控制器是否按预期工作。这包括测试控制器的构造器、行动方法以及Getters和Setters。 接下来，我们会详细讲解如何测试控制器的构造器。构造器是控制器初始化时调用的方法，我们需要确保它正确地设置了所有必要的变量和对象。 然后，我们会讨论如何测试行动方法。这些方法是用户与页面交互时调用的，比如点击按钮或提交表单。我们需要确保这些方法能够正确处理输入并返回正确的结果。 最后，我们会学习如何测试Getters和Setters以及属性。这些是控制器中用于获取和设置数据的方法，我们需要确保它们能够正确地读取和写入数据。 通过这些测试，我们可以大大提高我们的Visualforce页面的质量和可靠性。希望大家能够认真听讲，并在课后进行实践。如果有任何问题，随时提问。我们开始吧！

  ▶ 播放视频 查看详情
• 451

  Testing Action Methods

  第 534 页

  同学们，今天我们来聊聊如何在Salesforce中测试控制器扩展中的动作方法。这个听起来可能有点技术性，但其实很简单，我会用最通俗的语言来解释。 首先，什么是控制器扩展呢？简单来说，控制器扩展就是在Salesforce的标准控制器基础上，添加一些自定义的功能。比如，你可能想要在点击一个按钮时，执行一些特定的操作，这时候就需要用到控制器扩展。 那么，如何测试这些动作方法呢？我们可以通过编写测试类来实现。测试类的主要目的是确保我们的代码在各种情况下都能正常工作。 假设我们有一个控制器扩展，里面有一个方法叫做“saveRecord”，这个方法的作用是保存一条记录。我们需要测试这个方法是否真的能保存记录。 首先，我们创建一个测试类。在这个测试类中，我们会模拟一些数据，然后调用“saveRecord”方法。之后，我们会检查记录是否真的被保存了。 举个例子，假设我们有一个自定义对象叫做“CustomObject__c”，我们想要测试“saveRecord”方法是否能保存这个对象的记录。我们可以在测试类中创建一个“CustomObject__c”的实例，然后调用“saveRecord”方法。最后，我们使用SOQL查询来检查这条记录是否真的存在于数据库中。 如果记录存在，那么我们的测试就通过了；如果不存在，那么我们就需要检查代码中哪里出了问题。 总结一下，测试控制器扩展中的动作方法，其实就是模拟数据，调用方法，然后验证结果。这个过程虽然听起来有点复杂，但只要你理解了基本的逻辑，就会发现其实并不难。 好了，今天的课程就到这里。希望你们对如何测试控制器扩展中的动作方法有了更清晰的理解。如果有任何问题，随时问我哦！

  ▶ 播放视频 查看详情
• 452

  Components of an Action Method

  第 535 页

  今天我们来聊聊Salesforce中的行动方法。行动方法主要分为两种类型：导航型和逻辑型。导航型的行动方法，顾名思义，就是用来在系统中导航的，比如从一个页面跳转到另一个页面。而逻辑型的行动方法则涉及到一些计算、条件判断或者触发某些业务逻辑。 当我们使用这些行动方法时，测试是非常重要的。特别是对于逻辑型的行动方法，我们需要在测试导航功能之前，先单独测试这些逻辑是否正确执行。这是因为如果逻辑部分有问题，那么即使导航功能正常，整个流程也可能无法达到预期的效果。 所以，记得在测试时，先确保逻辑部分没有问题，再测试导航部分。这样可以避免很多不必要的麻烦，也能确保我们的系统更加稳定和可靠。希望这个小技巧对你们有帮助！

  ▶ 播放视频 查看详情
• 453

  Testing an Action Method

  第 536 页

  让我们来聊聊如何在Salesforce中测试一个Action Method，也就是我们常说的操作方法。这个操作通常是在Visualforce页面上，比如你点击一个“保存”按钮时触发的。 首先，我们需要理解的是，当我们点击页面上的按钮时，比如“保存”按钮，它会调用一个后台的Apex方法。这个方法会执行一些操作，比如保存数据到数据库中。为了确保这个方法按预期工作，我们需要写一些测试代码来模拟这个点击操作，并验证结果。 现在，我们来看一下你提供的测试代码： 1. 首先，我们创建了一个控制器实例 `MyController testControl = new MyController();`。这个控制器通常是与Visualforce页面绑定的，它包含了页面需要的所有逻辑和数据。 2. 接下来，我们设置了控制器的属性。比如 `testControl.setName(&#39;John&#39;);` 这行代码，我们假设控制器有一个方法 `setName`，用来设置一个名字。这里我们设置名字为“John”。 3. 然后，我们调用了 `testControl.setCal(new Cal());`。这里假设 `setCal` 方法接受一个 `Cal` 类型的对象，并将其设置为控制器的属性。`Cal` 可能是我们定义的一个类，用来处理一些特定的逻辑。 4. 最后，我们调用了 `save` 方法，这个方法通常是我们点击“保存”按钮时调用的。`PageReference successPage = testCtrl.save();` 这行代码执行了保存操作，并返回一个 `PageReference` 对象。这个对象通常用来重定向用户到另一个页面，比如保存成功后的确认页面。 通过这样的测试代码，我们可以模拟用户在页面上的操作，并验证控制器的逻辑是否正确执行。如果 `save` 方法按预期工作，它应该返回一个有效的 `PageReference`，并且相关的数据应该被正确地保存到数据库中。 这就是如何通过显式调用方法来测试一个Action Method的基本流程。希望这能帮助你更好地理解Salesforce中的测试方法！

  ▶ 播放视频 查看详情
• 454

  Verify Where the Action "Goes"

  第 537 页

  同学们，今天我们来聊聊验证行动中的“去哪里”教学点。这个部分其实就是在讲，我们在测试软件或者系统的时候，不仅要看它处理正确数据时表现如何，还要看它在面对错误或意外数据时，能不能妥善处理。 首先，我们来说说阳性测试。阳性测试就像是给系统一个“幸福之路”的考验。我们输入正确的数据，看看系统是不是能按照预期那样，给出我们想要的结果。比如，3B-5 B这个行为，就是阳性测试的一个例子。我们输入3B-5 B，系统应该能正确识别并处理这个数据，给出我们预期的输出。 然后，我们再来看看阴性测试。阴性测试就像是给系统一个“不愉快的路径”的考验。我们输入一些错误的数据，或者故意制造一些意外情况，看看系统能不能妥善处理这些异常。比如，6 B-7 B这个行为，就是阴性测试的一个例子。我们输入6 B-7 B，系统应该能识别出这个数据有问题，并给出相应的错误提示或者处理方式。 所以，同学们，记住哦，验证行动中的“去哪里”教学点，就是要我们既关注系统在正确数据下的表现，也要关注它在错误数据下的应对能力。这样，我们才能更全面地了解系统的性能和稳定性。

  ▶ 播放视频 查看详情
• 455

  20-2: Write Unit Tests for Action Methods

  第 538 页

  同学们，今天我们来学习如何为Salesforce中的控制器扩展编写单元测试。特别是，我们要测试“技术员状态”页面的控制器扩展中的两个自定义操作方法。 首先，我们需要理解什么是控制器扩展。在Salesforce中，控制器扩展是一个Apex类，它扩展了标准或自定义控制器的功能。这意味着我们可以在页面上添加更多的逻辑和功能。 现在，假设我们有一个名为`TechnicianStatusController`的控制器扩展，它有两个自定义操作方法：`updateStatus`和`resetStatus`。我们的任务是编写单元测试来验证这两个方法是否按预期工作。 ### 第一步：创建测试类 首先，我们需要创建一个测试类。这个类将包含我们的测试方法。我们可以命名为`TechnicianStatusControllerTest`。 ```apex @isTest public class TechnicianStatusControllerTest { // 这里我们将编写测试方法 } ``` ### 第二步：编写测试方法 接下来，我们需要为每个自定义操作方法编写一个测试方法。我们将使用`@isTest`注解来标记这些方法为测试方法。 #### 测试`updateStatus`方法 假设`updateStatus`方法用于更新技术员的状态。我们可以编写一个测试方法来模拟这个操作，并验证状态是否被正确更新。 ```apex @isTest static void testUpdateStatus() { // 创建测试数据 Technician__c tech = new Technician__c(Name=&#39;Test Tech&#39;, Status__c=&#39;Active&#39;); insert tech; // 实例化控制器扩展 TechnicianStatusController controller = new TechnicianStatusController(new ApexPages.StandardController(tech)); // 调用updateStatus方法 controller.updateStatus(); // 验证状态是否更新 Technician__c updatedTech = [SELECT Status__c FROM Technician__c WHERE Id = :tech.Id]; System.assertEquals(&#39;Inactive&#39;, updatedTech.Status__c, &#39;Status should be updated to Inactive&#39;); } ``` #### 测试`resetStatus`方法 假设`resetStatus`方法用于重置技术员的状态。我们可以编写一个测试方法来模拟这个操作，并验证状态是否被重置。 ```apex @isTest static void testResetStatus() { // 创建测试数据 Technician__c tech = new Technician__c(Name=&#39;Test Tech&#39;, Status__c=&#39;Inactive&#39;); insert tech; // 实例化控制器扩展 TechnicianStatusController controller = new TechnicianStatusController(new ApexPages.StandardController(tech)); // 调用resetStatus方法 controller.resetStatus(); // 验证状态是否重置 Technician__c updatedTech = [SELECT Status__c FROM Technician__c WHERE Id = :tech.Id]; System.assertEquals(&#39;Active&#39;, updatedTech.Status__c, &#39;Status should be reset to Active&#39;); } ``` ### 第三步：运行测试 编写完测试方法后，我们需要运行这些测试来验证我们的逻辑是否正确。在Salesforce中，你可以通过开发者控制台或使用命令行工具来运行测试。 ### 总结 通过以上步骤，我们为“技术员状态”页面的控制器扩展中的两个自定义操作方法编写了单元测试。这些测试方法帮助我们确保代码的正确性和可靠性。记住，编写单元测试是开发过程中非常重要的一部分，它可以帮助我们及早发现和修复问题。 希望这个讲解对你们有帮助！如果有任何问题，随时提问。

  ▶ 播放视频 查看详情
• 456

  Module Agenda - 539

  第 539 页

  今天我们来聊聊Salesforce中的Visualforce控制器测试。这个模块的内容非常实用，能帮助你确保你的Visualforce页面和控制器都能正常工作。 首先，我们会了解一下什么是Visualforce控制器测试。简单来说，就是通过编写测试代码来检查你的控制器是否按预期工作。这包括检查控制器的构造器、行动方法以及Getters和Setters等属性。 接下来，我们会详细讲解如何测试Visualforce控制器的构造器。构造器是控制器初始化时调用的方法，确保它正确地设置了初始状态是非常重要的。 然后，我们会讨论如何测试行动方法。这些方法是用户与页面交互时调用的，比如点击按钮或提交表单。我们需要确保这些方法能正确地处理用户输入并返回预期的结果。 最后，我们会学习如何测试Getters、Setters和属性。这些是控制器中用于获取和设置数据的方法和属性。通过测试它们，我们可以确保数据在控制器和页面之间正确地传递。 通过这个模块的学习，你将能够编写有效的测试代码，确保你的Visualforce控制器在各种情况下都能稳定运行。这不仅有助于提高代码质量，还能减少生产环境中的错误。希望这些内容对你有所帮助！

  ▶ 播放视频 查看详情
• 457

  Testing Getter and Setter Methods

  第 540 页

  今天我们来聊聊如何在Salesforce中测试Getter和Setter方法。这两个方法在Apex类中非常常见，它们帮助我们获取和设置对象字段的值。 首先，假设我们有一个Apex类，里面有一个字段叫做`field`。我们通常会为这个字段创建Getter和Setter方法。Getter方法用来获取字段的值，Setter方法用来设置字段的值。 ### 1. 设置值 假设我们有一个字符串变量`test`，我们想把这个变量的值设置到`field`字段中。我们可以这样做： ```apex obj.field = test; ``` 这里，`obj`是我们的对象实例，`field`是我们要设置的字段。通过这行代码，`test`的值就被设置到了`field`字段中。 ### 2. 获取值 接下来，我们想验证一下这个值是否真的被设置成功了。我们可以使用Getter方法来获取`field`字段的值，然后和`test`变量进行比较。 ```apex String retrievedValue = obj.field; System.assertEquals(test, retrievedValue); ``` 在这段代码中，`retrievedValue`是通过Getter方法获取的`field`字段的值。然后我们使用`System.assertEquals`方法来比较`test`和`retrievedValue`是否相等。如果相等，说明我们的Setter方法工作正常。 ### 3. 总结 - ，Setter方法，：用来设置字段的值。比如`obj.field = test;`。 - ，Getter方法，：用来获取字段的值。比如`String retrievedValue = obj.field;`。 - ，验证，：通过比较设置的值和获取的值，确保Getter和Setter方法正常工作。 通过这种方式，我们可以轻松地测试和验证我们的Getter和Setter方法是否按预期工作。希望这个解释对你有帮助！如果有任何问题，随时问我哦！

  ▶ 播放视频 查看详情
• 458

  Testing Getters: A more Complex example

  第 541 页

  同学们，今天我们来聊聊如何测试Getters方法。想象一下，你有一个方法，它的任务是给你一些数据。现在，你需要确保这个方法真的能给你你想要的数据，而且数据是准确和有效的。 首先，我们来看看具体结果。这意味着你要检查方法返回的数据是否完全符合你的预期。比如，如果你期望得到一个包含三个元素的列表，那么你就需要确认返回的列表确实有三个元素。 接下来，是包含特定值的结果。这里，你要检查返回的数据中是否包含了你需要的特定值。比如说，如果你需要列表中包含某个特定的名字，那么你就要确认这个名字确实在返回的列表中。 最后，我们要检查的是有效结果。这很简单，就是确保返回的数据不是空的。如果方法返回了一个空值，那显然这不是我们想要的结果。 记住，测试Getters方法的目的，是为了确保你的代码能够稳定、可靠地返回你需要的数据。这样，当你在构建更复杂的系统时，你可以信赖这些基础的方法，它们会像坚固的基石一样，支撑起你的整个应用。 好了，这就是今天的内容。希望你们能理解并记住这些要点，下次我们再见！

  ▶ 播放视频 查看详情
• 459

  Testing Properties

  第 542 页

  今天我们来聊聊在Salesforce中处理Visualforce页面时，关于属性绑定和getter方法的一些小技巧。听起来有点复杂，但其实很简单，我会用简单的语言来解释。 首先，当你在Visualforce页面上工作时，你可能会想要显示一些来自Apex控制器的数据。这时候，你通常会使用一个叫做“值绑定”的技术。简单来说，就是告诉Visualforce页面：“嘿，去Apex控制器里找这个数据，然后显示出来。” 在Visualforce页面上，你只需要写属性的名字，不需要写“get”这个词。比如，如果你的Apex控制器里有一个方法叫做`getUserName()`，那么在Visualforce页面上，你只需要写`{!userName}`，Visualforce就会自动调用`getUserName()`方法来获取数据。 但是，当你在Apex代码里，比如在测试类中，想要调用这个getter方法时，情况就有点不同了。你不能像在Visualforce页面上那样只写属性名，你必须完整地调用这个方法，包括“get”这个词。所以，在测试类中，你会写`controller.getUserName()`来获取数据。 总结一下，Visualforce页面上的值绑定是简化的，你只需要写属性名，而在Apex代码中，你需要完整地调用getter方法。这个小细节很重要，因为它确保了你的代码在不同的上下文中都能正确工作。 希望这个解释能帮助你更好地理解在Salesforce中如何处理属性和getter方法。如果有任何问题，随时问我哦！

  ▶ 播放视频 查看详情
• 460

  20-3: Write Unit Tests for Getters and Setters

  第 543 页

  让我们一起来完成这个任务。首先，我们需要理解什么是Getter和Setter。在Salesforce中，Getter方法用于获取一个变量的值，而Setter方法用于设置一个变量的值。在这个任务中，我们主要关注的是测试一个名为`getAttendeeList`的Getter方法。 ### 第一步：理解控制器扩展代码 假设我们有一个控制器扩展，它管理“技术员状态”页面的逻辑。在这个控制器扩展中，有一个方法叫做`getAttendeeList`，它返回一个包含“Attendees：”字符串的列表。 ### 第二步：创建单元测试方法 我们需要创建一个单元测试方法来测试`getAttendeeList`方法。单元测试的目的是确保我们的代码按预期工作。我们可以使用Salesforce的Apex测试框架来编写这个测试。 ```apex @isTest private class TechnicianStatusControllerTest { @isTest static void testGetAttendeeList() { // 创建控制器扩展的实例 TechnicianStatusController controller = new TechnicianStatusController(); // 调用getAttendeeList方法 List attendeeList = controller.getAttendeeList(); // 断言返回的列表包含“Attendees：” System.assert(attendeeList.contains(&#39;Attendees：&#39;), &#39;The attendee list should contain &quot;Attendees：&quot;&#39;); } } ``` ### 第三步：测试新的单元测试逻辑 现在，我们需要运行这个测试来确保它按预期工作。在Salesforce中，你可以通过开发者控制台或Salesforce CLI来运行测试。 1. 打开开发者控制台。 2. 选择“测试”菜单，然后选择“新建运行”。 3. 选择你刚刚创建的测试类`TechnicianStatusControllerTest`。 4. 点击“运行”按钮。 ### 第四步：检查测试结果 测试运行完成后，你应该能够看到测试结果。如果测试通过，那么恭喜你，你的`getAttendeeList`方法按预期工作。如果测试失败，你需要检查你的代码，看看哪里出了问题。 ### 总结 通过这个任务，我们学习了如何编写和测试一个Getter方法。我们创建了一个单元测试方法来确保`getAttendeeList`方法返回包含“Attendees：”字符串的列表。然后我们运行了这个测试，并检查了结果。这个过程帮助我们确保我们的代码是可靠和正确的。 希望这个解释对你有帮助！如果你有任何问题，随时问我。

  ▶ 播放视频 查看详情
• 461

  Key Takeaways - 544

  第 544 页

  让我们来聊聊Visualforce控制器的测试。首先，你得知道，就像Apex触发器和类一样，Visualforce控制器也需要满足代码覆盖的要求。这意味着你需要编写足够的测试代码来确保你的控制器逻辑被充分测试。 当你测试Visualforce控制器时，你需要模拟用户和视图的行为。这就像是你在扮演一个用户，点击按钮、输入数据，看看控制器会怎么反应。这样做的目的是确保控制器在实际使用中能够正常工作。 Visualforce控制器的测试主要分为几个类别： 1. ，构造函数，：这是控制器被创建时首先调用的部分。你需要测试构造函数是否正确初始化了所有必要的变量和对象。 2. ，动作方法，：这些是用户与页面交互时调用的方法，比如点击按钮。你需要测试这些方法是否按预期执行，比如是否正确地更新了数据或导航到了正确的页面。 3. ，接球手和接球手（Getter和Setter），：这些方法用于获取和设置控制器的属性。你需要测试这些方法是否正确地返回和设置值。 4. ，属性，：这些是控制器中定义的变量，用于存储数据。你需要测试这些属性是否被正确地初始化和使用。 通过这些测试，你可以确保你的Visualforce控制器在各种情况下都能稳定运行，为用户提供流畅的体验。记住，好的测试不仅能发现错误，还能帮助你理解代码的工作原理。所以，花时间好好测试你的控制器吧！

  ▶ 播放视频 查看详情