Java泛型详解 ：
http://blog.csdn.net/jinuxwu/article/details/6771121
http://www.cnblogs.com/tech-bird/p/3516325.html
http://lichaozhangobj.iteye.com/blog/476911
<? extends SomeClass>与<T extends SomeClass>的区别 ：
http://blog.csdn.net/cgf1993/article/details/50754584
instanceof 与isAssignableFrom ：
http://blog.csdn.net/kjfcpua/article/details/7045207
Java String和Date的转换：
http://www.cnblogs.com/bmbm/archive/2011/12/06/2342264.html
测试主类：
package test;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import javax.servlet.http.HttpServletRequest;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import util.JsonUtils;
/**
* 根据请求转换请求参数bean
* @author donald
* @date 2017-1-6
* @time 上午11:29:37
*/
public class RequestParamUtils {
private static final Logger log = LoggerFactory.getLogger(RequestParamUtils.class);
private static final String SET_METHOD_PREFIX = "set";
private static final String GET_METHOD_PREFIX = "get";
private static final String GETCLASS_METHOD_SUFFIX = "class";
private static SimpleDateFormat time = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
private static volatile RequestParamUtils instance = null;
public static synchronized RequestParamUtils getInstance(){
if (instance == null){
instance = new RequestParamUtils();
}
return instance;
}
/**
* 转化bean
* @param request
* @param clazz
* @return
*/
@SuppressWarnings({ "rawtypes", "unchecked" })
public <T> T getParamBean(HttpServletRequest request, Class<T> clazz) {
T bean = null;
try {
bean = clazz.newInstance();
} catch (InstantiationException e) {
log.error("==========请求参数模型实例化错误");
e.printStackTrace();
} catch (IllegalAccessException e) {
log.error("==========无法访问参数模型构造函数");
e.printStackTrace();
}
Method[] allGetMethodList = clazz.getMethods();
for(Method m : allGetMethodList){
if(m.getName().startsWith(GET_METHOD_PREFIX)){
if(isHaveGetProperties(clazz,m)){
log.debug("========Get Method Name:"+m.getName());
String setMethodName = SET_METHOD_PREFIX + m.getName().substring(3,m.getName().length());
log.debug("========set Method Name:"+setMethodName);
Class type = getPropertiesType(clazz,m);
if(type != null){
try {
Method setM = clazz.getMethod(setMethodName, type);
String fieldName = getMethodProperty(m);
String mProperty = request.getParameter(fieldName);
Object mobj = null;
if(mProperty != null)
mobj = ConvertStringToObject(mProperty,type);
try {
if(mobj != null)
setM.invoke(bean, mobj);
} catch (IllegalArgumentException e) {
log.error("==========参数异常");
e.printStackTrace();
} catch (IllegalAccessException e) {
log.error("==========非法访问");
e.printStackTrace();
} catch (InvocationTargetException e) {
log.error("==========目标调用异常");
e.printStackTrace();
}
} catch (SecurityException e) {
log.error("==========无访问权限");
e.printStackTrace();
} catch (NoSuchMethodException e) {
log.error("==========类中没有对应的方法:"+setMethodName);
e.printStackTrace();
}
}
}
}
}
return (T)bean;
}
/**
* 从Map转换bean
* @param params
* @param clazz
* @return
*/
@SuppressWarnings("rawtypes")
public <T> T getParamBeanFromMap(Map<String,Object> params, Class<T> clazz) {
T bean = null;
try {
bean = clazz.newInstance();
} catch (InstantiationException e) {
log.error("==========请求参数模型实例化错误");
e.printStackTrace();
} catch (IllegalAccessException e) {
log.error("==========无法访问参数模型构造函数");
e.printStackTrace();
}
Method[] allGetMethodList = clazz.getMethods();
for(Method m : allGetMethodList){
if(m.getName().startsWith(GET_METHOD_PREFIX)){
if(isHaveGetProperties(clazz,m)){
log.debug("========Get Method Name:"+m.getName());
String setMethodName = SET_METHOD_PREFIX + m.getName().substring(3,m.getName().length());
log.debug("========set Method Name:"+setMethodName);
Class type = getPropertiesType(clazz,m);
if(type != null){
try {
Method setM = clazz.getMethod(setMethodName, type);
String fieldName = getMethodProperty(m);
Object mProperty = params.get(fieldName);
try {
if(mProperty != null)
setM.invoke(bean, mProperty);
} catch (IllegalArgumentException e) {
log.error("==========参数异常");
e.printStackTrace();
} catch (IllegalAccessException e) {
log.error("==========非法访问");
e.printStackTrace();
} catch (InvocationTargetException e) {
log.error("==========目标调用异常");
e.printStackTrace();
}
} catch (SecurityException e) {
log.error("==========无访问权限");
e.printStackTrace();
} catch (NoSuchMethodException e) {
log.error("==========类中没有对应的方法:"+setMethodName);
e.printStackTrace();
}
}
}
}
}
return (T)bean;
}
/**
* clazz 是否存在m对应的属性
* @param clazz
* @param m
* @return
*/
private boolean isHaveGetProperties(Class<?> clazz,Method m){
boolean flag = false;
String fieldName = getMethodProperty(m);
log.debug("=========Get Method Field Name:"+fieldName);
try {
if(!fieldName.equals(GETCLASS_METHOD_SUFFIX)&&!m.isAnnotationPresent(Transient.class)){
if(clazz.getDeclaredField(fieldName)!= null)
flag = true;
}
} catch (SecurityException e) {
log.error("==========无访问权限");
e.printStackTrace();
} catch (NoSuchFieldException e) {
log.error("==========类中没有对应的方法属性:"+fieldName);
e.printStackTrace();
}
return flag;
}
/**
* 获取m方法对应属性的类型
* @param clazz
* @param m
* @return
*/
@SuppressWarnings("rawtypes")
private Class getPropertiesType(Class<?> clazz,Method m){
Class type = null;
String fieldName = getMethodProperty(m);
try {
if(!fieldName.equals(GETCLASS_METHOD_SUFFIX)){
Field f = clazz.getDeclaredField(fieldName);
type = f.getType();
log.debug(fieldName+" Type:"+type.toString());
}
} catch (SecurityException e) {
log.error("==========无访问权限");
e.printStackTrace();
} catch (NoSuchFieldException e) {
log.error("==========类中没有对应的方法属性:"+fieldName);
e.printStackTrace();
}
return type;
}
/**
* 获取方法属性名
* @param m
* @return
*/
private String getMethodProperty(Method m){
String fieldName = m.getName().substring(3,m.getName().length());
fieldName = fieldName.substring(0, 1).toLowerCase()+fieldName.substring(1, fieldName.length());
return fieldName;
}
/**
*
* @param param
* @param type
* @return
*/
@SuppressWarnings("unchecked")
private <T> T ConvertStringToType (String param,Class<T> type){
T obj =null;
obj = (T) param;
return obj;
}
/**
* 转化类型
* @param param
* @param type
* @return
*/
@SuppressWarnings({ "deprecation"})
private Object ConvertStringToObject(String param,Class<?> type){
Object obj =null;
if(type.isAssignableFrom(String.class)){
obj = String.valueOf(param);
}
if(type.isAssignableFrom(Integer.class)){
obj = Integer.valueOf(param);
}
if(type.isAssignableFrom(Double.class)){
obj = Double.valueOf(param);
}
if(type.isAssignableFrom(Date.class)){
try {
obj = time.parse(param);
} catch (ParseException e) {
log.error("=========时间日期解析异常");
e.printStackTrace();
}
}
return obj;
}
@SuppressWarnings({ "unchecked", "rawtypes" })
public static void main(String[] args) {
//从map转换bean
Map params = new HashMap<String, Object>();
params.put("userName", "donald");
params.put("userAge", 20);
params.put("borth", new Date());
params.put("weight", 56.3);
Param pm = new Param();
pm = RequestParamUtils.getInstance().getParamBeanFromMap(params,Param.class);
log.info("======result："+JsonUtils.toJson(pm));
//测试类型转换方法ConvertStringToType，这种强制转化的参数设置方式，容易出现参数异常
String ss = "user";
String it = "2";
String du = "50.36";
String date = "2016-10-23 12:05:56";
// Object obj = RequestParamUtils.getInstance().ConvertStringToType(ss, String.class);
/*log.info("String:"+RequestParamUtils.getInstance().ConvertStringToType(ss, String.class));
log.info("it:"+RequestParamUtils.getInstance().ConvertStringToType(it, Integer.class));
log.info("du:"+RequestParamUtils.getInstance().ConvertStringToType(du, Double.class));
log.info("date:"+RequestParamUtils.getInstance().ConvertStringToType(date, java.util.Date.class));*/
//测试类型转换方法ConvertStringToObject，尽量用这种方式，obj实际为Class<?> type
Object obj = RequestParamUtils.getInstance().ConvertStringToObject(ss, String.class);
log.info("String:"+RequestParamUtils.getInstance().ConvertStringToObject(ss, String.class));
log.info("it:"+RequestParamUtils.getInstance().ConvertStringToObject(it, Integer.class));
log.info("du:"+RequestParamUtils.getInstance().ConvertStringToObject(du, Double.class));
log.info("date:"+RequestParamUtils.getInstance().ConvertStringToObject(date, java.util.Date.class));
}
}
实体类：
package test;
import java.io.Serializable;
import java.util.Date;
public class Param implements Serializable{
/**
*
*/
private static final long serialVersionUID = 7834236561543851887L;
private String userName;
private Integer userAge;
private Date borth;
private Double weight;
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public Integer getUserAge() {
return userAge;
}
public void setUserAge(Integer userAge) {
this.userAge = userAge;
}
public Date getBorth() {
return borth;
}
public void setBorth(Date borth) {
this.borth = borth;
}
public Double getWeight() {
return weight;
}
public void setWeight(Double weight) {
this.weight = weight;
}
}
控制台输出：
2017-1-6 16:28:11 test.RequestParamUtils main
信息: ======result：{"weight":56.3,"userName":"donald","userAge":20,"borth":{"time":1483691291811,"minutes":28,"seconds":11,"hours":16,"month":0,"year":117,"timezoneOffset":-480,"day":5,"date":6}}
2017-1-6 16:28:11 test.RequestParamUtils main
信息: String:user
2017-1-6 16:28:11 test.RequestParamUtils main
信息: it:2
2017-1-6 16:28:11 test.RequestParamUtils main
信息: du:50.36
2017-1-6 16:28:11 test.RequestParamUtils main
信息: date:Sun Oct 23 12:05:56 CST 2016
分享到：
相关推荐
在Java开发中，数据结构的转换是常见的任务之一，特别是在处理来自数据库的查询结果或接收HTTP请求时。Map和Bean之间的转换就是这类场景的一个典型例子。`MapUtils`和`BeanUtils`这样的工具类能够帮助我们高效且灵活...
在Java编程中，Map到Bean的转换是一种常见的数据处理需求，特别是在处理来自数据库查询结果、HTTP请求参数等场景。这个过程通常涉及到Java反射机制和JavaBeans包中的工具类。下面我们将详细探讨如何实现这一转换，并...
OkHttpUtils提供了一系列静态方法，如`get()`, `post()`等，用于发起HTTP请求。这些方法接收一个URL字符串和一个`OkCallback`对象作为参数，`OkCallback`用于处理请求的响应结果。 1. **OkHttpUtils的Bean封装**： ...
通常，一个HTTP请求工具类会包含以下方法： 1. `sendGet(String url, Map, String> params)`: 这个方法用于发送GET请求。URL参数可以直接拼接在URL后面，或者通过HttpURLConnection的setRequestProperty方法设置...
在这个场景下，Bean类是模型，JSP页面是视图，而处理HTTP请求的部分可能是控制器。 7. **工具支持**：有一些工具和库，如Apache Velocity或FreeMarker，可以帮助动态生成HTML页面。此外，IDE如Eclipse或IntelliJ ...
为了实现HTTP请求数据到DAO的映射，你需要创建相应的Java对象，然后在Controller层解析请求数据，将其转换为Java对象。接着，Service层调用DAO方法，将这些对象作为参数传递，最后由DAO执行SQL操作。 总的来说，...
博客中提到的工具可能是指一些图形化界面工具，例如Postman，它允许开发者发送HTTP请求并接收JSON响应。在Postman中，可以直接将JSON响应转换为Java Bean的代码片段，这对于快速开发和测试非常方便。 总的来说，将...
3. 准备数据源：可以是来自HTTP请求的数据，如Servlet的请求参数，或者是其他任何形式的数据结构，如Map。 4. 使用`BeanUtilities`填充Bean：通过`BeanUtilities.copyProperties()`方法，将数据源中的键值对映射到...
在处理HTTP请求方面，SpringBoot利用了Spring MVC的机制，其中包括`DispatcherServlet`、`RequestMappingHandlerAdapter`等多个核心组件。下面将详细解析这些关键组件的工作原理。 1. **DispatcherServlet**：这是...
这些转换器是Spring MVC的一部分，用于处理HTTP请求和响应中的JSON数据。 ```java import org.springframework.http.converter.json.GsonHttpMessageConverter; List<PersonBean> personList = new ArrayList(); /...
总的来说，JavaBean与Web Form表单的自动装配是通过解析HTTP请求参数，匹配Bean属性，以及调用setter方法完成数据绑定的过程。这种技术在减少代码冗余，提高开发效率方面起到了重要作用。在没有框架支持的情况下，...
- `@RequestBody`：将HTTP请求体中的数据转换为Java对象。 - `@ResponseBody`：将方法的返回值转换为HTTP响应体。 4. **分层架构**： - 分层架构包括表现层（Web层）、业务逻辑层（Service层）、数据访问层（DAO...
在Spring框架中，拦截器（Interceptor）是一种强大的工具，它允许开发者在请求处理前后执行自定义逻辑，例如日志记录、权限检查等。Spring MVC中的拦截器是基于AOP（面向切面编程）原理实现的，可以理解为对...
这对于大型Web应用来说，可以有效减少HTTP请求，提升页面性能。 4. **版本控制与缓存**：通过使用CSS Bean，开发者可以轻松地实现CSS版本控制，确保用户始终获取最新的样式更新。同时，库还支持缓存机制，减少不必...
在Spring+CXF的环境中，XML请求通常是通过Java对象转换得到的。CXF提供了JAXB（Java Architecture for XML Binding）支持，可以将Java对象自动转换为XML，反之亦然。因此，调用Web服务方法时，传入Java对象，CXF会...
1. **参数映射（Parameter Mapping）**：将HTTP请求参数（如POST请求体或URL查询参数）映射到Java Bean对象上，方便进一步的业务处理。 2. **验证和数据绑定（Validation and Data Binding）**：可以配合Java的校验...
由于HTTP请求的参数默认为字符串，因此在将这些日期字符串转化为日期对象时，我们需要进行转换。 三、自动转化机制 1. 使用Struts的`PropertyEditors`：Struts提供了一套自定义属性编辑器（PropertyEditor）机制，...
Apache Commons BeanUtils库提供了`BeanUtils.copyProperties()`方法实现Bean到Bean的转换，而Map到Bean的转换可以借助`Dozer`或`ModelMapper`库。这些工具可以帮助我们在数据绑定和对象映射中节省大量工作。 4. **...
`RestTemplate`是Spring提供的一种简单易用的HTTP客户端工具，用于发起HTTP请求并与REST服务进行交互。本文将深入探讨`RestTemplate`的使用方法，以及如何在实际项目中有效地利用它。 首先，`RestTemplate`是Spring...
在Java世界中，`RestTemplate`是Spring框架提供的一种用于执行HTTP请求的工具，它使得与RESTful服务的交互变得更加简单。这篇博客“RestTemplate例子”可能是介绍如何使用`RestTemplate`进行RESTful API调用的实践...