allen218
allen218

【设计模式】设计原则之S.O.L.I.D 五原则

SOLID 原则

S：单一职责原则 SRP（Single Responsibility Principle）
O：单一职责原则 OCP（Open Close Principle）
L：里氏替换原则 LSP（Liskov Substitution Principle）
I：接口隔离原则 ISP（Interface Segregationi Principle）
D：依赖反转原则 DIP（Dependency Inversion Principle）

1. 单一职责原则 SRP（Single Responsibility Principle）

1.1 定义

一个类或者模块只负责完成一个职责（或者功能）。

1.2 可以从哪几个维度判断当前类设计是否符合单一职责

public class UserInfo {
  private long userId;
  private String username;
  private String email;
  private String telephone;
  private long createTime;
  private long lastLoginTime;
  private String avatarUrl;
  private String provinceOfAddress; // 省
  private String cityOfAddress; // 市
  private String regionOfAddress; // 区 
  private String detailedAddress; // 详细地址
  // ...省略其他属性和方法...
}

从不同的应用场景

拿用户数据来说，如果只是简单的作展示，那么把地址等信息全部放在 UserInfo 中是符合单一职责的。

如果除了作展示外，比如：地址信息还会被用到物流等业务中去，那么，地址相关的信息就应该从 UserInfo 中抽离出来形成单独的类。

从不同阶段的需求背景

在当前的需求背景下，可能 UserInfo 是满足单一职责的；而随着业务的发展，新的需求使得 UserInfo 不在满足单一职责，如：业务需要实现进行统一鉴权功能，那么跟鉴权相关的字段（手机号、邮箱，用户名等）就需要抽离出来形成新的类才能满足新需求下，单一职责的类设计。

从不同的业务层面

如果你从“用户”这个业务层面来看，UserInfo 是满足单一职责要求的。

如果你从更加细分的“用户展示信息”、“地址信息”、“登录认证信息”等业务层面来看，UserInfo 是就需要继续进行拆分。

1.3 防止过度设计的思路

在设计过程中，我们可以先写一个相对粗粒度的类，满足业务需求。如果粗粒度的类越来越大，代码越来越多的时候，我们可以将粗粒度的类拆分成几个更细粒度的类。通过重构来完成这个操作。

1.4 判断类职责是否单一的几点原则

  1. 类中的代码行数、函数或属性过多，会影响代码的可读性和可维护性
  2. 类依赖的其它类过多，或者依赖类的其它类过多，不符合高内聚、低耦合的设计思想
  3. 私有方法过多，需要考虑能否将私有方法独立到新类中，设置 public 方法，供更多的类使用，从而提高代码的复用性
  4. 比较难取名字的类，一般只能用一些比较笼统的 Manager、Context 之类的名词来命名
  5. 类中大量方法都是集中操作类中的某几个属性，如：UserInfo 中很多方法都只是在操作和地址相关的字段

1.5 类的职责是否越单一越好

/**
 * Protocol format: identifier-string;{gson string}
 * For example: UEUEUE;{"a":"A","b":"B"}
 */
public class Serialization {
  private static final String IDENTIFIER_STRING = "UEUEUE;";
  private Gson gson;
  
  public Serialization() {
    this.gson = new Gson();
  }
  
  public String serialize(Map object) {
    StringBuilder textBuilder = new StringBuilder();
    textBuilder.append(IDENTIFIER_STRING);
    textBuilder.append(gson.toJson(object));
    return textBuilder.toString();
  }
  
  public Map deserialize(String text) {
    if (!text.startsWith(IDENTIFIER_STRING)) {
        return Collections.emptyMap();
    }
    String gsonStr = text.substring(IDENTIFIER_STRING.length());
    return gson.fromJson(gsonStr, Map.class);
  }
}

更加满足单一职责的版本

public class Serializer {
  private static final String IDENTIFIER_STRING = "UEUEUE;";
  private Gson gson;
  
  public Serializer() {
    this.gson = new Gson();
  }
  
  public String serialize(Map object) {
    StringBuilder textBuilder = new StringBuilder();
    textBuilder.append(IDENTIFIER_STRING);
    textBuilder.append(gson.toJson(object));
    return textBuilder.toString();
  }
}

public class Deserializer {
  private static final String IDENTIFIER_STRING = "UEUEUE;";
  private Gson gson;
  
  public Deserializer() {
    this.gson = new Gson();
  }
  
  public Map deserialize(String text) {
    if (!text.startsWith(IDENTIFIER_STRING)) {
        return Collections.emptyMap();
    }
    String gsonStr = text.substring(IDENTIFIER_STRING.length());
    return gson.fromJson(gsonStr, Map.class);
  }
}

更加单一职责的版本带来的问题：

  1. 代码的内聚性没有原来高。当修改协议后，或者有其它改变后，Serializer 和 Deserializer 两个类都需要修改
  2. 容易引发新的问题。如：当协议修改后，我们只修改了一个类，而忘记修改其它类，这样会导致程度出错，代码的可维护性变差

总的来说，单一职责主要是避免不相关的功能耦合在一起，提高类的内聚性的。但如果拆分的过细，反倒会降低内聚性，也会影响代码的可读性。

2. 开闭原则 OCP（Open Close Principle）

2.1 定义

软件实体（模块、类、方法等）应该“对扩展开放，对修改关闭”。
也就是在添加新的功能的时候，在已有代码基础上扩展代码（新增模块、类或方法等），而非修改已有代码（修改模块、类或方法等）。

2.2 开闭原则改造的例子

public class Alert {
  private AlertRule rule;
  private Notification notification;

  public Alert(AlertRule rule, Notification notification) {
    this.rule = rule;
    this.notification = notification;
  }

  public void check(String api, long requestCount, long errorCount, long durationOfSeconds) {
    long tps = requestCount / durationOfSeconds;
    if (tps > rule.getMatchedRule(api).getMaxTps()) {
      notification.notify(NotificationEmergencyLevel.URGENCY, "...");
    }
    if (errorCount > rule.getMatchedRule(api).getMaxErrorCount()) {
      notification.notify(NotificationEmergencyLevel.SEVERE, "...");
    }
  }
}

未改造前，添加新功能

public class Alert {
  // ...省略AlertRule/Notification属性和构造函数...
  
  // 改动一：添加参数timeoutCount
  public void check(String api, long requestCount, long errorCount, long timeoutCount, long durationOfSeconds) {
    long tps = requestCount / durationOfSeconds;
    if (tps > rule.getMatchedRule(api).getMaxTps()) {
      notification.notify(NotificationEmergencyLevel.URGENCY, "...");
    }
    if (errorCount > rule.getMatchedRule(api).getMaxErrorCount()) {
      notification.notify(NotificationEmergencyLevel.SEVERE, "...");
    }
    // 改动二：添加接口超时处理逻辑
    long timeoutTps = timeoutCount / durationOfSeconds;
    if (timeoutTps > rule.getMatchedRule(api).getMaxTimeoutTps()) {
      notification.notify(NotificationEmergencyLevel.URGENCY, "...");
    }
  }
}

该修改一共有两处改动，且都是在原有核心业务方法中添加新的参数或逻辑，这种操作显然是不符合开闭原则的。

改造之后的类组成

public class Alert {
  private List alertHandlers = new ArrayList<>();
  
  public void addAlertHandler(AlertHandler alertHandler) {
    this.alertHandlers.add(alertHandler);
  }

