J2ee程序中的面向对象设计（2）

九、使用反射（Using Reflection）

public void vetoableChange(PropertyChangeEvent e) throws PropertyVetoException {
    if (e.getPropertyName() .equals ("email")) {
        String email = (String) e.getNewValue();
        validateEmail (email, e);
    }
    ...
    } else if (e.getPropertyName() .equals ("age")) {
        int age = ((Integer) e.getNewValue()).intValue();
        validateAge(age, e);
    }

    ...
  }

  public AbstractVetoableChangeListener() throws SecurityException {
    Method[] methods = getClass() .getMethods();
    for (int i = 0; i < methods.length; i++) {
        if (methods[i] .getName() .startsWith(VALIDATE_METHOD_PREFIX) &&
            methods[i] .getParameterTypes() .length == 2 &&
                PropertyChangeEvent.class.isAssignableFrom(methods[i].
                    getParameterTypes() [1])) {
            // We've found a potential validator
            Class[] exceptions = methods[i] .getExceptionTypes();
            // We don't care about the return type, but we must ensure that
            // the method throws only one checked exception, PropertyVetoException
            if (exceptions.length == 1 &&
                    PropertyVetoException.class.isAssignableFrom(exceptions[0])) {
                // We have a valid validator method
                // Ensure it's accessible (for example, it might be a method on an
                // inner class)
                methods[i].setAccessible(true);
                String propertyName = Introspector.decapitalize(methods[i].getName().
                substring(VALIDATE_METHOD_PREFIX.length()));
                validationMethodHash.put(propertyName, methods[i]);
                System.out.println(methods[i] + " is validator for property " +
                    propertyName);
            }
        }
    }
  }

public final void vetoableChange(PropertyChangeEvent e)
        throws PropertyVetoException {

    Method m = (Method) validationMethodHash.get(e.getPropertyName());

    if (m != null) {
        try {
            Object val = e.getNewValue();
            m.invoke(this, new Object[] { val, e });

        } catch (IllegalAccessException ex) {
            System.out.println("WARNING: can't validate. " +
                "Validation method "' + m + "' isn't accessible");

        } catch (InvocationTargetException ex) {
            // We don't need to catch runtime exceptions
            if (ex.getTargetException() instanceof RuntimeException)
                throw (RuntimeException) ex.getTargetException();
            // Must be a PropertyVetoException if it's a checked exception
            PropertyVetoException pex = (PropertyVetoException)
                ex.getTargetException();
            throw pex;
        }
    }
  }

    public Object getObject(String classname, Class requiredType)
        throws FactoryException {
    try {
        Class clazz = Class.forName(classname);
        Object o = clazz.newInstance();
        if (! requiredType.isAssignableFrom(clazz))
            throw new FactoryException("Class "' + classname +
                                                     "' not of required type " + requiredType);
        // Configure the object...
        return o;
    } catch (ClassNotFoundException ex) {
        throw new FactoryException("Couldn't load class "' + classname + ""', ex);
    } catch (IllegalAccessException ex) {
        throw new FactoryException("Couldn't construct class "' + classname + "': is the no arg constructor public?", ex);
    } catch (InstantiationException ex) {
        throw new FactoryException("Couldn't construct class "' + classname +
                                     "': does it have a no arg constructor", ex);
    }
  }
使用：    MyInterface mo = (MyInterface)
    beanFactory.getObject("com.mycompany.mypackage.MyImplementation",
    MyInterface.class);  

十、使用JavaBean取得灵活性（Using JavaBeans to Achieve Flexibility）

1. PropertyEditor

2. PropertyChangeListener

3. VetoableChangeListener

4. Introspector