似水无痕

Tools Typora1.2.4

Wed, 06 Apr 2022 00:00:00 +0000

Typora1.2.4破解方案

第一步：下载Typora1.2.4

第二步：破解

将app.asar替换Typora安装目录resources目录下的app.asar文件

Filter过滤器源码解析

Wed, 06 Jun 2018 00:00:00 +0000

什么是Filter

本文所说的Filter是JavaWeb中常见常使用的过滤器。Filter的作用是拦截前端发送给后端的请求，一般是用于权限过滤、日志记录、图片转换、加密、数据压缩等操作。大致流程如下图所示：

初步了解Filter接口

Filter是过滤器的核心接口，其中定义了初始化方法、拦截请求后的要做的具体任务方法、销毁方法

public interface Filter {
    //初始化方法，整个生命周期中只执行一次。
    //在init方法成功(失败如抛异常等)执行完前，不能提供过滤服务。
    //参数FilterConfig用于获取初始化参数
    public void init(FilterConfig filterConfig) throws ServletException;

    //执行过滤任务的方法，参数FilterChain表示过滤器链，doFilter方法中只有执行chain.doFilter()后才能调用下一个过滤器的doFilter方法
    //才能将请求交经下一个Filter或Servlet执行
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException;

    //销毁方法，当移出服务时由web容器调用。整个生命周期中destroy方法只会执行一次
    //destroy方法可用于释放持有的资源，如内存、文件句柄等
    public void destroy();
}

Filter的执行流程

详细的说，Filter的执行流程主要分为两个部分：

初始化部分：对于定义好的Filter过滤器，会首先创建过滤器对象，并保存到过容器中，并调用其init方法进行初始化。
执行部分：当匹配到相应的请求路径时，首先会对该请求进行拦截，执行doFilter中的逻辑，若不通过则该请求则到此为止，不会继续往下执行（此时通常会进行重定向或者转发到其他地方进行处理）；若通过则继续执行下一个拦截器的doFilter方法，直到指定的过滤器都执行完doFilter后，便执行Servlet中的业务逻辑。

1.初始化部分首先来了解下Filter的初始化流程，当我们定义好Filter类后，便开启Tomcat服务器，开始启动程序。通过调试发现初始化Filter的入口是：StandardContext类的startInternal方法

@Override
protected synchronized void startInternal() throws LifecycleException {
	... // 省略不必要代码
    fireLifecycleEvent(Lifecycle.CONFIGURE_START_EVENT, null); // 读取web.xml配置文件或者注解配置信息，创建并添加Filter
	... 
    if (ok) {
        if (!filterStart()) { // 初始化Filter。若初始化成功则继续往下执行；若初始化失败则抛出异常，终止程序
            log.error(sm.getString("standardContext.filterFail"));
            ok = false;
        }
    }
    ... 
}

可以看到，原来filterStart方法才是真正初始化Filter的方法。那么在看filterStart方法源码之前，我们先来了解下一些相关的重点属性（有助于之后的源码阅读）：

// filterConfigs是一个HashMap，以键值对的形式保存数据（key ：value = 过滤器名 ：过滤器配置信息对象）
private HashMap<String, ApplicationFilterConfig> filterConfigs = new HashMap<>();

// filterDefs同时也是一个HashMap，其中保存的数据是（过滤器名 ：过滤器定义对象）
private HashMap<String, FilterDef> filterDefs = new HashMap<>();

下其中的FilterDef、ApplicationFilterConfig这两个类，再进一步了解上面的两个属性：

FilterDef

/**
* 来看下官方解释：
* Web应用程序的过滤器定义的表示形式，如部署描述符中<filter>元素中的所示。
* 例如：
* <filter>  
* 	<filter-name>MyFilter</filter-name>  
*   <filter-class>com.filter.MyFilter</filter-class>  
* </filter>  
* 
* 说白了，这个FilterDef其实就是封装了配置信息中<filter>标签当中的元素
* 其中就有三个重点属性：filterName、filterClass、filter
*/
public class FilterDef implements Serializable {
	...
    private String filterName = null; // 过滤器名，对应的是<filter-name>中的内容
    
    private String filterClass = null; // 过滤器全限定类名，对应的是<filter-class>中的内容（用于反射创建过滤器对象）

	private transient Filter filter = null; // 真正的过滤器对象（如：MyFilter实例对象）
	...
}

ApplicationFilterConfig

/**
* ApplicationFilterConfig类主要用于保存自定义Filter的一些配置信息，例如过滤器名、初始化参数、过滤器定义对象等等
*/
public final class ApplicationFilterConfig implements FilterConfig, Serializable {
	...
	/**
	* 构造方法
	*/
	ApplicationFilterConfig(Context context, FilterDef filterDef)
	        throws ClassCastException, ClassNotFoundException, IllegalAccessException,
	        InstantiationException, ServletException, InvocationTargetException, NamingException,
	        IllegalArgumentException, NoSuchMethodException, SecurityException {
	    super();
	    this.context = context; 
	    this.filterDef = filterDef; // 由此可知，ApplicationFilterConfig类中其实定义了过滤器定义对象
		// 初始化真正的过滤器对象
	    if (filterDef.getFilter() == null) {
	        getFilter();
	    } else {
	        this.filter = filterDef.getFilter();
	        getInstanceManager().newInstance(filter);
	        initFilter();
	    }
	}
	...
}

了解完上面的属性，我们再来研究filterStart方法到底做了什么

public boolean filterStart() {
    if (getLogger().isDebugEnabled()) { // 日志相关
        getLogger().debug("Starting filters");
    }

    boolean ok = true;
    synchronized (filterConfigs) { // 初始化过滤器属于同步操作
        filterConfigs.clear(); // 在初始化前，先清空
        for (Entry<String,FilterDef> entry : filterDefs.entrySet()) { // 循环遍历过滤器定义对象集合（filterDefs初始化在哪？）
            String name = entry.getKey(); // 获取过滤器名
            if (getLogger().isDebugEnabled()) { // 日志相关
                getLogger().debug(" Starting filter '" + name + "'");
            }
            try {
                ApplicationFilterConfig filterConfig = new ApplicationFilterConfig(this, entry.getValue()); // 创建过滤器配置对象
                filterConfigs.put(name, filterConfig); // 添加配置对象
            } catch (Throwable t) {
                t = ExceptionUtils.unwrapInvocationTargetException(t);
                ExceptionUtils.handleThrowable(t);
                getLogger().error(sm.getString("standardContext.filterStart", name), t);
                ok = false;
            }
        }
    }
    return ok;
}

此处，如果细心的朋友就会发现，filterStart方法中直接就拿filterDefs进行循环遍历获取过滤器名了。但是filterDefs是在哪里进行添加元素的呢？回想一下，我们发现初始化过滤器的入口是StandardContext类中的startInternal方法，而在其中执行真正过滤器初始化方法前，还有一步

fireLifecycleEvent(Lifecycle.CONFIGURE_START_EVENT, null); // 读取web.xml配置文件或者注解配置信息，创建并添加FilterDef过滤器定义对象

