La logique de base est la suivante :
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 | String event = crsRequest.getEvent();
CRSResponse crsResponse = null;
switch (event) {
case CRSRequestEvent.APP_START:
crsResponse = processAppStartCommand(crsRequest);
break ;
case CRSRequestEvent.INIT_COMPLETE:
crsResponse = processInitCompleteCommand(crsRequest);
break ;
case CRSRequestEvent.COLLECT_COMPLETE:
crsResponse = processCollectCompleteCommand(crsRequest);
break ;
case CRSRequestEvent.COLLECT_NO_INPUT:
crsResponse = processCollectNoInputCommand(crsRequest);
break ;
case CRSRequestEvent.PLAY_COMPLETE:
crsResponse = processPlayCompleteCommand(crsRequest);
break ;
default :
}
|
Copier après la connexion
Après l'avoir écrit, vous constaterez qu'à mesure que les événements augmentent, ce code sera très long, et les fonctions de traitement de chaque événement sont également concentrées dans une seule classe, ce qui est difficile à maintenir. Par conséquent, grâce à la recherche et à l'apprentissage, nous avons découvert que nous pouvons utiliser les annotations + le mode stratégie + l'usine simple de Springboot pour éliminer le cas de commutation.
Refactor
Définir la structure
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 | public enum CRSEvent {
APP_START( "APP_START" ),
INIT_COMPLETE( "INIT_COMPLETE" ),
PLAY_COMPLETE( "PLAY_COMPLETE" ),
COLLECT_COMPLETE( "COLLECT_COMPLETE" ),
COLLECT_NO_INPUT( "COLLECT_NO_INPUT" ),
APP_END( "APP_END" ),
RESP_ERROR_CMD( "RESP_ERROR_CMD" );
private String event;
CRSEvent(String event){
this.event = event;
}
public String getEvent() {
return event;
}
public void setEvent(String event) {
this.event = event;
}
}
|
Copier après la connexion
Définir une annotation
1 2 3 4 5 6 | @Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @ interface CRSEventAnnotation {
CRSEvent value();
}
|
Copier après la connexion
Définir l'interface de traitement des événements
1 2 3 | public interface EventProcess {
CRSResponse execute(CRSRequest resquest);
}
|
Copier après la connexion
Toutes les classes de traitement du temps doivent implémenter cette interface. Parmi eux, exécuter est la méthode de traitement des événements
Écrivez une classe de traitement du temps spécifique
Ensuite, écrivez les classes de traitement des événements une par une, prenez l'exemple suivant :
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | @Component( "appStartProcess" )
@CRSEventAnnotation(value = CRSEvent.APP_START)
public class AppStartProcess implements EventProcess{
@Override
public CRSResponse execute(CRSRequest resquest) {
CRSResponse response = new CRSResponse();
response.setCommand(CRSResponseCmd.IVR_SESSION_INIT);
CRSResponse.Message message = new CRSResponse.Message();
message.setTts_vid( "65580" );
message.setTts_speed( "120" );
response.setMessage(message);
return response;
}
}
|
Copier après la connexion
Définissez la classe d'outils SpringContext
1 2 3 4 5 6 7 8 9 10 11 12 13 14 | @Component
public class SpringContextUtil implements ApplicationContextAware{
private ApplicationContext context;
public ApplicationContext getContext(){
return context;
}
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
this.context = applicationContext;
}
}
|
Copier après la connexion
Définir une usine de classe de traitement d'événements, utilisée pour produire divers objets de traitement d'événements
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 | @Component
public class EventProcessFactory {
@Autowired
SpringContextUtil contextUtil;
private static Map<CRSEvent, EventProcess> eventProcessMap = new ConcurrentHashMap<>();
public EventProcessFactory() {
Map<String, Object> beanMap = contextUtil.getContext().getBeansWithAnnotation(CRSEventAnnotation. class );
for (Object evetProcess : beanMap.values()) {
CRSEventAnnotation annotation = evetProcess.getClass().getAnnotation(CRSEventAnnotation. class );
eventProcessMap.put(annotation.value(), (EventProcess) evetProcess);
}
}
public static EventProcess createEventProcess(CRSEvent event){
return eventProcessMap.get(event);
}
}
|
Copier après la connexion
Modification du code d'appel
1 2 3 4 5 6 | CRSEvent crsEvent = CRSEvent.valueOf(crsRequest.getEvent());
EventProcess eventProcess = EventProcessFactory.createEventProcess(crsEvent);
if (eventProcess != null){
return eventProcess.execute(crsRequest);
}
return null;
|
Copier après la connexion
De cette façon, le code n'a pas de cas de commutation, et l'ajout d'un événement est également très simple, il suffit d'implémenter EventProcess interface.
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!