2002年，Rod Jahnson首次推出了Spring框架雏形interface21框架。

2004年3月24日，Spring框架以interface21框架为基础，经过重新设计，发布了1.0正式版。

Rod Johnson 的学历 , 他是悉尼大学的博士，然而他的专业不是计算机，而是音乐学。

Spring理念 : 使现有技术更加实用 。本身可以认为是一个大杂烩 ,，就是整合了现有的框架技术

优点

  • Spring是一个开源免费的框架 , 容器 .
  • Spring是一个轻量级的框架 , 非侵入式的 .
  • 控制反转 IoC , 面向切面 Aop
  • 对事物的支持 , 对框架的支持

Spring是一个轻量级的控制反转 ( IoC ) 和面向切面 ( AOP ) 的容器（框架）
**Spring - 图1
组成 Spring 框架的每个模块（或组件）都可以单独存在，或者与其他一个或多个模块联合实现。每个模块的功能如下：

核心容器：核心容器提供 Spring 框架的基本功能。核心容器的主要组件是 BeanFactory ，它是工厂模式的实现。BeanFactory 使用控制反转（ IOC） 模式将应用程序的配置和依赖性规范与实际的应用程序代码分开。

Spring 上下文：Spring 上下文是一个配置文件，向 Spring 框架提供上下文信息。Spring 上下文包括企业服务，例如 JNDI、EJB、电子邮件、国际化、校验和调度功能。

Spring AOP：通过配置管理特性，Spring AOP 模块直接将面向切面的编程功能 , 集成到了 Spring 框架中。所以，可以很容易地使 Spring 框架管理任何支持 AOP的对象。Spring AOP 模块为基于Spring 的应用程序中的对象提供了事务管理服务。通过使用 Spring AOP，不用依赖组件，就可以将声明性事务管理集成到应用程序中

Spring DAO：JDBC DAO 抽象层提供了有意义的异常层次结构，可用该结构来管理异常处理和不同数据库供应商抛出的错误消息。异常层次结构简化了错误处理，并且极大地降低了需要编写的异常代码数量（例如打开和关闭连接）。Spring DAO 的面向 JDBC 的异常遵从通用的 DAO 异常层次结构。

Spring ORM：Spring 框架插入了若干个 ORM 框架，从而提供了 ORM 的对象关系工具，其中包括 JDO、Hibernate 和 iBatis SQL Map。所有这些都遵从 Spring 的通用事务和 DAO 异常层次结构。

Spring Web 模块：Web 上下文模块建立在应用程序上下文模块之上，为基于 Web 的应用程序提供了上下文。所以，Spring 框架支持与 Jakarta Struts 的集成。Web 模块还简化了处理多部分请求以及将请求参数绑定到域对象的工作。

Spring MVC 框架：MVC 框架是一个全功能的构建 Web 应用程序的 MVC 实现。通过策略接口，MVC 框架变成为高度可配置的，MVC 容纳了大量视图技术，其中包括 JSP、Velocity、Tiles、iText 和 POI。

IOC

ioc是一个容器，无论依赖注入还是自动装配的bean中都被保存在ioc容器中，被spring管理和使用

  • 容器启动会实例所有的bean
  • autowire自动装配时，是从容器中寻找合适的bean
  • getbean也是去容器中找bean实例
  • 容器是一个map，map中保持好所有创建的bean，并提供给外界使用

    依赖注入DI

    依赖 : 指 bean 对象所依赖的资源

注入 : 指 bean 对象所依赖的资源 (属性值等)，由容器来设置和装配

反射实现对象的创建，在xml文件中，当有一个bean时，xml会自动的生成一个对象，供java程序去使用，bean属性的赋值是通过调用对象的set方法进行赋值。

  1. <!--
  2. bean可以注册一个组件(对象、类)
  3. class：组件的全类名
  4. id：对象的唯一标识
  5. -->
  6. <bean id="person01" class="com.spring.ioc.Person" >
  7.     <property name="age"  value="19"></property>
  8.     <property name="name"  value="张三"></property>
  9. </bean>

通过class对象来获取xml中的对象

  1. <bean id="person02" class="com.spring.ioc.Person" >
  2.     <property name="age"  value="19"></property>
  3.     <property name="name"  value="李四"></property>
  4. </bean>
  1. //当xml文件中只有一个bean时，通过class对象来获得bean，但当bean有多个时，ioc.xml文件无法正常匹配
  2. //No qualifying bean of type 'com.spring.ioc.Person' available:
  3. //expected single matching bean but found 2: person01,person02
  4. Person bean = ioc.getBean(Person.class);

当有多个bean时，如果想用class对象获取对象，必须通过指定id名来获取

  1. //通过class对象获得必须指定响应的name值
  2. Person person02 = ioc.getBean("person02", Person.class);
  3. System.out.println(person02);

构造器注入

通过有参构造器赋值

  1. <bean id="person03" class="com.spring.ioc.Person">
  2.     <!-- 通过有参构造器来创建对象并赋值 -->
  3.     <constructor-arg name="name" value="王五"></constructor-arg>
  4.     <constructor-arg name="age" value="20"></constructor-arg>
  5. </bean>

