python3复制代码from multiprocessing import Process
import os

# 子进程要执行的代码
def run_proc(name):
    print('Run child process %s (%s)...' % (name, os.getpid()))

if __name__=='__main__':
    print('Parent process %s.' % os.getpid())
    p = Process(target=run_proc, args=('test',))
    print('Child process will start.')
    p.start()
    p.join()
    print('Child process end.')

python3复制代码from multiprocessing import Pool
import os, time, random

def long_time_task(name):
    print('Run task %s (%s)...' % (name, os.getpid()))
    start = time.time()
    time.sleep(random.random() * 3)
    end = time.time()
    print('Task %s runs %0.2f seconds.' % (name, (end - start)))


if __name__ == '__main__':
    print('Parent process %s.' % os.getpid())
    p = Pool(3)
    for i in range(4):
        p.apply_async(long_time_task, args=(i,))
    print('Waiting for all subprocesses done...')
    p.close()
    p.join()
    print('All subprocesses done.')

python3复制代码from multiprocessing import Process, Queue
import os, time, random

# 写数据进程执行的代码:
def write(q):
    print('Process to write: %s' % os.getpid())
    for value in ['A', 'B', 'C']:
        print('Put %s to queue...' % value)
        q.put(value)
        time.sleep(random.random())

# 读数据进程执行的代码:
def read(q):
    print('Process to read: %s' % os.getpid())
    while True:
        value = q.get(True)
        print('Get %s from queue.' % value)

if __name__=='__main__':
    # 父进程创建Queue，并传给各个子进程：
    q = Queue()
    pw = Process(target=write, args=(q,))
    pr = Process(target=read, args=(q,))
    # 启动子进程pw，写入:
    pw.start()
    # 启动子进程pr，读取:
    pr.start()
    # 等待pw结束:
    pw.join()
    # pr进程里是死循环，无法等待其结束，只能强行终止:
    pr.terminate()

python3复制代码import time, threading

# 新线程执行的代码:
def loop():
    print('thread %s is running...' % threading.current_thread().name)
    n = 0
    while n < 5:
        n = n + 1
        print('thread %s >>> %s' % (threading.current_thread().name, n))
        time.sleep(1)
    print('thread %s ended.' % threading.current_thread().name)

print('thread %s is running...' % threading.current_thread().name)
t = threading.Thread(target=loop, name='LoopThread')
t.start()
t.join()
print('thread %s ended.' % threading.current_thread().name)

python3复制代码balance = 0
lock = threading.Lock()

def run_thread(n):
    for i in range(100000):
        # 先要获取锁:
        lock.acquire()
        try:
            # 放心地改吧:
                global balance
								balance = balance + n
								balance = balance - n
        finally:
            # 改完了一定要释放锁:
            lock.release()

python复制代码from socket import AF_INET, SOCK_STREAM, socket
from concurrent.futures import ThreadPoolExecutor

def echo_client(sock, client_addr):
    '''
    Handle a client connection
    '''
    print('Got connection from', client_addr)
    while True:
        msg = sock.recv(65536)
        if not msg:
            break
        sock.sendall(msg)
    print('Client closed connection')
    sock.close()

def echo_server(addr):
    pool = ThreadPoolExecutor(128)
    sock = socket(AF_INET, SOCK_STREAM)
    sock.bind(addr)
    sock.listen(5)
    while True:
        client_sock, client_addr = sock.accept()
        pool.submit(echo_client, client_sock, client_addr)

echo_server(('',15000))

python3复制代码from socket import socket, AF_INET, SOCK_STREAM
from threading import Thread
from queue import Queue

def echo_client(q):
    '''
    Handle a client connection
    '''
    sock, client_addr = q.get()
    print('Got connection from', client_addr)
    while True:
        msg = sock.recv(65536)
        if not msg:
            break
        sock.sendall(msg)
    print('Client closed connection')

    sock.close()

def echo_server(addr, nworkers):
    # Launch the client workers
    q = Queue()
    for n in range(nworkers):
        t = Thread(target=echo_client, args=(q,))
        t.daemon = True
        t.start()

    # Run the server
    sock = socket(AF_INET, SOCK_STREAM)
    sock.bind(addr)
    sock.listen(5)
    while True:
        client_sock, client_addr = sock.accept()
        q.put((client_sock, client_addr))
echo_server(('',15000), 128)

kotlin复制代码基于数组
class UnionFind(n: Int) {
    1. 初始时，节点指向自己
    val parent = IntArray(n) { it } 
    ...
}
-------------------------------------------------------
基于散列表
class UnionFind() {
    val parent = HashMap<Int, Int>()
    
    fun find(x: Int): Int {
        1. 首次查询时，添加到散列表，并指向自己
        if (null == parent[x]) {
            parent[x] = x
        }
        var key = x
        while (parent[key] != key) {
            parent[key] = parent[parent[key]]!!
            key = parent[key]!!
        }
        return key
    }
}

kotlin复制代码private class UnionFind(n: Int) {

    1. 初始时，节点指向自己
    val parent = IntArray(n) { it }

    2. 查询
    fun find(x: Int): Int {
        var key = x
        while (key != parent[key]) {
            key = parent[key]
        }
        return key
    }
    
    3. 合并
    fun union(x: Int, y: Int) {
        val rootX = find(x)
        val rootY = find(y)
        parent[rootY] = rootX 
    }

    4. 判断连通性
    fun isConnected(x: Int, y: Int): Boolean {
        return find(x) == find(y)
    }
}

