#
//editor 绑定click事件
var ed = $('#tt').datagrid('getEditor', {
index: 2,
field: 'name'
});
$(ed.target).bind('click', function(){
alert('clicked');
});
//editor 绑定回车事件
$('#ttt').datagrid('beginEdit', rowIndex);
var ed = $('#ttt').datagrid('getEditors', rowIndex);
for (var i = 0; i < ed.length; i++)
{
var e = ed[i];
$(e.target).bind('keyup', function()
{
if (window.event.keyCode == 13)
{
alert("you check enter key");
}
});
}//editor绑定change 事件
function setEditing(tablename,rowIndex) {
var editors = $('#tt').datagrid('getEditors', rowIndex);
var priceEditor = editors[0];
var amountEditor = editors[1];
var sumcount = editors[2];
priceEditor.target.bind('change', function () {
// calculate();
var sum = priceEditor.target.val() * amountEditor.target.val();
alert(sum);
sumcount.attr1.val(sum);
});
amountEditor.target.bind('change', function () {
var sum = priceEditor.target.val() + amountEditor.target.val();
alert(sum);
});
在datagrid中动态生成combobox问题
$('#tt').datagrid('beginEdit', index);
var ed = $('#tt').datagrid('getEditor', {index:index, field:'productid'});
$(ed.target).combobox('reload', 'combobox_data.json');
在beginEdit时给$("input.datagrid-editable-input")添加keyup事件即可
代码如下：
onClickRow: function(rowindex, rowData)
{
$('#ttt').datagrid('beginEdit', rowindex);
//$.each(rowData, function(k, v) { alert(k+":"+v); });
$("input.datagrid-editable-input").keyup(function() { alert('hello'); });
},
如何从网页中下载图片
如果做为爬虫很有必要从网页中下载图片到本地，那么我们利用jsoup来进行该操作，jsoup 是一个很不错的html解析器。
网页中下载图片需要这么两步操作
1.获取绝对路径
很多网页中用的是相对路径，因此获取图片的绝对路径很重要
方法一：我们就利用jsoup来获取
Element image = document.select("img").first();
String url = image.absUrl("src");
// url = http://www.example.com/images/chicken.jpg
或者
String url = image.attr("abs:src");
他们的前提利用connect方式获取而不是文件方式
Document doc = Jsoup.connect("http://jsoup.org").get();
Element link = doc.select("a").first();
String relHref = link.attr("href"); // == "/"
String absHref = link.attr("abs:href"); // "http://jsoup.org/"
方法二：利用jdk中url
URL url = new URL("http://www.example.com/index.html");
URI uri = url.toURI();
System.out.println(uri.resolve("images/chicken.jpg").toString());
2.第二步则就是下载图片
URL url = new URL( "图片地址");
URLConnection uc = url.openConnection();
InputStream is = uc.getInputStream();
File file = new File( "本地路径 ");
FileOutputStream out = new FileOutputStream(file);
int i=0;
while ((i=is.read())!=-1) {
out.write(i);
}
is.close();
AJP是定向包协议。因为性能原因，使用二进制格式来传输可读性文本。WEB服务器通过TCP连接和SERVLET容器连接。为了减少进程生成socket的花费，WEB服务器和SERVLET容器之间尝试保持持久性的TCP连接，对多个请求/回复循环重用一个连接。一旦连接分配给一个特定的请求，在请求处理循环结束之前不会在分配。换句话说，在连接上，请求不是多元的。这个是连接两端的编码变得容易，虽然这导致在一时刻会有很多连接。
通常正式的应用都是由apache，nginx来解析http 协议，然后将ajp协议有应用服务器来解析，这样可以大大提高性能。 一旦WEB服务器打开了一个到SERVLET容器的连接，连接处于下面的状态：
空闲
这个连接上没有处理的请求。
已分派
连接正在处理特定的请求。
一旦一个连接被分配给一个特定的请求，在连接上发送的基本请求信息是高度压缩的。在这点，SERVLET容器大概准备开始处理请求，当它处理的时候，它能发回下面的信息给WEB服务器：
SEND_HEADERS
发送一组头到浏览器。
SEND_BODY_CHUNK
发送一块主体数据到浏览器。
GET_BODY_CHUNK
从请求获得下一个数据如果还没有全部传输完，如果请求内容的包长度非常大或者长度不确定，这是非常必要的。例如上载文件。注意这和HTTP的块传输没有关联。
END_RESPONSE
结束请求处理循环。
异步 IO 模型
异步 I/O 模型大体上可以分为两种，反应式 (Reactive) 模型和前摄式 (Proactive) 模型：
1. 传统的 select / epoll / kqueue 模型，以及 Java NIO 模型，都是典型的反应式模型，即应用代码对 I/O 描述符进行注册，然后等待 I/O 事件。当某个或某些 I/O 描述符所对应的 I/O 设备上产生 I/O 事件（可读、可写、异常等）时，系统将发出通知，于是应用便有机会进行 I/O 操作并避免阻塞。由于在反应式模型中应用代码需要根据相应的事件类型采取不同的动作，最常见的结构便是嵌套的 if {...} else {...} 或 switch ，并常常需要结合状态机来完成复杂的逻辑。
2. 前摄式模型则不同。在前摄式模型中，应用代码主动地投递异步操作而不管 I/O 设备当前是否可读或可写。投递的异步 I/O 操作被系统接管，应用代码也并不阻塞在该操作上，而是指定一个回调函数并继续自己的应用逻辑。当该异步操作完成时，系统将发起通知并调用应用代码指定的回调函数。在前摄式模型中，程序逻辑由各个回调函数串联起来：异步操作 A 的回调发起异步操作 B ，B 的回调再发起异步操作 C ，以此往复。 MINA2 便是一个前摄式的异步 I/O 框架。
1.原则： Don't call us,we will call you
2.原来构建对象，对象内如果有其他依赖对象，需要一个个构建后传入，现在直接先注入好，构建原对象的时候
它会直接向Ioc service Provider 去要
3.注入对象的方式有
A. 构造方法方式注入
B.通过setter 方式注入
C.实现提供的接口来注入
4.Ioc service provider 有两种功能
A. 业务对象构建管理
B. 业务对象间依赖绑定
5.Ioc service provider 简化代码来构建对象，但是这些依赖条件Ioc service provider
如何知道？
A.直接编码方式知道
比如
IoContainer container=...
container.register(FXNewProvider.class,new FXNewsProvider());
B.配置文件方式
<bean id="newsProvider" ...>
....
</bean>
C.通过注解来注入
6.Spring Ioc 容器
Ioc service provider 是其中的一部分
Ioc 容器spring提供两种类型
A.BeanFactory ：基础类型Ioc 容器 默认为延时初始化策略，启动快需要资源有限
B.ApplicationContext:BeanFactory 基础上构建，属于高级容器，提供事件发布，国际化等
高级功能，需要资源相对多，启动相对也就慢。
7.bean 的生命周期
A.singleton: 在spring Ioc 容器中只存在一个实例，他的生命周期从容器启动并因为第一次被
请求而初始化后，将一直存活到容器退出。这里的singleton 和Gof中提出的Singleton 有点区别
bean的singleton 表示在同一个容器中存在一个实例；而Gof中的Singleton表示同一个classloader中
只存在一个实例。
B.prototype:代理
容器在接收到请求后，为之生成一个新对象实例给请求方，然后就不再有新对象的引用。
C.request,session,global session
只适用web 应用，不像上面的那么通用。通常与XmlWebApplicationContext一起用
request：每一个请求生成一个新的requestProcessor 对象，和http request的生命周期一样
session：和http session 生命周期一个
global session：只应用在基于portlet 的web应用程序才有意义。映射到portlet的global
范围的session
D.自定义scope类型
实现org.springframework.beans.factory.config.Scope接口
public infterface Scope{
...
}
其中get和remove 方法必须实现，参考例子
http://jroller.com/eu/entry/more_fun_with_spring_scopes
有了Scope的实现类后，需要把Scope注册到容器中，才能提供相应的bean定义
通过ConfigurableBeanFactory的 registerScope中进行注册。BeanFactory
通常实现ConfigurableBeanFactory接口。
如果是ApplicationContext，你还可以通过配置文件来实现，ApplicationContext
会自动识别并加载.
E.面向接口编程指以接口为导向，在类中引用接口而不是具体接口的实现类，这样就减少和
特定实现类的耦合，比如传统写法
public class Foo{
private BarInterface barInstance;
public Foo()
{
barInstance = new BarInterfaceImp();
//BarInterfaceImp其实是BarInterface 接口的实现类
}
}
上面的写法耦合很大，如果该类是由我们设计并开发的，那么还好说，我们可以通过依赖注入，
让容器帮助我们解除接口和实现类之间的耦合性，但是，有时，我们需要依赖第三方库，需要实例化
并通过第三方库中的相关类，这时，接口和实现类的耦合性需要其他方式来避免。
比如工程方法模式。提供一个工厂类来实例化具体的接口实现类，这样主体对象只需要依赖工厂类，具体使用的实现类有变革的话，只要变更工厂类。
上面的Foo可以改为:
public class Foo{
private BarInterface barInterface;
public Foo()
{
//barInterface = BarInterfaceFactory.getInstance();
或者
//barInterface =new BarInterfaceFactory().getInstance();
}
}
静态工厂方法:
public class StaticBarInterfaceFactory
{
public static BarInterface getInstance()
{
return new BarInterfaceImpl();
}
}
spring 提供配置来支持静态工厂方法
<bean id="bar" class="...StaticBarInterfaceFactory" factory-method="getInstance">
//如果factory-method 有参数可以,进入下面参数
<constructor-arg>
<ref bean="foobar">
</constructor-arg>
</bean>
非静态工厂方法：
public class NoStaticBarInterfaceFactory
{
public BarInterface getInstance()
{
return new BarInterfaceImpl();
}
}
spring配置如下：
<bean id="barFactory" class="...NoStaticBarInterfaceFactory" />
<bean id="bar" factory-bean="barFactory" factory-method="getInstance" />
FactoryBean:spring 提供的生产对象的工厂bean
只需要实现org.springframework.beans.factory.FactoryBean 接口
public interface FactoryBean{
//获取实例
Object getObject() throws Exception;
//获取实现相对于的类型
Class getObjectType();
//表明获取的实例在容器中是否是singleton形式
boolean isSingleton();
}
然后在spring 进行bean定义
<bean id="objectId" class="...FactoryBean"/>需要注意的是，这里的objectId不是
FactoryBean类型，而是上面实现接口的具体getObjectType的类型。
F.方法注入和方法替换。
方法替换实现org.springframework.beans.facotry.support.MethodReplacer
并在bean中定义
<replaced-method name="getAndPersistNews" replacer="providerReplacer"/>
<bean id="providerReplacer" class="...FXNewsReplacer">
其实方法替换就是对方法的拦截。
G.ApplicationContext特性
Resource:spring 定义统一的资源
ResourceLoader：有了资源，需要有加载工具。
ResourcePatternResolver：是ResourceLoader的扩展，resourceLoader每次只能根据
资源返回单个Resource实例，而ResourcePatternResolver可以一次返回多个Resource
[PHP]-register_globals使用详解
2008年02月25日 星期一 20:12
|
register_globals是php.ini里的一个配置，这个配置影响到php如何接收传递过来的参数，如果你的问题是：为什么我的表单无法传递数据？为什么我的程序无法得到传递过来的变量？等等，那么你需要仔细的阅读以下的内容。
register_globals的值可以设置为：On或者Off，我们举一段代码来分别描述它们的不同。
代码:
<form name="frmTest" id="frmTest" action="URL">
<input type="text" name="user_name" id="user_name">
<input type="password" name="user_pass" id="user_pass">
<input type="submit" value="login">
</form>
当register_globals=Off的时候，下一个程序接收的时候应该用$_GET['user_name']和$_GET['user_pass']来接受传递过来的值。（注：当<form>的method属性为post的时候应该用$_POST['user_name']和$_POST['user_pass']）
当register_globals=On的时候，下一个程序可以直接使用$user_name和$user_pass来接受值。
顾名思义，register_globals的意思就是注册为全局变量，所以当On的时候，传递过来的值会被直接的注册为全局变量直接使用，而Off的时候，我们需要到特定的数组里去得到它。所以，碰到上边那些无法得到值的问题的朋友应该首先检查一下你的register_globals的设置和你获取值的方法是否匹配。（查看可以用phpinfo()函数或者直接查看php.ini）
那我们为什么要使用Off呢？原因有2：
1、php以后的新版本默认都用Off，虽然你可以设置它为On，但是当你无法控制服务器的时候，你的代码的兼容性就成为一个大问题，所以，你最好从现在就开始用Off的风格开始编程
2、这里有两篇文章介绍为什么要Off而不用On
http://www.linuxforum.net/forum/gshowflat.php?Cat=&Board=php3&Number=292803&page=0&view=collapsed&sb=5&o=all&fpart=
http://www.php.net/manual/en/security.registerglobals.php
现在还有一个问题就是，以前用On风格写的大量脚本怎么办？
如果你以前的脚本规划得好，有个公共包含文件，比如config.inc.php一类的文件，在这个文件里加上以下的代码来模拟一下（这个代码不保证100%可以解决你的问题，因为我没有大量测试，但是我觉得效果不错）。另外，这个帖子里的解决方法也可以参考一下（http://www.chinaunix.net/forum/viewtopic.php?t=159284）。
代码:
<?php
if ( !ini_get('register_globals') )
{
extract($_POST);
extract($_GET);
extract($_SERVER);
extract($_FILES);
extract($_ENV);
extract($_COOKIE);
if ( isset($_SESSION) )
{
extract($_SESSION);
}
}
?>
register_globals = Off的情况不仅仅影响到如何获取从<form>、url传递过来的数据，也影响到session、cookie，对应的，得到session、cookie的方式应该为：$_SESSION[]、$_COOKIE。同时对于session的处理也有一些改变，比如，session_register()没有必要而且失效，具体的变化，请查看php manual里的Session handling functions
$_REQUEST中间的内容实际上还是来源于$_GET $_POST $_COOKIE，缺点是无法判断变量到底来自于get post 还是cookie，对要求比较严格的场合不适用。
php manual 写到:
Variables provided to the script via the GET, POST, and COOKIE input mechanisms, and which therefore cannot be trusted. The presence and order of variable inclusion in this array is defined according to the PHP variables_order configuration directive.
|
一直以来，经常看到JMX这个keyword，于是就想什么时候研究一下，看了半天的材料，看得云里雾里，大概的意思好像就是说，各式可以的系统
分布在任何地方，如何统一去管理，去监控，于是sun就引入了jmx的概念。
但是具体怎么，如何使用，心里不清楚，直接看jms spec很吃力，忽然之间想，可以先从现有的jmx 框架去一个个研究，或许就能慢慢理解他的含义。
首先选择Jolokia：
http://www.jolokia.org。
他们的官方描述是：
Jolokia is a JMX-HTTP bridge giving an alternative to JSR-160 connectors. It is an agent based approach with support for many platforms. In addition to basic JMX operations it enhances JMX remoting with unique features like bulk requests or fine grained security policies.
废话少说，先下载安装再说。
在jolokia的Artifact 里面有面向不同框架方面的相关产品，
我下载了jolokia.war 他应该表示j2ee 应用服务，将 war部署到tomcat后
访问http://127.0.0.1:8080/jolokia
发现输出为
{"timestamp":1298621555,"status":200,"request":{"type":"version"},"value":{"protocol":"4.1","agent":"0.83","info":{"product":"tomcat","vendor":"Apache","version":"6.0.18"}}}
这是一串json字符串，里面是jmx信息，其中有我放入的容器是tomcat以及它的版本。
我想 如果我将war放入weblogic 或者其他j2ee 容器，应该对象的输出会有相关的j2ee的信息。
Artifact里面还有osgi和jvm的，因为osgi不是很熟，暂时就不研究，那么在开始jvm对应的jar
研究jvm 首先要了解javaAgent 参数的含义，为此先补一下-javaAgent 参数的知识。
具体可以参考
http://i-giraffe.com/2010/12/javaagent-example/
这里简要概括一下这个参数的含义，javaAgent 在main方法执行之前，执行agent的代码；必须实现premain这个方法。
因为是在main之前执行，那么可以运用在不修改现有程序来增强或修改软件，或者热启动等等。
接下来我们再回到jolokia jvm版本
首先我们下载这个jolokia_jvm_agent.jar 改为agent.jar, 下面我们需要写一个java application；
代码如下
public class FirstThread extends Thread{//继承Thread重写run方法
@Override
public void run(){
for (int i = 0; i < 300000; i++) {
System.out.println(i);
try {
Thread.sleep(100);//停100毫秒
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
//////////////////main
public class MyProgram{
public static void main(String[] args) {
FirstThread fThread=new FirstThread();
fThread.start();
for (int i = 0; i < 300; i++) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
我们打包为demo.jar
在cmd 命令下执行 java -javaagent:agent.jar -jar demo.jar
执行后我们访问
http://127.0.0.1:8778/jolokia/
会出现json的jmx 信息
{"timestamp":1299226883,"status":200,"request":{"type":"version"},"value":{"protocol":"4.1","agent":"0.83","info":{}}}
这里需要注意两点
如果我访问
http://127.0.0.1:8778/jolokia 则会出现404
另外如果上面的线程循环很小，一会儿就结束了，那么这个时候再访问就会找不到服务器。
另外agent的端口和host都可以通过参数来设定，具体可以查看jolokia jvm 相关的网页。
到目前为止，jolokia for jvm也演示结束了。
-javaagent 这个JVM参数是JDK 5引进的.
java -help的帮助里面写道：
-javaagent:<jarpath>[=<options>]
load Java programming language agent, see java.lang.instrument
JDK 工具文档里面，并没有很详细的说明。
1. 代理 (agent) 是在你的main方法前的一个拦截器 (interceptor)，也就是在main方法执行之前，执行agent的代码。
agent的代码与你的main方法在同一个JVM中运行，并被同一个system classloader装载，被同一的安全策略 (security policy) 和上下文 (context) 所管理。
叫代理（agent）这个名字有点误导的成分，它与我们一般理解的代理不大一样。java agent使用起来比较简单。
怎样写一个java agent? 只需要实现premain这个方法
public static void premain(String agentArgs, Instrumentation inst)
JDK 6 中如果找不到上面的这种premain的定义，还会尝试调用下面的这种premain定义：
public static void premain(String agentArgs)
2. Agent 类必须打成jar包，然后里面的 META-INF/MAINIFEST.MF 必须包含 Premain-Class这个属性。
下面是一个MANIFEST.MF的例子：
Manifest-Version: 1.0
Premain-Class:MyAgent1
Created-By:1.6.0_06
然后把MANIFEST.MF 加入到你的jar包中。
3. 所有的这些Agent的jar包，都会自动加入到程序的classpath中。所以不需要手动把他们添加到classpath。
除非你想指定classpath的顺序。
4. 一个java程序中-javaagent这个参数的个数是没有限制的，所以可以添加任意多个java agent。
所有的java agent会按照你定义的顺序执行。
例如：
java -javaagent:MyAgent1.jar -javaagent:MyAgent2.jar -jar MyProgram.jar
假设MyProgram.jar里面的main函数在MyProgram中。
MyAgent1.jar, MyAgent2.jar, 这2个jar包中实现了premain的类分别是MyAgent1, MyAgent2
程序执行的顺序将会是
MyAgent1.premain -> MyAgent2.premain -> MyProgram.main
5. 另外，放在main函数之后的premain是不会被执行的，
例如
java -javaagent:MyAgent1.jar -jar MyProgram.jar -javaagent:MyAgent2.jar
MyAgent2 和MyAgent3 都放在了MyProgram.jar后面，所以MyAgent2的premain都不会被执行，
所以执行的结果将是
MyAgent1.premain -> MyProgram.main
6. 每一个java agent 都可以接收一个字符串类型的参数，也就是premain中的agentArgs，这个agentArgs是通过java option中定义的。
如：
java -javaagent:MyAgent2.jar=thisIsAgentArgs -jar MyProgram.jar
MyAgent2中premain接收到的agentArgs的值将是”thisIsAgentArgs” （不包括双引号）
7. 参数中的Instrumentation：
通过参数中的Instrumentation inst，添加自己定义的ClassFileTransformer，来改变class文件。
8. 通过java agent就可以不用修改原有的java程序代码，通过agent的形式来修改或者增强程序了，或者做热启动等等。
9. JDK 6 中还增加了agentmain，agentmain可以在JVM运行过程中做一些事情，这个迟点再研究一下。
上面我写的例子可以在我的skydrive上面下载到：点击下载例子
参考：
http://download-llnw.oracle.com/javase/1.5.0/docs/api/java/lang/instrument/package-summary.html
http://download.oracle.com/javase/6/docs/api/java/lang/instrument/package-summary.html
http://javahowto.blogspot.com/2006/07/javaagent-option.html