Kenyth Zeng's Library tagged java → View Popular

Filter:
All
Annotated

15 Dec 09

AlBlue's Weblog: JSR294 is dead, long live OSGi!

alblue.blogspot.com/...94-is-dead-long-live-osgi.html - Preview

OSGi news JCP JSR blog modularization java

11 Dec 09

Twitter4J - A Java library for the Twitter API

yusuke.homeip.net/...index.html - Preview

twitter api java opensource

推特中文圈 | bang's blog

blog.webbang.net/863 - Preview

twitter api client-side GAE java china

通过Google AppEngine的Cron功能，每隔一定的时间抓取某一用户的好友存进数据库，存之前判断是否为使用中文的用户。只要从任意一个好友数非零的用户开始抓取，循环下去，就差不多能抓取到所有twitter上的中文用户。对已抓取的则只更新最新消息，这样就形成了“随便看看”
- Google AppEngine的数据库很差，十分差，如下：
  数据库建立后不能增加新栏不能减少栏，必须删除重建才可以。
  Key不能以数字开头，导致我每一个Key前都要增加一个字母。
  查询语句没有like也就算了，连or都没有，服了~导致制作排行榜的标签功能变得困难。
  一次最多只能查询到1000条数据。导致我不知道我已经抓取了多少条数据，排行榜上能显示的也就1000个用户。
  twitter停止source的申请，新应用只有通过OAuth验证才能有“from [myApp]”的字眼，OAuth验证需要经过twitter网站，这对于大陆用户实在不是什么好东西，没有了source，对于宣传和统计很不利。
  本地测试十分慢，是因为本地读取twitter的API十分慢，有时全部传上去在网站上看效果反倒快了，另外Google AppEngine的上传很不方便，就算我只改某一个静态js文件的一个标点，都要整站上传，Eclipse插件也没有提供只更新cron的功能，麻烦。
2 more annotations...
- JAVA写的
- 这种第三方的应用，用户提交id，密码，这个过程会不会被截获啊？安全吗？

08 Dec 09

对于学生而言，无论是应届毕业的本科、硕士，我的面试标准都差不多，考察的为Java基础、Java框架、设计模式、互联网架构的了解，当然，在最后会问一些其他的问题，例如大学学习情况呀、一两年后对自己的期望呀、优势和不足、最近看过的技术新闻等等，在这些所有的问题的背后，考察的最重要的是基础掌握的是否扎实、学习能力、反应速度、抗压能力以及技术兴趣。
第一关会是java基础的考察，在java基础的考察上通常我会考察下学生对于protected、static等等的掌握程度，在面试的过程中，几乎所有的同学都认为自己熟悉的包是集合，其他的包都谈不上熟悉，在集合包方面可以考察的点也很多，例如List、Set的区别；HashMap的实现方式等；在基础方面，线程、通信、远程调用、并发、GC等这些会成为加分项，我觉的如果学生能对这些有掌握的话就更好了。

第二关会是Java框架的考察，在这方面会考察学生对于自己认为的最熟悉的框架的掌握程度，然后会考察学生对这类框架中的核心思想的掌握情况，例如 Struts，那么就可以考察学生对于MVC思想的掌握情况，自主如何实现MVC框架；例如spring，可以考察如何自主实现一个DI框架等，这些题目其实如果学生具备很强的举一反三和反向推理的能力，基本是可以答出来的。

第三关会是设计模式的考察，这关我觉得基本已经属于加分环节了，设计模式方面可以让学生当场写一段自己最熟悉的模式的代码，例如singleton模式，有很多种写法，可以问下学生各种写法有什么不同。

第四关为互联网架构的了解状况，这关纯属加分环节，如果能够对互联网的架构有所了解的话，会非常有帮助。

重温java之classloader体系结构（含hotswap） - Java - JavaEye论坛

www.javaeye.com/136427 - Preview

classloader java thread JRebel architecture

使用线程上下文类加载器, 可以在执行线程中, 抛弃双亲委派加载链模式, 使用线程上下文里的类加载器加载类.
典型的例子有, 通过线程上下文来加载第三方库jndi实现, 而不依赖于双亲委派.

大部分java app服务器(jboss, tomcat..)也是采用contextClassLoader来处理web服务。
1 more annotations...
- 使用线程上下文加载类, 也要注意, 保证多根需要通信的线程间的类加载器应该是同一个,
  防止因为不同的类加载器, 导致类型转换异常(ClassCastException).

Carlo Bonamico’s weblog » btrace

www.carlobonamico.com/...btrace - Preview

aop java debug dev btrace blog

In a way, BTrace scripts are very similar to AOP’s aspects, but can be attached to any existing Java code (or better, bytecode) at runtime and without any configuration or modification at development time.
On the other hand, on previous JDKs it is necessary to enable tracing in a similar way to how you enable remote debugging.
1 more annotations...
- Note the use of BTrace built-in strcat function, which is needed to avoid the overhead of string concatenation.

MY(a)ware: Java ClassLoading

jalexoid.blogspot.com/...java-classloading.html - Preview

classloader java php webdev blog

For every request the PHP page is reloaded and until the release of PHP5 there wasn't the concept of Web Application as there is in JEE. The better that could be done was to do little low level unportable tricks like using memory sharing APIs. And even compiled PHP had to be reloaded every time.

22 Nov 09

java手机翻墙软件

docs.google.com/View - Preview

java GFW workaround

13 Nov 09

Apache MINA - Index

mina.apache.org/ - Preview

java opensource network Java NIO apache starred async

C, Erlang, Java , (Google) Go Web Server performance test : programming

www.reddit.com/...ogle_go_web_server_performance - Preview

c Erlang java Go performance benchmarking discussion comparison

C, Erlang, Java and Go Web Server performance test - Tim[后端技术]

