目录

1. Web MVC发展史历程
2.Spring概要
3.Spring-依赖注入概要(IOC)
4.属性注入的三种实现方式
5.Spring-IoC XML装配
6.Spring-XML设置Bean的值
7.Spring-IoC 注解(1)
8.Spring-IoC 注解(2)
9.Spring-AOP切面编程(1)
10.Spring-AOP切面编程(2)
未完待续...
未完待续...

一、简介

有些时候Spring装配Bean的时候，我们需要初始化一些属性的时候，我们就需要在bean中定义

1. 构造注入
2. setter注入
3. 自动装配

二、constructor-arg

1. 说明
   通过指定构造方法的参数来实例化Bean
2. 可选属性

   属性	说明
   type	根据参数的类型,避免构造方法冲突
   value	用于指定字符串类型、基本类型的属性值
   name	属性的名称
   ref	关联其它类型
   index	对应于构造函数的多个参数，index属性的值从0开始

3. 示例代码
   java代码

   public class Shop {
       private int shopId;
       private String title;
       private String name;
       public Shop() {
       }
       public Shop(int shopId, String title) {
           this.shopId = shopId;
           this.title = title;
       }
       public Shop(String title, String name) {
           this.title = title;
           this.name = name;
       }
       public Shop(int shopId, String title, String name) {
           this.shopId = shopId;
           this.title = title;
           this.name = name;
       }
       public int getShopId() {
           return shopId;
       }
       public void setShopId(int shopId) {
           this.shopId = shopId;
       }
       public String getTitle() {
           return title;
       }
       public void setTitle(String title) {
           this.title = title;
       }
       public String getName() {
           return name;
       }
       public void setName(String name) {
           this.name = name;
       }
       @Override
       public String toString() {
           return "Shop{" +
                   "shopId=" + shopId +
                   ", title='" + title + '\'' +
                   ", name='" + name + '\'' +
                   '}';
       }
   }
   

   xml代码

   <bean id="shop" class="com.wener.example.bean.Shop">
       <!--通过构造方法注入-->
       <constructor-arg type="int" value="1"/>
       <constructor-arg type="java.lang.String" value="iPhone X"/>
   </bean>
   <!-- 或者 -->
   <bean id="shop" class="com.wener.example.bean.Shop">
       <!--通过构造方法注入-->
      <constructor-arg index="0" value="1"/>
      <constructor-arg index='title' value="手机"/>
      <constructor-arg index='2' value="iPhone X"/>
   </bean>
   <!--或者-->
   <bean id="shop" class="com.wener.example.bean.Shop">
       <!--通过构造方法注入-->
      <constructor-arg name="id" value="1"/>
      <constructor-arg index='1' value="手机"/>
      <constructor-arg index='name' value="iPhone X"/>
   </bean>
   

   测试代码

   ApplicationContext context = new ClassPathXmlApplicationContext("ApplicationContext.xml");
   Shop shop = context.getBean("shop", Shop.class);
   System.out.println(shop.toString());
   

三、property

1. 说明
   在 Spring 配置文件中，我们也可以通过 Bean 的属性 property 进行参数注入。使用 property 属性不但可以将 String、int 等字面值注入到 Bean 中，还可以将集合、Map 等类型注入到 Bean 中，此外还可以注入其他的 Bean
   必须提供setter方法，因为需要通过名字自动装配
2. 可选属性

   属性	说明
   name	属性的名称
   value	主要是配置基本类型的属性值，
   ref	但是如果我们需要为Bean设置属性值是另一个Bean实例时，这个时候需要使用<ref.../>元素。使用<ref.../>元素可以指定如下两个属性。bean:引用不在同一份XML配置文件中的其他Bean实例的id属性值。local：引用同一份XML配置文件中的其他Bean实例的id属性值

3. 示例代码
   java代码

   public class Shop {
    ...
       private ShopDetail detail;
       public void setDetail(ShopDetail detail) {
           this.detail = detail;
       }
       public ShopDetail getDetail() {
           return detail;
       }
   }
   public class ShopDetail {
       private String desc;
       public String getDesc() {
           return desc;
       }
       public void setDesc(String desc) {
           this.desc = desc;
       }
   }
   

   xml配置

   <bean id="detail" class="com.wener.example.bean.ShopDetail">
       <property name="desc" value="demo"/>
   </bean>
   

   测试代码

   ApplicationContext context = new ClassPathXmlApplicationContext("ApplicationContext.xml");
   Shop shop = context.getBean("shop", Shop.class);
   System.out.println(shop.getDetail().getDesc());
   

