Spring（四）

痛定思痛。 2023-07-15 13:03 3阅读 0赞

## AOP ##

**什么是 AOP**  
在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

简单的说它就是把我们程序重复的代码抽取出来，在需要执行的时候，使用动态代理的技术，在不修改源码的  
基础上，对我们的已有方法进行增强。

**AOP 的作用及优势**

*  作用：  
    在程序运行期间，不修改源码对已有方法进行增强。
 *  优势：  
    减少重复代码  
    提高开发效率  
    维护方便

**AOP 的实现方式**  
使用动态代理技术

首先先看下面案例

/** * 账户的业务层实现类 */
    public class AccountServiceImpl implements IAccountService { 
    
    	private IAccountDao accountDao;
    	
    	public void setAccountDao(IAccountDao accountDao) { 
    		this.accountDao = accountDao;
    	}
    	@Override
    	public void saveAccount(Account account) throws SQLException { 
    		accountDao.save(account);
    	}
    	@Override
    	public void updateAccount(Account account) throws SQLException{ 
    		accountDao.update(account);
    	}
    	@Override
    	public void deleteAccount(Integer accountId) throws SQLException{ 
    		accountDao.delete(accountId);
    	}
    	@Override
    	public Account findAccountById(Integer accountId) throws SQLException { 
    		return accountDao.findById(accountId);
    	}
    	@Override
    	public List<Account> findAllAccount() throws SQLException{ 
    		return accountDao.findAll();
    	}
    }

问题就是：  
事务被自动控制了。换言之，我们使用了 connection 对象的setAutoCommit(true)  
此方式控制事务，如果我们每次都执行一条 sql 语句，没有问题，但是如果业务方法一次要执行多条 sql语句，这种方式就无法实现功能了。

再看下面的案例

业务层接口
    	/** * 转账 * @param sourceName * @param targetName * @param money */
    	void transfer(String sourceName,String targetName,Float money);

业务层实现类：
    	@Override
    	public void transfer(String sourceName, String targetName, Float money) { 
    	//根据名称查询两个账户信息
    	Account source = accountDao.findByName(sourceName);
    	Account target = accountDao.findByName(targetName);
    	//转出账户减钱，转入账户加钱
    	source.setMoney(source.getMoney()-money);
    	target.setMoney(target.getMoney()+money);
    	//更新两个账户
    	accountDao.update(source);
    	int i=1/0; //模拟转账异常
    	accountDao.update(target);
    }

当我们执行时，由于执行有异常，转账失败。但是因为我们是每次执行持久层方法都是独立事务，导致无法实现事务控制（不符合事务的一致性）

*  解决办法：  
    让业务层来控制事务的提交和回滚。

