java复制代码// Step 1: 开启 Feign 客户端
@EnableFeignClients
@SpringBootApplication
public class ComGangCloudTemplateOrderApplication {..........}


// Step 2 : 准备 FeignClient 对象
@Component
@FeignClient("product-server")
public interface ProductFeignClient {
    @GetMapping("/template/get")
    CloudTemplateEntity get(@RequestParam("desc") String desc);
}

// Step 3 : 调用 FeignClient 对象
@Autowired
private ProductFeignClient productFeignClient;
productFeignClient.get("order-server")

java复制代码public void registerBeanDefinitions(AnnotationMetadata metadata,
			BeanDefinitionRegistry registry) {
    // 其中涉及到2个主要的步骤 : 
    // 1.注册Configuration
    registerDefaultConfiguration(metadata, registry);
    // 2. 注册 Feign Client
    registerFeignClients(metadata, registry);
}

java复制代码// 1. 获取注解上面的属性 -> PS:001
Map<String, Object> defaultAttrs = 
    metadata.getAnnotationAttributes(EnableFeignClients.class.getName(), true);

// 2. 注册 BeanDefinitionBuilder (PS : 这一步骤实际上构建了一个 BeanDefinitionBuilder)
private void registerClientConfiguration(BeanDefinitionRegistry registry, Object name,
    Object configuration) {
    
    // BeanDefinitionBuilder是使用构建器模式构建BeanDefinitions
    BeanDefinitionBuilder builder = BeanDefinitionBuilder
        .genericBeanDefinition(FeignClientSpecification.class);
    // name : default.com.gang.cloud.template.demo.ComGangCloudTemplateOrderApplication
    builder.addConstructorArgValue(name);
    builder.addConstructorArgValue(configuration);
    // default.com.gang.cloud.template.demo.ComGangCloudTemplateOrderApplication.FeignClientSpecification
    registry.registerBeanDefinition(
        name + "." + FeignClientSpecification.class.getSimpleName(),builder.getBeanDefinition()
    );
        
}

java复制代码// 注解类的使用主要是 FeignClientsRegistrar
C05- FeignClientsRegistrar(AnnotationMetadata metadata,BeanDefinitionRegistry registry)
    M5_01- registerFeignClients : FeignClient 核心方式
        - 准备对象 ClassPathScanningCandidateComponentProvider
        - 获取标注了 EnableFeignClients 的 Map 集合
        - 构建一个 AnnotationTypeFilter 
            ?- 为什么不和上面一样使用 getAnnotationAttributes 直接获取相关类 -> PS:M5_01_01
         - getBasePackages 获取需要扫描的路径集合 Set<String>->LV001 
        FOR- 循环路径集合 : LV001
            - findCandidateComponents 获取对应的 Set<BeanDefinition>->LV002
                 ?- 注意 , 这里会通过 findCandidateComponents 查找路径下标注了 Component 的类型 ->  PS:M5_01_02
           FOR- 循环 BeanDefinition : LV002
               - 获取 FeignClient 的属性 Map<String, Object> ->LV003
               - registerClientConfiguration 注册配置信息
               - registerFeignClient 注册当前 FeignClient 
    M5_02- registerFeignClient(BeanDefinitionRegistry registry,AnnotationMetadata annotationMetadata, Map<String, Object> attributes)
        ?- 核心作用就是构建一个 BeanDefined , 其中又主要可以分为4步 -> PS:M5_02_01
         1- BeanDefinitionBuilder.genericBeanDefinition 构建一个 BeanDefinitionBuilder
         2- definition.getBeanDefinition() 构建一个 AbstractBeanDefinition
         3- new BeanDefinitionHolder 构建一个 BeanDefinitionHolder
         4- BeanDefinitionReaderUtils.registerBeanDefinition 注入 Bean

java复制代码// PS : 其中省略了部分代码 , 想看完整版的可以看源码
public void registerFeignClients(AnnotationMetadata metadata,
			BeanDefinitionRegistry registry) {
    // 准备 scan 对象用于扫描
    ClassPathScanningCandidateComponentProvider scanner = getScanner();
    scanner.setResourceLoader(this.resourceLoader);

    // 这一句很重要 , 这是个用于 Scan 的排除筛选器 ,他会屏蔽调无用的 Bean
    AnnotationTypeFilter annotationTypeFilter = new AnnotationTypeFilter(
				FeignClient.class);
                                
    if (clients == null || clients.length == 0) {
        // 添加排除筛选器 -> PS:0002
        scanner.addIncludeFilter(annotationTypeFilter);
        basePackages = getBasePackages(metadata);
    } else {
        // 省略 ,同样是为了进行特殊的匹配
    }

    for (String basePackage : basePackages) {
        Set<BeanDefinition> candidateComponents = scanner.findCandidateComponents(basePackage);
        for (BeanDefinition candidateComponent : candidateComponents) {
            if (candidateComponent instanceof AnnotatedBeanDefinition) {
                AnnotatedBeanDefinition beanDefinition = (AnnotatedBeanDefinition) candidateComponent;
                AnnotationMetadata annotationMetadata = beanDefinition.getMetadata();
                // 获取注解属性 -> PS:0003
                Map<String, Object> attributes = annotationMetadata
                    .getAnnotationAttributes(FeignClient.class.getCanonicalName());
                // 注册 FeignClient
                registerFeignClient(registry, annotationMetadata, attributes);
            }
        }
    }
}
        
// PS:0002 排除筛选器的使用
protected boolean isCandidateComponent(MetadataReader metadataReader) throws IOException {
    for (TypeFilter tf : this.includeFilters) {
        //..........
    }
}

java复制代码
private void registerFeignClient(BeanDefinitionRegistry registry,
			AnnotationMetadata annotationMetadata, Map<String, Object> attributes) {
    String className = annotationMetadata.getClassName();
    
    // 准备 BeanDefinitionBuilder -> org.springframework.cloud.openfeign.FeignClientFactoryBean
    BeanDefinitionBuilder definition = BeanDefinitionBuilder
        .genericBeanDefinition(FeignClientFactoryBean.class);
    // 校验属性是否合法
    validate(attributes);
                
    // 省略所有的 addPropertyValue 操作 ,此操作为 definition 添加属性

    String alias = contextId + "FeignClient";
    AbstractBeanDefinition beanDefinition = definition.getBeanDefinition();
    beanDefinition.setAttribute(FactoryBean.OBJECT_TYPE_ATTRIBUTE, className);

    // 由于有一个默认 BeanDefinition  , 此处通过 primary 进行覆盖
    boolean primary = (Boolean) attributes.get("primary");
    beanDefinition.setPrimary(primary);

    BeanDefinitionHolder holder = new BeanDefinitionHolder(beanDefinition, className,
        new String[] { alias });
    // 向给定的bean工厂注册给定的bean定义    
    BeanDefinitionReaderUtils.registerBeanDefinition(holder, registry);
}

