计算机书籍推荐

Thu, 14 Sep 2023 17:16:03 +0800

计算机书籍推荐

sicp

架构设计

Designing Data-Intensive Applications
Clean Architecture: A Craftsman’s Guide to Software Structure and Design
领域驱动设计
企业应用架构模式
凤凰架构
设计模式
MIT6.824

手边书

on java
Java Concurrency in Practice(java concurrency包的开发者所著)
java并发编程之美
实战java高并发程序设计
深入理解java虚拟机
netty实战
高性能mysql(补充高可用mysql)
redis实战，redis设计与实现
计算机的构造与解释

编码规范

代码大全
代码整洁之道《Clean Code》
重构:改善既有代码质量

性能优化

性能之巅

计算机基础

通识

深入理解计算机系统

算法和编程思想

编程珠玑
编码：隐匿在计算机软硬件背后的语言
算法导论
计算机程序设计艺术
啊哈算法

操作系统

现代操作系统

数据库

CMU15445
MySQL必知必会
MySQL技术内幕

计算机网络

计算机网络-自顶向下方法

Redis教程

Thu, 17 Aug 2023 11:34:15 +0800

响应式变成与虚拟线程

平台线程

平台线程是操作系统的一个线程，大概有以下特点：
- 需要1ms来启动
- 会被预先分配约2m内存
- 上下文切换需要0.1ms
内存的分配与操作系统的实现保持一致：
- 在线程创建时，操作系统在虚拟内存中为线程栈预留空间。
- 物理内存分配：实际物理内存往往是按需分配的，当访问栈空间时，出发缺页异常，通过页错误（page fault）机制实现
- 当线程第一次访问其栈空间的某个页面时，操作系统才会为该页面分配物理内存（懒加载方式）
- 内存的大小制约了cpu的处理请求数量

给定条件：

中台高扩展实践

Sun, 11 Jun 2023 15:06:06 +0800

中台高扩展实战

扩展点

基于Spring Bean的扩展点

使用流程：

编写扩展点类

该类实现扩展点接口

该类添加扩展点注解（可能包括了扩展点定位信息）来标识扩展点

执行扩展点类

定义扩展点坐标类：用于定位扩展点的位置
- 包含扩展点名和ID
- 扩展点名是接口，用于分别不同的扩展点业务
- 扩展点ID是其对应的业务区分点，用于分别此处使用的该扩展点业务的方法

package com.alibaba.cola.extension;

/**
 * Extension Coordinate(扩展坐标) is used to uniquely position an Extension
 */
public class ExtensionCoordinate {

    private final String extensionPointName;
    private final String bizScenarioUniqueIdentity;

    /**
     * Wrapper
     */
    private Class<?> extensionPointClass;
    private BizScenario bizScenario;

    public Class getExtensionPointClass() {
        return extensionPointClass;
    }

    public BizScenario getBizScenario() {
        return bizScenario;
    }

    public static ExtensionCoordinate valueOf(Class<?> extPtClass, BizScenario bizScenario){
        return new ExtensionCoordinate(extPtClass, bizScenario);
    }

    public ExtensionCoordinate(Class<?> extPtClass, BizScenario bizScenario){
        this.extensionPointClass = extPtClass;
        this.extensionPointName = extPtClass.getName();
        this.bizScenario = bizScenario;
        this.bizScenarioUniqueIdentity = bizScenario.getUniqueIdentity();
    }

    public ExtensionCoordinate(String extensionPoint, String bizScenario){
        this.extensionPointName = extensionPoint;
        this.bizScenarioUniqueIdentity = bizScenario;
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((bizScenarioUniqueIdentity == null) ? 0 : bizScenarioUniqueIdentity.hashCode());
        result = prime * result + ((extensionPointName == null) ? 0 : extensionPointName.hashCode());
        return result;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
          return true;
        }

        if (obj == null) {
          return false;
        }

        if (getClass() != obj.getClass()) {
          return false;
        }

        ExtensionCoordinate other = (ExtensionCoordinate) obj;
        if (bizScenarioUniqueIdentity == null) {
            if (other.bizScenarioUniqueIdentity != null) {
              return false;
            }
        } else if (!bizScenarioUniqueIdentity.equals(other.bizScenarioUniqueIdentity)) {
          return false;
        }
        if (extensionPointName == null) {
          return other.extensionPointName == null;
        } else {
          return extensionPointName.equals(other.extensionPointName);
        }
    }

    @Override
    public String toString() {
        return "ExtensionCoordinate [extensionPointName=" + extensionPointName + ", bizScenarioUniqueIdentity=" + bizScenarioUniqueIdentity + "]";
    }

}

