浅析Java中的动态代理

目录

• 代理常见功能
• 代理模式的组成
• 代理模式分类
• 动态代理实现的技术
• JDK 代理的实现步骤
• CGLIB 代理实现步骤

代理常见功能

日志代理

数据库访问的事务代理

代理模式的组成

• 抽象主题：通过接口或抽象类定义核心业务方法。
• 真实主题：实现了接口的实现类，是实施代理的具体对象。即代理最终代理的是具体的实现类类而不是接口。
• 代理：具有与代理对象相同的方法，可以控制和扩展被代理对象的功能，也是使用代理对象的根据目的。

代理对象 = 增强代码 + 目标对象（原对象）

代理模式分类

静态代理：代理类与被代理类一一对应，缺点是代理类太多。

动态代理：代理类是运行时通过反射技术动态生成的。有点是一类相似功能的被代理类（即需要相同扩展功能的类）只需要一个动态代理类。

动态代理实现的技术

JDK 代理：面向接口的代理，无法直接代理类，被代理的类必须实现某业务接口。

CGLIB 代理：功能更强，性能更好，可以直接代理类而不用实现接口，是通过动态创建被代理的子类重写父类的被代理方法来实现统计附件功能的。不能代理final类或final方法。

JDK 代理的实现步骤

核心业务接口

public interface Buyer {
    /**
     * 卖房：核心业务方法
     * @return
     */
    String buy();
}

业务实现类

public class BuyerImpl implements Buyer{
    public String buy() {
        System.out.println("本人卖房，从不坑人...");
        return "一次搞定";
    }
}

动态代理类

public class BuyerInvocationHandler implements InvocationHandler {
    //被代理对象
    private Object target;

    /**
     * 设置被代理对象
     * @param target
     */
    public void setTarget(Object target) {
        this.target = target;
    }

    /**
     * 执行被代理对象的业务方法的代理方法
     * @param proxy
     * @param method
     * @param args
     * @return
     * @throws Throwable
     */
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("熬夜满大街收集电话号码.....");
        //调用核心业务方法
        Object result = method.invoke(target,args);

        System.out.println("不满意，再找我...");

        return result;
    }
}

代理工厂类

public class BuyerProxyFactory {
    /**
     * 工厂方法
     * @param target 需要被代理的对象
     * @param <T> 
     * @return 返回动态生成的代理对象
     */
    public static <T> T create(Object target){
        // 创建动态代理对象
        BuyerInvocationHandler handler = new BuyerInvocationHandler();
        // 设置被代理对象
        handler.setTarget(target);
        // 动态创建执行业务方法的代理对象
        return  (T) Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                handler);
    }
}

测试类

public class example {
    public static void main(String[] args) {
        //定义被代理对象
        //定义被代理对象
        Buyer buyer = new BuyerImpl();
        buyer.buy();  // 直接调用业务方法，没有代理的功能
        // 使用代理工厂创建动态代理类对象
        Buyer proxyBuyer = BuyerProxyFactory.create(buyer);
        proxyBuyer.buy();
    }
}

CGLIB 代理实现步骤

导入 POM

<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib-nodep</artifactId>
    <version>3.3.0</version>
</dependency>

定义业务方法

public class OrderService {
    public int insert(){
        System.out.println("添加订单....");
        return 0;
    }
}

定义代理工厂类，与提供事务控制功能的MethodInterceptor合二为一

public class TransactionProxyFactory {
    /**
     * 动态创建被代理类的代理对象
     * @param clazz 类型
     * @param <T>
     * @return 代理对象
     */
    public static <T> T create(Class<T> clazz){
        Enhancer enhancer = new Enhancer();
        // 采用接口内部类的方式实现代理功能
        enhancer.setCallback(new MethodInterceptor() {
            public Object intercept(Object target, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                System.out.println("开始事务。。。。");
                // 核心业务,调用父类的方法
                Object result = methodProxy.invokeSuper(target,objects);
                System.out.println("提交或回滚事务....");
                return result;
            }
        });
        // 设置代理类的父类
        enhancer.setSuperclass(clazz);
        // 返回创建的动态代理类对象
        return (T) enhancer.create();
    }
}

测试类

public class TransactionProxyFactoryTest {
    public static void main(String[] args) {
        // 使用代理创建业务逻辑类
        OrderService orderService =
                TransactionProxyFactory.create(OrderService.class);
        orderService.insert();

        CartService cartService = TransactionProxyFactory.create(CartService.class);
        cartService.insert();
    }
}

到此这篇关于浅析Java中的动态代理的文章就介绍到这了,更多相关Java动态代理内容请搜索自由互联以前的文章或继续浏览下面的相关文章希望大家以后多多支持自由互联！