Spring Boot 整合 Web 开发

这一节我们主要学习如何整合 Web 相关技术：

  • Servlet
  • Filter
  • Listener
  • 访问静态资源
  • 文件上传
  • 文件下载

　　Web三大基本组件分别是：Servlet，Listener，Filter。正常来说一旦我们用了框架，这三个基本就用不上了，Servlet 被 Controller 代替，Filter 被拦截器代替。但是可能在一些特殊的场景下不得不使用这三个基本组件时，Spring Boot 中要如何去引用呢？下面我们来一起学习一下。

　　Spring Boot 集成了 Servlet 容器，当我们在 pom.xml 中增加 spring-boot-starter-web 组件依赖时，不做任何 web 相关的配置便能提供 web 服务，这还得归功于 Spring Boot 自动配置的功能，帮我们创建了一堆默认的配置，以前在 web.xml 中的配置，现在都可以通过 Spring Bean 的方式或者注解方式进行配置，由 Spring 来进行生命周期的管理，大多数情况下，我们需要自定义这些配置，如：修改服务的启动端口，ContextPath，Filter，Listener，Servlet，Session超时时间等等。

　　Spring Boot 提供了 ServletRegistrationBean，FilterRegistrationBean，ServletListenerRegistrationBean和 @WebServlet，@WebFilter，@WebListener 三种类型分别配置应用的 Servlet，Filter，Listener。

　　创建 jar 项目，编写 pom.xml

<?xml version="1.0" encoding="UTF-8"?>

<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.springboot</groupId>
    <artifactId>springboot-hello</artifactId>
    <version>1.0-SNAPSHOT</version>

    <name>springboot-hello</name>
    <!-- FIXME change it to the project's website -->
    <url>http://www.example.com</url>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
    </properties>

    <!-- 引入springboot父类依赖 -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.6.RELEASE</version>
    </parent>

    <dependencies>
        <!-- springboot-web 组件 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>
</project>

整合Servlet

　　Servlet 是 Java Servlet 的简称，称为小服务程序或服务连接器，用 Java 编写的服务器端程序，具有独立于平台和协议的特性，主要功能在于交互式地浏览和生成数据，生成动态Web内容。

　　Java Servlet 是运行在 Web 服务器或应用服务器上的程序，它是作为来自 Web 浏览器或其他 HTTP 客户端的请求和 HTTP 服务器上的数据库或应用程序之间的中间层。使用 Servlet 可以收集来自网页表单的用户输入，呈现来自数据库或者其他源的记录，还可以动态创建网页。

方法一

　　通过注解扫描完成 Servlet 组件的注册

　　编写FirstServlet.java

package com.springboot.servlet;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

/*
    配置文件的写法：
    <servlet>
        <servlet-name>FirstServlet</servlet-name>
        <servlet-class>com.springboot.servlet.FirstServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>FirstServlet</servlet-name>
        <url-pattern>/first</url-pattern>
    </servlet-mapping>
 */
@WebServlet(name = "FirstServlet", urlPatterns = {"/first"})
public class FirstServlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException {
        System.out.println("FirstServlet");
    }

}

　　启动类App.java

package com.springboot;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.servlet.ServletComponentScan;

@SpringBootApplication
// 在 SpringBoot 启动时会扫描 @WebServlet，并将该类实例化
@ServletComponentScan
public class App {

    // 项目中不需要有多个 main 方法只需要有一个入口就可以了
    public static void main(String[] args) {
        // 主函数运行 springboot 项目
        SpringApplication.run(App.class, args);
    }

}

方法二

　　通过方法完成 Servlet 组件的注册

　　编写SecondServlet.java

package com.springboot.servlet;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@WebServlet(name = "SecondServlet", urlPatterns = {"/second"})
public class SecondServlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException {
        System.out.println("FirstServlet");
    }

}

　　启动类App.java

package com.springboot;

import com.springboot.servlet.SecondServlet;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.context.annotation.Bean;

@SpringBootApplication
public class App {

