iLeichun

病人情况

今年7月份毕业于某非著名城市某非著名本科院校，专业方向是计算机师范类，但是选择了传说中牛逼叉叉的程序员这个行业，放弃了去初中或者高中的当一枚伟大的人类灵魂工程师（教师）的职业，而且还选择据说门槛最低的PHP语言，去年十月份，南漂于据说是人间天堂的杭州，真正的程序员生涯大概是在快毕业的时候（5月份），喝罢散伙酒，吃完散伙饭，大学四年同学感情的点点滴滴只能存在记忆，现有女友一枚，蜗居于杭。

病症表现

感觉生活每天忙忙碌碌，碌碌无为，时间一天天重复，物价一天天飞涨，自己只能艰难靠自己的工资生活，每当夜晚来临的时候，晚上睡觉前的时候，总感觉生活总是少了些什么，惊慌和忧虑困扰着自己。

病人的一天活动

公司上班时间：8：30--17：30， 午休2.5h，住处到公司大概2.5kM

6：30醒来，在床上赖上30分钟

7：00开始拿起手机，使用uc看了一下cnbeta的新闻

7：30开始起床

7：45左右开始骑自行车上班

8：05到公司 停车 打卡

8：10 到公司 开启电脑 倒杯开水 QQ 博客园 csdn 等等

8：30 公司上班时间

9：00 开启 ecilips dw 等等工具开始工作

11：30 去吃饭

12:00 回到办公室 又是qq 博客园 微博 音乐等等

13：00 开始休息

14：00 醒来 洗洗脸 继续工作

17：30 公司下班时间， 自己习惯性的留下来加班 查看今天遇到的问题所涉及的知识点 解决没有解决的问题

18：00 主任提醒该下班了

19：00开始准备下班走人

19：20开始到家

19：30 开始自己做饭， 等女友回来吃饭， 吃完饭 刷锅洗碗

20：30在优酷上看一集电视剧

21：30洗澡等等

22：00开始准备睡觉休息

22：20进入梦乡

“医生”诊断

1、该病人属于典型的蚁族一类----（非著名高校，典型穷二代，某偏僻农村）

2、该病人的处于校园思想和社会大环境的思想冲撞之中（尤其是刚刚毕业的学生，豪情万丈出校园，结果发现社会与学校是两回事）

3、该病人是典型的80后的焦虑综合症（房价，物价……都在涨，只有工资如蜗牛，女友可能考虑结婚买房，父母想着好不容易培养出来村子里唯一一枚大学生，要儿子有出息……）

4、该病人处于人生迷茫阶段（刚毕业的学生不知道如何定位自己，如何给自己做好人生规划，才会感觉生活忙忙碌碌，随波逐浪，但是内心又豪情万丈，以至于感觉惊慌和困扰不安）

“医生”建议

生活态度

1. 做实事

不要抱怨，不解释。

2. 欲速则不达

不要用小聪明、权宜之计解决问题，有些东西必须勇敢彻底的解决。

3. 对事不对人

就事论事，明智、真诚、虚心地讨论问题，提出创新方案。

4. 排除万难，奋勇前进

勇气往往是克服困难的唯一方法。

生活压力

对物价上涨等，各个方面的压力的态度，推荐一种经典的图：

工作学习

把握开发节奏

控制好时间，养成好习惯，不要加班。加班不是好习惯，个人感觉效率不高。

1、今日事今日毕 要有肯钻研的精神和态度去学习工作

2、懂得丢弃 程序员对于老的套路和技术该丢弃就丢弃，不要因循守旧！

3、跟踪变化 新技术总是层出不穷，对于新技术学习要以解决工作问题为动机，切忌一味的跟风

4、搞好团队关系 一个良好的团队不仅是一种很好的氛围，更重要是对于提高自身和技术交流的一个重要因素。

5、站在用户的角度思考问题 做出来的产品都是给不懂电脑的人看的，不是给你们这些程序员看的，所以不要骂用户白痴，而要反省自己。

6、及时做好个人总结 以及开发文档的整理

7、伟大是熬出来！ 贵在坚持

针对你的生活药方

你个人浪费时间的地方：

1：赖床 和在床上玩手机

2：qq 微博等等社交类网站 因为早上 中午 晚上 睡觉 也就是说一天光顾了四次 可以节约成一次

3：工作的时候没有计划性

针对你一天时间的建议：

1：工作之前写写一下一天的工作计划标签

2：禁止多次在qq等上闲逛

3：不要赖床和在床上玩手机

4：做事情要快速点，勤奋点，因为人一旦懒惰，就很难在勤奋起来了。

使用方法

日日坚持，坚持是一种美德，伟大是熬出来的！

注意事项：

1、忌骄忌躁，需要长期坚持才可有限

2、本药方因人而异，切忌胡乱生搬硬套，使用前请先咨询医生

3、资深愤青就要不要用了

文章来源：PHP淮北

       这里介紹Eclipse的SVN Plugin，叫做Subclipse,官方网站的下载地址在http://subclipse.tigris.org/。

旧版本的MyEclipse可以通过Eclipse的插件自动下载和更新功能来安装，在Eclipse的菜单中选择 Help->Software Updates->Find and Install-> Search for new features to install ->New Remote Site。URL中就输入http://subclipse.tigris.org/update，MyEclipse就会自已安装上了. 

        如果是MyEclipse 8.5 M1需要手动安装，具体方法如下：
在http://subclipse.tigris.org/servlets/ProjectDocumentList?folderID=2240上下载最新的SVN，如site-1.6.10.zip，然后解压后放到X:Program FilesGenuitecMyEclipse 8.5 M1dropins目录下，重启就行了。

        如果是MyEclipse 9需要手动安装，具体方法如下：
在http://subclipse.tigris.org/servlets/ProjectDocumentList?folderID=2240上下载最新的SVN，如site-1.6.17.zip，然后解压后放到X:Program FilesMyEclipseMyEclipse 9dropins目录下，重启就行了。

        安装完成后，打开MyEclipse,window->show view窗口中多了一个SVN文件夹，到此就证明svn插件成功的安装上了。

1.- 所有的程序都写的很烂，除了我的。

