Spring解析json文件成json对象 spring读取json配置文件

转载

mob6454cc6d3e23 2024-03-28 06:56:56

Springmvc中使用json，首先要json的解析器(jackson)导入依赖：

jackson 比较好用的json比较好掌握，解析工具还有阿里巴巴fastjson等

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.10.1</version>
</dependency>

配置web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
    <!--注册servlet-->
    <!--配置DispachxerServlet:这个是SpeingMvc的核心，请求分发器，前端控制器-->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--通过初始化参数指定Springmvc配置文件的位置-->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc-servlet.xml</param-value>
        </init-param>
        <!--启动级别 为1 ，意思是与服务器一块启动-->
        <load-on-startup>1</load-on-startup>
    </servlet>
    <!--/ 所有访问的 URL 都由DispatcherServlet来解析,所有请求都会Springmvc被拦截 -->
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

    <!-- 配置编码方式过滤器,注意一点:要配置在所有过滤器的前面 -->
    <filter>
        <filter-name>CharacterEncodingFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>utf-8</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>CharacterEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
</web-app>

Springmvc配置文件 springmvc-servlet.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/mvc
        https://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <!--自动扫描包，让注解指定包下的注解生效，又ioc容器同一管理-->
    <context:component-scan base-package="com.fanlan.Controller"/>
    
    <!--springmvc不处理静态资源-->
    <mvc:default-servlet-handler/>
    
    <!--支持mvc注解驱动，
    在spring中采用@RequestMapping注解在完成映射关系必须向上下文中注册DefaultAnnotationHandlerMapping
    必须和一个AnnotationMethodhandlerAdapter实例,而annotation-driven配置帮助我们完成上述两个实例的注入-->
    <mvc:annotation-driven/>
    
    <!--视图解析-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="internalResourceViewResolver">
        <!--前缀-->
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <!--后缀-->
        <property name="suffix" value=".jsp"/>
    </bean>

</beans>

之后我们编写一个实体类User

package com.fanlan.pojo;

public class User {
    private String name;
    private int age;
    private String sex;
	//此处省略了 构造 set get  toString 方法 
}

在编写一个Controller类

