springboot系列十四: 注入Servlet, Filter, Listener + 内置Tomcat配置和切换 + 数据库操作

注入Servlet, Filter, Listener

官方文档

spring-boot-reference.pdf

基本介绍

1.考虑到实际需求, SpringBoot 可以将 Servlet, Filter, Listener 注入 Spring 容器, 成为 SpringBean.

2.即 SpringBoot 开放了和原生 WEB 组件 (Servlet, Filter, Listener) 的兼容.

使用注解方式注入

1.创建src/main/java/com/zzw/springboot/servlet/Servlet_.java

/**
 * 1.通过继承 HttpServlet 开发原生的Servlet
 * 2.@WebServlet标识将 Servlet_ 对象/bean注入到容器
 * 3.(urlPatterns = {"/Servlet_"}) 对Servlet配置 url-pattern
 * 4.注入的原生的Servlet_, 不会被springboot的拦截器拦截
 */
@WebServlet(urlPatterns = {"/Servlet_1", "/Servlet_2"})
public class Servlet_ extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.getWriter().write("Servlet_");
    }
}

2.修改启动类 Application.java

//要求扫描com.zzw.springboot 包/及其子包下的原生方式注入的Servlet
@ServletComponentScan("com.zzw.springboot")
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        ApplicationContext ioc = SpringApplication.run(Application.class, args);
    }
}

3.测试 无需登录，不走拦截器

4.创建src/main/java/com/zzw/springboot/filter/Filter_.java

/**
 * 解读
 * 1.@WebFilter 表示Filter_ 是一个过滤器, 并注入容器
 * 2.urlPatterns = {"/css/*", "/images/*"} 当请求 /css/*目录的资源 或者 /images/*目录的资源 时, 会触发Filter_过滤器
 * 3.这里是直接放行后, 再经过拦截器, 拦截器是否拦截要根据拦截器的规则.
 */
@Slf4j
@WebFilter(urlPatterns = {"css/*", "images/*"})
public class Filter_ implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        log.info("-- Filter init() --");
    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("-- Filter doFilter() --");
        HttpServletRequest request = (HttpServletRequest) servletRequest;
        log.info("过滤器处理的uri={}", request.getRequestURI());
        filterChain.doFilter(servletRequest, servletResponse);//放行
    }

    @Override
    public void destroy() {
        log.info("-- Filter init() --");
    }
}

注意: 过滤器配置的urlPatterns也会经过SpringBoot拦截器. 为了看到效果, 请在拦截器配置中放行 /css/**.
在servlet中匹配路径全是 /*, 在SpringBoot中是 /**.

5.当前拦截器已经拦截 /css/*，当请求 localhost:8080/images/logo.png 时

由于拦截器不拦截 /images/**，所以当请求 localhost:8080/images/logo.png时，拦截器不会拦截

6.创建src/main/java/com/zzw/springboot/listener/Listener_.java

@Slf4j
@WebListener
public class Listener_ implements ServletContextListener {

    @Override
    public void contextInitialized(ServletContextEvent sce) {
        log.info("contextInitialized 项目初始化 OK");
    }

    @Override
    public void contextDestroyed(ServletContextEvent sce) {
        log.info("contextInitialized 项目销毁 ");
    }
}

7.测试容器销毁

@ServletComponentScan("com.zzw.springboot")
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        ApplicationContext ioc = SpringApplication.run(Application.class, args);
        ioc.stop();//测试项目销毁
    }
}

使用RegistrationBean方法注入

前提: 取消原来的注解. @WebServlet, @WebFilter, @WebListener, @ServletComponentScan

1.创建src/main/java/com/zzw/springboot/config/RegisterConfig_.java

/**
 * 1.@Configuration 表示这是一个配置类
 * 2.Full(proxyBeanMethods = true): (默认)保证每个@Bean方法被调用多少次返回的组件都是单例的, 是代理方法
 */
@Configuration(proxyBeanMethods = true)
public class RegisterConfig_ {

