发号网站源码_发号_

发号网站源码_发号_

下面将有我来为大家聊一聊发号网站源码的问题，希望这个问题可以为您解答您的疑问，关于发号网站源码的问题我们就开始来说说。

文章目录列表:

1.代码是什么原理？

2.求助含有Junit测试代码的Java源代码，用来学习Junit

3.作为科研人员，看完《流浪地球 2》有哪些感受？

4.IFIX中如何引用CryStal Report

5.如何解决_的性能问题和超卖的讨论

代码是什么原理？

代码运行的全过程(原理)

首先操作系统是自由的,它可以对硬盘,CPU,内存发号施令

运行一段代码,操作系统先把代码和代码解释器从硬盘弄到内存中,CPU先用解释器把代码解释成机器码,解释型语言就解释一句,执行一句,编译型语言就把所有语句翻译成机器码,保存为机器码文件,然后把机器码文件存到内存里,然后CPU再启动内存中的机器码

代码就是程序员用开发工具所支持的语言写出来的源文件，是一组由字符、符号或信号码元以离散形式表示信息的明确的规则体系。代码设计的原则包括_确定性、标准化和通用性、可扩充性与稳定性、便于识别与记忆、力求短小与格式_以及容易修改等。

在现代程序语言中，源代码可以是以书籍或者磁带的形式出现，但_为常用的格式是文本文件，这种典型格式的目的是为了编译出计算机程序。

代码就是用一篇文章来描述我希望电脑帮我做的事情，我们使用编程语言这种介于人类语言和机器能读懂的语言之间的语言来表达如何指挥电脑做事情。

当然_后需要一个翻译软件自动把我们的编程语言翻译成电脑读的懂的语言，然后电脑读取翻译后的语言做事情。

求助含有Junit测试代码的Java源代码，用来学习Junit

下面是我做项目时的例子，希望对你有所帮助。

/*

*@author ougaoyan ,date:2008-10-19

*/

package test;

import java.util.Date;

import junit.framework.TestCase;

import _.DA.BookDA;

import _.PD.Book;

public class TestBookDA extends TestCase {

public TestBookDA(String name){

super(name);

}

// public Book(int bookID, String cip, String name, String author,String press, String category, int quantity, int reborrowable,int borrowerID,Date startDate)

public_oid testEditBook(){

Book book1=new Book(1,"123456","信号","张建","某出版社","电信",1,1,1,new Date());

Book book2=new Book(-1,"123456","信号","张建","某出版社","电信",1,1,1,new Date());

Book book3=new Book(99,"123456","信号","张建","某出版社","电信",1,1,1,new Date());

Book book4=new Book(1,"123456","信号","张建","某出版社","电信",1,1,1,new Date());

assertEquals(true,BookDA.editBook(book1));

assertEquals(false,BookDA.editBook(book2));

assertEquals(true,BookDA.editBook(book3));

assertEquals(false,BookDA.editBook(book4));

}

////Book(int borrowerID, Date startDate, int reBorrowable, String cip)

public_oid testAddBook(){

Book book1=new Book(0,"234567","信发号","张建","某出版社","电信",1,1,1,new Date());

Book book2=new Book(0,"123456","信的号","张建","某出版社","电信",1,1,1,new Date());

Book book3=new Book(0,"99999","信i号","张建","某出版社","电信",1,1,1,new Date());

assertEquals(true,BookDA.addBook(book1));

assertEquals(true,BookDA.addBook(book2));

assertEquals(false,BookDA.addBook(book3));

}

public static_oid main(String[] args) {

junit.textui.TestRunner.run(TestBookDA.class);

System.out.println(new TestBookDA("TestBookDA").countTestCases());

}

}

/*

*@author ougaoyan ,date:2008-10-19

*/

package test;

import java.util.Date;

import java.util.Vector;

import junit.framework.TestCase;

import _.DA.CipDA;

import _.PD.Cip;

