Spring依赖注入 --- 简单使用说明

Spring依赖注入 --- 简单使用说明

本文将对spring依赖注入的使用做简单的说明，enjoy your time！

1.使用Spring提供的依赖注入

对spring依赖注入的实现方法感兴趣的同学可以参考我的日志：http://www.cnblogs.com/kodoyang/p/Frame_Imitate_Spring.html

我们会用spring提供的ClassPathXmlApplicationContext实现来代替这篇日志中相应的实现

为导入的jar文件配置api
对应的Library的jar上右键，选择properties>JavadocLocation
鼠标停留在对应的类上，按F1就可以看到对应的api文档

ClassPathXmlApplicationContext实现了接口ApplicationContext；接口ApplicationContext继承了BeanFactory的接口
ApplicationContext可以使用的方法更多，所以一般用ApplicationContext

下面是详细的代码：

/Spring_IOC/src/yuki/spring/ioc/pojo/User.java

package yuki.spring.ioc.pojo;

public class User {

    private String username;
    private String password;

    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }

}

/Spring_IOC/src/yuki/spring/ioc/dao/UserDAO.java

package yuki.spring.ioc.dao;

import yuki.spring.ioc.pojo.User;

public interface UserDAO {

    void save(User u);
}

/Spring_IOC/src/yuki/spring/ioc/dao/impl/UserDAOImpl.java

package yuki.spring.ioc.dao.impl;

import yuki.spring.ioc.dao.UserDAO;
import yuki.spring.ioc.pojo.User;

public class UserDAOImpl implements UserDAO {

    private int daoId;
    private String daoStatus;

    public int getDaoId() {
        return daoId;
    }
    public void setDaoId(int daoId) {
        this.daoId = daoId;
    }
    public String getDaoStatus() {
        return daoStatus;
    }
    public void setDaoStatus(String daoStatus) {
        this.daoStatus = daoStatus;
    }

    @Override
    public void save(User u) {
        System.out.println(daoId + ", " + daoStatus);
        System.out.println("user saved...");
    }
}

/Spring_IOC/src/yuki/spring/ioc/service/UserService.java

package yuki.spring.ioc.service;

import yuki.spring.ioc.dao.UserDAO;
import yuki.spring.ioc.pojo.User;

public class UserService {

    private UserDAO userDAO;

    public UserService(UserDAO userDAO) {
        this.userDAO = userDAO;
    }

    public void add(User u){
        this.userDAO.save(u);
    }
}

/Spring_IOC/src/beans.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
                    http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="userDAO" class="yuki.spring.ioc.dao.impl.UserDAOImpl">
        <property name="daoId" value="6"></property>
        <property name="daoStatus" value="good"></property>
    </bean>

    <bean id="userService" class="yuki.spring.ioc.service.UserService">
        <!-- <property name="userDAO" ref="userDAO"></property> -->
        <constructor-arg ref="userDAO"></constructor-arg>
    </bean>
</beans>

/Spring_IOC/test/yuki/spring/ioc/service/UserServiceTest.java

package yuki.spring.ioc.service;

import org.junit.Test;
//import org.springframework.beans.factory.BeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import yuki.spring.ioc.pojo.User;

public class UserServiceTest {

    @Test
    public void testAdd() {
        @SuppressWarnings("resource")
//      BeanFactory applicationContext = new ClassPathXmlApplicationContext("beans.xml");
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
        UserService userService = (UserService) applicationContext.getBean("userService");
        User u = new User();
        u.setUsername("username");
        u.setPassword("password");
        userService.add(u);
    }

}

运行结果如下：

八月 31, 2014 9:04:55 上午 org.springframework.context.support.ClassPathXmlApplicationContext prepareRefresh
信息: Refreshing org[email protected]3a439b: startup date [Sun Aug 31 09:04:55 CST 2014]; root of context hierarchy
八月 31, 2014 9:04:55 上午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
信息: Loading XML bean definitions from class path resource [beans.xml]
6, good
user saved...

控制反转：把具体的实现反转到了抽象的接口概念上；依赖注入：面向的是接口，注入它的实现

setter注入和构造方法注入，当有多个参数时可以定义索引或类型；可以把简单属性的值放在配置文件中，这很少用

2.Bean的生存范围、自动编织