说实话，要告诉你一个坏消息，所有的程序都写的很烂，也包括你的。无论你在上面花多少功夫，其他大多数程序员总是会认为你写的代码很烂、他们能写出比你好10倍的程序。

如何纠正： 不要挑剔别人的程序，或许有一天也许你的程序会被人放在聚光灯下挑剔。要保持客观和专业的评论，不要轻易判断。要谦虚，从周围人哪里学习经验，提醒自己不要写出这样的程序。

2.- 这就几秒钟的事，不用走变更流程了。

每个人都想走捷径，捷径充满诱惑。有时候走捷径是必要的，但总的来说，走捷径是危险的，应该避免。走捷径也许会节省你数小时的时间，但如果走错了，就可能会给你带来数月的麻烦。

如何纠正： 遇到需要慎重处理的事情时不要太过自信。让其他人来复查你的所作所为。如果你计划要走捷径，请确保让你的负责人知道这样做的理由以及其中的风险。每次在走捷径时最好都让你的经理来确认实施成功。

3.- 这是个几分钟就能搞定的事。

在我的家乡Barcelona，那里的圣家族大教堂让我非常的自豪，它的举世闻名来自于它的美丽，也来自于它的建筑完工日期的规划(它动工于1882年，目前仍未完工)，但这可能是因为他们没有让一个程序员去估计这个完工时间，否则的话，估计出的完工所需的时间很可能2周。

如何纠正： 从一开始，你就必须严肃的认识到，对于一个有一定规模的软件开发过程来说，进行精确的时间评估是不现实的，我们能做的只是猜测。同样要记住的非常相似一点是，我们通常会发现有很多事情根本不能预见到它们会花去数倍于我们初始估计的时间，我通常的做法是把估计的时间乘上1.5或2。

4.- 唯我独尊。

很多程序员参与的讨论会基本上看起来就像是一场斗鸡，而不像是人类的讨论，这通常会出现在关于设计和架构问题的讨论会上。你基本上很容易看出其中各自都怀有顺我者昌逆我者亡的心态，你基本上可以把大多数的争论者所说的话直接换成咕咕！咕咕嘎！咕咕咕咕咕咕！咕咕嘎！

如何纠正： 把你的自负留在心底。太过自负是所有程序员身上的一个非技术性的最大的一个毛病。凡事要三思而行啊。

5.- 这不是我的错。

在我看来，这另外一个大多数程序员都会有的坏毛病是缺乏责任心。我们总在找借口… 就比如有人会说，如果在正常情况下，这个错误绝对不会出现，但说老实话，这很难让人信服。

如何纠正： 犯了错误不需要去捶胸顿足，也不需要用刨腹自杀来谢罪，要勇于承担。我们应该怀有一种健康的态度，说出这样的话：“呀，抱歉，我现在就去改正这个错误，是我的错”，这是一种很敬业的态度，这能帮助我们树立一个好的声誉，更好的得到你同事的尊重。

6.- 没有激情。

重复的和简单的任务通常不会带来什么动力，但这些事必须要完成，当程序员被要求去完成这些事情时，通常会显得无精打采，没有效率。

如何纠正： 要提高自信。

7.- 不成熟

你根本就没有潜心投入，干到一半就结束了，然后倒头便睡。我发现大多数程序员对“干完”这个词很纠结。请记住，干完意味着：测试过(不仅仅只是单元测试)，文档完整，提交过，合并过…

如何纠正： 这是一个很严重的问题，相对于完全的完成某些功能性问题而言，这些并不是显得很有必要的任务会很庞杂和难处理，通常需要你有纪律性和受过培训。也许，这最简单的能让一个程序员理解他的开发是否真正的完成的两个办法就是：相互复查和演示。

一、 语言比较

PHP是解释执行的服务器脚本语言，首先php有简单容易上手的特点。语法和c语言比较象，所以学过c语言的程序员可以很快的熟悉php的开发。而java需要先学好java的语法和熟悉一些核心的类库，懂得面向对象的程序设计方法。所以java不如php好学。

Java首先要编译成字节码.class文件，然后在java虚拟机上解释执行。Java的Web开发首先最容易想到的就是JSP（现在已经到JSP2.0），原来的java的Web开发都是用servlet来实现的，用servlet来开发需要程序员在java的源文件中嵌入大量的html代码。所以后来就出现了JSP,JSP可以方便的嵌入到html文件当中，其实jsp文件在服务器上执行的时候首先会被应用服务器转换成servlet，然后再编译执行。Jsp可以通过servlet和JavaBean的支持产生强大的功能。JavaBean 是一种可复用的、跨平台的软件组件。使用javabean可以方便的实现java代码和html的分离，能够增强系统的功能和软件的复用性。

Java的Web开发属于SUN公司定义的J2EE其中的规范。而且在J2EE中包括了java的Web开发的所有方面，如：JSP、Servlet、JDBC、JNDI、JAVABEAN、EJB等等。J2EE就特别适合于做大型的企业级的应用。

二、数据库访问比较

Java通过JDBC来访问数据库，通过不同的数据库厂商提供的数据库驱动方便地访问数据库。访问数据库的接口比较统一。

PHP对于不同的数据库采用不同的数据库访问接口，所以数据库访问代码的通用性不强。例如：用Java开发的Web应用从MySQL数据库转到Oracle数据库只需要做很少的修改。而PHP则需要做大量的修改工作。

三、系统设计架构比较

采用Java的Web开发技术，需要使用的是面向对象的系统设计方法，而PHP还是采用面向过程的开发方法。所以用Java进行开发前期需要做大量的系统分析和设计的工作。

四、跨平台性

Java和PHP都有很好的跨平台的特性。几乎都可以在不作任何修改的情况下运行在Linux或者Windows等不同的操作系统上。

五、 开发成本比较

PHP最经典的组合就是：PHP + MySQL + Apache。非常适合开发中小型的Web应用，开发的速度比较快。而且所有的软件都是开源免费的，可以减少投入。

Java的Web应用服务器有免费Tomcat、JBoss等，如果需要更好的商业化的服务有：Web Sphere和 Web logic。

