---

---

前言

---

一、静态代理

完整代码

接口 ITeacherDao （代理类和被代理类都需要实现这个接口）

package tanchishell.SJMS.staticproxy;

//接口
public interface ITeacherDao {
    void teach(); // 授课的方法
}

被代理类 TeacherDao

//教师类
public class TeacherDao implements ITeacherDao{

    @Override
    public void teach() {
        System.out.println(" 老师授课中 。。。。。");
    }
}

代理类 TeacherDaoProxy

//代理对象,静态代理
public class TeacherDaoProxy implements ITeacherDao {

    private ITeacherDao target; // 目标对象，通过接口来聚合

    //构造器
    public TeacherDaoProxy(ITeacherDao target) {
        this.target = target;
    }

    @Override
    public void teach() {
        System.out.println("开始代理 完成某些操作。。。。。 ");//方法
        target.teach();
        System.out.println("提交。。。。。");//方法

    }
}

测试类 Client

package tanchishell.SJMS.staticproxy;

public class Client {

    public static void main(String[] args) {

        //创建目标对象(被代理对象)
        TeacherDao teacherDao = new TeacherDao();
        //创建代理对象, 同时将被代理对象传递给代理对象
        TeacherDaoProxy teacherDaoProxy = new TeacherDaoProxy(teacherDao);
        //通过代理对象，调用到被代理对象的方法
        //即：执行的是代理对象的方法，代理对象再去调用目标对象的方法
        teacherDaoProxy.teach();
    }
}

输出

开始代理 完成某些操作。。。。。 
 老师授课中 。。。。。
提交。。。。。

二、JDK动态代理

完整代码

接口 ITeacher

package tanchishell.SJMS.JDKstaticproxy;

public interface ITeacherDao {

    void teach(); // 授课方法
    void sayHello(String name);

}

实现类TeacherDao

package tanchishell.SJMS.JDKstaticproxy;

public class TeacherDao implements ITeacherDao {
    @Override
    public void teach(){

        System.out.println(" 老师授课中.... ");
    }

    @Override
    public void sayHello(String name) {

        System.out.println("hello " + name);
    }

}

代理工厂 ProxyFacyory

package tanchishell.SJMS.JDKstaticproxy;

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

public class ProxyFactory {

    //维护一个目标对象 , Object
    private Object target;

    //构造器 ， 对 target 进行初始化
    public ProxyFactory(Object target) {
        this.target = target;
    }

    //给目标对象 生成一个代理对象
    public Object getProxyInstance() {

//说明
/*
* public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)
//1. ClassLoader loader ： 指定当前目标对象使用的类加载器, 获取加载器的方法固定
//2. Class<?>[] interfaces: 目标对象实现的接口类型，使用泛型方法确认类型
//3. InvocationHandler h : 事情处理，执行目标对象的方法时，会触发事情处理器方法, 会把当前执行
的目标对象方法作为参数传入
*/
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                System.out.println("JDK 代理开始~~");
                //反射机制调用目标对象的方法
                Object returnVal = method.invoke(target, args);
                System.out.println("JDK 代理提交");
                return returnVal;
            }
        });
    }
}

client 测试

package tanchishell.SJMS.JDKstaticproxy;

public class Client {
    public static void main(String[] args) {

        //创建目标对象
        ITeacherDao target = new TeacherDao();
        //给目标对象，创建代理对象, 可以转成 ITeacherDa
        ITeacherDao proxyInstance = (ITeacherDao)new ProxyFactory(target).getProxyInstance();
        // proxyInstance=class com.sun.proxy.$Proxy0 内存中动态生成了代理对象
        System.out.println("proxyInstance=" + proxyInstance.getClass());
        //通过代理对象，调用目标对象的方法
        proxyInstance.teach();
        proxyInstance.sayHello(" tom ");
    }
}


输出

proxyInstance=class com.sun.proxy.$Proxy0
JDK 代理开始~~
 老师授课中.... 
JDK 代理提交
JDK 代理开始~~
hello  tom 
JDK 代理提交

三、Cglib代理

CGlib 代理和 jdk 代理的最大区别是不需要 被代理类实现接口，使用方法拦截的形式进行动态代理

完整代码

被代理对象

package CgLibstaticproxy;

public class TeacherDao {
    public String teach() {
        System.out.println(" 老师授课中 ， 我是 cglib 代理，不需要实现接口 ");
        return "hello";
    }
}

代理工厂

package CgLibstaticproxy;

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

import java.lang.reflect.Method;

public class ProxyFactory implements MethodInterceptor {
    //维护一个目标对象
    private Object target;

    //构造器，传入一个被代理的对象
    public ProxyFactory(Object target) {
        this.target = target;
    }

    //返回一个代理对象: 是 target 对象的代理对象
    public Object getProxyInstance() {
        //1. 创建一个工具类
        Enhancer enhancer = new Enhancer();

        //2. 设置父类
        enhancer.setSuperclass(target.getClass());
        //3. 设置回调函数
        enhancer.setCallback(this);
        //4. 创建子类对象，即代理对象
        return enhancer.create();
    }

    //重写 intercept 方法，会调用目标对象的方法
    @Override
    public Object intercept(Object arg0, Method method, Object[] args, MethodProxy arg3) throws Throwable {

        System.out.println("Cglib 代理模式 ~~ 开始");
        Object returnVal = method.invoke(target, args);
        System.out.println("Cglib 代理模式 ~~ 提交");
        return returnVal;
    }
}

测试

package CgLibstaticproxy;

public class Client {
    public static void main(String[] args) {

        //创建目标对象
        TeacherDao target = new TeacherDao();
        //获取到代理对象，并且将目标对象传递给代理对象
        TeacherDao proxyInstance = (TeacherDao)new ProxyFactory(target).getProxyInstance();
        //执行代理对象的方法，触发 intecept 方法，从而实现 对目标对象的调用
        String res = proxyInstance.teach();
        System.out.println("res=" + res);
    }
}

输出

Cglib 代理模式 ~~ 开始
 老师授课中 ， 我是 cglib 代理，不需要实现接口 
Cglib 代理模式 ~~ 提交
res=hello

四、代理模式(Proxy)的变体