bean的scope属性可以接受的字面值：singleton、prototype、request、session、global session、application
明显是和Web相关的，默认情况下是singleton

在添加XML Catalog Element后，在key后填写文件名

在上下文环境中，取出相同的bean，它们指向同一个对象
在bean上添加属性scope="prototype"，prototype的意思是原型，取出来的对象是原型的复制品
如果bean是接收用户请求的action，scope应该设成prototype

/Spring_Scope/src/singleton.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
                        http://www.springframework.org/schema/beans/spring-beans-4.0.xsd ">

    <!-- <bean id="userService" class="yuki.spring.ioc.scope.singleton.UserService"></bean> -->
    <bean id="userService" class="yuki.spring.ioc.scope.UserService" scope="prototype"></bean>

</beans>

/Spring_Scope/src/yuki/spring/ioc/scope/UserService.java

package yuki.spring.ioc.scope;

public class UserService {

}

/Spring_Scope/src/yuki/spring/ioc/scope/ScopeTest.java

package yuki.spring.ioc.scope;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class ScopeTest {

    @Test
    public void testSingleton() {
        @SuppressWarnings("resource")
        ApplicationContext context = new ClassPathXmlApplicationContext("singleton.xml");
        UserService userService = (UserService) context.getBean("userService");
        UserService userService2 = (UserService) context.getBean("userService");
        System.out.println(userService == userService2);
    }

}

运行结果如下：

八月 31, 2014 9:34:53 上午 org.springframework.context.support.ClassPathXmlApplicationContext prepareRefresh
信息: Refreshing org[email protected]265ba4: startup date [Sun Aug 31 09:34:53 CST 2014]; root of context hierarchy
八月 31, 2014 9:34:54 上午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
信息: Loading XML bean definitions from class path resource [singleton.xml]
false

集合装配：set、list、map

/Spring_Scope/src/collections.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
                        http://www.springframework.org/schema/beans/spring-beans-4.0.xsd ">

    <bean id="userDao" class="yuki.spring.ioc.collections.UserDao">
        <property name="sets">
            <set>
                <value>1</value>
                <value>2</value>
            </set>
        </property>
        <property name="lists">
            <list>
                <value>3</value>
                <value>4</value>
                <value>5</value>
            </list>
        </property>
        <property name="maps">
            <map>
                <entry key="6" value="six"></entry>
                <entry key="7" value="seven"></entry>
                <entry key="8" value="eight"></entry>
            </map>
        </property>
    </bean>

</beans>

/Spring_Scope/src/yuki/spring/ioc/collections/UserDao.java

package yuki.spring.ioc.collections;

import java.util.List;
import java.util.Map;
import java.util.Set;

public class UserDao {

    private Set<String> sets;
    private List<String> lists;
    private Map<String, String> maps;

    public Set<String> getSets() {
        return sets;
    }
    public void setSets(Set<String> sets) {
        this.sets = sets;
    }
    public List<String> getLists() {
        return lists;
    }
    public void setLists(List<String> lists) {
        this.lists = lists;
    }
    public Map<String, String> getMaps() {
        return maps;
    }
    public void setMaps(Map<String, String> maps) {
        this.maps = maps;
    }

}

/Spring_Scope/src/yuki/spring/ioc/collections/CollectionsTest.java

package yuki.spring.ioc.collections;

import java.lang.reflect.Method;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class CollectionsTest {

    @Test
    @SuppressWarnings("unchecked")
    public void testCollection() throws Exception{
        @SuppressWarnings("resource")
        ApplicationContext context = new ClassPathXmlApplicationContext("collections.xml");
        UserDao userDao = (UserDao) context.getBean("userDao");

        Method[] methods = userDao.getClass().getMethods();
        for(Method method : methods){
            switch(method.getName()){
            case "getMaps":
                Map<String, String> map =  (Map<String, String>) method.invoke(userDao, new Object[0]);
                for(Map.Entry<String, String> entry : map.entrySet())
                    System.out.println("map::" + entry.getKey() + " -> " + entry.getValue());
                break;
            case "getSets":
                Set<String> set = (Set<String>) method.invoke(userDao, new Object[0]);
                for(String s : set)
                    System.out.println("set::" + s);
                break;
            case "getLists":
                List<String> list = (List<String>) method.invoke(userDao, new Object[0]);
                for(String s : list)
                    System.out.println("list::" + s);
                break;
            }
        }
    }
}

