bean工厂的思想——面向接口编程，ioc的思想，控制反转

为什么要去使用beanFactory？

主要是为了解耦合

我们可以去看一个很简单的案例

一个web项目可以分为

• 控制层
• 业务层
• dao层

如果说根据分层来分模块开发，那么控制层就会依赖业务层，业务层又会依赖dao层

那么一旦dao层的代码发生变化，比如以前的类设计有问题，重新换个类，那么业务层就会发生变化

同样的控制层可能也要发生变化

所以他们之间的联系是硬编码，耦合性太强

这个时候为了避免这种情况就要面向接口编程 ，我们需要什么功能提前用接口的方式定义出来

那么即使以后换了一个类 但是只要接口没变，函数名什么的都不会变，就可以使得很多代码不需要更改

可是这个时候就又有问题了，接口是不能获得对象的，而我们在调用这些功能的时候其实还是需要new 一个对象，如果只是仅仅调用接口，并不能有效的解决问题

比如UserDaoImpl dao = new UserDaoImpl()变成了UserDao dao = new UserDaoImpl()

但是其后半部分依然还是硬编码的，耦合性还是太强，dao层的修改会导致业务层还是得相应的去修改代码，所以我们获取对象的方式就不能是new了

这个时候beanFactory就派上了用场

我们可以将实现类的全类名写在配置文件里，然后根据我们的配置去修改

然后让beanFactory帮我们获取配置文件的参数，根据全类名，使用反射技术得到相应的对象

比如我们可以在配置文件里写

UserDao=com.kehao.UserDaoImpl1

这样我们只要给beanFactory一个接口，他就可以根据接口找到，是哪一个实现类，于是就可以获取相应的对象，就解决了他们之间的耦合性问题

而这个配置文件，可以在项目部署之后修改，这样就算dao层，发生了改变，只需要修改对应的配置文件，业务层根本不需要修改任何编码，成功实现了解耦合

这也就是所谓的控制反转

一个简单的例子

• 接口

public interface Animal {
    void shout();
}

• 实现类

Cat

public class Cat implements Animal {
    @Override
    public void shout() {
        System.out.println("喵喵喵！！！");
    }
}

Dog

public class Dog implements Animal{
    @Override
    public void shout() {
        System.out.println("汪汪汪！！！");
    }
}

• BeanFactory的实现

public class MyBeanFactory {

    public static  <T> T newInstance(Class<T> tClass)  {
        ResourceBundle bundle = ResourceBundle.getBundle("impl");
        String animal = bundle.getString("Animal").trim();
        T t = null;
        try {
            t = (T) Class.forName(animal).newInstance();
        }catch (Exception e){
            e.printStackTrace();
        }
        return t;
    }
}

• properties文件

Animal=kehao.others.Cat 

• 主函数

public class Main {

    public static void main(String[] args) {
        Animal animal = MyBeanFactory.newInstance(Animal.class);
        animal.shout();
    }
}

这里只是一个思想的记录，具体真实的使用可以直接采用spring框架