Spring

简介

概述

        官网地址：https://spring.io/

        Spring是最受欢迎的企业级Java应用程序开发框架，数以百万的来自世界各地的开发人员使用Spring框架来创建性能好、易于测试、可重用的代码。

        Spring框架是一个开源的Java平台，它最初是由Rod Johnson编写的，并且于2003年6月首次在Apache 2.0许可下发布。

        Spring是轻量级的框架，其基础版本只有 2 MB 左右的大小。

        Spring框架的核心特性是可以用于开发任何Java应用程序，但是在 Java EE 平台上构建web 应用程序是需要扩展的。Spring框架的目标是使J2EE开发变得更容易使用，通过启用基于POJO编程模型来促进良好的编程实践。

Spring家族

        项目列表：https://spring.io/projects

Spring Framework

        Spring基础框架，可以视为Spring基础设施，基本上任何其他Spring项目都是以Spring Framework为基础的。

特性

        非侵入式：使用 Spring Framework 开发应用程序时，Spring 对应用程序本身的结构影响非常小。对领域模型可以做到零污染；对功能性组件也只需要使用几个简单的注解进行标记，完全不会破坏原有结构，反而能将组件结构进一步简化。这就使得基于 Spring Framework 开发应用程序时结构清晰、简洁优雅。

        控制反转：IOC——Inversion of Control，翻转资源获取方向。把自己创建资源、向环境索取资源变成环境将资源准备好，我们享受资源注入。面向切面编程：AOP——Aspect Oriented Programming，在不修改源代码的基础上增强代码功能。

        容器：Spring IOC 是一个容器，因为它包含并且管理组件对象的生命周期。组件享受到了容器化的管理，替程序员屏蔽了组件创建过程中的大量细节，极大的降低了使用门槛，大幅度提高了开发效率。

        组件化：Spring 实现了使用简单的组件配置组合成一个复杂的应用。在 Spring 中可以使用 XML和 Java 注解组合这些对象。这使得我们可以基于一个个功能明确、边界清晰的组件有条不紊的搭建超大型复杂应用系统。

        声明式：很多以前需要编写代码才能实现的功能，现在只需要声明需求即可由框架代为实现。

        一站式：在 IOC 和 AOP 的基础上可以整合各种企业应用的开源框架和优秀的第三方类库。而且Spring 旗下的项目已经覆盖了广泛领域，很多方面的功能性需求可以在 Spring Framework 的基础上全部使用 Spring 来实现。

五大功能模块

模块	介绍
Core Container	核心容器，在 Spring 环境下使用任何功能都必须基于 IOC 容器。
AOP&Aspects	面向切面编程
Testing	提供了对 junit 或 TestNG 测试框架的整合。
Data Access/Integration	提供了对数据访问/集成的功能。
Spring MVC	提供了面向Web应用程序的集成功能。

IOC

IOC容器

IOC思想

        IOC：Inversion of Control，翻译过来是反转控制。

①获取资源的传统方式

        在应用程序中的组件需要获取资源时，传统的方式是组件主动的从容器中获取所需要的资源，在这样的模式下开发人员往往需要知道在具体容器中特定资源的获取方式，增加了学习成本，同时降低了开发效率

②反转控制方式获取资源

        反转控制的思想完全颠覆了应用程序组件获取资源的传统方式：反转了资源的获取方向——改由容器主动的将资源推送给需要的组件，开发人员不需要知道容器是如何创建资源对象的，只需要提供接收资源的方式即可，极大的降低了学习成本，提高了开发的效率。这种行为也称为查找的被动形式。

③DI

        DI：Dependency Injection，翻译过来是依赖注入。

        DI 是 IOC 的另一种表述方式：即组件以一些预先定义好的方式（例如：setter 方法）接受来自于容器的资源注入。相对于IOC而言，这种表述更直接。

        IOC 就是一种反转控制的思想， 而 DI 是对 IOC 的一种具体实现。

IOC容器在Spring中的实现

        Spring 的 IOC 容器就是 IOC 思想的一个落地的产品实现。IOC 容器中管理的组件也叫做 bean。在创建bean 之前，首先需要创建 IOC 容器。Spring 提供了 IOC 容器的两种实现方式：

        BeanFactory：这是 IOC 容器的基本实现，是 Spring 内部使用的接口。面向 Spring 本身，不提供给开发人员使用。

        ApplicationContext：BeanFactory 的子接口，提供了更多高级特性。面向 Spring 的使用者，几乎所有场合都使用ApplicationContext 而不是底层的 BeanFactory。

ApplicationContext的主要实现类

类型名	简介
ClassPathXmlApplicationContext	通过读取类路径下的 XML 格式的配置文件创建 IOC 容器对象
FileSystemXmlApplicationContext	通过文件系统路径读取 XML 格式的配置文件创建 IOC 容器对象
ConfigurableApplicationContext	ApplicationContext 的子接口，包含一些扩展方法refresh() 和 close() ，让ApplicationContext 具有启动、关闭和刷新上下文的能力。
WebApplicationContext	专门为 Web 应用准备，基于 Web 环境创建 IOC 容器对象，并将对象引入存入 ServletContext 域中。

基于XML管理bean

入门案例

        引入依赖

<dependencies>
    <!-- 基于Maven依赖传递性，导入spring-context依赖即可导入当前所需所有jar包 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.3.1</version>
    </dependency>
    <!-- junit测试 -->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.13.2</version>
        <scope>test</scope>
    </dependency>
</dependencies>

        创建类

public class People {

    public void sayHello(){
        System.out.println("I come here.");
    }

    //...
}}

         *Spring底层默认通过反射技术调用组件类的无参构造器来创建组件对象。如果在需要无参构造器时，没有无参构造器，则会抛出异常

        创建Spring配置文件

        在resources中创建Spring配置文件，名称目前可以随意起(之后在SSM整合中Spring配置文件默认的名字叫applicationContext)

        在Spring的配置文件中配置bean