省略name属性赋值

  1. <!--  省略name属性还赋值 -->
  2. <bean id="person04" class="com.spring.ioc.Person">
  3. <!--  不指定响应name值，就必须按照顺序传入-->
  4.     <constructor-arg value="小米"></constructor-arg>
  5.     <!-- 如果顺序不正确时，可以使用index来指定参数的位置-->
  6.     <constructor-arg value="16"></constructor-arg>
  7.     <!-- 如果两个构造器的参数相同时，可以指定type的类型来使得参数的传入正确    -->
  8. </bean>

使用p名称空间注入

  1. <!-- 使用p名称来为bean赋值-->
  2. <!-- 名称空间：xml中防止标签重复 -->
  3. <bean id="person05" class="com.spring.ioc.Person" p:name="p名称" p:age="12"></bean>

Set注入

为复杂属性赋值

  1. <bean id="car01" class="com.spring.factory.Car">
  2.     <property name="carName" value="宝马"></property>
  3.     <property name="carNum" value="123123"></property>
  4.     <property name="length" value="200"></property>
  5.  </bean>
  6. <bean id="person01" class="com.spring.ioc.Person">
  7.     <!--为赋值属性的赋值都需要写在property中-->
  8.     <property name="name">
  9.         <!--为对象的属性设置为null,value=null得到的是字符串-->
  10.         <null></null>
  11.     </property>
  12.     <!-- ref表示引用的意思,引用外部的值,与xml中car01创建的对象是相同的对象，只是引用不同而已-->
  13.     <property name="car" ref="car01"></property>
  14.     <property name="car">
  15.         <bean class="com.spring.factory.Car">
  16.             <!--为复杂属性赋值-->
  17.             <property name="carName" value="法拉利"></property>
  18.             <property name="carNum" value="123123"></property>
  19.             <property name="length" value="200"></property>
  20.         </bean>
  21.     </property>
  22. </bean>

注：内部bean中设置id是无效的，无法通过getbean获取

为list赋值

  1. <bean id="person02" class="com.spring.ioc.Person">
  2.     <property name="list">
  3.         <list>
  4.             <value>1</value>
  5.             <value>2</value>
  6.         </list>
  7.     </property>
  8. </bean>

为map赋值

  1. <property name="map">
  2.     <map>
  3.         <!--entry表示一个键值对-->
  4.         <entry key="key01" value="mao01"></entry>
  5.         <entry key="key02" value-ref="car01"></entry>
  6.         <entry key="key03">
  7.             <bean class="com.spring.factory.Car">
  8.                 <property name="carName" value="东风"></property>
  9.             </bean>
  10.         </entry>
  11.     </map>
  12. </property>

为properties配置类赋值

  1. <property name="properties">
  2.     <props>
  3.         <!--prop都是字符串，以k=v形式-->
  4.         <prop key="username" >root</prop>
  5.         <prop key="password">123456</prop>
  6.     </props>
  7. </property>

使用util名称空间

  1. <!--使用util名称空间赋值-->
  2. <util:map id="myMap">
  3.     <!--entry表示一个键值对-->
  4.     <entry key="key01" value="mao01"></entry>
  5.     <entry key="key02" value-ref="car01"></entry>
  6.     <entry key="key03">
  7.         <bean class="com.spring.factory.Car">
  8.             <property name="carName" value="东风"></property>
  9.         </bean>
  10.     </entry>
  11. </util:map>

级联属性赋值

  1. <!--级联属性赋值：属性的属性-->
  2. <bean id="person03" class="com.spring.ioc.Person">
  3.     <property name="car" ref="car01"></property>
  4.     <property name="car.carName" value="奥迪"></property>
  5. </bean>

继承实现bean中配置信息的重用，但不是同一对象

  1. <!--继承实现bean中配置信息的重用-->
  2. <bean id="person04" class="com.spring.ioc.Person" >
  3.     <property name="age"  value="19"></property>
  4.     <property name="name"  value="张三"></property>
  5. </bean>
  6. <bean id="person05" parent="person04">
  7.     <property name="name" value="李四"></property>
  8.     <property name="car" ref="car01"></property>
  9. </bean>

abstract属性创建一个模板bean

  1. <!--不能创建一个关于该bean的一个实例，只能通过继承实现-->
  2. <bean id="person04" class="com.spring.ioc.Person" abstract="true">
  3.     <property name="age"  value="19"></property>
  4.     <property name="name"  value="张三"></property>
  5. </bean>

bean之间的依赖

depend-on：

  • 指定相应的bean，会按照从左到右一次创建对象

bean的作用域

prototype

  • 多实例的
  • 默认不会自动创建对象

  • 每次getbean，xml都有自动的创建对象

    singleton

  • 单实例的

  • 默认会自动创建对象
  • 无论如何getbean，xml中只有一个对象
  1. <bean id="person06" class="com.spring.ioc.Person" scope="singleton"></bean>
  2. <bean id="person07" class="com.spring.ioc.Person" scope="prototype"></bean>

静态工厂和实例工厂