public class TestCipDA extends TestCase {

public TestCipDA (String name){

super(name);

}

public_oid testFindBooksByName(){

String name1="数据库";

String name2="小小";

_ector_ector1=CipDA.findBooksByName(name1);

_ector_ector2=CipDA.findBooksByName(name2);

assertNotNull(vector1);

assertNull(vector2);

}

public_oid testFindBooksByAuthor(){

String name1="欧阳";

String name2="小小";

_ector_ector1=CipDA.findBooksByAuthor(name1);

_ector_ector2=CipDA.findBooksByAuthor(name2);

assertNotNull(vector1);

assertNull(vector2);

}

public_oid testFindBooksByCategory(){

String name1="计算机";

String name2="计 算 机";

String name3="wucimin";

_ector_ector1=CipDA.findBooksByCategory(name1);

_ector_ector2=CipDA.findBooksByCategory(name2);

_ector_ector3=CipDA.findBooksByCategory(name3);

assertNotNull(vector1);

assertNotNull(vector2);

assertNull(vector3);

}

// public_oid testEditCip(){

// }

//public Cip(String cip, String name, String author, String press,String category, int quantity, int reserverID,Date reservedDate)

public_oid testAddCip(){

Cip cip1=new Cip("2244","新加书","新者","出版社","计算机",3,0,new Date());

//Cip cip2=new Cip(null,"新加书","新者","出版社","计算机",3,0,new Date());

Cip cip3=new Cip("22er3rr3rt4t43t43t3t34t34t34t44","新加书","新者","出版社","计算机",3,0,new Date());

assertEquals(true,CipDA.addCip(cip1));

//assertEquals(false,CipDA.addCip(cip2));

assertEquals(false,CipDA.addCip(cip3));

}

public_oid testEditCip(){

Cip cip1=new Cip("2244","新加书","新者","出版社","计算机",3,0,new Date());

Cip cip2=new Cip(null,"新加书","新者","出版社","计算机",3,0,new Date());

Cip cip3=new Cip("22er3rr3rt4t43t43t3t34t34t34t44","新加书","新者","出版社","计算机",3,0,new Date());

assertEquals(true,CipDA.editCip(cip1));

assertEquals(false,CipDA.editCip(cip2));

assertEquals(false,CipDA.editCip(cip3));

}

public static_oid main(String[] args) {

junit.textui.TestRunner.run(TestCipDA.class);

System.out.println(new TestCipDA("TestCipDA").countTestCases());

}

}

/*

*@author ougaoyan ,date:2008-10-19

*/

package test;

import java.util.Date;

import java.util.Vector;

import junit.framework.TestCase;

import _.DA.LibManagerDA;

import _.PD.LibManager;

import _.PD.Student;

