超类中的java静态工厂

我有一些java bean（它们有

private

属性和

getter/setter

方法）。并且可以在构造函数中使用

映射构建实例，如下所示：

public class A {
    private String name;
    private String gender;
    ...

    public A(Map<String, Object> m){
        BeanInfo beanInfo = Introspector.getBeanInfo(this.getClass());
        for(PropertyDescriptor pd: beanInfo.getPropertyDescriptors()){
            if(pd.getName().equals("class")){
                continue;
            }
            Method setter = pd.getWriteMethod();
            if(setter != null && m.get(pd.getName())!=null){
                setter.invoke(this,m.get(pd.getName()));
            }
        }
    }
    getter()/setter()
        ...

}

我觉得这很烦人，我想在父类
a
中构建一个静态工厂方法来一次性完成这项工作（可能在类
a
？）中有类似的代码）：

publicstaticfrommap（Map）{
returnnew//我真的不知道怎么写这个。
}

有人能给我一个关于如何编写这个工厂方法的提示吗？还是有可能？也许是一些通用的技巧？
您想要使用的方法不是最好的。事实上，如果将工厂方法放在超类中，那么它必须知道哪些是它的子类。因此，这种方法打破了抽象原则。例如，如果您赋予基类构建其子类的责任，那么每次添加新的子类型时都必须对其进行更改。此外，这违反了单一责任原则

可以使用工厂方法，但必须将其提取并放入专用类

必须在子类内部调用超类的构造函数，才能保证子类是超类的精化

最后，为了降低层次结构中类之间的耦合级别，我建议您仅使用抽象类型的继承，例如
abstract
类或
interface
s。
您想要使用的方法不是最好的方法。事实上，如果将工厂方法放在超类中，那么它必须知道哪些是它的子类。因此，这种方法打破了抽象原则。例如，如果您赋予基类构建其子类的责任，那么每次添加新的子类型时都必须对其进行更改。此外，这违反了单一责任原则

可以使用工厂方法，但必须将其提取并放入专用类

必须在子类内部调用超类的构造函数，才能保证子类是超类的精化

最后，为了降低层次结构中类之间的耦合级别，我建议您仅使用抽象类型的继承，例如
abstract
类或
interface
s。
您想要使用的方法不是最好的方法。事实上，如果将工厂方法放在超类中，那么它必须知道哪些是它的子类。因此，这种方法打破了抽象原则。例如，如果您赋予基类构建其子类的责任，那么每次添加新的子类型时都必须对其进行更改。此外，这违反了单一责任原则

可以使用工厂方法，但必须将其提取并放入专用类

必须在子类内部调用超类的构造函数，才能保证子类是超类的精化

最后，为了降低层次结构中类之间的耦合级别，我建议您仅使用抽象类型的继承，例如
abstract
类或
interface
s。
您想要使用的方法不是最好的方法。事实上，如果将工厂方法放在超类中，那么它必须知道哪些是它的子类。因此，这种方法打破了抽象原则。例如，如果您赋予基类构建其子类的责任，那么每次添加新的子类型时都必须对其进行更改。此外，这违反了单一责任原则

可以使用工厂方法，但必须将其提取并放入专用类

必须在子类内部调用超类的构造函数，才能保证子类是超类的精化

最后，为了降低层次结构中类之间的耦合级别，我建议您仅使用抽象类型的继承，例如
abstract
classes或
interface
s.
来回答您的问题，并在映射的“class”条目中假设完全限定的类名：

public static Object fromMap(Map<String, Object> map) throes Exception
    return Class.forName((String)map.get("class")).getConstructor(Map.class).newInstance(map);
}

publicstaticobjectfrommap（Map-Map）thres异常
返回Class.forName（（字符串）map.get（“Class”））.getConstructor（map.Class）.newInstance（map）；
}
要回答您的问题，并假设地图的“class”条目中有完全限定的类名：

public static Object fromMap(Map<String, Object> map) throes Exception
    return Class.forName((String)map.get("class")).getConstructor(Map.class).newInstance(map);
}

publicstaticobjectfrommap（Map-Map）thres异常
返回Class.forName（（字符串）map.get（“Class”））.getConstructor（map.Class）.newInstance（map）；
}
要回答您的问题，并假设地图的“class”条目中有完全限定的类名：

public static Object fromMap(Map<String, Object> map) throes Exception
    return Class.forName((String)map.get("class")).getConstructor(Map.class).newInstance(map);
}

publicstaticobjectfrommap（Map-Map）thres异常
返回Class.forName（（字符串）map.get（“Class”））.getConstructor（map.Class）.newInstance（map）；
}
要回答您的问题，并假设地图的“class”条目中有完全限定的类名：

public static Object fromMap(Map<String, Object> map) throes Exception
    return Class.forName((String)map.get("class")).getConstructor(Map.class).newInstance(map);
}

publicstaticobjectfrommap（Map-Map）thres异常
返回Class.forName（（字符串）map.get（“Class”））.getConstructor（map.Class）.newInstance（map）；
}
我更喜欢使用帮助器类，类似于以下内容：

package empty;

import java.beans.BeanInfo;
import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;

public class FromMap {

    public static class First {
        private String name;
        private int age;

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public int getAge() {
            return age;
        }

        public void setAge(int age) {
            this.age = age;
        }

        @Override public String toString() {
            return "First [name=" + name + ", age=" + age + "]";
        }

    }

    public static void main(String[] args) {
        Map<String, Object> v = new HashMap<String, Object>();
        v.put("name", "My Name");
        v.put("age", 100);
        try {
            First f = FromMap.fromMap(v, new First());
            System.out.println(f);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static <T> T fromMap(Map<String, Object> m, T t) throws IllegalAccessException, IllegalArgumentException,
            InvocationTargetException, IntrospectionException {
        BeanInfo beanInfo = Introspector.getBeanInfo(t.getClass());
        for (PropertyDescriptor pd : beanInfo.getPropertyDescriptors()) {
            if (pd.getName().equals("class")) {
                continue;
            }
            Method setter = pd.getWriteMethod();
            if (setter != null && m.get(pd.getName()) != null) {
                setter.invoke(t, m.get(pd.getName()));
            }
        }
        return t;
    }
}

包为空；
导入java.beans.BeanInfo；
导入java.beans.IntrospectionException；
导入java.beans.Introspector；
导入java.beans.PropertyDescriptor；
导入java.lang.reflect.InvocationTargetException；
导入java.lang.reflect.Method；
导入java.util.HashMap；
导入java.util.Map；
公共类FromMap{
公共静态类优先{
私有字符串名称；
私人互联网；
公共字符串getName
public class Animal<A extends Animal> {
  public A init(Map<String, Object> map) {
    ...
  }
}

public class Dog extends Animal<Dog> {
  public void bark() { ... }
}

static void test {
  new Dog().init(map).bark();
}

public class Animal {
    public static class Factory {
        public static <A extends Animal> A create(Class<A> animalClass, Map<String, Object> map) {
            try {
                A a = animalClass.newInstance();
                a.init(map);

                return a;
            } catch (InstantiationException e) {
            } catch (IllegalAccessException e) {
            }

            return null;
        }
    }

    void init(Map<String, Object> map) {
        // ...
    }
}

public class Dog extends Animal {
  public void bark() { ... }
}

static void test() {
    Animal.Factory.create(Dog.class, map).bark();
}