静态代理和动态代理（两种）

1、静态代理（装饰者模式）

//1、首先创建一个接口，定义一个方法
public interface UserService { 
    /**
     * 模拟装修
     */
    void save();
}

//2、编写接口的实现类，这里的save() 方法可以理解为原始方法
public class UserServiceImpl implements UserService {
    @Override
    public void save() {
        System.out.println("开始给墙刷大白");
    }
}

//3、编写代理类，实现此接口，定义成员变量和带参构造方法，然后重写save方法，调用原save方法后编写增强代码
public class Decorator01 implements UserService {

    private UserService userService;
    public Decorator01(UserService userService) {
        this.userService = userService;
    }

    @Override
    public void save() {
        userService.save();
        System.out.println("方法加强： 开始贴瓷砖了");
    }
}

//4、编写测试类，测试方法是否被增强，需要注意的是，代理类需要传入实现类的对象参数
    @Test
    public void test01() {

        UserServiceImpl userService = new UserServiceImpl();
        userService.save();
        System.out.println("-----------------");
        Decorator01 decorator01 = new Decorator01(userService);
        decorator01.save();
    }  

静态代理
优点：不改变原有代码的情况下对方法进行了增强，提高了代码的复用性
缺点：代理对象仅支持当前接口，多个接口需要编写多个实现类
且接口中添加方法时，所有实现类和代理类都要实现新添加的方法

2、动态代理

2.1 基于接口（jdk默认）

//基于接口的动态代理，格式比较固定，只需要在重写的invoke方法里添上增强代码即可
public class JDKProxy {
    public  UserService getUserServiceImpl(UserService userService){
        UserService proxy = (UserService) Proxy.newProxyInstance(
                userService.getClass().getClassLoader(),
                userService.getClass().getInterfaces(),
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                        Object rtValue = method.invoke(userService, args);
                        System.out.println("贴壁纸了");
//匹配方法名进行增强
                        String methodName = method.getName();
                        if ("save".equals(methodName)){
                            System.out.println("匹配到了save方法，再一次给墙装修，挂上字画");
                        }
                        return rtValue;
                    }
                }
        );
        return proxy;
    }
}
//对基于jdk动态代理类进行测试
   @Test
    public void test001(){
        UserServiceImpl userService = new UserServiceImpl();
        UserService proxy = new JDKProxy().getUserServiceImpl(userService);
        proxy.save();
    }

基于jdk的动态代理
优点：不修改原有代码对方法进行增强，提高代码的复用性
缺点：只能通过接口方式进行代理，若没有接口就不能实现此种动态代理

2.2 基于子类

//基于子类的动态代理，格式依旧比较固定，在重写的方法里添上增强代码
public class TestCglibProxy {

    public UserService getCglibProxy(Class clazz){
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(clazz);
        enhancer.setCallback(new MethodInterceptor() {
            @Override
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                Object rtValue = null;
                if("save".equals(method.getName())){
                    rtValue = methodProxy.invokeSuper(o,objects);
                    System.out.println("我使用cglib代理对save方法进行了增强");
                }
                return rtValue;
            }
        });
        return (UserService) enhancer.create();
    }
}
//测试基于cglib的动态代理
 @Test
    public void tes002(){
        UserService cglibProxy = new TestCglibProxy().getCglibProxy(UserServiceImpl.class);
        cglibProxy.save();
    }

优点：不改变原有代码的情况下对方法进行了增强，提高了代码的复用性
缺点：只能通过继承关系来实现动态代理，若被代理类final修饰则不适用
（spring 里可以通过配置来选择动态代理的方式，默认是基于接口方式）

静态/动态代理区别：
静态代理在原方法执行前就已经编译
动态代理是在执行到原始方法时才开始增强原方法