    //使用RegistrationBean方法注入Servlet
    @Bean
    public ServletRegistrationBean servlet_() {
        //创建原生的Servlet对象
        Servlet_ servlet = new Servlet_();
        //把servlet_对象关联到 ServletRegistrationBean对象
        //"/Servlet_1", "/Servlet_2" 就是注入的Servlet 的 url-patterns
        return new ServletRegistrationBean(servlet, "/Servlet_1", "/Servlet_2");
    }

	 //使用RegistrationBean方法注入Filter
    @Bean
    public FilterRegistrationBean filter_() {
        //创建原生的Filter对象
        Filter_ filter = new Filter_();
        FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean(filter);
        //设置filter的url-patterns
        filterRegistrationBean.setUrlPatterns(Arrays.asList("/css/*", "/images/logo.png"));
        return filterRegistrationBean;
    }

    //使用RegistrationBean方法注入Listener
    @Bean
    public ServletListenerRegistrationBean listener_() {
        //创建原生的Listener对象
        Listener_ listener = new Listener_();
        return new ServletListenerRegistrationBean(listener);
    }
}

2.证明 ServletRegistrationBean 和 原生Servlet_ 对象的关系.

3.测试

DispatcherServlet详解

1.请求Servlet时，不会到达DispatcherServlet，因此也不会到达拦截器。

2.原因分析
注入的Servlet会存在于Spring容器；DispatcherServlet也会存在于Spring容器。

3.会议Tomcat在对Servlet url匹配的原则，多个servlet都能处理到同一层路径，精确优先原则/最长前缀匹配原则。

4.看看spring容器的debug图

5.在SpringBoot中，调用@Controller目标方法 是按照DispatcherServlet分发匹配的机制， 回顾一下SpringMVC底层机制。

6.源码分析
1)DispatcherServlet在SpringBoot是如何配置和注入的？
DispatcherServletAutoConfiguration完成对DispatcherServlet自动配置。

内置Tomcat配置和切换

基本介绍

1.SpringBoot支持的webServer：Tomcat，Jetty，Undertow。

2.SpringBoot应用启动是Web应用时， web场景包-导入tomcat。

3.支持对Tomcat（也可以是Jetty，Undertow)的配置和切换。

内置Tomcat配置

通过application.yml完成配置

参考 ServerProperties.java, 查看源码得知有哪些属性配置. 有很多内部类.

2.通过application.yml完成配置

server:
  #配置端口
  port: 8084
  tomcat: #tomat是ServerProperties的静态内部类，对tomcat配置
    threads:
      max: 10 #max是threads静态内部类的属性，默认是200
      min-spare: 5 #Minimum amount of worker threads. 默认是10
    accept-count: 200 #当tomcat启动的线程达到最大值后，接受排队的请求个数，默认是100
    max-connections: 2000 #最大 连接数/并发数
    connection-timeout: 10000 #建立连接的超时时间，单位是毫秒
    # tomcat还有其它的配置...

通过类配置

1.通过类配置Tomcat (提示: 配置文件可以配置的更全)

2.创建src/main/java/com/zzw/springboot/config/CustomizationBean.java

//通过类配置Tomcat
@Component
public class CustomizationBean implements WebServerFactoryCustomizer<ConfigurableServletWebServerFactory> {
    @Override
    public void customize(ConfigurableServletWebServerFactory server) {//手动修改的
        server.setPort(9092);//设置server的端口 9092
    }
}

3.注销application.yml配置

  #配置端口
#  port: 8084
#  tomcat: #tomat是ServerProperties的静态内部类，对tomcat配置
#    threads:
#      max: 10 #max是threads静态内部类的属性，默认是200
#      min-spare: 5 #Minimum amount of worker threads. 默认是10
#    accept-count: 200 #当tomcat启动的线程达到最大值后，接受排队的请求个数，默认是100
#    max-connections: 2000 #最大 连接数/并发数
#    connection-timeout: 10000 #建立连接的超时时间，单位是毫秒
    # tomcat还有其它的配置...

4.启动Tomcat
2024-11-07 21:47:33.830 INFO 24888 — [ main] o.s.b.w.embedded.tomcat.TomcatWebServer : Tomcat started on port(s): 9092 (http) with context path ‘’

切换Undertow

1.修改pom.xml, 排除tomcat, 加入Undertow依赖

