SpringBoot第四谈（springboot使用拦截器、Servlet、过滤器Filter、Spring Boot 项目配置字符编码、SpringBoot打包部署、集成Logback日志）

本人是一名物联网工程专业的学生，即将进入大三，写博客即是为了记录自己的学习历程，又希望能够帮助到很多和自己一样处于起步阶段的萌新。
临渊羡鱼，不如退而结网。一起加油！
博客主页:https://blog.csdn.net/qq_44895397

SpringBoot使用拦截器

1、定义一个拦截器，实现HandlerInterceptor接口

public class StudentHandler implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request,
                             HttpServletResponse response,
                             Object handler) throws Exception {

        Object user = request.getSession().getAttribute("user");
        if (null == user||"".equals(user)){
            response.sendRedirect("/student/error");
            return false;//已经登陆过
        }else {
            return true;//没有登陆
        }
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {

    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {

    }
}

2、创建一个配置类

相当于在springmvc配置文件中使用mvc:interceptor标签

• 创 建 一 个 配 置 类 InterceptorConfig ， 并 实 现WebMvcConfigurer 接口， 覆盖接口中的 addInterceptors 方法，并为该配置类添加@Configuration 注解，标注此类为一个配置类，让 Spring Boot 扫描到，
• 这里的操作就相当于 SpringMVC 的注册拦截器 ，@Configuration 就相当于一个 applicationContext-mvc.xml

@Configuration//配置类
public class StudetnConfig implements WebMvcConfigurer {

    /**
     * addInterceptor()增加拦截器对象（相当于之前的mvc:interceptor里面的声明拦截器对象）
     * addPathPatterns()：增加拦截请求路径（拦截）
     * excludePathPatterns()：排除拦截请求路径（对这里面的请求路径不拦截）
     * @param registry：拦截器注册类对象
     */
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        String [] addPathPatterns = {"/student/*"};//增加拦截路径
        String [] excludePathPatterns = {"/student/login","/student/anytime","/student/error"};//额外路径，不进行拦截
        registry.addInterceptor(new StudentHandler()).
                addPathPatterns(addPathPatterns).
                excludePathPatterns(excludePathPatterns);
    }
}

SpringBoot使用Servlet

1、第一种方式：使用注解

• a、定义一个类继承HttpServlet，重写doPost、doGet方法

• b、在该类上添加注解@WebServlet，定义请求路径

• c、在启动类上添加扫描servlet注解的注解：@ServletComponentScan

定义一个类继承HttpServlet，重写doPost、doGet方法

@WebServlet(urlPatterns = "/userservlet")//urlPatterns请求路径
public class UserServlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.getWriter().println("servlet");
        resp.getWriter().flush();
        resp.getWriter().close();
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req,resp);
    }
}

c、在启动类上添加扫描servlet注解的注解：@ServletComponentScan

@ServletComponentScan(basePackages = "com.yky.springboot.servlet")

第二种方式：使用配置类

1. servlet类
   
2. 配置类：
   声明servlet对象，请求路径
   

/**
* 配置类
*/
@Configuration
public class servletConfiger {
			
	/**
	* @Bean 相当于
	* ServletRegistrationBean(声明servlet，请求路径)
	*/
	@Bean
	public ServletRegistrationBean userServletRegistrationBean() {
		 ServletRegistrationBean servletRegistrationBean = new ServletRegistrationBean(new UserServlet(), "/userServlet");
		return servletRegistrationBean;
		}
}

SpringBoot使用过滤器Filter

方式一：使用注解

1）创建过滤器类，实现Filter接口，在类上添加@WebFilter(urlPatterns = “/userservlet”)

@WebFilter(urlPatterns = "/user/*")
public class UserFilter implements Filter{
    @Override
    public void doFilter(ServletRequest servletRequest,
                         ServletResponse servletResponse,
                         FilterChain filterChain) throws IOException, ServletException {
        System.out.println("++++==你好==++++");
        filterChain.doFilter(servletRequest,servletResponse);
    }
}

