参考：http://www.gnu.org/software/libtool/manual/libc/Hooks-for-Malloc.html
 
3.2.2.10 Memory Allocation Hooks
The GNU C library lets you modify the behavior of malloc, realloc, and free by specifying appropriate hook functions. You can use these hooks to help you debug programs that use dynamic memory allocation, for example. 
The hook variables are declared in malloc.h. 
— Variable: __malloc_hook

The value of this variable is a pointer to the function that malloc uses whenever it is called. You should define this function to look like malloc; that is, like: 
          void *function (size_t size, const void *caller)

The value of caller is the return address found on the stack when the malloc function was called. This value allows you to trace the memory consumption of the program. 



— Variable: __realloc_hook

The value of this variable is a pointer to function that realloc uses whenever it is called. You should define this function to look like realloc; that is, like: 
          void *function (void *ptr, size_t size, const void *caller)

The value of caller is the return address found on the stack when the realloc function was called. This value allows you to trace the memory consumption of the program. 



— Variable: __free_hook

The value of this variable is a pointer to function that free uses whenever it is called. You should define this function to look like free; that is, like: 
          void function (void *ptr, const void *caller)

The value of caller is the return address found on the stack when the free function was called. This value allows you to trace the memory consumption of the program. 



— Variable: __memalign_hook

The value of this variable is a pointer to function that memalign uses whenever it is called. You should define this function to look like memalign; that is, like: 
          void *function (size_t alignment, size_t size, const void *caller)

The value of caller is the return address found on the stack when the memalign function was called. This value allows you to trace the memory consumption of the program. 


You must make sure that the function you install as a hook for one of these functions does not call that function recursively without restoring the old value of the hook first! Otherwise, your program will get stuck in an infinite recursion. Before calling the function recursively, one should make sure to restore all the hooks to their previous value. When coming back from the recursive call, all the hooks should be resaved since a hook might modify itself. 
— Variable: __malloc_initialize_hook

The value of this variable is a pointer to a function that is called once when the malloc implementation is initialized. This is a weak variable, so it can be overridden in the application with a definition like the following: 
          void (*__malloc_initialize_hook) (void) = my_init_hook;



An issue to look out for is the time at which the malloc hook functions can be safely installed. If the hook functions call the malloc-related functions recursively, it is necessary that malloc has already properly initialized itself at the time when __malloc_hook etc. is assigned to. On the other hand, if the hook functions provide a complete malloc implementation of their own, it is vital that the hooks are assigned to before the very first malloc call has completed, because otherwise a chunk obtained from the ordinary, un-hooked malloc may later be handed to __free_hook, for example. 
In both cases, the problem can be solved by setting up the hooks from within a user-defined function pointed to by __malloc_initialize_hook—then the hooks will be set up safely at the right time. 
Here is an example showing how to use __malloc_hook and __free_hook properly. It installs a function that prints out information every time malloc or free is called. We just assume here that realloc and memalign are not used in our program. 
     /* Prototypes for __malloc_hook, __free_hook */
     #include <malloc.h>
     
     /* Prototypes for our hooks.  */
     static void my_init_hook (void);
     static void *my_malloc_hook (size_t, const void *);
     static void my_free_hook (void*, const void *);
     
     /* Override initializing hook from the C library. */
     void (*__malloc_initialize_hook) (void) = my_init_hook;
     
     static void
     my_init_hook (void)
     {
       old_malloc_hook = __malloc_hook;
       old_free_hook = __free_hook;
       __malloc_hook = my_malloc_hook;
       __free_hook = my_free_hook;
     }
     
     static void *
     my_malloc_hook (size_t size, const void *caller)
     {
       void *result;
       /* Restore all old hooks */
       __malloc_hook = old_malloc_hook;
       __free_hook = old_free_hook;
       /* Call recursively */
       result = malloc (size);
       /* Save underlying hooks */
       old_malloc_hook = __malloc_hook;
       old_free_hook = __free_hook;
       /* printf might call malloc, so protect it too. */
       printf ("malloc (%u) returns %p/n", (unsigned int) size, result);
       /* Restore our own hooks */
       __malloc_hook = my_malloc_hook;
       __free_hook = my_free_hook;
       return result;
     }
     
     static void
     my_free_hook (void *ptr, const void *caller)
     {
       /* Restore all old hooks */
       __malloc_hook = old_malloc_hook;
       __free_hook = old_free_hook;
       /* Call recursively */
       free (ptr);
       /* Save underlying hooks */
       old_malloc_hook = __malloc_hook;
       old_free_hook = __free_hook;
       /* printf might call free, so protect it too. */
       printf ("freed pointer %p/n", ptr);
       /* Restore our own hooks */
       __malloc_hook = my_malloc_hook;
       __free_hook = my_free_hook;
     }
     
     main ()
     {
       ...
     }