运行结果如下：

八月 31, 2014 9:36:12 上午 org.springframework.context.support.ClassPathXmlApplicationContext prepareRefresh
信息: Refreshing org[email protected]265ba4: startup date [Sun Aug 31 09:36:12 CST 2014]; root of context hierarchy
八月 31, 2014 9:36:12 上午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
信息: Loading XML bean definitions from class path resource [collections.xml]
set::1
set::2
map::6 -> six
map::7 -> seven
map::8 -> eight
list::3
list::4
list::5

autowire：autodetect、byName、byType、constructor、default、no

/Spring_Scope/src/yuki/spring/ioc/autowire/User.java

package yuki.spring.ioc.autowire;

public class User {

}

/Spring_Scope/src/yuki/spring/ioc/autowire/UserDAO.java

package yuki.spring.ioc.autowire;

public interface UserDAO {

    void save(User user);
}

/Spring_Scope/src/yuki/spring/ioc/autowire/UserDAOImpl.java

package yuki.spring.ioc.autowire;

public class UserDAOImpl implements UserDAO {

    private int daoId;
    public int getDaoId() {
        return daoId;
    }
    public void setDaoId(int daoId) {
        this.daoId = daoId;
    }

    @Override
    public void save(User user) {
        System.out.println("user saved... " + daoId);
    }
}

/Spring_Scope/src/yuki/spring/ioc/autowire/UserService.java

package yuki.spring.ioc.autowire;

public class UserService {

    private UserDAO userDAO;
    public void setUserDAO(UserDAO userDAO) {
        this.userDAO = userDAO;
    }

    public void save(User user){
        userDAO.save(user);
    }
}

/Spring_Scope/src/autowire.xml

默认是no，意思是需要手动指定

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
                        http://www.springframework.org/schema/beans/spring-beans-4.0.xsd ">

    <bean id="userDAO" class="yuki.spring.ioc.autowire.UserDAOImpl">
        <property name="daoId" value="1"></property>
    </bean>
    <bean id="userDAO2" class="yuki.spring.ioc.autowire.UserDAOImpl">
        <property name="daoId" value="2"></property>
    </bean>

    <!--
    <bean id="userService" class="yuki.spring.ioc.autowire.UserService" autowire="no">
        <property name="userDAO" ref="userDAO1"></property>
    </bean>
     -->
    <bean id="userService" class="yuki.spring.ioc.autowire.UserService" autowire="byName"></bean>

</beans>

/Spring_Scope/src/autowire2.xml

default的意思是在beans标签内指定好了的

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
                        http://www.springframework.org/schema/beans/spring-beans-4.0.xsd "
            default-autowire="byType">

    <bean id="userDAO" class="yuki.spring.ioc.autowire.UserDAOImpl">
        <property name="daoId" value="2"></property>
    </bean>

    <bean id="userService" class="yuki.spring.ioc.autowire.UserService" autowire="byType"></bean>

</beans>

/Spring_Scope/src/yuki/spring/ioc/autowire/AutowireTest.java

package yuki.spring.ioc.autowire;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class AutowireTest {

    @Test
    public void testAutowire() throws Exception{
        @SuppressWarnings("resource")
        ApplicationContext context = new ClassPathXmlApplicationContext("autowire.xml");
        UserService service = (UserService) context.getBean("userService");
        service.save(new User());
    }

    @Test
    public void testAutowire2() throws Exception{
        @SuppressWarnings("resource")
        ApplicationContext context = new ClassPathXmlApplicationContext("autowire2.xml");
        UserService service = (UserService) context.getBean("userService");
        service.save(new User());
    }
}

运行结果如下：

八月 31, 2014 9:53:12 上午 org.springframework.context.support.ClassPathXmlApplicationContext prepareRefresh
信息: Refreshing org[email protected]265ba4: startup date [Sun Aug 31 09:53:12 CST 2014]; root of context hierarchy
八月 31, 2014 9:53:12 上午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
信息: Loading XML bean definitions from class path resource [autowire.xml]
user saved... 1
八月 31, 2014 9:53:13 上午 org.springframework.context.support.ClassPathXmlApplicationContext prepareRefresh
信息: Refreshing org[email protected]1c0542: startup date [Sun Aug 31 09:53:13 CST 2014]; root of context hierarchy
八月 31, 2014 9:53:13 上午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
信息: Loading XML bean definitions from class path resource [autowire2.xml]
user saved... 2

