Java代理模式详解：静态代理和动态代理有什么区别_Java

1. 代理模式

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

代理类与委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象本身并不真正实现服务，而是通过调用委托类的对象的相关方法，来提供特定的服务。

简单的说就是，我们在访问实际对象时，是通过代理对象来访问的，代理模式就是在访问实际对象时引入一定程度的间接性，因为这种间接性，可以附加多种用途。

2. 静态代理

简单来说代理模式就是将被代理类包装起来然后重新实现相同的方法，并且调用原来方法的同时可以在方法前后添加一个新的处理。而这种包装可以使用继承或者组合来使用。

当我们调用的时候需要使用的是代理类的对象来调用而不是原来的被代理对象。

静态代理有两种实现方式：

1、基于继承的方式实现

2、基于接口方式实现

基于继承实现静态代理

通过继承被代理对象，重写被代理方法，可以对其进行代理。

优点：被代理类无需实现接口
缺点：只能代理这个类，要想代理其他类，要想代理其他类需要写新的代理方法。

cglib动态代理就是采用这种方式对类进行代理。不过类是由cglib帮我们在内存中动态生成的。

/**
 * 被代理对象
 */
class userdao{
    public int insert(){
        system.out.println("执行insert......");
        return 1;
    }
}

/**
 * 代理对象
 */
class userdaoproxy extends userdao{

    @override
    public int insert() {
        system.out.println("代理执行方法前......");
        int result = super.insert();
        system.out.println("代理执行方法后......");
        return result;
    }
}

public class staticproxywithextendsdemo {
    public static void main(string[] args) {
        userdao userdao = new userdaoproxy();
        userdao.insert();
    }
}

基于接口方式实现

被代理类与代理类一定要实现同一接口。

代理类需要将该接口作为属性，实例化时需要传入该接口的对象。

优点：可以代理所有实现接口的类。
缺点：被代理的类必须实现接口。

jdk动态代理就是采用的这种方式实现的。同样的代理类是由jdk自动帮我们在内存生成的。

interface iuserdao{
    void insert();
}

/**
 * 被代理对象
 */
class userdaoimpl implements iuserdao{
    @override
    public void insert() {
        system.out.println("这里执行了insert方法......");
    }
}

/**
 * 代理对象
 */
class userdaoimplproxy implements iuserdao{
    private iuserdao userdao;
    public userdaoimplproxy(iuserdao userdao){
        this.userdao = userdao;
    }

    @override
    public void insert() {
        system.out.println("代理执行方法前.....");
        userdao.insert();
        system.out.println("代理执行方法后.....");
    }
}

public class staticproxywithinterfacedemo {
    public static void main(string[] args) {
        //需要被代理的对象
        iuserdao userdao = new userdaoimpl();
        //获取代理对象
        iuserdao userdaoproxy = new userdaoimplproxy(userdao);
        //代理对象执行方法
        userdaoproxy.insert();
    }
}

3. 动态代理

动态代理其实本质还是将被代理类包装一层，生成一个具有新的相同功能的代理类。

但是与静态代理不同的是，这个代理类我们自己定义的。而动态代理这个代理类是根据我们的提示动态生成的。

相比于静态代理，动态代理的优势在于可以很方便的对代理类的函数进行统一的处理，而不用修改每个代理类中的方法。

实现动态代理有几种方案：

jdk动态代理
cglib动态代理

3.1 jdk动态代理

通过java提供的proxy类帮我们创建代理对象。

优点：可以生成所有实现接口的代理对象
缺点：jdk反射生成代理必须面向接口, 这是由proxy的内部实现决定的。生成代理的方法中必须指定实现类的接口，它根据这个接口来实现代理类生成的所实现的接口。

interface istudentdao{
    void insert();
}

//被代理对象
class studentdaoimpl implements istudentdao{
    @override
    public void insert() {
        system.out.println("执行了insert方法......");
    }
}

class proxyinvoke implements invocationhandler{
    //需要被代理的对象
    object target;
    public proxyinvoke(object target){
        this.target = target;
    }
    /**
     * nvoke方法的三个参数
     *     object proxy：这个就是代理对象
     *     method method：执行的方法的反射对象
     *     object[] args：执行方法的参数
     */
    @override
    public object invoke(object proxy, method method, object[] args) throws throwable {
        system.out.println("代理执行方法前......");
        method.invoke(target,args);
        system.out.println("代理执行方法后......");
        return null;
    }
}
public class dynamicproxywithjdkdemo {
    public static void main(string[] args) {
        //需要被代理的对象
        istudentdao studentdao = new studentdaoimpl();
        //通过jdc的proxy.newproxyinstance进行生成代理对象
        // 参数一: 被代理类对象
        // 参数二：接口类对象  被代理对象所实现的接口
        // 参数三：调用处理器。 被调用对象的那个方法被调用后该如何处理
        istudentdao studentdaoproxy = (istudentdao) proxy.newproxyinstance(studentdao.getclass().getclassloader(),studentdao.getclass().getinterfaces(),new proxyinvoke(studentdao));
        studentdaoproxy.insert();
    }
}

如果业务逻辑不复杂，也可以进行简写：

public class dynamicproxywithjdkdemo {
    public static void main(string[] args) {
        //需要被代理的对象
        istudentdao studentdao = new studentdaoimpl();
        istudentdao studentdaoproxy = (istudentdao)proxy.newproxyinstance(studentdao.getclass().getclassloader(), studentdao.getclass().getinterfaces(), new invocationhandler() {
            @override
            public object invoke(object proxy, method method, object[] args) throws throwable {
                system.out.println("代理执行方法前......");
                object invoke = method.invoke(studentdao, args);
                system.out.println("代理执行方法后......");
                return invoke;
            }
        });
        studentdaoproxy.insert();
    }
}

interface istudentdao{
    void insert();
}

class studentdaoimpl implements istudentdao{
    @override
    public void insert() {
        system.out.println("执行了insert方法......");
    }
}

3.2 cglib动态代理

cglib(code generate library) 与jdk动态代理不同的是，cglib生成代理是被代理对象的子类。因此它拥有继承方法实现静态代理的优点：不需要被代理对象实现某个接口。

缺点：不能给final类生成代理，因为final类无法拥有子类。

使用cglib生成代理类也很简单，只要指定父类和回调方法即可

首先需要引入依赖

<dependency>
     <groupid>cglib</groupid>
     <artifactid>cglib</artifactid>
     <version>3.2.12</version>
 </dependency>

public class dynamicproxywithcglibdemo {
    public static void main(string[] args) {
        teacherdao teacherdao = new teacherdao();
        teacherdao teacherproxy = (teacherdao) enhancer.create(teacherdao.getclass(), new methodinterceptor() {
            @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;
            }
        });
        teacherproxy.insert();
    }
}

class teacherdao{
    public void insert(){
        system.out.println("执行了insert方法");
    }
}