datatables服务端分页配置

datatables服务端分页配置

datatables可以说是个好东西吧,几行js代码就能够让你初始化一个表格,很方便,但是要用好还是很困难的,因为配置太多太多了,网上的大多数是一些陈旧的配置,如果datatables更换了这么多版本,网上很多配置都有一些问题,我这里也不是datatables的基础教程,我这里就谈一下服务端分页怎么配置,因为我项目中用到了,笔以记之。后之览者,亦将有感于斯文~

一、必备

  1. 引入

    1
    2
    3
    4
    5
    6
    <!--引入css-->
    <link rel="stylesheet" type="text/css" href="https://cdn.datatables.net/1.10.15/css/jquery.dataTables.min.css">
    <!--引入JavaScript-->
    <script type="text/javascript" language="javascript" src="//code.jquery.com/jquery-1.12.4.js"></script>
    <script type="text/javascript" language="javascript" src="https://cdn.datatables.net/1.10.15/js/jquery.dataTables.min.js"></script>

Read More

Compartir

利用HttpServletResponseWrapper包装reponse

利用HttpServletResponseWrapper包装reponse

题记: 很多人或许用Spring的时候统一修改一下reponse信息,比较常见的就是给所有的response加一个status、code、message之类的要求,也有的想把response和request的日志打印出来,那么该如何做呢?那就耐心看看吧

一、背景介绍

  对于上述我们说到的这个需求,有很多中实现方式,比较容易想到的就是拦截器,过滤器等,这里我使用的是过滤器的方式来实现的,一是因为Spring天然就对Filter支持得比较好,二是开发方便容易。

  对于过滤器的实现方式,我这里也提供2种方式来实现,一种是复制ServletOutputStream的方式,一种是不复制ServletOutputStream的方式,两种方式各有用处,随君选择,后续我会开一篇原理的文章

Read More

Compartir

Spring filter原理深入浅出

Spring filter原理深入浅出

在这篇文章中,我会介绍一个请求从浏览器进来,是如何被Spring拦截到的,Spring又是如何处理这个请求的,filter有什么作用,filter的原理等

一、前置知识

OK,我们首先介绍一下,请求从浏览器过来,我们的服务器会经历些什么。先看一张jetty的内部结构图

Read More

Compartir

Spring Boot AOP系列之AOP原理介绍

Spring Boot AOP系列之AOP原理介绍


序言:在本文中,jdk动态代理和cglib代理的核心原理,我都会一一讲到,看本文的时候可以结合着上文看,了解创建的过程,创建的生命周期,才能知晓原理

一、JDK动态代理原理

1、前言

其实大家看了上文的demo肯定会有所疑惑,为什么实现了一个InvocationHandler接口就可以实现切面的植入了,就可以在写好的函数方法上面,植入我们的代码呢?是不是很神奇,惊不惊喜,意不意外。OK,废话不多说,下面跟着我的思路,走一遍源代码。

2、介绍

上文中提到了,Spring jdk动态代理最核心的一句话莫过于下面这句话

1
2
3
4
HelloWorld helloWorld=(HelloWorld)Proxy.
newProxyInstance(JDKProxyTest.class.getClassLoader(),
new Class<?>[]{HelloWorld.class},
new MyInvocationHandler(new HelloworldImpl()));

走进newProxyInstance这个方法

1
2
3
4
5
6
7
8
9
10
final Class<?>[] intfs = interfaces.clone();
final SecurityManager sm = System.getSecurityManager();
if (sm != null) {
checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
}
/*
* 从缓存中取出或者生成代理
*/
Class<?> cl = getProxyClass0(loader, intfs);

Read More

Compartir

Spring Boot AOP系列之动态代理创建

Spring Boot AOP系列之动态代理创建


序言:在本文中,我会讲到Spring中如何创建动态代理,如何利用jdk或者cglib来创建动态代理,但是同时,我也会提及如何手动创建代理,这将有助于我们了解动态代理的原理。我们先来讲讲如何手动创建吧。

一、 手动创建之jdk动态代理

1、 jdk动态代理是基于接口的,所以必须要写一个接口,以及实现类,然后还需要写一个类来实现InvocationHandler类,

接口如下

1
2
3
public interface Helloworld {
void sayHello();
}

实现类如下:

