Spring5笔记

内容介绍

1、Spring 框架概述

2、IOC 容器

（1）IOC 底层原理

（2）IOC 接口（BeanFactory）

（3）IOC 操作 Bean 管理（基于 xml）

（4）IOC 操作 Bean 管理（基于注解）

3、Aop

4、JdbcTemplate

5、事务管理

6、Spring5 新特性

spring框架概述

spring框架是轻量级的开源的 javaEE框架
spring可以解决企业应用开发的复杂性
spring有两个核心部分 ioc 和 aop
- ioc ：控制反转，把创建对象过程交给spring 进行管理
- aop: 面向切面，不修改源代码进行功能增强
spring 的特点
- 方便解耦，简化开发
- aop编程支持
- 方便程序测试
- 方便和其他框架进行整合
- 方便进行事务操作
- 降低api开发难度

spring5框架入门案例

前往spring官网下载 spring5 https://spring.io

spring 模块图：

新建一个项目，引入 spring 的基础jar包

编写一个类 User

public class User {
    public void add(){
        System.out.println("add方法....");
    }
}

在src目录下新建一个spring 配置文件

配置信息如下：

<?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">
<!--配置user对象创建-->
    <bean id="user" class="com.izumi.spring5.User"></bean>
</beans>

新建一个测试类 test

 @Test
    public void testAdd(){
        //加载spring配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
//        获取配置创建的对象
        User user = context.getBean("user", User.class);
        System.out.println(user);
        user.add();
    }

IOC

IOC概念和底层原理

什么是IOC

（Inversion of Control/DependencyInjection(Ioc/DI)）
是控制反转，即将对象的创建和对象之间的调用交给 spring 管理

IOC的作用是降低耦合度

spring5入门案例就是对IOC的使用

IOC的底层原理

1、用到的技术：xml解析，工厂模式，反射

2、画图讲解IOC底层原理

工厂模式

3、IOC容器接口

IOC思想基于IOC容器完成，IOC容器底层就是对象工厂
spring提供IOC容器实现两种方式（两个接口）
BeanFactory ：IOC容器基本实现，供spring内部使用，不提供开发人员进行使用
*特点：加载配置文件时不会创建对象，在获取（使用）对象时候才去创建
ApplicationContext：BeanFactory接口的子接口，提供更多更强大的功能，供开发人员使用
*特点：加载配置文件时候就会把配置文件对象进行创建

IOC操作Bean管理

什么是Bean管理（概念）

1、Bean管理指的是两个操作

spring创建对象
spring属性注入属性

2、Bean管理操作的两种方式

基于xml方式
基于注解方式

基于xml方式的bean管理

1、spring对象创建

xml配置：
（1）在spring配置文件中，使用bean标签，标签里面添加对应的属性，就可以实现对象创建
（2）在 bean标签有很多属性，介绍常用的属性：
id：唯一标识符
class: 类的全类名（包类路径）

1 2	<!--配置user对象创建--> <bean id="user" class="com.izumi.spring5.User"></bean>

（3）创建对象时候，默认也是执行无参数构造方法完成对象创建

2、基于xml方式注入属性

（1）DI：依赖注入，就是注入属性

它和IOC是什么关系？DI是IOC容器操作Bean管理属性注入的具体实现

先创建对象，再注入属性

第一种注入方式：通过 set 方法注入

通过 set 方法注入

（1）创建类，定义属性和对应的 set 方法

public class Book {
    private String name;
    private String author;

    //两种方式实现 属性 注入

    //1.set方法
    public void setName(String name) {
        this.name = name;
    }

    public void  setAuthor(String author){
        this.author = author;
    }
}

在spring配置文件配置对象，配置属性注入

    <bean id="book" class="com.izumi.spring5.Book">
<!--        基于xml方式的属性注入
            property 完成属性注入
            name 类里面 属性名称
            value :为该属性赋的值
            -->
        <property name="name" value="白夜行"></property>
        <property name="author" value="东野圭吾"></property>
    </bean>

第二种注入方式通过有参构造注入

创建类，定义属性，创建属性对应构造方法

/**
 * 通过有参构造注入属性
 */
public class Orders {
    private String name;
    private String address;

    public Orders(String name, String address) {
        this.name = name;
        this.address = address;
    }
}

在 spring配置文件中配置有参构造注入属性

<!--    通过有参构造注入属性-->
    <bean id="orders" class="com.izumi.spring5.Orders">
        <constructor-arg name="name" value="电脑"></constructor-arg>
        <constructor-arg name="address" value="USA"></constructor-arg>
    </bean>

p名称空间注入(了解，底层其实是set方法注入)

主要是简化基于 xml配置方式注入

1、在xml配置中加入p名称空间

2、进行属性注入，在bean标签里面添加

1 2	<!-- 使用p名称空间注入属性--> <bean id="dog" class="com.izumi.spring5.Dog" p:name="小彩" p:color="yellow"></bean>

注入其他类型属性

null值

<!--        为属性赋空值-->
        <property name="address">
           <null/>
        </property>

属性值包含特殊符号

（2）属性值包含特殊符号
<!--属性值包含特殊符号
 1 把<>进行转义 &lt; &gt;
 2 把带特殊符号内容写到 CDATA
-->
<property name="address">
 <value><![CDATA[<<南京>>]]></value>
</property>

外部bean

创建两个类serviec 和 dao

在service调用dao里面的方法

在spring中进行配置

public class UserService {
    //创建 dao 属性
    private UserDao userDao;
    //提供set方法
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }
    public void add(){
        System.out.println("service add方法....");
        userDao.daoTest();
    }
}

xml配置

<!--基于xml注入属性-外部bean-->
<!--    把 service对象和 dao对象 都创建好-->
    <bean id="userService" class="com.izumi.spring5.service.UserService">
        <!--注入 userDao 对象
        name 属性：类里面属性名称
        ref 属性：创建 userDao 对象 bean 标签 id 值
        -->
    <property name="userDao" ref="UserDaoImpl"></property>