java复制代码// HttpClientFeignConfiguration 的配置项
@Bean
@ConditionalOnMissingBean(HttpClientConnectionManager.class)
public HttpClientConnectionManager connectionManager(ApacheHttpClientConnectionManagerFactory connectionManagerFactory,FeignHttpClientProperties httpClientProperties) {
    final HttpClientConnectionManager connectionManager = connectionManagerFactory
        .newConnectionManager(httpClientProperties.isDisableSslValidation(),
        // 最大连接数
        httpClientProperties.getMaxConnections(),
        httpClientProperties.getMaxConnectionsPerRoute(),
        // 连接存活时间和单位
        httpClientProperties.getTimeToLive(),
        httpClientProperties.getTimeToLiveUnit(),
        this.registryBuilder);
        
        this.connectionManagerTimer.schedule(new TimerTask() {
                @Override
                public void run() {
                        connectionManager.closeExpiredConnections();
                }
        }, 30000, httpClientProperties.getConnectionTimerRepeat());
        
        return connectionManager;
}

@Bean
public CloseableHttpClient httpClient(ApacheHttpClientFactory httpClientFactory,
    HttpClientConnectionManager httpClientConnectionManager,
    FeignHttpClientProperties httpClientProperties) {
    
    RequestConfig defaultRequestConfig = RequestConfig.custom()
        .setConnectTimeout(httpClientProperties.getConnectionTimeout())
        .setRedirectsEnabled(httpClientProperties.isFollowRedirects())
        .build();
        
        this.httpClient = httpClientFactory.createBuilder()
            .setConnectionManager(httpClientConnectionManager)
            .setDefaultRequestConfig(defaultRequestConfig).build();
            
        return this.httpClient;
}


// OkHttpFeignConfiguration 的配置项
@Bean
@ConditionalOnMissingBean(ConnectionPool.class)
public ConnectionPool httpClientConnectionPool(
    FeignHttpClientProperties httpClientProperties,
    OkHttpClientConnectionPoolFactory connectionPoolFactory) {
    // OKHttp 连接池属性
    Integer maxTotalConnections = httpClientProperties.getMaxConnections();
    Long timeToLive = httpClientProperties.getTimeToLive();
    TimeUnit ttlUnit = httpClientProperties.getTimeToLiveUnit();
    return connectionPoolFactory.create(maxTotalConnections, timeToLive, ttlUnit);
}

@Bean
public okhttp3.OkHttpClient client(OkHttpClientFactory httpClientFactory,
    ConnectionPool connectionPool,
    FeignHttpClientProperties httpClientProperties) {
    
    Boolean followRedirects = httpClientProperties.isFollowRedirects();
    Integer connectTimeout = httpClientProperties.getConnectionTimeout();
    Boolean disableSslValidation = httpClientProperties.isDisableSslValidation();
    this.okHttpClient = httpClientFactory.createBuilder(disableSslValidation)
        .connectTimeout(connectTimeout, TimeUnit.MILLISECONDS)
        .followRedirects(followRedirects).connectionPool(connectionPool)
        .build();
        
    return this.okHttpClient;
}

java复制代码// 如果细看源码 , 会发现存在2个 OkHttpFeignConfiguration 
//一个在 FeignAutoConfiguration 内部 , 另外一个存在于 org.springframework.cloud.openfeign.clientconfig 包下

// 疑点 : 点开FeignAutoConfiguration$OkHttpFeignConfiguration 上面有多个 Conditional

@Configuration(proxyBeanMethods = false)
@ConditionalOnClass(OkHttpClient.class)
@ConditionalOnMissingClass("com.netflix.loadbalancer.ILoadBalancer")
@ConditionalOnMissingBean(okhttp3.OkHttpClient.class)
@ConditionalOnProperty("feign.okhttp.enabled")
protected static class OkHttpFeignConfiguration {
    //............
}

// [Pro] : 通过 OnClassCondition 测试的时候就会发现 , 由于 ILoadBalancer 存在 , 则不会加载该类下的配置

而在 org.springframework.cloud.openfeign.clientconfig 包下的配置中 , 则有如下要求
@ConditionalOnMissingBean(okhttp3.OkHttpClient.class)

// 所以 , 已知的那种配置实际上会导致2个配置项都不会走



//!!! 那么应该怎么配置 ?



// Step 1 ：添加　eign-okhttp　相关配置
<dependency>
    <groupId>io.github.openfeign</groupId>
    <artifactId>feign-okhttp</artifactId>
</dependency>


// Step 2 : Application 上导入配置文件 
@Import(value = {OkHttpFeignConfiguration.class})


// Step 3 : config 中注册 Client
@Configuration
@ConditionalOnClass(Feign.class)
@AutoConfigureAfter(value = {FeignAutoConfiguration.class, OkHttpFeignConfiguration.class})
public class FeignOkHttpConfig {

    @Bean
    @ConditionalOnMissingBean(Client.class)
    public Client feignClient(okhttp3.OkHttpClient client) {
        // 这里还有相关配置 ,暂时省略 , 写流程的时候补上
        return new OkHttpLoadBalancingClient(....);
    }
}

java复制代码C- FeignClient
    M- String value() default ""
    M- String serviceId() default ""
    M- String contextId() default "" : 如果存在，它将用作bean名而不是名称，但不会用作服务id。
    M- String name() default ""
    M- String qualifier() default ""
    M- String url() default ""
    M- boolean decode404() default false
    M- Class<?>[] configuration() : 为虚客户端定制的配置类。
    M- Class<?> fallback()
    M- Class<?> fallbackFactory()
    M- String path() default ""
    M- boolean primary() default true

java复制代码// 覆盖默认配置
@FeignClient(contextId = "fooClient", name = "stores", configuration = FooConfiguration.class)
link : https://docs.spring.io/spring-cloud-openfeign/docs/current/reference/html/#spring-cloud-feign-overriding-defaults    
    
// 获取回退的原因
@FeignClient(name = "test", url = "http://localhost:${server.port}/", fallback = Fallback.class)
    
// 获取触发回退的原因
@FeignClient(name = "testClientWithFactory", url = "http://localhost:${server.port}/",fallbackFactory = TestFallbackFactory.class)

// 配置主 Bean
// PS : 当使用 Feign 和 Spring Cloud CircuitBreaker 回退时，在同一类型的 ApplicationContext 中有多个 bean    
@FeignClient(name = "hello", primary = false)

