MIDDLEWARE = [

    'django.middleware.security.SecurityMiddleware',

    'django.contrib.sessions.middleware.SessionMiddleware',

    'django.middleware.common.CommonMiddleware',

    'django.middleware.csrf.CsrfViewMiddleware',

    'django.contrib.auth.middleware.AuthenticationMiddleware',

    'django.contrib.messages.middleware.MessageMiddleware',

    'django.middleware.clickjacking.XFrameOptionsMiddleware',

]

class CommonMiddleware(MiddlewareMixin):

    response_redirect_class = http.HttpResponsePermanentRedirect

    def process_request(self, request):

        """

        Check for denied User-Agents and rewrite the URL based on

        settings.APPEND_SLASH and settings.PREPEND_WWW

        """

        # Check for denied User-Agents

        if 'HTTP_USER_AGENT' in request.META:

            for user_agent_regex in settings.DISALLOWED_USER_AGENTS:

                if user_agent_regex.search(request.META['HTTP_USER_AGENT']):

                    raise PermissionDenied('Forbidden user agent')

        # Check for a redirect based on settings.PREPEND_WWW

        host = request.get_host()

        must_prepend = settings.PREPEND_WWW and host and not host.startswith('www.')

        redirect_url = ('%s://www.%s' % (request.scheme, host)) if must_prepend else ''

        # Check if a slash should be appended

        if self.should_redirect_with_slash(request):

            path = self.get_full_path_with_slash(request)

        else:

            path = request.get_full_path()

        # Return a redirect if necessary

        if redirect_url or path != request.get_full_path():

            redirect_url += path

            return self.response_redirect_class(redirect_url)

    def should_redirect_with_slash(self, request):

        """

        Return True if settings.APPEND_SLASH is True and appending a slash to

        the request path turns an invalid path into a valid one.

        """

        if settings.APPEND_SLASH and not request.get_full_path().endswith('/'):

            urlconf = getattr(request, 'urlconf', None)

            return (

                not is_valid_path(request.path_info, urlconf) and

                is_valid_path('%s/' % request.path_info, urlconf)

            )

        return False

    def get_full_path_with_slash(self, request):

        """

        Return the full path of the request with a trailing slash appended.

        Raise a RuntimeError if settings.DEBUG is True and request.method is

        POST, PUT, or PATCH.

        """

        new_path = request.get_full_path(force_append_slash=True)

        if settings.DEBUG and request.method in ('POST', 'PUT', 'PATCH'):

            raise RuntimeError(

                "You called this URL via %(method)s, but the URL doesn't end "

                "in a slash and you have APPEND_SLASH set. Django can't "

                "redirect to the slash URL while maintaining %(method)s data. "

                "Change your form to point to %(url)s (note the trailing "

                "slash), or set APPEND_SLASH=False in your Django settings." % {

                    'method': request.method,

                    'url': request.get_host() + new_path,

                }

            )

        return new_path

    def process_response(self, request, response):

        """

        Calculate the ETag, if needed.

        When the status code of the response is 404, it may redirect to a path

        with an appended slash if should_redirect_with_slash() returns True.

        """

        # If the given URL is "Not Found", then check if we should redirect to

        # a path with a slash appended.

        if response.status_code == 404:

            if self.should_redirect_with_slash(request):

                return self.response_redirect_class(self.get_full_path_with_slash(request))

        if settings.USE_ETAGS:

            if not response.has_header('ETag'):

                set_response_etag(response)

            if response.has_header('ETag'):

                return get_conditional_response(

                    request,

                    etag=unquote_etag(response['ETag']),

                    response=response,

                )

        return response

class MiddlewareMixin(object):

    def __init__(self, get_response=None):

        self.get_response = get_response

        super(MiddlewareMixin, self).__init__()

    def __call__(self, request):

        response = None

        if hasattr(self, 'process_request'):

            response = self.process_request(request)

        if not response:

            response = self.get_response(request)

        if hasattr(self, 'process_response'):

            response = self.process_response(request, response)

        return response

from django.utils.deprecation import MiddlewareMixin

from rest_framework.response import Response

from django.http import JsonResponse

import logging

jira_log = logging.getLogger('debug')

class Reponse(MiddlewareMixin):

    def process_response(self, request, response):

        if isinstance(response, Response) and response.get('content-type') == 'application/json' and \

                isinstance(response.data, dict):

            response.data['msg'] = '成功'

            response.content = response.rendered_content

            # self._convert_data(response, 200)

        if isinstance(response, JsonResponse):

            jira_log.debug(response.content)

        return response

    @staticmethod

    def process_request(request):

        if request.method == 'POST':

            jira_log.debug(request.body)

        if request.method == 'GET':

            jira_log.debug(request.GET)

        setattr(request, '_dont_enforce_csrf_checks', True)

MIDDLEWARE = [

    'django.middleware.security.SecurityMiddleware',

    'django.contrib.sessions.middleware.SessionMiddleware',

# 自定义的middleware，记录日志，

    'apps.common.middleware.Reponse',

    'django.middleware.common.CommonMiddleware',

    'django.middleware.csrf.CsrfViewMiddleware',

    'django.contrib.auth.middleware.AuthenticationMiddleware',

    'django.contrib.messages.middleware.MessageMiddleware',

    'django.middleware.clickjacking.XFrameOptionsMiddleware',

]

2017-12-13 14:12:04,520 [middleware.py: 39][Thread-7    ][debug   ]DEBUG request: b'{"a":1, "b":2}'

2017-12-13 14:12:04,530 [middleware.py: 31][Thread-7    ][debug   ]DEBUG response {'status': 200, 'msg': '成功'}

2017-12-13 14:12:21,071 [middleware.py: 41][Thread-8    ][debug   ]DEBUG request: <QueryDict: {}>

2017-12-13 14:12:21,074 [middleware.py: 31][Thread-8    ][debug   ]DEBUG response {'status': 200, 'msg': '成功'}

2017-12-13 14:12:44,432 [middleware.py: 41][Thread-9    ][debug   ]DEBUG request: <QueryDict: {}>

2017-12-13 14:12:44,434 [middleware.py: 33][Thread-9    ][debug   ]DEBUG response b'{"status": 200, "msg": "\\u6210\\u529f 1"}'

{

  "msg": "成功",

  "status": 200,

  "data": {

      "data": "our data"

  }

}