一个类的简单SPRING

开发 后端
你是否常编一些小工具,做一些小东西?在你扩展维护的时候,是不是觉得实例传递越来越复杂?你经常改变想法,但小东西不停重构开始耽误你越来越多的时间?你想到了用spring,但又不想对于一个简单的小东西,引入一个相对小重的框架,让你的小程序加载时都需要卡一下?

你是否常编一些小工具,做一些小东西?

在你扩展维护的时候,是不是觉得实例传递越来越复杂?

你经常改变想法,但小东西不停重构开始耽误你越来越多的时间?

你想到了用spring,但又不想对于一个简单的小东西,引入一个相对小重的框架,让你的小程序加载时都需要卡一下?

哈,试一试用下simpleFactory,是否可以解决你的烦恼,只有一个类哦,copy一下,就可以帮助你实现依赖注入;

simpleFactory是我在做小实验时,为了解决上面的问题,自己写的编码小工具,至少自己用起来很哈皮

SF代码:

  1. package com.honeysuckle.webx.context;     
  2.     
  3. import java.lang.reflect.Constructor;     
  4. import java.lang.reflect.Method;     
  5. import java.util.HashMap;     
  6. import java.util.LinkedList;     
  7. import java.util.Map;     
  8. import java.util.Queue;     
  9.     
  10. /**    
  11.  * 类SF.java的实现描述:SimpleBeanFactory no one simpler than this one    
  12.  *     
  13.  * @author yanghang 2010-9-16 下午04:43:05    
  14.  */    
  15. public class SF {     
  16.     
  17.     private final Map<Class<?>, Object> context = new HashMap<Class<?>, Object>();     
  18.     
  19.     /**    
  20.      * 向容器中放入某个实例    
  21.      * @param clazz 该实例的类型,可以是接口    
  22.      * @param object 该实例    
  23.      */    
  24.     public void put(Class<?> clazz, Object object) {     
  25.         this.context.put(clazz, object);     
  26.     }     
  27.     
  28.     /**    
  29.      * 获取某个实例(单例) <br/>    
  30.      * 如果容器中不存在,会尝试初使化: <br/>    
  31.      * 1.调用构造函数,args为可能的构造函数的参数 <br/>    
  32.      * 2.会对该实例的set方法进行注入 <br/>    
  33.      * 3.最后会调用init()方法 <br/>         
  34.      */    
  35.     public Object get(Class<?> clazz, Object... args) {     
  36.         Object object = this.context.get(clazz);     
  37.         if (object == null) {     
  38.             try {     
  39.                 object = this.instanceClazz(clazz, args);     
  40.                 this.instanceSetMethod(object);     
  41.                 this.instanceInitMethod(object);     
  42.                 this.put(clazz, object);     
  43.             } catch (Exception e) {     
  44.                 return null;     
  45.             }     
  46.         }     
  47.         return object;     
  48.     }     
  49.     
  50.     //获取某个实例的多例,每次都会重新产生该实例     
  51.     public Object getMulti(Class<?> clazz, Object... args) {     
  52.         Object object;     
  53.         try {     
  54.             object = this.instanceClazz(clazz, args);     
  55.             this.instanceSetMethod(object);     
  56.             this.instanceInitMethod(object);     
  57.         } catch (Exception e) {     
  58.             return null;     
  59.         }     
  60.         return object;     
  61.     }     
  62.     
  63.     //初使化该类,调用构造方法     
  64.     private Object instanceClazz(Class<?> clazz, Object[] args) throws Exception {     
  65.         Object object = null;     
  66.         Class<?>[] clazzes = new Class[args.length];     
  67.         for (int i = 0; i < args.length; i++) {     
  68.             clazzes[i] = args[i].getClass();     
  69.         }     
  70.         Constructor<?>[] cons = clazz.getConstructors();     
  71.         for (Constructor<?> con : cons) {     
  72.             if (con.getParameterTypes().length != args.length) continue;     
  73.             object = con.newInstance(args);     
  74.         }     
  75.         return object;     
  76.     }     
  77.     
  78.     //根据set方法,进行注入     
  79.     private void instanceSetMethod(Object object) {     
  80.         Method[] methods = object.getClass().getDeclaredMethods();     
  81.         Queue<Method> queue = new LinkedList<Method>();     
  82.         for (Method method : methods) {     
  83.             queue.add(method);     
  84.         }     
  85.         for (int i = queue.size(); queue.size() > 0; i = queue.size()) {     
  86.             Method method = queue.poll();     
  87.             if (method.getName().indexOf("set") != 0continue;     
  88.             Class<?>[] clazzes = method.getParameterTypes();     
  89.             if (clazzes.length != 1continue;     
  90.             Class<?> pclazz = clazzes[0];     
  91.             try {     
  92.                 Object pObject = this.get(pclazz);     
  93.                 method.invoke(object, new Object[] { pObject });     
  94.             } catch (Exception e) {     
  95.                 continue;     
  96.             }     
  97.             if (i == queue.size()) break;     
  98.         }     
  99.     }     
  100.     
  101.     // 初使化该类,调用init方法     
  102.     private void instanceInitMethod(Object object) {     
  103.         try {     
  104.             Method method = object.getClass().getMethod("init"new Class<?>[] {});     
  105.             method.invoke(object, new Object[] {});     
  106.         } catch (Exception e) {     
  107.             return;     
  108.         }     
  109.     }     
  110. }   

用法示例
有类Bean1
 

  1.     
  2. public class Bean1 {     
  3.     
  4.     private String hello;     
  5.     
  6.     public void init() {     
  7.         this.hello = "hello kitty";     
  8.     }     
  9.     
  10.     public void show() {     
  11.         System.out.println(this.hello);     
  12.     }     
  13. }    

执行 TestSF
 

  1. public class TestSF {     
  2.     
  3.     private Bean1 bean;     
  4.     
  5.     public void setBean(Bean1 bean) {     
  6.         this.bean = bean;     
  7.     }     
  8.     
  9.     public void test() {     
  10.         this.bean.show();     
  11.     }     
  12.     
  13.     public static void main(String[] args) {     
  14.         SF sf = new SF();     
  15.         TestSF test = (TestSF) sf.get(TestSF.class);     
  16.         test.test();     
  17.     }     
  18. }   

输出:
 

  1. hello kitty   

 

责任编辑:金贺 来源: JavaEye博客
相关推荐

2011-04-12 14:58:23

加密解密类

2021-09-02 10:01:58

Spring 容器AOP

2023-12-16 13:21:00

Python元类ORM

2018-11-22 14:09:45

iOS架构组件开发

2009-08-19 04:14:00

线性链表

2023-02-07 10:40:30

gRPC系统Mac

2009-07-14 16:02:42

JDBC例子

2020-11-09 06:38:00

ninja构建方式构建系统

2020-03-16 17:20:02

异常处理Spring Boot

2011-09-08 13:41:53

Widget

2022-10-31 08:27:53

Database数据数据库

2019-11-07 14:00:36

MySQL数据库SQL

2016-09-21 12:54:10

CAAS系统镜像

2016-11-08 18:53:08

编译器

2017-08-17 16:37:59

MySQL数据迁移

2013-04-25 09:55:21

进程线程

2021-11-04 10:29:01

CSS前端

2010-04-19 17:21:36

Oracle写文件

2020-03-26 17:00:53

HashMapputJava

2021-07-20 10:30:46

Golanghttp语言
点赞
收藏

51CTO技术栈公众号