public class TestLibManagerDA extends TestCase {

public TestLibManagerDA(String name){

super(name);

}

public_oid testCheck(){

String userName1="1234";

String password1="111111";

String userName2="";

String password2="";

String userName3="1234";

String password3="111";

LibManager libmanager=new LibManager(1,userName1,password1,"w");

assertEquals(libmanager.getID(), LibManagerDA.check(userName1,password1).getID());

assertEquals(libmanager.getName(), LibManagerDA.check(userName1,password1).getName());

assertEquals(null, LibManagerDA.check(userName2,password2));

assertEquals(null, LibManagerDA.check(userName3,password3));

}

public_oid testUpdatePwd(){

int id1=1,id2=99;

String qpwd="234567";

assertEquals(true,LibManagerDA.updatePwd(id1, qpwd));

assertEquals(false,LibManagerDA.updatePwd(id2, qpwd));

}

public_oid testSearchLibManager(){

LibManager libmanager1=new LibManager(1,"1234","111111","w");

LibManager libmanager2=new LibManager(2,"2345","23456","x");

assertEquals(libmanager1.getID(), LibManagerDA.searchLibManager("1234").getID());

assertEquals(libmanager2.getID(), LibManagerDA.searchLibManager("2345").getID());

assertNull(LibManagerDA.searchLibManager(""));

}

public_oid testQuantity(){

String cip1="123456";

String cip2="234567";

assertEquals(1,LibManagerDA.getBookQuantity(cip1));

assertEquals(3,LibManagerDA.getBookQuantity(cip2));

assertEquals(-1,LibManagerDA.getBookQuantity(""));

}

public_oid testEditLibManager(){

LibManager libmanager1=new LibManager(1,"1234","111111","w");

LibManager libmanager2=new LibManager(2,"2345","23456","x");

//LibManager libmanager3=new LibManager(90,"123456677","0","y");

LibManager libmanager4=new LibManager(3,"123456677","0","e");

assertEquals(true, LibManagerDA.editLibManager(libmanager1));

assertEquals(true,LibManagerDA.editLibManager(libmanager2));

//assertEquals(false,LibManagerDA.editLibManager(libmanager3));

assertEquals(false,LibManagerDA.editLibManager(libmanager4));

}

public_oid testAddLibManager(){

LibManager libmanager1=new LibManager(-1,"1234","0","z");

LibManager libmanager2=new LibManager(-1,"2345","0","x");

LibManager libmanager3=new LibManager(-1,"12hh3456677","0","y");

assertEquals(true, LibManagerDA.addLibManager(libmanager1));

assertEquals(true,LibManagerDA.addLibManager(libmanager2));

assertEquals(false,LibManagerDA.addLibManager(libmanager3));

}

public_oid testGetBookCip(){

int bookid1=1;

int bookid2=4;

int bookid3=-1;

String exceptedcip1="123456";

String exceptedcip2="234567";

String exceptedcip3=null;

assertEquals(exceptedcip1, LibManagerDA.getBookCip(bookid1));

assertEquals(exceptedcip2, LibManagerDA.getBookCip(bookid2));

assertEquals(exceptedcip3, LibManagerDA.getBookCip(bookid3));

}

public_oid testCheckReserved(){

String cip1="123456";

String cip2="234567";

int studentid1=1;

int studentid2=2;

int studentid3=99;

assertEquals(true, LibManagerDA.checkReserved(cip1,studentid1));

assertEquals(true, LibManagerDA.checkReserved(cip2,studentid2));

assertEquals(false, LibManagerDA.checkReserved(cip1,studentid2));

assertEquals(false,LibManagerDA.checkReserved(cip2,studentid1));

assertEquals(false,LibManagerDA.checkReserved(cip2,studentid3));

assertEquals(false,LibManagerDA.checkReserved(cip1,studentid3));

}

//public static boolean borrowOPeration(int quantity, int bookID, int borrowerID,int reservedNum, int borrowedNum,Date startDate)

public_oid testBorrowOPeration(){

int quantity1=1;

int bookID1=2;

int borrowerID1=3;

int reservedNum1=1;

int borrowedNum1=4;

int quantity2=1;

int bookID2=1;

int borrowerID2=3;

int reservedNum2=0;

int borrowedNum2=7;

assertEquals(true,LibManagerDA.borrowOperation(quantity1, bookID1, borrowerID1, reservedNum1, borrowedNum1, new Date()));

assertEquals(false,LibManagerDA.borrowOperation(quantity2, bookID2, borrowerID2, reservedNum2, borrowedNum2, new Date()));

}

//public static boolean returnOperation (int quantity, int bookID, int borrowerID, int borrowedNum, Date startDate, int reborrowable)

public_oid testReturnOperation(){

int quantity1=1;

int bookID1=1;

int borrowerID1=1;

int borrowedNum1=4;

int reborrowable1=0;

int quantity2=1;

int bookID2=2;

int borrowerID2=2;

int borrowedNum2=7;

int reborrowable2=0;

assertEquals(true,LibManagerDA.returnOperation(quantity1, bookID1, borrowerID1, borrowedNum1, new Date(),reborrowable1));

assertEquals(true,LibManagerDA.returnOperation(quantity2, bookID2, borrowerID2, borrowedNum2,new Date(), reborrowable2));

}

public_oid testGetBookQuantity(){

String cip1="123456";

String cip2="234567";

int quantity1=5;

int quantity2=3;

assertEquals(quantity1,LibManagerDA.getBookQuantity(cip1));

assertEquals(quantity2,LibManagerDA.getBookQuantity(cip2));

}

public_oid testFindBill(){

String userName1="111111";

String userName2="222222";

float bill1=0;

float bill2=0;

assertEquals(bill1,LibManagerDA.findBill(userName1),0.000001);

assertEquals(bill2,LibManagerDA.findBill(userName2),0.000001);

}

public_oid testClearBill(){

String userName1="111111";

String userName2="222222";

assertEquals(true,LibManagerDA.clearBill(userName1));

assertEquals(true,LibManagerDA.clearBill(userName2));

}

public_oid testSelectAllLibManager(){

_ector allLibManager=new_ector();

allLibManager=LibManagerDA.selectAllLibManager();

for(int i=0;i <allLibManager.size();i++ ){

LibManager libManager=(LibManager)allLibManager.get(i);

System.out.println(libManager.getName());

}

}

public_oid testSecelctAllStudent(){

_ector allStudent=new_ector();

allStudent=LibManagerDA.secelctAllStudent();

for(int i=0;i <allStudent.size();i++ ){

Student student=(Student)allStudent.get(i);

System.out.println(student.getName());

}

}

public_oid testStartTimes(){

_ector times=new_ector();

times=LibManagerDA.startTimes(0);

for(int i=0;i < times.size();i ++)

System.out.println((Date)times.get(i));

}

public_oid testUpdateStuBill() {

}

public static_oid main(String[] args) {

junit.textui.TestRunner.run(TestLibManagerDA.class);

System.out.println(new TestLibManagerDA("dd ").countTestCases());

}

}

/*

*@author ougaoyan ,date:2008-10-19

*/

package test;

import java.util.Date;

import java.util.Vector;

import junit.framework.TestCase;

import _.DA.StudentDA;

import _.PD.Book;

import _.PD.Cip;

import _.PD.Student;

