一、Bean的配置方式

    Bean 的配置方式：通過全類名（反射）、通過工廠方法（靜態工廠方法 & 例項工廠方法）、FactoryBean

1-1.通過靜態工廠方式配置Bean

/**
 * InstanceCarFactory：例項工廠方法
 * 例項工廠的方法，即需要先建立工廠本身，再呼叫工廠的例項方法來返回bean的例項
 *
 * @author Lcw 2015/11/12
 */
public class InstanceCarFactory {
    private Map<String, Car> cars = null;

    public InstanceCarFactory() {
        cars = new HashMap<String, Car>();
        cars.put("audi", new Car("audi", 500000));
        cars.put("ford", new Car("ford", 600000));
    }

    public Car getCar(String brand) {
        return cars.get(brand);
    }
}
 

/**
 * StaticCarFactory：靜態工廠方法：直接呼叫某一個類的靜態方法就可以返回Bean例項
 */
public class StaticCarFactory {
    private static Map<String , Car> cars = new HashMap<String, Car>();

    static {
        cars.put("audi",new Car("audi", 30000));
        cars.put("ford",new Car("ford", 40000));
    }

    //靜態工廠方法: 注意：要在配置檔案XML裡配置Car而不是StaticCarFactory
    public static Car getCar(String name) {
        return cars.get(name);
    }
}
 

<?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 http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">

    <!--通過靜態工廠方法來配置bean, 注意不是配置靜態工廠方法例項，而是配置bean例項-->
    <!--factory-method: 指向靜態工廠方法的名字
        constructor-arg：如果工廠方法需要傳入引數，則使用constructor-arg來配置引數-->
    <bean id="car1" class="Spring4_IOC.bean.factory.StaticCarFactory"
            factory-method="getCar">
        <constructor-arg value="audi"/>
    </bean>

    <!--配置例項工廠的例項-->
    <bean id="carFactory" class="Spring4_IOC.bean.factory.InstanceCarFactory"/>
    <!-- 通過例項工廠方法來配置bean-->
    <bean id="car2" factory-bean="carFactory" factory-method="getCar">
        <constructor-arg value="ford"/>
    </bean>
</beans>

    /**
     * Bean 的配置方式：-、通過全類名（反射）；二、通過工廠方法（靜態工廠方法 & 例項工廠方法）；三、FactoryBean
     *
     * 靜態工廠方法：直接呼叫某一個類的靜態方法就可以返回Bean例項
     * 例項工廠方法：例項工廠的方法，即需要先建立工廠本身，再呼叫工廠的例項方法來返回bean的例項
     */
    @Test
    public void testStaticFactory() {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("Spring4_IOC/beans-factory.xml");
        //測試靜態工廠方法
        Car car1 = (Car) ctx.getBean("car1");
        System.out.println(car1);

        //例項工廠方法
        Car car2 = (Car) ctx.getBean("car2");
        System.out.println(car2);
    }

/**
 * CarFactoryBean:自定義的factoryBean需要實現FactoryBean
 */
public class CarFactoryBean implements FactoryBean<Car> {
    private String brand;
    public String getBrand() {
        return brand;
    }
    public void setBrand(String brand) {
        this.brand = brand;
    }

    public CarFactoryBean() {
    }
    //下面是三個實現方法
    //返回bean的物件
    public Car getObject() throws Exception {
        return new Car("BMW" , 500000);
    }

    //返回bean的型別Class<?>  中?表示一個未知的類
    public Class<?> getObjectType() {
        return Car.class;
    }

    public boolean isSingleton() {
        return true;
    }
}

<?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 http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">

    <!--
        通過factoryBean來配置Bean的例項
        class：指向FactoryBean的全類名
        property：配置FactoryBean的屬性

        但實際返回的例項確是FactoryBean的getObject()返回的例項-->
   <bean id="car" class="Spring4_IOC.bean.CarFactoryBean">
       <property name="brand" value="BMW"/>
   </bean>
