静态代理 - 动态代理

以你之姓@ 2022-06-10 08:58 176阅读 0赞

# 静态代理 #

1、静态代理的角色分析：

抽象角色  ------  一般使用接口或者抽象类来实现 。

真实角色  ------  被代理角色 。

代理角色  ------  代理真实角色 （代理真实角色后一般会做一些附属操作，比如房屋中介的附属操作是带人看房，收中                                                      介费）

客户         ------  使用代理角色来进行一些操作 。

2、代码实现：

项目结构如下：

![Center][]

Rent.java --- 抽象角色

package cn.myspring.staticproxy;
    
    public interface Rent {
    
    	/**
    	 * 房屋出租
    	 */
    	public void rent() ;
    	
    }

Host.java --- 真实角色

package cn.myspring.staticproxy;
    
    /**
     * 房东
     */
    public class Host implements Rent{
    
    	@Override
    	public void rent() {
    		System.out.println("房屋出租");
    	}
    	
    }

Proxy.java --- 代理角色

package cn.myspring.staticproxy;
    
    /**
     * 中介
     */
    public class Proxy implements Rent {
    
    	private Host host;
    
    	public Proxy() {
    	}
    
    	public Proxy(Host host) {
    		super();
    		this.host = host;
    	}
    
    	public void setHost(Host host) {
    		this.host = host;
    	}
    
    	@Override
    	public void rent() {
    		seeHouse() ;
    		host.rent();
    		fare() ;
    	}
    	
    	//看房
    	private void seeHouse() {
    		System.out.println("带房客看房");
    	}
    	
    	//收中介费
    	private void fare() {
    		System.out.println("收取中介费");
    	}
    
    }

Client.java --- 客户

package cn.myspring.staticproxy;
    
    /**
     * 租客
     */
    public class Client {
    
    	public static void main(String[] args) {
    		Host host = new Host() ;
    		Proxy proxy = new Proxy(host) ;
    		proxy.rent() ;
    	}
    	
    }

控制台打印运行结果

![Center 1][]

3、使用静态代理的好处：

使得真实角色处理的业务更加纯粹，不在去关注一些公共的事情。

公共的业务由代理来完成 --- 实现业务的分工。

公共业务发生扩展时，更加集中和方便 。

缺点：

类多了 --- 多代理类，工作量变大，开发效率变低了。

解决静态代理的这些缺点的办法是，使用动态代理。

# 动态代理 #

分为两类：

1、基于接口的动态代理 -- JDK动态代理。

2、基于类的动态代理 -- cglib 。

现在大多使用javasist来生成动态代理。

3、jdk动态代理 --- Proxy类和invocationHandler接口

***态代理是代理接口的，只要有接口就能代理***

下面来看看具体的例子：

项目结构如图：

![Center 2][]

动态代理类ProxyInocationHandler代码：

package cn.my.dynamicproxy;
    
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    
    /**
     * 动态代理类
     */
    public class ProxyInocationHandler implements InvocationHandler {
    
    	private Object target;// 真实对象
    
    	public void setTarget(Object target) {
    		this.target = target;
    	}
    
    	/**
    	 * 生成代理类
    	 * 
    	 * @return
    	 */
    	public Object getProxy() {
    		return Proxy.newProxyInstance(this.getClass().getClassLoader(),
    				this.target.getClass().getInterfaces(), this);
    	}
    
    	/**
    	 * proxy:代理类 ; method：代理类的调用处理程序的方法对象
    	 */
    	@Override
    	public Object invoke(Object proxy, Method method, Object[] args)
    			throws Throwable {
    		log(method.getName()) ;
    		// target是真实对象
    		Object result = method.invoke(target, args);
    		return result;
    	}
    
    	public void log(String methodName) {
    		System.out.println("执行" + methodName + "方法");
    	}
    }

房屋出租接口--抽象角色  Rent代码：

package cn.my.dynamicproxy;
    
    public interface Rent {
    
    	/**
    	 * 出租房屋
    	 */
    	public void rent() ;
    	
    }

房屋拥有者--真实角色 Host代码：

package cn.my.dynamicproxy;
    
    /**
     * 房东
     */
    public class Host implements Rent{
    
    	@Override
    	public void rent() {
    		System.out.println("房屋出租");
    	}
    	
    }

另一个抽象角色UserService代码：

package cn.myspring.service;
    
    /**
     * 抽象角色
     */
    public interface UserService {
    
    	public void add() ;
    	public void update() ;
    	public void delete() ;
    	public void search() ;
    }

真实角色UserServiceImpl代码：

package cn.myspring.service;
    
    /**
     * 真实角色
     */
    public class UserServiceImpl implements UserService {
    
    	@Override
    	public void add() {
    		System.out.println("增加用户");
    	}
    
    	@Override
    	public void update() {
    		System.out.println("修改用户");
    	}
    
    	@Override
    	public void delete() {
    		System.out.println("删除用户");
    	}
    
    	@Override
    	public void search() {
    		System.out.println("查询用户");
    	}
    	
    }

客户端角色Client代码：

package cn.my.dynamicproxy;
    
    import cn.myspring.service.UserService;
    import cn.myspring.service.UserServiceImpl;
    
    /**
     * 租客
     */
    public class Client {
    
    	public static void main(String[] args) {
    		//动态代理类
    		ProxyInocationHandler pih = new ProxyInocationHandler() ;
    
    		//真实角色类
    		Host host = new Host() ;
    		pih.setTarget(host) ;
    		//Rent的代理对象
    		Rent proxy = (Rent) pih.getProxy() ;
    		proxy.rent() ;
    		
    		//真实角色类
    		UserService userService = new UserServiceImpl() ;
    		pih.setTarget(userService) ;
    		//UserService的代理对象
    		UserService uproxy = (UserService) pih.getProxy() ;
    		
    		System.out.println("---------------------------");
    		uproxy.add() ;
    		System.out.println("---------------------------");
    		uproxy.update();
    		System.out.println("---------------------------");
    		uproxy.delete() ;
    		System.out.println("---------------------------");
    		uproxy.search() ;
    		
    		
    	}
    	
    }

运行Client代码，控制台打印信息如下：

![Center 3][]

***态代理是代理接口的，只要有接口就能代理***

比如下面：

![Center 4][]

其中这个打印信息    ：   执行 。。。方法 ， 是动态代理类ProxyInocationHandler中的log日志方法打印的

![Center 5][]

[Center]: /images/20220610/0a8bd859aa654f2082c9fecf71bbabec.png
[Center 1]: /images/20220610/f2b7b00bb2fe4e019b10d2d7f1f6d6fd.png
[Center 2]: /images/20220610/50227d7cbb3a4b9488064cd9839b1780.png
[Center 3]: /images/20220610/bf04266770a2480a9eeb467bd6c0fba2.png
[Center 4]: /images/20220610/dcbfe9eb085e4f27a830d2e1569eab6b.png
[Center 5]: /images/20220610/8dd69f2cce7e4a2988c99d0daa6fa710.png