【Spring Boot系列学习】13.Web篇应用基础(热部署、打包方式、Servlet、过滤器、监听器、拦截器、AOP切面等)

最新推荐文章于 2024-09-10 09:42:49 发布

米殇粟

最新推荐文章于 2024-09-10 09:42:49 发布

阅读量252

点赞数

分类专栏： SpringBoot springboot系列学习文章标签：热部署类型转换器 Servlet filter、interceptor、listener AOP切面

本文链接：https://blog.csdn.net/jianmingxie/article/details/88173749

版权

SpringBoot 同时被 2 个专栏收录

18 篇文章 0 订阅

订阅专栏

springboot系列学习

16 篇文章 0 订阅

订阅专栏

六、Servlet、过滤器、监听器另外注册方式

一、热部署

当我们修改文件和创建文件时，都需要重新启动项目。这样频繁的操作很浪费时间，配置热部署可以让项目自动加载变化的文件，省去的手动操作。

其主要操作是在pom.xml配置文件中添加如下依赖

<!-- 热部署 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
    <optional>true</optional>
    <scope>true</scope>
</dependency>

<!-- 文件后面添加 -->
<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <configuration>
                <!-- 没有该配置，devtools 不生效 -->
                <fork>true</fork>
            </configuration>
        </plugin>
    </plugins>
</build>

此时，启动项目，修改项目中的信息，控制台会打印重新加载的相关信息。

二、打包运行

项目开发完成后，打包的形式有两种：jar 和 war。

1.打包成可执行的jar

通过 maven 执行 package 命令后，会生成 jar 包，且该 jar 包会内置了 tomcat 容器，因此我们可以通过命令行执行 java -jar 项目jar 就可以运行项目。

2.打包成部署的 war 包

1).修改启动类

让 SpringbootApplication 类继承 SpringBootServletInitializer 并重写 configure 方法

@SpringBootApplication
public class SpringbootApplication extends SpringBootServletInitializer {
    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
        return application.sources(SpringbootApplication.class);
    }
    public static void main(String[] args) {
        SpringApplication.run(SpringbootApplication.class, args);
    }
}

2).修改配置文件pom.xml

<packaging>war</packaging>

3).执行打包命令，打包成功，放入tomcat下运行即可。

三、自定义Servlet

1.编写Servlet

public class ServletTest extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doPost(req, resp);
    }
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.setContentType("text/html;charset=utf-8");
        resp.getWriter().write("自定义 Servlet");
    }    
}

2.注册Servlet

新建类webConfig配置类，并注册Servlet

@Configuration
public class WebConfig {    
    @Bean
    public ServletRegistrationBean servletRegistrationBean(){
        return new ServletRegistrationBean(new ServletTest(),"/servletTest");
    }
}

另一种注册配置方式见【六、Servlet、过滤器、监听器另外注册方式】

3.启动访问

四、过滤器(自定义及第三方)

1.编写过滤器

public class TimeFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("--------初始化过滤器----------");
    }
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        long startTime = System.currentTimeMillis();
        filterChain.doFilter();
        System.out.println("filter 耗时：" + (System.currentTimeMillis() - startTime));
    }
    @Override
    public void destroy() {
        System.out.println("--------销毁过滤器----------");
    }
}

2.注册过滤器

要使该过滤器生效，有两种方式

1).在该过滤器头部添加注解@Component；

2).新建配置类webConfig，注册该过滤器。添加到过滤器链中

@Configuration
public class WebConfig {
    @Bean
    public FilterRegistrationBean timeFilter(){
        FilterRegistrationBean registrationBean = new FilterRegistrationBean();

        TimeFilter timeFilter = new TimeFilter();
        registrationBean.setFilter(timeFilter);
        List<String> urls = new ArrayList<>();
        urls.add("/*");
        registrationBean.setUrlPatterns(urls);
        return registrationBean;
    }
}

3).使用Servlet自带注解@WebFilter

①在filter类中添加注解@WebFilter；

②在springboot项目启动类中添加注解ServletComponentScan开启扫描Servlet注解。

4).另一种配置方式见【六、Servlet、过滤器、监听器另外注册方式】

3.启动服务

访问某一url，控制台输出

五、自定义监听器

1.编写监听器

public class ListenerTest implements ServletContextListener {
    @Override
    public void contextInitialized(ServletContextEvent sce) {
        System.out.println("监听器初始化。。。");
    }
    @Override
    public void contextDestroyed(ServletContextEvent sce) {
    }
}

2.注册监听器

新建配置类webConfig，注册监听器为Bean

@Configuration
public class WebConfig {
    @Bean
    public ServletListenerRegistrationBean<ListenerTest> servletListenerRegistrationBean(){
        return new ServletListenerRegistrationBean<>(new ListenerTest());
    }
}

3.启动服务测试结果

六、Servlet、过滤器、监听器另外注册方式

@SpringBootApplication
public class Springboot05SqlApplicationimplements ServletContextInitializer {
    
