第一次写这个玩意儿，试一试新鲜感。废话不多说，直奔主题。今天粗浅的归纳一下java中常用的config配置文件的简单使用，仅仅为读取 key-value。
 
下面直接上代码：
 
 
<web>
    <frame webName="this is webname" socketPort="12345">
        <player nike="小白" id="12"/>
        <player nike="小红" id="2"/>
        <player nike="李明" id="3"/>
    </frame>
    
    <system>
        
    </system>
    
    <data>
        <dataA dbUrl="dbUrlA" userName="lqqA" pwd="rootA"/>
        <dataB dbUrl="dbUrlB" userName="lqqB" pwd="rootB"/>
    </data>
</web>



public class WebConfig {
    private static FrameConfig FRAME_CONFIG;
    private static SystemConfig SYSTEM_CONFIG;
    private static DataConfig DATA_CONFIG;
    static {
	//创建一个XML 读取器
        SAXReader reader = new SAXReader();
	//这个我也不太懂，我理解为接收XML 数据的容器吧
        Document doc;
        try {
		//这个read 里面是我们config.xml文在所在的位置
            doc = reader.read("config/config.xml");
		//获得根元素
            Element web = doc.getRootElement();
		//把每一个元素项传给相对应的类进行处理
            FRAME_CONFIG = new FrameConfig(web.element("frame"));
            SYSTEM_CONFIG = new SystemConfig(web.element("system"));
            DATA_CONFIG = new DataConfig(web.element("data"));
        } catch (DocumentException ex) {
            Logger.getLogger(WebConfig.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    private WebConfig() {
    }
    

    public static FrameConfig getFRAME_CONFIG() {
        return FRAME_CONFIG;
    }

    public static SystemConfig getSYSTEM_CONFIG() {
        return SYSTEM_CONFIG;
    }

    public static DataConfig getDATA_CONFIG() {
        return DATA_CONFIG;
    }
}


 

  


 

 

  
  
public class FrameConfig {

    private final String webName;
    private final int socketPort;
    private List<Element> elements;
    private List<Player> players;
    public FrameConfig(Element frame) {
	//通过attributeValue 函数用key webName 获取XML 中的 这个key 对应的 值value
        this.webName = frame.attributeValue("webName");
        this.socketPort = Integer.parseInt(frame.attributeValue("socketPort"));
        //通过elements函数获取相同元素 组成一个链表
        elements = frame.elements("player");
        players = new ArrayList<>();
        for(Element e : elements){
		//使用for迭代 获取出来并添加到链表中去
            players.add(new Player(e.attributeValue("nike"), Integer.parseInt(e.attributeValue("id"))));
        }
    }

    public String getWebName() {
        return webName;
    }

    public int getSocketPort() {
        return socketPort;
    }

    public List<Player> getPlayers() {
        return players;
    }
}
  
public class DataConfig {


    private Element dataA;
    private Element dataB;
    public DataConfig(Element data) {
        dataA = data.element("dataA");
        dataB = data.element("dataB");
        
        System.out.println("dbUrl="+dataA.attributeValue("dbUrl")+"   userName="+dataA.attributeValue("userName")+"   pwd="+dataA.attributeValue("pwd"));
        System.out.println("dbUrl="+dataB.attributeValue("dbUrl")+"   userName="+dataB.attributeValue("userName")+"   pwd="+dataB.attributeValue("pwd"));
    }
    
}
  
//主函数：//程序入口

public static void main(String[] args) {
        // TODO code application logic here
        WebConfig.getFRAME_CONFIG();
        WebConfig.getSYSTEM_CONFIG();
        WebConfig.getDATA_CONFIG();
        System.out.println(""+WebConfig.getFRAME_CONFIG().getWebName()+"      "+WebConfig.getFRAME_CONFIG().getSocketPort());
        for(Player p : WebConfig.getFRAME_CONFIG().getPlayers()){
            System.out.println(""+p.getName()+"      "+p.getId());
        }
        Collections.sort(WebConfig.getFRAME_CONFIG().getPlayers());
        for(Player p : WebConfig.getFRAME_CONFIG().getPlayers()){
            System.out.println(""+p.getName()+"      "+p.getId());
        }
    }



     

      运行效果如下：
dbUrl=dbUrlA   userName=lqqA   pwd=rootA
dbUrl=dbUrlB   userName=lqqB   pwd=rootB
this is webname      12345
小白      12
小红      2
李明      3
     
     


     
     

      大概就是这些，记住一点就是 element获取元素，通过element的方法attributeValue传入key来获取value
     
     


     
     

      最后一点别忘了引入config包，这个网上下载的。就到这里，thx

     

 

MyBatis配置文件mybatis-config.xml内容详解
 


 
文章目录
 
MyBatis配置文件mybatis-config.xml内容详解
一、略解mybatis-config.xml
二、详解mybatis-config.xml
1. configuration
2. properties
3. settings
4. typeAliases
5. typeHandlers
6. objectFactory
7. objectWrapperFactory
8. reflectorFactory
9. plugins
10. environments
a. dataSource
b. transcationManager
c. 其它
    
11. databaseIdProvider
12. mappers
  
 

 
 
一、略解mybatis-config.xml
 
核心配置文件mybatis-config.xml头部要包含这个约束：
 
<?xml version="1.0" encoding="utf-8"?> 
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
 
点开上面这个链接可以知道mybatis-config.xml文件的大致框架如下：
 
<?xml version="1.0" encoding="utf-8"?> 
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">

<configuration>

    <properties>
        <property></property>
        ...
    </properties>

    <settings>
        <setting></setting>
        ...
    </settings>

    <typeAliases>
        <package></package>
        ...
        <typeAlias></typeAlias>
        ...
    </typeAliases>

    <typeHandlers>
        <package></package>
        ...
        <typeHandler></typeHandler>
        ...
    </typeHandlers>

    <objectFactory>
        <property></property>
        ...
    </objectFactory>

    <objectWrapperFactory>
        <property></property>
        ...
    </objectWrapperFactory>

    <reflectorFactory></reflectorFactory>

    <plugins>
        <plugin>
            <property></property>
            ...
        </plugin>
        ...
    </plugins>

    <environments>
        <environment>
            <transactionManager>
                <property></property>
                ...
            </transactionManager>

            <dataSource>
                <property></property>
                ...
            </dataSource>
        </environment>
        ...
    </environments>

    <databaseIdProvider>
        <property></property>
        ...
    </databaseIdProvider>

    <mappers>
        <package></package>
        ...
        <mapper></mapper>
        ...
    </mappers>

</configuration>
 
二、详解mybatis-config.xml
 
1. configuration
 
最外层标签，表示这里面的都是配置内容。
 
2. properties
 
properties用来定义变量，从而将配置值写死到mybatis-config.xml中，也可以具体到一个属性文件中，并且使用属性文件的key名作为占位符。
 注意这个标签必须是configuration中最前面的子标签。
 
1. 将配置值写到property标签中，在之后的内容中可以用${}来获取该值：
 
<configuration>
    <properties>
        <property name="jdbc.username" value="test" /> 
        <property name="jdbc.password" value="test" /> 
    </properties>

    <environments default="development"> 
        <environment id="development"> 
            <transactionManager type="JDBC" /> 
            <dataSource type="POOLED">
                <property name="username" value="${jdbc.username}" /> 
                <property name="password" value="${jdbc.password}" /> 
        </dataSource> 
        </environment> 
    </environments>  
</configuration>
 
2. 将配置值写到另外一个属性文件中，在之后的内容中可以用${}来获取该值:
 
新建db.properties文件，写入如下内容：
 
jdbc.driverClassName=oracle.jdbc.driver.OracleDriver 
jdbc.url=jdbc:oracle:thin:@127.0.0.1:1521:XE
jdbc.username=test 
jdbc.password=test
 
mybatis-config.xml写入如下内容：
 
<configuration>
    <properties resource="db.properties"></properties>

    <environments default="development"> 
        <environment id="development"> 
            <transactionManager type="JDBC" /> 
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driverClassName}" /> 
                <property name="url" value="${jdbc.url}" /> 
                <property name="username" value="${jdbc.username}" /> 
                <property name="password" value="${jdbc.password}" /> 
        </dataSource> 
        </environment> 
    </environments>  
</configuration>
 
3. 注意：如果两种方式都写了，那么文件中的配置优先级更高，也就是文件的配置会覆盖标签中的值。
 
3. settings
 
settings标签用来设置全局参数，大多数情况下，这些参数使用它们的默认值即可。为满足应用特定的需求，MyBatis默认的全局参数设置可以被覆盖掉，如下所示：
 
<settings>
    <!-- 这个配置使全局的映射器启用或禁用 【缓存】 -->
    <setting name="cacheEnabled" value="true" />

    <!-- 全局启用或禁用【延迟加载】。当禁用时，所有关联对象都会即时加载 -->
    <setting name="lazyLoadingEnabled" value="true" />

    <!-- 允许或不允许多种结果集从一个单独的语句中返回（需要适合的驱动才有效） -->
    <setting name="multipleResultSetsEnabled" value="true" /> 

    <!-- 使用列标签代替列名。不同的驱动在这方便表现不同。参考驱动文档或充分测试两种方法来决定所使用的驱动 -->
    <setting name="useColumnLabel" value="true" /> 

    <!-- 允许JDBC支持【id自动生成】。需要适合的驱动。 -->
    <setting name="useGeneratedKeys" value="false" /> 

    <!-- 指定MyBatis如何【自动映射】列到 列/属性值。PARTIAL只会自动映射简单、没有嵌套的结果。FULL会自动映射任意复杂的结果（嵌套的或其他情况） -->
    <setting name="autoMappingBehavior" value="PARTIAL" />

    <!-- 配置默认的执行器。SIMPLE执行器没有什么特别之处。REUSE执行器重用预处理语句。BATCH【执行器】重用语句和批量更新 -->
    <setting name="defaultExecutorType" value="SIMPLE" /> 

    <!-- 设置【超时时间】，它决定驱动等待一个数据库响应的时间 -->
    <setting name="defaultStatementTimeout" value="25000" /> 

    <!-- 在嵌套语句中使用【分页功能】（RowBounds），默认false -->
    <setting name="safeRowBoundsEnabled" value="false" /> 

    <!-- 是否开启自动驼峰命名规则（camel case）映射，即从经典数据库列名 A_COLUMN 到经典 Java 属性名 aColumn 的类似映射。默认false -->
    <setting name="mapUnderscoreToCamelCase" value="false" /> 

    <!-- MyBatis 利用本地缓存机制（Local Cache）防止循环引用（circular references）和加速重复嵌套查询。 默认值为 SESSION，这种情况下会缓存一个会话中执行的所有查询。 若设置值为 STATEMENT，本地会话仅用在语句执行上，对相同 SqlSession 的不同调用将不会共享数据。 -->
    <setting name="localCacheScope" value="SESSION" /> 

    <!-- 当没有为参数提供特定的 JDBC 类型时，为空值指定 JDBC 类型。 某些驱动需要指定列的 JDBC 类型，多数情况直接用一般类型即可，比如 NULL、VARCHAR 或 OTHER。 -->
    <setting name="jdbcTypeForNull" value="OTHER" />

    <!-- 指定对象的哪个方法【触发一次延迟加载】。 -->
    <setting name="lazyLoadTriggerMethods" value="equals,clone,hashCode ,toString" /> 

    <!-- CGLIB | JAVASSIST 默认JAVASSIST(MyBatis 3.3 or above)  -->
    <!-- 指定 Mybatis 创建具有延迟加载能力的对象所用到的【代理工具】。 -->
    <setting name="proxyFactory" value="JAVASSIST" /> 
    <!-- 当启用时，对任意延迟属性的调用会使带有延迟加载属性的对象完整加载；反之，每种属性将会按需加载。 -->
    <setting name="aggressiveLazyLoading" value="true" /> 

    <!-- 指定 MyBatis 所用日志的具体实现，未指定时将自动查找。 -->
    <setting name="logImpl" value="LOG4J " /> 

    <!-- 指定 MyBatis 增加到日志名称的前缀。值可以是任意字符串 -->
    <setting name="logPrefix" value="LOG4J " /> 

    <!-- 指定当结果集中值为 null 的时候是否调用映射对象的 setter（map 对象时为 put）方法，这对于有 Map.keySet() 依赖或 null 值初始化的时候是有用的。注意基本类型（int、boolean等）是不能设置成 null 的。 默认false-->
    <setting name="callSettersOnNulls" value="false " /> 
</settings> 
 
4. typeAliases
 
这个标签里面的typeAlias标签可以定义别名，会在映射文件中使用。如果没有定义别名，那必须使用全限定名。配置别名有两种方法：
 
1. 直接写在typeAlias标签中：
 
<typeAliases> 
    <typeAlias alias="Student" type="com.au.bean.Student" />
</typeAliases> 
 
2. package标签和@Alias注解配合使用：
 
<typeAliases> 
    <package name="com.au.bean" />
</typeAliases> 
 
package com.au.bean;

@Alias("Student")   // 配合package标签起别名使用，别名默认为类名
public class Student {
    private Integer id;
    private String name;
    ...
}
 
在没有配别名之前的mapper.xml文件是下面这样写的，即resultType的值要写类的全限定名。
 
<select id="findStudentById" parameterType="int" resultType="com.au.bean.Student"> 
    SELECT STUD_ID AS ID, NAME, EMAIL, DOB  
    FROM STUDENTS WHERE STUD_ID=#{Id} 
</select> 
 
配置之后就可以写成别名了：
 
<select id="findStudentById" parameterType="int" resultType="Student"> 
    SELECT STUD_ID AS ID, NAME, EMAIL, DOB  
    FROM STUDENTS WHERE STUD_ID=#{Id} 
</select> 
 
注意：别名【不区分大小写】。
 
5. typeHandlers
 
typeHandlers标签用来设置类型处理器，在执行sql语句的时候，prepareStatement会设置sql语句中的 ? 值（如select * from student where id = ?），此时类型处理器帮prepareStatement找到对应的set方法，如setInt、setString或setDate等，但是如果是自定义的类型，类型处理器就找不到对应的set方法，所以要自定义类型处理器。
 
有关自定义类型处理器不详细介绍，移步我的其它文章：MyBatis自定义类型处理器（typeHandler）
 
假如我现在已经写好了一个类型处理器为PhoneTypeHandler，进行如下操作进行关联使用：
 
<configuration> 
    <typeHandlers> 
        <typeHandler handler="com.au.typehandlers.PhoneTypeHandler" /> 
    </typeHandlers> 
</configuration> 
 
6. objectFactory
 
用于指定结果集对象的实例是如何创建的。MyBatis 每次创建结果对象的新实例时，它都会使用一个对象工厂（ObjectFactory）实例来完成。默认的对象工厂需要做的仅仅是实例化目标类，要么通过默认构造方法，要么在参数映射存在的时候通过参数构造方法来实例化。默认情况下，我们不需要配置，mybatis会调用默认实现的objectFactory。 除非我们要自定义ObjectFactory的实现， 那么我们才需要去手动配置。自定义ObjectFactory只需要去继承DefaultObjectFactory（是ObjectFactory接口的实现类），并重写其方法即可。
 
7. objectWrapperFactory
 
8. reflectorFactory
 
9. plugins
 
MyBatis的插件，插件可以修改MyBatis内部的运行规则，如分页插件等。
 
10. environments
 
environments是配置mybatis当前工作的数据库环境的地方。整体结构为:
 
<environments default="db1">
    <environment id="db1">
        数据库连接四要素
        事务管理方式
    </environment>
    
    <environment id="db2">
        数据库连接四要素
        事务管理方式
    </environment>
    
    ...
</environments>
 
a. dataSource
 
dataSource表示的是【数据源】：至少会包括该连接数据库的各种信息【注意： 在Java里面，数据源是一个对象】
 
<dataSource type="POOLED"> 
    <property name="driver" value="${jdbc.driverClassName}" /> 
    <property name="url" value="${jdbc.url}" /> 
    <property name="username" value="${jdbc.username}" /> 
    <property name="password" value="${jdbc.password}" /> 
</dataSource> 
 
dataSource的类型type属性可以配置成其内置类型之一，如UNPOOLED，POOLED，JNDI(web使用)。如果将类型设置成UNPOOLED，MyBatis会为每一个数据库操作创建一个新的连接，使用完了并关闭它，该方式适用于只有小规模数量并发用户的简单应用程序上。
 
如果将属性设置成POOLED，MyBatis会【创建】一个【数据库连接池】，连接池中的一个连接将会被用作数据库操作。一旦数据库操作完成，MyBatis会将此连接返回给连接池。在开发或测试环境中，经常使用此种方式。
 
如果将类型设置成JNDI(Java Naming and Directory Interface , 【Java命名和目录接口】, 是SUN公司提供的一种标准的Java命名系统接口)，MyBatis从在应用服务器向配置好的JNDI数据源dataSource获取数据库连接。在生产环境中，优先考虑这种方式。
 
b. transcationManager
 
transcationManager是事务管理器，取值JDBC或MANAGED，JDBC表示手动控制，MANAGED被服务器管理。
 
JDBC事务管理器的使用，是在【jdbc程序】负责管理数据库连接的生命周期（提交、回退等等）的时候。如果将TransactionManager 属性设置成JDBC，MyBatis内部将使用JdbcTransactionFactory类创建TransactionManager。例如，部署到ApacheTomcat的应用程序，需要应用程序自己管理事务。MANAGED 事务管理器的使用，是在【应用服务器】负责管理数据库连接生命周期的时候。如果将TransactionManager属性设置成MANAGED时，MyBatis内部使用ManagedTransactionFactory 类创建事务管理器TransactionManager。例如，当一个Java EE的【应用程序部署】在类似JBoss，WebLogic，GlassFish应用【服务器】上时，它们会使用EJB进行应用服务器的事务管理能力。在这些管理环境中，你可以使用MANAGED事务管理器。注：【Managed 是托管】的意思，即我们编写的应用程序本身不去管理事务，而是把事务管理交给应用所在的服务器进行管理。
 
c. 其它
 
MyBatis支持配置多个environment环境，可以将应用部署到不同的环境上，如DEV【开发环境】，TEST【测试环境】，QA【质量评估环境】，UAT【用户验收环境】,PRODUCTION【生产环境】，可以通过将默认environments的【default属性】设置成想要的environment的id值。有时候，我们可能需要在相同的应用下使用多个数据库,比如我们可能有【shoppingcart】数据库来存储所有的【订单明细】；使用【reports】数据库存储【订单明细】的合计，用作报告。(也就是如果系统在运行期间如果有切换数据库环境的需求,mybatis中也可以很轻松的实现)。如果你的【应用】需要连接【多个数据库】，你需要将每个数据库配置成独立的环境，并且为每一个数据库创建一个SqlSessionFactory。例如:
 
<environments default="shoppingcart"> 
    <!-- 第一个数据库 用来存放明细 -->
    <environment id="shoppingcart"> 
    <transactionManager type="MANAGED" /> 
    <dataSource type="JNDI"> 
        <property name="data_source" value="java:comp/jdbc/ShoppingcartDS" /> 
    </dataSource> 
    </environment> 

    <!-- 第二个数据库 用来查询报表 -->
    <environment id="reports"> 
    <transaction Managertype="MANAGED" /> 
    <dataSource type="JNDI"> 
        <property name="data_source" value="java:comp/jdbc/ReportsDS" /> 
    </dataSource> 
    </environment> 
</environments> 
 
我们可以为以上每个环境创建一个SqlSessionFactory，java代码:
 
    inputStream = Resources.getResourceAsStream("mybatis-config.xml"); 
    //默认的环境
    defaultSqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

    //统计明细的环境 代码内部【通过参数】可以【切换数据库】
    cartSqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream, "shoppingcart"); 

