• Springboot中使用拦截器、过滤器、监听器

    一、Servlet、Filter（过滤器）、 Listener（监听器）、Interceptor（拦截器）

    Javaweb三大组件：servlet、Filter（过滤器）、 Listener（监听器）

    SpringBoot特有组件：Interceptor（拦截器）

    过滤器、拦截器、监听器、AOP（后续文章介绍）、全局异常处理器（后续文章介绍）是搭建系统框架时，经常用到的部分，全局异常处理器的作用很明显，就是处理接口执行过程中的异常，而过滤器、拦截器和AOP的作用就很丰富了，日志记录、性能监控、安全认证等等可以向上抽取的功能组件，均可以用他们来实现。

    传统基于Servlet容器的程序中，我们可以使用过滤器和监听器，在Java 框架中还可以使用拦截器，而面向切面编程AOP更是作为Spring框架中的核心思想被大家所关注

    Filter和Listener：依赖Servlet容器，基于函数回调实现。可以拦截所有请求，覆盖范围更广，但无法获取ioc容器中的bean。

    Interceptor和aop：依赖spring框架，基于java反射和动态代理实现。只能拦截controller的请求，可以获取ioc容器中的bean,这点很重要，在拦截器里注入一个service，可以调用业务逻辑。。 

    从 Filter -> Interceptor -> aop ，拦截的功能越来越细致、强大，尤其是Interceptor和aop可以更好的结合spring框架的上下文进行开发。但是拦截顺序也是越来越靠后，请求是先进入Servlet容器的，越早的过滤和拦截对系统性能的消耗越少。具体选用哪种方法，就需要开发人员根据实际业务情况综合考虑了。


    二、过滤器

    1、过滤器作用

    Filter过滤器是Servlet容器层面的，在实现上基于函数回调，可以对几乎所有请求进行过滤

    过滤器是对数据进行过滤，预处理过程，当我们访问网站时，有时候会发布一些敏感信息，发完以后有的会用*替代，还有就是登陆权限控制等，一个资源，没有经过授权，肯定是不能让用户随便访问的，这个时候，也可以用到过滤器,主要是对用户的一些请求进行一些预处理，并在服务器响应后再进行预处理，返回给用户。

    过滤器的功能还有很多，例如实现URL级别的权限控制、压缩响应信息、编码格式等等。对web服务器管理所有的web资源，例如jsp，静态图片 过滤敏感词汇，某些信息用*隐藏。
    使用方式有以下三种

    2、过滤器执行流程

    3、过滤器拦截路径

    4、过滤链

    一个javaweb系统中，可以配置多个过滤器、这多个过滤器就形成了一个过滤链，当然可以控制每个过滤器顺序，见过滤器三种实现方式

    5、过滤器三种实现方式

    第一种方式：利用Servlet3.0的WebFilter注解配置

    @WebFilter是Servlet3.0新增加的注解,在servlet3.0之前,我们需要在web.xml文件中进行过滤器的配置,而现在可以通过此注解进行配置,当项目启动时,会自动扫描自动注册

    通过 @WebFilter 注解来标记一个过滤器，这种方式相信大家很容易想到。这是将 Servlet 中的那一套东西直接拿到 Spring Boot 上用。

    具体做法就是通过 @WebFilter 注解来标记一个 Filter，如下：

    1. //一个是filter的名字，一个是url为什么时用此过滤器，其他的看源码,Filter,必须要有名字，所有的过滤器执行顺序是根据Filter的名字字母顺序来执行的
    2. @WebFilter(filterName = "filter1",urlPatterns = {"/hello/*"})
    3. public class TimeFilter implements Filter {
    4.     @Override
    5.     public void init(FilterConfig filterConfig) throws ServletException {
    6.         System.out.println("=======初始化过滤器=========");
    7.     }
    8.  
    9.     @Override
    10.     public void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain)
    11.             throws IOException, ServletException {
    12.         long start = System.currentTimeMillis();
    13.         filterChain.doFilter(request, response);
    14.         System.out.println("filter 耗时：" + (System.currentTimeMillis() - start));
    15.     }
    16.  
    17.     @Override
    18.     public void destroy() {
    19.         System.out.println("=======销毁过滤器=========");
    20.     }
    21.  
    22. }

    这个注解要生效，还需要我们在项目启动类上配置 @ServletComponentScan 注解，

    @ServletComponentScan 注解虽然名字带了 Servlet，但是实际上它不仅仅可以扫描项目中的 Servlet 容器，也可以扫描 Filter 和 Listener。

    这是我们在 Spring Boot 中使用过滤器的第一种方式，在实际项目中，这种方式使用较少，因为这种方式有一个很大的弊端就是无法指定 Filter 的优先级，如果存在多个 Filter 时，无法通过 @Order 指定优先级。

    1. @SpringBootApplication
    2. @ServletComponentScan
    3. public class SysoaApplication {
    4.  
    5.     public static void main(String[] args) {
    6.         SpringApplication.run(SysoaApplication.class, args);
    7.     }
    8.  
    9. }

    第二种方式：利用SpringBoot的配置类来添加过滤器

    这种方式最简单，直接实现Filter接口，并使用@Component注解标注为组件自动注入bean，

    Filter接口有 init、doFilter、destroy 三个方法，但 init、destroy 是有默认方法实现，可以不重写。

    1. @Component
    2. public class TimeFilter implements Filter {
    3.     @Override
    4.     public void init(FilterConfig filterConfig) throws ServletException {
    5.         System.out.println("=======初始化过滤器=========");
    6.     }
    7.  
    8.     @Override
    9.     public void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain)
    10.             throws IOException, ServletException {
    11.         long start = System.currentTimeMillis();
    12.         filterChain.doFilter(request, response);
    13.         System.out.println("filter 耗时：" + (System.currentTimeMillis() - start));
    14.     }
    15.  
    16.     @Override
    17.     public void destroy() {
    18.         System.out.println("=======销毁过滤器=========");
    19.     }
    20.  
    21. }

    但是缺点是没办法设置过滤的路径，默认是 /* 过滤所有（当然代码中可以加入相关判断）。 

    1. public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
    2.         HttpServletRequest request = (HttpServletRequest) servletRequest;
    3.         HttpServletResponse response = (HttpServletResponse) servletResponse;
    4.  
    5.         String requestUri = request.getRequestURI().replaceFirst(contextPath, "");
    6.         String[] urlList = {"/login","/loginPage","logOut"};
    7.  
    8.         for (String uriItem : urlList){
    9.             if(requestUri.contains(uriItem)){
    10.                 filterChain.doFilter(request,response);
    11.                 return;
    12.             }
    13.         }
    14.  
    15.         //判断session中是否存在用户，这里还可以做其他业务逻辑 比如ip黑名单等 用户是否被禁，禁止多人在线等
    16.         if (request.getSession().getAttribute(SystemConstants.USER) == null) {
    17.             //没有登录跳转到登录页面
    18.             response.sendRedirect(contextPath+SystemConstants.LOGIN_PAGE_URL);
    19.             return;
    20.         }
    21.         filterChain.doFilter(request, response);
    22.     }


    这种方式看起来很方便，一个注解将 Filter 纳入到 Spring 容器中即可。而且这种方式还有一个优势，就是如果存在多个 Filter，可以通过 @Order 注解指定多个 Filter 的优先级，像下面这样：

    1. @Component
    2. @Order(-1)
    3. public class MyFilter implements Filter {
    4.  
    5.     @Override
    6.     public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
    7.         System.out.println("-----doFilter-----");
    8.         chain.doFilter(request, response);
    9.     }
    10. }

    第三种方式：Configuration+FilterRegistrationBean

    还是将 Filter 封装成一个 Bean，但这个 Bean 是 FilterRegistrationBean，通过 FilterRegistrationBean 我们既可以配置 Filter 的优先级，也可以配置 Filter 的拦截规则。

    1. public class AFilter implements Filter {
    2.     @Override
    3.     public void init(FilterConfig filterConfig) throws ServletException {
    4.         System.out.println("=======初始化过滤器A=========");
    5.     }
    6.  
    7.     @Override
    8.     public void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain)
    9.             throws IOException, ServletException {
    10.         long start = System.currentTimeMillis();
    11.         filterChain.doFilter(request, response);
    12.         System.out.println("filter 耗时：" + (System.currentTimeMillis() - start));
    13.     }
    14.  
    15.     @Override
    16.     public void destroy() {
    17.         System.out.println("=======销毁过滤器=========");
    18.     }
    19.  
    20. }

     然后使用SpringBoot提供的FilterRegistrationBean来对Filter进行配置

    1. @Configuration
    2. public class FilterConfig  {
    3.     /*过滤器注解bean:  FilterRegistrationBean,  注册过滤器, 添加过滤器*/
    4.     @Bean
    5.     public FilterRegistrationBean createFilterRegistrationBean() {
    6.         //1.创建FilterRegistrationBean这个对象, 一个过滤器注册器,注册一个过滤器
    7.         FilterRegistrationBean filterRegistrationBean  = new FilterRegistrationBean<>();
    8.         //注册一个过滤器
    9.         filterRegistrationBean.setFilter(new AFilter());
    10.         //过滤器的配置, 设置拦截的url
    11.         filterRegistrationBean.addUrlPatterns("/*");
    12.         //给过滤器起名字
    13.         filterRegistrationBean.setName("AFilter");
    14.         //设置过滤器的执行顺序
    15.         filterRegistrationBean.setOrder(1);
    16.         return filterRegistrationBean;
    17.     }

    当然也可以配置多个并且控制顺序

    1. @Configuration
    2. public class FilterConfig  {
    3.     @Bean
    4.     FilterRegistrationBean myFilterFilterRegistrationBean() {
    5.         FilterRegistrationBean bean = new FilterRegistrationBean<>();
    6.         bean.setFilter(new AFilter());
    7.         bean.setOrder(-1);
    8.         bean.setUrlPatterns(Arrays.asList("/*"));
    9.         return bean;
    10.     }
    11.     @Bean
    12.     FilterRegistrationBean myFilterFilterRegistrationBean2() {
    13.         FilterRegistrationBean bean = new FilterRegistrationBean<>();
    14.         bean.setFilter(new BFilter());
    15.         bean.setOrder(-2);
    16.         bean.setUrlPatterns(Arrays.asList("/hello"));
    17.         return bean;
    18.     }
    19. }

     

    FilterRegistrationBean 扩展

    Spring Boot 为了方便大家向 Servlet 容器中注册 Servlet、Filter 以及 Listener，提供了一个 Bean 注册的抽象类 RegistrationBean，如下：

    1. public abstract class RegistrationBean implements ServletContextInitializer, Ordered {
    2. 	private int order = Ordered.LOWEST_PRECEDENCE;
    3. 	private boolean enabled = true;
    4. 	@Override
    5. 	public final void onStartup(ServletContext servletContext) throws ServletException {
    6. 		String description = getDescription();
    7. 		if (!isEnabled()) {
    8. 			logger.info(StringUtils.capitalize(description) + " was not registered (disabled)");
    9. 			return;
    10. 		}
    11. 		register(description, servletContext);
    12. 	}
    13. 	protected abstract String getDescription();
    14. 	protected abstract void register(String description, ServletContext servletContext);
    15. 	public void setEnabled(boolean enabled) {
    16. 		this.enabled = enabled;
    17. 	}
    18. 	public boolean isEnabled() {
    19. 		return this.enabled;
    20. 	}
    21. 	public void setOrder(int order) {
    22. 		this.order = order;
    23. 	}
    24. 	@Override
    25. 	public int getOrder() {
    26. 		return this.order;
    27. 	}
    28.  
    29. }

     

    RegistrationBean 实现了 ServletContextInitializer 接口，在 Servlet 启动时，RegistrationBean#onStartup 方法会被调用，进而完成 Filter、Servlet 以及 Listener 的注册。
        enabled 属性可以理解为一个开关，设置为 false 相当于关闭组件注册。

    RegistrationBean 有众多的实现类，我们之前使用的 FilterRegistrationBean 只是其中之一：

    实现类的作用一目了然：

        ServletListenerRegistrationBean 用来注册监听器。
        ServletRegistrationBean 用来注册 Servlet。
        DispatcherServletRegistrationBean 用来注册 DispatcherServlet。
        FilterRegistrationBean 用来注册过滤器。
        DelegatingFilterProxyRegistrationBean 则用来注册 DelegatingFilterProxy，DelegatingFilterProxy 在 Spring Security、Spring Session、Shiro 等整合时非常有用。
     

    6、过滤器实际项目场景使用举例

    使用filter实现登录校验

    三、监听器

    Listener监听器也是Servlet层面的，可以用于监听Web应用中某些对象、信息的创建、销毁和修改等动作发生，然后做出相应的响应处理。可以在这些事件发生前和发生后进行处理。

    用途：

    1、用于统计在线人数和在线用户，

    2、系统启动时加载初始化信息，

    3、统计网站访问量，

    4、记录用户访问路径

    根据监听对象，将监听器分为3类：

    第一类：ServletContext：对应application，实现接口ServletContextListener。在整个Web服务中只有一个，在Web服务关闭时销毁。可用于做数据缓存，例如结合redis，在Web服务创建时从数据库拉取数据到缓存服务器。

    第二类：HttpSession：对应session会话，实现接口HttpSessionListener。在会话起始时创建，一端关闭会话后销毁。可用作获取在线用户数量。

    第三类：ServletRequest：对应request，实现接口ServletRequestListener。request对象是客户发送请求时创建的，用于封装请求数据，请求处理完毕后销毁。可用作封装用户信息。

    在写Listener的类时，有两种方式。

    第一种是只加@Component；

    第二种是 @WebListener 和 @ServletComponentScan 配合使用。

    不过实现接口则根据监听对象区分，如：ServletContextListener、HttpSessionListener和ServletRequestListener。

    1.  
    2. import javax.servlet.annotation.WebListener;
    3. import javax.servlet.http.HttpSessionEvent;
    4. import javax.servlet.http.HttpSessionListener;
    5.  
    6.  
    7. @WebListener()
    8. public class MyListener implements HttpSessionListener{
    9.  
    10. 	 public static int online = 0;
    11.  
    12. 	    @Override
    13. 	    public void sessionCreated(HttpSessionEvent se) {
    14. 	        System.out.println("创建session,在线用户数:" + (++online));
    15. 	    }
    16.  
    17. 	    @Override
    18. 	    public void sessionDestroyed(HttpSessionEvent se) {
    19. 	        System.out.println("销毁session,在线用户数:" + (--online));
    20. 	        online--;
    21. 	    }
    22. }

    启动类

    1.  
    2. @SpringBootApplication
    3. @ServletComponentScan("com.demo.listener") //需要扫描包
    4. public class SpringBoot1Application {
    5.  
    6. 	public static void main(String[] args) {
    7. 		SpringApplication.run(SpringBoot1Application.class, args);
    8. 	}
    9.  
    10. }

     

    这里我们再补充一下常用的监听器接口：

    1.ServletContextListener -- 监听servletContext对象的创建以及销毁

        1.1    contextInitialized(ServletContextEvent arg0)   -- 创建时执行

        1.2    contextDestroyed(ServletContextEvent arg0)  -- 销毁时执行

    2.HttpSessionListener  -- 监听session对象的创建以及销毁

        2.2   sessionCreated(HttpSessionEvent se)   -- 创建时执行

        2.2   sessionDestroyed(HttpSessionEvent se) -- 销毁时执行

    3.ServletRequestListener -- 监听request对象的创建以及销毁

        3.1    requestInitialized(ServletRequestEvent sre) -- 创建时执行

        3.2    requestDestroyed(ServletRequestEvent sre) -- 销毁时执行

    4.ServletContextAttributeListener  -- 监听servletContext对象中属性的改变

        4.1    attributeAdded(ServletContextAttributeEvent event) -- 添加属性时执行

        4.2    attributeReplaced(ServletContextAttributeEvent event) -- 修改属性时执行

        4.3    attributeRemoved(ServletContextAttributeEvent event) -- 删除属性时执行

    5.HttpSessionAttributeListener  --监听session对象中属性的改变

        5.1    attributeAdded(HttpSessionBindingEvent event) -- 添加属性时执行

        5.2    attributeReplaced(HttpSessionBindingEvent event) -- 修改属性时执行

        5.3    attributeRemoved(HttpSessionBindingEvent event) -- 删除属性时执行

    6.ServletRequestAttributeListener  --监听request对象中属性的改变

        6.1    attributeAdded(ServletRequestAttributeEvent srae) -- 添加属性时执行

        6.2    attributeReplaced(ServletRequestAttributeEvent srae) -- 修改属性时执行

        6.3    attributeRemoved(ServletRequestAttributeEvent srae) -- 删除属性时执行

     

    四、拦截器

    1、拦截器作用

    过滤器是拦截所有请求，而拦截器是拦截在进入到前端控制器之后的请求，

    Interceptor和Filter、Listener有本质上的不同，Filter、Listener都是依赖于Servlet容器，而Interceptor则是依赖于Spring框架，是aop的一种表现,当某个方法或字段被访问时进行拦截，在之前 和 在之后 加入某些操作

    用途：权限验证，判断用户是否登录，或者再做某一操作时要确定满足某一定的条件，基于Java的动态代理实现的。

    2、拦截器执行流程

    3、拦截器拦截路径

     拦截器可以根据需求配置不同的拦截路径

     

    4、拦截器的使用

    首先通过实现 HandlerInterceptor接口声明拦截器的类，实现preHandle、postHandle和afterCompletion方法。然后通过配置类WebMvcConfigurer接口，实现addInterceptors方法配置拦截器

    1.  
    2. import org.springframework.stereotype.Component;
    3. import org.springframework.web.servlet.HandlerInterceptor;
    4. import org.springframework.web.servlet.ModelAndView;
    5.  
    6. import javax.servlet.http.HttpServletRequest;
    7. import javax.servlet.http.HttpServletResponse;
    8.  
    9. @Component
    10. public class InterceptorTest  implements HandlerInterceptor {
    11.     /**
    12.      * 在请求处理之前进行调用（Controller方法调用之前）
    13.      * 预处理回调方法，实现处理器的预处理
    14.      * 返回值：true表示继续流程；false表示流程中断，不会继续调用其他的拦截器或处理器
    15.      */
    16.     @Override
    17.     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
    18.             throws Exception {
    19.         System.out.println("开始拦截.........");
    20.         String name = MyCookie.getCookieByKey(request,response,"name");
    21.         String password = MyCookie.getCookieByKey(request,response,"password");
    22.         //如果session中没有user，表示没登陆
    23.         if (password == null|| name == null){
    24.             //这个方法返回false表示忽略当前请求，如果一个用户调用了需要登陆才能使用的接口，如果他没有登陆这里会直接忽略掉
    25.             //当然你可以利用response给用户返回一些提示信息，告诉他没登陆
    26.             request.getRequestDispatcher("/interceptor/to_login").forward(request, response);
    27.             return false;
    28.         }else {
    29.             return true;//放行
    30.         }
    31.     }
    32.  
    33.     /**
    34.      * 请求处理之后进行调用，但是在视图被渲染之前（Controller方法调用之后）
    35.      * 后处理回调方法，实现处理器（controller）的后处理，但在渲染视图之前
    36.      * 此时我们可以通过modelAndView对模型数据进行处理或对视图进行处理
    37.      */
    38.     @Override
    39.     public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
    40.                            ModelAndView modelAndView) throws Exception {
    41.         // TODO Auto-generated method stub
    42.         System.out.println("return前");
    43.  
    44.     }
    45.     /**
    46.      * 在整个请求结束之后被调用，也就是在DispatcherServlet 渲染了对应的视图之后执行（主要是用于进行资源清理工作）
    47.      * 整个请求处理完毕回调方法，即在视图渲染完毕时回调，
    48.      * 如性能监控中我们可以在此记录结束时间并输出消耗时间，
    49.      * 还可以进行一些资源清理，类似于try-catch-finally中的finally，
    50.      * 但仅调用处理器执行链中
    51.      */
    52.     @Override
    53.     public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
    54.             throws Exception {
    55.         // TODO Auto-generated method stub
    56.         System.out.println("操作完之后，可以用于资源清理");
    57.  
    58.     }
    59. }

    然后将这个组件加入到boot中，在boot1版本中 通过继承WebmvcConfigureAdapter实现一个web配置，例如我们配置上面的拦截器

    1. @Configuration //声明这是一个配置
    2. public class LoginInterceptorConfig extends WebMvcConfigurerAdapter {
    3. @Resource
    4. private LoginInterceptor loginInterceptor;
    5.  
    6. @Override
    7. public void addInterceptors(InterceptorRegistry registry) {
    8.     registry.addInterceptor(loginInterceptor).addPathPatterns("/admin/**").excludePathPatterns("/admin").excludePathPatterns("/admin/login");
    9. }
    10.     }

     或者直接使用匿名类的方式

    1. import org.springframework.context.annotation.Configuration;
    2. import org.springframework.web.servlet.HandlerInterceptor;
    3. import org.springframework.web.servlet.ModelAndView;
    4. import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
    5. import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
    6.  
    7. import javax.servlet.http.HttpServletRequest;
    8. import javax.servlet.http.HttpServletResponse;
    9.  
    10. /**
    11.  * 自定义一个登陆拦截器
    12.  */
    13. @Configuration //声明这是一个配置
    14. public class LoginInterceptor extends WebMvcConfigurerAdapter {
    15.     /*
    16.     用来添加拦截器的方法
    17.     InterceptorRegistry registry拦截器注册
    18.      */
    19.     @Override
    20.     public void addInterceptors(InterceptorRegistry registry) {
    21.         //使用匿名内部类创建要给拦截器
    22.         HandlerInterceptor loginInterceptor = new HandlerInterceptor() {
    23.             @Override
    24.             public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object o) throws Exception {
    25.                 //判断session中是否存在用户
    26.                 if (request.getSession().getAttribute("user") == null) {
    27.                     response.sendRedirect("/admin");
    28.                     return false;
    29.                 }
    30.                 return true;
    31.             }
    32.  
    33.             @Override
    34.             public void postHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, ModelAndView modelAndView) throws Exception {
    35.  
    36.             }
    37.  
    38.             @Override
    39.             public void afterCompletion(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) throws Exception {
    40.  
    41.             }
    42.         };
    43.         registry.addInterceptor(loginInterceptor).addPathPatterns("/admin/**").excludePathPatterns("/admin").excludePathPatterns("/admin/login");
    44.     }
    45. }

     对于Sprinboot2版本，第一步还是定义一个拦截器组件。

    第二不再是通过继承WebmvcConfigureAdapter实现一个web配置，而是实现接口WebMvcConfigurer增加一个配置

    1. @Configuration
    2. public class WebConfig implements WebMvcConfigurer {
    3.  
    4. //引入我们的拦截器组件
    5.     @Resource
    6.     private LoginInterceptor loginInterceptor;
    7. //实现拦截器配置方法
    8.     @Override
    9.     public void addInterceptors(InterceptorRegistry registry) {
    10.         registry.addInterceptor(loginInterceptor).addPathPatterns("/admin/**").excludePathPatterns("/admin").excludePathPatterns("/admin/login");
    11.  
    12.     }
    13. }

    踩坑5--springboot2.xl登陆拦截器中排除静态资源的几种情况整理 - 百度文库 (baidu.com) 

    5、拦截器使用场景举例

    Filter与Interceptor区别

    1.接口范围不同：过滤器需要实现Filter接口，而拦截器需要实现HandlerInterceptor接口。

    2.拦截范围不同：过滤器Filter会拦截所有的资源，而Interceptor只会拦截Spring环境中的资源

  • 相关阅读:
    mybatis中resultMap和resultType的区别
    （附源码）springboot医疗管理系统 毕业设计 015221
    WebGL笔记：矩阵的变换之平移的实现
    区块链游戏已无利可图？
    后羿采集器的使用出现了问题
    进程与线程
    趁热打铁之文本信息标注平台
    C# HttpClient使用和注意事项，.NET Framework连接池并发限制
    MIT指出公开预训练模型不能乱用
    C++编程小游戏------斗罗大陆（1）魂力测评和武魂觉醒
  • 原文地址：https://blog.csdn.net/qq_34491508/article/details/133411989