The mcheck function (see Heap Consistency Checking) works by installing such hooks. 

Struts2 拦截器举例



Struts2 拦截器

Struts2 拦截器在访问某个 Action 方法之前或之后实施拦截，Struts2 拦截器是可插拔的，拦截器是 AOP(spring会讲到，现在不理会) 的一种实现．

拦截器栈(Interceptor Stack): 将拦截器按一定的顺序联结成一条链. 在访问被拦截的方法时，Struts2拦截器链中的拦截器就会按其之前定义的顺序被依次调用．

Interceptor 接口

每个拦截器都是实现了 com.opensymphony.xwork2.interceptor.Interceptor接口的 Java 类: 


init: 该方法将在拦截器被创建后立即被调用, 它在拦截器的生命周期内只被调用一次. 可以在该方法中对相关资源进行必要的初始化
interecept: 每拦截一个动作请求, 该方法就会被调用一次. 相当于doFilter方法.
destroy: 该方法将在拦截器被销毁之前被调用, 它在拦截器的生命周期内也只被调用一次.
Struts 会依次调用程序员为某个 Action 而注册的每一个拦截器的 interecept 方法.
每次调用 interecept 方法时, Struts 会传递一个 ActionInvocation 接口的实例.
ActionInvocation: 代表一个给定动作的执行状态, 拦截器可以从该类的对象里获得与该动作相关联的 Action 对象和 

Result 对象. 在完成拦截器自己的任务之后, 拦截器将调用 ActionInvocation 对象的 invoke 方法前进到 

Action 处理流程的下一个环节.
还可以调用 ActionInvocation 对象的 addPreResultListener 方法给 ActionInvocation对象 “挂” 上一个或多个 PreResultListener 监听器该监听器对象可以在动作执行完毕之后, 开始执行动作结果之前做些事情 
AbstractInterceptor 类实现了    Interceptor 接口. 并为 init, destroy 

提供了一个空白的实现
自定义拦截器

定义自定义拦截器的步骤 
自定义拦截器
在 struts.xml 文件中配置自定义的拦截器
要自定义拦截器需要实现com.opensymphony.xwork2.interceptor.Interceptor接口：



package cn.itcast.aop;

import java.util.Map;

import org.apache.struts2.ServletActionContext;

import com.opensymphony.xwork2.ActionInvocation;
import com.opensymphony.xwork2.interceptor.Interceptor;

@SuppressWarnings("serial")
public class ExpessionInterceptor implements Interceptor {

    public void init() {
        System.out.println("ExpessionInterceptor ********* init()");

    }

    public String intercept(ActionInvocation invocation) throws Exception {
        System.out.println("ExpessionInterceptor ********* intercept()");

        //cn.itcast.aop.UserAction@15b5783，动作类的对象
        System.out.println("invocation.getAction() : "+invocation.getAction());

        //cn.itcast.aop.UserAction@15b5783，与invocation.getAction()方法获取的是同一的对象
        System.out.println("invocation.getProxy().getAction() : "+invocation.getProxy().getAction());

        //userAction_save，自定义配置文件中的action标签的name属性的值
        System.out.println("invocation.getProxy().getActionName() : "+invocation.getProxy().getActionName());

        //save，对应动作类指定要执行的方法名
        System.out.println("invocation.getProxy().getMethod() : "+invocation.getProxy().getMethod());

        //  /aop，自定义配置文件中的package标签的namespace属性的值
        System.out.println("invocation.getProxy().getNamespace() : "+invocation.getProxy().getNamespace());

        //null  返回结果
        System.out.println("invocation.getResult() : "+invocation.getResult());

        Map sessionMap = ServletActionContext.getContext().getSession();

        Object obj = sessionMap.get("user");

        if(obj==null||obj.equals("")){
            return "error";
        }else{
            return "success";
        }
    }

