`

JAVA动态对象装配实现 测试--初步实现bean的set/get功能

BeanJavaF#EclipseJ# 
阅读更多 
V1. 没有一点头绪,似乎只是在反射中 ... 写这个的目的是,实现自定义装配bean功能...
/**
 * 创建动态对象的
 */
package cn.iamsese.dyo;

import java.util.Enumeration;
import java.util.Hashtable;

/**
 * @author iamsese.cn
 *
 */
class MyObject {

    @Override
    public String toString() {
	return "Object 原始对象 MyObject!";
    }
    
}

public class DYNC_Object {

    /**
     * @param args
     */
    private static Hashtable db = new Hashtable();
    private static void dbOutput()
    {
	_dbPrint(db.keys());
    }
    
    private static void _dbPrint(Enumeration dbkeys)
    {
	if (dbkeys != null && db != null)
	{
	    while (dbkeys.hasMoreElements()){
		Object key = dbkeys.nextElement() ;
		System.out.println(key + "=" + db.get(key));
	    }
	}
    }
  
    public static void main(String[] args) {
	Object o = new MyObject();
	db.put("key1", o);
	db.put("key2", new DYNC_Object());
	dbOutput();
    }
    
    public String toString(){
	return "Dync_Object!" ;
    }

}

 

2
顶
1
踩
分享到：
| CSS实现纯图片替换效果和div模拟下拉条的 ...
评论
3 楼 vb2005xu 2009-01-12  
JAVA动态代理 http://java.e800.com.cn/articles/2008/917/1221639208579_1.html
2 楼 vb2005xu 2009-01-12  
V2 运行结果如下 
D:\eclipse\workspace\doswt\bin>java cn.iamsese.dyo.DYNC_Object
key2=Dync_Object!
key1=Object 原始对象 MyObject!
**当前字段信息 [开始]**
Field name: iname
Field type: java.lang.String
Field value: null
**当前字段信息 [结束]**

动态设置属性值成功! -- 1
**当前字段信息 [开始]**
Field name: iname
Field type: java.lang.String
Field value: 动态设置属性值成功! -- 1
**当前字段信息 [结束]**

+++++cn.iamsese.dyo.MyObject++++开始

**当前字段信息 [开始]**
Field name: iname
Field type: java.lang.String
Field value: 动态设置属性值成功! -- 2
**当前字段信息 [结束]**

+++++cn.iamsese.dyo.MyObject++++结束
1 楼 vb2005xu 2009-01-12  
V2 添加如下功能:
1.输出指定对象的属性信息
2.根据给定的字符串属性名输出这个属性的信息[属性,类型和值]
3.实现简单的类似bean的get/set功能,可以通过一个字符串属性名称来设置或者获取此属性的值 

/**
 * 创建动态对象的
 */
package cn.iamsese.dyo;

import java.lang.reflect.Array;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Enumeration;
import java.util.Hashtable;

/**
 * @author iamsese.cn
 *
 */
class MyObject {
    /**
     * 自身属性 iname
     */
    public String iname;

    public String getIname() {
	return iname;
    }

    public void setIname(String iname) {
	this.iname = iname;
    }

    @Override
    public String toString() {
	return "Object 原始对象 MyObject!";
    }

}

/**   
 * Java Reflection Cookbook   
 *   
 * @author Michael Lee   
 * @since 2006-8-23   
 * @version 0.1a   
 */

class MyReflection {
    /**   
     * 得到某个对象的公共属性   
     *   
     * @param owner, fieldName   
     * @return 该属性对象   
     * @throws Exception   
     *   
     */
    public Object getProperty(Object owner, String fieldName) throws Exception {
	Class ownerClass = owner.getClass();
	Field field = ownerClass.getField(fieldName);
	Object property = field.get(owner);
	return property;
    }

    /**   
     * 得到某类的静态公共属性   
     *   
     * @param className   类名   
     * @param fieldName   属性名   
     * @return 该属性对象   
     * @throws Exception   
     */
    public Object getStaticProperty(String className, String fieldName)
	    throws Exception {
	Class ownerClass = Class.forName(className);

	Field field = ownerClass.getField(fieldName);

	Object property = field.get(ownerClass);

	return property;
    }

    /**   
     * 执行某对象方法   
     *   
     * @param owner   
     *            对象   
     * @param methodName   
     *            方法名   
     * @param args   
     *            参数   
     * @return 方法返回值   
     * @throws Exception   
     */
    public Object invokeMethod(Object owner, String methodName, Object[] args)
	    throws Exception {

	Class ownerClass = owner.getClass();

	Class[] argsClass = new Class[args.length];

	for (int i = 0, j = args.length; i < j; i++) {
	    argsClass[i] = args[i].getClass();
	}

	Method method = ownerClass.getMethod(methodName, argsClass);

	return method.invoke(owner, args);
    }

    /**   
     * 执行某类的静态方法   
     *   
     * @param className   
     *            类名   
     * @param methodName   
     *            方法名   
     * @param args   
     *            参数数组   
     * @return 执行方法返回的结果   
     * @throws Exception   
     */
    public Object invokeStaticMethod(String className, String methodName,
	    Object[] args) throws Exception {
	Class ownerClass = Class.forName(className);

	Class[] argsClass = new Class[args.length];

	for (int i = 0, j = args.length; i < j; i++) {
	    argsClass[i] = args[i].getClass();
	}

	Method method = ownerClass.getMethod(methodName, argsClass);

	return method.invoke(null, args);
    }

    /**   
     * 新建实例   
     *   
     * @param className   
     *            类名   
     * @param args   
     *            构造函数的参数   
     * @return 新建的实例   
     * @throws Exception   
     */
    public Object newInstance(String className, Object[] args) throws Exception {
	Class newoneClass = Class.forName(className);

	Class[] argsClass = new Class[args.length];

	for (int i = 0, j = args.length; i < j; i++) {
	    argsClass[i] = args[i].getClass();
	}

	Constructor cons = newoneClass.getConstructor(argsClass);

	return cons.newInstance(args);

    }

    /**   
     * 是不是某个类的实例   
     * @param obj 实例   
     * @param cls 类   
     * @return 如果 obj 是此类的实例，则返回 true   
     */
    public boolean isInstance(Object obj, Class cls) {
	return cls.isInstance(obj);
    }

    /**   
     * 得到数组中的某个元素   
     * @param array 数组   
     * @param index 索引   
     * @return 返回指定数组对象中索引组件的值   
     */
    public Object getByArray(Object array, int index) {
	return Array.get(array, index);
    }
}






/**
 * @author iamsese.cn
 *
 */
public class DYNC_Object {

    /**
     * @param args
     */
    private static Hashtable db = new Hashtable();

    private static void dbOutput() {
	_dbPrint(db.keys());
    }

    private static void _dbPrint(Enumeration dbkeys) {
	if (dbkeys != null && db != null) {
	    while (dbkeys.hasMoreElements()) {
		Object key = dbkeys.nextElement();
		System.out.println(key + "=" + db.get(key));
	    }
	}
    }

    private static void _arrayPrint(Object[] o_array) {
	if (o_array != null) {
	    for (Object o : o_array) {
		System.out.println(o);
	    }
	}
    }

    private static void _fieldPrint(Field f) {
	StringBuffer sbuf = new StringBuffer();
	sbuf.append("*************************\n");

	sbuf.append("Field name: " + f.getName());
	sbuf.append("\n");
	sbuf.append("Field type: " + f.getType().getName());
	sbuf.append("\n");
	sbuf.append("Field value: " + f.getType());
	sbuf.append("\n");

	sbuf.append("*************************\n");

	System.out.println(sbuf.toString());
    }

    private static void _objectFieldsPrint(Object o) {
	Field[] fields = o.getClass().getDeclaredFields();
	//System.out.println("---------"+o.getClass().getCanonicalName()+"---------");
	for (Field field : fields) {
	    _fieldPrint(field);
	}
    }

    public static void main(String[] args) {
	Object o = new MyObject();
	db.put("key1", o);
	db.put("key2", new DYNC_Object());
	dbOutput();

	//_arrayPrint(o.getClass().getAnnotations());

	//Field [] fields = o.getClass().getDeclaredFields();
	//System.out.println(fields.length);
	//_arrayPrint(fields);
	//_objectFieldsPrint(o);
	
	/*
	 * 现在的任务是 动态取得 MyObject对象的属性 iname
	 * 获得 它的类型 , 为其设置一个值 , 再获得这个属性的值 并输出
	 */
	//printFieldValue(o, "iname");
	printFieldInfo(o,"iname");
	setField(o, "iname", "动态设置属性值成功! -- 1");
	printFieldValue(o, "iname");	
	printFieldInfo(o,"iname");
	
	setField(o, "iname", "动态设置属性值成功! -- 2");
	printObjectFieldsInfo(o);
    }
    
    public static Field getField(Object owner ,String fieldName){
	Field f = null ;
	try {
	    f = owner.getClass().getDeclaredField(fieldName);
	} catch (SecurityException e) {	    
	    e.printStackTrace();
	} catch (NoSuchFieldException e) {    
	    e.printStackTrace();
	}
	return f ;
    }
    public static void setField(Object owner ,Field tf,Object value){
	try {
	    tf.set(owner, value);
	} catch (IllegalArgumentException e) {
	    e.printStackTrace();
	} catch (IllegalAccessException e) {
	    e.printStackTrace();
	}
    }
    public static void setField(Object owner ,String fieldName,Object value){
	Field f = getField(owner, fieldName);
	setField(owner, f, value);//调用上边的那个此函数的另一种多态形式
    }
    public static Object getFieldValue(Object owner,Field tf){
	Object v = null ;
	try {	    
	    v = tf.get(owner) ;
	} catch (IllegalArgumentException e) {	    
	    e.printStackTrace();
	} catch (IllegalAccessException e) {	    
	    e.printStackTrace();
	}
	return v ;
    }
    public static Object getFieldValue(Object owner,String fieldName){
	Field f = getField(owner, fieldName);
	return getFieldValue(owner, f);//调用上边的那个此函数的另一种多态形式
    }
    public static void printFieldValue(Object owner,Field f){
	System.out.println(getFieldValue(owner, f));
    }
    public static void printFieldValue(Object owner,String fieldName){	
	System.out.println(getFieldValue(owner, fieldName));
    }
    public static void printFieldInfo(Object owner,Field f){	
	StringBuffer sbuf = new StringBuffer();	
	sbuf.append("**当前字段信息 [开始]**\n");
	sbuf.append("Field name: " + f.getName());
	sbuf.append("\n");
	sbuf.append("Field type: " + f.getType().getName());
	sbuf.append("\n");
	sbuf.append("Field value: " + getFieldValue(owner,f));
	sbuf.append("\n");
	sbuf.append("**当前字段信息 [结束]**\n");

	System.out.println(sbuf.toString());
    }
    public static void printFieldInfo(Object owner,String fieldName){	
	Field f = getField(owner, fieldName);
	printFieldInfo(owner,f);
    }
    public static void printObjectFieldsInfo(Object owner){
	System.out.println("+++++"+ owner.getClass().getName() +"++++开始\n");
	Field[] fields = owner.getClass().getDeclaredFields();
	for (Field field : fields) {
	    printFieldInfo(owner,field);
	}
	System.out.println("+++++"+ owner.getClass().getName() +"++++结束");
    }
    
    
    public String toString() {
	return "Dync_Object!";
    }

}
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Spring动态代理二.docx

    接着，Service 自动装配 Dao 对象，默认按照类型自动装配 productDao，不再需要 productService 的 bean 标签和 set/get。 底层实现是通过反射+无参构造实现的。反射机制可以动态地创建对象，而无参构造方法可以...

    Java仿Spring框架IOC控制反转利用反射简单实现(源码)

    这个简单的实现虽然不能与Spring的复杂功能相提并论，但它足够说明了IOC和反射在Java中实现解耦和依赖注入的基本原理。通过这种方式，我们可以更好地理解和模仿Spring框架的工作方式，为后续深入学习和使用Spring...

    Spring学习之Bean的装配多种方法

    在Spring框架中，Bean的装配是指将对象的创建交给第三方，并且由第三方进行注入的过程。Spring中的Ioc容器扮演着这样的一个角色，将对象的创建等交给Spring，而服务对象只管使用即可。配置Bean的过程其实也就是告诉...

    Java框架笔试题（含答案）.docx

    本文总结了 Java 框架笔试题中的重要知识点，涵盖了依赖注入、AOP、Bean 的注入、ApplicationContext 接口、事务管理、持久化支持、Spring 配置文件、自动装配等方面的知识。 一、依赖注入 依赖注入是一种设计模式...

    spring 个人笔记

    //* 以下for循环是实现模拟spring自动装配(注入)功能 //一开始列出此bean的所有property子元素 for (Element propertyElement : (List)element.getChildren("property")){ //获取property子元素中 属性为...

    基于Java反射的map自动装配JavaBean工具类设计示例代码

    基于Java反射的map自动装配JavaBean工具类设计...本文主要介绍了基于 Java 反射的 map 自动装配 JavaBean 工具类设计的相关知识点，可以帮助开发者更好地使用 Java 反射机制来自动装配 Map 对象到 JavaBean 对象中。

    Java 11道中级面试题.docx

    - `@Autowired`：自动装配Bean，Spring会尝试根据类型或名称自动匹配Bean。 - `@Resource`：也是用来注入Bean，如果没有指定名称，则按照类型匹配，是J2EE的注解。 2. **线程创建**： - 延伸Thread类：创建子类...

    Spring入门

    - **实现方式**：Spring通过容器管理对象的生命周期，并负责创建对象实例以及装配这些实例所需的依赖关系。 #### 依赖注入（DI） - **基本概念**：依赖注入（Dependency Injection, DI）是一种软件设计模式，用于...

    spring.zip

    Spring框架是Java开发中不可或缺的一部分，它以其强大的...通过Java反射，我们能够了解Spring如何在运行时动态创建和装配对象。这样的实践有助于提升对Spring框架的掌握，以及对面向对象设计原则和依赖注入模式的应用。

    springMVC详解以及注解说明

    - **`@Autowired`**：用于自动装配Bean，Spring会根据类型或名称自动匹配依赖项。 - **`@Qualifier`**：当存在多个相同类型的Bean时，可以用`@Qualifier`指定具体要注入哪一个Bean。 - **`@Component`**：标记类为...

    2020年Java各知识点综合面试题.zip

    Java是一种广泛使用的面向对象的编程语言，以其跨平台、高性能和丰富的类库而备受开发者喜爱。这份名为"2020年Java各知识点综合面试题.zip"的压缩包，包含了全面的Java面试题目，旨在帮助求职者在短期内提升对Java...

    springboot项目笔记（共48页）.docx

    - 集合类型的Java对象需要提供get和set方法。 - 集合名称需与配置文件中的属性名称保持一致。 - 可以通过`@ConfigurationProperties`注解指定前缀和配置文件路径。 ### 三、不同环境读取不同的配置文件 Spring ...

    JavaAnnotation实例.docx

    - **运行时行为改变**：例如，Spring框架中的`@Autowired`用于自动装配Bean。 3. **使用场景**： - 在本例中，我们将利用`Annotation`来实现权限控制逻辑的解耦。 #### 三、案例分析：权限控制系统 假设我们...

    类的反射机制

    3. 框架配置解析：如Spring框架，通过读取XML配置文件，动态创建和装配bean。 4. 测试工具：JUnit等测试框架，通过反射调用私有方法进行测试。 5. 配置文件加载：根据配置文件动态加载类并实例化对象。 四、反射的...

Magicbox
Global site tag (gtag.js) - Google Analytics