开发笔记 第638页

[转载]12个有趣的HTML5实例 – Alexis – 博客园.

[转载]小泥鳅解剖系列之模板机制 – 小泥鳅博客技术交流区 – 博客园.

[转载]C# 用Linq的方式实现对Xml文件的基本操作（创建xml文件、增删改查xml文件节点信息） – Eric Sun – 博客园.

我的上一篇文章描述了用普通方法实现对xml文件的基本操作，感谢各位园友给我提的每一个建议，大家主要在说：用Linq去实现对xml的操作 更加方便简洁，于是乎我就现学习了一下Linq to xml，由于是刚刚接触Linq，理解肯定不会很深，所以请各位园友不吝赐教，有建议尽管说，在此先谢过大家啦~

LINQ to XML 为创建 XML 元素提供了一种称为“函数构造”的有效方式。函数构造是指在单个语句中创建 XML 树的能力。

启用函数构造的 LINQ to XML 编程接口有几个重要功能：

XElement 构造函数可以对内容采用多种类型的参数。 例如，可以传递另一个 XElement 对象，该对象将成为一个子元素。 可以传递一个 XAttribute 对象，该对象将成为该元素的一个属性。 也可以传递任何其他类型的对象，该对象将转换为字符串并成为该元素的文本内容。

XElement 函数采用类型为 Object 的 params 数组，因此可以向该构造函数传递任意数目的对象。 这使您可以创建具有复杂内容的元素。如果对象实

现 IEnumerable<T>，则枚举对象中的集合，并添加集合中的所有项。

如果集合包含 XElement 或 XAttribute 对象，则单独添加集合中的每一项。这一功能很重要，因为它允许您将 LINQ 查询的结果传递给构造函数。

本文的主要模块为：

① ：生成xml文件

② ：遍历xml文件的节点信息

③ ：修改xml文件的节点信息

④ ：向xml文件添加节点信息

⑤ ：删除指定xml文件的节点信息

