上一篇我们写完了数据库连接的封装
没有看的请移步上一篇关于数据库连接的内容
这次我们讲数据库操作的封装。数据库的操作就是增删改查；心再大一点就可以直接分为查询和其他。
因为查询是有返回对象的，而其他都不用返回值（事实是可以返回执行该语句所影响数据表中的行数，但是用处不大，仅做判断用）
话不多说，看代码，代码比较长，但是我大概写了一些注释，有理解不到位的地方还请指正
package com.yck.database;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.sql.*;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class DataUtil
{
/**
* 以List的形式返回多条查询语句的结果
* @param clazz
* @param sql
* @param objects
* @return
*/
@SuppressWarnings("rawtypes")
public static <T> List<T> selectForBeanList(Class clazz,String sql,Object...objects)
{
List<T> list = new ArrayList<T>();
List<Map<String,Object>> mapList = queryForMapList(sql,objects);
for(Map<String,Object> map:mapList )
{
list.add(queryForBean(map, clazz));
}
return list;
}
/**
* 以javabean 对象的形式返回从数据空中查找出来的单条数据
* @param clazz
* @param sql
* @param objects
* @return
*/
@SuppressWarnings("rawtypes")
public static <T>T selectForBean(Class clazz,String sql,Object...objects)
{
Map<String,Object> map = queryForMap(sql,objects);
return queryForBean(map,clazz);
}
/**
* 除了查询外，都用这个
* @param updateSQL
* @param objects
* @return
*/
public static int updata(String updateSQL,Object...objects)
{
Connection conn = DButil.getConnection(); //建立与数据库的连接
PreparedStatement pStam = null;
int result = 10;
try
{
pStam = DButil.prepareStatement(conn, updateSQL);
for(int i=0;i<objects.length;i++) //对sql语句的通配符？进行填充
{
pStam.setObject(i+1, objects[i]);
}
result = pStam.executeUpdate(); //得到update结果
} catch (SQLException e)
{
e.printStackTrace();
}finally
{
DButil.closePreparedStatement(pStam);
DButil.closeConnection(conn);
}
return result;
}
@SuppressWarnings({ "unchecked", "rawtypes" })
private static <T>T queryForBean(Map<String,Object> map, Class clazz)
{
T obj = null;
Field field = null;
try
{
obj = (T) clazz.newInstance(); //实例化一个clazz对象
} catch (InstantiationException e)
{
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e)
{
// TODO Auto-generated catch block
e.printStackTrace();
}
if(map == null)
return null;
for(String columnName:map.keySet()) //遍历map的key
{
Method method = null;
String propertyName = StringUtil.columnToProperty(columnName); //将存在map中的key值转化成bean中的属性字段，驼峰命名
try
{
field = clazz.getDeclaredField(propertyName); //在类clazz中匹配相应的字段信息
} catch (NoSuchFieldException e)
{
// TODO Auto-generated catch block
e.printStackTrace();
} catch (SecurityException e)
{
// TODO Auto-generated catch block
e.printStackTrace();
}
String fieldType = field.toString().split(" ")[1]; //将字段信息以空格分割，第二条为字段类型（0 是第一条，一般为private）
Object value = map.get(columnName); //得到相应的值
if(value == null)
{
continue;
}
String setMethodName ="set"+StringUtil.upperCaseFirstCharacter(propertyName); //拼接set方法
String valueType = value.getClass().getName();
if(!fieldType.equalsIgnoreCase(valueType)) //根据类型转换value值
{
if(fieldType.equalsIgnoreCase("java.lang.Integer"))
{
value =Integer.parseInt(String.valueOf(value));
}
else if(fieldType.equalsIgnoreCase("java.lang.String"))
{
value = String.valueOf(value);
}
else if(fieldType.equalsIgnoreCase("java.util.Date"))
{
valueType = "java.lang.Date";
String datestr = String.valueOf(value);
Timestamp ts = Timestamp.valueOf(datestr);
Date date = new Date(ts.getTime());
value = date;
}
}
try
{
method = clazz.getDeclaredMethod(setMethodName, Class.forName(fieldType));
method.invoke(obj, value);
} catch (NoSuchMethodException e)
{
e.printStackTrace();
} catch (SecurityException e)
{
e.printStackTrace();
} catch (ClassNotFoundException e)
{
e.printStackTrace();
} catch (IllegalAccessException e)
{
e.printStackTrace();
} catch (IllegalArgumentException e)
{
e.printStackTrace();
} catch (InvocationTargetException e)
{
e.printStackTrace();
}
}
return obj;
}
/**
* 需要返回单个对象信息时，我们用Map存储，如果查询到不止一个对象或者没有查询到对象，返回null；
* @param sql
* @param objects
* @return
*/
private static Map<String,Object> queryForMap(String sql,Object...objects)
{
//新建一个Map，存放结果。key存放从数据库中取出的column名称，value存放相应column取出来的值（用rs.getObject（columnname）方法取出）
//
Map<String,Object> result = new HashMap<String,Object>();
Connection conn = DButil.getConnection(); //建立与数据库的连接
PreparedStatement pStam = null;
ResultSet rs = null;
try
{
pStam = DButil.prepareStatement(conn, sql);
for(int i=0;i<objects.length;i++) //对sql语句里的 ？进行填充
{
pStam.setObject(i+1, objects[i]);
}
rs = pStam.executeQuery(); //拿到查询结果
if(rs.next())
{
ResultSetMetaData rsmd = rs.getMetaData(); //拿到查询结果的字段
int count = rsmd.getColumnCount(); //字段数量
for(int i=0;i<count;i++)
{
result.put(rsmd.getColumnName(i+1), rs.getObject(rsmd.getColumnName(i+1)));
}
if(rs.next())
result = null;
}
} catch (SQLException e)
{
e.printStackTrace();
}finally
{
DButil.closeResultSet(rs);
DButil.closePreparedStatement(pStam);
DButil.closeConnection(conn);
}
return result;
}
/**
* 要返回多个对象时，我们把查询出来的单个对象的信息全部放在一个Map中，然后把这些单个对象的信息全放到
* List中返回
* @param sql
* @param objects
* @return
*/
private static List<Map<String,Object>> queryForMapList(String sql,Object...objects)
{
List<Map<String,Object>> result = new ArrayList<Map<String,Object>>(); //建立一个存放结果的List
Connection conn = DButil.getConnection(); //建立与数据库的连接
PreparedStatement pStam = null;
ResultSet rs = null;
try
{
pStam = DButil.prepareStatement(conn, sql);
for(int i=0;i<objects.length;i++) //对sql语句里的 ？进行填充
{
pStam.setObject(i+1, objects[i]);
}
rs = pStam.executeQuery(); //拿到查询结果
while(rs.next())
{
ResultSetMetaData rsmd = rs.getMetaData(); //拿到查询结果的字段
int count = rsmd.getColumnCount(); //字段数量
Map<String,Object> map = new HashMap<String,Object>(); //一个存放数据的map，key=字段名称，value=字段的内容
for(int i=0;i<count;i++)
{
map.put(rsmd.getColumnName(i+1), rs.getObject(rsmd.getColumnName(i+1)));
}
result.add(map);//将存放一条数据的map放进List
}
} catch (SQLException e)
{
e.printStackTrace();
}finally
{
DButil.closeResultSet(rs);
DButil.closePreparedStatement(pStam);
DButil.closeConnection(conn);
}
return result;
}
}
在Test类中做如下测试
package com.yck.test;
import java.util.List;
import com.yck.bean.User;
import com.yck.database.DataUtil;
public class Test
{
public static void main(String[] args)
{
String sql1 = "select * from t_user where name = ?";
User user = DataUtil.selectForBean(User.class, sql1, "张三");
System.out.println(user);
String sql2 = "select * from t_user";
List<User> list1 = DataUtil.selectForBeanList(User.class, sql2);
System.out.println("第一次查询的结果:"+list1);
String sql3 = "insert into t_user values (null,?,?)";
DataUtil.updata(sql3, "王老五",90);
List<User> list2 = DataUtil.selectForBeanList(User.class, sql2);
System.out.println("增加王老五之后:"+list2);
String sql4 = "update t_user set age=? where name =?";
DataUtil.updata(sql4, 200,"张三");
List<User> list3 = DataUtil.selectForBeanList(User.class, sql2);
System.out.println("把张三的年龄改掉之后:"+list3);
}
}
结果如下所示
数据库结果
忘了贴上上面用到的StringUtil的方法。
package com.yck.database;
import java.util.UUID;
public class StringUtil
{
public static String columnToProperty(String column)
{
//判断column是否为空
if(column.equals(null)||column.equals(""))
return "";
Byte length = (byte) column.length(); //获取字段的长度
StringBuilder sb = new StringBuilder(length);
for (int i = 0; i < length; i++) //遍历字符
{
if (column.charAt(i) == '_') //判断字符是否为下划线 _
{
while (column.charAt(i + 1) == '_') //如果是并且下一个还是是下划线，自增一个单位
{
i++;
}
sb.append(("" + column.charAt(++i)).toUpperCase()); //如果是并且下一个不是下划线，下一个字母变为大写
}
else
{
sb.append(column.charAt(i)); //如果不是下划线，直接保存
}
}
return sb.toString();
}
/**
* 把首字母大写
* @param str
* @return
*/
public static String upperCaseFirstCharacter(String str)
{
StringBuilder strBuilder = new StringBuilder();
char[] arr = str.toCharArray();
for(int i=0;i<arr.length;i++)
{
if(i==0)
strBuilder.append((arr[i]+"").toUpperCase());
else strBuilder.append(arr[i]+"");
}
return strBuilder.toString();
}
/**
* 生成32位uuid
* @return
*/
public static String createUniqueid()
{
UUID uniqueid = UUID.randomUUID();
String str = uniqueid.toString();
String uuidStr=str.replace("-", "");
return uuidStr;
}
}