Oracle JDBC 详解类实现方法介绍 封装增删改查方法

Oracle JDBC

介绍：

Java DataBase Connectivity java与数据库连接。

java通过jdbc这个连接，连接数据库，操作数据库。所以java 制定了标准 ，不同的数据库厂商实现 接口即可。

java 中提供的接口 java.sql.* 包下，常用接口如下。

接口名称	功能
java.sql.Connection	连接
java.sql.Statement	sql静态处理块
java.sql.PreparedStatement	sql预处理块
java.sql.ResultSet	结果集
java.sql.ResultSetMetaData	结果集元信息

连接前提，环境

Oracle数据库:

https://blog.csdn.net/xiaoliang98/article/details/109407665

数据库加载器：

F:\app\Administrator\product\11.2.0\dbhome_1\jdbc\li b\ojdbc6.jar 视安装路径而定

常用类介绍

java.sql.Connection

接口方法	作用
Statement createStatement()	得到该连接的静态处理块
PreparedStatement prepareStatement(String sql)	得到该连接的预处理块
void setAutoCommit(boolean autoCommit)	设置事务是否自动提交 true自动false手动
boolean getAutoCommit()	得到该连接的提交属性
void commit()	提交事务
void close()	关闭连接
void rollback()	回滚事务
boolean isClosed()	连接是否关闭

Statement与PreparedStatement的区别

Statement：是直接给sql语句，必须在String sql中拼接成完整的sql语句，然后直接sql语句执行。

PreparedStatement：后期拼接通过？,后期注入需要拼接的属性值，而且多了一层检验。避免了sql语句的注入。因为拼接过程只能填写值，若检测到sql语句则阻止注入。

java.sql.Statement

接口方法	作用
ResultSet executeQuery(String sql)	返回结果集
int executeUpdate(String sql)	返回修改行数
void close()	关闭sql静态处理块

java.sql.PreparedStatement

接口方法	作用
ResultSet executeQuery( )	返回结果集
int executeUpdate( )	返回修改行数
void setNull(int parameterIndex, int sqlType)	赋值为空
void set基本类型(int parameterIndex, 基本类型 x)	给n个？赋值
void close()	关闭sql静态处理块

java.sql.ResultSet

接口方法	作用
boolean next()	与迭代器类似
void close()	关闭结果集
boolean wasNull()	结果集是否为空
String get基本类型(int columnIndex)	得到索引的属性

java.sql.ResultSetMetaData 表结构信息

接口方法	作用
int getColumnCount()	表格的列数
String getColumnName(int column)	获取列名
String getTableName(int column)	获取该列的表名

获取表名我傻了。我找不到。

jdbc.properties

DRIVERS=oracle.jdbc.driver.OracleDriver
URL=jdbc:oracle:thin:@localhost:1521:MyOra
USER=user
PASSWORD=123456

常规的jdbc

public class JdbcUtil {
    private static Connection conn;
    private static Properties properties=new Properties();
    /**
     * 预先加载驱动 配置文件
     */
    static {
        try {
            properties.load(JdbcUtil.class.getClassLoader().getResourceAsStream("jdbc.properties"));
        } catch (IOException e) {
            System.out.println("配置文件加载错误");
            e.printStackTrace();
        }
        try {
            Class.forName(properties.getProperty("driver"));
        } catch (ClassNotFoundException e) {
            System.out.println("驱动加载错误");
            e.printStackTrace();
        }
    }

    //获取配置文件的值
    private static String url=properties.getProperty("url");
    private static String name=properties.getProperty("username");
    private static String pwd=properties.getProperty("password");

    //连接数据库
    public Connection getConn(){
        try {
            conn=DriverManager.getConnection(url,name,pwd);
        } catch (SQLException e) {
            System.out.println("url 用户 密码 错误 数据库连接失败。");
            e.printStackTrace();
        }
        System.out.println("连接成功");
        return conn;
    }

    //关闭连接
    public void close(){
        if(conn!=null){
            conn=null;
        }
    }
}

package ppl.com.jdbc;

public class Jdbc {
    protected Connection conn =null;
    protected PreparedStatement state =null;//预封装sql语句 加入判断
    protected ResultSet result =null;

    //传入sql conn 连接赋值  state 封装SQL语句
    protected void init(String sql){
        JdbcUtil jdbcUtil=new JdbcUtil();
        conn =jdbcUtil.getConn();
        try {
            state=conn.prepareStatement(sql);
            conn.setAutoCommit(false);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    //关闭所有连接
    protected void allClose(){
        if(result !=null){
            try {
                result.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if(state !=null){
            try {
                state.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if(conn !=null){
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

封装后的jdbc 代码不全

package ppl.com.baseUtil;

public interface InterJdbc {
    /**
     * 更新数据
     * @param sql
     * @param objs  可变参数列表
     * @return
     */
    boolean update(String sql,Object... objs);

    /**
     * 查找数据
     * @param obj
     * @param sql
     * @param objs
     * @return
     */
    List<Object> select(Object obj,String sql,Object... objs);

    /**
     * 插入语句
     * @param sql
     * @param objs
     * @return
     */
    boolean insert(String sql,Object... objs);

    /**
     * 删除数据
     * @param sql
     * @param objs
     */
    void delete(String sql,Object... objs);
}

package ppl.com.baseUtil;

public class JdbcBase extends Jdbc implements InterJdbc {

    /**
     * 更新数据
     *
     * @param sql
     * @param objs 可变参数列表
     * @return
     */
    @Override
    public boolean update(String sql, Object... objs) {
        boolean T=false;
        setSql(sql,objs);

        try {
            state.executeUpdate();
            conn.commit();
            T=true;
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            try {
                conn.rollback();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        return T;
    }

    /**
     * 查找数据
     *
     * @param classname
     * @param sql
     * @param objs
     * @return
     */
    @Override
    public List<Object> select(Object classname, String sql, Object... objs) {
        setSql(sql,objs);
        try {
            result = state.executeQuery();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return getList(result,classname);
    }
    /**
     * 插入语句
     *
     * @param sql
     * @param objs
     * @return
     */
    @Override
    public boolean insert(String sql, Object... objs) {
        return update(sql,objs);
    }

    /**
     * 删除数据
     *
     * @param sql
     * @param objs
     */
    @Override
    public void delete(String sql, Object... objs) {
        update(sql,objs);
    }

    /**
     * 将resultSet集 赋值给List<T>
     * @param resultSet
     * @param t
     * @return
     */
    public List<Object> getList(ResultSet resultSet,Object  t){
        List<Object> list=new ArrayList<>();
        Class<?> aClass = t.getClass();
        try {
                while (resultSet.next()){
                    Object o = aClass.newInstance();
                    Field[] fields = aClass.getDeclaredFields();
                    for (Field field : fields) {
                        field.setAccessible(true);
                        field.set(o,resultSet.getObject(field.getName()));
                    }
                    list.add(o);
                }
            } catch (Exception e) {
                e.printStackTrace();
        }
        allClose();
        return list;
    }

    private void setSql(String sql, Object... objs){
        init(sql);
        if(objs!=null&&objs.length>0){
            for (int i = 1; i <=objs.length ; i++) {
                try {
                    state.setObject(i,objs[i-1]);
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}