SpringBoot 6 使用监听器，拦截器，Servlet、项目的编码字符集，logback日志

1.获取启动后的Spring容器

方式一:

@SpringBootApplication
public class Application {
      public static void main(String[] args) {
 /**
 * SpringBoot 程序启动后，返回值是 ConfigurableApplicationContext，它也是一个Spring 容器对象
 * 其它相当于原来 Spring 中启动容器 ClassPathXmlApplicationContext context =new         ClassPathXmlApplicationContext("");
 */
 //获取 SpringBoot 程序启动后的 Spring 容器
 ConfigurableApplicationContext context =SpringApplication.run(Application.class, args);
 //从 Spring 容器中获取指定 bean 的对象
 UserService userService = (UserService)context.getBean("userServiceImpl");
 //调用业务 bean 的方法
 String sayHello = userService.sayHello();
 System.out.println(sayHello);
 }
}

方式二:

​ 将原有 Application 类的@SpringBootApplication 注解注释掉，复制一 个新的 Application 取名为 Application2，实现 CommandLineRunner 接 口

@SpringBootApplication
public class Application2 implements CommandLineRunner {
 //第二步：通过容器获取 bean，并注入给 userService
 @Autowired
 private UserService userService;
    
 public static void main(String[] args) {
 //第一步：SpringBoot 的启动程序，会初始化 spring 容器
 SpringApplication.run(Application2.class,args);
      }
 //覆盖接口中的 run 方法
 @Override
 public void run(String... args) throws Exception {
 //第三步：容器启动后调用 run 方法，在该方法中调用业务方法
 String sayHello = userService.sayHello();
 System.out.println(sayHello);
       }
 }

修改Banner---->banner.txt

---

1.SpringBoot 中使用拦截器

1.拦截器知识的回顾

• 拦截器的作用：可以在方法到达控制器之前进行校验。

• 拦截器的实现：

• 1.创建一个类，实现HandlerInterceptor

• 2.重写接口中的3个方法

  • preHandle：在方法控制器执行之前，先拦截。
    • 返回false代表，拦截不执行控制器。
    • 返回true，代表继续向下执行，执行控制器操作。
  • postHandle：在方法控制器执行之后，执行。
  • afterCompletion：页面加载完成后，执行。

• 作用：是否已经登录

2.应用

用户在第一次登陆的时候没有session，需要第二次登陆才有

1.Springboot.inteceptor

public class MyInterceptor implements HandlerInterceptor {

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

        //打印日志
        System.out.println("拦截器方法执行啦...preHandle");

        //判断当前用户是否已登录
        String user = (String) request.getSession().getAttribute("user");
        if(user == null ){
            //如果未登录，返回false
            System.out.println("用户未登录，请先登录");
            return false;

        }

        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        //打印日志
        System.out.println("拦截器方法执行啦...postHandle");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        //打印日志
        System.out.println("拦截器方法执行啦...afterCompletion");
    }
}

2.spring.config

@Configuration
public class MyConfiguration implements WebMvcConfigurer {
    /**
     * 重写添加拦截器的方法
     * @param registry
     */
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
 //拦截器的注册类
        registry.addInterceptor(new MyInterceptor()).  // 自定义拦截器添加
                addPathPatterns("/user/findAll").  //要拦截的路径
                excludePathPatterns("/user/login");   //要放行的路径
    } 
}

3.springboot.UserController

@RestController
@RequestMapping("/user")
public class UserController {
    /**
     * 未登录情况下可以访问
     * @return
     */
    @RequestMapping("/login")
    public Object login(HttpSession session){
        session.setAttribute("user","zhangsan");
        return "用户已登录";
    }
    /**
     * 登录请求下可以访问
     * @return
     */
    @RequestMapping("/findAll")
    public Object findAll(){

        List<Map<String,String>> list = new ArrayList<>();
        for(int i=0;i<10;i++){
            Map<String,String> map = new HashMap<>();

            map.put("id",i+"");
            map.put("name","zhangsan"+i);

            list.add(map);
        }
        return list;
    }
}

---

2.SpringBoot使用Servlet 用的少

1.导入servlet 支持坐标

   <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
        </dependency>
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>javax.servlet.jsp-api</artifactId>
            <version>2.3.1</version>
        </dependency>

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

2.方式一：在启动类上加注解

1.启动类：

/*
 * 扫描web组件注解
 *      可以扫描servlet、filter、listener
 */