<!--
    配置People所对应的bean，即将People的对象交给Spring的IOC容器管理
    通过bean标签配置IOC容器所管理的bean 
    属性：
        id：设置bean的唯一标识 
        class：设置bean所对应类型的全类名 
-->
<bean id="people" class="com.GLATY.studySpring.pojo.People"/>

        测试

@Test
public void Test1() {
    //获取IOC容器
    ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");
    //获取IOC对象
    People people = (People) ioc.getBean("people");
    people.sayHello();
}

获取bean

        获取bean有三种方式，可以根据bean的id、类型、id和类型获取

        根据id获取

        由于id属性指定了bean的唯一标识，所以根据bean标签的 id 属性可以精确获取到一个组件对象。根据id获取到的类型是object类

People people = (People) ioc.getBean("people");

        根据类型获取

        获取到的类型是所需要的类

People people = ioc.getBean(People.class);

        *如果有多个bean的类型相同，则不能通过类型获取，不然会报错。如果所需要的类型没有所匹配的bean也会报错

        根据id和类型获取

        获取到的类型是所需要的类

People people = ioc.getBean("people", People.class);

***

        如果组件类实现了接口，在bean是唯一的情况下可以根据接口类型获取bean。如果一个接口有多个实现类，这些实现类都配置了bean，不可以根据接口类型获取bean。因为bean不唯一

        根据类型来获取bean时，在满足bean唯一性的前提下，其实只是看：『对象 instanceof 指定的类型』的返回结果，只要返回的是true就可以认定为和类型匹配，能够获取到。

依赖注入

        set注入

        使用property标签

<bean id="people" class="com.GLATY.studySpring.pojo.People">
    <!-- property标签：通过组件类的setXxx()方法给组件对象设置属性 -->
    <!-- name属性：指定属性名(这个属性名是getXxx()、setXxx()方法定义的，和成员变量无关) -->
    <!-- value属性：指定属性值 -->
    <property name="name" value="杳无此人"/>
    <property name="age" value="0"/>
    <property name="sex" value="？"/>
</bean>

        构造器注入

         使用constructor-arg标签

<bean id="people" class="com.GLATY.studySpring.pojo.People">
    <constructor-arg name="name" value="杳无此人"/>
    <constructor-arg name="age" value="0"/>
    <constructor-arg name="sex" value="？"/>
    <?--当所使用的构造器参数个数与其它构造器参数个数都不同时name属性可以省略，但value要按顺序写-->
    <?--
        constructor-arg标签还有两个属性可以进一步描述构造器参数：
            index属性：指定参数所在位置的索引（从0开始）
            name属性：指定参数名
    -->
</bean>

特殊值处理

        字面量赋值

        使用value属性给bean的属性赋值时，Spring会把value属性的值看做字面量

        null值

<property name="name"><null/></property>

        xml实体类

        小于号在XML文档中用来定义标签的开始，不能随便使用。可以使用XML实体来代替，也可以使用CDATA节

<?--使用XML实体-->
<property name="expression" value="a &lt; b"/>
<?--使用CDATA节-->
<value><![CDATA[a < b]]></value>

为类类型属性赋值

        数据准备

         创建Species类

public class Species {
    private String speciesName;
    private int instanceNumber;
    //...
}

        在People类中加入Species属性

public class People {
    private String name;
    private String sex;
    private int age;
    private Species species;
    //...
}

        方法一：引用外部类

        配置Species类型的bean

<bean id="species" class="com.GLATY.studySpring.pojo.Species">
    <property name="speciesName" value="people"/>
    <property name="instanceNumber" value="0"/>
</bean>

        为People配置Species时使用ref属性指向Species类型bean的id

<bean id="people" class="com.GLATY.studySpring.pojo.People">
    <property name="name"><null/></property>
    <property name="age" value="0"/>
    <property name="sex" value="？"/>
    <property name="species" ref="species"/>
</bean>

        如果错把ref属性写成了value属性，会抛出异常

        方法二：创建内部bean

<bean id="people" class="com.GLATY.studySpring.pojo.People">
    <property name="name">
        <null/>
    </property>
    <property name="age" value="0"/>
    <property name="sex" value="？"/>
    <property name="species">
        <!-- 在一个bean中再声明一个bean就是内部bean -->
        <!-- 内部bean只能用于给属性赋值，不能在外部通过IOC容器获取，因此可以省略id属性 -->
        <bean class="com.GLATY.studySpring.pojo.Species">
            <property name="speciesName" value="people"/>
            <property name="instanceNumber" value="0"/>
        </bean>
    </property>
</bean>

        方法三：级联

<bean id="people" class="com.GLATY.studySpring.pojo.People">
    <property name="name">
        <null/>
    </property>
    <property name="age" value="0"/>
    <property name="sex" value="？"/>
    <!-- 一定先引用某个bean为属性赋值，才可以使用级联方式更新属性 -->
    <property name="species" ref="species"/>
    <property name="species.speciesName" value="people"/>
    <property name="species.instanceNumber" value="0"/>
</bean>

为数组类型属性赋值

        数据准备

        为People添加hobby属性

public class Species {
    private String speciesName;
    private int instanceNumber;
    private Species[] instance;
}

        配置bean

        使用array标签

<bean id="people" class="com.GLATY.studySpring.pojo.People">
    <property name="name">
        <null/>
    </property>
    <property name="age" value="0"/>
    <property name="sex" value="？"/>
    <!-- 一定先引用某个bean为属性赋值，才可以使用级联方式更新属性 -->
    <property name="species" ref="species"/>
    <property name="hobby">
        <array>
            <value>study</value>
            <value>run</value>
            <value>play game</value>
        </array>
    </property>
</bean>

为集合类型属性赋值

        为List集合类型属性赋值

        为Species添加Instance属性(把People的bean里的Species去除，不然会一直循环最后报错)

public class Species {
    private String speciesName;
    private int instanceNumber;
    private List<People> instance;
}

        使用list标签

