java IoC

IoC，控制反转，是spring的核心，通俗点讲就是我们不必再自己去用new创建对象了，通过l配置将类注入到IoC容器中，在启动时，IoC容器去帮我们创建对象，并管理其依赖关系，这种实现方式叫做DI，依赖注入。为什么我们要用IoC去帮我们管理对象呢，因为通常一个业务逻辑都是由多个对象合作完成工作的，如果自己管理的话比较，就要在一个方法中调用多个对象，不好管理，重用性低。

     //使用工厂模式加配置文件的方式模范了一个简易IoC的工作原理 //1.BeanFactory.java  bean工厂，创建对象 //2.PropertiesReader.java 读取配置文件 //3.普通bean类 //4.测试类 

 

 package myIoC;
 /**
  * 1.读取配置文件接口，有两个实现类，一个用类加载路径读取配置文件，第二个用文件路径读取配置文件
  * 2.提供Bean工厂方法
  * @author LH-PC
  *
  */
 public interface ApplicationContext {

     /**
      * bean工厂方法
      * @param name
      * @return
      */
     Object getBean(String name);
     Object getBean(String name, String className);

 }

 package myIoC;

 import java.util.Date;
 import java.util.Map;

 /**
  * ApplicationContext实现类之一，类加载读取配置文件
  * @author LH-PC
  *
  */
 public class ClassPathXmlApplicationContext implements ApplicationContext{

     private String propertiesName;

     /**
      * 构造方法用于加载配置文件
      * @param xml
      */
     public ClassPathXmlApplicationContext(String propertiesName){
         //初始化属性
         this.propertiesName = propertiesName;
     }

     /**
      * 通过类加载方式的工厂方法
      */
     public Object getBean(String name) {
         //读取配置文件
         PropertiesReader propertiesReader = new PropertiesReader(propertiesName);
         Object object = null;
         //创建对象
         Map<String, String> map = propertiesReader.getProperties();
         try {
             System.err.println(new Date() +": " + "BeanFactory开始生产对象...");
             object =  Class.forName(map.get(name)).newInstance();
             System.err.println(new Date() +": " + "生产对象完毕");
         } catch (InstantiationException e) {
             System.err.println(new Date() +": " + "创建对象异常");
             e.printStackTrace();
         } catch (IllegalAccessException e) {
             System.err.println(new Date() +": " + "IllegalAccessException异常");
             e.printStackTrace();
         } catch (ClassNotFoundException e) {
             System.err.println(new Date() +": " + "类加载异常");
             e.printStackTrace();
         }

         return object;
     }

     public Object getBean(String name, String className) {
         // TODO Auto-generated method stub
         return null;
     }

 }

 package myIoC;

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

 //读取properties文件类
 public class PropertiesReader {

     private Properties pro = null;
     private InputStream in = null;
     private String propertiesName = null;

     public PropertiesReader(String propertiesName){
         this.propertiesName = propertiesName;
     }

     @SuppressWarnings("rawtypes")
     public  Map<String,String> getProperties(){
         Map<String, String> map = new HashMap<String, String>();
         pro = new Properties();  //创建properties对象
         try {
             System.err.println(new Date() +": " + "开始读取" + propertiesName + "...");
             in = PropertiesReader.class.getClassLoader().getResourceAsStream(propertiesName); //通过反射机制读取配置文件
             if(in == null){
                 System.err.println(new Date() +": " + "读取流为空");
             }else{
                 //开始加载文件内容
                 pro.load(in);
                 System.err.println(new Date() +": " + propertiesName + "读取成功");
             }
             Enumeration en = pro.propertyNames();        //迭代器遍历pro
             while(en.hasMoreElements()){
                 String key = (String) en.nextElement();  //遍历key
                 String value = pro.getProperty(key);     //根据key取出value，放进map
                 map.put(key,value);
             }
         } catch (IOException e) {
             System.err.println(new Date() +": " + "io异常");
             e.printStackTrace();
         }
         finally{
             if(in != null){
                 try {
                     in.close();//关闭读取流
                     System.err.println(new Date() +": " + "读取流关闭成功");
                 } catch (IOException e) {
                     System.err.println(new Date() +": " + "读取流关闭失败");
                     e.printStackTrace();
                 }
             }
         }
         return map;
     }

     public static void main(String[] args) {
         PropertiesReader propertiesReader = new PropertiesReader("myIoc/applicationContext.properties");
         Map<String, String> map = propertiesReader.getProperties();
         System.out.println("ok");
     }

 }

student=myIoC.Student
bean2=test.BeansImpl2
bean3=test.BeansImpl3

 package myIoC;

 /**
  * MyIoC测试类
  * @author LH-PC
  */
 public class IoCTest {
     public static void main(String[] args) {
         ApplicationContext applicationContext = new ClassPathXmlApplicationContext("myIoc/applicationContext.properties");
         Student student = (Student) applicationContext.getBean("student");
         student.setSid("15301");
         student.setSname("海");
         System.out.println(student.getSid());
         System.out.println(student.getSname());

     }

 }

 /**
  * 测试实体类
  * @author LH-PC
  *
  */
 class Student {
     private String sname;
     private String sid;

     public String getSname() {
         return sname;
     }

     public void setSname(String sname) {
         this.sname = sname;
     }

     public String getSid() {
         return sid;
     }

     public void setSid(String sid) {
         this.sid = sid;
     }

 }