四、autowire

1. 说明
   在bean标签上通过autowire属性；或者在beans标签上通过default-autowire属性实现自动装配
2. 可选值

   可选值	说明
   no	不使用自动装配。Bean的引用必须通过ref元素定义。
   byName	根据属性名自动装配。BeanFactory查找容器中的全部Bean，找出其中id属性与属性同名的Bean来完成注入。如果没有找到匹配的Bean实例，则Spring不会进行任何注入
   byType	如果BeanFactory中正好有一个同属性类型一样的bean，就自动装配这个属性。如果有多于一个这样的bean，就抛出一个致命异常，它指出你可能不能对那个bean使用byType的自动装配。如果没有匹配的bean，则什么都不会发生，属性不会被设置。如果这是你不想要的情况（什么都不发生），通过设置dependency-check="objects"属性值来指定在这种情况下应该抛出错误。
   constructor	这个同byType类似，不过是应用于构造函数的参数。如果在BeanFactory中不是恰好有一个bean与构造函数参数相同类型，则一个致命的错误会产生。
   default	采用父级标签（即beans的default-autowire属性）的配置。

3. 示例代码
   java代码

   public class Application { 
       private User user;
       public Application(User user) {
           this.user = user;
       }
       public User getUser() {
           return user;
       }
       public void setUser(User user) {
           this.user = user;
       }
   }
    public class User implements Serializable {
         private String id;
         private String name;
         private String sex;
         private Integer age;
         public void destroy() {
              System.out.println("销毁!");
         }
         public void init() {
             System.out.println("初始化!");
   } 
   

   根据属性名来加载

    <!-- xml配置 -->
   <bean id="application" class="com.wener.example.bean.Application" autowire="byName"/>  
   <bean id="user" class="com.wener.example.bean.User" />  
   

   根据类型来加载

   <!-- 注意:当一个Bean即使用自动装配依赖，又使用ref显示依赖时，则显示指定的依赖就会覆盖自动装配 -->
   <bean id="user" class="com.wener.example.bean.User" /> 
   <!-- xml代码 -->
   <bean id="app" class="com.wener.example.bean.Application" autowire="byType"/>
   

   根据构造方法来加载

   // java代码
   public Application(User user) {
           this.user = user;
   }
   // xml配置
   <bean id="app" class="com.wener.example.bean.Application" autowire="constructor">
   </bean>
   

五、注入参数值详解

1、说明

在 Spring 配置文件中，用户可以通过 Bean 的属性 property 进行参数注入。使用 property 属性不但可以将 String、int 等基本注入到 Bean 中，还可以将List、Set、Map ,Properties等类型注入到 Bean 中，此外还可以注入其他的 Bean

2、基本类型注入

1. 概要
   一般是指可用字符串表示的值，这些值可通过 <value>元素标签进行注入。在默认情况下，基本数据类型及其封装类、String 等类型都可以采取字面值注入的方式
2. 示例代码

   public class User {
       private String name;
       private String password;
       public String getName() {
           return name;
       }
       public void setName(String name) {
           this.name = name;
       }
       public String getPassword() {
           return password;
       }
       public void setPassword(String password) {
           this.password = password;
       }
   }
   

   <bean id="userId" class="com.wener.example.bean.User">
       <property name="name" value="小明"/>
       <property name="password" value="123456"/>
   </bean>
   

3、引入其他Bean

1. 概要
   Spring IoC 容器中定义的 Bean 可以互相引用。<ref>元素可以通过 bean、local、parent 三个属性引用其他 Bean 的属性，
   • bean 可以引用统一配置文件中或者父容器中的 Bean
   • local 只能引用同一配置文件中的 Bean
   • parent 只能引用父容器中的 Bean
2. 示例代码
   见property案例

4、内部Bean

1. 概要
   只会被当前的Bean所引用，不能被其它Bean引用
2. 示例代码

   <bean id="xx" class="com.wener.example.bean.Application">
       <property name="user">
           <bean class="com.wener.example.bean.User">
               <property name="name" value="内部Bean"/>
           </bean>
       </property>
   </bean>
   

5、级联设置属性

1. 概要
   如果你想直接设置关联Bean的属性的值,可以设置级联属性
2. 示例代码

   <bean id="xxx" class="com.wener.example.bean.Application">
       <property name="user.name"  value="级联属性设置"/>
   </bean>
   

6、list

1. 说明
   <list> 元素进行装配，然后通过多个 <value> 设置基本类型的值，也可以使用<ref>类引用复杂的对象类型
2. 示例代码

   <bean id="complex" class="com.wener.example.bean.Complex">
       <property name="list">
           <list>
               <value>list1</value>
               <value>list2</value>
               <value>list3</value>
               <value>list4</value>
               <!-- 引用复杂对象 -->      
               <!-- <ref bean="user"/> -->          
           </list>
       </property>
   </bean>
   

7、map

1. 说明
   <map> 元素进行装配，然后通过多个 <entry> 元素设值，只是 entry 包含一个键值对的设置，也可以使用key-ref 属性去引用之前定义好的 Bean 作为键，而用 value-ref 属性引用之前定义好的 Bean 作为值
2. 示例代码

   <property name="map">
       <map>
           <entry key="k1" value="v1"/>
           <entry key="k2" value="v2"/>
           <entry key="k3" value="v3"/>
           <entry key="k4" value-ref="user"/>
       </map>
   </property>
   

8、set

1. 说明
   <set> 元素进行装配，可以通过value设置基本类型的值,也可以通过 <ref>去引用已经定义的Bean
2. 示例代码

   <property name="set">
       <set>
           <value>1</value>
           <value>2</value>
           <value>3</value>
       </set>
   </property>
   <property name="set">
       <set>
           <ref bean='user'/>
       </set>
   </property>
   

9、array

1. 说明
   <array> 可以通过多个 <value> 元素设值
2. 示例代码

   <property name="array">
       <array>
           <value>1</value>
           <value>2</value>
           <value>3</value>
          <!-- <ref name="user"/> -->
       </array>
   </property>
   

10、properties

1. 说明
   <properties> 元素进行装配，通过多个 <property> 元素设值，只是 properties 元素有一个必填属性 key ，然后可以设置值
2. 示例代码

   <property name="properties">
       <props>
           <prop key="k1">v1</prop>
       </props>
   </property>
   

11、其它

1. 集合合
   子Bean可以继承父Bean的同名属性集合元素，并且使用merge属性选择是否合并，默认不合并。
2. 示例代码

   <bean id="parent" abstract="true" class="***">
     <property name="list">
       <set>
         <value>1</value>
         <value>2</value>
         <value>3</value>
       </set>
     </property>
   </bean>
   <bean id="child" parent="parent">
     <property name="list">
       <set merge="true">
         <value>4</value>
         <value>5</value>
       </set>
     </property>
   

12、总结

1. value:指定集合元素是基本数据类型或者字符类型值。
2. ref:指定集合元素师容器中另一个Bean实例。
3. bean:指定集合元素是一个嵌套Bean。

六、命名空间装配

1、概要

除了上述的配置方式外，Spring3.0以上的版本还为上述的方式提供了一些简写方式

2、c

1. 说明
   命名空间-c属性名以 “c:” 开头，也就是命名空间的前缀，通过构造器注入的方式来配置 bean,接下来就是要装配的构造器参数名
2. 示例代码

   <beans 
     ...    
     xmlns:c="http://www.springframework.org/schema/c">
   </beans>
   

   <!-- 未引入之前-->
   <bean id="shop" class="com.wener.example.bean.Shop">
       <!--通过构造方法注入-->
       <constructor-arg type="int" value="1"/>
       <constructor-arg type="java.lang.String" value="iPhone X"/>
   </bean>
   <!--简写方式 -->
    <bean id="shop" class="com.wener.example.bean.Shop"  c:shopId="1" c:name="测试"/>
   

3、p

1. 说明
   命名空间-p通过setter的注入方式来配置 bean
2. 示例代码

   <!-- 未引入之前-->
   <bean id="userId" class="com.wener.example.bean.User" scope="prototype">
       <property name="name" value="小明"/>
       <property name="password" value="123456"/>
   </bean>
   <!--简写方式 -->
   <bean id="user4" 
         class="com.wener.example.bean.User" 
         p:name="admin" 
         p:password="123"/>
   <bean id="app"
         class="com.wener.example.bean.Application"
         p:user-ref="user" />
   

4、util

1. 说明
   工具类的命名空间，可以简化集合类元素的配置
2. util命名空间表

   元素	描述
   <util:list>	创建一个 java.util.List 类型的 bean，其中包含值或引用
   <util:map>	创建一个 java.util.map 类型的 bean，其中包含值或引用
   <util:properties>	创建一个 java.util.Properties 类型的 bean
   <util:property-path>	引用一个 bean 的属性（或内嵌属性），并将其暴露为 bean
   <util:set>	创建一个 java.util.Set 类型的 bean，其中包含值或引用
   <util:constant>	引用某个类型的 public static 域，并将其暴露为 bean

5、util:list

1. 说明
   可以通过util:list来定义一个java.util.List类型的bean，其子元素就是对应的List的元素，其子元素可以是一切可以用来定义对象的元素，比如value、bean等，
   默认元素的值是String类型，可以通过value-type属性指定元素值的类型，比如数字类型则指定value-type="java.lang.Integer"
   默认生成的是java.util.ArrayList类型的List，如果需要使用其它类型的List，则可以通过list-class来指定。比如下面就指定了生成的List是java.util.LinkedList
2. 示例代码

   <bean id="complex" class="com.wener.example.bean.Complex" p:list="list"/>
   <util:list id="list" value-type="java.lang.String" list-class="java.util.LinkedList">
       <value>1</value>
       <value>2</value>
       <value>3</value>
   </util:list>
   

6、util:map

1. 说明
   通过util:map来定义一个Map类型的， Map中的每一个Entry则由其子元素entry来定义。每个Entry的key和value可以通过entry元素的key和value属性来定义
   默认key和value的值是String类型，如果想修改类型可以通value-type属性指定value的类型,如果是复制的类型可以通过value-ref来引入
   默认生成的是`java.util.HashMap,如果想使用其他类型的Map，可以通过map-class来指定
2. 示例代码

   <util:map id="map"
             value-type="java.lang.Object"
             key-type="java.lang.Object">
       <entry value-ref="list" key-ref="set"/>
   </util:map>
   

7、util:set

1. 说明
   通过util:set来定义一个java.util.Set类型的bean。它的用法和util:list是类似的。
   通过value子元素指定的值默认也是java.lang.String类型，可以通过value-type属性来指定元素类型
   默认生成的Set是java.util.LinkedHashSet类型，可以通过set-class属性来指定生成的Set的类型
2. 示例代码

   <util:set id="set" value-type="java.lang.Integer" set-class="java.util.HashSet">
       <value>1</value>
       <value>2</value>
       <value>3</value>
   </util:set>
   

8、util:properties

1. 说明
   可以通过util:properties快速的定义一个Properties对象，可以通过其子元素<prop key=""></prop>来定义一个Properties的元素，key对应属性名，而<prop>元素中间的文本值则为对应的属性值
   util:properties的内容也可以来自一个外部文件，此时可以通过location属性引用对应的外部文件,通过location属性指定的本地文件也可以是多个，多个文件之间可以通过英文的逗号分隔
2. 示例代码

   <util:properties id="properties">
       <prop key="a">a</prop>
       <prop key="b">b</prop>
   </util:properties>
   

   <!--在工程的Resources目录下新建一个 util.properties的文件 -->
   <util:properties id="properties" location="util.properties,xxx.properties"/>
   

9、util:constant

1. 说明
   util:constant可以把一个常量定义为bean容器中的一个bean，可以通过id属性指定对应的bean的id。static-field用来指定引用的static变量，需要是public类型的
2. 示例代码

   public static final Integer ERROR = -1;
   <util:constant id="error" static-field="com.wener.example.bean.Application.ERROR" />
   

10、util:property-path

1. 说明
   util:property-path可以用来把某个bean的某个属性的值定义为一个bean，
2. 示例代码

   <util:property-path id="username" path="user_path.name"/>
   <bean id="user_path" class="com.wener.example.bean.User" scope="prototype">
       <property name="name" value="小明"/>
       <property name="password" value="123456"/>
   </bean>