SSM之SpringBoot框架（三）——返回json数据、FastJson框架和热部署

举报
小白同学111 发表于 2022/12/27 21:30:10 2022/12/27
【摘要】 SSM之SpringBoot框架（三）——返回json数据、FastJson框架和热部署

##### 1.0 实现步骤

> *   1.  编写实体类DEmo
> *   2.  编写getDemo（）方法
> *   3.  测试

##### 2.0 SringBoot默认使用json解析框架：javkson

创建一个SringBoot项目

![image](https://img-blog.csdnimg.cn/img_convert/c7b4d26a89d6c4fe0b08f727bf841ecd.png)

pom.xml

```
<project xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.edp</groupId>
    <artifactId>spring-boot-hello</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>spring-boot-hello</name>
    <url>http://maven.apache.org</url>

    <!-- spring boot 父节点依赖,引入这个之后相关的引入就不需要添加version配置，spring boot会自动选择最合适的版本进行添加。 -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.4.1.RELEASE</version>
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <!-- 指定一下jdk的版本 ，这里我们使用jdk 1.8 ,默认是1.6 -->
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
            <!-- spring-boot-starter-web: MVC,AOP的依赖包.... -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <!-- <version></version> 由于我们在上面指定了 parent(spring boot) -->
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>3.8.1</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>

```

启动类

```
package com.edp;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * 编写启动类 
 * 在这里我们使用@SpringBootApplication指定这是一个
 *  spring boot的应用程序.
 * @author Edpeng
 *
 */

@SpringBootApplication
public class App {
    public static void main(String[] args) {
        /*
         * 在main方法进行启动我们的应用程序.
         */
        SpringApplication.run(App.class, args);

    }
}

```

控制类

```
package com.edp;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * 在这里我们使用RestController  （等待于 @Controller 和 @RequestBody）
 * @author Edpeng
 *@version v.0.1
 *@date 2022年07月7日
 */
@RestController
public class HelloController {

    /**
     * 在这里我们使用@RequestMapping 建立请求映射:
     * http://127.0.0.1:8080/hello
     * @return
     */
    @RequestMapping("/hello")
    public String hello(){
        return "hello";
    }

    /**
     * SringBoot默认使用json解析框架：javkson
     * @return
     */
    @RequestMapping("/getdemo")
    public Demo getDemo() {
        Demo demo = new Demo ();
        demo.setId(1);
        demo.setName("张三");
        return demo;
    }
}

```

实体类

```
package com.edp;
/**
 * 
 * @author EdPeng
 * @DATE 2022年7月7日
 * @TODO 测试实体类
 */
public class Demo {
    private int id;
    private String name;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

}

```

运行：

![image](https://img-blog.csdnimg.cn/img_convert/e782be67d14c3f78619c08df7e8ff7ba.png)

##### 3.0 使用FastJson解析JSON数据

###### 3.1 引入fastjson依赖包

pom.xml

```
<project xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

        …………

    <dependencies>
<!-- 添加fastjson 依赖包. -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.15</version>
        </dependency>
    </dependencies>
</project>

```

###### 3.2 配置fastjon

目前有两种方法支持。

###### 1\. 第一种

步骤

> *   1.  启动类继承extends WebMvcConfigureAdapter
> *   覆盖方法configureMessageConverters
>     修改启动类

```
package com.edp;

import java.util.List;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
import com.alibaba.fastjson.support.spring.FastJsonHttpMessageConverter;
import com.alibaba.fastjson.serializer.SerializerFeature;
import com.alibaba.fastjson.support.config.FastJsonConfig;

/**
 * 编写启动类 在这里我们使用@SpringBootApplication指定这是一个 spring boot的应用程序.
 * 
 * @author Edpeng
 *
 */

@SpringBootApplication
public class App extends WebMvcConfigurerAdapter {

    @Override
    public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
        super.configureMessageConverters(converters);

        /*
         * 1、需要先定义一个 convert 转换消息的对象; 
         * 2、添加fastJson 的配置信息，比如：是否要格式化返回的json数据;
         * 3、在convert中添加配置信息. 
         * 4、将convert添加到converters当中.
         * 
         */

        // 1、需要先定义一个 convert 转换消息的对象;
        FastJsonHttpMessageConverter fastConverter = new FastJsonHttpMessageConverter();

        // 2、添加fastJson 的配置信息，比如：是否要格式化返回的json数据;
        FastJsonConfig fastJsonConfig = new FastJsonConfig();
        fastJsonConfig.setSerializerFeatures(SerializerFeature.PrettyFormat);

        // 3、在convert中添加配置信息.
        fastConverter.setFastJsonConfig(fastJsonConfig);

        // 4、将convert添加到converters当中.
        converters.add(fastConverter);

    }

    public static void main(String[] args) {
        /*
         * 在main方法进行启动我们的应用程序.
         */
        SpringApplication.run(App.class, args);

    }
}

```

###### 2\. 第二种办法

> *   注入Bean：HttpMessageConverters

```
package com.edp;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.web.HttpMessageConverters;
import org.springframework.context.annotation.Bean;
import org.springframework.http.converter.HttpMessageConverter;

import com.alibaba.fastjson.serializer.SerializerFeature;
import com.alibaba.fastjson.support.config.FastJsonConfig;
import com.alibaba.fastjson.support.spring.FastJsonHttpMessageConverter;

/**
 * 编写启动类 在这里我们使用@SpringBootApplication指定这是一个 spring boot的应用程序.
 * 
 * @author Edpeng
 *
 */

@SpringBootApplication
public class App {

    /**
     * 在这里我们使用 @Bean注入 fastJsonHttpMessageConvert
     * @return
     */
    @Bean
    public HttpMessageConverters fastJsonHttpMessageConverters() {
        // 1、需要先定义一个 convert 转换消息的对象;
        FastJsonHttpMessageConverter fastConverter = new FastJsonHttpMessageConverter();

        //2、添加fastJson 的配置信息，比如：是否要格式化返回的json数据;
        FastJsonConfig fastJsonConfig = new FastJsonConfig();
        fastJsonConfig.setSerializerFeatures(SerializerFeature.PrettyFormat);

        //3、在convert中添加配置信息.
        fastConverter.setFastJsonConfig(fastJsonConfig);

        HttpMessageConverter<?> converter = fastConverter;
        return new HttpMessageConverters(converter);
    }

    /**
     * 这是springloader的配置方式：-javaagent:.\lib\springloaded-1.2.4.RELEASE.jar -noverify
     * @param args
     */
    public static void main(String[] args) {
        /*
         * 在main方法进行启动我们的应用程序.
         */
        SpringApplication.run(App.class, args);

    }
}

```

FastJson框架的一些注解方法：

```
package com.edp;

import java.util.Date;

import com.alibaba.fastjson.annotation.JSONField;

/**
 * 
 * @author EdPeng
 * @DATE 2022年7月7日
 * @TODO 测试实体类
 */
public class Demo {
    private int id;
    private String name;

    //规范JSON时间的格式
    @JSONField(format = "yyyy-mmm-dd HH:mm")
    private Date createTime;

    /**
     * 不想返回remarks
     * serialize：是否需要序列化属性
     */
    @JSONField(serialize =  false)
    private String remarks;

    public Date getCreateTime() {
        return createTime;
    }

    public void setCreateTime(Date createTime) {
        this.createTime = createTime;
    }

    public String getRemarks() {
        return remarks;
    }

    public void setRemarks(String remarks) {
        this.remarks = remarks;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

}

```

##### 4.0 Spring Boot热部署

###### 4.1 第一种办法

就是运行的时候，可以修改代码，然后可以直接刷新浏览器即可。

```
<project xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

        …………

<!-- 构建编译节点. -->
    <build>
        <plugins>

            <!-- 在这里添加springloader plugin -->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin </artifactId>
                <dependencies>  
                   <dependency>  
                       <groupId>org.springframework</groupId>  
                       <artifactId>springloaded</artifactId>  
                       <version>1.2.4.RELEASE</version>
                   </dependency>  
                </dependencies>  
                <executions>  
                   <execution>  
                       <goals>  
                           <goal>repackage</goal>  
                       </goals>  
                       <configuration>  
                           <classifier>exec</classifier>  
                       </configuration>  
                   </execution>  
                </executions>
            </plugin>
    </plugins>

    </build>    

</project>

```

然后在maven build输入spring-boot:run运行即可。

![image](https://img-blog.csdnimg.cn/img_convert/663775c68add81cc15f858d6c4a61037.png)

![image](https://img-blog.csdnimg.cn/img_convert/77162c916943b3d3d058ba4726e8130e.png)

然后浏览器打开即可，改代码后，只需要刷新浏览器即可。

但这个方法存在一个问题，当在Eclipse中点击关闭后，还需要去后台手动杀进程，java.exe并没有被关闭。

###### 4.2 第二种办法

会比较麻烦一点，但是没有1中那种缺点。
使用run as -java application
把spring-loader-1.2.4RELEASE.jar下载下来，放到项目的lib目录下，然后把IDEA的run参数里面的VM参数设置为：

```
-javaagent:.\lib\springloaded-1.2.4.RELEASE.jar -noverify

```

然后启动既可以，这样，在run as 的时候，也可以进行热部署。

![image](https://img-blog.csdnimg.cn/img_convert/8ab777f2977bd70542bc8356f945ca23.png)

###### 4.3 devtools热部署

在上两种热部署中，如果新增方法，是没办法热部署的。

> *   spring-boot-devtools 是一个为开发者服务的一个模块，其中最重要的功能就是自动应用代码更改到最新的App上面去。原理是在发现代码有更改之后，重新启动应用，但是速度比手动停止后再启动还要更快，更快指的不是节省出来的手工操作的时间。在此我向大家推荐一个架构学习交流圈。交流学习指导伪鑫：1253431195（里面有大量的面试题及答案）里面会分享一些资深架构师录制的视频录像：有Spring，MyBatis，Netty源码分析，高并发、高性能、分布式、微服务架构的原理，JVM性能优化、分布式架构等这些成为架构师必备的知识体系。还能领取免费的学习资源，目前受益良多
> *   其深层原理是使用了两个ClassLoader，一个Classloader加载那些不会改变的类（第三方Jar包），另一个ClassLoader加载会更改的类，称为 restart ClassLoader
> *   ,这样在有代码更改的时候，原来的restart ClassLoader 被丢弃，重新创建一个restart ClassLoader，由于需要加载的类相比较少，所以实现了较快的重启时间（5秒以内）。

###### 第一步，添加依赖包

```
<project xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

        …………

<dependencies>

        …………

<!-- spring-boot-devtools依赖包 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <optional>true</optional>
            <scope>true</scope>
        </dependency>
    </dependencies>
</project>

```

然后在添加相应的plugins：

```
<!-- 构建节点. -->
    <build>
        <plugins>
            <!-- 这是spring boot devtool plugin -->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <!--fork : 如果没有该项配置，这个个devtools不会起作用，即应用不会restart -->
                    <fork>true</fork>
                </configuration>
            </plugin>
        </plugins>
    </build>

```

测试方法：

> 修改类→保存：应用会重启
> 修改配置文件→保存：应用会重启
> 修改页面→保存：应用会重启，页面会刷新（原理是将**spring.thymeleaf.cache**设为**false**）

发现，以上情况都能实现热部署。

> *   1.  devtools会监听classpath下的文件变动，并且会立即重启应用（发生在保存时机），注意：因为其采用的虚拟机机制，该项重启是很快的。
> *   2.  devtools可以实现页面热部署（即页面修改后会立即生效，这个可以直接在application.properties文件中配置spring.thymeleaf.cache=false来实现(这里注意不同的模板配置不一样)。
> *   3.  如果设置SpringApplication.setRegisterShutdownHook(false)，则自动重启将不起作用。

**END**

【版权声明】本文为华为云社区用户原创内容，转载时必须标注文章的来源（华为云社区）、文章链接、文章作者等基本信息， 否则作者和本社区有权追究责任。如果您发现本社区中有涉嫌抄袭的内容，欢迎发送邮件进行举报，并提供相关证据，一经查实，本社区将立刻删除涉嫌侵权内容，举报邮箱： cloudbbs@huaweicloud.com
JSON Spring Boot
  • 点赞
  • 收藏
  • 关注作者

评论（0）

0/1000
抱歉，系统识别当前为高风险访问，暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称，即可参与社区互动！

*长度不超过10个汉字或20个英文字符，设置后3个月内不可修改。

*长度不超过10个汉字或20个英文字符，设置后3个月内不可修改。

确认 取消

加入云驻计划，成为创作者

  • 华为云周边好礼
  • 免费体验产品
  • 特殊身份标识
  • 线下官方门票
  • 内部专家零距离
  • 与10000+优质创作者共同成长
立即加入