静态工厂

  1. <!--静态工厂
  2.     factory-method:指定工厂方法
  3.     constructor-arg：可以为方法指定参数
  4. -->
  5. <bean id="car01" class="com.spring.factory.CarStaticFactory" factory-method="createCar">
  6.     <!-- constructor-arg 可以为方法指定参数-->
  7.     <constructor-arg value="宝马"></constructor-arg>
  8. </bean>

实例工厂

  1. <!--实例工厂
  2. 1.需要先创建一个实例工厂
  3. -->
  4. <bean id="carfactory" class="com.spring.factory.CarInstanceFactory"></bean>
  5. <!--
  6. 2.factory-bean：指定哪个实例工厂bean
  7. 3.factory-method：指定实例工厂中的工厂方法
  8. -->
  9. <bean id="car02" class="com.spring.factory.Car" factory-bean="carfactory" factory-method="createCar">
  10.     <!--赋值-->
  11.     <constructor-arg value="奔驰"></constructor-arg>
  12. </bean>

使用FactoryBean创建工厂

  • 实现FactoryBean类，spring会认为该类是个工厂
  • xml中配置好bean，则spring会自动的创建工厂

无论对象是单实例还是多实例的，factorybean只有在调用的时候才创建对象，容器启动阶段是不会创建对象的。

  1. package com.spring.factory;
  3. import org.springframework.beans.factory.FactoryBean;
  5. public class MyFactoryBeanImpl implements FactoryBean<Car> {
  6.     //调用时，spring会创建一个对象
  7.     public Car getObject() throws Exception {
  8.         System.out.println("MyFactoryBeanImpl被调用了....");
  9.         Car car = new Car();
  10.         car.setCarName("大众");
  11.         return car;
  12.     }
  13.     //获取对象class
  14.     public Class<?> getObjectType() {
  15.         return Car.class;
  16.     }
  17.     //是否是单实例的，是工厂会创建一个实例，不是则可以创建多个实例
  18.     public boolean isSingleton() {
  19.         return false;
  20.     }
  21. }
  1. <!--FactoryBean-->
  2. <bean id="myFactoryBeanImpl" class="com.spring.factory.MyFactoryBeanImpl"></bean>

Bean的生命周期

ioc容器中的bean：

  • 单实例下，容器启动时就创建对象，容器关闭时则销毁创建bean
  • 多实例下，当获取的时候，对象才会被创建；容器关闭不会销毁

自定义方法测试

  1. <bean id="car03" class="com.spring.factory.Car" destroy-method="myDestory" init-method="myInit"></bean>

bean的后置处理器

  • 实现BeanPostProcessor类
  • 将MybeanPostProcessor注册进配置文件中

Car实体类

  1. public class Car {
  2.     private int carNum;
  3.     private String carName;
  4.     private int length;
  5.     //构造器调用
  6.     public Car() {
  7.         System.out.println("car被调用");
  8.     }
  9.     //car的初始化方法
  10.     public void myInit(){
  11.         System.out.println("bean被创建");
  12.     }
  13.     //car的销毁方法
  14.     public void myDestory(){
  15.         System.out.println("bean被销毁");
  16.     }
  17.     public int getCarNum() {
  18.         return carNum;
  19.     }
  21.     public void setCarNum(int carNum) {
  22.         this.carNum = carNum;
  23.     }
  25.     public String getCarName() {
  26.         return carName;
  27.     }
  29.     public void setCarName(String carName) {
  30.         this.carName = carName;
  31.     }
  33.     public int getLength() {
  34.         return length;
  35.     }
  37.     public void setLength(int length) {
  38.         this.length = length;
  39.     }
  41.     @Override
  42.     public String toString() {
  43.         return "Car{" +
  44.                 "carNum=" + carNum +
  45.                 ", carName='" + carName + '\'' +
  46.                 ", length=" + length +
  47.                 '}';
  48.     }
  49. }

MybeanPostProcessor后置处理器类

  1. public class MybeanPostProcessor implements BeanPostProcessor {
  3.     //初始化前调用
  4.     public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
  5.         System.out.println("【"+beanName+"】bean初始化前调用....postProcessBeforeInitialization");
  6.         return bean;
  7.     }
  8.     //初始化后调用
  9.     public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
  10.         System.out.println("【"+beanName+"】bean初始化后调用...postProcessAfterInitialization");
  11.         return bean;
  12.     }
  13. }

实现BeanPostProcessor接口，ioc初始bean时会自动调用这方法。

XML配置文件信息，需要指定bean中的自定义初始化方法

  1. <!--后置处理器-->
  2. <bean id="postProcessor" class="com.spring.bean.MybeanPostProcessor">
  3. </bean>
  4. <!--bean初始化 指定自定义的初始化方法和销毁方法-->
  5. <bean id="car" class="com.spring.factory.Car" init-method="myInit" 
  6.       destroy-method="myDestory">
  7. </bean>

测试类，获得测试结果

  1. public class BeanTest {
  2.     ApplicationContext ioc=new ClassPathXmlApplicationContext("bean/applicationContext.xml");
  3.     @Test
  4.     public void test01(){
  5.         Car car = (Car) ioc.getBean("car");
  6.         System.out.println(car);
  7.     }
  8. }

