1.AOP概念
Aspect Oriented Programming 面向切面编程
AOP概述
●AOP(Aspect-Oriented Programming，面向切面编程)：是一种新的方法论，
是对传统 OOP(Object-Oriented Programming，面向对象编程)的补充。
●参见图例和doc文档解释AOP的各个术语！
●Spring的AOP既可以使用xml配置的方式实现，也可以使用注解的方式来实现！
2.作用：本质上来说是一种简化代码的方式
继承机制
封装方法
动态代理
……
3.情景举例
①数学计算器接口[MathCalculator]
int add(int i,int j);
int sub(int i,int j);
int mul(int i, int j);
int div(int i,int j
②提供简单实现[EasyImpl]
③在简单实现的基础上让每一个计算方法都能够打印日志[LoginImpl]
④缺陷
[1]手动添加日志繁琐，重复
[2]统一修改不便
[3]对目标方法本来要实现的核心功能有干扰，使程序代码很臃肿，不易于开发维护
⑤使用动态代理实现
[1]创建一个类，让这个类能够提供一个目标对象的代理对象
[2]在代理对象中打印日志
4.在Spring中使用AOP实现日志功能
①Spring中可以使用注解或XML文件配置的方式实现AOP。
②导入jar包
com.springsource.net.sf.cglib -2.2.0.jar com.springsource.org.aopalliance-1.0.0 .jar com.springsource.org.aspectj.weaver-1.6.8 .RELEASE.jar commons-logging-1.1.3. jar spring-aop-4.0.0.RELEASE.jar spring-aspects-4.0.0.RELEASE.jar spring-beans-4.0.0.RELEASE.jar spring-context-4.0.0.RELEASE.jar spring-core-4.0.0.RELEASE.jar spring-expression-4.0.0.RELEASE. jar
③开启基于注解的AOP功能
< aop:aspectj-autoproxy />
④声明一个切面类，并把这个切面类加入到IOC容器中
@Aspect//表示这是一个切面类
@Component//加入IOC容器
public class LogAspect {}
⑤在切面类中声明通知方法
[1]前置通知：@Before
[2]返回通知：@AfterReturning
[3]异常通知：@AfterThrowing
[4]后置通知：@After
[5]环绕通知：@Around :环绕通知是前面四个通知的集合体！
@Aspect//表示这是一个切面类 @Component//将本类对象加入到IOC容器中！ public class LogAspect { @Before(value="execution(public int com.neuedu.aop.target.MathCalculatorImpl.add(int, int))") public void showBeginLog(){ System.out.println("AOP日志开始"); } @After(value="execution(public int com.neuedu.aop.target.MathCalculatorImpl.add(int, int))") public void showReturnLog(){ System.out.println("AOP方法返回"); } @AfterThrowing(value="execution(public int com.neuedu.aop.target.MathCalculatorImpl.add(int, int))") public void showExceptionLog(){ System.out.println("AOP方法异常"); } @AfterReturning(value="execution(public int com.neuedu.aop.target.MathCalculatorImpl.add(int, int))") public void showAfterLog(){ System.out.println("AOP方法结束"); } }
⑥被代理的对象也需要加入IOC容器
5.切入点表达式
1)上述案例通过junit测试，会发现，我们调用目标类的四个方法只有add方法被加入了4个通知，如果想所有的方法都加上这些通知，可以
在切入点表达式处，将execution(public int com.neuedu.aop.target.MathCalculatorImpl.add(int, int)) 换成：
execution(public int com.neuedu.aop.target.MathCalculatorImpl.*(int, int))这样只要是有两个参数，且
参数类型为int的方法在执行的时候都会执行其相应的通知方法！
2)切入点表达式的语法格式
execution([权限修饰符] [返回值类型] [简单类名/全类名] [方法名]([参数列表]))
最详细的切入点表达式：
execution(public int com.neuedu.aop.target.MathCalculatorImpl.add(int, int))
最模糊的切入点表达式：
execution (* *.*(..))
6.统一声明切入点表达式
@Pointcut(value= "execution(public int com.atguigu.aop.target.EazyImpl.add(int,int))")
public void myPointCut(){}
7.通知方法的细节
①在通知中获取目标方法的方法名和参数列表
[1]在通知方法中声明一个JoinPoint类型的形参
[2]调用JoinPoint对象的getSignature()方法获取目标方法的签名
[3]调用JoinPoint对象的getArgs()方法获取目标方法的实际参数列表
②在返回通知中获取方法的返回值
[1]在@AfterReturning注解中添加returning属性
@AfterReturning (value="myPointCut()", returning= "result")
[2]在返回通知的通知方法中声明一个形参，形参名和returning属性的值一致
showReturnLog(JoinPoint joinPoint, Object result)
③在异常通知中获取异常对象
[1]在@ AfterThrowing注解中添加throwing属性
@AfterThrowing (value="myPointCut()",throwing= "throwable" )
[2]在异常通知的通知方法中声明一个形参，形参名和throwing属性值一致
showExceptinLog(JoinPoint joinPoint, Throwable throwable)
根据接口类型获取target对象时，实际上真正放在IOC容器中的对象是代理对象，而并不是目标对象本身!
八、环绕通知:@Around
1.环绕通知需要在方法的参数中指定JoinPoint的子接口类型ProceedingJoinPoint为参数
@Around(value="pointCut()") public void around(ProceedingJoinPoint joinPoint){ }
2.环绕通知会将其他4个通知能干的，自己都给干了！
注意:@Around修饰的方法一定要将方法的返回值返回！本身相当于代理！
@Around(value="pointCut()") public Object around(ProceedingJoinPoint joinPoint){ Object[] args = joinPoint.getArgs(); Signature signature = joinPoint.getSignature(); String methodName = signature.getName(); List<Object> list = Arrays.asList(args); Object result = null; try { //目标方法之前要执行的操作 System.out.println("[环绕日志]"+methodName+"开始了，参数为:"+list); //调用目标方法 result = joinPoint.proceed(args); //目标方法正常执行之后的操作 System.out.println("[环绕日志]"+methodName+"返回了，返回值为:"+result); } catch (Throwable e) { //目标方法抛出异常信息之后的操作 System.out.println("[环绕日志]"+methodName+"出异常了，异常对象为:"+e); throw new RuntimeException(e.getMessage()); }finally{ //方法最终结束时执行的操作！ System.out.println("[环绕日志]"+methodName+"结束了!"); } return result; }
九、切面的优先级
对于同一个代理对象，可j以同时有多个切面共同对它进行代理。
可以在切面类上通过@Order (value=50)注解来进行设置，值越小优先级越高!
@Aspect @Component @Order(value=40) public class TxAspect { @Around(value="execution(public * com.neuedu.aop.target.MathCalculatorImpl.*(..))") public Object around(ProceedingJoinPoint joinPoint){ Object[] args = joinPoint.getArgs(); Signature signature = joinPoint.getSignature(); String methodName = signature.getName(); List<Object> list = Arrays.asList(args); Object result = null; try { //目标方法之前要执行的操作 System.out.println("[事务日志]"+methodName+"开始了，参数为:"+list); //调用目标方法 result = joinPoint.proceed(args); //目标方法正常执行之后的操作 System.out.println("[事务日志]"+methodName+"返回了，返回值为:"+result); } catch (Throwable e) { //目标方法抛出异常信息之后的操作 System.out.println("[事务日志]"+methodName+"出异常了，异常对象为:"+e); throw new RuntimeException(e.getMessage()); }finally{ //方法最终结束时执行的操作！ System.out.println("[事务日志]"+methodName+"结束了!"); } return result; } }
注意:上面的AOP都是通过注解实现的，AOP实际上也可以通过xml配置的方式实现！
事务的管理是和AOP是有很大关系的,即声明式事务的底层是用事务实现的！
<!-- 1.将需要加载到IOC容器中的bean配置好 --> <bean id="logAspect" class="com.neuedu.aop.proxy.LogAspect"></bean> <bean id="txAspect" class="com.neuedu.aop.target.TxAspect"></bean> <bean id="calculator" class="com.neuedu.aop.target.MathCalculatorImpl"></bean> <!-- 2.配置AOP,需要导入AOP名称空间 --> <aop:config> <!-- 声明切入点表达式 --> <aop:pointcut expression="execution(* com.neuedu.aop.target.MathCalculatorImpl.*(..))" id="myPointCut"/> <!-- 配置日志切面类,引用前面的类 ,通过order属性控制优先级--> <aop:aspect ref="logAspect" order="25"> <!-- 通过method属性指定切面类的切面方法，通过pointcut-ref指定切入点表达式 --> <aop:before method="showBeginLog" pointcut-ref="myPointCut"/> <aop:after method="showAfterLog" pointcut-ref="myPointCut"/> <aop:after-throwing method="showExceptionLog" pointcut-ref="myPointCut" throwing="ex"/> <aop:after-returning method="showReturnLog" pointcut-ref="myPointCut" returning="result"/> <aop:around method="around" pointcut-ref="myPointCut"/> </aop:aspect> <!-- 配置事务切面类,引用前面的类 --> <aop:aspect ref="txAspect" order="20"> <aop:around method="around" pointcut-ref="myPointCut"/> </aop:aspect> </aop:config>
十、批处理(batch)
1、概念
- 批处理指的是一次操作中执行多条SQL语句
- 批处理相比于一次一次执行效率会提高很多
2、主要步骤
1）将要执行的SQL语句保存
2）执行SQL语句
- Statement和PreparedStatement都支持批处理操作，这里我们只需要掌握PreparedStatement的批处理方式：
- 方法：
void addBatch()
- 将要执行的SQL先保存起来，先不执行
- 这个方法在设置完所有的占位符之后调用
int[] executeBatch()
- 这个方法用来执行SQL语句，这个方法会将批处理中所有SQL语句执行
- mysql默认批处理是关闭的，所以我们还需要去打开mysql的批处理：
rewriteBatchedStatements=true
我们需要将以上的参数添加到mysql的url地址中
- 注意：低版本的mysql-jdbc驱动也不支持批处理,一般都是在修改的时候使用批处理，查询的时候不使用！
案例演示：
1）创建一张新的数据表
CREATE TABLE t_emp( id INT PRIMARY KEY AUTO_INCREMENT, NAME VARCHAR(50) )
2）反复打开数据库客户端，插入语句【相当于每次获取一个connection连接，执行executeUpdate语句】
INSERT INTO t_emp(NAME) VALUES('张三');
SELECT * FROM t_emp;
3）引出批处理--->执行效率高,资源利用率好！
@Test//测试批处理 public void testBatch(){ //向t_emp表中插入10000条数据 //准备两个变量 Connection connection = null; PreparedStatement ps = null; try { //获取数据库连接 connection=JDBCUtil.getConnection(); //准备SQL模板 String sql = "INSERT INTO t_emp(NAME) VALUES(?)"; //获取PrepareStatement ps = connection.prepareStatement(sql); //创建一个for循环，来设置占位符 for(int i = 0; i < 10000 ;i++){ //填充占位符 ps.setString(1,"emp"+i); //添加到批处理方法中，调用无参的，有参的是Statement来调用的！ ps.addBatch(); } //获取一个时间戳 long start = System.currentTimeMillis(); //执行批处理 ps.executeBatch(); //获取一个时间戳 long end = System.currentTimeMillis(); System.out.println("共花费了："+(end-start)); } catch (SQLException e) { e.printStackTrace(); } }