1
2
3
4
5
public class HelloworldImpl implements HelloWorld {
public void sayHello() {
System.out.print("hello world");
}
}

Read More

Compartir

Fastjson解析多级泛型

Fastjson解析多级泛型

前言

现在网上大多数是使用TypeReference 方式来解析JSON数据,这里我提供另外一种方式来解析,使用类文件进行解析,两种方式我都会给出实际代码

实例

TypeReference方式
1
2
3
4
5
6
@GET
@Path("getUserCourse")
@Produces(MediaType.APPLICATION_JSON)
public Result<List<UserCourseDto>> getUserCourse(){
return externalBiz.getUserCourse();
}
1
2
3
4
public Result<List<UserCourseDto>> getUserCourse(){
String result = restTemplate.getForObject(MOCK_JSON_URL, String.class);
return JSONObject.parseObject(result, new TypeReference<Result<List<UserCourseDto>>>() {});
}

Read More

Compartir

Spring Boot 集成 resteasy篇 — jax-rs初步介绍和spring boot集成

Spring Boot 集成 resteasy篇 — jax-rs初步介绍和spring boot集成

JAX-RS 是代表restful web service的一套规范API,JAX-RS规范基于JAVA编程语言,它是用来创建Restful 风格的web services服务的。Jax-rs使用一系列注解来简化java开发。

JAX-RS也称jsr339 (全称java specifications requests java规范提案第339个),由jcp(java community process)组织经过投票通过。

为了加深对jsr的理解,举一个简单的例子,jsr 330标准就是依赖注入的提案,已经通过。

规范说明

规范定义了一些常见的注解(见下表),用来标注一种资源文件为restfun风格的资源文件

序号 注解 描述
1 @Path 类或者方法的相对地址,标注在类或者方法上
2 @GET HTTP GET请求用,用来获取资源
3 @PUT HTTP PUT 请求,用来创建资源
4 @POST HTTP POST 请求, 用来创建或者更新资源
5 @DELETE HTTP DELETE请求, 用来删除资源
6 @HEAD HTTP HEAD请求, 用来获取一个接口是否可用的状态
7 @Produces 返回数据的格式比如APPLICATION/XML, TEXT/HTML, APPLICATION/JSON
8 @Consumes 请求数据格式 , 如json
9 @PathParam 绑定url里面的参数
10 @QueryParam 绑定url后面的参数(?后面的)
11 @MatrixParam 绑定包含多个 property (属性)=value(值) 方法参数表达式
12 @HeaderParam 给header里面传参
13 @CookieParam 给cookie里面传参
14 @FormParam 给form传参
15 @DefaultValue 给参数一个默认值
16 @Context 可以注入HttpRequest,HttpResponse用

规范实现

下文将以resteasy为例

Read More

Compartir

Spring Boot 集成 resteasy篇 — jax-rs常用注解介绍

Spring Boot 集成 resteasy篇 — jax-rs常用注解介绍

@GET

http请求方式里面的get请求,标记这个请求方式为get

1
2
3
4
5
6
7
8
9
10
11
12
13
/**
* http://localhost:8080/v1/province/city/1
* @param id
* @return
*/
@Path("city/{id}")
@GET
@Produces(MediaType.APPLICATION_JSON) //表示输出json
@Consumes(MediaType.APPLICATION_JSON) //表示输入为json
public Result<Boolean> getCity(@PathParam("id") Long id) {
return new Result<>();
}

Read More

Compartir

高可用数据同步方案-SqlServer迁移Mysql实战

高可用数据同步方案-SqlServer迁移Mysql实战

简介

随着业务量的上升,以前的架构已经不满足业务的发展,数据作为业务中最重要的一环,需要有更好的架构作为支撑。目前我司有sql server转mysql的需求,所以结合当前业务,我挑选了阿里云开源的一个很好用的同步工具DataX

DataX介绍

DataX 是一个异构数据源离线同步工具,致力于实现包括关系型数据库(MySQL、Oracle等)、HDFS、Hive、MaxCompute(原ODPS)、HBase、FTP等各种异构数据源之间稳定高效的数据同步功能。

框架设计

datax_framework_new

