想做网站选什么专业,佳木斯建设局网站,wordpress视频教程下载,wordpress变英文目录1 中介模式详解1.1 中介模式的定义1.1.1 中介者模式在生活场景中应用1.1.2 中介者模式的使用场景1.2 中介模式的通用实现1.2.1 类图设计1.2.2 代码实现1.3 中介模式应用案例之聊天室1.3.1 类图设计1.3.2 代码实现1.4 中介者模式在源码中应用1.4.1 jdk中Timer类1.5 中介者模…
目录1 中介模式详解1.1 中介模式的定义1.1.1 中介者模式在生活场景中应用1.1.2 中介者模式的使用场景1.2 中介模式的通用实现1.2.1 类图设计1.2.2 代码实现1.3 中介模式应用案例之聊天室1.3.1 类图设计1.3.2 代码实现1.4 中介者模式在源码中应用1.4.1 jdk中Timer类1.5 中介者模式使用总结1.5.1 优缺点总结1.5.2 与其他模式的关系总结2 解释器模式详解2.1 解释器模式的定义2.1.1 解释器模式在生活场景中应用2.1.2 解释器模式的适用场景2.2 解释器模式的通用实现2.2.1 类图设计2.2.2 代码实现2.3 解释器模式实现案例之计算器功能2.3.1 类图设计2.3.2 代码实现2.3.3 解释器模式在源码中应用2.4.4 spring中ExpressionParser2.5 解释器模式的使用总结2.5.1 优缺点总结1 中介模式详解
1.1 中介模式的定义
定义
中介者模式【Mediator Pattern】,又称调解者模式或调停者模式。用一个中介对象封装一系列的对象
交互中介者使用各对象不需要显式地相互作用从而使其耦合松散而且可以独立地改变它们之间的交互。
核心
通过中介者解耦系统各层次对象的直接耦合层次对象的对外依赖通信统统交由中介者转发。
属于行为型模式。
1.1.1 中介者模式在生活场景中应用
1.人际交往圈通讯网络。如果需要自己逐个去建立关系会很困难且复杂如果加入中介者来维护这个网络。
中介者就很方便了。
2.朋友圈。
3.数据整合中心
4.rpc通信
1.1.2 中介者模式的使用场景
1.系统中对象之间存在复杂的引用关系产生相互依赖关系结构混乱且难以理解。
2.交互的公共行为如果需要改变行为则可以增加新的中介者类。
1.2 中介模式的通用实现
1.2.1 类图设计 1.2.2 代码实现
1.3 中介模式应用案例之聊天室
很多人进入一个聊天室或聊天群里群或聊天室都充当中介者的角色。
1.3.1 类图设计 说明
这里通过用户名表示不同用户。
1.3.2 代码实现
1.中介者【聊天室】
package com.oldlu.mediator.demo.chatroom;/*** ClassName ChatRoom* Description 聊天室* Author oldlu* Version 1.0*/
public class ChatRoom {public void showMsg(User user,String message){System.out.println(【user.getName() 】传达信息message);}
}它就只是一个传话者把信息发布者的内容传达出来。
2.用户类【聊天者】
package com.oldlu.mediator.demo.chatroom;/*** ClassName User* Description 用户类* Author oldlu* Version 1.0*/
public class User {private ChatRoom chatRoom;private String name;public String getName() {return name;}public User(String name,ChatRoom chatRoom) {this.chatRoom chatRoom;this.name name;}public void sendMessage(String msg){//用户传达信息通过聊天室this.chatRoom.showMsg(this, msg);}
}3.测试类
package com.oldlu.mediator.demo.chatroom;/*** ClassName Test* Description 测试类* Author oldlu* Version 1.0*/
public class Test {public static void main(String[] args) {ChatRoom chatRoom new ChatRoom();User tom new User(Tom,chatRoom);User jerry new User(Jerry,chatRoom);tom.sendMessage(大家好我是tom.getName()欢迎大家进入聊天室);jerry.sendMessage(大家好我是jerry.getName()欢迎大家进入聊天室);}
}测试结果 1.4 中介者模式在源码中应用
1.4.1 jdk中Timer类
private void sched(TimerTask task, long time, long period) {if (time 0)throw new IllegalArgumentException(Illegal execution time.);// Constrain value of period sufficiently to prevent numeric// overflow while still being effectively infinitely large.if (Math.abs(period) (Long.MAX_VALUE 1))period 1;synchronized(queue) {if (!thread.newTasksMayBeScheduled)throw new IllegalStateException(Timer already cancelled.);synchronized(task.lock) {if (task.state ! TimerTask.VIRGIN)throw new IllegalStateException(Task already scheduled or cancelled);task.nextExecutionTime time;task.period period;task.state TimerTask.SCHEDULED;}queue.add(task);if (queue.getMin() task)queue.notify();}}Timer类中有多个schedule重载方法内部都调用sched方法Timer本身是没有做什么事的。
它只是调用Quequ队列add,把TimerTask添加进去。所以Timer充当中介者的角色。
1.5 中介者模式使用总结
1.5.1 优缺点总结
优点
1.减少类间依赖将多对多依赖关系转化成一对多的关系降低了类间的耦合性。
2.类间各司其职符合迪米特法则。
缺点
中介者模式将原本多个对象直接的相互依赖关系变成依赖中介者和多个同事类的依赖关系。
当同事类越来越多时中介者责任越来越大且复杂难以维护。 1.5.2 与其他模式的关系总结
中介者模式和代理模式的区别
1.都存在中间角色。
2.代理模式着重在代理【增强功能】
3.中介者模式只他帮你联系上了就不管了后面的事情全权由自己完成。【只管搭桥】
2 解释器模式详解
2.1 解释器模式的定义
定义
解释器模式【Interpretor Pattern】给定一个语言定义它的文法的一种表示并定义解释器。
这个解释器使用该表示来解释语言中的句子。
特征
为了解释一种语言而为语言创建的解释器。
属于行为型模式。
2.1.1 解释器模式在生活场景中应用
1.音乐简谱
2.摩斯密码
2.1.2 解释器模式的适用场景
1.一些重复出现的问题可以一种简单的语言来进行表达
2.一个简单的语法 需要解释的场景
2.2 解释器模式的通用实现
2.2.1 类图设计
2.2.2 代码实现
2.3 解释器模式实现案例之计算器功能
2.3.1 类图设计 2.3.2 代码实现
1.计算器功能
package com.oldlu.interpreter.demo.calculate;import java.util.Stack;
/*** ClassName Calculator* Description 计算器* Author oldlu* Version 1.0*/
public class Calculator {private StackIArithmeticInterpreter stack new Stack();public Calculator(String expression) {parse(expression);}private void parse(String expression) {//解析 10 20 表达式String[] eles expression.split( );IArithmeticInterpreter left,right;for(int i 0;i eles.length;i){String operator eles[i];if(OperateUtil.ifOperator(operator)){left this.stack.pop();right new NumInterpreter(Integer.valueOf(eles[i]));System.out.println(出栈left.interpret()和right.interpret());this.stack.push(OperateUtil.getInterpreter(left,right,operator));System.out.println(应用运算符operator);}else {NumInterpreter numInterpreter new NumInterpreter(Integer.valueOf(eles[i]));this.stack.push(numInterpreter);System.out.println(入栈numInterpreter.interpret());}}}public int calculate(){return this.stack.pop().interpret();}
}2.解释器顶层接口
package com.oldlu.interpreter.demo.calculate;/*** ClassName IArithmeticInterpreter* Description 顶层解释器接口* Author oldlu* Version 1.0*/
public interface IArithmeticInterpreter {int interpret();
}3.数值解释器实现
package com.oldlu.interpreter.demo.calculate;/*** ClassName NumInterpreter* Description 具体解释器实现类终结表达式* Author oldlu* Date 2020/6/23 14:24* Version 1.0*/
public class NumInterpreter implements IArithmeticInterpreter {private int value;public NumInterpreter(int value) {this.value value;}Overridepublic int interpret() {return this.value;}
}4.两个操作数解释器抽象类
package com.oldlu.interpreter.demo.calculate;/*** ClassName Interpreter* Description 操作数解释器实现* Author oldlu* Version 1.0*/
public abstract class Interpreter implements IArithmeticInterpreter {protected IArithmeticInterpreter left;protected IArithmeticInterpreter right;public Interpreter(IArithmeticInterpreter left, IArithmeticInterpreter right) {this.left left;this.right right;}//这里是一个空方法具体逻辑在子类实现Overridepublic int interpret() {return 0;}
}5.四则运算解释器实现
package com.oldlu.interpreter.demo.calculate;/*** ClassName AddInterpreter* Description 运算符解释器* Author oldlu* Version 1.0*/
public class AddInterpreter extends Interpreter{public AddInterpreter(IArithmeticInterpreter left, IArithmeticInterpreter right) {super(left, right);}Overridepublic int interpret() {return this.left.interpret() this.right.interpret();}
}
package com.oldlu.interpreter.demo.calculate;/*** ClassName SubInterpreter* Description 减法解释器* Author oldlu* Version 1.0*/
public class SubInterpreter extends Interpreter{public SubInterpreter(IArithmeticInterpreter left, IArithmeticInterpreter right) {super(left, right);}Overridepublic int interpret() {return this.left.interpret() - this.right.interpret();}
}
package com.oldlu.interpreter.demo.calculate;/*** ClassName MultiInterpreter* Description 乘法解释器* Author oldlu* Version 1.0*/
public class MultiInterpreter extends Interpreter {public MultiInterpreter(IArithmeticInterpreter left, IArithmeticInterpreter right) {super(left, right);}Overridepublic int interpret() {return this.left.interpret() * this.right.interpret();}
}
package com.oldlu.interpreter.demo.calculate;/*** ClassName DivInterpreter* Description 除法解释器* Author oldlu* Version 1.0*/
public class DivInterpreter extends Interpreter{public DivInterpreter(IArithmeticInterpreter left, IArithmeticInterpreter right) {super(left, right);}Overridepublic int interpret() {return this.left.interpret() / this.right.interpret();}
}6.操作符工具类
package com.oldlu.interpreter.demo.calculate;/*** ClassName OperateUtil* Description 运算符解析工具类* Author oldlu* Version 1.0*/
public class OperateUtil {public static boolean ifOperator(String symbol){return (symbol.equals() || symbol.equals(-) || symbol.equals(*) || symbol.equals(/));}public static Interpreter getInterpreter(IArithmeticInterpreter left,IArithmeticInterpreter right,String symbol){if(symbol.equals()){return new AddInterpreter(left,right);}else if(symbol.equals(-)){return new SubInterpreter(left,right);}else if(symbol.equals(*)){return new MultiInterpreter(left,right);}else if(symbol.equals(/)){return new DivInterpreter(left,right);}return null;}
}7.测试类
package com.oldlu.interpreter.demo.calculate;/*** ClassName Test* Description 测试类* Author oldlu* Version 1.0*/
public class Test {public static void main(String[] args) {System.out.println(result:new Calculator(10 30).calculate());System.out.println(---------------------------);System.out.println(result:new Calculator(10 * 30).calculate());System.out.println(---------------------------);System.out.println(result:new Calculator(10 - 30 11).calculate());System.out.println(---------------------------);System.out.println(result:new Calculator(10 / 30 10 * 4 - 15).calculate());}
}测试结果 其实spring-expression模块中已经提供了四则运算的功能。
测试类如下
package com.oldlu.interpreter.demo.calculate;import org.springframework.expression.Expression;
import org.springframework.expression.ExpressionParser;
import org.springframework.expression.spel.standard.SpelExpressionParser;/*** ClassName SpringTest* Description spring表达式包测试* Author oldlu* Version 1.0*/
public class SpringTest {public static void main(String[] args) {ExpressionParser parser new SpelExpressionParser();Expression expression parser.parseExpression(10 / 30 10 * 4 - 15);Integer result (Integer) expression.getValue();System.out.println(计算结果result);//25}
}注意这个代码是有问题的
后面会进行分析并解决。如10 * 30 10 * 4 - 15表达式存在优先级问题默认按从左到右的顺序执行。
添加依赖 dependencygroupIdorg.springframework/groupIdartifactIdspring-expression/artifactIdversion5.0.2.RELEASE/version/dependency2.3.3 解释器模式在源码中应用
jdk下Pattern类
从构造器出发
private Pattern(String p, int f) {pattern p; //存储表达式flags f;// to use UNICODE_CASE if UNICODE_CHARACTER_CLASS presentif ((flags UNICODE_CHARACTER_CLASS) ! 0)flags | UNICODE_CASE;// Reset group index countcapturingGroupCount 1;localCount 0;if (pattern.length() 0) {compile(); //进行编译} else {root new Start(lastAccept);matchRoot lastAccept;}}2.4.4 spring中ExpressionParser 它是一个接口下面查看实现类SpelExpressionParser
protected SpelExpression doParseExpression(String expressionString, Nullable ParserContext context) throws ParseException {return new InternalSpelExpressionParser(this.configuration).doParseExpression(expressionString, context);
}2.5 解释器模式的使用总结
2.5.1 优缺点总结
优点
1.扩展性强在解释器模式中由于语法是由很多类表示当语法规则更改时只需要修改相应的非终结符表达式即可。
若扩展语法时只需添加相应的非终结符类即可。
2.增加了新的解释表达式的方式。
3.易于实现文法解释器模式对应的文法应当比较简单易于实现的过于复杂的语法不适合使用解释器模式。
缺点
1.语法规则比较复杂时会引起类大量增加。
2.执行效率比较低。
