java框架之springboot

一、简介

springboot是java的开源框架之一，简化spring的大量重复工作（spring.xml的配置，spring和第三框机集成需要的配置，重复jar的添加）通过特定配置进行项目的配置，不需要开发人员定义样板化的配置，实现项目的快速开发。

二、特点

1.可以创建独立的spring应用程序，基于他的maven，可以创建可执行的jar、war。
2.内嵌tomcat或jetty等servlet容器
3.自动配置spring容器，比如自动注入，自动扫描等
4.无代码生成，不需要xml配置
5.提供自动配置的“starter”项目对象模型（POMS）以简化maven配置

三、创建springboot应用的简要过程

1.创建springboot项目

2.springboot的依赖说明（pom.xml）

<?xml version="1.0" encoding="UTF-8"?>
-<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://maven.apache.org/POM/4.0.0">
<modelVersion>4.0.0</modelVersion>
<!--自己项目的父项目，当前使用的springboot的版本-->
-<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.2.2.RELEASE</version>
<relativePath/>
<!-- lookup parent from repository -->
</parent>
<groupId>com.yd.app</groupId>
<artifactId>01-springboot</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>war</packaging>
<name>01-springboot</name>
<description>Demo project for Spring Boot</description>
-<properties>
<java.version>1.8</java.version>
</properties>
-<dependencies>
<!--集成了springwebmvc的依赖-->
-<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!--集成了tomcat，内嵌的tomcat-->
-<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-tomcat</artifactId>
<scope>provided</scope>
</dependency>
<!--springboot集成单元内测-->
-<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
-<exclusions>
-<exclusion>
<groupId>org.junit.vintage</groupId>
<artifactId>junit-vintage-engine</artifactId>
</exclusion>
</exclusions>
</dependency>
</dependencies>
-<build>
-<plugins>
-<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>

3.springboot项目的目录结构

4.实例：客户端提交任意整数，服务器计算结果，将结果响应到客户端

/***
 * 创建springbmvc的controller
 * RestController=Controller+ResponseBody
 * @RestController 能将controller纳入spring容器
 *  还能controller的异步响应
 */
//@Controller
@RestController
public class SpringbootController {

    /***
     * 处理两个数相加的请求
     */
    @RequestMapping("/add")
    public Integer add(Integer x,Integer y){
        return x+y;
    }
}

5.项目启动

在浏览器中输入 localhost:8080/add:x=1&y=1访问

四、springboot项目配置

1.创建过程

2.配置application.properties

#tomcat的访问端口
server.port=8081
#项目的访问上下文
server.servlet.context-path=/boot
#get请求方式的中文乱码处理
server.tomcat.uri-encoding=UTF-8

3.启动springboot项目

4.通过application.yml进行项目配置

server:
  port: 8082  #配置tomncat端口号
  servlet:
    context-path: /bt  #配置上下文
  tomcat:
    uri-encoding: UTF-8 #get请求中文乱码处理
#以上的配置都是给系统中类的属性在赋值

5.创建实习类（在pojo包里）

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

/**
 * 自定义Users实体类
 * 在application.yml中对Uesrs类的属性赋值
 */
@ConfigurationProperties(
        prefix = "users", //指定配置文件中配置项的前缀
        ignoreUnknownFields = true
)
@Component  //将Users纳入spring容器中
public class Users {
    private String name;
    private String pwd;
    private String address;
//生成get/set/toString方法
}

6.配置application.yml

#给自动以类的属性赋值
users:
  name: zhagnsan
  pwd: 9527
  address: beijing
  age: 23

7.创建controller

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class UsersController {
    //注入Users
    @Autowired
    private Users users;
    /***
     * 处理显示用户信息的请求
     */
    @RequestMapping("/show")
    public String showUsers(){
        return users.toString();
    }
}

访问用户信息：localhost:8082/bt/show

8.springboot集成Junit（可自动装载spring容器）

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.context.ApplicationContext;

@SpringBootTest
class ApplicationTests {
   /***
    * junit在启动的时候加载了spring容器
    * junit在启动的时候加载了appliaction.yml
    */
   @Autowired
   private Users users;
   @Test
   void contextLoads() {
      System.out.println(users);
   }
}

四、springboot对象jsp的支持

1.项目构建

2.在pom.xml文件当中添加jsp解析器依赖

<!-- JSTL -->
<dependency>
   <groupId>javax.servlet</groupId>
   <artifactId>jstl</artifactId>
</dependency>
<!-- jsp解析器 -->
<dependency>
   <groupId>org.apache.tomcat.embed</groupId>
   <artifactId>tomcat-embed-jasper</artifactId>
</dependency>

3.在webapp/users下创建index.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <%
        for(int x=1;x<=10;x++){
            out.print("<hr color='red' width='"+x*50+"'/>");
        }
    %>
</body>
</html>

访问localhost:8080/users/index.jsp

五、springboot项目中添加拦截器（interceptor）

1.项目搭建

2.创建controller

@RestController
public class UserController {
    /***
     * 处理用户信息查询的请求
     */
    @RequestMapping("/show")
    public String show(){
        return "这是个人信息....";
    }
}

3.配置application.yml

server:
  port: 8081
  servlet:
    context-path: /user

4.创建premissionInterceptor拦截器

/***
 *通过实现HandlerInterceptor接口，自定义拦截器
 */
public class PremisssionInterceptor implements HandlerInterceptor{

    /***
     * 实现接口中定义的方法
     * @param request
     * @param response
     * @param handler
     * @return
     * @throws Exception
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        //获得客户端提交的凭证
        String token = request.getParameter("token");
        if(!StringUtils.isEmpty(token)){
            if(token.equals("123456")){
                System.out.println("token="+token);
                //权限验证通过，进行放行到Controller
                return true;
            }
        }
        response.setContentType("text/html;charset=UTF-8");
        //给客户端响应
        response.getWriter().write("权限不足.....");
        return false;
    }
}

5.配置自定义拦截器

//将该类纳入spring容器
@Configuration
public class ConfigBean implements WebMvcConfigurer {
    /**
     * 将自定义的拦截器添加到springboot框架中
     * @param registry
     */
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new PremisssionInterceptor()).addPathPatterns("/**");
    }
}

localhost:8081/user/shw?token=123456 ——>这是个人信息…
localhost:8081/user/shw?token=123 ——>权限不足

六、springboot静态资源的处理

静态资源存放在resources/static当中，拦截器中静态资源需要放行

//将该类纳入spring容器
@Configuration
public class ConfigBean implements WebMvcConfigurer {
    /**
     * 将自定义的拦截器添加到springboot框架中
     * @param registry
     */
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new PremisssionInterceptor())
                .addPathPatterns("/**") //配置需要拦截取得路径
                .excludePathPatterns("/images/**"); //指定不需要拦截的路径
    }
}