spring-bean(三)

配置方式：通过工厂方法配置bean，通过FactoryBean配置bean

配置形式：基于注解的方式

组件扫描

泛型依赖注入

 

 

 

静态工厂方法

/**
 * 静态工厂方法：直接调用某一个类的静态方法就可以返回bean的实例
 */
public class StaticCarFactory {
    private static Map<String, Car> cars = new HashMap<String, Car>();
    
    static{
        cars.put("audi", new Car("audi",123,123));
        cars.put("ford", new Car("ford",123,123));
    }
    
    public static Car getCar(String name) {
        return cars.get(name);
    }
}

 

　　 <!-- 通过静态工厂方法来配置bean，注意不是配置静态工厂方法实例，而是配置bean实例 -->
    <bean id="car1" class="com.text.StaticCarFactory" factory-method="getCar">
        <constructor-arg value="audi"></constructor-arg>
    </bean>

 

实例工厂方法

/**
 * 实例工厂方法：实例工厂的方法，即先需要创建工厂本身，在调用
 * 工厂的实例方法，再配置bean的实例
 */
public class InstanceCarFactory {
    
    private Map<String, Car> cars = null;
    
    public InstanceCarFactory() {
        cars = new HashMap<String, Car>();
        cars.put("audi", new Car("audi",123,123));
        cars.put("ford", new Car("ford",123,123));
    }
    
    public Car getCar(String name) {
        return cars.get(name);
    }
}

 

    <!-- 配置工厂的实例 -->
    <bean id="carFactory" class="com.text.InstanceCarFactory"></bean>
    <!-- 通过实例工厂方法来配置bean -->
    <bean id="car2" factory-bean="carFactory" factory-method="getCar">
        <constructor-arg value="ford"></constructor-arg>
    </bean>

 

用FactoryBean配置bean

//自定义的FactoryBean需要实现提供的接口
public class CarFactoryBean implements FactoryBean<Car> {

    private String name;
    public void setName(String name) {
        this.name = name;
    }
    
    @Override
    public Car getObject() throws Exception {
        // TODO Auto-generated method stub
        return new Car(name,5000,500);
    }

    @Override
    public Class<?> getObjectType() {
        // TODO Auto-generated method stub
        return Car.class;
    }

    @Override
    public boolean isSingleton() {
        // TODO Auto-generated method stub
        return true;
    }

    
}

 

    <!-- 
    通过FactoryBean来配置bean的实例
    class=指向FactoryBean的全类名
    property=配置FactoryBean的属性
    
    但实际返回的实例确是FactoryBean的getObject方法返回的实例
     -->
    <bean id="car" class="com.text.CarFactoryBean">
        <property name="name" value="bmw"></property>
    </bean>

 

基于注解的方式配置bean，装配bean的属性

组件扫描：spring能够从classpath下自动扫描，侦测和实例化具有特定注解的组件

1. @Component 基本注解

2. @Respository 持久层

3. @Service 业务层

4. @Controller 表现层

可混用，ioc容器分辨不了，不过建议按层使用，value属性可标示beanName

 

可增加属性resource-pattern指定扫描的资源。如repository/*.class

可增加子节点

<context:exclude-filter type="annotation" expression=""/> 排除
<context:include-filter type="annotation" expression=""/>  包含（在use-default-filters【不使用默认注解】为false时使用）

expression中可填入如org.springframework.stereotype.Repository等包名

　　 <!-- 指定ioc容器扫描的包 -->
    <context:component-scan base-package="com.rep"></context:component-scan>

 

实例：autowire自动装配具有兼容类型的单个bean属性

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

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

此时，就可以打印

controller
add

写到这里，突然产生了一个疑问，注解形式和xml形式是如何转化的

重新写了相同作用的xml

    <bean id="userController" class="com.rep.UserController" >
        <property name="userService" ref="userService"></property>
    </bean>
    
    <bean id="userService" class="com.rep.UserService"></bean>

在userController中的userService变量需要加上setter方法

运行得出相同结论。然后又产生一个问题，之前为啥用bean来着。。

如果不用bean呢？

    private UserService userService = new UserService();
    
    public void controller() {
        System.out.println("controller");
        userService.add();
    }

　　UserController userController = new UserController();
                //(UserController)ctx.getBean("userController");
    userController.controller();

写完对比后，就发现：用bean的原因是为了减少耦合，也就是Controller和Service之间不会产生关系，如果不用bean，Controller中需要new一个Service。而在用spring后，所有的bean都交给ioc容器管理，如果你有需要，跟ioc容器getBean即可。

 

言归正传，autowire可以有一个属性值required，当为false时，即使bean不存在，也不抛异常，而是允许不被设置。

 

当匹配的bean有两个或多个时，会抛异常expected single matching bean but found 2

解决方法：（以Service为接口，UserService和OtherService作为实现为例

在Controller中定义接口变量service）

1. 在UserService或者OtherService类上添加@Service("service")，value值为接口变量

2. 在autowired下方加入@Qualifier("otherService")，值为所装配的bean

    @Autowired
    @Qualifier("otherService")
    private Service service;

3. 在参数前加Qualifier，且autowired在setter方法前

    private Service service;
    @Autowired
    public void setService(@Qualifier("otherService")Service service) {
        this.service = service;
    }

 

autowired注解放在

1. 数组类型属性上，spring会把所有匹配的bean进行自动装配

    @Autowired
    private Service[] service;

    public void controller() {
        System.out.println("controller");
        service[1].add();
    }

 

2. 集合属性上，spring读取该集合的类型信息，然后自动装配所有与之兼容的bean

    @Autowired
    private List<Service> service;

    public void controller() {
        System.out.println("controller");
        service.get(0).add();
    }

 

3. 在map上，若map的键值为String，spring将自动装配与map值类型兼容的bean，此时bean的名称作为键值

    @Autowired
    private Map<String,Service> service;
    
    public void controller() {
        System.out.println("controller");
        service.get("userService").add();
    }

 

 

泛型依赖注入

public class BaseRepository<T> {

}

@Repository
public class UserRepository extends BaseRepository<User>{

}

 

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>{
    
}

 

此时，在main方法中

UserService userService = (UserService)ctx.getBean("userService");
userService.add();

打印结果为

add
com.di.UserRepository@e5a13

 

即Service父类装配Repository父类，且方法中用的是Repository父类类型变量，当Service子类调用父类方法时，调用的是Repository子类