</bean>
    <bean id="UserDaoImpl" class="com.izumi.spring5.dao.UserDaoImpl"></bean>

内部bean

内部bean：如一对多关系：部门和员工

  					一个部门有多名员工，一个员工属于一个部门

                      部门是一，员工是多

新建Emp类和Dept类

//员工类
public class Emp {
    //普通属性
    private String ename;
    private String gender;
    //对象属性,一个员工属于一个部门
    private Dept dept;
    public void setEname(String ename) {
        this.ename = ename;
    }
    public void setGender(String gender) {
        this.gender = gender;
    }
    public void setDept(Dept dept) {
        this.dept = dept;
    }
}

//部门类
public class Dept {
    private  String dname;
    public void setDname(String dname) {
        this.dname = dname;
    }
}

在spring配置文件中配置

<!--创建emp对象-->
    <bean id="emp" class="com.izumi.spring5.bean.Emp">
<!--        注入两个普通属性-->
        <property name="ename" value="Jack"></property>
        <property name="gender" value="男"></property>
<!--        注入对象属性 内部bean注入-->
        <property name="dept">
            <bean id="dept" class="com.izumi.spring5.bean.Dept">
                <property name="dname" value="安保部"></property>
            </bean>
        </property>
    </bean>

级联赋值

第一种写法：

<!--创建emp对象-->
    <bean id="emp" class="com.izumi.spring5.bean.Emp">
<!--        注入两个普通属性-->
        <property name="ename" value="Jack"></property>
        <property name="gender" value="男"></property>
<!--        注入对象属性 级联赋值 第一种写法：(和注入外部bean类似)-->
        <property name="dept" ref="dept"></property>
    </bean>
    <bean id="dept" class="com.izumi.spring5.bean.Dept">
        <property name="dname" value="安保部"></property>
    </bean>

第二种写法：

//生成dept的get方法 
    public Dept getDept() {
        return dept;
    }

xml配置：

<!--创建emp对象-->
    <bean id="emp" class="com.izumi.spring5.bean.Emp">
<!--        注入两个普通属性-->
        <property name="ename" value="Jack"></property>
        <property name="gender" value="男"></property>
<!--        注入对象属性 级联赋值 第一种写法：(和注入外部bean类似)-->
        <property name="dept" ref="dept"></property>
        <!--        注入对象属性 级联赋值 第二种写法：-->
        <property name="dept.dname" value="技术部"></property>
    </bean>
    <bean id="dept" class="com.izumi.spring5.bean.Dept">
        <property name="dname" value="安保部"></property>
    </bean>

其实就是UserService中调用UserDao的set注入覆盖掉UserDao之前调用set注入的结果。

注入集合类型的属性

1、注入数组类型属性

2、注入List类型属性

3、注入Map类型属性

public class Stu {
    //数组类型属性
    private String[] courses;
    //List类型
    private List<String> lists;
    //Map类型属性
    private Map<String,String> maps;
    //Set类型属性
    private Set<String> sets;
    public void setCourses(String[] courses) {
        this.courses = courses;
    }
    public void setList(List<String> list) {
        this.lists = list;
    }
    public void setMaps(Map<String, String> maps) {
        this.maps = maps;
    }
    public void setSet(Set<String> set) {
        this.sets = set;
    }
    @Override
    public String toString() {
        return "Stu{" +
                "courses=" + Arrays.toString(courses) +
                ", lists=" + lists +
                ", maps=" + maps +
                ", sets=" + sets +
                '}';
    }
}

spring配置文件配置

<!--集合类型属性注入-->
    <bean id="stu" class="com.izumi.spring5.collectiontype.Stu">
<!--        数组类型属性注入-->
        <property name="courses">
            <array>
                <value>java基础</value>
                <value>javaWeb</value>
            </array>
        </property>
<!--        list属性注入-->
        <property name="list">
            <list>
                <value>北京</value>
                <value>上海</value>
                <value>广州</value>
                <value>深圳</value>
            </list>
        </property>
<!--        map属性注入-->
        <property name="maps">
            <map>
                <entry key="JAVA" value="java" ></entry>
                <entry key="PHP" value="php" ></entry>
                <entry key="CPP" value="cpp" ></entry>
            </map>
        </property>
<!--    set属性注入-->
        <property name="set">
            <set>
                <value>Mysql</value>
                <value>Oracle</value>
                <value>Tomcat</value>
            </set>
        </property>
    </bean>

4、在集合里面设置对象类型值

<!--        集合存放对象的属性注入-->
        <property name="courseList">
            <list>
                <ref bean="courese1"></ref>
                <ref bean="courese2"></ref>
            </list>
        </property>
    </bean>
<!--    外部bean定义对象-->
    <bean id="courese1" class="com.izumi.spring5.collectiontype.Course">
        <property name="cname" value="Spring5框架课程"></property>
    </bean>
    <bean id="courese2" class="com.izumi.spring5.collectiontype.Course">
        <property name="cname" value="MyBatis框架课程"></property>
    </bean>

5、把集合注入部分提取出来

在spring配置文件中引入util名称空间

使用util标签完成list集合注入提取

<!--使用util标签完成    提取list集合属性注入-->
    <util:list id="bookList">
        <value>白夜行</value>
        <value>嫌疑人x的献身</value>
        <value>解忧杂货店</value>
    </util:list>

提取list集合类型注入属性

<!--    提取list集合类型注入属性-->
   <bean id="book" class="com.izumi.spring5.collectiontype.Book">
    <property name="list" ref="bookList"></property>
   </bean>

FactoryBean

基本介绍：

spring 有两种类型bean，一种是普通bean，另一种是工厂bean（FactoryBean）

普通bean：在配置文件中定义的类型就是返回类型

工厂bean，在配置文件中定义的类型可以和返回的类型不一致

如何实现创建工厂bean

第一步：创建类，让这个类作为工厂bean，实现接口 FactoryBean。

