Spring 学习（1）

Spring 框架是 Java 应用最广的框架，它的成功来源于理念，而不是技术本身，它的理念包括 IoC (Inversion of Control，控制反转) 和 AOP(Aspect Oriented Programming，面向切面编程)。

一、什么是 Spring

● Spring 是一个轻量级的 DI / IoC 和 AOP 容器的开源框架，来源于 Rod Johnson 在其著作《Expert one on one J2EE design and development》中阐述的部分理念和原型衍生而来。
● Spring 提倡以“最少侵入”的方式来管理应用中的代码，这意味着我们可以随时安装或者卸载 Spring
● 适用范围：任何 Java 应用
● Spring 的根本使命：简化 Java 开发

（1）组成

（2）Spring 能帮我们做什么

（3）优点

● Spring是一个开源的免费的框架（容器）！
● Spring是一个轻量级的、非入侵式的框架！
● 控制反转（IOC），面向切面编程（AOP）！
● 支持事务的处理，支持框架整合！

（4）拓展

现代化的Java开发！说白就是基于Spring的开发！

（5）Spring 中常用术语

Spring 的配置文件详解

Spring 配置文件是用于指导 Spring 工厂进行 Bean 生产、依赖关系注入（装配）及 Bean 实例分发的"图纸"。程序员必须学会并灵活应用这份"图纸"准确地表达自己的"生产意图"。
Spring 配置文件是一个或多个标准的 XML 文档，applicationContext.xml 是 Spring 的默认配置文件，当容器启动时找不到指定的配置文档时，将会尝试加载这个默认的配置文件。

（1）配置文件详解

（2）Spring 中加载 xml 配置文件的六种方式

● XmlBeanFactory 引用资源

Resource resource = new ClassPathResource("appcontext.xml");
BeanFactory factory = new XmlBeanFactory(resource); 

● ClassPathXmlApplicationContext 编译类路径

ApplicationContext factory = new ClassPathXmlApplicationContext("classpath:appcontext.xml"); 
// src目录下的
ApplicationContext factory = new ClassPathXmlApplicationContext("appcontext.xml"); ApplicationContext factory = new ClassPathXmlApplicationContext(new String[] {"bean1.xml","bean2.xml"}); 
// src/conf 目录下的 
ApplicationContext factory = new ClassPathXmlApplicationContext("conf/appcontext.xml");
ApplicationContext factory = new ClassPathXmlApplicationContext("file:G:/Test/src/appcontext.xml");  >   

● 磁盘文件系统的路径

ApplicationContext factory = new FileSystemXmlApplicationContext("src/appcontext.xml");
 // 使用了 classpath:  前缀,作为标志,  这样,FileSystemXmlApplicationContext 也能够读入classpath下的相对路径 
 ApplicationContext factory = new FileSystemXmlApplicationContext("classpath:appcontext.xml");
ApplicationContext factory = new FileSystemXmlApplicationContext("file:G:/Test/src/appcontext.xml");
ApplicationContext factory = new FileSystemXmlApplicationContext("G:/Test/src/appcontext.xml"); 

● XmlWebApplicationContext 是专为Web工程定制的。

ServletContext servletContext = request.getSession().getServletContext(); 
ApplicationContext ctx = WebApplicationContextUtils.getWebApplicationContext(servletContext );    

● 使用 BeanFactory

BeanDefinitionRegistry reg = new DefaultListableBeanFactory();
XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(reg);
reader.loadBeanDefinitions(new ClassPathResource("bean1.xml"));
reader.loadBeanDefinitions(new ClassPathResource("bean2.xml"));
BeanFactory bf=(BeanFactory)reg; 

● Web 应用启动时加载多个配置文件通过 ContextLoaderListener 也可加载多个配置文件，在 web.xml 文件中利用 \<context-pararn>元素来指定多个配置文件位置，其配置如下:

<context-param>   
    <!-- Context Configuration locations for Spring XML files -->   
       <param-name>contextConfigLocation</param-name>   
       <param-value>   
       ./WEB-INF/**/Appserver-resources.xml,   
       classpath:config/aer/aerContext.xml,   
       classpath:org/codehaus/xfire/spring/xfire.xml,   
       ./WEB-INF/**/*.spring.xml   
       </param-value>       
</context-param>   

二、Spring 使用注解开发

Spring 是我们 web 开发中必不可少的一个框架，基于传统的 xml 方式配置 Bean 太过繁琐，从 Spring2.5 之后注解的出现可以大大简化我们的配置。

1、替代 <Bean> 的原始注解

当注解在作用类上时，表明这些类似交给Spring容器进行管理的。

2、依赖注入的注解

3、XML 配置文件中配置组件扫描

（1）组建注解扫描
使用注解进行开发时（代替配置 bean 方式开发），需要在 applicationContext.xml 中配置组件扫描，作用是指定哪个包及其子包下的 Bean 需要进行扫描以便识别使用注解配置的类、字段和方法。不配置这个的话，运行会报异常NoSuchBeanDefinitionException。

（2）不需要使用 <context:annotation-config> 元素
\<context:component-scan> 隐式地启用了 \<context:annotation-config>的功能。<context:annotation-config>的作用是让 Spring 具备解析 @Component 等注解的功能。当使用 \<context:component-scan> 时，通常不需要包含 \<context:annotation-config> 元素。

