java复制代码new Thread(() -> {
  // 休眠十五分钟，执行取消订单
  Thread.sleep(15 * 60 * 1000);
  cancelOrder(); 
}).start();

xml复制代码<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

<!-- 下面这里两个非必须，主要是后面的实现演示使用到了 -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
</dependency>
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
</dependency>

java复制代码private static final Long DELETE_SUCCESS = 1L;
@Autowired
private StringRedisTemplate redisTemplate;

public String fetchOne(String key) {
    Set<String> sets = redisTemplate.opsForZSet().rangeByScore(key, 0, System.currentTimeMillis(), 0, 3);
    if (CollectionUtils.isEmpty(sets)) {
        return null;
    }

    for (String val : sets) {
        if (DELETE_SUCCESS.equals(redisTemplate.opsForZSet().remove(key, val))) {
            // 删除成功，表示抢占到
            return val;
        }
    }
    return null;
}

java复制代码@Component
public class RedisDelayListWrapper implements ApplicationContextAware {
    private static final Long DELETE_SUCCESS = 1L;
 
    private Set<String> topic = new CopyOnWriteArraySet<>();

    public void publish(String key, Object val, long delayTime) {
        topic.add(key);
        String strVal = val instanceof String ? (String) val : JSONObject.toJSONString(val);

        redisTemplate.opsForZSet().add(key, strVal, System.currentTimeMillis() + delayTime);
    }
}

java复制代码@Scheduled(fixedRate = 10_000)
public void schedule() {
    for (String specialTopic : topic) {
        String cell = fetchOne(specialTopic);
        if (cell != null) {
            applicationContext.publishEvent(new DelayMsg(this, cell, specialTopic));
        }
    }
}

@ToString
public static class DelayMsg extends ApplicationEvent {
    @Getter
    private String msg;
    @Getter
    private String topic;

    public DelayMsg(Object source, String msg, String topic) {
        super(source);
        this.msg = msg;
        this.topic = topic;
    }
}

java复制代码@Target({ElementType.METHOD, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@EventListener
public @interface Consumer {
    String topic();
}

java复制代码@Aspect
@Component
public class ConsumerAspect {

    @Around("@annotation(consumer)")
    public Object around(ProceedingJoinPoint joinPoint, Consumer consumer) throws Throwable {
        Object[] args = joinPoint.getArgs();
        boolean check = false;
        for (Object obj : args) {
            if (obj instanceof RedisDelayListWrapper.DelayMsg) {
                check = consumer.topic().equals(((RedisDelayListWrapper.DelayMsg) obj).getTopic());
            }
        }

        if (!check) {
            // 不满足条件，直接忽略
            return null;
        }

        // topic匹配成功，执行
        return joinPoint.proceed();
    }
}

java复制代码@EnableScheduling
@RestController
@SpringBootApplication
public class Application {
    private static final String TEST_DELAY_QUEUE = "test";
    private static final String DEMO_DELAY_QUEUE = "demo";
    @Autowired
    private RedisDelayListWrapper redisDelayListWrapper;

    private Random random = new Random();

    public static void main(String[] args) {
        SpringApplication.run(Application.class);
    }

    @GetMapping(path = "publish")
    public String publish(String msg, Long delayTime) {
        if (delayTime == null) {
            delayTime = 10_000L;
        }

        String queue = random.nextBoolean() ? TEST_DELAY_QUEUE : DEMO_DELAY_QUEUE;
        msg = queue + "#" + msg + "#" + (System.currentTimeMillis() + delayTime);
        redisDelayListWrapper.publish(queue, msg, delayTime);
        System.out.println("延时: " + delayTime + "ms后消费: " + msg + " now:" + LocalDateTime.now());
        return "success!";
    }


    @Consumer(topic = TEST_DELAY_QUEUE)
    public void consumer(RedisDelayListWrapper.DelayMsg delayMsg) {
        System.out.println("TEST消费延时消息: " + delayMsg + " at:" + System.currentTimeMillis());
    }

    @Consumer(topic = DEMO_DELAY_QUEUE)
    public void consumerDemo(RedisDelayListWrapper.DelayMsg delayMsg) {
        System.out.println("DEMO消费延时消息: " + delayMsg + " at:" + System.currentTimeMillis());
    }
}

python复制代码import requests
import re
from selenium import webdriver
import time
from contextlib import closing


def get_home_ulrs(url):
    browser = webdriver.Chrome();
    browser.get(url)
    num = browser.find_element_by_xpath(
        '//*[@id="root"]/div/div[2]/div/div[4]/div[1]/div[1]/div[1]/span').text
    num = int(int(num)/15)+1
    urls = []
    for i in range(num):
        newList = re.findall('https\:\/\/www\.douyin\.com\/video\/[\d]*\?previous_page\=', browser.page_source)
        urls = [*urls,*newList]
        browser.execute_script('window.scrollTo(0, document.body.scrollHeight)')
        time.sleep(2)
    print(urls)
    print(set(urls))
    mainList =set(urls)
    browser.close()
    return mainList

def get_video(url):
    browser = webdriver.Chrome();
    browser.get(url)
    html = browser.find_element_by_xpath(
        '//*[@id="root"]/div/div[2]/div[1]/div[1]/div[1]/div[1]/div/div[1]/div[2]/video/source[1]')
    video_url = html.get_attribute('src')
    browser.close()
    return video_url


def download(url, name):
    with closing(requests.get(url=url, verify=False, stream=True)) as res:
        with open('video/{}.mp4'.format(name), 'wb') as fd:
            for chunk in res.iter_content(chunk_size=1024):
                if chunk:
                    fd.write(chunk)

if __name__ == '__main__':
    url = input('请输入个人主页地址')
    print('正在获取视频地址')
    urls = get_home_ulrs(url)
    print(urls)
    print('成功获取{}个,开始下载'.format(len(urls)))
    index = 1
    for url in urls:
        video_url = get_video(url)
        print('正在下载{}/{}'.format(len(urls),index))
        download(video_url, index)
        print('下载完成')
        index += 1

java复制代码    public final SelectionKey register(Selector sel, int ops)
        throws ClosedChannelException
    {
        return register(sel, ops, null);
    }
    
    public abstract SelectionKey register(Selector sel, int ops, Object att) throws ClosedChannelException;

java复制代码 // 1.创建通道管理器(Selector)
 Selector selector = Selector.open();
 
 // 2.创建通道ServerSocketChannel
 ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
 
 // 3.channel要注册到Selector上就必须是非阻塞的，所以FileChannel是不可以使用Selector的，因为FileChannel是阻塞的
 serverSocketChannel.configureBlocking(false);
 
 // 4.第二个参数指定了我们对 Channel 的什么类型的事件感兴趣
 SelectionKey key = serverSocketChannel.register(selector , SelectionKey.OP_READ);
 
 // 也可以使用或运算|来组合多个事件，例如
 SelectionKey key = serverSocketChannel.register(selector , SelectionKey.OP_READ | SelectionKey.OP_WRITE);

java复制代码// 当注册事件到达时，方法返回，否则该方法会一直阻塞
selector.select();

java复制代码// 返回当前感兴趣的事件列表
int interestSet = key.interestOps();

// 也可通过interestSet判断其中包含的事件
boolean isInterestedInAccept  = interestSet & SelectionKey.OP_ACCEPT;
boolean isInterestedInConnect = interestSet & SelectionKey.OP_CONNECT;
boolean isInterestedInRead    = interestSet & SelectionKey.OP_READ;
boolean isInterestedInWrite   = interestSet & SelectionKey.OP_WRITE;    

// 可以通过interestOps(int ops)方法修改事件列表
key.interestOps(interestSet | SelectionKey.OP_WRITE);

java复制代码int readySet = key.readyOps();

// 也可通过四个方法来分别判断不同事件是否就绪
key.isReadable();    //读事件是否就绪
key.isWritable();    //写事件是否就绪
key.isConnectable(); //客户端连接事件是否就绪
key.isAcceptable();  //服务端连接事件是否就绪

java复制代码//返回当前事件关联的通道，可转换的选项包括:`ServerSocketChannel`和`SocketChannel`
Channel channel = key.channel();

//返回当前事件所关联的Selector对象
Selector selector = key.selector();

java复制代码key.attach(theObject);
Object attachedObj = key.attachment();

java复制代码SelectionKey key = channel.register(selector, SelectionKey.OP_READ, theObject);

java复制代码Set<SelectionKey> selectionKeys = selector.selectedKeys();

java复制代码// 获取监听事件
Set<SelectionKey> selectionKeys = selector.selectedKeys();
Iterator<SelectionKey> iterator = selectionKeys.iterator();
// 迭代处理
while (iterator.hasNext()) {
    // 获取事件
    SelectionKey key = iterator.next();
    // 移除事件，避免重复处理
    iterator.remove();
    // 可连接
    if (key.isAcceptable()) {
        ...
    } 
    // 可读
    if (key.isReadable()) {
        ...
    }
    //可写
    if(key.isWritable()){
    	...                
    }
}

java复制代码public class NettyServerHandler extends ChannelInboundHandlerAdapter {

    //读取数据实际(这里我们可以读取客户端发送的消息)
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        System.out.println("server ctx =" + ctx);
        Channel channel = ctx.channel();
        //将 msg 转成一个 ByteBuf
        //ByteBuf 是 Netty 提供的，不是 NIO 的 ByteBuffer.
        ByteBuf buf = (ByteBuf) msg;
        System.out.println("客户端发送消息是:" + buf.toString(CharsetUtil.UTF_8));
        System.out.println("客户端地址:" + channel.remoteAddress());
    }


    //处理异常, 一般是需要关闭通道
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        ctx.close();
    }
}

