MySQL使用的封装工具（Java）

在写Java项目时，经常要使用数据库，每次写数据库操作都很繁琐，于是我就想在网上找找有没有大神封装好的工具类，发现找不到满意的，最后就自己写了一份比较简单的封装，以下是使用到的类：

下面开始贴代码

用法

HG.getInstance().***

HG.java

这个类主要是做单例模式的：

/**
 * HG MySql工具类
 * 
 * @author HG
 *
 */
public class HG {

    /** 工具类实例 **/
    private static HGBuilder builder = null;

    /** 在用户调用数据库操作前先初始化数据表 **/
    static {
        HGConfig.initTable();
    }

    /**
     * 获取工具类实例
     * 
     * @return
     */
    public static HGBuilder getInstance() {

        if (builder == null) {
            builder = new HGBuilder();
        }

        return builder;
    }

}

HGConfig.java

这个类是一些配置信息，其他配置修改一次即可，如果需要自动创建数据表则在initTable()方法中添加相应语句即可：

/**
 * 配置信息
 * 
 * @author HG
 *
 */
public class HGConfig {

    /** 数据库名 **/
    public static final String DBNAME = "jdbc_demo";
    /** 数据库管理账号 **/
    public static final String USERNAME = "123456";
    /** 数据库管理密码 **/
    public static final String PASSWORD = "123456";
    /** 驱动类名 **/
    public static final String DRIVER_CLASS = "com.mysql.jdbc.Driver";
    /** IP地址 **/
    public static final String IP = "localhost";
    /** 端口号 **/
    public static final String PORT = "";

    /** 数据库连接语句 **/
    public static final String CONNECTION = "jdbc:mysql://" + IP + PORT + "/" + DBNAME + "?user=" + USERNAME
        + "&password=" + PASSWORD + "&characterEncoding=utf-8";

    /**
     * 初始化数据表，用户在此配置需要初始化的表
     */
    public static void initTable() {

        HG.getInstance().initTable(User.class);
        HG.getInstance().initTable(Fish.class);
    }

}

IHGBuilder.java

这是一个接口，规定数据库有哪些操作：

import java.util.List;

/**
 * HG工具模型接口
 * 
 * @author HG
 *
 */
public interface IHGBuilder {

    /**
     * 查询所有数据
     * 
     * @param clazz
     * @return
     */
    public <T> List<T> findAll(Class<T> clazz);

    /**
     * 按条件 查询所有数据
     * 
     * @param clazz
     * @param builder
     * @return
     */
    public <T> List<T> findAll(Class<T> clazz, WhereBuilder builder);

    /**
     * 查询第一条数据
     * 
     * @param clazz
     * @return
     */
    public <T> T findFirst(Class<T> clazz);

    /**
     * 按条件 查询第一条数据
     * 
     * @param clazz
     * @param builder
     * @return
     */
    public <T> T findFirst(Class<T> clazz, WhereBuilder builder);

    /**
     * 删除所有数据
     * 
     * @param clazz
     * @return
     */
    public <T> boolean delete(Class<T> clazz);

    /**
     * 按条件 删除数据
     * 
     * @param clazz
     * @param builder
     * @return
     */
    public <T> boolean delete(Class<T> clazz, WhereBuilder builder);

    /**
     * 删除数据 类或list
     * 
     * @param obj
     * @return
     */
    public <E> boolean delete(Object obj);

    /**
     * 插入数据 类或list
     * 
     * @param obj
     * @return
     */
    public <E> boolean save(Object obj);

    /**
     * 修改数据
     * 
     * @param clazz
     * @param valueBuilder
     * @param whereBuilder
     * @return
     */
    public <T> boolean update(Class<T> clazz, ValueBuilder valueBuilder, WhereBuilder whereBuilder);

    /**
     * 修改数据 类
     * 
     * @param obj
     * @param builder
     * @return
     */
    public <E> boolean update(Object obj, WhereBuilder builder);

    /**
     * 修改数据 类
     * 
     * @param obj
     * @param primaryKeyName
     * @return
     */
    public <E> boolean update(Object obj, String primaryKeyName);

    /**
     * 初始化数据表，不存在则创建
     * 
     * @param clazz
     * @return
     */
    public <T> boolean initTable(Class<T> clazz);

}

HGBuilder.java

