精华内容
下载资源
问答
  • javabean和json的常用转换解析

    千次阅读 2015-12-19 10:44:01
    首先简单说一下几个json技术的简介:  1 json-lib和Jackson ...jackson相当于json-lib简单易用,由于是开源框架,社区活跃,更新速度也可以,但是对于一些list和map容易出问题,复杂的javabean
         首先简单说一下几个json技术的简介:

       1 json-lib和Jackson

       这两种都是比较早期的json技术,json-lib已经没有多少人使用,作为最早的json技术,依赖包太多,在当前开发中功能和性能都已不能满足开发需求。jackson相当于json-lib简单易用,由于是开源框架,社区活跃,更新速度也可以,但是对于一些list和map容易出问题,复杂的javabean也不能生成标准的json格式,所以也不常用。

      2 谷歌GSON

        Gson是目前功能最全的Json解析神器,Gson当初是为因应Google公司内部需求而由Google自行研发而来。Gson的应用主要为toJson与fromJson两个转换函数,无依赖,不需要例外额外的jar,能够直接跑在JDK上。Gson在功能上面无可挑剔,但是性能上面比FastJson有所差距。

     3 阿里巴巴fastjson

      Fastjson是一个Java语言编写的高性能的JSON处理器,由阿里巴巴公司开发。无依赖,不需要例外额外的jar,能够直接跑在JDK上。FastJson在复杂类型的Bean转换Json上会出现一些问题,可能会出现引用的类型,导致Json转换出错,需要制定引用。FastJson采用独创的算法,将parse的速度提升到极致,超过所有json库。

      

       对于这四种json技术,基本上都是使用后两者。如果只是功能要求,没有性能要求,尽量使用google的Gson,如果有性能上面的要求可以使用Gson将bean转换json确保数据的正确,使用FastJson将Json转换Bean。


      下面是简单的代码展示:

      maven依赖:
     

                   <!-- GSON工具 -->
    		<dependency>
    			<groupId>com.google.code.gson</groupId>
    			<artifactId>gson</artifactId>
    			<version>2.2.4</version>
    		</dependency>
    		<!-- GSON工具 -->
    		<!-- 阿里巴巴fastjson -->
    		<dependency>
    			<groupId>com.alibaba</groupId>
    			<artifactId>fastjson</artifactId>
    			<version>1.2.4</version>
    		</dependency>
    		<!-- 阿里巴巴fastjson -->

     
    /**
    	 * 使用谷歌GSON工具来实现JSON和Object转换
    	 */
    	@Test
    	public void testGSON() {
    		Milk milk = new Milk();
    		milk.setName("银鹭核桃");
    		milk.setBrand("银鹭");
    		milk.setType("混合牛奶");
    		// Gson().toJson(Object)实现javaBean到json数据转换
    		String gsonString = new Gson().toJson(milk);
    		System.out.println(gsonString);
    		// Gson().fromJson(json, clazz)实现json到javaBean的转换
    		Milk milk2 = new Gson().fromJson(gsonString, Milk.class);
    		System.out.println(milk2.getName());
    	}

     /**
        * 使用阿里巴巴fastjson实现JSON和Object转换
        */
    	@Test
    	public void testFastjson(){
    		Milk milk = new Milk();
    		milk.setName("冰糖雪梨");
    		milk.setBrand("冰糖");
    		milk.setType("混合果汁");
    		//使用JSON.toJSONString(obj)方式来实现javaBean到json
    		String jsonString=JSON.toJSONString(milk);
    		System.out.println(jsonString);
    		//使用JSON.parseObject(jsonString, clazz)可以将json数据转换成相应的javabean,可以是实体类,也可以是List,Map等集合类
    		Milk milk2=JSON.parseObject(jsonString, Milk.class);
    		System.out.println(milk2.getName());
    	}
       详细代码请参照github:https://github.com/LiuJishuai/javaCore/blob/master/src/com/basic_grammar/JsonTrans.java

        部分简介参考http://www.cnblogs.com/kunpengit/p/4001680.html

    展开全文
  • ●使用Lombok装点你的JavaBean ●Lombok的其他常用特性 ●小结 ●什么是JavaBean 对于JavaBean,简单的理解就是一个具备下面三个条件的Java类: 1、拥有一个或多个private修饰的成员变量; 2、该类具有无参...

    目录

     

    ●什么是JavaBean

    ●什么是Lombok

    ●使用前的准备

    ●使用Lombok装点你的JavaBean

    ●Lombok的其他常用特性

    ●小结


    ●什么是JavaBean

    对于JavaBean,最简单的理解就是一个具备下面三个条件的Java类:

    1、拥有一个或多个private修饰的成员变量;

    2、该类具有无参构造函数;

    3、每个成员变量都有get和set方法。

    通常在我们的代码或者说项目中,JavaBean的表现形式主要是各种DO、DTO等,例如:ORM的数据库表单对象、用于前后端传输的对象等。

     

    ●什么是Lombok

    Lombok是一个第三方Java库,它的主要作用是通过注解的形式,减少代码中的一些固定/模板化的代码,例如set、get、equal等方法;同时,它还具备日志的相关特性。

    Lombok遵守MIT开源协议,是一个商业友好的Java库。其Github地址和官方门户如下:

    https://github.com/rzwitserloot/lombok

    https://www.projectlombok.org/

    最初想到使用Lombok是因为学习建造者(Builder)模式时,发现自己去写模板代码有点麻烦,网上找了找发现Lombok可以解决,遂研究了一番。

     

    ●使用前的准备

    笔者使用IDEA,配合Maven项目为例,介绍下使用Lombok前需要做的两件事——

    1、在IDE中添加Lombok插件,目的是消除语法告警:

    首先在IDEA中搜索安装Lombok Plugin

    如果无法在软件内在线安装,可以去IDEA插件网站http://plugins.jetbrains.com/下载对应版本的插件,从本地进行离线安装(Install plugin from disk)

    重启下IDEA,插件安装成功生效

     

    2、在项目中引入Lombok的jar包:

    在maven官方仓或者阿里仓搜索Project Lombok,选择合适的版本,将依赖填入项目中的pom文件

     

    ●使用Lombok装点你的JavaBean

    Lombok最简单的用法,是在JavaBean中取代set、get方法。只需要在类的成员变量中加上注解@Setter和@Getter就可以了。你以下三种写法都是可以的,笔者喜欢第二种,美观:

    //写法1
    @Getter
    @Setter
    private String plateNo;
    
    //写法2
    @Getter @Setter
    private String laneName;
    
    //写法3
    @Getter @Setter private String driveway;

    也许你会说,IDEA中右键点击几下也是可以自动生成set、get方法的。没错!但是,有个问题,如果你修改了成员变量的类型,你需要手动修改相应set、get方法的入参或返回值类型,或者删掉重新生成一次。而使用注解则不会有这个问题。这是使用Lombok注解@setter、@getter的好处之一

    另外,使用注解的第二个好处也是显而易见的,能够减少代码量,直观地看出该成员变量是否拥有set、get方法。值得注意的是,如果该成员变量是boolean类型,对应的是is方法。即以变量var为例,注释后,可以使用setVar()、getVar()/isVar()方法。

    Lombok注解@setter、@getter的第三个好处是可以自由的控制成员变量的访问范围,通常,我们使用IDEA自动生成的set、get方法都是public的,当然你可以自己一个一个手动去修改。如果成员变量多了,改起来就比较麻烦。而Lombok注解@setter、@getter可以结合AccessLevel关键字限制权限,包括PUBLIC, PROTECTED, PACKAGE(对应default,即不写的情况)以及 PRIVATE四种。用法如下:

    //Lombok注解
    @Setter(AccessLevel.PROTECTED) private String name;
    
    //传统写法
    private String name;
    
    protected void setName(String name){
        this.name = name;
    }
    

     

    ●Lombok的其他常用特性

    Lombok如果只是提供@setter、@getter注解的话,那咱也没有必要特意选用它了。它还具备一些好用的注解。

    回到前面说的,在学习建造者(Builder)模式的时候,笔者发现Lombok可以化繁为简。

    我们先说说建造者模式,这是一种生成对象的设计模式,设计初衷是为了让使用者通过链式调用的方式产生对象,而不是写多行set方法设置属性:

    //非建造者模式
    People people = new People();
    people.setName("小明");
    people.setAge(15);
    people.setHobby("写代码");
    people.setTag("初级程序员");
    
    //建造者模式
    People people = People.builder().name("小明").age(15).hobby("写代码").tag("初级程序员").build();

    我们先来用正统方式实现这个建造者模式:

    public class People {
    
      private String name;
      private int age;
      private String hobby;
      private String tag;
    
      // 构造方法私有化,避免直接调用构造方法
      private People(String name, int age, String hobby, String tag) {
        this.name = name;
        this.age = age;
        this.hobby = hobby;
        this.tag = tag;
      }
    
      public static PeopleBuilder builder() {
        return new PeopleBuilder();
      }
    
      //内部类
      public static class PeopleBuilder {
    
        // 和 People 一样的成员变量
        private String name;
        private int age;
        private String hobby;
        private String tag;
    
        private PeopleBuilder() {
        }
    
        // 链式调用设置各个属性值,返回 this,即 PeopleBuilder
        public PeopleBuilder name(String name) {
          this.name = name;
          return this;
        }
    
        public PeopleBuilder hobby(String hobby) {
          this.hobby = hobby;
          return this;
        }
    
        public PeopleBuilder tag(String tag) {
          this.tag = tag;
          return this;
        }
    
        public PeopleBuilder age(int age) {
          this.age = age;
          return this;
        }
    
        // build() 方法负责将 PeopleBuilder 中设置好的属性“复制”到 People 中。
        // 也,可以在 “复制” 之前做点检验
        public People build() {
          if (name == null || tag == null) {
            throw new RuntimeException("姓名和标签不能为空");
          }
          if (age <= 0 || age >= 150) {
            throw new RuntimeException("年龄范围不正确");
          }
    
          return new People(name, age, hobby, tag);
        }
      }
    }
    

    虽然建造者模式使用起来很舒服,但是写起来其实是比较麻烦的,有很多固定套路的模板代码需要手动写。而Lombok提供了一个注解@Builder,就可以实现上述功能。只需要在类上加上这个注释,就可以直接链式调用,简直神器!

    @Builder
    public class People {
      private String name;
      private int age;
      private String hobby;
      private String tag;
    }
    
    //定义如上,用法如下
    People people = People.builder().name("小明").age(15).hobby("写代码").tag("初级程序员").build();

    最后,再给大家推荐下Lombok的日志注解。大家的项目中如果用到了日志,例如slf4j,那肯定经常看到这样的代码:

    public class myServiceImpl implements myService {
    
      private final Logger log = LoggerFactory.getLogger(myServiceImpl.class);
    
      ………………
      log.error("error data format: " + String.valueOf(arg));
      ………………
    
    }

    每一个类都需要写一遍这样的模板代码,当然,笔者之前的文章《Hutool不糊涂(一)》种介绍了一种解决方法。现在我们使用Lombok提供的日志类注解,可以更精美的解决这个问题,只需要在类上加上@Slf4j即可:

    @Slf4j
    public class myServiceImpl implements myService {
    
      ………………
      //可以直接使用这个log对象了
      log.error("error data format: " + String.valueOf(arg));
      ………………
    
    }

    除了slf4j,Lombok也提供了其他常用的日志系统的注解,如下:

    @CommonsLog
    Creates private static final org.apache.commons.logging.Log log = org.apache.commons.logging.LogFactory.getLog(LogExample.class);
    
    @Flogger
    Creates private static final com.google.common.flogger.FluentLogger log = com.google.common.flogger.FluentLogger.forEnclosingClass();
    
    @JBossLog
    Creates private static final org.jboss.logging.Logger log = org.jboss.logging.Logger.getLogger(LogExample.class);
    
    @Log
    Creates private static final java.util.logging.Logger log = java.util.logging.Logger.getLogger(LogExample.class.getName());
    
    @Log4j
    Creates private static final org.apache.log4j.Logger log = org.apache.log4j.Logger.getLogger(LogExample.class);
    
    @Log4j2
    Creates private static final org.apache.logging.log4j.Logger log = org.apache.logging.log4j.LogManager.getLogger(LogExample.class);
    
    @Slf4j
    Creates private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(LogExample.class);
    
    @XSlf4j
    Creates private static final org.slf4j.ext.XLogger log = org.slf4j.ext.XLoggerFactory.getXLogger(LogExample.class);

    ​​​​​​​

    ●小结

    本文抛砖引玉,给大家介绍下Lombok最常用的三种注解,其实Lombok还有不少注解,例如@Synchronized、@ToString、@NonNull、@Cleanup以及@Data等。一方面,网上有不少文章介绍了这几个注解,另一方面,大家也可以结合自己的需要参考官方指南或者Javadoc

    当然了,虽然Lombok开源协议商业友好,但是也并非没有缺点,对于学习者来说,使用多了注解,就和以前文字说的使用多了语法糖的后果一样,导致不会自己写设计模式了,需要在开发效率和自我提升上做一个权衡。今天,你学会了吗?

    展开全文
  • SpringMVC最常用的校验是对一个javaBean的校验,默认使用hibernate-validator校验框架。而网上对校验单个参数,譬如String,int之类的资料极少,这一篇就是讲这个的。校验JavaBeanpackage com.example.bean;import ...

    该示例项目使用SpringBoot,添加web和aop依赖。
    SpringMVC最常用的校验是对一个javaBean的校验,默认使用hibernate-validator校验框架。而网上对校验单个参数,譬如String,int之类的资料极少,这一篇就是讲这个的。

    校验JavaBean

    package com.example.bean;
    
    import org.hibernate.validator.constraints.Length;
    import org.hibernate.validator.constraints.NotEmpty;
    
    /**
     * Created by admin on 17/5/3.
     */
    public class User {
        private Long id;
    
        @NotEmpty(message = "姓名不能为空")
        private String name;
    
        @NotEmpty(message = "密码不能为空")
        @Length(min = 6, message = "密码长度不能小于6位")
        private String password;
    
        public Long getId() {
            return id;
        }
    
        public void setId(Long id) {
            this.id = id;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getPassword() {
            return password;
        }
    
        public void setPassword(String password) {
            this.password = password;
        }
    }
    

    定义了@NotEmpty等标签后,结合在Controller里使用@Valid即可完成参数的校验。

    package com.example.controller;
    
    import com.example.bean.User;
    import org.hibernate.validator.constraints.Length;
    import org.hibernate.validator.constraints.Range;
    import org.springframework.validation.BindingResult;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    import javax.validation.Valid;
    
    /**
     * Created by wuwf on 17/4/27.
     *
     */
    @RestController
    public class FirstController {
    
        @RequestMapping("/first")
        public Object first(@Valid User user, BindingResult bindingResult) {
            return "first controller";
        }
    
        @RequestMapping("/second")
        public @Length Object second(@Length(min = 6, message = "密码长度不能小于6位") String password) {
            return "second controller";
        }
    
        @RequestMapping("/third")
        public @Length Object third(@Range(min = 6, max = 10, message = "数据需要大于6小于10") int num, @Length(min = 6, message = "密码长度不能小于6位") String password) {
            return "third controller";
        }
    
        @RequestMapping("/four")
        public @Length Object four(int page) {
            return "four controller";
        }
    }
    

    譬如first方法里,只需要加上@Valid标签即可完成校验。如果校验不通过,那么错误信息就会封装到BindingResult对象了,可以通过bindingResult的相关方法获取详细的错误信息并返回给用户。
    访问:http://localhost:8080/first?name=1&password=1 debug可看到
    这里写图片描述
    如果不加BindingResult则会抛出异常。
    此时即可完成表单类,或者用户注册之类的类似请求的参数校验了,可以选择获取bindingResult信息后直接return给用户。如果这样的需要校验的地方比较多,每个都单独处理比较麻烦,可以通过aop统一处理返回,后面会讲到。
    校验的标签可参考:http://blog.csdn.net/catoop/article/details/51278675
    相关文章:http://412887952-qq-com.iteye.com/blog/2312356

    校验基本类型

    在很多场景下,我们不需要校验一个javaBean,更多的是校验单个的int,String等。也就是controller里的second和third方法。像方法中写的那样,但是直接写上去,是不起作用的,校验框架并没有去校验,我们需要做的就是让它生效。
    参考如下:https://diamondfsd.com/article/78fa12cd-b530-4a90-b438-13d5a0c4e26c
    http://blog.csdn.net/catoop/article/details/51284638
    直接上代码吧

    package com.example.aop;
    
    import org.aspectj.lang.ProceedingJoinPoint;
    import org.aspectj.lang.annotation.Around;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Pointcut;
    import org.aspectj.lang.reflect.MethodSignature;
    import org.hibernate.validator.internal.engine.path.PathImpl;
    import org.springframework.core.LocalVariableTableParameterNameDiscoverer;
    import org.springframework.core.ParameterNameDiscoverer;
    import org.springframework.stereotype.Component;
    import org.springframework.validation.BeanPropertyBindingResult;
    import org.springframework.validation.ObjectError;
    
    import javax.validation.ConstraintViolation;
    import javax.validation.Validation;
    import javax.validation.ValidatorFactory;
    import javax.validation.executable.ExecutableValidator;
    import java.lang.reflect.Method;
    import java.util.List;
    import java.util.Set;
    
    /**
     * Created by wuwf on 17/4/27.
     * 参数校验切面
     */
    @Aspect
    @Component
    public class ValidAspect {
        private ObjectError error;
    
        @Pointcut("execution(public * com.example.controller.*.*(..))")
        public void valid() {
        }
    
        //环绕通知,环绕增强,相当于MethodInterceptor
        @Around("valid()")
        public Object arround(ProceedingJoinPoint pjp) {
            System.out.println("方法环绕start.....");
            try {
                //取参数,如果没参数,那肯定不校验了
                Object[] objects = pjp.getArgs();
                if (objects.length == 0) {
                    return pjp.proceed();
                }
                /**************************校验封装好的javabean**********************/
                //寻找带BindingResult参数的方法,然后判断是否有error,如果有则是校验不通过
                for (Object object : objects) {
                    if (object instanceof BeanPropertyBindingResult) {
                        //有校验
                        BeanPropertyBindingResult result = (BeanPropertyBindingResult) object;
                        if (result.hasErrors()) {
                            List<ObjectError> list = result.getAllErrors();
                            for (ObjectError error : list) {
                                System.out.println(error.getCode() + "---" + error.getArguments() + "--" + error.getDefaultMessage());
                                //返回第一条校验失败信息。也可以拼接起来返回所有的
                                return error.getDefaultMessage();
                            }
                        }
                    }
                }
    
                /**************************校验普通参数*************************/
                //  获得切入目标对象
                Object target = pjp.getThis();
                // 获得切入的方法
                Method method = ((MethodSignature) pjp.getSignature()).getMethod();
                // 执行校验,获得校验结果
                Set<ConstraintViolation<Object>> validResult = validMethodParams(target, method, objects);
                //如果有校验不通过的
                if (!validResult.isEmpty()) {
                    String[] parameterNames = parameterNameDiscoverer.getParameterNames(method); // 获得方法的参数名称
    
                    for(ConstraintViolation<Object> constraintViolation : validResult) {
                        PathImpl pathImpl = (PathImpl) constraintViolation.getPropertyPath();  // 获得校验的参数路径信息
                        int paramIndex = pathImpl.getLeafNode().getParameterIndex(); // 获得校验的参数位置
                        String paramName = parameterNames[paramIndex];  // 获得校验的参数名称
    
                        System.out.println(paramName);
                        //校验信息
                        System.out.println(constraintViolation.getMessage());
                    }
                    //返回第一条
                    return validResult.iterator().next().getMessage();
                }
    
                return pjp.proceed();
            } catch (Throwable e) {
                e.printStackTrace();
                return null;
            }
        }
    
        private ParameterNameDiscoverer parameterNameDiscoverer = new LocalVariableTableParameterNameDiscoverer();
        private final ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
        private final ExecutableValidator validator = factory.getValidator().forExecutables();
    
    
        private <T> Set<ConstraintViolation<T>> validMethodParams(T obj, Method method, Object[] params) {
            return validator.validateParameters(obj, method, params);
        }
    }
    

    注释写的比较清楚了,这是一个aop切面类,拦截请求,并获取方法里的所有参数。第65行到85行是对普通参数进行校验的。
    加上这几行代码后在controller里写的那些才会生效,并且把校验信息保存到了ConstraintViolation的Set集合里,判断Set是否有值,即可知道是否有校验不通过的信息,然后就可以取到校验信息并返回给用户,然后结束方法。
    而49到62行,主要是判断是否存在BindingResult参数,如果有,说明有校验javaBean的意图,如果BindingResult有值,说明存在校验不通过的信息,那么就可以做处理了。通过这样的aop切面,就可以不用在每个controller方法里去处理校验信息了。

    展开全文
  • JSON格式的数据传递是最常用的方法之一,以下列出了常用的几种形态以及与Javabean之间的转换:  String json1="{'name':'zhangsan','age':23,'interests':[{'interest':'篮球','colors':['绿色','黄色']},{'...

        JSON格式的数据传递是最常用的方法之一,以下列出了常用的几种形态以及与Javabean之间的转换:

      String json1="{'name':'zhangsan','age':23,'interests':[{'interest':'篮球','colors':['绿色','黄色']},{'interest':'足球','colors':['红色','蓝色']}]}";
      String json2="[{'name':'zhangsan'},{'name':'lisi'},{'name':'王五'}]";
      String json3="{'1':{'name':'zhangsan'},'3':{'name':'lisi'},'4':{'name':'wangwu'}}";//map
      String json4="{'name':'zhangsan','age':23}";

    首先,此处的转化依赖两个JAR包

     1     <!-- https://mvnrepository.com/artifact/com.google.code.gson/gson -->
     2     <dependency>
     3         <groupId>com.google.code.gson</groupId>
     4         <artifactId>gson</artifactId>
     5         <version>2.8.1</version>
     6     </dependency>
     7     <!-- https://mvnrepository.com/artifact/org.json/json -->
     8     <dependency>
     9         <groupId>org.json</groupId>
    10         <artifactId>json</artifactId>
    11         <version>20170516</version>
    12     </dependency>
    View Code

    其次,封装的Javabean代码如下

     1 import java.util.List;
     2 
     3 public class UserBean {
     4 
     5     private String name;
     6     
     7     private Integer age;
     8     
     9     private List<InterestBean> interests;
    10 
    11     public String getName() {
    12         return name;
    13     }
    14 
    15     public void setName(String name) {
    16         this.name = name;
    17     }
    18 
    19     public Integer getAge() {
    20         return age;
    21     }
    22 
    23     public void setAge(Integer age) {
    24         this.age = age;
    25     }
    26     
    27     
    28     
    29     
    30     public List<InterestBean> getInterests() {
    31         return interests;
    32     }
    33 
    34     public void setInterests(List<InterestBean> interests) {
    35         this.interests = interests;
    36     }
    37 
    38 
    39 
    40 
    41      class InterestBean{
    42         private String interest;
    43         
    44         private List<String> colors;
    45 
    46         public String getInterest() {
    47             return interest;
    48         }
    49 
    50         public void setInterest(String interest) {
    51             this.interest = interest;
    52         }
    53 
    54         public List<String> getColors() {
    55             return colors;
    56         }
    57 
    58         public void setColors(List<String> colors) {
    59             this.colors = colors;
    60         }
    61         
    62         
    63     }
    64     
    65 }
    View Code

    1、普通的json4格式的JSON解析:

     1 public void testParseJson(){
     2         
     3         JSONObject jsonObj = new JSONObject(json4);
     4         String name = jsonObj.getString("name");
     5         int age = jsonObj.getInt("age");
     6         System.out.println(name);
     7         System.out.println(age);
     8         UserBean user = new UserBean();
     9         user.setAge(age);
    10         user.setName(name);
    11         
    12     }
    View Code

    2、数组形式的JSON解析以及GSON解析:

    1 public void testJsonArray(){
    2         JSONArray jsonArray = new JSONArray(json2);
    3         for (int i = 0; i < jsonArray.length(); i++) {
    4             JSONObject jsonObj = jsonArray.getJSONObject(i);
    5             String name = jsonObj.getString("name");
    6             System.out.println(name);
    7 
    8         }
    9     }
    View Code
     1     /**
     2      * 解析json数组
     3      */
     4     public void testParseListJson(){
     5         Gson gson = new Gson();
     6         Type type = new TypeToken<List<UserBean>>(){}.getType();
     7         List<UserBean> users = gson.fromJson(json2, type);
     8         for(UserBean user:users){
     9             System.out.println(user.getName());
    10         }
    11     }
    View Code

    3、内嵌JSON形式的JSON与GSON解析:

     1 /**
     2      * 内嵌JSON解析
     3      */
     4     public void testParseJson1(){
     5         JSONObject rootJson = new JSONObject(json1);
     6         JSONArray jsonInterestArray = rootJson.getJSONArray("interests");
     7         for (int i = 0; i < jsonInterestArray.length(); i++) {
     8             JSONObject interestJsonObj = jsonInterestArray.getJSONObject(i);
     9             String interest = interestJsonObj.getString("interest");
    10             System.out.println(interest);
    11             Object obj = interestJsonObj.get("colors");
    12             System.out.println(obj);
    13         }
    14     }
    View Code
     1 /**
     2      * 内嵌GSON解析
     3      */
     4     public void testSimpleJson(){
     5         Gson gson = new Gson();
     6         UserBean user = gson.fromJson(json1, UserBean.class);
     7         System.out.println(user.getName());
     8         System.out.println(user.getAge());
     9         System.out.println(user.getInterests().size());
    10         List<InterestBean> list = user.getInterests();
    11         for(InterestBean bean:list) {
    12             System.out.println(bean.getInterest());
    13             List<String> colors = bean.getColors();
    14             for(String color:colors){
    15                 System.out.println(color);
    16             }
    17         }
    18     }
    View Code

    4、Map形式的JSON的GSON解析:

     1     /**
     2      * 解析一个map类型的json
     3      */
     4     public void testParseMapJson(){
     5         Gson gson = new Gson();
     6         Type type = new TypeToken<Map<String,UserBean>>(){}.getType();
     7         Map<String,UserBean> map = gson.fromJson(json3, type);
     8         Set<String> keys = map.keySet();
     9         for(String key:keys){
    10             UserBean bean = map.get(key);
    11             System.out.println(key);
    12             System.out.println(bean.getName());
    13         }
    14     }
    View Code

    5、将一个JavaBean对象封装成JSON格式

     1     /**
     2      * 将一个JavaBean对象封装成JSON格式
     3      */
     4     public String testJavaBean2Json(){
     5         UserBean userBean = new UserBean();
     6         userBean.setName("zhangsan");
     7         userBean.setAge(33);
     8         List<InterestBean> list = new ArrayList<InterestBean>();
     9         InterestBean bean1 = new UserBean().new InterestBean();
    10         bean1.setInterest("篮球1");
    11         InterestBean bean2 = new UserBean().new InterestBean();
    12         bean2.setInterest("篮球2");
    13         list.add(bean1);
    14         list.add(bean2);
    15         userBean.setInterests(list);
    16         //将User Bean转换成Json
    17         Gson gson = new Gson();
    18         String jsonStr = gson.toJson(userBean);
    19         System.out.println(jsonStr);
    20         return jsonStr;
    21     }
    22 
    23 }
    View Code

    仅供参考,如有雷同,纯属巧合^_^

    转载于:https://www.cnblogs.com/lq147760524/p/7413835.html

    展开全文
  • 一、Servlet+JSP+JavaBean开发模式(MVC)介绍 Servlet+JSP+JavaBean模式(MVC)适合开发复杂的web应用,在这种模式下,servlet负责处理用户请求,jsp负责数据显示,... 这里以一个最常用的用户登录注册程序来讲解Servle
  • 一、Servlet+JSP+JavaBean开发模式(MVC)介绍  Servlet+JSP+JavaBean模式(MVC)适合开发复杂的web应用,在这种模式下,servlet负责处理用户请求,jsp负责数据显示,... 这里以一个最常用的用户登录注册程序来讲解S...
  • Javabean数据跳转是最常用,也是最常见一种,有时候并不是只能携带一种类型数据,需要将一堆不同类型数据一块传到下一个Activity中,那么,Javabean就很完美解决了很多问题。可以想这么一个问题,很多时候在...
  • java反射最常用的几个方法

    千次阅读 2018-04-06 13:05:21
    1.获取javaBean的属性 Student s = new Student(); Class&lt;? extends Student&gt; class1 = s.getClass(); //获取public属性 Field[] fields = class1.getFields(); //获取所有属性 Field[] ...
  • 上一篇以一个最常用的用户登录注册程序来讲解Servlet+JSP+JavaBean开发模式,所以我们也初步了解了Servlet+JSP+JavaBean(MVC)模式。现在我们以一个网上购物时的购物车程序来重新回顾这种开发模式。创建MVC架构的Web...
  • 一、Servlet+JSP+JavaBean开发模式(MVC)介绍Servlet+JSP+JavaBean模式(MVC)适合开发复杂的web应用,在这种模式下,servlet负责处理用户请求,jsp负责数据显示...这里以一个最常用的用户登录注册程序来讲解Servlet+J...
  • XML和JSON是两种很常用的数据描述和传输格式,在java里提供了完成JavaBean与这两种格式相互转换的组件,即XStream和JSON-lib,通过组件实现可以使得转换省事很多。这里主要讲解xstream的实现。首先要加载xstream包,...
  • SpringMVC最常用的校验是对一个javaBean的校验,默认使用hibernate-validator校验框架。而网上对校验单个参数,譬如String,int之类的资料极少,这一篇就是讲这个的。校验JavaBeanpackage com.example.bean;import ...
  • 一、Servlet+JSP+JavaBean开发模式(MVC)介绍  Servlet+JSP+JavaBean模式(MVC)适合开发复杂的web应用,在这种模式下,servlet负责处理用户请求,jsp负责数据显示,javabean负责... 这里以一个最常用的用户登录注...
  • 一、Servlet+JSP+JavaBean开发模式(MVC)介绍  Servlet+JSP+JavaBean模式(MVC)适合开发复杂的web应用,在这种模式下,servlet负责处理用户请求,jsp负责数据显示,... 这里以一个最常用的用户登录注册程序来讲解S...
  • 一、Servlet+JSP+JavaBean开发模式(MVC)介绍  Servlet+JSP+JavaBean模式(MVC)适合开发复杂的web应用,在这种模式下,servlet负责处理用户请求,jsp负责数据显示,javabean... 这里以一个最常用的用户登录注册程序
  • 一、Servlet+JSP+JavaBean开发模式(MVC)介绍  Servlet+JSP+JavaBean模式(MVC)适合开发复杂的web应用,在这种模式下,servlet负责处理用户请求,jsp负责数据显示,... 这里以一个最常用的用户登录注册程序来讲解S
  • 一、Servlet+JSP+JavaBean开发模式(MVC)介绍  Servlet+JSP+JavaBean模式(MVC)适合开发复杂的web应用,在这种模式下,servlet负责处理用户请求,jsp负责数据显示,javabean... 这里以一个最常用的用户登录注册程序
  • 一、Servlet+JSP+JavaBean开发模式(MVC)介绍  Servlet+JSP+JavaBean模式(MVC)适合开发复杂的web应用,在这种模式下,servlet负责处理用户请求,jsp负责数据显示,... 这里以一个最常用的用户登录注册程序来讲解S...

空空如也

空空如也

1 2 3 4 5 ... 19
收藏数 370
精华内容 148
关键字:

最常用的javabean

java 订阅