xiaoliuliu2050
xiaoliuliu2050

设计模式 学习 5：

11个行为模式之5(责任链模式，命令模式，解释器模式，迭代器模式，中介者模式)


责任链模式

问题： 

 Sunny软件公司承接了某企业SCM(Supply Chain Management，供应链管理)系统的开发任务，其中包含一个采购审批子系统。该企业的采购审批是分级进行的，即根据采购金额的不同由不同层次的主管人员来审批，主任可以审批5万元以下（不包括5万元）的采购单，副董事长可以审批5万元至10万元（不包括10万元）的采购单，董事长可以审批10万元至50万元（不包括50万元）的采购单，50万元及以上的采购单就需要开董事会讨论决定。如图16-1所示：



  1. /采购单：请求类  
  2. class PurchaseRequest {  
  3.     private double amount;  //采购金额  
  4.     private int number;  //采购单编号  
  5.     private String purpose;  //采购目的  
  6.       
  7.     public PurchaseRequest(double amount, int number, String purpose) {  
  8.         this.amount = amount;  
  9.         this.number = number;  
  10.         this.purpose = purpose;  
  11.     }  
  12.       
  13.     public void setAmount(double amount) {  
  14.         this.amount = amount;  
  15.     }  
  16.       
  17.     public double getAmount() {  
  18.         return this.amount;  
  19.     }  
  20.       
  21.     public void setNumber(int number) {  
  22.         this.number = number;  
  23.     }  
  24.       
  25.     public int getNumber() {  
  26.         return this.number;  
  27.     }  
  28.       
  29.     public void setPurpose(String purpose) {  
  30.         this.purpose = purpose;  
  31.     }  
  32.       
  33.     public String getPurpose() {  
  34.         return this.purpose;  
  35.     }  
  36. }  
  37.   
  38. //审批者类：抽象处理者  
  39. abstract class Approver {  
  40.     protected Approver successor; //定义后继对象  
  41.     protected String name; //审批者姓名  
  42.       
  43.     public Approver(String name) {  
  44.         this.name = name;  
  45.     }  
  46.   
  47.     //设置后继者  
  48.     public void setSuccessor(Approver successor) {   
  49.         this.successor = successor;  
  50.     }  
  51.   
  52.     //抽象请求处理方法  
  53.     public abstract void processRequest(PurchaseRequest request);  
  54. }  
  55.   
  56. //主任类：具体处理者  
  57. class Director extends Approver {  
  58.     public Director(String name) {  
  59.         super(name);  
  60.     }  
  61.       
  62.     //具体请求处理方法  
  63.     public void processRequest(PurchaseRequest request) {  
  64.         if (request.getAmount() < 50000) {  
  65.             System.out.println("主任" + this.name + "审批采购单：" + request.getNumber() + "，金额：" + request.getAmount() + "元，采购目的：" + request.getPurpose() + "。");  //处理请求  
  66.         }  
  67.         else {  
  68.             this.successor.processRequest(request);  //转发请求  
  69.         }     
  70.     }  
  71. }  
  72.   
  73. //副董事长类：具体处理者  
  74. class VicePresident extends Approver {  
  75.     public VicePresident(String name) {  
  76.         super(name);  
  77.     }  
  78.       
  79.     //具体请求处理方法  
  80.     public void processRequest(PurchaseRequest request) {  
  81.         if (request.getAmount() < 100000) {  
  82.             System.out.println("副董事长" + this.name + "审批采购单：" + request.getNumber() + "，金额：" + request.getAmount() + "元，采购目的：" + request.getPurpose() + "。");  //处理请求  
  83.         }  
  84.         else {  
  85.             this.successor.processRequest(request);  //转发请求  
  86.         }     
  87.     }  
  88. }  
  89.   
  90. //董事长类：具体处理者  
  91. class President extends Approver {  
  92.     public President(String name) {  
  93.         super(name);  
  94.     }  
  95.       
  96.     //具体请求处理方法  
  97.     public void processRequest(PurchaseRequest request) {  
  98.         if (request.getAmount() < 500000) {  
  99.             System.out.println("董事长" + this.name + "审批采购单：" + request.getNumber() + "，金额：" + request.getAmount() + "元，采购目的：" + request.getPurpose() + "。");  //处理请求  
  100.         }  
  101.         else {  
  102.             this.successor.processRequest(request);  //转发请求  
  103.         }  
  104.     }  
  105. }  
  106.   
  107. //董事会类：具体处理者  
  108. class Congress extends Approver {  
  109.     public Congress(String name) {  
  110.         super(name);  
  111.     }  
  112.       
  113.     //具体请求处理方法  
  114.     public void processRequest(PurchaseRequest request) {  
  115.         System.out.println("召开董事会审批采购单：" + request.getNumber() + "，金额：" + request.getAmount() + "元，采购目的：" + request.getPurpose() + "。");        //处理请求  
  116.     }      
  117. }  

      编写如下客户端测试代码： 


  1. class Client {  
  2.     public static void main(String[] args) {  
  3.         Approver wjzhang,gyang,jguo,meeting;  
  4.         wjzhang = new Director("张无忌");  
  5.         gyang = new VicePresident("杨过");  
  6.         jguo = new President("郭靖");  
  7.         meeting = new Congress("董事会");  
  8.       
  9.         //创建职责链  
  10.         wjzhang.setSuccessor(gyang);  
  11.         gyang.setSuccessor(jguo);  
  12.         jguo.setSuccessor(meeting);  
  13.           
  14.         //创建采购单  
  15.         PurchaseRequest pr1 = new PurchaseRequest(45000,10001,"购买倚天剑");  
  16.         wjzhang.processRequest(pr1);  
  17.           
  18.         PurchaseRequest pr2 = new PurchaseRequest(60000,10002,"购买《葵花宝典》");  
  19.         wjzhang.processRequest(pr2);  
  20.       
  21.         PurchaseRequest pr3 = new PurchaseRequest(160000,10003,"购买《金刚经》");  
  22.         wjzhang.processRequest(pr3);  
  23.   
  24.         PurchaseRequest pr4 = new PurchaseRequest(800000,10004,"购买桃花岛");  
  25.         wjzhang.processRequest(pr4);  
  26.     }  
  27. }   

命令模式

Sunny软件公司开发人员为公司内部OA系统开发了一个桌面版应用程序，该应用程序为用户提供了一系列自定义功能键，用户可以通过这些功能键来实现一些快捷操作。Sunny软件公司开发人员通过分析，发现不同的用户可能会有不同的使用习惯，在设置功能键的时候每个人都有自己的喜好，例如有的人喜欢将第一个功能键设置为“打开帮助文档”，有的人则喜欢将该功能键设置为“最小化至托盘”，为了让用户能够灵活地进行功能键的设置，开发人员提供了一个“功能键设置”窗口，该窗口界面如图2所示：