</beans>

   /**
     * Bean 的配置方式：-、通過全類名（反射）；二、通過工廠方法（靜態工廠方法 & 例項工廠方法）；三、FactoryBean
     *
     * 測試FactoryBean
     * Spring 中有兩種型別的 Bean, 一種是普通Bean, 另一種是工廠Bean, 即FactoryBean
     */
    @Test
    public void testFactoryBean() {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("Spring4_IOC/beans-beanFactory.xml");
        Car car = (Car) ctx.getBean("car");  //注意這個在類是Car!
        System.out.println(car);
    }

二、Bean的配置形式

以下 類那放在這個檔案下Spring4_IOC.annotation

@Component
public class TestObject {
}

public interface UserRepository {
    void save();
}

//介面實現一般用介面名
@Repository("userRepository")
public class UserRepositoryImpl implements UserRepository {
    public void save() {
        System.out.println("UserRepository Save...");
    }
}

@Service
public class UserService {
   //@Autowired(required=false) //如果沒有這個類，輸出為null
   @Autowired
    private UserRepository userRepository;

    public void add() {
        System.out.println("UserService add...");
        userRepository.save();
    }
}

@Controller
public class UserController {
    @Autowired
    private UserService userService;
    public void execute() {
        System.out.println("UserController execute...");
        userService.add();
    }
}

<?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">

   <!--指定Spring IOC容器掃描的包-->
    <!--可以通過resource-pattern指定掃描的資源-->
    <!--<context:component-scan base-package="Spring4_IOC.annotation"
            resource-pattern="repository/*.class"></context:component-scan>-->

    <!--exclude-filter: 子節點指定排除哪些指定表示式的元件-->
    <!--include-filter：子節點指定包含哪些表示式的元件，該子節點需要use-default-filters="false"配合使用-->
    <context:component-scan base-package="Spring4_IOC.annotation" >
        <!--<context:exclude-filter type="annotation" expression="org.springframework.stereotype.Repository"/>-->
        <!--<context:include-filter type="annotation" expression="org.springframework.stereotype.Repository"/>-->

        <!--<context:exclude-filter type="assignable" expression="com.changwen.spring4.annotation.repository.UserRepository"/>-->
        <!--<context:include-filter type="assignable" expression="com.changwen.spring4.annotation.repository.UserRepository"/>-->
    </context:component-scan>
</beans>

    @Test
    public void testAnnotation() {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("Spring4_IOC/beans-annotation.xml");

        TestObject to = (TestObject) ctx.getBean("testObject");
        System.out.println(to);

        //類UserController第一個字母小寫 userController
        UserController userController = (UserController) ctx.getBean("userController");
        System.out.println(userController);
        userController.execute();

        UserService userService = (UserService) ctx.getBean("userService");
        System.out.println(userService);

        UserRepository userRepository = (UserRepository) ctx.getBean("userRepository");
        System.out.println(userRepository);
    }

2-1.元件裝配

三、泛型依賴注入

public class BaseRepository<T> {
}

public class BaseService<T> {
    @Autowired
    protected BaseRepository<T> repository;

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

@Service
public class UserService extends BaseService<User> {
}

public class User {
    private String userName;
    private List<Car> cars;
    private String wifeName;

    public String getWifeName() {
        return wifeName;
    }

    public void setWifeName(String wifeName) {
        System.out.println("setWifhName: " + wifeName);
        this.wifeName = wifeName;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public List<Car> getCars() {
        return cars;
    }

    public void setCars(List<Car> cars) {
        this.cars = cars;
    }

    public User() {
        System.out.println("User's Construtor...");
    }

    @Override
    public String toString() {
        return "User [userName=" + userName + ", cars=" + cars + "]";
    }

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

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

}

@Repository
public class UserRepository extends BaseRepository<User>{
}

<?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/util http://www.springframework.org/schema/util/spring-util.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

  <context:component-scan base-package="Spring4_IOC.di">

  </context:component-scan>
</beans>

    /**
     * Spring 4.x 新特性：泛型依賴注入
     */
    @Test
    public void testDI() {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("Spring4_IOC/beans-generic.xml");
        Spring4_IOC.di.UserService userService = (Spring4_IOC.di.UserService) ctx.getBean("userService");
        System.out.println(userService);
        userService.add();
    }