java复制代码    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        ChannelFuture future = ctx.channel().close();
        future.addListener(new ChannelFutureListener() {
            @Override
            public void operationComplete(ChannelFuture channelFuture) throws Exception {
                //..
            }
        });
    }

java复制代码public class MyInboundHandler extends ChannelInboundHandlerAdapter {

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("Connected!");
        ctx.fireChannelActive();
    }
}

public class MyOutboundHandler extends ChannelOutboundHandlerAdapter {

    @Override
    public void close(ChannelHandlerContext ctx, ChannelPromise promise) throws Exception {
        System.out.println("Closing...");
        ctx.close(promise);
    }
}

java复制代码@Configuration
@ConditionalOnProperty(prefix = "module.wx-login", value = "enable", havingValue = "true")
@ComponentScan(basePackages = "com.lin.decorator.wxlogin")
public class WxLoginConfiguration {
}

java复制代码@Import(WxLoginConfiguration.class)
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

java复制代码@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(TransactionManagementConfigurationSelector.class)
public @interface EnableTransactionManagement {
   boolean proxyTargetClass() default false;
   AdviceMode mode() default AdviceMode.PROXY;
   int order() default Ordered.LOWEST_PRECEDENCE;
}

java复制代码protected String[] selectImports(AdviceMode adviceMode) {
    switch (adviceMode) {
        case PROXY:
            return new String[] {AutoProxyRegistrar.class.getName(),
               ProxyTransactionManagementConfiguration.class.getName()};
      case ASPECTJ:
          return new String[] {determineTransactionAspectClass()};
      default:
          return null;
    }
}

java复制代码@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@Import(MapperScannerRegistrar.class)
@Repeatable(MapperScans.class)
public @interface MapperScan {
}

java复制代码@org.springframework.context.annotation.Configuration
@Import(AutoConfiguredMapperScannerRegistrar.class)
@ConditionalOnMissingBean({ MapperFactoryBean.class, MapperScannerConfigurer.class })
public static class MapperScannerRegistrarNotFoundConfiguration implements InitializingBean {
    @Override
    public void afterPropertiesSet() {
      logger.debug(
          "Not found configuration for registering mapper bean using @MapperScan," +
           "MapperFactoryBean and MapperScannerConfigurer.");
    }
  }

java复制代码private void collectImports(SourceClass sourceClass, Set<SourceClass> imports, Set<SourceClass> visited)
         throws IOException {

    if (visited.add(sourceClass)) {
        for (SourceClass annotation : sourceClass.getAnnotations()) {
            String annName = annotation.getMetadata().getClassName();
            if (!annName.equals(Import.class.getName())) {
                collectImports(annotation, imports, visited);
            }
        }
        imports.addAll(sourceClass.getAnnotationAttributes(Import.class.getName(), "value"));
    }
}