    public void destroy() {
        System.out.println("ExpessionInterceptor ********* destroy()");

    }

}


在 struts_aop.xml 文件中配置自定义的拦截器

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts PUBLIC
    "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
    "http://struts.apache.org/dtds/struts-2.3.dtd">
<struts>
    <package name="aop" namespace="/aop" extends="struts-default">

        <interceptors>
            <!-- 声明自定义的拦截器 -->
            <interceptor name="expessionInterceptor" class="cn.itcast.aop.ExpessionInterceptor" />

            <!-- 声明自定义拦截器栈 -->
            <interceptor-stack name="expessionStack">
                <interceptor-ref name="defaultStack"/>

                <!-- 配置使用自定义拦截器 -->
                <interceptor-ref name="expessionInterceptor"/>

            </interceptor-stack>
        </interceptors>

        <!-- 配置修改struts2框架运行时，默认执行的是自定义拦截器栈 -->
        <default-interceptor-ref name="expessionStack" />

        <action name="userAction_save" class="cn.itcast.aop.UserAction" method="save">
            <result name="success">/aop/success.jsp</result>
            <result name="error">/aop/error.jsp</result>
        </action>
    </package>
</struts>

因为struts2中如文件上传，数据验证，封装请求参数到action等 

功能都是由系统默认的defaultStack中的拦截器实现的，所以 

我们定义的拦截器需要引用系统默认的defaultStack，这样应用才 

可以使用struts2框架提供的众多功能。 

如果希望包下的所有action都使用自定义的拦截器， 

可以通过<default-interceptor-ref name=“permissionStack”/> 

把拦截器定义为默认拦截器。注意：每个包只能指定一个默认拦截器。 

另外，一旦我们为该包中的某个action显式指定了某个拦截器， 

则默认拦截器不会起作用。

struts.xml文件中引入自定义配置文件

    <include file="cn/itcast/aop/struts_aop.xml"></include>



jap页面：

index.jsp

<%@ page language="java" pageEncoding="utf-8" contentType="text/html; charset=utf-8"%>
<%@ taglib uri="/struts-tags"   prefix="s"%>
<html>
  <head>
    <title>My JSP 'index.jsp' starting page</title>
    </head>
  <body>
      用户登录!!!

     <%
        session.setAttribute("user","user");
     %>

  </body>
</html>


test.jsp

<%@ page language="java" pageEncoding="utf-8" contentType="text/html; charset=utf-8"%>
<%@ taglib uri="/struts-tags"   prefix="s"%>
<html>
  <head>
    <title>My JSP 'index.jsp' starting page</title>
    </head>
  <body>
      测试拦截器:<br>
        <a href="${pageContext.request.contextPath}/aop/userAction_save.action">test</a><br>

  </body>
</html>


error.jsp



<%@ page language="java" pageEncoding="utf-8" contentType="text/html; charset=utf-8"%>
<%@ taglib uri="/struts-tags"   prefix="s"%>
<html>
  <head>
    <title>My JSP 'index.jsp' starting page</title>
    </head>
  <body>
       对不起,您没有权限<br>
  </body>
</html>


success.jsp



<%@ page language="java" pageEncoding="utf-8" contentType="text/html; charset=utf-8"%>
<%@ taglib uri="/struts-tags"   prefix="s"%>
<html>
  <head>
    <title>My JSP 'index.jsp' starting page</title>
    </head>
  <body>
        成功!!!!<br> ${id}
  </body>
</html>


测试： 

为登陆直接进入test.jsp 


点击超链接 


进入index.jsp进行登陆先 


在进入test.jsp 