第二部：实现接口里面的方法，在实现的方法定义返回的bean类型

public class MyFactoryBean implements FactoryBean<Course> {
    @Override
    public Course getObject() throws Exception {
        Course course = new Course();
        course.setCname("kksk");
        return course;
    }
    @Override
    public Class<?> getObjectType() {
        return null;
    }
}

spring配置文件

1 2	<!-- 配置工厂bean--> <bean id="myFactoryBean" class="com.izumi.spring5.factorybean.MyFactoryBean"></bean>

注意此时返回的类型是 Course

bean作用域

1、在spring里面，设置创建对象的时候是单实例还是多实例

2、在spring里面，默认情况下是单实例

如何设置单实例和多实例

在spring配置文件 bean标签里面有属性 scope 可以设置单实例或多实例

scope=”singleton” 表示单实例（默认值） scope =”prototype” 表示多实例

<!--    scope属性设置 创建的对象是单实例还是多实例    singleton表示单实例  prototype表示多实例-->
   <bean id="book" class="com.izumi.spring5.collectiontype.Book" scope="prototype">
    <property name="list" ref="bookList"></property>
   </bean>

singleton和 prototype的区别

第一：singleton 单实例，prototype 多实例

第二：设置scope 值是singleton 的时候，加载spring配置文件时就创建对象

设置 scope值时prototype的时候，不是在加载 spring 配置文件时候创建对象,

对象在调用 getBean 方法时才创建

bean的生命周期

什么是生命周期

从对象创建到对象销毁的过程

bean生命周期

1）通过构造器创建bean实例（无参构造）

2）为bean的属性设置值和对其他bean 的引用（调用set方法）

3）调用bean的初始化的方法（需要进行配置初始化的方法）

4）bean就可以使用了（对象获取到了）

5）当容器关闭时候，调用bean 的销毁方法（需要进行配置销毁的方法）

演示bean生命周期

public class Orders {
 //无参数构造
 public Orders() {
 System.out.println("第一步 执行无参数构造创建 bean 实例");
 }
 private String oname;
 public void setOname(String oname) {
 this.oname = oname;
 System.out.println("第二步 调用 set 方法设置属性值");
 }
 //创建执行的初始化的方法
 public void initMethod() {
 System.out.println("第三步 执行初始化的方法");
 }
 //创建执行的销毁的方法
 public void destroyMethod() {
 System.out.println("第五步 执行销毁的方法");
 }
}

<bean id="orders" class="com.atguigu.spring5.bean.Orders" initmethod="initMethod" destroy-method="destroyMethod">
 <property name="oname" value="手机"></property>
</bean>
    
 @Test
 public void testBean4() {
// ApplicationContext context =
// new ClassPathXmlApplicationContext("bean4.xml");
    //ClassPathXmlApplicationContext是 ApplicationContext接口的实现类
 ClassPathXmlApplicationContext context =
 new ClassPathXmlApplicationContext("bean4.xml");
 Orders orders = context.getBean("orders", Orders.class);
 System.out.println("第四步 获取创建 bean 实例对象");
 System.out.println(orders);
 //手动让 bean 实例销毁
 context.close();
 }

4、bean 的后置处理器，bean 生命周期有七步

（1）通过构造器创建 bean 实例（无参数构造）

（2）为 bean 的属性设置值和对其他 bean 引用（调用 set 方法）

（3）把 bean 实例传递 bean 后置处理器的方法 postProcessBeforeInitialization

（4）调用 bean 的初始化的方法（需要进行配置初始化的方法）

（5）把 bean 实例传递 bean 后置处理器的方法 postProcessAfterInitialization

（6）bean 可以使用了（对象获取到了）

（7）当容器关闭时候，调用 bean 的销毁的方法（需要进行配置销毁的方法）

创建类实现接口BeanPostProcessor，创建后置处理器

public class MyBeanPost implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("初始化之前执行的方法");
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("初始化之后执行的方法");
        return bean;
    }
}

配置后置处理器

<bean id="myBeanPost" class="com.izumi.spring5.bean.MyBeanPost"></bean>

xml自动装配

实际开发中主要使用注解方法，xml方式使用较少

什么是自动装配

（1）根据指定装配规则（属性名称或者属性类型），Spring 自动将匹配的属性值进行注入

演示自动装配

（1）根据属性名称自动注入
<!--实现自动装配
 bean 标签属性 autowire，配置自动装配
 autowire 属性常用两个值：
 byName 根据属性名称注入 ，注入值 bean 的 id 值和类属性名称一样
 byType 根据属性类型注入
-->
<bean id="emp" class="com.atguigu.spring5.autowire.Emp" autowire="byName">
 <!--<property name="dept" ref="dept"></property>-->
</bean>
<bean id="dept" class="com.atguigu.spring5.autowire.Dept"></bean>
（2）根据属性类型自动注入
<!--实现自动装配
 bean 标签属性 autowire，配置自动装配
 autowire 属性常用两个值：
 byName 根据属性名称注入 ，注入值 bean 的 id 值和类属性名称一样
 byType 根据属性类型注入
-->
<bean id="emp" class="com.atguigu.spring5.autowire.Emp" autowire="byType">
 <!--<property name="dept" ref="dept"></property>-->
</bean>
<bean id="dept" class="com.atguigu.spring5.autowire.Dept"></bean>

xml配置外部属性文件

1、直接配置数据库信息

1）配置德鲁伊连接池

2）引入德鲁伊jar包

<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql://localhost:3306/userDb"></property>
        <property name="username" value="root"></property>
        <property name="password" value="zzt"></property>
    </bean>

引入外部属性文件配置数据库连接池

1）创建外部属性文件，properties格式，写入数据库连接信息

注意：名称最好使用 prop. 这样的格式，这样可以防止冲突

prop.driverClass=com.mysql.jdbc.Driver
prop.url=jdbc:mysql://localhost:3306/userDb
prop.username=root
prop.passowrd=zzt

2)把外部的properties属性文件引入到spring配置文件中

