探索者一号
探索者一号

Java23种设计模式/GOF设计模式--行为型模式

目录

行为型模式

第一类 父与子

13、策略模式（Strategy pattern）

14、模板方法（Template method pattern）

第二类 两个类之间

15、观察者模式（Observer pattern）

16、迭代器模式（Iterator pattern）

17、责任链模式（Chain-of-responsibility pattern）

18、命令模式（Command pattern）

第三类 类的状态

19、备忘录模式（Memento pattern）

20、状态模式（State pattern）

第四类 通过中间类

21、访问者模式（Visitor pattern）

22、中介者模式（Mediator pattern）

23、解释器模式（Interpreter pattern）

创建性模式

结构型模式

行为型模式

行为型模式

第一类 父与子

13、策略模式（Strategy pattern）

策略模式作为一种软件设计模式，指对象有某个行为，但是在不同的场景中，该行为有不同的实现算法。比如每个人都要“交个人所得税”，但是“在美国交个人所得税”和“在中国交个人所得税”就有不同的算税方法。

策略模式：

  • 定义了一族算法（业务规则）；
  • 封装了每个算法；
  • 这族的算法可互换代替（interchangeable）

UML

Java23种设计模式/GOF设计模式--行为型模式_第1张图片

 

代码举例

//StrategyExample test application

class StrategyExample {

    public static void main(String[] args) {

        Context context;

        // Three contexts following different strategies
        context = new Context(new FirstStrategy());
        context.execute();

        context = new Context(new SecondStrategy());
        context.execute();

        context = new Context(new ThirdStrategy());
        context.execute();

    }

}

// The classes that implement a concrete strategy should implement this

// The context class uses this to call the concrete strategy
interface Strategy {

    void execute();
    
}

// Implements the algorithm using the strategy interface
class FirstStrategy implements Strategy {

    public void execute() {
        System.out.println("Called FirstStrategy.execute()");
    }
    
}

class SecondStrategy implements Strategy {

    public void execute() {
        System.out.println("Called SecondStrategy.execute()");
    }
    
}

class ThirdStrategy implements Strategy {

    public void execute() {
        System.out.println("Called ThirdStrategy.execute()");
    }
    
}

// Configured with a ConcreteStrategy object and maintains a reference to a Strategy object
class Context {

    Strategy strategy;

    // Constructor
    public Context(Strategy strategy) {
        this.strategy = strategy;
    }

    public void execute() {
        this.strategy.execute();
    }

}

14、模板方法（Template method pattern）

封装不变，开放变化给实现者。做法是一个抽象类，有个门面方法，门面方法调用几个其他方法。不想被子类修改的定义为final，需要子类实现的为抽象方法。行为由父类控制，子类实现某个细节。

在很多框架的抽象类中，很多都属于这种模式。

第二类 两个类之间

15、观察者模式（Observer pattern）

就是常说的订阅-发布模式。

What problems can the Observer design pattern solve?

  • A one-to-many dependency between objects should be defined without making the objects tightly coupled.
  • It should be ensured that when one object changes state an open-ended number of dependent objects are updated automatically.
  • It should be possible that one object can notify an open-ended number of other objects.

Defining a one-to-many dependency between objects by defining one object (subject) that updates the state of dependent objects directly is inflexible because it commits (tightly couples) the subject to particular dependent objects. Tightly coupled objects are hard to implement, change, test, and reuse because they refer to and know about (how to update) many different objects with different interfaces.

UML

Java23种设计模式/GOF设计模式--行为型模式_第2张图片

代码举例

import java.util.Observable;
import java.util.Scanner;

class EventSource extends Observable implements Runnable {
    public void run() {
        while (true) {
            String response = new Scanner(System.in).next();
            setChanged();
            notifyObservers(response);
        }
    }
}
import java.util.Observable;
import java.util.Observer;

public class MyApp {
    public static void main(String[] args) {
        System.out.println("Enter Text: ");
        EventSource eventSource = new EventSource();

        eventSource.addObserver(new Observer() {
            public void update(Observable obj, Object arg) {
                System.out.println("Received response: " + arg);
            }
        });

        new Thread(eventSource).start();
    }
}

16、迭代器模式（Iterator pattern）

