spring getBeansOfType

原创转载请注明出处：https://agilestyle.iteye.com/blog/2438883

 

前期准备：spring boot环境搭建完毕

 

Project Directory

 

AResponseData

package org.fool.springboot.contract.response;

public class AResponseData {
}

 

BResponseData

package org.fool.springboot.contract.response;

public class BResponseData {
}

 

CResponseData

package org.fool.springboot.contract.response;

public class CResponseData {
}

 

HandlerTypeEnum

package org.fool.springboot.handler;

public enum HandlerTypeEnum {
    /**
     * A(0), B(1), C(2);
     */
    A(0), B(1), C(2);

    private int index;

    public int getIndex() {
        return index;
    }

    HandlerTypeEnum(int index) {
        this.index = index;
    }
}

 

Message

package org.fool.springboot.contract;

import org.fool.springboot.handler.HandlerTypeEnum;

public class Message {
    private HandlerTypeEnum type;

    public HandlerTypeEnum getType() {
        return type;
    }

    public void setType(HandlerTypeEnum type) {
        this.type = type;
    }

    @Override
    public String toString() {
        return "Message{" +
                "type=" + type +
                '}';
    }
}

 

AbstractHandler

package org.fool.springboot.handler;

public abstract class AbstractHandler<REQUEST, RESPONSE> {
    public abstract HandlerTypeEnum getHandlerType();

    protected abstract void preHandle(REQUEST request);

    protected abstract RESPONSE postHandle(REQUEST request);

    protected abstract void afterCompletion(REQUEST request, RESPONSE response);

    public void execute(REQUEST request) {
        preHandle(request);
        RESPONSE response = postHandle(request);
        afterCompletion(request, response);
    }

}

 

AHandler

package org.fool.springboot.handler;

import org.fool.springboot.contract.Message;
import org.fool.springboot.contract.response.AResponseData;
import org.springframework.stereotype.Service;

@Service
public class AHandler extends AbstractHandler<Message, AResponseData> {
    @Override
    public HandlerTypeEnum getHandlerType() {
        return HandlerTypeEnum.A;
    }

    @Override
    protected void preHandle(Message request) {
        System.out.println("AHandler pre handle sth...");
    }

    @Override
    protected AResponseData postHandle(Message request) {
        System.out.println("AHandler post handle sth...");
        // handle business logic
        return new AResponseData();
    }

    @Override
    protected void afterCompletion(Message request, AResponseData response) {
        System.out.println("AHandler after completion sth...");
    }
}

 

BHandler

package org.fool.springboot.handler;

import org.fool.springboot.contract.Message;
import org.fool.springboot.contract.response.BResponseData;
import org.springframework.stereotype.Service;

@Service
public class BHandler extends AbstractHandler<Message, BResponseData> {
    @Override
    public HandlerTypeEnum getHandlerType() {
        return HandlerTypeEnum.B;
    }

    @Override
    protected void preHandle(Message request) {
        System.out.println("BHandler pre handle sth...");
    }

    @Override
    protected BResponseData postHandle(Message request) {
        System.out.println("BHandler post handle sth...");
        // handle business logic
        return new BResponseData();
    }

    @Override
    protected void afterCompletion(Message request, BResponseData response) {
        System.out.println("BHandler after completion sth...");
    }
}

 

CHandler

package org.fool.springboot.handler;

import org.fool.springboot.contract.Message;
import org.fool.springboot.contract.response.BResponseData;
import org.fool.springboot.contract.response.CResponseData;
import org.springframework.stereotype.Service;

@Service
public class CHandler extends AbstractHandler<Message, CResponseData> {
    @Override
    public HandlerTypeEnum getHandlerType() {
        return HandlerTypeEnum.C;
    }

    @Override
    protected void preHandle(Message request) {
        System.out.println("CHandler pre handle sth...");
    }

    @Override
    protected CResponseData postHandle(Message request) {
        System.out.println("CHandler post handle sth...");
        // handle business logic
        return new CResponseData();
    }

    @Override
    protected void afterCompletion(Message request, CResponseData response) {
        System.out.println("CHandler after completion sth...");
    }
}

 

HandlerFactory

package org.fool.springboot.handler;

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;

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

@Component
public class HandlerFactory implements ApplicationContextAware {

    private static Map<HandlerTypeEnum, AbstractHandler> handlerMap = new HashMap<>();

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        Map<String, AbstractHandler> beanMap = applicationContext.getBeansOfType(AbstractHandler.class);
        beanMap.forEach((key, value) -> handlerMap.put(value.getHandlerType(), value));
    }

    public static <T extends AbstractHandler> T getHandler(HandlerTypeEnum type) {
        return (T) handlerMap.get(type);
    }
}

 

MessageService

package org.fool.springboot.service;

import org.fool.springboot.contract.Message;

public interface MessageService {
    void handleMessage(Message message);
}

 

MessageServiceImpl

package org.fool.springboot.service.impl;

import org.fool.springboot.contract.Message;
import org.fool.springboot.handler.AbstractHandler;
import org.fool.springboot.handler.HandlerFactory;
import org.fool.springboot.handler.HandlerTypeEnum;
import org.fool.springboot.service.MessageService;
import org.springframework.stereotype.Service;

@Service
public class MessageServiceImpl implements MessageService {
    @Override
    public void handleMessage(Message message) {
        HandlerTypeEnum type = message.getType();

        AbstractHandler handler = HandlerFactory.getHandler(type);

        handler.execute(message);
    }
}

 

MessageController

package org.fool.springboot.controller;

import org.fool.springboot.contract.Message;
import org.fool.springboot.handler.HandlerTypeEnum;
import org.fool.springboot.service.MessageService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/v1")
public class MessageController {
    @Autowired
    private MessageService messageService;

    @GetMapping("/msgA")
    public String msgA() {
        Message message = new Message();
        message.setType(HandlerTypeEnum.A);

        messageService.handleMessage(message);

        return "SUCCESS";
    }

    @GetMapping("/msgB")
    public String msgB() {
        Message message = new Message();
        message.setType(HandlerTypeEnum.B);

        messageService.handleMessage(message);

        return "SUCCESS";
    }

    @GetMapping("/msgC")
    public String msgC() {
        Message message = new Message();
        message.setType(HandlerTypeEnum.C);

        messageService.handleMessage(message);

        return "SUCCESS";
    }
}

 

Test

http://localhost:8088/v1/msgC

Console Output