Liste değerlerinin dökümünü java'da standartlaştırılıyor

Question

Farklı modellere vermem gereken bir List<Node> JCR düğümüm var.

public List<MetaModel> castNodesToMetaModel(List<Node> nodes) { 
    List<MetaModel> models = new ArrayList<MetaModel>(); 
    for (Node node : nodes) { 
     models.add(new MetaModel(node, this)); 
    } 
    return models; 
} 
protected List<ArticleModel> castNodesToArticleModel(List<Node> nodes) { 
    List<ArticleModel> models = new ArrayList<ArticleModel>(); 
    for (Node node : nodes) { 
     models.add(new ArticleModel(node, this)); 
    } 
    return models; 
} 

Ben T türünü kullanarak bu casting standardize bir yolu var mı: Şu anda modellerin her biri ayrı fonksiyonu var?

protected <T> List<T> castNodes(T className, List<Node> nodes) { 
    ArrayList<T> list = new ArrayList<T>(); 

    for (Node node : nodes) { 
     list.add(new T(node, this)); // Cannot do: new T() 
    } 

    return list; 
} 

Answer 1

Evet, ancak imzanın biraz farklı olması gerekir.

import java.lang.reflect.Constructor; 

protected <T> List<T> castNodes(Class<T> clazz, List<Node>) { 
    List<T> list = new ArrayList<T>(); 
    try { 
     Constructor c = clazz.getConstructor(Node.class, getClass());   
     for (Node node : nodes) 
      list.add((T) c.newInstance(node, this)); 
    } catch (Exception e) { 
     // handle 
    } 
    return list; 
} 

Gerçekten yakalamak olmamalıdır genel Exception (daha spesifik türlerini yakalamak olmalıdır), ancak bu size bir fikir verir.

Answer 2

className parametresi aracılığıyla yönteme ilettiğiniz Class nesnesinin Class.new instance() yöntemini çağırabilirsiniz.

Answer 3

Kullanım Java 8 yaklaşım:

public static <T> List<T> mapNodes(List<Node> nodes, Function<Node, T> mapFunction) { 
     return nodes.stream().map(mapFunction).collect(Collectors.toList()); 
    } 

böyle çağrı it:

List<MetaModel> metaModels = mapNodes(nodeList, node -> new MetaModel(node, this)); 

List<ArticleModel> articleModels = mapNodes(nodeList, node -> new ArticleModel(node, this)); 

**** DÜZENLEME ****

Eğer java 7 ile sıkışmış ediyorsanız Yansıma yerine iyi bir nesne yönelimli yaklaşım öneririm. Bunun gibi: yansıma yaklaşımdan daha ayrıntılı, daha anlaşılır olsa sen dönüştürücüler her türlü uygulamaya ve olamaz çünkü

List<MetaModel> metaModels = convertNodes(nodeList, NodeConverterFactory.metaModel(this)); 

List<ArticleModel> articleModels = convertNodes(nodeList, NodeConverterFactory.articleModel(this)); 

, daha esnek (be: o zaman böyle kullanmanı

public static <T> List<T> convertNodes(List<Node> nodes, NodeConverter<T> converter) { 
    ArrayList<T> newNodes = new ArrayList<>(); 
    for (Node node : nodes) { 
     newNodes.add(converter.convert(node)); 
    } 
    return newNodes; 
} 

private static interface NodeConverter<T> { 

    public T convert(Node node); 
} 
public static class NodeConverterFactory { 

    public static final NodeConverter<MetaModel> metaModel(final Object thiz) { 
     return new NodeConverter<MetaModel>() { 
      @Override 
      public MetaModel convert(Node node) { 
       return new MetaModel(node, thiz); 
      } 
     }; 
    } 
    public static final NodeConverter<ArticleModel> articleModel(final Object thiz) { 
     return new NodeConverter<ArticleModel>() { 
      @Override 
      public ArticleModel convert(Node node) { 
       return new ArticleModel(node, thiz); 
      } 
     }; 
    } 
} 

bir tür kurucu ile sıkışmış) ve güvenli yazın. Yansıtma yaklaşımı, kullanılan kurucu/yöntem mevcut değilse, çalışma zamanı sorunlarına yol açabilir.