image.png
从结果可以看出，ioc容器被创建时，自动调用对象的构造器，在调用对象的初始化方法，而在初始化方法前后这插入后置处理器的方法。
即调用顺序：构造器—->before——>初始化——>after——>销毁方法
无论bean是否有自定义初始化方法，后置处理器都会默认有此方法。

Spring管理连接池

在maven中到入c3p0连接池jar包和mysql连接的依赖

  1. <dependency>
  2.   <groupId>com.mchange</groupId>
  3.   <artifactId>c3p0</artifactId>
  4.   <version>0.9.5.3</version>
  5. </dependency>
  6. <dependency>
  7.   <groupId>mysql</groupId>
  8.   <artifactId>mysql-connector-java</artifactId>
  9.   <version>5.1.47</version>
  10. </dependency>

在配置文件中配置好链接

  1. <!--引用外部属性文件，spring管理连接池-->
  2. <!--数据库连接池最好是单实例的-->
  3. <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
  4.   <property name="user" value="root"></property>
  5.   <property name="password" value="123456"></property>
  6.   <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/spring"></property>
  7.   <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
  8. </bean>

image.png
获得链接池的链接

引用外部属性配置文件

需要导入spring-context的jar包

  1. <dependency>
  2.   <groupId>org.springframework</groupId>
  3.   <artifactId>spring-context</artifactId>
  4.   <version>4.3.6.RELEASE</version>
  5. </dependency>

在bin目录下写数据库链接的配置文件

  1. jdbc.username=root
  2. password=123456
  3. jdbcUrl=jdbc:mysql://localhost:3306/spring
  4. driverClass=com.mysql.jdbc.Driver

注：username是xml中的一个关键字，为了防止冲突，因此需要将配置文件中的名字修改

  1. <!--加载外部配置文件-->
  2. <context:property-placeholder location="classpath:dbconfig.properties"></context:property-placeholder>
  3. <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
  4.   <property name="user" value="${jdbc.username}"></property>
  5.   <property name="password" value="${password}"></property>
  6.   <property name="jdbcUrl" value="${jdbcUrl}"></property>
  7.   <property name="driverClass" value="${driverClass}"></property>
  8. </bean>

导入context标签加载外部配置文件
${username}是什么？
它是计算机的用户名

源码文件夹和普通文件夹

resource目录下的文件，一般的存储在bin目录下，随着.class文件一起被编译

自动装配Bean

对象的赋值：

  • java文件中赋值
  • ioc容器中bean标签property中赋值

  • 自动装配

    autowire

    自动赋值:

  • default：不自动装配

  • byName：以属性名作为id去ioc容器中寻找
  • byType：根据类型去ioc容器中寻找

  • constructor：根据构造器

    XML自动装配

    byName的自动装配

    创建一个Person类和Car类，其中Person类中有Car类的变量
    Car类

    1. public class Car {
    2.   private int carNum;
    3.   private String carName;
    4.   private int length;
    6.   public int getCarNum() {
    7.       return carNum;
    8.   }
    10.   public void setCarNum(int carNum) {
    11.       this.carNum = carNum;
    12.   }
    14.   public String getCarName() {
    15.       return carName;
    16.   }
    18.   public void setCarName(String carName) {
    19.       this.carName = carName;
    20.   }
    22.   public int getLength() {
    23.       return length;
    24.   }
    26.   public void setLength(int length) {
    27.       this.length = length;
    28.   }
    30.   @Override
    31.   public String toString() {
    32.       return "Car{" +
    33.               "carNum=" + carNum +
    34.               ", carName='" + carName + '\'' +
    35.               ", length=" + length +
    36.               '}';
    37.   }
    38. }

    Person类 ```java public class Person { private String name; private int age; private Car car; private List list; private Properties properties;

    public Properties getProperties() {

    1.   return properties;

    }

    public void setProperties(Properties properties) {

    1.   this.properties = properties;

    }

    public void setCar(Car car) {

    1.   this.car = car;

    }

    public void setList(List list) {

    1.   this.list = list;

    }

  1. public void setMap(Map<String, Object> map) {
  2.     this.map = map;
  3. }
  5. private Map<String,Object> map;
  6. public Person() {
  7.     System.out.println("person对象被创建...");
  8. }
  10. public Car getCar() {
  11.     return car;
  12. }
  14. public List<Integer> getList() {
  15.     return list;
  16. }
  18. public Person(String name, int age) {
  19.     this.name = name;
  20.     this.age = age;
  21. }
  22. public String getName() {
  23.     return name;
  24. }
  26. public void setName(String name) {
  27.     this.name = name;
  28. }
  31. public Map<String, Object> getMap() {
  32.     return map;
  33. }
  35. @Override
  36. public String toString() {
  37.     return "Person{" +
  38.             "name='" + name + '\'' +
  39.             ", age=" + age +
  40.             ", car=" + car +
  41.             ", list=" + list +
  42.             ", properties=" + properties +
  43.             ", map=" + map +
  44.             '}';
  45. }
  47. public int getAge() {
  48.     return age;
  49. }
  51. public void setAge(int age) {
  52.     this.age = age;
  53. }

}

  1. 在xml中配置以byName的形式自动装配
  2. ```xml
  3. <bean id="car" class="com.spring.factory.Car">
  4.   <property name="carName" value="宝马"></property>
  5. </bean>
  6. <bean id="person" class="com.spring.ioc.Person" autowire="byName"></bean>