定义扩展点注解，用于后续自动注册扩展点类，同时也要包含一些参数用于区分不同的扩展点和生成扩展点坐标

package com.alibaba.cola.extension;

import org.springframework.stereotype.Component;

import java.lang.annotation.*;

/**
 * Extension
 */
@Inherited
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
@Component
public @interface Extension {
    String bizId()  default BizScenario.DEFAULT_BIZ_ID;
    String useCase() default BizScenario.DEFAULT_USE_CASE;
    String scenario() default BizScenario.DEFAULT_SCENARIO;
}

package com.alibaba.cola.extension;

import org.springframework.stereotype.Component;

import java.lang.annotation.*;

/**
 * because {@link Extension} only supports single coordinates,
 * this annotation is a supplement to {@link Extension} and supports multiple coordinates
 *
 * @version 1.0
 * @see Extension
 */
@Inherited
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
@Component
public @interface Extensions {

    String[] bizId() default BizScenario.DEFAULT_BIZ_ID;

    String[] useCase() default BizScenario.DEFAULT_USE_CASE;

    String[] scenario() default BizScenario.DEFAULT_SCENARIO;

}

定义扩展点仓库类，使用Map，Key代表扩展点坐标，Value代表扩展点类

package com.alibaba.cola.extension;

import org.springframework.stereotype.Component;

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

/**
 * ExtensionRepository 
 */
@Component
public class ExtensionRepository {

    public Map<ExtensionCoordinate, ExtensionPointI> getExtensionRepo() {
        return extensionRepo;
    }

    private Map<ExtensionCoordinate, ExtensionPointI> extensionRepo = new HashMap<>();


}

定义扩展点接口

package com.alibaba.cola.extension;

/**
 *  ExtensionPointI is the parent interface of all ExtensionPoints
 *  扩展点表示一块逻辑在不同的业务有不同的实现，使用扩展点做接口申明，然后用Extension（扩展）去实现扩展点。 
 */
public interface ExtensionPointI {

}

扩展点类自动注册：
- 利用Spring应用上下文来获取所有带有特殊注解的Bean对象，也就是扩展点类
- 定义扩展点注册类
  1. 通过反射来获取Bean对象对应的扩展点类
  2. 利用反射来获取该类对应的接口和以及注解中的值，生成扩展点坐标类
  3. 将扩展点坐标和扩展点类放入扩展点仓库

package com.alibaba.cola.extension.register;

import com.alibaba.cola.extension.Extension;
import com.alibaba.cola.extension.ExtensionPointI;
import com.alibaba.cola.extension.Extensions;
import jakarta.annotation.PostConstruct;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;


import java.util.Map;

/**
 * ExtensionBootstrap
 *
 * @author Frank Zhang
 * @date 2020-06-18 7:55 PM
 */
@Slf4j
@Component
public class ExtensionBootstrap implements ApplicationContextAware {

    @Resource
    private ExtensionRegister extensionRegister;

    private ApplicationContext applicationContext;

    @PostConstruct
    public void init(){
        Map<String, ExtensionPointI> extMap = applicationContext.getBeansOfType(ExtensionPointI.class);
        for (ExtensionPointI ext : extMap.values()) {
            if (ext.getClass().isAnnotationPresent(Extension.class)) {
                extensionRegister.doRegistration(ext);
            }else if (ext.getClass().isAnnotationPresent(Extensions.class)){
                extensionRegister.doRegistrationExtensions(ext);
            }else {
                log.error("There is no annotation for @Extension or @Extension on this extension class:{}" , ext.getClass());
            }
        }
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }
}

package com.alibaba.cola.extension.register;

import com.alibaba.cola.extension.*;
import jakarta.annotation.Resource;
import org.springframework.aop.support.AopUtils;
import org.springframework.core.annotation.AnnotatedElementUtils;
import org.springframework.core.annotation.AnnotationUtils;
import org.springframework.stereotype.Component;
import org.springframework.util.ClassUtils;
import org.springframework.util.ObjectUtils;

/**
 * ExtensionRegister
 *
 */
@Component
public class ExtensionRegister {

    /**
     * 扩展点接口名称不合法
     */
    private static final String EXTENSION_INTERFACE_NAME_ILLEGAL = "extension_interface_name_illegal";
    /**
     * 扩展点不合法
     */
    private static final String EXTENSION_ILLEGAL = "extension_illegal";
    /**
     * 扩展点定义重复
     */
    private static final String EXTENSION_DEFINE_DUPLICATE = "extension_define_duplicate";

    @Resource
    private ExtensionRepository extensionRepository;

