【奇淫巧技】Java动态代理（JDK和cglib）

ゞ浴缸里的玫瑰 2021-07-24 14:05 218阅读 0赞

## JAVA的动态代理 ##

**代理模式**

代理模式是常用的java设计模式，他的特征是代理类与委托类有同样的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。

代理类与委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象本身并不真正实现服务，而是通过调用委托类的对象的相关方法，来提供特定的服务。  
按照代理的创建时期，代理类可以分为两种。

*  静态代理：由程序员创建或特定工具自动生成源代码，再对其编译。在程序运行前，代理类的.class文件就已经存在了。
 *  动态代理：在程序运行时，运用反射机制动态创建而成。

首先看一下静态代理：  
**1、Count.java**

package net.battier.dao;  
      
    /** 
     * 定义一个账户接口 
     *  
     * @author Administrator 
     *  
     */  
    public interface Count {  
        // 查看账户方法  
        public void queryCount();  
      
        // 修改账户方法  
        public void updateCount();  
      
    }

**2、CountImpl.java**

package net.battier.dao.impl;  
      
    import net.battier.dao.Count;  
      
    /** 
     * 委托类(包含业务逻辑) 
     *  
     * @author Administrator 
     *  
     */  
    public class CountImpl implements Count {  
      
        @Override  
        public void queryCount() {  
            System.out.println("查看账户方法...");  
      
        }  
      
        @Override  
        public void updateCount() {  
            System.out.println("修改账户方法...");  
      
        }  
      
    }  
      //加入Java开发交流君样：756584822一起吹水聊天
    、CountProxy.java  
    package net.battier.dao.impl;  
      
    import net.battier.dao.Count;  
      
    /** 
     * 这是一个代理类（增强CountImpl实现类） 
     *  
     * @author Administrator 
     *  
     */  
    public class CountProxy implements Count {  
        private CountImpl countImpl;  
      
        /** 
         * 覆盖默认构造器 
         *  
         * @param countImpl 
         */  
        public CountProxy(CountImpl countImpl) {  
            this.countImpl = countImpl;  
        }  
      
        @Override  
        public void queryCount() {  
            System.out.println("事务处理之前");  
            // 调用委托类的方法;  
            countImpl.queryCount();  
            System.out.println("事务处理之后");  
        }  
      
        @Override  
        public void updateCount() {  
            System.out.println("事务处理之前");  
            // 调用委托类的方法;  
            countImpl.updateCount();  
            System.out.println("事务处理之后");  
      
        }  
      
    }

**3、TestCount.java**

package net.battier.test;  
      
    import net.battier.dao.impl.CountImpl;  
    import net.battier.dao.impl.CountProxy;  
      
    /** 
     *测试Count类 
     *  
     * @author Administrator 
     *  
     */  
    public class TestCount {  
        public static void main(String[] args) {  
            CountImpl countImpl = new CountImpl();  
            CountProxy countProxy = new CountProxy(countImpl);  
            countProxy.updateCount();  
            countProxy.queryCount();  
      //加入Java开发交流君样：756584822一起吹水聊天
        }  
    }

观察代码可以发现每一个代理类只能为一个接口服务，这样一来程序开发中必然会产生过多的代理，而且，所有的代理操作除了调用的方法不一样之外，其他的操作都一样，则此时肯定是重复代码。解决这一问题最好的做法是可以通过一个代理类完成全部的代理功能，那么此时就必须使用动态代理完成。  
再来看一下动态代理：  
**JDK动态代理中包含一个类和一个接口：**

InvocationHandler接口： 
    public interface InvocationHandler { 
    public Object invoke(Object proxy,Method method,Object[] args) throws Throwable; 
    }

参数说明：

*  Object proxy：指被代理的对象。
 *  Method method：要调用的方法
 *  Object\[\] args：方法调用时所需要的参数

可以将InvocationHandler接口的子类想象成一个代理的最终操作类，替换掉ProxySubject。

**Proxy类：**

Proxy类是专门完成代理的操作类，可以通过此类为一个或多个接口动态地生成实现类，此类提供了如下的操作方法：

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

参数说明：  
ClassLoader loader：类加载器  
Class<?>\[\] interfaces：得到全部的接口  
InvocationHandler h：得到InvocationHandler接口的子类实例

**Ps:类加载器**

*  在Proxy类中的newProxyInstance（）方法中需要一个ClassLoader类的实例，ClassLoader实际上对应的是类加载器，在Java中主要有一下三种类加载器;
 *  Booststrap ClassLoader：此加载器采用C++编写，一般开发中是看不到的；
 *  Extendsion ClassLoader：用来进行扩展类的加载，一般对应的是jre\\lib\\ext目录中的类;
 *  AppClassLoader：(默认)加载classpath指定的类，是最常使用的是一种加载器。

