目录
- 第十五章 AOP前奏
- 15.1 代理模式
- 15.2 为什么需要代理【程序中】
- 15.3 手动实现动态代理环境搭建
- 15.4 手动实现动态代理关键步骤
- 第十六章 Spring中AOP【重点】
- 16.1 AspectJ框架【AOP框架】
- 16.2 使用AspectJ步骤（入门）
- 16.3 Spring中AOP概述
- 16.4 Spring中AOP相关术语
- 第十七章 AspectJ详解【重点】
- 17.1 AspectJ中切入点表达式
- 17.2 AspectJ中JoinPoint对象
- 17.3 AspectJ中通知
- 17.4 定义切面优先级
- 17.5 基于XML方式配置AOP
- 第十八章 Spring中JdbcTemplate
- 18.1 JdbcTemplate简介
- 18.2 JdbcTemplate基本使用
- 18.3 JdbcTemplate的常用API
- 18.4 使用JdbcTemplate搭建Service&Dao层
第十五章 AOP前奏
15.1 代理模式
-
代理模式：我们需要做一件事情，又不期望自己亲力亲为，此时，可以找一个代理【中介】
-
我们【目标对象】与中介【代理对象】不能相互转换，因为是“兄弟”关系
15.2 为什么需要代理【程序中】
-
需求：实现【加减乘除】计算器类
- 在加减乘除方法中，添加日志功能【在计算之前，记录日志。在计算之后，显示结果。】
-
实现后发现问题如下
- 日志代码比较分散，可以提取日志类
- 日志代码比较混乱，日志代码【非核心业务代码】与加减乘除方法【核心业务代码】书写一处
-
总结：在核心业务代码中，需要添加日志功能，但不期望在核心业务代码中书写日志代码。
- 此时：使用代理模式解决问题【先将日志代码横向提取到日志类中，再动态织入回到业务代码中】
15.3 手动实现动态代理环境搭建
-
实现方式
- 基于接口实现动态代理： JDK动态代理
- 基于继承实现动态代理： Cglib、Javassist动态代理
-
实现动态代理关键步骤
- 一个类：Proxy
- 概述：Proxy代理类的基类【类似Object】
- 作用：newProxyInstance()：创建代理对象
- 一个接口：InvocationHandler
- 概述：实现【动态织入效果】关键接口
- 作用：invoke()，执行invoke()实现动态织入效果
- 一个类：Proxy
15.4 手动实现动态代理关键步骤
注意：代理对象与实现类【目标对象】是“兄弟”关系，不能相互转换
- 创建类【为了实现创建代理对象工具类】
- 提供属性【目标对象：实现类】
- 提供方法【创建代理对象】
- 提供有参构造器【避免目标对为空】
package com.atguigu.beforeaop;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
* @author Chunsheng Zhang 尚硅谷
* @create 2022/3/28 16:22
*/
public class MyProxy {
/**
* 目标对象【目标客户】
*/
private Object target;
public MyProxy(Object target){
this.target = target;
}
/**
* 获取目标对象的，代理对象
* @return
*/
public Object getProxyObject(){
Object proxyObj = null;
/**
类加载器【ClassLoader loader】,目标对象类加载器
目标对象实现接口：Class<?>[] interfaces,目标对象实现所有接口
InvocationHandler h
*/
ClassLoader classLoader = target.getClass().getClassLoader();
Class<?>[] interfaces = target.getClass().getInterfaces();
//创建代理对象
proxyObj = Proxy.newProxyInstance(classLoader, interfaces, new InvocationHandler() {
//执行invoke()实现动态织入效果
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//获取方法名【目标对象】
String methodName = method.getName();
//执行目标方法之前，添加日志
MyLogging.beforeMethod(methodName,args);
//触发目标对象目标方法
Object rs = method.invoke(target, args);
//执行目标方法之后，添加日志
MyLogging.afterMethod(methodName,rs);
return rs;
}
});
return proxyObj;
}
// class invocationImpl implements InvocationHandler{
// }
}
@Test
public void testBeforeAop(){
// int add = calc.add(1, 2);
// System.out.println("add = " + add);
//目标对象
Calc calc = new CalcImpl();
//代理工具类
MyProxy myProxy = new MyProxy(calc);
//获取代理对象
Calc calcProxy = (Calc)myProxy.getProxyObject();
//测试
// int add = calcProxy.add(1, 2);
int div = calcProxy.div(2, 1);
}
第十六章 Spring中AOP【重点】
16.1 AspectJ框架【AOP框架】
- AspectJ是Java社区里最完整最流行的AOP框架。
- 在Spring2.0以上版本中，可以使用基于AspectJ注解或基于XML配置的AOP。
16.2 使用AspectJ步骤（入门）
-
添加jar包支持
<!-- 添加AspectJ--> <!--spirng-aspects的jar包--> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-aspects</artifactId> <version>5.3.1</version> </dependency> -
配置文件
- 开启组件扫描
- 开启AspectJ注解支持
<!-- 开启组件扫描--> <context:component-scan base-package="com.atguigu"></context:component-scan> <!-- 开启AspectJ注解支持--> <aop:aspectj-autoproxy></aop:aspectj-autoproxy> -
将MyLogging类上面添加注解
- @Component：将当前类标识为一个组件
- @Aspect：将当前类标识为切面类【非核心业务提取类】
-
将MyLogging中的方法中添加通知注解
- @Before
@Component //将当前类标识为一个组件 @Aspect //将当前类标识为【切面类】【非核心业务提取类】 public class MyLogging { /** * 方法之前 */ @Before(value = "execution(public int com.atguigu.aop.CalcImpl.add(int , int ) )") public void beforeMethod(JoinPoint joinPoint){ //获取方法名称 String methodName = joinPoint.getSignature().getName(); //获取参数 Object[] args = joinPoint.getArgs(); System.out.println("==>Calc中的"+methodName+"方法()，参数：+" + Arrays.toString(args)); } } -
测试
@Test public void testAop(){ //创建容器对象 ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext_aop.xml"); Calc calc = context.getBean("calc", Calc.class); //错误的，代理对象不能转换为目标对象【代理对象与目标对象是兄弟关系】 //CalcImpl calc = context.getBean("calc", CalcImpl.class); int add = calc.add(1, 2); }
16.3 Spring中AOP概述
- AOP：Aspect-Oriented Programming，面向切面编程【面向对象一种补充】
- 优势：
- 解决代码分散问题
- 解决代码混乱问题
- 优势：
- OOP：Object-Oriented Programming，面向对象编程
16.4 Spring中AOP相关术语
- 横切关注点：非核心业务代码【日志】，称之为横切关注点
- 切面(Aspect)：将横切关注点提取到类中，这个类称之为切面类
- 通知(Advice)：将横切关注点提取到类中之后，横切关注点更名为：通知（切面类定义的方法）
- 目标(Target)：目标对象，指的是需要被代理的对象【实现类（CalcImpl）】
- 代理(Proxy)：代理对象可以理解为：中介
- 连接点(Joinpoint)：通知方法需要指定通知位置，这个位置称之为：连接点【通知之前】
- 切入点(pointcut)：通知方法需要指定通知位置，这个位置称之为：切入点【通知之后】
第十七章 AspectJ详解【重点】
17.1 AspectJ中切入点表达式
-
语法：@Before(value=“execution(权限修饰符 返回值类型 包名.类名.方法名(参数类型))”)
-
通配符
-
【*】：
-
【*】：可以代表任意权限修饰符&返回值类型
-
【*】：可以代表任意包名、任意类名、任意方法名
-
-
【…】：
- 【…】：代表任意参数类型及参数个数
-
-
重用切入点表达式
-
使用@PointCut注解，提取可重用的切入点表达式
@Pointcut("execution(* com.atguigu.aop.CalcImpl.*(..) )") public void myPointCut(){} -
使用**方法名()**引入切入点表达式
// @Before(value = "execution(public int com.atguigu.aop.CalcImpl.add(int , int ) )") @Before(value = "myPointCut()") public void beforeMethod(JoinPoint joinPoint){}
-
17.2 AspectJ中JoinPoint对象
-
JoinPont【切入点对象】
-
作用：
-
获取方法名称
//获取方法签名【方法签名=方法名+参数列表】 joinPoint.getSignature(); //获取方法名称 String methodName = joinPoint.getSignature().getName(); -
获取参数
Object[] args = joinPoint.getArgs();
-
17.3 AspectJ中通知
-
前置通知
-
语法：@Before
-
执行时机：指定方法执行之前执行【如目标方法中有异常，会执行】
- 指定方法：切入点表达式设置位置
-
示例代码
//重用切入点表达式 @Pointcut("execution(* com.atguigu.aop.CalcImpl.*(..) )") public void myPointCut(){} @Before(value = "myPointCut()") public void beforeMethod(JoinPoint joinPoint){ //获取方法名称 String methodName = joinPoint.getSignature().getName(); //获取参数 Object[] args = joinPoint.getArgs(); System.out.println("==>Calc中"+methodName+"方法(),参数："+ Arrays.toString(args)); }
-
-
后置通知
-
语法：@After
-
执行时机：指定方法所有通知执行之后执行【如目标方法中有异常，会执行】
-
示例代码
/** * 后置通知 */ @After("myPointCut()") public void afterMethod(JoinPoint joinPoint){ //获取方法名称 String methodName = joinPoint.getSignature().getName(); //获取参数 Object[] args = joinPoint.getArgs(); System.out.println("==>Calc中"+methodName+"方法,之后执行!"+Arrays.toString(args)); }
-
-
返回通知
-
语法：@AfterReturnning
-
执行时机：指定方法返回结果时执行，【如目标方法中有异常，不执行】
-
注意事项：@AfterReturnning中returning属性与入参中参数名一致
-
示例代码
/** * 返回通知 */ @AfterReturning(value = "myPointCut()",returning = "rs") public void afterReturnning(JoinPoint joinPoint,Object rs){ //获取方法名称 String methodName = joinPoint.getSignature().getName(); //获取参数 Object[] args = joinPoint.getArgs(); System.out.println("【返回通知】==>Calc中"+methodName+"方法,返回结果执行!结果："+rs); }
-
-
异常通知
-
语法：@AfterThrowing
-
执行时机：指定方法出现异常时执行，【如目标方法中无异常，不执行】
-
注意事项：@AfterThrowing中的throwing属性值与入参参数名一致
-
示例代码：
/** * 异常通知 */ @AfterThrowing(value = "myPointCut()",throwing = "ex") public void afterThrowing(JoinPoint joinPoint,Exception ex){ //获取方法名称 String methodName = joinPoint.getSignature().getName(); //获取参数 Object[] args = joinPoint.getArgs(); System.out.println("【异常通知】==>Calc中"+methodName+"方法,出现异常时执行!异常："+ex); } -
总结
- 有异常：前置通知=》异常通知=》后置通知
- 无异常：前置通知=》返回通知=》后置通知
-
-
环绕通知【前四个通知整合】
-
语法：@Around
-
作用：整合前四个通知
-
注意：
- 参数中必须使用ProceedingJoinPoint
- 环绕通知必须将返回结果，作为返回值
-
示例代码
@Around(value = "myPointCut()") public Object aroundMethod(ProceedingJoinPoint pjp){ //获取方法名称 String methodName = pjp.getSignature().getName(); //获取参数 Object[] args = pjp.getArgs(); //定义返回值 Object rs = null; try { //前置通知 System.out.println("【前置通知】==>Calc中"+methodName+"方法(),参数："+ Arrays.toString(args)); //触发目标对象的目标方法【加减乘除方法】 rs = pjp.proceed(); //返回通知【有异常不执行】 System.out.println("【返回通知】==>Calc中"+methodName+"方法,返回结果执行!结果："+rs); } catch (Throwable throwable) { throwable.printStackTrace(); //异常通知 System.out.println("【异常通知】==>Calc中"+methodName+"方法,出现异常时执行!异常："+throwable); } finally { //后置通知【有异常执行】 System.out.println("【后置通知】==>Calc中"+methodName+"方法,之后执行!"+Arrays.toString(args)); } return rs; }
-
17.4 定义切面优先级
-
语法：@Order(value=index)
- index是int类型，默认值是int可存储的最大值
- 数值越小，优先级越高【一般建议使用正整数】
-
示例代码
// com/atguigu/aop/MyLogging.java @Component @Aspect public class MyLogging{} // com/atguigu/aop/MyValidate.java @Component //将当前类标识为一个组件 @Aspect //将当前类标识为【切面类】【非核心业务提取类】 @Order(1) // 切面的优先级，数越小，优先级越高 public class MyValidate { /** * 添加数据验证功能 */ @Before(value = "com.atguigu.aop.MyLogging.myPointCut()") public void methodBefore(JoinPoint joinPoint){ // 获取方法名 String methodName = joinPoint.getSignature().getName(); // 获取参数 Object[] args = joinPoint.getArgs(); System.out.println("~~~~~~~=============>数据验证切面············"); } }
17.5 基于XML方式配置AOP
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">
<!--配置计算器实现类-->
<bean id="calculator" class="com.atguigu.spring.aop.xml.CalculatorImpl"></bean>
<!--配置切面类-->
<bean id="loggingAspect" class="com.atguigu.spring.aop.xml.LoggingAspect"></bean>
<!--AOP配置-->
<aop:config>
<!--配置切入点表达式-->
<aop:pointcut id="pointCut"
expression="execution(* com.atguigu.spring.aop.xml.Calculator.*(..))"/>
<!--配置切面-->
<aop:aspect ref="loggingAspect">
<!--前置通知-->
<aop:before method="beforeAdvice" pointcut-ref="pointCut"></aop:before>
<!--返回通知-->
<aop:after-returning method="returningAdvice" pointcut-ref="pointCut" returning="result"></aop:after-returning>
<!--异常通知-->
<aop:after-throwing method="throwingAdvice" pointcut-ref="pointCut" throwing="e"></aop:after-throwing>
<!--后置通知-->
<aop:after method="afterAdvice" pointcut-ref="pointCut"></aop:after>
<!--环绕通知-->
<aop:around method="aroundAdvice" pointcut-ref="pointCut"></aop:around>
</aop:aspect>
</aop:config>
</beans>
第十八章 Spring中JdbcTemplate
18.1 JdbcTemplate简介
- Spring提供的JdbcTemplate是一个小型持久化层框架，简化Jdbc代码。
- Mybatis是一个半自动化的ORM持久化层框架
18.2 JdbcTemplate基本使用
-
导入jar包
<!--spring-context--> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>5.3.1</version> </dependency> <!--spring-jdbc--> <!--spring-orm--> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-orm</artifactId> <version>5.3.1</version> </dependency> <!--导入druid的jar包--> <dependency> <groupId>com.alibaba</groupId> <artifactId>druid</artifactId> <version>1.1.10</version> </dependency> <!--导入mysql的jar包--> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>5.1.37</version> </dependency> <!--junit--> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.12</version> <scope>test</scope> </dependency> -
编写配置文件
-
db.properties：设置连接数据库属性
#key=value db.driverClassName=com.mysql.jdbc.Driver db.url=jdbc:mysql://127.0.0.1:3306/db220106 db.username=root db.password=123456 -
applicationContext.xml【spring配置文件】
- 加载外部属性文件
- 装配数据源【DataSources】
- 装配JdbcTemplate
-
示例代码
<!-- 加载外部属性文件--> <context:property-placeholder location="classpath:db.properties"></context:property-placeholder> <!-- - 装配数据源【DataSources】--> <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"> <property name="driverClassName" value="${db.driverClassName}"></property> <property name="url" value="${db.url}"></property> <property name="username" value="${db.username}"></property> <property name="password" value="${db.password}"></property> </bean> <!-- - 装配JdbcTemplate--> <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"> <property name="dataSource" ref="dataSource"></property> </bean>
-
-
使用核心类库【JdbcTemplate】
18.3 JdbcTemplate的常用API
JdbcTemplate默认：自动提交事务
- jdbcTemplate.update(String sql,Object… args)：通用的增删改方法
- jdbcTemplate.batchUpdate(String sql,List<Object[]> args)：通用批处理增删改方法
- jdbcTemplate.queryForObject(String sql,Class clazz,Object… args)：查询单个数值
- String sql = “select count(1) from tbl_xxx”;
- jdbcTemplate.queryForObject(String sql,RowMapper rm,Object… args)：查询单个对象
- String sql = “select col1,col2… from tbl_xxx”;
- jdbcTemplate.query(String sql,RowMapper rm,Obejct… args)：查询多个对象
18.4 使用JdbcTemplate搭建Service&Dao层
-
Service层依赖Dao层
-
Dao层依赖JdbcTemplate
-
示例代码
/** * @author Chunsheng Zhang 尚硅谷 * @create 2022/3/29 16:27 */ @Repository public class DeptDaoImpl implements DeptDao { @Autowired @Qualifier("jdbcTemplate") private JdbcTemplate jdbcTemplate; @Override public List<Dept> selectAllDepts() { String sql = "select dept_id,dept_name from tbl_dept"; RowMapper<Dept> rowMapper = new BeanPropertyRowMapper<>(Dept.class); List<Dept> list = jdbcTemplate.query(sql, rowMapper); return list; } } /** * @author Chunsheng Zhang 尚硅谷 * @create 2022/3/29 16:30 */ @Service("deptService") public class DeptServiceImpl implements DeptService { @Autowired @Qualifier("deptDaoImpl") private DeptDao deptDao; @Override public List<Dept> getAllDepts() { return deptDao.selectAllDepts(); } }
