45fan.com - 路饭网

搜索: 您的位置：主页 > 电脑频道 > 电脑教程 > 阅读资讯：使用Console Logging函数的方法

使用Console Logging函数的方法

2016-09-03 13:31:46 来源:www.45fan.com 【大 中 小】

使用Console Logging函数的方法

Console Logging 函数

FireBug 为所有 Web 页面提供了一个 console 对象。这个对象有以下函数：

Logging 基础

console.log("message" [,objects]) - 将一个字符串打印到控制台。字符串可以包含任何“String Formatting”小节描述的模式。字符串后面的对象应该用来取代之前字符串中的模式。（译者注：大家用过C里面 printf 吧，效果基本是一样的。）

Logging 等级

通常根据不同的等级来区分Logging的严重程度是很有帮助的。FireBug 提供了4个等级。为了达到视觉分离的效果，这些函数与 log 不同的地方就是它们在被调用的时候会自动包含一个指向代码行数的链接。

console.debug("message" [,objects]) - 记录一个 debug 消息。
console.info("message" [,objects]) - 记录一个信息.
console.warn("message" [,objects]) - 记录一个警告.
console.error("message" [,objects]) - 记录一个错误.

断言

断言是一条确保代码规则的非常好的途径。console 对象包含了一系列各种类型的断言函数，并且允许你编写自己的断言函数。

console.assert(a, "message" [,objects]) - Asserts that an a is true.
console.assertEquals(a, b, "message" [,objects]) - Asserts that a is equal to b.
console.assertNotEquals(a, b, "message" [,objects]) - Asserts that a is not equal to b.
console.assertGreater(a, b, "message" [,objects]) - Asserts that a is greater than b.
console.assertNotGreater(a, b, "message" [,objects]) - Asserts that a is not greater than b.
console.assertLess(a, b, "message" [,objects]) - Asserts that a is less than b.
console.assertNotLess(a, b, "message" [,objects]) - Asserts that a is not less than b.
console.assertContains(a, b, "message" [,objects]) - Asserts that a is in the array b.
console.assertNotContains(a, b, "message" [,objects]) - Asserts that a is not in the array b.
console.assertTrue(a, "message" [,objects]) - Asserts that a is equal to true.
console.assertFalse(a, "message" [,objects]) - Asserts that a is equal to false.
console.assertNull(a, "message" [,objects]) - Asserts that a is equal to null.
console.assertNotNull(a, "message" [,objects]) - Asserts that a is not equal to null.
console.assertUndefined(a, "message" [,objects]) - Asserts that a is equal to undefined.
console.assertNotUndefined(a, "message" [,objects]) - Asserts that a is not equal to undefined.
console.assertInstanceOf(a, b, "message" [,objects]) - Asserts that a is an instance of type b.
console.assertNotInstanceOf(a, b, "message" [,objects]) - Asserts that a is not an instance of type b.
console.assertTypeOf(a, b, "message" [,objects]) - Asserts that the type of a is equal to the string b.
console.assertNotTypeOf(a, b, "message" [,objects]) - Asserts that the type of a is not equal to the string b.

测量（Measurement）

下面的一些函数可以让你方便的测量你的一些代码。

console.trace() - 记录执行点的堆栈信息。
console.time("name") - 根据 name 创建一个唯一的计时器。
console.timeEnd("name") - 根据 name 停止计时器，并且记录消耗的时间，以毫秒为单位。
console.count("name") - 记录该行代码执行的次数。

字符串格式化

所有 console 的 logging 函数都可以通过以下模式格式化字符串：

%s - 将对象格式化为字符串。
%d, %i, %l, %f - 将对象格式化为数字。
%o - 将对象格式化成一个指向 inspector 的超链接。
%1.o, %2.0, etc.. - 将对象格式化成包含自己属性的可交互的表格。
%.o - 将对象格式化成具有自身属性的一个数组。
%x - 将对象格式化成一个可交互的 XML 树形结构。
%1.x, %2.x, etc.. - 将对象格式化成一个可交互的 XML 数型结构，并且展开 n 层节点。

如果你需要一个真实的 % 符号，你可以通过一个转移符号就像这样 "/%"。

命令行函数

内建的命令行函数可以通过以下命令行使用：

$("id") - document.getElementById() 的简写。（译者注：跟 prototype.js 学来的吧？）
$$("css") - 返回一个符合 CSS 选择器的元素数组。
$x("xpath") - 返回一个符合 XPath 选择器的元素数组。
$0 - 返回最近被检查（inspected）的对象。
$1 - 返回最近被检查（inspected）的下一个对象。
$n(5) - 返回最近被检查的第n个对象。
inspect(object) - 将对象显示在 Inspector 中。
dir(object) - 返回一个对象的属性名数组。（译者注：跟 Python 学的？）
clear() - 清除控制台信息。