kotlin复制代码private class UnionFind(n: Int) {

    1. 初始时，节点指向自己
    val parent = IntArray(n) { it }

    2. 连通分量计数
    var count = n
    
    3. 合并
    fun union(x: Int, y: Int) {
        val rootX = find(x)
        val rootY = find(y)
        if(rootX == rootY){
            return
        }
        // 合并后，连通分量减一
        parent[rootY] = rootX 
        count -- 
    }
    ...
}

kotlin复制代码1. 非递归写法
fun find(x: Int): Int {
    var key = x
    while (parent[key] != key) {
        parent[key] = parent[parent[key]] // 关键
        key = parent[key]
    }
    return key
}
-------------------------------------------------------
2. 递归写法
fun find(x: Int): Int {
    var key = x
    if (parent[key] != key) {
        parent[key] = find(parent[key])
    }
    return parent[key] // 关键
}

kotlin复制代码class UnionFind(n: Int) {
    1. 根节点的高度
    private val rank = IntArray(n) { 1 }
    2. 查询（未使用路径压缩）
    fun find(x: Int): Int {
        var key = x
        while (key != parent[key]) {
            key = parent[key]
        }
        return key
    }
    3. 按秩合并
    fun union(key1: Int, key2: Int) {
        val root1 = find(key1)
        val root2 = find(key2)

        if(rank[root1] > rank[root2]){
            parent[root2] = root1
        }else if(rank[root2] > rank[root1]){
            parent[root1] = root2
        }else{
            parent[root1] = root2
            rank[root1] ++
            //  或
            //  parent[root2] = root1
            //  rank[root2] ++
        }
    }
}

xml复制代码<dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-netflix-sidecar</artifactId>
</dependency>

xml复制代码      <dependency>
        <groupId>com.alibaba.otter</groupId>
        <artifactId>canal.client</artifactId>
        <version>1.1.0</version>
      </dependency>

java复制代码@Component
@Slf4j
public class CanalClientInitializer {


    CanalConfig canalConfig;

    CanalConnector connector;

    CanalDataProcessor canalDataProcessor;


    public CanalClientInitializer(@Autowired CanalConfig canalConfig, @Autowired CanalDataProcessor canalDataProcessor) {
        this.canalConfig = canalConfig;
        this.canalDataProcessor = canalDataProcessor;
    }


    @PostConstruct
    public void init() throws InterruptedException {
        connector = CanalConnectors.newSingleConnector(new InetSocketAddress(canalConfig.getIp(), canalConfig.getPort()), canalConfig.getDestination(), "", "");
      //建立连接
        connector.connect();
      //订阅相关的表
        connector.subscribe(canalConfig.getSyncTable());
        canalDataProcessor.process(connector);
    }


    @PreDestroy
    public void preDestroy() {
        log.info("stop the canal client");
        canalDataProcessor.stopProcess();
    }

}

java复制代码@Component
@Slf4j
public class CanalDataProcessor {


    boolean isRunning;

    RabbitTemplate rabbitTemplate;

    TableChangeProcessor tableChangeProcessor;

    public CanalDataProcessor(@Autowired RabbitTemplate rabbitTemplate, @Autowired TableChangeProcessor processor) {
        this.rabbitTemplate = rabbitTemplate;
        this.tableChangeProcessor = processor;
    }

    @Async
    public void process(CanalConnector connector) throws InterruptedException {
        isRunning = true;
        while (isRunning) {
            try {
              	//获取消息
                Message message = connector.getWithoutAck(100, 10L, TimeUnit.SECONDS);
              	//业务处理逻辑
                processMessage(message);
              	//消息被成功执行，向Canal Server发送ack消息通知server该message已经被处理完成
                connector.ack(message.getId());
            } catch (Exception e) {
                log.error("wtf", e);
	              //当消息没被成功处理完成时进行回滚，下次能够重新获取该Message
                connector.rollback();
                Thread.sleep(1000);
            }
        }
        connector.disconnect();
    }


    public void stopProcess() {
        isRunning = false;
    }


    private void processMessage(Message message) {
        for(Entry entry : message.getEntries()) {
            try {
                tableChangeProcessor.process(entry);
            } catch (Exception e) {
                log.error("wtf", e);
                continue;
            }
        }
    }
}

json复制代码{
  "change_id": "694212527059369984",
  "change_type": 1,   //商品发生变化
  "change_time": "1600741397"
}

java复制代码@Component
@Slf4j
public class ProductChangeQueueListener {

    @Autowired
    @Qualifier("snake")
    ObjectMapper om;

    @Autowired
    ChangeEventHandlerFactory changeEventHandlerFactory;

    @RabbitListener(queues = RabbitConfig.PRODUCT_QUEUE_NAME, containerFactory = "customRabbitListenerContainerFactory")
    public void onChange(Message message) {

        ChangeEvent event = parse(message);
        if(event == null) {
            return;
        }

        changeEventHandlerFactory.handle(event);
    }