在面向对象编程里，迭代器模式是一种设计模式，是一种最简单也最常见的设计模式。它可以让用户透过特定的接口巡访容器中的每一个元素而不用了解底层的实现。java.util下的集合类都是可迭代的，由于有这些强大的工具类，我们很少自己去构造新的可迭代的数据结构。

代码举例

interface Iterator{
    Object First();
    Object Next();
    boolean IsDone();
    Object CurrentItem();
}

abstract class Aggregate{
    abstract Iterator CreateIterator();
}

class ConcreteIterator implements Iterator{
    private List list = new ArrayList();
    private int curr=0;
    public ConcreteIterator(List list){
        this.list = list;
    }

    public Object First(){
        return list.get(0);
    }

    public Object Next(){
        Object ret = null;
        curr++;
        if(curr < list.size()){
            ret = list.get(curr);
        }
        return ret;
    }

    public boolean IsDone(){
        return curr>=list.size()?true:false;
    }

    public Object CurrentItem(){
        return list.get(curr);
    }
}

class ConcreteAggregate extends Aggregate{
    private List list = new ArrayList();
    public ConcreteAggregate(List list){
        this.list = list;
    }
    public Iterator CreateIterator(){
        return new ConcreteIterator(list);
    }
}

class client{
    public static void main(String[] args){
    List list = new ArrayList();
    list.add("miner");
    list.add("any");
    Aggregate agg = new ConcreteAggregate(list);
    Iterator iterator = agg.CreateIterator();
    iterator.First();
    while(!iterator.IsDone()){
        System.out.println(iterator.CurrentItem());
        iterator.Next();
        }
    }
} 
  
17、责任链模式（Chain-of-responsibility pattern）
 
  
 
  
参考servlet中的Filter，各个过滤器构成了一个过滤器链。使用时依次迭代各个责任链，只要一直返回成功就一直走下去，返回失败结束执行，避免了写一堆if  else-if else-if else-if
 
  
Java23种设计模式/GOF设计模式--行为型模式_第3张图片
 
  
18、命令模式（Command pattern）
 
  
 
  
面向对象编程的范畴中，命令模式（英语：Command pattern）是一种设计模式，它尝试以对象来代表实际行动。命令对象可以把行动(action) 及其参数封装起来，于是这些行动可以被：
 
  
     
   
  • 重复多次
    •  
   
  • 取消（如果该对象有实现的话）
    •  
   
  • 取消后又再重做
    •  
  
 
  
这些都是现代大型应用程序所必须的功能，即“撤消”及“重复”。除此之外，可以用命令模式来实现的功能例子还有：
 
  
     
   
  • 交易行为
    •  
   
  • 进度列
    •  
   
  • 向导
    •  
   
  • 用户界面按钮及功能表项目
    •  
   
  • 线程 pool
    •  
   
  • 宏收录
    •  
  
 
  
UML
 
  
Java23种设计模式/GOF设计模式--行为型模式_第4张图片
 
  
代码举例
 
  
import java.util.List;
import java.util.ArrayList;

/* The Command interface */
public interface Command {
   void execute();
}

/* The Receiver class */
public class Light {
   public Light() {
   }

   public void turnOn() {
      System.out.println("The light is on");
   }

   public void turnOff() {
      System.out.println("The light is off");
   }
}

/* The Command for turning on the light - ConcreteCommand #1 */
public class FlipUpCommand implements Command {
   private Light theLight;

   public FlipUpCommand(Light light) {
      this.theLight = light;
   }

   public void execute(){
      theLight.turnOn();
   }
}

/* The Command for turning off the light - ConcreteCommand #2 */
public class FlipDownCommand implements Command {
   private Light theLight;

   public FlipDownCommand(Light light) {
      this.theLight = light;
   }

   public void execute() {
      theLight.turnOff();
   }
}


/* The Invoker class */
public class Switch {
   private List history = new ArrayList();

   public Switch() {
   }

   public void storeAndExecute(Command cmd) {
      this.history.add(cmd); // optional 
      cmd.execute();        
   }
}

