Campo di autowire non riuscito: RestTemplate nell'applicazione Spring boot

Sto ottenendo un'eccezione inferiore durante l'esecuzione dell'applicazione di avvio a molla durante l'avvio:

org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'testController': Injection of autowired dependencies failed; nested exception is org.springframework.beans.factory.BeanCreationException: Could not autowire field: private org.springframework.web.client.RestTemplate com.micro.test.controller.TestController.restTemplate; nested exception is org.springframework.beans.factory.NoSuchBeanDefinitionException: No qualifying bean of type [org.springframework.web.client.RestTemplate] found for dependency: expected at least 1 bean which qualifies as autowire candidate for this dependency. Dependency annotations: {@org.springframework.beans.factory.annotation.Autowired(required=true)}

Sto autowiring RestTemplate nel mio TestController. Sto usando Maven per la gestione delle dipendenze.

TestMicroServiceApplication.java

package com.micro.test;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class TestMicroServiceApplication {

    public static void main(String[] args) {
        SpringApplication.run(TestMicroServiceApplication.class, args);
    }
}

TestController.java

    package com.micro.test.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

@RestController
public class TestController {

    @Autowired
    private RestTemplate restTemplate;

    @RequestMapping(value="/micro/order/{id}",
        method=RequestMethod.GET,
        produces=MediaType.ALL_VALUE)
    public String placeOrder(@PathVariable("id") int customerId){

        System.out.println("Hit ===> PlaceOrder");

        Object[] customerJson = restTemplate.getForObject("http://localhost:8080/micro/customers", Object[].class);

        System.out.println(customerJson.toString());

        return "false";
    }

}

pom.xml

    <?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.micro.test</groupId>
    <artifactId>Test-MicroService</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>Test-MicroService</name>
    <description>Demo project for Spring Boot</description>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.3.3.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>


</project>

È esattamente quello che dice l'errore. Non hai creato alcun RestTemplatebean, quindi non può autowire alcun bean. Se ne hai bisogno RestTemplatedovrai fornirne uno. Ad esempio, aggiungi quanto segue a TestMicroServiceApplication.java :

@Bean
public RestTemplate restTemplate() {
    return new RestTemplate();
}

Nota, nelle versioni precedenti di Spring cloud starter per Eureka, un RestTemplatebean è stato creato per te, ma questo non è più vero.

A seconda delle tecnologie che stai utilizzando e delle versioni che influenzeranno il modo in cui definisci un RestTemplatenella tua @Configurationclasse.

Spring> = 4 senza Spring Boot

Definisci semplicemente un @Bean:

@Bean
public RestTemplate restTemplate() {
    return new RestTemplate();
}

Spring Boot <= 1.3

Non c'è bisogno di definirne uno, Spring Boot ne definisce automaticamente uno per te.

Spring Boot> = 1.4

Spring Boot non definisce più automaticamente un RestTemplatema invece definisce un RestTemplateBuilderconsentendo un maggiore controllo sul RestTemplate che viene creato. Puoi inserire il RestTemplateBuildercome argomento nel tuo @Beanmetodo per creare un RestTemplate:

@Bean
public RestTemplate restTemplate(RestTemplateBuilder builder) {
   // Do any additional configuration here
   return builder.build();
}

Usandolo nella tua classe

@Autowired
private RestTemplate restTemplate;

Riferimento

Se un TestRestTemplate è un'opzione valida nel tuo unit test, questa documentazione potrebbe essere pertinente

http://docs.spring.io/spring-boot/docs/1.4.1.RELEASE/reference/htmlsingle/#boot-features-rest-templates-test-utility

Risposta breve: se si utilizza

@SpringBootTest(webEnvironment=WebEnvironment.RANDOM_PORT)

allora @Autowiredfunzionerà. Se usi

@SpringBootTest(webEnvironment=WebEnvironment.MOCK)

quindi creare un TestRestTemplate come questo

private TestRestTemplate template = new TestRestTemplate();

L'errore indica direttamente che il RestTemplatebean non è definito nel contesto e non può caricare i bean.

1. Definisci un bean per RestTemplate e quindi usalo
2. Usa una nuova istanza di RestTemplate

Se sei sicuro che il bean sia definito per RestTemplate, utilizza quanto segue per stampare i bean disponibili nel contesto caricato dall'applicazione Spring Boot

ApplicationContext ctx = SpringApplication.run(Application.class, args);
String[] beanNames = ctx.getBeanDefinitionNames();
Arrays.sort(beanNames);
for (String beanName : beanNames) {
    System.out.println(beanName);
}

Se questo contiene il bean con il nome / tipo fornito, allora tutto bene. Oppure definisci un nuovo bean e poi usalo.

Poiché le istanze RestTemplate spesso devono essere personalizzate prima di essere utilizzate, Spring Boot non fornisce alcun singolo bean RestTemplate configurato automaticamente.

RestTemplateBuilder offre un modo corretto per configurare e istanziare il bean del modello rest, ad esempio per l'autenticazione di base o gli interceptor.

@Bean
public RestTemplate restTemplate(RestTemplateBuilder builder) {
    return builder
                .basicAuthorization("user", "name") // Optional Basic auth example
                .interceptors(new MyCustomInterceptor()) // Optional Custom interceptors, etc..
                .build();
}

• Devi aggiungere @Bean public RestTemplate restTemplate(RestTemplateBuilder builder){ return builder.build(); }

Assicurati di due cose:

1- Usa l' @Beanannotazione con il metodo.

@Bean
public RestTemplate restTemplate(RestTemplateBuilder builder){
    return builder.build();
}

2- L'ambito di questo metodo dovrebbe essere pubblico, non privato .

Esempio completo -

@Service
public class MakeHttpsCallImpl implements MakeHttpsCall {

@Autowired
private RestTemplate restTemplate;

@Override
public String makeHttpsCall() {
    return restTemplate.getForObject("https://localhost:8085/onewayssl/v1/test",String.class);
}

@Bean
public RestTemplate restTemplate(RestTemplateBuilder builder){
    return builder.build();
}
}

Il modo più semplice in cui sono stato in grado di ottenere un'impresa simile è utilizzare il codice seguente ( riferimento ), ma suggerirei di non effettuare chiamate API nei controller ( principi SOLID ). Anche l'autowiring in questo modo è meglio ottimizzato rispetto al modo tradizionale di farlo.

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.web.client.RestTemplateBuilder;
import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

@RestController
public class TestController {

    private final RestTemplate restTemplate;


    @Autowired
    public TestController(RestTemplateBuilder builder) {
        this.restTemplate = builder.build();
    }

    @RequestMapping(value="/micro/order/{id}", method= RequestMethod.GET, produces= MediaType.ALL_VALUE)
    public String placeOrder(@PathVariable("id") int customerId){

        System.out.println("Hit ===> PlaceOrder");

        Object[] customerJson = restTemplate.getForObject("http://localhost:8080/micro/customers", Object[].class);

        System.out.println(customerJson.toString());

        return "false";
    }
}

stai cercando di iniettare restTemplate ma devi creare la classe di configurazione. quindi devi creare un bean che ti restituisca un nuovo RestTemplate vedi l'esempio seguente.

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;


@Configuration
public class YourConfigClass {


    @Bean
    public RestTemplate restTesmplate() {
        return new RestTemplate();
    }

}