主类
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;
public class Main
{
public static void main(String[] args)
{
connect_db mytest= new connect_db();
Connection con;
con =mytest.Db_Conn();
PreparedStatement pst = null;
ResultSet rs = null;
String sql = "select * from etl_job_dependency";
/**
* 该方法用到的技术是通过结果集的列属性的性质得到,没有用到反射机制
* 这个测试用例也是把查询的结果集放到List集合
* 里面的元素是集合Map,key是数据库中的字段类型,value是
* 字段类型对应的值,
*/
/* try {
List list=DBUtil.executeQuery(con, sql);
System.out.println(list);
} catch (SQLException e) {
e.printStackTrace();
}*/
/**
* 这个测试用例只是把查询的结果集中的某一条记录映射到了dao对象中,
*/
try {
pst = con.prepareStatement(sql);
rs = pst.executeQuery();
while(rs.next()){
dependency r = (dependency) DBUtil.getFirstObjectFromRs(rs, dependency.class);
System.out.println("Dependency:" + r);
}
} catch (SQLException e) {
e.printStackTrace();
}finally{
DBUtil.closeRs(rs);
DBUtil.closePst(pst);
DBUtil.closeCon(con);
}
/**
* 方法是用的反射机制
* 这个测试用例是测试executeQuery函数,把查询的结果集放到List集合
* 并且集合元素存放的是dao对象,一条数据库记录对应一个dao对象,
* 打印出来的结果如:
* [vehicle_id: 2 numberPlate: 苏B10001 deleteDate: null,
* vehicle_id: 3 numberPlate: 苏B90003 deleteDate: null]
*
*/
/* try {
List list=DBUtil.executeQuery(con, sql,Vehicle.class);
System.out.println(list);
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}*/
}
}
DBUtil工具类
import java.lang.reflect.*;
import java.sql.*;
import java.util.*;
/***
* 注意利用查询出数据库的一条记录映射到相应的dao中,写相应的dao一定要注意字段,一定
* 要与数据库的记录字段相对应,大小写可以忽略,但是字段不一致就返回错误的数据
*
* private static Object getValueFromRs(ResultSet rs, String fieldName, Type t) throws SQLException
* 此接口有个小的问题就是如果,获取的字段值是空值或者为null,而你自己的需求就是想要获取的字段为一个
* 默认的值,那就只需要客户该写这个方法,进行判断就可以
* @author Administrator
*
*/
public class DBUtil {
/**
* 对操作的数据库回滚
* @param con 对数据库操作所得到的链接
*/
public static void rollBack(Connection con){
try {
con.rollback();
} catch (SQLException e) {
e.printStackTrace();
}
}
/***
*
* @param con 数据库jdbc链接
* @param sql 执行的sql语句
* @return 返回查询的记录数,记录存储在集合List里面,
* 里面的元素是集合Map,key是数据库中的字段类型,value是
* 字段类型对应的值
* @throws SQLException
*/
public static List<Map<String, Object>> executeQuery(Connection con, String sql) throws SQLException{
PreparedStatement pst = null;
ResultSet rs = null;
try {
pst = con.prepareStatement(sql);
rs = pst.executeQuery();
return getListFromRsLowerCase(rs);
}finally{
closeRs(rs);
closePst(pst);
}
}
/***
* 执行sql语句,把结果集存放到List集合里,集合的元素是dao对象
* @param con 数据库得到的链接
* @param sql 执行查询的sql语句
* @param c 把一条条记录要映射的dao类中的对象中去
* @return
* @throws SQLException
*/
public static List<Object> executeQuery(Connection con, String sql, Class<?> c) throws SQLException{
PreparedStatement pst = null;
ResultSet rs = null;
try {
pst = con.prepareStatement(sql);
rs = pst.executeQuery();
return getListFromRs(rs, c);
}finally{
closeRs(rs);
closePst(pst);
}
}
/**
* 得到结果集存储到list中
* @param rs 查询的结果集
* @return
* @throws SQLException
*/
public static List<Map<String, Object>> getListFromRs(ResultSet rs) throws SQLException{
ResultSetMetaData md = rs.getMetaData();//得到结果集列的属性
int columns = md.getColumnCount();//得到记录有多少列
int i;
List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
while(rs.next()){
Map<String, Object> map = new HashMap<String, Object>();
for(i = 0; i < columns; i++){
map.put(md.getColumnName(i + 1), getValueByType(rs, md.getColumnType(i + 1), md.getColumnName(i + 1)));
}
list.add(map);
}
return list;
}
/**
* 这个与getListFromRs(ResultSet rs)差不多,只是把数据库的字段变成小写
*
* @param rs
* @return
* @throws SQLException
*/
public static List<Map<String, Object>> getListFromRsLowerCase(ResultSet rs) throws SQLException{
ResultSetMetaData md = rs.getMetaData();
int columns = md.getColumnCount();
int i;
List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
while(rs.next()){
Map<String, Object> map = new HashMap<String, Object>();
for(i = 0; i < columns; i++){
map.put(md.getColumnName(i + 1).toLowerCase(), getValueByType(rs, md.getColumnType(i + 1), md.getColumnName(i + 1)));
}
list.add(map);
}
return list;
}
/**
* 这个与getListFromRs(ResultSet rs)功能一样,只是把数据库的字段变成大写
* @param rs
* @return
* @throws SQLException
*/
public static List<Map<String, Object>> getListFromRsUpperCase(ResultSet rs) throws SQLException{
ResultSetMetaData md = rs.getMetaData();
int columns = md.getColumnCount();
int i;
List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
while(rs.next()){
Map<String, Object> map = new HashMap<String, Object>();
for(i = 0; i < columns; i++){
map.put(md.getColumnName(i + 1).toUpperCase(), getValueByType(rs, md.getColumnType(i + 1), md.getColumnName(i + 1)));
}
list.add(map);
}
return list;
}
/***
*
* @param rs 查询的结果集
* @param c 集合元素存放的dao对象
* @return
* @throws SQLException
*/
public static List<Object> getListFromRs(ResultSet rs, Class<?> c) throws SQLException{
List<Object> list = new ArrayList<Object>();
try {
while(rs.next()){
Object o = initObjectFromRsIfExist(rs, c);
list.add(o);
}
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
}
return list;
}
/**
*
* @param rs 查询的结果集
* @param c 结果集一条记录,而一条记录所对应的dao类
* @return
* @throws SQLException
*/
public static Object getFirstObjectFromRs(ResultSet rs, Class<?> c) throws SQLException{
Object o = null;
try {
o = initObjectFromRsIfExist(rs, c);
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
return o;
}
/***
*
* @param rs 查询出来的结果集
* @param type SQL type from java.sql.Types
* @param name 数据库记录所对应的字段名称
* @return 返回一条记录的一个列值
* @throws SQLException
*/
private static Object getValueByType(ResultSet rs, int type, String name) throws SQLException{
switch(type){
case Types.NUMERIC:
return rs.getLong(name);
case Types.VARCHAR:
//if(rs.getString(name)==null){
//return "";
//}
return rs.getString(name);
case Types.DATE:
//if(rs.getDate(name)==null){
//return System.currentTimeMillis();
// }
return rs.getDate(name);
case Types.TIMESTAMP:
return rs.getTimestamp(name).toString().substring(0,rs.getTimestamp(name).toString().length()-2);
case Types.INTEGER:
return rs.getInt(name);
case Types.DOUBLE:
return rs.getDouble(name);
case Types.FLOAT:
return rs.getFloat(name);
case Types.BIGINT:
return rs.getLong(name);
default:
return rs.getObject(name);
}
}
/***
* 查询dao映射的字段是否在记录在数据库包含的字段
* @param rs 查询的记录集
* @param fieldName dao映射的字段
* @return 如果包含在数据库记录集里面,返回true,否则false
* @throws SQLException
*/
private static boolean rsContainsFields(ResultSet rs, String fieldName) throws SQLException{
ResultSetMetaData md = rs.getMetaData();
for(int i = 0; i < md.getColumnCount(); i++){
if(md.getColumnName(i + 1).equalsIgnoreCase(fieldName)){
return true;
}
}
return false;
}
/***
* 这个函数与initObjectFromRsIfExist函数实现的功能是一样,只是
* 没有判断dao中的字段是否与数据库记录所定义的字段是一样的,
* 没有判断时如果自己设置的dao字段与数据库的字段不一致就会报异常
* @param rs
* @param c
* @return
* @throws InstantiationException
* @throws SQLException
* @throws IllegalAccessException
*/
private static Object initObjectFromRs(ResultSet rs, Class<?> c) throws InstantiationException, SQLException, IllegalAccessException{
Object o = c.newInstance();
Method[] methods = o.getClass().getMethods();
for(Method m: methods){
if(m.getName().startsWith("set")){
try {
m.invoke(o, getParamValueFromRs(rs, m));
} catch (IllegalArgumentException e) {
throw new RuntimeException("IllegalArgumentException:" + e + "\nMethods:" + m.getName());
} catch (InvocationTargetException e) {
throw new RuntimeException("InvocationTargetException:" + e + "\nMethods:" + m.getName());
}
}
}
return o;
}
/***
*
* 把数据库的一条记录映射到相应的dao对象中,
* 如果dao中的字段与数据库字段不一致,返回的就是dao数据类型定义的默认值
* 如:dao的字段long vehicleID;而数据库的字段是vehicle_id,那么返回的
* 就定义的默认值0.
* @param rs 查询的结果集
* @param c 结果集一条记录,而一条记录所对应的dao类
* @return
* @throws SQLException
* @throws IllegalAccessException
* @throws InstantiationException
*/
private static Object initObjectFromRsIfExist(ResultSet rs, Class<?> c) throws SQLException, IllegalAccessException, InstantiationException{
Object o = c.newInstance();//一条记录的dao,新建对象
Method[] methods = o.getClass().getMethods();//dao对象所有的方法
String field;
for(Method m: methods){
//得到dao字段,如getRegdate,转换成Regdate
field = m.getName().substring(3);
//查询dao映射的字段是否在记录在数据库包含的字段,dao方法对set开头的方法进行处理
//因为要将结果集映射到dao里面
if(m.getName().startsWith("set") && rsContainsFields(rs, field)){
try {
m.invoke(o, getParamValueFromRs(rs, m));
} catch (IllegalArgumentException e) {
throw new RuntimeException("IllegalArgumentException:" + e + "\nMethods:" + m.getName());
} catch (InvocationTargetException e) {
throw new RuntimeException("InvocationTargetException:" + e + "\nMethods:" + m.getName());
}
}
}
return o;
}
/***
*
* @param rs 查询的结果集
* @param m dao映射字段对应的一个set方法
* @return
* @throws SQLException
*/
private static Object getParamValueFromRs(ResultSet rs, Method m) throws SQLException
{
String fieldName = m.getName().substring(3);
Type type = m.getGenericParameterTypes()[0];//获取set方法参数的类型
return getValueFromRs(rs, fieldName, type);
}
/**
* 获取数据库一条记录的一个列值
* @param rs 查询的结果集
* @param fieldName dao数据字段,也就是数据库记录的数据字段类型
* @param t 参数的数据类型
* @return
* @throws SQLException
*/
private static Object getValueFromRs(ResultSet rs, String fieldName, Type t) throws SQLException{
String type = t.toString();
try{
if(type.equals("int") || type.equals("class java.lang.Integer")){
return rs.getInt(fieldName);
}else if(type.equals("float") || type.equals("class java.lang.Float")){
return rs.getFloat(fieldName);
}else if(type.equals("double") || type.equals("class java.lang.Double")){
return rs.getDouble(fieldName);
}else if(type.equals("long") || type.equals("class java.lang.Long")){
return rs.getLong(fieldName);
}else if(type.equals("class java.lang.String")){
return rs.getString(fieldName);
}else if(type.equals("class java.sql.Timestamp")){
return rs.getTimestamp(fieldName);
}else if(type.equals("class java.sql.Date")){
return rs.getDate(fieldName);
}else if(type.equals("class java.sql.Time")){
return rs.getTime(fieldName);
}
}catch(SQLException e){
throw new SQLException("SQLException when get field:" + fieldName + "\n" + e);
}
throw new RuntimeException("getValueFromRsByField fail, field type is:" + type + ",field name is:" + fieldName);
}
/***
* 关闭数据库多个结果集
* @param rss
*/
public static void closeRs(ResultSet... rss){
for(ResultSet rs: rss){
if(rs != null){
try {
rs.close();
} catch (SQLException e) {
}
}
}
}
/**
* 关闭数据库多个psts
* @param psts
*/
public static void closePst(Statement... psts){
for(Statement pst: psts){
if(pst != null){
try {
pst.close();
} catch (SQLException e) {
}
}
}
}
/**
* 关闭数据库所得到的多个链接
* @param cons
*/
public static void closeCon(Connection... cons){
for(Connection con: cons){
if(con != null)
{
try {
con.close();
} catch (SQLException e) {
}
}
}
}
}
dependence dao类
import java.sql.Date;
import java.util.ArrayList;
import java.util.List;
public class dependency{
private String etl_system;//系统名
private String etl_job;//任务名
private String dependency_system;//依赖系统名
private String dependency_job;//依赖任务名
private String description;//描述
private String enable;//使能状态
private String dep_mode;//依赖模式
public String get_enable() {
return enable;
}
public void set_enable(String remark) {
this.enable = enable;
}
public String toString(){
return "这个依赖的状态是: "+this.enable+" 代表:哈哈! ";
}
//@Override
public String tagetTableName() {
return "ETL_JOB_DEPENDENCY";
}
//@Override
public List<String> unEditFields() {
List<String> list = new ArrayList<String>();
list.add("remark");
return list;
}
public String getEtl_system() {
return etl_system;
}
public void setEtl_system(String etl_system) {
this.etl_system = etl_system;
}
public String getEtl_job() {
return etl_job;
}
public void setEtl_job(String etl_job) {
this.etl_job = etl_job;
}
public String getDependency_system() {
return dependency_system;
}
public void setDependency_system(String number_dependency_systemplate_type_id) {
this.dependency_system = dependency_system;
}
public String getDependency_job() {
return dependency_job;
}
public void setDependency_job(String dependency_job) {
this.dependency_job = dependency_job;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
public String getDep_mode() {
return dep_mode;
}
public void setColor(String dep_mode) {
this.dep_mode = dep_mode;
}
}
连接数据库类connect_db
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;
public class connect_db {
//这里是SqlConnection 类
/*
*java连接mysql数据库
*1、加载驱动程序
*2、数据库连接字符串"jdbc:mysql://localhost:3306/数据库名?"
*3、数据库登录名
*3、数据库登录密码
*/
private static final String URL="jdbc:mysql://192.168.31.161:3306/pelt";//数据库连接字符串
//private static final String URL="jdbc:mysql://192.168.31.161:3306/pelt?useUnicode\=true&characterEncoding\=UTF-8&zeroDateTimeBehavior\=convertToNull";
private static final String NAME="root";//登录名
private static final String PASSWORD="123456";//密码
//声明Connection对象
Connection conn = null;
Statement stmt = null;
public Connection Db_Conn(){
Connection c = null;
try {
Class.forName("com.mysql.jdbc.Driver");
conn = DriverManager.getConnection(URL, NAME, PASSWORD);
if(!conn.isClosed())
System.out.println("Succeeded connecting to the Database!");
System.out.println("获取数据库连接成功!");
} catch (ClassNotFoundException e) {
System.out.println("未能成功加载驱动程序,请检查是否导入驱动程序!");
//添加一个println,如果加载驱动异常,检查是否添加驱动,或者添加驱动字符串是否错误
e.printStackTrace();
} catch ( Exception e ) {
System.err.println( e.getClass().getName()+": "+ e.getMessage() );
System.exit(0);
}
return conn;
}
public Statement Db_Stat(Connection c){
Statement stmt=null;
try {
stmt = c.createStatement();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return stmt;
}
public void Db_Stat_Closed(Statement stmt){
try {
stmt.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
throw new RuntimeException(e);
}
}
public void Db_Conn_Closed(Connection c){
try {
c.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
throw new RuntimeException(e);
}
}
public String Return_sql(String sql,String tar_db){
conn=Db_Conn();
stmt=Db_Stat(conn);
ResultSet resultSet=null;
int columnCount=0;
try {
resultSet = stmt.executeQuery(sql);
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
ResultSetMetaData rsmd = null;
try {
rsmd = resultSet.getMetaData();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
try {
columnCount = rsmd.getColumnCount();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
String result="";
String result1="";
String insert="insert into "+tar_db+" values(";
//stmt.executeUpdate(sql1);
//stmt.executeUpdate(sql2);
try {
while(resultSet.next()){
//取出列值
for(int i=1;i<=columnCount;i++)
{
if(i==1){
String name = resultSet.getString(i);
if(name==null){
name="0";
}
result=insert+"'"+name+"'";
}else if(i==columnCount){
String name = resultSet.getString(i);
if(name==null){
name="0";
}
result=result+",'"+name+"');\n";
}else{
String name = resultSet.getString(i);
if(name==null){
name="0";
}
result=result+",'"+name+"'";
}
}
result1=result1+result;
}
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
Db_Stat_Closed(stmt);
Db_Conn_Closed(conn);
}
return result1;
}
public void WriteStringToFile(String result) {
try {
File file = new File("aaa.txt");
PrintStream ps = new PrintStream(new FileOutputStream(file));
ps.print(result);// 往文件里写入字符串
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public void InsertintoDb(String sql){
conn=Db_Conn();
stmt=Db_Stat(conn);
int rel=-1;
try {
rel=stmt.executeUpdate(sql);
if(rel>0){
System.out.println(sql+" successful!!");
}else{
System.out.println(sql+" unsuccessful!!");
}
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
Db_Stat_Closed(stmt);
Db_Conn_Closed(conn);
}
}
public void exectedroptable(String tablename){
conn=Db_Conn();
stmt=Db_Stat(conn);
String sql="drop table "+tablename;
int rel=-1;
try {
rel=stmt.executeUpdate(sql);
if(rel>0){
System.out.println("drop"+tablename+" successful!!");
}else{
System.out.println("drop"+tablename+" unsuccessful!!");
}
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
Db_Stat_Closed(stmt);
Db_Conn_Closed(conn);
}
}
public List<String> queryList(String sql){
ResultSet resultSet=null;
conn=Db_Conn();
stmt=Db_Stat(conn);
List<String> dataList = new ArrayList<String>();
try {
resultSet=stmt.executeQuery(sql);
try{
while(resultSet.next()){
String name = resultSet.getString(1);
dataList.add(name);
}
}catch(SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
Db_Stat_Closed(stmt);
Db_Conn_Closed(conn);
}
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return dataList;
}
}