八点读报

八点读报:全国最大最全最权威的看报平台软件。

发表在 android | 标签为 , | 留下评论

jquery笔记

一。选择器

基本选择器:

$(“#myELement”)    选择id值等于myElement的元素,id值不能重复在文档中只能有一个id值是myElement所以得到的是唯一的元素

$(“div”)                     选择所有的div标签元素,返回div元素数组

$(“.myClass”)           选择使用myClass类的css的所有元素

$(“*”)                        选择文档中的所有的元素

可以运用多种的选择方式进行联合选择:例如$(“#myELement,div,.myclass”)

层叠选择器:

$(“form input”)         选择所有的form元素中的input元素

$(“#main > *”)          选择id值为main的所有的子元素

$(“label + input”)     选择所有的label元素的下一个input元素节点

经测试选择器返回的是label标签后面直接跟一个input标签的所有input标签元素

$(“#prev ~ div”)       同胞选择器

该选择器返回的为id为prev的标签元素的所有的属于同一个父元素的div标签

基本过滤选择器:

$(“tr:first”)               选择所有tr元素的第一个

$(“tr:last”)                选择所有tr元素的最后一个

$(“input:not(:checked) + span”)

过滤掉:checked的选择器的所有的input元素

$(“tr:even”)               选择所有的tr元素的第0,2,4… …个元素(注意:因为所选择的多个元素时为数组,所以序号是从0开始)

$(“tr:odd”)                选择所有的tr元素的第1,3,5… …个元素

$(“td:eq(2)”)             选择所有的td元素中序号为2的那个td元素

$(“td:gt(4)”)             选择td元素中序号大于4的所有td元素

$(“td:ll(4)”)              选择td元素中序号小于4的所有的td元素

$(“:header”)

$(“div:animated”)

内容过滤选择器:

$(“div:contains(‘John’)”)  选择所有div中含有John文本的元素

$(“td:empty”)           选择所有的为空(也不包括文本节点)的td元素的数组

$(“div:has(p)”)        选择所有含有p标签的div元素

$(“td:parent”)          选择所有的以td为父节点的元素数组

可视化过滤选择器:

$(“div:hidden”)        选择所有的被hidden的div元素

$(“div:visible”)        选择所有的可视化的div元素

属性过滤选择器:

$(“div[id]“)              选择所有含有id属性的div元素

$(“input[name='newsletter']“)    选择所有的name属性等于’newsletter’的input元素

$(“input[name!='newsletter']“)  选择所有的name属性不等于’newsletter’的input元素

$(“input[name^='news']“)         选择所有的name属性以’news’开头的input元素

$(“input[name$='news']“)         选择所有的name属性以’news’结尾的input元素

$(“input[name*='man']“)          选择所有的name属性包含’news’的input元素

$(“input[id][name$='man']“)    可以使用多个属性进行联合选择,该选择器是得到所有的含有id属性并且那么属性以man结尾的元素

子元素过滤选择器:

$(“ul li:nth-child(2)”),$(“ul li:nth-child(odd)”),$(“ul li:nth-child(3n + 1)”)

$(“div span:first-child”)          返回所有的div元素的第一个子节点的数组

$(“div span:last-child”)           返回所有的div元素的最后一个节点的数组

$(“div button:only-child”)       返回所有的div中只有唯一一个子节点的所有子节点的数组

表单元素选择器:

$(“:input”)                  选择所有的表单输入元素,包括input, textarea, select 和 button

$(“:text”)                     选择所有的text input元素

$(“:password”)           选择所有的password input元素

$(“:radio”)                   选择所有的radio input元素

$(“:checkbox”)            选择所有的checkbox input元素

$(“:submit”)               选择所有的submit input元素

$(“:image”)                 选择所有的image input元素

$(“:reset”)                   选择所有的reset input元素

$(“:button”)                选择所有的button input元素

$(“:file”)                     选择所有的file input元素

$(“:hidden”)               选择所有类型为hidden的input元素或表单的隐藏域

表单元素过滤选择器:

$(“:enabled”)             选择所有的可操作的表单元素

$(“:disabled”)            选择所有的不可操作的表单元素

$(“:checked”)            选择所有的被checked的表单元素

$(“select option:selected”)  选择所有的select 的子元素中被selected的元素

二。jquery对象

在jquery中利用:
$(“#id”)取出的是jquery对象,这是个集合对象,要想获得dom对象,可以用$(“#id”).get(i),其中i是jquery对象序列号,从0开始计算。

举例如下:
$(“#input1″)获取的不是dom对象,而是jquery对象。

而采用:var obj=document.getElementById(id); 获取的才是dom对象。

所以需要将jquery对象转化为dom对象,所以后面需要加上get()方法。参数名称就是jquery对象的序列号,从0开始计算。

或者是用
$(“[id=input1]“) 可以直接获取dom对象

相互转换:

刚开始学习jQuery,可能一时会分不清楚哪些是jQuery对象,哪些是DOM对象。至于DOM对象不多解释,我们接触的太多了,下面重点介绍一下jQuery,以及两者相互间的转换。

什么是jQuery对象?

—就是通过jQuery包装DOM对象后产生的对象。jQuery对象是jQuery独有的,其可以使用jQuery里的方法。

比如:

$(“#test”).html()   意思是指:获取ID为test的元素内的html代码。其中html()是jQuery里的方法

这段代码等同于用DOM实现代码:

document.getElementById(“id”).innerHTML;

虽然jQuery对象是包装DOM对象后产生的,但是jQuery无法使用DOM对象的任何方法,同理DOM对象也不能使用jQuery里的方法.乱使用会报错。比如:$(“#test”).innerHTML、document.getElementById(“id”).html()之类的写法都是错误的。

还有一个要注意的是:用#id作为选择符取得的是jQuery对象与document.getElementById(“id”)得到的DOM对象,这两者并不等价。请参看如下说的两者间的转换。

既然jQuery有区别但也有联系,那么jQuery对象与DOM对象也可以相互转换。在再两者转换前首先我们给一个约定:如果一个获取的是jQuery对象,那么我们在变量前面加上$,如:var $variab = jQuery对象;如果获取的是DOM对象,则与习惯普通一样:var variab = DOM对象;这么约定只是便于讲解与区别,实际使用中并不规定。

jQuery对象转成DOM对象:

两种转换方式将一个jQuery对象转换成DOM对象:[index]和.get(index);

(1)jQuery对象是一个数据对象,可以通过[index]的方法,来得到相应的DOM对象。

如:var $v =$(“#v”) ; //jQuery对象

var v=$v[0];    //DOM对象

alert(v.checked)   //检测这个checkbox是否被选中

(2)jQuery本身提供,通过.get(index)方法,得到相应的DOM对象

如:var $v=$(“#v”);  //jQuery对象

var v=$v.get(0);   //DOM对象

alert(v.checked)  //检测这个checkbox是否被选中

DOM对象转成jQuery对象:

对于已经是一个DOM对象,只需要用$()把DOM对象包装起来,就可以获得一个jQuery对象了。$(DOM对象)

如:var v=document.getElementById(“v”);  //DOM对象

var $v=$(v);    //jQuery对象

转换后,就可以任意使用jQuery的方法了。

通过以上方法,可以任意的相互转换jQuery对象和DOM对象。需要再强调注意的是:DOM对象才能使用DOM中的方法,jQuery对象是不可以用DOM中的方法。

发表在 jquery | 留下评论

jqueryui 1.8.19引用顺序(导致var basePrototype = new base()错误)

在jqueryui1.8.19中,发现它没有使用原来1.8.17里边那个巨大的260K的单个js,而是把各种JS散开放了,有效地防止了JS下载的带宽。

不过放错顺序,会出现各种错误,不一而足,比如标题括号中的那个位置就经常出做,自己测试及上网搜索了一下,找到个现在可用的顺序,供大家参考。

(在搜索过程中发现有人1.4.X就开始用分离的多个小JS,但此之前本人一直单个的JS)

 

 

jquery本身必须放在第一位:
<script src="../../../Scripts/Jquery1.7.2/jquery-1.7.2.js" type="text/javascript"></script>
core必须放在所有ui之前:
<script src="../../../Scripts/jquery-ui-1.8.19/ui/jquery.ui.core.js" type="text/javascript"></script>
widget必须放在剩下.ui....之前:
<script src="../../../Scripts/jquery-ui-1.8.19/ui/jquery.ui.widget.js" type="text/javascript"></script>
mouse必须放在剩下的.ui...之前,这个试验了半天没发现,在google上找到的:
<script src="../../../Scripts/jquery-ui-1.8.19/ui/jquery.ui.mouse.js" type="text/javascript"></script>
下面的不强制,按字母顺序放就行,当然可以删除多余的:
<script src="../../../Scripts/jquery-ui-1.8.19/ui/jquery.ui.accordion.js" type="text/javascript"></script>
<script src="../../../Scripts/jquery-ui-1.8.19/ui/jquery.ui.autocomplete.js" type="text/javascript"></script>
<script src="../../../Scripts/jquery-ui-1.8.19/ui/jquery.ui.button.js" type="text/javascript"></script>
<script src="../../../Scripts/jquery-ui-1.8.19/ui/jquery.ui.datepicker.js" type="text/javascript"></script>
<script src="../../../Scripts/jquery-ui-1.8.19/ui/jquery.ui.dialog.js" type="text/javascript"></script>
<script src="../../../Scripts/jquery-ui-1.8.19/ui/jquery.ui.draggable.js" type="text/javascript"></script>
<script src="../../../Scripts/jquery-ui-1.8.19/ui/jquery.ui.droppable.js" type="text/javascript"></script>
<script src="../../../Scripts/jquery-ui-1.8.19/ui/jquery.ui.position.js" type="text/javascript"></script>
<script src="../../../Scripts/jquery-ui-1.8.19/ui/jquery.ui.progressbar.js" type="text/javascript"></script>
<script src="../../../Scripts/jquery-ui-1.8.19/ui/jquery.ui.resizable.js" type="text/javascript"></script>
<script src="../../../Scripts/jquery-ui-1.8.19/ui/jquery.ui.selectable.js" type="text/javascript"></script>
<script src="../../../Scripts/jquery-ui-1.8.19/ui/jquery.ui.slider.js" type="text/javascript"></script>
<script src="../../../Scripts/jquery-ui-1.8.19/ui/jquery.ui.sortable.js" type="text/javascript"></script>
<script src="../../../Scripts/jquery-ui-1.8.19/ui/jquery.ui.tabs.js" type="text/javascript"></script>
effects.core必须放置在所有剩下的.effects..之前:
<script src="../../../Scripts/jquery-ui-1.8.19/ui/jquery.effects.core.js" type="text/javascript"></script>
<script src="../../../Scripts/jquery-ui-1.8.19/ui/jquery.effects.blind.js" type="text/javascript"></script>
<script src="../../../Scripts/jquery-ui-1.8.19/ui/jquery.effects.bounce.js" type="text/javascript"></script>
<script src="../../../Scripts/jquery-ui-1.8.19/ui/jquery.effects.clip.js" type="text/javascript"></script>
<script src="../../../Scripts/jquery-ui-1.8.19/ui/jquery.effects.drop.js" type="text/javascript"></script>
<script src="../../../Scripts/jquery-ui-1.8.19/ui/jquery.effects.explode.js" type="text/javascript"></script>
<script src="../../../Scripts/jquery-ui-1.8.19/ui/jquery.effects.fade.js" type="text/javascript"></script>
<script src="../../../Scripts/jquery-ui-1.8.19/ui/jquery.effects.fold.js" type="text/javascript"></script>
<script src="../../../Scripts/jquery-ui-1.8.19/ui/jquery.effects.highlight.js" type="text/javascript"></script>
<script src="../../../Scripts/jquery-ui-1.8.19/ui/jquery.effects.pulsate.js" type="text/javascript"></script>
<script src="../../../Scripts/jquery-ui-1.8.19/ui/jquery.effects.scale.js" type="text/javascript"></script>
<script src="../../../Scripts/jquery-ui-1.8.19/ui/jquery.effects.shake.js" type="text/javascript"></script>
<script src="../../../Scripts/jquery-ui-1.8.19/ui/jquery.effects.slide.js" type="text/javascript"></script>
<script src="../../../Scripts/jquery-ui-1.8.19/ui/jquery.effects.transfer.js" type="text/javascript"></script>

 

发表在 jquery | 留下评论

Thread stack overrun: 解决办法

系统能不能连接数据库,关键要看两个数据

1、数据库系统允许的最大可连接数max_connections。这个参数是可以设置的。如果不设置,默认是100。

2、数据库当前的连接线程数threads_connected。这是动态变化的。

如果 threads_connected == max_connections 时,数据库系统就不能提供更多的连接数了,这时,如果程序还想新建连接线程,数据库系统就会拒绝。

因为创建和销毁数据库的连接,都会消耗系统的资源。而且为了避免在同一时间同时打开过多的连接线程,现在编程一般都使用所谓数据库连接池技术。

但数据库连接池技术,并不能避免程序错误导致连接资源消耗殆尽。

这种情况通常发生在程序未能及时释放数据库连接资源或其他原因造成数据库连接资源不能释放,

该错误的简便的检查办法是,在刷新页面时,不断监视threads_connected的变化。如果max_connections足够大,而 threads_connected值不断增加以至达到max_connections,那么,就应该检查程序了。当然,如果采用数据库连接池技术,threads_connected增长到数据库连接池的最大连接线程数时,就不再增长了。

查看max_connections

进入MySQL,用命令show variables
查看数据库最大可连接数的变量值max_connections

查看threads_connected

进入MySQL,用命令show status
查看当前活动的连接线程变量值threads_connected
设置max_connections

设置办法是在my.cnf文件中,添加下面的最后红色的一行

——————————————————————————–

[mysqld]
port=3306
#socket=MySQL
skip-locking
set-variable = key_buffer=16K
set-variable = max_allowed_packet=1M
set-variable = thread_stack=194K
set-variable = table_cache=4
set-variable = sort_buffer=64K
set-variable = net_buffer_length=2K
set-variable = max_connections=32000
——————————————————————————–

修改完毕后,重启MySQL即可。当然,为了确保设置正确,应该查看一下max_connections。

注意
1、虽然这里写的32000。但实际MySQL服务器允许的最大连接数16384;
2、除max_connections外,上述其他配置应该根据你们系统自身需要进行配置,不必拘泥;
3、添加了最大允许连接数,对系统消耗增加不大。
4、如果你的mysql用的是my.ini作配置文件,设置类似,但设置的格式要稍作变通。

ERROR 1436 (HY000):Threadstack overrun:  4508 bytesusedofa 131072 byte stack, and 128000 bytes needed.  Use ‘mysqld -O thread_stack=#’ to specify a bigger stack.

可通过上面方法改变set-variable = thread_stack=194K值

发表在 sql | 留下评论

JAVA获取数据库连接信息

package com.util.jdbc;  
 
import java.sql.Connection;  
import java.sql.Driver;  
import java.sql.DriverManager;  
import java.sql.PreparedStatement;  
import java.sql.ResultSet;  
import java.sql.ResultSetMetaData;  
import java.sql.SQLException;  
import java.util.Enumeration;  
 
import org.apache.log4j.Logger;  
 
/** 
 * @author ken 
 * @Time 2011-12-10 
 * SQL API 学习 
 */ 
public class JDBCMsg {  
 
    private static Logger log = Logger.getLogger(JDBCMsg.class);  
      
    public static void main(String[] args) throws SQLException {  
        //rs connection 未关闭  
        //getAllDriverMsg();  
        //getDBParameterMetaData();  
        demoDB();  
    }  
      
    /** 
     * 取一个数据库中所有表的信息 
     * @throws SQLException  
     */ 
    public static void demoDB() throws SQLException{  
        Connection conn = JDBCUtil.getConnection();  
        log.info(“######  DatabaseMetaData关于数据库的整体综合信息====”);  
        java.sql.DatabaseMetaData dbmd = conn.getMetaData();  
 
        log.info(“数据库产品名: ” + dbmd.getDatabaseProductName());  
        log.info(“数据库是否支持事务: ” + dbmd.supportsTransactions());  
        log.info(“数据库产品的版本号:”+dbmd.getDatabaseProductVersion());  
        log.info(“数据库的默认事务隔离级别:”+dbmd.getDefaultTransactionIsolation());  
        log.info(“支持批量更新:”+dbmd.supportsBatchUpdates());  
        log.info(“DBMS 的 URL:”+dbmd.getURL());  
        log.info(“数据库的已知的用户名称:”+dbmd.getUserName());  
        log.info(“数据库是否处于只读模式:”+dbmd.isReadOnly());  
        log.info(“数据库是否支持为列提供别名:”+dbmd.supportsColumnAliasing());  
        log.info(“是否支持指定 LIKE 转义子句:”+dbmd.supportsLikeEscapeClause());  
        log.info(“是否为外连接提供受限制的支持:”+dbmd.supportsLimitedOuterJoins());  
        log.info(“是否允许一次打开多个事务:”+dbmd.supportsMultipleTransactions());  
        log.info(“是否支持 EXISTS 表达式中的子查询:”+dbmd.supportsSubqueriesInExists());  
        log.info(“是否支持 IN 表达式中的子查询:”+dbmd.supportsSubqueriesInIns());  
        log.info(“是否支持给定事务隔离级别:”+dbmd.supportsTransactionIsolationLevel(1));  
        log.info(“此数据库是否支持事务:”+dbmd.supportsTransactions());  
        log.info(“此数据库是否支持 SQL UNION:”+dbmd.supportsUnion());  
        log.info(“此数据库是否支持 SQL UNION ALL:”+dbmd.supportsUnionAll());  
        log.info(“此数据库是否为每个表使用一个文件:”+dbmd.usesLocalFilePerTable());  
        log.info(“此数据库是否将表存储在本地文件中:”+dbmd.usesLocalFiles());  
        log.info(“底层数据库的主版本号:”+dbmd.getDatabaseMajorVersion());  
        log.info(“底层数据库的次版本号:”+dbmd.getDatabaseMinorVersion());  
          
        log.info(“JDBC 驱动程序的主版本号:”+dbmd.getJDBCMajorVersion());  
        log.info(“JDBC 驱动程序的次版本号:”+dbmd.getJDBCMinorVersion());  
        log.info(“JDBC 驱动程序的名称:”+dbmd.getDriverName());  
        log.info(“JDBC 驱动程序的 String 形式的版本号:”+dbmd.getDriverVersion());  
          
        log.info(“可以在不带引号的标识符名称中使用的所有“额外”字符:”+dbmd.getExtraNameCharacters());  
        log.info(“用于引用 SQL 标识符的字符串:”+dbmd.getIdentifierQuoteString());  
        log.info(“允许用于类别名称的最大字符数:”+dbmd.getMaxCatalogNameLength());  
        log.info(“允许用于列名称的最大字符数:”+dbmd.getMaxColumnNameLength());  
        log.info(“允许在 GROUP BY 子句中使用的最大列数:”+dbmd.getMaxColumnsInGroupBy());  
        log.info(“允许在 SELECT 列表中使用的最大列数:”+dbmd.getMaxColumnsInSelect());  
        log.info(“允许在表中使用的最大列数:”+dbmd.getMaxColumnsInTable());  
        log.info(“数据库的并发连接的可能最大数:”+dbmd.getMaxConnections());  
        log.info(“允许用于游标名称的最大字符数:”+dbmd.getMaxCursorNameLength());  
        log.info(“在同一时间内可处于开放状态的最大活动语句数:”+dbmd.getMaxStatements());  
          
        //获取所有表 new String[]{“TABLE”}   
        //String[] type = {“TABLE”,”VIEW”}  null  
        log.info(“###### 获取表的信息”);  
        ResultSet tSet = dbmd.getTables(null, “%”, “%”, new String[]{“TABLE”,”VIEW”});  
        while (tSet.next()) {  
            log.info(tSet.getRow()+”_表类别:”+tSet.getString(“TABLE_CAT”)+”_表模式:”+tSet.getString(“TABLE_SCHEM”)  
                    +”_表名称:”+tSet.getString(“TABLE_NAME”)+”_表类型:”+tSet.getString(“TABLE_TYPE”)  
                    //+”\n_表的解释性注释:”+tSet.getString(“REMARKS”)+”_类型的类别:”+tSet.getString(“TYPE_CAT”)  
                    //+”\n_类型模式:”+tSet.getString(“TYPE_SCHEM”)+”_类型名称:”+tSet.getString(“TYPE_NAME”)  
                    //+”\n_有类型表的指定’identifier’列的名称:”+tSet.getString(“SELF_REFERENCING_COL_NAME”)  
                    //+”\n_指定在 SELF_REFERENCING_COL_NAME 中创建值的方式:”+tSet.getString(“REF_GENERATION”)  
                    );  
            //2_表类别:MANOR_表模式:PUBLIC_表名称:SYS_RESOURCE_表类型:TABLE  
            String tableName = tSet.getString(3);  
            String sql = “select * from ” + tableName;  
            ResultSet rsSet = conn.createStatement().executeQuery(sql);  
            ResultSetMetaData rsData = rsSet.getMetaData();  
            for (int i = 1; i <= rsData.getColumnCount(); i++) {  
                log.info(“==列的信息:获取SQL语句的列名:”+rsData.getColumnName(i)+”(“+rsData.getColumnLabel(i)+”,”+rsData.getColumnType(i)+”,”+rsData.getColumnClassName(i)+”)” 
                        +” 列宽”+rsData.getPrecision(i)+” 大小写敏感”+rsData.isCaseSensitive(i)+” isReadOnly:”+rsData.isReadOnly(i));  
                //==列的信息:获取SQL语句的列名:LIMITLEVER(LIMITLEVER,5,java.lang.Short) 列宽5 大小写敏感true isReadOnly:false  
            }  
              
        }  
        tSet.close();  
          
        log.info(“###### 获取当前数据库所支持的SQL数据类型”);  
        ResultSet tableType = dbmd.getTypeInfo();  
        while(tableType.next()){  
            log.info(“数据类型名:”+tableType.getString(1)  
                 +”,短整型的数:”+tableType.getString(2)  
                 +”,整型的数:”+tableType.getString(3)  
                 +”,最小精度:”+tableType.getString(14)  
                 +”,最大精度:”+tableType.getString(15));  
            //数据类型名:TIMESTAMP,短整型的数:93,整型的数:23,最小精度:0,最大精度:10  
            //数据类型名:VARCHAR,短整型的数:12,整型的数:2147483647,最小精度:0,最大精度:0  
        }  
           
        log.info(“###### 表的主键列信息”);  
        ResultSet primaryKey = dbmd.getPrimaryKeys(“MANOR”,”PUBLIC”,”SYS_ROLE_RES”);  
        while(primaryKey.next()){  
         log.info(“表名:”+primaryKey.getString(“TABLE_NAME”)+”,列名:”+primaryKey.getString(“COLUMN_NAME”)  
                 +” 主键名:”+primaryKey.getString(“PK_NAME”));  
         //表名:SYS_ROLE_RES,列名:SYS_RES_ID 主键名:CONSTRAINT_9  
         //表名:SYS_ROLE_RES,列名:SYS_ROLE_ID 主键名:CONSTRAINT_9  
        }  
          
        log.info(“###### 表的外键列信息”);  
        ResultSet foreinKey = dbmd.getImportedKeys(“MANOR”,”PUBLIC”,”SYS_ROLE_RES”);  
        while(foreinKey.next()){  
            log.info(“主键名:”+foreinKey.getString(“PK_NAME”)+”,外键名:”+foreinKey.getString(“FKCOLUMN_NAME”)  
                    +”,主键表名:”+foreinKey.getString(“PKTABLE_NAME”)+”,外键表名:”+foreinKey.getString(“FKTABLE_NAME”)  
                    +”,外键列名:”+foreinKey.getString(“PKCOLUMN_NAME”)+”,外键序号:”+foreinKey.getString(“KEY_SEQ”));  
            //主键名:PRIMARY_KEY_95,外键名:SYS_RES_ID,主键表名:SYS_RESOURCE,外键表名:SYS_ROLE_RES,外键列名:ID,外键序号:1  
            //主键名:PRIMARY_KEY_A,外键名:SYS_ROLE_ID,主键表名:SYS_ROLE,外键表名:SYS_ROLE_RES,外键列名:ID,外键序号:1  
        }  
          
        log.info(“###### 获取数据库中允许存在的表类型”);  
        ResultSet tableTypes = dbmd.getTableTypes();  
        while(tableTypes.next()){  
            log.info(“类型名:”+tableTypes.getString(1));  
            /** H2 
             类型名:SYSTEM TABLE 
             类型名:TABLE 
             类型名:TABLE LINK 
             类型名:VIEW 
             */ 
        }  
          
        //此外还可以获取索引等的信息  
        conn.close();  
    }  
      
    /** 
     * PreparedStatement 信息 
     * ResultSetMetaData 信息 
     * @throws SQLException 
     */ 
    public static void getDBParameterMetaData() throws SQLException{  
        Connection conn = JDBCUtil.getConnection(); //id,name  
        PreparedStatement pre = conn.prepareStatement(“SELECT * FROM SYS_APPTYPE where id = ?”);  
        pre.setInt(1, 3);  
        java.sql.ParameterMetaData pmd = pre.getParameterMetaData();  
        log.info(“参数的个数:”+pmd.getParameterCount());  
        log.info(“获取指定参数的 SQL 类型:”+pmd.getParameterType(1));  
        log.info(“culomn的参数类型:”+pmd.getParameterTypeName(1));  
        log.info(“Java 类的完全限定名称:”+pmd.getParameterClassName(1));  
        log.info(“获取指定参数的模式:”+pmd.getParameterMode(1));  
        log.info(“获取指定参数的指定列大小:”+pmd.getPrecision(1));  
        log.info(“获取指定参数的小数点右边的位数:”+pmd.getScale(1));  
        log.info(“是否允许在指定参数中使用 null 值:”+pmd.isNullable(1));  
        log.info(“指定参数的值是否可以是带符号的数字:”+pmd.isSigned(1));  
          
        //获取结果集元数据  
        ResultSet rs = pre.executeQuery();  
        while (rs.next()) {  
            log.info(rs.getString(1)+”___”+rs.getString(2));  
        }  
        rs.close();  
    }  
 
    /** 
     * 获取所有Driver信息 
     */ 
    public static void getAllDriverMsg(){  
        Enumeration<Driver> drivers = DriverManager.getDrivers();  
        while(drivers.hasMoreElements()) {  
            Driver d = drivers.nextElement();  
            log.info(d.getClass().getName()+”_”+d.getMajorVersion());  
        }  
 
    }

发表在 sql | 留下评论

使用JavaFX2.0的属性和绑定

本教程通过一些可以编译和运行的例子描述了JavaFX的属性和绑定。关于JavaFX的安装,请参阅JavaFX安装指南。

概述

    很多年以来,Java语言一直使用JavaBean来表示对象的属性,这种模式既包含API,也包含设计模式,它已经广泛地被Java应用程序开发者所熟知,开发工具也一直使用这种模式。 这个版本将属性支持引入到了JavaFX中,它基于经过验证的JavaBean的模式,但做了扩展和改进。

    JavaFX的属性经常通过绑定来综合,这是一种表达变量间关系的强大的机制。当对象被绑定后,一个对象的改变会自动被反射到另一个对象。对应用程序来说,这是非常有用的。例如,绑定可以用在帐单票据跟踪程序中。在这种情况下,当一个独立的帐单改动后,总帐单将会自动改变。另外,绑定还可以应用到图形用户界面(GUI)中,用来将应用程序的基础数据的改变同步显示出来。

    绑定集成了一个或多个资源,也称为“依赖关系”,绑定观察者保存依赖关系的列表,当检测到变化时自动更新列表。

    绑定的API分为两大类:

1.高级别的API:提供了一种简单的方法来创建最常见的绑定用例。它的语法很容易学习和使用,特别是在支持自动完成功能的环境中。比如NetBeans IDE中。

2.低级别的API:提供额外的灵活性,可供高级开发人员在高级别API不能满足需要时使用。低级别的API是专为快速执行和小内存占用设计的。

本教程的所面部分将介绍这些API,并提供代码示例,您可以编译和运行它们。有关其他信息,请参阅JavaFX API文档。

理解属性

理解JavaFX的属性需要学习一些新的API和命名约定。你完全有可能只对使用包含属性的类感兴趣(反对在你自已的类中实现属性)。但例1将让你熟悉一种新的来自属性模式的命名规则。它定义了一个名为Bill的类,实现了一个名为amoutDue的属性。

例1:定义一个属性

import javafx.beans.property.DoubleProperty;

class Bill {

    //定义一个变量来保存属性

    private DoubleProperty amountDue = new DoubleProperty();

    //定义一个getter方法来获取属性的值

    public final double getAmountDue(){return amountDue.get();}

    //定义一个setter来设定属性的值

    public final void setAmountDue(double value){amountDue.set(value);}

     //定义一个getter来访问属性

    public DoubleProperty amountDueProperty() {return amountDue;}

}

amountDue对象是一个javafx.beans.property.DoubleProperty的类实例,被标以private来限制外部访问。这在Java或JavaBean程序开发中是一种标准做法。但是请注意,该对象的不是一个标准的Java基本数据类型,而是封装了Java基本数据类型,并增加了一些额外功能的封装类。(javafx.beans.property包中的类都内置了观察和绑定作为设计的一部分)。

属性方法命名规则如下:

l  getAmountDue()是一个标准的getter方法,返回当前值amountDue属性的值。按照惯例,它被声明为final。注意,此方法返回类型是双精度数值而不DoubleProperty类型。

l  setAmountDue(double)方法(也被声明为final)是一个标准的setter方法,用来设置属性的值。setter方法是可选的,其参数的类型也是双精度数值。

l  最后,amountDueProperty()方法定义了属性的getter。这是一种新的命名约定,方法中包含了属性的名称(在本例中是amountDue),然后加上“Property”。 返回类型是属性本身的类型(本例中是DoubleProperty)。

在用JavaFX构建GUI应用程序时,你会注意到某些API里的类已经实现了属性。例如:javafx.scene.shape.Rectangle类包含的属性arcHeight,arcWidth,height,width,x,y。对于这些属性,都有与前面提到的命名规则相对应的方法。例如,getArcHeight(),setArcHeight(double),arcHeightProperty()。 它们共同说明(对开发人员和工具),给定的属性存在。

例2:使用ChangeListener

import javafx.beans.value.ObservableValue;

import javafx.beans.value.ChangeListener;

 public class Main {

     public static void main(String[] args) {

        Bill electricBill = new Bill();

        electricBill.amountDueProperty().addListener(new ChangeListener(){

         @Override public void changed(ObservableValue o,Object oldVal,

                 Object newVal){

             System.out.println(“Electric bill has changed!”);

         }

      });

      electricBill.setAmountDue(100.00);

   }

}

运行该示例将在标准输出中打印消息“帐单已经改变”,证明更改侦听的起作用了。

使用高级别绑定API

高级别API是在你的应用程序中使用绑定的最快和最简单的方式。 它包括两个部分:Fluent API和绑定类。Fluent API将方法向各种依赖对象公开,而绑定类提供静态工厂方法。

要开始使用Fluent API,考虑一个简单的用例。其中两个整数是绑定的,以使他们的值观总是加在一起。在例3中,涉及三个变量:num1(依赖者),num2(依赖者)和sum(绑定)。依赖类型都IntegerProperty,绑定类型是NumberBinding。

例3:使用Fluent API

package bindingdemo;

import javafx.beans.property.IntegerProperty;

import javafx.binding.NumberBinding;

 public class Main {

     public static void main(String[] args) {

        IntegerProperty num1 = new IntegerProperty(1);

        IntegerProperty num2 = new IntegerProperty(2);

        NumberBinding sum = num1.add(num2);

        System.out.println(sum.getValue());

        num1.set(2);

        System.out.println(sum.getValue());

    }

}

此代码绑定两个依赖,打印其总和。改变值num1并再次打印总和,结果是“3”和“4”,这证明了绑定起作用了。

也可以使用绑定类来做同样的事,如例4所示。

例4:使用绑定类

import javafx.beans.property.IntegerProperty;

import javafx.binding.NumberBinding;

import javafx.binding.Bindings;

 public class Main {

     public static void main(String[] args) {

       IntegerProperty num1 = new IntegerProperty(1);

       IntegerProperty num2 = new IntegerProperty(2);

       NumberBinding sum = Bindings.add(num1,num2);

       System.out.println(sum.getValue());

       num1.setValue(2);

       System.err.println(sum.getValue());

    }

}

例5使用了两种方法。

例5:使用两种方法

import javafx.beans.property.IntegerProperty;

import javafx.binding.NumberBinding;

import javafx.binding.Bindings;

 public class Main {

     public static void main(String[] args) {

       IntegerProperty num1 = new IntegerProperty(1);

       IntegerProperty num2 = new IntegerProperty(2);

       IntegerProperty num3 = new IntegerProperty(3);

       IntegerProperty num4 = new IntegerProperty(4);

       NumberBinding total =  Bindings.add(num1.multiply(num2),num3.multiply(num4));

       System.out.println(total.getValue());

       num1.setValue(2);

       System.err.println(total.getValue());

    }

}

例5修改代码来调用Fluent API的multiply和绑定类的add方法。你也应该知道,高级别API允许你定义算术运算时混合类型。结果类型的定义为采用与Java编程语言相同的规则(Add, Subtract, Multiply, and Divide):

  1. 如果操作数是双精度,则结果也是双精度。
  2. 如果不是双精度而是浮点型,其结果是一个浮点型。
  3. 如果不是浮点型而是长整型,则结果是长整型。
  4. 其他情况,结果是一个整数。

下一节探讨观察者,并演示失效监听与改变监听的不同。

探索ObservableValue,InvalidationListener和ChangeListener

属性和绑定类都实现了ObservableValue<T>接口,ObservableValue包装了值并允许它观察改变。JavaFX绑定和属性实现都支持懒惰计算,这意味着当变化发生时,该值不立即重新计算。重新计算稍后发生,也就时当再次请求时。

在例6中,帐单总数(一个绑定)在它检测到其中的一个依赖的第一时间被标记为无效。无论如何,只有当帐单总数被再次请求时,绑定对象才被重新计算。

例6:使用InvalidationListener

import javafx.beans.property.DoubleProperty;

import javafx.binding.NumberBinding;

import javafx.binding.Bindings;

import javafx.beans.value.InvalidationListener;

import javafx.beans.value.ObservableValue;

class Bill {

     // Define the property

    private DoubleProperty amountDue = new DoubleProperty();

     // Define a getter for the property’s value

    public final double getAmountDue(){return amountDue.get();}

     // Define a setter for the property’s value

    public final void setAmountDue(double value){amountDue.set(value);}

      // Define a getter for the property itself

    public DoubleProperty amountDueProperty() {return amountDue;}

 }

public class Main {

     public static void main(String[] args) {

         Bill bill1 = new Bill();

        Bill bill2 = new Bill();

        Bill bill3 = new Bill();

         NumberBinding total =          Bindings.add(bill1.amountDueProperty().add(bill2.amountDueProperty()),

              bill3.amountDueProperty());

        total.addListener(new InvalidationListener() {

         @Override public void invalidated(ObservableValue o) {

                System.out.println(“The binding is now invalid.”);

            }

        });

        //第一次调用使绑定失效

        bill1.setAmountDue(200.00);

        //绑定现在无效

        bill2.setAmountDue(100.00);

        bill3.setAmountDue(75.00);

        //绑定现在有效

        System.out.println(total.getValue());

        //再次使用失效

        bill3.setAmountDue(150.00);

        //使它有效

        System.out.println(total.getValue());

    }

}

通过改变单一帐单的值,绑定变为无效,无效监听器触发。但是,如果绑定已经无效,无效监听器将会再次被触发,即使其他帐单发生了变化。(在例6中,调用total.getValue()使绑定从无效变为有效)。我们知道这个是因为随后对依赖列表中任一帐单的改变导致了无准备监听器的再次触发。如果绑定仍然无效,则触发不会发生。

ObservableValue,InvalidationListener和ChangeListener的方法签名如下:

ObservableValue

l  public void addListener(ChangeListener listener)

l  public void addListener(InvalidationListener listener)

l  public T getValue()

l  public void removeListener(ChangeListener listener)

l  public void removeListener(InvalidationListener listener)

InvalidationListener

l  public void invalidated(ObservableValue observable)

ChangeListener

l  public void changed(ObservableValue observable, T oldValue, T newValue)

请注意,注册一个ChangeListener将强制执行急迫计算,即使ObservableValue的实现支持懒惰计算。对于一个懒惰计算值,在它被重新计算前,是不可能知道一个无效值是否已经被改变的。出于这个原因,产生改变事件需要急迫计算。而失效的事件,可以通过急迫实现产生,也可以通过懒惰实现产生。

使用低级别绑定API

如果高级别API不够满足您的需求,你总是可以使用低级别的API来代替。低级别的API是为那些需要更多灵活性(或更好性能)的开发者准备的,这些特性在高级API中没有提供。

示例7展示了使用低级别的API基本的例子。

    例7:使用低级别API

import javafx.beans.property.DoubleProperty;

import javafx.binding.DoubleBinding;

public class Main {

    public static void main(String[] args) {

        final DoubleProperty a = new DoubleProperty(1);

        final DoubleProperty b = new DoubleProperty(2);

        final DoubleProperty c = new DoubleProperty(3);

        final DoubleProperty d = new DoubleProperty(4);

        DoubleBinding db = new DoubleBinding() {

             {

                super.bind(a, b, c, d);

            }

             @Override

            protected double computeValue() {

                return (a.get() * b.get()) + (c.get() * d.get());

            }

        };

        System.out.println(db.get());

        b.set(3);

        System.out.println(db.get());

    }

}

使用低级别的API调用继承自绑定类的一个方法并且覆写了computeValue()方法,返回当前绑定的值。例7通过这一个自定义的DoubleBinding子类完成这一工作。调用super.bind()向上将依赖传递给DoubleBinding,以便默认无效行为被保留。它通常没有必要为你检查绑定是否无效,这些行为通过基类来提供。

现在你已经有足够的信息来使用低级别API了,本文的后续版本将扩展这部份内容来说明如何展现各种不周的优化策略以使你自定义的绑定更有效率。

发表在 javaFx | 留下评论

jdbc PreparedStatement的用法

 

jdbc(java database connectivity,java数据库连接)的api中的主要的四个类之一的java.sql.statement要求开发者付出大量的时间和精力。在使用statement获取jdbc访问时所具有的一个共通的问题是输入适当格式的日期和时间戳:2002-02-05 20:56 或者 02/05/02 8:56 pm。

通过使用java.sql.preparedstatement,这个问题可以自动解决。一个preparedstatement是从 java.sql.connection对象和所提供的sql字符串得到的,sql字符串中包含问号(?),这些问号标明变量的位置,然后提供变量的值,最后执行语句,例如:

stringsql = “select * from people p where p.id = ? and p.name = ?”;
preparedstatement ps = connection.preparestatement(sql);
ps.setint(1,id);
ps.setstring(2,name);
resultset rs = ps.executequery();
使用preparedstatement的另一个优点是字符串不是动态创建的。下面是一个动态创建字符串的例子:

stringsql = “select * from people p where p.i = “+id;

这允许jvm(javavirtual machine,java虚拟机)和驱动/数据库缓存语句和字符串并提高性能。

preparedstatement也提供数据库无关性。当显示声明的sql越少,那么潜在的sql语句的数据库依赖性就越小。

由于preparedstatement具备很多优点,开发者可能通常都使用它,只有在完全是因为性能原因或者是在一行sql语句中没有变量的时候才使用通常的statement。

一个完整的preparedstatement的例子:

package jstarproject;
import java.sql.*;

public class mypreparedstatement {

private final string db_driver=”com.microsoft.jdbc.sqlserver.sqlserverdriver”;
private final string url = “jdbc:microsoft:sqlserver://127.0.0.1:1433;databasename=pubs”;

  public mypreparedstatement()
  {
  }
  public void query() throws sqlexception{
    connection conn = this.getconnection();
    string strsql = “select emp_id from employee where emp_id = ?”;
    preparedstatement pstmt = conn.preparestatement(strsql);
    pstmt.setstring(1,”pma42628m”);
    resultset rs = pstmt.executequery();

    while(rs.next()){
       string fname = rs.getstring(“emp_id”);
       system.out.println(“the fname is ” + fname);
    }
    rs.close();
    pstmt.close();
    conn.close();

  }
  private connection getconnection() throws sqlexception{
//    class.
    connection conn = null;
    try {
      class.forname(db_driver);
      conn = drivermanager.getconnection(url,”sa”,”sa”);
    }
    catch (classnotfoundexception ex) {}
    return conn;
  }
  //main
  public static void main(string[] args) throws sqlexception {
    mypreparedstatement jdbctest1 = new mypreparedstatement();
    jdbctest1.query();
  }
}

为什么要始终使用PreparedStatement代替Statement?为什么要始终使用PreparedStatement代替Statement?

在JDBC应用中,如果你已经是稍有水平开发者,你就应该始终以PreparedStatement代替Statement.也就是说,在任何时候都不要使用Statement.
基于以下的原因:
一.代码的可读性和可维护性.
虽然用PreparedStatement来代替Statement会使代码多出几行,但这样的代码无论从可读性还是可维护性上来说.都比直接用Statement的代码高很多档次:

stmt.executeUpdate(“insert into tb_name (col1,col2,col2,col4) values (‘”+var1+”‘,’”+var2+”‘,”+var3+”,’”+var4+”‘)”);

perstmt = con.prepareStatement(“insert into tb_name (col1,col2,col2,col4) values (?,?,?,?)”);
perstmt.setString(1,var1);
perstmt.setString(2,var2);
perstmt.setString(3,var3);
perstmt.setString(4,var4);
perstmt.executeUpdate();

不用我多说,对于第一种方法.别说其他人去读你的代码,就是你自己过一段时间再去读,都会觉得伤心.

二.PreparedStatement尽最大可能提高性能.
每一种数据库都会尽最大努力对预编译语句提供最大的性能优化.因为预编译语句有可能被重复调用.所以语句在被DB的编译器编译后的执行代码被缓存下来,那么下次调用时只要是相同的预编译语句就不需要编译,只要将参数直接传入编译过的语句执行代码中(相当于一个涵数)就会得到执行.这并不是说只有一个 Connection中多次执行的预编译语句被缓存,而是对于整个DB中,只要预编译的语句语法和缓存中匹配.那么在任何时候就可以不需要再次编译而可以直接执行.而statement的语句中,即使是相同一操作,而由于每次操作的数据不同所以使整个语句相匹配的机会极小,几乎不太可能匹配.比如:
insert into tb_name (col1,col2) values (’11′,’22′);
insert into tb_name (col1,col2) values (’11′,’23′);
即使是相同操作但因为数据内容不一样,所以整个个语句本身不能匹配,没有缓存语句的意义.事实是没有数据库会对普通语句编译后的执行代码缓存.

当然并不是所以预编译语句都一定会被缓存,数据库本身会用一种策略,比如使用频度等因素来决定什么时候不再缓存已有的预编译结果.以保存有更多的空间存储新的预编译语句.

三.最重要的一点是极大地提高了安全性.

即使到目前为止,仍有一些人连基本的恶义SQL语法都不知道.
String sql = “select * from tb_name where name= ‘”+varname+”‘ and passwd=’”+varpasswd+”‘”;
如果我们把[' or '1' = '1]作为varpasswd传入进来.用户名随意,看看会成为什么?

select * from tb_name = ‘随意’ and passwd = ” or ’1′ = ’1′;
因为’1′=’1′肯定成立,所以可以任何通过验证.更有甚者:
把[';drop table tb_name;]作为varpasswd传入进来,则:
select * from tb_name = ‘随意’ and passwd = ”;drop table tb_name;有些数据库是不会让你成功的,但也有很多数据库就可以使这些语句得到执行.

而如果你使用预编译语句.你传入的任何内容就不会和原来的语句发生任何匹配的关系.只要全使用预编译语句,你就用不着对传入的数据做任何过虑.而如果使用普通的statement,有可能要对drop,;等做费尽心机的判断和过虑.

上面的几个原因,还不足让你在任何时候都使用PreparedStatement吗?

发表在 java | 留下评论

八点读报

“8点报”手机客户端(八点读报)上线了!报纸数量持续添加中。。。。
八点读报:天天8点、免费看报、本地报纸、权威信息 。
八点读报:全国最大最全最权威的看报平台软件。

下载:八点读报

发表在 android | 留下评论

android ListView的美化涉及到的一些属性

用心的朋友应该会发现,listview中在设置了背景之后。会有些问题。

1.、listview在拖动的时候背景图片消失变成黑色背景。等到拖动完毕我们自己的背景图片才显示出来。

2 、listview的上边和下边有黑色的阴影。

3、lsitview的每一项之间需要设置一个图片做为间隔。

针对以上问题 在listview的xml文件中设置一下语句。

问题1 有如下代码结解决 android:scrollingCache=”false”

问题2 用如下代码解决:android:fadingEdge=”none”
问题3 用如下代码解决: android:divider=”@drawable/list_driver” 其中 @drawable/list_driver 是一个图片资源

总体如下

1 <ListView
2 android:id="@+id/myListView01"
3 android:layout_width="fill_parent"
4 android:layout_height="287dip"
5 android:fadingEdge="none"
6 android:divider="@drawable/list_driver"
7 android:scrollingCache="false"
8 android:background="@drawable/list">
9 </ListView>

 

 

4. 自定义listview的时候,当你不使用android:cacheColorHint=“#00000000”会出现下面选中一个空间黑色底色的情况,破坏整体美观度:

5. 当你不使用android:listSelector属性,默认会显示选中的item为橙黄底色,有时候我们需要去掉这种效果.

 

发表在 android | 留下评论

参考消息

《参考消息》是新华通讯社主办,参考消息报社编辑出版的日报,创刊于1931年,历史长达80年。《参考消息》每天及时选载世界各国(地区)通讯社、报刊及因特网上的最新消息、评论的精华,全面报道世界各国以及香港、澳门特区、台湾等地区的政治、经济、军事、科技、体育、文化及对华反应等各方面的最新情况。《参考消息》是一份提供“境外的声音”为特色的国际时政报纸。对外电、外报的翻译讲究“原汁原味”,力求全方位、多视角、立体化地报道国际新闻,突出“参考”特色,为国人提供了一个用“外人”眼光看世界、看中国的窗口。

下载:参考消息

发表在 android | 一条评论