java复制代码private void processImports(ConfigurationClass configClass, SourceClass currentSourceClass,
         Collection<SourceClass> importCandidates, Predicate<String> exclusionFilter,
         boolean checkForCircularImports) {

      if (importCandidates.isEmpty()) {
         return;
      }

      if (checkForCircularImports && isChainedImportOnStack(configClass)) {
         this.problemReporter.error(new CircularImportProblem(configClass, this.importStack));
      }
      else {
         this.importStack.push(configClass);
         try {
            for (SourceClass candidate : importCandidates) {
               if (candidate.isAssignable(ImportSelector.class)) {
                  // Candidate class is an ImportSelector -> delegate to it to determine imports
                  Class<?> candidateClass = candidate.loadClass();
                  ImportSelector selector = ParserStrategyUtils.instantiateClass(candidateClass, ImportSelector.class,
                        this.environment, this.resourceLoader, this.registry);
                  Predicate<String> selectorFilter = selector.getExclusionFilter();
                  if (selectorFilter != null) {
                     exclusionFilter = exclusionFilter.or(selectorFilter);
                  }
                  if (selector instanceof DeferredImportSelector) {
                     this.deferredImportSelectorHandler.handle(configClass, (DeferredImportSelector) selector);
                  }
                  else {
                     String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata());
                     Collection<SourceClass> importSourceClasses = asSourceClasses(importClassNames, exclusionFilter);
                     processImports(configClass, currentSourceClass, importSourceClasses, exclusionFilter, false);
                  }
               }
               else if (candidate.isAssignable(ImportBeanDefinitionRegistrar.class)) {
                  // Candidate class is an ImportBeanDefinitionRegistrar ->
                  // delegate to it to register additional bean definitions
                  Class<?> candidateClass = candidate.loadClass();
                  ImportBeanDefinitionRegistrar registrar =
                        ParserStrategyUtils.instantiateClass(candidateClass, ImportBeanDefinitionRegistrar.class,
                              this.environment, this.resourceLoader, this.registry);
                  configClass.addImportBeanDefinitionRegistrar(registrar, currentSourceClass.getMetadata());
               }
               else {
                  // Candidate class not an ImportSelector or ImportBeanDefinitionRegistrar ->
                  // process it as an @Configuration class
                  this.importStack.registerImport(
                        currentSourceClass.getMetadata(), candidate.getMetadata().getClassName());
                  processConfigurationClass(candidate.asConfigClass(configClass), exclusionFilter);
               }
            }
         }
         catch (BeanDefinitionStoreException ex) {
            throw ex;
         }
         catch (Throwable ex) {
            throw new BeanDefinitionStoreException(
                  "Failed to process import candidates for configuration class [" +
                  configClass.getMetadata().getClassName() + "]", ex);
         }
         finally {
            this.importStack.pop();
         }
      }
   }

复制代码这样递归调用，就实现了资源的加载。

复制代码

java复制代码   public void heapSort(int[] arr) {
        //首先我们假设依次把数组中的数加入堆中，以此方法来构建堆结构
        for (int i = 1; i < arr.length; i++) {
            heapInsert(arr, i);
        }
//        for (int i = arr.length - 1; i >= 0; i++) {  //这种调整成堆的时间复杂度O(N)
//            heapify(arr, i, arr.length);
//        }
        for (int i = arr.length - 1; i >= 0; i--) { //这个是O(N * logN)级别的
            swap(arr, i, 0);
            heapify(arr, 0, i);
        }
    }

    public void heapInsert(int[] arr, int index) {
        //在数组尾部插入
        //和父节点比较，一步一步向上走
        while (arr[index] > arr[(index - 1) / 2]) {
            swap(arr, index, (index - 1) / 2);
            index = (index - 1) / 2;
        }
    }

    //size表示当前堆的大小
    public void heapify(int[] arr, int index, int size) { //这个是调整成大根堆结构的过程
        //index表示从哪个下标开始调整
        int left = index * 2 + 1;
        while (left < size) { //表示存在左子节点
            int largestIndex = index * 2 + 2 < size && arr[left + 1] > arr[left] ? left + 1 : left;
            largestIndex = arr[largestIndex] > arr[index] ? largestIndex : index;
            if (largestIndex == index) break;
            swap(arr, largestIndex, index);
            index = largestIndex;  //需要调整的节点移动到被交换值的子节点的位置
            left = index * 2 + 1;//这个时候left就是子节点的left了
        }
    }

    public void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

java复制代码public void sortArrayDistanceLessK(int[] arr, int k) {
        PriorityQueue<Integer> heap = new PriorityQueue<>();
        int i = 0;
        for (; i < k; i++) {  //先向小根堆中添加k个数
            heap.add(arr[i]);
        }
        for (; i < arr.length; i++) {
            heap.add(arr[i]);
            arr[i - k] = heap.poll();

        }
        while (!heap.isEmpty()) {
            arr[i - k] = heap.poll();
            i++;
        }

    }

java复制代码        for (int i = arr.length - 1; i >= 0; i--) { //这个是O(N * logN)级别的
            swap(arr, i, 0);
            heapify(arr, 0, i);
        }

java复制代码// 之前我们就了解到 , Dubbo 通过 PostProcessor 在初始化中做二次处理 , Dubbo 中主要有以下 PostProcessor

// Dubbo 自动配置类
C- DubboAutoConfiguration
    
// 使用AbstractConfig#getId()设置Dubbo Config bean别名的后处理器类
C- DubboConfigAliasPostProcessor
    
// 一个BeanFactoryPostProcessor，用于处理java配置类中的@Service注释类和注释bean
// 它也是dubbbo:annotation上的XML BeanDefinitionParser的基础结构类
C- ServiceAnnotationPostProcessor
    
// 注册一些不存在的基础结构bean
C- DubboInfraBeanRegisterPostProcessor

java复制代码@DubboService
public class DemoServiceImpl implements DemoService {
    private static final Logger logger = LoggerFactory.getLogger(DemoServiceImpl.class);

    @Override
    public String sayHello(String name) {
        logger.info("Hello " + name + ", request from consumer: " + RpcContext.getServiceContext().getRemoteAddress());
        return "Hello " + name + ", response from provider: " + RpcContext.getServiceContext().getLocalAddress();
    }

    @Override
    public CompletableFuture<String> sayHelloAsync(String name) {
        return null;
    }

}

JAVA复制代码// 发起扫描  C- ServiceAnnotationPostProcessor
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
	this.registry = registry;
	
        //  Step 1 : 获得扫描的 Package 路径
	Set<String> resolvedPackagesToScan = resolvePackagesToScan(packagesToScan);

	if (!CollectionUtils.isEmpty(resolvedPackagesToScan)) {
             // Step 2 : 扫描 路径下的 Service
            scanServiceBeans(resolvedPackagesToScan, registry);
	} else {
	}
}

