原

JavaWeb中的Struts2概述

                                                                               2017年07月26日 15:00:58
                   豆芽胡
                       阅读数：207


                               标签：
                                                               JavaWeb                                                               web.xml                                                               struts                                                               struts2.0
                           更多

                               个人分类：
                                                               JavaWeb

Struts2是一种基于MVC模式的javaWeb框架，本质上相当于Servlet。

所谓MVC，就是模型-视图-控制器。

Model（模型）表示应用程序核心（比如数据库记录列表）。

View（视图）显示数据（数据库记录）。

Controller（控制器）处理输入（写入数据库记录）

而Struts的作用实际上是作为控制器，建立模型层和视图层的数据交互（就是通常所说控制model和jsp之间的数据交互）

上面都是废话，你只要知道struts2能控制model和jsp之间的数据交互即可。

web程序想要使用struts2框架，除了要引用相关jar包外，还要在web.xml中对struts2进行配置，只有配置后，struts2才能对浏览器的请求进行一系列处理。

怎么在web应用中配置struts2?

首先在web.xml中添加struts2的使用，代码如下：


    <!-- 配置Struts2 核心 Filter -->
    <filter>
        <filter-name>action2</filter-name>
        <filter-class>org.apache.struts2.dispatcher.filter.StrutsPrepareAndExecuteFilter</filter-class>
    </filter>
 
    <filter-mapping>
        <filter-name>action2</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

上述代码使用了Filter，那我们就回顾一下Filter的作用。

回顾：Filter，中文名为过滤器，通过Filter可以对web服务器的资源进行管理，例如Jsp,Servlet, 静态图片文件等进行拦截，从而实现一些特殊的功能。

实现URL级别的权限访问控制、过滤敏感词汇、压缩响应信息等一些高级功能

从代码层面来讲，只要创建一个实现了Filter接口的实现类，然后将这个类在web.xml进行配置，那么这个类就可以让用户在访问某个目标资源之前，对访问的请求和响应进行拦截。

更多介绍可以看我的另外一篇文章：http://blog.csdn.net/u012605477/article/details/75258358

注意：Struts2在web.xml中看来就是一个Filter，只不过其实现类StrutsPrepareAndExecuteFilter不是我们写的，是Struts2的。

为了验证StrutsPrepareAndExecuteFilter也实现了Filter接口，我们将其和我们自写的过滤器进行对比：

下面是自写的过滤器FilterA配置：


    <filter>
        <filter-name>FilterA</filter-name>
        <filter-class>com.strategy.jpa.FilterA</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>FilterA</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

自写FilterA的代码：


package com.strategy.jpa;
 
import java.io.IOException;
 
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
 
public class FilterA implements Filter {
 
    public void init(FilterConfig filterConfig) throws ServletException {
 
    }
 
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        
        
        chain.doFilter(request, response);
        response.reset();
        
    }
 
    public void destroy() {
 
    }
 
}

web中配置Struts2的代码：


 * $Id: DefaultActionSupport.java 651946 2008-04-27 13:41:38Z apetrelli $
package org.apache.struts2.dispatcher.filter;
 
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.apache.struts2.RequestUtils;
import org.apache.struts2.StrutsStatics;
import org.apache.struts2.dispatcher.Dispatcher;
import org.apache.struts2.dispatcher.mapper.ActionMapping;
import org.apache.struts2.dispatcher.ExecuteOperations;
import org.apache.struts2.dispatcher.InitOperations;
import org.apache.struts2.dispatcher.PrepareOperations;
 
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.List;
import java.util.regex.Pattern;
 
/**
 * Handles both the preparation and execution phases of the Struts dispatching process.  This filter is better to use
 * when you don't have another filter that needs access to action context information, such as Sitemesh.
 */
public class StrutsPrepareAndExecuteFilter implements StrutsStatics, Filter {
 
    private static final Logger LOG = LogManager.getLogger(StrutsPrepareAndExecuteFilter.class);
 
    protected PrepareOperations prepare;
    protected ExecuteOperations execute;
    protected List<Pattern> excludedPatterns = ;
 
