Java高级特性之动态代理

最新推荐文章于 2023-05-18 08:31:12 发布
最新推荐文章于 2023-05-18 08:31:12 发布
阅读量238 收藏
点赞数
分类专栏： 学习记录 文章标签： java 代理模式 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53606287/article/details/126827973
版权

Java高级特性之动态代理

学习之前首先介绍一下代理模式

这里拿手机销售来说、比方说三星厂商生产出了手机、之后需要经过销售、于是交给了厂商B来销售、所以B是一个代理销售商、但是厂商B在销售之前之后会做其他的动作。因此不仅仅是简单的进行销售。

流程图：

在这里插入图片描述

这里在模版上有点类似装饰者式，但是这里是不一样的。装饰者更强调行为、而代理模式更强调对象本身。

静态代理

1、被代理对象

/**
 * @Author Zzneko
 * @Date 2022/9/9 16:07
 **/
public class ProxyObj {

    public void sayHello(){
        System.out.println("hello");
    }
}

2、代理对象

package proxy.simpleProxy;

/**
 * 代理对象
 * */
public class Proxy {

    private ProxyObj proxyObj;

    public Proxy(ProxyObj proxyObj) {
        this.proxyObj = proxyObj;
    }

    /**
     * 代理方法
     */
    public void methodEnhance(){
        System.out.println("before say hello");
        proxyObj.sayHello();
        System.out.println("after say hello");
    }

}

3、测试

/**
 * @Author Zzneko
 * @Date 2022/9/9 16:10
 **/
public class ProgramEntering {
    public static void main(String[] args) {
        ProxyObj proxyObj = new ProxyObj();
        Proxy proxy = new Proxy(proxyObj);
        proxy.methodEnhance();
    }
}

静态代理很简单这里就不做过多讲述了

动态代理

动态代理有两种

一、JDK

1、被代理的类。

package proxy.jdk;

/**
 * @Author Zzneko
 * @Date 2022/9/7 12:50
 * 被代理类
 **/
public class ServiceImp implements IService{
    @Override
    public void sayHello() {
        System.out.println("hello");
    }

    @Override
    public void fly() {
        System.out.println("i am flying");
    }
}

//-----------实现的接口
package proxy.jdk;


/**
 * 代理接口
 */
public interface IService {
    void sayHello();

    void fly();
}

2、代理类

package proxy.jdk;

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

/**
 * @Author Zzneko
 * @Date 2022/9/7 12:50
 * 代理类
 **/
public class SimpleInvocationHandler implements InvocationHandler {
    //被代理的对象
    private Object realObject;

    public SimpleInvocationHandler(Object object) {
        this.realObject = object;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("entering"+method.getName());
        Object result = method.invoke(realObject, args);
        System.out.println("leaving"+method.getName());
        return result;
    }
}

3、测试类

public class SimpleJDKDynamicProxyDemo {
    public static void main(String[] args) {
        IService service = new ServiceImp();
        IService iService = (IService) Proxy.newProxyInstance(IService.class.getClassLoader(), new Class<?>[]{
                IService.class
        }, new SimpleInvocationHandler(service));
        service.sayHello();
        service.fly();
        System.out.println("代理之后");
        iService.fly();
        iService.sayHello();
    }
}

解读：

1、现在我们的创建的对象

public static Object newProxyInstance(ClassLoader loader,
                                      Class<?>[] interfaces,
                                      InvocationHandler h)

这个方法创建、他拥有三个参数

1）loader标识类加载器

2）标识代理类要实现的接口列表，是一个数组，元素的接口类型只能是接口，不能是普通的类。

3）h的类型是InvocationHandler,它是一个接口，也定义在反射包中。它定义了一个方法inboke，对代理接口所有方法的调用都会转给该方法。

该方法返回的Object可以强制转换interfaces中的某个接口的类型。值得注意的是它不能强制换花为某个类类型。

二、CGLib

1、被代理对象

