L'article de blog précédent a construit un framework Eureka + Ribbon + Hystrix. Bien qu'il puisse essentiellement répondre aux appels entre les services, le code semble vraiment moche. Le client doit rédiger un repos-plate à chaque fois. Afin de rendre les appels plus beaux et lisibles, nous apprenons maintenant à utiliser Feign.
La fierté comprend le ruban et l'hystrix, qui connaît progressivement sa signification dans le combat réel. La soi-disant inclusion n'est pas l'inclusion physique des packages JAR de Feign, y compris les packages de pot de ruban et d'hystrix, mais l'inclusion logique des fonctions de Feign, y compris les fonctions des deux autres. En bref: Feign peut faire des choses sur le ruban et l'hystrix, mais pour utiliser les annotations apportées par le ruban et l'hystrix, le package JAR correspondant doit être introduit.
Cas 1:
Centre d'enregistrement d'Eureka: https://github.com/yejingtao/forblog/tree/master/demo-eureka-gister
Fournisseur de services: https://github.com/yejingtao/forblog/tree/master/demo-feign-freeservice
APPELER DE SERVICE: https://github.com/yejingtao/forblog/tree/master/demo-feign-freeconsumer
Le fournisseur de services est une application Web simple eurekaclient +, fournissant les méthodes suivantes
@RestController @RequestMapping ("/ feign-Service") classe publique HellOserviceContorller {private logger logger = loggerfactory.getLogger (this.getClass ()); private void sleep (String methodname) {int sleepMintime = new random (). nextInt (3000); Logger.info ("Helloservice" + Methodname + "SleepMintime:" + SleepMintime); essayez {thread.sleep (sleepMintime); } catch (InterruptedException e) {e.printStackTrace (); }} @RequestMapping (value = "/ serviceGet", méthode = requestMethod.get) public String HellOservice (@RequestParam String Name) {sleep ("get"); Renvoie "HelloserviceImpl Nom:" + Name; } @RequestMapping (Value = "/ ServiceHead", méthode = requestMethod.head) public String HellOservice (@RequestHeader String Name, @RequestHeader String Motway) {sleep ("header"); Renvoie "HelloserviceHead Name:" + Name + "Mot de passe:" + mot de passe; } @RequestMapping (Value = "/ ServicePost", méthode = requestMethod.Post) public String HellOservice (@Requestbody UserDemo UserDemo) {sleep ("Post"); return userDemo.ToString (); }} Les annotations suivantes qui doivent être prêtées à l'attention ne peuvent pas être omises.
@RequestParam: Annotation qui indique que le paramètre de la méthode doit être lié à un paramètre de demande Web
@Requestbody: Annotation indiquant qu'un PARAMETER MÉTHODE doit être lié au corps de la demande Web.
@RequestHeader: Annotation qui indique que le paramètre de méthode doit être lié à un en-tête de demande Web.
Si les annotations ci-dessus sont manquantes, bien que le service ne signale pas une erreur après son exécution, il ne peut pas obtenir les paramètres d'entrée.
Projet d'appelant de service:
<dependency> <proupId> org.springframework.cloud </proupId> <ArtifactId> Spring-Cloud-Starter-Feign </etefactId> </Dependency>
Feign ne dépend que ici, pas du ruban et de l'hystrix.
application.yml:
server: port: 9051 spring: application: name: demo-feign-freeconsumer eureka: client: serviceUrl: defaultZone: http://peer1:1111/eureka/,http://peer2:1112/eureka/ feign: hystrix: enabled: true #Ribbon Timeout Setting#ribbon: # ConnectTimeout: 500 # ReadTimeout: 3000
La configuration d'Hystrix m'a trompé depuis longtemps. Le cloud de printemps que j'ai utilisé est Dalston Version SR1, qui est plus récent que les versions d'autres matériaux sur Internet. Parce que dans la nouvelle version, la prise en charge de Feign pour Hystrix est désactivée par défaut, vous devez donc activer manuellement feign.hystrix.enabled = true via la configuration, de sorte que le dégradation du service et d'autres fonctions seront efficaces.
Programme de démarrage d'application
@Springbootapplication @enableeurekaclient @enableFeignClient classe publique DemofeignApplication {public static void main (String [] args) {springApplication.run (DeemofeignApplication.class, args); }} Notez qu'il y a un autre piège ici. J'utilise @ SpringbootApplication + @ activyEUreKaclient au lieu de @springCloudApplication, car ce dernier contient @enableCircuitBreaker et @enableCircuitbreaker est le contenu du package Hystrix. Mon POM n'introduit pas Hystrix. Spring Cloud a donc toujours des lacunes à cet égard. Vous ne signalerez pas d'erreur en compilant directement avec @springCloudApplication, mais il ne peut pas être démarré. Bien sûr, le protagoniste ici est toujours l'annotation @enableFeignClients.
Code client principal
@FeignClient (name = "Demo-Feign-FreeService", Fallback = DemoFeignFallback.class) Interface publique DemoFeignService {@RequestMapping (Value = "/ feign-Service / ServiceGet", méthode = requestMethod.get) String HellOSVICE (@requestParam ("name") String name); @RequestMapping (value = "/ feign-Service / ServiceHead", méthode = requestMethod.head) string helloService (@RequestHeader ("name") String name, @RequestHeader ("mot de passe") mot de passe de chaîne); @RequestMapping (valeur = "/ feign-Service / ServicePost", méthode = requestMethod.Post) String HellOservice (@Requestbody UserDemo UserDemo); } L'annotation @FeignClient définit que l'interface est un client feign, le nom spécifie le nom de service enregistré sur Eureka, et Fallback est la classe d'implémentation de l'interface une fois le service rétrogradé.
@RequestMapping Spécifie les méthodes de demande d'URL et de demande HTTP relatives de la demande, ce qui correspond au serveur un par un. @RequestParam,
@Requestbody et @RequestHeader Les annotations ont plus d'attributs de valeur que les serveurs. Ils ne peuvent pas être omis ici. Ils doivent informer explicitement le client Feign comment correspondre aux paramètres.
Code de service de rétrogradation:
@Component public class DemoFeignFallback implémente DemoFeignService {@Override public String HellOservice (String Name) {return "Get Error"; } @Override public String HellOservice (String Name, String Motway) {return "Error Head"; } @Override public String Helloservice (UserDemo UserDemo) {return "Post Error"; }} J'ai trouvé que j'avais délibérément supprimé les annotations @RequestParam, @Requestbody et @RequestHeader dans les paramètres d'entrée ici, car la signification essentielle de ces annotations est que Feign utilise pour transmettre les paramètres à HTTP lors de la réalisation des appels de microservice, mais la dégradation du service ne fera pas de demandes HTTP, donc elle peut être obligée ici.
Code du contrôleur:
@RestController Public Class DemoFeignController {@Autowired private DemoFeignService DemoFeignService; @RequestMapping (value = "/ test", méthode = requestMethod.get) public String DemoServiceTest () {stringBuffer sb = new StringBuffer (); SB.APPEND (DemofeigService.hellOservice ("Yuanyuan")); sb.append ("/ n"); SB.APPEND (DemofeigService.helloService ("yjt", "xixihaha")); sb.append ("/ n"); SB.APPEND (DeMoFeigNervice.hellOservice (New UserDemo ("Yejingtao", "123456"))); return sb.toString (); }}Voyons l'effet:
Notre service n'a pas chronométré, les trois méthodes étaient normales, mais la demande de tête n'a pas obtenu la valeur de retour. Ceci est déterminé par les caractéristiques de la demande HTTP de la méthode de tête. La tête ne renvoie pas le corps du corps de la réponse et est généralement utilisé pour les tests de connectivité.
Regardons un autre ensemble:
Les méthodes de tête et de demande de poste ont été traitées pendant plus de 2000 ms, et le service est rétrogradé, et l'implémentation est remplacée par la classe de traitement de secours.
Dans le cas où nous avons toujours le sentiment qu'il existe du code en double entre le fournisseur de services et l'appelant de service. Peut-il être optimisé? Veuillez consulter l'affaire 2.
Cas 2:
Centre d'enregistrement d'Eureka: https://github.com/yejingtao/forblog/tree/master/demo-eureka-gister
API d'interface: https://github.com/yejingtao/forblog/tree/master/demo-peign-serveapi
Fournisseur de services: https://github.com/yejingtao/forblog/tree/master/demo-feign-servicempll
APPELER DE SERVICE: https://github.com/yejingtao/forblog/tree/master/demo-peign-apicconsumer
Le plus grand changement dans le cas 2 consiste à rédiger des capacités de service séparément dans un projet API, et l'appelant et le fournisseur POM reposent sur cette API.
API:
Interface publique HellOservice {@RequestMapping (value = "/ feign-Service / ServiceGet", méthode = requestMethod.get) String HellOservice (@RequestParam ("name") Nom de chaîne); @RequestMapping (value = "/ feign-Service / ServiceHead", méthode = requestMethod.head) string helloService (@RequestHeader ("name") String name, @RequestHeader ("mot de passe") mot de passe de chaîne); @RequestMapping (valeur = "/ feign-Service / ServicePost", méthode = requestMethod.Post) String HellOservice (@Requestbody UserDemo UserDemo); } Fournisseur de services:
@RestController public class helloServiceContorller implémente helloService {private logger logger = loggerfactory.getLogger (this.getClass ()); private void sleep (String methodname) {int sleepMintime = new random (). nextInt (3000); Logger.info ("Helloservice" + Methodname + "SleepMintime:" + SleepMintime); essayez {thread.sleep (sleepMintime); } catch (InterruptedException e) {e.printStackTrace (); }} @Override public String Helloservice (@RequestParam ("name") Nom de la chaîne) {sleep ("get"); Renvoie "HelloserviceImpl Nom:" + Name; } @Override public String Helloservice (@RequestHeader ("name") Nom de chaîne, @RequestHeader ("mot de passe") Mot de passe de chaîne) {sleep ("header"); Renvoie "HelloserviceHead Name:" + Name + "Mot de passe:" + mot de passe; } @Override public String Helloservice (@Requestbody UserDemo UserDemo) {sleep ("Post"); return userDemo.ToString (); }} Appelant de service:
@FeignClient (name = "Demo-Feign-ServiceImpl", Fallback = FeigServiceFallback.class) Interface publique FeigNervice étend Helloservice {}D'autres codes restent fondamentalement inchangés et l'effet est le même.
Les deux styles ont leurs propres avantages et inconvénients: le freestyle est plus gratuit et la nouvelle méthode ajoutée au serveur n'affectera pas le code client. L'inconvénient est que les capacités de service ne sont pas synchronisées et que les changements de capacités de service provoqueront des anomalies; Les capacités du service client du serveur API Format sont synchronisées, mais les modifications de l'interface nécessitent une modification du code des deux côtés, et vous devez la considérer clairement lors de la construction.
Ce qui précède est tout le contenu de cet article. J'espère que cela sera utile à l'apprentissage de tous et j'espère que tout le monde soutiendra davantage Wulin.com.