张国立_0695
张国立_0695

设计模式-行为型模式

行为型模式

描述程序运行时复杂的流程控制，涉及算法和对象间的行为控制。

一、模板方法模式 Template Method

定义算法模板，规范了基本构建，将部分算法延迟到子类进行，是的不改变整体结构情况下重新定义算法特定步骤。


13templateMethod.png

抽象类 AbstractClass

  • 模板方法：定义算法骨架，按某种顺序调用基本方法。
  • 基本方法： 整体算法中的一个步骤。
    • 抽象方法：声明由子类实现。
    • 具体方法：抽象类实现，子类和集成或重写。
    • 钩子方法：抽象类已经实现，包括用于判断逻辑方法和需要子类重写的空方法。
abstract AbstractClass{
    void templateMethod(){
        specificMethod();
        abstractMethod1();
        if(Hook1()){
            abstractMethod2();
        }
    }
    void specificMethod(){
            System.out.println("开始");
        }
    void abstractMethod1();
    void abstractMethod2();
    boolean Hook1(){
        return true;
    }
}

具体子类 ConcreteClass

实现抽象类中的抽象方法和钩子方法。

class ConcreteClass extends AbstractClass{
    
    void abstractMethod1(){
        System.out.print("method1");
    }
    
    void abstractMethod2(){
        System.out.print("method2");
    }
    
    boolean Hook1(){
        return false;
    }
}

客户端 TestTemplate

class TestTemplate {
    
    public static void main(String[] args ){
        AbstractClass a=new ConcreteClass();
        a.templateMethod();
    }
}

二、策略模式 Strategy

定义了一系类算法，并对算法进行封装使得可以相互替换，算法的替换不影响客户的调用。
优点：避免多重判断，减少重复代码。
可以根据不同的时间空间选择不同算法，算法扩展不修改原算法。使用放到环境类中，算法实现放到具体策略类中，二者分离。
缺点：客户需要了解算法使用条件，增加很多策略类。

14strategy.png

抽象策略类 Strategy

interface Strategy{
    void strateyMethod();
}

具体策略类 ConcreteStrategy

class ConcreteStrategyA{
    void strategyMethod(){
        System.out.println("strategyA");
    }
}

class ConcreteStrategyB{
    void strategyMethod(){
        System.out.println("strategyB);
    }
}

环境类 Context

class Context{
private Strategy strategy;
    Strategy getStrategy(){
        return strategy;
    }
    
    void setStrategy(Strategy strategy){
        this.strategy=strategy;
    }
    
    void strategyMethod(){
        strategy.strategyMethod();
    }
}

客户端 StrategyPatternTest

class StrategyPatternTest{
    public static void main(String[] args){
        Context ct=new Context();
        ct.setStrategy(new ConcreteStrategyA());
        ct.strategyMethod();
    }
}

扩展策略工厂 StrategyFactory

class StrategyFactory{
    Map stf=new HashMap<>();
    void put(String key,Strategy strategy){
        stf.put(key,strategy);
    }
    
     Strategy getStrategy(String key){
         return stf.get(key);
     }
     
     void strategyMethod(String key){
         stf.get(key).strategyMethod();
     }
}

三、命令模式 Command

将请求封装成对象，是的发出请求的责任和处理请求的责任分离。
优点： 降低耦合度，扩展灵活，可以实现宏命令，方便实现Undo,Redo操作。
缺点：增加大量的命令类，增加复杂性。

15command.png

抽象命令 Command

abstract Command{
    void execute();
}

具体命令 ConcreteCommand

class ConcreteCommand implements Command{
    private ReceiverA receiverA;
    public ConcreteCommand(){
        receiverA=new ReceiverA();
    }
     void execute(){
        receiverA.action();
         
     }
}

命令接收者 Receiver

class Receiver{
    void action(){
        System.out.println("acionA");
    }
}

调用者 invoker

class Invoker{
private Command command;
    public Invoker(Command command){
        this.command=command;
    }
    public void setCommand(Command command){
        this.command=command;
    }
    
    public void call(){
        command.execute();
    }
}

客户端 TestCommandPattern

class TestCommandPattern{
    public static void main(){
        Command commandA= new ConcreteCommandA();
        Invoker invoker=new Invoker(commandA);
        invoker.call();
    }
}

命令模式扩展

配合组合模式，构成宏命令模式，也即组合命令模式

class CompositeInvoker implements AbstractCommand{
    private ArrayList children =new ArraryList<>();
    public void add(AbstractCommand a){
        children.add(a);
    }
    public void remove(AbstractCommand a){
        children.remove(a);
    }
    public AbstractCommand getChild(int i){
        return children.get(i);
    }
    public void execute(){
        for(Object obj:children){
            obj.execute();
        }
    }
}

四、责任链（职责链模式） Chain of Responsibility

为了避免请求发送者与多个请求处理着耦合在一起，将多有请求的处理着通过前一个对象的引用而连城一条链。请求发生时沿着链传递，直到处理为止。

16chain_of_responsibility.png

抽象处理者角色 Handler

abstract Handler{
    private Handler next;
    public void setNext(Handler handler){
        this.next=handler;
    }
    public Handler getNext(){
        return next;
    }
     void handlerRequest();
}

具体处理角色 ConcreteHandler

class ConcreteHandlerA implements Handler{
    void handlerRequest(String rq){
    if("A".equal(rq))  System.out.println("处理");
    else{
        getNext().handlerRequest(rq);
    }
    }
}

class ConctreteHandlerB implements Handler{
    void handlerRequest(String rq){
    if("B".equal(rq))
        System.out.println("B");
    else{
        getNext().handlerRequest(rq);
    }
    }
}

客户类 Client

创建处理链，并向链头的具体处理者对象提交请求。

publict TestChainofResponsibility{
    
    public static void main(String[] args){
        Handler handler=new ConcreteHandlerA();
        Handler handlerB=new ConcreteHandlerB();
        handler.setNext(HandlerB);
        
        handler.handlerRequest("B");
    }
}

模式的扩展

  • 纯的职责链模式
  • 不纯的职责链模式：一个请求必须被某一个处理者对象接收。接收后两种处理一种自己处理或推给下家。
  • 允许出现某一个具体处理者对象在承担部分责任后，将其他责任传给下架的情况。
17state.png

五、状态模式 State

对有状态的对象，把复杂的判断逻辑提取到不同的状态对象中，允许状态对象在其内部状态改变是改变行为。

环境角色 Context

class Context{
    private State state;
    Pulic void Context(State state){
        this.state=new ConcreteStateA();
    }
    Public void Handle(){
        state.Handle(this);
    }
    public void setState(State state){
        this.state = state;
    }
    public State getState(){
        return state;
    }
}

抽象状态类 State

abstract State{
    void handle(Context context);
}

具体状态类 ConcreteState

class ConcreteStateA extends State{
    void Handle(Context context){
        System.out.println("A");
        context.setState(new ConcreteStateB());
    }
}

class ConcreteStateB extends State{
    void handle(Context context){
        System.out.println("B");
        context.setState(new ConcreteStateA());
    }
}

客户端 TestState

class TestState{
    public static void(String[] args){
        Context ct=new Context();
        
        ct.handle("A");
        ct.handle("B");
        ct.handle("C");
        
    }
}

状态模式扩展

有些情况可能多个环境共享一组状态，这时候需要引入享元模式，状态放到集合中程序共享。

class ShareContext{
    private ShareState state;
    private HashMap stateSet =new HashMap<>();
    public ShareContext(){
        state=new ConcreteState1();
        stateSet.put("1",state);
        state=new ConcreteState2();
        stateSet.put("2",state);
        state=getState("1");
    }
    public void setState(ShareState state){
        this.state=state;
    }
    
