GraphQL 快速入门【3】GraphQL 架构

【注】本文译自: GraphQL – Quick Guide (tutorialspoint.com)
    GraphQL 是描述 GraphQL 服务器行为的规范。它是一组关于如何处理请求和响应的指南,如支持的协议、服务器可以接受的数据格式、服务器返回的响应格式等。客户端向 GraphQL 发出的请求服务器称为查询。GraphQL 的另一个重要概念是其传输层不可知性。它可以与任何可用的网络协议一起使用,如 TCP、websocket 或任何其他传输层协议。它对数据库也是中立的,因此您可以将它与关系数据库或 NoSQL 数据库一起使用。
    可以使用下面列出的三种方法中的任何一种来部署 GraphQL Server:

  • 带有连接数据库的 GraphQL 服务器
  • 集成现有系统的 GraphQL 服务器
  • 混合方法

    集成连接数据库的 GraphQL 服务器

        这种架构有一个带有集成数据库的 GraphQL 服务器,通常可以用于新项目。收到查询后,服务器读取请求有效负载并从数据库中获取数据。这称为解析查询。返回给客户端的响应遵循官方 GraphQL 规范中指定的格式。

        在上图中,GraphQL 服务器和数据库集成在一个节点上。客户端(桌面/移动)通过 HTTP 与 GraphQL 服务器通信。服务器处理请求,从数据库中获取数据并将其返回给客户端。

    GraphQL 服务器集成现有系统

        这种方法对于拥有遗留基础设施和不同 API 的公司很有帮助。GraphQL 可用于统一现有系统中的微服务、遗留基础设施和第三方 API。

        在上图中,GraphQL API 充当客户端和现有系统之间的接口。客户端应用程序与 GraphQL 服务器通信,后者反过来解析查询。

    混合方法

        最后,我们可以将以上两种方式结合起来,搭建一个 GraphQL 服务器。在这种架构中,GraphQL 服务器将解析收到的任何请求。它将从连接的数据库或集成的 API 中检索数据。这如下图所示:

GraphQL 快速入门【2】环境设置

【注】本文节译自:GraphQL – Quick Guide (tutorialspoint.com)

    在本章中,我们将学习 GraphQL 的环境设置。 要执行本教程中的示例,您将需要以下内容:

  • 运行 Linux、macOS 或 Windows 的计算机。
  • 网络浏览器,最好是最新版本的 Google Chrome。
  • 安装了最新版本的 Node.js。建议使用最新的 LTS 版本。
  • 已安装适用于 VSCode 的扩展 GraphQL 的 Visual Studio Code 或您选择的任何代码编辑器。

如何使用 Nodejs 构建 GraphQL 服务器

    我们将详细介绍使用 Nodejs 构建 GraphQL 服务器的步骤,如下所示:

第 1 步 – 验证节点和 Npm 版本

    安装 NodeJs 后,在终端上使用以下命令验证 node 和 npm 的版本:

C:\Users\Admin>node -v
v8.11.3

C:\Users\Admin>npm -v
5.6.0

第 2 步 – 创建项目文件夹并在 VSCode 中打开 项目的根文件夹可以命名为 test-app。

    按照以下说明使用 Visual Studio 代码编辑器打开文件夹:

C:\Users\Admin>mkdir test-app
C:\Users\Admin>cd test-app
C:\Users\Admin\test-app>code.

第 3 步 – 创建 package.json 并安装依赖项

    创建 package.json 文件,该文件将包含 GraphQL 服务器应用程序的所有依赖项。

{
   "name": "hello-world-server",
   "private": true,
   "scripts": {
      "start": "nodemon --ignore data/ server.js"
   },
   "dependencies": {
      "apollo-server-express": "^1.4.0",
      "body-parser": "^1.18.3",
      "cors": "^2.8.4",
      "express": "^4.16.3",
      "graphql": "^0.13.2",
      "graphql-tools": "^3.1.1"
   },
   "devDependencies": {
      "nodemon": "1.17.1"
   }
}

    使用下面给出的命令安装依赖项:

C:\Users\Admin\test-app>npm install

步骤 4 – 在数据文件夹中创建平面文件数据库

    在这一步中,我们使用平面文件来存储和检索数据。创建文件夹 data 并添加两个文件 student.jsonColleges.json
    以下是 Colleges.json 文件:

[
    {
       "id": "col-101",
       "name": "AMU",
       "location": "Uttar Pradesh",
       "rating":5.0
    },

    {
       "id": "col-102",
       "name": "CUSAT",
       "location": "Kerala",
       "rating":4.5
    }
 ]

    以下是 student.json 文件:

[
    {
       "id": "S1001",
       "firstName":"Mohtashim",
       "lastName":"Mohammad",
       "email": "mohtashim.mohammad@tutorialpoint.org",
       "password": "pass123",
       "collegeId": "col-102"
    },

    {
       "id": "S1002",
       "email": "kannan.sudhakaran@tutorialpoint.org",
       "firstName":"Kannan",
       "lastName":"Sudhakaran",
       "password": "pass123",
       "collegeId": "col-101"
    },

    {
       "id": "S1003",
       "email": "kiran.panigrahi@tutorialpoint.org",
       "firstName":"Kiran",
       "lastName":"Panigrahi",
       "password": "pass123",
       "collegeId": "col-101"
    }
 ]

第 5 步 – 创建数据访问层

    我们需要创建加载数据文件夹内容的数据存储。在这种情况下,我们需要集合变量、学生和大学。每当应用程序需要数据时,它就会使用这些集合变量。
    在项目文件夹中创建文件 db.js,如下所示:

const { DataStore } = require('notarealdb');

const store = new DataStore('./data');

module.exports = {
   students:store.collection('students'),
   colleges:store.collection('colleges')
};

第 6 步 – 创建模式文件,schema.graphql

    在当前项目文件夹中创建模式文件并添加以下内容:

type Query  {
   test: String
}

第 7 步 – 创建解析器文件,resolvers.js

    在当前项目文件夹中创建解析器文件并添加以下内容:

const Query = {
    test: () => 'Test Success, GraphQL server is up & running !!'
 }
 module.exports = {Query}

第 8 步 – 创建 Server.js 并配置 GraphQL

    创建服务器文件并按如下方式配置 GraphQL:

const bodyParser = require('body-parser');
const cors = require('cors');
const express = require('express');
const db = require('./db');

const port = process.env.PORT || 9000;
const app = express();

const fs = require('fs')
const typeDefs = fs.readFileSync('./schema.graphql',{encoding:'utf-8'})
const resolvers = require('./resolvers')

const {makeExecutableSchema} = require('graphql-tools')
const schema = makeExecutableSchema({typeDefs, resolvers})

app.use(cors(), bodyParser.json());

const  {graphiqlExpress,graphqlExpress} = require('apollo-server-express')
app.use('/graphql',graphqlExpress({schema}))
app.use('/graphiql',graphiqlExpress({endpointURL:'/graphql'}))

app.listen(
   port, () => console.info(
      `Server started on port ${port}`
   )
);

第 9 步 – 运行应用程序并使用 GraphiQL 进行测试

    验证项目 test-app 的文件夹结构如下:

test-app /
   -->package.json
   -->db.js
   -->data
      students.json
      colleges.json
   -->resolvers.js
   -->schema.graphql
   -->server.js

    运行命令 npm start,如下所示:

C:\Users\Admin\test-app>npm start

    服务器运行在 9000 端口,因此我们可以使用 GraphiQL 工具测试应用程序。打开浏览器并输入 URL http://localhost:9000/graphiql 。在编辑器中输入以下查询:

{
  test
}

    来自服务器的响应如下:

{
    "data": {
        "test": "Test Success, GraphQL server is running !!"
    }
}

GraphQL 快速入门【1】简介

【注】本文节译自:GraphQL – Quick Guide (tutorialspoint.com)

    GraphQL 是 Facebook 开发的一种开源服务器端技术,用于优化 RESTful API 调用。它是一种执行引擎和一种数据查询语言。在本章中,我们将讨论使用 GraphQL 的优势。

为什么使用 GraphQL

    RESTful API 遵循清晰且结构良好的面向资源的方法。但是,当数据变得更复杂时,路由会变得更长。有时无法通过单个请求获取数据。这就是 GraphQL 派上用场的地方。GraphQL 以图的形式构建数据,其强大的查询语法用于遍历、检索和修改数据。
    以下是使用 GraphQL 查询语言的优势:

询问你想要的 – 并得到它

    向您的 API 发送 GraphQL 查询并准确获取您需要的内容。GraphQL 查询总是返回可预测的结果。使用 GraphQL 的应用程序且稳定。与 Restful 服务不同,这些应用程序可以限制应该从服务器获取的数据。
    以下示例将帮助您更好地理解这一点:
    让我们考虑一个具有属性 idfirstNamelastNameCollegeName 的业务对象 Student。假设一个移动应用只需要获取 firstNameid。 如果我们设计一个像 /api/v1/students 这样的 REST 端点,它最终会为一个 Student 对象的所有字段获取数据。这意味着,数据被 RESTful 服务过度获取。 这个问题可以通过使用 GraphQL 来解决。
    考虑下面给出的 GraphQL 查询:

{
  {
    id
    firstName
  }
}

    这将仅返回 id 和 firstname 字段的值。该查询不会获取学生对象的其他属性的值。上面说明的查询的响应如下所示:

{
    "data": {
        "students": [
            {
                "id": "S1001",
                "firstName": "Mohtashim"
            },
            {
                "id": "S1002",
                "firstName": "Kannan"
            }
        ]
    }
}

在单个请求中获取多个资源

    GraphQL 查询有助于顺利检索关联的业务对象,而典型的 REST API 需要从多个 URL 加载。GraphQL API 在单个请求中获取您的应用程序所需的所有数据。即使在缓慢的移动网络连接上,使用 GraphQL 的应用程序也可以很快。
    让我们再考虑一个业务对象 College,它具有以下属性:名称和位置。 Student 业务对象与 College 对象具有关联关系。如果我们使用 REST API 来获取学生及其大学的详细信息,我们最终将向服务器发出两个请求,如 /api/v1/students/api/v1/colleges。这将导致每个请求的数据获取不足。 因此,移动应用被迫多次调用服务器以获取所需的数据。
    但是,移动应用可以使用 GraphQL 在单个请求中获取 Student 和 College 对象的详细信息。
    以下是用于获取数据的 GraphQL 查询:

{
  students {
    id
    firstName
    lastName
    college {
      name
      location
    }
  }
}

    上述查询的输出正好包含我们要求的那些字段,如下所示:

{
    "data": {
        "students": [
            {
                "id": "S1001",
                "firstName": "Mohtashim",
                "lastName": "Mohammad",
                "college": {
                    "name": "CUSAT",
                    "location": "Kerala"
                }
            },
            {
                "id": "S1002",
                "firstName": "Kannan",
                "lastName": "Sudhakaran",
                "college": {
                    "name": "AMU",
                    "location": "Uttar Pradesh"
                }
            },
            {
                "id": "S1003",
                "firstName": "Kiran",
                "lastName": "Panigrahi",
                "college": {
                    "name": "AMU",
                    "location": "Uttar Pradesh"
                }
            }
        ]
    }
}

描述类型系统的可能性

    GraphQL 是强类型的,查询基于字段及其关联的数据类型。如果 GraphQL 查询中存在类型不匹配,服务器应用程序会返回清晰且有用的错误消息。这有助于客户端应用顺利调试和轻松检测错误。 GraphQL 还提供了客户端库,可以帮助减少显式数据转换和解析。
    下面给出了 StudentCollege 数据类型的示例:

type Query {
  students: [Student]
}

type Student {
  id: ID!
  firstName: String
  lastName: String
  fullName: String
  college: College
}

type College {
  id: ID!
  name: String
  location: String
  rating: Float
  students: [Student]
}

使用强大的开发工具更快地响应

    GraphQL 为文档和测试查询提供了丰富的开发工具。GraphiQL 是一个出色的工具,可以生成查询及其模式的文档。 它还提供了一个查询编辑器,用于在构建查询时测试 GraphQL API 和智能代码完成功能。

如何构建 Spring Boot 12 因素应用

【注】本文译自:How to build a Spring Boot 12-Factor app (theserverside.com)
在这里,我们看看 Spring Boot 框架如何支持十二因素应用的方法,以及 GitHub、Docker 和 Kubernetes 等工具填补了哪些空白。
    没有国际标准组织指定 Spring Boot 应用作为微服务必须满足的标准。Heroku 联合创始人 Adam Wiggins 向部署到 Heroku 平台的开发人员提供的 12 条建议是开发人员最接近的一套云原生开发指南。
    这 12 条戒律被称为“十二因素应用方法论”,已成为创建现代的以 Docker 和 Kubernetes 为部署目标的现代云原生微服务的事实标准。
    开发基于 Java 的微服务最流行的平台是 Spring Boot。以下是 Spring Boot 如何支持十二因素应用方法论的原则。

1. Spring Boot 代码库

    并非每个 12 因素的原则都直接映射到 Spring Boot。代码库原则就是责任落在 Spring 框架之外的一个例子。
    根据十二因素应用,每个 Spring Boot 微服务都应该有自己独立的代码库。这可以通过创建单个 Git 存储库来实现,开发人员可以在其中贡献代码、合并分支和修复错误。如果您的 Spring Boot 应用托管在其自己的 Git 存储库中,那么您已经正确地实现了 12 因素代码库要求。

2. 外部化依赖管理

    如果您使用 Spring Boot 初始化器创建一个项目,则必须在 Gradle 或 Maven 之间进行选择作为项目的构建工具。这两个工具都将管理依赖项外部化。
    如果您将 JAR 文件放在项目的 lib 目录之外,并在 Maven POM 或 Gradle 构建文件中列出程序的所有外部依赖项,则您的 Spring Boot 应用程序将正确实现 12 因素 依赖项管理。

3. Spring Boot 和 Kubernetes 配置

    根据十二因素应用方法论,Spring Boot 应用程序应该从环境中读取其配置数据。 例如,如果将云原生 Spring Boot 应用程序部署到 Docker 容器并在 Kubernetes 集群中进行管理,则应用程序应该从 Kubernetes ConfigMap 读取其配置数据——而不是从 JavaBean 字段甚至应用程序属性文件。Spring 的级联配置处理系统完全满足了这个 12-因素要求。
    任何用 Spring @ConfigurationProperties 注解修饰的 JavaBean 都会在多个地方寻找配置数据。 @ConfigurationProperties 修饰的 bean 的规则是始终使用最高外部化级别的配置。在 JavaBean 中硬编码的属性将被 ApplicationProperties 文件中的数据覆盖,这些数据将被 JVM 参数覆盖,最终将被 Docker 或 Kubernetes ConfigMap 提供的参数覆盖。
    使用 @ConfigurationProperties 注解,您的 12 因素 Spring Boot 应用将符合配置。

4. 支持服务和 Spring Boot

    将支持服务视为附加资源的能力自 Java 语言一开始就已经融入到 Java 语言中,因此即使开发人员齐心协力,也很难违反这个 12 因素 约束。
    例如,所有通过 Java 数据库连接 (JDBC) 访问的数据库都需要一个 URL 和驱动程序,这隐式地使数据库成为附加资源。 如果不将数据库视为支持服务,就不可能在 Java 中执行 JDBC 或 JPA。 NoSQL 数据库、Kafka 队列和 RESTful Web 服务也是如此。如果您在 Jakarta EE 或 Spring Boot 中编写代码,则几乎必须按照 12-因素指南将所有外部资源视为支持服务。

5. 构建、发布和运行

    开发人员遵循严格的构建、发布和运行策略的建议似乎有些不言而喻。 具有讽刺意味的是,这也可能是最常违反的 12 因素规则之一。
    这里的想法是您应该始终从您的代码库构建您的代码。发布是与版本化配置文件相关联的标记构建。它是您在服务器上部署和运行的标记构建和版本化配置数据的组合。
    不应更新在服务器上运行的代码来修复错误。不应在运行时调整配置设置来克服 Java 性能问题。进入部署的所有代码都来自构建,它基于在裸 Git 存储库中进行版本控制的代码。
    一旦与构建配对以创建发布,配置数据就不得更改。如果需要更改,团队必须再次经历完整的构建、发布和运行周期。 不应该有违反 12 因素构建、发布和运行原则的捷径。

6. 无状态 Spring Boot 进程

    Java 和 Jakarta EE API 有许多类和接口,它们隐式地向应用程序添加状态,其中最重要的是 Servlet 和 JSP API 的 HttpSession 对象。
    为了实现 12 因素合规性,Spring Boot 为 HttpSession 提供了一个替代品,称为 Spring Session。这有助于外部化数据,否则这些数据将被有状态地保存在 Tomcat 或 Jetty 等应用程序服务器上。这是 Spring Boot 如何提供额外 API 并重新实现常用类以确保应用程序和微服务保持 12 因素合规性的一个主要示例。
    此外,Spring Boot 允许开发人员轻松地将 NoSQL 数据库(如 Cassandra 和 MongoDB)中的状态外部化,这也有助于简化无状态微服务的开发。
    必须指出的是,确保微服务作为无状态进程运行的责任也很大程度上落在了软件开发人员的肩上。如果开发人员决定将用户状态保存在一个实例变量中,而不是在共享资源中将该数据外部化,那么 Spring、Docker 或 Kubernetes 无法让该应用程序作为无状态进程进行扩展。

7. 端口绑定

    端口绑定是另一个 12 因素 原则,它超出了 Spring Boot 框架的范围。相反,Docker 容器会将 Tomcat 或 Undertow 服务器使用的内部端口映射到公共端口。在集群环境中,kubectl 实用程序会将 Kubernetes Pod 的端口绑定为公共服务。无论哪种方式,Spring Framework 都不负责端口绑定要求。
    Spring 确实提供了更改打包的 Spring Boot 应用程序内部使用的端口的能力,但 Kubernetes 或 Docker 将负责外部端口绑定,使云原生应用程序可公开访问。

8. 并发性

    根据十二因素应用方法论,云原生应用应该能够横向扩展,以支持来自客户端的大容量并发请求-响应周期。只要 Spring Boot 应用是无状态的,Kubernetes 副本集就会负责使用 Docker 容器创建新的 Pod,这些容器可以同时处理不断增加的工作负载。

9. 快速启动和关闭

    十二因素应用方法论的第 9 条原则是可处置性,它坚持微服务应该快速启动并优雅地关闭。
    为了便于处理,Spring Boot 实现了延迟加载设计模式。它还执行智能初始化以减少在云原生微服务启动时创建的对象数量。此外,当开发人员使用 Spring 框架提供的资源类时,控制能力的反转确保资源在 Kubernetes 节点耗尽或 Docker 容器下线时优雅地终止。

10. 环境之间的奇偶校验

    开发、用户验收测试、预生产和生产环境之间总会存在差异。但十二因素方法坚持这些环境尽可能相似。
    为了促进环境对等,Spring Boot 构建将创建一个可运行的 JAR 文件,其中嵌入了一个应用程序服务器,例如 Tomcat。 打包在 Docker 容器中的相同嵌入式 Tomcat JAR 文件将用于每个不同的部署环境。 由于每个环境都部署了相同的编译代码和应用服务器,最终实现了环境间的对等。
    此外,Spring Profiles 提供了一种简单的方法来定义和配置需要从一个环境更改到另一个环境的属性,从而允许开发人员解决不可避免地发生的环境之间的差异。

11. 日志作为事件流

    十二因素应用坚持将日志视为事件流。
    Spring Boot 使用的所有标准 Java 日志框架都将它们的数据写入事件流,该事件流被保存到运行 Docker 容器的 Kubernetes 节点上的公共目录中。然后这些日志文件很容易被 Kubernetes DaemonSets 使用,比如 FluentD 或 Logstash。这些 DaemonSet 然后将日志流式传输到 Elasticsearch 和 Logstash 等工具以供使用。
    只要您使用框架标准的 Java 日志框架,您就可以放心,在日志消耗方面,您拥有一个符合 12 因素标准的 Spring Boot 应用程序。

