代理模式静态代理动态代理(JDK代理、cglib代理)

￡神魔★判官ぃ 2022-03-30 04:18 340阅读 0赞

# 面向对象的设计原则: #

开闭原则:对于修改来说是关闭,对于扩展来说是开放的
    单一职责原则:
           一个项目的功能单一
           一个模块的功能单一
           一个接口/类的功能单一
           一个方法的功能单一
           一个变量的功能单一

## 代理设计模式: ##

### 提出一个问题: ###

有一套原有的业务模型   符合单一职责
      有一套新的功能                 符合单一职责
      要把新的功能添加到原有业务模型中,填在原有业务模型的前或后,不是添在中间

### 解决方案: ###

方案一:
            在原有业务方法的第一行填写新功能代码
            在原有业务方法的最后一行填写新功能代码
            违反开闭原则,和单一职责
            是能完成添加新功能的需求,只是设计的不太好
    方案二:
            代理设计模式实现
             遵守开闭原则,和单一职责

### 代理设计模式的分类: ###

静态代理
    动态代理
            jdk的动态代理
            cglib的动态代理

#### 静态代理: ####

原有的业务模型
     UserDao.java        UserDaoImpl.java
     UserService.java     UserServiceImpl.java
    新功能:事务管理
      TransactionManager.java

##### 目标:要把新的功能(事务管理)切入到指定业务方法的前或后 #####

在业务方法的前添加事务的开启
          在业务方法的后添加事务的,没错误就提交,有错误就回滚
    
     原有业务有了
     新业务也有了
     新建一个类,在新建类中把老业务和新业务耦合在一起

TransactionManager.java

/** * 此类是一个新功能类,用于给原有业务添加事务处理的功能 * 符合单一职责原则,此类只做事务管理 * @author Administrator * */
    	public class TransactionManager { 
    		/** * 事务的开启 */
    		public void begin(){ 
    			System.out.println("事务开启");
    		}
    		/** * 事务提交 */
    		public void commit(){ 
    			System.out.println("事务提交");
    		}
    		/** * 事务的回滚 */
    		public void rollback(){ 
    			System.out.println("事务回滚");
    		}
    	}

StaticProxy.java
        
    	public class StaticProxy implements UserService { 
    		//老业务
    		private UserService userService;
    		
    		//新业务
    		private TransactionManager transactionManager;
    		
    		public void setUserService(UserService userService) { 
    			this.userService = userService;
    		}
    	
    		public void setTransactionManager(TransactionManager transactionManager) { 
    			this.transactionManager = transactionManager;
    		}
    	
    		@Override
    		public boolean addUser(User user) { 
    			try{ 
    				transactionManager.begin();
    				userService.addUser(user);
    				transactionManager.commit();
    			}catch(Exception e){ 
    				transactionManager.rollback();
    				e.printStackTrace();
    			}
    			return false;
    		}
    	
    		@Override
    		public boolean updateUser(User user) { 
    			try{ 
    				transactionManager.begin();
    				userService.updateUser(user);
    				transactionManager.commit();
    			}catch(Exception e){ 
    				transactionManager.rollback();
    				e.printStackTrace();
    			}
    			return false;
    		}
    		
    	
    	}

#### 总结静态代理: ####

1.原有的老业务,没有被破坏,符合单一职责  
2.新的业务,符合单一职责  
3.把新的业务要添加到老业务中  
a.新建一个老业务和新业务的耦合类,此耦合类就叫做静态代理类  
b.静态代理类要求必须实现自业务的接口,因为静态代理类的功能不能少于原有业务功能  
c.静态代理类不满足单一职责原则,因为老功能和新功能耦合在一起  
d.每一个套业务,都会对应一个静态代理类  
比如:UserService UserStaticProxy implements UserService  
ProductService ProductStaticProxy implements ProductService  
业务的模型越多,静态代理类就越多  
程序员会额外写很多的静态代理类,增加程序员的负担  
e.每个静态代理类都会创建很多代理对象  
f.静态代理是在编译期间就确定了老业务和新业务的耦合关系

