利用反射，注解获取建表的sql

最新推荐文章于 2023-12-05 16:51:43 发布
最新推荐文章于 2023-12-05 16:51:43 发布
阅读量666 收藏 1
点赞数 2
分类专栏： Android 文章标签： sqlite 注解 反射
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/hanshengjian/article/details/60578632
版权
本文介绍了一种使用反射和注解对SQLite进行优化的方法，包括表构建SQL、ContentValues转换及从Cursor提取Bean等实用功能。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

前言：因为项目很老，还是用的原生sqlite,因为建表还是手动构建sql，cursor转bean或者list都不灵活，特此用反射和 注解做了优化处理

首先创建我们的标注，有TableName,Primary,NotNull,DefaultText,DefaultInt,DefaultDecimal,Autoincrement 

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface TableName {
    public String tableName();
}
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Primary {
}
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface NotNull {
}

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface DefaultText {
    public String defaultVal();
}

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface DefaultInt {
    public int defaultVal();
}

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface DefaultDecimal {
    public double defaultVal();
}
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Autoincrement {
}

然后创建我们的Book类

@TableName(tableName = "book")
public class Book {

    @DefaultText(defaultVal = "世纪创奇")
    private String name;

    @Primary
    @Autoincrement
    private int id;

    @DefaultInt(defaultVal = 2)
    private int pages;

    @DefaultDecimal(defaultVal = 2.24)
    private double price;

    @NotNull
    private String mem;

    private long date;


    public String getName() {
        return name;
    }

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

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public int getPages() {
        return pages;
    }

    public void setPages(int pages) {
        this.pages = pages;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public String getMem() {
        return mem;
    }

    public void setMem(String mem) {
        this.mem = mem;
    }

    public long getDate() {
        return date;
    }

    public void setDate(long date) {
        this.date = date;
    }
}

最后创建DbUtil类

public class DbUtil {
    private static final String TAG = "DbUtil";
    public static final Map<Class<?>, String> TYPES;

    static {
        //基本类型
        TYPES = new HashMap<Class<?>, String>();
        TYPES.put(byte.class, "BYTE");
        TYPES.put(boolean.class, "INTEGER");
        TYPES.put(short.class, "SHORT");
        TYPES.put(int.class, "INTEGER");
        TYPES.put(long.class, "LONG");
        TYPES.put(String.class, "TEXT");
        TYPES.put(byte[].class, "BLOB");
        TYPES.put(float.class, "FLOAT");
        TYPES.put(double.class, "DOUBLE");

        //包装类型
        TYPES.put(Byte.class, "BYTE");
        TYPES.put(Boolean.class, "INTEGER");
        TYPES.put(Short.class, "SHORT");
        TYPES.put(Integer.class, "INTEGER");
        TYPES.put(Long.class, "LONG");
        TYPES.put(String.class, "TEXT");
        TYPES.put(byte[].class, "BLOB");
        TYPES.put(Float.class, "FLOAT");
        TYPES.put(Double.class, "DOUBLE");

    }

    /**
     * 根据类结构构造表。
     */
    public static String getTableBuildingSQL(Class<?> clazz) {
        StringBuilder strBuilder = new StringBuilder("create table if not exists ");

        if (clazz.isAnnotationPresent(TableName.class)) {
            String tableName = clazz.getAnnotation(TableName.class).tableName();
            strBuilder.append(tableName);
        } else {
            strBuilder.append(clazz.getSimpleName());
        }
        strBuilder.append("(");
        // getDeclaredFields():获取该类文件中声明的字段
        // getFields():获取该类public声明字段
        Field[] arrField = clazz.getDeclaredFields();
        for (int i = arrField.length - 1; i >= 0; i--) {
            Field f = arrField[i];
            String type = TYPES.get(f.getType());
            if (type == null) {
                continue;
            } else {
                strBuilder.append(f.getName() + " " + type);

                if (f.isAnnotationPresent(Primary.class)) {
                    strBuilder.append(" primary key ");
                }
                if (f.isAnnotationPresent(DefaultText.class)) {
                    String val = f.getAnnotation(DefaultText.class).defaultVal();
                    strBuilder.append(" DEFAULT \"" + val + "\"");
                }
                if (f.isAnnotationPresent(DefaultInt.class)) {
                    Object val = f.getAnnotation(DefaultInt.class).defaultVal();
                    strBuilder.append(" DEFAULT " + val);
                }
                if (f.isAnnotationPresent(DefaultDecimal.class)) {
                    Object val = f.getAnnotation(DefaultDecimal.class).defaultVal();
                    strBuilder.append(" DEFAULT " + val);
                }
                if (f.isAnnotationPresent(Autoincrement.class)) {
                    strBuilder.append(" AUTOINCREMENT");
                }
                if(f.isAnnotationPresent(NotNull.class)){
                    strBuilder.append(" NOT NULL");
                }

                if (i > 0) {
                    strBuilder.append(",");
                }
            }
        }
        strBuilder.append(")");
        return strBuilder.toString();
    }