2）在启动类上添加@ServletComponentScan，并且指定包

通过 Spring Boot 的配置类实现

1）创建一个普通的 Filter

2）编写一个 Spring Boot 的配置类，在该类中注册 Filter

@Configuration //定义为配置类
public class FilterConfig {
 @Bean
 public FilterRegistrationBean myFilterRegistration() {
 //注册过滤器
 FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean(new MyFilter());
 //添加过滤路径
 filterRegistrationBean.addUrlPatterns("/springboot/*","/user/*");
 return filterRegistrationBean;
	 } 
 }

Spring Boot 项目配置字符编码

方式一 使用传统的 Spring 提供的字符编码过滤器

1. 创建一个 Servlet
2. 创建配置类 userfilterConfig，配置过滤字符编码的信息
3. 在核心配置文件关闭springboot默认的字符编码

1、创建一个 Servlet

@WebServlet(urlPatterns = "/user/servlet")
public class StudentServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.getWriter().print("爱敲代码的小游子，加油！");
        //设置浏览器编码格式
        resp.setContentType("text/html;character=utf-8");
        resp.getWriter().flush();
        resp.getWriter().close();
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
       doGet(req, resp);
    }
}

2、创建配置类 userfilterConfig

@Configuration
public class userfilter {
    
    @Bean
    public FilterRegistrationBean characterFilterRegistration() {
        //设置字符编码过滤器
        //CharacterEncoding 是由 Spring 提供的一个字符编码过滤器，之前是配置在
        //web.xml 文件中
        CharacterEncodingFilter characterEncodingFilter = new
                CharacterEncodingFilter();
        //强制使用指定字符编码
        characterEncodingFilter.setForceEncoding(true);
        //设置指定字符编码
        characterEncodingFilter.setEncoding("UTF-8");
        //创建过滤器注册 bean
        FilterRegistrationBean filterRegistrationBean = new
                FilterRegistrationBean();
        //设置字符编码过滤器
        filterRegistrationBean.setFilter(characterEncodingFilter);
        //设置字符编码过滤器路径
        filterRegistrationBean.addUrlPatterns("/*");
        return filterRegistrationBean;
    }
}

3、在核心配置文件关闭springboot默认的字符编码

#关闭spring boot的http字符编码设置
server.servlet.encoding.enabled=false

第二种方式：在核心配置文件配置字符编码信息

1、servlet内设置浏览器字符编码

//设置浏览器编码
		 resp.setContentType("text/htlm;character=utf-8");

2、核心配置文件设置请求响应字符编码

server.servlet.encoding.charset=utf-8
	server.servlet.encoding.enabled=true
	server.servlet.encoding.force=true

SpringBoot打包部署

Spring Boot 程序 war 包部署

1、程序入口类需扩展继承SpringBootServletInitializer类并覆盖 configure 方法

@SpringBootApplication
@ServletComponentScan(basePackages = "com.yky.springboot.servlet")
public class Springbootdemo09Application extends SpringBootServletInitializer {

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

	@Override
	protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {

		//参数为当前spring boot启动类
		return builder.sources(Springbootdemo09Application.class);

	}
}

2、在 pom.xml 中添加（修改）打包方式为 war

<packaging>war</packaging>

3、在 pom.xml 中配置 springboot 打包的插件(默认自动加)

<!--SpringBoot 打包插件-->
<plugin>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-maven-plugin</artifactId>
</plugin>

4、在 pom.xml 中配置将配置文件编译到类路径