// 通过调试代码，可以找到其实是调用了ContextConfig类中configureContext方法，以下部分是该方法中的关键代码
for (FilterDef filter : webxml.getFilters().values()) { // 循环配置信息中的过滤器定义对象
    if (filter.getAsyncSupported() == null) {
        filter.setAsyncSupported("false");
    }
    context.addFilterDef(filter); // 将过滤器定义对象添加到容器中
}

/**
* 最后发现fireLifecycleEvent方法最终调用的是StandardContext类中的addFilterDef方法
* 而参数filterDef正是容器context经过解析web.xml文件或者注解配置后创建的过滤器定义对象
* 但此时filterDef中的真正过滤器对象filter还未初始化，因此才会有之后的初始化过滤器方法
*/
public void addFilterDef(FilterDef filterDef) {
    synchronized (filterDefs) { // 同步添加过滤器定义对象
        filterDefs.put(filterDef.getFilterName(), filterDef); 
    }
    fireContainerEvent("addFilterDef", filterDef);
}

明白了filterDefs的初始化，我们再回到filterStart方法，而此时执行到创建ApplicationFilterConfig过滤器配置对象

/**
* 没错，就是调用这个构造方法创建的filterConfig
**/
ApplicationFilterConfig(Context context, FilterDef filterDef)
        throws ClassCastException, ClassNotFoundException, IllegalAccessException,
        InstantiationException, ServletException, InvocationTargetException, NamingException,
        IllegalArgumentException, NoSuchMethodException, SecurityException {
    super();
    this.context = context;
    this.filterDef = filterDef;
	// 现在重点来关注以下部分的代码
	// 从过滤器定义对象中获取真正的过滤器对象（正常来说，应该都是空。因为从之前filterDefs的添加元素逻辑来看，添加的过滤器定义对象中的过滤器对象都是空的）
    if (filterDef.getFilter() == null) { // 过滤器对象为空
        getFilter(); // 获取并初始化过滤器（此处没有进行接收结果，说明此处只是进行初始化）
    } else {
        this.filter = filterDef.getFilter(); // 绑定过滤器对象
        getInstanceManager().newInstance(filter);
        initFilter(); // 调用过滤器的init方法，初始化过滤器
    }
}

获取并初始化过滤器

Filter getFilter() throws ClassCastException, ClassNotFoundException, IllegalAccessException,
        InstantiationException, ServletException, InvocationTargetException, NamingException,
        IllegalArgumentException, NoSuchMethodException, SecurityException {
    if (this.filter != null) // 若ApplicationFilterConfig类中已存在过滤器对象，则直接返回
        return (this.filter);
        
	// 通过反射的方式创建过滤器对象，并绑定到配置对象的filter上
    String filterClass = filterDef.getFilterClass(); 
    this.filter = (Filter) getInstanceManager().newInstance(filterClass);
    
    initFilter(); // 调用过滤器对象的init方法，初始化过滤器

    return (this.filter);
}

到此，过滤器对象也已经创建了，就差调用它的init方法初始化了

private void initFilter() throws ServletException {
    if (context instanceof StandardContext && context.getSwallowOutput()) {
        try {
            SystemLogHandler.startCapture();
            filter.init(this);
        } finally {
            String capturedlog = SystemLogHandler.stopCapture();
            if (capturedlog != null && capturedlog.length() > 0) {
                getServletContext().log(capturedlog);
            }
        }
    } else {
        filter.init(this); // 终于看到了，调用了filter对象的init方法
    }
    // Expose filter via JMX
    registerJMX();
}

@WebFilter(urlPatterns = "/my")
public class MyFilter implements Filter {

    @Override
    public void init(FilterConfig filterConfig) { // 其实就是调用了这个我们自己实现的init方法
        System.out.println("filter init...");
    }
	...
}

那么过滤器的初始化部分就到此结束了。

我们来整理下逻辑，如果你的逻辑清晰的话，就可以明白过滤器初始化的这个部分，做了各种各样的事情，其实都是为了根据配置信息去创建filterConfig对象，并为它的filterDef和filter属性进行赋值，最后将其添加到filterConfigs中去。换句话说，其实就是为了根据配置信息去创建过滤器配置对象，并初始化它的过滤器定义对象和真正的过滤器对象，最后将它加入到容器的过滤器配置映射表中去。

为了加深对Filter初始化部分的源码理解，送出下图

2.执行部分

了解完Filter的初始化，说明在后端程序中已经存在有相应的过滤器了（Tomcat自带的，我们自定义的）。那么当请求访问到达后端的时候，Filter是如何工作的？

下面再来看调用Filter的方法入口StandardWrapperValve类中的invoke

public final void invoke(Request request, Response response) throws IOException, ServletException {
	...
    ApplicationFilterChain filterChain = ApplicationFilterFactory.createFilterChain(request, wrapper, servlet); // 创建并初始化过滤器链

    try {
        if ((servlet != null) && (filterChain != null)) { // 此处需要判断servlet和过滤器不为空。因为在执行完过滤器链中所有的过滤器doFilter方法后，就会轮到真正处理请求的servlet来处理
            if (context.getSwallowOutput()) {
                try {
                    SystemLogHandler.startCapture();
                    if (request.isAsyncDispatching()) { 
                        request.getAsyncContextInternal().doInternalDispatch();
                    } else {
                        filterChain.doFilter(request.getRequest(),
                                response.getResponse());
                    }
                } finally {
                    String log = SystemLogHandler.stopCapture();
                    if (log != null && log.length() > 0) {
                        context.getLogger().info(log);
                    }
                }
            } else {
                if (request.isAsyncDispatching()) {
                    request.getAsyncContextInternal().doInternalDispatch();
                } else {
                    filterChain.doFilter(request.getRequest(), response.getResponse()); // 执行过滤器链中的所有过滤器的doFilter方法
                }
            }
        }
	} catch(...){...}
	...
}

通过上面的源码，可以看到直接就通过创建的过滤器链执行其中过滤器的doFilter方法了。因此重点就在于这个过滤器链filterChain是如何创建的？

来看下ApplicationFilterFactory类的createFilterChain方法