*引入 context名称空间

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       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
               http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

在spring配置文件中使用标签引入外部属性文件

<!--    引入外部属性文件-->
<!--    classpath就是项目的src文件夹-->
    <context:property-placeholder location="classpath:jdbc.properties"></context:property-placeholder>
<!--    配置连接池-->
    <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="${prop.password}"></property>
    </bean>

基于注解方式的bean管理

什么是注解？

1）注解是代码特殊标记，格式：@注解名称（属性名=属性，属性名=属性…）

2）使用注解，注解可以在类上面，方法上面，属性上面

3）使用注解，可以简化xml配置

spring针对bean管理中创建对象提供注解

@Component 通用

@Service 一般用在 service层

@Controller 一般用在web层

@Repository 一般用在dao层

以上四种注解功能都一样，都可以用来创建bean实例

基于注解方式实现bean对象创建实例

1)引入依赖

2)开启组件扫描

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       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
                            http://www.springframework.org/schema/context  http://www.springframework.org/schema/context/spring-context.xsd">
<!--  1.定义context名称空间
      2.配置spring组件扫描，
        base-package 属性值为扫描的包名，若有多个包可以使用逗号间隔或者扫描它们的上层包-->
    <context:component-scan base-package="com.izumi.spring5.dao,com.izumi.spring5.service"></context:component-scan>
</beans>

//在注解里面 value 属性值可以省略不写
//默认值是类名称，首字母小写
//UserService --userService
@Component(value = "userService")
public class UserService {
    public void  m1(){
        System.out.println("调用m1方法.....");
    }
}

组件扫描配置的细节

    <!--  开启组件扫描的细节 -->

    <!--示例1
        use-default-filters="false"表示现在不使用默认filter，自己配置filter
        context:include-filter设置扫描哪些内容
        -->
    <context:component-scan base-package="com.izumi.spring5" use-default-filters="false">
        <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>
<!--    示例2
       context:exclude-filter 表示设置哪些内容不扫描 -->
    <context:component-scan base-package="com.izumi.spring5">
        <context:exclude-filter  type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>

基于注解方式实现属性注入

@Autowired : 根据属性类型进行自动装配

第一步把 service 和 dao 对象创建，在 service 和 dao 类添加创建对象注解

第二步在 service 注入 dao 对象，在 service 类添加 dao 类型属性，在属性上面使用注解

@Repository
public class UserDaoImpl  implements UserDao{

}

@Service
public class UserService {
    //定义dao类型属性
    //不需要设置 set方法
    @Autowired //根据类型进行注入
    private UserDao userDao;
    public void  m1(){
        System.out.println("调用m1方法.....");
    }
    public void m2(){
        System.out.println("调用m2方法"+userDao);
    }
}

@Qualifier : 根据属性名称进行注入

//定义dao类型属性
    //不需要设置 set方法
    @Autowired //根据类型进行注入
    //此时UserDao实现类有两个，所以仅根据类型注入不知道找哪个实现类而报错
    @Qualifier(value = "userDaoImpl02")     //该注解必须和 @Autowired绑定使用
    private UserDao userDao;

@Resourse : 可以根据类型注入，也可以根据名称注入

但该注解不是spring里面提供的，因此不建议使用

 //@Resourse注解演示
// @Resource //注入根据类型
 @Resource(name = "userDaoImpl02") //根据名称注入
 private UserDao userDao;

@Value : 注入普通类型属性

1
2
3

//演示 @Value的使用
@Value(value = "你的名字")
private String name;

完全注解开发

1）创建配置类，替代xml配置文件

@Configuration  //作为配置类，替代 xml配置文件
@ComponentScan(basePackages = "com.izumi.spring5")
public class SpringConfig {
}

2）测试类

@Test
    public void testDemo2(){
        ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
        UserService userService = context.getBean("userService", UserService.class);
        System.out.println(userService);
        userService.m1();
        userService.m2();
    }

Aop

什么是aop

1、面向切面编程（方面），利用 AOP 可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

2、通俗描述，不通过修改源代码的方式，在程序主干功能上添加一个新的功能

3、使用登录例子说明aop

aop底层原理

1）有两种情况动态代理

第一种，有接口情况，使用jdk动态代理
实现：创建接口实现类代理对象，增强类的方法

第二种，没有接口的情况，使用CGLIB动态代理
实现：创建子类代理对象，增强类的方法

AOP（JDK动态代理）

使用 JDK 动态代理，使用 Proxy 类里面的方法创建代理对象
方法有三个参数：
第一参数，类加载器
第二参数，增强方法所在的类，这个类实现的接口，支持多个接口
第三参数，实现这个接口 InvocationHandler，创建代理对象，写增强的部分
编写jdk动态代理代码

//jdk的动态代理
public class UserProxy {
    public static void main(String[] args) {
        Class[] interfaces = {UserDao.class};
        //创建被代理类
        UserDao userDao = new UserDaoImpl();
        //创建接口实现类代理
        UserDao userDaoProxy =(UserDao) Proxy.newProxyInstance(UserProxy.class.getClassLoader(), interfaces, new UserDaoProxy(userDao));
        int add = userDaoProxy.add(10, 12);
        System.out.println(add);
        System.out.println();
        String id = userDaoProxy.id("1002");
        System.out.println(id);
    }
}
//创建代理对象代码
class UserDaoProxy implements InvocationHandler{
    private Object obj;
    public UserDaoProxy(Object obj){
        this.obj = obj;
    }
    //增强的功能逻辑
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        String methodName = method.getName();
            System.out.println(methodName+"方法调用前...");
            Object methodInvoke = method.invoke(obj, args);
            System.out.println(methodName+"方法调用后...");
            return methodInvoke;
    }
}

Aop的术语

1、连接点

类哪些方法可以被增强，这些方法就称为连接点

2、切入点

实际被真正增强的方法，称为切入点

3、通知（增强）

（1）实现增强的逻辑部分称为通知/增强

（2）通知有多种类型