通过如图2所示界面，用户可以将功能键和相应功能绑定在一起，还可以根据需要来修改功能键的设置，而且系统在未来可能还会增加一些新的功能或功能键。


  1. import java.util.*;  
  2.   
  3. //功能键设置窗口类  
  4. class FBSettingWindow {  
  5.     private String title; //窗口标题  
  6.     //定义一个ArrayList来存储所有功能键  
  7.     private ArrayList functionButtons = new ArrayList();  
  8.       
  9.     public FBSettingWindow(String title) {  
  10.         this.title = title;  
  11.     }  
  12.       
  13.     public void setTitle(String title) {  
  14.         this.title = title;  
  15.     }  
  16.       
  17.     public String getTitle() {  
  18.         return this.title;  
  19.     }  
  20.       
  21.     public void addFunctionButton(FunctionButton fb) {  
  22.         functionButtons.add(fb);  
  23.     }  
  24.       
  25.     public void removeFunctionButton(FunctionButton fb) {  
  26.         functionButtons.remove(fb);  
  27.     }  
  28.       
  29.     //显示窗口及功能键  
  30.     public void display() {  
  31.         System.out.println("显示窗口：" + this.title);  
  32.         System.out.println("显示功能键：");  
  33.         for (Object obj : functionButtons) {  
  34.             System.out.println(((FunctionButton)obj).getName());  
  35.         }  
  36.         System.out.println("------------------------------");  
  37.     }     
  38. }  
  39.   
  40. //功能键类：请求发送者  
  41. class FunctionButton {  
  42.     private String name; //功能键名称  
  43.     private Command command; //维持一个抽象命令对象的引用  
  44.       
  45.     public FunctionButton(String name) {  
  46.         this.name = name;  
  47.     }  
  48.       
  49.     public String getName() {  
  50.         return this.name;  
  51.     }  
  52.       
  53.     //为功能键注入命令  
  54.     public void setCommand(Command command) {  
  55.         this.command = command;  
  56.     }  
  57.       
  58.     //发送请求的方法  
  59.     public void onClick() {  
  60.         System.out.print("点击功能键：");  
  61.         command.execute();  
  62.     }  
  63. }  
  64.   
  65. //抽象命令类  
  66. abstract class Command {  
  67.     public abstract void execute();  
  68. }  
  69.   
  70. //帮助命令类：具体命令类  
  71. class HelpCommand extends Command {  
  72.     private HelpHandler hhObj; //维持对请求接收者的引用  
  73.       
  74.     public HelpCommand() {  
  75.         hhObj = new HelpHandler();  
  76.     }  
  77.       
  78.     //命令执行方法，将调用请求接收者的业务方法  
  79.     public void execute() {  
  80.         hhObj.display();  
  81.     }  
  82. }  
  83.   
  84. //最小化命令类：具体命令类  
  85. class MinimizeCommand extends Command {  
  86.     private WindowHanlder whObj; //维持对请求接收者的引用  
  87.       
  88.     public MinimizeCommand() {  
  89.         whObj = new WindowHanlder();  
  90.     }  
  91.       
  92. //命令执行方法，将调用请求接收者的业务方法  
  93.     public void execute() {  
  94.         whObj.minimize();  
  95.     }  
  96. }  
  97.   
  98. //窗口处理类：请求接收者  
  99. class WindowHanlder {  
  100.     public void minimize() {  
  101.         System.out.println("将窗口最小化至托盘！");  
  102.     }  
  103. }  
  104.   
  105. //帮助文档处理类：请求接收者  
  106. class HelpHandler {  
  107.     public void display() {  
  108.         System.out.println("显示帮助文档！");  
  109.     }  
  110. }  

       为了提高系统的灵活性和可扩展性，我们将具体命令类的类名存储在配置文件中，并通过工具类XMLUtil来读取配置文件并反射生成对象，XMLUtil类的代码如下所示：

[java] view plain copy


  1. import javax.xml.parsers.*;  
  2. import org.w3c.dom.*;  
  3. import org.xml.sax.SAXException;  
  4. import java.io.*;  
  5.   
  6. public class XMLUtil {  
  7. //该方法用于从XML配置文件中提取具体类类名，并返回一个实例对象，可以通过参数的不同返回不同类名节点所对应的实例  
  8.     public static Object getBean(int i) {  
  9.         try {  
  10.             //创建文档对象  
  11.             DocumentBuilderFactory dFactory = DocumentBuilderFactory.newInstance();  
  12.             DocumentBuilder builder = dFactory.newDocumentBuilder();  
  13.             Document doc;                             
  14.             doc = builder.parse(new File("config.xml"));   
  15.           
  16.             //获取包含类名的文本节点  
  17.             NodeList nl = doc.getElementsByTagName("className");  
  18.             Node classNode = null;  
  19.             if (0 == i) {  
  20.                 classNode = nl.item(0).getFirstChild();  
  21.             }  
  22.             else {  
  23.                 classNode = nl.item(1).getFirstChild();  
  24.             }   
  25.   
  26.             String cName = classNode.getNodeValue();  
  27.               
  28.             //通过类名生成实例对象并将其返回  
  29.             Class c = Class.forName(cName);  
  30.             Object obj = c.newInstance();  
  31.             return obj;  
  32.         }     
  33.         catch(Exception e){  
  34.             e.printStackTrace();  
  35.             return null;  
  36.         }  
  37.     }  
  38. }  

       配置文件config.xml中存储了具体建造者类的类名，代码如下所示：

[java] view plain copy


  1. "1.0"?>  
  2.   
  3.     HelpCommand  
  4.     MinimizeCommand  
  5.   

       编写如下客户端测试代码：


  1. class Client {  
  2.     public static void main(String args[]) {  
  3.         FBSettingWindow fbsw = new FBSettingWindow("功能键设置");  
  4.               
  5.         FunctionButton fb1,fb2;  
  6.         fb1 = new FunctionButton("功能键1");  
  7.         fb2 = new FunctionButton("功能键1");  
  8.           
  9.         Command command1,command2;  
  10.         //通过读取配置文件和反射生成具体命令对象  
  11.         command1 = (Command)XMLUtil.getBean(0);  
  12.         command2 = (Command)XMLUtil.getBean(1);  
  13.           
  14.         //将命令对象注入功能键  
  15.         fb1.setCommand(command1);  
  16.         fb2.setCommand(command2);  
  17.           
  18.         fbsw.addFunctionButton(fb1);  
  19.         fbsw.addFunctionButton(fb2);  
  20.         fbsw.display();  
  21.           
  22.         //调用功能键的业务方法  
  23.         fb1.onClick();  
  24.         fb2.onClick();  
  25.     }  
  26. }  




解释器模式


  Sunny软件公司欲为某玩具公司开发一套机器人控制程序，在该机器人控制程序中包含一些简单的英文控制指令，每一个指令对应一个表达式(expression)，该表达式可以是简单表达式也可以是复合表达式，每一个简单表达式由移动方向(direction)，移动方式(action)和移动距离(distance)三部分组成，其中移动方向包括上(up)、下(down)、左(left)、右(right)；移动方式包括移动(move)和快速移动(run)；移动距离为一个正整数。两个表达式之间可以通过与(and)连接，形成复合(composite)表达式。

       用户通过对图形化的设置界面进行操作可以创建一个机器人控制指令，机器人在收到指令后将按照指令的设置进行移动，例如输入控制指令：up move 5，则“向上移动5个单位”；输入控制指令：down  run 10 and left move 20，则“向下快速移动10个单位再向左移动20个单位”。



expression ::= direction action distance | composite //表达式

composite ::= expression 'and' expression //复合表达式

direction ::= 'up' | 'down' | 'left' | 'right' //移动方向

action ::= 'move' | 'run' //移动方式

