备案控制台
探索云世界
开发者社区 开发与运维 文章 正文

Java代码实现依赖注入

2017-11-08 1517
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介：
这里将模仿 Spring 实现一种基于 xml 配置文件的 依赖注入 机制。文件中将实现 3 中注入，一是单值注入，包括 int,float ， double ， char 等，也包括 String 注入；二是 Java 容器注入，包括 List ， Set ， Map 三种容器的注入，最后一种是 java bean 对象注入。
实现的机制是，使用 Dom4j 对 xml 配置文件进行解析，这里使用 dom4j 的 Element Handler 机制，一种类似与责任链模式的实现机制；对于 java 对象的构建使用反射机制，这里主要是针对得到的类的 Field 进行 set 赋值。我试图通过调用 Method 的 invoke 方法调用类本身的 setter 方法，但是由于通过 xml 解析得到的值都是 String ，如果将这些 String 动态的转换为相应的确定类型是个难点， Method 的 invoke 方法，如果形参是 int ，而传入 java.lang.Integer ，它不会认，所以尝试失败，只能通过 Field 的 set 方法传入特定值。
 
配置文件 setting.xml
<? xml  version="1.0" encoding="UTF-8"?>
 
< beans >
     < bean  id="me" class="com.zj.ioc.di.imp.Person">
        < property  name="name">
            < value > ZJ </ value >
        </ property >
        < property  name="age">
            < value > 26 </ value >
        </ property >
        < property  name="height">
            < value > 1.78 </ value >
        </ property >
     </ bean >
     < bean  id="you" class="com.zj.ioc.di.imp.Person">
        < property  name="name">
            < value > Mary </ value >
        </ property >
        < property  name="age">
            < value > 27 </ value >
        </ property >
        < property  name="height">
            < value > 1.66 </ value >
        </ property >
     </ bean >
     < bean  id="myList" class="com.zj.ioc.di.imp.ListOne">
        < property  name="msg">
            < list >
               < value > java </ value >
               < value > c </ value >
               < value > windows </ value >
            </ list >
        </ property >
     </ bean >
     < bean  id="mySet" class="com.zj.ioc.di.imp.SetOne">
        < property  name="msg">
            < set >
               < value > tom </ value >
               < value > cat </ value >
               < value > dog </ value >
            </ set >
        </ property >
     </ bean >
     < bean  id="myMap" class="com.zj.ioc.di.imp.MapOne">
        < property  name="msg">
            < map >
               < entry  key="c">
                   < value > CHINA </ value >
               </ entry >
               < entry  key="j">
                   < value > JAPAN </ value >
               </ entry >
               < entry  key="k">
                   < value > KOREA </ value >
               </ entry >
            </ map >
        </ property >
     </ bean >
     < bean  id="us" class="com.zj.ioc.di.imp.Persons">
        < property  name="i">
            < ref  bean="me" />
        </ property >
        < property  name="u">
            < ref  bean="you" />
        </ property >
     </ bean >
</ beans >
 
依据 setting.xml ，这里将构建两个 Person 类的实例 me 和 you ：
Person.java
package  com.zj.ioc.di.imp;
 
public   class  Person {
     private  String  name ;
     private   int   age ;
     private   float   height ;
 
     public  String getName() { return   name ;}
     public   void  setName(String name) { this . name  = name;}
     public   int  getAge() { return   age ;}
     public   void  setAge( int  age) { this . age  = age;}
     public   float  getHeight() { return   height ;}
     public   void  setHeight( float  height) { this . height  = height;}
}
紧接着，构建一个 ListOne 的实例 myList ：
ListOne.java
package  com.zj.ioc.di.imp;
import  java.util.List;
 
public   class  ListOne {
     private  List<String>  msg ;
 
     public  List<String> getMsg() { return   msg ;}
     public   void  setMsg(List<String> msg) { this . msg  = msg;}
}
紧接着，构建一个 SetOne 的实例 mySet ：
SetOne.java
package  com.zj.ioc.di.imp;
import  java.util.Set;
 
public   class  SetOne {
     private  Set<String>  msg ;
 
     public  Set<String> getMsg() { return   msg ;}
     public   void  setMsg(Set<String> msg) { this . msg  = msg;}
}
紧接着，构建一个 MapOne 的实例 myMap ：
MapOne.java
package  com.zj.ioc.di.imp;
import  java.util.Map;
 
public   class  MapOne {
     private  Map<String,String>  msg ;
 