**动态代理**  
与静态代理类对照的是动态代理类，动态代理类的字节码在程序运行时由Java反射机制动态生成，无需程序员手工编写它的源代码。动态代理类不仅简化了编程工作，而且提高了软件系统的可扩展性，因为Java 反射机制可以生成任意类型的动态代理类。java.lang.reflect 包中的Proxy类和InvocationHandler 接口提供了生成动态代理类的能力。

**动态代理示例:**  
1、BookFacade.java

package net.battier.dao;  
      
    public interface BookFacade {  
        public void addBook();  
    }

2、BookFacadeImpl.java

package net.battier.dao.impl;  
      //加入Java开发交流君样：756584822一起吹水聊天
    import net.battier.dao.BookFacade;  
      
    public class BookFacadeImpl implements BookFacade {  
      
        @Override  
        public void addBook() {  
            System.out.println("增加图书方法。。。");  
        }  
      
    }  
      
    、BookFacadeProxy.java  
      
    package net.battier.proxy;  
      
    import java.lang.reflect.InvocationHandler;  
    import java.lang.reflect.Method;  
    import java.lang.reflect.Proxy;  
      //加入Java开发交流君样：756584822一起吹水聊天
    /** 
     * JDK动态代理代理类 
     *  
     * @author student 
     *  
     */  
    public class BookFacadeProxy implements InvocationHandler {  
        private Object target;  
        /** 
         * 绑定委托对象并返回一个代理类 
         * @param target 
         * @return 
         */  
        public Object bind(Object target) {  
            this.target = target;  
            //取得代理对象  
            return Proxy.newProxyInstance(target.getClass().getClassLoader(),  
                    target.getClass().getInterfaces(), this);   //要绑定接口(这是一个缺陷，cglib弥补了这一缺陷)  
        }  
      //加入Java开发交流君样：756584822一起吹水聊天
        @Override  
        /** 
         * 调用方法 
         */  
        public Object invoke(Object proxy, Method method, Object[] args)  
                throws Throwable {  
            Object result=null;  
            System.out.println("事物开始");  
            //执行方法  
            result=method.invoke(target, args);  
            System.out.println("事物结束");  
            return result;  
        }  
      
    }

3、TestProxy.java

package net.battier.test;  
      
    import net.battier.dao.BookFacade;  
    import net.battier.dao.impl.BookFacadeImpl;  
    import net.battier.proxy.BookFacadeProxy;  
      
    public class TestProxy {  
      
        public static void main(String[] args) {  
            BookFacadeProxy proxy = new BookFacadeProxy();  
            BookFacade bookProxy = (BookFacade) proxy.bind(new BookFacadeImpl());  
            bookProxy.addBook();  
        }  //加入Java开发交流君样：756584822一起吹水聊天
      
    }

但是，JDK的动态代理依靠接口实现，如果有些类并没有实现接口，则不能使用JDK代理，这就要使用cglib动态代理了。

## Cglib动态代理 ##

JDK的动态代理机制只能代理实现了接口的类，而不能实现接口的类就不能实现JDK的动态代理，cglib是针对类来实现代理的，他的原理是对指定的目标类生成一个子类，并覆盖其中方法实现增强，但因为采用的是继承，所以不能对final修饰的类进行代理。  
示例  
1、BookFacadeCglib.java

package net.battier.dao;  
      
    public interface BookFacade {  
        public void addBook();  
    }

2、BookCadeImpl1.java

package net.battier.dao.impl;  
      
    /** 
     * 这个是没有实现接口的实现类 
     *  
     * @author student 
     *  
     */  
    public class BookFacadeImpl1 {  
        public void addBook() {  
            System.out.println("增加图书的普通方法...");  
        }  
    }

3、BookFacadeProxy.java

package net.battier.proxy;  
      
    import java.lang.reflect.Method;  
      
    import net.sf.cglib.proxy.Enhancer;  
    import net.sf.cglib.proxy.MethodInterceptor;  
    import net.sf.cglib.proxy.MethodProxy;  
      
    /** 
     * 使用cglib动态代理 
     *  
     * @author student 
     *  
     */  
    public class BookFacadeCglib implements MethodInterceptor {  
        private Object target;  
      
        /** 
         * 创建代理对象 
         *  
         * @param target 
         * @return 
         */  
        public Object getInstance(Object target) {  
            this.target = target;  
            Enhancer enhancer = new Enhancer();  
            enhancer.setSuperclass(this.target.getClass());  
            // 回调方法  
            enhancer.setCallback(this);  
            // 创建代理对象  
            return enhancer.create();  
        }  
      
        @Override  
        // 回调方法  
        public Object intercept(Object obj, Method method, Object[] args,  
                MethodProxy proxy) throws Throwable {  
            System.out.println("事物开始");  
            proxy.invokeSuper(obj, args);  
            System.out.println("事物结束");  
            return null;  
      
      
        }  
      
    }

