谨以书为马
谨以书为马

泛型和反射——读《编写高质量代码：改善Java程序的151个建议》（七）

读书，收获，分享
建议后面的五角星仅代表笔者个人需要注意的程度。
Talk is cheap.Show me the code

建议93：Java的泛型是类型擦除的★☆☆☆☆

Java的泛型在编译期有效，在运行期被删除，也就是说所有的泛型参数类型在编译后都会被清除掉。

//下面这种方法的重载，编辑器会报错，提示方法冲突....
//'listMethod(List)' clashes with 'listMethod(List)'; both methods have same erasure
    public void listMethod(List stringList){
    }
    public void listMethod(List intList) {
    }

这就是Java泛型擦除引起的问题：在编译后所有的泛型类型都会做相应的转化。转换规则如下：

  • List、List、List擦除后的类型为List。
  • List[]擦除后的类型为List[]。
  • List、List擦除后的类型为List。
  • List擦除后为List。

Java之所以如此处理，有两个原因：

  • 避免JVM的大换血。C++的泛型生命期延续到了运行期，而Java是在编译器擦除掉的，如果JVM也把泛型类型延续到运行期，那么JVM就需要进行大量的重构工作了。
  • 版本兼容。在编译期擦除可以更好地支持原生类型（Raw Type），在Java 1.5或1.6平台上，即使声明一个List这样的原生类型也是可以正常编译通过的，只是会产生警告信息而已。

我们就可以解释类似如下的问题了：

  1. 泛型的class对象是相同的

    public static void main(String[] args) {  
    List ls = new ArrayList();  
    List li = new ArrayList();  
    System.out.println(ls.getClass() == li.getClass());  
    //运行结果：true
}

    每个类都有一个class属性，泛型化不会改变class属性的返回值

  2. 泛型数组初始化时不能声明泛型类型

    //如下代码编译时通不过：
List[] list = new List[];

    可以声明一个带有泛型参数的数组，但是不能初始化该数组，因为执行了类型擦除操作，List[]与List[]就是同一回事了，编译器拒绝如此声明。

  3. instanceof不允许存在泛型参数

    //以下代码不能通过编译，原因一样，泛型类型被擦除了：
List list = new ArrayList();  
System.out.println(list instanceof List)

    4. 建议94：不能初始化泛型参数和数组★☆☆☆☆

    示例如下：

    //这段代码是编译通不过的，因为编译器在编译时需要获得T类型，但泛型在编译期类型已经被擦除了