4、示例

实体类 Bean

@Component
public class SleepNoMore{

    public void perform() {
        System.out.println("戏剧《不眠之夜Sleep No More》");
    }
}

XML 配置文件

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

    <context:component-scan base-package="com.spring"/>
</beans>

获取 IOC 容器中的 Bean

public class test {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        SleepNoMore sleepNoMore= (SleepNoMore) context.getBean("sleepNoMore");
        sleepNoMore.perform();
    }
}

三、Spring 纯注解开发

1、Spring 的新注解

Spring 的新注解开发增添了以下注解代替 XML 文件的配置

2、将 Bean 注册到 IOC 容器的两种方式

（1）@Component 注解 + @Configuration + @ComponentScan(basePackages = "com.spring")注解

● Spring 提供了一个注解 @Configuration，目的是让我们可以把一个普通的 Java 类等同于一个 XML 文件，而这个 Java 类就是 JavaConfig，我们习惯称之为配置类。
● @Component 是由 Spring 定义，因此也必须由 Spring 解析。这个解析可以由配置类的 @ComponentScan(basePackages = “com.spring”) 注解进行扫描包下的Bean。
● 配置类 JavaConfig 可以使用 AnnotationConfigApplicationContext 像解析 XML 一样解析配置类。

示例：

Bean 实体类

@Component 
public class SleepNoMore{

    public void perform() {
        System.out.println("戏剧《不眠之夜Sleep No More》");
    } 
   } 

配置类（JavaConfig）

@Configuration     // JavaConfig方式，把当前 Java 类作为配置类，代替 XML 配置文件
@ComponentScan(basePackages = "com.spring")      // 注解方式，开启扫描 public
class JavaConfig {

     } 

获取 IOC 容器中的 Bean

public class test {
    public static void main(String[] args) {
    
       // 参数为配置类的calss（JavaConfig.class）
       ApplicationContext app = new AnnotationConfigApplicationContext(JavaConfig.class);
       SleepNoMore sleepNoMore = (SleepNoMore)app.getBean("sleepNoMore");
       sleepNoMore.perform();
    }
   }

（2）@Configuration 注解 + @Bean 注解

● 用 @Configuration 把一个普通 Java 类变成配置类，充当XML，在配置类中写多个方法，使用 @Bean 注解把返回值对象注册到 Spring 容器中。
● 无需加 @Component 注解，因为我们可以手动 new 之后通过 @Bean 加入 Spring 容器。
● 配置类 JavaConfig 可以使用 AnnotationConfigApplicationContext 像解析 XML 一样解析配置类。

示例：

Bean 实体类

public class SleepNoMore{

    public void perform() {
        System.out.println("戏剧《不眠之夜Sleep No More》");
    } 
   } 

配置类（JavaConfig）

@Configuration     // JavaConfig方式，把当前 Java 类作为配置类，代替 XML 配置文件
class JavaConfig {

    @Bean   // @Bean 把返回值对象加入到 Spring 容器中
    public SleepNoMore sleepNoMore(){
       return new SleepNoMore();
    }
   } 

获取 IOC 容器中的 Bean

public class test {
    public static void main(String[] args) {
    
       // 参数为配置类的calss（JavaConfig.class）
       ApplicationContext app = new AnnotationConfigApplicationContext(JavaConfig.class);
       SleepNoMore sleepNoMore = (SleepNoMore)app.getBean("sleepNoMore");
       sleepNoMore.perform();
    }
   }

四、Spring IoC

控制反转 IoC（Inversion of Control），是一种设计思想，DI（依赖注入）是实现 IoC 的一种方法，也有人认为 DI 只是 IoC 的另一种说法。没有IoC的程序中，我们使用面向对象编程，对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象的创建转移给第三方，个人认为所谓控制反转就是：获得依赖对象的方式反转了。

控制反转是一种通过描述（XML或注解）并通过第三方去生产或获取特定对象的方式。在Spring中实现控制反转的是IoC容器，其实现方法是依赖注入（Dependency Injection，DI）。
采用 XML 方式配置 Bean 的时候，Bean 的定义信息是和实现分离的，而采用注解的方式可以把两者合为一体，Bean 的定义信息直接以注解的形式定义在实现类中，从而达到了零配置的目的。

控制反转显然是一个抽象的概念，我们举一个鲜明的例子来说明。

1、IoC 容器

Spring IoC 容器负责创建对象、管理对象（通过依赖注入（DI）、装配对象、配置对象，并且管理这些对象的整个生命周期。

Spring框架提供的容器

ApplicationContext 和 beanfactory 区别

Spring的IoC容器就是一个实现了BeanFactory接口的可实例化类。事实上，Spring提供了两种不同的容器：一种是最基本的BeanFactory，另一种是扩展的ApplicationContext。BeanFactory
仅提供了最基本的依赖注入支持，而 ApplicationContext 则扩展了BeanFactory，提供了更多的额外功能。

（1）Bean 创建

1）BeanFactroy采用的是延迟加载形式来注入Bean的，即只有在使用到某个Bean时(调用getBean())，才对该Bean进行加载实例化，这样，我们就不能发现一些存在的spring的配置问题。而ApplicationContext则相反，它是在容器启动时，一次性创建了所有的Bean。这样，在容器启动时，我们就可以发现Spring中存在的配置错误。

