静态代理

缺点:
1.直接在编译期间就确定了代理对象和被代理对象，没有体现动态性
2.如果多个代理类需要被代理则会创建过多的被代理类

package com.cff.zhum.proxy;

/**
 * @author by_zhum
 * @date 2021/9/27 20:00
 * @Version 1.0
 * 静态代理类模式
 *  缺点: 1.直接在编译期间就确定了代理对象和被代理对象，没有体现动态性
 *       2.如果多个代理类需要被代理则会创建过多的被代理类
 */


// 生产衣服的接口
interface ClothFactory{
    void produceCloth();
}


// 代理类对象
class ProxyClothFactory implements ClothFactory{


    private ClothFactory clothFactory;

    ProxyClothFactory(ClothFactory clothFactory){
        this.clothFactory=clothFactory;
    }

    @Override
    public void produceCloth() {
        System.out.println("被代理类方法执行之前");
        clothFactory.produceCloth();
        System.out.println("被代理类执行方法之后");
    }
}


// 被代理类对象
class NikeClothProxy implements ClothFactory{

    @Override
    public void produceCloth() {
        System.out.println("生产nike衣服");
    }
}

public class StaticProxy {
    public static void main(String[] args) {
        // 1.创建被代理类对象
        NikeClothProxy nikeClothProxy = new NikeClothProxy();
        // 2.创建代理对象
        ProxyClothFactory proxyClothFactory = new ProxyClothFactory(nikeClothProxy);
        proxyClothFactory.produceCloth();
    }
}

动态代理

• 优点:
  1.可以动态的创建被代理对象,不需要在编译期间确定，在运行期时确定
  2.只需要写一个被代理对象为多个代理对象进行代理

package com.cff.zhum.proxy;

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

/**
 * @author by_zhum
 * @date 2021/9/27 20:09
 * @Version 1.0
 * 动态代理
 *  优点:  1.可以动态的创建被代理对象,不需要在编译期间确定，在运行期时确定
 *        2.只需要写一个被代理对象为多个代理对象进行代理
 */

interface Person{
    void getBelieve();
    String eat();
}

//创建被代理类

class Human implements Person{

    @Override
    public void getBelieve() {
        System.out.println("信仰");
    }

    @Override
    public String eat() {
        return "吃食物！！！";
    }
}


// 创建代理类

class ProxyFactory{

//    public static Object getNewProxy(Object object){
//       MyInvocationHandle myInvocationHandle = new MyInvocationHandle(object);
//        return Proxy.newProxyInstance(object.getClass().getClassLoader(),object.getClass().getInterfaces(),myInvocationHandle);
//    }

//    public static Object getNewProxy(Object object){
//        //   MyInvocationHandle myInvocationHandle = new MyInvocationHandle(object);
//        return Proxy.newProxyInstance(object.getClass().getClassLoader(),object.getClass().getInterfaces(),(proxy, method, args)->{
//            System.out.println("方法进行增强之前");
//            // 执行被代理类的方法
//            Object invoke = method.invoke(object, args);
//
//            System.out.println("方法进行增强之后");
//            return invoke;
//        });
//    }

    public static Object getNewProxy(Object object){
        return Proxy.newProxyInstance(object.getClass().getClassLoader(), object.getClass().getInterfaces(), new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("方法进行增强之前");
                // 执行被代理类的方法
                Object invoke = method.invoke(object, args);

                System.out.println("方法进行增强之后");
                return invoke;
            }
        });
    }
}


class MyInvocationHandle implements InvocationHandler{
    // 被代理对象
    private Object object;

    MyInvocationHandle(Object object){
        this.object=object;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        System.out.println("方法进行增强之前");
        // 执行被代理类的方法
        Object invoke = method.invoke(object, args);

        System.out.println("方法进行增强之后");
        return invoke;
    }
}


public class DynamicProxy {
    public static void main(String[] args) {
        // 创建别代理类
        Human human = new Human();
        // 此处返回的是一个被代理对象
        Person newProxy = (Person) ProxyFactory.getNewProxy(human);
        System.out.println(newProxy.eat());
        newProxy.getBelieve();
    }
}