@Autowired instance of Service class is null in the application.java

I am a little confused,why @Autowired instance of the Service class is null

@Service
        public class TokenServiceImpl implements TokenService{
        
        	private final Settings settings;
        
            private final RestTemplate restTemplate;
        
            @Autowired
            public TokenServiceImpl(Settings settings, @Qualifier("rstProxy") RestTemplate restTemplate) {
                this.settings= settings;
                this.restTemplate = restTemplate;
            }
        	//...
        	
        }

Application.java

        @SpringBootApplication
        @EnableAsync
        @EnableScheduling
        public class Application extends SpringBootServletInitializer {
        
        	@Autowired
        	private TokenService tokenService; // return null
        
            //.......

@Bean("rstProxy")
	public RestTemplate restTemplateWithProxy() {
		final List<HttpMessageConverter<?>> messageConverters = new ArrayList<>();
		messageConverters.add(new ByteArrayHttpMessageConverter());
		messageConverters.add(new StringHttpMessageConverter());
		messageConverters.add(new ResourceHttpMessageConverter());
		messageConverters.add(new Jaxb2RootElementHttpMessageConverter());
		messageConverters.add(new MappingJackson2HttpMessageConverter());

		final RestTemplate restTemplate = new RestTemplate();

		List<ClientHttpRequestInterceptor> interceptors = new ArrayList<>();
		interceptors.add(new AuthorizationInterceptor(tokenService));
		restTemplate.setInterceptors(interceptors);
		restTemplate.getMessageConverters().addAll(messageConverters);

		restTemplate.setRequestFactory(factory);
		return restTemplate;
	}
        }

Why the TokenService returns null ?
But If I remove the @Qualifier("rstProxy") from my constructor, it works. Do you have a solution ? I need this @qualifier

First: Spring beans are instantiated in no guaranteed order, unless you specify it

@Autowired
@Lazy //this will load Bean when it is requested
private TokenService tokenService;

If above not work then continue and try to refactor your TokenServiceImpl to accept setter method after constructor:

    private RestTemplate restTemplate; 

    public TokenServiceImpl(Settings settings) {
        this.settings= settings;
    }

    @Autowired
    public void setRestTemplate(@Qualifier("rstProxy") RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }

Now TokenService is created without waiting for the RestTemplate.
Then, when the RestTemplate is created, It can inject it into the TokenService via setter method that we created.

@SpringBootApplication itself is not a @Component and no dependencies will be injected into your Application class (it's simply not a bean). You need to explicitly tell Spring that the Application class itself is a bean too:

@Service // <-- register as service in application context
@SpringBootApplication
@EnableAsync
@EnableScheduling
public class Application extends SpringBootServletInitializer {

    @Autowired
    private TokenService tokenService;

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

But I'd recommend using your application only as entry point to start the Spring application, but not take part in it itself.

Another answer, second one:
When you add @Lazy annotation to the RestTemplate bean in the constructor of TokenServiceImpl, it tells to Container to create this bean only when it is first time called, not at the application startup.

  @Autowired
  public TokenServiceImpl(Settings settings, @Lazy @Qualifier("rstProxy") RestTemplate restTemplate) {
    this.settings= settings;
    this.restTemplate = restTemplate;
  }

This above probably make your tokenServiceImpl bean to not be a null.