distance ::= an integer //移动距离


  1. //注：本实例对机器人控制指令的输出结果进行模拟，将英文指令翻译为中文指令，实际情况是调用不同的控制程序进行机器人的控制，包括对移动方向、方式和距离的控制等  
  2. import java.util.*;  
  3.   
  4. //抽象表达式  
  5. abstract class AbstractNode {  
  6.     public abstract String interpret();  
  7. }  
  8.   
  9. //And解释：非终结符表达式  
  10. class AndNode extends AbstractNode {  
  11.     private AbstractNode left; //And的左表达式  
  12.     private AbstractNode right; //And的右表达式  
  13.   
  14.     public AndNode(AbstractNode left, AbstractNode right) {  
  15.         this.left = left;  
  16.         this.right = right;  
  17.     }  
  18.       
  19.     //And表达式解释操作  
  20.     public String interpret() {  
  21.         return left.interpret() + "再" + right.interpret();  
  22.     }  
  23. }  
  24.   
  25. //简单句子解释：非终结符表达式  
  26. class SentenceNode extends AbstractNode {  
  27.     private AbstractNode direction;  
  28.     private AbstractNode action;  
  29.     private AbstractNode distance;  
  30.   
  31.     public SentenceNode(AbstractNode direction,AbstractNode action,AbstractNode distance) {  
  32.         this.direction = direction;  
  33.         this.action = action;  
  34.         this.distance = distance;  
  35.     }  
  36.       
  37.     //简单句子的解释操作  
  38.     public String interpret() {  
  39.         return direction.interpret() + action.interpret() + distance.interpret();  
  40.     }     
  41. }  
  42.   
  43. //方向解释：终结符表达式  
  44. class DirectionNode extends AbstractNode {  
  45.     private String direction;  
  46.       
  47.     public DirectionNode(String direction) {  
  48.         this.direction = direction;  
  49.     }  
  50.       
  51.     //方向表达式的解释操作  
  52.     public String interpret() {  
  53.         if (direction.equalsIgnoreCase("up")) {  
  54.             return "向上";  
  55.         }  
  56.         else if (direction.equalsIgnoreCase("down")) {  
  57.             return "向下";  
  58.         }  
  59.         else if (direction.equalsIgnoreCase("left")) {  
  60.             return "向左";  
  61.         }  
  62.         else if (direction.equalsIgnoreCase("right")) {  
  63.             return "向右";  
  64.         }  
  65.         else {  
  66.             return "无效指令";  
  67.         }  
  68.     }  
  69. }  
  70.   
  71. //动作解释：终结符表达式  
  72. class ActionNode extends AbstractNode {  
  73.     private String action;  
  74.       
  75.     public ActionNode(String action) {  
  76.         this.action = action;  
  77.     }  
  78.       
  79.     //动作（移动方式）表达式的解释操作  
  80.     public String interpret() {  
  81.         if (action.equalsIgnoreCase("move")) {  
  82.             return "移动";  
  83.         }  
  84.         else if (action.equalsIgnoreCase("run")) {  
  85.             return "快速移动";  
  86.         }  
  87.         else {  
  88.             return "无效指令";  
  89.         }  
  90.     }  
  91. }  
  92.   
  93. //距离解释：终结符表达式  
  94. class DistanceNode extends AbstractNode {  
  95.     private String distance;  
  96.       
  97.     public DistanceNode(String distance) {  
  98.         this.distance = distance;  
  99.     }  
  100.       
  101. //距离表达式的解释操作  
  102.     public String interpret() {  
  103.         return this.distance;  
  104.     }     
  105. }  
  106.   
  107. //指令处理类：工具类  
  108. class InstructionHandler {  
  109.     private String instruction;  
  110.     private AbstractNode node;  
  111.       
  112.     public void handle(String instruction) {  
  113.         AbstractNode left = null, right = null;  
  114.         AbstractNode direction = null, action = null, distance = null;  
  115.         Stack stack = new Stack(); //声明一个栈对象用于存储抽象语法树  
  116.         String[] words = instruction.split(" "); //以空格分隔指令字符串  
  117.         for (int i = 0; i < words.length; i++) {  
  118. //本实例采用栈的方式来处理指令，如果遇到“and”，则将其后的三个单词作为三个终结符表达式连成一个简单句子SentenceNode作为“and”的右表达式，而将从栈顶弹出的表达式作为“and”的左表达式，最后将新的“and”表达式压入栈中。                   if (words[i].equalsIgnoreCase("and")) {  
  119.                 left = (AbstractNode)stack.pop(); //弹出栈顶表达式作为左表达式  
  120.                 String word1= words[++i];  
  121.                 direction = new DirectionNode(word1);  
  122.                 String word2 = words[++i];  
  123.                 action = new ActionNode(word2);  
  124.                 String word3 = words[++i];  
  125.                 distance = new DistanceNode(word3);  
  126.                 right = new SentenceNode(direction,action,distance); //右表达式  
  127.                 stack.push(new AndNode(left,right)); //将新表达式压入栈中  
  128.             }  
  129.             //如果是从头开始进行解释，则将前三个单词组成一个简单句子SentenceNode并将该句子压入栈中  
  130.             else {  
  131.                 String word1 = words[i];  
  132.                 direction = new DirectionNode(word1);  
  133.                 String word2 = words[++i];  
  134.                 action = new ActionNode(word2);  
  135.                 String word3 = words[++i];  
  136.                 distance = new DistanceNode(word3);  
  137.                 left = new SentenceNode(direction,action,distance);  
  138.                 stack.push(left); //将新表达式压入栈中  
  139.             }  
  140.         }  
  141.         this.node = (AbstractNode)stack.pop(); //将全部表达式从栈中弹出  
  142.     }  
  143.       
  144.     public String output() {  
  145.         String result = node.interpret(); //解释表达式  
  146.         return result;  
  147.     }  
  148. }  

       工具类InstructionHandler用于对输入指令进行处理，将输入指令分割为字符串数组，将第1个、第2个和第3个单词组合成一个句子，并存入栈中；如果发现有单词“and”，则将“and”后的第1个、第2个和第3个单词组合成一个新的句子作为“and”的右表达式，并从栈中取出原先所存句子作为左表达式，然后组合成一个And节点存入栈中。依此类推，直到整个指令解析结束。

       编写如下客户端测试代码：

[java] view plain copy


  1. class Client {  
  2.     public static void main(String args[]) {  
  3.         String instruction = "up move 5 and down run 10 and left move 5";  
  4.         InstructionHandler handler = new InstructionHandler();  
  5.         handler.handle(instruction);  
  6.         String outString;  
  7.         outString = handler.output();  
  8.         System.out.println(outString);  
  9.     }  
  10. }  




