Java注解实践

标签 ： Java基础

注解对代码的语意没有直接影响, 他们只负责提供信息给相关的程序使用. 注解永远不会改变被注解代码的含义, 但可以通过工具对被注解的代码进行特殊处理.

JDK 基本Annotation

注解 说明
@Override 重写
@Deprecated 已过时
@SuppressWarnings(value = "unchecked") 压制编辑器警告
@SafeVarargs 修饰”堆污染”警告
@FunctionalInterface Java8特有的函数式接口
  • value特权

    如果使用注解时只需要为value成员变量指定值, 则使用注解时可以直接在该注解的括号中指定value值, 而无需使用name=value的形式. 如@SuppressWarnings("unchecked")(SuppressWarnings的各种参数

    请参考解析 @SuppressWarnings的各种参数)
  • 请坚持使用@Override注解: 如果在每个方法中使用Override注解来声明要覆盖父类声明, 编译器就可以替你防止大量的错误.

JDK 元Annotation

元Annotation用于修饰其他的Annotation定义.

元注解 释义
@Retention 注解保留策略
@Target 注解修饰目标
@Documented 注解文档提取
@Inherited 注解继承声明
  • @Retention 注解的保留策略
  1. @Documented
  2. @Retention(RetentionPolicy.RUNTIME)
  3. @Target(ElementType.ANNOTATION_TYPE)
  4. public @interface Retention {
  5.     RetentionPolicy value();
  6. }

value为SOURCE, CLASS, RUNTIME三值之一:

  1. public enum RetentionPolicy {
  2.     /**
  3.      * Annotations are to be discarded by the compiler.
  4.      */
  5.     SOURCE,
  7.     /**
  8.      * Annotations are to be recorded in the class file by the compiler
  9.      * but need not be retained by the VM at run time.  This is the default
  10.      * behavior.
  11.      */
  12.     CLASS,
  14.     /**
  15.      * Annotations are to be recorded in the class file by the compiler and
  16.      * retained by the VM at run time, so they may be read reflectively.
  17.      *
  18.      * @see java.lang.reflect.AnnotatedElement
  19.      */
  20.     RUNTIME
  21. }
  • @Target 指定Annotation可以放置的位置(被修饰的目标)
  1. @Documented
  2. @Retention(RetentionPolicy.RUNTIME)
  3. @Target(ElementType.ANNOTATION_TYPE)
  4. public @interface Target {
  5.     ElementType[] value();
  6. }
  1. public enum ElementType {
  2.     /** Class, interface (including annotation type), or enum declaration */
  3.     TYPE,
  5.     /** Field declaration (includes enum constants) */
  6.     FIELD,
  8.     /** Method declaration */
  9.     METHOD,
  11.     /** Parameter declaration */
  12.     PARAMETER,
  14.     /** Constructor declaration */
  15.     CONSTRUCTOR,
  17.     /** Local variable declaration */
  18.     LOCAL_VARIABLE,
  20.     /** Annotation type declaration */
  21.     ANNOTATION_TYPE,
  23.     /** Package declaration */
  24.     PACKAGE
  25. }
  • @Documented 指定被修饰的该Annotation可以被javadoc工具提取成文档.
  • @Inherited 指定被修饰的Annotation将具有继承性

    如果某个类使用@Xxx注解(该Annotation使用了@Inherited修饰)修饰, 则其子类自动被@Xxx注解修饰.

Annotation

  1. /**
  2.  * Created by jifang on 15/12/22.
  3.  */
  4. @Inherited
  5. @Target({ElementType.ANNOTATION_TYPE, ElementType.TYPE})
  6. @Retention(RetentionPolicy.RUNTIME)
  7. public @interface Testable {
  8. }

Client

  1. public class Client {
  3.     @Test
  4.     public void client(){
  5.         new SubClass();
  6.     }
  7. }
  9. @Testable
  10. class SupperClass{
  11. }
  13. class SubClass extends SupperClass{
  14.     public SubClass() {
  15.         for (Annotation annotation : SubClass.class.getAnnotations()){
  16.             System.out.println(annotation);
  17.         }
  18.     }
  19. }

