SpringIOC工厂模式解耦原理，简单易懂

一。创建maven项目Factory-pattern

二。创建Dao接口和实现类

UserDao接口

package com.zq.dao;

/**
 * 用户持久层接口
 */
public interface UserDao {
    /**
     * 添加用户
     */
    void addUser();
}

UserDaoImpl

package com.zq.dao.impl;

import com.zq.dao.UserDao;

/**
 * 用户持久层实现类
 */
public class UserDaoImpl implements UserDao {
    /**
     * 添加用户（这里我没有调用数据库，因为我讲的是工厂模式解耦）
     */
    @Override
    public void addUser() {
        System.out.println("添加用户成功");
    }
}

三。创建Service接口和实现类

UserService接口

package com.zq.service;

/**
 * 用户业务层接口
 */
public interface UserService {
    /**
     * 添加用户
     */
    void addUser();
}

UserServiceImpl

package com.zq.service.impl;

import com.zq.dao.UserDao;
import com.zq.dao.impl.UserDaoImpl;
import com.zq.service.UserService;

/**
 * 用户业务层实现
 */
public class UserServiceImpl implements UserService {
    private UserDao userDao = new UserDaoImpl();
    /**
     * 添加用户
     */
    @Override
    public void addUser() {
        userDao.addUser();
    }
}

四。创建测试方法测试业务层和持久层逻辑

UserServiceTest

package com.zq.test;

import com.zq.factory.FactoryBuilder;
import com.zq.service.UserService;
import com.zq.service.impl.UserServiceImpl;

/**
 * 用户业务层测试
 */
public class UserServiceTest {
    private static UserService userService=new UserServiceImpl();
    public static void main(String[] args) {
        userService.addUser();
    }
}

执行结果：

至此场景已经准备好了，你会发现，原来我们都是主动new对象，创建对象的UserService userService=new UserServiceImpl()，其中UserServiceImpl我们可能会对它进行功能的升级或者对这个实现不满意重新写个实现，那我们就得去改这个部位。它们耦合在一起，不利于功能功能的拓展升级。

五。下面我们来写一个工厂类，代替我们创建对象实现解耦，让工厂来代替我们创建实例对象，我们直接从工厂中获取对象实例（这就是控制反转）

• 首先我们得写一个属性文件，就像Spring的xml配置文件一样配置bean

bean.properties

UserDao=com.zq.dao.impl.UserDaoImpl
UserService=com.zq.service.impl.UserServiceImpl

• 其次最主要的是写一个工厂类

FactoryBuilder

package com.zq.factory;

import java.util.ResourceBundle;

/**
 * 工厂类
 */
public class FactoryBuilder {
    private static FactoryBuilder factoryBuilder;
    private FactoryBuilder(){

    }

    /**
     * 静态代码块实例化工厂
     */
    static{
        factoryBuilder = new FactoryBuilder();
    }

    /**
     * 提供静态的方法获取工厂对象
     * @return
     */
    public static FactoryBuilder getFactoryBuilder(){
        return factoryBuilder;
    }

    /**
     * 创建工厂方法，读取属性文件bean.properties通过反射创建实例对象
     * @param name
     * @return
     */
    public Object getBean(String name){
        //这里我通过ResourceBundle对象读取属性文件
        ResourceBundle bundle = ResourceBundle.getBundle("bean");
        String objectName = bundle.getString(name);
        Class clazz;
        Object obj=null;
        try {
            //动态加载类，得到实现类的类对象
            clazz = Class.forName(objectName);
            //通过反射创建实现类实例
            obj = clazz.newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        //返回实现类实例
        return obj;
    }
}

六。有了工厂类我们就不再需要自己new了

UserServiceTest

package com.zq.test;

import com.zq.factory.FactoryBuilder;
import com.zq.service.UserService;
import com.zq.service.impl.UserServiceImpl;

/**
 * 用户业务层测试
 */
public class UserServiceTest {
//    private static UserService userService=new UserServiceImpl();
    private static UserService userService= (UserService) FactoryBuilder.getFactoryBuilder().getBean("UserService");
    public static void main(String[] args) {
        userService.addUser();
    }
}

执行结果：

是不是清楚了，这就是工厂模式解耦，以后如果觉得某个实现类不好要重新写一个，我们只需要修改属性文件就可以了，因为我们代码中都是用的接口，这就是工厂模式解耦的好处。Spring中IOC就是如此实现，只不过在Spring中它是用的xml配置文件来管理bean的，通过dom4j解析xml配置文件，再用工厂模式实例化对象，不过Spring还会将这些创建的实例对象存入容器之中，Spring中提到的容器即是一个map集合，这样我们不需要在每次获取实例的时候都让工厂创建实例，我们需要实例就从容器中获取就可以了，当然我这个简单的案例没有引入map集合充当容器。但通过我的一番讲解大概也对Spring的IOC控制反转有了新一轮的认识吧！！！
感谢各位的观看，欢迎各位在下方点赞留言（纯手工敲的，不容易啊）！！！