java复制代码feign:
    client:
        config:
            feignName:
                connectTimeout: 5000
                readTimeout: 5000
                loggerLevel: full
                errorDecoder: com.example.SimpleErrorDecoder
                retryer: com.example.SimpleRetryer
                defaultQueryParameters:
                    query: queryValue
                defaultRequestHeaders:
                    header: headerValue
                requestInterceptors:
                    - com.example.FooRequestInterceptor
                    - com.example.BarRequestInterceptor
                decode404: false
                encoder: com.example.SimpleEncoder
                decoder: com.example.SimpleDecoder
                contract: com.example.SimpleContract
                capabilities:
                    - com.example.FooCapability
                    - com.example.BarCapability
                metrics.enabled: false
                
                
// 已经配套的 Bean 类 ,Debug get/set 就可以看到使用的节点
@ConfigurationProperties(prefix = "feign.httpclient")
public class FeignHttpClientProperties {

	// 禁用SSL验证的默认值
	public static final boolean DEFAULT_DISABLE_SSL_VALIDATION = false;

        // 最大od连接数的缺省值
	public static final int DEFAULT_MAX_CONNECTIONS = 200;

	// 每条路由的最大连接数的缺省值
	public static final int DEFAULT_MAX_CONNECTIONS_PER_ROUTE = 50;

	// 存活的时间的默认值
	public static final long DEFAULT_TIME_TO_LIVE = 900L;

	//  默认存活时间单位.
	public static final TimeUnit DEFAULT_TIME_TO_LIVE_UNIT = TimeUnit.SECONDS;

	// 是否重定向
	public static final boolean DEFAULT_FOLLOW_REDIRECTS = true;

	// 连接超时的默认值
	public static final int DEFAULT_CONNECTION_TIMEOUT = 2000;

	//连接计时器重复的默认值
	public static final int DEFAULT_CONNECTION_TIMER_REPEAT = 3000;

	private boolean disableSslValidation = DEFAULT_DISABLE_SSL_VALIDATION;

	private int maxConnections = DEFAULT_MAX_CONNECTIONS;

	private int maxConnectionsPerRoute = DEFAULT_MAX_CONNECTIONS_PER_ROUTE;

	private long timeToLive = DEFAULT_TIME_TO_LIVE;

	private TimeUnit timeToLiveUnit = DEFAULT_TIME_TO_LIVE_UNIT;

	private boolean followRedirects = DEFAULT_FOLLOW_REDIRECTS;

	private int connectionTimeout = DEFAULT_CONNECTION_TIMEOUT;

	private int connectionTimerRepeat = DEFAULT_CONNECTION_TIMER_REPEAT;
        
}

@ConfigurationProperties("feign.client")
public class FeignClientProperties {

	private boolean defaultToProperties = true;
	private String defaultConfig = "default";
	private Map<String, FeignClientConfiguration> config = new HashMap<>();
        
}       
          
public static class FeignClientConfiguration {

    private Logger.Level loggerLevel;

    private Integer connectTimeout;

    private Integer readTimeout;

    private Class<Retryer> retryer;

    private Class<ErrorDecoder> errorDecoder;

    private List<Class<RequestInterceptor>> requestInterceptors;

    private Boolean decode404;

    private Class<Decoder> decoder;

    private Class<Encoder> encoder;

    private Class<Contract> contract;

    private ExceptionPropagationPolicy exceptionPropagationPolicy;         
    
    //........
    
}
          
// Step 1 : Config 配置的类
FeignClientConfiguration     
FeignHttpClientProperties
FeignClientProperties


// Step 2 : 配置的位置
C- FeignClientFactoryBean
    M- configureUsingProperties
    M- configureUsingConfiguration

cpp复制代码#pragma once

#include <QtWidgets/QMainWindow>
#include "ui_SignalSlot.h"

class QtGuiSecond;

class SignalSlot : public QMainWindow {
	Q_OBJECT

public:
	SignalSlot(QWidget *parent = Q_NULLPTR);

private:
	void init();

private slots:
	void slotBtn();
	void slotEditStr(QString str);
private:
	Ui::SignalSlotClass ui;

	QtGuiSecond* _guiSecond = nullptr;
};

cpp复制代码#include "SignalSlot.h"
#include "QtGuiSecond.h"

SignalSlot::SignalSlot(QWidget *parent)
	: QMainWindow(parent) {
	ui.setupUi(this);
	init();
}

void SignalSlot::init() {
	connect(ui.pushButton, SIGNAL(clicked()), this, SLOT(slotBtn()));

	_guiSecond = new QtGuiSecond;

	connect(_guiSecond, SIGNAL(sigEditStr(QString)), this, SLOT(slotEditStr(QString)));
}

void SignalSlot::slotBtn() {
	_guiSecond->show();
}

void SignalSlot::slotEditStr(QString str) {
	ui.label->setText(str);
}

cpp复制代码#pragma once

#include <QWidget>
#include "ui_QtGuiSecond.h"

class QtGuiSecond : public QWidget {
	Q_OBJECT

public:
	QtGuiSecond(QWidget *parent = Q_NULLPTR);
	~QtGuiSecond();

private:
	void init();

private slots:
	void slotOK();
signals:
	void sigEditStr(QString);

private:
	Ui::QtGuiSecond ui;


};

cpp复制代码#include "QtGuiSecond.h"

QtGuiSecond::QtGuiSecond(QWidget *parent)
	: QWidget(parent) {
	ui.setupUi(this);
	init();
}

QtGuiSecond::~QtGuiSecond() {
}

void QtGuiSecond::init() {
	connect(ui.pushButton, SIGNAL(clicked()), this, SLOT(slotOK()));
}

void QtGuiSecond::slotOK() {
	QString str = ui.lineEdit->text();
	emit sigEditStr(str);
}

cpp复制代码#pragma once
#include <QString>

class IEditArg {
public:
	IEditArg();
	~IEditArg();

	virtual void editStr(QString str);
};

cpp复制代码#include "IEditArg.h"

IEditArg::IEditArg() {
}

IEditArg::~IEditArg() {
}

void IEditArg::editStr(QString str) {

}

cpp复制代码#pragma once

#include <QtWidgets/QMainWindow>
#include "ui_SignalSlot.h"
#include "IEditArg.h"

class QtGuiSecond;

class SignalSlot : public QMainWindow, public IEditArg {
	Q_OBJECT

public:
	SignalSlot(QWidget *parent = Q_NULLPTR);

	void editStr(QString str)override;
private:
	void init();

private slots:
	void slotBtn();
private:
	Ui::SignalSlotClass ui;

	QtGuiSecond* _guiSecond = nullptr;
};