<bean id="species" class="com.GLATY.studySpring.pojo.Species">
    <property name="speciesName" value="people"/>
    <property name="instanceNumber" value="2"/>
    <property name="instance">
        <list>
            <ref bean="people"/>
            <ref bean="peopleOther"/>
        </list>
    </property>
</bean>

若为Set集合类型属性赋值，只需要将其中的list标签改为set标签即可

        为map集合类型属性赋值

        为People添加friends属性

public class People {
    private String name;
    private String sex;
    private int age;
    private Species species;
    private String[] hobby;
    private Map<String, People> friends;
}

         使用map标签

<bean id="people" class="com.GLATY.studySpring.pojo.People">
    <property name="name">
        <null/>
    </property>
    <property name="age" value="0"/>
    <property name="sex" value="？"/>
    <property name="hobby">
        <array>
            <value>study</value>
            <value>run</value>
            <value>play game</value>
        </array>
    </property>
    <property name="friends">
        <map>
            <entry key="1" value-ref="peopleOther"/>
            <entry key="2" value-ref="peopleOther"/>
        </map>
    </property>
</bean>

        引用集合类型的bean

        list集合类型的bean

<util:list id="peopleList">
    <ref bean="people"/>
    <ref bean="peopleOther"/>
</util:list>

        map集合类型的bean

<util:map id="peopleMap">
    <entry key="1" value-ref="people"/>
    <entry key="2" value-ref="peopleOther"/>
</util:map>

        使用util:list、util:map标签必须引入相应的命名空间，可以通过idea的提示功能选择

P命名空间

        引入p命名空间后，可以通过 p: 方式为bean的各个属性赋值

<bean id="peopleP" class="com.GLATY.studySpring.pojo.People"
      p:name="name" p:age="0" p:sex="_" />

管理数据源引入外部属性文件

        加入依赖

<!-- MySQL驱动 -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.33</version>
</dependency>
<!-- 数据源 -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.0.31</version>
</dependency>

        创建外部属性文件

jdbc.drive=com.mysql.cj.jdbc.Driver
jdbc.rel=jdbc:mysql://localhost:3306/secondData?serverTimezone=UTC
jdbc.username=root
jdbc.password=123456

        引入属性文件

<!-- 引入jdbc.properties，之后可以通过${}的方式访问value -->
<context:property-placeholder location="jdbc.properties"/>

        配置bean

<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
    <property name="driverClassName" value="${jdbc.drive}"/>
    <property name="url" value="${jdbc.rel}"/>
    <property name="username" value="${jdbc.username}"/>
    <property name="password" value="${jdbc.password}"/>
</bean>

bean的作用域

        在Spring中可以通过配置bean标签的scope属性来指定bean的作用域范围，各取值含义参加下表：

取值	含义	创建对象的时机
singleton （默认）	在 IOC 容器中，这个 bean 的对象始终为单实例	IOC 容器初始化时
prototype	这个 bean 在 IOC 容器中有多个实例	获取 bean 时

        如果是在WebApplicationContext环境下还会有另外两个作用域（但不常用）：

取值	含义
request	在一个请求范围内有效
session	在一个会话范围内有效

bean生命周期

        具体的生命周期过程

• bean对象创建（调用无参构造器）
• 给bean对象设置属性
• bean对象初始化之前操作（由bean的后置处理器负责）
• bean对象初始化（需在配置bean时使用init-method属性指定初始化方法）
• bean对象初始化之后操作（由bean的后置处理器负责）
• bean对象就绪可以使用
• bean对象销毁（需在配置bean时使用destroy-method属性指定销毁方法，IOC容器关闭时bean对象才销毁）
• IOC容器关闭

<bean id="species" class="com.GLATY.studySpring.pojo.Species" init-method="initMethod" destroy-method="destroyMethod">
    <property name="speciesName" value="people"/>
    <property name="instanceNumber" value="2"/>
    <property name="instance">
        <list>
            <ref bean="people"/>
            <ref bean="peopleOther"/>
        </list>
    </property>
</bean>

*若bean的作用域为单例时，生命周期的前三个步骤会在获取IOC容器时执行

若bean的作用域为多例时，生命周期的前三个步骤会在获取bean时执行，且不会执行销毁方法

        bean的后置处理器

        bean的后置处理器会在生命周期的初始化前后添加额外的操作，需要实现BeanPostProcessor接口，且配置到IOC容器中，需要注意的是，bean后置处理器不是单独针对某一个bean生效，而是针对IOC容器中所有bean都会执行

创建bean的后置处理器：

public class MyBeanProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        //此方法在bean的生命周期初始化之前执行
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        //此方法在bean的生命周期初始化之后执行
        return bean;
    }
}

在IOC容器中配置后置处理器：

<!-- bean的后置处理器要放入IOC容器才能生效 -->
<bean id="myBeanProcessor" class="com.GLATY.studySpring.pojo.MyBeanProcessor"/>

FactoryBean

        简介

        FactoryBean是Spring提供的一种整合第三方框架的常用机制。和普通的bean不同，配置一个FactoryBean类型的bean，在获取bean的时候得到的并不是class属性中配置的这个类的对象，而是getObject()方法的返回值。通过这种机制，Spring可以帮我们把复杂组件创建的详细过程和繁琐细节都屏蔽起来，只把最简洁的使用界面展示给我们。

        将来我们整合Mybatis时，Spring就是通过FactoryBean机制来帮我们创建SqlSessionFactory对象的。

        步骤

创建类

        FactoryBean是一个接口，需要创建一个类实现接口
        有三个方法：
                getObject()：通过一个对象交给ioc容器管理
                getObjectType()：设置所提供对象的类型
                isSingleton()：所提供的对象是否单例(默认为true)

public class PeopleFactoryBean implements FactoryBean<People> {

    @Override
    public People getObject() throws Exception {
        return new People();
    }

    @Override
    public Class<?> getObjectType() {
        return People.class;
    }
}

配置bean

<bean id="peopleFactoryBean.java" class="com.GLATY.studySpring.factory.PeopleFactoryBean"/>

测试

