【Java中级】37.0 SSM之SpringBoot框架（三）

作者: bobokaka | 来源:发表于2020-02-21 17:14 被阅读0次

1.0 实现步骤

编写实体类DEmo

编写getDemo（）方法

测试

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

创建一个SringBoot项目

image.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 2020年02月21日
 */
@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 2020年2月21日
 * @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.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. 第一种

步骤

启动类继承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 2020年2月21日
 * @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.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.png

4.3 devtools热部署

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

spring-boot-devtools 是一个为开发者服务的一个模块，其中最重要的功能就是自动应用代码更改到最新的App上面去。原理是在发现代码有更改之后，重新启动应用，但是速度比手动停止后再启动还要更快，更快指的不是节省出来的手工操作的时间。

其深层原理是使用了两个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）

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

devtools会监听classpath下的文件变动，并且会立即重启应用（发生在保存时机），注意：因为其采用的虚拟机机制，该项重启是很快的。

devtools可以实现页面热部署（即页面修改后会立即生效，这个可以直接在application.properties文件中配置spring.thymeleaf.cache=false来实现(这里注意不同的模板配置不一样)。

如果设置SpringApplication.setRegisterShutdownHook(false)，则自动重启将不起作用。

END

【Java中级】37.0 SSM之SpringBoot框架（三）

1.0 实现步骤

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

3.0 使用FastJson解析JSON数据

3.1 引入fastjson依赖包

3.2 配置fastjon

1. 第一种

2. 第二种办法

4.0 Spring Boot热部署

4.1 第一种办法

4.2 第二种办法

4.3 devtools热部署

第一步，添加依赖包

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

Java子弹