死磕设计模式-设计模式总览

死磕设计模式-设计模式总览

为什么要学习设计模式

1、能够写出优雅的代码

2、能够帮助我们更好的重构代码

如果用好了设计模式就是架构师，如果用不好设计模式就是码农

回顾一下设计原则

开闭原则

对扩展开放，对修改关闭

单一职责原则

​ 一个类一个接口或者是一个方法，自干一件事

依赖倒置原则

​ 通过抽象使各个类或者模块之间相互不影响，实现松耦合

接口隔离原则定义

​ 尽量保证接口的纯洁性，客户端不应该依赖不需要的接口

迪米特法则

​ 又叫最少知道原则，一个类对其所依赖的类知道的越少越好

里氏替换原则

​ 子类可以扩展父类的功能，但不能改变父类原有的功能

合成复用原则

​ 尽量使用对象组合，聚合，而不使用继承关系达到代码复用的目的

设计模式总览

写出优雅的代码

public void setCurForm(Gw_exammingForm curForm,String parameters)throws BaseException {
      JSONObject jsonObj = new JSONObject(parameters);
      //试卷主键
      if(jsonObj.getString("examinationPaper_id")!= null && (!jsonObj.getString("examinationPaper_id").equals("")))
         curForm.setExaminationPaper_id(jsonObj.getLong("examinationPaper_id"));
      //剩余时间
      if(jsonObj.getString("leavTime") != null && (!jsonObj.getString("leavTime").equals("")))
         curForm.setLeavTime(jsonObj.getInt("leavTime"));
      //单位主键
      if(jsonObj.getString("organization_id")!= null && (!jsonObj.getString("organization_id").equals("")))
         curForm.setOrganization_id(jsonObj.getLong("organization_id"));
      //考试主键
      if(jsonObj.getString("id")!= null && (!jsonObj.getString("id").equals("")))
         curForm.setId(jsonObj.getLong("id"));
      //考场主键
      if(jsonObj.getString("examroom_id")!= null && (!jsonObj.getString("examroom_id").equals("")))
         curForm.setExamroom_id(jsonObj.getLong("examroom_id"));
      //用户主键
      if(jsonObj.getString("user_id")!= null && (!jsonObj.getString("user_id").equals("")))
         curForm.setUser_id(jsonObj.getLong("user_id"));
      //专业
      if(jsonObj.getString("specialtyCode")!= null && (!jsonObj.getString("specialtyCode").equals("")))
         curForm.setSpecialtyCode(jsonObj.getLong("specialtyCode"));
      //岗位
      if(jsonObj.getString("postionCode")!= null && (!jsonObj.getString("postionCode").equals("")))
         curForm.setPostionCode(jsonObj.getLong("postionCode"));
      //等级
      if(jsonObj.getString("gradeCode")!= null && (!jsonObj.getString("gradeCode").equals("")))
         curForm.setGradeCode(jsonObj.getLong("gradeCode"));
      //考试开始时间

      curForm.setExamStartTime(jsonObj.getString("examStartTime"));
      //考试结束时间
      curForm.setExamEndTime(jsonObj.getString("examEndTime"));
      //单选题重要数量
      if(jsonObj.getString("single_selectionImpCount")!= null &&
            (!jsonObj.getString("single_selectionImpCount").equals("")))
         curForm.setSingle_selectionImpCount(jsonObj.getInt("single_selectionImpCount"));
      //多选题重要数量
      if(jsonObj.getString("multi_selectionImpCount")!= null && 
            (!jsonObj.getString("multi_selectionImpCount").equals("")))
          curForm.setMulti_selectionImpCount(jsonObj.getInt("multi_selectionImpCount"));
      //判断题重要数量

      if(jsonObj.getString("judgementImpCount")!= null &&
            (!jsonObj.getString("judgementImpCount").equals("")))
         curForm.setJudgementImpCount(jsonObj.getInt("judgementImpCount"));
      //考试时间
      if(jsonObj.getString("examTime")!= null && (!jsonObj.getString("examTime").equals("")))
         curForm.setExamTime(jsonObj.getInt("examTime"));
      //总分
      if(jsonObj.getString("fullScore")!= null && (!jsonObj.getString("fullScore").equals("")))
         curForm.setFullScore(jsonObj.getLong("fullScore"));
      //及格分

      if(jsonObj.getString("passScore")!= null && (!jsonObj.getString("passScore").equals("")))
         curForm.setPassScore(jsonObj.getLong("passScore"));
      //学员姓名
      curForm.setUserName(jsonObj.getString("user_name"));
      //分数
      if(jsonObj.getString("score")!= null && (!jsonObj.getString("score").equals("")))
         curForm.setScore(jsonObj.getLong("score"));
      //是否及格
      curForm.setResult(jsonObj.getString("result"));
      curForm.setIsPassed(jsonObj.getString("result"));
      //单选答对数量

      if(jsonObj.getString("single_ok_count")!= null && (!jsonObj.getString("single_ok_count").equals("")))
         curForm.setSingle_ok_count(jsonObj.getInt("single_ok_count"));
      //多选答对数量
      if(jsonObj.getString("multi_ok_count")!= null && (!jsonObj.getString("multi_ok_count").equals("")))
         curForm.setMulti_ok_count(jsonObj.getInt("multi_ok_count"));
      //判断答对数量
      if(jsonObj.getString("judgement_ok_count")!= null && (!jsonObj.getString("judgement_ok_count").equals("")))
         curForm.setJudgement_ok_count(jsonObj.getInt("judgement_ok_count"));
}