12. 管理进程管理

    应用通常需要运行管理进程,这些进程与处理客户端-服务器交互的请求-响应循环没有直接联系的。根据十二因素应用,不应将实现这些过程的代码放在单独的代码库中。管理进程应打包为标准的、受版本控制的构建的一部分,并且进程本身应在应用使用的相同运行时环境中执行。
    在云原生 Spring Boot 应用程序中添加对管理进程的支持非常容易。Spring Batch 项目可以轻松添加对运行一次并退出的作业的支持。 此外,任何 Git 存储库都可以配置为包含文件夹,这些文件夹允许添加可以在需要时在 REPL shell 中运行的脚本。
    云原生微服务的开发没有明确的标准,但十二要素应用方法很接近。如果您是一名 Java 开发人员并且想要创建 12 因素应用,Spring Boot 将帮助您的团队保持云原生合规性。

技术白皮书:现代企业架构设计

【注】本文节译自:APIs and microservices: How to create modern enterprise architectures (bitpipe.com)

    创建和发展现代化的企业架构并非易事:这意味着打破单一的、集中的系统,转而使用 API 和微服务等工具支持更多云功能和自适应环境。在本指南中,我们研究了这些类型的云连接架构的关键属性,并提供了有助于培养以 API 为中心的现代架构的实用建议。接下来,我们来探讨一下渐进式 Web 应用程序的出现。
    云应用程序被认为是一种易于部署、修改、扩展和计量的服务。这为现代企业架构和应用程序设计须如何发展提供了线索。这就是为什么,以及未来是什么样子。
    云服务本身建立在高度分布式的基础架构上,旨在对故障具有弹性,并且在不影响用户的情况下轻松移动和调整大小。使用应用程序接口或 API 访问和控制抽象服务,将用户与实现细节完全隔离。用户几乎不知道或不关心服务在哪里运行或在什么类型的系统上运行。这些核心属性巩固了云服务相对于传统单体软件的众多优势。
    然而,这些相同的特性可以而且应该应用于构建在一个或多个云上的企业应用程序。事实上,使用共享、按需、可伸缩的云服务的细粒度微服务设计是任何现代企业架构的虚拟需求,这些架构期望满足数字业务的需求,服务于数百万移动客户、智能机器和连接的传感器。

互联的数字企业

    企业架构必须改变的原因是高速连接和数十年来计算能力指数级摩尔定律改进的融合。这使得廉价智能手机市场趋于饱和,公用事业规模的 IT 服务提供商得以创建云服务。这些技术共同推动了业务的巨大变化。无论您将其称为“新连接经济学 ”(Gartner) 还是“无界企业 ”(AT&T Bell Labs),它都意味着企业以及随之而来的 IT 系统和应用程序将越来越多地与人交互,还将以自动化业务流程和智能设备的形式与设备、虚拟对象和其他软件交互。这是一种交互的爆炸式增长,Gartner 称之为数字网格。
    这对企业架构的影响变得更像是大型云服务——想想谷歌、Facebook 和 AWS——而不是使用单体的、集中的系统来处理不断增长和越来越不可预测的工作负载。事实上,随着双模 IT、DevOps 和敏捷开发等概念的引入以加快数字业务创新的步伐,其影响将远远超出企业架构,深入到 IT 如何开展业务的核心。但是我们这里的重点是体系结构框架。

处理“连通性”

    但是,如果组织选择实施它,演进的现代企业架构将类似于云。应用程序是否最终运行在 AWS 和 Azure 等共享的公共服务上;基于 Azure Stack、OpenStack 或 vCloud 等软件构建的私有基础设施;或者两者结合,架构必须假定共享的可用性,即使仅在组织内部,计量软件服务也可以立即实例化、修改、扩展和互连。随着组织构建的数字服务看起来更像 Facebook 和 Uber,应用架构必须类似于云原生服务,而不是隔离在单个盒子上的单体系统。
    现代架构应具有以下关键属性:

  • 将客户端接口与业务服务分离:应用程序将采用移动和浏览器设计范式,客户端专门用于 UI 和后端服务的业务处理。
  • 天然分布式:后端应用程序将能够运行多个实例,提供弹性和可扩展性,同时支持持续、敏捷开发流程所需的无中断更新。
  • 使用微服务:后端服务将针对特定功能而设计。它还可以在许多消费者之间共享,并可以轻松链接到特定应用程序的服务链中。将微服务视为用于构建任意复杂功能的构件。服务可以在自己的 VM 中隔离运行,也可以作为共享操作系统实例的容器运行。它们还具有固有的自计量功能,以支持基于消费的计费、细粒度的性能跟踪和自动扩展。
  • 异步服务间通信:服务将使用消息总线交换信息,而不是到网络套接字和文件共享的持久连接。
  • 丰富的服务组合:服务将公开元数据,允许它们作为广泛服务组合的一部分进行管理、使用和编排,包括移动和物联网应用后端、数据存储和分析、消息传递、监控和安全。
  • 应用程序模板和设计模式库:
        该组合是模板的基础,这些模板将服务组合在一起,以解决各种应用开发需求和设计模式,比如 Azure 提供的。开发人员库还包括标准数据模型,用于选择合适的数据服务,如对象存储、NoSQL、SQL、大数据,例如 Hadoop 和 Spark;以及满足特定需求的数据转换管道。
  • 以 API 为中心:API 是主要的,通常也是唯一的服务接口。 客户端访问通常是无状态的,但任何状态都通过消息总线和后端数据服务处理,并且只有最少的客户端支持。
  • 自动化基础设施:服务链可以从用于部署、扩展、移动和停用云实例的基础设施模板中实例化。 服务计量和仪表用于对资源使用情况发出警报、活动、错误状态、并触发自动修复,例如缩放、重启和人工通知。
  • 细粒度的安全性:对单个服务的访问通过基于角色的访问控制列表进行控制,策略定义为应用程序模板的一部分。 用户身份和角色被集中管理,并可能与来自业务合作伙伴或公共在线服务的外部身份管理系统联合。

    待办事项清单

        拥有正确的企业架构可能是未来数字业务计划成败的关键。 对于 CIO 和 IT 高管来说,这意味着架构应该是执行层的优先级,它是通过 IT、应用程序开发人员和业务线经理之间的密切协作开发。 对于 IT 经理和技术专业人士来说,企业架构的重要性需要一个由多学科专家组成的专门团队——例如 IT 运营、AppDev、DevOps、云运营和数据科学家等——他们的重点是开发、改进、更新和实施架构。
        不断发展的企业架构是不断发展的 IT 的一部分,它必须专注于灵活的服务创新、开发和实施,以响应动态的数字业务需求。因此,它可能会伴随 IT 内部的结构和文化变化,例如双模式和 DevOps 组织以及持续交付流程。对于 IT 专业人员来说,这是最具挑战性但又最激动人心的时刻之一。

    在网页和原生应用之间架起桥梁

        移动应用和网站在用户体验方面历来采用不同的模式。让用户访问网站比安装应用程序要容易得多。但移动应用往往会促进更具吸引力的用户体验。一种全新的全渠道应用交付模式,称为渐进式 Web 应用,有望提供两全其美的服务,并且是旧金山 O’Reilly Fluent 会议的热门话题。
        谷歌 Chrome 团队的一名资深软件工程师 亚历克斯·拉塞尔(Alex Russell)表示,他们之所以选择“渐进式 Web 应用”这个词,是因为它们可以在标签中开始生活,并逐渐变得像应用程序一样。有几个因素正在推动这一趋势,包括更好的缓存技术和使 Web 应用的行为更像移动应用的新技术。
        一些先驱企业已经证明了使用新模式有利于增加用户访问量和在网站上花费的时间。Flipkart 开始实施渐进式应用,并且发现用户花在新网站上的时间增加了三倍,每周访问者增长 40%。他们还发现 63% 转化率来自主界面访问者,他们甚至还没有发布推送通知。

    解决分布式问题

        “我认为分发是软件中最困难的问题,”Russell 说。在早期,用户必须从软盘安装应用程序。现在,让用户安装应用程序要容易得多,但要让用户主屏上花费更多的精力和空间,仍然有很多阻力。网络是最便捷的分发平台,但令人惊讶的是,我们还没有转向通过 URL 分发移动应用。Web 应用程序可以更定期地更新,也可以通过单击链接进行更新,开发无需通过应用商店的审批流程。
        但根据 comScore Inc. 的研究,用户往往会将大约 87% 的时间花在移动应用上,而花在智能手机上的移动 Web 应用上的时间只占 13%。另一方面,大多数用户将大部分时间花在顶级应用上,而其他人则处于休眠状态。由于这些趋势,企业最终会花费大量资金让用户安装其软件的移动应用版本。许多这些应用最终成为永远不会被使用的僵尸应用。这需要付出很大代价,因为其中许多应用都无法进入顶层。
        与此同时,移动网站也吸引了许多未安装该应用的独立访问者。这对于应用使用较少的企业(例如零售商)很重要。用户平均每月使用 27 个应用,但访问超过 100 个移动网站。Russell 表示,用户对下载原生移动应用的空间、带宽和时间感到焦虑。

    超越技术

        一些处理密集型应用可能会像原生移动一样表现得更好。但 Russell 表示,他相信移动网络平台对于当今的大多数应用来说已经足够了。他说,阻碍移动网络应用使用的三个主要因素是缺少主屏、缺少推送通知托盘访问和缺少离线访问。

    主屏访问

        Chrome 团队最近发布了 Web 应用清单(Web App Manifest)规范。早期版本可在所有 Android 平台上运行。这提供了一个框架,用于告诉移动浏览器某个特定链接实际上是一个移动应用。 这样可以更轻松地将站点作为单独的窗口重新启动,该窗口的外观和行为类似于其他本机应用程序。
        开发人员只需在站点上包含一个清单文件,其中包含一个指向图标和应用名称的链接。Russell 说这是必要的,因为 Web 还没有应用结构的概念。直觉上,人们知道博客与博客中的条目是不同的。清单提供了一种向浏览器显式声明这种区别的方法。

    突破新极限

        去年,Chrome 团队在 Chrome 桌面版和 Android 版上推出了推送通知。 这使得 Web 应用程序可以更轻松地将更新定向到推送通知托盘中。 此功能也可用于三星和 Firefox 浏览器,并生成行为与本机应用程序非常相似的通知——即使在浏览器关闭时也是如此。 用户必须提供从特定站点接收通知的权限。
        这种策略对零售商的网站很有效,例如,他们可能想向访问商店的用户推出优惠券。它将允许用户接收这些更新,而无需在主屏上安装任何应用程序。零售商 Beyond The Rack 报告称,其 50% 的访客来自发布推送通知。他们还发现在网站上花费的时间和转化率有所增加。

    使用 Service worker 进行更好的缓存

        最后一个阈值是支持有效的离线功能。谷歌多年来一直致力于解决这个问题。最初,Google Gears 允许通过一组狭窄的方式来考虑打造离线体验。应用程序缓存与现在被纳入 HTML5 规范的设计相同。
        谷歌现在引入了服务工作者的概念。这种方法允许开发人员指定服务工作者在移动设备离线或在线时的行为方式。Russell 说离线只是网络连接不稳定的一个特例。这种方法允许应用程序提供令人满意的用户体验,而不管其连通性如何。应用程序外壳可以在重复访问时立即缓存和加载。“现在,有了 Service Worker,你可以在没有 DNS、http 或 TLS 辅助的情况下将内容投放到屏幕上,”Russell 说。个人、网络广播、播客、视频、虚拟贸易展览、研究报告等——利用技术提供商的丰富研发资源来应对市场趋势、挑战和解决方案。我们的现场活动和虚拟研讨会为您能够就您每天面临的问题和挑战获得中立的供应商评论、专家评论和建议。我们的社交社区 IT 知识交流使您可以与同行和专家实时共享现实世界的信息。