获得结果
image.png
xml中Car对象被自动装配到了Person中，据此，ByName属性是根据Person中Car类的属性名作为id的，根据这个id，去寻找在ioc容器中相同类名的Bean标签进行匹配的。
如果属型名car改为car1，则Person对象中car并没有被赋值。
image.png

byType的自动装配

  1. <bean id="car1" class="com.spring.factory.Car">
  2.   <property name="carName" value="宝马"></property>
  3. </bean>
  4. <bean id="person" class="com.spring.ioc.Person" autowire="byType"></bean>

byType自动装配是根据是否为同类进行匹配的，无论属性名如何，只要是同类对象，byType都能匹配上，唯一的缺点就是bean中不允许两个相同的bean，不然ioc容器会找不到对象。

Constructor的自动装配

在Person类中添加Car的构造器方法

  1. public Person(Car car1) {
  2.     this.car1 = car1;
  3. }

xml文件修改为constructor

  1. <bean id="car1" class="com.spring.factory.Car">
  2.   <property name="carName" value="宝马"></property>
  3. </bean>
  4. <bean id="person" class="com.spring.ioc.Person" autowire="constructor"></bean>

image.png
可以看到Car对象已经赋值给Person对象中了。

constructor装配，先按照有参构造器的类型进行装配，没有就赋值问null；如果ioc容器中类型有多个的话，就以属性名作为id进行装配。

自动装配的应用：

  • 主要给自定义类型进行赋值，基本类型不能使用自动装配

    注解自动装配

    依赖注入（DI）
    首先创建UserDao、UserService、UserController类这三层MVC架构
    UserDao类
    1. @Repository
    2. public class UserDao {
    3.   public void save(){
    4.       System.out.println("userDao...");
    5.   }
    6. }
    UserService类
    1. @Service
    2. public class UserService {
    3.   @Autowired
    4.   private UserDao userDao;
    5.   public void save(){
    6.       userDao.save();
    7.       System.out.println("userService...");
    8.   }
    9. }
    UserController类
    1. @Controller
    2. public class UserController {
    3.   @Autowired
    4.   private UserService userService;
    5.   public void save(){
    6.       userService.save();
    7.       System.out.println("userController...");
    8.   }
    9. }
    单元测试
    1. @Test
    2.   public void test02(){
    3.       UserController controller = (UserController) ioc.getBean("userController");
    4.       controller.save();
    5.   }
    xml配置，开启包扫描
    1. <!--指定哪个包开始包扫描-->
    2. <context:component-scan base-package="com.spring,annotation"></context:component-scan>
    显示结果
    image.png
    从结果可以看出，注解自动装配极大的减少了xml配置信息的修改，减少程序猿的工作量，但是注解在仅仅只是使用在一些不是十分重要的代码上，如果像是权限管理等这些aop切面操作时，需要单独写在xml文件中。

    autowire原理

    首先按照类型去容器中寻找组件，找到就赋值；如果找到多个组件，会按照id去容器中寻找bean。
    当有一个UserServiceExt继承UserService时，并且自动装配，如果Controller层使用的UserService变量名和这两个类名不相同时，会报错。因此需要采用注解Qualifier来对UserService赋值

    使用Qualifier指定使用bean的id

    1. public class UserController {
    2.   @Autowired
    3.   @Qualifier("userService")
    4.   private UserService userServiceExt1;
    5.   public void save(){
    6.       userServiceExt1.save();
    7.       System.out.println("userController...");
    8.   }
    9. }
    如果Qualifier指定其他的id，找不到则会报错

    required指定某属性允许不被设置

    1. public class UserController {
    2.   @Autowired(required = false)
    3.   @Qualifier("userServicehh")
    4.   private UserService userServiceExt1;
    5.   public void save(){
    6.       userServiceExt1.save();
    7.       System.out.println("userController...");
    8.   }
    9. }
    required时autowire的属性，默认时true，设置为false时，得到的UserService变量为null

SpEL

spring表达式，格式#{}，可以计算、获取其他bean的属性和方法，通过id，略微介绍

注解代替XML

添加上注解，可以快速的将bean加入到ioc容器中
四大注解：

  • Controller：给控制器层（servlet的包下）的组件添加
  • Service：给业务层（service层）的组件添加
  • Repository：给数据库层（Dao层、持久化层）的组件添加
  • Component：描述spring中的bean，不属于以上三层，仅仅只是一个bean而已

注解使用

想要使用注解，就必须导入spring-context，利用包扫描机制，将给组件添加进ioc容器中

  1. <!--指定哪个包开始包扫描-->
  2. <context:component-scan base-package="com.spring,annotation"></context:component-scan>

创建UserDao类

  1. @Repository
  2. public class UserDao {
  3.     public void save(){
  4.         UserDao bean = ioc.getBean(UserDao.class);
  5.         UserDao userDao = (UserDao) ioc.getBean("userDao");
  6.         bean.save();
  7.         userDao.save();
  8.         System.out.println(bean==userDao);
  9.     }
  10. }

