什么是DAO

Data Access Object(数据存取对象)，位于业务逻辑和持久化数据之间。DAO的作用是实现对持久化数据的访问，作为转换器将数据在实体类和数据库记录之间进行转换。

DAO模式

1、DAO接口

public interface BaseDAO {
      void getConn(String driver, String url, String user, String pwd);
      void query(String sql, String... params);
      boolean update(String sql, String... params);
      void close();
  }

2、DAO实现类

public class BaseDAOImpl implements BaseDAO {
      private Connection conn;
      private PreparedStatement pst;
      private static ResultSet rs;
   public ResultSet getRs() {
      return rs;
  }
  @Override
  public void getConn(String driver, String url, String user, String pwd) {
      try {
          Class.forName(driver);
      } catch (ClassNotFoundException e) {
          e.printStackTrace();
      }
      try {
          conn = DriverManager.getConnection(url, user, pwd);
      } catch (SQLException e) {
          e.printStackTrace();
      }
  }
  @Override
  public void query(String sql, String... params) {
      try {
          pst = conn.prepareStatement(sql);
          for (int i = 0; null != params && i < params.length; i++) {
              pst.setObject(i + 1, params[i]);
          }
          rs = pst.executeQuery();
      } catch (SQLException e) {
          e.printStackTrace();
      }
  }
  @Override
  public boolean update(String sql, String... params) {
      int num = 0;
      try {
          pst = conn.prepareStatement(sql);
          for (int i = 0; null != params && i < params.length; i++) {
              pst.setObject(i + 1, params[i]);
          }
          num = pst.executeUpdate();
      } catch (SQLException e) {
          e.printStackTrace();
      }
      return num > 0 ? true : false;
  }
  @Override
  public void close() {
      try {
          if (null != rs) {
              rs.close();
          }
          if (null != pst) {
              pst.close();
          }
          if (null != conn) {
              conn.close();
          }
      } catch (SQLException e) {
          e.printStackTrace();
      }
  }
 
 }

3、实体类student

public class Student {
      private int stu_id;
      private String stu_name;
      private int grade_id;
      private String gender;
      private String address;
      private String phone;
      private String IDCard;
   @Override
  public String toString() {
      return "Student{" +
          "stu_id=" + stu_id +
          ", stu_name='" + stu_name + '\'' +
          ", grade_id=" + grade_id +
          ", gender='" + gender + '\'' +
          ", address='" + address + '\'' +
          ", phone='" + phone + '\'' +
          ", IDCard='" + IDCard + '\'' +
          '}';
  }
  public int getStu_id() {
      return stu_id;
  }
  public void setStu_id(int stu_id) {
      this.stu_id = stu_id;
  }
  public String getStu_name() {
      return stu_name;
  }
  public void setStu_name(String stu_name) {
      this.stu_name = stu_name;
  }
  public int getGrade_id() {
      return grade_id;
  }
  public void setGrade_id(int grade_id) {
      this.grade_id = grade_id;
  }
  public String getGender() {
      return gender;
  }
  public void setGender(String gender) {
      this.gender = gender;
  }
  public String getAddress() {
      return address;
  }
  public void setAddress(String address) {
      this.address = address;
  }
  public String getPhone() {
      return phone;
  }
  public void setPhone(String phone) {
      this.phone = phone;
  }
  public String getIDCard() {
      return IDCard;
  }
  public void setIDCard(String IDCard) {
      this.IDCard = IDCard;
  }
 
 }

4、业务逻辑代码