Posted in JavaScript, Ajax, Web应用 | No Comments »

编写自己的dojo扩展

Posted by Nicholas Ding on 12th 八月 2006

前言

dojo是时下非常流行的javascript框架，它在自己的Wiki上给自己下了一个定义，dojo是一个用JavaScript编写的开源的DHTML工具箱。

dojo很想做一个“大一统”的工具箱，不仅仅是浏览器层面的，野心还是很大的。不过dojo带来了JavaScript编程的一些新想法，其中引入包机制进行动态加载是一个不错的概念。

理解dojo的包机制

其实dojo只需要一些很小的加载代码就可以用来加载它的各种包，它的官方站点上提供的dojo-ajax下载中包含的dojo.js体积还是比较庞大的，因为它将一些常用的包都包含在了js中， 但是很多时候我们并不需要这么多功能，还是按需加载比较好。

幸好在http://download.dojotoolkit.org/这个地址中我们还可以下载到dojo的各个自定义版本，其实包含的组件都是一样的，只不过dojo.js的大小有很大不同，那么，我们就从minimal版本下手。

下载之后会发现minimal版本包含的dojo.js只有18kb，里面仅仅包含了加载机制，非常不错。这样，我们就可以开始编写自己的dojo扩展。

dojo代码结构

解压缩后的目录里面包含src目录，src目录下存放有dojo的各个组件包，我们在这里面新建一个hello目录。

新建一个名为__package__.js文件，很类似Python的模块命名，这个__package__.js定义了在引入这个命名空间的时候默认导入多少类，以及这个命名空间的名字。

我们的目的是做一个dojo.hello.Echo扩展，那么在__package__.js中的代码应该这样：

// kwCompoundRequire 的作用是当你导入整个dojo.hello包的时候需要默认加载多少类
// 这些定义就在这个函数里面，common在这里表示默认的加载，这个参数不是固定的
// dojo希望自己是一个“大一统”的实现，所以考虑了非浏览器情况，可以有别的，譬如rhino
dojo.kwCompoundRequire({
common: [
"dojo.hello.Echo"
]
});
// 这个定义了包，默认这么写 | 原因嘛，当然是有的，看你的悟性了:-)
dojo.provide("dojo.hello.*");

我们指定了默认加载的类Echo，那么我们就去写Echo类，在hello目录中新建Echo.js，代码如下：

// 类名定义，JavaScript写的变扭，其实就是直接定义类名
dojo.provide("dojo.hello.Echo");

// 类定义部分，非常熟悉的代码
dojo.hello.Echo = function() {
this.name = "dojo.hello.Echo";
this.sayHello = function(greeting) {
return greeting;
}
}

扩展写好了，很简单，接下来就是掉用了，index.html如下。

<html>
<head>
<script language="javascript" src="dojo.js"></script>
<script language="javascript">
dojo.require("dojo.hello.*");
var echo = new dojo.hello.Echo();
document.write(echo.sayHello("Hello World"));
</script>
</head>
<body>

</body>
</html>

注意dojo.require("dojo.hello.*")回去请求两个文件，首先是__package__.js，这样一来就得到了之前在dojo.kwCompoundRequire里面指定的类列表，然后去加载Echo.js。你也可以直 接去加载Echo.js，只需要变成dojo.require("dojo.hello.Echo")。

更多内容

这个例子非常简单的介绍了一下dojo的包加载机制，当然这个包中的类并没有引用其它类，dojo还允许在代码中动态加载其它类，当然了，这些都是通过XmlHttp来实现的，因为是同步模式，所以请求的类比较多并且都没有包含在dojo.js中的时候会有页面停顿的现象，这点还是需要注意的。

文中的代码下载：，dojo-hello.tar.gz

一些dojo的资源：

  • dojo 官方站点
  • dojo 手册
  • dojo wiki

Posted in JavaScript, Ajax, Web应用 | No Comments »

cglib 指南

Posted by Nicholas Ding on 6th 六月 2006

cglib，全称是Code Generation Library，它可以用来动态继承Java类或者实现接口，很多知名的开源项目中用到了它，譬如Hibernate，Spring之类用它来实现动态代理。

增强一个已有类

public class MyClass {

public void method() {
System.out.println("MyClass.method()");
}
}
import java.lang.reflect.Method;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodProxy;
import net.sf.cglib.proxy.MethodInterceptor;

