了解Spring中常见的设计模式-------------------模版模式，适配器模式

模版模式（Template Method）

指定义一个算法的骨架，并允许子类为一个或者多个步骤提供实现

模版方法使得子类可以在不改变算法结构的情况下，重新定义算法的某些步骤

属于行为性设计模式

适用场景：

1、一次性实现一个算法的不变的部分，并将可变的行为留给子类来实现。

2、各子类中公共的行为被提取出来并集中到一个公共的父类中，从而避免代码的重复。

优点：

1、提高代码的复用性。

2、提高代码的扩展性。

3、符合开闭原则。

缺点：

1、类的数目增加

2、间接地增加了系统实现的复杂度。

3、继承关系自身缺点，如果父类增加新的抽象方法，所有子类都要进行修改。

简单课程创建示例：

public abstract class Course {

    protected final void createCourse() {
        //1,发布预习资料
        this.preResource();

        //2制作PPT
        this.createPPT();

        //3,在线直播
        this.liveVideo();

        //4,提交课堂笔记
        this.postNote();

        //5,提交源码
        this.postCode();

        //6,布置作业
        this.createHomework();

        if (this.isNeedHomework()) {
            this.checkHomework();
        }
    }

    protected abstract void checkHomework();

    //钩子方法，用于用户对服务的微调
    protected boolean isNeedHomework() {
        return false;
    }

    private void createHomework() {
    }

    private final void postCode() {
    }

    private final void postNote() {
        System.out.println("提交课堂笔记");
    }

    private final void liveVideo() {
        System.out.println("在线直播");
    }

    private final void createPPT() {
        System.out.println("制作PPT");
    }

    private final void preResource() {
        System.out.println("发布预习资料");
    }
}


public class JavaCourse extends Course {

    private boolean isNeedHomework = false;

    public JavaCourse(boolean isNeedHomework) {
        this.isNeedHomework = isNeedHomework;
    }

    @Override
    protected void checkHomework() {
        System.out.println("检测java作用");
    }

    @Override
    protected boolean isNeedHomework() {
        return this.isNeedHomework;
    }
}


public class PythonCourse extends Course {

    private boolean isNeedHomework = false;

    public PythonCourse(boolean isNeedHomework) {
        this.isNeedHomework = isNeedHomework;
    }

    @Override
    protected void checkHomework() {
        System.out.println("检查python作业");
    }

    @Override
    protected boolean isNeedHomework() {
        return this.isNeedHomework;
    }
}


public class TemplateCourseTest {

    public static void main(String[] args) {
        JavaCourse javaCourse = new JavaCourse(true);
        javaCourse.createCourse();

        System.out.println();

        PythonCourse pythonCourse = new PythonCourse(true);
        pythonCourse.createCourse();
    }
}


执行结果：
发布预习资料
制作PPT
在线直播
提交课堂笔记
检测java作用

发布预习资料
制作PPT
在线直播
提交课堂笔记
检查python作业

简单数据库连接查询示例：

public class Member {

    private String username;
    private String pwd;
    private String nickName;
    private Date crateDate;
    private boolean enabled;

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPwd() {
        return pwd;
    }

    public void setPwd(String pwd) {
        this.pwd = pwd;
    }

    public String getNickName() {
        return nickName;
    }

    public void setNickName(String nickName) {
        this.nickName = nickName;
    }

    public Date getCrateDate() {
        return crateDate;
    }

    public void setCrateDate(Date crateDate) {
        this.crateDate = crateDate;
    }

    public boolean isEnabled() {
        return enabled;
    }

    public void setEnabled(boolean enabled) {
        this.enabled = enabled;
    }

    @Override
    public String toString() {
        return "Member{" + "username='" + username + '\'' + ", pwd='" + pwd + '\'' + ", nickName='" + nickName + '\''
            + ", crateDate=" + crateDate + ", enabled=" + enabled + '}';
    }
}


public interface RowMapper<T> {

    T MapRow(ResultSet resultSet, int rowNum) throws Exception;
}


public abstract class JdbcTemplate<T> {

    private DataSource dataSource;

    public JdbcTemplate(DataSource dataSource) {
        this.dataSource = dataSource;
    }

    public List<?> executeQuery(String sql, RowMapper<T> rowMapper, Object[] values) throws Exception {
        //1,获取连接
        Connection conn = this.getConnection();

        //2,创建语句集
        PreparedStatement pstm = this.createPrepareStatement(conn, sql);

        //3、执行语句集
        ResultSet rs = this.executeQuery(pstm, values);

        //4、处理结果集
        List<?> result = this.pareResultSet(rs, rowMapper);

        //5、关闭结果集
        this.closeResultSet(rs);

        //6、关闭语句集
        this.closePrepareStatement(pstm);

        //7、关闭连接
        this.closeConnection(conn);

        return result;
    }

    protected void closeConnection(Connection conn) throws SQLException {
        conn.close();
    }

    protected void closePrepareStatement(PreparedStatement pstm) throws SQLException {
        pstm.close();
    }

    protected void closeResultSet(ResultSet rs) throws SQLException {
        rs.close();
    }

    protected List<?> pareResultSet(ResultSet rs, RowMapper rowMapper) throws Exception {
        List<Object> result = new ArrayList<Object>();
        int rowNum = 1;
        while (rs.next()) {
            result.add(rowMapper.MapRow(rs, rowNum++));
        }
        return result;
    }