Bean的生命周期
如果不加lazy-init="true"，当new出ClassPathXmlApplicationContext时
配置文件里所有的bean就会初始化，beans里有标签属性default-lazy-init
设置为true后，bean在用的时候才会初始化
当应用启动起来非常慢时，可以设置lazy-init
ApplicationContext的接口里没有destroy方法

/Spring_Scope/src/yuki/spring/ioc/lifecycle/UserService.java

package yuki.spring.ioc.lifecycle;

public class UserService {

    public void init(){
        System.out.println("init");
    }

    public void destroy(){
        System.out.println("destroy");
    }

}

/Spring_Scope/src/lifecycle.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
                        http://www.springframework.org/schema/beans/spring-beans-4.0.xsd">
    <!--
    <bean id="userService" class="yuki.spring.ioc.lifecycle.UserService"
                init-method="init" destroy-method="destroy" scope="prototype"></bean>
     -->
    <bean id="userService" class="yuki.spring.ioc.lifecycle.UserService"
                init-method="init" destroy-method="destroy"></bean>

</beans>

/Spring_Scope/src/yuki/spring/ioc/lifecycle/LifecycleTest.java

package yuki.spring.ioc.lifecycle;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class LifecycleTest {

    @SuppressWarnings({ "resource", "unused" })
    public static void main(String[] args) {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("lifecycle.xml");
        UserService service = (UserService) context.getBean("userService");
        UserService service2 = (UserService) context.getBean("userService");
        // 这个方法在ApplicationContext的接口里没有
        context.destroy();
    }

}

运行结果如下：

八月 31, 2014 10:07:13 上午 org.springframework.context.support.ClassPathXmlApplicationContext prepareRefresh
信息: Refreshing org[email protected]176fe71: startup date [Sun Aug 31 10:07:13 CST 2014]; root of context hierarchy
八月 31, 2014 10:07:14 上午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
信息: Loading XML bean definitions from class path resource [lifecycle.xml]
init
八月 31, 2014 10:07:14 上午 org.springframework.context.support.ClassPathXmlApplicationContext doClose
信息: Closing org[email protected]176fe71: startup date [Sun Aug 31 10:07:13 CST 2014]; root of context hierarchy
destroy

当bean的属性scope="prototype"时，上下文不再监测bean的destroy，所以不要和prototype一起用
作为一个数据源，需要close作为destroy-method方法

目录结构如下：

3.注解：自动编织，合格者

http://www.w3.org/2001/XMLSchema-instance
XML Schema instance namespace
dtd文件或xsd文件可以称为元数据文件，xsd文件称为xml文件的schema

<context:annotation-config></context:annotation-config>
它初始化了4个bean：

AutowiredAnnotationBeanPostProcessor,
处理bean初始化后的Autowired注解，默认byType
当有两个相同的要注入的类型时，就会匹配参数名，无法匹配就会报错

在preference>Java>Editor>Content> Assist>AutoAction
Auto active triggers for Java 后添加@ 再输入@ 就会自动提示了
qualifier - n.预选赛；（击败对手可进入某竞赛的）合格者；资格赛；外围赛

建议写在setXxx方法上，也可以写在其它的方法上
For a fallback match, the bean name is considered a default qualifier value.
　　　　　　　　　　　　　　　　　　为了容错，bean的name默认是qualifier的值

CommonAnnotationBeanPostProcessor,
PersistenceAnnotationBeanPostProcessor,
RequiredAnnotationBeanPostProcessor,
the affected bean property must be populated at configuration time,
　　　　　　　　　　　　　　　　　　容错用的，初始化的时候必须注入进来

/Spring_Annotation/src/yuki/spring/annotation/autowired/User.java

package yuki.spring.annotation.autowired;

public class User {

}

/Spring_Annotation/src/yuki/spring/annotation/autowired/UserDAO.java

package yuki.spring.annotation.autowired;

public interface UserDAO {

    void save(User user);
}