/* The test class or client */
public class PressSwitch {
   public static void main(String[] args){
      Light lamp = new Light();
      Command switchUp = new FlipUpCommand(lamp);
      Command switchDown = new FlipDownCommand(lamp);

      Switch mySwitch = new Switch();

      try {
         if ("ON".equalsIgnoreCase(args[0])) {
            mySwitch.storeAndExecute(switchUp);
         }
         else if ("OFF".equalsIgnoreCase(args[0])) {
            mySwitch.storeAndExecute(switchDown);
         }
         else {
            System.out.println("Argument \"ON\" or \"OFF\" is required.");
         }
      } catch (Exception e) {
         System.out.println("Arguments required.");
      }
   }
}
 
  
第三类 类的状态
 
  
19、备忘录模式（Memento pattern）
 
  
 
  
备忘录模式是备份的思想，将类当前的状态、信息备份起来，必要时恢复，不拘泥一个固定的结构。
 
  
UML
 
  
Java23种设计模式/GOF设计模式--行为型模式_第5张图片
 
  
代码举例
 
  
import java.util.List;
import java.util.ArrayList;
class Originator {
    private String state;
    // The class could also contain additional data that is not part of the
    // state saved in the memento..
 
    public void set(String state) {
        this.state = state;
        System.out.println("Originator: Setting state to " + state);
    }
 
    public Memento saveToMemento() {
        System.out.println("Originator: Saving to Memento.");
        return new Memento(this.state);
    }
 
    public void restoreFromMemento(Memento memento) {
        this.state = memento.getSavedState();
        System.out.println("Originator: State after restoring from Memento: " + state);
    }
 
    public static class Memento {
        private final String state;

        public Memento(String stateToSave) {
            state = stateToSave;
        }
 
        // accessible by outer class only
        private String getSavedState() {
            return state;
        }
    }
}
 
class Caretaker {
    public static void main(String[] args) {
        List savedStates = new ArrayList();
 
        Originator originator = new Originator();
        originator.set("State1");
        originator.set("State2");
        savedStates.add(originator.saveToMemento());
        originator.set("State3");
        // We can request multiple mementos, and choose which one to roll back to.
        savedStates.add(originator.saveToMemento());
        originator.set("State4");
 
        originator.restoreFromMemento(savedStates.get(1));   
    }
}
The output is:

Originator: Setting state to State1
Originator: Setting state to State2
Originator: Saving to Memento.
Originator: Setting state to State3
Originator: Saving to Memento.
Originator: Setting state to State4
Originator: State after restoring from Memento: State3
 
  
20、状态模式（State pattern）
 
  
 
  
在状态模式（State Pattern）中，类的行为是基于它的状态改变的。在状态模式中，我们创建表示各种状态的对象和一个行为随着状态对象改变而改变的 context 对象。
 
  
意图：允许对象在内部状态发生改变时改变它的行为，对象看起来好像修改了它的类。
 
  
主要解决：对象的行为依赖于它的状态（属性），并且可以根据它的状态改变而改变它的相关行为。
 
  
何时使用：代码中包含大量与对象状态有关的条件语句。
 
  
如何解决：将各种具体的状态类抽象出来。
 
  
状态模式解决什么问题？ 
 
  
     
   
  • An object should change its behavior when its internal state changes.
    •  
   
  • State-specific behavior should be defined independently. That is, new states should be added and the behavior of existing states should be changed independently.
    •  
  
 
  
Implementing state-specific behavior directly within a class is inflexible because it commits the class to a particular behavior and makes it impossible to add a new state or change the behavior of an existing state later independently from (without changing) the class.
 
  
步骤 1
 
  
创建一个接口。
 
  
State.java
public interface State {
   public void doAction(Context context);
}
 
  
步骤 2
 
  
创建实现接口的实体类。
 
  
StartState.java
public class StartState implements State {
 
   public void doAction(Context context) {
      System.out.println("Player is in start state");
      context.setState(this); 
   }
 
   public String toString(){
      return "Start State";
   }
}
 
  
StopState.java
public class StopState implements State {
 
   public void doAction(Context context) {
      System.out.println("Player is in stop state");
      context.setState(this); 
   }
 
   public String toString(){
      return "Stop State";
   }
}
 
  
步骤 3
 
  
创建 Context 类。
 
  
Context.java
public class Context {
   private State state;
 
   public Context(){
      state = null;
   }
 
   public void setState(State state){
      this.state = state;     
   }
 