public static ApplicationFilterChain createFilterChain(ServletRequest request, Wrapper wrapper, Servlet servlet) {
    if (servlet == null) // 如果没有之后处理请求的servlet，那么即使有过滤器也是白搭，直接返回空
        return null;
    // 创建过滤器链
    ApplicationFilterChain filterChain = null;
    if (request instanceof Request) {
        Request req = (Request) request;
        if (Globals.IS_SECURITY_ENABLED) {
            filterChain = new ApplicationFilterChain(); // 安全启用的过滤器链，直接新建，不复用request请求中的过滤器链
        } else {
            filterChain = (ApplicationFilterChain) req.getFilterChain(); // 获取请求中的过滤器链（若是第一次访问，获取的过滤器链为空）
            if (filterChain == null) { // 过滤器链为空
                filterChain = new ApplicationFilterChain(); // 新建过滤器链
                req.setFilterChain(filterChain); // 加入request请求中，在之后可以进行复用
            }
        }
    } else {
        // Request dispatcher in use
        filterChain = new ApplicationFilterChain();
    }

    filterChain.setServlet(servlet); // 在过滤器链中设置最后处理请求的servlet
    filterChain.setServletSupportsAsync(wrapper.isAsyncSupported());

    StandardContext context = (StandardContext) wrapper.getParent(); // 获取StandardContext容器
    // 这里又冒出来一个filterMaps，它又是怎么来的？
    FilterMap filterMaps[] = context.findFilterMaps(); // 获取过滤器映射对象
    
    if ((filterMaps == null) || (filterMaps.length == 0)) // 如果过滤器映射对象都不存在，或者没有映射信息，则说明没有自定义过滤器，则直接返回过滤器链
        return (filterChain);

    DispatcherType dispatcher = (DispatcherType) request.getAttribute(Globals.DISPATCHER_TYPE_ATTR); // 获取当前request请求的类型

    String requestPath = null;
    Object attribute = request.getAttribute(Globals.DISPATCHER_REQUEST_PATH_ATTR);
    if (attribute != null){
        requestPath = attribute.toString(); // 请求地址（例如：/my）
    }

    String servletName = wrapper.getName(); // 获取最终处理请求的servlet名

    // 循环遍历过滤器映射对象数组，为过滤器链添加符合条件的过滤器
    for (int i = 0; i < filterMaps.length; i++) {
        if (!matchDispatcher(filterMaps[i] ,dispatcher)) { // 匹配请求类型，不匹配则跳过
            continue;
        }
        if (!matchFiltersURL(filterMaps[i], requestPath)) // 匹配请求地址，不匹配则跳过
            continue;
        ApplicationFilterConfig filterConfig = (ApplicationFilterConfig) context.findFilterConfig(filterMaps[i].getFilterName()); // 符合前两个匹配条件，则根据过滤器名在StandardContext容器中获取对应的过滤器配置对象
        if (filterConfig == null) { 
            continue;
        }
        filterChain.addFilter(filterConfig); // 到这步终于明白，过滤器链中添加的并不是过滤器对象，而是过滤器配置对象
    }

    // 循环遍历过滤器映射对象数组，再次为过滤器链添加符合条件的过滤器
    for (int i = 0; i < filterMaps.length; i++) {
        if (!matchDispatcher(filterMaps[i] ,dispatcher)) { // 匹配请求类型，不匹配则跳过
            continue;
        }
        if (!matchFiltersServlet(filterMaps[i], servletName)) // 匹配过滤器对应的servlet名，不匹配则跳过
            continue;
        ApplicationFilterConfig filterConfig = (ApplicationFilterConfig) context.findFilterConfig(filterMaps[i].getFilterName()); // 符合前两个匹配条件，则根据过滤器名在StandardContext容器中获取对应的过滤器配置对象
        if (filterConfig == null) {
            continue;
        }
        filterChain.addFilter(filterConfig); // 添加对应的过滤器配置对象
    }

	// 到此，filterChain过滤器链已经将匹配的请求类型、请求路径、请求最终处理的servlet这三个条件的过滤器配置对象添加完毕，返回
    return filterChain;
}

当createFilterChain方法执行完后，一个完整的过滤器链filterChain就有了。但是在过滤器链生成的过程中有个非常重要的角色：filterMap，以及createFilterChain方法中还有很多其他的看似不起眼的方法，听我接下来慢慢分析：

首先，我们先来看看这个filterMap是个什么东西

FilterMap filterMaps[] = context.findFilterMaps(); // 从createFilterChain方法中的这句就可以知道，filterMap是从context容器来的

/**
* 这个context容器其实就是我们一直说的StandardContext
* 然后点进来到findFilterMaps方法，发现它只是返回了filterMaps属性对象的asArray方法的结果
*/
@Override
public FilterMap[] findFilterMaps() {
    return filterMaps.asArray();
}

// 因此，再来看这个filterMaps属性是个什么东西
// 原来又是ContextFilterMaps类的对象
private final ContextFilterMaps filterMaps = new ContextFilterMaps();

/**
* 再点进来这个ContextFilterMaps类，发现原来它是StandardContext类中的一个静态final内部类
* 重点是其内部维护了一个FilterMap[]类型的数组，而且它的asArray方法也只是返回了这个数组
*/
private static final class ContextFilterMaps {
		... 
        private FilterMap[] array = new FilterMap[0];
        ...
        public FilterMap[] asArray() {
            synchronized (lock) {
                return array;
            }
        }
        ...
	}
}

到此，可以知道StandardContext类的findFilterMaps方法返回的是，其内部类ContextFilterMaps中维护的一个FilterMap[]类型的数组。

但是对于filterMap的探索仍未结束，因为我们只知道它是一个FilterMap[]类型的数组，但是这个FilterMap是个什么类我们不知道，那还是继续看下吧

/**
 * 来看下这个类的官方解释：
 * Web应用程序的过滤器映射的表示形式，如部署描述符中<filter-mapping>元素中的所示
 * 每个过滤器映射都必须包含过滤器名称以及URL模式或servlet名称
 * 例如以下配置：
 * <filter-mapping>  
 *    <filter-name>MyFilter</filter-name>  
 *    <url-pattern>/my</url-pattern> 
 * </filter-mapping> 
 * 
 * 说白了，这个FilterMap就是封装了配置信息中<filter-mapping>标签中的元素
 * 其中还包含了两个重点属性：过滤器名、过滤器对应过滤的url
 */
public class FilterMap extends XmlEncodingBase implements Serializable {
	...
    private String filterName = null; // 过滤器名，对应的是<filter-name>中的内容
	
    private String[] urlPatterns = new String[0]; // 过滤url，对应的是<url-pattern>中的内容（可配置多个<filter-mapping>匹配不同的url，因此是数组形式）
    ...
}

终于，这个filterMap是个什么东西可以说是研究明白了。filterMap它其实就是个封装了配置映射信息中过滤器名和对应过滤url 参数的对象数组。

filterMap的定义搞清楚了，但是还不够。因为我们还不知道它是怎么初始化的？是在哪里把配置映射对象FilterMap加进去的？

接下来，给大家来说下这个filterMap是如何初始化的。（通过代码调试就ok了）在这里直接就和大家说了，大家应该还记得过滤器的第一阶段吧。是的，就是初始化阶段

// 大家对这个方法还有印象吧，它就是初始化过滤器的入口方法（StandardContext类中的startInterval中调用)
// 针对于以下代码，我们之前的说法是：读取web.xml配置文件或者注解配置信息，创建并添加FilterDef过滤器定义对象
// 那么到了现在，其实全面一点的说法应该是：
// 1. 读取web.xml配置文件或者注解配置信息，创建并添加FilterDef过滤器定义对象
// 2. 同时也创建并添加FilterMap过滤器映射对象
fireLifecycleEvent(Lifecycle.CONFIGURE_START_EVENT, null); 