优化后的代码

public class ExamPaper extends Gw_exammingForm{

   private String examinationPaperId;//试卷主键
   private String leavTime;//剩余时间
   private String organizationId;//单位主键
   private String id;//考试主键
   private String examRoomId;//考场主键
   private String userId;//用户主键
   private String specialtyCode;//专业代码
   private String postionCode;//报考岗位
   private String gradeCode;//报考等级
   private String examStartTime;//考试开始时间
   private String examEndTime;//考试结束时间
   private String singleSelectionImpCount;//单选选题重要数量
   private String multiSelectionImpCount;//多选题重要数量
   private String judgementImpCount;//判断题重要数量
   private String examTime;//考试时长
   private String fullScore;//总分
   private String passScore;//及格分
   private String userName;//学员姓名
   private String score;//考试得分
   private String resut;//是否及格
   private String singleOkCount;//单选题答对数量
   private String multiOkCount;//多选题答对数量
   private String judgementOkCount;//判断题答对数量

}

public void setCurFormpublic void setCurForm(Gw_exammingForm curForm,String parameters)throws BaseException {
   try {
      JSONObject jsonObj = new JSONObject(parameters);
      ExamPaper examPaper = JSONObject.parseObject(parameters,ExamPaper.class);

      curForm = examPaper;

   }catch (Exception e){
      e.printStackTrace();
   }

}

更好的重构

public void save(Student stu){
    String sql="INSERT INTO t_student(name,age) VALUES(?,?)";
    Connection conn=null;
    Statement st=null;
    try{
        // 1. 加载注册驱动
        Class.forName("com.mysql.jdbc.Driver");
        // 2. 获取数据库连接
        conn=DriverManager.getConnection("jdbc:mysql:///jdbcdemo","root","root");
        // 3. 创建语句对象
        PreparedStatement ps=conn.prepareStatement(sql);
        ps.setObject(1,stu.getName());
        ps.setObject(2,stu.getAge());
        // 4. 执行SQL语句
        ps.executeUpdate();
        // 5. 释放资源
    }catch(Exception e){
        e.printStackTrace();
    }finally{
        try{
            if(st!=null)
                st.close();
        }catch(SQLException e){
            e.printStackTrace();
        }finally{
            try{
                if(conn!=null)
                    conn.close();
            }catch(SQLException e){
                e.printStackTrace();
            }
        }
    }
}

// 删除学生信息
public void delete(Long id){
    String sql="DELETE  FROM t_student WHERE id=?";
    Connection conn=null;
    Statement st=null;
    try{
        // 1. 加载注册驱动
        Class.forName("com.mysql.jdbc.Driver");
        // 2. 获取数据库连接
        conn=DriverManager.getConnection("jdbc:mysql:///jdbcdemo","root","root");
        // 3. 创建语句对象
        PreparedStatement ps=conn.prepareStatement(sql);
        ps.setObject(1,id);
        // 4. 执行SQL语句
        ps.executeUpdate();
        // 5. 释放资源
    }catch(Exception e){
        e.printStackTrace();
    }finally{
        try{
            if(st!=null)
                st.close();
        }catch(SQLException e){
            e.printStackTrace();
        }finally{
            try{
                if(conn!=null)
                    conn.close();
            }catch(SQLException e){
                e.printStackTrace();
            }
        }
    }
}