//所以new T()和new T[5]都会报错
public class Client {
    private T t = new T();
    private T[] tArray = new T[5];
    private List list = new ArrayList();
}

    在某些情况下，我们确实需要泛型数组，那该如何处理呢？代码如下：

    public class Client {
    //不在初始化，由构造函数初始化
    private T t ;
    private T[] tArray;
    private List list = new ArrayList();
    
    public Client() {
        try {
            Class tType = Class.forName("");
            t = (T) tType.newInstance();
            tArray = (T[]) Array.newInstance(tType,5);
        }catch (Exception e){
            e.printStackTrace();
        }

    }

    类的成员变量是在类初始化前初始化的，所以要求在初始化前它必须具有明确的类型，否则就只能声明，不能初始化。

    建议95：强制声明泛型的实际类型★☆☆☆☆

    示例：

    class ArrayUtils{
    //把一个变长参数转变为列表
    public  static  List asList(T...t){
        List list = new ArrayList();
        Collections.addAll(list, t);
        return list;
    }
}

public class Client {
    public static void main(String[] args) {
     //强制声明泛型类型
    //asList方法要求的是一个泛型参数，在输入前定义这是一个Integer类型的参数，当然，输出也是Integer类型的集合了
        List list = ArrayUtils.asList();
    }
}

    注意：无法从代码中推断出泛型类型的情况下，即可强制声明泛型类型。

    建议96：不同的场景使用不同的泛型通配符★★☆☆☆

    Java泛型支持通配符（Wildcard），可以单独使用一个“？”表示任意类，也可以使用extends关键字表示某一个类（接口）的子类型，还可以使用super关键字表示某一个类（接口）的父类型，但问题是什么时候该用extends，什么时候该用super呢？

    1. 泛型结构只参与“读”操作则限定上界（使用extends关键字）

         public static  void read(List list){
        for(E e:list){
            System.out.println(e.getClass());
            //业务逻辑处理
        }
    }

    2. 泛型结构只参与“写”操作则限定下界（使用super关键字）

          public static void write(List list) {
        list.add(123);
        list.add(3.14);
    }

    对于是要限定上界还是限定下界，JDK的Collections.copy方法是一个非常好的例子，它实现了把源列表中的所有元素拷贝到目标列表中对应的索引位置上，代码如下：

        //源列表是用来提供数据的，所以src变量需要限定上界，带有extends关键字。
    //目标列表是用来写入数据的，所以dest变量需要界定上界，带有super关键字。
    public static  void copy(List dest, List src) {
        int srcSize = src.size();
        if (srcSize > dest.size())
            throw new IndexOutOfBoundsException("Source does not fit in dest");

        if (srcSize < COPY_THRESHOLD ||
            (src instanceof RandomAccess && dest instanceof RandomAccess)) {
            for (int i=0; i di=dest.listIterator();
            ListIterator si=src.listIterator();
            for (int i=0; i

    如果一个泛型结构即用作“读”操作又用作“写”操作，那该如何进行限定呢？不限定，使用确定的泛型类型即可，如List。

    建议97：警惕泛型是不能协变和逆变的★★☆☆☆

    什么叫协变（covariance）和逆变（contravariance）？

    在编程语言的类型框架中，协变和逆变是指宽类型和窄类型在某种情况下（如参数、泛型、返回值）替换或交换的特性，简单地说，协变是用一个窄类型替换宽类型，而逆变则是用宽类型覆盖窄类型。

    泛型既不支持协变，也不支持逆变:

        public static void main(String[] args) {
        //数组支持协变
        Number[] n = new Integer[10];
        //编译不通过，泛型不支持协变
        List ln = new ArrayList();
        //报错:Type mismatch: cannot convert from ArrayList to List
    }

    1. 可以使用通配符（Wildcard）模拟协变，代码如下所示：

         //Number的子类型都可以是泛型参数类型
   List ln = new ArrayList();

    2. 可以使用super关键字来模拟逆变，代码如下所示：

         //Integer的父类型(包括Integer)都可以是泛型参数类型
  List  li = new ArrayList();
    泛型通配符的QA

    注意：Java的泛型是不支持协变和逆变的，只是能够实现协变和逆变。

    建议98：建议采用的顺序是List、List、List★★☆☆☆

    原因如下：

    1. List是确定的某一个类型

      List表示的是List集合中的元素都为T类型，具体类型在运行期决定；

      List表示的是任意类型，与List类似，

      而List则表示List集合中的所有元素为Object类型，因为Object是所有类的父类，所以List也可以容纳所有的类类型，

      从这一字面意义上分析，List更符合习惯：编码者知道它是某一个类型，只是在运行期才确定而已。

    2. List可以进行读写操作

      List可以进行如add、remove等操作，因为它的类型是固定的T类型，在编码期不需要进行任何的转型操作。

      List是只读类型的，不能进行增加、修改操作，因为编译器不知道List中容纳的是什么类型的元素，也就无法校验类型是否安全了，而且List读取出的元素都是Object类型的，需要主动转型，所以它经常用于泛型方法的返回值。注意，List虽然无法增加、修改元素，但是却可以删除元素，比如执行remove、clear等方法，那是因为它的删除动作与泛型类型无关。

      List也可以读写操作，但是它执行写入操作时需要向上转型（Up cast），在读取数据后需要向下转型（Downcast），而此时已经失去了泛型存在的意义了。

      建议99：严格限定泛型类型采用多重界限★★★☆☆

      比如在公交车费优惠系统中，对部分人员（如工资低于2500元的上班族并且是站立着的乘客）车费打8折，该如何实现呢？

      //职员
interface Staff{
    //工资
    public int getSalary();
}

//乘客
interface Passenger{
    //是否是站立状态
    public boolean isStanding();
}

class Me implements Staff,Passenger{
    public boolean isStanding(){
        return true;
    }

    public int getSalary() {
        return 2000;
    }
}

//使用多重限定
public class Client {
    //工资低于2500元的上斑族并且站立的乘客车票打8折
    public static  void discount(T t){
        if(t.getSalary()<2500 && t.isStanding()){
            System.out.println("恭喜你！您的车票打八折！");
        }
    }
    public static void main(String[] args) {
        discount(new Me());
    }
}

      在Java的泛型中，可以使用“&”符号关联多个上界并实现多个边界限定，而且只有上界才有此限定，下界没有多重限定的情况。

      使用多重边界可以很方便地解决问题，而且非常优雅，建议在开发中考虑使用多重限定

      建议100：数组的真实类型必须是泛型类型的子类型★★★☆☆

      期望输入的是一个泛型化的List，转化为泛型数组，代码如下：

      public class Client {
    public static  T[] toArray(List list) {
        T[] t = (T[]) new Object[list.size()];
        for (int i = 0, n = list.size(); i < n; i++) {
            t[i] = list.get(i);
        }
        return t;
    }

    public static void main(String[] args) {
        List list = Arrays.asList("A", "B");
        for (String str : toArray(list)) {//这一句报错，Object数组不能向下转型为String数组
            System.out.println(str);
        }
    }
}

      运行异常如下：

      Exception in thread "main" java.lang.ClassCastException: [Ljava.lang.Object; cannot be cast to [Ljava.lang.String;
    at com.jyswm.demo.Client.main(Client.java:17)

      因为泛型是类型擦除的，toArray方法经过编译后与如下代码相同：

          public static Object[] toArray(List list){
        //此处的强制类型没必要存在，只是为了保持与源代码对比
        Object[] t = (Object[])new Object[list.size()];
        for(int i=0,n=list.size();i

      那该如何解决呢？

      其实要想把一个Obejct数组转换为String数组，只要Object数组的实际类型（Actual Type）也是String就可以了，例如：

      public class Client {
    public static void main(String[] args) {
        //objArray的实际类型和表面类型都是String数组
        Object[] objArray = {"A","B"};
        //抛出ClassCastException
        String[] strArray = (String[])objArray;

        String[] ss = {"A","B"};
        //objs的真实类型是String数组，显示类型为Object数组
        Object[] objs = ss;
        //顺利转换为String数组
        String[] strs = (String[])objs;
    }
}

      如此，那就把泛型数组声明为泛型类的子类型吧！代码如下：

      public class Client {

    public static  T[] toArray(List list, Class tClass) {
        //声明并初始化一个T类型的数组
        //通过反射类Array声明了一个T类型的数组，
        //由于我们无法在运行期获得泛型类型的参数，因此就需要调用者主动传入T参数类型
        T[] t = (T[]) Array.newInstance(tClass, list.size());
        for(int i=0,n=list.size();i list = Arrays.asList("A", "B");
        for (String str : toArray(list,String.class)) {
            System.out.println(str);
        }
    }
}

      注意：当一个泛型类（特别是泛型集合）转变为泛型数组时，泛型数组的真实类型不能是泛型类型的父类型（比如顶层类Object），只能是泛型类型的子类型（当然包括自身类型），否则就会出现类型转换异常。

      建议101：注意Class类的特殊性★☆☆☆☆

      Java语言是先把Java源文件编译成后缀为class的字节码文件，然后再通过ClassLoader机制把这些类文件加载到内存中，最后生成实例执行的，这是Java处理的基本机制，但是加载到内存中的数据是如何描述一个类的呢？

      Java使用一个元类（MetaClass）来描述加载到内存中的类数据，这就是Class类，它是一个描述类的类对象。

      Class类特殊的地方：

      • 无构造函数。Java中的类一般都有构造函数，但是Class类却没有构造函数，不能实例化，Class对象是在加载类时由 Java 虚拟机通过调用类加载器中的defineClass方法自动构造的。

      • 可以描述基本类型。虽然8个基本类型在JVM中并不是一个对象，它们一般存在于栈内存中，但是Class类仍然可以描述它们，例如可以使用int.class表示int类型的类对象。

      • 其对象都是单例模式。一个Class的实例对象描述一个类，并且只描述一个类，反过来也成立，一个类只有一个Class实例对象，如下代码返回的结果都为true：

        public class Client {
    public static void main(String[] args) throws Exception {
        //类的属性class所引用的对象与实例对象的getClass返回值相同
        String.class.equals(new String().getClass());
        "ABC".getClass().equals(String.class);
        //class实例对象不区分泛型
        ArrayList.class.equals(new ArrayList().getClass());
    }
}

      建议102：适时选择getDeclared×××和get×××★☆☆☆☆

      Java的Class类提供了很多的getDeclared×××方法和get×××方法，如下：

      public static void main(String[] args) throws Exception {
        //方法名称
        String methodName = "doStuff";
        Method m1 = Foo.class.getDeclaredMethod(methodName);
        Method m2 = Foo.class.getMethod(methodName);
}

      getMethod方法获得的是所有public访问级别的方法，包括从父类继承的方法，而getDeclaredMethod获得是自身类的所有方法，包括公用（public）方法、私有（private）方法等，而且不受限于访问权限。

      其他的getDeclaredConstructors和getConstructors、getDeclaredFields和getFields等与此相似。

      建议103：反射访问属性或方法时将Accessible设置为true★★☆☆☆

      Java中通过反射执行一个方法的过程如下：获取一个方法对象，然后根据isAccessible返回值确定是否能够执行，如果返回值为false则需要调用setAccessible（true），最后再调用invoke执行方法。如下：

      Method method= ...;
        //检查是否可以访问
        if(!method.isAccessible()){
            method.setAccessible(true);
        }
        //执行方法
        method.invoke(obj, args);

      那为什么要这么写呢？

      首先，Accessible的属性并不是访问权限，而是指是否要更容易获得，是否进行安全检查。

      AccessibleObject类的源代码如下：

      //它提供了取消默认访问控制检查的功能
public class AccessibleObject implements AnnotatedElement {
      //定义反射的默认操作权限suppressAccessChecks
      static final private java.security.Permission ACCESS_PERMISSION =
        new ReflectPermission("suppressAccessChecks");
      //是否重置了安全检查，默认为false
      boolean override;
      //构造函数
      protected AccessibleObject() {}
      //是否可以快速获取，默认是不能
      public boolean isAccessible() {
        return override;
    }
}

      Accessible属性只是用来判断是否需要进行安全检查的，如果不需要则直接执行，这就可以大幅度的提升系统性能了(注意：取消了安全检查，也可以运行private方法、访问private属性的)。经过测试，在大量的反射情况下，设置Accessible为true可以提高性能20倍左右。

      建议104：使用forName动态加载类文件★★☆☆☆

      动态加载（Dynamic Loading）是指在程序运行时加载需要的类库文件。

      对Java程序来说，一般情况下，一个类文件在启动时或首次初始化时会被加载到内存中，而反射则可以在运行时再决定是否要加载一个类。

      比如从Web上接收一个String参数作为类名，然后在JVM中加载并初始化，这就是动态加载，此动态加载通常是通过Class.forName(String)实现的，只是为什么要使用forName方法动态加载一个类文件呢？

      因为我们不知道将要生成的实例对象是什么类型（如果知道就不用动态加载），而且方法和属性都不可访问。

      动态加载的意义在什么地方呢？示例如下：

      class Utils{
    //静态代码块
    static{
        System.out.println("Do Something.....");
    }
}
public class Client {
    public static void main(String[] args) throws ClassNotFoundException {
        //动态加载
        Class.forName("Utils");
        //此时输出了：Do Something.....
    }
}

      如上，并没有对Utils做任何初始化，只是通过forName方法加载了Utils类，但是却产生了一个Do Something的输出，这就是因为Utils类被加载后，JVM会自动初始化其static变量和static代码块，这是类加载机制所决定的。

      经典的应用：数据库驱动程序的加载片段

         //加载驱动
  Class.forName("com.mysql..jdbc.Driver");
  String url="jdbc:mysql://localhost:3306/db?user=&password=";
  Connection conn =DriverManager.getConnection(url);
  Statement stmt =conn.createStatement();

      Class.forName("com.mysql..jdbc.Driver");这一句的意义，示例如下：

      public class Driver extends NonRegisteringDriver implements java.sql.Driver {
   
    //静态代码块
    static {
        try {
            //把自己注册到DriverManager中
            DriverManager.registerDriver(new Driver());
        } catch (SQLException E) {
            //异常处理
            throw new RuntimeException("Can't register driver!");
        }
    }
    //构造函数
    public Driver() throws SQLException {
    }

}

      程序逻辑如下：当程序动态加载该驱动时，也就是执行到Class.forName("com.mysql.jdbc.Driver")时，Driver类会被加载到内存中，也就是把自己注册到DriverManager中。

      forName只是把一个类加载到内存中，并不保证由此产生一个实例对象，也不会执行任何方法，之所以会初始化static代码，那是由类加载机制所决定的，而不是forName方法决定的。也就是说，如果没有static属性或static代码块，forName就只是加载类，没有任何的执行行为。

      注意：forName只是加载类，并不执行任何代码。

      建议105：动态加载不适合数组★☆☆☆☆

      在Java中，数组是一个非常特殊的类，虽然它是一个类，但没有定义类路径。

      示例：

      public static void main(String[] args) throws ClassNotFoundException {
        String [] strs =  new String[10];
        Class.forName("java.lang.String[]");
}

      运行异常，如下：

      Exception in thread "main" java.lang.ClassNotFoundException: java/lang/String[]
    at java.lang.Class.forName0(Native Method)
    at java.lang.Class.forName(Class.java:186)

      因为编译器编译后为不同的数组类型生成不同的类，具体如下表所示：


      数组编译对应关系表

      所以动态加载一个对象数组只要加载编译后的数组对象就可以了，修改代码如下：

        //加载一个String数组
  Class.forName("[Ljava.lang.String;");
  //加载一个Long数组
  Class.forName("[J");

      但是这种操作没有什么意义，因为它不能生成一个数组对象，只是把一个String类型的数组类和long类型的数组类加载到了内存中，它没有定义数组的长度，在Java中数组是定长的，没有长度的数组是不允许存在的。

      因为数组的特殊性，所以Java专门定义了一个Array数组反射工具类来实现动态探知数组的功能，如下：

              // 动态创建数组
        String[] strs = (String[]) Array.newInstance(String.class, 8);
        // 创建一个多维数组
        int[][] ints = (int[][]) Array.newInstance(int.class, 2, 3);

      注意：通过反射操作数组使用Array类，不要采用通用的反射处理API。

      建议106：动态代理可以使代理模式更加灵活★★★☆☆

      Java的反射框架提供了动态代理（Dynamic Proxy）机制，允许在运行期对目标类生成代理，避免重复开发。

      首先，简单的静态代理实现示例如下：

      /**
 * 抽象角色-厨师
 */
interface Chef {
    
    /**
     * 提供饺子
     */
    String dumplings();

    /**
     * 提供面条
     */
    String noodles();

}

/**
 * 具体角色-厨师老张
 */
class RealChef implements Chef {

    @Override
    public String dumplings() {
        return "老张秘制酸汤水饺";
    }

    @Override
    public String noodles() {
        return "老张秘制兰州牛肉面";
    }
}

/**
 * 代理角色(proxy)-幸福餐厅
 */
public class HappyRestaurant implements Chef {

    /**
     * 要代理哪个实现类（要让哪个厨师做）
     */
    private Chef chef = null;

    /**
     * 默认被代理者（默认的厨师老张）
     */
    public HappyRestaurant() {
        chef = new RealChef();
    }

    /**
     * 通过构造函数传递被代理者（客户点名哪个厨师做）
     */
    public HappyRestaurant(Chef _chef) {
        chef = _chef;
    }

    @Override
    public String dumplings() {
        before();
        return chef.dumplings();
    }

    @Override
    public String noodles() {
        before();
        return chef.noodles();
    }

    /**
     * 预处理
     */
    private void before() {
        // 先收银
    }

}
    //调用
    public static void main(String[] args) {
        //来到幸福餐厅
        HappyRestaurant happyRestaurant = new HappyRestaurant();
        //点了一份饺子
        String food = happyRestaurant.dumplings();
        System.out.println(food);
        //得到：老张秘制酸汤水饺
    }

      代理："你去餐厅吃饭，并没有见给你真正做饭的厨师老张，而是由餐厅的服务人员端到你面前的。"

      改为动态代理示例如下：

      /**
 * 抽象角色-厨师
 */
interface Chef {
    
    /**
     * 提供饺子
     */
    String dumplings();

    /**
     * 提供面条
     */
    String noodles();

}

/**
 * 具体角色-厨师老张
 */
class RealChef implements Chef {

    @Override
    public String dumplings() {
        return "老张秘制酸汤水饺";
    }

    @Override
    public String noodles() {
        return "老张秘制兰州牛肉面";
    }
}

/**
 * 委托处理（不是具体的哪一家餐厅，而是美团了）
 */
public class ChefHandler implements InvocationHandler {

    /**
     * 被代理的对象（厨师）
     */
    private Chef chef;

    public ChefHandler(Chef _chef) {
        chef = _chef;
    }

    /**
     * 委托处理方法(点外卖)
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        // 预处理
        System.out.println("预处理...");
        //直接调用被代理的方法
        Object obj = method.invoke(chef, args);
        // 后处理
        System.out.println("后处理...");
        return obj;
    }

}

      注意看，这里没有了餐厅这个角色，取而代之的是ChefHandler作为主要的逻辑委托处理，其中invoke方法是接口InvocationHandler定义必须实现的，它完成了对真实方法的调用。

      InvocationHanlder接口：动态代理是根据被代理的接口生成所有方法的，也就是说给定一个（或多个）接口，动态代理会宣称“我已经实现该接口下的所有方法了”

      动态代理的场景类，代码如下：

          public static void main(String[] args) {
        //被代理类（想吃老张做的饭，确定目标）
        Chef chef = new RealChef();
        //代理实例的处理Handler（打开美团app搜索老张）
        InvocationHandler handler = new ChefHandler(chef);
        //当前加载器(美团开始搜索并加载老张的信息)
        ClassLoader classLoader = chef.getClass().getClassLoader();
        //动态代理（美团已经拥有了老张的所有能力，比如提供一份水饺等）
        Chef proxy = (Chef) Proxy.newProxyInstance(classLoader, chef.getClass().getInterfaces(), handler);
        //调用具体方法（点一份酸汤水饺）
        String food = proxy.dumplings();
        System.out.println(food);
        //得到: 老张秘制酸汤水饺
    }

      此时就实现了不用显式创建代理类即实现代理的功能。例如可以在被代理角色执行前进行权限判断，或者执行后进行数据校验。

      建议107：使用反射增加装饰模式的普适性★★★☆☆

      装饰模式（Decorator Pattern）的定义是 动态地给一个对象添加一些额外的职责。就增加功能来说，装饰模式相比于生成子类更为灵活，

      使用Java的动态代理也可以实现装饰模式的效果，而且其灵活性、适应性都会更强。

      装饰一只小老鼠，让它更强大，示例如下：

      interface Animal{
    public void doStuff();
}

class Rat implements Animal{
    @Override
    public void doStuff() {
        System.out.println("Jerry will play with Tom ......");
    }
    
}

/**
 * 使用装饰模式，给老鼠增加一些能力，比如飞行，钻地等能力
 */

//定义某种能力
interface Feature{
    //加载特性
    public void load();
}
//飞行能力
class FlyFeature implements Feature{

    @Override
    public void load() {
        System.out.println("增加一对翅膀...");
    }
}
//钻地能力
class DigFeature implements Feature{
    @Override
    public void load() {
        System.out.println("增加钻地能力...");
    }
    
}

/**
 * 要把这两种属性赋予到老鼠身上，那需要一个包装动作类
 */

class DecorateAnimal implements Animal {
    // 被包装的动物
    private Animal animal;
    // 使用哪一个包装器
    private Class clz;

    public DecorateAnimal(Animal _animal, Class _clz) {
        animal = _animal;
        clz = _clz;
    }

    @Override
    public void doStuff() {
        InvocationHandler handler = new InvocationHandler() {
            // 具体包装行为
            @Override
            public Object invoke(Object proxy, Method method, Object[] args)
                    throws Throwable {
                Object obj = null;
                if (Modifier.isPublic(method.getModifiers())) {
                    obj = method.invoke(clz.newInstance(), args);
                }
                animal.doStuff();
                return obj;
            }
        };
        //当前加载器
        ClassLoader cl = getClass().getClassLoader();
        //动态代理，又handler决定如何包装
        Feature proxy = (Feature) Proxy.newProxyInstance(cl, clz.getInterfaces(), handler);
        proxy.load();
    }

}

    /**
     * 注意看doStuff方法，
     * 一个装饰类型必然是抽象构建(Component)的子类型，它必须实现doStuff方法，此处的doStuff方法委托给了动态代理执行，
     * 并且在动态代理的控制器Handler中还设置了决定装饰方式和行为的条件(即代码中InvocationHandler匿名类中的if判断语句)，
     * 当然，此处也可以通过读取持久化数据的方式进行判断，这样就更加灵活了。
     */

/**
 * 客户端进行调
 */
public static void main(String[] args) {
        //定义Jerry这只老鼠
        Animal jerry = new Rat();
        //为Jerry增加飞行能力
        jerry = new DecorateAnimal(jerry, FlyFeature.class);
        //jerry增加挖掘能力
        jerry = new DecorateAnimal(jerry, DigFeature.class);
        //Jerry开始戏弄猫了
        jerry.doStuff();
}
//　装饰行为由动态代理实现，实现了对装饰类和被装饰类的完全解耦，提供了系统的扩展性。

      建议108：反射让模板方法模式更强大★★★☆☆

      模板方法模式（Template Method Pattern）的定义是：定义一个操作中的算法骨架，将一些步骤延迟到子类中，使子类不改变一个算法的结构即可重定义该算法的某些特定步骤。简单地说，就是父类定义抽象模板作为骨架，其中包括基本方法（是由子类实现的方法，并且在模板方法被调用）和模板方法（实现对基本方法的调度，完成固定的逻辑），它使用了简单的继承和覆写机制。

      普通模板方法，示例如下：

      public abstract class AbsPopulator {
    // 模板方法
    public final void dataInitialing() throws Exception {
        // 调用基本方法
        doInit();
    }

    // 基本方法
    protected abstract void doInit();
}

//子类实现
public class UserPopulator extends AbsPopulator{
    @Override
    protected void doInit() {
        //初始化用户表，如创建、加载数据等
    }

}

      改造，使用反射增强模板方法模式，使模板方法实现对一批固定的规则的基本方法的调用。如下：

      public abstract class AbsPopulator {
    // 模板方法
    public final void dataInitialing() throws Exception {
        // 获得所有的public方法
        Method[] methods = getClass().getMethods();
        for (Method m : methods) {
            // 判断是否是数据初始化方法
            if (isInitDataMethod(m)) {
                m.invoke(this);
            }
        }
    }

    // 判断是否是数据初始化方法，基本方法鉴定器
    private boolean isInitDataMethod(Method m) {
        return m.getName().startsWith("init")// init开始
                && Modifier.isPublic(m.getModifiers())// 公开方法
                && m.getReturnType().equals(Void.TYPE)// 返回值是void
                && !m.isVarArgs()// 输出参数为空
                && !Modifier.isAbstract(m.getModifiers());// 不能是抽象方法
    }
}

//子类实现
public class UserPopulator extends AbsPopulator {

    public void initUser() {
        /* 初始化用户表，如创建、加载数据等 */
    }

    public void initPassword() {
        /* 初始化密码 */
    }

    public void initJobs() {
        /* 初始化工作任务 */
    }
}

      在一般的模板方法模式中，抽象模板（这里是AbsPopulator类）需要定义一系列的基本方法，一般都是protected访问级别的，并且是抽象方法，这标志着子类必须实现这些基本方法，这对子类来说既是一个约束也是一个负担。但是使用了反射后，不需要定义任何抽象方法，只需定义一个基本方法鉴别器（例子中isInitDataMethod）即可加载符合规则的基本方法。鉴别器在此处的作用是鉴别子类方法中哪些是基本方法，模板方法（例子中的dataInitialing）则根据基本方法鉴别器返回的结果通过反射执行相应的方法。

      注意：决定使用模板方法模式时，请尝试使用反射方式实现，它会让你的程序更灵活、更强大。

      建议109：不需要太多关注反射效率★★☆☆☆

      反射的效率相对于正常的代码执行确实低很多（经过测试，相差15倍左右），但是它是一个非常有效的运行期工具类，只要代码结构清晰、可读性好那就先开发起来，等到进行性能测试时证明此处性能确实有问题时再修改也不迟（一般情况下反射并不是性能的终极杀手，而代码结构混乱、可读性差则很可能会埋下性能隐患）。

      对于反射效率问题，不要做任何的提前优化和预期，这基本上是杞人忧天，很少有项目是因为反射问题引起系统效率故障的，而且根据二八原则，80%的性能消耗在20%的代码上，这20%的代码才是我们关注的重点，不要单单把反射作为重点关注对象。

      注意：反射效率低是个真命题，但因为这一点而不使用它就是个假命题。

      你可能感兴趣的:(泛型和反射——读《编写高质量代码：改善Java程序的151个建议》（七）)

      • 斤斤计较的婚姻到底有多难？ 白心之岂必有为
        很多人私聊我会问到在哪个人群当中斤斤计较的人最多？我都会回答他，一般婚姻出现问题的斤斤计较的人士会非常多，以我多年经验，在婚姻落的一塌糊涂的人当中，斤斤计较的人数占比在20～30%以上，也就是说10个婚姻出现问题的斤斤计较的人有2-3个有多不减。在婚姻出问题当中，有大量的心理不平衡的、尖酸刻薄的怨妇。在婚姻中仅斤斤计较有两种类型：第一种是物质上的，另一种是精神上的。在物质与精神上抠门已经严重的影响
      • 情绪觉察日记第37天 露露_e800
        今天是家庭关系规划师的第二阶最后一天，慧萍老师帮我做了个案，帮我处理了埋在心底好多年的一份恐惧，并给了我深深的力量！这几天出来学习，爸妈过来婆家帮我带小孩，妈妈出于爱帮我收拾东西，并跟我先生和婆婆产生矛盾，妈妈觉得他们没有照顾好我…。今晚回家见到妈妈，我很欣赏她并赞扬她，妈妈说今晚要跟我睡我说好，当我们俩躺在床上准备睡觉的时候，我握着妈妈的手对她说:妈妈这几天辛苦你了，你看你多利害把我们的家收拾得
      • 芦花鞋一四 许叶晗
        又是在一个寒冷的夏日里，青铜和葵花决定今天一起去卖芦花鞋，奶奶亲手给他们做了一碗热乎乎的粥对他们说:“就靠你们两挣生活费了这碗粥赶紧趁热喝了吧！”于是青铜和葵花喝完了奶奶给她们做的粥，就准备去镇上卖卢花鞋，这回青铜和葵花穿着新的芦花鞋来到了镇上。青铜这回看到了很多人都在卖，用手势表达对葵花说:“这回有好多人在抢我们生意呢！我们必须得吆喝起来。”葵花点了点头。可是谁知他们也大声的叫，卖芦花喽！卖芦花
      • QQ群采集助手，精准引流必备神器 2401_87347160 其他经验分享
        功能概述微信群查找与筛选工具是一款专为微信用户设计的辅助工具，它通过关键词搜索功能，帮助用户快速找到相关的微信群，并提供筛选是否需要验证的群组的功能。主要功能关键词搜索：用户可以输入关键词，工具将自动查找包含该关键词的微信群。筛选功能：工具提供筛选机制，用户可以选择是否只显示需要验证或不需要验证的群组。精准引流：通过上述功能，用户可以更精准地找到目标群组，进行有效的引流操作。3.设备需求该工具可以
      • 关于沟通这件事，项目经理不需要每次都面对面进行 流程大师兄
        很多项目经理都会遇到这样的问题，项目中由于事情太多，根本没有足够的时间去召开会议，那在这种情况下如何去有效地管理项目中的利益相关者？当然，不建议电子邮件也不需要开会的话，建议可以采取下面几种方式来形成有效的沟通，这几种方式可以帮助你努力的通过各种办法来保持和各方面的联系。项目经理首先要问自己几个问题，项目中哪些利益相关者是必须要进行沟通的？可以列出项目中所有的利益相关者清单，同时也整理出项目中哪些
      • 机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习python
        一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
      • 铭刻于星（四十二） 随风至
        69夜晚，绍敏同学做完功课后，看了眼房外，没听到动静才敢从书包的夹层里拿出那个心形纸团。折痕压得很深，都有些旧了，想来是已经写好很久了。绍敏同学慢慢地、轻轻地捏开折叠处，待到全部拆开后，又反复抚平纸张，然后仔细地一字字默看。只是开头的三个字是第一次看到，让她心漏跳了几拍。“亲爱的绍敏：从四年级的时候，我就喜欢你了，但是我一直不敢说，怕影响你学习。六年级的时候听说有人跟你表白，你接受了，我很难过，但
      • 底层逆袭到底有多难，不甘平凡的你准备好了吗？让吴起给你说说 造命者说
        底层逆袭到底有多难，不甘平凡的你准备好了吗？让吴起给你说说我叫吴起，生于公元前440年的战国初期，正是群雄并起、天下纷争不断的时候。后人说我是军事家、政治家、改革家，是兵家代表人物。评价我一生历仕鲁、魏、楚三国，通晓兵家、法家、儒家三家思想，在内政军事上都有极高的成就。周安王二十一年（公元前381年），因变法得罪守旧贵族，被人乱箭射死。我出生在卫国一个“家累万金”的富有家庭，从年轻时候起就不甘平凡
      • 2020-01-25 晴岚85
        郑海燕坚持分享590天2020.1.24在生活中只存在两个问题。一个问题是：你知道想要达成的目标是什么，但却不知道如何才能达成；另一个问题是：你不知道你的目标是什么。前一个是行动的问题，后一个是结果的问题。通过制定具体的下一步行动，可以解决不知道如何开始行动的问题。而通过去想象结果，对结果做预估，可以解决找不着目标的问题。对于所有吸引我们注意力，想要完成的任务，你可以先想象一下，预期的结果究竟是什
      • 随笔 | 仙一般的灵气 海思沧海
        仙岛今天，我看了你全部，似乎已经进入你的世界我不知道，这是否是梦幻，还是你仙一般的灵气吸引了我也许每一个人都要有一份属于自己的追求，这样才能够符合人生的梦想，生活才能够充满着阳光与快乐我不知道，我为什么会这样的感叹，是在感叹自己的人生，还是感叹自己一直没有孜孜不倦的追求只感觉虚度了光阴，每天活在自己的梦中，活在一个不真实的世界是在逃避自己，还是在逃避周围的一切有时候我嘲笑自己，嘲笑自己如此的虚无，
      • 想家 爆米花机
        也许不同于大家对家乡的思念，我对家乡甚至是疯狂的不舍。还未踏出车站就感觉到幸福，我享受这里的夕阳、这里的浓烈柴火味、这里每一口家常菜。我是宅女，我贪恋家的安逸。刚刚踏出大学校门，初出茅庐，无法适应每年只能国庆和春节回家。我焦虑、失眠、无端发脾气，是无法适应工作的节奏，是无法接受我将一步步离开家乡的事实。我不想承认自己胸无大志，选择再次踏上征程。图片发自App
      • 【iOS】MVC设计模式 Magnetic_h iosmvc设计模式objective-c学习ui
        MVC前言如何设计一个程序的结构，这是一门专门的学问，叫做"架构模式"（architecturalpattern），属于编程的方法论。MVC模式就是架构模式的一种。它是Apple官方推荐的App开发架构，也是一般开发者最先遇到、最经典的架构。MVC各层controller层Controller/ViewController/VC（控制器）负责协调Model和View，处理大部分逻辑它将数据从Mod
      • OC语言多界面传值五大方式 Magnetic_h iosui学习objective-c开发语言
        前言在完成暑假仿写项目时，遇到了许多需要用到多界面传值的地方，这篇博客来总结一下比较常用的五种多界面传值的方式。属性传值属性传值一般用前一个界面向后一个界面传值，简单地说就是通过访问后一个视图控制器的属性来为它赋值，通过这个属性来做到从前一个界面向后一个界面传值。首先在后一个界面中定义属性@interfaceBViewController:UIViewController@propertyNSSt
      • 一百九十四章. 自相矛盾 巨木擎天
        唉！就这么一夜，林子感觉就像过了很多天似的，先是回了阳间家里，遇到了那么多不可思议的事情儿。特别是小伙伴们，第二次与自己见面时，僵硬的表情和恐怖的气氛，让自己如坐针毡，打从心眼里难受！还有东子，他现在还好吗？有没有被人欺负？护城河里的小鱼小虾们，还都在吗？水不会真的干枯了吧？那对相亲相爱漂亮的太平鸟儿，还好吧！春天了，到了做窝、下蛋、喂养小鸟宝宝的时候了，希望它们都能够平安啊！虽然没有看见家人，也
      • UI学习——cell的复用和自定义cell Magnetic_h ui学习
        目录cell的复用手动（非注册）自动（注册）自定义cellcell的复用在iOS开发中，单元格复用是一种提高表格（UITableView）和集合视图（UICollectionView）滚动性能的技术。当一个UITableViewCell或UICollectionViewCell首次需要显示时，如果没有可复用的单元格，则视图会创建一个新的单元格。一旦这个单元格滚动出屏幕，它就不会被销毁。相反，它被添
      • element实现动态路由+面包屑 软件技术NINI vue案例vue.js前端
        el-breadcrumb是ElementUI组件库中的一个面包屑导航组件，它用于显示当前页面的路径，帮助用户快速理解和导航到应用的各个部分。在Vue.js项目中，如果你已经安装了ElementUI，就可以很方便地使用el-breadcrumb组件。以下是一个基本的使用示例：安装ElementUI（如果你还没有安装的话）:你可以通过npm或yarn来安装ElementUI。bash复制代码npmi
      • 10月|愿你的青春不负梦想-读书笔记-01 Tracy的小书斋
        本书的作者是俞敏洪，大家都很熟悉他了吧。俞敏洪老师是我行业的领头羊吧，也是我事业上的偶像。本日摘录他书中第一章中的金句：『一个人如果什么目标都没有，就会浑浑噩噩，感觉生命中缺少能量。能给我们能量的，是对未来的期待。第一件事，我始终为了进步而努力。与其追寻全世界的骏马，不如种植丰美的草原，到时骏马自然会来。第二件事，我始终有阶段性的目标。什么东西能给我能量？答案是对未来的期待。』读到这里的时候，我便
      • C语言宏函数 南林yan C语言c语言
        一、什么是宏函数？通过宏定义的函数是宏函数。如下，编译器在预处理阶段会将Add(x,y)替换为((x)*(y))#defineAdd(x,y)((x)*(y))#defineAdd(x,y)((x)*(y))intmain(){inta=10;intb=20;intd=10;intc=Add(a+d,b)*2;cout<
      • 地推话术，如何应对地推过程中家长的拒绝 校师学
        相信校长们在做地推的时候经常遇到这种情况：市场专员反馈家长不接单，咨询师反馈难以邀约这些家长上门，校区地推疲软，招生难。为什么？仅从地推层面分析，一方面因为家长受到的信息轰炸越来越多，对信息越来越“免疫”；而另一方面地推人员的专业能力和营销话术没有提高，无法应对家长的拒绝，对有意向的家长也不知如何跟进，眼睁睁看着家长走远；对于家长的疑问，更不知道如何有技巧地回答，机会白白流失。由于回答没技巧和专业
      • 谢谢你们，爱你们！ 鹿游儿
        昨天家人去泡温泉，二个孩子也带着去，出发前一晚，匆匆下班，赶回家和孩子一起收拾。饭后，我拿出笔和本子（上次去澳门时做手帐的本子）写下了1\2\3\4\5\6\7\8\9,让后让小壹去思考，带什么出发去旅游呢？她在对应的数字旁边画上了，泳衣、泳圈、肖恩、内衣内裤、tapuy、拖鞋……画完后，就让她自己对着这个本子，将要带的，一一带上，没想到这次带的书还是这本《便便工厂》(晚上姑婆发照片过来，妹妹累得
      • C语言如何定义宏函数？ 小九格物 c语言
        在C语言中，宏函数是通过预处理器定义的，它在编译之前替换代码中的宏调用。宏函数可以模拟函数的行为，但它们不是真正的函数，因为它们在编译时不会进行类型检查，也不会分配存储空间。宏函数的定义通常使用#define指令，后面跟着宏的名称和参数列表，以及宏展开后的代码。宏函数的定义方式：1.基本宏函数：这是最简单的宏函数形式，它直接定义一个表达式。#defineSQUARE(x)((x)*(x))2.带参
      • 微服务下功能权限与数据权限的设计与实现 nbsaas-boot 微服务java架构
        在微服务架构下，系统的功能权限和数据权限控制显得尤为重要。随着系统规模的扩大和微服务数量的增加，如何保证不同用户和服务之间的访问权限准确、细粒度地控制，成为设计安全策略的关键。本文将讨论如何在微服务体系中设计和实现功能权限与数据权限控制。1.功能权限与数据权限的定义功能权限：指用户或系统角色对特定功能的访问权限。通常是某个用户角色能否执行某个操作，比如查看订单、创建订单、修改用户资料等。数据权限：
      • 理解Gunicorn：Python WSGI服务器的基石 范范0825 ipythonlinux运维
        理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
      • 小丽成长记（四十三） 玲玲54321
        小丽发现，即使她好不容易调整好自己的心态下一秒总会有不确定的伤脑筋的事出现，一个接一个的问题，人生就没有停下的时候，小问题不断出现。不过她今天看的书，她接受了人生就是不确定的，厉害的人就是不断创造确定性，在Ta的领域比别人多的确定性就能让自己脱颖而出，显示价值从而获得的比别人多的利益。正是这样的原因，因为从前修炼自己太少，使得她现在在人生道路上打怪起来困难重重，她似乎永远摆脱不了那种无力感，有种习
      • 学点心理知识，呵护孩子健康 静候花开_7090
        昨天听了华中师范大学教育管理学系副教授张玲老师的《哪里才是学生心理健康的最后庇护所，超越教育与技术的思考》的讲座。今天又重新学习了一遍，收获匪浅。张玲博士也注意到了当今社会上的孩子由于心理问题导致的自残、自杀及伤害他人等恶性事件。她向我们普及了一个重要的命题，她说心理健康的一些基本命题，我们与我们通常的一些教育命题是不同的，她还举了几个例子，让我们明白我们原来以为的健康并非心理学上的健康。比如如果
      • 2021年12月19日，春蕾教育集团团建活动感受——黄晓丹 黄错错加油
        感受:1.从陌生到熟悉的过程。游戏环节让我们在轻松的氛围中得到了锻炼，也增长了不少知识。2.游戏过程中，我们贡献的是个人力量，展现的是团队的力量。它磨合的往往不止是工作的熟悉，更是观念上契合度的贴近。3.这和工作是一样的道理。在各自的岗位上，每个人摆正自己的位置、各司其职充分发挥才能，并团结一致劲往一处使，才能实现最大的成功。新知:1.团队精神需要不断地创新。过去，人们把创新看作是冒风险，现在人们
      • Cell Insight | 单细胞测序技术又一新发现，可用于HIV-1和Mtb共感染个体诊断 尐尐呅
        结核病是艾滋病合并其他疾病中导致患者死亡的主要原因。其中结核病由结核分枝杆菌（Mycobacteriumtuberculosis,Mtb）感染引起，获得性免疫缺陷综合症（艾滋病）由人免疫缺陷病毒（Humanimmunodeficiencyvirustype1,HIV-1）感染引起。国家感染性疾病临床医学研究中心/深圳市第三人民医院张国良团队携手深圳华大生命科学研究院吴靓团队，共同研究得出单细胞测序
      • c++ 的iostream 和 c++的stdio的区别和联系 黄卷青灯77 c++算法开发语言iostreamstdio
        在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
      • 瑶池防线 谜影梦蝶
        冥华虽然逃过了影梦的军队，但他是一个忠臣，他选择上报战况。败给影梦后成逃兵，高层亡尔还活着，七重天失守......随便一条，即可处死冥华。冥华自然是知道以仙界高层的习性此信一发自己必死无疑，但他还选择上报实情，因为责任。同样此信送到仙宫后，知道此事的人，大多数人都认定冥华要完了，所以上到仙界高层，下到扫大街的，包括冥华自己，全都准备好迎接冥华之死。如果仙界现在还属于两方之争的话，冥华必死无疑。然而
      • 爬山后遗症 璃绛
        爬山，攀登，一步一步走向制高点，是一种挑战。成功抵达是一种无法言语的快乐，在山顶吹吹风，看看风景，这是从未有过的体验。然而，爬山一时爽，下山腿打颤，颠簸的路，一路向下走，腿部力量不够，走起来抖到不行，停不下来了！第二天必定腿疼，浑身酸痛，坐立难安！
      • 关于旗正规则引擎中的MD5加密问题 何必如此 jspMD5规则加密
        一般情况下，为了防止个人隐私的泄露，我们都会对用户登录密码进行加密，使数据库相应字段保存的是加密后的字符串，而非原始密码。 在旗正规则引擎中，通过外部调用，可以实现MD5的加密，具体步骤如下： 1.在对象库中选择外部调用，选择“com.flagleader.util.MD5”，在子选项中选择“com.flagleader.util.MD5.getMD5ofStr({arg1})”； 2.在规
      • 【Spark101】Scala Promise/Future在Spark中的应用 bit1129 Promise
        Promise和Future是Scala用于异步调用并实现结果汇集的并发原语，Scala的Future同JUC里面的Future接口含义相同，Promise理解起来就有些绕。等有时间了再仔细的研究下Promise和Future的语义以及应用场景，具体参见Scala在线文档：http://docs.scala-lang.org/sips/completed/futures-promises.html
      • spark sql 访问hive数据的配置详解 daizj spark sqlhivethriftserver
        spark sql 能够通过thriftserver 访问hive数据，默认spark编译的版本是不支持访问hive，因为hive依赖比较多，因此打的包中不包含hive和thriftserver,因此需要自己下载源码进行编译，将hive，thriftserver打包进去才能够访问，详细配置步骤如下：   1、下载源码   2、下载Maven,并配置 此配置简单，就略过
      • HTTP 协议通信 周凡杨 javahttpclienthttp通信
                                一：简介  HTTPCLIENT，通过JAVA基于HTTP协议进行点与点间的通信！     二： 代码举例      测试类： import java
      • java unix时间戳转换 g21121 java
        把java时间戳转换成unix时间戳： Timestamp appointTime=Timestamp.valueOf(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date())) SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd hh:m
      • web报表工具FineReport常用函数的用法总结（报表函数） 老A不折腾 web报表finereport总结
        说明：本次总结中，凡是以tableName或viewName作为参数因子的。函数在调用的时候均按照先从私有数据源中查找，然后再从公有数据源中查找的顺序。   CLASS CLASS(object):返回object对象的所属的类。   CNMONEY CNMONEY(number,unit)返回人民币大写。 number:需要转换的数值型的数。 unit:单位，
      • java jni调用c++ 代码 报错 墙头上一根草 javaC++jni
        # # A fatal error has been detected by the Java Runtime Environment: # #  EXCEPTION_ACCESS_VIOLATION (0xc0000005) at pc=0x00000000777c3290, pid=5632, tid=6656 # # JRE version: Java(TM) SE Ru
      • Spring中事件处理de小技巧 aijuans springSpring 教程Spring 实例Spring 入门Spring3
        Spring 中提供一些Aware相关de接口，BeanFactoryAware、 ApplicationContextAware、ResourceLoaderAware、ServletContextAware等等，其中最常用到de匙ApplicationContextAware.实现ApplicationContextAwaredeBean，在Bean被初始后，将会被注入 Applicati
      • linux shell ls脚本样例 annan211 linuxlinux ls源码linux 源码
        #! /bin/sh - #查找输入文件的路径 #在查找路径下寻找一个或多个原始文件或文件模式 # 查找路径由特定的环境变量所定义 #标准输出所产生的结果 通常是查找路径下找到的每个文件的第一个实体的完整路径 # 或是filename :not found 的标准错误输出。 #如果文件没有找到 则退出码为0 #否则 即为找不到的文件个数 #语法 pathfind [--
      • List,Set,Map遍历方式 (收集的资源,值得看一下) 百合不是茶 listsetMap遍历方式
        List特点：元素有放入顺序，元素可重复 Map特点：元素按键值对存储，无放入顺序 Set特点：元素无放入顺序，元素不可重复（注意：元素虽然无放入顺序，但是元素在set中的位置是有该元素的HashCode决定的，其位置其实是固定的） List接口有三个实现类：LinkedList，ArrayList，Vector LinkedList：底层基于链表实现，链表内存是散乱的，每一个元素存储本身
      • 解决SimpleDateFormat的线程不安全问题的方法 bijian1013 javathread线程安全
        在Java项目中，我们通常会自己写一个DateUtil类，处理日期和字符串的转换，如下所示： public class DateUtil01 { private SimpleDateFormat dateformat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); public void format(Date d
      • http请求测试实例（采用fastjson解析） bijian1013 http测试
                在实际开发中，我们经常会去做http请求的开发，下面则是如何请求的单元测试小实例，仅供参考。 import java.util.HashMap; import java.util.Map; import org.apache.commons.httpclient.HttpClient; import
      • 【RPC框架Hessian三】Hessian 异常处理 bit1129 hessian
        RPC异常处理概述   RPC异常处理指是，当客户端调用远端的服务，如果服务执行过程中发生异常，这个异常能否序列到客户端？   如果服务在执行过程中可能发生异常，那么在服务接口的声明中，就该声明该接口可能抛出的异常。   在Hessian中，服务器端发生异常，可以将异常信息从服务器端序列化到客户端，因为Exception本身是实现了Serializable的
      • 【日志分析】日志分析工具 bit1129 日志分析
        1. 网站日志实时分析工具 GoAccess http://www.vpsee.com/2014/02/a-real-time-web-log-analyzer-goaccess/ 2. 通过日志监控并收集 Java 应用程序性能数据(Perf4J) http://www.ibm.com/developerworks/cn/java/j-lo-logforperf/ 3.log.io 和
      • nginx优化加强战斗力及遇到的坑解决 ronin47 nginx 优化
        　　　先说遇到个坑，第一个是负载问题，这个问题与架构有关，由于我设计架构多了两层，结果导致会话负载只转向一个。解决这样的问题思路有两个：一是改变负载策略，二是更改架构设计。 　　　由于采用动静分离部署，而nginx又设计了静态，结果客户端去读nginx静态，访问量上来，页面加载很慢。解决：二者留其一。最好是保留apache服务器。   　　　来以下优化：   　　　
      • java-50-输入两棵二叉树A和B，判断树B是不是A的子结构 bylijinnan java
        思路来自： http://zhedahht.blog.163.com/blog/static/25411174201011445550396/ import ljn.help.*; public class HasSubtree { /**Q50. * 输入两棵二叉树A和B，判断树B是不是A的子结构。 例如，下图中的两棵树A和B，由于A中有一部分子树的结构和B是一
      • mongoDB 备份与恢复 开窍的石头 mongDB备份与恢复
        Mongodb导出与导入 1: 导入/导出可以操作的是本地的mongodb服务器,也可以是远程的. 所以,都有如下通用选项: -h host   主机 --port port    端口 -u username 用户名 -p passwd   密码 2: mongoexport 导出json格式的文件
      • [网络与通讯]椭圆轨道计算的一些问题 comsci 网络
             如果按照中国古代农历的历法，现在应该是某个季节的开始，但是由于农历历法是3000年前的天文观测数据，如果按照现在的天文学记录来进行修正的话，这个季节已经过去一段时间了。。。。。       也就是说，还要再等3000年。才有机会了，太阳系的行星的椭圆轨道受到外来天体的干扰，轨道次序发生了变
      • 软件专利如何申请 cuiyadll 软件专利申请
        软件技术可以申请软件著作权以保护软件源代码，也可以申请发明专利以保护软件流程中的步骤执行方式。专利保护的是软件解决问题的思想，而软件著作权保护的是软件代码（即软件思想的表达形式）。例如，离线传送文件，那发明专利保护是如何实现离线传送文件。基于相同的软件思想，但实现离线传送的程序代码有千千万万种，每种代码都可以享有各自的软件著作权。申请一个软件发明专利的代理费大概需要5000-8000申请发明专利可
      • Android学习笔记 darrenzhu android
        1.启动一个AVD 2.命令行运行adb shell可连接到AVD,这也就是命令行客户端 3.如何启动一个程序   am start -n package name/.activityName   am start -n com.example.helloworld/.MainActivity 启动Android设置工具的命令如下所示： # am start -
      • apache虚拟机配置，本地多域名访问本地网站 dcj3sjt126com apache
        现在假定你有两个目录，一个存在于 /htdocs/a，另一个存在于 /htdocs/b 。 现在你想要在本地测试的时候访问 www.freeman.com 对应的目录是 /xampp/htdocs/freeman ,访问 www.duchengjiu.com 对应的目录是 /htdocs/duchengjiu。 1、首先修改C盘WINDOWS\system32\drivers\etc目录下的
      • yii2 restful web服务[速率限制] dcj3sjt126com PHPyii2
        速率限制 为防止滥用，你应该考虑增加速率限制到您的API。 例如，您可以限制每个用户的API的使用是在10分钟内最多100次的API调用。 如果一个用户同一个时间段内太多的请求被接收， 将返回响应状态代码 429 (这意味着过多的请求)。 要启用速率限制, [[yii\web\User::identityClass|user identity class]] 应该实现 [[yii\filter
      • Hadoop2.5.2安装——单机模式 eksliang hadoophadoop单机部署
        转载请出自出处：http://eksliang.iteye.com/blog/2185414 一、概述        Hadoop有三种模式 单机模式、伪分布模式和完全分布模式，这里先简单介绍单机模式 ，默认情况下，Hadoop被配置成一个非分布式模式，独立运行JAVA进程，适合开始做调试工作。   二、下载地址 Hadoop 网址http:
      • LoadMoreListView+SwipeRefreshLayout（分页下拉）基本结构 gundumw100 android
        一切为了快速迭代 import java.util.ArrayList; import org.json.JSONObject; import android.animation.ObjectAnimator; import android.os.Bundle; import android.support.v4.widget.SwipeRefreshLayo
      • 三道简单的前端HTML/CSS题目 ini htmlWeb前端css题目
        使用CSS为多个网页进行相同风格的布局和外观设置时，为了方便对这些网页进行修改，最好使用（ ）。http://hovertree.com/shortanswer/bjae/7bd72acca3206862.htm   在HTML中加入<table style=”color:red; font-size:10pt”>，此为（ ）。http://hovertree.com/s
      • overrided方法编译错误 kane_xie override
        问题描述： 在实现类中的某一或某几个Override方法发生编译错误如下： Name clash: The method put(String) of type XXXServiceImpl has the same erasure as put(String) of type XXXService but does not override it   当去掉@Over
      • Java中使用代理IP获取网址内容（防IP被封，做数据爬虫） mcj8089 免费代理IP代理IP数据爬虫JAVA设置代理IP爬虫封IP
        推荐两个代理IP网站：   1. 全网代理IP：http://proxy.goubanjia.com/   2. 敲代码免费IP：http://ip.qiaodm.com/   Java语言有两种方式使用代理IP访问网址并获取内容，   方式一，设置System系统属性   // 设置代理IP System.getProper
      • Nodejs Express 报错之 listen EADDRINUSE qiaolevip 每天进步一点点学习永无止境nodejs纵观千象
        当你启动 nodejs服务报错： >node app Express server listening on port 80 events.js:85 throw er; // Unhandled 'error' event ^ Error: listen EADDRINUSE at exports._errnoException (
      • C++中三种new的用法 _荆棘鸟_ C++new
        转载自：http://news.ccidnet.com/art/32855/20100713/2114025_1.html 作者: mt 其一是new operator，也叫new表达式；其二是operator new，也叫new操作符。这两个英文名称起的也太绝了，很容易搞混，那就记中文名称吧。new表达式比较常见，也最常用，例如： string* ps = new string("
      • Ruby深入研究笔记1 wudixiaotie Ruby
        module是可以定义private方法的 module MTest def aaa puts "aaa" private_method end private def private_method puts "this is private_method" end end