@Test
public void Test6() {
    //获取IOC容器
    ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");
    //获取IOC对象
    People people = ioc.getBean(People.class);
    System.out.println(people);
}

基于xml的自动装配

        自动装配：根据指定的策略，在IOC容器中匹配某一个bean，自动为指定的bean中所依赖的类类型或接口类型属性赋值

        数据准备

创建类PeopleController 

public class PeopleController {

    private PeopleServiceImpl peopleService;

    public PeopleServiceImpl getPeopleService() {
        return peopleService;
    }

    public void setPeopleService(PeopleServiceImpl peopleService) {
        this.peopleService = peopleService;
    }

    public void savePeople(){
        peopleService.savePeople();
    }
}

创建接口PeopleService 

public interface PeopleService {
    void savePeople();
}

创建类PeopleService 实现接口PeopleService 

public class PeopleServiceImpl implements PeopleService {

    private PeopleDaoImpl peopleDao;

    public PeopleDaoImpl getPeopleDao() {
        return peopleDao;
    }

    public void setPeopleDao(PeopleDaoImpl peopleDao) {
        this.peopleDao = peopleDao;
    }

    @Override
    public void savePeople() {
        peopleDao.savePeople();
    }
}

创建接口PeopleDao 

public interface PeopleDao {
    void savePeople();
}

创建类PeopleDao实现接口PeopleDao 

public class PeopleDaoImpl implements PeopleDao {
    @Override
    public void savePeople() {
        System.out.println("success");
    }
}

        配置bean

        使用bean标签的autowire属性设置自动装配效果

<!--
    自动装配方式：byType     
    byType：根据类型匹配IOC容器中的某个兼容类型的bean，为属性自动赋值
    若在IOC中，没有任何一个兼容类型的bean能够为属性赋值，则该属性不装配，即值为默认值null
    若在IOC中，有多个兼容类型的bean能够为属性赋值，则会抛出异常。
-->
<bean class="com.GLATY.studySpring.controller.PeopleController" autowire="byType"/>

<!--
    自动装配方式：byName
    byName：将自动装配的属性的属性名，作为bean的id在IOC容器中匹配相对应的bean进行赋值
-->
<bean id="peopleService" class="com.GLATY.studySpring.service.impl.PeopleServiceImpl" autowire="byName"/>

<bean id="peopleDao" class="com.GLATY.studySpring.dao.impl.PeopleDaoImpl"/>

基于注解管理bean

标记与扫描

        标记

标识组件的常用注解

• @Component：将类标识为普通组件
• @Controller：将类标识为控制层组件
• @Service：将类标识为业务层组件
• @Repository：将类标识为持久层组件

        @Controller、@Service、@Repository只是在@Component注解的基础上起了三个新的名字。对于Spring使用IOC容器管理这些组件来说并没有区别。所以@Controller、@Service、@Repository这三个注解只是给开发人员看的，让我们能够便于分辨组件的作用。

        虽然它们本质上一样，但是为了代码的可读性，为了程序结构严谨我们肯定不能随便胡乱标记。

        创建组件

创建控制层组件

@Controller
public class UserController {
}

创建接口UserService

public interface UserService {
}

创建业务层组件UserServiceImpl

@Service
public class UserServiceImpl implements UserService {
}

创建接口UserDao

public interface UserDao {
}

创建持久层组件UserDaoImpl

@Repository
public class UserDaoImpl implements UserDao {
}

扫描组件

情况一：最基本的扫描方式

<context:component-scan base-package="com.GLATY.studySpring"/>

情况二：指定要排除的组件

<context:component-scan base-package="com.GLATY.studySpring">
    <!-- context:exclude-filter标签：指定排除规则 -->
    <!--
        type：设置排除或包含的依据
        type="annotation"，根据注解排除，expression中设置要排除的注解的全类名
        type="assignable"，根据类型排除，expression中设置要排除的类型的全类名
    -->
    <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

情况三：仅扫描指定组件

<context:component-scan base-package="com.GLATY.studySpring">
    <!-- context:include-filter标签：指定在原有扫描规则的基础上追加的规则 -->
    <!-- use-default-filters属性：取值false表示关闭默认扫描规则 -->
    <!-- 此时必须设置use-default-filters="false"，因为默认规则即扫描指定包下所有类 -->
    <!--
        type：设置排除或包含的依据
        type="annotation"，根据注解排除，expression中设置要排除的注解的全类名
        type="assignable"，根据类型排除，expression中设置要排除的类型的全类名
    -->
    <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

组件所对应的bean的id

        在我们使用XML方式管理bean的时候，每个bean都有一个唯一标识，便于在其他地方引用。现在使用注解后，每个组件仍然应该有一个唯一标识。

        默认情况：类名首字母小写就是bean的id。例如：UserController类对应的bean的id就是userController。

        自定义bean的id：可通过标识组件的注解的value属性设置自定义的bean的id

@Controller("controller")
public class UserController {
}

基于注解的自动装配

        @Autowired注解 

        ●在成员变量上直接标记@Autowired注解即可完成自动装配，不需要提供setXxx()方法。

        ●@Autowired注解可以标记在构造器和set方法上

@Autowired
private UserDao userDao;

@Autowired
public UserServiceImpl(UserDao userDao) {
    this.userDao = userDao;
}

@Autowired
public void setUserDao(UserDao userDao) {
    this.userDao = userDao;
}

        @Autowired工作流程

@Autowired工作流程

首先根据所需要的组件类型到IOC容器中查找
        能够找到唯一的bean：直接执行装配
        如果完全找不到匹配这个类型的bean：装配失败
        和所需类型匹配的bean不止一个
                没有@Qualifier注解：根据@Autowired标记位置成员变量的变量名作为bean的id进行匹配。能够找到则执行装配，找不到则装配失败
                使用@Qualifier注解：根据@Qualifier注解中指定的名称作为bean的id进行匹配。能够找到则执行装配，找不到则装配失败