    public void init(FilterConfig filterConfig) throws ServletException {
        InitOperations init = new InitOperations();
        Dispatcher dispatcher = ;
        try {
            FilterHostConfig config = new FilterHostConfig(filterConfig);
            init.initLogging(config);
            dispatcher = init.initDispatcher(config);
            init.initStaticContentLoader(config, dispatcher);
 
            prepare = new PrepareOperations(dispatcher);
            execute = new ExecuteOperations(dispatcher);
            this.excludedPatterns = init.buildExcludedPatternsList(dispatcher);
 
            postInit(dispatcher, filterConfig);
        } finally {
            if (dispatcher != ) {
                dispatcher.cleanUpAfterInit();
            }
            init.cleanup();
        }
    }
 
    /**
     * Callback for post initialization
     *
     * @param dispatcher the dispatcher
     * @param filterConfig the filter config
     */
    protected void postInit(Dispatcher dispatcher, FilterConfig filterConfig) {
    }
 
    public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throws IOException, ServletException {
 
        HttpServletRequest request = (HttpServletRequest) req;
        HttpServletResponse response = (HttpServletResponse) res;
 
        try {
            String uri = RequestUtils.getUri(request);
            if (excludedPatterns !=  && prepare.isUrlExcluded(request, excludedPatterns)) {
                LOG.trace("Request {} is excluded from handling by Struts, passing request to other filters", uri);
                chain.doFilter(request, response);
            } else {
                LOG.trace("Checking if {} is a static resource", uri);
                boolean handled = execute.executeStaticResourceRequest(request, response);
                if (!handled) {
                    LOG.trace("Assuming uri {} as a normal action", uri);
                    prepare.setEncodingAndLocale(request, response);
                    prepare.createActionContext(request, response);
                    prepare.assignDispatcherToThread();
                    request = prepare.wrapRequest(request);
                    ActionMapping mapping = prepare.findActionMapping(request, response, true);
                    if (mapping == ) {
                        LOG.trace("Cannot find mapping for {}, passing to other filters", uri);
                        chain.doFilter(request, response);
                    } else {
                        LOG.trace("Found mapping {} for {}", mapping, uri);
                        execute.executeAction(request, response, mapping);
                    }
                }
            }
        } finally {
            prepare.cleanupRequest(request);
        }
    }
 
    public void destroy() {
        prepare.cleanupDispatcher();
    }
 
}

对比可知，struts2也实现了Filter接口，只是他比我们自己写的FilterA多实现了一个接口StrutsStatics，其它的没有变化。

我们对上面的代码进行了解：

在Init方法里面，我们看到有一个config对象，该类对象的作用是对FilterConfig进行封装。


package org.apache.struts2.dispatcher.filter;
 
import org.apache.struts2.util.MakeIterator;
 
import javax.servlet.FilterConfig;
import javax.servlet.ServletContext;
import java.util.Iterator;
 
import org.apache.struts2.dispatcher.HostConfig;
 
/**
 * Host configuration that wraps FilterConfig
 */
public class FilterHostConfig implements HostConfig {
 
    private FilterConfig config;
 
    public FilterHostConfig(FilterConfig config) {
        this.config = config;
    }
    public String getInitParameter(String key) {
        return config.getInitParameter(key);
    }
 
    public Iterator<String> getInitParameterNames() {
        return MakeIterator.convert(config.getInitParameterNames());
    }
 
    public ServletContext getServletContext() {
        return config.getServletContext();
    }
}

然后又在Init方法里面通过创建的config对象，并调用initDispatcher方法创建了转发器对象dispatcher对象。以及通过initLogging方法初始化日志记录器。


    private Dispatcher createDispatcher( HostConfig filterConfig ) {
        Map<String, String> params = new HashMap<>();
        for ( Iterator e = filterConfig.getInitParameterNames(); e.hasNext(); ) {
            String name = (String) e.next();
            String value = filterConfig.getInitParameter(name);
            params.put(name, value);
        }
        return new Dispatcher(filterConfig.getServletContext(), params);
    }
 
    public void cleanup() {
        ActionContext.setContext();
    }


    public void initLogging( HostConfig filterConfig ) {
        String factoryName = filterConfig.getInitParameter("loggerFactory");
        if (factoryName != ) {
            try {
                Class cls = ClassLoaderUtil.loadClass(factoryName, this.getClass());
                LoggerFactory fac = (LoggerFactory) cls.newInstance();
                LoggerFactory.setLoggerFactory(fac);
            } catch ( InstantiationException e ) {
                System.err.println("Unable to instantiate logger factory: " + factoryName + ", using default");
                e.printStackTrace();
            } catch ( IllegalAccessException e ) {
                System.err.println("Unable to access logger factory: " + factoryName + ", using default");
                e.printStackTrace();
            } catch ( ClassNotFoundException e ) {
                System.err.println("Unable to locate logger factory class: " + factoryName + ", using default");
                e.printStackTrace();
            }
        }
    }

