Java工厂模式解耦 —— 理解Spring IOC

最近看到一个很好的思想来理解Spring IOC，故记录下来。

资源获取方式

1. 主动式：（要什么资源都自己创建）

2. 被动式：（资源的获取不是我们创建，而是交给一个容器来创建和设置）

工厂模式获取资源

主要思想：

1. 使用工厂模式以及Java反射机制来获取资源（类）。
2. 使用容器（Map）来存储所有资源，当需要的时候由工厂从容器中取出。
3. 使用读取配置文件的方式向容器中注入组件（类）。

作用：

1. 降低组件之间的耦合性。

代码

com.lin.dao下：

package com.lin.dao;

/**
 * Create by ljc on 2019/10/31
 */

public interface IAccountDao
{
    public void save();
}

com.lin.dao.impl下：

package com.lin.dao.impl;

import com.lin.dao.IAccountDao;

/**
 * Create by ljc on 2019/10/31
 */

public class AccountDao implements IAccountDao
{
    public void save()
    {
        System.out.println("AccountDao save.....");
    }
}

com.lin.service下：

package com.lin.service;

/**
 * Create by ljc on 2019/10/31
 */

public interface IAccountService
{
    public void saveService();

}

com.lin.service.impl下：

package com.lin.service.impl;

import com.lin.MyBeanFactory;
import com.lin.dao.IAccountDao;
import com.lin.service.IAccountService;

/**
 * Create by ljc on 2019/10/31
 */

public class AccountService implements IAccountService
{
    IAccountDao iTestDao = (IAccountDao) MyBeanFactory.getBean("accountDao");

    public void saveService()
    {
        iTestDao.save();
    }
}

com.lin下：最重要的工厂类

package com.lin;

import org.springframework.beans.factory.BeanFactory;

import java.io.InputStream;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;

/**
 * 工厂类，用来管理所有组件（类）
 * Create by ljc on 2019/10/31
 */

public class MyBeanFactory
{
    // 从配置文件中读取所需组件（类）
    private static Properties properties;

    //使用容器来保存所有组件
    private static Map<String, Object> beans;

    static
    {
        try
        {
            //读取配置文件
            properties = new Properties();
            InputStream in = BeanFactory.class.getClassLoader()
                    .getResourceAsStream("bean.properties");
            properties.load(in);
            //实例化容器
            beans = new HashMap<String, Object>();
            //装载所有组件
            Enumeration keys = properties.keys();
            while (keys.hasMoreElements())
            {
                String key = keys.nextElement().toString();
                String beanPath = properties.getProperty(key);
                //反射创建对象
                Object object = Class.forName(beanPath).newInstance();
                //将对象加入到容器中
                System.out.println("装载类" + beanPath);
                beans.put(key, object);
            }
            System.out.println("初始化容器并装配组件完成");
        } catch (Exception e)
        {
            throw new ExceptionInInitializerError("初始化properties失败");
        }

    }

    public static Object getBean(String beanName)
    {
        return beans.get(beanName);
    }

}

com.lin下：

package com.lin;

import com.lin.service.IAccountService;

/**
 * Create by ljc on 2019/10/31
 */

public class Test
{

    public static void main(String[] args)
    {
        IAccountService iTestService = (IAccountService) MyBeanFactory.getBean("accountService");
        iTestService.saveService();

    }
}

resources下bean.properties文件：很重要的配置清单文件

accountService=com.lin.service.impl.AccountService
accountDao=com.lin.dao.impl.AccountDao

可以看到类的新建不再使用new关键字明确指定，而是使用容器管理，需要的时候直接从容器中获得需要的组件。

原文地址：https://www.cnblogs.com/jinchengll/p/11772131.html