    private ResultSet executeQuery(PreparedStatement pstm, Object[] values) throws SQLException {
        if (values != null) {
            for (int i = 0; i < values.length; i++) {
                pstm.setObject(i, values[i]);
            }
        }
        return pstm.executeQuery();
    }

    private PreparedStatement createPrepareStatement(Connection conn, String sql) throws SQLException {
        return conn.prepareStatement(sql);
    }

    private Connection getConnection() throws SQLException {
        return this.dataSource.getConnection();
    }

}


public class MemberDao extends JdbcTemplate {

    public MemberDao(DataSource dataSource) {
        super(dataSource);
    }

    public List<Member> selectAll() throws Exception {
        String sql = "select * from t_user;";

        return super.executeQuery(sql, new RowMapper<Member>() {
            @Override
            public Member MapRow(ResultSet resultSet, int rowNum) throws Exception {
                Member member = new Member();
                member.setUsername(resultSet.getString("username"));
                member.setPwd(resultSet.getString("password"));
                member.setNickName(resultSet.getString("nickname"));
                member.setCrateDate(resultSet.getDate("createDate"));
                member.setEnabled(resultSet.getBoolean("enabled"));
                return member;
            }
        }, null);
    }
}


public class JdbcTemplateTest {

    public static void main(String[] args) throws Exception {
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl(
            "jdbc:mysql://localhost:3306/login?useUnicode=true&useOldAliasMetadataBehavior=true&characterEncoding"
                + "=utf8&zeroDateTimeBehavior=convertToNull&useSSL=false&serverTimezone=CTT&useUnicode=true"
                + "&characterEncoding=utf-8&allowMultiQueries=true");
        dataSource.setUsername("root");
        dataSource.setPassword("root123");
        MemberDao memberDao = new MemberDao(dataSource);
        List<Member> list = memberDao.selectAll();
        for (Member member : list) {
            System.out.println(member.toString());
        }
    }
}


执行结果为：
Member{username='admin', pwd='b6aa79ceba5e51ee0b2aaaf3d9011433', nickName='超级管理员', crateDate=2019-07-11, enabled=true}
Member{username='羊羊羊', pwd='e9b56be2b9cd8c156c9cd90f9bbe28d4', nickName='测试用户1', crateDate=2019-07-11, enabled=true}

结构关系图：

适配器模式（Adapter Pattern）

是指将一个类的接口转换成客户期望的另一个接口，使得原本的接口不兼容的类可以一起工作。

属于结构型设计模式。

适用的场景：

1、已经存在的类，他的方法和需求不匹配（方法结果相同或相似）的情况。

2、适配器模式不是软件设计阶段考虑的设计模式，是随着软件维护由于不同的产品，不同的厂家造成功能类似而接口不相同情况下的解决方案。

简单示例：

public interface IUSB {
    void transfer();
}


public class USB1 implements IUSB{
    public void transfer(){
        System.out.println("于1996年1月正式提出USB1.0规格，频宽为1.5Mbps");
        System.out.println("使用USB1.0标准传输数据");
    }
}


public class USB2 implements IUSB{

    public void transfer() {
        System.out.println("2000年制定的USB 2.0标准是真正的USB 2.0，被称为USB 2.0的高速（High-speed）版本，理论传输速度为480 Mbps.");
        System.out.println("使用USB2.0标准传输数据");
    }
}


public class USB3 {

    public void transfer() {
        System.out.println("该规范由英特尔等公司发起,USB3.0的最大传输带宽高达5.0Gbps（640MB/s）,USB3.0 引入全双工数据传输");
        System.out.println("使用USB3.0标准传输数据");
    }
}


public class DeviceWorking {
    private IUSB usb;

    public DeviceWorking(IUSB usb) {
        this.usb = usb;
    }

    public void working(){
        usb.transfer();
        System.out.println("设备开始工作");
    }

}

//要想使得USB3.0在设备中运行，需要创建一个适配器，如下 ：
public class USBAdapter implements IUSB {
    private USB3 usb3;

    public USBAdapter(USB3 usb3) {
        this.usb3 = usb3;
    }

    @Override
    public void transfer() {
        usb3.transfer();
    }
}


public class SimpleAdatperTest {

    public static void main(String[] args) {
        USBAdapter usbAdapter = new USBAdapter(new USB3());
        DeviceWorking deviceWorking = new DeviceWorking(usbAdapter);
        deviceWorking.working();

        System.out.println("\t\n不使用适配器进行工作：");
        deviceWorking = new DeviceWorking(new USB1());
        deviceWorking.working();
        System.out.println();
        deviceWorking = new DeviceWorking(new USB2());
        deviceWorking.working();
    }
}


结果输出：
该规范由英特尔等公司发起,USB3.0的最大传输带宽高达5.0Gbps（640MB/s）,USB3.0 引入全双工数据传输
使用USB3.0标准传输数据
设备开始工作
	
不使用适配器进行工作：
于1996年1月正式提出USB1.0规格，频宽为1.5Mbps
使用USB1.0标准传输数据
设备开始工作

2000年制定的USB 2.0标准是真正的USB 2.0，被称为USB 2.0的高速（High-speed）版本，理论传输速度为480 Mbps.
使用USB2.0标准传输数据
设备开始工作

结构关系图：

优点：

1、能够提高类的透明性和复用，现有的类复用但不需要改变；

2、目标类和适配器类解耦，提高程序的扩展性；

3、在业务场景中符合开闭原则；

缺点：

1、在编写的过程中一定要全面考虑，可能会增加系统的复制性

2、增加了代码否理解难度，降低代码的可阅读性，适配器使用的过多会使系统代码变得凌乱