Java中的代理设计模式

最新推荐文章于 2024-02-22 10:22:21 发布

叶之暮风

最新推荐文章于 2024-02-22 10:22:21 发布

阅读量4.5k

点赞数 6

分类专栏： java代理模式文章标签： java 设计模式

本文链接：https://blog.csdn.net/qq_33214833/article/details/70230891

版权

java代理模式专栏收录该内容

1 篇文章 0 订阅

订阅专栏

- Java中的代理模式（proxty）

代理是一种常用的设计模式，代理模式可以对原有的类进行扩展，即通过代理对象的模式来访问目标类。最通俗的例子就是假设我们想邀请一位明星,那么并不是直接连接明星,而是联系明星的经纪人,来达到同样的目的.明星就是一个目标对象,他只要负责活动中的节目,而其他琐碎的事情就交给他的代理人(经纪人)来解决.这就是代理思想在现实中的一个例子。

1静态代理
静态代理需要代理类与目标类有一样的继承父类和实现接口，例子：
现在有一个类，知道它实现的接口，且只有添加和删除操作，现在要在他的添加和删除操作前和后分别添加操作，使用静态代理实现
接口：

package com.hdeasy.staticProxy;

/**
 * Created by ZHAOWANXIN on 2017/4/18.
 */
public interface UserDao {
    public void addUser();

    public void deleteUser();
}

目标类：

package com.hdeasy.staticProxy;

/**
 * Created by ZHAOWANXIN on 2017/4/18.
 */
public class DbUser implements UserDao {
    @Override
    public void addUser() {
        System.out.println("添加用户操作");
    }

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

静态代理类

package com.hdeasy.staticProxy;

/**
 * Created by ZHAOWANXIN on 2017/4/18.
 */
public class StaticProxyUser implements UserDao {
    private DbUser target;

    public StaticProxyUser(DbUser dbUser) {
        target = dbUser;
    }

    @Override
    public void addUser() {
        System.out.println("添加前的操作");
        target.addUser();
        System.out.println("添加后的操作");
    }

    @Override
    public void deleteUser() {
        System.out.println("删除前的操作");
        target.deleteUser();
        System.out.println("删除后的操作");
    }
}

测试类

package com.hdeasy.staticProxy;

import org.junit.Test;

/**
 * Created by ZHAOWANXIN on 2017/4/18.
 */
public class MyTest {
    @Test
    public void demo() {

        StaticProxyUser staticProxyUser = new StaticProxyUser(new DbUser());
        staticProxyUser.addUser();
        staticProxyUser.deleteUser();
    }
}

执行结果
这里写图片描述
通过执行结构的对比我们可以看到我们实现了开始的要求

* 静态代理总结:

1.可以做到在不修改目标对象的功能前提下,对目标功能扩展.
2.缺点:
因为代理对象需要与目标对象实现一样的接口,所以会有很多代理类,类太多.同时,一旦接口增加方法,目标对象与代理对象都要维护.

2动态代理（JDK代理）
动态代理不用实现目标类的接口，不会出现大量代理类的现象，一般情况下创建一个代理类就可以了。
动态代理对象的生成,是利用JDK的API,动态的在内存中构建代理对象(需要我们指定创建代理对象/目标对象实现的接口的类型)
动态代理也叫做:JDK代理,接口代理
动态代理需要使用newProxyInstance方法，该方法结构为static Object newProxyInstance(ClassLoader loader， Class<问号>] interfaces,InvocationHandler h )，可以看到该方法需要三个参数
参数1：ClassLoader 需要一个类加载器，Java中常用的类加载器有三种类型
启动类加载器(Bootstrap ClassLoader):

　　　　这个类加载器负责将\lib目录下的类库加载到虚拟机内存中,用来加载java的核心库,此类加载器并不继承于java.lang.ClassLoader,不能被java程序直接调用,代码是使用C++编写的.是虚拟机自身的一部分.

　　　扩展类加载器(Extendsion ClassLoader):
　　　　这个类加载器负责加载\lib\ext目录下的类库,用来加载java的扩展库,开发者可以直接使用这个类加载器.

　　　应用程序类加载器(Application ClassLoader):

　　　　这个类加载器负责加载用户类路径(CLASSPATH)下的类库,一般我们编写的java类都是由这个类加载器加载,这个类加载器是CLassLoader中的getSystemClassLoader()方法的返回值,所以也称为系统类加载器.一般情况下这就是系统默认的类加载器.

　　除此之外,我们还可以加入自己定义的类加载器,以满足特殊的需求,需要继承java.lang.ClassLoader类.
　　参数2：Class <问好>[] interfaces,:目标对象实现的接口的类型,使用泛型方式确认类型
　　参数3：InvocationHandler h:事件处理,执行目标对象的方法时,会触发事件处理器的方法,会把当前执行目标对象的方法作为参数传入
　　接口：
　　

package com.hdeasy.test.service;

/**
 * Created by ZHAOWANXIN on 2017/4/18.
 */
public interface UserService {
    public void addUser();

    public void updateUser();

    public void deleteUser();
}

目标类

package com.hdeasy.test.service;

/**
 * Created by ZHAOWANXIN on 2017/4/18.
 */
public class UserServiceImpl implements UserService {
    @Override
    public void addUser() {
        System.out.println("添加用户");
    }