六、分布式多层架构比较

PHP只能实现简单的分布式两层或三层的架构，而JAVA在这方面就比较强大，可以实现多层的网络架构。数据库层（持久化层）、应用（业务）逻辑层、表示逻辑层彼此分开，而且现在不同的层都已经有一些成熟的开发框架的支持。例如Struts就是利用java的Web开发技术实现了MVC的设计模式，而在业务逻辑层也有Spring框架，数据库持久化层有Hibernate等框架。这些框架可以方便开发者高效、合理、科学得架构多层的商业应用。

下面简要的说一下Struts，它实质上是在JSP Model2的基础上实现的一个MVC（Model、View、Controler）框架。JSP Model2体系结构是一种联合使用JSP 与Servlet 来提供动态内容的方法。在Struts框架中，模型由实现业务逻辑的JavaBean或EJB组件构成，控制器由Servlet实现的，视图由一组JSP文件组成。采用Struts可以明确角色的定义和开发者与网页设计者的分工。而且项目越复杂，其优势越明显。

七、源代码安全

PHP开发的程序的源代码都是公开的，他人拿到php开发的程序后都可以进行修改。

Java开发的程序，最后用户拿到的是只是一些编译好的class类，无法看到完整的源代码，安全性高。

八、性能比较

有人做过试验，对这两种种语言分别做回圈性能测试及存取Oracle数据库测试。在循环性能测试中，JSP只用了令人吃惊的四秒钟就结束了20000＊20000的回圈。而PHP测试的是2000＊2000循环（少一个数量级），却分别用了63秒。数据库测试中，二者分别对 Oracle 8 进行 1000 次 Insert,Update,Select和Delete： JSP 需要 13 秒，PHP 需要 69 秒。　

项目 PHP JAVA 
可复用性 低 高 
开发速度 快 慢 
易维护性 差 优 
可移植性 优－Linux Windows、Unix 
安全性 低 高 
开发费用 低 高 
多层架构 差 优 
数据库访问 接口不统一 接口统一 
可扩展性 差 优 
面向对象 差 优

综上所述，PHP适合于快速开发，中小型应用系统，开发成本低，能够对变动的需求作出快速的反应。而Java适合于开发大型的应用系统，应用的前景比较广阔，系统易维护、可复用性较好。还有，同样功能的系统用Java开发的系统要比PHP开发的系统的价格要高。

VBS控制Excel的一些常见方法：
(一) 使用动态创建的方法
首先创建 Excel 对象，使用ComObj:
oExcel = CreateObject( “Excel.Application” )
1) 显示当前窗口：
oExcel.Visible = True
2) 更改 Excel 标题栏：
oExcel.Caption = “应用程序调用 Microsoft Excel”
3) 添加新工作簿：
oExcel.WorkBooks.Add
4) 打开已存在的工作簿：
oExcel.WorkBooks.Open( “C:ExcelDemo.xls” )
5) 设置第2个工作表为活动工作表：
oExcel.WorkSheets(2).Activate
或
oExcel.WorksSheets( “Sheet2″ ).Activate
6) 给单元格赋值：
oExcel.Cells(1,4).Value = “第一行第四列”
7) 设置指定列的宽度（单位：字符个数），以第一列为例：
oExcel.ActiveSheet.Columns(1).ColumnsWidth = 5
8)设置指定行的高度（单位：磅）（1磅＝0.035厘米），以第二行为例：
oExcel.ActiveSheet.Rows(2).RowHeight = 1/0.035 ‘ 1厘米
9) 在第8行之前插入分页符：
oExcel.WorkSheets(1).Rows(8).PageBreak = 1
10) 在第8列之前删除分页符：
oExcel.ActiveSheet.Columns(4).PageBreak = 0
11) 指定边框线宽度：
oExcel.ActiveSheet.Range( “B3:D4″ ).Borders(2).Weight = 3
1-左 2-右 3-顶 4-底 5-斜( ) 6-斜( / )
12) 清除第一行第四列单元格公式：
oExcel.ActiveSheet.Cells(1,4).ClearContents
13) 设置第一行字体属性：
oExcel.ActiveSheet.Rows(1).Font.Name = “隶书”
oExcel.ActiveSheet.Rows(1).Font.Color = clBlue
oExcel.ActiveSheet.Rows(1).Font.Bold = True
oExcel.ActiveSheet.Rows(1).Font.UnderLine = True
14) 进行页面设置：
a.页眉：
oExcel.ActiveSheet.PageSetup.CenterHeader = “报表演示”
b.页脚：
oExcel.ActiveSheet.PageSetup.CenterFooter = “第&P页”
c.页眉到顶端边距2cm：
oExcel.ActiveSheet.PageSetup.HeaderMargin = 2/0.035
d.页脚到底端边距3cm：
oExcel.ActiveSheet.PageSetup.HeaderMargin = 3/0.035
e.顶边距2cm：
oExcel.ActiveSheet.PageSetup.TopMargin = 2/0.035
f.底边距2cm：
oExcel.ActiveSheet.PageSetup.BottomMargin = 2/0.035
g.左边距2cm：
oExcel.ActiveSheet.PageSetup.LeftMargin = 2/0.035
h.右边距2cm：
oExcel.ActiveSheet.PageSetup.RightMargin = 2/0.035
i.页面水平居中：
oExcel.ActiveSheet.PageSetup.CenterHorizontally = 2/0.035
j.页面垂直居中：
oExcel.ActiveSheet.PageSetup.CenterVertically = 2/0.035
k.打印单元格网线：
oExcel.ActiveSheet.PageSetup.PrintGridLines = True
15) 拷贝操作：
a.拷贝整个工作表：
oExcel.ActiveSheet.Used.Range.Copy
b.拷贝指定区域：
oExcel.ActiveSheet.Range( “A1:E2″ ).Copy
c.从A1位置开始粘贴：
oExcel.ActiveSheet.Range.( “A1″ ).PasteSpecial
d.从文件尾部开始粘贴：
oExcel.ActiveSheet.Range.PasteSpecial
16) 插入一行或一列：
a. oExcel.ActiveSheet.Rows(2).Insert
b. oExcel.ActiveSheet.Columns(1).Insert
17) 删除一行或一列：
a. oExcel.ActiveSheet.Rows(2).Delete
b. oExcel.ActiveSheet.Columns(1).Delete
18) 打印预览工作表：
oExcel.ActiveSheet.PrintPreview
19) 打印输出工作表：
oExcel.ActiveSheet.PrintOut
20) 工作表保存：
if not oExcel.ActiveWorkBook.Saved then
oExcel.ActiveSheet.PrintPreview
21) 工作表另存为：
oExcel.SaveAs( “C:ExcelDemo1.xls” )
22) 放弃存盘：
oExcel.ActiveWorkBook.Saved = True
23) 关闭工作簿：
oExcel.WorkBooks.Close
24) 退出 Excel：
oExcel.Quit
(二) 使用VBS 控制Excle二维图
1）选择当第一个工作薄第一个工作表
set oSheet=oExcel.Workbooks(1).Worksheets(1)
2）增加一个二维图
achart=oSheet.chartobjects.add(100,100,200,200)
3）选择二维图的形态
achart.chart.charttype=4
4）给二维图赋值
set series=achart.chart.seriescollection
range=”sheet1!r2c3:r3c9″
series.add range,true
5）加上二维图的标题
achart.Chart.HasTitle=True
achart.Chart.ChartTitle.Characters.Text=” Excle二维图”
6）改变二维图的标题字体大小
achart.Chart.ChartTitle.Font.size=18
7）给二维图加下标说明
achart.Chart.Axes(xlCategory, xlPrimary).HasTitle = True
achart.Chart.Axes(xlCategory, xlPrimary).AxisTitle.Characters.Text = “下标说明”
8）给二维图加左标说明
achart.Chart.Axes(xlValue, xlPrimary).HasTitle = True
achart.Chart.Axes(xlValue, xlPrimary).AxisTitle.Characters.Text = “左标说明”
9）给二维图加右标说明
achart.Chart.Axes(xlValue, xlSecondary).HasTitle = True
achart.Chart.Axes(xlValue, xlSecondary).AxisTitle.Characters.Text = “右标说明”
10）改变二维图的显示区大小
achart.Chart.PlotArea.Left = 5
achart.Chart.PlotArea.Width = 223
achart.Chart.PlotArea.Height = 108

