JDBC

JDBC :java database connection java数据连接

* JDBC是java连接数据库的一个标准，该标准提供了大量接口，这些接口有厂商根据自身数据库的特点做实现，由用户进行接口方法的调用。用户根据接口调方法，可以屏蔽不同数据库的差异，无论连接什么数据库都是一套API
* 每一个实体Bean都具有属性，每一行数据都是一个对象，jdbc就是完成数据库数据和数据对象的转换，磁盘数据和内存数据的转换
* 数据库相关包存放在java.sql包中

Statement和PreparedStatement的区别

* Statement 是PreparedStatement的父接口。采用Statement执行SQL语句时，由于SQL语句的值一般由用户提供，所以只能采用拼接字符串的方式设置。这种随着值的不同，系统会做多次SQL语句的编译操作，所以效率低，而且容易引起SQL注入
* PerparedStatement提供了占位符机制，将需要设置的地方都用占位符表示，这样无论说什么值都是一个SQL语句，不会进行多次编译操作，效率高。而且无论值是什么，都会做字符串处理，不会引起SQL注入

什么是SQL注入
采用拼接字符串方式，拼接SQL语句时，如果值中有SQL语句的关键字或者特殊字符，可能导致预习了结果不正确，或者SQL语句语法错误，这就叫做SQL注入。解决SQL注入的方式就是采用，PreparedStatement 代替Statement

命名规范
dao: data access Object 数据对象通道。是一种架构模式，建立实体类和数据库表做映射。也就是哪个类对应哪个表，哪个属性对应哪个列。所以完成数据库操作的本质就是完成对象数据和关系数据的转换

代码演示
创建Bean类

package com.lovo.bean;
import java.sql.Date;
public class EmployeeBean {
      private int id;
      private String name;
      // 数据库操作，日期到sql包
      private Date birthday;
      private int money;
      private String dept;
      // id 为数据库自行配置数据，可以不做初始化
      public EmployeeBean(String name, Date birthday, int money, String dept) {
            super();
            this.name = name;
            this.birthday = birthday;
            this.money = money;
            this.dept = dept;
      }
      
      public EmployeeBean() {
            super();
            // TODO Auto-generated constructor stub
      }
      public int getId() {
            return id;
      }
      public void setId(int id) {
            this.id = id;
      }
      public String getName() {
            return name;
      }
      public void setName(String name) {
            this.name = name;
      }
      public Date getBirthday() {
            return birthday;
      }
      public void setBirthday(Date birthday) {
            this.birthday = birthday;
      }
      public int getMoney() {
            return money;
      }
      public void setMoney(int money) {
            this.money = money;
      }
      public String getDept() {
            return dept;
      }
      public void setDept(String dept) {
            this.dept = dept;
      }
      @Override
      public String toString() {
            return "EmployeeBean [id=" + id + ", name=" + name + ", birthday=" + birthday + ", money=" + money + ", dept="
                        + dept + "]";
      }
}

创建持久化接口

package com.lovo.dao;

import java.util.List;

import com.lovo.bean.EmployeeBean;

/**
 * 员工的持久化接口
 * @author zhihe
 *
 */
public interface IEmployeeDao {
      /**
       * 添加员工
       * @param emBean
       */
      public void add(EmployeeBean emBean);
      /**
       * 按指定的标号删除员工
       * @param id 员工id
       */
      public void del(int id);
      /**
       * 修改ID指定员工的工资
       *
       * @param id 员工ID
       * @param money 新工资
       */
      public void update(int money,int id);
      /**
       * 查询所有员工
       * @return 返回一个员工集合
       */
      public List<EmployeeBean> findAll();
      /**
       * 按姓名模糊查询员工
       * @param name 员工姓名
       * @return 员工集合
       */
      public List<EmployeeBean> findByName(String name);
      /**
       * 按员工id查询
       * @param id 员工id
       * @return 员工对象
       */
      public EmployeeBean findByID(int id);
}

创建接口实现类

package com.lovo.impl;

import java.sql.Connection;
import java.sql.Date;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

import com.lovo.bean.EmployeeBean;
import com.lovo.dao.IEmployeeDao;

/**
 * 员工的持久化接口实现类
 *
 * @author zhihe
 *
 */
public class EmployeeDaoImpl implements IEmployeeDao {