    // 项目中不需要有多个 main 方法只需要有一个入口就可以了
    public static void main(String[] args) {
        // 主函数运行 springboot 项目
        SpringApplication.run(App.class, args);
    }

    // 通过方法完成 Servlet 组件的注册
    @Bean
    public ServletRegistrationBean getServletRegistrationBean() {
        ServletRegistrationBean bean = new ServletRegistrationBean(new SecondServlet());
        bean.addUrlMappings("/second");
        return bean;
    }

}

整合Filter

　　过滤器：Filter 是 Servlet 技术中最实用的技术，Web开发人员通过 Filter 技术，对 web 服务器管理的所有 web 资源，例如：Jsp，Servlet，图片，HTML，CSS，JS等文件进行拦截，从而实现一些特殊的功能。例如实现 URL 级别的权限访问控制、过滤敏感词汇、压缩响应信息等一些高级功能。它主要用于对用户请求进行预处理，也可以对 HttpServletResponse 进行后处理。

　　使用 Filter 的完整流程：Filter 对用户请求进行预处理，接着将请求交给 Servlet 进行处理并生成响应，最后 Filter 再对服务器响应进行后处理。

方法一

　　通过注解扫描完成 Filter 组件的注册

　　编写FirstFilter.java

package com.springboot.filter;

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import java.io.IOException;

/*
    配置文件写法：
    <filter>
        <filter-name>FirstFilter</filter-name>
        <filter-class>com.springboot.filter.FirstFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>FirstFilter</filter-name>
        <url-pattern>/first</url-pattern>
    </filter-mapping>
 */
@WebFilter(filterName = "FirstFilter", urlPatterns = {"/first"})
public class FirstFilter implements Filter {

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {

    }

    @Override
    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain filterChain)
            throws IOException, ServletException {
        System.out.println("FirstFilter Begin");
        filterChain.doFilter(req, resp);
        System.out.println("FirstFilter End");
    }

    @Override
    public void destroy() {

    }

}

　　启动类App.java

package com.springboot;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.servlet.ServletComponentScan;

@SpringBootApplication
@ServletComponentScan
public class App {

    // 项目中不需要有多个 main 方法只需要有一个入口就可以了
    public static void main(String[] args) {
        // 主函数运行 springboot 项目
        SpringApplication.run(App.class, args);
    }

}

方法二

　　通过方法完成 Filter 组件的注册

　　编写SecondFilter.java

package com.springboot.filter;

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import java.io.IOException;

@WebFilter(filterName = "SecondFilter", urlPatterns = {"/second"})
public class SecondFilter implements Filter {

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {

    }

    @Override
    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain filterChain)
            throws IOException, ServletException {
        System.out.println("SecondFilter Begin");
        filterChain.doFilter(req, resp);
        System.out.println("SecondFilter End");
    }

    @Override
    public void destroy() {

    }

}

　　启动类App.java

package com.springboot;

import com.springboot.filter.SecondFilter;
import com.springboot.servlet.SecondServlet;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.context.annotation.Bean;

@SpringBootApplication
public class App {

    // 项目中不需要有多个 main 方法只需要有一个入口就可以了
    public static void main(String[] args) {
        // 主函数运行 springboot 项目
        SpringApplication.run(App.class, args);
    }

    // 通过方法完成 Servlet 组件的注册
    @Bean
    public ServletRegistrationBean getServletRegistrationBean() {
        ServletRegistrationBean bean = new ServletRegistrationBean(new SecondServlet());
        bean.addUrlMappings("/second");
        return bean;
    }

    // 通过方法完成 Filter 组件的注册
    @Bean
    public FilterRegistrationBean getFilterRegistrationBean() {
        FilterRegistrationBean bean = new FilterRegistrationBean(new SecondFilter());
        bean.addUrlPatterns("/second");
        return bean;
    }

}

整合Listener