迭代器模式
  1. //在本实例中，为了详细说明自定义迭代器的实现过程，我们没有使用JDK中内置的迭代器，事实上，JDK内置迭代器已经实现了对一个List对象的正向遍历  
  2. import java.util.*;  
  3.   
  4. //抽象聚合类  
  5. abstract class AbstractObjectList {  
  6.     protected List objects = new ArrayList();  
  7.   
  8.     public AbstractObjectList(List objects) {  
  9.         this.objects = objects;  
  10.     }  
  11.       
  12.     public void addObject(Object obj) {  
  13.         this.objects.add(obj);  
  14.     }  
  15.       
  16.     public void removeObject(Object obj) {  
  17.         this.objects.remove(obj);  
  18.     }  
  19.       
  20.     public List getObjects() {  
  21.         return this.objects;  
  22.     }  
  23.       
  24.     //声明创建迭代器对象的抽象工厂方法  
  25.     public abstract AbstractIterator createIterator();  
  26. }  
  27.   
  28. //商品数据类：具体聚合类  
  29. class ProductList extends AbstractObjectList {  
  30.     public ProductList(List products) {  
  31.         super(products);  
  32.     }  
  33.       
  34.     //实现创建迭代器对象的具体工厂方法  
  35.     public AbstractIterator createIterator() {  
  36.         return new ProductIterator(this);  
  37.     }  
  38. }   
  39.   
  40. //抽象迭代器  
  41. interface AbstractIterator {  
  42.     public void next(); //移至下一个元素  
  43.     public boolean isLast(); //判断是否为最后一个元素  
  44.     public void previous(); //移至上一个元素  
  45.     public boolean isFirst(); //判断是否为第一个元素  
  46.     public Object getNextItem(); //获取下一个元素  
  47.     public Object getPreviousItem(); //获取上一个元素  
  48. }  
  49.   
  50. //商品迭代器：具体迭代器  
  51. class ProductIterator implements AbstractIterator {  
  52.     private ProductList productList;  
  53.     private List products;  
  54.     private int cursor1; //定义一个游标，用于记录正向遍历的位置  
  55.     private int cursor2; //定义一个游标，用于记录逆向遍历的位置  
  56.       
  57.     public ProductIterator(ProductList list) {  
  58.         this.productList = list;  
  59.         this.products = list.getObjects(); //获取集合对象  
  60.         cursor1 = 0; //设置正向遍历游标的初始值  
  61.         cursor2 = products.size() -1; //设置逆向遍历游标的初始值  
  62.     }  
  63.       
  64.     public void next() {  
  65.         if(cursor1 < products.size()) {  
  66.             cursor1++;  
  67.         }  
  68.     }  
  69.       
  70.     public boolean isLast() {  
  71.         return (cursor1 == products.size());  
  72.     }  
  73.       
  74.     public void previous() {  
  75.         if (cursor2 > -1) {  
  76.             cursor2--;  
  77.         }  
  78.     }  
  79.       
  80.     public boolean isFirst() {  
  81.         return (cursor2 == -1);  
  82.     }  
  83.       
  84.     public Object getNextItem() {  
  85.         return products.get(cursor1);  
  86.     }   
  87.           
  88.     public Object getPreviousItem() {  
  89.         return products.get(cursor2);  
  90.     }     
  91. }  

    92.        编写如下客户端测试代码：


    1. class Client {  
    2.     public static void main(String args[]) {  
    3.         List products = new ArrayList();  
    4.         products.add("倚天剑");  
    5.         products.add("屠龙刀");  
    6.         products.add("断肠草");  
    7.         products.add("葵花宝典");  
    8.         products.add("四十二章经");  
    9.               
    10.         AbstractObjectList list;  
    11.         AbstractIterator iterator;  
    12.           
    13.         list = new ProductList(products); //创建聚合对象  
    14.         iterator = list.createIterator();   //创建迭代器对象  
    15.           
    16.         System.out.println("正向遍历：");      
    17.         while(!iterator.isLast()) {  
    18.             System.out.print(iterator.getNextItem() + "，");  
    19.             iterator.next();  
    20.         }  
    21.         System.out.println();  
    22.         System.out.println("-----------------------------");  
    23.         System.out.println("逆向遍历：");  
    24.         while(!iterator.isFirst()) {  
    25.             System.out.print(iterator.getPreviousItem() + "，");  
    26.             iterator.previous();  
    27.         }  
    28.     }  
    29. ｝




    使用内部类实现迭代器


    1. //商品数据类：具体聚合类  
    2. class ProductList extends AbstractObjectList {  
    3.     public ProductList(List products) {  
    4.         super(products);  
    5.     }  
    6.       
    7.     public AbstractIterator createIterator() {  
    8.         return new ProductIterator();  
    9.     }  
    10.       
    11.     //商品迭代器：具体迭代器，内部类实现  
    12.     private class ProductIterator implements AbstractIterator {  
    13.         private int cursor1;  
    14.         private int cursor2;  
    15.           
    16.         public ProductIterator() {  
    17.             cursor1 = 0;  
    18.             cursor2 = objects.size() -1;  
    19.         }  
    20.           
    21.         public void next() {  
    22.             if(cursor1 < objects.size()) {  
    23.                 cursor1++;  
    24.             }  
    25.         }  
    26.           
    27.         public boolean isLast() {  
    28.             return (cursor1 == objects.size());  
    29.         }  
    30.           
    31.         public void previous() {  
    32.             if(cursor2 > -1) {  
    33.                 cursor2--;  
    34.             }  
    35.         }  
    36.           
    37.         public boolean isFirst() {  
    38.             return (cursor2 == -1);  
    39.         }  
    40.           
    41.         public Object getNextItem() {  
    42.             return objects.get(cursor1);  
    43.         }   
    44.               
    45.         public Object getPreviousItem() {  
    46.             return objects.get(cursor2);  
    47.         }     
    48.     }  
    49. }  




    中介者模式


      Sunny软件公司欲开发一套CRM系统，其中包含一个客户信息管理模块，所设计的“客户信息管理窗口”界面效果图如图20-2所示：   Sunny公司开发人员通过分析发现，在图20-2中，界面组件之间存在较为复杂的交互关系：如果删除一个客户，要在客户列表(List)中删掉对应的项，客户选择组合框(ComboBox)中客户名称也将减少一个；如果增加一个客户信息，客户列表中需增加一个客户，且组合框中也将增加一项。如果实现界面组件之间的交互是Sunny公司开发人员必须面对的一个问题？





    解决：





    1. abstract class Mediator {  
    2.     public abstract void componentChanged(Component c);  
    3. }  
    4.   
    5. //具体中介者  
    6. class ConcreteMediator extends Mediator {  
    7.     //维持对各个同事对象的引用  
    8.     public Button addButton;  
    9.     public List list;  
    10.     public TextBox userNameTextBox;  
    11.     public ComboBox cb;  
    12.   
    13.     //封装同事对象之间的交互  
    14.     public void componentChanged(Component c) {  
    15.         //单击按钮  
    16. if(c == addButton) {  
    17.             System.out.println("--单击增加按钮--");  
    18.             list.update();  
    19.             cb.update();  
    20.             userNameTextBox.update();  
    21.         }  
    22.         //从列表框选择客户  
    23.         else if(c == list) {  
    24.             System.out.println("--从列表框选择客户--");  
    25.             cb.select();  
    26.             userNameTextBox.setText();  
    27.         }  
    28.         //从组合框选择客户  
    29.         else if(c == cb) {  
    30.             System.out.println("--从组合框选择客户--");  
    31.             cb.select();  
    32.             userNameTextBox.setText();  
    33.         }  
    34.     }  
    35. }  
    36.   
    37. //抽象组件类：抽象同事类  
    38. abstract class Component {  
    39.     protected Mediator mediator;  
    40.       
    41.     public void setMediator(Mediator mediator) {  
    42.         this.mediator = mediator;  
    43.     }  
    44.   
    45.     //转发调用  
    46.     public void changed() {  
    47.         mediator.componentChanged(this);  
    48.     }  
    49.       
    50.     public abstract void update();    
    51. }  
    52.   
    53. //按钮类：具体同事类  
    54. class Button extends Component {  
    55.     public void update() {  
    56.         //按钮不产生交互  
    57.     }  
    58. }  
    59.   
    60. //列表框类：具体同事类  
    61. class List extends Component {  
    62.     public void update() {  
    63.         System.out.println("列表框增加一项：张无忌。");  
    64.     }  
    65.       
    66.     public void select() {  
    67.         System.out.println("列表框选中项：小龙女。");  
    68.     }  
    69. }  
    70.   
    71. //组合框类：具体同事类  
    72. class ComboBox extends Component {  
    73.     public void update() {  
    74.         System.out.println("组合框增加一项：张无忌。");  
    75.     }  
    76.       
    77.     public void select() {  
    78.         System.out.println("组合框选中项：小龙女。");  
    79.     }  
    80. }  
    81.   
    82. //文本框类：具体同事类  
    83. class TextBox extends Component {  
    84.     public void update() {  
    85.         System.out.println("客户信息增加成功后文本框清空。");  
    86.     }  
    87.       
    88.     public void setText() {  
    89.         System.out.println("文本框显示：小龙女。");  
    90.     }  
    91. }  

          编写如下客户端测试代码：


    1. class Client {  
    2.     public static void main(String args[]) {  
    3.         //定义中介者对象  
    4.         ConcreteMediator mediator;  
    5.         mediator = new ConcreteMediator();  
    6.           
    7.         //定义同事对象  
    8.         Button addBT = new Button();  
    9.         List list = new List();  
    10.         ComboBox cb = new ComboBox();  
    11.         TextBox userNameTB = new TextBox();  
    12.   
    13.         addBT.setMediator(mediator);  
    14.         list.setMediator(mediator);  
    15.         cb.setMediator(mediator);  
    16.         userNameTB.setMediator(mediator);  
    17.   
    18.         mediator.addButton = addBT;  
    19.         mediator.list = list;  
    20.         mediator.cb = cb;  
    21.         mediator.userNameTextBox = userNameTB;  
    22.           
    23.         addBT.changed();  
    24.         System.out.println("-----------------------------");  
    25.         list.changed();  
    26.     }  
    27. }  



    你可能感兴趣的:(设计模式)

    • 【iOS】MVC设计模式 Magnetic_h iosmvc设计模式objective-c学习ui
      MVC前言如何设计一个程序的结构，这是一门专门的学问，叫做"架构模式"（architecturalpattern），属于编程的方法论。MVC模式就是架构模式的一种。它是Apple官方推荐的App开发架构，也是一般开发者最先遇到、最经典的架构。MVC各层controller层Controller/ViewController/VC（控制器）负责协调Model和View，处理大部分逻辑它将数据从Mod
    • 【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数 广龙宇 一起学Rust#Rust设计模式rust设计模式开发语言
      提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
    • JAVA学习笔记之23种设计模式学习 victorfreedom Java技术设计模式androidjava常用设计模式
      博主最近买了《设计模式》这本书来学习，无奈这本书是以C++语言为基础进行说明，整个学习流程下来效率不是很高，虽然有的设计模式通俗易懂，但感觉还是没有充分的掌握了所有的设计模式。于是博主百度了一番，发现有大神写过了这方面的问题，于是博主迅速拿来学习。一、设计模式的分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器
    • 设计模式之建造者模式(通俗易懂--代码辅助理解【Java版】） ok!ko 设计模式设计模式建造者模式java
      文章目录设计模式概述1、建造者模式2、建造者模式使用场景3、优点4、缺点5、主要角色6、代码示例：1）实现要求2）UML图3)实现步骤：1）创建一个表示食物条目和食物包装的接口2）创建实现Packing接口的实体类3）创建实现Item接口的抽象类，该类提供了默认的功能4）创建扩展了Burger和ColdDrink的实体类5）创建一个Meal类，带有上面定义的Item对象6）创建一个MealBuil
    • 设计模式 23 访问者模式 WineMonk #设计模式设计模式访问者模式
      设计模式23创建型模式（5）：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式结构型模式（7）：适配器模式、桥接模式、组合模式、装饰者模式、外观模式、享元模式、代理模式行为型模式（11）：责任链模式、命令模式、解释器模式、迭代器模式、中介者模式、备忘录模式、观察者模式、状态模式、策略模式、模板方法模式、访问者模式文章目录设计模式23访问者模式（VisitorPattern）1定义2结构3
    • 设计模式】Listener模式和Visitor模式的区别 不爱洗脚的小滕 设计模式访问者模式javagolang
      文章目录前言一、介绍Listener模式Visitor模式二、代码实现2.1Listener模式的Java实现2.2Listener模式的Go实现2.3Visitor模式的Java实现2.4Visitor模式的Go实现三、总结前言在软件设计中，设计模式是解决特定问题的通用解决方案。Listener模式和Visitor模式是两种常见的行为设计模式，它们在不同的场景下提供了解决问题的有效方法。本文将详
    • 开发游戏的学习规划 杰克逊的日记 游戏学习
      第一阶段：●C#语言快速系统地学习一遍（基础的语法、面向对象、基础的数据结构、基础的设计模式）●Unity的2D和3D部分及UI、动画、物理系统●阶段性测验：需要去用前面所学的这些基础知识来完成一个简单的2d或者3d的案例，将通过一个自制的《Flappybird》游戏案例讲解游戏开发的思想及方法，并将《Flappybird》这个游戏进一步改造成一个横版射击类游戏《Crazybird》以巩固并且升华
    • 从单体到微服务：FastAPI ‘挂载’子应用程序的转变 黑金IT fastapi微服务fastapi架构
      在现代Web应用开发中，模块化架构是一种常见的设计模式，它有助于将大型应用程序分解为更小、更易于管理的部分。FastAPI，作为一个高性能的PythonWeb框架，提供了强大的支持来实现这种模块化设计。通过“挂载”子应用程序，我们可以为不同的功能区域（如前端接口、管理员接口和用户中心）创建独立的应用程序，并将它们整合到一个主应用程序中。本文将详细介绍如何在FastAPI中使用“挂载”子应用程序的方
    • [面试高频问题]关于多线程的单例模式 朱玥玥要每天学习 java单例模式开发语言
      单例模式什么是设计模式?设计模式可以看做为框架或者是围棋中的”棋谱”,红方当头炮,黑方马来跳.根据一些固定的套路下,能保证局势不会吃亏.在日常的程序设计中,往往有许多业务场景,根据这些场景,大佬们总结出了一些固定的套路.按照这个套路来实现代码,也不会吃亏.什么是单例模式,保证某类在程序中只有一个实例,而不会创建多份实例.单例模式具体的实现方式:可分为”懒汉模式”,”饿汉模式”.饿汉模式类加载的同时
    • 从简单到复杂：三种工厂模式的对比与应用 技术拾光者 设计模式java设计模式简单工厂模式抽象工厂模式工厂方法模式
      在软件设计中，创建型设计模式用于处理对象创建的复杂性。本文将对比三种常见的创建型设计模式：简单工厂模式、工厂方法模式和抽象工厂模式。一，简单工厂模式定义：简单工厂模式（SimpleFactoryPattern）定义了一个工厂类，该类可以根据传入的参数决定创建哪一种产品实例。结构：产品（Product）：定义产品的接口。具体产品（ConcreteProduct）：实现具体产品。工厂（Factory）
    • 当前最流行的架构设计模式 turingbooks
      《微服务设计（第2版）》最可贵的地方在于，不光具备理论性与系统性，更为注重实践性与可操作性。全书勾勒出一幅从宏观到细节，再到组织落地的微服务架构整体实施蓝图。无论是对关注微服务领域的工程师与架构师，还是对寻求架构升级的管理者与决策者来说，本书都可以作为指导手册。——沈剑，快狗打车CTO《微服务设计（第2版）》萨姆·纽曼|著钟健鑫张沙沙智伟|译软件开发大神MartinFowler如此推荐本书：“微服
    • 互联网 Java 工程师面试题（Java 面试题四） 苹果酱0567 面试题汇总与解析java中间件开发语言springboot后端
      下面列出这份Java面试问题列表包含的主题多线程，并发及线程基础数据类型转换的基本原则垃圾回收（GC）Java集合框架数组字符串GOF设计模式SOLID抽象类与接口Java基础，如equals和hashcode泛型与枚举JavaIO与NIO常用网络协议Java中的数据结构和算法正则表达式JVM底层Java最佳实JDBCDate,Time与CalendarJava处理XMLJUnit编程现在是时候给
    • 《Android进阶之光》— Android 书籍 王睿丶 Android永无止境《Android进阶之光》Android书籍Androidphoenix移动开发
      文章目录第1章Android新特性1第2章MaterialDesign48第3章View体系与自定义View87第4章多线程编程165第5章网络编程与网络框架204第6章设计模式271第7章事件总线308第8章函数响应式编程333第9章注解与依赖注入框架382第10章应用架构设计422第11章系统架构与MediaPlayer框架460出版年:2017-7简介：《Android进阶之光》是一本And
    • MyBatis 方法重载的陷阱及解决方案 molashaonian mybatis方法重载异常方法名相同
      在使用MyBatis进行开发时，尤其是使用注解模式（如@Select、@Insert等）时，开发者常常会遇到这样一个问题：为什么我的方法重载不能正常工作？即使在Java中允许方法名相同但参数不同的重载，MyBatis在处理注解的SQL方法时却并不支持这种方式。这篇文章将深入探讨MyBatis的这个特性及如何规避相关的坑。问题背景在标准的Java开发中，方法重载是一种常见的设计模式。方法重载允许我们
    • 【设计模式】结构型模式：组合模式 KunQAQrz
      意图使用组合模式可以将对象组合成树状结构，并且能像使用独立对象一样使用它们。组合模式结构在这里插入图片描述组件（Component）接口描述了树中简单项目和复杂项目所共有的操作。叶节点（Leaf）是树的基本结构，它不包含子项目。一般情况下，叶节点最终会完成大部分的实际工作，因为它们无法将工作指派给其他部分。容器（Container）又名“组合（Composite）”是包含叶节点或其他容器等子项目的
    • Java高并发编程详解系列-Balking设计模式 nihui123 高并发设计模式java编程语言
      导语  在实际操作中当某个线程因为发现其他线程正在进行相同的工作而放弃即将开始的任务，这种情况就被称为是Balking模式，Balking英文的意思是犹豫。在多个线程监控某个共享变量，A线程监控到共享变量发生变化后立即触发某个动作，但是这个这个时候发现了B线程也对该变量开始了行动，这个时候A变量就放弃了准备工作。下面就来详细的讲解一下关于Balking模式什么是Balking模式  在餐厅吃饭的时
    • Java高并发编程详解系列-Future设计模式 nihui123 高并发Java高并发Future高并发
      导语  假设，在一个使用场景中有一个任务需要执行比较长的时间，通常需要等待任务执行结束之后或者是中途出错之后才能返回结果。在这个期间调用者只能等待，对于这个结果Future设计模式提供了一种凭据式的解决方案。在日常生活中，这种方案也是存在的。例如去洗衣店洗衣服，当你把衣服放到洗衣店，等他洗完需要一段时间，这个时候洗衣店就会给你一凭证，你可以通过这个凭证到时候去取洗好的衣服。这个例子就是生活中的Fu
    • 字节跳动面试官亲述：Android开发学会了这些技术，你离大厂不远了 m0_65322636 程序员架构移动开发android
      HTTPSHTTP是超文本传输协议，明文传输；HTTPS使用SSL协议对HTTP传输数据进行了加密HTTP默认80端口；HTTPS默认443端口优点：安全缺点：费时、SSL证书收费，加密能力还是有限的，但是比HTTP强多了2、Java基础&容器&同步&设计模式StringBuilder、StringBuffer、+、String.concat链接字符串：StringBuffer线程安全，Strin
    • 生产者消费者模式_Labview基础之生产者消费者设计模式（事件） weixin_39532699 生产者消费者模式
      1绪论近期，开了一个QQ群，刚开始的目的也是想多拉写软件相关的大神，有问题的时候也可以交流交流。记得当时有个软件在写的时候遇到了一个棘手的问题，outlook邮箱配置账户密码的问题，到现在也没解决，算了，也不是很迫切。2000人群就留在那里爬虫发单吧！建群以后才发现，原来这一块的小白还挺多，总结起来就一个原因：做这个软件的大多数都不是软件出生，都是因为临时要搭建一个上位机平台，匆匆入门......
    • 案例分析：如何用设计模式优化性能7 是小旭啊 fastapi
      设计模式就是对常用开发技巧进行的总结，它使得程序员之间交流问题，有了更专业、便捷的方式。比如，我们在《02|理论分析：性能优化有章可循，谈谈常用的切入点》中提到，I/O模块使用的是装饰器模式，你就能很容易想到I/O模块的代码组织方式。事实上，大多数设计模式并不能增加程序的性能，它只是代码的一种组织方式。本课时，我们将一一举例讲解和性能相关的几个设计模式，包括代理模式、单例模式、享元模式、原型模式等
    • 重修设计模式-结构型-代理模式 丶白泽 重修设计模式设计模式代理模式系统安全
      重修设计模式-结构型-代理模式在不改变原始类代码的情况下，通过引入代理类来给原始类附加功能。代理模式通过创建一个代理对象，使得客户端对目标对象的访问都通过代理对象间接进行，从而可以在不修改目标对象的前提下，增加额外的功能操作，如权限控制、日志记录、事务处理等。代理模式又分为静态代理和动态代理。静态代理（StaticProxy）：在程序运行前就已经存在代理类的字节码文件，代理类和委托类的关系在运行前
    • 如何利用命令模式实现一个手游后端架构? 隔窗听雨眠 命令模式
      命令模式的原理解读命令模式的英文翻译是CommandDesignPattern。在GoF的《设计模式》一书中，它是这么定义的：Thecommandpatternencapsulatesarequestasanobject,therebylettingusparameterizeotherobjectswithdifferentrequests,queueorlogrequests,andsuppo
    • 单例模式以及反射对单例模式的破坏及防御 CodeDunkster 单例模式javajavascript
      单例模式（SingletonPattern）是一种确保类在应用程序生命周期内只存在一个实例的设计模式。它不仅提供了全局访问点，还能节省内存、控制实例的生命周期。但常见的单例模式实现方式如饿汉式、懒汉式、双重校验锁、静态内部类等，虽然设计良好，但都容易被Java的反射机制所破坏。本文将介绍这些单例实现方式的优缺点、反射如何破坏它们的唯一性，以及如何防御这种破坏。1.单例模式的常见实现方式1.1饿汉式
    • Koa2 的洋葱模型是什么？它是如何实现的？ 极客李华 Koakoa
      Koa2的洋葱模型是什么？它是如何实现的？Koa2的洋葱模型是一种中间件执行流程的设计模式，它允许开发者在请求的处理过程中，按照特定的顺序依次执行一系列中间件函数。洋葱模型的实现基于Koa2框架的特性和原理。下面我将通过一个具体的案例来解释洋葱模型的概念和实现。假设我们有一个简单的Koa2应用，用于处理用户的HTTP请求。首先，我们需要创建一个Koa应用实例：constKoa=require('k
    • 设计模式-单例模式 SAO&asuna 设计模式学习设计模式单例模式开发语言
      文章目录1.为什么要学习单例模式2.单例模式的类型2.1饿汉式单例2.2懒汉式单例2.2.1一般实现2.2.2sync.once实现2.2.3sync.Mutex实现2.2.4原子引用2.2.5极致性能优化3单例模式的优缺点1.为什么要学习单例模式单例模式，就是在整个进程的过程中，只会存在一个实例。这样做的好处主要是两个：访问控制：访问控制也就是只有这一个口子可以得到该实例，一般是通过全局变量达到
    • 深入解析C++单例模式：从基础到线程安全的高效实现 shuai_258 c++全套攻略c++c++多线程开发语言c++qt
      引言在C++开发中，单例模式（SingletonPattern）是一种常见且重要的设计模式。它确保类的实例在整个程序生命周期中唯一，并提供一个全局访问点。这在日志管理、配置管理等场景中尤为常见。本篇博客将带你深入了解单例模式的实现原理，并介绍如何在多线程环境下实现线程安全的单例模式。什么是单例模式？单例模式是一种设计模式，其核心思想是确保某个类只能有一个实例，并提供一个全局的访问点。其应用场景包括
    • 漫谈设计模式 [17]：状态模式 AI让世界更懂你 设计模式状态模式python
      引导性开场菜鸟：老鸟，我最近在写一个项目，遇到一个问题。我们有一个订单系统，不同的订单状态需要执行不同的操作。现在代码里充满了各种if-else语句，维护起来好痛苦。有没有什么好的解决办法？老鸟：你这个问题很常见，很多人都会遇到类似的痛点。你有没有听说过状态模式？菜鸟：状态模式？好像听过，但不太了解。老鸟：没关系，我们可以一步步来。先讲讲你现在的实现方式吧。渐进式介绍概念菜鸟：好的，我现在是这样写
    • Java基础 --- 多线程&JUC，以及一些常用的设计模式总结 lzhlizihang java设计模式
      文章目录一、多线程1、线程和进程的区别2、创建多线程的四种方式3、集合中的线程安全二、设计模式1、单例模式2、装饰者模式（IO流缓冲流）3、适配器模式4、模板模式一、多线程1、线程和进程的区别进程是操作系统资源分配的基本单位，而线程是处理器任务调度和执行的基本单位，一个进程可以运行多个线程多进程：操作系统中同时运行的多个程序多线程：在同一个进程中同时运行的多个任务2、创建多线程的四种方式Runna
    • 【系统架构设计师】解释器模式 Evaporator Core 解释器模式python开发语言
      解释器模式（InterpreterPattern）是一种行为型设计模式，它定义了文法的表示，并定义了一个解释器，该解释器使用该表示来解释语言中的句子。在解释器模式中，通常包括一个抽象语法树（AbstractSyntaxTree,AST），用于表示输入的语言文法，以及一系列的解释器类，每个类对应文法中的一个符号或符号的组合。解释器模式主要适用于那些需要将一个语言中的句子解释成程序可以理解的另一种形式
    • 设计模式-分离接口（Separated Interface） workflower 设计方法设计模式课程设计设计规范开发语言软件需求
      在一个包中定义接口，而在另一个包中实现这个接口，两个包是分离的。背景为了减少部件之间的耦合程度改进设计质量，可以将类分组并组织成包，并限定包之间的依赖关系。但有时可能需要调用与包之间一般性依赖关系有冲突的方法，此时可以在一个包中定义接口，在另一个包中实现它。运行机制核心思想利用了：实现类对接口存在依赖关系，反之不然。其他包可以只依赖于接口包，而与实现包没有依赖关系。可以采用独立的包将接口与实现链接
    • ASM系列六 利用TreeApi 添加和移除类成员 lijingyao8206 jvm动态代理ASM字节码技术TreeAPI
          同生成的做法一样，添加和移除类成员只要去修改fields和methods中的元素即可。这里我们拿一个简单的类做例子，下面这个Task类，我们来移除isNeedRemove方法，并且添加一个int 类型的addedField属性。   package asm.core; /** * Created by yunshen.ljy on 2015/6/
    • Springmvc-权限设计 bee1314 springWebjsp
      万丈高楼平地起。 权限管理对于管理系统而言已经是标配中的标配了吧，对于我等俗人更是不能免俗。同时就目前的项目状况而言，我们还不需要那么高大上的开源的解决方案，如Spring Security，Shiro。小伙伴一致决定我们还是从基本的功能迭代起来吧。 目标： 1.实现权限的管理（CRUD） 2.实现部门管理 （CRUD) 3.实现人员的管理 （CRUD） 4.实现部门和权限
    • 算法竞赛入门经典（第二版）第2章习题 CrazyMizzz c算法
      2.4.1 输出技巧 #include <stdio.h> int main() { int i, n; scanf("%d", &n); for (i = 1; i <= n; i++) printf("%d\n", i); return 0; } 习题2-2 水仙花数(daffodil
    • struts2中jsp自动跳转到Action 麦田的设计者 jspwebxmlstruts2自动跳转
      1、在struts2的开发中，经常需要用户点击网页后就直接跳转到一个Action，执行Action里面的方法，利用mvc分层思想执行相应操作在界面上得到动态数据。毕竟用户不可能在地址栏里输入一个Action（不是专业人士）   2、＜jsp:forward page="xxx.action" /＞ ，这个标签可以实现跳转，page的路径是相对地址,不同与jsp和j
    • php 操作webservice实例 IT独行者 PHPwebservice
      首先大家要简单了解了何谓webservice，接下来就做两个非常简单的例子，webservice还是逃不开server端与client端。我测试的环境为：apache2.2.11 php5.2.10做这个测试之前，要确认你的php配置文件中已经将soap扩展打开，即extension=php_soap.dll; OK 现在我们来体验webservice //server端 serve
    • Windows下使用Vagrant安装linux系统 _wy_ windowsvagrant
      准备工作： 下载安装 VirtualBox ：https://www.virtualbox.org/ 下载安装 Vagrant ：http://www.vagrantup.com/ 下载需要使用的 box ： 官方提供的范例：http://files.vagrantup.com/precise32.box 还可以在 http://www.vagrantbox.es/ 
    • 更改linux的文件拥有者及用户组(chown和chgrp) 无量 clinuxchgrpchown
      本文（转） http://blog.163.com/yanenshun@126/blog/static/128388169201203011157308/ http://ydlmlh.iteye.com/blog/1435157 一、基本使用： 使用chown命令可以修改文件或目录所属的用户：        命令
    • linux下抓包工具 矮蛋蛋 linux
      原文地址： http://blog.chinaunix.net/uid-23670869-id-2610683.html tcpdump -nn -vv -X udp port 8888 上面命令是抓取udp包、端口为8888 netstat -tln 命令是用来查看linux的端口使用情况 13 . 列出所有的网络连接 lsof -i 14. 列出所有tcp 网络连接信息 l
    • 我觉得mybatis是垃圾！：“每一个用mybatis的男纸，你伤不起” alafqq mybatis
      最近看了  每一个用mybatis的男纸，你伤不起 原文地址 ：http://www.iteye.com/topic/1073938 发表一下个人看法。欢迎大神拍砖； 个人一直使用的是Ibatis框架，公司对其进行过小小的改良； 最近换了公司，要使用新的框架。听说mybatis不错；就对其进行了部分的研究； 发现多了一个mapper层；个人感觉就是个dao；
    • 解决java数据交换之谜 百合不是茶 数据交换
      交换两个数字的方法有以下三种 ，其中第一种最常用   /* 输出最小的一个数 */ public class jiaohuan1 { public static void main(String[] args) { int a =4; int b = 3; if(a<b){ // 第一种交换方式 int tmep =
    • 渐变显示 bijian1013 JavaScript
      <style type="text/css"> #wxf { FILTER: progid:DXImageTransform.Microsoft.Gradient(GradientType=0, StartColorStr=#ffffff, EndColorStr=#97FF98); height: 25px; } </style>
    • 探索JUnit4扩展：断言语法assertThat bijian1013 java单元测试assertThat
      一.概述         JUnit 设计的目的就是有效地抓住编程人员写代码的意图，然后快速检查他们的代码是否与他们的意图相匹配。 JUnit 发展至今，版本不停的翻新，但是所有版本都一致致力于解决一个问题，那就是如何发现编程人员的代码意图，并且如何使得编程人员更加容易地表达他们的代码意图。JUnit 4.4 也是为了如何能够
    • 【Gson三】Gson解析{"data":{"IM":["MSN","QQ","Gtalk"]}} bit1129 gson
        如何把如下简单的JSON字符串反序列化为Java的POJO对象? {"data":{"IM":["MSN","QQ","Gtalk"]}}   下面的POJO类Model无法完成正确的解析：   import com.google.gson.Gson;
    • 【Kafka九】Kafka High Level API vs. Low Level API bit1129 kafka
      1. Kafka提供了两种Consumer API High Level Consumer API Low Level Consumer API(Kafka诡异的称之为Simple Consumer API，实际上非常复杂) 在选用哪种Consumer API时，首先要弄清楚这两种API的工作原理，能做什么不能做什么，能做的话怎么做的以及用的时候，有哪些可能的问题  
    • 在nginx中集成lua脚本：添加自定义Http头，封IP等 ronin47 nginx lua
      Lua是一个可以嵌入到Nginx配置文件中的动态脚本语言，从而可以在Nginx请求处理的任何阶段执行各种Lua代码。刚开始我们只是用Lua 把请求路由到后端服务器，但是它对我们架构的作用超出了我们的预期。下面就讲讲我们所做的工作。 强制搜索引擎只索引mixlr.com Google把子域名当作完全独立的网站，我们不希望爬虫抓取子域名的页面，降低我们的Page rank。 location /{
    • java-归并排序 bylijinnan java
      import java.util.Arrays; public class MergeSort { public static void main(String[] args) { int[] a={20,1,3,8,5,9,4,25}; mergeSort(a,0,a.length-1); System.out.println(Arrays.to
    • Netty源码学习-CompositeChannelBuffer bylijinnan javanetty
      CompositeChannelBuffer体现了Netty的“Transparent Zero Copy” 查看API（ http://docs.jboss.org/netty/3.2/api/org/jboss/netty/buffer/package-summary.html#package_description） 可以看到，所谓“Transparent Zero Copy”是通
    • Android中给Activity添加返回键 hotsunshine Activity
      // this need android:minSdkVersion="11" getActionBar().setDisplayHomeAsUpEnabled(true); @Override public boolean onOptionsItemSelected(MenuItem item) {
    • 静态页面传参 ctrain 静态
      $(document).ready(function () { var request = { QueryString : function (val) { var uri = window.location.search; var re = new RegExp("" + val + "=([^&?]*)", &
    • Windows中查找某个目录下的所有文件中包含某个字符串的命令 daizj windows查找某个目录下的所有文件包含某个字符串
      findstr可以完成这个工作。   [html]  view plain copy   >findstr /s /i "string" *.*   上面的命令表示，当前目录以及当前目录的所有子目录下的所有文件中查找"string&qu
    • 改善程序代码质量的一些技巧 dcj3sjt126com 编程PHP重构
      有很多理由都能说明为什么我们应该写出清晰、可读性好的程序。最重要的一点，程序你只写一次，但以后会无数次的阅读。当你第二天回头来看你的代码 时，你就要开始阅读它了。当你把代码拿给其他人看时，他必须阅读你的代码。因此，在编写时多花一点时间，你会在阅读它时节省大量的时间。让我们看一些基本的编程技巧：    尽量保持方法简短    尽管很多人都遵
    • SharedPreferences对数据的存储 dcj3sjt126com
      SharedPreferences简介：                                                   &nbs
    • linux复习笔记之bash shell (2) bash基础 eksliang bashbash shell
      转载请出自出处： http://eksliang.iteye.com/blog/2104329 1.影响显示结果的语系变量（locale）  1.1locale这个命令就是查看当前系统支持多少种语系，命令使用如下： [root@localhost shell]# locale LANG=en_US.UTF-8 LC_CTYPE="en_US.UTF-8"
    • Android零碎知识总结 gqdy365 android
      1、CopyOnWriteArrayList add(E) 和remove(int index)都是对新的数组进行修改和新增。所以在多线程操作时不会出现java.util.ConcurrentModificationException错误。 所以最后得出结论：CopyOnWriteArrayList适合使用在读操作远远大于写操作的场景里，比如缓存。发生修改时候做copy，新老版本分离，保证读的高
    • HoverTree.Model.ArticleSelect类的作用 hvt Web.netC#hovertreeasp.net
      ArticleSelect类在命名空间HoverTree.Model中可以认为是文章查询条件类，用于存放查询文章时的条件，例如HvtId就是文章的id。HvtIsShow就是文章的显示属性，当为-1是，该条件不产生作用，当为0时，查询不公开显示的文章，当为1时查询公开显示的文章。HvtIsHome则为是否在首页显示。HoverTree系统源码完全开放，开发环境为Visual Studio 2013
    • PHP 判断是否使用代理 PHP Proxy Detector 天梯梦 proxy
      1. php 类 I found this class looking for something else actually but I remembered I needed some while ago something similar and I never found one. I'm sure it will help a lot of developers who try to
    • apache的math库中的回归——regression（翻译） lvdccyb Mathapache
      这个Math库，虽然不向weka那样专业的ML库，但是用户友好，易用。 多元线性回归，协方差和相关性（皮尔逊和斯皮尔曼），分布测试（假设检验，t，卡方，G），统计。   数学库中还包含，Cholesky，LU，SVD，QR，特征根分解，真不错。   基本覆盖了：线代，统计，矩阵， 最优化理论 曲线拟合 常微分方程 遗传算法（GA）， 还有3维的运算。。。
    • 基础数据结构和算法十三：Undirected Graphs (2) sunwinner Algorithm
        Design pattern for graph processing. Since we consider a large number of graph-processing algorithms, our initial design goal is to decouple our implementations from the graph representation
    • 云计算平台最重要的五项技术 sumapp 云计算云平台智城云
      云计算平台最重要的五项技术 1、云服务器 云服务器提供简单高效，处理能力可弹性伸缩的计算服务，支持国内领先的云计算技术和大规模分布存储技术，使您的系统更稳定、数据更安全、传输更快速、部署更灵活。 特性 机型丰富 通过高性能服务器虚拟化为云服务器，提供丰富配置类型虚拟机，极大简化数据存储、数据库搭建、web服务器搭建等工作； 仅需要几分钟，根据CP
    • 《京东技术解密》有奖试读获奖名单公布 ITeye管理员 活动
      ITeye携手博文视点举办的12月技术图书有奖试读活动已圆满结束，非常感谢广大用户对本次活动的关注与参与。  12月试读活动回顾： http://webmaster.iteye.com/blog/2164754 本次技术图书试读活动获奖名单及相应作品如下： 一等奖（两名） Microhardest：http://microhardest.ite