   public State getState(){
      return state;
   }
}
 
  
步骤 4
 
  
使用 Context 来查看当状态 State 改变时的行为变化。
 
  
StatePatternDemo.java
public class StatePatternDemo {
   public static void main(String[] args) {
      Context context = new Context();
 
      StartState startState = new StartState();
      startState.doAction(context);
 
      System.out.println(context.getState().toString());
 
      StopState stopState = new StopState();
      stopState.doAction(context);
 
      System.out.println(context.getState().toString());
   }
}
 
  
步骤 5
 
  
执行程序，输出结果：
 
  
Player is in start state
Start State
Player is in stop state
Stop State
 
  
第四类 通过中间类
 
  
21、访问者模式（Visitor pattern）
 
  
 
  
将属性和行为分离，是一种回调思想。当不确定调用者如何利用自己时，构造一个接收访问的者方法accept，然后调用访问者的访问方法visit，将自己this作为参数传递过去。
 
  
参考景区，景区的大门不断accept游客visitor，游客一旦进来，景区就把自己交给了游客，游客想访问哪些具体的景点自己决定。
 
  
但如果景区以套票的形式，规定买什么样的票能访问哪些景点就成了普通的对象，拥有属性和特定的方法(服务)。
 
  
UML
 
  
Java23种设计模式/GOF设计模式--行为型模式_第6张图片
 
  
代码举例
 
  
interface Visitor {
     void visit(Wheel wheel);
     void visit(Engine engine);
     void visit(Body body);
     void visit(Car car);
 }

 class Wheel {
     private String name;
     Wheel(String name) {
         this.name = name;
     }
     String getName() {
         return this.name;
     }
     void accept(Visitor visitor) {
         visitor.visit(this);
     }
 }
  
 class Engine {
     void accept(Visitor visitor) {
         visitor.visit(this);
     }
 }

 class Body {
     void accept(Visitor visitor) {
         visitor.visit(this);
     }
 }

 class Car {
     private Engine  engine = new Engine();
     private Body    body   = new Body();
     private Wheel[] wheels 
         = { new Wheel("front left"), new Wheel("front right"),
             new Wheel("back left") , new Wheel("back right")  };
     void accept(Visitor visitor) {
         visitor.visit(this);
         engine.accept(visitor);
         body.accept(visitor);
         for (int i = 0; i < wheels.length; ++ i)
             wheels[i].accept(visitor);
     }
 }

 class PrintVisitor implements Visitor {
     public void visit(Wheel wheel) {
         System.out.println("Visiting " + wheel.getName()
                             + " wheel");
     }
     public void visit(Engine engine) {
         System.out.println("Visiting engine");
     }
     public void visit(Body body) {
         System.out.println("Visiting body");
     }
     public void visit(Car car) {
         System.out.println("Visiting car");
     }
 }

 public class VisitorDemo {
     static public void main(String[] args) {
         Car car = new Car();
         Visitor visitor = new PrintVisitor();
         car.accept(visitor);
     }
 }
 
  
22、中介者模式（Mediator pattern）
 
  
 
  
解耦需要沟通的各方，中介者就是消息中转站，信息的集散地，vue的消息总线就是这个思路。聊天软件的设计也是这个思想（只要不是P2P的），以微信为例，A发送B一条消息，是发给了微信的服务器，服务器转发给了B，B回消息也是如此，A和B不直接通信（解耦），这个服务器（系统）支撑起了几亿用户。
 
  
23、解释器模式（Interpreter pattern）
 
  
 
  
解释器模式不太好解释，构造自定义的语法，然后给出一个语句，能够解释它（往往翻译成一个语法数）。各类语法解释器就是这种思路。由于比较底层，我们一般很少用到，一旦用到的项目都是高大上的项目。
 
  
Java23种设计模式/GOF设计模式--行为型模式_第7张图片
 
  
   示例代码：
 
  
Following the interpreter pattern there is a class for each grammar rule.

import java.util.Map;

interface Expression {
    public int interpret(final Map variables);
}

class Number implements Expression {
    private int number;
    public Number(final int number)       { this.number = number; }
    public int interpret(final Map variables)  { return number; }
}

class Plus implements Expression {
    Expression leftOperand;
    Expression rightOperand;
    public Plus(final Expression left, final Expression right) {
        leftOperand = left;
        rightOperand = right;
    }
		
