java代理模式

hrabbit.jpg

定义:

代理模式的主要作用是为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个对象不想或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。

代理模式的思想是为了提供额外的处理或者不同的操作而在实际对象与调用者之间插入一个代理对象。这些额外的操作通常需要与实际对象进行通信。

角色：

1， 抽象角色：声明真实对象和代理对象的共同接口。
2， 代理角色：代理对象角色内部含有对真实对象的引用，从而可以操作真实对象，同时代理对象提供与真实对象相同的接口以便在任何时刻都能代替真实对象。同时，代理对象可以在执行真实对象操作时，附加其他的操作，相当于对真实对象进行封装。
3， 真实角色：代理角色所代表的真实对象，是我们最终要引用的对象。

分类：

静态代理
静态代理也就是在程序运行前就已经存在代理类的字节码文件，代理类和委托类的关系在运行前就确定了。

1.静态代理

抽象角色，真实对象和代理对象共同的接口

public interface UserService {
    
   /**
     * 查询用户
     */
    public void queryUser();

   /**
     * 删除用户
     */
    public void deleteUser();
}

真实对象

public class UserServiceImpl implements UserService {

    @Override
    public void queryUser() {
        System.out.println("用户查询");
    }

    @Override
    public void deleteUser() {
        System.out.println("用户删除");
    }
}

代理对象

public class UserServiceProxy implements UserService {

    private UserService userService;

    public UserServiceProxy(UserService userService){
        userService = userService;
    }


    @Override
    public void queryUser() {
        //查询之前操作
        this.queryBefore();
        //执行查询用户
        System.out.println("查询张三用户信息");
        //查询之后操作
        this.queryAfter();
    }

    @Override
    public void deleteUser() {
        //删除之前操作
        this.deleteBefore();
        //删除功能
        System.out.println("删除张三用户信息");
        //删除之后操作
        this.deleteAfter();
    }


    /**
     * 查询之前的方法
     */
    public void queryBefore(){
        System.out.println("查询之前~");
    }
    /**
     * 查询之后的方法
     */
    public void queryAfter(){
        System.out.println("查询之后~");
    }

    /**
     * 删除之前的方法
     */
    public void deleteBefore(){
        System.out.println("删除之前~");
    }
    /**
     * 删除之后的方法
     */
    public void deleteAfter(){
        System.out.println("删除之后~");
    }
}

使用代理之后如何调用呢？

public class UserTest {
    public static void main(String[] args) {
        UserService userServiceImpl = new UserServiceImpl();
        UserService userProxy = new UserServiceProxy(userServiceImpl);
        userProxy.queryUser();
        userProxy.deleteUser();
    }
}

2. 动态代理

动态代理类的源码是程序在运行期间由JVM根据反射等机制动态生成的，所以不存在代理类的字节码文件。代理角色和真实角色的联系在程序运行时确定。

抽象角色，真实对象和代理对象共同的接口

public interface UserService {

    /**
     * 查询用户
     */
    public void queryUser();

    /**
     * 删除用户
     */
    public void deleteUser();
}

真实对象

public class UserServiceImpl implements UserService {

    @Override
    public void queryUser() {
        System.out.println("用户查询");
    }

    @Override
    public void deleteUser() {
        System.out.println("用户删除");
    }
}

代理角色处理器：

public class UserServiceHandler implements InvocationHandler {

    private UserService userService;

    public UserServiceHandler(UserService userService){
        this.userService = userService;
    }

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

        Object object = null;
        if (method.getName().equals("queryUser")) {
            //查询之前的方法
            this.queryBefore();
            //激活调用的方法
            object = method.invoke(userService, args);
            //查询之后执行的方法
            this.queryAfter();
        }else if (method.getName().equals("deleteUser")){
            //查询之前的方法
            this.queryBefore();
            //激活调用的方法
            object = method.invoke(userService, args);
            //查询之后执行的方法
            this.queryAfter();
        }

        return object;
    }

    /**
     * 查询之前的方法
     */
    public void queryBefore(){
        System.out.println("查询之前~");
    }
    /**
     * 查询之后的方法
     */
    public void queryAfter(){
        System.out.println("查询之后~");
    }

    /**
     * 删除之前的方法
     */
    public void deleteBefore(){
        System.out.println("删除之前~");
    }
    /**
     * 删除之后的方法
     */
    public void deleteAfter(){
        System.out.println("删除之后~");
    }

}

使用动态代理之后调用和静态代理有些不一样

public class UserTest {
    public static void main(String[] args) {
        UserService userServiceImpl = new UserServiceImpl();

        UserServiceHandler handler = new UserServiceHandler(userServiceImpl);

        UserService userProxy = (UserService) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(), new Class[]{UserService.class}, handler);

        userProxy.queryUser();
    }
}

优点：
业务类只需要关注业务逻辑本身，保证了业务类的重用性。这是代理的共有优点。
能够协调调用者和被调用者，在一定程度上降低了系统的耦合度。

缺点：
由于在客户端和真实主题之间增加了代理对象，因此有些类型的代理模式可能会造成请求的处理速度变慢，例如保护代理。
实现代理模式需要额外的工作，而且有些代理模式的实现过程较为复杂，例如远程代理。

个人博客:www.hrabbit.xin
码云地址:https://gitee.com/hrabbit