标签：Adapter return String Pattern 适配器 public adapter login class
适配器模式(Adapter Pattern)
他的功能是将一个类的接口变成客户端所期望的另一种接口，从而使得原本因接口不匹配而不能一起工作的类一起工作。简而言之，就是之前有一个功能，但是新的功能需要原有的功能的一些代码，我们不想新开发，所以就新建一个适配器，使得可以使用。类似，手机充电转接头的功能，我们手机充电器有很头，双头的三头的，我们可以使用一个转接头，把三头的，二头的都插入转接头，然后转接头进行电量的输入。功能：解决不同功能兼容性问题 通用写法：类适配、接口适配、对象适配
Class Adapter
public class AC220 {
public int outputAC220(){
int output=220;
System.out.println("outPut"+output);
return output;
}
}
public interface DC5 {
int output5();
}
public class PowerAdapter extends AC220 implements DC5 {
public int output5() {
int adapterInput=super.outputAC220();
int adaptOutput=adapterInput/44;
System.out.println("adapterInput:"+adapterInput+"adaptOutput:"+adaptOutput);
return adaptOutput;
}
}
To test
public class Test {
public static void main(String[] args) {
DC5 powerAdapter=new PowerAdapter();
powerAdapter.output5();
}
}
To explain
The Least Knowledge Principle would be against(bacause in PowerAdapter we can use methods of AC220)
Object adapter
public class PowerAdapter implements DC5 {
private AC220 ac220;
public PowerAdapter(AC220 ac220) {
this.ac220 = ac220;
}
public int output5() {
int adapterInput=ac220.outputAC220();
int adaptOutput=adapterInput/44;
System.out.println("adapterInput:"+adapterInput+"adaptOutput:"+adaptOutput);
return adaptOutput;
}
}
To explain
Actually，we just pass on object by construction,the problem of Least Knowledge Principle will be solved easily, but do we need create each adapter for each new classes?it is too complex to create adatper for each new classes ,so we use interface adapter to solve the problem
interface adapter
public class PowerAdapter implements DC {
private AC220 ac220;
public PowerAdapter(AC220 ac220) {
this.ac220 = ac220;
}
public int outPut5V() {
// can be use
ac220.outputAC220();
System.out.println("outPut5V");
return 5;
}
public int outPut12V() {
// can be use
ac220.outputAC220();
return 12;
}
public int outPut24V() {
// can be use
ac220.outputAC220();
System.out.println("outPut24V");
return 24;
}
}
public interface DC {
int outPut5V();
int outPut12V();
int outPut24V();
}
To Test
public class Test {
public static void main(String[] args) {
DC powerAdapter=new PowerAdapter(new AC220());
powerAdapter.outPut5V();
powerAdapter.outPut12V();
powerAdapter.outPut24V();
}
}
To explain
apparently, Interface Adapter like a proxy pattern,we pass on class named AC220 then to reconstruct method of class of AC220
A scene of login to illustrate how to use Adapter Pattern
that is our kernel class to process logic of login
public class LoginService {
// to do register
protected ResultMeg register(String userName, String password) {
System.out.println("succeed in register" + userName + ":" + password);
return null;
}
// to do login
protected ResultMeg login(String userName, String password) {
System.out.println("succeed in login" + userName + ":" + password);
return null;
}
}
we need an adapter to redirect all of third party login
- we create an interface to restrict all thrid part login(IPassportForThird)
- we extends LoginService ,which can use method of LoginService(actually,that is class that we shoud adapt)
- because each thrid part login have different logic,we haven't to write all logic in the same class named LoginAdapterForThird,so we have to have a method named processLogin to distribute all requirement into each calsses
tips: the method named support is to verify rationality of classes
public class LoginAdapterForThird implements IPassportForThird {
// login for QQ
public ResultMeg loginForQQ(String openId) {
return processLogin(openId, LoginForQQAdapter.class);
}
// login for WeChat
public ResultMeg loginForWeChat(String openId) {
return processLogin(openId, LoginForWeChatAdapter.class);
}
// login for Token
public ResultMeg loginForToken(String token) {
return processLogin(token, LoginForTokenAdapter.class);
}
// all third part login are distributed with this method
private ResultMeg processLogin(String id, Class<? extends ILoginAdapter> clazz) {
try {
ILoginAdapter iLoginAdapter = clazz.newInstance();
if (iLoginAdapter.support(iLoginAdapter)) {
return iLoginAdapter.login(id, iLoginAdapter);
}
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
}
public interface IPassportForThird {
ResultMeg loginForQQ(String openId);
ResultMeg loginForWeChat(String openId);
ResultMeg loginForToken(String token);
}
Then each adapter have to has two methods one of is method named support the other is login,Two of them are ruled by ILoginAdapter
public interface ILoginAdapter {
boolean support(Object o);
ResultMeg login(String id, Object adapter);
}
each adapter have to has logic of LoginService ,which means each adapter should extends LoginService implements ILoginAdapter,do we need to create an abstract class to write some common method and make each adapter extends AbstractAdapter?,we do!
public abstract class AbstractAdapter extends LoginService implements ILoginAdapter {
ResultMeg loginForRegister(String userName, String password) {
if (null == password) {
password = "EMPTY_THIRD";
}
super.register(userName, password);
return super.login(userName, password);
}
}
each adapter like them
public class LoginForQQAdapter extends AbstractAdapter{
public boolean support(Object o) {
return o instanceof LoginForQQAdapter;
}
public ResultMeg login(String id, Object adapter) {
System.out.println("LoginForQQAdapter");
return super.loginForRegister(id,null); }
}
public class LoginForTokenAdapter extends AbstractAdapter {
public boolean support(Object o) {
return o instanceof LoginForTokenAdapter; }
public ResultMeg login(String id, Object adapter) {
System.out.println("LoginForTokenAdapter");
return super.loginForRegister(id,null); }
}
public class LoginForWeChatAdapter extends AbstractAdapter {
public boolean support(Object o) {
return o instanceof LoginForWeChatAdapter;
}
public ResultMeg login(String id, Object adapter) {
System.out.println("LoginForWeChatAdapter");
return super.loginForRegister(id,null);
}
}
To test(we can use LoginAdapterForThird to get different method to login)
public class Test {
public static void main(String[] args) {
LoginAdapterForThird loginAdapterForThird=new LoginAdapterForThird();
loginAdapterForThird.loginForQQ("121212");
}
}
additional class
public class ResultMeg {
String code;
String message;
}
How does the adpater use in source of code
org.springframework.aop.framework.adapter.AdvisorAdapter（its classes that implementing it are all like what we wrote-(its supportsAdvice like our method named support,dosen't it)
）
org.springframework.web.servlet.HandlerAdapter
Sum up
advantages:
- the classes can be reused,and do not need to be change
- raise expansibility of system as you see if you want add a new function just add a new adapter
disadvantages:
- raise complexity of system(we have to add many new adaoters)
- raise difficulty of reading
标签：Adapter,return,String,Pattern,适配器,public,adapter,login,class 来源： https://www.cnblogs.com/UpGx/p/14711296.html
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。