    /**
     * 构造插入Contvalues
     *
     * @param bean
     * @return
     */
    public static ContentValues translate2ContentValues(Object bean) {
        ContentValues cv = new ContentValues();
        Field[] arrField = bean.getClass().getDeclaredFields();
        try {
            for (Field f : arrField) {
                if (f.isAccessible() == false) {
                    f.setAccessible(true);
                }
                //排除自動增長的字段
                if (f.isAnnotationPresent(Autoincrement.class)) {
                    continue;
                }

                String name = f.getName();
                Object value = f.get(bean);

                if (value instanceof Byte) {
                    cv.put(name, (Byte) value);
                } else if (value instanceof Short) {
                    cv.put(name, (Short) value);
                } else if (value instanceof Integer) {
                    cv.put(name, (Integer) value);
                } else if (value instanceof Long) {
                    cv.put(name, (Long) value);
                } else if (value instanceof String) {
                    cv.put(name, (String) value);
                } else if (value instanceof byte[]) {
                    cv.put(name, (byte[]) value);
                } else if (value instanceof Boolean) {
                    cv.put(name, (Boolean) value);
                } else if (value instanceof Float) {
                    cv.put(name, (Float) value);
                } else if (value instanceof Double) {
                    cv.put(name, (Double) value);
                }
            }
        } catch (Exception e) {
            Log.e(TAG,"translate2ContentValues error:" + e.getMessage());
        }
        return cv;
    }

    /**
     * 从cursor中提取bean
     *
     * @param cursor
     * @param cls
     * @param <T>
     * @return
     */
    public static <T> T cursorToBean(Cursor cursor, Class<T> cls) {
        T bean = null;
        if (cursor != null && cursor.getCount() > 0) {
            Field[] fields = cls.getDeclaredFields();
            String[] columns = cursor.getColumnNames();
            try {
                while (cursor.moveToNext()) {
                    bean = cls.newInstance();
                    for (String column : columns) {
                        Field field = findFieldByName(fields, column);
                        if (field != null) {
                            String letter = column.substring(0, 1).toUpperCase();
                            String setter = "set" + letter + column.substring(1);
                            Method setMethod = cls.getMethod(setter, new Class[]{field.getType()});
                            setMethod.invoke(bean, getValueByField(cursor, column, field));
                        }

                    }
                }
            } catch (Exception e) {
                Log.e(TAG,"cursorToBean error:" + e.getMessage());
            }finally {
                cursor.close();
            }
        }
        return bean;
    }

    /**
     * 从cursor中提取bean 列表
     *
     * @param cursor
     * @param cls
     * @param <T>
     * @return
     */
    public static <T> List<T> cursorToBeans(Cursor cursor, Class<T> cls) {
        List<T> beans = new ArrayList<T>();
        if (cursor != null && cursor.getCount() > 0) {
            Field[] fields = cls.getDeclaredFields();
            String[] columns = cursor.getColumnNames();
            try {
                while (cursor.moveToNext()) {
                    T bean = cls.newInstance();
                    for (String column : columns) {
                        Field field = findFieldByName(fields, column);
                        if (field != null) {
                            String letter = column.substring(0, 1).toUpperCase();
                            String setter = "set" + letter + column.substring(1);
                            Method setMethod = cls.getMethod(setter, new Class[]{field.getType()});
                            setMethod.invoke(bean, getValueByField(cursor, column, field));
                        }

                    }
                    beans.add(bean);
                }
            } catch (Exception e) {
                Log.e(TAG,"cursorToBeans error:" + e.getMessage());
            }finally {
                cursor.close();
            }
        }
        return beans;
    }

