策略模式

转载：设计模式--spring源码中使用策略模式（Strategy Pattern）

spring常用模式--------策略模式

策略模式

定义

定义了算法族，分别封装起来，让他们之间可以互相替换，此模式让算法的变化独立于使用算法的客户。

作用

策略模式使开发人员能够开发出由许多可替换的部分组成的软件，并且各个部分之间是弱连接的关系。弱连接的特性使软件具有更强的可扩展性，易于维护；更重要的是，它大大提高了软件的可重用性。

 UML

可以发现，每个具体策略的实现都实现了相同的接口或者父类，然后需要提供一个上下文来提供策略的引用。

spring中的例子ValidationUtils

Class: org.springframework.validation.ValidationUtils 验证工具类

public static void invokeValidator(Validator validator, Object obj, Errors errors) {  
        Assert.notNull(validator, "Validator must not be null");  
        Assert.notNull(errors, "Errors object must not be null");  
        if (logger.isDebugEnabled()) {  
            logger.debug("Invoking validator [" + validator + "]");  
        }  
        if (obj != null && !validator.supports(obj.getClass())) {  
            throw new IllegalArgumentException(  
                    "Validator [" + validator.getClass() + "] does not support [" + obj.getClass() + "]");  
        }  
        validator.validate(obj, errors);  
        if (logger.isDebugEnabled()) {  
            if (errors.hasErrors()) {  
                logger.debug("Validator found " + errors.getErrorCount() + " errors");  
            }  
            else {  
                logger.debug("Validator found no errors");  
            }  
        }  
    }  

Interface:org.springframework.validation.Validator

public interface Validator {  
    boolean supports(Class clazz);  
    void validate(Object target, Errors errors);  
  
}  

可以自己定义Validator接口的实现。比如：

public class UserValidator implements Validator {  
  
    @Override  
    public boolean supports(Class clazz) {  
        return User.class.equals(clazz);  
    }  
  
    @Override  
    public void validate(Object target, Errors errors) {  
        User user = (User) target;  
        if (!StringUtils.hasLength(user.getUsername())) {  
            errors.rejectValue("username", "", "登录编码必须填写！");  
        }  
        if (!StringUtils.hasLength(user.getPassword())) {  
            errors.rejectValue("password", "", "登录密码必须填写！");  
        }  
        if (!StringUtils.hasLength(user.getName())) {  
            errors.rejectValue("name", "", "用户姓名必须填写！");  
        }  
    }  
  
}  

调用各自的validate策略：

ValidationUtils.invokeValidator(new UserValidator(), user, errors);  

以前的 

多用组合，少用继承。

//将基础属性与动态属性分类开来

public abstract class Duck {

    private FlyInterface flyInterface;

    private BarkInterface barkInterface;

    

    public abstract void swim(); 

    

    public abstract void display();

    

    public void performFly() {

        flyInterface.fly();

    }

    

    public void performBark() {

        barkInterface.bark();

    }

    

    public FlyInterface getFlyInterface() {

        return flyInterface;

    }

    public void setFlyInterface(FlyInterface flyInterface) {

        this.flyInterface = flyInterface;

    }

    public BarkInterface getBarkInterface() {

        return barkInterface;

    }

    public void setBarkInterface(BarkInterface barkInterface) {

        this.barkInterface = barkInterface;

    }

}

//duck实现类

public class MyDuck extends Duck {

    public void swim() {

        System.out.println("i can swim.");

    }

    

    public void display() {

        System.out.println("i am red.");

    }

}

//鸭子叫接口

public interface BarkInterface {

    public void bark();

}

//鸭子飞接口

public interface FlyInterface {

    public void fly();

}

//鸭子飞实现类

public class FlyWithWings implements FlyInterface {

 

    @Override

    public void fly() {

        System.out.println("i fly with wings.");

    }

}

//测试类

public class Test {

    public static void main(String[] args) {

        Duck myDuck = new MyDuck();

        myDuck.setFlyInterface(new FlyWithWings());

        myDuck.performFly();

    }

}

//结果：

i fly with wings.