java复制代码// Step 2-1 : 扫描 Bean
private void scanServiceBeans(Set<String> packagesToScan, BeanDefinitionRegistry registry) {

    // PRO0001
    DubboClassPathBeanDefinitionScanner scanner =
            new DubboClassPathBeanDefinitionScanner(registry, environment, resourceLoader);

    // PRO0002
    BeanNameGenerator beanNameGenerator = resolveBeanNameGenerator(registry);
    scanner.setBeanNameGenerator(beanNameGenerator);
    
    // PRO0003
    for (Class<? extends Annotation> annotationType : serviceAnnotationTypes) {
        scanner.addIncludeFilter(new AnnotationTypeFilter(annotationType));
    }

    ScanExcludeFilter scanExcludeFilter = new ScanExcludeFilter();
    scanner.addExcludeFilter(scanExcludeFilter);

    for (String packageToScan : packagesToScan) {

        // 避免重复扫描 -> PRO0004
        if (servicePackagesHolder.isPackageScanned(packageToScan)) {
            continue;
        }

        // 扫描所有的 @Service 注解 (Spring) ? 
        scanner.scan(packageToScan);

        // Finds all BeanDefinitionHolders of @Service whether @ComponentScan scans or not.
        Set<BeanDefinitionHolder> beanDefinitionHolders =
                findServiceBeanDefinitionHolders(scanner, packageToScan, registry, beanNameGenerator);

        if (!CollectionUtils.isEmpty(beanDefinitionHolders)) {
            // 此处的 serviceClasses 主要是为了 log 处理 , 打印详细的 Service
            // PS : 意味着此处可以通过配置该属性打印详细的 Service 类
            if (logger.isInfoEnabled()) {
                List<String> serviceClasses = new ArrayList<>(beanDefinitionHolders.size());
                for (BeanDefinitionHolder beanDefinitionHolder : beanDefinitionHolders) {
                    serviceClasses.add(beanDefinitionHolder.getBeanDefinition().getBeanClassName());
                }
            }
		  
            for (BeanDefinitionHolder beanDefinitionHolder : beanDefinitionHolders) {
                // -> 2.4 BeanDefinition 的处理
                processScannedBeanDefinition(beanDefinitionHolder, registry, scanner);
                // 添加以及加载的 Bean
                servicePackagesHolder.addScannedClass(beanDefinitionHolder.getBeanDefinition().getBeanClassName());
            }
        } else {
 
        }
		// 添加扫描的 package
        servicePackagesHolder.addScannedPackage(packageToScan);
    }
}

java复制代码
核心 : DubboClassPathBeanDefinitionScanner 继承于 ClassPathBeanDefinitionScanner , 在这个基础上添加了属性 :
private final ConcurrentMap<String, Set<BeanDefinition>> beanDefinitionMap = new ConcurrentHashMap<>();

在调用父类 findCandidateComponents 的时候 , 会缓存在该类中
    
目的 :

java复制代码String CONFIGURATION_BEAN_NAME_GENERATOR = "org.springframework.context.annotation.internalConfigurationBeanNameGenerator"
private BeanNameGenerator resolveBeanNameGenerator(BeanDefinitionRegistry registry) {

    BeanNameGenerator beanNameGenerator = null;

    if (registry instanceof SingletonBeanRegistry) {
        SingletonBeanRegistry singletonBeanRegistry = SingletonBeanRegistry.class.cast(registry);
        beanNameGenerator = (BeanNameGenerator) singletonBeanRegistry.getSingleton(CONFIGURATION_BEAN_NAME_GENERATOR);
    }

    if (beanNameGenerator == null) {
        beanNameGenerator = new AnnotationBeanNameGenerator();
    }
    return beanNameGenerator;

}

java复制代码private final static List<Class<? extends Annotation>> serviceAnnotationTypes = asList(
    // @since 2.7.7 Add the @DubboService , the issue : https://github.com/apache/dubbo/issues/6007
    DubboService.class,
    // @since 2.7.0 the substitute @com.alibaba.dubbo.config.annotation.Service
    Service.class,
    // @since 2.7.3 Add the compatibility for legacy Dubbo's @Service , the issue : https://github.com/apache/dubbo/issues/4330
    com.alibaba.dubbo.config.annotation.Service.class
);

这里主要是 DubboService , 下方的 2 个 Service 官方标注已过时

java复制代码public class ServicePackagesHolder {
    // 可以看到 , 其中主要是2个set 集合用于保存已经加载的 class 和 package
    public static final String BEAN_NAME = "dubboServicePackagesHolder";
    private final Set<String> scannedPackages = new HashSet<>();
    private final Set<String> scannedClasses = new HashSet<>();
    
    
}

java复制代码
private Set<BeanDefinitionHolder> findServiceBeanDefinitionHolders(
        ClassPathBeanDefinitionScanner scanner, String packageToScan, BeanDefinitionRegistry registry,
        BeanNameGenerator beanNameGenerator) {
	// 扫描 Bean , 此处实际上是依赖了 Spring 的体系
    Set<BeanDefinition> beanDefinitions = scanner.findCandidateComponents(packageToScan);

    Set<BeanDefinitionHolder> beanDefinitionHolders = new LinkedHashSet<>(beanDefinitions.size());
	// 所有的Service 类 , 此处的类型 org.springframework.context.annotation.ScannedGenericBeanDefinition
    for (BeanDefinition beanDefinition : beanDefinitions) {

        String beanName = beanNameGenerator.generateBeanName(beanDefinition, registry);
        BeanDefinitionHolder beanDefinitionHolder = new BeanDefinitionHolder(beanDefinition, beanName);
        beanDefinitionHolders.add(beanDefinitionHolder);

    }

    return beanDefinitionHolders;

}

java复制代码// BeanDefinition 加载主流程 C- ServiceAnnotationPostProcessor
private void processScannedBeanDefinition(BeanDefinitionHolder beanDefinitionHolder, BeanDefinitionRegistry registry,
                                          DubboClassPathBeanDefinitionScanner scanner) {
	
    Class<?> beanClass = resolveClass(beanDefinitionHolder);
	
    // 获取 Bean 的注解及属性
    Annotation service = findServiceAnnotation(beanClass);
    Map<String, Object> serviceAnnotationAttributes = AnnotationUtils.getAttributes(service, true);
	
    // 返回接口类
    Class<?> interfaceClass = resolveServiceInterfaceClass(serviceAnnotationAttributes, beanClass);

    String annotatedServiceBeanName = beanDefinitionHolder.getBeanName();

    // ServiceBean Bean name
    String beanName = generateServiceBeanName(serviceAnnotationAttributes, interfaceClass);

    AbstractBeanDefinition serviceBeanDefinition =
            buildServiceBeanDefinition(serviceAnnotationAttributes, interfaceClass, annotatedServiceBeanName);

    registerServiceBeanDefinition(beanName, serviceBeanDefinition, interfaceClass);

}