面向资源的架构(ROA)概述

【注】本文译自: Overview of Resource-Oriented Architectures (ROA) | Developer.com

了解面向资源的架构 (ROA)、其价值以及最佳实践。

  面向服务的架构 (Service-Oriented Architecture,SOA) 和面向资源的架构 (Resource-Oriented Architecture,ROA) 是用于实现健壮、可扩展的分布式应用程序架构的架构设计模式。分布式架构由通过定义良好的接口在网络上使用的组件组成。在 ROA 中,这些组件被称为资源,而在 SOA 中,它们被称为服务。本文概述了面向资源的体系结构。

什么是面向资源的架构 (ROA)?

  面向资源的架构 (ROA) 是一种架构风格,它扩展了 REST 架构风格,并提供了更广泛、可扩展、灵活且与传输无关的架构。面向资源的架构 (ROA) 范式建立在资源的概念之上。资源是一个独立的、可识别的实体,其状态可以被分配一个统一的资源定位符 (URI)。服务代表所请求操作的执行,而资源代表可通过一致的标准化接口进行管理的分布式组件。
  面向资源架构的特征之一是与传输无关。因此,必须有特定的机制将面向资源的服务暴露给外部世界。当消费者请求统一资源定位器(Uniform Resource Locator,URL)并指定访问方法(例如,GET、PUT、POST 和 DELETE)时,该 URL 将转换为相对的内部 URI。访问方法被转化为动作。
  面向资源的架构仅围绕四个概念建模:

  • 资源
  • URI
  • 表述
  • 链接和连通性

  以下是面向资源架构的四个属性:

  • 可寻址性
  • 无状态性
  • 连通性
  • 统一的接口

面向资源的架构:资源

  资源是 ROA 的基石;资源是信息的逻辑表示。例如,学生是数据点的抽象集合,可以用多种方式表示,包括 XHTML、JSON 和 XML。 资源名称包括以下内容:

  • 资源的类型
  • 资源标识符
  • 父元素的资源名
  • API 服务的名称

  资源是 REST 或 RESTful 架构中最重要的信息抽象。术语“资源”是指任何可识别的信息。这些信息可以是文档、计算机、汽车、临时服务(例如“俄亥俄州今天的天气”)、其他资源的集合、个人、学生等。
  每个不可变资源表示都可以通过相对的统一资源指示符 (URI) 来标识,它可能包括到其他资源以及其他不可变资源的连接。请注意,一个资源也可以有多个 URI。
  每种资源应具有以下特征:

  • 是唯一的
  • 必须至少有一个表述
  • 具有属性,模式可以被访问并提供上下文

统一资源标识符(URI)

  统一资源标识符 (Uniform Resource Identifier,URI) 是包含资源名称和地址的字符序列,用于标识逻辑或物理资源。请注意,资源必须具有一个或多个 URI。 没有 URI,一条信息不被视为资源,因为它不能被引用或访问。 您可以使用 URI 来标识任何事物,例如现实世界的对象、网页、书籍等。
  下面是一个 URI 的例子:语法::示例:http://payroll/employee/1234 下表说明了如何指定资源的相对 URI:

  • 动作
    相对 URI
    目的
  • Read
    /student/3
    读取 ID 是 3 的学生记录
  • Delete
    /student/4
    删除 ID 是 4 的学生记录

面向资源架构ROA的特性

  以下是面向资源的架构的四个基本属性:

可寻址性

  可寻址性是面向资源架构的一个基本特征。如果应用程序将其数据集的感兴趣方面发布为服务端点,则可以认为该应用程序是可寻址的。这些服务可以反过来用于处理应用程序的数据。由于 ROA 中的资源使用 URI 公开,因此应用程序应使用 URI 公开其数据。

无状态

  无状态是面向资源架构的另一个特征,这意味着该架构中的每个 HTTP 请求都是独立发生的。换句话说,当客户端向服务器请求资源时,客户端必须提供服务器请求成功所需的所有信息。服务器从不存储来自先前请求的信息,也就是说,服务器上不存储状态信息。如果服务器需要来自较早请求的信息来处理请求,则客户端必须在另一个请求中再次发送该信息。

连通性

  在面向资源的架构中,表述是超媒体:包含数据和其他资源链接的文档。RESTful Web 服务遵循超媒体作为应用程序状态引擎 (Hypermedia As the Engine Of Application State, HATEOS) 原则。这是数据格式影响应用程序中转换状态的原则。到其他资源的链接嵌入在响应中,但对于相同的资源,它们可能会根据其当前状态而有所不同。
  网络最重要的特征之一是它的互连性。也就是说,互联网上的几乎所有信息都通过超链接链接在一起。超链接可用于将互联网上可访问的任何资源连接到另一个资源。基于 ROA 构建的应用程序应将其所有资源相互链接,反之亦然。当我们为资源选择合适的表述时,我们可以在应用程序中实现连通性。

统一接口

  您应该有一组定义良好的方法来操作应用程序中的资源。例如,HTTP 提供了以下您可能通常需要在任何应用程序中执行的常见操作:

HTTP GET – 获取一个资源

HTTP POST – 创建新资源

HTTP PUT – 修改一个存在的资源

HTTP DELETE – 删除一个存在的资源

HEAD 和 OPTIONS HTTP 方法

  下面是您应该了解的另外两个重要的 HTTP 方法:

HTTP HEAD – 用于检索资源的元数据表述

HTTP OPTIONS – 用于检查特定资源支持哪些 HTTP 方法

总结

  面向资源的体系结构是无状态的,并以资源为中心。URI 用于标识每个资源。您总是可以在计算机上同时拥有同一资源的多个副本。一个资源也可以有多个 URI。

软件库与框架的区别

【注】本文译自:https://www.theserverside.com/tip/Library-vs-framework-How-these-software-artifacts-differ

  库与框架:这两个软件构件的区别库(Libraries)是提供特定功能(如建立网络连接)的低级组件。框架(Framework)是已知的编程环境,比如 Spring Boot。
  当软件主管开始构建新的企业应用程序时,他们必须决定要使用哪一组库和框架。 这引出了一个明显的问题:软件库和框架之间有什么区别?
  库和软件框架都有助于应用程序的开发。但是,两者之间的主要区别在于它们的任务范围,以及它们减轻开发人员编写代码负担的方式。
  库提供了开发人员可以调用来执行特定功能的组件、类和方法。相比之下,框架提供的代码已经执行了通常需要的功能,并在需要定制功能时调用开发人员提供的代码。

库与框架

  库是一组相关的低级组件,开发人员调用这些组件来实现特定结果。常用库函数包括日期格式化和建立网络连接。
  框架处理更高级别的问题。框架提供了一个既定的编程环境,它本身建立在低级库之上。
  例如,框架可能会处理如何最好地将应用程序中的所有对象映射到相关数据库中的表中。它还可以处理如何向最终用户提供丰富的、基于 Web 的体验。

软件库示例

  一个库的例子是 Java 日期和时间 API。它是一组定义属性和方法的类和接口,开发人员可以使用这些属性和方法来格式化日期、执行时区转换并提供全局日历支持。Java 开发人员在需要时实例化 Date 和 Time 类,并以他们认为合适的任何方式调用库的方法。
  另一个 Java 库示例是流行的 java.net 网络 I/O 包。该库由数十个类和接口组成,开发人员使用这些类和接口来打开网络端口、处理传入连接并将数据发送到互连的客户端。
  只需要使用 java.net 包,软件开发人员就可以实现处理基于 REST 的 Web 服务或通过 HTTP 协议的基于 HTML 的请求-响应循环所需的所有必要逻辑。java.net 库提供了一组低级 API,任何开发人员都可以使用这些 API 来开发通过网络进行通信的应用程序。

流行的 Java 库

  其他流行的 Java 库,包括已经利用了 Java 框架的 Spring Boot、JHipster 或 Vaadin 等 的库,包括:

  • Apache Commons Math
  • BouncyCastle for cryptography
  • Java Advanced Imaging
  • Java Speech
  • Java 3D
  • JavaMail
  • Joda-Time
  • Apache Collections
  • Jackson for JSON and XML
  • Java Networking

软件框架的作用

  企业项目通常需要开发人员提供一组 RESTful API,以便外部客户端与在线应用程序集成。然而,许多开发人员不仅解决了如何使用低级 java.net 库来处理 RESTful API 调用的问题,而且还将他们的工作作为开源项目来分享。这是软件框架的本质。它是一个现有项目,解决了一个常见且具有挑战性的问题,开发人员可以在自己的项目中使用它。

  框架是解决常见且具有挑战性的问题的现有项目,开发人员可以在自己的项目中使用它。

  在给定的问题域中,通常有许多框架可供选择。在 Java 生态系统中,有许多流行的框架使用标准的 Java 和 Jakarta EE 库来解决如何最好地处理基于 REST 的请求-响应周期的问题,包括:

  • Spring Boot
  • Jersey
  • RESTEasy
  • Restlet
  • Micronaut
  • Apache CFX
  • JAX-RS