自定义注解

  • 根据Annotation是否包含成员变量,可以把Annotation分为两类:

    • 标记Annotation: 没有成员变量的Annotation; 这种Annotation仅利用自身的存在与否来提供信息;
    • 元数据Annotation: 包含成员变量的Annotation; 它们可以接受(和提供)更多的元数据;
  • 定义新注解使用@interface关键字, 其定义过程与定义接口非常类似(见上面的@Testable), 需要注意的是:Annotation的成员变量在Annotation定义中是以无参的方法形式来声明的, 其方法名和返回值类型定义了该成员变量的名字和类型, 而且我们还可以使用default关键字为这个成员变量设定默认值.
  1. @Inherited
  2. @Retention(RetentionPolicy.RUNTIME)
  3. @Target({ElementType.METHOD, ElementType.TYPE})
  4. public @interface Tag {
  5.     String name() default "该叫啥才好呢?";
  7.     String description() default "这家伙很懒, 啥也没留下...";
  8. }
  • 自定义的Annotation继承了Annotation这个接口, 因此自定义注解中包含了Annotation接口中所有的方法;
  1. public interface Annotation {
  2.     /**
  3.      * @return true if the specified object represents an annotation
  4.      *     that is logically equivalent to this one, otherwise false
  5.      */
  6.     boolean equals(Object obj);
  8.     /**
  9.      * @return the hash code of this annotation
  10.      */
  11.     int hashCode();
  13.     /**
  14.      * @return a string representation of this annotation
  15.      */
  16.     String toString();
  18.     /**
  19.      * Returns the annotation type of this annotation.
  20.      */
  21.     Class<? extends Annotation> annotationType();
  22. }

提取Annotation信息

  • 使用Annotation修饰了类/方法/成员变量等之后,这些Annotation不会自己生效,必须由这些注解的开发者提供相应的工具来提取并处理Annotation信息(当然,只有当定义Annotation时使用了@Retention(RetentionPolicy.RUNTIME)修饰,JVM才会在装载class文件时提取保存在class文件中的Annotation,该Annotation才会在运行时可见,这样我们才能够解析).
  • Java使用Annotation接口来代表程序元素前面的注解, 用AnnotatedElement接口代表程序中可以接受注解的程序元素.像Class Constructor Field Method Package这些类都实现了AnnotatedElement接口.
  1. public final
  2.     class Class<T> implements java.io.Serializable,
  3.                               java.lang.reflect.GenericDeclaration,
  4.                               java.lang.reflect.Type,
  5.                               java.lang.reflect.AnnotatedElement {
  6. ...
  7. }
  1. public interface AnnotatedElement {
  2.     /**
  3.      * Returns true if an annotation for the specified type
  4.      * is present on this element, else false.  This method
  5.      * is designed primarily for convenient access to marker annotations.
  6.      */
  7.      boolean isAnnotationPresent(Class<? extends Annotation> annotationClass);
  9.    /**
  10.      * Returns this element's annotation for the specified type if
  11.      * such an annotation is present, else null.
  12.      */
  13.     <T extends Annotation> T getAnnotation(Class<T> annotationClass);
  15.     /**
  16.      * Returns all annotations present on this element.
  17.      */
  18.     Annotation[] getAnnotations();
  20.     /**
  21.      * Returns all annotations that are directly present on this
  22.      * element.  Unlike the other methods in this interface, this method
  23.      * ignores inherited annotations.  (Returns an array of length zero if
  24.      * no annotations are directly present on this element.)  The caller of
  25.      * this method is free to modify the returned array; it will have no
  26.      * effect on the arrays returned to other callers.
  27.      */
  28.     Annotation[] getDeclaredAnnotations();
  29. }

这样, 我们只需要获取到Class Method Filed等这些实现了AnnotatedElement接口的类实例, 就可以获取到我们想要的注解信息了.

  1. /**
  2.  * Created by jifang on 15/12/22.
  3.  */
  4. public class Client {
  6.     @Test
  7.     public void client() throws NoSuchMethodException {
  8.         Annotation[] annotations = this.getClass().getMethod("client").getAnnotations();
  9.         for (Annotation annotation : annotations) {
  10.             System.out.println(annotation.annotationType().getName());
  11.         }
  12.     }
  13. }