/Spring_Annotation/src/yuki/spring/annotation/autowired/UserDAOImpl.java

package yuki.spring.annotation.autowired;

public class UserDAOImpl implements UserDAO {

    @Override
    public void save(User user) {
        System.out.println("user saved... ");
    }
}

/Spring_Annotation/src/yuki/spring/annotation/autowired/UserService.java

package yuki.spring.annotation.autowired;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;

public class UserService {

    private UserDAO userDAO;

    // 在容器里查找与参数对应类型的bean注入
    @Autowired
    /*public void setUserDAO(UserDAO userDAO) {
        this.userDAO = userDAO;
    }*/
    public void setUserDAO(@Qualifier("userDAO1") UserDAO userDAO) {
        this.userDAO = userDAO;
    }

    public void save(User user){
        userDAO.save(user);
    }
}

/Spring_Annotation/src/annotation.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
                        http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
                        http://www.springframework.org/schema/context
                        http://www.springframework.org/schema/context/spring-context-4.0.xsd ">

    <context:annotation-config></context:annotation-config>

    <bean id="userDAO1" class="yuki.spring.annotation.autowired.UserDAOImpl"></bean>
    <bean id="userDAO2" class="yuki.spring.annotation.autowired.UserDAOImpl"></bean>

    <bean id="userService" class="yuki.spring.annotation.autowired.UserService"></bean>
</beans>

/Spring_Annotation/src/yuki/spring/annotation/autowired/AutowiredTest.java

package yuki.spring.annotation.autowired;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class AutowiredTest {

    @Test
    public void testAutowired() throws Exception{
        @SuppressWarnings("resource")
        ApplicationContext context = new ClassPathXmlApplicationContext("annotation.xml");
        UserService service = (UserService) context.getBean("userService");
        service.save(new User());
    }
}

运行结果如下：

八月 31, 2014 10:28:40 上午 org.springframework.context.support.ClassPathXmlApplicationContext prepareRefresh
信息: Refreshing org[email protected]3a439b: startup date [Sun Aug 31 10:28:40 CST 2014]; root of context hierarchy
八月 31, 2014 10:28:40 上午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
信息: Loading XML bean definitions from class path resource [annotation.xml]
user saved...

4.注解：资源，组件

JCP(Java Community Process)用来定义java的一些新的标准
每一个标准可以成为一个JSR(Java Specification Request)

@Resource表示引用了一个资源，默认是按名称，如果名称找不到，再按类型
填写属性name可以查找对应的bean的id并注入

/Spring_Annotation/src/yuki/spring/annotation/resource/UserDAO.java

package yuki.spring.annotation.resource;

public interface UserDAO {

    void save();
}

/Spring_Annotation/src/yuki/spring/annotation/resource/UserDAOImpl.java

package yuki.spring.annotation.resource;

public class UserDAOImpl implements UserDAO {

    @Override
    public void save() {
        System.out.println("user saved... ");
    }
}

/Spring_Annotation/src/yuki/spring/annotation/resource/UserService.java

package yuki.spring.annotation.resource;

import javax.annotation.Resource;

public class UserService {

    private UserDAO userDAO;

//  @Resource
    @Resource(name="userDAO2")
    public void setUserDAO(UserDAO userDAO) {
        this.userDAO = userDAO;
    }

    public void save(){
        userDAO.save();
    }
}

/Spring_Annotation/src/resource.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
                        http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
                        http://www.springframework.org/schema/context
                        http://www.springframework.org/schema/context/spring-context-4.0.xsd ">

    <context:annotation-config></context:annotation-config>

    <bean id="userDAO" class="yuki.spring.annotation.resource.UserDAOImpl"></bean>
    <bean id="userDAO2" class="yuki.spring.annotation.resource.UserDAOImpl"></bean>

    <bean id="userService" class="yuki.spring.annotation.resource.UserService"></bean>
</beans>

/Spring_Annotation/src/yuki/spring/annotation/resource/ResourceTest.java

package yuki.spring.annotation.resource;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class ResourceTest {

    @Test
    public void testAutowired() throws Exception{
        @SuppressWarnings("resource")
        ApplicationContext context = new ClassPathXmlApplicationContext("resource.xml");
        UserService service = (UserService) context.getBean("userService");
        service.save();
    }
}