*@Autowired中有属性required，默认值为true，因此在自动装配无法找到相应的bean时，会装配失败。可以将属性required的值设置为true，则表示能装就装，装不上就不装，此时自动装配的属性为默认值（但是实际开发时，基本上所有需要装配组件的地方都是必须装配的）

AOP

代理模式

概念

        二十三种设计模式中的一种，属于结构型模式。它的作用就是通过提供一个代理类，让我们在调用目标方法的时候，不再是直接对目标方法进行调用，而是通过代理类间接调用。让不属于目标方法核心逻辑的代码从目标方法中剥离出来——解耦。调用目标方法时先调用代理对象的方法，减少对目标方法的调用和打扰，同时让附加功能能够集中在一起也有利于统一维护。

        代理：将非核心逻辑剥离出来以后，封装这些非核心逻辑的类、对象、方法。
        目标：被代理“套用”了非核心逻辑代码的类、对象、方法。

数据准备

声明计算器接口Calculator

public interface Calculator {

    int add(int i, int j);

    int sub(int i, int j);

    int mul(int i, int j);

    int div(int i, int j);
}

创建实现类

public class CalculatorImpl implements Calculator {
    @Override
    public int add(int i, int j) {
        int result = i + j;
        System.out.println("结果是:" + result);
        return result;
    }

    @Override
    public int sub(int i, int j) {
        int result = i - j;
        System.out.println("结果是:" + result);
        return result;
    }

    @Override
    public int mul(int i, int j) {
        int result = i * j;
        System.out.println("结果是:" + result);
        return result;
    }

    @Override
    public int div(int i, int j) {
        int result = i / j;
        System.out.println("结果是:" + result);
        return result;
    }
}

静态代理

        创建静态代理类

public class CalculatorStaticProxy implements Calculator {

    // 将被代理的目标对象声明为成员变量
    private CalculatorImpl target;

    public CalculatorStaticProxy(CalculatorImpl target) {
        this.target = target;
    }

    @Override
    public int add(int i, int j) {
        // 附加功能由代理类中的代理方法来实现
        System.out.println("[日志] add 方法开始了，参数是：" + i + "," + j);
        // 通过目标对象来实现核心业务逻辑
        int addResult = target.add(i, j);
        System.out.println("[日志] add 方法结束了，结果是：" + addResult);
        return addResult;
    }

    @Override
    public int sub(int i, int j) {
        System.out.println("[日志] sub 方法开始了，参数是：" + i + "," + j);
        int subResult = target.sub(i, j);
        System.out.println("[日志] sub 方法结束了，结果是：" + subResult);
        return subResult;
    }

    @Override
    public int mul(int i, int j) {
        System.out.println("[日志] mul 方法开始了，参数是：" + i + "," + j);
        int mulResult = target.mul(i, j);
        System.out.println("[日志] mul 方法结束了，结果是：" + mulResult);
        return mulResult;
    }

    @Override
    public int div(int i, int j) {
        System.out.println("[日志] div 方法开始了，参数是：" + i + "," + j);
        int divResult = target.div(i, j);
        System.out.println("[日志] div 方法结束了，结果是：" + divResult);
        return divResult;
    }
}

动态代理

        动态代理有两种， jdk动态代理和cglib动态代理

        ●jdk动态代理：要求必须有接口，最终生成的代理类和目标类实现相同的接口在com.sun.proxy包下，类名为$proxy2

        ●cglib动态代理：最终生成的代理类会继承目标类，并且和目标类在相同的包下

        下列代码为jdk动态代理

创建生产代理对象的工厂类：

public class ProxyFactory {
    private Object target;

    public ProxyFactory(Object target) {
        this.target = target;
    }

    public Object getProxy() {
        /*
        * newProxyInstance()：创建一个代理实例 * 其中有三个参数：
        * 1、classLoader：加载动态生成的代理类的类加载器
        * 2、interfaces：目标对象实现的所有接口的class对象所组成的数组
        * 3、invocationHandler：设置代理对象实现目标对象方法的过程，即代理类中如何重写接 口中的抽象方法
        */
        ClassLoader classLoader = this.getClass().getClassLoader();
        Class<?>[] interfaces = target.getClass().getInterfaces();
        InvocationHandler invocationHandler = new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                /*
                * proxy：代理对象
                * method：代理对象需要实现的方法，即其中需要重写的方法
                * args：method所对应方法的参数
                */
                Object result = null;
                try {
                    System.out.println("[动态代理][日志] " + method.getName() + "，参 数：" + Arrays.toString(args));
                    result = method.invoke(target, args);
                    System.out.println("[动态代理][日志] " + method.getName() + "，结 果：" + result);
                } catch (Exception e) {
                    System.out.println("[动态代理][日志] " + method.getName() + "，异 常：" + e.getMessage());
                } finally {
                    System.out.println("[动态代理][日志] " + method.getName() + "，方法 执行完毕");
                }
                return result;
            }
        };
        return Proxy.newProxyInstance(classLoader, interfaces, invocationHandler);
    }
}

测试

@Test
public void Test10() {
    ProxyFactory proxyFactory = new ProxyFactory(new CalculatorImpl());
    Calculator proxy = (Calculator) proxyFactory.getProxy();
    proxy.add(1, 2);
}

AOP概念及相关术语

概述

        AOP（Aspect Oriented Programming）是一种设计思想，是软件设计领域中的面向切面编程，它是面向对象编程的一种补充和完善，它以通过预编译方式和运行期动态代理方式实现在不修改源代码的情况下给程序动态统一添加额外功能的一种技术。

相关术语

        ①横切关注点 

        从每个方法中抽取出来的同一类非核心业务。在同一个项目中，我们可以使用多个横切关注点对相关方 法进行多个不同方面的增强。

        这个概念不是语法层面天然存在的，而是根据附加功能的逻辑上的需要：有十个附加功能，就有十个横 切关注点。

        ②通知

