Java代码实现依赖注入

最新推荐文章于 2023-08-21 09:05:39 发布
最新推荐文章于 2023-08-21 09:05:39 发布
阅读量431 收藏
点赞数
分类专栏： java

（转载）http://zhangjunhd.blog.51cto.com/113473/126545

这里将模仿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

本文出自 “子 孑” 博客，请务必保留此出处http://zhangjunhd.blog.51cto.com/113473/126545


u010746364
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java中spring依赖注入的简单例子
03-11
javaEE 开发中 现在最成熟的框架之一应该就是spring了 spring框架最强大的地方就是实现了依赖注入 也叫控制反转 最近的一个项目中用的就是 spring框架 spring框架是工厂模式的应用结合了ＭＶＣ的设计思想 大家可以看到在spring框架中到处体现工厂模式 下面是一个简单的例子 依赖注入早期叫控制反转 也可以称反射 他们的意义都相同 当某个 Java 实例 调用者 需要另一个Java 实例 被调用者 时 在传统的程序设计过程中 通常由调用者来创建被调用者的实例 而在依赖注入的模式下 创建被调用者的工作 也就是实例化一个类 不再由调用者来完成 通常由 Spring 容器来完成 然后注入调用者 因此称为控制反转 也称为依赖注入 ">javaEE 开发中 现在最成熟的框架之一应该就是spring了 spring框架最强大的地方就是实现了依赖注入 也叫控制反转 最近的一个项目中用的就是 spring框架 spring框架是工厂模式的应用结合了ＭＶＣ的设计思想 大家可以看到在spring框 [更多]
200行Java代码实现依赖注入框架
weixin_34405925的博客
05-01 69
依赖注入框架并不神秘，其实它是非常简单的东西。不要去看spring的依赖注入源码，因为你只要一去看就意味着你再也写不敢下手自己撸了，它的功能因为过于强大，所以设计也过于复杂，普通程序员一眼看去只能望洋兴叹。 我也并没有去细致阅读spring源码。即便如此也只用了半天的时间便自己撸了一个基本满足标准依赖注入规范「JSR-330」的小框架iockids。这个小框架只有一个主类Injector，大约20...
依赖注入 java_Java代码实现依赖注入
weixin_35988836的博客
02-20 263
http://zhangjunhd.blog.51cto.com/113473/126545这里将模仿Spring实现一种基于xml配置文件的依赖注入机制。文件中将实现3中注入，一是单值注入，包括int,float，double，char等，也包括String注入；二是Java容器注入，包括List，Set，Map三种容器的注入，最后一种是java bean对象注入。实现的机制是，使用Dom4j对...
200行Java代码如何实现依赖注入框架详解
08-27
依赖注入对大家来说应该都不陌生，下面这篇文章主要给大家介绍了关于利用200行Java代码如何实现依赖注入框架的相关资料，文中通过示例代码介绍的非常详细，需要的朋友可以参考借鉴，下面随着小编来一起学习学习吧
java Spring DI依赖注入.rar
01-30
Java Spring 框架是企业级Java应用开发的首选框架之一，其核心特性之一就是依赖注入（Dependency Injection，简称DI）。依赖注入是一种设计模式，它允许我们解耦组件，提高代码的可测试性和可维护性。Spring框架通过...
golang不到30行代码实现依赖注入的方法
09-20
尽管Golang没有像Java那样的动态创建对象能力，但我们依然可以通过这样的方式实现依赖注入，使得代码更加灵活和易于测试。 通过这个简单的示例，我们可以看到在Golang中实现依赖注入并不复杂，关键在于理解依赖注入...
深入解析Java的Spring框架中bean的依赖注入
09-03
在Java的Spring框架中，依赖注入（Dependency Injection，简称DI）是一种设计模式，用于降低代码间的耦合度，提高软件的可测试性和可维护性。Spring框架提供了实现DI的主要机制，使得对象之间的依赖关系可以通过外部...
java web中spring自动注入autowired极度精简版源代码
10-11
java web开中spring在autowired自动注入极度精简版本，绝对可以运行。博客地址： http://blog.csdn.net/qq5132834/article/details/47870351
java模拟spring实现依赖注入
new Girl的博客
11-24 501
http://only1.iteye.com/blog/733550 这个是java 的spring 框架 的简单例子 我个人理解原理是 1.将接口和实现类的关系 记录到xml 文件 2.运行的时候解析xml 文件 获取关系 3.根据关系，反射 new 出实际的 实现类 4.注入 使用
java依赖注入实现方式_java Spring中如何实现依赖注入
weixin_34797773的博客
02-16 159
总得来说，Spring中依赖注入有这么三种方式:①通过set方式赋值②通过构造器赋值③通过p标签赋值java相关视频教程推荐：java视频下面我们稍稍展开来谈:1.通过set方式赋值主要用到围堵标签来传递值此处的name就是Teacher类里声明的变量名,value就是你要给这个变量赋什么值。Teacher类：public class Teacher {private String name;pr...
java 代码动态注入
weixin_30852451的博客
06-14 867
参考http://www.ibm.com/developerworks/cn/java/j-lo-jse61/ 转载于:https://www.cnblogs.com/wjw334/p/4575370.html
Java表达式注入（JSP EL表达式注入）
GalaxySpaceX的博客
08-16 1078
Java表达式注入（JSP EL表达式注入）
Java动态字节码注入技术
最新发布
琅琊之榜
08-21 1219
Java动态字节码注入技术是一种在运行时修改Java字节码的技术。它允许开发者在程序运行期间动态地向现有的Java类中注入字节码，并改变类的行为和功能。这项技术通常用于实现AOP（面向切面编程）、代码增强、动态代理等需求。
java 代码注入_200行Java代码实现依赖注入框架
weixin_35734209的博客
02-20 187
依赖注入框架并不神秘，其实它是非常简单的东西。不要去看spring的依赖注入源码，因为你只要一去看就意味着你再也写不敢下手自己撸了，它的功能因为过于强大，所以设计也过于复杂，普通程序员一眼看去只能望洋兴叹。我也并没有去细致阅读spring源码。即便如此也只用了半天的时间便自己撸了一个基本满足标准依赖注入规范「JSR-330」的小框架iockids。这个小框架只有一个主类Injector，大约200...
使用AspectJ，Javassist和Java Proxy进行代码注入的实用介绍
最佳 Java 编程
05-07 610
静态地或在运行时将代码片段注入已编译的类和方法中的功能可能会很有帮助。 这尤其适用于在没有源代码的第三方库中或在无法使用调试器或探查器的环境中对问题进行故障排除。 代码注入对于处理涉及整个应用程序的问题（例如性能监视）也很有用。 以这种方式使用代码注入在面向方面编程 （AOP）的名字下变得很流行。 相反，代码注入并不是很少使用，就像相反。 每个程序员都会遇到这种能力可以避免很多痛苦和沮丧的情...
java代码动态注入与class文件热加载实现
qq_21223653的博客
05-09 5904
一、java代码动态注入 在本文中，我们将研究如何将Java代码动态加载到正在运行的jvm中。 该代码可能是全新的，或者我们可能想更改程序中某些现有代码的功能。 （在开始之前，您可能想知道为什么到底有人会这样做。显而易见的示例是规则引擎之类的东西。规则引擎希望为用户提供添加或更改规则的能力，而不必重新启动规则。您可以通过将DSL脚本作为规则注入规则库来执行此操作，这种方法的真正问题在于，必须对DSL脚本进行解释，使其运行起来极其缓慢。然后可以像程序中的任何其他代码一样编译和运行该程序，效率将提高几个数量级。
Java如何实现静态变量的依赖注入代码具体实现
04-11
静态变量是属于类的变量，不能通过实例来访问和修改。因此，在注入静态变量时，需要使用特殊方法。常见的方式是使用静态代码块，例如： ``` public class MyService { public static MyDependency dependency; static { dependency = new MyDependency(); } } ``` 在上述示例中，我们使用静态代码块来初始化静态变量 dependency，并将其实例化为 MyDependency 类的实例。 此外，还可以使用构造函数或静态方法来注入静态变量。例如： ``` public class MyService { public static MyDependency dependency; public static void initialize(MyDependency dep) { dependency = dep; } } ``` 在上述示例中，我们使用静态方法 initialize 来注入静态变量 dependency，并将其值设置为传入的 MyDependency 实例。 希望对你有所帮助！

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值