/** * 账户的业务层实现类 */
    	public class AccountServiceImpl implements IAccountService { 
    	
    		private IAccountDao accountDao = new AccountDaoImpl();
    		@Override
    		public void saveAccount(Account account) { 
    			try { 
    				TransactionManager.beginTransaction();
    				accountDao.save(account);
    				TransactionManager.commit();
    			} catch (Exception e) { 
    				TransactionManager.rollback();
    				e.printStackTrace();
    			}finally { 
    				TransactionManager.release();
    			}
    		}
    		@Override
    		public void updateAccount(Account account) { 
    			try { 
    				TransactionManager.beginTransaction();
    				accountDao.update(account);
    				TransactionManager.commit();
    			} catch (Exception e) { 
    				TransactionManager.rollback();
    				e.printStackTrace();
    			}finally { 
    				TransactionManager.release();
    			}
    		}
    		@Override
    		public void deleteAccount(Integer accountId) { 
    			try { 
    				TransactionManager.beginTransaction();
    				accountDao.delete(accountId);
    				TransactionManager.commit();
    			} catch (Exception e) { 
    				TransactionManager.rollback();
    				e.printStackTrace();
    			}finally { 
    				TransactionManager.release();
    			}
    		}
    		@Override
    		public Account findAccountById(Integer accountId) { 
    			Account account = null;
    			try { 
    				TransactionManager.beginTransaction();
    				account = accountDao.findById(accountId);
    				TransactionManager.commit();
    				return account;
    			} catch (Exception e) { 
    				TransactionManager.rollback();
    				e.printStackTrace();
    			}finally { 
    				TransactionManager.release();
    			}
    			return null;
    		}
    		@Override
    		public List<Account> findAllAccount() { 
    			List<Account> accounts = null;
    			try { 
    				TransactionManager.beginTransaction();
    				accounts = accountDao.findAll();
    				TransactionManager.commit();
    				return accounts;
    			} catch (Exception e) { 
    				TransactionManager.rollback();
    				e.printStackTrace();
    			}finally { 
    				TransactionManager.release();
    			}
    				return null;
    			}
    		@Override
    		public void transfer(String sourceName, String targetName, Float money) { 
    			try { 
    				TransactionManager.beginTransaction();
    				Account source = accountDao.findByName(sourceName);
    				Account target = accountDao.findByName(targetName);
    				source.setMoney(source.getMoney()-money);
    				target.setMoney(target.getMoney()+money);
    				accountDao.update(source);
    				int i=1/0;
    				accountDao.update(target);
    				TransactionManager.commit();
    			} catch (Exception e) { 
    				TransactionManager.rollback();
    				e.printStackTrace();
    			}finally { 
    				TransactionManager.release();
    			}
    	}
    }

TransactionManager 类的代码：
    /** * 事务控制类 */
    public class TransactionManager { 
    	//定义一个 DBAssit
    	private static DBAssit dbAssit = new DBAssit(C3P0Utils.getDataSource(),true);
    	//开启事务
    	public static void beginTransaction() { 
    		try { 
    			dbAssit.getCurrentConnection().setAutoCommit(false);
    		} catch (SQLException e) { 
    			e.printStackTrace();
    		}
    	}
    	//提交事务
    	public static void commit() { 
    		try { 
    			dbAssit.getCurrentConnection().commit();
    		} catch (SQLException e) { 
    			e.printStackTrace();
    		}
    	}
    	//回滚事务
    	public static void rollback() { 
    		try { 
    			dbAssit.getCurrentConnection().rollback();
    		} catch (SQLException e) { 
    			e.printStackTrace();
    		}
    	}
    	//释放资源
    	public static void release() { 
    		try { 
    			dbAssit.releaseConnection();
    		} catch (Exception e) { 
    			e.printStackTrace();
    		}
    	}
    }

上面的代码，通过对业务层改造，已经可以实现事务控制了，但是由于我们添加了事务控制，也产生了一个新的问题：业务层方法变得臃肿了，里面充斥着很多重复代码。并且业务层方法和事务控制方法耦合了。  
试想一下，如果我们此时提交，回滚，释放资源中任何一个方法名变更，都需要修改业务层的代码，况且这还只是一个业务层实现类，而实际的项目中这种业务层实现类可能有十几个甚至几十个。  
怎么解决呢？  
**动态代理**

**动态代理的特点**  
字节码随用随创建，随用随加载。  
它与静态代理的区别也在于此。因为静态代理是字节码一上来就创建好，并完成加载。  
装饰者模式就是静态代理的一种体现。  
**动态代理常用的有两种方式**

*  基于接口的动态代理  
    提供者：JDK 官方的 Proxy 类。  
    要求：被代理类最少实现一个接口。
 *  基于子类的动态代理  
    提供者：第三方的 CGLib，如果报 asmxxxx 异常，需要导入 asm.jar。  
    要求：被代理类不能用 final 修饰的类（最终类）。

**使用 JDK 官方的 Proxy 类创建代理对象**

public interface IActor { 
    	/** * 基本演出 * @param money */
    	public void basicAct(float money);
    	/** * 危险演出 * @param money */
    	public void dangerAct(float money);
    }