  public void check(ApiStatInfo apiStatInfo) {
    for (AlertHandler handler : alertHandlers) {
      handler.check(apiStatInfo);
    }
  }
}

public class ApiStatInfo {//省略constructor/getter/setter方法
  private String api;
  private long requestCount;
  private long errorCount;
  private long durationOfSeconds;
}

public abstract class AlertHandler {
  protected AlertRule rule;
  protected Notification notification;
  public AlertHandler(AlertRule rule, Notification notification) {
    this.rule = rule;
    this.notification = notification;
  }
  public abstract void check(ApiStatInfo apiStatInfo);
}

public class TpsAlertHandler extends AlertHandler {
  public TpsAlertHandler(AlertRule rule, Notification notification) {
    super(rule, notification);
  }

  @Override
  public void check(ApiStatInfo apiStatInfo) {
    long tps = apiStatInfo.getRequestCount()/ apiStatInfo.getDurationOfSeconds();
    if (tps > rule.getMatchedRule(apiStatInfo.getApi()).getMaxTps()) {
      notification.notify(NotificationEmergencyLevel.URGENCY, "...");
    }
  }
}

public class ErrorAlertHandler extends AlertHandler {
  public ErrorAlertHandler(AlertRule rule, Notification notification){
    super(rule, notification);
  }

  @Override
  public void check(ApiStatInfo apiStatInfo) {
    if (apiStatInfo.getErrorCount() > rule.getMatchedRule(apiStatInfo.getApi()).getMaxErrorCount()) {
      notification.notify(NotificationEmergencyLevel.SEVERE, "...");
    }
  }
}

主要有两点改造：

  1. 将之间耦合在一起的业务逻辑的处理，都抽离到对应的类中，让每个类只处理一种情况的业务逻辑，符合单一职责
  2. 使用对象对函数参数进行了统一封装，让后续的改动不会再引发函数参数的改变

改造之后，添加新功能

public class ApplicationContext {
  private AlertRule alertRule;
  private Notification notification;
  private Alert alert;
  
  public void initializeBeans() {
    alertRule = new AlertRule(/*.省略参数.*/); //省略一些初始化代码
    notification = new Notification(/*.省略参数.*/); //省略一些初始化代码
    alert = new Alert();
    alert.addAlertHandler(new TpsAlertHandler(alertRule, notification));
    alert.addAlertHandler(new ErrorAlertHandler(alertRule, notification));
  }
  public Alert getAlert() { return alert; }

  // 饿汉式单例
  private static final ApplicationContext instance = new ApplicationContext();
  private ApplicationContext() {
    initializeBeans();
  }
  public static ApplicationContext getInstance() {
    return instance;
  }
}

public class Alert { // 代码未改动... }
public class ApiStatInfo {//省略constructor/getter/setter方法
  private String api;
  private long requestCount;
  private long errorCount;
  private long durationOfSeconds;
  private long timeoutCount; // 改动一：添加新字段
}
public abstract class AlertHandler { //代码未改动... }
public class TpsAlertHandler extends AlertHandler {//代码未改动...}
public class ErrorAlertHandler extends AlertHandler {//代码未改动...}
// 改动二：添加新的handler
public class TimeoutAlertHandler extends AlertHandler {//省略代码...}

public class ApplicationContext {
  private AlertRule alertRule;
  private Notification notification;
  private Alert alert;
  
  public void initializeBeans() {
    alertRule = new AlertRule(/*.省略参数.*/); //省略一些初始化代码
    notification = new Notification(/*.省略参数.*/); //省略一些初始化代码
    alert = new Alert();
    alert.addAlertHandler(new TpsAlertHandler(alertRule, notification));
    alert.addAlertHandler(new ErrorAlertHandler(alertRule, notification));
    // 改动三：注册handler
    alert.addAlertHandler(new TimeoutAlertHandler(alertRule, notification));
  }
  //...省略其他未改动代码...
}

public class Demo {
  public static void main(String[] args) {
    ApiStatInfo apiStatInfo = new ApiStatInfo();
    // ...省略apiStatInfo的set字段代码
    apiStatInfo.setTimeoutCount(289); // 改动四：设置tiemoutCount值
    ApplicationContext.getInstance().getAlert().check(apiStatInfo);
}

重构之后，代码更加灵活和可扩展。如果需要添加新的告警逻辑，核心是只需要添加对应的 Handler 新逻辑处理类即可。不需要再去修改之前的 check() 中的逻辑。

同时，只需要对新添加的 handler 添加单元测试代码测试，而老的单元测试没有被改动，不需要再修改。

2.3 修改代码就意味着违背开闭原则吗？

改动一：为 ApiStatInfo 添加 timeoutCount

实际上，开闭原则可以应用到不同粒度的代码中，可以是模块、可以是类还可以是方法（及其属性）。同样一个代码改动，在粗代码粒度下，会被认为是修改；在细粒度下，会被认为是扩展。如：在类这个粒度层面来看，添加了 timeoutCount 这个属性，会被认为是修改；而在方法或属性的这粒度层面来看，由于并没有修改已有属性或方法，反而会被认为是扩展。

开闭原则的设计初衷是：只要它没有破坏原有代码的运行，没有破坏原有的单元测试，就可以被认定为一个合理的改动。

改动三和四：在方法内部添加代码

这种改动，无论在哪个粒度上来说，都是对原有代码的修改操作。而这种改动是否是可接受的呢？

我们要认识到，添加一个新功能，不可能任何模块、类、方法的代码都不被“修改”。我们的原则是：尽量让修改更集中、更少、更上层，尽量让最核心、最复杂的部分逻辑代码满足开闭原则。

对于上面的例子中，最核心的逻辑是和告警及其处理相关的功能（主要是 Alert 和 Handler 类）。如果把这部分的代码看能一个模块的话，该模块在添加新功能时，是符合开闭原则的。

2.4 如何做到符合“对扩展开放、对修改关闭”

最常用来提高代码可扩展性的方法有：多态、依赖注入、基于接口而非实现，以及部分设计模式（如：装饰、策略、模板、职责链和状态等）等。

// 这一部分体现了抽象意识
public interface MessageQueue { //... }
public class KafkaMessageQueue implements MessageQueue { //... }
public class RocketMQMessageQueue implements MessageQueue {//...}

public interface MessageFromatter { //... }
public class JsonMessageFromatter implements MessageFromatter {//...}
public class ProtoBufMessageFromatter implements MessageFromatter {//...}

public class Demo {
  private MessageQueue msgQueue; // 基于接口而非实现编程
  public Demo(MessageQueue msgQueue) { // 依赖注入
    this.msgQueue = msgQueue;
  }
  
  // msgFormatter：多态、依赖注入
  public void sendNotification(Notification notification, MessageFormatter msgFormatter) {
    //...    
  }
}

2.5 如何在项目中灵活运用开闭原则