    /**
     * 根据字段取出值
     *
     * @param cursor
     * @param columnName
     * @param field
     * @return
     */
    private static Object getValueByField(Cursor cursor, String columnName, Field field) {
        int index = cursor.getColumnIndex(columnName);
        if (index == -1) return null;// 如果不存在此列则返回null
        Class fieldClass = field.getType();
        // 根据属性类型从Cursor中获取值
        if (fieldClass == String.class) return cursor.getString(index);

        else if (fieldClass == int.class || fieldClass == Integer.class)
            return cursor.getInt(index);
        else if (fieldClass == Long.class || fieldClass == long.class)
            return cursor.getLong(index);

        else if (fieldClass == Double.class || fieldClass == double.class)
            return cursor.getDouble(index);

        else if (fieldClass == Float.class || fieldClass == float.class)
            return cursor.getFloat(index);

        else if (fieldClass == Short.class || fieldClass == short.class)
            return cursor.getShort(index);

        return null;
    }

    private static Field findFieldByName(Field[] fields, String name) {
        for (Field field : fields) {
            if (field.getName().equals(name)) {
                return field;
            }
        }
        return null;
    }
}

注释已经解释了每个方法的作用。demo可以通过这个链接下载，http://download.youkuaiyun.com/download/hanshengjian/9771886,这是个module

通过反射+注解生成sql语句
ImSe7en的博客
06-13 1215
通过反射+注解生成sql语句先写注释设置主键的注释import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target;@Target(ElementT
java反射与注解结合使用(根据传入对象输出查询sql)
weixin_44970764的博客
05-19 724
需求：创建一个与数据库表对应的实体类，通过使用注解的方式，来生成该实体类的查询sql语句 　　1.创建Table类注解，用于标明该类对应数据库的表名称 import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPo...
sqlite 注解获取建表sql
03-06
在sqlite 中，利用注解，反射，将jave bean转为建表语句。利用反射将cursor构建bean或者list.
反射 读取 注解 生成sql建表语句（demo）
多言数穷，不如守中。十语九中，未必称奇；一语未中，愆尤骈集。
03-21 2700
最后看了太多的源码，为了应聘做了复习，简单地做了一个demo（反射 读取 注解 生成sql建表语句（demo））。。 二话不说，贴代码 //两个注解类，Tab用于注解实体类，Col用于注解字段或方法 package cn.zw.annotation; import java.lang.annotation.Documented; import java.lang.annotation.E
java通过反射注解生成对应的sql语句
qq_45049981的博客
02-16 752
java通过反射注解生成对应的sql语句
SQLite注解实现JavaBean与建表SQL自动转换
总结一下，在SQLite中使用注解获取建表SQL，主要知识点包括理解Java注解的概念和使用方式，掌握Java反射API的使用，以及熟悉如何从数据库查询结果（cursor）构建Java对象。这些知识点结合在一起，能帮助开发者更高效...
利用注解，自动生成建表语句&转换查询结果
11-11
通过解析这些注解，我们可以编写一个工具类，遍历所有带有`@Table`注解的类，获取其字段上的`@Column`注解信息，然后构建并输出相应的SQL建表语句。 接下来，我们讨论如何使用注解自动转换查询结果。在ORM（Object-...
Java - 注解使用示例（解析注解生成创建SQL表语句）
用时间去蜕变
02-22 1988
当你觉得你用反射的情况非常少的时候，通常就是因为注解接触的少。 目的 使用注解来自动生成一个建数据库表的SQL命令。 注解 我们会创建如下的四个注解，用于进行数据库表，以及字段本身表述的注解。 @DBTable 代表数据库表，注解元素name表示表名； @Constraints 代表对数据表每一列的条件补充，有primaryKey是不是主键，默认false，allowNu...
Java反射注解封装JDBC模拟Hibernate框架功能
1. **自动建表和删表**：利用JDBC执行SQL语句，根据实体类的元数据动态创建或删除数据库表。通过注解来标注实体类，例如使用@TableName注解来指定表名。 2. **实体关系映射**：通过注解如@Entity和@Table来标识一个...
数据表创建及利用反射构建SQL语句、DataTable转实体
MaFeng
03-07 426
public class CombinBll { public void ImportExcel(string filePath) { #region 判断数据库中是否存在该表,没有则创建 var dbDataReader = App.DB.ExecuteReader("select * from sq...
利用JAVA注解与反射 - 实现SQL语句自动生成
08-04
利用JAVA注解实现SQL语句自动生成 编写对应Entity添加相关注解，并通过SqlUtil工具，传入相关参数生成SQL语句 例如：要生成对应数据库Person的SQL增删改查 SqlUtil.create(Person.class) SqlUtil.insert(Person.class) SqlUtil.insert(Person.class,person) SqlUtil.updateById(Person.class,person) SqlUtil.deleteById(Person.class,person) 开发工具IDEA，MAVEN项目
SQL注解实现机制，运用反射
m0_46106931的博客
03-30 2344
SQL 注解不适用于复杂情况，最好还是xml 获取sqlsession对象，拿到数据库配置 mapperInterface找到com.kuang.UserMapper(反射 得到包的全类名,通过类调用方法) methodCache 注解的核心就是反射 都有class这个模子了，自然找得到<select> 步骤： 1.注解在接口上实现 @Select("select * from user") List<User> getUs...
反射获取由注解信息构进行sql查询
mmxgl的博客
03-03 116
java注解学习笔记 一、jdk中的注解 jdk中都属于编译时注解，在编译前就会提示错误，总共有两种注解： @Deprecated 注解 表示方法已过时 @Suppress Warning注解：忽略由Deprecated注解造成的警告 二、java第三方注解 这里只列举了Spring和Mybatis中常见的几个 Spring中的注解 @Autowired注解 @Service注解 @Repository注解 Mybatis中的注解 @InsertProvider @UpdateProvider @Optio
使用反射动态生成sql语句
最新发布
ZHONGERMAOMAO的博客
12-05 962
对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
Java核心基础--基于注解&反射生成SQL语句
迪卡蛙的成长日记
05-14 432
Java核心基础--注解&反射一、注解1. 基本概念2. JDK内置标准注解3. 自定义注解3.1. @interface3.2. 元注解3.3. 注解参数4. 注解使用二、反射1. 获取 Class 对象的常用方式1.1. 类的 class 属性1.2. Object 对象 的 getClass() 方法1.3. 通过 Class 类的 forName() 方法（最常用）1.4. 通过 ClassLoader 类（不常用）2. 反射常用的API3. 实例三、手写简单查询SQL生成器1. 定义描述用
用反射动态生成SQL语句（增，查）
weixin_52104995的博客
12-04 302
反射是一种非常强大的功能，它可以帮助我们实现动态生成查询语句等灵活的数据库操作。在实际开发中，我们可以根据具体的需求来灵活地运用反射，从而提高开发效率，减少重复代码，使代码更加灵活和易于维护。
反射写SQL语句
xi5566的专栏
08-26 301
// 改 // public void update(Object o, String table) { // String id = ""; // String name = ""; // String id1 = ""; // String name1 = ""; // Class c = o.getClass(); // Field[] f = c.getDeclaredFie...
利用反射动态构成sql语句
mx5721的专栏
07-29 1195
class Program     {         static void Main(string[] args)         {             People p = new People();             Insert(p);         }         public static bool Insert(object obj)       
【Java反射&注解】通过反射和注解的方式根据Entity实体对象自动生成Sql语句
qq_43097201的博客
05-23 1071
首先我们定义好两个接口注解： 这个注解是用于定义在实体对象中用的 package homework4.exp3; import java.lang.annotation.Retention; import java.lang.annotation.Target; import static java.lang.annotation.ElementType.FIELD; import static java.lang.annotation.RetentionPolicy.RUNTIME; @Retent
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值