public class Main {

public static void main(String[] args) {

Enhancer enhancer = new Enhancer();

enhancer.setSuperclass(MyClass.class);
enhancer.setCallback( new MethodInterceptorImpl() );


MyClass my = (MyClass)enhancer.create();

my.method();
}

private static class MethodInterceptorImpl implements MethodInterceptor {

public Object intercept(Object obj, 
                Method method, 
                Object[] args, 
                MethodProxy proxy) throws Throwable {

System.out.println(method);

proxy.invokeSuper(obj, args);

return null;
}
}
}

执行结果：

public void cglib_test.MyClass.method()
MyClass.method()

使用CallbackFilter

public class MyClass {

public void method() {
System.out.println("MyClass.method()");
}

public void method2() {
System.out.println("MyClass.method2()");
}
}
import java.lang.reflect.Method;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodProxy;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.NoOp;
import net.sf.cglib.proxy.Callback;
import net.sf.cglib.proxy.CallbackFilter;


public class Main {

public static void main(String[] args) {

Callback[] callbacks =
new Callback[] { new MethodInterceptorImpl(), NoOp.INSTANCE };

Enhancer enhancer = new Enhancer();

enhancer.setSuperclass(MyClass.class);
enhancer.setCallbacks( callbacks );
enhancer.setCallbackFilter( new CallbackFilterImpl() );


MyClass my = (MyClass)enhancer.create();

my.method();
my.method2();
}

private static class CallbackFilterImpl implements CallbackFilter {

public int accept(Method method) {

if ( method.getName().equals("method2") ) {
return 1;

} else {
return 0;
}
}
}

private static class MethodInterceptorImpl implements MethodInterceptor {

public Object intercept(Object obj, 
                Method method, 
                Object[] args, 
                MethodProxy proxy) throws Throwable {

System.out.println(method);

return proxy.invokeSuper(obj, args);
}
}
}

执行结果：

public void cglib_test.MyClass.method()
MyClass.method()
MyClass.method2()

使用Mixin

public interface MyInterfaceA {

public void methodA();
}

public interface MyInterfaceB {
public void methodB();
}

public class MyInterfaceAImpl implements MyInterfaceA {

public void methodA() {
System.out.println("MyInterfaceAImpl.methodA()");
}
}

public class MyInterfaceBImpl implements MyInterfaceB {

public void methodB() {
System.out.println("MyInterfaceBImpl.methodB()");
}
}
import net.sf.cglib.proxy.Mixin;

public class Main {

public static void main(String[] args) {

Class[] interfaces =
new Class[] { MyInterfaceA.class, MyInterfaceB.class };

Object[] delegates =
new Object[] { new MyInterfaceAImpl(), new MyInterfaceBImpl() };


Object obj = Mixin.create(interfaces, delegates);


MyInterfaceA myA = (MyInterfaceA)obj;
myA.methodA();


MyInterfaceB myB = (MyInterfaceB)obj;
myB.methodB();
}
}
执行结果： 
MyInterfaceAImpl.methodA()
MyInterfaceBImpl.methodB()

Posted in Java | 2 Comments »

Don’t repeat the DAO!

Posted by Nicholas Ding on 1st 六月 2006

译者：Nicholas @ Nirvana Studio
原文地址：http://www-128.ibm.com/developerworks/java/library/j-genericdao.html

使用Hibernate和Spring AOP购建一个范型类型安全的DAO
2006年五月12日

在采用了Java 5的范型之后，要实现一个基于范型类型安全的数据访问对象（DAO）就变得切实可行了。在这篇文章里，系统架构师Per Mellqvist展示了一个基于Hibernate的范型DAO实现。然后将介绍如何使用Spring AOP的introduction为一个类增加一个类型安全的接口以便于执行查询。

对于大多数开发者来说，在系统中为每一个DAO编写几乎一样的代码已经成为了一种习惯。同时大家也都认可这种重复就是“代码的味道”，我们中的大多数已经习惯如此。当然也有另外的办法。你可以使用很多ORM工具来避免代码的重复编写。举个例子，用Hibernate，你可以简单的使用session操作直接控制你的持久化领域对象。这种方式的负面影响就是丢失了类型安全。

为什么你的数据访问代码需要一个类型安全的接口？我认为它减少了编程错误，提高了生产率，尤其是在使用现代高级IDE的时候。首先，一个类型安全的接口清晰的制定了哪些领域对象具有持久化功能。其次，它消除了类型转换带来的潜在问题。最后，它平衡了IDE的自动完成功能。使用自动完成功能是最快的方式来记住对于适当的领域类哪些查询是可用的。

