JDK的动态代理简单实例

LoginInterceptor.java ===》实现InvocationHandler接口的实现类,里面实现了在被代理对象方法的前后做了些自己特有的处理

package com.gj.aop;

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

public class LoginInterceptor implements InvocationHandler {
    // 被代理的对象
    private Object target;

    public Object getTarget() {
        return target;
    }

    public void setTarget(Object target) {
        this.target = target;
    }

    public void before(Method method) {
        System.out.println(method.getName() + " start..");
    }

    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        before(method);
        Object oj = method.invoke(target, args);
        end(method);
        return oj;
    }

    public void end(Method method) {
        System.out.println(method.getName() + " end..");
    }

}

User.java ==> 一个简单的实体对象

package com.gj.bean;

public class User {
    private String username;
    private String password;
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
}

LoginDao.java ==>要被代理对象的接口

package com.gj.dao;

import com.gj.bean.User;

public interface LoginDao {
    void query(User user);

    void add(User user);

}

LoginDaoImpl.java ==》接口的实现类

package com.gj.dao.impl;

import com.gj.bean.User;
import com.gj.dao.LoginDao;

public class LoginDaoImpl implements LoginDao {

    public void query(User user) {
        System.out.println("query sucess");
    }

    public void add(User user) {
        System.out.println("add user sucess");
    }

}

ProxyTest.java ==>测试类

package com.gj.service;

import java.lang.reflect.Proxy;

import org.junit.Test;

import com.gj.aop.LoginInterceptor;
import com.gj.bean.User;
import com.gj.dao.LoginDao;
import com.gj.dao.impl.LoginDaoImpl;

/**
 * 动态代理测试类
 * 
 */
public class ProxyTest {

    @Test
    public void test() {
        LoginDao loginDao = new LoginDaoImpl();
        LoginInterceptor lg = new LoginInterceptor();
        lg.setTarget(loginDao);
       //获取代理对象
        LoginDao loginDaoProxy = (LoginDao) Proxy.newProxyInstance(loginDao
                .getClass().getClassLoader(), loginDao.getClass()
                .getInterfaces(), lg);

        loginDaoProxy.add(new User());
        loginDaoProxy.query(new User());
    }

}

测试结果如下图所示:

这里写图片描述

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java动态代理是一种在运行时动态生成代理对象的技术。它可以代理某个接口或者类,使得代理对象可以拦截到对被代理对象的方法调用,并在调用前后进行一些额外的操作,比如记录日志、权限控制等。 Java提供了两种动态代理的实现方式:基于JDK动态代理和基于CGLIB的动态代理。其中,基于JDK动态代理只能代理实现了接口的类,而基于CGLIB的动态代理则可以代理任何类,包括没有实现接口的类。 下面是一个基于JDK动态代理简单实例: ```java import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; interface Hello { void sayHello(); } class HelloImpl implements Hello { public void sayHello() { System.out.println("Hello, world!"); } } class MyInvocationHandler implements InvocationHandler { private Object target; public MyInvocationHandler(Object target) { this.target = target; } public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println("Before invoking " + method.getName()); Object result = method.invoke(target, args); System.out.println("After invoking " + method.getName()); return result; } } public class Main { public static void main(String[] args) { Hello hello = new HelloImpl(); InvocationHandler handler = new MyInvocationHandler(hello); Hello proxy = (Hello) Proxy.newProxyInstance( Main.class.getClassLoader(), new Class[] { Hello.class }, handler); proxy.sayHello(); } } ``` 这里定义了一个接口`Hello`和它的实现类`HelloImpl`。`MyInvocationHandler`是一个实现了`InvocationHandler`接口的类,它负责拦截并处理对`Hello`接口的方法调用。`Main`类中创建了一个`HelloImpl`对象和一个`MyInvocationHandler`对象,然后调用`Proxy.newProxyInstance`方法构造一个代理对象。通过代理对象调用`sayHello`方法时,`MyInvocationHandler`会先打印一行`Before invoking sayHello`,然后再调用`HelloImpl`对象的`sayHello`方法,最后打印一行`After invoking sayHello`。 下面是一个基于CGLIB的动态代理简单实例: ```java import net.sf.cglib.proxy.Enhancer; import net.sf.cglib.proxy.MethodInterceptor; import net.sf.cglib.proxy.MethodProxy; class Hello { public void sayHello() { System.out.println("Hello, world!"); } } class MyMethodInterceptor implements MethodInterceptor { public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable { System.out.println("Before invoking " + method.getName()); Object result = proxy.invokeSuper(obj, args); System.out.println("After invoking " + method.getName()); return result; } } public class Main { public static void main(String[] args) { Enhancer enhancer = new Enhancer(); enhancer.setSuperclass(Hello.class); enhancer.setCallback(new MyMethodInterceptor()); Hello hello = (Hello) enhancer.create(); hello.sayHello(); } } ``` 这里定义了一个类`Hello`和它的一个方法`sayHello`。`MyMethodInterceptor`是一个实现了`MethodInterceptor`接口的类,它负责拦截并处理对`Hello`类的方法调用。`Main`类中创建了一个`Enhancer`对象,通过`setSuperclass`方法指定要代理的类,通过`setCallback`方法指定拦截器,然后调用`create`方法构造一个代理对象。通过代理对象调用`sayHello`方法时,`MyMethodInterceptor`会先打印一行`Before invoking sayHello`,然后再调用`Hello`对象的`sayHello`方法,最后打印一行`After invoking sayHello`。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值