public class TestStudentDA extends TestCase {

public TestStudentDA(String name){

super(name);

}

/*public Student(int id, int borrowedNum, int reservedNum, float bill,

String userName, String password, String name, String department,

String unit, String sex) */

public_oid testCheck(){

Student student1=new Student(1,0,0,0,"111111","123456","张三","软件","0602","男");

//Student student2=new Student(1,0,0,0,"111111","123","张三","软件","0602","男");

//Student student3=new Student(2,0,0,0,"11111","123456","张三","软件","0602","男");

assertEquals(student1.getId(),StudentDA.check("111111","123456").getId());

assertEquals(true,student1.getId()==StudentDA.check("111111","123456").getId());

assertEquals(null,StudentDA.check("111111","12356"));

//assertEquals(false,);

//assertEquals(false,);

}

public_oid testUpdatePwd(){

int id1=1;

int id2=2;

int id3=-1;

String password1="123456";

String password2="234567";

String password3="1234555";

assertEquals(true,StudentDA.updatePwd(id1, password1));

assertEquals(true,StudentDA.updatePwd(id2, password2));

assertEquals(false,StudentDA.updatePwd(id3, password3));

}

public_oid testSearchStudent(){

Student student1=new Student(1,0,0,0,"111111","123456","张三","软件","0602","男");

assertEquals(true,student1.getId()==StudentDA.searchStudent("111111").getId());

assertEquals(null,StudentDA.searchStudent("111"));

}

public_oid testEditStudent(){

Student student1=new Student(1,0,0,0,"111111","123456","张三","软件","0602","女");

Student student2=new Student(1,0,0,0,"11111333555555555556631","123456","张三","软件","0602","女");

assertEquals(true,StudentDA.editStudent(student1));

assertEquals(false,StudentDA.editStudent(student2));

}

public_oid testAddStudent(){

Student student1=new Student(5,0,0,0,"111111","123456","张三","软件","0602","女");

Student student2=new Student(1,0,0,0,"1111133331","123456","张三","软件","0602","女");

assertEquals(true,StudentDA.addStudent(student1));

//assertEquals(false,StudentDA.addStudent(student2));

}

public static_oid testGetBorrowBookInfor(){

int studentid1=1;

int studentid2=2;

int studentid3=5;

_ector_ector1=new_ector();

_ector_ector2=new_ector();

_ector_ector3=new_ector();

_ector1=StudentDA.getBorrowBookInfor(studentid1);

_ector2=StudentDA.getBorrowBookInfor(studentid2);

_ector3=StudentDA.getBorrowBookInfor(studentid3);

//System.out.println(vector1);

assertNotNull(((Book)vector1.get(0)).getName());

}

public_oid testGetReserveBookInfor(){

int studentid1=1;

_ector_ector1=new_ector();

_ector1=StudentDA.getReserveBookInfor(studentid1);

assertEquals("数据库",((Cip)vector1.get(0)).getCategory());

}

//public static boolean reserveOperation(int reserverID1, String cip1, int quantity1, int reservedNum1, Date reservedDate1 )

public_oid testReserveOperation(){

assertEquals(true,StudentDA.reserveOperation(1, "123456", 1, 2, new Date()));

}

//void cancelReservation(int reserverID1,String cip1, int quantity1, int reserveNum1)

public_oid testCancelReservation(){

assertTrue(StudentDA.cancelReservation(1, "1234567", 1, 3));

}

//public static boolean updateReborrowable(int bookID, int reborrowable1, int studentID,Date startDate1)

public_oid testUpdateReborrowable(){

assertTrue(StudentDA.updateReborrowable(2,0,1,new Date()));

}

public static_oid main(String[] args) {

//junit.textui.TestRunner.run(TestStudentDA.class);

//System.out.println(new TestStudentDA("TestStudentDA").countTestCases());

testGetBorrowBookInfor();

}

}

/*

*@author ougaoyan ,date:2008-10-19

*/

package test;

import junit.framework.Test;

import junit.framework.TestSuite;

public class AllTests {

public static Test suite() {

TestSuite suite=new TestSuite("Test for test");

suite.addTestSuite(TestLibManagerDA.class);

suite.addTestSuite(TestBookDA.class);

suite.addTestSuite(TestCipDA.class);

suite.addTestSuite(TestStudentDA.class);

//suite.addTestSuite(TestLibManagerDA.class);

//$JUnit-END$

return suite;

}

}

作为科研人员，看完《流浪地球 2》有哪些感受？

通观整部影片，无不围绕着“灾难”与“拯救”两个关键词。灾难是太阳系不再适合人类，地球必须要去流浪。而“拯救”则是多方面，多层次的：有人类的自我拯救，有英雄的自告奋勇、舍生忘死，有全球的合作——如：联合政府的成立，有人类_武器的应用——如：核武轰炸月球，有“数据生命”的积极参与，还有人工智能的“反向”拯救。

尤其值得一提的，就是人工智能的“反向”拯救”。其冷静与睿智，令人印象深刻。当人类在地球是否要去“流浪”上争论不休时，人工智能制造了一些灾难，以此来逼迫人类尽快做出理性选择。也许手段不够委婉，但初衷却是好的，也算勉强能够接受。不过，至少透漏出一个信号，那就是：当人工智能有了自我意识之后，它会自行判断而不会听从人类的“发号施令”。