DataX本身作为离线数据同步框架,采用Framework + plugin架构构建。将数据源读取和写入抽象成为Reader/Writer插件,纳入到整个同步框架中。

  • Reader:Reader为数据采集模块,负责采集数据源的数据,将数据发送给Framework。
  • Writer: Writer为数据写入模块,负责不断向Framework取数据,并将数据写入到目的端。
  • Framework:Framework用于连接reader和writer,作为两者的数据传输通道,并处理缓冲,流控,并发,数据转换等核心技术问题。

Read More

Compartir

spring boot给接口返回添加输入输出日志

Spring boot返回request、response 添加log

目前有个需求需要给接口返回添加输入输出日志,目前比价常用的方法就是使用过滤器,就可以很方便的拦截到输入请求和输出请求,那么在过滤器里面如何HttpServletRequest HttpServletRequest这两个对象输入和输出日志呢?

解决办法

事实上javax包里面本来就提供HttpServletRequstWrapper、HttpServletResponseWrapper两个包装类进行对请求、和放回进行拦截、我们实现这两个,这样我们就能够写一些单独的东西,就可以实现我们的效果

上代码

request代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
public class RequestWrapper extends HttpServletRequestWrapper {
private static Logger logger = LoggerFactory.getLogger(RequestWrapper.class);
private final byte[] body;
public RequestWrapper(HttpServletRequest request) throws IOException {
super(request);
body = getBodyString(request).getBytes(Charset.forName("UTF-8"));
}
@Override
public BufferedReader getReader() throws IOException {
return new BufferedReader(new InputStreamReader(getInputStream()));
}
@Override
public ServletInputStream getInputStream() throws IOException {
//这里从body里面直接读了,没有去读inputStream了,很巧妙的方式
final ByteArrayInputStream bais = new ByteArrayInputStream(body);
return new ServletInputStream() {
@Override
public int read() throws IOException {
return bais.read();
}
@Override
public boolean isFinished() {
return false;
}
@Override
public boolean isReady() {
return false;
}
@Override
public void setReadListener(ReadListener readListener) {
}
};
}
public String getBodyString(ServletRequest request) {
StringBuilder sb = new StringBuilder();
InputStream inputStream = null;
BufferedReader reader = null;
try {
inputStream = request.getInputStream();
reader = new BufferedReader(new InputStreamReader(inputStream, Charset.forName("UTF-8")));
String line = "";
while ((line = reader.readLine()) != null) {
sb.append(line);
}
} catch (IOException e) {
logger.warn("处理异常",e);
} finally {
if (inputStream != null) {
try {
inputStream.close();
} catch (IOException e) {
logger.warn("处理异常",e);
}
}
if (reader != null) {
try {
reader.close();
} catch (IOException e) {
logger.warn("处理异常",e);
}
}
}
return sb.toString();
}
}