Java复制代码// 从@Service注释属性解析服务接口名称
// 注意:如果是通用服务，服务接口类可能在本地找不到
public static String resolveInterfaceName(Map<String, Object> attributes, Class<?> defaultInterfaceClass) {
    Boolean generic = getAttribute(attributes, "generic");
    // 1. get from DubboService.interfaceName()
    String interfaceClassName = getAttribute(attributes, "interfaceName");
    if (StringUtils.hasText(interfaceClassName)) {
        if (GenericService.class.getName().equals(interfaceClassName) ||
            com.alibaba.dubbo.rpc.service.GenericService.class.getName().equals(interfaceClassName)) {
            throw new IllegalStateException...;
        }
        return interfaceClassName;
    }

    // 2. get from DubboService.interfaceClass()
    Class<?> interfaceClass = getAttribute(attributes, "interfaceClass");
    if (interfaceClass == null || void.class.equals(interfaceClass)) { // default or set void.class for purpose.
        interfaceClass = null;
    } else  if (GenericService.class.isAssignableFrom(interfaceClass)) {
        throw new IllegalStateException....;
    }

    // 3. get from annotation element type, ignore GenericService
    if (interfaceClass == null && defaultInterfaceClass != null  && !GenericService.class.isAssignableFrom(defaultInterfaceClass)) {
        // 此处拿到的为 interface org.apache.dubbo.demo.DemoService
        Class<?>[] allInterfaces = getAllInterfacesForClass(defaultInterfaceClass);
        if (allInterfaces.length > 0) {
            interfaceClass = allInterfaces[0];
        }
    }

    return interfaceClass.getName();
}

JAVA复制代码// C- ServiceAnnotationPostProcessor
private AbstractBeanDefinition buildServiceBeanDefinition(Map<String, Object> serviceAnnotationAttributes,
                                                          Class<?> interfaceClass,
                                                          String refServiceBeanName) {

    BeanDefinitionBuilder builder = rootBeanDefinition(ServiceBean.class);

    AbstractBeanDefinition beanDefinition = builder.getBeanDefinition();

    MutablePropertyValues propertyValues = beanDefinition.getPropertyValues();

    String[] ignoreAttributeNames = of("provider", "monitor", "application", "module", "registry", "protocol",
            "interface", "interfaceName", "parameters");

    propertyValues.addPropertyValues(new AnnotationPropertyValuesAdapter(serviceAnnotationAttributes, environment, ignoreAttributeNames));

    //set config id, for ConfigManager cache key
    //builder.addPropertyValue("id", beanName);
    // References "ref" property to annotated-@Service Bean
    addPropertyReference(builder, "ref", refServiceBeanName);
    // Set interface
    builder.addPropertyValue("interface", interfaceClass.getName());
    // Convert parameters into map
    builder.addPropertyValue("parameters", convertParameters((String[]) serviceAnnotationAttributes.get("parameters")));
    // Add methods parameters
    List<MethodConfig> methodConfigs = convertMethodConfigs(serviceAnnotationAttributes.get("methods"));
    if (!methodConfigs.isEmpty()) {
        builder.addPropertyValue("methods", methodConfigs);
    }

    // convert provider to providerIds
    String providerConfigId = (String) serviceAnnotationAttributes.get("provider");
    if (StringUtils.hasText(providerConfigId)) {
        addPropertyValue(builder, "providerIds", providerConfigId);
    }

    // Convert registry[] to registryIds
    String[] registryConfigIds = (String[]) serviceAnnotationAttributes.get("registry");
    if (registryConfigIds != null && registryConfigIds.length > 0) {
        resolveStringArray(registryConfigIds);
        builder.addPropertyValue("registryIds", StringUtils.join(registryConfigIds, ','));
    }

    // Convert protocol[] to protocolIds
    String[] protocolConfigIds = (String[]) serviceAnnotationAttributes.get("protocol");
    if (protocolConfigIds != null && protocolConfigIds.length > 0) {
        resolveStringArray(protocolConfigIds);
        builder.addPropertyValue("protocolIds", StringUtils.join(protocolConfigIds, ','));
    }

    // TODO Could we ignore these attributes: applicatin/monitor/module ? Use global config
    // monitor reference
    String monitorConfigId = (String) serviceAnnotationAttributes.get("monitor");
    if (StringUtils.hasText(monitorConfigId)) {
        addPropertyReference(builder, "monitor", monitorConfigId);
    }

    // application reference
    String applicationConfigId = (String) serviceAnnotationAttributes.get("application");
    if (StringUtils.hasText(applicationConfigId)) {
        addPropertyReference(builder, "application", applicationConfigId);
    }

    // module reference
    String moduleConfigId = (String) serviceAnnotationAttributes.get("module");
    if (StringUtils.hasText(moduleConfigId)) {
        addPropertyReference(builder, "module", moduleConfigId);
    }

    return builder.getBeanDefinition();

}

// 这一步主要是属性的处理 , 没什么看的

JAVA复制代码// C- ServiceAnnotationPostProcessor
private void registerServiceBeanDefinition(String serviceBeanName, AbstractBeanDefinition serviceBeanDefinition, Class<?> interfaceClass) {
	// check service bean
	if (registry.containsBeanDefinition(serviceBeanName)) {
		BeanDefinition existingDefinition = registry.getBeanDefinition(serviceBeanName);
		if (existingDefinition.equals(serviceBeanDefinition)) {
			// exist equipment bean definition
			return;
		}

		// ..... 省略异常抛出
		throw new BeanDefinitionStoreException(....)
	}

	registry.registerBeanDefinition(serviceBeanName, serviceBeanDefinition);

}


// [PRO] : generateServiceBeanName 的简述
private String generateServiceBeanName(Map<String, Object> serviceAnnotationAttributes, Class<?> interfaceClass) {
	ServiceBeanNameBuilder builder = create(interfaceClass, environment)
		.group((String) serviceAnnotationAttributes.get("group"))
		.version((String) serviceAnnotationAttributes.get("version"));
	return builder.build();
}

// PS : 注意 ,此处创建的名称是 ServiceBean:org.apache.dubbo.demo.DemoService
// 这个很重要 , 后面会使用

java复制代码// 在 AbstractApplicationContext # refresh 中 , 
public void refresh() throws BeansException, IllegalStateException {
    // Bean 的扫描逻辑
    invokeBeanFactoryPostProcessors(beanFactory);
    
    //...... 中间处理
    
    // Bean 的注册逻辑
    finishBeanFactoryInitialization(beanFactory);

}