    private ChangeEvent parse(Message message) {
        ChangeEvent event = null;
        try {
            event = om.readValue(new String(message.getBody()), ChangeEvent.class);
        } catch (Exception e) {
            log.error("同步失败，解析失败", e);
        }
        return event;
    }


}

java复制代码@Component
@Slf4j
public class OutProductEventHandler implements ChangeEventHandler {

    @Autowired
    ProductDao productDao;

    @Autowired
    RequestBulkBuffer buffer;


    @Autowired
    OutProductChangeRequestBuilder builder;

    @Override
    @Retryable
    public boolean handle(ChangeEvent changeEvent) {
        if (!match(changeEvent)) {
            return false;
        }

        Tuple dataTuple = productDao.getProductWithStore(changeEvent.getChangeId());
        if (dataTuple == null) {
            return true;
        }
        Product product = dataTuple.get(QProduct.product);
        Store store = dataTuple.get(QStore.store);

        IndexRequest request = null;
        try {
            request = builder.convertToUpdateQuery(getTimestampNow(), product, store);
        } catch (Exception e) {
            log.error("wtf", e);
        }
        if (request == null) {
            return true;
        }
        buffer.add(request);
        return true;

    }

    @Override
    public boolean match(ChangeEvent changeEvent) {
        return ChangeEvent.CHANGE_TYPE_OUT_PRODUCT == changeEvent.getChangeType();
    }
}

java复制代码@Component
public class RequestBulkBuffer {

    CircularFifoBuffer buffer;

    public RequestBulkBuffer(CircularFifoBuffer buffer) {
        this.buffer = buffer;
    }


    public void add(DocWriteRequest<?> request) {
        buffer.add(request);
    }

}

java复制代码/**
 * 允许多线程写
 * 只允许单线程->读->处理->移除
 */
public class CircularFifoBuffer {

    private Logger logger = LoggerFactory.getLogger(CircularFifoBuffer.class.getName());


    private transient Object[] elements;

    private transient int start = 0;
    private transient int end = 0;

    private transient boolean full = false;

    private final int maxElements;

    private ReentrantLock addLock;

    private Semaphore semaphore;

    public CircularFifoBuffer(int size) {
        if (size <= 0) {
            throw new IllegalArgumentException("The size must be greater than 0");
        }
        elements = new Object[size];
        maxElements = elements.length;
        addLock = new ReentrantLock();
        semaphore = new Semaphore(size);
    }


    public int size() {
        int size = 0;

        if (end < start) {
            size = maxElements - start + end;
        } else if (end == start) {
            size = (full ? maxElements : 0);
        } else {
            size = end - start;
        }

        return size;
    }

    public boolean isEmpty() {
        return size() == 0;
    }

    public boolean isFull() {
        return size() == maxElements;
    }

    public int maxSize() {
        return maxElements;
    }

    public void clear() {
        full = false;
        start = 0;
        end = 0;
        Arrays.fill(elements, null);
    }

    public boolean add(Object element) {
        if (null == element) {
            throw new NullPointerException("Attempted to add null object to buffer");
        }

        addLock.lock();
        try {
            semaphore.acquire();
        } catch (Exception e) {
            logger.error("RingBuffer", "线程退出，添加失败");
            return false;
        }

        elements[end++] = element;


        if (end >= maxElements) {
            end = 0;
        }

        if (end == start) {
            full = true;
        }

        addLock.unlock();

        return true;

    }

    public Object get() {
        if (isEmpty()) {
            return null;
        }

        return elements[start];
    }


    public Object remove() {
        if (isEmpty()) {
            return null;
        }

        Object element = elements[start];
        if(null != element) {
            elements[start++] = null;
            if (start >= maxElements) {
                start = 0;
            }
            full = false;
            semaphore.release();
        }
        return element;
    }


    /**
     * @param size the max size of elements will return
     */
    public Object[] get(int size) {
        int queueSize = size();
        if (queueSize == 0) { //empty
            return new Object[0];
        }
        int realFetchSize =  queueSize >= size ? size : queueSize;
        if (end > start) {
            return Arrays.copyOfRange(elements, start, start + realFetchSize);
        } else {
            if (maxElements - start >= realFetchSize) {
                return Arrays.copyOfRange(elements, start, start + realFetchSize);
            } else {
                return ArrayUtils.addAll(
                    Arrays.copyOfRange(elements, start, maxElements),
                    Arrays.copyOfRange(elements, 0, realFetchSize - (maxElements - start))
                );
            }
        }
    }


    public Object[] getAll() {
        return get(size());
    }



    public Object[] remove(int size) {
        if(isEmpty()) {
            return new Object[0];
        }
        int queueSize = size();
        int realFetchSize = queueSize >= size ? size : queueSize;
        Object [] retArr = new Object[realFetchSize];
        for(int i=0;i<realFetchSize;i++) {
            retArr[i] = remove();
        }

        return retArr;
    }

}

java复制代码@Slf4j
public class RequestBulkConsumer {
    private static final int DEFAULT_BULK_SIZE = 2000;

    private CircularFifoBuffer buffer;
    private EsBulkRequestService service;

    private boolean isRunning = false;
    private int bulkSize = DEFAULT_BULK_SIZE;

