Utilizzare l'attuatore di avvio a molla senza un'applicazione di avvio a molla

Question

La libreria di strumenti di avvio di avvio con endpoint di produzione è davvero utile per qualsiasi applicazione server. Ma il problema è che non sono riuscito a trovare un modo per integrarmi in un'applicazione Spring tradizionale (che non è un'applicazione Spring Boot).

Ci deve essere un modo per utilizzare i punti finali dell'attuatore ma non ho potuto collegarli.

Ho una classe JavaConfig come qui di seguito

@Configuration 
@ComponentScan(basePackages = { "com.company.helper", "org.springframework.boot" }) 
@EnableWebMvc 
@Import({ DbConfig.class }) 

public class AppConfig extends WebMvcConfigurerAdapter { 

} 

Ma questa configurazione genera un errore durante la distribuzione.

Questo cablaggio può essere eseguito senza l'applicazione Spring Boot?

Answer 1

ho aggiunto informazioni su come aggiungere attuatore avvio primavera in un'applicazione non di avvio in questo post del blog

http://givenwhenthen.blogspot.com/2015/09/adding-spring-boot-actuator-to-non.html

Nel build.gradle dell'applicazione , Ho aggiunto la seguente dipendenza

compile('org.springframework.boot:spring-boot-actuator:1.2.5.RELEASE'){ 
    exclude group: 'org.springframework.boot', module:'spring-boot-starter-logging'} 

Nella classe Spring Config dell'applicazione, ho aggiunto le seguenti cose:

import org.springframework.beans.factory.annotation.Autowired; 
import org.springframework.boot.actuate.autoconfigure.EndpointAutoConfiguration; 
import org.springframework.boot.actuate.endpoint.BeansEndpoint; 
import org.springframework.boot.actuate.endpoint.HealthEndpoint; 
import org.springframework.boot.actuate.endpoint.InfoEndpoint; 
import org.springframework.boot.actuate.endpoint.RequestMappingEndpoint; 
import org.springframework.boot.actuate.endpoint.mvc.EndpointHandlerMapping; 
import org.springframework.boot.actuate.endpoint.mvc.EndpointMvcAdapter; 
import org.springframework.boot.actuate.endpoint.mvc.HealthMvcEndpoint; 
import org.springframework.boot.actuate.endpoint.mvc.MvcEndpoint; 

@Configuration 
@Import(EndpointAutoConfiguration.class) 
public class MyAppSpringConfig { 

    @Bean 
    @Autowired 
    //Define the HandlerMapping similar to RequestHandlerMapping to expose the endpoint 
    public EndpointHandlerMapping endpointHandlerMapping( 
    Collection<? extends MvcEndpoint> endpoints 
    ){ 
    return new EndpointHandlerMapping(endpoints); 
    } 

    @Bean 
    @Autowired 
    //define the HealthPoint endpoint 
    public HealthMvcEndpoint healthMvcEndpoint(HealthEndpoint delegate){ 
    return new HealthMvcEndpoint(delegate, false); 
    } 

    @Bean 
    @Autowired 
    //define the Info endpoint 
    public EndpointMvcAdapter infoMvcEndPoint(InfoEndpoint delegate){ 
     return new EndpointMvcAdapter(delegate); 
    } 

    @Bean 
    @Autowired 
    //define the beans endpoint 
    public EndpointMvcAdapter beansEndPoint(BeansEndpoint delegate){ 
    return new EndpointMvcAdapter(delegate); 
    } 

    @Bean 
    @Autowired 
    //define the mappings endpoint 
    public EndpointMvcAdapter requestMappingEndPoint( 
    RequestMappingEndpoint delegate 
    ){ 
    return new EndpointMvcAdapter(delegate); 
    } 
} 

Se si desidera eliminare una dipendenza aggiuntiva, fare riferimento al blogpost.

UPDATE

Inoltre è necessario assicurarsi di avere un fagiolo definito per RequestMappingHandlerAdapter, se non ce l'hai il ServletDispatcher non sarà in grado di recuperare l'adattatore per il gestore del vostro HealthMvcEndpoint.

se non avete semplicemente inserirlo al file di configurazione di fagioli

configurazioni XML:

<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter"> 
     <property name="messageConverters"> 
      <list> 
       <ref bean="jsonConverter"/> 
      </list> 
     </property> 
    </bean> 

    <bean id="jsonConverter" class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"> 
     <property name="supportedMediaTypes" value="application/json" /> 
     <property name="prettyPrint" value="true" /> 
    </bean> 

Answer 2

Nel nostro progetto abbiamo usato un piccolo trucco, che ha funzionato per noi. Per abilitare l'attuatore abbiamo utilizzato le dipendenze da spring-boot in POM.

<dependency> 
     <groupId>org.springframework.boot</groupId> 
     <artifactId>spring-boot-actuator</artifactId> 
     <version>1.2.3.RELEASE</version> 
     <type>jar</type> 
    </dependency> 
    <dependency> 
     <groupId>org.hibernate</groupId> 
     <artifactId>hibernate-validator</artifactId> 
     <version>4.3.2.Final</version> 
    </dependency> 

e appena usato classe config supplementari come segue:

@EnableConfigurationProperties 
@Configuration 
@EnableAutoConfiguration 
@Import(EndpointAutoConfiguration.class) 
public class SpringBootActuatorConfig { 

} 

Answer 3

Il progetto su cui sto lavorando usa primavera, ma nessuno dei due Primavera-boot né Primavera-MVC. La seguente soluzione potrebbe non essere automatica come l'attuatore con avvio, ma espone gli endpoint in modo abbastanza succinto.

Fondamentalmente, tutti gli endpoint dell'attuatore sono solo bean, quindi è possibile creare un nuovo componente e un autowire negli endpoint come si ritiene opportuno.

Gli unici ulteriori dipendenze nel mio pom sono la primavera-boot-attuatore e la primavera-webmvc:

<dependency> 
     <groupId>org.springframework.boot</groupId> 
     <artifactId>spring-boot-actuator</artifactId> 
     <version>1.2.1.RELEASE</version> 
    </dependency> 
    <dependency> 
     <groupId>org.springframework</groupId> 
     <artifactId>spring-webmvc</artifactId> 
     <version>4.1.4.RELEASE</version> 
    </dependency> 

Poi tutto quello che dovete fare è creare una singola classe componente (forse registrarlo se è necessario) . Assicurati di annotare con @EnableAutoConfiguration:

@Component 
@EnableAutoConfiguration 
@Path("/actuator/") 
public class ActuatorResource { 

private ObjectMapper mapper = new ObjectMapper(); 


@Autowired 
private DumpEndpoint dumpEndpoint; 

@GET 
@Produces("application/json") 
@Path("/dump") 
@Transactional(readOnly = true) 
public String getDump() throws JsonProcessingException { 
    return mapper.writeValueAsString(dumpEndpoint.invoke()); 
} 

@Autowired 
private EnvironmentEndpoint envEndpoint; 

@GET 
@Produces("application/json") 
@Path("/environment") 
@Transactional(readOnly = true) 
public String getEnvironment() throws JsonProcessingException { 
    return mapper.writeValueAsString(envEndpoint.invoke()); 
} 

}