　　Servlet 的监听器 Listener 实现了 javax.servlet.ServletContextListener 接口的服务器端程序，它随 web应用的启动而启动，只初始化一次，随 web 应用的停止而销毁。主要作用是： 做一些初始化的内容添加工作、设置一些基本的内容、比如一些参数或者是一些固定的对象等等。

方法一

　　通过注解扫描完成 Listener 组件的注册

　　编写FirstListener.java

package com.springboot.listener;

import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import javax.servlet.annotation.WebListener;

/*
    配置文件写法：
    <listener>
        <listener-class>com.springboot.listener.FirstListener</listener-class>
    </listener>
 */
@WebListener
public class FirstListener implements ServletContextListener {

    @Override
    public void contextInitialized(ServletContextEvent servletContextEvent) {
        System.out.println("FirstListener Init");
    }

    @Override
    public void contextDestroyed(ServletContextEvent servletContextEvent) {

    }

}

? 启动类App.java

package com.springboot;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.servlet.ServletComponentScan;

@SpringBootApplication
@ServletComponentScan
public class App {

    // 项目中不需要有多个 main 方法只需要有一个入口就可以了
    public static void main(String[] args) {
        // 主函数运行 springboot 项目
        SpringApplication.run(App.class, args);
    }

}

方法二

　　通过方法完成 Listener 组件注册

　　编写SecondListener.java

package com.springboot.listener;

import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import javax.servlet.annotation.WebListener;

@WebListener
public class SecondListener implements ServletContextListener {

    @Override
    public void contextInitialized(ServletContextEvent servletContextEvent) {
        System.out.println("SecondListener Init");
    }

    @Override
    public void contextDestroyed(ServletContextEvent servletContextEvent) {

    }

}

　　启动类App.java

package com.springboot;

import com.springboot.listener.SecondListener;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.servlet.ServletListenerRegistrationBean;
import org.springframework.context.annotation.Bean;

@SpringBootApplication
public class App {

    // 项目中不需要有多个 main 方法只需要有一个入口就可以了
    public static void main(String[] args) {
        // 主函数运行 springboot 项目
        SpringApplication.run(App.class, args);
    }

    // 通过方法完成 Listener 组件注册
    @Bean
    public ServletListenerRegistrationBean<SecondListener> getServletListenerRegistrationBean() {
        return new ServletListenerRegistrationBean(new SecondListener());
    }

}

访问静态资源

static目录

　　在我们开发web应用的时候，需要引用大量的js、css、图片等静态资源。

　　Spring Boot 默认提供静态资源目录位置需要置于 classpath 下，目录名需符合如下规则：

　　　/static

　　　/public

　　　/resources

　　　/META-INF/resources

　　比如：

　　　启动项目后，位于 static 下的资源直接访问，路径里无需添加 /static

　　　如果 /static下还有文件夹需要添加对应路径访问

　　访问：http://localhost:8080/spring-boot.svg

　　demo.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>资源访问</title>
</head>
<body>
    <p>资源访问</p>
    <img src="images/java.jpg">
</body>
</html>

　　访问：http://localhost:8080/demo.html

ServletContext目录

　　在 src/main/webapp 下，目录名称必须是 webapp

　　demo.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>资源访问</title>
</head>
<body>
    <p>资源访问</p>
    <img src="../images/spring-boot.svg">
</body>
</html>

　　访问：http://localhost:8080/html/demo.html

文件上传

　　Spring MVC 通过 MultipartResolver（多部件解析器）对象实现对文件上传的支持。

　　MultipartResolver 是一个接口对象，需要通过它的实现类 CommonsMultipartResolver 来完成文件的上传工作。在 Spring Boot 中又是如何来完成的，我们一起学习一下。

　　FileController.java

package com.springboot.controller;

import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletRequest;
import java.io.File;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

@RestController
@RequestMapping("/file")
public class FileController {