①：【生成xml文件】假设我们想生成这样的一个xml文件结构，如下所示：

 1 using System;
 2  using System.Collections.Generic;
 3  using System.Linq;
 4  using System.Text;
 5  using System.Xml.Linq;
 6 
 7  namespace OperateXmlLinq
 8 {
 9     class Program
10     {
11         static void Main(string[] args)
12         {
13             //xml文件存储路径
14              string myXmlPath = "E:\\MyUsers.xml";
15             //创建xml文件
16              GenerateXmlFile(myXmlPath);
17         }
18 
19         private static void GenerateXmlFile(string xmlPath)
20         {
21             try
22             {
23                 //定义一个XDocument结构
24                  XDocument myXDoc = new XDocument(
25                     new XElement("Users",
26                         new XElement("User", new XAttribute("ID", "111111"),
27                             new XElement("name", "EricSun"),
28                             new XElement("password", "123456"),
29                             new XElement("description", "Hello I'm from Dalian")
30                             ),
31                         new XElement("User", new XAttribute("ID", "222222"),
32                             new XElement("name", "Ray"), 
33                             new XElement("password", "654321"),
34                             new XElement("description", "Hello I'm from Jilin")
35                             )
36                        )
37                 );
38                 //保存此结构（即：我们预期的xml文件）
39                  myXDoc.Save(xmlPath);
40             }
41             catch (Exception ex)
42             {
43                 Console.WriteLine(ex.ToString());
44             }
45         }
46 }

②：【遍历xml文件的节点信息】创造出了xml文件之后，我们就要知道如何获得xml文件的各个节点的信息，请看如下代码：

 1 private static void GetXmlNodeInforOld(string xmlPath)
 2         {
 3             try
 4             {
 5                 XDocument myXDoc = XDocument.Load(xmlPath);
 6                 XElement rootNode = myXDoc.Element("Users");
 7                 foreach (XElement node in rootNode.Elements("User"))
 8                 {
 9                     Console.WriteLine("User ID = {0}", node.Attribute("ID").Value);
10 
11                     string name = node.Element("name").Value;
12                     string password = node.Element("password").Value;
13                     string description = node.Element("description").Value;
14                     Console.WriteLine("name = {0} \npassword = {1} \ndescription = {2}", name, password, description);
15                 }
16             }
17             catch (Exception ex)
18             {
19                 Console.WriteLine(ex.ToString());
20             }
21         }
22 
23         private static void GetXmlNodeInformation(string xmlPath)
24         {
25             try
26             {
27                 //定义并从xml文件中加载节点（根节点）
28                  XElement rootNode = XElement.Load(xmlPath);
29                 //查询语句: 获得根节点下name子节点（此时的子节点可以跨层次：孙节点、重孙节点......）
30                  IEnumerable<XElement> targetNodes = from target in rootNode.Descendants("name")
31                                                     select target;
32                 foreach (XElement node in targetNodes)
33                 {
34                     Console.WriteLine("name = {0}", node.Value);
35                 }
36 
37                 //查询语句: 获取ID属性值等于"111111"并且函数子节点的所有User节点（并列条件用"&&"符号连接）
38                  IEnumerable<XElement> myTargetNodes = from myTarget in rootNode.Descendants("User")
39                                                       where myTarget.Attribute("ID").Value.Equals("111111") 
                                                               && myTarget.HasElements
40                                                       select myTarget;
41                 foreach (XElement node in myTargetNodes)
42                 {
43                     Console.WriteLine("name = {0}", node.Element("name").Value);
44                     Console.WriteLine("password = {0}", node.Element("password").Value);
45                     Console.WriteLine("description = {0}", node.Element("description").Value);
46                 }
47             }
48             catch (Exception ex)
49             {
50                 Console.WriteLine(ex.ToString());
51             }
52         }

上 面用了两种方法去实现对xml文件节点信息的读取，第一种方法是那种比较老的模式：通过父节点获得它的子节点（一层一层的获得），然后获取目标节点的信 息；第二中方法用到的是Linq to xml的查询模式，根据我们的需求获得符合条件的所有节点，然后对这些节点的信息进行读取。

接下来我们要简单的讲述一下Linq to xml的查询模式（语法一看便懂，这里就不过多阐述了），LINQ to XML 的一个最重要的性能优势（与 XmlDocument 相比）为：LINQ to XML 中的查询是静态编译的，而 XPath 查询则必须在运行时进行解释，此功能是 LINQ to XML 的内置功能。

在 调试程序的时候我们发现，第二种方法的IEnumerable<XElement> targetNodes = from target in rootNode.Descendants(“name”) select target;的这句话执行完毕后，得到的targetNodes依然是null，直到遍历的时候才获得相应的对象信息，这种方式就做延迟执行，【延迟执行】：意味着表达式的计算延迟，直到真正需要它的实现值为止。 当必须操作大型数据集合，特别是在包含一系列链接的查询或操作的程序中操作时，延迟执行可以大大改善性能。 在最佳情况下，延迟执行只允许对源集合的单个循环访问。

【注：查询条件写在where语句中，并列条件用”&&”符号连接，或条件用”||”符号连接】

③：【修改xml文件的节点信息】知道了如何查询xml文件的节点信息之后，对相应节点信息做相应的修改，就显得很容易了。请看如下代码：

 1 private static void ModifyXmlNodeInforOld(string xmlPath)
 2         {
 3             try
 4             {
 5                 XDocument myXDoc = XDocument.Load(xmlPath);
 6                 myXDoc.Element("Users").Element("User").Attribute("ID").Value = "777777";
 7                 foreach (XElement node in myXDoc.Element("Users").Elements("User").Elements("description"))
 8                 {
 9                     node.SetValue("Hello, I'm from China.");
10                 }
11                 myXDoc.Save(xmlPath);
12             }
13             catch (Exception ex)
14             {
15                 Console.WriteLine(ex.ToString());
16             }
17         }
18 
19         private static void ModifyXmlNodeInformation(string xmlPath)
20         {
21             try
22             {
23                 //定义并从xml文件中加载节点（根节点）
24                 XElement rootNode = XElement.Load(xmlPath);
25                 //查询语句: 获取ID属性值等于"222222"或者等于"777777"的所有User节点（或条件用"||"符号连接）
26                 IEnumerable<XElement> targetNodes = from target in rootNode.Descendants("User")
27                                                     where target.Attribute("ID").Value == "222222" 
                                                             || target.Attribute("ID").Value.Equals("777777")
28                                                     select target;
29                 //遍历所获得的目标节点（集合）
30                 foreach (XElement node in targetNodes)
31                 {
32                     //将description节点的InnerText设置为"Hello, I'm from USA."
33                     node.Element("description").SetValue("Hello, I'm from USA.");
34                 }
35                 //保存对xml的更改操作
36                 rootNode.Save(xmlPath);
37             }
38             catch (Exception ex)
39             {
40                 Console.WriteLine(ex.ToString());
41             }
42         }

这里也用了两种方法去获取相应节点信息的，具体过程请看代码就可以啦。

④：【向xml文件添加节点信息】下面的代码是向原有xml文件中添加一个节点

 1 private static void AddXmlNodeInformation(string xmlPath)
 2         {
 3             try
 4             {
 5                 //定义并从xml文件中加载节点（根节点）
 6                 XElement rootNode = XElement.Load(xmlPath);
 7                 //定义一个新节点
 8                 XElement newNode = new XElement("User", new XAttribute("ID","999999"), 
 9                                                             new XElement("name", "Rose"), 
10                                                             new XElement("password", "456123"), 
11                                                             new XElement("description", "Hello, I'm from UK."));
12                 //将此新节点添加到根节点下
13                 rootNode.Add(newNode);
14                 //保存对xml的更改操作
15                 rootNode.Save(xmlPath);
16             }
17             catch (Exception ex)
18             {
19                 Console.WriteLine(ex.ToString());
20             }
21         }

简单做一个总结：下面的方法将子内容添加到 XElement 或 XDocument 中：

方法                 说明

Add                  在 XContainer 的子内容的末尾添加内容。

AddFirst           在 XContainer 的子内容的开头添加内容。

下面的方法将内容添加为 XNode 的同级节点。 向其中添加同级内容的最常见的节点是 XElement，不过你也可以将有效的同级内容添加到其他类型的节点，

例如 XText 或 XComment。

方法                         说明

AddAfterSelf            在 XNode 后面添加内容。

AddBeforeSelf          在 XNode 前面添加内容。

⑤：【删除指定xml文件的节点信息】如何将刚刚加入的那个节点删除掉呢？请看如下代码：

 1 private static void DeleteXmlNodeInformation(string xmlPath)
 2         {
 3             try
 4             {
 5                 //定义并从xml文件中加载节点（根节点）
 6                 XElement rootNode = XElement.Load(xmlPath);
 7                 //查询语句: 获取ID属性值等于"999999"的所有User节点
 8                 IEnumerable<XElement> targetNodes = from target in rootNode.Descendants("User")
 9                                                     where target.Attribute("ID").Value.Equals("999999")
10                                                     select target;
11 
12                 //将获得的节点集合中的每一个节点依次从它相应的父节点中删除
13                 targetNodes.Remove();
14                 //保存对xml的更改操作
15                 rootNode.Save(xmlPath);
16             }
17             catch (Exception ex)
18             {
19                 Console.WriteLine(ex.ToString());
20             }
21         }

至此，我们就完成对xml文件的基本操作：创建、读取、修改、添加、删除。由于刚刚学习Linq，理解的很浅显，如有不合适的地方，欢迎大家指出~~

[转载]android中隐藏的layout 抽屉的运用 – noTice520 – 博客园.

最近在写一个应 用，想把设置页面和应用页面放在一起，这样就能实现用户可以实时看到自己的设置对UI的影响，从而更方便的设置用户喜欢的界面。想了一段时间，发现用 slidingDrawer这个控件可以实现这个效果。也就是一个抽屉。拉开抽屉，占据半个屏幕，另外半个屏幕还是显示应用页面。效果还是不错的。

今天就和大家分享一下Android中这个抽屉效果。其实在Android的lanucher就是一个抽屉，打开它就可以看到安装的应用。相信大家都见过用过。下面我们就来做个相同的效果，当然只是UI上差不多相同的效果。

slidingDrawer这个控件使用非常简单，基本在xml里面配置就可以。代码如下所示。

<?xml version=”1.0″ encoding=”utf-8″?>
<RelativeLayout
xmlns:Android=”http://schemas.android.com/apk/res/android”
android:layout_width=”fill_parent”
android:layout_height=”fill_parent”
>
<TextView
android:layout_width=”fill_parent”
android:layout_height=”wrap_content”
android:text=”@string/hello”
android:textSize=”20sp”
/>
<SlidingDrawer
android:id=”@+id/sd”
android:layout_width=”match_parent”
android:layout_height=”match_parent”
android:handle=”@+id/iv”
android:content=”@+id/myContent”
android:orientation=”vertical”
>

<ImageView
android:id=”@+id/iv”
android:layout_width=”wrap_content”
android:layout_height=”wrap_content”
android:src=”@drawable/open1″
/>

<GridView
android:id=”@id/myContent”
android:layout_width=”wrap_content”
android:layout_height=”wrap_content”
android:numColumns=”3″
android:background=”@drawable/background”
android:gravity=”center”
/>

</SlidingDrawer>
</RelativeLayout>

在SlidingDrawer这个标签下android:handle：指示的就是抽屉的图片。android:content:指向的就是抽屉里面的布局。有了这个布局，其实一个抽屉就出来了。

下面我们看Chouti这个类的代码

public class Chouti extends Activity {

private GridView gv;
private SlidingDrawer sd;
private ImageView iv;
private int[] icons={R.drawable.browser,R.drawable.gallery,
R.drawable.camera,R.drawable.gmail,
R.drawable.music,R.drawable.market,
R.drawable.phone,R.drawable.messages,R.drawable.maps};
private String[] items={“浏览器”,”图片”,”相机”,”时钟”,”音乐”,”市场”,”拨号”,”信息”,”地图”};

/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
gv = (GridView)findViewById(R.id.myContent);
sd = (SlidingDrawer)findViewById(R.id.sd);
iv=(ImageView)findViewById(R.id.iv);
MyAdapter adapter=new MyAdapter(this,items,icons);//自定义MyAdapter来实现图标加item的显示效果
gv.setAdapter(adapter);
sd.setOnDrawerOpenListener(new SlidingDrawer.OnDrawerOpenListener()//开抽屉
{
@Override
public void onDrawerOpened()
{
iv.setImageResource(R.drawable.close1);//响应开抽屉事件 ，把图片设为向下的
}
});
sd.setOnDrawerCloseListener(new SlidingDrawer.OnDrawerCloseListener()
{
@Override
public void onDrawerClosed()
{
iv.setImageResource(R.drawable.open1);//响应关抽屉事件
}
});
}
}