    public int interpret(final Map variables) {
        return leftOperand.interpret(variables) + rightOperand.interpret(variables);
    }
}

class Minus implements Expression {
    Expression leftOperand;
    Expression rightOperand;
    public Minus(final Expression left, final Expression right) {
        leftOperand = left;
        rightOperand = right;
    }
		
    public int interpret(final Map variables) {
        return leftOperand.interpret(variables) - rightOperand.interpret(variables);
    }
}

class Variable implements Expression {
    private String name;
    public Variable(final String name)       { this.name = name; }
    public int interpret(final Map variables) {
        if (null == variables.get(name)) return 0; // Either return new Number(0).
        return variables.get(name).interpret(variables);
    }
}
While the interpreter pattern does not address parsing[1]:247 a parser is provided for completeness.

import java.util.Map;
import java.util.Stack;

class Evaluator implements Expression {
    private Expression syntaxTree;

    public Evaluator(final String expression) {
        final Stack expressionStack = new Stack();
        for (final String token : expression.split(" ")) {
            if (token.equals("+")) {
                final Expression subExpression = new Plus(expressionStack.pop(), expressionStack.pop());
                expressionStack.push(subExpression);
            } else if (token.equals("-")) {
                // it's necessary remove first the right operand from the stack
                final Expression right = expressionStack.pop();
                // ..and after the left one
                final Expression left = expressionStack.pop();
                final Expression subExpression = new Minus(left, right);
                expressionStack.push(subExpression);
            } else
                expressionStack.push(new Variable(token));
        }
        syntaxTree = expressionStack.pop();
    }

    public int interpret(final Map context) {
        return syntaxTree.interpret(context);
    }
}
Finally evaluating the expression "w x z - +" with w = 5, x = 10, and z = 42.

import java.util.Map;
import java.util.HashMap;

public class InterpreterExample {
    public static void main(final String[] args) {
        final String expression = "w x z - +";
        final Evaluator sentence = new Evaluator(expression);
        final Map variables = new HashMap();
        variables.put("w", new Number(5));
        variables.put("x", new Number(10));
        variables.put("z", new Number(42));
        final int result = sentence.interpret(variables);
        System.out.println(result);
    }
}
 
  
国人的一个例子 https://www.jianshu.com/p/c138a1d2be5e
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

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

        

            

                
    
                    
  • 【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
设计方法设计模式课程设计设计规范开发语言软件需求
                        
    在一个包中定义接口，而在另一个包中实现这个接口，两个包是分离的。背景为了减少部件之间的耦合程度改进设计质量，可以将类分组并组织成包，并限定包之间的依赖关系。但有时可能需要调用与包之间一般性依赖关系有冲突的方法，此时可以在一个包中定义接口，在另一个包中实现它。运行机制核心思想利用了：实现类对接口存在依赖关系，反之不然。其他包可以只依赖于接口包，而与实现包没有依赖关系。可以采用独立的包将接口与实现链接
    
                    
    • 
                                
  • redis学习笔记——不仅仅是存取数据
                                    Everyday都不同
returnSourceexpire/delincr/lpush数据库分区redis
                                    
    最近项目中用到比较多redis，感觉之前对它一直局限于get/set数据的层面。其实作为一个强大的NoSql数据库产品，如果好好利用它，会带来很多意想不到的效果。（因为我搞java，所以就从jedis的角度来补充一点东西吧。PS：不一定全，只是个人理解，不喜勿喷） 
  
1、关于JedisPool.returnSource(Jedis jeids) 
  
这个方法是从red
    
                                
    • 
                                
  • SQL性能优化-持续更新中。。。。。。
                                    atongyeye
oraclesql
                                    
    1 通过ROWID访问表--索引 
你可以采用基于ROWID的访问方式情况,提高访问表的效率, , ROWID包含了表中记录的物理位置信息..ORACLE采用索引(INDEX)实现了数据和存放数据的物理位置(ROWID)之间的联系. 通常索引提供了快速访问ROWID的方法,因此那些基于索引列的查询就可以得到性能上的提高. 
 
2 共享SQL语句--相同的sql放入缓存 
 
3 选择最有效率的表
    
                                
    • 
                                
  • [JAVA语言]JAVA虚拟机对底层硬件的操控还不完善
                                    comsci
