Moya
15.0.3
Uma versão chinesa deste documento pode ser encontrada aqui.
Você é um desenvolvedor inteligente. Você provavelmente usa o Alamofire para abstrair o acesso à URLSession e todos os detalhes desagradáveis dos quais você realmente não se importa. Mas, como muitos desenvolvedores inteligentes, você escreve camadas de abstração de rede ad hoc. Eles provavelmente são chamados de "Apimanager" ou "NetworkModel", e sempre terminam em lágrimas.
As camadas de rede ad hoc são comuns nos aplicativos iOS. Eles são ruins por alguns motivos:
Portanto, a idéia básica de Moya é que queremos uma camada de abstração de rede que encapsula suficientemente chamando o Alamofire diretamente. Deve ser simples o suficiente para que as coisas comuns sejam fáceis, mas abrangentes o suficiente para que coisas complicadas também sejam fáceis.
Se você usa o Alamofire para abstrair
URLSession, por que não usar algo para abstrair o âmago da questão dos URLs, parâmetros, etc?
Algumas características impressionantes de Moya:
Você pode verificar mais sobre a direção do projeto no documento da visão.
Fornecemos dois projetos de amostra no repositório. Para usá -lo, faça o download do repo, execute carthage update para baixar as bibliotecas necessárias e abrir moya.xcodeproj. Você verá dois esquemas: Basic e Multi-Target - selecione um e depois construa e execute! Os arquivos de origem para estes estão no diretório Examples no Project Navigator. Divirta-se!
Este projeto está ativamente em desenvolvimento e está sendo usado no aplicativo de leilão da Artsy. Nós o consideramos pronto para uso da produção.
Abaixo está uma tabela que mostra qual versão do Moya você deve usar para sua versão Swift.
| Swift | Moya | Rxmoya | ReactiveMoya | Rxswift | Reativeswift | Alamofire |
|---|---|---|---|---|---|---|
| > = 5.2 | > = 15.0.0 | > = 15.0.0 | > = 15.0.0 | 6.x | 6.x | 5.x |
| 5.x | > = 14.0.0 | > = 14.0.0 | > = 14.0.0 | 5.x | 6.x | 5.x |
| 5.x | > = 13.0.0 | > = 13.0.0 | > = 13.0.0 | 4.x | 5.x | > = 4.1 |
| 4.x | 9.0.0 - 12.0.1 | 10.0.0 - 12.0.1 | 9.0.0 - 12.0.1 | 4.x (> = 10.0.0) | 4.x (> = 12.0.0) | 4.1 (> = 11.0.0) |
| 3.x | 8.0.0 - 8.0.5 | 8.0.0 - 8.0.5 | 8.0.0 - 8.0.5 | - | - | - |
| 2.3 | 7.0.2 - 7.0.4 | 7.0.2 - 7.0.4 | 7.0.2 - 7.0.4 | - | - | - |
| 2.2 | <= 7.0.1 | <= 7.0.1 | <= 7.0.1 | - | - | - |
Nota: Se você estiver usando o Swift 4.2 em seu projeto, mas estiver usando o XCode 10.2, o Moya 13 deve funcionar corretamente, mesmo que usemos o Swift 5.0.
Atualizando para uma nova versão principal de Moya? Confira nossos guias de migração.
NOTA: As instruções abaixo são para usar o SWIFTPM sem a interface do usuário do Xcode. É o mais fácil de acessar as configurações do seu projeto -> Pacotes Swift e adicionar Moya a partir daí.
Para integrar o uso do Swift Package Manager da Apple, sem integração do Xcode, adicione o seguinte como uma dependência ao seu Package.swift :
. package ( url : " https://github.com/Moya/Moya.git " , . upToNextMajor ( from : " 15.0.0 " ) ) e depois especifique "Moya" como uma dependência do alvo em que você deseja usar o Moya. Se você deseja usar extensões reativas, adicione também "ReactiveMoya" , "RxMoya" ou "CombineMoya" como sua dependência de destino, respectivamente. Aqui está um exemplo PackageDescription :
// swift-tools-version:5.3
import PackageDescription
let package = Package (
name : " MyPackage " ,
products : [
. library (
name : " MyPackage " ,
targets : [ " MyPackage " ] ) ,
] ,
dependencies : [
. package ( url : " https://github.com/Moya/Moya.git " , . upToNextMajor ( from : " 15.0.0 " ) )
] ,
targets : [
. target (
name : " MyPackage " ,
dependencies : [ " ReactiveMoya " ] )
]
)Combine Nota: Se você estiver usando o CombineMoya , certifique -se de usar o Xcode 11.5.0 ou posterior. Com as versões anteriores do Xcode, você precisará adicionar manualmente como uma estrutura fracamente vinculada ao seu destino de aplicativo.
O ACCIO é um gerente de dependência baseado no SWIFTPM, que pode criar estruturas para iOS/macOS/tvOS/watchOS. Portanto, as etapas de integração de Moya são exatamente as mesmas descritas acima. Depois que o arquivo Package.swift estiver configurado, execute accio update em vez da swift package update .
Para Moya, use a seguinte entrada em seu podfile:
pod 'Moya' , '~> 15.0'
# or
pod 'Moya/RxSwift' , '~> 15.0'
# or
pod 'Moya/ReactiveSwift' , '~> 15.0'
# or
pod 'Moya/Combine' , '~> 15.0' Em seguida, execute pod install .
Em qualquer arquivo em que você deseja usar o Moya, não se esqueça de importar a estrutura com import Moya .
Os usuários do Cartago podem apontar para este repositório e usar a estrutura gerada que eles gostariam, Moya , RxMoya , ReactiveMoya ou CombineMoya .
Faça a seguinte entrada em seu arquivo Cart:
github "Moya/Moya" ~> 15.0
Em seguida, execute carthage update --use-xcframeworks .
Se esta é a sua primeira vez usando Cartago no projeto, você precisará seguir algumas etapas adicionais, conforme explicado em Cartago.
NOTA: Neste momento, Cartago não fornece uma maneira de criar apenas submódulos específicos do repositório. Todos os submódulos e suas dependências serão construídos com o comando acima. No entanto, você não precisa copiar estruturas que não está usando em seu projeto. Por exemplo, se você não estiver usando
ReactiveSwift, sinta -se à vontade para excluir essa estrutura, juntamente comReactiveMoyado diretório de construção do Cartago após a conclusãocarthage update. Ou se você estiver usandoReactiveSwift, mas nãoRxSwiftouCombine,RxMoya,RxTest,RxCocoa,CombineMoyaetc. pode ser excluído com segurança.
cd no seu diretório de projeto de nível superior e execute o seguinte comando se o seu projeto não for inicializado como um repositório Git: $ git init$ git submodule add https://github.com/Alamofire/Alamofire.git
$ git submodule add https://github.com/Moya/Moya.gitAlamofire e arraste o Alamofire.xcodeproj para o navegador do projeto do projeto Xcode do seu aplicativo. Faça o mesmo com o Moya.xcodeproj na pasta Moya .Eles devem aparecer aninhados sob o ícone do projeto azul do seu aplicativo. Se está acima ou abaixo de todos os outros grupos Xcode, não importa.
xcodeproj correspondem ao de sua meta de aplicativo no navegador do projeto.+ na seção "Binários incorporados".Alamofire.xcodeproj , cada uma com duas versões diferentes do Alamofire.framework Framework aninhado dentro de uma pasta Products .Não importa qual pasta
Productsvocê escolhe, mas importa se você escolhe oAlamofire.frameworksuperior ou inferior.
Alamofire.framework superior para iOS e o inferior para MacOS.Você pode verificar qual você selecionou inspecionando o log de compilação para o seu projeto. O alvo de construção do
Alamofireserá listado comoAlamofire iOS,Alamofire macOS,Alamofire tvOSouAlamofire watchOS.
Clique no botão + em "Binários incorporados" novamente e adicione o alvo de construção correto para Moya .
E é isso!
As três estruturas são adicionadas automaticamente como uma dependência de destino, estrutura vinculada e estrutura incorporada em uma fase de criação de arquivos de cópia, o que é tudo o que você precisa para criar no simulador e no dispositivo.
Depois de alguma configuração, o uso de Moya é realmente simples. Você pode acessar uma API como esta:
provider = MoyaProvider < GitHub > ( )
provider . request ( . zen ) { result in
switch result {
case let . success ( moyaResponse ) :
let data = moyaResponse . data
let statusCode = moyaResponse . statusCode
// do something with the response data or statusCode
case let . failure ( error ) :
// this means there was a network failure - either the request
// wasn't sent (connectivity), or no response was received (server
// timed out). If the server responds with a 4xx or 5xx error, that
// will be sent as a ".success"-ful response.
}
}Esse é um exemplo básico. Muitas solicitações de API precisam de parâmetros. Moya os codifica na enumeração que você usa para acessar o terminal, como este:
provider = MoyaProvider < GitHub > ( )
provider . request ( . userProfile ( " ashfurrow " ) ) { result in
// do something with the result
}Não há mais erros de digitação nos URLs. Não há mais valores de parâmetros ausentes. Não há mais bagunça com a codificação de parâmetros.
Para mais exemplos, consulte a documentação.
Mesmo mais frio são as extensões reativas. Moya fornece extensões reativas para reativeswift, rxswift e combinar.
A extensão ReactiveSwift fornece os dois reactive.request(:callbackQueue:) e reactive.requestWithProgress(:callbackQueue:) Métodos que retornam imediatamente SignalProducer que você pode iniciar, vincular, mapa ou o que quiser. Para lidar com erros, por exemplo, poderíamos fazer o seguinte:
provider = MoyaProvider < GitHub > ( )
provider . reactive . request ( . userProfile ( " ashfurrow " ) ) . start { event in
switch event {
case let . value ( response ) :
image = UIImage ( data : response . data )
case let . failed ( error ) :
print ( error )
default :
break
}
} A extensão RxSwift também fornece os métodos rx.request(:callbackQueue:) e rx.requestWithProgress(:callbackQueue:) , mas o tipo de retorno é diferente para ambos. No caso de um rx.request(:callbackQueue) , o tipo de retorno é Single<Response> que emite um elemento único ou um erro. No caso de um rx.requestWithProgress(:callbackQueue:) , o tipo de retorno é Observable<ProgressResponse> , pois podemos obter vários eventos do progresso e um último evento que é uma resposta.
Para lidar com erros, por exemplo, poderíamos fazer o seguinte:
provider = MoyaProvider < GitHub > ( )
provider . rx . request ( . userProfile ( " ashfurrow " ) ) . subscribe { event in
switch event {
case let . success ( response ) :
image = UIImage ( data : response . data )
case let . error ( error ) :
print ( error )
}
} Além da opção de usar sinais em vez de blocos de retorno de chamada, também existem uma série de operadores de sinal para RXSWIFT e Reactiveswift que tentarão mapear os dados recebidos da resposta da rede em uma imagem, algum JSON ou uma string, com mapImage() , mapJSON() e mapString() , respectivamente. Se o mapeamento não tiver sucesso, você receberá um erro no sinal. Você também obtém métodos úteis para filtrar determinados códigos de status. Isso significa que você pode colocar seu código para lidar com erros de API como 400 nos mesmos locais que o código para lidar com respostas inválidas.
A Extensão Combine fornece requestPublisher(:callbackQueue:) e requestWithProgressPublisher(:callbackQueue) que retornam AnyPublisher<Response, MoyaError> e AnyPublisher<ProgressResponse, MoyaError> respectivamente.
Aqui está um exemplo de uso requestPublisher : Uso:
provider = MoyaProvider < GitHub > ( )
let cancellable = provider . requestPublisher ( . userProfile ( " ashfurrow " ) )
. sink ( receiveCompletion : { completion in
guard case let . failure ( error ) = completion else { return }
print ( error )
} , receiveValue : { response in
image = UIImage ( data : response . data )
} ) Moya tem uma ótima comunidade em torno disso e algumas pessoas criaram algumas extensões muito úteis.
Ei! Você gosta de Moya? Incrível! Na verdade, poderíamos realmente usar sua ajuda!
O código aberto não está apenas escrevendo código. Moya poderia usar sua ajuda com qualquer um dos seguintes:
Se isso parece legal para você, envie uma solicitação de tração! Após sua primeira contribuição, adicionaremos você como membro ao repositório para que você possa mesclar solicitações de puxar e ajudar a dirigir o navio? Você pode ler mais detalhes sobre isso em nossas diretrizes de colaboradores.
A comunidade de Moya tem uma tremenda energia positiva, e os mantenedores estão comprometidos em manter as coisas incríveis. Como na comunidade Cocoapods, sempre assuma uma intenção positiva. Mesmo que um comentário pareça mesquinho, dê à pessoa o benefício da dúvida.
Observe que este projeto é lançado com um código de conduta colaborador. Ao participar deste projeto, você concorda em cumprir seus termos.
Se você adicionar ou remover um arquivo de origem do Moya, uma alteração correspondente precisará ser feita para o projeto Moya.xcodeproj na raiz deste repositório. Este projeto é usado para Cartago. Não se preocupe, você receberá um aviso automatizado ao enviar uma solicitação de tração, se esquecer.
Seja você um membro do núcleo ou um usuário experimentando pela primeira vez, pode fazer uma contribuição valiosa para a Moya, melhorando a documentação. Ajude -nos por:
Moya é liberado sob uma licença do MIT. Consulte License.md para obter mais informações.
