@Autowired注解

@Autowired注解，默認情況下，如果因為找不到合適的bean將會導致autowiring拋出失敗異常，
可以通過@Autowired(required=false)的方式避免.

@Autowired注解可以用於成員變量、set方法、構造器（一個類中只能有一個構造被注釋成@Autowired(required=true)）、list集合、map。

新建一個web項目，導入jar包，jar包如圖：

一、@Autowired注解用於成員變量、set方法、構造器（一個類中只能有一個構造被注釋成@Autowired(required=true)）

1.新建一個service 接口和一個serviceImpl實現類

1）InjectionService接口

package com.moocer.injection.service;

public interface InjectionService {
    public void save(String arg);
}

2)新建InjectionServiceImpl實現類

package com.moocer.injection.service.impl;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.moocer.injection.dao.InjectionDao;
import com.moocer.injection.service.InjectionService;
@Service
public class InjectionServiceImpl implements InjectionService{
    /**
     * @Autowired注解，默認情況下，如果因為找不到合適的bean將會導致autowiring拋出失敗異常，
     * 可以通過@Autowired(required=false)的方式避免
     */
    //@Autowired//用於成員變量
    private InjectionDao injectionDao;
    
    //@Autowired//用於set方法
    public void setInjectionDao(InjectionDao injectionDao) {
        this.injectionDao = injectionDao;
    }
    @Autowired//用於注解構造器 ，一個類中只能有一個構造被注釋成@Autowired(required=true)
    public InjectionServiceImpl(InjectionDao injectionDao){
        this.injectionDao = injectionDao;
    }
    @Override
    public void save(String arg) {
        System.out.println("InjectionServiceImpl service接受參數"+arg);
        arg = arg+":"+this.hashCode();
        injectionDao.save(arg);
    }

}

2.新建dao用於數據保存，這里只是模擬數據庫保存操作，並不真正操作數據庫

1）、新建InjectionDao接口

package com.moocer.injection.dao;

public interface InjectionDao {
    public void save(String args);
}

2）、新建InjectionDaoImpl實現類

package com.moocer.injection.dao.impl;

import org.springframework.stereotype.Repository;

import com.moocer.injection.dao.InjectionDao;
@Repository
public class InjectionDaoImpl implements InjectionDao{

    @Override
    public void save(String args) {
        //模擬保存數據
        System.out.println("InjectionDaoImpl 保存數據: "+args);
    }

}

 

3.新建一個測試類並繼承測試類的工具類

1）、新建測試類工具類

package com.moocer.test;

import org.junit.After;
import org.junit.Before;
import org.springframework.beans.BeansException;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.util.StringUtils;


public class JUnitBaseUtil {
    private ClassPathXmlApplicationContext context;
    
    private String springXmlpath;
    
    public JUnitBaseUtil() {}
    
    public JUnitBaseUtil(String springXmlpath) {
        this.springXmlpath = springXmlpath;
    }
    
    @Before
    public void before() {
        if (StringUtils.isEmpty(springXmlpath)) {
            springXmlpath = "classpath*:spring-*.xml";
        }
        try {
            context = new ClassPathXmlApplicationContext(springXmlpath.split("[,\\s]+"));
            context.start();
        } catch (BeansException e) {
            e.printStackTrace();
        }
    }
    
    @After
    public void after() {
        context.destroy();
    }
    
    @SuppressWarnings("unchecked")
    protected <T extends Object> T getBean(String beanId) {
        try {
            return (T)context.getBean(beanId);
        } catch (BeansException e) {
            e.printStackTrace();
            return null;
        }
    }
    
    protected <T extends Object> T getBean(Class<T> clazz) {
        try {
            return context.getBean(clazz);
        } catch (BeansException e) {
            e.printStackTrace();
            return null;
        }
    }
}

2）、新建測試類並繼承工具類

package com.moocer.test;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.BlockJUnit4ClassRunner;

import com.moocer.injection.service.impl.InjectionServiceImpl;

@RunWith(BlockJUnit4ClassRunner.class)
public class InjectionTest extends JUnitBaseUtil{
    public InjectionTest(){
        super("classpath*:config/spring-injection.xml");
    }
    @Test
    public void testInjection(){
        InjectionServiceImpl injection = super.getBean("injectionServiceImpl");
        injection.save("this is autowired 注解");
    }
}

4.新建一個spring-injection.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"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd" >
        
        <context:component-scan base-package="com.moocer.injection"></context:component-scan>
 </beans>

5.執行測試類得到結果

二、@Autowired注解用於list集合、map

1.新建一個XBeanInter的接口

package com.moocer.annotation.mulbean;

public interface XBeanInter {
    
}

2，新建兩個實現類實現接口，不需要任何方法體，空着就行

1）、XBeanInterOne

package com.moocer.annotation.mulbean;

import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
@Order(value=2)//@Order(value=2)//這個注解是用來排序的，但是這個排序只針對list有效，針對map沒效
@Component
public class XBeanInterOne implements XBeanInter {

}

2)、XBeanInterTwo

package com.moocer.annotation.mulbean;

import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
@Order(value=1)//@Order(value=1)
@Component
public class XBeanInterTwo implements XBeanInter {

}

3.新建一個CoInvoker類

package com.moocer.annotation.mulbean;

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

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class CoInvoker {
    @Autowired//用於list
    private List<XBeanInter> list;
    @Autowired//用於map
    private Map<String,XBeanInter> map;
    
    public void say(){
        if(null !=list && 0 != list.size()){
            //循環list，把list中每一個兩個實現類XBeanInterOne XBeanInterTwo
            //全部通過@Autowired注解到list中去
            System.out.println("list");
            for(XBeanInter bean:list){
                System.out.println(bean.getClass().getName());
            }
        }else{
            System.out.println("List<XBeanInter> is null!!!");
        }
        
        
        if(map != null && 0 != map.size()){
            System.out.println("map");
            for(Map.Entry<String,XBeanInter> entry:map.entrySet()){
                System.out.println(entry.getKey()+":"+entry.getValue().getClass().getName());
            }
        }else{
            System.out.println("Map<String,XBeanInter> is null!!!!");
        }
    }
}

4、新建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"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd" >
        <context:component-scan base-package="com.moocer.annotation"></context:component-scan>
 </beans>

 

 5、新建測試類測試

package com.moocer.test;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.BlockJUnit4ClassRunner;

import com.moocer.annotation.BeanAnnotation;
import com.moocer.annotation.mulbean.CoInvoker;

@RunWith(BlockJUnit4ClassRunner.class)
public class AnnotationTest extends JUnitBaseUtil{
    public AnnotationTest(){
        super("classpath*:config/spring-beanannotation.xml");
    }
    
    
    
    @Test
    public void testMt(){
        CoInvoker co = super.getBean("coInvoker");
        co.say();
    }
    
}

6.執行測試類結果