    public RequestBulkConsumer(CircularFifoBuffer buffer, RestHighLevelClient client) {
        this.buffer = buffer;
        this.service = new EsBulkRequestService(client);
    }

    public void setBulkSize(int size) {
        this.bulkSize = size;
    }

    public int getBulkSize() {
        return bulkSize;
    }

    public boolean isRunning() {
        return isRunning;
    }


    public void startConsume() {
        if(isRunning) {
            return;
        }
        isRunning = true;
        while(true) {
            if(!isRunning) {
                break;
            }

            Object [] items = buffer.get(bulkSize);
            if(items.length == 0) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    break;
                }
            } else {
                List<DocWriteRequest<?>> requests = convert(items);
                try {
                    BulkResponse response = service.request(requests);
                    processResponse(response);
                    buffer.remove(items.length);
                    if (items.length < bulkSize) {
                        Thread.sleep(3000);
                    }
                } catch (InterruptedException e) {
                    break;
                } catch (IOException e) {
                    log.error("wtf", e);
                } catch (Exception e) {
                    log.error("wtf", e);
                    buffer.remove(items.length);
                }
            }
        }
    }


    private List<DocWriteRequest<?>> convert(Object [] items) {
        return Stream.of(items)
            .map(i -> {
                if(i instanceof DocWriteRequest) {
                    return (DocWriteRequest<?>) i;
                } else {
                    return null;
                }
            })
            .filter(Objects::nonNull)
            .collect(Collectors.toList());
    }

    public void stop() {
        isRunning = false;
    }


    private void processResponse(BulkResponse bulkResponse) {
        BulkItemResponse [] itemResponseArr = bulkResponse.getItems();
        for(BulkItemResponse resp : itemResponseArr) {
            DocWriteResponse docWriteResponse = resp.getResponse();
            if(docWriteResponse instanceof IndexResponse) {
                IndexResponse indexResponse = (IndexResponse) docWriteResponse;
                if(indexResponse.getResult() != Result.CREATED && indexResponse.getResult() != Result.UPDATED) {
                    if(indexResponse.status() == RestStatus.CONFLICT) {
                        continue;
                    } else {
                        log.error("索引更新失败: {}, {}", indexResponse.getId(), resp.getFailureMessage());
                    }
                }
            } else if(docWriteResponse instanceof DeleteResponse) {
                DeleteResponse deleteResponse = (DeleteResponse) docWriteResponse;
                if(deleteResponse.getResult() != Result.DELETED) {
                    log.error("索引删除失败: {}, {}", deleteResponse.getId(), resp.getFailureMessage());
                }
            }
        }
    }
}

java复制代码    private IndexRequest convertToUpdateQuery(Long timestamp, OutStoreProduct outStoreProduct) throws JsonProcessingException {
        IndexRequest indexRequest = new IndexRequest(indexName, "doc", outStoreProduct.getId());
        if(StringUtils.isEmpty(outStoreProduct.getTooEbaoProductId())) {
            log.error("商品 {} 的ebaoProductId为空，无法同步", outStoreProduct.getId());
            return null;
        }
        indexRequest.source(om.writeValueAsString(outStoreProduct), XContentType.JSON)
            .versionType(VersionType.EXTERNAL_GTE)
            .version(timestamp)
            .routing(outStoreProduct.getTooEbaoProductId());
        return indexRequest;
    }

xml复制代码<dependency>
    <groupId>cn.dev33</groupId>
    <artifactId>sa-token</artifactId>
    <version>1.4.0</version>
</dependency>

xml复制代码<!-- sa-token 权限认证, 在线文档：http://sa-token.dev33.cn/ -->
<dependency>
   <groupId>cn.dev33</groupId>
   <artifactId>sa-token</artifactId>
   <version>1.4.0</version>
</dependency>

xml复制代码<!-- web应用依赖 -->
<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>
</dependency>

<!-- lombok代码简化工具 -->
<dependency>
   <groupId>org.projectlombok</groupId>
   <artifactId>lombok</artifactId>
   <optional>true</optional>
</dependency>

<!-- sa-token 权限认证, 在线文档：http://sa-token.dev33.cn/ -->
<dependency>
   <groupId>cn.dev33</groupId>
   <artifactId>sa-token</artifactId>
   <version>1.4.0</version>
</dependency>

yaml复制代码server:
  port: 8070

spring:
  # sa-token配置
  sa-token:
    # token名称（同时也是cookie名称）
    token-name: satoken
    # token有效期，单位s 默认30天
    timeout: 2592000
    # 在多人登录同一账号时，是否共享会话（为true时共用一个，为false时新登录挤掉旧登录）
    is-share: true
    # 是否在cookie读取不到token时，继续从请求header里继续尝试读取
    is-read-head: true
    #  是否在header读取不到token时，继续从请求题参数里继续尝试读取
    is-read-body: true
    # 是否在初始化配置时打印版本字符画
    is-v: true

java复制代码@SaTokenSetup // 标注启动 sa-token
@SpringBootApplication
public class SaTokenDemoApplication {
    public static void main(String[] args) throws JsonProcessingException {
        SpringApplication.run(SaTokenDemoApplication.class, args); // run-->
        System.out.println("启动成功：sa-token配置如下：" + SaTokenManager.getConfig());
    }
}