timyang.net/...c-erlang-java-performance - Preview

c Erlang java Go performance benchmarking comparison discussion blog

Recommendation against Python? - Unladen Swallow | Google Groups

groups.google.com/...4edbc406f544643e - Preview

Google python java c++ performance comparison discussion

To date, IronPython and

Jython have had to dedicate a significant portion of their engineering

resources to achieving compatibility with CPython, with relatively

little time left over for performance optimization.
One area where I believe Python (and other dynamic languages) do

particularly well is projects with lots of developers working on lots

of little subsystems, all contributing to the same codebase or the

same released binary.
1 more annotations...
- Python may not be a good fit for millisecond-critical systems

06 Nov 09

Class Loading in Java: Time to Add Dynamicity? | Javalobby

java.dzone.com/...class-loading-dinamicity - Preview

JRebel hot deploy java discussion .net jvm classloader class article

But not everything can be reloaded by JavaRebel: No reloads with class hierarchy change are possible.
no schema changes are allowed.
8 more annotations...
- Our «irritating little» friend Ruby has this idea of open classes: you may change a class at runtime by adding new methods. This proves that it's possible to do ad-hoc changes.
- Dynamic languages pay a huge performance hit for the ability to update classes dynamically.
- http://classworlds.codehaus.org/
- AFAIK .NET does not reload code, it does full redeploy juts like Java, just application start usually will take less.
- In many cases if you have problems with proxies adding "-Drebel.forbid_bypass=true" will help.
- So if we could only have a jvm-server that could integrate all types of similar jar in the memory.
- They're all compiled with offsets, not labels. When you say "getTitle", the JVM knows the offset within the object structure to the "title" instance variable (if you had, say, 3 instance variables, title being the 3rd slot, all class references (vs, say, char or int),
- Most dynamic languages written on top of the JVM, for example, don't use Java Classes at all for their instances, because they're so rigid.

How JavaRebel Saves Development Time | Javalobby

java.dzone.com/...saving-time-java-development - Preview

JRebel java hot deploy classloader jvm debug dev article how-something-work starred

When debugging through my code in Eclipse, it’s nice to make a change and see that reflected in the running instance straight away with HotSwap.
I’ve often wondered why this is the case with Java when dynamic languages and .NET can handle this quickly.
8 more annotations...
- Finally, OSGi is another approach to take - by splitting your application into smaller modules, it can make the redeployment seem faster.
- With JavaRebel, it’s conceivable that I can start up my debug session and nicely interweave my code changes into the running instance, without anything unexpected happening.
- Why doesn’t this exist already in Java? And how has .NET managed to have this from day one?
- The tricky part in reloading object-oriented code is preserving the object state intact.
- However web development frameworks in .NET are designed around stateless and/or isolated classes so turnaround is usually instantaneous. However I’d assume that writing a complicated business app would run into same problem as Java at some point.
- The need to support class code, structure and layout changes would mean significant compromises in the JVM Just-In-Time compiler. Specifically you’d have to do dependency analysis between classes and make the method lookup and calls more dynamic than they currently are. This would decrease performance, or at least further complicate the design of the JVM. These compromises are already present in dynamic languages VMs, which makes it easy to implement such features there.
- We extend their APIs with an ability to inject and override classes, resources and web resources in the running web applications. We then interpret the rebel.xml file provided by the user to override the deployed classes and resources with the ones found from the project workspace.
- To reload the actual classes we build a kind of our own Just-In-Time compiler, which intercepts loading of every class and rewrites them in a way that makes reloading possible.

JRebel FAQ | ZeroTurnaround.com

www.zeroturnaround.com/faq - Preview

java hot deploy deploy classloader memory leak jvm debug dev FAQ

without having to restart the
container or redeploy the application.
It does not create any new class loaders,
instead, it
extends the existing ones with the ability to manage reloaded classes.
3 more annotations...
- The .class
  file timestamp is then
  monitored for changes in the loaded class and updates are propagated
  through the extended class loader, to your application.
- Importantly, when loading updates to a class, JRebel preserves all
  of
  the existing instances of that class. This allows the application to
  just continue working, but also means that when adding a new instance
  field it will not be initialized in the existing instances, since the
  constructor will not be rerun.
- The Instrumentation API was introduced in Java
  5 and included a limited ability to redefine Java classes on-the-fly.
  Unfortunately it is limited to only changing method bodies (as is
  HotSwap)

JRebel Feature Comparison Matrix | ZeroTurnaround.com

Hot Redeploy JVM HotSwap JRebel

www.zeroturnaround.com/...comparison - Preview

feature comparison hot deploy deploy classloader memory leak starred java jvm debug dev

05 Nov 09

Judd Solutions: The Ultimate Enterprise Java Build Solution

juddsolutions.blogspot.com/...erprise-java-build-system.html - Preview

bug scm java blog dev build-time deploy testing release architecture toread starred

04 Nov 09

Understanding Network Class Loaders

URLClassLoader

java.sun.com/...classloaders - Preview

network classloader url security article java starred introduction

The mechanism that enabled such dynamic loading is a class loader, which is one of the cornerstones of Java dynamism.
The process of combining the code into an executable native code is called linking - the merging of separately compiled code with shared library code to create an executable application.
6 more annotations...
- Any URL that ends with a '/' is assumed to refer to a directory, otherwise the URL is assumed to refer to a JAR file which will be opened as needed.
- One way to protect against such attacks is by using a security manager, which is not automatically installed when an application is running.
- prompt> java -Djava.security.manager MyLoader2
- The default security manager, however, doesn't allow your application to create its own class loader.
- Such a security policy allows you to state, using grant clauses, what sorts of actions a Java program can and cannot perform.
- A thread's context class loader is, by default, set to the context class loader of the thread's parent.