动态代理

静态代理

代码示例

/*
 * @program: day-01
 *
 * @description: 静态代理
 *
 * @author: 2021-04-13 13:43
 **/

public class Demo {
    public static void main(String[] args) {
        ClothFactory nikeFactory = new NikeClothFactory();
        ClothFactory proxyFactory = new ProxyClothFactory(nikeFactory);
        proxyFactory.produceCloth();
    }
}

interface ClothFactory{
    void produceCloth();
}



class ProxyClothFactory implements ClothFactory{
    private ClothFactory factory;

    public ProxyClothFactory(ClothFactory factory) {
        this.factory = factory;
    }

    @Override
    public void produceCloth() {
        System.out.println("代理类工厂做一些准备工作");
        this.factory.produceCloth();
        System.out.println("代理类工厂做一些收尾工作");
    }
}



class NikeClothFactory implements ClothFactory{

    @Override
    public void produceCloth() {
        System.out.println("耐克生产服装");
    }
}

动态代理

java中的动态代理，实际上指的是反射包java.lang.reflect下的类Proxy

Proxy提供用于创建动态代理类和示例的静态方法，他还是由这些方法创建的所有动态代理类的超类。
动态代理类是一个实现在创建类时在运行时指定的接口列表的类，该类具有下面描述的行为。
代理接口：代理类实现的一个接口
代理实例：代理类的一个实例，每个代理实例都有一个关联的调用处理程序对象，它可以实现接口InvocationHandler。通过其中一个代理接口的代理实例上的方法调用将指派到实例的调用处理程序的invoke方法，并传递代理实例、识别调用方法的java.lang.reflect.Method对象以及包含参数的Object类型的数组。调用处理程序以适当的方式处理编码的方法调用，并且它返回的结果将作为代理实例上方法调用的结果返回

使用动态代理，主要是使用类Proxy的一个静态方法newProxyInstance:

public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,IncocationHandler h) throws IllegalArgumentException{//.....}

该方法返回一个指定接口的代理类实例，该接口可以将方法调用指派到指定的调用处理程序（InvocationHandler）
该方法有三个参数：

1. loader：定义代理类的类加载器
2. interfaces：代理类要实现的接口列表
3. h：指派方法调用的调用处理程序
   关于参数 h，它是一个InvocationHandler接口，表示代理实例的调用处理程序 实现的接口。每个代理实例都具有一个关联的调用处理程序。对代理实例调用方法时，将对方法调用进行编码并将其指派到它的调用处理程序的 invoke 方法。
   方法返回值表示：一个带有代理类的指定调用处理程序的代理实例，它由指定的类加载器定义，并实现指定的接口。

反射Proxy类的使用
作用：创建代理对象
之前创建对象方式：new 类的构造方法
现在使用Proxy类的方法代替new使用
方法：静态方法newProxyInstance()
作用：创建代理对象，等同于静态代理对象 new 构造方法()

参数：

• ClassLoader loader：类的加载器，负责向内存中加载对象的
  1. 使用反射获取对象的ClassLoader
  2. 类.getClass().getClassLoader()
  3. 这个是目标对象的类的加载器
• Class<?>[] interfaces:目标所实现的接口，也是通过反射获取
• InvocationHandler h：我们自己写的，代理类要完成的功能
• 返回值就是代理对象

InvocationHandler（调用处理器）

• 是一个接口，就有一个方法invoke()
  1. invoke()表示代理对象要执行的功能代码
  2. 你的代理类要完成的功能就卸载invoke()方法中
• 代理类完成的功能
  1. 调用目标方法，执行目标方法
  2. 功能增强，在目标方法调用后需要做的事情

参数

• Object proxy：jdk创建的代理对象，无需赋值
• method：目标类中的方法，jdk提供的method对象
• args：目标类中的方法参数，jdk提供
  public Object invoke(Object proxy,Method method,Object[] args)
  怎么用
• 创建一个类实现接口InvocationHandler
• 重写invoke()方法，将原来静态代理中代理类要完成的功能写在这

jdk动态代理实现

• 创建接口，定义目标要完成的功能
• 创建目标类实现接口
• 创建InvocationHandler接口的实现类，在invoke方法中实现代理类的功能
  1. 调用目标方法
  2. 增加功能
• 使用Proxy类的静态方法来创建代理对象，并将返回值转为接口类型

/*
 * @program: day-01
 *
 * @description: 动态代理
 * 
 * @author: 2021-04-13 15:36
 **/

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

public class ProxyMain {
    public static void main(String[] args) {
        //使用Proxy类的静态方法来创建代理对象，并将返回值转为接口类型

        //1、创建目标对象
        Usbsell usbSell = new usbKingFactory();
        //2、创建InvocationHandler对象
        InvocationHandler invocationHandler = new MySellHandler(usbSell);

        //3、创建代理
        Usbsell proxy = (Usbsell) Proxy.newProxyInstance(usbSell.getClass().getClassLoader(), usbSell.getClass().getInterfaces(),invocationHandler);
        System.out.println(proxy.getClass().getName());

        //4、通过代理执行方法
        float sell = proxy.sell(1);
        System.out.println("通过动态代理对象，调用方法 = " + sell);

    }
}


//创建目标接口
interface Usbsell{
    float sell(int amount);

}

//金士顿工厂接口
class usbKingFactory implements Usbsell{

    @Override
    public float sell(int amount) {
        System.out.println("目标类中执行了sell目标方法");
        return 85.0f;
    }
}


//InvocationHandler 接口的实现类
class MySellHandler implements InvocationHandler{
    private Object object = null;

    public MySellHandler(Object object) {
        this.object = object;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object res = null;
        res = method.invoke(object,args);

        if(res != null){
            Float price = (Float) res;
            price = price + 25;
            res = price;
        }
        return res;
    }
}

java8 新特性

lambda表达式

本质：作为函数式接口的实例

Comparator<Integer> com = (o1, o2) -> Integer.compare(o1,o2);

System.out.println(com.compare(12,13)); // -1

函数式接口

如果一个接口中，只声明了一个抽象方法，则此接口i称为函数式接口

java内置抵达核心函数式接口

• void Consumer 消费型接口 对类型为T的对象应用操作，包含方法： void accept(T t)
• T Suplier 供给型接口 返回类型为T的对象，包含方法：T get()
• R Function<T,R> 对类型为T的对象应用操作，并返回结果。结果是R类型的对象。包含方法 R apply(T t)
• boolean Predicate 确定类型为T的对象是否满足某约束，并返回boolean值，包含方法boolean test(T t)

public class Demo03 {
    public static void main(String[] args) {
        Comparator<Integer> com = (o1, o2) -> Integer.compare(o1,o2);

        System.out.println(com.compare(12,13));
        happyTime(22.22,(money)->{
            System.out.println("好家伙，花里胡哨的" + money);
        });



        List<String> list = Arrays.asList("北京","南京","西京","东京","天津","普京");
        List<String> filterStrs = filterString(list,s->s.contains("京"));
        System.out.println(filterStrs);
    }


    public static void happyTime(double money, Consumer<Double> con){
        con.accept(money);
    }

    public static List<String> filterString(List<String> list, Predicate<String> pre){
        ArrayList<String> filterList = new ArrayList<>();
        for (String s: list
             ) {
            if(pre.test(s)){
                filterList.add(s);
            }
        }
        return filterList;
    }
}

方法引用

• 当要传递给Lambda体的操作，已经有实现的方法了，可以使用引用！
• 方法引用就是Lambda表达式，也就是函数式接口的一个实例，通过方法的名字来指向一个方法，可以认为是Lambda表达式的一个语法糖
• 要求：实现接口的抽象方法的参数列表和返回值类型，必须与方法引用的方法的参数列表和返回值类型保持一致
• 格式：使用操作符"::"将类或对象与方法名分隔开来
• 如下三种主要使用情况：
  1. 对象::实例方法名
  2. 类::静态方法名
  3. 类::实例方法名

//类名::静态方法名
//Integer对象有一个静态方法
public static int compare(int x, int y) {
    return (x < y) ? -1 : ((x == y) ? 0 : 1);
}

//普通lambda调用
List<Integer> integers = Arrays.asList(23,12,100,98);
integers.sort((arg1,arg2) -> Integer.compare(arg1,arg2));
System.out.println(integers);

//方法引用调用
List<Integer> integers = Arrays.asList(23,12,100,98);
integers.sort(Integer::compare);
System.out.println(integers);

//对象引用名::实例方法名
//新创建一个类，可以对Integer进行排序
public class IntegerComparator {
    public int compare(Integer arg1,Integer arg2){
        return arg1-arg2;
    }
}

//普通lambda调用
IntegerComparator integerComparator = new IntegerComparator();
List<Integer> integers = Arrays.asList(23,12,100,98);
integers.sort((arg1,arg2)->integerComparator.compare(arg1,arg2));

//方法引用调用
IntegerComparator integerComparator = new IntegerComparator();
List<Integer> integers = Arrays.asList(23,12,100,98);
integers.sort(integerComparator::compare);

//类名::实例方法名
//在看Integer对象有这样非静态的方法
public int compareTo(Integer anotherInteger) {
    return compare(this.value, anotherInteger.value);
}

//普通lambda调用
List<Integer> integers = Arrays.asList(23,12,100,98);
integers.sort((arg1,arg2) -> arg1.compareTo(arg2));

//方法引用调用
integers.sort(Integer::compareTo);