在这篇文章里，我将展示给大家如何避免一次次地重复编写DAO代码，但同时还收益于类型安全的接口。事实上，所有内需要编写的是为新的DAO编写一个Hibernate映射文件，一个POJO的Java接口，并且10行Spring配置文件。

DAO实现

DAO模式对于任何Java开发人员来说都是耳熟能详的。这个模式的实现相当多，所以让我们仔细推敲一下我这篇文章里面对于DAO实现的一些假设：

  • 所有系统中的数据库访问都是通过DAO来完成封装
  • 每一个DAO实例对一个主要的领域对象或者实体负责。如果一个领域对象具有独立的生命周期，那么它需要具有自己的DAO。
  • DAO具有CRUD操作
  • DAO可以允许基于criteria方式的查询而不仅仅是通过主键查询。我将这些成为finder方法或者finders。这个finder的返回值通常是DAO所负责的领域对象的集合。

范型DAO接口

范型DAO的基础就是CRUD操作。下面的接口定义了范型DAO的方法：

public interface GenericDao <T, PK extends Serializable> {

  /** Persist the newInstance object into database */
  PK create(T newInstance);

  /** Retrieve an object that was previously persisted to the database using
   *  the indicated id as primary key
   */
  T read(PK id);

  /** Save changes made to a persistent object. */
  void update(T transientObject);

  /** Remove an object from persistent storage in the database */
  void delete(T persistentObject);
}

实现这个接口

使用Hibernate实现上面的接口是非常简单的。也就是调用一下Hibernate的方法和增加一些类型转换。Spring负责session和transaction管理。

public class GenericDaoHibernateImpl <T, PK extends Serializable>
  implements GenericDao<T, PK>, FinderExecutor {
  private Class<T> type;

  public GenericDaoHibernateImpl(Class<T> type) {
    this.type = type;
  }

  public PK create(T o) {
    return (PK) getSession().save(o);
  }

  public T read(PK id) {
    return (T) getSession().get(type, id);
  }

  public void update(T o) {
    getSession().update(o);
  }

  public void delete(T o) {
    getSession().delete(o);
  }

  // Not showing implementations of getSession() and setSessionFactory()
}

Spring 配置

最后，Spring配置，我创建了一个GenericDaoHibernateImpl的实例。GenericDaoHibernateImpl的构造器必须被告知领域对象的类型，这样DAO实例才能为之负责。这个同样需要Hibernate运行时知道这个对象的类型。下面的代码中，我将领域类Person传递给构造器并且将Hibernate的session工厂作为一个参数用来实例化DAO：

<bean id="personDao" class="genericdao.impl.GenericDaoHibernateImpl">
    <constructor-arg>
      <value>genericdaotest.domain.Person</value>
    </constructor-arg>
    <property name="sessionFactory">
      <ref bean="sessionFactory"/>
    </property>
</bean>

可用的范型DAO

我还没有全部完成，但我现在已经有了一个可供作的代码。下面的代码展示了范型DAO如何使用：

public void someMethodCreatingAPerson() {
  ...
  GenericDao dao = (GenericDao)
   beanFactory.getBean("personDao"); // This should normally be injected

  Person p = new Person("Per", 90);
  dao.create(p);
}

这时候，我有一个范型DAO有能力进行类型安全的CRUD操作。同时也有理由编写GenericDaoHibernateImpl的子类来为每个领域对象增加查询功能。但是这篇文章的主旨在于展示如何完成这项功能而不是为每个查询编写明确的代码，然而，我将会使用多个工具来介绍DAO的查询，这就是Spring AOP和Hibernate命名查询。

Spring AOP介绍

你可以使用Spring AOP提供的introduction功能将一个现存的对象包装到一个代理里面来增加新的功能，定义它需要实现的新接口，并且将之前所有不支持的方法委派到一个处理机。在我的DAO实现里面，我用introduction将一定数量的finder方法增加到现存的范型DAO类里面。因为finder方法针对特定的领域对象，所以它们被应用到表明接口的范型DAO中。

<bean id="finderIntroductionAdvisor" class="genericdao.impl.FinderIntroductionAdvisor"/>

<bean id="abstractDaoTarget"
    class="genericdao.impl.GenericDaoHibernateImpl" abstract="true">
    <property name="sessionFactory">
      <ref bean="sessionFactory"/>
    </property>
</bean>

<bean id="abstractDao"
    class="org.springframework.aop.framework.ProxyFactoryBean" abstract="true">
    <property name="interceptorNames">
      <list>
        <value>finderIntroductionAdvisor</value>
      </list>
    </property>