     public  Map<String, String> getMsg() { return   msg ;}
     public   void  setMsg(Map<String, String> msg) { this . msg  = msg;}
}
最后构建一个 Persons 类的实例 us ，其中包含 me 和 you 两个已经构建好的对象：
Persons.java
package  com.zj.ioc.di.imp;
 
public   class  Persons {
     private  Person  i ;
     private  Person  u ;
   
     public  Person getI() { return   i ;}
     public   void  setI(Person i) { this . i  = i;}
     public  Person getU() { return   u ;}
     public   void  setU(Person u) { this . u  = u;}
}
 
主要的实现机制是(代码BeanFactory.java以及工程见附件)，
1. 通过一个 HashMap 保存构造好的对象， key 就是 bean 的 id 属性， value 就是这个对象；
private  Map<String, Object>  beanMap  =  new  HashMap<String, Object>();
……
public  Object getBean(String beanId) {
    Object obj =  beanMap .get(beanId);
     return  obj;
}
查询时
BeanFactory factory =  new  BeanFactory();
factory.init( "setting.xml" );
Person p1 = (Person) factory.getBean( "me" );
 
2.init 方法读入配置文件 setting.xml ，并直接定位到 beans 下的 bean 元素，并实例化一个 ElementHandler 对其处理。
public   void  init(String xmlUri)  throws  Exception {
    SAXReader saxReader =  new  SAXReader();
    File file =  new  File(xmlUri);
     try  {
       saxReader.addHandler( "/beans/bean" ,  new  BeanHandler());
       saxReader.read(file);
    }  catch  (DocumentException e) {
       System. out .println(e.getMessage());
    }
}
 
3.ElementHandler ， dom4j 的 ElementHandler 接口有两个方法，一个是 onStart() ，它主要用于处理该元素的属性以及动态增加新的 Handler 类；另一个是 onEnd() ，它主要用于获得该元素的 Text 文本以及删除已添加的 Handler 。
BeanHandler
private   class  BeanHandler  implements  ElementHandler {
    Object  obj  =  null ;
 
     public   void  .Start(ElementPath path) {
       Element beanElement = path.getCurrent();
       Attribute classAttribute = beanElement.attribute( "class" );
 
       Class<?> bean =  null ;
        try  {
           bean = Class.forName(classAttribute.getText());
       }  catch  (ClassNotFoundException e) {
           e.printStackTrace();
       }
       Field fields[] = bean.getDeclaredFields();
       Map<String, Field> mapField =  new  HashMap<String, Field>();
        for  (Field field : fields)
           mapField.put(field.getName(), field);
        try  {
            obj  = bean.newInstance();
       }  catch  (InstantiationException e) {
           e.printStackTrace();
       }  catch  (IllegalAccessException e) {
           e.printStackTrace();
       }
 
       path.addHandler( "property" ,  new  PropertyHandler(mapField,  obj ));
    }
 
     public   void  .End(ElementPath path) {
       Element beanElement = path.getCurrent();
       Attribute idAttribute = beanElement.attribute( "id" );
        beanMap .put(idAttribute.getText(),  obj );
       path.removeHandler( "property" );
    }
}
   
PropertyHandler
private   class  PropertyHandler  implements  ElementHandler {
    Map<String, Field>  mapField ;
    Object  obj ;
 
     public  PropertyHandler(Map<String, Field> mapField, Object obj) {
        this . mapField  = mapField;
        this . obj  = obj;
    }
 
     public   void  .Start(ElementPath path) {
       Element propertyElement = path.getCurrent();
       Attribute nameAttribute = propertyElement.attribute( "name" );
       path.addHandler( "value" ,  new  ValueHandler( mapField ,  obj ,
              nameAttribute));
       path.addHandler( "list" ,  new  ListHandler( mapField ,  obj ,
              nameAttribute));
       path.addHandler( "set" ,  new  SetHandler( mapField ,  obj ,
              nameAttribute));
       path.addHandler( "map" ,  new  MapHandler( mapField ,  obj ,
              nameAttribute));
       path.addHandler( "ref" ,  new  RefHandler( mapField ,  obj ,
              nameAttribute));
    }
 
     public   void  .End(ElementPath path) {
       path.removeHandler( "value" );
       path.removeHandler( "list" );
       path.removeHandler( "set" );
       path.removeHandler( "map" );
       path.removeHandler( "ref" );
    }
}
 
根据 setting.xml ，我们可以得到各种注入元素的 Handler 类处理流程图。
 