2）BeanFactory和ApplicationContext都支持BeanPostProcessor、BeanFactoryPostProcessor的使用，但两者之间的区别是：BeanFactory需要手动注册，而ApplicationContext则是自动注册。

3）BeanFactory当需要调用时读取配置信息，生成某个类的实例。如果读入的Bean配置正确，则其他的配置中有错误也不会影响程序的运行。而ApplicationContext 在初始化时就把 xml 的配置信息读入内存，对 XML 文件进行检验，如果配置文件没有错误，就创建所有的Bean，直接为应用程序服务。相对于基本的BeanFactory，ApplicationContext
唯一的不足是占用内存空间。当应用程序配置Bean较多时，程序启动较慢。
4）ApplicationContext会利用Java反射机制自动识别出配置文件中定义的BeanPostProcessor、InstantiationAwareBeanPostProcessor和BeanFactoryPostProcessor，并自动将它们注册到应用上下文中；而BeanFactory需要在代码中通过手工调用addBeanPostProcessor()方法进行注册。

（2）国际化

BeanFactory是不支持国际化功能的，因为BeanFactory没有扩展Spring中MessageResource接口。相反，由于ApplicationContext扩展了MessageResource接口，因而具有消息处理的能力(i18N)，具体spring如何使用国际化

（3）事件机制(Event)

基本上牵涉到事件(Event)方面的设计，就离不开观察者模式。 ApplicationContext的事件机制主要通过ApplicationEvent和ApplicationListener这两个接口来提供的，和java
swing中的事件机制一样。即当ApplicationContext中发布一个事件的时，所有扩展了ApplicationListener的Bean都将会接受到这个事件，并进行相应的处理。

（4）底层资源的访问

ApplicationContext扩展了ResourceLoader(资源加载器)接口，从而可以用来加载多个Resource，而BeanFactory是没有扩展ResourceLoader。

（5）对Web应用的支持

与BeanFactory通常以编程的方式被创建不同的是，ApplicationContext能以声明的方式创建，如使用ContextLoader。当然你也可以使用ApplicationContext的实现之一来以编程的方式创建ApplicationContext实例
。

ContextLoader有两个实现：ContextLoaderListener和ContextLoaderServlet。它们两个有着同样的功能，除了listener不能在Servlet
2.2兼容的容器中使用。自从Servelt 2.4规范，listener被要求在web应用启动后初始化。很多2.3兼容的容器已经实现了这个特性。使用哪一个取决于你自己，但是如果所有的条件都一样，你大概会更喜欢ContextLoaderListener；关于兼容方面的更多信息可以参照ContextLoaderServlet的JavaDoc。

这个listener需要检查contextConfigLocation参数。如果不存在的话，它将默认使用/WEB-INF/applicationContext.xml。如果它存在，它就会用预先定义的分隔符（逗号，分号和空格）分开分割字符串，并将这些值作为应用上下文将要搜索的位置。ContextLoaderServlet可以用来替换ContextLoaderListener。这个servlet像listener那样使用contextConfigLocation参数。

2、IoC 容器的创建

（1）Java 中创建

ApplicationContext 是 spring 继 BeanFactory 之外的另一个核心接口或容器，允许容器通过应用程序上下文环境创建、获取、管理 bean。

Java 中创建容器流程如下：

● 程序运行 main() 方法 ；
● 调用 ClassPathXmlApplicationContext(String configLocation) 的构造函数创建出一个 ApplicationContext 接口的实现类；
● 将创建完成的 ClassPathXmlApplicationContext 对象赋于 context 变量；
● 此时 context 也就是我们通俗讲的spring容器了；

Java 中常见的几种创建方式：

（1）ClassPathXmlApplicationContext

它可以加载类路径下的配置文件，但要求配置文件必须在类路径下，如果不在就无法加载。

 ApplicationContext act = new ClassPathXmlApplicationContext("applicationContext.xml"); 
 Hello hello = (Hello) act.getBean("hello"); 
 // 或者 Hello hello = act.getBean("hello"，Hello.class);
 hello.show();

（2）FileSystemXmlApplicationContext

