Spring之面向接口增强实现类

Spring之面向接口增强实现类

使用场景：在不修改原有代码的 或者没有办法修改原有代码的情况下 增强对象功能 使用代理对象 代替原来的对象去完成功能进而达到拓展功能的目的
代理模式
是通过代理对象访问目标对象，这样可以在目标对象基础上增强额外的功能，如添加权限，访问控制和审计等功能。
例如：房产中介代替业主卖房

静态代理
静态代理中代理类与被代理类都需要实现同一个接口，这就说明我们的一个静态代理类只能代理一个类，并且还要事先知道我们要代理哪个类才能写代理类，如果我们有其他类还想使用代理那就必须再写一个代理类。
然而在实际开发中我们是可能是有非常多的类是需要被代理的，并且事先我们可能并不知道我们要代理哪个类。所以如果继续使用静态代理反而会增加许多的工作量，并且效率低下，代码复用率也不好。

package com.mrshun.test;

public class Test1 {

    public static void main(String[] args) {
        Person person=new Person("张三");
        Lawyer lawyer=new Lawyer(person);
        lawyer.doCourt();
    }
}

interface Court{
    void doCourt();
}

class Lawyer implements Court{
    private Person person;

    public Lawyer(Person person) {
        this.person=person;
    }

    @Override
    public void doCourt() {
        System.out.println("律师取证：视频证明张三当时不在案发现场");
        person.doCourt();
    }
}

class Person implements Court{

    private String name;

    public Person(String name) {
        this.name = name;
    }

    @Override
    public void doCourt() {
        System.out.println(name+"说：我没有杀人");
    }
}

动态代理
动态代理可以针对于一些不特定的类或者一些不特定的方法进行代理,我们可以在程序运行时动态的变化代理的规则，代理类在程序运行时才创建的代理模式成为动态代理。这种情况下，代理类并不是在Java代码中定义好的，而是在程序运行时根据我们的在Java代码中的“指示”动态生成的

1. Proxy 动态代理 JDK动态代理 面向接口

2. cglib 动态代理 第三方动态代理 面向父类

 package com.mrshun.testProxy;

import javax.swing.*;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;

public class Test1 {
    public static void main(String[] args) {
        final Dinner dinner=new Person("张三");
        //通过Proxy动态代理获得一个代理对象，在代理对象中，对某个方法进行增强
        //ClassLoader loader, 被代理的类加载器
        ClassLoader classLoader = dinner.getClass().getClassLoader();
        //Class<?>... interfaces，被代理对象所实现的所有接口
        Class[] interaces= dinner.getClass().getInterfaces();
        //InvocationHandler h，执行处理对象，专门用于定义增强的规则
        InvocationHandler handler=new InvocationHandler(){
            //invoke 当我们让代理对象调用任何方法时，都会触发invoke方法
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                Object res;
                //object proxy，被代理对象
                //System.out.println(proxy);//proxy-->invoke-->proxy
                //Method method,被代理的方法
                System.out.println(method.getName());
                //object[] args,被代理对象方法运行的实参
                if(method.getName().equals("eat")){
                    System.out.println("饭前洗手");
                    res = method.invoke(dinner,args);
                    System.out.println("饭后刷碗");
                }else {
                    res = method.invoke(dinner,args);
                }
                System.out.println(Arrays.toString(args));
                return null;
            }
        };
        Dinner dinnerProxy=(Dinner) Proxy.newProxyInstance(classLoader,interaces,handler);
        //dinnerProxy.eat("包子");
        dinnerProxy.drink();
    }
}

interface Dinner{
    void eat(String  footName);
    void drink();
}

class Person implements Dinner{
    private String name;

    public Person(String name) {
        this.name = name;
    }

    @Override
    public void eat(String footName) {
        System.out.println(name+"正在吃"+footName);
    }


    @Override
    public void drink() {
        System.out.println(name+"正在喝茶");
    }
}

class Student implements Dinner{
    private String name;

    public Student(String name) {
        this.name = name;
    }

    @Override
    public void eat(String footName) {
        System.out.println(name+"正在吃"+footName);
    }

    @Override
    public void drink() {
        System.out.println(name+"正在喝可乐");
    }
}

使用代理技术 获得代理对象 代替张三 增强打官司的方法

总结

1.在不修改原有代码的 或者没有办法修改原有代码的情况下 增强对象功能 使用代理对象 代替原来的对象去完成功能进而达到拓展功能的目的
2.JDK Proxy 动态代理面向接口的动态代理 一定要有接口和实现类的存在 代理对象增强的是实现类 在实现接口的方法重写的方法生成的代理对象只能转换成 接口的不能转换成 被代理类代理对象只能增强接口中定义的方法 实现类中其他和接口无关的方法是无法增强的代理对象只能读取到接口中方法上的注解 不能读取到实现类方法上的注解