#### 动态代理:(jdk动态代理,cglib动态代理) ####

##### jdk动态代理:是由jdk提供的功能 #####

老的业务功能:
      UserDao.java    UserDaoImpl.java
      UserService.java    UserServiceImpl.java
    新的业务功能:
      TransactionMananger.java

##### 目的:把新的功能添加到老业务功能,遵守开闭原则和单一职责原则 #####

##### 学习jdk动态代理的几个层次 #####

1.能够写出jdk动态代理的代码
    2.能清晰的了解jdk动态代理的调用关系  参见:jdk动态代理调用原理图.png
    3.了解jdk的动态代理类的内容

##### jdk的动态代理流程 #####

1.创建生成代理对象的类JDKProxy.java       getProxyObject方法用户生成代理对象
    2.创建InvocationHandler接口的子实现,在子实现中的invoke方法把老业务功能和新业务功能耦合
    OldAndNewtogether.java      invoke方法,耦合了新和老的业务
    
    在jdk创建代理对象的之前,由jdk底层根据目标对象和目标对象所对应的接口,
    创建出代理类,此代理类只是临时出现,用完就没有了,
    创建完代理类,实例化此代理类的对象,Object proxyObject=Proxy.newProxyInstance(参数一,参数二,参数三);
    只有调用Object proxyObject=Proxy.newProxyInstance(参数一,参数二,参数三);才会生成代理类和代理对象

##### 下面是生成的代理类的模型: #####

/** * jdk的代理类,由jdk的底层创建的 * @author Administrator * */
    public final class $Proxy0 extends Proxy implements UserService { 
    	//静态代码块,m0---mx赋值 类型是Method
    	static { 
    		try { 
    			m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
    			m1 = Class.forName("java.lang.Object").getMethod("equals",
    					new Class[] {  Class.forName("java.lang.Object") });
    			m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
    			m3 = Class.forName("com.arno.service.UserService").getMethod("addUser",
    					new Class[] {  Class.forName("com.tarean.entity.User") });
    			m4 = Class.forName("com.arno.service.UserService").getMethod("updateUser",
    					new Class[] {  Class.forName("com.tarean.entity.User") });
    			
    			return;
    		} catch (NoSuchMethodException localNoSuchMethodException) { 
    			throw new NoSuchMethodError(localNoSuchMethodException.getMessage());
    		} catch (ClassNotFoundException localClassNotFoundException) { 
    			throw new NoClassDefFoundError(localClassNotFoundException.getMessage());
    		}
    	}
    	//若干私有属性
    	private static Method m0;//hashCode方法,从Object中获取
    	private static Method m1;//equals方法,从Object中获取
    	private static Method m2;//toString方法,从Object中获取
    	private static Method m3;//addUser方法,从UserService接口中获取
    	private static Method m4;//updateUser方法,从UserService接口中获取
    	
        //代理类构造
    	public $Proxy0(InvocationHandler paramInvocationHandler)throws { 
    		super(paramInvocationHandler);
    	}
        
    	//重写UserService接口的addUser方法
        public final void addUser(User user)throws{ 
        	try{ 
        		this.h.invoke(this, m3, new Object[] {  user });
        		return;
        	}catch (Error|RuntimeException localError){ 
        		throw localError;
        	}catch (Throwable localThrowable){ 
        		throw new UndeclaredThrowableException(localThrowable);
        	}
        }
        //重写UserService接口的updateUser方法
        public final void updateUser(User user)throws{ 
        	try{ 
        		this.h.invoke(this, m4, new Object[] {  user });
        		return;
        	}catch (Error|RuntimeException localError){ 
        		throw localError;
        	}catch (Throwable localThrowable){ 
        		throw new UndeclaredThrowableException(localThrowable);
        	}
        }
        
        //equals方法
        public final boolean equals(Object paramObject)throws { 
        	try{ 
        		return ((Boolean)this.h.invoke(this, m1, new Object[] {  paramObject })).booleanValue();
        	}catch (Error|RuntimeException localError){ 
        		throw localError;
        	}catch (Throwable localThrowable){ 
        		throw new UndeclaredThrowableException(localThrowable);
        	}
        }
        public final String toString()throws{ 
        	try{ 
        		return (String)this.h.invoke(this, m2, null);
        	}catch (Error|RuntimeException localError){ 
        		throw localError;
        	}catch (Throwable localThrowable){ 
        		throw new UndeclaredThrowableException(localThrowable);
        	}
        }
    
        public final int hashCode()throws{ 
        	try{ 
        		return ((Integer)this.h.invoke(this, m0, null)).intValue();
        	}catch (Error|RuntimeException localError){ 
        		throw localError;
        	}catch (Throwable localThrowable){ 
        		throw new UndeclaredThrowableException(localThrowable);
        	}
        }	
    }

