– Start
 点击此处观看本系列配套视频。
 
 
当我们需要某个对象时，通常的做法是 new 一个对象，然后使用它。使用 Spring 后，套路完全变了，Spring 帮我们创建对象，然后缓存到它的容器中，当我们需要一个对象时，问 Spring 要即可，怎么样？想法是不是非常妙，我们来看个例子吧。
 首先，定义一个类。
 
package shangbo.spring.core.example1;

public class OutPutService {
	
	public void outPut() {
        System.out.println("Hello World");
    }
	
}
 
然后定义一个 XML 配置文件，用来告诉 Spring 需要创建哪些对象以及如何创建对象。
 
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">

	<!-- 
		id 指定 bean 的标识符，必须唯一，如果没有设置，spring 帮我们生成一个
		name 也用来标识 bean，但可以起多个名字，不是必须要设置的
		class 指定类的全名
	-->
	<bean id="outPutService"
		name="outPutService1,outPutService2"
		class="shangbo.spring.core.example1.OutPutService"/>

</beans>
 
最后定义一个客户端测试类。
 
package shangbo.spring.core.example1;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class App {
	public static void main(String[] args) {
		// 实例化 Spring IoC 容器，也可以一次读取多个配置文件
		// ApplicationContext 有很多子类，可以根据你的需求选择
		ApplicationContext context = new ClassPathXmlApplicationContext("shangbo/spring/core/example1/example.xml");

		// 从容器中获得 Service 对象，传统方式是自己 new 对象
		OutPutService printer = context.getBean(OutPutService.class);

		// 使用对象
		printer.outPut();
	}
}
 
从这个例子我们可以看到，我们需要以某种方式告诉 Spring，哪些对象需要它管理，以及创建对象的细节，Spring 称之为配置元数据(Configuration metadata)， 这个例子使用 XML 配置元数据。下面我们看一个 Java 配置元数据的例子。
 首先定义一个类。
 
package shangbo.spring.core.example2;

public class OutPutService {
	
	public void outPut() {
        System.out.println("Hello World");
    }
	
}
 
然后定义一个Java配置类, 用来告诉 Spring 需要创建哪些对象以及如何创建对象。
 
package shangbo.spring.core.example2;

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

// @Configuration 用来标识该类是一个 Java 配置元数据
@Configuration
public class AppConfig {

	// @Bean 用来标识该对象需要 Spring 帮我们管理
	@Bean
	public OutPutService outPutService() {
		return new OutPutService();
	}
}
 
最后定义一个客户端测试类。
 
package shangbo.spring.core.example2;

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class App {
	public static void main(String[] args) {
		// 实例化 Spring IoC 容器，也可以一次读取多个Java配置文件
		ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);

		// 从容器中获得 Service 对象，传统方式是自己 new 对象
		OutPutService printer = context.getBean(OutPutService.class);

		// 使用对象
		printer.outPut();
	}
}
 
通过上面的例子可以看到，不管使用 XML 或 Java 配置元数据，我们仍然需要明确告诉 Spring 哪些对象需要它管理，以及创建对象的细节，有没有可能完全自动化呢？答案是肯定的，Spring 还支持基于注解的配置元数据，看看下面的例子吧。
 首先还是定义一个类。
 
package shangbo.spring.core.example3;

import org.springframework.stereotype.Component;

// @Component 标识的类可以被 Spring 自动管理
// @Service 标识的类也可以被 Spring 自动管理
// @Controller 标识的类也可以被 Spring 自动管理
// @Repository 标识的类也可以被 Spring 自动管理
@Component
public class OutPutService {

	public void outPut() {
		System.out.println("Hello World");
	}

}
 
然后定义如下 XML 配置文件，注意我们需要引入context命名空间。
 
<?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">

	<!-- 
		需要告诉 Spring 扫描组件的位置
	 -->
    <context:component-scan base-package="shangbo.spring.core.example3"/>

</beans>
 
然后是测试类。
 
package shangbo.spring.core.example3;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class App {
	public static void main(String[] args) {
		// 实例化 Spring IoC 容器，也可以一次读取多个配置文件
		// ApplicationContext 有很多子类，可以根据你的需求选择
		ApplicationContext context = new ClassPathXmlApplicationContext("example.xml", OutPutService.class);

		// 从容器中获得 Service 对象，传统方式是自己 new 对象
		OutPutService printer = context.getBean(OutPutService.class);

		// 使用对象
		printer.outPut();
	}
}
 
你也可以使用 Java 配置元数据。
 首先定义一个类。
 
package shangbo.spring.core.example4;

import org.springframework.stereotype.Component;

@Component
public class OutPutService {

	public void outPut() {
		System.out.println("Hello World");
	}

}
 
然后定义一个Java配置类。
 
package shangbo.spring.core.example4;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
// 需要告诉 Spring 扫描组件的位置
@ComponentScan(basePackages = "shangbo.spring.core.example4")
public class AppConfig {
	// 此处没有定义创建 bean 的细节
}

 
最后定义一个测试类。
 