    public ShareState getState(String key){
        ShareState s= (ShareState)stateSet.get(key);
        return s;
    }
    public void Handle(){
        state.handle(this);
    }
    
}

六、观察者模式

多个对象间存在一对多的依赖关系，当一个对象的状态发生改变是其它对象自动更新，这种模式有时候又称作发布-订阅模式。在软件开发中用的最多的是窗体程序设计中的事件处理，sping 中ApplicationContext 的事件机制也是通过该模式实现的。
优点： 降低了目标与观察者之间的耦合关系。目标与观察者之间建立了一套触发机制。
缺点：目标和观察者之间的医疗没有完全解除，可能导致循环引用。 当观察者对象很多时，通知观察者会花费很多时间，影响效率。


20observer.png

抽象主题 Subject

保存观察者对象的聚集类和增删方法，通知所有观察者。

abstract Subject{
    private  List observers=new ArraryList<>();
    public void add(Observer obs){
        if(observers.contains(obs))return;
        observers.add(obs);
    }
    public void remove(Observer obs){
        observers.remove(obs);
    }
    public void notifyObserver();
    
}

具体主题 ConcreteSubject

class ConcreteSubject extends Subject{
    
    public void notifyObserver(){
        for(Observer obs:observers){
             obs.response();
        }
    }
}

抽象观察者 Observer

interface Observer{
    void response();
}

具体观察者 ConcreteObserver

class ConcreteObserver1 implements Observer{
    
    void response(){
        System.out.println("观察者1");
    }
}

class ConcreteObserver2 implements Observer{
    
    void response(){
        System.out.println("观察者2");
    }
}

客户端 TestObserver

class TestObserver{
    
    public static void main(String[] args){
        
        Subject subject =new ConcreteSubject();
        Observer obs1=new ConcreteObserver1();
        subject.add(obs1);
        Observer obs2= new ConcreteObserver2();
        subject.add(obs2);
        subject.notifyObserver();
    }
}

模式扩展

在java中，通过java.util.Observable类和 java.util.Observer 接口定义观察者模式。

1、Observable类
  • 抽象目标类，有一个Vector向量，用于保存需要通知的观察者对象
  • void addObserver(Observer o) 添加观察者
  • void notifyObservers(Object arg) 调用向量中观察者对象update方法
    ，越晚加入越先得到通知
  • void setChange() 用于设置内部标志位，为真时notifyObservers才会通知观察者。
2、Observer接口

抽象观察者，监视目标的变化。

具体目标观察者
class MdmMapping extends Observable{
    public void changeMapping(MdmMap mp){
        super.setChanged();
        super.notifyObservers(mp);
    }
}
观察者
class CacheMapping implements Observer{
    
    public void update(Observable o,Object arg){
        MdmMap mdmMap=(MdmMap)arg;
        Cache.remove(arg.getKey());
    }
}

class DbMapping implements Observer{
    public void update(Observable o,Object arg){
        MdmMap mdmMap=(MdmMap)arg;
        Mappingdb.update(mdmMap);
    }
}
调用类
public class MappingTest{
    public static void main(String[] args){
        MdmMapping mdmMp=new MdmMapping();
        Observer cache=new CacheMapping();
        Observer db =new DbMapping();
        mdmMp.addObserver(cache);
        mdmMp.addObserver(db);
        MdmMap mp=new MdmMap();
        mp.setkey("1");
        mp.setvalue("男");
        mdmMp.changeMapping(mp);
    }
}

七、中介者mediator

定义一个中介对象来封装一系列对象之间的交互
优点：

  • 降低对象间耦合，使得对象可以独立复用
  • 对象间一对多的关系转变为一对一，提高系统灵活性
19mediator.png

抽象中介者 Mediator

定义了注册和转发的接口

abstract class Mediator{
    public abstract void register(Colleague colleagur);
    public abstract void relay(Colleague cl);
}

具体中介者 ConcreteMediator

class ConcreteMediator extands Mediator{
    private List colleagues= new ArrayList<>();
    public void register(Colleague colleague){
        if(!colleagues.contains(colleague)){
            colleagues.add(colleague);
            colleague.setMedium(this);
        }
    }
    pulic void relay(Colleague cl){
        for(Colleague ob:colleagues){
            if(!ob.equals(cl)){
                ((Colleague)ob).receive();
            }
        }
    }
    
}

抽象同事类 Colleague

abstract class Colleague{
    protected mediator mediator;
    public void setMedium(Mediator mediator){
        this.mediator=mediator;
    }
    public abstract void receive();
    public abstract void send();
}

具体同事类 ConcreteColleague

class ConcreteColleague1 extends Colleague{
    public void receive(){
        System.out.println("接收请求");
        
    }
    public void send(){
        System.out.println("发送请求");
        mediator.relay(this);
    }
}

class ConcreteColleague2 extends Colleague{
    public void receive(){
        System.out.println("接收请求");
        
    }
    public boid send(){
        System.out.println("发送请求");
        mediator.relay(this);
    }
}

八、迭代器 Iterator

提供一个对象来访问聚合对象中的一系列数据，而不暴露聚合对象的内部表示。聚合迭代非常密切，大多数语言在实现聚合类是都提供了迭代类。

