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"
  }
}