cpp复制代码#include "SignalSlot.h"
#include "QtGuiSecond.h"

SignalSlot::SignalSlot(QWidget *parent)
	: QMainWindow(parent) {
	ui.setupUi(this);
	init();
}

void SignalSlot::editStr(QString str) {
	ui.label->setText(str);
}

void SignalSlot::init() {
	connect(ui.pushButton, SIGNAL(clicked()), this, SLOT(slotBtn()));

	_guiSecond = new QtGuiSecond;

	_guiSecond->setArgInterface(this);
}

void SignalSlot::slotBtn() {
	_guiSecond->show();
}

cpp复制代码#pragma once

#include <QWidget>
#include "ui_QtGuiSecond.h"

class IEditArg;

class QtGuiSecond : public QWidget {
	Q_OBJECT

public:
	QtGuiSecond(QWidget *parent = Q_NULLPTR);
	~QtGuiSecond();

	void setArgInterface(IEditArg* editArg);
private:
	void init();

private slots:
	void slotOK();

private:
	Ui::QtGuiSecond ui;

	IEditArg* _editArg = nullptr;
};

cpp复制代码#include "QtGuiSecond.h"
#include "IEditArg.h"

QtGuiSecond::QtGuiSecond(QWidget *parent)
	: QWidget(parent) {
	ui.setupUi(this);
	init();
}

QtGuiSecond::~QtGuiSecond() {
}

void QtGuiSecond::setArgInterface(IEditArg* editArg) {
	_editArg = editArg;
}

void QtGuiSecond::init() {
	connect(ui.pushButton, SIGNAL(clicked()), this, SLOT(slotOK()));
}

void QtGuiSecond::slotOK() {
	QString str = ui.lineEdit->text();
	if (_editArg!=nullptr){
		_editArg->editStr(str);
	}
}

c复制代码struct sdshdr {

    // 记录 buf 数组中已使用字节的数量
    // 等于 SDS 所保存字符串的长度
    int len;
    // 记录 buf 数组中未使用字节的数量
    int free;
    // 字节数组，用于保存字符串，
    char buf[];

};

c复制代码struct sdshdr {
    int len; = 5
    int free; = 0
    char buf[]; = 'hello'

};

c复制代码struct sdshdr {
    int len; = 11
    int free; = 11
    char buf[]; = 'hello world'

};
> set demo 'hello world wang';
struct sdshdr {
    int len; = 16
    int free; = 6
    char buf[]; = 'hello world wang'

};

java复制代码public class Producer {
    public static void main(String[] args) throws Exception{
        //生产者组
        DefaultMQProducer producer = new DefaultMQProducer("delay_producer_group");

        //设置nameserver
        producer.setNamesrvAddr("localhost:9876");
        //启动生产者
        producer.start();

        //构建消息
        Message message = new Message("delayTopic","TagA","delayMessage".getBytes(RemotingHelper.DEFAULT_CHARSET));
        // 重点：设置延迟级别
        message.setDelayTimeLevel(3);
        // 发送消息
        SendResult sendResult = producer.send(message);
        // 打印发送结果
        System.out.println("发送结果："+sendResult);
        // 关闭生产者
        producer.shutdown();
    }
}

java复制代码public class Consumer {
    public static void main(String[] args) throws Exception {
        // 消费者组
        DefaultMQPushConsumer consumer =  new DefaultMQPushConsumer("delay_consumer_group");
        //注册nameserver
        consumer.setNamesrvAddr("localhost:9876");

        // 订阅主题
        consumer.subscribe("delayTopic","TagA");

        // 开启消费offset
        consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);


        //监听器
        consumer.registerMessageListener(new MessageListenerConcurrently() {
            @Override
            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> list, ConsumeConcurrentlyContext consumeConcurrentlyContext) {
                for (int i = 0; i < list.size(); i++) {
                    MessageExt messageExt = list.get(i);
                    String msg = new String(messageExt.getBody());
                    //这里主要打印延迟时间≈当前时间-消息的生产时间
                    System.out.println(msg+" 时间="+(System.currentTimeMillis()-messageExt.getBornTimestamp()));
                }
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            }
        });

        consumer.start();
    }
}

ini复制代码        //真正的topic
        String topic = msg.getTopic();
        //真正的队列Id
        int queueId = msg.getQueueId();

        final int tranType = MessageSysFlag.getTransactionValue(msg.getSysFlag());
        if (tranType == MessageSysFlag.TRANSACTION_NOT_TYPE
            || tranType == MessageSysFlag.TRANSACTION_COMMIT_TYPE) {
            // 延迟级别大于0
            if (msg.getDelayTimeLevel() > 0) {
                // 如果延迟级别大于最大延迟级别，那就把延迟级别设置为最大延迟级别
                if (msg.getDelayTimeLevel() > this.defaultMessageStore.getScheduleMessageService().getMaxDelayLevel()) {
                    msg.setDelayTimeLevel(this.defaultMessageStore.getScheduleMessageService().getMaxDelayLevel());
                }
                // 延迟topicSCHEDULE_TOPIC_XXXX
                topic = TopicValidator.RMQ_SYS_SCHEDULE_TOPIC;
                // 根据延迟级别，获取队列id
                queueId = ScheduleMessageService.delayLevel2QueueId(msg.getDelayTimeLevel());

                // Backup real topic, queueId
                MessageAccessor.putProperty(msg, MessageConst.PROPERTY_REAL_TOPIC, msg.getTopic());
                MessageAccessor.putProperty(msg, MessageConst.PROPERTY_REAL_QUEUE_ID, String.valueOf(msg.getQueueId()));
                msg.setPropertiesString(MessageDecoder.messageProperties2String(msg.getProperties()));
                // 消息的topic设置为延迟topic，不是设置真正的topic
                msg.setTopic(topic);
                msg.setQueueId(queueId);
            }
        }

        省略部分封装msg的代码..
            //最后把msg追加到mappedFile上，mappedFile这个后续再讲，在这里你把它当做一个文件即可
            result = mappedFile.appendMessage(msg, this.appendMessageCallback);

