Spring学习(三)--高级装配

一.Spring profile
　　在开发软件的时候，有一个很大的挑战就是将应用程序从一个环境迁 移到另外一个环境。开发阶段中，某些环境相关做法可能并不适合迁 移到生产环境中，甚至即便迁移过去也无法正常工作。数据库配置、 加密算法以及与外部系统的集成是跨环境部署时会发生变化的几个典 型例子。例
--配置profile bean
　　Spring为环境相关的bean所提供的解决方案其实与构建时的方案没有 太大的差别。当然，在这个过程中需要根据环境决定该创建哪个bean 和不创建哪个bean。不过Spring并不是在构建的时候做出这样的决 策，而是等到运行时再来确定。这样的结果就是同一个部署单元（可 能会是WAR文件）能够适用于所有的环境，没有必要进行重新构建。
--我们还是一样建立一个多媒体播放器,以其其CD播放器的实现

package 高级配置.profile.player;

/**
 * @author : S K Y
 * @version :0.0.1
 */
public interface MediaPlayer {      //定义一个多媒体播放器
    /**
     * 播放多媒体文件
     */
    void play();
}

package 高级配置.profile.player;

/**
 * @author : S K Y
 * @version :0.0.1
 */
public interface CompactDisc {
    /**
     * 播放内容
     */
    void play();
}

package 高级配置.profile.player;

/**
 * @author : S K Y
 * @version :0.0.1
 */
public class CDorDVDPlayer implements MediaPlayer {
    private CompactDisc compactDisc;

    public CDorDVDPlayer(CompactDisc compactDisc) {
        this.compactDisc = compactDisc;
    }

    @Override
    public void play() {
        compactDisc.play();
    }
}

package 高级配置.profile.player;

/**
 * @author : S K Y
 * @version :0.0.1
 */
public class MyDVD implements CompactDisc {
    @Override
    public void play() {
        System.out.println("播放我最喜欢的DVD");
    }
}

package 高级配置.profile.player;

/**
 * @author : S K Y
 * @version :0.0.1
 */
public class MyCD implements CompactDisc{
    @Override
    public void play() {
        System.out.println("播放我最喜爱的CD..");
    }
}

--现在我们有这样的区别,在我们的测试环境中,此时团队的资金比较充足,需要实现的是播放DVD,但是对于线上环境来说,由于客户使用量较大,昂贵的DVD虽然稳定但是无法承担起这个费用,因此需要使用的是CD,我们可以使用@Profile注解来指定当前的这个bean所装配的环境:

package 高级配置.profile.player;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Profile;

/**
 * @author : S K Y
 * @version :0.0.1
 */
@Configuration
public class PlayerConfig {
    @Bean("compactDisc")
    @Profile("test")        //此时是在测试开发环境之中
    public CompactDisc testCompact() {
        return new MyDVD();
    }

    @Bean("compactDisc")
    @Profile("run")         //此时是在线上运行环境之中
    public CompactDisc runCompact() {
        return new MyCD();
    }

    @Bean
    public MediaPlayer player(CompactDisc compactDisc) {
        return new CDorDVDPlayer(compactDisc);
    }
}

 --在我们的测试类中,需要使用到Springtest

package 高级配置.profile.player;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.test.context.ActiveProfiles;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