如果需要获取某个注解中的元数据,则需要强转成所需的注解类型,然后通过注解对象的抽象方法来访问这些元数据:

  1. @Tag(name = "client")
  2. public class Client {
  4.     @Test
  5.     public void client() throws NoSuchMethodException {
  6.         Annotation[] annotations = this.getClass().getAnnotations();
  7.         for (Annotation annotation : annotations) {
  8.             if (annotation instanceof Tag) {
  9.                 Tag tag = (Tag) annotation;
  10.                 System.out.println("name: " + tag.name());
  11.                 System.out.println("description: " + tag.description());
  12.             }
  13.         }
  14.     }
  15. }

模拟Junit框架

我们用@Testable标记哪些方法是可测试的, 只有被@Testable修饰的方法才可以被执行.

  1. /**
  2.  * Created by jifang on 15/12/27.
  3.  */
  4. @Inherited
  5. @Target(ElementType.METHOD)
  6. @Retention(RetentionPolicy.RUNTIME)
  7. public @interface Testable {
  8. }

如下定义TestCase测试用例定义了6个方法, 其中有4个被@Testable修饰了:

  1. public class TestCase {
  3.     @Testable
  4.     public void test1() {
  5.         System.out.println("test1");
  6.     }
  8.     public void test2() throws IOException {
  9.         System.out.println("test2");
  10.         throw new IOException("我test2出错啦...");
  11.     }
  13.     @Testable
  14.     public void test3() {
  15.         System.out.println("test3");
  16.         throw new RuntimeException("我test3出错啦...");
  17.     }
  19.     public void test4() {
  20.         System.out.println("test4");
  21.     }
  23.     @Testable
  24.     public void test5() {
  25.         System.out.println("test5");
  26.     }
  28.     @Testable
  29.     public void test6() {
  30.         System.out.println("test6");
  31.     }
  32. }

为了让程序中的这些注解起作用, 必须为这些注解提供一个注解处理工具.

  1. /**
  2.  * Created by jifang on 15/12/27.
  3.  */
  4. public class TestableProcessor {
  6.     public static void process(String clazz) throws ClassNotFoundException, IllegalAccessException, InstantiationException {
  7.         int passed = 0;
  8.         int failed = 0;
  9.         Object obj = Class.forName(clazz).newInstance();
  10.         for (Method method : Class.forName(clazz).getMethods()) {
  11.             if (method.isAnnotationPresent(Testable.class)) {
  12.                 try {
  13.                     method.invoke(obj);
  14.                     ++passed;
  15.                 } catch (IllegalAccessException | InvocationTargetException e) {
  16.                     System.out.println("method " + method.getName() + " execute error: < " + e.getCause() + " >");
  17.                     e.printStackTrace(System.out);
  18.                     ++failed;
  19.                 }
  20.             }
  21.         }
  23.         System.out.println("共运行" + (failed + passed) + "个方法, 成功" + passed + "个, 失败" + failed + "个");
  24.     }
  26.     public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
  27.         TestableProcessor.process("com.feiqing.annotation.TestCase");
  28.     }
  29. }

抛出特定异常