接下来调用了init对象initStaticContentLoader(config, dispatcher);方法加载一些静态资源。


    public StaticContentLoader initStaticContentLoader( HostConfig filterConfig, Dispatcher dispatcher ) {
        StaticContentLoader loader = dispatcher.getContainer().getInstance(StaticContentLoader.class);
        loader.setHostConfig(filterConfig);
        return loader;
    }

最重要的就是dispatcher，它主要将filter拦截到的请求转入struts2的请求处理模块，我们必须知道这一点。

其次是FilterConfig，它将我们在web.xml中的Filter的配置信息也保存到了dispatcher中。下面是该对象的构造方法。


    public Dispatcher(ServletContext servletContext, Map<String, String> initParams) {
        this.servletContext = servletContext;
        this.initParams = initParams;
    }

接下来就是prepare和execute对象，和InitOperations类似，也是进行了封装一些操作，都是截取一部分重要的代码。


    public PrepareOperations(Dispatcher dispatcher) {
        this.dispatcher = dispatcher;
    }
    public ActionContext createActionContext(HttpServletRequest request, HttpServletResponse response) {
        ActionContext ctx;
        Integer counter = 1;
        Integer oldCounter = (Integer) request.getAttribute(CLEANUP_RECURSION_COUNTER);
        if (oldCounter != ) {
            counter = oldCounter + 1;
        }
        
        ActionContext oldContext = ActionContext.getContext();
        if (oldContext != ) {
            // detected existing context, so we are probably in a forward
            ctx = new ActionContext(new HashMap<>(oldContext.getContextMap()));
        } else {
            ValueStack stack = dispatcher.getContainer().getInstance(ValueStackFactory.class).createValueStack();
            stack.getContext().putAll(dispatcher.createContextMap(request, response, ));
            ctx = new ActionContext(stack.getContext());
        }
        request.setAttribute(CLEANUP_RECURSION_COUNTER, counter);
        ActionContext.setContext(ctx);
        return ctx;
    }