4、TestCglib.java

package net.battier.test;  
      
    import net.battier.dao.impl.BookFacadeImpl1;  
    import net.battier.proxy.BookFacadeCglib;  
      
    public class TestCglib {  
          
        public static void main(String[] args) {  
            BookFacadeCglib cglib=new BookFacadeCglib();  
            BookFacadeImpl1 bookCglib=(BookFacadeImpl1)cglib.getInstance(new BookFacadeImpl1());  
            bookCglib.addBook();  
        }  
    }

![在这里插入图片描述][20201228153418423.gif_pic_center]

![image][]

[**最新2020整理收集的一些高频面试题（都整理成文档），有很多干货，包含mysql，netty，spring，线程，spring cloud、jvm、源码、算法等详细讲解，也有详细的学习规划图，面试题整理等，需要获取这些内容的朋友请加Q君样：756584822**][2020_mysql_netty_spring_spring cloud_jvm_Q_756584822]

[20201228153418423.gif_pic_center]: /images/20210724/29096d0009684b8d9ac358da96ea3b6f.png
[image]: /images/20210724/e7cf20dd79cd4b0b959bfe6c215ad519.png
[2020_mysql_netty_spring_spring cloud_jvm_Q_756584822]: https://jq.qq.com/?_wv=1027&k=0IsBuUb0

发表评论取消回复

表情：

评论列表（有 0 条评论，218人围观）

还没有评论，来说两句吧...

相关阅读

相关 Android Studio 奇技淫巧

> 这篇文章篇幅较长，可以使用版权声明下面的目录，找到感兴趣的进行阅读目录 > 3.1 Android Studio使用初探 > > >

红太狼/ 2022年07月14日 03:57/ 0 赞/ 244 阅读

相关 Java奇淫巧技之Lombok

Lombok是一个可以通过简单的注解形式来帮助我们简化消除一些必须有但显得很臃肿的Java代码的工具，通过使用对应的注解，可以在编译源码的时候生成对应的方法。官方地址：[ht

港控/mmm°/ 2022年06月16日 07:10/ 0 赞/ 182 阅读

相关 Java奇淫巧技之Lombok

from: http://blog.csdn.net/ghsau/article/details/52334762 背景我们在开发过程中，通常都会定义大量

爱被打了一巴掌/ 2022年06月10日 07:57/ 0 赞/ 189 阅读

相关 Java奇淫巧技之Lombok

奇淫巧技之Lombok -------------------- 一、Lombok介绍 > Lombok是一个可以通过简单的注解形式来帮助我们简化消除一些必

「爱情、让人受尽委屈。」/ 2022年06月06日 07:55/ 0 赞/ 190 阅读

相关 JS 奇淫巧技

ps: js另外一种高深写法，只不过不适合基础太差的想故意装逼的，因为你要是有意而为之，只能是披着羊皮的狼，玩死自己。要不叫做JsFuck。可以自行JsFuck。什么叫基础

桃扇骨/ 2022年05月24日 02:30/ 0 赞/ 191 阅读

相关 Java奇淫巧技之Lombok

Lombok是一个可以通过简单的注解形式来帮助我们简化消除一些必须有但显得很臃肿的Java代码的工具，通过使用对应的注解，可以在编译源码的时候生成对应的方法。官方地址：[ht

你的名字/ 2022年04月06日 03:14/ 0 赞/ 197 阅读

相关 Java奇淫巧技之Lombok

Lombok是一个可以通过简单的注解形式来帮助我们简化消除一些必须有但显得很臃肿的Java代码的工具，通过使用对应的注解，可以在编译源码的时候生成对应的方法。官方地址：[ht

╰+攻爆jí腚メ/ 2022年04月06日 03:14/ 0 赞/ 200 阅读

相关 Java奇淫巧技之Lombok

背景我们在开发过程中，通常都会定义大量的JavaBean，然后通过IDE去生成其属性的构造器、getter、setter、equals、hashcode、toStr

悠悠/ 2022年03月26日 03:48/ 0 赞/ 262 阅读

相关 Java奇淫巧技之Lombok

Lombok是一个可以通过简单的注解形式来帮助我们简化消除一些必须有但显得很臃肿的Java代码的工具，通过使用对应的注解，可以在编译源码的时候生成对应的方法。官方地址：[htt

一时失言乱红尘/ 2022年02月26日 08:54/ 0 赞/ 229 阅读

相关【奇淫巧技】Java动态代理（JDK和cglib）

JAVA的动态代理代理模式代理模式是常用的java设计模式，他的特征是代理类与委托类有同样的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委

ゞ浴缸里的玫瑰/ 2021年07月24日 14:05/ 0 赞/ 219 阅读