每一个横切关注点上要做的事情都需要写一个方法来实现，这样的方法就叫通知方法。

        ● 前置通知：在被代理的目标方法前执行

        ● 返回通知：在被代理的目标方法成功结束后执行（ 寿终正寝 ）

        ● 异常通知：在被代理的目标方法异常结束后执行（ 死于非命 ）

        ● 后置通知：在被代理的目标方法最终结束后执行（ 盖棺定论 ）

        ● 环绕通知：使用try...catch...finally结构围绕 整个 被代理的目标方法，包括上面四种通知对应的所有位置

        ③切面

封装通知方法的类。

        ④目标

        被代理的目标对象。

        ⑤代理

        向目标对象应用通知之后创建的代理对象。

        ⑥连接点

        这也是一个纯逻辑概念，不是语法定义的。

        把方法排成一排，每一个横切位置看成x轴方向，把方法从上到下执行的顺序看成y轴，x轴和y轴的交叉点就是连接点。

        ⑦切入点

• 定位连接点的方式。
• 每个类的方法中都包含多个连接点，所以连接点是类中客观存在的事物（从逻辑上来说）。
• 如果把连接点看作数据库中的记录，那么切入点就是查询记录的 SQL 语句。
• Spring 的 AOP 技术可以通过切入点定位到特定的连接点。
• 切点通过 org.springframework.aop.Pointcut 接口进行描述，它使用类和方法作为连接点的查询条件。

作用

        简化代码：把方法中固定位置的重复的代码抽取出来，让被抽取的方法更专注于自己的核心功能，提高内聚性。

        代码增强：把特定的功能封装到切面类中，看哪里有需要，就往上套，被套用了切面逻辑的方法就被切面给增强了。

基于注解的AOP

        AOP是一种思想，AspectJ是这种思想的一个实现

数据准备

添加依赖

<!-- spring-aspects会帮我们传递过来aspectjweaver -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aspects</artifactId>
    <version>5.3.1</version>
</dependency>

在Spring的配置文件中配置

<context:component-scan base-package="com.GLATY.studySpring"/>
<!--在Spring的配置配置文件中设置<aop:aspectj-autoproxy/>,开启基于注解的AOP-->
<aop:aspectj-autoproxy/>

创建切面类

@Component
@Aspect  //将当前组件标记为切面
public class LoggerAspect {

    /*
        前置通知：使用@Before注解标识，在被代理的目标方法前执行
        返回通知：使用@AfterReturning注解标识，在被代理的目标方法成功结束后执行（寿终正寝）
        异常通知：使用@AfterThrowing注解标识，在被代理的目标方法异常结束后执行（死于非命）
        后置通知：使用@After注解标识，在被代理的目标方法最终结束后执行（盖棺定论）
        环绕通知：使用@Around注解标识，使用try...catch...finally结构围绕整个被代理的目标方法，包括上面四种通知对应的所有位置
        各种通知的执行顺序：
            Spring版本5.3.x以前
                前置通知
                目标操作
                后置通知
                返回通知或异常通知
            Spring版本5.3.x以后
                前置通知
                目标操作
                返回通知或异常通知
                后置通知
    */

    //@Before("execution(public int com.GLATY.studySpring.proxy.CalculatorImpl.add(int, int))")
    //Before后的()写切入点表达式，execution()是固定形式
    @Before("execution(* com.GLATY.studySpring.proxy.CalculatorImpl.*(..))")
    public void beforeAdviceMethod(JoinPoint joinPoint) {
        //在通知方法的参数位置设置JoinPoint类型的参数，就可以获取父节点所对应方法的信息

        //获取连接点所对应方法的签名信息
        Signature signature = joinPoint.getSignature();
        //获取连接点所对应方法的方法名
        System.out.println("方法:" + signature.getName());
        //获取连接点所对应方法的参数
        Object[] args = joinPoint.getArgs();
        System.out.println("参数:" + Arrays.toString(args));
    }


    /*
    * @Pointcut()声明一个公共的切入点表达式
    * 使用时只需要写所对应方法的方法名
    * */
    @Pointcut("execution(* com.GLATY.studySpring.proxy.CalculatorImpl.*(..))")
    public void pointCut1(){};

    @After("pointCut1()")
    public void afterAdviceMethod(){
        System.out.println("^_^ afterAdviceMethod ^_^");
    }

    @AfterReturning(value = "pointCut1()", returning = "result")
    //returning是设置接收目标目标方法的返回值的参数名的，在所标注的方法必须有这个参数。
    public void AfterReturningAdviceMethod(Object result){
        System.out.println("^_^ AfterReturningAdviceMethod ^_^  结果:" + result);
    }

    @AfterThrowing(value = "pointCut1()", throwing = "e")
    //throwing是设置接收目标目标方法的异常的参数名的，在所标注的方法必须有这个参数。
    //参数值类型可以为Exception 也可以是Throwable
    public void AfterThrowingAdviceMethod(Exception e){
        System.out.println("—_- AfterThrowingAdviceMethod -_—   error:" + e);
    }

    @Around("pointCut1()")
    public Object AroundAdviceMethod(ProceedingJoinPoint joinPoint) {
        Object result = null;
        //表示目标对象方法的执行
        try {
            System.out.println("前置通知");
            result = joinPoint.proceed();
            System.out.println("返回通知");
        } catch (Throwable e) {
            e.printStackTrace();
            System.out.println("异常通知");
        } finally {
            System.out.println("后置通知");
        }
        System.out.println("^_^ AroundAdviceMethod ^_^");
        return result;
    }

}

切入点表达式语法

 

• 用*号代替“权限修饰符”和“返回值”部分表示“权限修饰符”和“返回值”不限
• 在包名的部分，一个“*”号只能代表包的层次结构中的一层，表示这一层是任意的。
• 在包名的部分，使用“*..”表示包名任意、包的层次深度任意
• 在类名的部分，类名部分整体用*号代替，表示类名任意
• 在类名的部分，可以使用*号代替类名的一部分 （*Service匹配所有名称以Service结尾的类或接口）
• 在方法名部分，可以使用*号表示方法名任意
• 在方法名部分，可以使用*号代替方法名的一部分 （*Operation匹配所有方法名以Operation结尾的方法）
• 在方法参数列表部分，使用(..)表示参数列表任意
• 在方法参数列表部分，使用(int,..)表示参数列表以一个int类型的参数开头
• 在方法参数列表部分，基本数据类型和对应的包装类型是不一样的
• 切入点表达式中使用 int 和实际方法中 Integer 是不匹配的
• 在方法返回值部分，如果想要明确指定一个返回值类型，那么必须同时写明权限修饰符