JAVA虚拟机
                                    
     
     如果我们用汇编语言编写一个直接读写CPU寄存器的代码段，然后利用这个代码段去控制被操作系统屏蔽的硬件资源，这对于JVM虚拟机显然是不合法的，对操作系统来讲，这样也是不合法的，但是如果是一个工程项目的确需要这样做，合同已经签了，我们又不能够这样做，怎么办呢？ 那么一个精通汇编语言的那种X客，是否在这个时候就会发生某种至关重要的作用呢？ 
 
&n
    
                                
    • 
                                
  • lvs- real
                                    男人50
LVS
                                    
    #!/bin/bash 
# 
# Script to start LVS DR real server. 
# description: LVS DR real server 
# 
#.  /etc/rc.d/init.d/functions 
 
VIP=10.10.6.252 
host='/bin/hostname' 
 
case "$1" in 
sta
    
                                
    • 
                                
  • 生成公钥和私钥
                                    oloz
DSA安全加密
                                    
    package com.msserver.core.util;

import java.security.KeyPair;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.SecureRandom;

public class SecurityUtil {

    
                                
    • 
                                
  • UIView 中加入的cocos2d，背景透明
                                    374016526
cocos2dglClearColor
                                    
    要点是首先pixelFormat:kEAGLColorFormatRGBA8，必须有alpha层才能透明。然后view设置为透明glView.opaque = NO;[director setOpenGLView:glView];[self.viewController.view setBackgroundColor:[UIColor clearColor]];[self.viewControll
    
                                
    • 
                                
  • mysql常用命令
                                    香水浓
mysql
                                    
    连接数据库 
mysql -u troy -ptroy 
 
备份表 
mysqldump -u troy -ptroy mm_database mm_user_tbl > user.sql 
 
恢复表（与恢复数据库命令相同） 
mysql -u troy -ptroy mm_database < user.sql 
 
备份数据库 
mysqldump -u troy -ptroy
    
                                
    • 
                                
  • 我的架构经验系列文章 - 后端架构 - 系统层面
                                    agevs
JavaScriptjquerycsshtml5
                                    
    系统层面：
高可用性

所谓高可用性也就是通过避免单独故障加上快速故障转移实现一旦某台物理服务器出现故障能实现故障快速恢复。一般来说，可以采用两种方式，如果可以做业务可以做负载均衡则通过负载均衡实现集群，然后针对每一台服务器进行监控，一旦发生故障则从集群中移除；如果业务只能有单点入口那么可以通过实现Standby机加上虚拟IP机制，实现Active机在出现故障之后虚拟IP转移到Standby的快速
    
                                
    • 
                                
  • 利用ant进行远程tomcat部署
                                    aijuans
tomcat
                                    
    在javaEE项目中，需要将工程部署到远程服务器上，如果部署的频率比较高，手动部署的方式就比较麻烦，可以利用Ant工具实现快捷的部署。这篇博文详细介绍了ant配置的步骤（http://www.cnblogs.com/GloriousOnion/archive/2012/12/18/2822817.html），但是在tomcat7以上不适用，需要修改配置，具体如下： 
1.配置tomcat的用户角色
    
                                
    • 
                                
  • 获取复利总收入
                                    baalwolf
获取
                                    
           public static void main(String args[]){ 
        int money=200; 
        int year=1; 
        double rate=0.1; 
&
    
                                
    • 
                                
  • eclipse.ini解释
                                    BigBird2012
eclipse
                                    
    大多数java开发者使用的都是eclipse，今天感兴趣去eclipse官网搜了一下eclipse.ini的配置，供大家参考，我会把关键的部分给大家用中文解释一下。还是推荐有问题不会直接搜谷歌，看官方文档，这样我们会知道问题的真面目是什么，对问题也有一个全面清晰的认识。 
Overview 
1、Eclipse.ini的作用 
Eclipse startup is controlled by th
    
                                
    • 
                                
  • AngularJS实现分页功能
                                    bijian1013
JavaScriptAngularJS分页
                                    
            对于大多数web应用来说显示项目列表是一种很常见的任务。通常情况下，我们的数据会比较多，无法很好地显示在单个页面中。在这种情况下，我们需要把数据以页的方式来展示，同时带有转到上一页和下一页的功能。既然在整个应用中这是一种很常见的需求，那么把这一功能抽象成一个通用的、可复用的分页（Paginator）服务是很有意义的。 
  &nbs
    
                                
    • 
                                
  • [Maven学习笔记三]Maven archetype
                                    bit1129
ArcheType
                                    
    archetype的英文意思是原型，Maven archetype表示创建Maven模块的模版，比如创建web项目，创建Spring项目等等. 
  
mvn archetype提供了一种命令行交互式创建Maven项目或者模块的方式， 
  
mvn archetype 
  
1.在LearnMaven-ch03目录下，执行命令mvn archetype:gener
    
                                
    • 
                                
  • 【Java命令三】jps
                                    bit1129
Java命令
                                    
    jps很简单，用于显示当前运行的Java进程，也可以连接到远程服务器去查看 
  
[hadoop@hadoop bin]$ jps -help
usage: jps [-help]
       jps [-q] [-mlvV] [<hostid>]

Definitions:
    <hostid>:      <hostname>[:
    
                                
    • 
                                
  • ZABBIX2.2 2.4 等各版本之间的兼容性
                                    ronin47

                                    
    zabbix更新很快，从2009年到现在已经更新多个版本，为了使用更多zabbix的新特性，随之而来的便是升级版本，zabbix版本兼容性是必须优先考虑的一点 客户端AGENT兼容 
zabbix1.x到zabbix2.x的所有agent都兼容zabbix server2.4：如果你升级zabbix server，客户端是可以不做任何改变，除非你想使用agent的一些新特性。 Zabbix代理（p
    
                                
    • 
                                
  • unity 3d还是cocos2dx哪个适合游戏？
                                    brotherlamp
unity自学unity教程unity视频unity资料unity
                                    
    unity 3d还是cocos2dx哪个适合游戏？ 
问：unity 3d还是cocos2dx哪个适合游戏？ 
答：首先目前来看unity视频教程因为是3d引擎，目前对2d支持并不完善，unity 3d 目前做2d普遍两种思路，一种是正交相机，3d画面2d视角，另一种是通过一些插件，动态创建mesh来绘制图形单元目前用的较多的是2d toolkit，ex2d，smooth moves，sm2， 

    
                                
    • 
                                
  • 百度笔试题：一个已经排序好的很大的数组，现在给它划分成m段，每段长度不定，段长最长为k，然后段内打乱顺序，请设计一个算法对其进行重新排序
                                    bylijinnan
java算法面试百度招聘
                                    
    

import java.util.Arrays;

/**
 * 最早是在陈利人老师的微博看到这道题：
 * #面试题#An array with n elements which is K most sorted，就是每个element的初始位置和它最终的排序后的位置的距离不超过常数K
 * 设计一个排序算法。It should be faster than O(n*lgn)。
    
                                
    • 
                                
  • 获取checkbox复选框的值
                                    chiangfai
checkbox
                                    
    <title>CheckBox</title>
  <script type = "text/javascript">
	doGetVal: function  doGetVal()
	{
		//var fruitName = document.getElementById("apple").value;//根据
    
                                
    • 
                                
  • MySQLdb用户指南
                                    chenchao051
mysqldb
                                    
    原网页被墙，放这里备用。  MySQLdb User's Guide  
Contents 
 
 Introduction 
 Installation 
  _mysql 
   
   MySQL C API translation 
   MySQL C API function mapping 
   Some _mysql examples 
    
  MySQLdb 
   
 
    
                                
    • 
                                
  • HIVE 窗口及分析函数
                                    daizj
hive窗口函数分析函数
                                    
    窗口函数应用场景： 
（1）用于分区排序 
（2）动态Group By 
（3）Top N 
（4）累计计算 
（5）层次查询 
 
一、分析函数 
用于等级、百分点、n分片等。 
函数             说明 
RANK()     &nbs
    
                                
    • 
                                
  • PHP ZipArchive 实现压缩解压Zip文件
                                    dcj3sjt126com
PHPzip
                                    
      
PHP ZipArchive 是PHP自带的扩展类，可以轻松实现ZIP文件的压缩和解压，使用前首先要确保PHP ZIP 扩展已经开启，具体开启方法就不说了，不同的平台开启PHP扩增的方法网上都有，如有疑问欢迎交流。这里整理一下常用的示例供参考。 
一、解压缩zip文件        01   02   03   04   05   06   07   08   09   10   11   
    
                                
    • 
                                
  • 精彩英语贺词
                                    dcj3sjt126com
英语
                                    
    I'm always here  
            我会一直在这里支持你  
              &nb
    
                                
    • 
                                
  • 基于Java注解的Spring的IoC功能
                                    e200702084
javaspringbeanIOCOffice
                                    
                                    
  
    
                                
    • 
                                
  • java模拟post请求
                                    geeksun
java
                                    
    一般API接收客户端（比如网页、APP或其他应用服务）的请求，但在测试时需要模拟来自外界的请求，经探索，使用HttpComponentshttpClient可模拟Post提交请求。  此处用HttpComponents的httpclient来完成使命。   
import org.apache.http.HttpEntity ;
import org.apache.http.HttpRespon
    
                                
    • 
                                
  • Swift语法之 ---- ?和!区别
                                    hongtoushizi
?swift!
                                    
    转载自： http://blog.sina.com.cn/s/blog_71715bf80102ux3v.html 
  
Swift语言使用var定义变量，但和别的语言不同，Swift里不会自动给变量赋初始值，也就是说变量不会有默认值，所以要求使用变量之前必须要对其初始化。如果在使用变量之前不进行初始化就会报错：  
var stringValue : String 
//
    
                                
    • 
                                
  • centos7安装jdk1.7
                                    jisonami
jdkcentos
                                    
    安装JDK1.7 
步骤1、解压tar包在当前目录 
[root@localhost usr]#tar -xzvf jdk-7u75-linux-x64.tar.gz 
步骤2：配置环境变量 
在etc/profile文件下添加 
export JAVA_HOME=/usr/java/jdk1.7.0_75 
export CLASSPATH=/usr/java/jdk1.7.0_75/lib 

    
                                
    • 
                                
  • 数据源架构模式之数据映射器
                                    home198979
PHP架构数据映射器datamapper
                                    
    前面分别介绍了数据源架构模式之表数据入口、数据源架构模式之行和数据入口数据源架构模式之活动记录，相较于这三种数据源架构模式，数据映射器显得更加“高大上”。 
  
一、概念 
数据映射器（Data Mapper）：在保持对象和数据库（以及映射器本身）彼此独立的情况下，在二者之间移动数据的一个映射器层。概念永远都是抽象的，简单的说，数据映射器就是一个负责将数据映射到对象的类数据。 
&nb
    
                                
    • 
                                
  • 在Python中使用MYSQL
                                    pda158
mysqlpython
                                    
    缘由   　　近期在折腾一个小东西须要抓取网上的页面。然后进行解析。将结果放到 
数据库中。   　　了解到 
Python在这方面有优势，便选用之。   　　由于我有台 
server上面安装有 
mysql，自然使用之。在进行数据库的这个操作过程中遇到了不少问题，这里 
记录一下，大家共勉。   　　 
python中mysql的调用   　　 
百度之后能够通过MySQLdb进行数据库操作。
    
                                
    • 
                                
  • 单例模式
                                    hxl1988_0311
java单例设计模式单件
                                    
    package com.sosop.designpattern.singleton;

/*
 * 单件模式：保证一个类必须只有一个实例，并提供全局的访问点
 * 
 * 所以单例模式必须有私有的构造器，没有私有构造器根本不用谈单件
 * 
 * 必须考虑到并发情况下创建了多个实例对象
 * */

/**
 * 虽然有锁，但是只在第一次创建对象的时候加锁，并发时不会存在效率
    
                                
    • 
                                
  • 27种迹象显示你应该辞掉程序员的工作
                                    vipshichg
工作
                                    
    1、你仍然在等待老板在2010年答应的要提拔你的暗示。 2、你的上级近10年没有开发过任何代码。 3、老板假装懂你说的这些技术，但实际上他完全不知道你在说什么。 4、你干完的项目6个月后才部署到现场服务器上。 5、时不时的，老板在检查你刚刚完成的工作时，要求按新想法重新开发。 6、而最终这个软件只有12个用户。 7、时间全浪费在办公室政治中，而不是用在开发好的软件上。 8、部署前5分钟才开始测试。
    
                                
    •