类增强的实现方式

一:静态代理

1.继承

基础,此处省略

2.装饰者模式

接口

public interface Service {
    void speak();
    void sing();
}

实现类

public class ServiceImpl implements Service {

    @Override
    public void speak() {
        System.out.println("讲故事");
    }
 
    @Override
    public void sing() {
        System.out.println("唱歌");
    }
}

装饰者模式类

public class ServiceImplDecortar implements Service {

    private Service service;
 
    public ServiceImplDecortar(Service service) {
        this.service = service;
    }
 
    @Override
    public void speak() {
        service.speak();
        System.out.println("大声地讲故事");
    }
 
    @Override
    public void sing() {
        service.sing();
        System.out.println("大声地唱歌");
    }
}

测试类

public class App {
    public static void main(String[] args) {
        //没有使用装饰者模式的情况下
        Service service = new ServiceImpl();
        Service service1=new ServiceImplDecortar(service);
        //增强后的方法
        service1.speak();
        service1.sing();
    }
}

二:动态代理

1.jdk动态代理

动态代理类

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
 
public class ServiceProxy {
    public  static Service createServiceProxy(Service service) {
        ClassLoader classLoader = service.getClass().getClassLoader();
        Class[] interfaces = service.getClass().getInterfaces();
        InvocationHandler invocationHandler = new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                if (method.getName().equals("speak")) {
                    //执行原来的方法！(顺序和执行的逻辑有关)
                    Object invoke = method.invoke(service, args);
                    //做增强
                    System.out.println("大声的讲故事");
                    //返回方法的执行结果
                    return invoke;
                } else if (method.getName().equals("sing")) {
                    //执行原来的方法！
                    Object invoke = method.invoke(service, args);
                    //做增强
                    System.out.println("大声的唱歌");
                    //返回方法的执行结果
                    return invoke;
                }
                //没有对应的方法
                return null;
            }
        };
        Service service1 = (Service) Proxy.newProxyInstance(classLoader, interfaces, invocationHandler);
        return service1;
    }
}

测试类

public class App {
    public static void main(String[] args) {
        //没有使用装饰者模式的情况下
        Service service = new ServiceImpl();
       // Service service1=new ServiceImplDecortar(service);
       //jdk动态代理
        Service service1= ServiceProxy.createServiceProxy(service);
        //增强后的方法
        service1.speak();
        service1.sing();
    }
}

2.cglib动态代理

cglib动态代理比较jdk的动态代理强大，可以对任意类做增强，不需要接口！

动态代理类:

public class CGLIBService {
    public static Service createService(Class clazz) {
        //创建字节码对象
        Enhancer enhancer = new Enhancer();
        //设置Enhancer对象的父类是指定类型，也就是service的实现类即需要增强的类
        enhancer.setSuperclass(clazz);
        //设置回调方法
        enhancer.setCallback(new MethodInterceptor() {
            public Object intercept(Object o, Method method, Object[] args,
                                    MethodProxy methodProxy) throws Throwable {
                //使用父类的方法调用
                Object ret = methodProxy.invokeSuper(o, args);
                if (method.getName().equals("speak")) {
                    System.out.println("大声讲");
                }
                if (method.getName().equals("sing")) {
                    System.out.println("大声唱");
                }
                //返回执行结果
                return ret;
            }
        });
        //使用Enhancer对象创建对应的对象
        return (Service) enhancer.create();
    }
}

测试类:

public class App {
    public static void main(String[] args) {
        //没有使用装饰者模式的情况下
        // Service service = new ServiceImpl();
        // Service service1=new ServiceImplDecortar(service);
        // Service service1= ServiceProxy.createServiceProxy(service);
        Service service1 = CGLIBService.createService(ServiceImpl.class);
        //增强后的方法
        service1.speak();
        service1.sing();
    }
}

三:静态代理与动态代理的注入时机

	动态代理	静态代理
注入时机	运行	编译