第一章 初识Spring
1.1 Spring简介
-
Spring是一个为简化企业级开发而生的开源框架。
-
Spring是一个IOC(DI)和AOP容器框架。
-
IOC全称：Inversion of Control【控制反转】
- 将对象【万物皆对象】控制权交个Spring
-
DI全称：(Dependency Injection)：依赖注入
-
AOP全称：Aspect-Oriented Programming，面向切面编程
-
官网：spring.io/
1.2 搭建Spring框架步骤
-
导入jar包
<!--导入spring-context--> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>5.3.1</version> </dependency> <!--导入junit4.12--> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.12</version> <scope>test</scope> </dependency> -
编写核心配置文件
-
配置文件名称：applicationContext.xml【beans.xml或spring.xml】
-
配置文件路径：src/main/resources
-
示例代码
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"> <!-- 将对象装配到IOC容器中--> <bean id="stuZhenzhong" class="com.atguigu.spring.pojo.Student"> <property name="stuId" value="101"></property> <property name="stuName" value="zhenzhong"></property> </bean> </beans>
-
-
使用核心类库
@Test public void testSpring(){ //使用Spring之前 // Student student = new Student(); //使用Spring之后 //创建容器对象 ApplicationContext iocObj = new ClassPathXmlApplicationContext("applicationContext.xml"); //通过容器对象，获取需要对象 Student stuZhenzhong = (Student)iocObj.getBean("stuZhenzhong"); System.out.println("stuZhenzhong = " + stuZhenzhong); }
1.3 Spring特性
- 非侵入式：基于Spring开发的应用中的对象可以不依赖于Spring的API。
- 容器：Spring是一个容器，因为它包含并且管理应用对象的生命周期。
- 组件化：Spring实现了使用简单的组件配置组合成一个复杂的应用。在 Spring 中可以使用XML和Java注解组合这些对象。
- 一站式：在IOC和AOP的基础上可以整合各种企业应用的开源框架和优秀的第三方类库（实际上Spring 自身也提供了表述层的SpringMVC和持久层的JDBCTemplate）。
1.4 Spring中getBean()三种方式
-
getBean(String beanId)：通过beanId获取对象
- 不足：需要强制类型转换，不灵活
-
getBean(Class clazz)：通过Class方式获取对象
-
不足：容器中有多个相同类型bean的时候，会报如下错误：
expected single matching bean but found 2: stuZhenzhong,stuZhouxu
-
-
getBean(String beanId,Clazz clazz)：通过beanId和Class获取对象
- 推荐使用
注意：框架默认都是通过无参构造器，帮助我们创建对象。
所以：如提供对象的构造器时，一定添加无参构造器
1.5 bean标签详解
- 属性
- id：bean的唯一标识
- class：定义bean的类型【class全类名】
- 子标签
- property：为对象中属性赋值【set注入】
- name属性：设置属性名称
- value属性：设置属性数值
- property：为对象中属性赋值【set注入】
第二章 SpringIOC底层实现
IOC：将对象的控制器反转给Spring
2.1 BeanFactory与ApplicationContexet
- BeanFactory：IOC容器的基本实现，是Spring内部的使用接口，是面向Spring本身的，不是提供给开发人员使用的。****
- ApplicationContext：BeanFactory的子接口，提供了更多高级特性。面向Spring的使用者，几乎所有场合都使用ApplicationContext而不是底层的BeanFactory。
2.2 图解IOC类的结构
- BeanFactory：Spring底层IOC实现【面向Spring框架】
- ...
- ApplicationContext：面向程序员
- ConfigurableApplicationContext：提供关闭或刷新容器对象方法
- ...
- ClassPathXmlApplicationContext：基于类路径检索xml文件
- AnnotationConfigApplicationContext：基于注解创建容器对象
- FileSystemXmlApplicationContext：基于文件系统检索xml文件
- ...
- ConfigurableApplicationContext：提供关闭或刷新容器对象方法
- ApplicationContext：面向程序员
- ...
第三章 Spring依赖注入数值问题【重点】
3.1 字面量数值
- 数据类型：基本数据类型及包装类、String
- 语法：value属性或value标签
3.2 CDATA区
- 语法：<![CDATA[]]>
- 作用：在xml中定义特殊字符时，使用CDATA区
3.3 外部已声明bean及级联属性赋值
-
语法：ref
-
注意：级联属性更改数值会影响外部声明bean【ref赋值的是引用】
-
示例代码
<bean id="dept1" class="com.atguigu.pojo.Dept"> <property name="deptId" value="1"></property> <property name="deptName" value="研发部门"></property> </bean> <bean id="empChai" class="com.atguigu.pojo.Employee"> <property name="id" value="101"></property> <property name="lastName" value="chai"></property> <property name="email" value="chai@163.com"></property> <property name="salary" value="50.5"></property> <property name="dept" ref="dept1"></property> <property name="dept.deptName" value="财务部门"></property> </bean>
3.4 内部bean
-
概述
- 内部类：在一个类中完整定义另一个类，当前类称之为内部类
- 内部bean：在一个bean中完整定义另一个bean，当前bean称之为内部bean
-
注意：内部bean不会直接装配到IOC容器中
-
示例代码
<!-- 测试内部bean--> <bean id="empXin" class="com.atguigu.pojo.Employee"> <property name="id" value="102"></property> <property name="lastName" value="xx"></property> <property name="email" value="xx@163.com"></property> <property name="salary" value="51.5"></property> <property name="dept"> <bean class="com.atguigu.pojo.Dept"> <property name="deptId" value="2"></property> <property name="deptName" value="人事部门"></property> </bean> </property> </bean>
3.5 集合
-
List
<!-- 测试集合--> <bean id="dept3" class="com.atguigu.pojo.Dept"> <property name="deptId" value="3"></property> <property name="deptName" value="程序员鼓励师"></property> <property name="empList"> <list> <ref bean="empChai"></ref> <ref bean="empXin"></ref> <!-- <bean></bean>--> </list> </property> </bean> <!-- 测试提取List--> <util:list id="empList"> <ref bean="empChai"></ref> <ref bean="empXin"></ref> </util:list> <bean id="dept4" class="com.atguigu.pojo.Dept"> <property name="deptId" value="4"></property> <property name="deptName" value="运营部门"></property> <property name="empList" ref="empList"></property> </bean> -
Map
<!-- 测试Map--> <bean id="dept5" class="com.atguigu.pojo.Dept"> <property name="deptId" value="5"></property> <property name="deptName" value="采购部门"></property> <property name="empMap"> <map> <entry key="101" value-ref="empChai"></entry> <entry> <key><value>103</value></key> <ref bean="empChai"></ref> </entry> <entry> <key><value>102</value></key> <ref bean="empXin"></ref> </entry> </map> </property> </bean> <util:map id="empMap"> <entry key="101" value-ref="empChai"></entry> <entry> <key><value>103</value></key> <ref bean="empChai"></ref> </entry> <entry> <key><value>102</value></key> <ref bean="empXin"></ref> </entry> </util:map> <bean id="dept6" class="com.atguigu.pojo.Dept"> <property name="deptId" value="106"></property> <property name="deptName" value="后勤部门"></property> <property name="empMap" ref="empMap"></property> </bean>
第四章 Spring依赖注入方式【基于XML】
为属性赋值方式
- 通过xxxset()方法
- 通过构造器
- 反射
4.1 set注入
- 语法：<property>
4.2 构造器注入
- 语法：<constructor-arg>
4.3 p名称空间注入
导入名称空间：xmlns:p="www.springframework.org/schema/p"
-
语法：
-
示例代码
<bean id="stuZhouxu" class="com.atguigu.spring.pojo.Student"> <property name="stuId" value="102"></property> <property name="stuName"> <value><![CDATA[<<zhouxu>>]]></value> </property> </bean> <bean id="stuZhiFeng" class="com.atguigu.spring.pojo.Student"> <constructor-arg name="stuId" value="103"></constructor-arg> <constructor-arg name="stuName" value="zhifeng"></constructor-arg> </bean> <bean id="stuXiaoxi" class="com.atguigu.spring.pojo.Student" p:stuId="104" p:stuName="xiaoxi"></bean>
第五章 Spring管理第三方bean
5.1 Spring管理druid步骤
-
导入jar包
<!--导入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> <!-- <version>8.0.26</version>--> </dependency> -
编写db.properties配置文件
#key=value db.driverClassName=com.mysql.jdbc.Driver db.url=jdbc:mysql://localhost:3306/db220106 db.username=root db.password=root -
编写applicationContext.xml相关代码
<!-- 加载外部属性文件db.properties--> <context:property-placeholder location="classpath:db.properties"></context:property-placeholder> <!-- 装配数据源--> <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> -
测试
@Test public void testDruidDataSource() throws Exception{ //获取容器对象 ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext_druid.xml"); DruidDataSource dataSource = ioc.getBean("dataSource", DruidDataSource.class); System.out.println("dataSource = " + dataSource); DruidPooledConnection connection = dataSource.getConnection(); System.out.println("connection = " + connection); }
第六章 Spring中FactoryBean
6.1 Spring中两种bean
- 一种是普通bean
- 另一种是工厂bean【FactoryBean】
- 作用：如需我们程序员参数到bean的创建时，使用FactoryBean
6.2 FactoryBean使用步骤
- 实现FactoryBean接口
- 重写方法【三个】
- 装配工厂bean
- 测试
package com.atguigu.factory;
import com.atguigu.pojo.Dept;
import org.springframework.beans.factory.FactoryBean;
/**
* @author Chunsheng Zhang 尚硅谷
* @create 2022/3/26 14:09
*/
public class MyFactoryBean implements FactoryBean<Dept> {
/**
* getObject():参数对象创建的方法
* @return
* @throws Exception
*/
@Override
public Dept getObject() throws Exception {
Dept dept = new Dept(101,"研发部门");
//.....
return dept;
}
/**
* 设置参数对象Class
* @return
*/
@Override
public Class<?> getObjectType() {
return Dept.class;
}
/**
* 设置当前对象是否为单例
* @return
*/
@Override
public boolean isSingleton() {
return true;
}
}
第七章 Spring中bean的作用域
7.1 语法
- 在bean标签中添加属性：scope属性即可
7.2 四个作用域
- singleton【默认值】：单例【在容器中只有一个对象】
- 对象创建时机：创建容器对象时，创建对象执行
- prototype：多例【在容器中有多个对象】
- 对象创建时机：getBean()方法被调用时，创建对象执行
- request：请求域
- 当前请求有效，离开请求域失效
- 当前请求：URL不变即为当前请求
- session：会话域
- 当前会话有效，离开当前会话失效
- 当前会话：当前浏览不关闭不更换即为当前会话
第八章 Spring中bean的生命周期
8.1 bean的生命周期
① 通过构造器或工厂方法创建bean实例
② 为bean的属性设置值和对其他bean的引用
③ 调用bean的初始化方法
④ bean可以使用了
⑤ 当容器关闭时，调用bean的销毁方法
8.2 bean的后置处理器
-
作用：在调用初始化方法前后对bean进行额外的处理。
-
实现：
- 实现BeanPostProcessor接口
- 重写方法
- postProcessBeforeInitialization(Object, String)：在bean的初始化之前执行
- postProcessAfterInitialization(Object, String)：在bean的初始化之后执行
- 在容器中装配后置处理器
-
注意：装配后置处理器会为当前容器中每个bean均装配，不能为局部bean装配后置处理器
8.3 添加后置处理器后bean的生命周期
① 通过构造器或工厂方法创建bean实例
② 为bean的属性设置值和对其他bean的引用
postProcessBeforeInitialization(Object, String)：在bean的初始化之前执行
③ 调用bean的初始化方法
postProcessAfterInitialization(Object, String)：在bean的初始化之后执行
④ bean可以使用了
⑤ 当容器关闭时，调用bean的销毁方法
第九章 Spring中自动装配【基于XML】
9.1 Spring中提供两种装配方式
- 手动装配
- 自动装配
9.2 Spring自动装配语法及规则
-
在bean标签中添加属性：Autowire即可
-
byName：对象中属性名称与容器中的beanId进行匹配，如果属性名与beanId数值一致，则自动装配成功
-
byType：对象中属性类型与容器中class进行匹配，如果唯一匹配则自动装配成功
-
匹配0个：未装配
-
匹配多个，会报错
expected single matching bean but found 2: deptDao,deptDao2
-
-
-
注意：基于XML方式的自动装配，只能装配非字面量数值
9.3 总结
- 基于xml自动装配，底层使用set注入
- 最终：不建议使用byName、byType，建议使用注解方式自动装配
第十章 Spring中注解【非常重要】
10.1 使用注解将对象装配到IOC容器中
约定：约束>配置【注解>XML】>代码
位置：在类上面标识
注意：
- Spring本身不区分四个注解【四个注解本质是一样的@Component】，提供四个注解的目的只有一个：提高代码的可读性
- 只用注解装配对象，默认将类名首字母小写作为beanId
- 可以使用value属性，设置beanId；当注解中只使用一个value属性时，value关键字可省略
-
装配对象四个注解
- @Component：装配普通组件到IOC容器
- @Repository：装配持久化层组件到IOC容器
- @Service：装配业务逻辑层组件到IOC容器
- @Controller：装配控制层|表示层组件到IOC容器
-
使用注解步骤
-
导入相关jar包【已导入】
-
开启组件扫描
<!-- 开启组件扫描 base-package：设置扫描注解包名【当前包及其子包】 --> <context:component-scan base-package="com.atguigu"></context:component-scan> -
使用注解标识组件
-
10.2 使用注解装配对象中属性【自动装配】
-
@Autowired注解
-
作用：自动装配对象中属性
-
装配原理：反射机制
-
装配方式
-
先按照byType进行匹配
-
匹配1个：匹配成功，正常使用
-
匹配0个：
-
默认【@Autowired(required=true)】报错
/*expected at least 1 bean which qualifies as autowire candidate. Dependency annotations: {@org.springframework.beans.factory.annotation.Autowired(required=true)} */ -
@Autowired(required=false)，不会报错
-
-
匹配多个
-
再按照byName进行唯一筛选
-
筛选成功【对象中属性名称==beanId】，正常使用
-
筛选失败【对象中属性名称!=beanId】，报如下错误：
//expected single matching bean but found 2: deptDao,deptDao2
-
-
-
-
-
@Autowired中required属性
- true：表示被标识的属性必须装配数值，如未装配，会报错。
- false：表示被标识的属性不必须装配数值，如未装配，不会报错。
-
-
@Qualifier注解
- 作用：配合@Autowired一起使用，将设置beanId名称装配到属性中
- 注意：不能单独使用，需要与@Autowired一起使用
-
@Value注解
- 作用：装配对象中属性【字面量数值】
第十一章 Spring中组件扫描
11.1 默认使用情况
<!-- 开启组件扫描
base-package：设置扫描注解包名【当前包及其子包】
-->
<context:component-scan base-package="com.atguigu"></context:component-scan>
11.2 包含扫描
- 注意：
- 使用包含扫描之前，必须设置use-default-filters="false"【关闭当前包及其子包的扫描】
- type
- annotation：设置被扫描注解的全类名
- assignable：设置被扫描实现类的全类名
<context:component-scan base-package="com.atguigu" use-default-filters="false">
<context:include-filter type="annotation" expression="org.springframework.stereotype.Repository"/>
<context:include-filter type="assignable" expression="com.atguigu.service.impl.DeptServiceImpl"/>
</context:component-scan>
11.3 排除扫描
<!-- 【排除扫描】 假设：环境中共有100包，不想扫描2/100-->
<context:component-scan base-package="com.atguigu">
<context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
<!-- <context:exclude-filter type="assignable" expression="com.atguigu.controller.DeptController"/>-->
</context:component-scan>
第十二章 Spring完全注解开发【0配置】
12.1 完全注解开发步骤
- 创建配置类
- 在class上面添加注解
- @Configuration：标识当前类是一个配置类，作用：代替XML配置文件
- @ComponentScan：设置组件扫描当前包及其子包
- 使用AnnotationConfigApplicationContext容器对象
12.2 示例代码
/**
* @author Chunsheng Zhang 尚硅谷
* @create 2022/3/28 14:05
*/
@Configuration
@ComponentScan(basePackages = "com.atguigu")
public class SpringConfig {
}
@Test
public void test0Xml(){
//创建容器对象
// ApplicationContext context =
// new ClassPathXmlApplicationContext("applicationContext.xml");
//使用AnnotationConfigApplicationContext容器对象
ApplicationContext context =
new AnnotationConfigApplicationContext(SpringConfig.class);
DeptDaoImpl deptDao = context.getBean("deptDao", DeptDaoImpl.class);
System.out.println("deptDao = " + deptDao);
}
第十三章 Spring集成Junit4
13.1 集成步骤
- 导入jar包
- spring-test-5.3.1.jar
- 指定Spring的配置文件的路径
- 【@ContextConfiguration】
- 指定Spring环境下运行Junit4的运行器
- @RunWith
13.2 示例代码
/**
* @author Chunsheng Zhang 尚硅谷
* @create 2022/3/28 14:12
*/
@ContextConfiguration(locations = "classpath:applicationContext.xml")
@RunWith(SpringJUnit4ClassRunner.class)
public class TestSpringJunit4 {
@Autowired
private DeptService deptService;
@Test
public void testService(){
//创建容器对象
// ApplicationContext context =
// new ClassPathXmlApplicationContext("applicationContext.xml");
// DeptService deptService = context.getBean("deptService", DeptServiceImpl.class);
deptService.saveDept(new Dept());
}
}
第十四章 AOP前奏
14.1 代理模式
-
代理模式：我们需要做一件事情，又不期望自己亲力亲为，此时，可以找一个代理【中介】
-
我们【目标对象】与中介【代理对象】不能相互转换，因为是“兄弟”关系
14.2 为什么需要代理【程序中】
-
需求：实现【加减乘除】计算器类
- 在加减乘除方法中，添加日志功能【在计算之前，记录日志。在计算之后，显示结果。】
-
实现后发现问题如下
- 日志代码比较分散，可以提取日志类
- 日志代码比较混乱，日志代码【非核心业务代码】与加减乘除方法【核心业务代码】书写一处
-
总结：在核心业务代码中，需要添加日志功能，但不期望在核心业务代码中书写日志代码。
- 此时：使用代理模式解决问题【先将日志代码横向提取到日志类中，再动态织入回到业务代码中】
14.3 手动实现动态代理环境搭建
-
实现方式
- 基于接口实现动态代理： JDK动态代理
- 基于继承实现动态代理： Cglib、Javassist动态代理
-
实现动态代理关键步骤
- 一个类：Proxy
- 概述：Proxy代理类的基类【类似Object】
- 作用：newProxyInstance()：创建代理对象
- 一个接口：InvocationHandler
- 概述：实现【动态织入效果】关键接口
- 作用：invoke()，执行invoke()实现动态织入效果
- 一个类：Proxy
14.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
15.1 AspectJ框架【AOP框架】
- AspectJ是Java社区里最完整最流行的AOP框架。
- 在Spring2.0以上版本中，可以使用基于AspectJ注解或基于XML配置的AOP。
15.2 使用AspectJ步骤
-
添加jar包支持
<!-- 添加AspectJ --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-aspects</artifactId> <version>5.3.1</version> </dependency> -
配置文件
- 开启组件扫描
- 开启AspectJ注解支持
<!-- 开启组件扫描--> <context:component-scan base-package="com.lyj"></context:component-scan> <!-- 开启AspectJ注解--> <aop:aspectj-autoproxy></aop:aspectj-autoproxy> -
将MyLogging类上面添加注解
- @Component：将当前类标识为一个组件
- @Aspect：将当前类标识为切面类【非核心业务提取类】
-
将MyLogging中的方法中添加通知
- @Before
@Component("calc") public class CalcImpl implements Calc { @Override public int add(int a, int b) { int result = a+b; System.out.println("add正在计算..."); return result; } } @Component //将当前类标识为一个组件 @Aspect //将当前类标识为切面类【非核心业务提取类】 public class MyLogging { @Before(value = "execution(public int com.lyj.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);
int add = calc.add(1,2);
}
15.3 Spring中AOP概述
- AOP：Aspect-Oriented Programming，面向切面编程【面向对象一种补充】
- 优势：
- 解决代码分散问题
- 解决代码混乱问题
- 优势：
- OOP：Object-Oriented Programming，面向对象编程
15.4 Spring中Aop相关术语
- 横切关注点：非核心业务代码，称之为横切观点
- 切面(Aspect)：将横切关注点提取到类中，这个类称之为切面类
- 通知(Advice)：将横切关注点提取到类中之后，横切关注点更名为：通知
- 目标(Target)：目标对象，指的是需要被代理的对象【实现类(CalcImpl)】
- 代理(Proxy)：代理对象可以理解为：中介
- 连接点(JoinPoint)：通知方法需要指定通知位置，这个位置称之为：连接点【通知之前】
- 切入点(pointcut)：通知方法需要指定通知位置，这个位置称之为：切入点【通知之后】
第十六章 AspectJ详解
16.1 spring中切入点表达式
-
语法：@Before(value = "execution(权限修饰符 返回值类型 包名.类名 .方法名(参数类型))")
-
通配符：
【*】：
【*】：可以代表任意权限修饰符&返回值类型
【*】：可以代表任意包名、任意类名、任意方法名
【..】：
【..】：代表任意参数类型及参数个数
-
重用切入点表达式
-
使用@PointCut注解，提取可重用的切入点表达式
@Pointcut("execution(* com.lyj.aop.CalcImpl.*(..))") public void myPoinCut(){} -
使用方法名() 引入切入点表达式
@Before(value = "myPoinCut()") public void beforeMethod(JoinPoint joinPoint){}
-
16.2 AspectJ中JoinPoint对象
-
JoinPont【切入点对象】
-
作用：
-
获取方法名称
//获取方法签名【方法签名 = 方法名+参数列表】 joinPoint.getSignature(); //获取方法名称 String methodName = joinPoint.getSignature().getName(); -
获取参数
Object[] args = joinPoint.getArgs();
-
16.3AspectJ中通知
-
前置通知
-
语法：@Before
-
执行时机：指定方法执行之前执行
- 指定方法：切入点表达式设置位置
-
示例代码
//重用表达式 @Pointcut("execution(* com.lyj.aop.CalcImpl.*(..))") public void myPoinCut(){} @Before(value = "myPoinCut()") public void beforeMethod(JoinPoint joinPoint){ //获取方法名 String methodName = joinPoint.getSignature().getName(); // 获取参数 Object[] args = joinPoint.getArgs(); System.out.println("---->calc中的"+methodName+"方法，参数+"+ Arrays.toString(args)); }
-
-
后置通知
-
语法：@After
-
执行时机：指定方法执行之后执行【如果目标方法中有异常，会执行】
-
示例代码
@Before(value = "myPoinCut()") public void beforeMethod(JoinPoint joinPoint){ //获取方法名 String methodName = joinPoint.getSignature().getName(); // 获取参数 Object[] args = joinPoint.getArgs(); System.out.println("---->calc中的"+methodName+"方法，参数+"+ Arrays.toString(args)); }
-
-
返回通知
-
语法：@AfterReturning
-
执行时机：指定方法返回结果时执行【如果目标方法中有异常，不执行】
-
注意事项：@AfterReturning中returning属性与入参中的参数名一致
-
示例代码
/* * 返回通知 * */ @AfterReturning(value = "myPoinCut()",returning = "rs") public void afterReturning(JoinPoint joinPoint , Object rs){ String methodName = joinPoint.getSignature().getName(); // 获取参数 Object[] args = joinPoint.getArgs(); System.out.println("返回---->calc中的"+methodName+"方法,返回执行结果"+ rs); }
-
-
异常通知
-
语法：@AfterThrowing
-
执行时机：指定方法出现异常时执行【如果目标方法中无异常，不执行】
-
注意事项：@AfterThrowing中throwing属性与入参中的参数名一致
-
示例代码
/* * 异常通知 * */ @AfterThrowing(value = "myPoinCut()",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 = "myPoinCut()") 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; }
-
16.4 定义切面优先级
-
语法：@Order(value = index)
-
index是int类型，默认值是int可存储的最大值
-
数值越小，优先级越高
-
示例代码
@Component @Aspect @Order(Value = 1) public class MyValidate{} @Component @Aspect @Order(Value = 1) public class MyLogging{}
16.5 基于XML方式配置AOP
-
第十七章 Spring中JdbcTemplate
17.1 JdbcTemplate简介
- Spring提供的JdbcTemplate是一个小型持久化层框架，简化jdbc代码。
- Mybatis是一个半自动化的ORM持久化层架构
17.2 JdbcTemplate基本使用
-
导入jar包
-
编写配置文件
-
db.properties:设置连接数据库
-
applicationContext.xml【spring配置文件】
- 加载外部属性文件
- 装配数据源【DataSources】
- 装配 JdbcTemplate
-
示例代码
<!-- 加载外部属性文件--> <context:property-placeholder location="classpath:db.properties"></context:property-placeholder> <!--装配数据源【DateSources】--> <bean id="dataSourece" class="com.alibaba.druid.pool.DruidDataSource"> <property name="driverClassName" value="${db.driver}"></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="dataSourece"></property> </bean>
-
-
使用核心类库【 JdbcTemplate】
17.3JdbcTemplate的常用API
- 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 tabl_xxx";
- jdbcTemplate.queryForObject(String sql,RowMapper rm,Object...args):查询单个对象
- String sql = "select col1,col2....from tbl_xxx";
- jdbcTemplate.query(String sql,RowMapper rm,Object...args):查询多个对象
17.4 使用JdbcTemplate搭建Dao层
- Service层依赖Dao层
- Dao层依赖JdbcTemplate
- 示例代码
@Repository
public class UserDaoImpl implements UserDao {
@Autowired
private JdbcTemplate jdbcTemplate;
@Override
public int addOne(UserEntity userEntity) {
String sql = "INSERT INTO user_db (user_id, user_name, user_age) VALUES(?, ?, ?);";
int update = jdbcTemplate.update(sql, userEntity.getUserId(), userEntity.getUserName(), userEntity.getUserAge());
return update;
}
}
@Override
public String findNameById(int i) {
String str = "SELECT ud .user_name from user_db ud where ud.user_id =?";
// 1.sql 2.返回类型的Class
String s = jdbcTemplate.queryForObject(str, String.class, i);
return s;
}
@Override
public UserEntity findUserById(int i) {
String sql = "SELECT * from user_db ud where ud.user_id =?";
/**
* 第二个参数 ：RowMapper 是一个接口，返回不同类型的数据。
* 使用这个接口的实现类完成数据的封装。
*/
UserEntity userEntity =
jdbcTemplate.queryForObject(
sql,
new BeanPropertyRowMapper<UserEntity>(UserEntity.class),
i);
return userEntity;
}
@Override
public List<UserEntity> queryAllUser() {
String sql = "SELECT * from user_db";
List<UserEntity> query =
jdbcTemplate.query(
sql,
new BeanPropertyRowMapper<UserEntity>(UserEntity.class));
return query;
}
@Override
public int[] batchAdd() {
ArrayList<Object[]> list = new ArrayList<>();
list.add(new Object[]{"3", "张4", 19});
list.add(new Object[]{"4", "张5", 19});
list.add(new Object[]{"5", "张6", 19});
int[] ints = userDao.batchAdd(list);
return ints;
}
@Override
public int[] batchAdd(List list) {
String sql = "INSERT INTO user_db (user_id, user_name, user_age) VALUES(?, ?, ?);";
int[] ints = jdbcTemplate.batchUpdate(sql, list);
return ints;
}
@Override
public int[] batchUpdate() {
ArrayList<Object[]> list = new ArrayList<>();
list.add(new Object[]{120, "3"});
list.add(new Object[]{190, "4"});
list.add(new Object[]{190, "5"});
int[] ints = userDao.batchUpdate(list);
return ints;
}
@Override
public int[] batchUpdate(ArrayList<Object[]> list) {
String sql = "UPDATE user_db ud set ud.user_age = ? where ud.user_id = ?";
int[] ints = jdbcTemplate.batchUpdate(sql, list);
return ints;
}
第十八章 Spring声明式事务管理
回顾事务
1.事务四大特征【ACID】
原子性 - 一致性 - 隔离性 - 持久性
- 事务的三种行为
- 开启事务：connection.setAutoCommit(false)
- 提交事务：connection.commit()
- 回滚事务：connection.rollback()
18.1 Spring中支持事务管理
-
编程式事务管理【传统事务管理】
-
获取数据库连接Connection对象
-
取消事务的自动提交【开启事务】
-
执行操作
-
正常完成操作时手动提交事务
-
执行失败时回滚事务
-
关闭相关资源
不足：
- 事务管理代码【非核心业务】与核心业务代码相耦合
- 事务管理代码分散
- 事务管理代码混乱
- 事务管理代码【非核心业务】与核心业务代码相耦合
-
-
声明式事务管理【使用AOP管理事务】
- 先横向提取【事务管理代码】，在动态织入
18.2 使用声明式事务管理
不用事务管理代码，发现：同一个业务中，会出现局部成功及局部失败的现象【不正常】
使用步骤：
-
添加支持【Aspect J的jar包】
<dependency> <groupId>org.springframework</groupId> <artifactId>spring-aspects</artifactId> <version>5.3.1</version> </dependency> -
编写配置文件
- 配置事务管理器
- 开启事务注解支持
<!-- 装配事务管理器--> <bean id ="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> <property name="dataSource" ref="dataSourece"></property> </bean> <!-- 开启事务管理器 默认值： transaction-manager="transactionManager" --> <tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven> -
在需要事务管理的业务方法上，添加注解**@Transactional**
@Transactional public void purchase(String username,String isbn){ //查询book价格 Integer price = bookShopDao.findBookPriceByIsbn(isbn); //修改库存 bookShopDao.updateBookStock(isbn); //修改余额 bookShopDao.updateUserAccount(username,price); } -
总结：
- 添加声明式事务管理之后，获取是代理对象，代理对象不能转换为目标对象【实现类】
18.3 Spring声明式事务管理属性
@Transactional注解属性
-
事务传播行为
-
当事务方法被另一个事务方法调用时，必须指定事务应该如何传播。
- 如：执行事务方法method1()【事务x】之后，调用事务方法method2()【事务y】,此时需要设置method2()方法的事务传播行为。
-
Spring的7中传播行为。
传播属性 描述 REQUIRED 如果有事务在运行，当前的方法就在这个事务内运行;否则就启动一个新的事务，并在自己的事务内运行。 REQUIRES_NEW 当前的方法必须启动新事务，并在自己的事务内运行;如果有事务正在运行，应该将它挂起。 SUPPORTS 如果有事务在运行，当前的方法就在这个事务内运行，否则可以不运行在事务中。 NOT_SUPPORTED 当前的方法不应该运行在事务中，如果有运行的事务将它挂起 MANDATORY 当前的方法必须启动新事务，并在自己的事务内运行;如果有事务正在运行，应该将它挂起。
如果有事务在运行，当前的方法就在这个事务内运行，否则可以不运行在事务中。
当前的方法不应该运行在事务中，如果有运行的事务将它挂起
当前的方法必须运行在事务中，如果没有正在运行的事务就抛出异常。当前的方法不应该运行在事务中，如果有正在运行的事务就抛出异常。
如果有事务正在运行，当前的方法就应该在这个事务的嵌套事务内运行，否则就启动一个新的事务，并在它自己的事务内运行。NEVER 当前的方法必须运行在事务中，如果没有正在运行的事务就抛出异常。当前的方法不应该运行在事务中，如果有正在运行的事务就抛出异常。 NESTED 如果有事务正在运行，当前的方法就应该在这个事务的嵌套事务内运行，否则就启动一个新的事务，并在它自己的事务内运行。 -
图解事务传播行为
-
REQUIRED
-
-
* REQUIRES_NEW
* 使用场景
```java
/*
1.去结账时判断余额是否充足，余额不足：一本书都不能买
*/
@Transactional(propagation = Propagation.REQUIRED)
public void purchase(String username,String isbn){
//查询book价格
Integer price = bookShopDao.findBookPriceByIsbn(isbn);
//修改库存
bookShopDao.updateBookStock(isbn);
//修改余额
bookShopDao.updateUserAccount(username,price);
}
/*
2.去结账时判断余额是否充足，余额不足：最后导致余额不足的那本书，不让购买。
*/
@Transactional(propagation = Propagation.REQUIRES_NEW)
public void purchase(String username,String isbn){
//查询book价格
Integer price = bookShopDao.findBookPriceByIsbn(isbn);
//修改库存
bookShopDao.updateBookStock(isbn);
//修改余额
bookShopDao.updateUserAccount(username,price);
}
```
-
事务隔离级别
-
隔离级别概述：—个事务与其他事务之间的隔离等级【1,2,4,8】
-
隔离等级
- 读未提交【1】: READ UNCOMMITTED
- 存在问题：脏读【读取到了未提交数据】
- 读已提交【2】: READ COMMITTED
- 存在问题：可能出现不可重复读
- 可重复读【4】: REPEATABLE READ
- 存在问题：可能出现幻读
- 串行化【8】: SERIALIZABLE
- 读未提交【1】: READ UNCOMMITTED
-
各种数据库产品对事物隔离级别的支持程度
Oracle MySQL READ UNCOMMITTED × √ READ COMMITTED √（默认） √ REPEATABLE READ × √（默认） SERIALIZABLE √ √
-
-
事务超时
- 由于事务可以在行和表上获得锁，因此长事务会占用资源，并对整体性能产生影响。
- 设置事务超时时间，到达指定时间后会强制事务回滚
- 类型：int 单位：秒
- 默认值：-1【未设置强制回滚时间】
-
事务只读
- 一般事务方法中只有查询操作时，才将事务设置为只读。
- 默认值：false
-
事务回滚【不回滚】
- rollbackFor：设置回滚的异常Class
- noRollbackFor：设置不回滚的异常Class
18.4 基于XML方式，配置声明式事务管理【了解】
<!-- 配置事务切面 -->
<aop:config>
<aop:pointcut
expression="execution(* com.atguigu.tx.component.service.BookShopServiceImpl.purchase(..))"
id="txPointCut"/>
<!-- 将切入点表达式和事务属性配置关联到一起 -->
<aop:advisor advice-ref="myTx" pointcut-ref="txPointCut"/>
</aop:config>
<!-- 配置基于 XML 的声明式事务 -->
<tx:advice id="myTx" transaction-manager="transactionManager">
<tx:attributes>
<!-- 设置具体方法的事务属性 -->
<tx:method name="find*" read-only="true"/>
<tx:method name="get*" read-only="true"/>
<tx:method name="purchase"
isolation="READ_COMMITTED" no-rollback-for="java.lang.ArithmeticException,java.lang.NullPointerException" propagation="REQUIRES_NEW" read-only="false"
timeout="10"/>
</tx:attributes>
</tx:advice>
第十九章 Spring5新特性
19.1 添加新注解【了解】
| 名称 | 含义 | 可标记位置 |
|---|---|---|
| @Nullable | 可以为空 | @Target({ElementType METHOD ,ElementType PARAMETER,ElementType FIELD}) |
| @NonNull | 不应为空 | @Target({ElementType METHOD ,ElementType PARAMETER,ElementType FIELD}) |
| @NonNullFields | 在特定包下的字段不应为空 | @Target(ElementType PACKAGE) @TypeQualifierDefault(ElementType FIELD) |
| @NonNullApi | 参数和返回值不应为空 | @Target(ElementType PACKAGE) @TypeQualifierDefault({ElementType METHOD,ElementType PARAMETER}) |
- @Nullable作用
- 位置：可以书写在方法&属性上面&参数前面
- 作用：表示当前方法或属性可以为空，当前属性为空时，消除空指针异常。
19.2 Spring整合Log4j2
-
导入jar包
<dependency> <groupId>org.apache.logging.log4j</groupId> <artifactId>log4j-slf4j-impl</artifactId> <version>2.11.2</version> <scope>test</scope> </dependency> -
编写配置文件
- 文件名：log4j2.xml
<?xml version="1.0" encoding="UTF-8"?> <!--日志级别以及优先级排序: OFF > FATAL > ERROR > WARN > INFO > DEBUG > TRACE > ALL --> <configuration status="WARN" monitorInterval="30"> <!--先定义所有的appender--> <appenders> <!--这个输出控制台的配置--> <console name="Console" target="SYSTEM_OUT"> <!--输出日志的格式--> <PatternLayout pattern="[%d{HH:mm:ss:SSS}] [%p] - %l - %m%n"/> </console> </appenders> <!--然后定义logger，只有定义了logger并引入的appender，appender才会生效--> <loggers> <root level="all"> <appender-ref ref="Console"/> </root> </loggers> </configuration>
19.3 Spring整合Junit5
-
导入jar包【注意：将Junit4的jar包删除】
<dependency> <groupId>org.junit.jupiter</groupId> <artifactId>junit-jupiter-api</artifactId> <version>5.7.2</version> <scope>test</scope> </dependency> -
使用注解整合即可
-
方式一
@ContextConfiguration(locations = "classpath:applicationContext.xml") @ExtendWith(SpringExtension.class) public class TestJunit5 {} -
方式二
//简化注解，复合注解 @SpringJUnitConfig(classes = TxConfig.class) public class TestJunit5 { @Test public void test() { System.out.println("123"); } } -