可以加载磁盘任意路径下的配置文件(必须有访问权限）

 ApplicationContext act = new FileSystemXmlApplicationContext("D:/javaWorkSpace/spring2/src/applicationContext.xml");
 Hello hello = (Hello) act.getBean("hello"); 
 // 或者 Hello hello = act.getBean("hello"，Hello.class); 
 hello.show(); 

（3）AnnotationConfigApplicationContext

用于读取注解创建容器，读取的内容时配置类 JavaConfig

 AnnotationConfigApplicationContext(JavaConfig.class); 
 Hello hello = (Hello) act.getBean("hello");
 // 或者 Hello hello = act.getBean("hello"，Hello.class); 
 hello.show(); 

（2）Web 中创建

在普通项目中，我们可以通过 run main() 方法来运行程序，但是如果是 Web 项目的话，是将我们的项目部署到 Tomcat 上，通过启动 Tomcat 来加载我们的项目。

此时我们需要的是在 Tomcat 启动完成之前就完成对 Spring 容器的创建，通常我们都会在 web.xml 中写以下的代码：

<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:spring.xml</param-value>
</context-param>

<listener>
    <listener-class>
        org.springframework.web.context.ContextLoaderListener
    </listener-class>
</listener>

我们在web.xml中配置了一个 context-param 和一个 listener 节点：

ContextLoaderListener 类实现了 Tomcat 容器的 ServletContextListener 接口，与其他 Servlet 监听一样，重写了两个方法：contextInitialized() 方法进行 web 容器初始化，contextDestroyed() 方法进行容器销毁。 在初始化的过程中调用 ContextLoader 中的 initWebApplicationContext() 方法，由 web 容器监听器（ContextLoaderListener）提供 ServletContext。首先判断 servlectContext 中是否已经存在根上下文 WebApplicationContext，如果存在，则抛出异常；否则通过 createWebApplicationContext 方法创建新的根上下文。然后通过 loadParentContext() 方法为其设置父上下文。再通过configureAndRefreshWebApplicationContext 为根上下文构建 bean 工厂和 bean 对象。最后把上下文存入 servletContext，并且存入 currentContextPerThread。至此初始化过程完毕，接下来可以获取 WebApplicationContext，进而用 getBean(“bean name”)得到 bean。

refresh() 方法:

Web项目启动的流程：

在ServletContext一旦创建成功的时候org.springframework.web.context.ContextLoaderListener执行contextInitialized方法。我们可以猜：在contextInitialized方法中，读取到了context-param中名为contextConfigLocation的值（classpath:spring.xml），然后根据配置的这个值（classpath:spring.xml）去加载配置文件并创建出一个Spring容器。

关于 ServletContext：

3、IoC 如何实现的

4、IOC 创建与获取对象的方式

总结：在配置文件加载的时候，容器中管理的对象就已经初始化了！

1）基于 XML 配置文件创建对象

● 默认使用无参构造创建对象！

public class Person {
    private String name;
    private int age;
    private String like;
    private String high;

    public Person() {
        //输出一句话证明自己被调用了！
        System.out.println("我是Person类的无参构造函数！我被调用了！！！！");
    }
    //set、get、tostring方法因为篇幅原因省略，请手动加上! } 

<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">
    <bean id="Person" class="entity.Person">
        <property name="age" value="23"></property>
        <property name="name" value="丁大大"></property>
        <property name="like" value="钓鱼"></property>
        <property name="high" value="173"></property>
    </bean> 
</beans> 

● 使用有参构造创建对象：

下标赋值

// 第一种方式：下标赋值     
<bean id="user" class="com.kuang.pojo.User">
    <constructor-arg index="0" value="狂神说Java"/> 
</bean> 

类型

// 第二种方式：通过类型的创建，不建议使用     
<bean id="user" class="com.kuang.pojo.User">
    <constructor-arg type="java.lang.String" value="lifa"/> 
</bean> 

参数名

// 第三种方式：直接通过参数名来设置     
<bean id="user" class="com.kuang.pojo.User">
    <constructor-arg name="name" value="李发"/> 
</bean>

总结：

● 无参构造函数指定值时使用 propert 标签；
● 有参构造函数指定值时使用 constructor-arg 标签：index --通过下标来给属性赋值，name --通过属性名称来给属性赋值，type – 指定属性的类型来给属性赋值；
● 引用类型得加上全称，如：java.lang.String

2）基于注解创建对象

配置注解扫描，告诉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"
	       xsi:schemaLocation="http://www.springframework.org/schema/beans
		        https://www.springframework.org/schema/beans/spring-beans.xsd
		        http://www.springframework.org/schema/context
		        https://www.springframework.org/schema/context/spring-context.xsd">
			
		 <!--扫描注解所在的包-->
         <context:component-scan base-package="com.spring"/>
	</beans>

使用 @Component 以及三个衍生注解 @Repository、@Service 和 @Controller。这四个注解功能都是一样的，都是代表将某个类注册到Spring中，装配Bean。

//等价于<bean id="user" class="com.kuang.pojo.User"/>
//@Component 组件

@Component
@Scope("singleton")  // 作用域，用于指定单例还是多例
public class User {

    //相当于  <property name="name" value="白莲"/>
    @Value("白莲")
    public String name;
}

3）获取对象

//获取Spring的上下文对象！ 
ApplicationContext context = new ClassPathXmlApplicationContext("application.xml");

//我们的对象现在都在Spring中的管理了，我们需要使用，直接去里面取出来就可以！
Hello hello = (Hello)context.getBean("hello"); 
System.out.println(hello.toString()); 

5、HelloSpring 代码示例

新建一个maven项目，编写实体类

public class Hello {
    private String str;

    public String getStr() {
        return str;
    }

    public void setStr(String str) {
        this.str = str;
    }

    @Override
    public String toString() {
        return "Hello{" +
                "str='" + str + '\'' +
                '}';
    }
}

编写xml配置文件

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd">


    // 使用Spring来创建对象，在Spring这些都称为Bean
    // 类型 变量名 = new 类型();
    // Hello hello = new Hello();

    // id = 变量名
    // class = new 的对象,必须要写全类名
    // property 相当于给对象中的属性设置一个值！
        -->
    <bean id="hello" class="com.kuang.pojo.Hello">
        <property name="str" value="Spring"/>
    </bean>
</beans>

测试

public class MyTest {
    public static void main(String[] args) {
        //获取Spring的上下文对象！
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");

        //我们的对象现在都在Spring中的管理了，我们需要使用，直接去里面取出来就可以！
        Hello hello = (Hello) context.getBean("hello");
        System.out.println(hello.toString());
    }
}

五、Dependency Injection（依赖注入）

IOC 让程序员不在关注怎么去创建对象，而是关注与对象创建之后的操作，把对象的创建、初始化、销毁等工作交给spring容器来做。那么创建对象的时候，有可能依赖于其他的对象，即类的属性如何赋值，这就需要 DI 依赖注入来完成。

简单来说，在 Spring 创建对象的同时，为其属性赋值，或者说 spring 动态的向某个对象提供它所需要的其他对象，称之为依赖注入。
组件之间依赖关系由容器在运行期决定的，即由容器动态的将某个依赖关系注入到组件之中。
其作用是去除Java类之间的依赖关系，实现松耦合，以便于开发测试。

Spring 的依赖注入有基于 XML 文件的 Setter 方法注入、构造方法注入、自动注入以及基于注解的自动注入。

1、基于 XML 文件的 Setter 方法注入

Setter 方法注入，它只需要提供对应的 Setter 方法接口实现注入，由于 Lombok 的 @Data 注解提供了 Setter 方法的实现，所以 Setter 方法注入也成为了我们常用的注入方法之一。

定义一个JavaBean并赋予其Setter方法：

package com.mylifes1110.bean;
​
import java.util.*;
​
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
​
//Lombok 的 @Data 注解提供了Setter方法
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private Integer             id;
    private String              password;
    private String              sex;
    private Integer             age;
    private Date                bornDate;
    private String[]            hobbys;
    private Set<String>         phones;
    private List<String>        names;
    private Map<String, String> countries;
    private Properties          files;
}

XML 配置文件注入各种数据类型

<bean id="User" class="com.mylifes1110.bean.User">

    // 注入基本数据类型
    <property name="id" value="1"/>
    <property name="password" value="123456"/>
    <property name="sex" value="male"/>
    <property name="age" value="18"/>
    
    // 注入日期类型：Spring底层对Date日期类型做了处理，默认处理格式为“yyyy/MM/dd”
    <property name="bornDate" value="1999/09/09"/>
    
    // 注入数组类型
    <property name="hobbys">
        <array>
            <value>Run</value>
            <value>Jump</value>
            <value>Climb</value>
        </array>
    </property>
    
    // 注入List集合类型
    <property name="names">
        <list>
            <value>Ziph</value>
            <value>Join</value>
            <value>Marry</value>
        </list>
    </property>
    
    // 注入Set集合类型
    <property name="phones">
        <set>
            <value>110</value>
            <value>119</value>
            <value>120</value>
        </set>
    </property>
    
    // 注入Properties类型
    <property name="files">
        <props>
            <prop key="first">One</prop>
            <prop key="second">Two</prop>
            <prop key="third">Three</prop>
        </props>
    </property>
    
    // 注入Map集合类型
    <property name="countries">
        <map>
            <entry key="CHINA" value="中国"/>
            <entry key="USA" value="美国"/>
            <entry key="UK" value="英国"/>
        </map>
    </property>
</bean>

XML 配置文件注入自定义引用类型数据

// 次要bean,被作为属性注入到另一个对象中
<bean id="address" class="com.mylifes1110.bean.Address">
    <property name="position" value="上海市" />
    <property name="zipCode" value="100001" />
</bean>
​
// 主要bean,操作的主体
<bean id="user" class="com.mylifes1110.bean.User">
    // address属性引用address对象
    <property name="address" ref="address" />
</bean>

2、基于 XML 配置文件的构造方法注入

创建对象时，Spring工厂会通过构造方法为对象的属性赋值。由于某些框架或者项目中并没有为JavaBean提供Setter方法，我们就可以利用其构造方法来注入。

定义一个JavaBean对象，为其提供构造方法

public class Student {
    private Integer id;
    private String name;
    private String sex;
    private Integer age;
  
    //Constructors
    public Student(Integer id , String name , String sex , Integer age){
        this.id = id;
        this.name = name;
        this.sex = sex;
        this.age = age;
    }
}

构造方法注入

// 构造注入
<bean id="u3" class="com.mylifes1110.bean.Student">
    // 除标签名称有变化,其他均和Set注入一致 
    <constructor-arg name="id" value="1234" /> 
    <constructor-arg name="name" value="tom" />
    <constructor-arg name="age" value="20" />
    <constructor-arg name="sex" value="male" />
</bean>

3、基于 XML 配置文件的自动注入

不用在配置中指定为哪个属性赋值，及赋什么值。由spring自动根据某个 "原则" ，在工厂中查找一个bean，为属性注入属性值。

将 Dao 层实现类对象注入到 Service 层并调用方法得以测试

package com.mylifes1110.service.impl;
​
import com.mylifes1110.bean.User;
import com.mylifes1110.dao.UserDao;
import com.mylifes1110.service.UserService;
​
public class UserServiceImpl implements UserService {
    // 待注入的对象
    private UserDao userDao;   
​
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }
​
    @Override
    public int insertUser(User user) {
        System.out.println("------insertUser and UserService------");
        return userDao.insertUser(null);
    }
}