##### 总结jdk动态代理: #####

1.原有的老业务,没有被破坏,符合单一职责 UserService.java
    2.新的业务,符合单一职责 TransactionManager.java
    3.创建一个java类用户生成代理对象JDKProxy.java    
    4.把新的业务要添加到老业务中
        a.必须实现InvocationHandler接口   OldAndNewTogether.java
        b.重写invoke的方法
        c.在方法中把老业务和新业务耦合
    5.一定要先由jdk生成代理类    参见:$Proxy0.java
    6.由代理类生成代理对象
    7.代理对象和目标对象是兄弟关系
       代理类和目标类是兄弟关系
    8.jdk动态代理要求目标类必须接口 
    9.jdk的代理类是在运行期间出现,一定不在编译期间出现
       所谓的动态代理是代理类是动态出现的,什么时候调用,什么时候出现代理类

#### CGLIB动态代理:需要第三方库支撑 ####

##### 总结CGLIB动态代理: #####

0.需要额外第三方jar支撑
    1.原有的老业务,没有被破坏,符合单一职责 UserService.java
    2.新的业务,符合单一职责 TransactionManager.java
    3.创建一个java类用户生成代理对象CGLIBProxy.java    
    4.把新的业务要添加到老业务中
        a.必须实现MethodInterceptor接口   OldAndNewTogether.java
        b.重写intercept的方法
        c.在方法中把老业务和新业务耦合
    5.一定要先由asm.jar生成代理类    
    6.由代理类生成代理对象
    7.代理对象和目标对象是父子关系     
      目标类是代理类的父亲
       目标类不能是final
    8.cglib动态代理的目标类有无接口皆可 
    9.cglib的代理类是在运行期间出现,一定不在编译期间出现
       所谓的动态代理是代理类是动态出现的,什么时候调用,什么时候出现代理类

#### jdk动态代理和cglib动态代理的主要区别: ####

##### jdk动态代理: #####

1.目标类必须有接口
    2.代理对象和目标对象是兄弟关系
    3.代理类是在运行期间动态创建的
    4.创建代理对象快,用代理对象执行目标方法的时候是慢
    5.jdk动态代理会把代理类缓存

##### cglib动态代理: #####

1.目标类有无接口皆可,但不能是final类
    2.目标类是代理类的父类
    3.代理类是在运行期间动态创建的
    4.创建代理对象慢,用代理对象执行目标方法的时候快

代理就把新功能横切到原有业务上,在满足开闭原则和单一职责前提下  
可以把新功能看成某一方面的功能,把某一个方面的功能横切到需要的业务上  
spring aop的底层原理就是用的动态代理(有接口就用jdk,没有接口就用cglib)

##### 提出问题: #####

jdk动态代理和cglib动态代理,把新功能横切到原有老业务中的所有方法上
    能否把新功能横切到业务中的指定的一部分方法上,其他的业务方法不需要横切

答案:用spring aop可以对部分业务方法横切