    /**
     * 文件上传
     *
     * @param fileName
     * @param request
     * @return
     */
    @PostMapping("/upload")
    public Map<String, Object> fileUpload(MultipartFile fileName,
                                          HttpServletRequest request) {
        try {
            // 获取文件名
            System.out.println("文件名：" + fileName.getOriginalFilename());
            // 将文件保存至当前项目 src/main/upload 文件夹
            String baseDir = System.getProperty("user.dir") + "/src/main/upload/";
            fileName.transferTo(new File(baseDir + fileName.getOriginalFilename()));
        } catch (IOException e) {
            e.printStackTrace();
        }

        Map<String, Object> map = new HashMap<>();
        map.put("message", "success");
        return map;
    }

}

　　resources/static/fileUpload.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>文件上传</title>
</head>
<body>
    <form action="file/upload" method="post" enctype="multipart/form-data">
        文件上传：<input type="file" name="fileName"/>
        <input type="submit" value="上传"/>
    </form>
</body>
</html>

　　启动类App.java

package com.springboot;

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

@SpringBootApplication
public class App {

    // 项目中不需要有多个 main 方法只需要有一个入口就可以了
    public static void main(String[] args) {
        // 主函数运行 springboot 项目
        SpringApplication.run(App.class, args);
    }

}

　　演示效果：

设置上传文件大小的默认值

　　Spring 限制了文件上传的大小值，默认是10MB，需要通过配置文件设置，

　　在 resources 根目录下添加一个 Spring Boot 的配置文件 application.properties。

　　resources/application.properties

# 设置单个上传文件的大小
spring.http.multipart.max-file-size=200MB
# 设置一次请求上传文件的总容量
spring.http.multipart.max-request-size=200MB

文件下载

　　本文基于简单的功能实现，编写 Get 请求方法，将刚才上传的文件进行下载。

　　FileController.java

package com.springboot.controller;

import org.apache.tomcat.util.http.fileupload.IOUtils;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.*;
import java.util.HashMap;
import java.util.Map;

@RestController
@RequestMapping("/file")
public class FileController {

    /**
     * 文件上传
     *
     * @param fileName
     * @param request
     * @return
     */
    @PostMapping("/upload")
    public Map<String, Object> fileUpload(MultipartFile fileName,
                                          HttpServletRequest request) {
        ...
    }