    //统计报表的环境
    reportSqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream, "reports");
 
注意：对于environments，我们可以在其中配置多个environment子元素，同时还需要在environment中配置dataSource和transactionManager元素。
 
11. databaseIdProvider
 
12. mappers
 
mappers标签用来配置SQLMapper文件路径。mappers里面每一个mapper子标签都可以从不同类型的资源中加载映射mapper：
 
 
 
resource属性：用来指定在classpath中的mapper文件。
url属性：用来通过完全文件系统路径或者web中url地址来指向mapper文件。
class属性：用来指向一个mapper接口。
package属性：用来指向可以找到Mapper接口的包名。`
 
 
假如我在项目的src/com/au/mappers目录下有StudentMapper.xml文件，那么应该这样配置：
 
<configuration> 
    <mappers> 
        <mapper resource="com/au/mappers/StudentMapper.xml" /> 
    </mappers> 
</configuration>
 
假如我在电脑C盘有StudentMapper.xml文件，那么应该这样配置：
 
<configuration> 
    <mappers> 
        <mapper url="file:///C:/StudentMapper.xml" /> 
    </mappers> 
</configuration>
 
假如我没有写StudentMapper.xml文件，而是直接写sql注解（如@insert）在StudentMapper.java接口上，那么应该这样配置：
 
<configuration> 
    <mappers> 
        <mapper class="com.au.mappers.StudentMapper" /> 
    </mappers> 
</configuration>
 
还可以这样配置，前提是接口和xml文件的名字要一样：
 
<configuration> 
    <mappers> 
        <package name="com.au.mappers" /> 
    </mappers> 
</configuration>

一、配置文件config.properties是放在src根目录下的：例如我的是 
 /PropertiesTest/src/com/xuliugen/project/type.properties
 
配置文件中的内容如下：
 
left=com.sunny.project.LeftHair
right=com.sunny.project.RightHair
in=com.sunny.project.InHair
 
读取配置文件中的代码如下：
 
public class PropertiesReader {

    public static void main(String[] args) {
        new PropertiesReader().getProperties();
    }
    public Map<String, String> getProperties() {

        Properties props = new Properties();
        Map<String, String> map = new HashMap<String, String>();
        try {

            InputStream in = getClass().getResourceAsStream("type.properties");
            props.load(in);
            Enumeration en = props.propertyNames();
            while (en.hasMoreElements()) {
                String key = (String) en.nextElement();
                String property = props.getProperty(key);
                map.put(key, property);
                System.out.println(key + "  " + property);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return map;
    }
}
 
运行结果如下： 
 

Spring容器创建Bean的三种方法：JavaConfig,XML配置，自动装配
 
JavaConfig是独立于Spring的一个项目，在Spring3.0后出现。大部分企业中还是最常见的为自动装配及XML配置，其实JavaConfig也可被视为一个XML文件，只是由Java代码编写。XML配置文件只有在运行的时候的才检查Bean是否配置正确，比如如果没有相应的注解，无法注入到Spring容器，在启动时会报错，但是JavaConfig则会在编译的时候直接提示，利于提前发现错误。
 JavaConfig是一个配置类，用@Configuration注解来向Spring容器声明该类为一个配置类，通常单独放在一个包内。JavaConfig中实际就是为Spring配置Bean,通过@Bean来向Spring注入一个Bean并且返回一个类的实例化，容器中的类名就是Bean类的首个字母小写。可以想象，JavaConfig可以配置所有Spring需要的Bean,和XML文件配置及自动装配是一样的，JavaConfig注入Bean和其他两种方法向Spring容器中注入Bean是一样的，有DI依赖注入，依赖注入也相同，构造器注入，Setter方法依赖注入。下面的例子是简单的JavaConfig配置。
 

 
 
 

 该例子的意思为一个CDPlayer需要依赖一个CompactDisc也就是光盘才可以工作，依赖这个光盘。
 

 
 
 

 package JavaZhuangpeiBean;
 
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 
 import soudSystem.CDPlayer;
 import soudSystem.CompactDisc;
 import soudSystem.SgtPeppers;
 
 @Configuration
 public class CDPlayerConfig2 {
 
 @Bean
 public CDPlayer cdplayer(CompactDisc compactDisc){
 return new CDPlayer(
 compactDisc
 );                         //对这两个实例都通过构造器进行依赖注入一个compactDisc，查看一下Spring                                                                                       容器中对于同一个类的对象是否会创建多个
 }
 
 @Bean
 public CDPlayer anothercdplayer(CompactDisc compactDisc){
 return new CDPlayer(compactDisc);
 }
 }
 
 
 

 
 
 

 以上的配置文件向Spring容器声明了两个类，通过构造器注入了compactDisc。
 

 
 
 

 
 
 

 
 
 

 package soudSystem;
 
 public calss CompactDisc {
 void play(){
 System.out.println("----play------");
 }
 }
 
 

 
 
 

 以上创建一个类，有一个方法play。由此可以做个推断 1：如果play方法运行了，那么CompactDisc的对象肯定是创建了，否则无法运行其方法。2：CompactDisc要创建，必须CDPlayer的Bean要在容器中注册并创建，因为CDPlayer要依赖CompactDisc，CompactDisc已经创建了，CDPlayer必然创建了。那么到底是不是呢，我们用Junit来测试一下这两个Bean（CDPlayer，CompactDisc）是否为空，如果不为空，则表示已经通过JavaConfig在Spring容器中创建好了。
 

 
 
 

 package JavaZhuangpeiBean;
 
 import static org.junit.Assert.*;
 
 import org.junit.After;
 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;
 
 import soudSystem.CDPlayer;
 import soudSystem.CDPlayerConfig;
 import soudSystem.CompactDisc;
 @RunWith(SpringJUnit4ClassRunner.class)
 @ContextConfiguration(classes=CDPlayerConfig2.class) 
 public class CDPlayerConfig2Test {
 
 @Autowired
 private CompactDisc compactDisc;
 
 @Autowired
 private CDPlayer cdplayer;
 
 @Test
 public void testCdplayer() {
 assertNotNull(compactDisc);
 compactDisc.play();
 Boolean flag=compactDisc.equals(compactDisc)；
 

 System.out.println(flag);
 }
 
 @Test
 public void testAnothercdplayer() {
 assertNotNull(compactDisc);
 Boolean flag=compactDisc.equals(compactDisc);
 System.out.println(flag);
 }
 
 }
 
 

 
 
 

 
 
 

  
 

  
 
 
 
 
 

 
 
 
 

 
 
 

  
 

  
 
 
 
 
 

 运行结果：
 
 

 ----play------                    //由运行结果可看出不为null，说明已经创建bean成功了，调用  其方法也没有错
 true                                //由此可看出两个compactDisc是相同的，表明Spring对一同一个类只创建一个，Spring                                                             中的Bean都是单单例的。
 true