<!--导入web项目场景启动器, 会自动地导入和web开发相关的所有依赖[库/jar]-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <!--排除tomcat server-->
    <exclusions>
        <exclusion>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
        </exclusion>
    </exclusions>
</dependency>

<!--引入Undertow-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-undertow</artifactId>


</dependency>  

2.排除Tomcat后，由于无法引入servlet， 会报错。再次引入undertow之后，就好了。

3.测试

数据库操作

Jdbc+HikariDataSource

需求分析

需求：演示SpringBoot如何通过jdbc+HikariDataSource 完成对Mysql操作。

说明：HikariDataSource：目前市面上非常优秀的数据源，是SpringBoot2默认数据源。

应用实例

1.sql

`furn_ssm`-- 创建 furn_ssm
DROP DATABASE IF EXISTS spring_boot;
CREATE DATABASE spring_boot;
USE spring_boot;

-- 创建家居表
CREATE TABLE furn(
`id` INT(11) PRIMARY KEY AUTO_INCREMENT, ## id
`name` VARCHAR(64) NOT NULL DEFAULT '', ## 家居名
`maker` VARCHAR(64) NOT NULL DEFAULT '', ## 厂商
`price` DECIMAL(11,2) NOT NULL DEFAULT 0, ## 价格
`sales` INT(11) NOT NULL DEFAULT 0, ## 销量
`stock` INT(11) NOT NULL DEFAULT 0, ## 库存
`img_path` VARCHAR(255) NOT NULL # 图片路径
);

SELECT f1.`name` FROM furn f1 LEFT JOIN furn f2 ON f1.id = f2.id WHERE f1.price=123
-- 添加数据
INSERT INTO furn(`id` , `name` , `maker` , `price` , `sales` , `stock` , `img_path`) 
VALUES(NULL , '北欧风格小桌子' , '熊猫家居' , 180 , 666 , 7 , 'assets/images/product-image/6.jpg');
 
INSERT INTO furn(`id` , `name` , `maker` , `price` , `sales` , `stock` , `img_path`) 
VALUES(NULL , '简约风格小椅子' , '熊猫家居' , 180 , 666 , 7 , 'assets/images/product-image/4.jpg');
 
INSERT INTO furn(`id` , `name` , `maker` , `price` , `sales` , `stock` , `img_path`) 
VALUES(NULL , '典雅风格小台灯' , '蚂蚁家居' , 180 , 666 , 7 , 'assets/images/product-image/14.jpg');
 
INSERT INTO furn(`id` , `name` , `maker` , `price` , `sales` , `stock` , `img_path`) 
VALUES(NULL , '温馨风格盆景架' , '蚂蚁家居' , 180 , 666 , 7 , 'assets/images/product-image/16.jpg');

-- 查询
SELECT * FROM furn;

-- 删除
DROP TABLE furn;

2.进行数据库开发，在pom.xml引入data-jdbc-starter. 参考离线文档 spring-boot-reference.pdf

<!--进行数据库开发，引入data-jdbc starter-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jdbc</artifactId>
</dependency>

3.需要在pom.xml指定导入数据库驱动, 并指定对应版本.

<!--引入mysql驱动
1.说明: 我们这里没有使用版本仲裁 <mysql.version>8.0.26</mysql.version>
2.我们指定版本 <version>5.1.49</version>
-->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.49</version>
</dependency>

4.application.xml配置数据源信息
xml文件里使用&防止出现乱码, 在yaml里直接使用&

spring:
  datasource:
    # 如果没有指定useSSL=true, 启动项目会报红(不好看), 但能正常运行
    url: jdbc:mysql://localhost:3306/spring_boot?useSSL=true&useUnicode=true&characterEncoding=UTF-8
    username: root
    password: zzw
    driver-class-name: com.mysql.jdbc.Driver

5.新建src/main/java/com/zzw/springboot/bean/Furn.java

public class Furn {
    private Integer id;
    private String name;
    private String business;
    private BigDecimal price;
    private Integer saleNum;
    private Integer inventory;
    private String imagePath;

}

6.测试E:\idea_project\zzw_springboot\springboot-usersys\src\test\java\com\zzw\springboot\ApplicationTest.java

<!--如何在SpringBoot中开发测试类, 需要引入starter-test-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
</dependency>