框架有观点

  将框架与库区分开来的另一个关键特征是后者通常包括关于如何解决给定问题、问题的范围以及如何以最有效和最有效的方式解决框架目标的观点。
  框架将在各种非功能性需求上展开竞争,例如易用性、性能、可插入性和兼容性。

框架和控制反转

  最后,库和框架之间的一个关键区别因素是两者之间的相对控制反转 (IoC)。IoC 通常被称为好莱坞原则。与库不同,框架对开发人员编写的代码采取“不要打电话给我们,我们会打电话给你”的方法。
  要使用库开发应用程序,开发人员必须实例化库组件并调用其中存在的类和接口的方法。例如,如果开发人员想要使用 java.net 库来创建他们自己的 RESTful 应用程序,他们将需要调用各种 API 来打开端口、处理 HTTP 连接、将数据格式化为 XML 或 JSON 表示形式来回通信,以及当客户端发起请求时发起一个请求。
  另一方面,框架负责支持项目核心功能所需的所有底层管道。只有在需要时,框架才会调用开发人员提供的代码。

IoC 和 Spring Boot

  用 Spring Boot 编写的 RESTful Web 服务很好地体现了 IoC 的好莱坞原则。
  使用 Spring Boot RESTful Web 服务,开发人员只需编写在发生基于 HTTP 的 GET 调用时要执行的逻辑。当 GET 调用发生时,Spring Boot 框架会处理它,解释它,将数据交换格式转换为 JSON 或 XML,然后将 RESTful 请求路由到开发人员的业务逻辑。
  开发人员只需要编写业务逻辑。由框架决定何时调用业务逻辑。
  IoC 框架在 Java 中很常见。以下是十个常见的例子。

  • Hibernate
  • Struts
  • JavaServer Faces
  • Play for Scala
  • Vaadin
  • JHipster
  • JRuby
  • JUnit
  • Quarkus
  • Grails

框架和库一起使用

  虽然框架和库有不同的功能,但它们都可以帮助开发者完成更多工作。当许多常见的编程挑战已经被解决并以许可的开源项目的形式被共享时,没有软件专业人员愿意浪费时间重复发明轮子。
  每当您启动一个新的软件开发项目时,选择一个已被证明和建立的软件开发框架非常重要。同时,与您的个人开发和设计理念保持一致。在极少数情况下,特定的情况超出了所选框架的范围,标准库总是在那里帮助您的开发人员弥合差距。

面向服务体系结构的领域驱动设计

【注】本文译自:https://www.thoughtworks.com/insights/blog/domain-driven-design-services-architecture
  这篇文章是关于软件设计的选择。特别是大型系统,这些系统可能会以服务端点的形式分为多个可部署的对象。我不会特别谈论服务端点设计,但是我想讨论创建多个服务应用的构思阶段。

  当我们面对复杂的问题时,我们通常试图理解复杂的单个部分。通过分解问题,我们将其变成为更易于理解和管理的部分。
  正如在许多产品/项目管理周期中所描述的,对于现实生活中的问题,这通常是由本能驱动的。 我们不会使用公式来了解去一个需要签证的国家需要做什么。我们知道我们需要签证才能旅行,我们慢慢掌握需要的文件文件,需要填写哪些表格以及如何填写这些表格。当我们执行其中一个步骤时,我们不会将流程的所有细节都牢记在心,而只是要做手头的任务。这与要完成的任务的大小有关。潜在的真实标准是关于时间或进度、我们的执行力、我们的认知能力及其与任务熟悉程度的关系,甚至可能是执行这些任务的物理位置( 领事馆与 Photoshop 等)。
  在软件开发领域并没有什么不同。多年来,瀑布式的配方已被应用到软件开发过程中,最终,主要是基于启发式和基于经验的评估技术(计划扑克、T – 恤尺寸)和敏捷过程。在现实生活中,我们试着不去详述整个过程,而是通过观察我们的最新表现来尝试和理解整个旅程。
  同样适用于我们针对问题建模的软件。我们开始将它们分解为不同的应用的是方便管理单个应用,以更少的依赖关系更快地开发和部署,最后带来更多的技术选择自由。我们意识到,我们无法制定出适合所有人的完整流程。我们着眼于各个部分,并认识到我们在设计模式或技术方面的集体经验,并尝试应用其中最好的选择。
  理解和解决复杂性的一个有趣的软件设计技术是领域驱动设计(DDD)。领域驱动设计提倡基于与我们的用例相关的业务现实进行建模。由于 DDD 方法现在已经过时,而且宣传水平正在下降,我们许多人都忘记了 DDD 方法确实有助于理解手头的问题,并朝着对解决方案的普遍理解来设计软件。在构建应用DDD 会以域和子域的形式讨论的问题。它将问题的独立步骤/领域描述为边界上下文,强调使用一种通用语言来讨论这些,并添加了许多技术概念,如实体、值对象和聚合根规则以支持实现。有时,这些技术规则被视为是实施 DDD 的硬障碍,但最终,人们往往会忘记重要的部分是根据业务问题组织代码工件,并使用与(1)相同的通用语言。

设计为服务应用的边界上下文

  我想谈论的架构风格与微服务非常相似。它是关于将单体应用分离为多个独立的服务应用,或者从一开始就在边界上下文(DDD概念)的帮助下单独开发它们。
  有许多资源都强调了微服务叙述中更细粒度的服务的优点。越来越多的文章、博客和其他内容是关于陷阱和在向细粒度服务过渡之前或过渡期间应该拥有的安全网的。我将尽量不重复微服务或其他支持元素的好处,这些是迁移到这样的体系结构中所需要。我不想强调结果服务的“小型”性质,而是想强调如何通过应用领域驱动的设计概念来更好地分离这些服务。
  让我们使用一个真实的示例来实现我们的想法-借记卡/信用卡获取域。这个领域可以(不幸的是,很多时候都是这样)作为一组单体应用来实现。我们拥有多个应用的唯一原因是由于不同的应用中的存在严格的技术限制(例如希望执行批处理)。

  我所看到的大多数成功的架构都认识到,通过数据库进行集成是一种糟糕的实践,因为它使技术应用和业务职责之间的界限变得模糊,使业务逻辑泄漏到数据库中,并通过添加更多的应用服务器来阻止水平扩展。因此,以单体应用的的服务集成的形式发展到更好的架构。

  现在,应用之间的界限更加清晰了。但是,您可以看到,仍然存在隐藏的数据库交互,这一次是在各个应用内部发生的。我称它们为隐藏的,因为通常一开始它们通常很难被注意到。随着时间的流逝,代码的纠缠将使原先分离的业务流程人为地关联起来,并在业务开发中引入更多的摩擦,因为这种共置托管需要联合部署单独的功能,这可能会减慢速度。
  如果您幸运地有一个领域模型来指导的话,则领域建模可帮助您识别和分离复杂的实现。如果您还没有现有应用的域模型(在大多数情况下通常是这样),则无需遍历代码以了解不同的职责,而是构建域模型并将功能映射到手边的应用可能是一个更好的方法。这既能节省时间,又能避免被细节淹没的风险。此外,如果业务与开发团队之间存在差距(这可能是域模型最初不存在的主要原因),那么讨论域模型并映射到现有应用的功能将有助于缩小这一差距。

  我们设计演进的下一步是将域边界分离反映到我们的架构以及边界上下文中。一个域具有多个边界上下文意味着在同一域中可以有多个服务应用运行。有了适当的域模型,潜在的分离点就更可见了,这使我们可以从潜在的更细粒度的应用中受益(诸如单独发行和版本控制的好处,具有更多功能驱动的纯服务端点的潜力等,其中大多数已经在微服务文章中进行了讨论)。尽管许多微服务讨论都围绕技术不可知论和开发规范(避免/破坏整体),但对于我们大多数人所从事的应用而言,非常有价值的一项是领域和设计方面。一旦过渡到微服务架构(借助域模型),DDD 和更细粒度的服务便可以协同工作、相互支持。

  这还将为团队提供一定程度的独立性,更完善的服务功能以及更分离的交互,如许多微服务文章所述.
  同样,从我们的示例信用卡付款获取域中可以看出,这并不是我们的服务可以做到的最细粒度的分离。相反,这是在我们的领域知识所指导下最有意义的分离。重点不是规模,而是业务能力。我相信这是“正确的 SOA”,正如许多圈子所说的那样。

ELK 教程 – 高效发现、分析和可视化你的数据

【注】本文译自:https://www.edureka.co/blog/elk-stack-tutorial/

  随着越来越多的 IT 基础设施转身云计算,对公共云安全工具和日志分析平台的需求也在迅速增加。不管组织的规模有多大,每天都会生成大量的数据。这些数据中有相当一部分是由公司的 Web 服务器日志组成的。日志是最重要的信息来源之一, 但往往被忽视。每个日志文件都包含一些宝贵的信息,这些信息大多是非结构化的,没有任何意义。如果不对此日志数据进行详尽的分析,那么企业可能会忽视其周围的机会和威胁。这是日志分析工具非常有用的地方。ELK Stack 或 Elastic Stack 是完整的日志分析解决方案,它有助于深入搜索、分析和可视化不同机器生成的日志。通过本教程,我将为您提供相关见解。
  首先,让我们列出要讨论的主题:

  • 什么是 ELK Stack?
  • ELK Stack 架构
  • ELK Stack 安装
  • Elasticsearch 教程
  • Logstash 教程
  • Kibana 教程

  本教程将帮助您一起理解 Elasticsearch、Logstash 和 Kibana 的基础知识,并帮助您在 ELK Stack 中打下坚实的基础。
  首先让我们来了解什么是 ELK Stack。

什么是 ELK Stack?


  众所周知的 ELK Stack 最近被更名为 Elastic Stack。它是三个开源工具的强大集合:Elasticsearch、Logstash 和 Kibana。
  这三种不同的产品最常一起用于不同 IT 环境中的日志分析。使用 ELK Stack,您可以执行集中式日志记录,这有助于识别 Web 服务器或应用程序的问题。它使您可以在一个地方搜索所有日志,并通过在特定时间范围内关联多个服务器的日志来识别跨多个服务器的问题。
  现在让我们详细讨论这些工具。

