spring如何代理接口 • Worktile社区

worktile

Worktile官方账号

Spring可以通过动态代理的方式来代理接口。在Spring中，有两种方式来实现接口的代理：JDK动态代理和CGLIB动态代理。

1、JDK动态代理：
JDK动态代理是基于接口的代理方式。它要求被代理的类必须实现一个接口，代理类则实现了同样的接口，并将方法的调用委托给被代理的对象。JDK动态代理使用java.lang.reflect包中的Proxy类和InvocationHandler接口来实现。

首先，定义一个实现InvocationHandler接口的代理类，如下所示：

public class MyInvocationHandler implements InvocationHandler {

    private Object target;

    public MyInvocationHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 在方法被调用之前做一些操作
        System.out.println("Before method " + method.getName() + " is called.");

        // 调用被代理对象的方法
        Object result = method.invoke(target, args);

        // 在方法被调用之后做一些操作
        System.out.println("After method " + method.getName() + " is called.");

        return result;
    }
}

然后，在需要使用代理的地方，使用Proxy类的newProxyInstance方法创建代理对象，如下所示：

// 创建被代理的对象
SomeInterface someInterface = new SomeInterfaceImpl();

// 创建代理对象
SomeInterface proxy = (SomeInterface) Proxy.newProxyInstance(
        SomeInterface.class.getClassLoader(),
        new Class[] { SomeInterface.class },
        new MyInvocationHandler(someInterface)
);

// 调用代理对象的方法
proxy.someMethod();

2、CGLIB动态代理：
CGLIB动态代理是基于类的代理方式，它不要求被代理的类实现接口。CGLIB动态代理使用了第三方库cglib来实现。

首先，定义一个被代理的类，如下所示：

public class SomeClass {

    public void someMethod() {
        // 方法逻辑
    }
}

然后，定义一个实现MethodInterceptor接口的代理类，如下所示：

public class MyMethodInterceptor implements MethodInterceptor {

    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        // 在方法被调用之前做一些操作
        System.out.println("Before method " + method.getName() + " is called.");

        // 调用被代理对象的方法
        Object result = proxy.invokeSuper(obj, args);

        // 在方法被调用之后做一些操作
        System.out.println("After method " + method.getName() + " is called.");

        return result;
    }
}

然后，在需要使用代理的地方，使用Enhancer类来创建代理对象，如下所示：

// 创建被代理的对象
SomeClass someClass = new SomeClass();

// 创建Enhancer对象
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(SomeClass.class);
enhancer.setCallback(new MyMethodInterceptor());

// 创建代理对象
SomeClass proxy = (SomeClass) enhancer.create();

// 调用代理对象的方法
proxy.someMethod();

以上就是Spring中代理接口的两种方式：JDK动态代理和CGLIB动态代理的介绍和示例。可以根据需求选择相应的方式来实现接口的代理。

1年前 0条评论

不及物动词

这个人很懒，什么都没有留下～

Spring提供了多种方式来代理接口，常见的方式包括：

JDK动态代理：JDK动态代理是通过实现接口来进行代理的。在运行时，通过Java的反射机制动态生成一个实现了目标接口的代理类，代理类中的方法调用会被转发到拦截器中进行处理。可以使用Proxy类的newProxyInstance方法来创建代理对象，该方法需要传入一个实现InvocationHandler接口的对象作为拦截器。
CGLIB动态代理：CGLIB动态代理是通过生成目标类的子类来进行代理的。在运行时，通过继承目标类创建一个动态生成的子类，并重写目标类中的方法。使用CGLIB库可以很方便地实现CGLIB动态代理，通过Enhancer类的create方法可以创建代理对象，需要传入一个实现MethodInterceptor接口的对象作为拦截器。
使用@Proxy注解：Spring提供了@Proxy注解，可以直接在接口的方法上添加注解来指定该方法需要被代理。通过在配置文件中配置相关的AOP拦截器，可以将被@Proxy注解修饰的方法进行代理。
使用Spring AOP：Spring AOP（面向切面编程）提供了一种在运行时动态将代码横切到业务逻辑中的方式。可以通过配置文件（如XML配置文件、注解或Java代码）定义切面（Aspect）和通知（Advice），将通知应用到指定的连接点（Join Point）上，从而实现对接口的代理。
使用AspectJ：AspectJ是一个功能强大的面向切面编程框架，可以更加灵活地对接口进行代理。可以使用AspectJ的注解或XML配置文件定义切面和通知，通过编译时织入或运行时织入的方式将切面应用到目标接口上，从而实现代理。