/** * 一个演员 */
    //实现了接口，就表示具有接口中的方法实现。即：符合经纪公司的要求
    public class Actor implements IActor{ 
    	public void basicAct(float money){ 
    		System.out.println("拿到钱，开始基本的表演："+money);
    	}
    	public void dangerAct(float money){ 
    		System.out.println("拿到钱，开始危险的表演："+money);
    	}
    }

public class Client { 
    	public static void main(String[] args) { 
    		//一个剧组找演员：
    		final Actor actor = new Actor();//直接
    		/** * 代理： * 间接。 * 获取代理对象： * 要求： * 被代理类最少实现一个接口 * 创建的方式 * Proxy.newProxyInstance(三个参数) * 参数含义： * ClassLoader：和被代理对象使用相同的类加载器。 * Interfaces：和被代理对象具有相同的行为。实现相同的接口。 * InvocationHandler：如何代理。 * 策略模式：使用场景是： * 数据有了，目的明确。 * 如何达成目标，就是策略。 * */
    		IActor proxyActor = (IActor) Proxy.newProxyInstance(
    			actor.getClass().getClassLoader(),
    			actor.getClass().getInterfaces(),
    			new InvocationHandler() { 
    			/** * 执行被代理对象的任何方法，都会经过该方法。 * 此方法有拦截的功能。 * * 参数： * proxy：代理对象的引用。不一定每次都用得到 * method：当前执行的方法对象 * args：执行方法所需的参数 * 返回值： * 当前执行方法的返回值 */
    		@Override
    		public Object invoke(Object proxy, Method method, Object[] args)throws Throwable { 
    			String name = method.getName();
    			Float money = (Float) args[0];
    			Object rtValue = null;
    			//每个经纪公司对不同演出收费不一样，此处开始判断
    			if("basicAct".equals(name)){ 
    				//基本演出，没有 2000 不演
    				if(money > 2000){ 
    				//看上去剧组是给了 8000，实际到演员手里只有 4000
    				//这就是我们没有修改原来 basicAct 方法源码，对方法进行了增强
    				rtValue = method.invoke(actor, money/2);
    				}
    			}
    			if("dangerAct".equals(name)){ 
    				//危险演出,没有 5000 不演
    				if(money > 5000){ 
    				//看上去剧组是给了 50000，实际到演员手里只有 25000
    				//这就是我们没有修改原来 dangerAct 方法源码，对方法进行了增强
    					rtValue = method.invoke(actor, money/2);
    				}
    			}
    			return rtValue;
    			}
    		});
    		//没有经纪公司的时候，直接找演员。
    		// actor.basicAct(1000f);
    		// actor.dangerAct(5000f);
    		//剧组无法直接联系演员，而是由经纪公司找的演员
    		proxyActor.basicAct(8000f);
    		proxyActor.dangerAct(50000f);
    	}
    }

**使用 CGLib 的 Enhancer 类创建代理对象**

/** * 一个演员 */
    public class Actor{ //没有实现任何接口
        public void basicAct(float money){ 
            System.out.println("拿到钱，开始基本的表演："+money);
        }
        public void dangerAct(float money){ 
            System.out.println("拿到钱，开始危险的表演："+money);
        }
    }

public class Client { 
        /** * 基于子类的动态代理 * 要求： * 被代理对象不能是最终类 * 用到的类： * Enhancer * 用到的方法： * create(Class, Callback) * 方法的参数： * Class：被代理对象的字节码 * Callback：如何代理 * * @param args */
        public static void main(String[] args) { 
            final Actor actor = new Actor();
            Actor cglibActor = (Actor) Enhancer.create(actor.getClass(),
                    new MethodInterceptor() { 
                        /** * 执行被代理对象的任何方法，都会经过该方法。在此方法内部就可以对被代理对象的任何 方法进行增强。 * * 参数： * 前三个和基于接口的动态代理是一样的。 * MethodProxy：当前执行方法的代理对象。 * 返回值： * 当前执行方法的返回值 */
                        @Override
                        public Object intercept(Object proxy, Method method, Object[] args,
                                                MethodProxy methodProxy) throws Throwable { 
                            String name = method.getName();
                            Float money = (Float) args[0];
                            Object rtValue = null;
                            if ("basicAct".equals(name)) { 
    							//基本演出
                                if (money > 2000) { 
                                    rtValue = method.invoke(actor, money / 2);
                                }
                            }
                            if ("dangerAct".equals(name)) { 
    							//危险演出
                                if (money > 5000) { 
                                    rtValue = method.invoke(actor, money / 2);
                                }
                            }
                            return rtValue;
                        }
                    });
            cglibActor.basicAct(10000);
            cglibActor.dangerAct(100000);
        }
    }

