操作中遇到的问题

其他 2019-02-14 11:04:49 阅读次数: 0
一.连接数据库时配置文件中写的数据库名
二.Testng框架使用
  1).使用方法
   
@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 超时时间内

三.Spring的使用方法
1.简单使用
1).组件/框架设计
侵入式设计：
引入了框架，对现有的类的结构有影响，即需要实现或继承某些特定类，例如：Struts框架
非侵入设计：
引入了框架，对现实有的类结构没有影响，例如：Hibernate框架/Spring框架
2）控制反转和依赖注入
Inversion on Control控制反转IDC。
对象的创建交给外部容器完成这个就叫做控制反转
依赖注入dependency injection 处理对象的依赖关系
区别：
控制反转：解决对象创建的问题【对象创建交给别人】
依赖注入：在创建完对象后，对象的关系处理就是依赖注入【通过set方法依赖注入】
3）AOP
面向切面编程：切面，简单来说可以理解为一个类，由很多重复代码形成的类
切面举例：事务，日志，权限
 
 
2.spring框架分为六个模块：
1）模块以及模块解决的问题：

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等

3、开发步骤
3.1.下载源码
spring-framework-3.2.5.RELEASE
Sping必须要引入的jar文件有5个，分别是：
    commons-logging-1.1.3.jar  日志管理
    sping-beans-3.2.5.RELEASE.jar bean节点
    spring-context-3,2.RELEASE.jar spring 上下文节点
    spring-core-3.2.5.RELEASE.jar spring 核心功能
    pring-expression-3.2.5.RELEASE.jar spring 表达式相关表
3.2.配置
核心配置文件是：aalicationContext.xml,一般都是前者，JavaBean对象在这里面被创建，然后在java中调用就可以了。
假设已经存在一个User的JavaBean代码，需要创建对象，然后在java中使用
applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
            xmlns:xsi=" http://www.w3.org/2001/XMLSchema-instance"
            xsi:schemaLocation=" http://www.springframework.org/schema/beans
 
    <!--IOC容器的配置，要创建的所有的对象国都在这里配置-->
    <bean id="user" class="a_hello.User"></bean>
</beans>
 
使用API:
/**
*从IOC容器创建对象
*/
public class app{
    //1.通过工厂类得到IOC容器创建的对象
    @Test
    public void testIOC() throws Exception{
        //创建对象
//        User user = new User();
 
        //现在把对象的创建交给容器
        Resource resource = new ClassPathResource("a_hello/applicationContext.xml");
        //创容器对象（Beam的工厂），IOC容器=工厂类+applicationContext.xml
        BeanFactory factory = new XmlBeanFactory(resource);
        //得到容器创建的对象
        User user = (User) factory.getBean("user");
        
        System.out.println(user.getId());
    }
 
    //2.(方便)直接得到IOC容器对象
    @Test
    public void testAc() throws Exception{
        //得到IOC容器对象
        ApplicationContext ac = new ClassPathXmlApplicationContext("a_hello/applicationContext.xml");
        //从容器中 获取bean
        User user = (User) ac.getBean("user");
 
        System.out.printLn(user.getId());
    }
}
4.bean对象创建的细节
在applicationContext.xml中创建对象,要注意一些细节: 

/** * 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.使用注解,通过注解的方式,把对象加入

创建对象以及处理对象依赖关系,相关的注解:

​

猜你喜欢

转载自www.cnblogs.com/askill/p/10373352.html
今日推荐
《美国对全球网络空间安全与发展的威胁和破坏》报告发布
火速冲上 GitHub 热榜 —— 开源编程语言、框架哪有这么可爱？
北京人形机器人创新中心发布全球首个纯电驱拟人奔跑的全尺寸人形机器人“天工”
LFOSSA 源来如此公开课 | 掌握云原生未来：CNCF 认证全面攻略与备考秘籍
周排行
循环神经网络（rnn）讲解
Tigao教程四：单独的关节运动
金蝶K3WISE15.0-注册套打教程
如何在Mac上配置Kubernetes
Android应用结束自身进程的方法
SpringMVC学习 十三 拦截器栈
中国驻洛杉矶总领馆举行新春招待会
HttpClient get post 发送
11 - three.js 笔记 - 绘制三维字体模型
Mysql递归获取某个父节点下面的所有子节点和子节点上的所有父节点
每日归档
更多
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)
2024-04-22(39)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022