Spring学习(十七)——SpringBoot Web开发

最新推荐文章于 2023-03-26 22:37:03 发布

郭建華

最新推荐文章于 2023-03-26 22:37:03 发布

阅读量189

点赞数

本文链接：https://blog.csdn.net/ACE_GJH/article/details/106913674

版权

Spring全家桶专栏收录该内容

28 篇文章 0 订阅

订阅专栏

用SpringBoot和我们之前用Spring + Spring MVC基本上是一样的用法，比如Controller层，AOP编程，拦截器，全局异常，文件上传下载等，当然，我们目前主要用的是SpringBoot的Restful接口调用，所以下面也已返回Restful方式的Controller为中心，进行案例演示。

文章目录

一、Spring Boot Web基础开发

引入SpringBoot Web依赖

    <!-- SpringBoot web -->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

Controller类

package cool.gjh.controller;

import cool.gjh.entity.Student;
import cool.gjh.service.StudentService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * Controller层
 * <p>
 *     Restful风格，返回json数据
 * </p>
 * @author ACE_GJH
 */
@RestController
@RequestMapping("/student")
public class StudentController {

    @Autowired
    private StudentService studentService;

    @GetMapping(value = "/data")
    public Map<String, Object> showAll(){

        List<Student> students = studentService.getAllStudent();
        HashMap<String, Object> data = new HashMap<>(4*5/4, 0.8f);
        data.put("code", 200);
        data.put("msg", "OK");
        data.put("data", students);
        data.put("date", System.currentTimeMillis());
        return data;
    }

}

访问路径配置

application.yml

server:
  port: 80
  servlet:
    context-path: /test

测试

浏览器访问http://localhost/test/student/data

二、拦截器开发

拦截器类

package cool.gjh.interceptor;

import org.springframework.stereotype.Component;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * 拦截器
 * <p>
 * 针对/student请求的拦截处理
 * </p>
 *
 * @author ACE_GJH
 */
@Component
public class StudentInterceptor implements HandlerInterceptor {
    /**
     * 请求最先经过的方法，在HandlerAdapter之前调用
     *
     * @param request  current HTTP request
     * @param response current HTTP response
     * @param handler  chosen handler to execute, for type and/or instance evaluation
     * @return {@code true} 放行请求；{@code false} 中断请求
     * @throws Exception in case of errors
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("StudentInterceptor:preHandle");
        return true;
    }

    /**
     * 请求在HandlerAdapter之后调用
     *
     * @param request      current HTTP request
     * @param response     current HTTP response
     * @param handler      handler (or {@link HandlerMethod}) that started asynchronous
     *                     execution, for type and/or instance examination
     * @param modelAndView the {@code ModelAndView} that the handler returned
     *                     (can also be {@code null})
     * @throws Exception in case of errors
     */
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("StudentInterceptor:postHandle");
    }

    /**
     * 请求完成之后调用。
     * <p>注意：仅当此拦截器的{@code preHandle} 方法成功完成并返回{@code true}时才会调用！
     * <p>与{@code postHandle}方法一样，该方法将在链中的每个拦截器上以相反的顺序调用，因此第一个拦截器将是最后一个要调用的拦截器。
     *
     * @param request  current HTTP request
     * @param response current HTTP response
     * @param handler  handler (or {@link HandlerMethod}) that started asynchronous
     *                 execution, for type and/or instance examination
     * @param ex       exception thrown on handler execution, if any
     * @throws Exception in case of errors
     */
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("StudentInterceptor:afterCompletion");
    }
}

配置拦截器

package cool.gjh.config;

import cool.gjh.interceptor.StudentInterceptor;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

/**
 * 拦截器配置类
 *
 * @author ACE_GJH
 */
@Component
public class InterceptorConfig implements WebMvcConfigurer {


    /**
     * 添加拦截器
     *
     * @param registry 拦截器注册器
     */
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new StudentInterceptor())
                //定义拦截路径
                .addPathPatterns("/student/**");
    }
}

测试结果

排除对特定请求路径的拦截

  /**
     * 添加拦截器
     *
     * @param registry 拦截器注册器
     */
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new StudentInterceptor())
                //定义拦截路径
                .addPathPatterns("/student/**")
                //排除该路径的拦截
                .excludePathPatterns("/student/data");

    }

三、war包方式部署

1. 排除内嵌tomcat

    <!-- 排除内嵌tomcat -->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-tomcat</artifactId>
      <scope>provided</scope>
    </dependency>

2. 配置入口类

继承SpringBootServletInitializer类
重写其configure()方法

package cool.gjh.app;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
import org.springframework.context.annotation.ComponentScan;

/**
 * SpringBoot入口类
 * <p>
 *     注意：war包部署需要继承SpringBootServletInitializer类，并重写configure()方法
 * </p>
 *
 * @author ACE_GJH
 */
@SpringBootApplication
@MapperScan("cool.gjh.dao")
@ComponentScan("cool.gjh")
public class App extends SpringBootServletInitializer
{
    public static void main( String[] args )
    {
        SpringApplication.run(App.class, args);
    }

    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
        return builder.sources(App.class);
    }
}

3. 在Maven插件中指定入口类

  <build>
    <plugins>
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
        <configuration>
          <!-- 增加JVM参数 -->
          <jvmArguments>-Dfile.encoding=UTF-8</jvmArguments>
          <!-- 指定入口类 -->
          <mainClass>cool.gjh.app.App</mainClass>
        </configuration>
      </plugin>
    </plugins>
  </build>

4. 修改打包方式

pom.xml
在该位置添加<packaging>war</packaging>

  <groupId>cool.gjh</groupId>
  <artifactId>springboot</artifactId>
  <version>1.0-SNAPSHOT</version>

  <packaging>war</packaging>

四、jar包方式部署

笔者在用war包部署的时候，在windows上的tomcat里部署没有一点问题，但在linux里部署的时候，总是报404，无奈，只能采用jar包方式直接部署运行了。

1. 配置Maven打包插件

pom.xml

  <build>
    <plugins>
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
      </plugin>
    </plugins>
  </build>