    @Override
    public void onStartup(ServletContext servletContext) throws ServletException {
        // 配置 Servlet
        servletContext.addServlet("servletTest",new ServletTest())
                      .addMapping("/servletTest");
        // 配置过滤器
        servletContext.addFilter("timeFilter",new TimeFilter())
                      .addMappingForUrlPatterns(EnumSet.of(DispatcherType.REQUEST),true,"/*");
        // 配置监听器
        servletContext.addListener(new ListenerTest());
    }

    public static void main(String[] args) {
        SpringApplication.run(Springboot05SqlApplication.class, args);
    }
}

七、拦截器

1.编写拦截器

//通过该注解让spring管理该拦截器的生命周期
@Component
public class TimeInterceptor implements HandlerInterceptor {
    @Override //根据请求信息判定是否需要拦截
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("========preHandle=========");
        System.out.println(((HandlerMethod)handler).getBean().getClass().getName());
        System.out.println(((HandlerMethod)handler).getMethod().getName());
        request.setAttribute("startTime", System.currentTimeMillis());
        return true;
    }
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable ModelAndView modelAndView) throws Exception {
        System.out.println("========postHandle=========");
        Long start = (Long) request.getAttribute("startTime");
        System.out.println("耗时:"+(System.currentTimeMillis() - start));
    }
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable Exception ex) throws Exception {
        System.out.println("========afterCompletion=========");
        Long start = (Long) request.getAttribute("startTime");
        System.out.println("耗时:"+(System.currentTimeMillis() - start));
        System.out.println(ex);
    }
}

2.注册拦截器

需要将拦截器注册到拦截器链中。

在spring boot1.x版本中，可以通过如下方式注册

@Configuration
public class WebConfig extends WebMvcConfigurerAdapter{
    @Autowired
    private TimeInterceptor timeInterceptor;
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(timeInterceptor);
    }
}

在spring boot2.x版本中，WebMvcConfigurerAdapter类被废弃，通过如下方式注册。将继承 WebMvcConfigurerAdapter换成实现 WebMvcConfigurer

@Configuration
public class WebConfig implement WebMvcConfigurer{
    @Autowired
    private TimeInterceptor timeInterceptor;
   
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(timeInterceptor);
    }
}

3.启动测试

访问某个controller下的方法，如

八、AOP 切面

1.添加依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

2.编写切面类

@Aspect
@Component
public class TimeAspect {
    public Object method(ProceedingJoinPoint point) throws Throwable{
        System.out.println("=====Aspect处理=======");
        Object[] args = point.getArgs();
        for (Object arg : args) {
            System.out.println("参数为:" + arg);
        }
        long start = System.currentTimeMillis();
        Object object = point.proceed();
        System.out.println("Aspect 耗时:" + (System.currentTimeMillis() - start));
        return object;
    }
}

3.启动测试，访问http://localhost:8080/fastjson/test

九、国际化

1.传统方式

1).编写国际化配置文件；
2).使用ResourceBundleMessageSource管理国际化资源文件；
3).在页面中使用fmt：message取出国际化内容

2.springboot方式

1).编写国际化配置文件
2).springboot 自动配置好了管理国际化资源的组件MessageSourceAutoConfigruation;
默认为类路径下的message.properties相关的文件
可在application.properties配置文件中指定名称，方式为

spring.messages.basename=路径.name

3).在thymeleaf页面中通过#{}的方式获取国际化的内容

3.语言切换

1).原理：http请求中获取国际化Locale(区域信息对象)，springboot中默认的LocaleResolver(区域信息解析器)

默认是根据请求头带来的区域信息获取Locale进行国际化，

2).具体实现

a.需要在页面中切换连接中携带指定语言的参数，如l=zh_CN；
b.需要实现一个区域信息解析器MyLocaleResolver,并将其注册进容器；

public class MyLocaleResolver implements LocaleResolver {
    @Override
    public Locale resolveLocale(HttpServletRequest httpServletRequest) {
        String lang = httpServletRequest.getParameter("l");
        Locale locale = Locale.getDefault();
        if(!StringUtils.isEmpty(lang)){
            String[] langs = lang.split("_");
            locale = new Locale(langs[0],langs[1]);
        }
        return locale;
    }
    @Override
    public void setLocale(HttpServletRequest httpServletRequest, @Nullable HttpServletResponse httpServletResponse, @Nullable Locale locale) {
    }
}

@Configuration
public class myconfig {
    @Bean//注册组件到容器中
    public LocaleResolver myLocaleResolver(){
        return new MyLocaleResolver();
    }
}

十、总结

1.拦截器和过滤器的区别

①过滤器是servlet规范规定的，只能用于web程序中，而拦截器是在spring容器中，它不依赖servlet容器。
②拦截器属于Spring中的概念,可以在拦截器中使用任何Spring中的Bean信息，而过滤器不属于Spring中的概念点，所以过滤器不行.
③过滤器可以拦截几乎所有的请求(包含对静态资源的请求)，而拦截器只拦截Spring中的请求处理器(不拦截静态资源请求)
④不管是过滤器还是拦截器都是AOP编程思想的体现。
⑤过滤器的执行顺序在拦截器之前

参考：https://www.cnblogs.com/moonlightL/p/7891806.html