前面介绍的只是一个标记Annotation,程序通过判断Annotation是否存在来决定是否运行指定方法,现在我们要针对只在抛出特殊异常时才成功添加支持,这样就用到了具有成员变量的注解了:

  1. /**
  2.  * Created by jifang on 15/12/28.
  3.  */
  4. @Inherited
  5. @Target(ElementType.METHOD)
  6. @Retention(RetentionPolicy.RUNTIME)
  7. public @interface TestableException {
  8.     Class<? extends Throwable>[] value();
  9. }
  • TestCase
  1. /**
  2.  * Created by jifang on 15/12/27.
  3.  */
  4. public class TestCase {
  6.     public void test1() {
  7.         System.out.println("test1");
  8.     }
  10.     @TestableException(ArithmeticException.class)
  11.     public void test2() throws IOException {
  12.         int i = 1 / 0;
  13.         System.out.println(i);
  14.     }
  16.     @TestableException(ArithmeticException.class)
  17.     public void test3() {
  18.         System.out.println("test3");
  19.         throw new RuntimeException("我test3出错啦...");
  20.     }
  22.     public void test4() {
  23.         System.out.println("test4");
  24.     }
  26.     @TestableException({ArithmeticException.class, IOException.class})
  27.     public void test5() throws FileNotFoundException {
  28.         FileInputStream stream = new FileInputStream("xxxx");
  29.     }
  31.     @Testable
  32.     public void test6() {
  33.         System.out.println("test6");
  34.     }
  35. }
  • 注解处理器
  1. public class TestableExceptionProcessor {
  3.     public static void process(String clazz) throws ClassNotFoundException, IllegalAccessException, InstantiationException {
  4.         int passed = 0;
  5.         int failed = 0;
  6.         Object obj = Class.forName(clazz).newInstance();
  7.         for (Method method : Class.forName(clazz).getMethods()) {
  8.             if (method.isAnnotationPresent(TestableException.class)) {
  9.                 try {
  10.                     method.invoke(obj, null);
  11.                     // 没有抛出异常(失败)
  12.                     ++failed;
  13.                 } catch (InvocationTargetException e) {
  14.                     // 获取异常的引发原因
  15.                     Throwable cause = e.getCause();
  17.                     int oldPassed = passed;
  18.                     for (Class excType : method.getAnnotation(TestableException.class).value()) {
  19.                         // 是我们期望的异常类型之一(成功)
  20.                         if (excType.isInstance(cause)) {
  21.                             ++passed;
  22.                             break;
  23.                         }
  24.                     }
  25.                     // 并不是我们期望的异常类型(失败)
  26.                     if (oldPassed == passed) {
  27.                         ++failed;
  28.                         System.out.printf("Test <%s> failed <%s> %n", method, e);
  29.                     }
  30.                 }
  31.             }
  32.         }
  33.         System.out.println("共运行" + (failed + passed) + "个方法, 成功" + passed + "个, 失败" + failed + "个");
  34.     }
  36.     public static void main(String[] args) throws IllegalAccessException, InstantiationException, ClassNotFoundException {
  37.         process("com.feiqing.annotation.TestCase");
  38.     }
  39. }

注解添加监听器

下面通过使用Annotation简化事件编程, 在传统的代码中总是需要通过addActionListener方法来为事件源绑定事件监听器:

  1. /**
  2.  * Created by jifang on 15/12/27.
  3.  */
  4. public class SwingPro {
  5.     private JFrame mainWin = new JFrame("使用注解绑定事件监听器");
  7.     private JButton ok = new JButton("确定");
  8.     private JButton cancel = new JButton("取消");
  10.     public void init() {
  11.         JPanel jp = new JPanel();
  13.         // 为两个按钮设置监听事件
  14.         ok.addActionListener(new OkListener());
  15.         cancel.addActionListener(new CancelListener());
  17.         jp.add(ok);
  18.         jp.add(cancel);
  19.         mainWin.add(jp);
  20.         mainWin.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  21.         mainWin.pack();
  22.         mainWin.setVisible(true);
  23.     }
  25.     public static void main(String[] args) {
  26.         new SwingPro().init();
  27.     }
  28. }
  30. class OkListener implements ActionListener {
  32.     @Override
  33.     public void actionPerformed(ActionEvent e) {
  34.         JOptionPane.showMessageDialog(null, "你点击了确认按钮!");
  35.     }
  36. }
  38. class CancelListener implements ActionListener {
  40.     @Override
  41.     public void actionPerformed(ActionEvent e) {
  42.         JOptionPane.showMessageDialog(null, "你点击了取消按钮!");
  43.     }
  44. }

