一丶单例对象依赖多例对象，多例对象为单例

问题：

一个对象为单例，但依赖的对象为多列对象，此时，该依赖的多列对象会变成单例

原因：

对象为单例，因此只实例化和初始化一次，因此该属性只被赋值一次，因此在该对象中，被依赖的对象始终为同一个对象
代码说明：

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.2.0.RELEASE</version>
    </dependency>
</dependencies>

@ComponentScan(basePackages = {"com.wuhuafeng"})
public class AppConfig {
}

@Repository
@Scope(value = "prototype")
public class UserDao {

    public void print(){
        System.out.println("dao "+ this.hashCode());
    }

}

@Service
public class UserService {
    @Autowired
    UserDao userDao;

    public void print(){
        System.out.println("userService "+ this.hashCode());
        System.out.println("userDao "+ userDao.hashCode());
    }
    public void print1(){
        System.out.println("userService "+ this.hashCode());
        System.out.println("userDao "+ userDao.hashCode());
    }
}

public class UserController {

    public static void main(String[] args) {
        AnnotationConfigApplicationContext AC = new AnnotationConfigApplicationContext(AppConfig.class);
        UserService userService =(UserService) AC.getBean("userService");
        userService.print();
        userService.print1();
    }
}

userService 1418385211
userDao 1282811396
userService 1418385211
userDao 1282811396

我们看到每次输出userDao的HashCode都是一样的，证明我们实际上并没有达到使用原型bean的目的。

解决方法：

方法一：
继承ApplicationContextAware，使用applicationContext从容器中获取依赖.
在bean A中引入ApplicationContext每次调用方法时用上下文的getBean(name,class)方法去重新获取bean B的实例

@Service
public class UserService implements ApplicationContextAware {
    private ApplicationContext applicationContext;

    public void print(){
        UserDao userDao =(UserDao)applicationContext.getBean("userDao");
        System.out.println("userService "+ this.hashCode());
        System.out.println("userDao "+ userDao.hashCode());
    }
    public void print1(){
        UserDao userDao =(UserDao)applicationContext.getBean("userDao");
        System.out.println("userService "+ this.hashCode());
        System.out.println("userDao "+ userDao.hashCode());
    }

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

userService 775931202
userDao 22069592
userService 775931202
userDao 1160003871

方法二(推荐使用)：
使用@Lookup注解

@Service
public abstract class UserService  {

    @Lookup
    protected abstract UserDao methodInject();
    
    public void print(){
        UserDao userDao = methodInject();
        System.out.println("userService "+ this.hashCode());
        System.out.println("userDao "+ userDao.hashCode());
    }
    public void print1(){
        UserDao userDao = methodInject();
        System.out.println("userService "+ this.hashCode());
        System.out.println("userDao "+ userDao.hashCode());
    }
}

使用这种抽象类的时候可以看出，在调用的时候使用的是他的CGLIb的动态代理类。

还有一种不用抽象方法可以写成(一样可以)：

@Service
public class UserService  {

    @Lookup
    protected UserDao methodInject(){
        return null;
    }
    ....

userService 210652080
userDao 1652149987
userService 210652080
userDao 1107730949