mysql与eclipse连接以及封装过程

mysql基本的连接方式（六大步骤）
这里使用的是mysql-connector-java-5.1.39-bin.jar包，先做导入操作

//1.加载数据库提供商的驱动
        Class.forName("com.mysql.jdbc.Driver");
//      DriverManager.registerDriver(new com.mysql.jdbc.Driver());
//      DriverManager.registerDriver(new Driver());     //需要导包import com.mysql.jdbc.Driver;
        //2.获取数据库连接对象
        Connection conn = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/mydatabase", 
                "root", "root");
        System.out.println(conn);
        //3.获取处理命令(用于处理SQL语句)
        Statement stmt = conn.createStatement();

        //4.发送执行SQL命令
        boolean b = stmt.execute("create table user("
                + "id int,"
                + "name varchar(32)"
                + ");"
                );

        //5.处理执行结果
        System.out.println(b);

        //6.回收资源
        stmt.close();

由于上述过程中对于SQL语句的处理是属于拼接式的处理，在刻意的情况下是很容易发生SQL注入的问题。
举个例子：在进行用户名登录检测的时候，用户输入的username=任意字符串，password=（‘ ， ’1 = 1）为括号内的内容，此时该SQL语句在拼接完成后
select * from tb_user where username = 'a123' and password = ' ' , 1 = 1 ' ';
由于上述语句存在1=1，所以存在着很大的问题。此时采用另一种模式。

将上述步骤的第三四步改为下述形式
pps = cnnt.prepareStatement("insert into user(username,password) values(?,?)");
pps.setString(1, uname);
pps.setString(2, upwd);
int i = pps.executeUpdate();
//ResultSet rs = pps.executeQuery()
先进行预处理，然后对其进行运行操作，保证了SQL语句的安全。
这里的executeUpdate()，用于做修改操作，返回值是int类型的操作行数，即修改行数
executeQuery()做查询操作，返回一个结果集

但是由于每次连接数据库对其做操作都需要连接是一件很麻烦的事情，所以接下来介绍一种封装的操作，来简化连接。
java封装代码

private static String DIRVER;
    private static String URL;
    private static String USER;
    private static String PASSWORD;

    static {
        try {
            Properties pps = System.getProperties();
            pps.load(new FileInputStream("src/jdbc.properties"));
            DIRVER = pps.getProperty("driver");
            URL = pps.getProperty("url");
            USER = pps.getProperty("user");
            PASSWORD = pps.getProperty("password");
            Class.forName(DIRVER);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    /**
     * 封装数据库连接
     * 
     * @return
     */
    public static Connection getConn() {
        try {
            return DriverManager.getConnection(URL, USER, PASSWORD);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 封装资源回收
     * 
     * @param rs
     * @param stat
     * @param conn
     */
    public static void close(ResultSet rs, Statement stat, Connection conn) {
        try {
            if (rs != null)
                rs.close();
            if (stat != null)
                stat.close();
            if (conn != null)
                conn.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        System.out.println(getConn());
    }

读取的文件信息

###mysql connection information####
driver = com.mysql.jdbc.Driver
url = jdbc:mysql://127.0.0.1:3306/mydatabase
user = root
password = root

文件信息的作用是，当每次更换数据库时，可以直接在配置文件里修改即可，不用动java代码，这里以键值对的形式存储。放在同一src目录下即可。
这个时候我们的数据库连接只需调用getconn()方法就好了

Connection conn = JDBCconnection.getConn();

当然数据库封装完成后，每次写连接会变得非常方便，当然我们还可以继续封装，将修改和查询操作做一个封装，之后使用起来会更方便。
接下来是修改的封装操作

public static boolean execUpdate(Connection conn,String sql,Object ...objs){
        try {
            PreparedStatement ps = conn.prepareStatement(sql);
            for (int i = 0; i < objs.length; i++) {
                ps.setObject(i+1, objs[i]);
            }
            int i = ps.executeUpdate();
            return i>0 ? true:false;
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return false;
    }

返回值是一个操作结果，这里的Object…objs是一个对象数组，但是是自定义长度。
封装完成后，我们的修改操作将会非常简单。

// 添加操作
    public boolean insert(User user) throws SQLException {
        Connection conn = JDBCconnection.getConn();
        return DAOHelper.execUpdate(conn, "insert into tbuser(username,password) values(?,?)", user.getUsername(),user.getPassword());
    }

当然查询操作也是可以进行封装的，但是这里有一个小小的问题需要解决，那就是对于查询的结果我们是无法处理的，需要在使用的时候才知道具体的处理操作，类似按钮的监听，只有当点击时才知道需要进行什么操作。所以我们利用了回调和内部类来实现。

public static <T> List<T> queryList(String sql,CallBack<T> call,Object...params){
        Connection conn = DBConnection.getConn();
        PreparedStatement ps = null;
        try {
            ps = conn.prepareStatement(sql);
            for(int i = 0;i<params.length;i++)
            {
                ps.setObject(i+1, params[i]);
            }
            ResultSet rs = ps.executeQuery();
            return call.getDatas(rs);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return null;
    }
    public interface CallBack<T>{
        List<T> getDatas(ResultSet rs){
    }

这样就可以了，具体思想和上一个差不多。
mysql和eclipse的连接封装就差不多啦，当然还有很多更好的，之后会进行补充，如果有想法也可以进行留言，都会看的，谢谢。