I am working on spring batch with spring boot 2.X application, actually its existing code i am checked out from git. While running the application it fails due to below error only for me and same code is working for others.

    s.c.a.AnnotationConfigApplicationContext : Exception encountered during context initialization - cancelling refresh attempt: org.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean with name &#39;inputItemReader&#39; defined in file [C:\Users\XYZ\git\main\batch\CBatchProcessing\target\classes\com\main\batchprocessing\batch\reader\InputItemReader.class]: Unsatisfied dependency expressed through **constructor parameter 0; nested exception is org.springframework.beans.factory.NoSuchBeanDefinitionException: No qualifying bean of type &#39;java.lang.String&#39; available: expected at least 1 bean which qualifies as autowire candidate. Dependency annotations**: {}
    
    
    Error starting ApplicationContext. To display the conditions report re-run your application with &#39;debug&#39; enabled.
    2018-10-16 23:23:37.411 ERROR 2384 --- [           main] o.s.b.d.LoggingFailureAnalysisReporter   : 
    
    ***************************
    APPLICATION FAILED TO START
    ***************************
    
    Description:
    
    **Parameter 0 of constructor in com.main.batchprocessing.batch.reader.InputItemReader required a bean of type &#39;java.lang.String&#39; that could not be found.**
    
    
    Action:
    
    Consider defining a bean of type &#39;java.lang.String&#39; in your configuration.

I have checked below 

1. All Spring components are correctly annotated with @Component, @Service, @Controller,@Repository, etc...
2. @ComponentScan &amp; @EnableAutoCOnfiguration is also provided.
3. Tried giving &quot;java.lang.String&quot; in declarations.

Code:

        import java.util.Map;
        import org.slf4j.Logger;
        import org.slf4j.LoggerFactory;
        import org.springframework.batch.core.ExitStatus;
        import org.springframework.batch.core.StepExecution;
        import org.springframework.batch.core.StepExecutionListener;
        import org.springframework.batch.item.file.FlatFileItemReader;
        import org.springframework.batch.item.file.mapping.JsonLineMapper;
        import 
        org.springframework.batch.item.file.separator.JsonRecordSeparatorPolicy;
        import org.springframework.beans.factory.annotation.Autowired;
        import org.springframework.context.annotation.Bean;
        import org.springframework.core.io.FileSystemResource;
        import org.springframework.stereotype.Component;
    
        @Component
        public class InputItemReader extends  FlatFileItemReader&lt;Map&lt;String, 
         Object&gt;&gt; implements StepExecutionListener {
    
    	@Autowired
    	private InputFileHeaderValidator inputFileHeaderValidator; 
    
    	@Autowired
    	private FileAuditService fileAuditService;
    
    	private final Logger log = 
        LoggerFactory.getLogger(InputItemReader.class);
    	
    	private java.lang.String inputFilePath;
     
    	public InputItemReader(String inputFilePath) {
    		setLineMapper(new JsonLineMapper());
    		setRecordSeparatorPolicy(new JsonRecordSeparatorPolicy());
    		setResource(new FileSystemResource(inputFilePath));
    		this.inputFilePath = inputFilePath;
    	}
       }


Parameter 0 of constructor in required a bean of type &#39;java.lang.String&#39; that could not be found

I&#39;m using Spring 3.0.5 and am using @Autowire annotation for my class members as much as possible.  One of the beans that I need to autowire requires arguments to its constructor.  I&#39;ve looked through the Spring docs, but cannot seem to find any reference to how to annotate constructor arguments.

In XML, I can use &lt;constructor-args&gt; as part of the bean definition.  Is there a similar mechanism for @Autowire annotation?

Ex:

    @Component
    public class MyConstructorClass{
    
      String var;
      public MyConstructorClass( String constrArg ){
        this.var = var;
      }
    ...
    }
    
    
    @Service
    public class MyBeanService{
      @Autowired
      MyConstructorClass myConstructorClass;
    
      ....
    }


In this example, how do I specify the value of &quot;constrArg&quot; in MyBeanService with the @Autowire annotation?  Is there any way to do this?

Thanks,

Eric



Is there a way to @Autowire a bean that requires constructor arguments?

I&#39;m currently using the @Value Spring 3.1.x annotation like this:

    @Value(&quot;${stuff.value:}&quot;)
    private String value;

This puts an empty String into the variable if the attribute is not present. I would like to have null as the default instead of an empty String. Of course I also want to avoid an error when the property stuff.value is not set.

Can I set null as the default value for a @Value in Spring?

In the following example, the `ScriptFile` parameter is marked with an `@Valid` annotation.

What does `@Valid` annotation do?

    @RequestMapping(value = &quot;/scriptfile&quot;, method = RequestMethod.POST)    
    public String create(@Valid ScriptFile scriptFile, BindingResult result, ModelMap modelMap) {    
        if (scriptFile == null) throw new IllegalArgumentException(&quot;A scriptFile is required&quot;);        
        if (result.hasErrors()) {        
            modelMap.addAttribute(&quot;scriptFile&quot;, scriptFile);            
            modelMap.addAttribute(&quot;showcases&quot;, ShowCase.findAllShowCases());            
            return &quot;scriptfile/create&quot;;            
        }        
        scriptFile.persist();        
        return &quot;redirect:/scriptfile/&quot; + scriptFile.getId();        
    }    