    @Override
    public void add(EmployeeBean emBean) {
        // 连接对象
        Connection con = null;
        // 预编译SQL语句的执行对象
        PreparedStatement ps = null;
        try {
            // 加载驱动
            Class.forName("org.gjt.mm.mysql.Driver");
            // 建立连接,第一个参数为URL,其中localhost表示连接主机的ip，3306表示连接数据库的端口
            // mydb为连接数据库的库名，root为mysql登录用户名，password为masql的登录密码
            con = DriverManager.getConnection("jdbc:mysql://localhost:3306/mydb?characterEncoding=utf-8", "root",
                    "password");

            // 执行SQL语句 问号为占位符，有四个值需要插入，
            ps = con.prepareStatement("insert into t_employee(employeeName,birthday,money,depName) values(?,?,?,?)");
            // 设置占位符，指明哪个占位符需要填充
            // 取出对象的属性，设置占位符,属性是什么需要用什么格式
            ps.setString(1, emBean.getName());
            ps.setDate(2, emBean.getBirthday());
            ps.setInt(3, emBean.getMoney());
            ps.setString(4, emBean.getDept());

            // 更新数据库,将数据真正写入数据库
            ps.executeUpdate();

        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            try {
                // 关闭连接，后建立，先关闭
                ps.close();
                con.close();
            } catch (SQLException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

        }

    }

    @Override
    public void del(int id) {
        //连接对象
        Connection con=null;
        //SQL语句预操作对象
        PreparedStatement ps=null;

        try {
            Class.forName("org.gjt.mm.mysql.Driver");
            //建立连接
            con=DriverManager.getConnection("jdbc:mysql://localhost:3306/mydb?charactorEncoding=utf-8","root","password");
            ps=con.prepareStatement("delete from t_employee where id=?");
            ps.setInt(1, id);
            ps.executeUpdate();


        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
            try {
                ps.close();
                con.close();
            } catch (SQLException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

        }


    }

    @Override
    public void update(int money, int id) {
        Connection con=null;
        PreparedStatement ps=null;
        try {
            Class.forName("org.gjt.mm.mysql.Driver");
            con=DriverManager.getConnection("jdbc:mysql://localhost:3306/mydb?charactorEncoding=utf-8","root","password");
            ps=con.prepareStatement("update t_employee set money=? where id=?");
            ps.setInt(2, id);
            ps.setInt(1, money);

            ps.executeUpdate();

        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
            try {
                ps.close();
                con.close();
            } catch (SQLException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

    }


    @Override
    public List<EmployeeBean> findAll() {
        // 查询操作，需读取数据库记录
        List<EmployeeBean> list=new ArrayList<EmployeeBean>();
        Connection con=null;
        PreparedStatement ps=null;
        //结果集对象
        ResultSet rs=null;
        try {
            Class.forName("org.gjt.mm.mysql.Driver");
            con=DriverManager.getConnection("jdbc:mysql://localhost:3306/mydb?charactorEncoding=utf-8","root","password");
            ps=con.prepareStatement("select*from t_employee");
            //得到结果对象
            rs=ps.executeQuery();
            //遍历结果集，将结果集指针不断指向下一条记录，如果没有记录rs.next（）返回false ,从而退出循环
            while(rs.next()){
                //每次循环，产生一个新对象,用于封装当前结果集指针指向的记录的数据
                EmployeeBean emBean=new  EmployeeBean();
                //从结果集中取出指定列的值，封装对象的属性值
                emBean.setId(rs.getInt("id"));
                emBean.setName(rs.getString("employeeName"));
                emBean.setBirthday(rs.getDate("birthday"));
                emBean.setMoney(rs.getInt("money"));
                emBean.setDept(rs.getString("depName"));

                //将封装了数据的实体对象加入集合
                list.add(emBean);
            }


        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
            try {
                //最先关闭结果集
                rs.close();
                ps.close();
                con.close();
            } catch (SQLException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

        }

        return list;
    }

    @Override
    public List<EmployeeBean> findByName(String name) {
        List<EmployeeBean>list=new ArrayList<EmployeeBean>();
        Connection con=null;
        PreparedStatement ps=null;
        ResultSet rs=null;

        try {
            Class.forName("org.gjt.mm.mysql.Driver");
            con=DriverManager.getConnection("jdbc:mysql://localhost:3306/mydb?charactorEncoding=utf-8","root","password");
            ps=con.prepareStatement("select*from t_employee where employeeName like ?");
            ps.setString(1, "%"+name+"%");
            rs=ps.executeQuery();
            while(rs.next()){
                EmployeeBean emBean=new EmployeeBean();
                emBean.setId(rs.getInt("id"));
                emBean.setName(rs.getString("employeeName"));
                emBean.setBirthday(rs.getDate("birthday"));
                emBean.setMoney(rs.getInt("money"));
                emBean.setDept(rs.getString("depname"));

                list.add(emBean);
            }

        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
            try {
                rs.close();
                ps.close();
                con.close();
            } catch (SQLException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

        }

        return list;
    }

    @Override
    public EmployeeBean findByID(int id) {
        // 返回集合建集合，返回对象建对象
        EmployeeBean emBean=new EmployeeBean();

        Connection con=null;
        PreparedStatement ps=null;
        ResultSet rs=null;

        try {
            Class.forName("org.gjt.mm.mysql.Driver");
            con=DriverManager.getConnection("jdbc:mysql://localhost:3306/mydb?charactorEncoding=utf-8","root","password");
            ps=con.prepareStatement("select*from t_employee where id=?");
            ps.setInt(1, id);
            rs=ps.executeQuery();
            if(rs.next()){
                emBean.setId(rs.getInt("id"));
                emBean.setBirthday(rs.getDate("birthday"));
                emBean.setName(rs.getString("employeeName"));
                emBean.setMoney(rs.getInt("money"));
                emBean.setDept(rs.getString("depName"));

            }


        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
            try {
                rs.close();
                ps.close();
                con.close();
            } catch (SQLException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

        }

        return emBean;
    }


    //测试添加是否成功
    public static void main(String[] args) {
        IEmployeeDao dao = new EmployeeDaoImpl();
//        dao.add(new EmployeeBean("aaa", Date.valueOf("1988-02-02"), 2000, "市场部"));
//        dao.del(10);
//        dao.update(4000, 2);
//        List<EmployeeBean>list=dao.findAll();
        //系统有重写List集合的toString 方法，所以可以直接打印
//        List<EmployeeBean>list=dao.findByName("张");
//        System.out.println(list);
        EmployeeBean emBean=dao.findByID(3);
        System.out.println(emBean);
    }
}