  1. 对于一些比较确定的、短期内可能扩展，或者需求改动对代码结构影响比较大的情况，或者实现成本不高的扩展点，在编写代码的时候，我们是可以事先做好可扩展性设计的
  2. 对于一些未来不确定是否需要支持的需求，或者实现起来比较复杂的扩展点，可以等到后续需求来驱动，通过重构的方式支持可扩展的需求

2.6 开闭原则可能引发的问题

与代码可读性之间的冲突

一般情况下，重构之后符合开闭原则的代码，要比之前的代码复杂得多，理解起来也更加的有难度。

很多时候，需要在可扩展性和可读性之间做权衡。在某些情况下，可扩展性更重要，就牺牲一下可读性；而另一些时候，可可读性更重要，则需要牺牲一下可扩展性。

比如：如果核心逻辑中的判断逻辑不是很多，也就是功能不是很多的情况下，完全可以只使用 if-else 的方法来完成功能。相反，如果核心逻辑的判断逻辑比较多，本身的可读性和可维护性就会变差。此时，就需要将代码逻辑抽离出来，基于扩展性的思路来进行改造。

3. 里氏替换原则 LSP（Liskov Substitution Principle）

3.1 定义

能使用父类的地方，都可以用子类进行替换，并且保证原有程序的逻辑行为不变及正确性不被破坏。

主要用于继承关系中子类该如何设计的一个原则。

3.2 示例代码

public class Transporter {
  private HttpClient httpClient;
  
  public Transporter(HttpClient httpClient) {
    this.httpClient = httpClient;
  }

  public Response sendRequest(Request request) {
    // ...use httpClient to send request
  }
}

public class SecurityTransporter extends Transporter {
  private String appId;
  private String appToken;

  public SecurityTransporter(HttpClient httpClient, String appId, String appToken) {
    super(httpClient);
    this.appId = appId;
    this.appToken = appToken;
  }

  @Override
  public Response sendRequest(Request request) {
    if (StringUtils.isNotBlank(appId) && StringUtils.isNotBlank(appToken)) {
      request.addPayload("app-id", appId);
      request.addPayload("app-token", appToken);
    }
    return super.sendRequest(request);
  }
}

public class Demo {    
  public void demoFunction(Transporter transporter) {    
    Reuqest request = new Request();
    //...省略设置request中数据值的代码...
    Response response = transporter.sendRequest(request);
    //...省略其他逻辑...
  }
}

// 里式替换原则
Demo demo = new Demo();
demo.demofunction(new SecurityTransporter(/*省略参数*/););

3.3 面向对象多态和里氏替换区别

从定义描述和代码实现上来看，多态和里氏替换，但它们的关注角度是不一样的。

多态是面向对象编程的一大特性，也是面向对象编程语言的一种语法。它是一种代码层面的实现思路。

而里氏替换是一种设计原则，是用来指导继承关系中，子类该如何设计。子类的设计要保证在替换父类的时候，不改变原有程序的逻辑以及不破坏原有逻辑的正确性。

// 改造前：
public class SecurityTransporter extends Transporter {
  //...省略其他代码..
  @Override
  public Response sendRequest(Request request) {
    if (StringUtils.isNotBlank(appId) && StringUtils.isNotBlank(appToken)) {
      request.addPayload("app-id", appId);
      request.addPayload("app-token", appToken);
    }
    return super.sendRequest(request);
  }
}

// 改造后：
public class SecurityTransporter extends Transporter {
  //...省略其他代码..
  @Override
  public Response sendRequest(Request request) {
    if (StringUtils.isBlank(appId) || StringUtils.isBlank(appToken)) {
      throw new NoAuthorizationRuntimeException(...);
    }
    request.addPayload("app-id", appId);
    request.addPayload("app-token", appToken);
    return super.sendRequest(request);
  }
}

像上面这段改造后的代码，在使用时，是完全符合多态特性的，但是不满足里氏替换原则，为什么呢？

因为如果将父类替换成子类后，原本正常运行的代码，会抛出异常，导致代码无法正常运行。

3.4 哪些代码明显违反了 LSP？

里氏替换原则有一个更具指导意义的描述：按照协议来设计。也就是子类在设计的时候，要遵守父类的行为约定（协议）。子类只可以改变函数内部的实现逻辑，而不能改变函数原有的约定。这里主要包括：1. 函数声明要实现的功能；2. 对输入、输出、异常的规定；3. 注释中所罗列的任何特殊说明。

1. 子类违背父类声明要实现的功能

比如：父类定义的函数为 sortByAmount() 按照订单金额来进行排序，而子类使用的是按照订单生成日期来进行排序。

*2. 子类违背父类对输入、输出、异常的约定

比如：父类定义运行出错返回 null，数据为空返回空集合；而子类在运行出错后抛出异常，在数据为空返回 null。

3. 子类违背父类注释中所罗列的任何特殊说明

比如：对于提现功能来说，父类在注释中说明了：用户提现金额不能大于账户余额。而子类在实现中，对 VIP 客户实现了透支功能。

3.5 验证子类的设计是否符合里氏替换原则

使用父类的单元测试去验证子类的代码。如果某些单元测试运行失败，则有可能说明，子类的设计是没有完成遵守父类的约定，子类违反了里氏替换原则的。

4. 接口隔离原则 ISP（Interface Segregation Principle）

4.1 定义

客户端不应该被强迫依赖它不需要的接口。其中，客户端可以理解为接口的调用者或者使用者。

4.2 接口的理解

