Java23种设计模式之一（代理模式）

Java23种设计模式之一

代理模式（静态代理模式、动态代理模式、cglib代理模式）

代理模式是一种设计模式，提供了对目标对象额外的访问方式，即通过代理对象访问目标对象，这样可以在不修改原目标对象的前提下，提供额外的功能操作，扩展目标对象的功能。

静态代理模式：

此方法需要目标对象与代理对象实现一样的接口
优点：可以在不修改原目标对象的情况下扩展目标对象
缺点：冗余。由于代理对象要实现与目标对象一致的接口，会产生过多的代理类；不易维护。一旦接口增加方法，目标对象与代理对象都要进行修改。

接口类
public interface StudentDaoIfac {
    /*
    接口类
     */
    public String selectStudent();
}

public class StudentDao implements StudentDaoIfac{
    /*
    目标对象
     */
    public String selectStudent(){
        return "student";
    }
}

public class StudentDaoProxy implements StudentDaoIfac{
    /*
    静态代理对象
     */
    StudentDaoIfac studentDao;
    public StudentDaoProxy(StudentDaoIfac studentDao){
        this.studentDao=studentDao;//获取目标对象，防止对象为null
    }
    @Override
    public String selectStudent() {
        System.out.println("新添加的功能");//扩展额外功能
        return studentDao.selectStudent();
    }
}

public class TestProxy {
    /*
    测试
     */
    public static void main(String[] args) {
        StudentDaoIfac studentDao=new StudentDao();
        StudentDaoProxy studentDaoProxy = new StudentDaoProxy(studentDao);
        System.out.println(studentDaoProxy.selectStudent());
    }
}

输出：
新添加的功能
student

从上述代码可以看出静态代理模式的缺点：一旦所要代理的目标类过多，就得编写许多的代理类，现实一般不会这么做

动态代理模式：

动态代理利用JDK API,动态地在内存中构建对象，从而实现对目标对象的代理功能。动态代理又被称为JDK代理
静态代理与动态代理的区别：

• 静态代理在编译时就已经实现，编译完成后代理类是一个实际的class文件
• 动态代理是在运行时动态生成的，即编译完成后没有实际的class文件，而是在运行时动态生成类字节码，并加载到JVM中

特点：
动态代理对象不需要实现接口，但是要求目标对象必须实现接口，否则不能使用动态代理。

public interface BookDaoIfac {
    /*
    接口类
     */
    public void printBookName();
}

public class BookDao implements BookDaoIfac{
    /*
    目标对象
     */
    @Override
    public void printBookName() {
        System.out.println("Java从入门到入土");
    }
}

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

/**
 * dao的代理对象工厂
 */
public class DaoProxyFactory implements InvocationHandler {
    private Object target;//要生成代理对象的目标类

    public DaoProxyFactory(Object  target){
        this.target=target;//防止对象为null
    }

    /*
    获取代理的方法
     */
    public Object getProxy(){
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(),this);//获取代理实列
    }
    /*
    proxy参数为代理对象
    method参数方法对象，你调用哪个方法，就把那个方法封装成对象
    args参数 存放要给方法传的参数
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("这是给dao层方法扩展的功能代码---------");
        //利用反射调用方法
        Object result=method.invoke(target,args);
        System.out.println("这是给dao层方法扩展的功能代码..........");
        return result;
    }
}

public class BookproxyTest {
    /*
    测试
     */
    public static void main(String[] args) {
        BookDaoIfac bookDao = new BookDao();
        DaoProxyFactory factory = new DaoProxyFactory(bookDao);
        BookDaoIfac obj=(BookDaoIfac)factory.getProxy();
        obj.printBookName();
    }
}

输出：
这是给dao层方法扩展的功能代码---------
Java从入门到入土
这是给dao层方法扩展的功能代码..........

cglib代理

cglib (Code Generation Library )是一个第三方代码生成类库，运行时在内存中动态生成一个子类对象从而实现对目标对象功能的扩展。

cglib特点：

• JDK的动态代理有一个限制，就是使用动态代理的对象必须实现一个或多个接口，如果想代理没有实现接口的类，就可以使用CGLIB实现。
• CGLIB是一个强大的高性能的代码生成包，它可以在运行期扩展Java类与实现Java接口。它广泛的被许多AOP的框架使用，例如Spring AOP和dynaop，为他们提供方法的interception（拦截）。
• CGLIB包的底层是通过使用一个小而快的字节码处理框架ASM，来转换字节码并生成新的类。不鼓励直接使用ASM，因为它需要你对JVM内部结构包括class文件的格式和指令集都很熟悉。

cglib与动态代理的原理区别就是:

java动态代理利用反射机制生成一个实现代理接口的匿名类，在调用具体方法前调用InvokeHandler来处理。
而cglib动态代理是利用asm开源包，对代理对象类的class文件加载进来，通过修改其字节码生成子类来处理。

• 如果目标对象实现接口，默认情况下会采用JDK动态代理实现AOP
• 如果目标对象实现了接口，可以强制使用cglib实现AOP
• 如果目标对象没有实现接口，必须采用cglib库，spring会自动在jdk动态和cglib之间转换
  使用cglib需要引入cglib的jar包，如果你已经有spring-core的jar包，则无需引入，因为spring中包含了cglib。

cglib maven依赖：

<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>3.2.5</version>
</dependency>

package cglib;
/*
目标对象
 */
public class UserDao{
    public void getUsername(){
        System.out.println("钟部大大");
    }
}

package cglib;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

/**
 * 代理对象：proxyfactory
 */
public class ProxyFactory implements MethodInterceptor {
    private Object target;
    public ProxyFactory(Object target){
        this.target=target;
    }
    //目标对象生成代理对象
    public Object getProxyInstance(){
        //工具类
        Enhancer enhancer = new Enhancer();
        //设置父类
        enhancer.setSuperclass(target.getClass());
        //设置回调函数
        enhancer.setCallback(this);
        //创建子类对象代理
        return enhancer.create();
    }

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("对目标对象扩展的方法------------");
        //执行目标对象方法
        Object result=method.invoke(target,objects);
        System.out.println("对目标对象扩展的方法............");
        return result;
    }
}

package cglib;
/*
测试
 */
public class cglibTest {
    public static void main(String[] args) {
        UserDao target = new UserDao();
        System.out.println(target.getClass());
        UserDao proxy=(UserDao)new ProxyFactory(target).getProxyInstance();
        System.out.println(proxy.getClass());
        proxy.getUsername();
    }
}

输出：
class cglib.UserDao
class cglib.UserDao$$EnhancerByCGLIB$$6ac0ba82
对目标对象扩展的方法------------
钟部大大
对目标对象扩展的方法............