第06天 静态代理和动态代理

public interface UserService {

     String sell(String message);
}

public class UserServiceImpl implements UserService{
    public String sell(String message) {
        System.out.println("我是房东-->我要卖房,找我签合同");
        return message;
    }
}

public class UserServiceProxy implements UserService{

    private UserService userService;

    public UserServiceProxy(UserService userService) {
        this.userService = userService;
    }

    @Override
    public String sell(String message) {
        System.out.println("我是中介,我可以带你去看房");
        userService.sell(message);
        //调用方法之后，我们同样可以添加自己的操作
        System.out.println("after method send()");
        return null;
    }
}

@org.junit.Test
    public void name() {
        UserServiceImpl userService = new UserServiceImpl();
        UserServiceProxy userServiceProxy = new UserServiceProxy(userService);
        userServiceProxy.sell("卖房");
    }
}

1. 静态类文件数量过多，不利于项目管理
   UserServiceImpl  UserServiceProxy
   OrderServiceImpl OrderServiceProxy
2. 额外功能维护性差
   代理类中 额外功能修改复杂(麻烦)

概念：通过代理类为原始类(目标类)增加额外功能,代理类由Spring动态生成。
好处：利于原始类(目标类)的维护

public static newProxyInstance ( ClassLoader loader, Class<?>[] interfaces,InvocationHandler handler)
    
loader：目标类的类加载器，通过目标对象的反射可获取
interfaces：目标类实现的接口数组，通过目标对象的反射可获取
handler：调用处理器。

public Object invoke ( Object obj, Object... args)
    
obj：表示目标对象
args：表示目标方法参数，就是其上一层 invoke 方法的第三个参数
该方法的作用是：调用执行 obj 对象所属类的方法，这个方法由其调用者 Method 对象确定。在代码中，一般的写法为
method.invoke(target, args);
其中，method 为上一层 invoke 方法的第二个参数。这样，即可调用了目标类的目标方法。

InvocationHandler 接口叫做调用处理器，负责完成调用目标方法，并增强功能。通过代理对象执行目标接口中的方法 ， 会把方法的调用分派给调用处理器(InvocationHandler)的实现类，执行实现类中的 invoke()方法，我们需要把功能代理写在 invoke（）方法中 。此接口中只有一个方法。

package com.leo.demo02.service.impl;

import com.leo.demo02.service.UserService;

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

/**
 * @author : Leo
 * @version 1.0
 * @date 2023/8/14 13:40
 * @description :
 */
public class ProxyFactory {

    /**任何的代理对象，都要清楚目标对象，在此得设置一个目标对象*/
    private UserService userService;

    //传入目标对象

    public ProxyFactory(UserService userService){
        this.userService = userService;
    }

    /** 给目标对象生成代理实例 */
    public Object getProxyInstance(){
        return Proxy.newProxyInstance(
                //指定当前目标对象，使用类加载器获得
                userService.getClass().getClassLoader(),
                //获得目标对象实现的所有接口
                userService.getClass().getInterfaces(),
                //处理代理实例上的方法并返回调用结果
                new InvocationHandler() {
                    @Override
                    public Object invoke(
                            //代理对象的实例
                            Object proxy,
                            //代理的目标对象的实现方法
                            Method method,
                            //代理的目标对象实现方法的参数
                            Object[] args) throws Throwable {
                        System.out.println("我是中介,我在张贴广告......");
                        System.out.println("我是中介,我在带领租客看房子......");
                        //目标对象执行自己的方法
                        Object returnValue = method.invoke(userService, args);
                        System.out.println("我是中介,我在带领租客办理结束流程");
                        return returnValue;
                    }
                });
    }
}

@org.junit.Test
   public void test03() {
       // 创建代理工厂对象
       ProxyFactory factory = new ProxyFactory(new UserServiceImpl());
       UserService service = (UserService) factory.getProxyInstance();
       service.sell("卖房");
   }

package com.leo.demo02.service.impl;

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

/**
 * @author : Leo
 * @version 1.0
 * @date 2023/8/14 14:00
 * @description :
 */
public class ProxyFactory2 implements MethodInterceptor {
    /** 目标对象 */
    private Object target;

    /** 传入目标对象 */
    public ProxyFactory2(Object target){
        this.target = target;
    }
    /** Cglib采用底层的字节码技术，在子类中采用方法拦截的技术，拦截父类指定方法的调用，并顺势植入代理功能的代码 */
    @Override
    public Object intercept(Object obj, Method method, Object[] arg2, MethodProxy proxy) throws Throwable {
        //代理对象的功能
        System.out.println("我是中介,我在张贴广告......");
        System.out.println("我是中介,我在带领租客看房子......");
        //调用目标对象的方法
        Object returnValue=method.invoke(target, arg2);
        //代理对象的功能
        System.out.println("我是中介,我在带领租客办理结束流程");
        return returnValue;
    }
    /** 生成代理对象 */
    public Object getProxyInstance(){
        //1.使用工具类
        Enhancer en=new Enhancer();
        //2.设置父类
        en.setSuperclass(target.getClass());
        //3.设置回调函数
        en.setCallback(this);
        //4.创建子类（代理）对象
        return en.create();
    }}

 @org.junit.Test
    public void test04() {
        UserService service = (UserService)new ProxyFactory2(new UserServiceImpl()).getProxyInstance();
        service.sell("卖房");
}