单元测试查看是否创建userdao对象

  1. public class AnnotationTest {
  2.     ApplicationContext ioc=new ClassPathXmlApplicationContext("annotation/applicationContext.xml");
  3.     @Test
  4.     public void test01(){
  5.         UserDao bean = ioc.getBean(UserDao.class);
  6.         bean.save();
  7.     }
  8. }

结果
image.png
通过类名小写或者获得类的class来创建对象，得到的对象都是同一对象，是单实例的，并且可以看到通过注解，快速的将一个对象加入ioc容器中。

修改为多实例

  1. @Repository
  2. @Scope(value = "prototype")
  3. public class UserDao {
  4.     public void save(){
  5.         System.out.println("userDao...");
  6.     }
  7. }

image.png
可以看到，两个实例不是相同的

指定不使用哪个类

  1. <!--annotion:指定注解不使用
  2.          assignable:指定哪个类不适用
  3. -->
  4. <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
  5. <context:exclude-filter type="assignable" expression="com.spring.annotation.control.UserController"/>

指定使用哪个类

  1. <context:include-filter type="annotation" expression=""/>

和上面那个一样

泛型依赖注入

定义两个实体类
image.png

实现Dao和Service层
image.png
image.png
可以看到User和Book的Dao和Service都继承于Base
而BaseDao和BaseService是一个泛型类

  1. public abstract class BaseDao<T> {
  2.     public abstract void save();
  3. }
  1. @Repository
  2. public class BookDao extends BaseDao<Book>{
  3.     public void save(){
  4.         System.out.println("BookDao为你保存图书");
  5.     }
  6. }
  1. @Repository
  2. public class UserDao extends BaseDao<User>{
  3.     public void save(){
  4.         System.out.println("UserDao为你保存用户");
  5.     }
  6. }

UserDao和BookDao都继承实现了BaseDao的save方法

  1. public class BaseService<T> {
  2.     @Autowired
  3.     BaseDao<T> baseDao;
  4.     public void save(){
  5.         baseDao.save();
  6.     }
  7. }

User和Book的Dao、Service都继承于这两个

  1. @Service
  2. public class BookService extends BaseService<Book>{
  3. }
  1. @Service
  2. public class UserService extends BaseService<User>{
  3. }

Service类并没有写任何东西，只是继承BaseService，而在BaseService中，只是调用泛型的BaseDao类实例，并且自动装配，它继承的子类，都会继承这个自动装配，从而通过泛型，实现了User和Book调用自己的Dao层方法。
单元测试

  1. ApplicationContext ioc=new ClassPathXmlApplicationContext("generic/applicationContext.xml");
  2. @Test
  3. public void test01(){
  4.     BaseService bookService = (BaseService) ioc.getBean("bookService");
  5.     UserService userService = (UserService) ioc.getBean("userService");
  6.     bookService.save();
  7.     userService.save();
  8. }

结果
image.png

AOP

AOP（Aspect Oriented Programming）意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP 是 OOP 的延续，是软件开发中的一个热点，也是 Spring 框架中的一个重要内容，是函数式编程的一种衍生范型。利用 AOP 可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率
即程序运行期间，将某段代码动态的插入到指定方法的指定位置进行运行，这就是AOP
Spring - 图14
在每个方法前后都添加一些处理函数，如果是原来的java程序的设计，就在目标方法内部进行修改，或者引入调用其他处理函数，这样的方法，大大的增强的代码的耦合度，而且及其不适合开发，修改也十分麻烦。如果是使用AOP的话，这减少代码的修改，只需要通过代理对象，就可以对目标方法进行修改。

AOP的使用场景

将其他代码公用部分抽取处理，成为一个切面，动态的切入进所有的函数中，如日志管理，权限验证等此类具有公用特点的处理形式，均可以作为切面切入到方法中。
使用场景：

  • 添加日志
  • 权限验证
  • 安全检测
  • 事务处理

    动态代理

    是AOP的实现原型，需要先创建一个接口，通过Proxy.newProxyInstance生成代理对象，通过代理对象，我们可以对目标方法进行增强。
    抽象类
    1. public interface Calculator {
    2.   public int add(int i,int j);
    3.   public int sub(int i,int j);
    4.   public int mul(int i,int j);
    5.   public int div(int i,int j);
    6. }
    实现动态代理必须创建抽象类，代理对象和被代理对象实现同一个接口

实体类，这是目标增强方法

  1. public class CalculatorImpl implements Calculator{
  2.     public int add(int i, int j) {
  3.         return i+j;
  4.     }
  6.     public int sub(int i, int j) {
  7.         return i-j;
  8.     }
  10.     public int mul(int i, int j) {
  11.         return i*j;
  12.     }
  14.     public int div(int i, int j) {
  15.         return i/j;
  16.     }
  17. }

