Mode d'adaptateur graphique Java design patterns

Adaptateurs exemples de la vie réelle de

Thai prise avec les deux trous (norme européenne), peut acheter une prise de l'adaptateur multifonction (adaptateur) pour que vous puissiez utiliser.

Mode adaptateur introduction de base

1) Mode adaptateur (Pattern Adapter) converti en une interface, une interface client représente une autre désirée, le but principal est de compatibilité, de sorte que l'interface ne correspond pas à l'origine ne peut pas être due à des travaux avec deux classes peuvent travailler ensemble. Quels alias enveloppe (Wrapper)
2) sont en mode d'adaptation structurelle mode
3) divisé en trois catégories: le mode adaptateur de classe, le mode d'adaptateur d'objet, le mode d'adaptateur d'interface

fonctionne en mode adaptateur

Works
1) Mode adaptateur: Convertir l'interface d'une classe dans une autre interface: pour que l'interface d' origine n'est pas classe compatible compatible
2) du point de l'utilisateur de vue ne peut pas être adapté qui est découplé
3) les appels utilisateurs cible de conversion adaptateur d'interface sur la méthode, alors l'appel de l'adaptateur est adapté au procédé d'interface correspondant
4) , l'utilisateur reçoit le résultat de rétroaction, et l'interaction d'interface cible en tant que sensation

Classe modèle Adaptateur

modèle d'adaptateur de classe décrit
les notions de base: classe adaptateur par héritage de la classe src, dst implémenter l'interface de classe, complète src - « adaptation dst.
Exemple de classe modèle adaptateur d' application
1) Un exemple illustre
d'exemple pour expliquer la vie de l'adaptateur chargeur, le chargeur lui - même par rapport adaptateur, 220 V AC par rapport au src (c.- à -ajusteur), notre objectif DST (c.- à -cible) est 5V DC
2) analyse Thought (classe FIG)

package com.example.demo.adapter.classadapter;

public class Voltage220V {
	/**
	 * 输出220V的电压
	 */
	public int output220V() {
		int src = 220;
		System.out.println("电压 = " + src + "伏");
		return src;
	}
}
package com.example.demo.adapter.classadapter;

public interface IVoltage5V {
	int output5V();
}
package com.example.demo.adapter.classadapter;

/**
 * 适配器类
 * @author zhaozhaohai
 *
 */
public class VoltageAdapter extends Voltage220V implements IVoltage5V{

	@Override
	public int output5V() {
		// 获取到220V电压
		int srcV = output220V();
		// 转成5v
		int dstV = srcV / 44;
		return dstV;
	}

}
package com.example.demo.adapter.classadapter;

public class Phone {
	
	/**
	 * 充电
	 * @param iVoltage5V
	 */
	public void charging(IVoltage5V iVoltage5V) {
		if (iVoltage5V.output5V() == 5) {
			System.out.println("电压为5V，可以充电～～");
		} else if (iVoltage5V.output5V() > 5) {
			System.out.println("电压大于5V，不能充电～～");
		}
	}
}
package com.example.demo.adapter.classadapter;

public class Client {
	public static void main(String[] args) {
		System.out.println(" === 类适配器模式 ===");
		Phone phone = new Phone();
		phone.charging(new VoltageAdapter());
	}
}

modèle classe adaptateur billets et détails

1) Java est un mécanisme d'héritage, de sorte que les classes doivent Hériter src classe d'adaptateur qui peut être considéré comme un inconvénient , car il nécessite dst doit être une interface, il y a certaines limites;
2) la classe de méthodes sera exposée dans l'adaptateur, a également augmenté le coût d'utilisation.
3) En raison de sa classe héritée src, il peut donc remplacer la méthode en fonction des besoins de la classe src, de sorte que la flexibilité accrue classe adaptateur.

Objet en mode Adaptateur

1) les idées de base et de la même classe d'adaptateur de modèle, mais sera modifiée classe adaptateur, pas hérité classe src, mais la classe tenue instance src, pour résoudre les problèmes de compatibilité. A savoir: la classe détient Src, l' interface de classe dst pour obtenir src complète - « adaptateur dst
2) » Synthèse des principes multiplexage », dans le système pour utiliser l' association (agrégation) au lieu de l' héritage des relations.
3) adaptateur de mode d'adaptateur d'objet est couramment utilisé comme modèle

package com.example.demo.adapter.objectadapter;

/**
 * 被适配的类
 * @author zhaozhaohai
 *
 */
