DAO模式、单例模式

什么是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";
    //根据学生id查询所有信息
    public Student getStudnetById(String id){
        String sql="select * from student where stu_id=?";
        getConn(DRIVER,URL,"root","ok");
        query(sql,id);
        ResultSet rs=getRs();
        //Data Access Object
        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.getStudnetById("2");
        System.out.println(student);
//        StudentDao dao =new StudentDao();
//        dao.insertStudent();
//        Student student=dao.getStudnetById("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 {
    //java提供了Properities类
    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) {
        //通过属性文件key来获取值
        return p.getProperty(key);
    }
    public static void main(String[] args) {
        System.out.println(Prop.getValues("driver"));
    }
}

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

public class Prop {
    private static Prop prop;
    //java提供了Properities类
    private static Properties p =new Properties();
    //文件只加载一次 可以放到static里面
    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) {
        //通过属性文件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"));
    }
}