Spring简短回顾

课程介绍

Spring5
基本概念
IOC
AOP
JDBCTemplate
事务的管理
spring5的新特性

框架概述

轻量级开源的javaEE框架
spring解决企业应用开发的复杂性
两核心：
IOC：创建对象过程交给Spring进行管理
AOP：面向切面，不修改原代码来增强功能
特点：
方便解耦
AOP编程支持
对其他框架的整合
方便事务操作
降低api的开发难度

入门案例

导入基本包
beans
context
core
expression
因为需要依赖日志包，所以需要导入commons-logging包

创建普通类

public class User {
    public void add(){
        System.out.println("add............");
    }
}
1
2
3
4
5

创建对象
new User()
spring创建
在配置文件中创建对象（使用XML格式创建）


测试代码编写
加载配置文件
ApplicationContext context = new ClassPathXmlApplicationContext(“bean1.xml”);
获取配置问价对象
User user = context.getBean(“user”, User.class);
调用方法
System.out.println(user);
user.add();

IOC容器

控制反转：对象的创建以及调用都交给容器去管理
耦合度降低
入门案例的是实现
1
2
3

IOC底层原理

XML解析、工厂模式（解耦合）、反射 来实现

IOC的解耦过程：
第一步：xml配置文件，配置创建的对象
第二步：有service类和dao类，创建工厂类
xml解析（比如用dom4j）得到
通过反射创建对象

IOC接口(重要接口BeanFactory)

ApplicationContext context =
                new ClassPathXmlApplicationContext("bean1.xml");
1
2

BeanFaction context =
                new ClassPathXmlApplicationContext("bean1.xml");
1
2

BeanFactory：IOC容器基本实现，是Spring内部的使用接口，不是提供开发人员进行使用
特点：加载配置文件的时候不会去创建对象，在获取对象或者使用对象的时候才去创建对象
AppliationContext：BeanFactory接口的子接口，提供更多的更强大的功能，一般有开发人员进行使用
特点：加载配置文件时候就会在配置文件对象进行创建
AppliationContext：实现类的介绍（快捷键ctrl+alt+B）

IOC操作Bean（基于xml）

Bean管理：
创建对象
注入属性
Bean管理的操作
XML
创建对象
Bean标签中属性
id属性：对的的别名（唯一标识），通过它获得对象
class属性：包类路径
创建对象的时候默认使用无参构造方法
注入属性
DI：依赖注入，是IOC中的一种具体实现
set方法

<bean id="book" class="com.atguigu.spring5.Book" >
    <!-- <bean id="book" class="com.atguigu.spring5.Book" p:name="旧言真金" p:bauthor="独孤">-->
       <!-->注属性   使用prorerty完成属性的注入-->
      <property name="name" value="九阳神功"></property>
        <property name="bauthor" value="张无忌"></property>
         <!--设置空值-->
         <property name="address">
             <null/>
         </property>


         </bean>
1
2
3
4
5
6
7
8
9
10
11
12

有参的构造方法
创建一个类，定义一个属性

public class Orders {
    private String oname;//属性
    private  String address;//属性
    public Orders() {
    }
    public Orders(String oname, String address) {//有参构造
        this.oname = oname;
        this.address = address;
    }