在整个类里面将布局导入，同时设置开关抽屉的监听事件。这里面我们需要自定义一个MyAdapter来显示带文字下标的图片。

下面是MyAdapter这个类的代码
public class MyAdapter extends BaseAdapter
{
private Context _ct;
private String[] _items;
private int[] _icons;

public MyAdapter(Context ct,String[] items,int[] icons) //构造器
{
_ct=ct;
_items=items;
_icons=icons;
}

@Override
public int getCount()
{
return _items.length;
}

@Override
public Object getItem(int arg0)
{
return _items[arg0];
}

@Override
public long getItemId(int position)
{
return position;
}

@Override
public View getView(int position, View convertView, ViewGroup parent)
{
LayoutInflater factory = LayoutInflater.from(_ct);
View v = (View) factory.inflate(R.layout.gv, null);//绑定自定义的layout
ImageView iv = (ImageView) v.findViewById(R.id.icon);
TextView tv = (TextView) v.findViewById(R.id.text);
iv.setImageResource(_icons[position]);
tv.setText(_items[position]);
return v;
}
}

也是非常的简单，其中用到的布局如下

<?xml version=”1.0″ encoding=”utf-8″?>
<LinearLayout
xmlns:android=”http://schemas.android.com/apk/res/android”
android:orientation=”vertical”
android:layout_width=”fill_parent”
android:layout_height=”fill_parent”
>
<ImageView
android:id=”@+id/icon”
android:layout_width=”wrap_content”
android:layout_height=”40px”
android:layout_gravity=”center”
/>
<TextView
android:id=”@+id/text”
android:layout_width=”fill_parent”
android:layout_height=”wrap_content”
android:gravity=”center”
android:textColor=”#ffffffff”
/>
</LinearLayout>

