spring第三天（下）

动态代理 专题

这里重新创建一个工程，分别实现基于接口和基于子类的动态代理，

模拟的是生产商（IProducer）和销售商（Producer）的功能，客户（Client）从销售商买商品，销售商从生产商买商品。

基于接口的动态代理

public interface IProducer { 
    /**
     * 销售
     * @param money
     */
    public void saleProduct(float money);

    /**
     * 售后
     * @param money
     */
    public void afterService(float money);
}

public class Producer{ 
    /**
     * 销售
     * @param money
     */
    public void saleProduct(float money){
        System.out.println("销售产品，并拿到钱："+money);
    }

    /**
     * 售后
     * @param money
     */
    public void afterService(float money){
        System.out.println("提供售后服务，并拿到钱："+money);
    }
}

这里实现的是销售售卖商品的功能，假设客户购买商品付了10000元，销售只能拿到除了从工厂所付的20%的成本外的80%,这里通过动态代理来增强。

public class Client {

    public static void main(String[] args) {
        final Producer producer = new Producer(); 
        //这里实现的是一个接口的动态代理，使用Proxy.newProxyInstance()方法，这里的方法要加入类加载器和接口加载器，还有要加强的方法
        IProducer proxyPruoduce = (IProducer) Proxy.newProxyInstance(producer.getClass().getClassLoader(), producer.getClass().getInterfaces(), new InvocationHandler() {
            /**
             * 执行被代理的任何接口方法都会经过该方法
             * @param proxy     代理对象的引用
             * @param method    当前执行的方法
             * @param args      当前执行方法所需的参数
             * @return
             * @throws Throwable
             */
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                //提供增强的代码
                Object returnValue = null;
                //获取方法执行的参数，这里的参数只有一个money
                Float money = (Float) args[0];
                //判断当前方法是不是销售
                if("saleProduct".equals(method.getName())){
                    returnValue=method.invoke(producer,money*0.8f);
                }

                return returnValue;
            }
        });
        proxyPruoduce.saleProduct(10000f);
    }
}

基于子类的动态代理

如果直接基于子类的动态代理的话，要引入cglib依赖，

<dependencies>
        <dependency>
            <groupId>org.sonatype.sisu.inject</groupId>
            <artifactId>cglib</artifactId>
            <version>2.2.1-v20090111</version>
        </dependency>
    </dependencies>

public class Client {

    public static void main(String[] args) {
        final Producer producer = new Producer(); 
        //基于子类的动态代理，使用Enhancer.create(),这里的参数只需传入字节码和所要加强的方法
        Producer cglibProducer = (Producer)Enhancer.create(Producer.class, new MethodInterceptor() {
            public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
                //提供增强的代码
                Object returnValue = null;
                //获取方法执行的参数
                Float money = (Float) args[0];
                //判断当前方法是不是销售
                if("saleProduct".equals(method.getName())){
                    returnValue=method.invoke(producer,money*0.8f);
                } 
                return returnValue;
            }
        });
        cglibProducer.saleProduct(12000f);
    }
}

AOP

AOP就是把我们程序重复的代码抽取出来，在需要执行的时候，使用动态代理的技术，在不修改源码的基础上，对我们的已有方法进行增强。
使用spring框架，将以上的操作交给spring。

名词解释

Joinpoint(连接点):
所谓连接点是指那些被拦截到的点。在 spring 中,这些点指的是方法,因为 spring 只支持方法类型的
连接点。
Pointcut(切入点):（被加强的才叫切入点）
所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义。
Advice(通知/增强):
所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知。
通知的类型：前置通知,后置通知,异常通知,最终通知,环绕通知。
Introduction(引介):
引介是一种特殊的通知在不修改类代码的前提下, Introduction 可以在运行期为类动态地添加一些方
法或 Field。
Target(目标对象):
代理的目标对象。
Weaving(织入):
是指把增强应用到目标对象来创建新的代理对象的过程。
spring 采用动态代理织入，而 AspectJ 采用编译期织入和类装载期织入。
Proxy（代理）:
一个类被 AOP 织入增强后，就产生一个结果代理类。
Aspect(切面):
是切入点和通知（引介）的结合。

来源：CSDN

作者：weixin_43427728

链接：https://blog.csdn.net/weixin_43427728/article/details/104104510