scss复制代码// 商户A处理句柄
CompanyAHandler implements RequestHandler {
   Resp hander(req){
   //查询商户信息
   queryMerchantInfo();
   //加签
   signature();
   // http请求（走代理）
   httpRequestbyProxy()
   // 验签
   verify();
   }
}
// 商户B处理句柄
CompanyBHandler implements RequestHandler {
   Resp hander(Rreq){
   //查询商户信息
   queryMerchantInfo();
   //加签
   signature();
   // http请求（不走代理）
   httpRequestbyDirect();
   // 验签
   verify(); 
   }
}
// 商户C处理句柄
CompanyBHandler implements RequestHandler {
   Resp hander(Rreq){
   //查询商户信息
   queryMerchantInfo();
   // webservice 方式调用
   requestByWebservice();
   }
}

sql复制代码在模板模式（Template Pattern）中，一个抽象类公开定义了执行它的方法的方式/模板。它的子类可以按需要重写方法实现，但调用将以抽象类中定义的方式进行。
这种类型的设计模式属于行为型模式。

scss复制代码abstract class AbstractCompanyCommonService implements ICompanyCommonService { 
     //模板方法
     Resp handlerTempPlate(req){
            //查询商户信息
           queryMerchantInfo();
           // 加签
           signature();
           //http 请求
           if(isRequestByProxy()){
              httpProxy();
            }else{
              httpDirect();
             }
            // 验签
            verifySinature();
     }
      // Http是否走代理
      abstract boolean isRequestByProxy();
}

