1.配置檔案

Service=service.Impl.ServiceImpl

saveDao=dao.daoImpl.saveDaoImpl

2.模擬業務層

--介面 Service

package service;
/**
 * service層
 * @date 2019/10/29 16:42
 */
public interface Service {
    void save() throws IllegalAccessException, InstantiationException, ClassNotFoundException;
}

--實現 ServiceImpl

package service.Impl;
import factory.BeanFactory;
import service.Service;
import dao.*;
/**
 * 服務層
 * @date 2019/10/29 22:33
 */
public class ServiceImpl implements Service {
    //saveDao dao=new saveDaoImpl();//依賴很高 而且控制權在被呼叫者

    public void save() throws IllegalAccessException, InstantiationException, ClassNotFoundException {
        
 
int i = 1 ;
        //物件的例項不再由呼叫者來建立,而是由容器來建立
        saveDao dao =(saveDao) BeanFactory.getBean("saveDao");//使用配置檔案和反射解耦(這就是IOC)
        dao.save();
        System.out.println(i+"service");
        i++;
    }
}
//控制反轉和依賴注入 一樣

3.工廠BeanFactory

package factory;
import java.io.IOException;
import
 
 java.io.InputStream;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;
/**
 * 一個建立bean物件的工廠
 * bean: 在計算機中,有可重用的元件含義
 * javaBean:用java語言編寫的可重用元件
 * javaBean>實體類
 *
 * 第一個:需要一個配置檔案配置service和dao
 * 第二個:通過讀取配置檔案內容,反射建立物件
 * @date 2019/10/29 20:01
 */
public class BeanFactory {
    private static Properties properties;
    //定義一個map,用於存放我們要建立的物件,我們把它稱之為容器
    private static Map<String,Object> beans;
    static {
        properties=new Properties();
        InputStream stream = BeanFactory.class.getClassLoader().getResourceAsStream("bean.properties");
        try {
            properties.load(stream);
            //例項化容器
            beans= new HashMap<String, Object>();
            //取出所有配置檔案中所有的key
            Enumeration keys = properties.keys();
            //遍歷列舉
            while (keys.hasMoreElements()){
                //取出每個key
                String key=keys.nextElement().toString();
                //根據key獲取value
                String beanPath = properties.getProperty(key);
                //反射建立物件
                Object value = Class.forName(beanPath).newInstance();
                //存入map
                beans.put(key,value);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

    }
    //根據bean的  名字獲取bean物件(單例)
    public static Object getBean(String beanName) throws ClassNotFoundException, IllegalAccessException, InstantiationException {
       /* Object bean= null;
        String property = properties.getProperty(beanName);
        bean = Class.forName(property).newInstance();*/ //此次例項化就使用map了...上面

        return beans.get(beanName);

    }
}

4.模擬dao層

--介面saveDao

package dao;
/**
 * dao層
 * @date 2019/10/29 16:42
 */
public interface saveDao {
    void save();
}

--實現類saveDaoImpl

package dao.daoImpl;

import dao.saveDao;

public class saveDaoImpl implements saveDao {
    public void save() {
        System.out.println("dao儲存...");
    }
}

----------測試--------

import factory.BeanFactory;
import service.Impl.ServiceImpl;

/**
 * 模擬三層架構(使用new 會增加耦合性 所以通過 配置檔案和反射就會降低耦合  這也就是spring的核心)
 * @date 2019/10/29 16:40
 */
public class test {
    public static void main(String[] args) throws IllegalAccessException, InstantiationException, ClassNotFoundException {
       /* Service service=new ServiceImpl();//在使用new時增強了程式之間的耦合性
        service.save();*/


        for (int i = 0; i < 5; i++) {
            //使用反射 (此方法相當於上面的程式碼只是解耦了 也就是編譯期間不會報錯,執行期間會)
            ServiceImpl service =(ServiceImpl) BeanFactory.getBean("Service");
            System.out.println(service);//此時列印的物件都不相同(多例)
            //使用容器後列印的是同一個對像(那麼也就提高了程式碼的效能)
            service.save();
        }
    }
}