</bean>

在上面的配置中，我定义了三个Spring bean，第一个bean，FinderIntroductionAdvisor，处理那些introduce到DAO中但是不属于GenericDaoHibernateImpl类的方法。一会我再介绍Advisor bean的详细情况。

第二个bean定义为“abstract”。在Spring中，这个bean可以被其他bean重用但是它自己不会被实例化。不同于抽象属性，bean的定义简单的指出了我需要一个GenericDaoHibernateImpl的实例同时需要一个SessionFactory的引用。注意GenericDaoHibernateImpl类只定义了一个构造器接受领域类作为参数。因为这个bean是抽象的，我可以无限次的重用并且设定合适的领域类。

最后，第三个，也是最有意思的是bean将GenericDaoHibernateImpl的实例包装进了一个代理，给予了它执行finder方法的能力。这个bean定义同样是抽象的并且没有指定任何接口。这个接口不同于任何具体的实例。

扩展通用DAO

每个DAO的接口，都是基于GenericDAO接口的。我需要将为特定的领域类适配接口并且将其扩展包含我的finder方法。

public interface PersonDao extends GenericDao<Person, Long> {
  List<Person> findByName(String name);
}

上面的代码清晰的展示了通过用户名查找Person对象列表。所需的Java实现类不需要包含任何的更新操作，因为这些已经包含在了通用DAO里。

配置PersonDao

因为Spring配置依赖之前的那些抽象bean，所以它变得很紧凑。我需要指定DAO负责的领域类，并且我需要告诉Spring我这个DAO需要实现的接口。

<bean id="personDao" parent="abstractDao">
  <property name="proxyInterfaces">
    <value>genericdaotest.dao.PersonDao</value>
  </property>
  <property name="target">
    <bean parent="abstractDaoTarget">
      <constructor-arg>
        <value>genericdaotest.domain.Person</value>
      </constructor-arg>
    </bean>
  </property>
</bean>

你可以这样使用：

public void someMethodCreatingAPerson() {
  ...
  PersonDao dao = (PersonDao)
   beanFactory.getBean("personDao"); // This should normally be injected

  Person p = new Person("Per", 90);
  dao.create(p);

  List<Person> result = dao.findByName("Per"); // Runtime exception
}

上面的代码是使用类型安全接口PersonDao的一种正确途径，但是DAO的实现并没有完成。当调用findByName()的时候导致了一个运行时异常。这个问题是我还没有findByName()。剩下的工作就是指定查询语句。要完成这个，我使用Hibernate命名查询。

Hibernate命名查询

使用Hibernate，你可以定义任何HQL查询在映射文件里，并且给它一个名字。你可以在之后的代码里面方便的通过名字引用这个查询。这么做的一个优点就是能够在部署的时候调节查询而不需要改变代码。正如你一会将看到的，另一个好处就是实现一个“完整”的DAO而不需要编写任何Java实现代码。

<hibernate-mapping package="genericdaotest.domain">
   <class name="Person">
     <id name="id">
       <generator class="native"/>
     </id>
     <property name="name" />
     <property name="weight" />
   </class>

   <query name="Person.findByName">
     <![CDATA[select p from Person p where p.name = ? ]]>
   </query>
</hibernate-mapping>

上面的代码定义了领域类Person的Hibernate映射文件，有两个属性：name和weight。Person是一个具有上面属性的简单的POJO。这个文件同时包含了一个查询，通过提供的name属性从数据库查找Person实例。Hibernate为命名查询提供了不真实的命名空间功能。为了便于讨论，我将所有的查询名字的前缀变成领域类的的名称。在现实场景中，使用完整的类名，包含包名，是一个更好的主意。

总览

你已经看到了为任何领域对象创建并配置DAO的所需步骤了。这三个简单的步骤就是：

  1. 定义一个接口继承GenericDao并且包含任何所需

本文地址：http://www.45fan.com/dnjc/71730.html
Tags： 函数 logging console
编辑：路饭网
  • 上一篇：在Fedora 5上安装Qte的教程
  • 下一篇：有什么样的方法能够恢复硬盘数据？
    • 相关文章列表
    推广内容
    推荐阅读
    热门推荐
    推荐文章
    关于我们 | 联系我们 | 友情链接 | 网站地图 | Sitemap | App | 返回顶部

    Copyright ©2012-2013 . 版权所有  

    路饭网|路由器设置|192.168.1.1|无线路由器设置|192.168.0.1 www.45Fan.com