动态代理-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);
 
    }
}

输出