运行结果如下：

八月 31, 2014 10:40:33 上午 org.springframework.context.support.ClassPathXmlApplicationContext prepareRefresh
信息: Refreshing org[email protected]3a439b: startup date [Sun Aug 31 10:40:33 CST 2014]; root of context hierarchy
八月 31, 2014 10:40:33 上午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
信息: Loading XML bean definitions from class path resource [resource.xml]
user saved...

<context:component-scan base-package=""></context:component-scan>
在base-backage包下找bean，添加了注解Component的类
默认类名首字母小写作为bean的id，也可以填写value属性，作为bean的名称

/Spring_Annotation/src/yuki/spring/annotation/component/UserDAO.java

package yuki.spring.annotation.component;

import org.springframework.stereotype.Component;

@Component("u")
public class UserDAO {

    public void save() {
        System.out.println("user saved... ");
    }
}

/Spring_Annotation/src/yuki/spring/annotation/component/UserService.java

package yuki.spring.annotation.component;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.annotation.Resource;

import org.springframework.stereotype.Component;

@Component
public class UserService {

    @PostConstruct
    public void init(){
        System.out.println("init...");
    }

    private UserDAO userDAO;

    @Resource(name="u")
    public void setUserDAO(UserDAO userDAO) {
        this.userDAO = userDAO;
    }

    public void save(){
        userDAO.save();
    }

    @PreDestroy
    public void destroy(){
        System.out.println("destroy...");
    }
}

/Spring_Annotation/src/component.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
                        http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
                        http://www.springframework.org/schema/context
                        http://www.springframework.org/schema/context/spring-context-4.0.xsd ">

    <context:annotation-config></context:annotation-config>
    <context:component-scan base-package="yuki.spring.annotation.component"></context:component-scan>

</beans>

/Spring_Annotation/src/yuki/spring/annotation/component/ComponentTest.java

package yuki.spring.annotation.component;

import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class ComponentTest {

    @Test
    public void testAutowired() throws Exception{
        @SuppressWarnings("resource")
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("component.xml");
        UserService service = (UserService) context.getBean("userService");
        service.save();
        context.destroy();
    }
}

运行结果如下：

八月 31, 2014 10:47:26 上午 org.springframework.context.support.ClassPathXmlApplicationContext prepareRefresh
信息: Refreshing org[email protected]3a439b: startup date [Sun Aug 31 10:47:26 CST 2014]; root of context hierarchy
八月 31, 2014 10:47:26 上午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
信息: Loading XML bean definitions from class path resource [component.xml]
init...
user saved...
八月 31, 2014 10:47:27 上午 org.springframework.context.support.ClassPathXmlApplicationContext doClose
信息: Closing org[email protected]3a439b: startup date [Sun Aug 31 10:47:26 CST 2014]; root of context hierarchy
destroy...

By default, classes annotated with @Component, @Repository, @Service, @Controller,
or a custom annotation that itself is annotated with @Component  are the only detected candidate components.
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　默认被这四个注解所注解的类被认为是组件

生存范围： @Scope(BeanDefinition.SCOPE_SINGLETON)放在类的定义之前

PostConstruct和PreDestroy，相当于init和的destroy

目录结构如下：

本文参考了[尚学堂马士兵_Spring_IOC]的公开课程

更多好文请关注：http://www.cnblogs.com/kodoyang/

kongdongyang

2014/8/31

时间： 2024-10-19 19:00:09

Spring依赖注入 --- 简单使用说明的相关文章

Spring依赖注入

Spring依赖注入基础 一.Spring简介 1.Spring简化Java开发 Spring Framework是一个应用框架,框架一般是半成品,我们在框架的基础上可以不用每个项目自己实现架构.基础设施和常用功能性组件,而是可以专注业务逻辑.因此学习Spring Framework在架构和模式方面的结构和原理,对我们在架构和模块级别的理解帮助极大.Spring Framework(参考1)的宗旨是简化Java开发,主要的手段如下: (1)在架构上解耦:通过DI(依赖注入)管理类型依赖,通过AO

SSH深度历险（八） 剖析SSH核心原理+Spring依赖注入的三种方式