public class StudentDao extends BaseDAOImpl {
      private final String DRIVER = "com.mysql.jdbc.Driver";
      private final String URL = "jdbc:mysql://192.168.232.234:3306/test";
   public Student getStudentById(String id) {
      String sql = "select * from student where stu_id=?";
      getConn(DRIVER, URL, "root", "ok");
      query(sql, id);
      ResultSet rs = getRs();
      Student s = new Student();
      try {
          if (rs.next()) {
              s.setStu_id(rs.getInt("stu_id"));
              s.setStu_name(rs.getString("stu_name"));
              s.setGrade_id(rs.getInt("grade_id"));
              s.setGender(rs.getString("gender"));
              s.setAddress(rs.getString("address"));
              s.setPhone(rs.getString("phone"));
              s.setIDCard(rs.getString("IDCard"));
          }
      } catch (SQLException e) {
          e.printStackTrace();
      } finally {
          close();
      }
      return s;
  }
  public void insertStudent() {
      String sql = "insert into student(stu_id, stu_name, grade_id) values(15, ?, ?)";
      getConn(DRIVER, URL, "root", "ok");
      Boolean flag = update(sql, "777", "1");
      System.out.println(flag ? "插入成功" : "插入失败");
      close();
  }
  public static void main(String[] args) {
      StudentDao dao = new StudentDao();
      Student student = dao.getStudentById("2");
      System.out.println(student);
      StudentDao dao = new StudentDao();
      dao.insertStudent();
      Student student = dao.getStudentById("15");
      System.out.println(student);
  }
 
 }

单例模式

为什么需要单例模式

BaseDAO: 操作数据库的基类。每个线程对系统操作都需new一个BaseDAO实例。初始化时的I/O操作消耗系统资源，影响系统性能。对于每个线程，可共享一个实例。

单例模式概念

系统运行期间，有且仅有一个实例。一个类只有一个实例——最基本的要求。只提供私有构造器。它必须自行创建这个实例。定义了静态的该类私有对象。它必须自行向整个系统提供这个实例。提供一个静态的公有方法，返回创建或者获取本身的静态私有对象。

单例模式-懒汉式

在类加载时不创建实例，采用延迟加载的方式，在运行调用时创建实例。特点：线程不安全，延迟加载（lazy loading）。

public class TestSingle {
    private static TestSingle t = null;
    public synchronized static TestSingle newInstance() {
        if (t == null) {
            t = new TestSingle();
        }
        return t;
    }
    private TestSingle() {}
    public static void main(String[] args) {
        TestSingle ts = newInstance();
        System.out.println(ts);
        TestSingle ts2 = newInstance();
        System.out.println(ts2);
    }
}

单例模式-饿汉式

在类加载的时候，就完成初始化。特点：线程安全，不具备延迟加载特性。

public class TestSingle2 {
    private static TestSingle2 ts = null;
    private TestSingle2() {}
    static {
        ts = new TestSingle2();
    }
    public static TestSingle2 getInstance() {
        return ts;
    }
    public static void main(String[] args) {
        TestSingle2 ts1 = getInstance();
        System.out.println(ts1);
        TestSingle2 ts2 = getInstance();
        System.out.println(ts2);
    }
}

配置文件存储数据库信息

数据库发生改变时，要重新修改代码，重新编译和部署。将数据库信息写在配置文件当中，让程序通过读取配置文件来获得这些信息。配置文件-属性文件 .properties 后缀 键值对。

读取数据库属性文件，获取数据库连接信息。新建db.properties 文件。

public class Prop {
    static Properties p = new Properties();
    static {
        try {
            p.load(new FileInputStream("resource/db.properties"));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public static String getValues(String key) {
        return p.getProperty(key);
    }
    public static void main(String[] args) {
        System.out.println(Prop.getValues("driver"));
    }
}

如果不停地创建实例去加载文件，会占用资源，可以使用单例模式。

public class Prop {
    private static Prop prop;
    private static Properties p = new Properties();
    private Prop() {
        try {
            p.load(new FileInputStream("resource/db.properties"));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    static {
        prop = new Prop();
    }
    public static Prop getInstance() {
        return prop;
    }
    public static String getValues(String key) {
        return p.getProperty(key);
    }
    public static void main(String[] args) {
        System.out.println(Prop.getInstance());
        System.out.println(Prop.getInstance());
        System.out.println(Prop.getInstance().getValues("url"));
        System.out.println(Prop.getInstance().getValues("driver"));
    }
}