这样，我们的抽屉就完成啦 来看下效果

就写这么多啦。抽屉这个控件非常实用，除了我在开头所说的我在程序中的应用外，还有很多的用途， 发挥你的想象力，抽屉将为你的应用增色不少。

[转载]以异步的方式操作TCP/IP套接字——以异步方式实现简单的聊天室 – 风尘浪子 – 博客园.

普通的TCP/IP开发方式大家都应该非常熟练，但在系统开发的时候往往会遇到问题。

比如：在开发一个简单的聊天室的时候，一般情况下，Windows应用程序会处于同步方式运行，当监听的客户端越多，服务器的负荷将会越重，信息发送与接收都会受到影响。这时候，我们就应该尝试使用异步的TCP/IP通讯来缓解服务器的压力。

下面以一个最简单的聊天室服务器端的例子来说明异步TCP/IP的威力,先开发一个ChatClient类作为客户管理的代理类，每当服务器接收到信息时，就会把信息处理并发送给每一个在线客户。

void Main()
{
IPAddress ipAddress = IPAddress.Parse(“127.0.0.1”);            //默认地址
TcpListener tcpListener = new TcpListener(ipAddress,500);
tcpListener.Start();
while (isListen)                //以一个死循环来实现监听
{
ChatClient chatClient = new ChatClient(tcpListener.AcceptTcpClient());    //调用一个ChatClient对象来实现监听

}
tcpListener.Stop();

}

ChatClient中存在着一个Hashtabel类的静态变量 clients，此变量用来存贮在线的客户端信息，每当对一个客户端进行监听时，系统就生成一个ChatClient对象，然后在变量clients中加 入此客户端的信息。在接收客户端信息时，信息会调用Receive（IAsyncResult async）方法,把接收到的信息发送给每一个在线客户。

值得注意的是，每当接收到客户信息时，系统都会利用Stream.BeginRead()的方法去接收信息，然后把信息发送到每一个在线客户，这样做就可以利用异步的方式把信息进行接收，从而令主线程及早得到释放，提高系统的性能。

public class ChatClient

{
private TcpClient _tcpClient;
private byte[] byteMessage;
private string _clientEndPoint;

public volatile string message;
public static Hashtable clients= new Hashtable();          //以此静态变量存处多个客户端地址

public ChatClient(TcpClient tcpClient)
{
_tcpClient = tcpClient;
_clientEndPoint = _tcpClient.Client.RemoteEndPoint.ToString();
Console.WrtieLine(“连接成功，客户端EndPoint为”+_clientEndPoint);

ChatClient.clients.Add(_clientEndPoint, this);       //每创建一个对象，就会将客户端的ChatClient对象存入clients;

byteMessage=new byte[_tcpClient.ReceiveBufferSize];

lock (_tcpClient.GetStream())        //接收信息，使用lock避免数据冲突

{

_tcpClient.GetStream().BeginRead(byteMessage, 0, _tcpClient.ReceiveBufferSize, new AsyncCallback(Receive), null);

//就在此处使用异步的IO线程进行数据读取，这样每个一客户端的都处于一个IO线程中处理，使主线程及早得到释放

//这样做就缓解了服务器端压力。
}
}

public void Receive(IAsyncResult iAsyncResult)
{
try
{
int length;

lock (_tcpClient.GetStream())    //信息接收，使用lock避免数据冲突
{
length= _tcpClient.GetStream().EndRead(iAsyncResult);
}
if (length < 1)
{
MessageBox.Show(_tcpClient.Client.RemoteEndPoint + “已经断线”);
clients.Remove(_tcpClient);
return ;
}

message=Encoding.Unicode.GetString(byteMessage,0,length);
SendToEveryone(message);

//在此时我们可以在此处调用SendToEveryone方法，利用clients变量以Stream.Write方法为每个客户端发送信息。

lock (_tcpClient.GetStream())    //再次监听，使用lock避免数据冲突
{
_tcpClient.GetStream().BeginRead(byteMessage, 0, _tcpClient.ReceiveBufferSize, new AsyncCallback(Receive), null);

//再次调用Stream.BeginRead方法，以监听以下次客户的信息
}
}
catch (Exception ex)
{
clients.Remove(_tcpClient);
_tcpClient.GetStream().Close();
_tcpClient.Close();
}
}

//通过Send方法把信息转换成二进制数据，然后发送到客户端

public void Send(string message)
{
try
{
NetworkStream ns;
lock (_tcpClient.GetStream())
{
ns = _tcpClient.GetStream();
}
byte[] byteMessage = Encoding.ASCII.GetBytes(message);
ns.Write(byteMessage, 0, byteMessage.Length);
ns.Flush();
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}

//由于客户端信息记录在HashTabel变量clients中，当信息接收后，就会通过此变量把信息发送给每一个在线客户。

public void SendToEveryone(string message)
{
foreach (DictionaryEntry client in clients)
{
ChatClient chatClient = (ChatClient)client.Value;
chatClient.Send(message);
}
}

}

测试结果：

至于窗口的设计和客户端的设计在这里就省略不说，这里的目的只是要你了解服务器端多线程TCP/IP信息接收的原理。

这个例子里，ChatClient类使用异步的IO线程进行数据读取，这样每个一客户端的都处于一个IO线程中处理，使主线程及早得到释放，这样做就缓解了服务器端压力。

这时候你可以做一个测试，此聊天室在默认情况下可接受大约3000个客户端连接，仍然能够正常工作。

[转载]Android 中文 API (100) —— ScrollView – 农民伯伯 – 博客园.

前言

春节即至，谨代表Android中文翻译组全体同仁祝大家身体健 康，工作顺利！从第一篇译稿2010年8月27发布至今天2011年1月27整5个月，共发布100篇译文，3个合集，在新的一年里，翻译组仍将坚持 Android相关的翻译工作，秉承开源、合作、共享和坚持的信念打持久战，感谢大家的关心和支持！

本章内容是 Android.widget.ScrollView，版本为Android 2.3 r1，翻译来自”pengyouhong”，再次感谢”pengyouhong” ！期待你一起参与Android API的翻译，联系我over140@gmail.com。

声明

欢迎转载，但请保留文章原始出处:)