这个类就是上一个类的具体实现，数据库操作都在这个类里面：

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import java.util.Locale;

import com.mz.jdbc.util.ValueBuilder.TagHolder;

/**
 * HG工具模型
 * 
 * @author HG
 *
 */
public class HGBuilder implements IHGBuilder {

    /**
     * 获取条件配置
     * 
     * @param obj
     * @return
     */
    private WhereBuilder getConfig(Object obj) {

        Field[] fields = obj.getClass().getDeclaredFields();
        WhereBuilder builder = new WhereBuilder();
        String fieldTypeName = "";

        for (int i = 0; i < fields.length; i++) {
            fields[i].setAccessible(true);
            if (Modifier.toString(fields[i].getModifiers()).contains("static")
            || Modifier.toString(fields[i].getModifiers()).contains("final")) {
            continue;
            }
            fieldTypeName = fields[i].getType().getSimpleName().toLowerCase(Locale.getDefault());
            switch (fieldTypeName) {
            case "int":
            case "integer":
            case "string":
            case "short":
            case "long":
            case "boolean":
            case "float":
            case "double":
            if (i == 0) {
                try {
                    builder.where(fields[i].getName(), "=", fields[i].get(obj) + "");
                } catch (IllegalArgumentException e) {
                    e.printStackTrace();
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
            } else {
                try {
                    builder.and(fields[i].getName(), "=", fields[i].get(obj) + "");
                } catch (IllegalArgumentException e) {
                e.printStackTrace();
                } catch (IllegalAccessException e) {
                e.printStackTrace();
                }
            }
                break;
            default:
                break;
            }
        }

        return builder;
    }

    /**
     * 获取数据库连接
     * 
     * @return
     */
    public Connection getConnection() {

        Connection con = null;

        try {
            Class.forName(HGConfig.DRIVER_CLASS);
            con = DriverManager.getConnection(HGConfig.CONNECTION);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }

        return con;
    }

    /**
     * 查询所有数据
     * 
     * @param clazz
     * @return
     */
    @Override
    public <T> List<T> findAll(Class<T> clazz) {
        return findAll(clazz, null);
    }

    /**
     * 按条件 查询所有数据
     * 
     * @param clazz
     * @param builder
     * @return
     */
    @Override
    public <T> List<T> findAll(Class<T> clazz, WhereBuilder builder) {

        Connection con = getConnection();
        PreparedStatement ps = null;
        ResultSet rs = null;

        List<T> result = new ArrayList<T>();
        T obj = null;
        String className = clazz.getSimpleName();
        String sql = "SELECT * FROM " + className;

        if (builder != null) {
            sql = sql + builder.getSql();
        }

        try {
            ps = con.prepareStatement(sql);

            if (builder != null) {

            int i = 0;
            Object value = "";
            for (com.mz.jdbc.util.WhereBuilder.TagHolder tag : builder.getTag()) {
                if (!tag.key.equals("ORDER BY") && !tag.key.equals("LIMIT")) {
                value = builder.getTag().get(i).value;
                if ("true".equals(value)) {
                    ps.setObject(i + 1, "1");
                } else if ("false".equals(value)) {
                    ps.setObject(i + 1, "0");
                } else {
                    ps.setObject(i + 1, value);
                }
                } else {
                break;
                }

                i++;
            }
            }

            rs = ps.executeQuery();

            Field[] fields = clazz.getDeclaredFields();
            String fieldTypeName = "";

            while (rs.next()) {
            obj = (T) clazz.newInstance();

            for (Field field : fields) {
                field.setAccessible(true);
                if (Modifier.toString(field.getModifiers()).contains("static")
                    || Modifier.toString(field.getModifiers()).contains("final")) {
                continue;
                }
                fieldTypeName = field.getType().getSimpleName().toLowerCase(Locale.getDefault());
                switch (fieldTypeName) {
                case "int":
                case "integer":
                field.set(obj, rs.getInt(field.getName()));
                break;
                case "string":
                field.set(obj, rs.getString(field.getName()));
                break;
                case "short":
                field.set(obj, rs.getShort(field.getName()));
                break;
                case "long":
                field.set(obj, rs.getLong(field.getName()));
                break;
                case "boolean":
                field.set(obj, rs.getBoolean(field.getName()));
                break;
                case "float":
                field.set(obj, rs.getFloat(field.getName()));
                break;
                case "double":
                field.set(obj, rs.getDouble(field.getName()));
                break;

                default:
                break;
                }
            }

            result.add(obj);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } finally {
            try {
            con.close();
            ps.close();
            rs.close();
            } catch (SQLException e) {
            e.printStackTrace();
            }
        }

        return result;
    }

    /**
     * 查询第一条数据
     * 
     * @param clazz
     * @return
     */
    @Override
    public <T> T findFirst(Class<T> clazz) {
        return findFirst(clazz, null);
    }

    /**
     * 按条件 查询第一条数据
     * 
     * @param clazz
     * @param builder
     * @return
     */
    @Override
    public <T> T findFirst(Class<T> clazz, WhereBuilder builder) {

        Connection con = getConnection();
        PreparedStatement ps = null;
        ResultSet rs = null;

        T obj = null;
        String className = clazz.getSimpleName();
        String sql = "SELECT * FROM " + className;

        if (builder != null) {
            builder.limit(1, 1);
            sql = sql + builder.getSql();
        }

        try {
            ps = con.prepareStatement(sql);

            if (builder != null) {
            int i = 0;
            Object value = "";
            for (com.mz.jdbc.util.WhereBuilder.TagHolder tag : builder.getTag()) {
                if (!tag.key.equals("ORDER BY") && !tag.key.equals("LIMIT")) {
                value = builder.getTag().get(i).value;
                if ("true".equals(value)) {
                    ps.setObject(i + 1, "1");
                } else if ("false".equals(value)) {
                    ps.setObject(i + 1, "0");
                } else {
                    ps.setObject(i + 1, value);
                }
                } else {
                break;
                }

                i++;
            }
            }

            rs = ps.executeQuery();

            Field[] fields = clazz.getDeclaredFields();
            String fieldTypeName = "";

            if (rs.next()) {
            obj = (T) clazz.newInstance();

            for (Field field : fields) {
                field.setAccessible(true);
                if (Modifier.toString(field.getModifiers()).contains("static")
                    || Modifier.toString(field.getModifiers()).contains("final")) {
                continue;
                }
                fieldTypeName = field.getType().getSimpleName().toLowerCase(Locale.getDefault());
                switch (fieldTypeName) {
                case "int":
                case "integer":
                field.set(obj, rs.getInt(field.getName()));
                break;
                case "string":
                field.set(obj, rs.getString(field.getName()));
                break;
                case "short":
                field.set(obj, rs.getShort(field.getName()));
                break;
                case "long":
                field.set(obj, rs.getLong(field.getName()));
                break;
                case "boolean":
                field.set(obj, rs.getBoolean(field.getName()));
                break;
                case "float":
                field.set(obj, rs.getFloat(field.getName()));
                break;
                case "double":
                field.set(obj, rs.getDouble(field.getName()));
                break;

                default:
                break;
                }
            }
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } finally {
            try {
            con.close();
            ps.close();
            rs.close();
            } catch (SQLException e) {
            e.printStackTrace();
            }
        }

        return obj;
    }

    /**
     * 删除所有数据
     * 
     * @param clazz
     * @return
     */
    @Override
    public <T> boolean delete(Class<T> clazz) {
        return delete(clazz, null);
    }

    /**
     * 按条件 删除数据
     * 
     * @param clazz
     * @param builder
     * @return
     */
    @Override
    public <T> boolean delete(Class<T> clazz, WhereBuilder builder) {

        Connection con = getConnection();
        PreparedStatement ps = null;

        String className = clazz.getSimpleName();
        String sql = "DELETE FROM " + className;

        if (builder != null) {
            sql = sql + builder.getSql();
        }

        try {
            ps = con.prepareStatement(sql);
            Object value = "";

            if (builder != null) {
            int i = 0;
            for (com.mz.jdbc.util.WhereBuilder.TagHolder tag : builder.getTag()) {
                if (!tag.key.equals("ORDER BY") && !tag.key.equals("LIMIT")) {
                value = builder.getTag().get(i).value;
                if ("true".equals(value)) {
                    ps.setObject(i + 1, "1");
                } else if ("false".equals(value)) {
                    ps.setObject(i + 1, "0");
                } else {
                    ps.setObject(i + 1, value);
                }
                } else {
                break;
                }

                i++;
            }
            }

            ps.execute();
        } catch (SQLException e) {
            return false;
        }

        return true;
    }

    /**
     * 删除数据 类或list
     * 
     * @param obj
     * @return
     */
    @SuppressWarnings("unchecked")
    @Override
    public <E> boolean delete(Object obj) {

        if (obj instanceof List) {
            List<E> list = (List<E>) obj;
            int flag = 0;
            Object o = null;

            for (int i = 0; i < list.size(); i++) {
            o = list.get(i);
            flag = delete(o.getClass(), getConfig(o)) ? flag + 1 : flag;
            }

            return flag == list.size();
        } else {
            return delete(obj.getClass(), getConfig(obj));
        }
    }

    /**
     * 插入数据 类或list
     * 
     * @param obj
     * @return
     */
    @SuppressWarnings("unchecked")
    @Override
    public <E> boolean save(Object obj) {

        if (obj instanceof List) {
            List<E> list = (List<E>) obj;
            int flag = 0;
            Object o = null;

            for (int i = 0; i < list.size(); i++) {
            o = list.get(i);
            flag = save2(o) ? flag + 1 : flag;
            }

            return flag == list.size();
        } else {
            return save2(obj);
        }
    }

    /**
     * 插入数据 类
     * 
     * @param obj
     * @return
     */
    private <E> boolean save2(Object obj) {

        Connection con = getConnection();
        PreparedStatement ps = null;

        String className = obj.getClass().getSimpleName();
        String sql = "INSERT INTO " + className;
        Field[] fields = obj.getClass().getDeclaredFields();
        String fieldTypeName = "";

        if (fields.length > 0) {
            sql = sql + " (";
            String sql2 = " (";

            for (Field field : fields) {
            field.setAccessible(true);
            if (Modifier.toString(field.getModifiers()).contains("static")
                || Modifier.toString(field.getModifiers()).contains("final")) {
                continue;
            }
            fieldTypeName = field.getType().getSimpleName().toLowerCase(Locale.getDefault());
            switch (fieldTypeName) {
            case "int":
            case "integer":
            case "string":
            case "short":
            case "long":
            case "boolean":
            case "float":
            case "double":
                try {
                if (!"null".equals(String.valueOf(field.get(obj)))) {
                    sql = sql + field.getName() + ",";
                    sql2 = sql2 + "?,";
                }
                } catch (IllegalArgumentException e) {
                e.printStackTrace();
                } catch (IllegalAccessException e) {
                e.printStackTrace();
                }
                break;
            default:
                break;
            }
            }

            sql = sql.substring(0, sql.length() - 1);
            sql2 = sql2.substring(0, sql2.length() - 1) + ")";
            sql = sql + ")" + " VALUES " + sql2;

            try {
            ps = con.prepareStatement(sql);
            Object value = "";
            int i = 0;

            for (Field field : fields) {
                field.setAccessible(true);
                if (Modifier.toString(field.getModifiers()).contains("static")
                    || Modifier.toString(field.getModifiers()).contains("final")) {
                continue;
                }
                fieldTypeName = field.getType().getSimpleName().toLowerCase(Locale.getDefault());
                value = field.get(obj);
                switch (fieldTypeName) {
                case "int":
                case "integer":
                case "string":
                case "short":
                case "long":
                case "boolean":
                case "float":
                case "double":
                if (!"null".equals(value)) {
                    if ("true".equals(value)) {
                    ps.setObject(i + 1, "1");
                    } else if ("false".equals(value)) {
                    ps.setObject(i + 1, "0");
                    } else {
                    ps.setObject(i + 1, value);
                    }

                    i++;
                }
                break;
                default:
                break;
                }
            }
            ps.execute();
            } catch (SQLException e) {
            return false;
            } catch (IllegalArgumentException e) {
            return false;
            } catch (IllegalAccessException e) {
            return false;
            }
        }

        return true;
    }

    /**
     * 修改数据
     * 
     * @param clazz
     * @param valueBuilder
     * @param whereBuilder
     * @return
     */
    @Override
    public <T> boolean update(Class<T> clazz, ValueBuilder valueBuilder, WhereBuilder whereBuilder) {

        Connection con = getConnection();
        PreparedStatement ps = null;

        String className = clazz.getSimpleName();
        String sql = "UPDATE " + className;
        sql = sql + valueBuilder.getSql() + whereBuilder.getSql();

        try {
            ps = con.prepareStatement(sql);

            ArrayList<TagHolder> values = valueBuilder.getTag();
            Object value = "";
            int i = 0;
            for (TagHolder tagHolder : values) {
            value = tagHolder.value;
            if ("true".equals(value)) {
                ps.setObject(i + 1, "1");
            } else if ("false".equals(value)) {
                ps.setObject(i + 1, "0");
            } else {
                ps.setObject(i + 1, value);
            }

            i++;
            }

            ArrayList<com.mz.jdbc.util.WhereBuilder.TagHolder> values2 = whereBuilder.getTag();
            for (com.mz.jdbc.util.WhereBuilder.TagHolder tag : values2) {
            if (!tag.key.equals("ORDER BY") && !tag.key.equals("LIMIT")) {
                value = tag.value;
                if ("true".equals(value)) {
                ps.setObject(i + 1, "1");
                } else if ("false".equals(value)) {
                ps.setObject(i + 1, "0");
                } else {
                ps.setObject(i + 1, value);
                }
            } else {
                break;
            }

            i++;
            }

            ps.execute();
        } catch (SQLException e) {
            return false;
        }

        return true;
    }

    /**
     * 修改数据 类
     * 
     * @param obj
     * @param builder
     * @return
     */
    @Override
    public <E> boolean update(Object obj, WhereBuilder builder) {

        if (!(obj instanceof List)) {
            ValueBuilder valueBuilder = new ValueBuilder();
            Object value = "";
            Field[] fields = obj.getClass().getDeclaredFields();
            String fieldTypeName = "";

            for (Field field : fields) {
            field.setAccessible(true);
            if (Modifier.toString(field.getModifiers()).contains("static")
                || Modifier.toString(field.getModifiers()).contains("final")) {
                continue;
            }
            fieldTypeName = field.getType().getSimpleName().toLowerCase(Locale.getDefault());
            try {
                value = field.get(obj);
            } catch (IllegalArgumentException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
            switch (fieldTypeName) {
            case "int":
            case "integer":
            case "string":
            case "short":
            case "long":
            case "boolean":
            case "float":
            case "double":
                if (!"null".equals(value)) {
                valueBuilder.putValue(field.getName(), value);
                }
                break;
            default:
                break;
            }
            }
            return update(obj.getClass(), valueBuilder, builder);
        } else {
            return false;
        }
    }

    /**
     * 修改数据 类
     * 
     * @param obj
     * @param primaryKeyName
     * @return
     */
    @Override
    public <E> boolean update(Object obj, String primaryKeyName) {

        Field[] fields = obj.getClass().getDeclaredFields();
        WhereBuilder builder = new WhereBuilder();

        for (Field field : fields) {
            field.setAccessible(true);
            if (primaryKeyName.equals(field.getName())) {
            try {
                builder.where(primaryKeyName, "=", field.get(obj));
                break;
            } catch (IllegalArgumentException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
            }
        }

        return update(obj, builder);
    }

    /**
     * 初始化数据表，不存在则创建
     * 
     * @param clazz
     * @return
     */
    @Override
    public <T> boolean initTable(Class<T> clazz) {

        Connection conn = HG.getInstance().getConnection();
        String className = clazz.getSimpleName();
        String sql = "CREATE TABLE IF NOT EXISTS " + className;
        String sql2 = "";
        PreparedStatement ps = null;

        Field[] fields = clazz.getDeclaredFields();
        String fieldTypeName = "";

        if (fields.length < 1) {
            return false;
        }

        for (Field field : fields) {
            field.setAccessible(true);
            if (Modifier.toString(field.getModifiers()).contains("static")
                || Modifier.toString(field.getModifiers()).contains("final")) {
            continue;
            }
            fieldTypeName = field.getType().getSimpleName().toLowerCase(Locale.getDefault());

            switch (fieldTypeName) {
            case "int":
            case "integer":
            sql2 = sql2 + field.getName() + " int(11) DEFAULT 0,";
            break;
            case "string":
            sql2 = sql2 + field.getName() + " varchar(255) DEFAULT '',";
            break;
            case "short":
            sql2 = sql2 + field.getName() + " int(6) DEFAULT 0,";
            break;
            case "long":
            sql2 = sql2 + field.getName() + " bigint(20) DEFAULT 0,";
            break;
            case "boolean":
            sql2 = sql2 + field.getName() + " int(1) DEFAULT 0,";
            break;
            case "float":
            sql2 = sql2 + field.getName() + " float(20,6) DEFAULT 0,";
            break;
            case "double":
            sql2 = sql2 + field.getName() + " double(30,12) DEFAULT 0,";
            break;
            default:
            break;
            }
        }

        sql2 = sql2.substring(0, sql2.length() - 1);
        sql = sql + "(" + sql2 + ")";

        try {
            ps = conn.prepareStatement(sql);
            ps.execute();
        } catch (SQLException e) {
            return false;
        } finally {
            try {
            conn.close();
            ps.close();
            } catch (SQLException e) {
            return false;
            }
        }

        return true;
    }

}

WhereBuilder.java

这个类是做条件筛选操作的，例如where，and，or，limit等：

import java.util.ArrayList;

/**
 * 条件模型
 * 
 * @author HG
 *
 */
public class WhereBuilder {

    /** 拼接的sql语句 **/
    private String sql = "";
    /** 预处理缓存值 **/
    private ArrayList<TagHolder> valuesTag = new ArrayList<TagHolder>();

    /** 条件优先级-第1级 **/
    private final int PRIORITY_FIRST = 1;
    /** 条件优先级-第2级 **/
    private final int PRIORITY_SECOND = 2;
    /** 条件优先级-最后第2级 **/
    private final int PRIORITY_BEFORE_LAST = 98;
    /** 条件优先级-最后1级 **/
    private final int PRIORITY_LAST = 99;

    public class TagHolder {

        /** 操作关键字 **/
        public String key;
        /** 属性名 **/
        public String columnName;
        /** 操作符号 **/
        public String op;
        /** 值 **/
        public Object value;
        /** 分页索引 **/
        public long pageIndex;
        /** 分页一页条数 **/
        public long pageSize;
        /** 是否升序 **/
        public boolean isAsc;
        /** 优先级 **/
        public int priority;

        public TagHolder(String key, String columnName, String op, Object value, int priority) {
            this.key = key;
            this.columnName = columnName;
            this.op = op;
            this.value = value;
            this.priority = priority;
        }

        public TagHolder(String key, long pageIndex, long pageSize, int priority) {
            this.key = key;
            this.pageIndex = pageIndex;
            this.pageSize = pageSize;
            this.priority = priority;
        }

        public TagHolder(String key, String columnName, boolean isAsc, int priority) {
            this.key = key;
            this.columnName = columnName;
            this.isAsc = isAsc;
            this.priority = priority;
        }
    }

    public WhereBuilder where(String columnName, String op, Object value) {

        TagHolder holder = new TagHolder("WHERE", columnName, op, value, PRIORITY_FIRST);

        for (TagHolder tagHolder : valuesTag) {
            if ("WHERE".equals(tagHolder.key)) {
                valuesTag.remove(tagHolder);
                break;
            }
        }

        valuesTag.add(0, holder);

        return this;
    }

    public WhereBuilder and(String columnName, String op, Object value) {

        TagHolder holder = new TagHolder("AND", columnName, op, value, PRIORITY_SECOND);

        for (TagHolder tagHolder : valuesTag) {
            if (columnName.equals(tagHolder.columnName) && "AND".equals(tagHolder.key)) {
                valuesTag.remove(tagHolder);
                break;
            }
        }

        valuesTag.add(holder);

        return this;
    }

    public WhereBuilder or(String columnName, String op, Object value) {

        TagHolder holder = new TagHolder("OR", columnName, op, value, PRIORITY_SECOND);

        for (TagHolder tagHolder : valuesTag) {
            if (columnName.equals(tagHolder.columnName) && "OR".equals(tagHolder.key)) {
                valuesTag.remove(tagHolder);
                break;
            }
        }

        valuesTag.add(holder);

        return this;
    }

    /**
     * 分页 一定要放在sql语句最后
     * 
     * @param pageIndex
     *            页码(1,2,3,4,……)
     * @param pageSize
     *            每页的数据条数
     */
    public WhereBuilder limit(long pageIndex, long pageSize) {

        TagHolder holder = new TagHolder("LIMIT", pageIndex, pageSize, PRIORITY_LAST);

        for (TagHolder tagHolder : valuesTag) {
            if ("LIMIT".equals(tagHolder.key)) {
                valuesTag.remove(tagHolder);
                break;
            }
        }

        valuesTag.add(holder);

        return this;
    }

    /**
     * 排序
     * 
     * @param columnName
     * @param isAsc
     *            是否为升序
     * @return
     */
    public WhereBuilder order(String columnName, boolean isAsc) {

        TagHolder holder = new TagHolder("ORDER BY", columnName, isAsc, PRIORITY_BEFORE_LAST);

        for (TagHolder tagHolder : valuesTag) {
            if ("ORDER BY".equals(tagHolder.key)) {
                valuesTag.remove(tagHolder);
                break;
            }
        }

        valuesTag.add(holder);

        return this;
    }

    /**
     * 获取拼接的sql语句
     * 
     * @return
     */
    public String getSql() {

        int size = valuesTag.size();
        TagHolder tag = null;
        for (int i = 1; i < size; i++) {
            for (int j = 0; j < size - 1; j++) {
                if (valuesTag.get(j).priority > valuesTag.get(j + 1).priority) {
                        tag = valuesTag.get(j);
                        valuesTag.set(j, valuesTag.get(j + 1));
                        valuesTag.set(j + 1, tag);
                }
            }
        }

        sql = "";

        for (TagHolder tagHolder : valuesTag) {
            if (tagHolder.key.equals("ORDER BY")) {
                sql = sql + " ORDER BY " + tagHolder.columnName + (tagHolder.isAsc ? " ASC" : " DESC");
            } else if (tagHolder.key.equals("LIMIT")) {
                sql = sql + " LIMIT " + ((tagHolder.pageIndex - 1) * tagHolder.pageSize) + "," + tagHolder.pageSize;
            } else {
                sql = sql + " " + tagHolder.key + " " + tagHolder.columnName + tagHolder.op + "?";
            }
        }

        return sql;
    }

    /**
     * 获取预处理缓存的值
     * 
     * @return
     */
    public ArrayList<TagHolder> getTag() {
        return valuesTag;
    }

}

ValueBuilder.java

这个类是用于更新数据库时传入需要更新的值：

import java.util.ArrayList;

/**
 * 值模型
 * 
 * @author HG
 *
 */
public class ValueBuilder {

    /** 拼接sql语句 **/
    private String sql = "";
    /** 缓存值 **/
    private ArrayList<TagHolder> valuesTag = new ArrayList<TagHolder>();

    public class TagHolder {

        /** 属性名 **/
        public String columnName;
        /** 值 **/
        public Object value;

        public TagHolder(String columnName, Object value) {
            this.columnName = columnName;
            this.value = value;
        }
    }

    /**
     * 放值
     * 
     * @param columnName
     * @param value
     * @return
     */
    public ValueBuilder putValue(String columnName, Object value) {

        TagHolder holder = new TagHolder(columnName, value);

        for (TagHolder tagHolder : valuesTag) {
            if (tagHolder.columnName.equals(columnName)) {
                valuesTag.remove(tagHolder);
                break;
            }
        }

        valuesTag.add(holder);

        return this;
    }

    /**
     * 获取sql语句
     * 
     * @return
     */
    public String getSql() {

        sql = "";

        for (TagHolder tagHolder : valuesTag) {
            sql = sql + tagHolder.columnName + "=?,";
        }

        sql = " SET " + sql.substring(0, sql.length() - 1);

        return sql;
    }

    /**
     * 获取缓存值
     * 
     * @return
     */
    public ArrayList<TagHolder> getTag() {
        return valuesTag;
    }

}

目录

MySQL使用的封装工具Java 用法 HGjava HGConfigjava IHGBuilderjava HGBuilderjava WhereBuilderjava ValueBuilderjava 目录 小记

小记

封装主要用到Java的反射机制和暴力反射。

本人数据库学习不深，所以还有操作不会写，只封装了一些简单的操作，写下本篇博客希望大家一起学习，分享经验，大神们有改进的地方发我邮箱：op123355569@163.com

CSDN上资源下载地址