代理类

  1. public class CalculatorProxy {
  2.     public static Calculator getProxy(final Calculator calculator){
  4.         //ClassLoader：目标对象的类加载器
  5.         ClassLoader classLoader = calculator.getClass().getClassLoader();
  6.         //Class<?>[]：目标对象的继承的接口
  7.         Class<?>[] classes = calculator.getClass().getInterfaces();
  8.         //方法加载类，会执行目标对象的目标方法，当方法运行时，jvm会自动将方法编码到此。
  9.         InvocationHandler invocationHandler = new InvocationHandler() {
  10.             /**
  11.              * Object proxy：代理对象，会交给jdk使用
  12.              * Method method：目标对象的目标方法
  13.              * Object[] args：目标方法的参数，防止重载找不到目标方法
  14.              */
  15.             public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  16.                 System.out.println("这是动态代理执行的方法");
  17.                 //反射执行目标方法
  18.                 //目标方法的返回值
  19.                 Object invoke = method.invoke(calculator, args);
  20.                 return invoke;
  21.             }
  22.         };
  23.         Object proxy = Proxy.newProxyInstance(classLoader, classes, invocationHandler);
  25.         return (Calculator)proxy;
  26.     }
  27. }

注：jdk的动态代理，如果目标对象没有任何接口，则无法为它创造代理对象
单元测试

  1. @Test
  2.     public void test01(){
  3.         Calculator calculator = new CalculatorImpl();
  4.         Calculator proxy = CalculatorProxy.getProxy(calculator);
  5.         System.out.println(proxy.getClass());
  6.         proxy.add(1,1);
  7.     }

image.png
从结果可以看出，获得proxy是一个代理类，通过接口实现

AOP名词

image.png

基于注解的AOP

@Component
@Aspect
要想使用Aspect注解，必须想导入AspectJ包和Aspectweaver包才能使用
Before：前置注解，在方法执行前执行
After：后置注解，在方法结束的时候执行
AfterReturning：在方法执行完成后执行
AfterThrowing：在方法出现异常之后执行
Around：给方法的执行前后添加处理方法

执行的切面类

  1. @Component
  2. @Aspect
  3. public class LogUtils {
  4.     @Before("execution(int com.spring.aop.calculator.CalculatorImpl.*(int,int))")
  5.     public void startLog(){
  6.         System.out.println("这是start的前置方法");
  7.     }
  8.     @After("execution(int com.spring.aop.calculator.CalculatorImpl.*(int,int))")
  9.     public void endLog(){
  10.         System.out.println("这是后置方法");
  11.     }
  12.     @AfterReturning("execution(int com.spring.aop.calculator.CalculatorImpl.*(int,int))")
  13.     public void returnLog(){
  14.         System.out.println("这是返回方法");
  15.     }
  16.     @AfterThrowing("execution(int com.spring.aop.calculator.CalculatorImpl.*(int,int))")
  17.     public void exceptionLog(){
  18.         System.out.println("这是异常方法");
  19.     }
  20. }

执行的切面类必须设置为ioc容器中的组件，并告诉ioc容器这是一个切面。

单元测试

  1. @Test
  2.     public void test02(){
  3.         ApplicationContext ioc=new ClassPathXmlApplicationContext("aop/applicationContext.xml");
  4.         Calculator bean = ioc.getBean(Calculator.class);
  5.         bean.add(1,1);
  6.     }

得到的结果是
image.png
这是通过AspectJ类实现的AOP功能，但是本质底层实现还是动态代理，目标对象必须实现接口类，不然aop就无法正常为它创建代理对象了
从他获得的class中可以看出，底层还是有动态代理实现的AOP功能
image.png
如果目标对象没有实现接口，则自动的由cglib为目标对象实现AOP，cglib并不需要接口来实现动态代理
image.png

基于XML的AOP

  1.  <!--将目标类和切面类加入到ioc容器中-->
  2.     <bean id="calculator" class="com.spring.aop.calculator.CalculatorImpl"></bean>
  3.     <bean id="logUtils" class="com.spring.aop.utils.LogUtils"></bean>
  5.     <!--aop名称空间-->
  6.     <aop:config>
  7.         <!--指定切面-->
  8.         <aop:aspect ref="logUtils">
  9.             <!--切入点表达式-->
  10.             <aop:pointcut id="pointCut" expression="execution(int com.spring.aop.calculator.CalculatorImpl.*(int,int))"/>
  11.             <!--指定通知方法-->
  12.             <aop:before method="startLog" pointcut-ref="pointCut"></aop:before>
  13.             <aop:after method="endLog" pointcut-ref="pointCut"></aop:after>
  14.             <!--要指定通知方法参数的类型-->
  15.             <aop:after-returning method="returnLog" pointcut-ref="pointCut" returning="result"></aop:after-returning>
  16.             <aop:after-throwing method="exceptionLog" pointcut-ref="pointCut" throwing="exception"></aop:after-throwing>
  17.             <aop:around method="aroundLog" pointcut-ref="pointCut" ></aop:around>
  18.         </aop:aspect>
  19.     </aop:config>

主要还是xml中的配置，比起注解，xml的配置比较繁琐

Cglib代理的底层实现原理