kotlin复制代码public void start() {
        //通过AtomicBoolean 来确保 有且仅有一次执行start方法
        if (started.compareAndSet(false, true)) {
            this.timer = new Timer("ScheduleMessageTimerThread", true);
            // 遍历所有 延迟级别
            for (Map.Entry<Integer, Long> entry : this.delayLevelTable.entrySet()) {
                // key为延迟级别
                Integer level = entry.getKey();
                // value 为 毫秒数
                Long timeDelay = entry.getValue();
                // 根据延迟级别 ，获取对应的offset
                Long offset = this.offsetTable.get(level);
                //
                if (null == offset) {
                    offset = 0L;
                }
                // 为每个延迟级别创建定时任务，开始执行定时任务，1S后开始执行
                if (timeDelay != null) {
                    // 第二步：具体核心执行逻辑在DeliverDelayedMessageTimerTask-->executeOnTimeup()
                    this.timer.schedule(new DeliverDelayedMessageTimerTask(level, offset), FIRST_DELAY_TIME);
                }
            }
            // 延迟10秒后执行定时任务，flushDelayOffsetInterval=10s,周期也是10秒执行一次
            this.timer.scheduleAtFixedRate(new TimerTask() {

                @Override
                public void run() {
                    try {
                        //持久化每个队列的消费offset
                        if (started.get()) ScheduleMessageService.this.persist();
                    } catch (Throwable e) {
                        log.error("scheduleAtFixedRate flush exception", e);
                    }
                }
            }, 10000, this.defaultMessageStore.getMessageStoreConfig().getFlushDelayOffsetInterval());
        }
    }

