Spring学习笔记（9）——注入参数

集合类型属性

1.Set类型

1. private Set<String> sets=new HashSet<String>();
2. //我们需要给它添加set方法
3. public Set<String> getSets()
4. {
5. return sets;
6. }
7. public void setSets(Set<String> sets)
8. {
9. this.sets = sets;
10. }
11. public Set<String> showSet()
12. {
13. return sets;
14. }

然后根据属性修改配置文件

1. <bean id="userService" class="com.szy.spring.service.UserServiceImpl">
2. <property name="sets">
3. <set>
4. <value>Set1</value>
5. <value>Set2</value>
6. <value>Set3</value>
7. </set>
8. </property>
9. </bean>

与以前不同的是我们在property下面添加了<set></set>

这样就能装配set类型的属性

2.List类型

List类型的属性和Set类型的方法一样，主要是把配置文件中的set修改成list。

1. private List<String> lists=new ArrayList<String>();
2. public List<String> getLists()
3. {
4. return lists;
5. }
6. public void setLists(List<String> lists)
7. {
8. this.lists = lists;
9. }
10. public List<String> showList()
11. {
12. return lists;
13. }

配置文件修改如下

1. <bean id="userService"  class="com.szy.spring.service.UserServiceImpl">
2. <property name="lists">
3. <list>
4. <value>List1</value>
5. <value>List2</value>
6. <value>List3</value>
7. </list>
8. </property>
9. </bean>

3.Properties类型

1. private Properties properties=new Properties();
2. public void setProperties(Properties properties)
3. {
4. this.properties = properties;
5. }
6. public Properties getProperties()
7. {
8. return properties;
9. }
10. public Properties showProperties()
11. {
12. return properties;
13. }

配置文件需要如下配置

1. <bean id="userService" class="com.szy.spring.service.UserServiceImpl">
2. <property name="properties">
3. <props>
4. <prop key="key1">Properties1</prop>
5. <prop key="key2">Properties2</prop>
6. <prop key="key3">Properties3</prop>
7. </props>
8. </property>
9. </bean>

4.Map类型

1. private Map<String, String> maps=new HashMap<String, String>();
2. public List<String> getLists()
3. {
4. return lists;
5. }
6. public void setLists(List<String> lists)
7. {
8. this.lists = lists;
9. }
10. public Map<String, String> showMaps()
11. {
12. return maps;
13. }

配置文件做相应的配置

1. <bean id="userService" class="com.szy.spring.service.UserServiceImpl">
2. lt;property name="maps">
3. <map>
4. <entry key="key1" value="Map1"></entry>
5. <entry key="key2" value="Map2"></entry>
6. <entry key="key3" value="Map3"></entry>
7. </map>
8. </property>
9. </bean>

这样就完成了对Map类型的属性进行装配。

Spring完成自动扫描和管理bean

在前面的例子中，都是使用XML的bean定义来使用组件，在大的项目中，通常会有上百个组件，如果这些组件采用xml的bean定义来配置，显然会使配置文件显得很臃肿，查找和维护起来不方便。Spring2.5为我们引入了组件自动扫描机制，它可以在类路径下寻找标记了@Component、@Service、@Controller、@Repository注解的类，并把这些类纳入到spring容器中管理，它的作用和在xml中使用bean节点配置组件一样。要使用自动扫描机制，我们需要把配置文件如下配置：

1. <?xml version="1.0" encoding="UTF-8"?>
2. <beans xmlns="http://www.springframework.org/schema/beans"
3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4. xmlns:context="http://www.springframework.org/schema/context"
5. xmlns:tx="http://www.springframework.org/schema/tx"
6. xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
7. http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
8. http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">
9. <context:component-scan base-package="com.szy.spring"></context:component-scan>
10. </beans>

其中base-package为需要扫描的包（包括子包）

@Service用于标注业务层的组件，@Controller用于标注控制层组件（如struts中的action），@Repository用于标注数据访问组件，即DAO组件，而@Component泛指组件，当组件不好归类的时候，我们可以使用这个注解进行标注。但是在目前的spring版本中，这几个注解的作用是一样的，但是在以后可能会进行区分。

下面把先前的例子修改一下：

首先是PersonDaoBean类，修改如下

1. package com.szy.spring.dao;
2. import org.springframework.stereotype.Repository;
3. @Repository
4. //告诉spring这个类要交给spring管理，
5. public class PersonDaoBean implements PersonDao
6. {
7. public void show()
8. {
9. System.out.println("执行PersonDaoBean中的add()方法");
10. }
11. }

然后是UserServiceImpl类

1. package com.szy.spring.service;
2. import org.springframework.stereotype.Service;
3. import com.szy.spring.dao.PersonDao;
4. @Service
5. //把这个类交给spring管理，作为服务了。
6. public class UserServiceImpl implements UserService
7. {
8. private PersonDao personDaoBean;
9. public void show()
10. {
11. personDaoBean.show();
12. }
13. public void setPersonDaoBean(PersonDao personDaoBean)
14. {
15. this.personDaoBean = personDaoBean;
16. }
17. public PersonDao getPersonDaoBean()
18. {
19. return personDaoBean;
20. }
21. }

下面我们进行测试，原来的测试代码是userServiceImpl

1. ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext.xml");
2. UserService service=(UserService)ctx.getBean("userService");
3. service.show();

其中userService是我们在配置文件中配置的bean的id。但是如今我们并没有id这个属性，在spring2.5中，默认的id是类的名称，但是开后是小写，也就是userServiceImpl，因此测试代码应修改如下：

1. AbstractApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext.xml");
2. UserService service=(UserService)ctx.getBean("userServiceImpl");
3. System.out.println(service);

如果我们想自己命名的话，则只需在注解后加上括号，里面写入你希望的名字，如

@Service("userService")。

在spring中默认的是之生成一个bean实例，如果我们想每次调用都产生一个实例，则标注需如下配置

@Service @Scope("prototype")

在xml中我们还可以配置初始化方法和销毁方法，使用标注后只需如下标注

1. @PostConstruct
2. public void init()
3. {
4. System.out.println("初始化");
5. }
6. @PreDestroy
7. public void destory()
8. {
9. System.out.println("销毁");
10. }

使用注解后，我们的xml文件变得十分简单，因此建议大家在以后的开发中使用注解。

http://blog.csdn.net/u011225629/article/details/45459995