007 - 策略模式对模版方法设计模式改进

如果我只需要获取User 的name 怎么办? 需要在重新创建一个方法 单独获取方法吗?
那可以通过返回User 对象 这种方法 虽然说可以, 但不怎么符合设计规范 我需要什么样的数据, 你应该就返回给我什么数据, 而不是需要我在处理
而且当数据量的时候 会影响网络数据的传输性能

public String findName(int id){    

  String sql = "select name from user where id = ?";    

  Object[] args = new Object[]{id};    

  User user = (User) super.find(sql, args);     

  return user.getName(); 

}

参考下AbstractDao数据返回的 是通过 find 然后 rowMapper返回的 那么我可以在写一个rowMapper2 那怎么让父类的super.find方法中
调用 rowMapper2 呢?

protected String rowMapper2(ResultSet rs) throws SQLException {
return rs.getString("name");
}

回顾下sql 和 数据封装的处理: sql是通过参数传递进去的, 数据的封装是在子类的方法中。 那如果能把数据的分装 方法 也通过参数的传递就可以了
方法是不能通过参数传递的 这时就可以使用接口 通过传递接口的子类实现

RowMapper 接口
1 package com.jdbc.dao.impl;
2
3 import java.sql.ResultSet;
4 import java.sql.SQLException;
5
6 public interface RowMapper {
7     public Object mapRow(ResultSet rs) throws SQLException;
8 }
MyDaoTemplate.java
 1 package com.jdbc.dao.impl;
 2
 3 import java.sql.Connection;
 4 import java.sql.PreparedStatement;
 5 import java.sql.ResultSet;
 6 import java.sql.SQLException;
 7
 8 import com.jdbc.base.JdbcUtil;
 9 import com.jdbc.exception.DaoException;
10
11 public class MyDaoTemplate {
12      public Object find(String sql, Object[] args, RowMapper rowMapper){
13         Connection conn = null;
14         PreparedStatement ps = null;
15         ResultSet rs = null;
16         Object obj = null;
17         try {
18             conn = JdbcUtil.getConnection();
19             ps = conn.prepareStatement(sql);
20
21             for (int i = 0; i < args.length; i++) {
22                 ps.setObject(i+1, args[i]);
23             }
24
25             rs = ps.executeQuery();
26
27             while(rs.next()){
28                 obj = rowMapper.mapRow(rs);
29             }
30         } catch (SQLException e) {
31             throw new DaoException(e.getMessage(), e);
32         } finally {
33             JdbcUtil.free(rs, ps, conn);
34         }
35         return obj;
36     }
37
38     public int update(String sql, Object[] args, RowMapper rowMapper) {
39         Connection conn = null;
40         PreparedStatement ps = null;
41         ResultSet rs = null;
42         int count = 0;
43         try {
44             conn = JdbcUtil.getConnection();
45             ps = conn.prepareStatement(sql);
46
47             for (int i = 0; i < args.length; i++) {
48                 ps.setObject(i+1, args[i]);
49             }
50
51             count = ps.executeUpdate();
52         } catch (SQLException e) {
53             throw new DaoException(e.getMessage(), e);
54         } finally {
55             JdbcUtil.free(rs, ps, conn);
56         }
57
58         return count;
59     }
60
61     public int insert(String sql, Object[] args) {
62         Connection conn = null;
63         PreparedStatement ps = null;
64         ResultSet rs = null;
65         int count = 0;
66         try {
67             conn = JdbcUtil.getConnection();
68             ps = conn.prepareStatement(sql);
69
70             for (int i = 0; i < args.length; i++) {
71                 ps.setObject(i+1, args[i]);
72             }
73
74             count = ps.executeUpdate();
75             rs = ps.getGeneratedKeys();
76             if(rs.next()){
77                 return rs.getInt(1);
78             }
79         } catch (SQLException e) {
80             throw new DaoException(e.getMessage(), e);
81         } finally {
82             JdbcUtil.free(rs, ps, conn);
83         }
84
85         return count;
86     }
87 }

测试代码

 1 MyDaoTemplate template = new MyDaoTemplate();
 2         String sql = "select * from User where name = ?";
 3         Object[] arg = new Object[]{"zhangsan"};
 4
 5         User u2 = (User) template.find(sql, arg, new RowMapper(){
 6             @Override
 7             public Object mapRow(ResultSet rs) throws SQLException {
 8                 User user = new User();
 9                 user.setId(rs.getInt("id"));
10                 user.setName(rs.getString("name"));
11                 user.setBirthday(rs.getString("birthday"));
12                 user.setMoney(rs.getDouble("money"));
13
14                 return user;
15             }
16
17         });
时间: 2025-01-06 02:53:56

007 - 策略模式对模版方法设计模式改进的相关文章

一道题采用两种设计模式:对比策略模式和模版方法