博客园：http://www.cnblogs.com/

Android中文翻译组：http://goo.gl/6vJQl

正文

一、结构

二、概述

三、构造函数

四、公共方法

五、受保护方法

六、补充

七、译者其他译文

android 中文 api （64） —— Scroller

八、通知

由于年前事情较多，合集4将推迟到年后发布，时间约为2011年2月9日或10日，请大家谅解 🙂

[转载]Hadoop in Action 翻译 第一章 – 王新的博客 – 博客园.

[转载]Android 分享两个你学习android 平台开发必须碰到的几个知识点的组件【天气预报、日期】View 组件 – Terry_龙 – 博客园.

本篇文章将分享两个VIEW组件，一个天气组件和一个日期组件，这两个组件本来是一个App Widget 后来，我看着好玩，将他们弄成一个VIEW的组件，可以像使用Windows Phone 7 的用户控件一样拖放到你想要的项目中。本篇将演示这两个组件的编写过程，工程文件如下：

包名介绍：

• com.terry.weather　　程序的入口包
• com.yaomei.adapter　　天气预报组件使用到的数据源
• com.yaomei.model　　天气预报使用到的模型包
• com.yaomei.util　　获取天气信息的工具包
• com.yaomei.widget　　天气预报组件、日期组件的存放位置

从包名可以看出，编写一个天气预报所需要的代码量比编写一个日期VIEW所需要的代码量要多得多 ，那么我们先把天气预报的一些实现思路跟大家讲讲。

首先，本实例使用的天气预报是一个可以自己国际化的天气组件VIEW，可以看上图，将所需要的URL都放入Android 自己的国际化文件夹里面，比如中文的话就这样写：

那么是英语环境的就只需要在默认的VALUES里面的string.xml这样写即可：

这是本篇一个要注意的一点，另外还有需要注意的是，这个天气组件提供可供用户选择更新频率，这里比如我们使用3个小时更新一次，那么当用户退出 程序时，再打开是否还要再去Google 上面读天气呢？答案是NO，因为既然用户选择了更新频率，那么在一定的时间内，我们最好不要自动去更新，除非用户自己点击更新才去执行。那么要如何得到之 前的数据呢？

这里使用到的是SharePreference 将一些天气的信息保存进去，连同天气的图片也一并保存。保存天气图片是将google 天气的图片使用Base64转成字符串，然后保存进Sharepreference ，如果更新频率条件未满足则进去SharePrference 将天气预报数据取出来 。因为Android 并未提供将图片转成字符串的API，这里使用到的是apache 的一个Jar包，可在这里下载：点击这里

思路上面给出了，下面给出天气预报组件VIEW的核心代码，其他附属代码可在后面的附件下载得到，代码如下：

学习这个类，你能够学到的知识点为：为应用程序添加属性，编写组件，SharePreference 的使用，Timer和Handler 异步处理UI等知识点。

日期VIEW显示VIEW组件，是一个显示当前系统时间的组件，当第一次运行时，得到当前的秒数在以60秒减去当前秒，得到第一次运行时下一次 运行需要的秒数，当这一次更新完毕后，下一次每次60秒更新一次时间，这个组件也是以分更新UI的操作，学习本类，你可以学到两个Handler 是如何协作处理UI，代码如下：

上篇运行效果如下：

由于没有为其提供背景颜色，使用的同学可以自己为它们加上一个好看的背景颜色，效果会更加。

上面的天气组件，其实可以使用AsyncTask也是起到同样的效果，AsyncTask使用起来会觉得优雅一点，这里也顺便把一些AsyncTask在使用上一些注意事项跟大家谈一谈：

• 在doInBackground 里面不要直接操作UI，比如设置UI的可见性操作。
• 在doInBackground 所在的操作只负责帮你得到数据，然后把UI处理都放在onPostExecute 里面。
• 同时启动几个AsyncTask 注意线程加锁，使用synchronized
• 必须每次都创建一个新的AsyncTask 对象，否则会提示“a task can be executed only once” 的错误信息。