/**
 * @author : S K Y
 * @version :0.0.1
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes =  {PlayerConfig.class})
@ActiveProfiles("test")
public class PlayerTest {
    @Autowired      //在Spring test中使用此方法可以自动装配我们的配置文件,为了确保成功我们应该使用接口ApplicationContext
    private ApplicationContext context;
    @Test
    public void testPlayer(){
        MediaPlayer player = context.getBean("player", MediaPlayer.class);
        player.play();
    }
}

--使用@ActiveProfiles注解指定当前的环境为"test"测试环境,当然你也可以指定为使用"run"环境来实现.此时Spring并不是在构建的时候作出这样的决策,而是等到运行时来确定,这样一来我们的同一个部署单元,在这里就是player bean,就能适用于所有的环境,没有必要进行重构建.当然,我们也可以在XML配置文件中实现这样的profiles部署:

<?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 http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="player" class="高级配置.profile.player.CDorDVDPlayer">
        <constructor-arg ref="compactDisc"/>
    </bean>
    <beans profile="test">
        <bean class="高级配置.profile.player.MyDVD" id="compactDisc"/>
    </beans>
    <beans profile="run">
        <bean class="高级配置.profile.player.MyCD" id="compactDisc"/>
    </beans>
</beans>

package 高级配置.profile.player;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.test.context.ActiveProfiles;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

/**
 * @author : S K Y
 * @version :0.0.1
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"classpath:高级配置/profile/player/player.xml"})
@ActiveProfiles("test")
public class XMLConfigTest {
    @Autowired
    private ApplicationContext context;
    @Test
    public void testXMLPlayer() {
        MediaPlayer player = context.getBean("player", MediaPlayer.class);
        player.play();
    }
}

--事实上激活Spring的profile,并不只有上述的@ActiveProfiles注解,想要激活profile,需要依赖两个独立的属性:
　　1.spring.profiles.active
　　2.spring.profiles.default
--如果设置了spring.profiles.active属性的话,那么它的值就会用来确定那个哪个profile是激活的,但是如果没有设置spring.profiles.active的话,那么Spring将会查找spring.profiles.default的值.如果这两个值都没有进行设置的话,那么就没有激活的profile,因此只会创建那些没有定义在profile中的bean,在Spring中,提供了多种方式来设置这两个属性(更多的是在Web应用中):
　　1.作为DispatcherServlet的初始化参数;
　　2.作为Wen应用的上下文参数;
　　3.作为环境变量;
　　4.作为JVM的系统属性;
　　5.在集成测试类上,使用@ActiveProfiles注解来设置.
--使用Spring4和@Conditional注解来自定义条件化的bean
　　假设你希望一个或多个bean只有在应用的类路径下包含特定的库时才 创建。或者我们希望某个bean只有当另外某个特定的bean也声明了之 后才会创建。我们还可能要求只有某个特定的环境变量设置之后，才 会创建某个bean。
--在@Condition注解中,定义了一个Class,他指明了条件,@Condition将会通过Condition接口进行条件比对:

public interface Condition {

boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata);

}

--我们可以自定义一个Condition接口的实现:

package 高级配置.profile.player.condition;

import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.core.env.Environment;
import org.springframework.core.type.AnnotatedTypeMetadata;

import java.util.Arrays;


/**
 * @author : S K Y
 * @version :0.0.1
 */
public class MagicExistsCondition implements Condition {
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        Environment environment = context.getEnvironment();
        String[] activeProfiles = environment.getActiveProfiles();//获取当前环境中的Profile属性
        for (String activeProfile : activeProfiles) {      
            if (activeProfile.equalsIgnoreCase("magic")) {
                return true;
            }
        }
        return false;       //检查magic属性
    }
}

package 高级配置.profile.player.condition;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Conditional;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Profile;
import 高级配置.profile.player.*;

/**
 * @author : S K Y
 * @version :0.0.1
 */
@Configuration
public class PlayerConfig {
    @Bean("player")
    @Conditional(MagicExistsCondition.class)
    public MediaPlayer player(CompactDisc compactDisc) {
        return new CDorDVDPlayer(compactDisc);
    }

    @Bean("compactDisc")
    @Profile("magic")
    public CompactDisc myDVD() {
        return new MyDVD();
    }

    @Bean("compactDisc")
    @Profile("test")
    public CompactDisc myCD() {
        return new MyCD();
    }
}

--此时只有在我们当前的Profiles中存在magic,才能正确的初始化我们的bean,否则bean将不会被装配.可以发现在MagicExistsCondition中,使用了ConditionContext来获取当前的environment,ConditionContext是一个接口:

package org.springframework.context.annotation;

import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.core.env.Environment;
import org.springframework.core.io.ResourceLoader;

/**
 * Context information for use by {@link Condition}s.
 *
 * @author Phillip Webb
 * @since 4.0
 */
public interface ConditionContext {

    BeanDefinitionRegistry getRegistry();

    ConfigurableListableBeanFactory getBeanFactory();

    Environment getEnvironment();

    ResourceLoader getResourceLoader();

    ClassLoader getClassLoader();

}

