Java 实现代理模式以及通过Spring AOP 实现代理模式

最新推荐文章于 2022-07-07 20:47:38 发布

萧瑟1

最新推荐文章于 2022-07-07 20:47:38 发布

阅读量247

点赞数

分类专栏： Spring 春文章标签：代理模式 aop aspect

本文链接：https://blog.csdn.net/qq_41410799/article/details/101533595

版权

Spring 春专栏收录该内容

4 篇文章 0 订阅

订阅专栏

文章目录

什么是代理
代理模式

什么是代理

我们大家都知道微商代理，简单地说就是代替厂家卖商品，厂家“委托”代理为其销售商品。关于微商代理，首先我们从他们那里买东西时通常不知道背后的厂家究竟是谁，也就是说，“委托者”对我们来说是不可见的;其次，微商代理主要以朋友圈的人为目标客户，这就相当于为厂家做了一次对客户群体的“过滤”。我们把微商代理和厂家进一步抽象，前者可抽象为代理类，后者可抽象为目标类(被代理类)。通过使用代理，通常有两个优点，并且能够分别与我们提到的微商代理的两个特点对应起来：

优点一：可以隐藏目标类的实现;

优点二：可以实现客户与委托类间的解耦，在不修改委托类代码的情况下能够做一些额外的处理

参考链接：https://juejin.im/post/5ad3e6b36fb9a028ba1fee6a

代理模式

静态代理

一般将代理类在程序运行之前就存在的代理模式称为静态代理。通常情况下，代理类与目标类都实现了同一接口。

实现步骤

1.目标类：

public class StuServiceImpl implements StuService{
    @Override
    public void addStu() {
        System.out.println("add Stu!!!");

    }
    @Override
    public void deleteStu() {
        System.out.println("delete Stu!!!");
    }
    @Override
    public void modifyStu() {
        System.out.println("modify Stu!!!");
    }
}

2.代理类：

public class AgencyStu implements StuService{
    private  StuService stuService;
    //接收目标类实例
    public AgencyStu(StuService stuService) {
        this.stuService = stuService;
    }
    //实现代理
    @Override
    public void addStu() {
        System.out.println("before add");
        stuService.addStu();
        System.out.println("end add");
    }
    @Override
    public void deleteStu() {
        System.out.println("before delete");
        stuService.deleteStu();
        System.out.println("end delete");
    }
    @Override
    public void modifyStu() {
        System.out.println("before modify");
        stuService.modifyStu();
        System.out.println("end modify");
    }
}

可以看到上面代理类实现了对目标类的代理，但是由于代理类是在程序运行开始前就存在了，所以当存在不同的代理需求时，还需要再次创建一个新的代理类去实现代理需求，这就造成了代码的冗余，所以就出现了动态代理。

动态代理

基本JDK动态代理

代理类在运行时被创建的代理方式交动态代理。也就是说代理类不是在java代码中定义的，而是在运行过程中在我们java代码的指示下动态生成的。相比于静态代理，它可以实现对代理方法的统一处理，而不用像静态代理一样，挨个去编写重复代码。

实现步骤：

需要创建一个类似于"中介"的类，中介类需要实现InvocationHandler接口，并重写method.invoke方法，然后调用Proxy.newProxyInstance创建代理类，实现动态代理。
例如：
目标类：

public class ShopServiceImpl implements  ShopService{
    @Override
    public void addShop() {
        System.out.println("add Shop!!!");
    }
    @Override
    public void deleteShop() {
        System.out.println("delete Shop!!!");
    }
    @Override
    public void queryShop() {
        System.out.println("query Shop!!!");
    }
}

中介类：

public class Dynamicagency implements InvocationHandler {
    private Object object;
    //调用目标类实例
    public Dynamicagency(Object object) {
        this.object = object;
    }
    @Override
    //代理类每执行方法时，都会调用此类的invoke方法
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("before");
        Object result = method.invoke(object,args);
        System.out.println("after");
        return result;
    }
}

动态创建代理类

//生成中介类实例
Dynamicagency dynamicagency = new Dynamicagency(new ShopServiceImpl());
//生成代理类
ShopService shopService = (ShopService) Proxy.newProxyInstance(ShopService.class.getClassLoader(),
        new Class[]{ShopService.class},dynamicagency);
shopService.addShop();

在这里解释一下Proxy.newProxyInstance的参数：

参数1 : loader,类加载器，动态代理类，运行时创建，任何类都需要加载器将其加载到内存。

参数2: Class[] interfaces 代理类需要实现的所有接口

1. 目标类实例.getClass().getInterfaces(); 注意只能获得自己接口，不能获得父元素接口
2. new Class[]{interface.class}

