从数据库表中提取的到数据(json)转为java对象的---泛型方法

总代码

    private <T> List<T> convertToEntityList(Class<T> clazz, JSONArray dataValues) {
        //创建返回对象集合
        List<T> tList = new ArrayList<>();
        // 遍历返回数据结构中的data.values
        dataValues.forEach(dataValue -> {
            // 单次循环的需要创建的对象
            T t = null;
            try {
                t = clazz.newInstance();
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
            // 反射获取所有的字段数组
            Field[] declaredFields = clazz.getDeclaredFields();
            // 遍历所有的对象属性
            for (Field declaredField : declaredFields) {
                // 如果当前属性被BusColumnField注解修饰
                if (declaredField.isAnnotationPresent(BusColumnField.class)) {
                    // 得到注解中的value值,其值对应着dataValues中的key列名
                    String field = declaredField.getAnnotation(BusColumnField.class).value();
                    // 将Object强转为JSONObject类型
                    JSONObject dataValueObject = (JSONObject) dataValue;
                    // 根据注解中的key取出返回数据中对应的数据
                    JSONObject fieldData = (JSONObject) dataValueObject.get(field);
                    // 如果取不到就继续判断下一个属性
                    if (fieldData == null) {
                        continue;
                    }
                    // 开启私有属性的可见性可操作性
                    declaredField.setAccessible(true);
                    try {
                        // 将code原值写入对应对象的对应属性中
                        declaredField.set(t, fieldData.get("code"));
                    } catch (IllegalAccessException e) {
                        e.printStackTrace();
                    }
                }
            }

            tList.add(t);
        });
        return tList;
    }

代码解读

 

Class对象

作用:在运行时,识别一个对象的类型和类的信息

使用场景:反射机制,允许在运行时发现和使用类型的信息,在java中用来表示运行时类型信息的对应类就是Class类

创建:

public class Test {
    public static void main(String[] args) throws ClassNotFoundException {
        //class对象创建的3种方法
        //1、类名.class
        Class<User> userClass1 = User.class;
        System.out.println(userClass1);
        //2、实例.getClass()
        User user = new User();
        Class userClass2 = user.getClass();
        System.out.println(userClass2);
        //3、Class.forName("类的全路径")
        Class<?> user1 = Class.forName("User");
        System.out.println(user1);
    }
}

class User{
    private String name;
    private String age;
}

常用的方法:

 //常用的方法
        //1、getName()
        String userClass1Name = user.getClass().getName();
        System.out.println(userClass1Name);
        //返回User
        //2、newInstance() --创建一个实例-调用默认构造器(无参数构造器)初始化新建对象。
        User user2 = user.getClass().newInstance();
        //3、getClassLoader()---返回该类的类加载器
        ClassLoader classLoader = user.getClass().getClassLoader();
        // 4、getComponentType()---返回表示数组组件类型的 Class
        // 5、getSuperclass()---返回表示此 Class 所表示的实体(类、接口、基本类型或 void)的超类的 Class。
        // 6、isArray()---判定此 Class 对象是否表示一个数组类。

自定义注解:

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
@Documented
public @interface BusColumnField {

    String value() default "";
}

我们的实体类的属性上 会加这个注解 

@Data
public class Station {

    /**
     * 厂站ID
     */
    @BusColumnField(value = "id")
    private String id;
    /**
     * 厂站名称
     */
    @BusColumnField(value = "name")
    private String name;
    /**
     * 电压等级ID
     */

    @BusColumnField(value = "volId")
    private String volId;
    /**
     * 厂站所属调度机构ID
     */

    @BusColumnField(value = "orgId")
    private String orgId;
}

 

参考:

(84条消息) Java——深入理解Class对象(一):什么是Class对象_一只野生饭卡丘的博客-CSDN博客_class撖寡情

(84条消息) Class类简介——详述创建对象的两种方式之newInstance()方法_曼舞精灵的博客-CSDN博客_newinstance()方法

  • 0
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
JavaJava 5引入的新特性,可以提高代码的可读性和安全性,降低代码的耦合度。是将类参数化,实现代码的通用性。 一、的基本语法 在声明类、接口、方法时可以使用的声明方式为在类名、接口名、方法名后面加上尖括号<>,括号可以声明一个或多个类参数,多个类参数之间用逗号隔开。例如: ```java public class GenericClass<T> { private T data; public T getData() { return data; } public void setData(T data) { this.data = data; } } public interface GenericInterface<T> { T getData(); void setData(T data); } public <T> void genericMethod(T data) { System.out.println(data); } ``` 其,`GenericClass`是一个类,`GenericInterface`是一个接口,`genericMethod`是一个方法。在这些声明,`<T>`就是类参数,可以用任何字母代替。 二、的使用 1. 类的使用 在使用类时,需要在类名后面加上尖括号<>,并在括号指定具体的类参数。例如: ```java GenericClass<String> gc = new GenericClass<>(); gc.setData("Hello World"); String data = gc.getData(); ``` 在这个例子,`GenericClass`被声明为一个类,`<String>`指定了具体的类参数,即`data`字段的类为`String`,`gc`对象被创建时没有指定类参数,因为编译器可以根据上下文自动推断出类参数为`String`。 2. 接口的使用 在使用接口时,也需要在接口名后面加上尖括号<>,并在括号指定具体的类参数。例如: ```java GenericInterface<String> gi = new GenericInterface<String>() { private String data; @Override public String getData() { return data; } @Override public void setData(String data) { this.data = data; } }; gi.setData("Hello World"); String data = gi.getData(); ``` 在这个例子,`GenericInterface`被声明为一个接口,`<String>`指定了具体的类参数,匿名内部类实现了该接口,并使用`String`作为类参数。 3. 方法的使用 在使用方法时,需要在方法名前面加上尖括号<>,并在括号指定具体的类参数。例如: ```java genericMethod("Hello World"); ``` 在这个例子,`genericMethod`被声明为一个方法,`<T>`指定了类参数,`T data`示一个类为`T`的参数,调用时可以传入任何类的参数。 三、的通配符 有时候,我们不知道的具体类,可以使用通配符`?`。通配符可以作为类参数出现在方法的参数类或返回类,但不能用于声明类或接口。例如: ```java public void printList(List<?> list) { for (Object obj : list) { System.out.print(obj + " "); } } ``` 在这个例子,`printList`方法的参数类为`List<?>`,示可以接受任何类的`List`,无论是`List<String>`还是`List<Integer>`都可以。在方法内部,使用`Object`类来遍历`List`的元素。 四、的继承 类和接口可以继承或实现其他类或接口,可以使用子类或实现类的类参数来替换父类或接口的类参数。例如: ```java public class SubGenericClass<T> extends GenericClass<T> {} public class SubGenericInterface<T> implements GenericInterface<T> { private T data; @Override public T getData() { return data; } @Override public void setData(T data) { this.data = data; } } ``` 在这个例子,`SubGenericClass`继承了`GenericClass`,并使用了相同的类参数`T`,`SubGenericInterface`实现了`GenericInterface`,也使用了相同的类参数`T`。 五、的限定 有时候,我们需要对的类参数进行限定,使其只能是某个类或接口的子类或实现类。可以使用`extends`关键字来限定类参数的上限,或使用`super`关键字来限定类参数的下限。例如: ```java public class GenericClass<T extends Number> { private T data; public T getData() { return data; } public void setData(T data) { this.data = data; } } public interface GenericInterface<T extends Comparable<T>> { T getData(); void setData(T data); } ``` 在这个例子,`GenericClass`的类参数`T`被限定为`Number`的子类,`GenericInterface`的类参数`T`被限定为实现了`Comparable`接口的类。 六、的擦除 在Java信息只存在于代码编译阶段,在编译后的字节码会被擦除。在运行时,无法获取的具体类。例如: ```java public void genericMethod(List<String> list) { System.out.println(list.getClass()); } ``` 在这个例子,`list`的类为`List<String>`,但是在运行时,`getClass`返回的类为`java.util.ArrayList`,因为信息已经被擦除了。 七、的类推断 在Java 7,引入了钻石操作符<>,可以使用它来省略类参数的声明。例如: ```java List<String> list = new ArrayList<>(); ``` 在这个例子,`ArrayList`的类参数可以被编译器自动推断为`String`。 八、总结 Java是一个强大的特性,可以提高代码的可读性和安全性,降低代码的耦合度。在使用时,需要注意它的基本语法、使用方法、通配符、继承、限定、擦除和类推断等问题。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值