点击超链接 


后台的输出： 


Struts2 自带的拦截器(1)



Struts2 自带的拦截器(2)

文章目录
一、v5拦截器 requestInterceptors
二、umi-request 的拦截器
三、axios拦截请求
总结


一、v5拦截器 requestInterceptors
在umijs的配置中 Interceptor

拦截器主要作用You can intercept requests or responses before they are handled by then or catch.可以先拦截请求或响应，然后再进行捕获或捕获。

requestInterceptors 该配置接收一个数组，数组的每一项为一个 request 拦截器。等同于 umi-request 的 request.interceptors.request.use()。

requestInterceptors: [headerInfo]

headerInfo返回一个{url, options}，在options的headers上添加上token
const headerInfo: RequestInterceptor = (url: string, options: RequestInit) => {
  if (localStorage.getItem('token')) {
    const token = `Bearer ` + localStorage.getItem('token');
    // options.headers.Authorization = `Bearer ` + localStorage.getItem('token');
    options.headers = {
      ...options.headers,
      "Authorization": token,
      'Content-Type': 'application/json',
    }
  }
  console.log("url", url);
  return { url, options };
}
/**
 * 异常处理程序
 */
const errorHandler = (error: ResponseError) => {
  const { response } = error;
  if (response && response.status) {
    const errorText = codeMessage[response.status] || response.statusText;
    const { status, url } = response;

    notification.error({
      message: `请求错误 ${status}: ${url}`,
      description: errorText,
    });
  }

  if (!response) {
    notification.error({
      description: '您的网络发生异常，无法连接服务器',
      message: '网络异常',
    });
  }
  throw error;
};

在request的配置RequestConfig中，添加上拦截器
export const request: RequestConfig = {
  errorHandler,
  credentials: 'include',
  requestInterceptors: [headerInfo]
};



二、umi-request 的拦截器
umi官方给的实例 添加拦截，创建客户端请求
import request from 'umi-request';
request.interceptors.request.use(
  (url, options) => {
    return {
      url: `${url}&interceptors=yes`,
      options: { ...options, interceptors: true },
    };
  },
  { global: false }
); // second paramet defaults { global: true }

function createClient(baseUrl) {
  const request = extend({
    prefix: baseUrl,
  });
  return request;
}

const clientA = createClient('/api');
const clientB = createClient('/api');
// Independent instance Interceptor
clientA.interceptors.request.use(
  (url, options) => {
    return {
      url: `${url}&interceptors=clientA`,
      options,
    };
  },
  { global: false }
);

clientB.interceptors.request.use(
  (url, options) => {
    return {
      url: `${url}&interceptors=clientB`,
      options,
    };
  },
  { global: false }
);


三、axios拦截请求
// 创建实例
const instance = axios.create({
  baseURL: "http://localhost:4000/L1/getData",
  timeout: 5000 // 请求超时时间
});

instance.interceptors.response.use(
  res => {	// 正确则直接返回res
    return res;
  },
  err => {	// 对错误进行处理
    console.log(err.response)
    if (err.response.data.message) {
      message.error(err.response.data.message);

      if (err.response.status === 401) {
        const history = createHistory();
        history.push("/login");	// 401noAuthoration则跳转到登录页面
      }
    }
    return Promise.reject(err);
  }
);
// 实例请求头添加上token
instance.interceptors.request.use(function(config) {
    if (localStorage.token) {
      config.headers.Authorization = "Bearer " + localStorage.token;
    }
    return config;
  },function(err) {
    return Promise.reject(err);
  }
);
// 暴露四种请求方式
// get请求
export function get(url, params) {
  return instance.get(url, {
    params
  });
}
// post请求
export function post(url, data) {
  return instance.post(url, data);
}
// put请求
export function put(url, data) {
  return instance.put(url, data);
}
// del请求
export function del(url) {
  return instance.delete(url);
}


总结
antd-pro对umijs的请求拦截进行了二次封装，实现起来十分方便，添加了token之后还应该判断token的有效时间，查看token是否过期吗，若已过期，则将请求挂起。等待后台刷新token。