**解决案例中的问题**

/** * 用于创建客户业务层对象工厂（当然也可以创建其他业务层对象，只不过我们此处不做那么繁琐） */
    public class BeanFactory { 
        /** * 创建账户业务层实现类的代理对象 * @return */
        public static IAccountService getAccountService() { 
    		//1.定义被代理对象
            final IAccountService accountService = new AccountServiceImpl();
    		//2.创建代理对象
            IAccountService proxyAccountService = (IAccountService)
                    Proxy.newProxyInstance(accountService.getClass().getClassLoader(),
                            accountService.getClass().getInterfaces(), new
                                    InvocationHandler() { 
                                        /** * 执行被代理对象的任何方法，都会经过该方法。 * 此处添加事务控制 */
                                        @Override
                                        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
                                            Object rtValue = null;
                                            try { 
    //开启事务
                                                TransactionManager.beginTransaction();
    											//执行业务层方法
                                                rtValue = method.invoke(accountService, args);
    											//提交事务
                                                TransactionManager.commit();
                                            } catch (Exception e) { 
    											//回滚事务
                                                TransactionManager.rollback();
                                                e.printStackTrace();
                                            } finally { 
    											//释放资源
                                                TransactionManager.release();
                                            }
                                            return rtValue;
                                        }
                                    });
            return proxyAccountService;
        }
    }

**当我们改造完成之后，业务层用于控制事务的重复代码就都可以删掉了。**

**Spring 中 AOP 的细节**

*  AOP 相关术语  
    Joinpoint(连接点):  
    所谓连接点是指那些被拦截到的点。在 spring 中,这些点指的是方法,因为 spring 只支持方法类型的连接点。  
    Pointcut(切入点):  
    所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义。  
    Advice(通知/增强):  
    所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知。  
    通知的类型：前置通知,后置通知,异常通知,最终通知,环绕通知。  
    Introduction(引介):  
    引介是一种特殊的通知在不修改类代码的前提下, Introduction 可以在运行期为类动态地添加一些方法或 Field。  
    Target(目标对象):  
    代理的目标对象。  
    Weaving(织入):  
    是指把增强应用到目标对象来创建新的代理对象的过程。  
    spring 采用动态代理织入，而 AspectJ 采用编译期织入和类装载期织入。  
    Proxy（代理）:  
    一个类被 AOP 织入增强后，就产生一个结果代理类。  
    Aspect(切面):  
    是切入点和通知（引介）的结合。
 *  学习 spring 中的 AOP 要明确的事  
    a、开发阶段（我们做的）  
    编写核心业务代码（开发主线）：大部分程序员来做，要求熟悉业务需求。  
    把公用代码抽取出来，制作成通知。（开发阶段最后再做）：AOP 编程人员来做。  
    在配置文件中，声明切入点与通知间的关系，即切面。：AOP 编程人员来做。  
    b、运行阶段（Spring 框架完成的）  
    Spring 框架监控切入点方法的执行。一旦监控到切入点方法被运行，使用代理机制，动态创建目标对象的代理对象，根据通知类别，在代理对象的对应位置，将通知对应的功能织入，完成完整的代码逻辑运行。
 *  关于代理的选择  
    在 spring 中，框架会根据目标类是否实现了接口来决定采用哪种动态代理的方式。

**基于 XML 的 AOP 配置**