代理模式(proxy)

1.代理模式 

1.1创建工程

代理模式(proxy)_第1张图片

1.2代理模式的介绍

作用:通过代理可以控制访问某个对象的方法,在调用这个方法前做前置处理,调用这个方法后做后置处理。(即: AOP的微观实现!)

代理模式(proxy)_第2张图片

核心角色

  • 抽象角色(接口):定义公共对外方法

  • 真实角色(周杰伦):实现抽象角色,定义真实角色所要实现的业务逻辑

  • 代理角色(代理人):实现抽象角色,是真实角色的代理,通过调用真实角色的方法来完成业务逻辑,并可以附加自己的操作

 代理模式(proxy)_第3张图片2.

2.静态代理

2.1抽象角色

package com.by.proxy.staticProxy;

public interface Star {
    /**
     * 面谈
     */
    void confer();
    /**
     * 签合同
     */
    void signContract();
    /**
     * 订票
     */
    void bookTicket();
    /**
     * 唱歌
     */
    void sing();
    /**
     * 收钱
     */
    void collectMoney();
}

 2.2真正角色(周杰伦)

package com.by.proxy.staticProxy;

public class RealStar implements Star{
    @Override
    public void confer() {

    }

    @Override
    public void signContract() {

    }

    @Override
    public void bookTicket() {

    }

    @Override
    public void sing() {
        System.out.println("天青色等烟雨,而我在等你,炊烟袅袅升起,隔江千万里....");
    }

    @Override
    public void collectMoney() {

    }
}

2.3代理角色(经纪人)

package com.by.proxy.staticProxy;

public class proxyStar implements Star{
    private Star star;

    public proxyStar(Star star) {
        this.star = star;
    }

    @Override
    public void confer() {
        System.out.println("面谈");
    }

    @Override
    public void signContract() {
        System.out.println("签合同");
    }

    @Override
    public void bookTicket() {
        System.out.println("订机票");
    }

    @Override
    public void sing() {
        star.sing();
    }

    @Override
    public void collectMoney() {
        System.out.println("收尾款");
    }
}

 2.4测试

package com.by.proxy.staticProxy;

public class Client {
    public static void main(String[] args) {
        Star star = new proxyStar(new RealStar());
        star.sing();
        star.bookTicket();
        star.collectMoney();
        star.confer();
        star.signContract();
    }
}

 2.5结果

代理模式(proxy)_第4张图片

2.6静态代理的缺点

  1. 代理类和实现类实现了相同的接口,这样就出现了大量的代码重复。

  2. 代理对象只服务于一种类型的对象。如果要服务多类型的对象,例如代码是只为UserService类的访问提供了代理,但是还要为其他类如DeptService类提供代理的话,就需要我们再次添加代理DeptService的代理类

3.jdk动态代理

 3.1抽象角色

package com.by.proxy.jdkProxy;

public interface Star {
    void sing();
}

 3.2真正角色

package com.by.proxy.jdkProxy;

public class RealStar implements Star{
    @Override
    public void sing() {
        System.out.println("天青色等烟雨,而我在等你,炊烟袅袅升起,隔江千万里......");
    }
}

 3.3代理工厂

package com.by.proxy.jdkProxy;

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

public class ProxyFactory {
    /**
     * 要代理的真实角色
     */
    private Object realObj;
    public ProxyFactory(Object realObj){
        this.realObj=realObj;
    }
    //创建代理工厂,生成代理类proxy{.面谈.签合同.订机票【调用杰哥唱歌】.收尾款}
   public Object getObjectProxy(){
       /**
        * ClassLoader loader,类加载器
        * Class[] interfaces,公共接口
        * InvocationHandler h)调用invoke方法
        */
          return Proxy.newProxyInstance(realObj.getClass().getClassLoader(),
               realObj.getClass().getInterfaces(),
               new InvocationHandler() {
                   @Override
                   public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                       //代理类既要调用真实角色,还要处理自己的事务
                       System.out.println("面谈");
                       System.out.println("签合同");
                       System.out.println("订机票");
                       Object result = method.invoke(realObj, args);
                       System.out.println("收尾款");
                       return result;
                   }
               });
    }

}

 3.4测试

package com.by.proxy.jdkProxy;

public class Client {
    public static void main(String[] args) {
       Star star = (Star) new ProxyFactory(new RealStar()).getObjectProxy();
       star.sing();
    }
}

3.5结果

代理模式(proxy)_第5张图片

4.Cglib动态代理

 cglib与动态代理最大的区别就是:

  • 使用jdk动态代理的对象必须实现一个接口

  • 使用cglib代理的对象则无需实现接口

CGLIB是第三方提供的包,所以需要引入jar包的坐标:


    cglib
    cglib
    2.2.2

 如果你已经有spring-core的jar包,则无需引入,因为spring中包含了cglib。

4.1真正角色

package com.by.proxy.CglibProxy;

public class RealStar{

	public void sing() {
		System.out.println("RealStar(周杰伦本人).sing()");
	}
}

4.2代理角色

4.3测试

package com.by.proxy.CglibProxy;

//测试类
public class Client {
    public static void main(String[] args) {
        //获取代理对象
        RealStar proxyObject = 
            (RealStar) new ProxyFactory(new RealStar()).getProxyObject();
        proxyObject.sing();
    }
}

5.总结

1)静态代理
            角色:
                公共接口:Star
                真实角色:RealStar(真实角色.唱歌)
                代理角色:ProxyStar(代理角色.面谈.订机票.签合同.[调周杰伦唱歌].收尾款)
                客户类:Client(客户.调代理角色)

            缺陷:1.大量代码重复 2.只能代理Star类型的对象
        2)jdk动态代理
            角色:
                公共接口:Star
                真实角色:RealStar(真实角色.唱歌)
                代理工厂:ProxyFactroy{生成ProxyStar(代理角色.面谈.订机票.签合同.[调周杰伦唱歌].收尾款)}
                客户类:Client(客户.调代理角色)
        3)Cglib动态代理
            cglib和jdk动态代理的区别:cglib真实角色没有接口

你可能感兴趣的:(java,开发语言,代理模式)