总结来说，Spring提供了多种代理接口的方式，可以根据具体需求选择合适的方式来实现代理。无论是使用JDK动态代理、CGLIB动态代理、@Proxy注解、Spring AOP还是AspectJ，都可以通过配置相关的拦截器或切面来实现对接口的代理。

1年前 0条评论

fiy

Worktile&PingCode市场小伙伴

在Spring中代理接口有两种方式：JDK动态代理和CGLIB动态代理。这两种代理方式都可以实现接口的动态代理，但在不同的情况下选择合适的代理方式是很重要的。

JDK动态代理
JDK动态代理是基于接口的代理方式，在调用代理对象方法时，会通过反射来调用被代理对象的方法。使用JDK动态代理需要满足以下条件：

目标对象必须实现至少一个接口
创建代理对象时，需要使用Proxy类的newProxyInstance方法

使用JDK动态代理的步骤如下：
（1）定义接口：定义需要代理的接口，并声明需要代理的方法。
（2）实现接口：实现接口的类，称为目标对象。
（3）创建代理对象：使用Proxy类的newProxyInstance方法创建代理对象，该方法需要传入ClassLoader、接口数组和InvocationHandler对象。
（4）调用方法：通过代理对象调用目标对象的方法。

代码示例：

public interface UserService {
    void addUser(String username, String password);
}

public class UserServiceImpl implements UserService {
    @Override
    public void addUser(String username, String password) {
        System.out.println("添加用户：" + username + "，密码：" + password);
    }
}

public class UserServiceProxy implements InvocationHandler {
    private Object target;

    public UserServiceProxy(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("调用前");
        Object result = method.invoke(target, args);
        System.out.println("调用后");
        return result;
    }
}

public class Main {
    public static void main(String[] args) {
        UserService userService = new UserServiceImpl();
        UserService proxy = (UserService) Proxy.newProxyInstance(UserService.class.getClassLoader(), new Class<?>[]{UserService.class}, new UserServiceProxy(userService));
        proxy.addUser("admin", "123456");
    }
}

CGLIB动态代理
CGLIB动态代理是基于类的代理方式，在调用代理对象方法时，会通过生成子类来调用被代理对象的方法。使用CGLIB动态代理不需要目标对象实现接口，但目标对象不能是final类。
使用CGLIB动态代理的步骤如下：
（1）定义类：定义需要代理的类，并声明需要代理的方法。
（2）创建增强器：创建Enchancer对象，设置父类和回调对象。
（3）创建代理对象：调用Enchancer对象的create方法创建代理对象。
（4）调用方法：通过代理对象调用目标对象的方法。

代码示例：

public class UserService {
    public void addUser(String username, String password) {
        System.out.println("添加用户：" + username + "，密码：" + password);
    }
}

public class UserServiceInterceptor implements MethodInterceptor {
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("调用前");
        Object result = methodProxy.invokeSuper(o, objects);
        System.out.println("调用后");
        return result;
    }
}

public class Main {
    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(UserService.class);
        enhancer.setCallback(new UserServiceInterceptor());

        UserService userService = (UserService) enhancer.create();
        userService.addUser("admin", "123456");
    }
}

无论选择哪种代理方式，代理对象都会在调用目标对象方法之前和之后执行额外的逻辑。使用代理可以提供一种可插拔的方式，可以在不修改目标对象的前提下，对其进行功能增强。

1年前 0条评论