// 以下同样是调用了ContextConfig类的configureContext方法，以下是关键代码
for (FilterMap filterMap : webxml.getFilterMappings()) { // 循环配置信息中的过滤器映射对象
    context.addFilterMap(filterMap); // 将过滤器映射对象添加到容器中
}

/**
* 最终调用了StandardContext类中的addFilterMap方法
*/
@Override
public void addFilterMap(FilterMap filterMap) {
    validateFilterMap(filterMap); // 验证过滤器映射对象中的信息是否正确
    filterMaps.add(filterMap); // 添加到filterMaps中去
    fireContainerEvent("addFilterMap", filterMap);
}

到此，才可以说把filterMap这个东西的定义到初始化整个过程给研究明白了。

费了一番功夫，终于把这个filterMap给搞明白了。那么，再回头看下createFilterChain方法中被我们忽视的一些细节

获取过滤器配置对象

ApplicationFilterConfig filterConfig = (ApplicationFilterConfig) context.findFilterConfig(filterMaps[i].getFilterName()); // 说到底，还是根据过滤器名从容器中获取

/**
 * findFilterConfig方法一看，其实就是从容器的filterConfigs中根据过滤器名获取到对应的配置对象
 * （忘记filterConfigs怎么来的话，回头去看初始化阶段）
*/
public FilterConfig findFilterConfig(String name) {
    return (filterConfigs.get(name));
}

添加过滤器配置对象到过滤器链中

filterChain.addFilter(filterConfig); // 添加过滤器配置对象

/**
* 在此先介绍下ApplicationFilterChain过滤器链类的两个重要属性
*/
public final class ApplicationFilterChain implements FilterChain {
	...
	// filters数组，用于保存过滤器配置对象
	private ApplicationFilterConfig[] filters = new ApplicationFilterConfig[0];
    // 表示filters中获取过滤器配置对象的索引位置，初始值为0。说明从头开始获取
    private int pos = 0;
	// filters中元素个数
    private int n = 0;
    // 扩容范围
    public static final int INCREMENT = 10;
    ...
}

/**
* 添加过滤器配置对象到filters中去
*/
void addFilter(ApplicationFilterConfig filterConfig) {
    for(ApplicationFilterConfig filter : filters) // 避免重复添加相同的过滤器配合对象
        if(filter==filterConfig)
            return;
    if (n == filters.length) { // 过滤器达到数组最大值
        ApplicationFilterConfig[] newFilters = new ApplicationFilterConfig[n + INCREMENT]; // 扩容（扩大10个长度）
        System.arraycopy(filters, 0, newFilters, 0, n);
        filters = newFilters;
    }
    filters[n++] = filterConfig; // 将filterConfig添加到filters末尾
}

到此，过滤器链filterChain的创建和初始化已经完成了。

那么终于来到过滤器的最后一步，执行过滤器链中的过滤器。让我们重新回到StandardWrapperValve类中的invoke方法

filterChain.doFilter(request.getRequest(), response.getResponse()); // 执行过滤器链中的所有过滤器的doFilter方法（注意，这里调用的是过滤器链的doFilter方法，而不是过滤器的）

@Override
public void doFilter(ServletRequest request, ServletResponse response) throws IOException, ServletException {
    if( Globals.IS_SECURITY_ENABLED ) {
		...
    } else {
        internalDoFilter(request,response); // 重点关注这个方法
    }
}

/**
* 终于来真正执行过滤器doFilter的方法
*/
private void internalDoFilter(ServletRequest request, ServletResponse response) throws IOException, ServletException {
    if (pos < n) { // 获取位置 < 过滤器个数，说明还有过滤器未执行，继续获取
        ApplicationFilterConfig filterConfig = filters[pos++]; // 从filters头开始往后获取当中的过滤器配置对象
        try {
            Filter filter = filterConfig.getFilter(); // 获取真正的过滤器对象
            if (request.isAsyncSupported() && "false".equalsIgnoreCase(filterConfig.getFilterDef().getAsyncSupported())) {
                request.setAttribute(Globals.ASYNC_SUPPORTED_ATTR, Boolean.FALSE);
            }
            if( Globals.IS_SECURITY_ENABLED ) {
                final ServletRequest req = request;
                final ServletResponse res = response;
                Principal principal = ((HttpServletRequest) req).getUserPrincipal();
                Object[] args = new Object[]{req, res, this};
                SecurityUtil.doAsPrivilege ("doFilter", filter, classType, args, principal);
            } else {
                filter.doFilter(request, response, this); // 执行过滤器的doFilter方法
            }
        } catch (IOException | ServletException | RuntimeException e) {
            throw e;
        } catch (Throwable e) {
            e = ExceptionUtils.unwrapInvocationTargetException(e);
            ExceptionUtils.handleThrowable(e);
            throw new ServletException(sm.getString("filterChain.filter"), e);
        }
        return; // 注意这里，直接返回，不执行下面的代码
    }

	// 如果代码执行到此，说明过滤器链中的所有过滤器已经执行完毕，并都通过
	// 开始执行相应servlet中的service方法
    try {
        if (ApplicationDispatcher.WRAP_SAME_OBJECT) {
            lastServicedRequest.set(request);
            lastServicedResponse.set(response);
        }
        if (request.isAsyncSupported() && !servletSupportsAsync) {
            request.setAttribute(Globals.ASYNC_SUPPORTED_ATTR,
                    Boolean.FALSE);
        }
        // Use potentially wrapped request from this point
        if ((request instanceof HttpServletRequest) && (response instanceof HttpServletResponse) && Globals.IS_SECURITY_ENABLED ) {
            final ServletRequest req = request;
            final ServletResponse res = response;
            Principal principal = ((HttpServletRequest) req).getUserPrincipal();
            Object[] args = new Object[]{req, res};
            SecurityUtil.doAsPrivilege("service",
                                       servlet,
                                       classTypeUsedInService,
                                       args,
                                       principal);
        } else {
            servlet.service(request, response); // 执行serlvet中的service方法
        }
    } catch (IOException | ServletException | RuntimeException e) {
        throw e;
    } catch (Throwable e) {
        e = ExceptionUtils.unwrapInvocationTargetException(e);
        ExceptionUtils.handleThrowable(e);
        throw new ServletException(sm.getString("filterChain.servlet"), e);
    } finally {
        if (ApplicationDispatcher.WRAP_SAME_OBJECT) {
            lastServicedRequest.set(null);
            lastServicedResponse.set(null);
        }
    }
}

@WebFilter(urlPatterns = "/my")
public class MyFilter implements Filter {
	...
	/**
	* 经历了这么多，终于调用到这个doFilter方法了
	*/
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException { 
        System.out.println("doFilter...");
        chain.doFilter(request, response); // 在此处重新调用过滤器链的doFilter，执行下一个过滤器的doFilter方法
    }
    ...
}

最后的最后，终于执行到过滤器的doFilter方法了！！！

说到底，其实这个过滤器执行阶段的话，就是首先通过过滤器链工厂创建过滤器链对象。然后根据配置信息的过滤器名和过滤路径，从容器中获取对应的过滤器配置对象，并将其加入到过滤器链对象中的过滤器数组中，最后将执行数组中包含的所有过滤器对象的doFilter方法。