// Step 1 : 实例化所有的 Bean
// Instantiate all remaining (non-lazy-init) singletons.
beanFactory.preInstantiateSingletons();

// Step 2 : 获取 Bean 
for (String beanName : beanNames) {
    //...
    getBean(beanName)
}

// Step 3: 使用 -> 下一篇看看

rust复制代码(parameters) -> expression 或者 (parameters) -> { statements; }

ini复制代码  public static void main(String[] args)throws Exception {  
	        usersList = new ArrayList<Account>();  
	        //System.out.println(usersList);  
	        /**********************用户文本**********************/  
	        File users = new File("users.txt");  
	        if (!users.exists()) {  
	            try {  
	                users.createNewFile();  
	                Writer fw = new FileWriter("users.txt");  
	                fw.write("123456  123456   10000");  
	                fw.flush();  
	                fw.close();  
	            } catch (Exception e1) {  
	                JOptionPane.showMessageDialog(null, "创建用户文档失败");  
	            }  
	  
	        }  
	        usersFile = users;//创建用户文档，存储用户账户，密码，余额信息;  
	        usersListRead();  
	        usersListUpdate();  
	        /*****************************Login****************************/  
	  
	        LoginGui loginGui = new LoginGui();  
	    }

java复制代码package atm;
//import com.sun.deploy.util.SyncFileAccess;  
//import com.sun.org.apache.regexp.internal.RE;  
  
import javax.swing.*;  
import  java.io.*;  
import java.text.SimpleDateFormat;  
import  java.util.*;
public class Account {
	  int money;  
	    String id;//账号名  
	  
	    String password;  
	    Date now=new Date();  
	    Date currentTime;  
	    SimpleDateFormat formatter;  
	    Reader fr;  
	    ;  
	    public Account(String id, String password, String money) {//构造方法  
	        this.id = id;  
	  
	        this.password = password;  
	        this.money=Integer.parseInt(money);  
	    }  
	  
	    public void outMoney (int money)throws Exception {//抛出异常，由相关的界面类弹窗处理异常,下面几个方法同理  
	        //如在取钱界面取钱，则会调用此函数，进行try/catch处理，获得这个函数的异常，弹窗说明异常  
	        if (money > this.money) {  
	            throw new Exception("余额不足");  
	        }
	        if(money<0)  
	        {  
	            throw new Exception("不能取出负数");  
	        }  
	        formatter = new SimpleDateFormat("yy-MM-dd HH:mm:ss");//时间格式  
	        currentTime = new Date();//当前时间  
	        String dateString = formatter.format(currentTime);//处理当前时间格式  
	        Writer fw = new FileWriter(Test.file);  
	        fw.write(Test.recordString.append(dateString + "\t" + Test.currentAccount.id + "\t取出" + money + "元\r\n").toString());//将这次的取钱行为添加到记录文件中  
	        fw.flush();//写进文件  
	        fw.close();  
	        this.money -= money;  
	        Test.usersListUpdate();//更新用户文档（信息）  
	    }  
	  
	    public void inMoney(int money)throws Exception  
	    {  
	        try {  
	            Writer fw = new FileWriter(Test.file);  
	           // System.out.println(Test.file);  
	            formatter = new SimpleDateFormat("yy-MM-dd HH:mm:ss");  
	            currentTime=new Date();  
	            String dateString=formatter.format(currentTime);  
	            fw.write(Test.recordString.append(dateString+"\t"+Test.currentAccount.id+"\t存入" + money + "元\r\n").toString());  
	            fw.flush();//写进文件  
	            fw.close();  
	  
	            this.money+=money;  
	  
	            Test.usersListUpdate();//更新当前用户信息  
	  
	        }  
	        catch (Exception e1)  
	        {  
	            throw new Exception("写入记录失败");  
	        }  
	  
	    }  
	  
	    public void transfer(int money,String id)throws Exception//转账  
	    {  
	        if(id.equals(Test.currentAccount.id))  
	        {  
	            throw new Exception("不能转给自己");  
	        }  
	        if(money>this.money)  
	        {  
	            throw new Exception("余额不足");  
	        }  
	        if(money<0) {  
	            throw new Exception("不能转入负数");  
	        }  
	  
	  
	        for(int i=0;i<Test.usersList.size();i++)  
	        {  
	            if(Test.usersList.get(i).id.equals(id))//找到要转帐的用户  
	            {  
	                Test.usersList.get(i).money+=money;//转入  
	                this.money-=money;//扣钱  
	  
	                FileWriter fw=new FileWriter(Test.file);  
	                formatter = new SimpleDateFormat("yy-MM-dd HH:mm:ss");//声明时间格式  
	                currentTime=new Date();//获取当前时间  
	                String dateString=formatter.format(currentTime);//转换时间格式  
	                fw.write(Test.recordString.append(dateString+"\t向"+id+"\t转出"+money+"元\r\n").toString());//Test类中的静态字符串拼接上这个字符串覆盖写入当前用户文档  
	                fw.close();  
	  
	                /********************向转入目标写入转账信息*************************/  
	                try {  
	                fr = new FileReader(id+".txt");//字符流  
	                 }  
	                 catch (Exception e)  
	                 {  
	                System.out.println("字符流创建失败");  
	                }  
	  
	                BufferedReader bfr = new BufferedReader(fr);  
	  
	                String temp="";  
	                String temp1;  
	  
	                while ((temp1 = bfr.readLine()) != null)  
	                {  
	                    temp+=temp1;  
	                }  
	                temp=temp.replace("元","元\n\r")+dateString+"\t由"+Test.currentAccount.id+"\t转进"+money+"元\r\n";  
	                System.out.println(temp);  
	                fw=new FileWriter(id+".txt");  
	                fw.write(temp);  
	                fw.close();  
	  
	  
	                JOptionPane.showMessageDialog(null,"转账成功");  
	                Test.usersListUpdate();//更新用户文档  
	  
	                return;  
	            }  
	        }  
	        throw new Exception("目标用户不存在");  
	    }  
	  
	    public void ChangePassword(String newPassword)throws Exception  
	    {  
	     if(newPassword.equals(this.password))  
	     {  
	         throw new Exception("原密码和新密码不能一样");  
	     }  
	  
	     else  
	     {  
	         if(newPassword.equals(""))  
	         {  
	             throw new Exception("密码不能为空");  
	         }  
	  
	     }  
	     password=newPassword;  
	        Test.usersListUpdate();  
	  
	  
	    }  
	  
	  
	  
}

