设计模式之适配器模式和代理模式

1.适配器模式

将一个类的接口转换成客户希望的另一个接口，使得原本接口不兼容而不能一起工作的类可以一起工作

应用场景：1.《设计模式》中提到如果想使用一个已经存在的类，但它的接口与你的要求不一致，可以使用设计模式

                   2.我自己的一点认识，Java中就是如果一个类需要实现某个接口中的部分方法，如果通过直接继承该接口的话，需要去实现所有的

方法但是如果先用一个类继承 该 接 口，然后所有方法采用空实现，其他类再去继承该类则避免了要对接口的所有方法进行实现

代码：

//1.场景1
//客户希望的的的接口
public interface Target{
    public void request();
}

//当前使用的类
public class MyClass{
    public void specificRequest(){
        ……
    }
}

//使用适配器使得能提供客户需要的接口
public class TargetClass extends MyClass implements Target{
   
    @Override
    public void request(){
        super.specificRequest();
    }
}


//场景2
//想使用的接口
public interface Resource{
    public void method1();
    public void method2();
    ……
}

//只需要使用接口中的 method1方法的类，直接继承的情况
public class PartOfResource implements Resource{
    public void method1(){
        System.out.println("method1……")
    }
    
    public void method2(){}
    public void method3(){}
    ……
}

//适配器类
public class ResourceAdapter implements Resource{
    public void method1(){}
    public void method2(){}
    public void method3(){}
    ……
}

//只需要使用接口中的 method1方法的类，间接继承的情况
public class PartOfResource extends ResourceAdapter{
     public void method1(){
        System.out.println("method1……")
    }
}

2.代理模式

为其他对象提供一种代理以控制对这个对象的访问

代码：

public abstract Subject{
    public abstract void Request();
}

public class RealSubject extends Subject{
    @Override
    public void Request(){
        System.out.println("RealSubject");
    }
}

public class SubjectProxy extends Subject{
    RealSubject  realSubject;
    @Override
    public void Request(){
    if(realSubject==null){
        realSubject=new RealSubject();
    }
    realSubject.Request();
    }
}
//1.静态代理
public interface Ilogin(){
    public void login();
    public void logout();
}

public class RealLogin implements Ilogin{
    public void login(){
        System.out.println("login……");
    }
    
    public void logout(){
        System.out.println("logout……");
    }
}

public class LoginProxy implements Ilogin{
    private RealLogin realLogin;
     public void login(){
        System.out.println("go to login");
        realLogin.login();
        System.out.println("login success");
    }
    
    public void logout(){
        System.out.println("go to logout");
        realLogin.logout();
        System.out.println("logout success");
    }
}

//思考一个问题，如何避免重复的代码？没错，使用反射
//2.动态代理,JDK中提供一个Proxy类
public class MyInvocationHandler implements InvocationHandler{
    private Object target;  
 
    public MyInvocationHandler(Object target){  
        this.target = target;  
    }  
    
    
    @Override  
    public Object invoke(Object proxy, Method method, Object[] args)throws Throwable {
        
         System.out.println("begin……");
         Object retValue = method.invoke(target, args);
         System.out.println("end……");
    }

}
//测试类
public class Test{
    public static void main(String[] args){
        Ilogin target=new RealLogin();
        InvocationHandler handler=new MyInvocationHandler(target);
        Ilogin proxy=(Ilogin)Proxy.newProxyInstance(target.getClass().getClassLoader(),
        target.getClass().getInterfaces(),handler);
        proxy.login();
        proxy.logout();
    }
}