<resource>
	 <!--源文件夹-->
		 <directory>src/main/webapp</directory>
		 <!--目标文件夹-->
		 <targetPath>META-INF/resources</targetPath>
	 <!--包含的文件-->
	 <includes>
		 <include>**/*.*
	 
	
	
	
		 src/main/java
	 
		 **/*.xml</include>
	 </includes>
	</resource>
	<!--src/main/resources 下的所有配置文件编译到 classes 下面去-->
	<resource>
		 <directory>src/main/resources</directory>
		 <includes>
		 	<include>**/*.*
	 

5、在 pom.xml 的 build 标签下通过 finalName 指定打 war包的名字

<!--指定打 war 包的名字-->
<finalName>springboot</finalName>

6、通过 Maven package 命令打 war 包到 target 目录下

7、将 target 目录下生成的 war 包拷贝到 tomcat 的 webapps目录，并启动 tomcat

Spring Boot 程序打 Jar 包与运行

通过 java 命令执行 jar 包，相当于启动内嵌 tomcat

在核心配置文件中配置的tomcat信息依然有效

SpringBoot集成logback日志

• Spring Boot 官方推荐优先使用带有 -spring 的文件名作为你的日志配置（如使用logback-spring.xml ，而不是logback.xml），命名为 logback-spring.xml 的日志配置文件。
• 默认的命名规则，并且放在 src/main/resources 下如果你即想完全掌控日志配置，但又不想用 logback.xml 作为 Logback 配置的名字application.yml 可以通过 logging.config 属性指定自定义的名字：

logging.config=classpath:logging-config.xml

针对 DAO 的包进行 DEBUG 日志设置：

<logger name="com.abc.springboot.mapper" level="DEBUG" />

代码里打印日志

1、在 pom.xml 中添加依赖

<!--@Slf4j 自动化日志对象-->
<dependency>
 <groupId>org.projectlombok</groupId>
 <artifactId>lombok</artifactId>
 <version>1.18.2</version>
</dependency>

2、 logback-spring.xml

日志级别从低到高分为 TRACE < DEBUG < INFO < WARN < ERROR < FATAL

<?xml version="1.0" encoding="UTF-8"?>
<!-- 日志级别从低到高分为 TRACE < DEBUG < INFO < WARN < ERROR < FATAL，如果设置为 WARN，则低于 WARN 的信息都不会输出 -->
<!-- scan:当此属性设置为 true 时，配置文件如果发生改变，将会被重新加载，默认值为
true -->
<!-- scanPeriod:设置监测配置文件是否有修改的时间间隔，如果没有给出时间单位，默认
单位是毫秒。当 scan 为 true 时，此属性生效。默认的时间间隔为 1 分钟。 -->
<!-- debug:当此属性设置为 true 时，将打印出 logback 内部日志信息，实时查看 logback
运行状态。默认值为 false。通常不打印 -->
<configuration scan="true" scanPeriod="10 seconds">
 <!--输出到控制台-->
 <appender name="CONSOLE" 
class="ch.qos.logback.core.ConsoleAppender">
 <!--此日志 appender 是为开发使用，只配置最底级别，控制台输出的日志级别是大
于或等于此级别的日志信息-->
 <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
 <level>debug</level>
 </filter>
 <encoder>
 <Pattern>%date [%-5p] [%thread] %logger{60} [%file : %line] %msg%n</Pattern>
 <!-- 设置字符集 -->
 <charset>UTF-8</charset>
 </encoder>
 </appender>
 <appender name="FILE" 
class="ch.qos.logback.core.rolling.RollingFileAppender">
 <!--<File>/home/log/stdout.log</File>-->
 <File>D:/log/stdout.log</File>
 <encoder>
 <pattern>%date [%-5p] %thread %logger{60} [%file : %line] %msg%n</pattern>
 </encoder>
 <rollingPolicy 
class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
 <!-- 添加.gz 历史日志会启用压缩 大大缩小日志文件所占空间 -->
 
<!--<fileNamePattern>/home/log/stdout.log.%d{yyyy-MM-dd}.log</fileNam
ePattern>-->
 
	<fileNamePattern>D:/log/stdout.log.%d{yyyy-MM-dd}.log</fileNamePatter
n>
	 <maxHistory>30</maxHistory><!-- 保留 30 天日志 -->
 </rollingPolicy>
 </appender>
	 <logger name="com.abc.springboot.mapper" level="DEBUG" />
 <root level="INFO">
	 <appender-ref ref="CONSOLE"/>
	 <appender-ref ref="FILE"/>
 </root>
</configuration>