Logstash

Logstash 是数据收集管道工具。它是 ELK Stack 的第一个组件,它收集数据输入并将其输入到 Elasticsearch。它可以一次从不同来源收集各种类型的数据,并立即提供以备将来使用。

Elasticsearch

Elasticsearch 是基于 Lucene 搜索引擎的 NoSQL 数据库,并使用 RESTful API 构建。它是一个高度灵活的分布式搜索和分析引擎。此外,它通过水平可伸缩性提供了简单的部署、最大的可靠性和易于管理的功能。它提供高级查询以执行详细分析,并集中存储所有数据以快速搜索文档。

Kibana

Kibana 是一种数据可视化工具。它用于可视化 Elasticsearch 文档,并帮助开发人员立即对其进行深入了解。Kibana 仪表板提供了各种交互式图表、地理空间数据、时间线和图表,以可视化使用 Elasticsearch 完成的复杂查询。使用 Kibana,您可以根据自己的特定需求创建和保存自定义图形。
  下一部分将讨论 ELK Stack 架构以及其中的数据流向。

ELK Stack 架构

  以下是 ELK Stack 的架构,显示了 ELK 中日志流的正确顺序。在此,Logstash 会根据提供的过滤条件来收集和处理从各种来源生成的日志。然后,Logstash 将这些日志通过管道传输到 Elasticsearch,然后 Elasticsearch 分析和搜索数据。最后,使用 Kibana,可以根据要求对日志进行可视化和管理。

ELK Stack 安装

第 I 步:打开 https://www.elastic.co/downloads

第 II 步:选择并下载 Elasticsearch。
第 III 步:选择并下载 Kibana。
第 IV 步:选择并下载 Logstash。
第 V 步:解压缩所有三个文件以获取对应文件夹的文件。

安装 Elasticsearch

第 VI 步:现在打开 elasticsearch 文件夹并转到 bin 文件夹
第 VII 步:双击 elasticsearch.bat 文件以启动 elasticsearch 服务器。

第 VIII 步:等待 elasticsearch 服务器启动。
第 IX 步:要检查服务器是否已启动,请转到浏览器并键入 localhost:9200

安装 Kibana

第 X 步:现在打开 kibana 文件夹 并转到 bin 文件夹
第 XI 步:双击 kibana.bat 文件以启动 kibana 服务器。

第 XII 步:等待 kibana 服务器启动。
第 XIII 步:要检查服务器是否已启动,请转到浏览器并键入 localhost:5601

安装 Logstash

第 XIV 步:现在打开 logstash 文件夹
第 XV 步:要测试您的 logstash 安装,请打开命令提示符,然后转到 logstash 文件夹。现在输入:

binlogstash -e 'input { stdin { } } output { stdout {} }'

第 XVI 步:等待,直到命令提示符上显示“ Pipeline main started”出现在命令提示符下。

第 XVII 步:现在,在命令提示符下输入一条消息,然后按 Enter 键。
第 XVIII 步:Logstash 将时间戳和 IP 地址信息附加到消息中,并将其显示在命令提示符下。
  既然我们完成了安装,那么现在让我们更深入地研究这些工具。让我们从 Elasticsearch 开始。

Elasticsearch

  如前所述,Elasticsearch 是一个高度可扩展的搜索引擎,它运行在基于 Java 的 Lucene 引擎之上。它基本上是一个 NoSQL 数据库。这意味着它将以非结构化格式存储数据,并且无法对任何类型的交易执行 SQL 查询。换句话说,它将数据存储在文档中,而不是表和模式中。为了获得更好的图像,请检查下表,该表显示了与数据库相比在 Elasticsearch 中的内容。

  现在让我们熟悉 Elasticsearch 的基本概念。
使用Elasticsearch时,需要遵循三个主要步骤:

  1. 索引
  2. 映射
  3. 搜索

  让我们一个一个详细地谈谈。

索引

  索引编制是添加数据 Elasticsearch 的过程。之所以称为“索引”,是因为将数据输入到 Elasticsearch 中后,它将被放入 Apache Lucene 索引中。然后,Elasticsearch 使用这些 Lucene 索引来存储和检索数据。索引编制与 CRUD 操作的创建和更新过程相似。   索引方案由 名称/类型/id 组成,其中名称和类型是必填字段。 如果您不提供任何 ID,Elasticsearch 将自己提供一个 ID。 然后,将整个查询附加到 HTTP PUT 请求中,最终 URL 如下:PUT name/type/id 与 HTTP 有效负载一起,还将发送包含字段和值的 JSON 文档。
  以下是创建一个美国客户的文档的示例,该文档及其字段中的详细信息。

PUT /customer/US/1 
{
    "ID": 101,
    "FName": "James",
    "LName": "Butt",
    "Email": "jbutt@gmail.com",
    "City": "New Orleans",
    "Type": "VIP"
}

  它会给你以下输出:

  这里显示文档已创建并添加到索引中。
  现在,如果您尝试在不更改标识的情况下更改字段详细信息,Elasticsearch 将使用当前详细信息覆盖现有文档。

PUT /customer/US/1
{
    "ID": 101,
    "FName": "James",
    "LName": "Butt",
    "Email": "jbutt@yahoo.com",
    "City": "Los Angeles",
    "Type": "VVIP"
}


  这里显示文档已经更新了索引的新细节。

映射

  映射是设置索引模式的过程。通过映射,您可以告诉 Elasticsearch 你的模式中属性的数据类型。如果在预索引时未针对特定对象进行映射,则 Elasticsearch 将动态地将泛型类型添加到该字段。但是这些泛型类型是非常基本的,大多数时候都不能满足查询的期望。
  现在让我们尝试映射查询。

PUT /customer/
{
    "mappings": {
        "US": {
            "properties": {
                "ID": {
                    "type": "long"
                },
                "FName": {
                    "type": "text"
                },
                "LName": {
                    "type": "text"
                },
                "Email": {
                    "type": "text"
                },
                "City": {
                    "type": "text"
                },
                "Type": {
                    "type": "text"
                }
            }
        }
    }
}


  当您执行查询时,您将获得这种类型的输出。

搜索

  具有特定索引和类型的一般搜索查询如下:

POST index/type/_search

  现在,让我们尝试搜索“customer”索引中存在的所有客户的详细信息。

POST /customer/US/_search

  当您执行此查询时,将生成以下结果:

  但是,当您要搜索特定结果时,Elasticsearch 提供了三种方法:

使用查询

  使用查询,您可以搜索一些特定的文档或条目。例如,让我们对属于“ VVIP”类别的客户执行搜索查询。

POST /customer/US/_search
{
    "query": {
        "match": {
            "Type": "VVIP"
        }
    }
}

使用过滤器

  使用过滤器,您可以进一步缩小搜索范围。以下是搜索 ID 为“ 101”的 VVIP 客户的示例:

POST /customer/_search
{
    "query": {
        "match": {
            "Type": "VVIP"
        }
    },
    "post_filter": {
        "match": {
            "ID": 101
        }
    }
}

  如果执行此查询,则会得到以下结果:

使用聚合

  聚合是一个框架,可帮助通过搜索查询聚合数据。小型聚合可以结合在一起,以构建所提供数据的复杂摘要。让我们执行一个简单的汇总,以检查索引中有多少类型的客户:

POST /customer/_search
{
    "size": 0,
    "aggs": {
        "Cust_Types": {
            "terms": {
                "field": "Type.keyword"
            }
        }
    }
}


  现在让我们看看如何从索引中检索数据集。

获取数据

  要检查索引中包含的文档列表,您只需要发送以下格式的 HTTP GET 请求:

GET index/type/id

  让我们尝试检索“ id”等于 2 的客户的详细信息:

GET /customer/US/2

  成功执行后,它将为您提供以下类型的结果。

  使用 Elasticsearch,您不仅可以浏览数据,还可以删除或删除文档。

删除数据

  使用删除约定,您可以轻松地从索引中删除不需要的数据并释放内存空间。要删除任何文档,您需要以以下格式发送 HTTP DELETE 请求:

DELETE index/type/id.

  现在让我们尝试删除 ID 为 2 的客户的详细信息。

DELETE /customer/US/2

  执行此查询时,您将获得以下类型的结果。

  至此,我们讲解了使用 Elasticsearch 的 CRUD 操作的基础知识,了解这些基本操作将帮助您执行不同类型的搜索。
  现在让我们开始学习 ELK Stack 的下一个工具 Logstash。

Logstash

  正如我已经讨论的那样,Logstash 是一种管道工具,通常用于收集和转发日志或事件。它是一个开源数据收集引擎,可以动态集成来自各种来源的数据并将其标准化到指定的目标位置。

  使用多个输入,过滤器和输出插件,Logstash 可以轻松转换各种事件。至少,Logstash 需要在其配置文件中指定的输入和输出插件来执行转换。以下是 Logstash 配置文件的结构:

input {
    ...
}

filter {
    ...
}

