原文地址：http://techidiocy.com/annotation-config-vs-component-scan-spring-core/
<context:annotation-config> and <context:component-scan> are two of the most basic concepts available in the Spring Core introduced in Spring 3 that every Spring user should understand.It is important that to understand the usage of each of them and how they are different to each other.
annotation-config : Annotation config main job is to activate all the annotations that are present in java beans and those are already registered either by defining in your application context file or being registered while component scanning. Important point is they need to be registered.
component-scan : Component scan can do everything that annotation config does , in addition to it it also registers the java classes as spring bean those are annotated with @Component , @Service ,@Repository etc.
Let’s see an example that can clear the difference in annotation-config vs component-scan in much more simpler way –
I have three java classes that I have declared in my application context.
SuperUser.java:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
package com.lotusmedia.typesuper;
import com.lotusmedia.typenormal.NormalUser;
import com.lotusmedia.typenormal.TempUser;
public class SuperUser {
private NormalUser normalUser;
private TempUser tempUser;
public SuperUser(){
System.out.println("Super User Created ->"+this);
}
public void setNormalUser(NormalUser normalUser) {
System.out.println("Setting Normal User ->"+normalUser);
this.normalUser = normalUser;
}
public void setTempUser(TempUser tempUser) {
System.out.println("Setting Temp User ->"+tempUser);
this.tempUser = tempUser;
}
} |
NormalUser.java :
|
1
2
3
4
5
6
7
8
|
package com.lotusmedia.typenormal;
public class NormalUser {
public NormalUser(){
System.out.println("Normal User Created->"+this);
}
} |
TempUser.java :
|
1
2
3
4
5
6
7
8
|
package com.lotusmedia.typenormal;
public class TempUser {
public TempUser(){
System.out.println("Temporary User Created->"+this);
}
} |
Now here is my application context file where I am injecting normalUser and TempUser into SuperUser.
applicationContext.xml
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="
">
<bean id="normalUser" class="com.lotusmedia.typenormal.NormalUser"></bean>
<bean id="tempUser" class="com.lotusmedia.typenormal.TempUser"></bean>
<bean id="superUser" class="com.lotusmedia.typesuper.SuperUser">
<property name="normalUser" ref="normalUser"></property>
<property name="tempUser" ref="tempUser"></property>
</bean>
</beans>
|
And here is the executor class.
Executor.java :
|
1
2
3
4
5
6
7
8
9
10
11
|
package com.lotusmedia.run;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Executor {
public static void main(String args[]){
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
}
} |
Now when I executed this program I got output like this in my console and it is what we were expecting.
|
1
2
3
4
5
|
Normal User Created->com.lotusmedia.typenormal.NormalUser@75e845c2Temporary User Created->com.lotusmedia.typenormal.TempUser@1cec6b00Super User Created ->com.lotusmedia.typesuper.SuperUser@6564dbd5Setting Normal User ->com.lotusmedia.typenormal.NormalUser@75e845c2Setting Temp User ->com.lotusmedia.typenormal.TempUser@1cec6b00 |
Till now everything is good and as expected. Now lets do some modifications and introduce annotations in our beans. So , I have modified SuperUser.java to use annotations for wiring the properties.(notice the autowired annotation).
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
|
package com.lotusmedia.typesuper;
import org.springframework.beans.factory.annotation.Autowired;
import com.lotusmedia.typenormal.NormalUser;
import com.lotusmedia.typenormal.TempUser;
public class SuperUser {
private NormalUser normalUser;
private TempUser tempUser;
public SuperUser(){
System.out.println("Super User Created ->"+this);
}
@Autowired
public void setNormalUser(NormalUser normalUser) {
System.out.println("Setting Normal User ->"+normalUser);
this.normalUser = normalUser;
}
@Autowired
public void setTempUser(TempUser tempUser) {
System.out.println("Setting Temp User ->"+tempUser);
this.tempUser = tempUser;
}
} |
And from configuration file I have removed the properties injection, so now my context file looks like this.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="
">
<bean id="normalUser" class="com.lotusmedia.typenormal.NormalUser"></bean>
<bean id="tempUser" class="com.lotusmedia.typenormal.TempUser"></bean>
<bean id="superUser" class="com.lotusmedia.typesuper.SuperUser"></bean>
</beans>
|
Now I have executed my Executor class again and here is the output.
|
1
2
3
|
Normal User Created->com.lotusmedia.typenormal.NormalUser@4cc39a20Temporary User Created->com.lotusmedia.typenormal.TempUser@485fcf29Super User Created ->com.lotusmedia.typesuper.SuperUser@a19b1de |
This time you will see that properties injection didn’t take place only the new beans were created, now you might be wondering why it didn’t happen as we had marked those properties with the Autowired annotation. So, here is answer , in spring by default annotations don’t do anything by themselves , if you want to use them you have to enable them in your application.
Now enabling annotations in spring is very simple and you have to add only one line of code in your context file to enable them and here is the magic line.
|
1
|
<context:annotation-config/>
|
Updated applicationContext file :
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="
">
<context:annotation-config/>
<bean id="normalUser" class="com.lotusmedia.typenormal.NormalUser"></bean>
<bean id="tempUser" class="com.lotusmedia.typenormal.TempUser"></bean>
<bean id="superUser" class="com.lotusmedia.typesuper.SuperUser"></bean>
</beans>
|
Now this time when I executed the Executor class again , below is the output that I got and this is what we were expecting.
|
1
2
3
4
5
|
Normal User Created->com.lotusmedia.typenormal.NormalUser@679bfb30Temporary User Created->com.lotusmedia.typenormal.TempUser@7977b9bSuper User Created ->com.lotusmedia.typesuper.SuperUser@37fd6beaSetting Normal User ->com.lotusmedia.typenormal.NormalUser@679bfb30Setting Temp User ->com.lotusmedia.typenormal.TempUser@7977b9b |
So,till now all good, let’s play more now I am going to remove the bean declarations from the Xml file and use @Component annotation to register it as a bean.Here are the updated files.
applicationContext.xml :
|
1
2
3
4
5
6
7
8
9
10
11
12
|
xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="
">
<context:annotation-config/>
</beans>
|
SuperUser.java : (notice the @Component annotation)
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
|
package com.lotusmedia.typesuper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import com.lotusmedia.typenormal.NormalUser;
import com.lotusmedia.typenormal.TempUser;
@Componentpublic class SuperUser {
private NormalUser normalUser;
private TempUser tempUser;
public SuperUser(){
System.out.println("Super User Created ->"+this);
}
@Autowired
public void setNormalUser(NormalUser normalUser) {
System.out.println("Setting Normal User ->"+normalUser);
this.normalUser = normalUser;
}
@Autowired
public void setTempUser(TempUser tempUser) {
System.out.println("Setting Temp User ->"+tempUser);
this.tempUser = tempUser;
}
} |
NormalUser.java :
|
1
2
3
4
5
6
7
8
9
10
11
|
package com.lotusmedia.typenormal;
import org.springframework.stereotype.Component;
@Componentpublic class NormalUser {
public NormalUser(){
System.out.println("Normal User Created->"+this);
}
} |
TempUser.java :
|
1
2
3
4
5
6
7
8
9
10
11
|
package com.lotusmedia.typenormal;
import org.springframework.stereotype.Component;
@Componentpublic class TempUser {
public TempUser(){
System.out.println("Temporary User Created->"+this);
}
} |
Now when I executed my Executor class again , this time nothing happened no new bean has been created and no properties has been injected. This is what we were expecting right ? as annotation-config is not suffice and can’t register beans marked with @Component annotation. So , here comes the component scan in play , what it will do , it will scan all the packages provided as an argument to it and will register all the beans marked @Component annotation , and once the bean is registered it annotation-config will inject them.
Now you might be thinking why we need annotation-config when we already have component-scan in our context file ,yes you are thinking in right dierction, as I have already said that component scan can do everything what annotation config does.So, we can safely remove annotation-config from our configuration file and can add component-scan there. So. here is my updated applicationContext file.
|
1
2
3
4
5
6
7
8
9
10
11
12
|
xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="
">
<context:component-scan base-package="com.lotusmedia.typenormal,com.lotusmedia.typesuper"/>
</beans>
|
Now when i executed my Executor class again I got the below mentioned output as we were expecting , all the 3 beans have been created and been injected properly.
|
1
2
3
4
5
|
Super User Created ->com.lotusmedia.typesuper.SuperUser@426295ebNormal User Created->com.lotusmedia.typenormal.NormalUser@207f5580Setting Normal User ->com.lotusmedia.typenormal.NormalUser@207f5580Temporary User Created->com.lotusmedia.typenormal.TempUser@4f4db0e3Setting Temp User ->com.lotusmedia.typenormal.TempUser@4f4db0e3 |
I hope this example has clarified most of the confusion between annotation-config vs component-scan , if you still have any doubt/question please feel free to drop me a comment, I will be more than happy to answer you.