本篇的所有源码下载地址：组件

[转载]html5 实时股票数据展示控件- HumbleFinance – 分享web开发的最新技术、代码等 – 博客园.

HumbleFinance 一个HTML5数据可视化控件， 它 利用html5 的新特性来实现可交互的图表展示. 他的功能类似于 http://finance.google.com/上的股票展示控件. 该控件完全由 JavaScript 写的, 采用了 Prototype 和 Flotr 代码库. 可用来展示任何两组2维数据集， 只要他们的横坐标度量是一致的就可以.

附件的demo显示了google 2010年3月15号IPO的历史数据。 数据来自Google 财经频道。
值得一提的是，用户可以移动鼠标来显示某个时间点上的更详细的数据值，也可以使用鼠标放大、缩小、移动图表（类似百度地图）
组件在 FireFox, Chrome, Safari等浏览器上表现良好。

网站
http://www.humblesoftware.com/finance/index
下载地址
http://www.humblesoftware.com/finance/source
开源协议
MIT

[转载]如何向妻子解释OOD – 倪大虾 – 博客园.

前言

此文译自CodeProject上<How I explained OOD to my wife>一文，该文章在Top Articles上排名第3，读了之后觉得非常好，就翻译出来，供不想读英文的同学参考学习。

作者(Shubho)的妻子(Farhana)打算重新做一名软件工程师(她本来是，后来因为他们孩子出生放弃了)，于是作者就试图根据自己在软件开发设计方面的经验帮助她学习面向对象设计(OOD)。

自作者从事软件开发开始，作者常常注意到不管技术问题看起来多复杂，如果从现实生活的角度解释并以对答的方式讨论，那么它将变得更简单。现在他们把在OOD方面有些富有成效的对话分享出来，你可能会发现那是一种学习OOD很有意思的方式。

下面就是他们的对话：

OOD简介

Shubho:亲爱的，让我们开始学习OOD吧。你了解面向对象原则吗？

Farhana:你是说封装，继承，多态对吗？我知道的。

Shubho:好，我希望你已了解如何使用类和对象。今天我们学习OOD。

Farhana:等一下。面向对象原则对面向对象编程(OOP)来说不够吗？我的意思是我会定义类，并封装属性和方法。我也能根据类的关系定义它们之间的层次。如果是，那么还有什么？

Shubho:问得好。面向对象原则和OOD实际上是两个不同的方面。让我给你举个实际生活中的例子帮你弄明白。

再你小时候你首先学会字母表，对吗？

Farhana:嗯

Shubho:好。你也学了单词，并学会如何根据字母表造词。后来你学会了一些造句的语法。例如时态，介词，连词和其他一些让你能造出语法正确的句子。例如：

“I” (代词) “want” (动词) “to” (介词) “learn” (动词) “OOD”(名词)。

看，你按照某些规则组合了单词，并且你选择了有某些意义的正确的单词结束了句子。

Farhana:OK，这意味着什么呢？

Shubho:面向对象原则与这类似。OOP指的是面向对象编程的基本原则和核心思路。在这里，OOP可以比作英语基础语法，这些语法教你如何用单词构造有意义且正确的句子，OOP教你在代 码中构造类，并在类里封装属性和方法，同时构造他们之间的层次关系。

Farhana:嗯..我有点感觉了，这里有OOD吗？

Shubho:马上就有答案。现在假定你需要就某些主题写几篇文章或随笔。你也希望就几个你擅长主体写基本书。对写好文章/随笔或书来说，知道如何造句是不够的，对吗？为了使读者能更轻   松的明白你讲的内容，你需要写更多的内容，学习以更好的方式解释它。

Farhana:看起来有点意思…继续。

Shubho:现 在，如果你想就某个主题写一本书，如学习OOD，你知道如何把一个主题分为几个子主题。你需要为这些题目写几章内容，也需要在这些章节中写前言，简介，例 子和其他段落。   你需要为写个整体框架，并学习一些很好的写作技巧以便读者能更容易明白你要说的内容。这就是整体规划。

在软件开发中，OOD是整体思路。在某种程度上，设计软件时，你的类和代码需能达到模块化，可复用，且灵活，这些很不错的指导原则不用你重新发明创造。确实有些原则你已经在你的类和对象中已经用到了，对吗？

Farhana:嗯…有个大概的印象了，但需要继续深入。

Shubho:别担心，你马上就会学到。我们继续讨论下去。

为什么要OOD？

Shubho:这是一个非常重要的问题。当我们能很快地设计一些类，完成开发并发布时，为什么我们需要关心OOD？那样子还不够吗？

Farhana:嗯，我早先并不知道OOD，我一直就是开发并发布项目。那么关键是什么？

Shubho:好的，我先给你一句名言：

走在结冰的河边不会湿鞋，开发需求不变的项目畅通无阻(Walking on water and developing software from a specification are easy if both are frozen)

–Edward V. Berard

Farhana:你的意思是软件开发说明书会不断变化？

Shubho:非常正确！软件开发唯一的真理是“软件一定会变化”。为什么?

因为你的软件解决的是现实生活中的业务问题，而现实生活中得业务流程总是在不停的变化。

假设你的软件在今天工作的很好。但它能灵活的支持“变化”吗？如果不能，那么你就没有一个设计敏捷的软件。

Farhana:好，那么请解释一下“设计敏捷的软件”。

Shubho:”一个设计敏捷的软件能轻松应对变化，能被扩展，并且能被复用。”