这就不禁让我们担心：这样的人工智能，若是再具备了自我迭代能力，掌握了庞大的资源，拥有了超强的力量……那么，它还能够始终不改造福人类的初心吗？我想未必。人类不能对此太乐观。害人之心不可有，防人之心不可无。人类必须要保持清醒，确保在与人工智能的博弈中，始终处于优胜。不然，人类就可能失去对于自身命运掌控的权利。

IFIX中如何引用CryStal Report

在这里我主要想和大家讨论一下Crystal Report的总体框架模式方面的问题，重点是如何使用VB有效的融合报表和数据，快速的进行报表开发工作。希望抛砖引玉，找到几种_好_快的开发模式。

本文暂不涉及技术细节，所以您可能觉得太过简单。但这样的问题的确是我们开发中的_号大问题。在以后的讨论中，我们可以针对具体的问题讨论具体的技术细节。

我准备了一份源代码，已经发给了部分网友，但是没有做详细的测试。我准备在明后天做完测试，如果各位有需要的话，应该在星期一左右可以发给你们(唉，星期六星期天还要加班!)。

注意：有需要的朋友请跟帖说明，不要只给我发短消息。

缩写语说明

RPT Crystal Report Template File. 使用Crystal Report设计器生成的报表样式和模板文件，后缀名为RPT

RDC Crystal Report Designer Component. Crystal Report的对象模型，用于在VB中操作Crystal Report.

CRV Crystal Report_iewer. OCX 控件，用于在VB中提供报表预览界面。

CRC Crystal Report Control. OCX 控件，在Crystal Report 8.0以前用于在VB中提供报表预览界面，现已被CRV取代。

CDO Crystal Data Source Object. Crystal Report 提供的数据源对象，用于创建与数据库无关的动态数据源。

一，如何动态获取数据，生成报表？

报表的一个主要特征就是根据事先设计好的模板样式和运行时的动态数据生成一份可查看与打印的文档。

一般来说，VB的程序中整个报表流程中的主线，由它来对Crystal Report及其它工具发号施令，实现用户需求。

VB是通过RDC模型来操作CrystalReport的。通常有如下两种模式生成报表：

1，VB-RPT-DB

_B调用RPT文件，RPT文件查询数据库得到数据，生成报表。此方法的详细流程如下：

1）在Crystal Report 中设计好RPT文件，设计时可在CrystalReport中连接到数据库，得到查询数据，即时预览报表。

2) 在VB中，通过RDC模型打开RPT文件，并将运行时和数据库连接所需的信息，如数据库名，用户，密码等传给RPT文件，如果RPT文件中有参数，还要传入参数。

3）RPT文件连接到数据库，执行查询得到数据，生成报表。

4) 在VB中，通过CRV控件打开报表进行预览或通过RDC模型进行打印，导出等操作。

2，VB-DB-RPT

_B先查询数据库得到结果集，再打开RPT文件并传入结果集，生成报表。此方法详细流程如下：

1）在Crystal Report 中设计好RPT文件。由于此时结果集还未生成，只能使用TTX文件做为虚拟数据源，以便读取字段信息。所以在设计RPT文件之前，还要根据_终的结果集结构生成一个TTX文件。

2）在VB中，连接到数据库，执行查询，得到结果集。

3）在VB中，通过RDC模型打开RPT文件，传入结果集和参数，生成报表。

4）在VB中，通过CRV控件打开报表进行预览或通过RDC模型进行打印，导出等操作。

显然，VB-RPT-DB模式远优于VB-DB-RPT模式，这体现在如下几个方面：

1，设计时，VB-DB-RPT模式一般要求生成一个和_终结果集字段结构完全一致的TTX文件做为虚拟数据源，增大的开发和维护的工作量，而且还不能即时预览生成的报表。VB-RPT-DB模式则是直接和数据库相连，无需TTX文件，还能看到_终数据。

2，运行时，VB-DB-RPT模式在得到结果集后，需要在VB中建立相应的结果集对象，并将其传入RPT文件，与VB-RPT-DB模式相比多了一个很大的对象－－结果集对象。

3，运行时，VB-DB-RPT模式的结果集从DB传到VB，再传到RPT， 而VB-RPT-DB模式的结果集直接从DB传到RPT，少了一次大的数据传递。

4, 开发时，VB-DB-RPT模式一般每加一个报表，就要加两段代码：查询结果集和生成报表。而VB-RPT-DB模式可以很方便的实现一个接口应对所有的报表，新加报表几乎无需增加VB代码。二者的代码量不可同日而语。

二、如何生成报表模板文件？

设计报表格式是所有报表工作的_步。在CrystalReport中，有两个地方可以设计报表，Crystal Report集成设计器和内嵌在VB中的报表设计器。我个人觉得，内嵌报表设计器的做法弊远大于利，不推荐使用。

三，如何查询DB，得到运行时数据。

通过VB查询DB得到结果集的方式有很多种，大家都很熟悉。通过RPT查询DB的方式主要有：存储过程，视图，表， Crystal Query， 直接SQL查询。