自动注入的两种方式

● 基于名称自动注入值

<bean id="UserDao"  class="com.mylifes1110.dao.impl.UserDaoImpl"/>
     // 基于名称为UserServiceImpl中的属性自动注入值
    <bean id="userService" class="com.mylifes1110.service.impl.userServiceImpl"  autowire="byName"/>
</beans> 

● 基于类型自动注入值
根据实现的接口来判断并自动注入值，如果实现此接口的实现类太多，它会在很多实现此接口的实现类中选择名字相同的实现类进行注入。（先根据类型判断，如果不成功，再根据名称注入）

<bean id="userDao" class="com.mylifes1110.dao.UserDaoImpl" />
    // 基于类型为UserServiceImpl中的属性自动注入值
    <bean id="userService" class="com.mylifes1110.service.impl.UserServiceImpl" autowire="byType"/> 
</beans> 

4、基于注解自动注入

配置注解扫描，告诉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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
	        https://www.springframework.org/schema/beans/spring-beans.xsd
	        http://www.springframework.org/schema/context
	        https://www.springframework.org/schema/context/spring-context.xsd">
		
		<!--扫描注解所在的包-->
         <context:component-scan base-package="com.spring"/>
</beans>

● @Autowired 基于类型自动注入；
● @Resource 基于名称自动注入；
● @Qualifier(“userDAO”) 限定要自动注入的 bean 的 id，一般和 @Autowired 联用；
● @ Value 注入简单类型数据 （ jdk8种基本数据类型+String类型 ）

