BeanUtils和泛型
java泛型实现原理
Java泛型是Java编程语言中的一种特性,它允许程序员创建具有类型参数的类、接口和方法,以便在编译时强制执行类型安全性。
泛型的实现原理可以分为以下几个关键方面:1.类型擦除:Java中的泛型是通过类型擦除来实现的。
这意味着在编译时,泛型类型会被擦除为其边界类型或者Object类型。
这样做是为了保持与Java早期版本的兼容性,并且避免了在运行时额外生成大量的重复类。
2.类型参数转换:在类型擦除之后,泛型类中的类型参数会被转换为相应的边界类型或者Object类型。
编译器会插入必要的类型转换代码,以确保在运行时可以正确地处理类型。
3.类型擦除的影响:由于类型擦除的影响,泛型类中的参数化类型信息在运行时是不可用的。
这意味着在运行时,无法直接访问泛型类的参数化类型信息,而只能访问其擦除后的类型。
4.类型边界和限制:泛型中的类型边界和限制规定了泛型类型可以接受的类型范围。
这些边界可以是类、接口或者其他类型,用于限制泛型的类型参数必须满足特定的条件。
5.类型安全性和编译时检查:泛型的主要目的是为了提高类型安全性,并且在编译时进行类型检查,以确保类型的一致性。
这样可以在编译时捕获许多类型错误,并防止运行时出现类型相关的异常。
6.通配符和边界通配符:Java中的泛型还支持通配符和边界通配符,用于处理一些特定的泛型类型。
通配符允许程序员在泛型中使用未知类型,而边界通配符则允许限制通配符的类型范围。
Java泛型是Java编程语言中一个强大的特性,它提供了一种类型安全的编程方式,可以在编译时捕获许多潜在的类型错误。
尽管Java的泛型是通过类型擦除来实现的,但它仍然提供了许多有用的功能,使得Java编程更加灵活和可靠。
beanutil.beantomap 的用法
beanutil.beantomap的用法beanutil.beantlrmap是Java中一个常用的工具类,用于将对象映射到映射表中。
它提供了一组方法,可以帮助开发人员更加方便地操作对象和映射表之间的转换。
1.将对象转换为映射表中的记录:通过将对象属性与映射表中的列名进行匹配,可以将对象转换为映射表中的记录,并将其保存到数据库中。
2.将映射表中的记录转换为对象:通过匹配映射表中的记录与对象的属性,可以将映射表中的记录转换为相应的对象,从而方便地进行后续的处理和操作。
3.支持自定义映射规则:开发者可以通过实现自定义的映射规则类,来实现更加灵活的映射转换逻辑。
下面是一个简单的示例,展示了如何使用beanutil.beantlrmap将对象转换为映射表中的记录:1.创建一个对象,并设置其属性值:```javaPersonperson=newPerson();person.setName("John");person.setAge(30);```2.创建一个beanutil.beantlrmap实例,并指定映射表的表名和列名:```javaBeanMapper<Person>mapper=newBeanMapper<Person>().ofTableName("perso n_table").mapColumns("id","name","age");```3.使用mapper将对象转换为映射表中的记录:```javaObject[]record=mapper.toRecord(person);```现在,record数组中包含了person对象的属性值,可以将其保存到数据库中。
如果要将映射表中的记录转换为对象,可以按照以下步骤进行:1.创建一个beanutil.beantlrmap实例,并指定要匹配的记录和对象的属性:```javaBeanMapper<Person>mapper=newBeanMapper<Person>().ofTableName("perso n_table").mapColumns("id","name","age").toObject(Person.class);```2.使用mapper将映射表中的记录转换为对象:```javaPersonperson=mapper.fromRecord(record);```这样,person对象就得到了映射表中的记录的属性值。
jxls中文教程
一.JXLS简介在很多涉及到某种报表功能的Java程序中都需要生成Excel表格。
目前通过Java 来操作.xls文件最完整的类库是Apache POI类库,但是当需要创建多种自定义的复杂Excel报表的时候就会出现问题,这些Excel报表一般都带有多种格式和可扩展功能,在这种情况下,你就不得不写一大堆Java代码来创建报表的规则集(workbook),规则集一般包含所有要求的格式,公式,其他特定的设置和正确的Java对象集的数据出口。
这些代码一般都是难以调试,任务也常常变得容易出错并且耗时。
另外一个问题是有很多Excel组件都没有提供的API。
幸运的是POI API读取Excel 文件,可以保持它原有的格式,然后根据需要进行修改。
很明显,用一些Excel编辑工具来创建所有格式正确的报告模板然后指定真实的数据应该放置的地方,会容易很多。
JXLS是实现这种方法并且只用几行代码就能创建极其复杂的Excel报表。
你只需要用特定的标记来创建一个带有所有要求的格式,公式,宏等规则的.xls模板文件来指定数据放置的位置然后再写几行代码来调用JXLS引擎来传递.xls模板和导出的数据作为参数。
除了生成Excel报表功能,JXLS还提供了jxls-reader模块,jxls-reader模块会很有用,如果你需要解析一个预定义格式的Excel文件并在其中插入数据的话。
jxls-reader允许你用一个简单的XML文件描述解析规则,读取Excel文件和你的各种JAVA对象(population of your Java objects)的所有其他工作都会自动完成。
二.JXLS安装为了使用JXLS引擎,你必须把jxls-core.jar添加到项目的classpath,如果计划使用JXLS来读取.xls文件,那么你必须还要把jxls-reader.jar加入到项目的classpath中。
如果你用Maven来构建你的应用程序,你可以在你的pom.xml文件中配置指定要求的JXLS模块的依赖,让它们可以从Maven仓库下载。
java bean 泛型参数
java bean 泛型参数Java Bean 泛型参数:理解与应用一、引言在 Java 编程中,泛型是一种非常强大的工具,它允许程序员在编译时检查类型安全,并且所有的强制转换都是自动和隐式的,提高了代码的重用率。
而在使用Java Bean 时,我们也可以利用泛型来提高程序的灵活性和可读性。
二、什么是 Java Bean?Java Bean 是一种特殊的 Java 类,具有无参构造器,提供 getter 和 setter 方法访问属性,并且支持内省(Introspection)和事件处理(Event Handling)。
通常,Java Bean 被用于表示数据模型或者组件的状态。
三、泛型在 Java Bean 中的应用1. 定义泛型 Java Bean:```javapublic class GenericBean<T> {private T data;public T getData() {return data;}public void setData(T data) {this.data = data;}}```在这个例子中,`T` 是一个类型参数,代表任何类型。
当我们创建`GenericBean` 的实例时,可以指定 `T` 的具体类型。
2. 使用泛型 Java Bean:```javaGenericBean<String> stringBean = new GenericBean<>(); stringBean.setData("Hello, World!");String data = stringBean.getData();```在这个例子中,我们创建了一个 `GenericBean` 实例,其 `T` 参数为 `String` 类型。
然后我们可以使用 `setData()` 方法设置数据,并通过 `getData()` 方法获取数据。
BeanUtils中的自动类型转换(二)
BeanUtils中的⾃动类型转换(⼆)javabeanpackage entity;import java.util.Date;/*** ⼀个测试⽤:* student,javaBean* @author mzy* ⼀个标准的javaBean:* 1) 属性只要是private修饰的;* 2) 提供setter和getter⽅法;* 3) 提供⽆参构造。
* 就⾏了;有参构造等不是必须的。
*/public class Student {private int id;private String name;private double score;private boolean gender;private Date birth;public int getId() {return id;}public void setId(int id) {this.id = id;}public String getName() {return name;}public void setName(String name) { = name;}public double getScore() {return score;}public void setScore(double score) {this.score = score;}public boolean isGender() {return gender;}public void setGender(boolean gender) {this.gender = gender;}public Date getBirth() {return birth;}public void setBirth(Date birth) {this.birth = birth;}@Overridepublic String toString() {return "Student [id=" + id + ", name=" + name + ", score=" + score + ", gender=" + gender + ", birth=" + birth+ "]";}}package beanutil;import ng.reflect.InvocationTargetException;import java.text.ParseException;import java.text.SimpleDateFormat;import java.util.Date;import mons.beanutils.BeanUtils;import mons.beanutils.ConvertUtils;import mons.beanutils.Converter;import entity.Student;/*** BeanUtils:* 内部的⾃动类型转换。
开发系统的全流程
第一章需求分析 (1)1.1熟悉招聘网站的主要业务 (1)1.2系统功能需求初步分析 (5)1.2.1个人模块需求分析 (5)1.2.2企业模块 (5)1.2.3后台管理模块 (6)1.3确定系统的需求,完成用例图 (6)第二章数据库的设计 (8)2.1数据库实体分析 (8)2.2数据库设计 (9)2.2.1 概念模型设计 (9)2.2.2 物理模型的设计 (11)2.2.3 生成的sql语句 (11)第三章系统的环境的搭配 (12)第四章Hibernate持久层的设计与实现 (13)4.1设计持久化对象 (13)4.2创建持久化类 (15)4.3映射持久化类 (15)4.3.1 Users和它的三个子类的映射代码 (15)4.3.2 Resumes和属于Resumes的类的映射代码 (16)4.3.3 Users和Roles的映射代码 (18)4.4Hibernate配置文件的配置 (18)4.5设计和实现Dao层 (19)4.5.1 Dao组件的设计 (20)4.5.2 Dao组件的实现 (20)第五章业务逻辑层的设计与实现 (22)5.1业务逻辑组件的设计 (22)5.1.1 求职者模块的设计 (22)5.1.2 企业模块的设计 (25)5.1.3 管理员模块的设计 (28)5.2实现业务逻辑 (30)5.3事务管理 (32)5.4部署业务逻辑组件 (33)5.4.1 Struts中Action的配置 (33)5.4.2 Spring中Dao组件的配置 (33)5.4.3 Spring中Action中注入Dao的配置 (34)5.4.4 web.xml中的配置 (35)第六章系统页面的设计 (36)6.1系统主页面的设计 (36)6.2求职者用户主页面的设计 (36)6.3企业用户主页面的设计 (37)6.4系统管理员主页面的设计 (37)第七章系统安全 (38)第八章系统测试 (39)第九章项目总结 (40)9.1系统开发过程中用到的工具 (40)9.2系统开发中体现的思想 (40)9.3系统开发数据统计 (41)致谢 (42)附件一MySQL脚本 (43)附件二清河一班项目开发分工明细表 (51)第一章需求分析需求分析师系统开发的源头,一个系统的开发起源于系统的需求分析也最终回到需求分析。
BeanUtils工具类
BeanUtils⼯具类⼀.BeanUtils 概述BeanUtils 是阿帕奇提供的⼀套专门⽤于将⼀些数据封装到java对象中的⼯具类;名词:javaBean:特定格式的java类称为javaBean;要求:1:javaBean这个类要实现Serializable接⼝;(在实际开发中,通常省略了)2:javaBean必须有public权限的空参数的构造⽅法;3:javaBean必须有属性对应的getXxx与setter⽅法;⼆.BeanUtils 的使⽤Beanutils 有2个依赖jar包;commons-beanutils-1.8.3.jar和commons-logging-1.1.1.jar;BeanUtils 有2个核⼼类:BeanUtils,ConvertUtils 类;使⽤步骤:1:下载解压;2:复制核⼼jar包到⼯程中;(有2个)3:添加到本地;(add to build path)4:使⽤核⼼类;三.BeanUtils 常⽤⽅法public static void setProperty(Object bean,String name,Object value)throws IllegalAccessException,InvocationTargetException{}:向bean对象的name属性中保存value值;public static String getProperty(Object bean,String name)throws IllegalAccessException,InvocationTargetException,NoSuchMethodException{}:从bean对象中获取name属性的值; public static String[] getArrayProperty(Object bean,String name)throws IllegalAccessException,InvocationTargetException,NoSuchMethodException{}:从bean对象中获取name属性的数组类型的值;[注:getProperty⽅法就只认String类型和String[]数组类型,其它类型它会⾃动帮你转成这两个类型,使⽤时需时刻想到String类型,⽤""包裹属性]public static void populate(Object bean,Map properties)throws IllegalAccessException,InvocationTargetException{}:将properties集合中的数据,根据key与bean的属性名(实际上是匹配setXxx⽅法) 匹配,匹配成功,则赋值,匹配失败不操作;代码演⽰1:(以下代码全在Eclipse中实现)1//创建beanUtilsDemo01包2package beanUtilsDemo01;34import java.util.Arrays;56public class Person {7// 属性8private String name;9private int age;10private String[] hobby;1112// 构造⽅法13public Person() {14super();15 }1617public Person(String name, int age, String[] hobby) {18super(); = name;20this.age = age;21this.hobby = hobby;22 }2324// getter/setter25public String getName() {26return name;27 }2829public void setName(String name) { = name;31 }3233public int getAge() {34return age;35 }3637public void setAge(int age) {38this.age = age;41public String[] getHobby() {42return hobby;43 }4445public void setHobby(String[] hobby) {46this.hobby = hobby;47 }4849// 覆写toString/equal/hashcode50 @Override51public String toString() {52return "Person [name=" + name + ", age=" + age + ", hobby="53 + Arrays.toString(hobby) + "]";54 }5556 @Override57public int hashCode() {58final int prime = 31;59int result = 1;60 result = prime * result + age;61 result = prime * result + Arrays.hashCode(hobby);62 result = prime * result + ((name == null) ? 0 : name.hashCode());63return result;64 }6566 @Override67public boolean equals(Object obj) {68if (this == obj) {69return true;70 }71if (obj == null) {72return false;73 }74if (!(obj instanceof Person)) {75return false;76 }77 Person other = (Person) obj;78if (age != other.age) {79return false;80 }81if (!Arrays.equals(hobby, other.hobby)) {82return false;83 }84if (name == null) {85if ( != null) {86return false;87 }88 } else if (!name.equals()) {89return false;90 }91return true;92 }9394 }95//创建beanUtilsDemo01包96package beanUtilsDemo01;9798import java.util.Arrays;99100import mons.beanutils.BeanUtils;101102//BeanUtils常⽤⽅法练习103104public class Demo01BeanUtils {105106public static void main(String[] args) throws Exception {107// 实例化对象108 Person p = new Person();109// 借⽤BeanUtils⼯具类向Person对象赋值110 BeanUtils.setProperty(p, "name", "Rose");111 BeanUtils.setProperty(p, "age", 22);112 BeanUtils.setProperty(p, "hobby", new String[] { "eating", "sleeping", 113 "kissing" });114// 打印对象115 System.out.println(p);116// 获取各属性值117 String[] hobby = BeanUtils.getArrayProperty(p, "hobby");118 System.out.println(Arrays.toString(hobby));119 String name = BeanUtils.getProperty(p, "name");120 System.out.println(name);121 String age = BeanUtils.getProperty(p, "age");122 System.out.println(age);125 }126代码演⽰2:封装map集合中的数据1package beanUtilsDemo01;23import ng.reflect.InvocationTargetException;4import java.util.HashMap;5import java.util.Map;67import mons.beanutils.BeanUtils;89//借⽤BeanUtils将Map中的数据封装到javabean中1011public class Demo02BeanUtils {1213public static void main(String[] args) throws IllegalAccessException,14 InvocationTargetException {15// 实例化对象16 Person p = new Person();17// 准备MAP集合18 Map<String, Object> map = new HashMap<>();19// 向map中添加数据20 map.put("name", "jack");21 map.put("age", 23);22 map.put("hobbyy", new String[] { "eating", "sleeping", "painting" });23// 将map集合中的数据封装到javabean中24 BeanUtils.populate(p, map);25 System.out.println(p);26 }27 }28代码演⽰3:与以上利⽤同⼀个Person类1package beanUtilsDemo01;23import java.util.HashMap;4import java.util.Map;56import mons.beanutils.BeanUtils;78//利⽤BeanUtils⼯具类⾃定义⼯具类:要求传⼊任⼀类型的字节码⽂件和属性的map集合,返回实例化对象 9class MyBeanUtils {10public static <T> T popu(Class<T> c, Map map) throws Exception { //泛型11 Object obj = c.newInstance();12 BeanUtils.populate(obj, map);13return (T) obj; //向下转型14 }15 }1617public class MyTest {18public static void main(String[] args) throws Exception {19 Map<String, Object> map = new HashMap<>();20 map.put("name", "rose");21 map.put("age", "18");22 Person p = MyBeanUtils.popu(Person.class, map);23 System.out.println(p);24 }2526 }27代码演⽰4:需准备⼀个User类,和以上的Person类,及data.xml⽂件1package beanutilcase;23import java.util.HashMap;4import java.util.List;7import mons.beanutils.BeanUtils;8import org.dom4j.Document;9import org.dom4j.Element;10import org.dom4j.io.SAXReader;1112public class Demo {1314public static void main(String[] args) throws Exception {15 Person p = new Person();16 User u = new User();17// 创建解析器对象18 SAXReader sax = new SAXReader();19// 读取⽂档,并获取根节点20 Document doc = sax.read("data.xml");21 Element root = doc.getRootElement();22// 获取根节点下的⼀级⼦元素23 List<Element> listFirst = root.elements();24// 迭代25for (Element e : listFirst) {26// 获取⼀级⼦元素的属性值27 String path = e.attributeValue("className");28// 根据路径(属性)获取字节码⽂件29 Class c = Class.forName(path);30// 获取⼆级⼦元素31 List<Element> listSecond = e.elements();32// 定义map集合装属性值33 Map<String, Object> map = new HashMap<>(); 34for (Element es : listSecond) {35// 获取⼆级⼦元素的两个属性值36 String name = es.attributeValue("name");37 String value = es.attributeValue("value");38 map.put(name, value);39 }40// 利⽤beanutils⼯具类进⾏封装41// 判断是否为person42if (path.matches(".*Person$")) {43 BeanUtils.populate(p, map);44 } else {45 BeanUtils.populate(u, map);46 }47 }48 System.out.println(p);49 System.out.println(u);50 }5152 }53。
beanutils copyproperties拷贝规则
beanutils copyproperties拷贝规则摘要:1.BeanUtils 简介2.copyProperties 拷贝规则3.应用示例正文:1.BeanUtils 简介BeanUtils 是一个Java 库,它提供了将Java 对象转换为XML 或JSON 格式的简单方法。
同时,BeanUtils 也支持将XML 或JSON 格式的数据转换为Java 对象。
BeanUtils 的使用可以大大简化Java 对象与XML 或JSON 格式之间的数据转换工作。
2.copyProperties 拷贝规则copyProperties 是BeanUtils 中的一个方法,用于拷贝一个对象的属性到另一个对象。
拷贝规则如下:- 如果源对象的属性值为null,那么目标对象的对应属性值也会被设置为null。
- 如果源对象的属性值为空字符串,那么目标对象的对应属性值也会被设置为空字符串。
- 对于基本数据类型,如int、float、boolean 等,直接进行值拷贝。
- 对于引用类型,如对象、数组等,会进行深度拷贝。
3.应用示例以下是一个使用BeanUtils 的copyProperties 方法进行对象属性拷贝的示例:```javaimport com.alibaba.beanutils.BeanUtils;public class Main {public static void main(String[] args) {Person source = new Person();source.setName("张三");source.setAge(25);source.setAddress(new Address("北京市", "朝阳区"));Person target = new Person();BeanUtils.copyProperties(source, target);System.out.println(target.getName()); // 输出:张三System.out.println(target.getAge()); // 输出:25System.out.println(target.getAddress().getCity()); // 输出:北京市}}```在这个示例中,我们创建了两个Person 对象,并通过BeanUtils 的copyProperties 方法将source 对象的属性拷贝到target 对象。
java 通用 泛型 入参 bean 方法
Java通用泛型入参Bean方法一、介绍在Java开发中,我们经常会遇到需要处理通用类型的数据的情况。
为了提高代码的复用性和灵活性,我们通常会使用泛型来定义通用类型的方法。
在某些情况下,我们需要将通用类型的数据封装成Bean对象,并将其作为方法的入参。
本文将介绍如何使用泛型和Bean对象来实现通用类型的入参方法。
二、泛型入参方法的定义在Java中,我们可以使用泛型来定义通用类型的方法。
泛型方法可以接受任意类型的参数,并且在编译时会进行类型检查,确保方法的类型安全。
下面是一个使用泛型的通用类型方法的定义示例:```javapublic class GenericMethod {public <T> void process(T data) {// 对通用类型数据进行处理}}```在上面的示例中,`process`方法使用了泛型`<T>`来定义通用类型的参数`data`。
这样就可以接受任意类型的参数,并对其进行处理。
三、泛型Bean对象的定义除了直接使用泛型作为方法的入参外,我们还可以将通用类型的数据封装成Bean对象,并将其作为方法的入参。
下面是一个使用泛型Bean对象的定义示例:```javapublic class GenericBean<T> {private T data;public T getData() {return data;}public void setData(T data) {this.data = data;}}```在上面的示例中,`GenericBean`类使用了泛型`<T>`来定义通用类型的数据`data`。
通过将通用类型的数据封装成Bean对象,我们可以更加灵活地处理这些数据,并且可以在方法的入参中直接使用这个Bean 对象。
四、泛型Bean方法的定义现在我们已经有了泛型Bean对象的定义,接下来我们将介绍如何在方法的入参中使用这个Bean对象。
增删改查流程
1)拷贝下面所说的.java文件,9个java文件和相应的包名,这些都是大果任封装好的文件,可以直接用。
dao包里面有:还有一个impl包:manager包里面有:还有一个impl包:struts包里面有:还有一个action包:utils包里面有:再把log4j.properties贴到src包下面。
2)把spring-struts-struts-struts-struts-struts-struts-validator-这些以前写过的都可以贴过来,你可以直接把这个项目里的都贴过去,以后就直接在这里该代码就行了。
以上两个步骤样就是为了完成手写SSH代码3)新建一个pojo包:创建一个实体:先让这个类实现序列接口如:然后写相应的字段:利用get和set方法生成每个字段的get()和set()。
例如:4)为了更够生成所以为每一个字段写出相应的元数据:1.生成相应的表:说明:利用hibernate生成UserLogin表。
2.字段id的映射,元数据要写在get()方法前面:3.字段username的映射,元数据要写在get()方法前面:4.字段password的映射,元数据要写在get()方法前面:这样这个就完成了。
5)右键项目名称找到“属性”选项:找到:XDoclet点击这个出来相应的界面:单击按钮,出现:选中:并单击确定按钮。
出现:点击“确定”按钮。
6)右键项目名称:执行RunXDocle后只要出现:就说明你的UserLogin类的创建成功了!!7)新建一个的页面(带Form的那种页面):生成相应的页面后把属性名称,改成:给相应的action后面添加一个名字,指明提交表单后走哪个.do如:8)找到双击:在代码标签中手写action(就是上面表单提交后的那个/***.do):在找到标签,写上form-bean的代码:说明:根据jsp页面提交的/找到struts-里面的path属性,根据name属性找到form-bean标签里的name属性,以及它对应的type属性,type 属性写的就是pojo类中UserLogin的全名(包括包名和类名),Parameter属性是说明表单提交后要执行check方法,Validate=”false”属性说明不使用表单验证框架,Scope=”request”说明作用域是request,Type=””属性写得就是你一会要创建的UserLoginAction的全名(包括包名和类名),Forword标签就是说明要是check成功后跳转,失败就跳转页面。
寻找写代码感觉(十二)之封装分页请求参数和返回参数
寻找写代码感觉(⼗⼆)之封装分页请求参数和返回参数⼀、写在前⾯好在上周的加班,有了些成效,终于不⽤每天熬着了,可以为那段程序画上⼀个暂时性的句号了,最后希望项⽬顺利上线。
⼆、为什么要进⾏封装?学习的⾓度看,更加贴近了封装的特性,使得代码整洁,复⽤率⾼,锻炼⾃⼰的能⼒。
协作的⾓度看,利⼈利⼰。
别⼈调你的⽅法或者接⼝,效率更⾼。
三、如何进⾏分页请求参数和返回参数的封装从结果导向来看,就是将⼊参及返回信息统⼀化,我们先对请求参数进⾏改造。
1、⼊参的改造新建⼀个类,并附上页数和每页显⽰条数两个属性,⽰例代码如下:package com.rongrong.wiki.req;import lombok.Data;@Datapublic class PageReq {private int page;private int size;}这并没有完,因为还要保留原来⼊参,有时候也许还要⽤这两个属性,所以这⾥需要继承PageReq这个类即可,⽰例代码如下:package com.rongrong.wiki.req;public class EBookReq extends PageReq {private Long id;private String name;public Long getId() {return id;}public void setId(Long id) {this.id = id;}public String getName() {return name;}public void setName(String name) { = name;}@Overridepublic String toString() {StringBuilder sb = new StringBuilder();sb.append(getClass().getSimpleName());sb.append(" [");sb.append("Hash = ").append(hashCode());sb.append(", id=").append(id);sb.append(", name=").append(name);sb.append("]");return sb.toString();}}2、返回信息的改造其实,这么做的好处就是给前端同学更好的表⽰作⽤。
使用(BeanUtils工具包)将JavaBean对象和Map相互转换
使⽤(BeanUtils⼯具包)将JavaBean对象和Map相互转换public class ReflectBean {/*** 将⼀个 JavaBean 对象转化为⼀个 Map* @param bean 要转化的JavaBean 对象* @return 转化出来的 Map 对象*/public static Map<String, String> beanConvertMap(Object bean){Class<? extends Object> cls = bean.getClass();Map<String, String> returnMap = new HashMap<String, String>();Field[] fields = cls.getDeclaredFields();for(int i = 0 ; i < fields.length ; i++){PropertyDescriptor descriptor=BeanUtils.getPropertyDescriptor(cls, fields[i].getName());Method readMethod = descriptor.getReadMethod();try {String result = readMethod.invoke(bean, new Object[0])==null?"": readMethod.invoke(bean, new Object[0]).toString();if (!"".equals(result) && result != null) {returnMap.put(fields[i].getName(), result);}} catch (IllegalArgumentException e1) {e1.printStackTrace();} catch (IllegalAccessException e1) {e1.printStackTrace();} catch (InvocationTargetException e1) {e1.printStackTrace();}}return returnMap;}/*** 将⼀个 Map 对象转化为⼀个 JavaBean* @param obj 要转化的对象* @param map 包含属性值的 map* @return 转化出来的 JavaBean 对象*/public static Object mapConvertBean(Map<String, String> maps,Object obj){Class cls=obj.getClass();Field[] fields = cls.getDeclaredFields();for (int i = 0; i < fields.length; i++) {if (maps.containsKey(fields[i].getName())) {Object values = maps.get(fields[i].getName());Object[] argss = new Object[1];argss[0] = (String) values;PropertyDescriptor descriptor=BeanUtils.getPropertyDescriptor(cls, fields[i].getName());try {descriptor.getWriteMethod().invoke(obj, values);} catch (IllegalArgumentException e) {e.printStackTrace();} catch (IllegalAccessException e) {e.printStackTrace();} catch (InvocationTargetException e) {e.printStackTrace();}}}return obj;}/*** 将List结果集转换为Map* @param list* @return*/public static Map<String, String> listCoverMap(List<Param> list){Map<String,String> map=new HashMap<String,String>();for (int i = 0; i <list.size(); i++) {map.put(list.get(i).getName(),(list.get(i)).getValue());}return map;}BeanUtils⼯具包是由Apache公司所开发,主要是⽅便程序员对Bean类能够进⾏简便的操作。
beanutils copy 泛型
beanutils copy 泛型BeanUtils是ApacheCommons项目中的一个Java类库,它提供了一组工具类,用于简化JavaBean的操作。
其中,BeanUtils.copyProperties()方法是一个非常常用的方法,它可以将一个JavaBean的属性复制到另一个JavaBean中。
不过,在使用这个方法的时候,如果涉及到泛型类型的属性,就可能会遇到一些问题。
本文将详细介绍如何使用BeanUtils.copyProperties()方法复制泛型类型的属性。
一、BeanUtils.copyProperties()方法的基本用法BeanUtils.copyProperties()方法可以将一个JavaBean的属性复制到另一个JavaBean中。
其基本用法如下:```BeanUtils.copyProperties(dest, orig);```其中,dest表示目标JavaBean,orig表示源JavaBean。
该方法会将orig中的所有属性值复制到dest中对应的属性中。
如果目标JavaBean中没有与源JavaBean中对应的属性,则不进行复制。
二、BeanUtils.copyProperties()方法对泛型属性的处理BeanUtils.copyProperties()方法对于普通类型的属性,可以很好地进行复制。
但是,对于泛型类型的属性,就可能会遇到一些问题。
举个例子,假设有如下两个JavaBean:```public class User {private String name;private List<Role> roles;// getter and setter methods}public class Role {private String name;// getter and setter methods}```其中,User类中有一个roles属性,它是一个List类型的泛型属性。
hutool beanutil 类型转化
hutool beanutil 类型转化类型转化是编程中经常会遇到的需求之一,尤其是在处理数据时。
在Java开发中,我们可以使用Hutool框架中的BeanUtil类来实现类型转化的功能。
本文将以中括号为主题,详细介绍Hutool的BeanUtil类以及其类型转化功能。
第一章:引言Java是一种强类型语言,要求变量的数据类型在编译时期就要确定。
但在实际开发过程中,我们经常会遇到需要在不同数据类型之间进行转化的情况,如String转化为int、Map转化为实体类等。
Hutool是一个Java工具包,内置了许多常用的工具类,其中的BeanUtil类提供了丰富的类型转化方法,可以帮助我们简化代码、提高开发效率。
第二章:初始化BeanUtil类在开始使用BeanUtil类之前,我们首先需要引入Hutool的依赖以及初始化BeanUtil类。
java<dependency><groupId>cn.hutool</groupId><artifactId>hutool-all</artifactId><version>5.7.10</version></dependency>javaimport cn.hutool.core.bean.BeanUtil;第三章:基本的类型转化BeanUtil类提供了一系列静态方法,可以实现各种基本的类型转化。
3.1 String转换为基本类型javaString str = "123";int num = BeanUtil.parseInt(str);3.2 基本类型转换为Stringjavaint num = 123;String str = BeanUtil.toString(num);3.3 String数组转换为int数组javaString[] strArr = {"1", "2", "3"};int[] intArr = BeanUtil.toIntArray(strArr);3.4 int数组转换为String数组javaint[] intArr = {1, 2, 3};String[] strArr = BeanUtil.toStringArray(intArr);3.5 String转换为EnumjavaString str = "MALE";Gender gender = BeanUtil.toEnum(str, Gender.class);3.6 Enum转换为StringjavaGender gender = Gender.MALE;String str = BeanUtil.toString(gender);第四章:集合类型的转化除了基本类型的转化,BeanUtil类还支持集合类型的转化。
JSONUtils的几个常用方法
/*** * 将JSON文本反序列化为主从关系的实体 * @param 泛型T 代表主实体类型 * @param 泛型D1 代表从实体类型 * @param 泛型D2 代表从实体类型 * @param jsonString JSON文本 * @param mainClass 主实体类型 * @param detailName1 从实体类在主实体类中的属性 * @param detailClass1 从实体类型 * @param detailName2 从实体类在主实体类中的属性 * @param detailClass2 从实体类型 * @return */ public static <T, D1, D2> T toBean(String jsonString, Class<T> mainClass, String detailName1, Class<D1> detailClass1, String detailName2, Class<D2> detailClass2) { JSONObject jsonObject = JSONObject.fromObject(jsonString); JSONArray jsonArray1 = (JSONArray) jsonObject.get(detailName1); JSONArray jsonArray2 = (JSONArray) jsonObject.get(detailName2);
博客园 用户登录 代码改变世界 密码登录 短信登录 忘记登录用户名 忘记密码 记住我 登录 第三方登录/注册 没有账户,
JSONUtils的 几 个 常 用 方 法
1.首先新建1个JSONUtils类
张孝祥java高新特性个人整理(上)
Java高新技术 (2)课程内容 (2)Eclipse的使用技巧 (4)1名词翻译面试题 (4)2Java开发阶段和运行阶段使用的jdk可分别设置 (5)3workspace工作间概念 (5)调试,查看变量的值(面试) (5)透视图与视图的关系 (6)配置单个工程的javac和java (6)Eclipse里的各种模版,可以新建 (7)StaticImport静态导入 (7)方法的可变参数VariableParameter (7)自动裝箱和自动拆箱AutoBox (7)自动裝箱细节-基本数据类型缓存(享元模式) (8)枚举Enum (8)普通类模拟枚举 (8)Enum的基本使用 (9)实现带有构造方法的枚举 (9)实现带有抽象方法的枚举 (10)反射的基石-Class类 (10)如何得到各个字节码对应的实例对象(Class类) (10)理解反射的概念 (11)反射里的Construct类 (11)反射是比较耗时的,大量使用会降低程序性能 (11)成员变量Field类 (11)暴力反射 (11)将任意对象的String属性的值里的b字符替换成a (12)数组与Object的关系 (12)不用循环语句打印数组的值 (12)Hashset的内部原理 (13)重写HashSet的equals方法时自变量参数必须是Object (14)Hashcode方法与equals方法的关系 (14)Hashset存后又修改元素导致的内存泄漏 (14)框架要解决的核心问题 (15)最小框架实现 (15)什么是JavaBean (16)内省(xing)->InterSpector 内窥 (16)简单的内省操作 (16)使用BeanUtils工具包设置和读取JavaBean属性 (17)BeanUtils使用详解 (17)JDK里的注解 (18)什么是注解(Annotation)? (18)自定义注解及其应用 (20)为注解增加基本属性 (20)为注解增加高级属性 (21)泛型 (21)使用反射可以跳过编译期向泛型集合中添加别的类型数据 (21)你了解泛型(术语)吗? (22)泛型中的?通配符 (22)泛型中的?通配符的扩展 (23)泛型应用:遍历参数化HashMap (23)由c++的模版函数引入自定义泛型<T>方法(重点) (25)交换任意数组中的两个元素位置泛型语法实现 (25)编译器不会对int[]数组里面的int进行自动裝箱和自动拆箱 (26)泛型方法练习题 (26)类型参数的类型推断(难点) (27)定义泛型类型 (27)通过反射获得泛型的参数化类型 (28)类加载器(参考虚拟机详解笔记) (28)Java高新技术课程内容===================第1单元:概述======================01.课程价值与目标介绍===============第2单元:eclipse开发工具================02.eclipse及IDE开发工具介绍03.eclipse工程管理与快捷键配置04.eclipse视图管理与程序调试05.配置eclispe的编译与运行环境06.在eclispe中配置java模板代码07.在eclipse中导入已有的工程==========第3单元:java5的一些简单新特性===============08.java5的静态导入与编译器语法设置09.可变参数与OverLoad相关面试题分析10.java5的增加for循环11.基本数据的自动拆装箱及享元设计模式=================第4单元:java5的枚举==================12.枚举的作用介绍13.用普通类模拟枚举的实现原理14.java5的枚举的基本应用15.实现带有构造方法的枚举16.实现带有抽象方法的枚举=================第5单元:反射的深入讲解===============17.透彻分析反射的基础_Class类18.理解反射的概念19.构造方法的反射应用20.成员变量的反射21.成员变量反射的综合案例22.成员方法的反射23.对接收数组参数的成员方法进行反射24.数组与Object的关系及其反射类型25.数组的反射应用26.ArrayList_HashSet的比较及Hashcode分析27.框架的概念及用反射技术开发框架的原理28.用类加载器的方式管理资源和配置文件29.由内省引出JavaBean的讲解30.对JavaBean的简单内省操作31.对JavaBean的复杂内省操作32.使用BeanUtils工具包操作JavaBean================第6单元:java5的注解===================33.了解和入门注解的应用34.注解的定义与反射调用35.为注解增加各种属性================第7单元:java5的泛型===================36.入门泛型的基本应用37.泛型的内部原理及更深应用38.泛型的通配符扩展应用39.泛型集合的综合应用案例40.自定义泛型方法及其应用41.自定义泛型方法的练习与类型推断总结42.自定义泛型类的应用43.通过反射获得泛型的实际类型参数=========第8单元:类加载器的深入讲解与应用=============44.类加载器及其委托机制的深入分析45.自定义类加载器的编写原理分析46.编写对class文件进行加密的工具类47.编写和测试自己编写的解密类加载器48.类加载器的一个高级问题的实验分析==========第9单元:动态代理技术的深入讲解==============49.分析代理类的作用与原理及AOP概念50.创建动态类及查看其方法列表信息51.创建动态类的实例对象及调用其方法52.完成InvocationHandler对象的内部功能53.分析InvocationHandler对象的运行原理54.总结分析动态代理类的设计原理与结构55.编写可生成代理和插入通告的通用方法56.实现类似spring的可配置的AOP框架=======第10单元(待补充整理):多线程及java5的线程并发库========57.创建和启动线程的两种传统方式58.传统的定时器实现方式59.传统的线程同步互斥60.传统的线程间通讯61.多线程访问共享数据的经典总结62.ThreadLocal与线程级变量共享63.Java5中的线程池64.Java5中的定时器65.java5提供的可返回结果的线程模式66.java5中的锁与读写锁67.Semaphore同步工具68.CyclicBarrier同步工具69.CountDownLatch同步工具70.Exchanger同步与数据交换工具71.Java5中的可阻塞队列72.传统与java5中的同步集合Eclipse的使用技巧1名词翻译面试题面试的时候包名写公司的倒转域名,面试interviewJDK就是Java Development Kit它包含开发工具包和JRE(运行时环境包)JRE是Java Runtime Enviroment是指Java的运行环境,是面向Java程序的使用者,而不是开发者。
2016年最新版JavaEE学科课程大纲 黑马程序员官网
2016年最新版JavaEE学科课程大纲黑马程序员官网2016年最新版JavaEE学科课程大纲一、JavaWeb部分第一阶段:JavaWEB 部分一之WEB前端技术1、Html了解HTML语言,HTML语言背景知识,掌握HTML 的整体结构、文件标签、排版标签、块标签、字体标签、列表标签、图形标签、超链接标签、表格标签、表单标签(form 标签、input标签、select标签等)、分区标签、头标签。
(1)CSSCSS介绍、CSS导入方式(内部样式表、内联样式表、外部样式表)、五大CSS选择器(ID选择器、类选择器、元素选择器、属性选择器、伪类等)、样式属性介绍。
(2)JavaScript基础JavaScript编程,JavaScript语法、数据类型、运算符、表达式、流程控制,JavaScript内部对象、数组、字符串、日期时间、数学函数、正则表达式,JavaScript函数、自定义函数、全局函数,BOM介绍、window 对象、location对象、history对象使用。
DHTML编程,理解DOM树,DOM对象,常用DOM对象的属性、方法和事件,编写事件处理程序、使用DOM操作HTML文档、遍历文档树上的节点、搜索文档中特定的元素、修改文档内容、往文档添加新内容、使用DOM操作XML文档。
(3)JQuery基础认识JQuery、选择器介绍、css选择器、jQuery选择器及其优势势、基本选择器、层次选择器、过滤选择器、表单选择器、选择器练习小案例等;JQuery操作DOM:DOM分类、查找元素/属性节点、创造元素/属性/文本节点、插入节点、删除节点、复制节点、替换节点、包裹节点、属性操作、样式操作、遍历节点、CSS-DOM操作;动画和事件:jQuery中的事件、加载DOM、事件绑定、合成事件、事件冒泡、事件对象的属性、移除按钮上注册的事件、模拟操作、JQuery中的动画。
(4)BootStrap响应式页面的的开发与设计,强大的栅格布局,内置的CSS类库,JS插件,快速布局商城页面。
JavaBean中对象的复制:BeanUtils和Dozer
JavaBean中对象的复制:BeanUtils和Dozer在开发过程中,我们会遇到各种bean之间的转换,⽐如⽤ORM框架查询出来的数据,对应的bean,需要转换成Dto返回给调⽤⽅,这个时候就需要进⾏bean的转换了⼀、org.springframework.beans.BeanUtilsBeanUtils是开发中常⽤到的⼯具类,⽽获取这⼀⼯具类主要是通过导⼊org.springframework.beans.BeanUtils或者mons.beanutils.BeanUtils包来获取,但是不同的包中BeanUtils的⽅法使⽤是不⼀样的,接下来就对这两个包中的copyProperties⽅法进⾏对⽐。
先来看⼀下这两个包中的copyProperties⽅法的定义://org.springframework.beans.BeanUtilspublic static void copyProperties(Object source, Object target){....}//mons.beanutils.BeanUtilspublic static void copyProperties(Object dest,Object orig){....}由定义可知,在org.springframework.beans.BeanUtils包下的copyProperties第⼀个参数是被copy的对象,⽽mons.beanutils.BeanUtils中是第⼆个参数,所以使⽤时不要弄混。
建议使⽤org.springframework.beans.BeanUtils包下的copyProperties,因为⽬标对象(target/dest)中不包含被copy的对象(source/orig)的所有字段时,apache包下的BeanUtils会报错。
源代码:private static void copyProperties(Object source, Object target, @Nullable Class<?> editable, @Nullable String... ignoreProperties) throws BeansException {Assert.notNull(source, "Source must not be null");Assert.notNull(target, "Target must not be null");Class<?> actualEditable = target.getClass();if (editable != null) {if (!editable.isInstance(target)) {throw new IllegalArgumentException("Target class [" + target.getClass().getName() + "] not assignable to Editable class [" + editable.getName() + "]");}actualEditable = editable;}PropertyDescriptor[] targetPds = getPropertyDescriptors(actualEditable);List<String> ignoreList = ignoreProperties != null ? Arrays.asList(ignoreProperties) : null;PropertyDescriptor[] var7 = targetPds;int var8 = targetPds.length;for(int var9 = 0; var9 < var8; ++var9) {PropertyDescriptor targetPd = var7[var9];Method writeMethod = targetPd.getWriteMethod();if (writeMethod != null && (ignoreList == null || !ignoreList.contains(targetPd.getName()))) {PropertyDescriptor sourcePd = getPropertyDescriptor(source.getClass(), targetPd.getName());if (sourcePd != null) {Method readMethod = sourcePd.getReadMethod();if (readMethod != null && ClassUtils.isAssignable(writeMethod.getParameterTypes()[0], readMethod.getReturnType())) {try {if (!Modifier.isPublic(readMethod.getDeclaringClass().getModifiers())) {readMethod.setAccessible(true);}Object value = readMethod.invoke(source); // 将源对象的key对应的值读取出来if (!Modifier.isPublic(writeMethod.getDeclaringClass().getModifiers())) {writeMethod.setAccessible(true);}writeMethod.invoke(target, value); // 将源对象的值赋值到⽬标对象中} catch (Throwable var15) {throw new FatalBeanException("Could not copy property '" + targetPd.getName() + "' from source to target", var15);}}}}}}注意:复制的是属性,⽽不是字段,故要加@Data注解1、当⽬标对象中包含源对象的所有属性时,会将源对象的所有属性值都复制过来Student类@Datapublic class Student {private String id;private String username;private Integer age;}StudentDTO@Datapublic class StudentDTO{private String id;private String username;private Integer age;private String gender;private Date birthday;}测试public class BeanUtilsTest {public static void main(String[] args) throws InvocationTargetException, IllegalAccessException, IntrospectionException { Student student = new Student();student.setId(UUID.randomUUID().toString());student.setUsername("张三");student.setAge(22);StudentDTO studentDTO = new StudentDTO();BeanUtils.copyProperties(student,studentDTO);System.out.println(studentDTO);}}结果:StudentDTO(id=4b44fd85-1f06-4395-988f-628173f13480, username=张三, age=22, gender=null, birthday=null)2、当⽬标对象不包含源对象的所有属性时,源对象的部分属性值会丢失Student类@Datapublic class Student {private String id;private String username;private Integer age;}StudentDTO@Datapublic class StudentDTO{private String id;private String username;}测试public class BeanUtilsTest {public static void main(String[] args) throws InvocationTargetException, IllegalAccessException, IntrospectionException { Student student = new Student();student.setId(UUID.randomUUID().toString());student.setUsername("张三");student.setAge(22);StudentDTO studentDTO = new StudentDTO();BeanUtils.copyProperties(student,studentDTO);System.out.println(studentDTO);}}结果:StudentDTO(id=4fc2e73c-3ba5-448d-8884-88f3c66bbed7, username=张三)3、当源对象和⽬标对象中的属性的类型不⼀样时,会报错Student类@Datapublic class Student {private String id;private String username;private Integer age;}StudentDTO类@Datapublic class StudentDTO extends Student{private String id;private String username;private Long age;}注意:两个类的age属性的类型不⼀样,⼀个为Integer,⼀个为Long测试public class BeanUtilsTest {public static void main(String[] args) throws InvocationTargetException, IllegalAccessException, IntrospectionException {Student student = new Student();student.setId(UUID.randomUUID().toString());student.setUsername("张三");student.setAge(22);StudentDTO studentDTO = new StudentDTO();BeanUtils.copyProperties(student,studentDTO);System.out.println(studentDTO);}}结果Error:(16, 18) java: com.ljxx.entity.business.StudentDTO中的getAge()⽆法覆盖com.ljxx.entity.business.Student中的getAge()返回类型ng.Long与ng.Integer不兼容综上所述:BeanUtils.copyProperties只能复制对象中名称且类型相同的属性。
BeanUtils.copyProperties()拷贝id属性失败的原因及解决
BeanUtils.copyProperties()拷贝id属性失败的原因及解决⽬录BeanUtils.copyProperties()拷贝id属性失败部分代码如下解决⽅法BeanUtils.copyProperties 出错BeanUtils.copyProperties()拷贝id属性失败po类中id有值,但是使⽤BeanUtils.copyProperties()拷贝出的vo类id属性为null,检查后发现是因为po继承的⽗类声明了⼀个泛型。
部分代码如下public abstract class AbstractEntity<ID extends Serializable> implements Serializable {protected ID id;/**创建⼈*/protected ID createdBy;/**创建时间*/protected Date createdTime;/**最后⼀次修改⼈*/protected ID lastModifiedBy;/**最后⼀次修改时间*/protected Date lastModifiedTime;public void setId(ID id) {this.id = id;}public ID getId() {return this.id;}查看BeanUtils.copyProperties()源码中有⼀段判断如下:if (readMethod != null && ClassUtils.isAssignable(writeMethod.getParameterTypes()[0], readMethod.getReturnType()))当执⾏到获取vo类的writeMethod即setId()参数类型,结果是Long类型,⽽po类的readMethod即getId()返回值类型获取到的结果却是Serializable所以BeanUtils认为属性类型不同,所以不会拷贝id属性。
代码精简条目梳理_2020-5-9
代码精简条目文档编号:创建日期:最后修改日期:版本号:电子版文件名:文档修订摘要目录1 概述 (5)目的 (5)阅读对象 (5)设计原则与前提 (5)名词解释 (5)2 精简条目 (5)利用语法 (6)2.1.1 三元表达式 (6)2.1.2 利用for-each 语句 (7)2.1.3 利用try-with-resource 语句 (8)2.1.4 利用return 关键字 (9)2.1.5 利用static 关键字 (9)2.1.6 利用lambda 表达式 (10)2.1.7 利用方法引用 (11)2.1.8 利用静态导入 (11)利用注解 (12)2.2.1 利用Lombok 注解 (12)2.2.2 利用Validation 注解 (13)2.2.3 利用@NonNull 注解 (14)2.2.4 利用注解特性 (15)利用泛型 (15)2.3.1 泛型接口 (15)利用自身方法 (16)2.4.1 利用构造方法 (16)2.4.2 利用链式编程 (18)利用工具方法 (19)2.5.1 避免空值判断 (19)2.5.2 避免条件判断 (19)2.5.3 简化赋值语句 (20)2.5.4 简化数据拷贝 (20)2.5.5 简化异常断言 (21)利用数据结构 (22)2.6.1 利用数组简化 (22)2.6.2 利用Map 简化 (22)利用Optional (24)2.7.1 保证值存在 (24)2.7.2 保证值合法 (24)2.7.3 避免空判断 (25)利用Stream (25)2.8.1 匹配集合数据 (26)2.8.2 过滤集合数据 (26)2.8.3 汇总集合数据 (27)2.8.4 转化集合数据 (27)2.8.5 分组集合数据 (28)2.8.6 分组汇总集合 (28)利用程序结构 (29)2.9.1 返回条件表达式 (29)利用设计模式 (30)2.10.1 模板方法模式 (30)2.10.2 建造者模式 (32)2.10.3 代理模式 (36)利用删除代码 (37)2.11.1 删除已废弃的代码 (37)2.11.2 删除接口方法的public (38)2.11.3 删除枚举构造方法的private (39)2.11.4 删除不必要的变量 (40)多级for循环 (40)2.12.1 原代码 (41)2.12.2 精简 (41)开放性设计 (41)兼容性设计 (41)其他设计要求 (41)3 产品/服务高可用指标 (42)4 变更设计 (42)5 附录 (42)1概述目的《孙子兵法》讲:“道为术之灵,术为道之体;以道统术,以术得道”。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
// 4) 调用存取方法: Object obj = clazz.newInstance();// 无需转换成Person,因为反射的调用对象是Object writeMethod.invoke(obj, "王五"); String name_01 = (Sull); sop(name_01); // 对于age属性来说,都是如此 }
在使用者套 API 之前要导入的 jar 包: Log4j.jar commons-beanutils-1.8.0.jar Beanutils 工具包的常用类: BeanUtils. getProperty(Object bean, String name) BeanUtils. setProperty(Object bean, String name, Object value) ConvertUtils.register(Converter converter, Class clazz): 给BeanUtils工具提前注册一个自定义的转换器,该转换器能将String转成任意的类型,一定要在 BeanUtils. setProperty(Object bean, String name, Object value) 之前使用。 如果没有内置的类,那一定要实现Converter接口中的contvert方法: public Object convert(Class type,Object value) :获取属性值 :设置属性值
/* 1) BeanUtils能够自动将String转成8种基本类型,例如String转float; 2) 通过BeanUtils.setProperty()和BeanUtils.getProperty()对某个属性存取; 3) 自定义类型转换器,即String->java.util.Date类型 4) 此外,BeanUtiles还可以将:八种基本类型的数组、File、Class、BigDecimal、BigInteger、Date、 Calendar、Numebr、SqlDate、SqlTimestam、URL、String这些对象的String类型转成其对象值, 详情请参考:mons.beanutils.converters!!! */ } @Test public void test2() { // 在Person的类中添加一个Date类型的字段 try { Class clazz = Class.forName("cn.itcast.java.introspector.Person"); Object obj = clazz.newInstance();
// 3、第二种内省方式 : @Test public void test_03() throws Exception { // 1) Class clazz = Class.forName("cn.itcast.java.introspector.Person"); // 2) 获取该JaveBean的所有信息: BeanInfo beanInfo = Introspector.getBeanInfo(clazz); // 3) 获取该javaBean的所有属性信息:该JavaBean究竟有多少个属性: PropertyDescriptor [] pds = beanInfo.getPropertyDescriptors(); for(PropertyDescriptor pd : pds){ sop(pd.getName()); // } /* 在Person的类中明明之定义了两个私有的字段age和name,得出的属性描述器却有三个! * 是因为从Object中继承了一个方法:getClass() * 获取javaBean的的依据: * * 1) 如果定义了一个属性,只要有一个的getter或者setter方法; * 2) 如果没有定义一个字段,但有getXxx()方法,并且该方法是有返回值的; * */ } public static void sop(Object obj){ System.out.println(obj); } }
BeanUtils 工具
利用内省操作 JavaBean 的属性: import java.beans.BeanInfo; import java.beans.Introspector; import java.beans.PropertyDescriptor; import ng.reflect.Method; import org.junit.Test; public class PersonTest{ /* * 通常都是站在反射的角度来操作javaBean * * java.beans.PropertyDescriptor : 该类的一个实例代表javaBean的一个属性对,一个属性对 * 包括存和取的方法. */ // 1、普通的操作方式: @Test public void test_01(){ Person p = new Person(); String name = p.getName(); int age = p.getAge(); sop(name + "..." + age); p.setAge(20); p.setName("张三"); sop(p.getName() + "..." + p.getAge()); } // 2、第一种内省方式 :利用PropertyDescritor获取javaBean @Test public void test_02() throws Exception {
// 1) 获取Person的字节码对象 Class clazz = Class.forName("cn.itcast.java.introspector.Person"); // 2) 获取Person类的name属性描述器,即表示setName()和getName()这两个方法: PropertyDescriptor pd = new PropertyDescriptor("name", clazz); // 3) 获取name属性对应的存取方法: Method readMethod = pd.getReadMethod(); Method writeMethod = pd.getWriteMethod();
import java.text.SimpleDateFormat; import java.util.Date; import mons.beanutils.BeanUtils; import mons.beanutils.ConvertUtils; import mons.beanutils.Converter; import mons.beanutils.locale.converters.DateLocaleConverter; import org.junit.Test; /* * beanutils工具包的常用类: * * * * * 掌握: 1)内置转换器; * * */ public class Test_BeanUtils { @Test public void test() throws Exception{ // 此时Person类中增加一个id的属性并生成存储方法,主要是为了测试! Class clazz = Class.forName("cn.itcast.java.introspector.Person"); Object obj = clazz.newInstance(); // 1) 通过BeanUtils工具为Person对象的属性设置值: BeanUtils.setProperty(obj, "age", 20); BeanUtils.setProperty(obj, "id", "2008"); // id的类型是int,这里传入的值一个String类型的值 2)自定义转换器 BeanUtils ConvertUtils.register(Converter convert, Class clazz)
BeanUtils.setProperty(obj, "name", "李四"); // 2) 能过BeanUtils工具为Person对象的属性取值: String name = BeanUtils.getProperty(obj, "name"); int age = Integer.parseInt(BeanUtils.getProperty(obj, "age")); int id = Integer.parseInt(BeanUtils.getProperty(obj, "id")); System.out.println(name + "..." + age + "..." + id); // 李四...20...2008
/* // 1) 给BeanUtils工具提前注册一个自定义的转换器,该转换器能将String转成java.util.Date类型 ConvertUtils.register(new Converter(){ public Object convert(Class type, Object value){ // 通过匿名内部类实现Convert接口中的方法 // 参数一:type表示java.util.Date.class // 参数二:value表示"2012-03-29" // 基本的安全判断 if(type != null && value != null && type == java.util.Date.class ){ if(value instanceof String){ try { SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); // String ---> Date Date date = sdf.parse((String)value); return date; } catch( Exception e ){ }