We Keep Coding

When to use dependency Injection in spring mvc?

I am working on a Spring MVC project where I am dealing with different types of services,Repositories i.e classes annotated with #Service and #Repository. I am confused with a couple of questions:
When to use #AutoWired annotation?
I have seen various repositories using this:
CourseRepository crepo=new CourseRepository();
and I have seen this also
#AutoWired
private CourseRepository crepo;
Which one of the above options should be used to get an instance of
repository in Service class?
Can I use #AutoWired for classes which are not annotated with #Repository or
#Service?
I am a beginner in this java world.Any help will be highly appreciated.
Thanks

You use new for data objects, which in most modern architectures are passive (they're not "active records"). Everything else is a service object, and you should inject those. (The one place that you do use new is with an #Bean method, which is a "factory" that creates the service object; in this case you normally pass the dependencies as method parameters.)
Note that it is recommended to use constructor injection instead of field injection; it makes your code easier to test, and it eliminates the possibility of certain kinds of errors. In fact, if using constructor injection, it's not required to have any Spring annotations in your service classes at all; beans can be registered using #Import instructions or #Bean methods on a configuration class.

You should #Autowire the dependencies instead of instantiating it yourself. Doing so, service and repo layer will be loosely coupled. Moreover, a mock repository can be easily injected in service's JUnit test class if dependency is autowired. To conclude, use below:
#Autowired
private CourseRepository crepo;
A class not annotated with any of below stereotype annotations will not be in Spring's IoC (Inversion of Control) container. Hence, no point in autowiring in a class that is not annotated with any of below annotations.
#Component, #Controller, #Service, #Repository

Dependency injection means that the framework is the one who handles the classes instantiation and the object of that class is going to be injected (thanks to #Autowired annotation) in the class where you need it. In other words, you do not need to instantiate service and repository classes by yourself using new operator, you just need to tell the framework that those classes need to be injected and that's why you use #Autowired annotation.

Spring: #Value vs. #Autowired

I'm having some issues with injection in the application I'm working on (using Spring Version 3.1.2). To start with, I'm seeing a lot of code like this:
#Value("#{searchRequestBean}")
private SearchRequest searchRequest;
#Value("#{searchResponseBean}")
private SearchResponse searchResponse;
#Autowired
private SavedSearchService service;
Each of these three appears to have the effect of autowiring the specified bean/service into the class. What I don't understand is, what's the difference between #Value and #Autowired in these cases? Every example I find online seems to use #Value to inject values from a properties file. In this case, SearchResponse and SearchRequest are abstract classes.
I'm hoping that a better understanding of this will help me solve some issues I'm having with my Session bean.

#Value can be used for injecting default values. A good example is to inject the default of a String to be the value of a property file. In your example, #Value is used to set the default value of a class to be a Spring managed bean.
#Autowired can't be used for the first example: It's not property file aware. #Autowired is only for DI of a bean. It is more specific than #Value, but you can use #Value to do the same thing.
Here is a good tutorial for #Value: http://www.mkyong.com/spring3/spring-value-default-value/

What is the difference between #Inject and #Autowired in Spring Framework? Which one to use under what condition?

I am going through some blogs on SpringSource and in one of the blogs, author is using #Inject and I suppose he can also use #Autowired.
Here is the piece of code:
#Inject private CustomerOrderService customerOrderService;
I am not sure about the difference between #Inject and #Autowired and would appreciate it if someone explained their difference and which one to use under what situation?

Assuming here you're referring to the javax.inject.Inject annotation. #Inject is part of the Java CDI (Contexts and Dependency Injection) standard introduced in Java EE 6 (JSR-299), read more. Spring has chosen to support using the #Inject annotation synonymously with their own #Autowired annotation.
So, to answer your question, #Autowired is Spring's own annotation. #Inject is part of a Java technology called CDI that defines a standard for dependency injection similar to Spring. In a Spring application, the two annotations works the same way as Spring has decided to support some JSR-299 annotations in addition to their own.

Here is a blog post that compares #Resource, #Inject, and #Autowired, and appears to do a pretty comprehensive job.
From the link:
With the exception of test 2 & 7 the configuration and outcomes were
identical. When I looked under the hood I determined that the
‘#Autowired’ and ‘#Inject’ annotation behave identically. Both of
these annotations use the ‘AutowiredAnnotationBeanPostProcessor’ to
inject dependencies. ‘#Autowired’ and ‘#Inject’ can be used
interchangeable to inject Spring beans. However the ‘#Resource’
annotation uses the ‘CommonAnnotationBeanPostProcessor’ to inject
dependencies. Even though they use different post processor classes
they all behave nearly identically. Below is a summary of their
execution paths.
Tests 2 and 7 that the author references are 'injection by field name' and 'an attempt at resolving a bean using a bad qualifier', respectively.
The Conclusion should give you all the information you need.

To handle the situation in which there is no wiring, beans are available with #Autowired required attribute set to false.
But when using #Inject, the Provider interface works with the bean which means that the bean is not injected directly but with the Provider.

The key difference(noticed when reading the Spring Docs) between #Autowired and #Inject is that, #Autowired has the 'required' attribute while the #Inject has no 'required' attribute.

As of Spring 3.0, Spring offers support for JSR-330 dependency injection annotations (#Inject, #Named, #Singleton).
There is a separate section in the Spring documentation about them, including comparisons to their Spring equivalents.

Better use #Inject all the time. Because it is java configuration approach(provided by sun) which makes our application agnostic to the framework. So if you spring also your classes will work.
If you use #Autowired it will works only with spring because #Autowired is spring provided annotation.

#Autowired annotation is defined in the Spring framework.
#Inject annotation is a standard annotation, which is defined in the standard "Dependency Injection for Java" (JSR-330). Spring (since the version 3.0) supports the generalized model of dependency injection which is defined in the standard JSR-330. (Google Guice frameworks and Picocontainer framework also support this model).
With #Inject can be injected the reference to the implementation of the Provider interface, which allows injecting the deferred references.
Annotations #Inject and #Autowired- is almost complete analogies. As well as #Autowired annotation, #Inject annotation can be used for automatic binding properties, methods, and constructors.
In contrast to #Autowired annotation, #Inject annotation has no required attribute. Therefore, if the dependencies will not be found - will be thrown an exception.
There are also differences in the clarifications of the binding properties. If there is ambiguity in the choice of components for the injection the #Named qualifier should be added. In a similar situation for #Autowired annotation will be added #Qualifier qualifier (JSR-330 defines it's own #Qualifier annotation and via this qualifier annotation #Named is defined).

In addition to the above:
The default scope for #Autowired beans is Singleton whereas using JSR 330 #Inject annotation it is like Spring's prototype.
There is no equivalent of #Lazy in JSR 330 using #Inject.
There is no equivalent of #Value in JSR 330 using #Inject.

#Inject has no 'required' attribute

#Autowired(required=false)
By default the dependency injection for #Autowired must be fulfilled because the value of required attribute is true by default. We can change this behavior by using #Autowired(required=false). In this case if bean is not found for dependency injection, it will not through error.
Please have look at
https://www.concretepage.com/spring/spring-autowired-annotation#required-false
But #Inject doesn’t need (required=false) it will not through error if dependency is not found

The #Inject annotation is one of the JSR-330 annotations collection. This has Match by Type,Match by Qualifier, Match by Name execution paths.
These execution paths are valid for both setter and field injection.The behavior of #Autowired annotation is same as the #Inject annotation. The only difference is the #Autowired annotation is a part of the Spring framework. #Autowired annotation also has the above execution paths. So I recommend the #Autowired for your answer.

What is javax.inject.Named annotation supposed to be used for?

I am trying to understand the javax.inject package and I am not clear what the javax.inject.Named annotation is supposed to be used for. The Javadoc does not explain the the idea behind it.
Javadoc is at http://download.oracle.com/javaee/6/api/javax/inject/Named.html
I am using Spring 3.0 to write some sample programs, by putting #Named on a bean it seems to add it to the bean factory but the Javadoc description is so light I can't tell if that is the standard behavior or Spring specific behavior.
My questions are:
What is the difference between #Named and #Qualifier
How are you supposed to tell the Runtime system a class should be injectable in other classes what's the annotation for that? The equivalent of #Component in Spring?
Update 1 there is an excellent explanation of #Named and #Qualifier at Nice article about #Named and #Qualifier https://dzone.com/articles/java-ee6-cdi-named-components thanks #xmedeko for linking to it the comment below.

Use #Named to differentiate between different objects of the same type bound in the same scope.
#Named("maxWaitTime")
public long maxWaitTimeMs;
#Named("minWaitTime")
public long minWaitTimeMs;
Without the #Named qualifier, the injector would not know which long to bind to which variable.
If you want to create annotations that act like #Named, use the #Qualifier annotation when creating them.
If you look at #Named, it is itself annotated with #Qualifier.

#Inject instead of Spring’s #Autowired to inject a bean.
#Named instead of Spring’s #Component to declare a bean.
Those JSR-330 standard annotations are scanned and retrieved the same way as Spring annotation (as long as the following jar is in your classpath)

Regarding #2, according to the JSR-330 spec:
This package provides dependency
injection annotations that enable
portable classes, but it leaves
external dependency configuration up
to the injector implementation.
So it's up to the provider to determine which objects are available for injection. In the case of Spring it is all Spring beans. And any class annotated with JSR-330 annotations are automatically added as Spring beans when using an AnnotationConfigApplicationContext.

The primary role of the #Named annotation is to define a bean for the purpose of resolving EL statements within the application, usually through JSF EL resolvers. Injection can be performed using names but this was not how injection in CDI was meant to work since CDI gives us a much richer way to express injection points and the beans to be injected into them.

How does Wicket's #SpringBean annotation work?

How does Wicket's #SpringBean annotation work? Does it use reflection at run time? Does it make the compiler inject some code? Or what?

#SpringBean works using Wicket's underlying Injector mechanism. When you instantiate a Wicket component, the constructor of Wicket's component base class introspects the class being instantiated, looking for the #SpringBean annotation. If the bean is found, then Wicket generates a proxy for the spring bean and injects it into the component's field. This is Wicket's equivalent of Spring's #Autowired annotation, the effect is similar.
It doesn't, however, have anything to do with Spring's own context/classpath scanning functionality (e.g. #Component), which is about auto-discovery of what is and isn't a bean, rather having anything to do with wiring.

The class marked with a #SpringBean annotation has to have one of:
A no-args constructor
A superclass with a no-args constructor
Implement an interface
An exception will be thrown if these conditions are not met as Wicket will not be able to proxy the class.

Spring uses the class loader and ASM at runtime to find all annotated classes.
You can configure where spring should search for beans:
<context:component-scan base-package="some.package.to.start.from"/>
This uses the ClassPathBeanDefinitionScanner internally which will use the PathMatchingResourcePatternResolver to find the classes and the ASM-based MetadataReader to read the annotations.