模版模式(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、增加了代码否理解难度,降低代码的可阅读性,适配器使用的过多会使系统代码变得凌乱