execute对象


    public ExecuteOperations(Dispatcher dispatcher) {
        this.dispatcher = dispatcher;
    }
 
    public boolean executeStaticResourceRequest(HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException {
        // there is no action in this request, should we look for a static resource?
        String resourcePath = RequestUtils.getServletPath(request);
 
        if ("".equals(resourcePath) &&  != request.getPathInfo()) {
            resourcePath = request.getPathInfo();
        }
 
        StaticContentLoader staticResourceLoader = dispatcher.getContainer().getInstance(StaticContentLoader.class);
        if (staticResourceLoader.canHandle(resourcePath)) {
            staticResourceLoader.findStaticResource(resourcePath, request, response);
            // The framework did its job here
            return true;
 
        } else {
            // this is a normal request, let it pass through
            return false;
        }
    }

从上面的代码可以看出，这两个对象封装了请求预处理和请求处理的操作，当处理请求时方法被调用

在上述的代码中有个很重要的方法未罗列出来，那就是Disptcher中得init方法，该方法初始读取一些配置文件，包含我们想要知道的读取struts2.xml的方法。


    public void init() {
 
        if (configurationManager == ) {
            configurationManager = createConfigurationManager(DefaultBeanSelectionProvider.DEFAULT_BEAN_NAME);
        }
 
        try {
            init_FileManager();
            init_DefaultProperties(); // [1]
            init_TraditionalXmlConfigurations(); // [2]
            init_LegacyStrutsProperties(); // [3]
            init_CustomConfigurationProviders(); // [5]
            init_FilterInitParameters() ; // [6]
            init_AliasStandardObjects() ; // [7]
 
            Container container = init_PreloadConfiguration();
            container.inject(this);
            init_CheckWebLogicWorkaround(container);
 
            if (!dispatcherListeners.isEmpty()) {
                for (DispatcherListener l : dispatcherListeners) {
                    l.dispatcherInitialized(this);
                }
            }
            errorHandler.init(servletContext);
 
        } catch (Exception ex) {
            LOG.error("Dispatcher initialization failed", ex);
            throw new StrutsException(ex);
        }
    }

上面是init方法，里面调用了诸多读取配置文件的方法，包含我们想要知道的读取struts.xml的方法：


    private void init_TraditionalXmlConfigurations() {
        String configPaths = initParams.get("config");
        if (configPaths == ) {
            configPaths = DEFAULT_CONFIGURATION_PATHS;
        }
        String[] files = configPaths.split("\\s*[,]\\s*");
        for (String file : files) {
            if (file.endsWith(".xml")) {
                if ("xwork.xml".equals(file)) {
                    configurationManager.addContainerProvider(createXmlConfigurationProvider(file, false));
                } else {
                    configurationManager.addContainerProvider(createStrutsXmlConfigurationProvider(file, false, servletContext));
                }
            } else {
                throw new IllegalArgumentException("Invalid configuration file name");
            }
        }
    }

在上面的代码中，设定了读取struts.xml的默认路径，其内容如下：

private static final String DEFAULT_CONFIGURATION_PATHS = "struts-default.xml,struts-plugin.xml,struts.xml";

至此，web应用配置struts2框架，以及struts2如何将Filter封装成struts2的，甚至如何读取struts.xml以及其他配置，并进行相关struts2参数初始化都有了大概了解，接下来说一下Action。

回到StrutsPrepareAndExecuteFilter类的doFilter中，


    //每次发送一个Request，StrutsPrepareAndExecuteFilter都会调用doFilter方法  
    public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throws IOException, ServletException {  
  
        HttpServletRequest request = (HttpServletRequest) req;  
        HttpServletResponse response = (HttpServletResponse) res;  
  
        try {  
            //设置编码和国际化    
            prepare.setEncodingAndLocale(request, response);  
            //ActionContext创建  
            prepare.createActionContext(request, response);  
            prepare.assignDispatcherToThread();  
            if ( excludedPatterns !=  && prepare.isUrlExcluded(request, excludedPatterns)) {  
                chain.doFilter(request, response);  
            } else {  
                request = prepare.wrapRequest(request);  
                ActionMapping mapping = prepare.findActionMapping(request, response, true);  
                //如果找不到对应的action配置  
                if (mapping == ) {  
                    /* 
                     * 就是如果path是以“/struts”开头，则到初始参数packages配置的包路径去查找对应的静态资源并输出到页面流中， 
                     * 当然.class文件除外。如果再没有则跳转到404 
                     */  
                    boolean handled = execute.executeStaticResourceRequest(request, response);  
                    if (!handled) {  
                        chain.doFilter(request, response);  
                    }  
                } else {  
                    /* 
                     * 找到对应action配置文件后，调用ExecuteOperations类中executeAction， 
                     * 开始谳用Action的方法。 
                     */  
                    execute.executeAction(request, response, mapping);  
                }  
            }  
        } finally {  
            prepare.cleanupRequest(request);  
        }  
    }

相关准备（prepare）方法，设置编码的方法不再叙述（setEncodingAndLocale），我们主要说一下ActionContext。

prepare.createActionContext(request, response);

ActionContext是一个struts2容器，主要存储request、session、application、parameters等相关信息。

ActionContext是一个线程的本地变量，这意味着不同的action之间不会共享ActionContext，所以也不用考虑线程安全问题


    public ActionContext createActionContext(HttpServletRequest request, HttpServletResponse response) {
        ActionContext ctx;
        Integer counter = 1;
        Integer oldCounter = (Integer) request.getAttribute(CLEANUP_RECURSION_COUNTER);
        if (oldCounter != ) {
            counter = oldCounter + 1;
        }
        
        ActionContext oldContext = ActionContext.getContext();
        if (oldContext != ) {
            // detected existing context, so we are probably in a forward
            ctx = new ActionContext(new HashMap<>(oldContext.getContextMap()));
        } else {
            ValueStack stack = dispatcher.getContainer().getInstance(ValueStackFactory.class).createValueStack();
            stack.getContext().putAll(dispatcher.createContextMap(request, response, ));
            ctx = new ActionContext(stack.getContext());
        }
        request.setAttribute(CLEANUP_RECURSION_COUNTER, counter);
        ActionContext.setContext(ctx);
        return ctx;
    }

我们再看一下ActionContext是什么，取部分代码，由此可知ActionContext是一个键值对集合，跟Spring中的bean类似：


public class ActionContext implements Serializable {
 
    static ThreadLocal<ActionContext> actionContext = new ThreadLocal<>();
    
    private Map<String, Object> context;
 
    public ActionContext(Map<String, Object> context) {
        this.context = context;
    }

有了创建Action的方法，肯定有使用Action的方法，我们现在去找使用的方法：


    public void serviceAction(HttpServletRequest request, HttpServletResponse response, ActionMapping mapping)
            throws ServletException {
 
        Map<String, Object> extraContext = createContextMap(request, response, mapping);
 
        // If there was a previous value stack, then create a new copy and pass it in to be used by the new Action
        ValueStack stack = (ValueStack) request.getAttribute(ServletActionContext.STRUTS_VALUESTACK_KEY);
        boolean nullStack = stack == ;
        if (nullStack) {
            ActionContext ctx = ActionContext.getContext();
            if (ctx != ) {
                stack = ctx.getValueStack();
            }
        }
        if (stack != ) {
            extraContext.put(ActionContext.VALUE_STACK, valueStackFactory.createValueStack(stack));
        }
 
        String timerKey = "Handling request from Dispatcher";
        try {
            UtilTimerStack.push(timerKey);
            String namespace = mapping.getNamespace();
            String name = mapping.getName();
            String method = mapping.getMethod();
 
            ActionProxy proxy = getContainer().getInstance(ActionProxyFactory.class).createActionProxy(
                    namespace, name, method, extraContext, true, false);
 
            request.setAttribute(ServletActionContext.STRUTS_VALUESTACK_KEY, proxy.getInvocation().getStack());
 
            // if the ActionMapping says to go straight to a result, do it!
            if (mapping.getResult() != ) {
                Result result = mapping.getResult();
                result.execute(proxy.getInvocation());
            } else {
                proxy.execute();
            }
 
            // If there was a previous value stack then set it back onto the request
            if (!nullStack) {
                request.setAttribute(ServletActionContext.STRUTS_VALUESTACK_KEY, stack);
            }
        } catch (ConfigurationException e) {
            logConfigurationException(request, e);
            sendError(request, response, HttpServletResponse.SC_NOT_FOUND, e);
        } catch (Exception e) {
            if (handleException || devMode) {
                sendError(request, response, HttpServletResponse.SC_INTERNAL_SERVER_ERROR, e);
            } else {
                throw new ServletException(e);
            }
        } finally {
            UtilTimerStack.pop(timerKey);
        }
    }

在上面的try语句里面我们可以得知，struts是怎么通过命名空间，读取action的配置，以及action的method方法，

尤其是如何从容器中获得ActionProxyFactory代理工厂，是怎么创建ActionProxy来执行一个特定的命名空间和动作的。

以及怎么通过我们在struts2中设定的跳转方法，跳转到指定页面的。


            //执行execute方法，并转向结果   
            if (mapping.getResult() != ) {  
                Result result = mapping.getResult();  
                result.execute(proxy.getInvocation());  
            } else {  
                proxy.execute();  
            }

至此，对于Struts2是如何工作的，怎么读取xml的，如何搭建在web应用中基本叙述完了，更详细的实在说不完，各位大佬可以看下下面这位大神的博客，很给力，就是看起来太繁琐。

另外，本文部分来源于该大神，未通知，深表歉意。

http://blog.csdn.net/yuan_xw/article/details/7838123

阅读更多

收藏

新年折上折！德国钻石无油烟不粘锅！2折只限今日！不抢就亏了！

建颂企业 · 燨燚

                   还能输入1000个字符

JavaWeb中的Struts2概述

JavaWeb中的Struts2概述

LIUXUN1993728

Jorocco

豆芽胡

Jack-Chan

你可能感兴趣的:(JavaWeb中的Struts2概述)

JavaWeb中的Struts2概述

JavaWeb中的Struts2概述

Struts 2详细工作流程及原理

走进Struts2（一） — Struts2的运行流程及其工作原理

struts ---核心过滤器理解---

structs2框架介绍

struts1.x、struts2.x、Spring MVC原理总结

JavaWeb框架————Struts2（一）

JavaWeb使用Struts2的简单案例

struts2 概述

JavaWeb开发概述

文章热词

JAVAWEB开发之Struts2示例——Struts2练习之员工管理系统

LIUXUN1993728

Jorocco

豆芽胡

Jack-Chan

Java Web中选择Struts2,Spring等框架的分析

Struts中解耦与耦合

Struts2：输入校验-基于XML配置方式实现

javaweb项目中引入struts2后web.xml的详细配置和注释

JavaWeb三大框架之---struts2详解

拦截器的概述和struts2的执行流程（十）

JavaWeb-Hibernate-Struts2-Spring2

Struts2（一）概述

Struts2的历史

Struts2中action生命周期和Servlet生命周期

JavaWeb日记——struts2利用不同方式执行删除功能

struts2简要概述一

Java web项目添加Struts2支持的步骤

struts 2的全部jar包

struts2 action 返回原始文本字符串

struts2常用的标签介绍

简单讲一下 struts2的执行流程?

JavaWeb-struts2动态方法调用

struts2分页查询

Spring+Struts2+Hibernate javaweb网络商城系统+完整源码+可执行Mysq文件l

JavaWeb中的九大内置对象概述

web.xml直接设置action，404和struts2中的解决方案

struts2页面下载，从数据库把数据以excel表格形式导出

javaWeb学生公寓管理系统struts2

javaweb随身记

【Web开发】Struts2标签使用——数据标签

Struts2开发javaweb项目步骤

Struts2详细实例教程

Struts2访问web元素（Request，Session，Application）的四种方式

struts2的url标签解决contextpath的问题

Struts2实现增删改查和登录校验

Struts2上传文件及相关总结

JavaWeb利用struts2实现一个简单计算器

struts2简介及其优化

Struts2学习（一） 基础环境搭建与创建HelloWorld程序

JavaWeb相关技术简介

第一章javaweb应用开发技术概述

JavaWeb之概述

Java Web应用开发概述

使用Struts进行JavaWeb开发的中文乱码问题解决方案

【小程序】微信小程序开发实践

CAFFE -FCN训练配置过程

PHP jpgraph库的配置及生成统计图表:折线图、柱状图、饼状图等

追踪mysql操作记录时间1.

Activiti数据库表结构(表详细版)

jquery/js实现一个网页同时调用多个倒计时(最新的)

SNMP协议详解<二>

ORA-12518 TNS:监听程序无法分发客户机连接 解决办法

使用Spring进行面向切面编程

Java设计模式18——状态模式

linux上安装Docker(非常简单的安装方法)

java通过struts实现web中的文件上传

微信支付V3微信公众号支付PHP教程(thinkPHP5公众号支付)/JSSDK的使用

人脸检测和识别 源代码 下载-opencv3+python3.6完整实战项目源代码 识别视频《欢乐颂》中人物

人脸检测工具face_recognition的安装与应用

关于SpringBoot bean无法注入的问题（与文件包位置有关）

美团在Redis上踩过的一些坑-3.redis内存占用飙升

DataTables 的 实例 《一》

关于Android电池管理系统（一）Linux驱动部分

读核日记(三)

[JS进阶] JS 之Blob 对象类型

VB使用RES资源文件技巧

R语言逻辑回归、ROC曲线和十折交叉验证

Struts2学习（一）基础环境搭建与创建HelloWorld程序

ORA-12518 TNS:监听程序无法分发客户机连接解决办法

人脸检测和识别源代码下载-opencv3+python3.6完整实战项目源代码识别视频《欢乐颂》中人物

DataTables 的实例《一》