前置通知

后置通知

环绕通知

异常通知

最终通知（类似于 try—catch—finally的finally）

4、切面

把通知应用到切入点的过程

AOP操作准备：

1、spring框架一般是基于AspectJ来实现AOP操作

那么什么是 AspectJ？

AspectJ不是spring框架的组成部分，而是独立的aop框架，一般把spring和AspectJ一起使用，进行aop操作。

2、基于AspectJ操作Aop

基于xml配置文件方式实现
基于注解方式实现（一般使用注解方式）

3、引入相关jar包

4、切入点表达式

1）切入点表达式作用：知道对哪个类里面的哪个方法进行增强

2）语法结构：excution([权限修饰符][返回类型][类全路径][方法名][参数列表])

举例1： com.izumi.spring5.dao.BookDao的add方法进行增强

excution(* com.izumi.spring5.dao.BookDao.add(..)) 这里返回类型省略了

举例2： com.izumi.spring5.dao.BookDao的所有方法进行增强

excution(* com.izumi.spring5.dao.BookDao.*(..))

举例3： com.izumi.spring5.dao的所有类的所有方法进行增强

excution(* com.izumi.spring5.dao.*.*(..))

Aop操作-基于注解方式

创建被增强类

//被增强类
@Component
public class User {
    public void add(){
        System.out.println("add方法.....");
    }
}

创建增强类，在增强类里面编写不同方法，不同的方法代表不同的通知类型

//增强类
@Component
@Aspect
public class UserProxy {
    //编写增强方法-通知
    @Before(value = "execution(* com.izumi.spring5.aopannotation.User.add(..))")
    public void before(){
        System.out.println("before().....");
    }
}

进行通知的配置

在spring文件中，添加对应的名称空间，并开启注解扫描

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       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">
    <!--开启spring注解扫描-->
    <context:component-scan base-package="com.izumi.spring5.aopannotation"></context:component-scan>

使用注解创建被增强类和增强类的对象
1
@Component
在增强类上面添加 @Aspect

在spring配置文件开启生成代理对象

1 2	<!-- 开启aspect生成代理对象--> <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

配置不同类型的通知

//增强类
@Component
@Aspect
public class UserProxy {
    //编写增强方法-通知
    //前置通知
    @Before(value = "execution(* com.izumi.spring5.aopannotation.User.add(..))")
    public void before(){
        System.out.println("before().....");
    }
    //后置通知  出现异常就不会执行
    @After(value = "execution(* com.izumi.spring5.aopannotation.User.add(..))")
    public void after(){
        System.out.println("after()..............");
    }
    //最终通知（返回通知）    不管是否出现异常，都会执行
    @AfterReturning(value = "execution(* com.izumi.spring5.aopannotation.User.add(..))")
    public void afterReturning(){
        System.out.println("afterReturning().....");
    }
    //环绕通知
    @Around(value = "execution(* com.izumi.spring5.aopannotation.User.add(..))")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕之前....");
        proceedingJoinPoint.proceed();
        System.out.println("环绕之后....");
    }
    //异常通知  出现异常的时候才执行
    @AfterThrowing(value = "execution(* com.izumi.spring5.aopannotation.User.add(..))")
    public void afterThrowing(){
        System.out.println("afterThrowing().....");
    }

}

相同的切入点抽取

//相同的切入点抽取
    @Pointcut(value = "execution(* com.izumi.spring5.aopannotation.User.add(..))")
    public void pointCut(){}
    //编写增强方法-通知
    //前置通知
    @Before(value = "pointCut()")
    public void before(){
        System.out.println("before().....");
    }

有多个增强类对同一个方法进行增强，设置增强优先级
（1）在增强类上面添加注解 @Order(数字类型值)，（从0开始）数字类型值越小优先级越高
1
2
3
4
@Component
@Aspect
@Order(1)
public class PersonProxy {

完全注解开发

创建配置类，不需要创建配置文件

@Configuration
@ComponentScan(basePackages = {"com.izumi.spring5"})
@EnableAspectJAutoProxy(proxyTargetClass = true)
public class ConfigAop {
}

Aop操作-基于AspectJ配置文件(用的较少)

(了解)

创建增强类和被增强类，编写对应的方法

//被增强类
public class Book {
    public void buy(){
        System.out.println("buy().....");
    }
}
//增强类
public class BookProxy {
    //前置通知
    public void before(){
        System.out.println("before()....");
    }
}

配置spring配置文件

创建增强类和被增强类对象
在spring配置文件中配置切入点

<?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: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">
<!--创建对象-->
 <bean id="book" class="com.izumi.spring5.aopxml.Book"></bean>
 <bean id="bookproxy" class="com.izumi.spring5.aopxml.BookProxy"></bean>
<!--    配置aop增强-->
 <aop:config>
<!--        配置切入点-->
     <aop:pointcut id="p" expression="execution(* com.izumi.spring5.aopxml.Book.buy(..))"/>
<!--        配置切面-->
     <aop:aspect ref="bookproxy">
         <!--        增强作用在具体方法上-->
         <aop:before method="before" pointcut-ref="p"></aop:before>
     </aop:aspect>

 </aop:config>
</beans>

JdbcTemplate

概念和准备

1、什么是 JdbcTemplate

（1）Spring 框架对 JDBC 进行封装，使用 JdbcTemplate 方便实现对数据库操作

2、准备工作

（1）引入相关 jar 包

（2）在spring配置文件中配置德鲁伊连接池信息

<!-- 数据库连接池 -->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
      destroy-method="close">
    <property name="url" value="jdbc:mysql:///user_db" />
    <property name="username" value="root" />
    <property name="password" value="zzt" />
    <property name="driverClassName" value="com.mysql.jdbc.Driver" />
</bean>

（3）在spring配置文件中创建JdbcTemplate对象，注入DataSource属性

<!--创建JDBCtemplate对象，注入属性DataSource-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

(4) 创建service类，创建dao类，在dao类注入JdbcTemplate对象

1 2	<!-- 开启组件扫描--> <context:component-scan base-package="com.izumi.spring5"></context:component-scan>

service类：

@Service
public class BookService {
    //注入dao
    @Autowired
    private BookDao bookDao;
}

dao类:

@Repository
public class BookDaoIml implements BookDao{
    //注入jdbcTemplate
    @Autowired
    private JdbcTemplate jdbcTemplate;
}

jdbcTemplate操作数据库（增改删）

1、创建数据库表对应的实体类

2、编写service和dao

（1）在 dao 进行数据库添加操作

（2）调用 JdbcTemplate 对象里面 update 方法实现添加操作

第一个参数：编写的sql语句
第二个参数：可变参数，设置sql语句

