本文目录
- 请教Java高手， 表单刷新提交时发生异常
- commons-beanutils-1.8.3是什么jar包
- java内省和反射的区别
- 如何获取javabean的属性和值
- error 500:beanutils.populate怎么解决
- 如何实现javabean的属性拷贝
- net.sf.json.JSONException: java.lang.reflect.InvocationTargetException
- java解析json字符串数据
请教Java高手， 表单刷新提交时发生异常
数组下标越界，数组的index是从0开始的，那么第一个元素就是array。你的数组长度只有2，所以下标只有0和1，用2的下标去取元素是拿不到任何东西的，而且会报IndexOutOfBoundsException。
commons-beanutils-1.8.3是什么jar包
1.什么是 commons-beanutils ：
BeanUtils主要提供了对于JavaBean进行各种操作。
2.commons-beanutils 的作用：
在一般的写bean组件的时候，都必须要写setter和getter方法，当然假如我们事先已经知道bean的相关属性和方法，写bean是比较简单的，
但是组件太多的时候，重复编写经常是枯燥乏味令人厌烦的。
但当有些时候我么需要调用动态对象的属性的时候，我们应该怎么来设定和获取对象的属性呢？BeanUtils就可以帮助我们来解决这个问题。
3. org.apache.commons.beanutils：
这个包主要提供用于操作JavaBean的工具类，Jakarta-Common-BeanUtils的主要功能都在这个包里实现。
BeanUtils可以直接get和set一个属性的值。它将property分成3种类型：
1Simple——简单类型，如Stirng、Int……
（对于Simple类型，第二个参数直接是属性名即可，详见代码）
2Indexed——索引类型，如 数组、arrayList……
（对于Indexed，则为“属性名[索引值]”，注意这里对于ArrayList和数组都可以用一样的方式进行操作，详见代码）
3Maped——这个不用说也该知道，就是指Map，比如HashMap……
（对于Map类型，则需要以“属性名（key值）”的形式，详见代码）
访问不同类型的数据可以直接调用函数getProperty和setProperty。它们都只有2个参数，第一个是JavaBean对象，第二个是要操作的属性名。
4.Converter 把Request或ResultSet中的字符串绑定到对象的属性 经常要从request,resultSet等对象取出值来赋入bean中，如果不用MVC框架的绑定功能的话，下面的代码谁都写腻了。
String a = request.getParameter(“a“); bean.setA(a); String b = request.getParameter(“b“); bean.setB(b);…
不妨写一个Binder自动绑定所有属性：
MyBean bean = ; HashMap map = new HashMap(); Enumeration names = request.getParameterNames(); while (names.hasMoreElements()) { String name = (String) names.nextElement(); map.put(name, request.getParameterValues(name)); } BeanUtils.populate(bean, map);
其中BeanUtils的populate方法（Struts用于将一个map的值填充到一个bean中）或者getProperty,setProperty方法其实都会调用convert进行转换。
但Converter只支持一些基本的类型，甚至连java.util.Date类型也不支持。而且它比较笨的一个地方是当遇到不认识的类型时，居然会抛出异常来。 对于Date类型，我参考它的sqldate类型实现了一个Converter，而且添加了一个设置日期格式的函数。
要把这个Converter注册，需要如下语句：
例：
BeanUtilsBean beanUtils =new BeanUtilsBean( convertUtils, new PropertyUtilsBean() ) ;beanUtils.setProperty( bean, name, value ) ;
java内省和反射的区别
经过多方面的资料搜集整理，写下了这篇文章，本文主要讲解java的反射和内省机制，希望对大家有点帮助,也希望大家提出不同的看法！1).内省(Introspector)是 Java 语言对 Bean 类属性、事件的一种缺省处理方法。例如类 A 中有属性 name, 那我们可以通过 getName,setName 来得到其值或者设置新的值。通过 getName/setName 来访问 name 属性，这就是默认的规则。 Java 中提供了一套 API 用来访问某个属性的 getter/setter 方法，通过这些 API 可以使你不需要了解这个规则（但你最好还是要搞清楚），这些 API 存放于包 java.beans 中。2).直接通过属性的描述器java.beans.PropertyDescriptor类，来访问属性的getter/setter 方法;相关代码：public class Point {private Integer x;private Integer y;public Point(Integer x, Integer y) {super();this.x = x;this.y = y;}public Integer getX() {return x;}public void setX(Integer x) {this.x = x;}public Integer getY() {return y;}public void setY(Integer y) {this.y = y;}}import java.beans.PropertyDescriptor;import java.lang.reflect.Method;public class Reflect {public static void main(String args) throws Exception {Point point = new Point(2, 5);String proName = “x“;getProperty(point, proName);setProperty(point, proName);}private static void setProperty(Point point, String proName) throws Exception {PropertyDescriptor proDescriptor = new PropertyDescriptor(proName, Point.class);Method methodSetX = proDescriptor.getWriteMethod();methodSetX.invoke(point, 8);System.out.println(point.getX());// 8}private static void getProperty(Point point, String proName) throws Exception {PropertyDescriptor proDescriptor = new PropertyDescriptor(proName, Point.class);Method methodGetX = proDescriptor.getReadMethod();Object objx = methodGetX.invoke(point);System.out.println(objx);// 2}}3).通过类 Introspector 来获取某个对象的 BeanInfo 信息，然后通过 BeanInfo 来获取属性的描述器（ PropertyDescriptor ），通过这个属性描述器就可以获取某个属性对应的 getter/setter 方法，然后我们就可以通过反射机制来调用这些方法。相关代码：把2中的getProperty()修改成如下形式：private static void getProperty(Point point, String proName) throws Exception {BeanInfo beanInfo = Introspector.getBeanInfo(point.getClass());PropertyDescriptor proDescriptors = beanInfo.getPropertyDescriptors();for(PropertyDescriptor prop: proDescriptors){if(prop.getName().equals(proName)){Method methodGetx = prop.getReadMethod();System.out.println(methodGetx.invoke(point));//8break;}}}4).我们又通常把javabean的实例对象称之为值对象（Value Object）,因为这些bean中通常只有一些信息字段和存储方法，没有功能性方法。一个JavaBean类可以不当JavaBean用，而当成普通类用。JavaBean实际就是一种规范，当一个类满足这个规范，这个类就能被其它特定的类调用。一个类被当作javaBean使用时，JavaBean的属性是根据方法名推断出来的，它根本看不到java类内部的成员变量(javabean的成员变量通常都是私有private的)。5).除了反射用到的类需要引入外，内省需要引入的类如下所示，它们都属于java.beans包中的类，自己写程序的时候也不能忘了引入相应的包或者类。import java.beans.BeanInfo;import java.beans.IntrospectionException;import java.beans.Introspector;import java.beans.PropertyDescriptor;6).下面讲解一些开源的工具类Beanutils,需要额外下载的，commons-beanutils.jar，要使用它还必须导入commons-logging.jar包，不然会出异常；相关代码一：public static void main(String args) throws Exception {Point point = new Point(2, 5);String proName = “x“;BeanUtils.setProperty(point, proName, “8“);System.out.println(point.getX());// 8System.out.println(BeanUtils.getProperty(point, proName));// 8System.out.println(BeanUtils.getProperty(point, proName).getClass().getName());// java.lang.StringBeanUtils.setProperty(point, proName, 8);System.out.println(BeanUtils.getProperty(point, proName).getClass().getName());// java.lang.String}//我们看到虽然属性x的类型是Integer，但是我们设置的时候无论是Integer还是String，BeanUtils的内部都是当成String来处理的。相关代码二：BeanUtils支持javabean属性的级联操作；public static void main(String args) throws Exception {Point point = new Point(2, 5);//在point中加一个属性 private Date birth = new Date();并产生setter/getter方法String proName = “birth“;Date date= new Date();date.setTime(10000);BeanUtils.setProperty(point, proName, date);System.out.println(BeanUtils.getProperty(point, proName));BeanUtils.setProperty(point, “birth.time“, 10000);System.out.println(BeanUtils.getProperty(point, “birth.time“));//10000}//之所以可以 BeanUtils.setProperty(point, “birth.time“, 10000);这样写，那是因为Date类中有getTime()和setTime()方法，即Date类中相当于有time这个属性。相关代码三：BeanUtils和PropertyUtils对比：public static void main(String args) throws Exception {Point point = new Point(2, 5);String proName = “x“;BeanUtils.setProperty(point, proName, “8“);System.out.println(BeanUtils.getProperty(point, proName));//8System.out.println(BeanUtils.getProperty(point, proName).getClass().getName());//java.lang.String// PropertyUtils.setProperty(point, proName, “8“);//exception:argument type mismatchPropertyUtils.setProperty(point, proName, 8);System.out.println(PropertyUtils.getProperty(point, proName));//8System.out.println(PropertyUtils.getProperty(point, proName).getClass().getName());//java.lang.Integer}//BeanUtils它以字符串的形式对javabean进行转换，而PropertyUtils是以原本的类型对javabean进行操作。如果类型不对，就会有argument type mismatch异常。6).理解了相应的原理，那些现成的工具用起来就会更舒服，如Beanutils与PropertyUtils工具。这两个工具设置属性的时候一个主要区别是PropertyUtils.getPropety方法获得的属性值的类型为该属性本来的类型，而BeanUtils.getProperty则是将该属性的值转换成字符串后才返回。总结Web 开发框架 Struts 中的 FormBean 就是通过内省机制来将表单中的数据映射到类的属性上，因此要求 FormBean 的每个属性要有 getter/setter 方法。但也并不总是这样，什么意思呢？就是说对一个 Bean 类来讲，我可以没有属性，但是只要有 getter/setter 方法中的其中一个，那么 Java 的内省机制就会认为存在一个属性，比如类中有方法 setMobile ，那么就认为存在一个 mobile 的属性。将 Java 的反射以及内省应用到程序设计中去可以大大的提供程序的智能化和可扩展性。有很多项目都是采取这两种技术来实现其核心功能，例如我们前面提到的 Struts ，还有用于处理 XML 文件的 Digester 项目，其实应该说几乎所有的项目都或多或少的采用这两种技术。在实际应用过程中二者要相互结合方能发挥真正的智能化以及高度可扩展性。
如何获取javabean的属性和值
先实例化这个Bean使用这个Bean的set方法可以设置属性值使用这个Bean的get方法可以获取属性值例如有一个Bean名位PersonBean:public class PersonBean{private String name;private int age;public void setName(String name){ this.name = name;}public void setAge(String age){ this.age= age;}public String getName(){ return name;}public int getAge(){ return age;}}我们可以实例化这个Bean并设置属性PersonBean per = new PersonBean();per.setName(“yang“);per.setAge(18);然后将这个bean放到session中session.setAttribut(“Person“,per);当我们想要在另一个类中取得该bean中的值时先从session中获取这个bean的对象PersonBean per = (PersonBean )session.getAttribut(“Person“);然后用get方法取得值String name = per.getName();int age = per.gerAge();
error 500:beanutils.populate怎么解决
1.属性的动态getter,setter在这框架满天飞的年代，不能事事都保证执行getter,setter函数了，有时候属性是要需要根据名字动态取得的，就像这样： BeanUtils.getProperty(myBean,“code“);而BeanUtils更强的功能是直接访问内嵌对象的属性，只要使用点号分隔。BeanUtils.getProperty(orderBean, “address.city“);相比之下其他类库的BeanUtils通常都很简单，不能访问内嵌的对象，所以经常要用Commons BeanUtils替换它们。BeanUtils还支持List和Map类型的属性。如下面的语法即可取得顾客列表中第一个顾客的名字BeanUtils.getProperty(orderBean, “customers.name“);其中BeanUtils会使用ConvertUtils类把字符串转为Bean属性的真正类型，方便从HttpServletRequest等对象中提取bean，或者把bean输出到页面。而PropertyUtils就会原色的保留Bean原来的类型。2.beanCompartor 动态排序还是通过反射，动态设定Bean按照哪个属性来排序，而不再需要在bean的Compare接口进行复杂的条件判断。List peoples = ...; // Person对象的列表 Collections.sort(peoples, new BeanComparator(“age“));如果要支持多个属性的复合排序，如“Order By lastName,firstName“ArrayList sortFields = new ArrayList(); sortFields.add(new BeanComparator(“lastName“)); sortFields.add(new BeanComparator(“firstName“)); ComparatorChain multiSort = new ComparatorChain(sortFields); Collections.sort(rows,multiSort);其中ComparatorChain属于jakata commons-collections包。如果age属性不是普通类型，构造函数需要再传入一个comparator对象为age变量排序。另外, BeanCompartor本身的ComparebleComparator, 遇到属性为null就会抛出异常, 也不能设定升序还是降序。这个时候又要借助commons-collections包的ComparatorUtils. Comparator mycmp = ComparableComparator.getInstance(); mycmp = ComparatorUtils.nullLowComparator(mycmp); //允许null mycmp = ComparatorUtils.reversedComparator(mycmp); //逆序 Comparator cmp = new BeanComparator(sortColumn, mycmp);
如何实现javabean的属性拷贝
方式1：自己写一个，通过反射机制。示例代码（伪代码）如下
Object orgObj = new Object(); //原对象Object targetObj = new Object();//目标对象Field fields = orgObj.getClass().getDeclaredFields();for(Field field : fields){field.set(targetObj, field.get(orgObj));}
可以加入注解等，私有属性，记得使用暴力反射。
方式2：开源工具类。PropertyUtils、BeanUtils等。有对象拷贝等方法。
了解内省机制。
net.sf.json.JSONException: java.lang.reflect.InvocationTargetException
JSON-lib这个Java类包用于把bean,map和XML转换成JSON并能够把JSON转回成bean和DynaBean。参数可以是list,array等等vs.toArray() 改成这样试试
java解析json字符串数据
这个需要导入个jar包的，自己写太麻烦，而且要考虑特殊字符的转义的。
1. json-lib是一个java类库，提供将Java对象，包括beans, maps, collections, java arrays and XML等转换成JSON，或者反向转换的功能。
2. json-lib 主页 ： http://json-lib.sourceforge.net/
3.执行环境
需要以下类库支持
jakarta commons-lang 2.5
jakarta commons-beanutils 1.8.0
jakarta commons-collections 3.2.1
jakarta commons-logging 1.1.1
ezmorph 1.0.6
4.功能示例
这里通过JUnit-Case例子给出代码示例
package com.mai.json;import static org.junit.Assert.assertEquals;import java.util.ArrayList;import java.util.Date;import java.util.HashMap;import java.util.Iterator;import java.util.List;import java.util.Map;import net.sf.ezmorph.Morpher;import net.sf.ezmorph.MorpherRegistry;import net.sf.ezmorph.bean.BeanMorpher;import net.sf.json.JSONArray;import net.sf.json.JSONObject;import net.sf.json.util.JSONUtils;import org.apache.commons.beanutils.PropertyUtils;import org.junit.Test;public class JsonLibTest { /* * 普通类型、List、Collection等都是用JSONArray解析 * * Map、自定义类型是用JSONObject解析 * 可以将Map理解成一个对象，里面的key/value对可以理解成对象的属性/属性值 * 即{key1:value1,key2,value2......} * * 1.JSONObject是一个name:values集合，通过它的get(key)方法取得的是key后对应的value部分(字符串) * 通过它的getJSONObject(key)可以取到一个JSONObject，--》 转换成map, * 通过它的getJSONArray(key) 可以取到一个JSONArray ， * * */ //一般数组转换成JSON @Test public void testArrayToJSON(){ boolean boolArray = new boolean{true,false,true}; JSONArray jsonArray = JSONArray.fromObject( boolArray ); System.out.println( jsonArray ); // prints [true,false,true] } //Collection对象转换成JSON @Test public void testListToJSON(){ List list = new ArrayList(); list.add( “first“ ); list.add( “second“ ); JSONArray jsonArray = JSONArray.fromObject( list ); System.out.println( jsonArray ); // prints [“first“,“second“] } //字符串json转换成json， 根据情况是用JSONArray或JSONObject @Test public void testJsonStrToJSON(){ JSONArray jsonArray = JSONArray.fromObject( “[’json’,’is’,’easy’]“ ); System.out.println( jsonArray ); // prints [“json“,“is“,“easy“] } //Map转换成json， 是用jsonObject @Test public void testMapToJSON(){ Map map = new HashMap(); map.put( “name“, “json“ ); map.put( “bool“, Boolean.TRUE ); map.put( “int“, new Integer(1) ); map.put( “arr“, new String{“a“,“b“} ); map.put( “func“, “function(i){ return this.arr[i]; }“ ); JSONObject jsonObject = JSONObject.fromObject( map ); System.out.println( jsonObject ); } //复合类型bean转成成json @Test public void testBeadToJSON(){ MyBean bean = new MyBean(); bean.setId(“001“); bean.setName(“银行卡“); bean.setDate(new Date()); List cardNum = new ArrayList(); cardNum.add(“农行“); cardNum.add(“工行“); cardNum.add(“建行“); cardNum.add(new Person(“test“)); bean.setCardNum(cardNum); JSONObject jsonObject = JSONObject.fromObject(bean); System.out.println(jsonObject); } //普通类型的json转换成对象 @Test public void testJSONToObject() throws Exception{ String json = “{name=\“json\“,bool:true,int:1,double:2.2,func:function(a){ return a; },array:[1,2]}“; JSONObject jsonObject = JSONObject.fromObject( json ); System.out.println(jsonObject); Object bean = JSONObject.toBean( jsonObject ); assertEquals( jsonObject.get( “name“ ), PropertyUtils.getProperty( bean, “name“ ) ); assertEquals( jsonObject.get( “bool“ ), PropertyUtils.getProperty( bean, “bool“ ) ); assertEquals( jsonObject.get( “int“ ), PropertyUtils.getProperty( bean, “int“ ) ); assertEquals( jsonObject.get( “double“ ), PropertyUtils.getProperty( bean, “double“ ) ); assertEquals( jsonObject.get( “func“ ), PropertyUtils.getProperty( bean, “func“ ) ); System.out.println(PropertyUtils.getProperty(bean, “name“)); System.out.println(PropertyUtils.getProperty(bean, “bool“)); System.out.println(PropertyUtils.getProperty(bean, “int“)); System.out.println(PropertyUtils.getProperty(bean, “double“)); System.out.println(PropertyUtils.getProperty(bean, “func“)); System.out.println(PropertyUtils.getProperty(bean, “array“)); List arrayList = (List)JSONArray.toCollection(jsonObject.getJSONArray(“array“)); for(Object object : arrayList){ System.out.println(object); } } //将json解析成复合类型对象, 包含List @Test public void testJSONToBeanHavaList(){ String json = “{list:[{name:’test1’},{name:’test2’}],map:{test1:{name:’test1’},test2:{name:’test2’}}}“;// String json = “{list:[{name:’test1’},{name:’test2’}]}“; Map classMap = new HashMap(); classMap.put(“list“, Person.class); MyBeanWithPerson diyBean = (MyBeanWithPerson)JSONObject.toBean(JSONObject.fromObject(json),MyBeanWithPerson.class , classMap); System.out.println(diyBean); List list = diyBean.getList(); for(Object o : list){ if(o instanceof Person){ Person p = (Person)o; System.out.println(p.getName()); } } } //将json解析成复合类型对象, 包含Map @Test public void testJSONToBeanHavaMap(){ //把Map看成一个对象 String json = “{list:[{name:’test1’},{name:’test2’}],map:{testOne:{name:’test1’},testTwo:{name:’test2’}}}“; Map classMap = new HashMap(); classMap.put(“list“, Person.class); classMap.put(“map“, Map.class); //使用暗示，直接将json解析为指定自定义对象，其中List完全解析,Map没有完全解析 MyBeanWithPerson diyBean = (MyBeanWithPerson)JSONObject.toBean(JSONObject.fromObject(json),MyBeanWithPerson.class , classMap); System.out.println(diyBean); System.out.println(“do the list release“); List《Person》 list = diyBean.getList(); for(Person o : list){ Person p = (Person)o; System.out.println(p.getName()); } System.out.println(“do the map release“); //先往注册器中注册变换器，需要用到ezmorph包中的类 MorpherRegistry morpherRegistry = JSONUtils.getMorpherRegistry(); Morpher dynaMorpher = new BeanMorpher( Person.class, morpherRegistry); morpherRegistry.registerMorpher( dynaMorpher ); Map map = diyBean.getMap(); /*这里的map没进行类型暗示，故按默认的，里面存的为net.sf.ezmorph.bean.MorphDynaBean类型的对象*/ System.out.println(map); /*输出: {testOne=net.sf.ezmorph.bean.MorphDynaBean@f73c1[ {name=test1} ], testTwo=net.sf.ezmorph.bean.MorphDynaBean@186c6b2[ {name=test2} ]} */ List《Person》 output = new ArrayList(); for( Iterator i = map.values().iterator(); i.hasNext(); ){ //使用注册器对指定DynaBean进行对象变换 output.add( (Person)morpherRegistry.morph( Person.class, i.next() ) ); } for(Person p : output){ System.out.println(p.getName()); /*输出: test1 test2 */ } } }