spring - java反射问题求解

Question

写一个方法：
public void (类，参数1，参数2) {

}
调用这个方法的类是各个不同的类，但是这些类中都有一个公共的属性isTm，想把这个函数定义成公共的。不同的类传进来，可以根据不同的类，来设置属性isTm的值，应该如何设计和实现？
举例如下：

package basic;

public class Test {

    public void updateIsTm(T<? extends Object> pojo) {
        if (null != pojo) {
            // TODO
            //如果传进来的是A a对象，就调用a.setIsTm()方法，修改值。 
            //如果传进来的是B b对象，就调用b.setIsTm()方法，修改值。
        }
    }
}

 //类A和类B有公共的属性isTm
     
    class A {
    
        String a;
        String isTm;
    
        public String getIsTm() {
            return isTm;
        }
    
        public void setIsTm(String isTm) {
            this.isTm = isTm;
        }
    }
    
    class B {
    
        String b;
        String isTm;
    
        public String getIsTm() {
            return isTm;
        }
    
        public void setIsTm(String isTm) {
            this.isTm = isTm;
        }
    }

谢谢~~

Answer 1

Concevez une interface pour que toutes les classes qui souhaitent appeler cette fonction implémentent cette interface

interface IHaveTm {
    void setIsTm(String isTm);
    String getIsTm();
}

public void <T extends IHaveTm> updateIsTm(T t, ...) {
    t.setIsTm(...)
}

Supplément :
Si vous ne modifiez pas la classe qui appelle cette fonction et effectuez une conception non intrusive, vous ne pourrez probablement utiliser que la réflexion

public void updateIsTm(Object obj, ...) throws Exception {
    Method m = obj.getClass().getDeclaredMethod("setIsTm", String.class);
    if (m != null) {
        m.invoke(obj, ...);
    }
}

Dans ce cas, vous devez vous fier à l'accord pour assurer la sécurité de l'appel. Ceci n'est pas recommandé

.

Answer 2

public class Main {

    public static void main(String[] args) {
        setIsTm(new A(), "haha");
        setIsTm(new B(), "haha again");
    }
    
    public static void setIsTm(TMSetable t, String var1) {
        t.setIsTm(var1);
    }
}

interface TMSetable {
    public void setIsTm(String isTm);
}

class A implements TMSetable {

    private String isTm;
    
    /* 
     * @see io.beansoft.netty.netty4.bootstrap.TMSetable#setIsTm(java.lang.String)
     */
    @Override
    public void setIsTm(String isTm) {
        this.isTm = isTm;
        System.out.println("A is setting isTm=" + isTm);
    }
    
}

class B implements TMSetable {
    
    private String isTm;
    /* 
     * @see io.beansoft.netty.netty4.bootstrap.TMSetable#setIsTm(java.lang.String)
     */
    @Override
    public void setIsTm(String isTm) {
        this.isTm = isTm;
        System.out.println("B is setting isTm=" + isTm);
    }
}

Résultat de sortie :

A règle isTm=haha
B règle à nouveau isTm=haha

À en juger par le titre, je ne vois pas la nécessité d’un design générique.

Answer 3

Du point de vue de la conception, il est préférable de concevoir une interface ou une classe abstraite pour abstraire l'attribut isTm.

Mais si vous ne pouvez plus modifier ces classes et qu'elles n'héritent pas ou n'implémentent pas une classe ou une interface parent commune, alors vous ne pouvez utiliser que la réflexion.

Mais utiliser la réflexion rendra le code très laid, et il sera difficile de trouver des problèmes s'il n'est pas bien utilisé, c'est un comportement de champ de mines.