@ServletComponentScan(basePackages = "cn.ccut.springboot.web")
public class Application {

2.Controller

@WebFilter(urlPatterns = "/springboot/filter")
public class MyFilter extends HttpFilter {

@WebServlet(urlPatterns = "/myServlet")
public class MyServlet extends HttpServlet {

    //Controller 里面的内容不变，

---

3.方式二:注册的方式

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

    
    //----------------方式2：通过注册Bean的方法注册web组件-----------------
    @Bean  //就自动添加到当前容器了
    public ServletRegistrationBean getServletRegistrationBean(){
        //参数1，初始化的servlet对象
        //参数2，urlPatterns
        ServletRegistrationBean srb = new ServletRegistrationBean(new MyServlet(),"/springboot/servlet");
        
        //两种方式是一样的
//        srb.setServlet(new MyServlet());
//        srb.addUrlMappings("/springboot/servlet");
        return srb;
    }
    
    
    
    //拦截器
      @Bean
    public FilterRegistrationBean getFilterRegistrationBean(){
        //参数1，初始化的Filter对象
        //参数2，urlPatterns
        FilterRegistrationBean frb = new FilterRegistrationBean();

        frb.setFilter(new MyFilter());
        frb.addUrlPatterns("/myFilter");
        return frb;
    }  
}

3.设置项目的编码字符集

• 实现中文乱码过滤器

1.原先是通过在web.xml上加注解

  <!--解决post乱码的过滤器-->
    <filter>
        <filter-name>characterEncodingFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>UTF-8</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>characterEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

2.现在的:

1.方式一:启动器类里

@ServletComponentScan(basePackages = "cn.ccut.springboot.web")
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    } 
 
    
 @Bean(name = "characterEncodingFilter")  // 让其注册容器不重名
    public FilterRegistrationBean getCharacterEncodingFilterBean(){
        //参数1，初始化的servlet对象
        //参数2，urlPatterns
        FilterRegistrationBean frb = new FilterRegistrationBean();

        CharacterEncodingFilter characterEncodingFilter = new CharacterEncodingFilter();
        characterEncodingFilter.setEncoding("UTF-8");

        //强制使用
        characterEncodingFilter.setForceEncoding(true);
        //<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        frb.setFilter(characterEncodingFilter);
        //<url-pattern>/*</url-pattern>
        frb.addUrlPatterns("/*");

        return frb;
    }

2.方式二:通过配置文件

#方式2：#设置请求响应的字符编码
spring.http.encoding.charset=utf-8
spring.http.encoding.enabled=true
spring.http.encoding.force=true

3.linux中运行jar包

linux

可以将该命令封装到一个 Linux 的一个 shell 脚本中（上线部署）
1.写一个 shell 脚本(run.sh)：
#!/bin/sh
java -jar xxx.jar
2.赋权限 chmod 777 run.sh
3.启动 shell 脚本： ./run.sh

3.SpringBoot 集成logback日志

1.新建项目勾选web

2.导入依赖

   <!--MyBatis集成 SpringBoot框架的起步依赖-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.0.0</version>
        </dependency>

        <!--连接 MySQL 的驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

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

3.logback-spring.xml 放到resources 里面

<?xml version="1.0" encoding="UTF-8"?>
<configuration scan="true" scanPeriod="10 seconds">
<!--    将日志信息打印到控制台上

    TRACE < DEBUG(开发调试) < INFO（环境运行） < WARN < ERROR

-->
    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <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>D:/log/p2p/p2p-web.log</File>
        <encoder>
            <pattern>%date [%-5p] %thread %logger{60} [%file : %line] %msg%n</pattern>
        </encoder>
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>D:/log/p2p/p2p-web.log.%d{yyyy-MM-dd}.log</fileNamePattern>
            <maxHistory>30</maxHistory>
        </rollingPolicy>
    </appender>
<!--    SQL日志信息-->
    <logger name="cn.ccut.springboot.mapper" level="DEBUG"/>

    <root level="INFO">
        <appender-ref ref="CONSOLE"/>
        <appender-ref ref="FILE"/>
    </root>
</configuration>

4.使用：

@RestController
@RequestMapping("/user")

@Slf4j

public class UserController {
    @Autowired
    private UserService userService;

    @RequestMapping("/findAll")
    public Object findAll(){
        List<Object> userList = userService.findAll();
        System.out.println("userList:"+userList);
        log.debug("userList"+userList);  //使用
        return userList;
    }

}

5.lombok的使用

@Data  让当前的实体类，自动生成get set toString hashCode等方法