参数3：InvocationHandler 处理类，接口，必须进行实现类，一般采取匿名内部类

	   提供invoke方法，代理类的每一个方法执行时，都将调用一次invoke。

		参数31：Object proxy ： 代理对象

		参数32：Method method： 代理对象当前执行的方法的描述对象（反射）

		参数33：Object[] args:方法实际参数

因此，代理类执行代理方法，其实就是对实现InvocationHandler 中介类的调用，然后中介类通过反射原理实现对原目标类方法的调用。

Spring 手动代理—JDK动态代理

在这里说一下aop术语：
AOP 术语：

target ：目标类，需要被代理的类，例如： UserService
Joinpoint：连接点，所谓连接点是指那些可能被拦截到的方法。例如所有方法
PonitCut ：切入点，指已经被增强的连接点。例如addUser()
advice：通知/增强，增强代码。例如after，before
Weaving ：织入，是指把增强advice应用到目标对象target来创建的代理对象proxy的过程。
proxy 代理类
Aspect 切面是把pointcut和通知advice的结合。

一个是一个特殊的面

一个切入点和一个通知，组合成一个特殊的面
图示：

实现步骤

目标(委托)类：接口+实现类

public class UserServiceImpl  implements Userservice {
    @Override
    public void addUser() {
        System.out.println("add User!!!");
    }
    @Override
    public void deleteUser() {
        System.out.println("delete User!!!");
    }
    @Override
    public void updateUser() {
        System.out.println("update User!!!");
    }
}

切面类：用于通知

public class MyAspect {
    public void before()
    {
        System.out.println("running before");
    }

    public void after()
    {
        System.out.println("running after");
    }
}

工厂类: 编写工厂生产代理

public class MyBeanfactory {
    public static  Userservice  createUserSerive()
    {
        final Userservice userservice = new UserServiceImpl();

        final MyAspect myAspect = new MyAspect();

        Userservice result = (Userservice) Proxy.newProxyInstance(Userservice.class.getClassLoader()
        ,userservice.getClass().getInterfaces(), new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        myAspect.before();
                        Object object = method.invoke(userservice,args);
                        myAspect.after();
                        return object;

                    }
                });
        return result;
    }
}

cglib动态代理

Cglib是一个强大的、高性能的代码生成包，它广泛被许多AOP框架使用，为它们提供方法的拦截。
cglib动态代理的特点是目标类可以不用实现特定的方法，cglib在运行时创建目标类的增强类。

实现步骤

创建目标类（不用实现接口）

public class ShopServiceImpl {
    public void addShop() {
        System.out.println("add Shop!!!");
    }

    public void deleteShop() {
        System.out.println("delete Shop!!!");
    }

    public void queryShop() {
        System.out.println("query Shop!!!");
    }
}

编写拦截器(实现MethodInterceptor)

public class MyMethodIntecetor implements MethodInterceptor {
    private ShopServiceImpl shopService;

    public MyMethodIntecetor(ShopServiceImpl shopService) {
        this.shopService = shopService;
    }

    @Override
    public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        System.out.println("before");
        //两种方法都可以
        //Object result = methodProxy.invokeSuper(proxy,args);
        Object result = method.invoke(shopService,args);
        System.out.println("after");
        return result;
    }
}

其中MethodInterceptor中intercept方法的参数如下：
proxy 表示的是代理类
method:代理对象当前执行的方法的描述对象（反射）
args:方法实际参数
methodProxy：方法的代理
3. 创建代理类

        Enhancer enhancer = new Enhancer();
        //添加父类
        enhancer.setSuperclass(ShopServiceImpl.class);
        //调用回调函数
        enhancer.setCallback(new MyMethodIntecetor(new ShopServiceImpl()));
        //创建代理对象
        ShopServiceImpl shopService = (ShopServiceImpl) enhancer.create();
        shopService.addShop();

Spring 手动代理 cglib字节码增强

这种方式主要是通过BeanFactory生产代理对象，与上面不同的就是多个工厂还有含有通知的类。

实现步骤

目标类

public class ShopServiceImpl  {

    public void addShop() {
        System.out.println("add Shop!!!");
    }

    public void deleteShop() {
        System.out.println("delete Shop!!!");
    }

    public void queryShop() {
        System.out.println("query Shop!!!");
    }
}

含有通知的类

public class AdviceClass {
    public void before()
    {
        System.out.println("before");
    }
    public void after()
    {
        System.out.println("after");
    }
}

创建工厂

public class MyBeanFactory {
    public static ShopServiceImpl createShopServiceImpl()
    {
        ShopServiceImpl shopService = new ShopServiceImpl();

        AdviceClass adviceClass = new AdviceClass();

        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(ShopServiceImpl.class);
        enhancer.setCallback(new MethodInterceptor() {
            @Override
            //创建匿名内部类
            public Object intercept(Object object, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
                adviceClass.before();
                // 两种写法都可以
                //Object result = methodProxy.invokeSuper(object,args);
                Object result = method.invoke(shopService,args);
                adviceClass.after();
                return result;
            }
        });
        ShopServiceImpl proxyShop = (ShopServiceImpl) enhancer.create();
        return proxyShop;
    }
}

