代理模式的demo

代理模式与装饰模式的区别
动态代理模式的简单实现
动态代理基本构成三要素
1. 抽象角色:声明真实对象和代理对象的共同接口,这样可在任何使用真实对象的地方都可以使用代理对象。
2. 代理角色:代理对象内部含有真实对象的引用,从而可以在任何时候操作真实对象。代理对象提供一个与真实对象相同的接口,以便可以在任何时候替代真实对象。代理对象通常在客户端调用传递给真实对象之前或之后,执行某个操作,而不是单纯地将调用传递给真实对象,同时,代理对象可以在执行真实对象操作时,附加其他的操作,相当于对真实对象进行封装。
3. 真实角色:即为代理对象所代表的目标对象,代理角色所代表的真实对象,是我们最终要引用的对象。

以上引用出处https://www.cnblogs.com/LCcnblogs/p/6823982.html

首先要明确我们要代理的对象是什么?
我们需要代理的是某个接口的实现,如果没有这个接口,那么我们可以定义这个接口,因为代理的话一定是代理该对象的某个接口的(我自己观察的,真实的原因我不知道是什么,后期再说,先把demo写了,自己在学习中)

public interface MyBeanInterface {

    void setName(String flags);

    String getName(int id);

    Integer getAge(int id);
}

接口有了,接下来要看这个具体的实现类了,我们的目的就是要代理这个实现对象

public class MyBeanInterfaceImpl implements MyBeanInterface {
    public static final String TAG = MyBeanInterfaceImpl.class.getSimpleName();


    private String mName = "abc";

    @Override
    public void setName(String flags) {
        mName = flags;
    }

    @Override
    public String getName(int id) {
        return mName;
    }

    @Override
    public Integer getAge(int id) {
        return 18;
    }
}

接下来创建代理人

public class MyInvocationHandler implements InvocationHandler {
    private static final String TAG = MyInvocationHandler.class.getSimpleName();
    //既然要做代理,我们必须知道我们是给谁做代理,这里的obj就是被代理者。
    private Object target;


    public MyInvocationHandler(Object flags) {
        target = flags;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

            MyLog.debugLog(TAG, "++++++before " + method.getName() + "++++++");
            Object result = method.invoke(target, args);
            MyLog.debugLog(TAG, "++++++after " + method.getName() + "++++++");
            return result;

    }
}
    //创建一个InvocationHandler,描述我们希望代理者执行哪些操作
     InvocationHandler invocationHandler = new MyInvocationHandler(userService);
     //第一个参数是类加载器
     //第二个参数是这个代理者实现哪些接口(与被代理者实现的是相同的接口)
     //第三个参数就是代理人
     //userServiceProxy  就是代理人已经将我们真正需要调用的对象给套在里面了
     //我们通过代理人发出操作,在被代理的对象的操作开始前和结束后,我们都可以做一些自己的操作
     MyBeanInterface userServiceProxy = (MyBeanInterface)
                Proxy.newProxyInstance(
                        userService.getClass().getClassLoader()
                        ,  userService.getClass().getInterfaces()
                        , invocationHandler);


动态代理后的对象与原对象的关系
通过log可以看到,动态代理的对象的tostring,和被代理对象的tostring是同一个值,因为tostring方法也被代理了
若代理对象需要进行比较时,这里需要注意
先写这么多,后面的就todo了

注解+动态代理的实现
动态代理后被代理的对象还是原来的对象吗?

动态代理后,被代理的对象确实还是原来的对象
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
在Spring Boot项目中,可以使用Spring AOP(面向切面编程)实现代理模式。Spring AOP是Spring框架提供的一个功能,用于实现横切关注点(如日志记录、事务管理等)的代码重用。 具体实现方法如下: 1. 定义一个接口,声明需要代理的方法。 2. 创建一个被代理类,实现上述接口,并在类上添加注解@Service或@Component,表示该类是一个Bean。 3. 创建一个代理类,实现上述接口,并在类上添加注解@Aspect,表示该类是一个切面,用于处理横切关注点。 4. 在代理类中,定义一个方法,并在该方法上添加注解@Around,表示该方法将会拦截目标方法,并进行处理。 例如,下面是一个使用Spring Boot实现代理模式的示例代码: ``` public interface UserService { void addUser(User user); } @Service public class UserServiceImpl implements UserService { @Override public void addUser(User user) { // 添加用户 } } @Aspect @Component public class UserProxy { @Autowired private UserService userService; @Around("execution(* com.example.demo.UserService.addUser(..))") public void around(ProceedingJoinPoint point) throws Throwable { // 前置处理 System.out.println("before add user"); // 调用目标方法 point.proceed(); // 后置处理 System.out.println("after add user"); } } ``` 在上述示例中,定义了一个UserService接口和一个UserServiceImpl类,并在UserServiceImpl类上添加了@Service注解,表示该类是一个Bean。同时,创建了一个UserProxy类,实现了UserService接口,并在类上添加了@Aspect注解,表示该类是一个切面。在UserProxy类中,定义了一个around方法,并在该方法上添加了@Around注解,表示该方法将会拦截目标方法,并在前后进行处理。在方法中,通过ProceedingJoinPoint参数调用目标方法,并在前后分别输出日志。 通过上述实现,我们将UserService接口的添加用户方法进行了代理,并在代理中添加了前后处理逻辑,从而实现了代理模式

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值