如何定义适配器adapter类_适配器模式与代理模式

适配器模式就相当于你的usb接口设备与type-C接口的设备不能直接拿数据线连接起来，但是可以通过转接线来实现两个设备的相连，适配器就相当于转接头。

适配器模式：将一个类的接口转换成客户希望的另外一个接口。Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以在一起工作。

模式中的角色

• – 目标接口（Target）：客户所期待的接口。目标可以是具体的或抽象的类，也可以是接口。
• – 需要适配的类（Adaptee）：需要适配的类或适配者类。
• – 适配器（Adapter）：通过包装一个需要适配的对象，把原接口转换成目标接口。

工作中的场景

• – 经常用来做旧系统改造和升级
• – 如果我们的系统开发之后再也不需要维护，那么很多模式都是没必要的，但是不幸的是，事实却是维护一个系统的代价往往是开发一个系统的数倍。

我们学习中见过的场景

• java.io.InputStreamReader(InputStream)
• java.io.OutputStreamWriter(OutputStream)

在这种情况下，两个类是无法直接进行连接的。

这时，我们可以采用适配器模式来解决。

有一个很简单的例子

/**
 * 被适配的类
 */
public class TypeC {
    public void request(){
        System.out.println("TypeC接口");
    }
}

目标类：

public interface Target {
    void handleReq();
}

适配器：

/**
 * 适配器
 */
public class Adapter extends TypeC implements Target {
    @Override
    public void handleReq() {
        super.request();
    }
}

测试：

public class Test {
    public static void main(String[] args){
        Target target = new Adapter();
        target.handleReq();
    }
}

这样就可以达成一个简单的适配器模式。

代理模式

所谓的代理者是指一个类别可以作为其它东西的接口。代理者可以作任何东西的接口：网上连接、存储器中的大对象、文件或其它昂贵或无法复制的资源。代理模式的核心作用是想要通过代理，控制对对象的访问！

常见的有可以详细控制访问某个（某类）对象的方法，在调用这个方法前做前置处理，调用这个方法后做后置处理。（即：AOP的微观实现！）

代理模式的角色：

– 核心角色：

• 抽象角色： 定义代理角色和真实角色的公共对外方法

• 真实角色：实现抽象角色，定义真实角色所要实现的业务逻辑，供代理角色调用。并且关注真正的业务逻辑！

• 代理角色：实现抽象角色，是真实角色的代理，通过真实角色的业务逻辑方法来实现抽象方法，并可以附加自己的操作，将统一的流程控制放到代理角色中处理。

应用场景：

• – 安全代理：屏蔽对真实角色的直接访问。
• – 远程代理：通过代理类处理远程方法调用(RMI)
• – 延迟加载：先加载轻量级的代理对象，真正需要再加载真实对象。 比如你要开发一个大文档查看软件，大文档中有大的图片，有可能一个图片有100MB，在打开文件时不可能将所有的图片都显示出来，这样就可以使用代理模式，当需要查看图片时，用proxy来进行大图片的打开。

静态代理(静态定义代理类) – 动态代理(动态生成代理类)

• JDK自带的动态代理
• javaassist字节码操作库实现
• CGLIB
• ASM(底层使用指令，可维护性较差)

静态代理(静态定义代理类)：

抽象角色

package com.lianxi.Proxy;

public interface Player {
    /**
     * 面谈
     */
    void confer();
    /**
     * 签合同
     */
    void signContract();
    /**
     * 订票
     */
    void bookTicket();
    /**
     * 参加比赛
     */
    void gaming();
    /**
     * 收钱
     */
    void collectMoney();
}

真实的对象：

package com.lianxi.Proxy;

public class RealPlayer implements Player {


    @Override
    public void confer() {
        System.out.println("RealStar.confer()");
    }

    @Override
    public void signContract() {
        System.out.println("RealStar.signContract()");
    }

    @Override
    public void bookTicket() {
        System.out.println("RealStar.bookTicket()");
    }

    @Override
    public void gaming() {
        System.out.println("RealStar(科比本人).gaming()");
    }

    @Override
    public void collectMoney() {
        System.out.println("RealStar.collectMoney()");
    }
}

代理对象：

package com.lianxi.Proxy;

public class ProxyPlayer implements Player {

    private Player player;

    @Override
    public void confer() {
        System.out.println("ProxyStar.confer()");
    }

    @Override
    public void signContract() {
        System.out.println("ProxyStar.signContract()");
    }

    @Override
    public void bookTicket() {
        System.out.println("ProxyStar.bookTicket()");
    }

    @Override
    public void gaming() {
        this.player.gaming();
    }

    @Override
    public void collectMoney() {
        System.out.println("ProxyStar.collectMoney()");
    }

    public ProxyPlayer(Player player) {
        this.player = player;
    }
}

测试：

package com.lianxi.Proxy;

public class Test1 {
    public static void main(String[] args){
        Player realPlayer = new RealPlayer();
        ProxyPlayer proxyPlayer = new ProxyPlayer(realPlayer);
        proxyPlayer.bookTicket();
        proxyPlayer.collectMoney();
        proxyPlayer.confer();
        proxyPlayer.gaming();
    }

}

输出：

这样就能实现静态代理。

动态代理相比于静态代理的优点

抽象角色中(接口)声明的所有方法都被转移到调用处理器一个集中的方法中处理，这样，我们可以更加灵活和统一的处理众多的方法。

JDK自带的动态代理

– java.lang.reflect.Proxy

• 作用：动态生成代理类和对象 java.lang.reflect.InvocationHandler(处理器接口)

• 可以通过invoke方法实现对真实角色的代理访问。

• 每次通过Proxy生成代理类对象对象时都要指定对应的处理器对象

上面的例子加上动态代理的处理器：

package com.lianxi.Proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class PlayerHandler  implements InvocationHandler {
    Player player;

    public PlayerHandler(Player player) {
        this.player = player;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object object = null;

        System.out.println("真正的方法执行前！");
        System.out.println("面谈，签合同，预付款，订机票");

        if(method.getName().equals("gaming")){
            object = method.invoke(player, args);
        }

        System.out.println("真正的方法执行后！");
        System.out.println("收尾款");
        return object;
    }
}

测试：

public class Test1 {
    public static void main(String[] args){
        Player player = new RealPlayer();
        PlayerHandler playerHandler = new PlayerHandler(player);
        Player instance = (Player) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(),
                new Class[]{Player.class}, playerHandler);
        instance.gaming();
    }
}

结果：

这样就可以实现动态的代理。

开发框架中应用场景：

• struts2中拦截器的实现
• 数据库连接池关闭处理
• Hibernate中延时加载的实现
• mybatis中实现拦截器插件
• AspectJ的实现
• pring中AOP的实现
• 日志拦截
• 声明式事务处理
• web serviceRMI远程方法调用