What does the @Valid annotation indicate in Spring?

I have a bean `Item&lt;T&gt;` which is required to be autowired in a `@Configuration` class.

    @Configuration
    public class AppConfig {
    
        @Bean
        public Item&lt;String&gt; stringItem() {
            return new StringItem();
        }
    
        @Bean
        public Item&lt;Integer&gt; integerItem() {
            return new IntegerItem();
        }
    
    }

But when I try to `@Autowire Item&lt;String&gt;`, I get following exception.

    &quot;No qualifying bean of type [Item] is defined: expected single matching bean but found 2: stringItem, integerItem&quot;

How should I Autowire generic type `Item&lt;T&gt;` in Spring?

How to Autowire Bean of generic type &lt;T&gt; in Spring?

How can I inject values into a Map from the properties file using the @Value annotation in Spring?

My Spring Java class is and I tried using the $, but got the following error message:

&gt; Could not autowire field: private java.util.Map Test.standard; nested exception is java.lang.IllegalArgumentException: Could not resolve placeholder &#39;com.test.standard&#39; in string value &quot;${com.test.standard}&quot;

    @ConfigurationProperty(&quot;com.hello.foo&quot;)
    public class Test {
    
       @Value(&quot;${com.test.standard}&quot;)
       private Map&lt;String,Pattern&gt; standard = new LinkedHashMap&lt;String,Pattern&gt;

       private String enabled;
    
    }

I have the following properties in a .properties file

    com.test.standard.name1=Pattern1
    com.test.standard.name2=Pattern2
    com.test.standard.name3=Pattern3
    com.hello.foo.enabled=true

How to inject a Map using the @Value Spring Annotation?

Currently I have this :

    @Scheduled(fixedRate=5000)
    public void getSchedule(){
       System.out.println(&quot;in scheduled job&quot;);
    }

I could change this to use a reference to a property

    @Scheduled(fixedRateString=&quot;${myRate}&quot;)
    public void getSchedule(){
       System.out.println(&quot;in scheduled job&quot;);
    }

However I need to use a value obtained programmatically so the schedule can be changed without redeploying the app. What is the best way? I realize using annotations may not be possible... 

Scheduling a job with Spring programmatically (with fixedRate set dynamically)

Is there a simple way I can easily override an autowired bean in specific unit tests? There is only a single bean of every type in the compile classes so it&#39;s not a problem for autowiring in this case. The test classes would contain additional mocks. When running a unit test I&#39;d simply like to specify an additional Configuration that says basically, while running this unit test use this mock instead of the standard bean.

Profiles seem a bit overkill for what I require and I&#39;m not sure this would be achievable with the Primary annotation as different unit test could have different mocks.

Overriding an Autowired Bean in Unit Tests

This is continuation of question
https://stackoverflow.com/questions/3526523/spring-mvc-pathvariable-getting-truncated

Spring forum states that it has fixed(3.2 version) as part of ContentNegotiationManager. see the below link.&lt;BR&gt;
https://jira.springsource.org/browse/SPR-6164
&lt;BR&gt;
https://jira.springsource.org/browse/SPR-7632

In my application requestParameter with .com is truncated.

Could anyone explain me how to use this new feature? how is it configurable at xml?

Note: [spring forum- #1
Spring MVC @PathVariable with dot (.) is getting truncated][1]


  


  [1]: http://forum.springsource.org/showthread.php?137000-Spring-MVC-PathVariable-with-dot-(-)-is-getting-truncated&amp;p=444607#post444607

Spring MVC @PathVariable with dot (.) is getting truncated

What is the proper annotation since `@SpringApplicationConfiguration` and `@WebIntegration` are deprecated as of Spring Boot Framework 1.4?  I&#39;m trying to play around with unit testing.


What is the proper annotation since @SpringApplicationConfiguration, @WebIntegration, is deprecated in Spring Boot Framework?

for example I have a method in my CRUD interface which deletes a user from the database:

    public interface CrudUserRepository extends JpaRepository&lt;User, Integer&gt; {

        @Transactional
        @Modifying
        @Query(&quot;DELETE FROM User u WHERE u.id=:id&quot;)
        int delete(@Param(&quot;id&quot;) int id, @Param(&quot;userId&quot;) int userId);
    }
This method will work only with the annotation @Modifying. But what is the need for the annotation here? Why cant spring analyze the query and understand that it is a modifying query?

why do we have to use @Modifying annotation for queries in Data Jpa

I am using jsf and spring together in web application. I have configured datasource and session factory in one configuration class which uses annotations like `@Configuration, @ComponentScan` etc. **I don&#39;t have any applicationContext.xml file in my project** as I am handling every entry of context xml in Configuration class. The test case works successfully but when I deploy my web application, it gives me error 

&gt; java.lang.IllegalStateException: No WebApplicationContext found: no
&gt; ContextLoaderListener registered?