使用基于类型自动注入，将 Dao 层注入到 Service 层

@Service
public class UserServiceImpl implements UserService {   
    @Autowired //注入类型为UserDao的bean
    @Qualifier("userDao") //如果有多个类型为UserDao的bean,可以用此注解从中指定一个
    private UserDao userDao;
}

使用基于名称自动注入，将 Dao 层注入到 Serivce 层

@Service
public class UserServiceImpl implements UserService {   
    @Resource("userDao") //注入id=“userDao”的bean
    private UserDao userDao;
}

使用注入简单类型数据注解来完成简单注入 JavaBean

public class User{
    @Value("1")    //注入数字
    private Integer id;
    @Value("Ziph") //注入String
    private String name;
}

六、Spring AOP

AOP 即 Aspect Oriented Program 面向切面编程。如果说 IoC 是 Spring 的核心，那么面向切面编程就是 Spring 最为重要的功能之一了，在数据库事务中切面编程被广泛使用。
AOP 是通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。利用 AOP 可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

首先，在面向切面编程的思想里面，把功能分为核心业务功能，和周边功能。

周边功能在 Spring 的面向切面编程AOP思想里，即被定义为切面。
在面向切面编程AOP的思想里面，核心业务功能和切面功能分别独立进行开发，然后把切面功能和核心业务功能 “编织” 在一起，这就叫 AOP。

AOP 的目的

AOP 能够将那些与业务无关，却为业务模块所共同调用的逻辑或任务（例如事务处理、日志管理、权限控制等）封装起来，便于减少系统的重复代码，降低模块间的耦合度，并有利于未来的可拓展性和可维护性。

AOP 当中的概念：

1、Spring 支持的 5 种 Advice

Spring AOP 中，通过 Advice 定义横切逻辑，Spring 中支持 5 种类型的 Advice：

2、AOP 的使用——XML 方式

引入依赖包

<properties>
    <org.springframework.version>5.1.9.RELEASE</org.springframework.version>
