Retrievers#
retriever是一个接口，它可以给定的查询返回相关的文档。它接受一个字符串查询作为输入，并返回一个Document列表作为输出。
LangChain提供的Retrievers如下：
https://python.langchain.com/v0.1/docs/modules/data_connection/retrievers/#advanced-retrieval-types
LangChain社区也提供了很多的Retrieves，如下： https://python.langchain.com/v0.1/docs/integrations/retrievers/
LangChain中Retrievers的代码定义在langchain-guide/lib/python3.11/site-packages/langchain_community/vectorstores/__init__.py中
from langchain_community.document_loaders import WebBaseLoader
loader = WebBaseLoader(
web_paths=("https://daliuchen.github.io/langchain-guide/intro.html",)
)
loader.load()
USER_AGENT environment variable not set, consider setting it to identify your requests.
[Document(page_content='\n\n\n\n\n\n欢迎来到我的langchain的学习手册 — langchan study guide\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nSkip to main content\n\n\nBack to top\n\n\n\n\n\n\n\n\n\n\nCtrl+K\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n 欢迎来到我的langchain的学习手册\n \n\n\n\nhappy path\nLangChain Expression Language\nPrompt templates\nExample selectors\nOutput parsers\nRAG检索增强\nRetrievers\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nRepository\n\n\n\n\n\n\nOpen issue\n\n\n\n\n\n\n\n\n\n\n\n\n\n.md\n\n\n\n\n\n\n\n.pdf\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n欢迎来到我的langchain的学习手册\n\n\n\n\n Contents \n\n\n\n欢迎来到我的langchain的学习手册\nlangchain总述\n一句话说清\n是什么？\n特点\n整体架构\n\n\n\n\n\n\n\n\n\n\n欢迎来到我的langchain的学习手册#\nlangchain最近很火热，在这里记录我对langchain的学习。\n欢迎大家一块添砖加瓦\n\n\nlangchain总述#\nlangchain官网：\nhttps://python.langchain.com/v0.2/docs/introduction/\n\n一句话说清#\n在和LLM交互的时候，首先需要写prompt，在调用LLM提供的API，解析输出。这里面就有三步，langchain将这三步抽象简化，并且提供了很多组件，他有强大的社区，\n有很多好用的东西，方便我们开发LLM的应用程序\n\n\n是什么？#\n\n基于大语言模型的开发框架（LLM）\n大语言模型的一站式开发框架\n\n\n\n特点#\n\n简化了大语言模型开发的难度，将和模型交互的各个阶段做抽象组合。\n提供了一站式的开发框架，包括开发，部署，观测\n简化了llm应用生命周期阶段，包括\n\n开发：Langchain提供了很多的组件，模块来构建应用程序，并且有有强大的社区生态。\n生产：LangSmith可以检查、监控和评估chain。\n部署：LangServe可以将chain暴露给外部服务来使用（API）\n\n\n\n\n\n整体架构#\n\n如上图所示，langchain的库如下\n\nlangchain-core\n对langchain的基础抽象和langchain表达式\nlangchain-community\n和第三方的整合（langchain是基于LLM的开发框架，他本身并不提供关于LLM的能力，它只是简化了和LLM交互的难度）\n和一些模型的包（例如，langchain-openai、langchain-anthropic等），一些集成已经进一步分离为只依赖于langchain-core的独立轻量级包。\nlangchain\nChains、agents、和让应用程序有认知能力的检索策略（retrieval strategies）\nlanggraph\n通过将步骤建模为图中的边和节点，使用LLM构建健壮且有状态的多参与者应用程序。\nlangserve\n将chain变为REST APIs\nLangSmith\n一个开发者平台，让你调试、测试、评估和监控LLM应用程序。\n\n\n\n\n\n\n\n\n\n\n\n\nnext\nhappy path\n\n\n\n\n\n\n\n\n\n Contents\n \n\n\n欢迎来到我的langchain的学习手册\nlangchain总述\n一句话说清\n是什么？\n特点\n整体架构\n\n\n\n\n\n\n\n\n\n\nBy liuchen\n\n\n\n\n \n © Copyright 2023.\n \n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n', metadata={'source': 'https://daliuchen.github.io/langchain-guide/intro.html', 'title': '欢迎来到我的langchain的学习手册 — langchan study guide', 'language': 'en'})]
向量存储检索器#
构建向量数据库，存储数据
from langchain_community.vectorstores import Chroma
from langchain_openai import OpenAIEmbeddings
from langchain_text_splitters import CharacterTextSplitter
documents = loader.load()
text_splitter = CharacterTextSplitter(chunk_size=500, chunk_overlap=100)
texts = text_splitter.split_documents(documents)
embeddings = OpenAIEmbeddings()
db = Chroma.from_documents(texts, embeddings)
print(db)
<langchain_community.vectorstores.chroma.Chroma object at 0x117c8cbd0>
构建retriever查询
retriever = db.as_retriever()
# 默认使用的相似性计算
retriever.invoke("LangChain的特点")
[Document(page_content='欢迎来到我的langchain的学习手册#\nlangchain最近很火热，在这里记录我对langchain的学习。\n欢迎大家一块添砖加瓦\n\n\nlangchain总述#\nlangchain官网：\nhttps://python.langchain.com/v0.2/docs/introduction/\n\n一句话说清#\n在和LLM交互的时候，首先需要写prompt，在调用LLM提供的API，解析输出。这里面就有三步，langchain将这三步抽象简化，并且提供了很多组件，他有强大的社区，\n有很多好用的东西，方便我们开发LLM的应用程序\n\n\n是什么？#\n\n基于大语言模型的开发框架（LLM）\n大语言模型的一站式开发框架\n\n特点#\n\n简化了大语言模型开发的难度，将和模型交互的各个阶段做抽象组合。\n提供了一站式的开发框架，包括开发，部署，观测\n简化了llm应用生命周期阶段，包括\n\n开发：Langchain提供了很多的组件，模块来构建应用程序，并且有有强大的社区生态。\n生产：LangSmith可以检查、监控和评估chain。\n部署：LangServe可以将chain暴露给外部服务来使用（API）', metadata={'language': 'en', 'source': 'https://daliuchen.github.io/langchain-guide/intro.html', 'title': '欢迎来到我的langchain的学习手册 — langchan study guide'}),
Document(page_content='next\nhappy path\n\n Contents\n \n\n\n欢迎来到我的langchain的学习手册\nlangchain总述\n一句话说清\n是什么？\n特点\n整体架构\n\n\nBy liuchen\n\n\n \n © Copyright 2023.', metadata={'language': 'en', 'source': 'https://daliuchen.github.io/langchain-guide/intro.html', 'title': '欢迎来到我的langchain的学习手册 — langchan study guide'}),
Document(page_content='整体架构#\n\n如上图所示，langchain的库如下\n\nlangchain-core\n对langchain的基础抽象和langchain表达式\nlangchain-community\n和第三方的整合（langchain是基于LLM的开发框架，他本身并不提供关于LLM的能力，它只是简化了和LLM交互的难度）\n和一些模型的包（例如，langchain-openai、langchain-anthropic等），一些集成已经进一步分离为只依赖于langchain-core的独立轻量级包。\nlangchain\nChains、agents、和让应用程序有认知能力的检索策略（retrieval strategies）\nlanggraph\n通过将步骤建模为图中的边和节点，使用LLM构建健壮且有状态的多参与者应用程序。\nlangserve\n将chain变为REST APIs\nLangSmith\n一个开发者平台，让你调试、测试、评估和监控LLM应用程序。\n\n\nnext\nhappy path\n\n Contents', metadata={'language': 'en', 'source': 'https://daliuchen.github.io/langchain-guide/intro.html', 'title': '欢迎来到我的langchain的学习手册 — langchan study guide'}),
Document(page_content='欢迎来到我的langchain的学习手册 — langchan study guide\n\n\nSkip to main content\n\n\nBack to top\n\n\nCtrl+K\n\n 欢迎来到我的langchain的学习手册\n \n\nhappy path\nLangChain Expression Language\nPrompt templates\nExample selectors\nOutput parsers\nRAG检索增强\nRetrievers\n\nRepository\n\n\nOpen issue\n\n.md\n\n.pdf\n\n欢迎来到我的langchain的学习手册\n\n\n Contents \n\n欢迎来到我的langchain的学习手册\nlangchain总述\n一句话说清\n是什么？\n特点\n整体架构\n\n\n欢迎来到我的langchain的学习手册#\nlangchain最近很火热，在这里记录我对langchain的学习。\n欢迎大家一块添砖加瓦', metadata={'language': 'en', 'source': 'https://daliuchen.github.io/langchain-guide/intro.html', 'title': '欢迎来到我的langchain的学习手册 — langchan study guide'})]
默认采用相似性来计算，可以修改为使用MMR来计算,并且规定只返回一条，设置相似性得分， 大于0.5的 才是符合条件的
retriever = db.as_retriever(search_type="mmr",search_kwargs={"k": 1,"score_threshold":0.8})
retriever.invoke("LangChain的特点")
Number of requested results 20 is greater than number of elements in index 4, updating n_results = 4
[Document(page_content='欢迎来到我的langchain的学习手册#\nlangchain最近很火热，在这里记录我对langchain的学习。\n欢迎大家一块添砖加瓦\n\n\nlangchain总述#\nlangchain官网：\nhttps://python.langchain.com/v0.2/docs/introduction/\n\n一句话说清#\n在和LLM交互的时候，首先需要写prompt，在调用LLM提供的API，解析输出。这里面就有三步，langchain将这三步抽象简化，并且提供了很多组件，他有强大的社区，\n有很多好用的东西，方便我们开发LLM的应用程序\n\n\n是什么？#\n\n基于大语言模型的开发框架（LLM）\n大语言模型的一站式开发框架\n\n特点#\n\n简化了大语言模型开发的难度，将和模型交互的各个阶段做抽象组合。\n提供了一站式的开发框架，包括开发，部署，观测\n简化了llm应用生命周期阶段，包括\n\n开发：Langchain提供了很多的组件，模块来构建应用程序，并且有有强大的社区生态。\n生产：LangSmith可以检查、监控和评估chain。\n部署：LangServe可以将chain暴露给外部服务来使用（API）', metadata={'language': 'en', 'source': 'https://daliuchen.github.io/langchain-guide/intro.html', 'title': '欢迎来到我的langchain的学习手册 — langchan study guide'})]
MultiQueryRetriever#
这是检索优化的方式，上面的retriever存在一个问题，检索不准确，这里的优化方式是通过LLM，将单一的搜索，拓展为多个维度的搜索。提高了搜索的精度，并且会将搜索到的结果合并在一起。
from langchain.retrievers.multi_query import MultiQueryRetriever, DEFAULT_QUERY_PROMPT
from langchain_openai import ChatOpenAI
question = "LangChain的特点是什么"
llm = ChatOpenAI(temperature=0)
retriever_from_llm = MultiQueryRetriever.from_llm(
retriever=db.as_retriever(), llm=llm
)
print(retriever_from_llm)
retriever=VectorStoreRetriever(tags=['Chroma', 'OpenAIEmbeddings'], vectorstore=<langchain_community.vectorstores.chroma.Chroma object at 0x117c8cbd0>) llm_chain=PromptTemplate(input_variables=['question'], template='You are an AI language model assistant. Your task is \n to generate 3 different versions of the given user \n question to retrieve relevant documents from a vector database. \n By generating multiple perspectives on the user question, \n your goal is to help the user overcome some of the limitations \n of distance-based similarity search. Provide these alternative \n questions separated by newlines. Original question: {question}')
| ChatOpenAI(client=<openai.resources.chat.completions.Completions object at 0x1272524d0>, async_client=<openai.resources.chat.completions.AsyncCompletions object at 0x13670a310>, temperature=0.0, openai_api_key=SecretStr('**********'), openai_api_base='https://ai-yyds.com/v1', openai_proxy='')
| LineListOutputParser()
从上面可以看到，它是需要和模型做交互的，下面是他的promot
# 下面是他的promot
print(DEFAULT_QUERY_PROMPT.template)
You are an AI language model assistant. Your task is
to generate 3 different versions of the given user
question to retrieve relevant documents from a vector database.
By generating multiple perspectives on the user question,
your goal is to help the user overcome some of the limitations
of distance-based similarity search. Provide these alternative
questions separated by newlines. Original question: {question}
# Set logging for the queries
import langchain
langchain.debug=True
# 查询
unique_docs = retriever_from_llm.invoke(question)
len(unique_docs) # 查找到了四个文档
[chain/start] [retriever:Retriever > chain:RunnableSequence] Entering Chain run with input:
{
"question": "LangChain的特点是什么"
}
[chain/start] [retriever:Retriever > chain:RunnableSequence > prompt:PromptTemplate] Entering Prompt run with input:
{
"question": "LangChain的特点是什么"
}
[chain/end] [retriever:Retriever > chain:RunnableSequence > prompt:PromptTemplate] [1ms] Exiting Prompt run with output:
[outputs]
[llm/start] [retriever:Retriever > chain:RunnableSequence > llm:ChatOpenAI] Entering LLM run with input:
{
"prompts": [
"Human: You are an AI language model assistant. Your task is \n to generate 3 different versions of the given user \n question to retrieve relevant documents from a vector database. \n By generating multiple perspectives on the user question, \n your goal is to help the user overcome some of the limitations \n of distance-based similarity search. Provide these alternative \n questions separated by newlines. Original question: LangChain的特点是什么"
]
}
[llm/end] [retriever:Retriever > chain:RunnableSequence > llm:ChatOpenAI] [2.38s] Exiting LLM run with output:
{
"generations": [
[
{
"text": "1. LangChain有哪些独特的特点？\n2. LangChain有什么与众不同的特征？\n3. LangChain在哪些方面与其他技术不同？",
"generation_info": {
"finish_reason": "stop",
"logprobs": null
},
"type": "ChatGeneration",
"message": {
"lc": 1,
"type": "constructor",
"id": [
"langchain",
"schema",
"messages",
"AIMessage"
],
"kwargs": {
"content": "1. LangChain有哪些独特的特点？\n2. LangChain有什么与众不同的特征？\n3. LangChain在哪些方面与其他技术不同？",
"response_metadata": {
"token_usage": {
"completion_tokens": 52,
"prompt_tokens": 99,
"total_tokens": 151
},
"model_name": "gpt-35-turbo",
"system_fingerprint": null,
"finish_reason": "stop",
"logprobs": null
},
"type": "ai",
"id": "run-d284b676-6fea-4da2-b688-69ec1b17ee68-0",
"usage_metadata": {
"input_tokens": 99,
"output_tokens": 52,
"total_tokens": 151
},
"tool_calls": [],
"invalid_tool_calls": []
}
}
}
]
],
"llm_output": {
"token_usage": {
"completion_tokens": 52,
"prompt_tokens": 99,
"total_tokens": 151
},
"model_name": "gpt-35-turbo",
"system_fingerprint": null
},
"run": null
}
[chain/start] [retriever:Retriever > chain:RunnableSequence > parser:LineListOutputParser] Entering Parser run with input:
[inputs]
[chain/end] [retriever:Retriever > chain:RunnableSequence > parser:LineListOutputParser] [2ms] Exiting Parser run with output:
{
"output": [
"1. LangChain有哪些独特的特点？",
"2. LangChain有什么与众不同的特征？",
"3. LangChain在哪些方面与其他技术不同？"
]
}
[chain/end] [retriever:Retriever > chain:RunnableSequence] [2.38s] Exiting Chain run with output:
{
"output": [
"1. LangChain有哪些独特的特点？",
"2. LangChain有什么与众不同的特征？",
"3. LangChain在哪些方面与其他技术不同？"
]
}
4
内容压缩检索器#
在检索的过程中，面临一个问题：数据有很多，一次查询可能会查出很多无关的数据，即使调整查询的score和方式也不能满足，不可能最少化的通过检索来找出想要的数据（信息密度太低），如果将整个文档全部塞给LLM，LLM生成的响应可能也有很多无用的话，甚至只是将你塞给他的数据，复述一遍，并且这还会花费很多的token。
Contextual compression 就是解决了这个问题，这个想法很简单：不要返回检索到的原始数据，而是根据查询的上下文压缩文档，只返回相关的信息。这里的“压缩”指的是对单个文档内容进行压缩，同时也可以整体过滤掉一些文档。
在LangChain里面ContextualCompressionRetriever要配合Filter使用，不同的Filter有不同的内容处理方式。
# Helper function for printing docs
def pretty_print_docs(docs):
print(
f"\n{'-' * 100}\n".join(
[f"Document {i+1}:\n\n" + d.page_content for i, d in enumerate(docs)]
)
)
# retriever 用户还是上面的
retriever = Chroma.from_documents(texts, OpenAIEmbeddings()).as_retriever(search_kwargs={'k': 2})
docs = retriever.invoke("LangChain的特点是什么？")
pretty_print_docs(docs)
Document 1:
欢迎来到我的langchain的学习手册#
langchain最近很火热，在这里记录我对langchain的学习。
欢迎大家一块添砖加瓦
langchain总述#
langchain官网：
https://python.langchain.com/v0.2/docs/introduction/
一句话说清#
在和LLM交互的时候，首先需要写prompt，在调用LLM提供的API，解析输出。这里面就有三步，langchain将这三步抽象简化，并且提供了很多组件，他有强大的社区，
有很多好用的东西，方便我们开发LLM的应用程序
是什么？#
基于大语言模型的开发框架（LLM）
大语言模型的一站式开发框架
特点#
简化了大语言模型开发的难度，将和模型交互的各个阶段做抽象组合。
提供了一站式的开发框架，包括开发，部署，观测
简化了llm应用生命周期阶段，包括
开发：Langchain提供了很多的组件，模块来构建应用程序，并且有有强大的社区生态。
生产：LangSmith可以检查、监控和评估chain。
部署：LangServe可以将chain暴露给外部服务来使用（API）
----------------------------------------------------------------------------------------------------
Document 2:
欢迎来到我的langchain的学习手册#
langchain最近很火热，在这里记录我对langchain的学习。
欢迎大家一块添砖加瓦
langchain总述#
langchain官网：
https://python.langchain.com/v0.2/docs/introduction/
一句话说清#
在和LLM交互的时候，首先需要写prompt，在调用LLM提供的API，解析输出。这里面就有三步，langchain将这三步抽象简化，并且提供了很多组件，他有强大的社区，
有很多好用的东西，方便我们开发LLM的应用程序
是什么？#
基于大语言模型的开发框架（LLM）
大语言模型的一站式开发框架
特点#
简化了大语言模型开发的难度，将和模型交互的各个阶段做抽象组合。
提供了一站式的开发框架，包括开发，部署，观测
简化了llm应用生命周期阶段，包括
开发：Langchain提供了很多的组件，模块来构建应用程序，并且有有强大的社区生态。
生产：LangSmith可以检查、监控和评估chain。
部署：LangServe可以将chain暴露给外部服务来使用（API）
内容提取Filter(LLMChainExtractor)#
from langchain.retrievers import ContextualCompressionRetriever
from langchain.retrievers.document_compressors import LLMChainExtractor
from langchain_openai import OpenAI
llm = OpenAI(temperature=0)
compressor = LLMChainExtractor.from_llm(llm)
compression_retriever = ContextualCompressionRetriever(
base_compressor=compressor, base_retriever=retriever
)
compressed_docs = compression_retriever.invoke(
"LangChain的特点是什么？"
)
pretty_print_docs(compressed_docs)
[chain/start] [retriever:Retriever > chain:LLMChain] Entering Chain run with input:
{
"question": "LangChain的特点是什么？",
"context": "欢迎来到我的langchain的学习手册#\nlangchain最近很火热，在这里记录我对langchain的学习。\n欢迎大家一块添砖加瓦\n\n\nlangchain总述#\nlangchain官网：\nhttps://python.langchain.com/v0.2/docs/introduction/\n\n一句话说清#\n在和LLM交互的时候，首先需要写prompt，在调用LLM提供的API，解析输出。这里面就有三步，langchain将这三步抽象简化，并且提供了很多组件，他有强大的社区，\n有很多好用的东西，方便我们开发LLM的应用程序\n\n\n是什么？#\n\n基于大语言模型的开发框架（LLM）\n大语言模型的一站式开发框架\n\n特点#\n\n简化了大语言模型开发的难度，将和模型交互的各个阶段做抽象组合。\n提供了一站式的开发框架，包括开发，部署，观测\n简化了llm应用生命周期阶段，包括\n\n开发：Langchain提供了很多的组件，模块来构建应用程序，并且有有强大的社区生态。\n生产：LangSmith可以检查、监控和评估chain。\n部署：LangServe可以将chain暴露给外部服务来使用（API）"
}
[llm/start] [retriever:Retriever > chain:LLMChain > llm:OpenAI] Entering LLM run with input:
{
"prompts": [
"Given the following question and context, extract any part of the context *AS IS* that is relevant to answer the question. If none of the context is relevant return NO_OUTPUT. \n\nRemember, *DO NOT* edit the extracted parts of the context.\n\n> Question: LangChain的特点是什么？\n> Context:\n>>>\n欢迎来到我的langchain的学习手册#\nlangchain最近很火热，在这里记录我对langchain的学习。\n欢迎大家一块添砖加瓦\n\n\nlangchain总述#\nlangchain官网：\nhttps://python.langchain.com/v0.2/docs/introduction/\n\n一句话说清#\n在和LLM交互的时候，首先需要写prompt，在调用LLM提供的API，解析输出。这里面就有三步，langchain将这三步抽象简化，并且提供了很多组件，他有强大的社区，\n有很多好用的东西，方便我们开发LLM的应用程序\n\n\n是什么？#\n\n基于大语言模型的开发框架（LLM）\n大语言模型的一站式开发框架\n\n特点#\n\n简化了大语言模型开发的难度，将和模型交互的各个阶段做抽象组合。\n提供了一站式的开发框架，包括开发，部署，观测\n简化了llm应用生命周期阶段，包括\n\n开发：Langchain提供了很多的组件，模块来构建应用程序，并且有有强大的社区生态。\n生产：LangSmith可以检查、监控和评估chain。\n部署：LangServe可以将chain暴露给外部服务来使用（API）\n>>>\nExtracted relevant parts:"
]
}
[llm/end] [retriever:Retriever > chain:LLMChain > llm:OpenAI] [4.42s] Exiting LLM run with output:
{
"generations": [
[
{
"text": "\n- langchain最近很火热，在这里记录我对langchain的学习。\n- langchain总述#\n- langchain官网：\nhttps://python.langchain.com/v0.2/docs/introduction/\n- 一句话说清#\n- 是什么？#\n- 特点#\n- 简化了大语言模型开发的难度，将和模型交互的各个阶段做抽象组合。\n- 提供了一站式的开发框架，包括开发，部署，观测\n- 简化了llm应用生命周期阶段，包括\n- 开发：Langchain提供了很多的组件，模块来构建应用程序，并且有有强大的社区生态。\n- 生产：LangSmith可以检查、监控和评估chain。\n- 部署：LangServe可以将chain暴露给外部服务来使用（API）",
"generation_info": {
"finish_reason": "stop",
"logprobs": null
},
"type": "Generation"
}
]
],
"llm_output": {
"token_usage": {
"total_tokens": 710,
"completion_tokens": 246,
"prompt_tokens": 464
},
"model_name": "gpt-3.5-turbo-instruct"
},
"run": null
}
[chain/end] [retriever:Retriever > chain:LLMChain] [4.42s] Exiting Chain run with output:
{
"text": "\n- langchain最近很火热，在这里记录我对langchain的学习。\n- langchain总述#\n- langchain官网：\nhttps://python.langchain.com/v0.2/docs/introduction/\n- 一句话说清#\n- 是什么？#\n- 特点#\n- 简化了大语言模型开发的难度，将和模型交互的各个阶段做抽象组合。\n- 提供了一站式的开发框架，包括开发，部署，观测\n- 简化了llm应用生命周期阶段，包括\n- 开发：Langchain提供了很多的组件，模块来构建应用程序，并且有有强大的社区生态。\n- 生产：LangSmith可以检查、监控和评估chain。\n- 部署：LangServe可以将chain暴露给外部服务来使用（API）"
}
[chain/start] [retriever:Retriever > chain:LLMChain] Entering Chain run with input:
{
"question": "LangChain的特点是什么？",
"context": "欢迎来到我的langchain的学习手册#\nlangchain最近很火热，在这里记录我对langchain的学习。\n欢迎大家一块添砖加瓦\n\n\nlangchain总述#\nlangchain官网：\nhttps://python.langchain.com/v0.2/docs/introduction/\n\n一句话说清#\n在和LLM交互的时候，首先需要写prompt，在调用LLM提供的API，解析输出。这里面就有三步，langchain将这三步抽象简化，并且提供了很多组件，他有强大的社区，\n有很多好用的东西，方便我们开发LLM的应用程序\n\n\n是什么？#\n\n基于大语言模型的开发框架（LLM）\n大语言模型的一站式开发框架\n\n特点#\n\n简化了大语言模型开发的难度，将和模型交互的各个阶段做抽象组合。\n提供了一站式的开发框架，包括开发，部署，观测\n简化了llm应用生命周期阶段，包括\n\n开发：Langchain提供了很多的组件，模块来构建应用程序，并且有有强大的社区生态。\n生产：LangSmith可以检查、监控和评估chain。\n部署：LangServe可以将chain暴露给外部服务来使用（API）"
}
[llm/start] [retriever:Retriever > chain:LLMChain > llm:OpenAI] Entering LLM run with input:
{
"prompts": [
"Given the following question and context, extract any part of the context *AS IS* that is relevant to answer the question. If none of the context is relevant return NO_OUTPUT. \n\nRemember, *DO NOT* edit the extracted parts of the context.\n\n> Question: LangChain的特点是什么？\n> Context:\n>>>\n欢迎来到我的langchain的学习手册#\nlangchain最近很火热，在这里记录我对langchain的学习。\n欢迎大家一块添砖加瓦\n\n\nlangchain总述#\nlangchain官网：\nhttps://python.langchain.com/v0.2/docs/introduction/\n\n一句话说清#\n在和LLM交互的时候，首先需要写prompt，在调用LLM提供的API，解析输出。这里面就有三步，langchain将这三步抽象简化，并且提供了很多组件，他有强大的社区，\n有很多好用的东西，方便我们开发LLM的应用程序\n\n\n是什么？#\n\n基于大语言模型的开发框架（LLM）\n大语言模型的一站式开发框架\n\n特点#\n\n简化了大语言模型开发的难度，将和模型交互的各个阶段做抽象组合。\n提供了一站式的开发框架，包括开发，部署，观测\n简化了llm应用生命周期阶段，包括\n\n开发：Langchain提供了很多的组件，模块来构建应用程序，并且有有强大的社区生态。\n生产：LangSmith可以检查、监控和评估chain。\n部署：LangServe可以将chain暴露给外部服务来使用（API）\n>>>\nExtracted relevant parts:"
]
}
[llm/end] [retriever:Retriever > chain:LLMChain > llm:OpenAI] [7.96s] Exiting LLM run with output:
{
"generations": [
[
{
"text": "\n- langchain最近很火热，在这里记录我对langchain的学习。\n- langchain总述#\n- langchain官网：\nhttps://python.langchain.com/v0.2/docs/introduction/\n- 一句话说清#\n- 是什么？#\n- 特点#\n- 简化了大语言模型开发的难度，将和模型交互的各个阶段做抽象组合。\n- 提供了一站式的开发框架，包括开发，部署，观测\n- 简化了llm应用生命周期阶段，包括\n- 开发：Langchain提供了很多的组件，模块来构建应用程序，并且有有强大的社区生态。\n- 生产：LangSmith可以检查、监控和评估chain。\n- 部署：LangServe可以将chain暴露给外部服务来使用（API）",
"generation_info": {
"finish_reason": "stop",
"logprobs": null
},
"type": "Generation"
}
]
],
"llm_output": {
"token_usage": {
"total_tokens": 710,
"completion_tokens": 246,
"prompt_tokens": 464
},
"model_name": "gpt-3.5-turbo-instruct"
},
"run": null
}
[chain/end] [retriever:Retriever > chain:LLMChain] [7.96s] Exiting Chain run with output:
{
"text": "\n- langchain最近很火热，在这里记录我对langchain的学习。\n- langchain总述#\n- langchain官网：\nhttps://python.langchain.com/v0.2/docs/introduction/\n- 一句话说清#\n- 是什么？#\n- 特点#\n- 简化了大语言模型开发的难度，将和模型交互的各个阶段做抽象组合。\n- 提供了一站式的开发框架，包括开发，部署，观测\n- 简化了llm应用生命周期阶段，包括\n- 开发：Langchain提供了很多的组件，模块来构建应用程序，并且有有强大的社区生态。\n- 生产：LangSmith可以检查、监控和评估chain。\n- 部署：LangServe可以将chain暴露给外部服务来使用（API）"
}
Document 1:
- langchain最近很火热，在这里记录我对langchain的学习。
- langchain总述#
- langchain官网：
https://python.langchain.com/v0.2/docs/introduction/
- 一句话说清#
- 是什么？#
- 特点#
- 简化了大语言模型开发的难度，将和模型交互的各个阶段做抽象组合。
- 提供了一站式的开发框架，包括开发，部署，观测
- 简化了llm应用生命周期阶段，包括
- 开发：Langchain提供了很多的组件，模块来构建应用程序，并且有有强大的社区生态。
- 生产：LangSmith可以检查、监控和评估chain。
- 部署：LangServe可以将chain暴露给外部服务来使用（API）
----------------------------------------------------------------------------------------------------
Document 2:
- langchain最近很火热，在这里记录我对langchain的学习。
- langchain总述#
- langchain官网：
https://python.langchain.com/v0.2/docs/introduction/
- 一句话说清#
- 是什么？#
- 特点#
- 简化了大语言模型开发的难度，将和模型交互的各个阶段做抽象组合。
- 提供了一站式的开发框架，包括开发，部署，观测
- 简化了llm应用生命周期阶段，包括
- 开发：Langchain提供了很多的组件，模块来构建应用程序，并且有有强大的社区生态。
- 生产：LangSmith可以检查、监控和评估chain。
- 部署：LangServe可以将chain暴露给外部服务来使用（API）
从上面的执行过程可以看到，它会将每个搜索到的文档，和原始的问题，传递给LLM做汇总和内容整理。
内容相关Filter(LLMChainFilter)#
将找到的每一个文档的内容和原始的问题，传递给LLM，让LLM来决定两者是否有关，没有关系的文档直接过滤掉，有关系的直接返回，并且不会对文档的内容做提取
from langchain.retrievers.document_compressors import LLMChainFilter
_filter = LLMChainFilter.from_llm(llm)
compression_retriever = ContextualCompressionRetriever(
base_compressor=_filter, base_retriever=retriever
)
compressed_docs = compression_retriever.invoke(
"LangChain的有什么组件？"
)
pretty_print_docs(compressed_docs)
[chain/start] [retriever:Retriever > chain:LLMChain] Entering Chain run with input:
{
"question": "LangChain的有什么组件？",
"context": "欢迎来到我的langchain的学习手册#\nlangchain最近很火热，在这里记录我对langchain的学习。\n欢迎大家一块添砖加瓦\n\n\nlangchain总述#\nlangchain官网：\nhttps://python.langchain.com/v0.2/docs/introduction/\n\n一句话说清#\n在和LLM交互的时候，首先需要写prompt，在调用LLM提供的API，解析输出。这里面就有三步，langchain将这三步抽象简化，并且提供了很多组件，他有强大的社区，\n有很多好用的东西，方便我们开发LLM的应用程序\n\n\n是什么？#\n\n基于大语言模型的开发框架（LLM）\n大语言模型的一站式开发框架\n\n特点#\n\n简化了大语言模型开发的难度，将和模型交互的各个阶段做抽象组合。\n提供了一站式的开发框架，包括开发，部署，观测\n简化了llm应用生命周期阶段，包括\n\n开发：Langchain提供了很多的组件，模块来构建应用程序，并且有有强大的社区生态。\n生产：LangSmith可以检查、监控和评估chain。\n部署：LangServe可以将chain暴露给外部服务来使用（API）"
}[chain/start] [retriever:Retriever > chain:LLMChain] Entering Chain run with input:
{
"question": "LangChain的有什么组件？",
"context": "欢迎来到我的langchain的学习手册#\nlangchain最近很火热，在这里记录我对langchain的学习。\n欢迎大家一块添砖加瓦\n\n\nlangchain总述#\nlangchain官网：\nhttps://python.langchain.com/v0.2/docs/introduction/\n\n一句话说清#\n在和LLM交互的时候，首先需要写prompt，在调用LLM提供的API，解析输出。这里面就有三步，langchain将这三步抽象简化，并且提供了很多组件，他有强大的社区，\n有很多好用的东西，方便我们开发LLM的应用程序\n\n\n是什么？#\n\n基于大语言模型的开发框架（LLM）\n大语言模型的一站式开发框架\n\n特点#\n\n简化了大语言模型开发的难度，将和模型交互的各个阶段做抽象组合。\n提供了一站式的开发框架，包括开发，部署，观测\n简化了llm应用生命周期阶段，包括\n\n开发：Langchain提供了很多的组件，模块来构建应用程序，并且有有强大的社区生态。\n生产：LangSmith可以检查、监控和评估chain。\n部署：LangServe可以将chain暴露给外部服务来使用（API）"
}
[llm/start] [retriever:Retriever > chain:LLMChain > llm:OpenAI] Entering LLM run with input:
{
"prompts": [
"Given the following question and context, return YES if the context is relevant to the question and NO if it isn't.\n\n> Question: LangChain的有什么组件？\n> Context:\n>>>\n欢迎来到我的langchain的学习手册#\nlangchain最近很火热，在这里记录我对langchain的学习。\n欢迎大家一块添砖加瓦\n\n\nlangchain总述#\nlangchain官网：\nhttps://python.langchain.com/v0.2/docs/introduction/\n\n一句话说清#\n在和LLM交互的时候，首先需要写prompt，在调用LLM提供的API，解析输出。这里面就有三步，langchain将这三步抽象简化，并且提供了很多组件，他有强大的社区，\n有很多好用的东西，方便我们开发LLM的应用程序\n\n\n是什么？#\n\n基于大语言模型的开发框架（LLM）\n大语言模型的一站式开发框架\n\n特点#\n\n简化了大语言模型开发的难度，将和模型交互的各个阶段做抽象组合。\n提供了一站式的开发框架，包括开发，部署，观测\n简化了llm应用生命周期阶段，包括\n\n开发：Langchain提供了很多的组件，模块来构建应用程序，并且有有强大的社区生态。\n生产：LangSmith可以检查、监控和评估chain。\n部署：LangServe可以将chain暴露给外部服务来使用（API）\n>>>\n> Relevant (YES / NO):"
]
}
[llm/start] [retriever:Retriever > chain:LLMChain > llm:OpenAI] Entering LLM run with input:
{
"prompts": [
"Given the following question and context, return YES if the context is relevant to the question and NO if it isn't.\n\n> Question: LangChain的有什么组件？\n> Context:\n>>>\n欢迎来到我的langchain的学习手册#\nlangchain最近很火热，在这里记录我对langchain的学习。\n欢迎大家一块添砖加瓦\n\n\nlangchain总述#\nlangchain官网：\nhttps://python.langchain.com/v0.2/docs/introduction/\n\n一句话说清#\n在和LLM交互的时候，首先需要写prompt，在调用LLM提供的API，解析输出。这里面就有三步，langchain将这三步抽象简化，并且提供了很多组件，他有强大的社区，\n有很多好用的东西，方便我们开发LLM的应用程序\n\n\n是什么？#\n\n基于大语言模型的开发框架（LLM）\n大语言模型的一站式开发框架\n\n特点#\n\n简化了大语言模型开发的难度，将和模型交互的各个阶段做抽象组合。\n提供了一站式的开发框架，包括开发，部署，观测\n简化了llm应用生命周期阶段，包括\n\n开发：Langchain提供了很多的组件，模块来构建应用程序，并且有有强大的社区生态。\n生产：LangSmith可以检查、监控和评估chain。\n部署：LangServe可以将chain暴露给外部服务来使用（API）\n>>>\n> Relevant (YES / NO):"
]
}
[llm/end] [retriever:Retriever > chain:LLMChain > llm:OpenAI] [833ms] Exiting LLM run with output:
{
"generations": [
[
{
"text": " YES",
"generation_info": {
"finish_reason": "stop",
"logprobs": null
},
"type": "Generation"
}
]
],
"llm_output": {
"token_usage": {
"total_tokens": 440,
"completion_tokens": 1,
"prompt_tokens": 439
},
"model_name": "gpt-3.5-turbo-instruct"
},
"run": null
}
[chain/end] [retriever:Retriever > chain:LLMChain] [840ms] Exiting Chain run with output:
{
"text": " YES"
}
[llm/end] [retriever:Retriever > chain:LLMChain > llm:OpenAI] [5.07s] Exiting LLM run with output:
{
"generations": [
[
{
"text": " YES",
"generation_info": {
"finish_reason": "stop",
"logprobs": null
},
"type": "Generation"
}
]
],
"llm_output": {
"token_usage": {
"total_tokens": 440,
"completion_tokens": 1,
"prompt_tokens": 439
},
"model_name": "gpt-3.5-turbo-instruct"
},
"run": null
}
[chain/end] [retriever:Retriever > chain:LLMChain] [5.08s] Exiting Chain run with output:
{
"text": " YES"
}
Document 1:
欢迎来到我的langchain的学习手册#
langchain最近很火热，在这里记录我对langchain的学习。
欢迎大家一块添砖加瓦
langchain总述#
langchain官网：
https://python.langchain.com/v0.2/docs/introduction/
一句话说清#
在和LLM交互的时候，首先需要写prompt，在调用LLM提供的API，解析输出。这里面就有三步，langchain将这三步抽象简化，并且提供了很多组件，他有强大的社区，
有很多好用的东西，方便我们开发LLM的应用程序
是什么？#
基于大语言模型的开发框架（LLM）
大语言模型的一站式开发框架
特点#
简化了大语言模型开发的难度，将和模型交互的各个阶段做抽象组合。
提供了一站式的开发框架，包括开发，部署，观测
简化了llm应用生命周期阶段，包括
开发：Langchain提供了很多的组件，模块来构建应用程序，并且有有强大的社区生态。
生产：LangSmith可以检查、监控和评估chain。
部署：LangServe可以将chain暴露给外部服务来使用（API）
----------------------------------------------------------------------------------------------------
Document 2:
欢迎来到我的langchain的学习手册#
langchain最近很火热，在这里记录我对langchain的学习。
欢迎大家一块添砖加瓦
langchain总述#
langchain官网：
https://python.langchain.com/v0.2/docs/introduction/
一句话说清#
在和LLM交互的时候，首先需要写prompt，在调用LLM提供的API，解析输出。这里面就有三步，langchain将这三步抽象简化，并且提供了很多组件，他有强大的社区，
有很多好用的东西，方便我们开发LLM的应用程序
是什么？#
基于大语言模型的开发框架（LLM）
大语言模型的一站式开发框架
特点#
简化了大语言模型开发的难度，将和模型交互的各个阶段做抽象组合。
提供了一站式的开发框架，包括开发，部署，观测
简化了llm应用生命周期阶段，包括
开发：Langchain提供了很多的组件，模块来构建应用程序，并且有有强大的社区生态。
生产：LangSmith可以检查、监控和评估chain。
部署：LangServe可以将chain暴露给外部服务来使用（API）
EmbeddingsFilter#
上面的几个Filter，是要和LLM做交互的，虽然返回的内容精简了不少，但是花费一点都没有少。EmbeddingsFilter提供了一种便宜快速的选项，在从向量数据量中查找到数据后，对于每个文档再次Embedding，对query也再次Embedding，在计算一次相似度，只有满足的才能返回。
from langchain.retrievers.document_compressors import EmbeddingsFilter
from langchain_openai import OpenAIEmbeddings
embeddings = OpenAIEmbeddings()
retriever = db.as_retriever(search_kwargs={'k': 2})
embeddings_filter = EmbeddingsFilter(embeddings=embeddings, similarity_threshold=0.76)
compression_retriever = ContextualCompressionRetriever(
base_compressor=embeddings_filter, base_retriever=retriever
)
compressed_docs = compression_retriever.invoke(
"LangChain的特点是什么"
)
pretty_print_docs(compressed_docs)
Document 1:
欢迎来到我的langchain的学习手册#
langchain最近很火热，在这里记录我对langchain的学习。
欢迎大家一块添砖加瓦
langchain总述#
langchain官网：
https://python.langchain.com/v0.2/docs/introduction/
一句话说清#
在和LLM交互的时候，首先需要写prompt，在调用LLM提供的API，解析输出。这里面就有三步，langchain将这三步抽象简化，并且提供了很多组件，他有强大的社区，
有很多好用的东西，方便我们开发LLM的应用程序
是什么？#
基于大语言模型的开发框架（LLM）
大语言模型的一站式开发框架
特点#
简化了大语言模型开发的难度，将和模型交互的各个阶段做抽象组合。
提供了一站式的开发框架，包括开发，部署，观测
简化了llm应用生命周期阶段，包括
开发：Langchain提供了很多的组件，模块来构建应用程序，并且有有强大的社区生态。
生产：LangSmith可以检查、监控和评估chain。
部署：LangServe可以将chain暴露给外部服务来使用（API）
----------------------------------------------------------------------------------------------------
Document 2:
欢迎来到我的langchain的学习手册#
langchain最近很火热，在这里记录我对langchain的学习。
欢迎大家一块添砖加瓦
langchain总述#
langchain官网：
https://python.langchain.com/v0.2/docs/introduction/
一句话说清#
在和LLM交互的时候，首先需要写prompt，在调用LLM提供的API，解析输出。这里面就有三步，langchain将这三步抽象简化，并且提供了很多组件，他有强大的社区，
有很多好用的东西，方便我们开发LLM的应用程序
是什么？#
基于大语言模型的开发框架（LLM）
大语言模型的一站式开发框架
特点#
简化了大语言模型开发的难度，将和模型交互的各个阶段做抽象组合。
提供了一站式的开发框架，包括开发，部署，观测
简化了llm应用生命周期阶段，包括
开发：Langchain提供了很多的组件，模块来构建应用程序，并且有有强大的社区生态。
生产：LangSmith可以检查、监控和评估chain。
部署：LangServe可以将chain暴露给外部服务来使用（API）
组合Filter(DocumentCompressorPipeline)#
一个组合各个Filter的Pipeline，在下面的例子中，从向量数据库中查出来原始的文档后，首先使用CharacterTextSplitter对文档做切分，按照\n,之后使用EmbeddingsRedundantFilter剔除掉重复的文档，在使用EmbeddingsFilter做相似性查找，在使用LLMChainExtractor做内容提取和压缩。
from langchain.retrievers.document_compressors import DocumentCompressorPipeline
from langchain_community.document_transformers import EmbeddingsRedundantFilter
from langchain_text_splitters import CharacterTextSplitter
splitter = CharacterTextSplitter(chunk_size=300, chunk_overlap=0, separator="\n")
redundant_filter = EmbeddingsRedundantFilter(embeddings=embeddings)
relevant_filter = EmbeddingsFilter(embeddings=embeddings, similarity_threshold=0.76)
pipeline_compressor = DocumentCompressorPipeline(
transformers=[splitter,redundant_filter,relevant_filter]
)
compression_retriever = ContextualCompressionRetriever(
base_compressor=pipeline_compressor, base_retriever=retriever
)
compressed_docs = compression_retriever.invoke(
"LangChain的特点是什么"
)
pretty_print_docs(compressed_docs)
Document 1:
大语言模型的一站式开发框架
特点#
简化了大语言模型开发的难度，将和模型交互的各个阶段做抽象组合。
提供了一站式的开发框架，包括开发，部署，观测
简化了llm应用生命周期阶段，包括
开发：Langchain提供了很多的组件，模块来构建应用程序，并且有有强大的社区生态。
生产：LangSmith可以检查、监控和评估chain。
部署：LangServe可以将chain暴露给外部服务来使用（API）
----------------------------------------------------------------------------------------------------
Document 2:
欢迎来到我的langchain的学习手册#
langchain最近很火热，在这里记录我对langchain的学习。
欢迎大家一块添砖加瓦
langchain总述#
langchain官网：
https://python.langchain.com/v0.2/docs/introduction/
一句话说清#
在和LLM交互的时候，首先需要写prompt，在调用LLM提供的API，解析输出。这里面就有三步，langchain将这三步抽象简化，并且提供了很多组件，他有强大的社区，
有很多好用的东西，方便我们开发LLM的应用程序
是什么？#
基于大语言模型的开发框架（LLM）
上面没有添加压缩，下面增加压缩
compressor_fitler = LLMChainExtractor.from_llm(llm)
pipeline_compressor = DocumentCompressorPipeline(
transformers=[splitter,redundant_filter,relevant_filter,compressor_fitler]
)
compression_retriever = ContextualCompressionRetriever(
base_compressor=pipeline_compressor, base_retriever=retriever
)
compressed_docs = compression_retriever.invoke(
"LangChain的特点是什么"
)
pretty_print_docs(compressed_docs)
[chain/start] [retriever:Retriever > chain:LLMChain] Entering Chain run with input:
{
"question": "LangChain的特点是什么",
"context": "大语言模型的一站式开发框架\n特点#\n简化了大语言模型开发的难度，将和模型交互的各个阶段做抽象组合。\n提供了一站式的开发框架，包括开发，部署，观测\n简化了llm应用生命周期阶段，包括\n开发：Langchain提供了很多的组件，模块来构建应用程序，并且有有强大的社区生态。\n生产：LangSmith可以检查、监控和评估chain。\n部署：LangServe可以将chain暴露给外部服务来使用（API）"
}
[llm/start] [retriever:Retriever > chain:LLMChain > llm:OpenAI] Entering LLM run with input:
{
"prompts": [
"Given the following question and context, extract any part of the context *AS IS* that is relevant to answer the question. If none of the context is relevant return NO_OUTPUT. \n\nRemember, *DO NOT* edit the extracted parts of the context.\n\n> Question: LangChain的特点是什么\n> Context:\n>>>\n大语言模型的一站式开发框架\n特点#\n简化了大语言模型开发的难度，将和模型交互的各个阶段做抽象组合。\n提供了一站式的开发框架，包括开发，部署，观测\n简化了llm应用生命周期阶段，包括\n开发：Langchain提供了很多的组件，模块来构建应用程序，并且有有强大的社区生态。\n生产：LangSmith可以检查、监控和评估chain。\n部署：LangServe可以将chain暴露给外部服务来使用（API）\n>>>\nExtracted relevant parts:"
]
}
[llm/end] [retriever:Retriever > chain:LLMChain > llm:OpenAI] [5.03s] Exiting LLM run with output:
{
"generations": [
[
{
"text": "\n- 简化了大语言模型开发的难度，将和模型交互的各个阶段做抽象组合。\n- 提供了一站式的开发框架，包括开发，部署，观测\n- 简化了llm应用生命周期阶段，包括\n- 开发：Langchain提供了很多的组件，模块来构建应用程序，并且有有强大的社区生态。\n- 生产：LangSmith可以检查、监控和评估chain。\n- 部署：LangServe可以将chain暴露给外部服务来使用（API）",
"generation_info": {
"finish_reason": "stop",
"logprobs": null
},
"type": "Generation"
}
]
],
"llm_output": {
"token_usage": {
"total_tokens": 430,
"completion_tokens": 174,
"prompt_tokens": 256
},
"model_name": "gpt-3.5-turbo-instruct"
},
"run": null
}
[chain/end] [retriever:Retriever > chain:LLMChain] [5.03s] Exiting Chain run with output:
{
"text": "\n- 简化了大语言模型开发的难度，将和模型交互的各个阶段做抽象组合。\n- 提供了一站式的开发框架，包括开发，部署，观测\n- 简化了llm应用生命周期阶段，包括\n- 开发：Langchain提供了很多的组件，模块来构建应用程序，并且有有强大的社区生态。\n- 生产：LangSmith可以检查、监控和评估chain。\n- 部署：LangServe可以将chain暴露给外部服务来使用（API）"
}
[chain/start] [retriever:Retriever > chain:LLMChain] Entering Chain run with input:
{
"question": "LangChain的特点是什么",
"context": "欢迎来到我的langchain的学习手册#\nlangchain最近很火热，在这里记录我对langchain的学习。\n欢迎大家一块添砖加瓦\nlangchain总述#\nlangchain官网：\nhttps://python.langchain.com/v0.2/docs/introduction/\n一句话说清#\n在和LLM交互的时候，首先需要写prompt，在调用LLM提供的API，解析输出。这里面就有三步，langchain将这三步抽象简化，并且提供了很多组件，他有强大的社区，\n有很多好用的东西，方便我们开发LLM的应用程序\n是什么？#\n基于大语言模型的开发框架（LLM）"
}
[llm/start] [retriever:Retriever > chain:LLMChain > llm:OpenAI] Entering LLM run with input:
{
"prompts": [
"Given the following question and context, extract any part of the context *AS IS* that is relevant to answer the question. If none of the context is relevant return NO_OUTPUT. \n\nRemember, *DO NOT* edit the extracted parts of the context.\n\n> Question: LangChain的特点是什么\n> Context:\n>>>\n欢迎来到我的langchain的学习手册#\nlangchain最近很火热，在这里记录我对langchain的学习。\n欢迎大家一块添砖加瓦\nlangchain总述#\nlangchain官网：\nhttps://python.langchain.com/v0.2/docs/introduction/\n一句话说清#\n在和LLM交互的时候，首先需要写prompt，在调用LLM提供的API，解析输出。这里面就有三步，langchain将这三步抽象简化，并且提供了很多组件，他有强大的社区，\n有很多好用的东西，方便我们开发LLM的应用程序\n是什么？#\n基于大语言模型的开发框架（LLM）\n>>>\nExtracted relevant parts:"
]
}
[llm/end] [retriever:Retriever > chain:LLMChain > llm:OpenAI] [7.42s] Exiting LLM run with output:
{
"generations": [
[
{
"text": "\n- langchain最近很火热，在这里记录我对langchain的学习。\n- langchain总述#\n- langchain官网：\nhttps://python.langchain.com/v0.2/docs/introduction/\n- 一句话说清#\n- 在和LLM交互的时候，首先需要写prompt，在调用LLM提供的API，解析输出。这里面就有三步，langchain将这三步抽象简化，并且提供了很多组件，他有强大的社区，\n有很多好用的东西，方便我们开发LLM的应用程序\n- 是什么？#\n- 基于大语言模型的开发框架（LLM）",
"generation_info": {
"finish_reason": "stop",
"logprobs": null
},
"type": "Generation"
}
]
],
"llm_output": {
"token_usage": {
"total_tokens": 468,
"completion_tokens": 184,
"prompt_tokens": 284
},
"model_name": "gpt-3.5-turbo-instruct"
},
"run": null
}
[chain/end] [retriever:Retriever > chain:LLMChain] [7.42s] Exiting Chain run with output:
{
"text": "\n- langchain最近很火热，在这里记录我对langchain的学习。\n- langchain总述#\n- langchain官网：\nhttps://python.langchain.com/v0.2/docs/introduction/\n- 一句话说清#\n- 在和LLM交互的时候，首先需要写prompt，在调用LLM提供的API，解析输出。这里面就有三步，langchain将这三步抽象简化，并且提供了很多组件，他有强大的社区，\n有很多好用的东西，方便我们开发LLM的应用程序\n- 是什么？#\n- 基于大语言模型的开发框架（LLM）"
}
Document 1:
- 简化了大语言模型开发的难度，将和模型交互的各个阶段做抽象组合。
- 提供了一站式的开发框架，包括开发，部署，观测
- 简化了llm应用生命周期阶段，包括
- 开发：Langchain提供了很多的组件，模块来构建应用程序，并且有有强大的社区生态。
- 生产：LangSmith可以检查、监控和评估chain。
- 部署：LangServe可以将chain暴露给外部服务来使用（API）
----------------------------------------------------------------------------------------------------
Document 2:
- langchain最近很火热，在这里记录我对langchain的学习。
- langchain总述#
- langchain官网：
https://python.langchain.com/v0.2/docs/introduction/
- 一句话说清#
- 在和LLM交互的时候，首先需要写prompt，在调用LLM提供的API，解析输出。这里面就有三步，langchain将这三步抽象简化，并且提供了很多组件，他有强大的社区，
有很多好用的东西，方便我们开发LLM的应用程序
- 是什么？#
- 基于大语言模型的开发框架（LLM）
自定义#
在自定义的时候要实现BaseRetriever接口，并且实现两个方法
_get_relevant_documents_aget_relevant_documents在这里做一个字符串查询
from typing import List
from langchain_core.callbacks import CallbackManagerForRetrieverRun
from langchain_core.documents import Document
from langchain_core.retrievers import BaseRetriever
class ToyRetriever(BaseRetriever):
documents: List[Document]
def _get_relevant_documents(
self, query: str, *, run_manager: CallbackManagerForRetrieverRun
) -> List[Document]:
"""Sync implementations for retriever."""
matching_documents = []
for document in self.documents:
if query.lower() in document.page_content.lower():
matching_documents.append(document)
return matching_documents
from langchain_core.documents import Document
documents = [
Document(
page_content="今天的天气真好",
metadata={"type": "dog", "trait": "loyalty"},
),
Document(
page_content="南京市的天气正好",
metadata={"type": "cat", "trait": "independence"},
),
Document(
page_content="南京是今天下雨了，天气真好",
metadata={"type": "fish", "trait": "low maintenance"},
)
]
retriever = ToyRetriever(documents=documents)
datas = retriever.invoke("南京")
print(datas)
[Document(page_content='南京市的天气正好', metadata={'type': 'cat', 'trait': 'independence'}), Document(page_content='南京是今天下雨了，天气真好', metadata={'type': 'fish', 'trait': 'low maintenance'})]
Long-Context Reorder（重排文档顺序）#
一般来说，一次对话，包含10个或者更多检索到的文档的时候，性能会显著下降，模型会忽略提供的文档。 处理这个问题的方式是：将排序到的文档后重新排序，来避免性能下降
from langchain_community.document_transformers import LongContextReorder
retriever = db.as_retriever(search_kwargs={'k': 3})
documents = retriever.invoke("LangChain的特点是什么")
reordering = LongContextReorder()
reordering.transform_documents(documents) # 在这个方法里面重新排序文章
[Document(page_content='欢迎来到我的langchain的学习手册#\nlangchain最近很火热，在这里记录我对langchain的学习。\n欢迎大家一块添砖加瓦\n\n\nlangchain总述#\nlangchain官网：\nhttps://python.langchain.com/v0.2/docs/introduction/\n\n一句话说清#\n在和LLM交互的时候，首先需要写prompt，在调用LLM提供的API，解析输出。这里面就有三步，langchain将这三步抽象简化，并且提供了很多组件，他有强大的社区，\n有很多好用的东西，方便我们开发LLM的应用程序\n\n\n是什么？#\n\n基于大语言模型的开发框架（LLM）\n大语言模型的一站式开发框架\n\n特点#\n\n简化了大语言模型开发的难度，将和模型交互的各个阶段做抽象组合。\n提供了一站式的开发框架，包括开发，部署，观测\n简化了llm应用生命周期阶段，包括\n\n开发：Langchain提供了很多的组件，模块来构建应用程序，并且有有强大的社区生态。\n生产：LangSmith可以检查、监控和评估chain。\n部署：LangServe可以将chain暴露给外部服务来使用（API）', metadata={'language': 'en', 'source': 'https://daliuchen.github.io/langchain-guide/intro.html', 'title': '欢迎来到我的langchain的学习手册 — langchan study guide'}),
Document(page_content='next\nhappy path\n\n Contents\n \n\n\n欢迎来到我的langchain的学习手册\nlangchain总述\n一句话说清\n是什么？\n特点\n整体架构\n\n\nBy liuchen\n\n\n \n © Copyright 2023.', metadata={'language': 'en', 'source': 'https://daliuchen.github.io/langchain-guide/intro.html', 'title': '欢迎来到我的langchain的学习手册 — langchan study guide'}),
Document(page_content='欢迎来到我的langchain的学习手册#\nlangchain最近很火热，在这里记录我对langchain的学习。\n欢迎大家一块添砖加瓦\n\n\nlangchain总述#\nlangchain官网：\nhttps://python.langchain.com/v0.2/docs/introduction/\n\n一句话说清#\n在和LLM交互的时候，首先需要写prompt，在调用LLM提供的API，解析输出。这里面就有三步，langchain将这三步抽象简化，并且提供了很多组件，他有强大的社区，\n有很多好用的东西，方便我们开发LLM的应用程序\n\n\n是什么？#\n\n基于大语言模型的开发框架（LLM）\n大语言模型的一站式开发框架\n\n特点#\n\n简化了大语言模型开发的难度，将和模型交互的各个阶段做抽象组合。\n提供了一站式的开发框架，包括开发，部署，观测\n简化了llm应用生命周期阶段，包括\n\n开发：Langchain提供了很多的组件，模块来构建应用程序，并且有有强大的社区生态。\n生产：LangSmith可以检查、监控和评估chain。\n部署：LangServe可以将chain暴露给外部服务来使用（API）', metadata={'language': 'en', 'source': 'https://daliuchen.github.io/langchain-guide/intro.html', 'title': '欢迎来到我的langchain的学习手册 — langchan study guide'})]
多向量检索器（MultiVector Retriever）#
LLM开发的一个重点是检索到文档的相似度越高越好，对于一个文档，他的向量越多越好，这样他被查找到的可能性就越大，有下面的三种方式可以做到
Smaller chunks
Summary
Hypothetical Queries)
下面有详细的介绍
from langchain_text_splitters import RecursiveCharacterTextSplitter
loaders = [
WebBaseLoader(web_path="https://blog.csdn.net/daliucheng/article/details/136160807"),
]
docs = []
for loader in loaders:
docs.extend(loader.load())
text_splitter = RecursiveCharacterTextSplitter(chunk_size=10000)
docs = text_splitter.split_documents(docs)
for item in docs:
print(len(item.page_content))
9893
5746
Smaller chunks#
将文档切分为小块，查找的时候通过小块查找，返回的时候会将小块所关联的父文档返回，在下面的例子中 上面加载了文档，切分为了两个文档，之后遍历每个文档，将它切分为400个字符的的小块，做Embedding操作。 在搜索到结果之后，会返回每个小文档的父文档。
from langchain.retrievers import MultiVectorRetriever
from langchain_core.stores import InMemoryByteStore
# The vectorstore to use to index the child chunks
vectorstore = Chroma(
collection_name="full_documents", embedding_function=OpenAIEmbeddings()
)
# 最终，父文档会存储在这里，通过uuid来标识，每个子文档中的metadata中都有一个doc_id的key，关联到父文档
store = InMemoryByteStore()
id_key = "doc_id"
# The retriever (empty to start)
retriever = MultiVectorRetriever(
vectorstore=vectorstore,
byte_store=store,
id_key=id_key,
)
import uuid
doc_ids = [str(uuid.uuid4()) for _ in docs]
# The splitter to use to create smaller chunks
child_text_splitter = RecursiveCharacterTextSplitter(chunk_size=400)
sub_docs = []
for i, doc in enumerate(docs):
_id = doc_ids[i]
_sub_docs = child_text_splitter.split_documents([doc])
for _doc in _sub_docs:
_doc.metadata[id_key] = _id
sub_docs.extend(_sub_docs)
# 将子文档存储在向量数据库中
retriever.vectorstore.add_documents(sub_docs)
# 将父文档存储起来
retriever.docstore.mset(list(zip(doc_ids, docs)))
# 通过这种方式，直接查找的是分割出来的小文档
len(retriever.vectorstore.similarity_search("WebDriver是什么"))
4
# 通过它，返回的子文档关联的父文档,返回的是第一个文档
len(retriever.invoke("WebDriver是什么")[0].page_content)
9893
汇总总结（Summary）#
import uuid
from langchain_core.documents import Document
from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI
"".strip()
chain = (
{"doc": lambda x: x.page_content.strip().replace("\n","").replace("\t","").replace(" ","")}
| ChatPromptTemplate.from_template("总结下面文档的内容:\n\n{doc}")
| ChatOpenAI(max_retries=0)
| StrOutputParser()
)
# 先对每个文章做总结
summaries = chain.batch(docs, {"max_concurrency": 5})
[chain/start] [chain:RunnableSequence] Entering Chain run with input:
[inputs]
[chain/start] [chain:RunnableSequence] Entering Chain run with input:
[inputs]
[chain/start] [chain:RunnableSequence > chain:RunnableParallel<doc>] Entering Chain run with input:
[inputs]
[chain/start] [chain:RunnableSequence > chain:RunnableParallel<doc>] Entering Chain run with input:
[inputs]
[chain/start] [chain:RunnableSequence > chain:RunnableParallel<doc> > chain:RunnableLambda] Entering Chain run with input:
[inputs]
[chain/end] [chain:RunnableSequence > chain:RunnableParallel<doc> > chain:RunnableLambda] [0ms] Exiting Chain run with output:
{
"output": "CDP和Chrome_chromedevtoolsprotocol-CSDN博客CDP和Chromedaliucheng已于 2024-02-1900:07:33 修改阅读量1.7k收藏21点赞数27分类专栏：自动化测试文章标签：chrome自动化pythonnode.js于 2024-02-1823:45:32 首次发布版权声明：本文为博主原创文章，遵循CC4.0BY-SA版权协议，转载请附上原文出处链接和本声明。本文链接：https://blog.csdn.net/daliucheng/article/details/136160807版权自动化测试专栏收录该内容1篇文章0订阅订阅专栏CDP和ChromeCDP和WebDriverProtocolWebDriver和ChromeDevToolsProtocol（CDP）是用于自动化浏览器的两个主要协议，大多数的浏览器自动化工具都是基于上述其中之一来实现的。可以通过这两种形式来和浏览器交互，通过代码来控制浏览器，完成浏览器的自动化行为（包括网页加载，爬虫，截图，导出pdf等）。WebDriverProtocol官网地址：链接WebDriver是一个用于控制浏览器的远程控制接口，由SeleniumHQ开发，后来由W3C标准化。它提供了一个平台和语言中立的接口，支持几乎所有主流浏览器，如Chrome、Firefox、Safari、Edge、Opera等。它和浏览器的通信是通过JSONWire协议完成的，提供了RESTful的web服务，这个服务端就被称为服务端（也被称为webdriver），例如chromeDriver、geckoDriver等。有服务端就有客户端，客户端可以选择任何语言，客户端和服务端交互，服务端和浏览器交互，从而操作浏览器。常见的客户端就是selenium,nightwatch,webdriverio加上我们的自己写的自动化测试代码之后，交互流程如下：ChromeDevToolsProtocol官网地址：链接ChromeDevToolsProtocol(CDP)是一个基于Chromium的浏览器的调试协议，如Chrome、Edge、Opera等。通过它可以直接和浏览器交互。控制浏览器的行为。客户端和浏览器之间没有类似于WebDriverProtocol的服务端（webdriver），而是客户端通过WebSocket直接和浏览器连类似网络驱动服务器(浏览器驱动程序)的中间人。相反，浏览器是由客户端使用CDP直接控制的。与浏览器的通信是通过套接字连接完成的，因此也支持双向通信。客户端通过WebSocket发送命令给浏览器，浏览器执行并返回响应。两个相当流行的工具是Puppeteer和Playwright。它们不依赖于webdriver，而是通过ChromeDevToolsProtocol(CDP)直接与浏览器通话。从而更加灵活稳定的控制浏览器。区别从代码层面来看，使用的代码接近底层，接近浏览器，代码就会变得更加的稳定和强大，但对于跨浏览器的支持会变得更少。另一方面，代码和浏览器的之间的抽象程度越高，支持的浏览器就越多，但代码会变得不稳定并且功能受限。对比上面两种WebDriverProtocol支持的浏览器多，但不是很稳定，并且功能不强大。ChromeDevToolsProtocol支持的浏览器少（只是相对WebDriver来说，Chrome能支持就能用），功能强大，稳定。WebdriverProtocolChromeDevToolsProtocolDevelopedby:W3CDevelopedby:ChromeDeveloperTools需要webdriver不需要webdriver相对较慢并且不是很稳定速度快，较稳定支持的浏览器多支持部分浏览器无法通过提供的api来访问浏览器中网络相关的信息可以通过api来访问网络相关的信息它的实现有：SeleniumWebDriver3,WebdriverIO,Nightwatch它的实现有：Playwright,Puppeteer,SeleniumWebdriver4,Cypressv7不同的WebDriver有不同的实现方式，chromeDriver内部是通过DevToolsprotoco来控制浏览器的。如何选择如果跨浏览器很重要，就选webDriver，否则选择CDPpuppeteer链接：官网，github，github-examplesPuppeteer是Chrome开发团队在2017年发布的一个Node.js包，是它提供了一个高级API，通过DevTools协议控制Chrome/Chromium。为什么选择它？两个理由github中star数多Chrome开发团队可以做什么？简单来说，浏览器能做的，它都能做截图和生成PDF爬取SPA或SSR网站UI自动化测试…版本说明从v1.7.0版本以来，每次发布都会发布两个软件包：puppeteer它会自动下载一个最新版本的Chrome用于测试（macOS约170MB，Linux约282MB，Windows约280MB）以及一个chrome-headless-shell二进制文件（从Puppeteerv21.6.0开始），这个二进制文件保证可以与Puppeteer配合正常工作。默认情况下，浏览器会下载到$HOME/.cache/puppeteer文件夹中（从Puppeteerv19.0.0开始）。通过puppeteer-core控制它下载的浏览器puppeteer-corepuppeteer-core是一个库，用于帮助驱动任何支持DevTools协议的内容。它不会下载浏览器，它提供了封装好的API和浏览器交互。如果自己已经下载了浏览器，就可以使用它，但是必须在调用puppeteer.launch的时候显式的指定executablePath(浏览器的执行位置)一般来说我会使用这个代码建议看这篇文章结合项目来谈谈Puppeteer在结合github-examples的例子。注意点在部署的时候，建议使用容器化，Chrome本身是内存大户，如果遇到内存飙升，代码是不太好发现这种情况的，不能及时kill掉。在加载网页的时候不建议每次都关闭和开启一个新的。Chrome的启动和关系是比较耗时的，每次启动会慢150ms到300ms建议重复使用同一个Chrome。Chrome使用一段时间之后，要关掉重启。Chrome在我们自己的电脑中有的时候，页面都会崩溃，浏览器也会崩溃。在服务器这种情况下，肯定也会出现，建议在内存中设置调用阈值，比如加载了100个网页，重启一次。这样可降低崩溃的概率。容器化部署之后，建议一个容器中只启动一个Chrome。这样会让代码简单并且出现问题好排查。这就要求Chrome在代码中是单例在整个Chrome做操作期间，对Chrome崩溃的情况做处理在业务代码期间，建议使用trycatch来捕获异常，对于非业务异常，需要关闭掉Chrome。防止出现多个Chrome。Chrome在关闭的时候出现异常，也需要处理在调用close()api来关闭Chrome的时候，可能会报错（可能Chrome在这个时候被操作系统kill掉，会出现孤儿进程）。建议：在这个时候直接通过shell脚本来强行kill掉#!/bin/bashpids=$(ps-ef|grep\"[c]hrome\"|grep-v'kill_chrome_processes.sh'|awk'{print$2}')forpidin$pids;doecho\"TerminatingPID$pid\"kill$piddoneecho\"Allchromeprocesseshavebeenterminated.\"孤儿进程：父进程启动了子进程，子进程在没有退出的情况下，父进程退出了。此时子进程会被init进程接管。尽量关闭掉无用的功能，让他越简单越好。比如：-no-sandbox,--disable-extensions,--disable-gpu,--disable_scrollbars共享内存Chrome默认使用/dev/shm共享内存，但是docker默认/dev/shm只有64MB，显然是不够使用的，提供两种方式来解决：启动docker时添加参数--shm-size=1gb来增大/dev/shm共享内存，但是swarm目前不支持shm-size参数启动Chrome添加参数-disable-dev-shm-usage，禁止使用/dev/shm共享内存参考文档https://www.neovasolutions.com/2022/05/19/browser-automation-tools-protocols-webdriver-vs-cdp/https://dev.to/jankaritech/different-approaches-protocols-to-automate-the-browser-39f1https://stackoverflow.com/questions/50939116/what-is-the-difference-between-webdriver-and-devtool-protocolhttps://zhuanlan.zhihu.com/p/76237595关于博客这件事，我是把它当做我的笔记，里面有很多的内容反映了我思考的过程，因为思维有限，不免有些内容有出入，如果有问题，欢迎指出。一同探讨。谢谢。确定要放弃本次机会？福利倒计时::立减¥普通VIP年卡可用立即使用daliucheng关注关注27点赞踩21收藏觉得还不错?一键收藏知道了0评论CDP和ChromeWebDriver和是用于自动化浏览器的两个主要协议，大多数的浏览器自动化工具都是基于上述其中之一来实现的。可以通过这两种形式来和浏览器交互，通过代码来控制浏览器，完成浏览器的自动化行为（包括网页加载，爬虫，截图，导出pdf等）。复制链接扫一扫专栏目录Pythoncdp(ChromeDevToolsProtocol)爬虫墨鱼菜鸡07-113265devtools-protocol：https://github.com/ChromeDevTools/devtools-protocolChromeDevToolsProtocol：https://chromedevtools.github.io/devtools-protocol/AwesomeChromeDevTools：https:...ChromeDevToolsProtocol(谷歌开发者工具协议)ProtocolMonitor（协议监视器）llrraa2010的专栏06-102633该协议最初是由谷歌开发者工具团队维护的，负责调试、操作浏览器的协议。我们经常使用到的谷歌浏览器的开发者工具（快捷键CTRL+SHIFT+I或者F12）就是使用这个协议来操作浏览器的。与Selenium需要与浏览器驱动进行交互不同的是，ChromeDevTools协议直接通过WebSocket协议与浏览器暴露的API进行通信，这使得ChromeDevTools协议操作浏览器变得更快。我们要重启开发者工具，在右侧点击更多工具，这样就可以看到协议监视器面板了。参与评论您还未登录，请先登录后发表或查看评论探索Web开发新维度：Devtools-Protocol最新发布gitblog_00001的博客05-15353探索Web开发新维度：Devtools-Protocol项目地址:https://gitcode.com/ChromeDevTools/devtools-protocol项目介绍在Web开发的世界中，ChromeDevToolsProtocol（DTP）是连接开发者和浏览器内核的桥梁，它允许我们进行深度的调试、性能分析以及自动化测试。而devtools-protocol是一个官方维护的开...usus使用Chrome调试协议CDP渲染页面08-08usus使用Chrome调试协议（CDP）渲染页面。提取用于渲染页面的CSS。渲染带有阻塞CSS的HTML异步。浏览器自动化必须知道CDP协议白天安全建设，晚上全栈开发，大模型爱好者。公众号：飞羽技术工坊。01-131067之前搞自动化页面，因为有一个获取网络日志的需求，让我发现了新的知识盲区——CDP协议。ChromeDevTools通过cdp调节CPUThrottling时丶光11-26927打开DevTools(快捷键ctrl+shift+i)在DevTools界面再打开DevToolsletMain=awaitimport('./devtools-frontend/front_end/entrypoints/main/main.js');//or'./entrypoints/main/main.js'or'./main/main.js'dependingonthebrowserversion//设置CPUThrottling为本机cdp:软件包cdp为使用Go编程语言编写的ChromeDevTools协议（CDP）提供了类型安全的绑定05-04光盘软件包cdp为使用Go编程语言编写的（CDP）提供了类型安全的绑定。绑定是由根据最新协议定义生成的，并且主要用于GoogleChrome或Chromium，但是它们可以与任何调试目标（，，等）。通过ChromeDevTools协议，该软件包可用于任何类型的浏览器自动化，脚本编写或调试。cdp主要动机是公开ChromeDevTools协议的全部功能，并以一种可发现的自记录方式提供它。提供高级浏览器自动化对于该项目而言是不可行的。话虽如此，cdp希望通过提供更适合Go的原语并自动执行重复性任务来改善使用该协议的人体工程学。特征适用于ChromeDevTools协议的可发现API（GoDoc，自动完成友好）作为头等公民的情况（用于超时和取消）简单且同步的事件处理（无回调）同时安全没有无声或隐藏的错误做到用户期望的尽可能将CDP类型与ichrome：适用于人类的Chrome控制器，基于ChromeDevtools协议（CDP）和python3.7+01-31适用于人类的Chrome控制器，基于和python3.7+。为什么？Pyppeteer很棒，但是我不需要那么多pyppeteer的拼写很混乱事件驱动的编程并非总是明智的。Selenium慢网络驱动程序经常带有内存泄漏。迫切需要一个稳定的...selenium_cdp：Selenium4x，执行ChromeDevTools协议命令01-31该项目采用JavaSelenium4.0.x版本的来执行（也称为cdp命令），这是一套完全不同的API，通过对/session/$sessionId/goog/cdp/executePOSTPOST传达给Chrome浏览器系列，特定的有效负载）功能（许多cdp方法，例如...cdp4j：cdp4j-适用于Java的ChromeDevTools协议01-28cdp4j是Java库，具有清晰简洁的API，可自动执行基于Chrome/Chromium的浏览器。它使用GoogleChromeDevTools协议来自动化基于Chrome/Chromium的浏览器。cdp4j可以做什么？自动填写表格。您可以轻松下载和...getting-started-with-cdp:ChromeDevTools协议入门07-24使用ChromeDevTools协议在直接使用CDP进行浏览器自动化之前要三思。有会让你过得更好不服气？至少使用。另请参阅介绍注意：://vanilla.aslushnikov.com提供了交互式协议查看器。ChromeDevTools协议...Chrome之远程调试协议（Remotedebuggingprotocol）-Div.IOweixin_33940102的博客06-271781Chrome之远程调试协议（Remotedebuggingprotocol）-Div.IO一文读懂UI自动化测试三种核心实现原理：Native、Webdriver和CDPliwenxiang629的博客04-03808相信80%的UI自动化测试工程师在进行岗位面试的时候都会重点讲解自己会使用哪些工具，例如cypress、selenium、playwright等等。其实这只是初级段位，如果大家想谈得再高大上一些，就可以谈谈这些工具与浏览器talk的原理了，绝对会得到面试官的重视！目前主流主动化测试工具与浏览器沟通的原理主要包括：Native、Webdriver以及CDP，使用这三种方式的典型代表工具分别是：cypress、selenium和playwright。今天我就对此进行总结：朋友们，一起学习下ChromeDevToolsProtocol。z_l_x_的博客10-1830721947年9月9日，Firstactualcaseofbugbeingfound，自此引入了Debugging。CDP远程调试方案老司机的后备箱05-233656什么是cdp协议cdp协议简称chrome调试协议，是基于scoket（websocket、usb、adb）消息的jsonrpc协议。用来调用chrome内部的方法实现js，css，dom的开发调试。可以将实现了cdp协议的应用看做rpc调用的服务端（chrome，puppeteer），将调试面板看做rpc调用的客户端（devtools）。devtools调试系统完整的调试系统分别由前端，后端，协议，通道四部分组成Frontend：调试器前端GoChromedp库得使用----CDP（ChromeDevToolsProtocol)路小白的博客12-248813Gochromedp库的使用—CDP文章目录Gochromedp库的使用---CDPCDP（ChromeDevToolsProtocol)基于CDP协议的相关语言操作Chromedp使用示例本地界面浏览器操作远程操作示例（无头浏览器）Centos安装chronium-headless示例代码Browsesrless/chrome部署Linux-Centos安装NodeJS参考CDP（ChromeDevToolsProtocol)ChromeDevToolsProtocol是基.【学习笔记】seleniumChromeDriver移除navigator.webdriver属性MONKEYMONEY_的博客12-16906作为新手的我，在刚接触selenium时不了解的ChromeDriver一些常用属性和方法。为此特意记录了以下几项并加上注释，方便以后查阅调用。Selenium中的ChromeOptions选项chromeOptions是一个配置chrome启动属性的类。通过这个类，我们可以为chrome配置如下参数（这个部分可以通过selenium源码看到）：设置chrome二进制文件位置(binary_location)添加启动参数(add_argument)添加扩展应用(aChromeDevToolsProtocollocalstorage06-07"
}
[chain/end] [chain:RunnableSequence > chain:RunnableParallel<doc>] [2ms] Exiting Chain run with output:
{
"doc": "CDP和Chrome_chromedevtoolsprotocol-CSDN博客CDP和Chromedaliucheng已于 2024-02-1900:07:33 修改阅读量1.7k收藏21点赞数27分类专栏：自动化测试文章标签：chrome自动化pythonnode.js于 2024-02-1823:45:32 首次发布版权声明：本文为博主原创文章，遵循CC4.0BY-SA版权协议，转载请附上原文出处链接和本声明。本文链接：https://blog.csdn.net/daliucheng/article/details/136160807版权自动化测试专栏收录该内容1篇文章0订阅订阅专栏CDP和ChromeCDP和WebDriverProtocolWebDriver和ChromeDevToolsProtocol（CDP）是用于自动化浏览器的两个主要协议，大多数的浏览器自动化工具都是基于上述其中之一来实现的。可以通过这两种形式来和浏览器交互，通过代码来控制浏览器，完成浏览器的自动化行为（包括网页加载，爬虫，截图，导出pdf等）。WebDriverProtocol官网地址：链接WebDriver是一个用于控制浏览器的远程控制接口，由SeleniumHQ开发，后来由W3C标准化。它提供了一个平台和语言中立的接口，支持几乎所有主流浏览器，如Chrome、Firefox、Safari、Edge、Opera等。它和浏览器的通信是通过JSONWire协议完成的，提供了RESTful的web服务，这个服务端就被称为服务端（也被称为webdriver），例如chromeDriver、geckoDriver等。有服务端就有客户端，客户端可以选择任何语言，客户端和服务端交互，服务端和浏览器交互，从而操作浏览器。常见的客户端就是selenium,nightwatch,webdriverio加上我们的自己写的自动化测试代码之后，交互流程如下：ChromeDevToolsProtocol官网地址：链接ChromeDevToolsProtocol(CDP)是一个基于Chromium的浏览器的调试协议，如Chrome、Edge、Opera等。通过它可以直接和浏览器交互。控制浏览器的行为。客户端和浏览器之间没有类似于WebDriverProtocol的服务端（webdriver），而是客户端通过WebSocket直接和浏览器连类似网络驱动服务器(浏览器驱动程序)的中间人。相反，浏览器是由客户端使用CDP直接控制的。与浏览器的通信是通过套接字连接完成的，因此也支持双向通信。客户端通过WebSocket发送命令给浏览器，浏览器执行并返回响应。两个相当流行的工具是Puppeteer和Playwright。它们不依赖于webdriver，而是通过ChromeDevToolsProtocol(CDP)直接与浏览器通话。从而更加灵活稳定的控制浏览器。区别从代码层面来看，使用的代码接近底层，接近浏览器，代码就会变得更加的稳定和强大，但对于跨浏览器的支持会变得更少。另一方面，代码和浏览器的之间的抽象程度越高，支持的浏览器就越多，但代码会变得不稳定并且功能受限。对比上面两种WebDriverProtocol支持的浏览器多，但不是很稳定，并且功能不强大。ChromeDevToolsProtocol支持的浏览器少（只是相对WebDriver来说，Chrome能支持就能用），功能强大，稳定。WebdriverProtocolChromeDevToolsProtocolDevelopedby:W3CDevelopedby:ChromeDeveloperTools需要webdriver不需要webdriver相对较慢并且不是很稳定速度快，较稳定支持的浏览器多支持部分浏览器无法通过提供的api来访问浏览器中网络相关的信息可以通过api来访问网络相关的信息它的实现有：SeleniumWebDriver3,WebdriverIO,Nightwatch它的实现有：Playwright,Puppeteer,SeleniumWebdriver4,Cypressv7不同的WebDriver有不同的实现方式，chromeDriver内部是通过DevToolsprotoco来控制浏览器的。如何选择如果跨浏览器很重要，就选webDriver，否则选择CDPpuppeteer链接：官网，github，github-examplesPuppeteer是Chrome开发团队在2017年发布的一个Node.js包，是它提供了一个高级API，通过DevTools协议控制Chrome/Chromium。为什么选择它？两个理由github中star数多Chrome开发团队可以做什么？简单来说，浏览器能做的，它都能做截图和生成PDF爬取SPA或SSR网站UI自动化测试…版本说明从v1.7.0版本以来，每次发布都会发布两个软件包：puppeteer它会自动下载一个最新版本的Chrome用于测试（macOS约170MB，Linux约282MB，Windows约280MB）以及一个chrome-headless-shell二进制文件（从Puppeteerv21.6.0开始），这个二进制文件保证可以与Puppeteer配合正常工作。默认情况下，浏览器会下载到$HOME/.cache/puppeteer文件夹中（从Puppeteerv19.0.0开始）。通过puppeteer-core控制它下载的浏览器puppeteer-corepuppeteer-core是一个库，用于帮助驱动任何支持DevTools协议的内容。它不会下载浏览器，它提供了封装好的API和浏览器交互。如果自己已经下载了浏览器，就可以使用它，但是必须在调用puppeteer.launch的时候显式的指定executablePath(浏览器的执行位置)一般来说我会使用这个代码建议看这篇文章结合项目来谈谈Puppeteer在结合github-examples的例子。注意点在部署的时候，建议使用容器化，Chrome本身是内存大户，如果遇到内存飙升，代码是不太好发现这种情况的，不能及时kill掉。在加载网页的时候不建议每次都关闭和开启一个新的。Chrome的启动和关系是比较耗时的，每次启动会慢150ms到300ms建议重复使用同一个Chrome。Chrome使用一段时间之后，要关掉重启。Chrome在我们自己的电脑中有的时候，页面都会崩溃，浏览器也会崩溃。在服务器这种情况下，肯定也会出现，建议在内存中设置调用阈值，比如加载了100个网页，重启一次。这样可降低崩溃的概率。容器化部署之后，建议一个容器中只启动一个Chrome。这样会让代码简单并且出现问题好排查。这就要求Chrome在代码中是单例在整个Chrome做操作期间，对Chrome崩溃的情况做处理在业务代码期间，建议使用trycatch来捕获异常，对于非业务异常，需要关闭掉Chrome。防止出现多个Chrome。Chrome在关闭的时候出现异常，也需要处理在调用close()api来关闭Chrome的时候，可能会报错（可能Chrome在这个时候被操作系统kill掉，会出现孤儿进程）。建议：在这个时候直接通过shell脚本来强行kill掉#!/bin/bashpids=$(ps-ef|grep\"[c]hrome\"|grep-v'kill_chrome_processes.sh'|awk'{print$2}')forpidin$pids;doecho\"TerminatingPID$pid\"kill$piddoneecho\"Allchromeprocesseshavebeenterminated.\"孤儿进程：父进程启动了子进程，子进程在没有退出的情况下，父进程退出了。此时子进程会被init进程接管。尽量关闭掉无用的功能，让他越简单越好。比如：-no-sandbox,--disable-extensions,--disable-gpu,--disable_scrollbars共享内存Chrome默认使用/dev/shm共享内存，但是docker默认/dev/shm只有64MB，显然是不够使用的，提供两种方式来解决：启动docker时添加参数--shm-size=1gb来增大/dev/shm共享内存，但是swarm目前不支持shm-size参数启动Chrome添加参数-disable-dev-shm-usage，禁止使用/dev/shm共享内存参考文档https://www.neovasolutions.com/2022/05/19/browser-automation-tools-protocols-webdriver-vs-cdp/https://dev.to/jankaritech/different-approaches-protocols-to-automate-the-browser-39f1https://stackoverflow.com/questions/50939116/what-is-the-difference-between-webdriver-and-devtool-protocolhttps://zhuanlan.zhihu.com/p/76237595关于博客这件事，我是把它当做我的笔记，里面有很多的内容反映了我思考的过程，因为思维有限，不免有些内容有出入，如果有问题，欢迎指出。一同探讨。谢谢。确定要放弃本次机会？福利倒计时::立减¥普通VIP年卡可用立即使用daliucheng关注关注27点赞踩21收藏觉得还不错?一键收藏知道了0评论CDP和ChromeWebDriver和是用于自动化浏览器的两个主要协议，大多数的浏览器自动化工具都是基于上述其中之一来实现的。可以通过这两种形式来和浏览器交互，通过代码来控制浏览器，完成浏览器的自动化行为（包括网页加载，爬虫，截图，导出pdf等）。复制链接扫一扫专栏目录Pythoncdp(ChromeDevToolsProtocol)爬虫墨鱼菜鸡07-113265devtools-protocol：https://github.com/ChromeDevTools/devtools-protocolChromeDevToolsProtocol：https://chromedevtools.github.io/devtools-protocol/AwesomeChromeDevTools：https:...ChromeDevToolsProtocol(谷歌开发者工具协议)ProtocolMonitor（协议监视器）llrraa2010的专栏06-102633该协议最初是由谷歌开发者工具团队维护的，负责调试、操作浏览器的协议。我们经常使用到的谷歌浏览器的开发者工具（快捷键CTRL+SHIFT+I或者F12）就是使用这个协议来操作浏览器的。与Selenium需要与浏览器驱动进行交互不同的是，ChromeDevTools协议直接通过WebSocket协议与浏览器暴露的API进行通信，这使得ChromeDevTools协议操作浏览器变得更快。我们要重启开发者工具，在右侧点击更多工具，这样就可以看到协议监视器面板了。参与评论您还未登录，请先登录后发表或查看评论探索Web开发新维度：Devtools-Protocol最新发布gitblog_00001的博客05-15353探索Web开发新维度：Devtools-Protocol项目地址:https://gitcode.com/ChromeDevTools/devtools-protocol项目介绍在Web开发的世界中，ChromeDevToolsProtocol（DTP）是连接开发者和浏览器内核的桥梁，它允许我们进行深度的调试、性能分析以及自动化测试。而devtools-protocol是一个官方维护的开...usus使用Chrome调试协议CDP渲染页面08-08usus使用Chrome调试协议（CDP）渲染页面。提取用于渲染页面的CSS。渲染带有阻塞CSS的HTML异步。浏览器自动化必须知道CDP协议白天安全建设，晚上全栈开发，大模型爱好者。公众号：飞羽技术工坊。01-131067之前搞自动化页面，因为有一个获取网络日志的需求，让我发现了新的知识盲区——CDP协议。ChromeDevTools通过cdp调节CPUThrottling时丶光11-26927打开DevTools(快捷键ctrl+shift+i)在DevTools界面再打开DevToolsletMain=awaitimport('./devtools-frontend/front_end/entrypoints/main/main.js');//or'./entrypoints/main/main.js'or'./main/main.js'dependingonthebrowserversion//设置CPUThrottling为本机cdp:软件包cdp为使用Go编程语言编写的ChromeDevTools协议（CDP）提供了类型安全的绑定05-04光盘软件包cdp为使用Go编程语言编写的（CDP）提供了类型安全的绑定。绑定是由根据最新协议定义生成的，并且主要用于GoogleChrome或Chromium，但是它们可以与任何调试目标（，，等）。通过ChromeDevTools协议，该软件包可用于任何类型的浏览器自动化，脚本编写或调试。cdp主要动机是公开ChromeDevTools协议的全部功能，并以一种可发现的自记录方式提供它。提供高级浏览器自动化对于该项目而言是不可行的。话虽如此，cdp希望通过提供更适合Go的原语并自动执行重复性任务来改善使用该协议的人体工程学。特征适用于ChromeDevTools协议的可发现API（GoDoc，自动完成友好）作为头等公民的情况（用于超时和取消）简单且同步的事件处理（无回调）同时安全没有无声或隐藏的错误做到用户期望的尽可能将CDP类型与ichrome：适用于人类的Chrome控制器，基于ChromeDevtools协议（CDP）和python3.7+01-31适用于人类的Chrome控制器，基于和python3.7+。为什么？Pyppeteer很棒，但是我不需要那么多pyppeteer的拼写很混乱事件驱动的编程并非总是明智的。Selenium慢网络驱动程序经常带有内存泄漏。迫切需要一个稳定的...selenium_cdp：Selenium4x，执行ChromeDevTools协议命令01-31该项目采用JavaSelenium4.0.x版本的来执行（也称为cdp命令），这是一套完全不同的API，通过对/session/$sessionId/goog/cdp/executePOSTPOST传达给Chrome浏览器系列，特定的有效负载）功能（许多cdp方法，例如...cdp4j：cdp4j-适用于Java的ChromeDevTools协议01-28cdp4j是Java库，具有清晰简洁的API，可自动执行基于Chrome/Chromium的浏览器。它使用GoogleChromeDevTools协议来自动化基于Chrome/Chromium的浏览器。cdp4j可以做什么？自动填写表格。您可以轻松下载和...getting-started-with-cdp:ChromeDevTools协议入门07-24使用ChromeDevTools协议在直接使用CDP进行浏览器自动化之前要三思。有会让你过得更好不服气？至少使用。另请参阅介绍注意：://vanilla.aslushnikov.com提供了交互式协议查看器。ChromeDevTools协议...Chrome之远程调试协议（Remotedebuggingprotocol）-Div.IOweixin_33940102的博客06-271781Chrome之远程调试协议（Remotedebuggingprotocol）-Div.IO一文读懂UI自动化测试三种核心实现原理：Native、Webdriver和CDPliwenxiang629的博客04-03808相信80%的UI自动化测试工程师在进行岗位面试的时候都会重点讲解自己会使用哪些工具，例如cypress、selenium、playwright等等。其实这只是初级段位，如果大家想谈得再高大上一些，就可以谈谈这些工具与浏览器talk的原理了，绝对会得到面试官的重视！目前主流主动化测试工具与浏览器沟通的原理主要包括：Native、Webdriver以及CDP，使用这三种方式的典型代表工具分别是：cypress、selenium和playwright。今天我就对此进行总结：朋友们，一起学习下ChromeDevToolsProtocol。z_l_x_的博客10-1830721947年9月9日，Firstactualcaseofbugbeingfound，自此引入了Debugging。CDP远程调试方案老司机的后备箱05-233656什么是cdp协议cdp协议简称chrome调试协议，是基于scoket（websocket、usb、adb）消息的jsonrpc协议。用来调用chrome内部的方法实现js，css，dom的开发调试。可以将实现了cdp协议的应用看做rpc调用的服务端（chrome，puppeteer），将调试面板看做rpc调用的客户端（devtools）。devtools调试系统完整的调试系统分别由前端，后端，协议，通道四部分组成Frontend：调试器前端GoChromedp库得使用----CDP（ChromeDevToolsProtocol)路小白的博客12-248813Gochromedp库的使用—CDP文章目录Gochromedp库的使用---CDPCDP（ChromeDevToolsProtocol)基于CDP协议的相关语言操作Chromedp使用示例本地界面浏览器操作远程操作示例（无头浏览器）Centos安装chronium-headless示例代码Browsesrless/chrome部署Linux-Centos安装NodeJS参考CDP（ChromeDevToolsProtocol)ChromeDevToolsProtocol是基.【学习笔记】seleniumChromeDriver移除navigator.webdriver属性MONKEYMONEY_的博客12-16906作为新手的我，在刚接触selenium时不了解的ChromeDriver一些常用属性和方法。为此特意记录了以下几项并加上注释，方便以后查阅调用。Selenium中的ChromeOptions选项chromeOptions是一个配置chrome启动属性的类。通过这个类，我们可以为chrome配置如下参数（这个部分可以通过selenium源码看到）：设置chrome二进制文件位置(binary_location)添加启动参数(add_argument)添加扩展应用(aChromeDevToolsProtocollocalstorage06-07"
}
[chain/start] [chain:RunnableSequence > chain:RunnableParallel<doc> > chain:RunnableLambda] Entering Chain run with input:
[inputs]
[chain/end] [chain:RunnableSequence > chain:RunnableParallel<doc> > chain:RunnableLambda] [0ms] Exiting Chain run with output:
{
"output": "设置chrome二进制文件位置(binary_location)添加启动参数(add_argument)添加扩展应用(aChromeDevToolsProtocollocalstorage06-07ChromeDevToolsProtocol可以通过`Runtime.evaluate()`方法来读取和修改本地存储(`localStorage`)的值。以下是一个使用Node.js和`chrome-remote-interface`模块与ChromeDevToolsProtocol交互的例子：```javascriptconstCDP=require('chrome-remote-interface');CDP(asyncfunction(client){const{Runtime}=client;awaitRuntime.enable();//读取localStorage中的值const{result}=awaitRuntime.evaluate({expression:'localStorage.getItem(\"key\")'});console.log(result.value);//设置localStorage中的值awaitRuntime.evaluate({expression:'localStorage.setItem(\"key\",\"value\")'});client.close();}).on('error',(err)=>{console.error('Cannotconnecttobrowser:',err);});```需要注意的是，这个例子只是一个简单的示例，并没有对错误处理进行详细的说明。在实际使用中，需要对错误进行适当的处理，以确保程序的稳定性和可靠性。“相关推荐”对你有帮助么？非常没帮助没帮助一般有帮助非常有帮助提交daliuchengCSDN认证博客专家CSDN认证企业博客码龄7年暂无认证151原创4万+周排名4万+总排名17万+访问等级2170积分303粉丝287获赞51评论709收藏私信关注热门文章Spring定时任务@EnableScheduling解析27879数据库——求候选键的方法16022数据库——求候选键的方法14297Spring-动态数据源6182Mybatis中mapper是怎么和XMl关联起来的5361分类专栏自动化测试1篇go语言21篇springDataMongoDB4篇spring26篇Springmvc4篇mybaties11篇LeetCode算法2篇Java并发18篇netty2篇安全框架2篇大数据2篇流程引擎activiti4篇hadoophibernateandroid1篇数据结构11篇数据库6篇java基础12篇最新评论spring——JavaProxy和Cglib两种方式方法嵌套调用时代理对象行为分析Huunnnn:所以说网上总是说自调用失效是因为spring默认用的代理模式是java的动态代理如果改配置让代理模式强制改为cglib的代理模式这样自调用时的aop注解就不会失效了吧GO-日志分析白话机器学习:内容丰富图文并茂，认真看完收获很大。思路清晰细节满满，支持大佬优质好文。Spring——创建代理对象-JavaProxy方法分析（JdkDynamicAopProxy）wei青青:TestProxyFactorymain方法中的TDo这两个类的定义能放下代码吗？TreeMap分析daliucheng:欢迎交流TreeMap分析杨思默:博主总结很详细啊。大家在看从零开始学习嵌入式——C语言数值传递（值传递和地址传递）ue4----------理论（4.PBR)330Aiax应用get请求post请求json数据请求447帮自己了解疾病症状的健康APP，平时可以不用，关键时候必须要有！305椭流线法设计配光器558最新文章GO-日志分析Go异步任务Dubbogo详解2024年1篇2023年15篇2022年24篇2021年44篇2020年26篇2019年19篇2018年20篇2017年2篇目录目录分类专栏自动化测试1篇go语言21篇springDataMongoDB4篇spring26篇Springmvc4篇mybaties11篇LeetCode算法2篇Java并发18篇netty2篇安全框架2篇大数据2篇流程引擎activiti4篇hadoophibernateandroid1篇数据结构11篇数据库6篇java基础12篇目录评论被折叠的 条评论为什么被折叠?到【灌水乐园】发言查看更多评论添加红包祝福语请填写红包祝福语或标题红包数量个红包个数最小为10个红包总金额元红包金额最低5元余额支付当前余额3.43元前往充值>需支付：10.00元取消确定下一步知道了成就一亿技术人!领取后你会自动成为博主和红包主的粉丝规则hope_wisdom发出的红包实付元使用余额支付点击重新获取扫码支付钱包余额0抵扣说明：1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。余额充值"
}
[chain/end] [chain:RunnableSequence > chain:RunnableParallel<doc>] [2ms] Exiting Chain run with output:
{
"doc": "设置chrome二进制文件位置(binary_location)添加启动参数(add_argument)添加扩展应用(aChromeDevToolsProtocollocalstorage06-07ChromeDevToolsProtocol可以通过`Runtime.evaluate()`方法来读取和修改本地存储(`localStorage`)的值。以下是一个使用Node.js和`chrome-remote-interface`模块与ChromeDevToolsProtocol交互的例子：```javascriptconstCDP=require('chrome-remote-interface');CDP(asyncfunction(client){const{Runtime}=client;awaitRuntime.enable();//读取localStorage中的值const{result}=awaitRuntime.evaluate({expression:'localStorage.getItem(\"key\")'});console.log(result.value);//设置localStorage中的值awaitRuntime.evaluate({expression:'localStorage.setItem(\"key\",\"value\")'});client.close();}).on('error',(err)=>{console.error('Cannotconnecttobrowser:',err);});```需要注意的是，这个例子只是一个简单的示例，并没有对错误处理进行详细的说明。在实际使用中，需要对错误进行适当的处理，以确保程序的稳定性和可靠性。“相关推荐”对你有帮助么？非常没帮助没帮助一般有帮助非常有帮助提交daliuchengCSDN认证博客专家CSDN认证企业博客码龄7年暂无认证151原创4万+周排名4万+总排名17万+访问等级2170积分303粉丝287获赞51评论709收藏私信关注热门文章Spring定时任务@EnableScheduling解析27879数据库——求候选键的方法16022数据库——求候选键的方法14297Spring-动态数据源6182Mybatis中mapper是怎么和XMl关联起来的5361分类专栏自动化测试1篇go语言21篇springDataMongoDB4篇spring26篇Springmvc4篇mybaties11篇LeetCode算法2篇Java并发18篇netty2篇安全框架2篇大数据2篇流程引擎activiti4篇hadoophibernateandroid1篇数据结构11篇数据库6篇java基础12篇最新评论spring——JavaProxy和Cglib两种方式方法嵌套调用时代理对象行为分析Huunnnn:所以说网上总是说自调用失效是因为spring默认用的代理模式是java的动态代理如果改配置让代理模式强制改为cglib的代理模式这样自调用时的aop注解就不会失效了吧GO-日志分析白话机器学习:内容丰富图文并茂，认真看完收获很大。思路清晰细节满满，支持大佬优质好文。Spring——创建代理对象-JavaProxy方法分析（JdkDynamicAopProxy）wei青青:TestProxyFactorymain方法中的TDo这两个类的定义能放下代码吗？TreeMap分析daliucheng:欢迎交流TreeMap分析杨思默:博主总结很详细啊。大家在看从零开始学习嵌入式——C语言数值传递（值传递和地址传递）ue4----------理论（4.PBR)330Aiax应用get请求post请求json数据请求447帮自己了解疾病症状的健康APP，平时可以不用，关键时候必须要有！305椭流线法设计配光器558最新文章GO-日志分析Go异步任务Dubbogo详解2024年1篇2023年15篇2022年24篇2021年44篇2020年26篇2019年19篇2018年20篇2017年2篇目录目录分类专栏自动化测试1篇go语言21篇springDataMongoDB4篇spring26篇Springmvc4篇mybaties11篇LeetCode算法2篇Java并发18篇netty2篇安全框架2篇大数据2篇流程引擎activiti4篇hadoophibernateandroid1篇数据结构11篇数据库6篇java基础12篇目录评论被折叠的 条评论为什么被折叠?到【灌水乐园】发言查看更多评论添加红包祝福语请填写红包祝福语或标题红包数量个红包个数最小为10个红包总金额元红包金额最低5元余额支付当前余额3.43元前往充值>需支付：10.00元取消确定下一步知道了成就一亿技术人!领取后你会自动成为博主和红包主的粉丝规则hope_wisdom发出的红包实付元使用余额支付点击重新获取扫码支付钱包余额0抵扣说明：1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。余额充值"
}
[chain/start] [chain:RunnableSequence > prompt:ChatPromptTemplate] Entering Prompt run with input:
{
"doc": "CDP和Chrome_chromedevtoolsprotocol-CSDN博客CDP和Chromedaliucheng已于 2024-02-1900:07:33 修改阅读量1.7k收藏21点赞数27分类专栏：自动化测试文章标签：chrome自动化pythonnode.js于 2024-02-1823:45:32 首次发布版权声明：本文为博主原创文章，遵循CC4.0BY-SA版权协议，转载请附上原文出处链接和本声明。本文链接：https://blog.csdn.net/daliucheng/article/details/136160807版权自动化测试专栏收录该内容1篇文章0订阅订阅专栏CDP和ChromeCDP和WebDriverProtocolWebDriver和ChromeDevToolsProtocol（CDP）是用于自动化浏览器的两个主要协议，大多数的浏览器自动化工具都是基于上述其中之一来实现的。可以通过这两种形式来和浏览器交互，通过代码来控制浏览器，完成浏览器的自动化行为（包括网页加载，爬虫，截图，导出pdf等）。WebDriverProtocol官网地址：链接WebDriver是一个用于控制浏览器的远程控制接口，由SeleniumHQ开发，后来由W3C标准化。它提供了一个平台和语言中立的接口，支持几乎所有主流浏览器，如Chrome、Firefox、Safari、Edge、Opera等。它和浏览器的通信是通过JSONWire协议完成的，提供了RESTful的web服务，这个服务端就被称为服务端（也被称为webdriver），例如chromeDriver、geckoDriver等。有服务端就有客户端，客户端可以选择任何语言，客户端和服务端交互，服务端和浏览器交互，从而操作浏览器。常见的客户端就是selenium,nightwatch,webdriverio加上我们的自己写的自动化测试代码之后，交互流程如下：ChromeDevToolsProtocol官网地址：链接ChromeDevToolsProtocol(CDP)是一个基于Chromium的浏览器的调试协议，如Chrome、Edge、Opera等。通过它可以直接和浏览器交互。控制浏览器的行为。客户端和浏览器之间没有类似于WebDriverProtocol的服务端（webdriver），而是客户端通过WebSocket直接和浏览器连类似网络驱动服务器(浏览器驱动程序)的中间人。相反，浏览器是由客户端使用CDP直接控制的。与浏览器的通信是通过套接字连接完成的，因此也支持双向通信。客户端通过WebSocket发送命令给浏览器，浏览器执行并返回响应。两个相当流行的工具是Puppeteer和Playwright。它们不依赖于webdriver，而是通过ChromeDevToolsProtocol(CDP)直接与浏览器通话。从而更加灵活稳定的控制浏览器。区别从代码层面来看，使用的代码接近底层，接近浏览器，代码就会变得更加的稳定和强大，但对于跨浏览器的支持会变得更少。另一方面，代码和浏览器的之间的抽象程度越高，支持的浏览器就越多，但代码会变得不稳定并且功能受限。对比上面两种WebDriverProtocol支持的浏览器多，但不是很稳定，并且功能不强大。ChromeDevToolsProtocol支持的浏览器少（只是相对WebDriver来说，Chrome能支持就能用），功能强大，稳定。WebdriverProtocolChromeDevToolsProtocolDevelopedby:W3CDevelopedby:ChromeDeveloperTools需要webdriver不需要webdriver相对较慢并且不是很稳定速度快，较稳定支持的浏览器多支持部分浏览器无法通过提供的api来访问浏览器中网络相关的信息可以通过api来访问网络相关的信息它的实现有：SeleniumWebDriver3,WebdriverIO,Nightwatch它的实现有：Playwright,Puppeteer,SeleniumWebdriver4,Cypressv7不同的WebDriver有不同的实现方式，chromeDriver内部是通过DevToolsprotoco来控制浏览器的。如何选择如果跨浏览器很重要，就选webDriver，否则选择CDPpuppeteer链接：官网，github，github-examplesPuppeteer是Chrome开发团队在2017年发布的一个Node.js包，是它提供了一个高级API，通过DevTools协议控制Chrome/Chromium。为什么选择它？两个理由github中star数多Chrome开发团队可以做什么？简单来说，浏览器能做的，它都能做截图和生成PDF爬取SPA或SSR网站UI自动化测试…版本说明从v1.7.0版本以来，每次发布都会发布两个软件包：puppeteer它会自动下载一个最新版本的Chrome用于测试（macOS约170MB，Linux约282MB，Windows约280MB）以及一个chrome-headless-shell二进制文件（从Puppeteerv21.6.0开始），这个二进制文件保证可以与Puppeteer配合正常工作。默认情况下，浏览器会下载到$HOME/.cache/puppeteer文件夹中（从Puppeteerv19.0.0开始）。通过puppeteer-core控制它下载的浏览器puppeteer-corepuppeteer-core是一个库，用于帮助驱动任何支持DevTools协议的内容。它不会下载浏览器，它提供了封装好的API和浏览器交互。如果自己已经下载了浏览器，就可以使用它，但是必须在调用puppeteer.launch的时候显式的指定executablePath(浏览器的执行位置)一般来说我会使用这个代码建议看这篇文章结合项目来谈谈Puppeteer在结合github-examples的例子。注意点在部署的时候，建议使用容器化，Chrome本身是内存大户，如果遇到内存飙升，代码是不太好发现这种情况的，不能及时kill掉。在加载网页的时候不建议每次都关闭和开启一个新的。Chrome的启动和关系是比较耗时的，每次启动会慢150ms到300ms建议重复使用同一个Chrome。Chrome使用一段时间之后，要关掉重启。Chrome在我们自己的电脑中有的时候，页面都会崩溃，浏览器也会崩溃。在服务器这种情况下，肯定也会出现，建议在内存中设置调用阈值，比如加载了100个网页，重启一次。这样可降低崩溃的概率。容器化部署之后，建议一个容器中只启动一个Chrome。这样会让代码简单并且出现问题好排查。这就要求Chrome在代码中是单例在整个Chrome做操作期间，对Chrome崩溃的情况做处理在业务代码期间，建议使用trycatch来捕获异常，对于非业务异常，需要关闭掉Chrome。防止出现多个Chrome。Chrome在关闭的时候出现异常，也需要处理在调用close()api来关闭Chrome的时候，可能会报错（可能Chrome在这个时候被操作系统kill掉，会出现孤儿进程）。建议：在这个时候直接通过shell脚本来强行kill掉#!/bin/bashpids=$(ps-ef|grep\"[c]hrome\"|grep-v'kill_chrome_processes.sh'|awk'{print$2}')forpidin$pids;doecho\"TerminatingPID$pid\"kill$piddoneecho\"Allchromeprocesseshavebeenterminated.\"孤儿进程：父进程启动了子进程，子进程在没有退出的情况下，父进程退出了。此时子进程会被init进程接管。尽量关闭掉无用的功能，让他越简单越好。比如：-no-sandbox,--disable-extensions,--disable-gpu,--disable_scrollbars共享内存Chrome默认使用/dev/shm共享内存，但是docker默认/dev/shm只有64MB，显然是不够使用的，提供两种方式来解决：启动docker时添加参数--shm-size=1gb来增大/dev/shm共享内存，但是swarm目前不支持shm-size参数启动Chrome添加参数-disable-dev-shm-usage，禁止使用/dev/shm共享内存参考文档https://www.neovasolutions.com/2022/05/19/browser-automation-tools-protocols-webdriver-vs-cdp/https://dev.to/jankaritech/different-approaches-protocols-to-automate-the-browser-39f1https://stackoverflow.com/questions/50939116/what-is-the-difference-between-webdriver-and-devtool-protocolhttps://zhuanlan.zhihu.com/p/76237595关于博客这件事，我是把它当做我的笔记，里面有很多的内容反映了我思考的过程，因为思维有限，不免有些内容有出入，如果有问题，欢迎指出。一同探讨。谢谢。确定要放弃本次机会？福利倒计时::立减¥普通VIP年卡可用立即使用daliucheng关注关注27点赞踩21收藏觉得还不错?一键收藏知道了0评论CDP和ChromeWebDriver和是用于自动化浏览器的两个主要协议，大多数的浏览器自动化工具都是基于上述其中之一来实现的。可以通过这两种形式来和浏览器交互，通过代码来控制浏览器，完成浏览器的自动化行为（包括网页加载，爬虫，截图，导出pdf等）。复制链接扫一扫专栏目录Pythoncdp(ChromeDevToolsProtocol)爬虫墨鱼菜鸡07-113265devtools-protocol：https://github.com/ChromeDevTools/devtools-protocolChromeDevToolsProtocol：https://chromedevtools.github.io/devtools-protocol/AwesomeChromeDevTools：https:...ChromeDevToolsProtocol(谷歌开发者工具协议)ProtocolMonitor（协议监视器）llrraa2010的专栏06-102633该协议最初是由谷歌开发者工具团队维护的，负责调试、操作浏览器的协议。我们经常使用到的谷歌浏览器的开发者工具（快捷键CTRL+SHIFT+I或者F12）就是使用这个协议来操作浏览器的。与Selenium需要与浏览器驱动进行交互不同的是，ChromeDevTools协议直接通过WebSocket协议与浏览器暴露的API进行通信，这使得ChromeDevTools协议操作浏览器变得更快。我们要重启开发者工具，在右侧点击更多工具，这样就可以看到协议监视器面板了。参与评论您还未登录，请先登录后发表或查看评论探索Web开发新维度：Devtools-Protocol最新发布gitblog_00001的博客05-15353探索Web开发新维度：Devtools-Protocol项目地址:https://gitcode.com/ChromeDevTools/devtools-protocol项目介绍在Web开发的世界中，ChromeDevToolsProtocol（DTP）是连接开发者和浏览器内核的桥梁，它允许我们进行深度的调试、性能分析以及自动化测试。而devtools-protocol是一个官方维护的开...usus使用Chrome调试协议CDP渲染页面08-08usus使用Chrome调试协议（CDP）渲染页面。提取用于渲染页面的CSS。渲染带有阻塞CSS的HTML异步。浏览器自动化必须知道CDP协议白天安全建设，晚上全栈开发，大模型爱好者。公众号：飞羽技术工坊。01-131067之前搞自动化页面，因为有一个获取网络日志的需求，让我发现了新的知识盲区——CDP协议。ChromeDevTools通过cdp调节CPUThrottling时丶光11-26927打开DevTools(快捷键ctrl+shift+i)在DevTools界面再打开DevToolsletMain=awaitimport('./devtools-frontend/front_end/entrypoints/main/main.js');//or'./entrypoints/main/main.js'or'./main/main.js'dependingonthebrowserversion//设置CPUThrottling为本机cdp:软件包cdp为使用Go编程语言编写的ChromeDevTools协议（CDP）提供了类型安全的绑定05-04光盘软件包cdp为使用Go编程语言编写的（CDP）提供了类型安全的绑定。绑定是由根据最新协议定义生成的，并且主要用于GoogleChrome或Chromium，但是它们可以与任何调试目标（，，等）。通过ChromeDevTools协议，该软件包可用于任何类型的浏览器自动化，脚本编写或调试。cdp主要动机是公开ChromeDevTools协议的全部功能，并以一种可发现的自记录方式提供它。提供高级浏览器自动化对于该项目而言是不可行的。话虽如此，cdp希望通过提供更适合Go的原语并自动执行重复性任务来改善使用该协议的人体工程学。特征适用于ChromeDevTools协议的可发现API（GoDoc，自动完成友好）作为头等公民的情况（用于超时和取消）简单且同步的事件处理（无回调）同时安全没有无声或隐藏的错误做到用户期望的尽可能将CDP类型与ichrome：适用于人类的Chrome控制器，基于ChromeDevtools协议（CDP）和python3.7+01-31适用于人类的Chrome控制器，基于和python3.7+。为什么？Pyppeteer很棒，但是我不需要那么多pyppeteer的拼写很混乱事件驱动的编程并非总是明智的。Selenium慢网络驱动程序经常带有内存泄漏。迫切需要一个稳定的...selenium_cdp：Selenium4x，执行ChromeDevTools协议命令01-31该项目采用JavaSelenium4.0.x版本的来执行（也称为cdp命令），这是一套完全不同的API，通过对/session/$sessionId/goog/cdp/executePOSTPOST传达给Chrome浏览器系列，特定的有效负载）功能（许多cdp方法，例如...cdp4j：cdp4j-适用于Java的ChromeDevTools协议01-28cdp4j是Java库，具有清晰简洁的API，可自动执行基于Chrome/Chromium的浏览器。它使用GoogleChromeDevTools协议来自动化基于Chrome/Chromium的浏览器。cdp4j可以做什么？自动填写表格。您可以轻松下载和...getting-started-with-cdp:ChromeDevTools协议入门07-24使用ChromeDevTools协议在直接使用CDP进行浏览器自动化之前要三思。有会让你过得更好不服气？至少使用。另请参阅介绍注意：://vanilla.aslushnikov.com提供了交互式协议查看器。ChromeDevTools协议...Chrome之远程调试协议（Remotedebuggingprotocol）-Div.IOweixin_33940102的博客06-271781Chrome之远程调试协议（Remotedebuggingprotocol）-Div.IO一文读懂UI自动化测试三种核心实现原理：Native、Webdriver和CDPliwenxiang629的博客04-03808相信80%的UI自动化测试工程师在进行岗位面试的时候都会重点讲解自己会使用哪些工具，例如cypress、selenium、playwright等等。其实这只是初级段位，如果大家想谈得再高大上一些，就可以谈谈这些工具与浏览器talk的原理了，绝对会得到面试官的重视！目前主流主动化测试工具与浏览器沟通的原理主要包括：Native、Webdriver以及CDP，使用这三种方式的典型代表工具分别是：cypress、selenium和playwright。今天我就对此进行总结：朋友们，一起学习下ChromeDevToolsProtocol。z_l_x_的博客10-1830721947年9月9日，Firstactualcaseofbugbeingfound，自此引入了Debugging。CDP远程调试方案老司机的后备箱05-233656什么是cdp协议cdp协议简称chrome调试协议，是基于scoket（websocket、usb、adb）消息的jsonrpc协议。用来调用chrome内部的方法实现js，css，dom的开发调试。可以将实现了cdp协议的应用看做rpc调用的服务端（chrome，puppeteer），将调试面板看做rpc调用的客户端（devtools）。devtools调试系统完整的调试系统分别由前端，后端，协议，通道四部分组成Frontend：调试器前端GoChromedp库得使用----CDP（ChromeDevToolsProtocol)路小白的博客12-248813Gochromedp库的使用—CDP文章目录Gochromedp库的使用---CDPCDP（ChromeDevToolsProtocol)基于CDP协议的相关语言操作Chromedp使用示例本地界面浏览器操作远程操作示例（无头浏览器）Centos安装chronium-headless示例代码Browsesrless/chrome部署Linux-Centos安装NodeJS参考CDP（ChromeDevToolsProtocol)ChromeDevToolsProtocol是基.【学习笔记】seleniumChromeDriver移除navigator.webdriver属性MONKEYMONEY_的博客12-16906作为新手的我，在刚接触selenium时不了解的ChromeDriver一些常用属性和方法。为此特意记录了以下几项并加上注释，方便以后查阅调用。Selenium中的ChromeOptions选项chromeOptions是一个配置chrome启动属性的类。通过这个类，我们可以为chrome配置如下参数（这个部分可以通过selenium源码看到）：设置chrome二进制文件位置(binary_location)添加启动参数(add_argument)添加扩展应用(aChromeDevToolsProtocollocalstorage06-07"
}
[chain/end] [chain:RunnableSequence > prompt:ChatPromptTemplate] [1ms] Exiting Prompt run with output:
[outputs]
[chain/start] [chain:RunnableSequence > prompt:ChatPromptTemplate] Entering Prompt run with input:
{
"doc": "设置chrome二进制文件位置(binary_location)添加启动参数(add_argument)添加扩展应用(aChromeDevToolsProtocollocalstorage06-07ChromeDevToolsProtocol可以通过`Runtime.evaluate()`方法来读取和修改本地存储(`localStorage`)的值。以下是一个使用Node.js和`chrome-remote-interface`模块与ChromeDevToolsProtocol交互的例子：```javascriptconstCDP=require('chrome-remote-interface');CDP(asyncfunction(client){const{Runtime}=client;awaitRuntime.enable();//读取localStorage中的值const{result}=awaitRuntime.evaluate({expression:'localStorage.getItem(\"key\")'});console.log(result.value);//设置localStorage中的值awaitRuntime.evaluate({expression:'localStorage.setItem(\"key\",\"value\")'});client.close();}).on('error',(err)=>{console.error('Cannotconnecttobrowser:',err);});```需要注意的是，这个例子只是一个简单的示例，并没有对错误处理进行详细的说明。在实际使用中，需要对错误进行适当的处理，以确保程序的稳定性和可靠性。“相关推荐”对你有帮助么？非常没帮助没帮助一般有帮助非常有帮助提交daliuchengCSDN认证博客专家CSDN认证企业博客码龄7年暂无认证151原创4万+周排名4万+总排名17万+访问等级2170积分303粉丝287获赞51评论709收藏私信关注热门文章Spring定时任务@EnableScheduling解析27879数据库——求候选键的方法16022数据库——求候选键的方法14297Spring-动态数据源6182Mybatis中mapper是怎么和XMl关联起来的5361分类专栏自动化测试1篇go语言21篇springDataMongoDB4篇spring26篇Springmvc4篇mybaties11篇LeetCode算法2篇Java并发18篇netty2篇安全框架2篇大数据2篇流程引擎activiti4篇hadoophibernateandroid1篇数据结构11篇数据库6篇java基础12篇最新评论spring——JavaProxy和Cglib两种方式方法嵌套调用时代理对象行为分析Huunnnn:所以说网上总是说自调用失效是因为spring默认用的代理模式是java的动态代理如果改配置让代理模式强制改为cglib的代理模式这样自调用时的aop注解就不会失效了吧GO-日志分析白话机器学习:内容丰富图文并茂，认真看完收获很大。思路清晰细节满满，支持大佬优质好文。Spring——创建代理对象-JavaProxy方法分析（JdkDynamicAopProxy）wei青青:TestProxyFactorymain方法中的TDo这两个类的定义能放下代码吗？TreeMap分析daliucheng:欢迎交流TreeMap分析杨思默:博主总结很详细啊。大家在看从零开始学习嵌入式——C语言数值传递（值传递和地址传递）ue4----------理论（4.PBR)330Aiax应用get请求post请求json数据请求447帮自己了解疾病症状的健康APP，平时可以不用，关键时候必须要有！305椭流线法设计配光器558最新文章GO-日志分析Go异步任务Dubbogo详解2024年1篇2023年15篇2022年24篇2021年44篇2020年26篇2019年19篇2018年20篇2017年2篇目录目录分类专栏自动化测试1篇go语言21篇springDataMongoDB4篇spring26篇Springmvc4篇mybaties11篇LeetCode算法2篇Java并发18篇netty2篇安全框架2篇大数据2篇流程引擎activiti4篇hadoophibernateandroid1篇数据结构11篇数据库6篇java基础12篇目录评论被折叠的 条评论为什么被折叠?到【灌水乐园】发言查看更多评论添加红包祝福语请填写红包祝福语或标题红包数量个红包个数最小为10个红包总金额元红包金额最低5元余额支付当前余额3.43元前往充值>需支付：10.00元取消确定下一步知道了成就一亿技术人!领取后你会自动成为博主和红包主的粉丝规则hope_wisdom发出的红包实付元使用余额支付点击重新获取扫码支付钱包余额0抵扣说明：1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。余额充值"
}
[chain/end] [chain:RunnableSequence > prompt:ChatPromptTemplate] [0ms] Exiting Prompt run with output:
[outputs]
[llm/start] [chain:RunnableSequence > llm:ChatOpenAI] Entering LLM run with input:
{
"prompts": [
"Human: 总结下面文档的内容:\n\nCDP和Chrome_chromedevtoolsprotocol-CSDN博客CDP和Chromedaliucheng已于 2024-02-1900:07:33 修改阅读量1.7k收藏21点赞数27分类专栏：自动化测试文章标签：chrome自动化pythonnode.js于 2024-02-1823:45:32 首次发布版权声明：本文为博主原创文章，遵循CC4.0BY-SA版权协议，转载请附上原文出处链接和本声明。本文链接：https://blog.csdn.net/daliucheng/article/details/136160807版权自动化测试专栏收录该内容1篇文章0订阅订阅专栏CDP和ChromeCDP和WebDriverProtocolWebDriver和ChromeDevToolsProtocol（CDP）是用于自动化浏览器的两个主要协议，大多数的浏览器自动化工具都是基于上述其中之一来实现的。可以通过这两种形式来和浏览器交互，通过代码来控制浏览器，完成浏览器的自动化行为（包括网页加载，爬虫，截图，导出pdf等）。WebDriverProtocol官网地址：链接WebDriver是一个用于控制浏览器的远程控制接口，由SeleniumHQ开发，后来由W3C标准化。它提供了一个平台和语言中立的接口，支持几乎所有主流浏览器，如Chrome、Firefox、Safari、Edge、Opera等。它和浏览器的通信是通过JSONWire协议完成的，提供了RESTful的web服务，这个服务端就被称为服务端（也被称为webdriver），例如chromeDriver、geckoDriver等。有服务端就有客户端，客户端可以选择任何语言，客户端和服务端交互，服务端和浏览器交互，从而操作浏览器。常见的客户端就是selenium,nightwatch,webdriverio加上我们的自己写的自动化测试代码之后，交互流程如下：ChromeDevToolsProtocol官网地址：链接ChromeDevToolsProtocol(CDP)是一个基于Chromium的浏览器的调试协议，如Chrome、Edge、Opera等。通过它可以直接和浏览器交互。控制浏览器的行为。客户端和浏览器之间没有类似于WebDriverProtocol的服务端（webdriver），而是客户端通过WebSocket直接和浏览器连类似网络驱动服务器(浏览器驱动程序)的中间人。相反，浏览器是由客户端使用CDP直接控制的。与浏览器的通信是通过套接字连接完成的，因此也支持双向通信。客户端通过WebSocket发送命令给浏览器，浏览器执行并返回响应。两个相当流行的工具是Puppeteer和Playwright。它们不依赖于webdriver，而是通过ChromeDevToolsProtocol(CDP)直接与浏览器通话。从而更加灵活稳定的控制浏览器。区别从代码层面来看，使用的代码接近底层，接近浏览器，代码就会变得更加的稳定和强大，但对于跨浏览器的支持会变得更少。另一方面，代码和浏览器的之间的抽象程度越高，支持的浏览器就越多，但代码会变得不稳定并且功能受限。对比上面两种WebDriverProtocol支持的浏览器多，但不是很稳定，并且功能不强大。ChromeDevToolsProtocol支持的浏览器少（只是相对WebDriver来说，Chrome能支持就能用），功能强大，稳定。WebdriverProtocolChromeDevToolsProtocolDevelopedby:W3CDevelopedby:ChromeDeveloperTools需要webdriver不需要webdriver相对较慢并且不是很稳定速度快，较稳定支持的浏览器多支持部分浏览器无法通过提供的api来访问浏览器中网络相关的信息可以通过api来访问网络相关的信息它的实现有：SeleniumWebDriver3,WebdriverIO,Nightwatch它的实现有：Playwright,Puppeteer,SeleniumWebdriver4,Cypressv7不同的WebDriver有不同的实现方式，chromeDriver内部是通过DevToolsprotoco来控制浏览器的。如何选择如果跨浏览器很重要，就选webDriver，否则选择CDPpuppeteer链接：官网，github，github-examplesPuppeteer是Chrome开发团队在2017年发布的一个Node.js包，是它提供了一个高级API，通过DevTools协议控制Chrome/Chromium。为什么选择它？两个理由github中star数多Chrome开发团队可以做什么？简单来说，浏览器能做的，它都能做截图和生成PDF爬取SPA或SSR网站UI自动化测试…版本说明从v1.7.0版本以来，每次发布都会发布两个软件包：puppeteer它会自动下载一个最新版本的Chrome用于测试（macOS约170MB，Linux约282MB，Windows约280MB）以及一个chrome-headless-shell二进制文件（从Puppeteerv21.6.0开始），这个二进制文件保证可以与Puppeteer配合正常工作。默认情况下，浏览器会下载到$HOME/.cache/puppeteer文件夹中（从Puppeteerv19.0.0开始）。通过puppeteer-core控制它下载的浏览器puppeteer-corepuppeteer-core是一个库，用于帮助驱动任何支持DevTools协议的内容。它不会下载浏览器，它提供了封装好的API和浏览器交互。如果自己已经下载了浏览器，就可以使用它，但是必须在调用puppeteer.launch的时候显式的指定executablePath(浏览器的执行位置)一般来说我会使用这个代码建议看这篇文章结合项目来谈谈Puppeteer在结合github-examples的例子。注意点在部署的时候，建议使用容器化，Chrome本身是内存大户，如果遇到内存飙升，代码是不太好发现这种情况的，不能及时kill掉。在加载网页的时候不建议每次都关闭和开启一个新的。Chrome的启动和关系是比较耗时的，每次启动会慢150ms到300ms建议重复使用同一个Chrome。Chrome使用一段时间之后，要关掉重启。Chrome在我们自己的电脑中有的时候，页面都会崩溃，浏览器也会崩溃。在服务器这种情况下，肯定也会出现，建议在内存中设置调用阈值，比如加载了100个网页，重启一次。这样可降低崩溃的概率。容器化部署之后，建议一个容器中只启动一个Chrome。这样会让代码简单并且出现问题好排查。这就要求Chrome在代码中是单例在整个Chrome做操作期间，对Chrome崩溃的情况做处理在业务代码期间，建议使用trycatch来捕获异常，对于非业务异常，需要关闭掉Chrome。防止出现多个Chrome。Chrome在关闭的时候出现异常，也需要处理在调用close()api来关闭Chrome的时候，可能会报错（可能Chrome在这个时候被操作系统kill掉，会出现孤儿进程）。建议：在这个时候直接通过shell脚本来强行kill掉#!/bin/bashpids=$(ps-ef|grep\"[c]hrome\"|grep-v'kill_chrome_processes.sh'|awk'{print$2}')forpidin$pids;doecho\"TerminatingPID$pid\"kill$piddoneecho\"Allchromeprocesseshavebeenterminated.\"孤儿进程：父进程启动了子进程，子进程在没有退出的情况下，父进程退出了。此时子进程会被init进程接管。尽量关闭掉无用的功能，让他越简单越好。比如：-no-sandbox,--disable-extensions,--disable-gpu,--disable_scrollbars共享内存Chrome默认使用/dev/shm共享内存，但是docker默认/dev/shm只有64MB，显然是不够使用的，提供两种方式来解决：启动docker时添加参数--shm-size=1gb来增大/dev/shm共享内存，但是swarm目前不支持shm-size参数启动Chrome添加参数-disable-dev-shm-usage，禁止使用/dev/shm共享内存参考文档https://www.neovasolutions.com/2022/05/19/browser-automation-tools-protocols-webdriver-vs-cdp/https://dev.to/jankaritech/different-approaches-protocols-to-automate-the-browser-39f1https://stackoverflow.com/questions/50939116/what-is-the-difference-between-webdriver-and-devtool-protocolhttps://zhuanlan.zhihu.com/p/76237595关于博客这件事，我是把它当做我的笔记，里面有很多的内容反映了我思考的过程，因为思维有限，不免有些内容有出入，如果有问题，欢迎指出。一同探讨。谢谢。确定要放弃本次机会？福利倒计时::立减¥普通VIP年卡可用立即使用daliucheng关注关注27点赞踩21收藏觉得还不错?一键收藏知道了0评论CDP和ChromeWebDriver和是用于自动化浏览器的两个主要协议，大多数的浏览器自动化工具都是基于上述其中之一来实现的。可以通过这两种形式来和浏览器交互，通过代码来控制浏览器，完成浏览器的自动化行为（包括网页加载，爬虫，截图，导出pdf等）。复制链接扫一扫专栏目录Pythoncdp(ChromeDevToolsProtocol)爬虫墨鱼菜鸡07-113265devtools-protocol：https://github.com/ChromeDevTools/devtools-protocolChromeDevToolsProtocol：https://chromedevtools.github.io/devtools-protocol/AwesomeChromeDevTools：https:...ChromeDevToolsProtocol(谷歌开发者工具协议)ProtocolMonitor（协议监视器）llrraa2010的专栏06-102633该协议最初是由谷歌开发者工具团队维护的，负责调试、操作浏览器的协议。我们经常使用到的谷歌浏览器的开发者工具（快捷键CTRL+SHIFT+I或者F12）就是使用这个协议来操作浏览器的。与Selenium需要与浏览器驱动进行交互不同的是，ChromeDevTools协议直接通过WebSocket协议与浏览器暴露的API进行通信，这使得ChromeDevTools协议操作浏览器变得更快。我们要重启开发者工具，在右侧点击更多工具，这样就可以看到协议监视器面板了。参与评论您还未登录，请先登录后发表或查看评论探索Web开发新维度：Devtools-Protocol最新发布gitblog_00001的博客05-15353探索Web开发新维度：Devtools-Protocol项目地址:https://gitcode.com/ChromeDevTools/devtools-protocol项目介绍在Web开发的世界中，ChromeDevToolsProtocol（DTP）是连接开发者和浏览器内核的桥梁，它允许我们进行深度的调试、性能分析以及自动化测试。而devtools-protocol是一个官方维护的开...usus使用Chrome调试协议CDP渲染页面08-08usus使用Chrome调试协议（CDP）渲染页面。提取用于渲染页面的CSS。渲染带有阻塞CSS的HTML异步。浏览器自动化必须知道CDP协议白天安全建设，晚上全栈开发，大模型爱好者。公众号：飞羽技术工坊。01-131067之前搞自动化页面，因为有一个获取网络日志的需求，让我发现了新的知识盲区——CDP协议。ChromeDevTools通过cdp调节CPUThrottling时丶光11-26927打开DevTools(快捷键ctrl+shift+i)在DevTools界面再打开DevToolsletMain=awaitimport('./devtools-frontend/front_end/entrypoints/main/main.js');//or'./entrypoints/main/main.js'or'./main/main.js'dependingonthebrowserversion//设置CPUThrottling为本机cdp:软件包cdp为使用Go编程语言编写的ChromeDevTools协议（CDP）提供了类型安全的绑定05-04光盘软件包cdp为使用Go编程语言编写的（CDP）提供了类型安全的绑定。绑定是由根据最新协议定义生成的，并且主要用于GoogleChrome或Chromium，但是它们可以与任何调试目标（，，等）。通过ChromeDevTools协议，该软件包可用于任何类型的浏览器自动化，脚本编写或调试。cdp主要动机是公开ChromeDevTools协议的全部功能，并以一种可发现的自记录方式提供它。提供高级浏览器自动化对于该项目而言是不可行的。话虽如此，cdp希望通过提供更适合Go的原语并自动执行重复性任务来改善使用该协议的人体工程学。特征适用于ChromeDevTools协议的可发现API（GoDoc，自动完成友好）作为头等公民的情况（用于超时和取消）简单且同步的事件处理（无回调）同时安全没有无声或隐藏的错误做到用户期望的尽可能将CDP类型与ichrome：适用于人类的Chrome控制器，基于ChromeDevtools协议（CDP）和python3.7+01-31适用于人类的Chrome控制器，基于和python3.7+。为什么？Pyppeteer很棒，但是我不需要那么多pyppeteer的拼写很混乱事件驱动的编程并非总是明智的。Selenium慢网络驱动程序经常带有内存泄漏。迫切需要一个稳定的...selenium_cdp：Selenium4x，执行ChromeDevTools协议命令01-31该项目采用JavaSelenium4.0.x版本的来执行（也称为cdp命令），这是一套完全不同的API，通过对/session/$sessionId/goog/cdp/executePOSTPOST传达给Chrome浏览器系列，特定的有效负载）功能（许多cdp方法，例如...cdp4j：cdp4j-适用于Java的ChromeDevTools协议01-28cdp4j是Java库，具有清晰简洁的API，可自动执行基于Chrome/Chromium的浏览器。它使用GoogleChromeDevTools协议来自动化基于Chrome/Chromium的浏览器。cdp4j可以做什么？自动填写表格。您可以轻松下载和...getting-started-with-cdp:ChromeDevTools协议入门07-24使用ChromeDevTools协议在直接使用CDP进行浏览器自动化之前要三思。有会让你过得更好不服气？至少使用。另请参阅介绍注意：://vanilla.aslushnikov.com提供了交互式协议查看器。ChromeDevTools协议...Chrome之远程调试协议（Remotedebuggingprotocol）-Div.IOweixin_33940102的博客06-271781Chrome之远程调试协议（Remotedebuggingprotocol）-Div.IO一文读懂UI自动化测试三种核心实现原理：Native、Webdriver和CDPliwenxiang629的博客04-03808相信80%的UI自动化测试工程师在进行岗位面试的时候都会重点讲解自己会使用哪些工具，例如cypress、selenium、playwright等等。其实这只是初级段位，如果大家想谈得再高大上一些，就可以谈谈这些工具与浏览器talk的原理了，绝对会得到面试官的重视！目前主流主动化测试工具与浏览器沟通的原理主要包括：Native、Webdriver以及CDP，使用这三种方式的典型代表工具分别是：cypress、selenium和playwright。今天我就对此进行总结：朋友们，一起学习下ChromeDevToolsProtocol。z_l_x_的博客10-1830721947年9月9日，Firstactualcaseofbugbeingfound，自此引入了Debugging。CDP远程调试方案老司机的后备箱05-233656什么是cdp协议cdp协议简称chrome调试协议，是基于scoket（websocket、usb、adb）消息的jsonrpc协议。用来调用chrome内部的方法实现js，css，dom的开发调试。可以将实现了cdp协议的应用看做rpc调用的服务端（chrome，puppeteer），将调试面板看做rpc调用的客户端（devtools）。devtools调试系统完整的调试系统分别由前端，后端，协议，通道四部分组成Frontend：调试器前端GoChromedp库得使用----CDP（ChromeDevToolsProtocol)路小白的博客12-248813Gochromedp库的使用—CDP文章目录Gochromedp库的使用---CDPCDP（ChromeDevToolsProtocol)基于CDP协议的相关语言操作Chromedp使用示例本地界面浏览器操作远程操作示例（无头浏览器）Centos安装chronium-headless示例代码Browsesrless/chrome部署Linux-Centos安装NodeJS参考CDP（ChromeDevToolsProtocol)ChromeDevToolsProtocol是基.【学习笔记】seleniumChromeDriver移除navigator.webdriver属性MONKEYMONEY_的博客12-16906作为新手的我，在刚接触selenium时不了解的ChromeDriver一些常用属性和方法。为此特意记录了以下几项并加上注释，方便以后查阅调用。Selenium中的ChromeOptions选项chromeOptions是一个配置chrome启动属性的类。通过这个类，我们可以为chrome配置如下参数（这个部分可以通过selenium源码看到）：设置chrome二进制文件位置(binary_location)添加启动参数(add_argument)添加扩展应用(aChromeDevToolsProtocollocalstorage06-07"
]
}
[llm/start] [chain:RunnableSequence > llm:ChatOpenAI] Entering LLM run with input:
{
"prompts": [
"Human: 总结下面文档的内容:\n\n设置chrome二进制文件位置(binary_location)添加启动参数(add_argument)添加扩展应用(aChromeDevToolsProtocollocalstorage06-07ChromeDevToolsProtocol可以通过`Runtime.evaluate()`方法来读取和修改本地存储(`localStorage`)的值。以下是一个使用Node.js和`chrome-remote-interface`模块与ChromeDevToolsProtocol交互的例子：```javascriptconstCDP=require('chrome-remote-interface');CDP(asyncfunction(client){const{Runtime}=client;awaitRuntime.enable();//读取localStorage中的值const{result}=awaitRuntime.evaluate({expression:'localStorage.getItem(\"key\")'});console.log(result.value);//设置localStorage中的值awaitRuntime.evaluate({expression:'localStorage.setItem(\"key\",\"value\")'});client.close();}).on('error',(err)=>{console.error('Cannotconnecttobrowser:',err);});```需要注意的是，这个例子只是一个简单的示例，并没有对错误处理进行详细的说明。在实际使用中，需要对错误进行适当的处理，以确保程序的稳定性和可靠性。“相关推荐”对你有帮助么？非常没帮助没帮助一般有帮助非常有帮助提交daliuchengCSDN认证博客专家CSDN认证企业博客码龄7年暂无认证151原创4万+周排名4万+总排名17万+访问等级2170积分303粉丝287获赞51评论709收藏私信关注热门文章Spring定时任务@EnableScheduling解析27879数据库——求候选键的方法16022数据库——求候选键的方法14297Spring-动态数据源6182Mybatis中mapper是怎么和XMl关联起来的5361分类专栏自动化测试1篇go语言21篇springDataMongoDB4篇spring26篇Springmvc4篇mybaties11篇LeetCode算法2篇Java并发18篇netty2篇安全框架2篇大数据2篇流程引擎activiti4篇hadoophibernateandroid1篇数据结构11篇数据库6篇java基础12篇最新评论spring——JavaProxy和Cglib两种方式方法嵌套调用时代理对象行为分析Huunnnn:所以说网上总是说自调用失效是因为spring默认用的代理模式是java的动态代理如果改配置让代理模式强制改为cglib的代理模式这样自调用时的aop注解就不会失效了吧GO-日志分析白话机器学习:内容丰富图文并茂，认真看完收获很大。思路清晰细节满满，支持大佬优质好文。Spring——创建代理对象-JavaProxy方法分析（JdkDynamicAopProxy）wei青青:TestProxyFactorymain方法中的TDo这两个类的定义能放下代码吗？TreeMap分析daliucheng:欢迎交流TreeMap分析杨思默:博主总结很详细啊。大家在看从零开始学习嵌入式——C语言数值传递（值传递和地址传递）ue4----------理论（4.PBR)330Aiax应用get请求post请求json数据请求447帮自己了解疾病症状的健康APP，平时可以不用，关键时候必须要有！305椭流线法设计配光器558最新文章GO-日志分析Go异步任务Dubbogo详解2024年1篇2023年15篇2022年24篇2021年44篇2020年26篇2019年19篇2018年20篇2017年2篇目录目录分类专栏自动化测试1篇go语言21篇springDataMongoDB4篇spring26篇Springmvc4篇mybaties11篇LeetCode算法2篇Java并发18篇netty2篇安全框架2篇大数据2篇流程引擎activiti4篇hadoophibernateandroid1篇数据结构11篇数据库6篇java基础12篇目录评论被折叠的 条评论为什么被折叠?到【灌水乐园】发言查看更多评论添加红包祝福语请填写红包祝福语或标题红包数量个红包个数最小为10个红包总金额元红包金额最低5元余额支付当前余额3.43元前往充值>需支付：10.00元取消确定下一步知道了成就一亿技术人!领取后你会自动成为博主和红包主的粉丝规则hope_wisdom发出的红包实付元使用余额支付点击重新获取扫码支付钱包余额0抵扣说明：1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。余额充值"
]
}
[llm/end] [chain:RunnableSequence > llm:ChatOpenAI] [3.68s] Exiting LLM run with output:
{
"generations": [
[
{
"text": "这篇文档介绍了如何设置Chrome浏览器的二进制文件位置，添加启动参数和扩展应用。同时还展示了如何使用Node.js和`chrome-remote-interface`模块与ChromeDevToolsProtocol交互来读取和修改本地存储(`localStorage`)的值。文档中提供了一个简单的示例代码，但强调了在实际使用中需要对错误进行适当处理以确保程序的稳定性和可靠性。",
"generation_info": {
"finish_reason": "stop",
"logprobs": null
},
"type": "ChatGeneration",
"message": {
"lc": 1,
"type": "constructor",
"id": [
"langchain",
"schema",
"messages",
"AIMessage"
],
"kwargs": {
"content": "这篇文档介绍了如何设置Chrome浏览器的二进制文件位置，添加启动参数和扩展应用。同时还展示了如何使用Node.js和`chrome-remote-interface`模块与ChromeDevToolsProtocol交互来读取和修改本地存储(`localStorage`)的值。文档中提供了一个简单的示例代码，但强调了在实际使用中需要对错误进行适当处理以确保程序的稳定性和可靠性。",
"response_metadata": {
"token_usage": {
"completion_tokens": 130,
"prompt_tokens": 1374,
"total_tokens": 1504
},
"model_name": "gpt-3.5-turbo-0125",
"system_fingerprint": null,
"finish_reason": "stop",
"logprobs": null
},
"type": "ai",
"id": "run-be34d029-3537-4a93-9f0c-62536f41381f-0",
"usage_metadata": {
"input_tokens": 1374,
"output_tokens": 130,
"total_tokens": 1504
},
"tool_calls": [],
"invalid_tool_calls": []
}
}
}
]
],
"llm_output": {
"token_usage": {
"completion_tokens": 130,
"prompt_tokens": 1374,
"total_tokens": 1504
},
"model_name": "gpt-3.5-turbo-0125",
"system_fingerprint": null
},
"run": null
}
[llm/end] [chain:RunnableSequence > llm:ChatOpenAI] [5.24s] Exiting LLM run with output:
{
"generations": [
[
{
"text": "该文档总结了CDP和ChromeDevToolsProtocol（CDP）以及WebDriverProtocol之间的区别和联系。CDP和WebDriverProtocol是用于自动化浏览器的两个主要协议，大多数的浏览器自动化工具都是基于其中之一来实现的。WebDriverProtocol是一个用于控制浏览器的远程控制接口，而ChromeDevToolsProtocol是一个基于Chromium的浏览器的调试协议。通过这两种协议，可以通过代码来控制浏览器，完成浏览器的自动化行为。文中还介绍了Puppeteer和Playwright这两个工具，它们不依赖于WebDriver，而是直接通过ChromeDevToolsProtocol与浏览器通信，从而更加灵活和稳定地控制浏览器。最后，文中还提到了一些关于使用ChromeDevToolsProtocol的注意事项和建议，以及一些相关的资源链接。",
"generation_info": {
"finish_reason": "stop",
"logprobs": null
},
"type": "ChatGeneration",
"message": {
"lc": 1,
"type": "constructor",
"id": [
"langchain",
"schema",
"messages",
"AIMessage"
],
"kwargs": {
"content": "该文档总结了CDP和ChromeDevToolsProtocol（CDP）以及WebDriverProtocol之间的区别和联系。CDP和WebDriverProtocol是用于自动化浏览器的两个主要协议，大多数的浏览器自动化工具都是基于其中之一来实现的。WebDriverProtocol是一个用于控制浏览器的远程控制接口，而ChromeDevToolsProtocol是一个基于Chromium的浏览器的调试协议。通过这两种协议，可以通过代码来控制浏览器，完成浏览器的自动化行为。文中还介绍了Puppeteer和Playwright这两个工具，它们不依赖于WebDriver，而是直接通过ChromeDevToolsProtocol与浏览器通信，从而更加灵活和稳定地控制浏览器。最后，文中还提到了一些关于使用ChromeDevToolsProtocol的注意事项和建议，以及一些相关的资源链接。",
"response_metadata": {
"token_usage": {
"completion_tokens": 267,
"prompt_tokens": 5185,
"total_tokens": 5452
},
"model_name": "gpt-3.5-turbo-0125",
"system_fingerprint": null,
"finish_reason": "stop",
"logprobs": null
},
"type": "ai",
"id": "run-47b8c2ab-b507-4444-a1c2-e4585a99200b-0",
"usage_metadata": {
"input_tokens": 5185,
"output_tokens": 267,
"total_tokens": 5452
},
"tool_calls": [],
"invalid_tool_calls": []
}
}
}
]
],
"llm_output": {
"token_usage": {
"completion_tokens": 267,
"prompt_tokens": 5185,
"total_tokens": 5452
},
"model_name": "gpt-3.5-turbo-0125",
"system_fingerprint": null
},
"run": null
}
[chain/start] [chain:RunnableSequence > parser:StrOutputParser] Entering Parser run with input:
[inputs]
[chain/end] [chain:RunnableSequence > parser:StrOutputParser] [2ms] Exiting Parser run with output:
{
"output": "这篇文档介绍了如何设置Chrome浏览器的二进制文件位置，添加启动参数和扩展应用。同时还展示了如何使用Node.js和`chrome-remote-interface`模块与ChromeDevToolsProtocol交互来读取和修改本地存储(`localStorage`)的值。文档中提供了一个简单的示例代码，但强调了在实际使用中需要对错误进行适当处理以确保程序的稳定性和可靠性。"
}
[chain/start] [chain:RunnableSequence > parser:StrOutputParser] Entering Parser run with input:
[inputs]
[chain/end] [chain:RunnableSequence > parser:StrOutputParser] [1ms] Exiting Parser run with output:
{
"output": "该文档总结了CDP和ChromeDevToolsProtocol（CDP）以及WebDriverProtocol之间的区别和联系。CDP和WebDriverProtocol是用于自动化浏览器的两个主要协议，大多数的浏览器自动化工具都是基于其中之一来实现的。WebDriverProtocol是一个用于控制浏览器的远程控制接口，而ChromeDevToolsProtocol是一个基于Chromium的浏览器的调试协议。通过这两种协议，可以通过代码来控制浏览器，完成浏览器的自动化行为。文中还介绍了Puppeteer和Playwright这两个工具，它们不依赖于WebDriver，而是直接通过ChromeDevToolsProtocol与浏览器通信，从而更加灵活和稳定地控制浏览器。最后，文中还提到了一些关于使用ChromeDevToolsProtocol的注意事项和建议，以及一些相关的资源链接。"
}
[chain/end] [chain:RunnableSequence] [5.25s] Exiting Chain run with output:
{
"output": "该文档总结了CDP和ChromeDevToolsProtocol（CDP）以及WebDriverProtocol之间的区别和联系。CDP和WebDriverProtocol是用于自动化浏览器的两个主要协议，大多数的浏览器自动化工具都是基于其中之一来实现的。WebDriverProtocol是一个用于控制浏览器的远程控制接口，而ChromeDevToolsProtocol是一个基于Chromium的浏览器的调试协议。通过这两种协议，可以通过代码来控制浏览器，完成浏览器的自动化行为。文中还介绍了Puppeteer和Playwright这两个工具，它们不依赖于WebDriver，而是直接通过ChromeDevToolsProtocol与浏览器通信，从而更加灵活和稳定地控制浏览器。最后，文中还提到了一些关于使用ChromeDevToolsProtocol的注意事项和建议，以及一些相关的资源链接。"
}
[chain/end] [chain:RunnableSequence] [5.25s] Exiting Chain run with output:
{
"output": "这篇文档介绍了如何设置Chrome浏览器的二进制文件位置，添加启动参数和扩展应用。同时还展示了如何使用Node.js和`chrome-remote-interface`模块与ChromeDevToolsProtocol交互来读取和修改本地存储(`localStorage`)的值。文档中提供了一个简单的示例代码，但强调了在实际使用中需要对错误进行适当处理以确保程序的稳定性和可靠性。"
}
# The vectorstore to use to index the child chunks
vectorstore = Chroma(collection_name="summaries", embedding_function=OpenAIEmbeddings())
# The storage layer for the parent documents
store = InMemoryByteStore()
id_key = "doc_id"
# The retriever (empty to start)
retriever = MultiVectorRetriever(
vectorstore=vectorstore,
byte_store=store,
id_key=id_key,
)
print(summaries)
for item in summaries:
print(len(item))
doc_ids = [str(uuid.uuid4()) for _ in docs]
['该文档总结了CDP和ChromeDevToolsProtocol（CDP）以及WebDriverProtocol之间的区别和联系。CDP和WebDriverProtocol是用于自动化浏览器的两个主要协议，大多数的浏览器自动化工具都是基于其中之一来实现的。WebDriverProtocol是一个用于控制浏览器的远程控制接口，而ChromeDevToolsProtocol是一个基于Chromium的浏览器的调试协议。通过这两种协议，可以通过代码来控制浏览器，完成浏览器的自动化行为。文中还介绍了Puppeteer和Playwright这两个工具，它们不依赖于WebDriver，而是直接通过ChromeDevToolsProtocol与浏览器通信，从而更加灵活和稳定地控制浏览器。最后，文中还提到了一些关于使用ChromeDevToolsProtocol的注意事项和建议，以及一些相关的资源链接。', '这篇文档介绍了如何设置Chrome浏览器的二进制文件位置，添加启动参数和扩展应用。同时还展示了如何使用Node.js和`chrome-remote-interface`模块与ChromeDevToolsProtocol交互来读取和修改本地存储(`localStorage`)的值。文档中提供了一个简单的示例代码，但强调了在实际使用中需要对错误进行适当处理以确保程序的稳定性和可靠性。']
399
191
# 遍历总结，生成总结docs，key还是uuid
summary_docs = [
Document(page_content=s, metadata={id_key: doc_ids[i]})
for i, s in enumerate(summaries)
]
# 向量化总结
retriever.vectorstore.add_documents(summary_docs)
# 存储原始文档的映射关系
retriever.docstore.mset(list(zip(doc_ids, docs)))
sub_docs = vectorstore.similarity_search("WebDriver是什么")
for item in sub_docs:
print(len(item.page_content)) # 从输出的文档长度看，就是上面总结的文档
Number of requested results 4 is greater than number of elements in index 2, updating n_results = 2
399
191
retrieved_docs = retriever.invoke("WebDriver是什么")
print(len(retrieved_docs[0].page_content))
Number of requested results 4 is greater than number of elements in index 2, updating n_results = 2
9893
假设性查询(Hypothetical Queries)#
利用LLM来生成一系列的提问，对这些问题做Embedding。
# 定义输出结构
functions = [
{
"name": "hypothetical_questions",
"description": "生成的假设性问题",
"parameters": {
"type": "object",
"properties": {
"questions": {
"type": "array",
"items": {"type": "string"},
},
},
"required": ["questions"],
},
}
]
from langchain.output_parsers.openai_functions import JsonKeyOutputFunctionsParser
chain = (
{"doc": lambda x: x.page_content}
# Only asking for 3 hypothetical questions, but this could be adjusted
| ChatPromptTemplate.from_template(
"生成一个包含3个假设性问题的列表，中文回答，这些问题可以通过下面的文档来回答：\n\n{doc}"
)
# 给openAI绑定了工具
| ChatOpenAI(max_retries=0, model="gpt-4").bind(
functions=functions, function_call={"name": "hypothetical_questions"}
)
| JsonKeyOutputFunctionsParser(key_name="questions")
)
chain.invoke(docs[0])
[chain/start] [chain:RunnableSequence] Entering Chain run with input:
[inputs]
[chain/start] [chain:RunnableSequence > chain:RunnableParallel<doc>] Entering Chain run with input:
[inputs]
[chain/start] [chain:RunnableSequence > chain:RunnableParallel<doc> > chain:RunnableLambda] Entering Chain run with input:
[inputs]
[chain/end] [chain:RunnableSequence > chain:RunnableParallel<doc> > chain:RunnableLambda] [0ms] Exiting Chain run with output:
{
"output": "CDP和Chrome_chrome devtools protocol-CSDN博客\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nCDP和Chrome\n\n\n\n\n\ndaliucheng\n\n已于 2024-02-19 00:07:33 修改\n\n\n阅读量1.7k\n\n\n\n收藏\n\n 21\n \n\n\n\n\n点赞数\n 27\n \n\n\n\n\n\n\n分类专栏：\n自动化测试\n文章标签：\nchrome\n自动化\npython\nnode.js\n\n\n于 2024-02-18 23:45:32 首次发布\n\n\n\n 版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。\n \n\n 本文链接：https://blog.csdn.net/daliucheng/article/details/136160807\n\n\n\n\n版权\n\n\n\n\n\n\n\n\n\n\n\n\n\n自动化测试\n专栏收录该内容\n\n\n\n\n\n1 篇文章\n0 订阅\n\n\n订阅专栏\n\n\n\n\n\n\n\n\n\n\n\n\nCDP和Chrome\nCDP和WebDriver Protocol\nWebDriver和 Chrome DevTools Protocol（CDP） 是用于自动化浏览器的两个主要协议，大多数的浏览器自动化工具都是基于上述其中之一来实现的。可以通过这两种形式来和浏览器交互，通过代码来控制浏览器，完成浏览器的自动化行为（包括网页加载，爬虫，截图，导出pdf等）。\nWebDriver Protocol\n官网地址：链接\nWebDriver 是一个用于控制浏览器的远程控制接口，由 Selenium HQ 开发，后来由 W3C 标准化。它提供了一个平台和语言中立的接口，支持几乎所有主流浏览器，如 Chrome、 Firefox、 Safari、 Edge、 Opera 等。\n它和浏览器的通信是通过 JSON Wire 协议完成的，提供了RESTful的web服务，这个服务端就被称为服务端（也被称为webdriver），例如chromeDriver、geckoDriver等。\n有服务端就有客户端，客户端可以选择任何语言，客户端和服务端交互，服务端和浏览器交互，从而操作浏览器。常见的客户端就是selenium,nightwatch,webdriverio \n加上我们的自己写的自动化测试代码之后，交互流程如下：\n\nChrome DevTools Protocol\n官网地址：链接\nChromeDevTools Protocol (CDP)是一个基于 Chromium 的浏览器的调试协议，如 Chrome、 Edge、 Opera 等。通过它可以直接和浏览器交互。控制浏览器的行为。\n客户端和浏览器之间没有类似于WebDriver Protocol的服务端（webdriver），而是客户端通过WebSocket直接和浏览器连\n类似网络驱动服务器(浏览器驱动程序)的中间人。相反，浏览器是由客户端使用 CDP 直接控制的。与浏览器的通信是通过套接字连接完成的，因此也支持双向通信。客户端通过WebSocket发送命令给浏览器，浏览器执行并返回响应。\n\n两个相当流行的工具是Puppeteer和Playwright。它们不依赖于webdriver，而是通过 Chrome DevTools Protocol (CDP)直接与浏览器通话。从而更加灵活稳定的控制浏览器。\n区别\n从代码层面来看，使用的代码接近底层，接近浏览器，代码就会变得更加的稳定和强大，但对于跨浏览器的支持会变得更少。另一方面，代码和浏览器的之间的抽象程度越高，支持的浏览器就越多，但代码会变得不稳定并且功能受限。\n对比上面两种\n WebDriver Protocol 支持的浏览器多，但不是很稳定，并且功能不强大。 Chrome DevTools Protocol 支持的浏览器少（只是相对WebDriver来说，Chrome能支持就能用），功能强大，稳定。 \nWebdriver ProtocolChrome DevTools ProtocolDeveloped by: W3CDeveloped by: Chrome Developer Tools需要webdriver不需要webdriver相对较慢并且不是很稳定速度快，较稳定支持的浏览器多支持部分浏览器无法通过提供的api来访问浏览器中网络相关的信息可以通过api来访问网络相关的信息它的实现有：Selenium WebDriver 3, WebdriverIO, Nightwatch它的实现有：Playwright, Puppeteer, Selenium Webdriver 4, Cypress v7\n不同的WebDriver有不同的实现方式，chromeDriver内部是通过DevTools protoco来控制浏览器的。\n如何选择\n如果跨浏览器很重要，就选webDriver，否则选择CDP\npuppeteer\n链接：官网，github，github-examples\nPuppeteer 是 Chrome 开发团队在 2017 年发布的一个 Node.js 包，是它提供了一个高级 API，通过 DevTools 协议控制 Chrome/Chromium。\n为什么选择它？\n两个理由\ngithub中star数多Chrome开发团队\n可以做什么？\n简单来说，浏览器能做的，它都能做\n截图和生成PDF爬取 SPA 或 SSR 网站UI 自动化测试…\n版本说明\n从v1.7.0 版本以来，每次发布都会发布两个软件包：\n puppeteer\n\n它会自动下载一个最新版本的 Chrome 用于测试（macOS 约 170MB，Linux 约 282MB，Windows 约 280MB）以及一个 chrome-headless-shell 二进制文件（从 Puppeteer v21.6.0 开始），这个二进制文件保证可以与 Puppeteer 配合正常工作。默认情况下，浏览器会下载到 $HOME/.cache/puppeteer 文件夹中（从 Puppeteer v19.0.0 开始）。\n通过puppeteer-core 控制它下载的浏览器\n puppeteer-core\n\npuppeteer-core 是一个库，用于帮助驱动任何支持 DevTools 协议的内容。\n它不会下载浏览器，它提供了封装好的API和浏览器交互。\n如果自己已经下载了浏览器，就可以使用它，但是必须在调用puppeteer.launch的时候显式的指定executablePath(浏览器的执行位置)\n 一般来说我会使用这个 \n代码\n建议看这篇文章 结合项目来谈谈 Puppeteer 在结合 github-examples的例子。\n注意点\n 在部署的时候，建议使用容器化，Chrome本身是内存大户，如果遇到内存飙升，代码是不太好发现这种情况的，不能及时kill掉。 在加载网页的时候不建议每次都关闭和开启一个新的。 Chrome的启动和关系是比较耗时的，每次启动会慢150ms到300ms 建议重复使用同一个Chrome。 Chrome使用一段时间之后，要关掉重启。 Chrome在我们自己的电脑中有的时候，页面都会崩溃，浏览器也会崩溃。在服务器这种情况下，肯定也会出现，建议在内存中设置调用阈值，比如加载了100个网页，重启一次。这样可降低崩溃的概率。 容器化部署之后，建议一个容器中只启动一个Chrome。 这样会让代码简单并且出现问题好排查。这就要求Chrome在代码中是单例 在整个Chrome做操作期间，对Chrome崩溃的情况做处理 在业务代码期间，建议使用try catch 来捕获异常，对于非业务异常，需要关闭掉Chrome。防止出现多个Chrome。 Chrome在关闭的时候出现异常，也需要处理 在调用close()api来关闭Chrome的时候，可能会报错（可能Chrome在这个时候被操作系统kill掉，会出现孤儿进程）。 建议：在这个时候直接通过shell脚本来强行kill掉 #!/bin/bash\n\npids=$(ps -ef | grep \"[c]hrome\" | grep -v 'kill_chrome_processes.sh' |awk '{print $2}')\n\nfor pid in $pids; do\n echo \"Terminating PID $pid\"\n kill $pid\ndone\n\necho \"All chrome processes have been terminated.\"\n\n\n孤儿进程：\n父进程启动了子进程，子进程在没有退出的情况下，父进程退出了。此时子进程会被init进程接管。\n 尽量关闭掉无用的功能，让他越简单越好。 比如：-no-sandbox,--disable-extensions,--disable-gpu,--disable_scrollbars 共享内存\n\nChrome 默认使用 /dev/shm 共享内存，但是 docker 默认/dev/shm 只有64MB，显然是不够使用的，提供两种方式来解决：\n启动 docker 时添加参数 --shm-size=1gb 来增大 /dev/shm 共享内存，但是 swarm 目前不支持 shm-size 参数启动 Chrome 添加参数 - disable-dev-shm-usage，禁止使用 /dev/shm 共享内存\n \n参考文档\nhttps://www.neovasolutions.com/2022/05/19/browser-automation-tools-protocols-webdriver-vs-cdp/https://dev.to/jankaritech/different-approaches-protocols-to-automate-the-browser-39f1https://stackoverflow.com/questions/50939116/what-is-the-difference-between-webdriver-and-devtool-protocolhttps://zhuanlan.zhihu.com/p/76237595\n 关于博客这件事，我是把它当做我的笔记，里面有很多的内容反映了我思考的过程，因为思维有限，不免有些内容有出入，如果有问题，欢迎指出。一同探讨。谢谢。\n \n\n\n\n\n\n\n\n\n\n\n\n\n\n 确定要放弃本次机会？\n \n福利倒计时\n\n\n:\n\n:\n\n\n\n\n\n立减 ¥\n\n\n普通VIP年卡可用\n\n立即使用\n\n \n\n\n\n\n\n daliucheng\n \n\n\n\n关注\n关注\n\n\n\n\n\n\n\n\n\n\n 27\n \n\n点赞\n\n\n\n\n\n\n\n踩\n\n\n\n\n\n\n\n 21\n \n\n\n\n\n 收藏\n \n\n\n\n\n 觉得还不错?\n \n 一键收藏\n \n\n\n\n\n\n\n\n知道了\n\n\n\n\n 0\n \n\n评论\n\n\n\n\n\n\n\n\n\n\n\n\n\n CDP和Chrome\n \n\n WebDriver和是用于自动化浏览器的两个主要协议，大多数的浏览器自动化工具都是基于上述其中之一来实现的。可以通过这两种形式来和浏览器交互，通过代码来控制浏览器，完成浏览器的自动化行为（包括网页加载，爬虫，截图，导出pdf等）。\n \n复制链接\n\n\n\n扫一扫\n\n\n\n\n\n\n\n\n\n\n专栏目录\n\n\n\n\n\n\n\n \n\n\n\n\n\nPython cdp ( Chrome DevTools Protocol ) 爬虫\n\n\n\n\n墨鱼菜鸡\n\n\n07-11\n\n\t\t\t\t\t3265\n\t\t\t\t\t\n\n\n\n\n\ndevtools-protocol：https://github.com/ChromeDevTools/devtools-protocol Chrome DevTools Protocol：https://chromedevtools.github.io/devtools-protocol/ Awesome Chrome DevTools ：https:...\n\n\n\n\n\n\n\n\n\n\n\n\nChrome DevTools Protocol(谷歌开发者工具协议)Protocol Monitor（协议监视器）\n\n\n\n\nllrraa2010的专栏\n\n\n06-10\n\n\t\t\t\t\t2633\n\t\t\t\t\t\n\n\n\n\n\n该协议最初是由谷歌开发者工具团队维护的，负责调试、操作浏览器的协议。我们经常使用到的谷歌浏览器的开发者工具（快捷键 CTRL + SHIFT + I 或者 F12）就是使用这个协议来操作浏览器的。与 Selenium 需要与浏览器驱动进行交互不同的是，Chrome DevTools 协议直接通过 Web Socket 协议与浏览器暴露的 API 进行通信，这使得 Chrome DevTools 协议操作浏览器变得更快。我们要重启开发者工具，在右侧点击更多工具，这样就可以看到协议监视器面板了。\n\n\n\n\n\n\n\n\n参与评论\n您还未登录，请先\n登录\n后发表或查看评论\n\n\n\n\n\n\n\n\n\n探索Web开发新维度：Devtools-Protocol\n最新发布\n\n\n\n\ngitblog_00001的博客\n\n\n05-15\n\n\t\t\t\t\t353\n\t\t\t\t\t\n\n\n\n\n\n探索Web开发新维度：Devtools-Protocol\n项目地址:https://gitcode.com/ChromeDevTools/devtools-protocol\n项目介绍\n在Web开发的世界中，Chrome DevTools Protocol（DTP）是连接开发者和浏览器内核的桥梁，它允许我们进行深度的调试、性能分析以及自动化测试。而devtools-protocol是一个官方维护的开...\n\n\n\n\n\n\n\n\n\nusus使用Chrome调试协议CDP渲染页面\n\n\n\n\n08-08\n\n\n\n\n\nusus 使用Chrome调试协议（CDP）渲染页面。 提取用于渲染页面的CSS。 渲染带有阻塞CSS的HTML异步。\n\n\n\n\n\n\n\n\n\n\n\n浏览器自动化必须知道CDP协议\n\n\n\n\n白天安全建设，晚上全栈开发，大模型爱好者。公众号：飞羽技术工坊。\n\n\n01-13\n\n\t\t\t\t\t1067\n\t\t\t\t\t\n\n\n\n\n\n之前搞自动化页面，因为有一个获取网络日志的需求，让我发现了新的知识盲区——CDP协议。\n\n\n\n\n\n\n\n\n\nChrome DevTools 通过 cdp 调节 CPU Throttling\n\n\n\n\n时丶光\n\n\n11-26\n\n\t\t\t\t\t927\n\t\t\t\t\t\n\n\n\n\n\n打开DevTools (快捷键ctrl + shift + i)\n\n在DevTools 界面再打开DevTools\n\n\n\n\nlet Main = await import('./devtools-frontend/front_end/entrypoints/main/main.js'); // or './entrypoints/main/main.js' or './main/main.js' depending on the browser version\n\n//设置CPU Throttling 为本机\n\n\n\n\n\n\n\n\n\ncdp:软件包cdp为使用Go编程语言编写的Chrome DevTools协议（CDP）提供了类型安全的绑定\n\n\n\n\n05-04\n\n\n\n\n\n光盘\n 软件包cdp为使用Go编程语言编写的（CDP）提供了类型安全的绑定。 绑定是由根据最新协议定义生成的，并且主要用于Google Chrome或Chromium，但是它们可以与任何调试目标（ ， ， 等）。\n 通过Chrome DevTools协议，该软件包可用于任何类型的浏览器自动化，脚本编写或调试。\n cdp主要动机是公开Chrome DevTools协议的全部功能，并以一种可发现的自记录方式提供它。\n 提供高级浏览器自动化对于该项目而言是不可行的。 话虽如此， cdp希望通过提供更适合Go的原语并自动执行重复性任务来改善使用该协议的人体工程学。\n特征\n适用于Chrome DevTools协议的可发现API（GoDoc，自动完成友好）\n 作为头等公民的情况（用于超时和取消）\n 简单且同步的事件处理（无回调）\n 同时安全\n没有无声或隐藏的错误\n做到用户期望的\n尽可能将CDP类型与\n\n\n\n\n\n\n\n\n\nichrome：适用于人类的Chrome控制器，基于Chrome Devtools协议（CDP）和python3.7 +\n\n\n\n\n01-31\n\n\n\n\n\n适用于人类的Chrome控制器，基于和python3.7 +。为什么？ Pyppeteer很棒，但是我不需要那么多pyppeteer的拼写很混乱事件驱动的编程并非总是明智的。 Selenium慢网络驱动程序经常带有内存泄漏。 迫切需要一个稳定的...\n\n\n\n\n\n\n\n\n\nselenium_cdp：Selenium 4x，执行Chrome DevTools协议命令\n\n\n\n\n01-31\n\n\n\n\n\n该项目采用Java Selenium 4.0.x版本的来执行（也称为cdp命令），这是一套完全不同的API，通过对/session/$sessionId/goog/cdp/execute POST POST 传达给Chrome浏览器系列，特定的有效负载）功能（许多cdp方法，例如...\n\n\n\n\n\n\n\n\n\ncdp4j：cdp4j-适用于Java的Chrome DevTools协议\n\n\n\n\n01-28\n\n\n\n\n\ncdp4j是Java库，具有清晰简洁的API，可自动执行基于Chrome / Chromium的浏览器。 它使用Google Chrome DevTools协议来自动化基于Chrome / Chromium的浏览器。 cdp4j可以做什么？ 自动填写表格。 您可以轻松下载和...\n\n\n\n\n\n\n\n\n\ngetting-started-with-cdp:Chrome DevTools 协议入门\n\n\n\n\n07-24\n\n\n\n\n\n使用 Chrome DevTools 协议在直接使用 CDP 进行浏览器自动化之前要三思。 有会让你过得更好不服气？ 至少使用 。 另请参阅介绍注意： ://vanilla.aslushnikov.com 提供了交互式协议查看器。 Chrome DevTools 协议...\n\n\n\n\n\n\n\n\n\nChrome之远程调试协议（Remote debugging protocol） - Div.IO\n\n\n\n\nweixin_33940102的博客\n\n\n06-27\n\n\t\t\t\t\t1781\n\t\t\t\t\t\n\n\n\n\n\nChrome之远程调试协议（Remote debugging protocol） - Div.IO\n\n\n\n\n\n\n\n\n\n一文读懂UI自动化测试三种核心实现原理：Native、Webdriver和CDP\n\n\n\n\nliwenxiang629的博客\n\n\n04-03\n\n\t\t\t\t\t808\n\t\t\t\t\t\n\n\n\n\n\n相信80%的UI自动化测试工程师在进行岗位面试的时候都会重点讲解自己会使用哪些工具，例如cypress 、selenium 、playwright等等。其实这只是初级段位，如果大家想谈得再高大上一些，就可以谈谈这些工具与浏览器talk的原理了，绝对会得到面试官的重视！目前主流主动化测试工具与浏览器沟通的原理主要包括：Native、Webdriver以及CDP，使用这三种方式的典型代表工具分别是：cypress 、selenium 和playwright。今天我就对此进行总结：\n\n\n\n\n\n\n\n\n\n朋友们，一起学习下 Chrome DevTools Protocol。\n\n\n\n\nz_l_x_的博客\n\n\n10-18\n\n\t\t\t\t\t3072\n\t\t\t\t\t\n\n\n\n\n\n1947 年 9 月 9 日，First actual case of bug being found，自此引入了 Debugging。\n\n\n\n\n\n\n\n\n\nCDP 远程调试方案\n\n\n\n\n老司机的后备箱\n\n\n05-23\n\n\t\t\t\t\t3656\n\t\t\t\t\t\n\n\n\n\n\n什么是 cdp 协议\ncdp 协议简称 chrome 调试协议，是基于 scoket（websocket、usb、adb ）消息的 json rpc 协议。用来调用 chrome 内部的方法实现 js，css ，dom 的开发调试。 可以将 实现了 cdp 协议的应用 看做 rpc 调用的服务端（ chrome ，puppeteer）， 将调试面板看做 rpc 调用的客户端（devtools）。\ndevtools 调试系统\n完整的调试系统分别由前端，后端，协议，通道四部分组成\n\nFrontend：调试器前端\n\n\n\n\n\n\n\n\n\nGo Chromedp库得使用----CDP（Chrome DevTools Protocol)\n\n\n\n\n路小白的博客\n\n\n12-24\n\n\t\t\t\t\t8813\n\t\t\t\t\t\n\n\n\n\n\nGo chromedp库的使用 —CDP\n文章目录Go chromedp库的使用 ---CDPCDP（Chrome DevTools Protocol)基于CDP协议的相关语言操作Chromedp使用示例本地界面浏览器操作远程操作示例（无头浏览器）Centos 安装chronium-headless示例代码Browsesrless/chrome部署Linux-Centos安装NodeJS参考\nCDP（Chrome DevTools Protocol)\nChrome DevTools Protocol 是基.\n\n\n\n\n\n\n\n\n\n【学习笔记】selenium ChromeDriver 移除navigator.webdriver属性\n\n\n\n\nMONKEYMONEY_的博客\n\n\n12-16\n\n\t\t\t\t\t906\n\t\t\t\t\t\n\n\n\n\n\n作为新手的我，\n在刚接触selenium时不了解的\nChrome Driver 一些常用属性和方法。\n为此特意记录了以下几项并加上注释，方便以后查阅调用。\n\n\n \nSelenium中的ChromeOptions选项\n\n\nchromeOptions是一个配置chrome启动属性的类。通过这个类，我们可以为chrome配置如下参数（这个部分可以通过selenium源码看到）：\n\n设置 chrome 二进制文件位置 (binary_location)\n添加启动参数 (add_argument)\n添加扩展应用 (a\n\n\n\n\n\n\n\n\n\nChrome DevTools Protocol localstorage\n\n\n\n\n06-07"
}
[chain/end] [chain:RunnableSequence > chain:RunnableParallel<doc>] [3ms] Exiting Chain run with output:
{
"doc": "CDP和Chrome_chrome devtools protocol-CSDN博客\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nCDP和Chrome\n\n\n\n\n\ndaliucheng\n\n已于 2024-02-19 00:07:33 修改\n\n\n阅读量1.7k\n\n\n\n收藏\n\n 21\n \n\n\n\n\n点赞数\n 27\n \n\n\n\n\n\n\n分类专栏：\n自动化测试\n文章标签：\nchrome\n自动化\npython\nnode.js\n\n\n于 2024-02-18 23:45:32 首次发布\n\n\n\n 版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。\n \n\n 本文链接：https://blog.csdn.net/daliucheng/article/details/136160807\n\n\n\n\n版权\n\n\n\n\n\n\n\n\n\n\n\n\n\n自动化测试\n专栏收录该内容\n\n\n\n\n\n1 篇文章\n0 订阅\n\n\n订阅专栏\n\n\n\n\n\n\n\n\n\n\n\n\nCDP和Chrome\nCDP和WebDriver Protocol\nWebDriver和 Chrome DevTools Protocol（CDP） 是用于自动化浏览器的两个主要协议，大多数的浏览器自动化工具都是基于上述其中之一来实现的。可以通过这两种形式来和浏览器交互，通过代码来控制浏览器，完成浏览器的自动化行为（包括网页加载，爬虫，截图，导出pdf等）。\nWebDriver Protocol\n官网地址：链接\nWebDriver 是一个用于控制浏览器的远程控制接口，由 Selenium HQ 开发，后来由 W3C 标准化。它提供了一个平台和语言中立的接口，支持几乎所有主流浏览器，如 Chrome、 Firefox、 Safari、 Edge、 Opera 等。\n它和浏览器的通信是通过 JSON Wire 协议完成的，提供了RESTful的web服务，这个服务端就被称为服务端（也被称为webdriver），例如chromeDriver、geckoDriver等。\n有服务端就有客户端，客户端可以选择任何语言，客户端和服务端交互，服务端和浏览器交互，从而操作浏览器。常见的客户端就是selenium,nightwatch,webdriverio \n加上我们的自己写的自动化测试代码之后，交互流程如下：\n\nChrome DevTools Protocol\n官网地址：链接\nChromeDevTools Protocol (CDP)是一个基于 Chromium 的浏览器的调试协议，如 Chrome、 Edge、 Opera 等。通过它可以直接和浏览器交互。控制浏览器的行为。\n客户端和浏览器之间没有类似于WebDriver Protocol的服务端（webdriver），而是客户端通过WebSocket直接和浏览器连\n类似网络驱动服务器(浏览器驱动程序)的中间人。相反，浏览器是由客户端使用 CDP 直接控制的。与浏览器的通信是通过套接字连接完成的，因此也支持双向通信。客户端通过WebSocket发送命令给浏览器，浏览器执行并返回响应。\n\n两个相当流行的工具是Puppeteer和Playwright。它们不依赖于webdriver，而是通过 Chrome DevTools Protocol (CDP)直接与浏览器通话。从而更加灵活稳定的控制浏览器。\n区别\n从代码层面来看，使用的代码接近底层，接近浏览器，代码就会变得更加的稳定和强大，但对于跨浏览器的支持会变得更少。另一方面，代码和浏览器的之间的抽象程度越高，支持的浏览器就越多，但代码会变得不稳定并且功能受限。\n对比上面两种\n WebDriver Protocol 支持的浏览器多，但不是很稳定，并且功能不强大。 Chrome DevTools Protocol 支持的浏览器少（只是相对WebDriver来说，Chrome能支持就能用），功能强大，稳定。 \nWebdriver ProtocolChrome DevTools ProtocolDeveloped by: W3CDeveloped by: Chrome Developer Tools需要webdriver不需要webdriver相对较慢并且不是很稳定速度快，较稳定支持的浏览器多支持部分浏览器无法通过提供的api来访问浏览器中网络相关的信息可以通过api来访问网络相关的信息它的实现有：Selenium WebDriver 3, WebdriverIO, Nightwatch它的实现有：Playwright, Puppeteer, Selenium Webdriver 4, Cypress v7\n不同的WebDriver有不同的实现方式，chromeDriver内部是通过DevTools protoco来控制浏览器的。\n如何选择\n如果跨浏览器很重要，就选webDriver，否则选择CDP\npuppeteer\n链接：官网，github，github-examples\nPuppeteer 是 Chrome 开发团队在 2017 年发布的一个 Node.js 包，是它提供了一个高级 API，通过 DevTools 协议控制 Chrome/Chromium。\n为什么选择它？\n两个理由\ngithub中star数多Chrome开发团队\n可以做什么？\n简单来说，浏览器能做的，它都能做\n截图和生成PDF爬取 SPA 或 SSR 网站UI 自动化测试…\n版本说明\n从v1.7.0 版本以来，每次发布都会发布两个软件包：\n puppeteer\n\n它会自动下载一个最新版本的 Chrome 用于测试（macOS 约 170MB，Linux 约 282MB，Windows 约 280MB）以及一个 chrome-headless-shell 二进制文件（从 Puppeteer v21.6.0 开始），这个二进制文件保证可以与 Puppeteer 配合正常工作。默认情况下，浏览器会下载到 $HOME/.cache/puppeteer 文件夹中（从 Puppeteer v19.0.0 开始）。\n通过puppeteer-core 控制它下载的浏览器\n puppeteer-core\n\npuppeteer-core 是一个库，用于帮助驱动任何支持 DevTools 协议的内容。\n它不会下载浏览器，它提供了封装好的API和浏览器交互。\n如果自己已经下载了浏览器，就可以使用它，但是必须在调用puppeteer.launch的时候显式的指定executablePath(浏览器的执行位置)\n 一般来说我会使用这个 \n代码\n建议看这篇文章 结合项目来谈谈 Puppeteer 在结合 github-examples的例子。\n注意点\n 在部署的时候，建议使用容器化，Chrome本身是内存大户，如果遇到内存飙升，代码是不太好发现这种情况的，不能及时kill掉。 在加载网页的时候不建议每次都关闭和开启一个新的。 Chrome的启动和关系是比较耗时的，每次启动会慢150ms到300ms 建议重复使用同一个Chrome。 Chrome使用一段时间之后，要关掉重启。 Chrome在我们自己的电脑中有的时候，页面都会崩溃，浏览器也会崩溃。在服务器这种情况下，肯定也会出现，建议在内存中设置调用阈值，比如加载了100个网页，重启一次。这样可降低崩溃的概率。 容器化部署之后，建议一个容器中只启动一个Chrome。 这样会让代码简单并且出现问题好排查。这就要求Chrome在代码中是单例 在整个Chrome做操作期间，对Chrome崩溃的情况做处理 在业务代码期间，建议使用try catch 来捕获异常，对于非业务异常，需要关闭掉Chrome。防止出现多个Chrome。 Chrome在关闭的时候出现异常，也需要处理 在调用close()api来关闭Chrome的时候，可能会报错（可能Chrome在这个时候被操作系统kill掉，会出现孤儿进程）。 建议：在这个时候直接通过shell脚本来强行kill掉 #!/bin/bash\n\npids=$(ps -ef | grep \"[c]hrome\" | grep -v 'kill_chrome_processes.sh' |awk '{print $2}')\n\nfor pid in $pids; do\n echo \"Terminating PID $pid\"\n kill $pid\ndone\n\necho \"All chrome processes have been terminated.\"\n\n\n孤儿进程：\n父进程启动了子进程，子进程在没有退出的情况下，父进程退出了。此时子进程会被init进程接管。\n 尽量关闭掉无用的功能，让他越简单越好。 比如：-no-sandbox,--disable-extensions,--disable-gpu,--disable_scrollbars 共享内存\n\nChrome 默认使用 /dev/shm 共享内存，但是 docker 默认/dev/shm 只有64MB，显然是不够使用的，提供两种方式来解决：\n启动 docker 时添加参数 --shm-size=1gb 来增大 /dev/shm 共享内存，但是 swarm 目前不支持 shm-size 参数启动 Chrome 添加参数 - disable-dev-shm-usage，禁止使用 /dev/shm 共享内存\n \n参考文档\nhttps://www.neovasolutions.com/2022/05/19/browser-automation-tools-protocols-webdriver-vs-cdp/https://dev.to/jankaritech/different-approaches-protocols-to-automate-the-browser-39f1https://stackoverflow.com/questions/50939116/what-is-the-difference-between-webdriver-and-devtool-protocolhttps://zhuanlan.zhihu.com/p/76237595\n 关于博客这件事，我是把它当做我的笔记，里面有很多的内容反映了我思考的过程，因为思维有限，不免有些内容有出入，如果有问题，欢迎指出。一同探讨。谢谢。\n \n\n\n\n\n\n\n\n\n\n\n\n\n\n 确定要放弃本次机会？\n \n福利倒计时\n\n\n:\n\n:\n\n\n\n\n\n立减 ¥\n\n\n普通VIP年卡可用\n\n立即使用\n\n \n\n\n\n\n\n daliucheng\n \n\n\n\n关注\n关注\n\n\n\n\n\n\n\n\n\n\n 27\n \n\n点赞\n\n\n\n\n\n\n\n踩\n\n\n\n\n\n\n\n 21\n \n\n\n\n\n 收藏\n \n\n\n\n\n 觉得还不错?\n \n 一键收藏\n \n\n\n\n\n\n\n\n知道了\n\n\n\n\n 0\n \n\n评论\n\n\n\n\n\n\n\n\n\n\n\n\n\n CDP和Chrome\n \n\n WebDriver和是用于自动化浏览器的两个主要协议，大多数的浏览器自动化工具都是基于上述其中之一来实现的。可以通过这两种形式来和浏览器交互，通过代码来控制浏览器，完成浏览器的自动化行为（包括网页加载，爬虫，截图，导出pdf等）。\n \n复制链接\n\n\n\n扫一扫\n\n\n\n\n\n\n\n\n\n\n专栏目录\n\n\n\n\n\n\n\n \n\n\n\n\n\nPython cdp ( Chrome DevTools Protocol ) 爬虫\n\n\n\n\n墨鱼菜鸡\n\n\n07-11\n\n\t\t\t\t\t3265\n\t\t\t\t\t\n\n\n\n\n\ndevtools-protocol：https://github.com/ChromeDevTools/devtools-protocol Chrome DevTools Protocol：https://chromedevtools.github.io/devtools-protocol/ Awesome Chrome DevTools ：https:...\n\n\n\n\n\n\n\n\n\n\n\n\nChrome DevTools Protocol(谷歌开发者工具协议)Protocol Monitor（协议监视器）\n\n\n\n\nllrraa2010的专栏\n\n\n06-10\n\n\t\t\t\t\t2633\n\t\t\t\t\t\n\n\n\n\n\n该协议最初是由谷歌开发者工具团队维护的，负责调试、操作浏览器的协议。我们经常使用到的谷歌浏览器的开发者工具（快捷键 CTRL + SHIFT + I 或者 F12）就是使用这个协议来操作浏览器的。与 Selenium 需要与浏览器驱动进行交互不同的是，Chrome DevTools 协议直接通过 Web Socket 协议与浏览器暴露的 API 进行通信，这使得 Chrome DevTools 协议操作浏览器变得更快。我们要重启开发者工具，在右侧点击更多工具，这样就可以看到协议监视器面板了。\n\n\n\n\n\n\n\n\n参与评论\n您还未登录，请先\n登录\n后发表或查看评论\n\n\n\n\n\n\n\n\n\n探索Web开发新维度：Devtools-Protocol\n最新发布\n\n\n\n\ngitblog_00001的博客\n\n\n05-15\n\n\t\t\t\t\t353\n\t\t\t\t\t\n\n\n\n\n\n探索Web开发新维度：Devtools-Protocol\n项目地址:https://gitcode.com/ChromeDevTools/devtools-protocol\n项目介绍\n在Web开发的世界中，Chrome DevTools Protocol（DTP）是连接开发者和浏览器内核的桥梁，它允许我们进行深度的调试、性能分析以及自动化测试。而devtools-protocol是一个官方维护的开...\n\n\n\n\n\n\n\n\n\nusus使用Chrome调试协议CDP渲染页面\n\n\n\n\n08-08\n\n\n\n\n\nusus 使用Chrome调试协议（CDP）渲染页面。 提取用于渲染页面的CSS。 渲染带有阻塞CSS的HTML异步。\n\n\n\n\n\n\n\n\n\n\n\n浏览器自动化必须知道CDP协议\n\n\n\n\n白天安全建设，晚上全栈开发，大模型爱好者。公众号：飞羽技术工坊。\n\n\n01-13\n\n\t\t\t\t\t1067\n\t\t\t\t\t\n\n\n\n\n\n之前搞自动化页面，因为有一个获取网络日志的需求，让我发现了新的知识盲区——CDP协议。\n\n\n\n\n\n\n\n\n\nChrome DevTools 通过 cdp 调节 CPU Throttling\n\n\n\n\n时丶光\n\n\n11-26\n\n\t\t\t\t\t927\n\t\t\t\t\t\n\n\n\n\n\n打开DevTools (快捷键ctrl + shift + i)\n\n在DevTools 界面再打开DevTools\n\n\n\n\nlet Main = await import('./devtools-frontend/front_end/entrypoints/main/main.js'); // or './entrypoints/main/main.js' or './main/main.js' depending on the browser version\n\n//设置CPU Throttling 为本机\n\n\n\n\n\n\n\n\n\ncdp:软件包cdp为使用Go编程语言编写的Chrome DevTools协议（CDP）提供了类型安全的绑定\n\n\n\n\n05-04\n\n\n\n\n\n光盘\n 软件包cdp为使用Go编程语言编写的（CDP）提供了类型安全的绑定。 绑定是由根据最新协议定义生成的，并且主要用于Google Chrome或Chromium，但是它们可以与任何调试目标（ ， ， 等）。\n 通过Chrome DevTools协议，该软件包可用于任何类型的浏览器自动化，脚本编写或调试。\n cdp主要动机是公开Chrome DevTools协议的全部功能，并以一种可发现的自记录方式提供它。\n 提供高级浏览器自动化对于该项目而言是不可行的。 话虽如此， cdp希望通过提供更适合Go的原语并自动执行重复性任务来改善使用该协议的人体工程学。\n特征\n适用于Chrome DevTools协议的可发现API（GoDoc，自动完成友好）\n 作为头等公民的情况（用于超时和取消）\n 简单且同步的事件处理（无回调）\n 同时安全\n没有无声或隐藏的错误\n做到用户期望的\n尽可能将CDP类型与\n\n\n\n\n\n\n\n\n\nichrome：适用于人类的Chrome控制器，基于Chrome Devtools协议（CDP）和python3.7 +\n\n\n\n\n01-31\n\n\n\n\n\n适用于人类的Chrome控制器，基于和python3.7 +。为什么？ Pyppeteer很棒，但是我不需要那么多pyppeteer的拼写很混乱事件驱动的编程并非总是明智的。 Selenium慢网络驱动程序经常带有内存泄漏。 迫切需要一个稳定的...\n\n\n\n\n\n\n\n\n\nselenium_cdp：Selenium 4x，执行Chrome DevTools协议命令\n\n\n\n\n01-31\n\n\n\n\n\n该项目采用Java Selenium 4.0.x版本的来执行（也称为cdp命令），这是一套完全不同的API，通过对/session/$sessionId/goog/cdp/execute POST POST 传达给Chrome浏览器系列，特定的有效负载）功能（许多cdp方法，例如...\n\n\n\n\n\n\n\n\n\ncdp4j：cdp4j-适用于Java的Chrome DevTools协议\n\n\n\n\n01-28\n\n\n\n\n\ncdp4j是Java库，具有清晰简洁的API，可自动执行基于Chrome / Chromium的浏览器。 它使用Google Chrome DevTools协议来自动化基于Chrome / Chromium的浏览器。 cdp4j可以做什么？ 自动填写表格。 您可以轻松下载和...\n\n\n\n\n\n\n\n\n\ngetting-started-with-cdp:Chrome DevTools 协议入门\n\n\n\n\n07-24\n\n\n\n\n\n使用 Chrome DevTools 协议在直接使用 CDP 进行浏览器自动化之前要三思。 有会让你过得更好不服气？ 至少使用 。 另请参阅介绍注意： ://vanilla.aslushnikov.com 提供了交互式协议查看器。 Chrome DevTools 协议...\n\n\n\n\n\n\n\n\n\nChrome之远程调试协议（Remote debugging protocol） - Div.IO\n\n\n\n\nweixin_33940102的博客\n\n\n06-27\n\n\t\t\t\t\t1781\n\t\t\t\t\t\n\n\n\n\n\nChrome之远程调试协议（Remote debugging protocol） - Div.IO\n\n\n\n\n\n\n\n\n\n一文读懂UI自动化测试三种核心实现原理：Native、Webdriver和CDP\n\n\n\n\nliwenxiang629的博客\n\n\n04-03\n\n\t\t\t\t\t808\n\t\t\t\t\t\n\n\n\n\n\n相信80%的UI自动化测试工程师在进行岗位面试的时候都会重点讲解自己会使用哪些工具，例如cypress 、selenium 、playwright等等。其实这只是初级段位，如果大家想谈得再高大上一些，就可以谈谈这些工具与浏览器talk的原理了，绝对会得到面试官的重视！目前主流主动化测试工具与浏览器沟通的原理主要包括：Native、Webdriver以及CDP，使用这三种方式的典型代表工具分别是：cypress 、selenium 和playwright。今天我就对此进行总结：\n\n\n\n\n\n\n\n\n\n朋友们，一起学习下 Chrome DevTools Protocol。\n\n\n\n\nz_l_x_的博客\n\n\n10-18\n\n\t\t\t\t\t3072\n\t\t\t\t\t\n\n\n\n\n\n1947 年 9 月 9 日，First actual case of bug being found，自此引入了 Debugging。\n\n\n\n\n\n\n\n\n\nCDP 远程调试方案\n\n\n\n\n老司机的后备箱\n\n\n05-23\n\n\t\t\t\t\t3656\n\t\t\t\t\t\n\n\n\n\n\n什么是 cdp 协议\ncdp 协议简称 chrome 调试协议，是基于 scoket（websocket、usb、adb ）消息的 json rpc 协议。用来调用 chrome 内部的方法实现 js，css ，dom 的开发调试。 可以将 实现了 cdp 协议的应用 看做 rpc 调用的服务端（ chrome ，puppeteer）， 将调试面板看做 rpc 调用的客户端（devtools）。\ndevtools 调试系统\n完整的调试系统分别由前端，后端，协议，通道四部分组成\n\nFrontend：调试器前端\n\n\n\n\n\n\n\n\n\nGo Chromedp库得使用----CDP（Chrome DevTools Protocol)\n\n\n\n\n路小白的博客\n\n\n12-24\n\n\t\t\t\t\t8813\n\t\t\t\t\t\n\n\n\n\n\nGo chromedp库的使用 —CDP\n文章目录Go chromedp库的使用 ---CDPCDP（Chrome DevTools Protocol)基于CDP协议的相关语言操作Chromedp使用示例本地界面浏览器操作远程操作示例（无头浏览器）Centos 安装chronium-headless示例代码Browsesrless/chrome部署Linux-Centos安装NodeJS参考\nCDP（Chrome DevTools Protocol)\nChrome DevTools Protocol 是基.\n\n\n\n\n\n\n\n\n\n【学习笔记】selenium ChromeDriver 移除navigator.webdriver属性\n\n\n\n\nMONKEYMONEY_的博客\n\n\n12-16\n\n\t\t\t\t\t906\n\t\t\t\t\t\n\n\n\n\n\n作为新手的我，\n在刚接触selenium时不了解的\nChrome Driver 一些常用属性和方法。\n为此特意记录了以下几项并加上注释，方便以后查阅调用。\n\n\n \nSelenium中的ChromeOptions选项\n\n\nchromeOptions是一个配置chrome启动属性的类。通过这个类，我们可以为chrome配置如下参数（这个部分可以通过selenium源码看到）：\n\n设置 chrome 二进制文件位置 (binary_location)\n添加启动参数 (add_argument)\n添加扩展应用 (a\n\n\n\n\n\n\n\n\n\nChrome DevTools Protocol localstorage\n\n\n\n\n06-07"
}
[chain/start] [chain:RunnableSequence > prompt:ChatPromptTemplate] Entering Prompt run with input:
{
"doc": "CDP和Chrome_chrome devtools protocol-CSDN博客\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nCDP和Chrome\n\n\n\n\n\ndaliucheng\n\n已于 2024-02-19 00:07:33 修改\n\n\n阅读量1.7k\n\n\n\n收藏\n\n 21\n \n\n\n\n\n点赞数\n 27\n \n\n\n\n\n\n\n分类专栏：\n自动化测试\n文章标签：\nchrome\n自动化\npython\nnode.js\n\n\n于 2024-02-18 23:45:32 首次发布\n\n\n\n 版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。\n \n\n 本文链接：https://blog.csdn.net/daliucheng/article/details/136160807\n\n\n\n\n版权\n\n\n\n\n\n\n\n\n\n\n\n\n\n自动化测试\n专栏收录该内容\n\n\n\n\n\n1 篇文章\n0 订阅\n\n\n订阅专栏\n\n\n\n\n\n\n\n\n\n\n\n\nCDP和Chrome\nCDP和WebDriver Protocol\nWebDriver和 Chrome DevTools Protocol（CDP） 是用于自动化浏览器的两个主要协议，大多数的浏览器自动化工具都是基于上述其中之一来实现的。可以通过这两种形式来和浏览器交互，通过代码来控制浏览器，完成浏览器的自动化行为（包括网页加载，爬虫，截图，导出pdf等）。\nWebDriver Protocol\n官网地址：链接\nWebDriver 是一个用于控制浏览器的远程控制接口，由 Selenium HQ 开发，后来由 W3C 标准化。它提供了一个平台和语言中立的接口，支持几乎所有主流浏览器，如 Chrome、 Firefox、 Safari、 Edge、 Opera 等。\n它和浏览器的通信是通过 JSON Wire 协议完成的，提供了RESTful的web服务，这个服务端就被称为服务端（也被称为webdriver），例如chromeDriver、geckoDriver等。\n有服务端就有客户端，客户端可以选择任何语言，客户端和服务端交互，服务端和浏览器交互，从而操作浏览器。常见的客户端就是selenium,nightwatch,webdriverio \n加上我们的自己写的自动化测试代码之后，交互流程如下：\n\nChrome DevTools Protocol\n官网地址：链接\nChromeDevTools Protocol (CDP)是一个基于 Chromium 的浏览器的调试协议，如 Chrome、 Edge、 Opera 等。通过它可以直接和浏览器交互。控制浏览器的行为。\n客户端和浏览器之间没有类似于WebDriver Protocol的服务端（webdriver），而是客户端通过WebSocket直接和浏览器连\n类似网络驱动服务器(浏览器驱动程序)的中间人。相反，浏览器是由客户端使用 CDP 直接控制的。与浏览器的通信是通过套接字连接完成的，因此也支持双向通信。客户端通过WebSocket发送命令给浏览器，浏览器执行并返回响应。\n\n两个相当流行的工具是Puppeteer和Playwright。它们不依赖于webdriver，而是通过 Chrome DevTools Protocol (CDP)直接与浏览器通话。从而更加灵活稳定的控制浏览器。\n区别\n从代码层面来看，使用的代码接近底层，接近浏览器，代码就会变得更加的稳定和强大，但对于跨浏览器的支持会变得更少。另一方面，代码和浏览器的之间的抽象程度越高，支持的浏览器就越多，但代码会变得不稳定并且功能受限。\n对比上面两种\n WebDriver Protocol 支持的浏览器多，但不是很稳定，并且功能不强大。 Chrome DevTools Protocol 支持的浏览器少（只是相对WebDriver来说，Chrome能支持就能用），功能强大，稳定。 \nWebdriver ProtocolChrome DevTools ProtocolDeveloped by: W3CDeveloped by: Chrome Developer Tools需要webdriver不需要webdriver相对较慢并且不是很稳定速度快，较稳定支持的浏览器多支持部分浏览器无法通过提供的api来访问浏览器中网络相关的信息可以通过api来访问网络相关的信息它的实现有：Selenium WebDriver 3, WebdriverIO, Nightwatch它的实现有：Playwright, Puppeteer, Selenium Webdriver 4, Cypress v7\n不同的WebDriver有不同的实现方式，chromeDriver内部是通过DevTools protoco来控制浏览器的。\n如何选择\n如果跨浏览器很重要，就选webDriver，否则选择CDP\npuppeteer\n链接：官网，github，github-examples\nPuppeteer 是 Chrome 开发团队在 2017 年发布的一个 Node.js 包，是它提供了一个高级 API，通过 DevTools 协议控制 Chrome/Chromium。\n为什么选择它？\n两个理由\ngithub中star数多Chrome开发团队\n可以做什么？\n简单来说，浏览器能做的，它都能做\n截图和生成PDF爬取 SPA 或 SSR 网站UI 自动化测试…\n版本说明\n从v1.7.0 版本以来，每次发布都会发布两个软件包：\n puppeteer\n\n它会自动下载一个最新版本的 Chrome 用于测试（macOS 约 170MB，Linux 约 282MB，Windows 约 280MB）以及一个 chrome-headless-shell 二进制文件（从 Puppeteer v21.6.0 开始），这个二进制文件保证可以与 Puppeteer 配合正常工作。默认情况下，浏览器会下载到 $HOME/.cache/puppeteer 文件夹中（从 Puppeteer v19.0.0 开始）。\n通过puppeteer-core 控制它下载的浏览器\n puppeteer-core\n\npuppeteer-core 是一个库，用于帮助驱动任何支持 DevTools 协议的内容。\n它不会下载浏览器，它提供了封装好的API和浏览器交互。\n如果自己已经下载了浏览器，就可以使用它，但是必须在调用puppeteer.launch的时候显式的指定executablePath(浏览器的执行位置)\n 一般来说我会使用这个 \n代码\n建议看这篇文章 结合项目来谈谈 Puppeteer 在结合 github-examples的例子。\n注意点\n 在部署的时候，建议使用容器化，Chrome本身是内存大户，如果遇到内存飙升，代码是不太好发现这种情况的，不能及时kill掉。 在加载网页的时候不建议每次都关闭和开启一个新的。 Chrome的启动和关系是比较耗时的，每次启动会慢150ms到300ms 建议重复使用同一个Chrome。 Chrome使用一段时间之后，要关掉重启。 Chrome在我们自己的电脑中有的时候，页面都会崩溃，浏览器也会崩溃。在服务器这种情况下，肯定也会出现，建议在内存中设置调用阈值，比如加载了100个网页，重启一次。这样可降低崩溃的概率。 容器化部署之后，建议一个容器中只启动一个Chrome。 这样会让代码简单并且出现问题好排查。这就要求Chrome在代码中是单例 在整个Chrome做操作期间，对Chrome崩溃的情况做处理 在业务代码期间，建议使用try catch 来捕获异常，对于非业务异常，需要关闭掉Chrome。防止出现多个Chrome。 Chrome在关闭的时候出现异常，也需要处理 在调用close()api来关闭Chrome的时候，可能会报错（可能Chrome在这个时候被操作系统kill掉，会出现孤儿进程）。 建议：在这个时候直接通过shell脚本来强行kill掉 #!/bin/bash\n\npids=$(ps -ef | grep \"[c]hrome\" | grep -v 'kill_chrome_processes.sh' |awk '{print $2}')\n\nfor pid in $pids; do\n echo \"Terminating PID $pid\"\n kill $pid\ndone\n\necho \"All chrome processes have been terminated.\"\n\n\n孤儿进程：\n父进程启动了子进程，子进程在没有退出的情况下，父进程退出了。此时子进程会被init进程接管。\n 尽量关闭掉无用的功能，让他越简单越好。 比如：-no-sandbox,--disable-extensions,--disable-gpu,--disable_scrollbars 共享内存\n\nChrome 默认使用 /dev/shm 共享内存，但是 docker 默认/dev/shm 只有64MB，显然是不够使用的，提供两种方式来解决：\n启动 docker 时添加参数 --shm-size=1gb 来增大 /dev/shm 共享内存，但是 swarm 目前不支持 shm-size 参数启动 Chrome 添加参数 - disable-dev-shm-usage，禁止使用 /dev/shm 共享内存\n \n参考文档\nhttps://www.neovasolutions.com/2022/05/19/browser-automation-tools-protocols-webdriver-vs-cdp/https://dev.to/jankaritech/different-approaches-protocols-to-automate-the-browser-39f1https://stackoverflow.com/questions/50939116/what-is-the-difference-between-webdriver-and-devtool-protocolhttps://zhuanlan.zhihu.com/p/76237595\n 关于博客这件事，我是把它当做我的笔记，里面有很多的内容反映了我思考的过程，因为思维有限，不免有些内容有出入，如果有问题，欢迎指出。一同探讨。谢谢。\n \n\n\n\n\n\n\n\n\n\n\n\n\n\n 确定要放弃本次机会？\n \n福利倒计时\n\n\n:\n\n:\n\n\n\n\n\n立减 ¥\n\n\n普通VIP年卡可用\n\n立即使用\n\n \n\n\n\n\n\n daliucheng\n \n\n\n\n关注\n关注\n\n\n\n\n\n\n\n\n\n\n 27\n \n\n点赞\n\n\n\n\n\n\n\n踩\n\n\n\n\n\n\n\n 21\n \n\n\n\n\n 收藏\n \n\n\n\n\n 觉得还不错?\n \n 一键收藏\n \n\n\n\n\n\n\n\n知道了\n\n\n\n\n 0\n \n\n评论\n\n\n\n\n\n\n\n\n\n\n\n\n\n CDP和Chrome\n \n\n WebDriver和是用于自动化浏览器的两个主要协议，大多数的浏览器自动化工具都是基于上述其中之一来实现的。可以通过这两种形式来和浏览器交互，通过代码来控制浏览器，完成浏览器的自动化行为（包括网页加载，爬虫，截图，导出pdf等）。\n \n复制链接\n\n\n\n扫一扫\n\n\n\n\n\n\n\n\n\n\n专栏目录\n\n\n\n\n\n\n\n \n\n\n\n\n\nPython cdp ( Chrome DevTools Protocol ) 爬虫\n\n\n\n\n墨鱼菜鸡\n\n\n07-11\n\n\t\t\t\t\t3265\n\t\t\t\t\t\n\n\n\n\n\ndevtools-protocol：https://github.com/ChromeDevTools/devtools-protocol Chrome DevTools Protocol：https://chromedevtools.github.io/devtools-protocol/ Awesome Chrome DevTools ：https:...\n\n\n\n\n\n\n\n\n\n\n\n\nChrome DevTools Protocol(谷歌开发者工具协议)Protocol Monitor（协议监视器）\n\n\n\n\nllrraa2010的专栏\n\n\n06-10\n\n\t\t\t\t\t2633\n\t\t\t\t\t\n\n\n\n\n\n该协议最初是由谷歌开发者工具团队维护的，负责调试、操作浏览器的协议。我们经常使用到的谷歌浏览器的开发者工具（快捷键 CTRL + SHIFT + I 或者 F12）就是使用这个协议来操作浏览器的。与 Selenium 需要与浏览器驱动进行交互不同的是，Chrome DevTools 协议直接通过 Web Socket 协议与浏览器暴露的 API 进行通信，这使得 Chrome DevTools 协议操作浏览器变得更快。我们要重启开发者工具，在右侧点击更多工具，这样就可以看到协议监视器面板了。\n\n\n\n\n\n\n\n\n参与评论\n您还未登录，请先\n登录\n后发表或查看评论\n\n\n\n\n\n\n\n\n\n探索Web开发新维度：Devtools-Protocol\n最新发布\n\n\n\n\ngitblog_00001的博客\n\n\n05-15\n\n\t\t\t\t\t353\n\t\t\t\t\t\n\n\n\n\n\n探索Web开发新维度：Devtools-Protocol\n项目地址:https://gitcode.com/ChromeDevTools/devtools-protocol\n项目介绍\n在Web开发的世界中，Chrome DevTools Protocol（DTP）是连接开发者和浏览器内核的桥梁，它允许我们进行深度的调试、性能分析以及自动化测试。而devtools-protocol是一个官方维护的开...\n\n\n\n\n\n\n\n\n\nusus使用Chrome调试协议CDP渲染页面\n\n\n\n\n08-08\n\n\n\n\n\nusus 使用Chrome调试协议（CDP）渲染页面。 提取用于渲染页面的CSS。 渲染带有阻塞CSS的HTML异步。\n\n\n\n\n\n\n\n\n\n\n\n浏览器自动化必须知道CDP协议\n\n\n\n\n白天安全建设，晚上全栈开发，大模型爱好者。公众号：飞羽技术工坊。\n\n\n01-13\n\n\t\t\t\t\t1067\n\t\t\t\t\t\n\n\n\n\n\n之前搞自动化页面，因为有一个获取网络日志的需求，让我发现了新的知识盲区——CDP协议。\n\n\n\n\n\n\n\n\n\nChrome DevTools 通过 cdp 调节 CPU Throttling\n\n\n\n\n时丶光\n\n\n11-26\n\n\t\t\t\t\t927\n\t\t\t\t\t\n\n\n\n\n\n打开DevTools (快捷键ctrl + shift + i)\n\n在DevTools 界面再打开DevTools\n\n\n\n\nlet Main = await import('./devtools-frontend/front_end/entrypoints/main/main.js'); // or './entrypoints/main/main.js' or './main/main.js' depending on the browser version\n\n//设置CPU Throttling 为本机\n\n\n\n\n\n\n\n\n\ncdp:软件包cdp为使用Go编程语言编写的Chrome DevTools协议（CDP）提供了类型安全的绑定\n\n\n\n\n05-04\n\n\n\n\n\n光盘\n 软件包cdp为使用Go编程语言编写的（CDP）提供了类型安全的绑定。 绑定是由根据最新协议定义生成的，并且主要用于Google Chrome或Chromium，但是它们可以与任何调试目标（ ， ， 等）。\n 通过Chrome DevTools协议，该软件包可用于任何类型的浏览器自动化，脚本编写或调试。\n cdp主要动机是公开Chrome DevTools协议的全部功能，并以一种可发现的自记录方式提供它。\n 提供高级浏览器自动化对于该项目而言是不可行的。 话虽如此， cdp希望通过提供更适合Go的原语并自动执行重复性任务来改善使用该协议的人体工程学。\n特征\n适用于Chrome DevTools协议的可发现API（GoDoc，自动完成友好）\n 作为头等公民的情况（用于超时和取消）\n 简单且同步的事件处理（无回调）\n 同时安全\n没有无声或隐藏的错误\n做到用户期望的\n尽可能将CDP类型与\n\n\n\n\n\n\n\n\n\nichrome：适用于人类的Chrome控制器，基于Chrome Devtools协议（CDP）和python3.7 +\n\n\n\n\n01-31\n\n\n\n\n\n适用于人类的Chrome控制器，基于和python3.7 +。为什么？ Pyppeteer很棒，但是我不需要那么多pyppeteer的拼写很混乱事件驱动的编程并非总是明智的。 Selenium慢网络驱动程序经常带有内存泄漏。 迫切需要一个稳定的...\n\n\n\n\n\n\n\n\n\nselenium_cdp：Selenium 4x，执行Chrome DevTools协议命令\n\n\n\n\n01-31\n\n\n\n\n\n该项目采用Java Selenium 4.0.x版本的来执行（也称为cdp命令），这是一套完全不同的API，通过对/session/$sessionId/goog/cdp/execute POST POST 传达给Chrome浏览器系列，特定的有效负载）功能（许多cdp方法，例如...\n\n\n\n\n\n\n\n\n\ncdp4j：cdp4j-适用于Java的Chrome DevTools协议\n\n\n\n\n01-28\n\n\n\n\n\ncdp4j是Java库，具有清晰简洁的API，可自动执行基于Chrome / Chromium的浏览器。 它使用Google Chrome DevTools协议来自动化基于Chrome / Chromium的浏览器。 cdp4j可以做什么？ 自动填写表格。 您可以轻松下载和...\n\n\n\n\n\n\n\n\n\ngetting-started-with-cdp:Chrome DevTools 协议入门\n\n\n\n\n07-24\n\n\n\n\n\n使用 Chrome DevTools 协议在直接使用 CDP 进行浏览器自动化之前要三思。 有会让你过得更好不服气？ 至少使用 。 另请参阅介绍注意： ://vanilla.aslushnikov.com 提供了交互式协议查看器。 Chrome DevTools 协议...\n\n\n\n\n\n\n\n\n\nChrome之远程调试协议（Remote debugging protocol） - Div.IO\n\n\n\n\nweixin_33940102的博客\n\n\n06-27\n\n\t\t\t\t\t1781\n\t\t\t\t\t\n\n\n\n\n\nChrome之远程调试协议（Remote debugging protocol） - Div.IO\n\n\n\n\n\n\n\n\n\n一文读懂UI自动化测试三种核心实现原理：Native、Webdriver和CDP\n\n\n\n\nliwenxiang629的博客\n\n\n04-03\n\n\t\t\t\t\t808\n\t\t\t\t\t\n\n\n\n\n\n相信80%的UI自动化测试工程师在进行岗位面试的时候都会重点讲解自己会使用哪些工具，例如cypress 、selenium 、playwright等等。其实这只是初级段位，如果大家想谈得再高大上一些，就可以谈谈这些工具与浏览器talk的原理了，绝对会得到面试官的重视！目前主流主动化测试工具与浏览器沟通的原理主要包括：Native、Webdriver以及CDP，使用这三种方式的典型代表工具分别是：cypress 、selenium 和playwright。今天我就对此进行总结：\n\n\n\n\n\n\n\n\n\n朋友们，一起学习下 Chrome DevTools Protocol。\n\n\n\n\nz_l_x_的博客\n\n\n10-18\n\n\t\t\t\t\t3072\n\t\t\t\t\t\n\n\n\n\n\n1947 年 9 月 9 日，First actual case of bug being found，自此引入了 Debugging。\n\n\n\n\n\n\n\n\n\nCDP 远程调试方案\n\n\n\n\n老司机的后备箱\n\n\n05-23\n\n\t\t\t\t\t3656\n\t\t\t\t\t\n\n\n\n\n\n什么是 cdp 协议\ncdp 协议简称 chrome 调试协议，是基于 scoket（websocket、usb、adb ）消息的 json rpc 协议。用来调用 chrome 内部的方法实现 js，css ，dom 的开发调试。 可以将 实现了 cdp 协议的应用 看做 rpc 调用的服务端（ chrome ，puppeteer）， 将调试面板看做 rpc 调用的客户端（devtools）。\ndevtools 调试系统\n完整的调试系统分别由前端，后端，协议，通道四部分组成\n\nFrontend：调试器前端\n\n\n\n\n\n\n\n\n\nGo Chromedp库得使用----CDP（Chrome DevTools Protocol)\n\n\n\n\n路小白的博客\n\n\n12-24\n\n\t\t\t\t\t8813\n\t\t\t\t\t\n\n\n\n\n\nGo chromedp库的使用 —CDP\n文章目录Go chromedp库的使用 ---CDPCDP（Chrome DevTools Protocol)基于CDP协议的相关语言操作Chromedp使用示例本地界面浏览器操作远程操作示例（无头浏览器）Centos 安装chronium-headless示例代码Browsesrless/chrome部署Linux-Centos安装NodeJS参考\nCDP（Chrome DevTools Protocol)\nChrome DevTools Protocol 是基.\n\n\n\n\n\n\n\n\n\n【学习笔记】selenium ChromeDriver 移除navigator.webdriver属性\n\n\n\n\nMONKEYMONEY_的博客\n\n\n12-16\n\n\t\t\t\t\t906\n\t\t\t\t\t\n\n\n\n\n\n作为新手的我，\n在刚接触selenium时不了解的\nChrome Driver 一些常用属性和方法。\n为此特意记录了以下几项并加上注释，方便以后查阅调用。\n\n\n \nSelenium中的ChromeOptions选项\n\n\nchromeOptions是一个配置chrome启动属性的类。通过这个类，我们可以为chrome配置如下参数（这个部分可以通过selenium源码看到）：\n\n设置 chrome 二进制文件位置 (binary_location)\n添加启动参数 (add_argument)\n添加扩展应用 (a\n\n\n\n\n\n\n\n\n\nChrome DevTools Protocol localstorage\n\n\n\n\n06-07"
}
[chain/end] [chain:RunnableSequence > prompt:ChatPromptTemplate] [1ms] Exiting Prompt run with output:
[outputs]
[llm/start] [chain:RunnableSequence > llm:ChatOpenAI] Entering LLM run with input:
{
"prompts": [
"Human: 生成一个包含3个假设性问题的列表，中文回答，这些问题可以通过下面的文档来回答：\n\nCDP和Chrome_chrome devtools protocol-CSDN博客\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nCDP和Chrome\n\n\n\n\n\ndaliucheng\n\n已于 2024-02-19 00:07:33 修改\n\n\n阅读量1.7k\n\n\n\n收藏\n\n 21\n \n\n\n\n\n点赞数\n 27\n \n\n\n\n\n\n\n分类专栏：\n自动化测试\n文章标签：\nchrome\n自动化\npython\nnode.js\n\n\n于 2024-02-18 23:45:32 首次发布\n\n\n\n 版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。\n \n\n 本文链接：https://blog.csdn.net/daliucheng/article/details/136160807\n\n\n\n\n版权\n\n\n\n\n\n\n\n\n\n\n\n\n\n自动化测试\n专栏收录该内容\n\n\n\n\n\n1 篇文章\n0 订阅\n\n\n订阅专栏\n\n\n\n\n\n\n\n\n\n\n\n\nCDP和Chrome\nCDP和WebDriver Protocol\nWebDriver和 Chrome DevTools Protocol（CDP） 是用于自动化浏览器的两个主要协议，大多数的浏览器自动化工具都是基于上述其中之一来实现的。可以通过这两种形式来和浏览器交互，通过代码来控制浏览器，完成浏览器的自动化行为（包括网页加载，爬虫，截图，导出pdf等）。\nWebDriver Protocol\n官网地址：链接\nWebDriver 是一个用于控制浏览器的远程控制接口，由 Selenium HQ 开发，后来由 W3C 标准化。它提供了一个平台和语言中立的接口，支持几乎所有主流浏览器，如 Chrome、 Firefox、 Safari、 Edge、 Opera 等。\n它和浏览器的通信是通过 JSON Wire 协议完成的，提供了RESTful的web服务，这个服务端就被称为服务端（也被称为webdriver），例如chromeDriver、geckoDriver等。\n有服务端就有客户端，客户端可以选择任何语言，客户端和服务端交互，服务端和浏览器交互，从而操作浏览器。常见的客户端就是selenium,nightwatch,webdriverio \n加上我们的自己写的自动化测试代码之后，交互流程如下：\n\nChrome DevTools Protocol\n官网地址：链接\nChromeDevTools Protocol (CDP)是一个基于 Chromium 的浏览器的调试协议，如 Chrome、 Edge、 Opera 等。通过它可以直接和浏览器交互。控制浏览器的行为。\n客户端和浏览器之间没有类似于WebDriver Protocol的服务端（webdriver），而是客户端通过WebSocket直接和浏览器连\n类似网络驱动服务器(浏览器驱动程序)的中间人。相反，浏览器是由客户端使用 CDP 直接控制的。与浏览器的通信是通过套接字连接完成的，因此也支持双向通信。客户端通过WebSocket发送命令给浏览器，浏览器执行并返回响应。\n\n两个相当流行的工具是Puppeteer和Playwright。它们不依赖于webdriver，而是通过 Chrome DevTools Protocol (CDP)直接与浏览器通话。从而更加灵活稳定的控制浏览器。\n区别\n从代码层面来看，使用的代码接近底层，接近浏览器，代码就会变得更加的稳定和强大，但对于跨浏览器的支持会变得更少。另一方面，代码和浏览器的之间的抽象程度越高，支持的浏览器就越多，但代码会变得不稳定并且功能受限。\n对比上面两种\n WebDriver Protocol 支持的浏览器多，但不是很稳定，并且功能不强大。 Chrome DevTools Protocol 支持的浏览器少（只是相对WebDriver来说，Chrome能支持就能用），功能强大，稳定。 \nWebdriver ProtocolChrome DevTools ProtocolDeveloped by: W3CDeveloped by: Chrome Developer Tools需要webdriver不需要webdriver相对较慢并且不是很稳定速度快，较稳定支持的浏览器多支持部分浏览器无法通过提供的api来访问浏览器中网络相关的信息可以通过api来访问网络相关的信息它的实现有：Selenium WebDriver 3, WebdriverIO, Nightwatch它的实现有：Playwright, Puppeteer, Selenium Webdriver 4, Cypress v7\n不同的WebDriver有不同的实现方式，chromeDriver内部是通过DevTools protoco来控制浏览器的。\n如何选择\n如果跨浏览器很重要，就选webDriver，否则选择CDP\npuppeteer\n链接：官网，github，github-examples\nPuppeteer 是 Chrome 开发团队在 2017 年发布的一个 Node.js 包，是它提供了一个高级 API，通过 DevTools 协议控制 Chrome/Chromium。\n为什么选择它？\n两个理由\ngithub中star数多Chrome开发团队\n可以做什么？\n简单来说，浏览器能做的，它都能做\n截图和生成PDF爬取 SPA 或 SSR 网站UI 自动化测试…\n版本说明\n从v1.7.0 版本以来，每次发布都会发布两个软件包：\n puppeteer\n\n它会自动下载一个最新版本的 Chrome 用于测试（macOS 约 170MB，Linux 约 282MB，Windows 约 280MB）以及一个 chrome-headless-shell 二进制文件（从 Puppeteer v21.6.0 开始），这个二进制文件保证可以与 Puppeteer 配合正常工作。默认情况下，浏览器会下载到 $HOME/.cache/puppeteer 文件夹中（从 Puppeteer v19.0.0 开始）。\n通过puppeteer-core 控制它下载的浏览器\n puppeteer-core\n\npuppeteer-core 是一个库，用于帮助驱动任何支持 DevTools 协议的内容。\n它不会下载浏览器，它提供了封装好的API和浏览器交互。\n如果自己已经下载了浏览器，就可以使用它，但是必须在调用puppeteer.launch的时候显式的指定executablePath(浏览器的执行位置)\n 一般来说我会使用这个 \n代码\n建议看这篇文章 结合项目来谈谈 Puppeteer 在结合 github-examples的例子。\n注意点\n 在部署的时候，建议使用容器化，Chrome本身是内存大户，如果遇到内存飙升，代码是不太好发现这种情况的，不能及时kill掉。 在加载网页的时候不建议每次都关闭和开启一个新的。 Chrome的启动和关系是比较耗时的，每次启动会慢150ms到300ms 建议重复使用同一个Chrome。 Chrome使用一段时间之后，要关掉重启。 Chrome在我们自己的电脑中有的时候，页面都会崩溃，浏览器也会崩溃。在服务器这种情况下，肯定也会出现，建议在内存中设置调用阈值，比如加载了100个网页，重启一次。这样可降低崩溃的概率。 容器化部署之后，建议一个容器中只启动一个Chrome。 这样会让代码简单并且出现问题好排查。这就要求Chrome在代码中是单例 在整个Chrome做操作期间，对Chrome崩溃的情况做处理 在业务代码期间，建议使用try catch 来捕获异常，对于非业务异常，需要关闭掉Chrome。防止出现多个Chrome。 Chrome在关闭的时候出现异常，也需要处理 在调用close()api来关闭Chrome的时候，可能会报错（可能Chrome在这个时候被操作系统kill掉，会出现孤儿进程）。 建议：在这个时候直接通过shell脚本来强行kill掉 #!/bin/bash\n\npids=$(ps -ef | grep \"[c]hrome\" | grep -v 'kill_chrome_processes.sh' |awk '{print $2}')\n\nfor pid in $pids; do\n echo \"Terminating PID $pid\"\n kill $pid\ndone\n\necho \"All chrome processes have been terminated.\"\n\n\n孤儿进程：\n父进程启动了子进程，子进程在没有退出的情况下，父进程退出了。此时子进程会被init进程接管。\n 尽量关闭掉无用的功能，让他越简单越好。 比如：-no-sandbox,--disable-extensions,--disable-gpu,--disable_scrollbars 共享内存\n\nChrome 默认使用 /dev/shm 共享内存，但是 docker 默认/dev/shm 只有64MB，显然是不够使用的，提供两种方式来解决：\n启动 docker 时添加参数 --shm-size=1gb 来增大 /dev/shm 共享内存，但是 swarm 目前不支持 shm-size 参数启动 Chrome 添加参数 - disable-dev-shm-usage，禁止使用 /dev/shm 共享内存\n \n参考文档\nhttps://www.neovasolutions.com/2022/05/19/browser-automation-tools-protocols-webdriver-vs-cdp/https://dev.to/jankaritech/different-approaches-protocols-to-automate-the-browser-39f1https://stackoverflow.com/questions/50939116/what-is-the-difference-between-webdriver-and-devtool-protocolhttps://zhuanlan.zhihu.com/p/76237595\n 关于博客这件事，我是把它当做我的笔记，里面有很多的内容反映了我思考的过程，因为思维有限，不免有些内容有出入，如果有问题，欢迎指出。一同探讨。谢谢。\n \n\n\n\n\n\n\n\n\n\n\n\n\n\n 确定要放弃本次机会？\n \n福利倒计时\n\n\n:\n\n:\n\n\n\n\n\n立减 ¥\n\n\n普通VIP年卡可用\n\n立即使用\n\n \n\n\n\n\n\n daliucheng\n \n\n\n\n关注\n关注\n\n\n\n\n\n\n\n\n\n\n 27\n \n\n点赞\n\n\n\n\n\n\n\n踩\n\n\n\n\n\n\n\n 21\n \n\n\n\n\n 收藏\n \n\n\n\n\n 觉得还不错?\n \n 一键收藏\n \n\n\n\n\n\n\n\n知道了\n\n\n\n\n 0\n \n\n评论\n\n\n\n\n\n\n\n\n\n\n\n\n\n CDP和Chrome\n \n\n WebDriver和是用于自动化浏览器的两个主要协议，大多数的浏览器自动化工具都是基于上述其中之一来实现的。可以通过这两种形式来和浏览器交互，通过代码来控制浏览器，完成浏览器的自动化行为（包括网页加载，爬虫，截图，导出pdf等）。\n \n复制链接\n\n\n\n扫一扫\n\n\n\n\n\n\n\n\n\n\n专栏目录\n\n\n\n\n\n\n\n \n\n\n\n\n\nPython cdp ( Chrome DevTools Protocol ) 爬虫\n\n\n\n\n墨鱼菜鸡\n\n\n07-11\n\n\t\t\t\t\t3265\n\t\t\t\t\t\n\n\n\n\n\ndevtools-protocol：https://github.com/ChromeDevTools/devtools-protocol Chrome DevTools Protocol：https://chromedevtools.github.io/devtools-protocol/ Awesome Chrome DevTools ：https:...\n\n\n\n\n\n\n\n\n\n\n\n\nChrome DevTools Protocol(谷歌开发者工具协议)Protocol Monitor（协议监视器）\n\n\n\n\nllrraa2010的专栏\n\n\n06-10\n\n\t\t\t\t\t2633\n\t\t\t\t\t\n\n\n\n\n\n该协议最初是由谷歌开发者工具团队维护的，负责调试、操作浏览器的协议。我们经常使用到的谷歌浏览器的开发者工具（快捷键 CTRL + SHIFT + I 或者 F12）就是使用这个协议来操作浏览器的。与 Selenium 需要与浏览器驱动进行交互不同的是，Chrome DevTools 协议直接通过 Web Socket 协议与浏览器暴露的 API 进行通信，这使得 Chrome DevTools 协议操作浏览器变得更快。我们要重启开发者工具，在右侧点击更多工具，这样就可以看到协议监视器面板了。\n\n\n\n\n\n\n\n\n参与评论\n您还未登录，请先\n登录\n后发表或查看评论\n\n\n\n\n\n\n\n\n\n探索Web开发新维度：Devtools-Protocol\n最新发布\n\n\n\n\ngitblog_00001的博客\n\n\n05-15\n\n\t\t\t\t\t353\n\t\t\t\t\t\n\n\n\n\n\n探索Web开发新维度：Devtools-Protocol\n项目地址:https://gitcode.com/ChromeDevTools/devtools-protocol\n项目介绍\n在Web开发的世界中，Chrome DevTools Protocol（DTP）是连接开发者和浏览器内核的桥梁，它允许我们进行深度的调试、性能分析以及自动化测试。而devtools-protocol是一个官方维护的开...\n\n\n\n\n\n\n\n\n\nusus使用Chrome调试协议CDP渲染页面\n\n\n\n\n08-08\n\n\n\n\n\nusus 使用Chrome调试协议（CDP）渲染页面。 提取用于渲染页面的CSS。 渲染带有阻塞CSS的HTML异步。\n\n\n\n\n\n\n\n\n\n\n\n浏览器自动化必须知道CDP协议\n\n\n\n\n白天安全建设，晚上全栈开发，大模型爱好者。公众号：飞羽技术工坊。\n\n\n01-13\n\n\t\t\t\t\t1067\n\t\t\t\t\t\n\n\n\n\n\n之前搞自动化页面，因为有一个获取网络日志的需求，让我发现了新的知识盲区——CDP协议。\n\n\n\n\n\n\n\n\n\nChrome DevTools 通过 cdp 调节 CPU Throttling\n\n\n\n\n时丶光\n\n\n11-26\n\n\t\t\t\t\t927\n\t\t\t\t\t\n\n\n\n\n\n打开DevTools (快捷键ctrl + shift + i)\n\n在DevTools 界面再打开DevTools\n\n\n\n\nlet Main = await import('./devtools-frontend/front_end/entrypoints/main/main.js'); // or './entrypoints/main/main.js' or './main/main.js' depending on the browser version\n\n//设置CPU Throttling 为本机\n\n\n\n\n\n\n\n\n\ncdp:软件包cdp为使用Go编程语言编写的Chrome DevTools协议（CDP）提供了类型安全的绑定\n\n\n\n\n05-04\n\n\n\n\n\n光盘\n 软件包cdp为使用Go编程语言编写的（CDP）提供了类型安全的绑定。 绑定是由根据最新协议定义生成的，并且主要用于Google Chrome或Chromium，但是它们可以与任何调试目标（ ， ， 等）。\n 通过Chrome DevTools协议，该软件包可用于任何类型的浏览器自动化，脚本编写或调试。\n cdp主要动机是公开Chrome DevTools协议的全部功能，并以一种可发现的自记录方式提供它。\n 提供高级浏览器自动化对于该项目而言是不可行的。 话虽如此， cdp希望通过提供更适合Go的原语并自动执行重复性任务来改善使用该协议的人体工程学。\n特征\n适用于Chrome DevTools协议的可发现API（GoDoc，自动完成友好）\n 作为头等公民的情况（用于超时和取消）\n 简单且同步的事件处理（无回调）\n 同时安全\n没有无声或隐藏的错误\n做到用户期望的\n尽可能将CDP类型与\n\n\n\n\n\n\n\n\n\nichrome：适用于人类的Chrome控制器，基于Chrome Devtools协议（CDP）和python3.7 +\n\n\n\n\n01-31\n\n\n\n\n\n适用于人类的Chrome控制器，基于和python3.7 +。为什么？ Pyppeteer很棒，但是我不需要那么多pyppeteer的拼写很混乱事件驱动的编程并非总是明智的。 Selenium慢网络驱动程序经常带有内存泄漏。 迫切需要一个稳定的...\n\n\n\n\n\n\n\n\n\nselenium_cdp：Selenium 4x，执行Chrome DevTools协议命令\n\n\n\n\n01-31\n\n\n\n\n\n该项目采用Java Selenium 4.0.x版本的来执行（也称为cdp命令），这是一套完全不同的API，通过对/session/$sessionId/goog/cdp/execute POST POST 传达给Chrome浏览器系列，特定的有效负载）功能（许多cdp方法，例如...\n\n\n\n\n\n\n\n\n\ncdp4j：cdp4j-适用于Java的Chrome DevTools协议\n\n\n\n\n01-28\n\n\n\n\n\ncdp4j是Java库，具有清晰简洁的API，可自动执行基于Chrome / Chromium的浏览器。 它使用Google Chrome DevTools协议来自动化基于Chrome / Chromium的浏览器。 cdp4j可以做什么？ 自动填写表格。 您可以轻松下载和...\n\n\n\n\n\n\n\n\n\ngetting-started-with-cdp:Chrome DevTools 协议入门\n\n\n\n\n07-24\n\n\n\n\n\n使用 Chrome DevTools 协议在直接使用 CDP 进行浏览器自动化之前要三思。 有会让你过得更好不服气？ 至少使用 。 另请参阅介绍注意： ://vanilla.aslushnikov.com 提供了交互式协议查看器。 Chrome DevTools 协议...\n\n\n\n\n\n\n\n\n\nChrome之远程调试协议（Remote debugging protocol） - Div.IO\n\n\n\n\nweixin_33940102的博客\n\n\n06-27\n\n\t\t\t\t\t1781\n\t\t\t\t\t\n\n\n\n\n\nChrome之远程调试协议（Remote debugging protocol） - Div.IO\n\n\n\n\n\n\n\n\n\n一文读懂UI自动化测试三种核心实现原理：Native、Webdriver和CDP\n\n\n\n\nliwenxiang629的博客\n\n\n04-03\n\n\t\t\t\t\t808\n\t\t\t\t\t\n\n\n\n\n\n相信80%的UI自动化测试工程师在进行岗位面试的时候都会重点讲解自己会使用哪些工具，例如cypress 、selenium 、playwright等等。其实这只是初级段位，如果大家想谈得再高大上一些，就可以谈谈这些工具与浏览器talk的原理了，绝对会得到面试官的重视！目前主流主动化测试工具与浏览器沟通的原理主要包括：Native、Webdriver以及CDP，使用这三种方式的典型代表工具分别是：cypress 、selenium 和playwright。今天我就对此进行总结：\n\n\n\n\n\n\n\n\n\n朋友们，一起学习下 Chrome DevTools Protocol。\n\n\n\n\nz_l_x_的博客\n\n\n10-18\n\n\t\t\t\t\t3072\n\t\t\t\t\t\n\n\n\n\n\n1947 年 9 月 9 日，First actual case of bug being found，自此引入了 Debugging。\n\n\n\n\n\n\n\n\n\nCDP 远程调试方案\n\n\n\n\n老司机的后备箱\n\n\n05-23\n\n\t\t\t\t\t3656\n\t\t\t\t\t\n\n\n\n\n\n什么是 cdp 协议\ncdp 协议简称 chrome 调试协议，是基于 scoket（websocket、usb、adb ）消息的 json rpc 协议。用来调用 chrome 内部的方法实现 js，css ，dom 的开发调试。 可以将 实现了 cdp 协议的应用 看做 rpc 调用的服务端（ chrome ，puppeteer）， 将调试面板看做 rpc 调用的客户端（devtools）。\ndevtools 调试系统\n完整的调试系统分别由前端，后端，协议，通道四部分组成\n\nFrontend：调试器前端\n\n\n\n\n\n\n\n\n\nGo Chromedp库得使用----CDP（Chrome DevTools Protocol)\n\n\n\n\n路小白的博客\n\n\n12-24\n\n\t\t\t\t\t8813\n\t\t\t\t\t\n\n\n\n\n\nGo chromedp库的使用 —CDP\n文章目录Go chromedp库的使用 ---CDPCDP（Chrome DevTools Protocol)基于CDP协议的相关语言操作Chromedp使用示例本地界面浏览器操作远程操作示例（无头浏览器）Centos 安装chronium-headless示例代码Browsesrless/chrome部署Linux-Centos安装NodeJS参考\nCDP（Chrome DevTools Protocol)\nChrome DevTools Protocol 是基.\n\n\n\n\n\n\n\n\n\n【学习笔记】selenium ChromeDriver 移除navigator.webdriver属性\n\n\n\n\nMONKEYMONEY_的博客\n\n\n12-16\n\n\t\t\t\t\t906\n\t\t\t\t\t\n\n\n\n\n\n作为新手的我，\n在刚接触selenium时不了解的\nChrome Driver 一些常用属性和方法。\n为此特意记录了以下几项并加上注释，方便以后查阅调用。\n\n\n \nSelenium中的ChromeOptions选项\n\n\nchromeOptions是一个配置chrome启动属性的类。通过这个类，我们可以为chrome配置如下参数（这个部分可以通过selenium源码看到）：\n\n设置 chrome 二进制文件位置 (binary_location)\n添加启动参数 (add_argument)\n添加扩展应用 (a\n\n\n\n\n\n\n\n\n\nChrome DevTools Protocol localstorage\n\n\n\n\n06-07"
]
}
[llm/end] [chain:RunnableSequence > llm:ChatOpenAI] [6.00s] Exiting LLM run with output:
{
"generations": [
[
{
"text": "",
"generation_info": {
"finish_reason": "stop",
"logprobs": null
},
"type": "ChatGeneration",
"message": {
"lc": 1,
"type": "constructor",
"id": [
"langchain",
"schema",
"messages",
"AIMessage"
],
"kwargs": {
"content": "",
"additional_kwargs": {
"function_call": {
"arguments": "{\n \"questions\": [\n \"什么是 WebDriver Protocol 和 Chrome DevTools Protocol (CDP)？\",\n \"WebDriver Protocol 和 Chrome DevTools Protocol (CDP) 相比，各自有什么优缺点？\",\n \"什么是 Puppeteer 和它的工作原理是什么？\"\n ]\n}",
"name": "hypothetical_questions"
}
},
"response_metadata": {
"token_usage": {
"completion_tokens": 80,
"prompt_tokens": 5651,
"total_tokens": 5731
},
"model_name": "gpt-4-0613",
"system_fingerprint": null,
"finish_reason": "stop",
"logprobs": null
},
"type": "ai",
"id": "run-3537c1f3-9d7b-4967-8fa9-749fee3074dd-0",
"usage_metadata": {
"input_tokens": 5651,
"output_tokens": 80,
"total_tokens": 5731
},
"tool_calls": [],
"invalid_tool_calls": []
}
}
}
]
],
"llm_output": {
"token_usage": {
"completion_tokens": 80,
"prompt_tokens": 5651,
"total_tokens": 5731
},
"model_name": "gpt-4-0613",
"system_fingerprint": null
},
"run": null
}
[chain/start] [chain:RunnableSequence > parser:JsonKeyOutputFunctionsParser] Entering Parser run with input:
[inputs]
[chain/end] [chain:RunnableSequence > parser:JsonKeyOutputFunctionsParser] [2ms] Exiting Parser run with output:
{
"output": [
"什么是 WebDriver Protocol 和 Chrome DevTools Protocol (CDP)？",
"WebDriver Protocol 和 Chrome DevTools Protocol (CDP) 相比，各自有什么优缺点？",
"什么是 Puppeteer 和它的工作原理是什么？"
]
}
[chain/end] [chain:RunnableSequence] [6.01s] Exiting Chain run with output:
{
"output": [
"什么是 WebDriver Protocol 和 Chrome DevTools Protocol (CDP)？",
"WebDriver Protocol 和 Chrome DevTools Protocol (CDP) 相比，各自有什么优缺点？",
"什么是 Puppeteer 和它的工作原理是什么？"
]
}
['什么是 WebDriver Protocol 和 Chrome DevTools Protocol (CDP)？',
'WebDriver Protocol 和 Chrome DevTools Protocol (CDP) 相比，各自有什么优缺点？',
'什么是 Puppeteer 和它的工作原理是什么？']
# 将所有的文档都执行此操作，生成提问
hypothetical_questions = chain.batch(docs, {"max_concurrency": 5})
[chain/start] [chain:RunnableSequence] Entering Chain run with input:
[inputs]
[chain/start] [chain:RunnableSequence] Entering Chain run with input:
[inputs]
[chain/start] [chain:RunnableSequence > chain:RunnableParallel<doc>] Entering Chain run with input:
[inputs]
[chain/start] [chain:RunnableSequence > chain:RunnableParallel<doc>] Entering Chain run with input:
[inputs]
[chain/start] [chain:RunnableSequence > chain:RunnableParallel<doc> > chain:RunnableLambda] Entering Chain run with input:
[inputs]
[chain/end] [chain:RunnableSequence > chain:RunnableParallel<doc> > chain:RunnableLambda] [1ms] Exiting Chain run with output:
{
"output": "CDP和Chrome_chrome devtools protocol-CSDN博客\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nCDP和Chrome\n\n\n\n\n\ndaliucheng\n\n已于 2024-02-19 00:07:33 修改\n\n\n阅读量1.7k\n\n\n\n收藏\n\n 21\n \n\n\n\n\n点赞数\n 27\n \n\n\n\n\n\n\n分类专栏：\n自动化测试\n文章标签：\nchrome\n自动化\npython\nnode.js\n\n\n于 2024-02-18 23:45:32 首次发布\n\n\n\n 版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。\n \n\n 本文链接：https://blog.csdn.net/daliucheng/article/details/136160807\n\n\n\n\n版权\n\n\n\n\n\n\n\n\n\n\n\n\n\n自动化测试\n专栏收录该内容\n\n\n\n\n\n1 篇文章\n0 订阅\n\n\n订阅专栏\n\n\n\n\n\n\n\n\n\n\n\n\nCDP和Chrome\nCDP和WebDriver Protocol\nWebDriver和 Chrome DevTools Protocol（CDP） 是用于自动化浏览器的两个主要协议，大多数的浏览器自动化工具都是基于上述其中之一来实现的。可以通过这两种形式来和浏览器交互，通过代码来控制浏览器，完成浏览器的自动化行为（包括网页加载，爬虫，截图，导出pdf等）。\nWebDriver Protocol\n官网地址：链接\nWebDriver 是一个用于控制浏览器的远程控制接口，由 Selenium HQ 开发，后来由 W3C 标准化。它提供了一个平台和语言中立的接口，支持几乎所有主流浏览器，如 Chrome、 Firefox、 Safari、 Edge、 Opera 等。\n它和浏览器的通信是通过 JSON Wire 协议完成的，提供了RESTful的web服务，这个服务端就被称为服务端（也被称为webdriver），例如chromeDriver、geckoDriver等。\n有服务端就有客户端，客户端可以选择任何语言，客户端和服务端交互，服务端和浏览器交互，从而操作浏览器。常见的客户端就是selenium,nightwatch,webdriverio \n加上我们的自己写的自动化测试代码之后，交互流程如下：\n\nChrome DevTools Protocol\n官网地址：链接\nChromeDevTools Protocol (CDP)是一个基于 Chromium 的浏览器的调试协议，如 Chrome、 Edge、 Opera 等。通过它可以直接和浏览器交互。控制浏览器的行为。\n客户端和浏览器之间没有类似于WebDriver Protocol的服务端（webdriver），而是客户端通过WebSocket直接和浏览器连\n类似网络驱动服务器(浏览器驱动程序)的中间人。相反，浏览器是由客户端使用 CDP 直接控制的。与浏览器的通信是通过套接字连接完成的，因此也支持双向通信。客户端通过WebSocket发送命令给浏览器，浏览器执行并返回响应。\n\n两个相当流行的工具是Puppeteer和Playwright。它们不依赖于webdriver，而是通过 Chrome DevTools Protocol (CDP)直接与浏览器通话。从而更加灵活稳定的控制浏览器。\n区别\n从代码层面来看，使用的代码接近底层，接近浏览器，代码就会变得更加的稳定和强大，但对于跨浏览器的支持会变得更少。另一方面，代码和浏览器的之间的抽象程度越高，支持的浏览器就越多，但代码会变得不稳定并且功能受限。\n对比上面两种\n WebDriver Protocol 支持的浏览器多，但不是很稳定，并且功能不强大。 Chrome DevTools Protocol 支持的浏览器少（只是相对WebDriver来说，Chrome能支持就能用），功能强大，稳定。 \nWebdriver ProtocolChrome DevTools ProtocolDeveloped by: W3CDeveloped by: Chrome Developer Tools需要webdriver不需要webdriver相对较慢并且不是很稳定速度快，较稳定支持的浏览器多支持部分浏览器无法通过提供的api来访问浏览器中网络相关的信息可以通过api来访问网络相关的信息它的实现有：Selenium WebDriver 3, WebdriverIO, Nightwatch它的实现有：Playwright, Puppeteer, Selenium Webdriver 4, Cypress v7\n不同的WebDriver有不同的实现方式，chromeDriver内部是通过DevTools protoco来控制浏览器的。\n如何选择\n如果跨浏览器很重要，就选webDriver，否则选择CDP\npuppeteer\n链接：官网，github，github-examples\nPuppeteer 是 Chrome 开发团队在 2017 年发布的一个 Node.js 包，是它提供了一个高级 API，通过 DevTools 协议控制 Chrome/Chromium。\n为什么选择它？\n两个理由\ngithub中star数多Chrome开发团队\n可以做什么？\n简单来说，浏览器能做的，它都能做\n截图和生成PDF爬取 SPA 或 SSR 网站UI 自动化测试…\n版本说明\n从v1.7.0 版本以来，每次发布都会发布两个软件包：\n puppeteer\n\n它会自动下载一个最新版本的 Chrome 用于测试（macOS 约 170MB，Linux 约 282MB，Windows 约 280MB）以及一个 chrome-headless-shell 二进制文件（从 Puppeteer v21.6.0 开始），这个二进制文件保证可以与 Puppeteer 配合正常工作。默认情况下，浏览器会下载到 $HOME/.cache/puppeteer 文件夹中（从 Puppeteer v19.0.0 开始）。\n通过puppeteer-core 控制它下载的浏览器\n puppeteer-core\n\npuppeteer-core 是一个库，用于帮助驱动任何支持 DevTools 协议的内容。\n它不会下载浏览器，它提供了封装好的API和浏览器交互。\n如果自己已经下载了浏览器，就可以使用它，但是必须在调用puppeteer.launch的时候显式的指定executablePath(浏览器的执行位置)\n 一般来说我会使用这个 \n代码\n建议看这篇文章 结合项目来谈谈 Puppeteer 在结合 github-examples的例子。\n注意点\n 在部署的时候，建议使用容器化，Chrome本身是内存大户，如果遇到内存飙升，代码是不太好发现这种情况的，不能及时kill掉。 在加载网页的时候不建议每次都关闭和开启一个新的。 Chrome的启动和关系是比较耗时的，每次启动会慢150ms到300ms 建议重复使用同一个Chrome。 Chrome使用一段时间之后，要关掉重启。 Chrome在我们自己的电脑中有的时候，页面都会崩溃，浏览器也会崩溃。在服务器这种情况下，肯定也会出现，建议在内存中设置调用阈值，比如加载了100个网页，重启一次。这样可降低崩溃的概率。 容器化部署之后，建议一个容器中只启动一个Chrome。 这样会让代码简单并且出现问题好排查。这就要求Chrome在代码中是单例 在整个Chrome做操作期间，对Chrome崩溃的情况做处理 在业务代码期间，建议使用try catch 来捕获异常，对于非业务异常，需要关闭掉Chrome。防止出现多个Chrome。 Chrome在关闭的时候出现异常，也需要处理 在调用close()api来关闭Chrome的时候，可能会报错（可能Chrome在这个时候被操作系统kill掉，会出现孤儿进程）。 建议：在这个时候直接通过shell脚本来强行kill掉 #!/bin/bash\n\npids=$(ps -ef | grep \"[c]hrome\" | grep -v 'kill_chrome_processes.sh' |awk '{print $2}')\n\nfor pid in $pids; do\n echo \"Terminating PID $pid\"\n kill $pid\ndone\n\necho \"All chrome processes have been terminated.\"\n\n\n孤儿进程：\n父进程启动了子进程，子进程在没有退出的情况下，父进程退出了。此时子进程会被init进程接管。\n 尽量关闭掉无用的功能，让他越简单越好。 比如：-no-sandbox,--disable-extensions,--disable-gpu,--disable_scrollbars 共享内存\n\nChrome 默认使用 /dev/shm 共享内存，但是 docker 默认/dev/shm 只有64MB，显然是不够使用的，提供两种方式来解决：\n启动 docker 时添加参数 --shm-size=1gb 来增大 /dev/shm 共享内存，但是 swarm 目前不支持 shm-size 参数启动 Chrome 添加参数 - disable-dev-shm-usage，禁止使用 /dev/shm 共享内存\n \n参考文档\nhttps://www.neovasolutions.com/2022/05/19/browser-automation-tools-protocols-webdriver-vs-cdp/https://dev.to/jankaritech/different-approaches-protocols-to-automate-the-browser-39f1https://stackoverflow.com/questions/50939116/what-is-the-difference-between-webdriver-and-devtool-protocolhttps://zhuanlan.zhihu.com/p/76237595\n 关于博客这件事，我是把它当做我的笔记，里面有很多的内容反映了我思考的过程，因为思维有限，不免有些内容有出入，如果有问题，欢迎指出。一同探讨。谢谢。\n \n\n\n\n\n\n\n\n\n\n\n\n\n\n 确定要放弃本次机会？\n \n福利倒计时\n\n\n:\n\n:\n\n\n\n\n\n立减 ¥\n\n\n普通VIP年卡可用\n\n立即使用\n\n \n\n\n\n\n\n daliucheng\n \n\n\n\n关注\n关注\n\n\n\n\n\n\n\n\n\n\n 27\n \n\n点赞\n\n\n\n\n\n\n\n踩\n\n\n\n\n\n\n\n 21\n \n\n\n\n\n 收藏\n \n\n\n\n\n 觉得还不错?\n \n 一键收藏\n \n\n\n\n\n\n\n\n知道了\n\n\n\n\n 0\n \n\n评论\n\n\n\n\n\n\n\n\n\n\n\n\n\n CDP和Chrome\n \n\n WebDriver和是用于自动化浏览器的两个主要协议，大多数的浏览器自动化工具都是基于上述其中之一来实现的。可以通过这两种形式来和浏览器交互，通过代码来控制浏览器，完成浏览器的自动化行为（包括网页加载，爬虫，截图，导出pdf等）。\n \n复制链接\n\n\n\n扫一扫\n\n\n\n\n\n\n\n\n\n\n专栏目录\n\n\n\n\n\n\n\n \n\n\n\n\n\nPython cdp ( Chrome DevTools Protocol ) 爬虫\n\n\n\n\n墨鱼菜鸡\n\n\n07-11\n\n\t\t\t\t\t3265\n\t\t\t\t\t\n\n\n\n\n\ndevtools-protocol：https://github.com/ChromeDevTools/devtools-protocol Chrome DevTools Protocol：https://chromedevtools.github.io/devtools-protocol/ Awesome Chrome DevTools ：https:...\n\n\n\n\n\n\n\n\n\n\n\n\nChrome DevTools Protocol(谷歌开发者工具协议)Protocol Monitor（协议监视器）\n\n\n\n\nllrraa2010的专栏\n\n\n06-10\n\n\t\t\t\t\t2633\n\t\t\t\t\t\n\n\n\n\n\n该协议最初是由谷歌开发者工具团队维护的，负责调试、操作浏览器的协议。我们经常使用到的谷歌浏览器的开发者工具（快捷键 CTRL + SHIFT + I 或者 F12）就是使用这个协议来操作浏览器的。与 Selenium 需要与浏览器驱动进行交互不同的是，Chrome DevTools 协议直接通过 Web Socket 协议与浏览器暴露的 API 进行通信，这使得 Chrome DevTools 协议操作浏览器变得更快。我们要重启开发者工具，在右侧点击更多工具，这样就可以看到协议监视器面板了。\n\n\n\n\n\n\n\n\n参与评论\n您还未登录，请先\n登录\n后发表或查看评论\n\n\n\n\n\n\n\n\n\n探索Web开发新维度：Devtools-Protocol\n最新发布\n\n\n\n\ngitblog_00001的博客\n\n\n05-15\n\n\t\t\t\t\t353\n\t\t\t\t\t\n\n\n\n\n\n探索Web开发新维度：Devtools-Protocol\n项目地址:https://gitcode.com/ChromeDevTools/devtools-protocol\n项目介绍\n在Web开发的世界中，Chrome DevTools Protocol（DTP）是连接开发者和浏览器内核的桥梁，它允许我们进行深度的调试、性能分析以及自动化测试。而devtools-protocol是一个官方维护的开...\n\n\n\n\n\n\n\n\n\nusus使用Chrome调试协议CDP渲染页面\n\n\n\n\n08-08\n\n\n\n\n\nusus 使用Chrome调试协议（CDP）渲染页面。 提取用于渲染页面的CSS。 渲染带有阻塞CSS的HTML异步。\n\n\n\n\n\n\n\n\n\n\n\n浏览器自动化必须知道CDP协议\n\n\n\n\n白天安全建设，晚上全栈开发，大模型爱好者。公众号：飞羽技术工坊。\n\n\n01-13\n\n\t\t\t\t\t1067\n\t\t\t\t\t\n\n\n\n\n\n之前搞自动化页面，因为有一个获取网络日志的需求，让我发现了新的知识盲区——CDP协议。\n\n\n\n\n\n\n\n\n\nChrome DevTools 通过 cdp 调节 CPU Throttling\n\n\n\n\n时丶光\n\n\n11-26\n\n\t\t\t\t\t927\n\t\t\t\t\t\n\n\n\n\n\n打开DevTools (快捷键ctrl + shift + i)\n\n在DevTools 界面再打开DevTools\n\n\n\n\nlet Main = await import('./devtools-frontend/front_end/entrypoints/main/main.js'); // or './entrypoints/main/main.js' or './main/main.js' depending on the browser version\n\n//设置CPU Throttling 为本机\n\n\n\n\n\n\n\n\n\ncdp:软件包cdp为使用Go编程语言编写的Chrome DevTools协议（CDP）提供了类型安全的绑定\n\n\n\n\n05-04\n\n\n\n\n\n光盘\n 软件包cdp为使用Go编程语言编写的（CDP）提供了类型安全的绑定。 绑定是由根据最新协议定义生成的，并且主要用于Google Chrome或Chromium，但是它们可以与任何调试目标（ ， ， 等）。\n 通过Chrome DevTools协议，该软件包可用于任何类型的浏览器自动化，脚本编写或调试。\n cdp主要动机是公开Chrome DevTools协议的全部功能，并以一种可发现的自记录方式提供它。\n 提供高级浏览器自动化对于该项目而言是不可行的。 话虽如此， cdp希望通过提供更适合Go的原语并自动执行重复性任务来改善使用该协议的人体工程学。\n特征\n适用于Chrome DevTools协议的可发现API（GoDoc，自动完成友好）\n 作为头等公民的情况（用于超时和取消）\n 简单且同步的事件处理（无回调）\n 同时安全\n没有无声或隐藏的错误\n做到用户期望的\n尽可能将CDP类型与\n\n\n\n\n\n\n\n\n\nichrome：适用于人类的Chrome控制器，基于Chrome Devtools协议（CDP）和python3.7 +\n\n\n\n\n01-31\n\n\n\n\n\n适用于人类的Chrome控制器，基于和python3.7 +。为什么？ Pyppeteer很棒，但是我不需要那么多pyppeteer的拼写很混乱事件驱动的编程并非总是明智的。 Selenium慢网络驱动程序经常带有内存泄漏。 迫切需要一个稳定的...\n\n\n\n\n\n\n\n\n\nselenium_cdp：Selenium 4x，执行Chrome DevTools协议命令\n\n\n\n\n01-31\n\n\n\n\n\n该项目采用Java Selenium 4.0.x版本的来执行（也称为cdp命令），这是一套完全不同的API，通过对/session/$sessionId/goog/cdp/execute POST POST 传达给Chrome浏览器系列，特定的有效负载）功能（许多cdp方法，例如...\n\n\n\n\n\n\n\n\n\ncdp4j：cdp4j-适用于Java的Chrome DevTools协议\n\n\n\n\n01-28\n\n\n\n\n\ncdp4j是Java库，具有清晰简洁的API，可自动执行基于Chrome / Chromium的浏览器。 它使用Google Chrome DevTools协议来自动化基于Chrome / Chromium的浏览器。 cdp4j可以做什么？ 自动填写表格。 您可以轻松下载和...\n\n\n\n\n\n\n\n\n\ngetting-started-with-cdp:Chrome DevTools 协议入门\n\n\n\n\n07-24\n\n\n\n\n\n使用 Chrome DevTools 协议在直接使用 CDP 进行浏览器自动化之前要三思。 有会让你过得更好不服气？ 至少使用 。 另请参阅介绍注意： ://vanilla.aslushnikov.com 提供了交互式协议查看器。 Chrome DevTools 协议...\n\n\n\n\n\n\n\n\n\nChrome之远程调试协议（Remote debugging protocol） - Div.IO\n\n\n\n\nweixin_33940102的博客\n\n\n06-27\n\n\t\t\t\t\t1781\n\t\t\t\t\t\n\n\n\n\n\nChrome之远程调试协议（Remote debugging protocol） - Div.IO\n\n\n\n\n\n\n\n\n\n一文读懂UI自动化测试三种核心实现原理：Native、Webdriver和CDP\n\n\n\n\nliwenxiang629的博客\n\n\n04-03\n\n\t\t\t\t\t808\n\t\t\t\t\t\n\n\n\n\n\n相信80%的UI自动化测试工程师在进行岗位面试的时候都会重点讲解自己会使用哪些工具，例如cypress 、selenium 、playwright等等。其实这只是初级段位，如果大家想谈得再高大上一些，就可以谈谈这些工具与浏览器talk的原理了，绝对会得到面试官的重视！目前主流主动化测试工具与浏览器沟通的原理主要包括：Native、Webdriver以及CDP，使用这三种方式的典型代表工具分别是：cypress 、selenium 和playwright。今天我就对此进行总结：\n\n\n\n\n\n\n\n\n\n朋友们，一起学习下 Chrome DevTools Protocol。\n\n\n\n\nz_l_x_的博客\n\n\n10-18\n\n\t\t\t\t\t3072\n\t\t\t\t\t\n\n\n\n\n\n1947 年 9 月 9 日，First actual case of bug being found，自此引入了 Debugging。\n\n\n\n\n\n\n\n\n\nCDP 远程调试方案\n\n\n\n\n老司机的后备箱\n\n\n05-23\n\n\t\t\t\t\t3656\n\t\t\t\t\t\n\n\n\n\n\n什么是 cdp 协议\ncdp 协议简称 chrome 调试协议，是基于 scoket（websocket、usb、adb ）消息的 json rpc 协议。用来调用 chrome 内部的方法实现 js，css ，dom 的开发调试。 可以将 实现了 cdp 协议的应用 看做 rpc 调用的服务端（ chrome ，puppeteer）， 将调试面板看做 rpc 调用的客户端（devtools）。\ndevtools 调试系统\n完整的调试系统分别由前端，后端，协议，通道四部分组成\n\nFrontend：调试器前端\n\n\n\n\n\n\n\n\n\nGo Chromedp库得使用----CDP（Chrome DevTools Protocol)\n\n\n\n\n路小白的博客\n\n\n12-24\n\n\t\t\t\t\t8813\n\t\t\t\t\t\n\n\n\n\n\nGo chromedp库的使用 —CDP\n文章目录Go chromedp库的使用 ---CDPCDP（Chrome DevTools Protocol)基于CDP协议的相关语言操作Chromedp使用示例本地界面浏览器操作远程操作示例（无头浏览器）Centos 安装chronium-headless示例代码Browsesrless/chrome部署Linux-Centos安装NodeJS参考\nCDP（Chrome DevTools Protocol)\nChrome DevTools Protocol 是基.\n\n\n\n\n\n\n\n\n\n【学习笔记】selenium ChromeDriver 移除navigator.webdriver属性\n\n\n\n\nMONKEYMONEY_的博客\n\n\n12-16\n\n\t\t\t\t\t906\n\t\t\t\t\t\n\n\n\n\n\n作为新手的我，\n在刚接触selenium时不了解的\nChrome Driver 一些常用属性和方法。\n为此特意记录了以下几项并加上注释，方便以后查阅调用。\n\n\n \nSelenium中的ChromeOptions选项\n\n\nchromeOptions是一个配置chrome启动属性的类。通过这个类，我们可以为chrome配置如下参数（这个部分可以通过selenium源码看到）：\n\n设置 chrome 二进制文件位置 (binary_location)\n添加启动参数 (add_argument)\n添加扩展应用 (a\n\n\n\n\n\n\n\n\n\nChrome DevTools Protocol localstorage\n\n\n\n\n06-07"
}
[chain/end] [chain:RunnableSequence > chain:RunnableParallel<doc>] [3ms] Exiting Chain run with output:
{
"doc": "CDP和Chrome_chrome devtools protocol-CSDN博客\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nCDP和Chrome\n\n\n\n\n\ndaliucheng\n\n已于 2024-02-19 00:07:33 修改\n\n\n阅读量1.7k\n\n\n\n收藏\n\n 21\n \n\n\n\n\n点赞数\n 27\n \n\n\n\n\n\n\n分类专栏：\n自动化测试\n文章标签：\nchrome\n自动化\npython\nnode.js\n\n\n于 2024-02-18 23:45:32 首次发布\n\n\n\n 版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。\n \n\n 本文链接：https://blog.csdn.net/daliucheng/article/details/136160807\n\n\n\n\n版权\n\n\n\n\n\n\n\n\n\n\n\n\n\n自动化测试\n专栏收录该内容\n\n\n\n\n\n1 篇文章\n0 订阅\n\n\n订阅专栏\n\n\n\n\n\n\n\n\n\n\n\n\nCDP和Chrome\nCDP和WebDriver Protocol\nWebDriver和 Chrome DevTools Protocol（CDP） 是用于自动化浏览器的两个主要协议，大多数的浏览器自动化工具都是基于上述其中之一来实现的。可以通过这两种形式来和浏览器交互，通过代码来控制浏览器，完成浏览器的自动化行为（包括网页加载，爬虫，截图，导出pdf等）。\nWebDriver Protocol\n官网地址：链接\nWebDriver 是一个用于控制浏览器的远程控制接口，由 Selenium HQ 开发，后来由 W3C 标准化。它提供了一个平台和语言中立的接口，支持几乎所有主流浏览器，如 Chrome、 Firefox、 Safari、 Edge、 Opera 等。\n它和浏览器的通信是通过 JSON Wire 协议完成的，提供了RESTful的web服务，这个服务端就被称为服务端（也被称为webdriver），例如chromeDriver、geckoDriver等。\n有服务端就有客户端，客户端可以选择任何语言，客户端和服务端交互，服务端和浏览器交互，从而操作浏览器。常见的客户端就是selenium,nightwatch,webdriverio \n加上我们的自己写的自动化测试代码之后，交互流程如下：\n\nChrome DevTools Protocol\n官网地址：链接\nChromeDevTools Protocol (CDP)是一个基于 Chromium 的浏览器的调试协议，如 Chrome、 Edge、 Opera 等。通过它可以直接和浏览器交互。控制浏览器的行为。\n客户端和浏览器之间没有类似于WebDriver Protocol的服务端（webdriver），而是客户端通过WebSocket直接和浏览器连\n类似网络驱动服务器(浏览器驱动程序)的中间人。相反，浏览器是由客户端使用 CDP 直接控制的。与浏览器的通信是通过套接字连接完成的，因此也支持双向通信。客户端通过WebSocket发送命令给浏览器，浏览器执行并返回响应。\n\n两个相当流行的工具是Puppeteer和Playwright。它们不依赖于webdriver，而是通过 Chrome DevTools Protocol (CDP)直接与浏览器通话。从而更加灵活稳定的控制浏览器。\n区别\n从代码层面来看，使用的代码接近底层，接近浏览器，代码就会变得更加的稳定和强大，但对于跨浏览器的支持会变得更少。另一方面，代码和浏览器的之间的抽象程度越高，支持的浏览器就越多，但代码会变得不稳定并且功能受限。\n对比上面两种\n WebDriver Protocol 支持的浏览器多，但不是很稳定，并且功能不强大。 Chrome DevTools Protocol 支持的浏览器少（只是相对WebDriver来说，Chrome能支持就能用），功能强大，稳定。 \nWebdriver ProtocolChrome DevTools ProtocolDeveloped by: W3CDeveloped by: Chrome Developer Tools需要webdriver不需要webdriver相对较慢并且不是很稳定速度快，较稳定支持的浏览器多支持部分浏览器无法通过提供的api来访问浏览器中网络相关的信息可以通过api来访问网络相关的信息它的实现有：Selenium WebDriver 3, WebdriverIO, Nightwatch它的实现有：Playwright, Puppeteer, Selenium Webdriver 4, Cypress v7\n不同的WebDriver有不同的实现方式，chromeDriver内部是通过DevTools protoco来控制浏览器的。\n如何选择\n如果跨浏览器很重要，就选webDriver，否则选择CDP\npuppeteer\n链接：官网，github，github-examples\nPuppeteer 是 Chrome 开发团队在 2017 年发布的一个 Node.js 包，是它提供了一个高级 API，通过 DevTools 协议控制 Chrome/Chromium。\n为什么选择它？\n两个理由\ngithub中star数多Chrome开发团队\n可以做什么？\n简单来说，浏览器能做的，它都能做\n截图和生成PDF爬取 SPA 或 SSR 网站UI 自动化测试…\n版本说明\n从v1.7.0 版本以来，每次发布都会发布两个软件包：\n puppeteer\n\n它会自动下载一个最新版本的 Chrome 用于测试（macOS 约 170MB，Linux 约 282MB，Windows 约 280MB）以及一个 chrome-headless-shell 二进制文件（从 Puppeteer v21.6.0 开始），这个二进制文件保证可以与 Puppeteer 配合正常工作。默认情况下，浏览器会下载到 $HOME/.cache/puppeteer 文件夹中（从 Puppeteer v19.0.0 开始）。\n通过puppeteer-core 控制它下载的浏览器\n puppeteer-core\n\npuppeteer-core 是一个库，用于帮助驱动任何支持 DevTools 协议的内容。\n它不会下载浏览器，它提供了封装好的API和浏览器交互。\n如果自己已经下载了浏览器，就可以使用它，但是必须在调用puppeteer.launch的时候显式的指定executablePath(浏览器的执行位置)\n 一般来说我会使用这个 \n代码\n建议看这篇文章 结合项目来谈谈 Puppeteer 在结合 github-examples的例子。\n注意点\n 在部署的时候，建议使用容器化，Chrome本身是内存大户，如果遇到内存飙升，代码是不太好发现这种情况的，不能及时kill掉。 在加载网页的时候不建议每次都关闭和开启一个新的。 Chrome的启动和关系是比较耗时的，每次启动会慢150ms到300ms 建议重复使用同一个Chrome。 Chrome使用一段时间之后，要关掉重启。 Chrome在我们自己的电脑中有的时候，页面都会崩溃，浏览器也会崩溃。在服务器这种情况下，肯定也会出现，建议在内存中设置调用阈值，比如加载了100个网页，重启一次。这样可降低崩溃的概率。 容器化部署之后，建议一个容器中只启动一个Chrome。 这样会让代码简单并且出现问题好排查。这就要求Chrome在代码中是单例 在整个Chrome做操作期间，对Chrome崩溃的情况做处理 在业务代码期间，建议使用try catch 来捕获异常，对于非业务异常，需要关闭掉Chrome。防止出现多个Chrome。 Chrome在关闭的时候出现异常，也需要处理 在调用close()api来关闭Chrome的时候，可能会报错（可能Chrome在这个时候被操作系统kill掉，会出现孤儿进程）。 建议：在这个时候直接通过shell脚本来强行kill掉 #!/bin/bash\n\npids=$(ps -ef | grep \"[c]hrome\" | grep -v 'kill_chrome_processes.sh' |awk '{print $2}')\n\nfor pid in $pids; do\n echo \"Terminating PID $pid\"\n kill $pid\ndone\n\necho \"All chrome processes have been terminated.\"\n\n\n孤儿进程：\n父进程启动了子进程，子进程在没有退出的情况下，父进程退出了。此时子进程会被init进程接管。\n 尽量关闭掉无用的功能，让他越简单越好。 比如：-no-sandbox,--disable-extensions,--disable-gpu,--disable_scrollbars 共享内存\n\nChrome 默认使用 /dev/shm 共享内存，但是 docker 默认/dev/shm 只有64MB，显然是不够使用的，提供两种方式来解决：\n启动 docker 时添加参数 --shm-size=1gb 来增大 /dev/shm 共享内存，但是 swarm 目前不支持 shm-size 参数启动 Chrome 添加参数 - disable-dev-shm-usage，禁止使用 /dev/shm 共享内存\n \n参考文档\nhttps://www.neovasolutions.com/2022/05/19/browser-automation-tools-protocols-webdriver-vs-cdp/https://dev.to/jankaritech/different-approaches-protocols-to-automate-the-browser-39f1https://stackoverflow.com/questions/50939116/what-is-the-difference-between-webdriver-and-devtool-protocolhttps://zhuanlan.zhihu.com/p/76237595\n 关于博客这件事，我是把它当做我的笔记，里面有很多的内容反映了我思考的过程，因为思维有限，不免有些内容有出入，如果有问题，欢迎指出。一同探讨。谢谢。\n \n\n\n\n\n\n\n\n\n\n\n\n\n\n 确定要放弃本次机会？\n \n福利倒计时\n\n\n:\n\n:\n\n\n\n\n\n立减 ¥\n\n\n普通VIP年卡可用\n\n立即使用\n\n \n\n\n\n\n\n daliucheng\n \n\n\n\n关注\n关注\n\n\n\n\n\n\n\n\n\n\n 27\n \n\n点赞\n\n\n\n\n\n\n\n踩\n\n\n\n\n\n\n\n 21\n \n\n\n\n\n 收藏\n \n\n\n\n\n 觉得还不错?\n \n 一键收藏\n \n\n\n\n\n\n\n\n知道了\n\n\n\n\n 0\n \n\n评论\n\n\n\n\n\n\n\n\n\n\n\n\n\n CDP和Chrome\n \n\n WebDriver和是用于自动化浏览器的两个主要协议，大多数的浏览器自动化工具都是基于上述其中之一来实现的。可以通过这两种形式来和浏览器交互，通过代码来控制浏览器，完成浏览器的自动化行为（包括网页加载，爬虫，截图，导出pdf等）。\n \n复制链接\n\n\n\n扫一扫\n\n\n\n\n\n\n\n\n\n\n专栏目录\n\n\n\n\n\n\n\n \n\n\n\n\n\nPython cdp ( Chrome DevTools Protocol ) 爬虫\n\n\n\n\n墨鱼菜鸡\n\n\n07-11\n\n\t\t\t\t\t3265\n\t\t\t\t\t\n\n\n\n\n\ndevtools-protocol：https://github.com/ChromeDevTools/devtools-protocol Chrome DevTools Protocol：https://chromedevtools.github.io/devtools-protocol/ Awesome Chrome DevTools ：https:...\n\n\n\n\n\n\n\n\n\n\n\n\nChrome DevTools Protocol(谷歌开发者工具协议)Protocol Monitor（协议监视器）\n\n\n\n\nllrraa2010的专栏\n\n\n06-10\n\n\t\t\t\t\t2633\n\t\t\t\t\t\n\n\n\n\n\n该协议最初是由谷歌开发者工具团队维护的，负责调试、操作浏览器的协议。我们经常使用到的谷歌浏览器的开发者工具（快捷键 CTRL + SHIFT + I 或者 F12）就是使用这个协议来操作浏览器的。与 Selenium 需要与浏览器驱动进行交互不同的是，Chrome DevTools 协议直接通过 Web Socket 协议与浏览器暴露的 API 进行通信，这使得 Chrome DevTools 协议操作浏览器变得更快。我们要重启开发者工具，在右侧点击更多工具，这样就可以看到协议监视器面板了。\n\n\n\n\n\n\n\n\n参与评论\n您还未登录，请先\n登录\n后发表或查看评论\n\n\n\n\n\n\n\n\n\n探索Web开发新维度：Devtools-Protocol\n最新发布\n\n\n\n\ngitblog_00001的博客\n\n\n05-15\n\n\t\t\t\t\t353\n\t\t\t\t\t\n\n\n\n\n\n探索Web开发新维度：Devtools-Protocol\n项目地址:https://gitcode.com/ChromeDevTools/devtools-protocol\n项目介绍\n在Web开发的世界中，Chrome DevTools Protocol（DTP）是连接开发者和浏览器内核的桥梁，它允许我们进行深度的调试、性能分析以及自动化测试。而devtools-protocol是一个官方维护的开...\n\n\n\n\n\n\n\n\n\nusus使用Chrome调试协议CDP渲染页面\n\n\n\n\n08-08\n\n\n\n\n\nusus 使用Chrome调试协议（CDP）渲染页面。 提取用于渲染页面的CSS。 渲染带有阻塞CSS的HTML异步。\n\n\n\n\n\n\n\n\n\n\n\n浏览器自动化必须知道CDP协议\n\n\n\n\n白天安全建设，晚上全栈开发，大模型爱好者。公众号：飞羽技术工坊。\n\n\n01-13\n\n\t\t\t\t\t1067\n\t\t\t\t\t\n\n\n\n\n\n之前搞自动化页面，因为有一个获取网络日志的需求，让我发现了新的知识盲区——CDP协议。\n\n\n\n\n\n\n\n\n\nChrome DevTools 通过 cdp 调节 CPU Throttling\n\n\n\n\n时丶光\n\n\n11-26\n\n\t\t\t\t\t927\n\t\t\t\t\t\n\n\n\n\n\n打开DevTools (快捷键ctrl + shift + i)\n\n在DevTools 界面再打开DevTools\n\n\n\n\nlet Main = await import('./devtools-frontend/front_end/entrypoints/main/main.js'); // or './entrypoints/main/main.js' or './main/main.js' depending on the browser version\n\n//设置CPU Throttling 为本机\n\n\n\n\n\n\n\n\n\ncdp:软件包cdp为使用Go编程语言编写的Chrome DevTools协议（CDP）提供了类型安全的绑定\n\n\n\n\n05-04\n\n\n\n\n\n光盘\n 软件包cdp为使用Go编程语言编写的（CDP）提供了类型安全的绑定。 绑定是由根据最新协议定义生成的，并且主要用于Google Chrome或Chromium，但是它们可以与任何调试目标（ ， ， 等）。\n 通过Chrome DevTools协议，该软件包可用于任何类型的浏览器自动化，脚本编写或调试。\n cdp主要动机是公开Chrome DevTools协议的全部功能，并以一种可发现的自记录方式提供它。\n 提供高级浏览器自动化对于该项目而言是不可行的。 话虽如此， cdp希望通过提供更适合Go的原语并自动执行重复性任务来改善使用该协议的人体工程学。\n特征\n适用于Chrome DevTools协议的可发现API（GoDoc，自动完成友好）\n 作为头等公民的情况（用于超时和取消）\n 简单且同步的事件处理（无回调）\n 同时安全\n没有无声或隐藏的错误\n做到用户期望的\n尽可能将CDP类型与\n\n\n\n\n\n\n\n\n\nichrome：适用于人类的Chrome控制器，基于Chrome Devtools协议（CDP）和python3.7 +\n\n\n\n\n01-31\n\n\n\n\n\n适用于人类的Chrome控制器，基于和python3.7 +。为什么？ Pyppeteer很棒，但是我不需要那么多pyppeteer的拼写很混乱事件驱动的编程并非总是明智的。 Selenium慢网络驱动程序经常带有内存泄漏。 迫切需要一个稳定的...\n\n\n\n\n\n\n\n\n\nselenium_cdp：Selenium 4x，执行Chrome DevTools协议命令\n\n\n\n\n01-31\n\n\n\n\n\n该项目采用Java Selenium 4.0.x版本的来执行（也称为cdp命令），这是一套完全不同的API，通过对/session/$sessionId/goog/cdp/execute POST POST 传达给Chrome浏览器系列，特定的有效负载）功能（许多cdp方法，例如...\n\n\n\n\n\n\n\n\n\ncdp4j：cdp4j-适用于Java的Chrome DevTools协议\n\n\n\n\n01-28\n\n\n\n\n\ncdp4j是Java库，具有清晰简洁的API，可自动执行基于Chrome / Chromium的浏览器。 它使用Google Chrome DevTools协议来自动化基于Chrome / Chromium的浏览器。 cdp4j可以做什么？ 自动填写表格。 您可以轻松下载和...\n\n\n\n\n\n\n\n\n\ngetting-started-with-cdp:Chrome DevTools 协议入门\n\n\n\n\n07-24\n\n\n\n\n\n使用 Chrome DevTools 协议在直接使用 CDP 进行浏览器自动化之前要三思。 有会让你过得更好不服气？ 至少使用 。 另请参阅介绍注意： ://vanilla.aslushnikov.com 提供了交互式协议查看器。 Chrome DevTools 协议...\n\n\n\n\n\n\n\n\n\nChrome之远程调试协议（Remote debugging protocol） - Div.IO\n\n\n\n\nweixin_33940102的博客\n\n\n06-27\n\n\t\t\t\t\t1781\n\t\t\t\t\t\n\n\n\n\n\nChrome之远程调试协议（Remote debugging protocol） - Div.IO\n\n\n\n\n\n\n\n\n\n一文读懂UI自动化测试三种核心实现原理：Native、Webdriver和CDP\n\n\n\n\nliwenxiang629的博客\n\n\n04-03\n\n\t\t\t\t\t808\n\t\t\t\t\t\n\n\n\n\n\n相信80%的UI自动化测试工程师在进行岗位面试的时候都会重点讲解自己会使用哪些工具，例如cypress 、selenium 、playwright等等。其实这只是初级段位，如果大家想谈得再高大上一些，就可以谈谈这些工具与浏览器talk的原理了，绝对会得到面试官的重视！目前主流主动化测试工具与浏览器沟通的原理主要包括：Native、Webdriver以及CDP，使用这三种方式的典型代表工具分别是：cypress 、selenium 和playwright。今天我就对此进行总结：\n\n\n\n\n\n\n\n\n\n朋友们，一起学习下 Chrome DevTools Protocol。\n\n\n\n\nz_l_x_的博客\n\n\n10-18\n\n\t\t\t\t\t3072\n\t\t\t\t\t\n\n\n\n\n\n1947 年 9 月 9 日，First actual case of bug being found，自此引入了 Debugging。\n\n\n\n\n\n\n\n\n\nCDP 远程调试方案\n\n\n\n\n老司机的后备箱\n\n\n05-23\n\n\t\t\t\t\t3656\n\t\t\t\t\t\n\n\n\n\n\n什么是 cdp 协议\ncdp 协议简称 chrome 调试协议，是基于 scoket（websocket、usb、adb ）消息的 json rpc 协议。用来调用 chrome 内部的方法实现 js，css ，dom 的开发调试。 可以将 实现了 cdp 协议的应用 看做 rpc 调用的服务端（ chrome ，puppeteer）， 将调试面板看做 rpc 调用的客户端（devtools）。\ndevtools 调试系统\n完整的调试系统分别由前端，后端，协议，通道四部分组成\n\nFrontend：调试器前端\n\n\n\n\n\n\n\n\n\nGo Chromedp库得使用----CDP（Chrome DevTools Protocol)\n\n\n\n\n路小白的博客\n\n\n12-24\n\n\t\t\t\t\t8813\n\t\t\t\t\t\n\n\n\n\n\nGo chromedp库的使用 —CDP\n文章目录Go chromedp库的使用 ---CDPCDP（Chrome DevTools Protocol)基于CDP协议的相关语言操作Chromedp使用示例本地界面浏览器操作远程操作示例（无头浏览器）Centos 安装chronium-headless示例代码Browsesrless/chrome部署Linux-Centos安装NodeJS参考\nCDP（Chrome DevTools Protocol)\nChrome DevTools Protocol 是基.\n\n\n\n\n\n\n\n\n\n【学习笔记】selenium ChromeDriver 移除navigator.webdriver属性\n\n\n\n\nMONKEYMONEY_的博客\n\n\n12-16\n\n\t\t\t\t\t906\n\t\t\t\t\t\n\n\n\n\n\n作为新手的我，\n在刚接触selenium时不了解的\nChrome Driver 一些常用属性和方法。\n为此特意记录了以下几项并加上注释，方便以后查阅调用。\n\n\n \nSelenium中的ChromeOptions选项\n\n\nchromeOptions是一个配置chrome启动属性的类。通过这个类，我们可以为chrome配置如下参数（这个部分可以通过selenium源码看到）：\n\n设置 chrome 二进制文件位置 (binary_location)\n添加启动参数 (add_argument)\n添加扩展应用 (a\n\n\n\n\n\n\n\n\n\nChrome DevTools Protocol localstorage\n\n\n\n\n06-07"
}
[chain/start] [chain:RunnableSequence > chain:RunnableParallel<doc> > chain:RunnableLambda] Entering Chain run with input:
[inputs]
[chain/end] [chain:RunnableSequence > chain:RunnableParallel<doc> > chain:RunnableLambda] [1ms] Exiting Chain run with output:
{
"output": "设置 chrome 二进制文件位置 (binary_location)\n添加启动参数 (add_argument)\n添加扩展应用 (a\n\n\n\n\n\n\n\n\n\nChrome DevTools Protocol localstorage\n\n\n\n\n06-07\n\n\n\n\n\nChrome DevTools Protocol 可以通过 `Runtime.evaluate()` 方法来读取和修改本地存储 (`localStorage`) 的值。以下是一个使用 Node.js 和 `chrome-remote-interface` 模块与 Chrome DevTools Protocol 交互的例子：\n\n```javascript\nconst CDP = require('chrome-remote-interface');\n\nCDP(async function(client) {\n const { Runtime } = client;\n await Runtime.enable();\n\n // 读取 localStorage 中的值\n const { result } = await Runtime.evaluate({\n expression: 'localStorage.getItem(\"key\")'\n });\n console.log(result.value);\n\n // 设置 localStorage 中的值\n await Runtime.evaluate({\n expression: 'localStorage.setItem(\"key\", \"value\")'\n });\n\n client.close();\n}).on('error', (err) => {\n console.error('Cannot connect to browser:', err);\n});\n```\n\n需要注意的是，这个例子只是一个简单的示例，并没有对错误处理进行详细的说明。在实际使用中，需要对错误进行适当的处理，以确保程序的稳定性和可靠性。\n\n\n\n\n\n\n“相关推荐”对你有帮助么？\n\n\n\n\n\n\n\n非常没帮助\n\n\n\n\n\n\n没帮助\n\n\n\n\n\n\n一般\n\n\n\n\n\n\n有帮助\n\n\n\n\n\n\n非常有帮助\n\n\n\n\n\n提交\n\n\n\n\n\n \n\n\n\n\n\n\n\n\n\n\n\ndaliucheng\n\n\n\n\nCSDN认证博客专家\n\n\nCSDN认证企业博客\n\n\n\n码龄7年\n\n\n\n 暂无认证\n \n\n\n\n\n\n\n\n151\n原创\n\n\n\n\n4万+\n周排名\n\n\n\n\n4万+\n总排名\n\n\n\n17万+\n访问\n\n\n\n\n\n\n等级\n\n\n\n\n\n2170\n积分\n\n\n303\n粉丝\n\n\n287\n获赞\n\n\n51\n评论\n\n\n709\n收藏\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n私信\n\n\n关注\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n热门文章\n\n\n\n\n\t\t\t\tSpring 定时任务@EnableScheduling解析\n\t\t\t\t\t\n27879\n\n\n\n\n\t\t\t\t数据库——求候选键的方法\n\t\t\t\t\t\n16022\n\n\n\n\n\t\t\t\t数据库——求候选键的方法\n\t\t\t\t\t\n14297\n\n\n\n\n\t\t\t\tSpring-动态数据源\n\t\t\t\t\t\n6182\n\n\n\n\n\t\t\t\tMybatis中mapper是怎么和XMl关联起来的\n\t\t\t\t\t\n5361\n\n\n\n\n\n\n分类专栏\n\n\n\n\n\n\n\n 自动化测试\n \n\n1篇\n\n\n\n\n\n\n go语言\n \n\n21篇\n\n\n\n\n\n\n springData MongoDB\n \n\n4篇\n\n\n\n\n\n\n spring\n \n\n26篇\n\n\n\n\n\n\n Springmvc\n \n\n4篇\n\n\n\n\n\n\n mybaties\n \n\n11篇\n\n\n\n\n\n\n LeetCode算法\n \n\n2篇\n\n\n\n\n\n\n Java并发\n \n\n18篇\n\n\n\n\n\n\n netty\n \n\n2篇\n\n\n\n\n\n\n 安全框架\n \n\n2篇\n\n\n\n\n\n\n 大数据\n \n\n2篇\n\n\n\n\n\n\n 流程引擎 activiti\n \n\n4篇\n\n\n\n\n\n\n hadoop\n \n\n\n\n\n\n\n\n hibernate\n \n\n\n\n\n\n\n\n android\n \n\n1篇\n\n\n\n\n\n\n 数据结构\n \n\n11篇\n\n\n\n\n\n\n 数据库\n \n\n6篇\n\n\n\n\n\n\n java基础\n \n\n12篇\n\n\n\n\n\n\n\n\n最新评论\n\n\n\nspring——Java Proxy和Cglib两种方式方法嵌套调用时代理对象行为分析\n\nHuunnnn: \n所以说网上总是说自调用失效是因为spring默认用的代理模式是java的动态代理 如果改配置让代理模式强制改为cglib的代理模式 这样自调用时的aop注解就不会失效了吧\n\n\n\nGO-日志分析\n\n白话机器学习: \n内容丰富图文并茂，认真看完收获很大。思路清晰细节满满，支持大佬优质好文。\n\n\n\nSpring——创建代理对象-Java Proxy方法分析（JdkDynamicAopProxy）\n\nwei青青: \nTestProxyFactory main方法中的T Do 这两个类的定义能放下代码吗？\n\n\n\nTreeMap分析\n\ndaliucheng: \n欢迎交流\n\n\n\nTreeMap分析\n\n杨思默: \n博主总结很详细啊。\n\n\n\n\n\n\n大家在看\n\n\n\n\n\t\t\t\t从零开始学习嵌入式——C语言数值传递（值传递和地址传递）\n \n\n\n\n\t\t\t\tue4----------理论（4.PBR)\n\t\t\t\t\t\n330\n\n\n\n\n\t\t\t\tAiax应用 get请求 post请求 json数据请求\n\t\t\t\t\t\n447\n\n\n\n\n\t\t\t\t帮自己了解疾病症状的健康APP，平时可以不用，关键时候必须要有！\n\t\t\t\t\t\n305\n\n\n\n\n\t\t\t\t椭流线法设计配光器\n\t\t\t\t\t\n558\n\n\n\n\n\n\n最新文章\n\n\n\nGO-日志分析\n\n\nGo 异步任务\n\n\nDubbogo 详解\n\n\n\n\n2024年1篇\n2023年15篇\n2022年24篇\n2021年44篇\n2020年26篇\n2019年19篇\n2018年20篇\n2017年2篇\n\n\n\n\n\n\n\n\n\n\n\n\n目录\n\n\n\n\n\n\n\n\n\n\n\n\n \n\n\n\n\n\n\n\n\n目录\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n分类专栏\n\n\n\n\n\n\n\n\n 自动化测试\n \n\n1篇\n\n\n\n\n\n\n go语言\n \n\n21篇\n\n\n\n\n\n\n springData MongoDB\n \n\n4篇\n\n\n\n\n\n\n spring\n \n\n26篇\n\n\n\n\n\n\n Springmvc\n \n\n4篇\n\n\n\n\n\n\n mybaties\n \n\n11篇\n\n\n\n\n\n\n LeetCode算法\n \n\n2篇\n\n\n\n\n\n\n Java并发\n \n\n18篇\n\n\n\n\n\n\n netty\n \n\n2篇\n\n\n\n\n\n\n 安全框架\n \n\n2篇\n\n\n\n\n\n\n 大数据\n \n\n2篇\n\n\n\n\n\n\n 流程引擎 activiti\n \n\n4篇\n\n\n\n\n\n\n hadoop\n \n\n\n\n\n\n\n\n hibernate\n \n\n\n\n\n\n\n\n android\n \n\n1篇\n\n\n\n\n\n\n 数据结构\n \n\n11篇\n\n\n\n\n\n\n 数据库\n \n\n6篇\n\n\n\n\n\n\n java基础\n \n\n12篇\n\n\n\n\n\n\n\n\n\n\n\n\n\n目录\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n评论\n\n\n\n\n被折叠的 条评论\n\t\t 为什么被折叠?\n\n到【灌水乐园】发言\n\n\n\n查看更多评论\n\n\n\n\n\n\n 添加红包\n \n\n\n\n祝福语\n\n\n\n\n请填写红包祝福语或标题\n\n\n红包数量\n\n\n个\n\n红包个数最小为10个\n\n\n红包总金额\n\n\n元\n\n红包金额最低5元\n\n\n余额支付\n\n 当前余额3.43元\n 前往充值 >\n\n\n\n\n 需支付：10.00元\n \n取消\n确定\n\n\n\n\n\n\n\n下一步\n\n\n\n知道了\n\n\n\n\n\n\n\n\n\n\n成就一亿技术人!\n\n\n\n\n\n\n 领取后你会自动成为博主和红包主的粉丝\n 规则\n\n\n\n\n\n\n\n\n\n\nhope_wisdom 发出的红包\n \n\n\n\n\n\n\n\n\n\n\n\n\n\n实付元\n使用余额支付\n\n\n\n\n点击重新获取\n\n\n扫码支付\n\n\n\n\n\n\n\n\n\n\n\n钱包余额\n0\n\n\n\n\n抵扣说明：\n 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。\n\n\n\n\n余额充值"
}
[chain/end] [chain:RunnableSequence > chain:RunnableParallel<doc>] [4ms] Exiting Chain run with output:
{
"doc": "设置 chrome 二进制文件位置 (binary_location)\n添加启动参数 (add_argument)\n添加扩展应用 (a\n\n\n\n\n\n\n\n\n\nChrome DevTools Protocol localstorage\n\n\n\n\n06-07\n\n\n\n\n\nChrome DevTools Protocol 可以通过 `Runtime.evaluate()` 方法来读取和修改本地存储 (`localStorage`) 的值。以下是一个使用 Node.js 和 `chrome-remote-interface` 模块与 Chrome DevTools Protocol 交互的例子：\n\n```javascript\nconst CDP = require('chrome-remote-interface');\n\nCDP(async function(client) {\n const { Runtime } = client;\n await Runtime.enable();\n\n // 读取 localStorage 中的值\n const { result } = await Runtime.evaluate({\n expression: 'localStorage.getItem(\"key\")'\n });\n console.log(result.value);\n\n // 设置 localStorage 中的值\n await Runtime.evaluate({\n expression: 'localStorage.setItem(\"key\", \"value\")'\n });\n\n client.close();\n}).on('error', (err) => {\n console.error('Cannot connect to browser:', err);\n});\n```\n\n需要注意的是，这个例子只是一个简单的示例，并没有对错误处理进行详细的说明。在实际使用中，需要对错误进行适当的处理，以确保程序的稳定性和可靠性。\n\n\n\n\n\n\n“相关推荐”对你有帮助么？\n\n\n\n\n\n\n\n非常没帮助\n\n\n\n\n\n\n没帮助\n\n\n\n\n\n\n一般\n\n\n\n\n\n\n有帮助\n\n\n\n\n\n\n非常有帮助\n\n\n\n\n\n提交\n\n\n\n\n\n \n\n\n\n\n\n\n\n\n\n\n\ndaliucheng\n\n\n\n\nCSDN认证博客专家\n\n\nCSDN认证企业博客\n\n\n\n码龄7年\n\n\n\n 暂无认证\n \n\n\n\n\n\n\n\n151\n原创\n\n\n\n\n4万+\n周排名\n\n\n\n\n4万+\n总排名\n\n\n\n17万+\n访问\n\n\n\n\n\n\n等级\n\n\n\n\n\n2170\n积分\n\n\n303\n粉丝\n\n\n287\n获赞\n\n\n51\n评论\n\n\n709\n收藏\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n私信\n\n\n关注\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n热门文章\n\n\n\n\n\t\t\t\tSpring 定时任务@EnableScheduling解析\n\t\t\t\t\t\n27879\n\n\n\n\n\t\t\t\t数据库——求候选键的方法\n\t\t\t\t\t\n16022\n\n\n\n\n\t\t\t\t数据库——求候选键的方法\n\t\t\t\t\t\n14297\n\n\n\n\n\t\t\t\tSpring-动态数据源\n\t\t\t\t\t\n6182\n\n\n\n\n\t\t\t\tMybatis中mapper是怎么和XMl关联起来的\n\t\t\t\t\t\n5361\n\n\n\n\n\n\n分类专栏\n\n\n\n\n\n\n\n 自动化测试\n \n\n1篇\n\n\n\n\n\n\n go语言\n \n\n21篇\n\n\n\n\n\n\n springData MongoDB\n \n\n4篇\n\n\n\n\n\n\n spring\n \n\n26篇\n\n\n\n\n\n\n Springmvc\n \n\n4篇\n\n\n\n\n\n\n mybaties\n \n\n11篇\n\n\n\n\n\n\n LeetCode算法\n \n\n2篇\n\n\n\n\n\n\n Java并发\n \n\n18篇\n\n\n\n\n\n\n netty\n \n\n2篇\n\n\n\n\n\n\n 安全框架\n \n\n2篇\n\n\n\n\n\n\n 大数据\n \n\n2篇\n\n\n\n\n\n\n 流程引擎 activiti\n \n\n4篇\n\n\n\n\n\n\n hadoop\n \n\n\n\n\n\n\n\n hibernate\n \n\n\n\n\n\n\n\n android\n \n\n1篇\n\n\n\n\n\n\n 数据结构\n \n\n11篇\n\n\n\n\n\n\n 数据库\n \n\n6篇\n\n\n\n\n\n\n java基础\n \n\n12篇\n\n\n\n\n\n\n\n\n最新评论\n\n\n\nspring——Java Proxy和Cglib两种方式方法嵌套调用时代理对象行为分析\n\nHuunnnn: \n所以说网上总是说自调用失效是因为spring默认用的代理模式是java的动态代理 如果改配置让代理模式强制改为cglib的代理模式 这样自调用时的aop注解就不会失效了吧\n\n\n\nGO-日志分析\n\n白话机器学习: \n内容丰富图文并茂，认真看完收获很大。思路清晰细节满满，支持大佬优质好文。\n\n\n\nSpring——创建代理对象-Java Proxy方法分析（JdkDynamicAopProxy）\n\nwei青青: \nTestProxyFactory main方法中的T Do 这两个类的定义能放下代码吗？\n\n\n\nTreeMap分析\n\ndaliucheng: \n欢迎交流\n\n\n\nTreeMap分析\n\n杨思默: \n博主总结很详细啊。\n\n\n\n\n\n\n大家在看\n\n\n\n\n\t\t\t\t从零开始学习嵌入式——C语言数值传递（值传递和地址传递）\n \n\n\n\n\t\t\t\tue4----------理论（4.PBR)\n\t\t\t\t\t\n330\n\n\n\n\n\t\t\t\tAiax应用 get请求 post请求 json数据请求\n\t\t\t\t\t\n447\n\n\n\n\n\t\t\t\t帮自己了解疾病症状的健康APP，平时可以不用，关键时候必须要有！\n\t\t\t\t\t\n305\n\n\n\n\n\t\t\t\t椭流线法设计配光器\n\t\t\t\t\t\n558\n\n\n\n\n\n\n最新文章\n\n\n\nGO-日志分析\n\n\nGo 异步任务\n\n\nDubbogo 详解\n\n\n\n\n2024年1篇\n2023年15篇\n2022年24篇\n2021年44篇\n2020年26篇\n2019年19篇\n2018年20篇\n2017年2篇\n\n\n\n\n\n\n\n\n\n\n\n\n目录\n\n\n\n\n\n\n\n\n\n\n\n\n \n\n\n\n\n\n\n\n\n目录\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n分类专栏\n\n\n\n\n\n\n\n\n 自动化测试\n \n\n1篇\n\n\n\n\n\n\n go语言\n \n\n21篇\n\n\n\n\n\n\n springData MongoDB\n \n\n4篇\n\n\n\n\n\n\n spring\n \n\n26篇\n\n\n\n\n\n\n Springmvc\n \n\n4篇\n\n\n\n\n\n\n mybaties\n \n\n11篇\n\n\n\n\n\n\n LeetCode算法\n \n\n2篇\n\n\n\n\n\n\n Java并发\n \n\n18篇\n\n\n\n\n\n\n netty\n \n\n2篇\n\n\n\n\n\n\n 安全框架\n \n\n2篇\n\n\n\n\n\n\n 大数据\n \n\n2篇\n\n\n\n\n\n\n 流程引擎 activiti\n \n\n4篇\n\n\n\n\n\n\n hadoop\n \n\n\n\n\n\n\n\n hibernate\n \n\n\n\n\n\n\n\n android\n \n\n1篇\n\n\n\n\n\n\n 数据结构\n \n\n11篇\n\n\n\n\n\n\n 数据库\n \n\n6篇\n\n\n\n\n\n\n java基础\n \n\n12篇\n\n\n\n\n\n\n\n\n\n\n\n\n\n目录\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n评论\n\n\n\n\n被折叠的 条评论\n\t\t 为什么被折叠?\n\n到【灌水乐园】发言\n\n\n\n查看更多评论\n\n\n\n\n\n\n 添加红包\n \n\n\n\n祝福语\n\n\n\n\n请填写红包祝福语或标题\n\n\n红包数量\n\n\n个\n\n红包个数最小为10个\n\n\n红包总金额\n\n\n元\n\n红包金额最低5元\n\n\n余额支付\n\n 当前余额3.43元\n 前往充值 >\n\n\n\n\n 需支付：10.00元\n \n取消\n确定\n\n\n\n\n\n\n\n下一步\n\n\n\n知道了\n\n\n\n\n\n\n\n\n\n\n成就一亿技术人!\n\n\n\n\n\n\n 领取后你会自动成为博主和红包主的粉丝\n 规则\n\n\n\n\n\n\n\n\n\n\nhope_wisdom 发出的红包\n \n\n\n\n\n\n\n\n\n\n\n\n\n\n实付元\n使用余额支付\n\n\n\n\n点击重新获取\n\n\n扫码支付\n\n\n\n\n\n\n\n\n\n\n\n钱包余额\n0\n\n\n\n\n抵扣说明：\n 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。\n\n\n\n\n余额充值"
}
[chain/start] [chain:RunnableSequence > prompt:ChatPromptTemplate] Entering Prompt run with input:
{
"doc": "CDP和Chrome_chrome devtools protocol-CSDN博客\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nCDP和Chrome\n\n\n\n\n\ndaliucheng\n\n已于 2024-02-19 00:07:33 修改\n\n\n阅读量1.7k\n\n\n\n收藏\n\n 21\n \n\n\n\n\n点赞数\n 27\n \n\n\n\n\n\n\n分类专栏：\n自动化测试\n文章标签：\nchrome\n自动化\npython\nnode.js\n\n\n于 2024-02-18 23:45:32 首次发布\n\n\n\n 版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。\n \n\n 本文链接：https://blog.csdn.net/daliucheng/article/details/136160807\n\n\n\n\n版权\n\n\n\n\n\n\n\n\n\n\n\n\n\n自动化测试\n专栏收录该内容\n\n\n\n\n\n1 篇文章\n0 订阅\n\n\n订阅专栏\n\n\n\n\n\n\n\n\n\n\n\n\nCDP和Chrome\nCDP和WebDriver Protocol\nWebDriver和 Chrome DevTools Protocol（CDP） 是用于自动化浏览器的两个主要协议，大多数的浏览器自动化工具都是基于上述其中之一来实现的。可以通过这两种形式来和浏览器交互，通过代码来控制浏览器，完成浏览器的自动化行为（包括网页加载，爬虫，截图，导出pdf等）。\nWebDriver Protocol\n官网地址：链接\nWebDriver 是一个用于控制浏览器的远程控制接口，由 Selenium HQ 开发，后来由 W3C 标准化。它提供了一个平台和语言中立的接口，支持几乎所有主流浏览器，如 Chrome、 Firefox、 Safari、 Edge、 Opera 等。\n它和浏览器的通信是通过 JSON Wire 协议完成的，提供了RESTful的web服务，这个服务端就被称为服务端（也被称为webdriver），例如chromeDriver、geckoDriver等。\n有服务端就有客户端，客户端可以选择任何语言，客户端和服务端交互，服务端和浏览器交互，从而操作浏览器。常见的客户端就是selenium,nightwatch,webdriverio \n加上我们的自己写的自动化测试代码之后，交互流程如下：\n\nChrome DevTools Protocol\n官网地址：链接\nChromeDevTools Protocol (CDP)是一个基于 Chromium 的浏览器的调试协议，如 Chrome、 Edge、 Opera 等。通过它可以直接和浏览器交互。控制浏览器的行为。\n客户端和浏览器之间没有类似于WebDriver Protocol的服务端（webdriver），而是客户端通过WebSocket直接和浏览器连\n类似网络驱动服务器(浏览器驱动程序)的中间人。相反，浏览器是由客户端使用 CDP 直接控制的。与浏览器的通信是通过套接字连接完成的，因此也支持双向通信。客户端通过WebSocket发送命令给浏览器，浏览器执行并返回响应。\n\n两个相当流行的工具是Puppeteer和Playwright。它们不依赖于webdriver，而是通过 Chrome DevTools Protocol (CDP)直接与浏览器通话。从而更加灵活稳定的控制浏览器。\n区别\n从代码层面来看，使用的代码接近底层，接近浏览器，代码就会变得更加的稳定和强大，但对于跨浏览器的支持会变得更少。另一方面，代码和浏览器的之间的抽象程度越高，支持的浏览器就越多，但代码会变得不稳定并且功能受限。\n对比上面两种\n WebDriver Protocol 支持的浏览器多，但不是很稳定，并且功能不强大。 Chrome DevTools Protocol 支持的浏览器少（只是相对WebDriver来说，Chrome能支持就能用），功能强大，稳定。 \nWebdriver ProtocolChrome DevTools ProtocolDeveloped by: W3CDeveloped by: Chrome Developer Tools需要webdriver不需要webdriver相对较慢并且不是很稳定速度快，较稳定支持的浏览器多支持部分浏览器无法通过提供的api来访问浏览器中网络相关的信息可以通过api来访问网络相关的信息它的实现有：Selenium WebDriver 3, WebdriverIO, Nightwatch它的实现有：Playwright, Puppeteer, Selenium Webdriver 4, Cypress v7\n不同的WebDriver有不同的实现方式，chromeDriver内部是通过DevTools protoco来控制浏览器的。\n如何选择\n如果跨浏览器很重要，就选webDriver，否则选择CDP\npuppeteer\n链接：官网，github，github-examples\nPuppeteer 是 Chrome 开发团队在 2017 年发布的一个 Node.js 包，是它提供了一个高级 API，通过 DevTools 协议控制 Chrome/Chromium。\n为什么选择它？\n两个理由\ngithub中star数多Chrome开发团队\n可以做什么？\n简单来说，浏览器能做的，它都能做\n截图和生成PDF爬取 SPA 或 SSR 网站UI 自动化测试…\n版本说明\n从v1.7.0 版本以来，每次发布都会发布两个软件包：\n puppeteer\n\n它会自动下载一个最新版本的 Chrome 用于测试（macOS 约 170MB，Linux 约 282MB，Windows 约 280MB）以及一个 chrome-headless-shell 二进制文件（从 Puppeteer v21.6.0 开始），这个二进制文件保证可以与 Puppeteer 配合正常工作。默认情况下，浏览器会下载到 $HOME/.cache/puppeteer 文件夹中（从 Puppeteer v19.0.0 开始）。\n通过puppeteer-core 控制它下载的浏览器\n puppeteer-core\n\npuppeteer-core 是一个库，用于帮助驱动任何支持 DevTools 协议的内容。\n它不会下载浏览器，它提供了封装好的API和浏览器交互。\n如果自己已经下载了浏览器，就可以使用它，但是必须在调用puppeteer.launch的时候显式的指定executablePath(浏览器的执行位置)\n 一般来说我会使用这个 \n代码\n建议看这篇文章 结合项目来谈谈 Puppeteer 在结合 github-examples的例子。\n注意点\n 在部署的时候，建议使用容器化，Chrome本身是内存大户，如果遇到内存飙升，代码是不太好发现这种情况的，不能及时kill掉。 在加载网页的时候不建议每次都关闭和开启一个新的。 Chrome的启动和关系是比较耗时的，每次启动会慢150ms到300ms 建议重复使用同一个Chrome。 Chrome使用一段时间之后，要关掉重启。 Chrome在我们自己的电脑中有的时候，页面都会崩溃，浏览器也会崩溃。在服务器这种情况下，肯定也会出现，建议在内存中设置调用阈值，比如加载了100个网页，重启一次。这样可降低崩溃的概率。 容器化部署之后，建议一个容器中只启动一个Chrome。 这样会让代码简单并且出现问题好排查。这就要求Chrome在代码中是单例 在整个Chrome做操作期间，对Chrome崩溃的情况做处理 在业务代码期间，建议使用try catch 来捕获异常，对于非业务异常，需要关闭掉Chrome。防止出现多个Chrome。 Chrome在关闭的时候出现异常，也需要处理 在调用close()api来关闭Chrome的时候，可能会报错（可能Chrome在这个时候被操作系统kill掉，会出现孤儿进程）。 建议：在这个时候直接通过shell脚本来强行kill掉 #!/bin/bash\n\npids=$(ps -ef | grep \"[c]hrome\" | grep -v 'kill_chrome_processes.sh' |awk '{print $2}')\n\nfor pid in $pids; do\n echo \"Terminating PID $pid\"\n kill $pid\ndone\n\necho \"All chrome processes have been terminated.\"\n\n\n孤儿进程：\n父进程启动了子进程，子进程在没有退出的情况下，父进程退出了。此时子进程会被init进程接管。\n 尽量关闭掉无用的功能，让他越简单越好。 比如：-no-sandbox,--disable-extensions,--disable-gpu,--disable_scrollbars 共享内存\n\nChrome 默认使用 /dev/shm 共享内存，但是 docker 默认/dev/shm 只有64MB，显然是不够使用的，提供两种方式来解决：\n启动 docker 时添加参数 --shm-size=1gb 来增大 /dev/shm 共享内存，但是 swarm 目前不支持 shm-size 参数启动 Chrome 添加参数 - disable-dev-shm-usage，禁止使用 /dev/shm 共享内存\n \n参考文档\nhttps://www.neovasolutions.com/2022/05/19/browser-automation-tools-protocols-webdriver-vs-cdp/https://dev.to/jankaritech/different-approaches-protocols-to-automate-the-browser-39f1https://stackoverflow.com/questions/50939116/what-is-the-difference-between-webdriver-and-devtool-protocolhttps://zhuanlan.zhihu.com/p/76237595\n 关于博客这件事，我是把它当做我的笔记，里面有很多的内容反映了我思考的过程，因为思维有限，不免有些内容有出入，如果有问题，欢迎指出。一同探讨。谢谢。\n \n\n\n\n\n\n\n\n\n\n\n\n\n\n 确定要放弃本次机会？\n \n福利倒计时\n\n\n:\n\n:\n\n\n\n\n\n立减 ¥\n\n\n普通VIP年卡可用\n\n立即使用\n\n \n\n\n\n\n\n daliucheng\n \n\n\n\n关注\n关注\n\n\n\n\n\n\n\n\n\n\n 27\n \n\n点赞\n\n\n\n\n\n\n\n踩\n\n\n\n\n\n\n\n 21\n \n\n\n\n\n 收藏\n \n\n\n\n\n 觉得还不错?\n \n 一键收藏\n \n\n\n\n\n\n\n\n知道了\n\n\n\n\n 0\n \n\n评论\n\n\n\n\n\n\n\n\n\n\n\n\n\n CDP和Chrome\n \n\n WebDriver和是用于自动化浏览器的两个主要协议，大多数的浏览器自动化工具都是基于上述其中之一来实现的。可以通过这两种形式来和浏览器交互，通过代码来控制浏览器，完成浏览器的自动化行为（包括网页加载，爬虫，截图，导出pdf等）。\n \n复制链接\n\n\n\n扫一扫\n\n\n\n\n\n\n\n\n\n\n专栏目录\n\n\n\n\n\n\n\n \n\n\n\n\n\nPython cdp ( Chrome DevTools Protocol ) 爬虫\n\n\n\n\n墨鱼菜鸡\n\n\n07-11\n\n\t\t\t\t\t3265\n\t\t\t\t\t\n\n\n\n\n\ndevtools-protocol：https://github.com/ChromeDevTools/devtools-protocol Chrome DevTools Protocol：https://chromedevtools.github.io/devtools-protocol/ Awesome Chrome DevTools ：https:...\n\n\n\n\n\n\n\n\n\n\n\n\nChrome DevTools Protocol(谷歌开发者工具协议)Protocol Monitor（协议监视器）\n\n\n\n\nllrraa2010的专栏\n\n\n06-10\n\n\t\t\t\t\t2633\n\t\t\t\t\t\n\n\n\n\n\n该协议最初是由谷歌开发者工具团队维护的，负责调试、操作浏览器的协议。我们经常使用到的谷歌浏览器的开发者工具（快捷键 CTRL + SHIFT + I 或者 F12）就是使用这个协议来操作浏览器的。与 Selenium 需要与浏览器驱动进行交互不同的是，Chrome DevTools 协议直接通过 Web Socket 协议与浏览器暴露的 API 进行通信，这使得 Chrome DevTools 协议操作浏览器变得更快。我们要重启开发者工具，在右侧点击更多工具，这样就可以看到协议监视器面板了。\n\n\n\n\n\n\n\n\n参与评论\n您还未登录，请先\n登录\n后发表或查看评论\n\n\n\n\n\n\n\n\n\n探索Web开发新维度：Devtools-Protocol\n最新发布\n\n\n\n\ngitblog_00001的博客\n\n\n05-15\n\n\t\t\t\t\t353\n\t\t\t\t\t\n\n\n\n\n\n探索Web开发新维度：Devtools-Protocol\n项目地址:https://gitcode.com/ChromeDevTools/devtools-protocol\n项目介绍\n在Web开发的世界中，Chrome DevTools Protocol（DTP）是连接开发者和浏览器内核的桥梁，它允许我们进行深度的调试、性能分析以及自动化测试。而devtools-protocol是一个官方维护的开...\n\n\n\n\n\n\n\n\n\nusus使用Chrome调试协议CDP渲染页面\n\n\n\n\n08-08\n\n\n\n\n\nusus 使用Chrome调试协议（CDP）渲染页面。 提取用于渲染页面的CSS。 渲染带有阻塞CSS的HTML异步。\n\n\n\n\n\n\n\n\n\n\n\n浏览器自动化必须知道CDP协议\n\n\n\n\n白天安全建设，晚上全栈开发，大模型爱好者。公众号：飞羽技术工坊。\n\n\n01-13\n\n\t\t\t\t\t1067\n\t\t\t\t\t\n\n\n\n\n\n之前搞自动化页面，因为有一个获取网络日志的需求，让我发现了新的知识盲区——CDP协议。\n\n\n\n\n\n\n\n\n\nChrome DevTools 通过 cdp 调节 CPU Throttling\n\n\n\n\n时丶光\n\n\n11-26\n\n\t\t\t\t\t927\n\t\t\t\t\t\n\n\n\n\n\n打开DevTools (快捷键ctrl + shift + i)\n\n在DevTools 界面再打开DevTools\n\n\n\n\nlet Main = await import('./devtools-frontend/front_end/entrypoints/main/main.js'); // or './entrypoints/main/main.js' or './main/main.js' depending on the browser version\n\n//设置CPU Throttling 为本机\n\n\n\n\n\n\n\n\n\ncdp:软件包cdp为使用Go编程语言编写的Chrome DevTools协议（CDP）提供了类型安全的绑定\n\n\n\n\n05-04\n\n\n\n\n\n光盘\n 软件包cdp为使用Go编程语言编写的（CDP）提供了类型安全的绑定。 绑定是由根据最新协议定义生成的，并且主要用于Google Chrome或Chromium，但是它们可以与任何调试目标（ ， ， 等）。\n 通过Chrome DevTools协议，该软件包可用于任何类型的浏览器自动化，脚本编写或调试。\n cdp主要动机是公开Chrome DevTools协议的全部功能，并以一种可发现的自记录方式提供它。\n 提供高级浏览器自动化对于该项目而言是不可行的。 话虽如此， cdp希望通过提供更适合Go的原语并自动执行重复性任务来改善使用该协议的人体工程学。\n特征\n适用于Chrome DevTools协议的可发现API（GoDoc，自动完成友好）\n 作为头等公民的情况（用于超时和取消）\n 简单且同步的事件处理（无回调）\n 同时安全\n没有无声或隐藏的错误\n做到用户期望的\n尽可能将CDP类型与\n\n\n\n\n\n\n\n\n\nichrome：适用于人类的Chrome控制器，基于Chrome Devtools协议（CDP）和python3.7 +\n\n\n\n\n01-31\n\n\n\n\n\n适用于人类的Chrome控制器，基于和python3.7 +。为什么？ Pyppeteer很棒，但是我不需要那么多pyppeteer的拼写很混乱事件驱动的编程并非总是明智的。 Selenium慢网络驱动程序经常带有内存泄漏。 迫切需要一个稳定的...\n\n\n\n\n\n\n\n\n\nselenium_cdp：Selenium 4x，执行Chrome DevTools协议命令\n\n\n\n\n01-31\n\n\n\n\n\n该项目采用Java Selenium 4.0.x版本的来执行（也称为cdp命令），这是一套完全不同的API，通过对/session/$sessionId/goog/cdp/execute POST POST 传达给Chrome浏览器系列，特定的有效负载）功能（许多cdp方法，例如...\n\n\n\n\n\n\n\n\n\ncdp4j：cdp4j-适用于Java的Chrome DevTools协议\n\n\n\n\n01-28\n\n\n\n\n\ncdp4j是Java库，具有清晰简洁的API，可自动执行基于Chrome / Chromium的浏览器。 它使用Google Chrome DevTools协议来自动化基于Chrome / Chromium的浏览器。 cdp4j可以做什么？ 自动填写表格。 您可以轻松下载和...\n\n\n\n\n\n\n\n\n\ngetting-started-with-cdp:Chrome DevTools 协议入门\n\n\n\n\n07-24\n\n\n\n\n\n使用 Chrome DevTools 协议在直接使用 CDP 进行浏览器自动化之前要三思。 有会让你过得更好不服气？ 至少使用 。 另请参阅介绍注意： ://vanilla.aslushnikov.com 提供了交互式协议查看器。 Chrome DevTools 协议...\n\n\n\n\n\n\n\n\n\nChrome之远程调试协议（Remote debugging protocol） - Div.IO\n\n\n\n\nweixin_33940102的博客\n\n\n06-27\n\n\t\t\t\t\t1781\n\t\t\t\t\t\n\n\n\n\n\nChrome之远程调试协议（Remote debugging protocol） - Div.IO\n\n\n\n\n\n\n\n\n\n一文读懂UI自动化测试三种核心实现原理：Native、Webdriver和CDP\n\n\n\n\nliwenxiang629的博客\n\n\n04-03\n\n\t\t\t\t\t808\n\t\t\t\t\t\n\n\n\n\n\n相信80%的UI自动化测试工程师在进行岗位面试的时候都会重点讲解自己会使用哪些工具，例如cypress 、selenium 、playwright等等。其实这只是初级段位，如果大家想谈得再高大上一些，就可以谈谈这些工具与浏览器talk的原理了，绝对会得到面试官的重视！目前主流主动化测试工具与浏览器沟通的原理主要包括：Native、Webdriver以及CDP，使用这三种方式的典型代表工具分别是：cypress 、selenium 和playwright。今天我就对此进行总结：\n\n\n\n\n\n\n\n\n\n朋友们，一起学习下 Chrome DevTools Protocol。\n\n\n\n\nz_l_x_的博客\n\n\n10-18\n\n\t\t\t\t\t3072\n\t\t\t\t\t\n\n\n\n\n\n1947 年 9 月 9 日，First actual case of bug being found，自此引入了 Debugging。\n\n\n\n\n\n\n\n\n\nCDP 远程调试方案\n\n\n\n\n老司机的后备箱\n\n\n05-23\n\n\t\t\t\t\t3656\n\t\t\t\t\t\n\n\n\n\n\n什么是 cdp 协议\ncdp 协议简称 chrome 调试协议，是基于 scoket（websocket、usb、adb ）消息的 json rpc 协议。用来调用 chrome 内部的方法实现 js，css ，dom 的开发调试。 可以将 实现了 cdp 协议的应用 看做 rpc 调用的服务端（ chrome ，puppeteer）， 将调试面板看做 rpc 调用的客户端（devtools）。\ndevtools 调试系统\n完整的调试系统分别由前端，后端，协议，通道四部分组成\n\nFrontend：调试器前端\n\n\n\n\n\n\n\n\n\nGo Chromedp库得使用----CDP（Chrome DevTools Protocol)\n\n\n\n\n路小白的博客\n\n\n12-24\n\n\t\t\t\t\t8813\n\t\t\t\t\t\n\n\n\n\n\nGo chromedp库的使用 —CDP\n文章目录Go chromedp库的使用 ---CDPCDP（Chrome DevTools Protocol)基于CDP协议的相关语言操作Chromedp使用示例本地界面浏览器操作远程操作示例（无头浏览器）Centos 安装chronium-headless示例代码Browsesrless/chrome部署Linux-Centos安装NodeJS参考\nCDP（Chrome DevTools Protocol)\nChrome DevTools Protocol 是基.\n\n\n\n\n\n\n\n\n\n【学习笔记】selenium ChromeDriver 移除navigator.webdriver属性\n\n\n\n\nMONKEYMONEY_的博客\n\n\n12-16\n\n\t\t\t\t\t906\n\t\t\t\t\t\n\n\n\n\n\n作为新手的我，\n在刚接触selenium时不了解的\nChrome Driver 一些常用属性和方法。\n为此特意记录了以下几项并加上注释，方便以后查阅调用。\n\n\n \nSelenium中的ChromeOptions选项\n\n\nchromeOptions是一个配置chrome启动属性的类。通过这个类，我们可以为chrome配置如下参数（这个部分可以通过selenium源码看到）：\n\n设置 chrome 二进制文件位置 (binary_location)\n添加启动参数 (add_argument)\n添加扩展应用 (a\n\n\n\n\n\n\n\n\n\nChrome DevTools Protocol localstorage\n\n\n\n\n06-07"
}
[chain/end] [chain:RunnableSequence > prompt:ChatPromptTemplate] [1ms] Exiting Prompt run with output:
[outputs]
[chain/start] [chain:RunnableSequence > prompt:ChatPromptTemplate] Entering Prompt run with input:
{
"doc": "设置 chrome 二进制文件位置 (binary_location)\n添加启动参数 (add_argument)\n添加扩展应用 (a\n\n\n\n\n\n\n\n\n\nChrome DevTools Protocol localstorage\n\n\n\n\n06-07\n\n\n\n\n\nChrome DevTools Protocol 可以通过 `Runtime.evaluate()` 方法来读取和修改本地存储 (`localStorage`) 的值。以下是一个使用 Node.js 和 `chrome-remote-interface` 模块与 Chrome DevTools Protocol 交互的例子：\n\n```javascript\nconst CDP = require('chrome-remote-interface');\n\nCDP(async function(client) {\n const { Runtime } = client;\n await Runtime.enable();\n\n // 读取 localStorage 中的值\n const { result } = await Runtime.evaluate({\n expression: 'localStorage.getItem(\"key\")'\n });\n console.log(result.value);\n\n // 设置 localStorage 中的值\n await Runtime.evaluate({\n expression: 'localStorage.setItem(\"key\", \"value\")'\n });\n\n client.close();\n}).on('error', (err) => {\n console.error('Cannot connect to browser:', err);\n});\n```\n\n需要注意的是，这个例子只是一个简单的示例，并没有对错误处理进行详细的说明。在实际使用中，需要对错误进行适当的处理，以确保程序的稳定性和可靠性。\n\n\n\n\n\n\n“相关推荐”对你有帮助么？\n\n\n\n\n\n\n\n非常没帮助\n\n\n\n\n\n\n没帮助\n\n\n\n\n\n\n一般\n\n\n\n\n\n\n有帮助\n\n\n\n\n\n\n非常有帮助\n\n\n\n\n\n提交\n\n\n\n\n\n \n\n\n\n\n\n\n\n\n\n\n\ndaliucheng\n\n\n\n\nCSDN认证博客专家\n\n\nCSDN认证企业博客\n\n\n\n码龄7年\n\n\n\n 暂无认证\n \n\n\n\n\n\n\n\n151\n原创\n\n\n\n\n4万+\n周排名\n\n\n\n\n4万+\n总排名\n\n\n\n17万+\n访问\n\n\n\n\n\n\n等级\n\n\n\n\n\n2170\n积分\n\n\n303\n粉丝\n\n\n287\n获赞\n\n\n51\n评论\n\n\n709\n收藏\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n私信\n\n\n关注\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n热门文章\n\n\n\n\n\t\t\t\tSpring 定时任务@EnableScheduling解析\n\t\t\t\t\t\n27879\n\n\n\n\n\t\t\t\t数据库——求候选键的方法\n\t\t\t\t\t\n16022\n\n\n\n\n\t\t\t\t数据库——求候选键的方法\n\t\t\t\t\t\n14297\n\n\n\n\n\t\t\t\tSpring-动态数据源\n\t\t\t\t\t\n6182\n\n\n\n\n\t\t\t\tMybatis中mapper是怎么和XMl关联起来的\n\t\t\t\t\t\n5361\n\n\n\n\n\n\n分类专栏\n\n\n\n\n\n\n\n 自动化测试\n \n\n1篇\n\n\n\n\n\n\n go语言\n \n\n21篇\n\n\n\n\n\n\n springData MongoDB\n \n\n4篇\n\n\n\n\n\n\n spring\n \n\n26篇\n\n\n\n\n\n\n Springmvc\n \n\n4篇\n\n\n\n\n\n\n mybaties\n \n\n11篇\n\n\n\n\n\n\n LeetCode算法\n \n\n2篇\n\n\n\n\n\n\n Java并发\n \n\n18篇\n\n\n\n\n\n\n netty\n \n\n2篇\n\n\n\n\n\n\n 安全框架\n \n\n2篇\n\n\n\n\n\n\n 大数据\n \n\n2篇\n\n\n\n\n\n\n 流程引擎 activiti\n \n\n4篇\n\n\n\n\n\n\n hadoop\n \n\n\n\n\n\n\n\n hibernate\n \n\n\n\n\n\n\n\n android\n \n\n1篇\n\n\n\n\n\n\n 数据结构\n \n\n11篇\n\n\n\n\n\n\n 数据库\n \n\n6篇\n\n\n\n\n\n\n java基础\n \n\n12篇\n\n\n\n\n\n\n\n\n最新评论\n\n\n\nspring——Java Proxy和Cglib两种方式方法嵌套调用时代理对象行为分析\n\nHuunnnn: \n所以说网上总是说自调用失效是因为spring默认用的代理模式是java的动态代理 如果改配置让代理模式强制改为cglib的代理模式 这样自调用时的aop注解就不会失效了吧\n\n\n\nGO-日志分析\n\n白话机器学习: \n内容丰富图文并茂，认真看完收获很大。思路清晰细节满满，支持大佬优质好文。\n\n\n\nSpring——创建代理对象-Java Proxy方法分析（JdkDynamicAopProxy）\n\nwei青青: \nTestProxyFactory main方法中的T Do 这两个类的定义能放下代码吗？\n\n\n\nTreeMap分析\n\ndaliucheng: \n欢迎交流\n\n\n\nTreeMap分析\n\n杨思默: \n博主总结很详细啊。\n\n\n\n\n\n\n大家在看\n\n\n\n\n\t\t\t\t从零开始学习嵌入式——C语言数值传递（值传递和地址传递）\n \n\n\n\n\t\t\t\tue4----------理论（4.PBR)\n\t\t\t\t\t\n330\n\n\n\n\n\t\t\t\tAiax应用 get请求 post请求 json数据请求\n\t\t\t\t\t\n447\n\n\n\n\n\t\t\t\t帮自己了解疾病症状的健康APP，平时可以不用，关键时候必须要有！\n\t\t\t\t\t\n305\n\n\n\n\n\t\t\t\t椭流线法设计配光器\n\t\t\t\t\t\n558\n\n\n\n\n\n\n最新文章\n\n\n\nGO-日志分析\n\n\nGo 异步任务\n\n\nDubbogo 详解\n\n\n\n\n2024年1篇\n2023年15篇\n2022年24篇\n2021年44篇\n2020年26篇\n2019年19篇\n2018年20篇\n2017年2篇\n\n\n\n\n\n\n\n\n\n\n\n\n目录\n\n\n\n\n\n\n\n\n\n\n\n\n \n\n\n\n\n\n\n\n\n目录\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n分类专栏\n\n\n\n\n\n\n\n\n 自动化测试\n \n\n1篇\n\n\n\n\n\n\n go语言\n \n\n21篇\n\n\n\n\n\n\n springData MongoDB\n \n\n4篇\n\n\n\n\n\n\n spring\n \n\n26篇\n\n\n\n\n\n\n Springmvc\n \n\n4篇\n\n\n\n\n\n\n mybaties\n \n\n11篇\n\n\n\n\n\n\n LeetCode算法\n \n\n2篇\n\n\n\n\n\n\n Java并发\n \n\n18篇\n\n\n\n\n\n\n netty\n \n\n2篇\n\n\n\n\n\n\n 安全框架\n \n\n2篇\n\n\n\n\n\n\n 大数据\n \n\n2篇\n\n\n\n\n\n\n 流程引擎 activiti\n \n\n4篇\n\n\n\n\n\n\n hadoop\n \n\n\n\n\n\n\n\n hibernate\n \n\n\n\n\n\n\n\n android\n \n\n1篇\n\n\n\n\n\n\n 数据结构\n \n\n11篇\n\n\n\n\n\n\n 数据库\n \n\n6篇\n\n\n\n\n\n\n java基础\n \n\n12篇\n\n\n\n\n\n\n\n\n\n\n\n\n\n目录\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n评论\n\n\n\n\n被折叠的 条评论\n\t\t 为什么被折叠?\n\n到【灌水乐园】发言\n\n\n\n查看更多评论\n\n\n\n\n\n\n 添加红包\n \n\n\n\n祝福语\n\n\n\n\n请填写红包祝福语或标题\n\n\n红包数量\n\n\n个\n\n红包个数最小为10个\n\n\n红包总金额\n\n\n元\n\n红包金额最低5元\n\n\n余额支付\n\n 当前余额3.43元\n 前往充值 >\n\n\n\n\n 需支付：10.00元\n \n取消\n确定\n\n\n\n\n\n\n\n下一步\n\n\n\n知道了\n\n\n\n\n\n\n\n\n\n\n成就一亿技术人!\n\n\n\n\n\n\n 领取后你会自动成为博主和红包主的粉丝\n 规则\n\n\n\n\n\n\n\n\n\n\nhope_wisdom 发出的红包\n \n\n\n\n\n\n\n\n\n\n\n\n\n\n实付元\n使用余额支付\n\n\n\n\n点击重新获取\n\n\n扫码支付\n\n\n\n\n\n\n\n\n\n\n\n钱包余额\n0\n\n\n\n\n抵扣说明：\n 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。\n\n\n\n\n余额充值"
}
[chain/end] [chain:RunnableSequence > prompt:ChatPromptTemplate] [1ms] Exiting Prompt run with output:
[outputs]
[llm/start] [chain:RunnableSequence > llm:ChatOpenAI] Entering LLM run with input:
{
"prompts": [
"Human: 生成一个包含3个假设性问题的列表，中文回答，这些问题可以通过下面的文档来回答：\n\nCDP和Chrome_chrome devtools protocol-CSDN博客\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nCDP和Chrome\n\n\n\n\n\ndaliucheng\n\n已于 2024-02-19 00:07:33 修改\n\n\n阅读量1.7k\n\n\n\n收藏\n\n 21\n \n\n\n\n\n点赞数\n 27\n \n\n\n\n\n\n\n分类专栏：\n自动化测试\n文章标签：\nchrome\n自动化\npython\nnode.js\n\n\n于 2024-02-18 23:45:32 首次发布\n\n\n\n 版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。\n \n\n 本文链接：https://blog.csdn.net/daliucheng/article/details/136160807\n\n\n\n\n版权\n\n\n\n\n\n\n\n\n\n\n\n\n\n自动化测试\n专栏收录该内容\n\n\n\n\n\n1 篇文章\n0 订阅\n\n\n订阅专栏\n\n\n\n\n\n\n\n\n\n\n\n\nCDP和Chrome\nCDP和WebDriver Protocol\nWebDriver和 Chrome DevTools Protocol（CDP） 是用于自动化浏览器的两个主要协议，大多数的浏览器自动化工具都是基于上述其中之一来实现的。可以通过这两种形式来和浏览器交互，通过代码来控制浏览器，完成浏览器的自动化行为（包括网页加载，爬虫，截图，导出pdf等）。\nWebDriver Protocol\n官网地址：链接\nWebDriver 是一个用于控制浏览器的远程控制接口，由 Selenium HQ 开发，后来由 W3C 标准化。它提供了一个平台和语言中立的接口，支持几乎所有主流浏览器，如 Chrome、 Firefox、 Safari、 Edge、 Opera 等。\n它和浏览器的通信是通过 JSON Wire 协议完成的，提供了RESTful的web服务，这个服务端就被称为服务端（也被称为webdriver），例如chromeDriver、geckoDriver等。\n有服务端就有客户端，客户端可以选择任何语言，客户端和服务端交互，服务端和浏览器交互，从而操作浏览器。常见的客户端就是selenium,nightwatch,webdriverio \n加上我们的自己写的自动化测试代码之后，交互流程如下：\n\nChrome DevTools Protocol\n官网地址：链接\nChromeDevTools Protocol (CDP)是一个基于 Chromium 的浏览器的调试协议，如 Chrome、 Edge、 Opera 等。通过它可以直接和浏览器交互。控制浏览器的行为。\n客户端和浏览器之间没有类似于WebDriver Protocol的服务端（webdriver），而是客户端通过WebSocket直接和浏览器连\n类似网络驱动服务器(浏览器驱动程序)的中间人。相反，浏览器是由客户端使用 CDP 直接控制的。与浏览器的通信是通过套接字连接完成的，因此也支持双向通信。客户端通过WebSocket发送命令给浏览器，浏览器执行并返回响应。\n\n两个相当流行的工具是Puppeteer和Playwright。它们不依赖于webdriver，而是通过 Chrome DevTools Protocol (CDP)直接与浏览器通话。从而更加灵活稳定的控制浏览器。\n区别\n从代码层面来看，使用的代码接近底层，接近浏览器，代码就会变得更加的稳定和强大，但对于跨浏览器的支持会变得更少。另一方面，代码和浏览器的之间的抽象程度越高，支持的浏览器就越多，但代码会变得不稳定并且功能受限。\n对比上面两种\n WebDriver Protocol 支持的浏览器多，但不是很稳定，并且功能不强大。 Chrome DevTools Protocol 支持的浏览器少（只是相对WebDriver来说，Chrome能支持就能用），功能强大，稳定。 \nWebdriver ProtocolChrome DevTools ProtocolDeveloped by: W3CDeveloped by: Chrome Developer Tools需要webdriver不需要webdriver相对较慢并且不是很稳定速度快，较稳定支持的浏览器多支持部分浏览器无法通过提供的api来访问浏览器中网络相关的信息可以通过api来访问网络相关的信息它的实现有：Selenium WebDriver 3, WebdriverIO, Nightwatch它的实现有：Playwright, Puppeteer, Selenium Webdriver 4, Cypress v7\n不同的WebDriver有不同的实现方式，chromeDriver内部是通过DevTools protoco来控制浏览器的。\n如何选择\n如果跨浏览器很重要，就选webDriver，否则选择CDP\npuppeteer\n链接：官网，github，github-examples\nPuppeteer 是 Chrome 开发团队在 2017 年发布的一个 Node.js 包，是它提供了一个高级 API，通过 DevTools 协议控制 Chrome/Chromium。\n为什么选择它？\n两个理由\ngithub中star数多Chrome开发团队\n可以做什么？\n简单来说，浏览器能做的，它都能做\n截图和生成PDF爬取 SPA 或 SSR 网站UI 自动化测试…\n版本说明\n从v1.7.0 版本以来，每次发布都会发布两个软件包：\n puppeteer\n\n它会自动下载一个最新版本的 Chrome 用于测试（macOS 约 170MB，Linux 约 282MB，Windows 约 280MB）以及一个 chrome-headless-shell 二进制文件（从 Puppeteer v21.6.0 开始），这个二进制文件保证可以与 Puppeteer 配合正常工作。默认情况下，浏览器会下载到 $HOME/.cache/puppeteer 文件夹中（从 Puppeteer v19.0.0 开始）。\n通过puppeteer-core 控制它下载的浏览器\n puppeteer-core\n\npuppeteer-core 是一个库，用于帮助驱动任何支持 DevTools 协议的内容。\n它不会下载浏览器，它提供了封装好的API和浏览器交互。\n如果自己已经下载了浏览器，就可以使用它，但是必须在调用puppeteer.launch的时候显式的指定executablePath(浏览器的执行位置)\n 一般来说我会使用这个 \n代码\n建议看这篇文章 结合项目来谈谈 Puppeteer 在结合 github-examples的例子。\n注意点\n 在部署的时候，建议使用容器化，Chrome本身是内存大户，如果遇到内存飙升，代码是不太好发现这种情况的，不能及时kill掉。 在加载网页的时候不建议每次都关闭和开启一个新的。 Chrome的启动和关系是比较耗时的，每次启动会慢150ms到300ms 建议重复使用同一个Chrome。 Chrome使用一段时间之后，要关掉重启。 Chrome在我们自己的电脑中有的时候，页面都会崩溃，浏览器也会崩溃。在服务器这种情况下，肯定也会出现，建议在内存中设置调用阈值，比如加载了100个网页，重启一次。这样可降低崩溃的概率。 容器化部署之后，建议一个容器中只启动一个Chrome。 这样会让代码简单并且出现问题好排查。这就要求Chrome在代码中是单例 在整个Chrome做操作期间，对Chrome崩溃的情况做处理 在业务代码期间，建议使用try catch 来捕获异常，对于非业务异常，需要关闭掉Chrome。防止出现多个Chrome。 Chrome在关闭的时候出现异常，也需要处理 在调用close()api来关闭Chrome的时候，可能会报错（可能Chrome在这个时候被操作系统kill掉，会出现孤儿进程）。 建议：在这个时候直接通过shell脚本来强行kill掉 #!/bin/bash\n\npids=$(ps -ef | grep \"[c]hrome\" | grep -v 'kill_chrome_processes.sh' |awk '{print $2}')\n\nfor pid in $pids; do\n echo \"Terminating PID $pid\"\n kill $pid\ndone\n\necho \"All chrome processes have been terminated.\"\n\n\n孤儿进程：\n父进程启动了子进程，子进程在没有退出的情况下，父进程退出了。此时子进程会被init进程接管。\n 尽量关闭掉无用的功能，让他越简单越好。 比如：-no-sandbox,--disable-extensions,--disable-gpu,--disable_scrollbars 共享内存\n\nChrome 默认使用 /dev/shm 共享内存，但是 docker 默认/dev/shm 只有64MB，显然是不够使用的，提供两种方式来解决：\n启动 docker 时添加参数 --shm-size=1gb 来增大 /dev/shm 共享内存，但是 swarm 目前不支持 shm-size 参数启动 Chrome 添加参数 - disable-dev-shm-usage，禁止使用 /dev/shm 共享内存\n \n参考文档\nhttps://www.neovasolutions.com/2022/05/19/browser-automation-tools-protocols-webdriver-vs-cdp/https://dev.to/jankaritech/different-approaches-protocols-to-automate-the-browser-39f1https://stackoverflow.com/questions/50939116/what-is-the-difference-between-webdriver-and-devtool-protocolhttps://zhuanlan.zhihu.com/p/76237595\n 关于博客这件事，我是把它当做我的笔记，里面有很多的内容反映了我思考的过程，因为思维有限，不免有些内容有出入，如果有问题，欢迎指出。一同探讨。谢谢。\n \n\n\n\n\n\n\n\n\n\n\n\n\n\n 确定要放弃本次机会？\n \n福利倒计时\n\n\n:\n\n:\n\n\n\n\n\n立减 ¥\n\n\n普通VIP年卡可用\n\n立即使用\n\n \n\n\n\n\n\n daliucheng\n \n\n\n\n关注\n关注\n\n\n\n\n\n\n\n\n\n\n 27\n \n\n点赞\n\n\n\n\n\n\n\n踩\n\n\n\n\n\n\n\n 21\n \n\n\n\n\n 收藏\n \n\n\n\n\n 觉得还不错?\n \n 一键收藏\n \n\n\n\n\n\n\n\n知道了\n\n\n\n\n 0\n \n\n评论\n\n\n\n\n\n\n\n\n\n\n\n\n\n CDP和Chrome\n \n\n WebDriver和是用于自动化浏览器的两个主要协议，大多数的浏览器自动化工具都是基于上述其中之一来实现的。可以通过这两种形式来和浏览器交互，通过代码来控制浏览器，完成浏览器的自动化行为（包括网页加载，爬虫，截图，导出pdf等）。\n \n复制链接\n\n\n\n扫一扫\n\n\n\n\n\n\n\n\n\n\n专栏目录\n\n\n\n\n\n\n\n \n\n\n\n\n\nPython cdp ( Chrome DevTools Protocol ) 爬虫\n\n\n\n\n墨鱼菜鸡\n\n\n07-11\n\n\t\t\t\t\t3265\n\t\t\t\t\t\n\n\n\n\n\ndevtools-protocol：https://github.com/ChromeDevTools/devtools-protocol Chrome DevTools Protocol：https://chromedevtools.github.io/devtools-protocol/ Awesome Chrome DevTools ：https:...\n\n\n\n\n\n\n\n\n\n\n\n\nChrome DevTools Protocol(谷歌开发者工具协议)Protocol Monitor（协议监视器）\n\n\n\n\nllrraa2010的专栏\n\n\n06-10\n\n\t\t\t\t\t2633\n\t\t\t\t\t\n\n\n\n\n\n该协议最初是由谷歌开发者工具团队维护的，负责调试、操作浏览器的协议。我们经常使用到的谷歌浏览器的开发者工具（快捷键 CTRL + SHIFT + I 或者 F12）就是使用这个协议来操作浏览器的。与 Selenium 需要与浏览器驱动进行交互不同的是，Chrome DevTools 协议直接通过 Web Socket 协议与浏览器暴露的 API 进行通信，这使得 Chrome DevTools 协议操作浏览器变得更快。我们要重启开发者工具，在右侧点击更多工具，这样就可以看到协议监视器面板了。\n\n\n\n\n\n\n\n\n参与评论\n您还未登录，请先\n登录\n后发表或查看评论\n\n\n\n\n\n\n\n\n\n探索Web开发新维度：Devtools-Protocol\n最新发布\n\n\n\n\ngitblog_00001的博客\n\n\n05-15\n\n\t\t\t\t\t353\n\t\t\t\t\t\n\n\n\n\n\n探索Web开发新维度：Devtools-Protocol\n项目地址:https://gitcode.com/ChromeDevTools/devtools-protocol\n项目介绍\n在Web开发的世界中，Chrome DevTools Protocol（DTP）是连接开发者和浏览器内核的桥梁，它允许我们进行深度的调试、性能分析以及自动化测试。而devtools-protocol是一个官方维护的开...\n\n\n\n\n\n\n\n\n\nusus使用Chrome调试协议CDP渲染页面\n\n\n\n\n08-08\n\n\n\n\n\nusus 使用Chrome调试协议（CDP）渲染页面。 提取用于渲染页面的CSS。 渲染带有阻塞CSS的HTML异步。\n\n\n\n\n\n\n\n\n\n\n\n浏览器自动化必须知道CDP协议\n\n\n\n\n白天安全建设，晚上全栈开发，大模型爱好者。公众号：飞羽技术工坊。\n\n\n01-13\n\n\t\t\t\t\t1067\n\t\t\t\t\t\n\n\n\n\n\n之前搞自动化页面，因为有一个获取网络日志的需求，让我发现了新的知识盲区——CDP协议。\n\n\n\n\n\n\n\n\n\nChrome DevTools 通过 cdp 调节 CPU Throttling\n\n\n\n\n时丶光\n\n\n11-26\n\n\t\t\t\t\t927\n\t\t\t\t\t\n\n\n\n\n\n打开DevTools (快捷键ctrl + shift + i)\n\n在DevTools 界面再打开DevTools\n\n\n\n\nlet Main = await import('./devtools-frontend/front_end/entrypoints/main/main.js'); // or './entrypoints/main/main.js' or './main/main.js' depending on the browser version\n\n//设置CPU Throttling 为本机\n\n\n\n\n\n\n\n\n\ncdp:软件包cdp为使用Go编程语言编写的Chrome DevTools协议（CDP）提供了类型安全的绑定\n\n\n\n\n05-04\n\n\n\n\n\n光盘\n 软件包cdp为使用Go编程语言编写的（CDP）提供了类型安全的绑定。 绑定是由根据最新协议定义生成的，并且主要用于Google Chrome或Chromium，但是它们可以与任何调试目标（ ， ， 等）。\n 通过Chrome DevTools协议，该软件包可用于任何类型的浏览器自动化，脚本编写或调试。\n cdp主要动机是公开Chrome DevTools协议的全部功能，并以一种可发现的自记录方式提供它。\n 提供高级浏览器自动化对于该项目而言是不可行的。 话虽如此， cdp希望通过提供更适合Go的原语并自动执行重复性任务来改善使用该协议的人体工程学。\n特征\n适用于Chrome DevTools协议的可发现API（GoDoc，自动完成友好）\n 作为头等公民的情况（用于超时和取消）\n 简单且同步的事件处理（无回调）\n 同时安全\n没有无声或隐藏的错误\n做到用户期望的\n尽可能将CDP类型与\n\n\n\n\n\n\n\n\n\nichrome：适用于人类的Chrome控制器，基于Chrome Devtools协议（CDP）和python3.7 +\n\n\n\n\n01-31\n\n\n\n\n\n适用于人类的Chrome控制器，基于和python3.7 +。为什么？ Pyppeteer很棒，但是我不需要那么多pyppeteer的拼写很混乱事件驱动的编程并非总是明智的。 Selenium慢网络驱动程序经常带有内存泄漏。 迫切需要一个稳定的...\n\n\n\n\n\n\n\n\n\nselenium_cdp：Selenium 4x，执行Chrome DevTools协议命令\n\n\n\n\n01-31\n\n\n\n\n\n该项目采用Java Selenium 4.0.x版本的来执行（也称为cdp命令），这是一套完全不同的API，通过对/session/$sessionId/goog/cdp/execute POST POST 传达给Chrome浏览器系列，特定的有效负载）功能（许多cdp方法，例如...\n\n\n\n\n\n\n\n\n\ncdp4j：cdp4j-适用于Java的Chrome DevTools协议\n\n\n\n\n01-28\n\n\n\n\n\ncdp4j是Java库，具有清晰简洁的API，可自动执行基于Chrome / Chromium的浏览器。 它使用Google Chrome DevTools协议来自动化基于Chrome / Chromium的浏览器。 cdp4j可以做什么？ 自动填写表格。 您可以轻松下载和...\n\n\n\n\n\n\n\n\n\ngetting-started-with-cdp:Chrome DevTools 协议入门\n\n\n\n\n07-24\n\n\n\n\n\n使用 Chrome DevTools 协议在直接使用 CDP 进行浏览器自动化之前要三思。 有会让你过得更好不服气？ 至少使用 。 另请参阅介绍注意： ://vanilla.aslushnikov.com 提供了交互式协议查看器。 Chrome DevTools 协议...\n\n\n\n\n\n\n\n\n\nChrome之远程调试协议（Remote debugging protocol） - Div.IO\n\n\n\n\nweixin_33940102的博客\n\n\n06-27\n\n\t\t\t\t\t1781\n\t\t\t\t\t\n\n\n\n\n\nChrome之远程调试协议（Remote debugging protocol） - Div.IO\n\n\n\n\n\n\n\n\n\n一文读懂UI自动化测试三种核心实现原理：Native、Webdriver和CDP\n\n\n\n\nliwenxiang629的博客\n\n\n04-03\n\n\t\t\t\t\t808\n\t\t\t\t\t\n\n\n\n\n\n相信80%的UI自动化测试工程师在进行岗位面试的时候都会重点讲解自己会使用哪些工具，例如cypress 、selenium 、playwright等等。其实这只是初级段位，如果大家想谈得再高大上一些，就可以谈谈这些工具与浏览器talk的原理了，绝对会得到面试官的重视！目前主流主动化测试工具与浏览器沟通的原理主要包括：Native、Webdriver以及CDP，使用这三种方式的典型代表工具分别是：cypress 、selenium 和playwright。今天我就对此进行总结：\n\n\n\n\n\n\n\n\n\n朋友们，一起学习下 Chrome DevTools Protocol。\n\n\n\n\nz_l_x_的博客\n\n\n10-18\n\n\t\t\t\t\t3072\n\t\t\t\t\t\n\n\n\n\n\n1947 年 9 月 9 日，First actual case of bug being found，自此引入了 Debugging。\n\n\n\n\n\n\n\n\n\nCDP 远程调试方案\n\n\n\n\n老司机的后备箱\n\n\n05-23\n\n\t\t\t\t\t3656\n\t\t\t\t\t\n\n\n\n\n\n什么是 cdp 协议\ncdp 协议简称 chrome 调试协议，是基于 scoket（websocket、usb、adb ）消息的 json rpc 协议。用来调用 chrome 内部的方法实现 js，css ，dom 的开发调试。 可以将 实现了 cdp 协议的应用 看做 rpc 调用的服务端（ chrome ，puppeteer）， 将调试面板看做 rpc 调用的客户端（devtools）。\ndevtools 调试系统\n完整的调试系统分别由前端，后端，协议，通道四部分组成\n\nFrontend：调试器前端\n\n\n\n\n\n\n\n\n\nGo Chromedp库得使用----CDP（Chrome DevTools Protocol)\n\n\n\n\n路小白的博客\n\n\n12-24\n\n\t\t\t\t\t8813\n\t\t\t\t\t\n\n\n\n\n\nGo chromedp库的使用 —CDP\n文章目录Go chromedp库的使用 ---CDPCDP（Chrome DevTools Protocol)基于CDP协议的相关语言操作Chromedp使用示例本地界面浏览器操作远程操作示例（无头浏览器）Centos 安装chronium-headless示例代码Browsesrless/chrome部署Linux-Centos安装NodeJS参考\nCDP（Chrome DevTools Protocol)\nChrome DevTools Protocol 是基.\n\n\n\n\n\n\n\n\n\n【学习笔记】selenium ChromeDriver 移除navigator.webdriver属性\n\n\n\n\nMONKEYMONEY_的博客\n\n\n12-16\n\n\t\t\t\t\t906\n\t\t\t\t\t\n\n\n\n\n\n作为新手的我，\n在刚接触selenium时不了解的\nChrome Driver 一些常用属性和方法。\n为此特意记录了以下几项并加上注释，方便以后查阅调用。\n\n\n \nSelenium中的ChromeOptions选项\n\n\nchromeOptions是一个配置chrome启动属性的类。通过这个类，我们可以为chrome配置如下参数（这个部分可以通过selenium源码看到）：\n\n设置 chrome 二进制文件位置 (binary_location)\n添加启动参数 (add_argument)\n添加扩展应用 (a\n\n\n\n\n\n\n\n\n\nChrome DevTools Protocol localstorage\n\n\n\n\n06-07"
]
}
[llm/start] [chain:RunnableSequence > llm:ChatOpenAI] Entering LLM run with input:
{
"prompts": [
"Human: 生成一个包含3个假设性问题的列表，中文回答，这些问题可以通过下面的文档来回答：\n\n设置 chrome 二进制文件位置 (binary_location)\n添加启动参数 (add_argument)\n添加扩展应用 (a\n\n\n\n\n\n\n\n\n\nChrome DevTools Protocol localstorage\n\n\n\n\n06-07\n\n\n\n\n\nChrome DevTools Protocol 可以通过 `Runtime.evaluate()` 方法来读取和修改本地存储 (`localStorage`) 的值。以下是一个使用 Node.js 和 `chrome-remote-interface` 模块与 Chrome DevTools Protocol 交互的例子：\n\n```javascript\nconst CDP = require('chrome-remote-interface');\n\nCDP(async function(client) {\n const { Runtime } = client;\n await Runtime.enable();\n\n // 读取 localStorage 中的值\n const { result } = await Runtime.evaluate({\n expression: 'localStorage.getItem(\"key\")'\n });\n console.log(result.value);\n\n // 设置 localStorage 中的值\n await Runtime.evaluate({\n expression: 'localStorage.setItem(\"key\", \"value\")'\n });\n\n client.close();\n}).on('error', (err) => {\n console.error('Cannot connect to browser:', err);\n});\n```\n\n需要注意的是，这个例子只是一个简单的示例，并没有对错误处理进行详细的说明。在实际使用中，需要对错误进行适当的处理，以确保程序的稳定性和可靠性。\n\n\n\n\n\n\n“相关推荐”对你有帮助么？\n\n\n\n\n\n\n\n非常没帮助\n\n\n\n\n\n\n没帮助\n\n\n\n\n\n\n一般\n\n\n\n\n\n\n有帮助\n\n\n\n\n\n\n非常有帮助\n\n\n\n\n\n提交\n\n\n\n\n\n \n\n\n\n\n\n\n\n\n\n\n\ndaliucheng\n\n\n\n\nCSDN认证博客专家\n\n\nCSDN认证企业博客\n\n\n\n码龄7年\n\n\n\n 暂无认证\n \n\n\n\n\n\n\n\n151\n原创\n\n\n\n\n4万+\n周排名\n\n\n\n\n4万+\n总排名\n\n\n\n17万+\n访问\n\n\n\n\n\n\n等级\n\n\n\n\n\n2170\n积分\n\n\n303\n粉丝\n\n\n287\n获赞\n\n\n51\n评论\n\n\n709\n收藏\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n私信\n\n\n关注\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n热门文章\n\n\n\n\n\t\t\t\tSpring 定时任务@EnableScheduling解析\n\t\t\t\t\t\n27879\n\n\n\n\n\t\t\t\t数据库——求候选键的方法\n\t\t\t\t\t\n16022\n\n\n\n\n\t\t\t\t数据库——求候选键的方法\n\t\t\t\t\t\n14297\n\n\n\n\n\t\t\t\tSpring-动态数据源\n\t\t\t\t\t\n6182\n\n\n\n\n\t\t\t\tMybatis中mapper是怎么和XMl关联起来的\n\t\t\t\t\t\n5361\n\n\n\n\n\n\n分类专栏\n\n\n\n\n\n\n\n 自动化测试\n \n\n1篇\n\n\n\n\n\n\n go语言\n \n\n21篇\n\n\n\n\n\n\n springData MongoDB\n \n\n4篇\n\n\n\n\n\n\n spring\n \n\n26篇\n\n\n\n\n\n\n Springmvc\n \n\n4篇\n\n\n\n\n\n\n mybaties\n \n\n11篇\n\n\n\n\n\n\n LeetCode算法\n \n\n2篇\n\n\n\n\n\n\n Java并发\n \n\n18篇\n\n\n\n\n\n\n netty\n \n\n2篇\n\n\n\n\n\n\n 安全框架\n \n\n2篇\n\n\n\n\n\n\n 大数据\n \n\n2篇\n\n\n\n\n\n\n 流程引擎 activiti\n \n\n4篇\n\n\n\n\n\n\n hadoop\n \n\n\n\n\n\n\n\n hibernate\n \n\n\n\n\n\n\n\n android\n \n\n1篇\n\n\n\n\n\n\n 数据结构\n \n\n11篇\n\n\n\n\n\n\n 数据库\n \n\n6篇\n\n\n\n\n\n\n java基础\n \n\n12篇\n\n\n\n\n\n\n\n\n最新评论\n\n\n\nspring——Java Proxy和Cglib两种方式方法嵌套调用时代理对象行为分析\n\nHuunnnn: \n所以说网上总是说自调用失效是因为spring默认用的代理模式是java的动态代理 如果改配置让代理模式强制改为cglib的代理模式 这样自调用时的aop注解就不会失效了吧\n\n\n\nGO-日志分析\n\n白话机器学习: \n内容丰富图文并茂，认真看完收获很大。思路清晰细节满满，支持大佬优质好文。\n\n\n\nSpring——创建代理对象-Java Proxy方法分析（JdkDynamicAopProxy）\n\nwei青青: \nTestProxyFactory main方法中的T Do 这两个类的定义能放下代码吗？\n\n\n\nTreeMap分析\n\ndaliucheng: \n欢迎交流\n\n\n\nTreeMap分析\n\n杨思默: \n博主总结很详细啊。\n\n\n\n\n\n\n大家在看\n\n\n\n\n\t\t\t\t从零开始学习嵌入式——C语言数值传递（值传递和地址传递）\n \n\n\n\n\t\t\t\tue4----------理论（4.PBR)\n\t\t\t\t\t\n330\n\n\n\n\n\t\t\t\tAiax应用 get请求 post请求 json数据请求\n\t\t\t\t\t\n447\n\n\n\n\n\t\t\t\t帮自己了解疾病症状的健康APP，平时可以不用，关键时候必须要有！\n\t\t\t\t\t\n305\n\n\n\n\n\t\t\t\t椭流线法设计配光器\n\t\t\t\t\t\n558\n\n\n\n\n\n\n最新文章\n\n\n\nGO-日志分析\n\n\nGo 异步任务\n\n\nDubbogo 详解\n\n\n\n\n2024年1篇\n2023年15篇\n2022年24篇\n2021年44篇\n2020年26篇\n2019年19篇\n2018年20篇\n2017年2篇\n\n\n\n\n\n\n\n\n\n\n\n\n目录\n\n\n\n\n\n\n\n\n\n\n\n\n \n\n\n\n\n\n\n\n\n目录\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n分类专栏\n\n\n\n\n\n\n\n\n 自动化测试\n \n\n1篇\n\n\n\n\n\n\n go语言\n \n\n21篇\n\n\n\n\n\n\n springData MongoDB\n \n\n4篇\n\n\n\n\n\n\n spring\n \n\n26篇\n\n\n\n\n\n\n Springmvc\n \n\n4篇\n\n\n\n\n\n\n mybaties\n \n\n11篇\n\n\n\n\n\n\n LeetCode算法\n \n\n2篇\n\n\n\n\n\n\n Java并发\n \n\n18篇\n\n\n\n\n\n\n netty\n \n\n2篇\n\n\n\n\n\n\n 安全框架\n \n\n2篇\n\n\n\n\n\n\n 大数据\n \n\n2篇\n\n\n\n\n\n\n 流程引擎 activiti\n \n\n4篇\n\n\n\n\n\n\n hadoop\n \n\n\n\n\n\n\n\n hibernate\n \n\n\n\n\n\n\n\n android\n \n\n1篇\n\n\n\n\n\n\n 数据结构\n \n\n11篇\n\n\n\n\n\n\n 数据库\n \n\n6篇\n\n\n\n\n\n\n java基础\n \n\n12篇\n\n\n\n\n\n\n\n\n\n\n\n\n\n目录\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n评论\n\n\n\n\n被折叠的 条评论\n\t\t 为什么被折叠?\n\n到【灌水乐园】发言\n\n\n\n查看更多评论\n\n\n\n\n\n\n 添加红包\n \n\n\n\n祝福语\n\n\n\n\n请填写红包祝福语或标题\n\n\n红包数量\n\n\n个\n\n红包个数最小为10个\n\n\n红包总金额\n\n\n元\n\n红包金额最低5元\n\n\n余额支付\n\n 当前余额3.43元\n 前往充值 >\n\n\n\n\n 需支付：10.00元\n \n取消\n确定\n\n\n\n\n\n\n\n下一步\n\n\n\n知道了\n\n\n\n\n\n\n\n\n\n\n成就一亿技术人!\n\n\n\n\n\n\n 领取后你会自动成为博主和红包主的粉丝\n 规则\n\n\n\n\n\n\n\n\n\n\nhope_wisdom 发出的红包\n \n\n\n\n\n\n\n\n\n\n\n\n\n\n实付元\n使用余额支付\n\n\n\n\n点击重新获取\n\n\n扫码支付\n\n\n\n\n\n\n\n\n\n\n\n钱包余额\n0\n\n\n\n\n抵扣说明：\n 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。\n\n\n\n\n余额充值"
]
}
[llm/end] [chain:RunnableSequence > llm:ChatOpenAI] [4.65s] Exiting LLM run with output:
{
"generations": [
[
{
"text": "",
"generation_info": {
"finish_reason": "stop",
"logprobs": null
},
"type": "ChatGeneration",
"message": {
"lc": 1,
"type": "constructor",
"id": [
"langchain",
"schema",
"messages",
"AIMessage"
],
"kwargs": {
"content": "",
"additional_kwargs": {
"function_call": {
"arguments": "{\n \"questions\": [\n \"如何在chrome中设置二进制文件的位置？\",\n \"如何在chrome中添加启动参数？\",\n \"如何在chrome中添加扩展应用？\"\n ]\n}",
"name": "hypothetical_questions"
}
},
"response_metadata": {
"token_usage": {
"completion_tokens": 53,
"prompt_tokens": 1853,
"total_tokens": 1906
},
"model_name": "gpt-4-0613",
"system_fingerprint": null,
"finish_reason": "stop",
"logprobs": null
},
"type": "ai",
"id": "run-961acbfa-187f-446c-bd3f-8ed18c8c8bb4-0",
"usage_metadata": {
"input_tokens": 1853,
"output_tokens": 53,
"total_tokens": 1906
},
"tool_calls": [],
"invalid_tool_calls": []
}
}
}
]
],
"llm_output": {
"token_usage": {
"completion_tokens": 53,
"prompt_tokens": 1853,
"total_tokens": 1906
},
"model_name": "gpt-4-0613",
"system_fingerprint": null
},
"run": null
}
[llm/end] [chain:RunnableSequence > llm:ChatOpenAI] [7.24s] Exiting LLM run with output:
{
"generations": [
[
{
"text": "",
"generation_info": {
"finish_reason": "stop",
"logprobs": null
},
"type": "ChatGeneration",
"message": {
"lc": 1,
"type": "constructor",
"id": [
"langchain",
"schema",
"messages",
"AIMessage"
],
"kwargs": {
"content": "",
"additional_kwargs": {
"function_call": {
"arguments": "{\n \"questions\": [\n \"CDP和WebDriver Protocol在浏览器自动化测试中有何不同？\",\n \"为什么在部署时推荐使用容器化？\",\n \"在何种情况下会选择使用puppeteer-core而不是puppeteer？\"\n ]\n}",
"name": "hypothetical_questions"
}
},
"response_metadata": {
"token_usage": {
"completion_tokens": 77,
"prompt_tokens": 5651,
"total_tokens": 5728
},
"model_name": "gpt-4-0613",
"system_fingerprint": null,
"finish_reason": "stop",
"logprobs": null
},
"type": "ai",
"id": "run-6b39c240-b1a9-44a2-b876-6572c371dbb2-0",
"usage_metadata": {
"input_tokens": 5651,
"output_tokens": 77,
"total_tokens": 5728
},
"tool_calls": [],
"invalid_tool_calls": []
}
}
}
]
],
"llm_output": {
"token_usage": {
"completion_tokens": 77,
"prompt_tokens": 5651,
"total_tokens": 5728
},
"model_name": "gpt-4-0613",
"system_fingerprint": null
},
"run": null
}
[chain/start] [chain:RunnableSequence > parser:JsonKeyOutputFunctionsParser] Entering Parser run with input:
[inputs]
[chain/end] [chain:RunnableSequence > parser:JsonKeyOutputFunctionsParser] [2ms] Exiting Parser run with output:
{
"output": [
"如何在chrome中设置二进制文件的位置？",
"如何在chrome中添加启动参数？",
"如何在chrome中添加扩展应用？"
]
}
[chain/start] [chain:RunnableSequence > parser:JsonKeyOutputFunctionsParser] Entering Parser run with input:
[inputs]
[chain/end] [chain:RunnableSequence > parser:JsonKeyOutputFunctionsParser] [1ms] Exiting Parser run with output:
{
"output": [
"CDP和WebDriver Protocol在浏览器自动化测试中有何不同？",
"为什么在部署时推荐使用容器化？",
"在何种情况下会选择使用puppeteer-core而不是puppeteer？"
]
}
[chain/end] [chain:RunnableSequence] [7.26s] Exiting Chain run with output:
{
"output": [
"CDP和WebDriver Protocol在浏览器自动化测试中有何不同？",
"为什么在部署时推荐使用容器化？",
"在何种情况下会选择使用puppeteer-core而不是puppeteer？"
]
}
[chain/end] [chain:RunnableSequence] [7.26s] Exiting Chain run with output:
{
"output": [
"如何在chrome中设置二进制文件的位置？",
"如何在chrome中添加启动参数？",
"如何在chrome中添加扩展应用？"
]
}
# The vectorstore to use to index the child chunks
vectorstore = Chroma(
collection_name="hypo-questions", embedding_function=OpenAIEmbeddings()
)
# The storage layer for the parent documents
store = InMemoryByteStore()
id_key = "doc_id"
# The retriever (empty to start)
retriever = MultiVectorRetriever(
vectorstore=vectorstore,
byte_store=store,
id_key=id_key,
)
doc_ids = [str(uuid.uuid4()) for _ in docs]
question_docs = []
for i, question_list in enumerate(hypothetical_questions):
question_docs.extend(
[Document(page_content=s, metadata={id_key: doc_ids[i]}) for s in question_list]
)
retriever.vectorstore.add_documents(question_docs)
retriever.docstore.mset(list(zip(doc_ids, docs)))
# 这只能找到相关的问题
sub_docs = vectorstore.similarity_search("CDP是什么")
# 找到原文
retrieved_docs = retriever.invoke("CDP是什么")
Self-querying#
他可以将自然语句，通过LLM结构化做结构化查询，然后在应用于向量存储，这个可以提高查询的相似性还可以应用元数据中的过滤器。所以，查询效率高
下面的链接列举出了相关的self query https://python.langchain.com/v0.1/docs/integrations/retrievers/self_query/
流程如下：
from langchain_chroma import Chroma
from langchain_core.documents import Document
from langchain_openai import OpenAIEmbeddings
# mock了文档，
docs = [
Document(
page_content=" 肖申克的救赎 The Shawshank Redemption (1994) ",
metadata={"year": 1994, "rating": 9.7, "director": "弗兰克·德拉邦特"},
),
Document(
page_content=" 霸王别姬 (1993) ",
metadata={"year": 1993, "director": "陈凯歌", "rating": 9.6},
),
Document(
page_content=" 阿甘正传 Forrest Gump (1994) ",
metadata={"year": 1994, "director": "罗伯特·泽米吉斯", "rating": 9.5},
),
Document(
page_content=" 泰坦尼克号 Titanic (1997) ",
metadata={"year": 1997, "director": "詹姆斯·卡梅隆", "rating": 9.5},
),
Document(
page_content=" 这个杀手不太冷 Léon (1994) ",
metadata={"year": 1994, "director": "吕克·贝松","rating": 9.4},
)
]
vectorstore = Chroma.from_documents(docs, OpenAIEmbeddings())
vectorstore.as_retriever().invoke("杀手")
[Document(page_content=' 这个杀手不太冷 Léon (1994) ', metadata={'director': '吕克·贝松', 'rating': 9.4, 'year': 1994}),
Document(page_content=' 这个杀手不太冷 Léon (1994) ', metadata={'director': '吕克·贝松', 'rating': 9.4, 'year': 1994}),
Document(page_content=' 肖申克的救赎 The Shawshank Redemption (1994) ', metadata={'director': '弗兰克·德拉邦特', 'rating': 9.7, 'year': 1994}),
Document(page_content=' 肖申克的救赎 The Shawshank Redemption (1994) ', metadata={'director': '弗兰克·德拉邦特', 'rating': 9.7, 'year': 1994})]
# 创建self query retriever
from langchain.chains.query_constructor.base import AttributeInfo
from langchain.retrievers.self_query.base import SelfQueryRetriever
from langchain_openai import ChatOpenAI
metadata_field_info = [
AttributeInfo(
name="director",
description="电影的导演",
type="string",
),
AttributeInfo(
name="year",
description="电影上映的年份",
type="integer",
),
AttributeInfo(
name="rating", description="电影评分，1到10", type="float"
),
]
document_content_description = "杀手"
llm = ChatOpenAI(temperature=0)
retriever = SelfQueryRetriever.from_llm(
llm,
vectorstore,
document_content_description,
metadata_field_info,
)
# This example only specifies a filter
retriever.invoke("评分大于9的电影")
[chain/start] [retriever:Retriever > chain:query_constructor] Entering Chain run with input:
{
"query": "评分大于9的电影"
}
[chain/start] [retriever:Retriever > chain:query_constructor > prompt:FewShotPromptTemplate] Entering Prompt run with input:
{
"query": "评分大于9的电影"
}
[chain/end] [retriever:Retriever > chain:query_constructor > prompt:FewShotPromptTemplate] [1ms] Exiting Prompt run with output:
[outputs]
[llm/start] [retriever:Retriever > chain:query_constructor > llm:ChatOpenAI] Entering LLM run with input:
{
"prompts": [
"Human: Your goal is to structure the user's query to match the request schema provided below.\n\n<< Structured Request Schema >>\nWhen responding use a markdown code snippet with a JSON object formatted in the following schema:\n\n```json\n{\n \"query\": string \\ text string to compare to document contents\n \"filter\": string \\ logical condition statement for filtering documents\n}\n```\n\nThe query string should contain only text that is expected to match the contents of documents. Any conditions in the filter should not be mentioned in the query as well.\n\nA logical condition statement is composed of one or more comparison and logical operation statements.\n\nA comparison statement takes the form: `comp(attr, val)`:\n- `comp` (eq | ne | gt | gte | lt | lte): comparator\n- `attr` (string): name of attribute to apply the comparison to\n- `val` (string): is the comparison value\n\nA logical operation statement takes the form `op(statement1, statement2, ...)`:\n- `op` (and | or): logical operator\n- `statement1`, `statement2`, ... (comparison statements or logical operation statements): one or more statements to apply the operation to\n\nMake sure that you only use the comparators and logical operators listed above and no others.\nMake sure that filters only refer to attributes that exist in the data source.\nMake sure that filters only use the attributed names with its function names if there are functions applied on them.\nMake sure that filters only use format `YYYY-MM-DD` when handling date data typed values.\nMake sure that filters take into account the descriptions of attributes and only make comparisons that are feasible given the type of data being stored.\nMake sure that filters are only used as needed. If there are no filters that should be applied return \"NO_FILTER\" for the filter value.\n\n<< Example 1. >>\nData Source:\n```json\n{\n \"content\": \"Lyrics of a song\",\n \"attributes\": {\n \"artist\": {\n \"type\": \"string\",\n \"description\": \"Name of the song artist\"\n },\n \"length\": {\n \"type\": \"integer\",\n \"description\": \"Length of the song in seconds\"\n },\n \"genre\": {\n \"type\": \"string\",\n \"description\": \"The song genre, one of \"pop\", \"rock\" or \"rap\"\"\n }\n }\n}\n```\n\nUser Query:\nWhat are songs by Taylor Swift or Katy Perry about teenage romance under 3 minutes long in the dance pop genre\n\nStructured Request:\n```json\n{\n \"query\": \"teenager love\",\n \"filter\": \"and(or(eq(\\\"artist\\\", \\\"Taylor Swift\\\"), eq(\\\"artist\\\", \\\"Katy Perry\\\")), lt(\\\"length\\\", 180), eq(\\\"genre\\\", \\\"pop\\\"))\"\n}\n```\n\n\n<< Example 2. >>\nData Source:\n```json\n{\n \"content\": \"Lyrics of a song\",\n \"attributes\": {\n \"artist\": {\n \"type\": \"string\",\n \"description\": \"Name of the song artist\"\n },\n \"length\": {\n \"type\": \"integer\",\n \"description\": \"Length of the song in seconds\"\n },\n \"genre\": {\n \"type\": \"string\",\n \"description\": \"The song genre, one of \"pop\", \"rock\" or \"rap\"\"\n }\n }\n}\n```\n\nUser Query:\nWhat are songs that were not published on Spotify\n\nStructured Request:\n```json\n{\n \"query\": \"\",\n \"filter\": \"NO_FILTER\"\n}\n```\n\n\n<< Example 3. >>\nData Source:\n```json\n{\n \"content\": \"杀手\",\n \"attributes\": {\n \"director\": {\n \"description\": \"\\u7535\\u5f71\\u7684\\u5bfc\\u6f14\",\n \"type\": \"string\"\n },\n \"year\": {\n \"description\": \"\\u7535\\u5f71\\u4e0a\\u6620\\u7684\\u5e74\\u4efd\",\n \"type\": \"integer\"\n },\n \"rating\": {\n \"description\": \"\\u7535\\u5f71\\u8bc4\\u5206\\uff0c1\\u523010\",\n \"type\": \"float\"\n }\n}\n}\n```\n\nUser Query:\n评分大于9的电影\n\nStructured Request:"
]
}
[llm/end] [retriever:Retriever > chain:query_constructor > llm:ChatOpenAI] [2.08s] Exiting LLM run with output:
{
"generations": [
[
{
"text": "```json\n{\n \"query\": \"\",\n \"filter\": \"gt(\\\"rating\\\", 9)\"\n}\n```",
"generation_info": {
"finish_reason": "stop",
"logprobs": null
},
"type": "ChatGeneration",
"message": {
"lc": 1,
"type": "constructor",
"id": [
"langchain",
"schema",
"messages",
"AIMessage"
],
"kwargs": {
"content": "```json\n{\n \"query\": \"\",\n \"filter\": \"gt(\\\"rating\\\", 9)\"\n}\n```",
"response_metadata": {
"token_usage": {
"completion_tokens": 23,
"prompt_tokens": 915,
"total_tokens": 938
},
"model_name": "gpt-3.5-turbo-0125",
"system_fingerprint": null,
"finish_reason": "stop",
"logprobs": null
},
"type": "ai",
"id": "run-bacd92af-e29f-438d-9605-3a0d2ff311a1-0",
"usage_metadata": {
"input_tokens": 915,
"output_tokens": 23,
"total_tokens": 938
},
"tool_calls": [],
"invalid_tool_calls": []
}
}
}
]
],
"llm_output": {
"token_usage": {
"completion_tokens": 23,
"prompt_tokens": 915,
"total_tokens": 938
},
"model_name": "gpt-3.5-turbo-0125",
"system_fingerprint": null
},
"run": null
}
[chain/start] [retriever:Retriever > chain:query_constructor > parser:StructuredQueryOutputParser] Entering Parser run with input:
[inputs]
[chain/end] [retriever:Retriever > chain:query_constructor > parser:StructuredQueryOutputParser] [2ms] Exiting Parser run with output:
[outputs]
[chain/end] [retriever:Retriever > chain:query_constructor] [2.08s] Exiting Chain run with output:
[outputs]
[Document(page_content=' 阿甘正传 Forrest Gump (1994) ', metadata={'director': '罗伯特·泽米吉斯', 'rating': 9.5, 'year': 1994}),
Document(page_content=' 阿甘正传 Forrest Gump (1994) ', metadata={'director': '罗伯特·泽米吉斯', 'rating': 9.5, 'year': 1994}),
Document(page_content=' 霸王别姬 (1993) ', metadata={'director': '陈凯歌', 'rating': 9.6, 'year': 1993}),
Document(page_content=' 霸王别姬 (1993) ', metadata={'director': '陈凯歌', 'rating': 9.6, 'year': 1993})]
到此，结束了