静态代理在使用时,需要定义接口或者父类,被代理对象(即目标对象)与代理对象一起实现相同的接口或者时继承相同父类
public interface ITeacherDao {
void teach();
}
被代理类:
public class TeacherDao implements ITeacherDao{
@Override
public void teach() {
System.out.println("老师授课中");
}
}
代理类:
// 静态代理对象
public class TeacherDaoProxy implements ITeacherDao{
// 目标对象,通过接口来聚合
private ITeacherDao target;
//构造器
public TeacherDaoProxy(ITeacherDao iTeacherDao) {
this.target = iTeacherDao;
}
@Override
public void teach() {
System.out.println("代理对象开始。。。。");
target.teach();
System.out.println("代理对象结束。。。。");
}
}
调用:
public static void main(String[] args) {
// 创建目标对象
ITeacherDao target = new TeacherDao();
// 创建代理对象, 同时将被代理对象传给代理对象
ITeacherDao teacherDaoProxy = new TeacherDaoProxy(target);
// 通过代理对象,调用到被代理对象的方法
// 即:执行时代理对象的方法,代理对象再去调用目标对象的方法
teacherDaoProxy.teach();
}
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h) {}
public interface ITeacherDao {
void teach();
void name(String name);
}
被代理类:
public class TeacherDao implements ITeacherDao {
@Override
public void teach() {
System.out.println("学习中....");
}
@Override
public void name(String name) {
System.out.println("名字:" + name);
}
}
代理类工厂类:
// 代理对象生产工厂
public class ProxyFactory {
// 维护一个目标对象,Obejct
private Object 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;
}
});
}
}
调用:
public static void main(String[] args) {
// 创建目标对象
ITeacherDao target = new TeacherDao();
// 创建代理对象, 同时将被代理对象传给代理对象
ITeacherDao teacherDaoProxy = (ITeacherDao) new ProxyFactory(target).getProxyInstance();
// proxyInstance = com.sun.proxy.$Proxy0 内存中动态生成了代理对象
System.out.println("proxyInstance" + teacherDaoProxy.getClass());
//通过代理对象调用目标对象方法:
teacherDaoProxy.teach();
teacherDaoProxy.name("yu");
}
被代理对象:
public class TeacherDao {
public void teach() {
System.out.println("学习中....");
}
public void name(String name) {
System.out.println("名字:" + name);
}
public String hello() {
return "hello";
}
}
代理工厂类:
public class CglibProxyFactory implements MethodInterceptor {
// 维护一个目标对象
private Object target;
// 构造器,传入一个被代理对象
public CglibProxyFactory (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 o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
System.out.println("Cglib代理对象模式开始。。。。。。。");
Object res = method.invoke(target, objects);
System.out.println("Cglib代理对象模式结束。。。。。。。");
return res;
}
}
调用:
public static void main(String[] args) {
// 创建目标对象
TeacherDao target = new TeacherDao();
// 创建代理对象, 同时将被代理对象传给代理对象
TeacherDao teacherDaoProxy = (TeacherDao) new CglibProxyFactory(target).getProxyInstance();
// proxyInstance = com.sun.proxy.$Proxy0 内存中动态生成了代理对象
System.out.println("proxyInstance" + teacherDaoProxy.getClass());
//通过代理对象调用目标对象方法
teacherDaoProxy.teach();
teacherDaoProxy.name("yu");
String res = teacherDaoProxy.hello();
System.out.println("+++" + res);
}
参考Spring AOP