代理类

  1. public class CglibProxy {
  2.     public static Object getProxy(Object o){
  3.         //目标对象的Class，将其设为父类
  4.         Class aClass = o.getClass();
  5.         //设置回调函数
  6.         Callback callback = new MethodInterceptor() {
  7.             public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
  8.                 System.out.println("这是cglib代理执行的方法");
  9.                 Object o1 = methodProxy.invokeSuper(o, objects);
  10.                 return o1;
  11.             }
  12.         };
  13.         //返回代理对象
  14.         return Enhancer.create(aClass,callback);
  15.     }
  16. }

通过Enhancer类的create创建动态代理，然后通过MethodInterceptor方法实现动态代理。
单元测试对象

  1. @Test
  2. public void test03(){
  3.     CalculatorImpl calculator = new CalculatorImpl();
  4.     CalculatorImpl o = (CalculatorImpl) CglibProxy.getProxy(calculator);
  5.     System.out.println(o.getClass());
  6.     o.add(1,1);
  7. }

结果
image.png
从结果可以发现，获得的Class和Cglib代理的Class是同一个类的，而且并不需要实现接口，就能实现AOP功能。

通过哪种方式实现AOP

可以设置XML中的proxy-target-class的值，false为AspectJ,true为Cglib

  1. <aop:aspectj-autoproxy proxy-target-class="true"></aop:aspectj-autoproxy>

AspectJ和Cglib代理的差别

Spring的AspecJ代理底层是通过Proxy.newProxyInstance实现的，InvocationHandler类在调用方法过程中，会自动被JVM编码进内存中，因此可以这样来实现动态代理，特点就是目标类必须要有接口。
和Cglib代理是通过Enhancer.create，必须指定目标对象的Class和回调函数，回调函数是通过MethodInterceptor类实现的，具体是怎么操作的还没看过源码。但是他并不需要目标类实现接口。

切入点表达式

格式：execution(public int com.spring.aop.calculator.CalculatorImpl.(int,int))
execution(public(可省略) 返回类型 全类名.函数(参数))
和..的用法：
*：

  • 匹配一个或任意多个字符（路径）
  • 匹配任意一个参数

..：

  • 匹配任意多个参数 任意参数类型
  • 匹配任意多层路径

最模糊的书写：execution( .*(..)) —->不推荐

JoinPoint参数获得方法的参数

  1. public void startLog(JoinPoint joinPoint){
  2.     Object[] args = joinPoint.getArgs();
  3.     String name = joinPoint.getSignature().getName();
  4.     System.out.println(name+"为你处理"+ Arrays.asList(args));
  5. }

Spring通知方法

  1. //告诉spring result是返回值
  2. @AfterReturning(value = "execution(int com.spring.aop.calculator.CalculatorImpl.*(int,int))",returning = "result")
  3. public void returnLog(JoinPoint joinPoint,Object result){
  4.     System.out.println(joinPoint.getSignature().getName()+"处理完毕，结果是"+result);
  5. }
  6. //告诉spring exception是用来接受异常的
  7. @AfterThrowing(value = "execution(int com.spring.aop.calculator.CalculatorImpl.*(int,int))",throwing ="exception")
  8. public void exceptionLog(JoinPoint joinPoint,Exception exception){
  9.     System.out.println(joinPoint.getSignature().getName()+"方法处理异常，异常信息是"+exception.getMessage());
  10. }

spring中的通知方法是通过反射实现的，因此每个方法的参数必须告诉给spring，spring才可以通过参数去调用相应方法，不然不声明的话，spring就会报错

抽取可重用的切入点表达式

  1. @Pointcut("execution(int com.spring.aop.calculator.CalculatorImpl.*(int,int))")
  2. public void pointCut(){
  4. }
  5. @Before("pointCut()")

将重复的切入点表达式，提取出来，可以降低代码的修改次数，而且方便修改，只要将切入点中的增强方法修改，其他同名切入点的通知方法都会相应修改。

环绕通知

  1. @Around("pointCut()")
  2. public Object aroundLog(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
  3.     String name = proceedingJoinPoint.getSignature().getName();
  4.     Object[] args = proceedingJoinPoint.getArgs();
  5.     Object proceed=null;
  6.     try {
  7.         System.out.println(name+"环绕前置通知方法");
  8.         //proceed方法类似method.invoke方法，proceed是方法的返回值
  9.         proceed = proceedingJoinPoint.proceed();
  10.         System.out.println(name+"环绕后置通知方法");
  11.     } catch (Exception e) {
  12.         System.out.println(name+"环绕异常通知方法"+e.getMessage());
  13.     }finally {
  14.         System.out.println(name+"环绕返回通知方法");;
  15.     }
  16.     return proceed;
  17. }

环绕通知优先于其他通知执行，因此执行结果如下
image.png
环绕前置—->普通前置—->环绕后置——>环绕返回——>普通后置——>普通返回

多切面运行顺序

当有多个切面切入同一个切入点时，加入的通知方法执行顺序也会不同。
image.png
切面的执行顺序是跟着切面类的类名的字符串大小排序的，小的会优先执行外层切面的前置通知方法，外层切面会包裹内层切面，当内层切面执行完毕之后，外层切面才会相应的执行完毕。
当然也可以指定切面的执行顺序，使用Order注解

  1. @Order(1) //小的优先级高

如果是基于XML配置的话，那个前面写在XML前面的话，就优先执行那个切面