动态代理-JDK

1.必须创建接口

关键：

使用 Proxy 类创建 代理类对象 （需要传入代理类对象，目标类装载类，目标类接口）

//返回一个指定接口的代理类实例(是一个接口对象)
        Object o = Proxy.newProxyInstance(UserServiceImpl.class.getClassLoader(), // 目标类对象的装载类
                UserServiceImpl.class.getInterfaces(),  // 目标类接口
                jdkProxy); //指派到指定的调用处理类对象

1.接口

package com.lt.test.service;

public interface UserService {
    void func();

    void func2();
}

2.实现类

package com.lt.test.service.impl;

import com.lt.test.service.UserService;

public class UserServiceImpl implements UserService {
    @Override
    public void func() {
        System.out.println("目标类方法1");
    }

    @Override
    public void func2() {
        System.out.println("目标方法2");
    }


}

3.代理类1

package com.lt.test.proxy;

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

//动态代理类
public class JDKProxy implements InvocationHandler {

    private Object target;

    //传入需要代理的目标对象
    public JDKProxy(Object target) {
        this.target = target;
    }

    //方法调用
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        if("func".equals(method.getName())){
            System.out.println("before func");
            Object result = method.invoke(target,args); //传入方法，参数，和目标对象
            System.out.println("after func");
            return result;
        } else if("func2".equals(method.getName())){
            System.out.println("before func2");
            Object result = method.invoke(target,args); //传入方法，参数，和目标对象
            System.out.println("after func2");
            return result;
        }

        return null; //返回值
    }
}

代理类2

package com.lt.test.proxy;

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

//动态代理类
public class JDKfun2Proxy implements InvocationHandler {

    private Object target;

    //传入需要代理的目标对象
    public JDKfun2Proxy(Object target) {
        this.target = target;
    }

    //方法调用
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("before func2 JDKfun2Proxy");
        Object result = method.invoke(target,args); //传入方法，参数，和目标对象
        System.out.println("after func2 JDKfun2Proxy");
        return result;
    }
}

4.测试类

package com.lt.test;

import com.lt.test.proxy.JDKProxy;
import com.lt.test.proxy.JDKfun2Proxy;
import com.lt.test.service.UserService;
import com.lt.test.service.impl.UserServiceImpl;

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

public class demo3 {
    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        UserServiceImpl userService = new UserServiceImpl();
        userService.func();
        userService.func2();
        JDKProxy jdkProxy = new JDKProxy(userService); //指派到指定的调用处理类对象。

        //强类型转换调用
        UserService userService1 = (UserService) Proxy.newProxyInstance(UserServiceImpl.class.getClassLoader(), UserServiceImpl.class.getInterfaces(), jdkProxy);
        userService1.func();
        userService1.func2();

        //返回一个指定接口的代理类实例(是一个接口对象)
        Object o = Proxy.newProxyInstance(UserServiceImpl.class.getClassLoader(), // 目标类对象的装载类
                UserServiceImpl.class.getInterfaces(),  // 目标类接口
                jdkProxy); //指派到指定的调用处理类对象
        System.out.println(o instanceof UserService);
        //反射的方式去调用目标类方法
        Class<?> aClass = o.getClass();
        Method func = aClass.getDeclaredMethod("func");
        func.setAccessible(true); //突破封装限制
        Method func2 = aClass.getDeclaredMethod("func2");
        func2.setAccessible(true); // 突破封装限制
        func.invoke(o);
        func2.invoke(o);


        //其他代理类对象创建
        JDKfun2Proxy jdKfun2Proxy = new JDKfun2Proxy(userService);
        Object o1 = Proxy.newProxyInstance(UserServiceImpl.class.getClassLoader(), UserServiceImpl.class.getInterfaces(), jdKfun2Proxy);
        Class<?> aClass1 = o1.getClass();
        Method func21 = aClass1.getDeclaredMethod("func2");
        func21.setAccessible(true);
        func21.invoke(o1);

    }
}

输出