下面我们该用注解绑定监听器:

  • 首先, 我们需要自定义一个注解
  1. /**
  2.  * Created by jifang on 15/12/27.
  3.  */
  4. @Inherited
  5. @Target(ElementType.FIELD)
  6. @Retention(RetentionPolicy.RUNTIME)
  7. public @interface ActionListenerFor {
  8.     Class<? extends ActionListener> listener();
  9. }
  • 然后还要一个注解处理器
  1. /**
  2.  * Created by jifang on 15/12/27.
  3.  */
  4. public class ActionListenerInstaller {
  6.     public static void install(Object targetObject) throws IllegalAccessException, InstantiationException {
  7.         for (Field field : targetObject.getClass().getDeclaredFields()) {
  8.             // 如果该成员变量被ActionListenerFor标记了
  9.             if (field.isAnnotationPresent(ActionListenerFor.class)) {
  10.                 // 设置访问权限
  11.                 field.setAccessible(true);
  13.                 // 获取到成员变量的值
  14.                 AbstractButton targetButton = (AbstractButton) field.get(targetObject);
  16.                 // 获取到注解中的Listener
  17.                 Class<? extends ActionListener> listener = field.getAnnotation(ActionListenerFor.class).listener();
  19.                 // 添加到成员变量中
  20.                 targetButton.addActionListener(listener.newInstance());
  21.             }
  22.         }
  23.     }
  24. }
  • 主程序(注意注释处)
  1. public class SwingPro {
  3.     private JFrame mainWin = new JFrame("使用注解绑定事件监听器");
  5.     /**
  6.      * 使用注解设置Listener
  7.      */
  8.     @ActionListenerFor(listener = OkListener.class)
  9.     private JButton ok = new JButton("确定");
  11.     @ActionListenerFor(listener = CancelListener.class)
  12.     private JButton cancel = new JButton("取消");
  14.     public SwingPro init() {
  15.         JPanel jp = new JPanel();
  17.         // 使得注解生效
  18.         try {
  19.             ActionListenerInstaller.install(this);
  20.         } catch (IllegalAccessException | InstantiationException e) {
  21.             e.printStackTrace(System.out);
  22.         }
  24.         jp.add(ok);
  25.         jp.add(cancel);
  26.         mainWin.add(jp);
  27.         mainWin.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  28.         mainWin.pack();
  29.         mainWin.setVisible(true);
  31.         return this;
  32.     }
  34.     //下同
  35. }

重复注解

在Java5到Java7这段时间里, 同一个程序元素前只能使用一个相同类型的Annotation; 如果需要在同一个元素前使用多个相同的Annotation, 则必须使用Annotation容器(在Java8中, 对这种情况做了改善, 但其实也只是一种写法上的简化, 其本质还是一样的).由于在实际开发中,Java8还未大面积的使用, 因此在此只介绍Java7中重复注解定义与使用.

  • Table Annotation定义(代表数据库表)
  1. /**
  2.  * Created by jifang on 15/12/27.
  3.  */
  4. @Inherited
  5. @Retention(RetentionPolicy.RUNTIME)
  6. public @interface Table {
  8.     String name() default "表名是啥?";
  10.     String description() default "这家伙很懒, 啥也没留下...";
  11. }
  • Table 容器
  1. @Inherited
  2. @Retention(RetentionPolicy.RUNTIME)
  3. public @interface Tables {
  5.     Table[] value();
  6. }

注意: 容器注解的保留期必须比它所包含的注解的保留期更长, 否则JVM会丢弃容器, 相应的注解也就丢失了.

  • Client

    使用时需要用Table容器来盛装Table注解
  1. @Tables({
  2.         @Table(name = "t_user", description = "用户表"),
  3.         @Table(name = "t_feed", description = "动态表")
  4. })
  5. public class Client {
  7.     @Test
  8.     public void client() {
  9.         Tables tableArray = this.getClass().getAnnotation(Tables.class);
  10.         Table[] tables = tableArray.value();
  12.         for (Table table : tables) {
  13.             System.out.println(table.name() + " : " + table.description());
  14.         }
  15.     }
  16. }

在Java8中, 可以直接使用

  1. @Table(name = "t_user", description = "用户表")
  2. @Table(name = "t_feed", description = "动态表")

的形式来注解Client, 但@Tables还是需要开发者来写的, 由此可以看出, 重复注解只是一种简化写法, 这种写法只是一种假象: 多个重复注解其实会被作为容器注解的value成员.

参考:
Effective Java
疯狂Java讲义
Java核心技术

