spring 自動裝配

 Spring利用依賴注入（DI）完成對IOC容器中各組件的依賴關係賦值

1. @Autowired：自動注入，主要由AutowiredAnnotationBeanPostProcessor 解析完成自動裝配功能
    1）默認優先按照類型去容器中找對應的組件:applicationContext.getBean(BookDao.class);找到就賦值
    2）如果找到多個相同類型的組件，再將屬性變量名稱作爲組件的id去容器中查找
                applicationContext.getBean("bookDao")
    3）@Qualifier("bookDao")：使用 @Qualifier 指定需要裝配的組件的id，而不是使用屬性名；
    4）自動裝配默認一定要將屬性賦值好，否則會報錯，可使用 @Autowired(required=false) 屏蔽初始化錯誤，但獲取時依然會報錯;
    5）@Primary：讓Spring進行自動裝配的時候，默認使用首選的bean，也可繼續使用@Qualifier指定需要裝配的bean的名字；

2. @Autowired : 可標註在構造器、參數、方法、屬性，都是從容器中獲取參數組件的值進行裝配
    1）[標註在方法位置]：@Bean+方法參數；參數從容器中獲取;默認不寫@Autowired效果是一樣的；都能自動裝配
    2）[標在構造器上]：如果組件只有一個有參構造器，這個有參構造器的@Autowired可以省略，參數位置的組件還是可以自動從容器中獲取
    3）放在參數位置：

3. Spring 還支持使用 @Resource(JSR250) 和 @Inject(JSR330)【java規範的註解】
    @Resource:
        可以和@Autowired一樣實現自動裝配功能；默認是按照組件名稱進行裝配的；
        沒有能支持@Primary功能沒有支持@Autowired（reqiured=false）;
    @Inject:
        需要導入javax.inject的包，和Autowired的功能一樣。沒有required=false的功能；
 @Autowired: 是Spring定義的； @Resource @Inject 都是java規範

4. 自定義組件想要使用Spring容器底層的一些組件（ApplicationContext，BeanFactory，xxx）
    自定義組件實現xxxAware；在創建對象的時候，會調用接口規定的方法注入相關組件，重點 Aware 接口；
    把Spring底層一些組件注入到自定義的Bean中；
    xxxAware：功能使用xxxAwareProcessor 實現；
        ApplicationContextAware ==> ApplicationContextAwareProcessor；

demo代碼如下：

@Configuration
@ComponentScan({"com.atguigu.service", "com.atguigu.dao", "com.atguigu.controller", "com.atguigu.bean"})
public class MainConifgOfAutowired {

    @Primary
    @Bean("bookDao2")
    public BookDao bookDao() {
        BookDao bookDao = new BookDao();
        bookDao.setLable("2");
        return bookDao;
    }

    /**
     * @param car
     * @return
     * @Bean標註的方法創建對象的時候，方法參數的值從容器中獲取
     */
    @Bean
    // 一般此處 @Autowired 可省略
    public Color color(@Autowired Car car) {
        Color color = new Color();
        color.setCar(car);
        return color;
    }
}

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.EmbeddedValueResolverAware;
import org.springframework.stereotype.Component;
import org.springframework.util.StringValueResolver;

@Component
public class Red implements ApplicationContextAware, BeanNameAware, EmbeddedValueResolverAware {

    private ApplicationContext applicationContext;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        System.out.println("傳入的ioc：" + applicationContext);
        this.applicationContext = applicationContext;
    }

    @Override
    public void setBeanName(String name) {
        System.out.println("當前bean的名字：" + name);
    }

    @Override
    public void setEmbeddedValueResolver(StringValueResolver resolver) {
        String resolveStringValue = resolver.resolveStringValue("你好 ${os.name} 我是 #{20*18}");
        System.out.println("解析的字符串：" + resolveStringValue);
    }
}

public class Color {

    private Car car;

    public Car getCar() {
        return car;
    }

    public void setCar(Car car) {
        this.car = car;
    }

    @Override
    public String toString() {
        return "Color [car=" + car + "]";
    }
}

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;

@Component
public class Car implements ApplicationContextAware, InitializingBean, DisposableBean {

    private ApplicationContext applicationContext;

    public Car() {
        System.out.println("car constructor...");
    }

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

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

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

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

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }

    @Override
    public void destroy() throws Exception {
        System.out.println("car ... destroy()...");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("car ... afterPropertiesSet()...");
    }
}

// 默認加在ioc容器中的組件，容器啓動會調用無參構造器創建對象，再進行初始化賦值等操作
@Component
public class Boss {
    private Car car;

    // 構造器要用的組件，都是從容器中獲取
    public Boss(Car car) {
        this.car = car;
        System.out.println("Boss...有參構造器");
    }

    public Car getCar() {
        return car;
    }

    // @Autowired
    // 標註在方法，Spring容器創建當前對象，就會調用方法，完成賦值；
    // 方法使用的參數，自定義類型的值從ioc容器中獲取
    public void setCar(Car car) {
        this.car = car;
    }

