设计模式课程 设计模式精讲 21-3 观察者模式源码解析
Posted 1446358788-qq
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了设计模式课程 设计模式精讲 21-3 观察者模式源码解析相关的知识，希望对你有一定的参考价值。
1 源码解析
1.1 源码解析1（jdk中的应用）
1.2 源码解析2（Spring中的应用）
1.3 源码解析为何算出666？
1 源码解析
1.1 源码解析1（jdk中的应用）
java.util.regex.Pattern
(java正则表达式通过java.util.regex包下的Pattern类与Matcher类实现)
1.2 源码解析2（Spring中的应用）
测试类：（通过el表达式计算出结果）（以下代码中红色粗体为跳转顺序)
package com.geely.design.pattern.behavioral.interpreter;
import org.springframework.expression.Expression;
import org.springframework.expression.spel.standard.SpelExpressionParser;
/**
* Created by geely
*/
public class SpringTest {
public static void main(String[] args) {
org.springframework.expression.ExpressionParser parser = new SpelExpressionParser();
Expression expression = parser.parseExpression("100 * 2 + 400 * 1 + 66");
int result = (Integer) expression.getValue();
System.out.println(result);
}
}
应用类1：
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//
package org.springframework.expression.common;
import java.util.LinkedList;
import java.util.List;
import java.util.Stack;
import org.springframework.expression.Expression;
import org.springframework.expression.ExpressionParser;
import org.springframework.expression.ParseException;
import org.springframework.expression.ParserContext;
public abstract class TemplateAwareExpressionParser implements ExpressionParser {
private static final ParserContext NON_TEMPLATE_PARSER_CONTEXT = new ParserContext() {
public String getExpressionPrefix() {
return null;
}
public String getExpressionSuffix() {
return null;
}
public boolean isTemplate() {
return false;
}
};
public TemplateAwareExpressionParser() {
}
public Expression parseExpression(String expressionString) throws ParseException {
return this.parseExpression(expressionString, NON_TEMPLATE_PARSER_CONTEXT);
}
public Expression parseExpression(String expressionString, ParserContext context) throws ParseException {
if (context == null) {
context = NON_TEMPLATE_PARSER_CONTEXT;
}
return context.isTemplate() ? this.parseTemplate(expressionString, context) : this.doParseExpression(expressionString, context);
}
private Expression parseTemplate(String expressionString, ParserContext context) throws ParseException {
if (expressionString.length() == 0) {
return new LiteralExpression("");
} else {
Expression[] expressions = this.parseExpressions(expressionString, context);
return (Expression)(expressions.length == 1 ? expressions[0] : new CompositeStringExpression(expressionString, expressions));
}
}
private Expression[] parseExpressions(String expressionString, ParserContext context) throws ParseException {
List<Expression> expressions = new LinkedList();
String prefix = context.getExpressionPrefix();
String suffix = context.getExpressionSuffix();
int startIdx = 0;
while(startIdx < expressionString.length()) {
int prefixIndex = expressionString.indexOf(prefix, startIdx);
if (prefixIndex >= startIdx) {
if (prefixIndex > startIdx) {
expressions.add(this.createLiteralExpression(context, expressionString.substring(startIdx, prefixIndex)));
}
int afterPrefixIndex = prefixIndex + prefix.length();
int suffixIndex = this.skipToCorrectEndSuffix(prefix, suffix, expressionString, afterPrefixIndex);
if (suffixIndex == -1) {
throw new ParseException(expressionString, prefixIndex, "No ending suffix ‘" + suffix + "‘ for expression starting at character " + prefixIndex + ": " + expressionString.substring(prefixIndex));
}
if (suffixIndex == afterPrefixIndex) {
throw new ParseException(expressionString, prefixIndex, "No expression defined within delimiter ‘" + prefix + suffix + "‘ at character " + prefixIndex);
}
String expr = expressionString.substring(prefixIndex + prefix.length(), suffixIndex);
expr = expr.trim();
if (expr.length() == 0) {
throw new ParseException(expressionString, prefixIndex, "No expression defined within delimiter ‘" + prefix + suffix + "‘ at character " + prefixIndex);
}
expressions.add(this.doParseExpression(expr, context));
startIdx = suffixIndex + suffix.length();
} else {
expressions.add(this.createLiteralExpression(context, expressionString.substring(startIdx)));
startIdx = expressionString.length();
}
}
return (Expression[])expressions.toArray(new Expression[expressions.size()]);
}
private Expression createLiteralExpression(ParserContext context, String text) {
return new LiteralExpression(text);
}
private boolean isSuffixHere(String expressionString, int pos, String suffix) {
int suffixPosition = 0;
for(int i = 0; i < suffix.length() && pos < expressionString.length(); ++i) {
if (expressionString.charAt(pos++) != suffix.charAt(suffixPosition++)) {
return false;
}
}
return suffixPosition == suffix.length();
}
private int skipToCorrectEndSuffix(String prefix, String suffix, String expressionString, int afterPrefixIndex) throws ParseException {
int pos = afterPrefixIndex;
int maxlen = expressionString.length();
int nextSuffix = expressionString.indexOf(suffix, afterPrefixIndex);
if (nextSuffix == -1) {
return -1;
} else {
Stack stack;
for(stack = new Stack(); pos < maxlen && (!this.isSuffixHere(expressionString, pos, suffix) || !stack.isEmpty()); ++pos) {
char ch = expressionString.charAt(pos);
switch(ch) {
case ‘"‘:
case ‘‘‘:
int endLiteral = expressionString.indexOf(ch, pos + 1);
if (endLiteral == -1) {
throw new ParseException(expressionString, pos, "Found non terminating string literal starting at position " + pos);
}
pos = endLiteral;
break;
case ‘(‘:
case ‘[‘:
case ‘{‘:
stack.push(new TemplateAwareExpressionParser.Bracket(ch, pos));
break;
case ‘)‘:
case ‘]‘:
case ‘}‘:
if (stack.isEmpty()) {
throw new ParseException(expressionString, pos, "Found closing ‘" + ch + "‘ at position " + pos + " without an opening ‘" + TemplateAwareExpressionParser.Bracket.theOpenBracketFor(ch) + "‘");
}
TemplateAwareExpressionParser.Bracket p = (TemplateAwareExpressionParser.Bracket)stack.pop();
if (!p.compatibleWithCloseBracket(ch)) {
throw new ParseException(expressionString, pos, "Found closing ‘" + ch + "‘ at position " + pos + " but most recent opening is ‘" + p.bracket + "‘ at position " + p.pos);
}
}
}
if (!stack.isEmpty()) {
TemplateAwareExpressionParser.Bracket p = (TemplateAwareExpressionParser.Bracket)stack.pop();
throw new ParseException(expressionString, p.pos, "Missing closing ‘" + TemplateAwareExpressionParser.Bracket.theCloseBracketFor(p.bracket) + "‘ for ‘" + p.bracket + "‘ at position " + p.pos);
} else {
return !this.isSuffixHere(expressionString, pos, suffix) ? -1 : pos;
}
}
}
protected abstract Expression doParseExpression(String var1, ParserContext var2) throws ParseException;
private static class Bracket {
char bracket;
int pos;
Bracket(char bracket, int pos) {