    @Override
    public void updateUser() {
        System.out.println("更新用户");
    }

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

代理类

package com.hdeasy.test.factory;

import com.hdeasy.test.aspect.MyAspect;
import com.hdeasy.test.service.UserService;
import com.hdeasy.test.service.UserServiceImpl;

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

/**
 * Created by ZHAOWANXIN on 2017/4/18.
 */
public class MyBeanFactory {
    public static UserService createUserservice() {
        //目标类
        final UserService userService = new UserServiceImpl();
        //生成代理类
        UserService proxyService = (UserService) Proxy.newProxyInstance(MyBeanFactory.class.getClassLoader(), userService.getClass().getInterfaces(), new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("执行前");
                Object obj = method.invoke(userService, args);
                System.out.println("执行后");
                System.out.println("========");
                return obj;
            }
        });
        return proxyService;
    }
}

测试类

package com.hdeasy.test;

import com.hdeasy.test.factory.MyBeanFactory;
import com.hdeasy.test.service.UserService;
import org.junit.Test;

/**
 * Created by ZHAOWANXIN on 2017/4/18.
 */
public class test {
    @Test
    public void demo() {
        UserService userService = MyBeanFactory.createUserservice();
        userService.addUser();
        userService.updateUser();
        userService.deleteUser();
    }
}

执行结果
这里写图片描述
3CGLIB代理
上面的静态代理和动态代理模式都是要求目标对象是实现一个接口的目标对象,但是有时候目标对象只是一个单独的对象,并没有实现任何的接口,这个时候就可以使用以目标对象子类的方式类实现代理,这种方法就叫做:Cglib代理

Cglib代理,也叫作子类代理,它是在内存中构建一个子类对象从而实现对目标对象功能的扩展.

JDK的动态代理有一个限制,就是使用动态代理的对象必须实现一个或多个接口,如果想代理没有实现接口的类,就可以使用Cglib实现.
Cglib是一个强大的高性能的代码生成包,它可以在运行期扩展java类与实现java接口.它广泛的被许多AOP的框架使用,例如Spring AOP和synaop,为他们提供方法的interception(拦截)
Cglib包的底层是通过使用一个小而块的字节码处理框架ASM来转换字节码并生成新的类.不鼓励直接使用ASM,因为它要求你必须对JVM内部结构包括class文件的格式和指令集都很熟悉.
Cglib子类代理实现方法:
1.需要引入cglib的jar文件,但是Spring的核心包中已经包括了Cglib功能,所以直接引入pring-core-3.2.5.jar即可.
2.引入功能包后,就可以在内存中动态构建子类
3.代理的类不能为final,否则报错
4.目标对象的方法如果为final/static,那么就不会被拦截,即不会执行目标对象额外的业务方法.
接口和目标类同上
代理类：

package com.hdeasy.test.factory;

import com.hdeasy.test.aspect.MyAspect;
import com.hdeasy.test.service.UserService;
import com.hdeasy.test.service.UserServiceImpl;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

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

/**
 * Created by ZHAOWANXIN on 2017/4/18.
 */
public class MyBeanFactory {
    //cglib代理
    public static UserService createUserService() {
        //目标类
        final UserService userService = new UserServiceImpl();
        /**
         * 代理类
         * 回掉函数中的intercept同jdk动态代理的invoke方法
         * 4个参数，前三个同jdk动态代理的参数
         * 第四个参数：methodProxy是目标类的方法的代理
         *
         */
        //1.1核心类
        Enhancer enhancer = new Enhancer();
        //1.2确定父类
        enhancer.setSuperclass(UserService.class);
        //1.3设置回掉函数
        enhancer.setCallback(new MethodInterceptor() {
            @Override
            public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
                System.out.println("执行前");
                Object invoke = method.invoke(userService, args);
                System.out.println("执行后");
                return invoke;
            }
        });
        //1.4创建代理对象
        UserService proxyUserService = (UserService) enhancer.create();
        return proxyUserService;
    }
}

测试类：

package com.hdeasy.test;

import com.hdeasy.test.factory.MyBeanFactory;
import com.hdeasy.test.service.UserService;
import org.junit.Test;

/**
 * Created by ZHAOWANXIN on 2017/4/18.
 */
public class test {
    @Test
    public void demo() {
        UserService userService = MyBeanFactory.createUserService();
        userService.addUser();
        userService.updateUser();
        userService.deleteUser();
    }
}

执行结果：
这里写图片描述、
使用时如果目标对象没有实现接口可以采用cglib代理，目标类实现了接口采用jdk动态代理，静态代理一般不建议使用。

叶之暮风

关注

6
点赞
踩
17

收藏

觉得还不错? 一键收藏
1
评论
Java中的代理设计模式

- Java中的代理模式（proxty）代理是一种常用的设计模式，代理模式可以对原有的类进行扩展，即通过代理对象的模式来访问目标类。最通俗的例子就是假设我们想邀请一位明星,那么并不是直接连接明星,而是联系明星的经纪人,来达到同样的目的.明星就是一个目标对象,他只要负责活动中的节目,而其他琐碎的事情就交给他的代理人(经纪人)来解决.这就是代理思想在现实中的一个例子。1静态代理静态代理需要代理
复制链接

扫一扫