    @Override
    public String toString() {
        return "Boss [car=" + car + "]";
    }
}

@Repository
public class BookDao {

    private String lable = "1";

    public String getLable() {
        return lable;
    }

    public void setLable(String lable) {
        this.lable = lable;
    }

    @Override
    public String toString() {
        return "BookDao [lable=" + lable + "]";
    }
}

public class IOCTest_Autowired {

    @Test
    public void test01() {
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConifgOfAutowired.class);

        BookService bookService = applicationContext.getBean(BookService.class);
        System.out.println(bookService);

        //BookDao bean = applicationContext.getBean(BookDao.class);
        //System.out.println(bean);

        Boss boss = applicationContext.getBean(Boss.class);
        System.out.println(boss);
        Car car = applicationContext.getBean(Car.class);
        System.out.println(car);

        Color color = applicationContext.getBean(Color.class);
        System.out.println(color);
        System.out.println(applicationContext);
        applicationContext.close();
    }
}

 5. Profile 根據環境註冊 bean，Spring爲我們提供的可以根據當前環境，動態的激活和切換一系列組件的功能

  @Profile：指定組件在哪個環境的情況下才能被註冊到容器中，不指定，任何環境下都能註冊這個組件
    1）加了環境標識的bean，只有這個環境被激活的時候才能註冊到容器中。默認是default環境
    2）寫在配置類上，只有是指定的環境的時候，整個配置類裏面的所有配置才能開始生效
    3）沒有標註環境標識的bean在，任何環境下都是加載的；

   一般在 開發環境、測試環境、生產環境 分別有三個不同的數據源 dev、stg、prd，此時就能夠很好的使用這個功能

import javax.sql.DataSource;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.EmbeddedValueResolverAware;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Profile;
import org.springframework.context.annotation.PropertySource;
import org.springframework.util.StringValueResolver;

import com.atguigu.bean.Yellow;
import com.mchange.v2.c3p0.ComboPooledDataSource;

@PropertySource("classpath:/dbconfig.properties")
@Configuration
public class MainConfigOfProfile implements EmbeddedValueResolverAware {

    @Value("${db.user}")
    private String user;
    private StringValueResolver valueResolver;
    private String driverClass;

    @Bean
    public Yellow yellow() {
        return new Yellow();
    }

    @Profile("test")
    @Bean("testDataSource")
    public DataSource dataSourceTest(@Value("${db.password}") String pwd) throws Exception {
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        dataSource.setUser(user);
        dataSource.setPassword(pwd);
        dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/test");
        dataSource.setDriverClass(driverClass);
        return dataSource;
    }

    @Profile("dev")
    @Bean("devDataSource")
    public DataSource dataSourceDev(@Value("${db.password}") String pwd) throws Exception {
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        dataSource.setUser(user);
        dataSource.setPassword(pwd);
        dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/ssm_crud");
        dataSource.setDriverClass(driverClass);
        return dataSource;
    }

    @Profile("prod")
    @Bean("prodDataSource")
    public DataSource dataSourceProd(@Value("${db.password}") String pwd) throws Exception {
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        dataSource.setUser(user);
        dataSource.setPassword(pwd);
        dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/scw_0515");
        dataSource.setDriverClass(driverClass);
        return dataSource;
    }

    @Override
    public void setEmbeddedValueResolver(StringValueResolver resolver) {
        this.valueResolver = resolver;
        driverClass = valueResolver.resolveStringValue("${db.driverClass}");
    }
}

dbconfig.properties 

db.user=root
db.password=123456
db.driverClass=com.mysql.jdbc.Driver

import javax.sql.DataSource;
import org.junit.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import com.atguigu.bean.Boss;
import com.atguigu.bean.Car;
import com.atguigu.bean.Color;
import com.atguigu.bean.Red;
import com.atguigu.bean.Yellow;
import com.atguigu.config.MainConfigOfProfile;
import com.atguigu.config.MainConifgOfAutowired;
import com.atguigu.dao.BookDao;
import com.atguigu.service.BookService;

public class IOCTest_Profile {

    //1、使用命令行動態參數: 在虛擬機參數位置加載 -Dspring.profiles.active=test
    //2、代碼的方式激活某種環境，如下測試代碼實現
    @Test
    public void test01() {
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
        //1、創建一個applicationContext
        //2、設置需要激活的環境
        applicationContext.getEnvironment().setActiveProfiles("dev");
        //3、註冊主配置類
        applicationContext.register(MainConfigOfProfile.class);
        //4、啓動刷新容器
        applicationContext.refresh();
		

        String[] namesForType = applicationContext.getBeanNamesForType(DataSource.class);
        for (String string : namesForType) {
            System.out.println(string);
        }

        Yellow bean = applicationContext.getBean(Yellow.class);
        System.out.println(bean);
        applicationContext.close();
    }
}