在java开发中,程序员在某个类中需要依赖其它类的方法,则通常是new一个依赖类再调用类实例的方法,这种开发存在的问题是new的类实例不好统一管理,spring提出了依赖注入的思想,即依赖类不由程序员实例化,而是通过spring容器帮我们new指定实例并且将实例注入到需要该对象的类中.依赖注入的另一种说法是"控制反转",通俗的理解是:平常我们new一个实例,这个实例的控制权是我们程序员,而控制反转是指new实例工作不由我们程序员来做而是交给spring容器来做. Spring依赖注入(

Java Web系列：Spring依赖注入基础

一.Spring简介 1.Spring简化Java开发 Spring Framework是一个应用框架,框架一般是半成品,我们在框架的基础上可以不用每个项目自己实现架构.基础设施和常用功能性组件,而是可以专注业务逻辑.因此学习Spring Framework在架构和模式方面的结构和原理,对我们在架构和模块级别的理解帮助极大.Spring Framework(参考1)的宗旨是简化Java开发,主要的手段如下: (1)在架构上解耦:通过DI(依赖注入)管理类型依赖,通过AOP分离关注点,减少重复代码

Spring学习笔记——Spring依赖注入原理分析

我们知道Spring的依赖注入有四种方式,分别是get/set方法注入.构造器注入.静态工厂方法注入.实例工厂方法注入 下面我们先分析下这几种注入方式 1.get/set方法注入 public class SpringAction { //注入对象springDao private SpringDao springDao; //一定要写被注入对象的set方法 public void setSpringDao(SpringDao springDao) { this.springDao = spri

研究 Spring MVC 将请求分发到 Spring 依赖注入的类实例

太阳火神的美丽人生 (http://blog.csdn.net/opengl_es) 本文遵循"署名-非商业用途-保持一致"创作公用协议 转载请保留此句:太阳火神的美丽人生 -  本博客专注于 敏捷开发及移动和物联设备研究:iOS.Android.Html5.Arduino.pcDuino,否则,出自本博客的文章拒绝转载或再转载,谢谢合作. 一上午时间,碰了 N 个钉子,不断地把钉子拨掉,记录一下选择的工具和方法: 1.首先 Spring Mvc 框架的下载,那么有三个包是必不可少的:

Spring依赖注入的三种方式

Spring依赖注入(DI)的三种方式,分别为: 1． 接口注入 2． Setter方法注入 3． 构造方法注入 下面介绍一下这三种依赖注入在Spring中是怎么样实现的. 首先我们需要以下几个类: 接口 Logic.java 接口实现类 LogicImpl.java 一个处理类 LoginAction.java 还有一个测试类 TestMain.java Logic.java如下: package com.spring.test.di; public interface Logic { pub

【Spring】Spring依赖注入IOC的设值注入setter

其实标题中如此高大上的名词,只是一个问题,关于在Spring的applicationContext.xml中的如下语句是什么意思? <property name="aService" ref="aService"/> 这类语句在SSH的配置中会大量存在,因为Spring所谓的核心机制就是Spring依赖注入IOC.下面举一个例子说明这个问题: 先贴上目录结构: 在Eclipse中新建一个Java工程,不是JavaWeb,在这个Java配置好Spring3

Spring依赖注入（DI）的三种方式

Spring依赖注入(DI)的三种方式 Spring依赖注入(DI)的三种方式,分别为: 1． 接口注入 2． Setter方法注入 3． 构造方法注入 下面介绍一下这三种依赖注入在Spring中是怎么样实现的. 首先我们需要以下几个类: 接口 Logic.java 接口实现类 LogicImpl.java 一个处理类 LoginAction.java 还有一个测试类 TestMain.java Logic.java如下: package com.spring.test.di? public i

（转）Java Web系列：Spring依赖注入基础

一.Spring简介 1.Spring简化Java开发 Spring Framework是一个应用框架,框架一般是半成品,我们在框架的基础上可以不用每个项目自己实现架构.基础设施和常用功能性组件,而是可以专注业务逻辑.因此学习Spring Framework在架构和模式方面的结构和原理,对我们在架构和模块级别的理解帮助极大.Spring Framework(参考1)的宗旨是简化Java开发,主要的手段如下: (1)在架构上解耦:通过DI(依赖注入)管理类型依赖,通过AOP分离关注点,减少重复代码