  1. 一组 API 接口集合
  2. 单个 API 接口或函数
  3. OOP 中接口的概念

1. 一组 API 接口集合

public interface UserService {
  boolean register(String cellphone, String password);
  boolean login(String cellphone, String password);
  UserInfo getUserInfoById(long id);
  UserInfo getUserInfoByCellphone(String cellphone);
}

public class UserServiceImpl implements UserService {
  //...
}

增加删除用户接口导致的问题

如果我们继续将 deleteById() 和 deleteUserByCellphone() 接口直接添加到 UserService 接口中，会存在安全隐患。比如：这个删除用户的操作只有管理台才能使用，而如果将该方法直接添加到 UserService 接口后，其它没有被授权的系统也可以调用该方法。

使用 ISP 进行改造

public interface UserService {
  boolean register(String cellphone, String password);
  boolean login(String cellphone, String password);
  UserInfo getUserInfoById(long id);
  UserInfo getUserInfoByCellphone(String cellphone);
}

public interface RestrictedUserService {
  boolean deleteUserByCellphone(String cellphone);
  boolean deleteUserById(long id);
}

public class UserServiceImpl implements UserService, RestrictedUserService {
  // ...省略实现代码...
}

主要是将存在安全隐患的接口，通过创建单独的接口从原来的接口中隔离出来，避免被其它系统滥用。

如果部分接口只被部分调用者使用，那就需要将这部分接口隔离出来，单独给对应的调用者使用，而不是强迫其它调用者也依赖这部分用不到的接口。

2. 单个接口或函数

接口功能的定义或函数的实现在设计上要功能单一，不要将多个不同的功能逻辑在一个函数中实现。

public class Statistics {
  private Long max;
  private Long min;
  private Long average;
  private Long sum;
  private Long percentile99;
  private Long percentile999;
  //...省略constructor/getter/setter等方法...
}

public Statistics count(Collection dataSet) {
  Statistics statistics = new Statistics();
  //...省略计算逻辑...
  return statistics;
}

通过 ISP 原则改造后：

public Long max(Collection dataSet) { //... }
public Long min(Collection dataSet) { //... } 
public Long average(Colletion dataSet) { //... }
// ...省略其他统计函数...

将原有设计中职责不够单一的函数使用 ISP 原则进行了隔离，让其满足单一职责。

3. 把接口理解为 OOP 中的接口

public interface Updater {
  void update();
}

public interface Viewer {
  String outputInPlainText();
  Map output();
}

public class RedisConfig implemets Updater, Viewer {
  //...省略其他属性和方法...
  @Override
  public void update() { //... }
  @Override
  public String outputInPlainText() { //... }
  @Override
  public Map output() { //...}
}

public class KafkaConfig implements Updater {
  //...省略其他属性和方法...
  @Override
  public void update() { //... }
}

public class MysqlConfig implements Viewer {
  //...省略其他属性和方法...
  @Override
  public String outputInPlainText() { //... }
  @Override
  public Map output() { //...}
}

public class SimpleHttpServer {
  private String host;
  private int port;
  private Map> viewers = new HashMap<>();
  
  public SimpleHttpServer(String host, int port) {//...}
  
  public void addViewers(String urlDirectory, Viewer viewer) {
    if (!viewers.containsKey(urlDirectory)) {
      viewers.put(urlDirectory, new ArrayList());
    }
    this.viewers.get(urlDirectory).add(viewer);
  }
  
  public void run() { //... }
}

public class Application {
    ConfigSource configSource = new ZookeeperConfigSource();
    public static final RedisConfig redisConfig = new RedisConfig(configSource);
    public static final KafkaConfig kafkaConfig = new KakfaConfig(configSource);
    public static final MySqlConfig mysqlConfig = new MySqlConfig(configSource);
    
    public static void main(String[] args) {
        ScheduledUpdater redisConfigUpdater =
            new ScheduledUpdater(redisConfig, 300, 300);
        redisConfigUpdater.run();
        
        ScheduledUpdater kafkaConfigUpdater =
            new ScheduledUpdater(kafkaConfig, 60, 60);
        redisConfigUpdater.run();
        
        SimpleHttpServer simpleHttpServer = new SimpleHttpServer(“127.0.0.1”, 2389);
        simpleHttpServer.addViewer("/config", redisConfig);
        simpleHttpServer.addViewer("/config", mysqlConfig);
        simpleHttpServer.run();
    }
}

通过 ISP 原则，这里设计了两个职责非常单一的接口：Updater 和 Viewer。ScheduledUpdater 只依赖 Updater 这个跟热更新相关的接口，不需要依赖自己用不到的 Viewer 接口。同样的，SimpleHttpServer 也只依赖跟查看信息相关的接口 Viewer 接口，不需要依赖 Updater 接口。

4.3 单一职责原则和接口隔离原则的区别

接口隔离原则更加侧重接口的设计。同时，它提供了一种判断接口是否职责单一的标准：通过调用者如何使用接口来间接地判定。如果调用者只使用部分接口或接口的部分功能，那接口的职责就不够单一。

单一职责原则是针对模块、类、接口的设计。涉及的范围更大。

4.4 不符合接口隔离原则的接口会存在的问题

  1. 会导致某些类依赖了一些它不需要的接口。
  2. 当接口增加一个方法，所以，之间实现了该接口的类，都需要实现这个方法。而如果是新建一个接口，则不会影响之前实现类的逻辑。

5. 依赖反转/依赖倒置原则 DIP（Dependency Inversion Principle）

5.1 定义

高层模块不要依赖低层模块，高层模块和低层模块应该通过抽象来相互依赖。此外，抽象不要依赖具体的实现细节，具体的实现细节依赖抽象。

高层模块和低层模块

在调用链上，调用者属于高层，被调用者属于低层。而在平时的开发中，高层模块依赖低层模块是没有任何问题的。

Tomcat 和 Java Web 程序的关系

Tomcat 就是高层模块，Java Web 应用程序属于低层模块。Tomcat 和 Java Web 之间没有直接的依赖关系，两者都是依赖于同一个“抽象”（Servlet 规范）。Servlet 规范不依赖 Tomcat 和 Java Web 程序的实现细节，而 Tomcat 和 Java Web 依赖于 Servlet 规范。

5.2 控制反转 IOC（Inversion of Control）

逻辑由程序员控制

public class UserServiceTest {
  public static boolean doTest() {
    // ... 
  }
  
  public static void main(String[] args) {//这部分逻辑可以放到框架中
    if (doTest()) {
      System.out.println("Test succeed.");
    } else {
      System.out.println("Test failed.");
    }
  }
}

逻辑由框架控制

public abstract class TestCase {
  public void run() {
    if (doTest()) {
      System.out.println("Test succeed.");
    } else {
      System.out.println("Test failed.");
    }
  }
  
  public abstract boolean doTest();
}

public class JunitApplication {
  private static final List testCases = new ArrayList<>();
  
  public static void register(TestCase testCase) {
    testCases.add(testCase);
  }
  
  public static final void main(String[] args) {
    for (TestCase case: testCases) {
      case.run();
    }
  }

框架通过 doTest() 预留扩展点，程序员只需要实现这个方法，而不需要再写 main 函数中的执行流程了。

只需要程序员实现的代码

public class UserServiceTest extends TestCase {
  @Override
  public boolean doTest() {
    // ... 
  }
}

// 注册操作还可以通过配置的方式来实现，不需要程序员显示调用register()
JunitApplication.register(new UserServiceTest();

控制反转的核心

框架只需要提供可扩展的代码骨架，用来封装对象，管理整个流程的执行。程序员只需要将业务有关的代码块添加到预留点上就可以利用框架来驱动整个程序流程的执行。

控制反转中的“控制”指的是对程序流程的控制，而“反转”指的是在没有使用框架前，程序员需要自己来控制流程的执行。在使用框架后，整个流程通过框架来控制。流程的控制权从程序员“反转”到了框架。

5.3 依赖注入 DI（Dependency Injection）

依赖注入是一种具体的编程技巧。该技术有一个非常形象的说法：依赖注入是一个标价 25 美元，实际只值 5 美分的概念。

依赖注入的概念：不通过 new() 的方式在类内部创建依赖对象，而是将依赖的类对象在外部创建好之后，通过构造函数、函数参数等方式传递（或注入）给类使用。

非依赖注入方式

// 非依赖注入实现方式
public class Notification {
  private MessageSender messageSender;
  
  public Notification() {
    this.messageSender = new MessageSender(); //此处有点像hardcode
  }
  
  public void sendMessage(String cellphone, String message) {
    //...省略校验逻辑等...
    this.messageSender.send(cellphone, message);
  }
}

public class MessageSender {
  public void send(String cellphone, String message) {
    //....
  }
}
// 使用Notification
Notification notification = new Notification();

依赖注入方式

// 依赖注入的实现方式
public class Notification {
  private MessageSender messageSender;
  
  // 通过构造函数将messageSender传递进来
  public Notification(MessageSender messageSender) {
    this.messageSender = messageSender;
  }
  
  public void sendMessage(String cellphone, String message) {
    //...省略校验逻辑等...
    this.messageSender.send(cellphone, message);
  }
}
//使用Notification
MessageSender messageSender = new MessageSender();
Notification notification = new Notification(messageSender);

5.4 控制反转与依赖注入的区别

控制反转是一种设计思想，是将程序由程序员控制“反转”到由框架控制。控制反转的实现主要有依赖注入、模板方法等方式。

而依赖注入是一种具体的编程技巧，是用来实现控制反转的一种方法。

说明

此文是根据王争设计模式之美相关专栏内容整理而来，非原创。

你可能感兴趣的:(【设计模式】设计原则之S.O.L.I.D 五原则)

  • 转班遇上星期六 凝结的海
    晚上上班的时候，我感觉有点饿，就在十点五左右去食堂，看看有没有什么吃的，一路上同事们都在说可能已经关门了，走快一点或许能碰得到。庆幸的是我到了他还没来得及关，我买了一个粽子和一个咸鸭蛋，总共花了四块三，总感觉比外面卖的要贵的多。后来我在三点多近四点的时候，我和三号前化料的一起去保安室拉了一大车水，我们装好之后，我让他先拉到我的岗位上，我去拉点原材料。他把水拉走之后我就出去把充电动车的电拔掉，又到路
  • 心情不好时，去做这四件事 绿茵下
    01读书当一个人的智慧不够时，最容易胡思乱想，将自己困住思维的牢笼里。想要开悟，首先要与智者对话，与高人同行，那么与智者对话最经济实惠的方式，莫过于读书了。于时光的静美中，手捧一本高质量的书籍，在书中窥见先贤们的所思所想，仿佛进入了一个平静的世界，让人思绪越来越清晰明了。或许读书不能够马上帮你解决眼前的难题，可日复一日地坚持下去，总能让你内心更加笃定，心灵更加沉静，生出智慧之花。在书中人物不同的经
  • 七绝.诗人之六（新韵四开） 水波杨山
    一诗在腹似怀胎，口诵笔挥生我孩。此际苦愁杂喜乐，若非孕妇怎知来？在每一个清晨，用诗歌叫醒灵魂。采今纳古写真情，尽付诗魂画境中。水向波心逐夏鸟，杨依山畔舞春风。诗的本质就是发现，诗人要永远像婴儿一样，睁大了好奇的眼睛去看周围的世界，去发现世界的新的美。——林庚
  • 养生和烟火气十足的生活 玉竹园
    内经素问的第二篇四季调神大论中是故圣人不治已病，治未病，不治已乱，治未乱，此之谓也。夫病已成而后药之，乱已成而后治之，譬犹渴而穿井，斗而铸锥，不亦晚乎。小绵羊穴健脾穴提到养生这个词，你会不会觉得离自己很遥远认为是上年纪的大爷大妈的专属？有的人觉得自己年纪轻不需要，有些是我上有老下有小工作忙忙叨叨，哪有闲心和时间来养生？养生是个很宽泛的词，也很抽象，无从下手感到迷茫。相信在阅读的你也会有过这样的闪念
  • 唯品会的东西是正品吗|唯品会和天猫哪个可靠|唯品会返利平台 好项目高省
    唯品会的东西是正品吗？目前电商发展较为完善，商品质量保证也逐步健全。一般情况下唯品会的东西都是属于正品的。唯品会买手们会找到全球各地不同的供应商进行报价，再进行供应商之间和同一家供应商历史报价的比价，从中选择价格最有优势的供应商。唯品会所销售的商品均从品牌方、代理商、品牌分支机构、国际品牌驻中国办事处等正规渠道采购，并与之签订战略正品采购协议。唯品会和天猫哪个可靠？其实唯品会和天猫都是比较可靠的购
  • 送考与年度考核之痛 康康的教育视野
    今天下午初三中考结束了，轮到我们初二班主任送学生地理生物小中考了。下午一点半，我们班主任各就各位，因为我们要集中的大本营是高三5班，但我推门一看，都是在午休监考老师们，我又合上门，打电话问段长，原来过一会儿学生进来时监考老师们正好去集中了，不影响我们集中。待监考老师们走后，我走进去一看，三三两两的桌子拼成各式“睡床”，地上桌上抽屉里到处都是废纸、饮料瓶、口罩等垃圾，我赶紧叫隔壁班的峰哥帮忙一起整理
  • 丁俊贵之《“女人和男人”那些事》 兴时态_198812
    【“女人和男人”那些事】生活中，我们经常用性别来给很多现象和问题贴标签。比如：女性发脾气是常见的事情，所以不要跟她们讲道理，要让着她们；女性考虑问题总是比较感性，不如男性那么理性、严谨、全面；女生的数学成绩普遍比较差，因此选文科的女生更多；……许许多多像这样的认知，已经成为我们根深蒂固的信念。我们在生活中哪怕不会直接这样讲，但多多少少都会有类似的想法和感受，并且用这些信念去理解和认知他人。一、人世
  • 想要孩子具备敏锐的观察力，只需了解这五大关键点 美式学习零距离
    孩子上了小学后，很多家长辅导孩子作业时发现孩子总是粗心大意，一会看错了题，一会又把相似的图案混淆在一起。对孩子的学习来说，观察力其实是专注力和记忆力的基础，孩子只有具备优秀的洞察力，清晰辨别事物，才在此基础上才能发展更好的专注力和记忆力。其实，各行各业都需要有敏锐观察力的人才。而且，对孩子来说，良好的观察力可以让孩子的学习、记忆都上一个台阶。01何为“观察力”？观察力是大脑多种智力活动的一项基础能
  • Makefile问答之 04 优化异常与警告设置 捕鲸叉 Linux使用Linux系统编程Makefilelinux
    Makefile怎样指定优化选项，包括编译和链接优化，常用的选项有哪些？在Makefile中，你可以通过设置编译器和链接器的选项来指定优化选项。优化选项可以分为编译优化和链接优化，以下是如何在Makefile中指定这些选项，以及一些常用的选项。示例Makefile#编译器CC=gcc#编译选项CFLAGS=-Wall-O2#链接选项LDFLAGS=-O2#需要链接的库LDLIBS=#目标文件TAR
  • [面试高频问题]关于多线程的单例模式 朱玥玥要每天学习 java单例模式开发语言
    单例模式什么是设计模式?设计模式可以看做为框架或者是围棋中的”棋谱”,红方当头炮,黑方马来跳.根据一些固定的套路下,能保证局势不会吃亏.在日常的程序设计中,往往有许多业务场景,根据这些场景,大佬们总结出了一些固定的套路.按照这个套路来实现代码,也不会吃亏.什么是单例模式,保证某类在程序中只有一个实例,而不会创建多份实例.单例模式具体的实现方式:可分为”懒汉模式”,”饿汉模式”.饿汉模式类加载的同时
  • 这该死的疫情 婴宁嫣然
    我真的是后知后觉，对今年年初的疫情当时只是恐惧，厌恶，现在是严重的憎恨了。因为疫情，领导说上学期学生在家没好好学习，基础不扎实，于是我们从期末考试结束就开始补课，今年的暑假休息了四天，哦不对是四天半。从七月至今，我们已经连续上了五个月课了，如果不是春节，估计我们还会有下一个五个月，还好，春节让我们这学期只用再上两个月。而从期中考试之前两周到现在，已经连续七个周上课了。我知道有人一定说疫情期间，你们
  • 2023-10-26 Eltonpeople
    文化通史121今日启发：Elton:第八章中世文化的初兴第一节幕府体制与公武二元文化的确立镰仓幕府在日本历史上，平安时代末期，出现平氏和源氏两大武士集团。首先平氏取代贵族而获得了政权，但仍沿袭贵族政治。平氏与源氏两大武士集团之间不断发生战争。源赖朝于1180年奉以仁王之旨令，举兵讨伐平氏，经过富士川、一谷、坛浦等战役，最终推翻了平氏政权。源赖朝夺取政权后，在地方领主的武力支持下，在镰仓地方初步建立
  • 息县一中第二期心理咨询培训第四组分享第五天 bcf0473e009c
    今天在组长的带领下我们一组6人在五楼小会议室进行了一次复盘学习，大家都发表了自己的学习心得，令我感触良多。经过第一次的学习，初次了解聚焦正向的含义，朱老师说的两句话让我印象很深“不以改变为目的，才有改变的机会”“关系大于方式，方式大于内容”遇到学生的问题时，不要想着上来就去改变他，对他的说教只会让他更加封闭自己，更不要想着会去改变他，要换种思维方式，试着把关系搞好，可以从兴趣爱好入手，打开他的内心
  • 五分钟手机美食插画教程194-秋葵 藩鼠
    图片发自App图片发自App工具：procreatepocket+手指第一步：用浅绿色木炭块画笔画一个小花瓣第二步：用墨绿色木炭块画笔在长长的三角形第三步：用浅墨绿色木炭块画笔画秋葵的另一个面第四步：用绿色杂色画笔在秋葵表面刷纹理第五步：用白色木炭块画笔画截面小圆珠
  • 【621】幼儿园亲子阅读之《小蓝和小黄》 登登一君
    我是昭君，我想记录我生活工作的点点滴滴，今天是我每日一篇文章的第621天。公众号搜索赵君可以查看最新文章。《小蓝和小黄》大部分的家长都看过，故事的诞生特别有戏剧性，当时是一位爷爷带着一个五岁的孙子，还有三岁的孙女坐火车，我们都知道三五岁的孩子是特别闹的时候，爷爷想让他们安静下来，拿出了自己讲故事的绝活。他随手从本杂志上撕下了几个不同颜色的纸块，把小颜色的纸块做成了故事的主角，然后就开始讲故事了。小
  • 感恩日记20190516 三皮Simon
    图片发自App人们交往，最重要是信任，因为你无法要求别人来信任你，所以最好的方法是你先去信任别人，别人也会投之以信任的。今天看着Remee聊了很多工作的事情，发觉上周的忧虑都是多余的，接下来就是努力支持到她的工作就可以啦。晚上去见了师父，听他讲了很多的人生哲学道理，哈哈，佩服佩服，不得不说又是学习啦。好吧，感恩他对我的信任，在我面前展示不同面的他，当然我也跟他说，他待我如儿子，我待他如半个父亲。感
  • 《读屈原《渔夫》有感》 丁宁_143a
    其一:水清可濯缨，水浊能涤足。万法皆随缘，不变唯真如。其二:察察之身受汶汶，浩浩之白蒙尘埃。屈公不勘世俗累，不见芙蕖淤泥来。
  • 《婆婆的意外之伤》 棻子
    《妖约芳香165》201809010周一晴28度❤今日感悟上午接到红龙的电话，除了平常的问候，听得出他沉重的声音，出大事了，原来是婆婆不小心摔跤，竟然摔断了右大腿骨，动弹不得，叫了救护车才把老人从六楼的家中抬下，送到医院。这真的对于老人来说，是最怕碰上的事情。都说年老后最怕摔，一摔不知会引起何样的后果与并发症。婆婆身体本就不好，因年轻时劳动过量，导致腰椎肩盘突出，动过大手术，此后走路也是慢悠悠，不
  • 失败不可怕，可怕的是没有备选方案 早起er
    身体是革命的本钱。健康的身体，良好的精神状态，才是生活与工作的根本。而运动，就是一个同时提升身体、和精神状态的好方法。我从小爱运动，但是从工作起，运动对我而言，也成为了一种奢侈品。每一次，我为自己做好了锻炼的计划。但每一次，又会因为各种原因，没能执行。有时候，是因为陪客户，有时候，是因为朋友的聚餐。有时候，纯粹是看电影、打游戏入了迷，所有的计划，都被抛之脑后。刚开始，还为此感到后悔不已，恨自己没用
  • 增长黑客和最小可复制的内核 爱思考的糖
    五段-增长黑客的三大步骤生活就像逆水行舟，加入你不能加速，现实中最好的情况，你也就处在一种原地打转的状况。增长，就像一辆车里的加速器。围棋爱好者，水平一直没有进步的原因。是因为没有找到提高下棋水平的增长模式有三个办法可以提高：做死活题，练习做关键决策的能力；打谱，复盘经典案例；找AI陪练。增长黑客的三个实战步骤：第一步，假设：建立最小闭环。从笨办法开始，不怕犯错，代价并不高，你可以勇敢尝试。想知道
  • MacOS Catalina 从源码构建Qt6.2开发库之01: 编译Qt6.2源代码 捕鲸叉 QTmacosc++QT
    安装xcode，cmake，ninjabrewinstallnodemac下安装OpenGL库并使之对各项目可见在macOS上安装OpenGL通常涉及到安装一些依赖库，如MGL、GLUT或者是GLEW等，同时确保LLVM的OpenGL框架和相关工具链的兼容性。以下是一个基本的安装步骤，你可以在终端中执行：安装Homebrew（如果还没有安装的话）：/bin/bash-c"$(curl-fsSLht
  • 【周总结】第六期第7周29叮当 29_叮当
    时间：2019.6.24——2019.6.30【本周计划/总结】一、职业发展注会复习备考。计划一天八小时复习。二、财务状况收支正常，还有账未收回，等段时间再催。三、健康每日1万步，7天完成；治疗白发，6天；平板支撑最近没坚持；每天锻炼完后拉伸，疏通经络；体重下降。图片发自App四、娱乐没什么娱乐活动。五、朋友与重要他人哥哥和侄子都回来了，家人团聚，老人很开心。一家人难得相聚六、家庭做好每周的清洁，
  • 每日片刻诗情画意之2022-06-28 人生下伴场
    #日诵诗情，画意日趣#人生下伴场-每日诗情画意#日诵之20220628春怨刘方平纱窗日落渐黄昏，金屋无人见泪痕。寂寞空庭春欲晚，梨花满地不开门。1、春怨是古代诗词的经典主题系列，除了民间夫君出远门或者思念意中人之外，宫廷锁春深也是常见的内容。刘方平的这一首我是第一次读到，第二句“金屋无人见泪痕”不知道是金屋藏娇的由来还是引用。2、梨花满地不开门，让我想起李清照《声声慢》词中“满地黄花堆积”、“寻寻
  • java的四个层级结构 活跃家族 JAVA
    java的四个层级结构首先，最底层的就是dto层，dto层就是所谓的model，dto中定义的是实体类，也就是.class文件，该文件中包含实体类的属性和对应属性的get、set方法；其次，是dao层（dao层的文件习惯以*Mapper命名），dao层会调用dto层，dao层中会定义实际使用到的方法，比如增删改查。一般在dao层下还会有个叫做sqlmap的包，该包下有xml文件，文件内容正是根据之
  • HTTPS 安全最佳实践（一）之SSLTLS部署 SHENHUANJIE HTTPSSSLTLS
    SSL/TLS是一种简单易懂的技术，它很容易部署及运行。但想要部署的安全通常是不容易的。这也使系统管理员和开发者不得不去了解SSL和TLS相关的技术，掌握如何配置一个安全的web服务器或应用。无疑会耗费很大的精力去看相关的技术文档，乏味且宽泛。受理SSL数字证书客户问题，包括产品咨询、技术支持、投诉受理、建议反馈，以及购买帮助等。1证书和私钥在TLS中，所有的安全性都从服务器的密码标识开始；需要一
  • 一个人的兵荒马乱 Q满船清梦压星河X
    听张信哲唱着：“人最怕就是动了情。”心里五味杂陈，纠结又害怕，犹豫又坚定，理智和感性在脑子里打架。二十多岁的人了，都快被催婚了，还玩暗恋。记忆中很多年前，朦朦胧胧的阳光下的教室窗边，那个人就站在那里，闪闪发光。许多年后，街边霓虹灯下，他依旧在那里，闪闪发光。暗恋中最大的理性就是把感觉藏在心里，等待它自己生根发芽的那一天。那时候我们懵懵懂懂，为了某个小男生小女生心跳、激动、流泪，我们以朋友的身份陪伴
  • 自我教育 自我的救赎
    教育一词最早见于《孟子.尽心上》。“得天下英才而教育之，三乐也。”《现代汉语词典》里说：教育作为名词指按一定要求培养人的工作。作为动词指按一定要求培养或用道理说服人使照着做。单从词典上的解释，我们很难实施好教育，在工作中，我们说了无穷的道理也很难说服人使之照着做。我们只能在如何说道理，如何说服人方面下功夫。真正的教育是自我教育。是指让受教育者自己教育自己，自己管理自己，这是教育的最高点。我们教育者
  • 致敬无名英雄!就在《无名》电影! ffc7a15e23ae
    “王一博股”乐华娱乐登陆港交所上市!万万没想到，开盘半小时大涨五成。上市首日开盘价5.6港元，上午最高时达到6.48元。王一博一跃成为股东，不愧是年轻有为，而最近他与梁朝伟领衔主演的《无名》更是登上热搜，领跑春节档!近日陈鲁豫采访《无名》导演程耳，称他之前不认识王一博，两个人仅仅见了一面，两个小时就迅速定下了彼此的合作，这一切都那么恰到好处。“鬼才”程耳还说，第一眼看见王一博，他身上的优雅力量感，
  • 地缚少年：源光被喊变态，八寻宁宁没有撩到源辉，却撩到了源光 ACGN安乐
    细想之下花子君和八寻宁宁之所以可以走到一起，主要还是因为花子君在未经过八寻宁宁允许就亲吻了八寻宁宁，虽说这是花子君给八寻宁宁的保护咒，但严格来讲这种kiss的结果确实在八寻宁宁的心中种下了爱情的种子。动画《地缚少年花子君》第五话，神秘女生出现，可能是花子君的女票，八寻宁宁这是吃醋了。神秘女生出现后与八寻宁宁进行了一番对话，声称花子君像猫咪不但可爱还喜欢撒娇，可花子君从未在八寻宁宁身边撒过娇，随后神
  • 用自己的方式为祖国庆生 霞12331
    今天是国庆节第一天，到处都是鲜红的国旗。天安门的升旗视频也刷爆了朋友圈。想起前年和家人下了火车，放下行李，直奔天安门广场观看升旗仪式。凌晨三点已经是人山人海，看见护卫队从城楼踢着正步迈着整齐的步伐走出来，内心无比激动。虽然被人群挡着，但是当听到国歌响起，看着五星红旗冉冉升起，作为一个中国人真的无比骄傲。接着参观了毛主席纪念堂，为主席献花，充满了感激。过去两年了，依然记忆犹新。今年是建国72周年，建
  • [黑洞与暗粒子]没有光的世界 comsci
         无论是相对论还是其它现代物理学,都显然有个缺陷,那就是必须有光才能够计算      但是,我相信,在我们的世界和宇宙平面中,肯定存在没有光的世界....      那么,在没有光的世界,光子和其它粒子的规律无法被应用和考察,那么以光速为核心的 &nbs
  • jQuery Lazy Load 图片延迟加载 aijuans jquery
    基于 jQuery 的图片延迟加载插件，在用户滚动页面到图片之后才进行加载。 对于有较多的图片的网页，使用图片延迟加载，能有效的提高页面加载速度。 版本： jQuery v1.4.4+ jQuery Lazy Load v1.7.2 注意事项： 需要真正实现图片延迟加载，必须将真实图片地址写在 data-original 属性中。若 src
  • 使用Jodd的优点 Kai_Ge jodd
    1.  简化和统一 controller ，抛弃 extends SimpleFormController ，统一使用 implements Controller 的方式。 2.  简化 JSP 页面的 bind, 不需要一个字段一个字段的绑定。 3.  对 bean 没有任何要求，可以使用任意的 bean 做为 formBean。   使用方法简介
  • jpa Query转hibernate Query 120153216 Hibernate
    public List<Map> getMapList(String hql, Map map) { org.hibernate.Query jpaQuery = entityManager.createQuery(hql); if (null != map) { for (String parameter : map.keySet()) { jp
  • Django_Python3添加MySQL/MariaDB支持 2002wmj mariaDB
    现状 首先，[email protected] 中默认的引擎为 django.db.backends.mysql 。但是在Python3中如果这样写的话，会发现 django.db.backends.mysql 依赖 MySQLdb[5] ，而 MySQLdb 又不兼容 Python3 于是要找一种新的方式来继续使用MySQL。 MySQL官方的方案 首先据MySQL文档[3]说，自从MySQL
  • 在SQLSERVER中查找消耗IO最多的SQL 357029540 SQL Server
    返回做IO数目最多的50条语句以及它们的执行计划。 select top 50   (total_logical_reads/execution_count) as avg_logical_reads,  (total_logical_writes/execution_count) as avg_logical_writes,  (tot
  • spring UnChecked 异常 官方定义！ 7454103 spring
      如果你接触过spring的 事物管理！那么你必须明白 spring的 非捕获异常！ 即 unchecked 异常！ 因为 spring 默认这类异常事物自动回滚！！ public static boolean isCheckedException(Throwable ex) { return !(ex instanceof RuntimeExcep
  • mongoDB 入门指南、示例 adminjun javamongodb操作
    一、准备工作 1、 下载mongoDB 下载地址：http://www.mongodb.org/downloads 选择合适你的版本 相关文档：http://www.mongodb.org/display/DOCS/Tutorial 2、 安装mongoDB A、 不解压模式： 将下载下来的mongoDB-xxx.zip打开，找到bin目录，运行mongod.exe就可以启动服务，默
  • CUDA 5 Release Candidate Now Available aijuans CUDA
    The CUDA 5 Release Candidate is now available at http://developer.nvidia.com/<wbr></wbr>cuda/cuda-pre-production. Now applicable to a broader set of algorithms, CUDA 5 has advanced fe
  • Essential Studio for WinRT网格控件测评 Axiba JavaScripthtml5
    Essential Studio for WinRT界面控件包含了商业平板应用程序开发中所需的所有控件，如市场上运行速度最快的grid 和chart、地图、RDL报表查看器、丰富的文本查看器及图表等等。同时，该控件还包含了一组独特的库，用于从WinRT应用程序中生成Excel、Word以及PDF格式的文件。此文将对其另外一个强大的控件——网格控件进行专门的测评详述。 网格控件功能 1、
  • java 获取windows系统安装的证书或证书链 bewithme windows
          有时需要获取windows系统安装的证书或证书链，比如说你要通过证书来创建java的密钥库  。 有关证书链的解释可以查看此处 。   public static void main(String[] args) { SunMSCAPI providerMSCAPI = new SunMSCAPI(); S
  • NoSQL数据库之Redis数据库管理(set类型和zset类型) bijian1013 redis数据库NoSQL
    4.sets类型         Set是集合，它是string类型的无序集合。set是通过hash table实现的，添加、删除和查找的复杂度都是O(1)。对集合我们可以取并集、交集、差集。通过这些操作我们可以实现sns中的好友推荐和blog的tag功能。         sadd：向名称为key的set中添加元
  • 异常捕获何时用Exception，何时用Throwable bingyingao
    用Exception的情况 try {        //可能发生空指针、数组溢出等异常         } catch (Exception e) {          
  • 【Kafka四】Kakfa伪分布式安装 bit1129 kafka
    在http://bit1129.iteye.com/blog/2174791一文中，实现了单Kafka服务器的安装，在Kafka中，每个Kafka服务器称为一个broker。本文简单介绍下，在单机环境下Kafka的伪分布式安装和测试验证   1. 安装步骤   Kafka伪分布式安装的思路跟Zookeeper的伪分布式安装思路完全一样，不过比Zookeeper稍微简单些(不
  • Project Euler bookjovi haskell
    Project Euler是个数学问题求解网站，网站设计的很有意思，有很多problem，在未提交正确答案前不能查看problem的overview，也不能查看关于problem的discussion thread，只能看到现在problem已经被多少人解决了，人数越多往往代表问题越容易。     看看problem 1吧： Add all the natural num
  • Java-Collections Framework学习与总结-ArrayDeque BrokenDreams Collections
            表、栈和队列是三种基本的数据结构，前面总结的ArrayList和LinkedList可以作为任意一种数据结构来使用，当然由于实现方式的不同，操作的效率也会不同。         这篇要看一下java.util.ArrayDeque。从命名上看
  • 读《研磨设计模式》-代码笔记-装饰模式-Decorator bylijinnan java设计模式
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ import java.io.BufferedOutputStream; import java.io.DataOutputStream; import java.io.FileOutputStream; import java.io.Fi
  • Maven学习(一) chenyu19891124 Maven私服
        学习一门技术和工具总得花费一段时间，5月底6月初自己学习了一些工具，maven+Hudson+nexus的搭建，对于maven以前只是听说，顺便再自己的电脑上搭建了一个maven环境，但是完全不了解maven这一强大的构建工具，还有ant也是一个构建工具，但ant就没有maven那么的简单方便，其实简单点说maven是一个运用命令行就能完成构建，测试，打包，发布一系列功
  • [原创]JWFD工作流引擎设计----节点匹配搜索算法(用于初步解决条件异步汇聚问题) 补充 comsci 算法工作PHP搜索引擎嵌入式
    本文主要介绍在JWFD工作流引擎设计中遇到的一个实际问题的解决方案，请参考我的博文"带条件选择的并行汇聚路由问题"中图例A2描述的情况(http://comsci.iteye.com/blog/339756),我现在把我对图例A2的一个解决方案公布出来，请大家多指点 节点匹配搜索算法(用于解决标准对称流程图条件汇聚点运行控制参数的算法) 需要解决的问题：已知分支
  • Linux中用shell获取昨天、明天或多天前的日期 daizj linuxshell上几年昨天获取上几个月
    在Linux中可以通过date命令获取昨天、明天、上个月、下个月、上一年和下一年 # 获取昨天 date -d 'yesterday'  # 或 date -d 'last day' # 获取明天 date -d 'tomorrow'   # 或 date -d 'next day' # 获取上个月 date -d 'last month' #
  • 我所理解的云计算 dongwei_6688 云计算
          在刚开始接触到一个概念时，人们往往都会去探寻这个概念的含义，以达到对其有一个感性的认知，在Wikipedia上关于“云计算”是这么定义的，它说：        Cloud computing is a phrase used to describe a variety of computing co
  • YII CMenu配置 dcj3sjt126com yii
    Adding id and class names to CMenu We use the id and htmlOptions to accomplish this. Watch. //in your view $this->widget('zii.widgets.CMenu', array( 'id'=>'myMenu', 'items'=>$this-&g
  • 设计模式之静态代理与动态代理 come_for_dream 设计模式
    静态代理与动态代理        代理模式是java开发中用到的相对比较多的设计模式，其中的思想就是主业务和相关业务分离。所谓的代理设计就是指由一个代理主题来操作真实主题，真实主题执行具体的业务操作，而代理主题负责其他相关业务的处理。比如我们在进行删除操作的时候需要检验一下用户是否登陆，我们可以删除看成主业务，而把检验用户是否登陆看成其相关业务
  • 【转】理解Javascript 系列 gcc2ge JavaScript
    理解Javascript_13_执行模型详解 摘要: 在《理解Javascript_12_执行模型浅析》一文中,我们初步的了解了执行上下文与作用域的概念，那么这一篇将深入分析执行上下文的构建过程，了解执行上下文、函数对象、作用域三者之间的关系。函数执行环境简单的代码:当调用say方法时，第一步是创建其执行环境，在创建执行环境的过程中，会按照定义的先后顺序完成一系列操作:1.首先会创建一个
  • Subsets II hcx2013 set
    Given a collection of integers that might contain duplicates, nums, return all possible subsets. Note: Elements in a subset must be in non-descending order. The solution set must not conta
  • Spring4.1新特性——Spring缓存框架增强 jinnianshilongnian spring4
    目录 Spring4.1新特性——综述 Spring4.1新特性——Spring核心部分及其他 Spring4.1新特性——Spring缓存框架增强 Spring4.1新特性——异步调用和事件机制的异常处理 Spring4.1新特性——数据库集成测试脚本初始化 Spring4.1新特性——Spring MVC增强 Spring4.1新特性——页面自动化测试框架Spring MVC T
  • shell嵌套expect执行命令 liyonghui160com
        一直都想把expect的操作写到bash脚本里,这样就不用我再写两个脚本来执行了,搞了一下午终于有点小成就,给大家看看吧.   系统:centos 5.x   1.先安装expect yum -y install expect   2.脚本内容: cat auto_svn.sh   #!/bin/bash
  • Linux实用命令整理 pda158 linux
    0. 基本命令 　　linux 基本命令整理 　 　1. 压缩 解压 　　tar -zcvf a.tar.gz a   #把a压缩成a.tar.gz 　　tar -zxvf a.tar.gz     #把a.tar.gz解压成a 　 　2. vim小结 　　2.1 vim替换 　　:m,ns/word_1/word_2/gc  
  • 独立开发人员通向成功的29个小贴士 shoothao 独立开发
    概述：本文收集了关于独立开发人员通向成功需要注意的一些东西,对于具体的每个贴士的注解有兴趣的朋友可以查看下面标注的原文地址。 明白你从事独立开发的原因和目的。 保持坚持制定计划的好习惯。 万事开头难，第一份订单是关键。 培养多元化业务技能。 提供卓越的服务和品质。 谨小慎微。 营销是必备技能。 学会组织，有条理的工作才是最有效率的。 “独立
  • JAVA中堆栈和内存分配原理 uule java
    1、栈、堆 1.寄存器：最快的存储区, 由编译器根据需求进行分配,我们在程序中无法控制.2. 栈：存放基本类型的变量数据和对象的引用，但对象本身不存放在栈中，而是存放在堆（new 出来的对象）或者常量池中（字符串常量对象存放在常量池中。）3. 堆：存放所有new出来的对象。4. 静态域：存放静态成员（static定义的）5. 常量池：存放字符串常量和基本类型常量（public static f
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他