--通过ConditionContext我们可以做到如下几点:
　　1.借助getRegistry()返回的BeanDefinitionRegistry检查 bean定义；
　　2.借助getBeanFactory()返回的 ConfigurableListableBeanFactory检查bean是否存在， 甚至探查bean的属性；
　　3.借助getEnvironment()返回的Environment检查环境变量 是否存在以及它的值是什么；
　　4.读取并探查getResourceLoader()返回的ResourceLoader 所加载的资源；
　　5.借助getClassLoader()返回的ClassLoader加载并检查类 是否存在。
--而matches()方法的另一个属性AnnotatedTypeMetadata 则能够让我们检查带有@Bean注解的方法上还有什么其他的注解:

package org.springframework.core.type;

import java.util.Map;

import org.springframework.util.MultiValueMap;

/**
 * Defines access to the annotations of a specific type ({@link AnnotationMetadata class}
 * or {@link MethodMetadata method}), in a form that does not necessarily require the
 * class-loading.
 *
 * @author Juergen Hoeller
 * @author Mark Fisher
 * @author Mark Pollack
 * @author Chris Beams
 * @author Phillip Webb
 * @author Sam Brannen
 * @since 4.0
 * @see AnnotationMetadata
 * @see MethodMetadata
 */
public interface AnnotatedTypeMetadata {

    boolean isAnnotated(String annotationName);

    Map<String, Object> getAnnotationAttributes(String annotationName);

    Map<String, Object> getAnnotationAttributes(String annotationName, boolean classValuesAsString);

    MultiValueMap<String, Object> getAllAnnotationAttributes(String annotationName);

    MultiValueMap<String, Object> getAllAnnotationAttributes(String annotationName, boolean classValuesAsString);

}

--借助isAnnotated()方法,我们能够判断带有@Bean注解的方法是不是还有其他特定的注解,借助其他的方法,我们可以判断@Bean注解的方法上是否还有其他注解的属性.@Profile本身也使用了@Conditional注解，并且引用ProfileCondition作为Condition实 现。如下所示，ProfileCondition实现了Condition接口，并且在做出决策的过程中，考虑到了 ConditionContext和AnnotatedTypeMetadata中的多个因素:

package org.springframework.context.annotation;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

import org.springframework.core.env.AbstractEnvironment;
import org.springframework.core.env.ConfigurableEnvironment;
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.METHOD})
@Documented
@Conditional(ProfileCondition.class)
public @interface Profile {

    /**
     * The set of profiles for which the annotated component should be registered.
     */
    String[] value();

}

class ProfileCondition implements Condition {

    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        if (context.getEnvironment() != null) {
            MultiValueMap<String, Object> attrs = metadata.getAllAnnotationAttributes(Profile.class.getName());
            if (attrs != null) {
                for (Object value : attrs.get("value")) {
                    if (context.getEnvironment().acceptsProfiles(((String[]) value))) {
                        return true;
                    }
                }
                return false;
            }
        }
        return true;
    }

}

--ProfileCondition通过 AnnotatedTypeMetadata得到了用于@Profile注解的所有属 性。借助该信息，它会明确地检查value属性，该属性包含了bean的 profile名称。然后，它根据通过ConditionContext得到的 Environment来检查［借助acceptsProfiles()方法］该profile 是否处于激活状态。

二.处理自动装配的歧义
　　在之前已经介绍了如何使用自动装配让Spring完成bean的装配和使用(点击查看原文),但是也存在一个问题,在仅有一个bean匹配所需的结果的时候,自动装配才是有效的,如果不仅有一个bean能够匹配结果的haunted,这种歧义会阻碍Spring自动装配属性,构造器参数或方法参数:

package 高级配置.profile.player.自动装配中的歧义;

/**
 * @author : S K Y
 * @version :0.0.1
 */
public interface Dessert {
    /**
     * 吃甜点
     */
    void eat();
}

package 高级配置.profile.player.自动装配中的歧义;

import org.springframework.stereotype.Component;

/**
 * @author : S K Y
 * @version :0.0.1
 */
@Component
public class Cake implements Dessert {
    @Override
    public void eat() {
        System.out.println("吃蛋糕....");
    }
}

package 高级配置.profile.player.自动装配中的歧义;

import org.springframework.stereotype.Component;

/**
 * @author : S K Y
 * @version :0.0.1
 */
@Component
public class Cookies implements Dessert {
    @Override
    public void eat() {
        System.out.println("吃巧克力...");
    }
}

package 高级配置.profile.player.自动装配中的歧义;

import org.springframework.stereotype.Component;

/**
 * @author : S K Y
 * @version :0.0.1
 */
