动态添加属性_es6 动态添加属性 - CSDN
精华内容
参与话题
  • 动态添加属性,方法

    2018-12-06 23:35:05
    一、动态语言相关概念 1.1 动态语言 在运行时代码可以根据某些条件改变自身结构 可以在运行时引进新的函数、对象、甚至代码,可以删除已有的函数等其他结构上的变化 常见的动态语言:Object-C、C#、JavaScript...

    一、动态语言相关概念

    1.1 动态语言

    • 在运行时代码可以根据某些条件改变自身结构
    • 可以在运行时引进新的函数、对象、甚至代码,可以删除已有的函数等其他结构上的变化
    • 常见的动态语言:Object-C、C#、JavaScript、PHP、Python、Erlang

    1.2 动态类型语言

    • 在运行期间检查数据类型的语言
    • 数据类型不是在编译阶段决定的,而是把类型绑定延后到了运行阶段
    • 常见的动态类型语言:Python、Ruby、Erlang、JavaScript、swift、PHP、Perl

    1.3 强类型语言

    • 一旦一个变量被指定了某个数据类型,如果不经过强制类型转换,那么它就永远是这个数据类型
    • 常见的强类型语言:Java、C#、Python、Object-C、Ruby

    Python是动态语言,动态类型语言,也是强类型语言。所以Python可以在运行时改变自身结构,动态添加/删除属性和方法。接下来将介绍Python如何动态添加属性和方法。

     

    二、动态添加属性

    2.1 添加对象属性

     

    class Person(object):
        def __init__(self, newName, newAge):
            self.name = newName
            self.age = newAge
    
    zhangsan = Person("张三", 18)
    zhangsan.addr = "北京"    # 类对象zhangsan动态添加对象属性addr
    print(zhangsan.name)    # 张三
    print(zhangsan.age)     # 18
    print(zhangsan.addr)    # 北京
    
    lisi = Person("李四", 28)
    print(lisi.name)        # 李四
    print(lisi.age)         # 28
    print(lisi.addr)        # 'Person' object has no attribute 'addr'

     

    由以上代码可知,Person类有两个属性:name和age。通过[对象名.属性名]给类对象zhangsan动态添加了对象属性addr,而Person的另一个类对象lisi却不能调用这个属性。

    注:通过对象名添加的对象属性,只有这个对象能使用

    2.2 添加类属性

     

    class Person(object):
        def __init__(self, newName, newAge):
            self.name = newName
            self.age = newAge
    
    Person.addr = "北京"  # 类Person动态添加类属性addr
    
    zhangsan = Person("张三", 18)
    print(zhangsan.name)    # 张三
    print(zhangsan.age)     # 18
    print(zhangsan.addr)    # 北京
    
    lisi = Person("李四", 28)
    print(lisi.name)    # 李四
    print(lisi.age)     # 28
    print(lisi.addr)    # 北京
    

     

    由以上代码可知,通过[类名.属性名]给类Person动态添加了类属性addr,Person的类对象zhangsan和lisi都能调用这个属性

    注:通过类名添加的类属性,这个类的所有对象都能使用

     

    三、动态添加方法

    类中有三种方法,实例方法,静态方法和类方法,三种方法的区别如下:

    • 实例方法:需要绑定要一个对象上,第一个参数默认使用self,会把对象作为第一个参数传递进来
    • 静态方法:使用装饰器@staticmethod进行定义,类和对象都可以调用,不需要默认参数
    • 类方法:使用装饰器@classmethod进行定义,类和对象都可以调用,第一个参数默认使用cls,会把类作为第一个参数传递进来

    3.1 添加实例方法

     

    import types
    
    class Person(object):
        def __init__(self, newName, newAge):
            self.name = newName
            self.age = newAge
    
        def eat(self):
            print("---正在吃---")
    
    def run(self):
        print("---正在跑---")
    
    zhangsan = Person("张三", 18)
    zhangsan.eat()  # ---正在吃---
    zhangsan.run = types.MethodType(run, zhangsan)  # 类对象zhangsan动态添加对象方法run()
    zhangsan.run()  # ---正在跑---
    
    lisi = Person("李四", 28)
    lisi.eat()  # ---正在吃---
    lisi.run()  # 'Person' object has no attribute 'run'

     

    由以上代码可知,Person类有一个方法:eat()方法。通过[types.MethodType(方法名, 对象名)]给类对象zhangsan动态添加了对象方法run(),同理,Person的另一个类对象lisi不能调用这个方法

    注:通过对象名添加的对象方法,只有这个对象能使用

    3.2 添加静态方法

    复制代码

    class Person(object):
        def __init__(self, newName, newAge):
            self.name = newName
            self.age = newAge
    
        def eat(self):
            print("---正在吃---")
    
    @staticmethod
    def staticRun():
        print("---正在跑---")
    
    Person.staticRun = staticRun    # 类Person动态添加静态方法staticRun()
    
    Person.staticRun()  # ---正在跑---
    
    zhangsan = Person("张三", 18)
    zhangsan.eat()        # ---正在吃---
    zhangsan.staticRun()  # ---正在跑---
    
    lisi = Person("李四", 28)
    lisi.eat()        # ---正在吃---
    lisi.staticRun()  # ---正在跑---

    复制代码

    由以上代码可知,通过[类名.静态方法名]给类Person动态添加了静态方法staticRun(),Person类的Person的类对象zhangsan和lisi都能调用这个方法

    注:通过类名添加的静态方法,这个类及这个类的所有对象都能使用

    3.3 添加类方法

    复制代码

    class Person(object):
        def __init__(self, newName, newAge):
            self.name = newName
            self.age = newAge
    
        def eat(self):
            print("---正在吃---")
    
    @classmethod
    def classRun(cls):
        print("---正在跑---")
    
    Person.classRun = classRun    # 类Person动态添加类方法classRun()
    
    Person.classRun()  # ---正在跑---
    
    zhangsan = Person("张三", 18)
    zhangsan.eat()        # ---正在吃---
    zhangsan.classRun()  # ---正在跑---
    
    lisi = Person("李四", 28)
    lisi.eat()        # ---正在吃---
    lisi.classRun()  # ---正在跑---

    复制代码

    由以上代码可知,通过[类名.类方法名]给类Person动态添加了类方法classRun(),Person类的Person的类对象zhangsan和lisi都能调用这个方法

    注:通过类名添加的类方法,这个类及这个类的所有对象都能使用

     

    四、__slots__的使用

    通过以上内容,我们知道了如何动态的添加属性和方法。但是,如果我们想要限制class的属性该怎么办?例如:只允许Person实例添加name和age属性。为了达到这个目的,Python允许在定义class的时候,定义一个特殊变量__slots__来限制该class能添加的属性。

    复制代码

    import types
    class Person(object):
        __slots__ = ("name", "age")  # 定义__slots__    
        def __init__(self, newName, newAge):
            self.name = newName
            self.age = newAge
    
        def eat(self):
            print("---正在吃---")
    
    def run(self):
        print("---正在跑---")
    
    Person.num = 100        # 类Person动态添加类属性num
    
    zhangsan = Person("张三", 18)
    print(zhangsan.name)    # 张三
    print(zhangsan.age)     # 18
    print(zhangsan.num)     # 100
    zhangsan.eat()          # ---正在吃---
    
    zhangsan.addr = "北京"   # 'Person' object has no attribute 'addr'
    zhangsan.run = types.MethodType(run, zhangsan)  # 'Person' object has no attribute 'run'

    复制代码

    通过以上代码可知,__slots__对Person类的动态添加没有限制,而Person类对象zhangsan不能再动态添加对象属性和方法。

    对于__slot__有以下几个需要注意的地方:

    • __slots__只对类对象进行限制,不对类进行限制
    • __slots__不仅限制类对象的属性,还限制类对象的方法
    • __slots__仅对当前类起作用,对继承的子类不起作用
    • 在子类中定义__slots__,子类允许定义的属性就是自身的__slots__加上父类的__slots__
    展开全文
  • JAVA“动态”为类添加属性

    万次阅读 2018-01-04 19:35:07
    来源 : https://www.cnblogs.com/frinder6/p/7204574.html部分参考:http://www.cnblogs.com/zy2009/p/6725843.htmlpom.xml中添加:1234567891011<dependency> <groupId>commons-...

    来源 : https://www.cnblogs.com/frinder6/p/7204574.html


    部分参考:http://www.cnblogs.com/zy2009/p/6725843.html

    pom.xml中添加:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    <dependency>
        <groupId>commons-beanutils</groupId>
        <artifactId>commons-beanutils</artifactId>
        <version>1.9.3</version>
    </dependency>
     
    <dependency>
        <groupId>cglib</groupId>
        <artifactId>cglib-nodep</artifactId>
        <version>3.2.4</version>
    </dependency>

      

    使用cglib动态生成类与使用 commons-beanutils获取源对象属性-类型集合,封装成新对象并设置值代码:

    package com.frinder.util;
     
    import com.google.common.collect.Maps;
    import com.kiktech.entity.LoggerEntity;
    import net.sf.cglib.beans.BeanGenerator;
    import net.sf.cglib.beans.BeanMap;
    import org.apache.commons.beanutils.PropertyUtilsBean;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
     
    import java.beans.PropertyDescriptor;
    import java.util.HashMap;
    import java.util.Map;
     
    /**
     * Created by frinder on 2017/7/18.
     */
    public class ReflectUtil {
     
        staticLogger logger = LoggerFactory.getLogger(ReflectUtil.class);
     
        publicstatic Object getTarget(Object dest, Map<String, Object> addProperties) {
            // get property map
            PropertyUtilsBean propertyUtilsBean =new PropertyUtilsBean();
            PropertyDescriptor[] descriptors = propertyUtilsBean.getPropertyDescriptors(dest);
            Map<String, Class> propertyMap = Maps.newHashMap();
            for(PropertyDescriptor d : descriptors) {
                if(!"class".equalsIgnoreCase(d.getName())) {
                    propertyMap.put(d.getName(), d.getPropertyType());
                }
            }
            // add extra properties
            addProperties.forEach((k, v) -> propertyMap.put(k, v.getClass()));
            // new dynamic bean
            DynamicBean dynamicBean =new DynamicBean(dest.getClass(), propertyMap);
            // add old value
            propertyMap.forEach((k, v) -> {
                try{
                    // filter extra properties
                    if(!addProperties.containsKey(k)) {
                        dynamicBean.setValue(k, propertyUtilsBean.getNestedProperty(dest, k));
                    }
                }catch (Exception e) {
                    logger.error(e.getMessage(), e);
                }
            });
            // add extra value
            addProperties.forEach((k, v) -> {
                try{
                    dynamicBean.setValue(k, v);
                }catch (Exception e) {
                    logger.error(e.getMessage(), e);
                }
            });
            Object target = dynamicBean.getTarget();
            returntarget;
        }
     
     
        publicstatic void main(String[] args) {
            LoggerEntity entity =new LoggerEntity();
            entity.setAppName("appname");
            entity.setOperator("add");
            entity.setResult("result");
            entity.setUri("uri");
            entity.setMethod("method");
            Map<String, Object> addProperties =new HashMap() {{
                put("hello","world");
                put("abc","123");
            }};
            System.out.println(getTarget(entity, addProperties));
        }
     
     
        publicstatic class DynamicBean {
            /**
             * 目标对象
             */
            privateObject target;
     
            /**
             * 属性集合
             */
            privateBeanMap beanMap;
     
            publicDynamicBean(Class superclass, Map<String, Class> propertyMap) {
                this.target = generateBean(superclass, propertyMap);
                this.beanMap = BeanMap.create(this.target);
            }
     
     
            /**
             * bean 添加属性和值
             *
             * @param property
             * @param value
             */
            publicvoid setValue(String property, Object value) {
                beanMap.put(property, value);
            }
     
            /**
             * 获取属性值
             *
             * @param property
             * @return
             */
            publicObject getValue(String property) {
                returnbeanMap.get(property);
            }
     
            /**
             * 获取对象
             *
             * @return
             */
            publicObject getTarget() {
                returnthis.target;
            }
     
     
            /**
             * 根据属性生成对象
             *
             * @param superclass
             * @param propertyMap
             * @return
             */
            privateObject generateBean(Class superclass, Map<String, Class> propertyMap) {
                BeanGenerator generator =new BeanGenerator();
                if(null != superclass) {
                    generator.setSuperclass(superclass);
                }
                BeanGenerator.addProperties(generator, propertyMap);
                returngenerator.create();
            }
        }
     
    }

      

     LoggerEntity代码:

    package com.frinder.entity;
     
    import net.logstash.logback.encoder.org.apache.commons.lang.builder.ReflectionToStringBuilder;
     
    /**
     * Created by frinder on 2017/5/24.
     */
    public class LoggerEntity {
     
        privateString method;
        privateString uri;
        privateObject[] args;
        privateObject result;
        privateString operator;
        privateString appName;
     
        /**
         * 获取当前对象
         *
         * @param method
         * @param uri
         * @param args
         * @param result
         * @return
         */
        publicLoggerEntity get(String method, String uri, Object[] args, Object result, String operator, String appName) {
            setMethod(method);
            setUri(uri);
            setArgs(args);
            setResult(result);
            setOperator(operator);
            setAppName(appName);
            returnthis;
        }
     
        publicString getMethod() {
            returnmethod;
        }
     
        publicvoid setMethod(String method) {
            this.method = method;
        }
     
        publicString getUri() {
            returnuri;
        }
     
        publicvoid setUri(String uri) {
            this.uri = uri;
        }
     
        publicObject[] getArgs() {
            returnargs;
        }
     
        publicvoid setArgs(Object[] args) {
            this.args = args;
        }
     
        publicObject getResult() {
            returnresult;
        }
     
        publicvoid setResult(Object result) {
            this.result = result;
        }
     
        publicString getOperator() {
            returnoperator;
        }
     
        publicvoid setOperator(String operator) {
            this.operator = operator;
        }
     
        publicString getAppName() {
            returnappName;
        }
     
        publicvoid setAppName(String appName) {
            this.appName = appName;
        }
     
        @Override
        publicString toString() {
            returnReflectionToStringBuilder.toString(this);
        }
    }

    测试结果,需要在调试模式下才能看到:

    展开全文
  • from types import MethodType #创建一个空类 class Person(object): __slots__ = ("name","age",...#动态添加属性,这体现了动态语言的特点(灵活) per.name = "tom" print(per.name) ''' #动态添加方法 d...
    from types import  MethodType
    
    
    #创建一个空类
    class Person(object):
        __slots__ = ("name","age","speak","height")
    
    
    
    per = Person()
    #动态添加属性,这体现了动态语言的特点(灵活)
    
    per.name = "tom"
    print(per.name)
    '''
    #动态添加方法
    def say(self):
        print("my name is "+self.name)
    per.speak = say
    per.speak()
    '''
    
    def say(self):
        print("my name is "+self.name)
    per.speak = MethodType(say,per)
    per.speak()
    
    
    #思考:如果我们想要限制实力的属性怎么办
    #比如:只允许给对象添加 name,age,height,weight属性
    
    #解决:定义类的时候,定义一个特殊的属性(__slots__)
    #可以限制动态添加的属性
    per.height = 100
    print(per.height)

     

    展开全文
  • 给java对象动态添加属性

    万次阅读 2018-09-03 16:53:28
    、不知道大家有没有遇到过这样的需求 ,就java运行的时候 动态给你java对象添加属性,最近在项目终于到了,想到了反射去实现,但是最终也没有搞出来。。。哎。。 有的时候 比如你用的是hibernate或者Spring jdb.....

    抓狂、不知道大家有没有遇到过这样的需求 ,就java运行的时候 动态给你java对象添加属性,最近在项目终于到了,想到了反射去实现,但是最终也没有搞出来。。。哎。。


    有的时候 比如你用的是hibernate或者Spring jdbc 来做dao层进行数据库相关的操作的时候,若果是单表的操作的时候 还比较简单 hibernate可直接返回(get,load)你的需要的po,spring3可以用rowmapper的实现类来处理这个操作,这些操作对于大家来说都是熟悉的不能在熟悉了。

    疑问、问题:当进行多个表进行连接的操作时候,如:

    select p.id,p.name,ad.address,ad.post_code from person  p join person_address ad on p.id = ad.person_id


    现在有两张表进行查询 ,查询出来是两个表的字段,hibernate中也许你会想创建一个含有这些字段的vo就可以了解决了 (或者基于这个查询建立以个视图 ,然后基于这个视图在用hibernate进行orm映射,),在spring3里会用到org.springframework.jdbc.core.BeanPropertyRowMapper如:

    this.jdbcTemplate.queryForObject(sql,BeanPropertyRowMapper.newInstance(PersonAdressVo.class));//返回PersonAdressVo对象

    是的这样的确可以解决,想想如果你的好的查询,而且结果都不一样,连接的表也是很多,那么你创建的vo或者是视图肯定是泛滥的,整个项目就会臃肿起来,这是我们不想看到的。

    大笑、现在说说解决方法:

    你可以在进行查询结果的时候,为你联合查询出来的Object 动态添加你查出来的属性;

    下面来说一下具体的代码:

    此时需要你需要cglib-nodep-2.2.jar,自己google下载

    DynamicBean.java

    1. package com.ajun.spring.orm;
    2. import java.util.Iterator;
    3. import java.util.Map;
    4. import java.util.Set;
    5. import net.sf.cglib.beans.BeanGenerator;
    6. import net.sf.cglib.beans.BeanMap;
    7. /**
    8. *
    9. * @author ajun
    10. *
    11. */
    12. public class DynamicBean {
    13. /**
    14. * 实体Object
    15. */
    16. private Object object = null;
    17. /**
    18. * 属性map
    19. */
    20. private BeanMap beanMap = null;
    21. public DynamicBean() {
    22. super();
    23. }
    24. @SuppressWarnings("unchecked")
    25. public DynamicBean(Map propertyMap) {
    26. this.object = generateBean(propertyMap);
    27. this.beanMap = BeanMap.create(this.object);
    28. }
    29. /**
    30. * 给bean属性赋值
    31. * @param property 属性名
    32. * @param value 值
    33. */
    34. public void setValue(String property, Object value) {
    35. beanMap.put(property, value);
    36. }
    37. /**
    38. * 通过属性名得到属性值
    39. * @param property 属性名
    40. * @return
    41. */
    42. public Object getValue(String property) {
    43. return beanMap.get(property);
    44. }
    45. /**
    46. * 得到该实体bean对象
    47. * @return
    48. */
    49. public Object getObject() {
    50. return this.object;
    51. }
    52. /**
    53. * @param propertyMap
    54. * @return
    55. */
    56. @SuppressWarnings("unchecked")
    57. private Object generateBean(Map propertyMap) {
    58. BeanGenerator generator = new BeanGenerator();
    59. Set keySet = propertyMap.keySet();
    60. for (Iterator i = keySet.iterator(); i.hasNext();) {
    61. String key = (String) i.next();
    62. generator.addProperty(key, (Class) propertyMap.get(key));
    63. }
    64. return generator.create();
    65. }
    66. }

    测试类:

    1. public static void main(String[] args) throws ClassNotFoundException {
    2. // 设置类成员属性
    3. HashMap propertyMap = new HashMap();
    4. propertyMap.put("id", Class.forName("java.lang.Integer"));
    5. propertyMap.put("name", Class.forName("java.lang.String"));
    6. propertyMap.put("address", Class.forName("java.lang.String"));
    7. // 生成动态 Bean
    8. DynamicBean bean = new DynamicBean(propertyMap);
    9. // 给 Bean 设置值
    10. bean.setValue("id", new Integer(123));
    11. bean.setValue("name", "454");
    12. bean.setValue("address", "789");
    13. // 从 Bean 中获取值,当然了获得值的类型是 Object
    14. System.out.println(" >> id = " + bean.getValue("id"));
    15. System.out.println(" >> name = " + bean.getValue("name"));
    16. System.out.println(" >> address = " + bean.getValue("address"));
    17. // 获得bean的实体
    18. Object object = bean.getObject();
    19. // 通过反射查看所有方法名
    20. Class clazz = object.getClass();
    21. Method[] methods = clazz.getDeclaredMethods();
    22. for (int i = 0; i < methods.length; i++) {
    23. System.out.println(methods[i].getName());
    24. }
    25. }

    在这里在举一个spring jdbc中查询多个表 ,返回一个动态bean的例子:
    首先是你在用spring3 jdbc进行查询的时候 这时候你想返回一个对象 此时你一般的做法是:

    1. String sql="select p.id,p.name,ad.address,ad.post_code from person p join person_address ad on p.id = ad.person_id";//此时你返回是多个表的结果
    2. this.jdbcTemplate.queryForObject(sql,BeanPropertyRowMapper.newInstance(PersonAddressVO.class), id);//返回一个含有多个表的属性的vo:PersonAddressVO
    随着你的业务的复杂也许你vo会很多 ,为了减少你vo的数量 ,应该动态返回一个bean 此时bean含有你想要的的属性。

    我们在用spring jdbc 进行查询 就行orm映射的时候 都要是首先实现org.springframework.jdbc.core.RowMapper,因为spring jdbc查询的时候你要进行orm要求一个参数必须为org.springframework.jdbc.core.RowMapper,所以此时我要实现org.springframework.jdbc.core.RowMapper里的public Object mapRow(ResultSet rs, int rowNum) f。

    里面我们会用前面的DynamicBean.java

    1. <code class="language-java">package com.ajun.spring.orm;  
    2.   
    3. import java.sql.ResultSet;  
    4. import java.sql.ResultSetMetaData;  
    5. import java.sql.SQLException;  
    6. import java.util.HashMap;  
    7.   
    8. import org.springframework.jdbc.core.RowMapper;  
    9. import org.springframework.jdbc.support.JdbcUtils;  
    10.   
    11.   
    12.   
    13. /** 
    14.  ********************************************************************************* 
    15.  * 例子:数据库:person_id <----->po:personId 请写好驼峰表示风格 
    16.  ********************************************************************************* 
    17.  * @author ajun 
    18.  */  
    19. @SuppressWarnings("unchecked")  
    20. public class CustomRowMapper implements RowMapper {  
    21.   
    22.       
    23.     @Override  
    24.     public Object mapRow(ResultSet rs, int rowNum) throws SQLException {  
    25.             return this.toDynamicObject(rs, rowNum);  
    26.     }  
    27.       
    28.     private  Object toDynamicObject(ResultSet rs, int rowNum) throws SQLException{  
    29.         DynamicBean dyBean  =null;  
    30.         ResultSetMetaData rsmd = rs.getMetaData();  
    31.         if(rsmd!=null){  
    32.             int columnCount = rsmd.getColumnCount();  
    33.             HashMap propertyMap = new HashMap();  
    34.             for (int index = 1; index <= columnCount; index++){//JdbcUtils自己查spring API  
    35.                 String column = JdbcUtils.lookupColumnName(rsmd, index);  
    36.                 String propertyName = JdbcUtils.convertUnderscoreNameToPropertyName(column);  
    37.                 propertyMap.put(propertyName, Object.class);//添加动态属性 此时person_address ==>personAddress  
    38.             }  
    39.             dyBean = new DynamicBean(propertyMap);  
    40.             for (int index = 1; index <= columnCount; index++){  
    41.                 String column = JdbcUtils.lookupColumnName(rsmd, index);  
    42.                 String propertyName = JdbcUtils.convertUnderscoreNameToPropertyName(column);  
    43.                 Object value = JdbcUtils.getResultSetValue(rs, index);  
    44.                 dyBean.setValue(propertyName, value);//设置值  
    45.             }  
    46.         }  
    47.         return dyBean.getObject();  
    48.     }  
    49.       
    50.       
    51.     public static  CopyOfCustomRowMapper newInstance() {  
    52.         CopyOfCustomRowMapper newInstance = new CopyOfCustomRowMapper();  
    53.         return newInstance;  
    54.     }  
    55.   
    56. }  
    57. </code>  
    1. package com.ajun.spring.orm;
    2. import java.sql.ResultSet;
    3. import java.sql.ResultSetMetaData;
    4. import java.sql.SQLException;
    5. import java.util.HashMap;
    6. import org.springframework.jdbc.core.RowMapper;
    7. import org.springframework.jdbc.support.JdbcUtils;
    8. /**
    9. *********************************************************************************
    10. * 例子:数据库:person_id <----->po:personId 请写好驼峰表示风格
    11. *********************************************************************************
    12. * @author ajun
    13. */
    14. @SuppressWarnings("unchecked")
    15. public class CustomRowMapper implements RowMapper {
    16. @Override
    17. public Object mapRow(ResultSet rs, int rowNum) throws SQLException {
    18. return this.toDynamicObject(rs, rowNum);
    19. }
    20. private Object toDynamicObject(ResultSet rs, int rowNum) throws SQLException{
    21. DynamicBean dyBean =null;
    22. ResultSetMetaData rsmd = rs.getMetaData();
    23. if(rsmd!=null){
    24. int columnCount = rsmd.getColumnCount();
    25. HashMap propertyMap = new HashMap();
    26. for (int index = 1; index <= columnCount; index++){//JdbcUtils自己查spring API
    27. String column = JdbcUtils.lookupColumnName(rsmd, index);
    28. String propertyName = JdbcUtils.convertUnderscoreNameToPropertyName(column);
    29. propertyMap.put(propertyName, Object.class);//添加动态属性 此时person_address ==>personAddress
    30. }
    31. dyBean = new DynamicBean(propertyMap);
    32. for (int index = 1; index <= columnCount; index++){
    33. String column = JdbcUtils.lookupColumnName(rsmd, index);
    34. String propertyName = JdbcUtils.convertUnderscoreNameToPropertyName(column);
    35. Object value = JdbcUtils.getResultSetValue(rs, index);
    36. dyBean.setValue(propertyName, value);//设置值
    37. }
    38. }
    39. return dyBean.getObject();
    40. }
    41. public static CopyOfCustomRowMapper newInstance() {
    42. CopyOfCustomRowMapper newInstance = new CopyOfCustomRowMapper();
    43. return newInstance;
    44. }
    45. }
    调用的时候:

    1. String sql="select p.id,p.name,ad.address,ad.post_code from person p join person_address ad on p.id = ad.person_id";//此时你返回是多个表的结果
    2. List<Object> list = this.jdbcTemplate.query(sql, BeanPropertyRowMapper.newInstance());//返回一个含有多个表的属性的动态bean

    在页面上你就可以用el表达式这样去出来:

    1. <c:forEach items="${list}" var="p">
    2. <tr>
    3. <td>${p.id}</td>
    4. <td>${p.name}</td>
    5. <td>${p.address}</td>
                            <td>${p.postCode}</td>
    </tr> </c:forEach>
    
    

    
    
    这样是不是很方便呢 ,呵呵偷笑


    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
                
                    
    				
    阅读更多 登录后自动展开
    展开全文
  • 动态添加属性

    2018-11-07 21:44:03
    &lt;!DOCTYPE html&gt;   &lt;HTML&gt;   &lt;HEAD&gt;   &lt;TITLE&gt;选项卡&lt;/ TITLE&gt;   &lt;... #header {w
  • js给动态添加的元素添加属性

    千次阅读 2019-02-18 09:57:56
    将一段标签动态添加到div中,给这段标签的img标签设置width:100% 一开始设置了添加类名 // 内容 const content = res.data.data.info.content; document.getElementById('content').innerHTML = content; var a ...
  • 动态添加标签属性

    2017-12-18 09:59:00
    2019独角兽企业重金招聘Python工程师标准>>> ...
  • c#动态添加属性

    千次阅读 2019-09-11 10:48:34
    代码 using System; using System.Collections.Generic; using System.Dynamic; namespace ConsoleDynamicModel { public class DynamicModel : DynamicObject ... private string propertyName;...
  • ios动态添加属性的几种方法

    千次阅读 2015-04-07 14:12:48
    在ios运行过程中,有几种方式能够动态添加属性。 1-通过runtime动态关联对象 主要用到了objc_setAssociatedObject,objc_getAssociatedObject以及objc_removeAssociatedObjects //在目标target上添加...
  • 一些概念 ... 属性 方法 类 实例   类(1) - 《零基础学python》(第二版):https://docs.pythontab.com/learnpython/206/   对象(object):在面向对象编程中(OOP),万物都是对...
  • JS动态添加属性

    千次阅读 2019-05-14 09:40:15
    // 编辑表格内容 addItem() { const item = { editing: true, uid: uid++ } // 动态设置对象 for (let index = 0; index < this.columns.length; index++) { var ke...
  • js为Object对象动态添加属性和值

    万次阅读 2017-03-01 17:12:12
    为Object对象动态添加属性和值 方式1: var obj = {}; //或者 var obj=new Object(); var key = "name"; var value = "张三丰" obj[key] = value; console.info(obj); 方式2,使用eval() 动态解析字符串表达式 ...
  • iOS runtime ~ 动态添加属性

    千次阅读 2017-12-30 09:28:54
    联系人:石虎 QQ:1224614774 昵称: 嗡嘛呢叭咪... 1.runtime:动态添加属性:什么时候需要动态添加属性;  2.开发场景:给系统的类添加属性的时候,可以使用runtime动态添加属性方法;  3.本质:动态添加属性,就是...
  • C#类动态添加属性

    万次阅读 2015-09-16 14:59:45
    动态类实现 using System; using System.Collections.Generic; using System.Reflection.Emit; using System.Reflection; using System.Threading; namespace CopyMapFile { /**//// /// 类帮助器,可以...
  • Python 动态添加属性及方法

    千次阅读 2018-03-20 15:12:13
    Python是一门动态语言,动态语言的一个主要的特性就是你那个在运行时,添加属性以及方法。不同于静态语言(例如c,c++,java......)他们都是通过编译后在运行指定的编译后的文件。Python与他们最大的不同就是Python...
  • vue 动态添加属性

    千次阅读 2018-09-11 16:54:02
    Vue.set 方法用于设置对象的属性,它可以解决 Vue 无法检测添加属性的限制,语法格式如下: Vue.set( target, key, value ) 参数说明: target: 可以是对象或数组 key : 可以是字符串或数字 value: 可以是任何...
  • objective-c 动态添加属性

    千次阅读 2019-03-21 18:30:53
    项目开发中经常会申明变量保存相关相关值,但是对于功能太多的类中申明过多的变量看着就非常的繁琐,尤其是使用动态语言如javaScript 写过功能的都知道,动态语言可以动态的在一个对象上添加新的属性和值,这将是...
  • dynamic动态添加属性

    千次阅读 2019-01-25 15:31:16
    List&lt;dynamic&gt; list = conn.Query(srhsql, p).ToList(); //查出数据 List&lt;dynamic&gt; tmp = new List&lt;dynamic&gt;(); foreach (var row in ... dynamic info = new System....
  • 1,python动态添加属性(对象属性,类属性) ** 1,python是动态类型语言:可以在运行中改变自身结构,动态添加/删除属性和方法,删除函数 2,也是强类型语言:变量的类型可以在运行之后,任意变量,不需要强制转换...
  • C# 类动态添加属性、方法

    千次阅读 2015-03-16 23:00:38
     需要动态为WPF中的DataGrid添加列,并动态绑定相应数据.(此处仅实现动态属性添加和使用,关于动态方法的添加和使用详见推荐阅读) 实现关键点:  目标类继承DynamicObject,添加动态属性集合,并重写方法...
1 2 3 4 5 ... 20
收藏数 542,645
精华内容 217,058
关键字:

动态添加属性