public class Voltage220V {
	/**
	 * 输出220V的电压
	 */
	public int output220V() {
		int src = 220;
		System.out.println("电压 = " + src + "伏");
		return src;
	}
}
package com.example.demo.adapter.objectadapter;

/**
 * 适配接口
 * @author zhaozhaohai
 *
 */
public interface IVoltage5V {
	int output5V();
}
package com.example.demo.adapter.objectadapter;

/**
 * 适配器类
 * @author zhaozhaohai
 *
 */
public class VoltageAdapter implements IVoltage5V{
	/**
	 * 关联关系 - 聚合
	 */
	private Voltage220V voltage220V;
	
	/**
	 * 通过构造器，传入一个Voltage220V 实例
	 * @param voltage220v
	 */
	public VoltageAdapter(Voltage220V voltage220v) {
		this.voltage220V = voltage220v;
	}

	@Override
	public int output5V() {
		int dstV = 0;
		if (voltage220V != null) {
			// 获取220V 电压
			int src = voltage220V.output220V();
			System.out.println("使用对象适配器，进行适配～～");
			dstV = src / 44;
			System.out.println("适配完成，输出的电压为 = " + dstV);
		}
		return dstV;
	}

}
package com.example.demo.adapter.objectadapter;

public class Phone {
	
	/**
	 * 充电
	 * @param iVoltage5V
	 */
	public void charging(IVoltage5V iVoltage5V) {
		if (iVoltage5V.output5V() == 5) {
			System.out.println("电压为5V，可以充电～～");
		} else if (iVoltage5V.output5V() > 5) {
			System.out.println("电压大于5V，不能充电～～");
		}
	}
}
package com.example.demo.adapter.objectadapter;

public class Client {
	public static void main(String[] args) {
		System.out.println(" === 对象适配器模式 ===");
		Phone phone = new Phone();
		phone.charging(new VoltageAdapter(new Voltage220V()));
	}
}

motif adaptateur d'objet et les détails Mises en garde

1) Adaptateur objet et adaptateur de classe , en fait , être la même idée, mais réalisé de différentes manières.
Le principe de multiplexage synthétique, une combinaison de l' héritage alternatif, de façon à traiter les limites de l'adaptateur doit hériter des classes de src, dst doit être ne nécessite plus l'interface.
Baissez 2) le coût, et plus souple.

Mode adaptateur d'interface

1) certains livres appelés: mode adaptateur (Pattern adaptateur par défaut) ou en mode adaptateur par défaut.
2) Si aucune interface fournit une méthode pour réaliser le plein, peut être conçu pour implémenter une interface de classe abstraite et fournir une implémentation (par défaut de méthode vide) méthode pour chaque interface, la sous - classe abstraite de cette classe peut être sélectivement méthode passer outre certaines exigences de mise en œuvre de la classe parente de classe à
cas 3) applique à tous veulent utiliser celui - ci une méthode d'interface

package com.example.demo.adapter.interfaceadapter;

public interface Interface4 {
	
	public void m1();
	
	public void m2();
	
	public void m3();
	
	public void m4();

}
package com.example.demo.adapter.interfaceadapter;

/**
 * 在AbsAdapter 我们将Interface4 的方法进行默认实现
 * @author zhaozhaohai
 *
 */
public abstract class AbsAdapter implements Interface4{
	@Override
	public void m1() {
		// TODO Auto-generated method stub
		
	}
	
	@Override
	public void m2() {
		// TODO Auto-generated method stub
		
	}
	
	@Override
	public void m3() {
		// TODO Auto-generated method stub
		
	}
	
	@Override
	public void m4() {
		// TODO Auto-generated method stub
		
	}
}
package com.example.demo.adapter.interfaceadapter;

public class Client {
	public static void main(String[] args) {
		AbsAdapter absAdapter = new AbsAdapter() {
			
			/**
			 * 只需要去覆盖我们需要使用的接口方法
			 */
			@Override
			public void m1() {
				System.out.println("使用类m1的方法");
			}
			
		};
		absAdapter.m1();
	}
}

Cadre mode adaptateur d'analyse dans l'application source SpringMVC

1) SpringMVC dans HandlerAdapter, sur l'utilisation du mode adaptateur classe
examen demande de traitement de flux SpringMVC 2)