</properties>

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aop</artifactId>
        <version>5.1.12.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjrt</artifactId>
        <version>1.8.9</version>
    </dependency>
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.9.1</version>
        <scope>runtime</scope>
    </dependency>

    <!-- Spring核心依赖 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <version>${org.springframework.version}</version>
    </dependency>
    <!-- Spring beans包-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-beans</artifactId>
        <version>${org.springframework.version}</version>
    </dependency>
    <!-- Spring 容器包 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>${org.springframework.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-expression</artifactId>
        <version>${org.springframework.version}</version>
    </dependency>
</dependencies>

1）目标对象类

目标对象里的每个方法都是连接点，每个连接点都可以作为被增强的切入点。

定义现场表演的接口 Performance 和它的实现类 SleepNoMore：

package chapter04.concert;   

/**  
* 现场表演,如舞台剧,电影,音乐会  
*/

public interface Performance {
    void perform();
     } 

package chapter04.concert;   
import org.springframework.stereotype.Component;  

 /**  
 * 戏剧:《不眠之夜Sleep No More》  
 */ 
 
public class SleepNoMore implements Performance {
    @Override
    public void perform() {
        System.out.println("戏剧《不眠之夜Sleep No More》");
    } 
    } 

2）通知/增强

定义一个观众的增强类：

package chapter04.concert;
 
import org.aspectj.lang.annotation.Aspect;
 
/**
 * 观众
 */
 
public class Audience {
	 /**
     * 业务逻辑开始之前执行
     */
    public void beforeMethod(JoinPoint joinPoint) {
        Object[] args = joinPoint.getArgs();
        for (int i = 0; i < args.length; i++) {
            Object arg = args[i];
            System.out.println(arg);
        }
        System.out.println("观众就坐.......");
    }

    /**
     * 业务逻辑结束时执行（无论异常与否）
     */
    public void afterMethod() {
        System.out.println("表演结束.......");
    }

    /**
     * 异常时时执行
     */
    public void exceptionMethod() {
        System.out.println("表演失败之后,观众要求退款.......");
    }

    /**
     * 业务逻辑正常时执行，参数名称可以配置是指定`retVal`
     */
    public void successMethod(Object retVal) {
        System.out.println("表演正常进行.......");
    }

    /**
     * 环绕通知 可替代其他四种通知，不推荐与其他四种通知同时使用。
     * 环绕通知 类似代理模式拦截方法
     *
     */
    public Object arroundMethod(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕通知中的beforemethod....");
        Object result = null;
        try{
            // 控制原有业务逻辑是否执行
            // result = proceedingJoinPoint.proceed(proceedingJoinPoint.getArgs());
        }catch(Exception e) {
            System.out.println("环绕通知中的exceptionmethod....");
        }finally {
            System.out.println("环绕通知中的after method....");
        }

        return result;
    }
}

3）XML 配置切面

<?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: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/aop
		http://www.springframework.org/schema/aop/spring-aop.xsd">


    <!--注册 bean，注册目标类和通知类实例-->
    <bean id="sleepNoMore" class="spring.aop.target.SleepNoMore"/>
    <bean id="audience" class="spring.aop.advice.Audience"/>

    <!--使用 config 标签表明开始 aop 配置,在内部配置切面 aspect-->
    <!--aspect = 切入点（锁定方法）+ 方位（锁定方法中的特殊时机）+ 横切逻辑 -->
    <!--使用 aspect 将切入点和通知联系起来 -->
    <aop:config>
        <!-- 配置一个日志切面 -->
        <aop:aspect  ref="audience">
            <!--切入点锁定我们需要拦截的方法，使用aspectj语法表达式：返回值 类全限定名.方法(参数)
            返回值：可以用 * 代替任意返回值
               类全限定名：可以使用*代替任意包，或者代替任意类，使用..代替任意层级的包（零到多个层级任意名称的包）
            方法：可以使用*代替任意方法
            参数：可以使用*代替任意参数（必须有参数）使用..代替任意参数（可以没有参数）-->
            <aop:pointcut id="point" expression="execution(* spring.aop.target.SleepNoMore.*(..))"/>

            <!--方位信息,pointcut-ref关联切入点-->
            <!--aop:before前置通知/增强-->
            <aop:before method="beforeMethod" pointcut-ref="point"/>
            <!--aop:after，最终通知，无论如何都执行-->
            <aop:after method="afterMethod" pointcut-ref="point"/>
            <!--aop:after-returnning，正常执行通知，returning：指定返回值注入的参数名称-->
            <aop:after-returning method="successMethod" returning="retVal" pointcut-ref="point"/>
            <!--aop:after-throwing，异常通知-->
            <aop:after-throwing method="exceptionMethod" pointcut-ref="point"/>
            <!--环绕通知配置，不推荐和以上四种同时使用-->
            <aop:around method="arroundMethod" pointcut-ref="point"/>
        </aop:aspect>
    </aop:config> 
    </beans> 

Expression 表达式简单说明：
配置切点的时候，spring使用expression表达式定位方法，这里简单说明一下如何写：
● 唯一定位：

expression="execution(public void com.lagou.edu.service.impl.TransferServiceImpl.transfer(String,String,int))"> 

要将方法作用域，返回值类型，类全限定名，方法名，方法参数类型列表全部写上。

● 批量定位

批量定位就是，有些地方可以用*或者.来表示任意名称，* 和 . 的区别是，* 最少有一个，.可以一个都没有。
方法作用域可以省略，其他可以用 * 和 . 替换。

expression="execution(* com.wjy.service..*.*(..)) 

上面表示，拦截com.wjy.service包及任意层级子包下任意类的任意方法，参数可有可无，返回值任意类型

4）测试

public class test {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

        // 动态代理代理的是接口：注意点
        Performance performance = (Performance) context.getBean("sleepNoMore");
        performance.perform();
    }
}

3、AOP 的使用—— 注解方式

1）目标对象类

目标对象里的每个方法都是连接点，每个连接点都可以作为被增强的切入点。

定义现场表演的接口 Performance 和它的实现类 SleepNoMore：

package chapter04.concert;   

/**  
* 现场表演,如舞台剧,电影,音乐会  
*/

public interface Performance {
    void perform();
     } 

package chapter04.concert;   
import org.springframework.stereotype.Component;  

 /**  
 * 戏剧:《不眠之夜Sleep No More》  
 */ 
 
 @Component 
 public class SleepNoMore implements Performance {
    @Override
    public void perform() {
        System.out.println("戏剧《不眠之夜Sleep No More》");
    } 
    } 

2）定义一个观众的切面类

package chapter04.concert;
 
import org.aspectj.lang.annotation.Aspect;
 
/**
 * 观众
 * 使用@Aspect注解定义为切面
 */