切面的优先级

相同目标方法上同时存在多个切面时，切面的优先级控制切面的内外嵌套顺序。

         ●优先级高的切面：外面

         ●优先级低的切面：里面

使用@Order注解可以控制切面的优先级：

         ●@Order(较小的数)：优先级高

         ●@Order(较大的数)：优先级低

*基于XML的AOP

<aop:config>
    <!--配置切面类-->
    <aop:aspect ref="loggerAspect">
        <aop:pointcut id="pointCut" expression="execution(* com.GLATY.studySpring.proxy.CalculatorImpl.*(..))"/>
        <aop:before method="beforeAdviceMethod" pointcut-ref="pointCut"/>
        <aop:after method="afterAdviceMethod" pointcut-ref="pointCut"/>
        <aop:after-returning method="afterReturningAdviceMethod" returning="result" pointcut-ref="pointCut"/>
        <aop:after-throwing method="afterThrowingAdviceMethod" throwing="e" pointcut-ref="pointCut"/>
        <aop:around method="aroundAdviceMethod" pointcut-ref="pointCut"/>
    </aop:aspect>
</aop:config>

声明式事务

JdbcTemplate

简介

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

数据准备

导入依赖

<dependencies> 
    <!-- 基于Maven依赖传递性，导入spring-context依赖即可导入当前所需所有jar包 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.3.1</version>
    </dependency> 
    <!-- Spring 持久化层支持jar包 --> 
    <!-- Spring 在执行持久化层操作、与持久化层技术进行整合过程中，需要使用orm、jdbc、tx三个 jar包 --> 
    <!-- 导入 orm 包就可以通过 Maven 的依赖传递性把其他两个也导入 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-orm</artifactId>
        <version>5.3.1</version>
    </dependency> 
    <!-- Spring 测试相关 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>5.3.1</version>
    </dependency> 
    <!-- junit测试 -->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
    </dependency> 
    <!-- MySQL驱动 -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.16</version>
    </dependency> 
    <!-- 数据源 -->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>1.0.31</version>
    </dependency>
</dependencies>

创建jdbc.properties

jdbc.drive=com.mysql.cj.jdbc.Driver
jdbc.rel=jdbc:mysql://localhost:3306/secondData?serverTimezone=UTC
jdbc.username=root
jdbc.password=123465

配置Spring的配置文件

<!-- 导入外部属性文件 -->
<context:property-placeholder location="jdbc.properties"/>
<!-- 配置数据源 -->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
    <property name="driverClassName" value="${jdbc.drive}"/>
    <property name="url" value="${jdbc.rel}"/>
    <property name="username" value="${jdbc.username}"/>
    <property name="password" value="${jdbc.password}"/>
</bean>
<!-- 配置 JdbcTemplate -->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
    <!-- 装配数据源 -->
    <property name="dataSource" ref="dataSource"/>
</bean>

测试

在测试类装配 JdbcTemplate

@RunWith(SpringJUnit4ClassRunner.class)
//指定当前测试类在Spring的测试环境中执行，此时就可以通过注入的方式直接获取IOC容器中bean
@ContextConfiguration("classpath:JdbcTemplate.xml")
//设置Spring测试环境的配置文件
public class TestJdbcTemplate {

    @Autowired
    private JdbcTemplate jdbcTemplate;

}

增删改功能

            增删改都是调用jdbcTemplate的update方法

@Test
public void Test1() {
    String sql = "insert into secondtable.hero value(?, ?, ?, ?)";
    jdbcTemplate.update(sql, "name", 520, "codeName", 100);
}

查询

@Test
public void testSelectEmpById() {
    //查询一条数据为一个实体类对象
    String sql = "select * from secondtable.hero where id = ?";
    Hero hero = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<>(Hero.class), 1);
    System.out.println(hero);
}

声明式事务概念

编程式事务

        事务功能的相关操作全部通过自己编写代码来实现

        编程式的实现方式存在缺陷：

        细节没有被屏蔽：具体操作过程中，所有细节都需要程序员自己来完成，比较繁琐。

        代码复用性不高：如果没有有效抽取出来，每次实现功能都需要自己编写代码，代码就没有得到复用。

声明式事务

        事务控制的代码有规律可循，代码的结构基本是确定的，然而框架可以将固定模式的代码抽取出来，进行相关的封装。

        封装起来后，我们只需要在配置文件中进行简单的配置即可完成操作。

好处：

1. 提高开发效率
2. 消除了冗余的代码
3. 框架会综合考虑相关领域中在实际开发环境下有可能遇到的各种问题，进行了健壮性、性能等各个方面的优化

所以，我们可以总结下面两个概念：

编程式：自己写代码实现功能

声明式：通过配置让框架实现功能

基于注解的声明式事务

加入事务

        添加事务配置

<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"/>
</bean>
<!--
    开启事务的注解驱动 
    通过注解@Transactional所标识的方法或标识的类中所有的方法，都会被事务管理器管理事务 
-->
<!-- transaction-manager属性的默认值是transactionManager，如果事务管理器bean的id正好就是这个默认值，则可以省略这个属性 -->
<tx:annotation-driven transaction-manager="transactionManager"/>

 开启基于注解的声明式事务功能

        添加事务注解

        因为service层表示业务逻辑层，一个方法表示一个完成的功能，因此处理事务一般在service层的方法(或service类)上添加注解@Transactional

*@Transactional注解标识的位置

        @Transactional标识在方法上，咋只会影响该方法

        @Transactional标识的类上，咋会影响类中所有的方法