4.  setFieldValue() 基于反射机制和相应的类信息得到 Field 的类型，并根据 setting.xml 设置它的值。
private   void  setFieldValue(Object obj, Field field, String value) {
    String fieldType = field.getType().getSimpleName();
     try  {
        if  (fieldType.equals( "int" ))
           field.setInt(obj,  new  Integer(value));
        else   if  (fieldType.equals( "float" ))
           field.setFloat(obj,  new  Float(value));
        else   if  (fieldType.equals( "boolean" ))
           field.setBoolean(obj,  new  Boolean(value));
        else   if  (fieldType.equals( "char" ))
           field.setChar(obj, value.charAt(0));
        else   if  (fieldType.equals( "double" ))
           field.setDouble(obj,  new  Double(value));
        else   if  (fieldType.equals( "long" ))
           field.setLong(obj,  new  Long(value));
        else
           field.set(obj, value);
    }  catch  (IllegalArgumentException e) {
       e.printStackTrace();
    }  catch  (IllegalAccessException e) {
       e.printStackTrace();
    }
}
 
private   void  setFieldValue(Object obj, Field field, List<String> value) {
     try  {
       field.set(obj, value);
    }  catch  (IllegalArgumentException e) {
       e.printStackTrace();
    }  catch  (IllegalAccessException e) {
       e.printStackTrace();
    }
}
 
5. 测试
public   static   void  main(String[] args) {
     try  {
       BeanFactory factory =  new  BeanFactory();
       factory.init( "setting.xml" );
 
       Person p1 = (Person) factory.getBean( "me" );
       System. out .print(p1.getName() +  " " );
       System. out .print(p1.getAge() +  " " );
       System. out .println(p1.getHeight());
 
       Person p2 = (Person) factory.getBean( "you" );
       System. out .print(p2.getName() +  " " );
       System. out .print(p2.getAge() +  " " );
       System. out .println(p2.getHeight());
 
       ListOne list = (ListOne) factory.getBean( "myList" );
       System. out .println(list.getMsg());
 
       SetOne set = (SetOne) factory.getBean( "mySet" );
       System. out .println(set.getMsg());
 
       MapOne map = (MapOne) factory.getBean( "myMap" );
       System. out .println(map.getMsg());
 
       Persons us = (Persons) factory.getBean( "us" );
       System. out .println(us.getI());
       System. out .println(us.getU());
    }  catch  (Exception e) {
       e.printStackTrace();
    }
}
测试结果：
ZJ 26 1.78
Mary 27 1.66
[java, c, windows]
[cat, tom, dog]
{c=CHINA, j=JAPAN, k=KOREA}
com.zj.ioc.di.imp.Person@1a5ab41
com.zj.ioc.di.imp.Person@18e3e60


