JDBC框架

public class JdbcUtils {

// 表示定义数据库的用户名

private final String USERNAME = "root";

// 定义数据库的密码

private final String PASSWORD = "admin";

// 定义数据库的驱动信息

private final String DRIVER = "com.mysql.jdbc.Driver";

// 定义访问数据库的地址

private final String URL = "jdbc:mysql://localhost:3306/mydb";

// 定义数据库的链接

private Connection connection;

// 定义sql语句的执行对象

private PreparedStatement pstmt;

// 定义查询返回的结果集合

private ResultSet resultSet;

public JdbcUtils() {

try {

//注册驱动

Class.forName(DRIVER);

System.out.println("注册驱动成功!!");

} catch (Exception e) {

// TODO: handle exception

}

}

// 定义获得数据库的链接

public Connection getConnection() {

try {

//获得数据库连接

connection = DriverManager.getConnection(URL, USERNAME, PASSWORD);

} catch (Exception e) {

// TODO: handle exception

}

return connection;

}

/**

 * 完成对数据库的表的添加删除和修改的操作

 * 

 * @param sql

 * @param params???

 * @return

 * @throws SQLException

 */

public boolean updateByPreparedStatement(String sql, List<Object> params)

throws SQLException {

boolean flag = false;

int result = -1;// 表示当用户执行添加删除和修改的时候所影响数据库的行数

//获得执行SQL语句的对象

pstmt = connection.prepareStatement(sql);

int index = 1;//setObjet参数的第一个是从1开始的，即占位符的第一个位置

//判断所填充的占位符是否有值

if (params != null && !params.isEmpty()) {

for (int i = 0; i < params.size(); i++) {

//setObject填充占位符

pstmt.setObject(index++, params.get(i));//????

}

}

//返回结果要么是0要么是影响的行数

result = pstmt.executeUpdate();

flag = result > 0 ? true : false;

return flag;

}

/**

 * 查询返回单条记录

 * 

 * @param sql

 * @param params

 * @return

 * @throws SQLException

 */

public Map<String, Object> findSimpleResult(String sql, List<Object> params)

throws SQLException {

Map<String, Object> map = new HashMap<String, Object>();

int index = 1;//setObjet参数的第一个是从1开始的

//获得执行SQL语句的对象

pstmt = connection.prepareStatement(sql);

if (params != null && !params.isEmpty()) {

for (int i = 0; i < params.size(); i++) {

pstmt.setObject(index++, params.get(i));

}

}

resultSet = pstmt.executeQuery();// 返回查询结果

ResultSetMetaData metaData = resultSet.getMetaData();//返回结果集对象的列的相关信息

int col_len = metaData.getColumnCount();//返回对象的列数

//判断游标移动到下一行后是否还存在数据

while (resultSet.next()) {// 获得列的名称

//循环获得每列的列名和每行该列名所对应的值（判断是否有下一条记录）

for (int i = 0; i < col_len; i++) {

//先获得列名列名从1开始！！！

String cols_name = metaData.getColumnName(i + 1);

//由列名获得对象

Object cols_value = resultSet.getObject(cols_name);

//判断值是否为空，为空给空格

if (cols_value == null) {

cols_value = "";

}

//放入集合MAP中

map.put(cols_name, cols_value);

}

}

return map;

}

/**

 * 查询返回多行记录

 * 

 * @param sql

 * @param params

 * @return

 * @throws SQLException

 */

public List<Map<String, Object>> findMoreResult(String sql,

List<Object> params) throws SQLException {

//多条记录存放list+map

List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();

int index = 1;//setObject()第一参数从1开始

//获得执行SQL语句的对象

pstmt = connection.prepareStatement(sql);

if (params != null && !params.isEmpty()) {

for (int i = 0; i < params.size(); i++) {

pstmt.setObject(index++, params.get(i));

}

}

//执行查询语句并将结果集赋值给resultSet

resultSet = pstmt.executeQuery();

ResultSetMetaData metaData = resultSet.getMetaData();//获得列的相关信息

int cols_len = metaData.getColumnCount();

while (resultSet.next()) {

Map<String, Object> map = new HashMap<String, Object>();

for (int i = 0; i < cols_len; i++) {

String cols_name = metaData.getColumnName(i + 1);

Object cols_value = resultSet.getObject(cols_name);

if (cols_value == null) {

cols_value = "";

}

map.put(cols_name, cols_value);

}

list.add(map);

}

return list;

}

/*

 * jAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；

 * 对于任意一个对象，都能够调用它的任意一个方法和属性；

 * 这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

 * */

// jdbc的封装可以用反射机制来封装：

//定义范型

public <T> T findSimpleRefResult(String sql, List<Object> params,

Class<T> cls) throws Exception {

T resultObject = null;//返回对象

int index = 1;

//获得sql语句执行对象

pstmt = connection.prepareStatement(sql);

//设置占位符

if (params != null && !params.isEmpty()) {

for (int i = 0; i < params.size(); i++) {

pstmt.setObject(index++, params.get(i));

}

}

resultSet = pstmt.executeQuery();

//

ResultSetMetaData metaData = resultSet.getMetaData();

//

int cols_len = metaData.getColumnCount();

while (resultSet.next()) {

// 通过反射机制创建实例

resultObject = cls.newInstance();

for (int i = 0; i < cols_len; i++) {

String cols_name = metaData.getColumnName(i + 1);

Object cols_value = resultSet.getObject(cols_name);

if (cols_value == null) {

cols_value = "";

}

//通过列名来获得类的属性字段

Field field = cls.getDeclaredField(cols_name);

field.setAccessible(true);// 打开javabean的访问private权限

//第一个参数是需要改变字段的对象（由反射机制创建的实例） 第二个参数字段改变的值

field.set(resultObject, cols_value);

}

}

return resultObject;

}

/**

 * 通过反射机制访问数据库

 * 

 * @param <T>

 * @param sql

 * @param params

 * @param cls

 * @return

 * @throws Exception

 */

public <T> List<T> findMoreRefResult(String sql, List<Object> params,

Class<T> cls) throws Exception {

List<T> list = new ArrayList<T>();

int index = 1;

//获得执行SQL语句的对象

pstmt = connection.prepareStatement(sql);

//占位符

if (params != null && !params.isEmpty()) {

for (int i = 0; i < params.size(); i++) {

pstmt.setObject(index++, params.get(i));

}

}

//执行

resultSet = pstmt.executeQuery();

//获得列的相关信息

ResultSetMetaData metaData = resultSet.getMetaData();

int cols_len = metaData.getColumnCount();

//是否有下一条记录

while (resultSet.next()) {

//反射机制创建实例

T resultObject = cls.newInstance();

for (int i = 0; i < cols_len; i++) {

String cols_name = metaData.getColumnName(i + 1);

Object cols_value = resultSet.getObject(cols_name);

if (cols_value == null) {

cols_value = "";

}

//通过列名来获得类的属性字段

Field field = cls.getDeclaredField(cols_name);

// 打开javabean的访问private权限

field.setAccessible(true);

//设置反射对象的字段对应的值

field.set(resultObject, cols_value);

}

list.add(resultObject);

}

return list;

}

//数据库释放连接

public void releaseConn() {

//判断结果集是否为空

if (resultSet != null) {

try {

//不为空关闭结果集合

resultSet.close();

} catch (SQLException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

//判断SQL执行语句的对象是否为空

if (pstmt != null) {

try {

//不为空关闭

pstmt.close();

} catch (SQLException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

//判断连接是否为空

if (connection != null) {

try {

//不为空关闭

connection.close();

} catch (SQLException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

}

/**

 * @param args

 */

public static void main(String[] args) {

// TODO Auto-generated method stub

JdbcUtils jdbcUtils = new JdbcUtils();

jdbcUtils.getConnection();

// String sql = "insert into userinfo(username,pswd) values(?,?)";

// List<Object> params = new ArrayList<Object>();

// params.add("rose");

// params.add("123");

// try {

// boolean flag = jdbcUtils.updateByPreparedStatement(sql, params);

// System.out.println(flag);

// } catch (SQLException e) {

// // TODO Auto-generated catch block

// e.printStackTrace();

// }

String sql = "select * from userinfo ";

//List<Object> params = new ArrayList<Object>();

//params.add(1);

try {

List<UserInfo> list = jdbcUtils.findMoreRefResult(sql,

null, UserInfo.class);

System.out.println(list);

} catch (Exception e) {

// TODO: handle exception

} finally {

jdbcUtils.releaseConn();

}

}

}

实体类用于java反射机制

public class UserInfo implements Serializable {

/**

 * 

 */

//序列化

private static final long serialVersionUID = 1L;

private int id;

private String username;

private String pswd;

@Override

public String toString() {

return "UserInfo [id=" + id + ", username=" + username + ", pswd="

+ pswd + "]";

}

public int getId() {

return id;

}

public void setId(int id) {

this.id = id;

}

public String getUsername() {

return username;

}

public void setUsername(String username) {

this.username = username;

}

public String getPswd() {

return pswd;

}

public void setPswd(String pswd) {

this.pswd = pswd;

}

public static long getSerialversionuid() {

return serialVersionUID;

}

public UserInfo() {

// TODO Auto-generated constructor stub

}

}