记录自己的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
<bean id="user" class="com.van.spring5.User"></bean>
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配置文件，配置创建的对象
<bean id="user" class="com.van.spring5.User"></bean>
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创建对象
<bean id="user" class="com.van.spring5.User"></bean>
（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配置文件配置对象创建，配置属性注入
<!-- 2 创建对象并 set方法注入属性-->
<bean id="book" class="com.van.spring5.Book">
<!--使用property完成属性注入
name:类中属性名
value：向属性注入的值
-->
<property name="bname" value="java"></property>
<property name="bauthor" value="maomao"></property>
</bean>
第二种：使用有参构造方法注入属性
1.定义类中属性和有参构造方法
2.在spring配置文件配置对象创建，配置属性注入
<!--3 创建对象并 在有参构造中注入属性-->
<bean id="orders" class="com.van.spring5.Orders">
<constructor-arg name="oname" value="abc"></constructor-arg>
<constructor-arg name="address" value="China"></constructor-arg>
</bean>
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.进行属性注入
<bean id="book" class="com.van.spring5.Book" p:bname="spring" p:bauthor="maoamo"></bean>
（3） 底层是在set的基础上操作
d.xml注入其他类型属性
（1）字面量：
1.null值
<!-- 注入null值-->
<property name="baddress" >
<null/>
</property>
2.属性值包含特殊符号
<!-- 属性值包含特殊符号
1 把特殊符号转义 > <
2 把带特殊符号内容写到CDATA
-->
<property name="baddress">
<value>
<![CDATA[<<南京>>]]>
</value>
</property>
e.xml注入外部bean
（1）例子：
1.创建两个类service类和dao类
2.在service调用dao里面的方法
3.在spring配置文件中进行配置
<!-- 1 配置service和dao对象创建-->
<bean id="userService" class="com.van.spring5.service.UserService">
<!--注入userDao对象
name属性值：类里面属性名称
ref属性：创建userDao对象bean标签的id值
-->
<property name="userDao" ref="userDaoImpl"></property>
</bean>
<bean id="userDaoImpl" class="com.van.spring5.dao.UserDaoImpl"></bean>
f.xml注入内部bean和级联赋值
（1）一对多关系：部门和员工
（2）在实体类之间表示一对多关系，员工属于某一个部门，使用对象形式表示
<!-- 内部bean-->
<bean id="emp" class="com.van.spring5.bean.Emp">
<!--设置两个普通属性-->
<property name="ename" value="leo"></property>
<property name="gender" value="男"></property>
<!--设置对象类型属性-->
<property name="dept">
<bean id="dept" class="com.van.spring5.bean.Dept">
<property name="dname" value="maomao"></property>
</bean>
</property>
</bean>
g.xml注入集合属性
（1）注入数组类型属性
（2）注入List集合类型属性
（3）注入Map集合类型属性
操作：
1.创建一个普通类，定义好这些需要注入的类型属性
2.在spring配置文件中进行配置
<!-- 集合类型属性注入-->
<bean id="stu" class="com.van.spring5.CollectionType.Stu">
<!--数组类型属性注入-->
<property name="courses">
<array>
<value>java</value>
<value>spring</value>
</array>
</property>
<!--list类型属性注入-->
<property name="list">
<list>
<value>leo</value>
<value>messi</value>
</list>
</property>
<!--map类型属性注入-->
<property name="maps">
<map>
<entry key="JAVA" value="java"></entry>
<entry key="SPRING" value="spring"></entry>
</map>
</property>
<!--set类型属性注入-->
<property name="set">
<set>
<value>Mysql</value>
<value>Redis</value>
</set>
</property>
</bean>
特殊情况：
1.在集合中需要注入对象类型值
<!--注入list集合类型，值是对象-->
<property name="courseList">
<list>
<ref bean="course1"></ref>
<ref bean="course2"></ref>
</list>
</property>
下面创建好多个course对象 上面引入就可以
<!--创建多个course对象-->
<bean id="course1" class="com.van.spring5.CollectionType.Course">
<property name="cname" value="Spring5"></property>
</bean>
<bean id="course2" class="com.van.spring5.CollectionType.Course">
<property name="cname" value="MyBatis"></property>
</bean>
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集合类型属性注入
<!--提取list集合类型属性注入-->
<util:list id="bookList">
<value>jsp</value>
<value>java</value>
<value>spring</value>
</util:list>
<!--提取list集合类型属性注入使用-->
<bean id="book" class="com.van.spring5.CollectionType.Book">
<property name="list" ref="bookList"></property>
</bean>
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配置文件中配置
<!-- 配置后置处理器-->
<bean id="myBeanPost" class="com.van.spring5.bean.MyBeanPost"></bean>
因为类实现了接口，所以spring能直接识别出是后置处理器
7、IOC操作 Bean 管理（XML自动装配）、
1.什么是自动装配
（1）根据指定装配规则（属性名或者属性类型），Spring自动将匹配的属性值注入
2.操作过程
<!--
实现自动装配：
bean标签属性autowire，配置自动装配
autowire常用的两个值：
byName:根据属性名称注入，注入值bean的id值和类属性名称需要一样
byType:根据属性类型注入，在类有多实例对象时，无法确定是哪一个会报错
-->
<bean id="emp" class="com.van.spring5.autowire.Emp" autowire="byType">
<!--<property name="dept" ref="dept1"></property>-->
</bean>
<bean id="dept1" class="com.van.spring5.autowire.Dept"></bean>
8、IOC操作 Bean 管理(外部属性文件)
1.直接配置数据库信息
（1）配置Druid连接池
<!--直接配置druid数据库连接池-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<property name="driverClassName" value="com.mysql.cj.jdbc.Driver"></property>
<property name="url" value="jdbc:mysql://localhost:3306/test"></property>
<property name="username" value="root"></property>
<property name="password" value="123456"></property>
</bean>
（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中使用名称空间引入属性配置文件
<!--引入外部属性文件配置数据库连接池-->
<context:property-placeholder location="classpath:jdbc.properties"/>
c.引入之后配置druid数据库连接池
<!--引入之后配置druid数据库连接池-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<property name="driverClassName" value="${prop.driverClass}"></property>
<property name="url" value="${prop.url}"></property>
<property name="username" value="${prop.userName}"></property>
<property name="password" value="${password}"></property>
</bean>
个人思考：优势不需要再去做繁琐的读取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.开启组件扫描
<!--开启组件扫描
扫描spring5下多个包可以有多种写法
1 多个包之间使用逗号隔开 com.van.spring5.dao,com.van.spring5.service
2 扫描上层目录 com.van.spring5
-->
<context:component-scan base-package="com.van.spring5"></context:component-scan>
（3）第三步 创建UserService测试类，在类上面添加创建对象注解
//在注解里面value属性值可以省略，默认是类名搜字母小写
@Component(value = "userService") //等同于<bean id="" value=""></bean>
在类上方添加这个注解，就能创建对象了
获取配置文件，直接getBean就可以得到对象了
4.开启组件扫描细节配置
<!-- 实例1
use-default-filters="false" 表示现在不适用默认filter，自己配置filter
context:include-filter 设置扫描哪些内容 最后的.Controller代表只扫描@Controller
写了第一个属性，不写第二个属性就不会扫描包
-->
<context:component-scan base-package="com.van.spring5" use-default-filters="false">
<context:include-filter type="annotation"
expression="org.springframework.stereotype.Controller"/>
</context:component-scan>
<!-- 示例2
context:exclude-filter 设置哪些内容不扫描 expression=“....Controller 表示不扫描@Controller
-->
<context:component-scan base-package="com.van.spring5">
<context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>
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方法进行增强
//*代表任何返回类型
//把add改成*表示对所有方法进行增强
//里面的两个点代表任意参数
execution(* com.atguigu.aopdemo.UserDaoImpl.add(..))
例：对com/atguigu.aopdemo里面的所有类和所有方法进行增强
execution(* com.atguigu.aopdemo.*.*(..))
4、AOP操作(AspectJ注解)
1.创建一个类，在类里面定义方法
2.创建增强类（编写增强逻辑）
1.在增强类里面，创建方法，让不同方法代表不同通知类型
3.进行通知的配置
1.在spring配置文件中，开启注解扫描
//顶部要引入空间
xmlns:context="http://www.springframework.org/schema/context"
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/context http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
<!-- 开启注解扫描-->
<context:component-scan base-package="aopanno"></context:component-scan>
2.使用注解创建User和UserProxy对象
3.增强类上面添加注解@Aspect
4.在spring配置文件中开启生成代码的对象
4.配置不同类型的通知
1.在增强类的里面，在作为通知方法上面添加通知类型注解，使用切入点表达式配置
//增强类
@Component
@Aspect
public class UserProxy {
//前置通知
//@before注解表示作为前置通知
@Before(value = "execution(* aopanno.User.add(..))")
public void before(){
System.out.println("before.....");
}
//后置通知。在返回值之后执行，有异常不执行
@AfterReturning(value = "execution(* aopanno.User.add(..))")
public void afterReturning(){
System.out.println("afterReturning.....");
}
//异常通知，方法发生异常的时候执行
@AfterThrowing(value = "execution(* aopanno.User.add(..))")
public void afterThrowing(){
System.out.println("AfterThrowing.....");
}
//在方法执行之后执行，也是最终通知，不管有没有异常都执行
@After(value = "execution(* aopanno.User.add(..))")
public void after(){
System.out.println("after.....");
}
//环绕通知
@Around(value = "execution(* aopanno.User.add(..))")
public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
System.out.println("环绕之前....");
//被增强的方法执行
proceedingJoinPoint.proceed();
System.out.println("环绕之后....");
}
}
5.相同的切入点抽取
//相同切入点抽取
@Pointcut(value = "execution(* aopanno.User.add(..))")
public void commonpointcut(){
}
//前置通知
//@before注解表示作为前置通知
@Before(value = "commonpointcut()")
public void before(){
System.out.println("before.....");
}
6.多个增强类对同一个方法进行增强，可以设置增强类优先级
1.可以在增强类的上面添加一个注解@Order(数字类型值)值越小优先级越高
5、AOP操作(AspectJ配置文件)
1.创建两个类，增强类和被增强类，创建方法。
2.在Spring配置文件中创建两个类的对象
3.在Spring配置文件中配置切入点。
4.配置切入点之后在里面配置切面
5.配置切面后配置具体作用在哪个通知类型上和作用在哪个具体的方法上
<!-- 创建对象-->
<bean id="book" class="aopxml.Book"></bean>
<bean id="bookProxy" class="aopxml.BookProxy"></bean>
<!-- 配置aop增强-->
<aop:config>
<!-- 切入点-->
<aop:pointcut id="buy" expression="execution(* aopxml.Book.buy(..))"/>
<!-- 配置切面-->
<aop:aspect ref="bookProxy">
<!-- 配置作用在具体的方法上-->
<aop:before method="before" pointcut-ref="buy"></aop:before>
</aop:aspect>
</aop:config>
6、完全注解开发实现AspectJ注解扫描
1.可以实现spring配置文件中开启扫描组件和生成代理对象的操作
2.创建配置类，不需要再创建xml配置文件
//@Configuration:代表这个类是一个注解类
//@ComponentScan(basePackages = {"aopanno"}):实现aopanno包下的注解组件扫描
//@EnableAspectJAutoProxy(proxyTargetClass = true):实现AspectJ代理对象的生成
@Configuration
@ComponentScan(basePackages = {"aopanno"})
@EnableAspectJAutoProxy(proxyTargetClass = true)
public class ConfigAop {
}
⑤JDBCTemplate
1.JdbcTemplate概念和准备
1.什么是jdbcTemplate？
(1)Spring框架对JDBC进行封装，使用JDBCTemplate可以很方便的实现对数据库的操作
2.准备工作
(1)引入相关的jar包
a.数据库链接相关jar包，如：mysql-connector、druid等
b.spring.jdbc.jar、spring.tx(事务方面的jar包)、spring.orm(整合mybatis、hibernate等框架时使用)
(2)在spring配置文件中配置数据库连接池
<!--数据库连接池-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close">
<property name="url" value="jdbc:mysql://localhost:3306/test" ></property>
<property name="username" value="root" ></property>
<property name="password" value="123456" ></property>
<property name="driverClassName" value="com.mysql.cj.jdbc.Driver" ></property>
</bean>
(3)配置JdbcTamplate对象，注入DataSource
<!--JdbcTemplate对象-->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<!-- 注入dataSource-->
<property name="dataSource" ref="dataSource"></property>
</bean>
(4)创建service类，创建dao、daoimpl类，在dao注入Jdbctamplate对象
a.spring配置文件中开启组件扫描
<!-- 开启组件扫描-->
<context:component-scan base-package="com.van"></context:component-scan>
b.service类创建对象，并注入DaoImpl对象
@Service
public class BookService {
//注入dao
@Autowired
private BookDao bookDao;
}
c.DaoImpl类中注入JdbcTemplate对象
@Repository
public class BookDaoImpl implements BookDao{
//注入JdbcTemplate
@Autowired
private JdbcTemplate jdbcTemplate;
}
2.JdbcTemplate操作数据库(添加数据)
1.对应数据库表先创建出实体类（User类）
2.编写service和dao
(1)在service层调用dao的add方法，impl实现dao的add方法
(2)在impl调用jdbcTemplate对象里面的update()方法
update(String sql,Object... args)
第一个参数sql：写入的sql语句
第二个参数：可变参数，sql语句需要带入？的值
3.JdbcTemplate操作数据库(修改数据和删除)
1.操作和添加数据一样，只不过sql语句变成了update和delete
4.JdbcTemplate操作数据库(查询数据返回某一个值)
1.例：查询表中有多少条记录
(1)在Dao和DaoImpl中创建selectCount()方法
(2)在BookService中用bookService调用Dao中的方法
(3)在DaoImpl的selectCount()中实现具体查询方法逻辑
public int selectCount() {
/*
第一个参数 String sql：sql语句
第二个参数 Class<T> requiredType ：返回类型的Class
*/
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 = ?";
/*
第一个参数 String sql：sql语句
第二个参数 RowMapper:是一个接口，返回不同类型的数据，使用这个接口里面实现类完成数据的封装
去new BeanPropertyRowMapper<T>(T.class) 可以把查询的数据封装到T中去
第三个参数 ：sql语句中?的值
*/
Book book = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<Book>(Book.class), id);
return book;
}
6.JdbcTemplate操作数据库(查询数据返回集合)
1.和查询返回值有点相似
(1)在Dao和DaoImpl中创建selectCount()方法
(2)在BookService中用bookService调用Dao中的方法
(3)在DaoImpl的findBookInfo()中实现具体查询方法逻辑
public List<Book> findAllBookInfo() {
String sql = "select * from t_book";
/*
第一个参数 String sql：sql语句
第二个参数 RowMapper:是一个接口，返回不同类型的数据，使用这个接口里面实现类完成数据的封装
去new BeanPropertyRowMapper<T>(T.class) 可以把查询的数据封装到T中去
第三个参数 ：sql语句中?的值
*/
List<Book> books = jdbcTemplate.query(sql, new BeanPropertyRowMapper<Book>(Book.class));
return books;
}
7.JdbcTemplate操作数据库(批量操作)
1.批量操作：操作表里面的多条记录
2.JdbcTemplate实现批量添加操作
//jdbcTemplate.batchUpdate(String sql,List<Object[]> batchArgs)
/*
第一个参数：sql语句
第二个参数：List集合：添加的多条记录的数据
*/
//在输入的时候会创建List<Object[]> batchArgs数组
//测试调用插入的List
List<Object[]> batchArgs = new ArrayList<>();
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配置文件中配置事务管理器
<!-- 创建事务管理器-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<!-- 注入数据源-->
<property name="dataSource" ref="dataSource"></property>
</bean>
2.在Spring配置文件中开启事务注解
1.在Spring配置文件中引入名称空间tx
2.开启事务的注解
<!--开启事务注解-->
<tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>
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.配置切入点和切面
<!-- 1 创建事务管理器-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<!-- 注入数据源-->
<property name="dataSource" ref="dataSource"></property>
</bean>
<!--2配置通知-->
<tx:advice id="txadvice">
<!--配置事务参数-->
<tx:attributes>
<!--指定哪种规则的方法上面添加事务-->
<tx:method name="accountMoney" propagation="REQUIRED" isolation="REPEATABLE_READ"/>
<!--*代表account开头的所有方法-->
<!--<tx:method name="account*"/>-->
</tx:attributes>
</tx:advice>
<!-- 3配置切入点和切面-->
<aop:config>
<aop:pointcut id="pt" expression="execution(* com.van.service.UserService.*(..))"/>
<!-- 配置切面-->
<!-- 把事务的通知配置到切入点和切面中-->
<aop:advisor advice-ref="txadvice" pointcut-ref="pt"></aop:advisor>
</aop:config>
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;
}