//演示一下如何在SpringBoot中开发测试类
@SpringBootTest
public class ApplicationTest {

    //自动注入JdbcTemplate对象
    @Resource
    private JdbcTemplate jdbcTemplate;

    @Test
    public void contextLoads() {
        //准备参数
        String sql = "select * from `furn`";
        BeanPropertyRowMapper<Furn> rowMapper = new BeanPropertyRowMapper<>(Furn.class);
        //调用
        List<Furn> furnList = jdbcTemplate.query(sql, rowMapper);
        //输出
        for (Furn furn : furnList) {
            System.out.println(furn);
        }
        //查看底层使用的是什么数据源类型[HikariDataSource]
        System.out.println(jdbcTemplate.getDataSource());
    }
}

整合Druid到SpringBoot

官方文档

使用手册: https://github.com/alibaba/druid

中文手册: https://github.com/alibaba/druid/wiki/%E5%B8%B8%E8%A7%81%E9%97%AE%E9%A2%98

基本介绍

1.HiKariCP: 目前市面上非常优秀的数据源, 是SpringBoot2默认数据源.

2.Druid: 性能优秀, Druid提供性能卓越的连接池功能外(java基础), 还集成了SQL监控, 黑名单拦截功能. 通过Druid提供的监控功能, 可以清楚地知道连接池和SQL的工作情况及SQL的执行时间. 所以根据项目的需要, 我们需要掌握Druid和SpringBoot的整合.

3.Druid和SpringBoot的整合方式.
自定义方式;
引入starter方式.

Druid基本使用

需求：将SpringBoot的数据源切换成Druid。

代码实现
1.修改pom.xml, 引入druid依赖

<!--引入druid依赖-->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.17</version>
</dependency>

2.创建src/main/java/com/zzw/springboot/config/DruidDataSourceConfig.java

@Setter
@Getter
@Configuration
@ConfigurationProperties(prefix = "spring.datasource")
public class DruidDataSourceConfig {

    private String url;
    private String username;
    private String password;
    private String driverClassName;

    //编写方法，注入DruidDataSource
    @Bean
    public DruidDataSource druidDataSource() {
        DruidDataSource druidDataSource = new DruidDataSource();
        druidDataSource.setUrl(url);
        druidDataSource.setUsername(username);
        druidDataSource.setPassword(password);
        druidDataSource.setDriverClassName(driverClassName);
        return druidDataSource;
    }
}

或者

@Configuration
public class DruidDataSourceConfig {

    //编写方法，注入DruidDataSource
    //疑问: 为什么我们注入自己的DataSource, 默认的HikariDataSource失效了?
    //1.默认的数据源是如何配置的?
    //解读: 通过@ConditionalOnMissingBean({ DataSource.class, XADataSource.class }), 判断如果容器有 DataSource Bean
    //      就不注入默认的HikariDataSource
    //2.debug源码
    @ConfigurationProperties(prefix = "spring.datasource")
    @Bean
    public DruidDataSource druidDataSource() {
        //1.配置了 @ConfigurationProperties("spring.datasource")
        //  就可以读取到application.yml的配置
        //2.我们就不需要显示地调用DruidDataSource 对象的 setXxx, 会自动关联调用
        DruidDataSource druidDataSource = new DruidDataSource();
        return druidDataSource;
    }
}

Druid监控功能-SQL监控

需求：配置Druid的监控功能，包括SQL监控，SQL防火墙，Web应用，Session监控等。 [参考官方文档]

1.修改src/main/java/com/zzw/springboot/config/DruidDataSourceConfig.java, 增加druid的监控功能.

//配置druid监控页功能
@Bean
public ServletRegistrationBean statViewServlet() {
    StatViewServlet statViewServlet = new StatViewServlet();
    ServletRegistrationBean servletRegistrationBean = new ServletRegistrationBean(statViewServlet, "druid/*");

    Map<String, String> initParameters = new HashMap<>();
    initParameters.put("loginUsername", "druid");//允许清空统计数据
    initParameters.put("loginPassword", "druid");//用户名
    initParameters.put("resetEnable", "true");//密码
    servletRegistrationBean.setInitParameters(initParameters);

    return servletRegistrationBean;
}