@Controller	//@Controller标识这个类是一个控制器
public class jsonController {
    @RequestMapping("/json")		//@RequestMapping给控制器方法绑定一个uri
    @ResponseBody   //@ResponseBody：将java对象转成json，并且发送给客户端
    public String Json() throws JsonProcessingException {
		//创建一个jsckson的对象映射器，解析数据
        ObjectMapper mapper = new ObjectMapper();
        //创建一个对象
        User user = new User("张三", 3, "男");
		//使用writeValueAsString()方法将Java对象解析成json格式
        String str = mapper.writeValueAsString(user);
		//返回前端
        return str;
    }

配置tomcat,启动测试

Spring解析json文件成json对象 spring读取json配置文件_json

发现出现乱码？有问题就有解决方法：

设置它的编码格式以及返回类型

@RequestMapping(value = "/json",produces = "application/json; charset=utf-8")

可是这种方式需要我们每次设置，好麻烦，Spring也帮我们解决了，可以在spring配置文件中添加

<!-- 处理请求返回json字符串的乱码问题 -->
<mvc:annotation-driven>
   <mvc:message-converters register-defaults="true">
       <!-- 启动Spring MVC的注解功能，完成请求和注解POJO的映射 注解请求映射
       默认是ISO-88859-1，避免乱码这里设置为UTF-8 -->
       <bean class="org.springframework.http.converter.StringHttpMessageConverter">
           <property name="supportedMediaTypes" value="text/html;charset=UTF-8" />
       </bean>
       <!-- 启动JSON格式的配置,自动将格式转换成JSON格式，不需要其他类 -->
       <bean id="jacksonMessageConverter" class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
           <property name="supportedMediaTypes" value="application/json;charset=UTF-8" />
       </bean>
   </mvc:message-converters>
</mvc:annotation-driven>

测试一下

Spring解析json文件成json对象 spring读取json配置文件_json_02

乱码成功解决😄

拓展：

@RestController 相当于@Controller+ @ResponseBody

@RestController 只会返回json字符串，不需要配置其他。

@Controller和@RestController的区别？

除了可以解析对象，那集合，时间，可以解析吗？接下来我们实践一下，实践出真理

@Controller //表明是一个控制器
public class jsonController {
    @RequestMapping("/json1")//路径
    @ResponseBody	//将java对象转成json，并且发送给客户端
    public String Json1() throws JsonProcessingException {

        ObjectMapper mapper = new ObjectMapper();

        List<User> list=new ArrayList<User>();
        //创建一个对象
        User user = new User("张三", 3, "男");
        User user1 = new User("张三", 3, "男");
        User user2 = new User("张三", 3, "男");
        User user3 = new User("张三", 3, "男");
        list.add(user);
        list.add(user1);
        list.add(user2);
        list.add(user3);
        String str = mapper.writeValueAsString(list);
        return str;
    }

运行结果:表明没问题

Spring解析json文件成json对象 spring读取json配置文件_xml_03

@Controller//控制类
public class jsonController {
    @RequestMapping("/jsonDate")//访问路径
    @ResponseBody
    public String jsonDate() throws JsonProcessingException {
        //创建一个jsckson的对象映射器，解析数据
        ObjectMapper mapper = new ObjectMapper();
        //时间类
        Date date = new Date();
        //设置时间格式
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //format(Date date)方法将指定的日期对象格式化为指定格式的字符串
        String formatdate = sdf.format(date);
   		//使用writeValueAsString()方法将Java对象解析成json格式
        String strDate = mapper.writeValueAsString(formatdate);
		//返回页面
        return strDate;
    }

运行结果

Spring解析json文件成json对象 spring读取json配置文件_json_04

这种方式使用时间戳，那不使用时间戳的办法

@Controller//控制类
public class jsonController {
	@RequestMapping("/jsonDate")
	@ResponseBody
	public String jsonDate() throws JsonProcessingException {
	
	    ObjectMapper mapper = new ObjectMapper();
	
	    mapper.configure(SerializationFeature.WRITE_CHAR_ARRAYS_AS_JSON_ARRAYS,false);
	    //Date date = new Date();
	    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
	
	    mapper.setDateFormat(sdf);
	
	    //String formatdate = sdf.format(date);
	    Date date = new Date();
	
	    String strDate = mapper.writeValueAsString(date);
	
	    return strDate;
	}
}

运行结果

Spring解析json文件成json对象 spring读取json配置文件_spring_05

然而这些代码有好多重复，可不可以写一个工具类

package com.fanlan.Utils;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;

import java.text.SimpleDateFormat;

public class JsonUtils {

    public static String getJson(Object object){
        return getJson(object, "yyyy-MM-dd HH:mm:ss");
    }

    public static String getJson(Object object,String sdfDate){
        ObjectMapper mapper = new ObjectMapper();
        //不使用时间戳
        mapper.configure(SerializationFeature.WRITE_CHAR_ARRAYS_AS_JSON_ARRAYS,false);
        //格式化时间
        SimpleDateFormat sdf = new SimpleDateFormat(sdfDate);
        mapper.setDateFormat(sdf);

        try {
            return mapper.writeValueAsString(object);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        return null;
    }
}

测试：

@Controller//控制类
public class jsonController {
    @RequestMapping("/jsonDate1")
    @ResponseBody
    public String jsonDate1(){

        Date date = new Date();

        String json = JsonUtils.getJson(date, "yyyy-MM-dd HH:mm:ss");
        
        return json;
    }


    @RequestMapping("/jsonDate2")
    @ResponseBody
    public String jsonDate2(){

        Date date = new Date();
        String json1 = JsonUtils.getJson(date);
        return json1;
    }
}

结果都是 ok 😀，总之要学会编写工具类实现复用。

接下来就是使用AJAX将这些数据动态显示到客户端界面。

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。