其中_简单的莫过于直接连接到表，进行表查询。可是一般的报表都不会只涉及到一个表。在RPT文件中进行多表查询并设置查询条件的方法虽然简单，但是分散了整体的查询逻辑，而且操作烦琐，不是一个好办法。视图和存储过程是_好的选择，不过视图在性能上不及存储过程，所以我推荐使用存储过程。

存储过程和视图是放在数据库中的。如果不允许或不能在数据库中建立视图和存储过程等，还可以利用Crystal Report自已的SQL查询功能，将完整的SQL查询语句写在RPT文件中。

从Crystal Report自己的说明来看，Crystal Query文件就像是Crystal Report自己的存储过程。不过这个工具不包含在Crystal Report 9中。Crystal Report 官方网站提供了单独的免费下载。这个工具有两个限制：在Crystal Queryk中的每个字段，字段值长度不能超过20个字符, 总字段数据也不能超过20个。我是从Crystal Report的帮助文件中看到这些信息的。如是真的话，Crystal Query就没有什么竞争力了。Crystal Report 也支持在设计RPT文件时直接写SQL，还可以带参数。这是个不错的功能。不知道是不是也有上述两个限制。

我没有仔细测试Crystal Report内嵌SQL查询的功能，在此不宜多加评论。但我强烈推荐使用数据库的存储过程和视图。它有效的分离的报表工作中的逻辑和设计工作，利于分工合作，也利于编护和升级。

使用Oracle的存储过程有如下限制，SQL Server 类似。

> 要使用本地连接或ODBC连接到Oracle，不能使用OLE DB连接。建议使用本地连接。

> 存储过程必须放到一个包内。结果集游标必须在包头声明。

> 存储过程只能有输入参数。

> 存储过程只能返回一个结果集，以输入输出型（IN OUT）的游标参数形式返回。

> 结果集中的字段名称和类型通过打开游标的SQL语句直接确定。所以不能使用动态SQL，也不能通过嵌套调用存储过程的方式来将数据装入游标。

四，如何传递多个数据源和参数。

如果所有的数据源都是VB-RPT-DB模式，那么VB要做的连接工作就很简单，将一个动态建立的连接传给RDC就可以了。RDC再将连接传给每一个RPT中存在的数据源。即便在报表包含子报表时也是如此的简单。

如果数据源是VB-DB-RPT模式，或都是好几种类型混合的。_好在设计报表的时候给每个数据源设定一个_名字（包括子报表的数据源），RDC就跟据名字来给每个数据源传递连接信息或结果集。

事实上，在一个报表中即便存在多个数据源，由于Crystal Report要求互相之间要有主键的对应关系，而不能一个数据源处理完后再处理另一个数据源，所以这些多个的数据源在本质上仍然是一个数据源。我做过很多复杂的报表，很少碰到要用到多个数据源的。使用子报表的情况倒是占了一半左右。

报表中的所参数都可以从VB中传入，建议也为所有的参数（包括子报表的参数）设定一个_的名字，由RDC跟据名字来传值，这样就不用理会报表中有哪些子报表了。

在处理大量的报表时，将报表的RPT文件路径及其参数信息存入数据库，就可以实现新增报表无须修改VB程序。一般而言，一个系统中的绝大部分报表，其参数都差不多，很容易控制。

2.1 准备一个通用模板。

一个项目中的所有报表，通常有一个_的格式和标准。准备一个带有_基本格式和标准的RPT文件作为模板是个聪明的做法。不过Crystal Report中的模板向导功能并不是很强，不如直接创建一个RPT文件，然后复制来得快。

2.2 在Crystal Report 编辑环境中设定字段和数据的缺省模式。

在Crystal Report的选项菜单(文件－＞选项)中设定要不同字段，不同数据类型的显示格式和字体，这一点非常重要。它可以_的保证的模板设计完全符合标准。减少重复劳动。

在文件－＞报表选项中也有三项很重要的设置：

1) 将数据库的NULL值转为默认值， 选中。

2) 将其它NULL值转为默认值， 选中。

3) 若无记录则取消打印， 不选。

2.3 选择一个可以同时支持中英文的字体。

字体的选择直接影响版面效果。有的字体不支持中文，显示中文时就会出现乱码。有的中文字体在纯英文下不能使用。有的字体在Windows 2000/XP的中英文环境中大小不同。有的字体不是Windows 自带字体。

_好在各种环境下试过后再决定采用哪种字体。

2.4 使用公式字段，汇总字段，运行时总计字段，以及变量实现数据的页面逻辑。

Crystal Report中的公式其实就是一个表达式，它通过使用Crystal Report中的函数和操作符来操作数据源中的数据以得到_终想要显示的字段。在公式中还可以使用变量。