Now if I give listener class in web.xml,

    &lt;listener&gt;
            &lt;listener-class&gt;org.springframework.web.context.ContextLoaderListener&lt;/listener-class&gt;
    &lt;/listener&gt;

it gives me error, 

&gt; /WEB-INF/applicationContext.xml not found

As per the document of `ContextLoaderListener`, it&#39;s true that if I don&#39;t give `contextConfigLocation` param in `web.xml` explicitly, it will search for the default spring context file named `applicationContext.xml` in `web.xml`. Now, what should I do if I don&#39;t want to use spring context file and do all the configuration with annotations? How should I register listener class `ContextLoaderListener` so that without use of xml file and using annotations only, I be able to run my web application with spring and jsf?

How to register Spring @Configuration annotated class instead of applicationContext.xml file in web.xml?

I&#39;m new to Spring MVC. Please help me unpack the documentation.

**Documentation**

[Spring MVC Documentation][1] states (emphasis mine):

- `@ModelAttribute` on a method argument indicates the argument should be retrieved from the model. If not present in the model, the argument should be instantiated first and then added to the model. Once present in the model, **the argument’s fields should be populated from all request parameters that have matching names**. The WebDataBinder class matches request parameter names — including query string parameters and form fields — to model attribute fields by name. 

- `@RequestParam` **binds request parameters to a method parameter** in your controller.

**Disclaimer / Clarifier**

I know that `@ModelAttribute` and `@RequestParam` are not the same thing, are not mutually exclusive, do not perform the same role, and can be used simultaneously, as in [this question][2] - indeed, `@RequestParam` can be used to populate fields of `@ModelAttribute`. My question is more geared towards the difference between their internal workings.

**Question:**

What is the difference between `@ModelAttribute` (used on a method argument, not method) and `@RequestParam`? Specifically:

- **Source:** Do `@RequestParam` and `@ModelAttribute` have the same source of
   information / population, i.e. request parameters in URL, which may have been supplied as elements of a form / model that was `POST`ed? 
- **Usage:** Is it correct that variables retrieved with `@RequestParam` are thrown away (unless passed into a model), whereas variables retrieved with `@ModelAttribute` are automatically fed into the model to be returned?

Or in very basic coding examples, what is the real working difference between these two examples?

Example 1: `@RequestParam`:
 
    // foo and bar are thrown away, and are just used (e.g.) to control flow?
    @RequestMapping(method = RequestMethod.POST)
    public String testFooBar(@RequestParam(&quot;foo&quot;) String foo,
    @RequestParam(&quot;bar&quot;) String bar, ModelMap model) {
        try {
         doStuff(foo, bar);
        }
        // other code
      }

Example 2: `@ModelAttribute`:

    // FOOBAR CLASS
    // Fields could of course be explicitly populated from parameters by @RequestParam
    public class FooBar{
        private String foo;
        private String bar;
       // plus set() and get() methods
    }

    // CONTROLLER
    // Foo and Bar become part of the model to be returned for the next view?
    @RequestMapping(method = RequestMethod.POST)
    public String setupForm(@ModelAttribute(&quot;fooBar&quot;) FooBar foobar) {
       String foo = fooBar.getFoo();
       String bar = fooBar.getBar();
       try {
          doStuff(foo, bar);
       }
       // other code
    }


----------
**My current understanding:**

`@ModelAttribute` and `@RequestParam` both interrogate the request parameters for information, but they use this information differently:

 - `@RequestParam` just populates stand-alone variables (which may of course be fields in a `@ModelAttribute` class). These variables will be thrown away when the Controller is done, unless they have been fed into the model.

 - `@ModelAttribute` populates the fields of a class, which then populates an attribute of the model to be passed back to the view



Is this correct?

  [1]: http://docs.spring.io/spring/docs/current/spring-framework-reference/html/mvc.html
  [2]: https://stackoverflow.com/questions/11268470/how-to-pass-requestparam-and-modelattribute-in-one-form
  [3]: https://stackoverflow.com/questions/8652074/what-exactly-is-requestparam-and-how-does-it-get-populated 

Spring MVC: please explain difference between @RequestParam and @ModelAttribute

I&#39;m trying to write a Unit Test for a simple bean that&#39;s used in my program to validate forms. The bean is annotated with `@Component` and has a class variable that is initialized using 

    @Value(&quot;${this.property.value}&quot;) private String thisProperty;

I would like to write unit tests for the validation methods inside this class, however, if possible I would like to do so without utilizing the properties file. My reasoning behind this, is that if the value I&#39;m pulling from the properties file changes, I would like that to not affect my test case. My test case is testing the code that validates the value, not the value itself. 

Is there a way to use Java code inside my test class to initialize a Java class and populate the Spring @Value property inside that class then use that to test with?

I did find this [How To][1] that seems to be close, but still uses a properties file. I would rather it all be Java code.

  [1]: https://gist.github.com/danlangford/3418696

All Spring Annotations Solutions on Gang of Coders

Total of 14 Spring Annotations Solutions

Parameter 0 of constructor in required a bean of type 'java.lang.String' that could not be found