最后为了加深理解，再基于第二阶段的源码分析，送出一图那么本文的再最后说一个细节，就是在过滤器的doFilter方法如果需要执行下一个过滤器的话，必须要调用 chain.doFilter(request, response) 。

正是基于以上的逻辑，我们通常会在Filter中做请求校验的业务。当校验通过，则继续执行下一个Filter，或者执行servlet处理请求；否则，就停止传递请求，返回错误信息给前端

原文链接：https://blog.csdn.net/weixin_41083377/article/details/115307195

检测到目标URL存在httphost头攻击漏洞修复方案

Tue, 05 Jun 2018 00:00:00 +0000

1、漏洞说明

检测到目标URL存在httphost头攻击漏洞

2、基于Nginx的修复方案

修改nginx.conf文件，如下：

http {
    server {
        listen       18080;
        server_name  172.0.0.1;
        #以下if条件判断是修复漏洞的关键代码，host头是否是指定的host，如果是则放行，不是就返回403
        #修改成你自己的IP+端口此处是关键代码
        if ($http_Host != '172.0.0.1:18080'){
                return 403;
        }
        location / {
            root   html;
            index  index.html index.htm;
        }
    }
}

【绿盟科技】检测到目标主机可能存在缓慢的HTTP拒绝服务攻击漏洞修复方案

Tue, 05 Jun 2018 00:00:00 +0000

1、漏洞说明

缓慢的HTTP拒绝服务攻击是一种专门针对于Web的应用层拒绝服务攻击，攻击者操纵网络上的肉鸡，对目标Web服务器进行海量HTTP请求攻击，直到服务器带宽被打满，造成了拒绝服务。慢速HTTP拒绝服务攻击经过不断的演变和发展，主要有三种攻击类型，分别是Slowheaders、Slowbody、Slowread。以Slowheaders为例，Web应用在处理HTTP请求之前都要先接收完所有的HTTP头部，因为HTTP头部中包含了一些Web应用可能用到的重要的信息。攻击者利用这点，发起一个HTTP请求，一直不停的发送HTTP头部，消耗服务器的连接和内存源。抓包数据可见，攻击客户端与服务器建立TCP连接后，每10秒才向服务器发送一个HTTP头部，而Web服务器在没接收到2个连续的\r\n时，会认为客户端没有发送完头部，而持续的等等客户端发送数据。如果恶意攻击者客户端持续建立这样的连接，那么服务器上可用的连接将一点一点被占满，从而导致拒绝服务。这种攻击类型称为慢速HTTP拒绝服务攻击。

2、基于Nginx的修复方案

修改nginx.conf文件，如下：

http {
	#limit_conn_zone $binary_remote_addr zone=addr:10m;
	limit_conn_status 503;
	#限制ip
    limit_req_zone $binary_remote_addr zone=ip_second:10m   rate=100r/s;
    limit_req   zone=ip_second  burst=5  nodelay;
    #限制url
    limit_req_zone $request_uri zone=url_minute:10m   rate=100r/s;
    limit_req   zone=url_minute  burst=5  nodelay;
    server {
        listen       80;
        server_name  localhost;
		#以下两段代码是关闭慢速连接，解决缓慢的HTTP拒绝服务攻击的关键两行
		client_body_timeout 3s;
		client_header_timeout 3s;
        location / {
            root   html;
            index  index.html index.htm;
		#	limit_conn addr 100;
        }
    }
}

参考链接： https://www.nginx.com/blog/mitigating-ddos-attacks-with-nginx-and-nginx-plus/

Windows Server 2008或2012 修复CVE-2016-2183，CVE-2013-2566，CVE-2015-2808漏洞

Tue, 05 Jun 2018 00:00:00 +0000

1 漏洞说明

Windows server 2008或2012远程桌面服务SSL加密默认是开启的，且有默认的CA证书。由于SSL/ TLS自身存在漏洞缺陷，当开启远程桌面服务，使用漏洞扫描工具扫描，发现存在SSL/TSL漏洞

2 修复办法

1、使用win+r 输入gpedit.msc进入组策略编辑器

2、依次打开”计算机配置”—->”管理模块”—–>”网络”—–>”SSL配置设置”—->双击打开”SSL密码套件顺序”

3.在“SSL密码套件”下修改SSL密码套件算法，仅保留TLS 1.2 SHA256 和 SHA384 密码套件、TLS 1.2 ECC GCM 密码套件（备注：建议先将SSL密码套件选项里的内容复制到txt文档中保存，以便恢复，再删除原有内容替换为以下内容，修改后，点击“应用”、“确定”，即可）

TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256_P256,TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256_P384,TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256_P521,TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384_P384,TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384_P521,TLS_RSA_WITH_AES_128_CBC_SHA256,TLS_RSA_WITH_AES_256_CBC_SHA256,TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256_P256,TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256_P384,TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256_P521,TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384_P256,TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384_P384,TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384_P521,TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256_P256,TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256_P384,TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256_P521,TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384_P384,TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384_P521,TLS_DHE_DSS_WITH_AES_128_CBC_SHA256,TLS_DHE_DSS_WITH_AES_256_CBC_SHA256,TLS_RSA_WITH_NULL_SHA,TLS_RSA_WITH_AES_128_CBC_SHA,TLS_DHE_DSS_WITH_AES_128_CBC_SHA

4.暂停系统并重启服务器

mysql windows 定时任务备份方案

Tue, 05 Jun 2018 00:00:00 +0000

1、新建mysql_bakup.bat脚本如下：

@echo off
echo ------------------------- 
echo mysql backup 
echo ------------------------- 
set "Ymd=%date:~,4%%date:~5,2%%date:~8,2%"
cd C:\Program Files\MySQL\MySQL Server 5.7\bin
mysqldump -h localhost -u root -123456 -P 3306 bhxq_db >C:\db_backup\db_%Ymd%.sql
cd \ 
@echo off 

2、 windows窗口 win+r 打开运行窗口,输入：compmgmt.msc,如下图所示：

3、系统工具->任务计划程序->任务计划程序库->右键创建任务

4、常规->勾选->不管用户是否登录都要运行

5、触发器->新建->设置定时任务执行时间和频次

6、操作->新建->选择第一步新建的bat脚本->确定

mysql-8.0.28 centos 安装

Tue, 05 Jun 2018 00:00:00 +0000

1 mysql下载：

1 、mysql社区版下载地址：https://downloads.mysql.com/archives/community/

2、选择product version 5.7.37

3 、linux为centos的话选择 operation system :Red Hat Enterprise Linux/Oracle Linux Os Version:All

4、选择 Red Hat Enterprise Linux 7 / Oracle Linux 7 (x86, 64-bit), RPM Bundle -> Download

2 mysql安装

1、首先清除CentOS7系统中默认的数据库mariadb，否则不能安装mysql

rpm -qa |grep mariadb |xargs yum remove -y

2、将下载的mysql-8.0.28-1.el7.x86_64.rpm-bundle.tar放到/usr/local/mysql目录，解压缩安装包