在Crystal Report中有两种比较特别的公式：汇总公式和运行时总计公式。这两种公式都可以在公式编辑器（CR称之为公式工作室）中编辑，但比较复杂。CR提供了更简单的方法：在报表中选中要统计的字段，点出右键菜单，选中"插入…"项，就会弹出两个子菜单项：汇总，运行总计。

汇总字段用于对特定的字段进行按组或全局的汇总统计。

运行时总计字段在汇总字段的基础上加入条伯控制，使得在报表中跟据一个字段的不同取值分别得到另一个字段的总计数据成为可能。

在公式编辑器中可以使用变量。按作用域分，有局部变量，全局变量和共享变量。局部变量只在一个公式或函数中有效。全局变量在整个报表（但不包含子报表）中有效，共享变量在一个报表文件，包括子报表中都有效。

2.5 使用子报表。

跟据以往的项目经验，有一半左右的报表要用到子报表。在Crystal Report中，一个报表事实上只能处理一个结果集。存在多个结果集，要求互相之间有主键的对应关系，在本质上仍然是一个。如果报表要显示多个部分，就必须使用子报表。除没有单独的页眉和页脚外，子报表具有完整报表的所有特性。

页面显示的时候，子报表的宽度会受到其在主报表中的宽度限制，所以在把子报表放入主报表的时候，一定要给予足够的宽度。

主报表和子报表之间可以通过字段－参数的关系进行链接。即将主报表中的字段作为子报表的参数。

2.6 使用交叉表。

设有A，B两个字段，要求在报表中将A的全部值显示在_列的列头，将B的全部值显示在每一行的行首，在行和列的主体部分显示出跟据相应的A值和B值计算出来的结果，如下图所示。这就是一个交叉表。

交叉表中Crystal Report 中的一个对象，可以很简单的创建，注意交叉表应放到报表的报表页脚部分（Report Footer），不能放在细节部分或页眉。否则会导致重复显示和数据不全。

Crystal Report对交叉表的分页功能支持不佳，所以要尽可能的不让数据超过一页。

2.7 使用分栏表。

所谓分栏表，就是把页面分成几栏来显示结果。这样就可以在同一行显示多条记录。

在节_中选中详细资料节，注意只能选详细资料节的总节，不能选子节，就可以发出多栏格式化的选项，选中后界面上会多出一个布局的选项卡。在这个选项卡中就可以设置分栏。

2.8 _好不要在每页显示总页数。

显示总页数会导致报表多一次全程运算，严重降低性能，_好不要在每页都显示总页数。

2.9 把报表打印出来检查格式与数据。

这是个要诀，不打印出来检查，你的格式与数据很难保证没有错误。

2.10 设置字段或小节的条件显示条件

Crystal Report中的所有对象，大到一个小节，小到一个字段，都可限定显示的格式。在这些对象的格式化编辑器中，有个抑制显示的选项，其右有一个公式编辑按钮，点击这个按钮就可以进入公式编辑器，编辑一个逻辑表达式来控制抑制显示的条件。注意，只有勾上抑制显示的选项，条件公式才会起作用。

2.11 对字段进行有条件的格式化

如果碰到类似这样要求，就要对字段进行有条件的格式化：将所有值大于1000的A字段加下划线显示。

对字段的有条件格式化只能在公式编辑器（公式工作室）中实现。

2.12 在导出为RTF是要注意字段对齐。

如果报表的字段是随意放置的，在导出RTF文件是将会出现位置的严重错乱。

如何解决_的性能问题和超卖的讨论

_近业务试水电商，接了一个_的活。之前经常看到淘宝的同行们讨论_，讨论电商，这次终于轮到我们自己理论结合实际一次了。

ps：进入正文前先说一点个人感受，之前看淘宝的ppt感觉都懂了，等到自己出解决方案的时候发现还是有很多想不到的地方其实都没懂，再次验证了“细节是魔鬼”的理论。并且一个人的能力有限，只有大家一起讨论才能想的更周全，更细致。好了，闲话少说，下面进入正文。

一、_带来了什么？

_或_活动一般会经过预约抢订单支付这3个大环节，而其中抢订单这个环节是_考验业务提供方的抗压能力的。

抢订单环节一般会带来2个问题：

1、高并发

比较火热的__人数都是10w起的，如此之高的_人数对于网站架构从前到后都是一种考验。

2、超卖

任何商品都会有数量上限，如何避免成功下订单买到商品的人数不超过商品数量的上限，这是每个_活动都要面临的难题。

二、如何解决？

首先，产品解决方案我们就不予讨论了。我们只讨论技术解决方案

1、前端

面对高并发的_活动，前端常用的三板斧是扩容静态化限流

A：扩容

加机器，这是_简单的方法，通过增加前端池的整体承载量来抗峰值。

B：静态化

将活动页面上的所有可以静态的元素全部静态化，并尽量减少动态元素。通过CDN来抗峰值。

C：限流

