netty项目中添加strategy策略模式，来实现接收websocket指令码，处理对应的聊天软件app业务流程 例如单聊、群聊
采用自定义注解的方式将指令码对应到策略实现 。
指令枚举类
/**
* @Description ws请求类型
*/
public enum WsRequestPathEnum {
/**
* 单聊
*/
SINGLE(1),
/**
* 加密群聊
*/
GROUP_ENCTYPT(2),
/**
* 普通群聊
*/
GROUP(3),
/**
* 获取所有离线消息
*/
All_OFFLINE_MSG(4);
private final int uriCode;
WsRequestPathEnum(int uriCode) {
this.uriCode = uriCode;
}
public int getUriCode() {
return uriCode;
}
/**
* 根据uriCode获取
*
* @param uriCode
* @return
*/
public static WsRequestPathEnum getByCode(int uriCode) {
for (WsRequestPathEnum wsRequestUriPathEnum : values()) {
if (wsRequestUriPathEnum.getUriCode() == uriCode) {
return wsRequestUriPathEnum;
}
}
return null;
}
}
策略抽象类
/**
* @Description 接收netty不同类型请求
* 抽象类 策略设计模式
*/
public abstract class ReceiveAbstractStrategy {
/**
* 处理业务流程
*
* @param requestModel
* @param user
* @param language
* @throws Exception
*/
abstract public void process(ReceiveModel requestModel, User user, String language) throws Exception;
}
策略模式 上下文
维护指令码与策略实现的对应
public class ReceiveStrategyContext {
private Map<WsRequestPathEnum, Class> strategyMap;
public ReceiveStrategyContext(Map<WsRequestPathEnum, Class> strategyMap) {
this.strategyMap = strategyMap;
}
public ReceiveAbstractStrategy getStrategy(WsRequestPathEnum wsRequestPathEnum) {
if (wsRequestPathEnum == null) {
throw new IllegalArgumentException("not fond enum");
}
if (CollectionUtils.isEmpty(strategyMap)) {
throw new IllegalArgumentException("strategy map is empty,please check you strategy package path");
}
Class aClass = strategyMap.get(wsRequestPathEnum);
if (aClass == null) {
throw new IllegalArgumentException("not fond strategy for type:" + wsRequestPathEnum.getUriCode());
}
return (ReceiveAbstractStrategy) SpringBeanUtils.getBean(aClass);
}
}
策略 bean注解扫描注册类
/**
* @Description
* 扫描自定义注解，将指令码与实现类绑定，将对应关系添加到上下文对象中
* <p>
* BeanStrategyProcessor是spring在容器初始化后对外暴露的扩展点，
* spring ioc容器允许beanFactoryPostProcessor在容器加载注册BeanDefinition后读取BeanDefinition，并能修改它。
*/
@Component
public class ReceiveStrategyProcessor implements BeanFactoryPostProcessor {
// 扫码注解的包路径
private static final String STRATEGY_PACK = "com.xx.strategy";
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
Map<WsRequestPathEnum, Class> handlerMap = Maps.newHashMapWithExpectedSize(5);
// 扫码ReceiveTypeAnnotation注解的类
Set<Class<?>> classSet = ClassScanner.scan(STRATEGY_PACK, ReceiveTypeAnnotation.class);
classSet.forEach(clazz -> {
// 获取注解中的类型值，与枚举类一一对应
WsRequestPathEnum type = clazz.getAnnotation(ReceiveTypeAnnotation.class).type();
handlerMap.put(type, clazz);
});
// 初始化Contenxt， 将其注册到spring容器当中
ReceiveStrategyContext context = new ReceiveStrategyContext(handlerMap);
try {
configurableListableBeanFactory.registerResolvableDependency(Class.forName(ReceiveStrategyContext.class.getName()), context);
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
注解扫描工具类
import org.apache.commons.lang3.ArrayUtils;
import org.springframework.beans.factory.BeanDefinitionStoreException;
import org.springframework.context.ResourceLoaderAware;
import org.springframework.core.io.Resource;
import org.springframework.core.io.ResourceLoader;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.core.io.support.ResourcePatternResolver;
import org.springframework.core.io.support.ResourcePatternUtils;
import org.springframework.core.type.classreading.CachingMetadataReaderFactory;
import org.springframework.core.type.classreading.MetadataReader;
import org.springframework.core.type.classreading.MetadataReaderFactory;
import org.springframework.core.type.filter.AnnotationTypeFilter;
import org.springframework.core.type.filter.TypeFilter;
import org.springframework.util.StringUtils;
import org.springframework.util.SystemPropertyUtils;
import java.io.IOException;
import java.lang.annotation.Annotation;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;
/**
* @Description 扫描注解 工具类
* @Author hewei hwei1233@163.com
* @Date 2020-01-03
*/
public class ClassScanner implements ResourceLoaderAware {
private final List<TypeFilter> includeFilters = new LinkedList<TypeFilter>();
private final List<TypeFilter> excludeFilters = new LinkedList<TypeFilter>();
private ResourcePatternResolver resourcePatternResolver = new PathMatchingResourcePatternResolver();
private MetadataReaderFactory metadataReaderFactory = new CachingMetadataReaderFactory(this.resourcePatternResolver);
@SafeVarargs
public static Set<Class<?>> scan(String[] basePackages, Class<? extends Annotation>... annotations) {
ClassScanner cs = new ClassScanner();
if (ArrayUtils.isNotEmpty(annotations)) {
for (Class anno : annotations) {
cs.addIncludeFilter(new AnnotationTypeFilter(anno));
}
}
Set<Class<?>> classes = new HashSet<>();
for (String s : basePackages) {
classes.addAll(cs.doScan(s));
}
return classes;
}
@SafeVarargs
public static Set<Class<?>> scan(String basePackages, Class<? extends Annotation>... annotations) {
return ClassScanner.scan(StringUtils.tokenizeToStringArray(basePackages, ",; \t\n"), annotations);
}
public final ResourceLoader getResourceLoader() {
return this.resourcePatternResolver;
}
@Override
public void setResourceLoader(ResourceLoader resourceLoader) {
this.resourcePatternResolver = ResourcePatternUtils
.getResourcePatternResolver(resourceLoader);
this.metadataReaderFactory = new CachingMetadataReaderFactory(
resourceLoader);
}
public void addIncludeFilter(TypeFilter includeFilter) {
this.includeFilters.add(includeFilter);
}
public void addExcludeFilter(TypeFilter excludeFilter) {
this.excludeFilters.add(0, excludeFilter);
}
public void resetFilters(boolean useDefaultFilters) {
this.includeFilters.clear();
this.excludeFilters.clear();
}
public Set<Class<?>> doScan(String basePackage) {
Set<Class<?>> classes = new HashSet<>();
try {
String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX
+ org.springframework.util.ClassUtils
.convertClassNameToResourcePath(SystemPropertyUtils
.resolvePlaceholders(basePackage))
+ "/**/*.class";
Resource[] resources = this.resourcePatternResolver
.getResources(packageSearchPath);
for (int i = 0; i < resources.length; i++) {
Resource resource = resources[i];
if (resource.isReadable()) {
MetadataReader metadataReader = this.metadataReaderFactory.getMetadataReader(resource);
if ((includeFilters.size() == 0 && excludeFilters.size() == 0) || matches(metadataReader)) {
try {
classes.add(Class.forName(metadataReader
.getClassMetadata().getClassName()));
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
}
} catch (IOException ex) {
throw new BeanDefinitionStoreException(
"I/O failure during classpath scanning", ex);
}
return classes;
}
protected boolean matches(MetadataReader metadataReader) throws IOException {
for (TypeFilter tf : this.excludeFilters) {
if (tf.match(metadataReader, this.metadataReaderFactory)) {
return false;
}
}
for (TypeFilter tf : this.includeFilters) {
if (tf.match(metadataReader, this.metadataReaderFactory)) {
return true;
}
}
return false;
}
}
处理app单聊消息具体策略实现
@ReceiveTypeAnnotation(type = WsRequestPathEnum.SINGLE)
@Service
public class SingleConcreteStrategy extends ReceiveAbstractStrategy {
@Override
public void process(ReceiveModel requestModel, User user, String language) throws Exception {
//具体业务代码
}
}
工具类
在非spring管理的类中获取spring注册的bean
@Component
public class SpringBeanUtils implements ApplicationContextAware {
private static ApplicationContext applicationContext;
@Override
public void setApplicationContext(ApplicationContext context) throws BeansException {
if (context != null) {
applicationContext = context;
}
}
public static Object getBean(String name) {
return applicationContext.getBean(name);
}
public static <T> T getBean(Class<T> clazz) {
return applicationContext.getBean(clazz);
}
}
调用示例
// idea此处报红 属于正常
@SuppressWarnings("SpringJavaInjectionPointsAutowiringInspection")
@Autowired
private ReceiveStrategyContext receiveStrategyContext;
private void core(String language, ReceiveModel requestModel, User user) throws Exception {
WsRequestPathEnum wsRequestUriPathEnum = WsRequestPathEnum.getByCode(requestModel.getPath());
// 使用策略模式， 根据不同类型请求调用不同实现类
ReceiveAbstractStrategy receiveStrategy = receiveStrategyContext.getStrategy(wsRequestUriPathEnum);
receiveStrategy.process(requestModel, user, language);
}
网友评论