DButils工具类可以用来获取数据库连接向数据库插入更新删除对象

package com.ctl.util;

import java.awt.Color;
import java.awt.Font;
import java.awt.Insets;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.io.*;
import java.lang.reflect.*;
import java.sql.*;
import java.util.*;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JPasswordField;
import javax.swing.JTextField;

/**
* @author Administrator
* @category

*/
public class DButils {
private static String driver;
private static String url;
private static String username;
private static String password;
private static Connection conn;
private static ThreadLocal<Connection> connHolder = new ThreadLocal<Connection>();
static {
driver = RegisterUtil.getStringFromSystemRoot("mysql.driver");
url = RegisterUtil.getStringFromSystemRoot("mysql.url");
username = RegisterUtil.getStringFromSystemRoot("mysql.username");
password = RegisterUtil.getStringFromSystemRoot("mysql.password");
try {
Runtime.getRuntime().exec("net start mysql");
} catch (IOException e) {
e.printStackTrace();
}
}

static class KeyValue {
Object key;
Object value;

public Object getKey() {
return key;
}

public void setKey(Object key) {
this.key = key;
}

public Object getValue() {
return value;
}

public void setValue(Object value) {
this.value = value;
}

public KeyValue() {
super();
}

public KeyValue(Object key, Object value) {
super();
this.key = key;
this.value = value;
}

@Override
public String toString() {
// TODO Auto-generated method stub
return this.key + ":" + this.value;
}

}

/**
*
* @return Connection
* @throws SQLException
* @throws ClassNotFoundException
*/

public static Connection getConnection() {
conn = connHolder.get();
try {
if (conn == null || conn.isClosed()) {
Class.forName(driver);
conn = DriverManager.getConnection(url, username, password);
conn.setAutoCommit(false);
connHolder.set(conn);
}
} catch (Exception e) {
init();
e.printStackTrace();
}
return conn;
}

/**
* @category 根据sql得到记录总数
* @param sql
* @return int 如果返回-1代表出错
*/
public static int getCount(String sql) {
try {
ResultSet rs = getConnection().createStatement().executeQuery(sql);
if (rs.next()) {
return rs.getInt(1);
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return -1;

}

/**
* @see 获取某张表的总记录数
* @param c
*            Person.class
* @return -1 出错 >=0 right
*/
public static int getCount(Class c) {
String tableName = c.getSimpleName().toLowerCase();// person 表的名字
if (!isTableExist(tableName)) {
System.err.println("表'" + tableName + "'不存在");
return -1;
}
try {
ResultSet rs = getConnection().prepareStatement(
"select count(" + getColumns(c).get(0) + ") from "
+ tableName).executeQuery();
if (rs.next()) {
return rs.getInt(1);
}
} catch (Exception e) {
e.printStackTrace();
}
return -1;
}
public static void init(){
Font fontGlobal = new Font("楷体", 11, 10);
JFrame jf=new JFrame("数据库初始化操作");
jf.setVisible(true);
jf.setBounds(600 , 260, 266, 166);
jf.setVisible(true);
jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
jf.setResizable(false);

JPanel jpanel=new JPanel();
jpanel.setBounds(0, 0, 300, 600);
jf.add(jpanel);
jpanel.setBackground(new Color(199, 237, 204));
jpanel.setLayout(null);

//	JLabel jls1 = new JLabel("mysql 数据库初始化操作");
//	jls1.setBounds(30, 0, 140, 20);
//	jpanel.add(jls1);
//	jls1.setFont(fontGlobal);

JLabel jls2 = new JLabel("主机名/ip:");
jls2.setBounds(0, 5, 50, 45);
jpanel.add(jls2);
jls2.setFont(fontGlobal);

// IP框
final JTextField jtfip = new JTextField(18);
jtfip.setBounds(50, 17, 100, 20);
jpanel.add(jtfip);
jtfip.setText("127.0.0.1");

JLabel jls3 = new JLabel("端口:");
jls3.setBounds(155, 5, 50, 45);
jpanel.add(jls3);
jls3.setFont(fontGlobal);

// 端口框
final JTextField jtfport = new JTextField(15);
jtfport.setBounds(180, 17, 45, 20);
jpanel.add(jtfport);
jtfport.setText("3306");

JLabel jls4= new JLabel("用户名:");
jls4.setBounds(16, 35, 50, 45);
jpanel.add(jls4);
jls4.setFont(fontGlobal);

final JTextField jtfip1 = new JTextField(18);
jtfip1.setBounds(50, 46, 58, 20);
jpanel.add(jtfip1);
jtfip1.setText("root");

JLabel jls5= new JLabel("密码:");
jls5.setBounds(125, 35, 50, 45);
jpanel.add(jls5);
jls5.setFont(fontGlobal);

// 端口框
final JPasswordField jtfport1 = new JPasswordField(15);
jtfport1.setBounds(150, 46,75, 20);
jpanel.add(jtfport1);
jtfport1.setText("root");

JLabel jls6= new JLabel("数据库名:");
jls6.setBounds(6, 65, 50, 45);
jpanel.add(jls6);
jls6.setFont(fontGlobal);

// IP框
final JTextField jtfip11 = new JTextField(18);
jtfip11.setBounds(50, 77, 58, 20);
jpanel.add(jtfip11);
jtfip11.setText("test");

JLabel jls51= new JLabel("编码:");
jls51.setBounds(125, 65, 50, 45);
jpanel.add(jls51);
jls51.setFont(fontGlobal);

// 端口框
final JTextField jtfport11 = new JTextField(15);
jtfport11.setBounds(150, 77,75, 20);
jpanel.add(jtfport11);
jtfport11.setText("utf-8");

final JButton linkBtn = new JButton("初始化DButils工具类");
linkBtn.setBounds(56, 111, 150, 20);
jpanel.add(linkBtn);
linkBtn.setMargin(new Insets(0,0,0,0));// 这样设置button中的字体与button无上下边距
linkBtn.setFont(fontGlobal);
MouseAdapter linkServerListener = new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
//linkClick(e);// 点击连接
String ip=jtfip.getText().trim();
int port=Integer.parseInt(jtfport.getText().trim());
String username=jtfip1.getText().trim();
String password=jtfport1.getText().trim();
String databaseName=jtfip11.getText().trim();
String code=jtfport11.getText().trim();

String mysqlDriver="com.mysql.jdbc.Driver";
String mysqlUrl="jdbc:mysql://"+ip+":"+port+"/"+databaseName
+"?unicode\\=true&characterEncoding\\="+code;

RegisterUtil.putStringSystemRoot("mysql.driver", mysqlDriver);
RegisterUtil.putStringSystemRoot("mysql.url", mysqlUrl);
RegisterUtil.putStringSystemRoot("mysql.username", username);
RegisterUtil.putStringSystemRoot("mysql.password", password);

System.out.println(RegisterUtil.getStringFromSystemRoot("mysql.driver"));

System.out.println(mysqlUrl);
System.out.println(username);
System.out.println(password);

try {
conn = DriverManager.getConnection(RegisterUtil.getStringFromSystemRoot("mysql.url"),
RegisterUtil.getStringFromSystemRoot("mysql.username"),
RegisterUtil.getStringFromSystemRoot("mysql.password"));
if(conn!=null)
{
linkBtn.setText("初始化成功！请关闭窗体");

}
} catch (Exception e2) {
// TODO: handle exception
}
//System.exit(0);
}
};
linkBtn.addMouseListener(linkServerListener);
}
/**
* @category close Connection
* @throws SQLException
*/
public static void close() throws SQLException {
conn.close();
connHolder.set(null);
}

public static int createTable(Class c) {
String tableName = c.getSimpleName().toLowerCase();// person
return 0;

}

/**
*
* @param c
*            参数例如Person.class
* @param obj
*            参数例如 person obj为某一实例对象 // Person person=new Person();
* @category 该方法用于向数据库中插入条数据 插入的对象是一个实体类的对象
*/
public static void insertEntity(Class c, Object obj) {
// System.out.println("1");
if (obj == null || c.getSimpleName().equals(obj.getClass().getName()))
return;
Field[] fields = obj.getClass().getDeclaredFields();
int fieldSize = fields.length;
String tableName = c.getSimpleName().toLowerCase();// person
String[] types1 = { "int", "java.lang.String", "boolean", "char",
"float", "double", "long", "short", "byte", "date" };
String[] types2 = { "java.lang.Integer", "java.lang.String",
"java.lang.Boolean", "java.lang.Character", "java.lang.Float",
"java.lang.Double", "java.lang.Long", "java.lang.Short",
"java.lang.Byte", "java.util.Date" };

StringBuffer sql = new StringBuffer("replace into " + tableName
+ " values(");
for (int i = 0; i < fieldSize; i++) {
sql.append("?,");
}
sql.deleteCharAt(sql.length() - 1);
sql.append(")");
System.out.println(sql);
PreparedStatement ps = null;
try {
ps = getConnection().prepareStatement(sql.toString());
for (int j = 0; j < fieldSize; j++) {
fields[j].setAccessible(true);
for (int i = 0; i < types1.length; i++) {
if (fields[j].getType().getName()
.equalsIgnoreCase(types1[i])
|| fields[j].getType().getName()
.equalsIgnoreCase(types2[i])) {

if (fields[j].get(obj) != null
&& !"".equals(fields[j].get(obj))
&& !"null".equals(fields[j].get(obj))) {
System.out.print(fields[j].getName() + ":"
+ fields[j].get(obj) + " ");
ps.setObject(j + 1, fields[j].get(obj));
} else {
System.out.print(fields[j].getName() + ":"
+ fields[j].get(obj) + " ");
ps.setObject(j + 1, null);
}
}
}
}
ps.executeUpdate();
getConnection().commit();
System.out.println("\nsql:" + ps.toString().split(":")[1].trim());
} catch (Exception e1) {
e1.printStackTrace();
}

}

/**
* @category 根据传入的主键值返回一个实体对象
* @param c
*            for example Person.class
* @param primaryKeys
*            primaryKeys为主键,参数顺序和表中保持一致 如果id， name 为主键 类名为Person 则
*            getEntity(Person.class,1,"name")
* @return Object
*/
public static Object getEntity(Class c, Object... primaryKeys) {
PreparedStatement ps = null;
ResultSet rs = null;
DatabaseMetaData dmd = null;
Object obj = null;// 要返回的对象
String tableName = c.getSimpleName().toLowerCase();// person 表的名字
List primaryKeyNameList = new ArrayList();// 存放从表中获取的主键
Field[] fields = c.getFields();// 获取所有的属性
Method[] methods = null;
if (fields.length == 0) {// 当类的属性都是private时
// fields=c.getDeclaredFields();//获取所有的private属性
methods = c.getDeclaredMethods();// 获取get set 方法
}
StringBuilder sql = new StringBuilder("select * from " + tableName
+ " where ");
try {
obj = c.newInstance();
if (!isTableExist(tableName)) {
System.err.println("表不存在");
return obj;
}
dmd = getConnection().getMetaData();
rs = dmd.getPrimaryKeys(null, null, tableName);
while (rs.next()) {// 获取所有的主键
sql.append(rs.getObject(4) + "=?");
sql.append(" and ");
primaryKeyNameList.add(rs.getObject(4));// 将从表中获取的 主键字段存到 list中，
// 主键位于表中第几列=rs.getString(5)
}
sql.delete(sql.length() - 4, sql.length());
if (!sql.toString().contains("where")) {
System.err.println("没有找到主键");
return obj;
}
ps = (PreparedStatement) getConnection().prepareStatement(
sql.toString());
for (int l = 0; l < primaryKeyNameList.size(); l++) {
ps.setObject(l + 1, primaryKeys[l]);
}
rs = ps.executeQuery();
System.out.println(ps.toString().split(":")[1]);
List<String> tableColumns = getColumns(c);
if (rs.next()) {
if (fields.length > 0) {// 如果类 的属性为public
for (int k = 0; k < fields.length; k++) {
fields[k].set(obj, rs.getObject(k + 1));
}
} else {// 如果类 的属性为private
for (int k = 0; k < methods.length; k++) {
for (int i = 0; i < tableColumns.size(); i++) {
if (methods[k].getName().equalsIgnoreCase(
"set" + tableColumns.get(i))) {
methods[k].invoke(obj,
rs.getObject(tableColumns.get(i)));
}
}
}
}
}
rs.close();
ps.close();
rs = null;
ps = null;
} catch (Exception e) {
e.printStackTrace();
} finally {

}
return obj;
}

/**
*
* @param tableName
*            标的名字
* @category 表不存在 1表存在
* @return 0表不存在 >=1表存在
*/
public static boolean isTableExist(String tableName) {
int v = getCount("SELECT count(table_name) FROM information_schema.TABLES WHERE table_name='"
+ tableName + "' ");
if (v >= 1) {
return true;
} else {
System.err.println("表 不存在 table not exist");
return false;
}
}

/**
*
* @category 获取某个表中所有的列名
* @param c
*            Person.class (类名与表名一致)
* @return List
*/
public static List<String> getColumns(Class c) {
List<String> list = new ArrayList<String>();
String tableName = c.getSimpleName().toLowerCase();// person 表的名字
if (!isTableExist(tableName)) {
System.err.println("talbe is not exist");
return list;
}
String sql = "select COLUMN_NAME from information_schema.columns where table_name='"
+ tableName + "'";
try {
ResultSet rs = getConnection().createStatement().executeQuery(sql);
while (rs.next()) {
if (!list.contains(rs.getString(1))) {
list.add(rs.getString(1));// 防止不同数据库中有相同的表名
}
}
} catch (Exception e) {
e.printStackTrace();
}
return list;
}

/**
* @category 返回数据库的名字
* @param Person
*            .class
* @return database name
*/
public static String getDatabaseName(Class c) {
String tableName = c.getSimpleName().toLowerCase();// person 表的名字
try {
ResultSet rs = getConnection().getMetaData().getPrimaryKeys(null,
null, tableName);
if (rs.next()) {
System.out.println("database:"+rs.getString(1));
return rs.getString(1);
}
} catch (Exception e) {
e.printStackTrace();
}
return null;
}

/**
* @category 返回 int auto_increment的下一个自增值
* @param c
*            Person。class
* @return int 下一个自增值 如果没有则返回null
*/
public static int getAutoIncremet(Class c) {
String tableName = c.getSimpleName().toLowerCase();// person 表的名字
if (!isTableExist(tableName)) {
System.err.println("表'" + tableName + "'不存在");
return -1;
}
try {
ResultSet rs = getConnection().prepareStatement(
"SELECT auto_increment FROM information_schema.`TABLES` WHERE TABLE_SCHEMA='"
+ getDatabaseName(c) + "' AND TABLE_NAME='"
+ tableName + "'").executeQuery();
if (rs.next()) {
return rs.getInt(1);
}
} catch (Exception e) {
e.printStackTrace();
}
return -1;
}

/**
* @category 查找某一列的所有值
* @param c
*            Person.class
* @param columnName
*            要查找的某一列的列名
* @return List<String> 返回某一列的所有值
*/
public static List<String> getColumnData(Class c, String columnName) {
if (!getColumns(c).contains(columnName)) {
System.err.println("列名'" + columnName + "'不存在");
return null;
}
List<String> list = new ArrayList<String>();
String tableName = c.getSimpleName().toLowerCase();// person 表的名字
if (!isTableExist(tableName)) {
System.err.println("talbe is not exist");
return list;
}
String sql = "select " + columnName + " from " + tableName;
try {
ResultSet rs = getConnection().createStatement().executeQuery(sql);
while (rs.next()) {
list.add(rs.getString(1));
}
} catch (Exception e) {
e.printStackTrace();
}
return list;
}

/**
* @category 根据条件查询 返回where columnName=value
* @param c
*            Person.class 且Person 所有的属性必须全为为public类型或者全部为private
* @param columnName
*            表中的某字段
* @param value
*            columnName对应的值
* @return List
*/
public static List getEntitys(Class c, String columnName, Object value) {
if (!getColumns(c).contains(columnName)) {
System.err.println("列名'" + columnName + "'不存在");
return null;
}
List list = new ArrayList();
PreparedStatement ps = null;
ResultSet rs = null;
String tableName = c.getSimpleName().toLowerCase();// person 表的名字
Field[] fields = c.getFields();// 获取所有的public属性
Method[] methods = null;
if (fields.length == 0) {
fields = c.getDeclaredFields();// 获取所有的private属性
methods = c.getDeclaredMethods();// 获取get set 方法
}
StringBuilder sql = new StringBuilder("select * from " + tableName
+ " where " + columnName + "=?");
try {
if (!isTableExist(tableName)) {
System.err.println("表不存在");
return list;
}
ps = (PreparedStatement) getConnection().prepareStatement(
sql.toString());
ps.setObject(1, value);
rs = ps.executeQuery();
System.out.println("\n" + ps.toString().split(":")[1]);
Object obj = null;
while (rs.next()) {
obj = c.newInstance();

if (fields.length > 0) {// 如果类 的属性为public
for (int k = 0; k < fields.length; k++) {
fields[k].setAccessible(true);
fields[k].set(obj, rs.getObject(k + 1));
}
} else {// 如果类 的属性为private
for (int k = 0; k < methods.length / 2; k++) {
methods[k * 2].invoke(obj, rs.getObject(k + 1));
}
}
list.add(obj);
}
rs.close();
ps.close();
} catch (Exception e) {
e.printStackTrace();
} finally {
rs = null;
ps = null;
}
return list;
}

/**
* @see 获取所有的数据
* @param c
*            Person.class
* @return List所有的数据
*/
public static List getAllEntitys(Class c) {
String tableName = c.getSimpleName().toLowerCase();// person 表的名字
if (!isTableExist(tableName)) {
System.err.println("表'" + tableName + "'不存在");
return null;
}
List list = new ArrayList();
PreparedStatement ps = null;
ResultSet rs = null;
Field[] fields = c.getFields();// 获取所有的public属性
if (fields.length == 0) {
// fields=c.getDeclaredFields();//获取所有的private属性
fields = c.getDeclaredFields();// 获取get set 方法
}
StringBuilder sql = new StringBuilder("select * from " + tableName);
try {
if (!isTableExist(tableName)) {
System.err.println("表不存在");
return list;
}
ps = (PreparedStatement) getConnection().prepareStatement(
sql.toString());
rs = ps.executeQuery();
System.out.println("\n" + ps.toString().split(":")[1]);
Object obj = null;
while (rs.next()) {
obj = c.newInstance();
for (int k = 0; k < fields.length; k++) {
fields[k].setAccessible(true);
fields[k].set(obj, rs.getObject(k + 1));
}
list.add(obj);
}
rs.close();
ps.close();
} catch (Exception e) {
e.printStackTrace();
} finally {
rs = null;
ps = null;
}
return list;

}

/**
* @see 获取数据中的某几条记录
* @param c
*            Person.class
* @param fromNumber
*            从数据库的第几条开始（0，1，2，3）
* @param number
*            从fromNumber开始获取多少行
* @return List
*/
public static List getEntitysLimit(Class c, int fromNumber, int number) {
String tableName = c.getSimpleName().toLowerCase();// person 表的名字
if (!isTableExist(tableName)) {
System.err.println("表'" + tableName + "'不存在");
return null;
}
List list = new ArrayList();
PreparedStatement ps = null;
ResultSet rs = null;
Field[] fields = c.getFields();// 获取所有的public属性
if (fields.length == 0) {
// fields=c.getDeclaredFields();//获取所有的private属性
fields = c.getDeclaredFields();// 获取get set 方法
}
StringBuilder sql = new StringBuilder("select * from " + tableName)
.append(" limit ?,?");
try {
if (!isTableExist(tableName)) {
System.err.println("表不存在");
return list;
}
ps = (PreparedStatement) getConnection().prepareStatement(
sql.toString());
ps.setInt(1, fromNumber);
ps.setInt(2, number);
rs = ps.executeQuery();
System.out.println("\n" + ps.toString().split(":")[1]);
Object obj = null;
while (rs.next()) {
obj = c.newInstance();
for (int k = 0; k < fields.length; k++) {
fields[k].setAccessible(true);
fields[k].set(obj, rs.getObject(k + 1));
}
list.add(obj);
}
rs.close();
ps.close();
} catch (Exception e) {
e.printStackTrace();
} finally {
rs = null;
ps = null;
}
return list;

}

/**
* @category 返回表中所有的主键
* @param c
*            Person.class
* @return list
*/
public static List<String> getPrimaryKeys(Class c) {
String tableName = c.getSimpleName().toLowerCase();// person 表的名字
ResultSet rs = null;
List<String> list = new ArrayList<String>();
try {
rs = getConnection().getMetaData().getPrimaryKeys(null, null,
tableName);
while (rs.next()) {
list.add(rs.getString(4));
}
} catch (Exception e) {
e.printStackTrace();
}
return list;
}

/**
* @category 根据主键删除数据
* @param c
*            Person.class
* @param primaryKey
*            按表中主键删除 如果主键为id。name
*            则deleteByPrimaryKey(Person.class,1,"ctl");
*/
public static void deleteByPrimaryKey(Class c, Object... primaryKey) {
String tableName = c.getSimpleName().toLowerCase();// person 表的名字
List<String> primaryKeysList = getPrimaryKeys(c);
StringBuilder sb = new StringBuilder("delete from " + tableName
+ " where ");
for (int i = 0; i < primaryKeysList.size(); i++) {
sb.append(primaryKeysList.get(i) + "=? and ");
}
sb.delete(sb.length() - 4, sb.length());
PreparedStatement ps = null;
try {
ps = getConnection().prepareStatement(sb.toString());
for (int i = 0; i < primaryKeysList.size(); i++) {
ps.setObject(i + 1, primaryKey[i]);
}
ps.executeUpdate();
getConnection().commit();
System.out.println(ps.toString().split(":")[1].trim());
} catch (Exception e) {
e.printStackTrace();
}

}

/**
* @see 删除列名为columnName列值为columnValue的数据
* @param c
*            Person.class
* @param columnName
*            列名
* @param columnValue
*            列名对应的值
*/
public static void deleteByColumn(Class c, String columnName,
Object columnValue) {
if (!getColumns(c).contains(columnName)) {
System.err.println("列名'" + columnName + "'" + "不存在");
return;
}
String tableName = c.getSimpleName().toLowerCase();// person 表的名字
StringBuilder sql = new StringBuilder("delete from ").append(tableName)
.append(" where ").append(columnName + "=?");
try {
PreparedStatement ps = getConnection().prepareStatement(
sql.toString());
ps.setObject(1, columnValue);
// ps.setObject(2,columnValue );
int result = ps.executeUpdate();
System.out.println(ps.toString().split(":")[1].trim());
if (result >= 1) {
getConnection().commit();
System.out.println("删除" + result + "条记录");
} else {
System.out.println("删除" + result + "条记录");
getConnection().rollback();
}
} catch (Exception e) {
System.err.println("delete error");
e.printStackTrace();
}
}

/**
* @category 从实体类对象中获取主键的列名和value 利用的是filed获取
* @param c
*            Person.class
* @param obj
*            实体对象
* @return 从数据库中获取主键 然后与实体类相匹配，返回对象中的主键名和值
*/
public static List<KeyValue> getEntityPrimaryKeyValueField(Class c,
Object obj) {
List<KeyValue> keyValues = new ArrayList<KeyValue>();
List<String> primaryKeys = getPrimaryKeys(c);
Field[] fields = c.getFields();// 获取所有的属性
for (int i = 0; i < fields.length; i++) {// 所有属性为public
try {
for (int j = 0; j < primaryKeys.size(); j++) {
if (primaryKeys.get(j)
.equalsIgnoreCase(fields[i].getName())) {
KeyValue kv = new KeyValue();
kv.setKey(fields[i].getName());
kv.setValue(fields[i].get(obj));
keyValues.add(kv);
System.out.println(fields[i].getName() + ":"
+ fields[i].get(obj));
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
if (fields.length == 0) {// 当类的属性都是private时
// fields=c.getDeclaredFields();//获取所有的private属性
fields = c.getDeclaredFields();// //获得对象所有属性
for (int i = 0; i < fields.length; i++) {
try {
fields[i].setAccessible(true);// 修改访问权限 可以访问private
for (int j = 0; j < primaryKeys.size(); j++) {
if (primaryKeys.get(j).equalsIgnoreCase(
fields[i].getName())) {
KeyValue kv = new KeyValue();
kv.setKey(fields[i].getName());
kv.setValue(fields[i].get(obj));// 读取属性值
keyValues.add(kv);
System.out.println(fields[i].getName() + ":"
+ fields[i].get(obj));
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
return keyValues;
}

/**
* @category 从实体类对象中获取主键的列名和value 利用的是Method get方法获取
* @param c
*            Person.class
* @param obj
*            实体对象
* @return 从数据库中获取主键 然后与实体类相匹配，返回对象中的主键名和值
*/
public static List<KeyValue> getEntityPrimaryKeyValueMethod(Class c,
Object obj) {
List<KeyValue> keyValues = new ArrayList<KeyValue>();
List<String> primaryKeys = getPrimaryKeys(c);
Field[] fields = c.getFields();// 获取所有的属性
for (int i = 0; i < fields.length; i++) {// 所有属性为public
try {
for (int j = 0; j < primaryKeys.size(); j++) {
if (primaryKeys.get(j)
.equalsIgnoreCase(fields[i].getName())) {
KeyValue kv = new KeyValue();
kv.setKey(fields[i].getName());
kv.setValue(fields[i].get(obj));
keyValues.add(kv);
System.out.println(fields[i].getName() + ":"
+ fields[i].get(obj));
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
if (fields.length == 0) {// 当类的属性都是private时
// fields=c.getDeclaredFields();//获取所有的private属性
fields = c.getDeclaredFields();// //获得对象所有属性
for (int i = 0; i < fields.length; i++) {
try {
fields[i].setAccessible(true);// 修改访问权限 可以访问private
for (int j = 0; j < primaryKeys.size(); j++) {
if (primaryKeys.get(j).equalsIgnoreCase(
fields[i].getName())) {
KeyValue kv = new KeyValue();
kv.setKey(fields[i].getName());
kv.setValue(fields[i].get(obj));// 读取属性值
keyValues.add(kv);
System.out.println(fields[i].getName() + ":"
+ fields[i].get(obj));
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
return keyValues;
}

/**
* @category 从实体类对象中按顺序获取所有主键的value
* @param c
*            Person.class
* @param obj
*            实体对象
* @return 从数据库中获取主键 然后与实体类相匹配，返回对象中的主键值
*/
public static List<Object> getEntityPKValues(Class c, Object obj) {
List<Object> keyValues = new ArrayList<Object>();
List<String> primaryKeys = getPrimaryKeys(c);
Field[] fields = c.getFields();// 获取所有的属性
for (int i = 0; i < fields.length; i++) {// 所有属性为public
try {
for (int j = 0; j < primaryKeys.size(); j++) {
if (primaryKeys.get(j)
.equalsIgnoreCase(fields[i].getName())) {
keyValues.add(fields[i].get(obj));
System.out.println(fields[i].getName() + ":"
+ fields[i].get(obj));
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
if (fields.length == 0) {// 当类的属性都是private时
// fields=c.getDeclaredFields();//获取所有的private属性
fields = c.getDeclaredFields();// //获得对象所有属性
for (int i = 0; i < fields.length; i++) {
try {
fields[i].setAccessible(true);// 修改访问权限 可以访问private
for (int j = 0; j < primaryKeys.size(); j++) {
if (primaryKeys.get(j).equalsIgnoreCase(
fields[i].getName())) {
keyValues.add(fields[i].get(obj));
System.out.println(fields[i].getName() + ":"
+ fields[i].get(obj));
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
return keyValues;
}

/**
* @see 如果有主键则执行更行，没有主键则执行插入操作
* @category 将实体类对象跟新到数据库中，如果对象中的属性与数据中不一致则更新，对象某属性为空则不更改该属性
* @param c
*            Person.class
* @param obj
*            person
*/
public static void updateEntity(Class c, Object obj) {
String tableName = c.getSimpleName().toLowerCase();// person 表的名字
List<String> primaryKeys = getPrimaryKeys(c);
List<KeyValue> keyValues = getEntityPrimaryKeyValueField(c, obj);
List<String> columns = getColumns(c);
List<Object> values = getEntityPKValues(c, obj);
Object tableDate = getEntity(c, values.toArray(new Object[] {}));
// System.out.println(o);
Field[] fields = c.getFields();// 获取所有的属性
System.out.println("数据库比对前:" + obj);
System.out.println("数据库中数据:" + tableDate);
for (int i = 0; i < fields.length; i++) {// 所有属性为public
try {
for (int j = 0; j < columns.size(); j++) {
if (columns.get(j).equalsIgnoreCase(fields[i].getName())) {
System.out.println(fields[i].getName() + ":"
+ fields[i].get(obj));
if (fields[i].get(obj) == null) {
fields[i].set(obj, fields[i].get(tableDate));
} else if (!fields[i].get(obj).equals(
fields[i].get(tableDate))) {
continue;
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
}

if (fields.length == 0) {// 当类的属性都是private时
// fields=c.getDeclaredFields();//获取所有的private属性
fields = c.getDeclaredFields();// //获得对象所有属性
for (int i = 0; i < fields.length; i++) {
try {
fields[i].setAccessible(true);// 修改访问权限 可以访问private
for (int j = 0; j < columns.size(); j++) {
if (columns.get(j)
.equalsIgnoreCase(fields[i].getName())) {
System.out.println(fields[i].getName() + ":"
+ fields[i].get(obj));
if (fields[i].get(obj) == null) {
fields[i].set(obj, fields[i].get(tableDate));
} else if (!fields[i].get(obj).equals(
fields[i].get(tableDate))) {
continue;
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
System.out.println("数据库比对后:" + obj);
insertEntity(c, obj);
}

public static void main(String[] args) {
Class c = null;
try {
c = Class.forName("com.ctl.bean.Person");
// c = Class.forName("com.ctl.bean.Test");
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(getAutoIncremet(c));
}

}