// 修改学生信息
public void update(Student stu){
    String sql="UPDATE t_student SET name=?,age=? WHERE id=?";
    Connection conn=null;
    Statement st=null;
    try{
        // 1. 加载注册驱动
        Class.forName("com.mysql.jdbc.Driver");
        // 2. 获取数据库连接
        conn=DriverManager.getConnection("jdbc:mysql:///jdbcdemo","root","root");
        // 3. 创建语句对象
        PreparedStatement ps=conn.prepareStatement(sql);
        ps.setObject(1,stu.getName());
        ps.setObject(2,stu.getAge());
        ps.setObject(3,stu.getId());
        // 4. 执行SQL语句
        ps.executeUpdate();
        // 5. 释放资源
    }catch(Exception e){
        e.printStackTrace();
    }finally{
        try{
            if(st!=null)
                st.close();
        }catch(SQLException e){
            e.printStackTrace();
        }finally{
            try{
                if(conn!=null)
                    conn.close();
            }catch(SQLException e){
                e.printStackTrace();
            }
        }
    }
}

上面代码功能没有问题，但是代码重复太多了，因此我们可以进行优化，把重复的代码放到一个工具类JdbcUtils里

public class JdbcUtil {
    private JdbcUtil() { }
    static {
        //	1. 加载注册驱动
        try {
            Class.forName("com.mysql.jdbc.Driver");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static Connection getConnection() {
        try {
            // 2. 获取数据库连接
            return DriverManager.getConnection("jdbc:mysql:///jdbcdemo", "root", "root");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    //释放资源
    public static void close(ResultSet rs, Statement st, Connection conn) {
        try {
            if (rs != null)
                rs.close();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            try {
                if (st != null)
                    st.close();
            } catch (SQLException e) {
                e.printStackTrace();
            } finally {
                try {
                    if (conn != null)
                        conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

实现类里调用

// 增加学生信息
public void save(Student stu) {
    String sql = "INSERT INTO t_student(name,age) VALUES(?,?)";
    Connection conn = null;
    PreparedStatement ps=null;
    try {
        conn = JDBCUtil.getConnection();
        // 3. 创建语句对象
        ps = conn.prepareStatement(sql);
        ps.setObject(1, stu.getName());
        ps.setObject(2, stu.getAge());
        // 4. 执行SQL语句
        ps.executeUpdate();
        // 5. 释放资源
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        JDBCUtil.close(null, ps, conn);
    }

}

// 删除学生信息
public void delete(Long id) {
    String sql = "DELETE  FROM t_student WHERE id=?";
    Connection conn = null;
    PreparedStatement ps = null;
    try {
        conn=JDBCUtil.getConnection();
        // 3. 创建语句对象
        ps = conn.prepareStatement(sql);
        ps.setObject(1, id);
        // 4. 执行SQL语句
        ps.executeUpdate();
        // 5. 释放资源
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        JDBCUtil.close(null, ps, conn);
    }

}

// 修改学生信息
public void update(Student stu) {
    String sql = "UPDATE t_student SET name=?,age=? WHERE id=?";
    Connection conn = null;
    PreparedStatement ps = null;
    try {
        conn=JDBCUtil.getConnection();
        // 3. 创建语句对象
        ps = conn.prepareStatement(sql);
        ps.setObject(1, stu.getName());
        ps.setObject(2, stu.getAge());
        ps.setObject(3, stu.getId());
        // 4. 执行SQL语句
        ps.executeUpdate();
        // 5. 释放资源
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        JDBCUtil.close(null, ps, conn);
    }

}

public Student get(Long id) {
    String sql = "SELECT * FROM t_student WHERE id=?";
    Connection conn = null;
    Statement st = null;
    ResultSet rs = null;
    PreparedStatement ps=null;
    try {
        conn = JDBCUtil.getConnection();
        // 3. 创建语句对象
        ps = conn.prepareStatement(sql);
        ps.setObject(1, id);
        // 4. 执行SQL语句
        rs = ps.executeQuery();
        if (rs.next()) {
            String name = rs.getString("name");
            int age = rs.getInt("age");
            Student stu = new Student(id, name, age);
            return stu;
        }
        // 5. 释放资源
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        JDBCUtil.close(rs, ps, conn);
    }
    return null;
}

public List<Student> list() {
    List<Student> list = new ArrayList<>();
    String sql = "SELECT * FROM t_student ";
    Connection conn = null;
    Statement st = null;
    ResultSet rs = null;
    PreparedStatement ps=null;
    try {
        conn=JDBCUtil.getConnection();
        // 3. 创建语句对象
        ps = conn.prepareStatement(sql);
        // 4. 执行SQL语句
        rs = ps.executeQuery();
        while (rs.next()) {
            long id = rs.getLong("id");
            String name = rs.getString("name");
            int age = rs.getInt("age");
            Student stu = new Student(id, name, age);
            list.add(stu);
        }
        // 5. 释放资源
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        JDBCUtil.close(rs, ps, conn);
    }
    return list;
}

以上代码完成了重复代码的优化，但是数据库中的账号密码等直接显示在代码中，不利于后期账户密码修改，我们可以建立一个db.properties文件来存储这些信息

driverName=com.microsoft.sqlserver.jdbc.SQLServerDriver
userName=sa
passWord=sa
url=jdbc:sqlserver://localhost:1433;DatabaseName=HousDB

只需要在工具类JdbcUtlis中获取

static {
    // 1. 加载注册驱动
    try {
        ClassLoader loader = Thread.currentThread().getContextClassLoader();
        InputStream inputStream = loader.getResourceAsStream("db.properties");
        p = new Properties();
        p.load(inputStream);
        Class.forName(p.getProperty("driverClassName"));
    } catch (Exception e) {
        e.printStackTrace();
    }
}
public static Connection getConnection() {
    try {
        // 2. 获取数据库连接
        return DriverManager.getConnection(p.getProperty("url"), p.getProperty("username"),
        p.getProperty("password"));
    } catch (Exception e) {
        e.printStackTrace();
    }
    return null;
}

​ 百分之80的程序员到这里已经完成代码的优化了

抽取到这里貌似已经完成了，但在实现类中，依赖存在部分重复，在DML操作中，除了SQL和设置值的不同，其他都相同，将相同的抽取出去，不同的部分通过参数传递进啦，无法直接放在工具类中，这时我们可以创建一个模板类JbbcTemplate,创建一个DML和DQL的模板来进行对代码的优化

//查询统一模板
public static List<Student> query(String sql,Object...params){
    List<Student> list=new ArrayList<>();
    Connection conn = null;
    PreparedStatement ps=null;
    ResultSet rs = null;
    try {
        conn=JDBCUtil.getConnection();
        ps=conn.prepareStatement(sql);
        //设置值
        for (int i = 0; i < params.length; i++) {
            ps.setObject(i+1, params[i]);
        }
        rs = ps.executeQuery();
        while (rs.next()) {
            long id = rs.getLong("id");
            String name = rs.getString("name");
            int age = rs.getInt("age");
            Student stu = new Student(id, name, age);
            list.add(stu);
        }
        // 5. 释放资源
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        JDBCUtil.close(rs, ps, conn);
    }
    return list;
}

实现类直接调用方法

// 增加学生信息
public void save(Student stu) {
    String sql = "INSERT INTO t_student(name,age) VALUES(?,?)";
    Object[] params=new Object[]{stu.getName(),stu.getAge()};
    JdbcTemplate.update(sql, params);
}

// 删除学生信息
public void delete(Long id) {
    String sql = "DELETE FROM t_student WHERE id = ?";
    JdbcTemplate.update(sql, id);
}

// 修改学生信息
public void update(Student stu) {
    String sql = "UPDATE t_student SET name = ?,age = ? WHERE id = ?";
    Object[] params=new Object[]{stu.getName(),stu.getAge(),stu.getId()};
    JdbcTemplate.update(sql, params);
}

public Student get(Long id) {
    String sql = "SELECT * FROM t_student WHERE id=?";
    List<Student> list = JDBCTemplate.query(sql, id);
    return list.size()>0? list.get(0):null;
}

public List<Student> list() {
    String sql = "SELECT * FROM t_student ";
    return JDBCTemplate.query(sql);
}

这样重复代码基本就解决了，但又个很严重的问题就是这个程序DQL操作中只能处理Student类和t_studetn表相关数据，无法处理其他类如：Teacher类和t_teacher表。不同表（不同对象），不同表就有不同的列，不同的列处理的结果集就不一样，处理的结果集的操作只有DAO自己最清楚，一件事说，处理结果的方法压根就不应该放在模板中，应该由每个DAO自己来处理。因此我们可以创建IRowMapper接口来处理结果集

public interface IRowMapper {
    //处理结果集
    List rowMapper(ResultSet rs) throws Exception;
}

DQL模板中调用IRowMapper接口中的handle方法提醒实现类去自己实现mapping方法

public static List<Student> query(String sql,IRowMapper rsh, Object...params){
    List<Student> list = new ArrayList<>();
    Connection conn = null;
    PreparedStatement ps=null;
    ResultSet rs = null;
    try {
        conn = JdbcUtil.getConnection();
        ps = conn.prepareStatement(sql);
        //设置值
        for (int i = 0; i < params.length; i++) {
            ps.setObject(i+1, params[i]);
        }
        rs = ps.executeQuery();
        return rsh.mapping(rs);
        // 5. 释放资源
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        JdbcUtil.close(rs, ps, conn);
    }
    return list ;
}

实现类自己去实现IRowMapper接口的Mapping 方法，想要处理什么类型数据在里面自定义即可

public Student get(Long id) {
    String sql = "SELECT * FROM t_student WHERE id = ?";
    List<Student> list = JdbcTemplate.query(sql,new StudentRowMapper(), id);
    return list.size()>0? list.get(0):null;
}
public List<Student> list() {
    String sql = "SELECT * FROM t_student ";
    return JdbcTemplate.query(sql,new StudentRowMapper());
}
class StudentRowMapper implements IRowMapper{
    public List mapping(ResultSet rs) throws Exception {
        List<Student> list=new ArrayList<>();
        while(rs.next()){
            long id = rs.getLong("id");
            String name = rs.getString("name");
            int age = rs.getInt("age");
            Student stu=new Student(id, name, age);
            list.add(stu);
        }
        return list;
    }
}

好了基本大功告成了，但是DQL查询不单单只有查询学生信息（List类型），还可以查询学生数量，这时就要通过泛型来完成了

public interface IRowMapper<T> {
    //处理结果集
    T rowMapper(ResultSet rs) throws Exception;
}
public static <T> T query(String sql,IRowMapper<T> rsh, Object...params){
    Connection conn = null;
    PreparedStatement ps=null;
    ResultSet rs = null;
    try {
        conn = JdbcUtil.getConnection();
        ps = conn.prepareStatement(sql);
        //设置值
        for (int i = 0; i < params.length; i++) {
            ps.setObject(i+1, params[i]);
        }
        rs = ps.executeQuery();
        return rsh.mapping(rs);
        // 5. 释放资源
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        JdbcUtil.close(rs, ps, conn);
    }
    return null;
}

StudentRowMapper类

class StudentRowMapper implements IRowMapper<List<Student>>{
    public List<Student> mapping(ResultSet rs) throws Exception {
        List<Student> list=new ArrayList<>();
        while(rs.next()){
            long id = rs.getLong("id");
            String name = rs.getString("name");
            int age = rs.getInt("age");
            Student stu=new Student(id, name, age);
            list.add(stu);
        }
        return list;
    }
}

这样不仅可以查询LIst,还可以查询学生数量:

public Long getCount(){
    String sql = "SELECT COUNT(*) total FROM t_student";
    Long totalCount = (Long) JdbcTemplate.query(sql,
            new IRowMapper<Long>() {
                public Long mapping(ResultSet rs) throws Exception {
                    Long totalCount = null;
                    if(rs.next()){
                        totalCount = rs.getLong("total");
                    }
                    return totalCount;
                }
            });
    return totalCount;
}

好了重构设计已经完成了，好的代码能够让我们以后维护根方便，因此学会代码重构是非常重要的

推荐书籍 重构 改善既有代码的设计

经典框架都在用的设计模式

Spring就是一个把设计模式用的淋漓尽致的经典框架，其实从类的命名就能看出来

设计模式名称	举例
工厂模式	BeanFactory
装饰器模式	BeanWrapper
代理模式	AopProxy
委派模式	DispatcherServlet
策略模式	HandlerMapping
适配器模式	HandlerAdapter
模板模式	JdbcTemplate
观察者模式	ContextLoaderListener

需要特别声明的，设计模式从来都不是单个设计模式独立使用的。在实际应用中，通常是多个设计模式混合使用，你中有我，我中有你