 //添加书本的方法	增
    @Override
    public void add(Book book){
        String sql = "insert into t_book values(?,?,?)";
        int update = jdbcTemplate.update(sql,book.getBookId(), book.getBookName(), book.getBookStatus());
        System.out.println(update);
    }
//修改
    @Override
    public void updateBook(Book book) {
        String sql = "update t_book set book_name=?,book_status=? where book_id=?";
        int update = jdbcTemplate.update(sql, book.getBookName(), book.getBookStatus(), book.getBookId());
        System.out.println(update);
    }

    //删除
    @Override
    public void deleteBook(Integer id) {
        String sql ="delete from t_book where book_id=?";
        int update = jdbcTemplate.update(sql, id);
        System.out.println(update);
    }

3、测试类

@Test
   public void testAdd(){
       ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
       BookService bookService = context.getBean(BookService.class);
       Book book = new Book();
       book.setBookId(1);
       book.setBookName("三体");
       book.setBookStatus("畅销");
       bookService.add(book);
   }

jdbcTemplate操作数据库（查）

查询返回某个值

场景：查询表里返回多少条记录，返回的是某个值

第一个参数：sql语句
第二个参数：返回值的类型的class

//查询返回某个值
    @Override
    public int findCount() {
        String sql = "select count(*) from t_book";
        return jdbcTemplate.queryForObject(sql,Integer.class);
    }

查询返回某个对象

场景：查询图书详情

第一个参数：sql语句
第二个参数： RowMapper接口，针对返回不同类型数据，使用改接口的实现类( BeanPropertyRowMapper< >)实现对数据的封装
sql语句值

//查询返回某个对象
    /*BeanPropertyRowMapper<Book>(Book.class)
    是RowMapper接口的实现类，泛型里填入返回的类型，参数列表填返回参数类型的class类型*/
    @Override
    public Book findBookInfo(Integer id) {
        String sql = "select * from t_book where book_id=?";
        return jdbcTemplate.queryForObject(sql,new BeanPropertyRowMapper<Book>(Book.class),id);
    }

查询返回某个集合

场景：查询图书列表分页

第一个参数：sql语句
第二个参数： RowMapper接口，针对返回不同类型数据，使用改接口的实现类( BeanPropertyRowMapper< >)实现对数据的封装
sql语句值

//查询返回集合
    @Override
    public List<Book> findAll() {
        String sql = "select * from t_book";
        List<Book> bookList = jdbcTemplate.query(sql, new BeanPropertyRowMapper<Book>(Book.class));
        return bookList;
    }

jdbcTemplate操作数据库（批量操作）

批量操作：操作表里多条记录

第一个参数：sql语句
第二个参数：LIst集合，添加多条记录数据

//批量添加多条记录	删除修改
    @Override
    public void batchAddBooks(List<Object[]> batchArgs) {
        String sql = "insert into t_book values(?,?,?)";
        int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
        System.out.println(Arrays.toString(ints));
    }

测试：

@Test
   public void testBatchAddBooks(){
       List<Object[]> list = new ArrayList<>();
       Object[] objects1 = new Object[]{3,"php","fjlsjf"};
       Object[] objects2 = new Object[]{4,"c#","sfsf"};
       Object[] objects3 = new Object[]{5,"python","lghf"};
       list.add(objects1);
       list.add(objects2);
       list.add(objects3);
       bookService.batchAddBooks(list);
   }

spring操作事务

事务

什么是事务？

事务是数据库操作最基本单元，逻辑上，一组操作，要么都成功，如果有一个失败所有操作都失败。

典型应用场景：银行转账

事务的四个特性 (ACID)

原子性：要么都成功，要么都失败
一致性：事务提交前后的完整性和状态保持一致
隔离性：是多个并发事务之间是隔离的
持久性：一个事务一旦被提交了，那么对数据库中的数据的改变就是永久性的

事务操作环境搭建

略

spring事务管理介绍

1、事务一般添加到javaee三层框架的service层（业务逻辑层）。

2、spring进行事务管理操作有两种方式：

编程式实务操作、声明式实务操作（使用）

3、声明式实务管理：

基于xml方式基于注解方式（使用）

4、在spring进行声明式事务管理，底层使用AOP原理。

5、spring事务管理api

（1）提供一个接口，代表事务管理器，这个接口针对不同的框架提供不同的实现类

JDBC事务：使用 DataSourceTranscationManager

Hibernate事务:使用HibernateTransactionManager

JPA事务：使用JpaTranscationManager

注解声明式事务管理

1、在spring配置文件中配置事务管理器

<!--    创建事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<!--注入数据源-->
        <property name="dataSource" ref="dataSource"></property>
    </bean>

2、在spring配置文件文件中配置 tx名称空间，并开启事务管理

1 2	<!-- 开启事务管理--> <tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>

3、在service类上面（或者service类方法上面）添加事务注解

1）@Transcational

将该注解添加到类上面，表示在这个类开启事务管理

将该注解添加到方法上面，表示在这个方法开启事务管理

1
2
3

@Service
@Transactional
public class UserService {

声明式事务管理参数配置

1、在 service 类上面添加注解@Transactional，在这个注解里面可以配置事务相关参数

propagation：事务传播行为（面试会考）

事务方法被另一个事务方法调用时，必须指定事务应该如何传播。例如方法可能继续在现有事务中运行，也可能开启一个新的事务，并在自己的事务运行。spring中的事务传播行为可以由传播属性指定。spring指定了7种类传播行为。

1
2
3

@Service
@Transactional(propagation=Propagation.REQUIRED)
public class UserService {

重点掌握前两个

REQUIRED举例：

通俗来说就是：方法一调用方法二，方法二会看如果方法一有事务，就直接用方法一的事务就行，和调用几次无关；如果方法一没有事务，我方法二就自己创建个事务，调用我几次我创建几次！

REQUIRES_NEW举例：

它表示该方法必须启动一个新事务, 并在自己的事务内运行. 如果有事务在运行, 就应该先挂起它.（这个正好相反就是，我方法二不管你方法一有没有事务，我都自己创建一个事务，你调用我几次我创建几次！

方法A调用方法B的时候，如果方法A也有事务，则先将方法A的事务挂起，开启方法B的事务，待方法B执行完毕提交，再恢复方法A的事务。

isolation:事务隔离级别

（1）事务有特性成为隔离性，多事务操作之间不会产生影响。不考虑隔离性产生很多问题

（2）有三个读问题：脏读、不可重复读、虚（幻）读

（3）脏读（Dirty Read）：A事务读取B事务尚未提交的数据并在此基础上操作，而B事务执行回滚，那么A读取到的数据就是脏数据。

解决办法：如果在第一个事务提交前，任何其他事务不可读取其修改过的值，则可以避免该问题。

（4）不可重复读: 一个未提交事务读取到另一个提交事务的数据

不可重复读（Non-repeatable Reads）
一个事务对同一行数据重复读取两次，但是却得到了不同的结果。事务T1读取某一数据后，事务T2对其做了修改，当事务T1再次读该数据时得到与前一次不同的值。

解决办法：如果只有在修改事务完全提交之后才可以读取数据，则可以避免该问题。

（5）虚读：一个未提交事务读取到另一提交事务添加数据

指两次执行同一条 select 语句会出现不同的结果，第二次读会增加一数据行，并没有说这两次执行是在同一个事务中。一般情况下，幻象读应该正是我们所需要的。但有时候却不是，如果打开的游标，在对游标进行操作时，并不希望新增的记录加到游标命中的数据集中来。隔离级别为游标稳定性的，可以阻止幻象读。例如：目前工资为1000的员工有10人。那么事务1中读取所有工资为1000的员工，得到了10条记录；这时事务2向员工表插入了一条员工记录，工资也为1000；那么事务1再次读取所有工资为1000的员工共读取到了11条记录。

（6）解决：通过设置事务隔离级别，解决读问题(mysql默认可重复读)

1
2
3

@Service
@Transactional(propagation=Propagation.REQUIRED,isolation = Isolation.REPEATABLE_READ)
public class UserService {

4、timeout：超时时间
（1）事务需要在一定时间内进行提交，如果不提交进行回滚
（2）默认值是 -1 ，设置时间以秒单位进行计算

5、readOnly：是否只读
（1）读：查询操作，写：添加修改删除操作
（2）readOnly 默认值 false，表示可以查询，可以添加修改删除操作
（3）设置 readOnly 值是 true，设置成 true 之后，只能查询

6、rollbackFor：回滚
（1）设置出现哪些异常进行事务回滚

7、noRollbackFor：不回滚
（1）设置出现哪些异常不进行事务回滚

基于xml方式进行声明式事务管理

1、在spring配置文件中配置事务管理器

2、配置通知

3、配置切入点和切面

<!--    创建事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<!--注入数据源-->
        <property name="dataSource" ref="dataSource"></property>
    </bean>

<!--    配置通知-->
    <tx:advice id="txadvice">
<!--        配置事务参数-->
        <tx:attributes>
<!--            制定哪种规则上面添加事务-->
            <tx:method name="account" propagation="REQUIRED" timeout="-1"/>
        </tx:attributes>
    </tx:advice>
<!--    配置切入点和切面-->
    <aop:config>
<!--        配置切入点-->
        <aop:pointcut id="pt" expression="execution(* com.izumi.spring5.service.UserService.*(..))"/>
<!--        配置切面-->
        <aop:advisor advice-ref="txadvice" pointcut-ref="pt"/>
    </aop:config>

基于完全注解开发实现声明式事务管理

创建配置类，使用配置类替代配置文件

@Configuration  //配置类
@ComponentScan(basePackages = "com.izumi.spring5") //组件扫描
@EnableTransactionManagement    //开启事务
public class Txconfig {
    @Bean   //创建数据库连接池
    public DruidDataSource getDruidDataSource(){
        DruidDataSource druidDataSource = new DruidDataSource();
        druidDataSource.setUrl("jdbc:mysql:///user_db");
        druidDataSource.setUsername("root");
        druidDataSource.setPassword("zzt");
        druidDataSource.setDriverClassName("com.mysql.jdbc.Driver");
        return druidDataSource;
    }
    @Bean   //创建jdbcTemplate            //参数：到ioc容器中根据参数类型找到dataSource
    public JdbcTemplate getJdbcTemplate(DataSource dataSource){
        JdbcTemplate jdbcTemplate = new JdbcTemplate();
        //注入DataSource
        jdbcTemplate.setDataSource(dataSource);
        return jdbcTemplate;
    }
    @Bean //创建事务管理器
    public DataSourceTransactionManager getDataSourceTransactionManager(DataSource dataSource){
        DataSourceTransactionManager dataSourceTransactionManager = new DataSourceTransactionManager();
        dataSourceTransactionManager.setDataSource(dataSource);
        return dataSourceTransactionManager;
    }
}

spring5新特性

1、特点

1、整个 Spring5 框架的代码基于 Java8，运行时兼容 JDK9，许多不建议使用的类和方法在代码库中删除

2、Spring 5.0 框架自带了通用的日志封装

（1）Spring5 已经移除 Log4jConfigListener，官方建议使用 Log4j2

（2）Spring5 框架整合 Log4j2

第一步引入 jar 包

第二步创建 log4j2.xml 配置文件

<?xml version="1.0" encoding="UTF-8"?>
<!--日志级别以及优先级排序: OFF > FATAL > ERROR > WARN > INFO > DEBUG > TRACE > ALL -->
<!--Configuration后面的status用于设置log4j2自身内部的信息输出，可以不设置，当设置成trace时，可以看到log4j2内部各种详细输出-->
<configuration status="DEBUG">
    <!--先定义所有的appender-->
    <appenders>
        <!--输出日志信息到控制台-->
        <console name="Console" target="SYSTEM_OUT">
            <!--控制日志输出的格式-->
            <PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
        </console>
    </appenders>
    <!--然后定义logger，只有定义了logger并引入的appender，appender才会生效-->
    <!--root：用于指定项目的根日志，如果没有单独指定Logger，则会使用root作为默认的日志输出-->
    <loggers>
        <root level="info">
            <appender-ref ref="Console"/>
        </root>
    </loggers>
</configuration>

3、Spring5 框架核心容器支持@Nullable 注解

（1）@Nullable 注解可以使用在方法上面，属性上面，参数上面，表示方法返回可以为空，

属性值可以为空，参数值可以为空

（2）注解用在方法上面，方法返回值可以为空

（3）注解使用在方法参数里面，方法参数可以为空

（4）注解使用在属性上面，属性值可以为空

4、Spring5 核心容器支持函数式风格 GenericApplicationContext

/**
     * 演示spring5新特性 核心容器支持函数式风格 GenericApplicationContext
     */
    @Test
    public void testGenericApplicationContext(){
        //创建 GenericApplicationContext 对象
        GenericApplicationContext context = new GenericApplicationContext();
        //调用context 的方法注册（在spring容器里注册，这样才能让spring管理该对象）
        context.refresh();
        //()->new User() : java四大核心函数式接口的供给型接口，采用lambda表达式实现
        context.registerBean("user",User.class,()->new User());
        //获取在spring注册的对象
      //  User user =(User) context.getBean("com.izumi.spring5.entity.User");
        User user =(User) context.getBean("user");
        System.out.println(user);
    }

5、Spring5 支持整合 JUnit5

（1）整合 JUnit4

第一步引入 Spring 相关针对测试依赖

第二步创建测试类，使用注解完成

//spring5 支持整合junit4测试
@RunWith(SpringJUnit4ClassRunner.class) //单元测试框架
@ContextConfiguration("classpath:bean1.xml")    //加载配置文件
public class JUnit4Test {
    @Autowired
    private UserService userService;
@Test
    public void test1(){
    userService.account(new BigDecimal(100),"lucy","mary");
}
}

（2）Spring5 整合 JUnit5

第一步引入 JUnit5 的 jar 包

import org.junit.jupiter.api.Test;//导入Junit5的包

第二步创建测试类，使用注解完成

//演示spring5整合junit5

/*@ExtendWith(SpringExtension.class)
@ContextConfiguration("classpath:bean1.xml")*/

//使用一个复合注解(SpringJUnitConfig)替代上面两个注解完成整合
@SpringJUnitConfig(locations = "classpath:bean1.xml")
public class Junit5Test {
    @Autowired
    private UserService userService;

