记录自己的Spring学习的笔记，学习课程是通过B站尚硅谷的视频学习。
@Description Spring5学习
@author Van
①Spring5框架
1、内容
1.Spring概念
2.IOC容器
3.AOP
4.JdbcTemplate
5.事务管理
6.Spring5新特性
②spring5框架概述
1、Spring是轻量级的开源的JavaEE的框架
2、Spring可以解决企业应用开发的复杂性
3、Spring有两个核心部分：IOC和AOP
1.IOC：控制反转，把创建对象过程交给spring进行管理
2.Aop：面向切面，不修改源代码的情况下进行功能增强或功能开发
4、Spring特点：
1.方便解耦，简化开发
2.Aop编程支持
3.方便程序的测试
4.方便继承各种优秀框架
5.降低JavaEE API的开发难度（比如对JDBC进行封装）
6.方便进行事务操作
7.spring是java开发的一种规范。
5、选取spring 5.x
6、入门案例
1、创建priject等，然后导入jar包
1.导入beans、context、core、expression、commons-logging5个jar包
最后一个不是ioc的jar包，是一个日志jar包不导入会报错
2、创建一个User类，并且有一个普通的方法
3、创建spring配置文件，再配置文件配置创建的对象
1.spring配置文件使用xml文件格式
src下new xml->spring config
4、测试代码编写
//1 加载Spring的配置文件
ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
//2 获取配置创建的对象
User user = context.getBean("user", User.class);
System.out.println(user);
user.add();
③IOC容器
1、IOC底层原理
1.什么是IOC
IOC-Inversion of Control,控制反转，用来降低代码之间的耦合度
1.控制反转，把对象创建和对象之间的调用过程，交给Spring进行管理
2.使用IOC目的：为了降低耦合度
3.入门案例就是IOC的实现
2.IOC的底层原理
1.xml解析、工厂模式、反射
工厂模式：
例如：UserService和UserDao两个类需要相互调用就要在一个类里面创建另一个的对象，耦合度太高
工厂模式创建一个类来专门创建对象，有一个方法来返回创建对象
将两个类的高耦合度转移到了工厂类身上，降低了两个类之间的耦合度
2.IOC过程
1.xml配置文件，配置创建的对象
2.有service类和dao类：创建工厂类
class UserFactory{
public static UserDao getDao(){
//1. xml解析
String classValue = class属性值;
//2.通过反射创建对象
Class clazz = Class.forName(classValue);
return (UserDao)clazz.newInstance();
}
}
可以进一步的降低耦合程度
2、IOC接口(BeanFactory)
1.IOC思想基于IOC容器完成，IOC容器底层就是对象工厂
2.Spring提供IOC容器实现的两种方式：（两个接口）
1.BeanFactory：
a.IOC容器基本实现，Spring内部的使用接口，一般不提供给开发人员使用
b.加载配置文件的时候不回创建对象，在获取或使用的时候才会创建对象
2.ApplicationContext
a.BeanFactory接口的子接口，提供了更多更强大的功能，一般面向开发人员
b.在加载配置文件的时候就会把配置文件中的对象进行创建
3.ApplicationContext实现类--2个
1.FileSystemXmlApplicationContext
ApplicationContext context = new FileSystemXmlApplicationContext("xxx")
xxx是xml配置文件在系统盘符中的位置---绝对路径
2.ClassPathXmlApplicationContext
ApplicationContext context = new ClassPathXmlApplicationContext("xxx")
xxx是xml配置文件在src下的位置---相对路径
3、IOC操作 Bean 管理(基于XML)
1.什么是Bean管理：
--指的是下面两个操作
a.Spring创建对象
b.Spring注入属性
2.Bean管理的操作
a.Spring基于XML创建对象
（1）在spring配置文件中，使用bean标签，实现对象创建
（2）bean标签常用属性：
id属性 ：唯一标识
class属性 ：类的全路径（包类路径）
name属性 ：和id一样，可以加特殊符号
（3） 创建对象时默认也是执行无参构造方法完成对象创建
b.Spring基于XML注入属性
（1） DI：依赖注入，就是注入属性
面试：IOC和DI有什么区别
DI是IOC中的具体实现，就是依赖注入或者是注入属性
（2）注入有支持以下两种方式注入属性
第一种：使用set方法注入属性
1.定义类中属性和set方法
2.在spring配置文件配置对象创建，配置属性注入
第二种：使用有参构造方法注入属性
1.定义类中属性和有参构造方法
2.在spring配置文件配置对象创建，配置属性注入
c.p名称空间注入
（1） 通过xml使用set和有参构造注入太麻烦，衍生简化出p名称空间注入
（2） 实际操作
1.在顶部加一个属性
xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="http://www.springframework.org/schema/p"
加了第三个这个属性
2.进行属性注入
（3） 底层是在set的基础上操作
d.xml注入其他类型属性
（1）字面量：
1.null值
2.属性值包含特殊符号
>]]>
e.xml注入外部bean
（1）例子：
1.创建两个类service类和dao类
2.在service调用dao里面的方法
3.在spring配置文件中进行配置
f.xml注入内部bean和级联赋值
（1）一对多关系：部门和员工
（2）在实体类之间表示一对多关系，员工属于某一个部门，使用对象形式表示
g.xml注入集合属性
（1）注入数组类型属性
（2）注入List集合类型属性
（3）注入Map集合类型属性
操作：
1.创建一个普通类，定义好这些需要注入的类型属性
2.在spring配置文件中进行配置
特殊情况：
1.在集合中需要注入对象类型值
下面创建好多个course对象 上面引入就可以
2.把集合注入部分提取出来，作为公共部分，让其他对象也能使用
1.在spring配置文件中引入名称空间util
xmlns:util="http://www.springframework.org/schema/util"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">
2.提取list集合类型属性注入
4、IOC操作 Bean 管理（工厂Bean）——FactoryBean
1.Spring有两种类型bean，一种是普通bean，另外一种是工厂bean(FactoryBean)
a.普通bean：在xml配置中class引入的类返回的就是对应类的对象
b.工厂bean：在xml配置中class引入的类返回的可以是其他的对象
1.创建一个类，让这个类作为工厂bean，实现接口FactoryBean
2.实现接口里面的方法，在实现的方法中定义返回的bean类型
//定义返回bean
@Override
public Course getObject() throws Exception {
Course course = new Course();
course.setCname("maoamo");
return course;
}
Factorybean可以简化普通bean实例化很复杂的情况
5、IOC操作 Bean 管理（Bean的作用域）
1.在Spring里面，可以设置创建bean实例是单实例还是多实例
2.在Spring里面，默认情况下，bean是一个单实例对象
a.创建两个对象，如果地址一样就是单实例对象，不一样就是多实例对象
3.设置单例还是多实例
a.在spring配置文件bean标签中有 scope 用于设置单实例还是多实例
b.scope有两个值：
singleton：表示单实例对象
加载spring配置文件时候就会创建这个单实例对象
标记为拥有singleton的对象定义，在Spring的IOC容器中只存在一个实例，所有对该对象的引用将共享这个实例。该实例从容器启动，并因为第一次请求而初始化之后，将一直存活到容器退出。
prototype：表示多实施对象
加载spring配置文件时候不会创建对象，在调用getBean方法时才会创建多实例对象
拥有prototype的bean定义，容器在接到该类型对象的请求的时候，会每次都重新生成一个新的对象实例给请求方，
虽然这种类型的对象的实例化以及属性设置等工作都是由容器负责的，但是只要准备完毕，并且对象实例返回给请求方之后，容器就不在拥有当前返回对象的引用
c.还有两个值：几乎不用
request:创建的对象会放到request域中
session:创建的对象会放到session域中
6、IOC操作 Bean 管理（Bean的生命周期）---面试重点
1.bean生命周期
（1）通过构造器创建bean实例(无参数构造)或者工厂方法
（2）为bean的属性设置值和对其他bean引用(调用set方法)
（3）调用bean的初始化的方法(需要进行配置)
（4）bean可以使用了(对象获取到了)
（5）当容器关闭的时候，调用bean的销毁的方法(需要进行配置销毁的方法)
需要手动关闭容器销毁 context.close()
（6）关闭容器 ---这个课程中没有讲 正常应该是到5结束
2.bean的后置处理器
（1）加上后置处理器后，bean生命周期有七步，不加就是五步
（2）在初始化之前，把bean实例传递到bean的后置处理器的方法
（3）在初始化之后，也会把把bean实例传递到bean的后置处理器的另一个方法
1.创建一个类，实现接口BeanPostProcessor，创建后置处理器
2.在初始化之前会执行接口下的postProcessBeforeInitialization()方法
3.在初始化之后会执行接口下的postProcessAfterInitialization()方法
为了能让spring知道是bean后置处理器，需要在xml配置文件中配置
因为类实现了接口，所以spring能直接识别出是后置处理器
7、IOC操作 Bean 管理（XML自动装配）、
1.什么是自动装配
（1）根据指定装配规则（属性名或者属性类型），Spring自动将匹配的属性值注入
2.操作过程
8、IOC操作 Bean 管理(外部属性文件)
1.直接配置数据库信息
（1）配置Druid连接池
（2）引入外部属性文件配置数据库连接池
1.创建外部属性文件，properties格式文件，写数据库配置信息
prop.driverClass=com.mysql.cj.jdbc.Driver
prop.url=jdbc:mysql://localhost:3306/test
prop.userName=root
password=123456
2.把外部properties属性文件引入到spring配置文件中
a.引入context名称空间
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
b. 在xml中使用名称空间引入属性配置文件
c.引入之后配置druid数据库连接池
个人思考：优势不需要再去做繁琐的读取properties文件来获得数据库配置，直接获取对象就可以得到值
9、IOC操作 Bean 管理(基于注解)
1.什么是注解
（1）注解是代码特殊标记，格式：@注解名称(属性名称=属性值,属性名称=属性值...)
（2）注解作用在类、方法、属性上面
（3）使用注解的目的：简化xml配置
2.SPring针对Bean管理中创建对象提供注解
（1）@Component:普通注解，一般可以直接创建对象
（2）@Service：一般用在业务逻辑层或者service层上
（3）@Controller：一般用在web层上
（4）@Repository：一般用在Dao层或持久层上
上面4个注解功能是一样的，都可以用来创建bean实例，为了方便开发人员清晰当前组件结构位置
3.基于注解方式实现对象创建
（1）第一步 引入依赖
引入spring5下lib中的spring-aop-```.jar
aopjar包中继承了注解的一些东西
（2）第二步 开启组件扫描
使用组件需要开启组件扫描
1.首先要创建context命名空间
和上面的创建context命名空间一样
2.开启组件扫描
（3）第三步 创建UserService测试类，在类上面添加创建对象注解
//在注解里面value属性值可以省略，默认是类名搜字母小写
@Component(value = "userService") //等同于
在类上方添加这个注解，就能创建对象了
获取配置文件，直接getBean就可以得到对象了
4.开启组件扫描细节配置
5.基于注解方式实现属性注入
（1）@AutoWired
根据属性类型进行自动装配（注入）
1.第一步 把service和dao对象创建，再service和dao类添加注解创建对象
2.在service中注入dao对象，在service类添加dao类属性，在属性上使用注解
//定义dao类型属性
//不需要添加set方法
//添加注入属性注解
@Autowired
private UserDao userDao;
（2）@Qualifier
根据属性名称进行注入
@Qualifier和@AutoWired一起使用
如autowire的例子，有多个dao的实现用@Repository(value="x1")和@Qualifier(value="x1")识别搭配使用
（3）@Resource
可以根据类型注入，也可以根据名称注入
如果直接使用@Resource就是根据类型注入
如果使用@Resource(name="x1") 就是根据名称注入
这个Resource本身不是spring包中的 是javax中的注解
官方更建议使用上面两个，不推荐使用Resource
-----------上面这三个都是针对对象类型------------
（4）@value
注入普通类型属性
@Value(value = "abc")
private String name;
就是把 abc注入到那么属性中 ---> this.name = "abc"
这个和直接赋值的优势在于可以value="${}"读取配置文件中的值
6.IOC操作 Bean 管理(完全注解开发)
（1）创建配置类，替代xml配置文件
@Configuration //作为配置类，替代xml配置文件
@ComponentScan(basePackages = {"com.van.spring5"})//代替开启扫描
public class SpringConfig {
}
这个操作一般用SpringBoot操作，SB本质上就是完全注解开发
④AOP面向切面编程
1、概念
1.AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
2.不修改原代码的情况下增加新的功能
2、原理
1.AOP使用动态代理
1.有接口的情况，使用jdk动态代理
a.创建接口实现类代理对象，通过代理对象去实现对接口的功能增强
b.使用jdk动态代理，使用Proxy类里面的方法创建，Proxy类在java.lang包中
(1).调用Proxy类中的newProxyInstance(ClassLoader loader,类[] interface,InvocationHandler h )方法：返回指定接口的代理类的实例
第一个参数：类加载器
第二个参数：增强方法所在的类，这个类实现的接口，支持多个接口
第三个参数：实现接口InvocationHandler，创建代理对象，写增强方法
(2).JDK动态代理的代码实现
1.创建接口，定义方法
2.创建接口实现类，实现定义方法
3.使用Proxy类创建接口代理对象
public class JDKProxy{
Class[] interfaces = {UserDao.class};
UserDao UserDao = new UserDaoImpl();
UserDao dao = (com.van.aopdemo.UserDao) Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new UserDaoProxy(UserDao));
int result = dao.add(1, 2);
System.out.println(result);
}
//创建代理对象代码
class UserDaoProxy implements InvocationHandler{
//1.把被代理的对象传进来，可以理解成需要增强谁就传谁进来
//通过有参构造传递
private Object obj;
public UserDaoProxy(Object obj){
this.obj = obj;
}
//增强逻辑
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//被增强方法执行之前
System.out.println("before function run!" + method.getName() + "传递的参数" + Arrays.toString(args));
//被增强方法执行
Object res = method.invoke(obj, args);
//被增强方法执行之后
System.out.println("after function run!" + obj);
return res;
}
}
2.没有接口的情况，使用CGLIB动态代理
a.创建当前类子类的代理对象，通过代理对象去实现对接口的功能增强
2.AOP术语
1.连接点：类里面哪些方法可以被增强，这些方法称为连接点
2.切入点：实际真正被增强的方法，被称为切入点
3.通知(增强)：
a.实际增强的逻辑部分，被称为通知
b.通知有多种类型：
*前置通知
*后置通知
*环绕通知
*异常通知
*最终通知
4.切面：把通知应用到切入点的过程，是一个动作。
3、AOP操作(准备)
1.Spring框架一般都是基于AspectJ实现AOP操作
1.什么是AspectJ
*AspectJ不是Spring组成部分，独立的AOP框架，一般把AspectJ和Spring框架一起使用，进行AOP操作
2.基于AspectJ实现AOP操作
a.基于XML配置文件实现
b.基于注解方式实现(实际使用)
3.在项目工程里面引入AOP相关依赖（jar）
4.切入点表达式
a.切入点表达式的作用：知道要对哪个类里面的哪个方法进行增强
b.语法结构：
Execution([权限修饰符(可省略)][返回类型][类全路径][方法名称]([参数列表]))
例：对com.atguigu.aopdemo.UserDaoImpl里面的add方法进行增强
/
Integer count = jdbcTemplate.queryForObject(sql, Integer.class);
return count;
}
5.JdbcTemplate操作数据库(查询数据返回对象)
1.和查询返回值有点相似
(1)在Dao和DaoImpl中创建selectCount()方法
(2)在BookService中用bookService调用Dao中的方法
(3)在DaoImpl的findBookInfo()中实现具体查询方法逻辑
public Book findBookInfo(int id) {
String sql = "select * from t_book where user_id = ?";
Book book = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper
return book;
}
6.JdbcTemplate操作数据库(查询数据返回集合)
1.和查询返回值有点相似
(1)在Dao和DaoImpl中创建selectCount()方法
(2)在BookService中用bookService调用Dao中的方法
(3)在DaoImpl的findBookInfo()中实现具体查询方法逻辑
public List
String sql = "select * from t_book";
List
return books;
}
7.JdbcTemplate操作数据库(批量操作)
1.批量操作：操作表里面的多条记录
2.JdbcTemplate实现批量添加操作
//jdbcTemplate.batchUpdate(String sql,List
//在输入的时候会创建List
//测试调用插入的List
List
Object[] o1 = {"","",""}
batchArgs.add(o1);
//DaoImpl中的批量插入
String sql = "insert into t_book values(?,?,?)";
int[] ints = jdbcTemplate.batchUpdate(sql,batchArgs);
3.JdbcTemplate实现批量修改操作
(1)同批量添加一样，只不过sql语句变了
4.JdbcTemplate实现批量修改操作
(1)同批量添加一样，只不过sql语句变了
⑥事务
1.概念
1.什么是事务
(1)事务是数据库操作最基本的单元，逻辑上是一组操作，要么都成功，要么都不成功。
(2)典型场景：银行转账
2.事务的四个特性：
ACID：
1.原子性：不可分割，要么都成功，要么都不成功。
2.一致性：事务提交前后的数据完整性和状态保持一致。理解：操作之前和操作之后的总量是不变的。
3.隔离性：多事务操作时不会相互产生影响，例如两个事务同时操作一条记录不会相会影响
4.持久性：事务提交后，表中数据真正发生变化
2.事务操作(搭建事务操作环境)
1.在service层进行业务调度，在dao层访问数据库进行数据操作
在service调用两个dao的方法
dao层有一个多钱和一个少钱的方法
2.创建service和dao，完成对象创建和注入关系
1.在service注入dao，在dao注入Jdbctamplate对象，在Jdbctamplate注入datasource
3.在dao创建两个方法，一个多钱一个少钱，在service创建一个转账方法
1.事务操作过程:
1.开启事务操作
2.进行业务操作，出现异常会有其他操作
3.没有异常，提交事务
4.出现异常，事务回滚，回滚到一开始的状态
3.事务操作(Spring事务管理介绍)
1.事务添加到JavaEE三层结构中的service层(业务逻辑层)
2.在Spring里面进行事务管理操作
1.有两种方式：编程式事务管理和声明式事务管理，实际操作中一般使用声明式事务管理
2.编程式事务管理：通过写代码实现
3.声明式事务管理：
1.基于注解方式
2.基于xml配置文件方式
3.在Spring进行声明式事务管理，底层使用AOP原理
4.Spring事务管理API
1.提供了一个接口，代表事务管理器
PlatformTransactionManager接口：
1.DataSourceTransactionManager类：用于jdbc模板和mybatis等的使用
2.HibernateTransactionManager类：主要用于hibernate的使用
5.事务操作(注解声明式事务管理)
1.在Spring配置文件中配置事务管理器
2.在Spring配置文件中开启事务注解
1.在Spring配置文件中引入名称空间tx
2.开启事务的注解
3.在service类(或service类里面的方法上面)添加事务注解
@Transactional:可以添加要类上也可以添加到方法上
如果添加到service类上代表这个类中所有方法都添加了事务
如果添加到方法上代表只有这个方法添加了事务
6.事务操作(声明式事务管理参数配置)
1.在service类上面添加注解@transactional，在这个注解里面可以配置事务相关参数
1.propagation：事务传播行为
(1):多事务方法直接进行调用，这个过程中事务是如何进行管理的
(2):事务方法：对数据库表数据进行变化的操作
(3)一有7种行为：
1.required：如果有事务在运行，当前的方法就在这个事务内运行，否则，就启动一个新的事务，并在自己的事务内运行
2.REQUIRED_NEW：当前的方法必须启动新事务，并在它自己的事务内运行．如果有事务正在运行，应该将它挂起
3.SUPPORTS：如果有事务在运行，当前的方法就在这个事务内运行.否则它可以不运行在事务中.
4.NOT_SUPPORTE：当前的方法不应该运行在事务中．如果有运行的事务，将它挂起
5.MANDATORY：当前的方法必须运行在事务内部，如果没有正在运行的事务，就抛出异常
6.NEVER：当前的方法不应该运行在事务中．如果有运行的事务，就抛出异常
7.NESTED：如果有事务在运行，当前的方法就应该在这个事务的嵌套事务内运行．否则，就启动一个新的事务，并在它自己的事务内运行.
2.ioslation：事务的隔离级别
(1)事务中有一个特性--隔离性：多事务操作时不会相互产生影响，不考虑隔离性会产生一些问题：脏读、不可重复读、幻读
1.脏读：一个未提交的事务读取到另一个未提交事务的数据
2.不可重复读：一个未提交的事务能在过程中读取到另外一个已经提交事务修改的数据。（两个事务应该互不影响，但是这种情况影响了）
3.幻读：一个未提交的事务读取到另一个已提交事务添加的数据
(2)解决：通过设置事务的隔离性：
1、READ UNCOMMITTED：有脏读、有不可重复读、有幻读
2、READ COMMITED:无脏读、有不可重复读、有幻读
3、REPEATABLE READ：无脏读、无不可重复读、有幻读
4、SERIALIZABLE：无脏读、无不可重复读、无幻读
3.timeout：超时时间
(1)在事务开始后在一段时间之内没有提交会自动回滚
(2)默认值：-1 不超时 以秒为单位
4.readOnly：是否只读
(1)默认值：false可以读写
5.rollbackFor：回滚
---》设置哪些异常进行回滚
6.norollbackFor：不回滚
---》设置哪些异常不进行回滚
7.事务操作(基于XML声明式)
1.在Spring配置文件中配置事务管理器
2.配置通知
3.配置切入点和切面
8.事务操作(完全注解声明式事务管理)
1.创建配置类，使用配置类替代xml文件
@Configuration
@ComponentScan(basePackages = "com.van")
@EnableTransactionManagement //开启事务
public class TxConfig{}
2.把xml里面的信息在配置类里面实现
1.数据库连接
//创建数据库链接
@Bean
public DruidDataSource getDruidDataSource(){
DruidDataSource dataSource = new DruidDataSource();
dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
dataSource.setUrl("jdbc:mysql://localhost:3306/test");
dataSource.setUsername("root");
dataSource.setPassword("123456");
return dataSource;
}
2.创建jdbcTamplate对象，并将dataSource的信息注入jdbcTemplate
//创建jdbcTemplate对象
//因为前面已经通过注解创建dataSource对象，IOC容器中有这个对象，直接传递进来注入jdbcTemplate就可以
@Bean
public JdbcTemplate getJdbcTemplate(DataSource dataSource){
JdbcTemplate jdbcTemplate = new JdbcTemplate();
//数据源注入jdbcTemplate
jdbcTemplate.setDataSource(dataSource);
return jdbcTemplate;
}
3.创建事务管理器
//创建事务管理器
@Bean
public DataSourceTransactionManager getDataSourceTransactionManager(DataSource dataSource){
DataSourceTransactionManager dataSourceTransactionManager = new DataSourceTransactionManager();
dataSourceTransactionManager.setDataSource(dataSource);
return dataSourceTransactionManager;
}
