`

Java JDBC连接数据库,反射创建实体类对象并赋值数据库行记录(支持存储过程)

    博客分类:
  • JDBC
 
阅读更多
import java.lang.reflect.*;
import java.sql.*;
import java.util.*;

public class SqlHelper {
    // SQL Server
    /**
     * JDBC驱动名称
     */
    public static final String CLASS_NAME = "com.microsoft.sqlserver.jdbc.SQLServerDriver";
    /**
     * 数据库连库字符串
     */
    public static final String URL = "jdbc:sqlserver://192.168.1.254:1433;databaseName=BBSDB";
    /**
     * 用户名
     */
    public static final String UID = "sa";
    /**
     * 密码
     */
    public static final String PWD = "";
    /**
     * JDBC驱动类型
     */
    public static Class CLS = null;

    // Oracle
    // public static final String CLASS_NAME =
    // "oracle.jdbc.driver.OracleDriver";
    // public static final String URL =
    // "jdbc:oracle:thin:@localhost:1522:accp11g";
    // public static final String UID = "system";
    // public static final String PWD = "manager";
    /**
     * 获取数据库连接对象
     *
     * @return
     * @throws ClassNotFoundException
     * @throws SQLException
     */
    public static Connection getConnection() throws ClassNotFoundException,
            SQLException {
        if (CLS == null) {
            CLS = Class.forName(CLASS_NAME);
        }
        return DriverManager.getConnection(URL, UID, PWD);
    }

    /**
     * 执行SQL语句不返回查询的操作,返回受影响的行数
     *
     * @param sql
     *            SQL语句
     * @return 受影响的行数
     * @throws ClassNotFoundException
     * @throws SQLException
     */
    public static int executeNonQuery(String sql) {
        int result = -1;
        Connection con = null;
        PreparedStatement ps = null;
        try {
            con = getConnection();
            ps = con.prepareStatement(sql);
            result = ps.executeUpdate();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            close(con, ps, null);
        }
        return result;
    }

    /**
     * 执行Insert语句,返回Insert成功之后标识列的值
     *
     * @param sql
     * @return
     * @throws ClassNotFoundException
     * @throws SQLException
     */
    public static int executeIdentity(String sql) {
        int identity = -1;
        Connection con = null;
        Statement ps = null;
        ResultSet rs = null;
        try {
            con = getConnection();
            ps = con.createStatement();
            ps.executeUpdate(sql, Statement.RETURN_GENERATED_KEYS);
            rs = ps.getGeneratedKeys();
            if (rs.next()) {
                // identity = rs.getInt("GENERATED_KEYS");
                identity = rs.getInt(1);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            close(con, ps, null);
        }
        return identity;
    }

    /**
     * 执行不返回结果集的存储过程
     *
     * @param sql
     *            存储过程名称
     * @param params
     *            存储过程参数
     * @throws ClassNotFoundException
     * @throws SQLException
     */
    public static void executeNonQuery(String sql, SqlParameter... params) {
        Connection con = null;
        CallableStatement cs = null;
        try {
            con = getConnection();
            cs = con.prepareCall(sql);
            setSqlParameter(cs, params);
            cs.executeUpdate();
            getSqlParameter(cs, params);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            close(con, cs, null);
        }
    }

    /**
     * 执行返回聚合函数的操作
     *
     * @param sql
     *            含有聚合函数的SQL语句
     * @return 聚合函数的执行结果
     * @throws SQLException
     * @throws ClassNotFoundException
     */
    public static int executeScalar(String sql) {
        int result = -1;
        Connection con = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            con = getConnection();
            ps = con.prepareStatement(sql);
            rs = ps.executeQuery();
            if (rs.next()) {
                result = rs.getInt(1);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            close(con, ps, rs);
        }
        return result;
    }

    /**
     * 执行返回泛型集合的SQL语句
     *
     * @param cls
     *            泛型类型
     * @param sql
     *            查询SQL语句
     * @return 泛型集合
     * @throws ClassNotFoundException
     * @throws SQLException
     * @throws InstantiationException
     * @throws IllegalAccessException
     */
    public static <T> List<T> executeList(Class<T> cls, String sql) {
        List<T> list = new ArrayList<T>();
        Connection con = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            con = getConnection();
            ps = con.prepareStatement(sql);
            rs = ps.executeQuery();
            while (rs.next()) {
                T obj = executeResultSet(cls, rs);
                list.add(obj);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            close(con, ps, rs);
        }
        return list;
    }

    /**
     * 执行返回泛型集合的存储过程
     *
     * @param cls
     *            泛型类型
     * @param sql
     *            存储过程名称
     * @param params
     *            存储过程参数
     * @return 泛型集合
     * @throws ClassNotFoundException
     * @throws SQLException
     * @throws InstantiationException
     * @throws IllegalAccessException
     */
    public static <T> List<T> executeList(Class<T> cls, String sql,
            SqlParameter... params) {
        List<T> list = new ArrayList<T>();
        Connection con = null;
        CallableStatement cs = null;
        ResultSet rs = null;
        try {
            con = getConnection();
            cs = con.prepareCall(sql);
            setSqlParameter(cs, params);
            rs = cs.executeQuery();
            while (rs.next()) {
                T obj = executeResultSet(cls, rs);
                list.add(obj);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            close(con, cs, rs);
        }
        return list;
    }

    /**
     * 执行返回泛型类型对象的SQL语句
     *
     * @param cls
     *            泛型类型
     * @param sql
     *            SQL语句
     * @return 泛型类型对象
     * @throws SQLException
     * @throws ClassNotFoundException
     * @throws InstantiationException
     * @throws IllegalAccessException
     */
    public static <T> T executeEntity(Class<T> cls, String sql) {
        T obj = null;
        Connection con = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            con = getConnection();
            ps = con.prepareStatement(sql);
            rs = ps.executeQuery();
            while (rs.next()) {
                obj = executeResultSet(cls, rs);
                break;
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            close(con, ps, rs);
        }
        return obj;
    }

    /**
     * 执行返回泛型类型对象的存储过程
     *
     * @param cls
     *            泛型类型
     * @param sql
     *            SQL语句
     * @param params
     *            存储过程参数
     * @return 泛型类型对象
     * @throws SQLException
     * @throws ClassNotFoundException
     * @throws InstantiationException
     * @throws IllegalAccessException
     */
    public static <T> T executeEntity(Class<T> cls, String sql,
            SqlParameter... params) {
        T obj = null;
        Connection con = null;
        CallableStatement cs = null;
        ResultSet rs = null;
        try {
            con = getConnection();
            cs = con.prepareCall(sql);
            setSqlParameter(cs, params);
            rs = cs.executeQuery();
            while (rs.next()) {
                obj = executeResultSet(cls, rs);
                break;
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            close(con, cs, rs);
        }
        return obj;
    }

    /**
     * 将一条记录转成一个对象
     *
     * @param cls
     *            泛型类型
     * @param rs
     *            ResultSet对象
     * @return 泛型类型对象
     * @throws InstantiationException
     * @throws IllegalAccessException
     * @throws SQLException
     */
    private static <T> T executeResultSet(Class<T> cls, ResultSet rs)
            throws InstantiationException, IllegalAccessException, SQLException {
        T obj = cls.newInstance();
        ResultSetMetaData rsm = rs.getMetaData();
        int columnCount = rsm.getColumnCount();
        // Field[] fields = cls.getFields();
        Field[] fields = cls.getDeclaredFields();
        for (int i = 0; i < fields.length; i++) {
            Field field = fields[i];
            String fieldName = field.getName();
            for (int j = 1; j <= columnCount; j++) {
                String columnName = rsm.getColumnName(j);
                if (fieldName.equalsIgnoreCase(columnName)) {
                    Object value = rs.getObject(j);
                    field.setAccessible(true);
                    field.set(obj, value);
                    break;
                }
            }
        }
        return obj;
    }

    /**
     * 设置存储过程参数名称,参数值,参数方向
     *
     * @param cs
     * @param params
     * @throws SQLException
     */
    private static void setSqlParameter(CallableStatement cs,
            SqlParameter... params) throws SQLException {
        if (params != null) {
            for (SqlParameter param : params) {
                if (param.OutPut) {
                    String paramName = param.Name;
                    if (paramName == null || paramName.equals("")) {
                        cs.registerOutParameter(1, param.Type);// 设置返回类型参数
                    } else {
                        cs.registerOutParameter(paramName, param.Type);// 设置输出类型参数
                    }
                } else {
                    cs.setObject(param.Name, param.Value);// 设置输入类型参数
                }
            }
        }
    }

    /**
     * 得到存储过程参数执行结果
     *
     * @param cs
     * @param params
     * @throws SQLException
     */
    private static void getSqlParameter(CallableStatement cs,
            SqlParameter... params) throws SQLException {
        for (SqlParameter param : params) {
            if (param.OutPut) {
                String paramName = param.Name;
                if (paramName == null || paramName.equals("")) {
                    param.Value = cs.getObject(1);// 返回类型参数值
                } else {
                    param.Value = cs.getObject(paramName);// 输出类型参数值
                }
            }
        }
    }

    /**
     * 关闭JDBC对象,释放资源。
     *
     * @param con
     *            连接对象
     * @param ps
     *            命令对象
     * @param rs
     *            结果集对象
     * @throws SQLException
     */
    private static void close(Connection con, Statement ps, ResultSet rs) {
        try {
            rs.close();
            if (rs != null) {

                rs = null;
            }
            if (ps != null) {
                ps.close();
                ps = null;
            }
            if (con != null) {
                con.close();
                con = null;
            }
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}



类SqlParameter
/**
* 存储过程参数类型
* @author Administrator
*
*/
public class SqlParameter {
    /**
     * 参数名称
     */
    public String Name;
    /**
     * 参数值
     */
    public Object Value;
    /**
     * true表示参数为输出类型
     */
    public boolean OutPut;
    /**
     * 参数类型
     */
    public int Type;
    /**
     * 输入类型参数的构造函数
     * @param name 存储过程 输入类型 参数名称
     * @param value 存储过程 输入类型 参数值
     */
    public SqlParameter(String name,Object value){
        this.Name = name;
        this.Value= value;
    }
    /**
     * 输出类型参数的构造函数
     * @param type 存储过程 输出类型 参数类型
     * @param name 存储过程 输出类型 参数名称
     */
    public SqlParameter(int type,String name){
        this.Name = name;
        this.OutPut = true;
        this.Type = type;
    }
    /**
     * 返回类型参数的构造函数
     * @param type 存储过程 返回类型
     */
    public SqlParameter(int type){
        this.Name = "";
        this.OutPut = true;
        this.Type = type;
    }
}




类Program

import java.util.List;

public class Program {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
       
        String sql = "INSERT INTO [dbo].[UserInfo] ([UserName] ,[LoginName] ,[LoginPwd] ,[UserSex] ,[Birthday]) VALUES ('%s','%s','%s','%s','%s')";
        sql = String.format(sql, "wyp1","wyp1","wyp1","1","1981-04-21");
        int identyValue = SqlHelper.executeIdentity(sql);
        System.out.println(String.format("Identity Value:%d",identyValue));
       
//        List<UserInfo> list = SqlHelper.executeList(UserInfo.class, "select * from UserInfo");
//        for (UserInfo userInfo : list) {
//            System.out.println(String.format(
//                    "UserInfoId:%d,UserName:%s,LoginName:%s,LoginPwd:%s,UserSex:%s,Birthday:%s",
//                    userInfo.getUserInfoId(),userInfo.getUserName(),userInfo.getLoginName(),userInfo.getLoginPwd(),userInfo.getUserSex()?"男":"女",DateHelper.toString(userInfo.getBirthday())));
//        }
       
//        SqlParameter param = new SqlParameter("sortField", "[UserInfoId] DESC");
//        List<UserInfo> list = SqlHelper.executeList(UserInfo.class, "{call dbo.UserInfoSelectAll(?)}",param);
//        for (UserInfo userInfo : list) {
//            System.out.println(String.format(
//                    "UserInfoId:%d,UserName:%s,LoginName:%s,LoginPwd:%s,UserSex:%s,Birthday:%s",
//                    userInfo.getUserInfoId(),userInfo.getUserName(),userInfo.getLoginName(),userInfo.getLoginPwd(),userInfo.getUserSex()?"男":"女",DateHelper.toString(userInfo.getBirthday())));
//        }
       
//        SqlParameter paramSortField = new SqlParameter("sortField", "[UserInfoId] DESC");
//        SqlParameter paramPageSize = new SqlParameter("pageSize", 10);
//        SqlParameter paramPageIndex = new SqlParameter("pageIndex", 1);
//        SqlParameter paramWhere = new SqlParameter("where", "1=1");
//        List<UserInfo> list = SqlHelper.executeList(UserInfo.class, "{call dbo.UserInfoSelectByPagerParams(?,?,?,?)}",paramSortField,paramPageSize,paramPageIndex,paramWhere);
//        for (UserInfo userInfo : list) {
//            System.out.println(String.format(
//                    "UserInfoId:%d,UserName:%s,LoginName:%s,LoginPwd:%s,UserSex:%s,Birthday:%s",
//                    userInfo.getUserInfoId(),userInfo.getUserName(),userInfo.getLoginName(),userInfo.getLoginPwd(),userInfo.getUserSex()?"男":"女",DateHelper.toString(userInfo.getBirthday())));
//        }
       
//        SqlParameter paramWhere = new SqlParameter("where", "1=1");
//        SqlParameter paramRecordCount = new SqlParameter(java.sql.Types.INTEGER, "recordCount");
//        SqlHelper.executeNonQuery("{call dbo.UserInfoCountByWhere(?,?)}", paramWhere,paramRecordCount);
//        if(paramRecordCount.Value instanceof Integer){
//            Integer recordCount = (Integer)paramRecordCount.Value;
//            System.out.println(String.format("RecordCount:%d",recordCount));
//        }
       
//        SqlParameter paramWhere = new SqlParameter("where", "1=1");
//        SqlParameter paramRecordCount = new SqlParameter(java.sql.Types.INTEGER, "recordCount");
//        SqlParameter paramReturnValue = new SqlParameter(java.sql.Types.INTEGER);
//        SqlHelper.executeNonQuery("{? = call dbo.UserInfoCountByWhere(?,?)}", paramReturnValue,paramWhere,paramRecordCount);
//        if(paramRecordCount.Value instanceof Integer){
//            Integer recordCount = (Integer)paramRecordCount.Value;
//            System.out.println(String.format("RecordCount:%d",recordCount));
//        }
//        if(paramReturnValue.Value instanceof Integer){
//            Integer returnValue = (Integer)paramReturnValue.Value;
//            System.out.println(String.format("ReturnValue:%d",returnValue));
//        }
    }

}

分享到:
评论

相关推荐

    Java jdbc数据库连接池总结

    Java JDBC 数据库连接池总结 Java 语言中,JDBC(Java DataBase Connection)是应用程序与数据库沟通的桥梁。在 Web 应用开发的早期,主要使用的技术是 CGIASPPHP 等。之后,Sun 公司推出了基于 Java 语言的 ...

    java JDBC连接数据库代码大全

    JDBC(Java Database Connectivity)是一种标准的Java API,允许Java程序连接并操作各种类型的数据库。它为开发人员提供了一种统一的方式,以便使用相同的API来访问不同的数据库管理系统。 ##### JDBC驱动类型 ...

    JDBCjava 与数据库之间的链接

    JDBC java 与数据库之间的链接 java 与数据库之间的链接 java 与数据库之间的链接

    java使用jdbc将数据库数据导出到csv文件.pdf

    Java 是一种广泛使用的编程语言,它提供了多种方式来处理数据库数据,而 JDBC(Java Database Connectivity)是 Java 中连接数据库的标准 API 之一。将数据库数据导出到 CSV 文件是一种常见的数据交换格式,它可以被...

    Java中JDBC连接数据库详解

    Java中JDBC连接数据库详解是指Java程序使用JDBC(Java Database Connectivity)来连接和操作数据库的过程。JDBC是一种Java API,用于连接和操作数据库,它提供了一套标准化的接口,允许Java程序连接各种类型的数据库...

    完整java开发中JDBC连接数据库代码和步骤

    ### 完整Java开发中JDBC连接数据库代码和步骤 #### 一、概述 在Java开发过程中,通过Java Database Connectivity (JDBC) 连接数据库是非常常见的一种操作方式。JDBC提供了一组标准的API,使得Java应用程序可以访问...

    JDBC连接数据库步骤

    jdbc java 数据库 连接数据库 步骤

    JAVA反射机制和JDBC和各种数据库的连接

    总结来说,Java反射机制提供了运行时对类的动态访问和操作能力,而JDBC则是Java与数据库交互的桥梁,两者结合,可以在运行时动态地连接不同的数据库并进行数据操作,大大提高了代码的通用性和灵活性。

    JDBC连接数据库工具类

    JDBC连接数据库工具类 JDBC 连接数据库 ORACLE SQLSERVER MYSQL ORACLE 已测 OK 欢迎大家反馈 我的微博是: http://weibo.com/namenode

    java_jdbc数据库连接池总结

    解决多数据库服务器和多用户问题可以设计一个符合单例模式的连接池管理类,在连接池管理类的唯一实例被创建时读取一个资源文件,其中包含了不同的数据库连接信息。 Java JDBC 数据库连接池的优点包括: 1. 提高...

    JDBC连接数据库方法文档

    要连接数据库,需要向 java.sql.DriverManager 请求并获得 Connection 对象,该对象就代表一个数据库的连接。 使用 DriverManager 的 getConnection(String url, String username, String password) 方法传入指定的...

    Java连接数据库 JDBC封装类 带使用例子

    Java JDBC封装类,带增删改查例子,支持oracle,MySql,hsqldb 等,支持事务,返回数据格式 支持二维数组,MAP格式,以及javabean对象。有利于初学者DbDemo.java为demo,Connect为jdbc封装类,可以作为项目共通类使用。

    使用java,jdbc连接数据库和Java swing图形化界面完成一个商品管理系统.zip

    在这个名为“使用java,jdbc连接数据库和Java swing图形化界面完成一个商品管理系统.zip”的压缩包中,包含了使用Java编程语言,结合JDBC(Java Database Connectivity)接口与MySQL数据库,以及利用Java Swing构建...

    JDBC连接数据库步骤及代码

    - **单例模式**:为了确保每次获取的都是同一个数据库连接对象,这里使用了单例模式来创建`ConnectionTest`类的对象。 - **加载驱动**:使用`Class.forName()`方法加载Oracle JDBC驱动。 - **建立连接**:通过`...

    JAVA 通过JDBC连接数据库工具类

    JDBC连接数据库工具类 JDBC 连接数据库 ORACLE SQLSERVER MYSQL ORACLE 已测 OK 欢迎大家反馈

    jdbc连接数据库步骤

    JDBC(Java Database Connectivity)是Java语言中用于连接和操作数据库的应用程序接口。它定义了Java应用程序如何与数据库之间通信,允许用户执行SQL语句并获取结果。对于初学者来说,理解JDBC连接数据库的基本步骤...

    JDBC读取数据库元数据,自动生成JAVA实体类

    JDBC读取数据库元数据,生成JAVA实体类

    数据库实验8 java连接数据库(JDBC代码+报告)

    程序实现了使用Java语言编程实现对数据库的访问,所有的SQL操作均在自己建立的新库里进行,数据库建议选用学生课程数据库,可以选择进行创建、插入、查询、删除和更新等操作,其中查询操作可以按学号、姓名、专业...

    jdbc连接数据库类

    ### JDBC连接数据库类知识点解析 #### 一、JDBC简介 Java Database Connectivity (JDBC) 是 Java 中一种用于执行 SQL 语句的标准 API,它由一组用 Java 编程语言编写的类和接口组成。JDBC 可为多种关系型数据库...

Global site tag (gtag.js) - Google Analytics