    @Test
    public void test1() {
        userService.account(new BigDecimal(100), "lucy", "mary");

    }
}

SpringWebflux

基于 springMVC springboot maven java8新特性

内容介绍

spring框架概述

spring5框架入门案例

IOC

IOC概念和底层原理

什么是IOC

IOC的底层原理

IOC操作Bean管理

什么是Bean管理（概念）

基于xml方式的bean管理

1、spring对象创建

2、基于xml方式注入属性

第一种注入方式：通过 set 方法注入

第二种注入方式 通过有参构造注入

p名称空间注入(了解 ，底层其实是set方法注入)

注入其他类型属性

外部bean

内部bean

级联赋值

注入集合类型的属性

FactoryBean

基本介绍：

如何实现 创建工厂bean

bean作用域

如何设置单实例和多实例

singleton和 prototype的区别

bean的生命周期

什么是生命周期

bean生命周期

演示bean生命周期

4、bean 的后置处理器，bean 生命周期有七步

xml自动装配

什么是自动装配

演示自动装配

xml配置外部属性文件

1、直接配置数据库信息

引入外部属性文件配置数据库连接池

基于注解方式的bean管理

什么是注解？

spring针对bean管理中创建对象提供注解

基于注解方式实现bean对象创建实例

组件扫描配置的细节

基于注解方式实现属性注入

完全注解开发

Aop

什么是aop

aop底层原理

AOP（JDK动态代理）

Aop的术语

AOP操作准备：

Aop操作-基于注解方式

Aop操作-基于AspectJ配置文件(用的较少)

JdbcTemplate

概念和准备

jdbcTemplate操作数据库（增改删）

jdbcTemplate操作数据库（查）

查询返回某个值

查询返回某个对象

查询返回某个集合

jdbcTemplate操作数据库（批量操作）

spring操作事务

事务

什么是事务？

事务的四个特性 (ACID)

事务操作环境搭建

spring事务管理介绍

注解声明式事务管理

声明式事务管理参数配置

propagation：事务传播行为 （面试会考）

isolation:事务隔离级别

基于xml方式进行声明式事务管理

基于完全注解开发实现声明式事务管理

spring5新特性

1、特点

2、Spring 5.0 框架自带了通用的日志封装

3、Spring5 框架核心容器支持@Nullable 注解

4、Spring5 核心容器支持函数式风格 GenericApplicationContext

5、Spring5 支持整合 JUnit5

（1）整合 JUnit4

（2）Spring5 整合 JUnit5

第二种注入方式通过有参构造注入

p名称空间注入(了解，底层其实是set方法注入)

如何实现创建工厂bean

propagation：事务传播行为（面试会考）