/**
 * @Author Zzneko
 * @Date 2022/9/7 13:18
 **/
public class RealService {
    public void sayHello(){
        System.out.println("hello world");
    }
}

2、代理对象

/**
 * @Author Zzneko
 * @Date 2022/9/7 13:18
 **/
public class SimpleInterceptor implements MethodInterceptor {
    //VM   Jdk8之后 启动参数记得加上 --add-opens java.base/java.lang=ALL-UNNAMED
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("entering\t"+method.getName());
        Object invoke = methodProxy.invokeSuper(o, objects);
        System.out.println("leaving\t"+method.getName());
        return invoke;
    }
    public static<T> T getProxy(Class<T> cls){
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(cls);
        enhancer.setCallback(new SimpleInterceptor());
        return (T) enhancer.create();
    }
}

3、测试

/**
 * @Author Zzneko
 * @Date 2022/9/7 13:18
 **/
public class SimpleCGLibDemo {
    public static void main(String[] args) {
        RealService realService = new RealService();
        realService.sayHello();
        System.out.println("代理类的方法");
        RealService proxy = SimpleInterceptor.getProxy(RealService.class);
        proxy.sayHello();
    }
}

总结：

JDK中的代理面向的是一组接口、其背后不一定真正有被代理的对象，也可能有多个实际对象

cglib代理的是一个具体的类。他动态的创建类一个新类、继承该类、重写了其方法

动态代理应用-AOP

1、定义注解

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface Aspect{
    Class<?>[] value();
}

2、定义切面类

/**
 * @Author Zzneko
 * @Date 2022/9/9 17:00
 **/
@Aspect(ServiceB.class)
public class ExceptionAspect {
    public static void exception(Object object,
                                 Method method,
                                 Object[] args,
                                 Throwable e) {
        System.err.println("exception when calling: " + method.getName()
                + "," + Arrays.toString(args));
    }
}

package aop.Aspect;

import Annotaion.diInject.ServiceA;
import Annotaion.diInject.ServiceB;
import aop.annotaion.Aspect;

import java.lang.reflect.Method;
import java.util.Arrays;

/**
 * @Author Zzneko
 * @Date 2022/9/9 17:00
 **/
@Aspect({ServiceB.class, ServiceA.class})
public class ServiceLogAspect {
    public static void before(Object object,
                              Method method,
                              Object[] args) {
        System.out.println(
                "entering " + method.getDeclaringClass().getSimpleName()
                + "::" + method.getName() + ", args: " + Arrays.toString(args)
        );
    }

    public static void after(Object object,
                             Method method,
                             Object[] args,
                             Object result) {
        System.out.println(
                "leaving " + method.getDeclaringClass().getSimpleName()
                + "::" + method.getName() + ", result: " + result
        );
    }
}

3、定义容器

/**
 * @Author Zzneko
 * @Date 2022/9/9 17:04
 **/
public class CGLibContainer {
    /**
     * 容器初始化分析所有带@Aspect的类，分析每个类的方法、前后需要调用那些方法。
     * */
    private static Map<Class<?>,Map<InterceptPoint, List<Method>>>  interceptMethodsMap =new HashMap();

    static Class<?>[] aspects = new Class<?>[] { ServiceLogAspect.class, ExceptionAspect.class };

    static {
        init();
    }

    private static void init(){
        for (Class<?> cls : aspects) {
            /**
             * ：用于获得切面的注解。
             *   以及根据方法名、来获取方法。
             * */
            Aspect aspect = cls.getAnnotation(Aspect.class);
            if (aspect!=null) {
                Method before = getMethod(cls, "before", new Class<?>[]{  Object.class,
                                   Method.class,
                                   Object[].class
                                }
                );
                Method after = getMethod(cls, "after", new Class<?>[]{  Object.class,
                                Method.class,
                                Object[].class
                        }
                );
                Method exception = getMethod(cls,"exception",new Class<?>[]{Object.class,Method.class,Object[].class,Throwable.class});
                //切面中面向的类。
                Class<?>[] value = aspect.value();
                for (Class<?> aClass : value) {
                    //对切面的对象生成代理类。
                    addInterceptMethod(aClass,InterceptPoint.BEFORE,before);
                    addInterceptMethod(aClass,InterceptPoint.AFTER,after);
                    addInterceptMethod(aClass,InterceptPoint.EXCEPTION,exception);
                }
            }
        }
    }

