设计模式之代理模式

代理模式（自己的理解）：在程序中我们并不直接去使用目标对象，而是使用另外一个对象作为中介去代替目标对象来完成目标对象需要做的事。

代理模式分为：静态代理、动态代理

静态代理：在程序编译期间，就将需要植入的代码植入，耦合度高

静态代理的缺点：需要实现跟目标对象一样的接口，耦合度高，难以维护

优点：因为实现了相同的接口，所以可以扩展需要代理的类。

以下为代码：

package proxyTest;
//静态代理的实现
//代理模式，就是面向相同接口的编程
//所以需要实现相同的接口
public class proTest implements userDao {
    private userDao userDao;
    public proTest(userDao userDao){
        this.userDao = userDao;
    }

    @Override
    public void sys() {
        System.out.println("前置");
        userDao.sys();
        System.out.println("后置");
    }
    
    public static void main(String[] args) {
        userDaoService userDaoService = new userDaoService();
        proTest proTest = new proTest(userDaoService);
        proTest.sys();
    }
}

interface userDao{
    public void sys();
}

class userDaoService implements userDao{
    @Override
    public void sys() {
        System.out.println("实现userDao");
    }

}

动态代理模式：jdk动态代理，cglib动态代理

动态代理：在程序运行期间达到代理的效果，代码不会耦合，可维护性好。

缺点：被代理的对象必须实现对应的接口。

以下是jdk动态代理的代码：

package proxyTest;

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

//jdk动态代理
public class jdkProxy implements InvocationHandler {
    private userD userD;
    public jdkProxy(userD userD){
        this.userD = userD;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("前置");
        method.invoke(userD,args);
        System.out.println("后置");
        return null;
    }

    public static void main(String[] args) {
        userDSer userD1 = new userDSer();
        proxyTest.userD userD  =
                (userD) Proxy.newProxyInstance(jdkProxy.class.getClassLoader(),userD1.getClass().getInterfaces(),new jdkProxy(userD1));
        userD.sys();
    }
}
interface userD{
    public void sys();
}
class userDSer implements userD{

    @Override
    public void sys() {
        System.out.println("jdk动态代理");
    }
}

cglib代理：也叫做子类代理

package proxyTest;

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

import java.lang.reflect.Method;

//cglib测试类
//jdk动态代理 和静态代理都需要实现对应的接口
//必须面向接口编程
//若需要代理的类没有实现对应的接口
//就需要用到cglib代理
public class cglibTest implements MethodInterceptor{
//    private cgTest cgTest;
//    public cglibTest(cgTest cgTest){
//        this.cgTest = cgTest;
//    }

    /**
     * o 表示被代理的对象
     * method 代理对象所执行的方法
     * objects 方法参数
     * methodProxy 所执行方法的代理
     * */
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("调用前");
        methodProxy.invokeSuper(o,objects);
        System.out.println("调用后");
        return null;
    }

    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer();//字节码生成器
        enhancer.setSuperclass(cgTest.class);//设置代理的类
        enhancer.setCallback(new cglibTest());//设置回调方法
        cgTest cgTest = (cgTest) enhancer.create();
        cgTest.sys();

    }
}
class cgTest{
    public void sys(){
        System.out.println("cglib");
    }
}