@Test | 标记一个类或方法作为测试的一部分 |
@BeforeSuite | 注解的方法将只运行一次,运行所有测试前此套件中 |
@AfterSuite | 注解的方法将只运行一次此套件中的所有测试都运行之后 |
@BeforeClass | 注解的方法将只运行一次先行先试在当前类中的方法调用 |
@AfterClass | 注解的方法将只运行一次后已经运行在当前类中的所有测试方法 |
@BeforeTest | 注解的方法将被运行之前的任何测试方法属于内部类的 标签的运行 |
@AfterTest | 注解的方法将被运行后,所有的测试方法,属于内部类的标签的运行 |
@BeforeGroups | 组的列表,这种配置方法将之前运行。此方法是保证在运行属于任何这些组第一个测试方法,该方法被调用 |
@AfterGroups | 组的名单,这种配置方法后,将运行。此方法是保证运行后不久,最后的测试方法,该方法属于任何这些组被调用 |
@BeforeMethod | 注解的方法将每个测试方法之前运行 |
@AfterMethod | 被注释的方法将被运行后,每个测试方法 |
@DataProvider | 标志着一个方法,提供数据的一个测试方法。注解的方法必须返回一个Object[] [],其中每个对象[]的测试方法的参数列表中可以分配。该@Test 方法,希望从这个DataProvider的接收数据,需要使用一个dataProvider名称等于这个注解的名字 |
@Factory | 作为一个工厂,返回TestNG的测试类的对象将被用于标记的方法。该方法必须返回Object[] |
@Listeners | 定义一个测试类的监听器 |
@Parameters | 将xml文件中参数传递给@Test方法 |
@Test的使用
invocationCount可以定义用例调用次数
threadPoolSize 线程池内线程个数
timeOut 超时时间内
1.Spring Core,Spring的核心功能.
IOC容器,解决对象创建以及依赖关系
包含并管理应用对象的配置和生命周期,可以配置每一个bean如何被创建,也可以配置每一个bean是只有一个实例,还是每次需要时都生成一个新的实例,以及他们是如何相互关联的
2.Spring Web,Spring对Web模块的支持.
可以与Struts整合,让Struts的action创建交给Spring
提供了子弟的Spring MVC和对显示层框架的集合支持
3.Spring DAO,Spring对jdbc的支持
使用JdbcTemplate来简化数据操作
4.Spring ORM,Spring对ORM的支持.
提供了对主流的对象映射关系框架的支持
既可以与Hibernate整合(session)
也可以使用spring的对Hibernate操作的封装
5.Spring AOP,切面编程.
采用了面向切面编程来实现很多基础但是与业务逻辑无关的功能的解耦,比如:事务管理,日志,权限验证
6.Spring JEE,Spring对JavaEE其他模块的支持.
对java企业级开发提供了一些解决方案,如EJB,JMS等
/** * Bean对象创建的细节 */public class AppBean {
/** *1.对象创建:单例/多例 * 在applicationContext.xml配置文件中,设置scope参数 * scope="singleton",默认值,即默认是单例 [service/dao等工具类时使用单例] * scope="prototype",多例, [Action对象时用多例] */
/** *2.什么时候创建 * scope="singleton",在启动时(容器创建之前),就已经创建了bean,且整个应用只有一个对象 * scope="prototype",先创建容器,只有在用到对象的时候,才创建对象. */
/** * 3.是否延迟创建 * 在applicationContext.xml配置文件中,设置lazy-init参数 * lazy-init="false" 默认为false,不延迟创建,在启动的时候就创建对象 * lazy-init="true" 延迟初始化,在用到对象的时候才创建对象 * lazy-init参数只对单例有效 */
/** *4.创建对象之后,初始化/销毁 * init-method="init_user",init_user是user中的一个方法,对应对象的init_user方法,在对象创建之后执行 * destroy-method="destroy_user",destory_user是user中的一个方法,在调用容器对象的destriy方法时执行(容器用类实现) */
@Test
public void testAc() throws Exception{
//得到IOC容器对象
ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("a_hello/applicationContext.xml");
System.out.println("容器创建成功");
//从容器中获取bean
User user1 = (User) ac.getBean("user");
User user2 = (User) ac.getBean("user");
//scope="singleton"时,返回true
//scope="prototype"时,返回false
System.out.println(user1==user2);
//销毁容器对象,调用了destroy-method参数中的方法
ac.destroy();
}
}
applicationContext.xml文件:
<?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">
<!--IOC容器的配置,要创建的所有的对象都在这里配置-->
<bean id="user" class="a_hello.User" scope="singleton" lazy-init="false" init-method="init_user" destroy-method="destroy_user"></bean></beans>
2.Spring IOC容器功能
Spring IOC容器,是Spring核心内容,属于Spring Core部分.作用是:创建对象以及处理对象的依赖关系
下面分别看创建对象和依赖关系
2.1.创建对象
IOC容器创建对象的几种方式:
1.调用无参数构造器
2.带参数构造器
3.工厂创建对象,分为工厂类的静态方法创建对象和非静态方法创建对象
代码示例:
用java写一个工厂类:ObjectFactory.java
public class ObjectFactory {
//实例方法创建对象
public User getInstance(){
return new User(100,"调用实例方法");
}
//静态方法创建对象
public static User getStaticInstance(){
return new User(100,"调用静态方法");
}
}
applicationContext.xml写法:
<?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:p="http://www.springframework.org/schema/p" 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">
<!--对象创建-->
<!--1.默认无参数构造器-->
<!--<bean id="user" class="a_hello.User"/>-->
<!--2.带参数构造器-->
<bean id="user1" class="a_hello.User">
<!--type的值,如果是基本类型用常用的类型就可以,如果是引用类型就用类型的全名-->
<constructor-arg value="100" index="0" type="int"></constructor-arg>
<constructor-arg value="Jack" index="1" type="java.lang.String"></constructor-arg>
</bean>
<!--定义一个字符串,值是"Jack",String s = new String("Jack")-->
<bean id="str" class="java.lang.String">
<constructor-arg value="Jack"/>
</bean>
<bean id="user2" class="a_hello.User">
<constructor-arg index="0" type="int" value="100"/>
<constructor-arg index="1" type="java.lang.String" ref="str"/>
</bean>
<!--3.工厂类创建对象-->
<!--3.1.工厂类 实例方法-->
<!--先创建工厂-->
<bean id="factory" class="a_hello.ObjectFactory"/>
<!--再创建user对象,用factory的实例方法-->
<bean id="user3" factory-bean="factory" factory-method="getInstance"/>
<!--3.2.工厂类 静态方法-->
<!--class 指定的就是工厂类型-->
<!--factory-method 一定是工厂里面的静态方法-->
<bean id="user4" class="a_hello.ObjectFactory" factory-method="getStaticInstance"/></beans>
2.2.对象依赖关系
上面已经可以创建一个对象了,但是如何给对象的属性赋值呢?
1.通过构造函数(上面已经有例子了)
2.通过set方法给属性注入值
3.p名称空间
4.自动装配(了解)
5.注解
0.通过构造函数
<!--1.通过构造函数-->
<bean id="user" class="b_property.User">
<constructor-arg value="100"></constructor-arg>
<constructor-arg value="Jack"></constructor-arg>
</bean>
1.(常用)Set方法注入值
<!--2.通过set方法给属性赋值-->
<bean id="user1" class="b_property.User">
<!--user.id的赋值-->
<property name="id" value="99"/>
<!--user.name的赋值-->
<property name="name" value="Jerry"/>
</bean>
测试类:
@Test
public void testSet() throws Exception{
//创建容器对象
ApplicationContext ac = new ClassPathXmlApplicationContext("b_property/applicationContext.xml");
//获取容器中的对象
User user = (User) ac.getBean("user1");
System.out.println(user);
}
案例:在一个项目中,需要在action/service/dao三个地方创建对象.配置如下:
<!-- dao 对象创建 -->
<bean id="userDao" class="b_property.UserDao"></bean>
<!-- service 对象创建,并调用dao-->
<bean id="userService" class="b_property.UserService">
<property name="userDao" ref="userDao"></property>
</bean>
<!-- action 对象创建,并调用service -->
<bean id="userAction" class="b_property.UserAction">
<property name="userService" ref="userService"></property>
</bean>
2.内部bean
使用内部bean的方法,同样可以实现action/service/dao
<!--内部bean-->
<bean id="userAction" class="b_property.UserAction">
<property name="userService">
<bean class="b_property.UserService">
<property name="userDao">
<bean class="b_property.UserDao"></bean>
</property>
</bean>
</property>
</bean>
与Set注入的达到的效果是一样的,区别在于如果不同的action要使用service时候,需要再写一遍.且不易维护
3.p 名称空间注入属性值(优化)
使用p名称空间也可以达到上面同样的效果,并得到了优化
<!-- 对象属性赋值 -->
<!-- 给对象属性注入值也可以使用 p 名称空间给对象的属性注入值 注意:spring3.0以上版本才支持 -->
<bean id="userDao" class="b_property.UserDao"></bean>
<bean id="userService" class="b_property.UserService" p:userDao-ref="userDao"></bean>
<bean id="userAction" class="b_property.UserAction" p:userService-ref="userService"></bean>
<!-- 传统的注入: <bean id="user" class="b_property.User" > <property name="name" value="xxx"></property> </bean> -->
<!-- p名称空间优化后 -->
<bean id="user" class="b_property.User" p:name="Jack0001"></bean>
4.自动装配(了解)
根据名称自动装配
autowire="byName"会自动去IOC容器中查找与属性同名的引用的对象,并自动注入.
代码示例:
<!--自动装配-->
<bean id="userDao" class="d_auto.UserDao"></bean>
<bean id="userService" class="d_auto.UserService" autowire="byName"></bean>
<!-- 根据“名称”自动装配: userAction注入的属性,会去ioc容器中自动查找与属性同名的对象 -->
<bean id="userAction" class="d_auto.UserAction" autowire="byName"></bean>
也可以把autowire="byName"定义到全局,这样就不用每个bean节点都去写autowire="byName"
代码示例:
<?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:p="http://www.springframework.org/schema/p" 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" default-autowire="byName"> 根据名称自动装配(全局)
<!--自动装配 -->
<bean id="userDao" class="d_auto.UserDao"></bean>
<bean id="userService" class="d_auto.UserService"></bean>
<bean id="userAction" class="d_auto.UserAction"></bean></beans>
根据类型自动装配
除了根据相似的名称自动装配外,还可以根据类型自动装配,使用的参数为:autowire="byType".
此时必须确保该类型在IOC容器中只有一个对象,否则,报错!
示例代码:
<?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:p="http://www.springframework.org/schema/p" 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" default-autowire="byType">
<!-- ###############自动装配############### -->
<bean id="userDao" class="d_auto.UserDao"></bean>
<bean id="userService" class="d_auto.UserService"></bean>
<!-- 如果根据类型自动装配: 必须确保IOC容器中只有一个该类型的对象 -->
<bean id="userAction" class="d_auto.UserAction"></bean>
<!-- 报错: 因为上面已经有一个该类型的对象,且使用了根据类型自动装配 <bean id="userService_test" class="d_auto.UserService" autowire="byType"></bean> --></beans>
总结:
Spring提供的自动专配主要是为了简化配置;但是不利于后期的维护.一般推荐使用
5.注解
Spring的IOC容器的配置也可以使用注解来简化操作.
使用注解的步骤:
1.applicationContext.xml文件中引入context名称空间
mlns:context="http://www.springframework.org/schema/context"
2.开始注解扫描
<!--开始注解扫描-->
<!--base-package="b_property":扫描b_property包下的所有类-->
<context:component-scan base-package="b_property"/>
3.使用注解,通过注解的方式,把对象加入
创建对象以及处理对象依赖关系,相关的注解:
-
@component:指定把一个对象加入IOC容器
-
@Respository:作用同@component;在持久层使用
-
@Controller:作用同@component;在控制层使用