并且应用好”面向对象设计”是做到敏捷设计的关键。那么，你什么时候能说你在代码中很好的应用了OOD？

Farhana:这正是我的问题。

Shubho:如果你代码能做到以下几点，那么你就正在OOD：

• 面向对象
• 复用
• 能以最小的代价满足变化
• 不用改变现有代码满足扩展

Farhana：还有？

Shubho:我们并不是孤立的。很多人在这个问题上思考了很多，也花费了很大努力，他们试图做好OOD，并为OOD指出几条基本的原则(那些灵感你能用之于你的OOD)。他们最终也确实总结出了一些通用的设计模式(基于基本的原则)。

Farhana:你能说几个吗？

Shubho:当然。这里有很多涉及原则，但最基本的是叫做SOLID的5原则(感谢Uncle Bob,伟大OOD导师)。

S = 单一职责原则 Single Responsibility Principle
O = 开放闭合原则 Opened Closed Principle 
L = Liscov替换原则 Liscov Substitution Principle
I = 接口隔离原则 Interface Segregation Principle
D = 依赖倒置原则 Dependency Inversion Principle

接下去，我们会仔细探讨每一个原则。

单一职责原则

Shubho:我先给你展示一张海报。我们应当谢谢做这张海报的人，它非常有意思。

单一职责原则海报

它说：”并不是因为你能，你就应该做”。为什么？因为长远来看它会带来很多管理问题。

从面向对象角度解释为：”引起类变化的因素永远不要多于一个。”

或者说”一个类有且只有一个职责”。

Farhana：能解释一下吗？

Shubho:当然，这个原则是说，如果你的类有多于一个原因会导致它变化(或者多于一个职责)，你需要一句它们的职责把这个类拆分为多个类。

Farhana:嗯…这是不是意味着在一个类里不能有多个方法？

Shubho:不。你当然可以在一个类中包含多个方法。问题是，他们都是为了一个目的。如今为什么拆分是重要的？

那是因为：

• 每个职责是轴向变化的；
• 如果类包含多个职责，代码会变得耦合；

Farhana:能给我一个例子吗？

Shubho:当然，看一下下面的类层次。当然这个例子是从Uncle Bob那里得来，再谢谢他。

违反单一职责原则的类结构图

这里，Rectangle类做了下面两件事：

• 计算矩形面积；
• 在界面上绘制矩形；

并且，有两个应用使用了Rectangle类：

• 计算几何应用程序用这个类计算面积；
• 图形程序用这个类在界面上绘制矩形；

这违反了SRP(单一职责原则);

Farhana:如何违反的？

Shubho:你看，Rectangle类做了两件事。在一个方法里它计算了面积，在另外一个方法了它返回一个表示矩形的GUI。这会带来一些有趣的问题：

在计算几何应用程序中我们必须包含GUI。也就是在开发几何应用时，我们必须引用GUI库；

图形应用中Rectangle类的变化可能导致计算几何应用变化，编译和测试，反之亦然；

Farhana:有点意思。那么我猜我们应该依据职责拆分这个类，对吗？

Shubho:非常对，你猜我们应该做些什么？

Farhana:当然，我试试。下面是我们可能要做的：

拆分职责到两个不同的类中，如：

• Rectangle:这个类应该定义Area()方法；
• Rectangle:这个类应继承Rectangle类，并定义Draw()方法。

Shubho:非常好。在这里，Rectangle类被计算几何应用使用，而RectangleUI被图形应用使用。我们甚至可以分离这些类到两个独立的DLL中，那会允许我们在变化时不需要关心另一个就可以实现它。

Farhana:谢谢，我想我明白SRP了。SRP看起来是把事物分离成分子部分，以便于能被复用和集中管理。我们也不能把SRP用到方法级别吗？我的意思是，我们可以写一些方法，它们包含做很多事的代码。这些方法可能违反SRP，对吗？

Shubho:你理解了。你应当分解你的方法，让每个方法只做某一项工作。那样允许你复用方法，并且一旦出现变化，你能购以修改最少的代码满足变化。

开放闭合原则

Shubho:这里是开放闭合原则的海报

开放闭合原则海报

从面向对象设计角度看,它可以这么说:”软件实体(类,模块,函数等等)应当对扩展开放，对修改闭合。”

通俗来讲，它意味着你应当能在不修改类的前提下扩展一个类的行为。就好像我不需要改变我的身体而可以穿上衣服。

Farhana:有趣。你能够按照你意愿穿上不同的衣服来改变面貌，而从不用改造身体。你对扩展开放了，对不？

Shubho:是的。在OOD里，对扩展开发意味着类或模块的行为能够改变，在需求变化时我们能以新的，不同的方式让模块改变，或者在新的应用中满足需求。

Farhana:并且你的身体对修改是闭合的。我喜欢这个例子。当需要变化时，核心类或模块的源代码不应当改动。你能用些例子解释一下吗？

Shubho:当然，看下面这个例子。它不支持”开放闭合”原则。

违反开发闭合原则的类结构

你看，客户端和服务段都耦合在一起。那么，只要出现任何变化，服务端变化了，客户端一样需要改变。

Farhana:理解。如果一个浏览器以紧耦合的方式按照指定的服务器(比如IIS)实现，那么如果服务器因为某些原因被其他服务器(如Apache)替换了，那么浏览器也需要修改或替换。这确实很可怕！

