码迷，mamicode.com
首页 > 编程语言 > 详细

Java设计模式透析之 —— 策略(Strategy)

时间：2017-05-01 11:06:59      阅读：270      评论：0      收藏：0      [点我收藏+]

标签：silver   tostring   扩展性   mon   阅读   .net   where   rom   exec   

今天你的leader兴致冲冲地找到你，希望你能够帮他一个小忙。他如今急着要去开会。要帮什么忙呢？你非常好奇。

他对你说。当前你们项目的数据库中有一张用户信息表。里面存放了非常用户的数据。如今须要完毕一个选择性查询用户信息的功能。

他说会传递给你一个包括很多username的数组。你须要依据这些username把他们对应的数据都给查出来。

这个功能非常easy的嘛。你爽快地答应了。

因为你们项目使用的是MySQL数据库，你非常快地写出了例如以下代码：

[java] view plaincopy
  1. public class QueryUtil {  
  2.   
  3.     public void findUserInfo(String[] usernames) throws Exception {  
  4.         Class.forName("com.mysql.jdbc.Driver");  
  5.         Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root",  
  6.                 "123456");  
  7.         Statement stat = conn.createStatement();  
  8.         StringBuilder sql = new StringBuilder("select * from user_info where ");  
  9.         for (String user : usernames) {  
  10.             sql.append("username = ‘");  
  11.             sql.append(user);  
  12.             sql.append("‘ or ");  
  13.         }  
  14.         System.out.println(sql);  
  15.         ResultSet resultSet = stat.executeQuery(sql.toString());  
  16.         while (resultSet.next()) {  
  17.             // 处理从数据库读出来的数据  
  18.         }  
  19.         // 后面应将读到的数据组装成对象返回，这里略去。  
  20.     }  
  21. }  
这里依据传入的username数组拼装了SQL语句，然后去数据库中查找对应的行。为了方面调试。你还将拼装好的SQL语句打印了出来。

然后，你写了例如以下代码来測试这种方法：

[java] view plaincopy
  1. public class Test {  
  2.   
  3.     public static void main(String[] args) throws Exception {  
  4.         QueryUtil query = new QueryUtil();  
  5.         query.findUserInfo(new String[] { "Tom", "Jim", "Anna" });  
  6.     }  
  7.   
  8. }  
如今执行一下測试代码，你发现程序出错了。于是你立马去检查了一下打印的SQL语句，果然发现了问题。

[sql] view plaincopy
  1. select * from user_info where username = ‘Tom‘ or username = ‘Jim‘ or username = ‘Anna‘ or   
拼装出来的SQL语句在最后多加了一个 or keyword。由于for循环运行到最后一条数据时不应该再加上or，但是代码非常笨地给最后一条数据也加了orkeyword。导致SQL语句语法出错了。

这可怎么办呢？

有了。你灵光一闪，想出了一个解决的方法。

等SQL语句拼装完毕后，把最后一个or删除掉不就好了么。于是你将代码改成例如以下所看到的：

[java] view plaincopy
  1. public class QueryUtil {  
  2.   
  3.     public void findUserInfo(String[] usernames) throws Exception {  
  4.         Class.forName("com.mysql.jdbc.Driver");  
  5.         Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root",  
  6.                 "123456");  
  7.         Statement stat = conn.createStatement();  
  8.         StringBuilder sql = new StringBuilder("select * from user_info where ");  
  9.         for (String user : usernames) {  
  10.             sql.append("username = ‘");  
  11.             sql.append(user);  
  12.             sql.append("‘ or ");  
  13.         }  
  14.         sql.delete(sql.length() - " or ".length(), sql.length());  
  15.         System.out.println(sql);  
  16.         ResultSet resultSet = stat.executeQuery(sql.toString());  
  17.         while (resultSet.next()) {  
  18.             // 处理从数据库读出来的数据  
  19.         }  
  20.         // 后面应将读到的数据组装成对象返回，这里略去。  
  21.     }  
  22. }  