    /**
     * 文件下载
     *
     * @param fileName
     * @param request
     * @param response
     */
    @GetMapping("/download")
    public void fileDownload(String fileName,
                             HttpServletRequest request,
                             HttpServletResponse response) {
        // 获取文件存储路径
        String baseDir = System.getProperty("user.dir") + "/src/main/upload/";
        // 读取文件，声明输出流
        try (InputStream is = new FileInputStream(new File(baseDir, fileName));
             OutputStream os = response.getOutputStream()) {
            // 设置响应数据类型
            response.setContentType("application/x-download");
            response.addHeader("Content-Disposition", "attchment;filename=" + fileName);
            // 复制写出文件
            IOUtils.copy(is, os);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

　　演示效果：

　　??本章节到这里就结束了，喜欢的话就点赞??加转发??吧，我们下章节再见??。

原文地址：https://www.cnblogs.com/5Dylan/p/springboot-web.html

时间： 2024-12-08 19:22:06

Spring Boot 整合 Web 开发的相关文章

Spring Boot 整合web层之JSON的使用

Spring Boot对web层进行了一系列的自动化配置,只需要引入web依赖,零配置,就可以直接使用spring  mvc 里面的东西,这篇看一下它对json的自动化配置: 创建一个web项目,勾选web的依赖,就可以看到依赖里面引入了json 在前后端分离的项目中,前后端的交互是通过json格式进行的.那么在Spring Boot中如何使用呢? 我们先看一个消息转化工具(HttpMessageConverter),所用的json生成都离不开它,它的作用: 1.将服务端返回的对象序列化成JSO

Spring Boot的web开发

Web开发的自动配置类:org.springframework.boot.autoconfigure.web.WebMvcAutoConfiguration 1.1. 自动配置的ViewResolver 视图的配置mvcProperties对象中: org.springframework.boot.autoconfigure.web.WebMvcProperties.View 1.2. 自动配置静态资源 1.2.1.   进入规则为 / 如果进入SpringMVC的规则为/时,Spring Bo

Spring Boot 05 —— web开发案例

Spring Boot 的一些坑 https://www.jianshu.com/p/3494c84b4be3 国际化: 1)设置首页: 方法1:在controller添加一个请求 @RequestMapping({"/","index.html"}) public String index(){ return "index.html"; } 方法2:设置配置文件  :WebMvcConfigurer  的  addViewControllers

spring boot框架学习6-spring boot的web开发(2)

本章节主要内容: 通过前面的学习,我们了解并快速完成了spring boot第一个应用.spring boot企业级框架,那么spring boot怎么读取静态资源?如js文件夹,css文件以及png/jpg图片呢?怎么自定义消息转换器呢?怎么自定义spring mvc的配置呢?这些我们在公司都需要用的.这些怎么解决呢?在接下来的小节详细讲解这些.好了,现在开启spring boot的web开发第一节 本节主要: 1:InternalResourceViewResolver讲解 2:自动配置静态

spring boot框架学习7-spring boot的web开发(3)-自定义消息转换器

本章节主要内容: 通过前面的学习,我们了解并快速完成了spring boot第一个应用.spring boot企业级框架,那么spring boot怎么读取静态资源?如js文件夹,css文件以及png/jpg图片呢?怎么自定义消息转换器呢?怎么自定义spring mvc的配置呢?这些我们在公司都需要用的.这些怎么解决呢?在接下来的小节详细讲解这些.好了,现在开启spring boot的web开发第一节 本节主要: 1:自定义消息转换器 本文是<凯哥陪你学系列-框架学习之spring boot框架

Spring Boot 整合JDBC 实现后端项目开发

一.前言 前后端分离开发是将项目开发工作前后端交互工作拆分,使前端开发人员能够专注于页面开发或APP 开发,后端开发人员专注与接口开发.业务逻辑开发. 此处开发后端项目,给前端或者APP 端提供接口.不涉及复杂的业务逻辑,通过简单的增删改查来演示后端开发项目. 环境介绍: 开发工具:IDEA JDK: 1.7 及以上 Spring Boot: 2.0 及以上 Maven: 3.0 及以上 二.新建Spring Boot 项目 通过功能菜单File - New - Project 新建Spring

JAVAWEB开发之Spring详解之——Spring的入门以及IOC容器装配Bean(xml和注解的方式)、Spring整合web开发、整合Junit4测试

Spring框架学习路线 Spring的IOC Spring的AOP,AspectJ Spring的事务管理,三大框架的整合 Spring框架概述 什么是Spring? Spring是分层的JavaSE/EE full-stack(一站式)轻量级开源框架. 所谓分层: SUN提供的EE的三层结构:web层.业务层.数据访问层(也称持久层,集成层). Struts2是web层基于MVC设计模式框架. Hibernate是持久的一个ORM的框架. 所谓一站式:Spring框架有对三层的每层解决方案.

Spring整合web开发(6)

正常整合Servlet和Spring没有问题的但是每次执行Servlet的时候加载Spring配置,加载Spring环境. 解决办法:在Servlet的init方法中加载Spring配置文件? 当前这个Servlet可以使用,但是其他的Servlet的用不了了!!! 将加载的信息内容放到ServletContext中.ServletContext对象时全局的对象.服务器启动的时候创建的.在创建ServletContext的时候就加载Spring的环境. ServletContextListene

Spring boot整合jsp

这几天在集中学习Spring boot+Shiro框架,因为之前view层用jsp比较多,所以想在spring boot中配置jsp,但是spring boot官方不推荐使用jsp,因为jsp相对于一些模板引擎,性能都比较低,官方推荐使用thymeleaf,但是Spring boot整合jsp的过程已经完成,在这里记录一下. 这篇博文是在LZ上篇文章spring boot+mybatis整合基础上写的,开发工具仍然是Intellij idea.这篇文章的重点是Intellij idea的设置,否