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;
}
}
目录
小记
封装主要用到Java的反射机制和暴力反射。
本人数据库学习不深,所以还有操作不会写,只封装了一些简单的操作,写下本篇博客希望大家一起学习,分享经验,大神们有改进的地方发我邮箱:op123355569@163.com