一般都会采用IP级别的限流，即针对某一个IP，限制单位时间内发起请求数量。

或者活动入口的时候增加游戏或者问题环节进行消峰操作。

D：有损服务

_后一招，在接近前端池承载能力的水位上限的时候，随机拒绝部分请求来保护活动整体的可用性。

2、后端

那么后端的数据库在高并发和超卖下会遇到什么问题呢？主要会有如下3个问题：（主要讨论写的问题，读的问题通过增加cache可以很容易的解决）

I： 首先MySQL自身对于高并发的处理性能就会出现问题，一般来说，MySQL的处理性能会随着并发thread上升而上升，但是到了一定的并发度之后会出现明显的拐点，之后一路下降，_终甚至会比单thread的性能还要差。

II： 其次，超卖的根结在于减库存操作是一个事务操作，需要先select，然后insert，_后update -1。_后这个-1操作是不能出现负数的，但是当多用户在有库存的情况下并发操作，出现负数这是无法避免的。

III：_后，当减库存和高并发碰到一起的时候，由于操作的库存数目在同一行，就会出现争抢InnoDB行锁的问题，导致出现互相等待甚至死锁，从而大大降低MySQL的处理性能，_终导致前端页面出现超时异常。

针对上述问题，如何解决呢？ 我们先看眼淘宝的高大上解决方案：

I： 关闭死锁检测，提高并发处理性能。

II：修改源代码，将排队提到进入引擎层前，降低引擎层面的并发度。

III：组提交，降低server和引擎的交互次数，降低IO消耗。

以上内容可以参考丁奇在DTCC2013上分享的《_场景下MySQL的低效》一文。在文中所有优化都使用后，TPS在高并发下，从原始的150飙升到8.5w，提升近566倍，非常吓人！！！

不过结合我们的实际，改源码这种高大上的解决方案显然有那么一点不切实际。于是小伙伴们需要讨论出一种适合我们实际情况的解决方案。以下就是我们讨论的解决方案：

首先设定一个前提，为了防止超卖现象，所有减库存操作都需要进行一次减后检查，保证减完不能等于负数。（由于MySQL事务的特性，这种方法只能降低超卖的数量，但是不可能完全避免超卖）

update number set x=x-1 where (x -1 ) >=0;解决方案1：

将存库从MySQL前移到Redis中，所有的写操作放到内存中，由于Redis中不存在锁故不会出现互相等待，并且由于Redis的写性能和读性能都远高于MySQL，这就解决了高并发下的性能问题。然后通过队列等异步手段，将变化的数据异步写入到DB中。

优点：解决性能问题

缺点：没有解决超卖问题，同时由于异步写入DB，存在某一时刻DB和Redis中数据不一致的风险。

解决方案2：

引入队列，然后将所有写DB操作在单队列中排队，完全串行处理。当达到库存阀值的时候就不在消费队列，并关闭购买功能。这就解决了超卖问题。

优点：解决超卖问题，略微提升性能。

缺点：性能受限于队列处理机处理性能和DB的写入性能中_短的那个，另外多商品同时_的时候需要准备多条队列。

解决方案3：

将写操作前移到MC中，同时利用MC的轻量级的锁机制CAS来实现减库存操作。

优点：读写在内存中，操作性能快，引入轻量级锁之后可以保证同一时刻只有一个写入成功，解决减库存问题。

缺点：没有实测，基于CAS的特性不知道高并发下是否会出现大量更新失败？不过加锁之后肯定对并发性能会有影响。

解决方案4：

将提交操作变成两段式，先申请后确认。然后利用Redis的原子自增操作（相比较MySQL的自增来说没有空洞），同时利用Redis的事务特性来发号，保证拿到小于等于库存阀值的号的人都可以成功提交订单。然后数据异步更新到DB中。

优点：解决超卖问题，库存读写都在内存中，故同时解决性能问题。

缺点：由于异步写入DB，可能存在数据不一致。另可能存在少买，也就是如果拿到号的人不真正下订单，可能库存减为0，但是订单数并没有达到库存阀值。

三、总结

1、前端三板斧扩容限流静态化

2、后端两条路内存+排队

四、非技术感想

1、团队的力量是无穷的，各种各样的解决方案（先不谈可行性）都是在小伙伴们七嘴八舌中讨论出来的。我们需要让所有人都发出自己的声音，不要着急去否定。

2、优化需要从整体层面去思考，不要只纠结于自己负责的部分，如果只盯着一个点思考，_后很可能就走进死胡同中了。

3、有很多东西以为读过了就懂了，其实不然。依然还是需要实践，否则别人的知识永远不可能变成自己的。

4、多思考为什么，会发生什么，不要想当然。只有这样才能深入进去，而不是留在表面。

好了，今天关于发号网站源码就到这里了。希望大家对发号网站源码有更深入的了解，同时也希望这个话题发号网站源码的解答可以帮助到大家。