3.修改src/main/java/com/zzw/springboot/config/DruidDataSourceConfig.java/druidDataSource(),加入SQL监控

//加入监控功能
druidDataSource.setFilters("stat");

4.增加src/main/java/com/zzw/springboot/controller/DruidSqlController.java, 模拟操作DB请求

@Controller
public class DruidSqlController {

    @Resource
    private JdbcTemplate jdbcTemplate;

    @ResponseBody
    @GetMapping("sql")
    public List<Furn> getData() {
        String sql = "select * from furn";
        BeanPropertyRowMapper<Furn> rowMapper = new BeanPropertyRowMapper<>(Furn.class);

        List<Furn> furnList = jdbcTemplate.query(sql, rowMapper);

        return furnList;
    }
}

5.测试 Druid连接池介绍

Druid监控功能-WEB关联监控

需求: 配置Web关联监控配置, 包括Web应用, URI监控. [参考官方文档]

1.修改src/main/java/com/zzw/springboot/config/DruidDataSourceConfig.java/druidDataSource(),加入WEB监控

//WebStatFilter用于采集web-jdbc关联监控的数据。
@Bean
public FilterRegistrationBean webStatFilter() {
    WebStatFilter webStatFilter = new WebStatFilter();
    FilterRegistrationBean<WebStatFilter> filterRegistrationBean = new FilterRegistrationBean<>(webStatFilter);
    filterRegistrationBean.setUrlPatterns(Arrays.asList("/*"));

    Map<String, String> initParameters = new HashMap<>();
    initParameters.put("exclusions", "*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*");
    filterRegistrationBean.setInitParameters(initParameters);

    return filterRegistrationBean;
}

2.测试

Druid监控功能-SQL防火墙

需求: 配置SQL防火墙 [参考官方文档]

1.修改src/main/java/com/zzw/springboot/config/DruidDataSourceConfig.java/druidDataSource(),加入SQL防火墙

//加入监控功能, 加入SQL防火墙
druidDataSource.setFilters("stat,wall");

2.测试

Druid监控功能-session监控

需求: 配置session监控 [参考官方文档]

1.不用配置，要登录用户系统，才能看到session监控信息

Druid Spring Boot Starter

✅基本介绍
1.前面我们使用的是自己引入druid+配置类方式整合Druid和监控。
2.Druid Spring Boot Start 可以让程序员在Spring Boot项目中更加轻松集成Druid和监控。

✅应用案例
需求：使用Druid Spring Boot Starter 方式完成Druid集成和监控。[参考官方文档]

1.修改pom.xml, 注销druid的依赖

2.注销src/main/java/com/zzw/springboot/config/DruidDataSourceConfig.java全部

3.测试,可见已经恢复到原状

4.在 Spring Boot 项目中加入druid-spring-boot-starter依赖

<dependency>
   <groupId>com.alibaba</groupId>
   <artifactId>druid-spring-boot-starter</artifactId>
   <version>1.1.17</version>
</dependency>

5.添加配置

#配置druid和监控功能
druid:
  stat-view-servlet: #配置druid和监控功能
    enabled: true
    login-username: zhaozhiwei
    login-password: 123456
    reset-enable: false
  web-stat-filter: # 配置Web关联监控配置
    enabled: true
    url-pattern: /*
    exclusions: '*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*'
  filter: #sql监控
    stat:
      slow-sql-millis: 1000 #指定慢查询的时间
      log-slow-sql: true
      enabled: true #超过这个时间就记录在sql监控的页面里
    wall: #配置sql防火墙
      enabled: true #启用sql防火墙(不在白名单那就在黑名单,看你的拦截规则)
      drop-table-allowed: false #禁止删除表
      config:
        select-all-column-allow: false #禁止select *, 如果有,加入sql黑名单

6.测试

作业布置

1.把我们前面学过的异常处理，注入Servlet Fileter Listener，Tomcat切换，数据库操作（HiKariDataSource 和 DruidDataSource), 相关代码和案例，自己写一遍。

2.目前是一些比较散的知识点，同学们学习时，如果想不起来，一定要回顾在前面那个章节中讲过，做一个简单快速的巩固，从而达到融会贯通。