package shangbo.spring.core.example4;

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class App {
	public static void main(String[] args) {
		// 实例化 Spring IoC 容器，也可以一次读取多个Java配置文件
		ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);

		// 从容器中获得 Service 对象，传统方式是自己 new 对象
		OutPutService printer = context.getBean(OutPutService.class);

		// 使用对象
		printer.outPut();
	}
}

 
– 更多参见：Spring Framework 精萃
 – 声 明：转载请注明出处
 – Last Updated on 2017-06-17
 – Written by ShangBo on 2017-05-20
 – End

最近项目中就有如题的一个需求，有些对象，不希望将其交给spring容器去管理，想通过自己new的方式去实例化，以便自己更好的去维护这个对象。
 
这里非SPRING管理的对象，即自己实例化的对象，用A来代替，SPRING管理的对象用B来代替
 
在网上找了很久，最终搞定了，这里先说一个弯路：
 

ApplicationContext context = new ClassPathXmlApplicationContext(
                "classpath*:spring/spring-*.xml");
        return (CommonService) context.getBean("commonService");
如上图所示，A类想引用B类，于是在A类中写了如上的方法来获取B类，启动项目后发现，一旦引用B类时，spring的所有对象就会再次实例化，通过JVM监控发现，对象快要撑爆了，果断放弃，说明如上方法和WEB容器启动加载不是共享的，是独立的，WEB容器启动加载了spring的所有对象，上面方法在被引用时又加载了，这就重复了，引用多少次，就重复多少次，巨坑啊！！！！
 

 
 
找寻spring容器的方法，从spring容器里去拿一个刚刚被spring容器实例化的对象，这样就不会重复加载了，拿的是实例化后的共享的一个对象
 
定义一个类实现自BeanFactoryAware接口
 
public class ServiceLocator
        implements BeanFactoryAware {

    private static BeanFactory beanFactory = null;
    private static ServiceLocator serviceLocator = null;

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        ServiceLocator.beanFactory = beanFactory;
    }

    public BeanFactory getBeanFactory() {
        return beanFactory;
    }

    public static ServiceLocator getInstance() {
        if (serviceLocator == null) {
            serviceLocator = (ServiceLocator) beanFactory.getBean("serviceLocator");
        }
        return serviceLocator;
    }

    public static Object getService(String serviceName) {
        return beanFactory.getBean(serviceName);
    }

}
这样在A类中，如果要引用B类的话，通过上述类的静态方法getService即可，将bean的名字传入

 
private CommonService getCommonService() {
        /*@SuppressWarnings("resource")
        ApplicationContext context = new ClassPathXmlApplicationContext(
                "classpath*:spring/spring-*.xml");
        return (CommonService) context.getBean("commonService");*/
        return (CommonService) ServiceLocator.getService("commonService");
    }
如上，亲测成功
 

 
 
这样，非SPRING管理对象和SPRING管理对象就完美的结合到了一起
 

 
 

 
 

 

                          Unity3D框架学习_对象池和对象池管理
 

目录
 
1、博客介绍
 
2、内容
 
（1）ObjectPoolContainer 对象容器
 
（2）ObjectPool 单一对象池
 
（3）PoolManager 对象池管理
 
3、推送
 
4、结语
 

1、博客介绍
 
        本篇博客介绍Unity对象池的管理，改自github某工程，结尾会推送，对象池没什么特别好说的了就是实例对象，释放对象，博主这篇写的很简单，读者直接看博主的工程就一目了然了，博客内不再书写代码，工程注释和结构都很清晰，配的还有流程图，工程推送在结尾博主的github。
 

2、内容
 
（1）ObjectPoolContainer 对象容器
 
该脚本包含了实例对象和该对象的使用状态
 
 
（2）ObjectPool 单一对象池
 
         对象池内包含了，储存对象容器的链表，正在使用的对象的字典，池子名字，获取对象实例的方法Get（），释放对象的方法Release（）。
 
 
（3）PoolManager 对象池管理
 
       对象池管理脚本，对象池会自动挂载在PoolManager空节点下，没有自动创建，生成物释放后也放置在PoolManager下,字典储存了不同的对象池， 可以设置刷新时间RefreshTime来定时刷新池子，会删除不活跃的池子。
 
 

3、推送
 
博主github：https://github.com/KingSun5/UnityPool
 
学习借鉴:https://github.com/thefuntastic/unity-object-pool
 

4、结语
 
学习使人进步，最近好困呀，春困呀，博主能力有限，若文中有出现什么错误的地方，欢迎各位评论指摘。
 
       QQ交流群：806091680（Chinar）
 
       该群为CSDN博主Chinar所创，推荐一下！我也在群里！
 
       本文属于原创文章，转载请著名作者出处并置顶！！！！！

  
 
     基于GUI的自动化测试主要是围绕着界面的控件元素来进行的，例如文本框、列表框、控制按钮等等，软件用户通常都是通过这些控件与程序交互，因此，编辑测试脚本的第一步就是识别测试对象。
 
  
 