本文转自zhangjunhd51CTO博客，原文链接：http://blog.51cto.com/zhangjunhd/126545，如需转载请自行联系原作者
文章标签：
Java
数据格式
XML
容器
Windows
Spring
关键词：
Java代码
Java依赖
Java代码实现
Java依赖注入
科技小先锋
目录
相关文章
技术君
|
13天前
|
Java 测试技术 应用服务中间件
常见 Java 代码缺陷及规避方式（下）
常见 Java 代码缺陷及规避方式（下）
技术君
41 0
舒一笑
|
15天前
|
Java
Java中ReentrantLock释放锁代码解析
Java中ReentrantLock释放锁代码解析
舒一笑
25 8
Y2000104
|
18天前
|
前端开发 小程序 Java
uniapp上传图片 前端以及java后端代码实现
uniapp上传图片 前端以及java后端代码实现
Y2000104
32 0
喜欢猪猪
|
20天前
|
设计模式 存储 Java
23种设计模式，享元模式的概念优缺点以及JAVA代码举例
【4月更文挑战第6天】享元模式（Flyweight Pattern）是一种结构型设计模式，旨在通过共享技术有效地支持大量细粒度对象的重用。这个模式在处理大量对象时非常有用，特别是当这些对象中的许多实例实际上可以共享相同的状态时，从而可以减少内存占用，提高程序效率
喜欢猪猪
35 4
喜欢猪猪
|
20天前
|
设计模式 Java 中间件
23种设计模式，适配器模式的概念优缺点以及JAVA代码举例
【4月更文挑战第6天】适配器模式（Adapter Pattern）是一种结构型设计模式，它的主要目标是让原本由于接口不匹配而不能一起工作的类可以一起工作。适配器模式主要有两种形式：类适配器和对象适配器。类适配器模式通过继承来实现适配，而对象适配器模式则通过组合来实现
喜欢猪猪
30 4
桃李春风一杯酒
|
21天前
|
存储 缓存 算法
优化 Java 后台代码的关键要点
【4月更文挑战第5天】本文探讨了优化 Java 后台代码的关键点，包括选用合适的数据结构与算法、减少不必要的对象创建、利用 Java 8 新特性、并发与多线程处理、数据库和缓存优化、代码分析与性能调优、避免阻塞调用、JVM 调优以及精简第三方库。通过这些方法，开发者可以提高系统性能、降低资源消耗，提升用户体验并减少运营成本。
桃李春风一杯酒
31 14
游客fo2eqpxud5eue
|
22天前
|
Java 开发工具 流计算
flink最新master代码编译出现Java Runtime Environment 问题
在尝试编译Flink源码时遇到Java运行时环境致命错误：EXCEPTION_ACCESS_VIOLATION。问题出现在JVM.dll+0x88212。使用的是Java 11.0.28和Java HotSpot(TM) 64-Bit Server VM。系统为Windows客户端，没有生成核心dump文件。错误日志保存在hs_err_pid39364.log和replay_pid39364.log。要解决这个问题，建议检查JDK版本兼容性，更新JDK或参照错误报告文件提交Bug至http://bugreport.java.com/bugreport/crash.jsp。
游客fo2eqpxud5eue
28 0
是阿超
|
23天前
|
Java
使用Java代码打印log日志
使用Java代码打印log日志
是阿超
77 1
桃李春风一杯酒
|
23天前
|
设计模式 Java 数据库
Java设计模式精讲：让代码更优雅、更可维护
【4月更文挑战第2天】**设计模式是解决软件设计问题的成熟方案，分为创建型、结构型和行为型。Java中的单例模式确保类仅有一个实例，工厂方法模式让子类决定实例化哪个类。适配器模式则协调不兼容接口间的合作。观察者模式实现了一对多依赖，状态变化时自动通知相关对象。学习和适当应用设计模式能提升代码质量和可维护性，但需避免过度使用。设计模式的掌握源于实践与不断学习。**
桃李春风一杯酒
20 4
Java设计模式精讲：让代码更优雅、更可维护
薛伟同学
|
13天前
|
Java
代码的魔法师：Java反射工厂模式详解
代码的魔法师：Java反射工厂模式详解
薛伟同学
26 0

热门文章

最新文章

  • 1
    Java中的多线程编程：概念、实现与性能优化
  • 2
    基于 java + Springboot + vue +mysql 大学生实习管理系统（含源码）
  • 3
    使用Java代码打印log日志
  • 4
    Java数据结构与算法-java数据结构与算法（二）
  • 5
    【JVM故障问题排查心得】「Java技术体系方向」Java虚拟机内存优化之虚拟机参数调优原理介绍（一）
  • 6
    深入理解Java并发编程：线程安全与性能优化
  • 7
    Java入门高频考查基础知识4（字节跳动面试题18题2.5万字参考答案）
  • 8
    开发语言详解（python、java、Go(Golong)。。。。）
  • 9
    《理解 WebSocket：Java Web 开发的实时通信技术》
  • 10
    java线程池讲解面试
  • 1
    Java中的集合框架：深入理解与应用
    19
  • 2
    Java并发编程：理解并使用Future和Callable接口
    17
  • 3
    性能工具之 Java 调试工具 JDB
    45
  • 4
    JAVA云HIS系统医院信息管理源码
    31
  • 5
    Java基于物联网技术的智慧工地云管理平台源码 依托丰富的设备接口标准库，快速接入工地现场各类型设备
    148
  • 6
    [Java基础]——JVM内存模型
    36
  • 7
    [Java基础]——类的生命周期
    13
  • 8
    [java进阶]——泛型类、泛型方法、泛型接口、泛型的通配符
    23
  • 9
    【java进阶】Java中线程的实现方式
    14
  • 10
    【java进阶】集合的三种遍历(迭代器、增强for、Lambda)
    17

    • 相关课程

    更多
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • JAVA开发手册1.5.0

    • 相关实验场景

    更多
  • 基于ECS搭建Java Web开发环境
  • 使用Aliyun Java Intializr进行项目开发
  • 搭建Java Web开发环境
  • 部署基于Dragonwell的Java运行环境
  • 阿里云平台上进行Java程序的编译与运行
    • 下一篇
    部署LAMP环境（Alibaba Cloud Linux 3）