Java注解实践的更多相关文章

  1. Java注解实践--annotation学习三

    注解对代码的语意没有直接影响, 他们只负责提供信息给相关的程序使用. 注解永远不会改变被注解代码的含义, 但可以通过工具对被注解的代码进行特殊处理. JDK 基本Annotation 注解 说明 @O ...

  2. attilax.java 注解的本质and 使用最佳实践(3)O7

    attilax.java 注解的本质and 使用最佳实践(3)O7 1. 定义pojo 1 2. 建立注解By eclipse tps 1 3. 注解参数的可支持数据类型: 2 4. 注解处理器 2 ...

  3. 夯实Java基础系列15：Java注解简介和最佳实践

    Java注解简介 注解如同标签 Java 注解概述 什么是注解? 注解的用处 注解的原理 元注解 JDK里的注解 注解处理器实战 不同类型的注解 类注解 方法注解 参数注解 变量注解 Java注解相关 ...

  4. JAVA 注解的几大作用及使用方法详解

    JAVA 注解的几大作用及使用方法详解 (2013-01-22 15:13:04) 转载▼ 标签: java 注解 杂谈 分类: Java java 注解,从名字上看是注释,解释.但功能却不仅仅是注释 ...

  5. JAVA 注解的几大作用及使用方法详解【转】

    java 注解,从名字上看是注释,解释.但功能却不仅仅是注释那么简单.注解(Annotation) 为我们在代码中添加信息提供了一种形式化的方法,是我们可以在稍后 某个时刻方便地使用这些数据(通过 解 ...

  6. Java注解处理器（转）

    Java中的注解(Annotation)是一个很神奇的东西,特别现在有很多Android库都是使用注解的方式来实现的.一直想详细了解一下其中的原理.很有幸阅读到一篇详细解释编写注解处理器的文章.本文的 ...

  7. Java注解处理器使用详解

    在这篇文章中,我将阐述怎样写一个注解处理器(Annotation Processor).在这篇教程中,首先,我将向您解释什么是注解器,你可以利用这个强大的工具做什么以及不能做什么:然后,我将一步一步实 ...

  8. Java注解处理器

    Java注解处理器 2015/03/03 | 分类: 基础技术 | 0 条评论 | 标签: 注解 分享到:1 译文出处: race604.com   原文出处:Hannes Dorfmann Java ...

  9. 通过项目了解JAVA注解

    java自定义注解实践 ² 背景 最近在为公司的技术改造做准备,我设计了一个提高Web开发效率的技术框架,为了增加框架的友好性和易用性,决定采用注解来代替配置文件,于是我查询了很多的资料,进行整理和学 ...

随机推荐

  1. 学习KnockOut第三篇之List

    学习KnockOut第三篇之List 欲看此篇---------------------------------------------可先看上篇.          第一步,先搭建一个大概的框架起来 ...

  2. javacript中的mvc设计模式

    以下内容为原创翻译,翻译不对的地方还请原谅,凑合着看吧. 原文网址是: 来源:http://www.alexatnet.com/articles/model-view-controller-mvc-j ...

  3. C# type - IsPrimitive

    Type t = typeof(string); if (t.IsPrimitive)//not { Console.WriteLine("string is a Primitive&quo ...

  4. c++ 时间格式化

    struct tm tm_time; strptime(time.c_str(), "%Y%m%d %H:%M:%S", &tm_time); time_t tt = mk ...

  5. VMware ESXi虚拟机克隆及迁移

    使用ESXi经常会遇到这样的问题,我需要建立多个虚拟机,都是linux操作系统,难道必须一个一个安装吗? VMware ESXi.VMware vCenter Server 和 vSphere Cli ...

  6. VIM Taglist安装配置和使用

    问题描述:            VIM  Taglist安装于配置 问题解决:             (1)安装Taglist包      (2)解压taglist压缩包         (3)将 ...

  7. Leetcode#143 Reorder List

    原题地址 先把链表分割成前后两半,然后交叉融合 实践证明,凡是链表相关的题目,都应该当成工程类题目做,局部变量.功能函数什么的随便整,代码长了没关系,关键是清楚,不容易出错. 代码: ListNode ...

  8. struts.properties配置详解(转)

    Struts 2框架有两个核心配置文件,其中struts.xml文件主要负责管理应用中的Action映射,以及该Action包含的Result定义等.除此之 外,Struts 2框架还包含     s ...

  9. QualityCenter10+Oracle10.2.1.0.1+Win2003SP2企业版安装步骤

    HpQualityCenter10+Oracle10.2.1.0.1+Win2003SP2企业版安装步骤: 1.点击setup.exe,等待,知道出现以下界面,然后按“下一步” 2.出现如下界面,接受 ...

  10. Iptables DDOS/CC 自动屏蔽脚本

    Iptables DDOS/CC 自动屏蔽脚本 May 20, 2013 最近不停地被 CC (DDOS的一种)频繁干扰,分享一个 iptables 屏蔽 DDOS 的脚本.让 crond 每分钟运行 ...