Java server-side solves cross-domain problems

Now many developed APIs support ajax direct requests, which will lead to cross-domain problems. Solving cross-domain problems can be done from the front end on the one hand, and the server side on the other hand.
Since it is engaged in server-side and external API services, of course, the simpler the better, the front-end only needs to be used foolishly.

At present, the situation I have come into contact with is that there are two implementation methods. The following is the direct code. You can choose or modify the code according to your own project situation. All the code is run in the actual project.
The first case is relatively simple, let all controller classes inherit the custom BaseController class, and do some special processing on the returned header in the modified class.

public abstract class BaseController {
  /**
     * description:send the ajax response back to the client side
     * @param responseObj
     * @param response
     */
    protected void writeAjaxJSONResponse(Object responseObj, HttpServletResponse response) {
        response.setCharacterEncoding("UTF-8");

        response.setHeader("Cache-Control", "no-cache, no-store, must-revalidate"); // HTTP 1.1
        response.setHeader("Pragma", "no-cache"); // HTTP 1.0

        /**
         * for ajax-cross-domain request TODO get the ip address from
         * configration(ajax-cross-domain.properties)
         */
        response.setHeader("Access-Control-Allow-Origin", "*");

        response.setDateHeader("Expires", 0); // Proxies.

        PrintWriter writer = getWriter(response);

        writeAjaxJSONResponse(responseObj, writer);
    }
  /**
     *
     * @param response
     * @return
     */
    protected PrintWriter getWriter(HttpServletResponse response) {
        if(null == response){
            return null;
        }

        PrintWriter writer = null;

        try {
            writer = response.getWriter();
        } catch (IOException e) {
            logger.error("unknow exception", e);
        }


        return writer;
    }

    /**
     * description:send the ajax response back to the client side.
     *
     * @param responseObj
     * @param writer
     * @param writer
     */
    protected void writeAjaxJSONResponse(Object responseObj, PrintWriter writer) {
        if (writer == null || responseObj == null) {
            return;
        }
        try {         writer.write(JSON.toJSONString(responseObj,SerializerFeature.DisableCircularReferenceDetect));
        } finally {
            writer.flush();
            writer.close();
        }
    }
}

Next is the controller of our own business, which is mainly to call writeAjaxJSONResponse(result, response); this method

@Controller
@RequestMapping(value = "/account")
public class AccountController extends BaseController {
@RequestMapping(value = "/add", method = RequestMethod.POST)
    public void addAccount(HttpSession session,HttpServletRequest request,HttpServletResponse response){
        ViewerResult result = new ViewerResult();
         //实现自己业务逻辑代码
        writeAjaxJSONResponse(result, response);
    }

}

    好了，这种简单的方式就实现了。

    接下来介绍第二种方式，filter。我们在写springMVC的时候，更喜欢的方式是通过@ResponseBody给返回对象进行封装直接返回给前端，这样简单而且容易。
    如果使用@ResponseBody就不能使用第一种方法了，所有就使用filter给所有的请求都封装一下跨域，接下来直接实现代码：

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;
import javax.servlet.http.HttpServletResponse;

public class HeadersCORSFilter implements Filter {

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        // TODO Auto-generated method stub

    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse servletResponse,
            FilterChain chain) throws IOException, ServletException {
         HttpServletResponse response = (HttpServletResponse) servletResponse;
            response.setHeader("Access-Control-Allow-Origin", "*");
            response.setHeader("Access-Control-Allow-Methods", "POST, GET, OPTIONS, DELETE");
            response.setHeader("Access-Control-Max-Age", "3600");
            response.setHeader("Access-Control-Allow-Headers", "x-requested-with,Authorization");
            response.setHeader("Access-Control-Allow-Credentials","true");
            chain.doFilter(request, servletResponse);

    }

    @Override
    public void destroy() {
        // TODO Auto-generated method stub

    }

}

Well, the filter is implemented, and then it is necessary to use this filter in web.xml.
Open the web.xml of the project and fill in the following lines of code:

    <filter>
      <filter-name>cors</filter-name>
      <filter-class>xxx.xxxx.xxxxx.xxxx.HeadersCORSFilter</filter-class><!--你过滤器的包 -->
    </filter>
    <filter-mapping>
      <filter-name>cors</filter-name>
      <url-pattern>/open/*</url-pattern><!-- 你开放的接口前缀  -->
    </filter-mapping>

    好了，通过上面的2种方式，可以解决百分之80的跨域问题，也许还有更好的解决方案，可以提出来大家一起学习学习。
    最好的方案是最符合当前需求且易于扩展的。

Java server-side solves cross-domain problems

Guess you like