tar axvf mysql-8.0.28-1.el7.x86_64.rpm-bundle.tar

3、切换到下载包目录下（cd 你的下载目录），然后对每个包按如下顺序着一安装；

方案一：成功
 rpm -ivh mysql-community-common-8.0.28-1.el7.x86_64.rpm
 rpm -ivh mysql-community-libs-8.0.28-1.el7.x86_64.rpm --force --nodeps
 rpm -ivh mysql-community-libs-compat-8.0.28-1.el7.x86_64.rpm 
 rpm -ivh mysql-community-client-8.0.28-1.el7.x86_64.rpm --force --nodeps
 rpm -ivh mysql-community-server-8.0.28-1.el7.x86_64.rpm --force --nodeps

4、安装失败情况

检测本地已经安装的包：rpm -qa | grep mysql
卸载本地已经安装的包：rpm -e --nodeps mysql-community-xx

5、安装完成后，查看已经安装好的组件

rpm -qa | grep mysql

6、通过以下命令，完成对 mysql 数据库的初始化和相关配置

mysqld --initialize 
chown mysql:mysql /var/lib/mysql -R 
systemctl start mysqld.service systemctl  
enable mysqld

3 mysql启动

1、启动MySql

systemctl start mysqld.service

2、停止MySql

systemctl stop mysqld.service

3、重启MySql

systemctl restart mysqld.service

4、设置MySql开机自启

systemctl enable mysqld

5、通过 cat /var/log/mysqld.log | grep password 命令查看数据库的密码

cat /var/log/mysqld.log | grep password

2019-02-16T09:46:38.945518Z 5 [Note] [MY-010454] [Server] A temporary password is generated for root@localhost: ,#t#dlkOG0j0 以上密码为,#t#dlkOG0j0

#### 4 测试MySql安装是否成功
1、以root用户登录MySql，执行命令

mysql -u root -p

输入以上命令回车进入，出现输入密码提示
2、输入刚刚查到的密码，进行数据库的登陆，复制粘贴就行，MySQL 的登陆密码也是不显示的

Welcome to the MySQL monitor. Commands end with ; or g. Your MySQL connection id is 11 Server version: 8.0.15 Copyright (c) 2000, 2019, Oracle and/or its affiliates. All rights reserved. Oracle is a registered trademark of Oracle Corporation and/or its affiliates. Other names may be trademarks of their respective owners. Type ‘help;’ or ‘h’ for help. Type ‘c’ to clear the current input statement. mysql>

3、修改密码

use mysql; 密码检查等级，0/LOW、1/MEDIUM、2/STRONG set global validate_password.policy=0; a、密码的最短长度 set global validate_password.length=6; b、密码至少要包含的小写字母个数和大写字母个数 set global validate_password.mixed_case_count=0; c、设置密码 – ALTER USER ‘root’@’localhost’ IDENTIFIED BY ‘gzjbimbjpt@123’; –远程无法访问会出现Authentication plugin ‘caching_sha2_password’ cannot be loaded’问题

– ALTER USER ‘root’@’localhost’ IDENTIFIED WITH mysql_native_password BY ‘gzjbimbjpt@123’; – ALTER USER ‘root’@’%’ IDENTIFIED WITH mysql_native_password BY ‘gzjbimbjpt@123’;

4、通过 exit; 命令退出 MySQL，然后通过新密码再次登陆
至此，mysql8.0.15数据库就安装完成了。

#### 5 MySql远程访问授权配置
1、以root用户登录MySql

mysql -u root -p

2、以root用户登录MySql

USE mysql; UPDATE mysql.user SET host = ‘%’ WHERE user = ‘root’; flush privileges; SELECT host, user FROM user;

3、（暂且无用）使root（也可以配置其他的用户，如hadoop）用户可以操作数据库hive中的所有表