Shubho:对的。下面是正确的设计。

遵循开放闭合原则的类结构

在这个例子中，添加了一个抽象的服务器类，客户端包含一个抽象类的引用，具体的服务类实现了抽象服务类。那么，因任何原因引起服务实现发生变化时，客户端都不需要任何改变。

这里抽象服务类对修改是闭合的，实体类的实现对扩展是开放的。

Farhana:我明白了，抽闲是关键，对吗？

Shubho:是的，基本上，你抽象的东西是你系统的核心内容，如果你抽象的好，很可能在扩展功能时它不需要任 何修改(就像服务是一个抽象概念)。如果在实现里定义了抽象的东西(比如IIS服务器实现的服务)，代码要尽可能以抽象(服务)为依据。这会允许你扩展抽 象事物，定义一个新的实现(如Apache服务器)而不需要修改任何客户端代码。

Liskov’s 替换原则

Shubho:”Liskov’s替换原则(LSP)”听起来很难，却是很有用的基本概念。看下这幅有趣的海报：

Liskov替换原则海报

这个原则意思是：”子类型必须能够替换它们基类型。”

或者换个说法：”使用基类引用的函数必须能使用继承类的对象而不必知道它。”

Farhana:不好意思，听起来有点困惑。我认为这个OOP的基本原则之一。也就是多态，对吗？为什么一个面向对象原则需要这么说呢？

Shubho:问的好。这就是你的答案：

在基本的面向对象原则里，”继承”通常是”is a“的关系。如果”Developer” 是一个”SoftwareProfessional“,那么”Developer“类应当继承”SoftwareProfessional“类。在类设计中”Is a“关系非常重要，但它容易冲昏头脑，结果使用错误的继承造成错误设计。

“Liskov替换原则“正是保证继承能够被正确使用的方法。

Farhana:我明白了。有意思。

Shubho:是的，亲爱的，确实。我们看个例子：

Liskov替换原则类结构图

这里，KingFisher类扩展了Bird基类，并继承了Fly()方法，这看起来没问题。

现在看下面的例子：

违反Liskov替换原则类结构图

Ostrich(鸵鸟)是一种鸟(显然是),并从Bird类继承。它能飞吗？不能，这个设计就违反了LSP。

所以，即使在现实中看起来没问题，在类设计中，Ostrich不应该从Bird类继承，这里应该从Bird中分离一个不会飞的类，Ostrich应该继承与它。

Farhana:好，明白了。那么让我来试着指出为什么LSP这么重要：

• 如果没有LSP，类继承就会混乱；如果子类作为一个参数传递给方法，将会出现未知行为；
• 如果没有LSP，适用与基类的单元测试将不能成功用于测试子类；

对吗？

Shubho:非常正确。你能设计对象，使用LSP做为一个检查工作来测试继承是否正确。

接口分离原则

Shubho:今天我们学习”接口分离原则”,这是海报：

接口分离原则海报

Farhana:这是什么意思？

Shubho:它的意思是：”客户端不应该被迫依赖于它们不用的接口。”

Farhana:请解释一下。

Shubho:当然，这是解释：

假设你想买个电视机，你有两个选择。一个有很多开关和按钮，它们看起来很混乱，且好像对你来说没必要。另一个只有几个开关和按钮，它们很友好，且适合你使用。假定两个电视机提供同样的功能，你会选哪一个？

Farhana:当然是只有几个开关和按钮的第二个。

Shubho:对，但为什么？

Farhana:因为我不需要那些看起来混乱又对我没用的开关和按钮。

Shubho:以便外部能够指导这些类有哪些可用的功能,客户端代码也能根据接口来设计.现在,如果接口太大,包含很多暴露的方法,在外界看来会很混乱.接口包含太多的方法也使其可用性降低,像这种包含了无用方法的”胖接口”会增加类之间的耦合.你通过接口暴露类的功能,对.同样地,假设你有一些类,

这也引起了其他问题.如果一个类想实现该接口,那么它需要实现所有的方法,尽管有些对它来说可能完全没用.所以说这么做会在系统中引入不必要的复杂度,降低可维护性或鲁棒性.

接口隔离原则确保实现的接口有他们共同的职责,它们是明确的,易理解的,可复用的.

Shubho:非常正确.一起看个例子.

注意到IBird接口包含很多鸟类的行为,包括Fly()行为.现在如果一个Bird类(如Ostrich)实现了这个接口，那么它需要实现不必要的Fly()行为(Ostrich不会飞).

Farhana:确实如此。那么这个接口必须拆分了？

Shubho:是的。这个”胖接口”应该拆分未两个不同的接口，IBird和IFlyingBird,IFlyingBird继承自IBird.

这里如果一种鸟不会飞(如Ostrich)，那它实现IBird接口。如果一种鸟会飞(如KingFisher)，那么它实现IFlyingBird.

Farhana:所以回头看包含了很多开关和按钮的电视机的例子，电视机制造商应该有一个电视机的图纸，开关和按钮都在这个方案里。不论任何时候，当他们向制造一种新款电视机时，如果他们想复用这个图纸，他们将需要在这个方案里添加更多的开关和按钮。那么他们将没法复用这个方案，对吗？

Shubho:对的。

Farhana:如果他们确实需要复用方案，它们应当把电视机的图纸份为更小部分，以便在任何需要造新款电视机的时候复用这点小部分。

Shubho:你理解了。