chore: add @Override tag on some methods (#6304)

apm-checkstyle/checkStyle.xml

@@ -105,6 +105,7 @@
         <module name="TypeName">
             <property name="format" value="(^[A-Z][a-zA-Z0-9]*$)|(^[A-Z][A-Z0-9]*(_[A-Z0-9]+)*$)"/>
         </module>
+        <module name="MissingOverride"/>
 
         <!--whitespace-->
         <module name="GenericWhitespace"/>

apm-commons/apm-datacarrier/src/main/java/org/apache/skywalking/apm/commons/datacarrier/common/AtomicRangeInteger.java

@@ -54,18 +54,22 @@ public class AtomicRangeInteger extends Number implements Serializable {
         return this.values.get(VALUE_OFFSET);
     }
 
+    @Override
     public int intValue() {
         return this.values.get(VALUE_OFFSET);
     }
 
+    @Override
     public long longValue() {
         return this.values.get(VALUE_OFFSET);
     }
 
+    @Override
     public float floatValue() {
         return this.values.get(VALUE_OFFSET);
     }
 
+    @Override
     public double doubleValue() {
         return this.values.get(VALUE_OFFSET);
     }

apm-sniffer/apm-agent-core/src/main/java/org/apache/skywalking/apm/agent/core/context/CorrelationContext.java

@@ -176,6 +176,7 @@ public class CorrelationContext {
     /**
      * Clone the context data, work for capture to cross-thread.
      */
+    @Override
     public CorrelationContext clone() {
         final CorrelationContext context = new CorrelationContext();
         context.data.putAll(this.data);

apm-sniffer/apm-agent-core/src/main/java/org/apache/skywalking/apm/agent/core/context/util/ThrowableTransformer.java

@@ -37,10 +37,12 @@ public enum ThrowableTransformer {
             stackMessage.append(printExceptionInfo(causeException));
 
             boolean isLookDeeper = printStackElement(causeException.getStackTrace(), new AppendListener() {
+                @Override
                 public void append(String value) {
                     stackMessage.append(value);
                 }
 
+                @Override
                 public boolean overMaxLength() {
                     return stackMessage.length() > maxLength;
                 }

apm-sniffer/apm-agent-core/src/main/java/org/apache/skywalking/apm/agent/core/plugin/match/ProtectiveShieldMatcher.java

@@ -41,6 +41,7 @@ public class ProtectiveShieldMatcher<T> extends ElementMatcher.Junction.Abstract
         this.matcher = matcher;
     }
 
+    @Override
     public boolean matches(T target) {
         try {
             return this.matcher.matches(target);

apm-sniffer/apm-sdk-plugin/jdbc-commons/src/main/java/org/apache/skywalking/apm/plugin/jdbc/trace/SWCallableStatement.java

@@ -64,904 +64,1129 @@ public class SWCallableStatement implements CallableStatement {
         this.sql = sql;
     }
 
+    @Override
     public ResultSet executeQuery() throws SQLException {
         return CallableStatementTracing.execute(realStatement, connectInfo, "executeQuery", sql, new CallableStatementTracing.Executable<ResultSet>() {
+            @Override
             public ResultSet exe(CallableStatement realStatement, String sql) throws SQLException {
                 return realStatement.executeQuery();
             }
         });
     }
 
+    @Override
     public int executeUpdate() throws SQLException {
         return CallableStatementTracing.execute(realStatement, connectInfo, "executeUpdate", sql, new CallableStatementTracing.Executable<Integer>() {
+            @Override
             public Integer exe(CallableStatement realStatement, String sql) throws SQLException {
                 return realStatement.executeUpdate();
             }
         });
     }
 
+    @Override
     public void setNull(int parameterIndex, int sqlType) throws SQLException {
         realStatement.setNull(parameterIndex, sqlType);
     }
 
+    @Override
     public void setBoolean(int parameterIndex, boolean x) throws SQLException {
         realStatement.setBoolean(parameterIndex, x);
     }
 
+    @Override
     public void setByte(int parameterIndex, byte x) throws SQLException {
         realStatement.setByte(parameterIndex, x);
     }
 
+    @Override
     public void setShort(int parameterIndex, short x) throws SQLException {
         realStatement.setShort(parameterIndex, x);
     }
 
+    @Override
     public void setInt(int parameterIndex, int x) throws SQLException {
         realStatement.setInt(parameterIndex, x);
     }
 
+    @Override
     public void setLong(int parameterIndex, long x) throws SQLException {
         realStatement.setLong(parameterIndex, x);
     }
 
+    @Override
     public void setFloat(int parameterIndex, float x) throws SQLException {
         realStatement.setFloat(parameterIndex, x);
     }
 
+    @Override
     public void setDouble(int parameterIndex, double x) throws SQLException {
         realStatement.setDouble(parameterIndex, x);
     }
 
+    @Override
     public void setBigDecimal(int parameterIndex, BigDecimal x) throws SQLException {
         realStatement.setBigDecimal(parameterIndex, x);
     }
 
+    @Override
     public void setString(int parameterIndex, String x) throws SQLException {
         realStatement.setString(parameterIndex, x);
     }
 
+    @Override
     public void setBytes(int parameterIndex, byte[] x) throws SQLException {
         realStatement.setBytes(parameterIndex, x);
     }
 
+    @Override
     public void setDate(int parameterIndex, Date x) throws SQLException {
         realStatement.setDate(parameterIndex, x);
     }
 
+    @Override
     public void setTime(int parameterIndex, Time x) throws SQLException {
         realStatement.setTime(parameterIndex, x);
     }
 
+    @Override
     public void setTimestamp(int parameterIndex, Timestamp x) throws SQLException {
         realStatement.setTimestamp(parameterIndex, x);
     }
 
+    @Override
     public void setAsciiStream(int parameterIndex, InputStream x, int length) throws SQLException {
         realStatement.setAsciiStream(parameterIndex, x, length);
     }
 
+    @Override
     @Deprecated
     public void setUnicodeStream(int parameterIndex, InputStream x, int length) throws SQLException {
         realStatement.setUnicodeStream(parameterIndex, x, length);
     }
 
+    @Override
     public void setBinaryStream(int parameterIndex, InputStream x, int length) throws SQLException {
         realStatement.setBinaryStream(parameterIndex, x, length);
     }
 
+    @Override
     public void clearParameters() throws SQLException {
         realStatement.clearParameters();
     }
 
+    @Override
     public void setObject(int parameterIndex, Object x, int targetSqlType) throws SQLException {
         realStatement.setObject(parameterIndex, x, targetSqlType);
     }
 
+    @Override
     public void setObject(int parameterIndex, Object x) throws SQLException {
         realStatement.setObject(parameterIndex, x);
     }
 
+    @Override
     public boolean execute() throws SQLException {
         return CallableStatementTracing.execute(realStatement, connectInfo, "execute", sql, new CallableStatementTracing.Executable<Boolean>() {
+            @Override
             public Boolean exe(CallableStatement realStatement, String sql) throws SQLException {
                 return realStatement.execute();
             }
         });
     }
 
+    @Override
     public void addBatch() throws SQLException {
         realStatement.addBatch();
     }
 
+    @Override
     public void setCharacterStream(int parameterIndex, Reader reader, int length) throws SQLException {
         realStatement.setCharacterStream(parameterIndex, reader, length);
     }
 
+    @Override
     public void setRef(int parameterIndex, Ref x) throws SQLException {
         realStatement.setRef(parameterIndex, x);
     }
 
+    @Override
     public void setBlob(int parameterIndex, Blob x) throws SQLException {
         realStatement.setBlob(parameterIndex, x);
     }
 
+    @Override
     public void setClob(int parameterIndex, Clob x) throws SQLException {
         realStatement.setClob(parameterIndex, x);
     }
 
+    @Override
     public void setArray(int parameterIndex, Array x) throws SQLException {
         realStatement.setArray(parameterIndex, x);
     }
 
+    @Override
     public ResultSetMetaData getMetaData() throws SQLException {
         return realStatement.getMetaData();
     }
 
+    @Override
     public void setDate(int parameterIndex, Date x, Calendar cal) throws SQLException {
         realStatement.setDate(parameterIndex, x, cal);
     }
 
+    @Override
     public void setTime(int parameterIndex, Time x, Calendar cal) throws SQLException {
         realStatement.setTime(parameterIndex, x, cal);
     }
 
+    @Override
     public void setTimestamp(int parameterIndex, Timestamp x, Calendar cal) throws SQLException {
         realStatement.setTimestamp(parameterIndex, x, cal);
     }
 
+    @Override
     public void setNull(int parameterIndex, int sqlType, String typeName) throws SQLException {
         realStatement.setNull(parameterIndex, sqlType, typeName);
     }
 
+    @Override
     public void setURL(int parameterIndex, URL x) throws SQLException {
         realStatement.setURL(parameterIndex, x);
     }
 
+    @Override
     public ParameterMetaData getParameterMetaData() throws SQLException {
         return realStatement.getParameterMetaData();
     }
 
+    @Override
     public void setRowId(int parameterIndex, RowId x) throws SQLException {
         realStatement.setRowId(parameterIndex, x);
     }
 
+    @Override
     public void setNString(int parameterIndex, String value) throws SQLException {
         realStatement.setNString(parameterIndex, value);
     }
 
+    @Override
     public void setNCharacterStream(int parameterIndex, Reader value, long length) throws SQLException {
         realStatement.setNCharacterStream(parameterIndex, value, length);
     }
 
+    @Override
     public void setNClob(int parameterIndex, NClob value) throws SQLException {
         realStatement.setNClob(parameterIndex, value);
     }
 
+    @Override
     public void setClob(int parameterIndex, Reader reader, long length) throws SQLException {
         realStatement.setClob(parameterIndex, reader, length);
     }
 
+    @Override
     public void setBlob(int parameterIndex, InputStream inputStream, long length) throws SQLException {
         realStatement.setBlob(parameterIndex, inputStream, length);
     }
 
+    @Override
     public void setNClob(int parameterIndex, Reader reader, long length) throws SQLException {
         realStatement.setNClob(parameterIndex, reader, length);
     }
 
+    @Override
     public void setSQLXML(int parameterIndex, SQLXML xmlObject) throws SQLException {
         realStatement.setSQLXML(parameterIndex, xmlObject);
     }
 
+    @Override
     public void setObject(int parameterIndex, Object x, int targetSqlType, int scaleOrLength) throws SQLException {
         realStatement.setObject(parameterIndex, x, targetSqlType, scaleOrLength);
     }
 
+    @Override
     public void setAsciiStream(int parameterIndex, InputStream x, long length) throws SQLException {
         realStatement.setAsciiStream(parameterIndex, x, length);
     }
 
+    @Override
     public void setBinaryStream(int parameterIndex, InputStream x, long length) throws SQLException {
         realStatement.setBinaryStream(parameterIndex, x, length);
     }
 
+    @Override
     public void setCharacterStream(int parameterIndex, Reader reader, long length) throws SQLException {
         realStatement.setCharacterStream(parameterIndex, reader, length);
     }
 
+    @Override
     public void setAsciiStream(int parameterIndex, InputStream x) throws SQLException {
         realStatement.setAsciiStream(parameterIndex, x);
     }
 
+    @Override
     public void setBinaryStream(int parameterIndex, InputStream x) throws SQLException {
         realStatement.setBinaryStream(parameterIndex, x);
     }
 
+    @Override
     public void setCharacterStream(int parameterIndex, Reader reader) throws SQLException {
         realStatement.setCharacterStream(parameterIndex, reader);
     }
 
+    @Override
     public void setNCharacterStream(int parameterIndex, Reader value) throws SQLException {
         realStatement.setNCharacterStream(parameterIndex, value);
     }
 
+    @Override
     public void setClob(int parameterIndex, Reader reader) throws SQLException {
         realStatement.setClob(parameterIndex, reader);
     }
 
+    @Override
     public void setBlob(int parameterIndex, InputStream inputStream) throws SQLException {
         realStatement.setBlob(parameterIndex, inputStream);
     }
 
+    @Override
     public void setNClob(int parameterIndex, Reader reader) throws SQLException {
         realStatement.setNClob(parameterIndex, reader);
     }
 
+    @Override
     public ResultSet executeQuery(String sql) throws SQLException {
         return CallableStatementTracing.execute(realStatement, connectInfo, "executeQuery", sql, new CallableStatementTracing.Executable<ResultSet>() {
+            @Override
             public ResultSet exe(CallableStatement realStatement, String sql) throws SQLException {
                 return realStatement.executeQuery(sql);
             }
         });
     }
 
+    @Override
     public int executeUpdate(String sql) throws SQLException {
         return CallableStatementTracing.execute(realStatement, connectInfo, "executeUpdate", sql, new CallableStatementTracing.Executable<Integer>() {
+            @Override
             public Integer exe(CallableStatement realStatement, String sql) throws SQLException {
                 return realStatement.executeUpdate(sql);
             }
         });
     }
 
+    @Override
     public void close() throws SQLException {
         realStatement.close();
     }
 
+    @Override
     public int getMaxFieldSize() throws SQLException {
         return realStatement.getMaxFieldSize();
     }
 
+    @Override
     public void setMaxFieldSize(int max) throws SQLException {
         realStatement.setMaxFieldSize(max);
     }
 
+    @Override
     public int getMaxRows() throws SQLException {
         return realStatement.getMaxRows();
     }
 
+    @Override
     public void setMaxRows(int max) throws SQLException {
         realStatement.setMaxRows(max);
     }
 
+    @Override
     public void setEscapeProcessing(boolean enable) throws SQLException {
         realStatement.setEscapeProcessing(enable);
     }
 
+    @Override
     public int getQueryTimeout() throws SQLException {
         return realStatement.getQueryTimeout();
     }
 
+    @Override
     public void setQueryTimeout(int seconds) throws SQLException {
         realStatement.setQueryTimeout(seconds);
     }
 
+    @Override
     public void cancel() throws SQLException {
         realStatement.cancel();
     }
 
+    @Override
     public SQLWarning getWarnings() throws SQLException {
         return realStatement.getWarnings();
     }
 
+    @Override
     public void clearWarnings() throws SQLException {
         realStatement.clearWarnings();
     }
 
+    @Override
     public void setCursorName(String name) throws SQLException {
         realStatement.setCursorName(name);
     }
 
+    @Override
     public boolean execute(String sql) throws SQLException {
         return CallableStatementTracing.execute(realStatement, connectInfo, "execute", sql, new CallableStatementTracing.Executable<Boolean>() {
+            @Override
             public Boolean exe(CallableStatement realStatement, String sql) throws SQLException {
                 return realStatement.execute(sql);
             }
         });
     }
 
+    @Override
     public ResultSet getResultSet() throws SQLException {
         return realStatement.getResultSet();
     }
 
+    @Override
     public int getUpdateCount() throws SQLException {
         return realStatement.getUpdateCount();
     }
 
+    @Override
     public boolean getMoreResults() throws SQLException {
         return realStatement.getMoreResults();
     }
 
+    @Override
     public void setFetchDirection(int direction) throws SQLException {
         realStatement.setFetchDirection(direction);
     }
 
+    @Override
     public int getFetchDirection() throws SQLException {
         return realStatement.getFetchDirection();
     }
 
+    @Override
     public void setFetchSize(int rows) throws SQLException {
         realStatement.setFetchSize(rows);
     }
 
+    @Override
     public int getFetchSize() throws SQLException {
         return realStatement.getFetchSize();
     }
 
+    @Override
     public int getResultSetConcurrency() throws SQLException {
         return realStatement.getResultSetConcurrency();
     }
 
+    @Override
     public int getResultSetType() throws SQLException {
         return realStatement.getResultSetType();
     }
 
+    @Override
     public void addBatch(String sql) throws SQLException {
         realStatement.addBatch();
     }
 
+    @Override
     public void clearBatch() throws SQLException {
         realStatement.clearBatch();
     }
 
+    @Override
     public int[] executeBatch() throws SQLException {
         return CallableStatementTracing.execute(realStatement, connectInfo, "executeBatch", "", new CallableStatementTracing.Executable<int[]>() {
+            @Override
             public int[] exe(CallableStatement realStatement, String sql) throws SQLException {
                 return realStatement.executeBatch();
             }
         });
     }
 
+    @Override
     public Connection getConnection() throws SQLException {
         return this.realConnection;
     }
 
+    @Override
     public boolean getMoreResults(int current) throws SQLException {
         return realStatement.getMoreResults(current);
     }
 
+    @Override
     public ResultSet getGeneratedKeys() throws SQLException {
         return realStatement.getGeneratedKeys();
     }
 
+    @Override
     public int executeUpdate(String sql, final int autoGeneratedKeys) throws SQLException {
         return CallableStatementTracing.execute(realStatement, connectInfo, "executeUpdate", sql, new CallableStatementTracing.Executable<Integer>() {
+            @Override
             public Integer exe(CallableStatement realStatement, String sql) throws SQLException {
                 return realStatement.executeUpdate(sql, autoGeneratedKeys);
             }
         });
     }
 
+    @Override
     public int executeUpdate(String sql, final int[] columnIndexes) throws SQLException {
         return CallableStatementTracing.execute(realStatement, connectInfo, "executeUpdate", sql, new CallableStatementTracing.Executable<Integer>() {
+            @Override
             public Integer exe(CallableStatement realStatement, String sql) throws SQLException {
                 return realStatement.executeUpdate(sql, columnIndexes);
             }
         });
     }
 
+    @Override
     public int executeUpdate(String sql, final String[] columnNames) throws SQLException {
         return CallableStatementTracing.execute(realStatement, connectInfo, "executeUpdate", sql, new CallableStatementTracing.Executable<Integer>() {
+            @Override
             public Integer exe(CallableStatement realStatement, String sql) throws SQLException {
                 return realStatement.executeUpdate(sql, columnNames);
             }
         });
     }
 
+    @Override
     public boolean execute(String sql, final int autoGeneratedKeys) throws SQLException {
         return CallableStatementTracing.execute(realStatement, connectInfo, "execute", sql, new CallableStatementTracing.Executable<Boolean>() {
+            @Override
             public Boolean exe(CallableStatement realStatement, String sql) throws SQLException {
                 return realStatement.execute(sql, autoGeneratedKeys);
             }
         });
     }
 
+    @Override
     public boolean execute(String sql, final int[] columnIndexes) throws SQLException {
         return CallableStatementTracing.execute(realStatement, connectInfo, "execute", sql, new CallableStatementTracing.Executable<Boolean>() {
+            @Override
             public Boolean exe(CallableStatement realStatement, String sql) throws SQLException {
                 return realStatement.execute(sql, columnIndexes);
             }
         });
     }
 
+    @Override
     public boolean execute(String sql, final String[] columnNames) throws SQLException {
         return CallableStatementTracing.execute(realStatement, connectInfo, "execute", sql, new CallableStatementTracing.Executable<Boolean>() {
+            @Override
             public Boolean exe(CallableStatement realStatement, String sql) throws SQLException {
                 return realStatement.execute(sql, columnNames);
             }
         });
     }
 
+    @Override
     public int getResultSetHoldability() throws SQLException {
         return realStatement.getResultSetHoldability();
     }
 
+    @Override
     public boolean isClosed() throws SQLException {
         return realStatement.isClosed();
     }
 
+    @Override
     public void setPoolable(boolean poolable) throws SQLException {
         realStatement.setPoolable(poolable);
     }
 
+    @Override
     public boolean isPoolable() throws SQLException {
         return realStatement.isPoolable();
     }
 
+    @Override
     public void closeOnCompletion() throws SQLException {
         realStatement.closeOnCompletion();
     }
 
+    @Override
     public boolean isCloseOnCompletion() throws SQLException {
         return realStatement.isCloseOnCompletion();
     }
 
+    @Override
     public <T> T unwrap(Class<T> iface) throws SQLException {
         return realStatement.unwrap(iface);
     }
 
+    @Override
     public boolean isWrapperFor(Class<?> iface) throws SQLException {
         return realStatement.isWrapperFor(iface);
     }
 
+    @Override
     public void registerOutParameter(int parameterIndex, int sqlType) throws SQLException {
         realStatement.registerOutParameter(parameterIndex, sqlType);
     }
 
+    @Override
     public void registerOutParameter(int parameterIndex, int sqlType, int scale) throws SQLException {
         realStatement.registerOutParameter(parameterIndex, sqlType, scale);
     }
 
+    @Override
     public boolean wasNull() throws SQLException {
         return realStatement.wasNull();
     }
 
+    @Override
     public String getString(int parameterIndex) throws SQLException {
         return realStatement.getString(parameterIndex);
     }
 
+    @Override
     public boolean getBoolean(int parameterIndex) throws SQLException {
         return realStatement.getBoolean(parameterIndex);
     }
 
+    @Override
     public byte getByte(int parameterIndex) throws SQLException {
         return realStatement.getByte(parameterIndex);
     }
 
+    @Override
     public short getShort(int parameterIndex) throws SQLException {
         return realStatement.getShort(parameterIndex);
     }
 
+    @Override
     public int getInt(int parameterIndex) throws SQLException {
         return realStatement.getInt(parameterIndex);
     }
 
+    @Override
     public long getLong(int parameterIndex) throws SQLException {
         return realStatement.getLong(parameterIndex);
     }
 
+    @Override
     public float getFloat(int parameterIndex) throws SQLException {
         return realStatement.getFloat(parameterIndex);
     }
 
+    @Override
     public double getDouble(int parameterIndex) throws SQLException {
         return realStatement.getDouble(parameterIndex);
     }
 
+    @Override
     @Deprecated
     public BigDecimal getBigDecimal(int parameterIndex, int scale) throws SQLException {
         return realStatement.getBigDecimal(parameterIndex, scale);
     }
 
+    @Override
     public byte[] getBytes(int parameterIndex) throws SQLException {
         return realStatement.getBytes(parameterIndex);
     }
 
+    @Override
     public Date getDate(int parameterIndex) throws SQLException {
         return realStatement.getDate(parameterIndex);
     }
 
+    @Override
     public Time getTime(int parameterIndex) throws SQLException {
         return realStatement.getTime(parameterIndex);
     }
 
+    @Override
     public Timestamp getTimestamp(int parameterIndex) throws SQLException {
         return realStatement.getTimestamp(parameterIndex);
     }
 
+    @Override
     public Object getObject(int parameterIndex) throws SQLException {
         return realStatement.getObject(parameterIndex);
     }
 
+    @Override
     public BigDecimal getBigDecimal(int parameterIndex) throws SQLException {
         return realStatement.getBigDecimal(parameterIndex);
     }
 
+    @Override
     public Object getObject(int parameterIndex, Map<String, Class<?>> map) throws SQLException {
         return realStatement.getObject(parameterIndex, map);
     }
 
+    @Override
     public Ref getRef(int parameterIndex) throws SQLException {
         return realStatement.getRef(parameterIndex);
     }
 
+    @Override
     public Blob getBlob(int parameterIndex) throws SQLException {
         return realStatement.getBlob(parameterIndex);
     }
 
+    @Override
     public Clob getClob(int parameterIndex) throws SQLException {
         return realStatement.getClob(parameterIndex);
     }
 
+    @Override
     public Array getArray(int parameterIndex) throws SQLException {
         return realStatement.getArray(parameterIndex);
     }
 
+    @Override
     public Date getDate(int parameterIndex, Calendar cal) throws SQLException {
         return realStatement.getDate(parameterIndex, cal);
     }
 
+    @Override
     public Time getTime(int parameterIndex, Calendar cal) throws SQLException {
         return realStatement.getTime(parameterIndex, cal);
     }
 
+    @Override
     public Timestamp getTimestamp(int parameterIndex, Calendar cal) throws SQLException {
         return realStatement.getTimestamp(parameterIndex, cal);
     }
 
+    @Override
     public void registerOutParameter(int parameterIndex, int sqlType, String typeName) throws SQLException {
         realStatement.registerOutParameter(parameterIndex, sqlType, typeName);
     }
 
+    @Override
     public void registerOutParameter(String parameterName, int sqlType) throws SQLException {
         realStatement.registerOutParameter(parameterName, sqlType);
     }
 
+    @Override
     public void registerOutParameter(String parameterName, int sqlType, int scale) throws SQLException {
         realStatement.registerOutParameter(parameterName, sqlType, scale);
     }
 
+    @Override
     public void registerOutParameter(String parameterName, int sqlType, String typeName) throws SQLException {
         realStatement.registerOutParameter(parameterName, sqlType, typeName);
     }
 
+    @Override
     public URL getURL(int parameterIndex) throws SQLException {
         return realStatement.getURL(parameterIndex);
     }
 
+    @Override
     public void setURL(String parameterName, URL val) throws SQLException {
         realStatement.setURL(parameterName, val);
     }
 
+    @Override
     public void setNull(String parameterName, int sqlType) throws SQLException {
         realStatement.setNull(parameterName, sqlType);
     }
 
+    @Override
     public void setBoolean(String parameterName, boolean x) throws SQLException {
         realStatement.setBoolean(parameterName, x);
     }
 
+    @Override
     public void setByte(String parameterName, byte x) throws SQLException {
         realStatement.setByte(parameterName, x);
     }
 
+    @Override
     public void setShort(String parameterName, short x) throws SQLException {
         realStatement.setShort(parameterName, x);
     }
 
+    @Override
     public void setInt(String parameterName, int x) throws SQLException {
         realStatement.setInt(parameterName, x);
     }
 
+    @Override
     public void setLong(String parameterName, long x) throws SQLException {
         realStatement.setLong(parameterName, x);
     }
 
+    @Override
     public void setFloat(String parameterName, float x) throws SQLException {
         realStatement.setFloat(parameterName, x);
     }
 
+    @Override
     public void setDouble(String parameterName, double x) throws SQLException {
         realStatement.setDouble(parameterName, x);
     }
 
+    @Override
     public void setBigDecimal(String parameterName, BigDecimal x) throws SQLException {
         realStatement.setBigDecimal(parameterName, x);
     }
 
+    @Override
     public void setString(String parameterName, String x) throws SQLException {
         realStatement.setString(parameterName, x);
     }
 
+    @Override
     public void setBytes(String parameterName, byte[] x) throws SQLException {
         realStatement.setBytes(parameterName, x);
     }
 
+    @Override
     public void setDate(String parameterName, Date x) throws SQLException {
         realStatement.setDate(parameterName, x);
     }
 
+    @Override
     public void setTime(String parameterName, Time x) throws SQLException {
         realStatement.setTime(parameterName, x);
     }
 
+    @Override
     public void setTimestamp(String parameterName, Timestamp x) throws SQLException {
         realStatement.setTimestamp(parameterName, x);
     }
 
+    @Override
     public void setAsciiStream(String parameterName, InputStream x, int length) throws SQLException {
         realStatement.setAsciiStream(parameterName, x, length);
     }
 
+    @Override
     public void setBinaryStream(String parameterName, InputStream x, int length) throws SQLException {
         realStatement.setBinaryStream(parameterName, x, length);
     }
 
+    @Override
     public void setObject(String parameterName, Object x, int targetSqlType, int scale) throws SQLException {
         realStatement.setObject(parameterName, x, targetSqlType, scale);
     }
 
+    @Override
     public void setObject(String parameterName, Object x, int targetSqlType) throws SQLException {
         realStatement.setObject(parameterName, x, targetSqlType);
     }
 
+    @Override
     public void setObject(String parameterName, Object x) throws SQLException {
         realStatement.setObject(parameterName, x);
     }
 
+    @Override
     public void setCharacterStream(String parameterName, Reader reader, int length) throws SQLException {
         realStatement.setCharacterStream(parameterName, reader, length);
     }
 
+    @Override
     public void setDate(String parameterName, Date x, Calendar cal) throws SQLException {
         realStatement.setDate(parameterName, x, cal);
     }
 
+    @Override
     public void setTime(String parameterName, Time x, Calendar cal) throws SQLException {
         realStatement.setTime(parameterName, x, cal);
     }
 
+    @Override
     public void setTimestamp(String parameterName, Timestamp x, Calendar cal) throws SQLException {
         realStatement.setTimestamp(parameterName, x, cal);
     }
 
+    @Override
     public void setNull(String parameterName, int sqlType, String typeName) throws SQLException {
         realStatement.setNull(parameterName, sqlType, typeName);
     }
 
+    @Override
     public String getString(String parameterName) throws SQLException {
         return realStatement.getString(parameterName);
     }
 
+    @Override
     public boolean getBoolean(String parameterName) throws SQLException {
         return realStatement.getBoolean(parameterName);
     }
 
+    @Override
     public byte getByte(String parameterName) throws SQLException {
         return realStatement.getByte(parameterName);
     }
 
+    @Override
     public short getShort(String parameterName) throws SQLException {
         return realStatement.getShort(parameterName);
     }
 
+    @Override
     public int getInt(String parameterName) throws SQLException {
         return realStatement.getInt(parameterName);
     }
 
+    @Override
     public long getLong(String parameterName) throws SQLException {
         return realStatement.getLong(parameterName);
     }
 
+    @Override
     public float getFloat(String parameterName) throws SQLException {
         return realStatement.getFloat(parameterName);
     }
 
+    @Override
     public double getDouble(String parameterName) throws SQLException {
         return realStatement.getDouble(parameterName);
     }
 
+    @Override
     public byte[] getBytes(String parameterName) throws SQLException {
         return realStatement.getBytes(parameterName);
     }
 
+    @Override
     public Date getDate(String parameterName) throws SQLException {
         return realStatement.getDate(parameterName);
     }
 
+    @Override
     public Time getTime(String parameterName) throws SQLException {
         return realStatement.getTime(parameterName);
     }
 
+    @Override
     public Timestamp getTimestamp(String parameterName) throws SQLException {
         return realStatement.getTimestamp(parameterName);
     }
 
+    @Override
     public Object getObject(String parameterName) throws SQLException {
         return realStatement.getObject(parameterName);
     }
 
+    @Override
     public BigDecimal getBigDecimal(String parameterName) throws SQLException {
         return realStatement.getBigDecimal(parameterName);
     }
 
+    @Override
     public Object getObject(String parameterName, Map<String, Class<?>> map) throws SQLException {
         return realStatement.getObject(parameterName, map);
     }
 
+    @Override
     public Ref getRef(String parameterName) throws SQLException {
         return realStatement.getRef(parameterName);
     }
 
+    @Override
     public Blob getBlob(String parameterName) throws SQLException {
         return realStatement.getBlob(parameterName);
     }
 
+    @Override
     public Clob getClob(String parameterName) throws SQLException {
         return realStatement.getClob(parameterName);
     }
 
+    @Override
     public Array getArray(String parameterName) throws SQLException {
         return realStatement.getArray(parameterName);
     }
 
+    @Override
     public Date getDate(String parameterName, Calendar cal) throws SQLException {
         return realStatement.getDate(parameterName, cal);
     }
 
+    @Override
     public Time getTime(String parameterName, Calendar cal) throws SQLException {
         return realStatement.getTime(parameterName, cal);
     }
 
+    @Override
     public Timestamp getTimestamp(String parameterName, Calendar cal) throws SQLException {
         return realStatement.getTimestamp(parameterName, cal);
     }
 
+    @Override
     public URL getURL(String parameterName) throws SQLException {
         return realStatement.getURL(parameterName);
     }
 
+    @Override
     public RowId getRowId(int parameterIndex) throws SQLException {
         return realStatement.getRowId(parameterIndex);
     }
 
+    @Override
     public RowId getRowId(String parameterName) throws SQLException {
         return realStatement.getRowId(parameterName);
     }
 
+    @Override
     public void setRowId(String parameterName, RowId x) throws SQLException {
         realStatement.setRowId(parameterName, x);
     }
 
+    @Override
     public void setNString(String parameterName, String value) throws SQLException {
         realStatement.setNString(parameterName, value);
     }
 
+    @Override
     public void setNCharacterStream(String parameterName, Reader value, long length) throws SQLException {
         realStatement.setNCharacterStream(parameterName, value, length);
     }
 
+    @Override
     public void setNClob(String parameterName, NClob value) throws SQLException {
         realStatement.setNClob(parameterName, value);
     }
 
+    @Override
     public void setClob(String parameterName, Reader reader, long length) throws SQLException {
         realStatement.setClob(parameterName, reader, length);
     }
 
+    @Override
     public void setBlob(String parameterName, InputStream inputStream, long length) throws SQLException {
         realStatement.setBlob(parameterName, inputStream, length);
     }
 
+    @Override
     public void setNClob(String parameterName, Reader reader, long length) throws SQLException {
         realStatement.setNClob(parameterName, reader, length);
     }
 
+    @Override
     public NClob getNClob(int parameterIndex) throws SQLException {
         return realStatement.getNClob(parameterIndex);
     }
 
+    @Override
     public NClob getNClob(String parameterName) throws SQLException {
         return realStatement.getNClob(parameterName);
     }
 
+    @Override
     public void setSQLXML(String parameterName, SQLXML xmlObject) throws SQLException {
         realStatement.setSQLXML(parameterName, xmlObject);
     }
 
+    @Override
     public SQLXML getSQLXML(int parameterIndex) throws SQLException {
         return realStatement.getSQLXML(parameterIndex);
     }
 
+    @Override
     public SQLXML getSQLXML(String parameterName) throws SQLException {
         return realStatement.getSQLXML(parameterName);
     }
 
+    @Override
     public String getNString(int parameterIndex) throws SQLException {
         return realStatement.getNString(parameterIndex);
     }
 
+    @Override
     public String getNString(String parameterName) throws SQLException {
         return realStatement.getNString(parameterName);
     }
 
+    @Override
     public Reader getNCharacterStream(int parameterIndex) throws SQLException {
         return realStatement.getNCharacterStream(parameterIndex);
     }
 
+    @Override
     public Reader getNCharacterStream(String parameterName) throws SQLException {
         return realStatement.getNCharacterStream(parameterName);
     }
 
+    @Override
     public Reader getCharacterStream(int parameterIndex) throws SQLException {
         return realStatement.getCharacterStream(parameterIndex);
     }
 
+    @Override
     public Reader getCharacterStream(String parameterName) throws SQLException {
         return realStatement.getCharacterStream(parameterName);
     }
 
+    @Override
     public void setBlob(String parameterName, Blob x) throws SQLException {
         realStatement.setBlob(parameterName, x);
     }
 
+    @Override
     public void setClob(String parameterName, Clob x) throws SQLException {
         realStatement.setClob(parameterName, x);
     }
 
+    @Override
     public void setAsciiStream(String parameterName, InputStream x, long length) throws SQLException {
         realStatement.setAsciiStream(parameterName, x, length);
     }
 
+    @Override
     public void setBinaryStream(String parameterName, InputStream x, long length) throws SQLException {
         realStatement.setBinaryStream(parameterName, x, length);
     }
 
+    @Override
     public void setCharacterStream(String parameterName, Reader reader, long length) throws SQLException {
         realStatement.setCharacterStream(parameterName, reader, length);
     }
 
+    @Override
     public void setAsciiStream(String parameterName, InputStream x) throws SQLException {
         realStatement.setAsciiStream(parameterName, x);
     }
 
+    @Override
     public void setBinaryStream(String parameterName, InputStream x) throws SQLException {
         realStatement.setBinaryStream(parameterName, x);
     }
 
+    @Override
     public void setCharacterStream(String parameterName, Reader reader) throws SQLException {
         realStatement.setCharacterStream(parameterName, reader);
     }
 
+    @Override
     public void setNCharacterStream(String parameterName, Reader value) throws SQLException {
         realStatement.setNCharacterStream(parameterName, value);
     }
 
+    @Override
     public void setClob(String parameterName, Reader reader) throws SQLException {
         realStatement.setClob(parameterName, reader);
     }
 
+    @Override
     public void setBlob(String parameterName, InputStream inputStream) throws SQLException {
         realStatement.setBlob(parameterName, inputStream);
     }
 
+    @Override
     public void setNClob(String parameterName, Reader reader) throws SQLException {
         realStatement.setNClob(parameterName, reader);
     }
 
+    @Override
     public <T> T getObject(int parameterIndex, Class<T> type) throws SQLException {
         return realStatement.getObject(parameterIndex, type);
     }
 
+    @Override
     public <T> T getObject(String parameterName, Class<T> type) throws SQLException {
         return realStatement.getObject(parameterName, type);
     }

apm-sniffer/apm-sdk-plugin/jdbc-commons/src/main/java/org/apache/skywalking/apm/plugin/jdbc/trace/SWPreparedStatement.java

@@ -63,451 +63,563 @@ public class SWPreparedStatement implements PreparedStatement {
         this.sql = sql;
     }
 
+    @Override
     public ResultSet executeQuery(String sql) throws SQLException {
         return PreparedStatementTracing.execute(realStatement, connectInfo, "executeQuery", sql, new PreparedStatementTracing.Executable<ResultSet>() {
+            @Override
             public ResultSet exe(PreparedStatement realStatement, String sql) throws SQLException {
                 return realStatement.executeQuery(sql);
             }
         });
     }
 
+    @Override
     public int executeUpdate(String sql) throws SQLException {
         return PreparedStatementTracing.execute(realStatement, connectInfo, "executeUpdate", sql, new PreparedStatementTracing.Executable<Integer>() {
+            @Override
             public Integer exe(PreparedStatement realStatement, String sql) throws SQLException {
                 return realStatement.executeUpdate(sql);
             }
         });
     }
 
+    @Override
     public void close() throws SQLException {
         realStatement.close();
     }
 
+    @Override
     public int getMaxFieldSize() throws SQLException {
         return realStatement.getMaxFieldSize();
     }
 
+    @Override
     public void setMaxFieldSize(int max) throws SQLException {
         realStatement.setMaxFieldSize(max);
     }
 
+    @Override
     public int getMaxRows() throws SQLException {
         return realStatement.getMaxRows();
     }
 
+    @Override
     public void setMaxRows(int max) throws SQLException {
         realStatement.setMaxRows(max);
     }
 
+    @Override
     public void setEscapeProcessing(boolean enable) throws SQLException {
         realStatement.setEscapeProcessing(enable);
     }
 
+    @Override
     public int getQueryTimeout() throws SQLException {
         return realStatement.getQueryTimeout();
     }
 
+    @Override
     public void setQueryTimeout(int seconds) throws SQLException {
         realStatement.setQueryTimeout(seconds);
     }
 
+    @Override
     public void cancel() throws SQLException {
         realStatement.cancel();
     }
 
+    @Override
     public SQLWarning getWarnings() throws SQLException {
         return realStatement.getWarnings();
     }
 
+    @Override
     public void clearWarnings() throws SQLException {
         realStatement.clearWarnings();
     }
 
+    @Override
     public void setCursorName(String name) throws SQLException {
         realStatement.setCursorName(name);
     }
 
+    @Override
     public boolean execute(String sql) throws SQLException {
         return PreparedStatementTracing.execute(realStatement, connectInfo, "execute", sql, new PreparedStatementTracing.Executable<Boolean>() {
+            @Override
             public Boolean exe(PreparedStatement realStatement, String sql) throws SQLException {
                 return realStatement.execute(sql);
             }
         });
     }
 
+    @Override
     public ResultSet getResultSet() throws SQLException {
         return realStatement.getResultSet();
     }
 
+    @Override
     public int getUpdateCount() throws SQLException {
         return realStatement.getUpdateCount();
     }
 
+    @Override
     public boolean getMoreResults() throws SQLException {
         return realStatement.getMoreResults();
     }
 
+    @Override
     public void setFetchDirection(int direction) throws SQLException {
         realStatement.setFetchDirection(direction);
     }
 
+    @Override
     public int getFetchDirection() throws SQLException {
         return realStatement.getFetchDirection();
     }
 
+    @Override
     public void setFetchSize(int rows) throws SQLException {
         realStatement.setFetchSize(rows);
     }
 
+    @Override
     public int getFetchSize() throws SQLException {
         return realStatement.getFetchSize();
     }
 
+    @Override
     public int getResultSetConcurrency() throws SQLException {
         return realStatement.getResultSetConcurrency();
     }
 
+    @Override
     public int getResultSetType() throws SQLException {
         return realStatement.getResultSetType();
     }
 
+    @Override
     public void addBatch(String sql) throws SQLException {
         realStatement.addBatch(sql);
     }
 
+    @Override
     public void clearBatch() throws SQLException {
         realStatement.clearBatch();
     }
 
+    @Override
     public int[] executeBatch() throws SQLException {
         return PreparedStatementTracing.execute(realStatement, connectInfo, "executeBatch", "", new PreparedStatementTracing.Executable<int[]>() {
+            @Override
             public int[] exe(PreparedStatement realStatement, String sql) throws SQLException {
                 return realStatement.executeBatch();
             }
         });
     }
 
+    @Override
     public Connection getConnection() throws SQLException {
         return realConnection;
     }
 
+    @Override
     public boolean getMoreResults(int current) throws SQLException {
         return realStatement.getMoreResults(current);
     }
 
+    @Override
     public ResultSet getGeneratedKeys() throws SQLException {
         return realStatement.getGeneratedKeys();
     }
 
+    @Override
     public int executeUpdate(String sql, final int autoGeneratedKeys) throws SQLException {
         return PreparedStatementTracing.execute(realStatement, connectInfo, "executeUpdate", sql, new PreparedStatementTracing.Executable<Integer>() {
+            @Override
             public Integer exe(PreparedStatement realStatement, String sql) throws SQLException {
                 return realStatement.executeUpdate(sql, autoGeneratedKeys);
             }
         });
     }
 
+    @Override
     public int executeUpdate(String sql, final int[] columnIndexes) throws SQLException {
         return PreparedStatementTracing.execute(realStatement, connectInfo, "executeUpdate", sql, new PreparedStatementTracing.Executable<Integer>() {
+            @Override
             public Integer exe(PreparedStatement realStatement, String sql) throws SQLException {
                 return realStatement.executeUpdate(sql, columnIndexes);
             }
         });
     }
 
+    @Override
     public int executeUpdate(String sql, final String[] columnNames) throws SQLException {
         return PreparedStatementTracing.execute(realStatement, connectInfo, "executeUpdate", sql, new PreparedStatementTracing.Executable<Integer>() {
+            @Override
             public Integer exe(PreparedStatement realStatement, String sql) throws SQLException {
                 return realStatement.executeUpdate(sql, columnNames);
             }
         });
     }
 
+    @Override
     public boolean execute(String sql, final int autoGeneratedKeys) throws SQLException {
         return PreparedStatementTracing.execute(realStatement, connectInfo, "execute", sql, new PreparedStatementTracing.Executable<Boolean>() {
+            @Override
             public Boolean exe(PreparedStatement realStatement, String sql) throws SQLException {
                 return realStatement.execute(sql, autoGeneratedKeys);
             }
         });
     }
 
+    @Override
     public boolean execute(String sql, final int[] columnIndexes) throws SQLException {
         return PreparedStatementTracing.execute(realStatement, connectInfo, "execute", sql, new PreparedStatementTracing.Executable<Boolean>() {
+            @Override
             public Boolean exe(PreparedStatement realStatement, String sql) throws SQLException {
                 return realStatement.execute(sql, columnIndexes);
             }
         });
     }
 
+    @Override
     public boolean execute(String sql, final String[] columnNames) throws SQLException {
         return PreparedStatementTracing.execute(realStatement, connectInfo, "execute", sql, new PreparedStatementTracing.Executable<Boolean>() {
+            @Override
             public Boolean exe(PreparedStatement realStatement, String sql) throws SQLException {
                 return realStatement.execute(sql, columnNames);
             }
         });
     }
 
+    @Override
     public int getResultSetHoldability() throws SQLException {
         return realStatement.getResultSetHoldability();
     }
 
+    @Override
     public boolean isClosed() throws SQLException {
         return realStatement.isClosed();
     }
 
+    @Override
     public void setPoolable(boolean poolable) throws SQLException {
         realStatement.setPoolable(poolable);
     }
 
+    @Override
     public boolean isPoolable() throws SQLException {
         return realStatement.isPoolable();
     }
 
+    @Override
     public void closeOnCompletion() throws SQLException {
         realStatement.closeOnCompletion();
     }
 
+    @Override
     public boolean isCloseOnCompletion() throws SQLException {
         return realStatement.isCloseOnCompletion();
     }
 
+    @Override
     public <T> T unwrap(Class<T> iface) throws SQLException {
         return realStatement.unwrap(iface);
     }
 
+    @Override
     public boolean isWrapperFor(Class<?> iface) throws SQLException {
         return realStatement.isWrapperFor(iface);
     }
 
+    @Override
     public ResultSet executeQuery() throws SQLException {
         return PreparedStatementTracing.execute(realStatement, connectInfo, "executeQuery", sql, new PreparedStatementTracing.Executable<ResultSet>() {
+            @Override
             public ResultSet exe(PreparedStatement realStatement, String sql) throws SQLException {
                 return realStatement.executeQuery();
             }
         });
     }
 
+    @Override
     public int executeUpdate() throws SQLException {
         return PreparedStatementTracing.execute(realStatement, connectInfo, "executeUpdate", sql, new PreparedStatementTracing.Executable<Integer>() {
+            @Override
             public Integer exe(PreparedStatement realStatement, String sql) throws SQLException {
                 return realStatement.executeUpdate();
             }
         });
     }
 
+    @Override
     public void setNull(int parameterIndex, int sqlType) throws SQLException {
         realStatement.setNull(parameterIndex, sqlType);
     }
 
+    @Override
     public void setBoolean(int parameterIndex, boolean x) throws SQLException {
         realStatement.setBoolean(parameterIndex, x);
     }
 
+    @Override
     public void setByte(int parameterIndex, byte x) throws SQLException {
         realStatement.setByte(parameterIndex, x);
     }
 
+    @Override
     public void setShort(int parameterIndex, short x) throws SQLException {
         realStatement.setShort(parameterIndex, x);
     }
 
+    @Override
     public void setInt(int parameterIndex, int x) throws SQLException {
         realStatement.setInt(parameterIndex, x);
     }
 
+    @Override
     public void setLong(int parameterIndex, long x) throws SQLException {
         realStatement.setLong(parameterIndex, x);
     }
 
+    @Override
     public void setFloat(int parameterIndex, float x) throws SQLException {
         realStatement.setFloat(parameterIndex, x);
     }
 
+    @Override
     public void setDouble(int parameterIndex, double x) throws SQLException {
         realStatement.setDouble(parameterIndex, x);
     }
 
+    @Override
     public void setBigDecimal(int parameterIndex, BigDecimal x) throws SQLException {
         realStatement.setBigDecimal(parameterIndex, x);
     }
 
+    @Override
     public void setString(int parameterIndex, String x) throws SQLException {
         realStatement.setString(parameterIndex, x);
     }
 
+    @Override
     public void setBytes(int parameterIndex, byte[] x) throws SQLException {
         realStatement.setBytes(parameterIndex, x);
     }
 
+    @Override
     public void setDate(int parameterIndex, Date x) throws SQLException {
         realStatement.setDate(parameterIndex, x);
     }
 
+    @Override
     public void setTime(int parameterIndex, Time x) throws SQLException {
         realStatement.setTime(parameterIndex, x);
     }
 
+    @Override
     public void setTimestamp(int parameterIndex, Timestamp x) throws SQLException {
         realStatement.setTimestamp(parameterIndex, x);
     }
 
+    @Override
     public void setAsciiStream(int parameterIndex, InputStream x, int length) throws SQLException {
         realStatement.setAsciiStream(parameterIndex, x, length);
     }
 
+    @Override
     @Deprecated
     public void setUnicodeStream(int parameterIndex, InputStream x, int length) throws SQLException {
         realStatement.setUnicodeStream(parameterIndex, x, length);
     }
 
+    @Override
     public void setBinaryStream(int parameterIndex, InputStream x, int length) throws SQLException {
         realStatement.setBinaryStream(parameterIndex, x, length);
     }
 
+    @Override
     public void clearParameters() throws SQLException {
         realStatement.clearParameters();
     }
 
+    @Override
     public void setObject(int parameterIndex, Object x, int targetSqlType) throws SQLException {
         realStatement.setObject(parameterIndex, x, targetSqlType);
     }
 
+    @Override
     public void setObject(int parameterIndex, Object x) throws SQLException {
         realStatement.setObject(parameterIndex, x);
     }
 
+    @Override
     public boolean execute() throws SQLException {
         return PreparedStatementTracing.execute(realStatement, connectInfo, "execute", sql, new PreparedStatementTracing.Executable<Boolean>() {
+            @Override
             public Boolean exe(PreparedStatement realStatement, String sql) throws SQLException {
                 return realStatement.execute();
             }
         });
     }
 
+    @Override
     public void addBatch() throws SQLException {
         realStatement.addBatch();
     }
 
+    @Override
     public void setCharacterStream(int parameterIndex, Reader reader, int length) throws SQLException {
         realStatement.setCharacterStream(parameterIndex, reader, length);
     }
 
+    @Override
     public void setRef(int parameterIndex, Ref x) throws SQLException {
         realStatement.setRef(parameterIndex, x);
     }
 
+    @Override
     public void setBlob(int parameterIndex, Blob x) throws SQLException {
         realStatement.setBlob(parameterIndex, x);
     }
 
+    @Override
     public void setClob(int parameterIndex, Clob x) throws SQLException {
         realStatement.setClob(parameterIndex, x);
     }
 
+    @Override
     public void setArray(int parameterIndex, Array x) throws SQLException {
         realStatement.setArray(parameterIndex, x);
     }
 
+    @Override
     public ResultSetMetaData getMetaData() throws SQLException {
         return realStatement.getMetaData();
     }
 
+    @Override
     public void setDate(int parameterIndex, Date x, Calendar cal) throws SQLException {
         realStatement.setDate(parameterIndex, x, cal);
     }
 
+    @Override
     public void setTime(int parameterIndex, Time x, Calendar cal) throws SQLException {
         realStatement.setTime(parameterIndex, x, cal);
     }
 
+    @Override
     public void setTimestamp(int parameterIndex, Timestamp x, Calendar cal) throws SQLException {
         realStatement.setTimestamp(parameterIndex, x, cal);
     }
 
+    @Override
     public void setNull(int parameterIndex, int sqlType, String typeName) throws SQLException {
         realStatement.setNull(parameterIndex, sqlType, typeName);
     }
 
+    @Override
     public void setURL(int parameterIndex, URL x) throws SQLException {
         realStatement.setURL(parameterIndex, x);
     }
 
+    @Override
     public ParameterMetaData getParameterMetaData() throws SQLException {
         return realStatement.getParameterMetaData();
     }
 
+    @Override
     public void setRowId(int parameterIndex, RowId x) throws SQLException {
         realStatement.setRowId(parameterIndex, x);
     }
 
+    @Override
     public void setNString(int parameterIndex, String value) throws SQLException {
         realStatement.setNString(parameterIndex, value);
     }
 
+    @Override
     public void setNCharacterStream(int parameterIndex, Reader value, long length) throws SQLException {
         realStatement.setNCharacterStream(parameterIndex, value, length);
     }
 
+    @Override
     public void setNClob(int parameterIndex, NClob value) throws SQLException {
         realStatement.setNClob(parameterIndex, value);
     }
 
+    @Override
     public void setClob(int parameterIndex, Reader reader, long length) throws SQLException {
         realStatement.setClob(parameterIndex, reader, length);
     }
 
+    @Override
     public void setBlob(int parameterIndex, InputStream inputStream, long length) throws SQLException {
         realStatement.setBlob(parameterIndex, inputStream, length);
     }
 
+    @Override
     public void setNClob(int parameterIndex, Reader reader, long length) throws SQLException {
         realStatement.setNClob(parameterIndex, reader, length);
     }
 
+    @Override
     public void setSQLXML(int parameterIndex, SQLXML xmlObject) throws SQLException {
         realStatement.setSQLXML(parameterIndex, xmlObject);
     }
 
+    @Override
     public void setObject(int parameterIndex, Object x, int targetSqlType, int scaleOrLength) throws SQLException {
         realStatement.setObject(parameterIndex, x, targetSqlType, scaleOrLength);
     }
 
+    @Override
     public void setAsciiStream(int parameterIndex, InputStream x, long length) throws SQLException {
         realStatement.setAsciiStream(parameterIndex, x, length);
     }
 
+    @Override
     public void setBinaryStream(int parameterIndex, InputStream x, long length) throws SQLException {
         realStatement.setBinaryStream(parameterIndex, x, length);
     }
 
+    @Override
     public void setCharacterStream(int parameterIndex, Reader reader, long length) throws SQLException {
         realStatement.setCharacterStream(parameterIndex, reader, length);
     }
 
+    @Override
     public void setAsciiStream(int parameterIndex, InputStream x) throws SQLException {
         realStatement.setAsciiStream(parameterIndex, x);
     }
 
+    @Override
     public void setBinaryStream(int parameterIndex, InputStream x) throws SQLException {
         realStatement.setBinaryStream(parameterIndex, x);
     }
 
+    @Override
     public void setCharacterStream(int parameterIndex, Reader reader) throws SQLException {
         realStatement.setCharacterStream(parameterIndex, reader);
     }
 
+    @Override
     public void setNCharacterStream(int parameterIndex, Reader value) throws SQLException {
         realStatement.setNCharacterStream(parameterIndex, value);
     }
 
+    @Override
     public void setClob(int parameterIndex, Reader reader) throws SQLException {
         realStatement.setClob(parameterIndex, reader);
     }
 
+    @Override
     public void setBlob(int parameterIndex, InputStream inputStream) throws SQLException {
         realStatement.setBlob(parameterIndex, inputStream);
     }
 
+    @Override
     public void setNClob(int parameterIndex, Reader reader) throws SQLException {
         realStatement.setNClob(parameterIndex, reader);
     }

apm-sniffer/apm-sdk-plugin/jdbc-commons/src/main/java/org/apache/skywalking/apm/plugin/jdbc/trace/SWStatement.java

@@ -42,218 +42,272 @@ public class SWStatement implements java.sql.Statement {
         this.connectInfo = connectInfo;
     }
 
+    @Override
     public <T> T unwrap(Class<T> iface) throws SQLException {
         return realStatement.unwrap(iface);
     }
 
+    @Override
     public boolean isWrapperFor(Class<?> iface) throws SQLException {
         return realStatement.isWrapperFor(iface);
     }
 
+    @Override
     public ResultSet executeQuery(String sql) throws SQLException {
         return StatementTracing.execute(realStatement, connectInfo, "executeQuery", sql, new StatementTracing.Executable<ResultSet>() {
+            @Override
             public ResultSet exe(java.sql.Statement realStatement, String sql) throws SQLException {
                 return realStatement.executeQuery(sql);
             }
         });
     }
 
+    @Override
     public int executeUpdate(String sql) throws SQLException {
         return StatementTracing.execute(realStatement, connectInfo, "executeUpdate", sql, new StatementTracing.Executable<Integer>() {
+            @Override
             public Integer exe(java.sql.Statement realStatement, String sql) throws SQLException {
                 return realStatement.executeUpdate(sql);
             }
         });
     }
 
+    @Override
     public void close() throws SQLException {
         realStatement.close();
     }
 
+    @Override
     public int getMaxFieldSize() throws SQLException {
         return realStatement.getMaxFieldSize();
     }
 
+    @Override
     public void setMaxFieldSize(int max) throws SQLException {
         realStatement.setMaxFieldSize(max);
     }
 
+    @Override
     public int getMaxRows() throws SQLException {
         return realStatement.getMaxRows();
     }
 
+    @Override
     public void setMaxRows(int max) throws SQLException {
         realStatement.setMaxRows(max);
     }
 
+    @Override
     public void setEscapeProcessing(boolean enable) throws SQLException {
         realStatement.setEscapeProcessing(enable);
     }
 
+    @Override
     public int getQueryTimeout() throws SQLException {
         return realStatement.getQueryTimeout();
     }
 
+    @Override
     public void setQueryTimeout(int seconds) throws SQLException {
         realStatement.setQueryTimeout(seconds);
     }
 
+    @Override
     public void cancel() throws SQLException {
         realStatement.cancel();
     }
 
+    @Override
     public SQLWarning getWarnings() throws SQLException {
         return realStatement.getWarnings();
     }
 
+    @Override
     public void clearWarnings() throws SQLException {
         realStatement.clearWarnings();
     }
 
+    @Override
     public void setCursorName(String name) throws SQLException {
         realStatement.setCursorName(name);
     }
 
+    @Override
     public boolean execute(String sql) throws SQLException {
         return StatementTracing.execute(realStatement, connectInfo, "execute", sql, new StatementTracing.Executable<Boolean>() {
+            @Override
             public Boolean exe(java.sql.Statement realStatement, String sql) throws SQLException {
                 return realStatement.execute(sql);
             }
         });
     }
 
+    @Override
     public ResultSet getResultSet() throws SQLException {
         return realStatement.getResultSet();
     }
 
+    @Override
     public int getUpdateCount() throws SQLException {
         return realStatement.getUpdateCount();
     }
 
+    @Override
     public boolean getMoreResults() throws SQLException {
         return realStatement.getMoreResults();
     }
 
+    @Override
     public void setFetchDirection(int direction) throws SQLException {
         realStatement.setFetchDirection(direction);
     }
 
+    @Override
     public int getFetchDirection() throws SQLException {
         return realStatement.getFetchDirection();
     }
 
+    @Override
     public void setFetchSize(int rows) throws SQLException {
         realStatement.setFetchSize(rows);
     }
 
+    @Override
     public int getFetchSize() throws SQLException {
         return realStatement.getFetchSize();
     }
 
+    @Override
     public int getResultSetConcurrency() throws SQLException {
         return realStatement.getResultSetConcurrency();
     }
 
+    @Override
     public int getResultSetType() throws SQLException {
         return realStatement.getResultSetType();
     }
 
+    @Override
     public void addBatch(String sql) throws SQLException {
         realStatement.addBatch(sql);
     }
 
+    @Override
     public void clearBatch() throws SQLException {
         realStatement.clearBatch();
     }
 
+    @Override
     public int[] executeBatch() throws SQLException {
         return StatementTracing.execute(realStatement, connectInfo, "executeBatch", "", new StatementTracing.Executable<int[]>() {
+            @Override
             public int[] exe(java.sql.Statement realStatement, String sql) throws SQLException {
                 return realStatement.executeBatch();
             }
         });
     }
 
+    @Override
     public Connection getConnection() throws SQLException {
         return this.realConnection;
     }
 
+    @Override
     public boolean getMoreResults(int current) throws SQLException {
         return realStatement.getMoreResults(current);
     }
 
+    @Override
     public ResultSet getGeneratedKeys() throws SQLException {
         return realStatement.getGeneratedKeys();
     }
 
+    @Override
     public int executeUpdate(String sql, final int autoGeneratedKeys) throws SQLException {
         return StatementTracing.execute(realStatement, connectInfo, "executeUpdate", sql, new StatementTracing.Executable<Integer>() {
+            @Override
             public Integer exe(java.sql.Statement realStatement, String sql) throws SQLException {
                 return realStatement.executeUpdate(sql, autoGeneratedKeys);
             }
         });
     }
 
+    @Override
     public int executeUpdate(String sql, final int[] columnIndexes) throws SQLException {
         return StatementTracing.execute(realStatement, connectInfo, "executeUpdate", sql, new StatementTracing.Executable<Integer>() {
+            @Override
             public Integer exe(java.sql.Statement realStatement, String sql) throws SQLException {
                 return realStatement.executeUpdate(sql, columnIndexes);
             }
         });
     }
 
+    @Override
     public int executeUpdate(String sql, final String[] columnNames) throws SQLException {
         return StatementTracing.execute(realStatement, connectInfo, "executeUpdate", sql, new StatementTracing.Executable<Integer>() {
+            @Override
             public Integer exe(java.sql.Statement realStatement, String sql) throws SQLException {
                 return realStatement.executeUpdate(sql, columnNames);
             }
         });
     }
 
+    @Override
     public boolean execute(String sql, final int autoGeneratedKeys) throws SQLException {
         return StatementTracing.execute(realStatement, connectInfo, "execute", sql, new StatementTracing.Executable<Boolean>() {
+            @Override
             public Boolean exe(java.sql.Statement realStatement, String sql) throws SQLException {
                 return realStatement.execute(sql, autoGeneratedKeys);
             }
         });
     }
 
+    @Override
     public boolean execute(String sql, final int[] columnIndexes) throws SQLException {
         return StatementTracing.execute(realStatement, connectInfo, "execute", sql, new StatementTracing.Executable<Boolean>() {
+            @Override
             public Boolean exe(java.sql.Statement realStatement, String sql) throws SQLException {
                 return realStatement.execute(sql, columnIndexes);
             }
         });
     }
 
+    @Override
     public boolean execute(String sql, final String[] columnNames) throws SQLException {
         return StatementTracing.execute(realStatement, connectInfo, "execute", sql, new StatementTracing.Executable<Boolean>() {
+            @Override
             public Boolean exe(java.sql.Statement realStatement, String sql) throws SQLException {
                 return realStatement.execute(sql, columnNames);
             }
         });
     }
 
+    @Override
     public int getResultSetHoldability() throws SQLException {
         return realStatement.getResultSetHoldability();
     }
 
+    @Override
     public boolean isClosed() throws SQLException {
         return realStatement.isClosed();
     }
 
+    @Override
     public void setPoolable(boolean poolable) throws SQLException {
         realStatement.setPoolable(poolable);
     }
 
+    @Override
     public boolean isPoolable() throws SQLException {
         return realStatement.isPoolable();
     }
 
+    @Override
     public void closeOnCompletion() throws SQLException {
         realStatement.closeOnCompletion();
     }
 
+    @Override
     public boolean isCloseOnCompletion() throws SQLException {
         return realStatement.isCloseOnCompletion();
     }

apm-sniffer/apm-sdk-plugin/nutz-plugins/http-1.x-plugin/src/main/java/org/apache/skywalking/apm/plugin/nutz/http/sync/define/AbstractNutzHttpInstrumentation.java

@@ -73,5 +73,6 @@ public abstract class AbstractNutzHttpInstrumentation extends ClassInstanceMetho
         };
     }
 
+    @Override
     protected abstract ClassMatch enhanceClass();
 }

apm-sniffer/apm-sdk-plugin/nutz-plugins/http-1.x-plugin/src/main/java/org/apache/skywalking/apm/plugin/nutz/http/sync/define/NutzHttpFilePostSenderInstrumentation.java

@@ -23,6 +23,7 @@ import org.apache.skywalking.apm.agent.core.plugin.match.NameMatch;
 
 public class NutzHttpFilePostSenderInstrumentation extends AbstractNutzHttpInstrumentation {
 
+    @Override
     protected ClassMatch enhanceClass() {
         return NameMatch.byName("org.nutz.http.sender.FilePostSender");
     }

codeStyle.xml

@@ -12,6 +12,7 @@
     <option name="CLASS_NAMES_IN_JAVADOC" value="3" />
     <option name="CLASS_COUNT_TO_USE_IMPORT_ON_DEMAND" value="999" />
     <option name="NAMES_COUNT_TO_USE_IMPORT_ON_DEMAND" value="999" />
+    <option name="INSERT_OVERRIDE_ANNOTATION" value="true" />
     <option name="PACKAGES_TO_USE_IMPORT_ON_DEMAND">
       <value />
     </option>

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/metrics/PercentileMetrics.java

@@ -116,6 +116,7 @@ public abstract class PercentileMetrics extends Metrics implements MultiIntValue
         }
     }
 
+    @Override
     public int[] getValues() {
         return percentileValues.sortedValues(Comparator.comparingInt(Integer::parseInt))
                                .stream()

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/worker/MetricsStreamProcessor.java

@@ -79,6 +79,7 @@ public class MetricsStreamProcessor implements StreamProcessor<Metrics> {
         return PROCESSOR;
     }
 
+    @Override
     public void in(Metrics metrics) {
         MetricsAggregateWorker worker = entryWorkers.get(metrics.getClass());
         if (worker != null) {
@@ -93,6 +94,7 @@ public class MetricsStreamProcessor implements StreamProcessor<Metrics> {
      * @param stream             definition of the metrics class.
      * @param metricsClass       data type of the streaming calculation.
      */
+    @Override
     public void create(ModuleDefineHolder moduleDefineHolder, Stream stream, Class<? extends Metrics> metricsClass) throws StorageException {
         this.create(moduleDefineHolder, StreamDefinition.from(stream), metricsClass);
     }

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/worker/RecordStreamProcessor.java

@@ -46,6 +46,7 @@ public class RecordStreamProcessor implements StreamProcessor<Record> {
         return PROCESSOR;
     }
 
+    @Override
     public void in(Record record) {
         RecordPersistentWorker worker = workers.get(record.getClass());
         if (worker != null) {
@@ -53,6 +54,7 @@ public class RecordStreamProcessor implements StreamProcessor<Record> {
         }
     }
 
+    @Override
     @SuppressWarnings("unchecked")
     public void create(ModuleDefineHolder moduleDefineHolder, Stream stream, Class<? extends Record> recordClass) throws StorageException {
         if (DisableRegister.INSTANCE.include(stream.name())) {

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/worker/TopNStreamProcessor.java

@@ -63,6 +63,7 @@ public class TopNStreamProcessor implements StreamProcessor<TopN> {
         return PROCESSOR;
     }
 
+    @Override
     @SuppressWarnings("unchecked")
     public void create(ModuleDefineHolder moduleDefineHolder, Stream stream, Class<? extends TopN> topNClass) throws StorageException {
         if (DisableRegister.INSTANCE.include(stream.name())) {
@@ -88,6 +89,7 @@ public class TopNStreamProcessor implements StreamProcessor<TopN> {
         workers.put(topNClass, persistentWorker);
     }
 
+    @Override
     public void in(TopN topN) {
         TopNWorker worker = workers.get(topN.getClass());
         if (worker != null) {

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/storage/model/ModelInstaller.java

@@ -35,6 +35,7 @@ public abstract class ModelInstaller implements ModelCreator.CreatingListener {
     protected final Client client;
     private final ModuleManager moduleManager;
 
+    @Override
     public void whenCreating(Model model) throws StorageException {
         if (RunningMode.isNoInitMode()) {
             while (!isExists(model)) {

oap-server/server-library/library-server/src/main/java/org/apache/skywalking/oap/server/library/server/grpc/ssl/DynamicSslContext.java

@@ -50,6 +50,7 @@ public class DynamicSslContext extends AbstractSslContext {
         super(caFile);
     }
 
+    @Override
     protected void updateContext(String caFile) {
         try {
             setCtx(GrpcSslContexts.forClient().trustManager(Paths.get(caFile).toFile()).build());
@@ -58,6 +59,7 @@ public class DynamicSslContext extends AbstractSslContext {
         }
     }
 
+    @Override
     protected void updateContext(final String privateKeyFile, final String certChainFile) {
         try {
             setCtx(GrpcSslContexts

oap-server/server-library/library-server/src/main/java/org/apache/skywalking/oap/server/library/server/pool/CustomThreadFactory.java

@@ -33,6 +33,7 @@ public class CustomThreadFactory implements ThreadFactory {
         namePrefix = name + "-" + poolNumber.getAndIncrement() + "-thread-";
     }
 
+    @Override
     public Thread newThread(Runnable r) {
         Thread t = new Thread(group, r, namePrefix + threadNumber.getAndIncrement(), 0);
         if (t.isDaemon())

oap-server/server-library/library-server/src/main/java/org/apache/skywalking/oap/server/library/server/ssl/HttpDynamicSslContext.java

@@ -43,6 +43,7 @@ public class HttpDynamicSslContext extends AbstractSslContext {
         super(caFile);
     }
 
+    @Override
     protected void updateContext(String caFile) {
         try {
             setCtx(SslContextBuilder.forClient().trustManager(Paths.get(caFile).toFile()).build());
@@ -51,6 +52,7 @@ public class HttpDynamicSslContext extends AbstractSslContext {
         }
     }
 
+    @Override
     protected void updateContext(final String privateKeyFile, final String certChainFile) {
         try {
             setCtx(SslContextBuilder

oap-server/server-receiver-plugin/jaeger-receiver-plugin/src/main/java/org/apache/skywalking/aop/server/receiver/jaeger/JaegerGRPCHandler.java

@@ -46,6 +46,7 @@ public class JaegerGRPCHandler extends CollectorServiceGrpc.CollectorServiceImpl
         this.config = config;
     }
 
+    @Override
     public void postSpans(Collector.PostSpansRequest request,
                           StreamObserver<Collector.PostSpansResponse> responseObserver) {
 

oap-server/server-storage-plugin/storage-elasticsearch-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/elasticsearch/query/AlarmQueryEsDAO.java

@@ -42,6 +42,7 @@ public class AlarmQueryEsDAO extends EsDAO implements IAlarmQueryDAO {
         super(client);
     }
 
+    @Override
     public Alarms getAlarm(final Integer scopeId, final String keyword, final int limit, final int from,
         final long startTB, final long endTB) throws IOException {
         SearchSourceBuilder sourceBuilder = SearchSourceBuilder.searchSource();

oap-server/server-storage-plugin/storage-elasticsearch7-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/elasticsearch7/base/StorageEs7Installer.java

@@ -34,6 +34,7 @@ public class StorageEs7Installer extends StorageEsInstaller {
         super(client, moduleManager, config);
     }
 
+    @Override
     @SuppressWarnings("unchecked")
     protected Map<String, Object> createMapping(Model model) {
         Map<String, Object> mapping = super.createMapping(model);

oap-server/server-storage-plugin/storage-elasticsearch7-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/elasticsearch7/client/ElasticSearch7Client.java

@@ -102,6 +102,7 @@ public class ElasticSearch7Client extends ElasticSearchClient {
         }
     }
 
+    @Override
     public boolean createIndex(String indexName) throws IOException {
         indexName = formatIndexName(indexName);
 
@@ -111,6 +112,7 @@ public class ElasticSearch7Client extends ElasticSearchClient {
         return response.isAcknowledged();
     }
 
+    @Override
     public boolean createIndex(String indexName, Map<String, Object> settings,
                                Map<String, Object> mapping) throws IOException {
         indexName = formatIndexName(indexName);
@@ -141,6 +143,7 @@ public class ElasticSearch7Client extends ElasticSearchClient {
         return new ArrayList<>(alias.getAliases().keySet());
     }
 
+    @Override
     protected boolean deleteIndex(String indexName, boolean formatIndexName) throws IOException {
         if (formatIndexName) {
             indexName = formatIndexName(indexName);
@@ -151,12 +154,14 @@ public class ElasticSearch7Client extends ElasticSearchClient {
         return response.isAcknowledged();
     }
 
+    @Override
     public boolean isExistsIndex(String indexName) throws IOException {
         indexName = formatIndexName(indexName);
         GetIndexRequest request = new GetIndexRequest(indexName);
         return client.indices().exists(request, RequestOptions.DEFAULT);
     }
 
+    @Override
     public boolean isExistsTemplate(String indexName) throws IOException {
         indexName = formatIndexName(indexName);
 
@@ -165,6 +170,7 @@ public class ElasticSearch7Client extends ElasticSearchClient {
         return client.indices().existsTemplate(indexTemplatesExistRequest, RequestOptions.DEFAULT);
     }
 
+    @Override
     public boolean createTemplate(String indexName, Map<String, Object> settings,
                                   Map<String, Object> mapping) throws IOException {
         indexName = formatIndexName(indexName);
@@ -182,6 +188,7 @@ public class ElasticSearch7Client extends ElasticSearchClient {
         return acknowledgedResponse.isAcknowledged();
     }
 
+    @Override
     public boolean deleteTemplate(String indexName) throws IOException {
         indexName = formatIndexName(indexName);
 
@@ -209,6 +216,7 @@ public class ElasticSearch7Client extends ElasticSearchClient {
         }
     }
 
+    @Override
     public GetResponse get(String indexName, String id) throws IOException {
         indexName = formatIndexName(indexName);
         GetRequest request = new GetRequest(indexName, id);
@@ -222,6 +230,7 @@ public class ElasticSearch7Client extends ElasticSearchClient {
         }
     }
 
+    @Override
     public SearchResponse ids(String indexName, String[] ids) throws IOException {
         indexName = formatIndexName(indexName);
 
@@ -237,6 +246,7 @@ public class ElasticSearch7Client extends ElasticSearchClient {
         }
     }
 
+    @Override
     public void forceInsert(String indexName, String id, XContentBuilder source) throws IOException {
         IndexRequest request = (IndexRequest) prepareInsert(indexName, id, source);
         request.setRefreshPolicy(WriteRequest.RefreshPolicy.IMMEDIATE);
@@ -249,6 +259,7 @@ public class ElasticSearch7Client extends ElasticSearchClient {
         }
     }
 
+    @Override
     public void forceUpdate(String indexName, String id, XContentBuilder source) throws IOException {
         org.elasticsearch.action.update.UpdateRequest request = (org.elasticsearch.action.update.UpdateRequest) prepareUpdate(
             indexName, id, source);
@@ -262,16 +273,19 @@ public class ElasticSearch7Client extends ElasticSearchClient {
         }
     }
 
+    @Override
     public InsertRequest prepareInsert(String indexName, String id, XContentBuilder source) {
         indexName = formatIndexName(indexName);
         return new ElasticSearch7InsertRequest(indexName, id).source(source);
     }
 
+    @Override
     public UpdateRequest prepareUpdate(String indexName, String id, XContentBuilder source) {
         indexName = formatIndexName(indexName);
         return new ElasticSearch7UpdateRequest(indexName, id).doc(source);
     }
 
+    @Override
     public int delete(String indexName, String timeBucketColumnName, long endTimeBucket) throws IOException {
         indexName = formatIndexName(indexName);
 
@@ -286,6 +300,7 @@ public class ElasticSearch7Client extends ElasticSearchClient {
         return HttpStatus.SC_OK;
     }
 
+    @Override
     public void synchronousBulk(BulkRequest request) {
         request.timeout(TimeValue.timeValueMinutes(2));
         request.setRefreshPolicy(WriteRequest.RefreshPolicy.WAIT_UNTIL);
@@ -300,6 +315,7 @@ public class ElasticSearch7Client extends ElasticSearchClient {
         }
     }
 
+    @Override
     public BulkProcessor createBulkProcessor(int bulkActions, int flushInterval, int concurrentRequests) {
         BulkProcessor.Listener listener = createBulkListener();
 

oap-server/server-storage-plugin/storage-elasticsearch7-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/elasticsearch7/query/AlarmQueryEs7DAO.java

@@ -43,6 +43,7 @@ public class AlarmQueryEs7DAO extends EsDAO implements IAlarmQueryDAO {
         super(client);
     }
 
+    @Override
     public Alarms getAlarm(final Integer scopeId, final String keyword, final int limit, final int from,
         final long startTB, final long endTB) throws IOException {
         SearchSourceBuilder sourceBuilder = SearchSourceBuilder.searchSource();

oap-server/server-storage-plugin/storage-elasticsearch7-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/elasticsearch7/query/MetricsQueryEs7DAO.java

@@ -83,6 +83,7 @@ public class MetricsQueryEs7DAO extends MetricsQueryEsDAO {
         return defaultValue;
     }
 
+    @Override
     protected void functionAggregation(Function function, TermsAggregationBuilder parentAggBuilder, String valueCName) {
         switch (function) {
             case Avg:

oap-server/server-storage-plugin/storage-jdbc-hikaricp-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/jdbc/mysql/MySQLLogQueryDAO.java

@@ -35,6 +35,7 @@ public class MySQLLogQueryDAO extends H2LogQueryDAO {
         return "select count(1) total " + sql;
     }
 
+    @Override
     protected void buildLimit(StringBuilder sql, int from, int limit) {
         sql.append(" LIMIT ").append(from).append(", ").append(limit);
     }

oap-server/server-telemetry/telemetry-api/src/main/java/org/apache/skywalking/oap/server/telemetry/api/HealthCheckMetrics.java

@@ -34,10 +34,12 @@ public class HealthCheckMetrics implements HealthChecker {
         metrics.setValue(-1);
     }
 
+    @Override
     public void health() {
         metrics.setValue(0);
     }
 
+    @Override
     public void unHealth(Throwable t) {
         log.error("Health check fails", t);
         metrics.setValue(1);