output {
    ...
}

  如您所见,整个配置文件分为三个部分,每个部分都包含一个或多个插件的配置选项。这三个部分是:

  1. input(输入)
  2. filter (过滤)
  3. output (输出)

  您也可以在配置文件中应用多个过滤器。在这种情况下,其应用程序顺序将与配置文件中的规范顺序相同。
  现在,让我们尝试配置 CSV 文件格式的美国客户数据集文件。

    file {
        path => "E:/ELK/data/US_Customer_List.csv"
        start_position => "beginning"
        sincedb_path => "/dev/null"
    }
}
filter {
    csv {
        separator => ","
        columns => ["Cust_ID", "Cust_Fname", "Cust_Lname", "Cust_Email", "Cust_City", "Cust_Type"]
    }
    mutate {
        convert => ["Cust_ID", "integer"]
    }
}
output {
    elasticsearch {
        hosts => "localhost"
        index => "customers"
        document_type => "US_Based_Cust"
    }
    stdout {}
}

  要将这个 CSV 文件数据插入 elasticsearch 中,您必须通知 Logstash 服务器。
  为此,请执行以下步骤:

  1. 打开命令提示符
  2. 进入 Logstash 的 bin 目录
  3. 输入:logstash –f X:/foldername/config_filename.config 然后按回车。一旦您的 logstash 服务器启动并运行,它将开始将文件中的数据传输到Elasticsearch 中。

      如果要检查是否成功插入了数据,请转到 Sense 插件并键入:GET /customers/
      它会为您提供已创建的文档数。
      现在,如果要可视化此数据,则必须使用 ELK Stack 的最后一个工具,即Kibana。因此,在本教程的下一部分中,我将讨论 Kibana 及其使用方式,以可视化您的数据。

    Kibana

      如前所述,Kibana 是一个开源的可视化和分析工具。它有助于可视化 Logstash 管道传输并存储到 Elasticsearch 中的数据。您可以使用 Kibana 来搜索,查看此存储的数据并与之交互,然后在各种图表,表格和地图中对其进行可视化。Kibana 的基于浏览器的界面简化了海量数据并反映了 Elasticsearch 查询中的实时变化。此外,您还可以轻松创建、自定义、保存和共享仪表板。
      一旦您了解了如何与 Elasticsearch 和 Logstash 一起使用,学习 Kibana 就不是什么大事了。在本教程的这一部分,我将向您介绍为了对数据进行分析所需的各种功能。

    管理页面

      在这里,您必须执行 Kibana 的运行时配置。 在此页面中,您需要指定一些搜索内容。请参见以下示例,在该示例中,我已经配置了“customer”索引的条目。

      如您所见,在“索引模式(Index Patterns)”字段中,您需要指定要使用的索引。确保在“时间过滤器字段名称”中将其选择为@timestamp。然后,您可以继续并单击创建以创建索引。如果索引创建成功,您将看到以下页面类型:

      在这里,您可以根据需要从下拉列表中选择不同的过滤器。此外,要释放内存,您还可以删除特定的索引。

    发现页面

      通过“发现”页面,您可以访问存在于每个与所选索引模式匹配的每个索引的文档。 您可以轻松地交互和浏览Kibana服务器上存在的所有数据。 此外,您可以查看文档中存在的数据并对其进行搜索查询。 下面你可以看到,我正在搜索来自“洛杉矶”的“ VIP”客户。

      因此,如您所见,我们只有一位来自洛杉矶的VIP客户。

    可视化页面

      可视化页面使您可以可视化以图表、条形图、饼图等形式显示在 Elasticsearch 索引中的数据。您甚至可以在此处构建仪表板,这些仪表板将基于 Elasticsearch查询显示相关的可视化效果。通常,使用一系列 Elasticsearch 聚合查询来提取和处理数据。当您转到“可视化”页面并搜索保存的可视化时,或者可以创建一个新的可视化。

      您可以以任何形式汇总数据。为了方便用户,提供了不同类型的可视化选项。

      让我向您展示如何根据用户类型可视化美国客户数据。

      要执行可视化,请按照以下步骤操作:

  4. 选择可视化类型。 [这里我用的是饼图]
  5. 在汇总字段中,从下拉列表中选择“术语(term)”。
  6. 在“字段(field)”中,选择要执行搜索的字段类型。
  7. 您还可以指定可视化的顺序和大小。
  8. 现在单击执行按钮以生成饼图。

    仪表盘页面

      “仪表板”页面显示已保存的可视化的集合。在这里,您可以添加新的可视化效果,也可以使用任何保存的可视化效果。

    Timelion 页面

      Timelion 是一个时间序列数据可视化工具,它将完全独立的数据源整合到一个界面中。 它由一种单行表达语言驱动,可用于检索时间序列数据,执行计算以简化复杂问题并可视化结果。

    开发工具页面

      Kibana 的“开发工具”页面包含诸如“ Beta Sense”插件之类的开发工具,可用于与 Elasticsearch 中存在的数据进行交互。它通常被称为 Kibana 的控制台。以下是一个示例,其中我使用了 Kibana 的 Sense 插件来搜索类型为“ US_based_cust”的“客户(customers)”索引:

      本文到此结束。现在,您可以使用 Logstash、Elasticsearch 和 Kibana 对任何数据执行各种搜索和分析。

Selenium WebDriver教程