scss复制代码package atm;
import javax.swing.*;  
import java.awt.*;  
import java.awt.event.ActionEvent;  
import java.awt.event.ActionListener; 
public class ChangePassword implements ActionListener{
	public JPasswordField oldPassword,newPassword,checkPassword;  
    public JFrame iframe;  
    public JPanel ip0,ip1,ip2,ip3,ip4;  
    public JButton confirm,cancel,exit;  
    public ChangePassword() {  
        iframe=new JFrame("更改密码");  
        iframe.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);  
  
        ip2=new JPanel();  
        ip2.add(new JLabel("原密码:"));  
        oldPassword=new JPasswordField(20);  
        ip2.add(new JLabel("<html><br/><html>"));//换行  
        ip2.add(oldPassword);  
  
        ip0=new JPanel();  
        ip0.add(new JLabel("新密码:"));  
        newPassword=new JPasswordField(20);  
        ip0.add(new JLabel("<html><br/><html>"));//换行  
        ip0.add(newPassword);  
  
        ip4=new JPanel();  
        ip4.add(new JLabel("再次输入新密码:"));  
        checkPassword=new JPasswordField(20);  
        ip4.add(new JLabel("<html><br/><html>"));//换行  
        ip4.add(checkPassword);  
  
        ip3=new JPanel();  
        confirm=new JButton("确定");  
        ip3.add(confirm);  
        cancel=new JButton("返回");  
        ip3.add(cancel);  
  
        iframe.add(ip2);  
        iframe.add(ip0);  
        iframe.add(ip4);  
        iframe.add(ip3);  
        iframe.add(confirm);  
        iframe.add(cancel);  
        iframe.setLayout(new FlowLayout());  
        iframe.setVisible(true);  
        iframe.setTitle("密码更改");//窗体标签  
        iframe.setSize(400, 200);//窗体大小  
        iframe.setLocationRelativeTo(null);//在屏幕中间显示(居中显示)  
        confirm.addActionListener(this);  
  
        cancel.addActionListener(this);  
  
    } 
    public void  pw_clean() {
    	newPassword.setText("");
		oldPassword.setText("");
		checkPassword.setText("");
    }
  
    @Override  
    public void actionPerformed(ActionEvent e) {  
        if(e.getActionCommand().equals("确定")) {  
            if (Test.currentAccount.password.equals(oldPassword.getText())) {  
                try {  
                    if(newPassword.getText().equals(checkPassword.getText())) { 
                    	if(newPassword.getText().length()>=6) {
                    		Test.currentAccount.ChangePassword(newPassword.getText());  
                    		JOptionPane.showMessageDialog(null, "更改密码成功");  
                    		iframe.setVisible(false);  
                            Test.menu.mframe.setVisible(false);//关闭菜单界面  
                            new LoginGui();  
                    	}else {
                    		JOptionPane.showMessageDialog(null,"密码不能少于6位！\n请重新输入","提示消息",JOptionPane.ERROR_MESSAGE);
                    		pw_clean();
                    	}
                    }  
                    else  
                    {  
                        JOptionPane.showMessageDialog(null, "两次输入的密码不一致");  
                        pw_clean();
                    }  
                }  
             catch (Exception e1) {//捕获账户类中更改密码函数的异常并弹窗显示  
                    JOptionPane.showMessageDialog(null, e1.getMessage()); 
                    pw_clean();
                }  
            } else {  
  
                JOptionPane.showMessageDialog(null, "原密码错误");  
                pw_clean();
            }  
        }  
        else//如果点击cancel  
        {  
            iframe.setVisible(false);  
        }  
    }  
}

java复制代码public interface WebSocketHandler {

	
	void afterConnectionEstablished(WebSocketSession session) throws Exception;

	
	void handleMessage(WebSocketSession session, WebSocketMessage<?> message) throws Exception;

	
	void handleTransportError(WebSocketSession session, Throwable exception) throws Exception;

	
	void afterConnectionClosed(WebSocketSession session, CloseStatus closeStatus) throws Exception;

	
	boolean supportsPartialMessages();

}

java复制代码public class MarcoHandler extends AbstractWebSocketHandler {

 protected void handleTextMessage(WebSocketSession session, TextMessage message) throws Exception {
  System.out.println("Received message: " + message.getPayload());
  Thread.sleep(2000);
  session.sendMessage(new TextMessage("Polo!"));
 }
 
 @Override
 public void afterConnectionEstablished(WebSocketSession session) {
  System.out.println("Connection established!");
 }
 
 @Override
 public void afterConnectionClosed(WebSocketSession session, CloseStatus status) {
  System.out.println("Connection closed. Status: " + status);
 }

java复制代码public class MarcoHandler extends TextWebSocketHandler {
...
}

public class MarcoHandler extends BinaryWebSocketHandler{
...
}

java复制代码@Configuration
@EnableWebSocket
public class WebSocketConfig implements WebSocketConfigurer{
 
 @Override
 public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
  registry.addHandler(marcoHandler(), "/marco"); //注册信息管理器，将MarcoHandler映射到"/marco"
 }
 
 @Bean
 public MarcoHandler marcoHandler() {
  return new MarcoHandler();
 }
 
}

java复制代码@Override
 protected Class<?>[] getServletConfigClasses() {
  return new Class<?>[] {WebSocketConfig.class};
 }

xml复制代码<script>
	
		var url = 'ws://' + window.location.host + '/yds(你的项目名称)/marco';
		var sock = new WebSocket(url);      //打开WebSocket
		 
		sock.onopen = function() {          //处理连接开启事件
		 console.log('Opening');
		 sock.send('Marco!');
		};
		 
		sock.onmessage = function(e) {      //处理信息
		 console.log('Received Message: ', e.data);
		 setTimeout(function() {
		  sayMarco()
		 }, 2000);
		};
		 
		sock.onclose = function() {         //处理连接关闭事件
		 console.log('Closing');
		};
		 
		function sayMarco() {               //发送信息函数
		 console.log('Sending Marco!');
		 sock.send('Marco!');
		}
	</script>

xml复制代码<script>

        if('WebSocket' in window)
        {
         var url = 'ws://' + window.location.host + '/TestsWebSocket（项目名）/websocket（服务端定义的端点）';
         var sock = new WebSocket(url);      //打开WebSocket
        }else
        {
        alert("你的浏览器不支持WebSocket");
        }
       
        sock.onopen = function() {          //处理连接开启事件
         console.log('Opening');
         sock.send('start');
        };

        sock.onmessage = function(e) {      //处理信息
	    e = e || event; 		   //获取事件，这样写是为了兼容IE浏览器
		console.log(e.data);
        };

        sock.onclose = function() {         //处理连接关闭事件
         console.log('Closing');
        };
               
    </script>