@Aspect
@Component
public class Audience {

/**
 * 表演之前,观众就座
 */
@Before("execution(* spring.aop.target.SleepNoMore.perform(..))")
public void takeSeats() {
    System.out.println("Taking seats");
}
 
/**
 * 表演之前,将手机调至静音
 */
@Before("execution(* spring.aop.target.SleepNoMore.perform(..))")
public void silenceCellPhones() {
    System.out.println("Silencing cell phones");
}

/**
 * 表演结束,不管表演成功或者失败
 */
@After("execution(* spring.aop.target.SleepNoMore.perform(..))")
public void finish() {
    System.out.println("perform finish");
}

/**
 * 表演之后,鼓掌
 */
@AfterReturning("execution(* spring.aop.target.SleepNoMore.perform(..))")
public void applause() {
    System.out.println("CLAP CLAP CLAP!!!");
}

/**
 * 表演失败之后,观众要求退款
 */
@AfterThrowing("execution(* spring.aop.target.SleepNoMore.perform(..))")
public void demandRefund() {
    System.out.println("Demanding a refund");
}
}

3）XML 配置

注解扫描，告诉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:aop="http://www.springframework.org/schema/aop"
       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/aop http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

	<!-- 扫包-->
    <context:component-scan base-package="spring.aop"/>
    <!-- 启用 @AspectJ，生成代理对象-->
    <aop:aspectj-autoproxy/>
</beans>

5、AOP 的实现原理

Spring 的 AOP 实现原理其实很简单，就是通过动态代理实现的。如果我们为 Spring 的某个 bean 配置了切面，那么 Spring 在创建这个 bean 的时候，实际上创建的是这个 bean 的一个代理对象，我们后续对 bean 中方法的调用，实际上调用的是代理类重写的代理方法。而 Spring 的 AOP 使用了两种动态代理，分别是 JDK 的动态代理和 CGLib 的动态代理。

1、JDK 动态代理

Spring 默认使用 JDK 的动态代理实现 AOP，类如果实现了接口，Spring 就会使用这种方式实现动态代理。JDK实现动态代理需要两个组件，首先第一个就是InvocationHandler接口。我们在使用JDK的动态代理时，需要编写一个类，去实现这个接口，然后重写invoke方法，这个方法其实就是我们提供的代理方法。然后JDK动态代理需要使用的第二个组件就是Proxy这个类，我们可以通过这个类的newProxyInstance方法，返回一个代理对象。

原理

JDK的动态代理是基于反射实现。JDK 通过反射，生成一个代理类，这个代理类实现了原来那个类的全部接口，并对接口中定义的所有方法进行了代理。当我们通过代理对象执行原来那个类的方法时，代理类底层会通过反射机制，回调我们实现的 InvocationHandler 接口的 invoke 方法。并且这个代理类是 Proxy 类的子类。

优点

● JDK动态代理是JDK原生的，不需要任何依赖即可使用；
● 通过反射机制生成代理类的速度要比CGLib操作字节码生成代理类的速度更快；

缺点

● 如果要使用JDK动态代理，被代理的类必须实现了接口，否则无法代理；
● JDK动态代理无法为没有在接口中定义的方法实现代理，假设我们有一个实现了接口的类，我们为它的一个不属于接口中的方法配置了切面，Spring仍然会使用JDK的动态代理，但是由于配置了切面的方法不属于接口，为这个方法配置的切面将不会被织入。
● JDK动态代理执行代理方法时，需要通过反射机制进行回调，此时方法执行的效率比较低；

2、CGLib 动态代理

JDK 的动态代理存在限制，那就是被代理的类必须是一个实现了接口的类，代理类需要实现相同的接口，代理接口中声明的方法。若需要代理的类没有实现接口，此时JDK的动态代理将没有办法使用，于是 Spring 会使用 CGLib 的动态代理来生成代理对象。CGLib直接操作字节码，生成类的子类，重写类的方法完成代理。

原理

CGLib 实现动态代理的原理是，底层采用了 ASM 字节码生成框架，直接对需要代理的类的字节码进行操作，生成这个类的一个子类，并重写了类的所有可以重写的方法，在重写的过程中，将我们定义的额外的逻辑（简单理解为Spring中的切面）织入到方法中，对方法进行了增强。而通过字节码操作生成的代理类，和我们自己编写并编译后的类没有太大区别。

优点

● 使用CGLib代理的类，不需要实现接口，因为CGLib生成的代理类是直接继承自需要被代理的类；
● CGLib生成的代理类是原来那个类的子类，这就意味着这个代理类可以为原来那个类中所有能够被子类重写的方法进行代理；
● CGLib生成的代理类，和我们自己编写并编译的类没有太大区别，对方法的调用和直接调用普通类的方式一致，所以CGLib执行代理方法的效率要高于JDK的动态代理；

缺点

● 由于CGLib的代理类使用的是继承，这也就意味着如果需要被代理的类是一个final类则无法使用CGLib代理；
● 由于CGLib实现代理方法的方式是重写父类的方法，所以无法对final方法或者private方法进行代理，因为子类无法重写这些方法；
● CGLib生成代理类的方式是通过操作字节码，这种方式生成代理类的速度要比JDK通过反射生成代理类的速度更慢；