@Component
public class IceCream implements Dessert {
    @Override
    public void eat() {
        System.out.println("吃冰激凌...");
    }
}

--此时我们存在有3个Dessert的实现,那么此时如果我们进行自动化装配:

package 高级配置.profile.player.自动装配中的歧义;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

/**
 * @author : S K Y
 * @version :0.0.1
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = {AutoWiredConfig.class})
public class DessertTest {
    @Autowired
    private Dessert dessert;
    @Test
    public void eatDessert(){
        dessert.eat();
    }
}

--运行结果(会出现如下异常):

org.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean with name '高级配置.profile.player.自动装配中的歧义.DessertTest': Unsatisfied dependency expressed through field 'dessert'; nested exception is org.springframework.beans.factory.NoUniqueBeanDefinitionException: No qualifying bean of type '高级配置.profile.player.自动装配中的歧义.Dessert' available: expected single matching bean but found 3: cake,cookies,iceCream
    

--可以发现在自动装配的时候,发现了三个和Dessert相关的bean,因此由于歧义的存在,本次的自动装配将无法成功.从而抛出异常.在Spring中提供了解决歧义的多种方案:我们可以将一个bean设置为首选(primary),或者使用限定符(qualifier)来帮助Spring将可选的bean的范围缩小到只有一个bean.
--标示首选的bean

package 高级配置.profile.player.自动装配中的歧义;

import org.springframework.context.annotation.Primary;
import org.springframework.stereotype.Component;

/**
 * @author : S K Y
 * @version :0.0.1
 */
@Component
@Primary
public class Cake implements Dessert {
    @Override
    public void eat() {
        System.out.println("吃蛋糕....");
    }
}

--如果使用的是XML的配置方式,那么可以设置profile属性为true:

<?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 http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="cake" class="高级配置.profile.player.自动装配中的歧义.Cake"/>
    <bean id="cookies" class="高级配置.profile.player.自动装配中的歧义.Cookies" primary="true"/>
    <bean id="iceCream" class="高级配置.profile.player.自动装配中的歧义.IceCream"/>
</beans>

--如果说设置了不止一个的bean为首选的bean,那么就相当于没有设置这个首选属性了,Spring还是找不到我们所需要自动装配的bean,依然存在歧义.
--限定自动装配的bean
　　设置首选bean的局限性在于@Primary无法将可选方案的范围限定到 唯一一个无歧义性的选项中。它只能标示一个优先的可选方案。当首 选bean的数量超过一个时，我们并没有其他的方法进一步缩小可选范围。　　
--Spring的限定符能够在所有可选的bean上进行缩小范围的操作,最终能够达到只有一个bean满足所规定的限制条件,如果将所有的限定符都用上后依然存在歧义,那么可以继续使用更多的限定符来缩小选择的范围.@Qualifier注解使使用限定符的主要方式,他可以与@Autowired注解协同使用:

package 高级配置.profile.player.自动装配中的歧义;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

/**
 * @author : S K Y
 * @version :0.0.1
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = {AutoWiredConfig.class})
public class DessertTest {
    @Autowired
    @Qualifier("iceCream")      //优先级高于primary属性即@Primary注解
    private Dessert dessert;

    @Test
    public void eatDessert() {
        dessert.eat();
    }
}

--更准确地 讲，@Qualifier("iceCream")所引用的bean要具有String类型 的“iceCream”作为限定符。如果没有指定其他的限定符的话，所有的 bean都会给定一个默认的限定符，这个限定符与bean的ID相同。因 此，框架会将具有“iceCream”限定符的bean注入到setDessert()方 法中。这恰巧就是ID为iceCream的bean，它是IceCream类在组件 扫描的时候创建的。但是这样依然存在一个问题,如果哪一天进行代码的重构将IceCream修改了名称,那么此时所定义的@Qualifier("iceCream")就将失去了作用.因此实际上我们在进行自动装配的时候可以自定义限定符:

package 高级配置.profile.player.自动装配中的歧义;

import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Component;

/**
 * @author : S K Y
 * @version :0.0.1
 */
@Component
@Qualifier("myFavoriteDessert")     //使用自定义的限定符
public class Cookies implements Dessert {
    @Override
    public void eat() {
        System.out.println("吃巧克力...");
    }
}

--但是如果这个人比较贪心,同时为多个都设置了相同的自定义的限定符,那么歧义将会再次产生,此时我们可以对其中一个设置@Primary注解,那么可以消除歧义:

@Component
@Primary
@Qualifier("myFavoriteDessert")     //使用自定义的限定符
public class Cake implements Dessert {
    @Override
    public void eat() {
        System.out.println("吃蛋糕....");
    }
}

--除此之外,我们还能定义多个@Qualifiter注解来消除歧义,但是这里会有一个小问题:Java不允许在同一个条目上重复出现相同类型的多个注解,但是我们可以创建自定义的限定符注解来解决这个问题:

package 高级配置.profile.player.自动装配中的歧义;

import org.springframework.beans.factory.annotation.Qualifier;

import java.lang.annotation.*;

/**
 * @author : S K Y
 * @version :0.0.1
 */
@Target({ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER, ElementType.TYPE, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Qualifier
public @interface MyFavoriteDessert {
    String value();
}

package 高级配置.profile.player.自动装配中的歧义;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

/**
 * @author : S K Y
 * @version :0.0.1
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = {AutoWiredConfig.class})
public class DessertTest {
    @Autowired
    @Qualifier("myFavoriteDessert")      //优先级高于primary属性即@Primary注解
    @MyFavoriteDessert("cookies")
    private Dessert dessert;

    @Test
    public void eatDessert() {
        dessert.eat();
    }
}

三.bean的作用域
　　在默认情况下,Spring应用上下文中所有的bean都是以单例(singleton)的形式创建的.也就是说,不管给定的一个bean被注入到其他的bean中多次,每次所注入的都是熊一个实例.但是有时候所使用的一个类是易变的(mutable),他们会保持一些状态,因此重用是不安全的.这样一来,将class声明为单例的bean就不是声明好主意;额,因为对象会被污染,稍后重用的时候会出现意想不到的情况.Spring中定义了多种作用域,可以基于这些作用域创建bean:
　　1.单例（Singleton）：在整个应用中，只创建bean的一个实例。
　　2.原型（Prototype）：每次注入或者通过Spring应用上下文获取的 时候，都会创建一个新的bean实例。
　　3.会话（Session）：在Web应用中，为每个会话创建一个bean实 例。
　　4.请求（Rquest）：在Web应用中，为每个请求创建一个bean实 例。
--单例是默认的作用域,如果要选择其他的作用域,要使用@Scope注解,他可以与@Component或@Bean注解一起使用

package 高级配置.profile.player.自动装配中的歧义;

import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

/**
 * @author : S K Y
 * @version :0.0.1
 */
@Component
@Qualifier("myFavoriteDessert")     //使用自定义的限定符
@MyFavoriteDessert("cookies")
@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)     //声明为原型
public class Cookies implements Dessert {
    @Override
    public void eat() {
        System.out.println("吃巧克力...");
    }
}

    @Test
    public void testScope(){
        Dessert cakeA = context.getBean("cake", Dessert.class);
        Dessert cookiesA = context.getBean("cookies", Dessert.class);
        Dessert cakeB = context.getBean("cake", Dessert.class);
        Dessert cookiesB = context.getBean("cookies", Dessert.class);
        System.out.println(cakeA + " " + cakeB);
        System.out.println(cookiesA + " " + cookiesB );
    }

--运行结果

高级配置.profile.player.自动装配中的歧义.Cake@3d74bf60 高级配置.profile.player.自动装配中的歧义.Cake@3d74bf60
高级配置.profile.player.自动装配中的歧义.Cookies@4f209819 高级配置.profile.player.自动装配中的歧义.Cookies@15eb5ee5
九月 08, 2019 10:35:12 上午 org.springframework.context.support.GenericApplicationContext doClose
信息: Closing org.springframework.context.support.GenericApplicationContext@3cbbc1e0: startup date [Sun Sep 08 10:35:11 CST 2019]; root of context hierarchy

Process finished with exit code 0

--此外,也可以直接使用@Scope("prototype")来进行声明,但是使用常来会更加的安全不易出错,在XML配置文件中则可以使用scope属性来设置其类型:

<?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 http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="cake" class="高级配置.profile.player.自动装配中的歧义.Cake"/>
    <bean id="cookies" class="高级配置.profile.player.自动装配中的歧义.Cookies" primary="true"/>
    <bean id="iceCream" class="高级配置.profile.player.自动装配中的歧义.IceCream" scope="prototype"/>
</beans>

四.运行时值注入
　　当讨论依赖注入的时候，我们通常所讨论的是将一个bean引用注入到 另一个bean的属性或构造器参数中。它通常来讲指的是将一个对象与 另一个对象进行关联。但是还存在将属性或者构造参数进行赋值的情况,此时在我们之前的装配中使用的都是硬编码的装配(显示的指明了所需要装配的值),那么如何在运行时去决定所需要装配的值呢,为了实现这个功能,Spring提供了两种运行时求值的方式:
　　1.属性占位符(Property placeholder);
　　2.Spring表达式语言(SpEL);
--利用属性占位符注入外部的值,此时我们需要准备一个properties属性文件:

//@Component
@Qualifier("myFavoriteDessert")     //使用自定义的限定符
@MyFavoriteDessert("cake")
public class Cake implements Dessert {
    private String name;

    public Cake(String name) {
        this.name = name;
    }

    @Override
    public void eat() {
        System.out.println("吃" + name + "....");
    }
}

@Configuration
//@ComponentScan(basePackages = {"高级配置.profile.player.自动装配中的歧义"})
@PropertySource("classpath:高级配置/profile/player/自动装配中的歧义/dessert.properties")        //引入外部的属性文件
public class AutoWiredConfig {
    @Autowired
    private Environment environment;

    @Bean
    public Dessert cake() {
        return new Cake(environment.getProperty("name"));
    }
}

    @Test
    public void testProperties(){
        Dessert cake = context.getBean("cake", Dessert.class);
        cake.eat();
    }

--运行结果

吃超级无敌大蛋糕....

Process finished with exit code 0

--需要注意的是在属性文件中,中文字符不能直接输入,需要输入Unicode编码,可以使用JDK的自带工具native2ascii.exe来实现转化.
--深入学习Spring的Environment:我们可以发现getProperty()方法存在四种重载的实现:
　　1.String getProperty(String key);
　　2.String getProperty(String key, String defaultValue);
　　3.<T> T getProperty(String key, Class<T> targetType);
　　4.<T> T getProperty(String key, Class<T> targetType, T defaultValue);
--前两种方法都会返回一个String类型的参数,但是使用第二个方法,当属性不存在的时候,我们可以自定义默认值,3 4 两种方法则可以在获取属性的时候将内容转化为指定的类型,例如我们知道所需要获取的属性是数字(当前配置的是连接池所维持的最大连接数量),那么可以直接指定返回类型为Integer.class;当然,如果对于获取的属性,希望他必须存在定义,那么我们可以使用String getRequiredProperty(String key) throws IllegalStateException;方法来完成,此时如果当前的属性没有并定义的话,就会抛出异常信息;同时还可以使用boolean containsProperty(String key);方法来判断一个属性是否存在;此外还提供了一些方法来检查有哪些profile处于激活状态:
　　1.String[] getActiveProfiles():返回当前激活的profile名称的数组;
　　2.String[] getDefaultProfiles():返回默认profile名称的数组
　　3.boolean acceptsProfiles(String... profiles): 如果environment支持所给定的profile,那么则返回true;
--属性占位符:我们可以使用属性占位符来完成我们的定义,当然想要使用属性占位符的话,我们必须配置PropertyPlaceholderConfigurer bean或PropertySourcesPlaceholderConfigurer bean:

package 高级配置.profile.player.自动装配中的歧义;

import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

/**
 * @author : S K Y
 * @version :0.0.1
 */
@Component
@Qualifier("myFavoriteDessert")     //使用自定义的限定符
@MyFavoriteDessert("cake")
public class Cake implements Dessert {
    private String name;

    public Cake(@Value("${name}") String name) {
        this.name = name;
    }

    @Override
    public void eat() {
        System.out.println("吃" + name + "....");
    }
}

package 高级配置.profile.player.自动装配中的歧义;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.context.support.PropertySourcesPlaceholderConfigurer;

/**
 * @author : S K Y
 * @version :0.0.1
 */
@Configuration
@ComponentScan(basePackages = {"高级配置.profile.player.自动装配中的歧义"})
@PropertySource("classpath:高级配置/profile/player/自动装配中的歧义/dessert.properties")        //引入外部的属性文件
public class AutoWiredConfig {
    @Bean
    public static PropertySourcesPlaceholderConfigurer placeholderConfigurer() {
        return new PropertySourcesPlaceholderConfigurer();
    }

}

--如果想要在XML中使用属性占位符进行定义的话,Spring context命名空间中的<context:propertyPlaceholder>元素可是实现PropertySourcesPlaceholderConfigurer bean的功能

<?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 http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
    <!--引入外部属性文件-->
    <context:property-placeholder location="classpath:高级配置/profile/player/自动装配中的歧义/dessert.properties"`/>
    <bean id="cake" class="高级配置.profile.player.自动装配中的歧义.Cake" primary="true">
        <constructor-arg value="${name}"/>
    </bean>
    <bean id="cookies" class="高级配置.profile.player.自动装配中的歧义.Cookies"/>
    <bean id="iceCream" class="高级配置.profile.player.自动装配中的歧义.IceCream" scope="prototype"/>
</beans>

--使用Spring表达式语言进行装配
　　Spring 3引入了Spring表达式语言（Spring Expression Language， SpEL），它能够以一种强大和简洁的方式将值装配到bean属性和构造 器参数中，在这个过程中所使用的表达式会在运行时计算得到值。SpELl拥有如下特性:
　　1.使用bean的ID来引用bean;
　　2.调用方法和访问对象的属性;
　　3.对值进行算数,关系和逻辑运算;
　　4.正则表达式匹配;
　　5.集合操作;
--SpELl样例
　　SpEL表达式要放到"#{...}"中(需要主要的是,属性占位符是放在${..}中),例如我们定义SpEL表达式#{1},那么其表达式体就是数字1,一个数字常量,那么我们所计算得到的结果就是数字1.#{T(System).currentTimeMillis()}:T()表达式会将java.lang.System视为Java中对应的类型,因此可以调用其static修饰的currentTimeMillis()方法.SpEL还可以引用其他bean的属性#{student.name},那么就可以得到ID为student的bean的name属性.
--在上述的示例中,在注入属性和构造器参数时,我们可以使用@Value注解,这与属性占位符非常的相似,但是我们所使用的实质上并不是占位符表达式,而是属于SpEL表达式:

@Component
@Qualifier("myFavoriteDessert")     //使用自定义的限定符
@MyFavoriteDessert("cake")
public class Cake implements Dessert {
    private String name;

    public Cake(@Value("#{systemProperties['os.name']}") String name) {
        this.name = name;
    }

    @Override
    public void eat() {
        System.out.println("吃" + name + "....");
    }
}

--这样我们就可以顺利获取到当前的系统名称来作为们要吃的蛋糕名称....同样在XML配置文件中,我们也可以通过这样的方法来进行我们参数的设置,接下来我们看如何使用SpEL来设置字面值:
　　1.设置浮点数:　　#{3.14159};
　　2.设置数值98700:　　#{9.87E4};
　　3.设置String字符串:　　#{'hello'};
　　4.设置Boolean类型的值:　　#{false}
--引用bean,属性和方法
　　1.使用beanID:#{student};
　　2.引用bean属性:　　#{student.name};
　　3.引用方法:　　#{student.getTeacher()};
　　4.操作引用方法的返回值:　　#{studnet.getTeacher().getName()};
　　5.防止空异常(在不是null的情况下执行?后的操作):　　#{student.getTeacher()?.getName()};
　　6.访问类作用域的方法和常量:　　T{java.lang.Math}
　　7.将PI(π)装配到bean属性中:　　#{T{java.lang.Math}.PI};
　　8.调用static方法:　　#{T{java.lang.Math}.random()}
--SpEL运算符:

 

　　SpEl三目表达式的运算:　　#{studentA.age > studentB.age?true : false};
　　查询学生集合中名称第一个匹配MIke的人: #{teacher.students.^[name eq 'Mike']};
　　选择学生集合中名字最后一匹配MIke的人:#{teacher.students.$[name eq 'Mike']};
　　投影运算,将一个教师的学生的姓名存放入一个新的集合:　　#{teacher.students.![name]};
　　获取所有年龄为18岁的学生的名称集合:　　#{teacher.students.?[age eq 18].![name]};
　　获取字符串的指定字符(获取第四个字符):　　#{"hello"[3]}
--事实上,在Java8中允许出现重复的注解,只要将这个注解本身在定义的时候带有@Repeatable注解就可以了,但是Spring的@Qualifier注解在定义的时候并没有添加@Repeatable注解.