1、测试对象、运行时对象的区分以及对象库概念
 
     首先区分UFT中测试对象和运行时对象概念。
 
 
    测试对象：Test Object，TO，是UFT定义的一些类，用它们来代表被测应用的各种对象；
 
 
 
TO属性：
 
    获取对象的属性，可以理解为静态的属性，在运行时的输入东西与它无关。测试对象的属性是UFT为了识别在测试执行过程中的运行时对象而保留在对象库中的属性。
 
    GetToProperty/GetToProperties和SetToProperty则分别用于读取和修改To的属性值
 
 
    运行时对象：Runtime Object，RO，是实际的被测应用对象，是测试执行过程中，TO用来关联的对象；
 
 
 
RO属性：
 
    是变的（用户名框输入不同的值，这个Ro属性取出来就是不一样）
 
    GetRoProperty方法用于取得运行时对象（实际对象）的某个属性的值。
 
 
     简单以登录操作中AgentName对象来说，to属性和运行时输入的东西无关，而ro属性是实际中被测应用对象，在测试执行过程中，会看到对应属性的变化：
 
 
 
 
 
 
       UFT对象库：UFT中，使用对象库对对象进行管理。记录的对象和这些对象的属性，都存储在对象库中。而对象库也可以设置为共享对象库，供多个Action调用。当发现对象库中缺少某个对象时，可以使用对象抓取工具，单个抓取对象添加到对象库中。  
 
    
 
  
 
2、对象库工具的一些操作
 
  
     1）对象识别器：Tools-----Object Identification
 
 
 
 
     2）对象嗅探器：Tools----Object Spy
 
 
 
 
     打开如下的嗅探器窗口，点击下图方框中的按钮，移动手型的光标，可以看到下图中显示当前光标下的空间属性
 
 
 
 
 
 
 
  
 
     3）对象库：Resources-----Object Repository
 
 
 
 
     注意这里存储的除了测试对象，还有其他的对象类型，如下面的检查点。同样在对象库中，我们可以点击工具栏中的按钮，添加对象到对象库中；也可以高亮某个测试对象；，也可以使用对象嗅探器捕获测试对象；也可以关联其他的测试对象；
 
 
 
 
  
 
     4）对象库管理：Resources----Object Repository Manager
 
     这里实际上共享对象库。在该对话框中，我们可以创建一个共享对象库、将对象库跟Action关联、添加对象到共享对象库中、保存一个共享对象库、修改共享对象库中的对象等。下面是新建一个共享的测试对象：
 
 
 
 
  
 
3、练习
 
     录制一个Flight程序登录的脚本。脚本要求：
 
使用Systemutil.Run打开程序
创建三个Action，分别是Login，NewOrder，Logout。在三个Action中分别录制对应的操作
保存NewOrder的本地对象库为NewOrder.tsr
删除NewOrder的本地对象库
将NewOrder的Action使用共享对象库（引用已保存的NewOrder.tsr），设置为共享对象库的路径为相对路径
使用自定义检查点，检查Price*Ticket的价格是否等于Total，并用If语句写出判断成功或是失败后的Reporter.ReportEvent报告语句
点击关闭，结束录制
 
     
 
 补充知识点：
 
     1）可以使用Systemutil.run加上程序路径，使UFT自动打开被测程序
 
     2）在录制脚本的过程中，可以点击“录制工具条”中的新建Action按钮，将三个部分的操作放在三个Action中
 
     3）UFT的VBscript脚本中，使用Const声明定义常量，使用Dim声明定义变量
 
     4）报告语句，如果程序正确，则可以书写为Reporter.ReportEvent micPass,"结果正确","总价格正确";如果程序不正确，可以使用Reporter.ReportEvent micFail,"结果错误","总价格计算错误";
 
 
 
 
 
 
 
 结果：
 
 
 
 NewOrder中代码：
 
 
'新建订单
Window("Flight Reservation").ActiveX("MaskEdBox").Type "121216"
Window("Flight Reservation").WinComboBox("Fly From:").Select "Denver"
Window("Flight Reservation").WinComboBox("Fly To:").Select "London"
Window("Flight Reservation").WinButton("FLIGHT").Click
Window("Flight Reservation").Dialog("Flights Table").WinButton("OK").Click
Window("Flight Reservation").WinEdit("Name:").Set "jojo"
Window("Flight Reservation").WinEdit("Tickets:").SetSelection 0,1

Dim tiknum,price,total
tiknum=2


Window("Flight Reservation").WinEdit("Tickets:").Set tiknum
Window("Flight Reservation").WinRadioButton("First").Set
Window("Flight Reservation").WinButton("Insert Order").Click

Dim pricestr,totalstr
pricestr=mid(window("Flight Reservation").WinEdit("Price:").GetROProperty("text"),2)
price=CDBl(pricestr)
totalstr=mid(window("Flight Reservation").WinEdit("Total:").GetROProperty("text"),2)
total=CDBl(totalstr)

If (price*tiknum)=total Then
    Reporter.ReportEvent micPass,"结果正确","总价格正确"
Else
    Reporter.ReportEvent micFail,"结果错误","总价格计算错误"
End if