    public final static String EXTENSION_EXTPT_NAMING = "ExtPt";


    public void doRegistration(ExtensionPointI extensionObject) {
        Class<?> extensionClz = extensionObject.getClass();
        if (AopUtils.isAopProxy(extensionObject)) {
            extensionClz = AopUtils.getTargetClass(extensionObject);
        }
        Extension extensionAnn = AnnotatedElementUtils.findMergedAnnotation(extensionClz, Extension.class);
        BizScenario bizScenario = BizScenario.valueOf(extensionAnn.bizId(), extensionAnn.useCase(), extensionAnn.scenario());
        ExtensionCoordinate extensionCoordinate = new ExtensionCoordinate(calculateExtensionPoint(extensionClz), bizScenario.getUniqueIdentity());
        ExtensionPointI preVal = extensionRepository.getExtensionRepo().put(extensionCoordinate, extensionObject);
        if (preVal != null) {
            String errMessage = "Duplicate registration is not allowed for :" + extensionCoordinate;
            throw new ExtensionException(EXTENSION_DEFINE_DUPLICATE, errMessage);
        }
    }

    public void doRegistrationExtensions(ExtensionPointI extensionObject){
        Class<?> extensionClz = extensionObject.getClass();
        if (AopUtils.isAopProxy(extensionObject)) {
            extensionClz = ClassUtils.getUserClass(extensionObject);
        }

        Extensions extensionsAnnotation = AnnotationUtils.findAnnotation(extensionClz, Extensions.class);

        //Support multiple extensions registration
        String[] bizIds = extensionsAnnotation.bizId();
        String[] useCases = extensionsAnnotation.useCase();
        String[] scenarios = extensionsAnnotation.scenario();
        for (String bizId : bizIds) {
            for (String useCase : useCases) {
                for (String scenario : scenarios) {
                    BizScenario bizScenario = BizScenario.valueOf(bizId, useCase, scenario);
                    ExtensionCoordinate extensionCoordinate = new ExtensionCoordinate(calculateExtensionPoint(extensionClz), bizScenario.getUniqueIdentity());
                    ExtensionPointI preVal = extensionRepository.getExtensionRepo().put(extensionCoordinate, extensionObject);
                    if (preVal != null) {
                        String errMessage = "Duplicate registration is not allowed for :" + extensionCoordinate;
                        throw new ExtensionException(EXTENSION_DEFINE_DUPLICATE, errMessage);
                    }
                }
            }
        }
    }

    /**
     * @param targetClz
     * @return
     */
    private String calculateExtensionPoint(Class<?> targetClz) {
        Class<?>[] interfaces = ClassUtils.getAllInterfacesForClass(targetClz);
        if (interfaces == null || interfaces.length == 0) {
            throw new ExtensionException(EXTENSION_ILLEGAL, "Please assign a extension point interface for " + targetClz);
        }
        for (Class intf : interfaces) {
            String extensionPoint = intf.getSimpleName();
            if (extensionPoint.contains(EXTENSION_EXTPT_NAMING)) {
                return intf.getName();
            }
        }
        String errMessage = "Your name of ExtensionPoint for " + targetClz +
                " is not valid, must be end of " + EXTENSION_EXTPT_NAMING;
        throw new ExtensionException(EXTENSION_INTERFACE_NAME_ILLEGAL, errMessage);
    }

}

定义扩展点执行器（本质上是一种策略模式）
- 通过接口和业务模式，生成扩展点坐标，通过不同的扩展点坐标，定位到不同的扩展点类
- 使用函数式接口来执行不同的扩展点类的方法

抽象扩展点执行器，包含了函数式接口的执行方法

设计模式

Sun, 11 Jun 2023 14:38:20 +0800

设计模式

设计原则

开闭原则
- 对扩展开放
- 对修改关闭

通过扩展来实现变化，而不是通过修改已有代码来实现变化

里氏替换原则
- 子类可以实现父类的抽象方法，但不能覆盖父类的非抽象方法
- 子类可以有自己独有的方法
- 覆盖或实现父类的方法时，输入参数可以被放大，更宽松
- 覆盖或实现父类的方法时，输出参数可以被缩小，更严格

保证将所有父类替换为子类，程序的运行没有任何问题

后端开发 on loveLZZ的个人博客

计算机书籍推荐

计算机书籍推荐

架构设计

手边书

编码规范

性能优化

计算机基础

通识

算法和编程思想

操作系统

数据库

计算机网络

Redis教程

响应式变成与虚拟线程

平台线程

中台高扩展实践

中台高扩展实战

扩展点

基于Spring Bean的扩展点

设计模式

设计模式

设计原则