ini复制代码public void executeOnTimeup() {
            //根据延迟级别和topic:RMQ_SYS_SCHEDULE_TOPIC = "SCHEDULE_TOPIC_XXXX";来找到对应的ConsumeQueue
            ConsumeQueue cq =
                ScheduleMessageService.this.defaultMessageStore.findConsumeQueue(TopicValidator.RMQ_SYS_SCHEDULE_TOPIC,
                    delayLevel2QueueId(delayLevel));
            // 消费偏移量
            long failScheduleOffset = offset;

            if (cq != null) {
                // 根据消费偏移量从消息队列中获取所有有效消息
                SelectMappedBufferResult bufferCQ = cq.getIndexBuffer(this.offset);
                if (bufferCQ != null) {
                    try {
                        long nextOffset = offset;
                        int i = 0;
                        ConsumeQueueExt.CqExtUnit cqExtUnit = new ConsumeQueueExt.CqExtUnit();
                        // 遍历所有消息
                        for (; i < bufferCQ.getSize(); i += ConsumeQueue.CQ_STORE_UNIT_SIZE) {
                            // 获取消息的物理偏移量
                            long offsetPy = bufferCQ.getByteBuffer().getLong();
                            // 获取消息的物理长度
                            int sizePy = bufferCQ.getByteBuffer().getInt();
                            long tagsCode = bufferCQ.getByteBuffer().getLong();

                          
                            //当前时间
                            long now = System.currentTimeMillis();
                            //消费时间
                            long deliverTimestamp = this.correctDeliverTimestamp(now, tagsCode);
                            //下一个偏移量
                            nextOffset = offset + (i / ConsumeQueue.CQ_STORE_UNIT_SIZE);
                            //如果消费时间<当前时间，说明应该被消费了
                            long countdown = deliverTimestamp - now;

                            if (countdown <= 0) {
                                //根据物理偏移量和长度，获取消息
                                MessageExt msgExt =
                                    ScheduleMessageService.this.defaultMessageStore.lookMessageByOffset(
                                        offsetPy, sizePy);

                                if (msgExt != null) {
                                    try {
                                        //构建真正 的消息
                                        MessageExtBrokerInner msgInner = this.messageTimeup(msgExt);
                                        
                                        // 重新把消息发送到真正的消息队列上
                                        PutMessageResult putMessageResult =
                                            ScheduleMessageService.this.writeMessageStore
                                                .putMessage(msgInner);
                                  ...省略一堆不太重要的代码
                                       }
            //这里又重新添加一个新的任务，这次是100毫秒
            ScheduleMessageService.this.timer.schedule(new DeliverDelayedMessageTimerTask(this.delayLevel,
                failScheduleOffset), DELAY_FOR_A_WHILE);
        }

java复制代码// 野怪投放【生产者】
public static class WildMonsterProducer implements Runnable {
  public void run() {
    try {
      createWildMonster();
    } catch (InterruptedException e) {
      System.out.println("野怪投放被中断");
    }
  }

  //投放野怪，每1秒检查一次
  public void createWildMonster() throws InterruptedException {
    for (int i = 0;; i++) {
      synchronized(wildMonsterArea) {
        if (wildMonsterArea.size() == 0) {
          wildMonsterArea.add("野怪" + i);
          System.out.println(wildMonsterArea.getLast());
          wildMonsterArea.notify();
        }
      }
      Thread.sleep(1000);
    }
  }
}

java复制代码// 兰陵王，打野英雄
public static class LanLingWang implements Runnable {
  public void run() {
    try {
      attackWildMonster();
    } catch (InterruptedException e) {
      System.out.println("兰陵王打野被中断");
    }
  }

  // 打野，如果没有则进行等待
  public void attackWildMonster() throws InterruptedException {
    while (true) {
      synchronized(wildMonsterArea) {
        if (wildMonsterArea.size() == 0) {
          wildMonsterArea.wait();
        }
        String wildMonster = wildMonsterArea.getLast();
        wildMonsterArea.remove(wildMonster);
        System.out.println("收获野怪：" + wildMonster);
      }
    }
  }
}

java复制代码public class ProducerConsumerProblemDemo {

    // 野怪活动的野区
    private static final LinkedList<String> wildMonsterArea = new LinkedList<String>();

    public static void main(String[] args) {
        Thread wildMonsterProducerThread = new Thread(new WildMonsterProducer());
        Thread lanLingWangThread = new Thread(new LanLingWang());

        wildMonsterProducerThread.start();
        lanLingWangThread.start();
    }
}

shell复制代码野怪0
收获野怪：野怪0
野怪1
收获野怪：野怪1
野怪2
收获野怪：野怪2
野怪3
收获野怪：野怪3
野怪4
收获野怪：野怪4
野怪5
收获野怪：野怪5
野怪6
收获野怪：野怪6

java复制代码.
|-- BOOT-INF
|   |-- classes
|   |   `-- com
|   |       `-- gang
|   |           `-- study
|   |               `-- maven
|   |                   |-- BootdependencyApplication.class
|   |                   `-- service
|   |                       `-- AopAdvice.class
|   `-- lib
|       |-- 省略 JAR
|-- META-INF
|   |-- MANIFEST.MF
|   `-- maven
|       `-- com.gang.study.maven.bootdependency
|           `-- com-gang-study-maven-bootdependency
|               |-- pom.properties
|               `-- pom.xml
`-- org
    `-- springframework
        `-- boot
            `-- loader
                |-- 省略 class

java复制代码// 规范的版本
Manifest-Version: 1.0
Archiver-Version: Plexus Archiver
// 多重发布 : 存在多个 JDK 版本    
Multi-Release: true
//创建清单文件的用户的名称    
Built-By: 10169
// SpringBoot 启动类
Start-Class: com.gang.study.maven.BootdependencyApplication
// SpringBoot 类路径
Spring-Boot-Classes: BOOT-INF/classes/
// Spring-Boot lib 文件路径
Spring-Boot-Lib: BOOT-INF/lib/
// Spring Boot 版本
Spring-Boot-Version: 2.2.6.RELEASE
// 创建清单文件的工具版本和供应商    
Created-By: Apache Maven 3.6.1
// 此自定义头给出创建清单文件的用户的名称    
Build-Jdk: 1.8.0_152
// Main 方法入口 , 这里更像一个加载器
Main-Class: org.springframework.boot.loader.JarLauncher
// 到库或资源的相对路径的空格分隔列表
Class-Path: core.jar lib/ properties/
    
    
//---------------- 其他的属性
Name: 包名
Implementation-Build-Date: 实施的构建日期
Implementation-Title: 执行的标题
Implementation-Vendor: 实施的供应商
Implementation-Version: 实施版本
Specification-Title: 规范的标题
Specification-Vendor: 规范的供应商
Specification-Version: 规格版本
Sealed: 那么包的所有类是否都来自同一个 JAR
    
    
// 一 : 格式
MANIFEST.MF 是一个标准的 key:value ( headers:attributes)
key1: value1
Key2: value2
// 有效的标题必须在冒号和值之间有空格。另一个重要的地方是在文件的末尾必须有一个新的行 (这个地方坑了很久 , 怎么都导不进去 , 需要换行才对) , 否则最后一行会被忽略

JAVA复制代码
// 当一个 JAR 文件被签名时，一个签名文件被自动生成并放置在 JAR 文件的 META-INF 目录中
// 这个目录包含了归档文件的清单 , 签名文件的文件名是.SF 扩展

Signature-Version: 1.0
SHA1-Digest-Manifest: h1yS+K9T7DyHtZrtI+LxvgqaMYM=
Created-By: 1.7.0_06 (Oracle Corporation)

Name: test/classes/ClassOne.class
SHA1-Digest: fcav7ShIG6i86xPepmitOVo4vWY=

Name: test/classes/ClassTwo.class
SHA1-Digest: xrQem9snnPhLySDiZyclMlsFdtM=

Name: test/images/ImageOne.gif
SHA1-Digest: kdHbE7kL9ZHLgK7akHttYV4XIa0=

Name: test/images/ImageTwo.gif
SHA1-Digest: mF0D5zpk68R4oaxEqoS9Q7nhm60=

java复制代码// JAR 命令获取 
打印出 jar 中所有的class名 : jar tf com-gang-bootdependency-1.0-SNAPSHOT.jar
打印所有的 class : jar tf com-gang-bootdependency-1.0-SNAPSHOT.jar | grep '\.class$'

// Java 代码获取    
public static Set<String> getClassNamesFromJarFile(File givenFile) throws IOException {
    Set<String> classNames = new HashSet<>();
    try (JarFile jarFile = new JarFile(givenFile)) {
        Enumeration<JarEntry> e = jarFile.entries();
        while (e.hasMoreElements()) {
            JarEntry jarEntry = e.nextElement();
            if (jarEntry.getName().endsWith(".class")) {
                String className = jarEntry.getName()
                  .replace("/", ".")
                  .replace(".class", "");
                classNames.add(className);
            }
        }
        return classNames;
    }
}

// 运行时动态获取
public static Set<Class> getClassesFromJarFile(File jarFile) throws IOException, ClassNotFoundException {
    Set<String> classNames = getClassNamesFromJarFile(jarFile);
    Set<Class> classes = new HashSet<>(classNames.size());
    try (URLClassLoader cl = URLClassLoader.newInstance(
           new URL[] { new URL("jar:file:" + jarFile + "!/") })) {
        for (String name : classNames) {
            Class clazz = cl.loadClass(name); // Load the class by its name
            classes.add(clazz);
        }
    }
    return classes;
}

java复制代码
// 方式一 : tree 命令可以用于 Windows 生成目录数 (PS : 应该是系统本身就有该命令)
打印到当前文件 : tree /f >tree.txt 

    
// 方式二 : tree for windows (PS : 这个和上面不是一个东西)
1. 下载 tree for windows 文件 : http://gnuwin32.sourceforge.net/packages/tree.htm  (选择 Binaries.zip) 
2. 解压获取 tree.exe , 放在 git 项目中 : Git\usr\bin (注意 , 外层的 bin , 需要到 usr 目录下)
3. 项目路径下反键 - git base here (即 git 控制台)    
4. 运行 tree 命令    
    
-A 使用ASNI绘图字符显示树状图而非以ASCII字符组合。
-C 在文件和目录清单加上色彩，便于区分各种类型。
-d 显示目录名称而非内容。
-D 列出文件或目录的更改时间。
-f 在每个文件或目录之前，显示完整的相对路径名称。
-F 在执行文件，目录，Socket，符号连接，管道名称名称，各自加上"*","/","=","@","|“号。
-g 列出文件或目录的所属群组名称，没有对应的名称时，则显示群组识别码。
-i 不以阶梯状列出文件或目录名称。
-I 不显示符合范本样式的文件或目录名称。
-l 如遇到性质为符号连接的目录，直接列出该连接所指向的原始目录。
-n 不在文件和目录清单加上色彩。
-N 直接列出文件和目录名称，包括控制字符。
-p 列出权限标示。
-P 只显示符合范本样式的文件或目录名称。
-q 用”?"号取代控制字符，列出文件和目录名称。
-s 列出文件或目录大小。
-t 用文件和目录的更改时间排序。
-u 列出文件或目录的拥有者名称，没有对应的名称时，则显示用户识别码。
-x 将范围局限在现行的文件系统中，若指定目录下的某些子目录，其存放于另一个文件系统上，则将该子目录予以排除在寻找范围外。
    
    
$ tree
.
|-- classes
|   `-- com
|       `-- gang
|           `-- study

    
// 方式三 : 在线 tree 转换
http://dir.yardtea.cc/

// 方式四 : 使用软件显示如上图所示的数结构
下载软件 DirPrintOK

java复制代码// 方案一 :  工具查看

1. ZIP 解压后 , 直接通过 Java Decompiler 查看
	?- 该方案对于部分 class 有局限性 , 看出来的如下所示 : // INTERNAL ERROR //
2. JD Project : 最常用的最好的 java 脱机反编译器之一
3. Cavaj Java Decompiler 
4. DJ Java Decompiler
5. JBVD 
6. androidchef 
7. Procyon 
8. CFR Decompiler
9. FernFlower
10. Krakatau
11. Luyten
    
// 编译器大同小异 , 无非就是转码 , 以上任意一种都可以试着用一下 , 一般我自己使用 JD-GUI / Jar Explorer
https://java-decompiler.github.io/
    

// 方案二 : 命令行反编译
java -jar JDCommandLine.jar ${TARGET_JAR_NAME}.jar ./classes

java复制代码<dependency>
	<groupId>com.yworks</groupId>
	<artifactId>yguard</artifactId>
	<version>3.0.0</version>
	<scope>compile</scope>
</dependency>

<!-- 配置规则详见官方文档 -->  
<plugin>
	<artifactId>maven-antrun-plugin</artifactId>
	<version>1.8</version>
	<executions>
		<execution>
            <phase>package</phase>
            <goals>
                <goal>run</goal>
            </goals>
            <id>obfuscate</id>
            <configuration>
                <tasks>
                    <property name="runtime_classpath" refid="maven.runtime.classpath"/>
                    <taskdef name="yguard" classname="com.yworks.yguard.YGuardTask" />
                    <yguard>
						<!-- see the yGuard task documentation for information about the <yguard> element-->
                    </yguard>
                </tasks>
            </configuration>
		</execution>
	</executions>
</plugin>

xml复制代码<!-- Maven pom.xml 文件构建 jar-->
<modelVersion>4.0.0</modelVersion>
<version>0.1.0-SNAPSHOT</version>
<packaging>jar</packaging>
    
<!-- Plugin  Java-->
<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-jar-plugin</artifactId>
    <configuration>
        <archive>
            <manifest>
                <addClasspath>true</addClasspath>
                <classpathPrefix>libs/</classpathPrefix>
                <mainClass>
                    com.baeldung.executable.ExecutableMavenJar
                </mainClass>
            </manifest>
        </archive>
    </configuration>
</plugin>    
    
    
<!--  Plugin Spring -->
<plugin>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-maven-plugin</artifactId>
    <executions>
        <execution>
            <goals>
                <goal>repackage</goal>
            </goals>
            <configuration>
                <classifier>spring-boot</classifier>
                <mainClass>
                  com.baeldung.executable.ExecutableMavenJar
                </mainClass>
            </configuration>
        </execution>
    </executions>
</plugin>
    
<!-- 通常也可以直接使用 -->
<plugin>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-maven-plugin</artifactId>
</plugin>

java复制代码

jar uf JarExample.jar com/baeldung/jar/JarExample.class
    
    
// 案例 : 需要替换 parent.jar 内部的 child-1.3.4.jar 依赖

// Step 1 : 准备好相关的路径 (例如需要放在该路径下 , 先在外部创建一个相同的路径)
构建目录 ： \new_version\BOOT-INF\classes\bundles
    
// Step 2 : 将 bundles jar 移动到 该路径
    
// Step 3 : 执行命令执行
jar -uvf0 parent.jar BOOT-INF/classes/bundles/child-1.3.4.jar

java复制代码// Step 1 : 准备一个 .java 方法
public class DefaultMain {
    public static void main(String[] args){
        System.out.println("Test Default Main Success!");
    }
}

// Step 2 : 打包为 .class 文件 (运行后生成一个 DefaultMain.class)
javac -d . DefaultMain.java
    
    
// Step 3 : (此处可以省略 , 参考后文设置清单文件)
    
// Step 4 : 打包到 JAR 文件中 (运行后生成一个 example.jar)
jar cfe example.jar com/gang/DefaultMain com/gang/DefaultMain.class
    
// Step 5 : 执行 jar
java -jar example.jar    
    
    
// 附录 : JAR 包结构
.
|-- META-INF
|   `-- MANIFEST.MF
|-- com
|   `-- gang
|       `-- DefaultMain.class
`-- tree.txt

3 directories, 3 files

xml复制代码<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-jar-plugin</artifactId>
    <version>3.1.2</version>
    <configuration>
        <archive>
            <manifest>
                <packageName>com.baeldung.java</packageName>
            </manifest>
            <manifestEntries>
                <Created-By>baeldung</Created-By>
            </manifestEntries>
        </archive>
    </configuration>
</plugin>

java复制代码// Step 1 : 准备一个任意的文本文件 , 添加属性(记得回车)
Built-By: gang

// Step 2 : 使用命令打包
jar cvfm example.jar manifest.txt com/gang/DefaultMain.class    
    
../test>jar cvfm example.jar manifest.txt com/gang/DefaultMain.class
已添加清单
正在添加: com/gang/DefaultMain.class(输入 = 442) (输出 = 299)(压缩了 32%)
    
// 解压后最终结果 :
Manifest-Version: 1.0
Built-By: gang
Created-By: 1.8.0_152 (Oracle Corporation)

xml复制代码├── pom.xml
├── src
│   ├── main
│   │   ├── java
│   │   │   └── com
│   │   │       └── gang
│   │   │           └── test
│   │   │               ├── DefaultVersion.java
│   │   │               └── App.java
│   │   └── java9
│   │       └── com
│   │           └── gang
│   │               └── test
│   │                   └── DefaultVersion.java
    


<!-- Step 1  : 通过 Maven 构建 -->
<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <executions>
                <execution>
                    <id>compile-java-8</id>
                    <goals>
                        <goal>compile</goal>
                    </goals>
                    <configuration>
                        <source>1.8</source>
                        <target>1.8</target>
                    </configuration>
                </execution>
                <execution>
                    <id>compile-java-9</id>
                    <phase>compile</phase>
                    <goals>
                        <goal>compile</goal>
                    </goals>
                    <configuration>
                        <release>9</release>
                        <compileSourceRoots>
                            <compileSourceRoot>${project.basedir}/src/main/java9</compileSourceRoot>
                        </compileSourceRoots>
    				   <!-- > 3.7.1 时替换下句 :  <multiReleaseOutput>true</multiReleaseOutput> -->
                        <outputDirectory>${project.build.outputDirectory}/META-INF/versions/9</outputDirectory>
                    </configuration>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>
    
<!-- Step 2 :  MANIFEST 文件中将 Multi-Release 条目设置为 true  -->
<!--使用这种配置，Java 运行时将在 JAR 文件的 META-INF/versions 文件夹中查找特定于版本的类; 否则，只使用基类-->

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-jar-plugin</artifactId>
    <version>3.2.0</version>
    <configuration>
        <archive>
            <manifestEntries>
                <Multi-Release>true</Multi-Release>
            </manifestEntries>
        </archive>
    </configuration>
</plugin>

xml复制代码 

    

    
<plugin> 
  <groupId>org.apache.maven.plugins</groupId>  
  <artifactId>maven-assembly-plugin</artifactId>  
  <executions> 
    <execution> 
      <id>source-release-assembly</id>  
      <phase>none</phase> 
    </execution>  
    <execution> 
      <id>source-release-assembly-no-eclipse-libs</id>  
      <phase>package</phase>  
      <goals> 
        <goal>single</goal> 
      </goals>  
      <configuration> 
        <runOnlyAtExecutionRoot>true</runOnlyAtExecutionRoot>  
        <descriptors> 
          <descriptor>src/assemble/${sourceReleaseAssemblyDescriptor}.xml</descriptor> 
        </descriptors>  
        <tarLongFileMode>gnu</tarLongFileMode> 
      </configuration> 
    </execution> 
  </executions> 
</plugin> 
    

<properties>
    <start-class>org.baeldung.boot.Application</start-class>
</properties>

java复制代码jar cfe example.jar com.gang.DefaultMain com/gang/*.class

// 生成的 MANIFEST 文件
Manifest-Version: 1.0
Created-By: 1.8.0_152 (Oracle Corporation)
Main-Class: com.gang.DefaultMain

JAVA复制代码java -jar test.jar

java复制代码// 提取 JAR 内容
jar xf jar-file [archived-file(s)]

// 查看 JAR 内容
jar tf jar-file

// 更新 JAR 内容
jar uf jar-file input-file(s)

java复制代码// 命令行修改清单文件
jar cfm jar-file manifest-addition input-file(s)

// 设置默认入口
jar cfm MyJar.jar Manifest.txt MyPackage/*.class

// 添加 class
jar cfm MyJar.jar Manifest.txt MyPackage/*.class

java复制代码// 指定主类 : 
> java -cp JarExample.jar com.baeldung.jar.JarExample
> java -cp JarExample.jar com/baeldung/jar/JarExample
    
// 列出 Jar 的内容 : 
> jar tf JarExample.jar
    
// 查看清单文件
> unzip -p JarExample.jar META-INF/MANIFEST.MF

java复制代码// WAR 包格式
META-INF/
    MANIFEST.MF
WEB-INF/
    web.xml
    jsp/
        helloWorld.jsp
    classes/
        static/
        templates/
        application.properties
    lib/
        // *.jar files as libs

JAVA复制代码example.jar
 |
 +-META-INF
 |  +-MANIFEST.MF
 +-org
 |  +-springframework
 |     +-boot
 |        +-loader
 |           +-<spring boot loader classes>
 +-BOOT-INF
    +-classes
    |  +-mycompany
    |     +-project
    |        +-YourClasses.class
    +-lib
       +-dependency1.jar
       +-dependency2.jar

// SpringBoot 对于 War 包的目录格式 (依赖项应该放在嵌套的 WEB-INF/lib 目录中) :
example.war
 |
 +-META-INF
 |  +-MANIFEST.MF
 +-org
 |  +-springframework
 |     +-boot
 |        +-loader
 |           +-<spring boot loader classes>
 +-WEB-INF
    +-classes
    |  +-com
    |     +-mycompany
    |        +-project
    |           +-YourClasses.class
    +-lib
    |  +-dependency1.jar
    |  +-dependency2.jar
    +-lib-provided
       +-servlet-api.jar
       +-dependency3.jar

JAVA复制代码// classpath.idx
- "BOOT-INF/lib/dependency2.jar"
- "BOOT-INF/lib/dependency1.jar"

// layers.idx
- "dependencies":
  - "BOOT-INF/lib/dependency1.jar"
  - "BOOT-INF/lib/dependency2.jar"
- "application":
  - "BOOT-INF/classes/"
  - "META-INF/"

java复制代码myapp.jar
+-------------------+-------------------------+
| /BOOT-INF/classes | /BOOT-INF/lib/mylib.jar |
|+-----------------+||+-----------+----------+|
||     A.class      |||  B.class  |  C.class ||
|+-----------------+||+-----------+----------+|
+-------------------+-------------------------+
 ^                    ^           ^
 0063                 3452        3980
 
// 可以看到 :  
1. 在 myapp.jar 的位置0063的/BOOT-INF/classes 中找到 A.class
2. 在 myapp.jar 中位于3452的位置找到来自嵌套 jar 的 B.class
3. C.class 位于3980的位置

java复制代码// 配置方式 :
Main-Class: org.springframework.boot.loader.WarLauncher
Start-Class: com.mycompany.project.MyApplication

java复制代码 public static void main(String[] args) {
        Thread neZhaThread = new Thread() {
            public void run() {
                throw new RuntimeException("我是哪吒，我被围攻了！");
            }
        };
        // 尝试捕获线程抛出的异常
        try {
            neZhaThread.start();
        } catch (Exception e) {
            System.out.println("接收英雄异常：" + e.getMessage());
        }
    }

shell复制代码Exception in thread "Thread-0" java.lang.RuntimeException: 我是哪吒，我被围攻了！
	at cn.tao.king.juc.execises1.ExceptionDemo$1.run(ExceptionDemo.java:7)

Process finished with exit code 0

java复制代码 public static void main(String[] args) {
        throw new NullPointerException();
    }

shell复制代码Exception in thread "main" java.lang.NullPointerException
	at cn.tao.king.juc.execises1.ExceptionDemo.main(ExceptionDemo.java:21)

java复制代码 public static void main(String[] args) {
        Thread.setDefaultUncaughtExceptionHandler(new MyUncaughtExceptionHandler());
        throw new NullPointerException();
    }

    // 自定义错误处理
    static class MyUncaughtExceptionHandler implements Thread.UncaughtExceptionHandler {
        public void uncaughtException(Thread t, Throwable e) {
            System.out.println("出错了！线程名：" + t.getName() + "，错误信息：" + e.getMessage());
        }
    }

shell复制代码出错了！线程名：main，错误信息：null

Process finished with exit code 1

java复制代码neZhaThread.setName("哪吒");
neZhaThread.setUncaughtExceptionHandler(new MyUncaughtExceptionHandler());

shell复制代码出错了！线程名：哪吒，错误信息：我是哪吒，我被围攻了！

Process finished with exit code 0

java复制代码 Thread.setDefaultUncaughtExceptionHandler(new MyUncaughtExceptionHandler());

java复制代码neZhaThread.setUncaughtExceptionHandler(new MyUncaughtExceptionHandler());

java复制代码public class MyThreadGroupDemo  extends ThreadGroup{
    public MyThreadGroupDemo(String name) {
        super(name);
    }

    @Override
    public void uncaughtException(Thread t, Throwable e) {
        // 在这里重写线程组的异常处理逻辑
        System.out.println("出错了！线程名：" + t.getName() + "，错误信息：" + e.getMessage());
    }
}