事务属性

        只读

        对一个查询操作来说，如果我们把它设置成只读，就能够明确告诉数据库，这个操作不涉及写操作。这样数据库就能够针对查询操作来进行优化。

        使用方式：设置@Transactional注解的属性readOnly为true

@Transactional(readOnly = true)

对增删改操作设置只读会抛出异常

        超时

        事务在执行过程中，有可能因为遇到某些问题，导致程序卡住，从而长时间占用数据库资源。而长时间占用资源，大概率是因为程序运行出现了问题（可能是Java程序或MySQL数据库或网络连接等等）。此时这个很可能出问题的程序应该被回滚，撤销它已做的操作，事务结束，把资源让出来，让其他正常程序可以执行。概括来说就是一句话：超时回滚，释放资源。

        使用方式：设置@Transactional注解的属性timeout的值，单位为秒(默认为-1，表示一直等待)

@Transactional(timeout = 3)

         执行过程中超时会抛出异常

        回滚策略

        声明式事务默认只针对运行时异常回滚，编译时异常不回滚。

        可以通过@Transactional中相关属性设置回滚策略

                rollbackFor属性：需要设置一个Class类型的对象

                rollbackForClassName属性：需要设置一个字符串类型的全类名

                noRollbackFor属性：需要设置一个Class类型的对象

                rollbackFor属性：需要设置一个字符串类型的全类名

        使用方式：设置@Transactional注解的属性

@Transactional(noRollbackFor = ArithmeticException.class)
//当出现ArithmeticException异常不发生回滚

        事务隔离级别

        数据库系统必须具有隔离并发运行各个事务的能力，使它们不会相互影响，避免各种并发问题。一个事务与其他事务隔离的程度称为隔离级别。SQL标准中规定了多种事务隔离级别，不同隔离级别对应不同的干扰程度，隔离级别越高，数据一致性就越好，但并发性越弱。

隔离级别一共有四种：

        ●读未提交：READ UNCOMMITTED

        允许Transaction01读取Transaction02未提交的修改。

        ●读已提交：READ COMMITTED

        要求Transaction01只能读取Transaction02已提交的修改。

        ●可重复读：REPEATABLE READ

        确保Transaction01可以多次从一个字段中读取到相同的值，即Transaction01执行期间禁止其它事务对这个字段进行更新。

        ●串行化：SERIALIZABLE

        确保Transaction01可以多次从一个表中读取到相同的行，在Transaction01执行期间，禁止其它事务对这个表进行添加、更新、删除操作。可以避免任何并发问题，但性能十分低下。

隔离级别解决并发问题的能力

隔离级别	脏读	不可重复读	幻读
READ UNCOMMITTED	有	有	有
READ COMMITTED	无	有	有
REPEATABLE READ	无	无	有
SERIALIZABLE	无	无	无

数据库产品对事务隔离级别的支持程度

隔离级别	Oracle	MySQL
READ UNCOMMITTED	×	√
READ COMMITTED	√( 默认 )	√
REPEATABLE READ	×	√( 默认 )
SERIALIZABLE	√	√

        使用方式：设置@Transactional注解的isolation属性

@Transactional(isolation = Isolation.DEFAULT)//使用数据库默认的隔离级别 
@Transactional(isolation = Isolation.READ_UNCOMMITTED)//读未提交 
@Transactional(isolation = Isolation.READ_COMMITTED)//读已提交 
@Transactional(isolation = Isolation.REPEATABLE_READ)//可重复读 
@Transactional(isolation = Isolation.SERIALIZABLE)//串行化

        事务传播行为

        当事务方法被另一个事务方法调用时，必须指定事务应该如何传播。例如：方法可能继续在现有事务中运行，也可能开启一个新事务，并在自己的事务中运行。

        可以通过@Transactional中的propagation属性设置事务传播行为

        propagation属性值默认为Propagation.REQUIRED，表示如果当前线程上有已经开启的事务可用，那么就在这个事务中运行。

        设置propagation属性值为Propagation.REQUIRES_NEW，表示不管当前线程上是否有已经开启 的事务，都要开启新事务。

@Transactional(propagation = Propagation.REQUIRED)      //默认值
@Transactional(propagation = Propagation.REQUIRES_NEW)

*基于XML的声明式事务

        将Spring 配置文件中去掉 tx:annotation-driven 标签，并添加配置

<aop:config>
    <!-- 配置事务通知和切入点表达式 -->
    <aop:advisor advice-ref="txAdvice" pointcut="execution(* com.GLATY.studySpring.service.impl.*.*(..))"/>
</aop:config>
<!-- 
    tx:advice标签：配置事务通知
        id属性：给事务通知标签设置唯一标识，便于引用
        transaction-manager属性：关联事务管理器 
-->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
    <tx:attributes>
        <!-- tx:method标签：配置具体的事务方法 -->
        <!-- name属性：指定方法名，可以使用星号代表多个字符 -->
        <tx:method name="get*" read-only="true"/>
        <tx:method name="query*" read-only="true"/>
        <tx:method name="find*" read-only="true"/>
        <!-- read-only属性：设置只读属性 -->
        <!-- rollback-for属性：设置回滚的异常 -->
        <!-- no-rollback-for属性：设置不回滚的异常 -->
        <!-- isolation属性：设置事务的隔离级别 -->
        <!-- timeout属性：设置事务的超时属性 -->
        <!-- propagation属性：设置事务的传播行为 -->
        <tx:method name="save*" read-only="false" rollback-for="java.lang.Exception" propagation="REQUIRES_NEW"/>
        <tx:method name="update*" read-only="false" rollback-for="java.lang.Exception" propagation="REQUIRES_NEW"/>
        <tx:method name="delete*" read-only="false" rollback-for="java.lang.Exception" propagation="REQUIRES_NEW"/>
    </tx:attributes>
</tx:advice>

        基于xml实现的声明式事务，必须引入aspectJ的依赖

<!--aspectJ依赖-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aspects</artifactId>
    <version>5.3.1</version>
</dependency>