  • 当需要为聚合对象提供多种遍历方式时。
  • 为遍历不同聚合结构提供统一的接口。
  • 访问聚合对象而无需暴露内部细节时。
20Iterator.png

抽象聚合 Aggregate

定义存储、添加、删除聚合对象以及创建迭代器对象接口。

interface Aggregate{
    public void add(Object o);
    public void remove(Object o);
    public Iterator getInterator();
}

具体迭代器 ConcreteAggregate

class ConcreteAggregate implements Aggregate{
    private List list =new ArrayList<>();
    public void add(Object o){
        list.add(o);
    }
    public void remove(Object o){
        list.remove(o);
    }
    public Iterator getIterator(){
        return (new ConcreteIterator(list));
    }
}
 
 
抽象迭代器 Iterator
 
 
 
  
定义访问和遍历聚合元素的接口，通常包括hasNext()、first()、next()等方法。
 
 
 
 
interface Iterator{
    public boolean hasNext();
    public Object first();
    public Object next();
}

 
 
具体迭代器 ConcreteIterator
 
 
class ConcreteIterator implements Iterator{
    private List list=null;
    private int index=-1;
    public ConcreteIterator(List list){
        this.list=list;
    }
    public boolean hasNext(){
        if(index 
 
模式的扩展
 
 
 
  
迭代器常常与组合模式结合起来使用，经常潜藏在组合模式的容器构成类中。
 
 
 
 
class Composite impelements Component{
    private List components= new Arrarylist<>();
    public void add(Commponent com){
      components.add(com);
        
    }
    public void remove(Commponent com){
        components.remove(com);
    }
    public Commponent getChild(int i){
        return components.get(i);
    }
    
    public void Operation(){
        System.out.println("opt");
    }
    
    public Iterator getIterator(){
        return (new ConcreteIterator(components));
    }
}

 
 
九、访问者模式 Visitor
 
 
 
  
将作用于某种数据结构中的各元素操作分离成独立的类，使得在不改变数据机构的前提下添加新的操作，为数据结构中的元素提供各种操作。数据元素和数据操作分离，是行为模式中最复杂的一种模式。
 
  
 
  
 
   
 
    
  
    
 
   
 
   

     21visitor.png 
   
 
  
 
 
 
 
抽象访问者 Visitor
 
 
 
  
为每个对应元素提供一个访问操作visit(),参数标识了被访问元素
 
 
 
 
interface Visitor{
    void visit(ConcreteElementA element);
    void visit(ConcreteElementB element);
}

 
 
具体访问者 ConcreteVisitor
 
 
class ConcreteVisitorA implements Visitor{
    void visitor(ConcreteElementA element){
        System.out.println("具体访问者A访问->"+element.operationA());
    }
    void visitor(ConcreteElementB element){
        System.out.println("A->"+element.operationB());
    }
}

 
 
抽象元素 Element
 
 
interface Element{
    void accept(Visitor visitor);
}

 
 
具体元素 ConcreteElement
 
 
class ConcreteElementA implements Element{

    void accept(Visitor v){
        v.visit(this);
    }
    
    String operationA(){
        return "ConcreteElementA";
    }
}

 
 
class ConcreteElementB implements Element{
    void accept(Visitor v){
        v.visit(this);
    }
    String operationB(){
        return "ConcreteElementB";
    }
}

 
 
对象结构 ObjectStruct
 
 
 
  
包含元素角色的容器，提供访问者访问元素
 
 
 
 
class ObjectStruct {
    private List elements=new ArrayList<>();
    public void accept(Visitor visitor){
        Iterator i=list.iterator();
        while(i.hasNext()){
            ((Elemnet)i.next()).accept(visitor);
        }
    }
    public void add(Element element){
        list.add(element);
    }
    public void remove(Element element){
        list.remove(element);
    }
}

 
 
客户端调用 TestVisitor
 
 
public class TestVisitor{
    
    public static void main(String[] args){
        ObjectStrut objects=new ObjectStrut();
        ConcreteElementA cA=new ConcreteElementA();
        COncreteElementB CB=new ConcreteElementB();
        objects.add(cA);
        objects.add(cB);
        Visitor vA=new ConcreteVisitorA();
        Visitor vB=new ConcreteVisitorB();
        objects.accept(vA);
        objects.accept(vB);
    }
}

 
 
模式扩展
 
 
 
  
访问这模式使用频率比较高的一种模式，通常与迭代器或组合模式联用。
 以组合模式为例（主要具体元素类）：
 
 
 
 
叶子构件 Leaf
 
 
class ConcreteLeafElement implements Element{
    void accept(Visitor v){
        v.visit(this);
    }
    void operatorLeaf(){
        System.out.print("leaf");
    }
}

 
 
树枝构件Composite
 
 
class CompositeElement implements Element{
    private List elements=new ArrayList<>();
    
    void accept(Visitor v){
        for(Element e:elements){
            v.visit(e);
        }
    }
    void operatorComposite(){
    System.out.print("Composite");
    }
    
    void add(Element e){
        elements.add(e);
    }
    
    void remove(Element e){
        elements.remove(e);
    }
    Element getChild(int i){
        elements.get(i);
    }
    
}

 
 
十、备忘录模式 Memento
 
 
 
  
在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态，以便以后当需要的时能将该对象恢复到原先保存的状态。又叫快照模式。
 
 
 
 
 
  
 
   
  
   
 
  
 
  

    22Memento.png 
  
 
 
 
 
备忘录Memento
 
 
class Memento{
    private String state;
    public Memento(String state){
        this.state=state;
    }
    
    public void setState(String state){
        this.state=state;
    }
    
    public String getState(){
        return state
    }
}

 
 
发起人Originator
 
 
 
  
记录当前时刻的内部状态信息，提供创建备忘录和恢复备忘录数据的功能，实现其他业务功能，可以访问备忘录里的所有信息。
 
 
 
 
class Originator{
    private String state;
    public void setState(String state){
        this.state=state;
    }
    public String getState(){
        return state;
    }
    public Memento createMemento(){
        return new Memento(state);
    }
    public void restoreMemento(Memento m){
        this.setState(m.getState());
    }
}

 
 
管理者 Caretaker
 
 
class Caretaker{
    private Memento memento;
    
    public void setMemento(Memento m){
        memento=m;
    }
    public Memento getMemento(){
        return memento;
    }
}

 
 
客户端 TestMemento
 
 
public class TestMemento{
    public static void main(String[] args){
        Originator otr=new Originator();
        Caretaker ctr=new Caretaker();
        
        otr.setState("1");
        ctr.setMemento(otr.createMemento());
        otr.setState("2");
        otr.restoreMemento(ctr.getMemento());
    }
}

 
 
模式扩展
 
 
 
  
和原型模式结合使用，可以拥有自备功能，省去了备忘录，主要变化在发起人。
 
 
 
 
class OriginatorPrototype implements Cloneable{
    private String state;
    public void setState(String state){
        this.state=state;
    }
    public String getState(){
        return state;
    }
    public OriginatorPrototype createMemento(){
        return this.clone();
    }
    public void restoreMemento(OriginatorPrototype opt){
        this.setState(opt.getState());
    }
    public OriginatorPrototype clone(){
        try{
            return(OriginatorPrototype) super.clone();
        }catch(CloneNotSupportedException e){
            e.printStackTrace();
        }
        return null;
    }
}

 
 
十一、解释器模式 Interpreter
 
 
 
  
给分析对象定义一个语言，并定义该语言的文法表示，在设计一个解释器来解释语言中的句子。该模式实现了文法表达式处理的接口，该接口解释一个特定的上下文。
 
 
 
 
     
  
  • 优点： 扩展性好，可通过集成改变或扩展语法。 每个表达式都是类似的实现比较容易。
    •  
  
  • 缺点：解析器模式中通常使用大量的循环和递归调用，当解释的句子复杂时，运行速度很慢，且调试代码比较麻烦。
    •  
 
 
 
 
  
解释器模式通常用于对简单语言的编译或分析实例中，为了掌握好他的结构和实现，必须先了解编译原理中的“we文法、句子、语法树”等相关概念。
 
 
 
 
 
  
 
   
  
   
 
  
 
  

    23interpret.png 
  
 
 
 
 
抽象表达式 Abstract Expression
 
 
interface AbstractExpression{
    public Object interpret(String info);
}

 
 
终结符表达式 Terminal Expression
 
 
class TerminalExpressoin implements AbstractExpression{
private Set set=new HashSet();
    public boolean interpret(String info){
        if(set.contains(info)){
            return true;
        }
        return false;
    }
    public TerminalExpression(String[] data){
        for(int i=0;i
 
 
非终结符表达式 Nonterminal Expression
 
 
class NonterminalExpression implements AbstractExpression{
    private AbstractExpression city;
    private AbstractExpression person;
    public AndExpression(Expression city,Expression person){
        this.city=city;
        this.person=person;
    }
    public boolean interpret(String info){
        String s[]=info.split("的");
        return city.interpret(s[0])&&persion.interpret([s[1]);
    }
}

 
 
环境 Context
 
 
class Context{
    private String[] citys={"韶关","广州"};
    private String[] persons={"老人","妇女","儿童"}；
    private Expression cityPerson;
    public Context(){
        Expression city=new TerminalExpression(citys);
        Expression person=new TerminalExpression(persons);
        cityPerson=new AndExpression(city,person);
    }
    
    pulic void freeRide(String info){
        boolean ok =cityPerson.interpret(info);
        if(ok) System.out.println("免费");
        else System.out.println("扣费2元");
    }
}

 
 
客户端 TestInterpret
 
 
public class InterpreterPattern{
    public static void main(String[] args){
        Context bus=new Context();
        bus.freeRide("广东的妇女");
        bus.freeRide("韶关的年轻人");
    }
}

 
 
模式扩展
 
 
 
  
项目开发中，如果要对表达式进行分析计算，java提供了数学公式解析器： Expression4J、Jep等
 
 
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(设计模式-行为型模式)

        

            

                
    
                    
  • 【Spring】Spring DI(依赖注入)详解——注入参数的细节处理-null值的注入
                        AI人H哥会Java
JAVAjava开发语言spring后端架构
                        
    引言在现代Java开发中，Spring框架已经成为了构建企业级应用的标准工具之一。Spring的核心特性之一就是依赖注入（DependencyInjection，DI），它通过将对象的依赖关系从代码中解耦出来，提升了代码的可维护性和可测试性。特别是在大型项目中，良好的依赖管理能够显著降低代码的复杂度，提高开发效率。依赖注入的基本概念依赖注入是一种设计模式，用于实现控制反转（InversionofC
    
                    
    • 
                    
  • 掌握Python核心技巧：轻松实现依赖注入与控制反转 | python 小知识
                        egzosn
python开发语言
                        
    掌握Python核心技巧：轻松实现依赖注入与控制反转|python小知识1.依赖注入与控制反转思想介绍**依赖注入(DependencyInjection,DI)**和控制反转(InversionofControl,IoC)是现代软件开发中的重要设计模式，它们的核心思想是减少模块间的耦合度，提高代码的可测试性和可维护性。依赖注入：指将对象的依赖关系从代码中抽离出来，由外部容器或框架在运行时动态地注
    
                    
    • 
                    
  • 高级java每日一道面试题-2025年01月19日-框架篇[Mybatis篇]-MyBatis 中见过什么设计模式 ?
                        java我跟你拼了
java每日一道面试题javamybatis设计模式
                        
    如果有遗漏,评论区告诉我进行补充面试官:MyBatis中见过什么设计模式?我回答:1.工厂模式（FactoryPattern）定义：工厂模式是一种创建型模式，它提供了一种创建对象的最佳方式，将对象创建过程抽象化，从而提高代码的可维护性和灵活性。在MyBatis中的应用：SqlSessionFactoryBuilder和SqlSessionFactory的创建过程体现了工厂模式的应用。SqlSess
    
                    
    • 
                    
  • SpringBoot实践设计模式———装饰者模式
                        
spring设计装饰者模式
                        
    什么是装饰者模式？装饰者模式属于结构型设计模式之一，主要目的是通过包装对象而不是继承来扩展功能。这种模式允许用户动态地为对象添加新的行为而无需修改其源代码。这与继承相比提供了一种更为灵活的方式来扩展功能。装饰者模式的关键组成部分：抽象组件（Component）：定义核心业务接口。具体组件（ConcreteComponent）：核心业务实现类，实现了抽象组件接口。装饰器（Decorator）：持有抽
    
                    
    • 
                    
  • java 设计模式 建造者模式
                        Leaf吧
java设计模式java设计模式建造者模式
                        
    建造者模式什么是建造者模式建造者模式（BuilderPattern）是一种设计模式，属于创建型模式之一。它的主要目的是通过一步步构建一个复杂对象的方式，避免了构造过程中的混乱和复杂性。这个模式通常用于构建一个具有多个属性或复杂结构的对象，可以通过分步设置属性来构建对象，而不需要构造函数中传递大量的参数。在建造者模式中，通常会有：Product（产品）：最终被构建的复杂对象。Builder（建造者）
    
                    
    • 
                    
  • java 设计模式 工厂模式
                        Leaf吧
java设计模式java设计模式开发语言
                        
    什么是工厂模式工厂模式（FactoryPattern）是一种创建型设计模式，它通过定义一个接口或抽象类来创建对象，但由子类决定具体实例化哪个类。简单来说，工厂模式将对象的实例化过程封装起来，客户端通过工厂方法来创建对象，而不需要直接使用new关键字。工厂模式的目的是将对象的创建和使用解耦，使得客户端代码不需要关心具体对象的创建过程，尤其是对象的构造方式或者具体类型。工厂模式的作用解耦：客户端代码与
    
                    
    • 
                    
  • 【设计模式】依赖注入（Dependency Injection, DI）
                        艾米理
设计模式设计模式c#c++
                        
    依赖注入（DependencyInjection,DI）是一种软件设计模式，用于实现对象之间的松耦合，同时提升代码的可测试性和可维护性。它主要用于管理和提供对象的依赖关系，而不需要在代码中手动创建依赖实例。核心概念依赖：一个类需要的服务或对象。例如，类A需要类B提供某些功能，那么B就是A的依赖。注入：将依赖通过外部方式传递给类，而不是让类直接创建或获取这些依赖。在传统编程中，如果类A需要使用类B，
    
                    
    • 
                    
  • 编程全景洞察：从基础架构到前沿创新与行业影响
                        ༺ཌༀ傲世万物ༀད༻
人工智能人工智能
                        
    编程全景洞察：从基础架构到前沿创新与行业影响由于文章过长，博主写的时候可能会有一些差错以及一些不连贯或者是一些重复，请大家谅解~编程全景洞察：从基础架构到前沿创新与行业影响编程的基础语言与逻辑架构编程范式与设计模式：理念升华与实践指南编程在前沿科技领域的深度融合与突破编程竞赛与荣誉体系：人才摇篮与创新引擎编程教育的普及与多元发展路径编程行业的生态与职业发展全景编程的未来趋势与无限可能编程与数学、物
    
                    
    • 
                    
  • 设计模式之代理模式
                        Code额
设计模式代理模式
                        
    代理模式这里主要是对代理模式中的JDK动态代理、CGLIB代理以代码的形式做简单的介绍1.JDK动态代理代理对象和目标对象必须实现相同的接口。使用Proxy类提供了为对象产生代理对象的方法：publicstaticObjectnewProxyInstance(ClassLoaderloader,Class[]interfaces,InvocationHandlerh)ClassLoaderload
    
                    
    • 
                    
  • java软件工程师简历
                        极客11
面试与求职java开发语言
                        
    java软件工程师简历一姓名：陶**性别：男电话：136-3231****学历：本科邮箱：[email protected]地址：广州市天河区求职意向java软件工程师掌握技能1.熟练CoreJava编程，有编写注释的习惯;2.能熟练的整合Spring+Struts+Hibernate(SSH)三大开源框架;3.能熟练的应用各种常见的设计模式：工厂模式、单例模式、缺省适配器模式、不变模式、装饰模式、
    
                    
    • 
                    
  • Vue 开发者的 React 实战指南：组件设计模式篇
                        

                        
    作为Vue开发者，在学习React的过程中，除了语法和状态管理的差异，组件设计模式的差异也是一个重要的方面。本文将从Vue开发者熟悉的角度出发，详细介绍React中常用的组件设计模式。组件基础对比Vue组件Vue组件通常采用单文件组件（SFC）的形式：{{username}}{{bio}}exportdefault{name:'UserCard',props:{username:{type:Str
    
                    
    • 
                    
  • C#中的设计模式：构建更加优雅的代码
                        Envyᥫᩣᩚ
c#开发语言
                        
    C#在面向对象编程（OOP）方面的强大支持，我们可以探讨“C#中的设计模式”。这不仅有助于理解如何更好地组织代码，还能提高代码的可维护性和可扩展性。引言设计模式是软件工程中经过实践验证的解决方案模板，它们提供了一种标准化的方法来解决常见的开发问题。对于使用C#进行开发的程序员来说，理解和应用这些模式可以帮助创建结构良好、易于维护和扩展的应用程序。本文将介绍几种常用的设计模式，并展示如何用C#实现它
    
                    
    • 
                    
  • 单体架构、集群架构和分布式架构概述
                        JoyousHorse
软件工程架构分布式软考软件工程系统架构设计师
                        
    单体架构、集群架构和分布式架构概述在现代系统架构和开发过程中，单体架构、集群架构和分布式架构是三个常见且关键的概念。本文将详细介绍这些技术的相关概念，并探讨它们之间的联系与区别。一、单体架构单体架构，即单体技术，是一种软件设计模式，所有的功能和模块都集中在一个单一的应用程序中。比较常见的是学生时代开发的各类应用程序，应用包部署在一台服务器上，无需考虑系统性能、请求并发、服务连续性等问题。特点：单一
    
                    
    • 
                    
  • 事件驱动架构下的Java应用——构建响应迅速、解耦合的高效系统
                        墨夶
Java学习资料2java架构开发语言
                        
    在当今快速变化的技术环境中，软件系统的灵活性和响应速度成为了决定其成功与否的关键因素之一。传统的同步处理方式往往难以满足现代应用程序对于高性能和低延迟的要求。而事件驱动架构（Event-DrivenArchitecture,EDA）作为一种新兴的设计模式，通过引入异步机制来实现组件间的松散耦合，从而极大地提高了系统的可扩展性和维护性。本文将深入探讨如何基于Java语言构建一个高效的事件驱动架构，并
    
                    
    • 
                    
  • 用C++实现一个基于模板的观察者设计模式
                        CoderIsArt
UML设计模式C++11设计模式
                        
    观察者模式定义观察者模式（ObserverPattern）是一种行为型设计模式，用于定义对象间的一对多依赖关系，使得当一个对象状态发生变化时，其所有依赖它的对象都会收到通知并自动更新。核心概念角色定义Subject（被观察者）：持有观察者列表，维护观察者的注册和移除。状态改变时通知所有观察者。Observer（观察者）：定义接收通知的接口。注册到被观察者中，等待状态变化通知。适用场景一个对象状态改
    
                    
    • 
                    
  • 设计模式详解（命令模式）
                        小马不敲代码
设计模式设计模式命令模式
                        
    命令模式（CommandPattern）是一种行为型设计模式，它将请求封装为一个对象，从而使得请求的发送者和接收者解耦。一、命令模式的核心思想命令模式的核心思想是将“请求”封装成为一个对象，从而使得我们可以用不同的请求对客户进行参数化，对请求排队或记录请求日志，以及支持可撤销的操作。每一个命令都是一个操作：请求的一方发出请求要求执行一个操作；接收的一方收到请求，并执行相应的操作。命令模式允许请求的
    
                    
    • 
                    
  • MVC设计模式简介
                        大海知天空

                        
    MVC设计模式（Model-View-Controller)是软件工程中常见的一种软件架构模式，该模式把软件系统（项目）分为三个基本部分：模型（Model）、视图（View）和控制器（Controller）。使用MVC模式有很多优势，例如：简化后期对项目的修改、扩展等维护操作；使项目的某一部分变得可以重复利用；使项目的结构更加直观。具体来讲，MVC模式可以将项目划分为模型（M）、视图（V）和控制器
    
                    
    • 
                    
  • 设计模式之命令模式：从原理到实战，深入解析及源码应用
                        coffee_baby
设计模式原理和实战设计模式命令模式java
                        
    命令模式什么是命令模式？命令模式（CommandPattern）是一种行为设计模式，它将一个请求封装为一个对象，从而允许使用不同的请求、队列或者日志来参数化对象，并支持可撤销的操作。命令模式的核心思想是将命令的发起者和执行者解耦，从而使得命令的发起者不必关心命令是如何被执行的。命令模式的关键组成部分：命令（Command）：定义命令的接口，声明执行方法。具体命令（ConcreteCommand）：
    
                    
    • 
                    
  • C++设计模式---迭代器模式
                        xinruoqianqiu
设计模式设计模式迭代器模式
                        
    1、介绍迭代器模式是⼀种行为型设计模式，是⼀种使⽤频率⾮常⾼的设计模式，在各个语⾔中都有应用，其主要⽬的是提供⼀种统⼀的⽅式来访问⼀个聚合对象中的各个元素，而不需要暴露该对象的内部表示。通过迭代器，客户端可以顺序访问聚合对象的元素，而无需了解底层数据结构。迭代器模式应⽤⼴泛，但是⼤多数语⾔都已经内置了迭代器接⼝，不需要⾃⼰实现。包含一下几个部分：（1）迭代器接口Iterator：定义访问和遍历元素
    
                    
    • 
                    
  • Qt C++设计模式-＞中介者模式
                        多喝热水-多读书
c++设计模式中介者模式qt
                        
    中介者模式（MediatorPattern）是一种行为型设计模式，定义了一个对象用于封装一系列对象之间的交互。中介者使得对象之间不再需要显式地相互引用，减少了对象之间的依赖关系，从而使系统更加松散耦合，并且可以独立地改变对象之间的交互。中介者模式的应用场景中介者模式适用于当多个对象之间存在复杂的通信关系时，通过引入一个中介者对象来管理这些对象之间的交互，避免了对象之间直接相互依赖，降低系统的复杂性
    
                    
    • 
                    
  • C++设计模式--中介者模式
                        爱学习的蓝调
C++设计模式设计模式中介者模式C++
                        
    中介者模式（MediatorPattern）定义用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。Mediator：中介者，它定义了一个接口用于与各个Colleague对象通信；ConcreteMediator：具体的中介者，它通过协调各Colleague对象实现协作行为；并了解和维护它的各个Colleague；Colle
    
                    
    • 
                    
  • 深入理解观察者模式 —— Qt信号槽机制的实现
                        拾工
软件设计观察者模式qt开发语言
                        
    观察者模式是一种行为型设计模式，允许一个对象（被观察者）状态发生变化时通知一组依赖它的对象（观察者），从而实现对象之间的解耦。在这篇文章中，我们将探讨如何用C++和Python实现观察者模式，并在代码中清晰地体现这一设计模式的核心思想。其实Qt的信号槽机制，就是借住了这一设计模式，并对其进行了一些扩展。由于Qt广泛的被C++和Python用户使用，所以这里给出Python和C++两个版本的简单实现
    
                    
    • 
                    
  • 设计模式之结构型模式
                        power-辰南
java专栏设计模式
                        
    一、结构型模式概述结构型模式主要用于处理类与对象的组合。它描述了如何将类或对象结合在一起形成更大的结构，就像搭积木一样，通过不同的组合方式构建出复杂而强大的软件架构。其主要目的是简化系统的设计，提高系统的灵活性、可维护性和可扩展性。常见的结构型模式有代理模式、适配器模式、桥接模式、装饰器模式、外观模式、享元模式和组合模式。二、代理模式（一）定义与概念代理模式是为其他对象提供一种代理以控制对这个对象
    
                    
    • 
                    
  • 单例模式
                        智想天开
单例模式
                        
    公众号地址：单例模式更多内容请关注公众号：智想天开1.什么是单例模式？单例模式是一种创建型设计模式，旨在确保一个类在整个应用程序生命周期中只有一个实例，并提供一个全局访问点。通过单例模式，可以避免多个实例带来的资源浪费和数据不一致问题。关键点：唯一性：确保一个类只有一个实例。全局访问：提供一个全局的访问点来获取该实例。2.单例模式的意图控制实例数量：限制类的实例化数量，通常为一个。全局访问点：提供
    
                    
    • 
                    
  • C++设计模式——Iterator迭代器模式
                        程序员与背包客_CoderZ
C/C++设计模式c++设计模式迭代器模式开发语言c语言linux
                        
    一，迭代器模式的定义迭代器模式是一种行为型设计模式，它使得遍历一个容器对象中的元素变得更加简单。迭代器模式将遍历操作从容器对象（如集合、列表）中分离出来，它通过迭代器对象来遍历容器对象中的元素，使得遍历操作与容器对象解耦。迭代器模式可以解决的需求场景是当容器对象内部的结构经常被改变时，需要对外部屏蔽其变化过程。迭代器模式对外提供了一个统一的遍历接口，这个接口可以顺序访问容器对象中的每个元素。迭代器
    
                    
    • 
                    
  • 实战设计模式之命令模式
                        希望_睿智
实战设计模式系列设计模式命令模式软件工程架构设计系统架构
                        
    概述命令模式是一种行为设计模式，用于将请求封装成对象，从而使我们可以用不同的请求对客户进行参数化。简单来说，命令模式就是把一个请求转换为一个包含所有关于这个请求信息的对象。这样，就可以像传递其他对象一样传递这个请求，并且可以在适当的时间和地点执行它。命令模式主要适用于以下几种应用场景。1、需要支持撤销、重做操作的应用程序，比如：文本编辑器、绘图程序等。2、操作可以被放入队列中，并按顺序或特定条件执
    
                    
    • 
                    
  • 设计模式简介
                        智想天开
设计模式技术文章设计模式
                        
    本文章为原创，禁止未经授权的转载。对应公众号地址：设计模式简介，更多内容请关注公众号：智想天开1.什么是设计模式？设计模式是一套被反复使用、多数人知晓的、经过分类编目的代码设计经验。它们不是具体的代码，而是解决特定类型问题的通用方案。设计模式旨在提供一种高效、可维护和可扩展的方式来构建软件系统。关键点：重用：通过使用设计模式，可以避免重复造轮子，提升开发效率。沟通：设计模式提供了标准化的术语，促进
    
                    
    • 
                    
  • C++实现设计模式---中介者模式 (Mediator)
                        计算机小混子
设计模式c++设计模式中介者模式
                        
    中介者模式(Mediator)中介者模式是一种行为型设计模式，它用一个中介对象来封装一组对象之间的交互。中介者通过协调多个对象之间的通信，避免对象之间的直接依赖，从而实现对象之间的松耦合。意图通过引入一个中介者对象，减少对象之间的直接依赖，从而降低耦合性。中介者负责管理和协调对象之间的通信。使用场景对象之间的交互变得复杂：如果对象之间存在大量的直接引用和交互，可以使用中介者模式减少耦合。希望解耦多
    
                    
    • 
                    
  • C++实现设计模式---迭代器模式 (Iterator)
                        计算机小混子
设计模式c++设计模式迭代器模式
                        
    迭代器模式(Iterator)迭代器模式是一种行为型设计模式，它提供了一种方法，顺序访问一个聚合对象中的各个元素，而又不需要暴露该对象的内部表示。意图提供一种方法，可以顺序访问一个容器对象中的元素，而无需暴露其内部实现。将遍历行为从集合对象中分离出来，使得遍历行为可以独立变化。使用场景需要顺序访问一个聚合对象中的元素：如数组、链表或集合。需要支持多种遍历方式：如正序遍历、反序遍历等。需要解耦遍历算
    
                    
    • 
                    
  • 设计模式-生成器模式(建造者模式)-(Builder)
                        树懒_Zz
设计模式建造者模式
                        
    生成器模式是一种创建型设计模式，使你能够分步骤创建复杂对象。该模式允许你使用相同的创建代码生成不同类型和形式的对象。就像流水线的组装机器人一样，一件产品组装分成好几部，每一个工位组装不同的内容。问题：譬如你开了一家公司，专门承接私人建房，建房有的人要求：自带车库的房子、带游泳池的房子、装饰豪华的房子和带花园的房子等等。如果你基于这些创建了一个构造函数：House(windows,doors,roo
    
                    
    • 
                                
  • 多线程编程之join()方法
                                    周凡杨
javaJOIN多线程编程线程
                                    
    现实生活中，有些工作是需要团队中成员依次完成的，这就涉及到了一个顺序问题。现在有T1、T2、T3三个工人，如何保证T2在T1执行完后执行，T3在T2执行完后执行？问题分析：首先问题中有三个实体，T1、T2、T3， 因为是多线程编程，所以都要设计成线程类。关键是怎么保证线程能依次执行完呢？   
Java实现过程如下： 
public class T1 implements Runnabl
    
                                
    • 
                                
  • java中switch的使用
                                    bingyingao
javaenumbreakcontinue
                                    
    java中的switch仅支持case条件仅支持int、enum两种类型。 
用enum的时候，不能直接写下列形式。 
 
 
switch (timeType) {
            case ProdtransTimeTypeEnum.DAILY:

                break;

            default:
                br
    
                                
    • 
                                
  • hive having count 不能去重
                                    daizj
hive去重having count计数
                                    
    hive在使用having count()是，不支持去重计数 
  
hive (default)> select imei from t_test_phonenum where ds=20150701 group by imei having count(distinct phone_num)>1 limit 10;  
FAILED: SemanticExcep
    
                                
    • 
                                
  • WebSphere对JSP的缓存
                                    周凡杨
WAS JSP 缓存
                                    
          对于线网上的工程，更新JSP到WebSphere后，有时会出现修改的jsp没有起作用，特别是改变了某jsp的样式后，在页面中没看到效果，这主要就是由于websphere中缓存的缘故，这就要清除WebSphere中jsp缓存。要清除WebSphere中JSP的缓存，就要找到WAS安装后的根目录。 
       现服务
    
                                
    • 
                                
  • 设计模式总结
                                    朱辉辉33
java设计模式
                                    
    1.工厂模式 
  1.1 工厂方法模式 (由一个工厂类管理构造方法) 
     1.1.1普通工厂模式(一个工厂类中只有一个方法) 
     1.1.2多工厂模式(一个工厂类中有多个方法) 
     1.1.3静态工厂模式(将工厂类中的方法变成静态方法) 
&n
    
                                
    • 
                                
  • 实例：供应商管理报表需求调研报告
                                    老A不折腾
finereport报表系统报表软件信息化选型
                                    
    引言 
随着企业集团的生产规模扩张，为支撑全球供应链管理，对于供应商的管理和采购过程的监控已经不局限于简单的交付以及价格的管理，目前采购及供应商管理各个环节的操作分别在不同的系统下进行，而各个数据源都独立存在，无法提供统一的数据支持；因此，为了实现对于数据分析以提供采购决策，建立报表体系成为必须。 业务目标 
1、通过报表为采购决策提供数据分析与支撑 
2、对供应商进行综合评估以及管理，合理管理和
    
                                
    • 
                                
  • mysql
                                    林鹤霄

                                    
    转载源：http://blog.sina.com.cn/s/blog_4f925fc30100rx5l.html 
mysql -uroot -p 
ERROR 1045 (28000): Access denied for user 'root'@'localhost' (using password: YES) 
  
[root@centos var]# service mysql
    
                                
    • 
                                
  • Linux下多线程堆栈查看工具(pstree、ps、pstack)
                                    aigo
linux
                                    
    原文：http://blog.csdn.net/yfkiss/article/details/6729364 
  
1. pstree 
pstree以树结构显示进程$ pstree -p work | grep adsshd(22669)---bash(22670)---ad_preprocess(4551)-+-{ad_preprocess}(4552)  &n
    
                                
    • 
                                
  • html input与textarea 值改变事件
                                    alxw4616
JavaScript
                                    
    // 文本输入框(input) 文本域(textarea)值改变事件 
// onpropertychange(IE) oninput(w3c) 
$('input,textarea').on('propertychange input', function(event) { 
     console.log($(this).val()) 
}); 
  
    
                                
    • 
                                
  • String类的基本用法
                                    百合不是茶
String
                                    
      
字符串的用法; 
    // 根据字节数组创建字符串 
byte[] by = { 'a', 'b', 'c', 'd' };
String newByteString = new String(by); 
  
  
    1,length()  获取字符串的长度 
  
  &nbs
    
                                
    • 
                                
  • JDK1.5 Semaphore实例
                                    bijian1013
javathreadjava多线程Semaphore
                                    
    Semaphore类 
       一个计数信号量。从概念上讲，信号量维护了一个许可集合。如有必要，在许可可用前会阻塞每一个 acquire()，然后再获取该许可。每个 release() 添加一个许可，从而可能释放一个正在阻塞的获取者。但是，不使用实际的许可对象，Semaphore 只对可用许可的号码进行计数，并采取相应的行动。 
S
    
                                
    • 
                                
  • 使用GZip来压缩传输量
                                    bijian1013
javaGZip
                                    
            启动GZip压缩要用到一个开源的Filter：PJL Compressing Filter。这个Filter自1.5.0开始该工程开始构建于JDK5.0，因此在JDK1.4环境下只能使用1.4.6。 
        PJL Compressi
    
                                
    • 
                                
  • 【Java范型三】Java范型详解之范型类型通配符
                                    bit1129
java
                                    
      
  
定义如下一个简单的范型类， 
  
package com.tom.lang.generics;

public class Generics<T> {
    private T value;
    public Generics(T  value) {
        this.value = value;
    }
} 
    
                                
    • 
                                
  • 【Hadoop十二】HDFS常用命令
                                    bit1129
hadoop
                                    
    1. 修改日志文件查看器 
  
hdfs oev -i edits_0000000000000000081-0000000000000000089 -o edits.xml
cat edits.xml 
  
修改日志文件转储为xml格式的edits.xml文件，其中每条RECORD就是一个操作事务日志 
  2. fsimage查看HDFS中的块信息等 
&nb
    
                                
    • 
                                
  • 怎样区别nginx中rewrite时break和last
                                    ronin47

                                    
    在使用nginx配置rewrite中经常会遇到有的地方用last并不能工作，换成break就可以，其中的原理是对于根目录的理解有所区别，按我的测试结果大致是这样的。  
 
 location /    
 {     
     proxy_pass http://test; 
    
                                
    • 
                                
  • java-21.中兴面试题 输入两个整数 n 和 m ，从数列 1 ， 2 ， 3.......n 中随意取几个数 , 使其和等于 m
                                    bylijinnan
java
                                    
    
import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

public class CombinationToSum {

	/*
第21 题
2010 年中兴面试题
编程求解：
输入两个整数 n 和 m ，从数列 1 ， 2 ， 3.......n 中随意取几个数 ,
使其和等
    
                                
    • 
                                
  • eclipse svn 帐号密码修改问题
                                    开窍的石头
eclipseSVNsvn帐号密码修改
                                    
    问题描述： 
     Eclipse的SVN插件Subclipse做得很好，在svn操作方面提供了很强大丰富的功能。但到目前为止，该插件对svn用户的概念极为淡薄，不但不能方便地切换用户，而且一旦用户的帐号、密码保存之后，就无法再变更了。 
解决思路： 
     删除subclipse记录的帐号、密码信息，重新输入
    
                                
    • 
                                
  • [电子商务]传统商务活动与互联网的结合
                                    comsci
电子商务
                                    
     
 
      某一个传统名牌产品，过去销售的地点就在某些特定的地区和阶层，现在进入互联网之后，用户的数量群突然扩大了无数倍，但是，这种产品潜在的劣势也被放大了无数倍，这种销售利润与经营风险同步放大的效应，在最近几年将会频繁出现。。。。 
 
       如何避免销售量和利润率增加的
    
                                
    • 
                                
  • java 解析 properties-使用 Properties-可以指定配置文件路径
                                    cuityang
javaproperties
                                    
    #mq 
xdr.mq.url=tcp://192.168.100.15:61618; 
 
import java.io.IOException; 
import java.util.Properties; 
 
 
public class Test { 
 
 String conf = "log4j.properties"; 
 private static final
    
                                
    • 
                                
  • Java核心问题集锦
                                    darrenzhu
java基础核心难点
                                    
    注意，这里的参考文章基本来自Effective Java和jdk源码 
 
 
1)ConcurrentModificationException 
当你用for each遍历一个list时，如果你在循环主体代码中修改list中的元素，将会得到这个Exception，解决的办法是： 
1)用listIterator, 它支持在遍历的过程中修改元素， 
2)不用listIterator, new一个
    
                                
    • 
                                
  • 1分钟学会Markdown语法
                                    dcj3sjt126com
markdown
                                    
    markdown 简明语法 基本符号 
 
 *,-,+ 3个符号效果都一样，这3个符号被称为 Markdown符号  
 空白行表示另起一个段落 
 `是表示inline代码，tab是用来标记 代码段，分别对应html的code，pre标签 
 换行 
 
 单一段落( <p>) 用一个空白行 
 连续两个空格 会变成一个 <br> 
 连续3个符号，然后是空行
    
                                
    • 
                                
  • Gson使用二（GsonBuilder）
                                    eksliang
jsongsonGsonBuilder
                                    
    转载请出自出处：http://eksliang.iteye.com/blog/2175473 一.概述 
    GsonBuilder用来定制java跟json之间的转换格式 
  二.基本使用 
实体测试类： 
温馨提示：默认情况下@Expose注解是不起作用的,除非你用GsonBuilder创建Gson的时候调用了GsonBuilder.excludeField
    
                                
    • 
                                
  • 报ClassNotFoundException: Didn't find class "...Activity" on path: DexPathList
                                    gundumw100
android
                                    
    有一个工程，本来运行是正常的，我想把它移植到另一台PC上，结果报： 
 
 java.lang.RuntimeException: Unable to instantiate activity ComponentInfo{com.mobovip.bgr/com.mobovip.bgr.MainActivity}: java.lang.ClassNotFoundException: Didn't f
    
                                
    • 
                                
  • JavaWeb之JSP指令
                                    ihuning
javaweb
                                    
      
要点 
  
JSP指令简介  
page指令  
include指令  
  
JSP指令简介  
  
JSP指令（directive）是为JSP引擎而设计的，它们并不直接产生任何可见输出，而只是告诉引擎如何处理JSP页面中的其余部分。 
JSP指令的基本语法格式： 
<%@ 指令 属性名="
    
                                
    • 
                                
  • mac上编译FFmpeg跑ios
                                    啸笑天
ffmpeg
                                    
    1、下载文件：https://github.com/libav/gas-preprocessor， 复制gas-preprocessor.pl到/usr/local/bin/下， 修改文件权限：chmod 777 /usr/local/bin/gas-preprocessor.pl 
2、安装yasm-1.2.0 
curl http://www.tortall.net/projects/yasm
    
                                
    • 
                                
  • sql mysql oracle中字符串连接
                                    macroli
oraclesqlmysqlSQL Server
                                    
    有的时候，我们有需要将由不同栏位获得的资料串连在一起。每一种资料库都有提供方法来达到这个目的： 
 
 MySQL: CONCAT() 
 Oracle: CONCAT(), || 
 SQL Server: + 
 
CONCAT() 的语法如下： 
Mysql 中 CONCAT(字串1, 字串2, 字串3, ...): 将字串1、字串2、字串3，等字串连在一起。 
请注意，Oracle的CON
    
                                
    • 
                                
  • Git fatal: unab SSL certificate problem: unable to get local issuer ce rtificate
                                    qiaolevip
学习永无止境每天进步一点点git纵观千象
                                    
    // 报错如下： 
$ git pull origin master 
fatal: unable to access 'https://git.xxx.com/': SSL certificate problem: unable to get local issuer ce 
rtificate 
  
// 原因： 
由于git最新版默认使用ssl安全验证，但是我们是使用的git未设
    
                                
    • 
                                
  • windows命令行设置wifi
                                    surfingll
windowswifi笔记本wifi
                                    
    还没有讨厌无线wifi的无尽广告么，还在耐心等待它慢慢启动么 
教你命令行设置 笔记本电脑wifi： 
 
1、开启wifi命令 
 

netsh wlan set hostednetwork mode=allow ssid=surf8 key=bb123456
netsh wlan start hostednetwork
pause
 
 其中pause是等待输入，可以去掉 
 
2、
    
                                
    • 
                                
  • Linux（Ubuntu）下安装sysv-rc-conf
                                    wmlJava
linuxubuntusysv-rc-conf
                                    
    安装：sudo apt-get install sysv-rc-conf 使用：sudo sysv-rc-conf 
操作界面十分简洁，你可以用鼠标点击，也可以用键盘方向键定位，用空格键选择，用Ctrl+N翻下一页，用Ctrl+P翻上一页，用Q退出。 
  
  
背景知识 
sysv-rc-conf是一个强大的服务管理程序，群众的意见是sysv-rc-conf比chkconf
    
                                
    • 
                                
  • svn切换环境，重发布应用多了javaee标签前缀
                                    zengshaotao
javaee
                                    
    更换了开发环境，从杭州，改变到了上海。svn的地址肯定要切换的，切换之前需要将原svn自带的.svn文件信息删除，可手动删除，也可通过废弃原来的svn位置提示删除.svn时删除。 
  
然后就是按照最新的svn地址和规范建立相关的目录信息，再将原来的纯代码信息上传到新的环境。然后再重新检出，这样每次修改后就可以看到哪些文件被修改过，这对于增量发布的规范特别有用。 
  
检出
    
                                
    •