【注】本文译自:
https://www.edureka.co/blog/selenium-tutorial

  在本教程中,我将向您介绍 Selenium Webdriver,它是当今市场上使用最广泛的自动化测试框架。它是开源的,可与所有著名的编程语言(如Java、Python、C#、Ruby、Perl等)一起使用,以实现浏览器活动的自动化。通过本文,我将告诉您开始使用 Selenium WebDriver 测试 Web 应用程序所需了解的所有信息。

  以下是本教程的主题:

  • 什么是 Selenium Webdriver?
  • Selenium 容易学吗?
  • Selenium 软件有什么作用?
  • Selenium 的基本知识是什么?
  • Selenium RC 的缺点和 WebDriver 的诞生
  • 什么是浏览器元素?
  • 定位网页上的浏览器元素
  • 浏览器元素上的操作

什么是 Selenium WebDriver?

  Selenium WebDriver 是一个基于 Web 的自动化测试框架,可以测试在各种Web浏览器和各种操作系统上启动的网页。实际上,您还可以自由使用各种编程语言(例如Java、Perl、Python、Ruby、C#、PHP 和 JavaScript)编写测试脚本。请注意,Mozilla Firefox 是 Selenium WebDriver 的默认浏览器。

  但是很多时候,刚入门的测试人员会想到这个疑问:

Selenium 好学吗?

  要用外行的话回答这个问题,我会说:”是的,是!”。Selenium 真的很容易学习和掌握,因为您只需要对任意一种常见的编程语言(例如 Java、C#、Python、Perl、Ruby、PHP)有基本的了解。预先掌握这些编程语言中的任何一种的都可有助于编写测试用例。但是,如果您没有,那就不要担心了。Selenium IDE 是一个可以有效使用的基于 GUI 的工具。

Selenium 软件有什么作用?

  以下是 Selenium 软件最吸引人的一些用途:

  1. 自动化测试: 在大型项目中,自动化测试会派上用场,在大型项目中,如果不是 Selenium,测试人员将必须手动测试每个创建的功能。使用 Selenium,所有手动任务都可以自动化,从而减轻了测试人员的负担和压力。
  2. 跨浏览器兼容性: Selenium 支持多种浏览器,例如:Chrome、Mozilla Firefox、Internet Explorer、Safari 和 Opera。
  3. 提高测试覆盖率: 通过自动化的测试,可以减少总体测试时间,从而为测试人员腾出时间来同时在不同的测试场景下执行更多测试。
  4. 减少测试执行时间: 由于 Selenium 支持并行测试执行,因此可以大大减少并行测试执行时间。
  5. 多操作系统支持: Selenium WebDriver 提供跨 Windows、Linux、UNIX、Mac 等多种操作系统的支持。使用 Selenium WebDriver,您可以在 Windows 操作系统上创建测试用例并在 Mac 操作系统上执行。

Selenium 的基本知识是什么?

  WebDriver 是 Selenium v2.0 的一部分。Selenium v1 仅由 IDE,RC 和 Grid 组成。但是 Selenium 项目的主要突破是开发 WebDriver 并将其作为 Selenium v2 的替代产品引入。但是,随着 Selenium v3 的发布,不推荐使用 RC,而将其迁移到旧版软件包中。 您仍然可以下载并使用 RC,但不要期望对其提供任何支持。

  简而言之,WebDriver相对于 RC 的优势是:

  • 支持更多的编程语言、操作系统和 Web 浏览器
  • 克服 Selenium 1 的局限性,例如文件上传、下载、弹出窗口和对话障碍
  • 与 RC 相比,命令更简单,API 更好
  • 支持批量测试,跨浏览器测试和数据驱动的测试

  但是,与 RC 相比,缺点是无法生成测试报告。RC 生成详细的报告。

  下图描述了 WebDriver 的工作方式:

  但是您是否想知道为什么需要 Selenium Webdriver?接下来,我将讨论 Selenium RC 的局限性,因为这是最终开发 WebDriver 的原因。

Selenium RC 的缺点和 WebDriver 的诞生

  当我说 Selenium RC 推出时立即引起轰动时,您可能会感到惊讶。那是因为它克服了同源策略问题,而在使用 Selenium Core 测试 Web 应用程序时这是一个主要问题。但是您知道什么是同源政策问题吗?

  同源策略是用于强制实施 Web 应用程序安全模型的规则。根据同源策略,当且仅当被测试的 JavaScript 和网页都来自同一域时,Web 浏览器才会允许 JavaScript 代码访问网页上的元素。Selenium Core 是基于 JavaScript 的测试工具,由于无法测试每个网页的原因而受到限制。

  但是,当 Selenium RC 出现时,它使测试人员摆脱了同源政策问题。但是,RC 如何做到这一点? RC 通过使用另一个称为 Selenium RC 服务器的组件来做到这一点。 因此,RC 是由两个组件组合而成的工具:Selenium RC 服务器Selenium RC 客户端

  Selenium RC 服务器是一个 HTTP 代理服务器,旨在“欺骗”浏览器,使其相信 Selenium Core 和被测试的 Web 应用程序来自同一域。因此,不能阻止 JavaScript 代码访问和测试任何网站。

  尽管 Selenium RC 受到了很大的欢迎,但它也有自己的问题。主要的是执行测试所花费的时间。由于 Selenium RC 服务器是浏览器与您的 Selenium 命令之间通信的中间人,因此执行测试非常耗时。除了时间因素之外,RC 的架构也有些复杂。

  这种架构涉及首先将 Selenium Core 注入 Web 浏览器。然后,Selenium Core 将接收来自 RC 服务器的指令并将其转换为 JavaScript 命令。此 JavaScript 代码负责访问和测试 Web 元素。下面这张图有助于您将了解 RC 的工作原理。

  为了克服这些问题,开发了 Selenium WebDriver。WebDriver更快,因为它直接与浏览器交互,并且不需要外部代理服务器。由于从操作系统级别控制浏览器,因此架构也更简单。下图将帮助您了解 WebDriver 的工作方式。

  WebDriver 的另一个好处是它支持在 HTML Unit 驱动程序(无头驱动程序)上进行测试。当我们说无头驱动程序时,它是指浏览器没有 GUI 的事实。另一方面,RC 不支持 HTML Unit 驱动程序。这些是 WebDriver 比 RC 得分高的原因。

  在学习 Selenium 的概念之前,您应该对 Java 或任何其他面向对象的编程语言有基本的了解。Selenium 支持的语言包括 C#、Java、Perl、PHP、Python 和 Ruby。当前,Selenium Webdriver 在 Java 和 C# 中最受欢迎。

  现在,让我们继续,下一部分学习“浏览器元素”,我将告诉您这些元素是什么以及如何在这些 Web 元素上进行测试。

什么是浏览器元素?

  元素是网页上存在的不同组件。我们在浏览时注意到的最常见元素是:

  • 文本框
  • CTA 按钮
  • 图像
  • 超链接
  • 单选按钮 / 复选框
  • 文字区 / 错误信息
  • 下拉框 / 列表框 / 组合框
  • Web表格 / HTML表格
  • 框架

  测试这些元素本质上意味着我们必须检查它们是否工作正常,并按照我们希望的方式进行响应。例如,如果我们正在测试文本框,您将对它进行什么测试?

  1. 我们是否能够将文本或数字发送到文本框
  2. 我们可以检索已传递到文本框等的文本吗?

  如果我们正在测试图像,则可能需要:

  1. 下载图片
  2. 上传图片
  3. 点击图片链接
  4. 检索图像标题等。

  类似地,可以对前面提到的每个元素执行操作。但是只有将元素放置在网页上之后,我们才能执行操作并开始对其进行测试,对吗? 因此,下一个主题,我将介绍元素定位器技术。

定位网页上存在的浏览器元素

  网页上的每个元素都具有属性。元素可以具有多个属性,并且这些属性中的大多数对于不同的元素而言都是唯一的。例如,考虑具有两个元素的页面:图像和文本框。 这两个元素都有一个“名称”属性和一个“ ID”属性。这些属性值对于每个元素都必须是唯一的。 换句话说,两个元素不能具有相同的属性值。元素的“类名”可以具有相同的值。

  在本例中,图像和文本框既不能具有相同的“ ID”值,也不能具有相同的“名称”值。但是,页面上的一组元素可能有一些共同的属性。稍后,我将告诉您这些属性是哪些,但是在此之前,让我列出我们可以用来定位元素的 8 个属性。 这些属性是 ID、名称、类名、标签名、链接文本、部分链接文本、CSS 和 XPath。

  由于元素是使用这些属性定位的,因此我们将其称为“定位器”。定位器有:

  • By.id
      语法: driver.findElement(By.id(“xxx”));
  • By.name
      语法: driver.findElement(By.name(“xxx”));
  • By.className
      语法: driver.findElement(By.className(“xxx”));
  • By.tagName
      语法: driver.findElement(By.tagName(“xxx”));
  • By.linkText
      语法: driver.findElement(By.linkText(“xxx”));
  • By.partialLinkText
      语法: driver.findElement(By.partialLinkText(“xxx”));
  • By.css
      语法: driver.findElement(By.css(“xxx”));
  • By.xpath
      语法: driver.findElement(By.xpath(“xxx”));

  通过查看上面的语法,您可能已经意识到定位器是在内部调用的。因此,在进行进一步操作之前,您需要学习可用于对元素执行操作的所有其他方法、浏览器命令和功能。

浏览器元素上的操作

  从现在开始,您将获得很多乐趣,因为理论更少、代码更多。因此,请做好准备,打开Eclipse IDE,并安装必需的 Selenium 软件包。

  要开始测试网页,我们需要首先打开浏览器,然后通过提供正确的 URL 导航到该网页?看看下面的代码,我在上面复制了同样的代码。Firefox 浏览器将首先启动,然后将导航到 Facebook 的登录页面。

package seleniumWebDriver;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.firefox.FirefoxDriver;

public class WebDriverClass
{
    public static void main(String[] args)
    {
        System.setProperty("webdriver.gecko.driver", "files/geckodriver.exe");
        WebDriver driver = new FirefoxDriver();
        driver.get("https://www.facebook.com/");
        driver.getTitle();
        driver.quit();
    }
}

  import
org.openqa.selenium.WebDriver;
是一个库包,其中包含启动加载有特定驱动程序的浏览器所需的类。

  import org.openqa.selenium.firefox.FirefoxDriver; 是一个库包,其中包含 FirefoxDriver 类,该类是启动 FirefoxDriver 作为 WebDriver 类启动的浏览器所需的。

  System.setProperty(“webdriver.gecko.driver”, “files/geckodriver.exe”); – 该命令通知运行时引擎指定路径中存在 Gecko 驱动程序。在 Firefox 35 之后,我们需要下载 Gecko 驱动程序以使用 WebDriver。如果要在 Chrome 上进行测试,则必须下载ChromeDriver(这是一个.exe文件),并在此代码行中指定其路径。对于其他浏览器,我们也必须这样做。

  WebDriver driver = new FirefoxDriver(); – 此命令用于启动新的 Firefox 驱动程序对象。

  driver.get(“https://www.edureka.co/”); – 这个方法用于打开指定的URL。

  driver.getTitle(); – 此命令获取浏览器中当前打开的选项卡的标题。

  driver.quit(); – 此命令关闭浏览器驱动程序。

  但是,如果您想导航到其他 URL 然后进行测试该怎么办?在这种情况下,您可以使用下面的代码片段所示的 navigation.to() 命令。然后,如果您想返回上一页,则可以通过使用navigation.back()命令来完成。 同样,要刷新当前页面,可以使用navigation.refresh() 命令。

driver.navigate().to(“https://www.edureka.co/testing-with-selenium-webdriver”);
driver.navigate().refresh();
driver.navigate().back();

  如果您想最大化浏览器窗口的大小,则可以使用下面的代码片段来实现。

driver.manage().window().maximize();

  如果要为浏览器窗口设置自定义尺寸,则可以设置自己的尺寸,如下面的代码片段所示。

Dimension d = new Dimension(420,600);
driver.manage().window().setSize(d);

  现在您已经了解了大多数基本知识,我们进入下一个主题。让我们尝试在网页上找到一个元素,然后执行所有可能的操作。

  我很确定,你们所有人都有 Facebook 帐户。因此,让我向您展示如何绕过代码本身的凭据登录 Facebook。

  登录页面中有两个文本字段,一个用于电子邮件 / 电话,另一个用于密码。我们必须找到这两个元素,将凭据传递给这些元素,然后找到第三个元素:需要单击的“登录”按钮。

  请看下面的截图。这是 Facebook 登录页面的屏幕截图。

  如果您检查(Ctlr + Shift + i)此页面,则将在浏览器中看到相同的窗口。然后,在“元素”下,将显示页面上存在的所有元素及其属性的列表。上面的屏幕快照中突出显示了三个部分。第一个突出显示的元素是电子邮件文本字段,第二个是密码文本字段,第三个是“登录”按钮。

  如果您还记得,我在前面提到过可以使用元素定位器技术来定位这些元素。 让我们用它来定位这些元素并发送字段值。

  这是查找元素的语法:driver.findElement(By.id(“xxx”));

为了发送它的值,我们可以使用方法 sendKeys(“credentials“);

要单击按钮,我们必须使用 click();

  那么,让我们开始寻找元素并对其进行操作。其代码在下面的代码片段中。

driver.findElement(By.name("email")).sendKeys("xxx@gmail.com");
driver.findElement(By.name("pass")).sendKeys("xxxxxx");
driver.findElement(By.id("u_0_q")).click();

  在第 1 行中,我们通过其唯一的“名称”属性来标识 Email 元素,并将其发送给 EmailID。

  在第 2 行中,我们通过其唯一的“名称”属性来标识 Password 元素,并将其发送给密码。

  在第 3 行中,我们通过其唯一 ID 找到“登录”按钮元素,然后单击该按钮。

  仅添加这些代码行可能还不够。那是因为页面的动态,它可能不会立即响应,并且在页面加载时,WebDriver 将终止并引发超时异常错误。此问题可能很快就不会在 Facebook 页面上发生,但很可能会在其他任何电子商务网站和其他动态网站上发生。

  为了克服这个问题,我们需要使用一种先进的技术。我们需要请求我们的 WebDriver 在页面被访问并且页面完全加载之后等待,我们需要找到元素然后执行操作。

如果你想让你的 WebDriver 等待,直到所有元素加载到网页中,然后关闭浏览器,那么我们可以使用 driver.wait() 方法或 Threads.sleep() 方法来实现。但是,如果您正在编写更高级的代码,那么您应该使用隐式等待显式等待。但是对于我们的情况,下面的命令就足够了。

driver.wait(5000);
// or use this:-
Thread.sleep(5000);

  但是,在使用等待条件时,请记住导入该库:

import java.util.concurrent.TimeUnit;

  我们这样做是因为,等待类及其相关方法将出现在此库中。

  下面是我所解释代码的完整代码片段。

package seleniumWebDriver;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.firefox.FirefoxDriver;
import java.util.concurrent.TimeUnit;

public class WebDriverClass
{
    public static void main(String[] args)
    {
        System.setProperty("webdriver.gecko.driver", "files/geckodriver.exe");
        WebDriver driver = new FirefoxDriver();
        driver.get("https://www.facebook.com/");
        driver.manage().window().maximize();
        driver.getTitle();
        driver.navigate().to(“https://www.edureka.co/testing-with-selenium-webdriver”);

        driver.navigate().back();
        driver.navigate().refresh();
        driver.wait(5000);
        // or use
        // Thread.sleep(5000);

        driver.findElement(By.name("email")).sendKeys("xxx@gmail.com");
        driver.findElement(By.name("pass")).sendKeys("xxxxxx");
        driver.findElement(By.id("u_0_q")).click();

        driver.quit();
    }
}

  当您用实际的电子邮件和密码替换凭据并执行此代码时,Facebook 将在新窗口中打开,输入您的凭据并登录到您的帐户。

  瞧! 您已成功登录,这意味着您的完整代码已完全执行。

  我使用了 ID 和 Name 属性来定位元素。实际上,您可以使用任何其他定位器来查找元素。XPath 是最有用和最重要的定位器技术。但是,只要您甚至可以找到其中一个属性并将其用于定位元素,就可以了。