Spring 工厂Bean代理 ----半自动化

上面的工厂是我们手动创建的，其实我们可以通过使用Spring中的ProxyFactoryBean代替手动创建工厂。下面是步骤。

实现步骤

目标类

public class UserServiceImpl implements  UserService{
    @Override
    public void addUser() {
        System.out.println("addUser!!!");
    }

    @Override
    public void deleteUser() {
        System.out.println("deleteUser!!!");
    }

    @Override
    public void updateUser() {
        System.out.println("updateUser!!!");
    }
}

切面类

public class MyAspect implements MethodInterceptor {
    @Override
    public Object invoke(MethodInvocation methodInvocation) throws Throwable {
        System.out.println("before");
        //实现目标类的相应方法
        Object object =methodInvocation.proceed();
        System.out.println("after");
        return object;
    }
}

接下来是配置xml文件

<!--创建目标类-->
    <bean id="userServiceImplId" class="com.zamao.FactoryAgencyBeanXml.UserServiceImpl"></bean>
    <!--创建切面类-->
    <bean id="myAspect" class="com.zamao.FactoryAgencyBeanXml.MyAspect"></bean>
    <!--创建代理类-->
    <!--
       使用工厂bean FactoryBean,底层调用getObject() 返回特殊bean
       ProxyFactoryBean 用于创建代理工厂bean，生成特殊代理对象
       interfaces ： 确定接口们  通过<array> 可以设置多个值 只有一个值时，value=""
        target： 目标类
        interceptorNames ： 通知切面类的名称，类型String[],如果设置一个值value=""
       -->
    <bean id="proxyUserService" class="org.springframework.aop.framework.ProxyFactoryBean">
        <property name="interfaces" value="com.zamao.FactoryAgencyBeanXml.UserService">			   	</property>
        <property name="target" ref="userServiceImplId"></property>
        <property name="interceptorNames" value="myAspect"></property>
    </bean>

Spring aop 实现代理

与上面不同的是将配置工厂替换成了aop配置，相比于工厂配置来说更加简便，也可以对拦截条件进行设置。

实现步骤

1.导入aspectjweaver-1.9.4.jar。
2. 引入aop命名空间

在xml中添加如下代码：

xmlns:aop="http://www.springframework.org/schema/aop"
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd

3.目标类：

public class UserServiceImpl implements UserService {
    @Override
    public void addUser() {
        System.out.println("addUser!!! springAopProgramm");
    }

    @Override
    public void deleteUser() {
        System.out.println("deleteUser!!! springAopProgramm");
    }

    @Override
    public void updateUser() {
        System.out.println("updateUser!!! springAopProgramm");
    }
}

4.切面类：

public class MyAspect implements MethodInterceptor {
    @Override
    public Object invoke(MethodInvocation methodInvocation) throws Throwable {
        System.out.println("before");
        Object object =methodInvocation.proceed();
        System.out.println("after");
        return object;
    }
}

5.配置xml

<!--创建目标类-->
  <bean id="userServiceImplId" class="com.zamao.springAopProgramme.UserServiceImpl"></bean>
  <!--创建切面类-->
  <bean id="myAspect" class="com.zamao.springAopProgramme.MyAspect"></bean>
  <!--aop编程
      1. 引入命名空间
      2. 使用<aop:config> 进行配置
             <aop:pointcut> 切入点，从目标对象中获得具体方法
             <aop:advisor> 特殊的切面，只有一个通知和一个切入点
             advice-ref 通知引用
             point-ref 切入点引用
     3. 切入点表达式：
          execution(返回值 包 类名 (方法名) 参数名)

  -->
  <aop:config>
      <aop:pointcut id="MyPointCut" expression="execution(* com.zamao.springAopProgramme.*.*(..))"/>
      <aop:advisor advice-ref="myAspect" pointcut-ref="MyPointCut"></aop:advisor>
  </aop:config>

萧瑟1

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java 实现代理模式以及通过Spring AOP 实现代理模式

什么是代理我们大家都知道微商代理，简单地说就是代替厂家卖商品，厂家“委托”代理为其销售商品。关于微商代理，首先我们从他们那里买东西时通常不知道背后的厂家究竟是谁，也就是说，“委托者”对我们来说是不可见的;其次，微商代理主要以朋友圈的人为目标客户，这就相当于为厂家做了一次对客户群体的“过滤”。我们把微商代理和厂家进一步抽象，前者可抽象为代理类，后者可抽象为目标类(被代理类)。通过使用代理，通常有两...
复制链接

扫一扫