    /***
     * 添加被代理的类、以及被增强的方法。
     * @param cls 被代理类。
     * @param point 切点
     * @param method 被代理方法
     */
    private static void addInterceptMethod(Class<?> cls, InterceptPoint point, Method method) {
        if (method==null) {
            return;
        }
        /**
         * 获得当前切面的所有方法
         */
        Map<InterceptPoint, List<Method>> map = interceptMethodsMap.get(cls);
        if (map==null) {
            map=new HashMap<>();
            interceptMethodsMap.put(cls,map);
        }
        List<Method> methods = map.get(point);
        if (methods==null) {
            methods=new ArrayList<>();
            map.put(point,methods);
        }
        methods.add(method);
    }

    /**
     * 创建代理类
     * @param cls
     * @param <T>
     * @return
     * @throws InstantiationException
     * @throws IllegalAccessException
     */
    private static <T> T createInstance(Class<T> cls) throws InstantiationException, IllegalAccessException {
        //如果容器有当前类对象、则直接返回否则进行代理创建。
        if (!interceptMethodsMap.containsKey(cls)) {
            return (T) cls.newInstance();
        }
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(cls);
        enhancer.setCallback(new AspectInterceptor());
        return (T) enhancer.create();
    }

    /**
     * 代理生成
     */
    static class AspectInterceptor implements MethodInterceptor {
        @Override
        public Object intercept(Object object, Method method,
                                Object[] args, MethodProxy proxy) throws Throwable {
            //执行before方法
            List<Method> beforeMethods = getInterceptMethods(
                    object.getClass().getSuperclass(), InterceptPoint.BEFORE);
            for (Method m : beforeMethods) {
                m.invoke(null, new Object[] { object, method, args });
            }

            try {
                // 调用原始方法
                Object result = proxy.invokeSuper(object, args);

                // 执行after方法
                List<Method> afterMethods = getInterceptMethods(
                        object.getClass().getSuperclass(), InterceptPoint.AFTER);
                for (Method m : afterMethods) {
                    m.invoke(null, new Object[] { object, method, args, result });
                }
                return result;
            } catch (Throwable e) {
                //执行exception方法
                List<Method> exceptionMethods = getInterceptMethods(
                        object.getClass().getSuperclass(), InterceptPoint.EXCEPTION);
                for (Method m : exceptionMethods) {
                    m.invoke(null, new Object[] { object, method, args, e });
                }
                throw e;
            }
        }
    }

    private static Method getMethod(Class<?> cls, String name, Class<?>[] paramTypes) {
        try {
            return cls.getMethod(name, paramTypes);
        } catch (NoSuchMethodException e) {
            return null;
        }
    }

    static List<Method> getInterceptMethods(Class<?> cls, InterceptPoint point) {
        Map<InterceptPoint, List<Method>> map = interceptMethodsMap.get(cls);
        if (map == null) {
            return Collections.emptyList();
        }
        List<Method> methods = map.get(point);
        if (methods == null) {
            return Collections.emptyList();
        }
        return methods;
    }