先写一个ResponseWrapper类来继承HttpServletResponseWrapper

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
package com.dzy.itar.pinpin.support.filter;
import org.apache.commons.io.output.TeeOutputStream;
import javax.servlet.ServletOutputStream;
import javax.servlet.ServletResponse;
import javax.servlet.WriteListener;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpServletResponseWrapper;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.PrintWriter;
public class ResponseWrapper extends HttpServletResponseWrapper {
private final ByteArrayOutputStream bos = new ByteArrayOutputStream();
private PrintWriter writer = new PrintWriter(bos);
private long id;
public ResponseWrapper(Long requestId, HttpServletResponse response) {
super(response);
this.id = requestId;
}
@Override
public ServletResponse getResponse() {
return this;
}
@Override
public ServletOutputStream getOutputStream() throws IOException {
return new ServletOutputStream() {
@Override
public boolean isReady() {
return false;
}
@Override
public void setWriteListener(WriteListener writeListener) {
}
private TeeOutputStream tee = new TeeOutputStream(ResponseWrapper.super.getOutputStream(), bos);
@Override
public void write(int b) throws IOException {
tee.write(b);
}
};
}
@Override
public PrintWriter getWriter() throws IOException {
return new TeePrintWriter(super.getWriter(), writer);
}
public byte[] toByteArray(){
return bos.toByteArray();
}
public long getId() {
return id;
}
public void setId(long id) {
this.id = id;
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
package com.dzy.itar.pinpin.support.filter;
import java.io.PrintWriter;
public class TeePrintWriter extends PrintWriter{
PrintWriter branch;
public TeePrintWriter(PrintWriter main, PrintWriter branch) {
super(main, true);
this.branch = branch;
}
public void write(char buf[], int off, int len) {
super.write(buf, off, len);
super.flush();
branch.write(buf, off, len);
branch.flush();
}
public void write(String s, int off, int len) {
super.write(s, off, len);
super.flush();
branch.write(s, off, len);
branch.flush();
}
public void write(int c) {
super.write(c);
super.flush();
branch.write(c);
branch.flush();
}
public void flush() {
super.flush();
branch.flush();
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
package com.dzy.itar.pinpin.support.filter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import org.springframework.web.filter.OncePerRequestFilter;
import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.concurrent.atomic.AtomicLong;
@Component
public class LoggingFilter extends OncePerRequestFilter {
protected static final Logger logger = LoggerFactory.getLogger(LoggingFilter.class);
private static final String REQUEST_PREFIX = "Request: ";
private static final String RESPONSE_PREFIX = "Response: ";
private AtomicLong id = new AtomicLong(1);
@Override
protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, final FilterChain filterChain) throws ServletException, IOException {
if (logger.isDebugEnabled()) {
long requestId = id.incrementAndGet();
request = new RequestWrapper(requestId, request);
response = new ResponseWrapper(requestId, response);
}
try {
filterChain.doFilter(request, response);
// response.flushBuffer();
} finally {
if (logger.isDebugEnabled()) {
logRequest(request);
logResponse((ResponseWrapper) response);
}
}
}
private void logRequest(final HttpServletRequest request) {
StringBuilder msg = new StringBuilder();
msg.append(REQUEST_PREFIX);
if (request instanceof RequestWrapper) {
msg.append("request id=").append(((RequestWrapper) request).getId()).append("; ");
}
HttpSession session = request.getSession(false);
if (session != null) {
msg.append("session id=").append(session.getId()).append("; ");
}
if (request.getMethod() != null) {
msg.append("method=").append(request.getMethod()).append("; ");
}
if (request.getContentType() != null) {
msg.append("content type=").append(request.getContentType()).append("; ");
}
msg.append("uri=").append(request.getRequestURI());
if (request.getQueryString() != null) {
msg.append('?').append(request.getQueryString());
}
if (request instanceof RequestWrapper && !isMultipart(request) && !isBinaryContent(request)) {
RequestWrapper requestWrapper = (RequestWrapper) request;
try {
String charEncoding = requestWrapper.getCharacterEncoding() != null ? requestWrapper.getCharacterEncoding() :
"UTF-8";
msg.append("; payload=").append(new String(requestWrapper.toByteArray(), charEncoding));
} catch (UnsupportedEncodingException e) {
logger.warn("Failed to parse request payload", e);
}
}
logger.debug(msg.toString());
}
private boolean isBinaryContent(final HttpServletRequest request) {
if (request.getContentType() == null) {
return false;
}
return request.getContentType().startsWith("image") || request.getContentType().startsWith("video") || request.getContentType().startsWith("audio");
}
private boolean isMultipart(final HttpServletRequest request) {
return request.getContentType() != null && request.getContentType().startsWith("multipart/form-data");
}
private void logResponse(final ResponseWrapper response) {
StringBuilder msg = new StringBuilder();
msg.append(RESPONSE_PREFIX);
msg.append("request id=").append((response.getId()));
try {
msg.append("; payload=").append(new String(response.toByteArray(), response.getCharacterEncoding()));
} catch (UnsupportedEncodingException e) {
logger.warn("Failed to parse response payload", e);
}
logger.debug(msg.toString());
}
}

PrintWriter是一种写入字符的一种操作类,可以写入字符,TeePrintWriter继承了他,主要功能是把原始的字符流copy到branch里面。

LoggingFilter是一种filter,继承OncePerRequestFilter,每次请求都会经过他。

主要代码就是上面这样的,我把代码放到了这里大家可以下载借鉴

源码解析

SpringMVC在处理完毕请求之后,会调用AbstractMessageConverterMethodProcessor里的writeWithMessageConverters方法,然后会调用AbstractGenericHttpMessageConverter 的write方法,把返回的接口输出到HttpOutputMessage里面去,事实上,然后会调用WriteInternal方法

然后里面有getBody()方法,然后里面就调用到了我们的getOutputStream方法,终于走到我们写的方法了

然后我们就可以处理这个流了

主要是copy了一份,然后再filter里面打印了出来

完毕

Compartir