使用StringBuilder的delete方法，把最后多余的一个or删除掉了，这样再执行測试代码。一切就正常了，打印的SQL语句例如以下所看到的：

[sql] view plaincopy
  1. select * from user_info where username = ‘Tom‘ or username = ‘Jim‘ or username = ‘Anna‘  
好了，完工！你自信满满。

你的leader开完会后，过来看了下你的成果。整体来说。他还挺惬意。但对于你使用的SQL语句拼装算法，他总是感觉有些不正确劲，但是又说不上哪里不好。

于是他告诉了你还有一种拼装SQL语句的算法。让你增加到代码中，但是之前的那种算法也不要删除。先保留着再说，然后他又非常忙似的跑开了。

于是，你把他刚刚教你的算法加了进去，代码例如以下所看到的：

[java] view plaincopy
  1. public class QueryUtil {  
  2.   
  3.     public void findUserInfo(String[] usernames, int strategy) throws Exception {  
  4.         Class.forName("com.mysql.jdbc.Driver");  
  5.         Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root",  
  6.                 "123456");  
  7.         Statement stat = conn.createStatement();  
  8.         StringBuilder sql = new StringBuilder("select * from user_info where ");  
  9.         if (strategy == 1) {  
  10.             for (String user : usernames) {  
  11.                 sql.append("username = ‘");  
  12.                 sql.append(user);  
  13.                 sql.append("‘ or ");  
  14.             }  
  15.             sql.delete(sql.length() - " or ".length(), sql.length());  
  16.         } else if (strategy == 2) {  
  17.             boolean needOr = false;  
  18.             for (String user : usernames) {  
  19.                 if (needOr) {  
  20.                     sql.append(" or ");  
  21.                 }  
  22.                 sql.append("username = ‘");  
  23.                 sql.append(user);  
  24.                 sql.append("‘");  
  25.                 needOr = true;  
  26.             }  
  27.         }  
  28.         System.out.println(sql);  
  29.         ResultSet resultSet = stat.executeQuery(sql.toString());  
  30.         while (resultSet.next()) {  
  31.             // 处理从数据库读出来的数据  
  32.         }  
  33.         // 后面应将读到的数据组装成对象返回，这里略去。  
  34.     }  
  35. }  
能够看到，你leader教你的拼装算法。使用了一个布尔变量来控制是否须要加个or这个keyword。第一次运行for循环的时候由于该布尔值为false，所以不会加上or，在循环的最后将布尔值赋值为true，这样以后循环每次都会在头部加上一个orkeyword。由于使用了头部加入or的方法。所以不用再操心SQL语句的尾部会多出一个or来。然后你为了将两个算法都保留，在findUserInfo方法上加了一个參数，strategy值为1表示使用第一种算法。strategy值为2表示使用另外一种算法。

这样測试代码也须要改成例如以下方式：

[java] view plaincopy
  1. public class Test {  
  2.   
  3.     public static void main(String[] args) throws Exception {  
  4.         QueryUtil query = new QueryUtil();  
  5.         query.findUserInfo(new String[] { "Tom", "Jim", "Anna" }, 2);  
  6.     }  
  7.   
  8. }  
这里你通过參数指明了使用另外一种算法来拼装SQL语句。打印的结果和使用第一种算法是全然同样的。


你立马把你的leader从百忙之中拖了过来。让他检验一下你当前的成果，但是他还是一如既往的挑剔。

“你这样写的话，findUserInfo这种方法的逻辑就太复杂了，很不利于阅读，也不利于将来的扩展，假设我还有第三第四种算法想加进去，这种方法还能看吗？”  你的leader指点你，遇到这样的情况，就要使用策略模式来解决，策略模式的核心思想就是把算法提取出来放到一个独立的对象中。

为了指点你。他不顾自己的百忙，開始教你怎样使用策略模式进行优化。