    public void  orderTest(){
        System.out.println(oname+"::::"+address);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

用有参构造注入属性

 <!--有参构造注入属性-->
    <bean id="orders" class="com.atguigu.spring5.Orders">
        <constructor-arg name="oname" value="手机"></constructor-arg>
        <constructor-arg name="address" value="东莞"></constructor-arg>
    </bean>
1
2
3
4
5

P空称间注入

<bean id="book" class="com.atguigu.spring5.Book" p:name="旧言真金" p:bauthor="独孤">
1

特殊符号
CDATA
转义符号

注解 详解在下

Bean管理，注入内部bean和级联赋值

外部Bean：（mvc三层之间调用）
创建 两个类：service类和dao类
service调用dao里面的方法
在spring配置文件中进行配置

 <bean id="userService" class="com.atguigu.spring5.service.UserService">
        <property name="userDao" ref="userDaoIpml"></property>
    </bean>
    <bean id="userDaoIpml"  class="com.atguigu.spring5.dao.UserDaoImpl"></bean>
1
2
3
4

内部Bean和级联赋值:
一对多关系：部门和员工的关系

 <!--内部bean-->
    <bean id="emp" class="com.atguigu.spring5.bean.Emp">
        <!--设置两个普通属性-->
        <property name="ename" value="lucy"></property>
        <property name="gender" value="女"></property>
        <!--对象类型的实属性-->
        <property name="dept">
            <bean id="dept" class="com.atguigu.spring5.bean.Dept">
                <property name="dname" value="安保部"></property>
            </bean>
        </property>
1
2
3
4
5
6
7
8
9
10
11

Bean管理-注入集合类型属性

注入数组、List、Map
创建类定义上述类型的属性以及对应的set方法

public class Stu {
    //数组类型的属性
    private String[] course;
//    List集合类型的属性
    private List<String> list;
//    创建map集合类型属性
    private Map<String,String> maps;
//    set集合的类型属性
    private Set<String> sets;
    //学生所学多门课程
    private List<Course> courseList;
    public void setCourseList(List<Course> courseList) {
        this.courseList = courseList;
    }
    public void setSets(Set<String> sets) {
        this.sets = sets;
    }
    public void setCourse(String[] course) {
        this.course = course;
    }
    public void setList(List<String> list) {
        this.list = list;
    }
    public void setMaps(Map<String, String> maps) {
        this.maps = maps;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

Bean.xml

<bean id="stu" class="com.atguigu.spring5.collectiontype.Stu">
        <!--数组类型属性注入-->
        <property name="course" >
            <array>
                <value>java课程</value>
                <value>数据库课程</value>
            </array>
        </property>
        <!--list类型属性注入-->
        <property name="list">
            <list>
                <value>张三</value>
                <value>小三</value>
            </list>
        </property>
        <!--map类型属性注入-->
        <property name="maps">
            <map>
                <entry key="JAVA" value="java"></entry>
                <entry key="PHP" value="php"></entry>
            </map>
        </property>
        <!--set类型属性注入-->
        <property name="sets">
            <set>
                <value>MySQL</value>
                <value>Redis</value>
            </set>
        </property>
        <!--注入list集合类型，值是对象-->
        <property name="courseList">
            <list>
                <ref bean="course1"></ref>
                <ref bean="course2"></ref>
            </list>
        </property>
     </bean>
      <!--创建多个course对象-->
    <bean id="course1" class="com.atguigu.spring5.collectiontype.Course">
        <property name="cname" value="Spring5框架"></property>
    </bean>
    <bean id="course2" class="com.atguigu.spring5.collectiontype.Course">
        <property name="cname" value="MyBatis框架"></property>
    </bean>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

测试：

@Test
    public  void testCollection(){
        ApplicationContext context =
                new ClassPathXmlApplicationContext("bean1.xml");
        Stu stu = context.getBean("stu", Stu.class);
        stu.test();
1
2
3
4
5
6

结果：

FactoryBean

Spring Bean 分为两种，普通Bean,一种为工厂Bean(FactoryBean)
普通Bean：与配置文件定义的一样
工厂Bean：可以不一样
定义工厂Bean:
创建类，让这个类作为bean，实现接口FactoryBean
实现接口里面的方法，在实现的方法中定义返回bean类型

Bean作用域

单实例、多实例、Request、session

Bean的生命周期

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

1. 通过构造器创建bean实例（无参构造器）
2. 为bean的属性设置值和对其他bean引用（调用set方法）
   把bean的实例传递给bean后置处理器方法postProcessBeforeInitialization
3. 调用bean的初始化的方法（需要进行配置初始化的方法）
   把bean的实例传递给bean后置处理器方法postProcessAfterInitialization
4. bean可以使用了（对象获取到了）
5. 当容器关闭的时候，调用bean的销毁方法（需要自己进行配置销毁的方法）

XML自动装配

手动装配

<property name="oname" value="手机"></property>
1

自动装配
根据指定的装配规则，Spring自动将匹配的属性值进行注入

• 根据属性名称
• 根据属性类型

引入外部的属性文件

全览图

IOC操作Bean管理(基于注解)

什么是注解：
注解时代码特殊标记，格式：@注解名称（属性=属性值……）
使用注解，注解使用在类上面、方法上面、属性上面
使用注解目的：简化xml配置

使用注解创建对象

1. 引入依赖，与上面相比加入aop依赖
   
2. 开启组件扫描（告诉容器哪个类上要扫描）
   
3. 创建类，在类上面添加创建对象的注解
   
4. 测试
   
5. 分析流程
   加载配置文件时候，发现配置文件里面只有开启文件扫描，就会在配置的包里面找到包中的所有类
   如果类上有注解，就会把该类的对象创建
   创建好的对象调用该类的方法

组件扫描配置

开启组件扫描细节配置

可以设置扫描哪些注解的类

注解实现属性注入

@AutoWired：根据属性类型进行自动装配
@Qualifier：根据属性名称进行注入
@Resource：可以根据类型注入，可以根据名称注入
@Value：注入普通类型属性

完全注解开发（SpringBoot）

不用配置文件，而用配置类来替代

AOP

AOP基本概念

面向切面编程，可以用AOP对业务逻辑的各个部分进行隔离，使得业务逻辑各部分之间耦合度降低，提高程序的可重用性，提高开发效率

AOP底层原理

动态代理
有接口：jdk动态代理
创建接口实现类的代理对象，增强类里的方法
没有接口：CGLIB动态代理
创建当前类子类的代理对象，增强类里的方法

AOP术语

连接点：类里面的方法哪些可以被增强，这些方法就称为连接点
切入点：实际真正增强的方法
通知（增强）：增强的逻辑部分
切面：是动作，把通知应用到切入点的过程

AspectJ

用他来实现Aop操作
基于XML实现
基于注解方式实现
先引入依赖

切入点表达式
语法结构

exection([权限修饰符] [返回类型]  [类全名称] （[参数列表]）)
1

事务操作

事务是数据库操作的最基本单元，逻辑上的一组数据，要么都成功，如果有一个失败所有操作都失败
Spring 进行事务：
编程式
声明式：基于注解、基于xml配置文件：底层使用AOP原理

事务里面针对事务详细的配置
声明式事务管理参数配置

==================================================================================================================================================================================================================
Spring中的事务
三大基础设施：
PlatformTransactionManager
TransactionDefinition
TransactionStatus

事务传播行为

当一个事务被另外一个事务调用时，这个事务方法该如何进行（七种）

						required：**方法2开启事务A，调用方法1，方法1加入当前事务A里面**
						required_new ：**当前的方法必须启动新事务，并在他自己的事务内运行，如果有事务正在运行，应该将他挂起**
						supports：**如果有事务在运行，当前的方法就在这个事务运行，否则他可以不运行在事务中**
1
2
3

隔离级别

脏读、不可重复读、幻读
读未提交、读已提交、可重复读、串行化

超时时间

事务在一定时间要提交，否则回滚。默认-1

是否只读

读：查询操作
写：添加修改删除操作

回滚

不回滚