Spring 管理 Bean-IOC--基于注解配置 bean

<?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 https://www.springframework.org/schema/context/spring-context.xsd">
    <!--配置容器要扫描的包
    1. component-scan 要对指定包下的类进行扫描, 并创建对象到容器
    2. base-package 指定要扫描的包
    3. 含义是当spring容器创建/初始化时，就会扫描com.wyxedu.spring.component包
       下的所有的 有注解 @Controller / @Service / @Respository / @Component类
       将其实例化，生成对象，放入到ioc容器
    4. resource-pattern="User*.class" 表示只扫描com.wyxedu.spring.component 和它的子包下的User打头的类
    -->
    <!--<context:component-scan base-package="com.spring.component"/>-->
    <!--
        需求：如果我们希望排除某个包/子包下的某种类型的注解，可以通过exclude-filter来指定
        1. context:exclude-filter 指定要排除哪些类
        2. type 指定排除方式 annotation表示按照注解来排除
        3. expression="org.springframework.stereotype.Service" 指定要排除的注解的全路径
    -->
    <!--<context:component-scan base-package="com.spring.component">-->
    <!--    <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Service"/>-->
    <!--    <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Repository"/>-->
    <!--</context:component-scan>-->
    <!--
        需求：如果我们希望按照自己的规则，来扫描包/子包下的某些注解, 可以通过 include-filter
        1. use-default-filters="false" 表示不使用默认的过滤机制/扫描机制
        2. context:include-filter 表示要去扫描哪些类
        3. type="annotation" 按照注解方式来扫描/过滤
        4. expression="org.springframework.stereotype.Service" 指定要扫描的注解的全路径
    -->
    <context:component-scan base-package="com.spring.component" use-default-filters="false">
       <context:include-filter type="annotation" expression="org.springframework.stereotype.Service"/>
       <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
       <context:include-filter type="annotation" expression="org.springframework.stereotype.Repository"/>
    </context:component-scan>
</beans>

  //通过注解来配置Bean
    @Test
    public void setBeanByAnnotation() {
        ApplicationContext ioc =
                new ClassPathXmlApplicationContext("beans05.xml");
        UserDao userDao = ioc.getBean(UserDao.class);
        //在默认情况下, 注解标识的类创建对象后，在容器中，id 为类名的首字母小写
        UserDao userDao1 = ioc.getBean("userDao", UserDao.class);
        System.out.println("userDao1=" + userDao1);
        UserService userService = ioc.getBean(UserService.class);
        UserAction userAction = ioc.getBean(UserAction.class);
        MyComponent myComponent = ioc.getBean(MyComponent.class);
        System.out.println("userDao=" + userDao);
        System.out.println("userService=" + userService);
        System.out.println("userAction=" + userAction);
        System.out.println("myComponent=" + myComponent);
        System.out.println("ok");
    }

@Service
public class UserService {
public void hi(){
System.out.println("UserService hi()~");
}
}

@Controller
public class UserAction {
    //xml配置 ref
    //说明 @Autowired
    //1)在IOC容器中查找待装配的组件的类型，如果有唯一的bean匹配(按照类型)，则使用该bean装配
    //2)如待装配的类型对应的bean在IOC容器中有多个，则使用待装配的属性的属性名作为id值再进行查找,
    //  找到就装配，找不到就抛异常
    //说明 @Resource
    //1) @Resource有两个属性是比较重要的,分是name和type,Spring将@Resource注解的name属性解析为bean的名字,
    //  而type属性则解析为bean的类型.所以如果使用name属性,则使用byName的自动注入策略,
    //  而使用type属性时则使用byType自动注入策略
    //  比如@Resource(name = "userService") 表示装配 id=userService对对象
    //  比如@Resource(type = UserService.class) 表示按照UserService.class类型进行装配, 这时要求容器中，只能有一个这样类型的对象
    //2) 如果@Resource 没有指定 name 和 type ,则先使用byName注入策略,
    //   如果匹配不上, 再使用byType策略, 如果都不成功，就会报错
    //=================================
    //说明： @Autowired + @Qualifier(value = "userService02") 组合也可以完成指定 name/id 来进行自动装配
    //指定id进行组装, 也可以使用@Autowired 和 @Qualifier(value = "userService02")
    // 这时，是装配的 id=userService02 , 需要两个注解都需要写上
    @Resource
    private UserService userService;
    public void sayOk() {
        System.out.println("UserAction 的sayOk()");
        System.out.println("userAction 装配的 userService属性=" + userService);
        userService.hi();
    }
}

    <context:component-scan
            base-package="com.spring.component"/>
    <!--配置两个UserService对象-->
    <bean class="com.wyxedu.spring.component.UserService" id="userService200"/>
    <bean class="com.wyxedu.spring.component.UserService" id="userService300"/>

 public void setProByAutowired() {
        ApplicationContext ioc =
                new ClassPathXmlApplicationContext("beans06.xml");
        UserService userService = ioc.getBean("userService", UserService.class);
        System.out.println("ioc容器中的userService=" + userService);
            UserService userService200 = ioc.getBean("userService200", UserService.class);
        System.out.println("ioc容器中的userService200=" + userService200);
        UserAction userAction = ioc.getBean("userAction", UserAction.class);
        //System.out.println("userAction=" + userAction);
        userAction.sayOk();
    }   

@Repository
public class BookDao extends BaseDao<Book>{
    @Override
    public void save() {
        System.out.println("BookDao 的 save()..");
    }
}

@Repository
public class PhoneDao extends BaseDao<Phone>{
    @Override
    public void save() {
        System.out.println("PhoneDao save()");
    }
}

public class BaseService<T> {
    @Autowired
    private BaseDao<T> baseDao;
    public void save() {
        baseDao.save();
    }
}

@Service
public class BookService extends BaseService<Book>{
    //并没有写属性
}

@Service
public class PhoneService extends BaseService<Phone>{
}

    <context:component-scan base-package="com.spring.depinjection"/>

    @Test
    public void setProByDependencyInjection() {
        ApplicationContext ioc =
                new ClassPathXmlApplicationContext("beans07.xml");
        PhoneService phoneService = ioc.getBean("phoneService", PhoneService.class);
        phoneService.save();
        System.out.println("ok");
    }