create user ‘root’@’%’ identified with mysql_native_password by ‘xhw888’; grant all privileges on . to ‘root’@’%’ with grant option; flush privileges; ``` 附：创建新用户： CREATE USER ‘用户名’@‘host名称’ IDENTIFIED WITH mysql_native_password BY ‘密码’;

给新用户授权：GRANT ALL PRIVILEGES ON . TO ‘用户名’@‘host名称’;

刷新权限： FLUSH PRIVILEGES;

ssm框架搭建

Mon, 04 Jun 2018 00:00:00 +0000

1、新建一个项目，如下图所示

2、选择maven-archetype-webapp

3、填写GroupId和ArtifactId

4、配置maven仓库地址

5、填写项目名称并点击完成

6、新建java、resource等资源包，项目结构如下图所示：

7、修改pom.xml文件添加依赖

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <spring.version>4.3.9.RELEASE</spring.version>
        <druid.version>1.0.18</druid.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.39</version>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>${druid.version}</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.1</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>1.3.0</version>
        </dependency>
        <dependency>
            <groupId>com.oracle</groupId>
            <artifactId>oracle-jdbc-driver</artifactId>
            <version>11.2.0</version>
            <scope>runtime</scope>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.0.1</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>

8、resources添加jdbc.properties配置文件

#oracle数据库
jdbc.driver=oracle.jdbc.driver.OracleDriver
jdbc.url=jdbc:oracle:thin:@ip:port:orcl
jdbc.username=username
jdbc.password=password
#pool settings
jdbc.pool.init=100
jdbc.pool.minIdle=3000
jdbc.pool.maxActive=10000
jdbc.testSql=SELECT 'x' FROM DUAL

9、修改web.xml配置文件

<web-app version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
  <display-name>Archetype Created Web Application</display-name>
  <servlet>
    <servlet-name>dispatcher</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:spring-*.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>dispatcher</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>
  <welcome-file-list>
    <welcome-file>index.jsp</welcome-file>
  </welcome-file-list>
</web-app>

10、resources添加spring-context.xml配置文件

<?xml version="1.0" encoding="utf-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

    <context:component-scan base-package="com"/>
    <context:property-placeholder ignore-unresolvable="true" location="classpath:jdbc.properties"/>
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/views/"/>
        <property name="suffix" value=".jsp"/>
    </bean>
</beans>

11、resources添加mybatis-config.xml配置文件

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration >
    <!-- 全局参数 -->
    <settings>
        <!-- 使全局的映射器启用或禁用缓存。 -->
        <setting name="cacheEnabled" value="true"/>

        <!-- 全局启用或禁用延迟加载。当禁用时，所有关联对象都会即时加载。 -->
        <setting name="lazyLoadingEnabled" value="true"/>

        <!-- 当启用时，有延迟加载属性的对象在被调用时将会完全加载任意属性。否则，每种属性将会按需要加载。 -->
        <setting name="aggressiveLazyLoading" value="true"/>

        <!-- 是否允许单条sql 返回多个数据集  (取决于驱动的兼容性) default:true -->
        <setting name="multipleResultSetsEnabled" value="true"/>

        <!-- 是否可以使用列的别名 (取决于驱动的兼容性) default:true -->
        <setting name="useColumnLabel" value="true"/>

        <!-- 允许JDBC 生成主键。需要驱动器支持。如果设为了true，这个设置将强制使用被生成的主键，有一些驱动器不兼容不过仍然可以执行。  default:false  -->
        <setting name="useGeneratedKeys" value="false"/>

        <!-- 指定 MyBatis 如何自动映射 数据基表的列 NONE：不隐射　PARTIAL:部分  FULL:全部  -->
        <setting name="autoMappingBehavior" value="PARTIAL"/>

        <!-- 这是默认的执行类型  （SIMPLE: 简单； REUSE: 执行器可能重复使用prepared statements语句；BATCH: 执行器可以重复执行语句和批量更新）  -->
        <setting name="defaultExecutorType" value="SIMPLE"/>

        <!-- 使用驼峰命名法转换字段。 -->
        <setting name="mapUnderscoreToCamelCase" value="true"/>

        <!-- 设置本地缓存范围 session:就会有数据的共享  statement:语句范围 (这样就不会有数据的共享 ) defalut:session -->
        <setting name="localCacheScope" value="SESSION"/>

        <!-- 设置但JDBC类型为空时,某些驱动程序 要指定值,default:OTHER，插入空值时不需要指定类型 -->
        <setting name="jdbcTypeForNull" value="NULL"/>

    </settings>
</configuration>

12、resources添加spring-datasource.xml配置文件

<?xml version="1.0" encoding="utf-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd ">


    <!-- 定义事务 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource" />
    </bean>
    <!-- 数据源配置, 使用 BoneCP 数据库连接池 -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
        <!-- 数据源驱动类可不写，Druid默认会自动根据URL识别DriverClass -->
        <property name="driverClassName" value="${jdbc.driver}" />

        <!-- 基本属性 url、user、password -->
        <property name="url" value="${jdbc.url}" />
        <property name="username" value="${jdbc.username}" />
        <property name="password" value="${jdbc.password}" />

        <!-- 配置初始化大小、最小、最大 -->
        <property name="initialSize" value="${jdbc.pool.init}" />
        <property name="minIdle" value="${jdbc.pool.minIdle}" />
        <property name="maxActive" value="${jdbc.pool.maxActive}" />

        <!-- 配置获取连接等待超时的时间 -->
        <property name="maxWait" value="60000" />

        <!-- 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒 -->
        <property name="timeBetweenEvictionRunsMillis" value="60000" />

        <!-- 配置一个连接在池中最小生存的时间，单位是毫秒 -->
        <property name="minEvictableIdleTimeMillis" value="300000" />

        <property name="validationQuery" value="${jdbc.testSql}" />
        <property name="testWhileIdle" value="true" />
        <property name="testOnBorrow" value="false" />
        <property name="testOnReturn" value="false" />

        <!-- 打开PSCache，并且指定每个连接上PSCache的大小（Oracle使用） -->
        <property name="poolPreparedStatements" value="true" />
        <property name="maxPoolPreparedStatementPerConnectionSize" value="20" />

        <!-- 配置监控统计拦截的filters -->
        <property name="filters" value="stat" />
    </bean>

    <!-- MyBatis begin -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <property name="typeAliasesPackage" value="com.entity"/>
        <property name="mapperLocations" value="classpath:/mapper/*.xml"/>
        <property name="configLocation" value="classpath:/mybatis-config.xml"></property>
    </bean>

    <!-- 扫描basePackage下所有以@MyBatisDao注解的接口 -->
    <bean id="mapperScannerConfigurer" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory" />
        <property name="basePackage" value="com.mapper"/>
    </bean>

</beans>

13、resources/mapper目录下添加TestMapper.xml映射文件

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >

<mapper namespace="com.mapper.TestMapper">

        <parameterMap id="parameterMap" type="com.entity.Test"></parameterMap>
        <resultMap id="resultMap" type="com.entity.Test">
            <result property="id" column="id"/>
            <result property="userName" column="USER_NAME"/>
            <result property="gender" column="GENDER"/>
            <result property="email" column="EMAIL"/>
            <result property="age" column="AGE"/>
            <result property="createDate" column="CREATE_DATE"/>
            <result property="updateDate" column="UPDATE_DATE"/>
        </resultMap>

    <sql id="columnSql">
        <trim suffixOverrides=",">
            a.id as id,
            a.USER_NAME as USER_NAME,
            a.GENDER as GENDER,
            a.EMAIL as EMAIL,
            a.AGE as AGE,
            a.CREATE_DATE as CREATE_DATE,
            a.UPDATE_DATE as UPDATE_DATE
        </trim>
    </sql>
    <select id="selectOne" resultMap="resultMap">
        SELECT
        <include refid="columnSql"></include>
        FROM test_table a
        WHERE rownum = 1
    </select>
    <insert id="insert">
          insert into test_table (
            id,
            USER_NAME,
            GENDER,
            EMAIL,
            AGE,
            CREATE_DATE,
            UPDATE_DATE
        ) values(
            #{id},
            #{userName,jdbcType=VARCHAR},
            #{gender,jdbcType=VARCHAR},
            #{email,jdbcType=VARCHAR},
            #{age,jdbcType=VARCHAR},
            #{createDate,jdbcType=DATE},
            #{updateDate,jdbcType=DATE}
        )
    </insert>
</mapper>

13、main\java\com\entity目录下添加Test.java文件

package com.entity;


import java.util.Date;

/**
 * @Description 测试实体类
 * @Author wanglz
 * @Date 2018/06/02 14:05
 **/
public class Test {
    private String id;
    private String userName;
    private String gender;
    private String email;
    private Integer age;
    private Date createDate;
    private Date updateDate;

    public Test() {
    }

    public Test(String id, String userName, String gender, String email, Integer age, Date createDate, Date updateDate) {
        this.id = id;
        this.userName = userName;
        this.gender = gender;
        this.email = email;
        this.age = age;
        this.createDate = createDate;
        this.updateDate = updateDate;
    }
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Date getCreateDate() {
        return createDate;
    }

    public void setCreateDate(Date createDate) {
        this.createDate = createDate;
    }

    public Date getUpdateDate() {
        return updateDate;
    }

    public void setUpdateDate(Date updateDate) {
        this.updateDate = updateDate;
    }
}

14、main\java\com\mapper目录下添加TestMapper.java接口

package com.mapper;
import entity.Test;
import org.apache.ibatis.annotations.Mapper;
import org.springframework.stereotype.Repository;
/**
 * @Description 映射接口
 * @Author wanglz
 * @Date 2018/06/02 14:06
 **/
@Mapper
@Repository
public interface TestMapper {
    Test selectOne();
    void insert(Test test);
}

15、main\java\com\service目录下添加TestService.java文件

package com.service;
import entity.Test;
import mapper.TestMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * @Description service层
 * @Author wanglz
 * @Date 2018/06/02 14:06
 **/
@Service
public class TestService {
    @Autowired
    private TestMapper testMapper;

    public void insert(Test test){
        testMapper.insert(test);
    }

    public Test selectOne() {
        return testMapper.selectOne();
    }
}

16、main\java\com\controller目录下添加TestController.java文件

package com.controller;
import entity.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import service.TestService;
import java.util.Date;
import java.util.UUID;

/**
 * @Description 控制层
 * @Author wanglz
 * @Date 2018/06/02 14:16
 **/
@Controller
@RequestMapping("/test")
public class TestController {
    @Autowired
    private TestService testService;

    @RequestMapping("/index")
    public String index(Model model) {
        Test test = testService.selectOne();
        model.addAttribute("id", test.getId());
        return "index";
    }

    @RequestMapping("/insert")
    @ResponseBody
    public String insert() {
        testService.insert(new Test(UUID.randomUUID().toString(), "张三", "男", "123424@qq.com", 32, new Date(), new Date()));
        return "success";
    }
}

Angular集成dhtmlx-gantt甘特图

Sun, 03 Jun 2018 00:00:00 +0000

安装dhtmlx-gantt甘特图依赖

npm install dhtmlx-gantt --save

新增甘特图weekly-plan-management.componet.ts组件如下：

import {Component, ElementRef, OnInit, ViewChild} from '@angular/core';
import "dhtmlx-gantt";


import {TaskServiceService} from "./task-service.service";
import {LinkServiceService} from "./link-service.service";

@Component({
  selector: 'weekly-plan-management',
  styles: [
      `
      :host {
        display: block;
        height: 600px;
        position: relative;
        width: 100%;
      }
    `],
  providers: [TaskServiceService, LinkServiceService],
  template: "<div #gantt_here style='width: 100%; height: 100%;'></div>",
})

export class WeeklyPlanManagementComponent implements OnInit {

  constructor(
      private taskService: TaskServiceService, 
      private linkService: LinkServiceService
      ) {
  }

  @ViewChild("gantt_here") ganttContainer: ElementRef;

  ngOnInit() {
    gantt.config.xml_date = "%Y-%m-%d %H:%i";

    gantt.init(this.ganttContainer.nativeElement);

    Promise.all([this.taskService.get(), this.linkService.get()])
      .then(([data, links]) => {
        gantt.parse({data, links});
    });
  }

}

Link.ts代码如下：

export class Link {
  id: number;
  source: number;
  target: number;
  type: string;
}

Task.ts代码如下：

export class Task {
  id: number;
  start_date: string;
  text: string;
  duration: number;
  progress: number;
}

task-service.service.ts代码如下：

import { Injectable } from '@angular/core';
import {Task} from "./Task";
@Injectable({
  providedIn: 'root'
})
export class TaskServiceService {
  get(): Promise<Task[]>{
    return Promise.resolve([
      {id: 1, text: "Task #1", start_date: "2017-04", duration: 3, progress: 0.6},
      {id: 2, text: "Task #2", start_date: "2017-05", duration: 3, progress: 0.4}
    ]);
  }
}

link-service.service.ts代码如下：

import { Injectable } from '@angular/core';
import {Link} from "./link";

@Injectable({
  providedIn: 'root'
})
export class LinkServiceService {

  get(): Promise<Link[]> {
    return Promise.resolve([
      {id: 1, source: 1, target: 2, type: "0"}
    ]);
  }
}

src/style.less代码如下：

@import '../node_modules/dhtmlx-gantt/codebase/dhtmlxgantt.css';

linux系统安装jdk方法

Sat, 02 Jun 2018 00:00:00 +0000

linux系统安装jdk

1、在home目录下新建software目录

[root@localhost /]# mkdir home/software

[root@localhost /]# mkdir usr/java

3、将jdk压缩文件上传至home/software目录下

4、解压jdk

[root@localhost /]# tar -zxvf jdk-8u191-linux-x64.tar.gz

5、将解压后的jdk移至usr/java目录下

[root@localhost /]#  mv jdk1.8.0_191/ /usr/java/

6、配置环境变量

编辑etc下的profile文件（vi /etc/profile）并在最后添加jdk环境变量：

export JAVA_HOME=/usr/java/jdk1.8.0_191
export CLASSPATH=.:%JAVA_HOME%/lib/dt.jar:%JAVA_HOME%/lib/tools.jar
export PATH=$PATH:$JAVA_HOME/bin

7、刷新profile,使其生效

[root@localhost /]# source /etc/profile

似水无痕

Tools Typora1.2.4

Typora1.2.4破解方案

第一步：下载Typora1.2.4

Typora官网下载地址：

GITHUB下载地址：

百度网盘下载地址：

第二步：破解

Filter过滤器源码解析

什么是Filter

初步了解Filter接口

Filter的执行流程

检测到目标URL存在httphost头攻击漏洞修复方案

1、 漏洞说明

2、 基于Nginx的修复方案

【绿盟科技】检测到目标主机可能存在缓慢的HTTP拒绝服务攻击漏洞修复方案

1、漏洞说明

2、基于Nginx的修复方案

Windows Server 2008或2012 修复CVE-2016-2183，CVE-2013-2566，CVE-2015-2808漏洞

1 漏洞说明

2 修复办法

mysql windows 定时任务备份方案

1、新建mysql_bakup.bat脚本如下：

2、 windows窗口 win+r 打开运行窗口,输入：compmgmt.msc,如下图所示：

3、 系统工具->任务计划程序->任务计划程序库->右键创建任务

4、 常规->勾选->不管用户是否登录都要运行

5、 触发器->新建->设置定时任务执行时间和频次

6、 操作->新建->选择第一步新建的bat脚本->确定

mysql-8.0.28 centos 安装

1 mysql下载：

2 mysql安装

3 mysql启动

ssm框架搭建

1、新建一个项目，如下图所示

2、选择maven-archetype-webapp

3、填写GroupId和ArtifactId

4、配置maven仓库地址

5、填写项目名称并点击完成

6、新建java、resource等资源包，项目结构如下图所示：

7、修改pom.xml文件添加依赖

8、resources添加jdbc.properties配置文件

9、修改web.xml配置文件

10、resources添加spring-context.xml配置文件

11、resources添加mybatis-config.xml配置文件

12、resources添加spring-datasource.xml配置文件

13、resources/mapper目录下添加TestMapper.xml映射文件

13、main\java\com\entity目录下添加Test.java文件

14、main\java\com\mapper目录下添加TestMapper.java接口

15、main\java\com\service目录下添加TestService.java文件

16、main\java\com\controller目录下添加TestController.java文件

Angular集成dhtmlx-gantt甘特图

安装dhtmlx-gantt甘特图依赖

新增甘特图weekly-plan-management.componet.ts组件如下：

Link.ts代码如下：

Task.ts代码如下：

task-service.service.ts代码如下：

link-service.service.ts代码如下：

src/style.less代码如下：

linux系统安装jdk方法

linux系统安装jdk

1、漏洞说明

2、基于Nginx的修复方案

3、系统工具->任务计划程序->任务计划程序库->右键创建任务

4、常规->勾选->不管用户是否登录都要运行

5、触发器->新建->设置定时任务执行时间和频次

6、操作->新建->选择第一步新建的bat脚本->确定