typescript复制代码CompanyAServiceImpl extends AbstractCompanyCommonService{
    Resp hander(req){
      return handlerTempPlate(req);
    }
    //公司A是走代理的
    boolean isRequestByProxy(){
       return true;
    }

typescript复制代码CompanyBServiceImpl extends AbstractCompanyCommonService{
    Resp hander(req){
      return handlerTempPlate(req);
    }
    //公司B是不走代理的
    boolean isRequestByProxy(){
       return false;
    }

sql复制代码在策略模式（Strategy Pattern）中，一个类的行为或其算法可以在运行时更改。这种类型的设计模式属于行为型模式。

csharp复制代码// 定义一个方法，把策略交给子类去实现。
interface ICompanyCommonService{
  Resp hander(req);
}

scss复制代码CompanyCServiceImpl extends AbstractCompanyCommonService{
    Res hander(req){
       //查询商户信息
       queryMerchantInfo();
       requestByWebservice();    
    }
    //随意了，你都不走模板了
    boolean isRequestByProxy(){
       return false;
    }

复制代码在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

typescript复制代码interface ICompanyCommonService{
  Resp hander(req);
  CompanyEnum getCompanyEnum();
}

CompanyAServiceImpl extends AbstractCompanyCommonService{
    Resp hander(req){
      return handlerTempPlate(req);
    }
    //公司A是走代理的
    boolean isRequestByProxy(){
       return true;
    }
    CompanyEnum getCompanyEnum(){
     return CompanyEnum.A;
    } 
    
CompanyBServiceImpl extends AbstractCompanyCommonService{
    Resp hander(req){
      return handlerTempPlate(req);
    }
    //公司B是不走代理的
    boolean isRequestByProxy(){
       return false;
    }
    CompanyEnum getCompanyEnum(){
     return CompanyEnum.B;
    }

typescript复制代码@Component
public class CompanyServiceFactory implements ApplicationContextAware {

    private static Map<CompanyEnum, ICompanyCommonService> map = new HashMap<>();

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        Map<String, ICompanyCommonService> tempMap = applicationContext.getBeansOfType(ICompanyCommonService.class);
        tempMap.values().forEach(iCompanyCommonService ->
                map.put(iCompanyCommonService.getCompanyEnum(), iCompanyCommonService));
    }

    public Resp handler(req) {
        return map.get(CompanyEnum.getCompanyEnum(req.getCompanyFlag()).hander(req);
    }
}

typescript复制代码@Service
public class CompanyHandler implements RequestHandler  {
   @Autowire
   private CompanyServiceFactory companyServiceFactory;
   
   Resp hander(req){
    return companyServiceFactory.handler(req);
  }
}

xml复制代码<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">
	<!-- 要扫描的包 -->
	<context:component-scan base-package="model"></context:component-scan>
</beans>

kotlin复制代码package config;
import org.springframework.beans.factory.annotation.Configurable;
import org.springframework.context.annotation.ComponentScan;
import model.Product;

/**
 * @Configurable: 该注解是标注该类是配置类
 * @ComponentScan：配置要扫描的包
 * @author GaoYang
 */
@Configurable
@ComponentScan("model")
public class MainConfig {

}

kotlin复制代码/**
	@Componnt可以指定该对象的id，也可以不用指定
	默认id为该类的类名首字母小写
 */
@Component("students")
public class Student {
	@Value("01")
	private int sid;
	@Value("侯宁宁")
	private String name;
	@Value("男")
	private String sex;

less复制代码/**
 * @Configurable: 该注解是标注该类是配置类
 * @ComponentScan：配置要扫描的包
 * @author GaoYang
 */
@Configurable
@ComponentScan("model")
public class MainConfig {

}

typescript复制代码@Component("students")
public class Student {
	@Value("01")
	private int sid;
	@Value("侯宁宁")
	private String name;
	@Value("男")
	private String sex;

	public Student() {
		super();
	}
	public Student(int sid, String name, String sex) {
		super();
		this.sid = sid;
		this.name = name;
		this.sex = sex;
	}
	public int getSid() {
		return sid;
	}
	public void setSid(int sid) {
		this.sid = sid;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
	@Override
	public String toString() {
		return "Student [sid=" + sid + ", name=" + name + ", sex=" + sex + "]";
	}

}

typescript复制代码// 配置类
@Configurable
@ComponentScan("model")
public class MainConfig {
	// 默认id为方法名
	@Bean
	public Product product1() {
		return new Product("张三","hashd",1);
	}
	// 可以指定id
	@Bean("product2")
	public Product product2() {
		return new Product("张三","hashd",1);
	}

}

typescript复制代码public class Product {
	private String name;
	private String price;
	private int num;
	public Product() {
		super();
	}
	public Product(String name, String price, int num) {
		super();
		this.name = name;
		this.price = price;
		this.num = num;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getPrice() {
		return price;
	}
	public void setPrice(String price) {
		this.price = price;
	}
	public int getNum() {
		return num;
	}
	public void setNum(int num) {
		this.num = num;
	}
	@Override
	public String toString() {
		return "Product [name=" + name + ", price=" + price + ", num=" + num + "]";
	}

}

less复制代码@Configurable
@ComponentScan(value = "model",excludeFilters = {
		// FilterType.ANNOTATION是通过注解的形式进行过滤
		@Filter(type = FilterType.ANNOTATION,classes = {Controller.class}),

		// FilterType.ASSIGNABLE_TYPE 是通过给定的类型
		@Filter(type = FilterType.ASSIGNABLE_TYPE,classes = {Product.class}),

		// FilterType.ASPECTJ 根据正则表达式
		@Filter(type = FilterType.ASPECTJ,classes = {""}),

		// FilterType.CUSTOM 使用自定义规则
		@Filter(type = FilterType.CUSTOM,classes = {TypeFilterImp.class})

})
public class MainConfig {
	// @Bean == <bean></bean>

}

java复制代码/**
	 * MetadataReader： 读取到的当前正在扫描的信息
	 * MetadataReaderFactory：可以获取到其他任何类的信息
	 */
	@Override
	public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException {
		// 获取当前类注解的信息
		AnnotationMetadata mr = metadataReader.getAnnotationMetadata();
		// 获取当前正在扫描的类的信息
		ClassMetadata classMetadata = metadataReader.getClassMetadata();
		// 获取当前类的资源信息
		Resource resource =  metadataReader.getResource();
		// 获取当前类的名字
		String className = classMetadata.getClassName();
		System.out.println("----"+className);
		// contains包含“er”
		if(className.contains("er")) {
			return true;
		}
		return false;
	}

}

less复制代码@Configurable
@ComponentScan("model")
public class MainConfig {
   /**
    * @Scope
    * prototype: 多实例的  @Scope("prototype")
    * singleton: 单实例的  @Scope("person")
    * request: 一次请求创建一个实例
    * session: 同一个session创建一个实例
    * @return
    */
   @Scope("singleton")
   @Bean
   public Product product() {
   	System.out.println("该实例已被创建");
   	return new Product("张三","hashd",1);
   }
}

ini复制代码public class text {
	public static void main(String[] args) {
		AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig.class);
		System.out.println("Ioc容器已创建完成!");
		Product bean1 = applicationContext.getBean(Product.class);
		Product bean2 = applicationContext.getBean(Product.class);
		System.out.println(bean1== bean2);

	}
}

less复制代码// 配置类
@Configurable
@ComponentScan("model")
public class MainConfig {
	/**
	 * 懒加载：
	 * 		针对的是单实例的bean，默认在容器启动的时候创建对象
	 * 		赖加载：容器启动时不创建对象，当第一次被调用时被创建
	 * 
	 */
	@Lazy
	@Bean
	public Product product() {
		System.out.println("该实例已被创建");
		return new Product("张三","hashd",1);
	}

less复制代码@Configurable
public class MainConfig {

	@Conditional({winCondition.class})
	@Bean("wind")
	public Product wind() {
		System.out.println("该实例已被创建");
		return new Product("张三","wind",1);
}

java复制代码public class winCondition implements Condition{

	@Override
	public boolean matches(ConditionContext context, AnnotatedTypeMetadata arg1) {
		Environment environment = context.getEnvironment();
		// 获取当前操作系统的名字
		String property = environment.getProperty("os.name");
		if(property.contains("Windows")) {
			return true;
		}
		return false;
	}
}

less复制代码// 配置类
@Configurable
@Import(Hero.class)
public class MainConfig {
	// Windows系统
	@Conditional({winCondition.class})
	@Bean("wind")
	public Product wind() {
		System.out.println("该实例已被创建");
		return new Product("张三","wind",1);
	}
	// Linux系统  
	@Conditional({linuxCondition.class})
	@Bean("linux")
	public Product linux() {
		return new Product("李四","linux",2);

	}

}

java复制代码public class winCondition implements Condition{
	// Windows系统，返回true
	@Override
	public boolean matches(ConditionContext context, AnnotatedTypeMetadata arg1) {
		Environment environment = context.getEnvironment();
		String property = environment.getProperty("os.name");
		if(property.contains("Windows")) {
			return true;
		}
		return false;
	}

}

java复制代码public class linuxCondition implements Condition{
	/**
	 * ConditionContext: 判断条件能使用上下文环境
	 * AnnotatedTypeMetadata: 注释信息
	 */

	@Override
	public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
		// 是否Linux系统
		// 1、能获取到ioc使用的bean工厂
		ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
		// 2、获取类加载器
		ClassLoader clLoader = context.getClassLoader();
		// 3、获取当前环境信息
		  Environment environment = context.getEnvironment();
		  String property = environment.getProperty("os.name");

		// 5、bean注册类
		  BeanDefinitionRegistry registry = context.getRegistry();
		  if(property.contains("Linux")) {
			  return true;
		  }

		return false;
}

ruby复制代码@Import({ 类名.class , 类名.class... })
public class TestDemo {

}

typescript复制代码public class Myclass implements ImportSelector {
//既然是接口肯定要实现这个接口的方法
    @Override
    public String[] selectImports(AnnotationMetadata annotationMetadata) {
        return new String[0];
    }
}
// 分析实现接口的selectImports方法中的：

// 1、返回值： 就是我们实际上要导入到容器中的组件全类名【重点 】
// 2、参数： AnnotationMetadata表示当前被@Import注解给标注的所有注解信息【不是重点】
// 需要注意的是selectImports方法可以返回空数组但是不能返回null，否则会报空指针异常！

typescript复制代码public class Myclass implements ImportSelector {
    @Override
    public String[] selectImports(AnnotationMetadata annotationMetadata) {
        return new String[]{"com.yc.Test.TestDemo3"};
    }
}

csharp复制代码@Import({TestDemo2.class,Myclass.class})
public class TestDemo {
        @Bean
        public AccountDao2 accountDao2(){
            return new AccountDao2();
        }

}

arduino复制代码**
 * 打印容器中的组件测试
 */
public class AnnotationTestDemo {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext applicationContext=new AnnotationConfigApplicationContext(TestDemo.class);  //这里的参数代表要做操作的类

        String[] beanDefinitionNames = applicationContext.getBeanDefinitionNames();
        for (String name : beanDefinitionNames){
            System.out.println(name);
        }

    }
}

typescript复制代码public class Myclass2 implements ImportBeanDefinitionRegistrar {
//该实现方法默认为空
    @Override
    public void registerBeanDefinitions(AnnotationMetadata annotationMetadata, BeanDefinitionRegistry beanDefinitionRegistry) {

    }
}
// 参数分析：

// 第一个参数：annotationMetadata 和之前的ImportSelector参数一样都是表示当前被@Import注解给标注的所有注解信息
// 第二个参数表示用于注册定义一个bean

java复制代码public class Myclass2 implements ImportBeanDefinitionRegistrar {
    @Override
    public void registerBeanDefinitions(AnnotationMetadata annotationMetadata, BeanDefinitionRegistry beanDefinitionRegistry) {
        //指定bean定义信息（包括bean的类型、作用域...）
        RootBeanDefinition rootBeanDefinition = new RootBeanDefinition(TestDemo4.class);
        //注册一个bean指定bean名字（id）
        beanDefinitionRegistry.registerBeanDefinition("TestDemo4444",rootBeanDefinition);
    }
}

csharp复制代码@Import({TestDemo2.class,Myclass.class,Myclass2.class})
public class TestDemo {

        @Bean
        public AccountDao2 accountDao222(){
            return new AccountDao2();
        }

}

kotlin复制代码// 标记这是一个Spring配置类
@Configuration
public class SpringConfiguration {
    // 如果没有@Bean注解,则注入到容器中的id就是方法名(也就是myFactoryBean),但是如果显示的给了值,那么注入到容器中的就是factoryBean
    @Bean("factoryBean")
    public MyFactoryBean myFactoryBean(){
        return new MyFactoryBean();
    }
}

ini复制代码public class SpringDemo {

    @Test
    public void springTest01() throws Exception {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(SpringConfiguration.class);
        // 容器中获取的Bean,实际上就是工厂Bean(MyFactoryBean通过getObject()方法返回的对象)
        Object factoryBean01 = context.getBean("factoryBean");
        System.out.println("实际上注入到容器中的类型是:" + factoryBean01.getClass());

        Object factoryBean02 = context.getBean("factoryBean");
        System.out.println("注入到容器内的对象是否是单例:" + (factoryBean01 == factoryBean02));

        Object factoryBean03 = context.getBean("&factoryBean");
        System.out.println("如果想获取到MyFactoryBean的对象,使用&前缀:" + factoryBean03);

        // 输出打印Spring中的所有Bean名称
        String[] beanDefinitionNames = context.getBeanDefinitionNames();
        for (String beanDefinitionName : beanDefinitionNames) {
            System.out.println(beanDefinitionName);
        }
    }
}

yaml复制代码spring:
  datasource:
    master:
      jdbcUrl: jdbc:mysql://192.168.xxx.xxx:xxxx/db1?.........
      username: xxx
      password: xxx
      driverClassName: com.mysql.cj.jdbc.Driver
    s1:
      jdbcUrl: jdbc:mysql://192.168.xxx.xxx:xxxx/db2?........
      username: xxx
      password: xxx
      driverClassName: com.mysql.cj.jdbc.Driver

java复制代码@Configuration
@MapperScan(basePackages = "com.hosjoy.xxx.xxx.xxx.xxx.mapper.master", sqlSessionFactoryRef = "masterSqlSessionFactory")
public class MasterDataSourceConfig {

    //默认数据源
    @Bean(name = "masterDataSource")
    @Primary
    @ConfigurationProperties(prefix = "spring.datasource.master")
    public HikariDataSource masterDataSource() {
        return DataSourceBuilder.create().type(HikariDataSource.class).build();
    }

    @Bean(name = "masterSqlSessionFactory")
    @Primary
    public SqlSessionFactory masterSqlSessionFactory(@Qualifier("masterDataSource") DataSource datasource, PaginationInterceptor paginationInterceptor)
            throws Exception {
        MybatisSqlSessionFactoryBean bean = new MybatisSqlSessionFactoryBean();
        bean.setDataSource(datasource);
        bean.setMapperLocations(
                // 设置mybatis的xml所在位置
                new PathMatchingResourcePatternResolver().getResources("classpath*:mapper/master/**/**.xml"));
        bean.setPlugins(new Interceptor[]{paginationInterceptor});
        return bean.getObject();
    }

    @Bean(name = "masterSqlSessionTemplate")
    @Primary
    public SqlSessionTemplate masterSqlSessionTemplate(
            @Qualifier("masterSqlSessionFactory") SqlSessionFactory sessionfactory) {
        return new SqlSessionTemplate(sessionfactory);
    }
}

java复制代码@Configuration
@MapperScan(basePackages = "com.hosjoy.xxx.xxx.xxx.xxx.mapper.s1", sqlSessionFactoryRef = "s1SqlSessionFactory")
public class S1DataSourceConfig {

    @Bean(name = "s1DataSource")
    @ConfigurationProperties(prefix = "spring.datasource.s1")
    public HikariDataSource s1DataSource() {
        return DataSourceBuilder.create().type(HikariDataSource.class).build();
    }

    @Bean(name = "s1SqlSessionFactory")
    public SqlSessionFactory s1SqlSessionFactory(@Qualifier("s1DataSource") DataSource datasource
            , PaginationInterceptor paginationInterceptor)
            throws Exception {
        MybatisSqlSessionFactoryBean bean = new MybatisSqlSessionFactoryBean();
        bean.setDataSource(datasource);
        bean.setMapperLocations(
                // 设置mybatis的xml所在位置
                new PathMatchingResourcePatternResolver().getResources("classpath*:mapper/s1/**/**.xml"));
        bean.setPlugins(new Interceptor[]{paginationInterceptor});
        return bean.getObject();
    }

    @Bean(name = "s1SqlSessionTemplate")
    public SqlSessionTemplate s1SqlSessionTemplate(
            @Qualifier("s1SqlSessionFactory") SqlSessionFactory sessionfactory) {
        return new SqlSessionTemplate(sessionfactory);
    }
}

java复制代码/**伪代码**/
int userType = reqUser.getType();
if (userType == 1){
    //切换到数据源slave1
    //数据库操作
} else if(userType == 2){
    //切换到数据源slave2
    //数据库操作
}

yaml复制代码spring:
  datasource:
    master:
      jdbcUrl: jdbc:mysql://192.168.xx.xxx:xxx/db1?........
      username: xxx
      password: xxx
      driverClassName: com.mysql.cj.jdbc.Driver
    slave1:
      jdbcUrl: jdbc:sqlserver://192.168.xx.xxx:xxx;DatabaseName=db2
      username: xxx
      password: xxx
      driverClassName: com.microsoft.sqlserver.jdbc.SQLServerDriver
    slave2:
      jdbcUrl: jdbc:sqlserver://192.168.xx.xxx:xxx;DatabaseName=db3
      username: xxx
      password: xxx
      driverClassName: com.microsoft.sqlserver.jdbc.SQLServerDriver

java复制代码public class DynamicDataSource extends AbstractRoutingDataSource {
    /*存储所有数据源*/
    private Map<Object, Object> backupTargetDataSources;

    public Map<Object, Object> getBackupTargetDataSources() {
        return backupTargetDataSources;
    }
    /*defaultDataSource为默认数据源*/
    public DynamicDataSource(DataSource defaultDataSource, Map<Object, Object> targetDataSource) {
        backupTargetDataSources = targetDataSource;
        super.setDefaultTargetDataSource(defaultDataSource);
        super.setTargetDataSources(backupTargetDataSources);
        super.afterPropertiesSet();
    }
    public void addDataSource(String key, DataSource dataSource) {
        this.backupTargetDataSources.put(key, dataSource);
        super.setTargetDataSources(this.backupTargetDataSources);
        super.afterPropertiesSet();
    }
    /*返回当前线程的数据源的key*/
    @Override
    protected Object determineCurrentLookupKey() {
        return DynamicDataSourceContextHolder.getContextKey();
    }
}