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

java设计模式之策略

时间：2016-04-16 21:29:45      阅读：274      评论：0      收藏：0      [点我收藏+]

标签：

今天你的leader兴致冲冲地找到你，希望你可以帮他一个小忙，他现在急着要去开会。要帮什么忙呢？你很好奇。

他对你说，当前你们项目的数据库中有一张用户信息表，里面存放了很用户的数据，现在需要完成一个选择性查询用户信息的功能。他说会传递给你一个包含许多用户名的数组，你需要根据这些用户名把他们相应的数据都给查出来。

这个功能很简单的嘛，你爽快地答应了。由于你们项目使用的是MySQL数据库，你很快地写出了如下代码：

[java] view plain copy
  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. }  

这里根据传入的用户名数组拼装了SQL语句，然后去数据库中查找相应的行。为了方面调试，你还将拼装好的SQL语句打印了出来。

 

然后，你写了如下代码来测试这个方法：

[java] view plain copy
  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 plain copy
  1. select * from user_info where username = ‘Tom‘ or username = ‘Jim‘ or username = ‘Anna‘ or   

拼装出来的SQL语句在最后多加了一个 or 关键字！因为for循环执行到最后一条数据时不应该再加上or，可是代码很笨地给最后一条数据也加了or关键字，导致SQL语句语法出错了。

 

这可怎么办呢？

有了！你灵光一闪，想出了一个解决办法。等SQL语句拼装完成后，把最后一个or删除掉不就好了么。于是你将代码改成如下所示：

[java] view plain copy
  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 plain copy
  1. select * from user_info where username = ‘Tom‘ or username = ‘Jim‘ or username = ‘Anna‘  

好了，完工！你自信满满。

 

你的leader开完会后，过来看了下你的成果。总体来说，他还挺满意，但对于你使用的SQL语句拼装算法，他总是感觉有些不对劲，可是又说不上哪里不好。于是他告诉了你另一种拼装SQL语句的算法，让你加入到代码中，但是之前的那种算法也不要删除，先保留着再说，然后他又很忙似的跑开了。于是，你把他刚刚教你的算法加了进去，代码如下所示：

[java] view plain copy
  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这个关键字，第一次执行for循环的时候因为该布尔值为false，所以不会加上or，在循环的最后将布尔值赋值为true，这样以后循环每次都会在头部加上一个or关键字，由于使用了头部添加or的方法，所以不用再担心SQL语句的尾部会多出一个or来。然后你为了将两个算法都保留，在findUserInfo方法上加了一个参数，strategy值为1表示使用第一种算法，strategy值为2表示使用第二种算法。

 

这样测试代码也需要改成如下方式：

[java] view plain copy
  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 plain copy
  1. public interface Strategy {  
  2.   
  3.     String getSQL(String[] usernames);  
  4.   
  5. }  

然后定义两个子类都实现了上述接口，并将两种拼装SQL语句的算法分别加入两个子类中：

[java] view plain copy
  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 plain copy
  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 plain copy
  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 plain copy
  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 plain copy
  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设计模式之策略

标签：

原文地址：http://www.cnblogs.com/hoobey/p/5399312.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
迷上了代码！