精华内容
参与话题
问答
  • 实体类转换

    2017-09-19 14:50:16
    转集合实体类 JSONObject obj = new JSONObject(json); JSONObject list = obj.optJSONObject("list"); List logBeanList = com.alibaba.fastjson.JSONObject.parseArray(list.optJSONArray("lottery_log...

    转集合实体类

    JSONObject obj = new JSONObject(json);

    JSONObject list = obj.optJSONObject("list");

    List<BonusPoolEntity.ListBean.LotteryLogBean> logBeanList = com.alibaba.fastjson.JSONObject.parseArray(list.optJSONArray("lottery_log").toString(),BonusPoolEntity.ListBean.LotteryLogBean.class);
    


    HashMap 转实体类

    private void initNews(BaseViewHolder baseViewHolder, final HashMap<String, Object> stringObjectHashMap) {
        final MoreSectionDatasBean.NewsSectionDatasBean newsSectionDatasBean=
                JSONObject.parseObject(JSON.toJSONString(stringObjectHashMap),MoreSectionDatasBean.NewsSectionDatasBean.class);
    }

    展开全文
  • c#实体类转换

    2019-01-07 21:20:59
    实用的.net实体类转换,在项目中稳定长期的使用,好用分享给大家!
  • 实体类转换Map Map转换实体类

    千次阅读 2018-04-23 14:10:43
    public class JavaBeanUtil { private static Logger logger = LoggerFactory.getLogger(JavaBeanUtil.class); /** * 实体类转map * @param obj * @return */ public static Map&lt;String, Ob...
    1. public class JavaBeanUtil {
    2.     private static Logger logger = LoggerFactory.getLogger(JavaBeanUtil.class);


    3.     /**
    4.      * 实体类转map
    5.      * @param obj
    6.      * @return
    7.      */
    8.     public static Map<String, Object> convertBeanToMap(Object obj) {
    9.         if (obj == null) {
    10.             return null;
    11.         }
    12.         Map<String, Object> map = new HashMap<String, Object>();
    13.         try {
    14.             BeanInfo beanInfo = Introspector.getBeanInfo(obj.getClass());
    15.             PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
    16.             for (PropertyDescriptor property : propertyDescriptors) {
    17.                 String key = property.getName();
    18.                 // 过滤class属性
    19.                 if (!key.equals("class")) {
    20.                     // 得到property对应的getter方法
    21.                     Method getter = property.getReadMethod();
    22.                     Object value = getter.invoke(obj);
    23.                     if(null==value){
    24.                         map.put(key,"");
    25.                     }else{
    26.                         map.put(key,value);
    27.                     }
    28.                 }


    29.             }
    30.         } catch (Exception e) {
    31.             logger.error("convertBean2Map Error {}" ,e);
    32.         }
    33.         return map;
    34.     }


    35.     /**
    36.      * map 转实体类
    37.      * @param clazz
    38.      * @param map
    39.      * @param <T>
    40.      * @return
    41.      */
    42.     public static <T> T convertMapToBean(Class<T> clazz, Map<String,Object> map) {
    43.         T obj = null;
    44.         try {
    45.             BeanInfo beanInfo = Introspector.getBeanInfo(clazz);
    46.             obj = clazz.newInstance(); // 创建 JavaBean 对象


    47.             // 给 JavaBean 对象的属性赋值
    48.             PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
    49.             for (int i = 0; i < propertyDescriptors.length; i++) {
    50.                 PropertyDescriptor descriptor = propertyDescriptors[i];
    51.                 String propertyName = descriptor.getName();
    52.                 if (map.containsKey(propertyName)) {
    53.                     // 下面一句可以 try 起来,这样当一个属性赋值失败的时候就不会影响其他属性赋值。
    54.                     Object value = map.get(propertyName);
    55.                     if ("".equals(value)) {
    56.                         value = null;
    57.                     }
    58.                     Object[] args = new Object[1];
    59.                     args[0] = value;
    60.                     descriptor.getWriteMethod().invoke(obj, args);


    61.                 }
    62.             }
    63.         } catch (IllegalAccessException e) {
    64.             logger.error("convertMapToBean 实例化JavaBean失败 Error{}" ,e);
    65.         } catch (IntrospectionException e) {
    66.             logger.error("convertMapToBean 分析类属性失败 Error{}" ,e);
    67.         } catch (IllegalArgumentException e) {
    68.             logger.error("convertMapToBean 映射错误 Error{}" ,e);
    69.         } catch (InstantiationException e) {
    70.             logger.error("convertMapToBean 实例化 JavaBean 失败 Error{}" ,e);
    71.         }catch (InvocationTargetException e){
    72.             logger.error("convertMapToBean字段映射失败 Error{}" ,e);
    73.         }catch (Exception e){
    74.             logger.error("convertMapToBean Error{}" ,e);
    75.         }
    76.         return (T) obj;
    77.     }


    78. }
    展开全文
  • package ...import java.beans.BeanInfo;import java.beans.IntrospectionException;import java.beans.Introspector;import java.beans.PropertyDescriptor;import java.lang.reflect.Field;import...
    package com.ruiguang.tools;


    import java.beans.BeanInfo;
    import java.beans.IntrospectionException;
    import java.beans.Introspector;
    import java.beans.PropertyDescriptor;
    import java.lang.reflect.Field;
    import java.lang.reflect.InvocationTargetException;
    import java.lang.reflect.Method;
    import java.lang.reflect.Modifier;
    import java.util.Date;
    import java.util.HashMap;
    import java.util.Map;


    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;


    public class JavaBeanUtil {
    private static Logger logger = LoggerFactory.getLogger(JavaBeanUtil.class);




        /**
         * 实体类转map
         * @param obj
         * @return
         */
        public static Map<String, Object> convertBeanToMap(Object obj) {
            if (obj == null) {
                return null;
            }
            Map<String, Object> map = new HashMap<String, Object>();
            try {
                BeanInfo beanInfo = Introspector.getBeanInfo(obj.getClass());
                PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
                for (PropertyDescriptor property : propertyDescriptors) {
                    String key = property.getName();
                    // 过滤class属性
                    if (!key.equals("class")) {
                        // 得到property对应的getter方法
                        Method getter = property.getReadMethod();
                        Object value = getter.invoke(obj);
                        if(null==value){
                            map.put(key,"");
                        }else{
                            map.put(key,value);
                        }
                    }




                }
            } catch (Exception e) {
                logger.error("convertBean2Map Error {}" ,e);
            }
            return map;
        }




        /**
         * map 转实体类
         * @param clazz
         * @param map
         * @param <T>
         * @return
         */
        public static <T> T convertMapToBean(Class<T> clazz, Map<String,Object> map) {
            T obj = null;
            try {
                BeanInfo beanInfo = Introspector.getBeanInfo(clazz);
                obj = clazz.newInstance(); // 创建 JavaBean 对象




                // 给 JavaBean 对象的属性赋值
                PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
                for (int i = 0; i < propertyDescriptors.length; i++) {
                    PropertyDescriptor descriptor = propertyDescriptors[i];
                    String propertyName = descriptor.getName();
                    if (map.containsKey(propertyName)) {
                        // 下面一句可以 try 起来,这样当一个属性赋值失败的时候就不会影响其他属性赋值。
                        Object value = map.get(propertyName);
                        if ("".equals(value)) {
                            value = null;
                        }
                        Object[] args = new Object[1];
                        args[0] = value;
                        descriptor.getWriteMethod().invoke(obj, args);




                    }
                }
            } catch (IllegalAccessException e) {
                logger.error("convertMapToBean 实例化JavaBean失败 Error{}" ,e);
            } catch (IntrospectionException e) {
                logger.error("convertMapToBean 分析类属性失败 Error{}" ,e);
            } catch (IllegalArgumentException e) {
                logger.error("convertMapToBean 映射错误 Error{}" ,e);
            } catch (InstantiationException e) {
                logger.error("convertMapToBean 实例化 JavaBean 失败 Error{}" ,e);
            }catch (InvocationTargetException e){
                logger.error("convertMapToBean字段映射失败 Error{}" ,e);
            }catch (Exception e){
                logger.error("convertMapToBean Error{}" ,e);
            }
            return (T) obj;
        }
        //将map通过反射转化为实体
        public static   Object MapToModel(Map<String,Object> map,Object o) throws Exception{
            if (!map.isEmpty()) {
                for (String k : map.keySet()) {
                    Object v =null;
                    if (!k.isEmpty()) {
                        v = map.get(k);
                    }
                    Field[] fields = null;
                    fields = o.getClass().getDeclaredFields();
                    String clzName = o.getClass().getSimpleName();
                    for (Field field : fields) {
                        int mod = field.getModifiers();


                        if (field.getName().toUpperCase().equals(k.toUpperCase())) {
                            field.setAccessible(true);


                            //region--进行类型判断
                              String type=field.getType().toString();
                              if (type.endsWith("String")){
                                  if (v!=null){
                                      v=v.toString();
                                  }else {
                                      v="";
                                  }
                              }
                            if (type.endsWith("Date")){
                                v=new Date(v.toString());
                            }
                            if (type.endsWith("Boolean")){


                               v=Boolean.getBoolean(v.toString());
                            }
                            if (type.endsWith("int")){


                                v=new Integer(v.toString());
                            }
                            if (type.endsWith("Long")){


                                v=new Long(v.toString());
                            }






                            //endregion
                            field.set(o, v);


                        }


                    }


                }
            }
            return o;
        }
        /**
         * 实体对象转成Map
         * @param obj 实体对象
         * @return
         */
        public static Map<String, Object> object2Map(Object obj) {
            Map<String, Object> map = new HashMap<>();
            if (obj == null) {
                return map;
            }
            Class clazz = obj.getClass();
            Field[] fields = clazz.getDeclaredFields();
            try {
                for (Field field : fields) {
                    field.setAccessible(true);
                    map.put(field.getName(), field.get(obj));
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
            return map;
        }
        /**
         * Map转成实体对象
         * @param map map实体对象包含属性
         * @param clazz 实体对象类型
         * @return
         */
        public static Object map2Object(Map<String, Object> map, Class<?> clazz) {
            if (map == null) {
                return null;
            }
            Object obj = null;
            try {
                obj = clazz.newInstance();




                Field[] fields = obj.getClass().getDeclaredFields();
                for (Field field : fields) {
                    int mod = field.getModifiers();
                    if (Modifier.isStatic(mod) || Modifier.isFinal(mod)) {
                        continue;
                    }
                    field.setAccessible(true);
                    field.set(obj, map.get(field.getName()));
                }
            } catch (Exception e) {
                e.printStackTrace();
            } 
            return obj;
        }
        
        public static void main(String[] args) {
        // TODO Auto-generated method stub
        /*Student s = new Student();
              s.setUserName("ZHH");
              s.setAge("24");
              System.out.println(object2Map(s));




              Map<String, Object> map = new HashMap<>();
              map.put("userName", "zhh");
              map.put("age", "24");
              System.out.println(map2Object(map, Student.class));*/
        }
        


    }
    展开全文
  • xml与实体类转换工具

    2020-09-28 14:14:31
    XML与实体类的相互转换工具,util是工具类,MyTest包含实体类转xml字符串以及XML字符串转实体类的方法,需要引入外部依赖或jar包,亲测可用
  • JAVABean public class User { private Integer userid; private String username; private String password; private String address;... private String email;... private String head_portrait;...

    JAVABean

    
    public class User {
    	private Integer userid;
    	private String username;
    	private String password;
    	private String address;
    	private String email;
    	private String head_portrait;
    	private String Phone;
    
    	public User(Integer userid, String username, String password, String address, String email, String head_portrait,
    			String phone) {
    		super();
    		this.userid = userid;
    		this.username = username;
    		this.password = password;
    		this.address = address;
    		this.email = email;
    		this.head_portrait = head_portrait;
    		Phone = phone;
    	}
    
    	public User() {
    		super();
    	}
    
    	public Integer getUserid() {
    		return userid;
    	}
    
    	public void setUserid(Integer userid) {
    		this.userid = userid;
    	}
    
    	public String getUsername() {
    		return username;
    	}
    
    	public void setUsername(String username) {
    		this.username = username;
    	}
    
    	public String getPassword() {
    		return password;
    	}
    
    	public void setPassword(String password) {
    		this.password = password;
    	}
    
    	public String getAddress() {
    		return address;
    	}
    
    	public void setAddress(String address) {
    		this.address = address;
    	}
    
    	public String getEmail() {
    		return email;
    	}
    
    	public void setEmail(String email) {
    		this.email = email;
    	}
    
    	public String getHead_portrait() {
    		return head_portrait;
    	}
    
    	public void setHead_portrait(String head_portrait) {
    		this.head_portrait = head_portrait;
    	}
    
    	public String getPhone() {
    		return Phone;
    	}
    
    	public void setPhone(String phone) {
    		Phone = phone;
    	}
    
    	@Override
    	public String toString() {
    		return "{\"userid\":\"" + userid + "\", \"username\":\"" + username + "\", \"password\":\"" + password
    				+ "\", \"address\":\"" + address + "\", \"email\":\"" + email + "\", \"head_portrait\":\""
    				+ head_portrait + "\", \"Phone\":\"" + Phone + "\"}";
    	}
    
    	
    
    }
    
    

    Controller层

    import java.io.IOException;
    import javax.servlet.ServletException;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.RequestBody;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RequestMethod;
    
    import com.alibaba.fastjson.JSON;
    import com.alibaba.fastjson.JSONObject;
    import com.ds.digitalshop.entity.User;
    @Controller
    public class TestJson {
    	
    	@RequestMapping(value="testjson", method = RequestMethod.POST)
    	public void testjson(HttpServletRequest request,HttpServletResponse response,@RequestBody String json)throws IOException,ServletException{
    		request.setCharacterEncoding("utf-8");
    		response.setCharacterEncoding("utf-8");
    		response.setContentType("text/html;charset=utf-8");
    		System.out.println("原始数据==========" + json);
    		// 转化为User实体类
    		User user=JSON.parseObject(json,User.class);
    		System.out.println("转换为teacher实体类==========" + user.toString());
    		//Java对象转换成JSON字符串
    		response.getWriter().write(JSONObject.toJSONString(user));
    	}
    }
    

    JSP代码

    <%@ page language="java" contentType="text/html; charset=utf-8"
    	pageEncoding="utf-8"%>
    <!DOCTYPE html>
    <html>
    <head>
    <meta charset="utf-8">
    <title>JSON测试</title>
    <script src="https://code.jquery.com/jquery-3.2.1.min.js"></script>
    <script type="text/javascript">
    
    
    
    
    function SendJson() {
        //将数据转换为JSON串
    	var obj = JSON.stringify({"userid":2,"username":"张三","password":"123","address":"广西南宁","email":"939296345@qq.com","head_portrait":"1null","phone":"18376680552"});
    	$.ajax({
    	    url:"testjson", //请求的url地址
    	    dataType:"text", //返回格式为json
    	    async:true,//请求是否异步,默认为异步,这也是ajax重要特性
    	    data:obj, //参数值
    	    type:"POST", //请求方式
    	    contentType: 'application/json;charset=utf-8',
    	    success:function(data){
    	    	//获取响应内容
    			//获取元素对象	处理响应内容
    			 console.log("数据对象:"+data); 
    	    	alert(data)
    	    }
    	});
    }
    
    
    </script>
    
    </style>
    </head>
    <body>
    	<h3>欢迎光临</h3>
    	<hr>
    	<input type="button" value="发送json数据测试" onclick="SendJson()" />
    	<hr>
    	
    </body>
    </html>
    

    原生ajax的创建及其状态码

    在这里插入图片描述

    状态码
    在这里插入图片描述

    展开全文
  • sqlserver数据库中的表通过hibernate反射生成的的实体类, 通过代码生成oracle数据库的表
  • C#下支持一行代码将实体类转换为JSON字符串,https://blog.csdn.net/simoral/article/details/80625654
  • Bean实体类转换

    千次阅读 2019-06-15 20:54:48
    Bean实体类转换 对象copy工具有很多,像dozer,orika等等。项目中对接搜索商品接口,原先是对接的是第三方平台的选单网,后面发现搜索类别实在太少了,只有一种like模糊搜索,后来打算用维易接口,搜索种类相对丰富...
  • 1.获取 internal CisEntities GetPatList(string wardCode, mHealth.Generic.Database.Helper.IDatabase dbHelper) { var sql = new StringBuilder(); ...
  • 在springboot中发起post请求时,需要参数集合,一般参数为我们的实体类中的属性,可以简化业务代码,不用一个一个传参数
  • 实体类转换XML

    2019-09-06 13:30:13
    package com.example.springboot09.com.test; import ... import org.apache.commons.lang.StringUtils; ...import javax.xml.bind.JAXBContext;...import javax.xml.bind.JAXB...
  • java实体类转换

    2020-10-26 16:18:37
    public static T sourceToTarget(Object source, Class target) { if (source == null) { return null; } else { Object targetObject = null; try { targetObject = target.newInstance(); BeanUtils....
  • using System;  using System.Collections;  using System.Configuration;  using System.Data;  using System.Linq;  using System.Web;  using System.Web.Security;  ...usin
  • usingSystem; usingSystem.Collections; usingSystem.Configuration; usingSystem.Data; usingSystem.Linq; usingSystem.Web; usingSystem.Web.Security; usingSystem.Web.UI; usin...
  • * Xml和对象转换工具 * * @author ljz * */ public class XmlUtils { /** * 对象转换为xml字符串 * * @param obj * @return */ public static String toXml(Object obj){ XStream ...
  • 实体类转换为map

    千次阅读 2018-10-17 16:06:28
    //利用反射 public static Map&lt;String, Object&gt; objectToMap(Object obj) {  Map&lt;String, Object&gt; map = new HashMap&lt;&gt;();  if (obj == null) { ... ...
  • 通过实体类转换JSON

    千次阅读 2018-02-14 22:05:00
    RootEntity ` package com.ithelei; import java.util.List; public class RootEntity { private String errorCode; private String errorMsg; ...
  • 实体类转换成SQL

    2019-11-01 13:31:24
    当需要把实体类的属性拼接成SQL的时候,可以使用下面的SQL 注意:针对的是属性而不是字段,属性需要加上{get;set;} string columns =string.Join(",", t.GetType().GetProperties().Where(w=>w.CanWrite)....
  • bean和实体类转换

    2019-08-23 10:38:59
    @Slf4j public class BeanConvertUtil { public static <T> T convertCopy(Object source, Class<T> tClass) { try { T target = tClass.newInstance(); ...
  • 主要介绍了c#的DataTable与不同结构实体类转换的方法实例,在大数据量的情况下很实用,大家可以参考使用
  • 具体转换过程如下图: 作者:jiankunking 出处:http://blog.csdn.net/jiankunking
  • 实体类转换成Map

    2020-06-15 09:20:46
    CompanyArchivesDto dto = ...//获取实体类数据 //import java.lang.reflect.Field; Field[] fields = dto.getClass().getDeclaredFields(); Map<String,Object> map = new HashMap<>(); f...
  • 实体类转换DTO的方式

    千次阅读 2018-08-21 15:36:36
    1.第一种,如果是实体类字段类型都一样,大部分会采用bean拷贝的方式,BeanUtils.copyProperties(obj,obj),单个对象的转换还好,但是List对象就要循环来转换。 2.第二种,要是遇到驼峰类型字段与下划线字段的...

空空如也

1 2 3 4 5 ... 20
收藏数 4,685
精华内容 1,874
关键字:

实体类转换