1．什么是面向对象技术？ 面向对象技术是一种以对象为基础，以事件或消息来驱动对象执行处理的程序设计技术。它具有抽象性、封装性、继承性及多态性。
2．面向对象与面向过程程序设计有什么不同? 面向对象与面向过程程序设计有如下不同： 
（1）面向过程程序设计方法采用函数（或过程）来描述对数据的操作，但又将函数与其操作的数据分离开来；面向对象程序设计方法将数据和对数据的操作封装在一起，作为一个整体来处理。 函数与数据是否分离 
（2）面向过程程序设计方法以功能为中心来设计功能模块，难于维护；而面向对象程序设计方法以数据为中心来描述系统，数据相对于功能而言具有较强的稳定性，因此更易于维护。 以功能为中心;以数据为中心 
（3）面向过程程序的控制流程由程序中预定顺序来决定；面向对象程序的控制流程由运行时各种事件的实际发生来触发，而不再由预定顺序来决定，更符合实际需要。 预定顺序;由运行时各种事件的实际发生来触发 
（4）面向对象程序设计方法可以利用框架产品（如MFC，Microsoft Foundation Classes）进行编程。 面向对象可利用框架 [color=#CC0000,strength=3);]面向对象和面向过程的根本差别，在于封装之后，面向对象提供了面向过程不具备的各种特性，最主要的，就是继承和多态。 3．面向对象技术有哪些优点? 面向对象技术具有程序结构清晰，自动生成程序框架，实现简单，可有效地减少程序的维护工作量，代码重用率高，软件开发效率高等优点。 4．面向对象技术中的封装性有何优缺点？如何克服这些缺点? 封装将对象有关的数据和行为封装成整体来处理，使得对象以外的部分不能随意存取对象的内部属性，从而有效地避免了外部错误对它的影响，大大减小了查错和排错的难度。另一方面，当进行修改对象内部时，由于只有少量的外部接口对外提供服务，因此同样减小了内部的修改对外部的影响。 如果一味地强调封装，对象的任何属性都不允许外部直接存取，则要增加许多没有其他意义、只负责读或写的行为。这会为编程工作增加负担，增加运行开销，并且使程序显得臃肿。为了避免这一点，在程序的具体实现过程中应使对象有不同程度的可见性，进而与客观世界的具体情况相符合。 
5．为什么要应用继承机制? 客观事物既有共性，也有特性。如果只考虑事物的共性，而不考虑事物的特性，就不能反映出客观世界中事物之间的层次关系。抽象机制是考虑事物的共性，继承机制是考虑事物的特性，这样才能完整地描述客观世界的层次关系。继承能使软件模块具有可重用性、独立性，缩短软件开发周期，提高软件开发效率，同时使软件易于维护。
6．C++对多态性的支持体现在哪些方面? C++的多态性分为编译时多态和运行时多态。编译时多态是指在程序的编译阶段由编译系统根据参数确定与哪个同名的函数相联系；运行时多态是指在程序的运行阶段才根据产生的信息确定需要调用哪个同名的函数。C++通过函数重载和运算符重载实现编译时多态，通过继承和虚函数来实现运行时多态。
7．目前常用的面向对象程序设计语言有何异同? 目前常用的面向对象程序设计语言有C++、Java、Visual Basic等。C++是混合型面向对象程序设计语言，继承并改进了C语言，是一种既支持面向对象又支持面向过程的程序设计方法。Java是纯面向对象程序设计语言，从C++发展而来。C++和Java均支持面向对象技术的基本概念和基本特征，如封装、类、构造函数、析构函数、继承、多态等。 C++与Java语法描述有相同之处，也有不同之处。如基本结构语句的语法大致相同，而类定义的语法等方面则不相同。此外还有以下不同： 
（1）C++有运算符重载机制，而Java没有此特性；
（2）C++支持多重继承，而Java只支持单重继承；
（3）C++通过构造函数创建对象，可以直接使用指针来操作对象的成员，而Java通过new运算符创建对象，通过new运算符返回的对象引用来使用对象，而不是直接操作指针； 
（4）C++程序要显式地释放所分配的内存，而Java具有内存垃圾收集机制，自动管理内存，不需要显式释放所分配的内存。 Visual Basic继承了BASIC语言所具有的语法简单、容易学习、容易使用、数据处理能力强的特点，又引入了面向对象、事件驱动的编程机制和可视化程序设计方法，大大降低了开发Windows应用程序的难度，有效地提高了应用程序开发的效率。但是，Visual Basic存在语法不严格、开发出的系统稳定性较低的缺点。相对C++来说，Visual Basic面向系统底层的编程能力有限。
8．什么是.NET? .NET是一种面向网络、支持各种用户终端的开发平台。它定义了一种公用语言子集（Common Language Subset，CLS），为符合其规范的语言与类库之间提供无缝集成的混合语言。.NET统一了编程类库，提供了对下一代网络通信标准——可扩展标记语言（eXtensible Markup Language，XML）的完全支持，使应用程序的开发变得更容易、更简单。所以?.NET就是Microsoft的XML Web服务平台，不论操作系统或编程语言有何差别，XML Web服务均能使应用程序在Internet上传输和共享数据。

MVC介绍

　　MVC其实是模、视图、控制的缩写，也就是说在使用jsp时，有相应的文件去实现相应的操作
通常jsp只负责view也就是只负责显示页面。业务逻辑等有bean(ejb)去实现。下面讨论的是不使用ejb的情况下实现。如果使用ejb,ejb负责M.C通常会由servlet去实现。
设计思路

　　当你构建一个Application时。你必须考虑界面的问题，而界面修改是非常平常的。如果你在jsp中实现所有的操作，一旦修改界面你麻烦大了。美工不懂jsp的，你必须自己去修改无数个文件，头不要太大，而此时一般时间都很紧，使用MVC则可以减少你的一些麻烦。在设计时候jsp只负责显示页面，也就是说jsp调用Bean(Struts,servlet)传过来的数据然后显示而Bean(Struts,servlet)负责收集jsp需要的数据，用ArrayList(Arttibute)传给jsp。假如需要提交表单，一般也直接提交给Struts,servlet,处理后以后再返回处理信息。而其中相应的业务逻辑由Bean去实现。
Bean的设计

　　在我使用时候Bean通常有三类，分别在manager,entry,database目录下面。

　　　manager下面的bean做商业逻辑

　　　entry下的bean就是封装数据，其实就是每个数据库表对应会有一个bean。jsp得到的也全部是类。

　　　database下的bean就是操作数据库，执行如insert,update,delete,load(查询一条记录),batchload(查询多条记录)。
他们之间的关系是entry负责封装数据，作为database的调用参数，返回结果。

using System;
using System.Collections.Generic;
// using System.Linq;
using System.Text;
using System.IO;
using System.IO.Compression;
using System.Xml;
using System.Web;
using System.Collections;
using System.Runtime.InteropServices;
using System.Net;
using System.Net.Security;
using System.Security.Authentication;
using System.Security.Cryptography.X509Certificates;

namespace Common
{
    /// <summary>
    /// 准备POST
    /// </summary>
    /// <param name="httpRequest"></param>
    public delegate void OnGetPostReady(HttpWebRequest httpRequest);

    /// <summary>
    /// 准备取回应
    /// </summary>
    /// <param name="httpRequest"></param>
    public delegate void OnGetResponseReady(HttpWebRequest httpRequest);

    public class HttpWebHelper
    {
        protected HttpWebRequest httpRequest;
        protected HttpWebResponse httpResponse;
        protected CookieContainer cookieContainer;
        protected CredentialCache credentialCache;
        protected bool certificatedMode = false;
        protected string certFilepath = string.Empty;
        public OnGetPostReady OnGetPostReadyHandler = null;
        public OnGetPostReady OnGetResponseReadyHandler = null;
        protected readonly int DEFAULT_BUFFER_SIZE = 4096;
        public WebProxy webProxySrv = null;
        private static readonly int MyConnectionLimit = 300;

        public bool CheckGotoRecv
        {
            get;
            set;
        }

        public bool DoBetIsGotoRecv
        {
            get;
            set;
        }

        public bool LastAccessError
        {
            private set;
            get;
        }

        /// <summary>
        /// 当前自动转向后的url
        /// </summary>
        public string CurrentUrl
        {
            private set;
            get;
        }

        public string CurrentLocation
        {
            private set;
            get;
        }

        public string CurSetCookie
        {
            set;
            get;
        }

        public string CurSetCookie2
        {
            set;
            get;
        }

        /// <summary>
        /// 默认构造器
        /// </summary>
        public HttpWebHelper()
        {
            this.cookieContainer = new CookieContainer();
            ServicePointManager.DefaultConnectionLimit = MyConnectionLimit;
            ServicePointManager.Expect100Continue = false;
            ServicePointManager.MaxServicePointIdleTime = 10000;
        }

        /// <summary>
        /// 代理參數構造器
        /// </summary>
        /// <param name="wp"></param>
        public HttpWebHelper(WebProxy wp) : this()
        {
            this.webProxySrv = wp;
        }
       
        /// <summary>
        /// 需要基本认证的构造器
        /// </summary>
        /// <param name="cred"></param>
        public HttpWebHelper(bool cred)
            : this()
        {
            this.certificatedMode = cred;
        }

        public HttpWebHelper(bool cred, WebProxy wp)
            : this()
        {
            this.certificatedMode = cred;
            this.webProxySrv = wp;
        }

        /// <summary>
        /// 基本认证和证书,refer页面
        /// </summary>
        /// <param name="cred"></param>
        /// <param name="certFilepath"></param>
        public HttpWebHelper(bool cred, string certFilepath)
            : this(cred)
        {
            this.certFilepath = certFilepath;
        }

        public HttpWebHelper(bool cred, WebProxy wp, string certFilepath)
            : this(cred, wp)
        {
            this.certFilepath = certFilepath;
        }

        /// <summary>
        /// 提供批量用户名和密码的构造器
        /// </summary>
        /// <param name="uri"></param>
        /// <param name="method"></param>
        /// <param name="username"></param>
        /// <param name="password"></param>
        public HttpWebHelper(string uri, string method, string username, string password)
            : this(true)
        {
            this.credentialCache = new CredentialCache();
            this.credentialCache.Add(new Uri(uri), method, new NetworkCredential(username, password));
        }

        /// <summary>
        /// 安全询问回调函数,直接同意
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="certificate"></param>
        /// <param name="chain"></param>
        /// <param name="errors"></param>
        /// <returns></returns>
        public bool CheckValidationResult(object sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors errors)
        {
            return true;
        }

        private void SetHttpRequestOptions_Accept(string url, string method, CookieCollection cc, string referUrl, bool nocache, DecompressionMethods dm, string httpAccept)
        {
            this.SetHttpRequestOptions(url, method, cc, referUrl, nocache, dm);
            this.httpRequest.Accept = httpAccept;
        }

        /// <summary>
        /// 设置HttpWebRequest对象
        /// </summary>
        /// <param name="url"></param>
        /// <param name="method"></param>
        /// <param name="cc"></param>
        /// <param name="referUrl"></param>
        /// <param name="nocache"></param>
        /// <param name="dm"></param>
        private void SetHttpRequestOptions(string url, string method, CookieCollection cc, string referUrl, bool nocache, DecompressionMethods dm)
        {
            httpRequest = (HttpWebRequest)HttpWebRequest.Create(url);
            httpRequest.UnsafeAuthenticatedConnectionSharing = true;
            httpRequest.ServicePoint.ConnectionLimit = MyConnectionLimit;

            if (null != this.webProxySrv) httpRequest.Proxy = this.webProxySrv;

            if (this.certificatedMode && url.ToLower().Substring(0, 5).Equals("https"))
            {
                ServicePointManager.ServerCertificateValidationCallback = new System.Net.Security.RemoteCertificateValidationCallback(CheckValidationResult);

                if (null == this.credentialCache)
                    httpRequest.UseDefaultCredentials = true;
                else
                    httpRequest.Credentials = this.credentialCache;

                if (!string.IsNullOrEmpty(this.certFilepath))
                    httpRequest.ClientCertificates.Add(X509Certificate.CreateFromCertFile(this.certFilepath));
            }

            httpRequest.CookieContainer = this.cookieContainer;
            if (!string.IsNullOrEmpty(referUrl)) httpRequest.Referer = referUrl;
            httpRequest.AutomaticDecompression = dm;
            httpRequest.ServicePoint.Expect100Continue = false;
            httpRequest.ServicePoint.UseNagleAlgorithm = false;
            httpRequest.ContentType = "application/x-www-form-urlencoded";
            // httpRequest.Accept = "image/gif, image/x-xbitmap, image/jpeg, image/pjpeg, application/x-shockwave-flash, */*";
            // httpRequest.AllowWriteStreamBuffering = true; 默认值就是true
            // httpRequest.AllowAutoRedirect = true; 默认值就是true
            httpRequest.Method = method;
            httpRequest.Timeout = ApplicationConfig.HTTP_REQUEST_TIMEOUT;
            // 讀寫超時
            //httpRequest.ReadWriteTimeout = ApplicationConfig.HTTP_REQUEST_TIMEOUT;
            // httpRequest.MaximumAutomaticRedirections = 50; 默认值就是50
            httpRequest.UserAgent = "Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.2; .NET CLR 1.1.4322; .NET CLR 2.0.50727)";
            httpRequest.Headers.Add("Accept-Language", "zh-cn");
            httpRequest.Headers.Add("UA-CPU", "x86");
            //httpRequest.Headers.Add("Accept-Encoding", "gzip, deflate");           

            if (nocache)
            {
                httpRequest.Headers.Add("Cache-Control", "no-cache");
                //httpRequest.Headers.Add("Pragma", "no-cache");
            }

            if (null != cc) httpRequest.CookieContainer.Add(cc);

            // 回调发起请求前事件
            if(null != this.OnGetPostReadyHandler)
            {
                try
                {
                    this.OnGetPostReadyHandler(this.httpRequest);
                    //BaseDebug.DebugPrint("KeepAlive = " + this.httpRequest.KeepAlive.ToString());
                }
                catch (System.Exception ex)
                {
                    this.LastAccessError = true;
                    BaseDebug.DebugPrint(ex.ToString());
                }
            }
        }

        private void SetHttpRequestOptions(string url, string method, CookieCollection cc, string referUrl, string httpAccept)
        {
            this.SetHttpRequestOptions_Accept(url, method, cc, referUrl, false, DecompressionMethods.GZip | DecompressionMethods.Deflate, httpAccept);
        }

        /// <summary>
        /// 重新设置某些成员
        /// </summary>
        private void ManualResetMember()
        {
            this.cookieContainer = httpRequest.CookieContainer;
            this.CurrentUrl = httpRequest.Address.OriginalString;
            this.CurrentLocation = httpResponse.Headers["Location"];
        }

        public MemoryStream GetMemoryStream(string url, string method, CookieCollection cc, string referUrl, string httpAccept)
        {
            MemoryStream ms = new MemoryStream();

            try
            {
                this.SetHttpRequestOptions(url, method, cc, referUrl, "*/*");
                this.httpRequest.Accept = httpAccept;
                this.httpResponse = (HttpWebResponse)httpRequest.GetResponse();
                // 是否收到响应
                if (!this.httpRequest.HaveResponse)
                {
                    this.httpResponse.Close();
                    this.httpRequest.Abort();
                    return ms;
                }

                this.ManualResetMember();

                if (null != this.OnGetResponseReadyHandler)
                {
                    try
                    {
                        this.OnGetResponseReadyHandler(this.httpRequest);
                    }
                    catch (System.Exception ex)
                    {
                        this.LastAccessError = true;
                        BaseDebug.DebugPrint(ex.ToString());
                    }
                }

                this.DoBetIsGotoRecv = true;

                Stream sm = httpResponse.GetResponseStream();
                if (null != sm && sm.CanRead)
                {
                    //int readBytes = 0;
                    //byte[] buffer = new byte[DEFAULT_BUFFER_SIZE];
                    //while ((readBytes = sm.Read(buffer, 0, buffer.Length)) != 0)
                    //{
                    //    ms.Write(buffer, 0, readBytes);
                    //}

                    BinaryReader br = new BinaryReader(sm);
                    byte[] bytes = br.ReadBytes(DEFAULT_BUFFER_SIZE);
                    while (null != bytes && bytes.Length != 0)
                    {
                        ms.Write(bytes, 0, bytes.Length);
                        bytes = br.ReadBytes(DEFAULT_BUFFER_SIZE);
                    }
                    br.Close();
                }

                if (httpResponse.Headers["Set-Cookie"] != null)
                    this.CurSetCookie = httpResponse.Headers["Set-Cookie"].ToString();

                httpResponse.Close();
                if (null != sm) sm.Close();

                // 非常重要,回到开头
                ms.Seek(0, SeekOrigin.Begin);
            }
            catch (System.Exception ex)
            {
                this.LastAccessError = true;
                BaseDebug.DebugPrint("異常網址:" + url);
                BaseDebug.DebugPrint(ex.ToString());
                if (null != httpRequest) httpRequest.Abort();
            }

            return ms;
        }

        public MemoryStream SimpleGetMemoryStream(string url, string method)
        {
            return this.GetMemoryStream(url, method, null, null, "text/html");
        }

        public MemoryStream SimpleGetMemoryStream(string url, string method, string httpAccept)
        {
            return this.GetMemoryStream(url, method, null, null, httpAccept);
        }

        /// <summary>
        /// 仅仅发送请求,返回所有的输出文本
        /// </summary>
        /// <param name="url"></param>
        /// <param name="method"></param>
        /// <param name="coding"></param>
        /// <param name="cc"></param>
        /// <param name="referUrl"></param>
        /// <returns></returns>
        public string SimpleDoPostWrapper(string url, string method, Encoding coding, CookieCollection cc, string referUrl)
        {
            string str = string.Empty;
            StreamReader sr = null;
            MemoryStream sm = null;

            if (null == coding)
            {
                sm = this.GetMemoryStream(url, method, cc, referUrl, "text/html");
                sr = new StreamReader(sm);
            }
            else
            {
                sm = this.GetMemoryStream(url, method, cc, referUrl, "text/html");
                sr = new StreamReader(sm, coding);
            }
            str = sr.ReadToEnd();
            sr.Close();
            sm.Close();
            return str;
        }

        public string SimpleDoPostWrapper(string url, string method)
        {
            return this.SimpleDoPostWrapper(url, method, null, null, null);
        }

        public string SimpleDoPostWrapper(string url, string method, CookieCollection cc)
        {
            return this.SimpleDoPostWrapper(url, method, null, cc, null);
        }

        public string SimpleDoPostWrapper(string url, string method, string referUrl)
        {
            return this.SimpleDoPostWrapper(url, method, null, null, referUrl);
        }

        /// <summary>
        /// 上送数据,返回输出流
        /// </summary>
        /// <param name="url"></param>
        /// <param name="data"></param>
        /// <param name="method"></param>
        /// <param name="coding"></param>
        /// <param name="cc"></param>
        /// <param name="referUrl"></param>
        /// <returns></returns>
        public MemoryStream GetMemoryStream(string url, string data, string method, Encoding coding, CookieCollection cc, string referUrl)
        {
            MemoryStream ms = new MemoryStream();

            try
            {
                this.SetHttpRequestOptions(url, method, cc, referUrl, "text/html");
                byte[] bytesData = coding.GetBytes(data);
                Stream requestStream = httpRequest.GetRequestStream();
                requestStream.Write(bytesData, 0, bytesData.Length);
                requestStream.Flush();
                requestStream.Close();
               
                this.httpResponse = (HttpWebResponse)httpRequest.GetResponse();

                // 是否收到响应
                if (!this.httpRequest.HaveResponse)
                {
                    this.httpResponse.Close();
                    this.httpRequest.Abort();
                    return ms;
                }

                this.ManualResetMember();

                if (null != this.OnGetResponseReadyHandler)
                {
                    try
                    {
                        this.OnGetResponseReadyHandler(this.httpRequest);
                    }
                    catch (System.Exception ex)
                    {
                        this.LastAccessError = true;
                        BaseDebug.DebugPrint(ex.ToString());
                    }
                }

                this.DoBetIsGotoRecv = true;

                Stream sm = httpResponse.GetResponseStream();
                if (null != sm && sm.CanRead)
                {
                    //int readBytes = 0;
                    //byte[] buffer = new byte[DEFAULT_BUFFER_SIZE];
                   
                    //while ((readBytes = sm.Read(buffer, 0, buffer.Length)) != 0)
                    //{
                    //    ms.Write(buffer, 0, readBytes);
                    //}

                    BinaryReader br = new BinaryReader(sm);
                    byte[] bytes = br.ReadBytes(DEFAULT_BUFFER_SIZE);
                    while (null != bytes && bytes.Length != 0)
                    {
                        ms.Write(bytes, 0, bytes.Length);
                        bytes = br.ReadBytes(DEFAULT_BUFFER_SIZE);
                    }
                    br.Close();
                }

                if (httpResponse.Headers["Set-Cookie"] != null)
                    this.CurSetCookie = httpResponse.Headers["Set-Cookie"].ToString();

                httpResponse.Close();
                if (null != sm) sm.Close();

                // 非常重要,回到开头
                ms.Seek(0, SeekOrigin.Begin);
            }
            catch (System.Exception ex)
            {
                this.LastAccessError = true;
                BaseDebug.DebugPrint("異常網址:" + url);
                BaseDebug.DebugPrint(ex.ToString());
                if (null != httpRequest) httpRequest.Abort();
            }
           
            return ms;
        }

        public MemoryStream SimpleGetMemoryStream(string url, string data, string method, Encoding coding)
        {
            return this.GetMemoryStream(url, data, method, coding, null, null);
        }

        public MemoryStream SimpleGetMemoryStream(string url, string data, string method, Encoding coding, string referUrl)
        {
            return this.GetMemoryStream(url, data, method, coding, null, referUrl);
        }

        /// <summary>
        /// 上送,返回所有的输出文本
        /// </summary>
        /// <param name="url"></param>
        /// <param name="data"></param>
        /// <param name="method"></param>
        /// <param name="coding"></param>
        /// <param name="referUrl"></param>
        /// <returns></returns>
        public string DoPostWrapper(string url, string data, string method, Encoding coding, CookieCollection cc, string referUrl)
        {
            string str = string.Empty;
            MemoryStream sm = this.GetMemoryStream(url, data, method, coding, cc, referUrl);
            StreamReader sr = new StreamReader(sm);
            str = sr.ReadToEnd();
            sr.Close();
            sm.Close();
            return str;
        }

        public string DoPostWrapper(string url, string data, string method, Encoding coding)
        {
            return this.DoPostWrapper(url, data, method, coding, null, null);
        }

        public string DoPostWrapper(string url, string data, string method, Encoding coding, CookieCollection cc)
        {
            return this.DoPostWrapper(url, data, method, coding, cc, null);
        }

        public string DoPostWrapper(string url, string data, string method, Encoding coding, string referUrl)
        {
            return this.DoPostWrapper(url, data, method, coding, null, referUrl);
        }

        /// <summary>
        /// 上送,返回所有的输出文本,参数是字典
        /// </summary>
        /// <param name="url"></param>
        /// <param name="dicArguments"></param>
        /// <param name="method"></param>
        /// <param name="coding"></param>
        /// <param name="referUrl"></param>
        /// <returns></returns>
        public string DoPostWrapper(string url, Dictionary<string, string> dicArguments, string method, Encoding coding, CookieCollection cc, string referUrl)
        {
            string data = this.BuildRequestArguments(dicArguments);
            return this.DoPostWrapper(url, data, method, coding, cc, referUrl);
        }

        public string DoPostWrapper(string url, Dictionary<string, string> dicArguments, string method, Encoding coding)
        {
            return this.DoPostWrapper(url, dicArguments, method, coding, null, null);
        }

        public string DoPostWrapper(string url, Dictionary<string, string> dicArguments, string method, Encoding coding, CookieCollection cc)
        {
            return this.DoPostWrapper(url, dicArguments, method, coding, cc, null);
        }

        public string DoPostWrapper(string url, Dictionary<string, string> dicArguments, string method, Encoding coding, string referUrl)
        {
            return this.DoPostWrapper(url, dicArguments, method, coding, null, referUrl);
        }

        /// <summary>
        /// 下载验证码,只返回内存流,调用函数要负责关闭该Stream
        /// </summary>
        /// <param name="url"></param>
        /// <param name="method"></param>
        /// <returns></returns>
        public MemoryStream DownloadStream(string url, string method)
        {
            return this.SimpleGetMemoryStream(url, method, "*/*");
        }

        /// <summary>
        /// 从字典中生成上传参数.提供编码定制支持
        /// </summary>
        /// <param name="dicArguments"></param>
        /// <param name="coding"></param>
        /// <returns></returns>
        public string BuildRequestArguments(Dictionary<string, string> dicArguments, Encoding coding)
        {
            StringBuilder sb = new StringBuilder();
            string str = string.Empty;
            if (0 == dicArguments.Count) return str;
            foreach (KeyValuePair<string, string> kvp in dicArguments)
            {
                if(null != coding)
                    sb.Append(HttpUtility.UrlEncode(kvp.Key, coding) + "=" + HttpUtility.UrlEncode(kvp.Value, coding));
                else
                    sb.Append(HttpUtility.UrlEncode(kvp.Key) + "=" + HttpUtility.UrlEncode(kvp.Value));
                // a&b
                sb.Append("&");
            }
            str = sb.ToString();
            return str.Substring(0, str.Length - 1);
        }

        /// <summary>
        /// 从字典中生成上传的默认参数,不提供编码定制支持
        /// </summary>
        /// <param name="dicArguments"></param>
        /// <returns></returns>
        public string BuildRequestArguments(Dictionary<string, string> dicArguments)
        {
            return this.BuildRequestArguments(dicArguments, null);
        }

        /// <summary>
        /// 查询cookie中的某个项的值
        /// </summary>
        /// <param name="key"></param>
        /// <param name="domain"></param>
        /// <returns></returns>
        public string GetCookieValue(string key, string domain)
        {
            if (0 == this.cookieContainer.Count)
            {
                return string.Empty;
            }

            CookieCollection cc = this.cookieContainer.GetCookies(new Uri(domain));
            return cc[key].Value;
        }

        /// <summary>
        /// 设置cookies容器
        /// </summary>
        /// <param name="cc"></param>
        public void SetCookieContainer(CookieContainer cc)
        {
            this.cookieContainer = cc;
        }

        /// <summary>
        /// 放棄請求
        /// </summary>
        public bool AbortHttpRequest()
        {
            if(null != this.httpRequest)
            {
                this.httpRequest.Abort();
            }

            return this.CheckGotoRecv && this.DoBetIsGotoRecv;
        }
    }
}

GBK的文字编码是双字节来表示的，即不论中、英文字符均使用双字节来表示，只不过为区分中文，将其最高位都定成1。
至于UTF－8编码则是用以解决国际上字符的一种多字节编码，它对英文使用8位（即一个字节），中文使用24位（三个字节）来编码。对于英文字符较多的论坛则用UTF－8节省空间。
GBK包含全部中文字符，
UTF-8则包含全世界所有国家需要用到的字符。
GBK是在国家标准GB2312基础上扩容后兼容GB2312的标准（好像还不是国家标准）
UTF-8编码的文字可以在各国各种支持UTF8字符集的浏览器上显示。
比如，如果是UTF8编码，则在外国人的英文IE上也能显示中文，而无需他们下载IE的中文语言支持包。
所以，对于英文比较多的论坛 ，使用GBK则每个字符占用2个字节，而使用UTF－8英文却只占一个字节。