    /**
     * 属性注入以及容器获取
     * @param cls
     * @param <T>
     * @return
     */
    public static <T> T getInstance(Class<T> cls) {
        try {
            T obj = createInstance(cls);
            Field[] fields = cls.getDeclaredFields();
            for (Field f : fields) {
                if (f.isAnnotationPresent(SimpleInject.class)) {
                    if (!f.isAccessible()) {
                        f.setAccessible(true);
                    }
                    Class<?> fieldCls = f.getType();
                    f.set(obj, getInstance(fieldCls));
                }
            }
            return obj;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

4、定义被具体的service

/**
 * @Author Zzneko
 * @Date 2022/9/9 17:00
 **/
public class ServiceA {
    @SimpleInject
    ServiceB b;

    public void callB(){
        b.action();
    }

    public ServiceB getB() {
        return b;
    }
}

/**
 * @Author Zzneko
 * @Date 2022/9/9 17:01
 **/
public class ServiceB {
    public void action(){
        System.out.println("I'm B");
    }
}

切面常量

public enum InterceptPoint {
    BEFORE,AFTER,EXCEPTION
}

测试

/**
 * @Author Zzneko
 * @Date 2022/9/9 17:04
 **/
public class ProgramEntering {
    public static void main(String[] args) {
        ServiceA a = CGLibContainer.getInstance(ServiceA.class);
        a.callB();
    }
}

结果

entering ServiceA::callB, args: []
entering ServiceB::action, args: []
I’m B
leaving ServiceB::action, result: null
leaving ServiceA::callB, result: null

Zznek0
关注
专栏目录
详解Java高级特性之反射
08-19
"详解Java高级特性之反射" Java反射机制是Java语言中一个非常重要的概念，它允许程序在运行时检查和修改其他类的行为。Java反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意...
java高级特性增强
03-27
java多线程、反射、代理等基础知识详细介绍，通过此文档可快速进阶为中级工程师
java高级特性——动态代理
a166244的博客
03-19 104
动态代理：用来修改已经具有的对象的方法,控制方法是否执行,或在方法执行之前和执行之后做一些额外的操作 Proxy.newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h); 　　　loader -- 类加载器 　　　interfaces -- 指...
Java动态代理的彻底理解（Java高级特性-动态代理）
小流至江河的博客
07-24 661
一、概述 说起动态代理用过Spring的都应该听说过，可是细琢磨又好像是不太明白，那今天就带着大家一起学习理解理解什么是Java的动态代理。 说动态代理之前，要先搞明白什么是代理，代理的字面意思已经很容易理解了，我们这里撇开其他的解释，我们只谈设计模式中的代理模式。 什么是代理模式（Proxy）? -> 给目标对象提供一个代理对象，并由代理对象控制对目标对象的引用。 使用...
Java笔记
oooqqqooo123的博客
10-19 492
Java
java动态代理
YZR的博客
03-21 476
1.JDK代理     动态的由java提供的api在内存中构建字节码类对象完成的动态代理.     使用JDK代理方式动态创建对象时,对象需要声明接口并且实现接口;     1.1声明接口: package yzr.dyn_jdk; public interface IPerson { void SayHello(); }    1.2 声明对象,并且实现接口: package
Java中的动态代理详解
09-18 1802
转载：https://www.ibm.com/developerworks/cn/java/j-lo-proxy1/index.html 前言 Java 动态代理机制的出现，使得 Java 开发人员不用手工编写代理类，只要简单地指定一组接口及委托类对象，便能动态地获得代理类。代理类会负责将所有的方法调用分派到委托对象上反射执行，在分派执行的过程中，开发人员还可以按需调整委托类对...
java高级特性增强（源码展示）
01-27
本教程将深入探讨几个关键的Java高级特性，包括多线程、并发包下的队列、Java消息服务（JMS）、虚拟机（JVM）技术和反射与动态代理。下面将对这些主题进行详细的讲解。 1. **多线程**：Java提供了强大的多线程支持...
Java高级特性之反射机制实例详解
08-27
Java反射机制是Java语言的一个重要特性，它允许程序在运行时动态地获取类的信息并进行操作。这使得Java具备了高度的灵活性和强大的元编程能力。在Java中，反射主要涉及以下几个方面： 1. **创建类的实例**： - ...
java7新特性与java高级编程
06-06
在Java高级编程方面，开发者需要掌握包括设计模式、并发编程、垃圾回收机制、JVM优化、反射、动态代理等核心概念。例如，深入理解线程池的使用，能够根据需求定制ThreadPoolExecutor，提高程序的并发性能。 **8. ...
Java中的动态代理
xingfuyisheng的专栏
10-30 1131
Java中的动态代理
如何使用java完成动态代理
aslzd123的博客
09-25 1165
使用jdk提供的API完成动态代理和接口高度绑定，如果类没有实现接口是不能完成动态代理的，而且只能对接口里面的方法完成代理，那么针对其他的类就需要使用另一种方式完成代理了，于是催生出cglib动态代理的技术，cglib完成动态代理的原理和基于jdk的动态代理类似，同样需要两个类，一个类完成代理对象的创建，另一个类完成功能增强，和被代理对象的业务方法调用，只不过基于cglib的动态代理是依赖于继承实现的，通过创建一个被代理对象的子类，来完成被代理对象的创建。那我们接着看handler这个对象。
java设计模式：动态代理Dynamic_Proxy详解 (使用场景：事务、日志、监控等)
血煞长虹 的专栏
03-27 2815
编者的话： 如果你想灵活，对方法执行前后（添加代码），进行监控（比如：方法运行[多少毫秒、记录日志、事务提交或回滚、权限监控、数据拦截、数据过滤]等）。时，动态代理模式，最适合你。 特别提示： 1、本案例主要是阐述动态代理的原理，及其模拟过程，可以提示对动态代理的理解和掌握。 2、JDK6以上版本，系统自带的有动态代理类Proxy，我们可以直接用，我们只需要专注于我们的InvocationHandler就可以了。
Java代理——静态代理、单接口动态代理、多接口动态代理、AOP编程
任天柳
03-07 1155
代理理念 在java中代理的运用我们可以类比于生活中的中介（卖家与买家通过中介来认识沟通）、明星经纪人（粉丝与明星之间一般是通过经纪人来预约联系，这样可以避免大量的分析直接联系给明星带来困扰，经过经纪人“审核”的粉丝可以与明星进行沟通互动）之类的第三方，这个第三方可以起到安全屏障、减少双方之间的关联程度。在java代理的理念之上诞生了经典模式之一的代理模式又称为委托模式，通过...
Java动态代理的常用场景及示例
最新发布
maxiaoteng的博客
05-18 1187
Java的动态代理在很多场景中都有广泛的应用。以下是几个常见的使用场景及相应的案例:**more。
Java动态代理实现原理分析
weixin_42555652的博客
02-15 479
1.首先清楚代理模式： 代理模式给某一个对象提供一个代理对象，并由代理对象控制对原对象的引用。通俗的来讲代理模式就是我们生活中常见的中介。 举个例子来说明：张三想买某种用品，虽然他可以自己去找，但是这确实太浪费时间和精力了，或者不好意思去买。于是张三就通过中介Mark来买，Mark来帮张三，张三只是负责选择自己喜欢的的size，然后付钱就可以了。 目的：（1）通过引入代理对象的...
Java中实现动态代理5种实现
austinlyway的博客
02-15 3430
Java动态代理的5中实现
could not autowire.No beans of 'FunctionService' type found.
热门推荐
expect521的博客
08-12 1万+
could not autowire. No beans of ‘FunctionService’ type found.checks autowiring probleam in a been class 出现这种错误的可能性，目前我遇到的有两种可能性： 1. 没有把类注入为bean导致。即没有用注解@bean/@Named/@Service/@Component注入… 2. 如
Java反射机制与动态代理深度解析
"Java的反射机制与动态代理是Java编程中的高级特性，它们允许程序在运行时探索和操作类及对象。反射机制提供了运行时获取类的信息，如类名、方法签名、属性等，而动态代理则允许在运行时创建具有特定行为的代理类。...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值