首先定义一个策略接口：

[java] view plaincopy
  1. public interface Strategy {  
  2.   
  3.     String getSQL(String[] usernames);  
  4.   
  5. }  
然后定义两个子类都实现了上述接口，并将两种拼装SQL语句的算法分别增加两个子类中：
[java] view plaincopy
  1. public class Strategy1 implements Strategy {  
  2.   
  3.     @Override  
  4.     public String getSQL(String[] usernames) {  
  5.         StringBuilder sql = new StringBuilder("select * from user_info where ");  
  6.         for (String user : usernames) {  
  7.             sql.append("username = ‘");  
  8.             sql.append(user);  
  9.             sql.append("‘ or ");  
  10.         }  
  11.         sql.delete(sql.length() - " or ".length(), sql.length());  
  12.         return sql.toString();  
  13.     }  
  14.   
  15. }  
[java] view plaincopy
  1. public class Strategy2 implements Strategy {  
  2.   
  3.     @Override  
  4.     public String getSQL(String[] usernames) {  
  5.         StringBuilder sql = new StringBuilder("select * from user_info where ");  
  6.         boolean needOr = false;  
  7.         for (String user : usernames) {  
  8.             if (needOr) {  
  9.                 sql.append(" or ");  
  10.             }  
  11.             sql.append("username = ‘");  
  12.             sql.append(user);  
  13.             sql.append("‘");  
  14.             needOr = true;  
  15.         }  
  16.         return sql.toString();  
  17.     }  
  18.   
  19. }  
然后把QueryUtil中findUserInfo方法的第二个參数改成Strategy对象，这样仅仅须要调用Strategy的getSQL方法就能够获得拼装好的SQL语句，代码例如以下所看到的：
[java] view plaincopy
  1. public class QueryUtil {  
  2.   
  3.     public void findUserInfo(String[] usernames, Strategy strategy) throws Exception {  
  4.         Class.forName("com.mysql.jdbc.Driver");  
  5.         Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root",  
  6.                 "123456");  
  7.         Statement stat = conn.createStatement();  
  8.         String sql = strategy.getSQL(usernames);  
  9.         System.out.println(sql);  
  10.         ResultSet resultSet = stat.executeQuery(sql);  
  11.         while (resultSet.next()) {  
  12.             // 处理从数据库读出来的数据  
  13.         }  
  14.         // 后面应将读到的数据组装成对象返回。这里略去。  
  15.     }  
  16. }  
最后，測试代码在调用findUserInfo方法时。仅仅须要显示地指明须要使用哪一个策略对象就能够了：
[java] view plaincopy
  1. public class Test {  
  2.   
  3.     public static void main(String[] args) throws Exception {  
  4.         QueryUtil query = new QueryUtil();  
  5.         query.findUserInfo(new String[] { "Tom", "Jim", "Anna" }, new Strategy1());  
  6.         query.findUserInfo(new String[] { "Jac", "Joe", "Rose" }, new Strategy2());  
  7.     }  
  8.   
  9. }  
打印出的SQL语句丝毫不出预料。例如以下所看到的：
[sql] view plaincopy
  1. select * from user_info where username = ‘Tom‘ or username = ‘Jim‘ or username = ‘Anna‘  
  2. select * from user_info where username = ‘Jac‘ or username = ‘Joe‘ or username = ‘Rose‘  

使用策略模式改动之后，代码的可读性和扩展性都有了非常大的提高。即使以后还须要加入新的算法。你也是手到擒来了！

策略：它定义了算法家庭，分别封装起来。让它们之间能够互相替换。此模式让算法的变化。不会影响到使用算法的客户。 

Java设计模式透析之 —— 策略(Strategy)

标签：silver   tostring   扩展性   mon   阅读   .net   where   rom   exec   

原文地址：http://www.cnblogs.com/wzjhoutai/p/6791329.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！