(1) à la carte du contrôleur par le HandlerMapping
(2) pour obtenir l'adaptateur
(3) au moyen d'un contrôleur d'appel de l' adaptateur et les retours ModelAndView
mis en œuvre sous dans HandlerAdapter de classe, chaque contrôleur il y a une utilisation de la classe d'implémentation de l' adaptateur correspondant, chaque contrôleur il y a différentes implémentations
l'utilisation de la raison analyse de HandlerAdapter 3):
vous pouvez voir les différents types de processeurs, ont plusieurs implémentations, l'appel sur le chemin il est pas certain, si vous avez besoin d'appeler la méthode Controller directement, vous devez appeler lorsque vous avez besoin de l'utilisation constante si d' autre pour juger quel type de graines, puis exécuté. Donc , si vous voulez étendre derrière Controller, vous devez modifier le code original, de sorte que contraire aux principes de l' OCP.
4) mains SpringMVC obtenir à écrire le code source correspondant via un adaptateur modèle de conception du contrôleur

package com.example.demo.adapter.sprringmvc;


/**
 * 多种Controller实现
 * @author zhaozhaohai
 *
 */
public interface Controller {

}

class HttpController implements Controller {
	public void doHttpHandler() {
		System.out.println("http....");
	}
}

class SimpleController implements Controller {
	public void doSimplerHandler() {
		System.out.println("simple...");
	}
}

class AnnotationController implements Controller {
	public void doAnnotationHandler() {
		System.out.println("annotation...");
	}
}
package com.example.demo.adapter.sprringmvc;


/**
 * 定义一个Adapter接口
 * @author zhaozhaohai
 *
 */
public interface HandlerAdapter {
	public boolean supports(Object handler);
	
	public void handle(Object handler);
}

/**
 * 多种适配器类
 * @author zhaozhaohai
 *
 */
class SimpleHandlerAdapter implements HandlerAdapter {

	@Override
	public boolean supports(Object handler) {
		return handler instanceof SimpleController;
	}

	@Override
	public void handle(Object handler) {
		((SimpleController) handler).doSimplerHandler();
	}
	
}

class HttpHandlerAdapter implements HandlerAdapter {

	@Override
	public boolean supports(Object handler) {
		return handler instanceof HttpController;
	}

	@Override
	public void handle(Object handler) {
		((HttpController) handler).doHttpHandler();
	}
	
}

class AnnotationHandlerAdapter implements HandlerAdapter {

	@Override
	public boolean supports(Object handler) {
		return handler instanceof AnnotationController;
	}

	@Override
	public void handle(Object handler) {
		((AnnotationController) handler).doAnnotationHandler();
	}
	
}
package com.example.demo.adapter.sprringmvc;

import java.util.ArrayList;
import java.util.List;


public class DispatchServlet {
	
	public static List<HandlerAdapter> handlerAdapters = new ArrayList<HandlerAdapter>();

	public DispatchServlet() {
		handlerAdapters.add(new AnnotationHandlerAdapter());
		handlerAdapters.add(new HttpHandlerAdapter());
		handlerAdapters.add(new SimpleHandlerAdapter());
	}
	
	public void doDispatch() {
		// 此处模拟SpringMVC从request取handler的对象，
		// 适配器可以获取到希望的Controller
		// HttpController controller = new HttpController（）；
		AnnotationController controller = new AnnotationController();
		// SimpleController controller = new SimpleController();
		// 得到对应适配器
		HandlerAdapter adapter = getHandler(controller);
		// 通过适配器执行对应的Controller对应方法
		adapter.handle(controller);
	}

	private HandlerAdapter getHandler(AnnotationController controller) {
		for (HandlerAdapter adapter : this.handlerAdapters) {
			if (adapter.supports(controller)) {
				return adapter;
			}
		}
		return null;
	}
	
	public static void main(String[] args) {
		new DispatchServlet().doDispatch();
	}
}

Description:
. 1) définit une interface d'adaptation au printemps, chaque contrôleur afin qu'il y ait une classe d'implémentation de l' adaptateur correspondant
2) au lieu de l'adaptateur contrôleur méthode respective
3) le contrôleur étendu, seulement besoin d'ajouter une classe d'adaptateur pour compléter la classe SpringMVC classe étendue
4) c'est la puissance des modèles de conception

Notes et détails du modèle adaptateur

1) trois nommés, est basée sur src est la forme que pour donner adaptateur (adaptateur sous la forme) soit nommé.
2) classe d'adaptateur: la classe pour donner, dans les années adaptateur, il est à src que les classes, l' héritage
adaptateur d'objet: l'objet est de donner, dans l'adaptateur dans le src comme un objet, maintenez
l'adaptateur d'interface: pour donner à l'interface, en Adapter dans le src d'interface,
3) Adapter le plus grand modèle est à l' origine des interfaces incompatibles à travailler ensemble
4) le développement réel, à mettre en œuvre ne pas adhérer strictement aux trois formes classiques