java复制代码import java.io.IOException;
import java.util.Date;

import javax.websocket.OnClose;
import javax.websocket.OnError;
import javax.websocket.OnMessage;
import javax.websocket.OnOpen;
import javax.websocket.Session;
import javax.websocket.server.ServerEndpoint;

@ServerEndpoint(value = "/websocket")    //声明这是一个Socket服务
public class MyWebSocket {
	//session为与某个客户端的连接会话，需要通过它来给客户端发送数据
	private Session session;
 
	/**
	 * 连接建立成功调用的方法
	 * @param session  可选的参数
	 * @throws Exception 
	 */
	@OnOpen
	public void onOpen(Session session) throws Exception {
		this.session = session;
		System.out.println("Open");
	}
 
	/**
	 * 连接关闭调用的方法
	 * @throws Exception 
	 */
	@OnClose
	public void onClose() throws Exception {		
		System.out.println("Close");
	}
 
	/**
	 * 收到消息后调用的方法
	 * @param message 客户端发送过来的消息
	 * @param session 可选的参数
	 * @throws Exception 
	 */
	@OnMessage
	public void onMessage(String message, Session session) throws Exception {
		if (message != null){
	        	switch (message) {        	
				case "start":
					System.out.println("接收到数据"+message);
					sendMessage("哈哈哈哈哈哈哈哈");
					break;				
				case "question":					
				case "close":
					System.out.println("关闭连接");
					onClose();
				default:
						break;
				}
	        }
	}
 
	/**
	 * 发生错误时调用
	 * @param session
	 * @param error
	 */
	@OnError
	public void onError(Session session, Throwable error) {
		error.printStackTrace();
	}
 
	/**
	 * 发送消息方法。
	 * @param message
	 * @throws IOException
	 */
	public void sendMessage(String message) throws IOException {
		this.session.getBasicRemote().sendText(message);   //向客户端发送数据
	}

}

java复制代码 @Override
 public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
  registry.addHandler(marcoHandler(), "/marco").withSockJS();
 }

xml复制代码<script src="https://cdn.bootcss.com/sockjs-client/1.1.4/sockjs.min.js"></script>

ruby复制代码        var url = 'marco';
		var sock = new SockJS(url);   //SockJS所处理的URL是http://或https://,不再是ws://和wss://
		           //使用相对URL。例如，如果包含JavaScript的页面位于"http://localhost:8080/websocket"的路径下
		           // 那么给定的"marco"路径将会形成到"http://localhost:8080/websocket/marco"的连接

javascript复制代码>>> SEND
destination:/app/marco
content-length:20

{"message":"Maeco!"}

java复制代码@Configuration
@EnableWebSocketMessageBroker
public class WebSocketStompConfig extends AbstractWebSocketMessageBrokerConfigurer{

	@Override
	public void registerStompEndpoints(StompEndpointRegistry registry) {
		
		registry.addEndpoint("/marcopolo").withSockJS();//为/marcopolo路径启用SockJS功能
	}
	@Override
	public void configureMessageBroker(MessageBrokerRegistry registry)
	{
		
		//表明在topic、queue、users这三个域上可以向客户端发消息。
		registry.enableSimpleBroker("/topic","/queue","/users");
        //客户端向服务端发起请求时，需要以/app为前缀。
		registry.setApplicationDestinationPrefixes("/app");
        //给指定用户发送一对一的消息前缀是/users/。
		registry.setUserDestinationPrefix("/users/");
	}
	
}

java复制代码 @Override
 protected Class<?>[] getServletConfigClasses() {
  return new Class<?>[] {WebSocketStompConfig.class,WebConfig.class};
 }

java复制代码@Controller
public class testConroller {
	@MessageMapping("/marco")
    public void handleShout(Shout incoming) 
    {
	System.out.println("Received message:"+incoming.getMessage());
    }
    
    @SubscribeMapping("/subscribe")
    public Shout handleSubscribe() 
    {
	Shout  outing = new Shout();
	outing.setMessage("subscribes");
	return outing;
    }
}

java复制代码public class Shout {
private String message;

public String getMessage() {
	return message;
}

public void setMessage(String message) {
	this.message = message;
}

}

xml复制代码<script src="https://cdn.bootcss.com/sockjs-client/1.1.4/sockjs.min.js"></script>
<script src="https://cdn.bootcss.com/stomp.js/2.3.3/stomp.min.js"></script>
<script src="https://cdn.bootcss.com/stomp.js/2.3.3/stomp.js"></script>
<script>
var url = 'http://'+window.location.host+'/yds/marcopolo';
var sock = new SockJS(url);  //创建SockJS连接。
var stomp = Stomp.over(sock);//创建STOMP客户端实例。实际上封装了SockJS,这样就能在WebSocket连接上发送STOMP消息。
var payload = JSON.stringify({'message':'Marco!'});
stomp.connect('guest','guest',function(frame){
stomp.send("/app/marco",{},payload);
stomp.subscribe('/app/subscribe', function(message){
            
            });
});
</script>

java复制代码@MessageMapping("/marco")	
public Shout handleShout(Shout incoming) {
	System.out.println("Received message:"+incoming.getMessage());
	Shout  outing = new Shout();
	outing.setMessage("Polo");
	return outing;
}

javascript复制代码stomp.subscribe('/topic/marco', function(message){    订阅后将会接收到消息。
});

java复制代码@MessageMapping("/marco")
@SendTo("/queue/marco")
public Shout handleShout(Shout incoming) {
	System.out.println("Received message:"+incoming.getMessage());
	Shout  outing = new Shout();
	outing.setMessage("Polo");
	return outing;
}

javascript复制代码stomp.subscribe('/queue/marco', function(message){ 
});

java复制代码 @Autowired
 private SimpMessageSendingOperations simpMessageSendingOperations;


@RequestMapping("/test")
	public void sendMessage()
	{
		simpMessageSendingOperations.convertAndSend("/topic/test", "测试SimpMessageSendingOperations ");
	}

java复制代码    @MessageMapping("/message")
	@SendToUser("/topic/sendtouser")
	public Shout message()
	{
		Shout  outing = new Shout();
		outing.setMessage("SendToUser");
		return outing;
	}

javascript复制代码stomp.subscribe('/users/topic/sendtouser', function(message){//给指定用户发送一对一的消息前缀是/users/。
});

arduino复制代码simpMessageSendingOperations.convertAndSendToUser("1", "/message", "测试convertAndSendToUser");

javascript复制代码stomp.subscribe('/users/1/message', function(message){ 

});