摘要 <C++ Primer>习题14.38和14.39分别采用策略模式.模版方法解决问题. 问题 <C++ Primer 5th>习题 14.38 : 编写一个类令其检查某个给定的 string 对象的长度是否与一个阀值相等.使用该对象编写程序,统计并报告输入的文件中长度为 1 的单词有多少个.长度为 2 的单词有多少个........长度为 10 的单词有多少个. <C++ Primer 5th>习题 14.39 : 修改上一题的程序令其报告长度在 1 至 9 之间

原型模式和模版方法模式

首先我们来了解原型模式 定义:用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象 根据定义,我们很明显地知道原型模式的对象是类.通过原型模式,我们可以无限地复制原型的对象 接着我们了解模版方法模式 定义:定义了一个操作中的算法的骨架,而将一些步骤延迟到子类中.模版方法使用使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤. 其实就是规定完成某件事情需要做多少步,并且规定那些需要你发挥自己的想象.能力根据实际情况去完成的. 综上所述.这两种设计模式的对象不同.原型是一个大的

二、模版方法设计模式

模板方法设计模式: 解决的问题:当功能内部一部分实现是确定,一部分实现是不确定的.这时可以把不确定的部分暴露出去,让子类去实现. ? 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 abstract class GetTime{     public final void getTime(){ //此功能如果不需要复写,可加final限定         long start

代码片--实现一个简单的模版方法设计模式(获取一段程序运行的时间)

package com.dreamy.day03; /** * @author dreamy * 需求:获取一段程序运行的时间 * 原理:获取程序开始和结束的时间并相减即可. * 获取时间:System.currentTimeMillis() * * * 当代码完成优化后,就可以解决这类问题 * 这种方式叫做模版方法设计模式. * * 什么是模版方法呢? * 在定义功能时,功能的一部分是确定的,但是有一部分是不确定的,而确定的部分在使用的不确定的部分, * 那么这时就将不确定的部分暴露出去,由该

模版方法设计模式

什么是模板方法 模板方法模式:定义一个操作中的算法骨架,而将一些步骤延迟到子类中.模板方法使得子类可以不改变一个算法的结构即可重定义该算法的 重复代码全部在父类里面,不同业务的,抽取给子类进行实现.抽取过程---抽象方法. 某些特定步骤. 核心:处理某个流程的代码已经都具备,但是其中某个节点的代码暂时不能确定.因此,我们采用工厂方法模式,将这个节点的代码实现转移给 子类完成.即:处理步骤在父类中定义好,具体的实现延迟到子类中定义. 说白了,就是将一些相同操作的代码,封装成一个算法的骨架.核心的部

模版方法设计模式(抽象类)

总结理解的模板方法设计模式及抽象类 (菜鸟一只,若有什么侵权或者不足之处,请指出,谢谢) 模板方法设计模式: 在父类中定义一个总体的算法骨架,而将一些具体的实现步骤放在到子类中,因为不同的子类实现细节不同         模板方法使得子类可以在不改变算法框架的情况下,只需要重新定义算法的某些实现步骤(借助于抽象类实现) 模板方法:一种统一的处理方式,即模板(比如课设报告,大家都按照规定同一种的格式去写,这就是模板,但是课设的题目不同,其具体内容是不同的) 注意:         抽象父类提供的模

23种设计模式(12):策略模式

定义:定义一组算法,将每个算法都封装起来,并且使他们之间可以互换. 类型:行为类模式. 类图: 策略模式是对算法的封装,把一系列的算法分别封装到对应的类中,并且这些类实现相同的接口,相互之间可以替换.在前面说过的行为类模式中,有一种模式也是关注对算法的封装——模版方法模式,对照类图可以看到,策略模式与模版方法模式的区别仅仅是多了一个单独的封装类Context,它与模版方法模式的区别在于:在模版方法模式中,调用算法的主体在抽象的父类中,而在策略模式中,调用算法的主体则是封装到了封装类Context

05 - 策略模式

定义:定义一组算法,将每个算法都封装起来,并且使他们之间可以互换. 类型:行为类模式 策略模式是对算法的封装,把一系列的算法分别封装到对应的类中,并且这些类实现相同的接口,相互之间可以替换.在前面说过的行为类模式中,有一种模式也是关注对算法的封装--模版方法模式,对照类图可以看到,策略模式与模版方法模式的区别仅仅是多了一个单独的封装类Context,它与模版方法模式的区别在于:在模版方法模式中,调用算法的主体在抽象的父类中,而在策略模式中,调用算法的主体则是封装到了封装类Context中,抽象策

(12)策略模式

 定义:定义一组算法,将每个算法都封装起来,并且使他们之间可以互换. 类型:行为类模式 类图: 策略模式是对算法的封装,把一系列的算法分别封装到对应的类中,并且这些类实现相同的接口,相互之间可以替换.在行为类模式中,有一种模式也是关注对算法的封装--模版方法模式,对照类图可以看到,策略模式与模版方法模式的区别仅仅是多了一个单独的封装类Context,它与模版方法模式的区别在于:在模版方法模式中,调用算法的主体在抽象的父类中,而在策略模式中,调用算法的主体则是封装到了封装类Context中,抽