【Java中级】37.0 SSM之SpringBoot框架（三）
2020-02-21 本文已影响0人
bobokaka
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
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
